Watchdog Arduino: Reset Automatico quando la Scheda si Blocca
Watchdog Arduino: cos'è e come funziona. Usa avr/wdt.h su Uno, Task WDT su ESP32 e machine.WDT su Pico per resettare la scheda bloccata e gli errori comuni.
Il watchdog di Arduino (il timer "cane da guardia") è un timer di sicurezza hardware che si accorge quando il programma si è bloccato e riavvia la scheda da solo. Il programma invia a intervalli regolari un segnale "sto ancora funzionando"; se il segnale non arriva entro il tempo impostato, il watchdog resetta la scheda come se avessi premuto il pulsante di reset. Così un progetto che finisce in un loop infinito, resta in attesa di un sensore o si pianta in una libreria Wi-Fi si riprende in pochi secondi, senza che tu debba andare a staccare l'alimentazione.
Sulla scrivania resettare a mano una scheda bloccata è facile; ma per un impianto di irrigazione in giardino, una stazione meteo sul tetto o un dispositivo di domotica acceso per settimane non è possibile. In questa guida impari come funziona il watchdog, come usare avr/wdt.h su Arduino Uno, il Task WDT su ESP32 e machine.WDT su Raspberry Pi Pico, dove mettere il comando di feed e quali sono gli errori classici che mandano la scheda in un loop di reset infinito, il tutto con esempi di codice.

