Failed to read from DHT sensor : causes et solutions DHT11/DHT22
Failed to read from DHT sensor ou nan ? Mauvaise broche ou mauvais type, pull-up absente, intervalle de lecture, ESP32, câble long : solutions et code de test.
Voir Failed to read from DHT sensor! défiler dans le moniteur série, ou nan à la place de la température et de l'humidité, est le problème le plus courant avec les capteurs DHT11 et DHT22. Bonne nouvelle : le capteur n'est presque jamais mort. La cause est généralement l'une de ces six : le numéro de broche du code ne correspond pas au câblage, le type de capteur est faux (DHT22 au lieu de DHT11 ou l'inverse), le capteur nu n'a pas de résistance de pull-up, il est lu trop souvent ou juste après la mise sous tension, l'ESP32 a des soucis d'alimentation ou de timing, ou le câble est trop long.
Dans ce guide, tu verras d'abord ce que signifie exactement le message d'erreur, puis le bon câblage et un tableau symptôme-cause-solution. Ensuite, nous passerons chaque cause en revue et écrirons un code de diagnostic qui détecte tout seul le type de capteur et mesure le taux de réussite, un code de lecture qui résiste aux erreurs et un script MicroPython pour le Raspberry Pi Pico qui distingue les types d'erreur. Pour finir, nous verrons quand abandonner le DHT pour un capteur I2C comme l'AHT20 ou le SHT31.

