Basi · 13 min di lettura

Controllo PID Arduino: cos'è e come tarare Kp, Ki e Kd

Cos'è il controllo PID e come funziona? Termini P, I e D, libreria PID per Arduino, taratura di Kp, Ki e Kd, codice per temperatura e robot line follower.

Il controllo PID è un metodo di retroazione che calcola di continuo la differenza (errore) tra il valore misurato e quello desiderato e regola l'uscita in base a quell'errore. Nei progetti Arduino serve per mantenere un riscaldatore esattamente a 45 °C, far girare un motore a velocità costante o guidare un robot line follower al centro della linea. Il nome viene dalle tre componenti: il termine Proporzionale (P) guarda l'errore presente, il termine Integrale (I) l'errore accumulato nel passato e il termine Derivativo (D) la velocità con cui l'errore cambia. La somma pesata dei tre determina il valore PWM inviato al motore o al riscaldatore.

Le formule sembrano spaventose, ma la logica del PID è molto simile a ciò che fai senza pensarci quando guidi. In questo articolo vedrai prima perché il semplice controllo on-off oscilla, poi conoscerai i tre termini con esempi intuitivi. Poi farai un controllo di temperatura con la libreria PID di Arduino usando un NTC e un MOSFET, imparerai a tarare Kp, Ki e Kd passo dopo passo e guiderai un robot line follower con un PID scritto senza libreria. Infine faremo girare lo stesso algoritmo su ESP32 e su Raspberry Pi Pico con MicroPython.

Perché il controllo on-off non basta?

Il metodo di controllo più semplice è il controllo on-off: se la temperatura è sotto l'obiettivo accendi il riscaldatore a piena potenza, se è sopra lo spegni. Il termostato della caldaia di casa e il riscaldatore dell'acquario funzionano in gran parte così. Il problema è che, quando il riscaldatore si spegne, il calore accumulato continua a diffondersi, quindi la temperatura supera l'obiettivo di qualche grado. Quando poi inizia a scendere, il riscaldatore deve riaccendersi e scaldarsi, e nel frattempo la temperatura scende sotto l'obiettivo. Il risultato è un dente di sega continuo attorno al valore desiderato. Per attenuarlo si lascia un intervallo tra due soglie (isteresi): il relè scatta meno spesso, ma l'ampiezza dell'oscillazione aumenta. Se devi mantenere l'obiettivo entro ±0,5 °C, come sul piano di una stampante 3D, in un'incubatrice o in un motore a velocità fissa, non basta. Il PID invece produce un'uscita graduale tra piena potenza e zero e riduce la potenza in anticipo quando il sistema si avvicina all'obiettivo.

MetodoCome decideProControUso tipico
On-offPiena potenza sotto l'obiettivo, spento sopraSemplicissimo, basta anche un relèOscillazione e overshoot continui, usura del relèTermostato della caldaia, riscaldatore per acquario
PUscita proporzionale all'erroreRisposta dolce, taratura facileResta un errore a regimeSemplice controllo di posizione e livello
PIProporzionale + errore accumulatoElimina l'errore a regimePiù overshoot, windup dell'integraleControllo di temperatura, portata e velocità del motore
PIDProporzionale + errore accumulato + velocità di variazioneVeloce, poco overshoot, precisoTaratura difficile, sensibile al rumoreStampante 3D, drone, robot bilanciato, line follower

Cos'è il controllo PID e come funziona?

A ogni ciclo il PID calcola prima l'errore: errore = valore desiderato (setpoint) − valore misurato (input). Poi valuta l'errore in tre modi diversi e li somma: uscita = Kp·e + Ki·∫e·dt + Kd·de/dt. Kp, Ki e Kd sono i coefficienti che imposti tu e decidono quanto ogni termine contribuisce all'uscita. In un microcontrollore l'integrale si calcola aggiungendo a una somma, a ogni campionamento, il prodotto tra errore e tempo di campionamento; la derivata si calcola dividendo la differenza tra le ultime due misure per il tempo di campionamento. Per questo, perché il PID funzioni bene, le misure devono essere fatte a intervalli costanti, per esempio ogni 10 ms o ogni 500 ms. Pensa a quando segui una corsia in auto: più sei lontano dalla corsia, più giri il volante (P); se il vento laterale ti spinge di continuo, impari a tenere il volante leggermente girato (I); quando ti avvicini in fretta alla corsia, raddrizzi in anticipo (D).

TermineCosa guardaAnalogia intuitivaSe è eccessivo
P (Proporzionale)L'errore presentePiù sei lontano dalla corsia, più giri il volanteOscillazioni rapide, tremolio
I (Integrale)L'errore accumulato nel tempoCon il vento laterale impari a tenere il volante leggermente giratoOscillazioni lente e ampie, grande overshoot
D (Derivativo)La velocità di variazione dell'erroreQuando ti avvicini in fretta alla corsia raddrizzi in anticipoReazione eccessiva al rumore, uscita che vibra

Termine proporzionale (P): risposta proporzionale all'errore

Il termine proporzionale regola l'uscita in proporzione diretta alla grandezza dell'errore. Con Kp = 20, un errore di 3 °C produce 60 unità PWM e un errore di 1 °C ne produce 20: avvicinandosi all'obiettivo la potenza cala da sola. Aumentando Kp il sistema reagisce più in fretta, ma oltre un certo punto supera l'obiettivo e torna indietro, cioè inizia a oscillare. Il controllo con solo P ha un punto debole importante: l'errore a regime (steady-state error). Supponiamo che per mantenere il riscaldatore a 45 °C serva una potenza continua di 80 unità per compensare il calore che si disperde. Con il solo termine P, queste 80 unità si possono produrre solo in presenza di un errore: 80 / 20 = 4 °C. Quindi il sistema si stabilizza intorno ai 41 °C e non raggiunge mai l'obiettivo. Aumentare Kp riduce la differenza, ma aumenta anche l'oscillazione.

Termine integrale (I): elimina l'errore a regime

Il termine integrale somma l'errore nel tempo. Anche un errore piccolo, se dura a lungo, fa crescere la somma e l'uscita aumenta lentamente finché l'errore non si annulla. Nell'esempio sopra, ora è il termine integrale a fornire le 80 unità di potenza necessarie, il termine P scende a zero e la temperatura si assesta esattamente a 45 °C. Più Ki è grande, più in fretta si chiude l'errore a regime; se è troppo grande, il sistema fa oscillazioni lente e ampie. Un noto tranello dell'integrale è il windup: se il riscaldatore è già a piena potenza e non riesce a raggiungere l'obiettivo, l'integrale continua a crescere inutilmente e, quando l'obiettivo viene raggiunto, questo valore accumulato tiene la temperatura sopra l'obiettivo per molto tempo. La soluzione è limitare l'integrale con i limiti d'uscita; la libreria PID di Arduino lo fa in automatico con SetOutputLimits.

Termine derivativo (D): frena avvicinandosi all'obiettivo

Il termine derivativo guarda la velocità con cui cambia l'errore e fornisce una sorta di previsione. Se la temperatura si avvicina in fretta all'obiettivo, l'errore diminuisce rapidamente; il termine D contribuisce in senso opposto, taglia la potenza in anticipo e riduce l'overshoot. Succede lo stesso con un robot: un robot che gira velocemente verso la linea ammorbidisce la curva prima di superarla. Il punto debole del termine D è la sua sensibilità al rumore. Se la lettura di un sensore analogico salta di qualche unità a ogni misura, la derivata vede questi piccoli salti come grandi variazioni e l'uscita vibra. Per questo bisogna mediare o filtrare la lettura del sensore; per i dettagli puoi leggere l'articolo sul filtraggio dei dati dei sensori. Inoltre, le buone implementazioni PID calcolano la derivata non sull'errore ma sulla misura: così, se cambi di colpo l'obiettivo, non compare un picco improvviso sull'uscita (derivative kick).

Esempio 1: controllo di temperatura con la libreria PID di Arduino

Nel primo esempio manterremo un piccolo riscaldatore (un pad riscaldante a 12 V o una resistenza di potenza) a 45 °C. Misureremo la temperatura con un partitore formato da un termistore NTC da 10 kΩ e una resistenza fissa da 10 kΩ, e comanderemo il riscaldatore in PWM tramite un MOSFET a canale N a livello logico (per es. IRLZ44N). Nell'IDE di Arduino apri il Gestore librerie, cerca PID e installa la libreria PID (PID_v1) di Brett Beauregard. Questa libreria gestisce al posto tuo dettagli come il tempo di campionamento, la limitazione dell'uscita, la protezione dal windup dell'integrale e la derivata sulla misura. Per i dettagli del collegamento del MOSFET dai un'occhiata all'articolo uso del MOSFET con Arduino.

Sensore di temperatura NTC termistore
Termistore NTC da 10 kΩ: la resistenza diminuisce all'aumentare della temperatura; nel controllo PID della temperatura è l'elemento di misura.
CollegamentoArduino UnoESP32Raspberry Pi Pico
Alimentazione del partitore (estremo superiore della resistenza fissa da 10 kΩ)5V3V33V3
Punto di giunzione tra NTC e resistenza fissaA0GPIO 34GP26 (ADC0)
Estremo inferiore dell'NTCGNDGNDGND
Gate del MOSFET (tramite 220 Ω, con 10 kΩ verso GND)D9GPIO 25GP15
Source del MOSFETGNDGNDGND
RiscaldatoreTra +12 V e il drain del MOSFETTra +12 V e il drain del MOSFETTra +12 V e il drain del MOSFET
Non alimentare mai il riscaldatore direttamente da un pin di Arduino: un pin può erogare al massimo circa 20–40 mA, mentre un riscaldatore assorbe ampere. Il negativo dell'alimentatore da 12 V deve essere in comune con il GND di Arduino, altrimenti il MOSFET non si apre correttamente. Poiché ESP32 e Pico escono a 3,3 V, al posto dell'IRLZ44N scegli un MOSFET che si apra completamente a 3,3 V (per es. AO3400); se pilotassi un carico induttivo come una ventola o un motore, aggiungi un diodo in antiparallelo al carico.
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}

Nel codice, la funzione readTemperature() riduce il rumore facendo la media di 16 misure, calcola la resistenza dell'NTC dalla formula del partitore (R = 10 kΩ · adc / (1023 − adc)) e la converte in gradi Celsius con l'equazione Beta (B = 3950). SetOutputLimits(0, 255) mantiene l'uscita nell'intervallo di analogWrite e impedisce all'integrale di superare questi limiti. SetSampleTime(500) fa sì che il PID calcoli ogni mezzo secondo; essendo il calore una grandezza che varia lentamente, basta. Compute() restituisce true solo quando è il momento del campionamento, quindi non devi usare delay() dentro loop(). Se apri i tre valori scritti sulla seriale nel Serial Plotter del menu Strumenti, vedi nello stesso grafico obiettivo, temperatura e potenza del riscaldatore in percentuale, e osservi subito l'effetto della taratura. In un sistema di raffreddamento (per es. con una ventola) l'uscita deve aumentare quando la temperatura sale; in questo caso usa REVERSE al posto di DIRECT.

Come tarare Kp, Ki e Kd? Passo dopo passo

  1. Azzera Ki e Kd, parti con un Kp piccolo (per es. 2) e apri il Serial Plotter.
  2. Raddoppia Kp a ogni passo; fermati quando il sistema si avvicina rapidamente all'obiettivo e inizia a oscillare in modo continuo. Usa circa la metà di questo valore come Kp.
  3. Aggiungi Kd: parti da un valore piccolo e aumentalo finché overshoot e oscillazione non si smorzano. Se l'uscita inizia a vibrare o il motore a ronzare, Kd è eccessivo oppure il sensore è rumoroso.
  4. Aggiungi Ki per ultimo: aumentalo lentamente finché l'errore a regime non si chiude in un tempo ragionevole. Se la temperatura disegna onde lente e ampie attorno all'obiettivo, riduci Ki.
  5. Prova con un disturbo: cambia l'obiettivo di 5 °C, soffia sul riscaldatore o spingi leggermente il robot con la mano; osserva in quanto tempo e con quale overshoot il sistema si riprende.
  6. Se vuoi, usa il metodo di Ziegler-Nichols come punto di partenza: misura con il solo P il guadagno che fa partire un'oscillazione continua (Ku) e il periodo di oscillazione (Tu, in secondi); parti con Kp = 0,6·Ku, Ki = 1,2·Ku / Tu, Kd = 0,075·Ku·Tu e fai la taratura fine a mano.
Aumentando il coefficienteTempo di salitaOvershootTempo di assestamentoErrore a regime
KpDiminuisceAumentaCambia pocoDiminuisce
KiDiminuisceAumentaAumentaSi annulla
KdCambia pocoDiminuisceDiminuisceIn teoria non influisce

Esempio 2: PID in un robot line follower

Sensore di linea a infrarossi TCRT5000
Sensore a riflessione a infrarossi TCRT5000: distingue il fondo nero da quello bianco e fornisce l'ingresso del PID nel robot line follower.

In un robot line follower l'obiettivo è che la linea resti esattamente al centro del robot. Facendo una media pesata delle letture di tre sensori analogici TCRT5000 posti a sinistra, al centro e a destra, convertiamo la posizione della linea in un numero tra 0 (tutta a sinistra) e 2000 (tutta a destra); 1000 è il centro esatto. L'errore è la differenza tra la posizione e 1000. La correzione prodotta dal PID viene sommata alla velocità del motore sinistro e sottratta a quella del motore destro, così il robot gira dolcemente verso la linea. Mentre i robot con la semplice logica on-off (se la linea è a sinistra gira a sinistra, se è a destra gira a destra) procedono a zig-zag e lentamente, un robot con PID percorre la stessa pista a velocità molto più alta e con una traiettoria regolare. In questo esempio scriviamo il PID da zero, senza libreria; i motori sono controllati con il 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}

I sensori sono collegati ad A0, A1 e A2, i morsetti ENA ed ENB dell'L298N ai pin PWM D5 e D6, e i morsetti IN1–IN4 a D7, D8, D9 e D10; non dimenticare di togliere i ponticelli (jumper) su ENA ed ENB. Il ciclo gira ogni 10 ms con millis(): così dt resta costante e i coefficienti si comportano in modo coerente. Perché usiamo millis() al posto di delay() lo trovi nell'articolo su millis e delay. Se l'errore è negativo la linea è a sinistra: la correzione diventa negativa, il motore sinistro rallenta, il destro accelera e il robot gira a sinistra. Dato che l'errore è al massimo 1000, Kp = 0,1 significa una correzione di circa 100 unità PWM con l'errore massimo. Poiché la derivata è calcolata per secondo, è normale che Kd sembri piccolo, come 0,004. In un line follower Ki si tiene di solito a zero o molto piccolo; l'integrale è utile solo se il robot deriva sempre da un lato (per es. se un motore è più debole dell'altro). Se i tuoi sensori leggono un valore alto sul fondo bianco e basso sulla linea nera, inverti la lettura con 1023 − v.

PID con ESP32 e Raspberry Pi Pico

Poiché la libreria PID_v1 è scritta in puro C++, funziona identica anche su ESP32; basta collegare l'NTC al GPIO 34 e il gate del MOSFET al GPIO 25. Le differenze sono nell'hardware: l'ADC dell'ESP32 è a 12 bit (0–4095) e non è lineare vicino agli estremi; mantenere la tensione misurata tra 0,3 e 2,8 V migliora il risultato. Per il PWM, al posto di analogWrite si usa l'unità LEDC, e poiché questa API è cambiata con il core 3.x, nel codice c'è un controllo di versione. Grazie al doppio core e alla velocità, l'ESP32 può eseguire il ciclo PID e allo stesso tempo ricevere da una pagina web una nuova temperatura obiettivo.

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}

Poiché per MicroPython su Raspberry Pi Pico non esiste un modulo PID pronto, scriviamo l'algoritmo come una piccola classe. Questa classe imita tre cose importanti che fa la libreria di Arduino: mantiene l'integrale entro i limiti d'uscita (anti-windup), calcola la derivata sulla misura e tiene conto del tempo di campionamento (dt). L'ADC del Pico restituisce con read_u16() un valore tra 0 e 65535; l'uscita del PID viene calcolata tra 0 e 255 e moltiplicata per 257 per scalarla a 16 bit per duty_u16(). Così puoi usare sul Pico gli stessi valori di Kp, Ki e Kd trovati su Arduino. Il partitore dell'NTC è collegato a GP26 e il gate del MOSFET a GP15. Se sei nuovo di MicroPython, puoi iniziare con l'articolo sui fondamenti di 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))

Idee di progetto con il controllo PID

  • Termostato di precisione: in un progetto di termostato con Arduino, usa il PID al posto dell'on-off per mantenere un'incubatrice o un armadio di fermentazione entro ±0,3 °C.
  • Velocità della ventola in base alla temperatura: in un progetto di controllo della ventola, pilota la ventola con un PID in modalità REVERSE per ottenere un raffreddamento silenzioso e costante.
  • Line follower veloce: aggiungi 5 sensori e un PID al progetto di robot line follower per arrivare alla velocità da gara.
  • Robot auto-bilanciante: misura l'angolo di inclinazione con l'MPU-6050 e tieni in piedi un robot a due ruote; è una delle applicazioni più istruttive del PID.
  • Inseguitore solare: nel progetto di inseguitore solare, usa come errore la differenza tra due LDR e ruota il pannello in modo dolce.
  • Stazione saldante o mini forno: misura le alte temperature con una termocoppia MAX6675 e pilota il riscaldatore con il PID.
  • Motore a giri costanti: mantieni al valore obiettivo la velocità di un motoriduttore DC con encoder, anche quando il carico cambia.

