Grundlagen · 11 Min. Lesezeit

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.

VerfahrenWie entscheidet es?VorteilNachteilTypische Anwendung
Ein-AusUnter dem Sollwert volle Leistung, darüber ausSehr einfach, geht sogar mit RelaisDauerndes Schwingen und Überschwingen, RelaisverschleißHeizungsthermostat, Aquarienheizer
PAusgang proportional zum FehlerSanfte Reaktion, leicht einzustellenBleibende RegelabweichungEinfache Positions- und Füllstandsregelung
PIProportional + aufsummierter FehlerBeseitigt die bleibende AbweichungMehr Überschwingen, Integral-WindupTemperatur-, Durchfluss- und Drehzahlregelung
PIDProportional + aufsummierter Fehler + ÄnderungsrateSchnell, wenig Überschwingen, präziseSchwer einzustellen, rauschempfindlich3D-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).

AnteilWorauf reagiert er?Anschauliches BeispielBei zu viel davon
P (proportional)Aktueller FehlerJe weiter du von der Spur weg bist, desto mehr lenkst duSchnelles Schwingen, Zittern
I (Integral)Über die Zeit aufsummierter FehlerBei Seitenwind lernst du, leicht gegenzulenkenLangsames, weites Schwingen, starkes Überschwingen
D (Differential)Änderungsrate des FehlersBeim schnellen Annähern an die Spur nimmst du die Lenkung früh zurückStarke 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.

NTC-Thermistor als Temperatursensor
10-kΩ-NTC-Thermistor: Mit steigender Temperatur sinkt sein Widerstand; bei der PID-Temperaturregelung dient er als Messelement.
AnschlussArduino UnoESP32Raspberry Pi Pico
Versorgung des Teilers (oberes Ende des 10-kΩ-Festwiderstands)5V3V33V3
Verbindungspunkt von NTC und FestwiderstandA0GPIO 34GP26 (ADC0)
Unteres Ende des NTCGNDGNDGND
MOSFET-Gate (über 220 Ω, mit 10 kΩ nach GND)D9GPIO 25GP15
MOSFET-SourceGNDGNDGND
HeizungZwischen +12 V und MOSFET-DrainZwischen +12 V und MOSFET-DrainZwischen +12 V und MOSFET-Drain
Versorge die Heizung niemals direkt über einen Arduino-Pin; ein Pin liefert höchstens etwa 20–40 mA, eine Heizung zieht aber mehrere Ampere. Der Minuspol des 12-V-Netzteils muss mit GND des Arduino verbunden sein, sonst schaltet der MOSFET nicht richtig durch. Da ESP32 und Pico mit 3,3 V arbeiten, nimm statt des IRLZ44N einen MOSFET, der schon bei 3,3 V voll durchschaltet (z. B. AO3400); bei einer induktiven Last wie Lüfter oder Motor setzt du außerdem eine Freilaufdiode antiparallel zur Last.
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}

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

  1. Setze Ki und Kd auf null, starte mit einem kleinen Kp (z. B. 2) und öffne den Serial Plotter.
  2. 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.
  3. 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.
  4. 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.
  5. 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.
  6. 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öhstAnstiegszeitÜberschwingenEinschwingzeitBleibende Abweichung
KpWird kürzerNimmt zuÄndert sich kaumNimmt ab
KiWird kürzerNimmt zuWird längerVerschwindet
KdÄndert sich kaumNimmt abWird kürzerIn der Theorie ohne Einfluss

Beispiel 2: PID beim Linienfolger-Roboter

TCRT5000-Infrarot-Liniensensor
TCRT5000-Infrarot-Reflexsensor: Er unterscheidet schwarzen und weißen Untergrund und liefert beim Linienfolger den Eingang für den PID.

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.

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}

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.

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}

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.

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

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

SymptomMögliche UrsacheLösung
Das System schwingt dauernd und schnell um den SollwertKp zu hoch oder Kd zu kleinKp um 30–50 % senken, Kd etwas erhöhen
Der Sollwert wird nie erreicht, einige Grad zu niedrigKi null oder zu kleinKi langsam erhöhen; prüfen, ob die Heizleistung ausreicht
Am Ende des Aufheizens großes, langes ÜberschwingenIntegral-WindupAusgang mit SetOutputLimits begrenzen, Integral beschränken, Ki senken
Ausgang zittert, Motor zirptVerrauschter Sensor und hohes KdMesswert mitteln oder filtern, Kd senken
Der Ausgang steigt, wenn die Temperatur steigtWirkrichtung falschBeim Kühlen REVERSE nutzen oder das Vorzeichen des Fehlers umkehren
Dieselben Faktoren funktionieren mal gut, mal schlechtUnregelmäßige Abtastung, delay() in loopMit millis() ein festes dt nutzen, delay() vermeiden
Heizung läuft ständig voll, Temperatur steigt nichtHardware zu schwach (Leistung, Dämmung, MOSFET)Ein PID kann fehlende Hardware nicht ausgleichen; Leistung und Anschlüsse prüfen
Beim Einstellen ist es mühsam, die Faktoren jedes Mal durch erneutes Hochladen zu ändern. Fügst du ein paar Zeilen hinzu, die über die serielle Schnittstelle Befehle wie "p2.5" oder "d0.8" lesen und die Faktoren mit SetTunings(Kp, Ki, Kd) im Betrieb aktualisieren, findest du anhand des Serial-Plotter-Diagramms in wenigen Minuten eine gute Einstellung. Um die gefundenen Werte dauerhaft zu speichern, kannst du sie im EEPROM ablegen.

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.

Alle Projekte ansehen
Temperatur und Luftfeuchtigkeit mit DHT11
AR-55Mittel

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…

4.7(47)
83
HC-SR04 Abstandsmessung (serielle Anzeige)
AR-27Anfänger

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…

4.6(50)
82
Temperaturmessung mit NTC und 2x16 Lcd Display
AR-44Anfänger
Premium

Temperaturmessung mit NTC und 2x16 Lcd Display

Miss die Umgebungstemperatur mit einem Sensor, der aussieht wie eine kleine Perle.

4.5(33)
44
TCRT5000 Schwarz-Weiß-Untergrunderkennung
AR-78Mittel
Premium

TCRT5000 Schwarz-Weiß-Untergrunderkennung

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

4.7(40)
49
Reflexion (Nähe) mit TCRT5000 messen
AR-77Mittel
Premium

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.

4.6(33)
43
Roboter zur Hindernisvermeidung
AR-81Fortgeschritten
Premium

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.

5.0(38)
49
Bluetooth-gesteuertes Auto mit L298N
AR-80Fortgeschritten
Premium

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…

5.0(39)
66
ESP32: LED-Helligkeit mit Potentiometer (Analog → PWM)
ES-13Mittel
Premium

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.

4.5(19)
32