Module DHT22 Arduino : caractéristiques, raccordement, et librairie utilisable (tutorial avec exemples de code arduino)

Si vous cherchez un moyen de mesurer simplement la température et l’hygrométrie de l’air, aussi bien intérieur qu’extérieur, alors rien de tel qu’un DHT22 pour ce faire ! Car pouvant faire des mesures de température allant de -40 °C à +80 °C et de taux d’humidité allant de 0 à 100%, il est clairement le capteur idéal pour tout bon bricoleur en électronique ! Surtout qu’il ne coûte que quelques euros seulement !

Ici, nous allons voir toutes les caractéristiques principales du DHT22 et son raccordement à l’Arduino (avec tous les composants additionnels indispensables pour assurer son bon fonctionnement). Tout cela sera ensuite accompagné de codes exemples arduino, vous montrant comment vous servir du DHT22 en pratique, avec relevés à l’intervalles réguliers, et traçage graphique de courbes de température et taux d’humidité. Ainsi, vous en saurez suffisamment pour faire vos premiers pas avec ce capteur de température et d’hygrométrie pas cher, et pour l’intégrer à vos propres projets arduino 😉

Cet article se veut avant tout à destination des débutants en électronique. Je n’approfondirai donc pas ici la communication à un fil de ce capteur, afin de rester simple (tant au niveau des explications, qu’au niveau du programme arduino en lui-même). Bien sûr, rien ne vous empêchera de pousser un peu plus les choses, en prenant vous-même le contrôle de communication Arduino / DHT22. Mais attention, car cela n’est pas si évident que cela au début, compte tenu du timing particulier à tenir ! Du reste, si vous avez la moindre question ou des remarques à faire, n’hésitez pas à m’en faire part en bas de l’article !

Module	Description	Lien
	Module DHT22 monté sur PCB (avec fils de raccordement dupont)	Voir le prix

Survol rapide

Pour faire simple, dites vous que le DHT22 est tout simplement un « thermomètre / hygromètre » électronique, interrogeable à distance (via un fil de données électrique). Vous le trouverez parfois également nommé AM2302 ou RHT03. Mais plus globalement, il fait parti de la famille des capteurs DHT, dans laquelle vous retrouvez les DHT11, DHT21, DHT22, DHT33, et DHT44.

Tous ces différents capteurs ont leurs propres caractéristiques. Mais en pratique, seuls les DHT11 et DHT22 sont réellement utilisés couramment par les bricoleurs en électronique. Voici d’ailleurs un bref comparatif entre ces deux types de capteur :

Modèle	DHT11	DHT22
Photo du capteur
Tension d’alimentation	3 à 5,5 V (typ. 5V)	3,3 à 6V (typ. 5V)
Plage de mesure température	0°C à 50 °C	-40°C à +80 °C
Précision de la mesure de température	± 2 °C	± 0,5 °C
Résolution « d’affichage » température	1 °C	0,1 °C
Plage de mesure humidité relative	20% à 80%	0% à 100%
Précision de mesure de l’humidité	± 5%	± 2 à 5%
Résolution « d’affichage » humidité	1 %	0,1%
Courant consommé (pendant les mesures / et au repos)	2,5 mA / 150 µA	1,5 mA / 50 µA
Fréquence d’échantillonnage maxi	1 Hz max (une lecture toutes les secondes, max)	0,5 Hz max (une lecture toutes les 2 secondes, maximum)
Avantages et inconvénients	Pas cher, mais manque cruellement de précision	Plus précis, mais revient plus cher à l’achat
Lien (description/prix)	DHT11	DHT22

Le DHT22 est sans conteste celui qui a le meilleur rapport qualité prix, selon moi. Personnellement, je vous déconseille l’achat d’un DHT11, si vous cherchez à avoir un « minimum » de précision. Quant aux DHT33 et 44, du fait qu’ils sont plus rares, le mieux reste là encore le DHT22.

