Traccia la qualità dell'aria usando Grafana e Raspberry Pi: 7 passaggi

2024 Autore: John Day | [email protected]. Ultima modifica: 2024-01-30 10:01

Stavo cercando un piccolo progetto IOT e un amico mi ha consigliato di dare un'occhiata a questo tutorial:

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

Consiglio vivamente di seguire il tutorial da seguire nella configurazione di un Raspberry Pi per il monitoraggio. Questo tutorial completerà ulteriori passaggi nella progettazione di un semplice dispositivo IoT che consente un'elevata tolleranza agli errori, nonché quanto può essere utile un Raspberry Pi quando associato ad Arduino.

Approfondisco anche l'efficacia e un po' la limitazione dei modelli MQ* di sensori d'aria. I sensori MQ* sono economici e abbastanza efficaci e sono semplicissimi da configurare.

Nel complesso, questo ti aiuterà a iniziare a connettere un Arduino a Internet nel modo più semplice possibile e aprirà la strada all'utilizzo di moduli con footprint più leggeri (ri: ESP8266).

Divertiti!

Passaggio 1: attrezzatura + configurazione

Attrezzatura

• Raspberry Pi con Raspbian installato
• Alimentatore Raspberry Pi
• Arduino Uno/Equivalente
• USB da maschio a maschio da tipo B a tipo A (dovrebbe venire con il tuo Arduino)
• Qualsiasi sensore MQ* (ho usato MQ-2, 4, 5 e 135)
• Ponticelli assortiti
• mini tagliere

Impostare

Questo tutorial è inteso come una delicata introduzione all'uso di Arduino e Raspberry Pi: ti aiuterà a sapere come utilizzare il terminale Linux. Tuttavia, non presumo molta esperienza con il lavoro su Arduino o Raspberry Pi: tutto ciò di cui hai veramente bisogno è l'attrezzatura fornita e un atteggiamento curioso.

• Dovrai completare i passaggi di questo tutorial.
• Ti consiglio di utilizzare Secure Shell (SSH) per interfacciarti con Raspberry Pi, in quanto ciò ti consente di inserire facilmente i comandi. La connessione tramite SSH è diversa se si utilizza Windows, Linux o Mac. Linux e Mac sono abbastanza facili da usare per quanto riguarda ssh (il comando per aprire SSH è letteralmente ssh). Dai un'occhiata a Putty per Windows. Ti consiglio di controllare lo schermo come un modo per mantenere la tua sessione durante il progetto.
• Dovrai anche installare Python su Raspbian. Quando ho completato questi passaggi, ho fatto una copia di una vecchia scheda SD che avevo in giro da un progetto precedente, che aveva già installato Python. Se la tua distribuzione di NOOBS/Raspbian non ha Python 3.7 o versioni successive, controlla questi passaggi per compilare Python dal sorgente.
• Familiarizza con git e installalo nel caso non sia già installato nella tua distribuzione di Raspbian.

Passaggio 2: configurazione del circuito

C'è un circuito che devi configurare in Arduino.

Ho fornito uno schema che puoi usare come riferimento.

La bellezza di tutti i sensori di gas MQ-* è che una volta effettuata una connessione a 5 Volt e Ground, la resistenza di ingresso dei pin analogici di Arduino consente al sensore di funzionare correttamente.

Fare attenzione a garantire che la connessione analogica dalla scheda breakout nel sensore sia collegata ad Arduino e non alla connessione digitale. Se stai affrontando un intervallo di valori molto ristretto durante il test, ti consiglio di controllare prima la tua connessione qui.

Passaggio 3: codice Arduino e lampeggio

Nel passaggio successivo a questo, collegheremo la scheda Arduino al Raspberry Pi. Prima di farlo, dobbiamo eseguire il flashing di Arduino con il codice per leggere il sensore e trasmettere i dati del sensore al Raspberry Pi. Questo può essere fatto in qualsiasi modo tu inserisca normalmente il codice su Arduino. Ho usato uno strumento di terze parti oltre all'IDE Arduino, quindi includo la libreria Arduino in alto. Questo non è necessario per altri progetti.

