Aller au contenu
ELECTRONICS ENGINEERINGelectronics-engineering.com
Automobile

ACC 1 : fonction, exigences ISO, machine à états et architecture AUTOSAR

Ce que fait un ACC avec stop & go, les limites de l'ISO 15622 et de l'ISO 22179, les quatre temps inter-véhiculaires, la machine à états complète, les composants AUTOSAR, les calculateurs, la protection E2E et le budget de temps.

https://www.electronics-engineering.com/fr/acc-regulateur-adaptatif-exigences-machine-a-etats-autosar/

Pas encore de vote : soyez le premier à noter cette page.

L’ACC (Adaptive Cruise Control, régulateur de vitesse adaptatif) maintient la vitesse choisie par le conducteur et, lorsqu’un véhicule plus lent se trouve devant, le suit à une distance proportionnelle à la vitesse. Cela paraît simple, mais derrière il y a une chaîne complète : capteurs, fusion des données, choix de la cible, planification de la manœuvre et contrôle du couple aux roues. C’est la première de sept leçons qui construisent un vrai ACC, du radar aux freins, avec du code Python et C qui fonctionne et qui a été testé sur des scénarios d’essai. Ici nous voyons ce que la fonction doit faire, les exigences des normes, la machine à états et l’organisation du logiciel dans AUTOSAR.

Ce que fait un ACC

Le conducteur règle une vitesse v_{set} et un temps inter-véhiculaire h (time gap). Le système fonctionne de deux façons :

  • régulation de vitesse : route libre, la voiture tient v_{set} comme un régulateur classique ;
  • suivi : un véhicule plus lent est devant, la voiture le suit à la distance d_{des} = d_0 + h\,v, où d_0 est la distance à l’arrêt (environ 4 m) et v notre vitesse.

Le temps inter-véhiculaire est le temps qu’il nous faudrait pour atteindre le point où se trouve maintenant le véhicule de devant : avec h = 1.8 s à 100 km/h (27,8 m/s) la distance souhaitée est 4 + 1.8 \cdot 27.8 \approx 54 m. Le conducteur le choisit avec un bouton parmi quatre valeurs : court 1,0 s, moyen 1,4 s, long 1,8 s, très long 2,2 s. À chaque démarrage on repart de « long ».

Avec le stop & go (Full Speed Range ACC) la fonction travaille jusqu’à l’arrêt : elle s’arrête derrière le véhicule de devant, maintient la voiture avec les freins, redémarre seule après un arrêt court et demande une confirmation au conducteur après un arrêt long.

L’ACC est un système d’aide, pas un freinage d’urgence : il décélère de quelques m/s² au maximum et le conducteur reste responsable. Les obstacles soudains relèvent d’une autre fonction, l’AEB (freinage automatique d’urgence), qui partage exigences et capteurs.

Les exigences des normes

Les normes de référence sont l’ISO 15622 (ACC) et l’ISO 22179 (ACC sur toute la plage de vitesse, avec stop & go). Elles fixent des limites de confort et de sécurité que le logiciel doit respecter dans tous les cas :

Grandeurà 20 m/s et au-delàà 5 m/s et en dessous
accélération maximale2,0 m/s²4,0 m/s²
décélération maximale (moyenne sur 2 s)3,5 m/s²5,0 m/s²
à-coup maximal au freinage2,5 m/s³5,0 m/s³
temps inter-véhiculaire minimal en régime établi0,8 s0,8 s

Entre 5 et 20 m/s les limites sont interpolées linéairement. La norme demande aussi qu’au moins un réglage du temps inter-véhiculaire soit entre 1,5 et 2,2 s (nos « long » et « très long »), que le conducteur puisse toujours reprendre la main (pédale d’accélérateur et de frein) et que la fonction signale quand elle ne peut pas gérer une situation.

La chaîne fonctionnelle

Chaîne de l'ACC en schéma-blocs
La chaîne de l’ACC en schéma-blocs : radar (RDR) et caméra (CAM) donnent les mesures z_r, z_c ; le filtre de Kalman (KF) les fusionne en objets d’état \hat x et de covariance P ; la trajectoire prévue (PATH) vient de la vitesse de lacet \dot\psi, de la vitesse et des lignes de voie ; la sélection de la cible (TS) choisit le véhicule à suivre ; le planificateur (PLN) calcule la demande d’accélération a_{req} ; le contrôle de couple (TQ) la répartit entre groupe motopropulseur (PT) et freins (ESC). Le véhicule referme la boucle vers les capteurs.

