Fundamentos · 13 min de lectura

Watchdog en Arduino: reinicio automático si se cuelga la placa

¿Qué es el watchdog de Arduino? Reinicia una placa colgada con avr/wdt.h en Uno, Task WDT en ESP32 y machine.WDT en Pico, y evita errores comunes.

El watchdog de Arduino (temporizador perro guardián) es un temporizador de seguridad por hardware que detecta que el programa se ha colgado y reinicia la placa por sí solo. El programa envía a intervalos regulares una señal de "sigo funcionando"; si esa señal no llega en el tiempo fijado, el watchdog reinicia la placa como si hubieras pulsado el botón de reset. Así, un proyecto atrapado en un bucle infinito, esperando a un sensor o congelado en la librería Wi-Fi se recupera en unos segundos sin que tengas que ir a desenchufarlo.

Reiniciar a mano una placa colgada es fácil cuando pruebas en tu mesa, pero imposible con un sistema de riego en el jardín, una estación meteorológica en el tejado o un dispositivo de casa inteligente que lleva semanas encendido. En este artículo verás cómo funciona el watchdog, cómo usar avr/wdt.h en Arduino Uno, el Task WDT en ESP32 y machine.WDT en Raspberry Pi Pico, dónde poner el comando de alimentación y los errores clásicos que meten la placa en un bucle de reinicio infinito, todo con código de ejemplo.

Placa Arduino Uno y microcontrolador ATmega328P
El ATmega328P del Arduino Uno incluye un temporizador watchdog interno con su propio oscilador de 128 kHz; no necesitas ningún componente adicional.

¿Qué es el watchdog timer y cómo funciona?

El watchdog es un pequeño contador dentro del microcontrolador que cuenta de forma independiente del programa principal. Lo inicias con un tiempo, por ejemplo 2 segundos, y el contador empieza a correr. El comando de alimentación (en inglés "feed" o "kick the dog") que llamas en cada vuelta del programa pone el contador a cero. Mientras el programa funciona bien, el contador nunca llega al final. Si el programa se atasca en algún punto, la alimentación no llega, el contador agota el tiempo y el watchdog aplica un reset por hardware al microcontrolador. Tras el reset, la placa arranca desde setup() como si acabara de encenderse.

El secreto de su fiabilidad es que usa una fuente de reloj distinta a la principal. En el ATmega328P del Arduino Uno es un oscilador interno de 128 kHz; aunque el cristal de 16 MHz o el flujo del código se corrompan, el watchdog sigue contando. Las causas típicas de un cuelgue son: un bucle while cuya condición de salida nunca se cumple, una librería que espera eternamente a un sensor I2C que no responde, la RAM fragmentada poco a poco por concatenaciones de String, memoria dañada por desbordar un array o ruido eléctrico que hace saltar el programa a una dirección aleatoria.

CaracterísticaArduino Uno (ATmega328P)ESP32Raspberry Pi Pico (RP2040)
Librería / móduloavr/wdt.hesp_task_wdt.hmachine.WDT (MicroPython)
Iniciowdt_enable(WDTO_2S)esp_task_wdt_init / reconfigure + esp_task_wdt_add(NULL)WDT(timeout=5000)
Alimentaciónwdt_reset()esp_task_wdt_reset()wdt.feed()
Tiempo máximo8 sConfigurable (por defecto en Arduino 5 s)8388 ms (unos 8,3 s)
Detenciónwdt_disable()Se quita la tarea con esp_task_wdt_delete()No se puede detener (solo se desactiva con un reset)
Fuente de relojOscilador interno de 128 kHzGrupo de temporizadores por hardware (MWDT)Generador de tick interno de 1 µs

