Bases · 13 min de lecture

Watchdog Arduino : redémarrage automatique en cas de blocage

Comment utiliser le watchdog Arduino ? avr/wdt.h sur Uno, Task WDT sur ESP32, machine.WDT sur Pico : redémarre ta carte bloquée, avec bon placement et erreurs.

Le watchdog Arduino (chien de garde) est une minuterie de sécurité matérielle qui détecte le blocage du programme et redémarre la carte toute seule. Le programme envoie régulièrement un signal « je tourne toujours » ; si ce signal n'arrive pas dans le délai fixé, le watchdog réinitialise la carte comme si tu avais appuyé sur le bouton reset. Un projet pris dans une boucle infinie, bloqué en attendant un capteur ou figé dans la bibliothèque Wi-Fi reprend ainsi vie en quelques secondes, sans que tu aies à débrancher quoi que ce soit.

Sur ton bureau, redémarrer à la main une carte bloquée est facile ; mais ce n'est pas possible pour un système d'arrosage au jardin, une station météo sur le toit ou un appareil domotique allumé pendant des semaines. Dans cet article, tu vas découvrir le fonctionnement du watchdog, l'utilisation de avr/wdt.h sur Arduino Uno, de Task WDT sur ESP32 et de machine.WDT sur Raspberry Pi Pico, le bon emplacement de la commande de reset et les erreurs classiques qui provoquent une boucle de redémarrage, avec des exemples de code.

Carte Arduino Uno et microcontrôleur ATmega328P
L'ATmega328P de l'Arduino Uno contient un watchdog interne cadencé par son propre oscillateur de 128 kHz ; aucun composant supplémentaire n'est nécessaire.

Qu'est-ce qu'un watchdog timer et comment fonctionne-t-il ?

Le watchdog est un petit compteur, à l'intérieur du microcontrôleur, qui compte indépendamment du programme principal. Tu le démarres avec une durée, par exemple 2 secondes, et il commence à compter. La commande de reset du compteur (en anglais « feed » ou « kick the dog ») que tu appelles à chaque tour de programme remet le compteur à zéro. Tant que le programme fonctionne bien, le compteur n'arrive jamais au bout. Si le programme se bloque quelque part, plus de reset du compteur : le délai s'écoule et le watchdog provoque un reset matériel du microcontrôleur. Après le reset, la carte repart de la fonction setup() comme si elle venait d'être alimentée.

Le watchdog est fiable parce qu'il utilise une source d'horloge séparée de l'horloge principale. Sur l'ATmega328P de l'Arduino Uno, c'est un oscillateur interne de 128 kHz ; même si le quartz de 16 MHz ou le déroulement du code est perturbé, le watchdog continue de compter. Les causes typiques de blocage : une boucle while dont la condition de sortie n'arrive jamais, une bibliothèque qui attend indéfiniment un capteur I2C muet, une RAM fragmentée par des concaténations de String, une mémoire corrompue par un débordement de tableau ou du bruit électrique qui fait sauter le programme à une adresse aléatoire.

