Arduino DHT22 code : exemple complet

Le capteur DHT22 transforme une simple carte Arduino en véritable poste de mesure température / humidité. Avec quelques lignes de code bien structurées, tu enregistres des valeurs fiables, tu les affiches sur moniteur série ou écran LCD, et tu poses les bases d’une domotique pertinente.

En maîtrisant une seule structure de programme, tu adaptes ensuite ton projet à une station météo, un système de ventilation ou un suivi de confort intérieur. Le point clé se joue dans le choix de la librairie, l’architecture du code et la gestion des erreurs de lecture.

Présentation du capteur DHT22 et de son fonctionnement avec Arduino

Le DHT22, aussi appelé AM2302, est un capteur numérique combiné température et humidité. Il communique sur un bus à fil unique et fournit des mesures précises sous forme de données numériques facilement exploitables en Arduino. Ce petit module s’intègre très bien dans des projets de régulation thermique, de surveillance de locaux techniques ou de domotique.

Le capteur intègre un capteur d’humidité à condensateur polymère couplé à une sonde de température. L’électronique interne réalise la conversion analogique-numérique, puis transmet les informations via un protocole série propriétaire sur une seule broche de données. Le microcontrôleur Arduino se contente de lire ce signal, de le décoder et de l’exploiter dans le programme.

Caractéristiques techniques clés du DHT22

Les caractéristiques du DHT22 orientent directement la façon d’écrire le code, notamment la période d’échantillonnage et la gestion des erreurs. Voici les paramètres à connaître avant d’attaquer la programmation.

Ces limites influencent directement le code : temps minimum entre deux acquisitions, gestion de la temporisation sans bloquer totalement la boucle principale, et traitement d’éventuelles lectures invalides. Une structure bien pensée évite les comportements aléatoires du capteur.

« Le DHT22 offre une bonne cohérence de mesures pour des projets de confort thermique ou d’optimisation énergétique, tant que la période de lecture et l’environnement d’installation restent maîtrisés. »

Câblage du DHT22 avec une carte Arduino

La connexion du DHT22 à une carte Arduino se fait généralement en quatre points : alimentation, masse, données et résistance de tirage. Un câblage propre et court limite les perturbations et sécurise la communication numérique.

La plupart des modules DHT22 vendus en breakout intègrent déjà la résistance de tirage interne entre VCC et DATA. Pour un capteur nu, une résistance de 4.7 kΩ ou 10 kΩ entre VCC et DATA s’impose.

Schéma de câblage type Arduino Uno + DHT22

Un exemple de raccordement simple pour un Arduino Uno :

• Pin 1 DHT22 (VCC) → 5 V Arduino
• Pin 2 DHT22 (DATA) → Pin numérique 2 Arduino (par exemple)
• Pin 3 DHT22 → non connectée
• Pin 4 DHT22 (GND) → GND Arduino

Avec un module monté sur PCB, les broches sont souvent déjà étiquetées : VCC, GND, DATA. Le câblage suit alors simplement les mentions du module.

Choix de la librairie Arduino pour le DHT22

Le DHT22 utilise un protocole temporel relativement strict. Une librairie dédiée simplifie la communication et évite de réécrire le décodage bas niveau. Le monde Arduino se structure surtout autour de la librairie Adafruit DHT sensor, complétée par quelques variantes stables.

Librairie Adafruit DHT sensor

La librairie Adafruit DHT sensor reste la plus largement utilisée dans la communauté. Elle gère les DHT11, DHT22 et variantes, et fournit des fonctions simples :

• dht.begin() pour initialiser le capteur
• dht.readTemperature() pour la température en °C ou °F
• dht.readHumidity() pour l’humidité relative en %
• dht.computeHeatIndex() pour l’indice de chaleur
• dht.convertCtoF() pour la conversion °C → °F

Côté taille mémoire, quelques versions se distinguent :

