Qu'est-ce qu'un régulateur PID et comment l'implémenter dans le firmware

14 juin 2026 · 8 min de lecture

Si votre produit doit maintenir une variable à une valeur cible —la vitesse d'un moteur, la température d'un four, la position d'un bras, la pression d'une pompe— tôt ou tard vous rencontrerez la régulation PID. C'est l'algorithme de régulation le plus utilisé dans l'industrie, et bien le comprendre fait toute la différence entre un produit qui répond en douceur et un autre qui oscille, dépasse la consigne ou réagit trop tard.

Qu'est-ce qu'un régulateur PID

Un régulateur PID (Proportionnel-Intégral-Dérivé) est un algorithme qui ajuste en continu une sortie pour qu'une mesure réelle se rapproche d'une valeur souhaitée, appelée référence ou consigne (setpoint). Il le fait en calculant l'erreur (la différence entre ce que vous voulez et ce que vous avez) et en la corrigeant à partir de trois composantes qui travaillent ensemble.

Les trois composantes : P, I et D

• Proportionnelle (P) : réagit à l'erreur actuelle. Plus vous êtes loin de la cible, plus elle corrige fort. Elle augmente la vitesse de réponse, mais à elle seule elle laisse une petite erreur permanente et, si elle est trop élevée, provoque des oscillations.
• Intégrale (I) : accumule l'erreur passée. C'est elle qui élimine cette erreur permanente : tant qu'il reste un écart, elle continue de pousser jusqu'à atteindre exactement la valeur. En contrepartie, si l'on exagère, elle ralentit et peut provoquer un dépassement (overshoot).
• Dérivée (D) : anticipe l'erreur future en observant la vitesse à laquelle elle change. Elle agit comme un frein qui adoucit la réponse et réduit le dépassement, mais elle amplifie le bruit du capteur, il faut donc l'utiliser avec précaution.

La sortie du régulateur est la somme des trois : u(t) = Kp·e + Ki·∫e·dt + Kd·de/dt. Régler les gains Kp, Ki et Kd est ce qui définit le caractère du système.

Un exemple simple : la vitesse d'un moteur

Imaginez un moteur qui doit tourner à 1 000 tr/min. Vous mesurez les tr/min réels avec un encodeur, vous les soustrayez aux 1 000 souhaités et vous obtenez l'erreur. Le PID convertit cette erreur en un signal PWM qui alimente le moteur : s'il va lentement, il augmente le PWM ; s'il dépasse, il le baisse. L'encodeur mesure à nouveau et le cycle se répète des dizaines ou des centaines de fois par seconde. Le résultat est un moteur qui maintient sa vitesse même quand la charge change —exactement ce que fait le régulateur de vitesse d'une voiture dans une côte—.

Comment l'implémenter dans le firmware

Sur un microcontrôleur, le PID est calculé dans une boucle à intervalle fixe (par exemple, toutes les 10 ms depuis une interruption de minuterie). Une implémentation discrète de base en C ressemble à ceci :

typedef struct {
    float kp, ki, kd;
    float integral, prev_error;
    float out_min, out_max;   // límites de la salida
} pid_t;

float pid_update(pid_t *pid, float setpoint, float measured, float dt) {
    float error = setpoint - measured;
    pid->integral += error * dt;
    float derivative = (error - pid->prev_error) / dt;
    pid->prev_error = error;

    float out = pid->kp * error
              + pid->ki * pid->integral
              + pid->kd * derivative;

    // Saturación + anti-windup: no dejes crecer la integral sin límite
    if (out > pid->out_max) { out = pid->out_max; pid->integral -= error * dt; }
    if (out < pid->out_min) { out = pid->out_min; pid->integral -= error * dt; }
    return out;
}

Les détails qui séparent un PID jouet d'un PID professionnel se trouvent dans ce qui entoure cette formule : un dt constant et bien mesuré, la saturation de la sortie avec anti-windup (pour que l'intégrale ne s'emballe pas quand l'actionneur atteint sa limite), le filtrage du terme dérivé et l'utilisation d'une arithmétique appropriée (entière ou à virgule fixe) sur les MCU sans unité à virgule flottante.

Comment régler (tuner) un PID

• Commencez avec P seul : augmentez-le jusqu'à ce que le système réponde rapidement mais juste avant qu'il ne commence à osciller.
• Ajoutez I progressivement pour éliminer l'erreur permanente, sans exagérer (cela provoque un dépassement).
• Utilisez D avec modération pour amortir, seulement si le bruit du capteur le permet.
• Des méthodes comme Ziegler-Nichols donnent un point de départ, mais le réglage fin est presque toujours empirique et dépend de votre matériel réel.

Erreurs courantes

• Calculer le PID avec un dt variable (par exemple à l'intérieur d'une loop() sans contrôle du temps) : les résultats deviennent imprévisibles.
• Oublier l'anti-windup : le système répond avec un retard énorme après avoir saturé.
• Appliquer la dérivée directement sur un signal bruité, ce qui injecte des vibrations dans l'actionneur.
• Vouloir tout résoudre avec un PID quand le procédé a de grands retards ou des non-linéarités : il faut parfois une autre stratégie.

Conclusion

Un PID bien implémenté est la différence entre un produit qui inspire confiance et un autre qui vibre, surchauffe ou réagit tard. Le concept est simple, mais le rendre robuste sur un microcontrôleur réel —avec sa temporisation, son bruit et les limites de l'actionneur— est un travail de firmware fin. Chez Regular Solids, nous concevons et implémentons des boucles de régulation pour moteurs, température, puissance et mouvement dans des produits embarqués. Si vous avez un produit qui doit contrôler quelque chose avec précision, parlez-nous-en.