Cela étant dit, il faut tout de même savoir une chose : le DHT22 peut se présenter de deux différentes manières, selon s’il est livré « nu », ou soudé sur une plaquette PCB. À noter que le modèle monté sur circuit imprimé a un fort avantage : il est déjà équipé de composants additionnels indispensables pour assurer une parfaite communication avec le capteur, à savoir : une résistance de pull-up sur la ligne de données, et une capacité de filtrage sur l’alim (comme le préconise le fabricant, d’ailleurs). Bien sûr, à vous de faire votre choix, selon vos besoins ! D’ailleurs, voici un bref aperçu de ces 2 versions :

Modèle	DHT22 « nu »	DHT22 « monté sur PCB »
Aperçu
Avantages / Inconvénients	Pas cher, mais nécessite des composants additionnels pour bien fonctionner	Compact et tout équipé, mais coûte un poil plus cher
Brochage (de gauche à droite)	1) VCC 2) DATA 3) Non Connecté 4) GND	1) GND 2) VCC 3) DATA
Lien (description/prix)	DHT22 « nu »	DHT22 « sur PCB »

À noter que le protocole de communication des DHT est de type unifilaire, c’est-à-dire qu’un seul fil est utilisé pour émettre ET recevoir des données. Ce protocole-ci est propre aux capteurs DHTxx, et nécessite un timing précis pour bien fonctionner (vous trouverez d’ailleurs tous les chronogrammes détaillés dans le datasheet du fabricant, téléchargeable dans le paragraphe suivant).

Cela étant dit, comme nous utiliserons des librairies toutes prêtes dans Arduino, nous n’aurons pas à nous soucier de toute la partie protocole du DHT22 ! Car celles-ci s’en occuperont à notre place, sans prise de tête ! Bien évidemment, rien ne vous empêche de vous passer de toute librairie arduino, et de tout faire à la mano ! Par contre, ne croyez pas qu’il s’agisse forcément d’une chose de facile à faire 😉

Voilà pour ce petit tour d’horizon sur le DHT22 (dans les grandes lignes, bien sûr !). À présent, voyons un peu plus en détail toutes les caractéristiques de ce capteur de température, et d’hygrométrie !

Caractéristiques du DHT22 (issues du datasheet)

Tout ce qui est partagé ici provient essentiellement de ce datasheet du DHT22. Nous allons voir chaque caractéristique importante, dans cette partie.

Tension d’alimentation

Le DHT22 s’alimente en courant continu, avec une tension comprise entre 3,3 volts et 6 volts. Typiquement, on utilisera une tension de 5V, pour alimenter ce capteur. Ce qui est d’ailleurs hyper pratique, lorsqu’on l’interface avec un arduino !

Côté consommation électrique, attendez-vous à consommer :

• De 1 à 1,5 mA, lorsque le capteur est actif (lorsqu’il fait ses mesures)
• Et de 40 à 50 µA, lorsqu’il est « au repos » (entre deux mesures, donc)

Ce courant n’est pas important en soit, mais est tout de même à prendre en considération, si vous travaillez sur batterie ou accus, par exemple. Car la consommation de ce genre de capteur n’est pas négligeable à long terme. Du coup, prenez bien en considération cette dimension, si jamais votre montage à base de DHT22 fonctionnait sur pile, accu, ou batterie !

Les mesures de température (plage d’opération, résolution, et précision des valeurs retournées)

La sonde de température intégrée au DHT22 permet de mesurer des températures allant de -40 °C à +80 °C. Elle peut donc aussi bien servir en intérieur, comme en extérieur (contrairement au DHT11, par exemple, qui lui n’est pas capable de mesurer des températures négatives).

Côté résolution, on va jusqu’au dixième de degré près (0,1 °C donc). Par contre, ne pensez pas pour autant que la précision de la mesure (son exactitude, si vous préférez), sera elle aussi de 0,1 degré. Car sa précision, quant à elle, est de ± 0,5 °C.

Tout cela ne vous semble pas clair ? Alors prenons un exemple !

[Exemple] Si le DHT22 vous retourne une valeur de température de 19,8 °C, alors la température réelle sera en fait comprise entre 19,3 et 20,3 °C. En clair : ce n’est pas parce que la précision va jusqu’au 1/10^ème de degré près, qu’elle en sera exacte au dixième de degré près pour autant !

Les mesures de taux d’humidité (plage de mesure, résolution, précision, et dérive)

