English

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.

Ce qu'il te faut pour la leçon K1 Les éléments posés côte à côte, dessinés à plat : une ESP32-DevKitC vue de dessus, prise USB à gauche, avec ses deux boutons EN et BOOT à côté de la prise ; un câble USB qui transporte des données ; un ordinateur portable ; une plaque d'essai ; une DEL avec une patte longue (plus) et une patte courte (moins) ; une résistance de 220 ohms ; deux fils de connexion. FIG. 1 — CE QU'IL TE FAUTENBOOTESP32-DevKitC (vue de dessus)prise USBBOOTordinateurWindows, macOS ou LinuxMicro-USBUSB-Acâble USB de donnéesplaque d'essai+−DEL220 Ωrésistance2 fils de connexion
Touche le schéma pour l’ouvrir en plein écran.
Câble de données ou câble de charge seule Deux câbles USB coupés. Un câble de données contient quatre fils : 5 V, masse, D plus et D moins ; les deux fils de données permettent à l'ordinateur de parler à la carte, donc un port apparaît. Un câble de charge seule n'a que les fils 5 V et masse. Le voyant d'alimentation de la carte s'allume avec les deux câbles : il ne prouve rien pour les données. Si aucun port n'apparaît, change d'abord de câble. FIG. 2 — CÂBLE DE DONNÉES OU DE CHARGEaCâble de données5 VD+D−GNDdonnéesvoyantalluméListe des portsCOM3L'ordinateur voit la carte.bCâble de charge seule5 VGNDaucun fil de donnéesvoyantalluméListe des ports(rien de nouveau)La carte reçoit du courant, rien d'autre.Les deux se ressemblent de l'extérieur. Pas de nouveau port ? Change d'abord de câble.
Touche le schéma pour l’ouvrir en plein écran.

É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 universe puis sudo 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.

Installer Arduino IDE 2 Trois croquis simplifiés, un par système. Windows : lance l'installateur téléchargé et va jusqu'au bout. macOS : fais glisser l'application téléchargée dans le dossier Applications. Linux : clic droit sur l'AppImage, Propriétés, onglet Permissions, coche « Autoriser l'exécution du fichier comme un programme », puis double-clique dessus. FIG. 3 — INSTALLER L'IDEWindowsAssistantInstallation…SuivantLance le fichiertéléchargé.macOSArduino IDEApplicationsCopie-le dansApplications.LinuxPropriétésPermissionsAutoriser l'exécutioncomme un programmeClic droit sur l'AppImage,coche, puis double-clique.Dessins simplifiés : tes écrans seront un peu différents.
Touche le schéma pour l’ouvrir en plein écran.
La fenêtre d'Arduino IDE 2, simplifiée Un dessin simplifié de la fenêtre de l'IDE, pas une capture d'écran. En haut à gauche : le bouton coche vérifie ton code, le bouton flèche le téléverse. À côté, la liste déroulante de carte et de port. En haut à droite : le bouton du moniteur série. Colonne de gauche : l'icône Boards Manager parmi d'autres outils. Au centre : l'éditeur, où va ton programme. En bas : la console, où s'affichent les messages et les erreurs. FIG. 4 — L'IDE, SIMPLIFIÉSelect Boardvoid setup() {  // put your setup code here}void loop() {  // runs again and again}OutputDone compiling.12345671Vérifiercontrôle et compile ton code2Téléverserl'envoie à la carte3Carte et portquelle carte, quel port4Moniteur sérieles messages de la carte5Boards Managerajoute des paquets de cartes6Éditeurton programme (sketch)7Consoleprogression et erreursDessin simplifié, pas une capture : les positions correspondent, les détails diffèrent.
Touche le schéma pour l’ouvrir en plein écran.

É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.

  1. 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.
  2. Repère le champ Additional boards manager URLs et colles-y cette adresse [1] :
https://espressif.github.io/arduino-esp32/package_esp32_index.json
  1. Clique sur OK. Si le champ contient déjà une autre adresse, sépare les deux par une virgule [1].

2b. Installer le paquet.

  1. Dans la colonne de gauche de l’IDE, clique sur l’icône Boards Manager (l’icône de carte) [3].
  2. Tape esp32 dans le champ de recherche. Choisis le paquet publié par Espressif, puis appuie sur INSTALL [3].
  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].
  4. Redémarre l’IDE [1].
Ajouter le paquet de cartes ESP32 Deux panneaux simplifiés. Panneau a, la fenêtre Preferences : le champ Additional boards manager URLs est mis en évidence avec l'adresse d'Espressif écrite dedans, puis le bouton OK. Panneau b, l'IDE avec le Boards Manager ouvert dans la colonne de gauche : esp32 est tapé dans la recherche, et le bouton INSTALL du paquet d'Espressif Systems est mis en évidence. Redémarre l'IDE à la fin. FIG. 5 — AJOUTER LE PAQUET ESP32aFile › Preferences (macOS : menu de l'app)PreferencesSketchbook location:Editor font size:14Additional boards manager URLs:https://espressif.github.io/arduino-esp32/package_esp32_index.json1OK2Déjà une adresse ? Sépare-les par une virgule.bBoards Manager : chercher, puis INSTALLArduino IDE 2123BOARDS MANAGEResp32esp32by Espressif Systemsx.y.zINSTALL1Clique sur l'icône de carte.2Tape esp32.3INSTALL celui d'Espressif.4Patiente, puis redémarre l'IDE.
Touche le schéma pour l’ouvrir en plein écran.

É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.

ESP32-DevKitC : qui est où Vue de dessus d'une carte de type DevKitC, prise USB à gauche. À côté de la prise : le bouton EN (reset) et le bouton BOOT. Juste à droite de la prise : la petite puce carrée du pont USB–UART ; lis le nom imprimé dessus, par exemple CP2102 ou CH340. Près d'elle, la DEL d'alimentation. À droite, le module ESP32, antenne au bout. Les broches longent les deux grands côtés. En dessous, une liste de ports avant et après le branchement : une nouvelle ligne, COM3, apparaît ; c'est ta carte. FIG. 6 — LA CARTE, VUE DE DESSUSENBOOT5VCLKCMDD0D3D1D215132GND0124141627172652518331932GND352134RXVNTXVP22EN233V3GNDprise USBEN = resetbouton BOOTDEL d'alimentationpuce de pont : lis le nom dessus(CP2102, CH340…)module ESP32antenne au boutle nom de chaque broche est imprimé à côtéTrouver le port : débranche, rebranche, repère la nouvelle lignecarte débranchéePortsCOM1carte branchéePortsCOM1COM3← nouveau : ta carteLinux : /dev/ttyUSB0 · macOS : /dev/cu.usbserial-…
Touche le schéma pour l’ouvrir en plein écran.

É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].

Choisir la carte et le port Dessin simplifié du choix de la carte et du port. La liste déroulante en haut de l'IDE est ouverte sur Select other board and port. À gauche, la liste des cartes filtrée avec esp32 : ESP32 Dev Module est en surbrillance. À droite, la liste des ports : COM3 est en surbrillance. Sous Linux, le port ressemble à /dev/ttyUSB0, sous macOS à /dev/cu.usbserial suivi d'un code. Une fois connectée, le nom de la carte s'affiche en gras dans la liste déroulante. FIG. 7 — CHOISIR LA CARTE ET LE PORTESP32 Dev Module← s'affiche en gras une fois connectéeou : Tools › Board et Tools › PortSelect Other Board and PortBOARDSPORTSesp32ESP32C3 Dev ModuleESP32 Dev Module1ESP32 Wrover ModuleESP32S3 Dev ModuleCOM3Serial Port (USB)2Linux : /dev/ttyUSB0macOS : /dev/cu.usbserial-…OK3Autre puce, comme l'ESP32-S3 ? Choisis l'entrée qui porte son nom.
Touche le schéma pour l’ouvrir en plein écran.

É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 :

  1. 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.
  2. Relie la broche repérée 26 à une extrémité de la résistance de 220 Ω avec un fil.
  3. 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].
  4. 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.

DEL sur la GPIO 26 à travers une résistance de 220 ohms Vue de dessus d'une plaque d'essai avec la DevKitC à cheval sur la rainure centrale, USB à gauche, ses broches 26 et GND sur la rangée du haut. Le fil 1, vert, va du trou à côté de la broche 26 à la rangée 24. La résistance de 220 ohms relie la rangée 24 à la rangée 28. La patte longue de la DEL, l'anode, marquée plus, est en rangée 28 ; sa patte courte, la cathode, en rangée 29. Le fil 2, noir, revient de la rangée 29 au trou à côté d'une broche GND. En dessous, le même circuit en schéma : GPIO 26, résistance de 220 ohms, DEL, masse ; environ 6 mA circulent quand la broche est à HIGH, 3,3 V. FIG. 8 — DEL SUR LA GPIO 26+−−+jihgfedcba15101520242832ENBOOT5VCMDD3D213GND121427262533323534VNVPEN3V3220 Ω+DEL121vert : GPIO 26 → rangée 242noir : rangée 29 → GNDDEL : patte longue (+, anode) en rangée 28 · patte courte (−, côté plat) en rangée 29.Les trous f à j d'une même rangée sont reliés dedans : les pièces d'une même rangée se touchent.Câble carte débranchée.Le même circuit en schémaGPIO 26220 ΩI(3,3 − 2) ÷ 220≈ 0,006 A = 6 mAHIGH = 3,3 V
Touche le schéma pour l’ouvrir en plein écran.

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. LOW la 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].

La roue setup/loop
La roue setup/loop Interactif. À gauche, le programme Blink avec la ligne en cours en surbrillance. À droite, setup() est en dehors d'une roue : il s'exécute une fois. La roue contient les quatre lignes de loop() : broche 26 à HIGH, attendre 500 ms, broche 26 à LOW, attendre 500 ms, puis retour en haut, sans fin. Le centre montre l'état de la DEL et la tension de la broche à chaque étape. Utilise Pas suivant pour avancer d'une ligne à la fois. FIG. W1 — SETUP() UNE FOIS, LOOP() SANS FINconst int LED_PIN = 26;void setup() {  pinMode(LED_PIN, OUTPUT);}void loop() {  digitalWrite(LED_PIN, HIGH);  delay(500);  digitalWrite(LED_PIN, LOW);  delay(500);}setup()une seule foisaprès mise soustension ou resetHIGH500 msLOW500 msloop() tourne encore et encoreDEL éteinteGPIO 26 = 0 VLa carte démarre (mise sous tension ou reset).tour de loop(): 0

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

  1. 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].
  2. 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].
  3. Surveille la console. Au début du téléversement, elle affiche Connecting suivi 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.

Téléverser, et que faire si ça bloque sur Connecting Trois panneaux. Panneau 1 : après un clic sur téléverser, la console affiche Connecting suivi de points ; les points veulent dire que l'ordinateur essaie encore de joindre la puce. Panneau 2, la méthode simple : maintiens le bouton BOOT enfoncé pendant le téléversement. Panneau 3, la méthode manuelle : maintiens BOOT, appuie une fois sur EN, puis relâche BOOT ; la puce est en mode téléchargement, lance le téléversement. FIG. 9 — TÉLÉVERSER1téléverserOutputSerial port COM3Connecting......points = ça essaie encoreSi ça finit en « Failed to connect »,utilise le bouton BOOT →2Méthode simpleENBOOTMaintiens BOOT pendanttout le téléversement.3Méthode manuelleENBOOT211maintiens BOOT2appuie une fois sur EN3relâche BOOT, téléverse
Touche le schéma pour l’ouvrir en plein écran.

É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].

Moniteur série à 115200 bauds Dessin simplifié du panneau du bas de l'IDE avec l'onglet Serial Monitor ouvert. Les lignes affichent Hello from my ESP32! Count: 0, puis 1, puis 2, une par seconde. En bas à droite, la liste de vitesse est réglée sur 115200 baud, entourée ; une flèche la relie à la ligne Serial.begin(115200) du programme : les deux doivent correspondre, sinon tu vois des symboles bizarres. FIG. 10 — MONITEUR SÉRIEdans ton programmeSerial.begin(115200);bouton du moniteur sérieen haut à droite de l'IDEOutputSerial Monitor ×Message (Enter to send)New Line115200 baudHello from my ESP32! Count: 0Hello from my ESP32! Count: 1Hello from my ESP32! Count: 2…une nouvelle ligne chaque secondeLes deux doivent dire 115200, sinon tu vois des symboles bizarres.doit correspondre
Touche le schéma pour l’ouvrir en plein écran.

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.

  1. 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].

  2. 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
    Voir la réponse

    La vitesse (baud) du moniteur ne correspond pas à celle du programme. Les deux côtés d’une liaison série doivent utiliser la même vitesse. Sinon, le récepteur ne reçoit que du charabia [11]. Notre programme utilise 115200, donc le moniteur doit afficher 115200 aussi [5].

  3. 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
  1. 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
  2. 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/
  3. 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/
  4. 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/
  5. 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
  6. 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
  7. 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
  8. 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
  9. 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
  10. 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
  11. 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
  12. Arduino, « Arduino Sketches » (un sketch est un programme ; setup() et loop() ; pinMode, digitalWrite, delay ; millisecondes) — https://docs.arduino.cc/learn/programming/sketches/
  13. 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/
  14. 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/
  15. 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/
  16. 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
  17. 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

Pince ou touche deux fois pour zoomer, glisse pour changer de schéma.Molette avec Ctrl ou double-clic pour zoomer. Les flèches changent de schéma.