CaractéristiqueArduino Uno (ATmega328P)ESP32Raspberry Pi Pico (RP2040)
Bibliothèque / moduleavr/wdt.hesp_task_wdt.hmachine.WDT (MicroPython)
Démarragewdt_enable(WDTO_2S)esp_task_wdt_init / reconfigure + esp_task_wdt_add(NULL)WDT(timeout=5000)
Réarmementwdt_reset()esp_task_wdt_reset()wdt.feed()
Durée maximale8 sRéglable (5 s par défaut sous Arduino)8388 ms (environ 8,3 s)
Arrêtwdt_disable()esp_task_wdt_delete() retire la tâcheImpossible (s'arrête seulement par reset)
Source d'horlogeOscillateur interne 128 kHzGroupe de timers matériels (MWDT)Générateur de tick interne de 1 µs

Que résout le watchdog, et que ne résout-il pas ?

  • Boucles infinies : une boucle while qui n'obtient jamais la valeur attendue ou une machine à états bloquée par une erreur de logique est débloquée en quelques secondes.
  • Bibliothèques bloquées : si une bibliothèque réseau figée sur une connexion Wi-Fi, MQTT ou HTTP, ou un pilote de capteur muet, gèle la carte, le reset la remet dans un état propre.
  • Corruption mémoire : si la fragmentation de la RAM ou un débordement de pile fait planter le programme, le watchdog remet la carte sur pied.
  • Bruit électrique : si des parasites de relais, de moteurs ou de longs câbles font sauter le programme, l'arrêt du réarmement te sauve.
  • Ce qu'il ne résout pas : une tension d'alimentation trop basse (brownout), un capteur externe bloqué ou une valeur mal calculée. Le watchdog ne réinitialise que le microcontrôleur ; un capteur qui maintient la ligne I2C bloquée ne repart souvent qu'une fois son alimentation coupée. Si le programme est faux mais tourne régulièrement, le watchdog ne le voit pas.
Le watchdog n'est pas une solution à un bug, c'est une ceinture de sécurité. Si tu vois ta carte redémarrer plusieurs fois par jour, cherche le vrai problème : le plus souvent une alimentation insuffisante, une fuite mémoire ou une boucle d'attente sans délai maximal. Pour les causes matérielles des resets aléatoires, jette un œil à l'article Arduino redémarre sans arrêt.

Watchdog sur Arduino Uno : avr/wdt.h

Sur les cartes AVR (Uno, Nano, Mega, Pro Mini), pas besoin d'installer de bibliothèque : le fichier d'en-tête avr/wdt.h fourni avec le compilateur suffit. Il y a trois fonctions de base : wdt_enable(durée) démarre le watchdog, wdt_reset() remet le compteur à zéro (le nourrit) et wdt_disable() l'arrête. La durée se donne avec l'une des constantes ci-dessous ; il y a dix choix, d'environ 15 ms à 8 secondes. Tu ne peux pas choisir directement plus de 8 secondes, mais la méthode de réarmement conditionnel vue plus loin te permet de fixer des limites bien plus longues.

ConstanteDurée approximativeUsage typique
WDTO_15MS15 msReset logiciel immédiat
WDTO_30MS30 msRarement utilisée
WDTO_60MS60 msRarement utilisée
WDTO_120MS120 msBoucles de contrôle très courtes
WDTO_250MS250 msBoucles à réaction rapide
WDTO_500MS500 msContrôle de boutons et de LED
WDTO_1S1 sBoucles de contrôle simples
WDTO_2S2 sLecture de capteurs et mise à jour d'écran
WDTO_4S4 sCapteurs lents, communication
WDTO_8S8 sOpérations réseau, longs calculs

Pas à pas : ton premier essai de watchdog

  1. Branche l'Arduino Uno à l'ordinateur en USB ; hormis la LED intégrée (broche 13), aucun circuit supplémentaire n'est nécessaire.
  2. Téléverse le code ci-dessous et ouvre le moniteur série à 9600 bauds.
  3. Tu vois le message « Basladi » et la LED qui clignote toutes les demi-secondes.
  4. Envoie la lettre k depuis le moniteur série ; le programme entre volontairement dans une boucle infinie et la LED se fige.
  5. Environ 2 secondes plus tard, la carte redémarre toute seule, « Basladi » s'affiche à nouveau et la LED recommence à clignoter.
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 ligne MCUSR = 0 au tout début de setup() efface les drapeaux de reset ; sur l'ATmega328P, on ne peut pas désactiver le watchdog tant que le drapeau de reset watchdog (WDRF) n'est pas effacé, c'est pourquoi wdt_disable() vient après. On active le watchdog à la fin de setup(), une fois les initialisations terminées, afin qu'une longue initialisation de capteur ne déclenche pas un reset par erreur. Le wdt_reset() de la première ligne de loop() remet le compteur à zéro à chaque tour. Faire clignoter la LED avec millis() plutôt qu'avec delay() est aussi un choix voulu : loop() ne s'arrête jamais et réarme le watchdog à intervalles de quelques millisecondes.

Déclencher volontairement le watchdog est la façon la plus propre de redémarrer la carte par code : en écrivant wdt_enable(WDTO_15MS); while (true) {}, la carte subit très vite un vrai reset matériel. La méthode courante du « saut à l'adresse 0 » ne fait que relancer le programme sans réinitialiser les périphériques. Rappelle-toi aussi que les durées du tableau sont des valeurs typiques ; l'oscillateur de 128 kHz dérive selon la température et la tension, donc n'utilise pas le watchdog pour un chronométrage précis, seulement pour la sécurité.

Ancien bootloader et boucle de redémarrage infinie

Quand le watchdog provoque un reset, l'ATmega328P ne le désactive pas ; au contraire, il le laisse actif avec la durée la plus courte (environ 16 ms). Si le bootloader, le premier programme exécuté au démarrage, ne gère pas ce cas, le délai du watchdog expire déjà pendant qu'il attend le téléversement et la carte redémarre encore. Résultat : une boucle de redémarrage infinie où la LED clignote vite, le code ne démarre jamais et aucun nouveau code ne peut être téléversé. Le bootloader Optiboot de l'Arduino Uno d'origine désactive le watchdog au démarrage et n'a donc pas ce problème. Il apparaît surtout sur les clones de Nano avec un ancien bootloader et sur certaines vieilles Mega 2560.

Si tu programmes ta carte dans l'IDE Arduino avec l'option ATmega328P (Old Bootloader), sois prudent avant d'essayer le watchdog. Si la carte entre en boucle, tu devras utiliser un second Arduino comme programmeur ISP et écrire le bootloader Optiboot récent avec la commande Graver la séquence d'initialisation du menu Outils. Même avec Optiboot, garder MCUSR = 0 et wdt_disable() au début de setup() est une bonne habitude.

Où placer la commande de réarmement ?

  • Choisis un seul endroit central : place wdt_reset() dans loop(), en un point unique par lequel passe tout le travail. Si tu sèmes des réarmements dans tout le code, une sous-boucle bloquée continue de s'auto-nourrir et le watchdog perd son sens.
  • Ne réarme pas dans une interruption : une interruption de timer continue de s'exécuter même si le programme principal est gelé. Si tu y mets le réarmement, le watchdog ne détectera aucun blocage. Tu trouveras le fonctionnement des interruptions dans l'article Arduino Interrupt.
  • Choisis la durée selon l'opération la plus longue : la durée du watchdog doit valoir au moins le double du tour de loop() le plus long. Si tu utilises WDTO_2S dans une boucle contenant delay(3000), la carte redémarre sans arrêt.
  • Ajoute un délai maximal aux boucles d'attente : au lieu de réarmer dans une boucle comme while (!Serial.available()), fais-la sortir après un certain temps. Ainsi la carte ne se fige pas et le watchdog reste attentif aux vrais blocages.
  • Active le watchdog après l'initialisation : active-le une fois terminées les opérations longues de setup(), comme la connexion Wi-Fi, l'initialisation de la carte SD ou l'étalonnage de capteurs.

Une approche plus intelligente consiste à conditionner le réarmement : tu ne nourris le watchdog que si le système est réellement en bonne santé. Dans l'exemple suivant, un capteur relié à A0 est lu toutes les 5 secondes ; si la valeur est dans une plage plausible, l'heure de la dernière mesure réussie est mise à jour. Si aucune mesure ne réussit pendant 60 secondes, le réarmement s'arrête et la carte redémarre 4 secondes plus tard. Avec cette méthode, tu dépasses la limite de 8 secondes de l'AVR avec une surveillance de plusieurs minutes, et tu détectes non seulement les blocages mais aussi les pannes silencieuses comme un fil de capteur débranché.

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 sur ESP32 : Task WDT et Interrupt WDT

Sur ESP32, le watchdog fonctionne déjà par défaut ; beaucoup de gens ne le découvrent qu'en voyant un message inattendu « Task watchdog got triggered » dans le moniteur série. Comme l'ESP32 exécute plusieurs tâches en parallèle avec FreeRTOS, il utilise une structure en couches plutôt qu'un seul compteur. Le Task WDT (TWDT) vérifie que les tâches abonnées sont réarmées dans le délai ; l'Interrupt WDT (IWDT) détecte un blocage prolongé des interruptions et de l'ordonnanceur. Dans le noyau Arduino, le TWDT est généralement actif avec 5 secondes et surveille les tâches idle ; la tâche qui exécute loop() n'est pas surveillée tant que tu ne l'ajoutes pas. Le comportement par défaut varie selon la version du noyau et, dans certains réglages, le TWDT affiche seulement un avertissement sans redémarrer la carte ; le plus sûr est donc de régler explicitement la durée et le comportement de reset dans le code.

TypeCe qu'il surveilleDurée typiqueMessage affiché au déclenchement
Task WDT (TWDT)Exécution régulière des tâches abonnées et des tâches idle5 s (réglable)task_wdt: Task watchdog got triggered
Interrupt WDT (IWDT)Blocage des interruptions et de l'ordonnanceurEnviron 300 msGuru Meditation Error ... Interrupt wdt timeout on CPU1
RTC WDTBlocage du processus de démarrageCourte durée au démarragerst: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}