Controlla il codice da copiare/incollare alla fine di questa sezione.

Cosa fa il codice

Il codice è impostato per ottenere dati da quattro diversi sensori - se si utilizzano diversi tipi di sensori, sarà sensato modificare i nomi sul segnale di uscita inviato dalla porta seriale.

Nel ciclo controlliamo se il Raspberry Pi ci richiede dati. Quindi, stiamo usando una configurazione Master/Slave molto semplice in cui il Raspberry Pi farà continuamente richieste di dati ad Arduino. Questo è molto più semplice che avere un contatore nel codice Arduino perché è più facile testare quali valori funzionano dal Raspberry Pi, invece di dover eseguire il flashing di nuovi valori su Arduino.

L'arduino, una volta ricevuta una richiesta di dati, formatterà l'output come parametro GET - questo è correlato ai metodi HTTP ed è semplicemente una scelta di progettazione. Se dovessi progettare uno schema di comunicazione da Arduino tramite porta seriale, potresti facilmente optare per qualsiasi altra cosa, purché lo progetti in modo che i dati siano ragionevolmente separati. Ho scelto GET perché è familiare e robusto.

Test semplice…

Una volta eseguito il flashing di Arduino e il codice in esecuzione, aprire il monitor seriale dell'IDE di Arduino. Se invii il singolo carattere "H" (assicurati la sua maiuscola!) otterrai il payload dei dati. Complimenti, funziona!

Un campione, raccoglitore asincrono di dati MQ-*

#includere

int mq2 = A2;

int mq4 = A3;

int mq5 = A4;

int mq135 = A5;

int incomingByte;

voidsetup() {

pinMode(mq2, INGRESSO);

pinMode(mq4, INGRESSO);

pinMode(mq5, INGRESSO);

pinMode(mq135, INGRESSO);

Serial.begin(9600);

}

/* valuePrint stampa il valore per questa etichetta.

* Crea solo effetti collaterali.

*/

voidvaluePrint(String label, int reading) {

Serial.print(etichetta);

Serial.print("=");

Serial.print(lettura);

}

voidloop() {

// controlla se ci sono dati seriali in entrata:

if (Serial.available() >0) {

// legge il byte più vecchio nel buffer seriale:

// "Quando chiami Serial.read un byte viene rimosso dal buffer di ricezione e restituito al tuo codice"

incomingByte = Serial.read();

// se è una H maiuscola (ASCII 72), leggi i valori e inviali all'host raspberry.

// TODO: assicurati che il messaggio sia sempre della stessa lunghezza, ogni volta

if (byte in entrata == 72) {

int mq2Lettura = analogRead(mq2);

int mq4Reading = analogRead(mq4);

int mq5Reading = analogRead(mq5);

int mq135Lettura = analogRead(mq135);

Serial.print("?");

valuePrint("mq2", mq2Lettura);

Serial.print("&");

valuePrint("mq4", mq4Lettura);

Serial.print("&");

valuePrint("mq5", mq5Lettura);

Serial.print("&");

valuePrint("mq135", mq135Lettura);

Serial.print("\n");

}

}

// legge il seriale solo ogni secondo

ritardo(1000);

}

visualizza rawmain.cpp ospitato con ❤ da GitHub

Passaggio 4: codice Raspberry Pi

Ora che hai configurato il Raspberry Pi come da https://dzone.com/articles/raspberry-pi-iot-sensor…, ora puoi eseguire il codice Raspberry Client che invierà i dati tramite MQTT al nostro database, che anche si collega a Grafana.

1. Assicurati che il tuo lampone sia connesso a Internet, quindi esegui un comando git clone per copiare l'intero codice sul Raspberry Pi. Il tuo comando assomiglierà un po' a:

   git clone

2. All'interno del terminale di Raspberry Pi, esegui un comando di cambio directory (cd) in "raspberry_client":

   cd raspberry_client.

3. Dovrai utilizzare un ambiente virtuale*. Semplice. Correre

   python3 -m venv env. Questo creerà un ambiente virtuale chiamato "env" che useremo per installare le dipendenze.

4. Ora dobbiamo entrare nel nostro ambiente virtuale. Correre:

   source env/bin/activate. Ora sei pronto per installare le dipendenze del progetto.

5. Nel pacchetto che hai appena clonato c'è un file chiamato require.txt. Apri questo file; vedrai che richiediamo i pacchetti paho-mqtt e pyserial, così come le loro rispettive versioni. Puoi visualizzare il contenuto del file eseguendo

   requisiti del gatto.txt. Per installare questi pacchetti, ru

   pip install -r requisiti.txt.

6. Questo conclude la configurazione.

Letteralmente ogni tutorial che usa Python fa menzione di Virtual env, e anche per questo piccolo progetto, farò una menzione. Gli ambienti virtuali ti consentono di separare le versioni delle dipendenze, oltre a separare il tuo flusso di lavoro Python: è un bel modo per riordinare i tuoi spazi di lavoro Python. Se è la prima volta che utilizzi ambienti virtuali, leggili brevemente qui.

Cosa fa il codice…

Il file client.py importerà un semplice set di librerie incluso il nostro sensore arduino. Nella funzione principale, otterremo i valori da Arduino, pubblicheremo i dati sul broker MQTT e quindi dormiremo per 10 secondi.

Il file arduinosensor.py è un insieme di metodi di supporto che avvolgono la libreria paho.mqtt, oltre a fornire alcuni schemi di comunicazione utili per comunicare con il payload di Arduino (vedi: parse_payload). Naturalmente, il codice è allegato alla fine di questa sezione.

Un semplice client che comunica con un elemento arduino tramite monitor seriale. Aspettati di trovare il codice qui quando sarà pubblico:

fromimportlibimportimport_module

importi

importtime

importarduinosensor

defmain():

# apri client definito

start_time=time.time()

mentreVero:

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

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

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

if_name_=="_main_":

principale()

visualizza rawclient.py ospitato con ❤ da GitHub

Passaggio 5: mettere tutto insieme

Abbiamo configurato il codice Raspberry Python e configurato il codice client Arduino. Passiamo alla connessione di entrambe le entità.

Innanzitutto, colleghiamo Arduino e impostiamo la configurazione corretta:

1. Sul tuo terminale Raspberry Pi, esegui

   python -m serial.tools.list_ports. Questo elencherà tutte le porte USB che supportano la comunicazione seriale.

2. Ora collega il tuo Arduino e attendi circa 2 secondi affinché il Raspberry lo riconosca. digitando

   python -m serial.tools.list_ports ancora una volta ti mostrerà di nuovo le porte. Potresti vedere un elenco aggiuntivo visualizzato - se questo è davvero il caso, allora questa nuova voce è la voce a cui è connesso il tuo Arduino. Probabilmente sarà "/dev/ttyUSB0".

3. Prova a eseguire il codice python all'interno del tuo ambiente virtuale eseguendo python3.7 client.py. Attendi qualche secondo (al massimo dieci) - se incontri un'eccezione, questo significa che dovremo cambiare il valore per la nostra porta com sul raspberry pi. Se vedi che il codice stampa una riga che inizia con "Sent following payload:…" Quindi, sarai pronto per passare al passaggio finale con Grafana. Suggerimento: assicurati di correre

   schermo -S pitone prima di avviare il client python, altrimenti, quando termini la connessione al tuo raspberry pi, perderai il programma python in esecuzione. Tecnicamente, non è necessario utilizzare rigorosamente "python" come ultimo parametro, ma mi piace nominare le mie sessioni dello schermo di conseguenza.

   1. Per modificare il valore della porta COM, sarà necessario impostare una variabile di ambiente prima di eseguire il codice. Dovrai provare questo per ogni possibile valore di output ottenuto durante l'esecuzione di python -m serial.tools.list_ports. Ad esempio, se la quantità di voci che ho ottenuto fosse due, e fosse la seguente:

      • /dev/ttyUSB6
      • /dev/acm0

