Mon projet Arduino ne fonctionne pas : diagnostic en 10 minutes

Si ton projet Arduino ne fonctionne pas, ne cherche pas la panne en débranchant et rebranchant des fils au hasard. Avance de l'extérieur vers l'intérieur : d'abord l'alimentation (la carte s'allume-t-elle ?), puis le téléversement (le code est-il vraiment arrivé sur la carte ?), puis le câblage (la masse GND est-elle commune, chaque fil est-il sur la bonne broche ?), puis le sens et la valeur des composants (la LED est-elle à l'envers, la résistance est-elle la bonne ?), puis le code (numéros de broches et logique) et enfin le capteur et l'environnement (lumière, distance, tension d'alimentation). Fais un seul test par couche et ne change qu'une chose à la fois. En suivant cet ordre, tu trouveras la plupart des pannes en 10 minutes, car les erreurs les plus fréquentes se trouvent dans les couches extérieures, et ce sont les moins coûteuses à vérifier.

Cet article ne dresse pas la liste des messages d'erreur un par un : il te donne une méthode de diagnostic. Tu verras d'abord les deux règles de la méthode, puis un tableau de déroulement avec le symptôme, un test d'une minute et la cause probable pour chaque couche. Viennent ensuite un court programme de test qui découpe le circuit en morceaux grâce à Blink et au moniteur série, 4 mesures au multimètre (et leurs équivalents avec une LED et le moniteur série si tu n'en as pas), le diagnostic pas à pas d'une panne dans un projet gratuit de BlueGrays, un tableau rapide par symptôme et une fiche de diagnostic en 8 points pour la classe.

Les deux règles du diagnostic : de l'extérieur vers l'intérieur, une seule variable

La logique est simple : les couches intérieures dépendent des couches extérieures. Si la carte n'est pas alimentée, peu importe que le code soit juste ; si le code n'est jamais arrivé sur la carte, corriger le câblage ne change rien. Les couches extérieures sont aussi les plus rapides à vérifier : regarder le voyant d'alimentation prend 5 secondes et lire le message de téléversement 10, alors que trouver une erreur de logique dans le code peut prendre plusieurs minutes. La deuxième règle est celle de la variable unique. Si tu changes en même temps le fil, la résistance et le seuil dans le code, tu ne sauras pas ce qui a réglé le problème même si le projet se met à fonctionner ; et s'il ne fonctionne pas, tu as peut-être ajouté une nouvelle panne. Fais un changement, teste, note le résultat, puis passe au suivant.

• Écris le symptôme en une phrase : « Quand je couvre la LDR avec ma main, je m'attends à ce que la LED s'allume, mais elle ne s'allume jamais. » « Ça ne marche pas » n'est pas un symptôme ; en écrivant séparément ce que tu attendais et ce qui se passe, la couche à vérifier devient souvent évidente.
• Débranche l'USB pendant le câblage : si la carte reste alimentée pendant que tu changes les connexions, un mauvais contact peut provoquer un court-circuit. Fais la modification, vérifie à l'œil, puis rebranche.
• Remplace par une pièce qui marche à coup sûr : remplacer la LED, le fil ou le capteur suspect par un exemplaire dont tu sais qu'il fonctionne est le test le plus efficace sans appareil de mesure.
• Prends des notes : de courtes notes comme « fil passé de 7 à 8, aucun changement » t'évitent de refaire le même test et forment un résumé tout prêt si tu poses la question sur un forum ou à ton enseignant.
• Simplifie : si le projet est gros, retire les modules un par un. D'abord la carte seule, puis la carte avec la partie sortie, puis la partie entrée. Voir quelle pièce fait tout tomber en panne t'indique où se trouve le défaut.

Le tableau de diagnostic en 10 minutes

Lis le tableau de haut en bas et ne descends à la couche suivante qu'une fois le test de la couche actuelle réussi. Chaque test prend environ une minute, donc les six couches sont terminées en 6 à 10 minutes. Pour la plupart des tests, tes yeux, les voyants de la carte et le moniteur série de l'Arduino IDE suffisent ; un multimètre accélère les choses mais n'est pas obligatoire. La colonne « Cause probable » indique les premiers endroits à regarder quand un test échoue, à peu près par ordre de fréquence.

Couches 1 et 2 : alimentation et téléversement

