Arduino Watchdog Timer: Hängenden Mikrocontroller resetten
Was ist ein Arduino Watchdog Timer? So resettest du hängende Boards: avr/wdt.h beim Uno, Task WDT beim ESP32, machine.WDT beim Pico, mit typischen Fehlern.
Der Arduino Watchdog ist ein Hardware-Sicherheitstimer, der erkennt, dass das Programm hängt, und das Board von selbst neu startet. Dein Programm sendet regelmäßig das Signal "Ich laufe noch". Kommt es nicht innerhalb der eingestellten Zeit, setzt der Watchdog das Board zurück, als hättest du die Reset-Taste gedrückt. So fängt sich ein Projekt, das in einer Endlosschleife steckt, auf einen Sensor wartet oder in der WLAN-Bibliothek hängt, nach wenigen Sekunden wieder, ohne dass du den Stecker ziehen musst.
Am Schreibtisch ist ein hängendes Board schnell von Hand resettet. Bei der Bewässerungsanlage im Garten, der Wetterstation auf dem Dach oder einem Smart-Home-Gerät, das wochenlang läuft, geht das nicht. In diesem Beitrag lernst du, wie der Watchdog funktioniert, wie du avr/wdt.h beim Arduino Uno, den Task WDT beim ESP32 und machine.WDT beim Raspberry Pi Pico nutzt, wo der Feed-Befehl hingehört und welche klassischen Fehler das Board in einen Endlos-Reset schicken.