Le code vérifie la version du noyau avec ESP_ARDUINO_VERSION_MAJOR : en 3.x (ESP-IDF 5), les réglages se donnent par la structure esp_task_wdt_config_t et le TWDT déjà actif se met à jour avec esp_task_wdt_reconfigure() ; en 2.x, esp_task_wdt_init() prend directement la durée en secondes et l'indicateur de panique. Quand trigger_panic vaut true, l'ESP32 écrit le vidage d'erreur sur le port série puis redémarre à l'expiration du délai. esp_task_wdt_add(NULL) place sous surveillance la tâche en cours, c'est-à-dire celle qui exécute setup() et loop(). Lire et enregistrer la cause du reset précédent avec esp_reset_reason() au démarrage est le moyen le plus simple de comprendre pourquoi un appareil sur le terrain a redémarré. Si tu veux seulement surveiller loop() sans réglage, appelle enableLoopWDT() du noyau Arduino dans setup() ; le réarmement se fait alors automatiquement au début de chaque tour de loop().

L'erreur de watchdog la plus fréquente sur ESP32 est d'écrire dans ta propre tâche FreeRTOS une boucle qui n'attend jamais. Par exemple, si tu écris while (true) { sensoruOku(); } dans une tâche fixée au cœur 0, la tâche idle du même cœur ne peut jamais s'exécuter, la pile Wi-Fi se grippe et après quelques secondes le message « Task watchdog got triggered ... IDLE (CPU 0) » apparaît. Ajoute au moins vTaskDelay(1) ou delay(1) à chaque boucle. Les détails sur les tâches sont dans l'article ESP32 FreeRTOS et double cœur, et le sens des messages « Guru Meditation » dans ESP32 Brownout et Guru Meditation.

