ACC 7 : intégration, 14 scénarios de test et code Python et C
Le système complet, comment on teste une fonction d'aide à la conduite, le catalogue des scénarios avec des critères mesurables, les erreurs trouvées, la version C99 aux mêmes résultats et le code à télécharger.
https://www.electronics-engineering.com/fr/acc-integration-scenarios-de-test-code-python-c/
Dans les leçons précédentes nous avons construit chaque bloc de l’ACC, de la mesure du radar au couple sur les freins. Un bloc qui fonctionne seul, pourtant, ne prouve encore rien : les vraies erreurs naissent des interactions, quand un pisteur trop sûr de lui rejette la caméra, quand une intégrale se charge pendant un changement de zone, quand la machine à états prend un ralentissement pour un arrêt. Nous les avons toutes trouvées justement en assemblant les pièces et en les testant. Dans cette leçon nous voyons le système complet, comment on le teste, et les résultats : 14 scénarios en Python et 13 en C, tous réussis avec des critères mesurables.
Le système complet

| Bloc | Leçon | Python (acc_sim.py) | C (acc.c) | Période |
|---|---|---|---|---|
| radar, caméra | 2 | radar_measure, camera_measure | (dans les calculateurs capteurs) | 50 / 66 ms |
| fusion | 3 | Tracker, Track | (Kalman : comme en Python) | à chaque mesure |
| trajectoire prévue | 4 | PathPredictor | PathPred_Run, PathPred_At | 20 ms |
| sélection de la cible | 4 | TargetSelector | TgtSel_Run | 20 ms |
| planificateur | 5 | Planner | Planner_Run | 20 ms |
| machine à états | 1, 5 | AccStateMachine | AccSm_Run | 20 ms |
| contrôle de couple | 6 | TorqueController, Estimator | LongCtrl_Run | 20 ms (10 ms dans l’ESC) |
| véhicule (procédé) | 6 | Vehicle | car_step dans le banc d’essai | 10 ms |
La boucle principale de la simulation a la même forme qu’une exécution dans le calculateur : chaque bloc tourne à son rythme et ne passe au suivant que ses sorties.
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)Comment on teste une telle fonction
Une fonction d’aide à la conduite se teste à plusieurs niveaux, et le code de ces leçons est prêt pour les deux premiers :
- SIL (software in the loop) : le vrai code, tel qu’il tourne dans le calculateur, avec un modèle du véhicule et des capteurs sur un PC. C’est ce que font
test_scenarios.py(Python) ettest_acc.c(C) ; - HIL (hardware in the loop) : le vrai calculateur relié à un simulateur temps réel qui génère les signaux des capteurs et du bus ;
- essais sur piste avec des cibles mobiles (y compris les procédures d’essai de l’ISO 15622 et d’Euro NCAP) ;
- essais sur route avec des milliers de kilomètres enregistrés, rejoués ensuite en simulation (re-simulation) à chaque nouvelle version du logiciel.
La règle qui rend tout cela utile : chaque scénario a un critère mesurable, décidé avant de regarder le résultat. « L’approche a l’air bien » n’est pas un test ; « décélération maximale sous 2 m/s² et erreur de distance sous 5 % après 60 s » en est un.
Le catalogue des scénarios
| Scénario | Critère | Résultat | Issue |
|---|---|---|---|
| vitesse libre, de 100 à 120 km/h | erreur de vitesse dans les 5 dernières s < 1 km/h | 0,02 km/h | réussi |
| approche de 130 à 80 km/h, 200 m | décélération maximale < 2 m/s² | 0,75 m/s² | réussi |
| approche de 130 à 80 km/h, 200 m | erreur de distance après 60 s < 5 % | 0,40 % | réussi |
| la cible freine à −4 m/s² jusqu’à l’arrêt | distance minimale > 2 m | 3,90 m | réussi |
| insertion à 50 m, 12 km/h plus lente (chaîne complète) | distance minimale > 15 m | 33,5 m | réussi |
| insertion à 50 m (chaîne complète) | décélération maximale < 3,6 m/s² | 3,07 m/s² | réussi |
| perte des mesures radar pendant 0,4 s | cycles sans cible = 0 | 0 | réussi |
| voiture dans la voie voisine à l’entrée d’un virage, lignes médiocres | temps comme fausse cible = 0 | 0 s | réussi |
| stop & go en côte de 4 % | distance d’arrêt 4 ± 0,5 m | 3,93 m | réussi |
| stop & go en côte de 4 % | recul < 0,1 km/h | 0,00 km/h | réussi |
| stop & go en côte de 4 % | WAIT, puis RES, puis ACTIVE | oui | réussi |
| charge, côte de 6 %, vent de face, freins faibles | erreur de vitesse < 2 km/h | 0,36 km/h | réussi |
| zone intermédiaire avec une demande bruitée | changements entre moteur et freins ≤ 4 | 4 | réussi |
| défaut d’un capteur pendant un freinage | à-coup de la demande ≤ 2 m/s³ | 2,00 m/s³ | réussi |
Les critères ne sont pas choisis au hasard : la décélération et l’à-coup viennent de la norme (leçon 1), les distances de la sécurité, le faux positif et la perte des mesures des situations qui ruinent la confiance du conducteur, les changements de zone du confort.
Presque chaque ligne de ce tableau a eu, pendant le développement, un premier résultat faux, et chacun a appris quelque chose :
- la fusion pire que la caméra seule (bruit de processus trop petit, leçon 3) ;
- l’approche « élastique » qui freinait plus que l’approche normale (la phase douce pouvait freiner plus que nécessaire, leçon 5) ;
- l’arrêt à 15 m au lieu de 4 (la machine à états prenait un ralentissement pour un arrêt, et le planificateur copiait le freinage de la cible au lieu de viser son point d’arrêt, leçon 5) ;
- le freinage à −3,9 m/s² au lieu de −3 (intégrale chargée pendant le temps d’attente du changement de zone, leçon 6) ;
- le recul en côte (les freins s’ouvraient dans la zone de roue libre à vitesse presque nulle, leçon 6) ;
- le temps inter-véhiculaire court qui rendait la file instable (gains fixes, leçon 5).
C’est pourquoi les tests automatiques comptent plus que n’importe quelle relecture à l’œil.
La même chaîne en C
La version C99 (acc.h, acc.c) est écrite sous forme de composants AUTOSAR : chaque composant a une fonction d’initialisation et un runnable avec des entrées et des sorties explicites, sans mémoire dynamique, sans récursion, seulement des float. Le banc d’essai test_acc.c contient un modèle du véhicule (moteur avec temps mort et retard, freins avec ressorts et jeu des plaquettes, frottement statique à l’arrêt) et 13 scénarios :
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 PASSIl se compile sans un seul avertissement avec gcc -std=c99 -O2 -Wall -Wextra -Wpedantic -o test_acc acc.c test_acc.c -lm. Les résultats coïncident avec ceux de Python (arrêts à 3,94 et 3,95 m contre 3,93 et 3,94, insertion verrouillée à 3,90 s contre 3,92, erreur de vitesse de 0,36 km/h dans les deux cas) : deux implémentations indépendantes du même algorithme qui donnent les mêmes nombres sont une preuve forte que toutes deux font ce que dit la théorie.
Les paramètres
| Paramètre | Valeur | Où | Pourquoi |
|---|---|---|---|
| temps inter-véhiculaire | 1,0 / 1,4 / 1,8 / 2,2 s | machine à états | quatre réglages, la norme demande ≥ 0,8 et un entre 1,5 et 2,2 |
| 4 m | planificateur | distance à l’arrêt | |
| 0,15, 0,6 (ou plus), 0,3 | planificateur | amortissement > 1, stabilité de la file | |
| élasticité | 0,25 h v, au plus 12 m | planificateur | freinage plus doux à l’approche |
| preboost | 0,9 s, +0,6 m/s², 4 s | planificateur | dépassement plus fluide, jamais sous 0,9 s |
| 0,60, 0,35 | sélection | hystérésis | |
| 0,3 + 0,25 | sélection | confirmation plus longue si la trajectoire est incertaine | |
| 0,6 s | sélection | courte perte des mesures | |
| 2,0, 1,5 m/s² | fusion | vraies manœuvres (changement de voie) | |
| bande de la zone C | ± 0,08 m/s² | couple | environ le couple de freinage minimal utile |
| temps minimal dans une zone | 0,3 s | couple | pas d’oscillations moteur/freins |
| 0,6, 1,2 | couple | correction des erreurs de modèle |
Où se place cette matière
Les sept leçons sont dans la matière Automotive, avec leur programme ; elles utilisent des outils d’autres matières, auxquelles elles renvoient quand il le faut :
- Automatique : stabilité, réponse du second ordre, PID et anti-emballement (leçons 5 et 6) ;
- Commande numérique : filtre de Kalman, observateurs, discrétisation, retard de calcul, commande optimale et prédictive (leçons 1, 3, 5) ;
- Télécommunications et Champs électromagnétiques : le radar FMCW (leçon 2) ;
- Physique 1 : dynamique, plan incliné, rotation (leçon 6) ;
- Analyse numérique et Méthodes mathématiques : moindres carrés, gaussienne et probabilités (leçons 3, 4, 6).
Et ensuite
Le code est un vrai point de départ, mais un ACC de série demande encore :
- le réglage sur le véhicule : les paramètres du moteur, des freins et des tables de confort se mesurent sur la voiture, ils ne s’inventent pas ;
- plusieurs modèles de mouvement dans le pisteur (IMM) et une association probabiliste dans le trafic dense ;
- la voie voisine pour le preboost, par les radars d’angle, et la prévision des trajectoires des autres véhicules ;
- la sécurité fonctionnelle : analyse des risques (ISO 26262), moniteurs indépendants des demandes, tests d’injection de défauts ;
- les essais d’homologation et Euro NCAP, qui utilisent des scénarios très proches de ceux du tableau.
Télécharger le code complet (zip, 42 ko) : acc_sim.py, make_plots.py, test_scenarios.py, acc.h, acc.c, test_acc.c et les instructions. Il faut Python 3.8 ou plus récent avec numpy (matplotlib pour les graphiques) et un compilateur C99.
Le code est fait pour être lu, modifié et relancé : changez un paramètre, relancez les tests et regardez quel critère cesse d’être respecté. C’est le moyen le plus rapide de comprendre pourquoi chaque détail des leçons précédentes est là.





