Spåra luftkvalitet med Grafana och Raspberry Pi: 7 steg

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

Jag letade efter ett litet litet IOT -projekt och en vän rekommenderade att jag kollade in denna handledning:

dzone.com/articles/raspberry-pi-iot-sensor…

Jag rekommenderar starkt att du följer handledningen för att följa med när du konfigurerar en Raspberry Pi för övervakning. Denna handledning kommer att slutföra ytterligare steg i utformningen av en enkel IoT -enhet som möjliggör en hög feltolerans, samt hur användbar en Raspberry Pi kan vara när den kopplas ihop med Arduino.

Jag går också in på effektiviteten och något begränsning av MQ* -modellerna för luftsensorer. MQ* -sensorer är billiga och ganska effektiva och är superenkla att installera.

Sammantaget hjälper det dig att komma igång med att ansluta en Arduino till internet på det enklaste sättet och sätta vägen för att använda lättare fotavtrycksmoduler (re: ESP8266).

Ha så kul!

Steg 1: Utrustning + Uppställning

Utrustning

• Raspberry Pi med Raspbian installerat
• Raspberry Pi strömförsörjning
• Arduino Uno/ekvivalent
• Man till man USB typ B till typ A (bör levereras med din Arduino)
• Alla MQ* -sensorer (jag använde MQ-2, 4, 5 och 135)
• Blandade tröjor
• mini brödbräda

Uppstart

Denna handledning är avsedd som ett försiktigt introduktion till att använda Arduino och Raspberry Pi - det hjälper dig att veta hur du använder Linux -terminalen. Jag antar dock inte mycket erfarenhet av att arbeta med Arduino eller Raspberry Pi - allt du verkligen behöver är utrustningen och en nyfiken inställning.

• Du måste slutföra stegen i den här självstudien.
• Jag rekommenderar att du använder Secure Shell (SSH) för att ansluta till Raspberry Pi, eftersom detta gör att du enkelt kan mata in kommandon. Att ansluta via SSH skiljer sig åt om du använder Windows, Linux eller Mac. Linux och Mac är ganska enkla att använda när det gäller ssh (kommandot för att öppna SSH är bokstavligen ssh). Kolla in Putty för Windows. Jag rekommenderar att du checkar ut skärmen som ett sätt att underhålla din session under projektet.
• Du måste också installera Python på Raspbian. När jag slutförde dessa steg gjorde jag en kopia av ett gammalt SD -kort som jag hade liggande från ett tidigare projekt, som redan hade Python installerat. Om din distribution av NOOBS/Raspbian inte har Python 3.7 eller högre, kolla in dessa steg för att kompilera Python från källan.
• Bekanta dig med git och installera det om det inte redan är installerat i din distribution av Raspbian.

Steg 2: Konfigurera kretsen

Det finns en krets du måste installera i Arduino.

Jag har lagt fram en schema som du kan använda som referens.

Det fina med alla MQ-* gassensorer är att när en 5 Volt- och jordanslutning har gjorts tillåter ingångsmotståndet för Arduinos analoga stift att sensorn fungerar korrekt.

Var noga med att se till att den analoga anslutningen från brytkortet i sensorn är ansluten till Arduino och inte den digitala anslutningen. Om du står inför ett mycket smalt värdeområde vid testning rekommenderar jag att du först kontrollerar din anslutning här.

Steg 3: Arduino -kod och blinkande

I steget efter det här ansluter vi Arduino -kortet till Raspberry Pi. Innan vi gör detta måste vi blinka Arduino med kod för att läsa sensorn samt överföra sensordata till Raspberry Pi. Detta kan göras på alla sätt som du normalt skickar kod till Arduino. Jag använde ett tredjepartsverktyg förutom Arduino IDE - därför inkluderar jag Arduino -biblioteket högst upp. Detta är inte nödvändigt för andra projekt.

Kontrollera koden för att kopiera/klistra in i slutet av detta avsnitt.

Vad gör koden

Koden är inställd för att få data från fyra olika sensorer - om du använder olika typer av sensorer är det klokt att ändra namnen på utsignalen som skickas från serieporten.

I slingan kontrollerar vi om Raspberry Pi begär data från oss. Därför använder vi en mycket enkel Master/Slave -konfiguration där Raspberry Pi kontinuerligt kommer att begära data till Arduino. Detta är mycket enklare än att ha en räknare i Arduino -koden eftersom det är lättare att testa vilka värden som fungerar från Raspberry Pi, istället för att behöva blinka nya värden till Arduino.

Arduino, när den en gång fick en begäran om data, formaterar utmatningen som en GET -parameter - detta är relaterat till HTTP -metoder och är helt enkelt ett designval. Om du skulle utforma ett kommunikationsschema från Arduino via Serial Port, kan du enkelt gå till allt annat, så länge du utformar det så att data är rimligt separerade. Jag valde GET eftersom det är bekant och robust.

Enkel testning …

När du har blinkat Arduino och koden körs, öppna Arduino IDE: s seriella bildskärm. Om du skickar det enda tecknet "H" (se till att det är stort!) Får du nyttolasten med data. Grattis, det fungerar!

Ett exempel, asynkron samlare av MQ-* data

#omfatta

int mq2 = A2;

int mq4 = A3;

int mq5 = A4;

int mq135 = A5;

int inkomingByte;

voidsetup () {

pinMode (mq2, INPUT);

pinMode (mq4, INPUT);

pinMode (mq5, INPUT);

pinMode (mq135, INPUT);

Serial.begin (9600);

}

/* valuePrint skriver ut värdet för denna etikett.

* Skapar endast biverkningar.

*/

voidvaluePrint (String label, int reading) {

Serial.print (etikett);

Serial.print ("=");

Serial.print (läsning);

}

voidloop () {

// se om det finns inkommande seriedata:

if (Serial.available ()> 0) {

// läs den äldsta byten i seriebufferten:

// "När du ringer Serial.read tas en byte bort från mottagningsbufferten och returneras till din kod"

incomingByte = Serial.read ();

// om det är ett stort H (ASCII 72), läs värdena och skicka dem till hallonvärden.

// TODO: se till att meddelandet alltid är lika långt, varje gång

if (incomingByte == 72) {

int mq2Reading = analogRead (mq2);

int mq4Reading = analogRead (mq4);

int mq5Reading = analogRead (mq5);

int mq135Reading = analogRead (mq135);

Serial.print ("?");

valuePrint ("mq2", mq2Reading);

Serial.print ("&");

valuePrint ("mq4", mq4Reading);

Serial.print ("&");

valuePrint ("mq5", mq5Reading);

Serial.print ("&");

valuePrint ("mq135", mq135Reading);

Serial.print ("\ n");

}

}

// läser serien bara varje sekund

fördröjning (1000);

}

visa rawmain.cpp värd med ❤ av GitHub

Steg 4: Raspberry Pi -kod

Nu när du har konfigurerat Raspberry Pi enligt https://dzone.com/articles/raspberry-pi-iot-sensor…, kan du nu köra Raspberry Client-koden som skickar data via MQTT till vår databas, som också ansluter till Grafana.

1. Se till att ditt hallon är anslutet till internet och utför sedan ett git -klonkommando för att kopiera hela koden till Raspberry Pi. Ditt kommando kommer att se ut lite som:

   git -klon

2. Utför Raspberry Pi -terminalen, utför ett kommando för ändringskatalog (cd) till "raspberry_client":

   cd raspberry_client.

3. Du måste använda en virtuell miljö*. Enkel. Springa

   python3 -m venv env. Detta skapar en virtuell miljö som kallas "env" som vi kommer att använda för att installera beroenden.

4. Nu måste vi gå in i vår virtuella miljö. Springa:

   källa env/bin/aktivera. Du är nu redo att installera beroenden för projektet.

5. I paketet du just klonade finns en fil som heter requirements.txt. Öppna den här filen; du kommer att se att vi kräver paketet paho-mqtt och pyserial, samt deras respektive versioner. Du kan visa innehållet i filen genom att köra

   kattkrav. text. För att installera dessa paket, ru

   pip install -r krav.txt.

6. Detta avslutar konfigurationen.

Bokstavligen varje handledning som använder python nämner Virtual env, och även för detta lilla projekt kommer jag att nämna. Virtuella miljöer låter dig separera versioner av beroenden, samt separera ditt python -arbetsflöde - Det är ett trevligt sätt att städa upp dina Python -arbetsytor. Om detta är första gången du använder virtuella miljöer, läs kort om dem här.

Vad gör koden …

Filen client.py importerar en enkel uppsättning bibliotek inklusive vår egen arduinosensor. I huvudfunktionen kommer vi att få värdena från Arduino, publicera data till MQTT -mäklaren och sedan sova i 10 sekunder.

Arduinosensor.py -filen är en uppsättning hjälpmetoder som lindas runt paho.mqtt -biblioteket, samt ger ett användbart kommunikationsschema för att kommunicera med Arduinos nyttolast (se: parse_payload). Naturligtvis bifogas koden i slutet av detta avsnitt.

En enkel klient som kommunicerar med ett arduino -objekt via seriell bildskärm. Räkna med att hitta koden här när den blir offentlig:

frånimportlibimportimport_module

importos

importtid

importarduinosensor

defmain ():

# öppen definierad klient

start_time = time.time ()

whileTrue:

läsning = arduinosensor.get_values (os.environ.get ('PORT', "/dev/ttyUSB0"))

arduinosensor.pub ("python_client", nyttolast = läsning)

time.sleep (10.0- ((time.time () -start_time) %10.0))

if_name _ == "_ main_":

main ()

visa rawclient.py värd med ❤ av GitHub

Steg 5: Sätta ihop allt

Vi har konfigurerat Raspberry Python -koden och vi har konfigurerat Arduino -klientkoden. Låt oss gå vidare till att ansluta båda enheterna tillsammans.

Låt oss först ansluta Arduino och konfigurera rätt konfiguration:

1. Kör på din Raspberry Pi -terminal

   python -m serial.tools.list_ports. Detta visar alla USB -portar som stöder seriell kommunikation.

2. Anslut nu din Arduino och vänta cirka 2 sekunder tills hallon känner igen den. Skriver in

   python -m serial.tools.list_ports en gång till kommer att visa dig portarna igen. Du kan se en ytterligare lista visas - om det verkligen är så är den här nya posten posten som din Arduino är ansluten till. Detta kommer sannolikt att vara "/dev/ttyUSB0".

3. Prova att köra pythonkoden i din virtuella miljö genom att köra python3.7 client.py. Vänta några sekunder (högst tio) - om du möter ett undantag betyder det att vi måste ändra värdet för vår com port på hallon pi. Om du ser att koden skriver ut en rad som börjar med "Skickat efter nyttolast: …" Då är det bra att gå vidare till det sista steget med Grafana. Tips: se till att springa

   skärm -S python innan du startar python -klienten, annars kommer du att förlora ditt python -program när du avslutar din anslutning till din hallon pi. Tekniskt sett behöver du inte strikt använda "python" som den sista parametern, men jag gillar att namnge mina skärmsessioner därefter.

1. För att ändra värdet för COM -porten måste du ställa in en miljövariabel innan du kör koden. Du måste prova detta för alla möjliga värden för utdata du fick när du kör python -m serial.tools.list_ports. Till exempel om mängden poster jag fick var två och var följande:

   • /dev/ttyUSB6
   • /dev/acm0

då skulle kommandona jag kör vara:

PORT = "/dev/ttyUSB6" python3.7 client.py, och om det inte skulle fungera, skulle jag därefter ru

PORT = "/dev/acm0" python3.7 client.py

När du har slutfört dessa steg kommer koden att överlämna data till vår inströmdatabasinstans, som när vi är anslutna till Grafana gör att vi kan se vår instrumentpanel.

Steg 6: Grafana Configuration och Dashboard Viewing

Okej, vi är nu i sista sträckan! Vi kommer nu att använda Grafana för att skapa en enkel instrumentpanel.

1. Anslut till din Grafana -instans. Eftersom du följde stegen från den ursprungliga dzone -artikeln bör du kunna logga in med din administratörsanvändare. Fortsätt och logga in.
2. Håll muspekaren över ikonen "instrumentpaneler" - de fyra rutorna i den vänstra rutan. Klicka på "Hantera".
3. Klicka på "Ny instrumentpanel" på den nya sidan. Klicka vidare på "Lägg till ny panel".

4. Detta öppnar Grafana -redigeraren. Vi skapar en enkel vy som visar ett enda mått.

   1. I den högra rutan ändrar du paneltiteln till något meningsfullt, till exempel "köksavläsningar". Du kan också ange en valfri beskrivning.
   2. Längst ner till vänster, "Fråga", lägger vi till en enda tidsserie. Grafana lyser verkligen här eftersom vi enkelt kan skapa SQL -satser med ett klickbaserat gränssnitt. Under "standard" väljer du InfluxDB.
   3. Nu, för att läsa "A" - i FROM -satsen, välj mätning "airtestt". Om du tittar på den ursprungliga pythonkoden i funktionen get_values för arduinosensor.py ser du att vi definierar denna airtestt -tabell i koden.
   4. För ett exempel, låt oss gå till "SELECT" -klausulen och välj fält (mq4). Ursprungligen kommer vår instrumentpanel att ge oss valet "mean ()" - klicka på det här alternativet och välj "Ta bort". klicka sedan på plustecknet och välj "distinkt ()" under "Aggregationer". Detta visar specifika tidpunkter. Vi kan välja andra mått men för närvarande kommer vår panel att visa distinkta avläsningar från mq4.
   5. Klicka på Spara längst upp till höger och du är klar!

Om du stöter på problem kan du verifiera dina inställningar med de i den bifogade skärmdumpen.

Steg 7: Avsluta

I denna handledning kunde du skapa ett robust MQTT -nätverk som består av en enda nod och mäklare. Du kunde också visualisera dina IOT -data med Grafana. Slutligen kunde du komponera denna enkla systemarkitektur från (förhoppningsvis) bekvämligheten i din webbläsare och dator via användning av en SSH -anslutning.

Det finns några saker vi kanske vill förbättra.

• Sensoravläsningarna i vårt diagram är faktiskt inte korrekta sensoravläsningar - de är utspänningen från vår sensor. De måste kalibreras, konsultera detta blogginlägg för mer information.
• Vår hallon pi -konfiguration kan göras mycket lättare genom att använda ett ESP8266 -kort anslutet till arduino och ta bort pi helt. Kolla in ett introduktion till ESP8266 -modulen.
• Vi kanske vill lägga till varningar för specifika händelser. Tack och lov erbjuder Grafana ett sätt att göra det.

Jag kommer att lämna lite mer läsning för att locka din fantasi med världen av IOT. Jag ser fram emot att se dig i nästa instruerbara!

Ytterligare läsningar: