.. note:: 

    Ciao, benvenuto nella Community di appassionati SunFounder Raspberry Pi & Arduino & ESP32 su Facebook! Approfondisci le tue conoscenze su Raspberry Pi, Arduino e ESP32 insieme ad altri appassionati.

    **Perché Unirsi?**

    - **Supporto Esperto**: Risolvi problematiche post-vendita e sfide tecniche grazie all’aiuto della nostra comunità e del nostro team.
    - **Impara e Condividi**: Scambia suggerimenti e tutorial per migliorare le tue competenze.
    - **Anteprime Esclusive**: Accedi in anteprima agli annunci di nuovi prodotti.
    - **Sconti Speciali**: Approfitta di sconti esclusivi sui nostri prodotti più recenti.
    - **Promozioni Festive e Giveaway**: Partecipa a omaggi e promozioni festive.

    👉 Pronto a esplorare e creare con noi? Clicca [|link_sf_facebook|] e unisciti subito!

2.2.3 DHT-11
=============

Introduzione
-------------

Il sensore digitale di temperatura e umidità DHT11 è un sensore composito che 
fornisce un'uscita digitale calibrata per temperatura e umidità. Grazie all'uso 
di moduli digitali dedicati alla raccolta dei dati e alla tecnologia di 
rilevamento della temperatura e dell'umidità, questo sensore garantisce elevata 
affidabilità e ottima stabilità.

Il DHT11 integra un sensore di umidità resistivo e un sensore di temperatura NTC, 
connessi a un microcontrollore a 8 bit ad alte prestazioni.

Componenti
-------------

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


Principio
------------

Il DHT11 è un sensore digitale di base, ultra economico, per rilevare 
temperatura e umidità. Utilizza un sensore capacitivo per l’umidità e 
un termistore per misurare l’aria circostante, generando un segnale 
digitale sul pin dati (non sono necessari pin di ingresso analogici).

.. image:: img/image205.png
    :width: 200

Il sensore dispone solo di tre pin: VCC, GND e DATA. La comunicazione inizia 
quando la linea DATA invia segnali di avvio al DHT11, che li riceve e risponde 
con un segnale di conferma. Successivamente, l'host riceve questo segnale e 
inizia a raccogliere 40 bit di dati relativi all'umidità e alla temperatura 
(8 bit per l'umidità intera + 8 bit per il decimale dell'umidità + 8 bit per 
la temperatura intera + 8 bit per il decimale della temperatura + 8 bit per il 
checksum). Per ulteriori informazioni, consulta il datasheet del DHT11.



Schema Circuitale
---------------------

.. image:: img/image326.png


Procedura Sperimentale
-------------------------

**Passo 1:** Costruisci il circuito.

.. image:: img/image207.png
    :width: 800



Per Utenti Linguaggio C
^^^^^^^^^^^^^^^^^^^^^^^^^

**Passo 2:** Vai alla cartella del codice.

.. raw:: html

   <run></run>

.. code-block::

    cd ~/davinci-kit-for-raspberry-pi/c/2.2.3/

**Passo 3:** Compila il codice.

.. raw:: html

   <run></run>

.. code-block::

    gcc 2.2.3_DHT.c -lwiringPi

**Passo 4:** Esegui il file eseguibile.

.. raw:: html

   <run></run>

.. code-block::

    sudo ./a.out

Dopo aver eseguito il codice, il programma stamperà sullo schermo la 
temperatura e l'umidità rilevate dal DHT11.

.. note::

    Se il programma non funziona o viene visualizzato un messaggio di errore: \"wiringPi.h: No such file or directory", consulta :ref:`faq_c_nowork`.

**Codice**

.. 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;
    }


**Spiegazione del Codice**

#. Includere Intestazioni: Il codice include le intestazioni necessarie per le funzioni wiringPi e input/output standard.

   .. code-block:: C

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

#. Definire Costanti:

   * ``MAXTIMINGS``: Il numero massimo di transizioni di temporizzazione attese dal sensore DHT11 (85).
   
   .. code-block:: C

        #define MAXTIMINGS 85  // Numero massimo di transizioni di temporizzazione

#. Array Globale di Dati:

   * ``dht11_dat[5]``: Un array per contenere i 5 byte di dati ricevuti dal sensore DHT11.
   
   .. code-block:: C

        int dht11_dat[5] = {0, 0, 0, 0, 0};  // Array per contenere i valori del sensore

#. Funzione ``read_dht11_dat(int GPIOPIN)``: Legge i dati dal sensore DHT11 collegato al pin GPIO specificato.
   
   * Inizializzazione: Reimposta l'array ``dht11_dat`` a zero prima di ogni lettura.
   
     .. code-block:: C

        dht11_dat[0] = dht11_dat[1] = dht11_dat[2] = dht11_dat[3] = dht11_dat[4] = 0;

   * Segnale di Avvio: Imposta il pin GPIO a livello basso per almeno 18 millisecondi per segnalare al DHT11 di iniziare a inviare dati.
   
     .. code-block:: C

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

   * Imposta il pin GPIO a livello alto per 40 microsecondi.
   
     .. code-block:: C

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

   * Imposta il pin GPIO in modalità input per leggere i dati dal sensore.
   
     .. code-block:: C

        pinMode(GPIOPIN, INPUT);

   * Ciclo di Lettura dei Dati: Il ciclo viene eseguito fino a ``MAXTIMINGS`` volte per leggere i bit dei dati.

     Ad ogni transizione (da alto a basso o da basso ad alto), misura per quanto tempo il pin rimane in ciascuno stato.

     .. 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);
            // ... resto del ciclo
        }

   * Estrazione dei Bit di Dati: Le prime 3 transizioni vengono ignorate in quanto fanno parte della risposta iniziale del DHT11.

     Per ogni bit di dati, determina se il bit è 0 o 1 in base alla durata di permanenza del pin in stato alto.

     .. code-block:: C

        if ((i >= 4) && (i % 2 == 0)) 
        {
            dht11_dat[j/8] <<= 1;
            if (counter > 16)
            {
                dht11_dat[j/8] |= 1;
            }
            j++;
        }

   * Verifica del Checksum: Dopo aver ricevuto tutti i bit, il codice verifica il checksum per garantire l'integrità dei dati.
   
     .. code-block:: C

        if ((j >= 40) && (dht11_dat[4] == ((dht11_dat[0] + dht11_dat[1] + dht11_dat[2] + dht11_dat[3]) & 0xFF)) )

   * Se il checksum è corretto, stampa i valori di umidità e temperatura.
   
     .. code-block:: C

        f = dht11_dat[2] * 9.0 / 5.0 + 32;
        printf("Umidità = %d.%d %% Temperatura = %d.%d °C (%.1f °F)\n",
               dht11_dat[0], dht11_dat[1], dht11_dat[2], dht11_dat[3], f);

   * Se il checksum non è corretto, stampa un messaggio di errore.
   
     .. code-block:: C

        else
        {
            printf("Dati non validi, salto\n");
        }

#. Funzione Principale:

   * Stampa un messaggio di avvio.

   .. code-block:: C

        printf("Programma di test temperatura DHT11 per Raspberry Pi con wiringPi\n");

   * Inizializza wiringPi utilizzando la numerazione dei pin GPIO BCM.
   
   .. code-block:: C

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

   * Entra in un ciclo infinito per leggere i dati dal sensore DHT11 ogni secondo.
     
     .. code-block:: C

        while(1) 
        {
            read_dht11_dat(17);
            delay(1000); // attende 1 secondo
        }

Per Utenti Python
^^^^^^^^^^^^^^^^^^^^

**Passo 2:** Vai alla cartella del codice.

.. raw:: html

   <run></run>

.. code-block::

    cd ~/davinci-kit-for-raspberry-pi/python/

**Passo 3:** Esegui il file eseguibile.

.. raw:: html

   <run></run>

.. code-block::

    sudo python3 2.2.3_DHT.py

Dopo l'esecuzione del codice, il programma stamperà a schermo la temperatura 
e l'umidità rilevate dal DHT11.

**Codice**

.. note::

    Puoi **Modificare/Reimpostare/Copiare/Eseguire/Fermare** il codice qui sotto. Ma prima, assicurati di accedere al percorso del codice sorgente, ad esempio ``davinci-kit-for-raspberry-pi/python``.
    
.. raw:: html

    <run></run>

