Bases · 14 min de lecture

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éthodeComment elle décideAvantageInconvénientUsage typique
Tout ou rien (on-off)Pleine puissance sous la consigne, coupé au-dessusTrès simple, faisable avec un simple relaisOscillation et dépassement permanents, usure du relaisThermostat de chaudière, chauffage d'aquarium
PSortie proportionnelle à l'erreurRéaction douce, réglage facileUne erreur permanente subsisteContrôle simple de position et de niveau
PIProportionnel + erreur accumuléeSupprime l'erreur permanentePlus de dépassement, saturation de l'intégraleContrôle de température, de débit et de vitesse de moteur
PIDProportionnel + erreur accumulée + vitesse de variationRapide, peu de dépassement, précisRéglage difficile, sensible au bruitImprimante 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).

TermeCe qu'il regardeAnalogie intuitiveS'il est trop fort
P (proportionnel)L'erreur présentePlus tu t'éloignes de la voie, plus tu tournes le volantOscillations rapides, tremblements
I (intégral)L'erreur accumulée dans le tempsAvec 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'erreurEn approchant vite de la voie, tu redresses plus tôtRé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.

Thermistance NTC, capteur de température
Thermistance NTC 10 kΩ : sa résistance diminue quand la température augmente ; elle sert d'élément de mesure dans la régulation de température PID.
ConnexionArduino UnoESP32Raspberry Pi Pico
Alimentation du diviseur (haut de la résistance fixe de 10 kΩ)5V3V33V3
Point de jonction NTC / résistance fixeA0GPIO 34GP26 (ADC0)
Bas de la NTCGNDGNDGND
Gate du MOSFET (via 220 Ω, avec 10 kΩ vers GND)D9GPIO 25GP15
Source du MOSFETGNDGNDGND
ChauffageEntre +12 V et le drain du MOSFETEntre +12 V et le drain du MOSFETEntre +12 V et le drain du MOSFET
N'alimente jamais le chauffage directement depuis une broche Arduino ; une broche ne fournit qu'environ 20–40 mA au maximum, alors qu'un chauffage consomme des ampères. Le moins de l'adaptateur 12 V doit être commun avec la GND de l'Arduino, sinon le MOSFET ne s'ouvre pas correctement. Comme l'ESP32 et le Pico sortent du 3,3 V, choisis à la place de l'IRLZ44N un MOSFET qui s'ouvre complètement à 3,3 V (par ex. AO3400) ; si tu pilotes une charge inductive comme un ventilateur ou un moteur, ajoute une diode en antiparallèle sur la charge.
C++ (Arduino IDE)
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

  1. Mets Ki et Kd à zéro, démarre avec un petit Kp (par ex. 2) et ouvre le Traceur série.
  2. 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.
  3. 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é.
  4. 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.
  5. 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.
  6. 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 coefficientTemps de montéeDépassement (overshoot)Temps d'établissementErreur permanente
KpDiminueAugmenteChange peuDiminue
KiDiminueAugmenteAugmenteÉliminée
KdChange peuDiminueDiminueSans effet en théorie

Exemple 2 : PID sur un robot suiveur de ligne

Capteur de ligne infrarouge TCRT5000
Capteur de réflexion infrarouge TCRT5000 : il distingue le sol noir du blanc et fournit l'entrée du 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.

C++ (Arduino IDE)
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.

C++ (Arduino IDE)
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.

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ômeCause probableSolution
Le système oscille en permanence et rapidement autour de la consigneKp trop élevé ou Kd insuffisantBaisse Kp de 30–50 %, augmente un peu Kd
N'atteint jamais la consigne, reste quelques degrés en dessousKi nul ou trop petitAugmente Ki lentement ; vérifie que la puissance du chauffage est suffisante
Gros dépassement durable en fin de montée en températureSaturation de l'intégrale (windup)Limite la sortie avec SetOutputLimits, limite l'intégrale, baisse Ki
La sortie tremble, le moteur grésilleCapteur bruité et Kd élevéMoyenne ou filtre la mesure, baisse Kd
La sortie augmente quand la température augmenteSens 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 loopUtilise millis() avec un dt constant, évite delay()
Le chauffage est toujours à fond mais la température ne monte pasMatériel insuffisant (puissance, isolation, MOSFET)Le PID ne compense pas un matériel insuffisant ; vérifie la puissance et les connexions
Pendant le réglage, recharger le code à chaque changement de coefficients devient fatigant. Si tu ajoutes quelques lignes qui lisent sur le port série des commandes comme "p2.5" ou "d0.8" et mettent à jour les coefficients en cours de route avec SetTunings(Kp, Ki, Kd), tu trouveras un bon réglage en quelques minutes en regardant le graphique du Traceur série. Pour conserver les valeurs trouvées, tu peux les enregistrer dans l'EEPROM.

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.

Voir tous les projets
Température et humidité avec DHT11
AR-55Intermédiaire

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…

4.7(47)
83
HC-SR04 Mesure de la distance (affichage en série)
AR-27Débutant

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…

4.6(50)
82
Mesure de la température avec NTC et écran LCD 2x16
AR-44Débutant
Premium

Mesure de la température avec NTC et écran LCD 2x16

Mesure la température ambiante avec un capteur qui ressemble à une petite perle.

4.5(33)
44
TCRT5000 Détection de surface noire et blanche
AR-78Intermédiaire
Premium

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.

4.7(40)
49
Lecture de réflexion (proximité) avec TCRT5000
AR-77Intermédiaire
Premium

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.

4.6(33)
43
Robot évitant les obstacles
AR-81Avancé
Premium

Robot évitant les obstacles

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

5.0(38)
49
Voiture contrôlée par Bluetooth avec L298N
AR-80Avancé
Premium

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…

5.0(39)
66
Luminosité d'une LED avec un Potentiomètre sur ESP32 (Analogique → PWM)
ES-13Intermédiaire
Premium

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.

4.5(19)
32