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
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à
e un tempo di distanziamento
(time gap). Il sistema lavora in due modi:
- controllo di velocità: strada libera, l’auto mantiene
come un normale cruise control; - inseguimento: c’è un veicolo davanti più lento, l’auto lo segue alla distanza
, dove
è la distanza da fermi (circa 4 m) e
la nostra velocità.
Il tempo di distanziamento è il tempo che impiegheremmo a raggiungere il punto in cui si trova ora il veicolo davanti: con
s a 100 km/h (27.8 m/s) la distanza desiderata è
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:
| Grandezza | a 20 m/s e oltre | a 5 m/s e sotto |
|---|---|---|
| accelerazione massima | 2.0 m/s² | 4.0 m/s² |
| decelerazione massima (media su 2 s) | 3.5 m/s² | 5.0 m/s² |
| strappo massimo in frenata | 2.5 m/s³ | 5.0 m/s³ |
| tempo di distanziamento minimo a regime | 0.8 s | 0.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

,
; il filtro di Kalman (KF) le fonde in oggetti con stato
e covarianza
; il percorso previsto (PATH) nasce da velocità di imbardata
, velocità e linee di corsia; la selezione dell’obiettivo (TS) sceglie il veicolo da seguire; il pianificatore (PLN) calcola la richiesta di accelerazione
; 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:
- questa: requisiti, macchina a stati, architettura;
- i sensori e le configurazioni (solo camera, camera e radar, più camere e più radar);
- la fusione: tracciamento con il filtro di Kalman, associazione, gestione delle tracce;
- la selezione dell’obiettivo: percorso previsto, probabilità di essere in corsia, cut-in e falsi positivi;
- pianificazione e controllo longitudinale: inseguimento, stabilità della colonna, avvicinamento elastico, preboost di sorpasso, stop & go;
- dalla richiesta di accelerazione alla coppia alle ruote: fisica del veicolo, tre zone motore/freno, stime di pendenza e massa;
- 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.

) o RES; OVERRIDE quando il guidatore preme l’acceleratore oltre la soglia α; ritorno a STANDBY con freno, CANCEL o (senza stop & go) sotto
; 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.| Stato | Cosa succede | Uscita verso il controllo |
|---|---|---|
| OFF | funzione spenta | nessuna |
| STANDBY | pronta, non comanda | rampa a 0 |
| ACTIVE | segue | |
| OVERRIDE | il guidatore accelera | solo valori positivi: l’ACC non frena |
| STANDSTILL | fermi dietro un veicolo (stop & go) | tenuta con i freni; ripartenza automatica entro 3 s |
| WAIT | fermi da più di 3 s | tenuta; riparte con RES o un tocco di acceleratore |
| FAULT | condizione necessaria persa | rampa 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.

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

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

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 metodostep(), 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.





