Nota

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 [Qui] 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

_images/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).

_images/image205.png

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

_images/image326.png

Procedura Sperimentale

Passo 1: Costruisci il circuito.

_images/image207.png

Per Utenti Linguaggio C

Passo 2: Vai alla cartella del codice.

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

Passo 3: Compila il codice.

gcc 2.2.3_DHT.c -lwiringPi

Passo 4: Esegui il file eseguibile.

sudo ./a.out

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

Nota

Se il programma non funziona o viene visualizzato un messaggio di errore: "wiringPi.h: No such file or directory», consulta Il codice C non funziona?.

Codice

#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

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

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

  2. Definire Costanti:

    • MAXTIMINGS: Il numero massimo di transizioni di temporizzazione attese dal sensore DHT11 (85).

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

  3. Array Globale di Dati:

    • dht11_dat[5]: Un array per contenere i 5 byte di dati ricevuti dal sensore DHT11.

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

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

      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.

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

    • Imposta il pin GPIO a livello alto per 40 microsecondi.

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

    • Imposta il pin GPIO in modalità input per leggere i dati dal sensore.

      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.

      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.

      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.

      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.

      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.

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

  5. Funzione Principale:

    • Stampa un messaggio di avvio.

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

    • Inizializza wiringPi utilizzando la numerazione dei pin GPIO BCM.

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

    • Entra in un ciclo infinito per leggere i dati dal sensore DHT11 ogni secondo.

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

Per Utenti Python

Passo 2: Vai alla cartella del codice.

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

Passo 3: Esegui il file eseguibile.

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

Nota

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.

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

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.

_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

_images/image209.jpeg