// Definizione del pin al quale è collegato il sensore DHT22

#define DHT_PIN 4

void setup() {

// Inizializzazione della comunicazione seriale a 9600 bps

Serial.begin(9600);

}

void loop() {

// Dichiarazione delle variabili per temperatura e umidità

float temperatura, umidita;

// Legge dati dal sensore DHT22

leggiDatiDHT22(temperatura, umidita);

// Visualizza i dati sulla porta seriale

Serial.print("Temperatura: ");

Serial.print(temperatura);

Serial.print("°C, Umidità: ");

Serial.print(umidita);

Serial.println("%");

// Ritardo di 2 secondi prima di effettuare una nuova lettura

delay(2000);

}

// Funzione per leggere i dati dal sensore DHT22

void leggiDatiDHT22(float &temperatura, float &umidita) {

// Array per memorizzare i dati ricevuti dal sensore

byte dati[5];

// Trasmissione del segnale di start al sensore

trasmettiSegnale();

// Attesa della risposta del sensore (LOW)

attesaRisposta();

// Attesa dell'inizio della trasmissione dei dati (HIGH)

attesaTrasmissione();

// Lettura di 5 byte di dati dal sensore

for (int i = 0; i < 5; i++) {

dati[i] = leggiByte();

}

// Calcolo della temperatura e dell'umidità dai dati letti

temperatura = combinaByte(dati[2], dati[3]) / 10.0;

umidita = combinaByte(dati[0], dati[1]) / 10.0;

}

// Funzione per trasmettere il segnale di start al sensore

void trasmettiSegnale() {

// Configura il pin del sensore come OUTPUT e invia il segnale di start

pinMode(DHT_PIN, OUTPUT);

digitalWrite(DHT_PIN, LOW);

delay(18);

digitalWrite(DHT_PIN, HIGH);

delayMicroseconds(40);

}

// Funzione per attendere la risposta del sensore (LOW)

void attesaRisposta() {

// Configura il pin del sensore come INPUT e attende che il sensore risponda (LOW)

pinMode(DHT_PIN, INPUT);

while (digitalRead(DHT_PIN) == LOW);

}

// Funzione per attendere l'inizio della trasmissione dei dati (HIGH)

void attesaTrasmissione() {

// Attende che il sensore inizi a trasmettere i dati (HIGH)

while (digitalRead(DHT_PIN) == HIGH);

}

// Funzione per leggere un byte dalla trasmissione del sensore

byte leggiByte() {

// Variabile per memorizzare il byte letto

byte valore = 0;

// Loop per leggere ciascun bit del byte

for (int i = 0; i < 8; i++) {

// Attesa dell'inizio di un bit (LOW)

while (digitalRead(DHT_PIN) == LOW);

// Misurazione della durata dell'impulso (HIGH)

valore |= (durataAlto() > 50) << (7 - i);

}

// Restituzione del byte letto

return valore;

}

// Funzione per calcolare la durata dell'impulso

unsigned long durataAlto() {

// Dichiarazione della variabile per memorizzare il tempo di inizio dell'impulso

unsigned long inizioTempo = micros();

// Attende che l'impulso diventi LOW

while (digitalRead(DHT_PIN) == HIGH);

// Restituzione della differenza tra il tempo attuale e l'inizio dell'impulso

return micros() - inizioTempo;

}

// Funzione per combinare due byte in un valore unsigned int

unsigned int combinaByte(byte MSB, byte LSB) {

// Combina i due byte in un valore unsigned int

return (MSB << 8) | LSB;

}

/* Cos'ho usato:

array: (esempio) = 'byte dati[5];'

dichiara un array di byte chiamato dati.

Ogni elemento dell'array è di tipo byte,

e l'array ha una dimensione di 5 elementi.

Questo array viene utilizzato per memorizzare

i dati letti dal sensore DHT22.

'leggiDatiDHT22(temperatura, umidita);'

E' una chiamata di funzione:

1)Parametri di ingresso: La funzione leggiDatiDHT22 accetta due

parametri di ingresso, temperatura e umidita, entrambi di tipo float

& (float passato per riferimento). Questi parametri vengono

utilizzati per restituire i valori della temperatura e dell'umidità

letti dal sensore.

2)Dichiarazione di un array: Viene dichiarato un array di byte

chiamato dati con una dimensione di 5 elementi. Questo array

verrà utilizzato per memorizzare temporaneamente i dati letti

dal sensore.

3)Chiamate a funzioni ausiliarie: Vengono chiamate tre funzioni

ausiliarie: trasmettiSegnale(), attesaRisposta(), e

attesaTrasmissione(). Queste funzioni sono utilizzate

per inizializzare la comunicazione con il sensore DHT22 seguendo il

suo protocollo.

4)Lettura dei dati: Utilizzando un ciclo for, vengono letti 5

byte di dati dal sensore DHT22 mediante la funzione leggiByte().

I byte letti sono memorizzati nell'array dati.

5) Calcolo della temperatura e dell'umidità: I dati letti

dall'array dati vengono poi utilizzati per calcolare i valori

della temperatura e dell'umidità attraverso la funzione combinaByte.

I risultati vengono divisi per 10.0 per ottenere la parte decimale

corretta.

*/