Upgrade del sistema di estrazione umidità: ottimizzazione con Arduino Nano e DHT22-AM2302 per un controllo avanzato della gestione energetica

Download here the english version in pdf

Torniamo ad occuparci di elettronica DIY in questo nuovo articolo di officinasottocasa.it e lo facciamo revisionando completamente il nostro sistema di estrazione dell’umidità che avete letto e apprezzato nel nostro precedente articolo Estrattore umidità a energia solare aggiornando l’umidostato e il sistema di gestione dell’energia utilizzando un sensore di temperatura/umidità con DHT22-AM2302 collegato ad un Arduino Nano.

Il motivo per cui abbiamo deciso di revisionare il sistema è legato al pannello solare che non riesce a fornire sufficiente energia alla batteria e a garantire quindi l’immagazzinamento dell’energia necessaria ad azionare le ventole di estrazione nei mesi più freddi e con meno luce dell’anno. Peraltro si tratta anche dei mesi più piovosi e con più problemi di umidità.

Un’alternativa all’aggiornamento dell’intero sistema poteva essere l’ampliamento del pannello fotovoltaico e della capacità dell’accumulatore ma l’attuale collocazione non ce lo permette.

Abbiamo quindi deciso di attivare, quando necessario, una fonte di ricarica supplementare utilizzando la rete elettrica domestica. Avremmo potuto semplicemente inserire un mantenitore di carica acquistato su Amazon a poche decine di euro ma non sarebbe stato in stile officinasottocasaDIY.

Componenti hardware

Iniziamo con i componenti del sistema di estrazione che, come nella precedente versione, sono i seguenti:

• Batteria al piombo 12V 7.2 Ah https://www.amazon.it/gp/product/B00FG8G9FG/ref=ppx_yo_dt_b_search_asin_title?ie=UTF8&th=1
• Regolatore di tensione per pannelli solari da 20A https://www.amazon.it/gp/product/B08LPL4LX3/ref=ppx_yo_dt_b_search_asin_title?ie=UTF8&psc=1
• Ventola 12V 2W https://www.amazon.it/gp/product/B07L2JBZFK/ref=ppx_yo_dt_b_search_asin_title?ie=UTF8&psc=1
• Pannello solare 12V 20W https://www.amazon.it/gp/product/B07FYJTBQR/ref=ppx_yo_dt_b_search_asin_title?ie=UTF8&th=1

Passiamo poi ai componenti della CPU:

• Elegoo Nano https://www.amazon.it/gp/product/B078S8BJ8T/ref=ppx_yo_dt_b_search_asin_title?ie=UTF8&th=1
• Schermo OLED SSD1306 128X64 https://www.amazon.it/gp/product/B074NJMPYJ/ref=ppx_yo_dt_b_search_asin_title?ie=UTF8&th=1
• Modulo DHT22-AM2302 https://www.amazon.it/gp/product/B07L4WCFPZ/ref=ppx_yo_dt_b_search_asin_title?ie=UTF8&th=1
• Relè SRD-05VDC-SL-C https://www.amazon.it/dp/B0745BKY36?psc=1&ref=ppx_yo2ov_dt_b_product_details
• Step down variabile con LM2596 https://www.amazon.it/gp/product/B07DP3JX2X/ref=ppx_yo_dt_b_search_asin_title?ie=UTF8&th=1

Abbiamo progettato la CPU con il designer circuitale disponibile su questo sito https://easyeda.com/it e creato la PCB con il servizio connesso https://jlcpcb.com/?href=easyeda-home. Il designer permette di creare automaticamente il file gerber della PCB e passarlo al sito per la produzione.

Schema elettrico CPU

Iniziamo con la visione d’insieme:

Per facilitare l’analisi dettagliata del diagramma e mantenere un ordine coerente, abbiamo suddiviso i componenti in specifiche zone, ognuna corrispondente alla sua funzione.

Zona A – Ingresso batteria

In questa zona abbiamo i contatti per il collegamento della batteria, il partitore di tensione e il convertitore stepdown DC-DC per l’alimentazione della scheda. Le due funzioni di questa gruppo sono le seguenti:

• Alimentare il nostro circuito attraverso uno stepdown a 5V con integrato LM2596
• Collegare la batteria al partitore di tensione per verificarne lo stato di carica e attivare la ricarica aggiuntiva tramite la rete

