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) |
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 :
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 :
À 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) |
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) |
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) |
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 !
(*) Mis à jour le 18/01/2024
Je cherchais des infos pour monter un DHT22 nu sur un PCB, je cherchais en vain, jusqu’à trouver votre tutorial qui comprend toutes les infos ! Excellent. Merci !
Héhé, de rien ! Amuses toi bien 😉
Super !
J’adore ces tutos bien faits et complets qui me permettent de progresser.
A ce jour j’utilise des capteurs de température DS18B20, tous sur la même pin OneWire.
Je pense qu’il est possible de faire la même chose avec des DHT22, je vais m’y atteler !
Salut Loïc !
Oui, tu verras, c’est tout aussi simple à utiliser, avec les librairies Arduino !
Et si tu veux un exemple concret d’utilisation du DHT22, tu peux jeter un coup d’œil au thermomètre/hygromètre arduino que j’avais réalisé il y a peu, également.
Bon courage à toi 😉
@+
Bonjour Jérôme,
Merci pour ce tuto très clair.
J’envisage de connecter 3 capteurs DHT22 à un Arduino en déclarant 3 instances de la classe DHT.
Est-ce que tu penses que c’est possible ?
Si oui, je poursuivrai en enregistrant les données recueillies dans un fichier.
Voilà mon programme pour les jours à venir dès que j’aurai reçu les capteurs.
Salut Marc !
Oui, c’est exactement ce qu’il faut que tu fasses (3 instances de la classe DHT).
Tu pourrais par exemple écrire du code du style :
Voilà ! Amuse toi bien 😉
Jérôme.
Jérôme,
Merci de ta réponse et bravo pour tous tes autres tutos que je viens de lire.
Je suis bien décidé à suivre ton travail.
Marc
Ça marche, et bon courage à toi !
Au plaisir 😉
Bonjour,
Très bien ce tuto qui a fonctionné du premier coup sans problème. Ou presque, car la valeur d’humidité est très souvent à 100%, et il faut qu’il y ait du vent pour que la valeur retombe.
D’où ma question : comment disposer physiquement le capteur DHT22 ? y a t il des précautions (vertical, horizontal?).
Actuellement il est fixé sous un plateau en bois de 50×50 cm qui supporte une ruche, car utilisé avec une balance connectée.
Merci
Salut !
Alors, sauf erreur de ma part, le datasheet du DHT22 que j’ai partagé plus haut ne donne aucune info à ce sujet. Cela étant dit, il faut bien garder à l’esprit que l’air humide est constitué de gouttelettes d’eau, et que mettre le DHT22 à plat (à l’horizontal) peut l’amener à accumuler de l’eau en lui. C’est pourquoi, je pense que la meilleure façon de l’utiliser est de le mettre bien droit (vertical).
Cela étant dit, concernant ton taux d’humidité quasi permanent à 100%, cela ne me choque pas outre mesure, si c’est dans un espace humide et « peu ventilé ». D’ailleurs, comme tu le dis, le capteur ne semble pas dysfonctionner, du fait qu’un courant d’air extérieur permet de temporairement faire baisser l’hygrométrie. Car dans ce cas, lorsqu’il y a du vent, ce n’est plus l’hygrométrie intérieure « seule » que tu mesures, mais bien un mix de celle intérieure, et de l’autre extérieure. Donc, selon moi, les 100% sont certainement la « véritable » humidité du lieu où tu as placé ton DHT22.
Voilà !
Bon courage à toi 😉
Jérôme.
Bonjour,
J’ai tout essayé (plusieurs codes, plusieurs librairies), mais impossible de faire fonctionner le DHT22 avec mon Arduino UNO. Y a-t-il un paramètre à modifier qui n’est pas présent dans le tuto ? Je précise que j’ai un capteur monté sur PCB.
Merci !
Salut Alex !
Non, tout est bien présent dans le tuto. Par contre, dans un cas comme le tien, je :
Bon courage à toi !
Jérôme.
Bonjour Jérôme, tout d’abord merci pour ce tuto super détaillé.
Est-ce que tu as finis celui qui permettra de mettre les données sur une carte sd, ça m’intéresse beaucoup (et ça me simplifierait bien les choses !)
Bonne continuation
Salut !
Non, malheureusement, désolé…
En fait, je manque tout simplement de temps, pour faire tout ce que j’ai prévu de faire !
Encore désolé.
Jérôme.
Pas de soucis. Merci pour ta réponse, au contraire, ca va me forcer à faire un peu de recherche ^^
Afin de filtrer au maximum les messages de type "spam" ou "inappropriés", chaque commentaire est soumis à modération, et validé manuellement. Du coup, il se peut que certains commentaires ne soient pas publiés, ou sinon, avec un peu de retard. Par ailleurs, j'ai malheureusement plus de messages à traiter que de temps pour y répondre ; c'est pourquoi je ne pourrais pas répondre à tout le monde. Désolé …