Note

Bonjour et bienvenue dans la Communauté Facebook des passionnés de Raspberry Pi, Arduino et ESP32 de SunFounder ! Plongez plus profondément dans l’univers des Raspberry Pi, Arduino et ESP32 avec d’autres passionnés.

Pourquoi rejoindre ?

Support d’experts : Résolvez les problèmes après-vente et les défis techniques avec l’aide de notre communauté et de notre équipe.
Apprendre et partager : Échangez des astuces et des tutoriels pour améliorer vos compétences.
Aperçus exclusifs : Accédez en avant-première aux annonces de nouveaux produits et aux aperçus.
Réductions spéciales : Profitez de réductions exclusives sur nos produits les plus récents.
Promotions festives et cadeaux : Participez à des cadeaux et des promotions de vacances.

👉 Prêt à explorer et à créer avec nous ? Cliquez [Ici] et rejoignez-nous aujourd’hui !

2.2.3 DHT-11

Introduction

Le capteur numérique de température et d’humidité DHT11 est un capteur composite qui contient un signal numérique calibré de température et d’humidité. La technologie

de collecte de modules numériques dédiés et la technologie de détection de température
et d’humidité sont appliquées pour garantir une haute fiabilité et une excellente stabilité du produit.

Les capteurs comprennent un capteur résistif d’humidité et un capteur de température: NTC, tous deux connectés à un microcontrôleur performant de 8 bits.

Required Components

Dans ce projet, nous avons besoin des composants suivants.

Il est vraiment pratique d’acheter un kit complet, voici le lien :

Nom	ARTICLES DANS CE KIT	LIEN
Kit Raphael	337	Raphael Kit

Vous pouvez également les acheter séparément via les liens ci-dessous.

INTRODUCTION DU COMPOSANT	LIEN D’ACHAT
Carte d’extension GPIO	ACHETER
Plaque d’expérimentation (Breadboard)	ACHETER
Fils de Liaison	ACHETER
Résistance	ACHETER
Module Capteur d’Humidité et de Température	ACHETER

Schematic Diagram

Experimental Procedures

Étape 1: Construire le circuit.

Étape 2: Aller dans le dossier du code.

cd ~/raphael-kit/c/2.2.3/

Étape 3: Compiler le code.

gcc 2.2.3_DHT.c -lwiringPi

Étape 4: Exécuter le fichier exécutable.

sudo ./a.out

Après l’exécution du code, le programme affichera la température et l’humidité détectées: par le DHT11 sur l’écran de l’ordinateur.

Note

Si cela ne fonctionne pas après l’exécution ou s’il y a une erreur indiquant : « wiringPi.h : Aucun fichier ou dossier de ce type », veuillez vous référer à Installer et vérifier WiringPi.

Code

#include <wiringPi.h>
#include <stdio.h>
#include <stdlib.h>
#include <stdint.h>

#define MAXTIMINGS 85  // Maximum number of timing transitions

int dht11_dat[5] = {0, 0, 0, 0, 0};  // Data array to hold sensor values

// Function to read data from DHT11 sensor
void read_dht11_dat(int GPIOPIN)
{
    uint8_t currState;
    uint8_t laststate = HIGH;
    uint8_t counter = 0;
    uint8_t j = 0;
    uint8_t i;
    float f; // Temperature in Fahrenheit

    // Reset data array before each read
    dht11_dat[0] = dht11_dat[1] = dht11_dat[2] = dht11_dat[3] = dht11_dat[4] = 0;

    // Pull pin down for 18 milliseconds to initiate communication
    pinMode(GPIOPIN, OUTPUT);
    digitalWrite(GPIOPIN, LOW);
    delay(18);

    // Then pull it up for 40 microseconds
    digitalWrite(GPIOPIN, HIGH);
    delayMicroseconds(40);

    // Prepare to read the pin
    pinMode(GPIOPIN, INPUT);

    // Detect change and read data
    for (i = 0; i < MAXTIMINGS; i++)
    {
        counter = 0;

        // Count how long each state lasts
        while (digitalRead(GPIOPIN) == laststate)
        {
            counter++;
            delayMicroseconds(2);
            if (counter == 255)
            {
                break;
            }
        }

        // Save the current state
        laststate = digitalRead(GPIOPIN);

        if (counter == 255) break;

        // Ignore first 3 transitions (DHT11 response signal)
        if ((i >= 4) && (i % 2 == 0))
        {
            // Shift bits and store data
            dht11_dat[j/8] <<= 1;
            if (counter > 16)
            {
                dht11_dat[j/8] |= 1;
            }

            j++;
        }
    }

    // Check if we received 40 bits (5 bytes) and verify checksum
    if ((j >= 40) && (dht11_dat[4] == ((dht11_dat[0] + dht11_dat[1] + dht11_dat[2] + dht11_dat[3]) & 0xFF)) )
    {
        // Convert temperature to Fahrenheit
        f = dht11_dat[2] * 9.0 / 5.0 + 32;
        printf("Humidity = %d.%d %% Temperature = %d.%d °C (%.1f °F)\n",
               dht11_dat[0], dht11_dat[1], dht11_dat[2], dht11_dat[3], f);
    }
    else
    {
        printf("Data not good, skip\n");
    }
}

