ESP32 DHT22 serveur web : température, humidité, courbe sur 24 h
Serveur web ESP32 DHT22 : câblage, code WebServer et AsyncWebServer, page qui se rafraîchit seule, courbe 24 h avec Chart.js et solution aux valeurs nan.
Un serveur web ESP32 DHT22 est le moyen le plus rapide de mettre un capteur de température et d'humidité sur ton Wi-Fi et de lire les valeurs dans le navigateur de ton téléphone. L'ESP32 mesure et fait tourner en même temps un petit serveur web : pas besoin d'ordinateur supplémentaire, d'application ni de service cloud. Tout téléphone, tablette ou PC du même réseau voit les dernières mesures dès qu'il ouvre l'adresse IP de l'ESP32.
On avance pas à pas : d'abord on câble correctement le DHT22 et on le lit sans erreur, puis on crée une page simple qui se recharge toute seule, et enfin on trace avec Chart.js la courbe de température et d'humidité des dernières 24 heures. Tu écriras le même serveur avec la bibliothèque standard WebServer puis avec ESPAsyncWebServer, et on verra d'où vient la fameuse valeur "nan" et ce qui change avec un DHT11.

Comment fonctionne un serveur web ESP32 DHT22 ?
Le système comporte trois parties. L'ESP32 rejoint ton réseau domestique comme client (mode station) et reçoit une adresse IP de la box. En arrière-plan, il lit le DHT22 à intervalle fixe et garde en mémoire la dernière valeur valide. Quand le navigateur du téléphone ouvre cette adresse IP, l'ESP32 envoie une page HTML ; quelques lignes de JavaScript dans la page demandent ensuite toutes les quelques secondes uniquement les chiffres (JSON) et mettent l'affichage à jour sans recharger toute la page. Pour la courbe, l'ESP32 écrit toutes les 5 minutes une moyenne dans un tampon circulaire (ring buffer) ; le navigateur récupère cette liste et la trace avec Chart.js.
| Adresse | Ce qu'elle renvoie | Qui la demande, et quand |
|---|---|---|
| / | La page HTML (mise en page et JavaScript) | Le navigateur, à la première ouverture |
| /data | Dernière mesure, ex. {"t":23.4,"h":51.2} | Le JavaScript, toutes les 5 secondes |
| /history | Moyennes sur 5 minutes des dernières 24 heures | Le JavaScript, une fois par minute |
Matériel et caractéristiques du DHT22
Il te faut une carte de développement ESP32 (DevKit V1, NodeMCU-32S ou équivalent), un capteur DHT22 ou un module DHT22 à 3 broches, une résistance de 10 kΩ si tu utilises le capteur nu, une breadboard (plaque d'essai), des fils de prototypage et un réseau Wi-Fi 2,4 GHz. Le DHT22 est aussi vendu sous le nom AM2302 ; la version avec câble intègre déjà la résistance de rappel (pull-up). Le tableau compare le DHT22 à son petit frère moins cher, le DHT11 :
| Caractéristique | DHT22 (AM2302) | DHT11 |
|---|---|---|
| Plage de température | −40 … 80 °C | 0 … 50 °C |
| Précision en température | ±0,5 °C | ±2 °C |
| Plage d'humidité | 0 … 100 % HR | 20 … 90 % HR |
| Précision en humidité | ±2 … 5 % HR | ±5 % HR |
| Résolution | 0,1 °C / 0,1 % | 1 °C / 1 % |
| Intervalle de lecture minimal | 2 secondes | 1 seconde |
| Alimentation | 3,3 … 6 V | 3,3 … 5,5 V |
| Consommation (mesure / repos) | 1–1,5 mA / 40–50 µA | 0,5–2,5 mA / 100–150 µA |
Branchement du DHT22 sur l'ESP32
| Broche du DHT22 | Broche de l'ESP32 | Remarque |
|---|---|---|
| VCC (+, broche 1) | 3V3 | Pas de 5 V : la ligne de données est tirée à cette tension |
| DATA (OUT, broche 2) | GPIO 4 | Sur le capteur nu, 10 kΩ entre DATA et VCC |
| NC (broche 3) | Non connectée | Uniquement sur le capteur nu à 4 broches |
| GND (−, broche 4) | GND | Masse commune avec l'ESP32 |
Avec le module à 3 broches, la résistance de rappel (et souvent un petit condensateur) est déjà sur la carte : tu peux le brancher directement. Avec le capteur nu à 4 broches, il faut une résistance de 4,7 à 10 kΩ entre DATA et VCC ; sans elle, la ligne reste flottante et la plupart des lectures échouent. En 3,3 V, garde un câble de moins d'un mètre ; pour plus long, passe à 4,7 kΩ et à un câble torsadé. Évite aussi de coller le capteur à l'ESP32 : la puce Wi-Fi et le régulateur chauffent la carte, et le capteur afficherait 1 à 2 °C de plus que la pièce.
Installer les bibliothèques
- Installe le paquet de cartes ESP32 dans l'Arduino IDE (détails dans Qu'est-ce que l'ESP32 ?) et choisis ESP32 Dev Module dans Outils > Type de carte.
- Dans le gestionnaire de bibliothèques, cherche DHT sensor library (Adafruit) et installe-la ; accepte aussi la dépendance Adafruit Unified Sensor.
- La bibliothèque WebServer est fournie avec le paquet ESP32, rien d'autre à installer.
- Pour la version asynchrone, installe ESP Async WebServer et Async TCP (d'ESP32Async). Les anciennes versions me-no-dev, qui ne sont plus maintenues, ne compilent souvent plus avec les paquets ESP32 récents.
Étape 1 : lire le DHT22 et éviter les "nan"
Teste d'abord le capteur seul avant d'ajouter la partie web. Quand une lecture échoue, la bibliothèque Adafruit renvoie NaN (not a number) au lieu d'un nombre, et le moniteur série affiche "nan". Il faut donc vérifier chaque valeur avec isnan(), jeter la mesure ratée et réessayer 2 secondes plus tard. La fonction readDHT() du code ci-dessous fait trois tentatives ; si les trois échouent, elle renvoie false et tu continues simplement avec la dernière valeur valide.
1#include <DHT.h>
2
3#define DHT_PIN 4 // DHT22 DATA → GPIO 4
4#define DHT_TYPE DHT22 // DHT11 için DHT11 yaz / write DHT11 for a DHT11
5
6DHT dht(DHT_PIN, DHT_TYPE);
7
8// 3 denemeli güvenli okuma / safe read with 3 attempts
9bool readDHT(float &t, float &h) {
10 for (int i = 0; i < 3; i++) {
11 h = dht.readHumidity();
12 t = dht.readTemperature();
13 if (!isnan(t) && !isnan(h)) return true; // ikisi de geçerli / both valid
14 delay(2100); // DHT22 iki okuma arası en az 2 sn ister / DHT22 needs 2 s between reads
15 }
16 return false;
17}
18
19void setup() {
20 Serial.begin(115200);
21 dht.begin();
22 delay(2000); // sensörün açılmasını bekle / let the sensor power up
23}
24
25void loop() {
26 float t, h;
27 if (readDHT(t, h)) {
28 float hi = dht.computeHeatIndex(t, h, false); // hissedilen sıcaklık / heat index
29 Serial.printf("Sicaklik / Temp: %.1f C Nem / Humidity: %.1f %% Hissedilen / Feels like: %.1f C\n", t, h, hi);
30 } else {
31 Serial.println("DHT okunamadi, kabloyu ve pini kontrol et / DHT read failed, check wiring and pin");
32 }
33 delay(5000);
34}Ouvre le moniteur série à 115200 bauds. Toutes les 5 secondes, tu dois voir une ligne avec la température, l'humidité et la température ressentie (heat index). Si "DHT read failed" revient sans arrêt, le problème est presque toujours matériel : fil DATA sur la mauvaise broche, résistance de rappel absente, capteur alimenté en 5 V ou mauvais DHT_TYPE. Un échec isolé de temps en temps est en revanche normal : les interruptions du Wi-Fi peuvent perturber le timing à la microseconde du capteur, et une nouvelle tentative règle le problème.
Étape 2 : une page web simple qui se rafraîchit seule (WebServer)
Notre premier serveur est aussi simple que possible : l'ESP32 se connecte au Wi-Fi et, quand on demande l'adresse racine (/), envoie une page HTML qui affiche la dernière mesure en grands chiffres. La balise meta refresh en tête de page demande au navigateur de recharger la page toutes les 10 secondes ; tu obtiens ainsi un affichage presque en direct sans écrire une ligne de JavaScript. Remplace le nom du réseau et le mot de passe, téléverse le programme et ouvre sur ton téléphone l'adresse IP affichée dans le moniteur série.
1#include <WiFi.h>
2#include <WebServer.h>
3#include <DHT.h>
4
5const char* ssid = "AgAdi"; // Wi-Fi adın / your Wi-Fi name
6const char* password = "Sifre123"; // Wi-Fi şifren / your Wi-Fi password
7
8DHT dht(4, DHT22); // DATA → GPIO 4
9WebServer server(80);
10
11float t = NAN, h = NAN; // son geçerli ölçüm / last valid reading
12unsigned long lastRead = 0;
13
14void handleRoot() {
15 String html = "<!DOCTYPE html><html><head><meta charset='utf-8'>"
16 "<meta name='viewport' content='width=device-width,initial-scale=1'>"
17 "<meta http-equiv='refresh' content='10'>" // 10 sn'de bir yenile / reload every 10 s
18 "<title>ESP32 DHT22</title></head>"
19 "<body style='font-family:sans-serif;text-align:center'><h2>ESP32 + DHT22</h2>";
20 if (isnan(t) || isnan(h)) {
21 html += "<p>Sensor okunamadi / Sensor read failed</p>";
22 } else {
23 html += "<p style='font-size:44px'>" + String(t, 1) + " °C</p>";
24 html += "<p style='font-size:44px'>" + String(h, 1) + " %</p>";
25 }
26 html += "</body></html>";
27 server.send(200, "text/html", html);
28}
29
30void setup() {
31 Serial.begin(115200);
32 dht.begin();
33 WiFi.mode(WIFI_STA);
34 WiFi.begin(ssid, password);
35 while (WiFi.status() != WL_CONNECTED) { delay(500); Serial.print('.'); }
36 Serial.print("\nIP: ");
37 Serial.println(WiFi.localIP()); // bu adresi telefonda aç / open this address on your phone
38 server.on("/", handleRoot);
39 server.begin();
40}
41
42void loop() {
43 server.handleClient(); // gelen istekleri cevapla / answer incoming requests
44 if (millis() - lastRead >= 5000) { // 5 sn'de bir oku / read every 5 s
45 lastRead = millis();
46 float nt = dht.readTemperature();
47 float nh = dht.readHumidity();
48 if (!isnan(nt) && !isnan(nh)) { t = nt; h = nh; } // hatalı ölçümü at / drop failed readings
49 }
50}Étape 3 : une courbe sur 24 heures avec Chart.js
Le meta refresh est simple, mais il télécharge toute la page à chaque fois et n'affiche aucun historique. Faisons mieux : la page se charge une seule fois, les valeurs arrivent en JSON depuis /data toutes les 5 secondes grâce au fetch() de JavaScript, et la courbe vient de /history. En découpant 24 heures en tranches de 5 minutes, on obtient 24 × 12 = 288 points. Chaque point stocke un float de 4 octets pour la température et un pour l'humidité, soit 288 × 2 × 4 = 2 304 octets, environ 2,3 Ko de RAM : presque rien face aux 520 Ko de l'ESP32.
1#include <WiFi.h>
2#include <WebServer.h>
3#include <DHT.h>
4
5const char* ssid = "AgAdi"; // Wi-Fi adın / your Wi-Fi name
6const char* password = "Sifre123"; // Wi-Fi şifren / your Wi-Fi password
7
8#define DHT_PIN 4 // DHT22 DATA → GPIO 4
9#define DHT_TYPE DHT22 // DHT11 için DHT11 / DHT11 for a DHT11
10DHT dht(DHT_PIN, DHT_TYPE);
11WebServer server(80);
12
13const unsigned long READ_MS = 10000; // 10 sn'de bir ölç / read every 10 s
14const unsigned long STEP_MS = 300000; // 5 dk'da bir kaydet / store every 5 min
15const int N = 288; // 24 sa × 12 = 288 kayıt / 24 h × 12 = 288 samples
16
17float temps[N], hums[N]; // halka tampon / ring buffer
18int count = 0, head = 0; // dolu kayıt, sıradaki yer / stored samples, next slot
19float lastT = NAN, lastH = NAN; // son geçerli ölçüm / last valid reading
20float sumT = 0, sumH = 0; // 5 dk ortalaması için / for the 5-min average
21int sumN = 0;
22unsigned long lastRead = 0, lastStep = 0;
23
24const char PAGE[] PROGMEM = R"HTML(<!DOCTYPE html>
25<html><head><meta charset="utf-8">
26<meta name="viewport" content="width=device-width,initial-scale=1">
27<title>ESP32 DHT22</title>
28<script src="https://cdn.jsdelivr.net/npm/[email protected]/dist/chart.umd.min.js"></script>
29<style>
30body{font-family:sans-serif;margin:16px;background:#f2f4f7;color:#222}
31.box{display:inline-block;background:#fff;border-radius:12px;padding:10px 18px;margin:4px;font-size:30px}
32small{display:block;font-size:13px;color:#666}
33</style></head><body>
34<h2>ESP32 + DHT22</h2>
35<div class="box"><small>Sıcaklık / Temperature</small><span id="t">--</span> °C</div>
36<div class="box"><small>Nem / Humidity</small><span id="h">--</span> %</div>
37<canvas id="c" height="240"></canvas>
38<script>
39const $ = id => document.getElementById(id);
40const fmt = v => v === null ? '--' : v.toFixed(1);
41const chart = new Chart($('c'), {
42 type: 'line',
43 data: { labels: [], datasets: [
44 { label: '°C', data: [], borderColor: '#e4572e', yAxisID: 'y' },
45 { label: '%', data: [], borderColor: '#2e86de', yAxisID: 'y1' } ] },
46 options: { animation: false, elements: { point: { radius: 0 } },
47 scales: { y: { position: 'left' }, y1: { position: 'right', grid: { drawOnChartArea: false } } } }
48});
49function live() {
50 fetch('/data').then(r => r.json()).then(d => { $('t').textContent = fmt(d.t); $('h').textContent = fmt(d.h); });
51}
52function loadHistory() {
53 fetch('/history').then(r => r.json()).then(d => {
54 const n = d.t.length, end = Date.now() - d.age * 1000;
55 chart.data.labels = d.t.map((_, i) => new Date(end - (n - 1 - i) * d.step * 1000).toTimeString().slice(0, 5));
56 chart.data.datasets[0].data = d.t;
57 chart.data.datasets[1].data = d.h;
58 chart.update();
59 });
60}
61live(); loadHistory();
62setInterval(live, 5000);
63setInterval(loadHistory, 60000);
64</script></body></html>)HTML";
65
66// NaN JSON'da geçersizdir, null gönder / NaN is invalid JSON, send null
67String num(float v) { return isnan(v) ? String("null") : String(v, 1); }
68
69bool readDHT(float &t, float &h) { // 3 denemeli okuma / read with 3 attempts
70 for (int i = 0; i < 3; i++) {
71 h = dht.readHumidity();
72 t = dht.readTemperature();
73 if (!isnan(t) && !isnan(h)) return true;
74 delay(2100);
75 }
76 return false;
77}
78
79void handleRoot() { server.send(200, "text/html", PAGE); }
80
81void handleData() {
82 server.send(200, "application/json", "{\"t\":" + num(lastT) + ",\"h\":" + num(lastH) + "}");
83}
84
85void handleHistory() {
86 String t, h;
87 t.reserve(2048);
88 h.reserve(2048);
89 for (int i = 0; i < count; i++) {
90 int k = (head - count + i + N) % N; // en eskiden en yeniye / oldest to newest
91 if (i) { t += ','; h += ','; }
92 t += num(temps[k]);
93 h += num(hums[k]);
94 }
95 String json = "{\"step\":" + String(STEP_MS / 1000) + ",\"age\":" + String((millis() - lastStep) / 1000) +
96 ",\"t\":[" + t + "],\"h\":[" + h + "]}";
97 server.send(200, "application/json", json);
98}
99
100void setup() {
101 Serial.begin(115200);
102 dht.begin();
103 WiFi.mode(WIFI_STA);
104 WiFi.begin(ssid, password);
105 while (WiFi.status() != WL_CONNECTED) { delay(500); Serial.print('.'); }
106 Serial.print("\nIP: ");
107 Serial.println(WiFi.localIP());
108 server.on("/", handleRoot);
109 server.on("/data", handleData);
110 server.on("/history", handleHistory);
111 server.begin();
112}
113
114void loop() {
115 server.handleClient();
116 unsigned long now = millis();
117 if (lastRead == 0 || now - lastRead >= READ_MS) {
118 lastRead = now;
119 float t, h;
120 if (readDHT(t, h)) { lastT = t; lastH = h; sumT += t; sumH += h; sumN++; }
121 }
122 // ilk kayıt hemen, sonra 5 dk'da bir ortalama / first sample at once, then a 5-min average
123 if ((count == 0 && sumN > 0) || (count > 0 && now - lastStep >= STEP_MS)) {
124 temps[head] = sumN ? sumT / sumN : NAN; // ölçüm yoksa boşluk / gap if no reading
125 hums[head] = sumN ? sumH / sumN : NAN;
126 head = (head + 1) % N;
127 if (count < N) count++;
128 sumT = sumH = 0;
129 sumN = 0;
130 lastStep = now;
131 }
132}| Partie du code | Rôle |
|---|---|
| READ_MS = 10000 | Lit le capteur toutes les 10 secondes (minimum du DHT22 : 2 secondes) |
| STEP_MS = 300000 | Enregistre la moyenne des lectures de chaque tranche de 5 minutes comme un point |
| temps[N], hums[N] | Tampon circulaire de 288 cases ; une fois plein, il écrase le point le plus ancien |
| num() | Transforme NaN en null, valide en JSON |
| /history : step et age | Intervalle entre les points et âge du dernier ; le navigateur en déduit les heures |
| setInterval(live, 5000) | Met à jour les grands chiffres toutes les 5 secondes |
Deux détails comptent ici. D'abord, JSON ne connaît pas la valeur NaN : si tu écris "nan" dans la réponse quand le capteur échoue, l'analyseur JSON du navigateur lève une erreur et la page semble figée. C'est pour cela que num() envoie null, et Chart.js trace les null comme des trous dans la courbe. Ensuite, l'ESP32 n'a pas besoin de récupérer l'heure sur Internet : le navigateur utilise sa propre horloge et place chaque point « tant de pas avant maintenant ». Si tu veux de vrais horodatages, ajoute la méthode de Heure NTP avec l'ESP32.
Chart.js est téléchargé depuis le CDN jsDelivr à l'ouverture de la page : ton téléphone doit donc avoir accès à Internet pour afficher la courbe. Si l'ESP32 fonctionne uniquement comme point d'accès (mode AP) ou s'il n'y a pas d'Internet à la maison, place chart.umd.min.js (environ 200 Ko) dans LittleFS et sers-le directement depuis l'ESP32. On explique comment servir des fichiers depuis LittleFS dans Serveur web asynchrone ESP32 et WebSocket.
Le même serveur avec AsyncWebServer
La bibliothèque standard WebServer est synchrone : aucune requête n'obtient de réponse tant que server.handleClient() n'est pas appelé dans loop(). Si readDHT() passe quelques secondes à réessayer, la page ne répond pas non plus pendant ce temps. ESPAsyncWebServer traite au contraire les requêtes en arrière-plan, dans sa propre tâche : la page s'ouvre immédiatement quoi que fasse loop(), et plusieurs téléphones peuvent se connecter en même temps. Le code ci-dessous sert le même point d'accès /data avec la bibliothèque asynchrone :
1#include <WiFi.h>
2#include <AsyncTCP.h>
3#include <ESPAsyncWebServer.h>
4#include <DHT.h>
5
6const char* ssid = "AgAdi"; // Wi-Fi adın / your Wi-Fi name
7const char* password = "Sifre123"; // Wi-Fi şifren / your Wi-Fi password
8
9DHT dht(4, DHT22); // DATA → GPIO 4
10AsyncWebServer server(80);
11float lastT = NAN, lastH = NAN; // loop() yazar, sunucu okur / loop() writes, server reads
12
13const char PAGE[] PROGMEM = R"HTML(<!DOCTYPE html><html><head><meta charset="utf-8">
14<meta name="viewport" content="width=device-width,initial-scale=1"><title>ESP32 DHT22</title></head>
15<body style="font-family:sans-serif;text-align:center"><h2>ESP32 + DHT22 (Async)</h2>
16<p style="font-size:44px"><span id="t">--</span> °C</p>
17<p style="font-size:44px"><span id="h">--</span> %</p>
18<script>
19const fmt = v => v === null ? '--' : v.toFixed(1);
20function live() {
21 fetch('/data').then(r => r.json()).then(d => {
22 document.getElementById('t').textContent = fmt(d.t);
23 document.getElementById('h').textContent = fmt(d.h);
24 });
25}
26live(); setInterval(live, 5000);
27</script></body></html>)HTML";
28
29String num(float v) { return isnan(v) ? String("null") : String(v, 1); }
30
31void setup() {
32 Serial.begin(115200);
33 dht.begin();
34 WiFi.mode(WIFI_STA);
35 WiFi.begin(ssid, password);
36 while (WiFi.status() != WL_CONNECTED) { delay(500); Serial.print('.'); }
37 Serial.print("\nIP: ");
38 Serial.println(WiFi.localIP());
39
40 server.on("/", HTTP_GET, [](AsyncWebServerRequest *request) {
41 request->send(200, "text/html", PAGE);
42 });
43 server.on("/data", HTTP_GET, [](AsyncWebServerRequest *request) { // burada sensör okunmaz / no sensor read here
44 request->send(200, "application/json", "{\"t\":" + num(lastT) + ",\"h\":" + num(lastH) + "}");
45 });
46 server.begin(); // istekler arka planda karşılanır / requests are handled in the background
47}
48
49void loop() {
50 static unsigned long lastRead = 0;
51 if (millis() - lastRead >= 10000) { // 10 sn'de bir oku / read every 10 s
52 lastRead = millis();
53 float t = dht.readTemperature();
54 float h = dht.readHumidity();
55 if (!isnan(t) && !isnan(h)) { lastT = t; lastH = h; }
56 }
57}| Caractéristique | WebServer | ESPAsyncWebServer |
|---|---|---|
| Installation | Fournie avec le paquet ESP32 | ESP Async WebServer + Async TCP nécessaires |
| Traitement des requêtes | handleClient() dans loop() | En arrière-plan, dans sa propre tâche |
| delay() dans loop() | Bloque aussi le serveur | N'affecte pas le serveur |
| Plusieurs clients à la fois | L'un après l'autre | Plusieurs clients sans souci |
| WebSocket et SSE | Non | Oui |
| Quand le choisir ? | Premier projet, page simple | Courbes, plusieurs utilisateurs, données en direct |
Dans la version asynchrone, une seule règle : lis le capteur dans loop(), pas à l'arrivée d'une requête, et garde le résultat dans une variable globale. Un delay() ou une lecture lente du capteur dans le gestionnaire de requête bloque la tâche de la bibliothèque et fait tomber les connexions. Tu peux transposer de la même façon la page avec la courbe et le gestionnaire /history de l'étape 3 ; seule différence, on utilise request->send() au lieu de server.send().
Intervalle de lecture : à quelle fréquence lire le DHT22 ?
La fiche technique du DHT22 demande au moins 2 secondes entre deux mesures ; si tu lis plus souvent, la bibliothèque Adafruit ne refait pas de mesure et renvoie la valeur précédente, ou le capteur répond par une erreur. La température d'une pièce ne change de toute façon pas en quelques secondes : en pratique, un intervalle de 10 à 60 secondes est idéal. Interroger le capteur très souvent peut aussi le réchauffer légèrement et faire baisser l'humidité affichée. Stocker des moyennes sur 5 minutes plutôt que des mesures isolées lisse le bruit et économise la mémoire. Pour une station sur batterie, il faut endormir l'ESP32 entre les mesures, comme expliqué dans ESP32 Deep Sleep.
Utiliser un DHT11 : que faut-il changer ?
Si tu as un DHT11, tout le code fonctionne : change seulement la ligne #define DHT_TYPE DHT11, le câblage reste identique. La différence porte sur la qualité de mesure : le DHT11 mesure de 0 à 50 °C à ±2 °C près, par pas d'un degré, et ne lit l'humidité qu'entre 20 et 90 %. Ta courbe ressemblera à un escalier et ne descendra jamais sous 0 °C ; pour un balcon, un frigo ou une serre, prends donc le DHT22. Les problèmes propres au DHT11 sont traités dans Capteur de température et d'humidité DHT11.
Idées de projets avec le serveur web ESP32 DHT22
- Moniteur de chambre de bébé : Affiche une alerte rouge au-delà de 26 °C et envoie un message sur ton téléphone avec un bot Telegram.
- Thermostat d'ambiance : Commande un radiateur d'appoint ou un ventilateur avec un module relais selon un seuil réglé depuis la page web.
- Enregistrement longue durée : Envoie les moyennes sur 5 minutes dans une feuille Google Sheets et garde des mois de données.
- Maison connectée : Transmets les valeurs à Home Assistant via MQTT et utilise-les dans des automatisations.
- Station avec écran : Affiche les mêmes valeurs sur un écran OLED pour les lire d'un coup d'œil sans ouvrir la page.
- Mesure dans plusieurs pièces : Place un ESP32 dans chaque pièce et rassemble les données sur une carte principale avec ESP-NOW.
Erreurs fréquentes et solutions
| Symptôme | Cause probable | Solution |
|---|---|---|
| La page affiche toujours -- ou nan | Mauvaise broche DATA, pas de pull-up, mauvais DHT_TYPE | Vérifie le tableau de câblage, ajoute 10 kΩ, assure-toi que le code indique DHT22 |
| nan de temps en temps | Les interruptions Wi-Fi perturbent le timing | Réessaie 3 fois avec readDHT() et garde la dernière valeur valide |
| Température trop haute de 1 à 3 °C | La chaleur de l'ESP32 atteint le capteur | Éloigne le capteur de 5 à 10 cm au bout d'un câble |
| La page ne s'ouvre pas | Téléphone sur un autre réseau ou IP changée | Rejoins le même Wi-Fi et utilise la nouvelle IP du moniteur série |
| Les chiffres s'affichent, la courbe reste vide | Chart.js n'a pas pu être téléchargé (pas d'Internet) | Vérifie l'accès Internet du téléphone ou sers le fichier depuis LittleFS |
| La courbe repart de zéro après un redémarrage | L'historique est en RAM | Écris les points dans LittleFS ou envoie-les dans le cloud |
| La carte redémarre au hasard | Alimentation USB trop faible (brownout) | Utilise un bon câble et un chargeur 5 V d'au moins 1 A |
Ce petit serveur web construit avec un ESP32 et un DHT22 est la base de projets plus ambitieux comme un thermostat, une serre ou une station météo : change de capteur et la même structure de page affichera l'humidité du sol, la qualité de l'air ou la pression. Si tu veux monter le circuit pas à pas, l'application BlueGrays propose les schémas de câblage et le code prêt à téléverser dans les projets ESP32 DHT22 température et humidité, Async Web Server et enregistreur de température.
Questions fréquentes
Pourquoi mon DHT22 affiche nan sur l'ESP32 ?
La bibliothèque Adafruit renvoie NaN dès qu'une lecture échoue. Les causes les plus courantes sont une mauvaise broche DATA, l'absence de résistance de rappel de 10 kΩ, un DHT_TYPE resté sur DHT11 ou des lectures plus rapprochées que 2 secondes. Vérifie le câblage, écarte les mesures ratées avec isnan() et réessaie 2 secondes plus tard.
Le DHT22 fonctionne-t-il en 3,3 V ?
Oui, le DHT22 fonctionne de 3,3 à 6 V, et avec un ESP32 il vaut mieux l'alimenter par la broche 3V3 pour que la ligne de données reste aussi à 3,3 V. En 5 V, la résistance de rappel tire la ligne de données à 5 V, ce qui peut abîmer une broche de l'ESP32, qui ne tolère pas le 5 V.
Comment accéder au serveur web de l'ESP32 depuis l'extérieur ?
Le serveur de ce guide ne fonctionne que sur ton réseau local. Ouvrir un port sur la box expose l'appareil à Internet et présente un risque de sécurité. Il est plus sûr d'envoyer les mesures vers un service comme MQTT, Telegram ou Google Sheets, ou de te connecter à ton réseau domestique par VPN.
DHT22 ou DHT11 : lequel choisir ?
Pour un simple affichage en intérieur, un DHT11 suffit, mais son erreur de ±2 °C et ses pas entiers se voient nettement sur une courbe. Pour l'extérieur, les températures négatives ou une courbe plus régulière, prends le DHT22 à ±0,5 °C ; la différence de prix est faible.
Peut-on brancher plusieurs DHT22 sur un ESP32 ?
Oui. Chaque capteur va sur son propre GPIO et a son propre objet dans le code, par exemple DHT dht1(4, DHT22) et DHT dht2(16, DHT22). Les DHT22 ne peuvent pas partager la même ligne de données ; pour plusieurs capteurs sur un seul fil, regarde le DS18B20 ou un capteur I2C comme le BME280.
L'historique de 24 heures est-il perdu après une coupure de courant ?
Dans cet exemple, oui : les points sont en RAM et disparaissent à la coupure ou au redémarrage de la carte. Pour les garder, écris-les régulièrement dans LittleFS, enregistre-les sur une carte SD ou envoie-les vers un service cloud comme Google Sheets.
Projets à réaliser après cet article
Voir tous les projets
Température et humidité avec DHT11
Quelle température fait-il dans ta chambre, et l'air est-il humide ou sec ? Le capteur DHT11 mesure la température et l'humidité, et l'Arduino affiche les valeurs sur un écran LCD à deux lignes…

ESP32 DHT22 Température et humidité (avec écran LCD)
Il s'agit d'un projet permettant de mesurer la température ambiante et le taux d'humidité à l'aide d'un capteur DHT22 et d'afficher ces données en temps réel sur un écran LCD I2C 16x2. Les données du capteur sont lues à l'aide du protocole one-wire grâce à la bibliothèque Adafruit DHT. Ce projet constitue la base des stations météo IoT, de la domotique ou des systèmes de surveillance de l'environnement dans les serres.

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

Enregistreur de Température ESP32 (DHT22 + DS1307 RTC + microSD + OLED)
Construis avec l'ESP32 un enregistreur de température et d'humidité horodaté ! Un capteur DHT22 mesure la température et l'humidité une fois par minute, et chaque mesure est enregistrée sur une carte microSD au format CSV avec l'heure réelle du module RTC DS1307. L'écran OLED affiche en direct, en grands caractères, la dernière température, l'humidité, l'horodatage et le nombre d'enregistrements.

Compteur ESP32 WebSocket (2 boutons + écran LCD + affichage Web en temps réel)
Dans ce projet, deux boutons reliés à l'ESP32 (GPIO 5 incrémente, GPIO 4 décrémente) modifient un compteur. La valeur se met à jour instantanément sur un écran LCD I2C 16x2 et, grâce au support WebSocket d'ESPAsyncWebServer, dans tous les navigateurs connectés sans recharger la page. Au lieu du polling HTTP, une seule connexion persistante est utilisée et l'ESP32 envoie la nouvelle valeur à tous avec ws.textAll().

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.

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

ESP32 : heure réelle depuis Internet via NTP
L'ESP32 se connecte au Wi-Fi et récupère l'heure exacte auprès de serveurs NTP (Network Time Protocol) à la milliseconde près. Avec configTzTime(), le fuseau horaire de la Turquie (TRT, UTC+3) s'applique automatiquement, et dans les pays à heure d'été, le changement (DST) est géré tout seul par une chaîne POSIX TZ. L'heure s'affiche dans le Serial Monitor et sur un LCD I2C en option.
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