quindi i comandi che eseguirei sarebbero:

PORT="/dev/ttyUSB6" python3.7 client.py, e se ciò non dovesse funzionare, in seguito avrei ru

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

Una volta completati questi passaggi, il codice impegnerà i dati nella nostra istanza di database influxdb che, una volta connessa a Grafana, ci consentirà di visualizzare la nostra dashboard.

Passaggio 6: configurazione di Grafana e visualizzazione del dashboard

Bene, ora siamo nel tratto finale! Ora useremo Grafana per creare una semplice dashboard.

1. Connettiti alla tua istanza Grafana. Poiché hai seguito i passaggi dell'articolo dzone originale, dovresti essere in grado di accedere con il tuo utente amministratore. Vai avanti e accedi.
2. Nel riquadro di sinistra, passa con il mouse sull'icona "dashboard", i quattro quadrati. Fare clic su "Gestisci".
3. Nella nuova pagina, fai clic su "Nuova dashboard". Inoltre, fai clic su "Aggiungi nuovo pannello".

4. Questo apre l'editor Grafana. Creeremo una visualizzazione semplice che mostra una singola metrica.

   1. Nel riquadro di destra, cambia il titolo del riquadro in qualcosa di significativo, come "Letture in cucina". Puoi anche inserire una descrizione facoltativa.
   2. In basso a sinistra, "Query", aggiungeremo una singola serie temporale. Grafana brilla davvero qui in quanto possiamo facilmente creare istruzioni SQL con un'interfaccia basata su clic. In "predefinito", scegli InfluxDB.
   3. Ora, per leggere "A" - nella clausola FROM, seleziona la misura "airtestt". Se guardi il codice Python originale nella funzione get_values di arduinosensor.py, vedrai che definiamo questa tabella airtestt all'interno del codice.
   4. Per un esempio, andiamo alla clausola "SELECT" e scegliamo field(mq4). Originariamente la nostra dashboard ci darà la scelta "mean ()" - fai clic su questa scelta e seleziona "Rimuovi". quindi, fai clic sul segno più e, in "Aggregazioni" scegli "distinct()". Questo mostrerà punti temporali specifici. Possiamo scegliere altre misure ma per ora il nostro pannello mostrerà letture distinte da mq4.
   5. Fai clic su Salva in alto a destra e il gioco è fatto!

In caso di problemi, puoi verificare le tue impostazioni con quelle nello screenshot allegato.

Passaggio 7: concludere

In questo tutorial sei stato in grado di configurare una solida rete MQTT composta da un singolo nodo e broker. Sei stato anche in grado di visualizzare i tuoi dati IOT utilizzando Grafana. Infine, sei stato in grado di comporre questa semplice architettura di sistema (si spera) comodamente dal tuo browser e PC tramite l'uso di una connessione SSH.

Ci sono alcune cose che potremmo voler migliorare.

• Le letture del sensore nel nostro grafico non sono in realtà letture del sensore accurate: sono la tensione di uscita dal nostro sensore. Devono essere calibrati, consulta questo post sul blog per maggiori dettagli.
• La nostra configurazione raspberry pi può essere resa molto più leggera utilizzando una scheda ESP8266 collegata ad arduino e rimuovendo completamente il pi. Guarda un'introduzione al modulo ESP8266.
• Potremmo voler aggiungere avvisi per eventi specifici. Per fortuna, Grafana offre un modo per farlo.

Lascio qualche ulteriore lettura per invogliare la vostra immaginazione con il mondo di IOT. Non vedo l'ora di vederti nel prossimo istruibile!

Ulteriori letture: