Luchtkwaliteit volgen met Grafana en Raspberry Pi - Ajarnpa

2024 Auteur: John Day | [email protected]. Laatst gewijzigd: 2024-01-30 11:15

Ik was op zoek naar een klein IOT-project en een vriend raadde me aan deze tutorial te bekijken:

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

Ik raad ten zeerste aan om de tutorial te volgen die moet worden gevolgd bij het instellen van een Raspberry Pi voor monitoring. Deze tutorial voltooit verdere stappen in het ontwerp van een eenvoudig IoT-apparaat dat een hoge fouttolerantie mogelijk maakt, evenals hoe nuttig een Raspberry Pi kan zijn wanneer deze wordt gekoppeld aan Arduino.

Ik ga ook in op de effectiviteit en enigszins beperking van de MQ*-modellen van luchtsensoren. MQ*-sensoren zijn goedkoop en redelijk effectief, en zijn supereenvoudig in te stellen.

Over het algemeen zal dit u helpen om op de eenvoudigste manier aan de slag te gaan met het verbinden van een Arduino met internet en de weg vrijmaken voor het gebruik van lichtere voetafdrukmodules (re: ESP8266).

Veel plezier!

Stap 1: Apparatuur + Opstelling

Apparatuur

• Raspberry Pi met Raspbian geïnstalleerd
• Raspberry Pi-voeding
• Arduino Uno/Equivalent
• Mannelijk naar mannelijk USB type B naar Type A (moet bij uw Arduino worden geleverd)
• Een van de MQ*-sensoren (ik gebruikte de MQ-2, 4, 5 en 135)
• Diverse jumperdraden
• mini breadboard

Opgericht

Deze tutorial is bedoeld als een zachte introductie tot het gebruik van Arduino en Raspberry Pi - het zal helpen om te weten hoe je de linux-terminal moet gebruiken. Ik veronderstel echter niet veel ervaring met het werken aan Arduino of Raspberry Pi - alles wat je echt nodig hebt, is de geleverde apparatuur en een nieuwsgierige houding.

• U moet de stappen in deze zelfstudie voltooien.
• Ik raad je aan om Secure Shell (SSH) te gebruiken om te communiceren met de Raspberry Pi, omdat je hierdoor gemakkelijk opdrachten kunt invoeren. Verbinding maken via SSH verschilt of je Windows, Linux of Mac gebruikt. Linux en Mac zijn vrij eenvoudig te gebruiken met betrekking tot ssh (het commando om SSH te openen is letterlijk ssh). Bekijk Putty voor Windows. Ik raad je aan om het scherm uit te checken als een manier om je sessie tijdens het project te behouden.
• Je moet ook Python op Raspbian installeren. Toen ik deze stappen voltooide, maakte ik een kopie van een oude SD-kaart die ik had liggen van een vorig project, waarop Python al was geïnstalleerd. Als je distributie van NOOBS/Raspbian geen Python 3.7 of hoger heeft, bekijk dan deze stappen om Python vanaf de bron te compileren.
• Maak kennis met git en installeer het voor het geval het nog niet is geïnstalleerd in je distributie van Raspbian.

Stap 2: Het circuit instellen

Er is één circuit dat u in de Arduino moet instellen.

Ik heb een schema gegeven dat u als referentie kunt gebruiken.

Het mooie van alle MQ-*-gassensoren is dat zodra een 5 Volt- en massaverbinding is gemaakt, de ingangsweerstand van de analoge pinnen van de Arduino ervoor zorgt dat de sensor correct werkt.

Zorg ervoor dat de analoge verbinding van het breakout-bord in de sensor is aangesloten op de Arduino en niet op de digitale verbinding. Als u tijdens het testen met een zeer smal bereik van waarden wordt geconfronteerd, raad ik u aan eerst uw verbinding hier te controleren.

Stap 3: Arduino-code en knipperen

In de volgende stap verbinden we het Arduino-bord met de Raspberry Pi. Voordat we dit doen, moeten we de Arduino met code flashen om de sensor te lezen en sensorgegevens naar de Raspberry Pi te verzenden. Dit kan op elke manier die u normaal gesproken code naar de Arduino pusht. Ik heb een tool van derden gebruikt naast de Arduino IDE - vandaar dat ik de Arduino-bibliotheek bovenaan vermeld. Voor andere projecten is dit niet nodig.

Controleer de code die u wilt kopiëren/plakken aan het einde van dit gedeelte.

Wat doet de code?

De code is ingesteld om gegevens van vier verschillende sensoren te verkrijgen - als u verschillende soorten sensoren gebruikt, is het verstandig om de namen op het uitgangssignaal dat vanaf de seriële poort wordt verzonden, te wijzigen.

In de loop controleren we of de Raspberry Pi gegevens bij ons opvraagt. Daarom gebruiken we een zeer eenvoudige Master/Slave-configuratie waarbij de Raspberry Pi voortdurend om gegevens naar de Arduino zal vragen. Dit is veel eenvoudiger dan het hebben van een teller in de Arduino-code, omdat het gemakkelijker is om te testen welke waarden werken vanaf de Raspberry Pi, in plaats van nieuwe waarden naar de Arduino te moeten flashen.

Zodra de Arduino een verzoek om gegevens heeft ontvangen, formatteert hij de uitvoer als een GET-parameter - dit is gerelateerd aan HTTP-methoden en is gewoon een ontwerpkeuze. Als je een communicatieschema van Arduino via de seriële poort zou ontwerpen, zou je gemakkelijk voor iets anders kunnen gaan, zolang je het zo ontwerpt dat de gegevens redelijk gescheiden zijn. Ik heb voor GET gekozen omdat het vertrouwd en robuust is.

Eenvoudig testen…

Zodra u de Arduino hebt geflitst en de code hebt uitgevoerd, opent u de seriële monitor van de Arduino IDE. Als u het enkele teken "H" (zorg voor de hoofdletter!) verzendt, krijgt u de lading aan gegevens. Gefeliciteerd, het werkt!

Een voorbeeld, asynchrone verzamelaar van MQ-*-gegevens

#erbij betrekken

int mq2 = A2;

int mq4 = A3;

int mq5 = A4;

int mq135 = A5;

int inkomendeByte;

voidsetup() {

pinMode (mq2, INGANG);

pinMode (mq4, INGANG);

pinMode (mq5, INGANG);

pinMode (mq135, INGANG);

Serieel.begin(9600);

}

/* valuePrint drukt de waarde voor dit label af.

* Creëert alleen bijwerkingen.

*/

voidvaluePrint(String label, int lezen) {

Serial.print(label);

Serieel.print("=");

Serial.print (lezen);

}

voidloop() {

// kijk of er inkomende seriële gegevens zijn:

if (Serial.available() >0) {

// lees de oudste byte in de seriële buffer:

// "Wanneer u Serial.read aanroept, wordt een byte uit de ontvangstbuffer verwijderd en teruggestuurd naar uw code"

inkomendeByte = Serieel.lezen();

// als het een hoofdletter H is (ASCII 72), lees de waarden en stuur ze naar de Raspberry-host.

// TODO: zorg ervoor dat het bericht altijd even lang is, elke keer

if (inkomende Byte == 72) {

int mq2Reading = analoogRead(mq2);

int mq4Reading = analogRead(mq4);

int mq5Reading = analoogRead(mq5);

int mq135Reading = analoogRead(mq135);

Serieel.print("?");

valuePrint("mq2", mq2Reading);

Serieel.print("&");

valuePrint("mq4", mq4Reading);

Serieel.print("&");

valuePrint("mq5", mq5Reading);

Serieel.print("&");

valuePrint("mq135", mq135Reading);

Serieel.print("\n");

}

}

// lees de serie alleen elke seconde

vertraging (1000);

}

bekijk rawmain.cpp gehost met ❤ door GitHub

Stap 4: Raspberry Pi-code

Nu je de Raspberry Pi hebt geconfigureerd volgens https://dzone.com/articles/raspberry-pi-iot-sensor…, kun je nu de Raspberry Client-code uitvoeren die gegevens via MQTT naar onze database stuurt, die ook verbindt met Grafana.

1. Zorg ervoor dat je Raspberry is verbonden met internet en voer vervolgens een git clone-commando uit om de hele code naar de Raspberry Pi te kopiëren. Je opdracht ziet er een beetje uit als:

   git kloon