L’MC LM2596 è un popolare circuito integrato regolatore di tensione a commutazione. Dotato di elevate prestazioni, è ampiamente utilizzato per convertire tensioni DC, garantendo una stabilità e un’efficienza energetica ottimali. Adatto per applicazioni di alimentazione in diversi settori, offre una soluzione affidabile e compatta per il controllo della tensione. Lo utilizziamo praticamente in ogni progetto. In particolare lo avete visto in questo nostro articolo: Allarme GSM per batteria scarica – Parte 1: Hardware

Il partitore di tensione è un circuito elettronico essenziale che suddivide la tensione in un circuito in proporzione ai valori delle resistenze utilizzate. Questo componente versatile trova applicazioni comuni nella progettazione elettronica, consentendo il controllo preciso della tensione in vari contesti, dai sensori agli amplificatori. Per gli approfondimenti rimandiamo al sito di Raffaele Ilardo che trovate nei riferimenti.

In questo progetto lo utilizziamo per abbassare la tensione della batteria ad una compatibile con l’ingresso analogico della scheda Arduino. In particolare, abbiamo inserito un partitore di tensione (R1=220KΩ e R2=100KΩ) che determina una caduta di tensione dai 12V in ingresso dalla batteria (Vin) agli 3,75V (Vout) ai capi della R2.

Zona B – Gestione alimentazione supplementare

In questo gruppo abbiamo i contatti per l’alimentatore dalla rete elettrica e il relè di comando gestito dal microcontrollore.

Il relè SRD è un componente elettronico versatile che controlla l’apertura e la chiusura di circuiti elettrici. La sua affidabilità e capacità di commutazione lo rendono ideale per controllare carichi in diversi dispositivi elettronici, garantendo una gestione efficiente delle connessioni elettriche e una maggiore durata.

In questo progetto utilizziamo relè SRD con bobina primaria a 5V in quanto sono gestiti tramite le porte digitali della scheda arduino.

Noterete che, con l’utilizzo del relè, abbiamo isolato completamente il nostro circuito dal sistema di ricarica a 12V proveniente dalla rete elettrica. Il relè infatti opera sul polo positivo mentre il polo negativo ha solo due fori di montaggio per la saldatura dei fili, non essendo in comune con la terra del nostro integrato.

Zona C – Gestione pannello fotovoltaico

In questo gruppo connettiamo un solo polo del pannello fotovoltaico ad un altro relè. La funzione di questo collegamento è quella di escludere il pannello quando il sistema è alimentato dalla rete elettrica. In questo modo evitiamo sovrapposizioni e utilizziamo fonti esclusive, senza interferenze tra pannello e alimentatore.

Anche qui, il relè ci garantisce l’isolamento della corrente del pannello da quella del circuito.

Zona D – Gestione estrattori

Qui è dove gestiamo l’attivazione del carico, che sono le ventole per l’estrazione dell’aria umida verso l’esterno. La corrente per azionare le ventole arriva dal regolatore di carica che gestisce il pannello e ricarica la batteria.

Zona E – Spie di funzionamento

Abbiamo inserito tre led che funzionano da indicatori dello stato dei relè. I led, governati tramite software dal microcontrollore, ci daranno evidenza dello stato di eccitazione del relè. Lo stato di eccitazione di un relè indica se è attivato o disattivato. Quando è eccitato, il relè chiude i contatti, consentendo il passaggio di corrente. Allo spegnimento, interrompe la connessione.

Modulo DHT22-AM2302

Il modulo DHT22-AM2302 è sensore di temperatura e umidità con elevate prestazioni, noto per la sua precisione nelle misurazioni ambientali. Caratterizzato da un design compatto e interfaccia semplificata, è comunemente impiegato in progetti DIY e contesti industriali. La sua integrazione con Arduino Nano ci permette di verificare il livello di umidità nell’aria e, in base a quanto definiremo nel software, di azionare gli estrattori.

Schermo OLED 128X64

Per avere tutte le informazioni di esercizio ed eventuali alert abbiamo inserito un display OLED, un componente elettronico avanzato con una risoluzione di 128×64 pixel. Grazie alla tecnologia OLED, offre una nitidezza e un contrasto superiori, rendendolo ideale per visualizzare testo e grafici. Il controller è un SSD1306 con interfaccia I2C che lo rende ideale per questo tipo di progetti.