¿Qué resuelve el watchdog y qué no?

  • Bucles infinitos: un bucle while que espera un valor que nunca llega, o una máquina de estados atascada por un error lógico, se supera en pocos segundos con el watchdog.
  • Librerías bloqueadas: si una librería de red que se cuelga en una conexión Wi-Fi, MQTT o HTTP, o un driver de sensor que no responde, congela la placa, el reset la devuelve a un estado limpio.
  • Corrupción de memoria: si la fragmentación de la RAM o un desbordamiento de pila hacen que el programa se comporte de forma extraña y se bloquee, el watchdog levanta la placa de nuevo.
  • Ruido eléctrico: si las interferencias de relés, motores o cables largos hacen saltar el programa a un punto aleatorio, que se corte la alimentación del watchdog te salva.
  • Lo que no resuelve: una tensión de alimentación baja (brownout), un sensor externo bloqueado o un valor mal calculado. El watchdog solo reinicia el microcontrolador; un sensor que mantiene bloqueada la línea I2C muchas veces no se recupera sin cortarle su propia alimentación. Si el programa funciona mal pero con regularidad, el watchdog no lo detecta.
El watchdog no es una solución al error, es un cinturón de seguridad. Si ves que la placa se reinicia varias veces al día, busca el problema de fondo: casi siempre es una fuente de alimentación insuficiente, una fuga de memoria o un bucle de espera sin tiempo límite. Para las causas de hardware de los reinicios aleatorios, echa un vistazo a Arduino se reinicia constantemente.

Watchdog en Arduino Uno: avr/wdt.h

En las placas basadas en AVR (Uno, Nano, Mega, Pro Mini) no necesitas instalar ninguna librería para el watchdog; basta el archivo de cabecera avr/wdt.h que viene con el compilador. Hay tres funciones básicas: wdt_enable(tiempo) inicia el watchdog, wdt_reset() pone a cero el contador (lo alimenta) y wdt_disable() lo apaga. El tiempo se da con una de las constantes de la tabla; hay diez opciones entre unos 15 ms y 8 segundos. No puedes elegir directamente más de 8 segundos, pero con el método de alimentación condicional que verás enseguida puedes fijar límites más largos.

ConstanteTiempo aproximadoUso típico
WDTO_15MS15 msReset inmediato por software
WDTO_30MS30 msSe usa rara vez
WDTO_60MS60 msSe usa rara vez
WDTO_120MS120 msBucles de control muy cortos
WDTO_250MS250 msBucles que necesitan reacción rápida
WDTO_500MS500 msControl de botones y LED
WDTO_1S1 sBucles de control sencillos
WDTO_2S2 sLectura de sensores y actualización de pantalla
WDTO_4S4 sSensores lentos, comunicación
WDTO_8S8 sOperaciones de red, cálculos largos

Paso a paso: tu primera prueba con el watchdog

  1. Conecta el Arduino Uno al ordenador por USB; aparte del LED integrado (pin 13) no hace falta ningún circuito adicional.
  2. Sube el código de abajo y abre el Monitor Serie a 9600 baudios.
  3. Verás el texto "Basladi" en pantalla y el LED parpadeando cada medio segundo.
  4. Envía la letra k desde el Monitor Serie; el programa entra a propósito en un bucle infinito y el LED se queda congelado donde esté.
  5. Unos 2 segundos después la placa se reinicia sola, vuelve a aparecer "Basladi" y el LED empieza a parpadear otra vez.
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 línea MCUSR = 0 al principio de setup() borra las banderas de reset; en el ATmega328P el watchdog no se puede desactivar sin borrar antes la bandera de reset del watchdog (WDRF), por eso wdt_disable() va después. Activamos el watchdog al final de setup(), cuando terminan las tareas de inicialización, para que una inicialización larga de un sensor no provoque un reset por error. La instrucción wdt_reset() de la primera línea de loop() pone el contador a cero en cada vuelta. Hacer parpadear el LED con millis() en lugar de delay() también es una decisión deliberada: loop() no espera nunca y alimenta al watchdog una y otra vez en milisegundos.

