Basi · 13 min di lettura

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.

Scheda Arduino Uno e microcontrollore ATmega328P
L'ATmega328P dell'Arduino Uno ha un watchdog interno con un oscillatore proprio a 128 kHz; non serve nessun componente aggiuntivo.

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.

CaratteristicaArduino Uno (ATmega328P)ESP32Raspberry Pi Pico (RP2040)
Libreria / moduloavr/wdt.hesp_task_wdt.hmachine.WDT (MicroPython)
Avviowdt_enable(WDTO_2S)esp_task_wdt_init / reconfigure + esp_task_wdt_add(NULL)WDT(timeout=5000)
Feedwdt_reset()esp_task_wdt_reset()wdt.feed()
Tempo massimo8 sConfigurabile (predefinito Arduino 5 s)8388 ms (circa 8,3 s)
Arrestowdt_disable()Si toglie il task con esp_task_wdt_delete()Non si può fermare (si disattiva solo con un reset)
Sorgente di clockOscillatore interno a 128 kHzTimer 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.
Il watchdog non è una soluzione al bug, è una cintura di sicurezza. Se vedi la scheda resettarsi più volte al giorno, trova il problema vero: nella maggior parte dei casi è un alimentatore insufficiente, una perdita di memoria o un'attesa senza timeout. Per le cause hardware dei reset casuali dai un'occhiata all'articolo Arduino si resetta continuamente.

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.

CostanteTempo approssimativoUso tipico
WDTO_15MS15 msReset immediato via software
WDTO_30MS30 msUsato raramente
WDTO_60MS60 msUsato raramente
WDTO_120MS120 msCicli di controllo molto brevi
WDTO_250MS250 msCicli che richiedono reazioni rapide
WDTO_500MS500 msControllo di pulsanti e LED
WDTO_1S1 sSemplici cicli di controllo
WDTO_2S2 sLettura sensori e aggiornamento display
WDTO_4S4 sSensori lenti, comunicazione
WDTO_8S8 sOperazioni di rete, calcoli lunghi

Passo dopo passo: la prima prova con il watchdog

  1. Collega l'Arduino Uno al computer con il cavo USB; oltre al LED integrato (pin 13) non serve nessun circuito aggiuntivo.
  2. Carica il codice qui sotto e apri il Monitor Seriale a 9600 baud.
  3. Vedrai comparire la scritta "Basladi" e il LED lampeggiare ogni mezzo secondo.
  4. Invia la lettera k dal Monitor Seriale: il programma entra volutamente in un loop infinito e il LED resta fermo dov'è.
  5. Dopo circa 2 secondi la scheda si resetta da sola, la scritta "Basladi" ricompare e il LED riprende a lampeggiare.
C++ (Arduino IDE)
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.

Attivare il watchdog di proposito è il modo più pulito per resettare la scheda via codice: scrivendo wdt_enable(WDTO_15MS); while (true) {} la scheda riceve in pochissimo tempo un vero reset hardware. Il metodo molto diffuso del "salto all'indirizzo 0" invece riavvia solo il programma e non azzera le periferiche hardware. Ricorda anche che i tempi in tabella sono valori tipici; l'oscillatore a 128 kHz varia con la temperatura e la tensione di alimentazione, quindi usa il watchdog solo per la sicurezza, non per temporizzazioni precise.

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.

Se programmi la scheda nell'IDE di Arduino con l'opzione ATmega328P (Old Bootloader), fai attenzione prima di provare il watchdog. Se la scheda finisce nel loop, devi usare un secondo Arduino come programmatore ISP e scrivere sulla scheda il bootloader Optiboot aggiornato con il comando Burn Bootloader (Scrivi bootloader) del menu Strumenti. Anche sulle schede con Optiboot è una buona abitudine mantenere le righe MCUSR = 0 e wdt_disable() all'inizio di setup().

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.

C++ (Arduino IDE)
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.

