ESP32 pour débutants : 6 projets WiFi avec code complet et câblage
ESP32 pour débutant : 6 projets WiFi expliqués, du variateur de LED au capteur sur batterie, avec câblage 3,3 V, code Arduino core 3.x et MicroPython.

Cet article contient des liens d'affiliation : si tu achètes via ces liens, Press & Pixel touche une commission, sans surcoût pour toi. Ça ne change pas nos verdicts. Comment on travaille.
Six projets pour apprendre l'ESP32 en partant de zéro : variateur de LED, thermomètre consultable depuis ton téléphone, alerte de mouvement, capteur qui tient sur batterie, mesure de niveau par ultrasons et version MicroPython. Quatre composants courants suffisent pour tout faire, une soirée par projet, et du code compatible avec le cœur Arduino ESP32 3.x.
Débuter avec l'ESP32, c'est apprendre le microcontrôleur et le WiFi d'un coup : la même carte de quelques euros lit un capteur, sert une page web et t'envoie une notification. Les six projets ci-dessous montent en difficulté, réutilisent les mêmes composants et tiennent chacun dans une soirée. Le code vise le cœur Arduino ESP32 3.x d'Espressif, avec une version MicroPython pour finir.
| Projet | Niveau | Composants en plus de l'ESP32 | Durée indicative |
|---|---|---|---|
| 1. Variateur de LED | Débutant | 1 LED, 1 résistance 220 Ω | 30 min |
| 2. Thermomètre web | Débutant | DHT22 | 1 h |
| 3. Alerte mouvement sur téléphone | Intermédiaire | PIR HC-SR501 | 1 h |
| 4. Capteur sur batterie | Intermédiaire | DHT22, batterie | 1 h 30 |
| 5. Niveau de cuve par ultrasons | Intermédiaire | HC-SR04, 2 résistances | 1 h |
| 6. Thermomètre en MicroPython | Débutant | DHT22 | 1 h |
Préparer l'IDE Arduino pour l'ESP32 en 2026
Dans l'IDE Arduino 2, ouvre Préférences et colle l'URL du gestionnaire de cartes d'Espressif : https://espressif.github.io/arduino-esp32/package_esp32_index.json (doc d'installation). Dans le gestionnaire de cartes, cherche « esp32 » et installe le paquet d'Espressif Systems, puis choisis « ESP32 Dev Module ».
Point d'actualité : la version 4.0.0 du cœur, basée sur ESP-IDF 6.1.1, est sortie le 19 novembre 2026, deux jours après la 3.3.13 (ESP-IDF 5.5.6). Pour débuter, reste sur la 3.3.13 quelques semaines, le temps que les bibliothèques tierces suivent. Tout le code de ce guide compile sur 3.x ; la seule différence 4.0 qui le touche est signalée au projet 1.
Les broches à éviter sur un ESP32 classique
L'ESP32 travaille en 3,3 V : ne lui envoie jamais du 5 V sur une entrée. Ensuite, quatre règles tirées de la documentation GPIO d'ESP-IDF et de la fiche technique :
- GPIO 6 à 11 (et 16-17 sur certains modules) sont reliés à la mémoire flash : ne les touche pas.
- GPIO 34 à 39 sont des entrées seules, sans résistance de tirage interne.
- Les broches de démarrage (strapping : GPIO 0, 2, 5, 12, 15) fixent le mode de boot. Un capteur qui les force au mauvais niveau à la mise sous tension empêche la carte de démarrer.
- L'ADC2 est partagé avec le WiFi : la doc ESP-IDF prévient qu'une lecture peut alors échouer. Pour un capteur analogique avec WiFi, prends l'ADC1 (GPIO 32 à 39).
Projet 1 : variateur de LED en PWM
Le plus simple pour vérifier que tout marche, et l'occasion de voir l'API LEDC du cœur 3.x. Câblage : GPIO 23 → résistance 220 Ω → patte longue de la LED, patte courte à GND.
// Projet 1 : la LED respire grâce au PWM matériel (LEDC)
// Cœur Arduino ESP32 3.x : ledcAttach() remplace ledcSetup() + ledcAttachPin()
const uint8_t BROCHE_LED = 23;
const uint32_t FREQUENCE_HZ = 5000; // 5 kHz : aucun scintillement visible
const uint8_t RESOLUTION_BITS = 8; // rapport cyclique de 0 à 255
void setup() {
ledcAttach(BROCHE_LED, FREQUENCE_HZ, RESOLUTION_BITS); // canal attribué automatiquement
}
void loop() {
for (int duty = 0; duty <= 255; duty++) { // montée
ledcWrite(BROCHE_LED, duty); // en 3.x, on passe la broche, plus le canal
delay(4);
}
for (int duty = 255; duty >= 0; duty--) { // descente
ledcWrite(BROCHE_LED, duty);
delay(4);
}
}
La documentation LEDC signale le changement de la 4.0 : ledcWrite() accepte désormais la plage 0 à 2^résolution incluse, donc le 100 % s'écrit 256 en 8 bits au lieu de 255. Avec le code ci-dessus, la seule conséquence est une LED à 99,6 % au lieu de 100 % : invisible.
Projet 2 : thermomètre WiFi consultable depuis ton téléphone
L'ESP32 lit un DHT22 et sert une page web sur ton réseau local, plus une petite API JSON réutilisable par Home Assistant ou un tableur.
Câblage : VCC du DHT22 au 3,3 V, DATA sur GPIO 4, GND à GND, résistance de 10 kΩ entre VCC et DATA si ton capteur n'est pas sur module. Alimenter le capteur en 5 V tirerait la ligne de données à 5 V : à proscrire sur un ESP32. Les détails du capteur sont dans notre guide des capteurs Arduino.
Bibliothèques : « DHT sensor library » d'Adafruit et « Adafruit Unified Sensor ». WiFi et WebServer font partie du cœur ESP32.
// Projet 2 : serveur web + API JSON pour un DHT22
#include <WiFi.h>
#include <WebServer.h>
#include <DHT.h>
const char* WIFI_SSID = "TonReseau";
const char* WIFI_MDP = "TonMotDePasse";
WebServer serveur(80);
DHT dht(4, DHT22);
float temperature = NAN, humidite = NAN;
unsigned long derniereLecture = 0;
void pageAccueil() {
String html = "<!doctype html><html lang='fr'><head><meta charset='utf-8'>"
"<meta name='viewport' content='width=device-width'>"
"<meta http-equiv='refresh' content='10'><title>Thermomètre</title></head>"
"<body style='font-family:sans-serif;text-align:center'>";
html += "<h1>" + String(temperature, 1) + " °C</h1>";
html += "<p>Humidité : " + String(humidite, 1) + " %</p></body></html>";
serveur.send(200, "text/html; charset=utf-8", html);
}
void api() {
String json = "{\"temperature\":" + String(temperature, 1) +
",\"humidite\":" + String(humidite, 1) + "}";
serveur.send(200, "application/json", json);
}
void setup() {
Serial.begin(115200);
dht.begin();
WiFi.mode(WIFI_STA);
WiFi.begin(WIFI_SSID, WIFI_MDP);
Serial.print("Connexion WiFi");
while (WiFi.status() != WL_CONNECTED) {
delay(500);
Serial.print(".");
}
Serial.print("\nAdresse : http://");
Serial.println(WiFi.localIP()); // à taper dans le navigateur du téléphone
serveur.on("/", pageAccueil);
serveur.on("/api", api);
serveur.begin();
}
void loop() {
serveur.handleClient(); // à appeler le plus souvent possible
// Lecture non bloquante : le DHT22 exige plus de 2 s entre deux mesures
if (millis() - derniereLecture >= 2500) {
derniereLecture = millis();
float t = dht.readTemperature();
float h = dht.readHumidity();
if (!isnan(t) && !isnan(h)) { temperature = t; humidite = h; }
}
}
Ouvre le moniteur série à 115 200 bauds, note l'adresse IP et tape-la dans le navigateur de ton téléphone, connecté au même réseau. La page se rafraîchit toute seule toutes les 10 secondes.
Projet 3 : alerte de mouvement sur ton téléphone
Un PIR HC-SR501 détecte un passage, l'ESP32 envoie une notification push via ntfy, un service open source qui ne demande ni compte ni clé : tu publies sur un « sujet » par une simple requête HTTP POST et l'appli ntfy de ton téléphone, abonnée au même sujet, affiche le message. La documentation ntfy précise que, faute d'inscription, le nom du sujet fait office de mot de passe : choisis-le long et impossible à deviner.
Câblage : VCC du PIR sur la broche 5V (ou VIN) de la DevKit, alimentée par l'USB ; OUT sur GPIO 27 ; GND à GND. La sortie du PIR monte à environ 3 V, compatible avec l'ESP32. Laisse 60 secondes de stabilisation après la mise sous tension.
// Projet 3 : PIR -> notification ntfy, avec anti-rafale de 60 s
#include <WiFi.h>
#include <WiFiClientSecure.h>
#include <HTTPClient.h>
const char* WIFI_SSID = "TonReseau";
const char* WIFI_MDP = "TonMotDePasse";
const char* SUJET_NTFY = "atelier-k7q9-alerte-xr42"; // long et impossible à deviner
const uint8_t BROCHE_PIR = 27;
const unsigned long PAUSE_ENTRE_ALERTES_MS = 60000;
unsigned long derniereAlerte = 0;
bool etatPrecedent = LOW;
void envoyerAlerte(const String& message) {
WiFiClientSecure client;
client.setInsecure(); // simplifie le HTTPS mais ne vérifie pas le certificat
HTTPClient http;
String url = String("https://ntfy.sh/") + SUJET_NTFY;
if (http.begin(client, url)) {
http.addHeader("Title", "Atelier");
http.addHeader("Tags", "rotating_light");
int code = http.POST(message);
Serial.printf("ntfy : code HTTP %d\n", code);
http.end();
}
}
void setup() {
Serial.begin(115200);
pinMode(BROCHE_PIR, INPUT);
WiFi.begin(WIFI_SSID, WIFI_MDP);
while (WiFi.status() != WL_CONNECTED) delay(500);
Serial.println("WiFi OK, stabilisation du PIR...");
delay(60000);
}
void loop() {
bool etat = digitalRead(BROCHE_PIR);
bool front = (etat == HIGH && etatPrecedent == LOW);
etatPrecedent = etat;
if (front && millis() - derniereAlerte > PAUSE_ENTRE_ALERTES_MS) {
derniereAlerte = millis();
envoyerAlerte("Mouvement détecté dans l'atelier");
}
delay(50);
}
Le setInsecure() chiffre la connexion sans vérifier l'identité du serveur. Pour un capteur d'atelier, c'est acceptable. Pour un usage sérieux, fournis le certificat racine avec client.setCACert().
Projet 4 : capteur de température qui vit sur batterie
Le sommeil profond (deep sleep) coupe presque tout l'ESP32 entre deux mesures. La fiche technique d'Espressif annonce 10 µA pour la puce dans ce mode, et la mémoire RTC reste alimentée : une variable marquée RTC_DATA_ATTR survit au sommeil. Au réveil, le programme repart de setup(), et loop() ne sert plus à rien.
// Projet 4 : mesure toutes les 10 min puis sommeil profond
#include <DHT.h>
#define US_PAR_SECONDE 1000000ULL
#define SOMMEIL_S 600 // 10 minutes
RTC_DATA_ATTR uint32_t nombreReveils = 0; // conservé en mémoire RTC
DHT dht(4, DHT22);
void setup() {
Serial.begin(115200);
nombreReveils++;
dht.begin();
delay(2000); // le DHT22 vient d'être réveillé : on lui laisse le temps
float t = dht.readTemperature();
float h = dht.readHumidity();
Serial.printf("Réveil n°%u : %.1f °C, %.1f %%\n", (unsigned)nombreReveils, t, h);
// Ici : envoyer la mesure (WiFi + ntfy, MQTT...) en restant éveillé le moins longtemps possible
esp_sleep_enable_timer_wakeup(SOMMEIL_S * US_PAR_SECONDE); // API documentée par Espressif
Serial.flush();
esp_deep_sleep_start(); // rien ne s'exécute après cette ligne
}
void loop() {} // jamais atteint
Calculer l'autonomie
Les 10 µA concernent la puce, pas ta carte. Une DevKit garde son régulateur et sa puce USB-série sous tension : elle consomme nettement plus en sommeil, et c'est elle qui fixe l'autonomie. Mesure deux valeurs au multimètre en série sur l'alimentation : le courant en sommeil (I_s) et le courant éveillé (I_e, pendant la durée t_e de chaque réveil). Ensuite :
- consommation moyenne = (I_e × t_e + I_s × (600 − t_e)) / 600, avec les durées en secondes ;
- autonomie en heures = capacité de la batterie en mAh / consommation moyenne en mA.
Le levier principal est presque toujours la durée éveillée : une connexion WiFi coûte plusieurs secondes, une mesure seule une fraction. Pour descendre vraiment bas, il faut une carte conçue pour la batterie, sans puce USB permanente.
Projet 5 : mesurer le niveau d'une cuve avec un HC-SR04
Le capteur à ultrasons, fixé au couvercle, mesure la distance jusqu'à la surface de l'eau. L'ESP32 en déduit un pourcentage de remplissage. La fiche HC-SR04 annonce 2 cm à 4 m de portée, sous 5 V.
Câblage : VCC sur 5V, GND à GND, Trig sur GPIO 18 (une sortie 3,3 V suffit à déclencher le capteur), Echo vers GPIO 19 à travers un diviseur : 1 kΩ entre Echo et GPIO 19, 2 kΩ entre GPIO 19 et GND. Le diviseur ramène le 5 V de l'écho à 3,3 V.
// Projet 5 : niveau de cuve en pourcentage
const uint8_t TRIG = 18, ECHO = 19;
const float DISTANCE_CUVE_VIDE_CM = 120.0; // capteur -> fond de la cuve
const float DISTANCE_CUVE_PLEINE_CM = 20.0; // capteur -> surface quand c'est plein
float mesurerCm() {
digitalWrite(TRIG, LOW); delayMicroseconds(2);
digitalWrite(TRIG, HIGH); delayMicroseconds(10); // impulsion de 10 µs (fiche)
digitalWrite(TRIG, LOW);
unsigned long us = pulseIn(ECHO, HIGH, 30000UL);
return us == 0 ? NAN : us / 58.0; // µs / 58 = cm (fiche)
}
void setup() {
Serial.begin(115200);
pinMode(TRIG, OUTPUT);
pinMode(ECHO, INPUT);
}
void loop() {
// Médiane de 5 mesures : élimine les échos parasites sur l'eau
float m[5];
for (int i = 0; i < 5; i++) { m[i] = mesurerCm(); delay(70); } // plus de 60 ms
for (int i = 0; i < 4; i++) // tri simple
for (int j = i + 1; j < 5; j++)
if (m[j] < m[i]) { float x = m[i]; m[i] = m[j]; m[j] = x; }
float d = m[2];
if (isnan(d)) { Serial.println("Pas d'écho"); delay(5000); return; }
float pourcent = 100.0 * (DISTANCE_CUVE_VIDE_CM - d) /
(DISTANCE_CUVE_VIDE_CM - DISTANCE_CUVE_PLEINE_CM);
pourcent = constrain(pourcent, 0, 100);
Serial.printf("Distance %.1f cm, cuve à %.0f %%\n", d, pourcent);
delay(5000);
}
Garde au moins 2 cm entre le capteur et le niveau maximum, sa distance minimale. Et protège-le de l'humidité : le HC-SR04 n'est pas étanche.
Projet 6 : le thermomètre en MicroPython
Même capteur, même câblage que le projet 2, mais en Python. Télécharge le firmware ESP32_GENERIC sur micropython.org (version 1.29.0 du 24 août 2026), puis flashe-le avec esptool, en démarrant à l'adresse 0x1000 comme l'indique la page :
pip install esptool
esptool.py erase_flash
esptool.py --baud 460800 write_flash 0x1000 ESP32_GENERIC-20260824-v1.29.0.bin
Le nom exact du fichier dépend de la version téléchargée. Ensuite, ouvre Thonny, choisis l'interpréteur « MicroPython (ESP32) » et enregistre ce code sous main.py sur la carte. Les modules dht, network et requests sont fournis avec le firmware (référence rapide).
# Projet 6 : DHT22 + envoi ntfy toutes les 5 minutes (MicroPython 1.29)
import time
import dht
import network
import requests
from machine import Pin
WIFI_SSID = "TonReseau"
WIFI_MDP = "TonMotDePasse"
SUJET_NTFY = "atelier-k7q9-mesures-xr42"
capteur = dht.DHT22(Pin(4))
def connecter_wifi():
wlan = network.WLAN(network.STA_IF)
wlan.active(True)
if not wlan.isconnected():
wlan.connect(WIFI_SSID, WIFI_MDP)
for _ in range(40): # 20 s max, sinon on abandonne
if wlan.isconnected():
break
time.sleep(0.5)
return wlan.isconnected()
while True:
try:
capteur.measure() # respecter 2 s entre deux appels
t = capteur.temperature()
h = capteur.humidity()
message = "{:.1f} °C, {:.1f} % HR".format(t, h)
print(message)
if connecter_wifi():
r = requests.post("https://ntfy.sh/" + SUJET_NTFY, data=message)
r.close() # libère la mémoire, indispensable en boucle
except OSError as e:
print("Erreur capteur ou réseau :", e)
time.sleep(300)
L'avantage de MicroPython saute aux yeux en phase de mise au point : tu tapes capteur.measure() dans la console et tu vois le résultat tout de suite, sans recompiler. L'inconvénient : moins de bibliothèques prêtes à l'emploi que l'écosystème Arduino.
Variantes et améliorations
- Tout réunir : DHT22, PIR et HC-SR04 sur la même carte, avec la page web du projet 2 qui affiche les trois. Les broches choisies dans ce guide (4, 27, 18, 19, 23) ne se chevauchent pas et évitent les broches de démarrage.
- Home Assistant : l'API JSON du projet 2 s'intègre avec le capteur REST de Home Assistant, ou passe à ESPHome pour configurer la carte en YAML sans écrire de C++. Un Raspberry Pi 5 fait un très bon serveur domotique pour héberger le tout.
- Circuit définitif : quand le montage fonctionne, transfère-le sur une plaque à pastilles. Il faudra souder, et notre guide pour choisir un fer à souder débutant t'évitera les mauvais achats.
- Arduino ou ESP32 ? Si tu hésites encore pour un projet sans WiFi, le comparatif Arduino vs ESP32 tranche selon les usages.
Questions fréquentes
ESP32 ou ESP8266 pour débuter en 2026 ?
L'ESP32, sans hésiter pour un nouveau projet. Selon la fiche Espressif, il a deux cœurs à 240 MHz, 520 Ko de SRAM, le Bluetooth en plus du WiFi et un convertisseur analogique 12 bits sur 18 canaux. C'est surtout la famille autour de laquelle Espressif fait évoluer son cœur Arduino (version 4.0.0 en novembre 2026) : documentation, exemples et bibliothèques suivent.
Peut-on programmer l'ESP32 sans connaître Arduino ?
Oui. Le langage Arduino (du C++ simplifié) reste le chemin le plus documenté, mais MicroPython tourne très bien sur ESP32 : la version 1.29.0 est sortie le 24 août 2026. Tu écris du Python dans un éditeur comme Thonny, sans compilation, et tu testes les lignes une par une dans la console. Le projet 6 de ce guide reprend le thermomètre en MicroPython pour comparer.
Quelle autonomie sur batterie pour un ESP32 ?
Tout dépend de la carte et du temps passé éveillé. La puce seule descend à 10 µA en sommeil profond selon Espressif, mais une carte de développement garde son régulateur et son convertisseur USB alimentés et consomme bien davantage. Mesure ta carte au multimètre en sommeil et éveillée, puis applique le calcul du projet 4 : c'est la seule façon d'avoir un chiffre fiable.
Pourquoi mon ESP32 ne se connecte pas au WiFi ?
Vérifie d'abord la bande : l'ESP32 classique ne parle que le 2,4 GHz, d'après sa fiche technique. Un réseau 5 GHz seul, ou une box qui fusionne les deux bandes sous un même nom, pose souvent problème. Vérifie aussi le mot de passe et la casse du SSID, puis rapproche la carte du point d'accès : l'antenne imprimée des modules est modeste.
Sources et méthode
Les valeurs et procédures de ce guide viennent de la documentation des fabricants et de références techniques reconnues de la communauté maker, listées ci-dessous. Notre méthode en détail.
- arduino-esp32, releases (3.3.13 et 4.0.0), Espressif / GitHub (2026-11)
- Ultrasonic Ranging Module HC-SR04, Elec Freaks (copie SparkFun) (2026-11)
- LED Control (LEDC) API, Espressif, Arduino ESP32 docs (2026-11)
- Deep Sleep API, Espressif, Arduino ESP32 docs (2026-11)
- GPIO & RTC GPIO (ESP32), Espressif, ESP-IDF (2026-11)
- ADC Oneshot Mode Driver (ESP32, v5.5), Espressif, ESP-IDF (2026-11)
- ESP32 Series Datasheet, Espressif (2026-11)
- Publishing (ntfy), ntfy docs (2026-11)
- Quick reference for the ESP32, MicroPython docs (2026-11)
- MicroPython firmware ESP32_GENERIC, micropython.org (2026-11)




