Hoe een Raspberry Pi-temperatuurmonitor te bouwen - Ajarnpa

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

Temperatuur en vochtigheid zijn essentiële gegevenspunten in de industriële wereld van vandaag. Het monitoren van omgevingsgegevens voor serverruimten, commerciële diepvriezers en productielijnen is noodzakelijk om alles soepel te laten verlopen. Er zijn veel oplossingen, variërend van eenvoudig tot complex, en het kan overweldigend lijken over wat uw bedrijf nodig heeft en waar te beginnen.

We zullen doornemen hoe u de temperatuur kunt bewaken met een Raspberry Pi en verschillende temperatuursensoren die u kunt gebruiken. Dit is een goede plek om te beginnen, aangezien deze oplossingen goedkoop en gemakkelijk uit te voeren zijn en u een basis biedt waarop u kunt voortbouwen voor andere omgevingsmonitoring.

Benodigdheden

• Raspberry Pi (3, 4 of Zero WH)
• Temperatuursensor (DHT2, DSB18B20, BME280 of Sense HAT)
• 6" 40-pins IDE mannelijk naar vrouwelijk verlengkabel (Sense HAT-oplossing)
• 10K-weerstand, breadboard, 40-pins breakout-bord + lintkabel, draden (voor DSB18B20-oplossing)

Stap 1: Raspberry Pi

Een Raspberry Pi is een goedkope computer met één bord waarmee u verbinding kunt maken met een temperatuursensor en de gegevens kunt streamen naar software voor gegevensvisualisatie. Raspberry Pi's zijn begonnen als een leermiddel en zijn geëvolueerd naar een hulpmiddel voor industriële werkplekken. Het gebruiksgemak en de mogelijkheid om te coderen met Python, de snelstgroeiende programmeertaal, heeft ervoor gezorgd dat ze een oplossing zijn.

U wilt een Raspberry Pi met ingebouwde WiFi, elk model 3, 4 en nul W / WH. Daartussen kunt u kiezen op basis van prijzen en functies. De Zero W/WH is de goedkoopste, maar als je meer functionaliteit nodig hebt, kun je kiezen tussen de 3 en 4. Je kunt maar één Zero W/WH per keer kopen vanwege beperkingen door de Raspberry Pi Foundation. Welke Pi je ook kiest, zorg ervoor dat je een oplader koopt, want zo voed je de Pi en een SD-kaart met Raspbian om de installatie van het besturingssysteem zo eenvoudig mogelijk te maken.

Er zijn andere computers met één bord die ook kunnen werken, maar dat is voor een andere keer en een ander artikel.

Stap 2: Sensoren

Er zijn drie sensoren die we aanbevelen te gebruiken omdat ze goedkoop zijn, gemakkelijk aan te sluiten zijn en nauwkeurige metingen geven; DSB18B20, DHT22 en Raspberry Pi Sense HAT.

DHT22 - Deze temperatuur- en vochtigheidssensor heeft een temperatuurnauwkeurigheid van +/- 0,5 C en een vochtigheidsbereik van 0 tot 100 procent. Het is eenvoudig aan te sluiten op de Raspberry Pi en vereist geen pull-up-weerstanden.

DSB18B20 - Deze temperatuursensor heeft een digitale uitgang, die goed werkt met de Raspberry Pi. Het heeft drie draden en vereist een breadboard en weerstand voor de verbinding.

BME280 - Deze sensor meet temperatuur, vochtigheid en luchtdruk. Het kan zowel in SPI als I2C worden gebruikt.

Sense HAT - Dit is een add-on voor Raspberry Pi met LED's, sensoren en een kleine joystick. Het maakt rechtstreeks verbinding met de GPIO op de Raspberry Pi, maar het gebruik van een lintkabel geeft u nauwkeurigere temperatuurmetingen.

Stap 3: Raspberry Pi-configuratie

Als dit de eerste keer is dat je je Raspberry Pi instelt, moet je het Raspbian-besturingssysteem installeren en je Pi verbinden met wifi. Dit vereist een monitor en toetsenbord om verbinding te maken met de Pi. Zodra je hem in gebruik hebt en verbonden bent met wifi, is je Pi klaar voor gebruik.

