Arduino redémarre tout seul ou plante : causes et solutions

Si ton Arduino redémarre tout seul ou se fige après avoir fonctionné un moment, la carte n'est presque jamais en panne. Dans la plupart des cas, c'est l'alimentation : quand un servo se met en mouvement, qu'un moteur démarre ou qu'un relais colle, l'appel de courant soudain fait s'effondrer la ligne 5 V pendant un instant et la protection contre les sous-tensions du processeur (brown-out) redémarre la carte. Dans les autres cas, les coupables sont les parasites des relais et des moteurs, les longs câbles, une RAM pleine, un watchdog oublié ou un port USB d'ordinateur qui ne fournit pas assez de courant.

Dans ce guide, tu vas d'abord apprendre à distinguer une carte qui redémarre vraiment d'une carte qui se fige. Nous expliquerons ensuite chaque cause avec de vraies valeurs de courant et de tension, puis nous montrerons les solutions avec du code : alimentation séparée et masse commune, condensateurs de 100 à 470 µF, diodes de roue libre, tampons fixes au lieu de String et watchdog. Tu trouveras aussi un sketch de diagnostic qui mesure la tension d'alimentation et la RAM libre de l'Arduino lui-même, un tableau pas à pas du symptôme à la solution et des exemples qui lisent la cause du redémarrage sur l'ESP32 et la Raspberry Pi Pico.

Redémarrage ou plantage ? Identifie d'abord le symptôme

Un Arduino qui redémarre exécute le programme depuis le tout début, comme si tu avais débranché puis rebranché le câble USB : setup() s'exécute à nouveau, le servo revient à son angle de départ, l'écran LCD réaffiche son texte d'accueil et le message de démarrage réapparaît dans le Moniteur série. Un Arduino figé, lui, ne réagit plus à rien ; les LED restent dans leur dernier état, la sortie série s'arrête et la carte reste ainsi jusqu'à ce que tu appuies sur le bouton reset. Comme les causes et les solutions sont différentes, commence par savoir lequel des deux tu as. Le plus simple est d'ajouter une ligne Serial.println("DEMARRAGE") dans setup() et de laisser le Moniteur série ouvert.

Pourquoi un Arduino redémarre-t-il tout seul ? Les sources de reset

Seules quelques sources peuvent redémarrer le processeur ATmega328P de l'Arduino Uno et du Nano, et chacune a son propre déclencheur. Quand la tension d'alimentation descend sous un certain seuil, le détecteur de brown-out (BOD) entre en action ; sur l'Uno et le Nano, les bits de configuration de la puce (fuses) fixent ce seuil à 2,7 V. Tout ce qui met la broche RESET à LOW redémarre aussi la carte : le bouton reset, le signal DTR de l'ordinateur ou les parasites captés par un long fil relié à cette broche. Il existe aussi un cas qui ressemble à un reset sans en être un : à cause d'une mémoire corrompue, le programme saute à l'adresse 0 et le code repart du début, mais comme les périphériques matériels ne sont pas réinitialisés, la carte se met à se comporter bizarrement.

Courant des servos, moteurs et relais : comment une chute de tension provoque un reset

Un servo SG90 consomme 100 à 250 mA en mouvement, mais au démarrage et quand son bras force, le courant grimpe au-dessus de 0,5 A. Le port USB 2.0 d'un ordinateur fournit au maximum 500 mA, et le fusible de la ligne USB de l'Uno travaille à la même limite. Quand le servo, les 50 mA de la carte elle-même et quelques modules dépassent cette limite, le port ou le fusible limite le courant, la ligne 5 V s'effondre un instant et, si la tension passe sous 2,7 V, le BOD redémarre la carte. Le cas le plus sournois est celui où la tension reste entre 2,7 V et environ 3,8 V : d'après la fiche technique de l'ATmega328P, il faut environ 3,8 V pour fonctionner de façon sûre à 16 MHz. Dans cette zone grise, le BOD ne se déclenche pas, mais le processeur tourne hors de sa limite de vitesse ; la carte peut alors se figer au lieu de redémarrer, renvoyer des valeurs absurdes, ou bien les écrans et capteurs I2C peuvent se bloquer.

Les câbles comptent aussi. Les fils de connexion fins utilisés sur une breadboard font en général 26 à 28 AWG, et un fil de cuivre de 28 AWG a une résistance d'environ 0,21 Ω par mètre. Si tu alimentes le servo avec deux fils de 20 cm (0,4 m aller-retour) en passant par une breadboard, les fils ajoutent environ 0,085 Ω et quatre contacts de la breadboard environ 0,2 Ω au total. D'après la loi d'Ohm (U = R × I), une pointe de 1 A du servo perd environ 0,3 V dans ces 0,29 Ω. Un câble USB fin et long, le fusible et les composants de protection de la carte ajoutent encore environ un demi-ohm ; pendant la même pointe, la ligne 5 V de l'Arduino descend sous 4,5 V, et si le port de l'ordinateur commence à limiter le courant, la chute est bien plus profonde. Tu peux calculer la chute dans ton propre circuit avec le calculateur de loi d'Ohm.

Solution 1 : alimentation séparée et masse commune

1. Choisis une alimentation séparée pour les servos et les moteurs : pour les servos, un adaptateur 5–6 V qui fournit au moins 1 A par servo (2 à 3 A pour un MG996R), un pack de 4 piles AA NiMH ou un module abaisseur LM2596 réglé sur 5–6 V.
2. Relie le plus de l'alimentation uniquement aux fils rouges des servos ou à l'entrée de puissance du pilote moteur ; ne relie pas cette ligne à la broche 5V de l'Arduino.
3. Relie le moins (GND) de l'alimentation à la fois à la charge et à la broche GND de l'Arduino. Sans cette masse commune, la tension de la broche de signal n'a pas de référence ; le servo tremble ou ne bouge pas du tout.
4. Réunis les GND en un seul point près de l'alimentation (masse en étoile). Le courant du moteur ne doit pas revenir à travers l'Arduino et ses pistes de masse ; sinon, la masse de l'Arduino bouge à chaque pointe du moteur.
5. Alimente l'Arduino par sa propre entrée : USB, prise jack DC (7–12 V) ou 5 V régulé. Ainsi, le processeur n'est pas touché même si l'alimentation des servos s'effondre.
6. Pour finir, mesure entre les broches 5V et GND de l'Arduino pendant que le servo bouge, ou lance le sketch de diagnostic plus bas ; la tension ne doit pas descendre sous 4,75 V.

Solution 2 : condensateur (100–470 µF) et diode

Un condensateur électrolytique agit comme une petite réserve d'énergie placée juste à côté de la charge : quand le servo réclame un courant soudain, il le fournit lui-même le temps que les fils et l'alimentation suivent. La formule ΔU = I × Δt / C indique à quel point il aide. Un condensateur de 470 µF ne laisse chuter la tension que de 0,21 V pendant une pointe de 1 A qui dure 100 µs ; si la même pointe dure 1 ms, la chute atteint 2,1 V. Autrement dit, le condensateur absorbe les pointes brèves et le bruit des balais des moteurs, mais il ne remplace pas une alimentation insuffisante. Mets 470 à 1000 µF sur la ligne des servos et 100 µF entre 5V et GND de l'Arduino, et ajoute à côté de chacun un condensateur céramique de 100 nF marqué 104 contre les parasites haute fréquence. Pour lire les marquages, utilise l'outil code des condensateurs, et pour additionner des condensateurs en parallèle le calculateur de réseau de condensateurs ; les différences entre les types sont expliquées dans Qu'est-ce qu'un condensateur ?.

Les bobines de relais, les moteurs et les solénoïdes sont des inductances. Quand le courant qui les traverse est coupé brusquement, la bobine s'oppose à ce changement et produit à ses bornes une courte pointe de tension de plusieurs dizaines, voire centaines de volts, bien au-dessus de la tension d'alimentation. Cette pointe se propage sur la ligne et redémarre l'Arduino ; elle peut aussi détruire le transistor de commande ou la broche. La solution est une diode de roue libre branchée en parallèle sur la bobine, en sens inverse : l'extrémité cathode d'une 1N4007, repérée par la bande, va au plus et l'autre au côté relié au transistor. Les modules relais intègrent déjà cette diode ; avec un relais nu, un solénoïde ou un moteur piloté par un transistor ou un MOSFET, tu dois l'ajouter toi-même. Pour les moteurs dont la vitesse est réglée en PWM, la diode Schottky 1N5819, plus rapide, donne de meilleurs résultats. Plus de détails dans Qu'est-ce qu'une diode ? et utiliser un MOSFET avec Arduino.

