Vai al contenuto
ELECTRONICS ENGINEERINGelectronics-engineering.com
Automotive

ACC 1: funzione, requisiti ISO, macchina a stati e architettura AUTOSAR

Cosa fa un ACC con stop & go, i limiti della ISO 15622 e ISO 22179, i quattro time gap, la macchina a stati completa, i componenti AUTOSAR, le centraline, la protezione E2E e il bilancio dei tempi.

https://www.electronics-engineering.com/acc-adaptive-cruise-control-requisiti-macchina-a-stati-autosar

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

L’ACC (Adaptive Cruise Control, regolatore di velocità adattivo) mantiene la velocità scelta dal guidatore e, quando davanti c’è un veicolo più lento, lo segue a una distanza proporzionale alla velocità. Sembra semplice, ma dietro c’è una catena completa: sensori, fusione dei dati, scelta dell’obiettivo, pianificazione della manovra e controllo della coppia alle ruote. Questa è la prima di sette lezioni che costruiscono un ACC vero, dal radar al freno, con codice Python e C che funziona e che è stato provato su scenari di prova. Qui vediamo cosa deve fare la funzione, i requisiti delle norme, la macchina a stati e come si organizza il software in AUTOSAR.

Cosa fa un ACC

Il guidatore imposta una velocità v_{set} e un tempo di distanziamento h (time gap). Il sistema lavora in due modi:

  • controllo di velocità: strada libera, l’auto mantiene v_{set} come un normale cruise control;
  • inseguimento: c’è un veicolo davanti più lento, l’auto lo segue alla distanza d_{des} = d_0 + h\,v, dove d_0 è la distanza da fermi (circa 4 m) e v la nostra velocità.

Il tempo di distanziamento è il tempo che impiegheremmo a raggiungere il punto in cui si trova ora il veicolo davanti: con h = 1.8 s a 100 km/h (27.8 m/s) la distanza desiderata è 4 + 1.8 \cdot 27.8 \approx 54 m. Il guidatore lo sceglie con un tasto tra quattro valori: corto 1.0 s, medio 1.4 s, lungo 1.8 s, molto lungo 2.2 s. A ogni accensione si riparte da “lungo”.

Con il stop & go (in inglese Full Speed Range ACC) la funzione lavora fino all’arresto: si ferma dietro al veicolo davanti, tiene ferma l’auto con i freni, riparte da sola se la sosta è breve e chiede una conferma al guidatore se è lunga.

L’ACC è un sistema di assistenza, non di frenata d’emergenza: decelera al massimo di qualche m/s² e il guidatore resta responsabile. Per gli ostacoli improvvisi c’è un’altra funzione, l’AEB (frenata automatica d’emergenza), con requisiti e sensori in comune.

I requisiti delle norme

Le norme di riferimento sono la ISO 15622 (ACC) e la ISO 22179 (ACC su tutto il campo di velocità, con stop & go). Fissano limiti di comfort e di sicurezza che il software deve rispettare in ogni caso:

Grandezzaa 20 m/s e oltrea 5 m/s e sotto
accelerazione massima2.0 m/s²4.0 m/s²
decelerazione massima (media su 2 s)3.5 m/s²5.0 m/s²
strappo massimo in frenata2.5 m/s³5.0 m/s³
tempo di distanziamento minimo a regime0.8 s0.8 s

Tra 5 e 20 m/s i limiti si interpolano linearmente. La norma chiede anche che almeno una delle impostazioni del time gap sia tra 1.5 e 2.2 s (la nostra “lungo” e “molto lungo”), che il guidatore possa sempre prevalere (pedale dell’acceleratore e del freno) e che la funzione segnali quando non è in grado di gestire una situazione.

La catena funzionale

Catena dell'ACC come schema a blocchi
La catena dell’ACC come schema a blocchi: radar (RDR) e camera (CAM) danno le misure z_r, z_c; il filtro di Kalman (KF) le fonde in oggetti con stato \hat x e covarianza P; il percorso previsto (PATH) nasce da velocità di imbardata \dot\psi, velocità e linee di corsia; la selezione dell’obiettivo (TS) sceglie il veicolo da seguire; il pianificatore (PLN) calcola la richiesta di accelerazione a_{req}; il controllore di coppia (TQ) la divide tra motore (PT) e freni (ESC). Il veicolo chiude l’anello verso i sensori.

