Que diriez vous d’intégrer un module ESP32 dans vos prochains montages électroniques ? D’autant plus que cela ne requiert que quelques composants autour, et un simple connecteur pour la programmation ! Pour preuve, voici un exemple de carte de base avec microcontrôleur ESP32-S3-WROOM-1, avec tout le minimum nécessaire, et des connecteurs de tests 🙂
Cela servira par ailleurs à tester le programmateur d’ESP32 que je vous avais publié dernièrement, un convertisseur USB/UART permettant d’uploader des programmes dans les ESP32 en filaire, pour être plus exact ! Cela étant dit, nous irons plus loin ici, en voyant non seulement comment programmer un ESP32 via son port UART, mais aussi comment le programmer sans fil, en OTA (de l’anglais « Over The Air »). Ça vous dit ? Alors par ici la suite !
Remarque : tout ce contenu est partagé à titre indicatif, pour vous faire découvrir les SoC ESP32-S3, et leur intégration sur un simple PCB double couche. Cela ne cherche donc pas à rivaliser avec tout ce qu’on trouve en vente sur internet, où c’est bien moins cher, et déjà tout prêt ! Ici, comme vous l’aurez compris, c’est pour apprendre l’électronique, par la pratique. Cela étant dit, cette carte n’est toutefois pas qu’une simple carte de démo, car c’est une véritable mini carte de développement, permettant de faire des tests, avec des fils dupont par exemple, tout comme vous pourriez le faire avec un Arduino Uno ou autre. Alors laissez vous tenter par la découverte de cette carte 😉
Présentation de cette carte de test ESP32
Comme évoqué en intro, cette carte est avant tout faite pour vous montrer comment mettre en œuvre un SoC ESP32 (SOC voulant dire « System on Chip », en anglais, c’est à dire un système complet sur une puce). Autrement dit, je parle ici des modules ESP32 « prêts à souder », qu’on peut implanter sur nos PCB. Ces modules sont reconnaissables par leur « enveloppe métallique brillante » (shield / blindage RF), et leur antenne interne (ou connecteur d’antenne externe) qui en ressort, comme visible ci-dessous :
À noter que cette carte ESP32-S3 dispose :
- une prise d’alimentation micro-USB, pour fournir l’énergie à la carte (c’est du « power only », comme on dit, donc pas faite pour véhiculer des signaux de données, et par conséquence, pas faite pour programmer les ESP32)
- un connecteur de programmation UART, adapté au convertisseur USB/UART pour ESP32 avec auto-boot et auto-reset que je vous avais présenté il y a peu, bien que vous pourriez y brancher n’importe quel autre modèle d’adaptateur USB ↔ UART fonctionnant en 3,3V, si vous en avez, via fils dupont
- des connecteurs pour lignes d’entrées/sorties (input/output, en anglais) notées IO0 à IO47, sur la photo
- un bouton nommé « BOOT », permettant de faire entrer l’ESP32 manuellement en mode programmation, en suivant une séquence particulière (remarque : ce bouton est inutile si vous vous servez d’un programmateur ESP32 avec auto-boot, comme je vais utiliser ici)
- un bouton nommé « RESET », pour faire redémarrer l’ESP32, au besoin
- un module ESP32-S3-WROOM-1 (plus précisément ici, il s’agit du modèle ESP32-S3-WROOM-1-N8, mais tout autre modèle de la famille, tel que le ESP32-S3-WROOM-1-N16R8, aurait pu convenir, comme nous allons le voir juste après)
- et des connecteurs de sortie d’alimentation, notés +5V (issu de la prise USB, lorsque celle-ci est raccordée), +3V3 (sortant du régulateur de tension, embarqué sur cette carte), et GND
L’idée, derrière cette carte, est de vous montrer une configuration minimale, pour faire tourner un module ESP32 sur une carte PCB. Bien sûr, au-delà de ça, les connecteurs d’entrées/sorties et d’alim en font une véritable carte de développement, à l’image d’une carte Arduino ou autre, mais en plus simple, et faite pour apprendre l’électronique 🙂
Nota : cette carte ESP32-S3 peut simplement être alimentée par la prise de programmation UART (uniquement, j’entends), du moment où on ne dépasse pas le courant max qu’elle peut fournir (500 mA, par exemple). Par contre, dans ce cas, le connecteur « 5V_USB » de la carte ESP32 ne délivrera aucune tension, du fait que le programmateur d’ESP32 (convertisseur USB/UART) fonctionne/fournit en 3,3 volts uniquement. Du coup, c’est seulement quand la prise micro-USB est branchée qu’une tension de 5V apparaît sur le connecteur +5V de la carte.
Liste des ESP32-S3-WROOM-1 intégrables sur cette carte de développement
Cette carte de développement ESP32-S3 peut accepter différents modèles de modules ESP32, à savoir :
| Modèle | Qté de mémoire Flash | Qté de PSRAM |
|---|---|---|
| ESP32-S3-WROOM-1-N4 | 4 MB Flash | Sans PSRAM |
| ESP32-S3-WROOM-1-N8 | 8 MB Flash | Sans PSRAM |
| ESP32-S3-WROOM-1-N16 | 16 MB Flash | Sans PSRAM |
| ESP32-S3-WROOM-1-N4R2 | 4 MB Flash | 2 MB PSRAM |
| ESP32-S3-WROOM-1-N8R2 | 8 MB Flash | 2 MB PSRAM |
| ESP32-S3-WROOM-1-N4R8 | 4 MB Flash | 8 MB PSRAM |
| ESP32-S3-WROOM-1-N8R8 | 8 MB Flash | 8 MB PSRAM |
| ESP32-S3-WROOM-1-N16R8 | 16 MB Flash | 8 MB PSRAM |
À noter que toutes ces versions de l’ESP32-S3-WROOM-1 (N4, N8, N16, N4R2, N8R2, N4R8, N8R8, N16R8) :
- partagent le même brochage/pinout (41 broches, assignées de la même manière)
- partagent le même footprint (empreinte du composant sur le PCB), avec une dimensions de 18 mm x 25,5 mm x 3,1 mm (largeur x profondeur x hauteur), et un pas de 1,27 mm entre broches
Remarque : il faut savoir qu’il existe le ESP32-S3-WROOM-1, disposant d’une antenne PCB intégrée, et le ESP32-S3-WROOM-1U, disposant d’un connecteur IPEX pour une antenne externe. Le premier mesure 18 × 25.5 × 3.1 mm, comme vu juste avant, et le deuxième mesure 18 × 19.2 × 3.2 mm ; ce dernier a donc la même empreinte, mais est plus court en profondeur (ce qui est normal, car pour le deuxième, il n’y a pas d’antenne intégrée). Si je parle de ça, c’est simplement pour dire que, techniquement parlant, on pourrait très bien souder (sur la carte PCB que je vous présente ici) des modèles ESP32-S3-WROOM-1U (avec antenne externe), plutôt que des ESP32-S3-WROOM-1 (avec antenne intégrée, donc).
Schéma électronique + liste des composants
Voici donc le schéma électronique de cette carte de test ESP32-S3 (vous trouverez une version « plus nette » vers la fin de cet article, en PDF, dans la rubrique « liens et téléchargements ») :
Comme à l’accoutumée, j’ai divisé ce schéma en plusieurs blocs, à savoir :
- un bloc « Connecteur prog (UART) », qui représente en fait le connecteur où viendra se brancher le programmateur d’ESP32 UART, avec lignes pour autoreset / autoboot, au besoin
- un bloc « Filtrage/découplage ESP32 », qui rassemble les condensateurs de filtrage et découplage du module ESP32 installé sur cette carte
- un bloc « Led embarquée (IO48) », qui, comme son nom l’indique, est une LED mise à disposition sur le PCB, avec un raccordement sur la broche GPIO 48 de l’ESP32
- un bloc « Microcontrôleur (ESP32-S3-WROOM-1) », qui, plus exactement, contient simplement le SoC ESP32 en lui-même (module prêt à souder sur PCB, donc), en sachant que plusieurs modèles sont compatibles ici, sur cette carte de démo ESP32 (la liste étant énumérée sur le schéma électronique ci-dessus)
- un bloc « Boot manuel ESP32 », qui est un exemple de branchement basique de bouton-poussoir BOOT manuel, si jamais votre programmateur d’ESP32 n’a pas de fonction autoboot
- un bloc « Reset manuel ESP32 », qui est là aussi un exemple de configuration typique de RESET manuel, pour que l’ESP32 soit « proprement » réinitialisé, au besoin
- un bloc « Alimentation USB (power only) », qui, comme son nom le suggère, est une alimentation qui tire son énergie de la prise USB, éventuellement branchée sur cette carte. À noter que le « power only » est là pour insister sur le fait que cet accès USB fournirait que de l’énergie, mais jamais de données USB (no data). Ainsi donc, il ne sera pas possible ici de programmer l’ESP32 via cette prise micro-USB, pour être tout à fait clair. Ici, sur cette carte, la programmation ne pourra se faire qu’en UART, via le connecteur présent en haut/à gauche du schéma. Remarque technique : j’ai déjà détaillé cette alimentation variable, permettant de fournir fournir du 3,0 à 3,6V, selon la charge/courant tiré dessus (avec du +3,3V typique, pour un courant d’environ 100 mA) ; je ne vais donc pas la détailler à nouveau ici, mais vous renvoie vers ce lien
- un bloc « Sorties ‘Carte ESP32′ », qui est ni plus ni moins qu’un ensemble de connecteurs, permettant de partager des lignes d’entrées/sorties (GPIO) de l’ESP32, ainsi que des points d’accès aux alims 5V et 3,3V
En somme, rien de bien compliqué !
Du reste, au niveau des composants, voici leurs caractéristiques en détail, avec des liens d’achats pour ceux que ça intéressent :
Voilà pour la partie schéma ! À présent, passons à la partie réalisation pratique !
Circuit imprimé (PCB)
Côté circuit imprimé, on retrouve un simple PCB double face, avec les composants électroniques à souder sur le dessus, et un plan de masse en dessous, comme visible ci-dessous :
À noter que, hormis les connecteurs (micro USB et pin sockets), tous les composants électroniques sont de type CMS (composants montés en surface).
Perso, j’ai soudé les composants CMS sur une plaque chauffante réglable en température (40°C ↔ 260°C), en utilisant de la pâte à souder étain/bismuth, basse température donc (Sn42/Bi58, pour être plus précis, dont le point de fusion est aux alentours de 138°C). Histoire que vous puissiez bien visualiser ce dont je parle, voici une photo prise juste après brasage, sur la table chauffante :
Remarque 1 : les soudures que vous voyez là ont été retouchées manuellement au fer à souder, surtout au niveau de l’ESP32. En effet, des « ponts de soudure » peuvent parfois apparaître après soudage, surtout au niveau des CMS qui ont des broches très rapprochées, comme c’est le cas ici sur le module ESP32 ; dans ce cas, j’ai simplement « badigeonné » de flux les pins du SoC ESP32, et ai passé un coup de fer à souder à « panne large » en glissant dessus, pour que la pâte à braser se fixe uniquement sur les broches, ou sur la panne en elle-même (qui récupère l’excès de soudure, du coup). Ainsi, on obtient un résultat plus propre (une fois nettoyé à l’alcool isopropylique), et sans court-circuit (à vérifier tout de même à la loupe, ou mieux, avec un petit microscope ; c’est impératif !)
Remarque 2 : une autre approche pour souder le SoC ESP32 est de mettre uniquement de la pâte à braser dessous/au centre, pour souder uniquement le gros pad central inférieur, via la table chauffante ; puis de finir ensuite le soudage en pourtour, avec un fer à souder à panne fine (et enfin, comme dit précédemment, retirer les ponts de soudure avec flux + repassage avec panne plus large, si besoin)
À partir de là, il ne reste plus qu’à souder tous les connecteurs (header femelle et prise USB), au fer à souder électronique, manuellement. Du coup, voici ce qu’on obtient, au final :
Encore une fois, vérifiez bien qu’il n’y ait visuellement pas le moindre court-circuit, à l’aide d’une loupe, ou mieux, d’un microscope. Ensuite, si tout paraît bon, vous pourrez brancher un câble USB sur la prise micro-USB de cette carte pour l’alimenter, tout en vérifiant qu’il n’y ait pas le moindre échauffement anormal ; perso, pour cela, j’utilise une caméra thermique portable, en surveillant bien l’ensemble du PCB pendant une minute ou deux, environ (à noter que le régulateur AMS1117 va chauffer un peu, ce qui est tout à fait normal, du fait que l’ESP32-S3-WROOM-1 va tirer du courant dessus, même en l’absence de programme à l’intérieur).
Préparation matérielle/logicielle, avant upload du programme
Maintenant que la carte ESP32 de test/dev est prête, il va falloir la préparer à être programmée (indispensable pour uploader les 3 exemples de code qui suivront). Pour cela, deux choses sont à faire au préalable, à savoir :
- brancher un programmateur ESP32 sur la carte ESP32
- installer (si ce n’est pas déjà fait) le « package de cartes ESP32 » dans Arduino IDE, pour ensuite avoir tous les outils internes pour les programmer
Branchement d’un programmateur d’ESP32 (adaptateur USB/UART)
Tout d’abord, il faudra se munir d’un programmateur ESP32. Pour ma part, j’utilise le convertisseur USB/UART avec auto-boot / auto-reset que j’avais précédemment réalisé, et qu’il suffit d’embrocher sur la carte ESP32 perpendiculairement, comme ceci (l’autre extrémité du câble USB du convertisseur étant relié au PC) :
Remarque : faites très attention au sens de branchement du programmateur ESP32, sinon vous risquez de tout endommager (car il n’y a pas de détrompeur, ici). Pour éviter toute inversion à ce niveau, vérifier simplement que les écritures, côté programmateur et côté carte ESP32, soient bien en face les unes des autres (c’est à dire : le GND en face du GND, et le +3,3V en face du +3,3V). À noter que seules deux lignes UART ne correspondront pas au niveau de leurs libellés, à savoir RX et TX (ce qui est parfaitement normal, du fait que dans une communication UART, les lignes TX et RX sont croisées ; donc le TX de l’un rentre dans le RX de l’autre, et vice-versa).
Cela étant fait, passons maintenant à la partie logicielle !
Configuration de l’IDE Arduino, pour pouvoir programmer des cartes ESP32 ensuite
Ici, nous allons travailler avec Arduino IDE. Et comme cet environnement de développement n’inclut pas nativement les cartes ESP32, il va falloir les installer dessus (ça se fait en 2 étapes seulement, rassurez-vous !).
En premier, il va falloir :
- aller dans les paramètres d’Arduino IDE (en cliquant sur Fichier > Préférences)
- ajouter l’url « https://espressif.github.io/arduino-esp32/package_esp32_index.json » dans le champ « URL de gestionnaire de cartes supplémentaires »
- puis cliquer sur « OK » pour enregistrer les changements
Au passage, en image, voici à quoi ressemble cette fenêtre de paramétrage Arduino :
Une fois fait, il va ensuite falloir aller dans le gestionnaire de carte de l’IDE Arduino (en cliquant sur Outils > Carte > Gestionnaire de cartes), et taper « espressif » dans le champ de recherche, pour voir le package « ESP32 par Espressif Systems » s’afficher à l’écran. Enfin, il faudra cliquer sur « Installer » pour installer toutes les cartes (boards) ESP32 du fabricant Espressif dans Arduino IDE, afin qu’elles soient dorénavant reconnues et utilisables. En image, voici où trouver le gestionnaire de carte, comment retrouver ces cartes ESP32, et comment les installer :
Remarque : cette opération peut prendre beaucoup de temps (vraiment beaucoup si votre PC est « ancien »), donc soyez patient ! Et surtout, n’interrompez pas le processus, et laissez l’installation se faire jusqu’au bout ! Sinon, vous risqueriez de corrompre des fichiers, ou avoir des bugs inexpliqués.
Voilà ! Vous êtes à présent fin prêt, pour pouvoir programmer des cartes ESP32, via Arduino IDE 🙂
Test #1 : exemple de code pour programmation ESP32 en filaire (via adaptateur USB/UART)
Le premier exemple de test ESP32 que nous allons voir ici, une fois les préparatifs du paragraphe précédent terminés, va permettre de :
- vous montrer comment programmer cette carte ESP32 S3 de test / développement, via l’adaptateur USB ↔ UART (en filaire, donc)
- et vous montrer comment téléverser un programme Arduino (via l’IDE Arduino), pour faire clignoter (blink) la LED présente sur cette carte ESP32
Tout d’abord, voyons le code, pour ce blink tout simple !
/*
______ _ _///_ _ _ _
/ _ \ (_) | ___| | | | (_)
| [_| |__ ___ ___ _ ___ _ __ | |__ | | ___ ___| |_ _ __ ___ _ __ _ ___ _ _ ___
| ___/ _ \| __|| __| |/ _ \| '_ \_____| __|| |/ _ \/ _| _| '__/ \| '_ \| |/ \| | | |/ _ \
| | | ( ) |__ ||__ | | ( ) | | | |____| |__ | | __/| (_| |_| | | (_) | | | | | (_) | |_| | __/
\__| \__,_|___||___|_|\___/|_| [_| \____/|_|\___|\____\__\_| \___/|_| |_|_|\__ |\__,_|\___|
| |
\_|
Fichier : prg1-upload-UART-et-test-blink-IO48.ino
Dépôt : https://github.com/PassionElectronique/Programmes-tests-ESP32-Simple-Dev-Board
Description : Programme permettant de faire clignoter une LED branchée sur la broche IO48,
à une fréquence de 1 hertz
Licence : BY-NC-ND 4.0 CC (https://creativecommons.org/licenses/by-nc-nd/4.0/deed.fr)
Remarque : Téléchargement via adaptateur USB/UART + auto-boot/auto-reset
Auteur : Jérôme TOMSKI (https://passionelectronique.fr/)
Créé le : 31.10.2025
*/
// Définition de la broche utilisée ici
#define BROCHE_LED 48 // Led branchée sur pin GPIO 48
// ========================
// Initialisation programme
// ========================
void setup() {
// Configure la broche "led" en sortie
pinMode(BROCHE_LED, OUTPUT);
}
// =================
// Boucle principale
// =================
void loop() {
// Allume la LED, puis attend une demi seconde
digitalWrite(BROCHE_LED, HIGH);
delay(500);
// Éteint la LED, puis attend une demi seconde
digitalWrite(BROCHE_LED, LOW);
delay(500);
}Jusque là, rien de bien compliqué, me direz vous ! Il est juste à noter que la LED est physiquement branchée à la broche GPIO 48 sur la carte ESP32-S3, c’est pourquoi la valeur « 48 » figure dans ce programme.
Maintenant, voyons comment uploader ce bout de code arduino dans la carte de test ESP32 !
Tout d’abord, il faudra s’assurer que le programmateur d’ESP32 (convertisseur USB/UART) soit bien enfiché sur la carte de développement ESP32, et que le programmateur soit relié à votre ordi via un câble USB.
Ensuite, côté Arduino IDE, il faudra aller dans le menu Outils, et paramétrer plusieurs choses, à savoir :
- le type de carte : « ESP32S3 Dev Module »
- le port COM associé au convertisseur USB/UART (dans mon cas, il s’agissait du port COM3)
- la taille de la mémoire flash du module ESP32 soudé sur la carte (de mon côté, j’ai sélectionné 8MB, car le SoC soudé sur ma carte était un ESP32-S3-WROOM-1-N8, le « N8 » signifiant 8 Mo de mémoire flash)
- le partitionnement (perso, j’ai simplement sélectionné « Default 4MB with spiffs »)
- et la taille de la PSRAM (que j’ai mis sur « Disabled » de mon côté, car il n’y avait pas de PSRAM sur mon SoC ESP32 ; mais si par exemple j’avais soudé un ESP32-S3-WROOM-1-N16R8, alors il aurait fallut sélectionner « 8MB » pour être conforme)
En image, voici à quoi ressemble le menu Outils de Arduino IDE, pour une carte ESP32-S3 de développement :
Du reste, il ne reste plus qu’à cliquer sur le bouton téléverser d’Arduino IDE, pour que le programme soit transféré de votre ordi, en passant par l’adaptateur USB/UART, au module ESP32 soudé sur la carte.
Pour info, côté console arduino, vous devriez avoir quelque chose qui ressemble à cela (montrant la compilation puis upload du code dans l’ESP32) :
Le croquis utilise 298551 octets (22%) de l'espace de stockage de programmes. Le maximum est de 1310720 octets.
Les variables globales utilisent 20648 octets (6%) de mémoire dynamique, ce qui laisse 307032 octets pour les variables locales. Le maximum est de 327680 octets.
"C:\Users\JEROME\AppData\Local\Arduino15\packages\esp32\tools\esptool_py\5.1.0/esptool.exe" --chip esp32s3 --port "COM3" --baud 921600 --before default-reset --after hard-reset write-flash -z --flash-mode keep --flash-freq keep --flash-size keep 0x0 "C:\Users\JEROME\AppData\Local\arduino\sketches\925A10184293DEB9E6E4EBF95DC13D2D/prg1-upload-UART-et-test-blink-IO48.ino.bootloader.bin" 0x8000 "C:\Users\JEROME\AppData\Local\arduino\sketches\925A10184293DEB9E6E4EBF95DC13D2D/prg1-upload-UART-et-test-blink-IO48.ino.partitions.bin" 0xe000 "C:\Users\JEROME\AppData\Local\Arduino15\packages\esp32\hardware\esp32\3.3.2/tools/partitions/boot_app0.bin" 0x10000 "C:\Users\JEROME\AppData\Local\arduino\sketches\925A10184293DEB9E6E4EBF95DC13D2D/prg1-upload-UART-et-test-blink-IO48.ino.bin"
esptool v5.1.0
Serial port COM3:
Connecting....
Connected to ESP32-S3 on COM3:
Chip type: ESP32-S3 (QFN56) (revision v0.2)
Features: Wi-Fi, BT 5 (LE), Dual Core + LP Core, 240MHz
Crystal frequency: 40MHz
MAC: 30:ed:a0:0e:ee:14
Uploading stub flasher...
Running stub flasher...
Stub flasher running.
Changing baud rate to 921600...
Changed.
Configuring flash size...
Flash will be erased from 0x00000000 to 0x00004fff...
Flash will be erased from 0x00008000 to 0x00008fff...
Flash will be erased from 0x0000e000 to 0x0000ffff...
Flash will be erased from 0x00010000 to 0x00058fff...
Compressed 20224 bytes to 13061...
Writing at 0x00000000 [ ] 0.0% 0/13061 bytes...
Writing at 0x00004f00 [==============================] 100.0% 13061/13061 bytes...
Wrote 20224 bytes (13061 compressed) at 0x00000000 in 0.3 seconds (535.3 kbit/s).
Hash of data verified.
Compressed 3072 bytes to 146...
Writing at 0x00008000 [ ] 0.0% 0/146 bytes...
Writing at 0x00008c00 [==============================] 100.0% 146/146 bytes...
Wrote 3072 bytes (146 compressed) at 0x00008000 in 0.0 seconds (1037.2 kbit/s).
Hash of data verified.
Compressed 8192 bytes to 47...
Writing at 0x0000e000 [ ] 0.0% 0/47 bytes...
Writing at 0x00010000 [==============================] 100.0% 47/47 bytes...
Wrote 8192 bytes (47 compressed) at 0x0000e000 in 0.0 seconds (1344.5 kbit/s).
Hash of data verified.
Compressed 298704 bytes to 162052...
Writing at 0x00010000 [ ] 0.0% 0/162052 bytes...
Writing at 0x0001befe [==> ] 10.1% 16384/162052 bytes...
Writing at 0x00028a48 [=====> ] 20.2% 32768/162052 bytes...
Writing at 0x0002e303 [========> ] 30.3% 49152/162052 bytes...
Writing at 0x000340f5 [===========> ] 40.4% 65536/162052 bytes...
Writing at 0x00039914 [==============> ] 50.6% 81920/162052 bytes...
Writing at 0x0003f352 [=================> ] 60.7% 98304/162052 bytes...
Writing at 0x00044ce8 [====================> ] 70.8% 114688/162052 bytes...
Writing at 0x0004d7c7 [=======================> ] 80.9% 131072/162052 bytes...
Writing at 0x0005368d [==========================> ] 91.0% 147456/162052 bytes...
Writing at 0x00058ed0 [==============================] 100.0% 162052/162052 bytes...
Wrote 298704 bytes (162052 compressed) at 0x00010000 in 2.4 seconds (985.3 kbit/s).
Hash of data verified.
Hard resetting via RTS pin...Et côté carte ESP32-S3, vous devriez voir la LED embarquée clignoter comme ceci :
Voilà pour la programmation filaire, utilisant le port UART de l’ESP32 ! Maintenant, abordons la partie sans fil 🙂
Test #2 : exemple de script OTA de base (programme « over the air », pour prochain upload en « sans fil »)
À présent, voyons comment envisager/préparer un upload sans fil( aussi appelée programmation « over the air » en anglais, ou « OTA » en abrégé) pour notre ESP32 ! En fait, pour programmer un ESP32 sans fil, il faut tout d’abord implanter en filaire un programme capable de gérer ensuite une programmation sans-fil.
En résumé :
- il faudra tout d’abord envoyer EN FILAIRE un programme servant à prendre en charge l’OTA
- pour ensuite pouvoir envoyer EN SANS FIL (en WiFi par exemple) un programme quelconque
Ici, je vais vous montrer un exemple de « programme de base OTA » (qu’il faudra uploader en filaire dans votre ESP32), qui permettra de gérer une programmation sans fil la fois suivante, si souhaité.
Juste une petite subtilité ici : si vous écrasez ce « programme OTA » par un autre programme ne gérant pas l’OTA (transmis en filaire ou en sans-fil, peu importe), alors vous ne pourrez plus programmer votre ESP32 en sans fil. Donc dans ce cas, si vous souhaitez à nouveau programmer votre ESP32 en « sans fil », alors il faudra réinjecter ce programme OTA en filaire, via l’interface UART, pour ensuite pouvoir à nouveau faire de la programmation sans fil. Du reste, dans l’exemple « Test #3 », nous verrons comment intégrer l’OTA à un programme blink (ou tout autre programme), afin de maintenir l’accès à la programmation sans fil ouvert, de manière persistante.
Voici donc un exemple de programme de base (à uploader en filaire), pour que votre ESP32 puisse juste après être programmé en « sans fil » :
/*
______ _ _///_ _ _ _
/ _ \ (_) | ___| | | | (_)
| [_| |__ ___ ___ _ ___ _ __ | |__ | | ___ ___| |_ _ __ ___ _ __ _ ___ _ _ ___
| ___/ _ \| __|| __| |/ _ \| '_ \_____| __|| |/ _ \/ _| _| '__/ \| '_ \| |/ \| | | |/ _ \
| | | ( ) |__ ||__ | | ( ) | | | |____| |__ | | __/| (_| |_| | | (_) | | | | | (_) | |_| | __/
\__| \__,_|___||___|_|\___/|_| [_| \____/|_|\___|\____\__\_| \___/|_| |_|_|\__ |\__,_|\___|
| |
\_|
Fichier : prg2-upload-UART-du-programme-de-prog-OTA.ino
Dépôt : https://github.com/PassionElectronique/Programmes-tests-ESP32-Simple-Dev-Board
Description : Programme permettant ensuite d'uploader d'autres programmes via le WiFi,
c'est à dire en "mode sans fil" (aussi nommé "OTA" en anglais, pour "over the air")
Licence : BY-NC-ND 4.0 CC (https://creativecommons.org/licenses/by-nc-nd/4.0/deed.fr)
Remarque : Téléchargement via adaptateur USB/UART + auto-boot/auto-reset
Auteur : Jérôme TOMSKI (https://passionelectronique.fr/)
Créé le : 01.11.2025
*/
// Inclusion des librairies nécessaires
#include <WiFi.h>
#include <ArduinoOTA.h>
// Codes WiFi (box internet)
const char* ssid_WiFi = "SSID_WIFI";
const char* mot_de_passe_WiFi = "MOT_DE_PASSE_WIFI";
// Codes OTA (permettant l'upload ultérieur de programmes dans l'ESP32, via le WiFi)
const char* nom_OTA = "Mon-ESP32-S3-OTA";
const char* mot_de_passe_OTA = "mdp-OTA";
// ========================
// Initialisation programme
// ========================
void setup() {
// -----------------------------------------------------------------------------------------------------------------
// Configuration de base ESP32/WiFi
// -----------------------------------------------------------------------------------------------------------------
// Ouverture du port série
Serial.begin(115200);
Serial.print("\n\n");
Serial.print("=== ESP32-S3 OTA Boot ===");
Serial.print("\n");
// Connexion au WiFi
WiFi.begin(ssid_WiFi, mot_de_passe_WiFi);
Serial.print("Connexion à "); Serial.print(ssid_WiFi);
// Attente confirmation WiFi connecté
while (WiFi.status() != WL_CONNECTED) {
delay(200);
Serial.print("."); // On affiche des "." toutes les 200 ms, en attendant la connexion
}
Serial.println("");
// Affichage adresse IP, pour confirmer connexion WiFi
Serial.println("WiFi connecté !");
Serial.print("Adresse IP : "); Serial.println(WiFi.localIP());
// -----------------------------------------------------------------------------------------------------------------
// Configuration de l'OTA
// -----------------------------------------------------------------------------------------------------------------
// Configuration de l'OTA
ArduinoOTA.setHostname(nom_OTA); // Nom qui apparaîtra dans la liste des ports COM d'Arduino IDE, une fois ce programme chargé dans l'ESP32
ArduinoOTA.setPassword(mot_de_passe_OTA); // Mot de passe OTA (optionnel, car on aurait très bien pu ne pas en mettre, en fait)
// Fonction OTA s'exécutant au démarrage de l'upload
ArduinoOTA.onStart([]() {
String type = (ArduinoOTA.getCommand() == U_FLASH) ? "sketch" : "filesystem";
Serial.println("Début upload OTA : " + type);
});
// Fonction OTA s'exécutant à la fin de l'upload
ArduinoOTA.onEnd([]() {
Serial.println(""); Serial.println("OTA terminé ! Redémarrage...");
});
// Fonction OTA s'exécutant pendant l'upload
ArduinoOTA.onProgress([](unsigned int progression, unsigned int total) {
static int dernierPourcentage = -1;
int pourcentage_d_avancement = (progression * 100) / total;
if (pourcentage_d_avancement != dernierPourcentage && pourcentage_d_avancement % 10 == 0) {
Serial.printf("Progression : %u%%\r", pourcentage_d_avancement);
dernierPourcentage = pourcentage_d_avancement;
}
});
// Fonction OTA s'exécutant lors d'une erreur
ArduinoOTA.onError([](ota_error_t code_erreur) {
Serial.printf("Erreur OTA[%u] : ", code_erreur);
if (code_erreur == OTA_AUTH_ERROR) Serial.println("Échec d'authentification");
else if (code_erreur == OTA_BEGIN_ERROR) Serial.println("Échec de démarrage");
else if (code_erreur == OTA_CONNECT_ERROR) Serial.println("Échec de connexion");
else if (code_erreur == OTA_RECEIVE_ERROR) Serial.println("Échec lors de la réception");
else if (code_erreur == OTA_END_ERROR) Serial.println("Échec de fin OTA");
});
// -----------------------------------------------------------------------------------------------------------------
// Démarrage de l'OTA
// -----------------------------------------------------------------------------------------------------------------
ArduinoOTA.begin();
Serial.println("");
Serial.println("----------");
Serial.println("OTA prêt !");
Serial.println("----------");
Serial.println("");
Serial.print("Remarque : ensuite, pour uploader un programme ESP32 via le WiFi, il faudra aller dans le menu 'Outils' d'Arduino IDE,\n");
Serial.print(" et sélectionner le port COM nommé '"); Serial.print(nom_OTA); Serial.print(" at "); Serial.print(WiFi.localIP()); Serial.println("'");
Serial.println("");
}
// =================
// Boucle principale
// =================
void loop() {
// Maintien de l'OTA actif en permanence, pour gérer les uploads
ArduinoOTA.handle();
}Ici, je ne vais pas vous détailler le programme, car il n’a pas grand intérêt à être compris, pour le présent usage.
Par contre, pour que ce programme fonctionne, il faudra impérativement remplacer les codes WiFi par les vôtres, dans les variables « ssid_WiFi » et « mot_de_passe_WiFi » (ceux-ci étant fournis avec votre box internet, si vous en avez une, par exemple). Du reste, la variable « nom_OTA » indique simplement comment s’appellera votre carte ESP32 sur votre réseau WiFi, et la variable « mot_de_passe_OTA » est un mot de passe (optionnel) permettant de sécuriser votre accès sans fil OTA.
Pour uploader ce bout de code arduino, il faudra procéder de la même façon que pour le « Test #1 », présenté auparavant. Et si tout se passe bien, vous devriez obtenir quelque chose ressemblant à cela, sur le moniteur série d’Arduino IDE, une fois ce programme uploadé :
13:14:20.028 ->
13:14:20.028 ->
13:14:20.028 -> === ESP32-S3 OTA Boot ===
13:14:20.074 -> Connexion à NomBoxInternet-ZZZZ..........
13:14:22.036 -> WiFi connecté !
13:14:22.036 -> Adresse IP : 192.168.1.17
13:14:22.077 ->
13:14:22.077 -> ----------
13:14:22.077 -> OTA prêt !
13:14:22.077 -> ----------
13:14:22.077 ->
13:14:22.077 -> Remarque : ensuite, pour uploader un programme ESP32 via le WiFi, il faudra aller dans le menu 'Outils' d'Arduino IDE,
13:14:22.077 -> et sélectionner le port COM nommé 'Mon-ESP32-S3-OTA at 192.168.1.17'
13:14:22.077 -> Du reste, pour confirmer la bonne marche du programme OTA, ouvrez le menu Outils de l’IDE Arduino, entrez dans le menu « Port », et vérifiez qu’un accès OTA est désormais accessible, avec le nom qui lui a été donné dans le programme OTA. Si tel est le cas, cela apparaît de la sorte, et signifie que vous pourrez ensuite faire une programmation sans fil, en utilisant le port là (plutôt qu’un port COM filaire).
Au passage, désolé si tout cela paraît compliqué, mais c’est pas évident à expliquer à l’écrit ! Dans tous les cas, ce qu’il faut retenir au final, c’est qu’il faudra intégrer le bout de code ci-dessus dans vos programmes ESP32, si vous souhaitez pouvoir faire une programmation sans-fil, en suivant.
Test #3 : exemple de code avec OTA intégré (programmation WiFi répétable à l’infini)
Si vous avez bien uploadé le programme OTA présenté juste avant (« Test #2 »), alors votre carte ESP32 accepte à présent une programmation sans fil, via votre réseau WiFi.
Malheureusement, en l’état, si vous uploadez à nouveau un programme dans votre ESP32, alors ce programme OTA sera écrasé, mettant fin à toute programmation future en WiFi. À moins que, et c’est tout l’intérêt du programme que je vais vous présenter ici, vous intégriez à votre futur programme une partie permettant de gérer l’OTA ; ainsi, l’accès « programmation WiFi » sera toujours disponible sur votre ESP32, jusqu’à écrasement (et ainsi de suite, tant que votre programme intégrera une partie gérant l’OTA !).
En bref, par exemple, pour faire un programme blink modifiable/effaçable/remplaçable en sans fil, il faut faire un mix entre le programme de test #1 (programme blink) et le programme de test #2 (programme OTA). Ainsi, vous obtenez un programme permettant de faire clignoter une led, et qui plus est, gardant une oreille ouverte sur le WiFi, pour gérer d’éventuels reprogrammation sans fil.
Et c’est exactement ce que va faire ce 3ème programme de test (à la différence qu’au lieu de faire un simple blink, j’ai programmé un « clignotement triple », histoire de bien montrer la différence avec le 1er programme de test !) :
/*
______ _ _///_ _ _ _
/ _ \ (_) | ___| | | | (_)
| [_| |__ ___ ___ _ ___ _ __ | |__ | | ___ ___| |_ _ __ ___ _ __ _ ___ _ _ ___
| ___/ _ \| __|| __| |/ _ \| '_ \_____| __|| |/ _ \/ _| _| '__/ \| '_ \| |/ \| | | |/ _ \
| | | ( ) |__ ||__ | | ( ) | | | |____| |__ | | __/| (_| |_| | | (_) | | | | | (_) | |_| | __/
\__| \__,_|___||___|_|\___/|_| [_| \____/|_|\___|\____\__\_| \___/|_| |_|_|\__ |\__,_|\___|
| |
\_|
Fichier : prg3-upload-OTA-et-test-triple-blink-IO48.ino
Dépôt : https://github.com/PassionElectronique/Programmes-tests-ESP32-Simple-Dev-Board
Description : Programme permettant de faire clignoter triplement une LED branchée sur la broche IO48
Licence : BY-NC-ND 4.0 CC (https://creativecommons.org/licenses/by-nc-nd/4.0/deed.fr)
Remarque : Téléchargement via WiFi / OTA ESP32
Auteur : Jérôme TOMSKI (https://passionelectronique.fr/)
Créé le : 01.11.2025
*/
// Inclusion des librairies nécessaires
#include <WiFi.h>
#include <ArduinoOTA.h>
// Définition de la broche ESP32 où est branchée la LED embarquée
#define BROCHE_LED 48 // Sur GPIO 48, donc
// Codes WiFi (box internet)
const char* ssid_WiFi = "SSID_WIFI";
const char* mot_de_passe_WiFi = "MOT_DE_PASSE_WIFI";
// Codes OTA (permettant l'upload ultérieur de programmes dans l'ESP32, via le WiFi)
const char* nom_OTA = "Mon-ESP32-S3-OTA";
const char* mot_de_passe_OTA = "mdp-OTA";
// ========================
// Initialisation programme
// ========================
void setup() {
// -----------------------------------------------------------------------------------------------------------------
// Configuration de base ESP32/WiFi
// -----------------------------------------------------------------------------------------------------------------
// Configure la "broche LED" en sortie
pinMode(BROCHE_LED, OUTPUT);
// Ouverture du port série
Serial.begin(115200);
Serial.print("\n\n");
Serial.print("=== ESP32-S3 OTA Boot ===");
Serial.print("\n");
// Connexion au WiFi
WiFi.begin(ssid_WiFi, mot_de_passe_WiFi);
Serial.print("Connexion à "); Serial.print(ssid_WiFi);
// Attente confirmation WiFi connecté
while (WiFi.status() != WL_CONNECTED) {
delay(200);
Serial.print("."); // On affiche des "." toutes les 200 ms, en attendant la connexion
}
Serial.println("");
// Affichage adresse IP, pour confirmer connexion WiFi
Serial.println("WiFi connecté !");
Serial.print("Adresse IP : "); Serial.println(WiFi.localIP());
// -----------------------------------------------------------------------------------------------------------------
// Configuration de l'OTA
// -----------------------------------------------------------------------------------------------------------------
// Configuration de l'OTA
ArduinoOTA.setHostname(nom_OTA); // Nom qui apparaîtra dans la liste des ports COM d'Arduino IDE, une fois ce programme chargé dans l'ESP32
ArduinoOTA.setPassword(mot_de_passe_OTA); // Mot de passe OTA (optionnel, car on aurait très bien pu ne pas en mettre, en fait)
// Fonction OTA s'exécutant au démarrage de l'upload
ArduinoOTA.onStart([]() {
String type = (ArduinoOTA.getCommand() == U_FLASH) ? "sketch" : "filesystem";
Serial.println("Début upload OTA : " + type);
});
// Fonction OTA s'exécutant à la fin de l'upload
ArduinoOTA.onEnd([]() {
Serial.println(""); Serial.println("OTA terminé ! Redémarrage...");
});
// Fonction OTA s'exécutant pendant l'upload
ArduinoOTA.onProgress([](unsigned int progression, unsigned int total) {
static int dernierPourcentage = -1;
int pourcentage_d_avancement = (progression * 100) / total;
if (pourcentage_d_avancement != dernierPourcentage && pourcentage_d_avancement % 10 == 0) {
Serial.printf("Progression : %u%%\r", pourcentage_d_avancement);
dernierPourcentage = pourcentage_d_avancement;
}
});
// Fonction OTA s'exécutant lors d'une erreur
ArduinoOTA.onError([](ota_error_t code_erreur) {
Serial.printf("Erreur OTA[%u] : ", code_erreur);
if (code_erreur == OTA_AUTH_ERROR) Serial.println("Échec d'authentification");
else if (code_erreur == OTA_BEGIN_ERROR) Serial.println("Échec de démarrage");
else if (code_erreur == OTA_CONNECT_ERROR) Serial.println("Échec de connexion");
else if (code_erreur == OTA_RECEIVE_ERROR) Serial.println("Échec lors de la réception");
else if (code_erreur == OTA_END_ERROR) Serial.println("Échec de fin OTA");
});
// -----------------------------------------------------------------------------------------------------------------
// Démarrage de l'OTA
// -----------------------------------------------------------------------------------------------------------------
ArduinoOTA.begin();
Serial.println("");
Serial.println("----------");
Serial.println("OTA prêt !");
Serial.println("----------");
Serial.println("");
Serial.print("Remarque : ensuite, pour uploader un programme ESP32 via le WiFi, il faudra aller dans le menu 'Outils' d'Arduino IDE,\n");
Serial.print(" et sélectionner le port COM nommé '"); Serial.print(nom_OTA); Serial.print(" at "); Serial.print(WiFi.localIP()); Serial.println("'");
Serial.println("");
}
// =================
// Boucle principale
// =================
void loop() {
// Maintien de l'OTA actif en permanence, pour gérer les uploads
ArduinoOTA.handle();
// Triple clignotement LED
digitalWrite(BROCHE_LED, HIGH); delay(100);
digitalWrite(BROCHE_LED, LOW); delay(200);
digitalWrite(BROCHE_LED, HIGH); delay(100);
digitalWrite(BROCHE_LED, LOW); delay(200);
digitalWrite(BROCHE_LED, HIGH); delay(100);
digitalWrite(BROCHE_LED, LOW); delay(200);
// Pause avant rebouclage
delay(1100);
}Vous noterez l’indispensable instruction « ArduinoOTA.handle(); » dans la partie « loop », pour rester à l’écoute du WiFi, et permettre l’upload d’un nouveau programme à la place de l’actuel, si souhaité.
Très important : au moment de mes essais, et du fait de la mise d’un mot de passe au niveau de l’accès ESP32/OTA, il m’a été impossible de faire la programmation sans fil avec Arduino IDE version 2 (v2.3.6 installée chez moi, sous Windows). En fait, j’avais un message d’erreur du style : « No monitor available for the port protocol network. Could not connect to 192.168.1.17 network port. ». Il a en fait fallut que je reprenne ma version 1 d’Arduino IDE (v.1.8.18, pour être plus précis), pour arriver à faire la programmation sans fil via WiFi, en OTA avec mot de passe.
Du coup, si vous n’avez pas Arduino v1 (legacy) d’installé sur votre ordi, et que vous travaillez comme moi, avec la v2 sous Windows, il vous faudra :
- aller sur la page téléchargement du site officiel Arduino
- descendre pour atteindre le bloc « Legacy IDE (1.8.xx) »
- cliquer sur ce bloc, pour qu’il s’ouvre
- sélectionner votre système d’exploitation, dans la liste déroulante
- et cliquer sur « Download »
Une fois fait, le téléchargement de la version 1 d’Arduino IDE va démarrer. Ensuite, il ne restera plus qu’à installer cette version, pour continuer avec ce tuto.
Une fois le présent programme de test #3 ouvert dans Arduino IDE version 1, il faudra aller dans le menu « Outils », renseigner les infos concernant votre ESP32, et surtout, bien sélectionner le « port OTA » dans la liste des ports réseaux, pour effectuer une programmation sans fil. En image, voici à quoi ressemble ce menu dans Arduino IDE, et les options associées, telles que sélectionnées de mon côté :
Une fois que tout est correctement configuré, on peut passer à l’upload sans fil du programme, à proprement parler !
À présent, il suffit de cliquer sur le bouton « Téléverser », d’Arduino IDE (v1). Une fois fait, une fenêtre va s’ouvrir à l’écran, vous demandant le mot de passe de la connexion OTA (qui, pour rappel ici, est « mdp-OTA » dans ce programme). Au passage, il se peut que votre pare-feu se déclenche, si vous travaillez sur Windows par exemple, comme moi. En images, voici à quoi tout ceci ressemble (la fenêtre de pare-feu Windows, puis la fenêtre demandant le mot de passe OTA) :
Une fois le mot de passe renseigné et validé, l’upload en lui-même va commencer. Il ne reste plus alors qu’à jeter un coup d’œil en bas de l’écran, dans la console, pour voir si tout s’est bien passé ou non. Si tout s’est bien déroulé, vous devriez pouvoir y lire un message de ce type :
Le croquis utilise 938599 octets (71%) de l'espace de stockage de programmes. Le maximum est de 1310720 octets.
Les variables globales utilisent 48784 octets (14%) de mémoire dynamique, ce qui laisse 278896 octets pour les variables locales. Le maximum est de 327680 octets.
C:\Users\JEROME\AppData\Local\Arduino15\packages\esp32\hardware\esp32\3.3.2\tools\espota.exe -r -i 192.168.1.17 -p 3232 --auth=mdp-OTA -f C:\Users\JEROME\AppData\Local\Temp\arduino_build_418846/prg3-upload-OTA-et-test-triple-blink-IO48.ino.bin
Sending invitation to 192.168.1.17
Authenticating...OK
Uploading: [============================================================] 100% Done...Ou dit autrement, en image :
Voilà ! Le programme a été envoyé dans l’ESP32, via le WiFi ! Et il peut-être modifié/effacé/écrasé en WiFi autant de fois que souhaité, à partir du moment où ce bout de code gérant l’OTA est intégré au programme à envoyer 🙂
Et pour bien vérifier que tout s’est bien passé, il suffit de jeter un coup d’œil à même la carte ESP32, où l’on peut voir le triple clignotement (blink x3) :
Sympa, non ? Bien que perso, je préfère la programmation filaire, car ça évite de surcharger le code arduino, avec la partie OTA 😉
Images thermiques échauffement ESP32 (composants aux alentours)
J’en profite pour vous montrer quelques photos d’imagerie thermique, permettant de s’assurer qu’il n’y ait pas la moindre trace d’échauffement excessif au niveau des composants électroniques. Comme j’effectue systématiquement ce contrôle, j’en profite pour vous en toucher deux mots, car c’est important et une bonne pratique, selon moi !
Du coup, voici 2 photos thermiques de cette carte ESP32, avec le programmateur enfiché dessus, que je vais vous commenter en suivant :
En premier, on voit le module ESP32-S3 en fonctionnement, sans échauffement particulier à sa surface (22,6°C environ), au niveau de son bouclier métallique supérieur. Par contre, au niveau des broches du SoC ESP32 en lui-même, on relève jusqu’à 29,7°C (écrit en rouge sur la zone « rouge », ce qui n’est pas très lisible, en fait !). Mais ce niveau de température en fonctionnement est tout à fait normal/acceptable.
En second, j’ai fait une photo avec un peu plus de recul, pour vous montrer la carte ESP32 + son programmateur (convertisseur USB/UART), branché perpendiculairement dessus. On note un « second point chaud » sur cette image thermique (le premier étant autour du module ESP32, comme précédemment expliqué). Ce second point chaud correspond en fait au régulateur/abaisseur de tension AMS1117 de la carte adaptateur USB↔UART, avec une température de surface mesurée sur ce composant de 31,3°C. Et là aussi, c’est parfaitement normal, du fait que l’ESP32 fonctionne et tire du courant (environ 100 mA, du fait de la connexion WiFi active, au moment de la prise photo).
Voilà ! C’était juste un aparté, mais qui me semblait intéressant de vous partager, pour vous montrer ce qui, selon moi, est une bonne pratique (la vérification d’absence d’échauffement anormal, lors des premiers essais sous tension).
Nota : pour ceux que ça intéresse, la caméra thermique que j’utilise est la KTI-W01 de chez Kaiweets, dont franchement, je ne me séparerai plus tellement elle m’a aidé à identifier des pannes rapidement !
Liens et téléchargements
Pour ceux que ça intéresse, voici :
- les programmes arduino (GitHub)
- le schéma électronique (format PDF, bien lisible !)
- le lien vers le PCB, pour ceux qui souhaiteraient faire fabriquer ce PCB à l’identique
POUR FAIRE FABRIQUER CE CIRCUIT IMPRIMÉ
→ Cliquez sur le lien, juste ci-dessus, pour ouvrir ce projet sur PCBWay
→ Cliquez sur « Add to cart », pour ajouter ce projet à votre panier
→ Attendez quelques minutes (24/48h maximum) pour que les fichiers de ce projet soient vérifiés (pour cela, surveillez simplement l’état d’avancement des éléments dans votre panier ; ils resteront grisés tant que tout ne sera pas validé, et colorés une fois fait)
→ Finalisez votre commande de circuit imprimé (en ajoutant un stencil, si souhaité)
Niveau coût de fabrication, le fabricant PCBWay est plutôt bien placé, alors ne vous en privez pas !
Du reste, voici le datasheet des principaux composants utilisés ici :
- le datasheet du régulateur de tension ajustable AMS1117-ADJ de chez Advanced Monolithic Systems (format PDF)
- le datasheet du module ESP32-S3-WROOM-1 / 1U de chez Espressif (format PDF)
ESP32-S3 Dev Board : conclusion !
Voilà ! J’espère que cet article sur la programmation ESP32-S3 en filaire ou sans fil vous aura plu, et qu’il aura été assez détaillé. Du reste, pour résumer les programmes de test, et pour que ce soit le plus clair possible :
- le programme de test #1 vous montre comment programmer un ESP32, en filaire, via son port UART, en utilisant un convertisseur USB↔UART et un ordi pour ce faire
- le programme de test #2 vous montre comment programmer un ESP32, en filaire, pour qu’il puisse ensuite être programmé en WiFi, une fois (c’est un exemple de base, permettant de gérer la programmation « over the air », OTA donc)
- le programme de test #3 vous montre comment programmer un ESP32 en « sans fil », via le WiFi, de manière répétable
En sachant que si vous moi vous préférez la programmation filaire, alors l’exemple de code #1 est ce qu’il vous faut ; et si vous préférez la programmation WiFi sans fil « perpétuelle », alors l’exemple de code #3 est tout ce qu’il vous faudra (le programme #2 n’étant là que pour vous montrer la partie OTA uniquement).
Et en notant bien que la programmation sans-fil AVEC mot de passe semble buguée sur Arduino IDE v2 (sous Windows, du moins), et que dans ce cas particulier, il faille revenir à Arduino IDE v1. À moins que quelque chose m’ait échappé, et dans ce cas, n’hésitez pas à m’en faire part en zone commentaire !
Une dernière chose, concernant les améliorations possibles sur cette carte ESP32-S3-WROOM-1 :
- j’aurais du mettre un connecteur d’alim USB-C au lieu du connecteur micro-USB (ça aurait fait plus moderne !)
- un témoin d’alimentation (LED « power ») aurait été le bienvenu, parce que là, on ne sait pas si l’ESP32 est vraiment bien alimenté ou non
- le bouton-poussoir « BOOT » n’a pas vraiment d’utilité, si on utilise un programmateur ESP32 avec auto-boot, comme celui que je vous avais partagé précédemment, et utilisé tout au long de cet article ; il pourrait donc, dans l’absolu, être enlevé, dans ce cas précis !
Bon, je pense qu’on a fait le tour complet de cette carte de test/dev ESP32 S3 ! Alors il est temps pour moi de vous quitter, et de vous dire à bientôt, sur un nouvel article !
Jérôme.
À découvrir aussi : les écrans TFT à contrôleur ILI9341, pilotage via ESP32-S3 !
(*) Mis à jour le 04/01/2026
Salut,
Merci pour l’article. Tu mentionnes utiliser de la pâte à souder Plomb (Pb) / Bismuth (Bi). Mais la formule que tu donnes (Sn42/Bi58) est à l’étain. Quelle info est la bonne ?
Merci !
Salut !
Erreur grossière de ma part, que je viens immédiatement de corriger ! C’est bien étain/bismuth qu’il fallait lire, et non plomb/bismuth !
Merci à toi, pour m’avoir remonté cette coquille !!!
Jérôme.
Bonjour Jérome
Jusqu’à maintenant, j’hésitais à passer le pas de la commande PCBWay. Je crois que tu m’as convaincu par ton projet bien ficelé.
Quand on commande le pack de 5 PCB nu; est-ce qu’il y a des choses à modifier avant de mettre dans le panier à part les frais de port ?
Même chose lorsque l’on commande assemblé; est-ce que tous les composants sont déjà prévu ? ou faut-il aller les choisir à un endroit du site ?
Merci pour ta réponse et bravo pour tous ces projets.
Salut Lucien !
En fait, une fois que tu es sur la page de ce projet sur PCBWay, il suffit de cliquer sur « Add to cart », pour accéder aux paramètres avant commande.
À ce niveau, tu peux modifier plusieurs choses. Perso, je modifie uniquement les options :
Et je ne touche pas au reste, sauf besoin spécifique (à noter que la quantité minimale de PCB est de 5, effectivement).
Du reste, sur cette même page, tu pourras choisir :
Pour info, je suis actuellement en train de tester leur service Assembly, donc je ne peux pas te le conseiller pour l’instant ; par contre, je peux d’ores et déjà te dire que ce service me paraît onéreux (simule le, et tu vas comprendre !), et long (délai de 20/21 jours, par exemple). J’aurais donc tendance à te conseiller de prendre uniquement le PCB (+ stencil si tu ne te sens pas apte à bien poser la soudure aux bons endroits), si tu as un budget limité. Cela étant dit, concernant ce projet là en particulier, je dirais que le module ESP32 (SoC) n’est pas forcément évident à souder, lorsqu’on n’a pas l’habitude de souder des CMS à pads multiples aussi rapprochées. À toi de voir, donc, en fonction de tes capacités.
Sinon, concernant les frais de ports, je prends parmi les moins chers, à savoir « Global Direct Shipping » ou un nom comme ça, de mémoire !
Voilà ! Excellente journée à toi !
Jérôme.
Bonjour Jerome,
Excellent comme d’habitude… mais peux tu faire un peu de lumière sur le fait que tu utilise dans ce projet un régulateur de tension réglable (AMS1117-ADJ) et pas un régulateur de tension 3.3v fixe.
Encore bravo pour ce nouvel exercice.
Paul
Salut Paul !
En fait, un module ESP32 requiert de 3.0 à 3.6V pour fonctionner. Bien sûr, un régulateur fixe à 3.3V pourrait convenir, pour l’alimenter. Cependant, du fait que j’ai rajouté une diode anti-retour (schottky) sur la ligne d’alimentation, et du fait qu’une telle diode entraîne une chute de tension moyenne d’environ 0.3V, la tension arrivant à l’ESP32 ne serait plus que de 3.0 volts (3.3 – 0.3), avec un tel régulateur. Et dans ce cas, on serait trop limite (3V fournis, alors que l’ESP32 requiert 3V minimum).
L’astuce ici est donc d’utiliser un régulateur de tension ajustable, fournissant environ 3.6V. Ainsi, en prenant en compte une chute de tension typique de 0.3V sur la diode anti-retour, la tension arrivant à l’ESP32 serait de 3.3V environ.
Nota 1 : j’ai dû mettre une telle diode car le programmateur d’ESP32 (adaptateur USB/UART) peut lui aussi fournir du 3,3V. Il fallait donc que, du côté du programmateur ESP32 comme du côté de l’alim USB de cette carte, des diodes anti-retour protègent chaque alim (car un régulateur ne supporterait pas le cas où il aurait une tension présente en sortie, et aucune en entrée).
Nota 2 : là encore, j’idéalise (en parlant de « 0.3 » pour les Schottky, j’entends). Car une diode, quelle qu’elle soit, induit une chute de tension qui est également fonction du courant qui passe à travers elle. Donc ça peut être plus ou moins de 0,3 volts, et donc ici, avec le risque de fournir moins que les 3V min requis par l’ESP32 pour fonctionner.
En espérant que tout soit plus clair, maintenant 😉
Très bonne journée à toi,
Jérôme.
Hello …. merci beaucoup pour le partage de ce tuto, je suis en plein dedans en ce moment (interface ESP32 / HA / Jablotron).
Pour l’anti-retour sans chute de tension tu aurais pu prendre une diode idéale (comme une LM73100 de TI).
Merci encore, tes tutos fourmillent de bonnes infos.
Hello à toi 🙂
Effectivement, une LM73100 de TI serait bien (je ne connaissais pas, donc milles mercis à toi !). Par contre, j’avoue ne pas être à l’aise avec la soudure de boîtiers QFN ; qui plus est, si je soumets ça à tout le monde, je ne suis pas sûr que tous pourraient réaliser de telles soudures (à moins de sous-traiter, bien entendu).
Cela étant dit, après recherche, je m’aperçois qu’il y avait encore une autre solution pertinente, provenant de Texas Instrument également. Il s’agit du TPS2115A (datasheet : https://www.ti.com/lit/ds/symlink/tps2115a.pdf). En fait, c’est simplement un commutateur automatique d’alimentation. Ce serait donc l’idéal ici, où le module ESP32 peut être alimenté soit via la prise USB sur sa carte, soit via le programmateur UART ! Qui plus est, en boîtier TSSOP-8, c’est nettement plus gérable à souder, quand on bricole ! Donc je me note ça, pour l’intégrer dans un prochain montage 😉
Du coup, encore merci à toi, car ça m’a permis de découvrir pas mal de trucs intéressants également !
Très bonne soirée à toi,
Jérôme.
Bonjour, Jérôme,
Juste un petit mot pour te remercier pour le travail énorme que tu accompli à chaque tuto. A chaque fois je me régale et on a l’impression de devenir moins idiot !!! bon, c’est vrai je part de loin !!!!
Bonne soirée.
Héhé, de rien 🙂
Et merci pour ton message !
Excellente soirée à toi également,
Jérôme.
Merci Jérôme pour le retour concernant PCBway.
Quand tu dis que l’assemblage se fait uniquement pour les composants cms, est-ce que ça comprend l’ESP32 ?
Merci
Oui, parfaitement ! Et plus précisément, c’est un modèle « ESP32-S3-WROOM-1-N16R8 » qui sera automatiquement intégré (avec 16 Mo de mémoire Flash, et 8 Mo de mémoire PSRAM, donc)
Bonjour Jérôme,
J’ajoute en complément une petite galère qui m’est arrivé lorsque j’ai fait mes premières programmations en mode OTA sur ESP32. la compilation fonctionnait bien mais le « téléchargement » à distance du programme me renvoyait un « error timeout ». A force de chercher, j’ai trouvé que c’était le parefeu de mon antivirus qui bloquait la connexion de l’IDE arduino vers la carte ESP32. En désactivant le parefeu, le téléchargement fonctionne parfaitement. Je n’ai jamais trouvé quel port libérer dans le pare feu pour ne plus avoir à le désactiver complément.
Oui, c’est pénible ça ! Moi, perso, j’ai eu la chance que Windows Defender m’ai ouvert une fenêtre à l’écran, pour me dire qu’il bloquait l’accès (avec un bouton à cliquer pour déverrouiller cet accès manuellement si je souhaitais, ce que j’ai fait !)