Cos'è il watchdog timer e come funziona?
Il watchdog è un piccolo contatore dentro il microcontrollore che conta in modo indipendente dal programma principale. Lo avvii con un tempo preciso, per esempio 2 secondi, e il contatore parte. Il comando di feed (in inglese "feed" o "kick the dog") che chiami a ogni giro del programma azzera il contatore. Finché il programma funziona bene, il contatore non arriva mai alla fine. Se il programma si pianta da qualche parte, il feed non arriva, il contatore scade e il watchdog applica un reset hardware al microcontrollore. Dopo il reset la scheda riparte dalla funzione setup() come appena accesa.
Il segreto dell'affidabilità del watchdog è che usa una sorgente di clock separata da quella principale. Nell'ATmega328P dell'Arduino Uno è un oscillatore interno a 128 kHz; anche se il quarzo a 16 MHz o il flusso del codice vanno in tilt, il watchdog continua a contare. Le cause tipiche di blocco sono: un ciclo while la cui condizione di uscita non si verifica mai, una libreria che aspetta all'infinito un sensore I2C che non risponde, la RAM frammentata nel tempo dalle concatenazioni di String, la memoria corrotta da un array che va in overflow o un disturbo elettrico che fa saltare il programma a un indirizzo casuale.
| Caratteristica | Arduino Uno (ATmega328P) | ESP32 | Raspberry Pi Pico (RP2040) |
|---|---|---|---|
| Libreria / modulo | avr/wdt.h | esp_task_wdt.h | machine.WDT (MicroPython) |
| Avvio | 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() |
| Tempo massimo | 8 s | Configurabile (predefinito Arduino 5 s) | 8388 ms (circa 8,3 s) |
| Arresto | wdt_disable() | Si toglie il task con esp_task_wdt_delete() | Non si può fermare (si disattiva solo con un reset) |
| Sorgente di clock | Oscillatore interno a 128 kHz | Timer hardware (MWDT) | Generatore di tick interno da 1 µs |
Cosa risolve il watchdog e cosa no?
- Loop infiniti: un ciclo while che non riceve mai il valore atteso o una macchina a stati bloccata da un errore di logica si risolvono con il watchdog in pochi secondi.
- Librerie bloccate: se una libreria di rete che si pianta su una connessione Wi-Fi, MQTT o HTTP, o un driver di sensore che non risponde, congela la scheda, il reset la riporta in uno stato pulito.
- Corruzione della memoria: se la RAM frammentata o lo stack in overflow fanno comportare il programma in modo strano fino al crash, il watchdog rimette in piedi la scheda.
- Disturbi elettrici: se i disturbi di relè, motori o cavi lunghi fanno saltare il programma in un punto casuale, l'interruzione del feed ti salva.
- Cosa non risolve: tensione di alimentazione troppo bassa (brownout), un sensore esterno bloccato o un valore calcolato male. Il watchdog resetta solo il microcontrollore; un sensore che tiene bloccata la linea I2C spesso non si riprende finché non gli togli l'alimentazione. Se il programma funziona in modo sbagliato ma regolare, il watchdog non se ne accorge.
Watchdog su Arduino Uno: avr/wdt.h
Sulle schede basate su AVR (Uno, Nano, Mega, Pro Mini) per usare il watchdog non devi installare nessuna libreria: basta l'header avr/wdt.h incluso nel compilatore. Le funzioni principali sono tre: wdt_enable(tempo) avvia il watchdog, wdt_reset() azzera il contatore (feed), wdt_disable() lo spegne. Il tempo si indica con una delle costanti predefinite qui sotto; ci sono dieci opzioni da circa 15 ms a 8 secondi. Non puoi scegliere direttamente un tempo più lungo di 8 secondi, ma con il feed condizionale che vedrai tra poco puoi impostare limiti più lunghi.
| Costante | Tempo approssimativo | Uso tipico |
|---|---|---|
| WDTO_15MS | 15 ms | Reset immediato via software |
| WDTO_30MS | 30 ms | Usato raramente |
| WDTO_60MS | 60 ms | Usato raramente |
| WDTO_120MS | 120 ms | Cicli di controllo molto brevi |
| WDTO_250MS | 250 ms | Cicli che richiedono reazioni rapide |
| WDTO_500MS | 500 ms | Controllo di pulsanti e LED |
| WDTO_1S | 1 s | Semplici cicli di controllo |
| WDTO_2S | 2 s | Lettura sensori e aggiornamento display |
| WDTO_4S | 4 s | Sensori lenti, comunicazione |
| WDTO_8S | 8 s | Operazioni di rete, calcoli lunghi |
Passo dopo passo: la prima prova con il watchdog
- Collega l'Arduino Uno al computer con il cavo USB; oltre al LED integrato (pin 13) non serve nessun circuito aggiuntivo.
- Carica il codice qui sotto e apri il Monitor Seriale a 9600 baud.
- Vedrai comparire la scritta "Basladi" e il LED lampeggiare ogni mezzo secondo.
- Invia la lettera k dal Monitor Seriale: il programma entra volutamente in un loop infinito e il LED resta fermo dov'è.
- Dopo circa 2 secondi la scheda si resetta da sola, la scritta "Basladi" ricompare e il LED riprende a lampeggiare.
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}La riga MCUSR = 0 all'inizio di setup() cancella i flag di reset; nell'ATmega328P il watchdog non si può disattivare finché il flag di reset del watchdog (WDRF) non è stato cancellato, per questo wdt_disable() viene dopo. Attiviamo il watchdog alla fine di setup(), dopo le operazioni di inizializzazione, così un'inizializzazione lunga di un sensore non provoca un reset per errore. Il wdt_reset() nella prima riga di loop() azzera il contatore a ogni giro. Anche la scelta di far lampeggiare il LED con millis() invece di delay() è voluta: loop() ritorna senza aspettare e nutre il watchdog di continuo, a distanza di millisecondi.
Vecchio bootloader e loop di reset infinito
Quando il watchdog provoca un reset, l'ATmega328P non lo disattiva; anzi, lo lascia attivo con il tempo più breve (circa 16 ms). Se il bootloader, cioè il primo programma che la scheda esegue all'accensione, non gestisce questa situazione, il tempo del watchdog scade mentre sta ancora aspettando il caricamento del codice e la scheda si resetta di nuovo. Il risultato è un loop di reset infinito: il LED lampeggia velocemente, il codice non parte mai e non si riesce nemmeno a caricare un nuovo sketch. Il bootloader Optiboot dell'Arduino Uno originale disattiva il watchdog all'avvio e quindi non ha questo problema. Il problema si vede soprattutto sui cloni di Nano con il vecchio bootloader e su alcune vecchie schede Mega 2560.
Dove mettere il comando di feed?
- Scegli un unico punto centrale: metti wdt_reset() dentro loop(), nel punto in cui passa tutto il lavoro. Se spargi i feed in ogni angolo del codice, un sottociclo bloccato continuerà a nutrire il watchdog da solo e il watchdog perde di significato.
- Non fare il feed dentro un'interrupt: un'interrupt del timer continua a funzionare anche se il programma principale è congelato. Se metti il feed lì, il watchdog non rileverà nessun blocco. Come funzionano le interrupt lo trovi nell'articolo Arduino Interrupt.
- Scegli il tempo in base all'operazione più lunga: il tempo del watchdog deve essere almeno il doppio della durata di un giro di loop() nel caso peggiore. Se in un ciclo c'è un delay(3000) e usi WDTO_2S, la scheda si resetta di continuo.
- Aggiungi timeout ai cicli di attesa: invece di mettere il feed dentro un ciclo come while (!Serial.available()), fai uscire dal ciclo dopo un certo tempo. Così la scheda non si blocca e il watchdog resta pronto per i blocchi veri.
- Attiva il watchdog dopo il setup: abilitalo solo dopo che le operazioni lunghe, come la connessione Wi-Fi, l'avvio della scheda SD o la calibrazione di un sensore, sono terminate in setup().
Un approccio più intelligente è condizionare il feed: nutri il watchdog solo se il sistema è davvero sano. Nell'esempio qui sotto un sensore collegato ad A0 viene letto ogni 5 secondi; se il valore letto è in un intervallo sensato, si aggiorna l'istante dell'ultima misura riuscita. Se per 60 secondi non c'è nessuna misura valida, il feed si interrompe e dopo 4 secondi la scheda si resetta. Con questo metodo costruisci un controllo dell'ordine dei minuti, oltre il limite di 8 secondi dell'AVR, e intercetti non solo i blocchi ma anche guasti silenziosi, come il cavo di un sensore che si è staccato.
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 su ESP32: Task WDT e Interrupt WDT
Sull'ESP32 il watchdog funziona già per impostazione predefinita; molti se ne accorgono solo quando vedono sul monitor seriale un inatteso messaggio "Task watchdog got triggered". Poiché l'ESP32 esegue più task contemporaneamente con il sistema operativo FreeRTOS, usa una struttura a livelli invece di un solo contatore. Il Task WDT (TWDT) controlla se i task iscritti vengono nutriti entro un certo tempo; l'Interrupt WDT (IWDT) invece rileva i blocchi prolungati delle interrupt e dello scheduler. Nel core Arduino il TWDT di solito è attivo con un tempo di 5 secondi e controlla i task idle; il task che esegue loop() non viene controllato finché non lo aggiungi tu. Il comportamento predefinito può cambiare a seconda della versione del core e in alcune configurazioni il TWDT stampa solo un avviso senza resettare la scheda; per questo è più sicuro impostare tempo e comportamento di reset esplicitamente nel codice.
| Tipo | Cosa controlla? | Tempo tipico | Messaggio che compare |
|---|---|---|---|
| Task WDT (TWDT) | Esecuzione regolare dei task iscritti e dei task idle | 5 s (configurabile) | task_wdt: Task watchdog got triggered |
| Interrupt WDT (IWDT) | Blocco delle interrupt e dello scheduler | Circa 300 ms | Guru Meditation Error ... Interrupt wdt timeout on CPU1 |
| RTC WDT | Blocco della fase di avvio | Breve durante l'avvio | 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}Il codice controlla la versione del core con ESP_ARDUINO_VERSION_MAJOR: nella versione 3.x (ESP-IDF 5) le impostazioni si passano con la struttura esp_task_wdt_config_t e il TWDT già attivo si aggiorna con esp_task_wdt_reconfigure(); nella versione 2.x invece esp_task_wdt_init() accetta direttamente il tempo in secondi e il flag di panic. Con trigger_panic a true, allo scadere del tempo l'ESP32 scrive il dump dell'errore sul monitor seriale e si resetta. esp_task_wdt_add(NULL) mette sotto controllo il task in esecuzione, cioè quello che esegue setup() e loop(). Leggere e registrare la causa del reset precedente con esp_reset_reason() all'avvio è il modo più semplice per capire perché un dispositivo sul campo si è riavviato. Se vuoi controllare solo loop() senza altre impostazioni, puoi chiamare in setup() la funzione enableLoopWDT() del core Arduino; in questo caso il feed viene fatto automaticamente all'inizio di ogni giro di loop().
Watchdog su Raspberry Pi Pico (MicroPython)
Il watchdog hardware dell'RP2040 si usa in MicroPython con la classe machine.WDT. Il tempo si dà in millisecondi e sull'RP2040 può arrivare al massimo a 8388 ms. C'è una differenza importante: sul Pico il watchdog, una volta avviato, non si può fermare via codice, si disattiva solo con un reset. Per questo, durante lo sviluppo, lasciarsi una piccola via di recupero può salvarti la vita. Nel codice qui sotto, se il pin GP15 è collegato a GND all'avvio, il watchdog non viene avviato e il programma cade nel REPL. Con machine.reset_cause() puoi anche scoprire se la scheda è ripartita per colpa del watchdog o con un avvio normale. Se programmi il Pico con l'IDE di Arduino (core arduino-pico) invece che con MicroPython, la stessa cosa si fa con le funzioni rp2040.wdt_begin(5000) e 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)Strategia watchdog per progetti IoT di lunga durata
- Registra gli avvii: a ogni avvio scrivi un contatore nella EEPROM sull'Uno e nella memoria Preferences (NVS) sull'ESP32; sull'ESP32 salva anche la causa con esp_reset_reason(). Un reset a settimana è accettabile, uno all'ora è un bug da correggere. Sull'Uno, poiché Optiboot cancella i flag di reset, spesso non si riesce a leggere la causa da MCUSR; il contatore di avvii mostra comunque quanto spesso il dispositivo si riavvia.
- Metti timeout alle operazioni di rete: non aspettare all'infinito la connessione Wi-Fi; per esempio, se non si connette entro 15 secondi, esci dal ciclo e riprova dopo un po'. Impostazioni come setTimeout() in HTTPClient o Wire.setWireTimeout() su AVR evitano che un'operazione bloccata superi il tempo del watchdog. Per i problemi di connessione guarda l'articolo ESP32 non si connette al Wi-Fi.
- Considera gli aggiornamenti OTA: il caricamento wireless dura alcuni secondi e in questo tempo loop() può restare in attesa. Chiamando esp_task_wdt_reset() nella callback onProgress di ArduinoOTA puoi evitare che l'aggiornamento venga interrotto a metà; è una rara ma legittima eccezione alla regola.
- Pensa alle modalità di sleep: sull'Uno il watchdog in modalità interrupt può servire da timer di risveglio e permette di dormire a intervalli di 8 secondi. Sull'ESP32 durante il deep sleep il processore è spento e al risveglio il codice riparte da capo. Per i dettagli guarda l'articolo ESP32 Deep Sleep.
- Gestisci l'alimentazione dei sensori esterni: il watchdog non resetta il sensore. Se alimenti un sensore I2C che si pianta spesso tramite un transistor o un MOSFET e all'avvio lo spegni e lo riaccendi per qualche centinaio di millisecondi, il sensore riparte pulito insieme al microcontrollore. Come si blocca la linea I2C lo puoi leggere nell'articolo Cos'è l'I2C.
- Watchdog esterno per i sistemi critici: il watchdog interno rileva solo gli errori del microcontrollore stesso. Se devi controllare l'intero circuito si usa un chip watchdog esterno che aspetta impulsi regolari da un GPIO oppure un secondo piccolo microcontrollore.
Errori comuni e soluzioni
| Sintomo | Causa probabile | Soluzione |
|---|---|---|
| La scheda si resetta ogni pochi secondi | Il tempo del watchdog è più breve del giro più lungo di loop() (es. WDTO_2S con delay(3000)) | Allunga il tempo, usa millis() al posto di delay() |
| Il LED lampeggia veloce, il codice non si carica | Il vecchio bootloader non disattiva il watchdog dopo un reset del watchdog | Scrivi Optiboot via ISP, programma la scheda con l'opzione del bootloader aggiornato |
| La scheda si blocca ma non si resetta mai | Il feed è in un'interrupt del timer o dentro un sottociclo bloccato | Sposta wdt_reset() in un unico punto di loop() |
| Su ESP32 "Task watchdog got triggered" si ripete, nessun reset | Il TWDT non è in modalità panic | Imposta trigger_panic a true (secondo parametro nella 2.x) |
| Su ESP32 avviso "IDLE (CPU 0)" | Un task sul core 0 gira senza mai aspettare | Aggiungi vTaskDelay(1) nel ciclo |
| esp_task_wdt_reset() dà l'errore "task not found" | Il task non è stato aggiunto al TWDT | Chiama prima esp_task_wdt_add(NULL) |
| Il Pico perde la connessione quando lo fermi in Thonny | machine.WDT non si può fermare una volta avviato | Usa un pin di recupero, nei test esegui il codice con un nome diverso da main.py |
| Al momento del reset un relè o un motore si attiva per un istante | Durante il reset i pin tornano in ingresso e l'ingresso del driver resta flottante | Aggiungi resistenze di pull-down sulle uscite e porta i pin in stato sicuro all'inizio di setup() |
Il watchdog timer, con poche righe di codice, trasforma il tuo progetto da una prova sulla scrivania in un dispositivo che può funzionare da solo per giorni. Prima elimina le vere cause dei blocchi, poi aggiungi il watchdog come ultimo strato di sicurezza e metti il feed in un unico punto sensato. Nell'app BlueGrays trovi passo dopo passo, con schemi dei circuiti e codice, progetti che restano accesi a lungo come connessione Wi-Fi con ESP32, web server, aggiornamento OTA, meteo e irrigazione intelligente, e puoi aggiungere tu stesso il watchdog.
Domande frequenti
A cosa serve il watchdog timer di Arduino?
Il watchdog è un timer interno che resetta automaticamente la scheda se il programma non invia il segnale "sto ancora funzionando" entro il tempo stabilito. Riporta in pochi secondi alla normalità i progetti che finiscono in un loop infinito, si fermano in attesa di un sensore o si congelano in una libreria di rete. È indispensabile soprattutto per irrigazione, allarmi e dispositivi IoT che lavorano a lungo senza supervisione.
Come resetto Arduino via codice?
Sulle schede AVR il modo più pulito è avviare il watchdog con il tempo più breve e aspettare: scrivendo wdt_enable(WDTO_15MS); while (true) {} la scheda riceve in pochissimo tempo un vero reset hardware. Su ESP32 ESP.restart() e su Raspberry Pi Pico con MicroPython machine.reset() fanno lo stesso lavoro. Sui cloni di Nano con il vecchio bootloader questo metodo può causare un loop di reset infinito.
Qual è il tempo massimo del watchdog?
Su Arduino Uno e sulle altre schede AVR il tempo massimo è 8 secondi (WDTO_8S). Su Raspberry Pi Pico il limite è 8388 ms, mentre nel Task WDT dell'ESP32 il tempo si può impostare liberamente. Se ti serve un controllo più lungo, puoi impostare limiti dell'ordine dei minuti con il feed condizionale, che nutre il watchdog solo quando il sistema è sano.
Come si corregge l'errore ESP32 "Task watchdog got triggered"?
Questo messaggio indica che un task controllato non è stato nutrito nel tempo stabilito; la causa di solito è un ciclo while che non aspetta mai o un task FreeRTOS che lascia a digiuno il task idle. Aggiungi vTaskDelay(1) o delay(1) ai cicli, spezza le operazioni lunghe in parti e, se hai aggiunto il tuo task al TWDT, chiama regolarmente esp_task_wdt_reset(). Il nome del task nel messaggio, per esempio IDLE (CPU 0), ti dice su quale core sta il problema.
Ho aggiunto il watchdog e Arduino si resetta di continuo. Perché?
La causa più frequente è un tempo del watchdog più breve del giro più lungo di loop(); per esempio scegliere WDTO_2S con un delay(3000) nel ciclo. Imposta un tempo pari ad almeno il doppio della durata del giro nel caso peggiore e usa millis() al posto dei delay() lunghi. Se il LED lampeggia velocemente e non riesci a caricare il codice, il problema è il vecchio bootloader: devi scrivere Optiboot sulla scheda via ISP.
Dopo un reset del watchdog le variabili vengono mantenute?
No, il reset del watchdog riavvia la scheda e setup() riparte da capo; le variabili globali tornano ai valori iniziali. Le informazioni da conservare dopo il reset, come contatori, impostazioni o l'ultimo stato, vanno scritte nella EEPROM sull'Uno, nella memoria Preferences (NVS) sull'ESP32 e in un file nella flash sul Pico.
Progetti da realizzare dopo questo articolo
Vedi tutti i progetti
LED Lampeggiante con ESP32
Insegna l'uso di base delle uscite GPIO con l'ESP32. Otteniamo un effetto lampeggiante accendendo e spegnendo un LED dal pin digitale. Versione ESP32 del classico progetto blink su Arduino UNO; i comandi di base di blink nell'ambiente Arduino sono gli stessi, ma la disposizione dei pin e i livelli GPIO a 3,3 V dell'ESP32 sono diversi da quelli di Arduino UNO.

Lampeggio LED Integrato Raspberry Pi Pico (Pico e Pico W)
Il progetto d'apertura della serie Raspberry Pi Pico! Facciamo lampeggiare il LED verde integrato del Pico per verificare che la scheda funzioni: il classico primo esperimento in stile "Hello World". Niente componenti esterni, bastano il Pico e un cavo USB. Il codice è scritto in MicroPython, il linguaggio supportato ufficialmente dalla Raspberry Pi Foundation.

Connessione Wi-Fi STA con ESP32 (con display LCD)
In questo progetto colleghiamo l'ESP32 alla rete Wi-Fi domestica in modalità Station (STA) in modo sicuro e tollerante agli errori. Separiamo SSID e password in un file secrets.h per impedire fughe su Git, impostiamo un meccanismo di riconnessione automatica e visualizziamo il livello del segnale RSSI e l'indirizzo IP su un display LCD I2C. Il LED interno funge da indicatore di stato.

Server web asincrono ESP32 (con indicazione dell'IP sul display LCD)
In questo progetto trasformiamo l'ESP32 in un server web asincrono che potrete controllare dal vostro telefono o computer collegato alla stessa rete Wi-Fi. Grazie alla libreria ESPAsyncWebServer, il server è in grado di elaborare più richieste contemporaneamente (a differenza del classico WebServer.h, che si blocca su una singola richiesta).

Aggiornamento OTA dell'ESP32 — Installazione wireless del firmware (con display LCD)
Imparerai a caricare un nuovo firmware sull'ESP32 via Wi-Fi, senza cavo USB. Con la libreria ArduinoOTA l'ESP32 diventa visibile in rete e compare automaticamente come bluegrays-ota nella scheda "Network port" dell'Arduino IDE. Il primo caricamento avviene via USB, poi tutti gli aggiornamenti sono wireless: una funzione fondamentale per i dispositivi installati sul campo.

ESP32 HTTPClient + API meteo (con schermo LCD)
L'ESP32 effettua via internet una chiamata REST a un'API meteo (wttr.in) con HTTPClient.h. La risposta JSON viene analizzata con ArduinoJson v7 e città, temperatura, umidità, condizioni meteo e vento compaiono su un display LCD I2C. wttr.in non richiede una chiave API: basta scrivere il nome di una città qualsiasi.

Sistema di Allarme Movimento ESP32 (PIR + Buzzer + LED + Telegram)
Un allarme di sicurezza smart: quando il sensore PIR rileva un movimento, suona il buzzer, si accende il LED e il proprietario riceve subito una notifica su Telegram. Un'attesa di 30 secondi (cooldown) limita la frequenza degli allarmi ripetuti; non elimina i falsi rilevamenti del sensore PIR. Adatto a casa, garage, magazzino o studio.
Altri articoli
App BlueGrays
Costruisci questo circuito passo passo sul telefono
Schema, codice ed elenco componenti in un’unica schermata. Oltre 500 progetti Arduino, ESP32 e Pico da realizzare.
Inquadra con il telefono
Punta la fotocamera sul codice: si apre lo store del tuo telefono.
oppure apri lo store

