Travou! E agora?

Um assunto que considero bastante importante é o Watchdog, palavra que, traduzida para o português, significa “cão de guarda”. Existe um problema que atinge muitos circuitos microcontrolados que é o fato deles travarem, isso por inúmeros motivos. O Watchdog, portanto, é um dispositivo independente do microcontrolador que, em caso de “congelamento”, irá reiniciar o sistema. Neste vídeo vamos, então, implementar um Watchdog no ESP32 utilizando interrupção por tempo e criar um exemplo para simular um travamento e acionar o dispositivo.

Introdução

O que fazer se seu programa travar no meio de uma execução e ficar “congelado”?
Como reiniciar o ESP32 sem precisar ir lá apertar o botão físico?

Para isso utilizamos o Watchdog, um “cão de guarda” que fica vigiando para verificar se seu programa travou e, caso isso ocorra, ele trata de reiniciá-lo automaticamente.

Mas, como funciona o Watchdog?

Imagine que você tem um cachorro que precisa comer de tempos em tempos para não começar a latir. Então, você passa a alimentá-lo com certa frequência para mantê-lo em estado normal.

É assim que o Watchdog funciona, ele fica aguardando ser “alimentado” (um sinal de que está tudo OK). Caso passe um tempo e nenhum sinal tenha sido recebido, ele reinicia o MCU.

Implementando um Watchdog

Implementaremos o Watchdog no ESP32 utilizando uma interrupção por tempo. Para isso vamos configurar um temporizador para disparar um sinal e acionar uma função callback (onde teremos o comando para reiniciar o ESP32), no caso de seu contador extrapolar o limite de tempo definido.

Não dá para você usar um circuito profissional microcontrolado sem utilizar o Watchdog porque ele é que impede que o sistema fiquei lá parado em caso de um travamento. Então, esse procedimento é bastante importante em inúmeras situações.

Interrupção por tempo

Utilizaremos os seguintes comandos para configurar e manipular nosso temporizador.

hw_timer_t *timer = NULL; //faz o controle do temporizador (interrupção por tempo)

//timerID 0, div 80 (clock do esp), contador progressivo
timer = timerBegin(0, 80, true); 

//instancia de timer, função callback, interrupção de borda
timerAttachInterrupt(timer, &resetModule, true);

// instancia de timer, tempo (us),3.000.000 us = 3 segundos , repetição
timerAlarmWrite(timer, 3000000, true);

timerAlarmEnable(timer); //habilita a interrupção

timerWrite(timer, 0); //reseta o temporizador (alimenta o watchdog) zera o contador 

WiFi NodeMCU-32S ESP-WROOM-32

Montagem

Programa

Nosso programa funcionará da seguinte forma: vamos configurar uma interrupção por tempo para 3 segundos. Na função Loop, a cada iteração, vamos resetar nosso temporizador. Teremos um botão para simular um travamento do programa. Enquanto ele estiver pressionado, o temporizador não será resetado, fazendo, assim, com que, ao extrapolar o limite de tempo pré-definido, a interrupção seja acionada e a função com o comando para reiniciar o ESP seja executada.

Variáveis

Aqui determinamos um pino do botão para simular um travamento. Um outro pino acenderá o Led vermelho. O mesmo ocorrerá com o Led verde toda vez que o ESP32 reiniciar. O controle é feito por um temporizador.

const int pinButton = 2; //pino do botão para simular um travamento
const int redLed = 23; //pino do led
const int greenLed = 4; //esse led acenderá toda vez que o ESP32 reiniciar

hw_timer_t *timer = NULL; //faz o controle do temporizador (interrupção por tempo)

Setup

Inicializamos os pinos e configuramos os timers. Na sequência, habilitamos a interrupção e colocamos o Led verde para piscar indicando que o programa reiniciou.

void setup() {
    Serial.begin(115200);
    Serial.println("running setup");
    
    pinMode(pinButton, INPUT_PULLUP);
    pinMode(redLed , OUTPUT);
    pinMode(greenLed , OUTPUT);   
    delay(500);  

    //hw_timer_t * timerBegin(uint8_t num, uint16_t divider, bool countUp)
    /*
       num: é a ordem do temporizador. Podemos ter quatro temporizadores, então a ordem pode ser [0,1,2,3].
      divider: É um prescaler (reduz a frequencia por fator). Para fazer um agendador de um segundo, 
      usaremos o divider como 80 (clock principal do ESP32 é 80MHz). Cada instante será T = 1/(80) = 1us
      countUp: True o contador será progressivo
    */
    timer = timerBegin(0, 80, true); //timerID 0, div 80
    //timer, callback, interrupção de borda
    timerAttachInterrupt(timer, &resetModule, true);
    //timer, tempo (us), repetição
    timerAlarmWrite(timer, 3000000, true);
    timerAlarmEnable(timer); //habilita a interrupção 
    digitalWrite(greenLed, HIGH);
    delay(1000);
    digitalWrite(greenLed, LOW);
}

Loop

void loop() {
    timerWrite(timer, 0); //reseta o temporizador (alimenta o watchdog) 
    long tme = millis(); //tempo inicial do loop
    //fica preso no loop enquanto o botão estiver pressionado
    while(digitalRead(pinButton))
    {
        Serial.println("botão pressionado: "+String(millis() - tme));
        digitalWrite(redLed, HIGH); //acende o led vermelho
        delay(500);
//        timerWrite(timer, 0); //se fizer esse reset no temporizador, o watchdog não será acionado
    }
    delay(1000);
    Serial.print("tempo passado dentro do loop (ms) = ");
    tme = millis() - tme; //calcula o tempo (atual - inicial)
    Serial.println(tme);
    //desliga o led vermelho
    digitalWrite(redLed, LOW);
}

resetModule

Temos aqui a função que o temporizador irá chamar para reiniciar o ESP32. Imprimimos o log e executamos o comando para reiniciar o chip.

//função que o temporizador irá chamar, para reiniciar o ESP32
void IRAM_ATTR resetModule(){
    ets_printf("(watchdog) reiniciar\n"); //imprime no log
    esp_restart_noos(); //reinicia o chip
}

Simulando

Segurando o botão por 3 segundos ou mais, o temporizador não foi resetado.

Logo, Watchdog entra em ação, reiniciando o ESP.

Segurando o botão por menos de 3 segundos.

Logo, não chegou ao limite do temporizador, e o Watchdog não será acionado.

Adicionando o Watchdog no ESP32 LoRa

É importante que vocês assistam este vídeo e entendam o código fonte que utilizei nele. Isso porque, a partir daí, você vai incluir a parte do Watchdog neste mesmo código.

Super WiFi Longa Distância do ESP32 LoRa com Arduino IDE

Para implementarmos o Watchdog nesse projeto faremos poucas alterações como veremos a seguir.

No arquivo LoRaSendReceiveBME280.ino, adicione o seguinte trecho de código em qualquer lugar do arquivo.

//faz o controle do temporizador (interrupção por tempo)
hw_timer_t *timer = NULL; 

//função que o temporizador irá chamar, para reiniciar o ESP32
void IRAM_ATTR resetModule(){
ets_printf("(watchdog) reiniciar\n"); //imprime no log
esp_restart_noos(); //reinicia o chip
}

//função que o configura o temporizador
void configureWatchdog()
{
timer = timerBegin(0, 80, true); //timerID 0, div 80
//timer, callback, interrupção de borda
timerAttachInterrupt(timer, &resetModule, true);
//timer, tempo (us), repetição
timerAlarmWrite(timer, 5000000, true);
timerAlarmEnable(timer); //habilita a interrupção //enable interrupt
}

Nos outros arquivos Master.ino e Slave.ino temos duas linhas para adicionar, uma no Setup e outra no Loop.

void setup(){
    Serial.begin(115200);
    configureWatchdog();
    .....
}

void loop(){
    //reseta o temporizador (alimenta o watchdog)
    timerWrite(timer, 0); 
    .....
}

Faça o download dos arquivos:

INO

PDF