Wemos D1 mini brochage : D0–D8 et GPIO, A0, shields, deep sleep
Brochage du Wemos D1 mini (ESP8266) : correspondance D0–D8 et GPIO, broches de démarrage, limite 3,2 V sur A0, shields relais, DHT, OLED et deep sleep D0–RST.
Le Wemos D1 mini loge la puce Wi-Fi ESP8266 sur une carte de 34 × 26 mm qu'on programme directement en USB et qu'on enrichit avec des shields empilables : c'est l'une des mini-cartes de développement les plus populaires. Petit, bon marché et compatible avec l'Arduino IDE, il s'impose pour les capteurs Wi-Fi, les prises connectées et les contrôleurs de rubans LED. Le piège : les repères D0–D8 sérigraphiés sur la carte ne sont pas des numéros de GPIO, et certaines broches mal utilisées empêchent tout simplement la carte de démarrer : d'où l'intérêt d'avoir sous les yeux le brochage du Wemos D1 mini.
Ce guide rassemble tout le brochage du Wemos D1 mini dans un seul tableau, avec le GPIO de chaque broche. Avec du code d'exemple, on verra quelles broches posent problème au démarrage (boot), pourquoi l'entrée analogique A0 plafonne à 3,2 V, quelles broches utilisent les shields relais, DHT et OLED, et pourquoi il faut relier D0 à RST pour le deep sleep. Pour finir, un coup d'œil rapide aux cousins à base d'ESP32.