Arduino Nano

Veniamo ora al cuore pulsante del progetto. Il microcontrollore che ospita il software da noi creato e che governa tutti i vari componenti.

Si tratta di un Nano clone, non un vero Arduino, anche se del suo parente originale è praticamente identico in termini di piedinatura, funzionamento e programmazione.

Hanno lo stesso chip ATMEGA328P. L’unica differenza tra gli originali e i cloni è il convertitore USB-Seriale. I cloni utilizzano infatti il chip CH340G e i driver per questo Chip non sono compresi nell’installazione dell’IDE di Arduino. Motivo per cui dovranno essere installati separatamente. In questo articolo https://www.makerslab.it/installare-i-driver-per-il-modulo-ftdi-ch340g-per-i-cloni-di-arduino/ trovate le informazioni e i link per scaricare e installare i driver per il CH340G.

Del suo utilizzo ne parleremo più che altro in termini di software nel prosieguo dell’articolo.

PCB

Per realizzare la PCB siamo partiti dallo schema elettrico. Attraverso il designer online di EasyEDA, infatti, è possibile tradurre lo schema elettrico in componenti sulla PCB. La disposizione dei componenti è a nostra cura. Come si può notare, ci siamo impegnati a conservare la separazione tra i gruppi identificati nello schema elettrico per motivi più che altro estetici e di ordine.

Abbiamo acquistato una scheda in FR-4, caratterizzata da due strati e dimensioni pari a 120 per 90 millimetri, per integrarla nei nostri progetti elettronici, garantendo affidabilità e precisione nel supporto di circuiti complessi.

Per i più curiosi, il FR-4, acronimo di “Flame Retardant 4,” è un materiale composito spesso utilizzato per la fabbricazione di PCB (Printed Circuit Board). È composto da una base di vetro epossidico rinforzato con fibra di vetro, impregnato con resina epossidica a bassa infiammabilità. Questo materiale offre eccellenti proprietà dielettriche, resistenza meccanica e buona lavorabilità, rendendolo una scelta comune per la realizzazione di schede elettroniche.

Programmazione software del microcontrollore ATMEGA328P

Fino a questo momento, la nostra attenzione è stata focalizzata esclusivamente sull’aspetto hardware del sistema. Tuttavia, è il software che avrà il ruolo chiave nell’orchestrare l’intero sistema. Il corretto funzionamento, la gestione efficace e la sincronizzazione delle componenti hardware saranno guidati dal nostro software.

Perché utilizziamo la piattaforma di prototipazione Arduino (e i suoi cloni) è semplice: la programmazione Arduino offre un accesso intuitivo alla creazione di progetti elettronici personalizzati. La sintassi è semplice e c’è una vasta gamma di librerie con le quali anche i principianti possono sviluppare rapidamente dispositivi interattivi.

Premesse per la programmazione

Come sempre, dovendo gestire la ricorrenza nella funzione Loop(), utilizzeremo alcune variabili “dummy” di tipo binario (0 e 1) che ci permetteranno di controllare in modo ciclico le variabili ambientali derivanti dalla lettura dei sensori (umidità e livello di carica) ma di eseguire le operazioni in modo lineare (per capirci, senza accendere e spegnere i relè ogni 10 secondi).

Le “variabili dummy” sono generalmente utilizzate come segnaposto temporaneo o per rispettare i requisiti di sintassi senza avere una reale utilità funzionale nel contesto del codice. In pratica, vengono utilizzate solo per soddisfare la struttura richiesta dal linguaggio di programmazione senza essere coinvolte in operazioni o calcoli significativi nel programma. Il termine “dummy” indica che queste variabili sono utilizzate solo a fini temporanei o formali.

Utilizzeremo anche la funzione watchdog. Questa funzione (timer di controllo) di Arduino si riferisce al Watchdog Timer integrato nei microcontroller AVR (Advanced Virtual RISC) come quelli utilizzati nelle schede Arduino (o cloni come nel nostro caso). Questo timer è un contatore hardware che può essere programmato per generare un reset del microcontrollore se non viene “nutrito” regolarmente attraverso l’inserimento di specifiche istruzioni nel codice (riavvio del timer prima della fine del countdown impostato). Il watchdog è utilizzato in questo progetto come meccanismo di sicurezza per riavviare automaticamente il microcontrollore in caso di malfunzionamenti o blocchi del programma.