Chaque bloc a sa leçon :

  1. celle-ci : exigences, machine à états, architecture ;
  2. les capteurs et les configurations (caméra seule, caméra et radar, plusieurs caméras et plusieurs radars) ;
  3. la fusion : pistage avec le filtre de Kalman, association, gestion des pistes ;
  4. la sélection de la cible : trajectoire prévue, probabilité d’être dans la voie, insertions (cut-in) et faux positifs ;
  5. planification et contrôle longitudinal : suivi, stabilité de la file, approche élastique, preboost de dépassement, stop & go ;
  6. de la demande d’accélération au couple aux roues : physique du véhicule, trois zones moteur/freins, estimation de la pente et de la masse ;
  7. l’intégration : le système complet testé sur des scénarios avec des critères mesurables.

La machine à états de la fonction

La machine à états décide quand l’ACC commande vraiment le véhicule. C’est la partie la plus liée à la sécurité : une erreur ici signifie une voiture qui freine ou accélère quand le conducteur ne s’y attend pas.

Machine à états de la fonction ACC
Machine à états de la fonction : de OFF à STANDBY avec l’interrupteur principal ; ACTIVE avec SET (vitesse actuelle comme v_{set}) ou RES ; OVERRIDE quand le conducteur appuie sur l’accélérateur au-delà du seuil α ; retour à STANDBY avec le frein, CANCEL ou (sans stop & go) en dessous de v_{off} ; FAULT si un capteur ou l’ESC ne sont plus disponibles pendant au moins 0,2 s. En FAULT et à la sortie la demande revient à zéro par une rampe, jamais par un échelon.
ÉtatCe qui se passeSortie vers le contrôle
OFFfonction éteinteaucune
STANDBYprête, ne commande pasrampe vers 0
ACTIVEtient v_{set} ou suit le véhicule de devanta_{req} du planificateur
OVERRIDEle conducteur accélèrevaleurs positives seulement : l’ACC ne freine pas
STANDSTILLarrêté derrière un véhicule (stop & go)maintien par les freins ; redémarrage automatique dans les 3 s
WAITarrêté depuis plus de 3 smaintien ; redémarre avec RES ou une pression sur l’accélérateur
FAULTune condition nécessaire est perduerampe vers 0 avec à-coup ≤ 2 m/s³, alerte au conducteur

Quelques détails font la différence entre un exercice et une vraie fonction :

  • vitesse réglée : SET prend la vitesse actuelle arrondie au km/h (jamais moins de 30 km/h) ; en ACTIVE, SET et RES la baissent ou l’augmentent de 1 km/h ;
  • filtrage des défauts : un capteur aveugle pendant un seul cycle n’éteint pas la fonction, un capteur aveugle pendant 0,2 s oui ;
  • sortie sans échelon : quand la fonction se désactive pendant un freinage, la demande revient à zéro avec un à-coup limité, pour que le conducteur ait le temps de reprendre la main ;
  • arrêt long : après 180 s en WAIT le frein de stationnement électrique (EPB) remplace les freins de service et la fonction passe en STANDBY.

Le code Python de la machine à états est dans acc_sim.py (classe AccStateMachine), le code C dans acc.c (fonction AccSm_Run) ; la leçon 7 les teste un par un.

L’architecture AUTOSAR

Dans les voitures, le logiciel des calculateurs suit la norme AUTOSAR. Dans la plateforme Classic, utilisée sur les microcontrôleurs avec un système d’exploitation temps réel, le logiciel applicatif est divisé en composants logiciels (SWC) qui communiquent uniquement par des ports ; le RTE (Run-Time Environment) relie les ports et déclenche les fonctions des composants, appelées runnables, à intervalles fixes ou à l’arrivée d’une donnée. En dessous se trouvent les modules de base (BSW) pour la communication sur le bus, le système d’exploitation, le diagnostic et la mémoire.

Architecture AUTOSAR Classic de l'ACC
Les composants de l’ACC au-dessus du RTE : fusion des objets, trajectoire prévue, sélection de la cible, planificateur, machine à états, contrôle longitudinal. Chaque composant a des ports de sortie (carrés pleins) et d’entrée (vides) ; le RTE les relie et appelle les runnables toutes les 10, 20 ou 40 ms. En dessous : communication (Com, PduR, CanIf, CanTp), protection de bout en bout (E2E), système d’exploitation (Os), gestion des erreurs (Dem, FiM), mémoire non volatile (NvM), et les pilotes du microcontrôleur (MCAL).

Un runnable n’appelle jamais directement un autre composant : il lit et écrit à travers le RTE. Voici le runnable du contrôle longitudinal (exécuté toutes les 20 ms) dans notre code C :

/* SwcLongCtrl, runnable at 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);       /* from component SwcAccSm */
    Rte_Read_StandstillHold_Value(&hold);
    Rte_Read_VehicleSpeed_Value(&v);           /* from the ESC, on 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); /* to the engine ECU */
    Rte_Write_BrakeTorqueReq_Value(t_br);      /* to the ESC */
}

