ESPDuino-32 : brochage, compatibilité des shields Uno et Wi-Fi
ESPDuino-32 expliqué : correspondance des broches avec l'Uno, piège du 3,3 V, shields qui ne marchent pas, choix de carte dans l'IDE Arduino et premier Wi-Fi.
L'ESPDuino-32 est une carte de développement qui place un ESP32 dans les dimensions et la disposition des broches d'un Arduino Uno : de l'extérieur, elle ressemble à un Uno, mais elle embarque un processeur double cœur à 240 MHz, le Wi-Fi et le Bluetooth. C'est une conception de DOIT, et une carte presque identique est vendue sous le nom de WEMOS D1 R32. Dans ce guide, on fait correspondre broche par broche le brochage de l'ESPDuino-32 avec celui de l'Uno, on voit quels shields Uno fonctionnent ou non, et on explique comment choisir la carte dans l'IDE Arduino.
Son grand atout : tu enfiches les shields Uno que tu possèdes déjà et tu ajoutes le Wi-Fi à ton projet. Mais il y a un piège important : l'Uno fonctionne en 5 V, alors que toutes les broches de signal de l'ESPDuino-32 fonctionnent en 3,3 V et ne tolèrent pas le 5 V. Les shields et les capteurs ignorent cette différence, et un mauvais branchement peut griller une broche, voire toute la carte. Commençons par faire connaissance avec la carte.

