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.
| Methode | Hoe het beslist | Voordelen | Nadelen | Typische toepassing |
|---|---|---|---|---|
| Aan-uit | Vol vermogen onder de doelwaarde, uit erboven | Heel eenvoudig, kan zelfs met een relais | Voortdurende oscillatie en overshoot, slijtage van het relais | Cv-thermostaat, aquariumverwarming |
| P | Uitgang evenredig met de fout | Soepele respons, eenvoudig af te stellen | Laat een blijvende fout over | Eenvoudige positie- en niveauregeling |
| PI | Proportioneel + opgebouwde fout | Verwijdert de blijvende fout | Meer overshoot, integraalopbouw (windup) | Regeling van temperatuur, debiet en motorsnelheid |
| PID | Proportioneel + opgebouwde fout + veranderingssnelheid | Snel, weinig overshoot, nauwkeurig | Moeilijk af te stellen, gevoelig voor ruis | 3D-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).
| Term | Waar het naar kijkt | Herkenbare vergelijking | Als te hoog |
|---|---|---|---|
| P (proportioneel) | De huidige fout | Hoe verder je van de strook af zit, hoe meer je aan het stuur draait | Snelle oscillatie, trillingen |
| I (integrerend) | Fout die zich in de loop van de tijd heeft opgebouwd | Bij zijwind leer je het stuur een beetje gedraaid te houden | Langzame, brede oscillatie, grote overshoot |
| D (differentiërend) | De veranderingssnelheid van de fout | Als je snel naar de strook toe beweegt, haal je de bocht al vroeg uit het stuur | Overreactie 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.

| Aansluiting | Arduino Uno | ESP32 | Raspberry Pi Pico |
|---|---|---|---|
| Voeding van de deler (bovenkant van de vaste weerstand van 10 kΩ) | 5V | 3V3 | 3V3 |
| Knooppunt van de NTC en de vaste weerstand | A0 | GPIO 34 | GP26 (ADC0) |
| Onderkant van de NTC | GND | GND | GND |
| MOSFET-gate (via 220 Ω, met 10 kΩ naar GND) | D9 | GPIO 25 | GP15 |
| MOSFET source | GND | GND | GND |
| Verwarming | Tussen +12 V en de MOSFET-drain | Tussen +12 V en de MOSFET-drain | Tussen +12 V en de MOSFET-drain |
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
- Zet Ki en Kd op nul, begin met een kleine waarde voor Kp (bijvoorbeeld 2) en open de Serial Plotter.
- 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.
- 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.
- 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.
- 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.
- 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 verhoogt | Stijgtijd | Overshoot | Insteltijd | Blijvende fout |
|---|---|---|---|---|
| Kp | Wordt korter | Neemt toe | Verandert weinig | Neemt af |
| Ki | Wordt korter | Neemt toe | Wordt langer | Verdwijnt |
| Kd | Verandert weinig | Neemt af | Wordt korter | In theorie geen effect |
Voorbeeld 2: 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.
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.
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.
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
| Symptoom | Waarschijnlijke oorzaak | Oplossing |
|---|---|---|
| Het systeem oscilleert voortdurend en snel rond de doelwaarde | Kp is te hoog of Kd is onvoldoende | Verlaag Kp met 30–50% en verhoog Kd een beetje |
| Het bereikt de doelwaarde nooit en blijft een paar graden eronder | Ki is nul of te klein | Verhoog Ki langzaam; controleer of het vermogen van de verwarming voldoende is |
| Grote, langdurige overshoot aan het einde van het opwarmen | Integraalopbouw (windup) | Begrens de uitgang met SetOutputLimits, begrens de integraal, verlaag Ki |
| De uitgang trilt, de motor zoemt | Ruisige sensor en hoge Kd | Middel of filter de meting, verlaag Kd |
| De uitgang stijgt als de temperatuur stijgt | De regelrichting is omgekeerd | Gebruik REVERSE voor koeling of draai het teken van de fout om |
| Dezelfde coëfficiënten werken soms goed en soms slecht | Onregelmatige sampling, delay() in de lus | Gebruik een vaste dt met millis(), vermijd delay() |
| De verwarming staat altijd op vol vermogen, maar de temperatuur stijgt niet | Onvoldoende hardware (vermogen, isolatie, MOSFET) | PID kan ontbrekende hardware niet compenseren; controleer de voeding en de aansluitingen |
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.
Projecten om hierna te bouwen
Alle projecten bekijken
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…

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.

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…

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.

Reflectie (nabijheid) meten met de TCRT5000
Met een kleine sensor die onzichtbaar licht uitzendt en meet hoeveel er terugkaatst, detecteer je het oppervlak ervoor.

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.

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…

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.
Meer artikelen
BlueGrays-app
Bouw deze schakeling stap voor stap op je telefoon
Schakelschema, code en onderdelenlijst op één scherm. Meer dan 500 Arduino-, ESP32- en Pico-projecten om te bouwen.
Scan met je telefoon
Richt je camera op de code en de appstore van je telefoon opent.
of open de store