int main (void)
{
    printf("Raspberry Pi wiringPi DHT11 Temperature test program\n");

    // Initialize wiringPi using BCM GPIO pin numbering
    if (wiringPiSetupGpio() == -1)
    {
        exit(1);
    }

    while(1)
    {
        // Read data from DHT11 connected to GPIO pin 17
        read_dht11_dat(17);
        delay(1000); // Wait 1 second before next read
    }

    return 0;
}

Explication du code

Inclure les en-têtes : Le code inclut les en-têtes nécessaires pour les fonctions wiringPi et l’entrée/sortie standard.
```
#include <wiringPi.h>
#include <stdio.h>
#include <stdlib.h>
#include <stdint.h>
```
Définir les constantes :
- MAXTIMINGS : Le nombre maximum de transitions de temps attendu du capteur DHT11 (85).
```
#define MAXTIMINGS 85  // Nombre maximum de transitions de temps
```
Tableau de données global :
- dht11_dat[5] : Un tableau pour stocker les 5 octets de données reçus du capteur DHT11.
```
int dht11_dat[5] = {0, 0, 0, 0, 0};  // Tableau de données pour stocker les valeurs du capteur
```
Fonction read_dht11_dat(int GPIOPIN) : Lit les données du capteur DHT11 connecté à la broche GPIO spécifiée.
- Initialisation : Réinitialise le tableau dht11_dat à zéro avant chaque lecture.
```
dht11_dat[0] = dht11_dat[1] = dht11_dat[2] = dht11_dat[3] = dht11_dat[4] = 0;
```
- Signal de démarrage : Met la broche GPIO à bas pendant au moins 18 millisecondes pour signaler au DHT11 de commencer à envoyer des données.
```
pinMode(GPIOPIN, OUTPUT);
digitalWrite(GPIOPIN, LOW);
delay(18);  // 18 millisecondes
```
- Met la broche GPIO à haut pendant 40 microsecondes.
```
digitalWrite(GPIOPIN, HIGH);
delayMicroseconds(40);  // 40 microsecondes
```
- Configure la broche GPIO en mode entrée pour lire les données du capteur.
```
pinMode(GPIOPIN, INPUT);
```
- Boucle de lecture des données : La boucle s’exécute jusqu’à MAXTIMINGS fois pour lire les bits de données.
  
  Pour chaque transition (de haut à bas ou de bas à haut), elle mesure combien de temps la broche reste dans chaque état.
```
for (i = 0; i < MAXTIMINGS; i++)
{
    counter = 0;
    while (digitalRead(GPIOPIN) == laststate)
    {
        counter++;
        delayMicroseconds(2);
        if (counter == 255)
        {
            break;
        }
    }
    laststate = digitalRead(GPIOPIN);
    // ... reste de la boucle
}
```
- Extraction de bits de données : Les 3 premières transitions sont ignorées car elles font partie de la réponse initiale du DHT11.
  
  Pour chaque bit de données, elle détermine si le bit est 0 ou 1 en fonction de la durée pendant laquelle la broche reste à haut.
```
if ((i >= 4) && (i % 2 == 0))
{
    dht11_dat[j/8] <<= 1;
    if (counter > 16)
    {
        dht11_dat[j/8] |= 1;
    }
    j++;
}
```
- Vérification de la somme de contrôle : Après avoir reçu tous les bits, le code vérifie la somme de contrôle pour garantir l’intégrité des données.
```
if ((j >= 40) && (dht11_dat[4] == ((dht11_dat[0] + dht11_dat[1] + dht11_dat[2] + dht11_dat[3]) & 0xFF)) )
```
- Si la somme de contrôle est correcte, elle affiche les valeurs d’humidité et de température.
```
f = dht11_dat[2] * 9.0 / 5.0 + 32;
printf("Humidité = %d.%d %% Température = %d.%d °C (%.1f °F)\n",
       dht11_dat[0], dht11_dat[1], dht11_dat[2], dht11_dat[3], f);
```
- Si la somme de contrôle échoue, elle affiche un message d’erreur.
```
else
{
    printf("Données incorrectes, saut\n");
}
```

Fonction principale :

Affiche un message de démarrage.

printf("Programme de test de température DHT11 pour Raspberry Pi avec wiringPi\n");

Initialise wiringPi en utilisant la numérotation des broches GPIO BCM.

if (wiringPiSetupGpio() == -1)
{
    exit(1);
}

Entre dans une boucle infinie pour lire les données du capteur DHT11 chaque seconde.

while(1)
{
    read_dht11_dat(17);
    delay(1000); // attendre 1 seconde
}