ACC 7: integrazione, 14 scenari di prova e codice Python e C
Il sistema completo, come si prova una funzione di assistenza, il catalogo degli scenari con criteri misurabili, gli errori trovati, la versione C99 con gli stessi risultati e il codice da scaricare.
https://www.electronics-engineering.com/acc-integrazione-scenari-di-prova-codice-python-c
Nelle lezioni precedenti abbiamo costruito ogni blocco dell’ACC, dalla misura del radar alla coppia sui freni. Un blocco che funziona da solo, però, non dice ancora niente: gli errori veri nascono nelle interazioni, quando un tracciatore troppo sicuro scarta la camera, quando un integrale si carica durante un cambio di zona, quando la macchina a stati prende un rallentamento per un arresto. Tutti questi li abbiamo trovati proprio mettendo insieme i pezzi e provandoli. In questa lezione vediamo il sistema completo, come si prova, e i risultati: 14 scenari in Python e 13 in C, tutti superati con criteri misurabili.
Il sistema completo

| Blocco | Lezione | Python (acc_sim.py) | C (acc.c) | Periodo |
|---|---|---|---|---|
| radar, camera | 2 | radar_measure, camera_measure | (nelle centraline sensore) | 50 / 66 ms |
| fusione | 3 | Tracker, Track | (Kalman: come in Python) | per misura |
| percorso previsto | 4 | PathPredictor | PathPred_Run, PathPred_At | 20 ms |
| selezione dell’obiettivo | 4 | TargetSelector | TgtSel_Run | 20 ms |
| pianificatore | 5 | Planner | Planner_Run | 20 ms |
| macchina a stati | 1, 5 | AccStateMachine | AccSm_Run | 20 ms |
| controllo di coppia | 6 | TorqueController, Estimator | LongCtrl_Run | 20 ms (10 ms nell’ESC) |
| veicolo (impianto) | 6 | Vehicle | car_step nel banco di prova | 10 ms |
Il ciclo principale della simulazione ha la stessa forma di un’esecuzione in centralina: ogni blocco gira al suo ritmo e passa al successivo solo le sue uscite.
for k in range(int(T / veh.dt)): # vehicle and sensors at 10 ms
t = k * veh.dt
tk.predict_to(t, veh.a)
if k % 5 == 0: # radar, 20 Hz
zs = [A.radar_to_cartesian(rp, m) for (x, y, v) in objs if (m := A.radar_measure(rp, rng, x - veh.x, y, v - veh.v))]
if zs:
tk.update(zs, A.H_RADAR, A.GATE_3D)
if k % 7 == 3: # camera, about 15 Hz
zs = [m for (x, y, v) in objs if (m := A.camera_measure(cp, rng, x - veh.x, y))]
if zs:
tk.update(zs, A.H_CAMERA, A.GATE_2D, init=False)
if k % 2 == 0: # ADAS runnables, 20 ms
tgt = ts.step(tk.tracks, pp.predict(veh.v, yaw_rate, lane), veh.v, 0.02, t)
a_pl = pl.step(veh.v, (tgt.s[0], veh.v + tgt.s[1], 0.0) if tgt is not None else None)
a_req = sm.step(driver, veh.v, a_pl, sensors_ok, t, pl.stop_request)
t_pt, t_br, _ = tq.step(a_req, veh.v, veh.a_imu, hold=sm.hold)
veh.step(t_pt, t_br, grade, wind)Come si prova una funzione così
Una funzione di assistenza si prova a livelli, e il codice di queste lezioni è pronto per i primi due:
- SIL (software in the loop): il codice vero, come gira in centralina, con un modello del veicolo e dei sensori sul PC. È quello che fanno
test_scenarios.py(Python) etest_acc.c(C); - HIL (hardware in the loop): la centralina vera collegata a un simulatore in tempo reale che genera i segnali dei sensori e del bus;
- prove su pista con bersagli mobili (anche i sistemi di prova della ISO 15622 e di Euro NCAP);
- prove su strada con migliaia di chilometri registrati, rigiocati poi in simulazione (re-simulazione) a ogni nuova versione del software.
La regola che rende utile tutto questo: ogni scenario ha un criterio misurabile, deciso prima di guardare il risultato. “L’avvicinamento sembra buono” non è una prova; “decelerazione massima sotto 2 m/s² ed errore di distanza sotto il 5% dopo 60 s” sì.
Il catalogo degli scenari
| Scenario | Criterio | Risultato | Esito |
|---|---|---|---|
| velocità libera, da 100 a 120 km/h | errore di velocità negli ultimi 5 s < 1 km/h | 0.02 km/h | superato |
| avvicinamento da 130 a 80 km/h, 200 m | decelerazione massima < 2 m/s² | 0.75 m/s² | superato |
| avvicinamento da 130 a 80 km/h, 200 m | errore di distanza dopo 60 s < 5% | 0.40% | superato |
| l’obiettivo frena a −4 m/s² fino a fermarsi | distanza minima > 2 m | 3.90 m | superato |
| cut-in a 50 m, 12 km/h più lento (catena completa) | distanza minima > 15 m | 33.5 m | superato |
| cut-in a 50 m (catena completa) | decelerazione massima < 3.6 m/s² | 3.07 m/s² | superato |
| perdita delle misure radar per 0.4 s | cicli senza obiettivo = 0 | 0 | superato |
| auto nella corsia accanto all’ingresso di una curva, linee scarse | tempo come falso obiettivo = 0 | 0 s | superato |
| stop & go in salita del 4% | distanza di arresto 4 ± 0.5 m | 3.93 m | superato |
| stop & go in salita del 4% | arretramento < 0.1 km/h | 0.00 km/h | superato |
| stop & go in salita del 4% | WAIT, poi RES, poi ACTIVE | sì | superato |
| carico, salita 6%, vento contrario, freni deboli | errore di velocità < 2 km/h | 0.36 km/h | superato |
| zona intermedia con richiesta rumorosa | cambi tra motore e freni ≤ 4 | 4 | superato |
| guasto di un sensore durante una frenata | strappo della richiesta ≤ 2 m/s³ | 2.00 m/s³ | superato |
I criteri non sono scelti a caso: la decelerazione e lo strappo vengono dalla norma (lezione 1), le distanze dalla sicurezza, il falso positivo e la perdita di misure dalle situazioni che rovinano la fiducia del guidatore, i cambi di zona dal comfort.
Quasi ogni riga di questa tabella ha avuto, durante lo sviluppo, un primo risultato sbagliato, e ognuno ha insegnato qualcosa:
- la fusione peggiore della sola camera (rumore di processo troppo piccolo, lezione 3);
- l’avvicinamento “elastico” che frenava più di quello normale (la fase dolce poteva frenare più del necessario, lezione 5);
- l’arresto a 15 m invece di 4 (la macchina a stati scambiava un rallentamento per un arresto, e il pianificatore copiava la frenata dell’obiettivo invece di puntare al suo punto di arresto, lezione 5);
- la frenata a −3.9 m/s² invece di −3 (integrale caricato durante il tempo di attesa del cambio di zona, lezione 6);
- l’arretramento in salita (i freni si aprivano nella zona di veleggiamento a velocità quasi nulla, lezione 6);
- il time gap corto che rendeva instabile la colonna (guadagni fissi, lezione 5).
È il motivo per cui le prove automatiche contano più di qualsiasi revisione a occhio.
La stessa catena in C
La versione C99 (acc.h, acc.c) è scritta come componenti AUTOSAR: ogni componente ha una funzione di inizializzazione e un runnable con ingressi e uscite espliciti, nessuna memoria dinamica, nessuna ricorsione, solo float. Il banco di prova test_acc.c contiene un modello del veicolo (motore con tempo morto e ritardo, freni con molle e gioco delle pastiglie, attrito statico da fermi) e 13 scenari:
Approach 130 -> 80 km/h peak deceleration [m/s2] 0.74 PASS
Approach 130 -> 80 km/h gap error after 60 s [%] 0.52 PASS
Stop & go, 4 % climb stops 2.00 PASS
Stop & go, 4 % climb 1st stop distance (d0 = 4) [m] 3.94 PASS
Stop & go, 4 % climb 2nd stop distance (d0 = 4) [m] 3.95 PASS
Stop & go, 4 % climb rollback speed [km/h] -0.00 PASS
Stop & go, 4 % climb WAIT then RES -> ACTIVE 1.00 PASS
Cut-in, lateral speed 1 m/s locked at t [s] (python 3.9) 3.90 PASS
Next-lane car at 95 m, no lines time locked [s] 0.00 PASS
Coast zone, noisy request zone changes (4 needed) 4.00 PASS
Coast zone, noisy request max |a - a_req| [m/s2] 0.09 PASS
Payload 350 kg + 6 % climb max speed error [km/h] 0.36 PASS
Sensor fault while braking jerk of the request [m/s3] 2.00 PASS
13/13 PASSSi compila senza un solo avviso con gcc -std=c99 -O2 -Wall -Wextra -Wpedantic -o test_acc acc.c test_acc.c -lm. I risultati coincidono con quelli Python (arresti a 3.94 e 3.95 m contro 3.93 e 3.94, cut-in agganciato a 3.90 s contro 3.92, errore di velocità 0.36 km/h in entrambi): due implementazioni indipendenti dello stesso algoritmo che danno gli stessi numeri sono una prova forte che entrambe fanno quello che dice la teoria.
I parametri
| Parametro | Valore | Dove | Perché |
|---|---|---|---|
| time gap | 1.0 / 1.4 / 1.8 / 2.2 s | macchina a stati | quattro impostazioni, la norma chiede ≥ 0.8 e una tra 1.5 e 2.2 |
| 4 m | pianificatore | distanza da fermi | |
| 0.15, 0.6 (o più), 0.3 | pianificatore | smorzamento > 1, stabilità della colonna | |
| elasticità | 0.25 h v, al massimo 12 m | pianificatore | frenata più dolce nell’avvicinamento |
| preboost | 0.9 s, +0.6 m/s², 4 s | pianificatore | sorpasso più fluido, mai sotto 0.9 s |
| 0.60, 0.35 | selezione | isteresi | |
| 0.3 + 0.25 | selezione | conferma più lunga se il percorso è incerto | |
| 0.6 s | selezione | perdita breve delle misure | |
| 2.0, 1.5 m/s² | fusione | manovre reali (cambio di corsia) | |
| fascia della zona C | ± 0.08 m/s² | coppia | circa la coppia frenante minima utile |
| tempo minimo in una zona | 0.3 s | coppia | niente oscillazioni motore/freni |
| 0.6, 1.2 | coppia | correzione degli errori di modello |
Dove sta questa materia
Le sette lezioni stanno nella materia Automotive, con il loro programma; usano strumenti di altre materie, ai quali rimandano dove servono:
- Controlli automatici: stabilità, risposta del secondo ordine, PID e anti-windup (lezioni 5 e 6);
- Controlli digitali: filtro di Kalman, osservatori, discretizzazione, ritardo di calcolo, controllo ottimo e predittivo (lezioni 1, 3, 5);
- Comunicazioni elettriche e Campi elettromagnetici: il radar FMCW (lezione 2);
- Fisica 1: dinamica, piano inclinato, rotazione (lezione 6);
- Calcolo numerico e Metodi matematici: minimi quadrati, gaussiana e probabilità (lezioni 3, 4, 6).
Dove andare da qui
Il codice è un punto di partenza vero, ma un ACC di serie richiede ancora:
- taratura sul veicolo: i parametri del motore, dei freni e delle tabelle di comfort si misurano sull’auto, non si inventano;
- più modelli di moto nel tracciatore (IMM) e associazione probabilistica nel traffico denso;
- la corsia accanto per il preboost, dai radar d’angolo, e la previsione delle traiettorie degli altri veicoli;
- la sicurezza funzionale: analisi dei rischi (ISO 26262), monitor indipendenti delle richieste, prove di iniezione dei guasti;
- le prove di omologazione e di Euro NCAP, che usano scenari molto simili a quelli della tabella.
Scarica il codice completo (zip, 42 kB): acc_sim.py, make_plots.py, test_scenarios.py, acc.h, acc.c, test_acc.c e le istruzioni. Serve Python 3.8 o più recente con numpy (matplotlib per i grafici) e un compilatore C99.
Il codice è pensato per essere letto, cambiato e rieseguito: cambiate un parametro, rilanciate le prove e guardate quale criterio smette di essere rispettato. È il modo più rapido per capire perché ogni dettaglio delle lezioni precedenti c’è.