Qu'est-ce que l'ESPDuino-32 ? Comparaison avec l'Uno et l'ESP32 DevKit
Au cœur de l'ESPDuino-32 se trouve le module ESP32-WROOM-32, le même que sur les cartes ESP32 classiques. Côté logiciel, c'est donc un ESP32 tout à fait ordinaire : tous les croquis et bibliothèques écrits pour l'ESP32 y fonctionnent. La différence tient au dessin de la carte : les broches sont ramenées sur des connecteurs au format Uno, et la carte ajoute une prise jack, un régulateur 3,3 V et un convertisseur USB-série (le plus souvent un CH340). Si tu n'as jamais utilisé d'ESP32, les bases sont dans Qu'est-ce que l'ESP32 ?
| Caractéristique | Arduino Uno R3 | ESPDuino-32 | ESP32 DevKit |
|---|---|---|---|
| Processeur | ATmega328P, 8 bits, 16 MHz | ESP32, double cœur, 240 MHz | ESP32, double cœur, 240 MHz |
| RAM | 2 Ko | 520 Ko | 520 Ko |
| Mémoire flash | 32 Ko | 4 Mo | 4 Mo |
| Niveau logique | 5 V | 3,3 V | 3,3 V |
| Sans fil | Aucun | Wi-Fi + Bluetooth | Wi-Fi + Bluetooth |
| Entrées analogiques | 6 canaux, 10 bits | 6 canaux sur le connecteur Uno, 12 bits | Jusqu'à 18 canaux, 12 bits |
| Format et shields | 68,6 × 53,4 mm, shields Uno | Même format que l'Uno, accepte les shields | Se pique sur une plaque d'essai, pas de shields |
| Puce USB | ATmega16U2 | Le plus souvent CH340 | CP2102 ou CH340 |
Alors, laquelle choisir ? Si tu as des shields Uno, si tu veux visser la carte dans un boîtier grâce aux trous de fixation de l'Uno ou si tu suis un livre ou un cours écrit pour l'Uno, l'ESPDuino-32 te simplifie la vie. Si tu travailles sur plaque d'essai, si tu as besoin de broches de l'ESP32 qui n'arrivent pas sur le connecteur Uno, comme GPIO 32 et 33, ou si l'appareil doit rester compact, l'ESP32 DevKit classique convient mieux. Le code est le même sur les deux ; seuls les numéros de broches changent.
Brochage de l'ESPDuino-32 : quel GPIO derrière chaque broche Uno ?
Même si la carte est sérigraphiée D2, D3, A0 comme un Uno, ton code a presque toujours besoin du numéro de GPIO. Le tableau ci-dessous donne le GPIO de l'ESP32 derrière chaque broche Uno et les points de vigilance. Tu peux aussi consulter la liste complète des broches de l'ESP32 dans l'outil Pinout.
| Broche Uno | GPIO de l'ESP32 | Statut | Remarque |
|---|---|---|---|
| D0 (RX) | GPIO 3 | À éviter | Ligne série de l'USB |
| D1 (TX) | GPIO 1 | À éviter | Ligne série de l'USB |
| D2 | GPIO 26 | Sûre | Peut aussi servir de sortie DAC2 |
| D3 | GPIO 25 | Sûre | Peut aussi servir de sortie DAC1 |
| D4 | GPIO 17 | Sûre | Sert aussi de TX pour Serial2 |
| D5 | GPIO 16 | Sûre | Sert aussi de RX pour Serial2 |
| D6 | GPIO 27 | Sûre | Entrée tactile (T7) |
| D7 | GPIO 14 | Avec prudence | Émet un bref signal PWM au démarrage |
| D8 | GPIO 12 | Avec prudence | Broche de démarrage : si elle est HIGH à la mise sous tension, la carte ne démarre pas |
| D9 | GPIO 13 | Sûre | Entrée et sortie à usage général |
| D10 | GPIO 5 | Avec prudence | SPI SS ; émet un bref signal PWM au démarrage |
| D11 | GPIO 23 | Sûre | SPI MOSI |
| D12 | GPIO 19 | Sûre | SPI MISO |
| D13 | GPIO 18 | Sûre | SPI SCK ; pas de LED ici, contrairement à l'Uno |
| A0 | GPIO 2 | Avec prudence | ADC2 (aucune mesure quand le Wi-Fi est actif), LED intégrée, broche de démarrage |
| A1 | GPIO 4 | Avec prudence | ADC2 (aucune mesure quand le Wi-Fi est actif) |
| A2 | GPIO 35 | Entrée seule | ADC1, fonctionne avec le Wi-Fi |
| A3 | GPIO 34 | Entrée seule | ADC1, fonctionne avec le Wi-Fi |
| A4 | GPIO 36 (VP) | Entrée seule | ADC1 ; ce n'est pas SDA comme sur l'Uno |
| A5 | GPIO 39 (VN) | Entrée seule | ADC1 ; ce n'est pas SCL comme sur l'Uno |
| SDA | GPIO 21 | Sûre | Ligne de données I2C |
| SCL | GPIO 22 | Sûre | Ligne d'horloge I2C |
Côté analogique, deux autres pièges t'attendent. D'abord, A0 (GPIO 2) et A1 (GPIO 4) appartiennent à l'unité ADC2 de l'ESP32, qui ne peut pas mesurer quand le Wi-Fi est actif ; dans un projet Wi-Fi, branche tes capteurs analogiques sur A2–A5 (ADC1). Ensuite, l'ADC de l'ESP32 travaille sur 12 bits : analogRead() renvoie 0–4095 au lieu de 0–1023, et la pleine échelle est d'environ 3,3 V, pas de 5 V. Les calculs du type "valeur × 5,0 / 1023" des croquis Uno doivent être adaptés ; mieux encore, utilise analogReadMilliVolts(), qui renvoie un résultat calibré en millivolts.
Le piège du 3,3 V : les shields Uno marchent-ils sur l'ESPDuino-32 ?
Qu'un shield s'enfiche ne veut pas dire qu'il fonctionne. Un shield pose problème sur l'ESPDuino-32 de trois façons : il envoie un signal de 5 V dans l'ESP32 et abîme la broche, il attend une logique 5 V et ne considère pas toujours 3,3 V comme HIGH, ou il confie aux broches A2–A5, qui ne sont que des entrées, une tâche qui demande une sortie. Comme la broche 5V de la carte fournit 5 V comme sur l'Uno, le shield lui-même est bien alimenté ; les problèmes apparaissent toujours sur les broches de signal. Voici le bilan des shields courants :

