Watchdog timer no Arduino: reinicie sozinha uma placa travada
O que é o watchdog timer do Arduino? Use avr/wdt.h no Uno, o Task WDT no ESP32 e machine.WDT no Pico para reiniciar automaticamente uma placa travada, com o posicionamento correto.
O watchdog do Arduino é um temporizador de segurança em hardware que percebe quando o programa travou e reinicia a placa sozinho. O programa envia regularmente um sinal de “ainda estou funcionando”; se esse sinal não chegar dentro do tempo definido, o watchdog reinicia a placa como se o botão de reset tivesse sido pressionado. Assim, um projeto preso em um loop infinito, esperando um sensor ou congelado dentro de uma biblioteca de Wi-Fi se recupera em poucos segundos, sem que você precise ir até lá tirar da tomada.
Reiniciar à mão uma placa travada é fácil na sua bancada, mas não é possível em um sistema de irrigação no jardim, em uma estação meteorológica no telhado ou em um dispositivo de casa inteligente que fica ligado por semanas. Neste post você vai aprender como o watchdog funciona, como usar o avr/wdt.h no Arduino Uno, o Task WDT no ESP32 e o machine.WDT no Raspberry Pi Pico, o lugar certo do comando de alimentação e os erros clássicos que prendem a placa em um loop de reset sem fim, tudo com código de exemplo.

O que é um watchdog timer e como ele funciona?
O watchdog é um pequeno contador dentro do microcontrolador que conta de forma independente do programa principal. Você o inicia com um tempo definido, por exemplo 2 segundos, e ele começa a contar. O comando de alimentação (feed) que você chama a cada passada do programa (também chamado de “kick the dog”, “chutar o cachorro”) zera o contador. Enquanto o programa roda saudável, o contador nunca chega ao fim. Se o programa trava em algum ponto, a alimentação não chega, o contador estoura e o watchdog aplica um reset de hardware no microcontrolador. Depois do reset, a placa começa de novo pelo setup(), como se tivesse acabado de ser ligada.
O segredo da confiabilidade do watchdog é que ele funciona com uma fonte de clock separada do clock principal. No ATmega328P do Arduino Uno essa fonte é um oscilador interno de 128 kHz; mesmo que o cristal de 16 MHz do programa ou o fluxo do código falhe, o watchdog continua contando. As causas típicas de travamento são: um laço while cuja condição de saída nunca acontece, uma biblioteca esperando para sempre um sensor I2C que não responde, a RAM fragmentada com o tempo por concatenações de String, memória corrompida por um array que estourou ou ruído elétrico fazendo o programa pular para um endereço aleatório.
| Característica | Arduino Uno (ATmega328P) | ESP32 | Raspberry Pi Pico (RP2040) |
|---|---|---|---|
| Biblioteca / módulo | avr/wdt.h | esp_task_wdt.h | machine.WDT (MicroPython) |
| Iniciar | wdt_enable(WDTO_2S) (inicialização) | esp_task_wdt_init / reconfigure + esp_task_wdt_add(NULL) | WDT(timeout=5000) (inicialização) |
| Alimentar | wdt_reset() (alimenta) | esp_task_wdt_reset() (alimenta) | wdt.feed() (alimenta) |
| Tempo máximo | 8 s | Configurável (padrão do Arduino: 5 s) | 8388 ms (cerca de 8,3 s) |
| Parar | wdt_disable() (desliga) | Remova a tarefa com esp_task_wdt_delete() | Não pode ser parado (só um reset o desliga) |
| Fonte de clock | Oscilador interno de 128 kHz | Grupo de temporizadores de hardware (MWDT) | Gerador de tick interno de 1 µs |
O que o watchdog resolve e o que ele não resolve?
- Loops infinitos: um laço while esperando um valor que nunca chega, ou uma máquina de estados presa por um erro de lógica, é resolvido em poucos segundos pelo watchdog.
- Bibliotecas travadas: se uma biblioteca de rede congela em uma conexão Wi-Fi, MQTT ou HTTP, ou um driver de sensor que não responde trava a placa, o reset a devolve a um estado limpo.
- Memória corrompida: se a fragmentação da RAM ou um estouro de pilha (stack) faz o programa se comportar de forma estranha e travar, o watchdog coloca a placa de pé de novo.
- Ruído elétrico: se a interferência de relés, motores ou fios longos faz o programa pular para um ponto aleatório, a falta de alimentação do watchdog é o que o salva.
- O que ele não resolve: tensão de alimentação baixa (brownout), um sensor externo travado ou um valor calculado errado. O watchdog só reinicia o microcontrolador; um sensor que segura a linha I2C em LOW muitas vezes não se recupera até que a alimentação dele seja cortada. Se o programa roda errado, mas de forma regular, o watchdog não consegue perceber.
Watchdog no Arduino Uno: avr/wdt.h
Nas placas baseadas em AVR (Uno, Nano, Mega, Pro Mini) você não precisa instalar nenhuma biblioteca extra para o watchdog; o arquivo de cabeçalho avr/wdt.h, que vem com o compilador, é suficiente. Há três funções básicas: wdt_enable(tempo) inicia o watchdog, wdt_reset() zera (alimenta) o contador e wdt_disable() o desliga. O tempo é dado com uma das constantes prontas abaixo; são dez opções, de cerca de 15 ms até 8 segundos. Não dá para escolher diretamente um tempo maior que 8 segundos, mas com o método de alimentação condicional que você verá daqui a pouco, é possível montar limites mais longos.
| Constante | Tempo aprox. | Uso típico |
|---|---|---|
| WDTO_15MS | 15 ms | Reset instantâneo por software |
| WDTO_30MS | 30 ms | Pouco usado |
| WDTO_60MS | 60 ms | Pouco usado |
| WDTO_120MS | 120 ms | Laços de controle muito curtos |
| WDTO_250MS | 250 ms | Laços que precisam de resposta rápida |
| WDTO_500MS | 500 ms | Controle de botões e LEDs |
| WDTO_1S | 1 s | Laços de controle simples |
| WDTO_2S | 2 s | Leitura de sensores e atualização de display |
| WDTO_4S | 4 s | Sensores lentos, comunicação |
| WDTO_8S | 8 s | Operações de rede, cálculos longos |
Passo a passo: seu primeiro teste de watchdog
- Conecte o Arduino Uno ao computador pelo USB; além do LED integrado (pino 13), não é preciso nenhum circuito extra.
- Carregue o código abaixo e abra o Monitor Serial a 9600 baud.
- Você verá “Basladi” (“Começou”, em turco) na tela e o LED piscando a cada meio segundo.
- Envie a letra k pelo Monitor Serial; o programa entra de propósito em um loop infinito e o LED congela onde está.
- Depois de cerca de 2 segundos, a placa reinicia sozinha, “Basladi” aparece de novo e o LED volta a piscar.
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}A linha MCUSR = 0 logo no início do setup() limpa as flags de reset; no ATmega328P o watchdog não pode ser desligado enquanto a flag de reset do watchdog (WDRF) não for apagada, por isso o wdt_disable() vem depois dela. Ativamos o watchdog no fim do setup(), depois de terminada a inicialização, para que a partida demorada de um sensor não dispare um reset por engano. O wdt_reset() na primeira linha do loop() zera o contador a cada passada. Piscar o LED com millis() em vez de delay() também é proposital: o loop() volta sem esperar e alimenta o watchdog de novo e de novo em questão de milissegundos.
Bootloader antigo e o loop de reset sem fim
Quando o watchdog provoca um reset, o ATmega328P não desliga o watchdog; pelo contrário, ele o deixa ativo com o menor tempo (cerca de 16 ms). Se o bootloader, o primeiro programa que a placa executa ao ligar, não trata isso, o watchdog estoura enquanto ele ainda está esperando o código a ser carregado, e a placa reinicia de novo. O resultado é um loop de reset sem fim, em que o LED pisca rápido, o código nunca começa e não dá para carregar código novo. O bootloader Optiboot do Arduino Uno original desliga o watchdog na partida, então não tem esse problema. O problema aparece mais em clones do Nano com bootloader antigo e em algumas placas Mega 2560 mais antigas.
Onde colocar o comando de alimentação?
- Escolha um único ponto central: coloque o wdt_reset() dentro do loop(), no ponto pelo qual todo o trabalho passa. Se você espalhar alimentações pelo código todo, um sub-laço travado continua se alimentando sozinho e o watchdog perde o sentido.
- Não alimente dentro de uma interrupção: uma interrupção de timer continua rodando mesmo com o programa principal congelado. Se você colocar a alimentação ali, o watchdog não pega nenhum travamento. Veja como as interrupções funcionam no post Interrupções no Arduino.
- Escolha o tempo pela operação mais longa: o tempo do watchdog deve ser pelo menos o dobro da duração de uma passada do loop() no pior caso. Se você usar WDTO_2S em um laço com delay(3000), a placa reinicia o tempo todo.
- Coloque tempo limite nos laços de espera: em vez de alimentar dentro de um laço como while (!Serial.available()), faça o laço sair depois de um certo tempo. Assim a placa não congela e o watchdog continua atento aos travamentos reais.
- Ative o watchdog depois da configuração: ative-o quando operações longas, como a conexão Wi-Fi, a inicialização do cartão SD ou a calibração de sensores, já tiverem terminado no setup().
Uma abordagem mais esperta é tornar a alimentação condicional: você só alimenta o watchdog se o sistema estiver realmente saudável. No exemplo abaixo, um sensor ligado ao A0 é lido a cada 5 segundos; se a leitura estiver em uma faixa que faça sentido, o horário da última medição bem-sucedida é atualizado. Se não houver nenhuma medição bem-sucedida por 60 segundos, a alimentação para e a placa reinicia 4 segundos depois. Com esse método você monta uma supervisão na escala de minutos, que vai além do limite de 8 segundos do AVR, e pega não só congelamentos, mas também falhas silenciosas, como um fio de sensor rompido.
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 no ESP32: Task WDT e Interrupt WDT
No ESP32 já existe um watchdog rodando por padrão; a maioria das pessoas o nota pela primeira vez quando aparece uma mensagem inesperada “Task watchdog got triggered” no monitor serial. Como o ESP32 roda várias tarefas ao mesmo tempo sob o sistema operacional FreeRTOS, ele usa uma estrutura em camadas em vez de um único contador. O Task WDT (TWDT) verifica se as tarefas inscritas nele são alimentadas dentro de um tempo definido; o Interrupt WDT (IWDT) detecta quando as interrupções e o escalonador de tarefas ficam bloqueados por muito tempo. No core do Arduino, o TWDT normalmente vem ativo com tempo de 5 segundos e monitora as tarefas ociosas (idle); a tarefa que roda o loop() não é monitorada a menos que você a adicione. O comportamento padrão pode variar com a versão do core e, em algumas configurações, o TWDT só imprime um aviso e não reinicia a placa, então definir o tempo e o comportamento de reset explicitamente no código é a opção mais segura.
| Tipo | O que monitora | Tempo típico | Mensagem que aparece ao disparar |
|---|---|---|---|
| Task WDT (TWDT) | Funcionamento regular das tarefas inscritas e das tarefas ociosas | 5 s (configurável) | task_wdt: Task watchdog got triggered (watchdog de tarefa disparado) |
| Interrupt WDT (IWDT) | Bloqueio das interrupções e do escalonador de tarefas | Cerca de 300 ms | Guru Meditation Error ... Interrupt wdt timeout on CPU1 (tempo esgotado do WDT de interrupção) |
| RTC WDT | Travamento do processo de inicialização (boot) | Tempo curto durante o boot | rst:0x10 (RTCWDT_RTC_RESET) |
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}O código verifica a versão do core com ESP_ARDUINO_VERSION_MAJOR: na versão 3.x (ESP-IDF 5) as configurações são passadas com a estrutura esp_task_wdt_config_t e um TWDT que já está rodando é atualizado com esp_task_wdt_reconfigure(); na versão 2.x, o esp_task_wdt_init() recebe diretamente o tempo em segundos e a flag de pânico. Quando trigger_panic é true, o ESP32 imprime o despejo do erro na porta serial e se reinicia quando o tempo acaba. O esp_task_wdt_add(NULL) começa a monitorar a tarefa que está rodando no momento, ou seja, a que executa o setup() e o loop(). Ler e registrar a causa do reset anterior com esp_reset_reason() na partida é a forma mais fácil de entender por que um dispositivo em campo reiniciou. Se você só quer monitorar o loop() sem nenhuma configuração, pode chamar a função enableLoopWDT() do core do Arduino no setup(); nesse caso, a alimentação é feita automaticamente no início de cada passada do loop().
Watchdog no Raspberry Pi Pico (MicroPython)
O watchdog de hardware do RP2040 é usado no MicroPython com a classe machine.WDT. O tempo é dado em milissegundos e pode ser de no máximo 8388 ms no RP2040. Há uma diferença importante: no Pico, depois de iniciado, o watchdog não pode ser parado pelo código; só um reset o desliga. Por isso, deixar um pequeno caminho de recuperação durante o desenvolvimento salva vidas. No código abaixo, se o pino GP15 estiver ligado ao GND na partida, o watchdog nunca é iniciado e o programa cai no REPL. Com machine.reset_cause() você também descobre se a placa iniciou por causa do watchdog ou com uma ligação normal. Se você programa o Pico com o Arduino IDE (core arduino-pico) em vez do MicroPython, o mesmo trabalho é feito com as funções rp2040.wdt_begin(5000) e rp2040.wdt_reset().
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)Estratégia de watchdog para projetos IoT que ficam ligados por muito tempo
- Registre as inicializações: a cada partida, grave um contador na EEPROM no Uno ou nas Preferences (NVS) no ESP32; no ESP32, guarde também a causa com esp_reset_reason(). Um reset por semana é aceitável; um reset por hora é um bug que precisa ser corrigido. Como o Optiboot limpa as flags de reset no Uno, muitas vezes não dá para ler a causa no MCUSR; mesmo assim, o contador de inicializações mostra com que frequência o dispositivo reinicia.
- Coloque tempo limite nas operações de rede: não espere para sempre pela conexão Wi-Fi; por exemplo, se não conectar em 15 segundos, saia do laço e tente de novo depois de um tempo. Configurações como setTimeout() no HTTPClient e Wire.setWireTimeout() no AVR evitam que uma operação travada ultrapasse o tempo do watchdog. Para problemas de conexão, veja ESP32 não conecta ao Wi-Fi.
- Leve em conta as atualizações OTA: um carregamento sem fio leva segundos e o loop() pode ficar parado durante esse tempo. Chamando esp_task_wdt_reset() no callback onProgress do ArduinoOTA, você evita que a atualização seja interrompida no meio; essa é uma exceção rara, mas justificada, à regra.
- Pense nos modos de sono: no Uno, o watchdog pode ser usado em modo de interrupção como temporizador para acordar, e dá para dormir em intervalos de 8 segundos. No ESP32, o processador fica desligado durante o deep sleep e o código começa do início ao acordar. Veja ESP32 Deep Sleep para detalhes.
- Controle a alimentação dos sensores externos: o watchdog não reinicia o sensor. Se você alimentar um sensor I2C que trava com frequência através de um transistor ou MOSFET e cortar e religar a alimentação dele por algumas centenas de milissegundos na partida, o sensor começa limpo junto com o microcontrolador. Veja como a linha I2C fica travada no post O que é I2C.
- Watchdog externo em sistemas críticos: o watchdog interno só pega as falhas do próprio microcontrolador. Se for preciso supervisionar o circuito inteiro, usa-se um CI de watchdog externo que espera pulsos regulares de um GPIO, ou um segundo microcontrolador pequeno.
Erros comuns e soluções
| Sintoma | Causa provável | Solução |
|---|---|---|
| A placa reinicia a cada poucos segundos | O tempo do watchdog é menor que a passada mais longa do loop() (ex.: WDTO_2S com delay(3000)) | Aumente o tempo, use millis() em vez de delay() |
| O LED pisca rápido, o código não carrega | O bootloader antigo não desliga o watchdog depois de um reset do watchdog | Grave o Optiboot via ISP e programe a placa com a opção de bootloader atual |
| A placa trava, mas nunca reinicia | A alimentação está dentro de uma interrupção de timer ou de um sub-laço travado | Mova o wdt_reset() para um único ponto no loop() |
| O ESP32 repete “Task watchdog got triggered”, sem reset | O TWDT não está em modo pânico | Defina trigger_panic como true (segundo parâmetro na 2.x) |
| Aviso “IDLE (CPU 0)” no ESP32 | Uma tarefa no núcleo 0 fica em laço sem nunca esperar | Adicione vTaskDelay(1) ao laço |
| esp_task_wdt_reset() dá erro “task not found” (tarefa não encontrada) | A tarefa não foi adicionada ao TWDT | Chame esp_task_wdt_add(NULL) antes |
| O Pico desconecta ao ser parado no Thonny | O machine.WDT não pode ser parado depois de iniciado | Use um pino de recuperação; nos testes, rode o código com um nome diferente de main.py |
| Um relé ou motor liga por um instante sem querer durante o reset | Os pinos voltam a ser entradas durante o reset e a entrada do driver fica flutuando | Adicione resistores de pull-down nas saídas e defina um estado seguro no início do setup() |
Com poucas linhas de código, um watchdog timer transforma seu projeto de um experimento de bancada em um dispositivo que funciona sozinho por dias. Primeiro elimine as causas reais dos travamentos, depois adicione o watchdog como última camada de segurança e coloque a alimentação em um único ponto que faça sentido. No app BlueGrays você pode acompanhar passo a passo projetos que ficam ligados por muito tempo, como conexão Wi-Fi com ESP32, servidor web, atualização OTA, previsão do tempo e irrigação inteligente, com esquemas do circuito e código, e adicionar o watchdog a eles você mesmo.
Perguntas frequentes
Para que serve o watchdog timer do Arduino?
O watchdog é um temporizador embutido que reinicia a placa automaticamente se o programa não enviar um sinal de “ainda estou funcionando” dentro do tempo definido. Ele traz de volta, em segundos, projetos que entram em loop infinito, travam esperando um sensor ou congelam em uma biblioteca de rede. É essencial principalmente em dispositivos de irrigação, alarme e IoT que funcionam sem supervisão por muito tempo.
Como reiniciar o Arduino pelo código?
Nas placas AVR, a forma mais limpa é ativar o watchdog com o menor tempo e esperar: quando você escreve wdt_enable(WDTO_15MS); while (true) {}, a placa recebe um reset de hardware de verdade quase na hora. No ESP32, ESP.restart() faz o mesmo, e no Raspberry Pi Pico com MicroPython, machine.reset(). Em clones do Nano com bootloader antigo, esse método pode causar um loop de reset sem fim.
Qual é o tempo máximo do watchdog?
No Arduino Uno e nas outras placas AVR, o tempo máximo é de 8 segundos (WDTO_8S). No Raspberry Pi Pico o limite é de 8388 ms, enquanto no Task WDT do ESP32 o tempo pode ser definido livremente. Se você precisar de uma supervisão mais longa, pode montar limites na escala de minutos com o método de alimentação condicional, que só alimenta o watchdog enquanto o sistema está saudável.
Como corrigir o erro “Task watchdog got triggered” no ESP32?
Essa mensagem indica que uma tarefa monitorada não foi alimentada dentro do tempo definido; a causa costuma ser um laço while que volta sem esperar ou uma tarefa FreeRTOS que deixa a tarefa ociosa sem tempo de rodar. Adicione vTaskDelay(1) ou delay(1) aos seus laços, divida operações longas em partes e, se você adicionou sua própria tarefa ao TWDT, chame esp_task_wdt_reset() regularmente. A tarefa citada na mensagem, por exemplo IDLE (CPU 0), mostra em qual núcleo está o problema.
Adicionei um watchdog e meu Arduino não para de reiniciar. Por quê?
A causa mais comum é um tempo de watchdog menor que a passada mais longa do loop(); por exemplo, escolher WDTO_2S quando o laço tem delay(3000). Deixe o tempo pelo menos no dobro da duração da passada no pior caso e use millis() em vez de chamadas longas de delay(). Se o LED pisca rápido e não dá para carregar o código, o problema é um bootloader antigo; você precisa gravar o Optiboot na placa via ISP.
As variáveis são preservadas depois de um reset do watchdog?
Não, o reset do watchdog reinicia a placa e o setup() roda desde o início; as variáveis globais voltam aos valores iniciais. Informações que precisam sobreviver a um reset, como contadores, configurações ou o último estado, devem ser gravadas na EEPROM no Uno, nas Preferences (NVS) no ESP32 e em um arquivo na flash no Pico.
Projetos para montar depois desta leitura
Ver todos os projetos
LED piscando com ESP32
Ensina o uso básico de uma saída GPIO no ESP32. Fazemos um LED piscar ligando e desligando um pino digital. É a versão para ESP32 do clássico projeto blink do Arduino UNO: os comandos básicos de blink no ambiente Arduino são os mesmos, mas a disposição dos pinos e os níveis de 3,3 V dos GPIOs do ESP32 diferem dos do Arduino UNO.