Stap 4: Initiële staatsrekening

Je hebt een locatie nodig om je gegevens naar toe te sturen om een historisch logboek bij te houden en de realtime gegevensstroom te bekijken, dus we zullen de beginstatus gebruiken. Ga naar https://iot.app.initialstate.com en maak een nieuw account aan of log in op je bestaande account.

Vervolgens moeten we de Initial State Python-module op uw Pi installeren. Voer de volgende opdracht uit bij een opdrachtprompt (vergeet niet eerst SSH naar uw Pi te sturen):

$ cd /home/pi/

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

Nadat u de curl-opdracht in de opdrachtprompt hebt ingevoerd, ziet u iets dat lijkt op de volgende uitvoer op het scherm:

pi@raspberrypi ~

$ \curl -sSL https://get.initialstate.com/python -o - | sudo bash Wachtwoord: Begin ISStreamer Python Eenvoudige installatie! Dit kan een paar minuten duren om te installeren, neem wat koffie:) Maar vergeet niet terug te komen, ik heb later vragen! Easy_install gevonden: setuptools 1.1.6 Gevonden pip: pip 1.5.6 van /Library/Python/2.7/site-packages/pip-1.5.6- py2.7.egg (python 2.7) pip hoofdversie: 1 pip kleine versie: 5 ISStreamer gevonden, updaten… Vereiste al up-to-date: ISStreamer in /Library/Python/2.7/site-packages Opruimen… Wil je automatisch een voorbeeldscript krijgen? [j/N] Waar wil je het voorbeeld opslaan? [default:./is_example.py] Selecteer a.u.b. welke Initial State-app u gebruikt: 1. app.initialstate.com 2. [NIEUW!] iot.app.initialstate.com Voer keuze 1 of 2 in: Voer iot.app in.initialstate.com gebruikersnaam: Voer het iot.app.initialstate.com wachtwoord in:

Wanneer u wordt gevraagd om automatisch een voorbeeldscript op te halen, typt u y. Hiermee wordt een testscript gemaakt dat we kunnen uitvoeren om ervoor te zorgen dat we gegevens naar de oorspronkelijke status kunnen streamen. De volgende prompt zal vragen waar u het voorbeeldbestand wilt opslaan. U kunt een aangepast lokaal pad typen of op Enter drukken om de standaardlocatie te accepteren. Ten slotte wordt u gevraagd welke Initial State-app u gebruikt. Als je onlangs een account hebt aangemaakt, selecteer dan optie 2, voer je gebruikersnaam en wachtwoord in. Daarna is de installatie voltooid.

Laten we eens kijken naar het voorbeeldscript dat is gemaakt.

$ nano is_voorbeeld.py