Was ist ein Watchdog Timer und wie funktioniert er?
Der Watchdog ist ein kleiner Zähler im Mikrocontroller, der unabhängig vom Hauptprogramm zählt. Du startest ihn mit einer Zeit, zum Beispiel 2 Sekunden, und er beginnt zu zählen. Der Feed-Befehl (englisch "feed" oder "kick the dog"), den du in jedem Programmdurchlauf aufrufst, setzt den Zähler auf null zurück. Läuft das Programm gesund, erreicht der Zähler nie sein Ende. Hängt es irgendwo, bleibt das Füttern aus, der Zähler läuft ab und der Watchdog löst einen Hardware-Reset aus. Danach startet das Board wie frisch eingeschaltet in setup().
Der Watchdog ist deshalb zuverlässig, weil er mit einer vom Haupttakt getrennten Taktquelle arbeitet. Beim ATmega328P des Arduino Uno ist das ein interner 128-kHz-Oszillator; selbst wenn der 16-MHz-Quarz oder der Programmablauf gestört ist, zählt der Watchdog weiter. Typische Ursachen für Hänger sind: eine while-Schleife, deren Abbruchbedingung nie eintritt, eine Bibliothek, die ewig auf einen nicht antwortenden I2C-Sensor wartet, RAM, das durch String-Verkettungen fragmentiert, ein Array-Überlauf, der den Speicher beschädigt, oder elektrische Störungen, die das Programm an eine zufällige Adresse springen lassen.
| Merkmal | Arduino Uno (ATmega328P) | ESP32 | Raspberry Pi Pico (RP2040) |
|---|---|---|---|
| Bibliothek / Modul | avr/wdt.h | esp_task_wdt.h | machine.WDT (MicroPython) |
| Start | wdt_enable(WDTO_2S) | esp_task_wdt_init / reconfigure + esp_task_wdt_add(NULL) | WDT(timeout=5000) |
| Füttern | wdt_reset() | esp_task_wdt_reset() | wdt.feed() |
| Längste Zeit | 8 s | Einstellbar (Arduino-Standard 5 s) | 8388 ms (ca. 8,3 s) |
| Stoppen | wdt_disable() | Task mit esp_task_wdt_delete() entfernen | Nicht stoppbar (nur durch Reset) |
| Taktquelle | Interner 128-kHz-Oszillator | Hardware-Timergruppe (MWDT) | Interner 1-µs-Tick-Generator |
Was löst der Watchdog und was nicht?
- Endlosschleifen: Eine while-Schleife, deren erwarteter Wert nie kommt, oder eine Zustandsmaschine, die sich durch einen Logikfehler verfängt, wird vom Watchdog in wenigen Sekunden aufgefangen.
- Hängende Bibliotheken: Friert eine Netzwerkbibliothek bei WLAN, MQTT oder HTTP ein oder blockiert ein Sensortreiber ohne Antwort das Board, bringt der Reset es in einen sauberen Zustand zurück.
- Speicherprobleme: Verhält sich das Programm wegen fragmentiertem RAM oder Stack-Überlauf seltsam und stürzt ab, bringt der Watchdog das Board wieder hoch.
- Elektrische Störungen: Springt das Programm durch Störungen von Relais, Motoren oder langen Kabeln an eine zufällige Stelle, rettet dich das ausbleibende Füttern.
- Was er nicht löst: Unterspannung (Brownout), einen blockierten externen Sensor oder falsch berechnete Werte. Der Watchdog resettet nur den Mikrocontroller; ein Sensor, der die I2C-Leitung festhält, erholt sich oft erst, wenn seine Versorgung unterbrochen wird. Läuft das Programm falsch, aber regelmäßig, merkt der Watchdog es nicht.
Watchdog beim Arduino Uno: avr/wdt.h
Auf AVR-basierten Boards (Uno, Nano, Mega, Pro Mini) brauchst du keine zusätzliche Bibliothek; die mit dem Compiler gelieferte Header-Datei avr/wdt.h genügt. Es gibt drei Grundfunktionen: wdt_enable(Zeit) startet den Watchdog, wdt_reset() setzt den Zähler zurück (füttert ihn) und wdt_disable() schaltet ihn aus. Die Zeit gibst du mit einer der fertigen Konstanten an; es gibt zehn Optionen zwischen etwa 15 ms und 8 Sekunden. Mehr als 8 Sekunden kannst du nicht direkt wählen, mit der bedingten Fütterung weiter unten lassen sich aber längere Grenzen bauen.
| Konstante | Ungefähre Zeit | Typische Verwendung |
|---|---|---|
| WDTO_15MS | 15 ms | Sofortiger Software-Reset |
| WDTO_30MS | 30 ms | Selten verwendet |
| WDTO_60MS | 60 ms | Selten verwendet |
| WDTO_120MS | 120 ms | Sehr kurze Kontrollschleifen |
| WDTO_250MS | 250 ms | Schleifen mit schneller Reaktion |
| WDTO_500MS | 500 ms | Tasten- und LED-Steuerung |
| WDTO_1S | 1 s | Einfache Kontrollschleifen |
| WDTO_2S | 2 s | Sensorauslesen und Display-Update |
| WDTO_4S | 4 s | Langsame Sensoren, Kommunikation |
| WDTO_8S | 8 s | Netzwerkvorgänge, lange Berechnungen |
Schritt für Schritt: dein erster Watchdog-Test
- Verbinde den Arduino Uno per USB mit dem Computer; außer der eingebauten LED (Pin 13) brauchst du keine zusätzliche Schaltung.
- Lade den folgenden Code hoch und öffne den Seriellen Monitor mit 9600 Baud.
- Du siehst den Text "Basladi" und die LED, die alle 500 ms blinkt.
- Sende den Buchstaben k über den Seriellen Monitor; das Programm gerät absichtlich in eine Endlosschleife und die LED bleibt stehen.
- Nach etwa 2 Sekunden resettet sich das Board von selbst, "Basladi" erscheint erneut und die LED blinkt wieder.
1#include <avr/wdt.h>
2
3const int LED_PIN = 13; // dahili LED / onboard LED
4unsigned long sonYanip = 0;
5bool ledDurum = false;
6
7void setup() {
8 MCUSR = 0; // reset bayraklarını temizle / clear reset flags
9 wdt_disable(); // kurulum sırasında kapalı tut / keep off during setup
10 pinMode(LED_PIN, OUTPUT);
11 Serial.begin(9600);
12 Serial.println(F("Basladi / Started"));
13 wdt_enable(WDTO_2S); // 2 saniyelik watchdog / 2 second watchdog
14}
15
16void loop() {
17 wdt_reset(); // köpeği besle / feed the dog
18
19 if (millis() - sonYanip >= 500) {
20 sonYanip = millis();
21 ledDurum = !ledDurum;
22 digitalWrite(LED_PIN, ledDurum);
23 }
24
25 if (Serial.available() && Serial.read() == 'k') {
26 Serial.println(F("Kilitlendi / Hanging..."));
27 while (true) { } // besleme yok: 2 s sonra reset / no feed: reset after 2 s
28 }
29}Die Zeile MCUSR = 0 am Anfang von setup() löscht die Reset-Flags; beim ATmega328P lässt sich der Watchdog nicht abschalten, solange das Watchdog-Reset-Flag (WDRF) gesetzt ist, deshalb folgt wdt_disable() danach. Wir aktivieren den Watchdog erst am Ende von setup(), damit eine lange Sensorinitialisierung nicht versehentlich einen Reset auslöst. Das wdt_reset() in der ersten Zeile von loop() setzt den Zähler in jedem Durchlauf zurück. Dass wir die LED mit millis() statt delay() blinken lassen, ist Absicht: loop() läuft ohne Warten durch und füttert den Watchdog immer wieder innerhalb von Millisekunden.
Alter Bootloader und Endlos-Reset-Schleife
Löst der Watchdog einen Reset aus, schaltet ihn der ATmega328P nicht ab, sondern lässt ihn mit der kürzesten Zeit (ca. 16 ms) aktiv. Behandelt der Bootloader, das erste Programm, das beim Start läuft, diesen Fall nicht, läuft der Watchdog schon beim Warten auf einen Upload ab und das Board resettet erneut. Das Ergebnis ist eine Endlos-Reset-Schleife: Die LED blinkt schnell, dein Code startet nie und neuer Code lässt sich auch nicht hochladen. Der Optiboot-Bootloader des originalen Arduino Uno schaltet den Watchdog beim Start ab und hat dieses Problem nicht. Betroffen sind eher Nano-Klone mit altem Bootloader und einige ältere Mega-2560-Boards.
Wohin gehört der Feed-Befehl?
- Wähle eine einzige zentrale Stelle: Setze wdt_reset() in loop() an den einen Punkt, den jeder Durchlauf passiert. Streust du das Füttern in jede Ecke des Codes, füttert sich eine hängende Unterschleife selbst weiter und der Watchdog ist nutzlos.
- Füttere nie in einem Interrupt: Ein Timer-Interrupt läuft weiter, auch wenn das Hauptprogramm eingefroren ist. Fütterst du dort, erkennt der Watchdog keinen einzigen Hänger. Wie Interrupts funktionieren, steht im Beitrag Arduino Interrupt.
- Wähle die Zeit nach dem längsten Vorgang: Der Watchdog sollte mindestens doppelt so lang sein wie ein Durchlauf von loop() im schlechtesten Fall. Nutzt du WDTO_2S in einer Schleife mit delay(3000), resettet das Board ständig.
- Gib Warteschleifen ein Timeout: Statt in einer Schleife wie while (!Serial.available()) zu füttern, sorge dafür, dass die Schleife nach einer bestimmten Zeit verlassen wird. So friert das Board nicht ein und der Watchdog bleibt für echte Hänger wachsam.
- Aktiviere den Watchdog nach dem Setup: Schalte ihn erst ein, wenn lange Vorgänge wie WLAN-Verbindung, SD-Karten-Start oder Sensorkalibrierung in setup() abgeschlossen sind.
Ein klügerer Ansatz ist, das Füttern an eine Bedingung zu knüpfen: Du fütterst den Watchdog nur, wenn das System wirklich gesund ist. Im Beispiel unten wird ein an A0 angeschlossener Sensor alle 5 Sekunden gelesen; liegt der Wert im sinnvollen Bereich, wird der Zeitpunkt der letzten erfolgreichen Messung aktualisiert. Gibt es 60 Sekunden lang keine erfolgreiche Messung, bleibt das Füttern aus und das Board resettet nach 4 Sekunden. So baust du eine Überwachung im Minutenbereich jenseits der 8-Sekunden-Grenze von AVR und fängst nicht nur Hänger, sondern auch stille Fehler wie ein gerissenes Sensorkabel.
1#include <avr/wdt.h>
2
3const unsigned long OLCUM_ARALIK = 5000UL; // 5 s'de bir ölç / measure every 5 s
4const unsigned long MAKS_SESSIZLIK = 60000UL; // 60 s başarısızlık sınırı / 60 s failure limit
5unsigned long sonOlcum = 0;
6unsigned long sonBasari = 0;
7
8bool olcumYap() {
9 int deger = analogRead(A0); // örnek sensör / sample sensor
10 Serial.println(deger);
11 return deger > 10 && deger < 1013; // uç değer = kopuk kablo / extreme value = broken wire
12}
13
14void setup() {
15 MCUSR = 0; // reset bayraklarını temizle / clear reset flags
16 wdt_disable();
17 Serial.begin(9600);
18 sonBasari = millis();
19 wdt_enable(WDTO_4S); // 4 saniyelik watchdog / 4 second watchdog
20}
21
22void loop() {
23 unsigned long simdi = millis();
24
25 if (simdi - sonOlcum >= OLCUM_ARALIK) {
26 sonOlcum = simdi;
27 if (olcumYap()) {
28 sonBasari = simdi; // sağlıklı ölçüm / healthy reading
29 }
30 }
31
32 if (simdi - sonBasari < MAKS_SESSIZLIK) {
33 wdt_reset(); // yalnız sistem sağlıklıysa besle / feed only if healthy
34 }
35}Watchdog beim ESP32: Task WDT und Interrupt WDT
Beim ESP32 läuft ein Watchdog standardmäßig bereits; viele bemerken ihn zum ersten Mal, wenn im seriellen Monitor unerwartet "Task watchdog got triggered" erscheint. Da der ESP32 mit dem Betriebssystem FreeRTOS mehrere Tasks gleichzeitig ausführt, nutzt er statt eines einzelnen Zählers eine Schichtstruktur. Der Task WDT (TWDT) prüft, ob die bei ihm angemeldeten Tasks in einer bestimmten Zeit gefüttert werden; der Interrupt WDT (IWDT) erkennt, wenn Interrupts und der Task-Scheduler zu lange blockiert sind. Im Arduino-Core ist der TWDT meist mit 5 Sekunden aktiv und überwacht die Idle-Tasks; der Task, der loop() ausführt, wird nur überwacht, wenn du ihn hinzufügst. Das Standardverhalten kann je nach Core-Version abweichen, und in manchen Konfigurationen gibt der TWDT nur eine Warnung aus, ohne zu resetten; am sichersten stellst du Zeit und Reset-Verhalten deshalb explizit im Code ein.
| Art | Was wird überwacht? | Typische Zeit | Meldung beim Auslösen |
|---|---|---|---|
| Task WDT (TWDT) | Regelmäßiges Laufen der angemeldeten Tasks und der Idle-Tasks | 5 s (einstellbar) | task_wdt: Task watchdog got triggered |
| Interrupt WDT (IWDT) | Blockierung von Interrupts und Task-Scheduler | Ca. 300 ms | Guru Meditation Error ... Interrupt wdt timeout on CPU1 |
| RTC WDT | Hängen im Bootvorgang | Kurze Zeit beim Booten | rst:0x10 (RTCWDT_RTC_RESET) |
1#include <esp_task_wdt.h>
2#include <esp_system.h>
3
4#define WDT_SURE_S 10 // watchdog süresi (s) / watchdog timeout (s)
5
6void wdtKur() {
7#if ESP_ARDUINO_VERSION_MAJOR >= 3
8 esp_task_wdt_config_t cfg = {
9 .timeout_ms = WDT_SURE_S * 1000,
10 .idle_core_mask = 0, // idle görevlerini izleme / do not watch idle tasks
11 .trigger_panic = true // süre dolunca resetle / reset on timeout
12 };
13 if (esp_task_wdt_reconfigure(&cfg) == ESP_ERR_INVALID_STATE) {
14 esp_task_wdt_init(&cfg); // TWDT kapalıysa başlat / start TWDT if not running
15 }
16#else
17 esp_task_wdt_init(WDT_SURE_S, true); // 2.x: süre (s), panik / 2.x: timeout (s), panic
18#endif
19 esp_task_wdt_add(NULL); // bu görevi (loop) izle / watch this task (loop)
20}
21
22void setup() {
23 Serial.begin(115200);
24 esp_reset_reason_t neden = esp_reset_reason();
25 Serial.print("Reset nedeni / Reset reason: ");
26 Serial.println((int)neden);
27 if (neden == ESP_RST_TASK_WDT || neden == ESP_RST_INT_WDT || neden == ESP_RST_WDT) {
28 Serial.println("Watchdog reseti / Watchdog reset");
29 }
30 wdtKur();
31 Serial.println("Hazir / Ready");
32}
33
34void loop() {
35 esp_task_wdt_reset(); // besle / feed
36
37 // sensör, Wi-Fi ve ekran işleri burada / sensor, Wi-Fi and display work here
38
39 if (Serial.available() && Serial.read() == 'k') {
40 Serial.println("Kilitlendi / Hanging...");
41 while (true) { delay(10); } // besleme yok: 10 s sonra reset / no feed: reset after 10 s
42 }
43 delay(10);
44}Der Code prüft die Core-Version mit ESP_ARDUINO_VERSION_MAJOR: Bei 3.x (ESP-IDF 5) werden die Einstellungen über die Struktur esp_task_wdt_config_t übergeben und ein bereits laufender TWDT wird mit esp_task_wdt_reconfigure() aktualisiert; bei 2.x nimmt esp_task_wdt_init() direkt die Zeit in Sekunden und das Panic-Flag. Ist trigger_panic true, schreibt der ESP32 nach Ablauf der Zeit den Fehler-Dump auf die serielle Schnittstelle und resettet sich. esp_task_wdt_add(NULL) nimmt den aktuell laufenden Task, also den, der setup() und loop() ausführt, in die Überwachung auf. Mit esp_reset_reason() beim Start den Grund des letzten Resets auszulesen und zu speichern ist der einfachste Weg zu verstehen, warum ein Gerät im Feld neu gestartet ist. Willst du ohne weitere Einstellungen nur loop() überwachen, rufe in setup() die Funktion enableLoopWDT() des Arduino-Cores auf; dann wird am Anfang jedes loop()-Durchlaufs automatisch gefüttert.
Watchdog beim Raspberry Pi Pico (MicroPython)
Der Hardware-Watchdog des RP2040 wird in MicroPython über die Klasse machine.WDT genutzt. Die Zeit wird in Millisekunden angegeben und kann beim RP2040 höchstens 8388 ms betragen. Ein wichtiger Unterschied: Beim Pico lässt sich der Watchdog nach dem Start nicht per Code stoppen, er endet nur durch einen Reset. Deshalb rettet dich in der Entwicklung ein kleiner Notausgang. Im Code unten wird der Watchdog gar nicht gestartet, wenn Pin GP15 beim Start mit GND verbunden ist, und das Programm fällt in die REPL. Mit machine.reset_cause() erfährst du außerdem, ob das Board wegen des Watchdogs oder durch einen normalen Start hochgefahren ist. Programmierst du den Pico statt mit MicroPython mit der Arduino IDE (arduino-pico-Core), geht dasselbe mit den Funktionen rp2040.wdt_begin(5000) und rp2040.wdt_reset().
1import machine
2from machine import Pin, WDT
3import time
4
5led = Pin(25, Pin.OUT) # dahili LED (Pico W'da "LED") / onboard LED ("LED" on Pico W)
6kurtarma = Pin(15, Pin.IN, Pin.PULL_UP) # GND'ye bağlıysa WDT başlamaz / tied to GND = WDT skipped
7
8if machine.reset_cause() == machine.WDT_RESET:
9 print("Watchdog reseti / Watchdog reset")
10
11if kurtarma.value() == 0:
12 print("Kurtarma modu / Recovery mode")
13 raise SystemExit
14
15wdt = WDT(timeout=5000) # 5 s, RP2040'ta en fazla 8388 ms / max 8388 ms on RP2040
16son = time.ticks_ms()
17
18while True:
19 wdt.feed() # besle / feed
20 if time.ticks_diff(time.ticks_ms(), son) >= 500:
21 son = time.ticks_ms()
22 led.toggle()
23 time.sleep_ms(10)Watchdog-Strategie für lange laufende IoT-Projekte
- Starts protokollieren: Schreibe bei jedem Start einen Zähler beim Uno ins EEPROM, beim ESP32 in den Preferences-Speicher (NVS); beim ESP32 speicherst du auch den Grund per esp_reset_reason(). Ein Reset pro Woche ist akzeptabel, ein Reset pro Stunde ist ein Fehler, den du beheben musst. Da Optiboot die Reset-Flags löscht, lässt sich der Grund beim Uno oft nicht aus MCUSR lesen; der Startzähler zeigt trotzdem, wie oft das Gerät neu startet.
- Netzwerkvorgängen ein Timeout geben: Warte nicht ewig auf die WLAN-Verbindung; schaffst du sie zum Beispiel nicht in 15 Sekunden, verlasse die Schleife und versuche es nach einer Weile erneut. Einstellungen wie setTimeout() bei HTTPClient oder Wire.setWireTimeout() bei AVR verhindern, dass ein hängender Vorgang die Watchdog-Zeit überschreitet. Bei Verbindungsproblemen hilft der Beitrag ESP32 WLAN verbindet sich nicht.
- OTA-Updates berücksichtigen: Ein drahtloses Update dauert Sekunden, und in dieser Zeit kann loop() ruhen. Rufst du im onProgress-Callback von ArduinoOTA esp_task_wdt_reset() auf, verhinderst du, dass das Update mittendrin abbricht; das ist eine seltene, aber berechtigte Ausnahme von der Regel.
- Schlafmodi bedenken: Beim Uno lässt sich der Watchdog im Interrupt-Modus als Weck-Timer nutzen und du kannst in 8-Sekunden-Intervallen schlafen. Beim ESP32 ist die CPU im Deep Sleep aus und der Code startet nach dem Aufwachen von vorn. Details findest du im Beitrag ESP32 Deep Sleep.
- Externe Sensoren per Strom steuern: Der Watchdog resettet den Sensor nicht. Versorgst du einen oft hängenden I2C-Sensor über einen Transistor oder MOSFET und schaltest ihn beim Start für einige hundert Millisekunden aus und wieder ein, startet der Sensor zusammen mit dem Mikrocontroller sauber. Wie sich die I2C-Leitung festfährt, kannst du im Beitrag Was ist I2C nachlesen.
- Externer Watchdog für kritische Systeme: Der interne Watchdog erkennt nur Fehler des Mikrocontrollers selbst. Muss die ganze Schaltung überwacht werden, nutzt man einen externen Watchdog-Baustein, der regelmäßige Impulse von einem GPIO erwartet, oder einen zweiten kleinen Mikrocontroller.
Häufige Fehler und Lösungen
| Symptom | Wahrscheinliche Ursache | Lösung |
|---|---|---|
| Das Board resettet alle paar Sekunden | Watchdog-Zeit kürzer als der längste loop()-Durchlauf (z. B. WDTO_2S mit delay(3000)) | Zeit verlängern, millis() statt delay() nutzen |
| LED blinkt schnell, Code lässt sich nicht hochladen | Alter Bootloader schaltet den Watchdog nach einem Watchdog-Reset nicht ab | Optiboot per ISP aufspielen, Board mit aktueller Bootloader-Option programmieren |
| Das Board hängt, resettet aber nie | Füttern in einem Timer-Interrupt oder in einer hängenden Unterschleife | wdt_reset() an eine einzige Stelle in loop() verlegen |
| Beim ESP32 wiederholt sich "Task watchdog got triggered", kein Reset | TWDT nicht im Panic-Modus | trigger_panic auf true setzen (bei 2.x der zweite Parameter) |
| Beim ESP32 Warnung "IDLE (CPU 0)" | Ein Task auf Core 0 läuft ohne zu warten | vTaskDelay(1) in die Schleife einfügen |
| esp_task_wdt_reset() meldet "task not found" | Task wurde nicht beim TWDT angemeldet | Zuerst esp_task_wdt_add(NULL) aufrufen |
| Pico: Verbindung bricht ab, wenn man in Thonny stoppt | machine.WDT lässt sich nach dem Start nicht stoppen | Rettungs-Pin nutzen, Code beim Testen nicht als main.py laufen lassen |
| Beim Reset schaltet ein Relais oder Motor kurz unbeabsichtigt | Pins werden beim Reset zu Eingängen, der Treibereingang hängt in der Luft | Pull-down-Widerstand an die Ausgänge, am Anfang von setup() sicheren Zustand setzen |
Mit wenigen Zeilen Code macht ein Watchdog Timer aus deinem Versuchsaufbau ein Gerät, das tagelang allein läuft. Beseitige zuerst die eigentlichen Ursachen der Hänger, ergänze den Watchdog dann als letzte Sicherheitsschicht und setze das Füttern an eine einzige, sinnvolle Stelle. In der BlueGrays-App findest du lang laufende Projekte wie ESP32-WLAN-Verbindung, Webserver, OTA-Update, Wetterstation und smarte Bewässerung mit Schaltplänen und Code Schritt für Schritt und kannst den Watchdog selbst einbauen.
Häufige Fragen
Wozu dient ein Arduino Watchdog Timer?
Der Watchdog ist ein interner Timer, der das Board automatisch resettet, wenn das Programm nicht innerhalb der eingestellten Zeit das Signal "Ich laufe noch" sendet. Er holt Projekte, die in einer Endlosschleife stecken, auf einen Sensor warten oder in der Netzwerkbibliothek einfrieren, in wenigen Sekunden zurück. Besonders bei lange unbeaufsichtigten Bewässerungs-, Alarm- und IoT-Geräten ist er unverzichtbar.
Wie resette ich einen Arduino per Code?
Bei AVR-Boards ist der sauberste Weg, den Watchdog mit der kürzesten Zeit zu starten und zu warten: Mit wdt_enable(WDTO_15MS); while (true) {} bekommt das Board in kürzester Zeit einen echten Hardware-Reset. Beim ESP32 erledigt ESP.restart() dasselbe, beim Raspberry Pi Pico mit MicroPython machine.reset(). Bei Nano-Klonen mit altem Bootloader kann diese Methode eine Endlos-Reset-Schleife auslösen.
Wie lang kann die Watchdog-Zeit maximal sein?
Beim Arduino Uno und anderen AVR-Boards beträgt die längste Zeit 8 Sekunden (WDTO_8S). Beim Raspberry Pi Pico liegt die Grenze bei 8388 ms, beim Task WDT des ESP32 lässt sich die Zeit frei einstellen. Brauchst du eine längere Überwachung, kannst du mit der bedingten Fütterung, die den Watchdog nur füttert, solange das System gesund ist, Grenzen im Minutenbereich bauen.
Wie behebe ich den ESP32-Fehler "Task watchdog got triggered"?
Die Meldung zeigt, dass ein überwachter Task nicht rechtzeitig gefüttert wurde; die Ursache ist meist eine while-Schleife ohne Wartezeit oder ein FreeRTOS-Task, der den Idle-Task aushungert. Füge deinen Schleifen vTaskDelay(1) oder delay(1) hinzu, teile lange Vorgänge in Teile auf und rufe esp_task_wdt_reset() regelmäßig auf, wenn du deinen Task beim TWDT angemeldet hast. Der in der Meldung genannte Task, etwa IDLE (CPU 0), zeigt, auf welchem Core das Problem liegt.
Ich habe einen Watchdog eingebaut, der Arduino resettet ständig. Warum?
Die häufigste Ursache ist eine Watchdog-Zeit, die kürzer ist als der längste loop()-Durchlauf, zum Beispiel WDTO_2S bei einem delay(3000) in der Schleife. Wähle die Zeit mindestens doppelt so lang wie den Durchlauf im schlechtesten Fall und nutze statt langer delay()-Aufrufe millis(). Blinkt die LED schnell und lässt sich kein Code hochladen, liegt es am alten Bootloader; dann musst du Optiboot per ISP aufspielen.
Bleiben Variablen nach einem Watchdog-Reset erhalten?
Nein, ein Watchdog-Reset startet das Board neu und setup() läuft von vorn; globale Variablen kehren zu ihren Anfangswerten zurück. Informationen, die nach dem Reset erhalten bleiben müssen, wie Zähler, Einstellungen oder der letzte Zustand, speicherst du beim Uno im EEPROM, beim ESP32 im Preferences-Speicher (NVS) und beim Pico in einer Datei im Flash.
Projekte, die du danach bauen kannst
Alle Projekte ansehen
LED Blinken mit ESP32
Lehrt die grundlegende Verwendung von GPIO-Ausgängen mit ESP32. Wir erreichen einen Blinkeffekt, indem wir eine LED über einen digitalen Pin ein- und ausschalten. ESP32-Version des klassischen Blink-Projekts auf Arduino UNO; die grundlegenden Blink-Befehle in der Arduino-Umgebung bleiben gleich, aber die Pinbelegung und die GPIO-Pegel von 3,3 V des ESP32 unterscheiden sich von denen des Arduino UNO.

Raspberry Pi Pico Onboard-LED Blinken (Pico und Pico W)
Das Auftaktprojekt der Raspberry-Pi-Pico-Reihe! Wir lassen die grüne eingebaute LED des Pico blinken und prüfen so, ob das Board funktioniert: das klassische "Hello World" als erstes Experiment. Keine externen Bauteile nötig, nur der Pico und ein USB-Kabel. Der Code ist in MicroPython geschrieben, der Sprache, die die Raspberry Pi Foundation offiziell unterstützt.

ESP32-WLAN-STA-Verbindung (mit LCD-Display)
In diesem Projekt verbinden wir den ESP32 im Station-Modus (STA) sicher und fehlertolerant mit dem heimischen WLAN. Wir lagern SSID und Passwort in eine separate secrets.h-Datei aus, um Leaks zu Git zu verhindern, richten einen Auto-Reconnect-Mechanismus ein und zeigen RSSI-Signalpegel und IP-Adresse auf einem I2C-LCD-Display an. Die interne LED dient als Statusanzeige. Ein Verbindungsmanager auf Produktionsniveau.

ESP32 Async-Webserver (mit IP-Anzeige auf dem LCD)
Wir machen den ESP32 zu einem asynchronen Webserver, den du per Handy oder Computer im selben WLAN steuerst. Dank der Bibliothek ESPAsyncWebServer verarbeitet der Server mehrere Anfragen gleichzeitig (er blockiert nicht wie das klassische WebServer.h bei einer einzigen Anfrage). Öffne im Browser die IP-Adresse des ESP32 und schalte mit den Tasten ON/OFF (Adressen /on und /off) die LED an GPIO 5 ein und aus.

ESP32-OTA-Update – Drahtlose Firmware-Installation (mit LCD-Display)
Du lernst, neue Firmware ohne USB-Kabel per WLAN auf den ESP32 zu laden. Mit der Bibliothek ArduinoOTA wird der ESP32 im Netzwerk sichtbar und erscheint in der Arduino IDE unter "Network port" automatisch als bluegrays-ota. Das erste Hochladen läuft über USB, danach kommen alle Updates kabellos, eine wichtige Funktion für Geräte im Außeneinsatz.

ESP32 HTTPClient + Wetter-API (mit LCD-Display)
Der ESP32 ruft über das Internet mit HTTPClient.h eine Wetter-API (wttr.in) per REST auf. Die JSON-Antwort wird mit ArduinoJson v7 ausgewertet; Stadt, Temperatur, Luftfeuchtigkeit, Wetterlage und Wind erscheinen auf einem I2C-LCD. wttr.in braucht keinen API-Schlüssel, du gibst einfach den Namen einer beliebigen Stadt ein.

ESP32 Bewegungsalarmsystem (PIR + Buzzer + LED + Telegram)
Eine smarte Alarmanlage: Erkennt der PIR-Sensor eine Bewegung, ertönt der Summer, die LED leuchtet und der Besitzer bekommt sofort eine Telegram-Nachricht. Eine Sperrzeit von 30 Sekunden begrenzt, wie oft der Alarm wiederholt wird; Fehlauslösungen des PIR-Sensors verhindert sie nicht. Geeignet für Haus, Garage, Lager oder Arbeitszimmer.
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