TipoCosa controlla?Tempo tipicoMessaggio che compare
Task WDT (TWDT)Esecuzione regolare dei task iscritti e dei task idle5 s (configurabile)task_wdt: Task watchdog got triggered
Interrupt WDT (IWDT)Blocco delle interrupt e dello schedulerCirca 300 msGuru Meditation Error ... Interrupt wdt timeout on CPU1
RTC WDTBlocco della fase di avvioBreve durante l'avviorst:0x10 (RTCWDT_RTC_RESET)
C++ (Arduino IDE)
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().

L'errore di watchdog più comune sull'ESP32 è scrivere un ciclo che non aspetta mai dentro un task FreeRTOS creato da te. Per esempio, se in un task fissato al core 0 scrivi while (true) { leggiSensore(); }, il task idle sullo stesso core non riesce mai a girare, lo stack Wi-Fi si inceppa e dopo qualche secondo compare il messaggio "Task watchdog got triggered ... IDLE (CPU 0)". Aggiungi in ogni ciclo almeno vTaskDelay(1) o delay(1). I dettagli sui task sono nell'articolo ESP32 FreeRTOS e doppio core, mentre il significato dei messaggi "Guru Meditation" lo trovi in ESP32 Brownout e Guru Meditation.

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

MicroPython
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)
Se in Thonny interrompi un programma con il watchdog usando il pulsante Stop, il watchdog continua a contare e in pochi secondi il Pico si resetta e la connessione cade. Prova prima il codice con un nome di file diverso da main.py; quando tutto va bene, salvalo come main.py. Se la scheda finisce in un loop, basta collegare GP15 a GND e resettare. Se hai appena iniziato con MicroPython, l'articolo Basi di MicroPython è un buon punto di partenza.

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

SintomoCausa probabileSoluzione
La scheda si resetta ogni pochi secondiIl 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 caricaIl vecchio bootloader non disattiva il watchdog dopo un reset del watchdogScrivi Optiboot via ISP, programma la scheda con l'opzione del bootloader aggiornato
La scheda si blocca ma non si resetta maiIl feed è in un'interrupt del timer o dentro un sottociclo bloccatoSposta wdt_reset() in un unico punto di loop()
Su ESP32 "Task watchdog got triggered" si ripete, nessun resetIl TWDT non è in modalità panicImposta trigger_panic a true (secondo parametro nella 2.x)
Su ESP32 avviso "IDLE (CPU 0)"Un task sul core 0 gira senza mai aspettareAggiungi vTaskDelay(1) nel ciclo
esp_task_wdt_reset() dà l'errore "task not found"Il task non è stato aggiunto al TWDTChiama prima esp_task_wdt_add(NULL)
Il Pico perde la connessione quando lo fermi in Thonnymachine.WDT non si può fermare una volta avviatoUsa 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 istanteDurante il reset i pin tornano in ingresso e l'ingresso del driver resta flottanteAggiungi 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.

Vedi tutti i progetti
LED Lampeggiante con ESP32
ES-1Principiante

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.

4.7(37)
108
Lampeggio LED Integrato Raspberry Pi Pico (Pico e Pico W)
PI-1Principiante

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.

5.0(1)
10
Connessione Wi-Fi STA con ESP32 (con display LCD)
ES-25Avanzato

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.

4.4(21)
38
Server web asincrono ESP32 (con indicazione dell'IP sul display LCD)
ES-27Avanzato

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

4.8(16)
26
Aggiornamento OTA dell'ESP32 — Installazione wireless del firmware (con display LCD)
ES-30Avanzato
Premium

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.

4.6(14)
22
ESP32 HTTPClient + API meteo (con schermo LCD)
ES-31Avanzato
Premium

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.

4.7(13)
20
Sistema di Allarme Movimento ESP32 (PIR + Buzzer + LED + Telegram)
ES-41Avanzato
Premium

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.

9