Que signifie « Failed to read from DHT sensor » ?
Ce message ne vient pas de la bibliothèque elle-même, mais de l'exemple DHTtester fourni avec la bibliothèque DHT d'Adafruit. L'exemple l'affiche quand readTemperature() ou readHumidity() renvoie NaN (Not a Number, « pas un nombre ») au lieu d'une valeur. La bibliothèque renvoie NaN dans deux cas : quand le capteur ne répond pas du tout au signal de démarrage (délai dépassé) ou quand la somme de contrôle des 40 bits reçus ne correspond pas (données corrompues). Le premier cas pointe généralement vers le câblage, la broche, le type ou l'alimentation ; le second vers le timing, les parasites et les câbles longs.
Pour comprendre pourquoi cela arrive si souvent, il suffit de regarder le protocole. L'Arduino réveille le capteur en maintenant la ligne de données à LOW pendant un moment ; le capteur répond par 80 µs à LOW et 80 µs à HIGH, puis envoie 40 bits : 16 bits d'humidité, 16 bits de température et 8 bits de somme de contrôle. Chaque bit commence par 50 µs à LOW ; si le HIGH qui suit dure environ 26–28 µs, le bit vaut 0, et s'il dure environ 70 µs, il vaut 1. Le microcontrôleur doit donc mesurer des écarts de quelques dizaines de microsecondes sans en rater aucun ; un fil mal enfoncé, une pull-up trop faible ou une interruption qui tombe au mauvais moment suffisent à tout fausser.
| Caractéristique qui influe sur la lecture | DHT11 | DHT22 (AM2302) |
|---|---|---|
| Couleur du boîtier | Bleu | Blanc |
| Alimentation | 3–5,5 V | 3,3–6 V |
| Impulsion de démarrage de la bibliothèque | 20 ms à LOW | 1,1 ms à LOW |
| Intervalle de lecture minimal | 1 seconde | 2 secondes |
| Attente après la mise sous tension | Au moins 1 seconde | Au moins 1 seconde, 2 par sécurité |
| Type dans le code | DHT11 | DHT22 |
Le bon câblage : Arduino Uno, ESP32 et Pico
| Broche du DHT | Arduino Uno | ESP32 | Raspberry Pi Pico |
|---|---|---|---|
| VCC (+) | 5V | 3V3 | 3V3 (OUT) |
| DATA (OUT, S) | D2 | GPIO 4 | GP15 |
| GND (−) | GND | GND | GND |
| Pull-up (capteur nu uniquement) | 10 kΩ entre DATA et 5V | 10 kΩ entre DATA et 3V3 | 10 kΩ entre DATA et 3V3 |
| Alimenter le capteur par une broche (code de lecture fiable) | D7 | GPIO 25 | Non utilisé |
Tableau symptôme, cause et solution
Le tableau ci-dessous associe les symptômes les plus fréquents à leurs causes. Trouve ton symptôme et essaie d'abord la solution de la ligne correspondante ; les détails suivent dans les sections après le tableau :
| Symptôme | Cause probable | Solution |
|---|---|---|
| Toutes les lectures donnent nan, aucune valeur | Autre broche dans le code, fil de données mal placé ou capteur non alimenté | Compare le numéro de broche au câblage, mesure entre VCC et GND au multimètre |
| Le capteur est un DHT11, toujours nan | DHT22 déclaré dans le code ; l'impulsion de 1,1 ms est trop courte pour un DHT11 | Écris DHT11 dans le code |
| Pas d'erreur mais des valeurs absurdes (ex. 0,1 °C et 16 %) | Le capteur est un DHT22, DHT11 déclaré dans le code | Écris DHT22 dans le code |
| Ça marche parfois, nan d'autres fois | Pas de pull-up sur le capteur nu, plaque d'essai ou câble mal enfoncé | Place 4,7–10 kΩ entre DATA et VCC, fixe bien les fils |
| Seule la première lecture donne nan | Le capteur est lu juste après la mise sous tension | Attends 2 secondes après begin() |
| Après une erreur, nan pendant 2 secondes | Lectures trop rapprochées ; la bibliothèque répète le dernier résultat pendant 2 s | Laisse au moins 2 secondes entre deux lectures |
| nan de temps en temps sur l'ESP32 | Le Wi-Fi et les tâches perturbent le timing, câble long en 3,3 V | Réessaie, garde la dernière bonne valeur, raccourcis le câble |
| L'ESP32 ne lit jamais rien | GPIO 34–39 choisie ou module en 5 V qui tire la ligne de données à 5 V | Utilise une broche bidirectionnelle comme GPIO 4 et alimente le module en 3V3 |
| Erreurs avec un câble long (3 m ou plus) | La capacité du câble adoucit les fronts du signal et la tension chute | Alimente en 5 V, utilise une pull-up de 4,7 kΩ et du câble torsadé |
| nan après des heures, un reset règle le problème | Le capteur s'est bloqué | Alimente le capteur par une GPIO et coupe-le puis rallume-le après une série d'erreurs |
1. Mauvaise broche ou mauvais type de capteur
Sur un Arduino Uno, #define DHTPIN 2 désigne la broche numérique 2, c'est-à-dire D2 ; ni A2, ni la deuxième patte de la carte. Sur l'ESP32, les numéros sont des numéros de GPIO et correspondent généralement aux marquages de la carte de développement. Les cartes ESP8266 (NodeMCU, Wemos D1 mini) cachent un piège : la broche marquée D4 est en réalité la GPIO 2 ; dans le code, il faut écrire D4 ou 2, et si tu écris 4, la bibliothèque parle à une autre broche. Sur l'ESP32, les GPIO 34–39 fonctionnent uniquement en entrée et ne conviennent donc pas au DHT, dont la ligne de données sert à la fois de sortie et d'entrée. Les GPIO 6–11 sont réservées à la mémoire flash et font planter la carte si tu les utilises.
Le type compte autant que la broche. Si tu écris DHT11, la bibliothèque réveille le capteur avec une impulsion LOW de 20 ms ; si tu écris DHT22, avec une impulsion de 1,1 ms. Un DHT11 a besoin d'au moins 18 ms : si tu lis un DHT11 comme un DHT22, tu n'obtiens le plus souvent aucune réponse et le résultat est nan. L'inverse est plus sournois : le DHT22 répond aussi à l'impulsion longue, mais la bibliothèque décode les octets au format du DHT11. Aucun message d'erreur, juste des valeurs absurdes : dans une pièce à 23,5 °C et 65 % d'humidité, tu verras 0,1 °C et 16 %. Un boîtier bleu, c'est un DHT11 ; un blanc, un DHT22 ; l'AM2302 blanc avec câble est aussi un DHT22.
2. Résistance de pull-up : module ou capteur nu ?
La ligne de données du DHT fonctionne en drain ouvert : le capteur ne fait que tirer la ligne à LOW, et c'est une résistance de pull-up qui fournit le niveau HIGH. Sur les modules à 3 broches soudés sur une petite carte, cette résistance (souvent 10 kΩ, parfois 4,7 kΩ) est déjà présente. Sur le capteur nu à 4 pattes, c'est à toi de la placer entre DATA et VCC ; la fiche technique conseille environ 5 kΩ, et en pratique toute valeur entre 4,7 et 10 kΩ fonctionne bien. La bibliothèque passe la broche en INPUT_PULLUP pendant la lecture, mais la pull-up interne du microcontrôleur est d'environ 20 à 50 kΩ, beaucoup trop faible. Avec un fil court, elle suffit parfois, et c'est justement pour cela que « ça marche parfois, nan d'autres fois » signale presque toujours une pull-up manquante. Tu trouveras le principe expliqué dans résistances de pull-up et pull-down, et tu peux lire la valeur d'une résistance à ses couleurs avec l'outil Code couleur des résistances.