2. Voer in de terminal van de Raspberry Pi een change directory-opdracht (cd) uit in "raspberry_client":

   cd raspberry_client.

3. U moet een virtuele omgeving* gebruiken. Eenvoudig. Loop

   python3 -m venv env. Dit zal een virtuele omgeving creëren met de naam "env", die we zullen gebruiken om afhankelijkheden te installeren.

4. Nu moeten we onze virtuele omgeving betreden. Loop:

   bron env/bin/activeren. U bent nu klaar om de afhankelijkheden van het project te installeren.

5. In het pakket dat u zojuist hebt gekloond, bevindt zich een bestand met de naam requirements.txt. Open dit bestand; u zult zien dat we de paho-mqtt- en pyserial-pakketten nodig hebben, evenals hun respectievelijke versies. U kunt de inhoud van het bestand bekijken door het uitvoeren van

   kat vereisten.txt. Om deze pakketten te installeren, ru

   pip install -r requirements.txt.

6. Dit rondt de configuratie af.

Letterlijk elke tutorial die python gebruikt, maakt melding van Virtual env, en zelfs voor dit kleine project zal ik een vermelding maken. Virtuele omgevingen stellen je in staat om versies van afhankelijkheden te scheiden, evenals je python-workflow te scheiden - het is een leuke manier om je Python-werkruimten op te ruimen. Als dit de eerste keer is dat u virtuele omgevingen gebruikt, kunt u deze hier kort lezen.

Wat doet de code…

Het client.py-bestand importeert een eenvoudige set bibliotheken, inclusief onze eigen arduinosensor. In de hoofdfunctie halen we de waarden van de Arduino, publiceren we de gegevens naar de MQTT-broker en slapen we vervolgens 10 seconden.

Het bestand arduinosensor.py is een reeks helpermethoden die zich rond de paho.mqtt-bibliotheek wikkelen en een nuttig communicatieschema bieden voor communicatie met de Arduino's payload (zie: parse_payload). Natuurlijk is de code aan het einde van dit gedeelte bijgevoegd.

Een eenvoudige client die communiceert met een arduino-item via seriële monitor. Verwacht de code hier te vinden wanneer deze openbaar wordt:

fromimportlibimportimport_module

importo's

invoertijd

importarduinosensor

defmain():

# open gedefinieerde client

start_time=time.time()

whileTrue:

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

arduinosensor.pub ("python_client", payload = lezen)

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

if_name_=="_main_":

hoofd()

bekijk rawclient.py gehost met ❤ door GitHub

Stap 5: Alles samenbrengen

We hebben de Raspberry Python-code ingesteld en we hebben de Arduino-clientcode ingesteld. Laten we verder gaan met het verbinden van beide entiteiten.

Laten we eerst de Arduino aansluiten en de juiste configuratie instellen:

1. Voer op uw Raspberry Pi-terminal uit:

   python -m serial.tools.list_ports. Hiermee worden alle USB-poorten weergegeven die seriële communicatie ondersteunen.

2. Sluit nu uw Arduino aan en wacht ongeveer 2 seconden totdat de Raspberry het herkent. Intypen

   python -m serial.tools.list_ports nogmaals toont u de poorten opnieuw. Mogelijk ziet u een extra vermelding verschijnen - als dat inderdaad het geval is, dan is dit nieuwe item het item waarop uw Arduino is aangesloten. Dit wordt waarschijnlijk "/dev/ttyUSB0".

3. Probeer de python-code in uw virtuele omgeving uit te voeren door python3.7 client.py uit te voeren. Wacht een paar seconden (maximaal tien) - als u een uitzondering tegenkomt, betekent dit dat we de waarde voor onze com-poort op de raspberry pi moeten wijzigen. Als je ziet dat de code een regel afdrukt die begint met "Verzonden volgende payload:…" Dan ben je goed om door te gaan naar de laatste stap met Grafana. Tip: zorg ervoor dat je rent

   scherm -S python voordat u de python-client start, anders verliest u uw actieve python-programma wanneer u uw verbinding met uw raspberry pi verbreekt. Technisch gezien hoef je "python" niet strikt als de laatste parameter te gebruiken, maar ik vind het leuk om mijn schermsessies dienovereenkomstig te noemen.

   1. Om de waarde voor de COM-poort te wijzigen, moet u een omgevingsvariabele instellen voordat u de code uitvoert. Je zult dit moeten proberen voor elke mogelijke uitvoerwaarde die je hebt gekregen bij het uitvoeren van python -m serial.tools.list_ports. Als het aantal inzendingen dat ik heb verkregen bijvoorbeeld twee was, en het volgende was:

      • /dev/ttyUSB6
      • /dev/acm0

