Leçons · Leçon K1 · Les bases du code · 30 min
Ton premier programme : connecter ton ESP32 et y envoyer du code
D’une boîte de composants à une DEL qui clignote et à ton premier message à l’écran, pas à pas. Environ 30 minutes, avec un tableau de dépannage pour quand quelque chose refuse de marcher.
Nouveau ? Installe d’abord les outils : Bien démarrer.
Ce qu’il te faut
- Une carte de développement ESP32. Cette leçon utilise l’ESP32-DevKitC, la carte qu’Espressif conçoit elle-même. Elle est petite, avec des broches des deux côtés pour l’enficher sur une plaque d’essai [7].
- Un câble USB qui transporte des données. La DevKitC V4 a une prise Micro-USB, et le câble va de cette prise à ton ordinateur [7]. Certains câbles sont faits uniquement pour charger et n’ont aucun fil de données. Avec un câble comme ça, ton ordinateur ne verra jamais la carte [6]. Si la carte n’apparaît pas plus tard, changer de câble est la première chose à essayer.
- Un ordinateur. Arduino IDE 2 fonctionne sous Windows 10 ou plus récent (64 bits), sous macOS 10.15 « Catalina » ou plus récent, et sous Linux 64 bits [2].
- Pour la partie clignotement : une plaque d’essai, une DEL, une résistance de 220 Ω et deux fils de connexion. La leçon E3 explique pourquoi la résistance est là.
Regarde la prise USB de ta carte. Les cartes « clones » ont des prises différentes. Choisis un câble qui correspond à la prise que tu vois réellement sur ta carte.
Étape 1 : installer Arduino IDE 2
L’Arduino IDE est le programme où tu écris ton code, où tu appuies sur un bouton, et où tout part vers ta carte. Télécharge-le sur la page des logiciels d’Arduino (arduino.cc/en/software) [2].
- Windows : lance le fichier téléchargé et suis l’installateur. Cela peut prendre quelques minutes [2].
- macOS : copie le fichier téléchargé dans ton dossier Applications [2].
- Linux : télécharge l’AppImage 64 bits. Avant le premier lancement, rends-la exécutable : clic droit sur le fichier, Propriétés, onglet Permissions, puis coche « Autoriser l’exécution du fichier comme un programme ». Ensuite, double-clique dessus [2]. Si elle refuse de démarrer, il manque peut-être un petit utilitaire appelé FUSE. Sous Ubuntu 22.04 ou plus récent, le guide d’Arduino donne
sudo add-apt-repository universepuissudo apt install libfuse2; sous Fedora,dnf install fuse[2].
Ouvre l’IDE une première fois pour vérifier qu’il démarre. Tu vois un programme vide. Un sketch (« croquis ») est le mot d’Arduino pour un programme [12].
Les noms de menus de cette leçon sont écrits en anglais, comme dans l’IDE par défaut. Si ton IDE est en français, les noms sont traduits, mais l’ordre reste le même.
Étape 2 : apprendre l’ESP32 à l’IDE
À l’origine, l’IDE ne connaît que les cartes d’Arduino. Un paquet de cartes (board package) est un module complémentaire qui traduit les commandes Arduino habituelles dans la langue d’une famille de puces précise [3]. Pour l’ESP32, ce paquet vient d’Espressif, l’entreprise qui fabrique la puce [1].
2a. Dire à l’IDE où le trouver.
- Ouvre la fenêtre Preferences [1]. Dans les versions actuelles, elle se trouve sous File sur Windows et Linux. Sous macOS, elle n’est pas dans le menu File : cherche dans le menu de l’application (celui qui s’appelle Arduino IDE) l’entrée Preferences ou Settings, selon ta version.
- Repère le champ Additional boards manager URLs et colles-y cette adresse [1] :
https://espressif.github.io/arduino-esp32/package_esp32_index.json
- Clique sur OK. Si le champ contient déjà une autre adresse, sépare les deux par une virgule [1].
2b. Installer le paquet.
- Dans la colonne de gauche de l’IDE, clique sur l’icône Boards Manager (l’icône de carte) [3].
- Tape
esp32dans le champ de recherche. Choisis le paquet publié par Espressif, puis appuie sur INSTALL [3]. - Attends la fin de l’installation. Elle peut durer quelques minutes. Le numéro de version installé s’affiche sous le nom du paquet [3].
- Redémarre l’IDE [1].
Étape 3 : brancher la carte et trouver son port
Relie la carte à ton ordinateur avec le câble de données. Une petite DEL s’allume sur la DevKitC quand elle reçoit les 5 V de l’USB. C’est seulement le voyant d’alimentation : il ne dit rien de la liaison de données [7].
Ton ordinateur parle à l’ESP32 grâce à une petite puce intermédiaire sur la carte, un pont USB–UART. L’ordinateur lui donne un nom, appelé port : COM3 sous Windows, quelque chose comme /dev/ttyUSB0 sous Linux, /dev/cu.usbserial-... sous macOS [5][7].
Trouver ton port. L’IDE liste les ports qu’il détecte dans Tools > Port. Tu peux aussi vérifier à la main [5] :
- Windows : ouvre le Gestionnaire de périphériques et regarde la liste des ports COM. Débranche la carte, rebranche-la, et note quelle ligne disparaît puis revient.
- Linux : lance
ls /dev/tty*une fois carte débranchée et une fois carte branchée. Le nouveau nom est ton port. - macOS : même méthode avec
ls /dev/cu.*.
Si aucun nouveau port n’apparaît, il te faut peut-être un pilote. Le plus souvent, tu n’as rien à faire : le pilote est fourni avec ton système d’exploitation et s’installe tout seul au branchement [5]. Quand ce n’est pas le cas, il faut savoir quelle puce de pont ta carte porte :
- Lire le nom de la puce. Repère la petite puce carrée près de la prise USB et lis le texte imprimé sur le dessus. Une loupe aide. Le guide d’Espressif renvoie vers les pilotes CP210x et FTDI ; le guide de ta carte indique sa puce [5]. Beaucoup de cartes « clones » utilisent une puce CH340, fabriquée par WCH [10]. Une fois la carte branchée, le nom apparaît aussi dans la liste des périphériques de ton système, par exemple « Silicon Labs CP210x UART Bridge » [6].
- CP210x : télécharge le pilote chez Silicon Labs (le guide d’Espressif renvoie vers la page « USB to UART Bridge VCP Drivers », silabs.com/developers/usb-to-uart-bridge-vcp-drivers) [5].
- CH340 : SparkFun propose un guide pas à pas avec les fichiers du pilote pour Windows, macOS et Linux [10].
- Cas particulier de macOS : après l’installation d’un pilote, le système peut te demander de l’autoriser. Sous macOS 13 et plus récent, regarde dans Réglages Système > Confidentialité et sécurité ; sur les versions plus anciennes, dans Préférences Système > Sécurité et confidentialité > Général [5]. Dans les deux cas, tu cherches un message sur un logiciel du développeur concerné (Silicon Labs ou FTDI).
Ensuite, débranche la carte, rebranche-la, et regarde de nouveau la liste des ports.
Étape 4 : choisir la carte et le port
En haut de l’IDE, à côté des boutons « vérifier » et « téléverser », il y a une liste déroulante. Si elle n’affiche pas ta carte d’elle-même, choisis « Select other board and port… », ou va dans Tools > Board et Tools > Port et fais ton choix à la main [4].
- Carte : parmi les entrées esp32, choisis ESP32 Dev Module. C’est l’entrée générique pour l’ESP32, elle convient bien à la DevKitC. Si ta carte porte une autre puce, par exemple une ESP32-S3, choisis plutôt l’entrée qui porte le nom de cette puce.
- Port : choisis celui que tu as trouvé à l’étape précédente.
Le nom de la carte s’affiche en gras quand l’IDE détecte une connexion [4].
Étape 5 : monter le circuit de la DEL
La plupart des DevKitC n’ont aucune DEL commandable par le code. La DevKitC V4 officielle ne mentionne qu’un voyant d’alimentation, qui s’allume quand les 5 V arrivent [7]. Certaines cartes « clones » ont bien une petite DEL bleue, souvent sur la GPIO 2, mais cela varie d’une carte à l’autre. On ajoute notre propre DEL sur la GPIO 26 pour que tout le monde obtienne le même résultat. (GPIO veut dire « entrée/sortie à usage général » : une broche que ton code peut allumer, éteindre ou lire [16].)
Monte-la ainsi, carte débranchée :
- Enfiche la DevKitC sur la plaque d’essai (elle est prévue pour ça [7]). Beaucoup de cartes ESP32 sont larges et recouvrent tous les trous d’un côté d’une plaque d’essai standard. Si c’est le cas de la tienne, utilise deux plaques côte à côte, ou branche les fils uniquement du côté resté libre.
- Relie la broche repérée 26 à une extrémité de la résistance de 220 Ω avec un fil.
- Relie l’autre extrémité de la résistance à la patte longue de la DEL, appelée anode. La patte longue est le côté positif [15].
- Relie la patte courte (la cathode) à une broche repérée GND [15].
Pourquoi 220 Ω ? L’ESP32 fonctionne en logique 3,3 V : une broche activée délivre donc 3,3 V [17]. Une DEL rouge garde environ 2 V pour elle, il reste donc environ 1,3 V aux bornes de la résistance, et la loi d’Ohm donne (3,3 − 2) ÷ 220 ≈ 0,006 A, soit environ 6 mA : un courant doux pour une DEL. La leçon E3 détaille ce calcul.
Étape 6 : ton premier programme, Blink
Dans l’IDE, va dans File > New Sketch (ou utilise simplement le programme vide) et remplace tout par ceci :
// Tinker Mission, leçon K1 : faire clignoter une DEL externe
// Câblage : GPIO 26 -> résistance de 220 ohms -> patte longue de la DEL (anode) ; patte courte (cathode) -> GND
const int LED_PIN = 26; // la broche où la DEL est branchée
void setup() {
// S’exécute une seule fois, au démarrage ou après un reset de la carte.
pinMode(LED_PIN, OUTPUT); // cette broche envoie des signaux
}
void loop() {
// S’exécute encore et encore, sans fin.
digitalWrite(LED_PIN, HIGH); // broche à 3,3 V : DEL allumée
delay(500); // attendre 500 ms (une demi-seconde)
digitalWrite(LED_PIN, LOW); // broche à 0 V : DEL éteinte
delay(500);
}
Télécharger le dossier du croquis (.zip)
Lis-le comme une recette :
const int LED_PIN = 26;donne un nom au nombre 26, pour que la suite du code dise ce qu’il signifie. Si tu déplaces le fil plus tard, tu ne changes qu’une ligne [12].pinMode(LED_PIN, OUTPUT);dit à la carte que cette broche enverra des signaux [12].digitalWrite(LED_PIN, HIGH);met la broche à sa tension haute, soit 3,3 V sur l’ESP32 [17], et la DEL s’allume.LOWla ramène à 0 V et la DEL s’éteint [12].delay(500);fait attendre la carte 500 millisecondes. Il y a 1000 millisecondes dans une seconde [12]. Pendant qu’elle attend, la carte ne fait rien d’autre [15].
Ce que font setup() et loop(). Chaque programme a besoin de ces deux fonctions [12]. setup() s’exécute une seule fois, quand la carte démarre ou est réinitialisée. C’est l’endroit pour tout préparer, comme le mode des broches [13]. loop() s’exécute encore et encore, tant que la carte est alimentée. C’est là que ton programme fait son vrai travail [13].
Fais glisser le dessin sur le côté pour tout voir.
La carte démarre (mise sous tension ou reset).
Étape 7 : téléverser
- Clique sur le bouton vérifier (la coche). L’IDE contrôle ton code et le compile, sans rien envoyer. Les erreurs éventuelles apparaissent dans la console, en bas [4].
- Clique sur le bouton téléverser (la flèche vers la droite). L’IDE compile de nouveau le code et l’envoie à la carte [4].
- Surveille la console. Au début du téléversement, elle affiche
Connectingsuivi d’une ligne de points [8]. À la fin, un message s’affiche en bas à droite de l’IDE [4], et la DEL se met à clignoter.
Si les points défilent et que le téléversement échoue. Rien n’est cassé. L’ESP32 doit d’abord passer dans un état d’écoute particulier appelé mode téléchargement (download mode) avant d’accepter du nouveau code. Beaucoup de cartes le font toutes seules. Quand la tienne ne le fait pas, tu le fais avec les boutons [5][6] :
- La méthode simple : maintiens le bouton BOOT enfoncé pendant le téléversement [6].
- La méthode manuelle : maintiens BOOT, appuie une fois sur EN (le bouton de reset), puis relâche BOOT. Sur la DevKitC d’Espressif, maintenir BOOT en appuyant sur EN est justement ce qui lance le mode téléchargement [7]. Ensuite, lance le téléversement [5].
À l’intérieur de la puce, BOOT agit en tirant une broche appelée GPIO 0 vers 0 V pendant que la puce redémarre [6][9].
Ça échoue encore ? Regarde le tableau à la fin de cette leçon.
Étape 8 : dire bonjour avec le moniteur série
Une DEL qui clignote prouve que quelque chose tourne. Le moniteur série (Serial Monitor) permet à la carte de te répondre, avec des mots et des nombres à l’écran. C’est aussi ton meilleur outil pour savoir ce que ton code fait vraiment.
Remplace le programme par celui-ci et téléverse-le :
// Tinker Mission, leçon K1 : dire bonjour au moniteur série
// Ouvre le moniteur série et règle-le sur 115200 baud.
int counter = 0; // un endroit où ranger un nombre
void setup() {
Serial.begin(115200); // démarrer la liaison série à 115200 bits par seconde
}
void loop() {
Serial.print("Hello from my ESP32! Count: ");
Serial.println(counter); // afficher le nombre, puis passer à la ligne
counter = counter + 1; // ajouter un
delay(1000); // attendre une seconde
}
Télécharger le dossier du croquis (.zip)
Ouvre maintenant le moniteur série avec le bouton en haut à droite de l’IDE. Il s’ouvre dans un onglet du panneau du bas [14]. Cherche le réglage de vitesse (baud rate) et choisis 115200 [14].
Le baud rate est la vitesse de la conversation, en bits par seconde [11]. Les deux côtés doivent utiliser la même. La vitesse par défaut de la console de l’ESP32 est 115200 [5], et c’est pourquoi notre programme contient Serial.begin(115200). Tu dois voir une nouvelle ligne chaque seconde, avec un compteur qui monte.
Juste après un reset, tu peux aussi voir du texte en plus avant tes propres lignes. C’est le compte rendu de démarrage de la puce, affiché à la même vitesse de 115200 [9].
Quand quelque chose ne marche pas
Avance ligne par ligne, et change une seule chose avant de réessayer.
| Ce que tu vois | Raison probable | Ce qu’il faut essayer |
|---|---|---|
| Aucun port dans la liste, ou un port qui apparaît et disparaît | Câble qui ne sert qu’à charger, pilote manquant, ou prise fatiguée | Change de câble pour un câble de données. Essaie une autre prise USB de l’ordinateur, directement et non via un hub. Installe le pilote de ta puce de pont (CP210x ou CH340, voir l’étape 3). Débranche et rebranche [5][6][10] |
| « Permission denied » sur le port (Linux) | Ton compte n’a pas le droit d’utiliser le port série | Ajoute-toi au groupe dialout : sudo usermod -a -G dialout $USER (sous Arch Linux, le groupe est uucp). Puis déconnecte-toi et reconnecte-toi pour que ce soit pris en compte [4][5] |
| « Failed to connect » ou « Timed out waiting for packet header » | La carte n’est pas entrée en mode téléchargement, ou la liaison est mauvaise | Maintiens BOOT pendant le téléversement. Change de câble et de prise USB. Débranche tout ce qui est relié aux broches TX et RX. Ferme tout autre programme qui a ouvert le port, comme un autre terminal série [6][9] |
| Le téléversement démarre puis s’arrête avec des erreurs au hasard en cours de route | Liaison instable ou alimentation faible | Utilise un câble plus court et de bonne qualité. Évite les hubs. Branche-toi directement sur l’ordinateur [9] |
| Les erreurs de compilation parlent d’une autre carte, ou le code compile mais rien ne se passe comme prévu | Mauvaise carte sélectionnée | Vérifie Tools > Board et choisis ESP32 Dev Module (ou l’entrée qui porte le nom de ta puce). Le paquet de cartes sert à traduire ton code pour une puce précise, donc une erreur ici compte [3][6] |
| Le moniteur série affiche des symboles bizarres | Vitesse (baud) qui ne correspond pas | Règle le moniteur sur 115200 pour qu’il corresponde à Serial.begin(115200) [11] |
| Le moniteur série n’affiche rien du tout | Ta carte a deux prises USB, ou le moniteur est relié à un autre port | Appuie une fois sur EN pour redémarrer le programme pendant que le moniteur est ouvert. Sur les cartes qui ont une prise UART et une prise USB native séparée, utilise la bonne prise avec le bon réglage. La DevKitC ESP32 classique n’a que la prise UART [6] |
| L’IDE dit que le port est occupé | Un autre programme tient le port | Ferme les autres moniteurs ou terminaux série, puis réessaie [9] |
Pas encore de carte ? Essaie un simulateur
Si ta carte n’est pas encore arrivée, tu peux déjà t’exercer sur les idées de cette leçon dans un simulateur ESP32 en ligne appelé Wokwi : https://wokwi.com/. Il tourne dans le navigateur, il n’y a rien à installer. C’est une bonne façon d’essayer le programme Blink avant de toucher le moindre fil.
Vérifie-toi
Trois petites questions. Rien n’est enregistré, prends ton temps.
Combien de fois le code placé dans setup() s’exécute-t-il après la mise sous tension de la carte ?
- Une seule fois
- En boucle
- Une fois par seconde
Voir la réponse
Une seule fois. setup() s’exécute une seule fois, à la mise sous tension ou après un reset ; c’est loop() qui se répète [13].
Tu ouvres le moniteur série et tu vois une pluie de symboles bizarres à la place de ton texte. Quelle est la cause la plus probable ?
- La DEL est sur la mauvaise broche
- La vitesse (baud) du moniteur ne correspond pas à celle du programme
- La résistance est trop petite
Le téléversement reste bloqué sur « Connecting...... » et finit par « Failed to connect ». Que tentes-tu en premier ?
- Réécrire le programme depuis zéro
- Essayer un autre câble USB qui transporte des données et maintenir le bouton BOOT pendant le téléversement
- Installer une seconde copie de l’IDE
Voir la réponse
Essayer un autre câble USB qui transporte des données et maintenir le bouton BOOT pendant le téléversement. Certains câbles ne servent qu’à charger et ne transportent aucune donnée, et sur certaines cartes il faut maintenir BOOT pendant le téléversement [6].
Sources
Voir les 17 sources
- Espressif, documentation Arduino-ESP32, « Installing » (l’URL stable du Boards Manager,
https://espressif.github.io/arduino-esp32/package_esp32_index.json; à ajouter dans Preferences sous « Additional Boards Manager URLs » ; installer la plateforme esp32 ; redémarrer l’IDE) — https://docs.espressif.com/projects/arduino-esp32/en/latest/installing.html - Arduino, « Downloading and installing the Arduino IDE 2 » (configuration requise ; installation sous Windows, macOS et Linux ; AppImage et FUSE) — https://docs.arduino.cc/software/ide-v2/tutorials/getting-started/ide-v2-downloading-and-installing/
- Arduino, « Installing a board package in the IDE 2 » (ce qu’est un paquet de cartes ; icône Boards Manager, recherche, INSTALL ; numéro de version) — https://docs.arduino.cc/software/ide-v2/tutorials/ide-v2-board-manager/
- Arduino, « How to upload a sketch with the Arduino IDE 2 » (boutons vérifier et téléverser ; liste déroulante de carte ; Tools > Board et Tools > Port ; la solution à « Permission denied » sous Linux) — https://docs.arduino.cc/software/ide-v2/tutorials/getting-started/ide-v2-uploading-a-sketch/
- Espressif, ESP-IDF Programming Guide, « Establish Serial Connection with ESP32 » (pilotes USB-UART pour CP210x et FTDI ; pilote normalement fourni avec le système ; trouver le port sous Windows, Linux et macOS ; groupe dialout/uucp ; baud par défaut de la console : 115200 ; mode téléchargement manuel) — https://docs.espressif.com/projects/esp-idf/en/latest/esp32/get-started/establish-serial-connection.html
- Espressif, documentation Arduino-ESP32, « Troubleshooting » (câbles de charge seule ; « Failed to connect… Timed out waiting for packet header » ; maintenir BOOT pendant le téléversement ; mode téléchargement et GPIO 0 ; carte non détectée ; ESP32 Dev Module ; nom du pont, par exemple Silicon Labs CP210x) — https://docs.espressif.com/projects/arduino-esp32/en/latest/troubleshooting.html
- Espressif, guide de l’utilisateur ESP32-DevKitC V4 (port Micro-USB ; voyant d’alimentation ; boutons BOOT et EN ; pont USB-UART ; usage sur plaque d’essai) — https://docs.espressif.com/projects/esp-dev-kits/en/latest/esp32/esp32-devkitc/user_guide.html
- Espressif, documentation esptool, « Flashing firmware » (exemple de sortie avec « Connecting……… » pendant que l’outil atteint la puce) — https://docs.espressif.com/projects/esptool/en/latest/esp32/esptool/flashing-firmware.html
- Espressif, documentation esptool, « Troubleshooting » (le bootloader ne répond pas ; droits d’accès et autres programmes qui tiennent le port ; câbles et hubs instables ; journal de démarrage à 115200 ; GPIO 0 maintenue à l’état bas = bootloader série) — https://docs.espressif.com/projects/esptool/en/latest/esp32/troubleshooting.html et https://docs.espressif.com/projects/esptool/en/latest/esp32/advanced-topics/boot-mode-selection.html
- SparkFun, « How to Install CH340 Drivers » (le CH340 est une puce USB-série fabriquée par WCH ; présente sur des cartes de développement ; fichiers et étapes d’installation du pilote) — https://learn.sparkfun.com/tutorials/how-to-install-ch340-drivers
- SparkFun, « Serial Communication » (baud rate ; les deux côtés doivent correspondre ; une différence produit du charabia ; 115200 comme vitesse courante) — https://learn.sparkfun.com/tutorials/serial-communication
- Arduino, « Arduino Sketches » (un sketch est un programme ; setup() et loop() ; pinMode, digitalWrite, delay ; millisecondes) — https://docs.arduino.cc/learn/programming/sketches/
- Arduino, exemple « BareMinimum » (setup() s’exécute une fois après la mise sous tension ou le reset ; loop() se répète) — https://docs.arduino.cc/built-in-examples/basics/BareMinimum/
- Arduino, « Using the Serial Monitor tool » (bouton du moniteur série en haut à droite dans l’IDE 2, onglet du panneau du bas, réglage du baud rate) — https://docs.arduino.cc/software/ide-v2/tutorials/ide-v2-serial-monitor/
- Arduino, exemple « Blink » (patte longue = anode, patte courte = cathode vers GND ; résistance en série ; delay() arrête tout le reste pendant ce temps) — https://docs.arduino.cc/built-in-examples/basics/Blink/
- Espressif, documentation Arduino-ESP32, « GPIO » (GPIO = entrée/sortie à usage général ; pinMode, digitalWrite) — https://docs.espressif.com/projects/arduino-esp32/en/latest/api/gpio.html
- Adafruit, « Adafruit HUZZAH32 ESP32 Feather: Pinouts » (l’ESP32 fonctionne en alimentation et logique 3,3 V ; les broches GPIO ne tolèrent pas 5 V sauf mention contraire) — https://learn.adafruit.com/adafruit-huzzah32-esp32-feather/pinouts