Home Assistant Geiger Counter Integration: 8 pași

2024 Autor: John Day | [email protected]. Modificat ultima dată: 2024-01-30 11:41

În acest tutorial voi arăta cum să adăugați senzori personalizați la HASS (asistent la domiciliu), mai precis un contor geiger, dar procesul este similar și pentru alți senzori.

Vom folosi placa NodeMCU, un contor geiger bazat pe arduino și un asistent la domiciliu deja instalat.

Integrarea se va baza pe un server MQTT (public sau privat) și vă voi duce pas cu pas cu acest lucru.

În cazul în care nu știți ce este asistent la domiciliu, vă rugăm să vizitați pagina lor https://www.home-assistant.io/. Este o platformă de automatizare a locuinței bine cunoscută, foarte bine întreținută și foarte personalizabilă.

Veți afla despre:

- configurație avansată pentru Home Assistant

- NodeMCU (placa de dezvoltare) și cum să-l programați cu Arduino IDE

- OTA (over the air updates) folosind Arduino IDE pentru placa NodeMCU

- cum să conectați un dispozitiv serial la NodeMCU

- instalarea manuală a unui server MQTT pe Linux (opțional)

Presupuneri de baza:

- aveți Home Assistant funcțional

- știi puțin despre electronică

- aveți Arduino IDE instalat

Pasul 1: Piese și instrumente

Părți:

1. Placa NodeMCU

2. pâine

3. fire juper masculin-masculin și masculin-feminin

3. cablu usb la micro usb

4. contor geiger arduino cu interfață serială

(căutați pe ebay „arduino geiger couter”)

5. material radioactiv (opțional un mic eșantion de testare)

Instrumente:

1. IDE Arduino

2. Home Assistant este instalat

Pasul 2: Principiul muncii

Scopul nostru este de a arăta pe HomeAssistat (HASS) citirile de pe ghișeul geiger. Pe de o parte, avem un server HASS și funcționează undeva, poate fi un raspberry pi sau alt dispozitiv, iar pe de altă parte avem contorul geiger.

Contorul Geiger are un port serial, o soluție va fi atașarea directă a portului serial la RaspberryPi pe care rulează HASS.

Câteva motive pentru care este posibil să nu fie o idee bună:

- acolo nu există spațiu fizic

- avem un alt dispozitiv pe portul serial

- vrem să atașăm un senzor de mediu care ar trebui plasat în exterior în locul contorului geiger

Ok, așa că vom explora o altă posibilitate de a face conexiunea prin WIFI:

HASS acceptă citirea datelor senzorilor și afișarea faptului că printr-un server MQTT, acest tip de server este o conexiune de greutate redusă pentru dispozitivele mici, un dispozitiv publică un mesaj pe un „subiect”, celălalt ascultă subiectul respectiv pentru a primi mesajul. Deci, HASS va asculta și avem nevoie de ceva care să publice mesajul.

Senzorul nostru știe doar să vorbească peste linia de serie, așa că vom folosi o placă care poate citi o linie de serie și care se poate conecta prin WIFI și poate vorbi cu serverul MQTT. O placă ieftină care face acest lucru este NodeMCU.

NodeMCU poate fi programat cu Arduino IDE. Schița este destul de simplă, face următoarele:

- se conectează la WIFI

- menține o conexiune MQTT cu serverul și reîncearcă conexiunea atunci când eșuează sau este deconectată

- ascultă datele de intrare în serie ca o serie de numere întregi

- odată ce ajunge un număr întreg, îl trimite prin MQTT către un subiect specific

Pasul 3: Asamblați dispozitivul

Vom folosi panouri și fire, așa că este destul de simplu, avem câțiva pași:

- puneți NodeMCU pe panou

- conectați tubul geiger la contorul geiger (atenție la polaritate)

- VIN merge la contorul geiger +

- GND merge la contorul geiger -

- NodeMCU D7 (pinul 13) merge la geiger TX

- NodeMCU D8 (pinul 15) merge la geiger RX

- alimentează NodeMCU prin micro USB de la computer

Pasul 4: încărcați codul

Vom folosi Arduino IDE și ne vom asigura că avem instalată placa NodeMCU și instalată biblioteca Adafruit_MQTT.

1. Clonați depozitul github: https://github.com/danionescu0/arduino și copiați schița din proiecte / HASSGeigerIntegration în locația carnetului de schițe arduino

2. Deschideți Arduino IDE și instalați NodeMCU

- accesați Fișier -> Preferințe, în adresele URL ale Managerului de plăci suplimentare adăugați https://arduino.esp8266.com/stable/package_esp8266com_index.json dacă aveți deja ceva acolo puneți comă în față și faceți clic pe ok

- din Instrumente -> Board -> Board Manager tastați "nodemcu" și selectați intrarea esp8266 de către Comunitatea ESP8266 și apăsați instalare

3. Instalați Adafruit_MQTT

- accesați Instrumente -> Gestionați bibliotecile -> căutați „Adafruit_MQTT” și instalați „Arduino MQTT library”

4. Conectați cablul USB din computer și configurați placa:

- accesați Instrumente -> Placă -> selectați NodeMcu 1.0

- Instrumente -> Port -> portul USB

- lăsați celelalte setări neschimbate

4. În schiță, modificați acreditările WIFI pentru a se potrivi cu ale voastre:

#define STASSID "ssid" // Înlocuiți cu SSID-ul WIFI

#define STAPSK "pass" // Înlocuiți cu parola WIFI

5. Încărcați schița pe placa dvs. și după încărcare resetați placa de pe buton

6. Deschideți monitorul serial, dacă totul a mers bine, ar trebui să vedeți o ieșire de genul acesta:

Pornirea

Adresă IP: 192.168.1.168 activat OTA Conectarea la MQTT… MQTT Conectat! {"radiație": 0,03}..

Pasul 5: Configurați HomeAssistant

Vom presupune că aveți asistent la domiciliu în funcțiune. Pe sistemul meu am HASSOS versiunea 3.12 pe un RaspberryPi. Dacă versiunea dvs. de asistent la domiciliu este prea veche sau foarte nouă, unele funcții pot diferi. Acest tutorial funcționează sigur cu versiunea 3.12.

Dacă nu aveți instalat Home Assistant, consultați ghidul oficial de instalare:

Înainte de a avansa cu instalarea, asigurați-vă că NodeMCU este conectat și că publică date.

Ok, vom avea o serie de pași și aici pentru configurare:

1. Instalați „editor de fișiere” dacă nu îl aveți în meniu, iată tutorialul oficial:

2. Editați fișierul „/config/configuration.yaml” și adăugați următoarele și salvați-l

- secțiunea mqtt dacă nu o aveți deja

mqtt:

broker: broker.hivemq.com descoperire: adevărat descoperire_prefix: ha

- secțiunea senzorilor

senzor:

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

3. Din Configurare -> Comenzi server: apăsați „Verificați configurația” verificați dacă fișierul de configurare yaml pentru erori, apoi apăsați „reporniți” și așteptați până când este repornit

4. Din Prezentare generală -> Meniul din colțul din dreapta sus -> Configurare UI -> apăsați butonul + din dreapta jos

5. Selectați „senzor” din listă -> în câmpul „entitate” căutați „senzor.radiație”, în câmpul de nume scrieți „Radiație” și faceți clic pe OK, ar trebui să fie acum pe pagina principală

Pasul 6: Configurarea propriului server MQTT [Opțional]

Să discutăm puțin despre MQTT

„MQTT este un protocol de transport de mesagerie de publicare / abonare Server Client. Este ușor, deschis, simplu și proiectat astfel încât să fie ușor de implementat. Aceste caracteristici îl fac ideal pentru utilizare în multe situații, inclusiv în medii restrânse, cum ar fi pentru comunicarea în contexte Machine to Machine (M2M) și Internet of Things (IoT) în care este necesară o mică amprentă de cod și / sau lățimea de bandă a rețelei este la un nivel superior.”

Citat din specificația oficială MQTT 3.1.1.

Deci, practic putem publica un mesaj undeva pe o parte și pe cealaltă parte putem asculta mesajele respective și putem face ceva cu datele. MQTT acceptă „subiecte”, subiectele sunt șiruri pe care brokerul le folosește pentru a filtra mesajele pentru fiecare client, deci dacă publicăm un mesaj pe subiectul „/ radiation”, un ascultător trebuie să se aboneze la același subiect pentru a primi mesajele pe care le trimitem.

Iată un tutorial minunat despre MQTT în detaliu:

Folosind serverul gratuit de stup există câteva dezavantaje, cum ar fi:

- oricine vă ascultă subiectul va primi mesajele dvs.

- dacă scade sau necesită o plată ulterioară, nu îl veți putea folosi (dacă nu plătiți)

- dacă cineva care publică mesaje pe același subiect îi vei primi și mesajele, poate publica mesaje incompatibile și îți rupe graficele HASS

Folosirea unui server privat

Dacă nu doriți să utilizați serverul public gratuit, aveți opțiunea unui server privat. Vom instala Mosquitto MQTT pe un server ubuntu / debian, cum ar fi un raspberry pi sau un computer.

Mosquitto este un server care implementează protocolul MQTT și este gratuit.

Pentru ao instala, conectați-vă la raspnerry pi sau la alt server bazat pe debian și rulați:

actualizare sudo apt

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

Aceasta va actualiza depozitul, va instala serverul și clientul mosquiito și îi va permite un serviciu să ruleze la pornire

Pentru a obține executarea ip-ului serverului:

numele gazdei -I

și va genera ceva de genul:

192.168.1.52 172.17.0.1 172.18.0.1

Deci ip-ul meu este 192.168.1.52, în comenzile de mai jos înlocuiți-l cu propriul dvs. IP

Puteți testa serverul MQTT publicând un mesaj și primindu-l cu instrumentul consolă, pentru aceasta trebuie deschise două terminale care ascultă un mesaj, unul care va publica mesajul.

Mai întâi într-un terminal executați această comandă pentru a asculta un mesaj despre „/ some-topic”

mosquitto_sub -h 192.168.1.52 -t / some-topic

Deschideți un alt terminal și publicați un mesaj către subiectul respectiv:

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

În primul terminal ar trebui să vedeți tipărit „{" umiditate ": 74.0}”.

Atentie speciala:

- această configurare presupune că HASS, Mosquitto și NodeMCU sunt conectate la aceeași rețea WIFI și nu există reguli firewall și pot comunica liber

- serverul Mosquitt MQTT nu are nume de utilizator / parolă, dacă doriți să configurați acreditările, verificați acest lucru: https://www.steves-internet-guide.com/mqtt-username-password-example/ De asemenea, va trebui să configurați acreditările din Home Assistant și din schița arduino

Pasul 7: OTA (Over the Air Updates) pentru NodeMCU

Actualizările prin aer înseamnă că placa de dezvoltare poate fi intermitentă fără fir, fără a fi nevoie de un cablu fizic.

Arduino IDE acceptă această funcționalitate pentru seria ESP8266 și alte plăci:

- necesită bliț inițial prin cablul USB

- creează un port virtual prin WIFI și este vizibil doar din Arduino IDE

- nu sunt disponibile informații de depanare în serie

- acceptă protecție cu parolă

Pentru a activa OTA într-o schiță ESP8266, includeți mai întâi biblioteca:

#include „ArduinoOTA.h”

De asemenea, definiți această constantă de parolă schiță:

#define SKETCHPASS "some_password"

În secțiunea de configurare adăugați următoarele linii:

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

Serial.println ("Conexiunea nu a reușit! Repornirea …"); întârziere (5000); ESP.restart (); } ArduinoOTA.setPassword (SKETCHPASS); ArduinoOTA.onStart ( () {String type; if (ArduinoOTA.getCommand () == U_FLASH) {type = "schiță";} else {// U_FS type = "filesystem";} Serial.println ("Începeți actualizarea) "+ tip);}); ArduinoOTA.onEnd ( () {Serial.println ("\ nEnd");}); ArduinoOTA.onProgress ( (nesemnat int progres, nesemnat int total) {Serial.printf ("Progres:% u %% / r", (progres / (total / 100)));}); ArduinoOTA.onError ( (eroare ota_error_t) {Serial.printf ("Eroare [% u]:", eroare); if (eroare == OTA_AUTH_ERROR) {Serial.println ("Auth Failed");} else if (eroare == OTA_BEGIN_ERROR) {Serial.println ("Începe eșuat");} else if (eroare == OTA_CONNECT_ERROR) {Serial.println ("Conectare eșuată");} else if (eroare == OTA_RECEIVE_ERROR) {Serial.println (" Receive Failed ");} else if (eroare == OTA_END_ERROR) {Serial.println (" End Failed ");}}); ArduinoOTA.begin (); Serial.print („Adresă IP:”); Serial.println (WiFi.localIP ());

Și în secțiunea buclă adăugați această linie:

ArduinoOTA.handle ();

După încărcarea codului inițial după pornirea plăcii, ar trebui să vedeți în ID-ul Arduino din secțiunea Instrumente-> Port două tipuri de porturi:

Porturi seriale: / dev / ttyUSB0 (de exemplu)

Porturi de rețea: esp8266-xxxxx la 192.168.1.xxx

Acum puteți selecta portul de rețea și puteți încărca schița la distanță, vi se va solicita parola de schiță (cea pe care ați definit-o într-o constantă de mai sus)

Pasul 8: Concluzii, lucrări viitoare

Acest tutorial poate fi modificat cu ușurință pentru a trimite date despre alte tipuri de senzori:

- dacă senzorul dvs. este susținut direct de NodeMCU printr-o bibliotecă, purtați datele de la senzor și împingeți-le direct prin MQTT

- dacă biblioteca senzorilor nu funcționează cu NodeMCU, dar este doar pentru Arduino, atunci încărcați codul pe arduino, scoateți valoarea prin linia serială și citiți-o în NodeMCU și împingeți-o (la fel cum am făcut cu contorul geiger)

Putem chiar să-l modificăm pentru a trimite date de la mai mulți senzori, astfel:

- conectați senzorii la NodeMCU

- datele sondajului de la fiecare senzor

- pentru fiecare dintre senzori publicați datele pe un subiect diferit

- în HASS definiți mai mulți senzori (așa cum am făcut cu geiger) care vor asculta diferite subiecte