Arduino watchdogtimer: een vastgelopen board automatisch resetten
Wat is een Arduino-watchdogtimer? Gebruik avr/wdt.h op de Uno, Task WDT op de ESP32 en machine.WDT op de Pico om een vastgelopen board automatisch te resetten, met de juiste plaatsing.
Een Arduino-watchdog is een hardwarematige veiligheidstimer die merkt dat je programma is vastgelopen en het board zelf opnieuw start. Het programma stuurt regelmatig een signaal "ik draai nog"; komt dat signaal niet binnen de ingestelde tijd, dan reset de watchdog het board alsof je op de resetknop had gedrukt. Een project dat vastzit in een oneindige lus, wacht op een sensor of vastloopt in een Wi-Fi-bibliotheek herstelt zich dus binnen een paar seconden, zonder dat jij naartoe hoeft te lopen om de stekker eruit te trekken.
Een vastgelopen board met de hand resetten is op je bureau geen probleem, maar bij een bewateringssysteem in de tuin, een weerstation op het dak of een slim apparaat dat weken achtereen draait kan dat niet. In dit bericht leer je hoe een watchdog werkt, hoe je avr/wdt.h gebruikt op de Arduino Uno, de Task WDT op de ESP32 en machine.WDT op de Raspberry Pi Pico, wat de juiste plek is voor het feed-commando en welke klassieke fouten een board in een eindeloze resetlus houden, alles met voorbeeldcode.