Watchdog sur Raspberry Pi Pico (MicroPython)

Le watchdog matériel du RP2040 s'utilise en MicroPython avec la classe machine.WDT. La durée se donne en millisecondes et ne peut pas dépasser 8388 ms sur le RP2040. Différence importante : sur le Pico, une fois démarré, le watchdog ne peut plus être arrêté par le code, seulement par un reset. C'est pourquoi prévoir une petite issue de secours pendant le développement peut te sauver la mise. Dans le code ci-dessous, si la broche GP15 est reliée à GND au démarrage, le watchdog n'est jamais lancé et le programme retombe dans le REPL. Avec machine.reset_cause(), tu peux aussi savoir si la carte a démarré à cause du watchdog ou par une mise sous tension normale. Si tu programmes le Pico avec l'IDE Arduino (noyau arduino-pico) plutôt qu'en MicroPython, le même travail se fait avec rp2040.wdt_begin(5000) et 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)
Dans Thonny, si tu interromps un programme avec watchdog via le bouton Stop, le watchdog continue de compter et en quelques secondes le Pico redémarre et la connexion saute. Essaie d'abord le code sous un nom de fichier autre que main.py ; quand tout va bien, enregistre-le en main.py. Si la carte entre en boucle, il suffit de relier GP15 à GND et de la réinitialiser. Si tu débutes en MicroPython, l'article Bases de MicroPython est un bon point de départ.