Parasites, contacts de relais et longs câbles

Si la carte redémarre exactement au moment où un relais retombe, le problème vient des parasites et non de l'alimentation. Quand un relais coupe une pompe à eau, un ventilateur, un tube fluorescent ou un contacteur, un petit arc se forme entre les contacts et cet arc rayonne des perturbations électromagnétiques à large bande. Ces parasites se couplent aux câbles des capteurs voisins, à la ligne RESET et aux lignes I2C, puis redémarrent le processeur ou bloquent un module. Pour l'éviter, utilise un module relais à optocoupleur, retire le cavalier JD-VCC et alimente les bobines des relais avec une source 5 V séparée ; le courant des bobines et les parasites restent ainsi loin de la ligne de l'Arduino. Avec des charges inductives sur le secteur, un snubber RC (100 Ω + 100 nF, classe X2) ou une varistance aux bornes des contacts ou de la charge atténue fortement l'arc. Tu trouveras le câblage détaillé dans Qu'est-ce qu'un module relais ? et le principe de l'isolation dans Qu'est-ce qu'un optocoupleur ?.

• I2C court : l'I2C a été conçu pour de courtes distances sur une carte. Garde les fils SDA et SCL sous 50 cm ; sur des liaisons plus longues, descends les résistances de pull-up de 4,7 kΩ à 2,2 kΩ et laisse la vitesse à 100 kHz.
• Fils torsadés : torsade chaque fil de signal avec un fil de masse ; les paires torsadées d'un câble réseau sont idéales pour cela.
• Sépare puissance et signal : ne fais pas courir les câbles des capteurs parallèlement à ceux des moteurs, des relais ou du secteur ; s'ils doivent se croiser, croise-les à angle droit.
• Laisse la broche RESET tranquille : un long fil sur la broche RESET se comporte comme une antenne et redémarre la carte quand on le touche ou quand un moteur proche tourne. Si tu as besoin d'un bouton reset externe, garde son fil court.
• Ferrites et boîtier : des tores de ferrite sur les câbles des moteurs et un boîtier métallique réduisent les parasites haute fréquence.
• Ajoute un délai d'attente : si les parasites bloquent le bus I2C, la bibliothèque Wire attend indéfiniment par défaut et la carte se fige. Le code ci-dessous évite ce blocage grâce à un délai d'attente.

1#include <Wire.h>
2
3const uint8_t ADDR = 0x27;   // örnek: I2C LCD adresi / example: I2C LCD address
4
5void setup() {
6  Serial.begin(9600);
7  Wire.begin();
8  Wire.setWireTimeout(25000, true);   // 25 ms; takılırsa I2C birimini sıfırla / reset the I2C unit on timeout
9}
10
11void loop() {
12  Wire.beginTransmission(ADDR);
13  byte err = Wire.endTransmission();  // 0 = cihaz cevap verdi / 0 = device answered
14
15  if (Wire.getWireTimeoutFlag()) {    // hat kilitlendi ama program donmadı / bus hung, sketch did not freeze
16    Serial.println(F("I2C zaman asimi / I2C timeout"));
17    Wire.clearWireTimeoutFlag();
18  } else if (err != 0) {
19    Serial.print(F("I2C hatasi / I2C error: "));
20    Serial.println(err);              // 2 = cihaz yok, 5 = zaman aşımı / 2 = no device, 5 = timeout
21  }
22  delay(1000);
23}

RAM saturée et utilisation de String

