PID-Regler Arduino: Kp, Ki, Kd einstellen mit Beispielen
Was ist ein PID-Regler? P-, I- und D-Anteil erklärt, Arduino-PID-Bibliothek, Kp/Ki/Kd einstellen, Code für Temperaturregelung und Linienfolger-Roboter.
Ein PID-Regler ist ein Regelverfahren mit Rückkopplung: Er berechnet ständig die Differenz zwischen Messwert und Sollwert (den Fehler) und stellt den Ausgang entsprechend ein, damit ein System auf einem gewünschten Wert bleibt. In Arduino-Projekten hältst du damit eine Heizung genau auf 45 °C, einen Motor auf konstanter Drehzahl oder lässt einen Linienfolger exakt in der Mitte der Linie fahren. Der Name kommt von den drei Anteilen: Der P-Anteil (proportional) reagiert auf den aktuellen Fehler, der I-Anteil (Integral) auf den über die Zeit aufsummierten Fehler und der D-Anteil (Differential) darauf, wie schnell sich der Fehler ändert. Die gewichtete Summe der drei bestimmt den PWM-Wert für Motor oder Heizung.
Die Formeln wirken auf den ersten Blick abschreckend, doch die Logik ähnelt dem, was du beim Autofahren ganz automatisch tust. In diesem Beitrag siehst du zuerst, warum eine einfache Ein-Aus-Regelung schwingt, und lernst dann die drei Anteile an anschaulichen Beispielen kennen. Danach baust du mit der Arduino-PID-Bibliothek, einem NTC und einem MOSFET eine Temperaturregelung, stellst Kp, Ki und Kd Schritt für Schritt ein und steuerst einen Linienfolger mit einem selbst geschriebenen PID ohne Bibliothek. Zum Schluss lassen wir denselben Algorithmus auf dem ESP32 und auf dem Raspberry Pi Pico mit MicroPython laufen.
Warum reicht eine Ein-Aus-Regelung nicht?
Die einfachste Regelung ist die Ein-Aus-Regelung (Zweipunktregelung): Liegt die Temperatur unter dem Sollwert, schaltest du die Heizung mit voller Leistung ein, liegt sie darüber, schaltest du sie aus. Der Thermostat deiner Heizung oder eines Aquariums arbeitet im Prinzip so. Das Problem: Wenn die Heizung abschaltet, gibt die gespeicherte Wärme weiter an die Umgebung ab, und die Temperatur schießt einige Grad über das Ziel hinaus. Beim Abkühlen fällt sie unter den Sollwert, bis die Heizung wieder eingeschaltet hat und aufgeheizt ist. Das Ergebnis ist ein Sägezahn um den Sollwert. Mit einer Hysterese zwischen zwei Schwellen schaltet das Relais zwar seltener, aber die Schwingung wird größer. Wenn du den Sollwert auf ±0,5 °C halten musst, etwa bei einem 3D-Drucker-Heizbett, einer Brutmaschine oder einem Motor mit konstanter Drehzahl, reicht das nicht. Ein PID-Regler liefert dagegen einen stufenlosen Ausgang zwischen voller Leistung und null und nimmt die Leistung schon vor dem Erreichen des Ziels zurück.
| Verfahren | Wie entscheidet es? | Vorteil | Nachteil | Typische Anwendung |
|---|---|---|---|---|
| Ein-Aus | Unter dem Sollwert volle Leistung, darüber aus | Sehr einfach, geht sogar mit Relais | Dauerndes Schwingen und Überschwingen, Relaisverschleiß | Heizungsthermostat, Aquarienheizer |
| P | Ausgang proportional zum Fehler | Sanfte Reaktion, leicht einzustellen | Bleibende Regelabweichung | Einfache Positions- und Füllstandsregelung |
| PI | Proportional + aufsummierter Fehler | Beseitigt die bleibende Abweichung | Mehr Überschwingen, Integral-Windup | Temperatur-, Durchfluss- und Drehzahlregelung |
| PID | Proportional + aufsummierter Fehler + Änderungsrate | Schnell, wenig Überschwingen, präzise | Schwer einzustellen, rauschempfindlich | 3D-Drucker, Drohne, Balancier-Roboter, Linienfolger |
Was ist ein PID-Regler und wie funktioniert er?
In jedem Durchlauf berechnet der PID zuerst den Fehler: Fehler = Sollwert (Setpoint) − Messwert (Input). Diesen Fehler wertet er auf drei Arten aus und addiert die Ergebnisse: Ausgang = Kp·e + Ki·∫e·dt + Kd·de/dt. Kp, Ki und Kd sind Faktoren, die du einstellst; sie bestimmen, wie stark jeder Anteil zum Ausgang beiträgt. Auf dem Mikrocontroller berechnest du das Integral, indem du bei jeder Abtastung Fehler mal Abtastzeit zu einer Summe addierst, und die Ableitung, indem du die Differenz der letzten beiden Messwerte durch die Abtastzeit teilst. Damit der PID sauber arbeitet, solltest du deshalb in festen Abständen messen, zum Beispiel alle 10 ms oder alle 500 ms. Stell dir vor, du folgst im Auto einer Spur: Je weiter du von der Mitte entfernt bist, desto mehr lenkst du (P); drückt dich ständig Seitenwind, lernst du, leicht gegenzulenken (I); und nähert du dich schnell der Spur, nimmst du die Lenkbewegung früh wieder zurück (D).
| Anteil | Worauf reagiert er? | Anschauliches Beispiel | Bei zu viel davon |
|---|---|---|---|
| P (proportional) | Aktueller Fehler | Je weiter du von der Spur weg bist, desto mehr lenkst du | Schnelles Schwingen, Zittern |
| I (Integral) | Über die Zeit aufsummierter Fehler | Bei Seitenwind lernst du, leicht gegenzulenken | Langsames, weites Schwingen, starkes Überschwingen |
| D (Differential) | Änderungsrate des Fehlers | Beim schnellen Annähern an die Spur nimmst du die Lenkung früh zurück | Starke Reaktion auf Rauschen, zitternder Ausgang |
P-Anteil: Reaktion proportional zum Fehler
Der P-Anteil stellt den Ausgang proportional zur Größe des Fehlers ein. Bei Kp = 20 erzeugt ein Fehler von 3 °C einen Wert von 60 PWM-Einheiten, ein Fehler von 1 °C nur 20 Einheiten; die Leistung sinkt also von selbst, je näher du dem Ziel kommst. Je größer Kp ist, desto schneller reagiert das System, doch ab einem gewissen Punkt überschwingt es und fängt an zu schwingen. Eine reine P-Regelung hat eine wichtige Schwäche: die bleibende Regelabweichung (Steady-State Error). Angenommen, du brauchst dauerhaft 80 Einheiten, um die Wärmeverluste bei 45 °C auszugleichen. Mit nur einem P-Anteil lassen sich diese 80 Einheiten nur bei einem vorhandenen Fehler erzeugen: 80 / 20 = 4 °C. Das System pendelt sich also bei etwa 41 °C ein und erreicht den Sollwert nie. Ein größeres Kp verkleinert die Abweichung, vergrößert aber auch das Schwingen.
I-Anteil: beseitigt die bleibende Abweichung
Der I-Anteil summiert den Fehler über die Zeit auf. Hält sich auch nur ein kleiner Fehler lange, wächst die Summe und der Ausgang steigt langsam an, bis der Fehler null ist. Im Beispiel oben liefert nun der I-Anteil die benötigten 80 Einheiten, der P-Anteil geht auf null zurück und die Temperatur stellt sich genau auf 45 °C ein. Je größer Ki, desto schneller verschwindet die bleibende Abweichung; ist es zu groß, schwingt das System langsam und weit. Eine bekannte Falle des Integrals ist das Integral-Windup: Läuft die Heizung schon mit voller Leistung und erreicht das Ziel trotzdem nicht, wächst das Integral sinnlos weiter, und wenn der Sollwert erreicht ist, bleibt die Temperatur wegen dieses aufgestauten Werts lange darüber. Die Lösung ist, das Integral auf die Ausgangsgrenzen zu beschränken; die Arduino-PID-Bibliothek macht das mit SetOutputLimits automatisch.
D-Anteil: bremst beim Annähern an den Sollwert
Der D-Anteil schaut darauf, wie schnell sich der Fehler ändert, und wirkt wie eine Art Vorausschau. Nähert sich die Temperatur schnell dem Sollwert, schrumpft der Fehler rasch; der D-Anteil wirkt dieser Änderung entgegen, nimmt die Leistung früh zurück und verringert das Überschwingen (Overshoot). Beim Roboter ist es genauso: Dreht er schnell auf die Linie zu, wird die Drehung weicher, bevor er die Linie überfährt. Die Schwäche des D-Anteils ist die Rauschempfindlichkeit. Springt der Messwert eines analogen Sensors bei jeder Messung um ein paar Einheiten, sieht die Ableitung diese kleinen Sprünge als große Änderungen, und der Ausgang zittert. Deshalb solltest du die Sensorwerte mitteln oder filtern; Details findest du im Beitrag Sensordaten filtern. Außerdem bilden gute PID-Implementierungen die Ableitung nicht aus dem Fehler, sondern aus dem Messwert; so entsteht bei einer plötzlichen Sollwertänderung kein Ausgangssprung (Derivative Kick).
Beispiel 1: Temperaturregelung mit der Arduino-PID-Bibliothek
Im ersten Beispiel halten wir eine kleine Heizung (12-V-Heizpad oder Leistungswiderstand) auf 45 °C. Die Temperatur messen wir mit einem Spannungsteiler aus einem 10-kΩ-NTC-Thermistor und einem festen 10-kΩ-Widerstand, die Heizung schalten wir per PWM über einen Logic-Level-N-Kanal-MOSFET (z. B. IRLZ44N). Öffne in der Arduino IDE den Bibliotheksverwalter, such nach PID und installiere die PID-Bibliothek von Brett Beauregard (PID_v1). Sie übernimmt für dich Details wie Abtastzeit, Ausgangsbegrenzung, Windup-Schutz und die Ableitung aus dem Messwert. Zum Anschluss des MOSFETs schau dir den Beitrag MOSFET mit Arduino verwenden an.

| Anschluss | Arduino Uno | ESP32 | Raspberry Pi Pico |
|---|---|---|---|
| Versorgung des Teilers (oberes Ende des 10-kΩ-Festwiderstands) | 5V | 3V3 | 3V3 |
| Verbindungspunkt von NTC und Festwiderstand | A0 | GPIO 34 | GP26 (ADC0) |
| Unteres Ende des NTC | GND | GND | GND |
| MOSFET-Gate (über 220 Ω, mit 10 kΩ nach GND) | D9 | GPIO 25 | GP15 |
| MOSFET-Source | GND | GND | GND |
| Heizung | Zwischen +12 V und MOSFET-Drain | Zwischen +12 V und MOSFET-Drain | Zwischen +12 V und 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}Im Code mittelt die Funktion readTemperature() 16 Messungen, um Rauschen zu reduzieren, berechnet den NTC-Widerstand aus der Teilerformel (R = 10 kΩ · adc / (1023 − adc)) und rechnet ihn mit der Beta-Gleichung (B = 3950) in Grad Celsius um. SetOutputLimits(0, 255) hält den Ausgang im analogWrite-Bereich und verhindert, dass das Integral über diese Grenzen hinauswächst. SetSampleTime(500) sorgt dafür, dass der PID alle halbe Sekunde rechnet; da sich Wärme langsam ändert, reicht das völlig. Compute() gibt nur true zurück, wenn die Abtastzeit erreicht ist, deshalb darfst du in loop() kein delay() verwenden. Öffnest du die drei seriell ausgegebenen Werte im Serial Plotter (Menü Werkzeuge), siehst du Sollwert, Temperatur und Heizleistung in Prozent im selben Diagramm und erkennst sofort die Wirkung deiner Einstellungen. Bei einem kühlenden System (z. B. Lüfterkühlung) muss der Ausgang steigen, wenn die Temperatur steigt; nimm dann statt DIRECT den Modus REVERSE.
Kp, Ki und Kd einstellen: Schritt für Schritt
- Setze Ki und Kd auf null, starte mit einem kleinen Kp (z. B. 2) und öffne den Serial Plotter.
- Verdopple Kp schrittweise, bis das System schnell auf den Sollwert zuläuft und dauerhaft um ihn schwingt; halte dann an. Nimm etwa die Hälfte dieses Werts als Kp.
- Füge Kd hinzu: Beginne mit einem kleinen Wert und erhöhe ihn, bis Überschwingen und Schwingen abklingen. Zittert der Ausgang oder zirpt der Motor, ist Kd zu groß oder der Sensor verrauscht.
- Füge Ki zuletzt hinzu: Erhöhe es langsam, bis die bleibende Abweichung in angemessener Zeit verschwindet. Zeichnet die Temperatur langsame, weite Wellen um den Sollwert, verringere Ki.
- Teste mit einer Störung: Ändere den Sollwert um 5 °C, puste auf die Heizung oder schubse den Roboter leicht an und beobachte, wie lange das System zur Erholung braucht und wie stark es überschwingt.
- Als Startpunkt kannst du die Ziegler-Nichols-Methode nutzen: Miss mit nur P den Verstärkungsfaktor (Ku), bei dem eine Dauerschwingung beginnt, und die Schwingungsperiode (Tu, in Sekunden); starte mit Kp = 0,6·Ku, Ki = 1,2·Ku / Tu, Kd = 0,075·Ku·Tu und stelle von Hand nach.
| Wenn du den Faktor erhöhst | Anstiegszeit | Überschwingen | Einschwingzeit | Bleibende Abweichung |
|---|---|---|---|---|
| Kp | Wird kürzer | Nimmt zu | Ändert sich kaum | Nimmt ab |
| Ki | Wird kürzer | Nimmt zu | Wird länger | Verschwindet |
| Kd | Ändert sich kaum | Nimmt ab | Wird kürzer | In der Theorie ohne Einfluss |
Beispiel 2: PID beim Linienfolger-Roboter

Beim Linienfolger soll die Linie genau in der Mitte des Roboters bleiben. Aus den Werten von drei analogen TCRT5000-Sensoren (links, Mitte, rechts) bilden wir einen gewichteten Mittelwert und erhalten die Linienposition als Zahl zwischen 0 (ganz links) und 2000 (ganz rechts); 1000 ist die Mitte. Der Fehler ist die Differenz zwischen Position und 1000. Die vom PID berechnete Korrektur wird zur Geschwindigkeit des linken Motors addiert und von der des rechten abgezogen, sodass der Roboter sanft zur Linie hin lenkt. Roboter mit einfacher Ein-Aus-Logik (Linie links: nach links, Linie rechts: nach rechts) wackeln und fahren langsam, ein Roboter mit PID fährt auf derselben Strecke deutlich schneller und ruhiger. In diesem Beispiel schreiben wir den PID ohne Bibliothek selbst; die Motoren steuert ein L298N-Treiber.
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}Die Sensoren hängen an A0, A1 und A2, die Anschlüsse ENA und ENB des L298N an den PWM-Pins D5 und D6, IN1–IN4 an D7, D8, D9 und D10; vergiss nicht, die Jumper auf ENA und ENB zu entfernen. Die Schleife läuft mit millis() alle 10 ms, damit dt konstant bleibt und die Faktoren zuverlässig wirken. Warum wir millis() statt delay() nehmen, steht im Beitrag millis und delay. Ist der Fehler negativ, liegt die Linie links: Die Korrektur wird negativ, der linke Motor wird langsamer, der rechte schneller und der Roboter dreht nach links. Da der Fehler höchstens 1000 beträgt, ergibt Kp = 0,1 beim größten Fehler eine Korrektur von etwa 100 PWM-Einheiten. Weil die Ableitung pro Sekunde berechnet wird, ist ein kleiner Wert wie Kd = 0,004 normal. Beim Linienfolger hält man Ki meist bei null oder sehr klein; das Integral hilft nur, wenn der Roboter dauerhaft in eine Richtung abdriftet (z. B. weil ein Motor schwächer ist). Liefern deine Sensoren auf weißem Untergrund hohe und auf der schwarzen Linie niedrige Werte, kehre die Messung mit 1023 − v um.
PID mit ESP32 und Raspberry Pi Pico
Die PID_v1-Bibliothek ist reines C++ und läuft deshalb unverändert auf dem ESP32; du musst nur den NTC an GPIO 34 und das MOSFET-Gate an GPIO 25 anschließen. Die Unterschiede liegen in der Hardware: Der ADC des ESP32 hat 12 Bit (0–4095) und ist an den Rändern nicht linear; hältst du die gemessene Spannung zwischen 0,3 und 2,8 V, wird das Ergebnis besser. Für PWM wird statt analogWrite die LEDC-Einheit verwendet, und weil sich diese API mit Core 3.x geändert hat, prüft der Code die Version. Dank des schnellen Dual-Core-Prozessors kann der ESP32 neben der PID-Schleife gleichzeitig über eine Webseite eine neue Solltemperatur entgegennehmen.
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}Für MicroPython auf dem Raspberry Pi Pico gibt es kein fertiges PID-Modul, deshalb schreiben wir den Algorithmus als kleine Klasse. Sie bildet drei wichtige Dinge der Arduino-Bibliothek nach: Das Integral bleibt innerhalb der Ausgangsgrenzen (Anti-Windup), die Ableitung wird aus dem Messwert gebildet, und die Abtastzeit (dt) wird berücksichtigt. Der ADC des Pico liefert mit read_u16() Werte von 0 bis 65535; der PID-Ausgang wird im Bereich 0–255 berechnet und für duty_u16() mit 257 auf 16 Bit skaliert. So kannst du die auf dem Arduino gefundenen Werte für Kp, Ki und Kd auch auf dem Pico unverändert nutzen. Der NTC-Teiler hängt an GP26, das MOSFET-Gate an GP15. Bist du neu bei MicroPython, starte mit dem Beitrag MicroPython-Grundlagen.
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))Projektideen mit PID-Regelung
- Präzises Thermostat: Halte bei einem Arduino-Thermostat eine Brutmaschine oder einen Gärschrank mit PID statt Ein-Aus auf ±0,3 °C.
- Lüfterdrehzahl nach Temperatur: Steuere bei einer Lüfterregelung den Lüfter mit einem PID im REVERSE-Modus für leise, konstante Kühlung.
- Schneller Linienfolger: Rüste deinen Linienfolger-Roboter mit 5 Sensoren und PID auf Wettbewerbstempo auf.
- Selbstbalancierender Roboter: Miss mit dem MPU-6050 den Neigungswinkel und halte einen zweirädrigen Roboter aufrecht; eine der lehrreichsten PID-Anwendungen.
- Solar-Tracker: Nutze bei einem Solar-Tracker die Differenz zweier LDRs als Fehler und drehe das Panel sanft nach.
- Lötstation oder Mini-Ofen: Miss hohe Temperaturen mit einem MAX6675-Thermoelement und steuere die Heizung per PID.
- Motor mit konstanter Drehzahl: Halte die Drehzahl eines Getriebemotors mit Encoder auch bei wechselnder Last auf dem Sollwert.
Häufige Fehler und Lösungen
| Symptom | Mögliche Ursache | Lösung |
|---|---|---|
| Das System schwingt dauernd und schnell um den Sollwert | Kp zu hoch oder Kd zu klein | Kp um 30–50 % senken, Kd etwas erhöhen |
| Der Sollwert wird nie erreicht, einige Grad zu niedrig | Ki null oder zu klein | Ki langsam erhöhen; prüfen, ob die Heizleistung ausreicht |
| Am Ende des Aufheizens großes, langes Überschwingen | Integral-Windup | Ausgang mit SetOutputLimits begrenzen, Integral beschränken, Ki senken |
| Ausgang zittert, Motor zirpt | Verrauschter Sensor und hohes Kd | Messwert mitteln oder filtern, Kd senken |
| Der Ausgang steigt, wenn die Temperatur steigt | Wirkrichtung falsch | Beim Kühlen REVERSE nutzen oder das Vorzeichen des Fehlers umkehren |
| Dieselben Faktoren funktionieren mal gut, mal schlecht | Unregelmäßige Abtastung, delay() in loop | Mit millis() ein festes dt nutzen, delay() vermeiden |
| Heizung läuft ständig voll, Temperatur steigt nicht | Hardware zu schwach (Leistung, Dämmung, MOSFET) | Ein PID kann fehlende Hardware nicht ausgleichen; Leistung und Anschlüsse prüfen |
Ein PID-Regler verbindet den Kreislauf aus Messen, Vergleichen und Korrigieren in drei einfachen Ideen und wird überall eingesetzt, von Hobbyprojekten bis zu Industrieöfen. Erkenne zuerst die Grenzen der Ein-Aus-Regelung, beginne dann mit P, bremse mit D und beseitige die bleibende Abweichung mit I; das Diagramm im Serial Plotter zeigt dir bei jedem Schritt den Weg. In der BlueGrays-App findest du Projekte mit den Bauteilen aus diesem Beitrag, etwa Temperaturmessung mit NTC, Untergrunderkennung mit TCRT5000, Roboterauto mit L298N und PWM-Steuerung per Potentiometer, jeweils mit Schaltplänen und Code; von dort aus kannst du PID in dein eigenes Projekt einbauen.
Häufige Fragen
Was ist ein PID-Regler und wofür braucht man ihn?
Ein PID-Regler ist ein Regelverfahren mit Rückkopplung, das den Fehler zwischen Messwert und Sollwert ständig berechnet und den Ausgang entsprechend anpasst. Der P-Anteil reagiert auf den aktuellen Fehler, der I-Anteil auf den aufsummierten Fehler und der D-Anteil auf die Änderungsrate. Bei Temperatur, Motordrehzahl, Position und Balance liefert er deutlich stabilere und präzisere Ergebnisse als eine Ein-Aus-Regelung.
Wie finde ich die richtigen Werte für Kp, Ki und Kd?
Am praktischsten ist das manuelle Einstellen: Setze Ki und Kd auf null, erhöhe Kp, bis das System schwingt, und nimm dann die Hälfte. Füge Kd hinzu, um das Überschwingen zu dämpfen, und zuletzt Ki, um die bleibende Abweichung zu beseitigen. Die Ziegler-Nichols-Methode liefert einen guten Startpunkt, die Feinabstimmung erfolgt aber fast immer von Hand. Die Werte sind systemspezifisch; Faktoren aus einem anderen Projekt funktionieren in deiner Schaltung womöglich nicht.
Was ist der Unterschied zwischen PID- und Ein-Aus-Regelung?
Die Ein-Aus-Regelung kennt nur voll an oder voll aus, daher schwingt und überschwingt sie ständig um den Sollwert. Ein PID stellt den Ausgang stufenlos ein, nimmt die Leistung vor dem Ziel zurück und beseitigt die bleibende Abweichung mit dem I-Anteil. Ein-Aus ist einfacher und billiger, PID ist präziser, muss aber eingestellt werden.
Welche Arduino-PID-Bibliothek gibt es und wie installiere ich sie?
Am weitesten verbreitet ist die PID-Bibliothek von Brett Beauregard (PID_v1). Such im Bibliotheksverwalter der Arduino IDE nach "PID", installiere sie und binde die Header-Datei PID_v1.h in deinen Code ein. Die Bibliothek kümmert sich selbst um Abtastzeit, Ausgangsbegrenzung und Schutz vor Integral-Windup.
Was ist Integral-Windup und wie verhindere ich es?
Integral-Windup bedeutet, dass sich der Fehler im Integral weiter aufsummiert, obwohl der Ausgang schon an der Grenze ist (z. B. Heizung auf voller Leistung). Ist das Ziel erreicht, überschwingt das System wegen dieses aufgestauten Werts lange über den Sollwert. Um das zu verhindern, musst du das Integral innerhalb der Ausgangsgrenzen halten; in der Arduino-PID-Bibliothek macht SetOutputLimits das automatisch.
Kann ich einen PID-Regler mit einem Relais betreiben?
Ja, mit der Zeitproportionierung: Beträgt der PID-Ausgang in einem Fenster von 5 Sekunden zum Beispiel 40 %, ist das Relais 2 Sekunden an und 3 Sekunden aus. Da mechanische Relais bei häufigem Schalten schnell verschleißen, eignet sich dafür besser ein Halbleiterrelais (SSR). Bei trägen Systemen wie Heizungen liefert diese Methode ähnlich gute Ergebnisse wie PWM.
Projekte, die du danach bauen kannst
Alle Projekte ansehen
Temperatur und Luftfeuchtigkeit mit DHT11
Wie warm ist dein Zimmer, und ist die Luft feucht oder trocken? Der DHT11-Sensor misst Temperatur und Luftfeuchtigkeit, und der Arduino schreibt die Werte auf ein zweizeiliges LCD und aktualisiert…

HC-SR04 Abstandsmessung (serielle Anzeige)
Der Sensor HC-SR04 funktioniert wie eine Fledermaus, die im Dunkeln ihren Weg findet: Er sendet einen Ton, den du nicht hörst, lauscht auf das Echo und misst, wie weit der Gegenstand vor ihm entfernt…

Temperaturmessung mit NTC und 2x16 Lcd Display
Miss die Umgebungstemperatur mit einem Sensor, der aussieht wie eine kleine Perle.

TCRT5000 Schwarz-Weiß-Untergrunderkennung
Mit dem kleinen Sensor, der bei Linienfolger-Robotern als Auge dient, erkennst du, ob der Boden schwarz oder weiß ist.

Reflexion (Nähe) mit TCRT5000 messen
Mit einem kleinen Sensor, der unsichtbares Licht aussendet und misst, wie viel davon zurückkommt, erkennst du die Fläche vor ihm.

Roboter zur Hindernisvermeidung
Wie wäre es, ein intelligentes Fahrzeug zu bauen, das seinen Weg selbst findet? Der Obstacle Avoiding Robot scannt dank des Ultraschallsensors vor ihm ständig seine Umgebung.

Bluetooth-gesteuertes Auto mit L298N
Mach dein Handy zur Fernbedienung und steuere dein eigenes Roboterauto. Der Arduino empfängt über ein Bluetooth-Modul die Befehle einer Fernsteuer-App auf dem Handy und treibt die Räder über einen…

ESP32: LED-Helligkeit mit Potentiometer (Analog → PWM)
In diesem Projekt steuern wir die Helligkeit einer LED analog über ein Potentiometer. Der ADC-Pin des ESP32 liest die vom Potentiometer kommende Spannung von 0-3,3 V aus, woraufhin dieser Wert in ein PWM-Signal (Pulsweitenmodulation) umgewandelt und an die LED gesendet wird. So leuchtet die LED beim Drehen des Potentiometers stufenweise auf und erlischt wieder. Mit Arduino Core 3.0+ kann analogWrite() direkt verwendet werden; bei ESP32-S2/S3 ist die ADC-Auflösung auf 12 Bit festgelegt.
Weitere Artikel
BlueGrays-App
Diese Schaltung Schritt für Schritt auf dem Handy nachbauen
Schaltplan, Code und Teileliste auf einem Bildschirm. Über 500 Arduino-, ESP32- und Pico-Projekte zum Nachbauen.
Mit dem Handy scannen
Richte die Kamera auf den Code, dann öffnet sich der App-Store deines Handys.
oder im Store öffnen

