Hemassistent Geiger Counter Integration: 8 steg

2024 Författare: John Day | [email protected]. Senast ändrad: 2024-01-30 12:38

I den här handledningen kommer jag att visa hur du lägger till anpassade sensorer till HASS (hemassistent) mer specifikt en geigermätare men processen liknar andra sensorer också.

Vi kommer att använda NodeMCU -kortet, en arduino -baserad geigerdisk och en redan installerad hemassistent.

Integrationen kommer att baseras på en MQTT -server (offentlig eller privat) och jag ska ta dig steg för steg med detta.

Om du inte vet vad som är hemassistent, besök deras sida https://www.home-assistant.io/. Det är en välkänd hemautomatiseringsplattform som är mycket väl underhållen och mycket anpassningsbar.

Du lär dig om:

- avancerad konfiguration för Home Assistant

- NodeMCU (utvecklingskort) och hur man programmerar det med Arduino IDE

- OTA (via luften -uppdateringar) med Arduino IDE för NodeMCU -kortet

- hur man ansluter en seriell enhet till NodeMCU

- manuell installation av en MQTT -server på Linux (tillval)

Grundantaganden:

- du har Home Assistant igång

- du kan lite om elektronik

- du har Arduino IDE installerat

Steg 1: Delar och verktyg

Delar:

1. NodeMCU -kort

2. brödbord

3. manliga-manliga och manliga-kvinnliga jupertrådar

3. usb till micro usb kabel

4. arduino geiger -räknare med seriellt gränssnitt

(sök på Ebay efter "arduino geiger couter")

5. radioaktivt material (valfritt litet testprov)

Verktyg:

1. Arduino IDE

2. Home Assistant installerad

Steg 2: Arbetsprincip

Vårt mål är att visa på HomeAssistat (HASS) avläsningarna från geigerdisken. På ena sidan har vi en HASS -server igång någonstans kan det vara en hallon pi eller annan enhet och på andra sidan har vi geigerdisken.

Geiger -räknaren har en serieport, en lösning är att ansluta den seriella porten direkt till RaspberryPi som HASS körs på.

Några skäl till varför det kanske inte är en bra idé:

- det finns inget fysiskt utrymme där

- vi har någon annan enhet på serieporten

- vi vill fästa en miljösensor som ska placeras utanför istället för geigerdisken

Ok, så vi ska utforska en annan möjlighet att göra anslutningen via WIFI:

HASS stöder avläsning av sensordata och visar att den här typen av servern via en MQTT -server är en lättviktsanslutning för små enheter, en enhet publicerar ett meddelande om ett "ämne" den andra lyssnar på det ämnet för att ta emot meddelandet. Så HASS kommer att lyssna, och vi behöver något som kommer att publicera meddelandet.

Vår sensor vet bara att prata över serielinjen så vi använder ett kort som kan läsa en seriell linje och som kan ansluta via WIFI och prata med MQTT -servern. En billig bräda som gör detta är NodeMCU.

NodeMCU kan programmeras med Arduino IDE. Skissen är ganska enkel, den gör följande:

- ansluter till WIFI

- upprätthåller en MQTT -anslutning med servern och försöker igen om anslutningen misslyckas eller kopplas bort

- lyssnar på inkommande seriell data som en serie heltal

- när ett heltal anländer skickar det det via MQTT till ett specifikt ämne

Steg 3: Montera enheten

Vi kommer att använda brödbrädor och trådar så det är ganska enkelt, vi har några steg:

- lägg NodeMCU på panelen

- anslut geigerröret till geigerdisken (se upp för polaritet)

- VIN går till geiger counter +

- GND går till geigerdisk -

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

- NodeMCU D8 (stift 15) går till geiger RX

- ström NodeMCU via mikro -USB från datorn

Steg 4: Ladda upp koden

Vi kommer att använda Arduino IDE och vi ser till att vi har NodeMCU -kortet installerat och Adafruit_MQTT -biblioteket installerat.

1. Klona github -förvaret: https://github.com/danionescu0/arduino och kopiera skissen från projekt/HASSGeigerIntegration till din arduino skissbok plats

2. Öppna Arduino IDE och installera NodeMCU

- gå till Arkiv -> Inställningar, i Extra Boards Manager URL: er lägger du till https://arduino.esp8266.com/stable/package_esp8266com_index.json om du redan har något lägger du en koma framför och klickar ok

-från Verktyg -> Board -> Board Manager skriver "nodemcu" och väljer posten esp8266 av ESP8266 Community och trycker på installera

3. Installera Adafruit_MQTT

