Hur man bygger en Raspberry Pi -temperaturmonitor: 9 steg

2025 Författare: John Day | [email protected]. Senast ändrad: 2025-01-13 06:58

Temperatur och luftfuktighet är viktiga datapunkter i dagens industriella värld. Övervakning av miljödata för serverrum, kommersiella frysar och produktionslinjer är nödvändigt för att saker och ting ska fungera smidigt. Det finns massor av lösningar som går från grundläggande till komplexa och det kan verka överväldigande på vad ditt företag behöver och var du ska börja.

Vi går igenom hur man övervakar temperaturen med en Raspberry Pi och olika temperatursensorer som du kan använda. Detta är ett bra ställe att börja eftersom dessa lösningar är billiga, enkla att göra och ger dig en grund att bygga på för annan miljöövervakning.

Tillbehör

• Raspberry Pi (3, 4 eller Zero WH)
• Temperatursensor (DHT2, DSB18B20, BME280 eller Sense HAT)
• 6 "40-pins IDE hane till hona förlängningskabel (Sense HAT-lösning)
• 10K motstånd, brödbräda, 40-polig brytskiva + bandkabel, ledningar (för DSB18B20-lösning)

Steg 1: Hallon Pi

En Raspberry Pi är en billig enkelkortsdator som låter dig ansluta till en temperatursensor och strömma data till en datavisualiseringsprogramvara. Raspberry Pi började som ett lärande verktyg och har utvecklats till ett industriellt arbetsplatsverktyg. Användarvänligheten och möjligheten att koda med Python, det snabbast växande programmeringsspråket, har gjort dem till en lösning.

Du vill ha en Raspberry Pi som har WiFi inbyggt, vilket är alla modeller 3, 4 och noll W/WH. Mellan dem kan du välja baserat på priser och funktioner. Zero W/WH är den billigaste men om du behöver mer funktionalitet kan du välja mellan 3 och 4. Du kan bara köpa en Zero W/WH åt gången på grund av begränsningar från Raspberry Pi Foundation. Oavsett vilken Pi du väljer, se till att köpa en laddare eftersom det är så du kommer att driva Pi och ett SD -kort med Raspbian för att göra installationen av operativsystemet så enkelt som möjligt.

Det finns andra enkeldator som också kan fungera, men det är för en annan tid och en annan artikel.

Steg 2: Sensorer

Det finns tre sensorer vi rekommenderar att använda eftersom de är billiga, enkla att ansluta och ger exakta avläsningar; DSB18B20, DHT22 och Raspberry Pi Sense HAT.

DHT22 - Denna temperatur- och fuktighetssensor har temperaturnoggrannhet på +/- 0,5 C och ett luftfuktighetsintervall från 0 till 100 procent. Det är enkelt att koppla upp till Raspberry Pi och kräver inga uppdragningsmotstånd.

DSB18B20 - Denna temperatursensor har en digital utgång, som fungerar bra med Raspberry Pi. Den har tre ledningar och kräver en brödbräda och motstånd för anslutningen.

BME280 - Denna sensor mäter temperatur, luftfuktighet och barometertryck. Den kan användas i både SPI och I2C.

Sense HAT - Detta är ett tillägg ombord för Raspberry Pi som har lysdioder, sensorer och en liten joystick. Den ansluts direkt till GPIO på Raspberry Pi men med en bandkabel får du mer exakta temperaturavläsningar.

Steg 3: Installation av Raspberry Pi

Om detta är första gången du konfigurerar din Raspberry Pi måste du installera Raspbian -operativsystemet och ansluta din Pi till WiFi. Detta kräver en bildskärm och ett tangentbord för att ansluta till Pi. När du väl har den igång och är ansluten till WiFI är din Pi redo att gå.

Steg 4: Första statskontot

Du behöver någonstans för att skicka dina data för att hålla en historisk logg och se dataströmmen i realtid så att vi använder Initial State. Gå till https://iot.app.initialstate.com och skapa ett nytt konto eller logga in på ditt befintliga konto.

Därefter måste vi installera Initial State Python -modulen på din Pi. Vid en kommandotolk (glöm inte att SSH in i din Pi först), kör följande kommando:

$ cd/home/pi/

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

När du har angett curl -kommandot i kommandotolken ser du något som liknar följande utmatning på skärmen:

pi@raspberrypi ~

$ / curl -sSL https://get.initialstate.com/python -o -| sudo bash Lösenord: Börjar ISStreamer Python Enkel installation! Det kan ta ett par minuter att installera, ta lite kaffe:) Men glöm inte att komma tillbaka, jag har frågor senare! Hittade easy_install: setuptools 1.1.6 Hittade pip: pip 1.5.6 från /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 hittades, uppdateras … Kravet är redan uppdaterat: ISStreamer i /Library/Python/2.7/site-packages Rengöring … Vill du automatiskt få ett exempelskript? [y/N] Var vill du spara exemplet? [standard:./is_example.py] Vänligen välj vilken Initial State -app du använder: 1. app.initialstate.com 2. [NEW!] iot.app.initialstate.com Ange val 1 eller 2: Ange iot.app.initialstate.com användarnamn: Ange iot.app.initialstate.com lösenord:

När du uppmanas att automatiskt hämta ett exempelskript skriver du y. Detta skapar ett testskript som vi kan köra för att säkerställa att vi kan strömma data till initialstatus. Nästa prompt frågar var du vill spara exempelfilen. Du kan antingen skriva en anpassad lokal sökväg eller trycka på enter för att acceptera standardplatsen. Slutligen kommer du att bli tillfrågad vilken Initial State -app du använder. Om du nyligen har skapat ett konto väljer du alternativ 2, anger ditt användarnamn och lösenord. Därefter är installationen klar.

Låt oss ta en titt på exempelskriptet som skapades.

$ nano är_exempel.py