Op regel 15 ziet u een regel die begint met streamer = Streamer(bucket_ …. Deze regel maakt een nieuwe gegevensbucket aan met de naam "Python Stream Voorbeeld" en is gekoppeld aan uw account. Deze koppeling vindt plaats vanwege de access_key="…". parameter op diezelfde regel. Die lange reeks letters en cijfers is de toegangssleutel van uw Initial State-account. Als u in uw webbrowser naar uw Initial State-account gaat, klikt u op uw gebruikersnaam in de rechterbovenhoek en gaat u naar "mijn instellingen", vindt u diezelfde toegangssleutel hier onder "Toegangssleutels streamen".

Elke keer dat u een gegevensstroom maakt, leidt die toegangssleutel die gegevensstroom naar uw account (deel uw sleutel dus met niemand).

Voer het testscript uit om er zeker van te zijn dat we een gegevensstroom naar uw Initial State-account kunnen maken. Voer het volgende uit:

$ python is_voorbeeld.py

Ga terug naar uw Initial State-account in uw webbrowser. Een nieuwe data-bucket genaamd "Python Stream-voorbeeld" zou aan de linkerkant in uw logplank moeten verschijnen (mogelijk moet u de pagina vernieuwen). Klik op deze bucket en klik vervolgens op het Waves-pictogram om de testgegevens te bekijken

Als u Python 3 gebruikt, kunt u de Initial State Streamer-module installeren die u kunt installeren met de volgende opdracht:

pip3 installeer ISStreamer

Nu zijn we klaar om de temperatuursensor met de Pi in te stellen om de temperatuur naar een dashboard te streamen.

Stap 5: DHT22-oplossing

De DHT22 heeft drie pinnen - 5V, Gnd en data. Er moet een pinlabel voor stroom op de DHT22 zijn (bijv. '+' of '5V'). Sluit deze aan op pin 2 (de pin rechtsboven, 5V) van de Pi. De Gnd-pin krijgt het label '-' of 'Gnd' of iets dergelijks. Sluit deze aan op pin 6 Gnd (twee pinnen onder de 5V-pin) op de Pi. De resterende pin op de DHT22 is de datapin en krijgt het label 'out' of 's' of 'data'. Sluit deze aan op een van de GPIO-pinnen op de Pi zoals GPIO4 (pin 7). Zodra dit is bedraad, schakelt u uw Pi in.

Installeer de Adafruit DHT Python-module bij een opdrachtprompt om het lezen van DHT22-sensorgegevens supereenvoudig te maken:

$ sudo pip installeren Adafruit_DHT

Met ons besturingssysteem geïnstalleerd samen met onze twee Python-modules voor het lezen van sensorgegevens en het verzenden van gegevens naar de initiële status, zijn we klaar om ons Python-script te schrijven. Het volgende script maakt/voegt toe aan een gegevensbucket met initiële status, leest de DHT22-sensorgegevens en stuurt die gegevens naar een realtime dashboard. Het enige dat u hoeft te doen, is de regels 6-11 wijzigen.

importeer Adafruit_DHT

van ISStreamer. Streamer import Streamer importtijd# --------- Gebruikersinstellingen --------- SENSOR_LOCATION_NAME = "Kantoor" BUCKET_NAME = ":partly_sunny: Kamertemperaturen" BUCKET_KEY = "rt0129" ACCESS_KEY = "PLAATS HIER UW EERSTE TOEGANGSSLEUTEL" MINUTES_BETWEEN_READS = 10METRIC_UNITS = False # --------------------------------- streamer = Streamer(bucket_name=BUCKET_NAME, bucket_key=BUCKET_KEY, access_key=ACCESS_KEY) while True: vochtigheid, temp_c = Adafruit_DHT.read_retry(Adafruit_DHT. DHT22, 4) if METRIC_UNITS: streamer.log(SENSOR_LOCATION_NAME + "Temperatuur(C)", temp_c): temp_f = format(temp_c * 9.0 / 5.0 + 32.0, ".2f") streamer.log(SENSOR_LOCATION_NAME + " Temperature(F)", temp_f) vochtigheid = format(humidity, ".2f") streamer.log(SENSOR_LOCATION_NAME + " Vochtigheid(%)", vochtigheid) streamer.flush() time.sleep(60*MINUTES_BETWEEN_READS)

• Regel 6 - Deze waarde moet uniek zijn voor elke node/temperatuursensor. Dit kan de kamernaam, fysieke locatie, unieke ID of wat dan ook zijn. Zorg ervoor dat het uniek is voor elk knooppunt om ervoor te zorgen dat de gegevens van dit knooppunt naar zijn eigen gegevensstroom in uw dashboard gaan.
• Regel 7 - Dit is de naam van de databucket. Dit kan op elk moment worden gewijzigd in de gebruikersinterface van de initiële status.
• Regel 8 - Dit is je bucket-sleutel. Het moet dezelfde bucketsleutel zijn voor elk knooppunt dat u in hetzelfde dashboard wilt weergeven.
• Regel 9 - Dit is de toegangssleutel van uw Initial State-account. Kopieer en plak deze sleutel van uw Initial State-account.
• Regel 10 - Dit is de tijd tussen sensoruitlezingen. Verander dienovereenkomstig.
• Regel 11 - U kunt metrische of Engelse eenheden opgeven op regel 11.

Nadat u regels 6-11 in uw Python-script op uw Pi hebt ingesteld, slaat u de teksteditor op en sluit u deze af. Voer het script uit met de volgende opdracht:

$ python tempsensor.py

Nu worden gegevens naar een dashboard met initiële status verzonden. Ga naar het laatste gedeelte van dit artikel voor meer informatie over het aanpassen van uw dashboard.

Stap 6: DSB18B20-oplossing

De lintkabel wordt aangesloten op de GPIO-pinnen op de Pi. De DS18B20 heeft drie draden. De rode draad wordt aangesloten op 3.3V. De blauw/zwarte draad wordt aangesloten op aarde. De gele draad wordt aangesloten op een pull-up-weerstand / pin 4. Zodra deze is aangesloten, schakelt u uw Pi in.

De nieuwste versie van Raspbian (kernel 3.18) vereist een toevoeging aan je /boot/config.txt-bestand om de Pi te laten communiceren met de DS18B20. Voer het volgende uit om dit bestand te bewerken:

$ sudo nano /boot/config.txt

Als de volgende regel nog niet in dit bestand staat (als dat wel het geval is, staat deze waarschijnlijk onderaan het bestand), voegt u deze toe en slaat u het bestand op.

dtoverlay=w1-gpio, gpiopin=4

Start uw Pi opnieuw op om de wijzigingen door te voeren.

$ sudo opnieuw opstarten

Om de leesinterface van de temperatuursensor te starten, moeten we twee opdrachten uitvoeren. Ga naar een opdrachtprompt op je Pi of SSH naar je Pi. Typ de volgende opdrachten:

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

De uitvoer van je temperatuursensor wordt nu naar een bestand op je Pi geschreven. Om dat bestand te vinden:

$ cd /sys/bus/w1/apparaten

In deze map zal er een submap zijn die begint met "28-". Wat na de "28-" komt, is het serienummer van uw sensor. cd in die map. In deze map bevat een bestand met de naam w1_slave de uitvoer van uw sensor. Gebruik nano om de inhoud van het bestand te bekijken. Nadat u het bestand hebt ingevoerd, ziet het er ongeveer zo uit:

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

Het getal na "t=" is het getal dat we willen. Dit is de temperatuur in 1/1000 graden Celsius (in het bovenstaande voorbeeld is de temperatuur 26,125 C). We hebben alleen een eenvoudig programma nodig dat dit bestand leest en dat nummer analyseert. Daar komen we zo op.

Alles is nu klaar voor ons om te beginnen met het streamen van gegevens. Typ het volgende in de opdrachtprompt om de teksteditor te openen:

$ nano temperatuur.py

Kopieer en plak de onderstaande code in de teksteditor.

importeer os

import glob importtijd van 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') lines = f.readlines() f.close() return regels 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 return temp_c while True: temp_c = read_temp() temp_f = temp_c * 9.0 / 5.0 + 32.0 streamer.log("temperatuur (C)", temp_c) streamer.log("temperatuur (F)", temp_f) time.sleep (.5)

U moet uw Initial State-toegangssleutel op regel 6 plaatsen in plaats van PUT_YOUR_ACCESS_KEY_HERE (kopieer de streamingsleutel naar uw klembord vanuit 'Mijn account' en plak deze in de code in nano in uw terminal).

Regel 6 maakt een bucket met de naam "Temperature Stream" in uw Initial State-account (ervan uitgaande dat u uw toegangssleutel correct hebt opgegeven op dezelfde regel). Regels 8 tot en met 30 van dit script communiceren eenvoudig met de DS18B20-sensor om de temperatuur te lezen uit het w1_slave-bestand dat we eerder hebben besproken. De functie read_temp_raw() op regel 15 leest het onbewerkte w1_slave-bestand. De functie read_temp() op regel 21 analyseert de temperatuur uit dat bestand. Lijn 34 roept deze functies op om de huidige temperatuur te krijgen. Lijn 35 zet de temperatuur om van Celsius naar Fahrenheit. Lijnen 35 en 36 streamen de temperatuur naar uw Initial State-account. Regel 37 pauzeert het script gedurende 0,5 seconde en stelt in hoe vaak de temperatuursensor wordt gelezen en gestreamd.

We zijn klaar om te beginnen met streamen. Voer de volgende opdracht uit:

$ sudo python temperatuur.py

Ga terug naar uw Initial State-account in uw webbrowser en zoek naar een nieuwe databucket met de naam Temperature Stream. Je zou temperatuurgegevens live moeten zien streamen. Varieer de temperatuur van de sensor door hem in je hand te houden of in een glas ijs te leggen.

Nu worden gegevens naar een dashboard met initiële status verzonden. Ga naar het laatste gedeelte van dit artikel voor meer informatie over het aanpassen van uw dashboard.

Stap 7: BME280-oplossing

U hebt het volgende nodig om deze oplossing te bouwen:

-BME280 Druk-, temperatuur- en vochtigheidssensor

Deze sensor wordt geleverd met pinnen die u op de sensor moet solderen. Ik raad aan om een breadboard te gebruiken met de pinnen met de lange kant naar beneden in het breadboard om het solderen gemakkelijker te maken. Zodra je dit hebt voltooid, moeten we de sensor op de Pi aansluiten.

Verbind de VIN-pin op de sensor met 3.3V pin 1 op de Pi. Verbind de GND-pin op de sensor met de grondpin 6 op de Pi. Verbind de SCK-pin op de sensor met de SCL-pin 5 op de Pi. Verbind de SDI-pin op de sensor met SDA-pin 3 op de Pi. U moet Python 3 gebruiken voor deze oplossing en de Initial State Streamer-module installeren met behulp van de pip3-installatiemethode.

Je moet ook een paar Adafruit Python-bibliotheken installeren.

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

Om de sensor te gebruiken, moeten we I2C op de Pi inschakelen.

sudo raspi-config

Hiermee wordt de Raspberry Pi-softwareconfiguratietool geopend. Ga naar Optie 5 Interface-opties. Ga vanaf hier naar I2C. Het zal u vragen of u I2C wilt inschakelen, Selecteer Ja en Voltooien. Nu heb je I2C ingeschakeld om met de sensor te communiceren.

We kunnen dit testen door het volgende uit te voeren:

sudo i2cdetect -y 1

Hiermee wordt gecontroleerd of je Pi de sensor ziet. Op de manier waarop het is aangesloten, zou het de sensor op adres 77 moeten tonen. Als u de sensor niet detecteert, start u uw Pi opnieuw op, schakelt u de I2C-interface-optie op uw Pi opnieuw in en probeert u het opnieuw. Zodra uw sensor is gedetecteerd, is het tijd om onze hoofdcode uit te voeren die gegevens naar de oorspronkelijke staat stuurt. Een bestand gemaakt met de naam bme280sensor.py met het nano-commando. Kopieer en plak de code uit de kern in de teksteditor. U moet wijzigingen aanbrengen in regel 12-19.

import tijd

import board import busio import adafruit_bme280 van ISStreamer. Streamer import Streamer # Maak een bibliotheekobject met onze Bus I2C porti2c = busio. I2C(board. SCL, board. SDA) bme280 = adafruit_bme280. Adafruit_BME280_I2C(i2c) # ------- -- Gebruikersinstellingen --------- SENSOR_LOCATION_NAME = "Kantoor" BUCKET_NAME = ":partly_sunny: Kamertemperatuur" BUCKET_KEY = "temp1" ACCESS_KEY = "UW TOEGANGSSLEUTEL HIER" # verander dit zodat het overeenkomt met de druk van de locatie (hPa) op zeeniveau bme280.sea_level_pressure = 1013.25 MINUTES_BETWEEN_READS = 10 METRIC_UNITS = False # --------------------------------- # OF maak een bibliotheekobject met onze Bus SPI-poort #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: vochtigheid = 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 + "Temperatuur(F)", temp_f) streamer.log(SENSOR_LOCATION_NAME + "Vochtigheid(%)", vochtigheid) streamer.log(SENSOR_LOCATION_NAME + "Druk(hPA)", druk) streamer.flush() time.sleep(60*MINUTES_BETWEEN_READS)

• Regel 12- Deze waarde moet uniek zijn voor elke node/temperatuursensor. Dit kan de kamernaam, fysieke locatie, unieke ID of wat dan ook van uw sensorknooppunt zijn. Zorg ervoor dat het uniek is voor elk knooppunt om ervoor te zorgen dat de gegevens van dit knooppunt naar zijn eigen gegevensstroom in uw dashboard gaan.
• Regel 13- Dit is de naam van de databucket. Dit kan op elk moment worden gewijzigd in de gebruikersinterface van de initiële status.
• Regel 14- Dit is je bucket-sleutel. Het moet dezelfde bucketsleutel zijn voor elk knooppunt dat u in hetzelfde dashboard wilt weergeven.
• Regel 15- Dit is de toegangssleutel van uw Initial State-account. Kopieer en plak deze sleutel van uw Initial State-account.
• Regel 17- Dit is de druk (hPa) van uw locatie op zeeniveau. U kunt deze informatie vinden op de meeste weerwebsites.
• Regel 18 - Dit is de tijd tussen sensormetingen. Wijzig dienovereenkomstig. Regel 19- Hier kunt u metrische of Engelse eenheden specificeren.

Nadat u regels 12-19 in uw Python-script op uw Pi Zero WH hebt ingesteld, slaat u de teksteditor op en sluit u deze af. Voer het script uit met de volgende opdracht:

$ python3 bme280sensor.py

Nu worden gegevens naar een dashboard met initiële status verzonden. Ga naar het laatste gedeelte van dit artikel voor meer informatie over het aanpassen van uw dashboard.

Stap 8: Sense HAT

De eerste stap bij het gebruik van de Sense HAT is om deze fysiek op uw Pi te installeren. Met de Pi uitgeschakeld, bevestig de HAT zoals weergegeven in de afbeelding.

Als je besluit om de oplossing te gebruiken zoals hierboven weergegeven, zul je merken dat de temperatuurmetingen van je Sense HAT wat hoog zullen zijn - dat is omdat ze dat zijn. De boosdoener is de warmte die wordt gegenereerd door de CPU van de Pi die de lucht rond de Sense HAT opwarmt wanneer deze bovenop de Pi zit. Om de temperatuursensor nuttig te maken, moeten we ofwel de HAT van de Pi halen of proberen de temperatuursensormeting te kalibreren. Een goede oplossing om de sensor uit de buurt van de Pi te krijgen, is een kabel waarmee de Sense HAT van de Pi kan bungelen. Een 6 , 40-pins IDE male naar female verlengkabel is voldoende.

Zodra je de twee opties hebt gekozen, zet je je Pi aan. We moeten de Python-bibliotheek installeren om het gemakkelijk te maken om de sensorwaarden van de Sense HAT te lezen. Eerst moet u ervoor zorgen dat alles up-to-date is in uw versie van Raspbian:

$ sudo apt-get update

Installeer vervolgens de Sense HAT Python-bibliotheek:

$ sudo apt-get install sense-hat

Start je Pi opnieuw op. We zijn klaar om de Sense HAT te testen door er sensorgegevens uit te lezen en die gegevens naar de beginstatus te sturen.

Maak een bestand met de naam sensehat en open het in de teksteditor door het volgende in te voeren in de opdrachtprompt:

$ nano sensehat.py

Kopieer en plak onderstaande code in de teksteditor.

van sense_hat importeer SenseHat

import tijd import sys van ISStreamer. Streamer import Streamer # --------- Gebruikersinstellingen --------- BUCKET_NAME = "Kantoorweer" BUCKET_KEY = "sensehat" ACCESS_KEY = "Your_Access_Key" SENSOR_LOCATION_NAME = " Kantoor" MINUTES_BETWEEN_SENSEHAT_READS = 0.1 # --------------------------------- streamer = Streamer (bucket_name=BUCKET_NAME, bucket_key=BUCKET_KEY, access_key=ACCESS_KEY) sense = SenseHat() while True: # Lees de sensoren temp_c = sense.get_temperature() vochtigheid = sense.get_humidity() pressure_mb = sense.get_pressure() # Formatteer de gegevens temp_f = temp_c * 9.0 / 5.0 + 32.0 temp_f = float("{0:.2f}".format(temp_f)) vochtigheid = float("{0:.2f}".format(humidity)) pressure_in = 0.03937008*(pressure_mb) pressure_in = float("{ 0:.2f}".format(pressure_in)) # Print en stream print SENSOR_LOCATION_NAME + " Temperature(F): " + str(temp_f) print SENSOR_LOCATION_NAME + " Vochtigheid(%): " + str(humidity) print SENSOR_LOCATION_NAME + " Druk(IN): " + str(druk_in) streamer.log(":zonnig: " + SEN SOR_LOCATION_NAME + " Temperature(F)", temp_f) streamer.log(":sweat_drops: " + SENSOR_LOCATION_NAME + " Vochtigheid(%)", vochtigheid) streamer.log(":cloud: " + SENSOR_LOCATION_NAME + " Pressure(IN)", pressure_in) streamer.flush() time.sleep(60*MINUTES_BETWEEN_SENSEHAT_READS)

Merk op de eerste regel op dat we de SenseHat-bibliotheek in het script importeren. Voordat u dit script uitvoert, moeten we onze gebruikersparameters instellen.

# --------- Gebruikersinstellingen ---------

BUCKET_NAME = "Kantoorweer"BUCKET_KEY = "sensehat"ACCESS_KEY = "Uw_Toegangssleutel"SENSOR_LOCATION_NAME = "Kantoor"MINUTES_BETWEEN_SENSEHAT_READS = 0.1# ------------------------ --------

In het bijzonder moet u uw ACCESS_KEY instellen op de toegangssleutel van uw Initial State-account. U kunt BUCKET_NAME en SENSOR_LOCATION_NAME wijzigen in de daadwerkelijke sensorlocatie. Sla op en verlaat de teksteditor.

Voer het script uit bij een opdrachtprompt op uw Pi:

$ sudo python sensehat.py

Nu worden gegevens naar een dashboard met initiële status verzonden. Ga naar het laatste gedeelte van dit artikel voor meer informatie over het aanpassen van uw dashboard.

Stap 9: Pas uw initiële statusdashboard aan

Ga naar uw Initial State-account en bekijk uw gegevens. U kunt met de rechtermuisknop op een tegel klikken om het diagramtype te wijzigen en op Tegels bewerken klikken om het formaat van uw tegels te wijzigen en ze te verplaatsen. Ik raad aan om de meterthermostaat te gebruiken voor temperatuur en het vloeistofniveau van de meter voor vochtigheid. U kunt lijngrafieken maken voor zowel temperatuur als vochtigheid om veranderingen in de loop van de tijd te zien. U kunt ook een achtergrondafbeelding aan uw dashboard toevoegen.

U kunt Trigger-waarschuwingen instellen, zodat u een sms of e-mail kunt ontvangen als de temperatuur onder of boven een bepaalde drempel daalt. Ga naar je databucket en klik op instellingen. Ga vanaf daar naar het tabblad Triggers. Voer de streamsleutel in die u wilt controleren, de operator die u wilt gebruiken en de drempelwaarde. Klik op het plusteken om de trigger toe te voegen. Vervolgens voert u uw e-mailadres of telefoonnummer in om de waarschuwing te ontvangen en klikt u op het plusteken. Nadat u al uw triggers hebt ingesteld, klikt u onderaan op de knop Gereed.

Nu je een temperatuurmonitor hebt gemaakt met een temperatuursensor en een Raspberry Pi, kun je gaan nadenken over welke andere omgevingsgegevens je vervolgens kunt controleren.