Sur une carte type Uno, la place mémoire reste confortable avec ces versions pour la majorité des projets de mesure simples ou de datalogging basique.

Librairie alternative DHT stable

Une autre famille de librairies, souvent appelée DHT stable, met l’accent sur la robustesse des timings et la compatibilité avec différentes fréquences CPU. Cette option intéresse surtout les projets déployés en continu avec forte exigence de fiabilité.

Sur certaines cartes 32 bits ou dans des environnements multi-tâches, l’utilisation d’une librairie plus stricte sur les délais améliore la régularité des lectures. Le choix se fait alors en fonction du microcontrôleur, de la fréquence d’horloge et de l’architecture logicielle globale.

Exemple complet de code Arduino avec DHT22

Le code ci-dessous constitue une base solide pour un projet de mesure température / humidité avec DHT22. Il gère l’initialisation, la lecture périodique, le contrôle d’erreur et l’affichage sur le moniteur série.

Code minimal fonctionnel avec librairie Adafruit DHT

Avant de compiler, installe la librairie Adafruit Unified Sensor et la librairie DHT sensor library depuis le gestionnaire de bibliothèques de l’IDE Arduino.

#include <DHT.h>

// --- Paramètres capteur ---
#define DHTPIN 2        // Broche de données DHT22 connectée à D2
#define DHTTYPE DHT22   // Type de capteur DHT22

DHT dht(DHTPIN, DHTTYPE);

// --- Paramètres de mesure ---
const unsigned long DHT_INTERVAL = 2000;  // 2 s entre deux lectures
unsigned long lastDhtRead = 0;

void setup() {
  Serial.begin(9600);
  Serial.println(F("Initialisation DHT22..."));

  dht.begin();
}

void loop() {
  unsigned long currentMillis = millis();

  if (currentMillis - lastDhtRead >= DHT_INTERVAL) {
    lastDhtRead = currentMillis;

    float humidity = dht.readHumidity();
    float temperature = dht.readTemperature();      // °C
    float temperatureF = dht.readTemperature(true); // °F

    if (isnan(humidity) || isnan(temperature)) {
      Serial.println(F("Erreur de lecture DHT22"));
      return;
    }

    // Calcul de l'indice de chaleur en °C et °F
    float heatIndexF = dht.computeHeatIndex(temperatureF, humidity);
    float heatIndexC = dht.computeHeatIndex(temperature, humidity, false);

    Serial.print(F("Humidite: "));
    Serial.print(humidity);
    Serial.print(F(" %  "));

    Serial.print(F("Temperature: "));
    Serial.print(temperature);
    Serial.print(F(" *C  "));
    Serial.print(temperatureF);
    Serial.print(F(" *F  "));

    Serial.print(F("Indice de chaleur: "));
    Serial.print(heatIndexC);
    Serial.print(F(" *C  "));
    Serial.print(heatIndexF);
    Serial.println(F(" *F"));
  }
}

Ce code respecte le délai de 2 secondes recommandé entre deux lectures. La fonction millis() assure une temporisation non bloquante, ce qui permet d’ajouter d’autres tâches dans la boucle principale (commande de relais, enregistrement sur carte SD, communication série, etc.).

« La gestion non bloquante du temps avec millis() reste une base saine pour tout projet Arduino un peu structuré. Elle facilite l’ajout de fonctionnalités sans réécrire le cœur du programme. »

Structure du code et bonnes pratiques

Le code s’organise autour de quelques points clés :

• Définition des constantes de broche et type de capteur
• Initialisation du port série et du DHT dans setup()
• Gestion d’un intervalle de mesure avec millis()
• Lecture, test isnan(), puis traitement des valeurs
• Calcul complémentaire de l’indice de chaleur

Cette base sert ensuite de squelette pour des projets plus avancés : envoi vers une plateforme IoT, affichage sur écran OLED, pilotage automatique de ventilation ou de chauffage.

Gestion des erreurs et fiabilité des mesures DHT22

