§ 01

L'analogie

Pousse une balançoire, une seule fois, doucement : elle revient à peine plus bas et s'arrête. Pousse-la un peu plus fort à chaque passage, toujours au même instant du mouvement : elle balance de plus en plus haut, d'un côté puis de l'autre, à un rythme qui lui appartient — sa période propre, celle que rien ne change tant que tu pousses toujours pareil. Un jour, en cherchant « jusqu'où avant que ça devienne dangereux », tu trouves une force de poussée précise pour laquelle la balançoire monte à la même hauteur, indéfiniment, ni plus ni moins : un régime entretenu, stable en apparence, mais sur le fil. Un cran de plus, et elle grimpe sans fin jusqu'à faire le tour de la barre. C'est très exactement l'essai que fait un régleur d'automatismes de 1942 sur une chaudière ou un moteur : n'utiliser qu'un correcteur proportionnel, monter le gain jusqu'à l'oscillation entretenue, noter le gain (« ultime », le tien juste avant le tour de la barre) et la période de ce mouvement — puis calculer, à partir de ces deux seuls nombres, les trois réglages P, I, D d'un coup. C'est la méthode du gain critique de Ziegler et Nichols 1, et le §02 la rejoue, en toute sécurité, sur un procédé simulé.

Une seconde image, pour le réglage qui rate. Une voiture est embourbée dans la neige : le conducteur appuie de plus en plus fort sur l'accélérateur, les roues patinent sans que la voiture n'avance d'un centimètre. Plus il attend, plus il enfonce la pédale — comme si, dans sa tête, « le temps que j'ai poussé fort » devait bien finir par compter. Puis les roues accrochent enfin le bitume sous la neige : la voiture bondit en avant, bien plus violemment que si le conducteur avait relâché la pédale dès qu'il avait senti l'inutilité de pousser plus. C'est l'image exacte de l'emballement de l'intégrale d'un régulateur PID quand son actionneur sature 3 : l'action intégrale continue d'accumuler l'erreur tant qu'elle existe, sans savoir que la commande qu'elle réclame ne sert déjà plus à rien puisque l'actionneur a atteint sa butée ; quand l'erreur finit par changer de signe, l'intégrale doit d'abord « redescendre » depuis une valeur énorme avant que la commande ne redevienne raisonnable — un dépassement, souvent spectaculaire, que le procédé subit en plein régime. Corriger cela, régler des gains qui marchent vraiment sur un moteur réel plutôt que sur son modèle idéal, et faire tourner tout cela à la cadence d'un microcontrôleur : c'est le programme de ce module, le dernier du monde 4.

🧠 Rappel express

Le PID et ses trois actions (module 4.1). : P proportionnelle à l'erreur, I qui s'accumule et annule l'erreur statique, D qui anticipe sur la pente de l'erreur. Ce module suppose ces trois actions acquises ; il répond à la question qu'elles laissent ouverte : quelles VALEURS leur donner sur un procédé réel, avec un actionneur qui sature et un calculateur qui échantillonne ?

L'intuition

Un PID bien réglé sur le papier (module 4.1) peut être inutilisable en pratique pour deux raisons qui n'ont rien à voir avec le choix des gains eux-mêmes : l'actionneur est physiquement borné (une tension, une vanne, un couple ne dépassent jamais leur maximum), et le calculateur qui l'implémente ne voit le monde qu'à intervalles discrets. Ignorer l'un ou l'autre transforme un correcteur théoriquement parfait en un correcteur qui dépasse, pompe, ou diverge sur le vrai procédé.

1.1 Ce que tu sauras faire à la fin

Identifier un modèle premier ordre plus retard (FOPDT) à partir d'une réponse indicielle réelle ; en déduire des gains PID par trois méthodes — Ziegler-Nichols en boucle ouverte, Ziegler-Nichols en boucle fermée, SIMC de Skogestad — et savoir pourquoi elles ne donnent pas le même résultat ; reconnaître l'emballement intégral et le neutraliser par recalcul (back-calculation) ou par intégration conditionnelle ; discrétiser un PID pour un microcontrôleur (Euler arrière, Tustin, forme incrémentale) et choisir sa période d'échantillonnage ; écrire — et faire tourner — le code C d'un PID embarqué complet, anti-emballement compris.

À retenir

Un réglage de manuel (Ziegler-Nichols) donne un point de départ rapide mais agressif ; un réglage par modèle (SIMC) donne un compromis explicite entre rapidité et robustesse, via un seul paramètre, ; et aucun des deux ne survit à une saturation d'actionneur sans une protection anti-emballement — ce n'est pas une option de confort, c'est ce qui décide si le régulateur reste stable une fois construit.

§ 02

Le widget

Le procédé de ce widget est le moteur du fil rouge, en vitesse, vu de loin : un modèle premier ordre plus retard, identifié une fois pour toutes au §04 (gain 5 rad/s/V, retard apparent 6,235 ms, constante de temps apparente 79,370 ms). Deux modes. En mode « essai de pompage », un correcteur purement proportionnel referme la boucle ; le curseur de gain rejoue exactement l'essai du §01 — la balançoire — sur ce procédé, avec le retard approché par un développement de Padé d'ordre 3 pour que la simulation temporelle ait un sens (un retard pur n'a pas de représentation d'état finie). Le plan des pôles, à gauche, montre la paire dominante s'approcher de l'axe imaginaire à mesure que le gain monte ; à droite, la réponse indicielle en boucle fermée montre la même chose dans le temps : oscillation qui s'éteint, puis qui s'entretient, puis qui grandit. En mode « comparer les réglages », trois jeux de gains PID — Ziegler-Nichols boucle ouverte, Ziegler-Nichols boucle fermée, SIMC avec réglable — sont calculés en direct par les formules du §03 et simulés en boucle fermée sur le même procédé ; les trois réponses se superposent sur un seul tracé.

L'essai de pompage, et Ziegler-Nichols contre SIMC

Mode « pompage » : monte le gain K jusqu'à l'oscillation entretenue (défi : rester à ±3 % du gain critique exact). Mode « comparer » : règle et compare les trois réponses en boucle fermée.

2.1 Cinq choses à voir