.. code-block:: python

   from gpiozero import OutputDevice, InputDevice
   import time


   class DHT11():
      MAX_DELAY_COUNT = 100
      BIT_1_DELAY_COUNT = 10
      BITS_LEN = 40

      def __init__(self, pin, pull_up=False):
         self._pin = pin
         self._pull_up = pull_up


      def read_data(self):
         bit_count = 0
         delay_count = 0
         bits = ""

         # -------------- invio inizio --------------
         gpio = OutputDevice(self._pin)
         gpio.off()
         time.sleep(0.02)

         gpio.close()
         gpio = InputDevice(self._pin, pull_up=self._pull_up)

         # -------------- attesa risposta --------------
         while gpio.value == 1:
               pass
         
         # -------------- lettura dati --------------
         while bit_count < self.BITS_LEN:
               while gpio.value == 0:
                  pass

               # st = time.time()
               while gpio.value == 1:
                  delay_count += 1
                  if delay_count > self.MAX_DELAY_COUNT:
                     break
               if delay_count > self.BIT_1_DELAY_COUNT:
                  bits += "1"
               else:
                  bits += "0"

               delay_count = 0
               bit_count += 1

         # -------------- verifica --------------
         humidity_integer = int(bits[0:8], 2)
         humidity_decimal = int(bits[8:16], 2)
         temperature_integer = int(bits[16:24], 2)
         temperature_decimal = int(bits[24:32], 2)
         check_sum = int(bits[32:40], 2)

         _sum = humidity_integer + humidity_decimal + temperature_integer + temperature_decimal

         # print(bits)
         # print(humidity_integer, humidity_decimal, temperature_integer, temperature_decimal)
         # print(f'sum:{_sum}, check_sum:{check_sum}')
         # print()

         if check_sum != _sum:
               humidity = 0.0
               temperature = 0.0
         else:
               humidity = float(f'{humidity_integer}.{humidity_decimal}')
               temperature = float(f'{temperature_integer}.{temperature_decimal}')

         # -------------- ritorno dati --------------
         return humidity, temperature


   if __name__ == '__main__':
      dht11 = DHT11(17)
      while True:
         humidity, temperature = dht11.read_data()
         print(f"{time.time():.3f}  temperature:{temperature}°C  humidity: {humidity}%")
         time.sleep(2)

**Spiegazione del Codice**

.. code-block:: python

   def read_data(self):
      bit_count = 0
      delay_count = 0
      bits = ""

      # -------------- invio inizio --------------
      gpio = OutputDevice(self._pin)
      gpio.off()
      time.sleep(0.02)

      gpio.close()
      gpio = InputDevice(self._pin, pull_up=self._pull_up)
      #...

Questa funzione implementa le funzioni del DHT11. Memorizza i dati rilevati 
nell'array bits[]. Il DHT11 trasmette dati a 40 bit alla volta. I primi 16 bit 
sono relativi all'umidità, i successivi 16 bit alla temperatura e gli ultimi 
otto bit vengono utilizzati per la verifica. Il formato dei dati è:

**8bit dati interi umidità** +\ **8bit dati decimali umidità**
+\ **8bit dati interi temperatura** + **8bit dati decimali temperatura**
+ **8bit bit di controllo**.

Quando la validità viene verificata tramite il bit di controllo, la 
funzione restituisce due risultati: 1. errore; 2. umidità e temperatura.

.. code-block:: python

   _sum = humidity_integer + humidity_decimal + temperature_integer + temperature_decimal

   if check_sum != _sum:
         humidity = 0.0
         temperature = 0.0
   else:
         humidity = float(f'{humidity_integer}.{humidity_decimal}')
         temperature = float(f'{temperature_integer}.{temperature_decimal}')

Ad esempio, se i dati ricevuti sono 00101011 (valore a 8 bit dell'umidità intera)
 00000000 (valore a 8 bit dell'umidità decimale) 00111100 (valore a 8 bit della 
 temperatura intera) 00000000 (valore a 8 bit della temperatura decimale) 01100111 
 (bit di controllo)

**Calcolo:**

00101011+00000000+00111100+00000000=01100111.

Se il risultato finale è diverso dal bit di controllo, la trasmissione dei dati 
è anomala: ritorna errore.

Se il risultato finale è uguale al bit di controllo, i dati ricevuti sono corretti 
e verranno restituite "umidità" e "temperatura" e stampato "Umidità =43%, Temperatura =60C".


Immagine del Fenomeno
-----------------------

.. image:: img/image209.jpeg