Le DHT22 retourne parfois des valeurs NaN ou incohérentes (0% d’humidité en environnement normal, par exemple) en cas de bruit électrique, de câblage approximatif ou de lecture trop fréquente. Le code doit filtrer ces événements et réagir proprement.

Stratégies de gestion d’erreurs

Quelques approches efficaces pour améliorer la fiabilité :

• Tester systématiquement isnan() sur température et humidité
• Limiter la fréquence des lectures à une fois toutes les 2 secondes ou plus
• Ignorer les valeurs manifestement aberrantes au regard d’un intervalle attendu
• Conserver la dernière mesure valide et la réutiliser si la lecture courante échoue

Une petite couche de logique dans le code renforce nettement la confiance dans les données, surtout lorsqu’un automate déclenche un chauffage, une VMC ou un déshumidificateur.

Exemple de filtrage simple dans le code

float lastValidTemp = NAN;
float lastValidHum = NAN;

void readDhtWithFilter() {
  float h = dht.readHumidity();
  float t = dht.readTemperature();

  if (isnan(h) || isnan(t)) {
    Serial.println(F("Lecture DHT invalide, conservation de la derniere valeur."));
    return; // On conserve lastValidTemp / lastValidHum
  }

  // Filtre simple sur les valeurs extrêmes
  if (t < -40 || t > 80 || h < 0 || h > 100) {
    Serial.println(F("Valeur DHT hors plage, ignoree."));
    return;
  }

  lastValidTemp = t;
  lastValidHum = h;
}

Ce type de fonction se combine facilement avec l’exemple complet précédent. La boucle principale appelle alors readDhtWithFilter() à intervalles réguliers.

Utilisation des fonctions avancées : indice de chaleur et conversions

La librairie Adafruit fournit déjà des routines pour calculer l’indice de chaleur et convertir les unités. Ces fonctions allègent le code utilisateur et améliorent la lisibilité.

Indice de chaleur : interpréter le ressenti

L’indice de chaleur traduit la sensation de chaleur ressentie en fonction de la température et de l’humidité relative. Par exemple, une pièce à 27°C et 70% d’humidité n’est pas perçue comme aussi confortable qu’une pièce à 27°C et 40% d’humidité.

ArduinoPiloter un relais 230 V avec Arduino en sécurité : 5 erreurs à éviter

Dans le code précédent, l’appel suivant réalise le calcul :

float heatIndexF = dht.computeHeatIndex(temperatureF, humidity);
float heatIndexC = dht.computeHeatIndex(temperature, humidity, false);

Cette valeur peut ensuite piloter un ventilateur, alerter un utilisateur ou ajuster une ventilation mécanique contrôlée dans une logique globale de gestion du confort intérieur.

Conversions Celsius / Fahrenheit

La fonction dht.convertCtoF() facilite les conversions lorsque l’affichage ou la plateforme IoT cible utilisent le Fahrenheit :

float tempC = dht.readTemperature();
float tempF = dht.convertCtoF(tempC);

Cette conversion explicite reste utile si tu préfères lire systématiquement la température en °C dans le capteur puis gérer les conversions dans le reste du programme ou au niveau de l’interface utilisateur.

Intégration du DHT22 dans des projets concrets

Le DHT22 s’insère dans de nombreux scénarios pratiques. L’exemple de code de base devient alors un module au sein d’une application complète. Le secret consiste à garder des fonctions claires et indépendantes dans le code Arduino.

Applications courantes autour du DHT22

Quelques usages typiques :

• Stations météo intérieures ou extérieures sous abri
• Systèmes de régulation de température pour serre, local technique ou atelier
• Projets de maison connectée avec interface web ou application mobile
• Surveillance environnementale de pièces sensibles (archives, cave, local informatique)
• Systèmes HVAC (chauffage, ventilation, climatisation) pour ajuster les consignes
• Qualité de l’air intérieur couplée à d’autres capteurs (CO₂, COV, particules fines)
• Surveillance à distance via Arduino IoT Cloud, MQTT ou HTTP

