Code Arduino avec l'IA (ChatGPT) : prompt, tests et erreurs

Écrire du code Arduino avec l'IA, c'est décrire ton projet à un assistant conversationnel comme ChatGPT, Gemini, Claude ou Copilot et lui demander un code qui fonctionne sur un Arduino, un ESP32 ou un Raspberry Pi Pico. Bien utilisée, l'IA transforme des heures de travail en minutes : au lieu d'une page blanche, tu obtiens un brouillon prêt à compiler. Mais l'IA ne voit pas ton circuit, ne sait pas quelle carte est posée sur ton bureau et peut affirmer quelque chose de faux avec un aplomb total. Elle peut inventer une fonction de bibliothèque qui n'existe pas, choisir la mauvaise broche ou écrire des boucles avec delay() qui bloquent tout. La vraie compétence n'est donc pas de demander du code, mais de bien demander et de vérifier ce que tu reçois.

Dans ce guide, tu verras comment un assistant IA produit du code Arduino et pourquoi il se trompe, comment écrire un bon prompt qui précise la carte, les broches, les bibliothèques et le comportement attendu, et quelles étapes suivre pour vérifier le code avant de le téléverser. Nous passerons en revue les trois erreurs les plus fréquentes avec de vrais messages du compilateur et du code corrigé. Ensuite, nous verrons comment coller correctement une erreur de compilation pour la faire corriger, pourquoi il ne faut pas faire confiance à l'IA quand on travaille sur le secteur 230 V et comment utiliser ces outils sans arrêter d'apprendre.

Comment l'IA écrit-elle du code Arduino et pourquoi se trompe-t-elle ?

Les grands modèles de langage (LLM) comme ChatGPT n'écrivent pas du code en l'exécutant comme un compilateur : ils prédisent la suite la plus probable à partir des millions d'exemples vus pendant leur entraînement. Pour les sujets très présents sur internet (faire clignoter une LED, lire un DHT11, faire tourner un servo), cette méthode marche très bien. Mais les connaissances du modèle sont figées à une certaine date ; il peut donc ignorer des fonctions qui ont changé dans les nouvelles versions d'une bibliothèque. Il peut confondre les fonctions de deux bibliothèques différentes portant le même nom. Surtout, au lieu de dire « je ne sais pas », il peut inventer une réponse qui paraît plausible : c'est ce qu'on appelle une hallucination. Comme le modèle ne voit pas ton circuit, il déduit les numéros de broches, les niveaux de tension et la version des modules soit de ce que tu as écrit, soit de ses propres suppositions.

Comment écrire un bon prompt ?

Le code que te donne l'IA ne peut pas être meilleur que les informations que tu lui fournis. Avec une demande d'une ligne comme « écris un code Arduino qui mesure la température », le modèle choisit lui-même la carte, le capteur, la broche et la bibliothèque. Si ses choix ne correspondent pas à ton matériel, le code ne compile pas, ou compile et ne marche pas. Rédige un bon prompt comme si tu expliquais le projet au téléphone à un ami qui en entend parler pour la première fois : cite un par un la carte, les composants, les branchements, les bibliothèques, le comportement attendu et les contraintes. Le tableau résume ce que doit contenir un prompt pour Arduino :

Par exemple, ce prompt donne de bien meilleurs résultats qu'une demande d'une ligne : « J'utilise un Arduino Uno R3 et l'Arduino IDE 2.3. La broche DATA du DHT22 est sur D2, un buzzer actif sur D8, et un écran LCD 16x2 I2C (PCF8574, adresse 0x27) a SDA sur A4 et SCL sur A5. Les bibliothèques Adafruit DHT sensor library et LiquidCrystal I2C de Frank de Brabander sont installées. Toutes les 2 secondes, affiche la température et l'humidité sur le LCD et, si la température dépasse 30 °C, fais biper le buzzer par petites salves. Utilise millis() au lieu de delay() et commente les lignes en français. Au début, liste les bibliothèques à installer et, à la fin, les hypothèses que tu as faites. » Avec ce prompt, il ne reste presque rien à deviner pour le modèle.

Les étapes pour vérifier le code généré par l'IA

