Régulateur PID Arduino : régler Kp, Ki, Kd avec des exemples
Comment fonctionne un régulateur PID ? Termes P, I, D, bibliothèque Arduino PID, réglage de Kp/Ki/Kd, exemple de chauffage et robot suiveur de ligne.
Un régulateur PID est une méthode de rétroaction qui calcule en continu l'écart (l'erreur) entre la valeur mesurée et la consigne, puis ajuste la sortie en fonction de cet écart pour maintenir un système à la valeur voulue. Dans les projets Arduino, on l'utilise pour garder un chauffage à 45 °C pile, faire tourner un moteur à vitesse constante ou guider un robot suiveur de ligne au milieu de la piste. Son nom vient de ses trois composantes : le terme proportionnel (P) regarde l'erreur présente, le terme intégral (I) l'erreur accumulée dans le passé, et le terme dérivé (D) la vitesse à laquelle l'erreur change. La somme pondérée des trois donne la valeur PWM envoyée au moteur ou au chauffage.
Les formules font peur au premier abord, mais la logique du PID ressemble beaucoup à ce que tu fais sans y penser en conduisant. Dans cet article, tu vas d'abord voir pourquoi la régulation tout ou rien oscille, puis découvrir les trois termes avec des exemples intuitifs. Ensuite, tu réaliseras une régulation de température avec la bibliothèque Arduino PID, une NTC et un MOSFET, tu apprendras à régler Kp, Ki et Kd pas à pas, et tu piloteras un robot suiveur de ligne avec un PID écrit sans bibliothèque. Enfin, nous ferons tourner le même algorithme sur ESP32 et sur Raspberry Pi Pico en MicroPython.
Pourquoi la régulation tout ou rien ne suffit pas
La méthode la plus simple est la régulation tout ou rien (on-off) : si la température est sous la consigne, on allume le chauffage à pleine puissance, sinon on l'éteint. Le thermostat d'une chaudière ou un chauffage d'aquarium fonctionnent en grande partie ainsi. Le problème : quand le chauffage s'éteint, la chaleur stockée continue de se diffuser, donc la température dépasse la consigne de quelques degrés. Ensuite, en refroidissant, elle passe sous la consigne le temps que le chauffage se rallume et chauffe. Résultat : une dent de scie permanente autour de la consigne. Pour l'adoucir, on laisse un écart (hystérésis) entre deux seuils ; le relais clique moins, mais l'amplitude de l'oscillation augmente. Pour un plateau d'imprimante 3D, une couveuse ou un moteur à vitesse constante où tu dois rester à ±0,5 °C, ce n'est pas suffisant. Le PID, lui, produit une sortie progressive entre pleine puissance et zéro, et réduit la puissance à l'avance à l'approche de la consigne.
| Méthode | Comment elle décide | Avantage | Inconvénient | Usage typique |
|---|---|---|---|---|
| Tout ou rien (on-off) | Pleine puissance sous la consigne, coupé au-dessus | Très simple, faisable avec un simple relais | Oscillation et dépassement permanents, usure du relais | Thermostat de chaudière, chauffage d'aquarium |
| P | Sortie proportionnelle à l'erreur | Réaction douce, réglage facile | Une erreur permanente subsiste | Contrôle simple de position et de niveau |
| PI | Proportionnel + erreur accumulée | Supprime l'erreur permanente | Plus de dépassement, saturation de l'intégrale | Contrôle de température, de débit et de vitesse de moteur |
| PID | Proportionnel + erreur accumulée + vitesse de variation | Rapide, peu de dépassement, précis | Réglage difficile, sensible au bruit | Imprimante 3D, drone, robot équilibriste, robot suiveur de ligne |
Qu'est-ce qu'un régulateur PID et comment fonctionne-t-il ?
À chaque boucle, le PID calcule d'abord l'erreur : erreur = valeur cible (setpoint) − valeur mesurée (input). Il traite ensuite cette erreur de trois façons et additionne le tout : sortie = Kp·e + Ki·∫e·dt + Kd·de/dt. Kp, Ki et Kd sont les coefficients que tu règles ; ils déterminent la contribution de chaque terme à la sortie. Sur un microcontrôleur, l'intégrale se calcule en ajoutant à chaque échantillon le produit de l'erreur par la période d'échantillonnage, et la dérivée en divisant la différence des deux dernières mesures par cette période. Pour que le PID fonctionne bien, il est donc important de mesurer à intervalles réguliers, par exemple toutes les 10 ms ou toutes les 500 ms. Imagine que tu suis une voie en voiture : plus tu t'éloignes de la voie, plus tu tournes le volant (P) ; si un vent latéral te pousse sans cesse, tu apprends à garder le volant légèrement braqué (I) ; et en te rapprochant vite de la voie, tu redresses le volant plus tôt (D).
| Terme | Ce qu'il regarde | Analogie intuitive | S'il est trop fort |
|---|---|---|---|
| P (proportionnel) | L'erreur présente | Plus tu t'éloignes de la voie, plus tu tournes le volant | Oscillations rapides, tremblements |
| I (intégral) | L'erreur accumulée dans le temps | Avec du vent latéral, tu apprends à garder le volant légèrement braqué | Oscillations lentes et larges, gros dépassement |
| D (dérivé) | La vitesse de variation de l'erreur | En approchant vite de la voie, tu redresses plus tôt | Réaction excessive au bruit, sortie qui tremble |
Terme proportionnel (P) : une réaction proportionnelle à l'erreur
Le terme proportionnel règle la sortie proportionnellement à l'amplitude de l'erreur. Avec Kp = 20, une erreur de 3 °C donne 60 unités PWM et une erreur de 1 °C en donne 20 ; la puissance diminue d'elle-même à l'approche de la consigne. Plus tu augmentes Kp, plus le système réagit vite, mais au-delà d'un certain point il dépasse la consigne et se met à osciller. Une régulation uniquement P a une faiblesse importante : l'erreur statique (steady-state error). Supposons que pour maintenir le chauffage à 45 °C, il faille une puissance continue de 80 unités pour compenser les pertes. Avec le seul terme P, ces 80 unités ne peuvent être produites que s'il y a une erreur : 80 / 20 = 4 °C. Le système se stabilise donc vers 41 °C et n'atteint jamais la consigne. Augmenter Kp réduit cet écart, mais augmente aussi l'oscillation.
Terme intégral (I) : il efface l'erreur permanente
Le terme intégral additionne l'erreur au fil du temps. Même une petite erreur qui dure finit par faire grossir la somme, et la sortie augmente peu à peu jusqu'à ce que l'erreur disparaisse. Dans l'exemple précédent, c'est désormais le terme intégral qui fournit les 80 unités nécessaires, le terme P retombe à zéro et la température se stabilise à 45 °C pile. Plus Ki est grand, plus vite l'erreur permanente se ferme ; s'il est trop grand, le système oscille lentement et largement. Un piège classique de l'intégrale est la saturation de l'intégrale (windup) : si le chauffage est déjà à pleine puissance et n'atteint pas la consigne, l'intégrale continue de grossir pour rien, et quand la consigne est atteinte, cette valeur accumulée maintient la température au-dessus de la consigne pendant longtemps. La solution est de limiter l'intégrale avec les bornes de sortie ; la bibliothèque Arduino PID le fait automatiquement avec SetOutputLimits.
Terme dérivé (D) : il freine à l'approche de la consigne
Le terme dérivé regarde la vitesse de variation de l'erreur et apporte une forme d'anticipation. Si la température approche vite de la consigne, l'erreur diminue vite ; le terme D agit alors en sens inverse, coupe la puissance plus tôt et réduit le dépassement (overshoot). Sur un robot, c'est pareil : un robot qui tourne vite vers la ligne adoucit son virage avant de la franchir. Le point faible du terme D est sa sensibilité au bruit. Si la lecture d'un capteur analogique saute de quelques unités à chaque mesure, la dérivée voit ces petits sauts comme de grosses variations et la sortie tremble. Il faut donc moyenner ou filtrer la lecture du capteur ; pour les détails, consulte l'article filtrage des données de capteur. De plus, les bonnes implémentations du PID calculent la dérivée sur la mesure et non sur l'erreur ; ainsi, quand tu changes brusquement la consigne, la sortie ne subit pas de pic soudain (derivative kick).
Exemple 1 : régulation de température avec la bibliothèque Arduino PID
Dans le premier exemple, nous allons maintenir un petit chauffage (une plaque chauffante 12 V ou une résistance de puissance) à 45 °C. Nous mesurerons la température avec un pont diviseur formé d'une thermistance NTC de 10 kΩ et d'une résistance fixe de 10 kΩ, et nous piloterons le chauffage en PWM via un MOSFET canal N à niveau logique (par ex. IRLZ44N). Dans l'IDE Arduino, ouvre le Gestionnaire de bibliothèques, cherche PID et installe la bibliothèque PID de Brett Beauregard (PID_v1). Cette bibliothèque gère à ta place la période d'échantillonnage, la limitation de la sortie, la protection contre la saturation de l'intégrale et la dérivée sur la mesure. Pour le câblage du MOSFET, tu peux lire l'article utiliser un MOSFET avec Arduino.

