.. 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 [|link_sf_facebook|] et rejoignez-nous aujourd'hui !

.. _2.2.3_c_pi5:

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. 

.. image:: ../img/list_2.2.3_dht-11.png

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

.. list-table::
    :widths: 20 20 20
    :header-rows: 1

    *   - Nom
        - ARTICLES DANS CE KIT
        - LIEN
    *   - Kit Raphael
        - 337
        - |link_Raphael_kit|

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

.. list-table::
    :widths: 30 20
    :header-rows: 1

    *   - INTRODUCTION DU COMPOSANT
        - LIEN D'ACHAT

    *   - :ref:`cpn_gpio_extension_board`
        - |link_gpio_board_buy|
    *   - :ref:`cpn_breadboard`
        - |link_breadboard_buy|
    *   - :ref:`cpn_wires`
        - |link_wires_buy|
    *   - :ref:`cpn_resistor`
        - |link_resistor_buy|
    *   - :ref:`cpn_humiture_sensor`
        - |link_humiture_buy|

Schematic Diagram
--------------------

.. image:: ../img/image326.png

Experimental Procedures
--------------------------

**Étape 1:** Construire le circuit.

.. image:: ../img/image207.png

**Étape 2:** Aller dans le dossier du code.

.. raw:: html

   <run></run>

.. code-block::

    cd ~/raphael-kit/c/2.2.3/

**Étape 3:** Compiler le code.

.. raw:: html

   <run></run>

.. code-block::

    gcc 2.2.3_DHT.c -lwiringPi

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

.. raw:: html

   <run></run>

.. code-block::

    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 à :ref:`install_wiringpi_pi5`.

**Code**

.. code-block:: c

    #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.

   .. code-block:: c

        #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).
   
   .. code-block:: C

        #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.
   
   .. code-block:: C

        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.
   
     .. code-block:: C

        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.
   
     .. code-block:: C

        pinMode(GPIOPIN, OUTPUT);
        digitalWrite(GPIOPIN, LOW);
        delay(18);  // 18 millisecondes

   * Met la broche GPIO à haut pendant 40 microsecondes.
   
     .. code-block:: C

        digitalWrite(GPIOPIN, HIGH);
        delayMicroseconds(40);  // 40 microsecondes

   * Configure la broche GPIO en mode entrée pour lire les données du capteur.
   
     .. code-block:: C

        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.

     .. code-block:: C

        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.

     .. code-block:: C

        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.
   
     .. code-block:: C

        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.
   
     .. code-block:: C

        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.
   
     .. code-block:: C

        else
        {
            printf("Données incorrectes, saut\n");
        }

#. Fonction principale :

   * Affiche un message de démarrage.

   .. code-block:: C

        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.
   
   .. code-block:: C

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

   * Entre dans une boucle infinie pour lire les données du capteur DHT11 chaque seconde.
     
     .. code-block:: C

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

Image du phénomène
-----------------------

.. image:: ../img/image209.jpeg