Ogni blocco ha una lezione:

  1. questa: requisiti, macchina a stati, architettura;
  2. i sensori e le configurazioni (solo camera, camera e radar, più camere e più radar);
  3. la fusione: tracciamento con il filtro di Kalman, associazione, gestione delle tracce;
  4. la selezione dell’obiettivo: percorso previsto, probabilità di essere in corsia, cut-in e falsi positivi;
  5. pianificazione e controllo longitudinale: inseguimento, stabilità della colonna, avvicinamento elastico, preboost di sorpasso, stop & go;
  6. dalla richiesta di accelerazione alla coppia alle ruote: fisica del veicolo, tre zone motore/freno, stime di pendenza e massa;
  7. l’integrazione: il sistema completo provato su scenari con criteri misurabili.

La macchina a stati della funzione

La macchina a stati decide quando l’ACC comanda davvero il veicolo. È la parte più legata alla sicurezza: un errore qui significa un’auto che frena o accelera quando il guidatore non se lo aspetta.

Macchina a stati della funzione ACC
Macchina a stati della funzione: da OFF a STANDBY con l’interruttore principale; ACTIVE con SET (velocità attuale come v_{set}) o RES; OVERRIDE quando il guidatore preme l’acceleratore oltre la soglia α; ritorno a STANDBY con freno, CANCEL o (senza stop & go) sotto v_{off}; FAULT se un sensore o l’ESC non sono più disponibili per almeno 0.2 s. In FAULT e all’uscita la richiesta torna a zero con una rampa, mai a gradino.
StatoCosa succedeUscita verso il controllo
OFFfunzione spentanessuna
STANDBYpronta, non comandarampa a 0
ACTIVEsegue v_{set} o il veicolo davantia_{req} del pianificatore
OVERRIDEil guidatore accelerasolo valori positivi: l’ACC non frena
STANDSTILLfermi dietro un veicolo (stop & go)tenuta con i freni; ripartenza automatica entro 3 s
WAITfermi da più di 3 stenuta; riparte con RES o un tocco di acceleratore
FAULTcondizione necessaria persarampa a 0 con strappo ≤ 2 m/s³, avviso al guidatore

Alcuni dettagli che fanno la differenza tra un esercizio e una funzione vera:

  • velocità impostata: con SET si prende la velocità attuale arrotondata al km/h (mai sotto 30 km/h); in ACTIVE, SET e RES la abbassano o alzano di 1 km/h;
  • debounce dei guasti: un sensore cieco per un solo ciclo non spegne la funzione, uno cieco per 0.2 s sì;
  • uscita senza gradini: quando la funzione si disattiva mentre sta frenando, la richiesta torna a zero con uno strappo limitato, così il guidatore ha il tempo di riprendere il controllo;
  • sosta lunga: dopo 180 s in WAIT il freno di stazionamento elettrico (EPB) prende il posto dei freni di servizio e la funzione va in STANDBY.

Il codice Python della macchina a stati è in acc_sim.py (classe AccStateMachine), quello C in acc.c (funzione AccSm_Run); la lezione 7 li prova uno per uno.

L’architettura AUTOSAR

Nelle auto il software delle centraline segue lo standard AUTOSAR. Nella versione Classic, usata sui microcontrollori con sistema operativo in tempo reale, il software applicativo è diviso in componenti software (SWC) che comunicano solo attraverso porte; il RTE (Run-Time Environment) collega le porte e attiva le funzioni dei componenti, chiamate runnable, a intervalli fissi o all’arrivo di un dato. Sotto ci sono i moduli di base (BSW) per la comunicazione sul bus, il sistema operativo, la diagnosi e la memoria.

Architettura AUTOSAR Classic dell'ACC
I componenti dell’ACC sopra il RTE: fusione degli oggetti, percorso previsto, selezione dell’obiettivo, pianificatore, macchina a stati, controllo longitudinale. Ogni componente ha porte di uscita (quadrati pieni) e di ingresso (vuoti); il RTE le collega e chiama i runnable ogni 10, 20 o 40 ms. Sotto: comunicazione (Com, PduR, CanIf, CanTp), protezione end-to-end (E2E), sistema operativo (Os), gestione degli errori (Dem, FiM), memoria non volatile (NvM), e i driver del microcontrollore (MCAL).

Un runnable non chiama mai direttamente un altro componente: legge e scrive attraverso il RTE. Ecco come diventa, nel nostro codice C, il runnable del controllo longitudinale (eseguito ogni 20 ms):

/* SwcLongCtrl, runnable a 20 ms (TimingEvent) */
void SwcLongCtrl_Run20ms(void)
{
    float a_req, v, a_imu, t_pt, t_br;
    boolean hold;
    Rte_Read_AccelRequest_Value(&a_req);       /* dal componente SwcAccSm */
    Rte_Read_StandstillHold_Value(&hold);
    Rte_Read_VehicleSpeed_Value(&v);           /* dall'ESC, sul CAN */
    Rte_Read_LongAccelImu_Value(&a_imu);
    LongCtrl_Run(&ctrl, a_req, v, a_imu, hold, &t_pt, &t_br);
    Rte_Write_PowertrainTorqueReq_Value(t_pt); /* verso la centralina motore */
    Rte_Write_BrakeTorqueReq_Value(t_br);      /* verso l'ESC */
}