La plage de mesure de l’hygrométrie avec un DHT22 s’étend de 0% à 100% (contrairement au DHT11, par exemple, qui lui est limité à la plage 20 – 80 %). À noter qu’il s’agit ici d’humidité relative (en %), et non de mesure d’humidité « absolue » (en g/m3, par exemple). C’est vrai que je ne l’ai pas précisé, jusqu’à présent ! Si besoin, voici un exemple de formule de calcul pour déterminer l’humidité absolue à partir de l’humidité relative, si cela vous intéresse 😉

Côté résolution, la mesure retournée sera spécifiée au dixième de pourcent près (0,1% donc). Mais comme pour la mesure de température, ne confondez pas « résolution » et « précision » (l’exactitude des mesures, si vous voulez), car ce sont deux choses vraiment différentes. Ici, avec le DHT22, la précision est de ± 2 à 5 %.

Par exemple : si votre DHT22 vous « indique » que l’humidité relative est de 49,3 %, alors l’humidité relative « réelle » sera comprise entre 48,8 et 49,8 %, dans le pire des cas (en considérant une précision de ± 5%). En clair, encore une fois : ce n’est pas parce que la valeur retournée par le DHT22 est spécifiée au dixième de pourcent près, que la précision sera de 0,1% elle aussi. En tout cas, j’espère que cette phrase est suffisamment claire, car je n’arrive pas à vous l’expliquer autrement 😉

Enfin, il faut savoir que tout capteur DHT22 aura une dérive d’environ ± 0,5% / an, au niveau de ses mesures de taux d’humidité. En bref, cela signifie que le capteur d’humidité intégré au DHT22 perdra en qualité au fil du temps, à raison d’un demi pourcent chaque année (contrairement au capteur de température, qui lui, semble très peu dériver).

Fréquence d’échantillonnage (sampling, en anglais)

Il faut savoir qu’un DHT22 ne pourra pas vous donner des valeurs « à jour » très souvent. En fait, selon les spécifications du fabricant, l’intervalle entre deux mesures de température ou d’hygrométrie ne devrait pas se faire à moins de 2 secondes de la précédente. Pour faire simple : vous ne pourrez pas faire plus d’une mesure toutes les deux secondes !

D’un autre côté, compte tenu de « l’inertie » des capteurs intégrés au DHT22, il ne sert pas à grand-chose d’aller consulter la température ou l’hygrométrie très souvent. Car les valeurs retournées ne bougeront pas aussi vite qu’en « réalité », compte tenu de l’inertie des capteurs dont je parlais. Du coup, faites seulement des mesures espacées, avec minimum 2 secondes d’écart entre chacune d’elle, et tout se passera bien 😉

À noter que si vous essayez de faire plus d’une lecture toutes les deux secondes, certaines librairies arduino vous retourneront tout simplement la précédente valeur lue sur le DHT22, plutôt que de l’interroger à nouveau (ça constitue une bonne sécurité, d’ailleurs). Mais attention, car toutes les bibliothèques Arduino n’ont peut-être pas cela d’intégré dans leur code. À fortiori, c’est encore plus vrai si vous ne faites appel à aucune librairie arduino, et que vous communiquez directement avec votre DHT22.

Pour résumer : ne faites pas plus de 1 mesure toutes les 2 secondes (soit une fréquence d’échantillonnage de 0,5 Hz), afin de bien respecter les préconisations fabricant.

Module	Description	Lien
	Module DHT22 monté sur PCB (avec fils de raccordement dupont)	Voir le prix

Comment raccorder le DHT22 à l’Arduino (alimentation, ligne de communication, …)

Le branchement d’un DHT22 à l’Arduino est on ne peut plus simple ! Car il y a seulement 3 fils à brancher :

• L’alimentation (qui, pour rappel, doit être comprise entre 3,3 et 6 volts)
• La masse (le GND, donc)
• Et la ligne de communication (unique ici, car la communication avec le DHT se fait de manière unifilaire)

Cela étant dit, il y a également 2 composants à rajouter :

• Une résistance de pull-up au niveau de la ligne de données (car celle-ci est de type « collecteur ouvert »). Cette résistance devra avoir une valeur comprise entre 4,7K et 10K ohms.
• Et une capacité de filtrage, à proximité du DHT (valeur typique : 100 nF)

