Come costruire un monitor di temperatura Raspberry Pi: 9 passaggi

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

La temperatura e l'umidità sono punti dati vitali nel mondo industriale di oggi. Il monitoraggio dei dati ambientali per le sale server, i congelatori commerciali e le linee di produzione è necessario per mantenere le cose senza intoppi. Ci sono molte soluzioni là fuori che vanno da quelle di base a quelle complesse e può sembrare schiacciante su ciò di cui la tua azienda ha bisogno e da dove cominciare.

Vedremo come monitorare la temperatura con un Raspberry Pi e diversi sensori di temperatura che puoi utilizzare. Questo è un buon punto di partenza poiché queste soluzioni sono poco costose, facili da realizzare e forniscono una base su cui costruire per altri monitoraggi ambientali.

Forniture

• Raspberry Pi (3, 4 o Zero WH)
• Sensore di temperatura (DHT2, DSB18B20, BME280 o Sense HAT)
• Cavo di prolunga da 6" a 40 pin IDE maschio-femmina (soluzione Sense HAT)
• Resistenza 10K, breadboard, scheda breakout a 40 pin + cavo a nastro, fili (per soluzione DSB18B20)

Passaggio 1: Raspberry Pi

Un Raspberry Pi è un computer a scheda singola economico che ti consentirà di collegarti a un sensore di temperatura e trasmettere i dati a un software di visualizzazione dei dati. Raspberry Pi è nato come strumento di apprendimento e si è evoluto in uno strumento di lavoro industriale. La facilità d'uso e la capacità di codificare con Python, il linguaggio di programmazione in più rapida crescita, li ha resi una soluzione ideale.

Avrai bisogno di un Raspberry Pi con WiFi integrato, che sono qualsiasi modello 3, 4 e zero W/WH. Tra quelli che puoi scegliere in base a prezzi e caratteristiche. Lo Zero W/WH è il più economico ma se hai bisogno di più funzionalità puoi scegliere tra il 3 e il 4. Puoi acquistare solo uno Zero W/WH alla volta a causa delle limitazioni della Raspberry Pi Foundation. Qualunque sia il Pi che scegli, assicurati di acquistare un caricabatterie poiché è così che alimenterai il Pi e una scheda SD con Raspbian per rendere l'installazione del sistema operativo il più semplice possibile.

Esistono anche altri computer a scheda singola che possono funzionare, ma questo è per un'altra volta e un altro articolo.

Passaggio 2: sensori

Ci sono tre sensori che consigliamo di utilizzare perché sono economici, facili da collegare e forniscono letture accurate; DSB18B20, DHT22 e CAPPELLO Sense Raspberry Pi.

DHT22 - Questo sensore di temperatura e umidità ha una precisione della temperatura di +/- 0,5 C e un intervallo di umidità da 0 a 100%. È semplice collegare il Raspberry Pi e non richiede resistori di pull-up.

DSB18B20 - Questo sensore di temperatura ha un'uscita digitale, che funziona bene con il Raspberry Pi. Ha tre fili e richiede una breadboard e una resistenza per il collegamento.

BME280 - Questo sensore misura temperatura, umidità e pressione barometrica. Può essere utilizzato sia in SPI che in I2C.

Sense HAT - Questo è un componente aggiuntivo per Raspberry Pi che ha LED, sensori e un piccolo joystick. Si collega direttamente al GPIO sul Raspberry Pi, ma l'utilizzo di un cavo a nastro offre letture della temperatura più accurate.

Passaggio 3: installazione di Raspberry Pi

Se è la prima volta che configuri il tuo Raspberry Pi, dovrai installare il sistema operativo Raspbian e connettere il tuo Pi al WiFi. Ciò richiederà un monitor e una tastiera per connettersi al Pi. Una volta installato e funzionante e connesso al WiFI, il tuo Pi è pronto per l'uso.

Passaggio 4: Conto di stato iniziale

Avrai bisogno di un posto dove inviare i tuoi dati per mantenere un registro storico e visualizzare il flusso di dati in tempo reale, quindi utilizzeremo lo stato iniziale. Vai su https://iot.app.initialstate.com e crea un nuovo account o accedi al tuo account esistente.

Successivamente, dobbiamo installare il modulo Python stato iniziale sul tuo Pi. Al prompt dei comandi (non dimenticare di SSH prima nel tuo Pi), esegui il seguente comando:

$ cd /home/pi/

$ \curl -sSL https://get.initialstate.com/python -o - | sudo bash

Dopo aver inserito il comando curl nel prompt dei comandi, vedrai qualcosa di simile al seguente output sullo schermo:

pi@raspberrypi ~

$ \curl -sSL https://get.initialstate.com/python -o - | sudo bash Password: inizio dell'installazione facile di ISStreamer Python! L'installazione potrebbe richiedere un paio di minuti, prendi un caffè:) Ma non dimenticare di tornare, avrò domande più tardi! Trovato easy_install: setuptools 1.1.6 Trovato pip: pip 1.5.6 da /Library/Python/2.7/site-packages/pip-1.5.6- py2.7.egg (python 2.7) pip major version: 1 pip minor version: 5 ISStreamer trovato, aggiornamento… Requisito già aggiornato: ISStreamer in /Library/Python/2.7/site-packages Pulizia… Vuoi ottenere automaticamente uno script di esempio? [y/N] Dove vuoi salvare l'esempio? [predefinito:./is_example.py] Seleziona quale app stato iniziale stai utilizzando: 1. app.initialstate.com 2. [NOVITÀ!] iot.app.initialstate.com Inserisci la scelta 1 o 2: inserisci iot.app Nome utente.initialstate.com: Inserisci la password iot.app.initialstate.com:

Quando viene richiesto di ottenere automaticamente uno script di esempio, digitare y. Questo creerà uno script di test che possiamo eseguire per assicurarci di poter trasmettere i dati allo stato iniziale. Il prompt successivo ti chiederà dove vuoi salvare il file di esempio. Puoi digitare un percorso locale personalizzato o premere invio per accettare la posizione predefinita. Infine, ti verrà chiesto quale app Stato iniziale stai utilizzando. Se hai creato un account di recente, seleziona l'opzione 2, inserisci nome utente e password. Dopodiché l'installazione sarà completata.

Diamo un'occhiata allo script di esempio che è stato creato.

$ nano è_esempio.py

Sulla riga 15, vedrai una riga che inizia con streamer = Streamer(bucket_ …. Questa riga crea un nuovo bucket di dati denominato "Python Stream Example" ed è associato al tuo account. Questa associazione avviene a causa di access_key="…" parametro su quella stessa riga. Quella lunga serie di lettere e numeri è la chiave di accesso al tuo account di stato iniziale. Se vai al tuo account di stato iniziale nel tuo browser web, fai clic sul tuo nome utente in alto a destra, quindi vai a "le mie impostazioni", troverai la stessa chiave di accesso qui sotto "Chiavi di accesso allo streaming".

Ogni volta che crei un flusso di dati, quella chiave di accesso indirizzerà quel flusso di dati al tuo account (quindi non condividere la tua chiave con nessuno).

Esegui lo script di prova per assicurarci di poter creare un flusso di dati sul tuo account Stato iniziale. Esegui quanto segue:

$ python è_esempio.py

Torna al tuo account di stato iniziale nel tuo browser web. Un nuovo bucket di dati chiamato "Python Stream Example" dovrebbe essere visualizzato a sinistra nel tuo scaffale di registro (potrebbe essere necessario aggiornare la pagina). Fare clic su questo bucket e quindi fare clic sull'icona Waves per visualizzare i dati del test

Se stai usando Python 3 puoi installare l'Initial State Streamer Module che puoi installare usando il seguente comando:

pip3 installa ISStreamer

Ora siamo pronti per configurare il sensore di temperatura con il Pi per trasmettere la temperatura a un cruscotto.

Passaggio 5: soluzione DHT22

Il DHT22 avrà tre pin: 5V, Gnd e dati. Dovrebbe esserci un'etichetta pin per l'alimentazione sul DHT22 (ad es. "+" o "5 V"). Collegalo al pin 2 (il pin in alto a destra, 5V) del Pi. Il pin Gnd sarà etichettato come "-" o "Gnd" o qualcosa di equivalente. Collegalo al pin 6 Gnd (due pin sotto il pin 5V) sul Pi. Il pin rimanente sul DHT22 è il pin dati e sarà etichettato come "out" o "s" o "data". Collegalo a uno dei pin GPIO sul Pi come GPIO4 (pin 7). Una volta che questo è cablato, accendi il tuo Pi.

Installa il modulo Adafruit DHT Python al prompt dei comandi per rendere la lettura dei dati del sensore DHT22 estremamente semplice:

$ sudo pip install Adafruit_DHT

Con il nostro sistema operativo installato insieme ai nostri due moduli Python per la lettura dei dati dei sensori e l'invio dei dati allo stato iniziale, siamo pronti per scrivere il nostro script Python. Il seguente script creerà/si aggiungerà a un bucket di dati dello stato iniziale, leggerà i dati del sensore DHT22 e invierà tali dati a un dashboard in tempo reale. Tutto quello che devi fare è modificare le righe 6–11.

import Adafruit_DHT

from ISStreamer. Streamer import Streamer import time# --------- Impostazioni utente --------- SENSOR_LOCATION_NAME = "Ufficio" BUCKET_NAME = ":partly_sunny: Temperature ambiente" BUCKET_KEY = "rt0129" ACCESS_KEY = "METTI QUI LA TUA CHIAVE DI ACCESSO ALLO STATO INIZIALE" MINUTES_BETWEEN_READS = 10METRIC_UNITS = False # --------------------------------- streamer = Streamer(bucket_name=BUCKET_NAME, bucket_key=BUCKET_KEY, access_key=ACCESS_KEY) while True: umidità, temp_c = Adafruit_DHT.read_retry(Adafruit_DHT. DHT22, 4) if METRIC_UNITS: streamer.log(SENSOR_LOCATION_NAME + " Temperature(C)", temp_c: temp_f = format(temp_c * 9.0 / 5.0 + 32.0, ".2f") streamer.log(SENSOR_LOCATION_NAME + " Temperature(F)", temp_f) umidita = format(humidity, ".2f") streamer.log(SENSOR_LOCATION_NAME + " Umidità(%)", umidità) streamer.flush() time.sleep(60*MINUTES_BETWEEN_READS)

• Riga 6 - Questo valore deve essere univoco per ogni nodo/sensore di temperatura. Questo potrebbe essere il nome della stanza del nodo del sensore, la posizione fisica, l'identificatore univoco o altro. Assicurati solo che sia univoco per ogni nodo per assicurarti che i dati di questo nodo vadano al proprio flusso di dati nella tua dashboard.
• Riga 7: questo è il nome del bucket di dati. Questo può essere modificato in qualsiasi momento nell'interfaccia utente dello stato iniziale.
• Riga 8 - Questa è la tua chiave del secchio. Deve essere la stessa chiave del bucket per ogni nodo che desideri venga visualizzato nella stessa dashboard.
• Riga 9 - Questa è la chiave di accesso all'account dello stato iniziale. Copia e incolla questa chiave dal tuo account Stato iniziale.
• Riga 10 - Questo è il tempo tra le letture del sensore. Cambia di conseguenza.
• Riga 11: è possibile specificare unità metriche o imperiali sulla riga 11.

Dopo aver impostato le righe 6-11 nel tuo script Python sul tuo Pi, salva ed esci dall'editor di testo. Esegui lo script con il seguente comando:

$ python tempsensor.py

Ora avrai i dati inviati a una dashboard dello stato iniziale. Vai alla sezione finale di questo articolo per i dettagli su come personalizzare la tua dashboard.

Passaggio 6: soluzione DSB18B20

Il cavo a nastro si collega ai pin GPIO sul Pi. Il DS18B20 ha tre fili. Il filo rosso si collega a 3.3V. Il filo blu/nero si collega a terra. Il filo giallo si collega a un resistore/pin 4 di pull-up. Una volta che questo è collegato, accendi il tuo Pi.

L'ultima versione di Raspbian (kernel 3.18) richiede un'aggiunta al file /boot/config.txt affinché il Pi comunichi con il DS18B20. Eseguire quanto segue per modificare questo file:

$ sudo nano /boot/config.txt

Se la riga seguente non è già in questo file (se lo è, è probabile che sia in fondo al file), aggiungila e salva il file.

dtoverlay=w1-gpio, gpiopin=4

Riavvia il tuo Pi per rendere effettive le modifiche.

$ sudo reboot

Per avviare l'interfaccia di lettura del sensore di temperatura è necessario eseguire due comandi. Vai a un prompt dei comandi sul tuo Pi o SSH nel tuo Pi. Digita i seguenti comandi:

$ sudo modprobe w1-gpio$ sudo modprobe w1-therm

L'output del tuo sensore di temperatura viene ora scritto su un file sul tuo Pi. Per trovare quel file:

$ cd /sys/bus/w1/devices

In questa directory, ci sarà una sottodirectory che inizia con "28-". Quello che viene dopo il "28-" è il numero di serie del sensore. cd in quella directory. All'interno di questa directory, un file denominato w1_slave contiene l'output del sensore. Usa nano per visualizzare il contenuto del file. Una volta inserito nel file, sarà simile a questo:

a2 01 4b 46 7f ff 0e 10 d8: crc=d8 SIa2 01 4b 46 7f ff 0e 10 d8 t=26125

Il numero dopo "t=" è il numero che vogliamo. Questa è la temperatura in 1/1000 gradi Celsius (nell'esempio sopra, la temperatura è 26,125 C). Abbiamo solo bisogno di un semplice programma che legga questo file e analizzi quel numero. Ci arriveremo in un secondo.

Ora è tutto pronto per iniziare a trasmettere i dati. Per aprire l'editor di testo, digita quanto segue nel prompt dei comandi:

$ nano temperatura.py

Copia e incolla il codice qui sotto nell'editor di testo.

importare il sistema operativo

import glob import time from ISStreamer. Streamer import Streamerstreamer = Streamer(bucket_name="Temperature Stream", bucket_key="piot_temp_stream031815", access_key="PUT_YOUR_ACCESS_KEY_HERE") os.system('modprobe w1-gpio') os.system('modprobe w1 -therm') base_dir = '/sys/bus/w1/devices/' device_folder = glob.glob(base_dir + '28*')[0] device_file = device_folder + '/w1_slave' def read_temp_raw(): f = open(device_file, 'r') righe = f.readlines() f.close() return righe def read_temp(): righe = read_temp_raw() while lines[0].strip()[-3:] != 'YES': time.sleep(0.2) lines = read_temp_raw() equals_pos = lines[1].find('t=') if equals_pos != -1: temp_string = lines[1][equals_pos+2:] temp_c = float(temp_string) / 1000.0 restituisce temp_c mentre True: temp_c = read_temp() temp_f = temp_c * 9.0 / 5.0 + 32.0 streamer.log("temperature (C)", temp_c) streamer.log("temperature (F)", temp_f) time.sleep (.5)

Devi inserire la tua chiave di accesso allo stato iniziale sulla riga 6 al posto di PUT_YOUR_ACCESS_KEY_HERE (copia la chiave di streaming negli appunti da "Il mio account" e incollala nel codice in nano nel tuo terminale).

La riga 6 creerà un bucket denominato "Temperature Stream" nel tuo account di stato iniziale (supponendo che tu abbia specificato correttamente la tua access_key su questa stessa riga). Le righe da 8 a 30 di questo script si interfacciano semplicemente con il sensore DS18B20 per leggere la sua temperatura dal file w1_slave di cui abbiamo discusso in precedenza. La funzione read_temp_raw() alla riga 15 legge il file w1_slave grezzo. La funzione read_temp() alla riga 21 analizza la temperatura da quel file. La riga 34 chiama queste funzioni per ottenere la temperatura attuale. La riga 35 converte la temperatura da Celsius a Fahrenheit. Le righe 35 e 36 trasmettono la temperatura al tuo account Stato iniziale. La riga 37 mette in pausa lo script per 0,5 secondi, impostando la frequenza con cui il sensore di temperatura verrà letto e trasmesso.

Siamo pronti per iniziare lo streaming. Esegui il seguente comando:

$ sudo python temperature.py

Torna al tuo account Stato iniziale nel tuo browser web e cerca un nuovo bucket di dati chiamato Temperature Stream. Dovresti vedere i dati di temperatura in streaming in diretta. Variare la temperatura del sensore tenendolo in mano o mettendolo in un bicchiere di ghiaccio.

Ora avrai i dati inviati a una dashboard dello stato iniziale. Vai alla sezione finale di questo articolo per i dettagli su come personalizzare la tua dashboard.

Passaggio 7: soluzione BME280

Avrai bisogno di quanto segue per creare questa soluzione:

-BME280 Sensore di pressione, temperatura e umidità

Questo sensore viene fornito con pin che dovrai saldare sul sensore. Consiglio di utilizzare una breadboard con i pin con il lato lungo rivolto verso il basso nella breadboard per facilitare la saldatura. Una volta completato questo, dobbiamo cablare il sensore al Pi.

Collegare il pin VIN sul sensore al pin 1 da 3,3 V sul Pi. Collegare il pin GND del sensore al pin 6 di massa del Pi. Collegare il pin SCK sul sensore al pin SCL 5 sul Pi. Collegare il pin SDI del sensore al pin 3 SDA del Pi. Dovrai utilizzare Python 3 per questa soluzione e installare il modulo Initial State Streamer utilizzando il metodo di installazione pip3.

Dovrai anche installare alcune librerie Adafruit Python.

pip3 installa adafruit-blinkapip3 installa pureio pip3 installa spidev pip3 installa adafruit-GPIO pip3 installa adafruit-circuitpython-bme280

Per utilizzare il sensore dobbiamo abilitare I2C sul Pi.

sudo raspi-config

Questo aprirà lo strumento di configurazione del software Raspberry Pi. Vai all'opzione 5 Opzioni di interfaccia. Da qui vai a I2C. Ti verrà chiesto se desideri abilitare I2C, selezionare Sì e Fine. Ora hai I2C abilitato per comunicare con il sensore.

Possiamo testarlo eseguendo quanto segue:

sudo i2cdetect -y 1

Questo verificherà che il tuo Pi veda il sensore. Nel modo in cui è connesso, dovrebbe mostrare il sensore all'indirizzo 77. Se non rilevi il sensore, riavvia il tuo Pi, riattiva l'opzione dell'interfaccia I2C sul tuo Pi e riprova. Una volta rilevato il sensore, è il momento per eseguire il nostro codice principale che invierà i dati allo stato iniziale. Creato un file chiamato bme280sensor.py con il comando nano. Copia e incolla il codice dall'essenza nell'editor di testo. Dovrai apportare modifiche alle righe 12-19.

tempo di importazione

import board import busio import adafruit_bme280 from ISStreamer. Streamer import Streamer # Crea un oggetto libreria usando il nostro Bus I2C porti2c = busio. I2C(board. SCL, board. SDA) bme280 = adafruit_bme280. Adafruit_BME280_I2C(i2c) # ------- -- Impostazioni utente --------- SENSOR_LOCATION_NAME = "Office" BUCKET_NAME = ":partly_sunny: Room Temperature" BUCKET_KEY = "temp1" ACCESS_KEY = "LA TUA CHIAVE DI ACCESSO QUI" # cambialo in modo che corrisponda alla pressione della posizione (hPa) al livello del mare bme280.sea_level_pression = 1013.25 MINUTES_BETWEEN_READS = 10 METRIC_UNTS = False # --------------------------------- # OPPURE creare un oggetto libreria utilizzando la nostra porta Bus SPI #spi = busio. SPI(board. SCK, board. MOSI, board. MISO) #bme_cs = digitalio. DigitalInOut(board. D10) #bme280 = adafruit_bme280. Adafruit_BME280_SPI(spi, bme_cs) streamer = Streamer(bucket_name=BUCKET_NAME, bucket_key=BUCKET_KEY, access_key=ACCESS_KEY) while True: umidità = format(bme280.humidity, ".1f") pressure = format(bme280.pressure, ".1f") temp_c = bme280.temperatu re if METRIC_UNITS: streamer.log(SENSOR_LOCATION_NAME + "Temperature(C)", temp_c) else: temp_f = format(temp_c * 9.0 / 5.0 + 32.0, ".1f") streamer.log(SENSOR_LOCATION_NAME + " Temperature(F)", temp_f) streamer.log(SENSOR_LOCATION_NAME + "Umidità(%)", umidità) streamer.log(SENSOR_LOCATION_NAME + "Pressione(hPA)", pressione) streamer.flush() time.sleep(60*MINUTES_BETWEEN_READS)

• Riga 12- Questo valore deve essere univoco per ogni nodo/sensore di temperatura. Questo potrebbe essere il nome della stanza del nodo del sensore, la posizione fisica, l'identificatore univoco o altro. Assicurati solo che sia univoco per ogni nodo per assicurarti che i dati di questo nodo vadano al proprio flusso di dati nella tua dashboard.
• Riga 13- Questo è il nome del bucket di dati. Questo può essere modificato in qualsiasi momento nell'interfaccia utente dello stato iniziale.
• Riga 14- Questa è la tua chiave del secchio. Deve essere la stessa chiave del bucket per ogni nodo che desideri venga visualizzato nella stessa dashboard.
• Riga 15- Questa è la chiave di accesso all'account dello stato iniziale. Copia e incolla questa chiave dal tuo account Stato iniziale.
• Riga 17- Questa è la pressione della tua posizione (hPa) al livello del mare. Puoi trovare queste informazioni sulla maggior parte dei siti Web meteorologici.
• Riga 18 - Questo è il tempo tra le letture del sensore. Cambia di conseguenza. Riga 19- Qui puoi specificare le unità metriche o imperiali.

Dopo aver impostato le righe 12-19 nel tuo script Python sul tuo Pi Zero WH, salva ed esci dall'editor di testo. Esegui lo script con il seguente comando:

$ python3 bme280sensor.py

Ora avrai i dati inviati a una dashboard dello stato iniziale. Vai alla sezione finale di questo articolo per i dettagli su come personalizzare la tua dashboard.

Passaggio 8: Rileva HAT

Il primo passo per usare Sense HAT è installarlo fisicamente sul tuo Pi. Con il Pi spento, attacca il CAPPELLO come mostrato nell'immagine.

Se decidi di utilizzare la soluzione come mostrato sopra, potresti notare che le letture della temperatura del tuo Sense HAT saranno un po' alte, perché lo sono. Il colpevole è il calore generato dalla CPU del Pi che riscalda l'aria intorno al Sense HAT quando si trova sopra il Pi. Per rendere utile il sensore di temperatura, dobbiamo allontanare l'HAT dal Pi o provare a calibrare la lettura del sensore di temperatura. Una buona soluzione per allontanare il sensore dal Pi è un cavo che lasci penzolare il Sense HAT lontano dal Pi. Un cavo di prolunga da 6 , 40 pin IDE maschio a femmina farà il trucco.

Una volta che hai deciso le due opzioni, accendi il tuo Pi. Dobbiamo installare la libreria Python per facilitare la lettura dei valori del sensore dal Sense HAT. Innanzitutto, dovrai assicurarti che tutto sia aggiornato sulla tua versione di Raspbian:

$ sudo apt-get update

Quindi, installa la libreria Python Sense HAT:

$ sudo apt-get install sense-hat

Riavvia il tuo Pi. Siamo pronti per testare il Sense HAT leggendo i dati del sensore da esso e inviando tali dati allo stato iniziale.

Crea un file chiamato sensehat e aprilo nell'editor di testo inserendo quanto segue nel prompt dei comandi:

$ nano sensehat.py

Copia e incolla il codice qui sotto nell'editor di testo.

from sense_hat import SenseHat

import time import sys from ISStreamer. Streamer import Streamer # --------- Impostazioni utente --------- BUCKET_NAME = "Office Weather" BUCKET_KEY = "sensehat" ACCESS_KEY = "Your_Access_Key" SENSOR_LOCATION_NAME = " Office" MINUTES_BETWEEN_SENSEHAT_READS = 0.1 # ---------------------------------- streamer = Streamer(bucket_name=BUCKET_NAME, bucket_key=BUCKET_KEY, access_key=ACCESS_KEY) sense = SenseHat() while True: # Leggi i sensori temp_c = sense.get_temperature() umidità = sense.get_humidity() pressure_mb = sense.get_pressure() # Formatta i dati temp_f = temp_c * 9.0 / 5.0 + 32.0 temp_f = float("{0:.2f}".format(temp_f)) umidità = float("{0:.2f}".format(umidità)) pressure_in = 0,03937008*(pressure_mb) pressure_in = float("{ 0:.2f}".format(Pressione_in)) # Stampa e trasmette print NOME_LOCAZIONE SENSORE + " Temperatura(F): " + str(Temp_f) print NOME_LOCALITA' SENSORE + " Umidità(%): " + str(Umidità) print NOME_LOCAZIONE_SENSORE + " Pressure(IN): " + str(pressure_in) streamer.log(":sunny: " + SEN SOR_LOCATION_NAME + " Temperatura(F)", temp_f) streamer.log(:sweat_drops: " + SENSOR_LOCATION_NAME + " Umidità(%)", umidità) streamer.log(:cloud: " + SENSOR_LOCATION_NAME + " Pressione(IN)", pressure_in) streamer.flush() time.sleep(60*MINUTES_BETWEEN_SENSEHAT_READS)

Notare sulla prima riga che stiamo importando la libreria SenseHat nello script. Prima di eseguire questo script, dobbiamo impostare i nostri parametri utente.

# --------- Impostazioni utente ---------

BUCKET_NAME = "Office Weather"BUCKET_KEY = "sensehat"ACCESS_KEY = "Your_Access_Key"SENSOR_LOCATION_NAME = "Office"MINUTES_BETWEEN_SENSEHAT_READS = 0.1# ------------------------- --------

In particolare, devi impostare la tua ACCESS_KEY sulla chiave di accesso all'account dello stato iniziale. Puoi modificare BUCKET_NAME e SENSOR_LOCATION_NAME nella posizione effettiva del sensore. Salva ed esci dall'editor di testo.

Al prompt dei comandi sul tuo Pi, esegui lo script:

$ sudo python sensehat.py

Ora avrai i dati inviati a una dashboard dello stato iniziale. Vai alla sezione finale di questo articolo per i dettagli su come personalizzare la tua dashboard.

Passaggio 9: personalizza il dashboard dello stato iniziale

Vai al tuo account Stato iniziale e guarda i tuoi dati. Puoi fare clic con il pulsante destro del mouse su un riquadro per modificare il tipo di grafico e fare clic su Modifica riquadri per ridimensionare e spostare i riquadri. Consiglierei di utilizzare il termostato dell'indicatore per la temperatura e il livello del liquido dell'indicatore per l'umidità. Puoi creare grafici a linee sia per la temperatura che per l'umidità per vedere i cambiamenti nel tempo. Puoi anche aggiungere un'immagine di sfondo alla dashboard.

Puoi impostare gli avvisi di trigger in modo da poter ricevere un SMS o un'e-mail se la temperatura scende al di sotto o supera una certa soglia. Vai al tuo bucket di dati e fai clic su Impostazioni. Da lì vai alla scheda Trigger. Immettere la chiave del flusso che si desidera monitorare, l'operatore che si desidera utilizzare e il valore di soglia. Fare clic sul segno più per aggiungere il trigger. Quindi inserisci la tua e-mail o il numero di telefono per ricevere l'avviso e fai clic sul segno più. Dopo aver impostato tutti i trigger, fai clic sul pulsante Fine in basso.

Ora che hai creato un monitor della temperatura utilizzando un sensore di temperatura e un Raspberry Pi, puoi iniziare a pensare a quali altri dati ambientali potrai monitorare in seguito.