Qu'est-ce que le Wemos D1 mini ? Caractéristiques
Le D1 mini a été conçu par Wemos (devenu LOLIN) et, comme son schéma est ouvert, de nombreux fabricants l'ont cloné. Le module ESP-12 sous capot métallique contient le processeur ESP8266EX et 4 Mo de flash ; la carte ajoute un convertisseur USB-série, un régulateur qui abaisse le 5 V en 3,3 V et le bouton RESET. On trouve surtout la version v3 en micro-USB et la v4 en USB-C ; le brochage est identique sur toutes.
| Caractéristique | Valeur |
|---|---|
| Puce | ESP8266EX, 32 bits, 80/160 MHz |
| Flash | 4 Mo (D1 mini Pro : 16 Mo) |
| RAM | 80 Ko de mémoire de données (environ 40–50 Ko libres avec le Wi-Fi actif) |
| Wi-Fi | 802.11 b/g/n, 2,4 GHz uniquement |
| Broches numériques | 11 (D0–D8, TX, RX) |
| Entrée analogique | 1 (A0, 0–3,2 V, 10 bits) |
| Niveau logique | 3,3 V (alimentation par USB ou par la broche 5V) |
| Puce USB-série | Le plus souvent CH340 |
| Dimensions | 34,2 × 25,6 mm |
Brochage du Wemos D1 mini : D0–D8 et leurs GPIO
L'erreur la plus fréquente consiste à écrire le repère de la carte comme un nombre dans le code. Si tu écris pinMode(4, OUTPUT) dans l'Arduino IDE, la carte n'utilise pas D4 mais le GPIO 4, c'est-à-dire D2. Dans ton code, utilise soit les constantes comme D4 (définies quand la carte D1 mini est sélectionnée), soit le numéro de GPIO du tableau. Tu peux aussi consulter le brochage de ta carte avec l'outil Pinout.
| Repère | GPIO | Fonction spéciale | Remarque |
|---|---|---|---|
| TX | GPIO 1 | UART TX (moniteur série) | Émet des données au démarrage ; à laisser libre si tu utilises Serial |
| RX | GPIO 3 | UART RX | À l'état HIGH au démarrage ; à laisser libre si tu utilises Serial |
| D0 | GPIO 16 | Réveil du deep sleep (relié à RST) | Pas de PWM, d'interruptions ni d'I2C ; HIGH au démarrage |
| D1 | GPIO 5 | I2C SCL | Sûre ; broche par défaut du shield relais |
| D2 | GPIO 4 | I2C SDA | Sûre |
| D3 | GPIO 0 | FLASH, rappel de 10 kΩ | À LOW au démarrage, la carte passe en mode programmation |
| D4 | GPIO 2 | LED intégrée (logique inversée), rappel de 10 kΩ | À LOW au démarrage, la carte ne démarre pas ; broche du shield DHT |
| D5 | GPIO 14 | SPI SCK | Sûre |
| D6 | GPIO 12 | SPI MISO | Sûre |
| D7 | GPIO 13 | SPI MOSI | Sûre |
| D8 | GPIO 15 | SPI CS, rappel au niveau bas de 10 kΩ | À HIGH au démarrage, la carte ne démarre pas ; CS du shield SD |
| A0 | ADC0 | Entrée analogique | 0–3,2 V ; pont diviseur 220 kΩ / 100 kΩ sur la carte |
| RST | - | Reset (actif à LOW) | Relié à D0 pour le deep sleep |
| 3V3 | - | Sortie 3,3 V | Alimente tes capteurs ici |
| 5V | - | 5 V de l'USB / entrée 5 V externe | Sortie avec l'USB branché, sinon entrée d'alimentation |
| G | - | GND | Masse commune |
En résumé, les broches utilisables sans risque pour tout sont D1, D2, D5, D6 et D7. D0 convient aux sorties simples et au réveil du deep sleep, mais n'a ni PWM ni interruptions. D3 et D4 conviennent aux boutons (tant qu'ils ne sont pas enfoncés au démarrage) et aux LED. Toutes les broches sauf D0 disposent d'une résistance de rappel interne (INPUT_PULLUP) ; D0 n'a qu'un rappel au niveau bas interne. Avec la version 3.x du core ESP8266, analogWrite() travaille par défaut sur 0–255 à 1 kHz. Une broche fournit au maximum environ 12 mA : pour un relais, un moteur ou un long ruban LED, passe par un transistor ou un driver.
Installer le Wemos D1 mini dans l'Arduino IDE
- Dans Fichier > Préférences, ajoute http://arduino.esp8266.com/stable/package_esp8266com_index.json dans « URL de gestionnaire de cartes supplémentaires » ; sépare-la des autres adresses par une virgule.
- Cherche esp8266 dans le gestionnaire de cartes et installe le paquet ESP8266 Community.
- Choisis LOLIN(WEMOS) D1 R2 & mini dans Outils > Type de carte > ESP8266 Boards.
- Si aucun port n'apparaît, installe le pilote CH340 et utilise un câble USB de données, pas un simple câble de charge.
- Si le téléversement échoue à 921600, baisse Upload Speed à 115200.
Premier programme : faire clignoter la LED intégrée
La petite LED bleue du module ESP-12 est reliée au GPIO 2 (D4) et fonctionne en logique inversée : elle s'allume quand la broche est à LOW et s'éteint à HIGH. LED_BUILTIN vaut 2 pour le D1 mini, donc le code ci-dessous fonctionne sans aucune modification :
1// D1 mini dahili LED: D4 = GPIO 2, LOW'da yanar / onboard LED: D4 = GPIO 2, lights on LOW
2void setup() {
3 pinMode(LED_BUILTIN, OUTPUT); // LED_BUILTIN = 2 (D4)
4}
5
6void loop() {
7 digitalWrite(LED_BUILTIN, LOW); // LED yanar (ters mantık) / LED on (inverted logic)
8 delay(500);
9 digitalWrite(LED_BUILTIN, HIGH); // LED söner / LED off
10 delay(500);
11}L'entrée analogique A0 : la limite de 3,2 V et la mesure de tension
L'unique convertisseur analogique-numérique (CAN) de l'ESP8266 ne mesure en réalité que 0 à 1,0 V sur 10 bits (0–1023). Le D1 mini place derrière la broche A0 un pont diviseur de 220 kΩ et 100 kΩ : la tension qui arrive au CAN vaut Ve × 100 / (220 + 100), donc 3,2 V sur A0 arrivent à la puce sous forme de 1,0 V. D'où la formule de conversion V = brut × 3,2 / 1023. Pour mesurer une tension plus élevée, ajoute une résistance en série devant A0 : avec 100 kΩ de plus, le haut du pont passe à 320 kΩ et la pleine échelle monte à 1,0 × (320 + 100) / 100 = 4,2 V, soit exactement la tension d'un accu Li-ion chargé. Tu peux calculer d'autres rapports avec l'outil Pont diviseur.
| Tension sur A0 | Arrive à la puce | analogRead() (env.) |
|---|---|---|
| 0 V | 0 V | 0 |
| 1,0 V | 0,31 V | 320 |
| 1,65 V | 0,52 V | 527 |
| 3,2 V | 1,0 V | 1023 |
| 3,3 V | 1,03 V | 1023 (saturé) |
1// A0: kartta 220k/100k bölücü, 0–3,2 V → 0–1023 / on-board 220k/100k divider, 0–3.2 V → 0–1023
2const float FULL_SCALE = 3.2; // ek 100 kΩ seri dirençle 4.2 olur / 4.2 with an extra 100 kΩ in series
3
4void setup() {
5 Serial.begin(115200);
6}
7
8void loop() {
9 long sum = 0;
10 for (int i = 0; i < 16; i++) { // 16 ölçümün ortalaması / average of 16 readings
11 sum += analogRead(A0);
12 delay(10); // Wi-Fi'ye zaman bırak / leave time for Wi-Fi
13 }
14 float raw = sum / 16.0;
15 float volts = raw * FULL_SCALE / 1023.0;
16 Serial.print("A0 ham / raw: ");
17 Serial.print(raw, 0);
18 Serial.print(" gerilim / voltage: ");
19 Serial.print(volts, 2);
20 Serial.println(" V");
21 delay(1000);
22}Les shields du Wemos D1 mini : relais, DHT, OLED et autres
Le grand atout du D1 mini, ce sont les shields au même format qui s'enfichent directement au-dessus ou en dessous de la carte grâce aux connecteurs femelles. Pas de soudure ni de câbles ; mais comme chaque shield utilise une broche fixe, il faut vérifier que les shields empilés ne partagent pas de broche. Voici les plus courants et leurs broches :
| Shield | Broche utilisée | Remarque |
|---|---|---|
| Shield relais | D1 (GPIO 5) | Contacts en général 10 A / 250 V AC ; entre en conflit avec le SCL de l'I2C |
| Shield DHT (DHT11 ou DHT22 Pro) | D4 (GPIO 2) | Même broche que la LED intégrée ; le capteur subit la chaleur de la carte |
| Shield SHT30 | D1, D2 (I2C) | Plus précis qu'un DHT ; adresse I2C 0x45 |
| Shield OLED 0,66" | D1 (SCL), D2 (SDA) | 64×48 pixels, contrôleur SSD1306, adresse 0x3C |
| Shield Micro SD | D5, D6, D7, D8 (CS) | SPI ; D8 doit rester à LOW au démarrage |
| Shield batterie | Aucune broche | Charge un accu LiPo et alimente la carte par la broche 5V |
Le tableau révèle le piège principal : le shield relais utilise D1 par défaut, et cette broche est aussi la ligne d'horloge de l'I2C. Empile le relais avec le shield OLED ou SHT30 et aucun des deux ne fonctionne correctement. Certaines versions du shield relais permettent de changer de broche avec un pont de soudure au dos ; sinon, relie le relais par un fil à l'une des broches D5–D7. Si tu enfiches le shield DHT directement sur la carte, la chaleur de l'ESP8266 lui fait afficher 1 à 3 °C de trop ; éloigne le capteur avec une base double (dual base) ou un petit câble. Le code ci-dessous associe le shield DHT et le shield relais pour faire un thermostat de ventilateur simple :
1#include <DHT.h>
2
3const uint8_t DHT_PIN = 2; // D4 = GPIO 2 (DHT shield)
4const uint8_t RELAY_PIN = 5; // D1 = GPIO 5 (röle shield / relay shield)
5const float ON_ABOVE = 28.0; // bunun üstünde fan açılır / fan on above this
6const float OFF_BELOW = 26.5; // bunun altında kapanır (histerezis) / off below this (hysteresis)
7
8DHT dht(DHT_PIN, DHT11); // DHT Pro shield için DHT22 / DHT22 for the DHT Pro shield
9bool fanOn = false;
10
11void setup() {
12 Serial.begin(115200);
13 pinMode(RELAY_PIN, OUTPUT);
14 digitalWrite(RELAY_PIN, LOW); // röle kapalı başlasın / start with the relay off
15 dht.begin();
16}
17
18void loop() {
19 float t = dht.readTemperature();
20 if (!isnan(t)) { // hatalı ölçümü atla / skip failed readings
21 if (!fanOn && t > ON_ABOVE) fanOn = true;
22 if (fanOn && t < OFF_BELOW) fanOn = false;
23 digitalWrite(RELAY_PIN, fanOn ? HIGH : LOW); // HIGH = röle çeker / HIGH = relay on
24 Serial.print(t, 1);
25 Serial.println(fanOn ? " C fan ON" : " C fan OFF");
26 }
27 delay(2000);
28}Les deux seuils du code (marche à 28 °C, arrêt à 26,5 °C) créent une hystérésis : avec un seul seuil, le relais claquerait toutes les secondes pendant que la température oscille entre 28,0 et 28,1, et le relais comme le ventilateur s'useraient. Pour câbler un relais en toute sécurité, consulte Qu'est-ce qu'un module relais ?. Le shield OLED est un minuscule écran SSD1306 de 64×48 pixels ; la bibliothèque standard Adafruit SSD1306 ne gère pas cette taille, le plus simple est donc d'utiliser la bibliothèque U8g2. Cet exemple affiche la tension sur A0 sous forme de nombre et de barre :
1#include <Wire.h>
2#include <U8g2lib.h>
3
4// 0,66" OLED shield: 64×48, I2C D1 (SCL) / D2 (SDA) / 0.66" OLED shield: 64×48, I2C on D1/D2
5U8G2_SSD1306_64X48_ER_F_HW_I2C oled(U8G2_R0, U8X8_PIN_NONE);
6
7void setup() {
8 oled.begin();
9}
10
11void loop() {
12 float volts = analogRead(A0) * 3.2 / 1023.0; // A0 → volt
13 oled.clearBuffer();
14 oled.setFont(u8g2_font_6x10_tf);
15 oled.drawStr(0, 10, "D1 mini");
16 oled.setCursor(0, 28);
17 oled.print(volts, 2);
18 oled.print(" V");
19 oled.drawFrame(0, 36, 64, 10); // çubuk çerçevesi / bar frame
20 oled.drawBox(2, 38, (int)(volts / 3.2 * 60), 6); // gerilim çubuğu / voltage bar
21 oled.sendBuffer();
22 delay(500);
23}Deep sleep : le pont D0–RST et le fonctionnement sur batterie
En deep sleep, l'ESP8266 coupe complètement le processeur et le Wi-Fi ; seul son temporisateur RTC interne continue de tourner. Quand le délai est écoulé, la RTC met brièvement le GPIO 16 (D0) à LOW. Si D0 est relié à la broche RST, cette impulsion réinitialise la puce et ton code repart de setup(). Sans ce pont, la carte ne se réveille jamais. Comme le réveil est un redémarrage, les variables ordinaires sont perdues ; les petites données comme un compteur de mesures peuvent être gardées dans les 512 octets de mémoire utilisateur de la RTC. Un sommeil dure au maximum environ 3,5 heures ; pour des périodes plus longues, rendors la carte plusieurs fois de suite.
| État | Consommation approximative |
|---|---|
| Envoi de données en Wi-Fi | 70–170 mA |
| Wi-Fi connecté, au repos (modem sleep) | 15–20 mA |
| Light sleep | Environ 1 mA |
| Deep sleep (puce ESP8266 seule) | Environ 20 µA |
| Deep sleep (carte D1 mini complète) | 80–200 µA (à cause du régulateur et de la puce USB-série) |
1// D0 (GPIO 16) ile RST arasına kablo tak / wire D0 (GPIO 16) to RST
2const uint64_t SLEEP_US = 10ULL * 60 * 1000000; // 10 dakika, mikrosaniye / 10 minutes in µs
3
4void setup() {
5 Serial.begin(115200);
6 delay(100);
7 float volts = analogRead(A0) * 3.2 / 1023.0; // ölç / measure
8 Serial.print("A0: ");
9 Serial.print(volts, 2);
10 Serial.println(" V");
11 // Wi-Fi ile gönderim burada yapılır / send the reading over Wi-Fi here
12 Serial.println("10 dk uyku / sleeping 10 min");
13 ESP.deepSleep(SLEEP_US); // uyanınca setup() baştan başlar / wakes up into setup()
14}
15
16void loop() {
17 // buraya hiç gelinmez / never reached
18}On peut estimer l'autonomie avec un calcul rapide. Imaginons que la carte se réveille toutes les 10 minutes, consomme en moyenne 80 mA pendant 5 secondes pour envoyer ses données et dorme à 0,15 mA pendant les 595 secondes restantes. Chaque cycle consomme 5 × 80 = 400 mAs plus 595 × 0,15 ≈ 89 mAs ; soit 489 mAs au total, ce qui donne une moyenne de 0,82 mA sur 600 secondes. Un accu 18650 de 2000 mAh tient alors 2000 / 0,82 ≈ 2440 heures, environ 100 jours. Fais le calcul avec tes propres valeurs grâce à l'outil Autonomie de la batterie, et retrouve l'équivalent pour l'ESP32 dans ESP32 Deep Sleep.
Wemos D1 mini, NodeMCU ou D1 mini ESP32 ?
| Carte | Puce | Point fort | Quand la choisir ? |
|---|---|---|---|
| Wemos D1 mini | ESP8266 | Très petite, système de shields | Petits capteurs Wi-Fi, projets avec shields |
| NodeMCU V3 | ESP8266 | Plus grande, broches repérées | Prototypage confortable sur breadboard |
| D1 mini ESP32 (MiniKit) | ESP32-WROOM-32 | Brochage D1 mini + rangée intérieure en plus | Bluetooth, plus de voies ADC et plus de mémoire |
| LOLIN S2 mini / C3 mini | ESP32-S2 / ESP32-C3 | Format D1 mini, compatible shields | USB natif (S2), BLE et faible consommation (C3) |
Sur les cartes D1 mini ESP32, les rangées de broches extérieures correspondent aux shields du D1 mini : tu peux donc enficher tel quel le shield relais ou OLED. En revanche, sur l'ESP32 les repères D correspondent à d'autres GPIO ; les broches I2C, par exemple, sont D1 = GPIO 22 et D2 = GPIO 21. Dans le code, utilise WiFi.h au lieu d'ESP8266WiFi.h et adapte les numéros de broche au brochage de la carte. La version ESP32 lit les entrées analogiques sur 12 bits (0–4095), a le Bluetooth et beaucoup plus de mémoire. Si tu hésites, compare Qu'est-ce que l'ESP32 ? et NodeMCU ESP8266.
Idées de projets avec le Wemos D1 mini
- Thermomètre Wi-Fi sur batterie : Avec un shield SHT30 ou DHT, le shield batterie et le deep sleep, envoie une mesure toutes les 10 minutes.
- Prise connectée : Allume une lampe depuis ton téléphone avec le shield relais ; lis le guide du module relais pour un câblage sûr.
- Contrôleur de ruban LED : Installe WLED et pilote un ruban WS2812B depuis ton téléphone.
- Capteur de porte : Envoie une notification à l'ouverture de la porte grâce à un interrupteur reed.
- Mini-écran de bureau : Affiche l'heure, la météo ou de petits graphiques sur le shield OLED, comme sur un écran OLED plus grand.
- Capteur domotique : Envoie les valeurs à Home Assistant via MQTT.
Erreurs fréquentes et solutions
| Symptôme | Cause probable | Solution |
|---|---|---|
| Aucun port visible | Pilote CH340 absent ou câble de charge seulement | Installe le pilote, utilise un câble de données |
| La mauvaise broche réagit | Le code indique 4 au lieu de D4 | Utilise les constantes D ou le GPIO du tableau |
| La carte ne démarre pas, le code ne tourne pas | Un montage sur D3, D4 ou D8 perturbe le niveau de démarrage | Déplace le montage vers des broches sûres (D1, D2, D5–D7) |
| Le Wi-Fi décroche souvent | analogRead() appelé sans pause ou alimentation faible | Ajoute une pause entre les mesures, utilise une bonne alimentation 5 V |
| Ne se réveille pas du deep sleep | D0 n'est pas relié à RST | Relie D0 à RST par un fil, une résistance ou une diode |
| Relais et OLED ne marchent pas ensemble | Les deux utilisent D1 | Change la broche du relais ou câble-le sur une autre broche |
| La LED fonctionne à l'envers | La LED intégrée s'allume à LOW | Inverse la logique : LOW = allumée, HIGH = éteinte |
Avec sa taille minuscule, son système de shields et son Wi-Fi, le Wemos D1 mini est l'une des portes d'entrée les plus simples vers la domotique et les projets à capteurs. Tant que tu gardes en tête le tableau des broches et les règles de démarrage, presque tous les exemples ESP8266 fonctionnent du premier coup. Dans l'application BlueGrays, tu trouveras schémas et code pas à pas dans les projets ESP (clignotement de LED, connexion Wi-Fi, serveur web, OTA et deep sleep), et tu peux les essayer sur le D1 mini en adaptant les numéros de broche grâce à ce tableau.
Questions fréquentes
À quel GPIO correspond D4 sur le Wemos D1 mini ?
D4 correspond au GPIO 2, auquel est aussi reliée la LED bleue intégrée. Dans le code, tu peux écrire pinMode(D4, OUTPUT) ou pinMode(2, OUTPUT), alors que pinMode(4, OUTPUT) sélectionne D2. La LED fonctionne en logique inversée : elle s'allume à LOW.
Le Wemos D1 mini fonctionne-t-il en 5 V ?
Oui, la carte peut être alimentée en 5 V par l'USB ou par la broche 5V ; son régulateur abaisse la tension à 3,3 V. Les broches GPIO fonctionnent toutefois en logique 3,3 V : pour des capteurs à sortie 5 V, passe par un pont diviseur ou un convertisseur de niveau.
Quelle tension peut mesurer la broche A0 du Wemos D1 mini ?
Grâce au pont diviseur 220 kΩ / 100 kΩ de la carte, la broche A0 mesure 0 à 3,2 V sous forme de 0–1023. La puce ESP8266 nue ne mesure que 0 à 1,0 V. En ajoutant une résistance de 100 kΩ en série devant A0, la plage monte à 4,2 V, de quoi lire un accu Li-ion.
Pourquoi mon Wemos D1 mini ne se réveille-t-il pas du deep sleep ?
Pour se réveiller, l'ESP8266 a besoin de l'impulsion de reset que la RTC envoie sur D0 (GPIO 16). Si tu ne relies pas D0 à RST par un fil, une résistance de 470 Ω à 1 kΩ ou une diode Schottky, la carte reste endormie. Vérifie aussi que la durée est bien indiquée en microsecondes.
Quelle différence entre le Wemos D1 mini et le NodeMCU ?
Les deux utilisent la même puce ESP8266 et leurs repères D0–D8 correspondent aux mêmes GPIO, donc les programmes fonctionnent sans modification. Le D1 mini est bien plus petit et accepte des shields empilables ; le NodeMCU est plus grand et plus pratique sur une breadboard.
Le Wemos D1 mini a-t-il le Bluetooth ?
Non, l'ESP8266 ne gère que le Wi-Fi. Si tu as besoin du Bluetooth, prends un D1 mini ESP32 ou la LOLIN C3 mini à base d'ESP32-C3 : même format, et compatibles avec les shields du D1 mini.
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.

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