Toute la logique est dans LongCtrl_Run, qui ne sait rien des bus ni du système d’exploitation : on la teste sur un PC exactement comme elle tourne dans le calculateur. Le même principe s’applique à tout le code de ces leçons.

Sur quels calculateurs

Répartition des composants sur les calculateurs
Une répartition typique : radar et caméra ont chacun leur calculateur, qui envoie des listes d’objets (toutes les 50 et 66 ms) ; le calculateur ADAS fait fusion, trajectoire, sélection, planification et machine à états toutes les 20 ms et envoie la demande d’accélération ; l’ESC (ou un contrôleur du mouvement du véhicule, VMC) la transforme en couples toutes les 10 ms et commande freins et moteur. La demande d’accélération est protégée par un CRC et un compteur (E2E).

Cette répartition a une raison : le contrôle de couple est proche des actionneurs (ESC), là où se trouvent les signaux rapides des roues et où tournent déjà l’ABS et l’ESP ; la fonction ACC est là où arrivent les données des capteurs. Dans les véhicules avec un ordinateur central puissant (architecture par zones), fusion et planification tournent souvent sous AUTOSAR Adaptive, sur Linux ou un système similaire, et dialoguent avec le reste par des services (ara::com) ; le contrôle de couple reste sur un microcontrôleur en Classic.

Protection des signaux et sécurité fonctionnelle

Une demande d’accélération erronée peut faire freiner ou accélérer la voiture sans raison : c’est un danger que l’ISO 26262 classe, selon l’analyse du constructeur, typiquement jusqu’à ASIL B. C’est pourquoi :

  • la demande circule avec la protection E2E (CRC sur le contenu, compteur qui change à chaque message) : le récepteur détecte les messages corrompus, répétés ou perdus ;
  • le récepteur a un délai d’attente : si la demande n’arrive pas pendant plus de quelques cycles, la fonction passe en FAULT et la demande revient à zéro par une rampe ;
  • l’ESC limite de toute façon la demande aux valeurs de la norme (décélération et à-coup), quoi qu’il arrive ;
  • les erreurs vont au gestionnaire du diagnostic (Dem) et le gestionnaire des inhibitions (FiM) désactive l’ACC quand un capteur nécessaire est dégradé (caméra éblouie, radar sale).

Le budget de temps

Budget des retards du capteur à la roue
Du capteur à la roue : un cycle du radar (50 ms), le bus, fusion, sélection et planification (quelques ms), la machine à états, de nouveau le bus, le contrôle de couple, et surtout le moteur, avec une constante de temps et un temps mort d’environ 0,3 s. Au total presque 0,4 s entre un événement et la réponse de la voiture.

Le retard dominant n’est pas le logiciel mais l’actionneur : le moteur répond avec une constante de temps d’environ 0,25 s plus un temps mort, les freins plus vite (environ 0,12 s), mais seulement après avoir rapproché les plaquettes du disque. Chaque retard dans la boucle enlève de la marge de phase (nous l’avons vu dans la leçon sur l’implémentation des régulateurs numériques) et dans la leçon 5 nous verrons qu’il dégrade la stabilité d’une file de véhicules : c’est l’une des raisons pour lesquelles le temps inter-véhiculaire minimal est de 0,8 s et pas moins.

Le code qui accompagne les leçons

Toutes les leçons utilisent le même code, qui fonctionne vraiment :

  • acc_sim.py : toute la chaîne en Python (numpy seulement) : modèle du véhicule avec moteur, freins, vent, pente et charge ; radar et caméra ; pisteur de Kalman ; trajectoire prévue ; sélection de la cible avec machine à états ; planificateur ; contrôle de couple ; machine à états de la fonction. Chaque bloc est une classe avec une méthode step(), comme un runnable ;
  • make_plots.py : tous les graphiques de ces leçons, calculés avec la simulation ;
  • test_scenarios.py : 14 scénarios d’essai avec des critères mesurables (leçon 7), tous réussis ;
  • acc.h, acc.c, test_acc.c : la même chaîne en C99 sous forme de composants AUTOSAR, compilée sans avertissement et testée sur 13 scénarios avec les mêmes résultats que la version Python.

Télécharger le code complet (zip, 42 ko), avec les instructions pour l’exécuter.

Dans la prochaine leçon nous partons du premier bloc : ce que voient une caméra et un radar, avec quelle précision, et pourquoi les configurations à plusieurs capteurs ne servent pas seulement à voir plus loin.

S’abonner
Notifier de
guest
0 commentaires
Le plus ancien
Plus récent Les plus votés
0
Vous avez apprécié cet article ? Merci de laisser un commentaire.x