À noter que si vous achetez un DHT22 déjà monté sur PCB, il y a fort à parier que ces 2 composants soient déjà intégrés au circuit imprimé, comme visible ci-dessous :

À présent, passons au branchement d’un DHT22 sur un Arduino ! Mais pour ce faire, il faut avant tout définir sur quelle broche vous voudrez brancher la ligne de données bidirectionnelle du DHT. En fait, rien de plus simple là aussi ! Car il suffit de connecter la ligne DATA sur n’importe quelle sortie digitale de votre Arduino, la plupart du temps. Par exemple, sur un Arduino Uno, vous pouvez la brancher la ligne de communication sur l’une des E/S digitales D0 à D13 (au choix !). Par contre, perso, j’éviterai au possible d’utiliser les pins D0 ou D1 d’un Arduino Uno, qui sont utilisées pour le téléversement du programme arduino (pins TX et RX).

Au final, au niveau du câblage avec un Arduino Uno, voici ce que vous pouvez réaliser :

Maintenant que nous avons vu la partie câblage et raccordement du DHT22 à un Arduino, passons à la partie logicielle, en utilisant une librairie adaptée à celui-ci !

Librairie DHT (gestionnaire de bibliothèque IDE Arduino)

Pour faire mes essais, j’ai utilisé la librairie « DHT sensor library » de « Adafruit ». Elle est probablement l’une des plus utilisées à ce jour, pour dialoguer avec un DHT22.

Pour la télécharger, il vous suffit d’ouvrir votre IDE arduino, puis de cliquer sur Outils > Gérer les bibliothèques. Ensuite, dans la fenêtre qui s’est ouverte, il vous suffit de taper « dht22 » dans le champ de recherche, puis d’appuyer sur la touche ENTRÉE. Une fois fait, vous devriez trouver, dans la liste proposée en dessous, la bibliothèque « DHT sensor library » d’Adafruit, comme visible ci-dessous :

Il ne vous reste plus qu’à cliquer sur « Installer », pour lancer son intégration dans votre IDE arduino. À noter que le logiciel vous proposera peut-être d’installer en même temps une « dépendance » (une autre librairie, dont la librairie DHT a besoin), nommée « Adafruit Unified Sensor ». Pour l’importer dans votre environnement Arduino, cliquez simplement sur « Install All », comme visible ci-après :

L’opération prend quelques secondes, puis, vous devriez voir apparaître le marquage « INSTALLED » au niveau de votre bibliothèque Adafruit DHT sensor. Voici ce que j’ai obtenu, de mon côté :

À présent, il ne vous reste plus qu’à fermer cette fenêtre, et à passer à la programmation !

Pour ce faire, il suffit d’écrire la ligne suivante, en haut de son programme arduino, pour appeler cette librairie :

#include <DHT.h>

Une fois fait, il ne vous restera plus qu’à instancier la classe issue de cette librairie, afin de pouvoir dialoguer avec le DHT22. Voici d’ailleurs un exemple de ce que vous pourriez écrire, pour ce faire :

#define brocheBranchementDHT 6   // Si la ligne de données du DHT22 est branchée sur la pin D6 de votre Arduino, par exemple
#define typeDeDHT DHT22          // Si votre DHT utilisé est un DHT22 (mais cela pourrait aussi bien être un DHT11 ou DHT21, par exemple)

DHT dht(brocheBranchementDHT, typeDeDHT);

Maintenant, vous pouvez appeler chaque fonction de cette classe « dht » dans votre code arduino, suivant ce que vous souhaitez faire. Voici d’ailleurs les fonctions les plus courantes, avec leur signification :