Disparar el watchdog a propósito es la forma más limpia de reiniciar la placa por código: si escribes wdt_enable(WDTO_15MS); while (true) {}, la placa recibe un auténtico reset por hardware en muy poco tiempo. El método habitual de "saltar a la dirección 0", en cambio, solo reinicia el programa y no restablece las unidades de hardware. Recuerda también que los tiempos de la tabla son valores típicos; el oscilador de 128 kHz varía con la temperatura y la tensión de alimentación, así que usa el watchdog solo como seguridad, no para temporizaciones precisas.

Bootloader antiguo y bucle de reinicio infinito

Cuando el watchdog provoca un reset, el ATmega328P no lo desactiva; al contrario, lo deja activo con el tiempo más corto (unos 16 ms). Si el bootloader, el primer programa que ejecuta la placa al arrancar, no gestiona esta situación, el tiempo del watchdog se agota mientras todavía espera la carga de código y la placa se reinicia otra vez. El resultado es un bucle de reinicio infinito: el LED parpadea rápido, el código nunca arranca y tampoco se puede subir código nuevo. El bootloader Optiboot del Arduino Uno original desactiva el watchdog al arrancar, así que no tiene este problema. Se ve sobre todo en clones de Nano con bootloader antiguo y en algunas placas Mega 2560 viejas.

Si programas tu placa en el IDE de Arduino con la opción ATmega328P (Old Bootloader), ten cuidado antes de probar el watchdog. Si la placa entra en el bucle, tendrás que usar un segundo Arduino como programador ISP y grabar el bootloader Optiboot actual con el comando Grabar Bootloader del menú Herramientas. También en placas con Optiboot es buena costumbre mantener las líneas MCUSR = 0 y wdt_disable() al principio de setup().

¿Dónde poner el comando de alimentación?

  • Elige un único punto central: pon wdt_reset() dentro de loop(), en un solo lugar por el que pase todo el trabajo. Si siembras alimentaciones por todo el código, un sub-bucle atascado seguirá alimentándose a sí mismo y el watchdog perderá su sentido.
  • No alimentes dentro de una interrupción: una interrupción de temporizador sigue ejecutándose aunque el programa principal esté congelado. Si pones ahí la alimentación, el watchdog no detectará ningún cuelgue. Cómo funcionan las interrupciones lo encontrarás en Arduino Interrupt.
  • Elige el tiempo según la operación más larga: el tiempo del watchdog debe ser al menos el doble de lo que tarda una vuelta de loop() en el peor caso. Si usas WDTO_2S en un bucle con delay(3000), la placa se reiniciará continuamente.
  • Añade un tiempo límite a los bucles de espera: en lugar de poner la alimentación dentro de un bucle como while (!Serial.available()), haz que se salga del bucle tras cierto tiempo. Así la placa no se congela y el watchdog sigue atento a los cuelgues reales.
  • Activa el watchdog después de la inicialización: activa el watchdog cuando acaben en setup() las operaciones largas como la conexión Wi-Fi, el arranque de la tarjeta SD o la calibración de sensores.

Un enfoque más inteligente es condicionar la alimentación: solo alimentas al watchdog si el sistema está realmente sano. En el ejemplo siguiente, un sensor conectado a A0 se lee cada 5 segundos; si el valor está en un rango con sentido, se actualiza la hora de la última medición correcta. Si pasan 60 segundos sin ninguna medición correcta, la alimentación se detiene y 4 segundos después la placa se reinicia. Con este método consigues una supervisión de minutos que supera el límite de 8 segundos de AVR, y además detectas no solo cuelgues sino también fallos silenciosos como un cable de sensor suelto.

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 en ESP32: Task WDT e Interrupt WDT