Aussi propre que paraisse le code, passe-le au crible d'une liste de contrôle avant de le téléverser. La plupart de ces étapes prennent quelques minutes et coûtent bien moins cher qu'un module grillé à cause d'une broche mal branchée :

1. Compile d'abord : Clique sur Vérifier (le bouton en forme de coche) sans brancher la carte. En cas d'erreur, fais-la corriger avec la méthode plus bas ; pour comprendre les messages, lis les erreurs de compilation Arduino.
2. Vérifie les bibliothèques une par une : Cherche chaque ligne #include dans le gestionnaire de bibliothèques et installe celle dont le nom, l'auteur et les exemples correspondent au code. Si tu ne sais pas comment faire, le guide ajouter une bibliothèque Arduino t'explique tout pas à pas.
3. Compare les broches : Compare chaque numéro de broche du code avec ton câblage et le brochage de la carte. Pour les broches PWM et celles à éviter, utilise l'outil Pinout.
4. Calcule les valeurs électriques : Vérifie la résistance proposée avec le calculateur de résistance pour LED. Si un capteur à sortie 5 V doit aller sur un ESP32 ou un Pico en 3,3 V, place un pont diviseur de tension entre les deux.
5. Teste en simulation : Lance le code dans Wokwi ou Tinkercad avant de brancher le vrai matériel ; tu repères les erreurs de logique sans risquer le moindre composant.
6. Teste morceau par morceau : Ne téléverse pas tout le projet d'un coup. Essaie d'abord un petit croquis qui lit seulement le capteur et l'affiche dans le moniteur série, puis ajoute l'écran et, en dernier, le buzzer ou le relais.
7. Surveille le moniteur série : Ajoute des Serial.println() aux endroits clés pour voir si les variables prennent les valeurs attendues, et vérifie que la vitesse en bauds correspond au Serial.begin() du code. Plus de détails dans le moniteur série Arduino.
8. Fais-toi expliquer le code : Pour chaque ligne que tu ne comprends pas, demande « que fait cette ligne et que se passe-t-il si je la supprime ? ». Ne téléverse jamais un code que tu ne sais pas expliquer.

Erreur fréquente n° 1 : des fonctions de bibliothèque qui n'existent pas

L'erreur la plus sournoise de l'IA consiste à écrire des fonctions qui n'existent pas mais dont le nom paraît très crédible. Par exemple, la bibliothèque Servo standard propose attach(), write(), writeMicroseconds(), read() et detach(), mais aucune fonction setSpeed() pour régler la vitesse ; le modèle peut l'inventer si tu demandes un servo qui tourne lentement. Parfois la fonction existe bel et bien, mais sur une autre carte : Serial.printf() fonctionne sur l'ESP32 mais ne compile pas sur un Arduino Uno. Et parfois la fonction appartient à une ancienne version : ledcSetup() et ledcAttachPin() ont été supprimées dans la version 3.x du noyau Arduino pour ESP32, sortie en 2024, pourtant la plupart des modèles écrivent encore du code avec. Il existe aussi des bibliothèques différentes qui utilisent le même fichier d'en-tête : dans l'une, appelée LiquidCrystal_I2C.h, l'écran se démarre avec lcd.init(), dans une autre du même nom avec lcd.begin(). Si tu vois l'avertissement « Multiple libraries were found » dans la sortie du compilateur, soupçonne cette confusion.

Le piège des anciennes fonctions sur l'ESP32 : ledcAttach au lieu de ledcSetup

Quand tu demandes un code ESP32 qui règle la luminosité d'une LED ou la vitesse d'un moteur, l'IA écrira très probablement le trio ledcSetup(canal, fréquence, résolution), ledcAttachPin(broche, canal) et ledcWrite(canal, valeur). Ce code fonctionne avec la version 2.x du noyau. Dans la version 3.x, en revanche, les canaux sont attribués automatiquement : ledcAttach(broche, fréquence, résolution) configure la broche en une seule fois, et ledcWrite(broche, valeur) prend désormais un numéro de broche au lieu d'un canal. Tu peux voir la version installée à côté du paquet esp32 dans le gestionnaire de cartes. Le code ci-dessous vérifie la version à la compilation et fonctionne donc avec les deux noyaux :

1// ESP32 PWM: çekirdek 2.x ve 3.x ile uyumlu LED soldurma / LED fade for both core 2.x and 3.x
2#include <esp_arduino_version.h>   // ESP_ARDUINO_VERSION_MAJOR için / for ESP_ARDUINO_VERSION_MAJOR
3
4const int LED_PIN = 2;             // çoğu DevKit'te dahili LED / onboard LED on most DevKits
5const uint32_t FREKANS = 5000;     // PWM frekansı, Hz / PWM frequency, Hz
6const uint8_t COZUNURLUK = 8;      // 8 bit: 0-255 / 8-bit: 0-255
7
8#if ESP_ARDUINO_VERSION_MAJOR >= 3
9// Çekirdek 3.x: kanal otomatik seçilir, fonksiyonlar pin alır / Core 3.x: channel is automatic, functions take the pin
10void pwmBaslat() { ledcAttach(LED_PIN, FREKANS, COZUNURLUK); }
11void pwmYaz(uint32_t deger) { ledcWrite(LED_PIN, deger); }
12#else
13// Çekirdek 2.x: önce kanal kurulur, sonra pine bağlanır / Core 2.x: set up a channel, then attach the pin
14const uint8_t KANAL = 0;
15void pwmBaslat() { ledcSetup(KANAL, FREKANS, COZUNURLUK); ledcAttachPin(LED_PIN, KANAL); }
16void pwmYaz(uint32_t deger) { ledcWrite(KANAL, deger); }
17#endif
18
19void setup() {
20  Serial.begin(115200);
21  Serial.print("ESP32 Arduino cekirdegi / core: ");
22  Serial.println(ESP_ARDUINO_VERSION_MAJOR);
23  pwmBaslat();
24}
25
26void loop() {
27  // Tek iş yaptığı için burada delay() sorun değil / delay() is fine here: only one task
28  for (int d = 0; d <= 255; d++) { pwmYaz(d); delay(4); }   // yavaşça yan / fade in
29  for (int d = 255; d >= 0; d--) { pwmYaz(d); delay(4); }   // yavaşça sön / fade out
30}

La leçon ne concerne pas que l'ESP32 : si tu indiques la version du noyau et des bibliothèques dans ton prompt, le modèle a une chance de choisir les bonnes fonctions. S'il utilise encore d'anciennes fonctions malgré tout, ouvre un des exemples officiels de la bibliothèque dans Fichier > Exemples et colle-le dans le prompt avec « réécris-le avec les fonctions de cet exemple ». Les exemples officiels correspondent toujours à la version installée. Pour comprendre le fonctionnement du PWM, jette un œil à Qu'est-ce que le PWM ?

Erreur fréquente n° 2 : la mauvaise broche

Même si le code compile et se téléverse, une mauvaise broche donne un circuit qui ne fait rien sans prévenir, ou un module grillé. Le compilateur ne peut pas le détecter, car pour lui un numéro de broche n'est qu'un nombre. Voici, carte par carte, les erreurs de broches les plus fréquentes de l'IA :

Erreur fréquente n° 3 : le blocage par delay()

Comme la plupart des exemples Arduino sur internet sont écrits avec delay(), l'IA utilise aussi delay() par défaut. Pendant que delay(1000) s'exécute, le processeur ne fait rien d'autre pendant une seconde entière : il ne lit pas les boutons, ne surveille pas les capteurs et ne met pas l'écran à jour. Dans un code qui ne fait qu'une chose, ce n'est pas grave. Mais si tu demandes deux choses à la fois, comme « fais clignoter une LED et fais biper le buzzer quand on appuie sur le bouton », tu obtiens souvent un code comme celui-ci :

1// Yapay zekanın sık ürettiği, kilitlenen kod / Blocking code that AI often produces
2const int BUTON_PIN = 2;    // buton: D2 ile GND arası / button between D2 and GND
3const int LED_PIN = 13;     // dahili LED / onboard LED
4const int BUZZER_PIN = 8;   // aktif buzzer / active buzzer
5
6void setup() {
7  pinMode(BUTON_PIN, INPUT_PULLUP);
8  pinMode(LED_PIN, OUTPUT);
9  pinMode(BUZZER_PIN, OUTPUT);
10}
11
12void loop() {
13  digitalWrite(LED_PIN, HIGH);
14  delay(1000);                          // 1 sn boyunca buton okunmaz / button is not read for 1 s
15  digitalWrite(LED_PIN, LOW);
16  delay(1000);                          // 1 sn daha kör bekleme / another blind second
17
18  if (digitalRead(BUTON_PIN) == LOW) {  // yalnızca tam bu anda basılıysa / only if pressed right now
19    digitalWrite(BUZZER_PIN, HIGH);
20    delay(200);
21    digitalWrite(BUZZER_PIN, LOW);
22  }
23}

Ce code compile sans erreur, mais la plupart du temps il ne se passe rien quand tu appuies sur le bouton. Environ 2 secondes de chaque tour de loop() se passent dans les deux appels à delay(), et le bouton n'est lu que pendant quelques microsecondes entre les deux. Un appui bref rate presque toujours ce moment ; pour que le buzzer sonne à coup sûr, tu dois maintenir le bouton plus de 2 secondes. La solution n'est pas d'attendre mais de regarder l'horloge : millis() renvoie le nombre de millisecondes écoulées depuis le démarrage, chaque tâche vérifie si son moment est venu et loop() tourne des milliers de fois par seconde :

1// millis() ile kilitlenmeyen sürüm / Non-blocking version with millis()
2const int BUTON_PIN = 2;    // buton: D2 ile GND arası / button between D2 and GND
3const int LED_PIN = 13;     // dahili LED / onboard LED
4const int BUZZER_PIN = 8;   // aktif buzzer / active buzzer
5
6const unsigned long LED_ARALIK = 1000;  // LED değişim aralığı, ms / LED toggle interval, ms
7const unsigned long BIP_SURE = 200;     // bip süresi, ms / beep length, ms
8const unsigned long SICRAMA = 30;       // debounce süresi, ms / debounce time, ms
9
10unsigned long ledZaman = 0;     // LED'in son değiştiği an / last LED toggle
11unsigned long bipZaman = 0;     // bipin başladığı an / beep start
12unsigned long butonZaman = 0;   // butonun son değiştiği an / last button change
13bool ledDurum = false;
14bool bipCaliyor = false;
15int oncekiButon = HIGH;         // önceki buton seviyesi / previous button level
16
17void setup() {
18  pinMode(BUTON_PIN, INPUT_PULLUP);
19  pinMode(LED_PIN, OUTPUT);
20  pinMode(BUZZER_PIN, OUTPUT);
21}
22
23void loop() {
24  unsigned long simdi = millis();
25
26  // 1) LED: zamanı geldiyse durum değiştir / toggle the LED when its time has come
27  if (simdi - ledZaman >= LED_ARALIK) {
28    ledZaman = simdi;
29    ledDurum = !ledDurum;
30    digitalWrite(LED_PIN, ledDurum ? HIGH : LOW);
31  }
32
33  // 2) Buton: yalnızca basıldığı anı yakala / catch only the moment of the press
34  int buton = digitalRead(BUTON_PIN);
35  if (buton != oncekiButon && simdi - butonZaman >= SICRAMA) {
36    butonZaman = simdi;
37    oncekiButon = buton;
38    if (buton == LOW && !bipCaliyor) {  // HIGH -> LOW: yeni basış / new press
39      bipCaliyor = true;
40      bipZaman = simdi;
41      digitalWrite(BUZZER_PIN, HIGH);
42    }
43  }
44
45  // 3) Buzzer: süre dolunca sustur / silence it when the time is up
46  if (bipCaliyor && simdi - bipZaman >= BIP_SURE) {
47    bipCaliyor = false;
48    digitalWrite(BUZZER_PIN, LOW);
49  }
50}

Dans cette version, la LED, le bouton et le buzzer fonctionnent sans s'attendre les uns les autres. Une soustraction de la forme simdi - ledZaman >= LED_ARALIK donne le bon résultat même quand millis() repasse à zéro, environ tous les 49,7 jours, alors que la comparaison millis() > tempsCible que l'IA écrit parfois échoue à ce débordement. Détecter l'instant où le bouton passe de HIGH à LOW empêche le buzzer de biper en boucle tant que le bouton reste enfoncé, et l'attente de 30 ms filtre les rebonds du contact (anti-rebond). Tout le sujet est traité dans le guide millis() au lieu de delay() sur Arduino, et le branchement du bouton dans brancher un bouton sur Arduino.

Coller une erreur de compilation et la faire corriger

L'IA est vraiment douée pour expliquer les erreurs de compilation, à condition de lui donner l'erreur complète et le contexte. Écrire seulement « le code ne marche pas » oblige le modèle à deviner. Suis cet ordre :

1. Quand une erreur de compilation apparaît dans l'Arduino IDE 2, clique sur Copier les messages d'erreur dans la notification en bas à droite, ou sélectionne et copie tout le texte de la console de sortie. La mention exit status 1 de la dernière ligne ne sert à rien seule ; la vraie cause se trouve plus haut, dans la ligne contenant error:.
2. Ton prompt doit contenir, dans cet ordre : la carte et la version du noyau, le code complet, le message d'erreur complet, ainsi que le nom et la version des bibliothèques installées.
3. Avant de demander la correction, écris « Explique d'abord la cause de l'erreur, puis montre seulement les lignes à modifier ». Ainsi, le modèle ne réécrit pas tout le croquis en ajoutant de nouvelles erreurs, et tu apprends ce qui change et pourquoi.
4. Applique la modification proposée et recompile. Si une nouvelle erreur apparaît, colle de nouveau la première ligne error: ; corrige une seule erreur à la fois.
5. Si la même erreur persiste après deux ou trois allers-retours, sors de la boucle et compile l'exemple officiel de la bibliothèque. Si l'exemple ne compile pas non plus, le problème ne vient pas du code mais de l'installation : mauvaise carte sélectionnée, bibliothèque manquante ou deux bibliothèques homonymes en conflit.

Si l'erreur survient au téléversement et non à la compilation (par exemple « avrdude: stk500_recv(): programmer is not responding » ou, sur l'ESP32, « Failed to connect to ESP32 »), modifier le code ne sert à rien ; il faut vérifier le port, le câble, le pilote et la carte sélectionnée. Le guide Arduino : le téléversement échoue t'accompagne pas à pas dans ces cas. Quand tu interroges l'IA sur une erreur de téléversement, donne aussi le message complet et ton système d'exploitation.

Faire écrire du code Raspberry Pi Pico et MicroPython par l'IA

Les mêmes règles s'appliquent au code MicroPython, mais ici l'IA peut en plus mélanger les plateformes. Le code écrit pour les ordinateurs Raspberry Pi avec RPi.GPIO ou gpiozero ne tourne pas sur le Pico ; sur le Pico, on utilise le module machine de MicroPython. Les modules board et digitalio de CircuitPython n'existent pas non plus dans MicroPython. Indique donc clairement dans ton prompt « Raspberry Pi Pico W, MicroPython, Thonny ». Le code ci-dessous fonctionne sur le Pico comme sur le Pico W et cadence le temps avec ticks_ms() au lieu d'attendre :

1# Pico ve Pico W: bekletmeden LED + buton / Pico and Pico W: LED + button without blocking
2from machine import Pin
3import time
4
5led = Pin("LED", Pin.OUT)             # Pico W'da Pin(25) çalışmaz / Pin(25) does not work on Pico W
6buton = Pin(14, Pin.IN, Pin.PULL_UP)  # buton: GP14 ile GND arası / button between GP14 and GND
7
8ARALIK = 500                          # LED değişim aralığı, ms / LED toggle interval, ms
9SICRAMA = 30                          # debounce süresi, ms / debounce time, ms
10son = time.ticks_ms()                 # LED'in son değiştiği an / last LED toggle
11degisim = time.ticks_ms()             # butonun son değiştiği an / last button change
12onceki = 1                            # önceki buton seviyesi / previous button level
13sayac = 0
14
15while True:
16    simdi = time.ticks_ms()
17    if time.ticks_diff(simdi, son) >= ARALIK:      # taşmada da doğru / correct even on overflow
18        son = simdi
19        led.toggle()
20    deger = buton.value()
21    if deger != onceki and time.ticks_diff(simdi, degisim) >= SICRAMA:
22        degisim = simdi
23        onceki = deger
24        if deger == 0:                # basıldığı an / moment of the press
25            sayac += 1
26            print("Basma / press:", sayac)

