Aller au contenu
ELECTRONICS ENGINEERINGelectronics-engineering.com
Recommandée par l'auteur Commande numérique

Du modèle Simulink au code ECU : un régulateur numérique avec la transformée en Z, aussi en Python

Une régulation de vitesse avec un PI discret dans Simulink : blocs à temps discret, équations aux différences, anti-windup, code C généré, runnables AUTOSAR, tests MIL, SIL, PIL et HIL, et la même régulation simulée en Python avec un code vérifié.

https://www.electronics-engineering.com/fr/commande-numerique-de-simulink-a-l-ecu-transformee-en-z-python/

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

Cette page montre comment un régulateur numérique passe de la conception au code qui tourne dans un microcontrôleur ou dans le calculateur électronique (ECU) d’une voiture, en suivant le flux de travail utilisé dans l’industrie : le modèle dans Simulink, des blocs à temps discret fondés sur la transformée en Z, la simulation, la génération automatique de code C et des tests en plusieurs étapes. La même régulation est ensuite reconstruite en Python, avec des bibliothèques libres, et le code est vérifié. L’exemple est la régulation de vitesse d’un moteur électrique, mais la structure est identique pour le régime de ralenti d’un moteur à combustion, la pression de suralimentation d’un turbo, le régulateur de vitesse ou le couple d’un moteur de traction.

Pourquoi la transformée en Z est le langage des ECU

Un ECU ne résout pas d’équations différentielles : à intervalles fixes (par exemple toutes les 10 ms), il lit les capteurs, exécute un morceau de code et met à jour les sorties. Le régulateur est donc un système à temps discret, décrit par une équation aux différences, et sa fonction de transfert est en z (leçon et approfondissement sur la transformée en Z). Dans Simulink, cela se voit directement : les blocs de la bibliothèque *Discrete* (Unit Delay, qui est exactement z^{-1}, Discrete Transfer Fcn, Discrete-Time Integrator, Discrete PID Controller) ont tous un paramètre *Sample time* et correspondent une à une à des lignes de code. Le processus physique, lui, reste continu (blocs *Transfer Fcn*, *Integrator*), et le simulateur l’intègre avec un pas fin.

Le modèle

Le moteur, piloté par une tension u, a une vitesse \omega de fonction de transfert

    \[ G(s) = \frac{K_m}{\tau s + 1},\qquad K_m = 20\ \frac{\text{rad/s}}{\text{V}},\quad \tau = 0.5\ \text{s} \]

et l’étage de puissance peut fournir au plus \pm 12 V. Le régulateur est un PI qui tourne à T = 10 ms.

Schéma fonctionnel de la régulation dans Simulink
La consigne en échelon entre dans le comparateur, l’erreur e va au régulateur discret C de z, puis à la saturation et au bloqueur d’ordre zéro, qui pilote le moteur continu K m sur tau s plus 1. La vitesse omega est échantillonnée avec la période T et renvoyée au comparateur. Le cadre en pointillés contient la partie à temps discret, c’est-à-dire celle qui finira dans l’ECU.

Dans Simulink, le schéma se construit ainsi :

  1. Step pour la consigne (0 → 200 rad/s à t = 0.1 s), Sum avec les signes +- ;
  2. Discrete PID Controller sous forme *Parallel*, P = 0.25, I = 0.5, *Sample time* T = 0.01, *Integrator method* Forward Euler (la valeur par défaut) ;
  3. dans l’onglet *Output Saturation* les limites \pm 12 et, dans l’onglet *Anti-windup*, la méthode *clamping* ;
  4. Transfer Fcn avec le numérateur 20 et le dénominateur [0.5 1] pour le moteur ;
  5. il n’est pas nécessaire de dessiner le bloqueur : un bloc discret qui pilote un bloc continu garde sa sortie constante entre deux échantillons, ce qui est exactement le ZOH ;
  6. dans les paramètres du modèle : un solveur à pas fixe (par exemple ode4) avec un pas de 1 ms, ou à pas variable pour la seule simulation. La génération de code exige un pas fixe, et la cadence du régulateur doit être un multiple du pas de base.

À l’intérieur du bloc PI : les équations aux différences

Avec l’intégration d’Euler explicite, le PI est

    \[ u[k] = K_p\,e[k] + I[k],\qquad I[k + 1] = I[k] + K_iT\,e[k] \]

c’est-à-dire, en z, C(z) = K_p + \frac{K_iT}{z - 1}. L’état I est conservé dans un Unit Delay : c’est la variable qui « se souvient » de la valeur du pas précédent.

L'intérieur du régulateur PI discret
L’erreur passe par le gain proportionnel et, en parallèle, par le gain K i fois T, qui s’accumule dans un sommateur bouclé sur un retard z à la moins 1 : la sortie du retard est l’état I de k. Les deux parties s’additionnent et passent par la saturation ; la ligne rouge en pointillés indique que, quand la sortie est saturée, l’intégrateur est gelé (anti-windup).

Anti-windup. Quand l’actionneur est saturé, l’erreur reste grande et l’intégrateur continue de croître : à la fin, quand la sortie s’approche de la consigne, l’intégrale accumulée provoque un grand dépassement. La méthode *clamping* cesse d’intégrer tant que la sortie est saturée. Dans la simulation ci-dessous, sans anti-windup la vitesse atteint 235 rad/s (17,5 % de dépassement) et se stabilise en 3,2 s ; avec l’anti-windup elle ne dépasse pas 200 rad/s et se stabilise en 1,7 s.

Réponse du moteur avec et sans anti-windup
La courbe rouge, numéro 1, est sans anti-windup : la vitesse dépasse la consigne de 200 rad/s jusqu’à environ 235 puis redescend lentement. La courbe bleue, numéro 2, est avec anti-windup : elle monte à 200 sans la dépasser.
Commande en tension dans les deux cas
Dans les deux cas, la tension reste à 12 V, la limite de l’étage de puissance, pendant la montée. Sans anti-windup, en rouge, elle reste saturée beaucoup plus longtemps, parce que l’intégrateur doit décharger ce qu’il a accumulé ; avec l’anti-windup, en bleu, elle retombe immédiatement à la valeur de régime de 10 V.

Du modèle au code

Avec Embedded Coder (le générateur de code de MathWorks pour les systèmes embarqués), le sous-système discret devient du code C. La structure typique, simplifiée, est la suivante :

/* model states (DWork): one for each Unit Delay or integrator */
typedef struct { float I; } DW_motor_ctrl;
static DW_motor_ctrl dw;

void motor_ctrl_initialize(void) { dw.I = 0.0f; }

/* called by the scheduler every 10 ms */
float motor_ctrl_step(float ref, float w)
{
    float e = ref - w;
    float u_lib = 0.25f * e + dw.I;
    float u = u_lib > 12.0f ? 12.0f : (u_lib < -12.0f ? -12.0f : u_lib);
    if (u == u_lib) {                    /* anti-windup: clamping */
        dw.I += 0.5f * 0.01f * e;        /* I[k+1] = I[k] + Ki*T*e[k] */
    }
    return u;
}

Le générateur produit aussi un programme principal d’exemple (ert_main.c) dans lequel une fonction appelée par un timer, rt_OneStep(), exécute model_step() à chaque période. Dans un ECU automobile, la fonction de pas devient un runnable AUTOSAR affecté à une tâche périodique du système d’exploitation (par exemple la tâche de 10 ms), qui lit les signaux depuis le bus CAN ou les convertisseurs et écrit les sorties.

Détails importants en pratique :

  • temps d’exécution : la lecture de l’A/N, le calcul et l’écriture du N/A prennent une partie de la période ; la commande est appliquée avec un retard \tau_c qui s’ajoute au demi-échantillon du bloqueur et retire de la marge de phase (approfondissement sur la stabilité dans le plan z) ;
  • arithmétique : beaucoup d’ECU à bas coût n’ont pas d’unité à virgule flottante, et le code est généré en virgule fixe, avec des mises à l’échelle choisies pour ne pas perdre de résolution ni déborder ;
  • cadences multiples : des régulateurs rapides (courant, 100 µs) et lents (température, 100 ms) coexistent ; les blocs *Rate Transition* gèrent le passage de données entre tâches différentes ;
  • sûreté de fonctionnement : dans l’automobile, le processus de développement suit la norme ISO 26262, qui exige la traçabilité entre exigences, modèle, code et tests.
Chronologie du régulateur dans l'ECU
À chaque instant k T, l’ECU lit le convertisseur A/N, en bleu, exécute le calcul, en violet, et écrit le N/A, en orange, après un retard tau c ; la commande u reste constante jusqu’à la mise à jour suivante.

Les tests : MIL, SIL, PIL, HIL

Le modèle est aussi la référence pour vérifier le code, par étapes successives :

  • MIL (*model in the loop*) : le modèle complet, régulateur et processus, est simulé sur le PC ;
  • SIL (*software in the loop*) : le code C généré, compilé pour le PC, remplace le bloc régulateur et les résultats doivent coïncider avec ceux du MIL ;
  • PIL (*processor in the loop*) : le même code tourne sur le vrai processeur (ou sur un simulateur de celui-ci), relié au modèle du processus sur le PC : on mesure les temps d’exécution et la mémoire ;
  • HIL (*hardware in the loop*) : l’ECU complet est relié à un simulateur temps réel qui reproduit le véhicule et les capteurs ; on peut aussi tester les pannes, sans risque ;
  • enfin, les essais sur le véhicule.
Étapes de vérification du modèle à l'ECU
Du modèle simulé MIL, on passe au code sur le PC SIL, au code sur le processeur PIL, à l’ECU avec le simulateur temps réel HIL, et enfin à l’ECU sur le véhicule.

La même régulation en Python

Python n’a pas d’équivalent complet de Simulink, avec génération automatique de code certifiable pour ECU. Pour la conception et la simulation, en revanche, des bibliothèques libres suffisent : numpy et scipy pour le calcul, python-control pour les fonctions de transfert, matplotlib pour les graphiques. La boucle du régulateur s’écrit explicitement, échantillon par échantillon, et c’est exactement le même code qui finira dans le microcontrôleur. Le processus continu est simulé avec son modèle exact avec bloqueur, \omega[k + 1] = a\,\omega[k] + (1 - a)K_m u[k] avec a = e^{-T/\tau} (exercice 8 sur la transformée en Z) :

import numpy as np

# process: motor, speed w [rad/s] driven by voltage u [V]
Km, tau = 20.0, 0.5          # gain [rad/s/V] and time constant [s]
T = 0.01                     # controller period: 10 ms
a = np.exp(-T / tau)         # exact model with hold (ZOH)

# discrete PI controller (forward Euler integrator, as in Simulink's
# Discrete PID Controller block with default settings)
Kp, Ki = 0.25, 0.5           # [V/(rad/s)], [V/(rad/s)/s]
Umax = 12.0                  # maximum driver voltage

def simulate(antiwindup, t_end=4.0):
    n = int(t_end / T)
    w = 0.0                  # process state
    I = 0.0                  # integrator state (Unit Delay)
    out = []
    for k in range(n):
        t = k * T
        ref = 200.0 if t >= 0.1 else 0.0
        e = ref - w                       # sensor reading and error
        u_free = Kp * e + I               # PI output
        u = min(max(u_free, -Umax), Umax) # saturation
        if not antiwindup or u == u_free: # clamping anti-windup
            I = I + Ki * T * e
        w = a * w + (1 - a) * Km * u      # the motor evolves for one period
        out.append((t, ref, w, u))
    return np.array(out)

for aw in (False, True):
    r = simulate(aw)
    t, w = r[:, 0], r[:, 2]
    outside = np.where(abs(w - 200) > 4)[0]        # samples outside the 2 % band
    print(f"anti-windup={aw}: max {w.max():.1f} rad/s, "
          f"overshoot {max(0.0, 100 * (w.max() - 200) / 200):.1f} %, "
          f"2 % settling at t = {t[outside[-1] + 1]:.2f} s")

En l’exécutant, on obtient :

anti-windup=False: max 235.1 rad/s, overshoot 17.5 %, 2 % settling at t = 3.22 s
anti-windup=True: max 200.0 rad/s, overshoot 0.0 %, 2 % settling at t = 1.72 s

et les graphiques de cette page ont été tracés à partir exactement de ces données. Pour des systèmes plus complexes, python-control permet de relier des blocs continus et discrets avec ct.interconnect et de les simuler avec ct.input_output_response. Parmi les alternatives libres à Simulink avec éditeur graphique de blocs, il y a Xcos (inclus dans Scilab) et OpenModelica ; la bibliothèque Python bdsim permet de décrire des schémas fonctionnels dans le code.

Comment les paramètres ont été choisis. Le zéro du PI, à K_i/K_p = 2 rad/s, annule le pôle du moteur à 1/\tau = 2 rad/s ; il reste une boucle du premier ordre \frac{K_pK_m}{\tau s}, de constante de temps \frac{\tau}{K_pK_m} = 0.1 s. Avec T = 10 ms, il y a dix échantillons par constante de temps : le retard d’échantillonnage coûte environ 3° de marge de phase, ce qui est négligeable (approfondissement sur la stabilité dans le plan z).

Les exercices sur la stabilité, le lieu des racines et les marges des systèmes numériques se trouvent sur la page d’exercices indiquée en haut.

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