Errori comuni e come risolverli

SintomoCausa probabileSoluzione
Il sistema oscilla in modo continuo e rapido attorno all'obiettivoKp troppo alto o Kd insufficienteRiduci Kp del 30–50% e aumenta un po' Kd
Non raggiunge mai l'obiettivo e resta qualche grado sottoKi è zero o troppo piccoloAumenta lentamente Ki; controlla che la potenza del riscaldatore sia sufficiente
Overshoot grande e lungo alla fine del riscaldamentoWindup dell'integraleLimita l'uscita con SetOutputLimits, limita l'integrale, riduci Ki
L'uscita vibra, il motore ronzaSensore rumoroso e Kd altoFai la media o filtra la misura, riduci Kd
All'aumentare della temperatura aumenta anche l'uscitaDirezione di controllo invertitaNel raffreddamento usa REVERSE o inverti il segno dell'errore
Gli stessi coefficienti a volte funzionano bene, a volte maleCampionamento irregolare, delay() nel loopUsa millis() con dt costante ed evita delay()
Il riscaldatore è sempre a piena potenza ma la temperatura non saleHardware insufficiente (potenza, isolamento, MOSFET)Il PID non può compensare un hardware inadeguato; controlla potenza e collegamenti
Durante la taratura è faticoso cambiare i coefficienti ricaricando ogni volta il codice. Se aggiungi poche righe che leggono dalla seriale comandi come "p2.5" o "d0.8" e aggiornano i coefficienti in esecuzione con SetTunings(Kp, Ki, Kd), guardando il grafico nel Serial Plotter trovi una buona taratura in pochi minuti. Per rendere permanenti i valori trovati puoi salvarli nella EEPROM.

Il controllo PID unisce il ciclo misura-confronta-correggi in tre idee semplici e si usa ovunque, dai progetti hobbistici ai forni industriali. Prima vedi i limiti del controllo on-off, poi parti con P, frena con D e chiudi l'errore a regime con I; il grafico del Serial Plotter ti guiderà a ogni passo. Nell'app BlueGrays puoi seguire passo dopo passo, con schemi e codice, progetti che usano le parti di questo articolo, come la misura della temperatura con NTC, il rilevamento del fondo con TCRT5000, l'auto robot con L298N e il controllo PWM con potenziometro, e da lì cominciare ad aggiungere il PID al tuo progetto.

Domande frequenti

Cos'è il controllo PID e a cosa serve, in parole semplici?

Il controllo PID è un metodo di retroazione che calcola di continuo l'errore per mantenere una grandezza misurata sul valore desiderato e regola l'uscita di conseguenza. Il termine proporzionale reagisce all'errore presente, quello integrale all'errore accumulato e quello derivativo alla velocità di variazione dell'errore. Nel controllo di temperatura, velocità del motore, posizione ed equilibrio dà risultati molto più stabili e precisi del controllo on-off.

Come si trovano i valori di Kp, Ki e Kd?

Il modo più pratico è la taratura manuale: azzera Ki e Kd, aumenta Kp finché il sistema oscilla e poi riducilo alla metà, aggiungi Kd per smorzare l'overshoot e infine Ki per chiudere l'errore a regime. Il metodo di Ziegler-Nichols dà un buon punto di partenza, ma la taratura fine si fa quasi sempre a mano. I valori sono specifici del sistema: i coefficienti copiati da un altro progetto potrebbero non funzionare nel tuo circuito.

Qual è la differenza tra PID e controllo on-off?

Il controllo on-off porta l'uscita solo a tutto acceso o tutto spento, quindi si creano oscillazioni e overshoot continui attorno all'obiettivo. Il PID invece regola l'uscita in modo graduale, riduce la potenza in anticipo avvicinandosi all'obiettivo ed elimina l'errore a regime con il termine integrale. L'on-off è più semplice ed economico, il PID è più preciso ma richiede taratura.

