Aller au contenu
ELECTRONICS ENGINEERINGelectronics-engineering.com
Automobile

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/

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

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

La chaîne complète
La chaîne complète, déjà vue dans la leçon 1 : maintenant chaque bloc a son code, ses paramètres et ses tests.
BlocLeçonPython (acc_sim.py)C (acc.c)Période
radar, caméra2radar_measure, camera_measure(dans les calculateurs capteurs)50 / 66 ms
fusion3Tracker, Track(Kalman : comme en Python)à chaque mesure
trajectoire prévue4PathPredictorPathPred_Run, PathPred_At20 ms
sélection de la cible4TargetSelectorTgtSel_Run20 ms
planificateur5PlannerPlanner_Run20 ms
machine à états1, 5AccStateMachineAccSm_Run20 ms
contrôle de couple6TorqueController, EstimatorLongCtrl_Run20 ms (10 ms dans l’ESC)
véhicule (procédé)6Vehiclecar_step dans le banc d’essai10 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 :

  1. 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) et test_acc.c (C) ;
  2. 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 ;
  3. essais sur piste avec des cibles mobiles (y compris les procédures d’essai de l’ISO 15622 et d’Euro NCAP) ;
  4. 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énarioCritèreRésultatIssue
vitesse libre, de 100 à 120 km/herreur de vitesse dans les 5 dernières s < 1 km/h0,02 km/hréussi
approche de 130 à 80 km/h, 200 mdécélération maximale < 2 m/s²0,75 m/s²réussi
approche de 130 à 80 km/h, 200 merreur de distance après 60 s < 5 %0,40 %réussi
la cible freine à −4 m/s² jusqu’à l’arrêtdistance minimale > 2 m3,90 mréussi
insertion à 50 m, 12 km/h plus lente (chaîne complète)distance minimale > 15 m33,5 mré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 scycles sans cible = 00réussi
voiture dans la voie voisine à l’entrée d’un virage, lignes médiocrestemps comme fausse cible = 00 sréussi
stop & go en côte de 4 %distance d’arrêt 4 ± 0,5 m3,93 mréussi
stop & go en côte de 4 %recul < 0,1 km/h0,00 km/hréussi
stop & go en côte de 4 %WAIT, puis RES, puis ACTIVEouiréussi
charge, côte de 6 %, vent de face, freins faibleserreur de vitesse < 2 km/h0,36 km/hréussi
zone intermédiaire avec une demande bruitéechangements entre moteur et freins ≤ 44ré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 PASS

Il 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ètreValeurOùPourquoi
temps inter-véhiculaire1,0 / 1,4 / 1,8 / 2,2 smachine à étatsquatre réglages, la norme demande ≥ 0,8 et un entre 1,5 et 2,2
d_04 mplanificateurdistance à l’arrêt
k_d, k_v, k_a0,15, 0,6 (ou plus), 0,3planificateuramortissement > 1, stabilité de la file k_d h^2 + 2k_v h \ge 2
élasticité \delta0,25 h v, au plus 12 mplanificateurfreinage plus doux à l’approche
preboost0,9 s, +0,6 m/s², 4 splanificateurdépassement plus fluide, jamais sous 0,9 s
p_{in}, p_{out}0,60, 0,35sélectionhystérésis
\tau_c0,3 + 0,25 \sigma_p ssélectionconfirmation plus longue si la trajectoire est incertaine
\tau_h0,6 ssélectioncourte perte des mesures
q_x, q_y2,0, 1,5 m/s²fusionvraies manœuvres (changement de voie)
bande de la zone C± 0,08 m/s²coupleenviron le couple de freinage minimal utile
temps minimal dans une zone0,3 scouplepas d’oscillations moteur/freins
k_p, k_i0,6, 1,2couplecorrection 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à.

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