ESP32-C6 na Prática: Watchdog Timer com Arduino IDE

07/11/2025

ÍNDICE DE CONTEÚDO

Este post faz parte da série ESP32-C6 na Prática

Introdução

Em sistemas embarcados e aplicações IoT, precisamos garantir que o sistema se recupere de travamentos, falhas em sensores ou problemas de comunicação. Para evitar isso, devemos implementar o Watchdog Timer (WDT).

Neste artigo, mostraremos como configurar e utilizar o Watchdog Timer na placa de desenvolvimento ESP32-C6 DevKitC-1 com Arduino IDE.

Para conhecer mais a placa de desenvolvimento consulte nosso artigo Introdução à Placa ESP32-C6-DevKitC-1: Ideal para IoT

O que é o Watchdog Timer (WDT)?

O Watchdog Timer é um temporizador interno que reinicia o microcontrolador de forma independente, caso ocorra uma falha de software ou hardware, impossibilitando reiniciar esse contador. Sendo útil para evitar travamentos permanentes em sistemas que precisam funcionar continuamente, como por exemplo aplicações em campo, industriais, IoT e automação residencial. Para saber mais consulte o artigo de José Morais Watchdog Timer – ESP32 – Saiba mais no Embarcados.

Os Melhores Treinamentos sobre Sistemas embarcados e IoT

Cursos com professores qualificados para acelerar sua carreira e projetos

MATRÍCULE-SE AGORA

Também é possível encontrar as informações na documentação da Espressif em Watchdogs – ESP32-C6 – — ESP-IDF Programming Guide v5.5.1 documentation

Como funciona:

O WDT é iniciado com um tempo limite (timeout)
Durante a execução normal, o sistema “alimenta o watchdog” periodicamente.
Se o sistema travar e não alimentar o WDT antes do timeout, o watchdog gera um reset da placa.

Materiais Necessários

Para desenvolver nossa aplicação os materiais utilizados foram:

Placa ESP23-C6 DevKitC-1
Cabo USB-C
Arduino IDE

Para configurar o ambiente e instalar o suporte a ESP32-C6 veja o artigo ESP32-C6 na Prática: Seu Primeiro “Hello World”

Circuito

Código

Neste exemplo, criaremos duas tasks independentes monitoradas pelo Watchdog.

Uma delas será propositalmente “travada” para demonstrar o reset automático do sistema.

#include <esp_task_wdt.h>
#define WDT_TIMEOUT 5000  // tempo em ms (5s)
esp_task_wdt_config_t config = {
  .timeout_ms = WDT_TIMEOUT,
  .idle_core_mask = 0,   // não monitorar idle tasks
  .trigger_panic = true  // resetar sistema ao travar
};
TaskHandle_t xHandleMyTask = NULL;
void myTask(void *pvParameters) {
  while (true) {
    Serial.println("myTask rodando");
    vTaskDelay(pdMS_TO_TICKS(2000));  // simula processamento
    esp_task_wdt_reset();             // alimenta watchdog
  }
}
void setup() {
  Serial.begin(115200);
  esp_task_wdt_init(&config);  // Inicializa o watchdog com a configuração acima
  esp_task_wdt_add(NULL);      // Adiciona loopTask ao watchdog
  // Cria task separada no Core 0
  xTaskCreatePinnedToCore(myTask,          // Nome da função
                          "MyTask",        // Nome da task
                          4096,            // Tamanho da stack
                          NULL,            // Parâmetros
                          1,               // Prioridade
                          &xHandleMyTask,  // Handle da task
                          0);              // Rodar no Core 0
  // Adiciona a nova task ao watchdog
  esp_task_wdt_add(xHandleMyTask);
  Serial.println("Watchdog monitorando loopTask + myTask");
}
void loop() {
  // Simula trabalho normal
  for (int i = 0; i < 10; i++) {
    Serial.println(i);
    delay(1000);           // cada ponto = 1s → 10s total
    esp_task_wdt_reset();  // alimenta o watchdog
  }
  Serial.println("\nSimulando travamento (sem reset do WDT)...");
  delay(10000);  // maior que o timeout → watchdog vai reiniciar
}

#include <esp_task_wdt.h>
#define WDT_TIMEOUT 5000  // tempo em ms (5s)
esp_task_wdt_config_t config = {
  .timeout_ms = WDT_TIMEOUT,
  .idle_core_mask = 0,   // não monitorar idle tasks
  .trigger_panic = true  // resetar sistema ao travar
};
TaskHandle_t xHandleMyTask = NULL;
void myTask(void *pvParameters) {
  while (true) {
    Serial.println("myTask rodando");
    vTaskDelay(pdMS_TO_TICKS(2000));  // simula processamento
    esp_task_wdt_reset();             // alimenta watchdog
  }
}
void setup() {
  Serial.begin(115200);
  esp_task_wdt_init(&config);  // Inicializa o watchdog com a configuração acima
  esp_task_wdt_add(NULL);      // Adiciona loopTask ao watchdog
  // Cria task separada no Core 0
  xTaskCreatePinnedToCore(myTask,          // Nome da função
                          "MyTask",        // Nome da task
                          4096,            // Tamanho da stack
                          NULL,            // Parâmetros
                          1,               // Prioridade
                          &xHandleMyTask,  // Handle da task
                          0);              // Rodar no Core 0
  // Adiciona a nova task ao watchdog
  esp_task_wdt_add(xHandleMyTask);
  Serial.println("Watchdog monitorando loopTask + myTask");
}
void loop() {
  // Simula trabalho normal
  for (int i = 0; i < 10; i++) {
    Serial.println(i);
    delay(1000);           // cada ponto = 1s → 10s total
    esp_task_wdt_reset();  // alimenta o watchdog
  }
  Serial.println("\nSimulando travamento (sem reset do WDT)...");
  delay(10000);  // maior que o timeout → watchdog vai reiniciar
}

O código completo pode ser consultado em:

ESP32-C6/watchdog/watchdog.ino at main · guilhermefernandesk/ESP32-C6

Resultados

Figura 2: Exemplo de saída no Monitor Serial

Conclusão

Neste artigo, demonstramos na prática o uso do Watchdog Timer (WDT) no ESP32-C6, utilizando a Arduino IDE.
O WDT é essencial em aplicações IoT e sistemas críticos, pois evita que travamentos comprometam o funcionamento contínuo do dispositivo.

Sinta-se à vontade para compartilhar seus resultados com a comunidade, seja por artigos, vídeos ou repositórios abertos. Sua experiência pode inspirar e auxiliar muitos outros desenvolvedores.