• dht.begin() : permet d’initialiser le DHT22
• dht.readTemperature() : retourne la température mesurée par le DHT22 (au format « float »)
• dht.readHumidity() : retourne le taux d’humidité mesuré (au format « float » également)
• dht.convertCtoF(tempEnCelsius) : permet de convertir en Fahrenheit, une température initialement exprimée en degrés Celsius
• dht.convertFtoC(tempEnFahrenheit) : inverse de la fonction précédente (transforme une température exprimée en degrés Fahrenheit pour donner une température en degré Celsius)
• dht.computeHeatIndex(tempEnFahrenheit, pourcentHumidite, booleenUnite) : calcule et retourne la température ressentie (en degrés Fahrenheit (utilisez la fonction convertFtoC pour transformer cette valeur en degrés Celsius)

Nota : pour cette fonction, il existe une variante qui permet de travailler directement en degrés Celsius. Pour ce faire, il suffit d’écrire une ligne du type : temperatureRessentieEnDegreCelsius = dht.computeHeatIndex(temperatureEnCelsius, pourcentageHumidite, false) … en sachant que le « false » écrit ici indique à cette fonction que l’on travaille en degrés Celsius ! Tout simplement !

Voilà qui fait le tour de cette librairie ! À présent, il est temps de passer à la pratique, et voir comment se servir de cette librairie DHT, et de ces fonctions ! Alors en avant 😉

Module	Description	Lien
	Module DHT22 monté sur PCB (avec fils de raccordement dupont)	Voir le prix

Code arduino (exemple #1) : afficher la température et le taux d’humidité sur le moniteur série

Comme premier exemple, je vous propose de faire afficher sur le moniteur série de l’IDE arduino la température et le taux d’humidité ambiant, mesuré par un DHT22.

Côté montage, voici ce que j’ai réalisé de mon côté, avec un Arduino Uno et un DHT22 monté sur PCB :

La pin D6 de l’Arduino est reliée à la broche « DATA » du DHT22, afin qu’ils puissent communiquer l’un avec l’autre via ce canal.

Côté logiciel, le programme suivant suppose que vous avez bien importé la bibliothèque « DHT sensor library », comme vu dans la partie juste avant. Si c’est bon, voici le code de programmation permettant de faire afficher température et hygrométrie sur le moniteur série, depuis un Arduino Uno :

/*
   ______               _                  _///_ _           _                   _
  /   _  \             (_)                |  ___| |         | |                 (_)
  |  [_|  |__  ___  ___ _  ___  _ __      | |__ | | ___  ___| |_ _ __ ___  _ __  _  ___  _   _  ___
  |   ___/ _ \| __|| __| |/ _ \| '_ \_____|  __|| |/ _ \/  _|  _| '__/   \| '_ \| |/   \| | | |/ _ \
  |  |  | ( ) |__ ||__ | | ( ) | | | |____| |__ | |  __/| (_| |_| | | (_) | | | | | (_) | |_| |  __/
  \__|   \__,_|___||___|_|\___/|_| [_|    \____/|_|\___|\____\__\_|  \___/|_| |_|_|\__  |\__,_|\___|
                                                                                      | |
                                                                                      \_|
  Fichier :       DHT22surMoniteurSerie.ino
  
  Description :   Programme permettant d'afficher sur le moniteur série de l'IDE Arduino, des températures et taux d'humidité
                  mesurés par un DHT22, branché sur la pin D6 d'un Arduino Uno

  Auteur :        Jérôme TOMSKI (https://passionelectronique.fr/)
  Créé le :       06.06.2021

  Librairie utilisée : DHT sensor library (https://github.com/adafruit/DHT-sensor-library)

*/

#include <DHT.h>
#define brocheDeBranchementDHT 6    // La ligne de communication du DHT22 sera donc branchée sur la pin D6 de l'Arduino
#define typeDeDHT DHT22             // Ici, le type de DHT utilisé est un DHT22 (que vous pouvez changer en DHT11, DHT21, ou autre, le cas échéant)

// Instanciation de la librairie DHT
DHT dht(brocheDeBranchementDHT, typeDeDHT);


// ========================
// Initialisation programme
// ========================
void setup () {
  
  // Initialisation de la liaison série (pour retourner les infos au moniteur série de l'ordi)
  Serial.begin(9600);
  Serial.println("Programme de test du DHT22");
  Serial.println("==========================");
  Serial.println();

  // Initialisation du DHT22;
  dht.begin();
}
 
// =================
// Boucle principale
// =================
void loop () {
  
  // Lecture des données
  float tauxHumidite = dht.readHumidity();              // Lecture du taux d'humidité (en %)
  float temperatureEnCelsius = dht.readTemperature();   // Lecture de la température, exprimée en degrés Celsius

  // Vérification si données bien reçues
  if (isnan(tauxHumidite) || isnan(temperatureEnCelsius)) {
    Serial.println("Aucune valeur retournée par le DHT22. Est-il bien branché ?");
    delay(2000);
    return;         // Si aucune valeur n'a été reçue par l'Arduino, on attend 2 secondes, puis on redémarre la fonction loop()
  }

  // Calcul de la température ressentie
  float temperatureRessentieEnCelsius = dht.computeHeatIndex(temperatureEnCelsius, tauxHumidite, false); // Le "false" est là pour dire qu'on travaille en °C, et non en °F
  
  // Affichage des valeurs
  Serial.print("Humidité = "); Serial.print(tauxHumidite); Serial.println(" %");
  Serial.print("Température = "); Serial.print(temperatureEnCelsius); Serial.println(" °C");
  Serial.print("Température ressentie = "); Serial.print(temperatureRessentieEnCelsius); Serial.println(" °C");
  Serial.println();

  // Temporisation de 2 secondes (pour rappel : il ne faut pas essayer de faire plus d'1 lecture toutes les 2 secondes, avec le DHT22, selon le fabricant)
  delay(2000);
}

Et au niveau du moniteur série de votre IDE Arduino, vous devriez avoir quelque chose qui ressemble à ce qui suit (avec d’autres valeurs de température et d’hygrométrie, bien entendu !) :

À noter ici que le rafraîchissement se fait toutes les 2 secondes (ce qui est la vitesse maximale de « consultation du capteur », autorisée par le fabricant). Cela étant dit, il est rare que la température ou le taux d’hygrométrie varient brusquement dans le temps, compte tenu de l’inertie des capteurs.

Code arduino (exemple #2) : tracer le graphique de la température et de l’hygrométrie sur le traceur série

Deuxième exemple que je vous propose de faire : tracer le graphe de l’évolution de la température et du taux d’humidité dans le temps, via le « traceur série » accessible via l’IDE Arduino. Ainsi, on pourra visualiser les données retournées par le DHT22, et leur évolution.

Physiquement, il s’agit exactement du même montage que celui présenté dans l’exemple précédent (voir un peu plus haut). En fait, rien ne change au niveau matériel, car tous les changements s’opèrent au niveau logiciel.

Par ailleurs, comme nous allons utiliser le « Traceur série » de l’IDE Arduino, et non le « Moniteur série » cette fois-ci, il va falloir adapter notre programme précédent, pour qu’il retourne un format adéquat, et interprétable par le « traceur série ». En fait, rien de plus simple, là encore ! Car il suffit simplement d’envoyer l’ensemble des valeurs avec un simple « println », et de séparer chacune d’elle d’une virgule (sans rajouter le moindre texte avec ; que des valeurs numériques, donc).

Au final, voici le code de programmation que j’ai réalisé, de mon côté, pour arriver au résultat escompté :

/*
   ______               _                  _///_ _           _                   _
  /   _  \             (_)                |  ___| |         | |                 (_)
  |  [_|  |__  ___  ___ _  ___  _ __      | |__ | | ___  ___| |_ _ __ ___  _ __  _  ___  _   _  ___
  |   ___/ _ \| __|| __| |/ _ \| '_ \_____|  __|| |/ _ \/  _|  _| '__/   \| '_ \| |/   \| | | |/ _ \
  |  |  | ( ) |__ ||__ | | ( ) | | | |____| |__ | |  __/| (_| |_| | | (_) | | | | | (_) | |_| |  __/
  \__|   \__,_|___||___|_|\___/|_| [_|    \____/|_|\___|\____\__\_|  \___/|_| |_|_|\__  |\__,_|\___|
                                                                                      | |
                                                                                      \_|
  Fichier :       DHT22surTraceurSerie.ino
  
  Description :   Programme permettant de tracer graphiquement, sur le traceur série de l'IDE Arduino, l'évolution de
                  la température et taux d'humidité, mesurés par notre DHT22, branché sur la pin D6 de notre Arduino Uno

  Auteur :        Jérôme TOMSKI (https://passionelectronique.fr/)
  Créé le :       06.06.2021

  Librairie utilisée : DHT sensor library (https://github.com/adafruit/DHT-sensor-library)

*/

#include <DHT.h>
#define brocheDeBranchementDHT 6    // La ligne de données de notre DHT22 sera branchée sur la pin D6 de notre Arduino
#define typeDeDHT DHT22             // Spécification du type de DHT utilisé (ici, ce sera un DHT22, comme indiqué)

// Instanciation de la librairie DHT
DHT dht(brocheDeBranchementDHT, typeDeDHT);


// ========================
// Initialisation programme
// ========================
void setup () {
  
  // Initialisation de la liaison série (pour retourner les infos au traceur série de l'ordi)
  Serial.begin(9600);

  // Initialisation du DHT22;
  dht.begin();

  // Transmission de valeurs à 0 au traceur série, pour avoir un graphique partant de 0 sur l'axe vertical
  Serial.println("0,0");
  delay(2000);
}
 
// =================
// Boucle principale
// =================
void loop () {
  
  // Lecture des données
  float tauxHumidite = dht.readHumidity();              // Lecture du taux d'humidité (en %)
  float temperatureEnCelsius = dht.readTemperature();   // Lecture de la température, exprimée en degrés Celsius

  // Vérification des données
  if (isnan(tauxHumidite) || isnan(temperatureEnCelsius)) {
    delay(2000);
    return;         // Si aucune valeur n'a été reçue par l'Arduino, on attend 2 secondes, puis on redémarre la fonction loop()
  }
  
  // Transmission des valeurs
  Serial.print(tauxHumidite);
  Serial.print(",");
  Serial.print(temperatureEnCelsius);
  Serial.println();

  // Temporisation de 2 secondes, avant nouvelle mesure (pour respect des directives du fabricant)
  delay(2000);
}

Particularité ici : il va falloir lancer le « traceur série » de votre IDE arduino. Mais à noter qu’il n’y a pas « d’icône raccourcis » pour le lancer. Il faudra donc aller le chercher manuellement, via les menus de l’IDE Arduino. Vous le trouverez dans le menu « Outils », puis en cliquant sur « Traceur série ». Vous pouvez également le lancer en tapant sur les touches « Ctrl + Maj + L » simultanément, si vous êtes fan des raccourcis clavier ! Une fois fait, vous devriez voir apparaître un graphique à l’écran. De mon côté, voici ce que ça m’a affiché (il faisait environ 24 °C lors de mes essais) :

Sympa, non ? Bien sûr, libre à vous d’espacer les mesures comme bon vous semble, afin de faire un suivi plus ou moins espacé de la température et de l’hygrométrie chez vous ! Du reste, je trouve que l’affichage sur le Traceur Série de l’IDE arduino est vraiment sympa, du fait qu’il permet de faire un affichage clair et très visuel, des valeurs qui évoluent dans le temps ! Par contre, j’avoue que la précision à l’écran n’est pas géniale, car les graduations ne sont pas adaptées aux valeurs. Dommage !

Module	Description	Lien
	Module DHT22 monté sur PCB (avec fils de raccordement dupont)	Voir le prix

Tutorial DHT22 arduino : conclusion !

Maintenant, à vous de vous approprier ces codes, et de les adapter à vos besoins ! Par contre : n’oubliez jamais qu’on ne peut aller plus vite qu’une lecture toutes les 2 secondes, avec un DHT22.

Voilà qui clôt ce tuto ! Pour ma part, je vous proposerai prochainement un article, qui vous montrera comment stocker des valeurs issues du DHT22 dans une carte SD. Ainsi, vous verrez une manière à la fois utile et pratique, de faire un suivi à long terme des températures et hygrométries ambiantes. Et ce sera d’autant plus intéressant que nous pourrons exploiter ces valeurs sous Excel, pour en sortir de beaux graphiques 😉

Alors à très vite !

Jérôme.

À découvrir aussi : l’ensemble des tutoriels réalisés sur ce site !

JEROME

Passionné par tout ce qui touche à l'électronique, sans toutefois en être expert, j'ai à coeur de vous partager ici, peu à peu, tout ce que j'ai appris, découvert, réalisé, et testé jusqu'à présent ! En espérant que tout cela puisse vous servir, ainsi qu'au plus grand nombre !

(*) Mis à jour le 18/01/2024