Piscar o LED integrado do Raspberry Pi Pico (Pico e Pico W)
O primeiro projeto da série Raspberry Pi Pico! Fazemos o LED verde integrado piscar para verificar se a placa funciona — um primeiro experimento no estilo clássico "Hello World". SEM componentes externos, apenas o Pico e um cabo USB. O código foi escrito em MicroPython (a linguagem com suporte oficial da Raspberry Pi Foundation). Aprenda a usar a classe machine.Pin, o modo Pin.OUT, os métodos led.on()/off() e time.sleep() no Thonny IDE.

Conexão Wi-Fi STA com ESP32 e display LCD
Neste projeto, conectamos o ESP32 à rede Wi-Fi de casa no modo estação (STA), de forma segura e tolerante a falhas. Guardamos o SSID e a senha em um arquivo secrets.h separado para evitar que sejam expostos no Git, configuramos um mecanismo de reconexão automática e exibimos o nível de sinal RSSI e o endereço IP em um display LCD I2C. O LED integrado funciona como indicador de status. É um gerenciador de conexão pronto para uso em produção.

Servidor web assíncrono com ESP32 (IP no LCD)
Neste projeto, transformamos o ESP32 em um servidor web assíncrono que você pode controlar pelo celular ou computador na mesma rede Wi-Fi. Com a biblioteca ESPAsyncWebServer, o servidor processa várias requisições ao mesmo tempo (ao contrário do WebServer.h tradicional, que bloqueia a execução ao processar uma requisição). Você poderá abrir o endereço IP do ESP32 no navegador e clicar nos botões ON/OFF (as rotas /on e /off) para ligar e desligar o LED conectado ao GPIO 5.

Atualização OTA no ESP32 — firmware sem fio (com display LCD)
Neste projeto, você aprende a carregar um novo firmware no ESP32 por Wi-Fi, sem cabo USB. Com a biblioteca ArduinoOTA, o ESP32 fica visível na rede e aparece automaticamente como bluegrays-ota na aba "Porta de rede" do Arduino IDE. A primeira carga é feita por USB, e todas as atualizações seguintes são sem fio — um recurso essencial para dispositivos em campo. O LCD I2C mostra o estado do Wi-Fi, o IP, o nome do host, a porcentagem de envio por OTA e as mensagens de erro em turco e inglês.

ESP32 HTTPClient + API de clima (com display LCD)
Neste projeto, usamos o ESP32 para fazer uma chamada REST à API de clima wttr.in pela internet com HTTPClient.h. Interpretamos a resposta JSON com ArduinoJson v7 e mostramos cidade, temperatura, umidade, condições do tempo e vento em um display LCD I2C, em turco e inglês. O wttr.in é grátis e não exige chave de API — basta informar o nome de uma cidade para consultar o clima atual. Os dados se atualizam sozinhos a cada 30 minutos, e o LED dá um retorno visual diferente para cada tela.

Alarme de movimento com ESP32 (PIR + buzzer + LED + Telegram)
Um sistema de alarme de segurança inteligente que aciona o buzzer e o LED quando o sensor PIR detecta movimento e, ao mesmo tempo, envia uma notificação instantânea ao proprietário pelo Telegram. Inclui um intervalo de espera de 30 segundos para limitar a frequência dos alarmes repetidos; esse mecanismo não valida as detecções do PIR nem elimina disparos falsos. Pode ser usado na segurança de casas, no monitoramento de garagens, depósitos ou salas de trabalho.
Mais artigos
App BlueGrays
Monte este circuito passo a passo pelo celular
Esquema do circuito, código e lista de componentes em uma só tela. Mais de 500 projetos com Arduino, ESP32 e Pico prontos para montar.
Escaneie com seu celular
Aponte a câmera para o código para abrir a loja de aplicativos do seu celular.
ou abrir a loja

