Arduino grillé ? Symptômes, diagnostic et solutions de réparation

« Mon Arduino est-il grillé ? » est une question que presque tout passionné d'électronique se pose un jour : un fil touche au mauvais endroit, un moteur est branché, et la carte se tait d'un coup. Bonne nouvelle : dans la plupart des cas, la carte n'est pas entièrement morte. Un Arduino Uno se compose de plusieurs parties distinctes : la liaison USB et son fusible, le régulateur de tension, la puce de conversion USB-série et le microcontrôleur principal, l'ATmega328P. Quand l'une d'elles lâche, les autres survivent souvent, et avec un bon diagnostic, sauver la carte prend parfois deux minutes.

Dans ce guide, tu vas apprendre à bien interpréter les symptômes et à isoler la carte pas à pas jusqu'à trouver la partie en panne. Nous suivrons un ordre précis : alimentation par Vin, contrôle du polyfuse et du régulateur au multimètre, repérage d'une puce chaude, test de la puce USB en boucle (loopback) et deux programmes Arduino qui testent les broches une à une. Ensuite, nous regraverons un bootloader corrompu avec un second Arduino, remplacerons l'ATmega328P si besoin et résumerons les règles à suivre pour ne plus jamais griller de carte. Le côté logiciel des erreurs de téléversement est traité à part dans Arduino : le téléversement échoue.

Arduino grillé ? Premiers symptômes et leur signification

Avant de commencer le diagnostic, écoute ce que la carte te dit. La LED verte ON indique si le rail 5 V est alimenté, la LED L (D13) si le microcontrôleur et le bootloader fonctionnent, et les LED TX/RX si la puce USB-série transmet des données. Le tableau résume les symptômes les plus courants et où regarder en premier.

Étape 1 : premier contrôle avec les yeux, le nez et un câble

1. Examine la carte sous une bonne lumière : tu cherches une puce noircie ou bombée, un boîtier fissuré, de la soudure fondue ou une piste carbonisée. Regarde surtout autour du régulateur, du polyfuse et de la puce USB.
2. Sens la carte. L'électronique brûlée laisse une odeur forte et reconnaissable, généralement plus intense autour de la pièce en panne.
3. Vérifie le dessous de la carte. Un bureau métallique, un bout de fil ou une mousse conductrice peut relier les soudures et provoquer un court-circuit.
4. Essaie un autre câble USB et un autre port USB. Certains câbles bon marché n'ont que les fils d'alimentation et ne transmettent pas de données : c'est la cause la plus fréquente d'une carte qui paraît morte.
5. Note si l'ordinateur émet le son de connexion USB quand tu branches la carte et si la LED ON s'allume ; la suite dépend de ces deux observations.

Le chemin d'alimentation de l'Arduino Uno : quelle pièce alimente quoi ?

Le moyen le plus rapide de trouver une panne est de connaître le chemin du courant sur la carte. Les 5 V de l'USB passent d'abord par un polyfuse de 500 mA (un fusible réarmable), puis par un petit MOSFET canal P, avant d'atteindre le rail 5 V. La tension du jack passe d'abord par une diode qui protège contre l'inversion de polarité, arrive sur la ligne VIN et est abaissée à 5 V par le régulateur NCP1117. Quand VIN dépasse environ 6,6 V, un comparateur coupe le MOSFET côté USB, si bien que les deux sources ne se gênent jamais. Le 3,3 V est produit à partir du rail 5 V par un petit régulateur LP2985. La LED ON, la puce USB-série (un ATmega16U2 sur les cartes d'origine, souvent un CH340 sur les clones) et l'ATmega328P sont tous alimentés par ce rail 5 V.

Étape 2 : LED ON éteinte ? Teste par USB puis par Vin

Alimente la carte une fois par USB et une fois avec un adaptateur 9 V sur le jack (ou 7 à 12 V sur la broche Vin), et observe la LED ON à chaque fois. Comme les deux chemins n'ont en commun que le rail 5 V, cette simple comparaison localise déjà bien la panne. Si le polyfuse s'est déclenché à cause d'une surintensité, laisse la carte hors tension quelques minutes pour qu'il se réarme ; si le court-circuit persiste, il se déclenchera de nouveau au rebranchement. Les options de piles et d'adaptateurs sont détaillées dans alimenter un Arduino sur piles.

Étape 3 : court-circuit, polyfuse et régulateur au multimètre

1. Test de court-circuit (carte hors tension) : Mets le multimètre en ohmmètre ou en continuité et touche les broches 5V et GND avec les pointes. Il est normal que la valeur parte basse et monte à mesure que les condensateurs se chargent ; un bip continu ou une valeur qui reste sous quelques ohms signale un court-circuit.
2. Test du polyfuse (USB branché) : En tension continue, place la pointe noire sur GND et mesure tour à tour les deux côtés du polyfuse. Tu dois trouver environ 5 V des deux côtés ; 5 V d'un côté et presque zéro de l'autre signifie que le polyfuse est ouvert.
3. Test du régulateur (9 V sur le jack) : Tu dois mesurer environ 8,3 V sur la patte d'entrée du NCP1117 (0,7 V chutent dans la diode) et 5,0 V sur sa sortie.
4. Test du 3,3 V : Entre la broche 3V3 et GND, tu dois mesurer 3,2 à 3,4 V.
5. Fais les mesures dans cet ordre ; chaque étape change le sens de la suivante. Les calibres du multimètre et la mesure en sécurité sont expliqués dans comment utiliser un multimètre.

Étape 4 : trouver la puce qui chauffe

S'il y a un court-circuit sur le rail 5 V, la pièce en court-circuit absorbe l'essentiel du courant et chauffe en quelques secondes. Branche la carte en USB, attends 3 à 5 secondes, débranche-la et touche brièvement du bout du doigt l'ATmega328P, la puce USB et le régulateur, l'un après l'autre. Si une pièce est trop chaude pour être touchée, le court-circuit est là. Si l'ATmega328P chauffe, l'une de ses broches a généralement reçu plus de 5 V ; si c'est la puce USB, le problème est côté USB ; si c'est le régulateur, soit il est défectueux, soit une charge sur le rail 5 V tire trop de courant. Ne laisse pas la carte longtemps sous tension pendant ce test, sinon les pièces saines risquent d'être abîmées elles aussi.

Étape 5 : tester la puce USB quand le port n'apparaît pas

Si la LED ON s'allume mais que l'ordinateur ne voit pas la carte, écarte d'abord le côté logiciel : installe le pilote de la puce CH340 sur les clones, puis regarde sous Windows dans le Gestionnaire de périphériques, rubrique « Ports (COM et LPT) », ou sous macOS et Linux les périphériques /dev/cu.* ou /dev/ttyUSB*. Si le périphérique n'apparaît pas du tout ou s'affiche comme inconnu, il est temps de tester la puce USB-série elle-même. Le test en boucle (loopback) met l'ATmega328P hors jeu et renvoie à la puce USB les données qu'elle émet : tu sais ainsi si le problème vient de la puce USB ou du microcontrôleur.

1. Coupe l'alimentation de la carte et relie la broche RESET au GND avec un fil. L'ATmega328P reste ainsi en reset et libère les lignes TX/RX.
2. Relie les broches D0 (RX) et D1 (TX) entre elles avec un second fil.
3. Branche la carte en USB, choisis le port dans l'IDE Arduino et ouvre le moniteur série (la vitesse importe peu).
4. Tape un texte et clique sur Envoyer. S'il revient à l'identique et que les LED TX/RX clignotent, la puce USB va bien ; le problème vient de l'ATmega328P ou du bootloader.
5. Si le texte ne revient pas et que le port n'apparaît pas non plus, la puce USB ou la prise USB est abîmée. Tu peux alors encore programmer la carte avec un convertisseur USB-TTL externe ou un programmateur ISP.

Étape 6 : tester les broches grillées

Si la carte accepte le code mais que ton projet se comporte bizarrement, une seule broche est peut-être grillée. Brancher sur une broche un moteur, une bobine de relais ou une LED sans résistance, court-circuiter deux sorties ou appliquer plus de 5 V à une broche peut tuer cette seule broche alors que le reste de l'ATmega328P continue de fonctionner. Le premier programme ci-dessous configure chaque broche en entrée avec pull-up interne : une broche saine doit lire HIGH quand elle est libre. Ensuite, tu relies un bout de fil au GND et tu touches les broches une à une avec l'autre bout ; à chaque contact, le moniteur série doit montrer cette broche passer à LOW.

1// Arduino Uno giriş testi / input test (D0 ve D1 seri port için hariç / D0 and D1 skipped for serial)
2const byte PINS[] = {2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, A0, A1, A2, A3, A4, A5};
3const byte COUNT = sizeof(PINS);
4bool lastState[COUNT];
5
6void printPin(byte p) {
7  if (p >= A0) {
8    Serial.print('A');
9    Serial.print(p - A0);
10  } else {
11    Serial.print('D');
12    Serial.print(p);
13  }
14}
15
16void setup() {
17  Serial.begin(9600);
18  for (byte i = 0; i < COUNT; i++) pinMode(PINS[i], INPUT_PULLUP);   // dahili pull-up açık / internal pull-up on
19  delay(10);
20  Serial.println(F("1) Bos pin testi / free pin test:"));
21  for (byte i = 0; i < COUNT; i++) {
22    lastState[i] = digitalRead(PINS[i]);
23    printPin(PINS[i]);
24    Serial.println(lastState[i] ? F("  HIGH  tamam / ok") : F("  LOW   SUPHELI / suspect"));
25  }
26  Serial.println(F("2) GND'ye bagli kabloyla pinlere sirayla dokun / touch each pin with a GND wire"));
27}
28
29void loop() {
30  for (byte i = 0; i < COUNT; i++) {
31    bool v = digitalRead(PINS[i]);
32    if (v != lastState[i]) {                 // durum değişti / state changed
33      lastState[i] = v;
34      printPin(PINS[i]);
35      Serial.println(v ? F("  birakildi / released") : F("  GND algilandi / GND detected"));
36    }
37  }
38  delay(20);
39}

Une broche qui lit LOW quand elle est libre ou ne change pas du tout quand on la touche avec le GND est suspecte : son étage d'entrée est en court-circuit ou coupé. Sur certaines cartes clones, la LED L est reliée directement à D13, si bien que D13 peut lire LOW à vide ; ce n'est pas une panne. Le second programme teste l'étage de sortie : toutes les broches passent à HIGH puis à LOW une fois par seconde. Relie la cathode d'une LED au GND et son anode à une résistance de 220 Ω, puis touche les broches une à une avec l'autre extrémité de la résistance : la LED clignote sur chaque broche saine ; la bonne valeur de résistance se trouve avec le calculateur de résistance pour LED. Au multimètre, tu dois voir environ 5 V à l'état HIGH ; une broche qui n'allume jamais la LED, l'allume faiblement ou reste bien en dessous de 4 V est abîmée.

1// Arduino Uno çıkış testi / output test: bütün pinler 1 sn HIGH, 1 sn LOW / all pins 1 s HIGH, 1 s LOW
2const byte PINS[] = {2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, A0, A1, A2, A3, A4, A5};
3const byte COUNT = sizeof(PINS);
4
5void setAll(bool level) {
6  for (byte i = 0; i < COUNT; i++) digitalWrite(PINS[i], level);
7}
8
9void setup() {
10  Serial.begin(9600);
11  for (byte i = 0; i < COUNT; i++) pinMode(PINS[i], OUTPUT);
12  Serial.println(F("LED + 220 ohm probuyla pinlere dokun / touch the pins with an LED + 220 ohm probe"));
13}
14
15void loop() {
16  setAll(HIGH);
17  Serial.println(F("HIGH (~5 V)"));
18  delay(1000);
19  setAll(LOW);
20  Serial.println(F("LOW (0 V)"));
21  delay(1000);
22}

Pendant que ce programme tourne, rien d'autre ne doit être branché sur les broches, car toutes sont pilotées en sortie. Pour tester aussi les entrées analogiques, relie A0 tour à tour au GND, au 3V3 et au 5V et lis-la avec analogRead() : tu dois voir environ 0, 675 et 1023. La liste complète des broches et le rôle de chacune se trouvent dans brochage de l'Arduino Uno, et les schémas de cartes dans l'outil de brochage.

Regraver le bootloader : Arduino as ISP

Si l'alimentation va bien et que le test en boucle réussit, mais que la LED L ne clignote pas au reset et que chaque téléversement finit par l'erreur « avrdude: stk500_getsync(): not in sync », le bootloader a peut-être été effacé ou corrompu. Le bootloader est le petit programme qui permet de téléverser par USB, et on peut le réécrire par ISP (programmation in situ). Inutile d'acheter un programmateur : un second Arduino Uno en bon état devient programmateur grâce à l'exemple ArduinoISP. La liaison ISP utilise les broches SPI ; tu peux aussi utiliser le connecteur ICSP à 6 broches de la carte cible.

1. Branche l'Uno sain à l'ordinateur, ouvre Fichier > Exemples > 11.ArduinoISP > ArduinoISP et téléverse-le dans cette carte.
2. Débranche-le de l'ordinateur, relie les deux cartes selon le tableau ci-dessus et place le condensateur de 10 µF entre les broches RESET et GND de l'Uno programmateur.
3. Rebranche le programmateur en USB. Dans le menu Outils, choisis Arduino Uno comme carte et le port du programmateur.
4. Dans Outils > Programmateur, choisis Arduino as ISP. L'option au nom proche « ArduinoISP » sert à un programmateur USB séparé : ne la prends pas.
5. Lance Outils > Graver la séquence d'initialisation (Burn Bootloader). Cela prend quelques secondes et se termine par « Done burning bootloader ».
6. Retire les fils, branche la carte cible par son propre USB et téléverse l'exemple Blink. Si la LED L clignote de nouveau brièvement au reset, la carte est sauvée.

Si l'opération échoue, le message de signature d'avrdude en dit long. « Device signature = 0x000000 » ou « 0xffffff » signifie que le programmateur n'arrive pas du tout à dialoguer avec la puce cible : vérifie le câblage, le condensateur de 10 µF et que la cible reçoit bien 5 V ; si tout est correct, l'ATmega328P est très probablement mort. Une signature 1E 95 0F indique une puce ATmega328P et une liaison fonctionnelle. Si tu vois 1E 95 14, ta puce est un ATmega328 sans « P » et il te faut la bonne définition de carte pour elle.

Remplacer l'ATmega328P

Sur l'Arduino Uno R3 d'origine et sur beaucoup de clones, l'ATmega328P est en boîtier DIP 28 broches monté sur un support : il se remplace donc sans soudure. Si le microcontrôleur chauffe, si sa signature est illisible ou si la plupart de ses broches sont mortes, c'est la solution la plus économique. Si le court-circuit disparaît aussi quand tu retires la puce (la LED ON se rallume et la carte reste froide), la panne vient bien de la puce. À l'achat, choisir un ATmega328P-PU avec le bootloader de l'Uno déjà gravé simplifie les choses ; si tu as acheté une puce vierge, tu peux graver le bootloader toi-même avec la méthode Arduino as ISP vue plus haut. Sur les cartes comme la Nano et l'Uno CMS, la puce est soudée ; la remplacer demande une station à air chaud et de l'expérience.

1. Coupe l'alimentation de la carte et photographie l'orientation de l'encoche de la puce (côté broche 1).
2. Glisse un petit tournevis plat entre la puce et le support et soulève la puce petit à petit en alternant les deux extrémités ; si tu forces d'un seul côté, les pattes se tordent.
3. Les pattes d'une puce neuve sont généralement un peu écartées. Pose la puce sur le côté contre une table plane et appuie pour rentrer légèrement les deux rangées en même temps.
4. Aligne la puce sur le support avec l'encoche dans le même sens que l'ancienne, vérifie que toutes les pattes sont dans leurs trous, puis enfonce-la de façon uniforme.
5. Branche la carte en USB, vérifie que la LED L clignote au reset et termine le test en téléversant l'exemple Blink.

Notes rapides pour l'ESP32 et le Raspberry Pi Pico

La même logique vaut pour les autres cartes ; seules les pièces changent. Les cartes de développement ESP32 ont un régulateur de type AMS1117 qui abaisse le 5 V à 3,3 V et une puce USB CP2102 ou CH340 ; si le régulateur chauffe, cherche un court-circuit sur le rail 3,3 V. Les broches de l'ESP32 ne tolèrent pas le 5 V : la panne la plus courante est d'appliquer 5 V sur une broche. L'erreur « Failed to connect » au téléversement n'est souvent pas une panne, mais un cas où il faut maintenir le bouton BOOT ; les détails sont dans Arduino : le téléversement échoue. Sur le Raspberry Pi Pico, le test le plus rapide consiste à le brancher en USB en maintenant BOOTSEL : si un lecteur nommé RPI-RP2 apparaît, le RP2040 et la liaison USB vont bien. Les broches de la Pico ne tolèrent pas non plus le 5 V, et tu dois mesurer environ 3,3 V sur la broche 3V3(OUT).

10 règles pour ne pas griller ton Arduino

• 20 mA par broche : Ne tire pas plus de 20 mA d'une broche ; la limite absolue est de 40 mA et l'ensemble des broches ne doit pas dépasser 200 mA.
• Toujours une résistance avec une LED : Une LED sans résistance fatigue la broche et la LED ; en 5 V, 220 à 330 Ω suffisent.
• Jamais plus de 5 V sur une broche : La tension d'une entrée ne doit pas dépasser l'alimentation de plus de 0,5 V ; un signal de 12 V tue une broche instantanément.
• Moteurs, relais et pompes jamais en direct sur une broche : Utilise un transistor ou un MOSFET et une diode de roue libre ; un exemple de montage figure dans le guide de la mini pompe à eau.
• 7 à 12 V sur Vin : C'est la plage recommandée ; au-delà de 12 V le régulateur chauffe, au-delà de 20 V la limite est dépassée.
• N'inverse jamais l'alimentation sur la broche Vin : La diode de protection du jack ne protège pas ce qui entre par la broche Vin ; inverser plus et moins grille la carte.
• Pas plus de 50 mA sur la broche 3V3 : Pour un module Wi-Fi ou un grand écran, utilise un régulateur 3,3 V séparé.
• Coupe le courant pour recâbler : Brancher et débrancher des fils sur un circuit sous tension est la cause la plus fréquente de courts-circuits passagers.
• Ne pose pas la carte sur du métal : Les soudures du dessous se court-circuitent au contact d'un bureau métallique, d'un outil ou d'un bout de fil ; utilise des pieds en plastique ou un boîtier.
• Masse commune, alimentation séparée : Relie les masses des charges alimentées de l'extérieur, mais ne fais pas passer de forts courants par la carte.

Avant de déclarer ton Arduino mort, trouver quelle partie s'est tue sauve souvent la carte : la LED ON contrôle le chemin d'alimentation, le test en boucle la puce USB, la LED L au reset le bootloader, et les programmes de test chaque patte de l'ATmega328P une par une. Le bootloader se regrave, une puce sur support se change en quelques minutes et, avec les règles ci-dessus, ta prochaine carte vivra longtemps. Pour voir ta carte refonctionner correctement, essaie dans l'application BlueGrays les projets Allumer une LED, Feu tricolore, LED commandée par bouton et Voltmètre numérique avec LCD, avec schémas et code pas à pas.