Un sistema che permette la misurazione della temperatura, della CO2 e dell'umidità dell'ambiente in cui viene installato. I dati ottenuti verranno poi inviati ad un foglio Google così da poter poi essere visualizzati e analizzati.

Open source e documentazione

Questo progetto è open source, chiunque può scaricare i file necessari, ricreare il progetto e contribuire al suo miglioramento. Non ci sono restrizioni di licenza d'uso, ma si invita a citare che è stato realizzato dagli studenti ASIRID.

Specifiche del progetto

Il progetto è stato concepito per misurare la concentrazione di CO2, la temperatura e l'umidità ambientali. L'impiego di termocarboigrometri in specifici ambienti assicura il monitoraggio delle condizioni, mantenendole ideali per il benessere e la salute. I dati raccolti vengono trasmessi a un foglio di calcolo Google per un'efficace supervisione dei valori rilevati. Nell'ambito del progetto, sono state progettate e successivamente prodotte, mediante l'uso di una stampante 3D, delle custodie atte a contenere tutti i circuiti necessari.

Requisiti Hardware

PCB (Printed Circuit Board): Cliccare qui) per realizzare il circuito stampato
Stazione di saldatura
NodeMCU ESP8266: Chip con modulo Wi-Fi integrato
DHT22 AM2302: Sensore di temperatura e umidità compatibile con ESPHome
MH-Z19: Sensore di CO2 a infrarossi compatibile con ESPHome
Display 16x2 LCD con Interfaccia I2C 2x16
Mini Modulo di Alimentazione: Il modulo trasforma la corrente alternata in corrente continua stabilizzata
Spina C8 maschio a 2 pin: Presa di corrente
Cavo Alimentazione IEC320 C7 a 2 pin: Cavo di alimentazione compatibile con presa C8.

Requisiti Software

Home Assistant
ESPHome (componente aggiuntivo di Home Assistant): cliccare qui per la procedura di installazione
Repository Gitlab: {terbocarboigrometro}

Template del sensore con Substitutions

ESPHome, mediante le Substitutions, consente di utilizzare un unico file sorgente generico per tutti i nodi di uno specifico tipo, permettendo di sostituire parti di esso con espressioni appropriate.

Per creare il file sorgente seguire questi passaggi:

Accedere a File Editor > epshome
Creare la cartella Sensor
All'interno della cartella Sensor, creare il file common_HTC.yaml

Descrizione template sensore

Per iniziare a configurare il file YAML per ESPHome, seguire questi passaggi:

Sezione delle substitutions ed esphome , inserire le coppie chiave-valore che ESPHome sostituirà automaticamente nel file con i rispettivi valori. Si specifica il nome che identifica univocamente il sensore
```
substitutions:
device_name: "sostituisci_con_il_nome_del_dispositivo"

esphome:
name: termocarboigrometro-${device_name}

esp8266:
board: d1
```
Sezione globals: si definisce una variabile intera display_page che serve per ciclare tra diverse pagine di informazioni sul display. Impostando initial_value a 0, si inizia dalla prima pagina. Questa variabile, incrementata periodicamente, permette di alternare le informazioni mostrate sul display ogni 5 secondi, consentendo così di visualizzare sequenzialmente diverse tipologie di dati senza necessità di interazione manuale.
```
globals:
- id: display_page
    type: int
    restore_value: no
    initial_value: "0"
```

Nella sezione sensor, sono definiti i sensori impiegati nel progetto:

Sezione sensor:
- Il sensore DHT22, utilizzato per rilevare umidità e temperatura, è collegato al pin GPIO0. A entrambi i parametri sono stati assegnati nomi e id univoci, e l'intervallo di tempo di aggiornamento dei valori è impostato a 30 secondi.
- Il sensore di CO2, configurato con un intervallo di aggiornamento di 30 secondi, ha attibuti univoci per nome e id. La calibrazione automatica è abilitata, facendo sì che il ciclo di calibrazione automatica si verifichi ogni 24 ore dall'accensione del dispositivo.
- Il sensore uptime monitora la durata di funzionamento del dispositivo, indicando da quanto tempo è acceso.
```
sensor:
- platform: dht
    pin: GPIO0
    model: DHT22
    temperature:
    name: "Temperatura ${device_name}"
    id: "${device_name}_temperatura"
    humidity:
    name: "Umidita ${device_name}"
    id: "${device_name}_umidita"
    update_interval: 30s

- platform: mhz19
    co2:
    name: "CO2 ${device_name}"
    id: "${device_name}_co2"
    update_interval: 30s
    automatic_baseline_calibration: true

- platform: uptime
    name: "Uptime ${device_name}"
```
Sezione button: è stato configurato un pulsante che permette di riavviare il dispositivo in caso di malfunzionamento. Questa funzionalità è essenziale per garantire che l'utente possa facilmente resettare il sistema senza dover ricorrere a interventi più complessi.
```
button:
- platform: restart
    name: "Restart ${device_name}"
```
Sezione uart: sono stati configurati i pin TX (trasmissione) e RX (ricezione) utilizzati per la comunicazione con il sensore di CO2. La configurazione specifica i pin GPIO a cui il sensore è connesso e imposta il baud rate, ovvero la velocità di trasmissione dei dati, a 9600 bps (bit per secondo).
```
uart:
tx_pin: GPIO12
rx_pin: GPIO14
baud_rate: 9600
```