Sur une Arduino Uno, deux voyants donnent le premier indice pour ces deux couches. Le voyant ON montre que la carte est alimentée ; s'il est éteint, change d'abord le câble USB, car certains câbles ne servent qu'à charger et ne transportent pas de données. Si ON est allumé mais que le son USB de ton ordinateur se coupe au branchement ou que le voyant clignote, il y a peut-être un court-circuit dans le montage : débranche l'USB, suis les lignes 5V et GND et cherche un module branché à l'envers ou un fil qui relie les deux rails. Un composant qui chauffe est toujours un signal sérieux ; ne réalimente pas la carte avant de l'avoir retiré. Si tu utilises un moteur, un servo ou un relais, le courant de l'USB peut ne pas suffire ; le symptôme n'est alors généralement pas « rien ne marche », mais des redémarrages aléatoires ou des tremblements. Pour les piles et les adaptateurs, consulte alimenter une Arduino sur piles.

Dans la couche téléversement, tu cherches la réponse à une seule question : le code présent sur la carte est-il celui que tu vois à l'écran ? À la fin du téléversement, l'Arduino IDE l'indique dans la zone de sortie en bas ; s'il y a des lignes rouges, le code n'est jamais arrivé sur la carte et celle-ci continue d'exécuter son ancien programme. C'est un piège, car tu croiras que ta correction n'a pas marché. Pour les erreurs avrdude, de port et de pilote, le code Arduino ne se téléverse pas explique chaque message, et si tu bloques à la compilation, consulte les erreurs de compilation. Il existe aussi un test de preuve simple : change un délai du code de 100 à 1000 et téléverse. Si le rythme de la LED ne change pas, le problème vient du téléversement. Certaines cartes ESP32 demandent de maintenir le bouton BOOT pendant le téléversement ; sur une Raspberry Pi Pico, vérifie que l'interpréteur MicroPython est sélectionné en bas à droite de Thonny.

Couche 3 : câblage, masse et broches

La carte est alimentée et le code téléversé : place aux fils. Les deux erreurs les plus fréquentes sont l'oubli de la masse commune et une mauvaise lecture de la plaque d'essai. Même si un capteur ou un module a sa propre alimentation, sa GND doit être reliée à celle de l'Arduino, sinon la tension du signal n'a pas de référence. Sur la plaque d'essai, la rainure centrale sépare les deux moitiés, et sur les grandes plaques les rails d'alimentation des bords peuvent être coupés au milieu ; alimenter une moitié de rail en 5V en pensant alimenter un composant de l'autre moitié est une erreur très courante. La meilleure méthode pour cette couche est la comparaison point par point avec le schéma : compte chaque fil avec ses deux extrémités et montre du doigt son équivalent sur le schéma. Le numérique 2 confondu avec l'analogique A2, 5V confondu avec VIN ou un fil décalé d'une rangée apparaissent tout de suite. Si les symboles te sont peu familiers, lire un schéma électronique explique pas à pas comment le reporter sur la plaque d'essai.

Couche 4 : sens et valeur des composants

Si le câblage est bon mais qu'un composant ne réagit toujours pas, regarde le composant lui-même. La patte longue de la LED (anode) va à la broche à travers la résistance et la patte courte (cathode) à GND ; une LED à l'envers n'est généralement pas abîmée, elle reste simplement éteinte. Les résistances sont les pièces que l'on confond le plus : 220 Ω a les anneaux rouge-rouge-marron, 10 kΩ marron-noir-orange. Avec 10 kΩ à côté d'une LED, elle brille si faiblement que tu ne le remarqueras pas ; avec 220 Ω à côté d'une LDR ou d'un bouton, les lectures n'ont plus de sens. Tu peux lire les anneaux avec le calculateur de code couleur et trouver la bonne valeur pour une LED avec le calculateur de résistance de LED. Un bouton-poussoir à quatre pattes tourné de 90 degrés semblera toujours appuyé ou jamais appuyé. Sur les modules, l'ordre VCC, GND et signal varie selon le fabricant ; lis les inscriptions sur la carte elle-même, pas sur une image trouvée en ligne. Pour les composants à trois pattes comme les transistors et les régulateurs de tension, l'ordre des pattes change aussi selon le modèle.

Couche 5 : code (numéros de broches et logique)

Si le matériel est sain, vérifie que le code dit la même chose que le circuit. Premier contrôle, les numéros de broches : si la LED est physiquement sur la 8 mais que le code dit digitalWrite(9, HIGH), tout a l'air parfait et rien ne se passe. Deuxième contrôle, pinMode : si pinMode(broche, OUTPUT) manque dans setup(), digitalWrite(broche, HIGH) ne met pas la broche en sortie, il active seulement la résistance de tirage interne, et la LED brille très faiblement. Après la résistance, c'est la cause la plus fréquente d'une « LED faible ». Troisième contrôle, la logique : écrire if (valeur = 100) ne compare rien, cela affecte 100 à la variable et la condition est toujours vraie ; la bonne forme est ==. Les seuils et les délais appartiennent aussi à cette couche : un seuil inadapté à ton environnement fait que rien ne se déclenche, même avec un capteur qui fonctionne parfaitement. Dans les projets qui utilisent des bibliothèques, vérifie aussi que la bonne bibliothèque est installée ; les détails sont dans installer une bibliothèque Arduino.

Couche 6 : capteur et environnement

La dernière couche regroupe les conditions extérieures qui faussent le résultat même quand le circuit et le code sont justes. La valeur d'une LDR dépend de l'éclairage de la pièce ; un seuil qui marche près de la fenêtre en journée peut ne plus convenir le soir sous une lampe. Un HC-SR04 ne reçoit pas d'écho des surfaces molles comme le tissu et ne mesure pas en dessous de 2 cm. Les capteurs de gaz de la série MQ ont besoin de quelques minutes de chauffe avant de mesurer. Un DHT11 renvoie des erreurs si tu le lis plus d'une fois par seconde. Les broches de l'ESP32 et de la Raspberry Pi Pico fonctionnent en 3,3 V ; brancher directement un capteur à sortie 5 V peut donner de fausses lectures et abîmer la broche. Les fils longs, les parasites des moteurs et les entrées en l'air font aussi sauter les valeurs. Le meilleur outil pour cette couche est le moniteur série : observe la valeur brute du capteur et change volontairement les conditions. Si un écran ou un capteur I2C ne répond pas du tout, le programme scanner de qu'est-ce que l'I2C affiche son adresse.

Diviser pour régner : vérifier la carte avec Blink et les étapes avec le moniteur série

Le moyen le plus rapide de passer les couches est de découper le circuit et le code en morceaux. Le premier morceau, c'est la carte elle-même : sans rien brancher, téléverse un code qui fait clignoter le voyant L de la carte. Si L clignote, l'alimentation, le téléversement et la carte sont bons, et tu cherches désormais le problème en dehors de la carte. Le deuxième morceau est la sortie : fais aussi clignoter la LED externe dans le même code. Le troisième est l'entrée : affiche la valeur du capteur dans le moniteur série. Le programme ci-dessous fait les trois et écrit un point de contrôle numéroté dans le moniteur série à chaque étape. Branche la LED externe sur la broche 9 à travers une résistance de 220 Ω et le signal du capteur analogique à tester sur A0, puis règle le moniteur série sur 9600 bauds.

1const int LED_PIN = 9;       // Harici LED pini / External LED pin
2const int SENSOR_PIN = A0;   // Analog sensör pini / Analog sensor pin
3
4void setup() {
5  Serial.begin(9600);                  // Seri monitör de 9600 olmalı / Serial Monitor must be 9600 too
6  pinMode(LED_BUILTIN, OUTPUT);        // Karttaki L ışığı / On-board L LED
7  pinMode(LED_PIN, OUTPUT);            // Harici LED çıkış / External LED as output
8  Serial.println("1) setup bitti");    // Kontrol noktası 1 / Checkpoint 1
9}
10
11void loop() {
12  digitalWrite(LED_BUILTIN, HIGH);     // Kart canlı mı? / Is the board alive?
13  digitalWrite(LED_PIN, HIGH);         // Harici LED açık / External LED on
14  Serial.println("2) LED acik");       // Kontrol noktası 2 / Checkpoint 2
15  delay(500);
16
17  digitalWrite(LED_BUILTIN, LOW);
18  digitalWrite(LED_PIN, LOW);          // Harici LED kapalı / External LED off
19  Serial.println("3) LED kapali");     // Kontrol noktası 3 / Checkpoint 3
20  delay(500);
21
22  int value = analogRead(SENSOR_PIN);  // 0-1023 arası okuma / Reading from 0 to 1023
23  Serial.print("4) A0 = ");
24  Serial.println(value);               // Sensör değeri / Sensor value
25}

La vraie force de ce programme, ce sont ses points de contrôle. Utilise la même méthode dans ton propre projet : ajoute un court Serial.println() à la fin de setup() et après chaque étape importante de loop(), par exemple « bouton appuye » ou « seuil depasse ». Le dernier message affiché dans le moniteur série te dit où le programme s'est bloqué. Pour comprendre pourquoi une condition ne se déclenche jamais, affiche juste avant la valeur que tu compares ; si « valeur < 50 » n'est jamais vrai, tu verras tout de suite que la valeur ne descend jamais sous 50. Dans les gros projets, applique la même logique : mets temporairement une partie du code en commentaire et teste les morceaux un par un. Pour les réglages du moniteur série comme la vitesse, la fin de ligne et le traceur, consulte utiliser le moniteur série Arduino.

4 mesures au multimètre (ou avec une LED et le moniteur série)

Un multimètre transforme le diagnostic en mesure plutôt qu'en devinette, et quatre mesures seulement couvrent la plupart des pannes Arduino. Avant de mesurer, place l'appareil sur le bon calibre : V continu pour la tension, bip (continuité) pour les fils et les rangées, Ω pour les résistances. Fais toujours les tests de continuité et de résistance avec l'USB débranché. Si tu n'as pas de multimètre, les méthodes de la dernière colonne donnent une réponse plus grossière mais suffisante à la même question. Les calibres de l'appareil et les douilles où brancher les pointes sont expliqués en images dans comment utiliser un multimètre.

Exemple : la LED ne s'allume pas dans le projet Veilleuse avec LDR

Essayons la méthode sur un projet gratuit de BlueGrays : Veilleuse avec LDR. Dans le circuit, une extrémité de la LDR va au 5V et l'autre à A0 ; une résistance de 10 kΩ se trouve entre A0 et GND, et les deux forment un pont diviseur de tension. La LED est reliée à la broche 13 à travers une résistance de 330 Ω. Le code lit A0 et, si la valeur est inférieure à 50, considère qu'il fait nuit et allume la LED. Le symptôme : « Je couvre la LDR avec ma main et la LED ne s'allume jamais. » Au lieu de changer des fils au hasard, passons les couches dans l'ordre.

1. Alimentation : le voyant ON est allumé, rien ne chauffe. On passe.
2. Téléversement : le téléversement s'est terminé sans erreur. Pour en être sûr, remplace temporairement le 50 du code par 2000 et téléverse ; comme analogRead renvoie au maximum 1023, la condition est toujours vraie et la LED devrait rester allumée.
3. Câblage et voyant L : la broche 13 est aussi reliée au voyant L de la carte. Si L s'allume avec le seuil 2000 mais pas la LED externe, le code tourne et le problème est sur le chemin de la LED. La patte longue de la LED va-t-elle à la 13 à travers 330 Ω et la courte à GND ?
4. Sens et valeur : la LED n'est pas à l'envers, mais s'il y a 10 kΩ à côté d'elle au lieu de 330 Ω, elle brille trop faiblement pour qu'on le remarque. Distingue les deux résistances par leurs couleurs.
5. Code et capteur : si la LED externe s'allume avec le seuil 2000, remets-le à 50. Pour voir maintenant les vraies valeurs, téléverse sur le même circuit le code du projet Mesurer l'intensité lumineuse avec une LDR ; il utilise le même câblage de la LDR et écrit A0 dans le moniteur série toutes les demi-secondes.
6. Lis les valeurs : imaginons que tu lises environ 600 à découvert et environ 120 en couvrant avec la main. La valeur ne descend jamais sous 50, donc la LED ne s'allume jamais. Reviens au code de la veilleuse et monte le seuil entre 200 et 300.
7. Repère le comportement inversé : si la valeur monte au lieu de baisser quand tu couvres la LDR, la LDR et la 10 kΩ ont été inversées. Si la valeur saute au hasard alors que ta main ne bouge pas, le fil de A0 n'est pas bien enfoncé dans la rangée où se rejoignent la LDR et la résistance.

Dans cet exemple, ce n'est pas une connaissance nouvelle qui a trouvé la panne, mais l'ordre : nous avons d'abord prouvé que la LED pouvait s'allumer, puis regardé ce que le capteur lisait réellement. Dans l'application, la partie Si tu bloques de l'onglet Comprendre le code de ce même projet contient déjà cinq de ces symptômes sous forme de paires symptôme et solution : la LED externe ne s'allume jamais dans le noir, la LED s'allume à la lumière et s'éteint dans le noir, elle ne s'allume même pas main posée dessus, elle reste allumée ou scintille, et une erreur de téléversement. La partie Dépannage du projet donne une liste générale de 10 étapes qui commence par l'alimentation et passe par le téléversement, les numéros de broches, la plaque d'essai, les fils de liaison, la masse, la LED et la résistance. Tu l'as peut-être remarqué : cet ordre est presque le même que celui des couches du début de l'article.

L'aide dans l'application : où regarder quand un projet ne marche pas

• Dépannage : une liste ordonnée sur la page du projet qui commence par « Si votre projet ne fonctionne pas, vérifiez les étapes ci-dessous. » Elle existe sur plus de 170 projets et s'ouvre avec Premium ; sur les projets gratuits aussi, cette partie s'affiche avec Premium. Si tu n'as aucune idée de ce qui ne va pas, c'est l'endroit pour tout vérifier du début à la fin.
• Comprendre le code > Si tu bloques : des paires symptôme et solution propres au code et au circuit de ce projet. Ouvert à tous sur les projets gratuits, avec Premium sur les projets Premium. Si tu peux écrire ton symptôme en une phrase, regarde d'abord ici. Toute la partie est expliquée dans l'article Comprendre le code.
• Reviens aux étapes de Construisons-le ensemble : dans le mode guidé, retourne à 2. Monte le circuit et refais le montage depuis le début avec le câble USB de la carte débranché ; à l'étape 3. Téléverse le code, revérifie la carte et le port dans le menu Outils de l'Arduino IDE. Le mode se souvient de l'étape où tu étais. Son fonctionnement est expliqué dans ton premier projet Arduino.
• Agrandis le schéma : zoome à deux doigts sur le Schéma de circuit et compare ton câblage connexion par connexion ; si tu veux, enregistre-le avec Enregistrer dans la galerie et coche les fils déjà vérifiés. Cette méthode attrape la plupart des pannes de la couche 3.
• La bonne question sur le forum : si tu as tout essayé et que ça ne marche toujours pas, ouvre un sujet dans la catégorie Question dans Apprendre › Forum. Indique la carte, le code complet, les connexions, le comportement attendu et réel et les couches que tu as vérifiées, et ajoute une photo nette du montage. La manière de le rédiger est dans poser une question sur le forum.

Aide-mémoire par symptôme

Pour les enseignants : une fiche de diagnostic en 8 points

Imaginons une classe de 24 élèves avec 8 groupes qui montent des circuits en même temps, et dans les 15 premières minutes six groupes lèvent la main en disant « ça ne marche pas ». Pose la fiche ci-dessous sur la table de chaque groupe et fixe la règle dès le départ : avant de lever la main, parcourez la fiche de haut en bas et notez au dos le point où vous bloquez et ce que vous avez changé. Cela te libère du temps et donne aux élèves des habitudes de résolution de problèmes ; les notes de diagnostic sont aussi une trace du processus utilisable pour l'évaluation. Pour organiser les groupes dans une classe nombreuse, consulte un cours Arduino en classe nombreuse, et pour noter le processus, la grille d'évaluation.

1. Symptôme : qu'attendions-nous et que se passe-t-il ? Écrivez-le en une phrase.
2. Alimentation : le voyant ON est-il allumé ? Débranchez l'USB : un composant est-il chaud ?
3. Téléversement : le téléversement s'est-il terminé sans erreur ? Carte et port sont-ils corrects dans le menu Outils ?
4. Carte : après avoir téléversé Blink, le voyant L de la carte clignote-t-il ?
5. Câblage : agrandissez le schéma et comptez chaque fil à ses deux extrémités. La masse est-elle commune, les fils sont-ils sur la bonne broche et dans la bonne rangée ?
6. Composant : la patte longue de la LED va-t-elle à la broche ? Les anneaux de la résistance correspondent-ils à la valeur de la liste ? VCC et GND sont-ils corrects sur le module ?
7. Code : les numéros de broches du code correspondent-ils au circuit ? En affichant des points de contrôle dans le moniteur série, lequel apparaît en dernier ?
8. Capteur et étape suivante : la valeur du capteur dans le moniteur série est-elle logique et change-t-elle quand les conditions changent ? Si ce n'est toujours pas résolu, regardez Si tu bloques et Dépannage, puis appelez l'enseignant. Ne changez qu'une chose à la fois et prenez des notes.

Le diagnostic est une compétence et il s'accélère à chaque panne : une recherche qui prend 20 minutes sur ton premier projet descend à 3 minutes au cinquième, parce que tu commences à deviner la couche à partir du symptôme. La prochaine fois qu'un projet ne marche pas, ouvre cet ordre avant de débrancher le moindre fil et avance de haut en bas. Les petits projets comme la veilleuse de cet article sont idéaux pour s'entraîner ; dans l'application BlueGrays, chacun des 60 projets gratuits est fourni avec son schéma de circuit, son code et la partie Comprendre le code, si bien qu'à la prochaine panne tu sauras déjà où regarder.