Mode veille profonde de l'ESP32 — Économie de batterie (OLED + compteur RAM RTC)
Le mode Deep Sleep de l'ESP32 coupe le CPU et la plupart des périphériques et réduit la consommation à environ 10µA, un point clé pour les objets IoT sur batterie. Ce projet utilise trois sources de réveil : un minuteur (15 s), une broche externe (EXT0, le bouton sur GPIO 33) et une broche tactile (T0/GPIO 4). Les compteurs marqués RTC_DATA_ATTR sont conservés pendant le deep sleep.

Mise à jour OTA de l'ESP32 — Installation sans fil du firmware (avec écran LCD)
Tu vas apprendre à charger un nouveau firmware sur l'ESP32 par Wi-Fi, sans câble USB. Avec la bibliothèque ArduinoOTA, l'ESP32 devient visible sur le réseau et apparaît automatiquement sous le nom bluegrays-ota dans l'onglet "Network port" de l'Arduino IDE. Le premier téléversement se fait en USB, ensuite toutes les mises à jour passent sans fil, un atout clé pour les appareils installés sur le terrain.

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

Éclairage Intelligent ESP32 (PIR + LDR + Relais + OLED)
Avec un ESP32, un capteur de mouvement PIR, un capteur de lumière LDR et un module relais, on transforme ton couloir, tes toilettes ou ton cellier en éclairage intelligent. Si la pièce est déjà claire, la lumière reste éteinte malgré le mouvement : pas de gaspillage d'énergie en journée. La lumière reste allumée 30 secondes et la durée se prolonge automatiquement tant que le mouvement continue.
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