Qual è la libreria PID per Arduino e come si installa?

La più diffusa è la libreria PID (PID_v1) di Brett Beauregard. Puoi installarla dal Gestore librerie dell'IDE di Arduino cercando "PID" e usarla includendo nel codice il file di intestazione PID_v1.h. La libreria gestisce da sola il tempo di campionamento, la limitazione dell'uscita e la protezione dal windup dell'integrale.

Cos'è il windup dell'integrale e come si evita?

Il windup dell'integrale si ha quando, con l'uscita già al limite (per es. riscaldatore a piena potenza), l'errore continua ad accumularsi nell'integrale. Quando si raggiunge l'obiettivo, questo valore accumulato fa superare l'obiettivo al sistema per molto tempo. Per evitarlo bisogna mantenere l'integrale entro i limiti d'uscita; nella libreria PID di Arduino lo fa SetOutputLimits in automatico.

Si può fare un controllo PID con un relè?

Sì, con il metodo della proporzione nel tempo (time proportioning): per esempio, in una finestra di 5 secondi, se l'uscita del PID è al 40%, il relè resta acceso 2 secondi e spento 3. Poiché i relè meccanici si usurano in fretta con commutazioni frequenti, per questo uso è più adatto un relè a stato solido (SSR). Nei sistemi che rispondono lentamente come un riscaldatore, questo metodo dà risultati buoni quanto il PWM.

Vedi tutti i progetti
Temperatura e umidità con DHT11
AR-55Intermedio

Temperatura e umidità con DHT11

Quanti gradi ci sono nella tua stanza, e l'aria è umida o secca? Il sensore DHT11 misura temperatura e umidità, e l'Arduino scrive i valori su uno schermo LCD a due righe, aggiornandoli ogni paio di…

4.7(47)
83
HC-SR04 Misura della distanza (display seriale)
AR-27Principiante

HC-SR04 Misura della distanza (display seriale)

Il sensore HC-SR04 funziona come un pipistrello che trova la strada al buio: manda un suono che non puoi sentire, ne ascolta l'eco e misura quanto è lontano l'oggetto davanti a sé.

4.6(50)
82
Misura di temperatura con NTC e display Lcd 2x16
AR-44Principiante
Premium

Misura di temperatura con NTC e display Lcd 2x16

Misura la temperatura dell'ambiente con un sensore che sembra una piccola perlina.

4.5(33)
44
TCRT5000 Rilevamento di superfici bianche e nere
AR-78Intermedio
Premium

TCRT5000 Rilevamento di superfici bianche e nere

Con il piccolo sensore che fa da occhio ai robot seguilinea capisci se il pavimento è nero o bianco.

4.7(40)
49
Lettura della riflessione (prossimità) con TCRT5000
AR-77Intermedio
Premium

Lettura della riflessione (prossimità) con TCRT5000

Con un piccolo sensore che manda luce invisibile e misura quanta ne torna indietro, rilevi la superficie che ha davanti.

4.6(33)
43
Robot che evita gli ostacoli
AR-81Avanzato
Premium

Robot che evita gli ostacoli

Che ne dite di costruire un veicolo intelligente che trova la propria strada? L'Obstacle Avoiding Robot scruta costantemente l'ambiente circostante grazie al sensore a ultrasuoni posto davanti a lui.

5.0(38)
49
Auto controllata via Bluetooth con L298N
AR-80Avanzato
Premium

Auto controllata via Bluetooth con L298N

Trasforma il telefono in un telecomando e guida la tua auto robot. L'Arduino riceve tramite un modulo Bluetooth i comandi di un'app di controllo remoto sul telefono e fa girare le ruote con un driver…

5.0(39)
66
Luminosità di un LED con Potenziometro su ESP32 (Analogico → PWM)
ES-13Intermedio
Premium

Luminosità di un LED con Potenziometro su ESP32 (Analogico → PWM)

In questo progetto controlliamo in modo analogico la luminosità di un LED tramite un potenziometro. Il pin ADC dell'ESP32 legge la tensione tra 0 e 3,3 V dal potenziometro; il valore viene convertito in un segnale PWM (Pulse Width Modulation) e inviato al LED. Ruotando il potenziometro, il LED si accende e si spegne gradualmente. Con Arduino Core 3.0+ si usa direttamente analogWrite(); su ESP32-S2/S3 la risoluzione dell'ADC è fissata a 12 bit.

4.5(19)
32