-gå till Verktyg -> Hantera bibliotek -> sök "Adafruit_MQTT" och installera "Arduino MQTT -bibliotek"

4. Anslut USB -kabeln i datorn och konfigurera kortet:

-gå till Verktyg -> Board -> välj NodeMcu 1.0

-Verktyg -> Port -> din USB -port

- lämna de andra inställningarna oförändrade

4. Ändra dina WIFI -uppgifter i skissen så att de matchar dina egna:

#define STASSID "ssid" // Ersätt med ditt WIFI SSID

#define STAPSK "pass" // Ersätt med ditt WIFI -lösenord

5. Ladda upp skissen till ditt bräde och återställ kortet från knappen efter uppladdningen

6. Öppna seriell bildskärm, om allt har gått bra bör du se en viss utdata så här:

Uppstart

IP -adress: 192.168.1.168 OTA aktiverad Ansluter till MQTT … MQTT Connected! {"strålning": 0,03}..

Steg 5: Konfigurera HomeAssistant

Vi antar att du har hemassistent igång. På mitt system har jag HASSOS version 3.12 på en RaspberryPi. Om din version av hemassistent är för gammal eller mycket ny kan vissa funktioner skilja sig åt. Denna handledning fungerar säkert med 3.12 -versionen.

Om du inte har Home Assistant installerad, kolla in deras officiella installationsguide:

Innan du fortsätter med installationen, se till att NodeMCU är ansluten och publicerar data.

Ok, vi kommer också att ha en rad steg för konfigurationen:

1. Installera "filredigerare" om du inte har det i menyn, här är den officiella självstudien:

2. Redigera filen "/config/configuration.yaml" och lägg till följande och spara den

- avsnittet mqtt om du inte redan har det

mqtt:

mäklare: broker.hivemq.com discovery: true discovery_prefix: ha

- sensorsektionen

sensor:

- plattform: mqtt namn: "Strålning" state_topic: "ha/strålning" enhet_mätning: 'uSv' unik_id: "strålning" value_template: "{{value_json.radiation}}"

3. Från konfiguration -> serverkontroller: tryck på "Kontrollera konfiguration", kontrollera om det finns fel på yaml -konfigurationsfilen och tryck sedan på "starta om" och vänta tills den startas om

4. Från Översikt -> Övre högra hörnmenyn -> Konfigurera användargränssnitt -> tryck på + -knappen längst ned till höger

5. Välj "sensor" från listan -> i fältet "enhet" sök efter "sensor.radiation", skriv "Radiation" i namnfältet och klicka på ok, det borde vara på huvudsidan nu

Steg 6: Konfigurera din egen MQTT -server [Valfritt]

Låt oss diskutera lite om MQTT

“MQTT är ett klient server publicera/prenumerera på meddelandetransportprotokoll. Den är lätt, öppen, enkel och utformad för att vara enkel att implementera. Dessa egenskaper gör den idealisk för användning i många situationer, inklusive begränsade miljöer som för kommunikation i Machine to Machine (M2M) och Internet of Things (IoT) -sammanhang där ett litet kodavtryck krävs och/eller nätverksbandbredd är högt.”

Citering från den officiella MQTT 3.1.1 -specifikationen.

Så i princip kan vi publicera ett meddelande någonstans på ena sidan och på andra sidan kan vi lyssna efter dessa meddelanden och göra något med data. MQTT stödjer "ämnen", ämnen är strängar som mäklaren använder för att filtrera meddelanden för varje klient, så om vi publicerar ett meddelande till "/strålning" -ämnet måste en lyssnare prenumerera på samma ämne för att få meddelandena som vi skickar.

Här är en bra handledning om MQTT i detalj:

Med den kostnadsfria bikupa -servern finns det några nackdelar som:

- alla som lyssnar på ditt ämne får dina meddelanden

- om det går ner eller kräver betalning senare kommer du inte att kunna använda det (om du inte betalar)

- om någon som publicerar meddelanden till samma ämne du också får sina meddelanden, kan de publicera inkompatibla meddelanden och bryta dina HASS -diagram

Använda en privat server

Om du inte vill använda den offentliga fria servern har du möjlighet till en privat server. Vi ska installera Mosquitto MQTT på en ubuntu / debian -server som en hallon -pi eller dator.

Mosquitto är en server som implementerar MQTT -protokoll och det är gratis.

För att installera det loggar du in på din raspnerry pi eller annan debianbaserad server och kör:

sudo apt uppdatering

sudo apt installera -y mygga mygg -klienter sudo systemctl aktivera mosquitto.service