| Shield | Statut | Pourquoi |
|---|---|---|
| CNC Shield V3 (A4988 / DRV8825) | Fonctionne en général | STEP et DIR tombent sur des GPIO capables de sortie ; les versions de GRBL pour ESP32 fournissent un brochage tout prêt pour cette carte |
| Shield relais | Fonctionne en général | Les relais sont alimentés par la broche 5V et le transistor qui les commande conduit aussi avec un signal de 3,3 V |
| Shield data logger (carte SD + RTC) | En partie | Une carte SD sur D10–D13 fonctionne, car ce sont les broches SPI de l'ESP32 ; la RTC échoue si son bus I2C n'est relié qu'à A4/A5 |
| Shield moteurs L293D | Peu fiable | Le 74HC595 en 5 V lit tout juste des entrées en 3,3 V, et sa ligne de données sur D8 (GPIO 12) peut en plus bloquer le démarrage |
| Shield LCD Keypad | Risqué | Les boutons arrivent sur A0 par une échelle de résistances reliée au 5 V : sans appui, GPIO 2 reçoit 5 V |
| Shield TFT parallèle 2,4 pouces | Ne fonctionne pas | Ses lignes de commande sont sur A0–A4 ; A2, A3 et A4 ne sont que des entrées et ne peuvent pas piloter l'écran |
| Anciens shields qui ne prennent l'I2C que sur A4/A5 | Ne fonctionne pas | Sur l'ESPDuino-32, l'I2C se trouve sur les broches SDA/SCL séparées (GPIO 21/22) |
Broches de démarrage (strapping) : attention à D8 et A0
À la mise sous tension, l'ESP32 lit le niveau de quelques broches pour décider comment démarrer. Sur l'ESPDuino-32, deux d'entre elles arrivent sur le connecteur Uno. Si D8 (GPIO 12) est HIGH au démarrage, l'ESP32 tente d'alimenter sa mémoire flash avec la mauvaise tension et la carte ne démarre pas. A0 (GPIO 2) doit rester en l'air ou à LOW pendant le téléversement. Si tu as branché sur D8 un module ou un shield avec une résistance de pull-up et que la carte ne démarre pas, c'est ton premier suspect. D7 (GPIO 14) et D10 (GPIO 5) émettent aussi un bref signal PWM au démarrage : un relais sur ces broches peut cliquer brièvement à la mise sous tension.
Installer l'ESPDuino-32 et choisir la carte dans l'IDE Arduino
- Installe dans l'IDE Arduino le paquet de cartes esp32 d'Espressif ; les étapes sont dans Qu'est-ce que l'ESP32 ?
- Branche la carte en USB. Si aucun port n'apparaît, installe le pilote de sa puce USB (le plus souvent un CH340) et vérifie que ton câble transmet bien les données.
- Dans Outils > Type de carte > esp32, choisis WEMOS D1 R32 : dans cette définition, les noms D2–D13 et A0–A5 correspondent exactement à la sérigraphie de la carte. DOIT ESPduino32 ou ESP32 Dev Module fonctionnent aussi, mais il faut alors n'utiliser que des numéros de GPIO.
- Choisis le port de la carte ; si le téléversement échoue avec un Upload Speed de 921600, descends à 115200.
- Clique sur Téléverser et ouvre le moniteur série à 115200 bauds. Si la carte n'entre pas en mode téléversement, vois les solutions de ESP32 Failed to Connect.
Premier test : LED intégrée, D13 et une mesure analogique
La LED bleue intégrée de la carte est reliée à GPIO 2, et non à D13 comme sur l'Uno. Le croquis ci-dessous allume tour à tour la LED intégrée et une LED branchée sur D13 (GPIO 18) via une résistance de 220 Ω, et affiche dans le moniteur série la valeur d'un potentiomètre branché sur A2 (GPIO 35). Relie les pattes extérieures du potentiomètre à 3V3 et à GND, pas au 5V ; le curseur va sur A2.
1// ESPDuino-32: Uno adları yerine GPIO numaraları / GPIO numbers instead of Uno pin names
2const int ONBOARD_LED = 2; // kart üstü mavi LED (A0 ile aynı pin) / onboard blue LED (same pin as A0)
3const int LED_D13 = 18; // Uno D13 = GPIO 18
4const int POT_A2 = 35; // Uno A2 = GPIO 35 (ADC1, yalnız giriş / input only)
5
6void setup() {
7 Serial.begin(115200);
8 pinMode(ONBOARD_LED, OUTPUT);
9 pinMode(LED_D13, OUTPUT);
10 analogReadResolution(12); // 0–4095 (varsayılan / default)
11}
12
13void loop() {
14 int raw = analogRead(POT_A2); // 0–4095, Uno'daki gibi 0–1023 değil / not 0–1023 like the Uno
15 int mv = analogReadMilliVolts(POT_A2); // kalibre edilmiş mV / calibrated millivolts
16 Serial.printf("A2 ham / raw: %d gerilim / voltage: %d mV\n", raw, mv);
17
18 digitalWrite(ONBOARD_LED, HIGH); // LED'ler sırayla / LEDs take turns
19 digitalWrite(LED_D13, LOW);
20 delay(500);
21 digitalWrite(ONBOARD_LED, LOW);
22 digitalWrite(LED_D13, HIGH);
23 delay(500);
24}Premier projet Wi-Fi : commander une LED depuis ton téléphone
Voyons maintenant ce qui distingue vraiment cette carte de l'Uno. Le croquis ci-dessous connecte l'ESPDuino-32 à ton réseau domestique et lance un petit serveur web. Tape l'adresse IP affichée dans le moniteur série dans le navigateur d'un téléphone connecté au même réseau : tu verras un bouton qui allume et éteint la LED de D13, ainsi que la mesure du potentiomètre de A2 en millivolts. On a mis le potentiomètre sur A2 exprès : quand le Wi-Fi est actif, A0 et A1 ne peuvent pas lire de valeurs analogiques.
1#include <WiFi.h>
2#include <WebServer.h>
3
4const char* WIFI_SSID = "AgAdi"; // Wi-Fi adın / your Wi-Fi name
5const char* WIFI_PASS = "Sifre123"; // Wi-Fi şifren / your Wi-Fi password
6
7const int LED_PIN = 18; // Uno D13 = GPIO 18
8const int POT_PIN = 35; // Uno A2 = GPIO 35 (ADC1: Wi-Fi ile çalışır / works with Wi-Fi)
9
10WebServer server(80);
11bool ledOn = false;
12
13String page() {
14 String html = "<!DOCTYPE html><html><head><meta charset='utf-8'>";
15 html += "<meta name='viewport' content='width=device-width,initial-scale=1'>";
16 html += "<title>ESPDuino-32</title></head>";
17 html += "<body style='font-family:sans-serif;text-align:center'><h1>ESPDuino-32</h1>";
18 html += "<p>LED (D13): <b>" + String(ledOn ? "ON" : "OFF") + "</b></p>";
19 html += "<p><a href='/toggle'><button style='font-size:24px;padding:12px 32px'>LED</button></a></p>";
20 html += "<p>A2: " + String(analogReadMilliVolts(POT_PIN)) + " mV</p>";
21 html += "</body></html>";
22 return html;
23}
24
25void handleRoot() {
26 server.send(200, "text/html", page());
27}
28
29void handleToggle() {
30 ledOn = !ledOn;
31 digitalWrite(LED_PIN, ledOn ? HIGH : LOW);
32 server.sendHeader("Location", "/"); // ana sayfaya dön / back to the main page
33 server.send(303);
34}
35
36void setup() {
37 Serial.begin(115200);
38 pinMode(LED_PIN, OUTPUT);
39
40 WiFi.mode(WIFI_STA);
41 WiFi.begin(WIFI_SSID, WIFI_PASS);
42 Serial.print("Baglaniyor / Connecting");
43 while (WiFi.status() != WL_CONNECTED) { // bağlanana kadar bekle / wait until connected
44 delay(500);
45 Serial.print(".");
46 }
47 Serial.println();
48 Serial.print("IP: ");
49 Serial.println(WiFi.localIP()); // bu adresi telefonda aç / open this address on your phone
50
51 server.on("/", handleRoot);
52 server.on("/toggle", handleToggle);
53 server.begin();
54}
55
56void loop() {
57 server.handleClient(); // gelen istekleri işle / handle incoming requests
58}Le croquis définit deux adresses : / envoie la page principale et /toggle inverse l'état de la LED puis renvoie le navigateur vers la page principale. À chaque rechargement de la page, le potentiomètre est relu. Pour une interface qui se met à jour en direct sans recharger, utilise la méthode de Serveur web asynchrone ESP32 et WebSocket. Si la carte ne se connecte pas, vérifie que ton réseau est en 2,4 GHz ; l'ESP32 ne voit pas les réseaux 5 GHz.
Alimentation : USB, prise jack et broche 3V3
| Source | Tension | Remarque |
|---|---|---|
| USB | 5 V | Suffisant pour le développement et les petits montages |
| Prise jack | En général 7–12 V (vérifie l'inscription sur ta carte) | Le régulateur chauffe ; en 9 V il reste plus frais qu'en 12 V |
| Broche VIN | La tension de la prise jack | Pour alimenter la carte depuis une source externe |
| Broche 5V | Sortie 5 V | Alimente les shields et modules 5 V ; pense à ramener leurs signaux à 3,3 V |
| Broche 3V3 | Sortie 3,3 V | Pour les capteurs ; n'y branche ni moteurs ni longs rubans de LED |
Quand il émet en Wi-Fi, l'ESP32 peut tirer des pointes de près de 250 mA. Un câble ou un port USB trop faible laisse la tension chuter à ces moments-là, et la carte redémarre avec "Brownout detector was triggered". Dans ce cas, prends un câble court et de bonne qualité ou alimente la carte par la prise jack ; les détails sont dans ESP32 Brownout et Guru Meditation.
Erreurs fréquentes et solutions
- Un croquis Uno ne fonctionne pas : les numéros de broches ont été écrits pour l'Uno. Sur l'ESPDuino-32, pinMode(13, OUTPUT) pilote GPIO 13, c'est-à-dire D9 et non D13 ; cherche le numéro de GPIO dans le tableau.
- analogRead renvoie toujours 4095 ou toujours 0 : le capteur est alimenté en 5 V et sa sortie dépasse 3,3 V, ou bien il est sur une broche ADC2 (A0, A1) alors que le Wi-Fi est actif.
- L'écran I2C n'est pas détecté : il est branché sur A4/A5 ; déplace les fils vers les broches SDA/SCL (GPIO 21/22).
- La carte ne démarre pas ou redémarre sans cesse : un élément branché sur D8 (GPIO 12) met la broche à HIGH à la mise sous tension ; déplace-le sur une autre broche.
- La carte ou un composant chauffe une fois le shield en place : le shield envoie du 5 V sur une broche ; débranche immédiatement la carte et abaisse cette ligne avec un pont diviseur ou un convertisseur de niveau.
- SoftwareSerial ou la bibliothèque Servo ne compilent pas : remplace les bibliothèques propres aux AVR par leurs équivalents ESP32 : le port série matériel Serial2 et ESP32Servo.
L'ESPDuino-32 est le passage le plus familier de l'Uno vers l'ESP32 : le même format, les mêmes connecteurs, mais une fréquence d'horloge 15 fois plus élevée et le sans-fil en plus. Garde Brochage de l'Arduino Uno sous la main pour te rappeler les différences. Tous les projets ESP32 de l'application BlueGrays fonctionnent aussi sur cette carte : tu peux réaliser pas à pas la LED, le feu tricolore, la connexion Wi-Fi et le serveur web avec leur schéma de câblage et leur code, il suffit de faire correspondre les broches grâce au tableau ci-dessus.
Questions fréquentes
L'ESPDuino-32 est-il identique à la WEMOS D1 R32 ?
En pratique, oui. Les deux placent un module ESP32-WROOM-32 sur une carte au format Uno, avec la même correspondance des broches sur les connecteurs Uno. L'IDE Arduino propose une définition pour chacune ; celle de la WEMOS D1 R32 est plus pratique, car elle relie les repères D et A de la carte aux bons GPIO.
Peut-on utiliser des shields Arduino Uno sur l'ESPDuino-32 ?
Ils s'enfichent, mais leur fonctionnement dépend du shield. Ceux qui n'envoient pas de signaux 5 V vers l'ESP32, n'utilisent pas A2–A5 comme sorties et ne prennent pas l'I2C uniquement sur A4/A5 fonctionnent généralement ; les shields LCD Keypad et TFT parallèle ne marchent pas sans modification.
L'ESPDuino-32 fonctionne-t-il en 5 V ?
La carte s'alimente en 5 V par l'USB ou la broche 5V et accepte une tension plus élevée par la prise jack. Ses broches de signal fonctionnent en revanche en 3,3 V et ne tolèrent pas le 5 V : les capteurs à sortie 5 V demandent un pont diviseur ou un convertisseur de niveau.
Sur quelle broche se trouve la LED intégrée de l'ESPDuino-32 ?
La LED bleue intégrée est reliée à GPIO 2, qui sort aussi sur la carte sous le nom A0. Contrairement à l'Uno, il n'y a pas de LED sur D13, et la constante LED_BUILTIN vaut 2.
Quelle carte choisir dans l'IDE Arduino pour l'ESPDuino-32 ?
Choisis WEMOS D1 R32 si tu veux utiliser dans ton code les repères de l'Uno, comme D2 ou A0. DOIT ESPduino32 ou ESP32 Dev Module téléversent le code tout aussi bien, mais il faut alors écrire les broches avec leur numéro de GPIO.
Pourquoi analogRead ne fonctionne-t-il pas sur mon ESPDuino-32 ?
Le plus souvent, le capteur est sur A0 ou A1 alors que le Wi-Fi est actif ; ces broches appartiennent à l'ADC2, qui ne peut pas mesurer en même temps que le Wi-Fi. Déplace le capteur sur A2–A5 (ADC1) et souviens-toi que le résultat va de 0 à 4095, avec une pleine échelle d'environ 3,3 V.
Projets à réaliser après cet article
Voir tous les projets
Clignotement LED avec ESP32
Enseigne l'utilisation de base des sorties GPIO avec l'ESP32. Nous obtenons un effet de clignotement en allumant et éteignant une LED à partir de la broche numérique. Version ESP32 du projet blink classique sur Arduino UNO ; les commandes de base de blink dans l'environnement Arduino restent les mêmes, mais le brochage et les niveaux GPIO de 3,3 V de l'ESP32 diffèrent de ceux de l'Arduino UNO.

Clignotement de la LED interne de l'ESP32
Faire clignoter la LED bleue intégrée à l'ESP32 DevKit V1. Aucun composant externe n'est nécessaire ! Le premier projet que vous devriez essayer lorsque vous achetez un ESP32. Le GPIO 2 est connecté à la LED interne.

Feu de circulation ESP32
Simulation d'un vrai feu de circulation avec 3 LED rouge-jaune-vert. Les temps sont proches de la logique du trafic réel : rouge long, jaune court, vert long. Exemple classique de contrôle séquentiel GPIO.

Mesure de l'intensité lumineuse avec le module LDR ESP32
Suivi en temps réel sur le moniteur série de la valeur brute de l'ADC du module LDR et du pourcentage relatif de luminosité calculé à partir de références dans l'obscurité et à la lumière. Ce pourcentage n'est pas une mesure en lux. Permet de comprendre le principe de calibrage du module. Il est préférable de réaliser cet exercice avant le projet 10, car il sert à déterminer la valeur seuil.

Luminosité d'une LED avec un Potentiomètre sur ESP32 (Analogique → PWM)
Dans ce projet, nous contrôlons la luminosité d'une LED de manière analogique à l'aide d'un potentiomètre. La broche ADC de l'ESP32 lit la tension entre 0 et 3,3 V provenant du potentiomètre, puis cette valeur est convertie en signal PWM (modulation de largeur d'impulsion) envoyé à la LED. Ainsi, la LED s'allume et s'éteint progressivement. Avec Arduino Core 3.0+, analogWrite() est utilisable directement; sur ESP32-S2/S3, la résolution de l'ADC est fixée à 12 bits.

Connexion Wi-Fi STA ESP32 (avec écran LCD)
Dans ce projet, nous connectons l'ESP32 au réseau Wi-Fi domestique en mode Station (STA) de manière sécurisée et tolérante aux pannes. Nous isolons SSID/mot de passe dans un fichier secrets.h pour empêcher leur fuite sur Git, mettons en place une reconnexion automatique, et affichons le niveau RSSI et l'adresse IP sur un écran LCD I2C. La LED intégrée sert d'indicateur d'état.

Serveur Web asynchrone ESP32 (avec affichage de l'adresse IP sur l'écran LCD)
On transforme l'ESP32 en serveur web asynchrone que tu pilotes depuis ton téléphone ou ton ordinateur sur le même réseau Wi-Fi. Grâce à la bibliothèque ESPAsyncWebServer, le serveur traite plusieurs requêtes à la fois (il ne bloque pas sur une seule requête comme le WebServer.h classique). Ouvre l'adresse IP de l'ESP32 dans le navigateur et allume ou éteins la LED sur GPIO 5 avec les boutons ON/OFF (adresses /on et /off).

ESP32 mDNS : accès à l'appareil via bluegrays-esp.local (avec écran LCD)
Dans ce projet, en ajoutant un service mDNS (Multicast DNS) à l'ESP32, nous permettons d'accéder à l'appareil via un nom d'hôte lisible, tel que bluegrays-esp.local, plutôt qu'à l'aide d'une adresse IP. Même si l'adresse IP attribuée par le DHCP venait à changer, vous pourrez toujours accéder à l'appareil sous le même nom. En exécutant également un petit serveur web sur l'appareil, nous envoyons des commandes de contrôle des LED depuis un navigateur via l'adresse http://bluegrays-esp.local/.
Autres articles
Application BlueGrays
Réalise ce montage pas à pas sur ton téléphone
Schéma, code et liste des composants sur un seul écran. Plus de 500 projets Arduino, ESP32 et Pico à réaliser.
Scanne avec ton téléphone
Pointe l’appareil photo vers le code : la boutique d’applications de ton téléphone s’ouvre.
ou ouvre la boutique