Wat is een watchdogtimer en hoe werkt hij?
Een watchdog is een kleine teller in de microcontroller die onafhankelijk van het hoofdprogramma telt. Je start hem met een vaste tijd, bijvoorbeeld 2 seconden, en hij begint te tellen. Het feed-commando dat je bij elke doorloop van het programma aanroept (ook wel "de hond schoppen" genoemd) zet de teller terug. Zolang het programma gezond draait, bereikt de teller nooit het einde. Loopt het programma ergens vast, dan komt de feed niet, loopt de teller af en geeft de watchdog de microcontroller een hardwarereset. Na de reset start het board vanaf setup(), precies alsof het net van stroom is voorzien.
Het geheim van de betrouwbaarheid van een watchdog is dat hij op een aparte klokbron draait, los van de hoofdklok. Op de ATmega328P in de Arduino Uno is die bron een interne oscillator van 128 kHz; ook als de kristal van 16 MHz of de codestroom van het programma uitvalt, blijft de watchdog tellen. Typische oorzaken van een hang zijn: een while-lus waarvan de uitstapvoorwaarde nooit optreedt, een bibliotheek die eindeloos wacht op een niet-reagerende I2C-sensor, RAM dat na verloop van tijd gefragmenteerd raakt door String-aaneenschakelingen, geheugen dat beschadigd raakt door een overlopende array, of elektrische ruis waardoor het programma naar een willekeurig adres springt.
| Kenmerk | Arduino Uno (ATmega328P) | ESP32 | Raspberry Pi Pico (RP2040) |
|---|---|---|---|
| Bibliotheek / module | avr/wdt.h | esp_task_wdt.h | machine.WDT (MicroPython) |
| Starten | wdt_enable(WDTO_2S) | esp_task_wdt_init / reconfigure + esp_task_wdt_add(NULL) | WDT(timeout=5000) |
| Feed | wdt_reset() | esp_task_wdt_reset() | wdt.feed() |
| Langste timeout | 8 s | Instelbaar (Arduino-standaard 5 s) | 8388 ms (ongeveer 8,3 s) |
| Stoppen | wdt_disable() | Verwijder de taak met esp_task_wdt_delete() | Kan niet worden gestopt (alleen een reset zet hem uit) |
| Klokbron | Interne oscillator van 128 kHz | Hardwaretimergroep (MWDT) | Interne tickgenerator van 1 µs |
Wat lost een watchdog op, en wat niet?
- Oneindige lussen: een while-lus die wacht op een waarde die nooit komt, of een toestandsmachine die vastzit door een logische fout, wordt door de watchdog in een paar seconden opgeruimd.
- Vastgelopen bibliotheken: als een netwerkbibliotheek vastloopt op een Wi-Fi-, MQTT- of HTTP-verbinding, of een niet-reagerend sensordriver het board bevriest, brengt de reset het terug in een schone toestand.
- Geheugenbeschadiging: als RAM-fragmentatie of een stack overflow het programma laat misdragen en crashen, brengt de watchdog het board weer omhoog.
- Elektrische ruis: als storing van relais, motoren of lange draden het programma naar een willekeurig punt laat springen, redt de weggevallen feed de situatie.
- Wat hij niet oplost: een te lage voedingsspanning (brownout), een vastgelopen externe sensor of een verkeerd berekende waarde. De watchdog reset alleen de microcontroller; een sensor die de I2C-lijn laag houdt, herstelt vaak pas als zijn eigen voeding wordt onderbroken. Als het programma fout maar wel regelmatig draait, kan de watchdog dat niet merken.
Watchdog op de Arduino Uno: avr/wdt.h
Op AVR-boards (Uno, Nano, Mega, Pro Mini) hoef je voor de watchdog geen extra bibliotheek te installeren; de header avr/wdt.h die bij de compiler zit, is genoeg. Er zijn drie basisfuncties: wdt_enable(timeout) start de watchdog, wdt_reset() zet de teller terug (feed) en wdt_disable() zet hem uit. De timeout geef je op met een van de kant-en-klare constanten hieronder; er zijn tien opties van ongeveer 15 ms tot 8 seconden. Een tijd langer dan 8 seconden kun je niet direct kiezen, maar met de methode van voorwaardelijk voeden die je zo ziet, kun je langere limieten instellen.
| Constante | Ongeveer | Typisch gebruik |
|---|---|---|
| WDTO_15MS | 15 ms | Directe softwarereset |
| WDTO_30MS | 30 ms | Zelden gebruikt |
| WDTO_60MS | 60 ms | Zelden gebruikt |
| WDTO_120MS | 120 ms | Zeer korte regellussen |
| WDTO_250MS | 250 ms | Lussen die snel moeten reageren |
| WDTO_500MS | 500 ms | Knop- en ledbesturing |
| WDTO_1S | 1 s | Eenvoudige regellussen |
| WDTO_2S | 2 s | Sensoren uitlezen en display bijwerken |
| WDTO_4S | 4 s | Trage sensoren, communicatie |
| WDTO_8S | 8 s | Netwerkbewerkingen, lange berekeningen |
Stap voor stap: je eerste watchdogtest
- Sluit de Arduino Uno via USB aan op je computer; behalve de ingebouwde led (pin 13) is er geen extra schakeling nodig.
- Upload de code hieronder en open de Serial Monitor op 9600 baud.
- Je ziet "Basladi" op het scherm en de led die elke halve seconde knippert.
- Stuur de letter k via de Serial Monitor; het programma gaat bewust in een oneindige lus en de led blijft staan waar hij staat.
- Na ongeveer 2 seconden reset het board zichzelf, verschijnt "Basladi" opnieuw en begint de led weer te knipperen.
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}De regel MCUSR = 0 helemaal aan het begin van setup() wist de resetvlaggen; op de ATmega328P kan de watchdog pas worden uitgezet als de watchdog-resetvlag (WDRF) is gewist, dus wdt_disable() komt daarna. We zetten de watchdog aan het einde van setup() aan, nadat de initialisatie klaar is, zodat een lange sensoropstart niet per ongeluk een reset veroorzaakt. De wdt_reset() op de eerste regel van loop() zet de teller bij elke doorloop terug. Ook het laten knipperen van de led met millis() in plaats van delay() is bewust: loop() keert terug zonder te wachten en voedt de watchdog steeds opnieuw binnen milliseconden.
Oude bootloader en de eindeloze resetlus
Als de watchdog een reset veroorzaakt, zet de ATmega328P de watchdog niet uit; integendeel, hij laat hem ingeschakeld met de kortste timeout (ongeveer 16 ms). Als de bootloader, het eerste programma dat het board bij het opstarten draait, hier niets mee doet, loopt de watchdog af terwijl hij nog wacht op code om te uploaden, en reset het board opnieuw. Het resultaat is een eindeloze resetlus waarin de led snel knippert, de code nooit start en er geen nieuwe code kan worden geüpload. De Optiboot-bootloader op de originele Arduino Uno zet de watchdog bij het opstarten uit en heeft dit probleem dus niet. Het probleem zie je vooral bij Nano-klonen met een oude bootloader en enkele oudere Mega 2560-boards.
Waar plaats je het feed-commando?
- Kies één centrale plek: zet wdt_reset() in loop(), op het ene punt waar al het werk doorheen gaat. Strooi je feeds over de hele code, dan blijft een vastgelopen sublus zichzelf voeden en wordt de watchdog nutteloos.
- Voed niet binnen een interrupt: een timerinterrupt blijft draaien, ook als het hoofdprogramma is vastgelopen. Zet je de feed daar, dan kan de watchdog geen enkele hang opvangen. Hoe interrupts werken lees je in het bericht Arduino Interrupt.
- Kies de timeout op basis van de langste bewerking: de watchdog-timeout moet minstens twee keer zo lang zijn als de slechtst denkbare duur van één doorloop van loop(). Gebruik je WDTO_2S in een lus met delay(3000), dan reset het board voortdurend.
- Voeg timeouts toe aan wachtlussen: voed niet binnen een lus als while (!Serial.available()), maar laat de lus na een bepaalde tijd verlaten. Zo loopt het board niet vast en blijft de watchdog alert op echte hangs.
- Schakel de watchdog na setup in: zet hem aan zodra lange bewerkingen zoals de Wi-Fi-verbinding, de initialisatie van de SD-kaart of de sensorkalibratie in setup() klaar zijn.
Een slimmere aanpak is het voeden voorwaardelijk te maken: je voedt de watchdog alleen als het systeem echt gezond is. In het voorbeeld hieronder wordt elke 5 seconden een sensor op A0 uitgelezen; ligt de meting in een zinvol bereik, dan wordt het tijdstip van de laatste geslaagde meting bijgewerkt. Is er 60 seconden lang geen geslaagde meting, dan stopt het voeden en reset het board 4 seconden later. Met deze methode zet je een bewaking op schaal van minuten op die verder gaat dan de limiet van 8 seconden van de AVR, en vang je niet alleen vastlopers maar ook sluipende fouten zoals een gebroken sensordraad.
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 op de ESP32: Task WDT en Interrupt WDT
Op de ESP32 draait standaard al een watchdog; de meeste mensen merken hem voor het eerst als er onverwacht een melding "Task watchdog got triggered" in de Serial Monitor verschijnt. Omdat de ESP32 onder het besturingssysteem FreeRTOS meerdere taken tegelijk draait, gebruikt hij een gelaagde structuur in plaats van één teller. De Task WDT (TWDT) controleert of de taken die erop zijn aangemeld binnen een vaste tijd worden gevoed; de Interrupt WDT (IWDT) vangt interrupts en een lang geblokkeerde taakplanner op. In de Arduino-core is de TWDT meestal ingeschakeld met een timeout van 5 seconden en bewaakt hij de idle-taken; de taak die loop() draait wordt niet bewaakt tenzij je hem toevoegt. Het standaardgedrag kan per coreversie verschillen en in sommige configuraties print de TWDT alleen een waarschuwing en reset hij het board niet, dus de timeout en het resetgedrag expliciet in code instellen is de veiligste keuze.
| Type | Wat hij bewaakt | Typische tijd | Melding die je ziet als hij afgaat |
|---|---|---|---|
| Task WDT (TWDT) | Regelmatig draaien van aangemelde taken en idle-taken | 5 s (instelbaar) | task_wdt: Task watchdog got triggered |
| Interrupt WDT (IWDT) | Geblokkeerde interrupts en taakplanner | Ongeveer 300 ms | Guru Meditation Error ... Interrupt wdt timeout on CPU1 |
| RTC WDT | Het opstartproces dat vastloopt | Korte tijd tijdens het opstarten | 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}De code controleert de coreversie met ESP_ARDUINO_VERSION_MAJOR: in versie 3.x (ESP-IDF 5) worden de instellingen doorgegeven met de structuur esp_task_wdt_config_t en wordt een al draaiende TWDT bijgewerkt met esp_task_wdt_reconfigure(); in versie 2.x neemt esp_task_wdt_init() de timeout in seconden en de panic-vlag direct aan. Als trigger_panic true is, print de ESP32 de foutdump naar de seriële poort en reset hij zichzelf als de tijd om is. esp_task_wdt_add(NULL) start de bewaking van de taak die op dat moment draait, dus die waarin setup() en loop() lopen. De oorzaak van de vorige reset bij het opstarten uitlezen en loggen met esp_reset_reason() is de makkelijkste manier om te begrijpen waarom een apparaat in het veld opnieuw is gestart. Wil je alleen loop() bewaken zonder configuratie, dan kun je de functie enableLoopWDT() van de Arduino-core in setup() aanroepen; de feed gebeurt dan automatisch aan het begin van elke doorloop van loop().
Watchdog op de Raspberry Pi Pico (MicroPython)
De hardwarewatchdog van de RP2040 gebruik je in MicroPython met de klasse machine.WDT. De timeout wordt in milliseconden opgegeven en mag op de RP2040 hoogstens 8388 ms zijn. Er is een belangrijk verschil: op de Pico kan de watchdog, eenmaal gestart, niet vanuit code worden gestopt; alleen een reset zet hem uit. Daarom is het tijdens de ontwikkeling een redder in nood om een klein herstelpad open te laten. In de code hieronder wordt de watchdog nooit gestart als pin GP15 bij het opstarten met GND is verbonden, en valt het programma terug naar de REPL. Met machine.reset_cause() kun je ook achterhalen of het board door de watchdog is gestart of met een gewone opstart. Programmeer je de Pico met de Arduino IDE (arduino-pico-core) in plaats van MicroPython, dan doe je hetzelfde met de functies rp2040.wdt_begin(5000) en 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)Watchdogstrategie voor langlopende IoT-projecten
- Log de opstarts: schrijf bij elke opstart een teller naar EEPROM op de Uno of naar Preferences (NVS) op de ESP32; sla op de ESP32 ook de oorzaak op met esp_reset_reason(). Eén reset per week is acceptabel, één reset per uur is een bug die opgelost moet worden. Omdat Optiboot op de Uno de resetvlaggen wist, is de oorzaak uitlezen uit MCUSR vaak niet mogelijk; de opstartteller laat nog steeds zien hoe vaak het apparaat herstart.
- Zet timeouts op netwerkbewerkingen: wacht niet eindeloos op de Wi-Fi-verbinding; kan hij bijvoorbeeld binnen 15 seconden niet verbinden, verlaat dan de lus en probeer het na een tijdje opnieuw. Instellingen als setTimeout() in HTTPClient en Wire.setWireTimeout() op AVR voorkomen dat een vastgelopen bewerking de watchdogtijd overschrijdt. Voor verbindingsproblemen zie ESP32 maakt geen verbinding met Wi-Fi.
- Houd rekening met OTA-updates: een draadloze upload duurt seconden en loop() kan in die tijd blijven wachten. Door esp_task_wdt_reset() aan te roepen in de onProgress-callback van ArduinoOTA kun je voorkomen dat de update halverwege wordt afgebroken; dit is een zeldzame maar gerechtvaardigde uitzondering op de regel.
- Denk aan slaapstanden: op de Uno kan de watchdog in interruptmodus als wekker dienen en kun je in intervallen van 8 seconden slapen. Op de ESP32 staat de processor tijdens deep sleep uit en begint de code bij het ontwaken opnieuw vanaf het begin. Zie ESP32 deep sleep voor details.
- Beheer de voeding van externe sensoren: de watchdog reset de sensor niet. Voed je een sensor die vaak vastloopt, zoals een I2C-sensor, via een transistor of MOSFET en schakel je de voeding bij het opstarten een paar honderd milliseconden uit en weer in, dan start de sensor schoon samen met de microcontroller. Hoe de I2C-lijn vastloopt lees je in het bericht Wat is I2C.
- Externe watchdog voor kritieke systemen: de interne watchdog vangt alleen fouten van de microcontroller zelf op. Moet je de hele schakeling bewaken, gebruik dan een externe watchdogchip die regelmatige pulsen van een GPIO verwacht, of een tweede kleine microcontroller.
Veelgemaakte fouten en oplossingen
| Symptoom | Waarschijnlijke oorzaak | Oplossing |
|---|---|---|
| Board reset om de paar seconden | Watchdog-timeout is korter dan de langste doorloop van loop() (bijv. WDTO_2S met delay(3000)) | Verleng de timeout, gebruik millis() in plaats van delay() |
| Led knippert snel, code wordt niet geüpload | Oude bootloader zet de watchdog na een watchdogreset niet uit | Brand Optiboot met ISP, programmeer het board met de actuele bootloader-optie |
| Board loopt vast maar reset nooit | Feed staat in een timerinterrupt of een vastgelopen sublus | Verplaats wdt_reset() naar één punt in loop() |
| ESP32 herhaalt "Task watchdog got triggered", geen reset | TWDT staat niet in panic-modus | Zet trigger_panic op true (tweede parameter in 2.x) |
| ESP32-waarschuwing "IDLE (CPU 0)" | Een taak op core 0 loopt in een lus zonder ooit te wachten | Voeg vTaskDelay(1) toe aan de lus |
| esp_task_wdt_reset() geeft de fout "task not found" | De taak is niet aan de TWDT toegevoegd | Roep eerst esp_task_wdt_add(NULL) aan |
| Pico verbreekt de verbinding als je in Thonny stopt | machine.WDT kan na het starten niet worden gestopt | Gebruik een herstelpin, draai de code bij het testen onder een andere naam dan main.py |
| Een relais of motor schakelt tijdens de reset per ongeluk kort in | Pins worden tijdens de reset weer ingangen en de driveringang zweeft | Voeg pull-downweerstanden toe aan de uitgangen, stel aan het begin van setup() een veilige toestand in |
Met slechts een paar regels code verandert een watchdogtimer je project van een experiment op de werkbank in een apparaat dat dagenlang zelfstandig kan draaien. Haal eerst de echte oorzaken van het vastlopen weg, voeg dan de watchdog toe als laatste veiligheidslaag en plaats de feed op één zinvol punt. In de BlueGrays-app kun je stap voor stap langlopende projecten doorlopen, zoals ESP32 Wi-Fi-verbinding, webserver, OTA-update, weer en slimme bewatering, met schakelschema's en code, en er zelf de watchdog aan toevoegen.
Veelgestelde vragen
Waarvoor gebruik je een Arduino-watchdogtimer?
Een watchdog is een ingebouwde timer die het board automatisch reset als het programma binnen de ingestelde tijd geen signaal "ik draai nog" stuurt. Hij brengt projecten die in een oneindige lus belanden, blijven wachten op een sensor of vastlopen in een netwerkbibliotheek binnen seconden weer tot leven. Hij is vooral onmisbaar voor bewatering, alarmen en IoT-apparaten die lange tijd zonder toezicht draaien.
Hoe reset ik een Arduino vanuit code?
Op AVR-boards is de schoonste manier de watchdog met de kortste timeout in te schakelen en te wachten: als je wdt_enable(WDTO_15MS); while (true) {} schrijft, krijgt het board bijna meteen een echte hardwarereset. Op de ESP32 doet ESP.restart() hetzelfde, en op de Raspberry Pi Pico met MicroPython doet machine.reset() dat. Op Nano-klonen met een oude bootloader kan deze methode leiden tot een eindeloze resetlus.
Wat is de langste watchdog-timeout?
Op de Arduino Uno en andere AVR-boards is de langste tijd 8 seconden (WDTO_8S). Op de Raspberry Pi Pico is de limiet 8388 ms, terwijl de tijd bij de Task WDT van de ESP32 vrij instelbaar is. Heb je een langere bewaking nodig, dan kun je met de methode van voorwaardelijk voeden limieten op schaal van minuten instellen; die voedt de watchdog alleen zolang het systeem gezond is.
Hoe los ik de ESP32-fout "Task watchdog got triggered" op?
Deze melding laat zien dat een bewaakte taak niet binnen de ingestelde tijd is gevoed; de oorzaak is meestal een while-lus die terugkeert zonder te wachten, of een FreeRTOS-taak die de idle-taak uithongert. Voeg vTaskDelay(1) of delay(1) toe aan je lussen, knip lange bewerkingen in stukken en roep esp_task_wdt_reset() regelmatig aan als je een eigen taak aan de TWDT hebt toegevoegd. De taak die in de melding wordt genoemd, bijvoorbeeld IDLE (CPU 0), laat zien op welke core het probleem zit.
Ik heb een watchdog toegevoegd en mijn Arduino blijft resetten. Waarom?
De meest voorkomende oorzaak is een watchdog-timeout die korter is dan de langste doorloop van loop(); bijvoorbeeld WDTO_2S kiezen terwijl de lus delay(3000) bevat. Maak de timeout minstens twee keer zo lang als de slechtste doorlooptijd en gebruik millis() in plaats van lange delay()-aanroepen. Knippert de led snel en kan er geen code worden geüpload, dan ligt het probleem bij een oude bootloader; je moet dan Optiboot met een ISP naar het board branden.
Blijven variabelen behouden na een watchdogreset?
Nee, een watchdogreset start het board opnieuw en setup() draait weer vanaf het begin; globale variabelen krijgen weer hun beginwaarden. Informatie die een reset moet overleven, zoals tellers, instellingen of de laatste toestand, schrijf je naar EEPROM op de Uno, naar Preferences (NVS) op de ESP32 en naar een bestand in flash op de Pico.
Projecten om hierna te bouwen
Alle projecten bekijken
Led laten knipperen met ESP32
Leert je het basisgebruik van een GPIO-uitgang met de ESP32. Door een led via een digitale pin aan en uit te zetten krijgen we een knippereffect. Dit is de ESP32-versie van het klassieke blinkproject op de Arduino UNO; de basiscommando's in de Arduino-omgeving zijn hetzelfde, maar de pinindeling en de 3,3 V-GPIO-niveaus van de ESP32 verschillen van die van de Arduino UNO.

Raspberry Pi Pico ingebouwde led laten knipperen (Pico en Pico W)
Het openingsproject van de Raspberry Pi Pico-serie! We laten de groene ingebouwde led van de Pico knipperen om te controleren of het board werkt: het klassieke "Hello World" als eerste experiment. Je hebt geen externe onderdelen nodig, alleen de Pico en een USB-kabel. De code is geschreven in MicroPython, de taal die officieel door de Raspberry Pi Foundation wordt ondersteund.

ESP32 Wi-Fi-verbinding in STA-modus (met lcd-scherm)
In dit project verbinden we de ESP32 in Station-modus (STA) veilig en foutbestendig met het wifinetwerk thuis. We zetten de SSID en het wachtwoord in een apart bestand secrets.h zodat ze niet in Git lekken, bouwen een automatisch herverbindingsmechanisme en tonen het RSSI-signaalniveau en het IP-adres op een I2C-lcd-scherm. De ingebouwde led werkt als statusindicator. Het is een verbindingsmanager van productieniveau.

ESP32 asynchrone webserver (met IP-weergave op lcd)
In dit project maken we van de ESP32 een asynchrone webserver die je met je telefoon of computer op hetzelfde wifinetwerk kunt bedienen. Dankzij de ESPAsyncWebServer-bibliotheek kan de server meerdere verzoeken tegelijk verwerken (anders dan de klassieke WebServer.h, die bij één verzoek blokkeert). Je opent het IP-adres van de ESP32 in een browser en klikt op de knoppen ON/OFF (de routes /on en /off) om de led op GPIO 5 aan en uit te zetten.

