Basis · 13 min leestijd

PID-regelaar Arduino: Kp, Ki en Kd afstellen met codevoorbeelden

Wat is een PID-regelaar en hoe werkt hij? P-, I- en D-term, de Arduino PID-bibliotheek, Kp/Ki/Kd afstellen, plus code voor temperatuurregeling en een lijnvolgerrobot.

PID-regeling is een terugkoppelmethode die een systeem op de gewenste waarde houdt door continu het verschil tussen de gemeten waarde en de doelwaarde (de fout) te berekenen en de uitgang daarop aan te passen. In Arduino-projecten gebruik je het om een verwarming precies op 45 °C te houden, een motor op een constante snelheid te laten draaien of een lijnvolgerrobot precies langs het midden van de lijn te sturen. De naam komt van de drie onderdelen: de proportionele (P) term kijkt naar de huidige fout, de integrerende (I) term naar de fout die zich in het verleden heeft opgebouwd en de differentiërende (D) term naar hoe snel de fout verandert. De gewogen som van de drie bepaalt de PWM-waarde die naar de motor of de verwarming gaat.

De formules zien er in het begin eng uit, maar de logica van PID lijkt veel op wat je tijdens het autorijden al zonder nadenken doet. In dit bericht zie je eerst waarom simpele aan-uitregeling oscilleert en leer je de drie termen kennen aan de hand van herkenbare voorbeelden. Daarna bouw je met de Arduino PID-bibliotheek een temperatuurregeling met een NTC en een MOSFET, leer je Kp, Ki en Kd stap voor stap af te stellen en stuur je een lijnvolgerrobot aan met een PID die je zonder bibliotheek schrijft. Tot slot laten we hetzelfde algoritme draaien op de ESP32 en op de Raspberry Pi Pico met MicroPython.

Waarom is aan-uitregeling niet genoeg?

De eenvoudigste regelmethode is aan-uitregeling: ligt de temperatuur onder de doelwaarde, dan zet je de verwarming op volle kracht aan; ligt hij erboven, dan zet je hem uit. De cv-thermostaat thuis en een aquariumverwarming werken grotendeels zo. Het probleem is dat de warmte die in de verwarming zit opgeslagen, na het uitschakelen blijft doorstromen naar de omgeving, waardoor de temperatuur een paar graden boven de doelwaarde uitschiet. Zodra het afkoelt, gaat de verwarming weer aan, maar de temperatuur zakt onder de doelwaarde totdat het weer warm is. Het resultaat is een zaagtand die voortdurend rond de doelwaarde op en neer gaat. Om dit te dempen laat je een marge (hysterese) tussen twee drempels; het relais klikt dan minder vaak, maar de amplitude van de schommeling wordt groter. Bij het bed van een 3D-printer, een broedmachine of een motor die met een constante snelheid moet draaien, waar je binnen ±0,5 °C moet blijven, is dit niet genoeg. PID geeft daarentegen een geleidelijke uitgang tussen vol vermogen en nul en verlaagt het vermogen op tijd als het systeem de doelwaarde nadert.

MethodeHoe het beslistVoordelenNadelenTypische toepassing
Aan-uitVol vermogen onder de doelwaarde, uit erbovenHeel eenvoudig, kan zelfs met een relaisVoortdurende oscillatie en overshoot, slijtage van het relaisCv-thermostaat, aquariumverwarming
PUitgang evenredig met de foutSoepele respons, eenvoudig af te stellenLaat een blijvende fout overEenvoudige positie- en niveauregeling
PIProportioneel + opgebouwde foutVerwijdert de blijvende foutMeer overshoot, integraalopbouw (windup)Regeling van temperatuur, debiet en motorsnelheid
PIDProportioneel + opgebouwde fout + veranderingssnelheidSnel, weinig overshoot, nauwkeurigMoeilijk af te stellen, gevoelig voor ruis3D-printer, drone, balancerende robot, lijnvolgerrobot

Wat is PID-regeling en hoe werkt het?

In elke lus berekent PID eerst de fout: fout = doelwaarde (setpoint) − gemeten waarde (input). Daarna beoordeelt hij deze fout op drie manieren en telt die bij elkaar op: uitgang = Kp·e + Ki·∫e·dt + Kd·de/dt. Kp, Ki en Kd zijn coëfficiënten die je zelf instelt; ze bepalen hoeveel elke term bijdraagt aan de uitgang. Op een microcontroller wordt de integraal berekend door bij elke meting het product van de fout en de sampletijd bij een lopende som op te tellen, en de afgeleide door het verschil tussen de laatste twee metingen te delen door de sampletijd. Daarom is het belangrijk om voor een goede werking op vaste tijdstippen te meten, bijvoorbeeld elke 10 ms of elke 500 ms. Denk aan het volgen van een rijstrook in een auto: hoe verder je van de strook af zit, hoe meer je aan het stuur draait (P); duwt een zijwind je steeds weg, dan leer je het stuur een beetje gedraaid te houden (I); en als je snel naar de strook toe beweegt, haal je de bocht al vroeg uit het stuur (D).

TermWaar het naar kijktHerkenbare vergelijkingAls te hoog
P (proportioneel)De huidige foutHoe verder je van de strook af zit, hoe meer je aan het stuur draaitSnelle oscillatie, trillingen
I (integrerend)Fout die zich in de loop van de tijd heeft opgebouwdBij zijwind leer je het stuur een beetje gedraaid te houdenLangzame, brede oscillatie, grote overshoot
D (differentiërend)De veranderingssnelheid van de foutAls je snel naar de strook toe beweegt, haal je de bocht al vroeg uit het stuurOverreactie op ruis, onrustige uitgang

Proportionele (P) term: een respons die evenredig is met de fout

De proportionele term past de uitgang rechtstreeks evenredig aan de grootte van de fout aan. Bij Kp = 20 geeft een fout van 3 °C 60 PWM-eenheden en een fout van 1 °C 20 eenheden; naarmate je de doelwaarde nadert, daalt het vermogen automatisch. Als je Kp verhoogt, reageert het systeem sneller, maar vanaf een bepaald punt schiet het door de doelwaarde heen en slingert het terug, oftewel het oscilleert. Regelen met alleen P heeft een duidelijke zwakte: de blijvende fout (steady-state error). Stel dat je de verwarming op 45 °C houdt en daarvoor continu 80 eenheden vermogen nodig hebt om de warmte te compenseren die naar de omgeving ontsnapt. Met alleen een P-term kunnen die 80 eenheden alleen worden geleverd zolang er een fout is: 80 / 20 = 4 °C. Het systeem komt dus uit op ongeveer 41 °C en bereikt de doelwaarde nooit. Een hogere Kp verkleint dit verschil, maar vergroot ook de oscillatie.

Integrerende (I) term: wist de blijvende fout

De integrerende term telt de fout in de loop van de tijd op. Zelfs een kleine fout laat de som groeien als hij lang blijft bestaan, en de uitgang stijgt langzaam totdat de fout nul is. In het voorbeeld hierboven levert de integrerende term nu de benodigde 80 eenheden vermogen, daalt de P-term naar nul en stabiliseert de temperatuur precies op 45 °C. Hoe groter Ki, hoe sneller de blijvende fout verdwijnt; is Ki te groot, dan maakt het systeem langzame, brede oscillaties. Een bekende valkuil van de integraal is integraalopbouw (integral windup): als de verwarming al op vol vermogen staat en de doelwaarde niet kan halen, blijft de integraal nutteloos groeien, en zodra de doelwaarde is bereikt houdt deze opgebouwde waarde de temperatuur lange tijd boven de doelwaarde. De oplossing is om de integraal te begrenzen met de uitgangslimieten; de Arduino PID-bibliotheek doet dit automatisch met SetOutputLimits.

Differentiërende (D) term: remt af als je de doelwaarde nadert

De differentiërende term kijkt naar hoe snel de fout verandert en geeft een soort voorspelling. Als de temperatuur snel naar de doelwaarde toe gaat, wordt de fout snel kleiner; de D-term werkt dan tegen deze verandering in, verlaagt het vermogen vroeg en beperkt de overshoot. Hetzelfde gebeurt in een robot: een robot die snel naar de lijn toe draait, haalt zijn bocht al uit voordat hij de lijn kruist. De zwakte van de D-term is zijn gevoeligheid voor ruis. Als de waarde van een analoge sensor bij elke meting een paar eenheden springt, ziet de afgeleide die kleine sprongen als grote veranderingen en gaat de uitgang trillen. Daarom moet je de sensorwaarde middelen of filteren; zie het bericht over sensordata filteren voor details. Goede PID-implementaties nemen de afgeleide bovendien van de meting in plaats van van de fout; zo is er geen plotselinge sprong in de uitgang (derivative kick) als je de doelwaarde ineens verandert.

Voorbeeld 1: temperatuurregeling met de Arduino PID-bibliotheek

In het eerste voorbeeld houden we een klein verwarmingselement (een 12 V-verwarmingsmat of een vermogensweerstand) op 45 °C. We meten de temperatuur met een spanningsdeler van een NTC-thermistor van 10 kΩ en een vaste weerstand van 10 kΩ, en sturen de verwarming met PWM aan via een logic-level N-kanaal-MOSFET (bijvoorbeeld IRLZ44N). Open in de Arduino IDE de Library Manager, zoek naar PID en installeer de PID-bibliotheek (PID_v1) van Brett Beauregard. Deze bibliotheek regelt details als het beheer van de sampletijd, uitgangsbegrenzing, bescherming tegen integraalopbouw en het nemen van de afgeleide van de meting voor je. Voor de details van de MOSFET-aansluiting kun je het bericht Een MOSFET gebruiken met Arduino bekijken.

NTC-thermistor als temperatuursensor
NTC-thermistor van 10 kΩ: de weerstand daalt als de temperatuur stijgt; hij wordt gebruikt als meetelement in PID-temperatuurregeling.
AansluitingArduino UnoESP32Raspberry Pi Pico
Voeding van de deler (bovenkant van de vaste weerstand van 10 kΩ)5V3V33V3
Knooppunt van de NTC en de vaste weerstandA0GPIO 34GP26 (ADC0)
Onderkant van de NTCGNDGNDGND
MOSFET-gate (via 220 Ω, met 10 kΩ naar GND)D9GPIO 25GP15
MOSFET sourceGNDGNDGND
VerwarmingTussen +12 V en de MOSFET-drainTussen +12 V en de MOSFET-drainTussen +12 V en de MOSFET-drain
Voed de verwarming nooit rechtstreeks vanaf een Arduino-pin; een pin kan hooguit zo'n 20–40 mA leveren, terwijl een verwarming ampères trekt. De minpool van de 12 V-adapter moet gemeenschappelijk zijn met de GND van de Arduino, anders schakelt de MOSFET niet goed in. Omdat de ESP32 en de Pico 3,3 V uitsturen, kies je een MOSFET die bij 3,3 V volledig geleidt (bijvoorbeeld AO3400) in plaats van de IRLZ44N; en als je een inductieve belasting zoals een ventilator of motor aanstuurt, plaats je een vrijloopdiode over de belasting.
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}

In de code beperkt de functie readTemperature() de ruis door 16 metingen te middelen, berekent ze de NTC-weerstand met de formule voor de spanningsdeler (R = 10 kΩ · adc / (1023 − adc)) en rekent ze die met de Beta-vergelijking (B = 3950) om naar graden Celsius. SetOutputLimits(0, 255) houdt de uitgang binnen het bereik van analogWrite en voorkomt dat de integraal buiten deze grenzen oploopt. SetSampleTime(500) laat de PID elke halve seconde rekenen; omdat warmte een langzaam veranderende grootheid is, is dat genoeg. Compute() geeft alleen true terug als het tijd is om te meten, dus je moet geen delay() in loop() gebruiken. Als je de drie waarden die naar de seriële poort worden geschreven opent in de Serial Plotter in het menu Tools, zie je de doelwaarde, de temperatuur en het verwarmingsvermogen als percentage in dezelfde grafiek en zie je het effect van je afstelling meteen. In een koelsysteem (bijvoorbeeld ventilatorkoeling) moet de uitgang stijgen als de temperatuur stijgt; gebruik dan REVERSE in plaats van DIRECT.

Kp, Ki en Kd afstellen: stap voor stap

  1. Zet Ki en Kd op nul, begin met een kleine waarde voor Kp (bijvoorbeeld 2) en open de Serial Plotter.
  2. Verdubbel Kp stap voor stap; stop zodra het systeem snel naar de doelwaarde gaat en er continu omheen begint te oscilleren. Gebruik ongeveer de helft van die waarde als Kp.
  3. Voeg Kd toe: begin met een kleine waarde en verhoog die totdat de overshoot en de oscillatie wegsterven. Als de uitgang gaat trillen of de motor gaat zoemen, is Kd te hoog of is de sensor te ruisig.
  4. Voeg Ki als laatste toe: verhoog hem langzaam totdat de blijvende fout binnen redelijke tijd verdwijnt. Als de temperatuur langzame, brede golven rond de doelwaarde tekent, verlaag je Ki.
  5. Test met een verstoring: verander de doelwaarde met 5 °C, blaas op de verwarming of geef de robot met de hand een lichte duw; kijk hoe lang het systeem nodig heeft om te herstellen en met hoeveel overshoot.
  6. Gebruik als je wilt de Ziegler-Nichols-methode als startpunt: meet met alleen P de versterking waarbij een aanhoudende oscillatie begint (Ku) en de oscillatieperiode (Tu, in seconden); begin met Kp = 0,6·Ku, Ki = 1,2·Ku / Tu, Kd = 0,075·Ku·Tu en stel daarna met de hand fijn af.
Als je de coëfficiënt verhoogtStijgtijdOvershootInsteltijdBlijvende fout
KpWordt korterNeemt toeVerandert weinigNeemt af
KiWordt korterNeemt toeWordt langerVerdwijnt
KdVerandert weinigNeemt afWordt korterIn theorie geen effect

Voorbeeld 2: PID in een lijnvolgerrobot

TCRT5000 infraroodlijnsensor
TCRT5000 infrarood reflectiesensor: hij onderscheidt zwarte van witte oppervlakken en levert de ingang voor de PID in een lijnvolgerrobot.

Bij een lijnvolgerrobot is het de bedoeling dat de lijn precies in het midden van de robot blijft. Door een gewogen gemiddelde te nemen van de waarden van drie analoge TCRT5000-sensoren die links, in het midden en rechts zitten, maken we van de positie van de lijn een getal tussen 0 (uiterst links) en 2000 (uiterst rechts); 1000 is precies het midden. De fout is het verschil tussen de positie en 1000. De correctie die de PID levert, tel je op bij de snelheid van de linkermotor en trek je af van de snelheid van de rechtermotor, zodat de robot soepel naar de lijn toe draait. Een robot met simpele aan-uitlogica (links draaien als de lijn links ligt, rechts draaien als hij rechts ligt) wiebelt en rijdt langzaam, terwijl een PID-robot hetzelfde parcours veel sneller en met een vloeiend traject aflegt. In dit voorbeeld schrijven we de PID helemaal zelf, zonder bibliotheek; de motoren worden aangestuurd met een L298N-driver.

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}

De sensoren zijn aangesloten op A0, A1 en A2, de pinnen ENA en ENB van de L298N op de PWM-pinnen D5 en D6 en de pinnen IN1–IN4 op D7, D8, D9 en D10; vergeet niet de jumpers op ENA en ENB te verwijderen. De lus draait elke 10 ms met millis(); zo blijft dt constant en gedragen de coëfficiënten zich consistent. Waarom we millis() gebruiken in plaats van delay(), lees je in het bericht millis en delay. Is de fout negatief, dan ligt de lijn links: de correctie wordt negatief, de linkermotor vertraagt, de rechtermotor versnelt en de robot draait naar links. Omdat de fout hooguit 1000 is, betekent Kp = 0.1 een correctie van ongeveer 100 PWM-eenheden bij de grootste fout. Omdat de afgeleide per seconde wordt berekend, is het normaal dat Kd zo klein lijkt als 0.004. Bij een lijnvolger houd je Ki meestal op nul of heel klein; de integraal is alleen nuttig als de robot voortdurend naar één kant afdrijft (bijvoorbeeld doordat de ene motor zwakker is dan de andere). Als je eigen sensoren op een wit oppervlak hoog en op de zwarte lijn laag aflezen, keer je de waarde om als 1023 − v.

PID met de ESP32 en de Raspberry Pi Pico

Omdat de PID_v1-bibliotheek in puur C++ is geschreven, werkt hij zo op de ESP32; je hoeft alleen de NTC op GPIO 34 en de MOSFET-gate op GPIO 25 aan te sluiten. De verschillen zitten in de hardware: de ADC van de ESP32 is 12-bit (0–4095) en niet lineair aan de uiteinden van het bereik; als je de gemeten spanning tussen 0,3 en 2,8 V houdt, wordt het resultaat beter. Voor PWM gebruik je de LEDC-peripheral in plaats van analogWrite, en omdat deze API met core 3.x is veranderd, bevat de code een versiecontrole. Dankzij zijn snelheid en twee kernen kan de ESP32 tegelijk met de PID-lus een nieuwe doeltemperatuur van een webpagina ontvangen.

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}

Voor MicroPython op de Raspberry Pi Pico bestaat er geen kant-en-klare PID-module, dus schrijven we het algoritme als een kleine klasse. Deze klasse bootst drie belangrijke dingen van de Arduino-bibliotheek na: ze houdt de integraal binnen de uitgangslimieten (anti-windup), neemt de afgeleide van de meting en houdt rekening met de sampletijd (dt). De ADC van de Pico geeft met read_u16() waarden in het bereik 0–65535; de PID-uitgang wordt berekend in het bereik 0–255 en met 257 vermenigvuldigd om hem naar 16 bits te schalen voor duty_u16(). Zo kun je de Kp-, Ki- en Kd-waarden die je op de Arduino hebt gevonden ook op de Pico gebruiken. De NTC-deler zit op GP26 en de MOSFET-gate op GP15. Ben je nieuw met MicroPython, begin dan met het bericht MicroPython-basis.

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))

Projectideeën voor PID-regeling

  • Precisiethermostaat: gebruik in een Arduino-thermostaat-project PID in plaats van aan-uit om een broedmachine of een fermentatiekast binnen ±0,3 °C te houden.
  • Ventilatorsnelheid op basis van temperatuur: stuur in een project voor ventilatorregeling de ventilator aan met een PID in REVERSE-richting voor stille, constante koeling.
  • Snelle lijnvolgerrobot: voeg aan een lijnvolgerrobot-project 5 sensoren en PID toe om racesnelheid te halen.
  • Zelfbalancerende robot: meet de hellingshoek met een MPU-6050 en houd een robot met twee wielen rechtop; het is een van de leerzaamste toepassingen van PID.
  • Zonvolger: gebruik in een zonvolger-project het verschil tussen twee LDR's als fout en draai het paneel soepel mee.
  • Soldeerstation of mini-oven: meet hoge temperaturen met een MAX6675-thermokoppel en stuur de verwarming aan met PID.
  • Motor met constante snelheid: houd de snelheid van een DC-motor met reductie en encoder op de doelwaarde, ook als de belasting verandert.

Veelgemaakte fouten en hoe je ze oplost

SymptoomWaarschijnlijke oorzaakOplossing
Het systeem oscilleert voortdurend en snel rond de doelwaardeKp is te hoog of Kd is onvoldoendeVerlaag Kp met 30–50% en verhoog Kd een beetje
Het bereikt de doelwaarde nooit en blijft een paar graden eronderKi is nul of te kleinVerhoog Ki langzaam; controleer of het vermogen van de verwarming voldoende is
Grote, langdurige overshoot aan het einde van het opwarmenIntegraalopbouw (windup)Begrens de uitgang met SetOutputLimits, begrens de integraal, verlaag Ki
De uitgang trilt, de motor zoemtRuisige sensor en hoge KdMiddel of filter de meting, verlaag Kd
De uitgang stijgt als de temperatuur stijgtDe regelrichting is omgekeerdGebruik REVERSE voor koeling of draai het teken van de fout om
Dezelfde coëfficiënten werken soms goed en soms slechtOnregelmatige sampling, delay() in de lusGebruik een vaste dt met millis(), vermijd delay()
De verwarming staat altijd op vol vermogen, maar de temperatuur stijgt nietOnvoldoende hardware (vermogen, isolatie, MOSFET)PID kan ontbrekende hardware niet compenseren; controleer de voeding en de aansluitingen
Tijdens het afstellen wordt het vermoeiend om de coëfficiënten steeds te wijzigen door de code opnieuw te uploaden. Als je een paar regels toevoegt die opdrachten als "p2.5" of "d0.8" van de seriële poort lezen en de coëfficiënten direct bijwerken met SetTunings(Kp, Ki, Kd), vind je in een paar minuten een goede afstelling door de grafiek in de Serial Plotter te volgen. Om de gevonden waarden vast te leggen, kun je ze opslaan in het EEPROM.

PID-regeling combineert de lus van meten, vergelijken en corrigeren met drie eenvoudige ideeën, en wordt overal gebruikt, van hobbyprojecten tot industriële ovens. Zie eerst de grenzen van aan-uitregeling, begin dan met P, rem af met D en laat de blijvende fout verdwijnen met I; de grafiek in de Serial Plotter leidt je bij elke stap. In de BlueGrays-app kun je stap voor stap, met schakelschema's en code, projecten bekijken die de onderdelen uit dit bericht gebruiken, zoals temperatuurmeting met een NTC, oppervlaktedetectie met een TCRT5000, een L298N-robotauto en PWM-regeling met een potentiometer, en van daaruit PID aan je eigen project toevoegen.

Veelgestelde vragen

Wat is PID-regeling en waarvoor gebruik je het?

PID-regeling is een terugkoppelmethode die continu de fout berekent om een gemeten waarde op een doelwaarde te houden en de uitgang daarop aanpast. De proportionele term reageert op de huidige fout, de integrerende term op de opgebouwde fout en de differentiërende term op de veranderingssnelheid van de fout. Bij regeling van temperatuur, motorsnelheid, positie en balans geeft het veel stabielere en nauwkeurigere resultaten dan aan-uitregeling.

Hoe vind je de waarden voor Kp, Ki en Kd?

De meest praktische manier is handmatig afstellen: zet Ki en Kd op nul, verhoog Kp totdat het systeem oscilleert en halveer hem dan, voeg Kd toe om de overshoot te dempen en voeg Ki als laatste toe om de blijvende fout te laten verdwijnen. De Ziegler-Nichols-methode geeft een goed beginpunt, maar het fijnafstellen gebeurt bijna altijd met de hand. De waarden zijn specifiek voor het systeem; coëfficiënten die je uit een ander project overneemt, werken misschien niet in jouw schakeling.

Wat is het verschil tussen PID en aan-uitregeling?

Aan-uitregeling zet de uitgang volledig aan of volledig uit, waardoor er voortdurend oscillatie en overshoot rond de doelwaarde ontstaan. PID past de uitgang geleidelijk aan, verlaagt het vermogen op tijd als de doelwaarde dichtbij komt en wist de blijvende fout met de integrerende term. Aan-uit is eenvoudiger en goedkoper; PID is nauwkeuriger, maar moet worden afgesteld.

Welke Arduino PID-bibliotheek moet ik gebruiken en hoe installeer ik die?

De meest gebruikte is de PID-bibliotheek (PID_v1) van Brett Beauregard. Zoek in de Arduino IDE in de Library Manager naar "PID" om hem te installeren en neem daarna de header PID_v1.h op in je code. De bibliotheek regelt sampletijd, uitgangsbegrenzing en bescherming tegen integraalopbouw zelf.

Wat is integraalopbouw (integral windup) en hoe voorkom je het?

Integraalopbouw is wanneer de fout zich blijft opbouwen in de integraal terwijl de uitgang al op zijn limiet staat (bijvoorbeeld de verwarming op vol vermogen). Zodra de doelwaarde is bereikt, zorgt deze opgebouwde waarde ervoor dat het systeem lange tijd door de doelwaarde heen schiet. Om dit te voorkomen moet je de integraal binnen de uitgangslimieten houden; in de Arduino PID-bibliotheek doet SetOutputLimits dit automatisch.

Kun je PID-regeling doen met een relais?

Ja, met tijdproportionele aansturing: als de PID-uitgang bijvoorbeeld 40 procent is, houd je het relais in een venster van 5 seconden 2 seconden aan en 3 seconden uit. Omdat mechanische relais bij vaak schakelen snel slijten, is een solid-state relais (SSR) hiervoor beter geschikt. Voor traag reagerende systemen zoals verwarmingen werkt deze methode net zo goed als PWM.

Alle projecten bekijken
Temperatuur en luchtvochtigheid met DHT11
AR-55Gemiddeld

Temperatuur en luchtvochtigheid met DHT11

Hoe warm is je kamer, en is de lucht vochtig of droog? De DHT11-sensor meet temperatuur en luchtvochtigheid en de Arduino schrijft de waarden op een lcd-scherm met twee regels, dat om de paar…

4.7(47)
83
Afstand meten met HC-SR04 (Serial-weergave)
AR-27Beginner

Afstand meten met HC-SR04 (Serial-weergave)

De HC-SR04-sensor werkt net als een vleermuis die in het donker zijn weg vindt: hij stuurt een geluid uit dat je niet kunt horen, luistert naar de echo en meet hoe ver het object voor hem staat.

4.6(50)
82
Temperatuur meten met NTC en 2x16 LCD-display
AR-44Beginner
Premium

Temperatuur meten met NTC en 2x16 LCD-display

Meet de temperatuur om je heen met een sensor die op een klein kraaltje lijkt. Dit onderdeel, een NTC, laat elektriciteit makkelijker door naarmate het warmer wordt; de Arduino leest die verandering…

4.5(33)
44
Zwart-wit ondergrond herkennen met TCRT5000
AR-78Gemiddeld
Premium

Zwart-wit ondergrond herkennen met TCRT5000

Met de kleine sensor die de ogen van lijnvolgrobots vormt, merk je of de ondergrond zwart of wit is.

4.7(40)
49
Reflectie (nabijheid) meten met de TCRT5000
AR-77Gemiddeld
Premium

Reflectie (nabijheid) meten met de TCRT5000

Met een kleine sensor die onzichtbaar licht uitzendt en meet hoeveel er terugkaatst, detecteer je het oppervlak ervoor.

4.6(33)
43
Obstakelvermijdende robot
AR-81Gevorderd
Premium

Obstakelvermijdende robot

Zin om een slim voertuig te bouwen dat zelf zijn weg vindt? De obstakelvermijdende robot scant voortdurend zijn omgeving dankzij de ultrasone sensor voorop.

5.0(38)
49
Auto met Bluetooth-besturing en L298N
AR-80Gevorderd
Premium

Auto met Bluetooth-besturing en L298N

Verander je telefoon in een afstandsbediening en bestuur je eigen robotauto. De Arduino ontvangt via een Bluetooth-module commando's van een afstandsbedieningsapp op je telefoon en laat de wielen…

5.0(39)
66
ESP32 ledhelderheid regelen met een potmeter (analoog → PWM)
ES-13Gemiddeld
Premium

ESP32 ledhelderheid regelen met een potmeter (analoog → PWM)

In dit project regel je de helderheid van een led analoog met een potmeter. De ADC-pin van de ESP32 leest de spanning van 0–3,3 V van de potmeter; die waarde wordt omgezet in een PWM-signaal (pulsbreedtemodulatie) en naar de led gestuurd. Als je aan de potmeter draait, wordt de led dus geleidelijk helderder en zwakker. Met Arduino Core 3.0+ kun je analogWrite() direct gebruiken; op de ESP32-S2/S3 ligt de ADC-resolutie vast op 12 bit.

4.5(19)
32