Le pôle dominant migre vers l'axe imaginaire, jamais en sautant. Monte le gain K doucement : la paire complexe se déplace en continu (même logique que le lieu des racines du module 3.2), et croise l'axe imaginaire tout près du gain critique exact calculé par NF.ctrl.marginDelay — la petite différence vient de l'approximation de Padé, affichée en clair.
À K = Ku, la réponse ne s'éteint plus. Impose une petite consigne et regarde : sous , les oscillations rétrécissent ; à , elles se maintiennent à amplitude constante — l'essai de pompage, en vrai, pendant quelques secondes, avant de rendre la main.
Les trois réglages du mode « comparer » ne visent pas le même compromis. Bascule sur les trois courbes en même temps : Ziegler-Nichols (les deux variantes) dépasse largement, SIMC agressif ( petit) dépasse un peu moins, SIMC prudent ( grand) ne dépasse plus du tout mais devient lent.
Glisser déplace continûment ce compromis. Rien de discret : à chaque valeur, et se recalculent par (7), la réponse SIMC se redessine.
Les deux Ziegler-Nichols, boucle ouverte et boucle fermée, se ressemblent — sans être identiques. Ils partent de données différentes (la courbe de réaction contre l'essai de pompage) sur le même procédé physique ; leurs gains sont proches mais pas égaux, une bonne façon de sentir que ce sont deux ESTIMATIONS d'un même compromis, pas deux calculs d'une même quantité exacte.

2.2 Ce que le widget calcule vraiment

Le procédé simulé est exactement le modèle identifié au §04 (K = 5, θ = 6,235 ms, τ = 79,370 ms), avec le retard remplacé par NF.ctrl.pade(θ, 3) pour toute simulation temporelle — jamais pour les marges, qui utilisent NF.ctrl.marginDelay, exact. L'autotest vérifie :

le gain critique exact (marginDelay) contre le gain critique approché (Padé, ordre 3), à moins de 0,05 % d'écart, et sa valeur contre celle recalculée à la main au §4.4 ;
la période critique mesurée sur le franchissement de l'axe imaginaire du pôle dominant approché, contre exact ;
les trois jeux de gains (ZN-BO, ZN-BF, SIMC) contre les formules (3), (4) et (7), recalculés indépendamment dans l'autotest ;
en dessous de , la paire dominante reste à partie réelle négative ; au-dessus, elle passe à droite — vérifié sur une dizaine de gains tirés ;
le défi : un gain à ±3 % de réussit, un gain choisi au hasard loin de cette fourchette échoue.

§ 03

La théorie

3.1 Le modèle qu'on identifie : premier ordre plus retard

Aucune des méthodes de ce module ne travaille sur le modèle physique complet du procédé (module 2.1, un système du second ordre pour le moteur, souvent bien plus compliqué en pratique — échangeur, four, colonne de distillation). Elles travaillent sur un modèle réduit à trois nombres, assez pauvre pour se lire sur UNE réponse indicielle, et assez riche pour capturer ce qui compte pour un PID : un gain statique, une inertie dominante, un retard.

🧠 Rappel express

Le retard pur en Laplace (module 2.1, 3.3). Un retard de secondes multiplie la fonction de transfert par : le module de la réponse fréquentielle ne change pas, mais la phase perd radians à la pulsation — une perte de phase qui grandit sans fin avec , contrairement à un pôle.

Le modèle premier ordre plus retard, FOPDT :

G(s) = \frac{K}{\tau s + 1}\,\mathrm e^{-\theta s}

(1)

: gain statique (sortie finale par unité d'entrée). : constante de temps apparente, l'inertie dominante vue depuis l'extérieur. : retard apparent — presque jamais un vrai transport physique (même le moteur, un second ordre sans aucun retard réel, en produit un, purement algébrique). Le procédé réel a beau être d'ordre 2, 3, ou plus, sa réponse à un échelon, si elle est en S (sans dépassement, un seul point d'inflexion), se laisse approcher par (1) — c'est tout ce dont Ziegler, Nichols et Skogestad ont besoin 1 2 6.

3.2 La méthode de la tangente à l'inflexion

Sur une réponse indicielle en S, , pour un échelon d'entrée d'amplitude : le point d'inflexion est là où la pente est maximale. La tangente en ce point est la droite qui approche le mieux la montée la plus raide de la courbe — c'est elle que Ziegler et Nichols lisent, pas la courbe entière. Elle coupe l'axe en (le retard apparent) et atteint la valeur finale en (la constante de temps apparente) :

\begin{gathered} L = t^* - \frac{y(t^*)}{\dot y(t^*)} \\ T = \frac{K\Delta u - y(t^*)}{\dot y(t^*)} \end{gathered}

(2)

Si le procédé EST exactement du premier ordre plus retard (1), cette construction retrouve et exactement — le point d'inflexion d'un FOPDT est à , là où la pente saute de 0 à sa valeur maximale . Si le procédé est d'ordre supérieur (le cas réel, §04), (2) donne une approximation : c'est le prix pour réduire n'importe quelle courbe en S à trois nombres lisibles à la règle, sans résoudre d'équation différentielle.

3.3 Ziegler-Nichols en boucle ouverte : la courbe de réaction

Ziegler et Nichols publient en 1942 deux méthodes, obtenues sur des régulateurs pneumatiques industriels, sans ordinateur : juste une règle, une courbe enregistrée au papier, et l'objectif practique d'un rapport de décroissance au quart (chaque oscillation vaut le quart de la précédente) — un compromis délibérément dynamique, pas un optimum au sens d'un critère quadratique 1. La première n'a besoin que de la courbe de réaction en boucle ouverte, (L, T) du §3.2, et d'un tableau :

Correcteur	Ti	Td
P	—	—
PI		—
PID

La logique : plus est grand devant , plus le procédé est difficile à commander vite (le retard limite tout gain possible), et le tableau réduit en proportion — mais la forme même du tableau (des constantes fixes multipliant ) ne s'adapte à AUCUNE autre considération : ni la robustesse voulue, ni un actionneur plus ou moins limité. C'est le prix de sa simplicité : trois lignes, deux nombres lus sur une courbe, un correcteur réglé en cinq minutes.

3.4 Ziegler-Nichols en boucle fermée : le gain critique

La seconde méthode ferme la boucle avec un correcteur purement proportionnel (§01, la balançoire) et augmente jusqu'à l'oscillation entretenue. À ce gain (« ultime »), la boucle est à la limite de stabilité : le gain de boucle vaut exactement 1 à la pulsation où la phase de boucle vaut −180°, exactement la condition du critère du revers 4 (module 3.3).

🧠 Rappel express

Le critère du revers (module 3.3). Une boucle à retour unitaire de gain de boucle est instable si à la pulsation où . Le gain critique est le plus petit gain proportionnel qui amène exactement cette égalité.

Sur le FOPDT (1), en notant la pulsation qui vérifie la condition de phase :

\begin{gathered} \arctan(\omega_u \tau) + \omega_u\theta = \pi \\ K_u = \frac{\sqrt{1+(\omega_u\tau)^2}}{K}, \qquad T_u = \frac{2\pi}{\omega_u} \end{gathered}

(3)

La première équation de (3) n'a pas de solution fermée (elle mélange un et un terme linéaire) : on la résout numériquement, exactement ce que fait NF.ctrl.marginDelay par dichotomie (ENGINE.md) — c'est réglé une fois pour toutes au §04. De et , Ziegler et Nichols tirent un second tableau, à la même forme que le premier :

Correcteur	Ti	Td
P	—	—
PI		—
PID

Les deux méthodes partent de données différentes — une courbe enregistrée une seule fois contre un essai qui pousse la vraie boucle jusqu'à l'oscillation — mais visent le même compromis empirique. Sur le moteur (§04), elles donnent des gains proches sans être égaux : deux ESTIMATIONS indépendantes d'un même objectif, pas deux calculs exacts d'une même quantité.

3.5 Le défaut commun : trop agressif

Le rapport de décroissance au quart correspond à un amortissement faible, (module 2.3) : un dépassement voisin de 25 % à chaque changement de consigne. Åström et Hägglund le documentent avec insistance 3 4 : les réglages Ziegler-Nichols, pensés pour le REJET d'une perturbation de charge en 1942 (le problème dominant sur les procédés industriels de l'époque, un débit ou une pression qui varie), sont trop agressifs pour un SUIVI de consigne (l'axe d'un robot, la vitesse d'un moteur asservi en position) et amplifient le bruit de mesure par la dérivée non filtrée du tableau d'origine. Le §04 le chiffre : sur le moteur, un dépassement proche de 50 %, très loin des 5 % que demandera le mini-boss.

3.6 SIMC de Skogestad : choisir directement la dynamique en boucle fermée

Skogestad (2003) part d'une autre question : au lieu de viser un compromis empirique fixe, pourquoi ne pas choisir directement la constante de temps de la boucle fermée, , et calculer les gains qui l'obtiennent exactement (au premier ordre) 2 ? La méthode, dite à modèle interne (IMC 7), synthétise un correcteur qui annule le modèle du procédé et impose en boucle fermée une réponse indicielle du premier ordre plus retard, de constante de temps — un seul réglage, au sens physique clair (« je veux que la boucle réponde en secondes »). Après un développement limité du retard (la plongée le fait en entier), on obtient la règle SIMC-PI :

\begin{gathered} K_c = \frac{1}{K}\cdot\frac{\tau}{\tau_c+\theta} \\ T_i = \min\!\big(\tau,\; 4(\tau_c+\theta)\big) \end{gathered}

(4)

Le paramètre est un choix, pas un résultat de calcul : Skogestad recommande pour un réglage « serré » (rapide, robuste avec une marge confortable), ou plus grand pour ménager l'actionneur ou tolérer un modèle moins sûr. Contrairement au tableau ZN, la forme (4) montre EXPLICITEMENT ce compromis : petit donne grand (rapide, agressif) ; grand donne petit (lent, prudent). Quand le procédé a une seconde constante de temps notable (un FOPDT n'en a qu'une, mais un vrai procédé souvent deux), SIMC ajoute une action dérivée, , pour la compenser — hors de portée de notre exemple, dont l'identification (§04) ne retient qu'une seule constante de temps.

La règle SIMC, démontrée en entier par synthèse à modèle interneNiveau 2

L'idée de la commande à modèle interne : si l'on connaît le modèle du procédé, le correcteur idéal serait — annuler le procédé, imposer n'importe quelle dynamique en sortie. Deux obstacles : n'est presque jamais réalisable (elle amplifierait les hautes fréquences sans limite, et un retard inversé serait une PRÉDICTION), et un modèle n'est jamais exact. La solution IMC : choisir la réponse en boucle fermée SOUHAITÉE, , réalisable et stable, puis en déduire le correcteur qui la produit EXACTEMENT si le modèle est exact :

T(s) = \frac{Y(s)}{R(s)} = \frac{C(s)G(s)}{1+C(s)G(s)} \quad\Longrightarrow\quad C(s) = \frac{1}{G(s)}\cdot\frac{T(s)}{1-T(s)}

Choisissons la réponse en boucle fermée désirée comme un premier ordre plus retard, de constante de temps , EXACTEMENT le retard du procédé (on ne peut pas faire mieux : rien n'annule un vrai retard) : . Avec le modèle FOPDT (1), :

C(s) = \frac{\tau s + 1}{K\,\mathrm e^{-\theta s}}\cdot\frac{\mathrm e^{-\theta s}/(\tau_c s+1)}{1 - \mathrm e^{-\theta s}/(\tau_c s+1)} = \frac{\tau s+1}{K}\cdot\frac{1}{\tau_c s + 1 - \mathrm e^{-\theta s}}

Les deux se sont annulés au numérateur (le retard du procédé et celui, voulu identique, de la cible) — c'est le seul endroit où le retard intervient encore : au dénominateur, dans , qui n'est pas un polynôme. Skogestad linéarise ce terme au premier ordre, (développement de Taylor de l'exponentielle, valable pour petit — cohérent avec un retard apparent, presque toujours petit devant la dynamique dominante) :

C(s) \approx \frac{\tau s+1}{K}\cdot\frac{1}{(\tau_c+\theta)s} = \frac{\tau}{K(\tau_c+\theta)}\cdot\frac{\tau s+1}{\tau s}

C'est un correcteur PI exact : le facteur a la forme d'un PI de gain 1 et de temps d'intégration . En identifiant, et — la première moitié de (4). Le plafond est un ajustement empirique que Skogestad ajoute pour les procédés où est très grand devant (four, réacteur thermique lent) : sans lui, resterait égal à , beaucoup trop grand, et la boucle rejetterait très lentement une perturbation de charge en régime lent — un défaut connu des correcteurs PI purs dérivés de l'IMC, documenté et corrigé par cette borne dans l'article original 2. Sur notre exemple (§04), ms : pour , ms est bien plus petit que , le plafond joue à plein ( ms, pas 79,37) ; à partir de , dépasse et se fige à — exactement ce que montre le tableau du §4.5.

3.7 Saturation d'actionneur et emballement de l'intégrale

Tous les réglages précédents supposent un actionneur qui obéit sans limite. En réalité, une tension moteur ne dépasse jamais l'alimentation, une vanne ne s'ouvre jamais plus qu'en grand : la commande réelle est . Tant que reste dans les bornes, rien ne change. Dès qu'il les dépasse, l'action intégrale continue d'accumuler l'erreur qui subsiste — la voiture embourbée du §01 — puisque rien, dans son calcul brut, ne sait que la commande qu'elle réclame ne sert plus à rien :

\frac{\mathrm d I}{\mathrm d t} = K_i\,e(t) \quad\text{(inchangée, que }u_{\text{brut}}\text{ sature ou non)}

(5)

Tant que garde son signe pendant la saturation — le cas typique d'un grand échelon de consigne — grandit sans borne, proportionnellement au temps passé en saturation. Quand l'erreur change enfin de signe (la sortie approche la consigne), reste saturé un moment de plus, le temps que redescende de son excès : la sortie continue de monter alors qu'elle devrait déjà freiner. C'est exactement le bond en avant de la voiture qui vient d'accrocher le bitume — un dépassement que ni ni ne peuvent empêcher, puisque le mal est déjà fait dans avant même que la commande ne redescende sous la saturation.

3.8 Anti-emballement par recalcul (back-calculation)

L'idée d'Åström et Hägglund 3 4 : mesurer en permanence l'écart entre ce que le correcteur RÉCLAME et ce que l'actionneur PEUT rendre, et le réinjecter dans l'intégrale pour la freiner automatiquement dès qu'il apparaît :

\frac{\mathrm d I}{\mathrm d t} = K_i\,e(t) + \frac{1}{T_t}\big(u_{\text{sat}} - u_{\text{brut}}\big)

(6)

Hors saturation, , le second terme est nul : (6) redevient (5), rien ne change. En saturation, le second terme est un retour NÉGATIF sur l'excès ( est du signe opposé à l'excès), qui ramène vers la limite avec une constante de temps — un second système bouclé, entièrement séparé de la boucle principale, dont est le seul réglage : trop grand, la correction est lente, presque comme sans anti-emballement ; trop petit, elle réagit au moindre dépassement transitoire et peut elle-même déstabiliser l'intégrale. Åström et Hägglund recommandent entre et — avec dérivée, pour un PI pur, la valeur retenue au §04 et au mini-boss 4.

3.9 Anti-emballement par intégration conditionnelle

Une seconde stratégie, plus simple à programmer, ne demande aucun réglage supplémentaire : geler l'intégrale dès que la commande sature ET que continuer à intégrer l'enfoncerait davantage dans la saturation 5.

Intégration conditionnelleentrée : e, u_brut, bornes [umin, umax] — sortie : mise à jour de I

si :
// la saturation est active ET l'erreur pousse encore dans le même sens : ne pas aggraver
1. (gelée)
sinon :
1. (intégration normale)

Moins fine que le recalcul (elle ne freine pas, elle bloque net, sans mémoire de ) mais robuste et bon marché — pas de second système à stabiliser, pas de à régler. Le mini-boss propose les deux stratégies ; le §08 revient sur leurs limites respectives.

Le transfert sans à-coup (bumpless transfer)Niveau 2

Un régulateur industriel bascule souvent entre un mode manuel (un opérateur pilote directement ) et un mode automatique (le PID pilote). Faire le saut sans à-coup — sans que ne saute brutalement à l'instant du basculement — est le même problème que l'anti-emballement, vu à l'envers : au lieu de freiner l'intégrale APRÈS une saturation, on l'INITIALISE au bon moment pour qu'elle produise déjà la commande en cours.

À l'instant du passage manuel → automatique, la commande manuelle vaut . Pour que la commande automatique démarre EXACTEMENT à (pas de saut), il suffit d'initialiser l'intégrale à la valeur qui rend l'équation du PID vraie à cet instant précis :

u_m = K_p\,e(t_0) + I(t_0) + D(t_0) \quad\Longrightarrow\quad I(t_0) = u_m - K_p\,e(t_0) - D(t_0)

Ensuite, l'intégrale évolue normalement par (5) ou (6). Le même principe protège aussi un changement DE GAINS en cours de marche (un ordonnancement de gains, module 12) : recalculer pour que ne bouge pas au moment du changement, plutôt que de garder la valeur numérique de telle quelle — ce qui, avec un nouveau , produirait un saut. La forme incrémentale du PID (§3.12) offre ce bénéfice presque gratuitement : elle ne calcule jamais depuis rien, seulement un ÉCART ajouté à ce que l'actionneur applique déjà.

3.10 Dérivée sur la mesure, pondération de consigne

Un échelon de consigne fait sauter instantanément l'erreur ; sa dérivée devient, en théorie, infinie — un « à-coup dérivateur » (derivative kick) que le filtre du module 4.1 atténue sans le supprimer, puisque l'échelon reste dans . La solution : dériver la MESURE plutôt que l'erreur, au lieu de — ne saute jamais (l'inertie du procédé l'en empêche), donc sa dérivée reste finie même pour un échelon de consigne. Åström et Hägglund généralisent avec une pondération de consigne, deux coefficients et (typiquement ) qui dosent combien de la consigne chaque action voit :

\begin{gathered} u(t) = K_p\big(b\,r(t)-y(t)\big) + K_i\!\int_0^t\!\big(r(\tau)-y(\tau)\big)\mathrm d\tau \\ {} + K_d\,\frac{\mathrm d}{\mathrm d t}\big(c\,r(t)-y(t)\big) \end{gathered}

(7)

L'action intégrale garde TOUJOURS l'erreur complète, — c'est elle, et elle seule, qui doit s'annuler en régime permanent (module 4.1) ; changer ou ne doit rien changer à l'erreur statique. Avec , un échelon de consigne provoque un saut de commande plus doux (moins de dépassement) sans changer la façon dont la boucle rejette une perturbation de charge — cela DÉCOUPLE deux objectifs que le seul triplet ne peut pas régler indépendamment.

3.11 Discrétiser le PID

Un microcontrôleur ne voit qu'à des instants espacés de (la période d'échantillonnage) : il faut remplacer l'intégrale et la dérivée continues par des formules récursives, calculables à chaque cycle avec un nombre fini d'états mémorisés.

🧠 Rappel express

Échantillonner. Un signal continu , échantillonné toutes les secondes, donne une suite . Le retard d'un pas s'écrit ; le monde 5 formalise cette écriture avec la variable ( = retard d'un pas). Ici, il suffit de manipuler directement les suites.

Euler arrière (rectangles, à droite). L'intégrale entre et est approchée par un rectangle de hauteur (l'échantillon LE PLUS RÉCENT, disponible au moment du calcul) :

\begin{gathered} I_k = I_{k-1} + K_i T_s\,e_k \\ D_k = K_d\,\frac{e_k-e_{k-1}}{T_s}\ \ \text{(ou sur }-y\text{, filtrée)} \end{gathered}

(8)

Le choix le plus utilisé en pratique : un seul échantillon en mémoire par terme, causal (n'utilise jamais une valeur future), et toujours stable pour petit.

Tustin (trapèzes, transformation bilinéaire). Approcher l'intégrale par un TRAPÈZE plutôt qu'un rectangle — la moyenne des deux hauteurs, — donne une meilleure approximation à fixé (module 5.2 la retrouvera comme , la transformation bilinéaire, exacte en fréquence à un « gauchissement » près, hors de portée ici) :

I_k = I_{k-1} + \frac{K_iT_s}{2}\big(e_k+e_{k-1}\big)

(9)

Sur le PI du §04 (, ms), à ms : Euler arrière donne , Tustin donne — proches (l'écart relatif sur le coefficient dominant est inférieur à 1 %, puisque ), mais PAS identiques ; la troisième plongée compare les deux pôles numériques exacts.

Forme vitesse (incrémentale). Plutôt que , calculer directement l'INCRÉMENT , en différenciant (8) d'un pas à l'autre :

\Delta u_k = K_p(e_k-e_{k-1}) + K_iT_s\,e_k + \frac{K_d}{T_s}\big(e_k-2e_{k-1}+e_{k-2}\big)

(10)

Aucun état à mémoriser explicitement : l'actionneur lui-même intègre, en appliquant — souvent une vanne pas à pas, un moteur qui ne connaît que « tourne un peu plus » et « tourne un peu moins ». Deux avantages concrets : le passage manuel/automatique est naturellement sans à-coup (§3.9, plongée : ne dépend jamais d'un état absolu à réinitialiser), et un changement de gains en cours de marche ne produit pas de saut. Il reste un état à protéger : si l'actionneur physique sature, appliquer aveuglément fait quand même dériver la somme au-delà de la borne ; la forme incrémentale a besoin, elle aussi, d'un clampage de à chaque pas — ce n'est pas un anti-emballement automatique, seulement plus simple à écrire sans état intégral séparé.

3.12 Choisir la période d'échantillonnage

Deux garde-fous, dans le même esprit que Åström et Wittenmark 9 : doit être petit devant le retard (sinon le calculateur « rate » une part significative de la dynamique la plus rapide qu'il doit corriger) et petit devant la constante de temps dominante (pour que (8) et (9) approchent vraiment l'intégrale continue). Une règle de pouce robuste, cohérente avec la pratique industrielle :

T_s \le \frac{\theta}{3} \quad\text{et}\quad T_s \le \frac{\tau}{10}

Sur le modèle identifié du §04 ( ms, ms) : ms et ms — le plus contraignant des deux, ms, fixe la limite haute. Le §04 et le mini-boss retiennent ms, confortablement en dessous des deux bornes. Trop grand, dégrade la marge de phase (le retard supplémentaire de l'échantillonneur-bloqueur, module 5.2, s'ajoute au retard du procédé) ; trop petit, il charge inutilement le calculateur pour un gain de précision qui ne sert plus à rien face au bruit de mesure.

Euler arrière contre Tustin : deux pôles numériques différentsNiveau 2

Comparons les deux discrétisations du PI du §04 (, s, s), en transformant en l'expression continue par les deux règles. Euler arrière remplace par (l'intégrale (8), transformée en ) ; Tustin le remplace par (l'intégrale trapézoïdale (9)) :

\begin{gathered} C_{\text{Euler}}(z) = \frac{(K_c+K_iT_s)\,z - K_c}{z-1} \\ C_{\text{Tustin}}(z) = \frac{\big(K_c+\tfrac{K_iT_s}{2}\big)z - \big(K_c-\tfrac{K_iT_s}{2}\big)}{z-1} \end{gathered}

Numériquement, avec et :

Méthode	Numérateur
Euler arrière
Tustin

Les deux DÉNOMINATEURS sont identiques (, l'intégrateur numérique pur reste un pôle en quelle que soit la méthode — l'erreur statique s'annule toujours en régime permanent). Les NUMÉRATEURS diffèrent d'environ 0,6 % sur le terme dominant : négligeable ici parce que ms est très petit devant ms (rapport ). L'écart grandirait, et la stabilité en discret pourrait en dépendre, pour un plus proche de — une raison de plus de respecter la règle de pouce du §3.12. Vérifié dans l'autotest par NF.ctrl.c2d (méthode 'tustin') comparé à la formule d'Euler arrière écrite à la main.

§ 04

L'exemple à la main

4.1 Le procédé : le moteur, en vitesse, en boucle ouverte

Le moteur du fil rouge (module 2.1) : , mH, N·m/A, kg·m², frottement négligé. Sa fonction de transfert tension → vitesse, établie au module 2.1 :

\begin{gathered} \frac{\Omega(s)}{U(s)} = \frac{K}{LJs^2+RJs+K^2} \\ = \frac{8000}{s^2+100s+1600} = \frac{8000}{(s+20)(s+80)} \end{gathered}

Un vrai second ordre, sans le moindre retard physique — et pourtant, sa réponse à un échelon est bien en S (aucun dépassement, un seul point d'inflexion) : exactement le cas où la méthode de la tangente (§3.2) donne un modèle FOPDT approché, pas exact.

4.2 Identifier le modèle FOPDT : la tangente à l'inflexion

Échelon V (l'alimentation nominale). La réponse s'écrit, par décomposition en éléments simples (module 2.1) :

y(t) = 120 - 160\,\mathrm e^{-20t} + 40\,\mathrm e^{-80t} \quad\text{(rad/s)}

de valeur finale rad/s (soit rad/s/V, le gain statique). Sa dérivée, , est nulle en (pas de saut initial, la signature d'un système d'ordre 2 sans zéro) et maximale au point d'inflexion, où :

\begin{gathered} -64000\,\mathrm e^{-20t^*} + 256000\,\mathrm e^{-80t^*} = 0 \;\Longrightarrow\; \mathrm e^{-60t^*} = \frac14 \\ \Longrightarrow\; t^* = \frac{\ln 4}{60} = 23{,}105\text{ ms} \end{gathered}

En : rad/s, (rad/s)/s. La tangente en ce point est la droite ; elle coupe en (2) et atteint en — sur une DROITE, cette seconde distance vaut toujours , quel que soit le point de départ choisi sur la droite :

Grandeur	Formule	Valeur
point d'inflexion		23,105 ms
pente à l'inflexion		1511,905 (rad/s)/s
retard apparent		6,235 ms
constante de temps apparente		79,370 ms
gain statique		5 rad/s/V

Le modèle identifié : . Le rapport reste petit — cohérent avec un « faux retard » né d'un second pôle proche, pas d'un vrai transport.

4.3 Ziegler-Nichols, boucle ouverte

Avec , ms, ms, le tableau du §3.3 (PID) :

\begin{gathered} K_c = \frac{1{,}2\times 0{,}07937}{5\times 0{,}006235} = 3{,}0552 \\ T_i = 2L = 12{,}470\text{ ms} \\ T_d = 0{,}5L = 3{,}117\text{ ms} \end{gathered}

Soit, en gains parallèles (module 4.1) : , .

4.4 Ziegler-Nichols, boucle fermée

La condition de phase (3), , résolue numériquement (dichotomie, comme NF.ctrl.marginDelay) :

\begin{gathered} \omega_u = 259{,}713\text{ rad/s} \\ T_u = \frac{2\pi}{\omega_u} = 24{,}193\text{ ms} \\ K_u = \frac{\sqrt{1+(0{,}07937\,\omega_u)^2}}{5} = 4{,}1275 \end{gathered}

D'où, par le tableau du §3.4 (PID) : , ms, ms (, ) — proche du réglage boucle ouverte (§4.3) sans lui être égal, comme annoncé au §3.4.

4.5 SIMC : plusieurs choix de

Par (4), avec , ms, ms — remarque : pour , le plafond est plus petit que et s'applique ; au-delà, se fige à :

τc	Kc	Ti	caractère
(serré)	1,2730	49,879 ms	agressif
	0,8487	74,818 ms	intermédiaire
	0,6365	79,370 ms	retenu au mini-boss
(prudent)	0,1854	79,370 ms	lent, aucun dépassement

4.6 Comparer les réglages sur le VRAI moteur (boucle linéaire, sans saturation)

Les gains sont calculés sur le modèle APPROCHÉ (FOPDT) ; appliqués en boucle fermée sur le vrai second ordre du §4.1 (sans le retard, qui n'existe pas physiquement), avec la même marche de consigne, et les mêmes définitions du dépassement et du temps de montée qu'au module 2.3 8 :

Réglage	Dépassement	Temps de montée (10–90 %)
Ziegler-Nichols, boucle ouverte	43,9 %	7,6 ms
Ziegler-Nichols, boucle fermée	47,8 %	8,5 ms
SIMC,	25,8 %	14,4 ms
SIMC,	9,4 %	21,2 ms
SIMC,	2,0 %	28,2 ms
SIMC,	0,0 %	192,2 ms

Le tableau chiffre exactement le défaut annoncé au §3.5 : Ziegler-Nichols, réglé pour un rapport de décroissance au quart, dépasse d'environ 45 % de sa valeur finale — bien au-delà des 5 % que le mini-boss exigera. SIMC, en choisissant explicitement , permet de viser directement un dépassement acceptable : reste confortablement sous 5 % (2,0 %, avec de la marge avant même d'ajouter la saturation), retenu comme réglage de référence pour le §07.

§ 05

Le code

La version outillée identifie le FOPDT par différence numérique sur la réponse de control.step_response, résout la condition de phase (3) par dichotomie (scipy.optimize.brentq), et vérifie la discrétisation avec control.c2d 10. La version à la main reprend les mêmes calculs avec les formules exactes du §04, plus une simulation non linéaire complète (moteur + PID discret + saturation + anti-emballement), en RK4 écrit à la main — exactement l'algorithme que NF.ctrl.rk4 encapsule, et celui que le §06 recompile en C. MATLAB ferait le même calcul avec le System Identification Toolbox et pidtune 11.


import numpy as np
import control as ct
from scipy.optimize import brentq

# Moteur en vitesse, boucle ouverte (module 2.1)
G = ct.tf([8000], [1, 100, 1600])
t = np.linspace(0, 0.3, 300001)
y = 24*ct.step_response(G, t).outputs          # echelon de 24 V
dy = np.gradient(y, t)
i_star = np.argmax(dy)                          # point d'inflexion : pente max
t_star, y_star, slope = t[i_star], y[i_star], dy[i_star]
yfinal = 24*ct.dcgain(G)
L = t_star - y_star/slope                       # retard apparent
T = yfinal/slope                                 # constante de temps apparente (droite tangente)
K = yfinal/24
print(f"K={K:.4f} rad/s/V  L={L*1000:.3f} ms  T={T*1000:.3f} ms")
# -> K=5.0000 rad/s/V  L=6.235 ms  T=79.370 ms

Kc_ol, Ti_ol, Td_ol = 1.2*T/(K*L), 2*L, 0.5*L
print(f"ZN-BO : Kc={Kc_ol:.4f}  Ti={Ti_ol*1000:.3f} ms  Td={Td_ol*1000:.3f} ms")
# -> ZN-BO : Kc=3.0552  Ti=12.470 ms  Td=3.117 ms

phase = lambda w: np.arctan(w*T) + w*L - np.pi   # condition de phase -180 deg, eq. (3)
wu = brentq(phase, 1, 2000)
Tu = 2*np.pi/wu
Ku = np.sqrt(1+(T*wu)**2)/K
print(f"Ku={Ku:.4f}  Tu={Tu*1000:.3f} ms")
# -> Ku=4.1275  Tu=24.193 ms

tau_c = 3*L
Kc_s = (1/K)*T/(tau_c+L); Ti_s = min(T, 4*(tau_c+L))
print(f"SIMC (tau_c=3L) : Kc={Kc_s:.4f}  Ti={Ti_s*1000:.3f} ms")
# -> SIMC (tau_c=3L) : Kc=0.6365  Ti=79.370 ms

# discretisation, verifiee par c2d
C = ct.tf([Kc_s, Kc_s/Ti_s], [1, 0])
print(ct.c2d(C, 0.001, method='tustin'))
# -> 0.6405 z - 0.6325
#    -----------------
#          z - 1   (dt = 0.001)

# comparaison des reglages sur le VRAI moteur (2e ordre, sans le retard, qui n'existe pas physiquement)
Gmot = ct.tf([0.2], [0.02*1.25e-3, 2*1.25e-3, 0.04])
def pid_tf(Kc, Ti, Td=0.0):
    if Td == 0: return ct.tf([Kc*Ti, Kc], [Ti, 0])
    Tf = Td/10; Ki = Kc/Ti
    return ct.tf([Kc*Tf+Kc*Td, Kc+Ki*Tf, Ki], [Tf, 1, 0])
for name, (Kc, Ti, Td) in {"ZN-BO": (Kc_ol, Ti_ol, Td_ol), "SIMC": (Kc_s, Ti_s, 0.0)}.items():
    Tcl = ct.feedback(pid_tf(Kc, Ti, Td)*Gmot, 1)
    tt = np.linspace(0, 0.5, 60000)
    yy = ct.step_response(Tcl, tt).outputs
    print(name, "depassement =", round((max(yy)-yy[-1])/yy[-1]*100, 2), "%")
# -> ZN-BO depassement = 43.88 %
# -> SIMC depassement = 2.08 %


import numpy as np

# ---- identification exacte (a la main) : y(t) = 120 - 160e^-20t + 40e^-80t ----
t_star = np.log(4) / 60                                    # y''(t*) = 0
y_star = 120 - 160*np.exp(-20*t_star) + 40*np.exp(-80*t_star)
slope = 3200*(np.exp(-20*t_star) - np.exp(-80*t_star))     # y'(t*)
K = 5.0
L = t_star - y_star/slope
T = 120.0/slope
print(f"L={L*1000:.4f} ms   T={T*1000:.4f} ms")
# -> L=6.2349 ms   T=79.3701 ms

Kc_ol, Ti_ol, Td_ol = 1.2*T/(K*L), 2*L, 0.5*L

def phase(w): return np.arctan(w*T) + w*L - np.pi          # dichotomie a la main
lo, hi = 1.0, 2000.0
for _ in range(80):
    mid = 0.5*(lo+hi)
    lo, hi = (mid, hi) if phase(mid) < 0 else (lo, mid)
wu = 0.5*(lo+hi); Tu = 2*np.pi/wu; Ku = np.sqrt(1+(T*wu)**2)/K
print(f"omega_u={wu:.4f} rad/s  Tu={Tu*1000:.4f} ms  Ku={Ku:.4f}")
# -> omega_u=259.7127 rad/s  Tu=24.1928 ms  Ku=4.1275

tau_c = 3*L
Kc_s, Ti_s = (1/K)*T/(tau_c+L), min(T, 4*(tau_c+L))
print(f"SIMC : Kc={Kc_s:.4f}  Ti={Ti_s*1000:.4f} ms")
# -> SIMC : Kc=0.6365  Ti=79.3701 ms

Ts = 0.001; Ki_s = Kc_s/Ti_s
print(f"Euler arriere : ({Kc_s+Ki_s*Ts:.6f} z {-Kc_s:.6f}) / (z-1)")
print(f"Tustin        : ({Kc_s+Ki_s*Ts/2:.6f} z {-Kc_s+Ki_s*Ts/2:.6f}) / (z-1)")
# -> Euler arriere : (0.644522 z -0.636503) / (z-1)
# -> Tustin        : (0.640513 z -0.632493) / (z-1)

# ---- moteur non lineaire (RK4) + PID discret + saturation + anti-emballement ----
R, Lind, Km, J, Vmax = 2.0, 0.02, 0.2, 1.25e-3, 24.0
def deriv(x, u):
    i, w = x
    return np.array([(-R*i - Km*w + u)/Lind, Km*i/J])
def rk4(x, u, h):
    k1 = deriv(x, u); k2 = deriv(x+h/2*k1, u); k3 = deriv(x+h/2*k2, u); k4 = deriv(x+h*k3, u)
    return x + h/6*(k1+2*k2+2*k3+k4)

def run(Kc, Ti, Ts, Tt, anti_windup, r=100.0, Tsim=0.5, sub=10):
    n = int(round(Tsim/Ts)); h = Ts/sub
    x = np.zeros(2); I = 0.0; u_pu = u_ps = 0.0; Ki = Kc/Ti
    peak = 0.0; energy = 0.0
    for k in range(1, n+1):
        e = r - x[1]
        I += Ki*Ts*e + (anti_windup*(Ts/Tt))*(u_ps - u_pu)
        u_unsat = Kc*e + I
        u_sat = min(max(u_unsat, -Vmax), Vmax)
        for _ in range(sub): x = rk4(x, u_sat, h)
        u_pu, u_ps = u_unsat, u_sat
        peak = max(peak, x[1]); energy += u_sat**2*Ts
    ov = max(0.0, (peak-x[1])/x[1]*100)
    return ov, energy

for aw in [True, False]:
    ov, E = run(Kc_s, Ti_s, 0.001, Ti_s, aw)
    print(f"anti-windup={aw!s:5s} : depassement={ov:.3f}%  energie={E:.2f} V^2.s")
# -> anti-windup=True  : depassement=0.000%  energie=212.19 V^2.s
# -> anti-windup=False : depassement=14.023%  energie=233.04 V^2.s


% Identification FOPDT depuis la reponse indicielle enregistree (module 2.1)
G = tf(8000, [1 100 1600]);
[y, t] = step(24*G, 0:1e-6:0.3);
info = stepinfo(24*G);                    % lecture directe des caracteristiques

% Ziegler-Nichols boucle ouverte : Kc = 1.2 T/(K L), Ti = 2L, Td = 0.5L
K = 5; L = 6.235e-3; T = 79.370e-3;
Kc_ol = 1.2*T/(K*L); Ti_ol = 2*L; Td_ol = 0.5*L;

% SIMC : pidtune avec un modele reduit, ou directement (4)
tau_c = 3*L;
Kc_s = (1/K)*T/(tau_c+L);
Ti_s = min(T, 4*(tau_c+L));
C = pid(Kc_s, Kc_s/Ti_s);

Gmot = tf(0.2, [0.02*1.25e-3 2*1.25e-3 0.04]);
Tcl = feedback(C*Gmot, 1);
S = stepinfo(Tcl);
disp(S.Overshoot)
% -> 2.08          (valeur deterministe, identique au calcul Python ci-contre)

% Discretisation, Ts = 1 ms
Cd_tustin = c2d(C, 1e-3, 'tustin');
disp(Cd_tustin)
% -> 0.6405 z - 0.6325
%    -----------------
%          z - 1

python-control 0.10.2, NumPy 2.4.6, SciPy 1.17.1 : les deux premiers blocs ont réellement tourné ici, les sorties en commentaire sont leur impression exacte. MATLAB (Control System Toolbox) n'est pas exécutable dans cet environnement : l'onglet affiche la structure d'un script réel (step, pid, feedback, stepinfo, c2d) et les deux seules valeurs numériques données — le dépassement SIMC et le correcteur discrétisé par Tustin — sont celles, déterministes, que les blocs python-control et NumPy ont calculées à l'identique.

§ 06

Le cas industriel

Un variateur de vitesse industriel n'exécute jamais un PID continu : c'est une boucle logicielle, sur un microcontrôleur, cadencée à une fréquence fixe — couramment entre 1 et 20 kHz pour une boucle de courant, quelques centaines de hertz à quelques kilohertz pour une boucle de vitesse (le rapport 10 entre les deux, chaque boucle interne étant plus rapide que celle qu'elle sert, est une règle de conception classique de commande en cascade). Le nôtre, sur le moteur du fil rouge, tourne à kHz — cohérent avec le §3.12 — et doit tenir dans un budget de calcul de quelques microsecondes par cycle sur un microcontrôleur à quelques dizaines de mégahertz : pas de bibliothèque, pas d'allocation dynamique, une poignée d'opérations en virgule flottante (ou en fixe, sur les cibles les plus contraintes). Le code ci-dessous est exactement cela : le PID SIMC du §04 (, ms), discrétisé par Euler arrière (8), avec anti-emballement par recalcul (6), — la simulation du moteur (RK4, exactement NF.ctrl.rk4) sert ici de banc d'essai logiciel, comme le ferait un simulateur temps réel avant la mise en service sur le vrai variateur.


/* PID discret avec anti-emballement par recalcul (back-calculation), moteur DC.
   Compile : gcc -O2 -o pid_embarque pid_embarque.c -lm
   Execute : ./pid_embarque                                                   */
#include <stdio.h>
#include <math.h>

#define R 2.0
#define L 0.02
#define KM 0.2
#define J 1.25e-3
#define VMAX 24.0

typedef struct { double i, w; } State;

static State plant_deriv(State x, double u, double Gamma_c) {
    State d;
    d.i = (-R*x.i - KM*x.w + u) / L;
    d.w = (KM*x.i - Gamma_c) / J;
    return d;
}
static State add_scaled(State a, State b, double s) {
    State r; r.i = a.i + s*b.i; r.w = a.w + s*b.w; return r;
}
static State rk4_step(State x, double u, double h, double Gamma_c) {
    State k1 = plant_deriv(x, u, Gamma_c);
    State k2 = plant_deriv(add_scaled(x, k1, h/2), u, Gamma_c);
    State k3 = plant_deriv(add_scaled(x, k2, h/2), u, Gamma_c);
    State k4 = plant_deriv(add_scaled(x, k3, h), u, Gamma_c);
    State sum = { k1.i+2*k2.i+2*k3.i+k4.i, k1.w+2*k2.w+2*k3.w+k4.w };
    return add_scaled(x, sum, h/6.0);
}

typedef struct {
    double Kp, Ki, Kd, Tf, Ts, Tt;
    int anti_windup;
    double I, Df, y_prev, u_prev_unsat, u_prev_sat;
} PID;

/* Un cycle de regulation : appele toutes les Ts secondes par le timer du MCU. */
static double pid_step(PID *c, double r, double y) {
    double e = r - y;
    if (c->anti_windup)
        c->I += c->Ki * c->Ts * e + (c->Ts / c->Tt) * (c->u_prev_sat - c->u_prev_unsat);
    else
        c->I += c->Ki * c->Ts * e;                          /* (5), sans protection */
    double P = c->Kp * e;
    double u_unsat = P + c->I;                                /* Kd = 0 (PI SIMC) */
    double u_sat = u_unsat;
    if (u_sat > VMAX) u_sat = VMAX;
    if (u_sat < -VMAX) u_sat = -VMAX;
    c->y_prev = y; c->u_prev_unsat = u_unsat; c->u_prev_sat = u_sat;
    return u_sat;                                              /* vers le PWM du pont en H */
}

int main(void) {
    double Ts = 0.001, r = 100.0, Tsim = 0.5;
    int sub = 10;                                              /* sous-pas RK4 par cycle PID */
    double h = Ts / sub;
    int n = (int)round(Tsim / Ts);
    double Kp = 0.6365, Ti = 0.079370, Ki = Kp/Ti;

    for (int aw = 1; aw >= 0; aw--) {
        PID c = { Kp, Ki, 0.0, 0.0, Ts, Ti, aw, 0.0, 0.0, 0.0, 0.0, 0.0 };
        State x = { 0.0, 0.0 };
        double peak = 0.0, energy = 0.0, t10 = -1.0, t90 = -1.0;
        for (int k = 1; k <= n; k++) {
            double u = pid_step(&c, r, x.w);
            for (int s = 0; s < sub; s++) x = rk4_step(x, u, h, 0.0);
            double t = k * Ts;
            if (x.w > peak) peak = x.w;
            energy += u*u*Ts;
            if (t10 < 0 && x.w >= 0.1*r) t10 = t;
            if (t90 < 0 && x.w >= 0.9*r) t90 = t;
        }
        double overshoot = (peak > x.w) ? (peak - x.w) / x.w * 100.0 : 0.0;
        printf("anti-windup=%d : y_final=%.4f peak=%.4f overshoot=%.4f%% t10-90=%.2fms E=%.4f\n",
               aw, x.w, peak, overshoot, (t90-t10)*1000.0, energy);
    }
    return 0;
}

Compilé et exécuté ici avec gcc -O2 (glibc, -lm) : anti-windup=1 : y_final=99.9362 peak=99.9362 overshoot=0.0000% t10-90=71.00ms E=212.1909 puis anti-windup=0 : y_final=100.3796 peak=114.4558 overshoot=14.0230% t10-90=71.00ms E=233.0378 — exactement les nombres du §05 (NumPy), à l'arrondi près, puisque c'est le même algorithme en deux langages.

Trois différences avec un vrai firmware, honnêtes à signaler : ce code utilise des double quand un microcontrôleur d'entrée de gamme travaille souvent en virgule fixe (16 ou 32 bits) pour économiser un FPU absent — les formules ne changent pas, seule l'arithmétique change, avec un soin supplémentaire pour éviter le débordement de ; la mesure de vitesse viendrait d'un capteur (codeur incrémental, résolveur), avec son propre bruit et sa propre latence, non modélisés ici ; et la commande piloterait un pont en H en modulation de largeur d'impulsions (PWM), pas une tension continue idéale — le filtre du bobinage moteur (l'inductance elle-même) lisse suffisamment le signal PWM pour que le modèle continu reste valide, à condition que la fréquence de découpage PWM dépasse largement (typiquement par un facteur 10 à 50 en pratique).

§ 07

Le mini-boss

Le mini-boss du monde 4 : asservir la vitesse du moteur du fil rouge à 100 rad/s, tension bornée à ±24 V, sans dépasser 5 % de dépassement, avec un correcteur PID discret ( ms) qui tourne en boucle sur le moteur RÉEL — pas le modèle FOPDT, la simulation non linéaire complète, pas à pas, en RK4 (le §06). Trois curseurs (, , ), un bouton pour choisir la stratégie anti-emballement (aucune, recalcul, intégration conditionnelle) et son réglage (). Le score, sur 100, combine trois exigences : le respect du dépassement (poids dominant — un dépassement au-delà de 5 % effondre le score), la rapidité (temps de montée 10–90 %, entre le minimum physique imposé par la saturation, 70 ms, et 150 ms), et l'énergie de commande (, moins il en faut, mieux c'est). Seuil de réussite : 70/100.

Le mini-boss : asservir le moteur sans dépassement, tension bornée

Règle Kp, Ki, Kd ; choisis une stratégie anti-emballement (indispensable : essaie d'abord sans, regarde le dépassement). Score ≥ 70/100 pour réussir.

7.1 Ce que le score récompense vraiment

Le §04 a déjà trouvé un réglage de référence : SIMC, (, ms), qui, sur la boucle LINÉAIRE sans saturation, dépassait de 2,0 % (§4.6). Sur le moteur RÉEL, saturé, avec anti-emballement actif, ce même réglage ne dépasse même plus du tout : la saturation, en limitant la tension au démarrage, joue elle-même un rôle de frein sur l'à-coup initial — un effet que le §04 ne pouvait pas voir, puisqu'il travaillait sans elle. Sans anti-emballement, ce même réglage dépasse de 14 %, largement recalé. Et même un réglage bien plus agressif — Ziegler-Nichols boucle ouverte, , presque cinq fois plus fort — reste sous 3 % de dépassement À CONDITION que l'anti-emballement soit actif : c'est lui, plus que le choix fin des gains, qui décide si le moteur passe ou casse le seuil.

Réglage	Anti-emballement	Dépassement	t10-90	Énergie
SIMC ()	recalcul,	0,0 %	71 ms	212,2 V²·s
SIMC ()	aucun	14,0 %	71 ms	233,0 V²·s
Ziegler-Nichols BO	recalcul,	2,5 %	71 ms	216,9 V²·s
Ziegler-Nichols BO	aucun	20,1 %	71 ms	262,0 V²·s

7.2 Ce que la démonstration calcule vraiment

Le procédé n'est jamais un modèle linéaire : à chaque cycle de 1 ms, le PID discret (Euler arrière, anti-emballement au choix) calcule une tension, saturée à ±24 V, appliquée en escalier (bloqueur d'ordre zéro) au vrai système d'équations du moteur (module 2.1), intégré par NF.ctrl.rk4 avec dix sous-pas par cycle. Le score suit la formule , avec sous 5 % de dépassement (et décroît ensuite), et qui interpolent linéairement entre un plancher et un plafond mesurés sur le moteur réel. L'autotest vérifie :

le réglage SIMC de référence, avec recalcul, atteint un score supérieur à 90 — le seuil de 70 est largement atteignable ;
le même réglage SANS anti-emballement retombe sous 45 — la protection n'est pas cosmétique, elle décide de la réussite ;
un réglage trop lent (Kp trop petit) échoue par lenteur même sans jamais dépasser, prouvant que la vitesse compte vraiment dans le score, pas seulement l'absence de dépassement ;
le temps de montée mesuré ne descend jamais sous le plancher physique de 70 ms (la butée de tension impose une accélération maximale, indépendante des gains) — vérifié contre le calcul analytique en boucle ouverte à tension constante du §08 ;
pour dix couples de gains tirés au hasard, la commande appliquée ne dépasse jamais ±24 V et l'énergie calculée coïncide avec recalculée indépendamment.

§ 08

Les pièges

8.1 Confondre le retard apparent avec un vrai retard de transport

Symptôme. Sur le moteur du §04, purement du second ordre, la tangente identifie ms « de retard » — et on cherche ce qui, physiquement, retarde le signal (un capteur, un bus de communication), sans rien trouver. Cause. Le retard apparent d'un FOPDT est un artefact de la réduction d'ordre (§3.1, §3.2) : un second pôle proche du premier produit, vu de loin, exactement la même signature qu'un petit retard pur. Rien ne transporte réellement le signal ici. Remède. Ne jamais interpréter comme un délai physique sans vérification indépendante (un vrai transport, un temps de calcul, un bus) ; sur un procédé d'ordre 2 ou plus sans retard réel, reste un paramètre de MODÈLE, utile pour régler un PID, pas une mesure d'un phénomène physique nommé.

8.2 Appliquer Ziegler-Nichols tel quel à un suivi de consigne

Symptôme. Un axe asservi en position avec les gains ZN du tableau (§3.3, §3.4) dépasse de 40 à 50 % à chaque changement de consigne (§4.6) — inacceptable pour un positionnement précis. Cause. Les tableaux ZN visent le rejet d'une perturbation de charge avec un rapport de décroissance au quart (§3.5), pas le suivi d'un échelon de consigne : ce sont deux objectifs différents, et un bon réglage pour l'un peut être médiocre pour l'autre. Remède. Pour du suivi de consigne, préférer SIMC avec un choisi pour le dépassement voulu (§4.5), ou garder les gains ZN pour le rejet de perturbation et ajouter une pondération de consigne (7) qui adoucit spécifiquement la réponse à un échelon de sans toucher au rejet de charge.

8.3 Régler en simulation linéaire, découvrir la saturation en service

Symptôme. Un réglage qui semblait propre (peu de dépassement) en simulation linéaire (§4.6) se comporte très différemment une fois câblé sur le vrai actionneur, avec un dépassement bien plus grand ou une réponse qui traîne. Cause. La simulation linéaire ne voit jamais la butée d'actionneur ; l'emballement de l'intégrale (§3.7) n'existe que sous saturation, donc jamais dans un modèle qui ne la modélise pas. Remède. Toujours simuler AVEC la saturation et l'anti-emballement avant la mise en service (§06, §07) — pas à pas (RK4 ou Euler), jamais avec un outil de simulation linéaire qui ignore la borne.

8.4 Oublier l'anti-emballement

Symptôme. Un grand échelon de consigne provoque un dépassement massif et une reprise lente, alors qu'un petit échelon (qui ne sature jamais l'actionneur) se comporte parfaitement avec les MÊMES gains. Cause. L'intégrale s'est emballée pendant la saturation (§3.7) — le symptôme n'apparaît que pour les grands échelons, précisément parce que ce sont eux qui saturent l'actionneur assez longtemps pour que dérive significativement. Remède. Un anti-emballement (recalcul §3.8 ou intégration conditionnelle §3.9) N'EST PAS optionnel dès qu'un actionneur peut saturer — le §07 le chiffre : jusqu'à 14 à 20 points de dépassement gagnés ou perdus, pour le même triplet de gains.

8.5 Croire qu'un gain plus grand va toujours plus vite

Symptôme. Multiplier par 5 (§07, comparer SIMC et Ziegler-Nichols boucle ouverte) ne change presque pas le temps de montée mesuré — toujours proche de 71 ms. Cause. Une fois l'actionneur saturé pendant l'essentiel de la montée, c'est la tension MAXIMALE, pas le gain, qui fixe l'accélération : un calcul en boucle ouverte à 24 V constants donne exactement ms sur ce moteur (résolution de et sur la réponse du §4.2, à 24 V) — un plancher physique qu'aucun gain, même infini, ne peut franchir. Remède. Reconnaître quand la limite vient de l'ACTIONNEUR plutôt que du réglage : au-delà d'un certain point, monter les gains n'accélère plus rien, ajoute seulement de l'énergie de commande et du risque de dépassement une fois l'actionneur désaturé.

8.6 Mal choisir dans le recalcul

Symptôme. L'anti-emballement par recalcul (6) semble presque inutile (dépassement à peine réduit) ou, à l'inverse, produit lui-même une réponse saccadée. Cause. trop grand freine l'intégrale trop lentement (presque comme sans anti-emballement) ; trop petit réagit à la moindre incursion en saturation et peut lui-même introduire une dynamique parasite dans . Remède. Suivre la fourchette d'Åström et Hägglund (§3.8) : entre et , pour un PI pur — le réglage vérifié tout du long de ce module.

8.7 Discrétiser avec une période trop grande

Symptôme. Un PID réglé en continu (§04) et qui semblait stable devient oscillant, voire instable, une fois implémenté à une période d'échantillonnage choisie « au hasard », plus grande que celle du §3.12. Cause. Un échantillonneur-bloqueur ajoute un retard supplémentaire, de l'ordre de (module 5.2) : additionné au retard déjà présent (), il grignote la marge de phase que le réglage continu supposait acquise. Remède. Respecter et (§3.12) ; si le calculateur ne peut pas tenir cette cadence, re-régler le PID en tenant compte du réel plutôt que de le traiter comme continu.