L'Arduino Uno n'a que 2 Ko de SRAM, et ce petit espace est partagé entre les variables globales, la mémoire dynamique (le tas) et la pile utilisée par les appels de fonctions. Si tu vois l'avertissement Low memory available, stability problems may occur. à la fin de la compilation, la carte finira très probablement par planter. La cause la plus sournoise est la classe String : chaque concaténation réserve un nouveau morceau sur le tas, l'ancien est libéré et, avec le temps, la mémoire se remplit de trous. Un jour, la pile rencontre le tas et le programme redémarre ou se fige à un moment aléatoire. Comme ce problème apparaît en général au bout de quelques minutes ou heures, il est facile à distinguer d'un souci d'alimentation. Garde les textes constants en flash avec la macro F(), utilise des tableaux de char de taille fixe et snprintf() au lieu de String, et ne déclare pas de grands tableaux locaux dans les fonctions. Le code ci-dessous affiche la RAM libre chaque seconde ; si la valeur ne cesse de baisser, il y a une fuite de mémoire. Tout le sujet est traité dans Arduino : mémoire insuffisante.

1extern int __heap_start, *__brkval;
2
3// Heap ile stack arasındaki boş RAM / free RAM between heap and stack
4int freeRam() {
5  int v;
6  return (int)&v - (__brkval == 0 ? (int)&__heap_start : (int)__brkval);
7}
8
9char line[32];             // sabit tampon, bir kez ayrılır / fixed buffer, allocated once
10unsigned long counter = 0;
11
12void setup() {
13  Serial.begin(9600);
14}
15
16void loop() {
17  counter++;
18  // Kaçın / avoid: String s = "Sayac: " + String(counter) + " sn";
19  snprintf(line, sizeof(line), "Sayac: %lu sn", counter);  // heap kullanmaz / no heap use
20  Serial.println(line);
21
22  Serial.print(F("Bos RAM / free RAM: "));  // F(): metin flaşta kalır / text stays in flash
23  Serial.println(freeRam());                // sürekli azalıyorsa sızıntı var / steady drop = leak
24  delay(1000);
25}

Watchdog : la ceinture de sécurité contre les plantages

Le watchdog (chien de garde) est un compteur interne au processeur qui fonctionne de façon indépendante avec son propre oscillateur de 128 kHz. Ton programme doit le relancer régulièrement avec wdt_reset() ; s'il ne le fait pas dans le délai choisi (entre 15 ms et 8 secondes), le watchdog redémarre la carte. Ainsi, un bus I2C bloqué, une fonction coincée dans une boucle infinie ou une lecture de capteur faussée par des parasites ne peuvent pas figer la carte pour toujours ; elle se rétablit en quelques secondes. N'oublie pas que le watchdog est une ceinture de sécurité, pas une réparation : il ne règle ni les problèmes d'alimentation ni ceux de mémoire, il permet seulement à un projet installé sur le terrain de repartir tout seul. Choisis un délai nettement plus long que l'opération la plus longue de ton code ; avec un delay(3000) dans le code, un watchdog de 2 secondes redémarrera la carte sans arrêt.

1#include <avr/wdt.h>
2
3const int LED_PIN = 13;
4
5void setup() {
6  MCUSR = 0;          // reset bayraklarını temizle / clear reset flags
7  wdt_disable();      // açılışta watchdog kapalı / watchdog off during startup
8  Serial.begin(9600);
9  pinMode(LED_PIN, OUTPUT);
10  Serial.println(F("Basladi / started"));
11  delay(500);
12  wdt_enable(WDTO_2S);  // 2 sn içinde beslenmezse reset / reset if not fed within 2 s
13}
14
15void loop() {
16  digitalWrite(LED_PIN, !digitalRead(LED_PIN));
17  delay(250);
18
19  // Seri Monitör'den 'x' gönder: takılmayı taklit eder / send 'x' to simulate a hang
20  if (Serial.available() && Serial.read() == 'x') {
21    Serial.println(F("Sonsuz donguye girildi / stuck in a loop"));
22    while (true) {}     // wdt_reset() yok: 2 sn sonra reset / no wdt_reset(): reset after 2 s
23  }
24
25  wdt_reset();          // her turda besle / feed it every loop
26}

Sketch de diagnostic : l'Arduino mesure lui-même sa tension et sa RAM

Un multimètre est trop lent pour voir des chutes de tension de quelques millisecondes. À la place, tu peux utiliser l'Arduino lui-même comme un instrument de mesure simple : le code ci-dessous mesure avec l'ADC la référence interne de 1,1 V de la puce et en déduit la tension d'alimentation environ 9000 fois par seconde, et affiche la valeur la plus basse de chaque seconde. Il incrémente aussi un compteur dans l'EEPROM à chaque démarrage, si bien que même si tu ouvres le Moniteur série plus tard, tu vois combien de fois la carte a redémarré. Comme charge de test, il fait bouger le servo branché sur D9 entre 0 et 180 degrés toutes les 2 secondes ; si tu as ton propre projet, tu peux ajouter la partie mesure à son code. Ouvre le Moniteur série à 115200 bauds.

1// Reset teşhis kodu (Uno, Nano) / reset diagnostic sketch (Uno, Nano)
2#include <EEPROM.h>
3#include <Servo.h>
4
5Servo servo;
6extern int __heap_start, *__brkval;
7
8int freeRam() {
9  int v;
10  return (int)&v - (__brkval == 0 ? (int)&__heap_start : (int)__brkval);
11}
12
13// Besleme gerilimini dahili 1,1 V referansla ölç / measure supply voltage against the internal 1.1 V reference
14long readVcc() {
15  ADMUX = _BV(REFS0) | _BV(MUX3) | _BV(MUX2) | _BV(MUX1);
16  ADCSRA |= _BV(ADSC);                  // ölçümü başlat / start a conversion
17  while (bit_is_set(ADCSRA, ADSC)) {}   // bitmesini bekle / wait until it is done
18  return 1125300L / ADC;                // 1100 mV × 1023 / okuma → mV / reading → mV
19}
20
21long minVcc = 9999;
22unsigned long lastPrint = 0, lastMove = 0;
23bool sideA = false;
24
25void setup() {
26  Serial.begin(115200);
27  uint16_t boots;
28  EEPROM.get(0, boots);                 // açılış sayacı / boot counter
29  if (boots == 0xFFFF) boots = 0;       // boş EEPROM / blank EEPROM
30  EEPROM.put(0, ++boots);
31  Serial.print(F("BASLADI / STARTED  acilis no / boot #"));
32  Serial.println(boots);
33
34  servo.attach(9);                      // test yükü: servo D9'da / test load: servo on D9
35  readVcc();                            // ilk ölçümü at / discard the first reading
36  delay(5);
37}
38
39void loop() {
40  long v = readVcc();                   // saniyede ~9000 ölçüm / ~9000 samples per second
41  if (v < minVcc) minVcc = v;
42
43  if (millis() - lastMove >= 2000) {    // 2 sn'de bir servoyu oynat / move the servo every 2 s
44    lastMove = millis();
45    sideA = !sideA;
46    servo.write(sideA ? 180 : 0);
47  }
48
49  if (millis() - lastPrint >= 1000) {
50    lastPrint = millis();
51    Serial.print(F("sn/s: "));
52    Serial.print(millis() / 1000);
53    Serial.print(F("  min Vcc (mV): "));
54    Serial.print(minVcc);
55    Serial.print(F("  bos RAM / free RAM: "));
56    Serial.println(freeRam());
57    minVcc = 9999;                      // her saniye sıfırla / reset every second
58  }
59}

Lis les résultats ainsi : sur un Uno en bonne santé alimenté par USB, la valeur minimale reste entre 4,6 et 5,1 V. Si elle descend sous 4,5 V à chaque mouvement du servo et que les resets coïncident avec ces moments, le problème vient de l'alimentation. Si le numéro de démarrage augmente alors que la tension reste stable, cherche du côté des parasites ou du logiciel ; si en plus la RAM libre ne cesse de baisser, tu as une fuite de mémoire. La référence interne de 1,1 V peut varier d'environ 10 % d'une puce à l'autre ; compare donc une fois la mesure avec un multimètre : si le multimètre affiche 4,95 V alors que le code indique 5,10 V, remplace la constante 1125300 par 1125300 × 4,95 / 5,10 ≈ 1092200. Une fois le diagnostic terminé, retire le compteur EEPROM du code ; les cellules de l'EEPROM supportent environ 100 000 écritures.

Tableau de diagnostic pas à pas : symptôme, cause, solution

Lis le tableau de haut en bas ; les premières lignes sont les causes les plus fréquentes. Ne change qu'une seule chose à la fois et relance le sketch de diagnostic. Si tu modifies trois choses en même temps, tu ne sauras pas laquelle a résolu le problème, et la même panne reviendra dans ton prochain projet.

Port USB trop faible et reset à l'ouverture du Moniteur série

Un port USB 2.0 fournit 500 mA et un port USB 3.0 900 mA ; mais comme le fusible USB de l'Uno limite à 500 mA, un port USB 3.0 ne t'apporte aucun courant supplémentaire. Un hub USB non alimenté partage le courant d'un seul port entre tous ses appareils, les prises en façade d'un PC perdent de la tension à cause de leurs fins câbles internes, et les portables sur batterie peuvent alimenter faiblement leurs ports en mode économie d'énergie. Branche la carte directement sur un port arrière avec un câble court et de bonne qualité. Il existe aussi un reset qui n'est pas une panne : l'Uno et le Nano se réinitialisent via le signal DTR quand le Moniteur série ou un programme Python ouvre le port, et c'est justement cette fonction qui permet le téléversement. Si tu communiques depuis Python, attends 2 secondes après l'ouverture du port (communication série entre Arduino et Python). Pour désactiver complètement ce reset, place un condensateur de 10 µF entre RESET et GND et retire-le pour téléverser. Les détails du port série sont dans Moniteur série Arduino.

L'ESP32 redémarre tout seul : lire la cause du reset

L'ESP32 est encore plus sensible aux mêmes problèmes, car il fonctionne en 3,3 V et consomme environ 240 mA lors des émissions Wi-Fi, davantage en pointes brèves ; Espressif recommande une alimentation capable de fournir au moins 500 mA. La bonne nouvelle, c'est que l'ESP32 te dit lui-même pourquoi il a redémarré. Le message Brownout detector was triggered dans le Moniteur série signale une chute de tension, et les lignes rst:0xf (RTCWDT_BROWN_OUT_RESET) ou Guru Meditation Error au démarrage indiquent la cause du reset. Le code ci-dessous lit cette même information avec esp_reset_reason() et la traduit en texte lisible. Sur l'ESP32, le bouton EN éteint et rallume complètement la puce ; un reset par ce bouton apparaît donc lui aussi comme une mise sous tension. Tous les messages et leurs solutions sont dans ESP32 : erreurs brownout et Guru Meditation.

1#include <esp_system.h>
2
3// Reset sebebini yazıya çevir / turn the reset reason into text
4const char* reasonText(esp_reset_reason_t r) {
5  switch (r) {
6    case ESP_RST_POWERON:   return "Guc acilisi ya da EN tusu / power-on or EN button";
7    case ESP_RST_SW:        return "Yazilimla (ESP.restart) / software restart";
8    case ESP_RST_PANIC:     return "Cokme (Guru Meditation) / panic";
9    case ESP_RST_INT_WDT:   return "Kesme watchdog'u / interrupt watchdog";
10    case ESP_RST_TASK_WDT:  return "Gorev watchdog'u / task watchdog";
11    case ESP_RST_WDT:       return "Diger watchdog / other watchdog";
12    case ESP_RST_DEEPSLEEP: return "Derin uykudan uyanma / deep sleep wake-up";
13    case ESP_RST_BROWNOUT:  return "Gerilim dusmesi (brownout) / brownout";
14    default:                return "Bilinmeyen / unknown";
15  }
16}
17
18void setup() {
19  Serial.begin(115200);
20  delay(500);
21  esp_reset_reason_t r = esp_reset_reason();
22  Serial.print("Reset nedeni / reset reason: ");
23  Serial.println(reasonText(r));
24}
25
26void loop() {
27  Serial.print("Calisma suresi / uptime (s): ");
28  Serial.println(millis() / 1000);
29  delay(5000);
30}

Raspberry Pi Pico : cause du reset et watchdog (MicroPython)