Diagramma di flusso

Anche se il programma sembrerà leggermente complesso, nella sostanza si limita a fare pochi e semplici passi:

• Verifica il livello di umidità e se il livello è superiore ad un valore soglia accende le ventole di estrazione;
• Verifica il livello di carica della batteria e se il livello è inferiore ad un valore soglia accende l’alimentazione esterna per caricare la batteria.

Vediamo il diagramma del suo funzionamento

Nella parte del controllo della carica abbiamo inserito un valore soglia superiore ed uno inferiore. In questo modo, All’interno dell’intervallo tra i due valori soglia, i relè rimangono nella posizione precedentemente impostata, per evitare fastidiosi cambi di stato continui quando i valori sono nell’intorno del valore soglia.

Librerie

Per rendere possibile la comunicazione con le varie periferiche I/O, per prima cosa carichiamo alcune librerie.

In Arduino, le librerie sono insiemi di codice predefiniti e funzioni che possono essere riutilizzate per semplificare la programmazione e l’interazione con componenti hardware specifici. Le librerie contengono implementazioni di routine comuni o complesse che possono essere richiamate nei tuoi programmi senza dover scrivere il codice da zero.

Le librerie in Arduino sono fondamentali per rendere l’ambiente di sviluppo più accessibile e per consentire agli utenti di concentrarsi sulla logica specifica del loro progetto, senza dover gestire dettagli di basso livello. Esse offrono una serie di vantaggi:

1. Riutilizzabilità del Codice: Puoi utilizzare le librerie per gestire facilmente funzionalità comuni in diversi progetti senza dover riscrivere il codice ogni volta.
2. Semplificazione del Codice: Le librerie astraggono complessità e dettagli di implementazione, semplificando il tuo codice principale.
3. Interfaccia Utente Semplificata: Le librerie spesso forniscono un’interfaccia di alto livello che semplifica l’interazione con i componenti hardware.
4. Comunità e Condivisione: La comunità di sviluppatori di Arduino contribuisce attivamente alla creazione e al miglioramento delle librerie, permettendo una condivisione rapida di soluzioni e idee.
5. Velocità di Sviluppo: L’utilizzo di librerie può accelerare il processo di sviluppo, consentendoti di concentrarti sui dettagli specifici del tuo progetto.

Ad esempio, se stai lavorando con uno schermo OLED, potresti utilizzare la libreria Adafruit_SSD1306 o U8x8 per semplificare la gestione del display. Includi la libreria nel tuo codice, e puoi chiamare le funzioni definite dalla libreria senza dover scrivere il codice di basso livello necessario per controllare lo schermo OLED.

Iniziamo a vedere il codice:

#include <avr/wdt.h> //includi libreria per utilizzo watchdog

#include <DHT.h>

#define DHTPIN 8 // Imposta il pin al quale è collegato il sensore DHT22

#define DHTTYPE DHT22 // Imposta il tipo di sensore (DHT22 o DHT11)

#include <U8x8lib.h>
// Imposta il pin di comunicazione I2C
#define OLED_SDA 4
#define OLED_SCL 5

//Inizializza lo schermo OLED128x64
U8X8_SSD1306_128X64_NONAME_SW_I2C u8x8(OLED_SCL, OLED_SDA, U8X8_PIN_NONE);

// Inizializza il sensore DHT
DHT dht(DHTPIN, DHTTYPE);

Il frammento di codice appena riportato inizia con l’inclusione delle librerie essenziali per il watchdog, il sensore DHT22 e il display OLED. Successivamente, vengono dichiarati i pin di connessione per il sensore DHT22 e il display OLED. Viene poi inizializzato uno schermo OLED128x64 e un sensore DHT22, stabilendo la comunicazione I2C necessaria per il funzionamento corretto del sistema.

Definizione delle variabili

Nel frammento di codice che trovate di seguito vengono dichiarate costanti e variabili utilizzate per il controllo di un sistema. Sono definiti pin per i relè e i LED, la tensione di riferimento, il pin per il partitore di tensione e i valori soglia per la lettura della tensione e dell’umidità. Le variabili booleane fan_state e charge_state indicano lo stato del ventilatore e della carica della batteria (acceso/spento). Vengono modificate ogni volta che si verifica una condizione che comporta un cambio di stato e ci serviranno come input per visualizzare le informazioni sul nostro schermo OLED. Questi parametri sono fondamentali per regolare il comportamento del sistema in base alle condizioni ambientali e di alimentazione.

const int REL_FAN = 7;
const int REL_CHG = 2;
const int REL_SPA = 3;

const int LED_FAN = 6;
const int LED_CHG = 4;
const int LED_SPA = 5;

const float tensioneDiRiferimento = 5.0; // Definisci la costante per la tensione di riferimento (5V per Arduino Uno)


const int pinPartitoreTensione = A0;// Definisci il pin analogico al quale è collegato il partitore di tensione

// Specifica i valori delle resistenze del partitore di tensione
const float resistenzaR1 = 220000.0;  // 220 kohm
const float resistenzaR2 = 100000.0;  // 100 kohm

// specifica le variabili valori soglia per le letture della tensione
const float batt_low_limit = 11.0;
const float batt_high_limit = 13.0;

// specifica le variabili valori soglia per le letture dell'umidità
const float hum_low_limit = 70.0;
const float hum_high_limit = 75.0;

bool fan_state = false;   // Stato del fan (acceso/spento)
bool charge_state = false; // Stato della carica della batteria (acceso/spento)

Funzione Setup()

La funzione setup() inizializza il programma Arduino. Viene impostata la modalità di output per i pin che controllano relè e LED, necessari per il controllo del sistema. Il sensore DHT viene inizializzato tramite dht.begin(), e la libreria U8x8 per il display OLED è avviata con u8x8.begin(). Infine, il watchdog timer (wdt_enable(WDTO_8S)) è attivato con un timeout di 8 secondi per monitorare il corretto funzionamento del programma.

void setup() {
  pinMode(REL_FAN, OUTPUT);
  pinMode(REL_CHG, OUTPUT);
  pinMode(REL_SPA, OUTPUT);
  pinMode(LED_FAN, OUTPUT);
  pinMode(LED_CHG, OUTPUT);
  pinMode(LED_SPA, OUTPUT);

  dht.begin();// Inizializza il sensore DHT

  u8x8.begin(); // Inizializza la libreria U8x8
  wdt_enable(WDTO_8S);
}

Funzione Loop()

La funzione loop del codice controlla ciclicamente il sistema. Dopo un periodo di attesa di 2 secondi, richiama le funzioni battery_level, humidity_level e update_screen. La prima verifica e gestisce lo stato della carica della batteria, la seconda controlla e regola l’umidità, mentre la terza aggiorna il display OLED con i valori correnti. Inoltre, resetta il timer del watchdog per evitare un reset del microcontrollore.

void loop() {
  delay(2000);

  battery_level();

  humidity_level();

  update_screen();


  wdt_reset();  // Resetta il timer del watchdog

  }

Update_screen()

La funzione update_screen legge la tensione della batteria e l’umidità dal sensore DHT22, calcola e visualizza i risultati su uno schermo OLED. Mostra la tensione con due decimali, indicando anche se la batteria si sta caricando da un pannello solare o dalla rete elettrica. Visualizza l’umidità con due decimali e segnala se le ventole di estrazione sono in funzione o spento.

void update_screen(){

  // Leggi il valore analogico dal pin A2
  int valoreLettura = analogRead(pinPartitoreTensione);

  // Calcola la tensione letta in base al partitore di tensione
  float tensioneLetta = (valoreLettura / 1023.0) * tensioneDiRiferimento * (resistenzaR1 + resistenzaR2) / resistenzaR2;

  // Leggi l'umidità
  float umidita = dht.readHumidity();
  u8x8.clearDisplay();
  u8x8.setCursor(0, 0);
  u8x8.print("Voltage: ");
  u8x8.print(tensioneLetta, 2); // Mostra la tensione con due decimali
  u8x8.print(" V");
  if (charge_state = true){
  u8x8.setCursor(0, 1);
  u8x8.print("220 charge");
  }
  else if (charge_state = false){
  u8x8.setCursor(0, 1);
  u8x8.print("Solar charge");
  }
  u8x8.setCursor(0, 2);
  u8x8.print("Humidity: ");
  u8x8.print(umidita, 2); // Mostra l'umidità con due decimali
  u8x8.print(" %");
  if (fan_state = true){
  u8x8.setCursor(0, 3);
  u8x8.print("fan running");
  }
  else if (charge_state = false){
  u8x8.setCursor(0, 3);
  u8x8.print("fan off");
  }
  u8x8.display();

}

battery_level()

La funzione battery_level misura la tensione di una batteria attraverso un partitore di tensione e verifica se è al di fuori delle soglie specificate. Se la tensione è inferiore alla soglia minima, attiva il relè e il LED della carica da rete elettrica, spegne il relè e il LED della carica solare. Se la tensione supera la soglia massima, inverte le operazioni. La funzione tiene traccia dello stato della carica con una variabile booleana.

void battery_level(){

// Leggi il valore analogico dal pin A2
  int valoreLettura = analogRead(pinPartitoreTensione);

  // Calcola la tensione letta in base al partitore di tensione
  float tensioneLetta = (valoreLettura / 1023.0) * tensioneDiRiferimento * (resistenzaR1 + resistenzaR2) / resistenzaR2;

  if (tensioneLetta < batt_low_limit) {
    charge_state = true;
    digitalWrite(LED_CHG, HIGH);
    digitalWrite(REL_CHG, HIGH);
    delay(200);
    digitalWrite(LED_SPA, HIGH);
    digitalWrite(REL_SPA, HIGH);
  } else if (tensioneLetta > batt_high_limit) {
    charge_state = false;
    digitalWrite(LED_CHG, LOW);
    digitalWrite(REL_CHG, LOW);
    delay(200);
    digitalWrite(LED_SPA, LOW);
    digitalWrite(REL_SPA, LOW);
  }

}

humidity_level()

La funzione humidity_level legge l’umidità dal sensore DHT22 e verifica se è al di fuori delle soglie predefinite. In caso di errore nella lettura del sensore, segnala l’errore sullo schermo. Se l’umidità supera la soglia massima, accende il relè e il LED del ventilatore per l’estrazione. Se l’umidità scende al di sotto della soglia minima, spegne il relè e il LED del ventilatore. La funzione tiene traccia dello stato del ventilatore con una variabile booleana che viene utilizzata per riportare l’informazione sullo schermo led.

void humidity_level() { // Verifica l'umidità
  float umidita = dht.readHumidity();  // Leggi l'umidità
  if (isnan(umidita)) {
    // Serial.println("Errore nella lettura del sensore DHT22!");
    u8x8.setCursor(0, 3);
    u8x8.print("Hum Read ERR");
    return;
  }
  if (umidita > hum_high_limit) {  // Verifica se l'umidità è al di fuori delle soglie
    digitalWrite(LED_FAN, HIGH); // Accendi il LED per il relè fan estrazione
    digitalWrite(REL_FAN, HIGH); // Accendi il relè fan estrazione
    fan_state = true; // imposta stato variabile estrattore su ON
  } else if (umidita < hum_low_limit) {
    digitalWrite(LED_FAN, LOW); // Spegni il LED per il relè fan estrazione
    digitalWrite(REL_FAN, LOW); // Spegni il relè fan estrazione
    fan_state = false;
  }
}

E con questo è tutto per oggi. Speriamo che la lettura di questo articolo sia stata di ispirazione. Come sempre, fatecelo sapere nei commenti.

Contribuisci al progetto officinasottocasa

Se avete apprezzato questo articolo o se vi è stato d’aiuto, potete contribuire allo sviluppo del nostro progetto officinasottocasa in due modi:

• Commentate questo articolo per farci sapere cosa ne pensate
• Contribuite attivamente allo sviluppo del progetto cliccando qui (tranquilli, non vi chiediamo i dati della carta di credito!)

Riferimenti

https://www.adrirobot.it/dht22-am2302-sensore-temperatura-umidita/

https://easyeda.com/it

https://jlcpcb.com/?href=easyeda-home

http://www.raffaeleilardo.it/parti.htm

https://www.makerslab.it/installare-i-driver-per-il-modulo-ftdi-ch340g-per-i-cloni-di-arduino/