3. Intervalle de lecture et temps de démarrage
Un DHT11 peut fournir au maximum une nouvelle mesure par seconde, un DHT22 une toutes les deux secondes. La bibliothèque Adafruit y veille pour toi : si moins de 2 secondes se sont écoulées depuis la dernière lecture, elle n'interroge pas le capteur et renvoie le dernier résultat. Voici le détail que beaucoup ratent : si ce dernier résultat était une erreur, chaque appel des 2 secondes suivantes renvoie aussi nan. Un code qui lit toutes les 100 ms transforme ainsi une seule erreur en un bloc de 20 lignes de nan. La solution est simple : laisse au moins 2 secondes entre deux lectures et, dans la même boucle, lis d'abord la température puis l'humidité ; le second appel réutilise la même mesure.
Le démarrage est un autre piège. D'après la fiche technique, le capteur est instable pendant la première seconde après sa mise sous tension et n'accepte aucune commande. Si tu lis juste après dht.begin() dans setup(), la première valeur vaut souvent nan. Attendre 2 secondes après begin() supprime complètement le problème. Si tu veux volontairement contourner le cache de 2 secondes de la bibliothèque, utilise readTemperature(false, true) ; le second paramètre force une nouvelle lecture.
4. Le DHT sur ESP32 : 3,3 V et timing
Sur l'ESP32, deux problèmes reviennent le plus souvent. Le premier, c'est la tension : si tu alimentes un module à 3 broches en 5 V, sa résistance de pull-up tire aussi la ligne de données à 5 V, alors que les broches de l'ESP32 ne supportent que 3,3 V. Alimente le module par la broche 3V3 ; le DHT11 et le DHT22 fonctionnent à cette tension. Si un câble long t'oblige à passer en 5 V, relie la ligne de données via un convertisseur de niveau logique. Le second, c'est le timing : la bibliothèque désactive les interruptions pendant la lecture, mais sur l'ESP32 cela ne concerne que le cœur où tourne ton code. La pile Wi-Fi de l'autre cœur et les attentes de la mémoire flash peuvent quand même fausser une lecture de temps en temps. Dans un projet Wi-Fi, il est normal que quelques lectures sur 100 échouent ; sur l'ESP32, il faut donc toujours réessayer et garder la dernière bonne valeur.
Si le taux d'erreur est élevé, évite de lire le capteur aux moments où le Wi-Fi est le plus sollicité, par exemple au milieu d'une requête web, et cherche les signes d'un brownout : une ligne 3,3 V qui s'effondre au démarrage du Wi-Fi fait aussi chuter l'alimentation du capteur. La bibliothèque DHTesp, écrite pour l'ESP32 et l'ESP8266, adapte le timing à ces puces et donne des résultats plus stables sur certaines cartes.
5. Câbles longs et parasites
Quand tu installes le capteur à l'autre bout de la pièce ou dehors, le taux d'erreur augmente. Il y a deux raisons : la capacité d'un câble long ralentit le front montant du signal et brouille l'écart entre 26 µs et 70 µs qui distingue les bits 0 et 1, et un fil fin fait en plus chuter la tension. Pour des câbles de plus de quelques mètres, alimente le capteur en 5 V, descends la pull-up à 4,7 kΩ et fais passer la ligne de données en paire torsadée avec GND ; une paire d'un câble Ethernet est idéale pour cela. La fiche technique recommande une pull-up d'environ 5 kΩ pour les câbles jusqu'à 20 mètres, mais avec des câbles Dupont, attends-toi à des problèmes au-delà de 3 à 5 mètres. Si tu n'as besoin que de la température sur une plus grande distance, le DS18B20 supporte bien mieux les câbles longs.
Code de diagnostic pour tester le capteur (Uno et ESP32)
Le code ci-dessous utilise la broche D2 sur un Arduino Uno et la GPIO 4 sur un ESP32 ; il reconnaît la carte tout seul. Au démarrage, il essaie de lire le capteur d'abord comme un DHT22, puis comme un DHT11, et choisit le type qui donne des valeurs physiquement possibles (−40 à 80 °C, 0 à 100 %). Il lit ensuite toutes les 2,5 secondes et affiche le taux de réussite. Ouvre le moniteur série à 115200 bauds :
1// DHT teşhis kodu: tipi bulur, başarı oranını ölçer (Uno ve ESP32) / DHT diagnostic: finds the type, measures the success rate (Uno and ESP32)
2#include <DHT.h>
3
4#if defined(ESP32)
5const int DHT_PIN = 4; // ESP32: GPIO 4 (34-39 olmaz / never 34-39)
6#else
7const int DHT_PIN = 2; // Uno ve Nano: D2 / Uno and Nano: D2
8#endif
9
10DHT asDht22(DHT_PIN, DHT22);
11DHT asDht11(DHT_PIN, DHT11);
12DHT *sensor = nullptr; // bulunan tip / detected type
13unsigned long okCount = 0, failCount = 0;
14
15bool plausible(float t, float h) { // fiziksel olarak mümkün mü? / physically possible?
16 return !isnan(t) && !isnan(h) && t > -40 && t < 80 && h >= 0 && h <= 100;
17}
18
19bool tryRead(DHT &d) {
20 float t = d.readTemperature(false, true); // force: 2 sn önbelleğini atla / force: skip the 2 s cache
21 float h = d.readHumidity(); // aynı ölçümü kullanır / reuses the same reading
22 return plausible(t, h);
23}
24
25void detect() {
26 for (int i = 0; i < 2 && !sensor; i++) { // önce iki kez DHT22 gibi dene / first try twice as DHT22
27 if (tryRead(asDht22)) sensor = &asDht22;
28 delay(2500);
29 }
30 if (!sensor && tryRead(asDht11)) sensor = &asDht11; // sonra DHT11 gibi / then as DHT11
31 if (sensor == &asDht22) Serial.println(F("DHT22 / AM2302 bulundu / found"));
32 else if (sensor == &asDht11) Serial.println(F("DHT11 bulundu / found"));
33 else Serial.println(F("Yanit yok: pin, kablo, besleme, pull-up / no reply: pin, wiring, power, pull-up"));
34}
35
36void setup() {
37 Serial.begin(115200);
38 asDht22.begin();
39 asDht11.begin();
40 delay(2000); // açılıştan sonra bekle / wait after power-up
41 detect();
42}
43
44void loop() {
45 delay(2500); // DHT22 için en az 2 sn / at least 2 s for the DHT22
46 if (!sensor) {
47 detect(); // bulunana kadar yeniden dene / retry until found
48 return;
49 }
50 float t = sensor->readTemperature(false, true);
51 float h = sensor->readHumidity();
52 if (isnan(t) || isnan(h)) failCount++;
53 else okCount++;
54 Serial.print(F("T: "));
55 Serial.print(t, 1);
56 Serial.print(F(" C H: %"));
57 Serial.print(h, 1);
58 Serial.print(F(" Basari / success: %"));
59 Serial.println(100.0 * okCount / (okCount + failCount), 0);
60}Voici comment interpréter le résultat : s'il affiche Yanit yok / no reply, le capteur ne répond sous aucun des deux types ; vérifie la broche, l'alimentation et la pull-up dans l'ordre ci-dessus. Si un type a été trouvé, regarde le taux de réussite. Sur un Arduino Uno avec un câble court, il doit être de 100 %. Sur un ESP32 qui utilise le Wi-Fi, au-dessus de 95 %, c'est acceptable. En dessous de 90 %, le problème vient très probablement de la pull-up, d'un faux contact ou d'un câble long. Si tu changes de capteur et que tu obtiens le même taux, le problème n'est pas le capteur mais le circuit.
Lecture tolérante aux erreurs : nouvelles tentatives et redémarrage du capteur
Dans un vrai projet, un nan isolé ne doit jamais arriver à l'écran, dans une base de données ou dans la décision de commuter un relais. Le code ci-dessous lit toutes les 3 secondes, continue d'utiliser la dernière valeur valide après une lecture ratée et coupe puis rallume le capteur après cinq erreurs d'affilée. Pour cela, le VCC du capteur est relié à une GPIO (D7 sur l'Uno, GPIO 25 sur l'ESP32) au lieu du 5V ou du 3V3. Un DHT consomme au plus 2,5 mA, une broche l'alimente donc sans peine, et les capteurs qui se bloquent après des heures de fonctionnement repartent ainsi sans reset. Le code n'utilise delay() que pendant le redémarrage du capteur ; le reste du temps, la boucle reste libre pour d'autres tâches.
1// Güvenilir DHT okuma: son iyi değer, hata sayacı, sensörü kapatıp açma / reliable DHT reading: last good value, error counter, sensor power cycle
2#include <DHT.h>
3
4#if defined(ESP32)
5const int DHT_PIN = 4;
6const int DHT_POWER_PIN = 25; // sensörün VCC'si bu pinden / the sensor's VCC comes from this pin
7#else
8const int DHT_PIN = 2;
9const int DHT_POWER_PIN = 7;
10#endif
11#define DHT_TYPE DHT22 // DHT11 kullanıyorsan DHT11 yaz / write DHT11 for a DHT11
12
13DHT dht(DHT_PIN, DHT_TYPE);
14const unsigned long READ_EVERY_MS = 3000; // 3 sn'de bir oku / read every 3 s
15const int MAX_FAILS = 5; // 5 hata = 15 sn / 5 errors = 15 s
16unsigned long lastRead = 0;
17float lastTemp = NAN, lastHum = NAN; // son geçerli değerler / last valid values
18int failStreak = 0;
19
20void powerCycleSensor() {
21 pinMode(DHT_PIN, OUTPUT);
22 digitalWrite(DHT_PIN, LOW); // veri hattından beslenmesin / no power through the data line
23 digitalWrite(DHT_POWER_PIN, LOW); // sensörü kapat / switch the sensor off
24 delay(1000);
25 digitalWrite(DHT_POWER_PIN, HIGH); // yeniden aç / switch it back on
26 dht.begin(); // veri pinini yeniden hazırlar / sets the data pin up again
27 delay(2000); // açılış süresi / start-up time
28}
29
30void setup() {
31 Serial.begin(115200);
32 pinMode(DHT_POWER_PIN, OUTPUT);
33 digitalWrite(DHT_POWER_PIN, HIGH);
34 dht.begin();
35 delay(2000);
36}
37
38void loop() {
39 if (millis() - lastRead >= READ_EVERY_MS) {
40 lastRead = millis();
41 float t = dht.readTemperature();
42 float h = dht.readHumidity();
43 if (isnan(t) || isnan(h)) {
44 failStreak++;
45 Serial.print(F("Okuma hatasi / read error #"));
46 Serial.println(failStreak);
47 if (failStreak >= MAX_FAILS) {
48 Serial.println(F("Sensor yeniden baslatiliyor / power-cycling the sensor"));
49 powerCycleSensor();
50 failStreak = 0;
51 }
52 } else {
53 failStreak = 0;
54 lastTemp = t;
55 lastHum = h;
56 }
57 if (!isnan(lastTemp)) { // ekranda hep son iyi değer / always show the last good value
58 Serial.print(F("T: "));
59 Serial.print(lastTemp, 1);
60 Serial.print(F(" C H: %"));
61 Serial.println(lastHum, 1);
62 }
63 }
64 // diğer işler burada bekletilmeden çalışır / other tasks run here without waiting
65}Test avec le Raspberry Pi Pico (MicroPython)
Le firmware MicroPython du Pico contient un module dht prêt à l'emploi pour le DHT11 et le DHT22 : aucune bibliothèque à installer. Son grand avantage est qu'il distingue les deux types d'erreur : si le capteur ne répond pas du tout, tu obtiens OSError: [Errno 110] ETIMEDOUT, et si des données arrivent mais que la somme de contrôle ne correspond pas, checksum error. Le premier pointe vers le câblage, la broche et l'alimentation ; le second vers les parasites, une pull-up trop faible et les câbles longs. Relie le capteur au 3V3, au GND et à GP15, puis lance le script dans Thonny :
1# DHT testi (Raspberry Pi Pico, MicroPython): hata türlerini ayırır / DHT test: tells the error types apart
2import dht
3import time
4from machine import Pin
5
6sensor = dht.DHT22(Pin(15)) # GP15; DHT11 için dht.DHT11 / dht.DHT11 for a DHT11
7time.sleep(2) # açılış süresi / start-up time
8ok = 0
9fail = 0
10
11while True:
12 try:
13 sensor.measure()
14 t = sensor.temperature()
15 h = sensor.humidity()
16 ok += 1
17 print("T: {:.1f} C H: {:.1f} %".format(t, h))
18 except OSError as e: # ETIMEDOUT: sensör cevap vermedi / the sensor did not answer
19 fail += 1
20 print("Cevap yok / no reply:", e)
21 except Exception as e: # checksum error: veri bozuk geldi / the data arrived corrupted
22 fail += 1
23 print("Bozuk veri / corrupted data:", e)
24 print("Basari / success: {}%".format(100 * ok // (ok + fail)))
25 time.sleep(2.5) # DHT22 için en az 2 sn / at least 2 s for the DHT22Quand passer à un AHT20 ou un SHT31 ?
Si le taux d'erreur reste élevé après toutes ces vérifications, ou si tu as besoin de mesures plus précises, il est peut-être temps d'abandonner le DHT. Les capteurs comme l'AHT20, le SHT31 et le BME280 communiquent en I2C : le capteur gère lui-même le timing et le microcontrôleur se contente de lire le résultat. C'est pourquoi ils restent stables sur l'ESP32 même avec le Wi-Fi actif, et ils peuvent partager les deux mêmes fils avec un écran OLED. Le seul avantage qui reste au DHT est de pouvoir être placé à quelques mètres sur un seul fil ; l'I2C est conçu pour les câbles courts.
| Capteur | Interface | Précision en température | Précision en humidité | Quand le choisir ? |
|---|---|---|---|---|
| DHT11 | Un seul fil | ±2 °C | ±5 % | Expériences scolaires, suivi approximatif d'une pièce |
| DHT22 (AM2302) | Un seul fil | ±0,5 °C | ±2–5 % | Là où il faut un câble de quelques mètres |
| AHT20 | I2C (0x38) | ±0,3 °C | ±2 % | Remplaçant bon marché et stable du DHT |
| SHT31 | I2C (0x44 ou 0x45) | ±0,3 °C | ±2 % | Mesure précise, extérieur, condensation grâce au chauffage intégré |
| BME280 | I2C ou SPI | ±1 °C | ±3 % | Quand tu as aussi besoin de la pression |
En bref : pour les projets en intérieur où le capteur est proche de la carte, l'AHT20 est le changement le plus simple ; les détails sont dans AHT10 et AHT20. Dans une serre, une salle de bain ou à l'extérieur, où l'humidité dépasse 90 %, le SHT31 dure plus longtemps grâce à son chauffage qui élimine la condensation. Si tu veux aussi la pression, le BME280 fournit les trois mesures dans un seul capteur. Pour voir tous les capteurs de température côte à côte, consulte le comparatif des capteurs de température.
En résumé, derrière « failed to read from DHT sensor » se cachent presque toujours la broche, le type, la pull-up, l'intervalle de lecture, l'alimentation ou le câble, et le code de diagnostic te montre lequel en quelques minutes. Tu trouveras les bases du capteur dans capteur de température et d'humidité DHT11. Une fois que ton capteur lit sans erreur, tu peux continuer dans l'application BlueGrays avec les projets de température et d'humidité avec DHT11, d'ESP32 avec DHT22 et écran LCD et d'enregistreur de température ESP32, chacun avec son schéma et son code prêt à l'emploi.
Questions fréquentes
Pourquoi mon DHT11 affiche-t-il nan ?
nan signifie que la bibliothèque n'a reçu aucune réponse valide du capteur. Les causes les plus fréquentes sont un numéro de broche qui ne correspond pas au câblage, un type déclaré en DHT22, l'absence de pull-up sur un capteur nu et des lectures espacées de moins de 2 secondes. Le code de diagnostic permet de trouver la cause en quelques minutes.
Comment corriger « Failed to read from DHT sensor! » sur un DHT22 ?
Vérifie que le type déclaré est DHT22, que la broche est la bonne et que tu attends au moins 2 secondes entre deux lectures. Un capteur nu a besoin d'une résistance de 4,7–10 kΩ entre DATA et VCC. Sur l'ESP32, alimente le capteur en 3V3 et n'utilise pas les GPIO 34–39.
Faut-il une résistance de pull-up pour le DHT22 ?
Oui pour le capteur nu à 4 pattes : place 4,7 à 10 kΩ entre DATA et VCC. Les modules à 3 broches l'ont déjà sur la carte. La pull-up interne du microcontrôleur est trop faible ; compter uniquement sur elle provoque des erreurs intermittentes.
Le DHT11 fonctionne-t-il en 3,3 V ?
Oui, le DHT11 fonctionne de 3 à 5,5 V et le DHT22 de 3,3 à 6 V ; sur l'ESP32 et le Pico, on conseille de les alimenter en 3V3. En 3,3 V, garde un câble court, car la chute de tension sur un long fil fausse les mesures. Pour plusieurs mètres de câble, une alimentation en 5 V avec un convertisseur de niveau logique est plus sûre.
À quelle fréquence peut-on lire un DHT22 ?
Un DHT22 au plus toutes les deux secondes et un DHT11 une fois par seconde. Pour des appels plus rapprochés, la bibliothèque Adafruit renvoie le dernier résultat sans interroger le capteur, et si c'était une erreur, le nan se répète aussi. Pour suivre une pièce, une lecture toutes les 5 à 60 secondes suffit largement.
Quel capteur choisir à la place du DHT22 ?
Pour des mesures plus stables et plus précises, l'AHT20 ou le SHT31 en I2C sont de bons choix ; ils gèrent eux-mêmes leur timing et fonctionnent bien sur l'ESP32 même avec le Wi-Fi actif. Dans les endroits très humides, on préfère le SHT31 avec son chauffage, et le BME280 si la pression est aussi utile. Si tu n'as besoin que de la température avec un long câble, prends un DS18B20.
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.

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.

Horloge matricielle, calendrier et station météo (MAX7219, DS1307)
Un panneau à texte défilant pour ton bureau ou ton mur, qui affiche tour à tour l'heure, la date et la météo de la pièce.

Station d'irrigation intelligente
Un jardinier qui arrose tes plantes tout seul pour qu'elles ne sèchent pas pendant tes vacances.

Mesure de la température avec NTC et écran LCD 2x16
Mesure la température ambiante avec un capteur qui ressemble à une petite perle.

ESP32 HTTPClient + API météo (avec écran LCD)
L'ESP32 appelle par Internet une API météo (wttr.in) en REST avec HTTPClient.h. La réponse JSON est analysée avec ArduinoJson v7, puis la ville, la température, l'humidité, la météo et le vent s'affichent sur un LCD I2C. wttr.in ne demande aucune clé d'API : il suffit de taper le nom de n'importe quelle ville.
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

