Home Assistant Integrazione del contatore Geiger: 8 passaggi

2024 Autore: John Day | [email protected]. Ultima modifica: 2024-01-30 10:00

In questo tutorial ti mostrerò come aggiungere sensori personalizzati a HASS (assistente domestico) più specificamente un contatore geiger, ma il processo è simile anche per altri sensori.

Useremo la scheda NodeMCU, un contatore geiger basato su arduino e un assistente domestico già installato.

L'integrazione sarà basata su un server MQTT (pubblico o privato) e ti guiderò passo dopo passo.

Nel caso in cui non sai cos'è l'assistente domiciliare, visita la loro pagina https://www.home-assistant.io/. È una piattaforma di automazione domestica ben nota, molto ben tenuta e altamente personalizzabile.

Imparerai a conoscere:

- configurazione avanzata per Home Assistant

- NodeMCU (scheda di sviluppo) e come programmarlo con l'IDE Arduino

- OTA (aggiornamenti via etere) utilizzando l'IDE Arduino per la scheda NodeMCU

- come collegare un dispositivo seriale al NodeMCU

- installazione manuale di un server MQTT su linux (opzionale)

Assunzioni base:

- hai Home Assistant attivo e funzionante

- conosci un po' di elettronica

- hai installato Arduino IDE

Passaggio 1: parti e strumenti

Parti:

1. Scheda NodeMCU

2. breadbord

3. fili juper maschio-maschio e maschio-femmina

3. cavo da usb a micro usb

4. arduino contatore geiger con interfaccia seriale

(cerca su Ebay "arduino geiger couter")

5. materiale radioattivo (opzionale un piccolo campione di prova)

Utensili:

1. Arduino IDE

2. Home Assistant installato

Fase 2: Principio di lavoro

Il nostro obiettivo è mostrare su HomeAssistat (HASS) le letture del contatore geiger. Da un lato abbiamo un server HASS attivo e funzionante da qualche parte che potrebbe essere un raspberry pi o un altro dispositivo e dall'altro abbiamo il contatore geiger.

Il contatore geiger ha una porta seriale, una soluzione sarà quella di collegare direttamente la porta seriale al RaspberryPi su cui gira HASS.

Alcuni motivi per cui potrebbe non essere una buona idea:

- non c'è spazio fisico lì

- abbiamo qualche altro dispositivo sulla porta seriale

- vogliamo collegare un sensore ambientale che va posizionato all'esterno al posto del contatore geiger

Ok, esploreremo un'altra possibilità di effettuare la connessione tramite WIFI:

L'HASS supporta la lettura dei dati del sensore e la visualizzazione che tramite un server MQTT, questo tipo di server è una connessione leggera per dispositivi di piccole dimensioni, un dispositivo pubblica un messaggio su un "argomento" l'altro ascolta su quell'argomento per ricevere il messaggio. Quindi HASS ascolterà e abbiamo bisogno di qualcosa che pubblichi il messaggio.

Il nostro sensore sa parlare solo sulla linea seriale, quindi utilizzeremo una scheda in grado di leggere una linea seriale e che può connettersi tramite WIFI e parlare con il server MQTT. Una scheda economica che fa questo è la NodeMCU.

Il NodeMCU può essere programmato con Arduino IDE. Lo schizzo è piuttosto semplice, fa quanto segue:

- si connette al WIFI

- mantiene una connessione MQTT con il server e riprova la connessione in caso di errore o disconnesso

- ascolta i dati in ingresso seriali come una serie di numeri interi

- una volta che arriva un intero lo invia tramite MQTT a un argomento specifico

Passaggio 3: assemblare il dispositivo

Useremo breadboard e wire, quindi è abbastanza semplice, abbiamo alcuni passaggi:

- metti il NodeMCU sulla breadboard

- collegare il tubo geiger al contatore geiger (attenzione alla polarità)

- VIN va al contatore geiger +

- GND va al contatore geiger -

- NodeMCU D7 (pin 13) va a geiger TX

- NodeMCU D8 (pin 15) va a geiger RX

- alimentare NodeMCU tramite micro USB dal computer

Passaggio 4: carica il codice

Useremo Arduino IDE e ci assicureremo di avere la scheda NodeMCU installata e la libreria Adafruit_MQTT installata.

1. Clona il repository github: https://github.com/danionescu0/arduino e copia lo schizzo da projects/HASSGeigerIntegration nella posizione del tuo sketchbook di arduino

2. Apri Arduino IDE e installa NodeMCU

- vai su File -> Preferenze, negli URL di Gestione schede aggiuntive aggiungi https://arduino.esp8266.com/stable/package_esp8266com_index.json se hai già qualcosa metti un coma davanti e fai clic su ok

- da Strumenti -> Scheda -> Board Manager digitare "nodemcu" e selezionare la voce esp8266 da ESP8266 Community e premere installa

3. Installa Adafruit_MQTT

- vai su Strumenti -> Gestisci librerie -> cerca "Adafruit_MQTT" e installa "Libreria Arduino MQTT"

4. Collega il cavo USB al tuo computer e configura la scheda:

- vai su Strumenti -> Scheda -> seleziona NodeMcu 1.0

- Strumenti -> Porta -> la tua porta USB

- lasciare invariate le altre impostazioni

4. Nello schizzo cambia le tue credenziali WIFI in modo che corrispondano alle tue:

#define STASSID "ssid" // Sostituisci con il tuo SSID WIFI

#define STAPSK "pass" // Sostituisci con la tua password WIFI

5. Carica lo schizzo sulla tua scheda e dopo il caricamento ripristina la scheda dal pulsante

6. Apri il monitor seriale, se tutto è andato bene dovresti vedere un output come questo:

Avvio

Indirizzo IP: 192.168.1.168 OTA abilitato Connessione a MQTT… MQTT connesso! {"radiazione": 0.03}..

Passaggio 5: configurare HomeAssistant

Supponiamo che tu abbia un assistente domestico attivo e funzionante. Sul mio sistema ho HASSOS versione 3.12 su un RaspberryPi. Se la tua versione dell'assistente domestico è troppo vecchia o molto nuova, alcune funzionalità potrebbero differire. Questo tutorial funziona sicuramente con la versione 3.12.

Se non hai installato Home Assistant, controlla la loro guida di installazione ufficiale:

Prima di procedere con l'installazione, assicurati che il NodeMCU sia collegato e che pubblichi i dati.

Ok avremo anche qui una serie di passaggi per la configurazione:

1. Installa "editor di file" se non lo hai nel menu, ecco il tutorial ufficiale:

2. Modifica il file "/config/configuration.yaml" e aggiungi quanto segue e salvalo

- la sezione mqtt se non ce l'hai già

mqt:

broker: broker.hivemq.com discovery: true discovery_prefix: ha

- la sezione sensori

sensore:

- piattaforma: mqtt nome: "Radiation" state_topic: "ha/radiation" unit_of_measurement: 'uSv' unique_id: "radiation" value_template: "{{ value_json.radiation }}"

3. Da Configurazione -> Controlli server: premere "Verifica configurazione" per verificare la presenza di errori nel file di configurazione yaml, quindi premere "riavvia" e attendere il riavvio

4. Da Panoramica -> Menu in alto a destra -> Configura UI -> premi il pulsante + in basso a destra

5. Seleziona "sensore" dall'elenco -> nel campo "entità" cerca "sensor.radiation", nel campo del nome scrivi "Radiazione" e fai clic su ok, ora dovrebbe essere nella pagina principale

Passaggio 6: configurazione del proprio server MQTT [Facoltativo]

Parliamo un po' di MQTT

“MQTT è un protocollo di trasporto di messaggistica di pubblicazione/sottoscrizione del server client. È leggero, aperto, semplice e progettato in modo da essere facile da implementare. Queste caratteristiche lo rendono ideale per l'uso in molte situazioni, inclusi ambienti vincolati come per la comunicazione in contesti Machine to Machine (M2M) e Internet of Things (IoT) in cui è richiesta una piccola impronta di codice e/o la larghezza di banda della rete è un premio."

Citazione dalla specifica ufficiale MQTT 3.1.1.

Quindi fondamentalmente possiamo pubblicare un messaggio da qualche parte da un lato e dall'altro possiamo ascoltare quei messaggi e fare qualcosa con i dati. Supporto MQTT "topics", gli argomenti sono stringhe che il broker utilizza per filtrare i messaggi per ogni client, quindi se pubblichiamo un messaggio nell'argomento "/radiation" un ascoltatore deve iscriversi allo stesso argomento per ottenere i messaggi che stiamo inviando.

Ecco un ottimo tutorial su MQTT in dettaglio:

Utilizzando il server hive gratuito ci sono alcuni svantaggi come:

- chiunque ascolti il tuo argomento riceverà i tuoi messaggi

- se va giù o richiede il pagamento in un secondo momento non potrai utilizzarlo (a meno che tu non paghi)

- se qualcuno che pubblica messaggi sullo stesso argomento riceverà anche i suoi messaggi, potrebbe pubblicare messaggi incompatibili e rompere i tuoi grafici HASS

Utilizzo di un server privato

Se non vuoi utilizzare il server pubblico gratuito hai la possibilità di un server privato. Installeremo Mosquitto MQTT su un server Ubuntu / Debian come un raspberry pi o un computer.

Mosquitto è un server che implementa il protocollo MQTT ed è gratuito.

Per installarlo accedi al tuo raspnerry pi o ad un altro server basato su Debian ed esegui:

sudo apt update

sudo apt install -y mosquitto mosquitto-clients sudo systemctl enable mosquitto.service

Ciò aggiornerà il repository, installerà il server e il client mosquiito e consentirà l'esecuzione di un servizio all'avvio

Per ottenere l'ip del server eseguire:

nome host -I

e produrrà qualcosa come:

192.168.1.52 172.17.0.1 172.18.0.1

Quindi il mio IP è 192.168.1.52, nei comandi seguenti sostituiscilo con il tuo IP

Puoi testare il server MQTT pubblicando un messaggio e ricevendolo con lo strumento console, per questo devono essere aperti due terminali uno che ascolta un messaggio, uno che pubblicherà il messaggio.

Prima in un terminale esegui questo comando per ascoltare un messaggio su "/some-topic"

mosquitto_sub -h 192.168.1.52 -t /un-topic

Apri un altro terminale e pubblica un messaggio su quell'argomento:

mosquitto_pub -h 192.168.1.52 -t /some-topic -m '{"umidità": 74.0}'

Nel primo terminale dovresti vedere ' {"humidity": 74.0}' stampato.

Attenzione speciale:

- questa configurazione presuppone che HASS, Mosquitto e NodeMCU siano connessi alla stessa rete WIFI e non ci siano regole firewall e possano comunicare liberamente

- il server Mosquitt MQTT non ha nome utente/password, se vuoi impostare le credenziali controlla questo: https://www.steves-internet-guide.com/mqtt-username-password-example/ Inoltre dovresti configurare le credenziali in Home Assistant e nello sketch di arduino

Passaggio 7: OTA (aggiornamenti via etere) per NodeMCU

Gli aggiornamenti via etere consentono di eseguire il flashing della scheda di sviluppo in modalità wireless senza la necessità di un cavo fisico.

Arduino IDE supporta questa funzionalità per la serie ESP8266 e alcune altre schede:

- richiede il flash iniziale tramite il cavo USB

- crea una porta virtuale su WIFI ed è visibile solo da Arduino IDE

- non sono disponibili informazioni di debug seriale

- supporta la protezione con password

Per abilitare OTA in uno schizzo ESP8266, includere prima la libreria:

#include "ArduinoOTA.h"

Definisci anche questa costante della password dello schizzo:

#define SKETCHPASS "qualche_password"

Nella sezione di configurazione aggiungi queste righe:

while (WiFi.waitForConnectResult() != WL_CONNECTED) {

Serial.println("Connessione fallita! Riavvio in corso…"); ritardo (5000); ESP.restart(); } ArduinoOTA.setPassword(SKETCHPASS); ArduinoOTA.onStart(() { String type; if (ArduinoOTA.getCommand() == U_FLASH) { type = "schizzo"; } else { // U_FS type = "filesystem"; } Serial.println("Inizia l'aggiornamento " + digita); }); ArduinoOTA.onEnd(() { Serial.println("\nEnd"); }); ArduinoOTA.onProgress((unsigned int progress, unsigned int total) { Serial.printf("Progress: %u%%\r", (progress / (total/100))); }); ArduinoOTA.onError((ota_error_t error) { Serial.printf("Error[%u]: ", error); if (error == OTA_AUTH_ERROR) { Serial.println("Auth Failed"); } else if (errore == OTA_BEGIN_ERROR) { Serial.println("Inizio fallito"); } else if (errore == OTA_CONNECT_ERROR) { Serial.println("Connessione fallita"); } else if (error == OTA_RECEIVE_ERROR) { Serial.println(" Ricezione fallita"); } else if (errore == OTA_END_ERROR) { Serial.println("Fine fallita"); } }); ArduinoOTA.begin(); Serial.print("Indirizzo IP: "); Serial.println(WiFi.localIP());

E nella sezione loop aggiungi questa riga:

ArduinoOTA.handle();

Dopo il caricamento iniziale del codice dopo l'avvio della scheda, dovresti vedere nell'IDE di Arduino nella sezione Strumenti->Porte due tipi di porte:

Porte seriali: /dev/ttyUSB0 (ad esempio)

Porte di rete: esp8266-xxxxx a 192.168.1.xxx

Ora puoi selezionare la porta di rete e caricare lo sketch remoto, ti verrà richiesta la password dello sketch (quella che hai definito in una costante sopra)

Passaggio 8: conclusioni, lavoro futuro

Questo tutorial può essere facilmente modificato per inviare dati su altri tipi di sensori:

- se il tuo sensore è supportato direttamente da NodeMCU tramite una libreria, raccogli i dati dal sensore e inviali direttamente tramite MQTT

- se la libreria dei sensori non funziona con NodeMCU ma è solo per Arduino, carica il tuo codice su arduino, emetti il valore attraverso la linea seriale e leggilo nel NodeMCU e spingilo (proprio come abbiamo fatto con il contatore geiger)

Possiamo persino modificarlo per inviare dati da più sensori in questo modo:

- collega i tuoi sensori al NodeMCU

- poll dati da ciascun sensore

- per ogni sensore pubblicare i dati su un argomento diverso

- nell'HASS definire più sensori (come abbiamo fatto con il geiger) che ascolteranno diversi argomenti