| Connexion | Arduino Uno | ESP32 | Raspberry Pi Pico |
|---|---|---|---|
| Alimentation du diviseur (haut de la résistance fixe de 10 kΩ) | 5V | 3V3 | 3V3 |
| Point de jonction NTC / résistance fixe | A0 | GPIO 34 | GP26 (ADC0) |
| Bas de la NTC | GND | GND | GND |
| Gate du MOSFET (via 220 Ω, avec 10 kΩ vers GND) | D9 | GPIO 25 | GP15 |
| Source du MOSFET | GND | GND | GND |
| Chauffage | Entre +12 V et le drain du MOSFET | Entre +12 V et le drain du MOSFET | Entre +12 V et le drain du MOSFET |
1#include <PID_v1.h>
2
3const int NTC_PIN = A0; // NTC bölücü orta noktası / NTC divider midpoint
4const int HEATER_PIN = 9; // MOSFET gate (PWM) / MOSFET gate (PWM)
5
6const float R_FIXED = 10000.0; // sabit direnç / fixed resistor
7const float R0 = 10000.0; // NTC'nin 25 °C direnci / NTC resistance at 25 °C
8const float T0 = 298.15; // 25 °C kelvin cinsinden / 25 °C in kelvin
9const float BETA = 3950.0; // NTC Beta katsayısı / NTC beta coefficient
10
11double setpoint = 45.0; // hedef sıcaklık / target temperature
12double input = 0; // ölçülen sıcaklık / measured temperature
13double output = 0; // ısıtıcı gücü 0-255 / heater power 0-255
14
15double Kp = 20.0, Ki = 0.5, Kd = 10.0; // başlangıç değerleri / starting values
16PID heaterPID(&input, &output, &setpoint, Kp, Ki, Kd, DIRECT);
17
18float readTemperature() {
19 long sum = 0;
20 for (int i = 0; i < 16; i++) {
21 sum += analogRead(NTC_PIN); // 16 ölçüm ortalaması / average of 16 readings
22 }
23 float adc = sum / 16.0;
24 adc = constrain(adc, 1.0, 1022.0); // sıfıra bölmeyi önle / avoid division by zero
25 float r = R_FIXED * adc / (1023.0 - adc); // NTC direnci / NTC resistance
26 float kelvin = 1.0 / (1.0 / T0 + log(r / R0) / BETA); // Beta denklemi / beta equation
27 return kelvin - 273.15;
28}
29
30void setup() {
31 Serial.begin(115200);
32 pinMode(HEATER_PIN, OUTPUT);
33 input = readTemperature();
34 heaterPID.SetOutputLimits(0, 255); // analogWrite aralığı / analogWrite range
35 heaterPID.SetSampleTime(500); // 500 ms'de bir hesapla / compute every 500 ms
36 heaterPID.SetMode(AUTOMATIC); // PID'yi başlat / start the PID
37}
38
39void loop() {
40 input = readTemperature();
41 if (heaterPID.Compute()) { // yeni çıkış hazırsa / if a new output is ready
42 analogWrite(HEATER_PIN, (int)output);
43 Serial.print(setpoint); // Seri Çizici için / for the Serial Plotter
44 Serial.print(' ');
45 Serial.print(input);
46 Serial.print(' ');
47 Serial.println(output / 255.0 * 100.0); // güç yüzdesi / power percent
48 }
49}Dans le code, la fonction readTemperature() réduit le bruit en moyennant 16 mesures, calcule la résistance de la NTC avec la formule du diviseur (R = 10 kΩ · adc / (1023 − adc)) et la convertit en degrés Celsius avec l'équation Beta (B = 3950). SetOutputLimits(0, 255) garde la sortie dans la plage d'analogWrite et empêche l'intégrale de dépasser ces bornes. SetSampleTime(500) fait calculer le PID toutes les demi-secondes ; la chaleur variant lentement, c'est suffisant. Compute() ne renvoie true que lorsque le moment d'échantillonnage est venu, tu ne dois donc pas utiliser delay() dans loop(). Si tu ouvres les trois valeurs envoyées sur le port série dans le Traceur série (Serial Plotter) du menu Outils, tu vois sur le même graphique la consigne, la température et la puissance du chauffage en pourcentage, et tu observes l'effet de ton réglage en direct. Pour un système de refroidissement (par ex. ventilateur), la sortie doit augmenter quand la température augmente ; dans ce cas, utilise REVERSE à la place de DIRECT.
Comment régler Kp, Ki et Kd ? Pas à pas
- Mets Ki et Kd à zéro, démarre avec un petit Kp (par ex. 2) et ouvre le Traceur série.
- Double Kp par étapes ; arrête-toi quand le système approche vite de la consigne et se met à osciller en permanence. Utilise environ la moitié de cette valeur comme Kp.
- Ajoute Kd : pars d'une petite valeur et augmente-la jusqu'à ce que le dépassement et l'oscillation s'éteignent. Si la sortie tremble ou si le moteur grésille, Kd est trop grand ou le capteur est bruité.
- Ajoute Ki en dernier : augmente-le lentement jusqu'à ce que l'erreur permanente se ferme en un temps raisonnable. Si la température trace des vagues lentes et larges autour de la consigne, diminue Ki.
- Teste avec une perturbation : change la consigne de 5 °C, souffle sur le chauffage ou pousse légèrement le robot à la main ; observe en combien de temps et avec quel dépassement le système se rétablit.
- Si tu veux, utilise la méthode de Ziegler-Nichols comme point de départ : mesure le gain (Ku) qui déclenche une oscillation continue avec le seul P et la période d'oscillation (Tu, en secondes) ; commence avec Kp = 0,6·Ku, Ki = 1,2·Ku / Tu, Kd = 0,075·Ku·Tu et fais le réglage fin à la main.
| En augmentant le coefficient | Temps de montée | Dépassement (overshoot) | Temps d'établissement | Erreur permanente |
|---|---|---|---|---|
| Kp | Diminue | Augmente | Change peu | Diminue |
| Ki | Diminue | Augmente | Augmente | Éliminée |
| Kd | Change peu | Diminue | Diminue | Sans effet en théorie |
Exemple 2 : PID sur un robot suiveur de ligne

Sur un robot suiveur de ligne, l'objectif est que la ligne reste pile au centre du robot. À partir des lectures de trois capteurs analogiques TCRT5000 placés à gauche, au centre et à droite, nous calculons une moyenne pondérée qui donne la position de la ligne sous forme d'un nombre entre 0 (tout à gauche) et 2000 (tout à droite) ; 1000 correspond au centre. L'erreur est la différence entre la position et 1000. La correction produite par le PID s'ajoute à la vitesse du moteur gauche et se soustrait à celle du moteur droit ; le robot tourne ainsi en douceur vers la ligne. Alors que les robots à logique tout ou rien (ligne à gauche, tourne à gauche ; à droite, tourne à droite) zigzaguent et avancent lentement, un robot à PID roule beaucoup plus vite et plus droit sur la même piste. Dans cet exemple, nous écrivons le PID à la main, sans bibliothèque ; les moteurs sont commandés avec un driver L298N.
1const int SENSOR_PINS[3] = {A0, A1, A2}; // sol, orta, sağ / left, center, right
2
3const int ENA = 5, IN1 = 7, IN2 = 8; // sol motor / left motor
4const int ENB = 6, IN3 = 9, IN4 = 10; // sağ motor / right motor
5
6const int BASE_SPEED = 150; // düz giderken hız / cruising speed
7float Kp = 0.1, Ki = 0.0, Kd = 0.004; // robota göre ayarla / tune for your robot
8
9float lastError = 0;
10float integral = 0;
11int lastPosition = 1000;
12unsigned long lastTime = 0;
13
14int readPosition() {
15 long sum = 0, weighted = 0;
16 int maxValue = 0;
17 for (int i = 0; i < 3; i++) {
18 int v = analogRead(SENSOR_PINS[i]); // siyah çizgi = yüksek değer / black line = high value
19 weighted += (long)v * i * 1000L;
20 sum += v;
21 if (v > maxValue) maxValue = v;
22 }
23 if (maxValue > 500) { // çizgi görülüyor / line is visible
24 lastPosition = weighted / sum; // 0 sol, 1000 orta, 2000 sağ / 0 left, 1000 center, 2000 right
25 }
26 return lastPosition; // çizgi kaybolursa son konum / last position if line is lost
27}
28
29void setMotor(int en, int inA, int inB, int speed) {
30 speed = constrain(speed, -255, 255);
31 if (speed >= 0) {
32 digitalWrite(inA, HIGH); // ileri / forward
33 digitalWrite(inB, LOW);
34 } else {
35 digitalWrite(inA, LOW); // geri / backward
36 digitalWrite(inB, HIGH);
37 speed = -speed;
38 }
39 analogWrite(en, speed);
40}
41
42void setup() {
43 int pins[] = {ENA, IN1, IN2, ENB, IN3, IN4};
44 for (int i = 0; i < 6; i++) {
45 pinMode(pins[i], OUTPUT);
46 }
47 lastTime = millis();
48}
49
50void loop() {
51 unsigned long now = millis();
52 if (now - lastTime < 10) return; // 10 ms örnekleme / 10 ms sampling
53 float dt = (now - lastTime) / 1000.0; // saniye cinsinden / in seconds
54 lastTime = now;
55
56 float error = readPosition() - 1000; // negatif = çizgi solda / negative = line on the left
57 integral += error * dt;
58 integral = constrain(integral, -500.0, 500.0); // windup sınırı / windup limit
59 float derivative = (error - lastError) / dt;
60 lastError = error;
61
62 float correction = Kp * error + Ki * integral + Kd * derivative;
63 setMotor(ENA, IN1, IN2, (int)(BASE_SPEED + correction));
64 setMotor(ENB, IN3, IN4, (int)(BASE_SPEED - correction));
65}Les capteurs sont reliés à A0, A1 et A2, les broches ENA et ENB du L298N aux broches PWM D5 et D6, et IN1–IN4 à D7, D8, D9 et D10 ; n'oublie pas de retirer les cavaliers (jumpers) sur ENA et ENB. La boucle s'exécute toutes les 10 ms grâce à millis() ; ainsi dt reste constant et les coefficients se comportent de façon cohérente. Pour savoir pourquoi nous utilisons millis() plutôt que delay(), consulte l'article millis et delay. Si l'erreur est négative, la ligne est à gauche : la correction est négative, le moteur gauche ralentit, le moteur droit accélère et le robot tourne à gauche. L'erreur ne dépassant pas 1000, Kp = 0,1 représente une correction d'environ 100 unités PWM pour l'erreur maximale. La dérivée étant calculée par seconde, il est normal que Kd paraisse petit, comme 0,004. Sur un suiveur de ligne, Ki est généralement nul ou très petit ; l'intégrale n'est utile que si le robot dérive en permanence d'un côté (par ex. un moteur plus faible que l'autre). Si tes capteurs lisent une valeur haute sur fond blanc et basse sur la ligne noire, inverse la lecture avec 1023 − v.
PID avec ESP32 et Raspberry Pi Pico
La bibliothèque PID_v1 étant écrite en C++ pur, elle fonctionne telle quelle sur ESP32 ; il suffit de relier la NTC au GPIO 34 et la gate du MOSFET au GPIO 25. Les différences sont matérielles : l'ADC de l'ESP32 fait 12 bits (0–4095) et n'est pas linéaire près des extrémités ; garder la tension mesurée entre 0,3 et 2,8 V améliore le résultat. Pour le PWM, on utilise le module LEDC à la place d'analogWrite, et comme cette API a changé avec le core 3.x, le code contient un test de version. Grâce à sa rapidité et à ses deux cœurs, l'ESP32 peut exécuter la boucle PID tout en recevant une nouvelle température cible depuis une page web.
1#include <PID_v1.h>
2
3const int NTC_PIN = 34; // ADC1 girişi / ADC1 input
4const int HEATER_PIN = 25; // MOSFET gate / MOSFET gate
5const int PWM_FREQ = 1000; // 1 kHz PWM / 1 kHz PWM
6const int PWM_BITS = 8; // 0-255 çözünürlük / 0-255 resolution
7
8double setpoint = 45.0, input = 0, output = 0;
9PID heaterPID(&input, &output, &setpoint, 20.0, 0.5, 10.0, DIRECT);
10
11float readTemperature() {
12 long sum = 0;
13 for (int i = 0; i < 16; i++) {
14 sum += analogRead(NTC_PIN); // 12 bit: 0-4095 / 12-bit: 0-4095
15 }
16 double adc = constrain(sum / 16.0, 1.0, 4094.0);
17 double r = 10000.0 * adc / (4095.0 - adc); // NTC direnci / NTC resistance
18 return 1.0 / (1.0 / 298.15 + log(r / 10000.0) / 3950.0) - 273.15;
19}
20
21void setup() {
22 Serial.begin(115200);
23 analogReadResolution(12);
24#if ESP_ARDUINO_VERSION_MAJOR >= 3
25 ledcAttach(HEATER_PIN, PWM_FREQ, PWM_BITS); // çekirdek 3.x / core 3.x
26#else
27 ledcSetup(0, PWM_FREQ, PWM_BITS); // çekirdek 2.x, kanal 0 / core 2.x, channel 0
28 ledcAttachPin(HEATER_PIN, 0);
29#endif
30 input = readTemperature();
31 heaterPID.SetOutputLimits(0, 255);
32 heaterPID.SetSampleTime(500);
33 heaterPID.SetMode(AUTOMATIC);
34}
35
36void loop() {
37 input = readTemperature();
38 if (heaterPID.Compute()) {
39#if ESP_ARDUINO_VERSION_MAJOR >= 3
40 ledcWrite(HEATER_PIN, (uint32_t)output); // pin ile yaz / write by pin
41#else
42 ledcWrite(0, (uint32_t)output); // kanal ile yaz / write by channel
43#endif
44 Serial.printf("%.1f %.2f %.0f\n", setpoint, input, output / 255.0 * 100.0);
45 }
46}Comme il n'existe pas de module PID prêt à l'emploi pour MicroPython sur Raspberry Pi Pico, nous écrivons l'algorithme sous forme d'une petite classe. Cette classe reproduit trois choses importantes que fait la bibliothèque Arduino : elle garde l'intégrale dans les bornes de sortie (anti-windup), calcule la dérivée sur la mesure et tient compte de la période d'échantillonnage (dt). L'ADC du Pico renvoie avec read_u16() une valeur entre 0 et 65535 ; la sortie PID est calculée entre 0 et 255 puis multipliée par 257 pour passer sur 16 bits pour duty_u16(). Tu peux ainsi réutiliser tels quels sur le Pico les Kp, Ki et Kd trouvés sur Arduino. Le diviseur NTC est relié à GP26 et la gate du MOSFET à GP15. Si tu débutes avec MicroPython, commence par l'article bases de MicroPython.
1from machine import ADC, Pin, PWM
2import math
3import time
4
5ntc = ADC(26) # GP26 = ADC0, NTC bölücüsü / NTC divider
6heater = PWM(Pin(15)) # MOSFET gate / MOSFET gate
7heater.freq(1000) # 1 kHz PWM / 1 kHz PWM
8
9R_FIXED = 10000 # sabit direnç / fixed resistor
10R0 = 10000 # NTC'nin 25 °C direnci / NTC resistance at 25 °C
11T0 = 298.15 # 25 °C kelvin cinsinden / 25 °C in kelvin
12BETA = 3950 # Beta katsayısı / beta coefficient
13SETPOINT = 45.0 # hedef sıcaklık / target temperature
14
15def read_temp():
16 total = 0
17 for _ in range(16):
18 total += ntc.read_u16() # 16 ölçüm ortalaması / average of 16 readings
19 adc = min(max(total / 16, 1), 65534)
20 r = R_FIXED * adc / (65535 - adc)
21 return 1 / (1 / T0 + math.log(r / R0) / BETA) - 273.15
22
23class PID:
24 def __init__(self, kp, ki, kd, out_min, out_max):
25 self.kp, self.ki, self.kd = kp, ki, kd
26 self.out_min, self.out_max = out_min, out_max
27 self.i_term = 0
28 self.last_input = None
29
30 def compute(self, setpoint, measurement, dt):
31 error = setpoint - measurement
32 self.i_term += self.ki * error * dt # biriken hata / accumulated error
33 self.i_term = min(max(self.i_term, self.out_min), self.out_max) # integral sınırı / anti-windup
34 if self.last_input is None:
35 d_input = 0
36 else:
37 d_input = (measurement - self.last_input) / dt # ölçümden türev / derivative on measurement
38 self.last_input = measurement
39 out = self.kp * error + self.i_term - self.kd * d_input
40 return min(max(out, self.out_min), self.out_max)
41
42pid = PID(20, 0.5, 10, 0, 255) # Arduino ile aynı katsayılar / same gains as Arduino
43last = time.ticks_ms()
44
45while True:
46 now = time.ticks_ms()
47 if time.ticks_diff(now, last) >= 500: # 500 ms örnekleme / 500 ms sampling
48 dt = time.ticks_diff(now, last) / 1000
49 last = now
50 temp = read_temp()
51 power = pid.compute(SETPOINT, temp, dt)
52 heater.duty_u16(int(power * 257)) # 0-255 -> 0-65535
53 print(SETPOINT, round(temp, 2), round(power))Idées de projets avec un régulateur PID
- Thermostat de précision : dans un projet de thermostat Arduino, utilise un PID à la place du tout ou rien pour garder une couveuse ou une armoire de fermentation à ±0,3 °C.
- Vitesse de ventilateur selon la température : dans un projet de contrôle de ventilateur, pilote le ventilateur avec un PID en mode REVERSE pour un refroidissement silencieux et stable.
- Robot suiveur de ligne rapide : ajoute 5 capteurs et un PID au projet de robot suiveur de ligne pour atteindre une vitesse de compétition.
- Robot auto-équilibré : mesure l'angle d'inclinaison avec un MPU-6050 pour tenir un robot à deux roues debout ; c'est l'une des applications les plus instructives du PID.
- Suiveur solaire : dans un projet de suiveur solaire, utilise la différence entre deux LDR comme erreur pour tourner le panneau en douceur.
- Station de soudure ou mini four : mesure les hautes températures avec un thermocouple MAX6675 et pilote le chauffage avec un PID.
- Moteur à vitesse constante : maintiens à la consigne la vitesse d'un moteur DC à réducteur avec encodeur, même quand la charge change.
Erreurs fréquentes et solutions
| Symptôme | Cause probable | Solution |
|---|---|---|
| Le système oscille en permanence et rapidement autour de la consigne | Kp trop élevé ou Kd insuffisant | Baisse Kp de 30–50 %, augmente un peu Kd |
| N'atteint jamais la consigne, reste quelques degrés en dessous | Ki nul ou trop petit | Augmente Ki lentement ; vérifie que la puissance du chauffage est suffisante |
| Gros dépassement durable en fin de montée en température | Saturation de l'intégrale (windup) | Limite la sortie avec SetOutputLimits, limite l'intégrale, baisse Ki |
| La sortie tremble, le moteur grésille | Capteur bruité et Kd élevé | Moyenne ou filtre la mesure, baisse Kd |
| La sortie augmente quand la température augmente | Sens de régulation inversé | Utilise REVERSE pour le refroidissement ou inverse le signe de l'erreur |
| Les mêmes coefficients marchent parfois bien, parfois mal | Échantillonnage irrégulier, delay() dans loop | Utilise millis() avec un dt constant, évite delay() |
| Le chauffage est toujours à fond mais la température ne monte pas | Matériel insuffisant (puissance, isolation, MOSFET) | Le PID ne compense pas un matériel insuffisant ; vérifie la puissance et les connexions |
Le régulateur PID combine la boucle mesurer-comparer-corriger en trois idées simples et s'utilise partout, des projets de loisir aux fours industriels. Vois d'abord les limites du tout ou rien, puis commence par P, freine avec D et ferme l'erreur permanente avec I ; le graphique du Traceur série te guidera à chaque étape. Dans l'application BlueGrays, tu peux consulter pas à pas, avec schémas et codes, des projets qui utilisent les éléments de cet article : mesure de température avec une NTC, détection du sol avec un TCRT5000, voiture robot avec L298N et contrôle PWM par potentiomètre. C'est un bon point de départ pour ajouter un PID à ton propre projet.
Questions fréquentes
Qu'est-ce qu'un régulateur PID et à quoi sert-il simplement ?
Un régulateur PID est une méthode de rétroaction qui calcule en continu l'erreur pour maintenir une valeur mesurée à la consigne, et ajuste la sortie en conséquence. Le terme proportionnel réagit à l'erreur présente, l'intégral à l'erreur accumulée et le dérivé à la vitesse de variation de l'erreur. Pour la température, la vitesse d'un moteur, la position et l'équilibre, il donne des résultats bien plus stables et précis que le tout ou rien.
Comment trouver les valeurs de Kp, Ki et Kd ?
Le plus pratique est le réglage manuel : mets Ki et Kd à zéro, augmente Kp jusqu'à ce que le système oscille puis ramène-le à la moitié, ajoute Kd pour calmer le dépassement, et ajoute Ki en dernier pour fermer l'erreur permanente. La méthode de Ziegler-Nichols donne un bon point de départ, mais le réglage fin se fait presque toujours à la main. Les valeurs sont propres à chaque système ; des coefficients copiés d'un autre projet peuvent ne pas fonctionner sur ton montage.
Quelle est la différence entre un PID et une régulation tout ou rien ?
La régulation tout ou rien met la sortie uniquement à fond ou à zéro, ce qui crée une oscillation et un dépassement permanents autour de la consigne. Le PID règle la sortie progressivement, réduit la puissance à l'avance à l'approche de la consigne et supprime l'erreur permanente grâce au terme intégral. Le tout ou rien est plus simple et moins cher, le PID est plus précis mais demande un réglage.
Quelle bibliothèque PID pour Arduino et comment l'installer ?
La plus répandue est la bibliothèque PID de Brett Beauregard (PID_v1). Tu peux l'installer en cherchant "PID" dans le Gestionnaire de bibliothèques de l'IDE Arduino et l'utiliser en ajoutant l'en-tête PID_v1.h à ton code. La bibliothèque gère elle-même la période d'échantillonnage, la limitation de la sortie et la protection contre la saturation de l'intégrale.
Qu'est-ce que l'intégrale windup et comment l'éviter ?
L'intégrale windup, c'est quand l'erreur continue de s'accumuler dans l'intégrale alors que la sortie est déjà à sa limite (par ex. chauffage à pleine puissance). Une fois la consigne atteinte, cette valeur accumulée fait dépasser la consigne longtemps. Pour l'éviter, il faut garder l'intégrale dans les bornes de sortie ; dans la bibliothèque Arduino PID, SetOutputLimits le fait automatiquement.
Peut-on faire une régulation PID avec un relais ?
Oui, avec la méthode de la proportion de temps (time proportioning) : par exemple, sur une fenêtre de 5 secondes, si la sortie PID est de 40 %, le relais reste fermé 2 secondes et ouvert 3 secondes. Les relais mécaniques s'usent vite en commutation fréquente, donc un relais statique (SSR) convient mieux. Pour les systèmes lents comme un chauffage, cette méthode donne d'aussi bons résultats que le PWM.
Projets à réaliser après cet article
Voir tous les projets
Température et humidité avec DHT11
Quelle température fait-il dans ta chambre, et l'air est-il humide ou sec ? Le capteur DHT11 mesure la température et l'humidité, et l'Arduino affiche les valeurs sur un écran LCD à deux lignes…

HC-SR04 Mesure de la distance (affichage en série)
Le capteur HC-SR04 fonctionne comme une chauve-souris qui trouve son chemin dans le noir : il envoie un son que tu ne peux pas entendre, écoute l'écho et mesure à quelle distance se trouve l'objet…

Mesure de la température avec NTC et écran LCD 2x16
Mesure la température ambiante avec un capteur qui ressemble à une petite perle.

TCRT5000 Détection de surface noire et blanche
Avec le petit capteur qui sert d'œil aux robots suiveurs de ligne, tu sais si le sol est noir ou blanc.

Lecture de réflexion (proximité) avec TCRT5000
Avec un petit capteur qui envoie une lumière invisible et mesure ce qui revient, tu détectes la surface placée devant lui.

Robot évitant les obstacles
Que diriez-vous de construire un véhicule intelligent qui trouve son propre chemin ?

Voiture contrôlée par Bluetooth avec L298N
Transforme ton téléphone en télécommande et pilote ta propre voiture robot. L'Arduino reçoit, via un module Bluetooth, les ordres d'une appli de télécommande sur ton téléphone et fait tourner les…

Luminosité d'une LED avec un Potentiomètre sur ESP32 (Analogique → PWM)
Dans ce projet, nous contrôlons la luminosité d'une LED de manière analogique à l'aide d'un potentiomètre. La broche ADC de l'ESP32 lit la tension entre 0 et 3,3 V provenant du potentiomètre, puis cette valeur est convertie en signal PWM (modulation de largeur d'impulsion) envoyé à la LED. Ainsi, la LED s'allume et s'éteint progressivement. Avec Arduino Core 3.0+, analogWrite() est utilisable directement; sur ESP32-S2/S3, la résolution de l'ADC est fixée à 12 bits.
Autres articles
Application BlueGrays
Réalise ce montage pas à pas sur ton téléphone
Schéma, code et liste des composants sur un seul écran. Plus de 500 projets Arduino, ESP32 et Pico à réaliser.
Scanne avec ton téléphone
Pointe l’appareil photo vers le code : la boutique d’applications de ton téléphone s’ouvre.
ou ouvre la boutique