dan zouden de opdrachten die ik zou uitvoeren zijn:

PORT="/dev/ttyUSB6" python3.7 client.py, en als dat niet zou werken, zou ik vervolgens ru

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

Zodra u deze stappen hebt voltooid, zal de code gegevens vastleggen in onze influxdb-database-instantie die, wanneer verbonden met Grafana, ons in staat zal stellen ons dashboard te bekijken.

Stap 6: Grafana-configuratie en dashboardweergave

Oké, we zijn nu in het laatste stuk! We gaan Grafana nu gebruiken om een eenvoudig dashboard te maken.

1. Maak verbinding met uw Grafana-instantie. Aangezien je de stappen van het originele dzone-artikel hebt gevolgd, zou je in staat moeten zijn om in te loggen met je administrator-gebruiker. Ga je gang en log in.
2. Plaats in het linkerdeelvenster de muisaanwijzer op het pictogram 'dashboards' - de vier vierkanten. Klik op "Beheren".
3. Klik op de nieuwe pagina op "Nieuw dashboard". Klik verder op "Nieuw paneel toevoegen".

4. Dit opent de Grafana-editor. We maken een eenvoudige weergave met een enkele statistiek.

   1. Wijzig in het rechterdeelvenster de titel van het paneel in iets zinvols, zoals 'Keukenlezingen'. U kunt ook een optionele Beschrijving invoeren.
   2. Linksonder, "Query", voegen we een enkele tijdreeks toe. Grafana schittert hier echt omdat we eenvoudig SQL-statements kunnen maken met een op klikken gebaseerde interface. Kies onder "standaard" InfluxDB.
   3. Nu, voor het lezen van "A" - in de FROM-clausule, selecteer meting "airtestt". Als je naar de originele python-code kijkt in de functie get_values van arduinosensor.py, zul je zien dat we deze airtestt-tabel in de code definiëren.
   4. Laten we voor een voorbeeld naar de clausule "SELECT" gaan en field(mq4) kiezen. Oorspronkelijk zal ons dashboard ons de keuze "gemiddelde ()" geven - klik op deze keuze en selecteer "Verwijderen". klik vervolgens op het plusteken en kies onder "Aggregaties" voor "distinct()". Dit toont specifieke tijdstippen. We kunnen andere maatregelen kiezen, maar voor nu zal ons panel verschillende metingen van mq4 laten zien.
   5. Klik rechtsboven op Opslaan en je bent klaar!

In het geval dat u problemen ondervindt, kunt u uw instellingen verifiëren met die in de bijgevoegde schermafbeelding.

Stap 7: Afsluiten

In deze tutorial kon je een robuust MQTT-netwerk opzetten dat bestaat uit een enkele node en een broker. Je was ook in staat om je IOT-gegevens te visualiseren met Grafana. Ten slotte kon je deze eenvoudige systeemarchitectuur samenstellen vanuit (hopelijk) het comfort van je browser en pc via een SSH-verbinding.

Er zijn een aantal dingen die we misschien willen verbeteren.

• De sensormetingen in onze grafiek zijn niet echt nauwkeurige sensormetingen - ze zijn de uitgangsspanning van onze sensor. Ze moeten gekalibreerd worden, raadpleeg deze blogpost voor meer details.
• Onze Raspberry Pi-configuratie kan veel lichter worden gemaakt door een ESP8266-bord te gebruiken dat op de Arduino is aangesloten en de pi volledig te verwijderen. Bekijk een intro van de ESP8266-module.
• Mogelijk willen we waarschuwingen toevoegen voor specifieke evenementen. Gelukkig biedt Grafana een manier om dat te doen.

Ik zal wat verder lezen om je fantasie te prikkelen met de wereld van IOT. Ik kijk ernaar uit je te zien in de volgende instructable!

Verdere lezingen: