Visualizza la concentrazione di CO2 e TVOC nell’aria in un ambiente chiuso, come l’aula di una scuola o un ufficio e segnala tramite LED se la qualità dell’aria è buona o scadente.
Perché monitorare la qualità dell’aria
Negli ultimi anni, sfortunatamente, la qualità dell’aria che respiriamo è diventata un problema non trascurabile. Lo è da tempo per gli ambienti indoor, specie in inverno, quando restiamo chiusi in tanti in un locale poco aerato, ma anche all’esterno, specie nelle città, la cui aria risulta sempre più contaminata dalle emissioni inquinanti degli autoveicoli, degli impianti di riscaldamento (non scordiamo che il gas naturale non è puro metano, ma contiene altri gas e gli additivi per l’odore e per colorare la fiamma…) delle fabbriche e delle centrali termoelettriche e via di seguito; e dove la scarsità di verde non favorisce l’ossigenazione dell’aria, che ha quindi un basso tenore di ossigeno e non favorisce i naturali processi dell’organismo umano e animale.
Negli ambienti indoor, la qualità dell’aria è pregiudicata da elementi come l’anidride carbonica che espiriamo, ma anche da polveri sottili ed eventuali agenti patogeni che possiamo emettere respirando o tossendo; si pensi ad esempio all’infezione da COVID 19, ormai da tempo un problema con il quale conviviamo, che ha nell’aria degli ambienti chiusi, uno dei principali veicoli di trasmissione. La diffusione di questo, come di altri virus, negli ambienti chiusi, sostanzialmente è un problema legato alla qualità dell’aria: più l’aria è “viziata”, tanto maggiore è la concentrazione di droplet (goccioline di saliva e liquidi organici provenienti dalle mucose) potenzialmente cariche di agenti patogeni, capaci di diffondere malattie. La soluzione per mitigare il contagio è ovviamente quella di operare un ricambio d’aria, per ridurre la concentrazione di questi patogeni.
Ma quando farlo, dal momento che, sia in estate che in inverno, tendiamo a tenere le finestre chiuse per ridurre i consumi di impianti di condizionamento e di riscaldamento?
Ebbene, in questo articolo vi proponiamo un semplice dispositivo che, leggendo un sensore di CO2 e TVOC (ossia la concentrazione di particelle organiche in sospensione nell’aria, nota in italia anche con l’acronimo COV – Composti Organici Volatili), ci consenta di avere un’idea della qualità dell’aria di un ambiente, e tramite dei LED, ci segnali quando è il momento di operare un ricambio, permettendoci di mantenere sotto controllo la qualità dell’aria e di minimizzare le perdite di energia.
L’hardware del progetto
Per realizzare il dispositivo che abbiamo sinora introdotto, abbiamo deciso di utilizzare un modulo Heltec WiFi kit 32 come unità di controllo, un sensore SGP30 della Sensirion come elemento rilevatore della concentrazione di anidride carbonica e TVOC e due comuni LED (uno rosso e l’altro verde) come elementi di segnalazione. Lo schema concettuale del sistema è proposto nella Fig. 1.
Modulo Heltec Wifi Kit 32
Il modulo Heltec WiFi kit 32, che in definitiva è il cuore del nostro sistema, è una piccola scheda elettronica che integra un microcontrollore ESP32 e un display OLED da 0,96 pollici; la potete vedere nella Fig.2. Le caratteristiche hardware del modulo WiFi kit 32, con cui lavoreremo in questo progetto, sono:
Display OLED blu da 0,96”;
Microcontroller Dual-Core Tensilica LX6 a 32 bit;
Frequenza di clock fino a 240 MHz;
SRAM interna da 520 kB;
Memoria flash da 32 MB;
Ricetrasmettitore Wi-Fi 802.11 b/g/n integrato;
Bluetooth dual-mode integrato (classico e BLE);
Alimentazione: da 3,3V a 7V;
28 GPIO (alcuni utilizzati per gestire il display OLED);
Caricabatteria per batterie ai polimeri di litio integrato;
Temperatura di lavoro: da -40°C a +90°C.
Questo modulo risulta perfetto per il nostro scopo, in quanto integra già un display OLED che utilizzeremo per la visualizzazione delle letture relative alla qualità dell’aria, e per i messaggi utente, oltre a diversi canali GPIO che ci servono per controllare i nostri dispositivi di segnalazione; in questa prima versione noi prevediamo di utilizzare solo 2 LED, ma il quantitativo di GPIO disponibili (28 in totale) ci permetterebbe agevolmente di aggiungere altri elementi, come ad esempio un buzzer per effettuare delle segnalazioni acustiche.
Oltre a queste caratteristiche, il modulo ha 520kbyte di memoria RAM on-board, e ben 32Mbyte di Flash, caratteristiche che ci permettono di stare tranquilli in termini di risorse di memoria per il nostro software di controllo. Inoltre il modulo monta un transceiver WiFi standard 802.11, che potremo usare per future evoluzioni di questo dispositivo (ad esempio per pubblicare i dati relativi alle concentrazioni di CO2 e TVOC direttamente su una pagina web, o per inviare eventuali allarmi via Telegram), oltre che una radio Bluetooth, che potremo utilizzare per interfacciarci con dispositivi esterni, come smartphone e PC, che potremo eventualmente utilizzare per configurare il dispositivo stesso.
Infine, la scheda integra anche un caricabatterie LiPo on-board, che ci permetterebbe di associare una batteria a singola cella, utilissima per garantire alimentazione al dispositivo anche in assenza di tensione di rete. In Fig. 3 è riportata la piedinatura del nostro modulo. Il modulo è disponibile a catalogo futura elettronica ed ulteriori informazioni possono essere reperite alla seguente pagina web: https://futuranet.it/prodotto/modulo-esp32-con-display-oled-096/.
Il sensore SGP30
Per ottenere la concentrazione di anidride carbonica e di TVOC nell’aria, abbiamo deciso di utilizzare una breakout board basata sul sensore SGP30 della Sensirion. Questo piccolissimo sensore permette di conoscere la concentrazione di anidride carbonica (così da indicarci quanto l’aria in un ambiente chiuso è viziata) e il TVOC (Total Volatile Organic Compounds) ossia la concentrazione in parti per miliardo di particelle in sospensione. Un’immagine della breakout board è riportata in Fig. 4.
Le caratteristiche hardware di dettaglio della breakout board sono queste:
sensore: Sensirion SGP30 (TVOC and e CO2);
rilevamento TVOC (Total Volatile Organic Compounds): da 0 a 60.000 ppb (parti per miliardo);
rilevamento CO2: da 400 a 60.000 ppm (parti per milione);
Frequenza di campionamento: 1 Hz;
Interfaccia: I2C (indirizzo 0x58)
Alimentazione: 3,3V o 5V.
La breakout board è disponibile, montata e collaudata, a catalogo futura elettronica e dettagli aggiuntivi possono essere reperiti alla seguente pagina web: https://futuranet.it/prodotto/breakout-con-sensore-qualita-dellaria-sgp30/.
Cablaggio dell’hardware
Vediamo adesso come realizzare in pratica il nostro apparato, partendo dalla costruzione fisica e quindi dal cablaggio dei componenti. Il collegamento tra la scheda sensore e i LED è piuttosto semplice, tanto da poter essere fatto mediante cavetti jumper maschio femmina tipo quelli per Arduino, ovvero appoggiandosi a una breadboard, come vedete in queste pagine.
Il sensore SGP30 è una breakout board interfacciata tramite bus I²C, quindi necessita di un totale di quattro collegamenti, perché oltre alle linee di clock (SCL) e dati (SDA) del bus I²C, dobbiamo anche collegare le due linee di alimentazione (GND, ossia il negativo, oltre al positivo 3,3V).
I due LED, invece, sono interfacciati attraverso due GPIO standard del modulo WiFi kit 32; questi LED non possono essere pilotati direttamente dalle linee della scheda, onde evitare sovraccarichi dei GPIO, ma piuttosto bisogna porre loro in serie le opportune resistenze di limitazione della corrente, che abbiamo calcolato in 220 ohm ciascuna.
Per agevolarvi nelle connessioni, nella pagina accanto proponiamo lo schema di cablaggio da utilizzare se volete interconnettere i vari elementi tramite cavetti saldati o jumper maschio-femmina. Inoltre nella Tabella 1 sono riportati i collegamenti tra modulo WiFi kit 32 e SGP30 breakout board. Invece nella Tabella 2 sono riportati i pin del modulo WiFi kit 32 utilizzati per i due LED di segnalazione.
Realizzazione software
Dopo aver visto i dettagli hardware del nostro sistema, passiamo al Software. Per lo sviluppo del software di controllo abbiamo deciso di utilizzare Micropython, e nello specifico il port per ESP32. Micropython è un potente sistema per lo sviluppo software di applicazioni per microcontrollori moderni ed orientati all’IoT come l’ESP32, ed inoltre la grande quantità di librerie esistenti per la gestione di sensori, attuatori ed interfacce, permette di semplificare notevolmente questa fase dello sviluppo.
Installazione di Micropython
Per utilizzare Micropython sulla WiFi Kit 32, la prima cosa da fare è installare l’interprete, dal momento che la WiFi kit 32 non lo presenta di default. Per farlo occorre prima di tutto procurarsi una versione del binario da flashare al seguente indirizzo web: https://micropython.org/download/esp32/. La versione utilizzata per lo sviluppo di questa applicazione è la v1.19 (2022-06-18). Scaricate il binario e salvatelo in una cartella del vostro PC.
A questo punto occorre dotarsi anche di esptool, un tool utilizzato per flashare la memoria flash dell’ESP32 e distribuito gratuitamente da Expressif (l’azienda produttrice dell’ESP32 e dell’ESP8266). Potete scaricare esptool dal seguente indirizzo web: https://github.com/espressif/esptool. A questo punto dovete cancellare la memoria del dispositivo e poi “flashare” (caricare nella Flash Memory) il binario di Micropython.
Cancellazione della memoria
Per prima cosa collegate la WiFi kit 32 al vostro PC tramite un cavo USB micro. Al dispositivo dovrebbe venire associata una porta COM virtuale (ad esempio COM3, ma il numero esatto dipende da quante porte avete già sul vostro sistema).
A questo punto mettete la scheda in modalità programmazione premendo e mantenendo premuto il pulsante PRG e premendo e rilasciando il pulsante RST. Ora non vi resta che usare lo script esptool.py per cancellare la memoria. Potete inserire il path dello script nel vostro system path, oppure operare direttamente da quella cartella e cancellare la memoria con il seguente comando (valido in ambiente Windows):
python esptool.py --port <port_numb> erase_flash
Sostituite <port_numb> con la porta COM virtuale assegnata al vostro dispositivo (per esempio la COM3).
Flash dell’interprete Micropython
A questo punto potete flashare micropython (nell’ESP32 l’interprete va flashato all’indirizzo 0x1000). Potete usare il seguente comando di console, sempre sotto Windows:
python esptool.py --chip esp32 --port <port_numb> --baud 460800 write_flash -z 0x1000 esp32.bin
Come prima sostituite <port_numb> con la porta COM virtuale assegnata al vostro dispositivo e esp32.bin con il nome (ed eventualmente il path, se non è lo stesso da cui operate), del binario scaricato il precedenza. In Fig. 5 è riportato il risultato di questa operazione.
Il software di controllo
A questo punto possiamo passare alla gestione del software di controllo della nostra scheda. Come abbiamo accennato, ciò che vogliamo fare è acquisire i dati relativi ai valori di CO2 e TVOC forniti dal sensore SGP30, visualizzare questi dati su display OLED; leggere da file system le soglie utente per i valori limite di CO2 (con relativa isteresi). Gestire due LED di segnalazione (rosso e verde) per indicare se il livello di CO2 è superiore alla soglia massima consentita.
Per implementare questo software ci occorrono innanzitutto degli opportuni driver per la gestione del display OLED e del sensore SGP30. Fortunatamente entrambi i driver sono disponibili, sviluppati da adafruit. Potete procurarveli scaricandoli ai seguenti link web:
per il driver dei display OLED: https://github.com/adafruit/micropython-adafruit-ssd1306/blob/master/ssd1306.py;
per il driver SGP30: https://github.com/alexmrqt/micropython-sgp30.
Lo schema architetturale del software che ci proponiamo di realizzare è rappresentato nella Fig. 6. Il progetto completo risulta quindi composto da questi tre file:
Air_quality.py (file principale dell’applicazione);
Ssd1306.py (driver display OLED);
Adafruit_sgp30.py (driver del sensore sgp30).
L’IDE Thonny
Come IDE di sviluppo per questa applicazione utilizzeremo Thonny, uno degli IDE per Python maggiormente utilizzati, che permette di sviluppare sia applicazioni Python standard, che micropython. Thonny può essere scaricato liberamente dal seguente link: https://thonny.org/.
L’interfacciamento con micropython è molto semplice: dopo aver collegato la scheda WiFi kit 32 alla porta USB del PC, aprite Thonny e cliccate sul bordo in basso a destra: nel menù a tendina che si apre dopo aver fatto click, tra i vari interpreti disponibili selezionate “ESP32”, come illustrato in Fig. 7.
Se l’interprete non dovesse essere presente, selezionate “Configure Interpreter…” e indicate manualmente l’interprete e la porta COM da utilizzare, come illustrato in Fig. 8.
System Setup e Main Loop
Passiamo adesso al dettaglio del software applicativo, contenuto interamente all’interno del file air_quality.py, che si presenta ripartito in due fasi distinte: System Setup e Main Loop. La prima fase, come si può facilmente intuire dal nome, costituisce quella di inizializzazione del sistema, mentre la seconda è il loop principale nel quale avviene la misurazione, la stampa dei valori su display OLED e la segnalazione dello stato tramite LED.
La prima fase, il cui codice è riportato nel Listato 1, ha il compito di inizializzare tutte le periferiche del sistema, come i LED, i due bus I²C (uno utilizzato per l’interfacciamento del display OLED, l’altro per la gestione del sensore SGP30), e di recuperare da file system i valori della baseline del sensore SGP30 e della soglia di CO2 impostata dall’utente. Questi file sono dei file di testo che il software si aspetta di trovare nel file system. I valori della baseline del sensore sono valori di calibrazione che migliorano la precisione della lettura e vengono automaticamente creati dal software se non sono presenti. I file contenenti la soglia di allarme per il valore di CO2 invece devono essere creati dall’utente e se non presenti vengono caricati i valori predefiniti. Per impostare questa soglia vanno creati i seguenti due file:
co2eq_th.txt = contiene il valore di allarme della lettura di CO2, in ppm (parti per milione);
hist_th.txt = contiene l’isteresi della soglia precedente, sempre in ppm.
Listato 1 – Inizializzazione del sistema
# -------------------------------------------------
# - SYSTEM INIT
# -------------------------------------------------
# LEDs
led_green = Pin(2, Pin.OUT)
led_red = Pin(17, Pin.OUT)
led_green.on()
led_red.off()
# Initialize I2C buses
s_i2c = I2C(scl=Pin(18), sda=Pin(19), freq=100000)
d_i2c = SoftI2C(scl=Pin(15), sda=Pin(4), freq=100000)
# OLED enable pin
oled_sts = Pin(16, Pin.OUT)
oled_sts.on()
# OLED initialization
oled_width = 128
oled_height = 64
oled = ssd1306.SSD1306_I2C(oled_width, oled_height, d_i2c)
# Air quality sensor init
sgp30 = adafruit_sgp30.Adafruit_SGP30(s_i2c)
# Initialize SGP-30 internal drift compensation algorithm.
sgp30.iaq_init()
# Wait 15 seconds for the SGP30 to properly initialize
user_message('Sensor Init...')
time.sleep(SENS_INIT_DELAY_S)
# User threshold for LEDs indication
get_user_threshold()
# Sensor Calibration
get_sensor_baseline()
# Store the time at which last baseline has been saved
baseline_time = time.time()La creazione di questi file è molto semplice: in ambiente Thonny, con la board collegata via USB, selezionate l’icona a forma di file oppure File > New. Ripetete questa operazione due volte, per creare due file e scrivete i valori all’interno (ad esempio 450 nel file co2eq_th.txt e 10 nel file hist_th.txt, in modo da avere una soglia di 450ppm di CO2 e una isteresi di 10ppm).
Adesso cliccate sull’icona a forma di floppy disk (o selezionate File > Save) e nel pop-up che compare, selezionate “Micropython Device”, come illustrato in Fig. 9.
Questa operazione permette di accedere al file system del dispositivo e salvare i file creati in precedenza. In questo modo è possibile impostare il valore della soglia di CO2 del caso. Una volta completata la fase di inizializzazione, il software passa al loop principale, rappresentato nel Listato 2.
Listato 2 – Main Loop
# ------------------------------------------------ # - MAIN LOOP # ------------------------------------------------ while True: # Get CO2 and TVOC data co2eq, tvoc = sgp30.iaq_measure() # Print values on Display oled_data(co2eq, tvoc) # Manage LEDs if (co2eq > co2eq_th): led_green.off() led_red.on() elif (co2eq < (co2eq_th - hysteresis)): led_green.on() led_red.off() # Update sensor baseline update_sensor_baseline() # Wait for the new sampling time time.sleep(SAMPLING_TIME_S)
Qui vengono eseguite le seguenti operazioni in sequenza. Tramite a funzione iaq_measure() della libreria adafruit_sgp30 (sgp30_iaq_measure()), vengono acquisiti i valori di CO2 e TVOC, salvati rispettivamente nelle due variabili co2eq e tvoc.
A questo punto, nella riga successiva, i valori vengono stampati sul display OLED, tramite la funzione oled_data(). Successivamente, tramite una serie di istruzioni if…elif, vengono gestiti i LED di segnalazione. In particolare, se il valore immagazzinato nella variabile co2eq risulta superiore a quello della soglia co2eq_th, impostata dall’utente, si accende il LED rosso e si spegne il LED verde, altrimenti, se il valore risulta inferiore a quello di soglia meno l’isteresi (co2eq_th – hysteresis), allora viene spento il LED rosso ed acceso quello verde. Terminata questa fase viene invocata la funzione update_sensor_baseline(), per aggiornare la baseline del sensore.
Per garantire un funzionamento ottimale del sensore, il software aggiorna la baseline la prima volta dopo 12 ore di funzionamento e poi ogni ora, come indicato nel datasheet del costruttore dell’SGP30. A questo punto il loop va in pausa per 60 secondi, prima di eseguire un nuovo ciclo di acquisizione dati.
Il progetto software completo di questa applicazione, corredato di descrizione e di tutte le librerie micropython necessarie può essere scaricato dal seguente repository github:
https://github.com/ffich/IndoorAirQuality.
Per testare il software dovrete salvare i due file contenenti i driver nella memoria della scheda WiFi kit 32, usando la stessa procedura illustrata per salvare i file utente, avendo l’accortezza di mantenere gli stessi nomi dei file, e di non dimenticare l’estensione .py. Il file principale può essere fatto girare direttamente da Thonny, oppure salvato sulla memoria del dispositivo rinominandolo main.py, accortezza necessaria se si desidera far funzionare il dispositivo in modalità “standalone”, ossia non collegato al PC (infatti il file main.py è il file che viene automaticamente cercato dall’interprete micropython all’avvio).
In Fig. 10 è proposta una foto del dispositivo cablato su breadboard mentre acquisisce i dati di qualità dell’aria ed attiva i LED.
Configurazione
Il software presenta anche alcune opzioni di configurazione che possono essere modificate dall’utente, tutte presenti nel file air_quality.py. In particolare è possibile:
modificare i valori predefiniti della soglia di allarme CO2 e relativa isteresi, modificando i due parametri co2eq_th e hysteresis, impostati per default a 450 e 10, come rappresentato nel Listato 3 (agendo sui valori predefiniti non è necessario salvare su file system i valori di questi due parametri);
modificare il tempo di attesa iniziale per la stabilizzazione del sensore ed il tempo di campionamento (SENS_INIT_DELAY_S e SAMPLING_TIME_S), impostati per default a 15 e 60 secondi, come rappresentato sempre nel Listato 3 (noi suggeriamo comunque di non modificare queste impostazioni).
Listato 3 – Parametri di configurazione
------------------------------- # - USER TH DEFAULT VALUES ------------------------------- co2eq_th = 450 hysteresis = 10 ------------------------------- # - TIMING CONST # ------------------------------- SAMPLING_TIME_S = 60 SENS_INIT_DELAY_S = 15
Conclusioni
In questo articolo abbiamo descritto in dettaglio la realizzazione di un dispositivo per il monitoraggio della qualità dell’aria. Il dispositivo, leggendo un sensore di qualità dell’aria (SGP30), è in grado di mostrare su display le concentrazioni di CO2 e TVOC. Inoltre, leggendo un file utente che contiene la soglia di tolleranza per la concentrazione di CO2 è in grado di segnalare visivamente tramite un LED, di operare un ricambio d’aria nell’ambiente.
Data la ricchezza di periferiche aggiuntive della piattaforma utilizzata, è possibile espandere questo dispositivo con funzionalità IoT, come ad esempio una pagina web che permetta di consultare i dati in remoto e segnalazioni via e-mail o notifica telegram.
