Aprender

El watchdog timer de Arduino, en un Uno con un botón que lo cuelga

Principiante

O mira todas las lecciones.

  • 526componentes en el banco de trabajo
  • 46placas funcionando ahora
  • 1.00xtiempo real, en todas las placas
Arduino Uno: un botón en el pin 2, listo para colgar un sketchen vivo0.000 s 0.00x
Mantén presionado el botón
Pega el sketch del watchdog, luego presiona el botón para colgarlo y mira cómo se reinicia.

El watchdog es un temporizador propio dentro del chip que reinicia la placa salvo que el sketch diga "sigo vivo" a tiempo. Actívalo con wdt_enable(WDTO_2S) desde <avr/wdt.h> y llama a wdt_reset() en loop(). Mientras loop() siga volviendo, no pasa nada. Si el sketch se cuelga, en un bucle que nunca termina o esperando un sensor que nunca responde, pasan dos segundos sin reinicio y el watchdog lo reinicia desde el principio.

El circuito de arriba es un botón en el pin 2 y un LED en un Uno. Pega el primer sketch de abajo y presiona Ejecutar. El monitor serie imprime "started". Presiona el botón y el sketch imprime "stuck!" y se cuelga en un while (true), y unos dos segundos después imprime "started" otra vez: el watchdog lo reinició.

Abajo está ese sketch, lo que muestra la causa del reinicio en un Uno, los tiempos de espera, por qué un arranque lento no entra en bucle aquí, y el watchdog como interrupción lenta, cada uno ejecutado en un Uno con lo que imprimió.

Un sketch que se reinicia a sí mismo

Here is the sketch. setup() turns the watchdog on last, after everything slow is done. loop() pats it first thing every time around. The button stands in for a real hang, a sensor read that waits forever, say: it prints "stuck!" and goes into a loop with no way out, and no more pats. It printed "started", "stuck!" and then "started" again.

El reinicio es un reset real: cada variable vuelve a su valor inicial y setup() corre de nuevo. El watchdog no arregla el bug que colgó el sketch. Logra que un dispositivo que corre por su cuenta vuelva a funcionar, y un sketch debería registrar o contar los reinicios para poder encontrar el bug.

Mantén presionado el botón para colgarlo
#include <avr/wdt.h>

void setup() {
  Serial.begin(9600);
  pinMode(2, INPUT_PULLUP);
  Serial.println("started");
  wdt_enable(WDTO_2S);
}

void loop() {
  wdt_reset();
  if (digitalRead(2) == LOW) {
    Serial.println("stuck!");
    while (true) {
    }
  }
  delay(100);
}

Abrir este sketch en el editorSolo el código: el editor coloca la placa y los componentes que puede leer del sketch.

Los tiempos de espera

El watchdog cuenta con su propio oscilador de 128 kHz, no con el cristal de 16 MHz, así que sus tiempos son aproximados y no cambian con el reloj. Las opciones son WDTO_15MS, WDTO_30MS, WDTO_60MS, WDTO_120MS, WDTO_250MS, WDTO_500MS, WDTO_1S, WDTO_2S, WDTO_4S y WDTO_8S; 8 segundos es el máximo. Elige uno cómodamente más largo que la vuelta más lenta normal por loop().

A long delay counts as a hang. With a 2 second watchdog, delay(3000) in loop() reset the board before the wait was over: in 7 seconds it printed "started" four times and "done waiting" never. Break long waits into short ones with a wdt_reset() in between, or better, time them with millis().

¿Fue eso el watchdog?

El chip guarda la razón del último reinicio en MCUSR, y el bit WDRF queda activado tras un reinicio del watchdog. El sketch de abajo lo lee primero en setup(), luego lo borra, y lo imprime. Imprimió "reset cause: 1" al encender, la bandera de encendido, y tras el cuelgue con el botón, "reset cause: 0".

El segundo inicio dice 0, no el 8 del watchdog. Un reinicio por watchdog en un Uno no se muestra: el cargador de arranque Optiboot lee MCUSR y lo limpia, y apaga el watchdog, antes de que tu sketch empiece, así que setup() encuentra WDRF ya limpio. El Uno de Mokxi hace lo mismo. Para saber que el watchdog se disparó, lleva tu propia cuenta, en EEPROM por ejemplo, y suma uno en setup().

Leer la causa del reinicio
#include <avr/wdt.h>