Dans chacun de ces cas, l’exemple de code de base reste identique. Seule la couche supérieure change : enregistrement de données, interface de pilotage, logique de décision.

Structurer le code pour un projet évolutif

Pour un projet amené à grandir, séparer les responsabilités dans le code rend la maintenance plus simple :

• Une fonction dédiée à la lecture capteur
• Une fonction pour la mise à jour de l’affichage
• Une fonction pour la logique de régulation (relais, ventilateurs, chauffage)
• Une fonction pour la communication (série, Wi-Fi, radio)

Le bloc DHT22 se limite alors à fournir des données fiables au reste du programme. Si un jour tu remplaces ce capteur par un autre modèle plus complet, la modification reste circonscrite à cette partie du code.

Optimisation et limites du DHT22 dans un code Arduino avancé

Le DHT22 rend de bons services dans un grand nombre de situations, mais il présente aussi quelques limites à prendre en compte dans l’architecture logicielle. Une bonne compréhension de ces aspects évite les mauvaises surprises lorsqu’un projet passe du prototype à la mise en service réelle.

Forces du DHT22 pour ton code Arduino

Plusieurs atouts expliquent la popularité du DHT22 :

• Faible consommation énergétique autour de 1.5 mA
• Stabilité à long terme avec une dérive d’environ ±0.5% HR par an
• Coût modéré, intéressant pour des installations multi-points
• Sortie numérique limitant les problèmes de calibration analogique

Ces caractéristiques conviennent bien à des systèmes distribués, alimentés par une source secteur ou par batterie avec veille prolongée et réveils ponctuels.

Limites à prendre en compte dans l’architecture logicielle

Certaines contraintes orientent le design du code :

• Fréquence de mesure limitée à une lecture toutes les 2 secondes
• Sensibilité aux perturbations sur les câbles longs ou mal blindés
• Temps de réponse qui n’autorise pas les changements rapides de consigne
• Précision adaptée au confort mais insuffisante pour la métrologie stricte

Pour des variations très rapides de température ou d’humidité, d’autres capteurs plus réactifs conviennent mieux. Le DHT22 se positionne plutôt sur des usages de contrôle de confort ou de surveillance progressive.

Adapter l’exemple de code DHT22 à d’autres cartes Arduino et environnements

La logique présentée plus haut se transpose sans difficulté à la plupart des cartes compatibles Arduino : Mega, Nano, Pro Mini, voire cartes avec microcontrôleur ARM ou ESP. Quelques ajustements renforcent toutefois la compatibilité.

Arduino Mega, Nano et cartes classiques

Sur les cartes 8 bits traditionnelles (Uno, Nano, Mega), l’exemple fonctionne quasiment tel quel :

• Choix d’une broche numérique libre pour DHTPIN
• Vérification de la tension (3.3 V ou 5 V) selon la carte
• Adaptation du débit série si tu souhaites une communication plus rapide

Sur une Mega, l’espace mémoire plus conséquent ouvre la porte à davantage de capteurs, de librairies et de fonctionnalités réseau.

ESP8266, ESP32 et plateformes connectées

Sur ESP8266 ou ESP32, la logique de code reste similaire, mais la gestion du temps et des tâches se combine avec le Wi-Fi, les timers internes et parfois un système d’exploitation temps réel léger. Dans ce cas, une librairie DHT stable et une attention particulière aux interruptions améliorent la fiabilité.

La structure générale de la fonction de lecture DHT ne change pas, mais s’intègre dans un scheduler ou un système d’événements périodiques plutôt que dans une simple boucle loop() monolithique.

« Un code DHT22 bien structuré, avec temporisation non bloquante et filtrage des erreurs, se transpose très facilement d’un Arduino Uno vers un environnement plus complexe, jusqu’aux cartes connectées et aux architectures multi-tâches. »