Composants · 9 min de lecture

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.

Carte de développement ESPDuino-32
ESPDuino-32 : un module ESP32-WROOM-32 sur une carte au format Uno, avec puce USB-série, prise jack d'alimentation et connecteurs placés au même endroit que sur l'Uno.

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éristiqueArduino Uno R3ESPDuino-32ESP32 DevKit
ProcesseurATmega328P, 8 bits, 16 MHzESP32, double cœur, 240 MHzESP32, double cœur, 240 MHz
RAM2 Ko520 Ko520 Ko
Mémoire flash32 Ko4 Mo4 Mo
Niveau logique5 V3,3 V3,3 V
Sans filAucunWi-Fi + BluetoothWi-Fi + Bluetooth
Entrées analogiques6 canaux, 10 bits6 canaux sur le connecteur Uno, 12 bitsJusqu'à 18 canaux, 12 bits
Format et shields68,6 × 53,4 mm, shields UnoMême format que l'Uno, accepte les shieldsSe pique sur une plaque d'essai, pas de shields
Puce USBATmega16U2Le plus souvent CH340CP2102 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 UnoGPIO de l'ESP32StatutRemarque
D0 (RX)GPIO 3À éviterLigne série de l'USB
D1 (TX)GPIO 1À éviterLigne série de l'USB
D2GPIO 26SûrePeut aussi servir de sortie DAC2
D3GPIO 25SûrePeut aussi servir de sortie DAC1
D4GPIO 17SûreSert aussi de TX pour Serial2
D5GPIO 16SûreSert aussi de RX pour Serial2
D6GPIO 27SûreEntrée tactile (T7)
D7GPIO 14Avec prudenceÉmet un bref signal PWM au démarrage
D8GPIO 12Avec prudenceBroche de démarrage : si elle est HIGH à la mise sous tension, la carte ne démarre pas
D9GPIO 13SûreEntrée et sortie à usage général
D10GPIO 5Avec prudenceSPI SS ; émet un bref signal PWM au démarrage
D11GPIO 23SûreSPI MOSI
D12GPIO 19SûreSPI MISO
D13GPIO 18SûreSPI SCK ; pas de LED ici, contrairement à l'Uno
A0GPIO 2Avec prudenceADC2 (aucune mesure quand le Wi-Fi est actif), LED intégrée, broche de démarrage
A1GPIO 4Avec prudenceADC2 (aucune mesure quand le Wi-Fi est actif)
A2GPIO 35Entrée seuleADC1, fonctionne avec le Wi-Fi
A3GPIO 34Entrée seuleADC1, fonctionne avec le Wi-Fi
A4GPIO 36 (VP)Entrée seuleADC1 ; ce n'est pas SDA comme sur l'Uno
A5GPIO 39 (VN)Entrée seuleADC1 ; ce n'est pas SCL comme sur l'Uno
SDAGPIO 21SûreLigne de données I2C
SCLGPIO 22SûreLigne d'horloge I2C
Ici, A4 et A5 ne sont pas de l'I2C. Sur l'Uno, A4 et A5 servent aussi de SDA et SCL ; sur l'ESPDuino-32, elles sont reliées à GPIO 36 et 39 et ne fonctionnent qu'en entrée. Pour les écrans et capteurs I2C, utilise les broches séparées SDA (GPIO 21) et SCL (GPIO 22) situées à côté d'AREF.

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 de commande de moteurs L293D
Shield moteurs L293D : son registre à décalage 74HC595 fonctionne en 5 V et ne reconnaît que de justesse les signaux 3,3 V de l'ESPDuino-32.
ShieldStatutPourquoi
CNC Shield V3 (A4988 / DRV8825)Fonctionne en généralSTEP 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 relaisFonctionne en généralLes 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 partieUne 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 L293DPeu fiableLe 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 KeypadRisqué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 poucesNe fonctionne pasSes 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/A5Ne fonctionne pasSur l'ESPDuino-32, l'I2C se trouve sur les broches SDA/SCL séparées (GPIO 21/22)
Pour juger de la compatibilité d'un shield, regarde son schéma et pose deux questions : envoie-t-il un signal de 5 V vers une broche ? Utilise-t-il l'une des broches A2–A5 comme sortie ? Si la réponse est non aux deux, il y a de fortes chances qu'il fonctionne. Si une seule ligne envoie du 5 V, intercale un pont diviseur de tension ou un convertisseur de niveau logique.

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

  1. Installe dans l'IDE Arduino le paquet de cartes esp32 d'Espressif ; les étapes sont dans Qu'est-ce que l'ESP32 ?
  2. 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.
  3. 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.
  4. Choisis le port de la carte ; si le téléversement échoue avec un Upload Speed de 921600, descends à 115200.
  5. 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.
Le choix de la carte change la signification de A0. Avec ESP32 Dev Module, le A0 de ton code désigne GPIO 36, c'est-à-dire la broche marquée A4 sur l'ESPDuino-32 ; avec DOIT ESPduino32, selon la version du core, A0 peut ne pas être défini du tout et le compilateur s'arrête sur une erreur. Le plus simple pour éviter la confusion est de toujours écrire des numéros de GPIO dans ton code.

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.

C++ (Arduino IDE)
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.

C++ (Arduino IDE)
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

SourceTensionRemarque
USB5 VSuffisant pour le développement et les petits montages
Prise jackEn 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 VINLa tension de la prise jackPour alimenter la carte depuis une source externe
Broche 5VSortie 5 VAlimente les shields et modules 5 V ; pense à ramener leurs signaux à 3,3 V
Broche 3V3Sortie 3,3 VPour 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.

Voir tous les projets
Clignotement LED avec ESP32
ES-1Débutant

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.

4.7(37)
108
Clignotement de la LED interne de l'ESP32
ES-4Débutant

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.

4.8(29)
54
Feu de circulation ESP32
ES-5Débutant

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.

4.4(22)
45
Mesure de l'intensité lumineuse avec le module LDR ESP32
ES-11Débutant

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.

4.6(36)
55
Luminosité d'une LED avec un Potentiomètre sur ESP32 (Analogique → PWM)
ES-13Intermédiaire
Premium

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.

4.5(19)
32
Connexion Wi-Fi STA ESP32 (avec écran LCD)
ES-25Avancé

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.

4.4(21)
38
Serveur Web asynchrone ESP32 (avec affichage de l'adresse IP sur l'écran LCD)
ES-27Avancé

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

4.8(16)
26
ESP32 mDNS : accès à l'appareil via bluegrays-esp.local (avec écran LCD)
ES-29Avancé
Premium

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

4.8(14)
23