ESP32 OTA-update: firmware draadloos installeren (met lcd-scherm)
In dit project leer je nieuwe firmware naar de ESP32 te uploaden via wifi, zonder USB-kabel. Met de ArduinoOTA-bibliotheek wordt de ESP32 zichtbaar op het netwerk en verschijnt hij automatisch als bluegrays-ota onder "Network port" in de Arduino IDE. De eerste upload gaat via USB; daarna zijn alle updates draadloos, een belangrijke functie voor apparaten die op afstand hangen.

ESP32 HTTPClient + weer-API (met lcd-scherm)
In dit project doet de ESP32 via internet een REST API-aanroep naar een weer-API (wttr.in) met HTTPClient.h. Het JSON-antwoord wordt verwerkt met ArduinoJson v7 en stad, temperatuur, luchtvochtigheid, weer en wind verschijnen op een I2C-LCD. wttr.in vraagt geen API-sleutel; typ gewoon de naam van een willekeurige stad.

ESP32-bewegingsalarm (PIR + buzzer + LED + Telegram)
Een slim beveiligingsalarm: als de PIR-sensor beweging detecteert, gaat de buzzer af, licht de LED op en krijgt de eigenaar direct een Telegram-melding. Een afkoeltijd van 30 seconden beperkt hoe vaak het alarm zich herhaalt; valse detecties van de PIR-sensor filtert dit niet weg. Gebruik het thuis, in een garage, een berging of een studeerkamer.
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