Stratégie de watchdog pour les projets IoT de longue durée

  • Enregistre les démarrages : à chaque démarrage, écris un compteur dans l'EEPROM sur Uno ou dans la mémoire Preferences (NVS) sur ESP32 ; sur ESP32, garde aussi la cause avec esp_reset_reason(). Un reset par semaine est acceptable, un reset par heure est un bug à corriger. Sur Uno, comme Optiboot efface les drapeaux de reset, lire la cause dans MCUSR est souvent impossible ; le compteur de démarrages montre quand même à quelle fréquence l'appareil redémarre.
  • Mets des délais maximaux aux opérations réseau : n'attends pas la connexion Wi-Fi indéfiniment ; par exemple, si elle n'aboutit pas en 15 secondes, sors de la boucle et réessaie plus tard. Des réglages comme setTimeout() de HTTPClient ou Wire.setWireTimeout() sur AVR empêchent une opération bloquée de dépasser la durée du watchdog. Pour les problèmes de connexion, lis l'article ESP32 ne se connecte pas au Wi-Fi.
  • Prends en compte la mise à jour OTA : le téléversement sans fil dure des secondes et loop() peut rester en attente pendant ce temps. En appelant esp_task_wdt_reset() dans le rappel onProgress d'ArduinoOTA, tu évites que la mise à jour soit interrompue en route ; c'est une exception rare mais justifiée à la règle.
  • Pense aux modes veille : sur Uno, le watchdog en mode interruption peut servir de minuterie de réveil pour dormir par intervalles de 8 secondes. Sur ESP32, le processeur est éteint pendant le deep sleep et le code repart de zéro au réveil. Pour les détails, consulte l'article ESP32 Deep Sleep.
  • Gère l'alimentation des capteurs externes : le watchdog ne réinitialise pas le capteur. Si tu alimentes un capteur I2C qui se bloque souvent via un transistor ou un MOSFET et que tu coupes puis rétablis son alimentation quelques centaines de millisecondes au démarrage, le capteur repart proprement avec le microcontrôleur. Tu peux lire comment la ligne I2C se bloque dans l'article Qu'est-ce que l'I2C.
  • Watchdog externe pour les systèmes critiques : le watchdog interne ne détecte que les défaillances du microcontrôleur lui-même. Pour surveiller tout le circuit, on utilise un circuit watchdog externe qui attend des impulsions régulières d'une GPIO, ou un second petit microcontrôleur.

Erreurs fréquentes et solutions

SymptômeCause probableSolution
La carte redémarre toutes les quelques secondesLa durée du watchdog est plus courte que le tour de loop() le plus long (ex. WDTO_2S avec delay(3000))Allonge la durée, utilise millis() au lieu de delay()
La LED clignote vite, le code ne se téléverse pasL'ancien bootloader ne désactive pas le watchdog après un reset watchdogÉcris Optiboot via ISP, programme la carte avec l'option de bootloader récent
La carte se bloque mais ne redémarre jamaisLe réarmement est dans une interruption de timer ou dans une sous-boucle bloquéeDéplace wdt_reset() en un seul point de loop()
Sur ESP32, « Task watchdog got triggered » se répète, sans resetLe TWDT n'est pas en mode paniqueMets trigger_panic à true (deuxième paramètre en 2.x)
Avertissement « IDLE (CPU 0) » sur ESP32Une tâche du cœur 0 tourne sans jamais attendreAjoute vTaskDelay(1) dans la boucle
esp_task_wdt_reset() renvoie l'erreur « task not found »La tâche n'a pas été ajoutée au TWDTAppelle d'abord esp_task_wdt_add(NULL)
Le Pico perd la connexion quand on l'arrête dans Thonnymachine.WDT ne peut plus s'arrêter une fois démarréUtilise une broche de secours, teste le code hors de main.py
Au moment du reset, un relais ou un moteur s'active brièvement par erreurPendant le reset, les broches repassent en entrée et l'entrée du driver flotteAjoute des résistances de pull-down aux sorties, mets-les en état sûr au début de setup()

