Dans ce tutoriel, vous apprendrez comment installer le core ESP32 dans l’IDE Arduino. L’ESP32 est un microcontrôleur puissant et polyvalent, largement utilisé dans les projets IoT et maker. Pour le programmer avec l’IDE Arduino, vous devez installer le core ESP32.
Le core ESP32 sert de pont entre l’environnement Arduino et le matériel ESP32. Il fournit les outils, bibliothèques et définitions nécessaires pour compiler et téléverser votre code sur la carte ESP32.
Vous découvrirez ce qu’est un core Arduino, pourquoi il est essentiel, et comment installer le core ESP32 étape par étape. Nous aborderons aussi l’installation des pilotes USB-série requis, la sélection de la bonne carte et du port, ainsi que la configuration des paramètres de la carte. À la fin, vous serez prêt à commencer vos projets ESP32 avec l’IDE Arduino familier.
Qu’est-ce qu’un Core dans l’IDE Arduino ?
Dans l’écosystème Arduino, un Core est un ensemble de composants logiciels qui permettent à l’IDE Arduino de compiler et téléverser du code vers une famille spécifique de microcontrôleurs ou de cartes. Il fait le lien essentiel entre vos sketches Arduino et le matériel que vous souhaitez programmer. Un core Arduino comprend généralement plusieurs éléments clés :
Définitions de cartes
Ce sont des fichiers JSON ou de configuration qui décrivent les spécificités matérielles de chaque carte supportée. Ils définissent l’architecture CPU, la fréquence d’horloge, les broches disponibles, la taille de la mémoire et d’autres paramètres matériels. Par exemple, le core ESP32 inclut des définitions pour des cartes populaires comme ESP32 Dev Module, WROOM et les variantes WROVER.
Chaîne d’outils du compilateur
Le core regroupe les outils de compilation et de liaison adaptés à l’architecture cible. Pour l’ESP32, cela signifie la chaîne Xtensa GCC, qui compile vos sketches Arduino en code machine exécutable par le CPU de l’ESP32.
Outils de téléversement
Ces outils gèrent le processus de flashage de votre code compilé sur la carte. Pour l’ESP32, le core utilise esptool.py, un utilitaire Python qui communique via le pont USB-série pour téléverser le firmware.
Bibliothèques du core
Cela inclut la couche d’abstraction matérielle (HAL), les pilotes périphériques et les API Arduino de base adaptées à la plateforme cible. Pour l’ESP32, le core intègre FreeRTOS pour le multitâche, les stacks Wi-Fi et Bluetooth, ainsi que d’autres bibliothèques spécialisées pour exploiter les fonctionnalités avancées de la puce.
Pourquoi un Core est-il nécessaire ?
L’IDE Arduino a été initialement conçu pour les cartes basées sur AVR comme l’Arduino Uno. Pour programmer un microcontrôleur différent, comme l’ESP32, l’IDE doit savoir comment :
- Compiler le code pour la nouvelle architecture CPU
- Gérer les fonctionnalités matérielles spécifiques à la carte
- Téléverser le code en utilisant le protocole et les outils appropriés
- Fournir des bibliothèques supportant les périphériques de la carte
Sans core, l’IDE ne peut pas communiquer avec la carte ni compiler du code pour elle. Le core vous permet d’utiliser le même code, ou un code très similaire, pour de nombreux microcontrôleurs différents et simplifie souvent le code.
Par exemple, le code suivant montre le classique Blink pour l’IDE Arduino qui fait clignoter une LED connectée au GPIO 2 toutes les secondes :
#define LED_PIN 2
void setup() {
pinMode(LED_PIN, OUTPUT);
}
void loop() {
digitalWrite(LED_PIN, HIGH);
delay(1000);
digitalWrite(LED_PIN, LOW);
delay(1000);
}
Le même code utilisant le ESP-IDF, qui est un IDE spécifique à la programmation ESP32, est beaucoup plus long et complexe :
#include "freertos/FreeRTOS.h"
#include "freertos/task.h"
#include "driver/gpio.h"
#define LED_PIN GPIO_NUM_2
void blink_task(void *pvParameter) {
while (1) {
gpio_set_level(LED_PIN, 1);
vTaskDelay(pdMS_TO_TICKS(1000));
gpio_set_level(LED_PIN, 0);
vTaskDelay(pdMS_TO_TICKS(1000));
}
}
void app_main(void) {
gpio_config_t io_conf = {
.pin_bit_mask = (1ULL << LED_PIN),
.mode = GPIO_MODE_OUTPUT,
.pull_up_en = GPIO_PULLUP_DISABLE,
.pull_down_en = GPIO_PULLDOWN_DISABLE,
.intr_type = GPIO_INTR_DISABLE
};
gpio_config(&io_conf);
xTaskCreate(blink_task, "blink_task",
2048, NULL, 5, NULL);
}
Architecture du Core ESP32
Le Core Arduino ESP32 est construit sur l’ESP-IDF officiel d’Espressif (IoT Development Framework). Il enveloppe les API complexes de l’ESP-IDF dans des fonctions et classes conviviales pour Arduino. L’architecture du core comprend :
- Couche d’abstraction matérielle (HAL) : Simplifie l’accès aux périphériques ESP32 comme GPIO, ADC, SPI, I2C et UART.
- Noyau FreeRTOS : Permet le multitâche et les opérations temps réel dans les sketches Arduino.
- Couche API Arduino : Offre les fonctions Arduino familières (
setup(),loop(),digitalWrite(),analogRead(),Serial, etc.) adaptées au matériel ESP32.
Cette architecture permet aux développeurs d’écrire des sketches Arduino qui s’exécutent sur les microcontrôleurs ESP32 ou tout autre microcontrôleur pour lequel un core est disponible.
Installation ou mise à jour de l’IDE Arduino
Avant d’installer le core ESP32, assurez-vous d’avoir la dernière version de l’IDE Arduino. Le core ESP32 nécessite Arduino IDE 1.8.13 ou plus récent. Utiliser une version obsolète peut causer des problèmes de compatibilité.
Visitez le Arduino website. Choisissez votre système d’exploitation : Windows, macOS ou Linux, et téléchargez la dernière version stable.
Installation de l’IDE Arduino
- Windows : Lancez le fichier
.exetéléchargé et suivez l’assistant d’installation. - macOS : Ouvrez le fichier
.dmget glissez l’application Arduino dans votre dossier Applications. - Linux : Extrayez l’archive téléchargée et lancez le script
install.sh.
Mise à jour de l’IDE Arduino
Si vous avez déjà l’IDE Arduino installé, vérifiez votre version via Help > About Arduino (Windows/Linux) ou Arduino > About Arduino (macOS). Comparez votre version avec la dernière disponible sur le site Arduino.
Installation du pilote USB-série
Pour programmer votre carte ESP32 depuis l’IDE Arduino, votre ordinateur doit communiquer avec la carte via un pont USB-série. La plupart des cartes ESP32 utilisent soit le CP210x soit le CH340 comme puces USB-série. Installer le bon pilote garantit que votre ordinateur reconnaît correctement la carte.
Identifier votre puce USB-série
Commencez par vérifier quelle puce USB-série votre carte ESP32 utilise. Consultez la description du produit ou le marquage sur la carte près du connecteur USB.
Les puces courantes sont le CP2102 / CP2104 de Silicon Labs et le CH340 / CH341 de WCH. Une fois la puce identifiée, téléchargez le pilote approprié :
Après téléchargement : lancez l’installateur, suivez les instructions à l’écran, redémarrez votre ordinateur si demandé.
Vérifier l’installation du pilote
Connectez votre carte ESP32 via USB. Puis :
- Sous Windows, ouvrez leGestionnaire de périphériques et regardez sous Ports (COM & LPT). Vous devriez voir un nouveau port COM nommé d’après la puce USB-série.
- Sous macOS ou Linux, ouvrez un terminal et lancez :
ls /dev/tty.*
Cherchez un périphérique comme /dev/tty.SLAB_USBtoUART (CP210x) ou /dev/tty.wchusbserialXXXX (CH340).
Si vous voyez le périphérique, le pilote est installé avec succès. Installer le bon pilote USB-série est crucial. Sans lui, l’IDE Arduino ne peut pas téléverser de code sur votre ESP32. Une fois cette étape terminée, vous pouvez ajouter le core ESP32 à l’IDE Arduino.
Ajouter le Core ESP32 à l’IDE Arduino
Maintenant que l’IDE Arduino est prêt et que le pilote USB-série est installé, il est temps d’ajouter le core ESP32. Cette étape permet à l’IDE Arduino de reconnaître et programmer les cartes ESP32.
Pour installer le Core ESP32, ouvrez votre IDE Arduino et allez dans File > Preferences comme montré ci-dessous :
Cela ouvre la fenêtre des Préférences. En bas, vous trouverez une section intitulée « Additional boards manager URLs : »
Cliquez sur le bouton à droite, qui ouvre une autre fenêtre où vous pouvez entrer l’URL depuis laquelle le core ESP32 peut être téléchargé :
Il peut déjà y avoir d’autres URLs (dans mon cas pour ESP8266 et la carte Unihiker). Ajoutez à cette liste l’URL suivante pour le core ESP32 :
https://espressif.github.io/arduino-esp32/package_esp32_index.json
Vous pouvez aussi utiliser celle-ci en alternative :
https://raw.githubusercontent.com/espressif/arduino-esp32/gh-pages/package_esp32_index.json
L’ordre des URLs dans la liste n’a pas d’importance. Pour d’autres architectures de microcontrôleurs, consultez cette liste de core URLs.
Installation des cartes ESP32
Ensuite, ouvrez le Boards Manager en allant dans Tools > Board > Boards Manager. Dans la barre de recherche, tapez « esp32 », trouvez l’entrée nommée « esp32 by Espressif Systems » et cliquez sur le bouton INSTALL :
L’installation peut prendre quelques minutes car tous les fichiers nécessaires sont téléchargés. Une fois terminée, fermez le Boards Manager.
Vous avez ajouté avec succès le core ESP32. Désormais, l’IDE Arduino peut compiler et téléverser du code vers les cartes ESP32. Dans la section suivante, nous configurerons les paramètres de la carte pour correspondre à votre modèle spécifique.
Configuration des paramètres de la carte ESP32
Après l’installation du core ESP32, vous devez configurer les paramètres de la carte. Ces options contrôlent la compilation, le téléversement et l’exécution de votre sketch sur l’ESP32. Des réglages corrects sont essentiels pour des téléversements stables, une bonne gestion mémoire et un débogage fiable.
Vous trouverez tous les paramètres sous Tools après avoir sélectionné une carte ESP32. La capture d’écran ci-dessous montre les paramètres pour un « ESP32S3 Dev Module » :
Pourquoi les paramètres de la carte sont importants
L’ESP32 est très configurable. Il supporte plusieurs méthodes de téléversement, configurations de flash, modes USB et options de débogage. Des réglages incorrects causent souvent des échecs de téléversement, des boucles de démarrage ou des plantages inattendus.
Cependant, seuls quelques paramètres sont essentiels pour la plupart des projets. Les autres sont avancés et peuvent rester par défaut. Les paramètres les plus importants sont :
- Carte : Doit correspondre exactement à votre variante ESP32.
- Vitesse de téléversement : Impacte la fiabilité du téléversement.
- Taille du flash : Doit correspondre à la mémoire flash embarquée.
- Schéma de partition : Contrôle la répartition de la mémoire flash.
- PSRAM : RAM externe
- Port : Indique où le firmware est téléversé.
Une fois ces paramètres corrects, la plupart des projets se compileront et téléverseront sans problème. Voici plus d’informations sur ces réglages :
Taille du flash
Ce paramètre doit correspondre à la puce flash physique de votre module ESP32. S’il est incorrect, les téléversements peuvent réussir mais les sketches planteront à l’exécution.
Schéma de partition
Le schéma de partition définit comment la mémoire flash de l’ESP32 est divisée et allouée. Il précise où sont stockés le code applicatif, le bootloader, les systèmes de fichiers et les emplacements OTA (Over-The-Air) optionnels. Ce paramètre influence directement la taille maximale de votre sketch et les fonctionnalités disponibles.
- Choisissez Default pour des sketches simples.
- Utilisez Minimal SPIFFS si votre application est volumineuse.
- Sélectionnez OTA si vous prévoyez de mettre à jour le firmware sans fil.
Vitesse de téléversement
Des vitesses plus élevées réduisent le temps de téléversement mais peuvent provoquer des échecs sur des connexions USB instables. En cas d’échec, réduisez la vitesse à 115200.
USB CDC et mode USB
Ces paramètres sont essentiels pour les cartes ESP32-S2 et ESP32-S3. Ils permettent une communication USB directe sans convertisseur USB-série externe.
PSRAM
Activez cette option uniquement si votre carte inclut physiquement de la PSRAM. Sinon, votre sketch risque de ne pas démarrer. La PSRAM est généralement nécessaire pour des applications gourmandes en RAM comme la vidéo ou l’audio.
Paramètres et leur fonction
Liste des paramètres les plus courants et leur fonction :
| Paramètre | Description | Quand modifier |
|---|---|---|
| USB CDC On Boot | Active la communication série USB via USB natif au lieu de UART | Activer pour les cartes USB ESP32-S2/S3 |
| Mode USB | Sélectionne la fonctionnalité USB (CDC, HID, MSC, ou désactivé) | Utiliser CDC pour le support du moniteur série |
| USB DFU On Boot | Active le mode Device Firmware Update au démarrage | Nécessaire pour les workflows de flash DFU |
| Mode de téléversement | Définit comment le firmware est téléversé (UART0, USB, OTA) | Modifier uniquement si vous utilisez USB ou OTA |
| Vitesse de téléversement | Débit en bauds utilisé lors du téléversement | Réduire si les téléversements échouent |
| Taille du flash | Taille de la mémoire flash embarquée (ex. 4MB, 8MB, 16MB) | Doit correspondre au matériel |
| Mode flash | Mode de communication entre l’ESP32 et la flash (QIO, DIO, etc.) | Laisser par défaut sauf indication contraire dans la datasheet |
| Fréquence du flash | Fréquence d’horloge du flash (40MHz ou 80MHz) | Réduire en cas d’instabilité du flash |
| Schéma de partition | Définit la disposition mémoire (taille app, SPIFFS, OTA) | Modifier pour OTA ou systèmes de fichiers |
| Effacer tout le flash avant téléversement | Efface toute la mémoire flash avant le téléversement | Activer en cas de problèmes de démarrage ou OTA |
| Niveau de débogage du core | Contrôle la verbosité des messages de débogage | Augmenter pendant le développement |
| PSRAM | Active la RAM pseudo-statique externe | Activer si la carte inclut de la PSRAM |
| Adaptateur JTAG | Sélectionne l’interface JTAG pour le débogage | Nécessaire uniquement pour le débogage matériel |
| Fréquence CPU | Définit la fréquence d’horloge CPU (ex. 80MHz, 160MHz, 240MHz) | Réduire pour économiser de l’énergie |
| Arduino tourne sur | Sélectionne le core (PRO ou APP CPU) | Laisser par défaut pour la plupart des cas |
Sélection de la carte et du port
Après avoir configuré les paramètres de la carte ESP32, vous devez sélectionner la bonne carte et le bon port. Cette étape indique à l’IDE Arduino quelle variante ESP32 vous utilisez et où téléverser le firmware. Des sélections incorrectes sont une cause fréquente d’erreurs de téléversement.
Sélection de la carte ESP32
Ouvrez d’abord le menu Tools > Board. Faites défiler jusqu’à la section ESP32 Arduino. Vous y trouverez une longue liste de cartes supportées.
Choisissez la carte qui correspond le mieux à votre matériel. Par exemple :
- ESP32 Dev Module : Générique et largement compatible
- DOIT ESP32 DEVKIT V1 : Carte de développement courante
- ESP32-WROOM-DA Module : Variante spécifique de module
- ESP32-S3 Dev Module : Pour les cartes basées sur ESP32-S3
- ESP32-C3 Dev Module : Pour les cartes ESP32-C3 basées sur RISC-V
Si vous n’êtes pas sûr, commencez par ESP32 Dev Module. Il fonctionne avec la plupart des cartes ESP32-WROOM et est un choix sûr par défaut.
Connexion de l’ESP32 à votre ordinateur
Connectez maintenant l’ESP32 à votre ordinateur avec un câble USB. Utilisez un câble compatible données. Les câbles uniquement pour charge ne fonctionnent pas et sont une source fréquente de confusion. Selon la carte, la connexion utilise soit :
- Un convertisseur USB-série externe (CP210x, CH340, FTDI)
- USB natif (ESP32-S2, ESP32-S3, ESP32-C3)
Sélection du port
Ensuite, ouvrez Tools > Port. Un nouveau port devrait apparaître après la connexion de l’ESP32.
Les noms de port typiques incluent :
- COMx sous Windows
- /dev/ttyUSBx ou /dev/ttyACMx sous Linux
- /dev/cu.usbserial-* ou /dev/cu.usbmodem-* sous macOS
Sélectionnez le port correspondant à votre ESP32. Si plusieurs ports sont listés, débranchez la carte et observez quel port disparaît. Rebranchez-la ensuite et sélectionnez le port nouvellement apparu.
Tester l’installation du Core
Après avoir sélectionné la carte et le port, vérifiez que le core ESP32 est bien installé et fonctionne correctement. Cette étape confirme que la chaîne d’outils, les définitions de carte et le processus de téléversement fonctionnent comme prévu.
Ouverture d’un sketch test
Commencez par un exemple connu fonctionnel. Ouvrez le sketch classique Blink :
File > Examples > 01.Basics > Blink
void setup() {
// initialize digital pin LED_BUILTIN as an output.
pinMode(LED_BUILTIN, OUTPUT);
}
// the loop function runs over and over again forever
void loop() {
digitalWrite(LED_BUILTIN, HIGH); // turn the LED on (HIGH is the voltage level)
delay(1000); // wait for a second
digitalWrite(LED_BUILTIN, LOW); // turn the LED off by making the voltage LOW
delay(1000); // wait for a second
}
La plupart des cartes ESP32 ont une LED intégrée. Cependant, le numéro GPIO varie selon la carte. Si la LED ne clignote pas, vous devrez peut-être modifier la définition de la broche. Pour beaucoup de cartes ESP32, la LED intégrée est connectée au GPIO 2 :
#define LED_BUILTIN 2
Ajoutez la définition de LED_BUILTIN en haut du sketch si elle manque et modifiez le GPIO si nécessaire :
#define LED_BUILTIN 2
void setup() {
pinMode(LED_BUILTIN, OUTPUT);
}
void loop() {
digitalWrite(LED_BUILTIN, HIGH);
delay(1000);
digitalWrite(LED_BUILTIN, LOW);
delay(1000);
}
Compilation et téléversement du sketch
Cliquez sur le bouton Upload pour flasher le sketch sur l’ESP32.
Pendant le téléversement, surveillez les messages de compilation et d’état en bas de l’IDE.
Sur certaines cartes, vous devrez peut-être appuyer et maintenir le bouton BOOT jusqu’au début du téléversement. Un téléversement réussi se termine par un message similaire à :
Leaving... Hard resetting via RTS pin...
Cela indique que l’ESP32 a été programmé et redémarré.
Vérification du résultat
Une fois l’ESP32 redémarré, observez la LED intégrée :
- Si la LED clignote, le core ESP32 est installé et fonctionne correctement.
- Si rien ne se passe, vérifiez la broche LED et la sélection de la carte.
Tester la communication série
Pour confirmer davantage la configuration, ouvrez le Moniteur Série : réglez la vitesse à 115200. Ensuite, lancez ce sketch qui affiche « test » dans le Moniteur Série toutes les secondes :
void setup() {
Serial.begin(115200);
}
void loop() {
Serial.println("test");
delay(1000);
}
Si vous voyez les messages dans le Moniteur Série, la communication USB et le core ESP32 fonctionnent parfaitement.
Problèmes courants d’installation
Même avec une installation correcte, des problèmes peuvent survenir avec le core ESP32. La plupart sont liés aux pilotes, aux paramètres de la carte ou à la configuration du téléversement. Voici les problèmes les plus fréquents et leurs solutions.
L’ESP32 n’apparaît pas dans les ports
Si aucun port n’apparaît après connexion de l’ESP32, l’ordinateur ne détecte pas la carte. Causes possibles et solutions :
- Installez le bon pilote USB-série (CP210x, CH340 ou FTDI).
- Utilisez un câble USB compatible données.
- Essayez un autre port USB sur votre ordinateur.
- Pour les cartes ESP32-S2 ou ESP32-S3, activez USB CDC On Boot et sélectionnez le bon USB Mode.
Redémarrez l’IDE Arduino après l’installation des pilotes.
Échec du téléversement avec “Timed out waiting for packet header”
Cette erreur signifie que l’ESP32 n’est pas entré en mode flash. Essayez de
- Appuyer et maintenir le bouton BOOT au début du téléversement.
- Réduisez la Upload Speed à 115200.
- Vérifiez que le bon Port est sélectionné.
- Fermez les autres programmes utilisant le même port série.
Échec du téléversement avec “Wrong boot mode detected”
Vous devrez peut-être appuyer sur les boutons BOOT et RESET dans une séquence spécifique, ou ajouter un condensateur de 1µF entre RESET/ENABLE et GND. Voir le Wrong boot mode ESP32 tutoriel.
Erreurs de compilation liées aux headers ESP32
Les erreurs mentionnant des fichiers manquants comme esp_system.h ou WiFi.h indiquent généralement un problème d’installation du core. Essayez de :
- Réinstaller le core ESP32 via le Boards Manager.
- Supprimer le dossier du package ESP32 et réinstaller.
- Vérifier qu’une seule version du core ESP32 est installée.
Le sketch se téléverse mais ne s’exécute pas
Si le téléversement réussit mais que l’ESP32 n’exécute pas le sketch, il s’agit probablement d’un problème de configuration. Vérifiez les paramètres suivants :
- Taille du flash correspond au matériel réel.
- Schéma de partition supporte la taille de votre sketch.
- PSRAM est activée uniquement si la carte en dispose.
- Effacer tout le flash avant téléversement est activé pour un test propre.
Le Moniteur Série affiche des caractères illisibles
Des caractères illisibles dans le Moniteur Série indiquent généralement un mauvais réglage de la vitesse en bauds. Pour corriger, réglez la vitesse du Moniteur Série pour qu’elle corresponde à Serial.begin(). Les valeurs courantes sont 115200 ou 9600.
Pour les cartes ESP32-S2 et ESP32-S3, vérifiez aussi que USB CDC est activé.
La carte redémarre en boucle
Des redémarrages répétés peuvent indiquer des problèmes d’alimentation ou de configuration. Causes fréquentes :
- Alimentation insuffisante via le port USB
- Fréquence ou mode flash incorrect
- Détection de brownout provoquant des resets
Essayez un hub USB alimenté ou réduisez la fréquence CPU.
Erreurs de compilation ou code ne fonctionnant pas
Parfois, il faut rétrograder la version du core ESP32, car certaines bibliothèques ne supportent pas les versions récentes, notamment la 3.x. En général, il faut revenir à la version 2.0.17.
Ouvrez le BOARDS MANAGER, tapez « esp32 » dans la barre de recherche, puis sélectionnez la version du core « esp32 by Espressif » et cliquez sur « UPDATE » comme montré ci-dessous :
Cela téléchargera et installera la version sélectionnée du core.
Conclusion
Dans ce tutoriel, vous avez appris comment installer le core ESP32 pour l’IDE Arduino. Le Core Arduino simplifie la programmation en fournissant un environnement facile à utiliser avec des fonctions et bibliothèques familières. Il masque les détails matériels complexes, vous permettant de vous concentrer sur votre projet plutôt que sur le code bas niveau. Pour plus d’informations, consultez le Espressif Installation Guide.
Le principal avantage d’utiliser le Core Arduino est son accessibilité. Les débutants peuvent rapidement démarrer le développement ESP32 sans connaissances approfondies en systèmes embarqués. La vaste communauté Arduino et le large support des bibliothèques facilitent le dépannage et l’extension de vos projets.
De plus, il existe d’autres cores pour de nombreux autres microprocesseurs, par exemple le ESP8266, STM32 et RP2350. Cela vous permet de programmer une large gamme de microprocesseurs différents dans le même IDE et avec un code (presque) identique.
Cependant, le Core Arduino a aussi des limites. Il n’expose pas toujours toutes les fonctionnalités avancées du matériel ESP32. L’optimisation des performances et les capacités temps réel peuvent être restreintes comparé à l’utilisation native de l’ESP32-IDF (Espressif IoT Development Framework). L’ESP32-IDF offre un contrôle complet de l’architecture de la puce, permettant des applications optimisées et complexes, mais avec une courbe d’apprentissage plus raide.
En résumé, choisissez le Core Arduino si vous voulez un développement rapide, simple et soutenu par la communauté. Optez pour l’ESP32-IDF si vous avez besoin de performances maximales, d’un contrôle fin et d’accès aux dernières fonctionnalités ESP32.
Si vous avez des questions, n’hésitez pas à les poser dans la section commentaires.
Bon bricolage ; )
