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/
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
(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
, 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
, a une vitesse
de fonction de transfert
![]()
et l’étage de puissance peut fournir au plus
V. Le régulateur est un PI qui tourne à
ms.

Dans Simulink, le schéma se construit ainsi :
- Step pour la consigne (0 → 200 rad/s à
s), Sum avec les signes
; - Discrete PID Controller sous forme *Parallel*,
,
, *Sample time*
, *Integrator method* Forward Euler (la valeur par défaut) ; - dans l’onglet *Output Saturation* les limites
et, dans l’onglet *Anti-windup*, la méthode *clamping* ; - Transfer Fcn avec le numérateur
20et le dénominateur[0.5 1]pour le moteur ; - 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 ;
- 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
![]()
c’est-à-dire, en
,
. L’état
est conservé dans un Unit Delay : c’est la variable qui « se souvient » de la valeur du pas précédent.

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.


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
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.

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.

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,
avec
(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 set 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, à
rad/s, annule le pôle du moteur à
rad/s ; il reste une boucle du premier ordre
, de constante de temps
s. Avec
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.






Benvenuti nella pagina su «Dal modello Simulink al codice della centralina: un controllo digitale con la trasformata Zeta, anche in Python». L'ho scritta pensando a chi studia ingegneria elettronica: se un passaggio non vi torna, un esercizio vi dà un risultato diverso o volete altro materiale sull'argomento, chiedete pure nei commenti e vi risponderò. Un voto con le stelle qui sopra mi aiuta a capire quali pagine migliorare.Welcome to the page on “From the Simulink model to ECU code: a digital controller with the Z transform, also in Python”. I wrote it for engineering students: if a step does not add up, an exercise gives you a different result or you would like more material on the topic, just ask in the comments and I will reply. A star rating above helps me understand which pages to improve.