På rad 15 ser du en rad som börjar med streamer = Streamer (bucket_…. Dessa rader skapar en ny datahink med namnet”Python Stream Exempel” och är kopplad till ditt konto. Denna koppling sker på grund av access_key =”…” parameter på samma rad. Den där långa serien med bokstäver och siffror är din åtkomstnyckel för initialstatskontot. Om du går till ditt ursprungliga statskonto i din webbläsare klickar du på ditt användarnamn högst upp till höger och går sedan till "mina inställningar", hittar du samma åtkomstnyckel här under "Streaming Access Keys".

Varje gång du skapar en dataström, leder den åtkomstnyckeln den dataströmmen till ditt konto (så dela inte din nyckel med någon).

Kör testskriptet för att se till att vi kan skapa en dataström till ditt Initial State -konto. Kör följande:

$ python är_exempel.py

Gå tillbaka till ditt ursprungliga statskonto i din webbläsare. En ny datahink som heter "Python Stream Exempel" borde ha dykt upp till vänster i din logghylla (du kan behöva uppdatera sidan). Klicka på den här hinken och klicka sedan på Waves -ikonen för att se testdata

Om du använder Python 3 kan du installera Initial State Streamer -modulen som du kan installera med följande kommando:

pip3 installera ISStreamer

Nu är vi redo att ställa in temperatursensorn med Pi för att strömma temperaturen till en instrumentpanel.

Steg 5: DHT22 -lösning

DHT22 kommer att ha tre stift - 5V, Gnd och data. Det bör finnas en stiftetikett för ström på DHT22 (t.ex. ‘+’ eller ‘5V’). Anslut detta till stift 2 (det övre högra stiftet, 5V) på Pi. Gnd-stiftet kommer att märkas med "-" eller "Gnd" eller något motsvarande. Anslut detta till stift 6 Gnd (två stift under 5V -stiftet) på Pi. Den återstående PIN -koden på DHT22 är datapinnen och kommer att märkas med 'out' eller 's' eller 'data'. Anslut detta till en av GPIO -stiften på Pi, till exempel GPIO4 (stift 7). När detta är anslutet, slå på din Pi.

Installera Adafruit DHT Python -modulen vid en kommandotolk för att göra läsning av DHT22 sensordata superenkelt:

$ sudo pip installera Adafruit_DHT

Med vårt operativsystem installerat tillsammans med våra två Python -moduler för att läsa sensordata och skicka data till Initial State, är vi redo att skriva vårt Python -skript. Följande skript skapar/lägger till en datahink för initialtillstånd, läser sensordata för DHT22 och skickar den till en instrumentpanel i realtid. Allt du behöver göra är att ändra rad 6–11.

importera Adafruit_DHT

från ISStreamer. Streamer import Streamer importtid# --------- Användarinställningar --------- SENSOR_LOCATION_NAME = "Office" BUCKET_NAME = ": delvis_soligt: Rumstemperatur" BUCKET_KEY = "rt0129" ACCESS_KEY = "PLACERA DIN INLÄGGNINGSKNAPP FÖR UTLÄNGANDE STAT HÄR" MINUTES_BETWEEN_READS = 10METRIC_UNITS = Falskt # --------------------------------- streamer = Streamer (bucket_name = BUCKET_NAME, bucket_key = BUCKET_KEY, access_key = ACCESS_KEY) medan True: fuktighet, temp_c = Adafruit_DHT.read_retry (Adafruit_DHT. DHT22, 4) om METRIC_UNITS: streamer.log (SENSOR_LOCATION_NAME) ": temp_f = format (temp_c * 9.0 / 5.0 + 32.0, ".2f") streamer.log (SENSOR_LOCATION_NAME + "Temperatur (F)", temp_f) fuktighet = format (fuktighet, ".2f") streamer.log (SENSOR_LOCATION_NAME + "Luftfuktighet (%)", fuktighet) streamer.flush () time.sleep (60*MINUTES_BETWEEN_READS)

• Rad 6 - Detta värde bör vara unikt för varje nod/temperaturgivare. Detta kan vara din sensornods rumsnamn, fysiska plats, unika identifierare eller vad som helst. Se bara till att det är unikt för varje nod för att säkerställa att data från denna nod går till sin egen dataström i din instrumentpanel.
• Rad 7 - Detta är namnet på dataskopan. Detta kan ändras när som helst i det ursprungliga tillståndsgränssnittet.
• Rad 8 - Det här är din hinknyckel. Det måste vara samma hinknyckel för varje nod du vill visa i samma instrumentpanel.
• Rad 9 - Det här är din åtkomstnyckel för det första statskontot. Kopiera och klistra in den här nyckeln från ditt Initial State -konto.
• Rad 10 - Detta är tiden mellan sensoravläsningar. Ändra därefter.
• Rad 11 - Du kan ange metriska eller imperiala enheter på rad 11.

När du har ställt in raderna 6–11 i ditt Python -skript på din Pi, spara och avsluta textredigeraren. Kör skriptet med följande kommando:

$ python tempsensor.py

Nu kommer du att ha data som skickas till en Initial State -instrumentpanel. Gå till det sista avsnittet i den här artikeln för mer information om hur du anpassar din instrumentpanel.

Steg 6: DSB18B20 -lösning

Bandkabeln ansluts till GPIO -stiften på Pi. DS18B20 har tre ledningar. Den röda ledningen ansluts till 3,3V. Den blå/svarta ledningen ansluts till marken. Den gula ledningen ansluts till ett uppdragningsmotstånd/stift 4. När detta är anslutet, slå på din Pi.

Den senaste versionen av Raspbian (kärna 3.18) kräver ett tillägg till din /boot/config.txt -fil för att Pi ska kunna kommunicera med DS18B20. Kör följande för att redigera den här filen:

$ sudo nano /boot/config.txt

Om följande rad inte redan finns i den här filen (om den är det är det troligtvis längst ner i filen), lägg till den och spara filen.

dtoverlay = w1-gpio, gpiopin = 4

Starta om din Pi för att ändringarna ska träda i kraft.

$ sudo starta om

För att starta temperaturgivarens läsgränssnitt måste vi köra två kommandon. Gå till en kommandotolk på din Pi eller SSH till din Pi. Skriv följande kommandon:

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

Utmatningen från din temperatursensor skrivs nu till en fil på din Pi. För att hitta den filen:

$ cd/sys/bus/w1/enheter

I den här katalogen kommer det att finnas en undermapp som börjar med "28-". Det som kommer efter “28-” är serienumret på din sensor. cd i den katalogen. Inne i den här katalogen innehåller en fil med namnet w1_slave utdata från din sensor. Använd nano för att visa innehållet i filen. När du har skrivit in filen kommer den att se ut ungefär så här:

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

Siffran efter “t =” är det tal vi vill ha. Detta är temperaturen i 1/1000 grader Celsius (i exemplet ovan är temperaturen 26,125 C). Vi behöver bara ett enkelt program som läser den här filen och analyserar det numret. Vi kommer till det på bara en sekund.

Allt är nu klart för oss att börja strömma data. För att öppna textredigeraren skriver du följande i kommandotolken:

$ nano temperatur. py

Kopiera och klistra in koden nedan i textredigeraren.

importera os

import glob importtid från 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 -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') lines = f.readlines () f.close () return lines def read_temp (): lines = 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 retur temp_c medan True: temp_c = read_temp () temp_f = temp_c * 9.0 / 5.0 + 32.0 streamer.log ("temperatur (C)", temp_c) streamer.log ("temperatur (F)", temp_f) time.sleep (.5)

Du måste sätta din initiala åtkomstnyckel på rad 6 istället för PUT_YOUR_ACCESS_KEY_HERE (kopiera strömningsnyckeln till ditt urklipp från "Mitt konto" och klistra in den i koden i nano i din terminal).

Rad 6 skapar en hink med namnet "Temperaturström" i ditt initialtillståndskonto (förutsatt att du korrekt angav din access_key på samma rad). Linjer 8 till 30 i detta skript gränsar helt enkelt med DS18B20 -sensorn för att läsa dess temperatur från w1_slave -filen som vi diskuterade tidigare. Funktionen read_temp_raw () på rad 15 läser rå w1_slave -filen. Funktionen read_temp () på rad 21 analyserar temperaturen från filen. Linje 34 kallar dessa funktioner för att få aktuell temperatur. Linje 35 omvandlar temperaturen från Celsius till Fahrenheit. Linjerna 35 och 36 strömmar temperaturen till ditt Initial State -konto. Rad 37 pausar manuset i 0,5 sekunder och anger hur ofta temperatursensorn ska läsas och streamas.

Vi är redo att börja strömma. Kör följande kommando:

$ sudo python temperatur. py

Gå tillbaka till ditt Initial State -konto i din webbläsare och leta efter en ny datahink som heter Temperaturström. Du bör se temperaturdataströmning live. Variera temperaturen på sensorn genom att hålla den i handen eller lägga den i ett glas is.

Nu kommer du att ha data som skickas till en Initial State -instrumentpanel. Gå till det sista avsnittet i den här artikeln för mer information om hur du anpassar din instrumentpanel.

Steg 7: BME280 -lösning

Du behöver följande för att bygga den här lösningen:

-BME280 Tryck-, temperatur- och fuktsensor

Denna sensor levereras med stift som du behöver lödda på sensorn. Jag rekommenderar att du använder en brödbräda med stiften långsida ner i brödbrädan för att underlätta lödningen. När du har slutfört detta måste vi koppla sensorn till Pi.

Anslut VIN -stiftet på sensorn till 3,3V stift 1 på Pi. Anslut GND -stiftet på sensorn till jordstiftet 6 på Pi. Anslut SCK -stiftet på sensorn till SCL -stiftet 5 på Pi. Anslut SDI -stiftet på sensorn till SDA -stift 3 på Pi. Du måste använda Python 3 för den här lösningen och installera Initial State Streamer -modulen med pip3 -installationsmetod.

Du måste också installera några Adafruit Python -bibliotek.

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

För att använda sensorn måste vi aktivera I2C på Pi.

sudo raspi-config

Detta kommer att öppna Raspberry Pi Software Configuration Tool. Gå till Alternativ 5 Gränssnittsalternativ. Härifrån går du till I2C. Den kommer att fråga dig om du vill aktivera I2C, välj Ja och slutför. Nu har du I2C aktiverat för att kommunicera med sensorn.

Vi kan testa detta genom att köra följande:

sudo i2cdetect -y 1

Detta kommer att verifiera att din Pi ser sensorn. På det sättet som den är ansluten bör den visa sensorn på adress 77. Om du inte upptäcker sensorn, starta om din Pi, aktivera åter I2C -gränssnittet på din Pi och försök igen. När din sensor har upptäckts är det dags för att köra vår huvudkod som skickar data till initialtillståndet. Skapade en fil som heter bme280sensor.py med kommandot nano. Kopiera och klistra in koden från essensen i textredigeraren. Du måste göra ändringar i raderna 12–19.

importtid

importkort import busio import adafruit_bme280 från ISStreamer. Streamer import Streamer # Skapa biblioteksobjekt med vårt Bus I2C porti2c = busio. I2C (board. SCL, board. SDA) bme280 = adafruit_bme280. Adafruit_BME280_I2C (i2c) # ------- -Användarinställningar --------- SENSOR_LOCATION_NAME = "Kontor" BUCKET_NAME = ": delvis_soligt: Rumstemperatur" BUCKET_KEY = "temp1" ACCESS_KEY = "DIN TILLGÅNGSKNAPP HÄR" # ändra detta för att matcha platsens tryck (hPa) vid havsnivå bme280.sea_level_pressure = 1013,25 MINUTES_BETWEEN_READS = 10 METRIC_UNITS = Falskt # --------------------------------- # ELLER skapa biblioteksobjekt med vår Bus SPI -port #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) medan True: fukt = format (bme280.fuktighet, ".1f") tryck = format (bme280.tryck, ".1f") temp_c = bme280.temperatur re if METRIC_UNITS: streamer.log (SENSOR_LOCATION_NAME + "Temperatur (C)", temp_c) else: temp_f = format (temp_c * 9.0 / 5.0 + 32.0, ".1f") streamer.log (SENSOR_LOCATION_NAME + "Temperatur (F)", temp_f) streamer.log (SENSOR_LOCATION_NAME + "Luftfuktighet (%)", fuktighet) streamer.log (SENSOR_LOCATION_NAME + "Tryck (hPA)", tryck) streamer.flush () time.sleep (60*MINUTES_BETWEEN_READS)

• Linje 12- Detta värde bör vara unikt för varje nod/temperaturgivare. Detta kan vara din sensornods rumsnamn, fysiska plats, unika identifierare eller vad som helst. Se bara till att det är unikt för varje nod för att säkerställa att data från denna nod går till sin egen dataström i din instrumentpanel.
• Linje 13- Detta är namnet på dataskopan. Detta kan ändras när som helst i det ursprungliga tillståndsgränssnittet.
• Rad 14- Det här är din hinknyckel. Det måste vara samma hinknyckel för varje nod du vill visa i samma instrumentpanel.
• Rad 15- Det här är din initiala statskontots åtkomstnyckel. Kopiera och klistra in den här nyckeln från ditt Initial State -konto.
• Linje 17- Detta är din platsens tryck (hPa) vid havsnivå. Du hittar denna information på de flesta väderwebbplatser.
• Rad 18 - Detta är tiden mellan sensoravläsningar. Ändra därefter. Rad 19- Här kan du ange metriska eller imperiala enheter.

När du har ställt in raderna 12–19 i ditt Python -skript på din Pi Zero WH, spara och avsluta textredigeraren. Kör skriptet med följande kommando:

$ python3 bme280sensor.py

Nu kommer du att ha data som skickas till en Initial State -instrumentpanel. Gå till det sista avsnittet i den här artikeln för mer information om hur du anpassar din instrumentpanel.

Steg 8: Känsla HAT

Det första steget i att använda Sense HAT är att fysiskt installera den på din Pi. Med Pi avstängd, fäst HAT som visas på bilden.

Om du bestämmer dig för att använda lösningen enligt ovan kan du märka att din Sense HAT: s temperaturmätningar blir lite höga - det beror på att de är det. Den skyldige är värmen som genereras från Pi: s CPU som värmer upp luften runt Sense HAT när den sitter ovanpå Pi. För att göra temperatursensorn användbar måste vi antingen ta bort hatten från Pi eller försöka kalibrera temperaturgivarens avläsning. En bra lösning för att få sensorn bort från Pi är en kabel som låter Sense HAT dingla bort från Pi. En 6 , 40-polig IDE hane till hona förlängningskabelkabel kommer att göra susen.

När du väl har bestämt dig för de två alternativen, slå på din Pi. Vi måste installera Python -biblioteket för att göra det enkelt att läsa sensorvärdena från Sense HAT. Först måste du se till att allt är uppdaterat på din version av Raspbian:

$ sudo apt-get uppdatering

Installera sedan Sense HAT Python -biblioteket:

$ sudo apt-get install sense-hat

Starta om din Pi. Vi är redo att testa Sense HAT genom att läsa sensordata från den och skicka den till Initial State.

Skapa en fil som heter sensehat och öppna den i textredigeraren genom att ange följande i kommandotolken:

$ nano sensehat.py

Kopiera och klistra in koden nedan i textredigeraren.

från sense_hat importera SenseHat

importtid import sys från ISStreamer. Streamer import Streamer # --------- Användarinställningar --------- BUCKET_NAME = "Kontorsväder" BUCKET_KEY = "sensehat" ACCESS_KEY = "Your_Access_Key" SENSOR_LOCATION_NAME = " Kontor "MINUTES_BETWEEN_SENSEHAT_READS = 0.1 # --------------------------------- streamer = Streamer (bucket_name = BUCKET_NAME, bucket_key = BUCKET_KEY, access_key = ACCESS_KEY) sense = SenseHat () medan True: # Läs sensorerna temp_c = sense.get_temperature () fukt = sense.get_humidity () pressure_mb = sense.get_pressure () # Formatera data temp_f = temp_c * 9,0 / 5,0 + 32.0 temp_f = float ("{0:.2f}". Format (temp_f)) fukt = float ("{0:.2f}". Format (fuktighet)) pressure_in = 0.03937008*(pressure_mb) pressure_in = float ("{ 0:.2f} ". Format (pressure_in)) # Skriv ut och strömma ut SENSOR_LOCATION_NAME +" Temperatur (F): " + str (temp_f) print SENSOR_LOCATION_NAME +" Luftfuktighet (%): " + str (fuktighet) tryck SENSOR_LOCATION_NAME +" Pressure (IN): " + str (pressure_in) streamer.log (": sunny: " + SEN SOR_LOCATION_NAME + "Temperatur (F)", temp_f) streamer.log (": sweat_drops:" + SENSOR_LOCATION_NAME + "Luftfuktighet (%)", fuktighet) streamer.log (": cloud:" + SENSOR_LOCATION_NAME + "Tryck (IN)", tryck_in) streamer.flush () time.sleep (60*MINUTES_BETWEEN_SENSEHAT_READS)

Lägg märke till på första raden att vi importerar SenseHat -biblioteket till skriptet. Innan du kör detta skript måste vi konfigurera våra användarparametrar.

# --------- Användarinställningar ---------

BUCKET_NAME = "Kontorsväder" BUCKET_KEY = "sensehat" ACCESS_KEY = "Your_Access_Key" SENSOR_LOCATION_NAME = "Kontor" MINUTES_BETWEEN_SENSEHAT_READS = 0.1# ------------------------- --------

Specifikt måste du ställa in din ACCESS_KEY till din åtkomstnyckel för initialstatskontot. Du kan ändra BUCKET_NAME och SENSOR_LOCATION_NAME till den aktuella sensorplatsen. Spara och avsluta textredigeraren.

Kör skriptet vid en kommandotolk på din Pi:

$ sudo python sensehat.py

Nu kommer du att ha data som skickas till en Initial State -instrumentpanel. Gå till det sista avsnittet i den här artikeln för mer information om hur du anpassar din instrumentpanel.

Steg 9: Anpassa din ursprungliga statusinstrumentpanel

Gå till ditt Initial State -konto och titta på dina data. Du kan högerklicka på en kakel för att ändra diagramtypen och klicka på Redigera plattor för att ändra storlek och flytta dina plattor. Jag rekommenderar att du använder mätartermostaten för temperatur och mätarens vätskenivå för luftfuktighet. Du kan skapa linjediagram för både temperatur och luftfuktighet för att se förändringar över tiden. Du kan också lägga till en bakgrundsbild på din instrumentpanel.

Du kan ställa in Trigger -varningar så att du kan få ett SMS eller e -postmeddelande om temperaturen sjunker under eller går över en viss tröskel. Gå till din datahink och klicka på inställningar. Därifrån går du till fliken Utlösare. Ange strömnyckeln du vill övervaka, operatören du vill använda och tröskelvärdet. Klicka på plustecknet för att lägga till utlösaren. Sedan anger du din e -postadress eller ditt telefonnummer för att få varningen och klickar på plustecknet. När du har ställt in alla dina utlösare klickar du på knappen Klar längst ner.

Nu när du har skapat en temperaturmätare med en temperatursensor och en Raspberry Pi kan du börja tänka på vilka andra miljödata du kan övervaka härnäst.