Grâce à son régulateur buck-boost, la Raspberry Pi Pico fonctionne avec n'importe quelle tension entre 1,8 et 5,5 V sur la broche VSYS ; elle supporte donc mieux les chutes de tension qu'un Arduino. Pourtant, si tu branches un servo sur la broche VBUS, qui porte le 5 V de l'USB, le courant est tiré directement du port de l'ordinateur et, si le port s'effondre, la Pico s'éteint aussi ; évite également de tirer plus de 300 mA au total sur la broche 3V3. La broche de reset de la Pico, RUN, est tirée vers le haut par une résistance interne d'environ 50 kΩ ; y brancher un long fil ouvre la porte aux parasites, exactement comme la broche RESET de l'Arduino. En MicroPython, machine.reset_cause() ne renvoie que deux valeurs sur la Pico : PWRON_RESET pour la mise sous tension ou la broche RUN, et WDT_RESET pour le watchdog ou machine.reset(). Le watchdog se règle au maximum à 8388 ms et ne peut plus être arrêté une fois lancé ; il continue de redémarrer la carte même si tu arrêtes le programme dans Thonny. C'est pourquoi il vaut mieux placer une attente de 3 secondes au début du code.

1import machine, time
2from machine import Pin
3
4time.sleep(3)   # Thonny durdurabilsin diye bekle / wait so Thonny can stop the script
5
6neden = machine.reset_cause()
7if neden == machine.WDT_RESET:
8    print("Watchdog ya da machine.reset() / watchdog or machine.reset()")
9else:
10    print("Guc acilisi ya da RUN pini / power-on or RUN pin")
11
12led = Pin("LED", Pin.OUT)          # Pico ve Pico W dahili LED / onboard LED
13wdt = machine.WDT(timeout=5000)    # 5 sn; RP2040'ta en fazla 8388 ms / max 8388 ms on RP2040
14
15sayac = 0
16while True:
17    led.toggle()
18    sayac += 1
19    print("Calisiyor / running", sayac)
20    wdt.feed()                     # her turda besle / feed it every loop
21    time.sleep(1)

La bonne alimentation selon ton projet

• Voiture robot : alimente les moteurs avec un pack 2S 18650 via un L298N ou un L9110S et place un condensateur de 100 nF aux bornes de chaque moteur ; le montage est décrit dans fabriquer une voiture robot Arduino.
• Bras robotique à servos : pour quatre servos ou plus, utilise une alimentation 5–6 V qui fournit au moins 3 à 5 A et ajoute 1000 µF sur la ligne des servos ; pour le choix des composants, vois servo MG996R et bras robotique Arduino.
• Arrosage avec pompe et relais : alimente la pompe séparément, isole le relais avec JD-VCC et éloigne les longs câbles des capteurs du câble de la pompe (capteur d'humidité du sol).
• Rubans LED et NeoPixel : compte environ 2 A pour 30 LED, place 1000 µF à l'entrée du ruban et une résistance de 300 à 500 Ω sur la ligne de données (WS2812B NeoPixel).
• Commande de moteurs à courant continu : n'oublie pas la diode de roue libre sur chaque moteur piloté par un transistor ou un MOSFET ; pour les cartes de pilotage toutes faites, vois piloter un moteur à courant continu avec le L298N.
• Station de capteurs en extérieur : active le watchdog, règle un délai d'attente I2C et alimente l'ensemble avec une source efficace comme l'abaisseur de tension LM2596.

Un Arduino qui redémarre tout seul, c'est agaçant, mais il y a presque toujours une cause mesurable et réparable : identifie d'abord le symptôme, mesure ensuite la tension et la RAM avec le sketch de diagnostic, puis sépare l'alimentation, relie les masses, ajoute le condensateur et la diode et, si besoin, sécurise le projet avec le watchdog. Une fois ce montage en place, tes projets avec servos, moteurs et relais tourneront des jours sans souci. Dans l'application BlueGrays, tu trouveras la commande de servomoteurs, une voiture Bluetooth avec L298N, un robot qui évite les obstacles, la commande d'une lampe 230 V et une station d'arrosage intelligente, avec des schémas qui montrent les bons branchements d'alimentation et du code pas à pas.