void setup() {
  byte cause = MCUSR;
  MCUSR = 0;
  wdt_disable();
  Serial.begin(9600);
  pinMode(2, INPUT_PULLUP);
  Serial.print("reset cause: ");
  Serial.println(cause, HEX);
  wdt_enable(WDTO_1S);
}

void loop() {
  wdt_reset();
  if (digitalRead(2) == LOW) {
    while (true) {
    }
  }
}

Abrir este sketch en el editorSolo el código: el editor coloca la placa y los componentes que puede leer del sketch.

El ciclo interminable de reinicios

En un chip desnudo, después de un reinicio por watchdog, mientras WDRF está activo, el watchdog sigue encendido en su tiempo más corto, unos 16 milisegundos. Un sketch que arranca despacio nunca tiene la oportunidad de fijar su propio tiempo, y la placa se reinicia cada pocos milisegundos. En un Uno no hay tal ciclo: Optiboot apaga el watchdog antes de que el sketch empiece. Con delay(100) en setup() antes de wdt_enable(WDTO_1S), una pulsación del botón reinició la placa una vez e imprimió "started" dos veces en total.

El cargador de arranque más antiguo de muchas placas Nano no apaga el watchdog, y un reinicio por watchdog puede dejar esa placa atascada reiniciándose hasta que se desconecte o se le grabe un cargador de arranque nuevo. La solución son las primeras tres líneas del sketch de arriba: leer MCUSR, limpiarlo, wdt_disable(), antes que cualquier otra cosa.

El watchdog como interrupción lenta

Configura su bit WDIE en lugar de WDE y el watchdog llama a ISR(WDT_vect) en lugar de reiniciar. El sketch de abajo pide un segundo; el controlador corrió a los 1024, 2048, 3072 y 4096 ms, un segundo según el propio oscilador del watchdog. Cambiar WDTCSR toma dos escrituras seguidas, la primera activando WDCE y WDE, como pide la hoja de datos. Este es el temporizador que despierta a un sketch de batería del sueño, porque sigue corriendo cuando todo lo demás está detenido.

Una interrupción del watchdog cada segundo
#include <avr/wdt.h>

volatile int barks = 0;

ISR(WDT_vect) {
  barks++;
}

void setup() {
  Serial.begin(9600);
  noInterrupts();
  wdt_reset();
  WDTCSR = (1 << WDCE) | (1 << WDE);
  WDTCSR = (1 << WDIE) | (1 << WDP2) | (1 << WDP1);
  interrupts();
}

void loop() {
  static int shown = 0;
  if (barks != shown) {
    shown = barks;
    Serial.print("bark ");
    Serial.print(shown);
    Serial.print(" at ");
    Serial.println(millis());
  }
}

Abrir este sketch en el editorSolo el código: el editor coloca la placa y los componentes que puede leer del sketch.

Abre este circuito en el editor. Arduino Uno: un botón en el pin 2, listo para colgar un sketch, conectado como corre al inicio de esta página. Cambia un componente o un valor y ejecútalo de nuevo.

Abrir el circuito

Preguntas

¿Qué es el temporizador watchdog en un Arduino?

Un temporizador aparte en el chip que reinicia la placa si el sketch no llama a wdt_reset() antes de que se agote. Vuelve a poner en marcha un sketch colgado sin que nadie presione reset.

¿Cómo uso el temporizador watchdog en un Arduino Uno?

Incluye <avr/wdt.h>, llama a wdt_enable(WDTO_2S) al final de setup() y a wdt_reset() una vez en cada vuelta de loop(). Elige un tiempo mayor que la vuelta normal más lenta de loop().

¿Por qué mi Arduino se sigue reiniciando con el watchdog?

Algo en loop() tarda más que el tiempo configurado, a menudo un delay() largo, o, en una placa con un cargador de arranque antiguo, el sketch arranca demasiado lento después de un reinicio por watchdog, cuando el chip mantiene un tiempo de 16 ms hasta que se limpia MCUSR. Limpia MCUSR y llama a wdt_disable() como primera cosa en setup().

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

Unos 8 segundos, WDTO_8S. Para más, usa la interrupción del watchdog y cuenta varias de ellas antes de decidir que el sketch está atascado.

¿Funciona el watchdog en un Nano?

El chip es el mismo, así que el código es el mismo. Las placas Nano más antiguas traen un cargador de arranque que no apaga el watchdog después de que se dispara, lo que puede dejar la placa reiniciándose hasta que se grabe un cargador de arranque nuevo.

Ármalo en la vida real

Abre el editor, cambia un valor y mira cómo cambia el número con él. Nada que instalar y sin necesidad de cuenta.