Quand tu lances le code dans Thonny, la LED intégrée clignote toutes les demi-secondes et chaque appui sur le bouton affiche un nombre croissant dans la fenêtre Shell. time.ticks_diff() donne le bon écart même quand le compteur de temps déborde, alors que la simple soustraction time.ticks_ms() - son, que l'IA écrit souvent, peut donner un résultat faux dans un code qui tourne longtemps. Si tu débutes avec le Pico, commence par Qu'est-ce que le Raspberry Pi Pico ?

Sur le secteur 230 V, ne fais pas confiance à l'IA

Si ton projet doit fonctionner sur le secteur, teste-le d'abord en basse tension : une LED à la place de la lampe, un ruban LED 12 V à la place de la prise. Si le système doit vraiment commuter du 230 V, certaines règles ne se discutent pas. Débranche le circuit avant de travailler dessus. Le relais doit couper la phase (L), pas le neutre. Ne dépasse pas le courant et la tension imprimés sur le module relais (10 A 250 VAC sur la plupart des modules) et place la partie haute tension dans un boîtier fermé et isolant. Les modules relais bon marché laissent souvent trop peu d'écart entre les parties basse et haute tension ; dans la mesure du possible, choisis une prise connectée ou un boîtier relais tout fait et certifié. Tu trouveras le branchement d'un module relais en détail dans Qu'est-ce qu'un module relais ?

Utiliser l'IA sans arrêter d'apprendre

Si l'IA écrit tous tes croquis à ta place, tu ne sauras pas quoi faire le premier jour où le code ne marchera pas. Si ton but est d'apprendre l'électronique et la programmation, utilise-la non pas comme une machine à code, mais comme un professeur patient :

• Écris d'abord toi-même : Essaie le code par toi-même, puis demande à l'IA de le relire avec « montre-moi les erreurs mais ne me donne pas le code corrigé ».
• Demande des indices, pas des réponses : Quand tu bloques, dis « donne-moi seulement un indice pour l'étape suivante ».
• Fais-toi expliquer ligne par ligne : Après l'explication, essaie de raconter la même logique avec tes propres mots ; ce que tu n'arrives pas à expliquer, tu ne l'as pas encore appris.
• Tape au lieu de copier : Taper le code à la main au lieu de le coller t'apprend la syntaxe et les noms de fonctions bien plus vite.
• Prédis, puis teste : Avant de changer une valeur, prédis ce qui va se passer (par exemple si LED_ARALIK passe à 200), puis téléverse et vérifie.
• Teste-toi : Demande à l'IA de te poser cinq questions sur ce que tu viens d'apprendre ; pour revoir les bases, utilise les bases de la programmation Arduino.
• Respecte les règles : Pour les devoirs, les projets scolaires et les concours scientifiques, respecte les règles sur l'usage de l'IA et indique clairement si tu t'en es servi.

Premiers projets à essayer avec l'IA

• Afficheur de température : Affiche les mesures d'un DHT11 sur un écran LCD I2C ; précise dans le prompt l'adresse du LCD et l'auteur de la bibliothèque.
• Radar de recul : Mesure la distance avec un HC-SR04 et fais biper le buzzer plus vite à mesure qu'un obstacle approche ; demande une gestion du temps avec millis().
• Veilleuse : Allume une LED quand il fait sombre grâce à une LDR ; relève d'abord le seuil dans le moniteur série et donne-le en chiffres dans le prompt.
• LED pilotée en Wi-Fi : Allume et éteins une LED depuis une page ouverte sur ton téléphone avec un ESP32 ; précise la version du noyau dans le prompt.
• Ta propre idée : Choisis un projet dans la liste d'idées de projets Arduino et décris-le à l'IA avec le modèle de prompt de ce guide.

L'IA peut être l'aide la plus rapide à ta disposition pendant que tu apprends Arduino, à condition de lui donner les bonnes informations, de compiler ce qu'elle te renvoie, de vérifier les broches, de tester morceau par morceau et de ne jamais téléverser une ligne que tu ne comprends pas. Si tu cherches des exemples fiables pour comparer le code écrit par l'IA, l'application BlueGrays propose des projets avec LED, bouton, DHT11, PWM sur ESP32 et Pico, avec des schémas de câblage pas à pas et du code testé.