Sezione display: questo blocco di codice serve per configuare e gestire il display

Sezione I2C: impostazione frequenza della comunicazione I2C a 400kHz
Sezione pcf8574: configurazione expander I/O PCF8574, specificando l'indirizzo I2C
Sezione interval: definizione di un'azione da eseguire a intervalli di 5000 millisecondi (5 secondi) utilizzata per cambiare le informazioni visualizzati sul display.

Sezione display: configurazione display LCD collegato tramite un PCF8574, specificando l'intervallo di aggiornamento, le dimensioni e l'indirizzo. Include una lamba function per aggiornare il display in base al valore della variabile globale definita in precedenza. Questa funzione mostra alternativamente la temperatura, l'umidità e il livello di C02, oltre all'indirizzo IP del dispositivo.

i2c:
frequency: 400khz

pcf8574:
id: "pcf8574_hub"
address: 0x27
pcf8575: false

interval:
    - interval: 5000ms
      then:
        - lambda: |-
            id(display_page) += 1;
            if (id(display_page) > 2) id(display_page) = 0;

display:
    - platform: lcd_pcf8574
    update_interval: 100ms
    dimensions: 20x4
    address: 0x27
    lambda: |-
        it.print(0, 0, "                    ");
        if (id(display_page) == 0) {
            it.printf(0, 0, "Temp: %.1f C", id(${device_name}_temperatura).state);
        } else if (id(display_page) == 1) {
            it.printf(0, 0, "Umidita': %.1f%%", id(${device_name}_umidita).state);
        } else if (id(display_page) == 2) {
        it.printf(0, 0, "CO2: %.0f ppm", id(${device_name}_co2).state);
        }
        it.printf(0, 1, "IP: %s", WiFi.localIP().toString().c_str());

Configurazione automation blueprints per invio dei dati su Google Sheet attraverso RESTful Command

Questa integrazione può esporre comandi REST regolari come servizi. I servizi possono essere chiamati da uno script o in automazione.

In particolare, viene richiamato uno script di Google Apps che consente di registrare i dati rilevati dal sensore su un foglio di calcolo specifico.

Per usare questa integrazione, aggiungi le seguenti righe nel file configuration.yaml:

rest_command:
    chiama_appscript_sheet_sensori:
        url: "https://script.google.com/macros/s/.../exec?deviceid={{ deviceid }}&tag={{ tag }}&value={{ value }}"

Per creare il file sorgente seguire questi passaggi:

Accedere a File Editor > blueprints > automations
All'interno della cartella automations, creare il file rest_sheet_sensors.yaml

Descrizione blueprint

Sezione blueprints: in questa sezione viene definito il nome della blueprint, il dominio e gli input richiesti, che includono i sensori per la temperatura, l'umidità e il CO2. È inoltre necessario specificare i tag (Temp, Hum, CO2), che fungono da etichette associate a ciascuna variabile.

N.B.: Per tag_2, entita_2, tag_3 e sensore_3, è previsto che, in assenza di un valore inserito, questi corrispondano a una stringa vuota. Ciò permette la possibilità di effettuare una chiamata REST utilizzando solamente un sensore, se necessario.

blueprint:
name: Chiamata Rest Google Sheet
description: Scrittura periodica dati sensori
domain: automation
input:
    deviceid:
    name: DeviceId
    tag_1:
    name: Tag 1
    entita_1:
    name: Entita' 1
    selector:
        entity:
        domain: sensor
    tag_2:
    name: Tag 2
    default: ""
    entita_2:
    name: Entita' 2
    selector:
        entity:
        domain: sensor
    default: ""
    tag_3:
    name: Tag 3
    default: ""
    entita_3:
    name: Entita' 3
    selector:
        entity:
        domain: sensor
    default: ""

Sezione variables: in questa sezione, per accedere ai dati rilevati dai sensori, è necessario convertire i sensori definiti negli input in variabili.
```
variables:
    entita_1: !input entita_1
    entita_2: !input entita_2
    entita_3: !input entita_3
```
Sezione trigger: in questa sezione viene definito un trigger di tipo time_pattern che consente di eseguire l'automazione ogni 5 minuti
```
trigger:
    - platform: time_pattern
      minutes: /5
```

Sezione action: in questa sezione della blueprint, si delineano le azioni da intraprendere una volta attivato il trigger. Se tutti gli input sono stati forniti, si procede con tre chiamate REST, ognuna delle quali registra i valori rilevati dai rispettivi sensori. In alternativa, se vengono inseriti solamente il deviceid, tag_1 e entita_1, verrà effettuata una singola chiamata REST che registrerà il valore di un unico parametro.

action:
- service: rest_command.chiama_appscript_sheet_sensori
    data_template:
        deviceid: !input "deviceid"
        tag: !input tag_1
        value: "{{ states(entita_1) }}"
- choose:
    - conditions: "{{ entita_2 != '' and tag_2 != ''}}"
        sequence:
        - service: rest_command.chiama_appscript_sheet_sensori
            data_template:
                deviceid: !input "deviceid"
                tag: !input tag_2
                value: "{{ states(entita_2) }}"
- choose:
    - conditions: "{{ entita_3 != '' and tag_3 != ''}}"
        sequence:
        - service: rest_command.chiama_appscript_sheet_sensori
            data_template:
                deviceid: !input "deviceid"
                tag: !input tag_3
                value: "{{ states(entita_3) }}"

Configurazione del sensore in EPSHome

Per configurare il sensore con ESPHome, seguire questi passaggi:

Collegare il microcontrollore tramite la porta seriale al PC
Andare in ESPHome
Cliccare sul pulsante in basso a destra + NEW DEVICE e successivamente CONTINUE
Assegnare un nome alla configurazione ad esempio "esterno"
Selezionare il microntrollore corretto (in questo caso ESP8266)
Cliccare su Install e successivamente su Plug into this computer
Scaricare il progetto e caricarlo tramite la pagina web di ESPHome

Una volta installato cliccare su EDIT per modificare la configurazione del sensore:

substitutions:
    device_name: "esterno"

<<: !include Sensor/common_HTC.yaml

logger:

api:

ota:

wifi:
    ssid: !secret wifi_ssid
    password: !secret wifi_password

captive_portal:

web_server:

Sostituisci device_name con il nome specifico del sensore, ad esempio, utilizza il nome che hai assegnato precedentemente per garantire una corretta corrispondenza.
Includi il template definito in precedenza nel tuo file di configurazione per mantenere la consistenza e riutilizzare le impostazioni comuni.
Il componente logger consente di registrare e visualizzare informazioni dettagliate sul sensore, come i dati rilevati, l'indirizzo IP, e altre metriche utili per il debug e il monitoraggio.
Il componente api è essenziale per integrare il sensore con Home Assistant, consentendo la comunicazione e lo scambio di dati tra il dispositivo e la piattaforma.
Il componente ota abilita la funzionalità di aggiornamento del firmware del sensore attraverso la rete WiFi, facilitando le modifiche alla configurazione senza la necessità di collegamenti fisici.
Il componente web_server offre la possibilità di accedere a una pagina web dedicata al sensore. Questa funzionalità consente di visualizzare lo stato e le metriche del sensore direttamente da un browser web, migliorando l'interattività e l'accessibilità.

Una volta modificata la configurazione installarla tramite OTA.

Integrazione sensore in Home Assistant

Dopo aver installato la configurazione del sensore, per integrare il sensore in Home Assistant:

Riavviare Home Assistant
Andare in Impostazioni > Dispositivi e Servizi > ESPHome
Aggiungere il dispositivo appena configurato cliccando sul tasto CONFIGURA

Creazione automazione basata su blueprints

Premessa: Prima di implementare l'automazione in Home Assistant, è cruciale preparare i foglio di calcolo di Google Sheets dove verranno registrati i dati. Il nome del foglio in basso a sinistra deve essere DataLogger

Per creare l'automazione per scrivere i dati sul foglio di Google seguire i seguenti passaggi:

Naviga in Impostazioni
Seleziona Automazioni e scenari per accedere alla sezione dove puoi gestire e creare nuove automazioni.
Clicca sul pulsante + CREA AUTOMAZIONE situato in basso a destra per iniziare la creazione di una nuova automazione.
Nella lista delle automazioni o delle blueprints disponibili, cerca e clicca sul nome della blueprint che hai creato precedentemente
Indicare il deviceid, i tag e selezionare le entità. Queste saranno le fonti dei dati che desideri registrare.
Salvare e assegnare un nome all'automazione.

Stato attuale del progetto

Il progetto è stato pubblicato a Marzo 2024, nella sua prima versione ed è attualmente funzionante. Sviluppi futuri da definire.

Autori

Francesco Sparascio, Francesco Rinaldi

Termocarboigrometro WiFi verso Home Assistant