Avec quelques lignes de code, le watchdog timer transforme ton projet d'un simple essai de bureau en un appareil capable de tourner seul pendant des jours. Élimine d'abord les vraies causes de blocage, ajoute ensuite le watchdog comme dernière couche de sécurité et place le réarmement en un point unique et pertinent. Dans l'application BlueGrays, tu peux étudier pas à pas, avec schémas et codes, des projets qui restent allumés longtemps comme la connexion Wi-Fi ESP32, le serveur web, la mise à jour OTA, la météo et l'arrosage intelligent, et y ajouter toi-même le watchdog.

Questions fréquentes

À quoi sert le watchdog timer d'Arduino ?

Le watchdog est une minuterie interne qui redémarre automatiquement la carte si le programme n'envoie pas son signal « je tourne toujours » dans le délai fixé. Il remet d'aplomb en quelques secondes les projets pris dans une boucle infinie, bloqués sur un capteur ou figés dans une bibliothèque réseau. Il est indispensable surtout pour les appareils d'arrosage, d'alarme et IoT qui fonctionnent longtemps sans surveillance.

Comment redémarrer un Arduino par code ?

Sur les cartes AVR, la façon la plus propre est d'activer le watchdog avec la durée la plus courte puis d'attendre : en écrivant wdt_enable(WDTO_15MS); while (true) {}, la carte subit très vite un vrai reset matériel. Sur ESP32, ESP.restart() fait la même chose, et sur Raspberry Pi Pico, machine.reset() en MicroPython. Sur les clones de Nano avec ancien bootloader, cette méthode peut provoquer une boucle de redémarrage infinie.

Quelle est la durée maximale du watchdog ?

Sur Arduino Uno et les autres cartes AVR, la durée maximale est de 8 secondes (WDTO_8S). Sur Raspberry Pi Pico, la limite est de 8388 ms, et sur le Task WDT de l'ESP32, la durée est librement réglable. Si tu as besoin d'une surveillance plus longue, tu peux fixer des limites de plusieurs minutes avec le réarmement conditionnel, qui ne nourrit le watchdog que lorsque le système est en bonne santé.

Comment corriger l'erreur ESP32 « Task watchdog got triggered » ?

Ce message indique qu'une tâche surveillée n'a pas été réarmée dans le délai ; la cause est le plus souvent une boucle while qui ne rend jamais la main ou une tâche FreeRTOS qui affame la tâche idle. Ajoute vTaskDelay(1) ou delay(1) dans tes boucles, découpe les longues opérations et, si tu as ajouté ta propre tâche au TWDT, appelle régulièrement esp_task_wdt_reset(). La tâche citée dans le message, par exemple IDLE (CPU 0), indique sur quel cœur se situe le problème.

J'ai ajouté un watchdog et mon Arduino redémarre sans arrêt. Pourquoi ?

La cause la plus fréquente est une durée de watchdog plus courte que le tour de loop() le plus long ; par exemple choisir WDTO_2S alors que la boucle contient delay(3000). Mets une durée d'au moins le double du tour le plus long et utilise millis() au lieu des longs delay(). Si la LED clignote vite et que le code ne se téléverse pas, le problème vient de l'ancien bootloader ; il faut écrire Optiboot sur la carte via ISP.

Les variables sont-elles conservées après un reset watchdog ?

Non, un reset watchdog redémarre la carte et setup() s'exécute depuis le début ; les variables globales reprennent leurs valeurs initiales. Les informations à conserver après le reset, comme un compteur, un réglage ou le dernier état, doivent être écrites dans l'EEPROM sur Uno, dans la mémoire Preferences (NVS) sur ESP32 ou dans un fichier en flash sur Pico.

Voir tous les projets
Clignotement LED avec ESP32
ES-1Débutant

Clignotement LED avec ESP32

Enseigne l'utilisation de base des sorties GPIO avec l'ESP32. Nous obtenons un effet de clignotement en allumant et éteignant une LED à partir de la broche numérique. Version ESP32 du projet blink classique sur Arduino UNO ; les commandes de base de blink dans l'environnement Arduino restent les mêmes, mais le brochage et les niveaux GPIO de 3,3 V de l'ESP32 diffèrent de ceux de l'Arduino UNO.

4.7(37)
108
Clignotement LED Intégrée Raspberry Pi Pico (Pico et Pico W)
PI-1Débutant

Clignotement LED Intégrée Raspberry Pi Pico (Pico et Pico W)

Le projet d'ouverture de la série Raspberry Pi Pico ! On fait clignoter la LED verte intégrée du Pico pour vérifier que la carte fonctionne : le classique premier essai façon "Hello World". Aucun composant externe, juste le Pico et un câble USB. Le code est écrit en MicroPython, le langage officiellement pris en charge par la Raspberry Pi Foundation.

5.0(1)
10
Connexion Wi-Fi STA ESP32 (avec écran LCD)
ES-25Avancé

Connexion Wi-Fi STA ESP32 (avec écran LCD)

Dans ce projet, nous connectons l'ESP32 au réseau Wi-Fi domestique en mode Station (STA) de manière sécurisée et tolérante aux pannes. Nous isolons SSID/mot de passe dans un fichier secrets.h pour empêcher leur fuite sur Git, mettons en place une reconnexion automatique, et affichons le niveau RSSI et l'adresse IP sur un écran LCD I2C. La LED intégrée sert d'indicateur d'état.

4.4(21)
38
Serveur Web asynchrone ESP32 (avec affichage de l'adresse IP sur l'écran LCD)
ES-27Avancé

Serveur Web asynchrone ESP32 (avec affichage de l'adresse IP sur l'écran LCD)

On transforme l'ESP32 en serveur web asynchrone que tu pilotes depuis ton téléphone ou ton ordinateur sur le même réseau Wi-Fi. Grâce à la bibliothèque ESPAsyncWebServer, le serveur traite plusieurs requêtes à la fois (il ne bloque pas sur une seule requête comme le WebServer.h classique). Ouvre l'adresse IP de l'ESP32 dans le navigateur et allume ou éteins la LED sur GPIO 5 avec les boutons ON/OFF (adresses /on et /off).

4.8(16)
26
Mise à jour OTA de l'ESP32 — Installation sans fil du firmware (avec écran LCD)
ES-30Avancé
Premium

Mise à jour OTA de l'ESP32 — Installation sans fil du firmware (avec écran LCD)

Tu vas apprendre à charger un nouveau firmware sur l'ESP32 par Wi-Fi, sans câble USB. Avec la bibliothèque ArduinoOTA, l'ESP32 devient visible sur le réseau et apparaît automatiquement sous le nom bluegrays-ota dans l'onglet "Network port" de l'Arduino IDE. Le premier téléversement se fait en USB, ensuite toutes les mises à jour passent sans fil, un atout clé pour les appareils installés sur le terrain.

4.6(14)
22
ESP32 HTTPClient + API météo (avec écran LCD)
ES-31Avancé
Premium

ESP32 HTTPClient + API météo (avec écran LCD)

L'ESP32 appelle par Internet une API météo (wttr.in) en REST avec HTTPClient.h. La réponse JSON est analysée avec ArduinoJson v7, puis la ville, la température, l'humidité, la météo et le vent s'affichent sur un LCD I2C. wttr.in ne demande aucune clé d'API : il suffit de taper le nom de n'importe quelle ville.

4.7(13)
20
Système d'Alarme de Mouvement ESP32 (PIR + Buzzer + LED + Telegram)
ES-41Avancé
Premium

Système d'Alarme de Mouvement ESP32 (PIR + Buzzer + LED + Telegram)

Une alarme de sécurité intelligente : quand le capteur PIR détecte un mouvement, le buzzer sonne, la LED s'allume et le propriétaire reçoit aussitôt une notification Telegram. Un délai de 30 secondes (cooldown) limite la répétition des alarmes ; il n'élimine pas les fausses détections du capteur PIR. À utiliser à la maison, au garage, dans une réserve ou un bureau.

9