En el ESP32 el watchdog ya funciona por defecto; mucha gente lo descubre por primera vez al ver en el monitor serie un inesperado "Task watchdog got triggered". Como el ESP32 ejecuta varias tareas a la vez con el sistema FreeRTOS, usa una estructura por capas en lugar de un único contador. El Task WDT (TWDT) vigila si las tareas suscritas se alimentan a tiempo; el Interrupt WDT (IWDT) detecta bloqueos prolongados de las interrupciones y del planificador de tareas. En el núcleo de Arduino el TWDT suele estar activo con 5 segundos y vigila las tareas inactivas (idle); la tarea que ejecuta loop() no se vigila a menos que tú la añadas. El comportamiento por defecto cambia según la versión del núcleo y en algunas configuraciones el TWDT solo imprime un aviso sin reiniciar la placa; por eso lo más seguro es fijar el tiempo y el comportamiento de reset explícitamente en el código.

TipoQué vigilaTiempo típicoMensaje al dispararse
Task WDT (TWDT)Que las tareas suscritas y las tareas idle se ejecuten con regularidad5 s (configurable)task_wdt: Task watchdog got triggered
Interrupt WDT (IWDT)Bloqueo de las interrupciones y del planificador de tareasUnos 300 msGuru Meditation Error ... Interrupt wdt timeout on CPU1
RTC WDTQue el proceso de arranque se atasquePoco tiempo durante el arranquerst: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}

El código comprueba la versión del núcleo con ESP_ARDUINO_VERSION_MAJOR: en la versión 3.x (ESP-IDF 5) los ajustes se pasan con la estructura esp_task_wdt_config_t y el TWDT que ya está en marcha se actualiza con esp_task_wdt_reconfigure(); en la 2.x, en cambio, esp_task_wdt_init() recibe directamente el tiempo en segundos y la bandera de pánico. Cuando trigger_panic es true, al agotarse el tiempo el ESP32 escribe el volcado de error en el monitor serie y se reinicia. esp_task_wdt_add(NULL) pone bajo vigilancia la tarea que se está ejecutando, es decir, la que ejecuta setup() y loop(). Leer y guardar al arrancar el motivo del reset anterior con esp_reset_reason() es la forma más fácil de saber por qué se reinició un dispositivo en campo. Si sin ajustar nada solo quieres vigilar loop(), puedes llamar a la función enableLoopWDT() del núcleo de Arduino en setup(); entonces la alimentación se hace automáticamente al principio de cada vuelta de loop().

El error de watchdog más frecuente en ESP32 es escribir, dentro de una tarea FreeRTOS propia, un bucle que no espera nunca. Por ejemplo, si escribes while (true) { leerSensor(); } en una tarea fijada al núcleo 0, la tarea idle de ese mismo núcleo no llega a ejecutarse, la pila Wi-Fi se resiente y pasados unos segundos aparece el mensaje "Task watchdog got triggered ... IDLE (CPU 0)". Añade al menos vTaskDelay(1) o delay(1) en cada bucle. Los detalles de las tareas están en ESP32 FreeRTOS y doble núcleo y el significado de los mensajes "Guru Meditation" en ESP32 Brownout y Guru Meditation.

Watchdog en Raspberry Pi Pico (MicroPython)

El watchdog por hardware del RP2040 se usa en MicroPython con la clase machine.WDT. El tiempo se da en milisegundos y en el RP2040 puede ser como máximo de 8388 ms. Hay una diferencia importante: en la Pico, una vez iniciado, el watchdog no se puede detener por código, solo se desactiva con un reset. Por eso, durante el desarrollo, dejar una pequeña vía de rescate te salva la vida. En el código siguiente, si el pin GP15 está conectado a GND al arrancar, el watchdog no se inicia nunca y el programa cae al REPL. Con machine.reset_cause() también puedes saber si la placa ha arrancado por el watchdog o con un arranque normal. Si programas la Pico con el IDE de Arduino (núcleo arduino-pico) en lugar de MicroPython, lo mismo se hace con las funciones rp2040.wdt_begin(5000) y 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)
Si en Thonny interrumpes un programa con watchdog con el botón Detener, el watchdog sigue contando y en unos segundos la Pico se reinicia y se pierde la conexión. Prueba primero el código con un nombre de archivo distinto de main.py y guárdalo como main.py cuando todo vaya bien. Si la placa entra en bucle, basta con conectar GP15 a GND y reiniciar. Si estás empezando con MicroPython, el artículo Fundamentos de MicroPython es un buen punto de partida.

Estrategia de watchdog en proyectos IoT de larga duración

  • Registra los arranques: en cada arranque escribe un contador en la EEPROM en el Uno y en la memoria Preferences (NVS) en el ESP32; en el ESP32 guarda también el motivo con esp_reset_reason(). Un reset a la semana es aceptable, uno por hora es un error que hay que corregir. En el Uno, como Optiboot borra las banderas de reset, muchas veces no se puede leer el motivo desde MCUSR; aun así, el contador de arranques te muestra con qué frecuencia se reinicia el dispositivo.
  • Pon tiempos límite a las operaciones de red: no esperes eternamente a la conexión Wi-Fi; por ejemplo, si no se conecta en 15 segundos, sal del bucle y reinténtalo pasado un rato. Ajustes como setTimeout() en HTTPClient o Wire.setWireTimeout() en AVR evitan que una operación atascada supere el tiempo del watchdog. Para los problemas de conexión mira ESP32 no se conecta al Wi-Fi.
  • Ten en cuenta la actualización OTA: la carga inalámbrica tarda segundos y durante ese tiempo loop() puede quedarse en espera. Llamando a esp_task_wdt_reset() en el callback onProgress de ArduinoOTA evitas que la actualización se corte a medias; es una de esas excepciones raras pero justificadas a la regla.
  • Piensa en los modos de bajo consumo: en el Uno, el watchdog en modo interrupción puede usarse como temporizador de despertar para dormir en intervalos de 8 segundos. En el ESP32 el procesador se apaga durante el deep sleep y al despertar el código arranca desde el principio. Para más detalles mira ESP32 Deep Sleep.
  • Gestiona la alimentación de los sensores externos: el watchdog no reinicia el sensor. Si alimentas un sensor I2C que se cuelga a menudo a través de un transistor o un MOSFET y lo cortas unos cientos de milisegundos al arrancar, el sensor y el microcontrolador empiezan limpios juntos. Cómo se bloquea la línea I2C puedes leerlo en Qué es I2C.
  • Watchdog externo en sistemas críticos: el watchdog interno solo detecta los fallos del propio microcontrolador. Si necesitas supervisar todo el circuito, se usa un circuito integrado watchdog externo que espera pulsos regulares de un GPIO o un segundo microcontrolador pequeño.

Errores frecuentes y soluciones

SíntomaCausa probableSolución
La placa se reinicia cada pocos segundosEl tiempo del watchdog es más corto que la vuelta más larga de loop() (p. ej. WDTO_2S con delay(3000))Alarga el tiempo y usa millis() en lugar de delay()
El LED parpadea rápido y no se puede subir códigoEl bootloader antiguo no desactiva el watchdog tras un reset del watchdogGraba Optiboot por ISP y programa la placa con la opción del bootloader actual
La placa se cuelga pero nunca se reiniciaLa alimentación está en una interrupción de temporizador o dentro de un sub-bucle atascadoMueve wdt_reset() a un único punto de loop()
En ESP32 se repite "Task watchdog got triggered" sin resetEl TWDT no está en modo pánicoPon trigger_panic en true (el segundo parámetro en 2.x)
Aviso "IDLE (CPU 0)" en ESP32Una tarea del núcleo 0 da vueltas sin esperar nuncaAñade vTaskDelay(1) al bucle
esp_task_wdt_reset() da el error "task not found"La tarea no se ha añadido al TWDTLlama antes a esp_task_wdt_add(NULL)
La Pico pierde la conexión al detenerla en Thonnymachine.WDT no se puede detener una vez iniciadoUsa un pin de rescate y ejecuta el código en pruebas con un nombre distinto de main.py
En el momento del reset un relé o motor se activa un instante sin quererDurante el reset los pines pasan a entrada y la entrada del driver queda flotanteAñade resistencias pull-down a las salidas y pon todo en estado seguro al principio de setup()

El watchdog timer, con unas pocas líneas de código, convierte tu proyecto de una prueba de mesa en un dispositivo que puede funcionar solo durante días. Primero elimina las verdaderas causas de los cuelgues, luego añade el watchdog como última capa de seguridad y coloca la alimentación en un único punto con sentido. En la app de BlueGrays puedes estudiar paso a paso, con esquemas y código, proyectos de larga duración como la conexión Wi-Fi del ESP32, el servidor web, la actualización OTA, el tiempo y el riego inteligente, y añadirles tú mismo el watchdog.

Preguntas frecuentes

¿Para qué sirve el watchdog timer de Arduino?

El watchdog es un temporizador interno que reinicia automáticamente la placa si el programa no envía la señal de "sigo funcionando" dentro del tiempo fijado. Recupera en pocos segundos los proyectos que entran en un bucle infinito, se quedan esperando a un sensor o se congelan en una librería de red. Es imprescindible sobre todo en dispositivos de riego, alarma e IoT que funcionan mucho tiempo sin supervisión.

¿Cómo reinicio Arduino por código?

En las placas AVR, lo más limpio es activar el watchdog con el tiempo más corto y esperar: al escribir wdt_enable(WDTO_15MS); while (true) {}, la placa recibe un auténtico reset por hardware en muy poco tiempo. En ESP32, ESP.restart() y en Raspberry Pi Pico con MicroPython, machine.reset() hacen lo mismo. En clones de Nano con bootloader antiguo, este método puede provocar un bucle de reinicio infinito.

¿Cuál es el tiempo máximo del watchdog?

En Arduino Uno y el resto de placas AVR el tiempo máximo es de 8 segundos (WDTO_8S). En Raspberry Pi Pico el límite es de 8388 ms y en el Task WDT del ESP32 el tiempo se puede ajustar libremente. Si necesitas una supervisión más larga, puedes fijar límites de minutos con la alimentación condicional, que solo alimenta al watchdog cuando el sistema está sano.

¿Cómo se corrige el error "Task watchdog got triggered" del ESP32?

Este mensaje indica que una tarea vigilada no se alimentó en el tiempo fijado; la causa suele ser un bucle while que no espera nunca o una tarea FreeRTOS que deja sin tiempo a la tarea idle. Añade vTaskDelay(1) o delay(1) a tus bucles, divide las operaciones largas en partes y, si añadiste tu propia tarea al TWDT, llama regularmente a esp_task_wdt_reset(). La tarea que aparece en el mensaje, por ejemplo IDLE (CPU 0), te dice en qué núcleo está el problema.

He añadido el watchdog y Arduino se reinicia sin parar. ¿Por qué?

La causa más común es que el tiempo del watchdog sea más corto que la vuelta más larga de loop(); por ejemplo, elegir WDTO_2S cuando el bucle tiene delay(3000). Pon un tiempo de al menos el doble de la vuelta en el peor caso y usa millis() en lugar de delay() largos. Si el LED parpadea rápido y no se puede subir código, el problema es el bootloader antiguo; tendrás que grabar Optiboot en la placa por ISP.

¿Se conservan las variables tras un reset del watchdog?

No, un reset del watchdog reinicia la placa y setup() se ejecuta desde el principio; las variables globales vuelven a sus valores iniciales. Lo que deba conservarse tras el reset, como contadores, ajustes o el último estado, tienes que escribirlo en la EEPROM en el Uno, en la memoria Preferences (NVS) en el ESP32 y en un archivo en la flash en la Pico.

Ver todos los proyectos
LED Parpadeante con ESP32
ES-1Principiante

LED Parpadeante con ESP32

Enseña el uso básico de la salida GPIO con ESP32. Conseguimos un efecto de parpadeo encendiendo y apagando un LED desde el pin digital. Versión para ESP32 del clásico proyecto blink en Arduino UNO; los comandos básicos de blink en el entorno Arduino son los mismos, pero la distribución de pines y los niveles GPIO de 3,3 V del ESP32 difieren de los del Arduino UNO.

4.7(37)
108
Parpadeo LED Integrado Raspberry Pi Pico (Pico y Pico W)
PI-1Principiante

Parpadeo LED Integrado Raspberry Pi Pico (Pico y Pico W)

¡El proyecto de apertura de la serie Raspberry Pi Pico! Hacemos parpadear el LED verde integrado de la Pico para comprobar que la placa funciona: el clásico primer experimento tipo "Hello World". No hacen falta componentes externos, solo la Pico y un cable USB. El código está escrito en MicroPython, el lenguaje con soporte oficial de la Raspberry Pi Foundation.

5.0(1)
10
Conexión Wi-Fi STA con ESP32 (con pantalla LCD)
ES-25Avanzado

Conexión Wi-Fi STA con ESP32 (con pantalla LCD)

En este proyecto, conectamos el ESP32 a la red Wi-Fi doméstica en modo Station (STA) de forma segura y tolerante a fallos. Separamos el SSID y la contraseña en el archivo secrets.h para evitar que se filtren a Git, configuramos un mecanismo de reconexión automática y mostramos el nivel de señal RSSI y la dirección IP en una pantalla LCD I2C. El LED interno actúa como indicador de estado.

4.4(21)
38
Servidor web asíncrono ESP32 (con indicación de IP en la pantalla LCD)
ES-27Avanzado

Servidor web asíncrono ESP32 (con indicación de IP en la pantalla LCD)

En este proyecto, convertimos el ESP32 en un servidor web asíncrono que puedes controlar desde tu teléfono o tu ordenador, siempre que estén conectados a la misma red Wi-Fi. Gracias a la biblioteca ESPAsyncWebServer, el servidor puede procesar varias solicitudes al mismo tiempo (a diferencia del clásico WebServer.h, que se bloquea con una sola solicitud).

4.8(16)
26
Actualización OTA del ESP32 — Instalación inalámbrica del firmware (con pantalla LCD)
ES-30Avanzado
Premium

Actualización OTA del ESP32 — Instalación inalámbrica del firmware (con pantalla LCD)

Aprenderás a cargar un firmware nuevo en el ESP32 por Wi-Fi, sin cable USB. Con la biblioteca ArduinoOTA, el ESP32 se hace visible en la red y aparece automáticamente como bluegrays-ota en la pestaña "Network port" del Arduino IDE. La primera carga se hace por USB; después, todas las actualizaciones son inalámbricas, algo clave para los dispositivos instalados sobre el terreno.

4.6(14)
22
ESP32 HTTPClient + API del tiempo (con pantalla LCD)
ES-31Avanzado
Premium

ESP32 HTTPClient + API del tiempo (con pantalla LCD)

El ESP32 hace una llamada REST por internet a una API del tiempo (wttr.in) con HTTPClient.h. La respuesta JSON se analiza con ArduinoJson v7, y la ciudad, la temperatura, la humedad, el estado del tiempo y el viento aparecen en una LCD I2C. wttr.in no pide clave de API: basta con escribir el nombre de cualquier ciudad.

4.7(13)
20
Sistema de Alarma de Movimiento ESP32 (PIR + Buzzer + LED + Telegram)
ES-41Avanzado
Premium

Sistema de Alarma de Movimiento ESP32 (PIR + Buzzer + LED + Telegram)

Una alarma de seguridad inteligente: cuando el sensor PIR detecta movimiento, suena el zumbador, se enciende el LED y el dueño recibe al instante una notificación por Telegram. Una espera de 30 segundos (cooldown) limita cada cuánto se repite la alarma; no elimina las falsas detecciones del sensor PIR. Sirve para casa, garaje, almacén o estudio.

9