Detta kommer att uppdatera förvaret, installera myggserver och klient och göra det möjligt att köra en tjänst vid start

För att få servern ip kör:

värdnamn -I

och det kommer att mata ut något liknande:

192.168.1.52 172.17.0.1 172.18.0.1

Så min ip är 192.168.1.52, i kommandona nedan ersätt den med din egen ip

Du kan testa MQTT -servern genom att publicera ett meddelande och ta emot det med konsolverktyget, för dessa två terminaler måste öppnas en som lyssnar efter ett meddelande, en som publicerar meddelandet.

Kör först det här kommandot i en terminal för att lyssna efter ett meddelande om "/some-topic"

mosquitto_sub -h 192.168.1.52 -t /some -topic

Öppna en annan terminal och publicera ett meddelande till det ämnet:

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

I den första terminalen bör du se "{" luftfuktighet ": 74.0}" utskriven.

Särskild uppmärksamhet:

- denna inställning förutsätter att HASS, Mosquitto och NodeMCU är anslutna till samma WIFI -nätverk och det finns inga brandväggsregler och de kan kommunicera fritt

-Mosquitt MQTT-servern har inget användarnamn/lösenord, om du vill konfigurera inloggningsuppgifter kolla in detta: https://www.steves-internet-guide.com/mqtt-username-password-example/ Du måste också konfigurera referenserna i Home Assistant och i arduino -skissen

Steg 7: OTA (Over the Air Updates) för NodeMCU

Uppdateringar över luften innebär att utvecklingskortet kan blinka trådlöst utan att behöva en fysisk kabel.

Arduino IDE stöder denna funktionalitet för ESP8266 -serien och några andra kort:

- kräver inledande blixt över USB -kabeln

- skapar en virtuell port över WIFI och den är endast synlig från Arduino IDE

- ingen seriell felsökningsinformation finns tillgänglig

- stöder skydd med lösenord

För att aktivera OTA i en ESP8266 -skiss, inkludera först biblioteket:

#inkludera "ArduinoOTA.h"

Definiera också denna skisslösenordskonstant:

#define SKETCHPASS "some_password"

Lägg till dessa rader i installationsdelen:

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

Serial.println ("Anslutningen misslyckades! Startar om …"); fördröjning (5000); ESP.start (); } ArduinoOTA.setPassword (SKETCHPASS); ArduinoOTA.onStart ( () {String type; if (ArduinoOTA.getCommand () == U_FLASH) {type = "sketch";} else {// U_FS type = "filesystem";} Serial.println ("Börja uppdatera " + typ);}); 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 fel) {Serial.printf ("Fel [%u]:", fel); om (fel == OTA_AUTH_ERROR) {Serial.println ("Auth Failed");} annars om (fel == OTA_BEGIN_ERROR) {Serial.println ("Börja misslyckades");} annars om (error == OTA_CONNECT_ERROR) {Serial.println ("Anslutning misslyckades");} annars om (fel == OTA_RECEIVE_ERROR) {Serial.println (" Ta emot misslyckad ");} annars om (error == OTA_END_ERROR) {Serial.println (" Slutet misslyckades ");}}); ArduinoOTA.begin (); Serial.print ("IP -adress:"); Serial.println (WiFi.localIP ());

Och i loop -sektionen lägger du till den här raden:

ArduinoOTA.handtag ();

Efter din första koduppladdning när kortet startar upp bör du se två typer av portar i Arduino IDE i Verktygs-> Port-sektionen:

Seriella portar: /dev /ttyUSB0 (till exempel)

Nätverksportar: esp8266-xxxxx på 192.168.1.xxx

Nu kan du välja nätverksport och ladda upp skissfjärrkontrollen, du kommer att bli ombedd att skissa lösenordet (det som du har definierat i en konstant ovan)

Steg 8: Slutsatser, framtida arbete

Denna handledning kan enkelt ändras för att skicka data om andra typer av sensorer:

- om din sensor stöds direkt av NodeMCU genom ett bibliotek, samla bara data från sensorn och tryck den direkt genom MQTT

- om sensorbiblioteket inte fungerar med NodeMCU men det bara är för Arduino, ladda sedan upp din kod till arduino, mata ut värdet via seriell raden och läs det i NodeMCU och tryck på det (precis som vi gjorde med geigerräknaren)

Vi kan till och med ändra den för att skicka data från flera sensorer så här:

- anslut dina sensorer till NodeMCU

- undersökningsdata från varje sensor

- för var och en av sensorn publicera data till ett annat ämne

- i HASS definiera flera sensorer (som vi gjorde med geiger) som kommer att lyssna på olika ämnen