Home Assistant Geiger Counter Integration: 8 trin

2024 Forfatter: John Day | [email protected]. Sidst ændret: 2024-01-30 08:26

I denne vejledning vil jeg vise, hvordan du tilføjer brugerdefinerede sensorer til HASS (hjemmeassistent) mere specifikt en geigertæller, men processen ligner også andre sensorer.

Vi bruger NodeMCU -kortet, en arduino -baseret geigertæller og en allerede installeret hjemmeassistent.

Integrationen vil være baseret på en MQTT -server (offentlig eller privat), og jeg tager dig trin for trin med dette.

Hvis du ikke ved, hvad der er hjemmeassistent, kan du besøge deres side https://www.home-assistant.io/. Det er en velkendt hjemmeautomatiseringsplatform, der er meget velholdt og meget tilpasselig.

Du lærer om:

- avanceret konfiguration til Home Assistant

- NodeMCU (udviklingstavle) og hvordan man programmerer det med Arduino IDE

- OTA (over the air -opdateringer) ved hjælp af Arduino IDE til NodeMCU -kortet

- hvordan man tilslutter en seriel enhed til NodeMCU

- manuel installation af en MQTT -server på linux (valgfrit)

Grundlæggende antagelser:

- du har Home Assistant i gang

- du ved lidt om elektronik

- du har Arduino IDE installeret

Trin 1: Dele og værktøjer

Dele:

1. NodeMCU -kort

2. brødbord

3. han-han og han-hun juper ledninger

3. usb til mikro usb kabel

4. arduino geigertæller med seriel grænseflade

(søg på Ebay efter "arduino geiger couter")

5. radioaktivt materiale (valgfri en lille testprøve)

Værktøjer:

1. Arduino IDE

2. Hjemmeassistent installeret

Trin 2: Arbejdsprincip

Vores mål er at vise på HomeAssistat (HASS) målingerne fra geigertælleren. På den ene side har vi en HASS -server i gang et sted, det kan være en hindbærpi eller anden enhed, og på den anden side har vi geigertælleren.

Geigertælleren har en seriel port, en løsning vil være at vedhæfte den serielle port direkte til RaspberryPi, som HASS kører på.

Nogle grunde til, at det måske ikke er en god ide:

- der er ikke noget fysisk rum der

- vi har en anden enhed på den serielle port

- vi ønsker at vedhæfte en miljøsensor, der skal placeres udenfor i stedet for geigertælleren

Ok, så vi vil undersøge en anden mulighed for at oprette forbindelse via WIFI:

HASS understøtter læsning af sensordata og viser, at denne form for server via en MQTT -server er en let vægtforbindelse for små enheder, den ene enhed udgiver en besked om et "emne", den anden lytter om emnet for at modtage meddelelsen. Så HASS vil lytte, og vi har brug for noget, der vil offentliggøre meddelelsen.

Vores sensor ved kun at tale over den serielle linje, så vi bruger et kort, der kan læse en seriel linje, og som kan forbinde via WIFI og tale med MQTT -serveren. Et billigt bord, der gør dette, er NodeMCU.

NodeMCU kan programmeres med Arduino IDE. Skitsen er ret enkel, den gør følgende:

- opretter forbindelse til WIFI

- opretholder en MQTT -forbindelse med serveren og prøver forbindelsen igen, når den mislykkes eller afbrydes

- lytter til serielle indgående data som en række heltal

- når et helt tal ankommer, sender det det gennem MQTT til et specifikt emne

Trin 3: Saml enheden

Vi bruger brødbrætter og ledninger, så det er ret enkelt, vi har et par trin:

- læg NodeMCU på brødbrættet

- tilslut geigerrøret til geigertælleren (pas på polaritet)

- VIN går til geigertæller +

- GND går til geigertæller -

- NodeMCU D7 (pin 13) går til geiger TX

- NodeMCU D8 (pin 15) går til geiger RX

- strøm NodeMCU via mikro -USB fra computeren

Trin 4: Upload koden

Vi kommer til at bruge Arduino IDE, og vi vil sikre, at vi har NodeMCU -kortet installeret og Adafruit_MQTT -biblioteket installeret.

1. Klon github -depotet: https://github.com/danionescu0/arduino og kopier skitsen fra projekter/HASSGeigerIntegration til din arduino -skitsebogs placering

2. Åbn Arduino IDE, og installer NodeMCU

- gå til Fil -> Præferencer, i Supplerende Boards Manager URL'er tilføj https://arduino.esp8266.com/stable/package_esp8266com_index.json hvis du allerede har noget der, kom en koma foran og klik ok

-fra Værktøjer -> Board -> Board Manager skriv "nodemcu" og vælg posten esp8266 af ESP8266 Community, og tryk på installer

3. Installer Adafruit_MQTT

-gå til Værktøjer -> Administrer biblioteker -> søg "Adafruit_MQTT" og installer "Arduino MQTT bibliotek"

4. Tilslut USB -kablet i din computer, og konfigurer kortet:

-gå til Værktøjer -> Board -> vælg NodeMcu 1.0

-Værktøjer -> Port -> din USB -port

- lad de andre indstillinger være uændrede

4. I skitsen skal du ændre dine WIFI -legitimationsoplysninger til at matche dine egne:

#define STASSID "ssid" // Udskift med dit WIFI SSID

#define STAPSK "pass" // Udskift med din WIFI -adgangskode

5. Upload skitsen til dit bræt, og efter upload nulstil tavlen fra knappen

6. Åbn den serielle skærm, hvis alt er gået godt, skal du se noget output som dette:

Opstart

IP -adresse: 192.168.1.168 OTA aktiveret Opretter forbindelse til MQTT … MQTT Connected! {"stråling": 0,03}..

Trin 5: Konfigurer HomeAssistant

Vi går ud fra, at du har hjemmeassistent i gang. På mit system har jeg HASSOS version 3.12 på en RaspberryPi. Hvis din version af hjemmeassistent er for gammel eller meget ny, kan nogle funktioner variere. Denne vejledning fungerer helt sikkert med 3.12 version.

Hvis du ikke har Home Assistant installeret, kan du tjekke deres officielle installationsguide:

Inden du går videre med installationen, skal du kontrollere, at NodeMCU er tilsluttet, og at den publicerer data.

Ok, vi har også en række trin her for konfigurationen:

1. Installer "fileditor", hvis du ikke har det i menuen, her er den officielle vejledning:

2. Rediger filen "/config/configuration.yaml", tilføj følgende, og gem den

- mqtt -sektionen, hvis du ikke allerede har den

mqtt:

mægler: broker.hivemq.com discovery: true discovery_prefix: ha

- sensorsektionen

sensor:

- platform: mqtt navn: "Stråling" state_topic: "ha/stråling" enhed_for_måling: 'uSv' unik_id: "stråling" value_template: "{{value_json.radiation}}"

3. Fra konfiguration -> Serverkontrol: tryk på "Kontroller konfiguration", tjek yaml -konfigurationsfilen for fejl, og tryk derefter på "genstart" og vent, indtil den er genstartet

4. Fra Oversigt -> Øverste højre hjørne menu -> Konfigurer brugergrænseflade -> tryk på knappen + nederst til højre

5. Vælg "sensor" fra listen -> i "enhed" feltsøgning efter "sensor.radiation", skriv i navnet navn "Stråling", og klik på ok, det skulle være på hovedsiden nu

Trin 6: Konfiguration af din egen MQTT -server [valgfrit]

Lad os diskutere lidt om MQTT

“MQTT er en klientservers publicerings-/abonnementstransportprotokol. Det er let, åbent, enkelt og designet til at være let at implementere. Disse egenskaber gør den ideel til brug i mange situationer, herunder begrænsede miljøer, f.eks. Til kommunikation i maskine til maskine (M2M) og tingenes internet (IoT) sammenhænge, hvor der kræves et lille kodefodaftryk og/eller netværksbåndbredde.”

Henvisning fra den officielle MQTT 3.1.1 -specifikation.

Så dybest set kan vi offentliggøre en besked et sted på den ene side, og på den anden side kan vi lytte efter disse beskeder og gøre noget med dataene. MQTT understøtter "emner", emner er strenge, som mægleren bruger til at filtrere meddelelser for hver klient, så hvis vi offentliggør en meddelelse til "/stråling" emne, skal en lytter abonnere på det samme emne for at få de beskeder, vi sender.

Her er en fantastisk tutorial om MQTT i detaljer:

Ved hjælp af den gratis bikube -server er der nogle ulemper som:

- enhver, der lytter til dit emne, modtager dine beskeder

- hvis den går ned eller kræver betaling senere, kan du ikke bruge den (medmindre du betaler)

- hvis nogen, der udgiver beskeder til det samme emne, også du modtager deres beskeder, kan de offentliggøre inkompatible meddelelser og bryde dine HASS -grafer

Brug af en privat server

Hvis du ikke vil bruge den offentlige gratis server, har du mulighed for en privat server. Vi skal installere Mosquitto MQTT på en ubuntu / debian -server som en hindbærpi eller computer.

Mosquitto er en server, der implementerer MQTT -protokollen, og den er gratis.

For at installere det skal du logge ind på din raspnerry pi eller en anden debian -baseret server og køre:

sudo apt opdatering

sudo apt installere -y mosquitto mosquitto -clients sudo systemctl aktivere mosquitto.service

Dette vil opdatere depotet, installere mygserver og klient og gøre det muligt for en service at køre ved opstart

For at få server ip udfør:

værtsnavn -I

og det udsender noget som:

192.168.1.52 172.17.0.1 172.18.0.1

Så min ip er 192.168.1.52, i kommandoerne herunder erstatte den med din egen ip

Du kan teste MQTT -serveren ved at offentliggøre en meddelelse og modtage den med konsolværktøjet, for disse to terminaler skal åbnes, en der lytter efter en meddelelse, en der vil offentliggøre meddelelsen.

Kør først denne kommando i en terminal for at lytte efter en besked om "/some-topic"

mosquitto_sub -h 192.168.1.52 -t /some -topic

Åbn en anden terminal, og offentliggør en besked til emnet:

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

I den første terminal skulle du se "{" luftfugtighed ": 74.0} 'udskrevet.

Særlig opmærksomhed:

- denne opsætning forudsætter, at HASS, Mosquitto og NodeMCU er forbundet til det samme WIFI -netværk, og der er ingen firewallregler, og de kan kommunikere frit

-Mosquitt MQTT-serveren har intet brugernavn/kodeord, hvis du vil konfigurere legitimationsoplysninger, tjek dette: https://www.steves-internet-guide.com/mqtt-username-password-example/ Du skal også konfigurere legitimationsoplysningerne i Home Assistant og i arduino -skitsen

Trin 7: OTA (Over the Air Updates) for NodeMCU

Over the air -opdateringer betyder, at udviklingskortet kan flashes trådløst uden behov for et fysisk kabel.

Arduino IDE understøtter denne funktionalitet til ESP8266 -serien og nogle andre tavler:

- kræver indledende flash over USB -kablet

- opretter en virtuel port over WIFI, og den er kun synlig fra Arduino IDE

- ingen seriel fejlfindingsinformation er tilgængelig

- understøtter beskyttelse med adgangskode

For at aktivere OTA i en ESP8266 -skitse skal du først inkludere biblioteket:

#inkluderer "ArduinoOTA.h"

Definer også denne skitsekodeordskonstant:

#define SKETCHPASS "some_password"

Tilføj disse linjer i opsætningsafsnittet:

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

Serial.println ("Forbindelsen mislykkedes! Genstart …"); forsinkelse (5000); ESP.restart (); } ArduinoOTA.setPassword (SKETCHPASS); ArduinoOTA.onStart ( () {String type; if (ArduinoOTA.getCommand () == U_FLASH) {type = "sketch";} else {// U_FS type = "filesystem";} Serial.println ("Start opdatering " + type);}); 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 fejl) {Serial.printf ("Fejl [%u]:", fejl); hvis (fejl == OTA_AUTH_ERROR) {Serial.println ("Auth. Mislykkedes");} ellers hvis (fejl == OTA_BEGIN_ERROR) {Serial.println ("Start mislykkedes");} ellers hvis (error == OTA_CONNECT_ERROR) {Serial.println ("Connect mislykkedes");} ellers if (error == OTA_RECEIVE_ERROR) {Serial.println (" Modtag mislykkedes ");} ellers hvis (fejl == OTA_END_ERROR) {Serial.println (" Afslutning mislykkedes ");}}); ArduinoOTA.begin (); Serial.print ("IP -adresse:"); Serial.println (WiFi.localIP ());

Og tilføj denne linje i loop -sektionen:

ArduinoOTA.håndtag ();

Efter din første kodeupload, når brættet er startet op, skal du se to typer porte i Arduino IDE i værktøjs-> portafsnittet:

Serielle porte: /dev /ttyUSB0 (f.eks.)

Netværksporte: esp8266-xxxxx på 192.168.1.xxx

Nu kan du vælge netværksporten og uploade skitse -fjernbetjeningen, du bliver bedt om at skitse adgangskoden (den, du har defineret i en konstant ovenfor)

Trin 8: Konklusioner, fremtidigt arbejde

Denne vejledning kan let ændres til at sende data om andre typer sensorer:

- hvis din sensor understøttes direkte af NodeMCU gennem et bibliotek, skal du blot samle data fra sensoren og skubbe den direkte gennem MQTT

- hvis sensorbiblioteket ikke fungerer med NodeMCU, men det kun er til Arduino, skal du uploade din kode til arduinoen, sende værdien gennem den serielle linje og læse den i NodeMCU og skubbe den (ligesom vi gjorde med geigertælleren)

Vi kan endda ændre det til at sende data fra flere sensorer sådan:

- tilslut dine sensorer til NodeMCU

- afstemningsdata fra hver sensor

- for hver af sensorerne offentliggøre dataene til et andet emne

- i HASS definere flere sensorer (som vi gjorde med geiger), der vil lytte til forskellige emner