Tutta la logica è in LongCtrl_Run, che non sa nulla di bus e di sistema operativo: si prova sul PC esattamente come gira nella centralina. È lo stesso principio di tutto il codice di queste lezioni.

Su quali centraline

Distribuzione dei componenti sulle centraline
Una distribuzione tipica: radar e camera hanno ciascuno la propria centralina, che manda liste di oggetti (ogni 50 e 66 ms); la centralina ADAS fa fusione, percorso, selezione, pianificazione e macchina a stati ogni 20 ms e manda la richiesta di accelerazione; l’ESC (o un controllore del moto del veicolo, VMC) la trasforma in coppie ogni 10 ms e comanda i freni e il motore. La richiesta di accelerazione è protetta con un CRC e un contatore (E2E).

Questa divisione ha una ragione: il controllo di coppia sta vicino agli attuatori (ESC), dove ci sono i segnali veloci delle ruote e dove già si fanno ABS ed ESP; la funzione ACC sta dove arrivano i dati dei sensori. Nei veicoli con un computer centrale potente (architettura per zone) i componenti di fusione e pianificazione girano spesso in AUTOSAR Adaptive, su Linux o un sistema simile, e parlano con il resto attraverso servizi (ara::com); il controllo di coppia resta su un microcontrollore in Classic.

Protezione dei segnali e sicurezza funzionale

Un’accelerazione richiesta sbagliata può far frenare o accelerare l’auto senza motivo: è un pericolo che la ISO 26262 classifica, a seconda dell’analisi del costruttore, tipicamente fino ad ASIL B. Per questo:

  • la richiesta viaggia con la protezione E2E (CRC sul contenuto, contatore che cambia a ogni messaggio): chi la riceve scopre messaggi corrotti, ripetuti o persi;
  • il ricevitore ha un timeout: se la richiesta non arriva per più di qualche ciclo, la funzione passa in FAULT e la richiesta torna a zero con una rampa;
  • l’ESC limita comunque la richiesta ai valori della norma (decelerazione e strappo), qualunque cosa arrivi;
  • gli errori vanno al gestore della diagnosi (Dem) e il gestore delle funzioni (FiM) disabilita l’ACC quando un sensore necessario è degradato (camera accecata, radar sporco).

Il bilancio dei tempi

Bilancio dei ritardi dal sensore alla ruota
Dal sensore alla ruota: un ciclo del radar (50 ms), il bus, fusione, selezione e pianificazione (pochi ms), la macchina a stati, di nuovo il bus, il controllo di coppia, e soprattutto il motore, con costante di tempo e tempo morto di circa 0.3 s. In tutto quasi 0.4 s tra un evento e la risposta dell’auto.

Il ritardo dominante non è il software ma l’attuatore: il motore risponde con una costante di tempo di circa 0.25 s più un tempo morto, i freni più in fretta (circa 0.12 s), ma solo dopo aver avvicinato le pastiglie al disco. Ogni ritardo nell’anello toglie margine di fase (lo abbiamo visto nella lezione sull’implementazione dei regolatori digitali) e nella lezione 5 vedremo che peggiora la stabilità della colonna di veicoli: è una delle ragioni per cui il time gap minimo è 0.8 s e non meno.

Il codice che accompagna le lezioni

Tutte le lezioni usano lo stesso codice, che funziona davvero:

  • acc_sim.py: l’intera catena in Python (solo numpy): modello del veicolo con motore, freni, vento, pendenza e carico; radar e camera; tracciatore di Kalman; percorso previsto; selezione dell’obiettivo con macchina a stati; pianificatore; controllo di coppia; macchina a stati della funzione. Ogni blocco è una classe con un metodo step(), come un runnable;
  • make_plots.py: tutti i grafici di queste lezioni, calcolati con la simulazione;
  • test_scenarios.py: 14 scenari di prova con criteri misurabili (lezione 7), tutti superati;
  • acc.h, acc.c, test_acc.c: la stessa catena in C99 come componenti AUTOSAR, compilata senza avvisi e provata su 13 scenari con gli stessi risultati della versione Python.

Scarica il codice completo (zip, 42 kB), con le istruzioni per eseguirlo.

Nella prossima lezione partiamo dal primo blocco: che cosa vedono una camera e un radar, con quale precisione, e perché le configurazioni con più sensori non servono solo a vedere più lontano.

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