Vai al contenuto
ELECTRONICS ENGINEERINGelectronics-engineering.com
Automotive

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

Nessun voto ancora: sii il primo a votare questa pagina.

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

La catena completa
La catena completa, già vista nella lezione 1: ora ogni blocco ha il suo codice, i suoi parametri e le sue prove.
BloccoLezionePython (acc_sim.py)C (acc.c)Periodo
radar, camera2radar_measure, camera_measure(nelle centraline sensore)50 / 66 ms
fusione3Tracker, Track(Kalman: come in Python)per misura
percorso previsto4PathPredictorPathPred_Run, PathPred_At20 ms
selezione dell’obiettivo4TargetSelectorTgtSel_Run20 ms
pianificatore5PlannerPlanner_Run20 ms
macchina a stati1, 5AccStateMachineAccSm_Run20 ms
controllo di coppia6TorqueController, EstimatorLongCtrl_Run20 ms (10 ms nell’ESC)
veicolo (impianto)6Vehiclecar_step nel banco di prova10 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:

  1. 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) e test_acc.c (C);
  2. HIL (hardware in the loop): la centralina vera collegata a un simulatore in tempo reale che genera i segnali dei sensori e del bus;
  3. prove su pista con bersagli mobili (anche i sistemi di prova della ISO 15622 e di Euro NCAP);
  4. 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

ScenarioCriterioRisultatoEsito
velocità libera, da 100 a 120 km/herrore di velocità negli ultimi 5 s < 1 km/h0.02 km/hsuperato
avvicinamento da 130 a 80 km/h, 200 mdecelerazione massima < 2 m/s²0.75 m/s²superato
avvicinamento da 130 a 80 km/h, 200 merrore di distanza dopo 60 s < 5%0.40%superato
l’obiettivo frena a −4 m/s² fino a fermarsidistanza minima > 2 m3.90 msuperato
cut-in a 50 m, 12 km/h più lento (catena completa)distanza minima > 15 m33.5 msuperato
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 scicli senza obiettivo = 00superato
auto nella corsia accanto all’ingresso di una curva, linee scarsetempo come falso obiettivo = 00 ssuperato
stop & go in salita del 4%distanza di arresto 4 ± 0.5 m3.93 msuperato
stop & go in salita del 4%arretramento < 0.1 km/h0.00 km/hsuperato
stop & go in salita del 4%WAIT, poi RES, poi ACTIVEsìsuperato
carico, salita 6%, vento contrario, freni debolierrore di velocità < 2 km/h0.36 km/hsuperato
zona intermedia con richiesta rumorosacambi tra motore e freni ≤ 44superato
guasto di un sensore durante una frenatastrappo 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 PASS

Si 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

ParametroValoreDovePerché
time gap1.0 / 1.4 / 1.8 / 2.2 smacchina a statiquattro impostazioni, la norma chiede ≥ 0.8 e una tra 1.5 e 2.2
d_04 mpianificatoredistanza da fermi
k_d, k_v, k_a0.15, 0.6 (o più), 0.3pianificatoresmorzamento > 1, stabilità della colonna k_d h^2 + 2k_v h \ge 2
elasticità \delta0.25 h v, al massimo 12 mpianificatorefrenata più dolce nell’avvicinamento
preboost0.9 s, +0.6 m/s², 4 spianificatoresorpasso più fluido, mai sotto 0.9 s
p_{in}, p_{out}0.60, 0.35selezioneisteresi
\tau_c0.3 + 0.25 \sigma_p sselezioneconferma più lunga se il percorso è incerto
\tau_h0.6 sselezioneperdita breve delle misure
q_x, q_y2.0, 1.5 m/s²fusionemanovre reali (cambio di corsia)
fascia della zona C± 0.08 m/s²coppiacirca la coppia frenante minima utile
tempo minimo in una zona0.3 scoppianiente oscillazioni motore/freni
k_p, k_i0.6, 1.2coppiacorrezione 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’è.

Iscriviti
Notificami
guest
0 commenti
Vecchi
Più recenti Le più votate
0
Esprimete la vostra opinione commentando.x