Guides · 10 min de lecture

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.

Capteur de température et d'humidité DHT22
DHT22 (AM2302) : mesure de −40 à 80 °C à ±0,5 °C près et de 0 à 100 % d'humidité relative, et communique sur une seule ligne de données.

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.

AdresseCe qu'elle renvoieQui la demande, et quand
/La page HTML (mise en page et JavaScript)Le navigateur, à la première ouverture
/dataDernière mesure, ex. {"t":23.4,"h":51.2}Le JavaScript, toutes les 5 secondes
/historyMoyennes sur 5 minutes des dernières 24 heuresLe 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éristiqueDHT22 (AM2302)DHT11
Plage de température−40 … 80 °C0 … 50 °C
Précision en température±0,5 °C±2 °C
Plage d'humidité0 … 100 % HR20 … 90 % HR
Précision en humidité±2 … 5 % HR±5 % HR
Résolution0,1 °C / 0,1 %1 °C / 1 %
Intervalle de lecture minimal2 secondes1 seconde
Alimentation3,3 … 6 V3,3 … 5,5 V
Consommation (mesure / repos)1–1,5 mA / 40–50 µA0,5–2,5 mA / 100–150 µA

Branchement du DHT22 sur l'ESP32

Broche du DHT22Broche de l'ESP32Remarque
VCC (+, broche 1)3V3Pas de 5 V : la ligne de données est tirée à cette tension
DATA (OUT, broche 2)GPIO 4Sur le capteur nu, 10 kΩ entre DATA et VCC
NC (broche 3)Non connectéeUniquement sur le capteur nu à 4 broches
GND (−, broche 4)GNDMasse commune avec l'ESP32
N'utilise pas les GPIO 6 à 11 (reliés à la mémoire flash) ni les GPIO 34 à 39 (entrée seulement) pour DATA : le DHT22 reçoit son signal de départ et envoie ses données sur le même fil, il lui faut donc une broche bidirectionnelle. Les GPIO 0, 2, 12 et 15 peuvent aussi perturber le démarrage de la carte. Les GPIO 4, 13, 16–19, 21–23, 25–27, 32 et 33 sont des choix sûrs ; tu peux consulter le brochage de ta carte avec l'outil Pinout.

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

  1. 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.
  2. Dans le gestionnaire de bibliothèques, cherche DHT sensor library (Adafruit) et installe-la ; accepte aussi la dépendance Adafruit Unified Sensor.
  3. La bibliothèque WebServer est fournie avec le paquet ESP32, rien d'autre à installer.
  4. 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.

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

C++ (Arduino IDE)
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) + " &deg;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}
Ton téléphone doit être sur le même réseau Wi-Fi que l'ESP32 : en 4G, tu ne peux pas joindre une adresse 192.168.x.x. L'ESP32 ne voit que les réseaux 2,4 GHz. Pour que l'adresse IP ne change pas à chaque redémarrage, réserve une adresse fixe à l'ESP32 dans ta box (bail DHCP statique). S'il refuse de se connecter, suis la liste de contrôle de L'ESP32 ne se connecte pas au Wi-Fi.

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

C++ (Arduino IDE)
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 codeRôle
READ_MS = 10000Lit le capteur toutes les 10 secondes (minimum du DHT22 : 2 secondes)
STEP_MS = 300000Enregistre 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 ageIntervalle 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 :

C++ (Arduino IDE)
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> &deg;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éristiqueWebServerESPAsyncWebServer
InstallationFournie avec le paquet ESP32ESP Async WebServer + Async TCP nécessaires
Traitement des requêteshandleClient() dans loop()En arrière-plan, dans sa propre tâche
delay() dans loop()Bloque aussi le serveurN'affecte pas le serveur
Plusieurs clients à la foisL'un après l'autrePlusieurs clients sans souci
WebSocket et SSENonOui
Quand le choisir ?Premier projet, page simpleCourbes, 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ômeCause probableSolution
La page affiche toujours -- ou nanMauvaise broche DATA, pas de pull-up, mauvais DHT_TYPEVérifie le tableau de câblage, ajoute 10 kΩ, assure-toi que le code indique DHT22
nan de temps en tempsLes interruptions Wi-Fi perturbent le timingRéessaie 3 fois avec readDHT() et garde la dernière valeur valide
Température trop haute de 1 à 3 °CLa 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 pasTéléphone sur un autre réseau ou IP changéeRejoins le même Wi-Fi et utilise la nouvelle IP du moniteur série
Les chiffres s'affichent, la courbe reste videChart.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émarrageL'historique est en RAMÉcris les points dans LittleFS ou envoie-les dans le cloud
La carte redémarre au hasardAlimentation 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.

Voir tous les projets
Température et humidité avec DHT11
AR-55Intermédiaire

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…

4.7(47)
83
ESP32 DHT22 Température et humidité (avec écran LCD)
ES-15Intermédiaire

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.

4.8(38)
57
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
Enregistreur de Température ESP32 (DHT22 + DS1307 RTC + microSD + OLED)
ES-40Avancé
Premium

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.

4.7(7)
12
Compteur ESP32 WebSocket (2 boutons + écran LCD + affichage Web en temps réel)
ES-28Avancé
Premium

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

4.5(14)
23
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
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
ESP32 : heure réelle depuis Internet via NTP
ES-26Avancé
Premium

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.

4.5(13)
22