Spisu treści:
2025 Autor: John Day | [email protected]. Ostatnio zmodyfikowany: 2025-01-13 06:58
Temperatura i wilgotność to ważne punkty danych w dzisiejszym świecie przemysłowym. Monitorowanie danych środowiskowych dla serwerowni, zamrażarek komercyjnych i linii produkcyjnych jest niezbędne do zapewnienia płynnego działania. Istnieje wiele rozwiązań, od podstawowych do złożonych i może wydawać się przytłaczające, jeśli chodzi o potrzeby Twojej firmy i od czego zacząć.
Omówimy, jak monitorować temperaturę za pomocą Raspberry Pi i różnych czujników temperatury, których możesz użyć. To dobry początek, ponieważ te rozwiązania są niedrogie, łatwe do wykonania i dają podstawę do zbudowania dla innego monitoringu środowiskowego.
Kieszonkowe dzieci
- Raspberry Pi (3, 4 lub Zero WH)
- Czujnik temperatury (DHT2, DSB18B20, BME280 lub Sense HAT)
- 6" 40-pinowy przedłużacz IDE męski na żeński (rozwiązanie Sense HAT)
- Rezystor 10K, płytka stykowa, płytka zaciskowa 40-pinowa + kabel taśmowy, przewody (dla rozwiązania DSB18B20)
Krok 1: Raspberry Pi
Raspberry Pi to niedrogi komputer jednopłytkowy, który umożliwia podłączenie do czujnika temperatury i przesyłanie danych do oprogramowania do wizualizacji danych. Raspberry Pi początkowo było narzędziem edukacyjnym, które przekształciło się w narzędzie przemysłowego miejsca pracy. Łatwość użycia i możliwość kodowania w Pythonie, najszybciej rozwijającym się języku programowania, sprawiły, że są dobrym rozwiązaniem.
Będziesz potrzebować Raspberry Pi z wbudowanym Wi-Fi, czyli dowolnym modelem 3, 4 i zerowym W/WH. Pomiędzy tymi możesz wybierać na podstawie ceny i funkcji. Zero W/WH jest najtańszy, ale jeśli potrzebujesz większej funkcjonalności, możesz wybrać między 3 a 4. Możesz kupić tylko jeden Zero W/WH na raz ze względu na ograniczenia Raspberry Pi Foundation. Niezależnie od tego, jaki wybierzesz Pi, kup ładowarkę, ponieważ w ten sposób zasilisz Pi i kartę SD za pomocą Raspbian, aby instalacja systemu operacyjnego była jak najłatwiejsza.
Istnieje inny komputer jednopłytkowy, który również może działać, ale to na inny czas i inny artykuł.
Krok 2: Czujniki
Zalecamy stosowanie trzech czujników, ponieważ są niedrogie, łatwe do podłączenia i dają dokładne odczyty; DSB18B20, DHT22 i Raspberry Pi Sense HAT.
DHT22 - Ten czujnik temperatury i wilgotności ma dokładność temperatury +/- 0,5 C i zakres wilgotności od 0 do 100 procent. Podłączenie do Raspberry Pi jest proste i nie wymaga żadnych rezystorów podciągających.
DSB18B20 - Ten czujnik temperatury posiada wyjście cyfrowe, które dobrze współpracuje z Raspberry Pi. Ma trzy przewody i do połączenia wymaga płytki stykowej i rezystora.
BME280 - ten czujnik mierzy temperaturę, wilgotność i ciśnienie barometryczne. Może być używany zarówno w SPI, jak i I2C.
Sense HAT - Jest to dodatek do Raspberry Pi, który ma diody LED, czujniki i mały joystick. Łączy się bezpośrednio z GPIO na Raspberry Pi, ale za pomocą kabla taśmowego zapewnia dokładniejsze odczyty temperatury.
Krok 3: Konfiguracja Raspberry Pi
Jeśli po raz pierwszy konfigurujesz Raspberry Pi, musisz zainstalować system operacyjny Raspbian i podłączyć Pi do Wi-Fi. Będzie to wymagało monitora i klawiatury, aby połączyć się z Pi. Po uruchomieniu i połączeniu z WiFI Twoje Pi jest gotowe do pracy.
Krok 4: Początkowe konto stanu
Będziesz potrzebować miejsca, w którym możesz wysłać swoje dane, aby przechowywać dziennik historyczny i przeglądać strumień danych w czasie rzeczywistym, więc użyjemy stanu początkowego. Przejdź do https://iot.app.initialstate.com i utwórz nowe konto lub zaloguj się do istniejącego konta.
Następnie musimy zainstalować moduł Initial State Python na twoim Pi. W wierszu polecenia (nie zapomnij najpierw SSH do swojego Pi), uruchom następujące polecenie:
$ cd /home/pi/
$ \curl -sSL https://get.initialstate.com/python -o - | sudo bash
Po wprowadzeniu polecenia curl w wierszu polecenia zobaczysz na ekranie coś podobnego do następującego:
pi@raspberrypi ~
$ \curl -sSL https://get.initialstate.com/python -o - | Hasło sudo bash: Początek ISStreamer Python Łatwa instalacja! Instalacja może potrwać kilka minut, napij się kawy:) Ale nie zapomnij wrócić, będę miał pytania później! Znaleziono easy_install: setuptools 1.1.6 Znaleziono pip: pip 1.5.6 z /Library/Python/2.7/site-packages/pip-1.5.6-py2.7.egg (python 2.7) pip wersja główna: 1 pip wersja podrzędna: 5 Znaleziono ISStreamer, aktualizuję… Wymaganie już aktualne: ISStreamer w /Library/Python/2.7/site-packages Porządkowanie… Czy chcesz automagicznie uzyskać przykładowy skrypt? [t/N] Gdzie chcesz zapisać przykład? [domyślnie:./is_example.py] Wybierz, której aplikacji stanu początkowego używasz: 1. app.initialstate.com 2. [NOWOŚĆ!] iot.app.initialstate.com Wybierz 1 lub 2: Wpisz iot.app Nazwa użytkownika.initialstate.com: Wprowadź hasło iot.app.initialstate.com:
Gdy zostaniesz poproszony o automatyczne pobranie przykładowego skryptu, wpisz y. Spowoduje to utworzenie skryptu testowego, który możemy uruchomić, aby upewnić się, że możemy przesyłać strumieniowo dane do stanu początkowego. Następny monit zapyta, gdzie chcesz zapisać przykładowy plik. Możesz wpisać niestandardową ścieżkę lokalną lub nacisnąć Enter, aby zaakceptować domyślną lokalizację. Na koniec zostaniesz zapytany, której aplikacji stanu początkowego używasz. Jeśli niedawno utworzyłeś konto, wybierz opcję 2, wprowadź swoją nazwę użytkownika i hasło. Po tym instalacja zostanie zakończona.
Rzućmy okiem na przykładowy skrypt, który został stworzony.
$ nano is_example.py
W wierszu 15 zobaczysz wiersz zaczynający się od streamer = Streamer(bucket_ …. Ten wiersz tworzy nowy zasobnik danych o nazwie „Przykład strumienia Pythona” i jest powiązany z Twoim kontem. To powiązanie dzieje się z powodu access_key = „…” w tym samym wierszu. Ta długa seria liter i cyfr to klucz dostępu do konta stanu początkowego. Jeśli przejdziesz do konta stanu początkowego w przeglądarce internetowej, kliknij swoją nazwę użytkownika w prawym górnym rogu, a następnie przejdź do „moich ustawień”, ten sam klucz dostępu znajdziesz tutaj w sekcji „Klucze dostępu do transmisji strumieniowej”.
Za każdym razem, gdy tworzysz strumień danych, ten klucz dostępu przekieruje strumień danych na Twoje konto (więc nie udostępniaj nikomu swojego klucza).
Uruchom skrypt testowy, aby upewnić się, że możemy utworzyć strumień danych na Twoje konto stanu początkowego. Uruchom następujące:
$ python is_example.py
Wróć do swojego konta stanu początkowego w przeglądarce internetowej. Po lewej stronie na półce dziennika powinien pojawić się nowy zasobnik danych o nazwie „Przykład strumienia Pythona” (może być konieczne odświeżenie strony). Kliknij to wiadro, a następnie kliknij ikonę Fale, aby wyświetlić dane testowe
Jeśli używasz Pythona 3, możesz zainstalować Moduł Streamera Stanu początkowego, który możesz zainstalować za pomocą następującego polecenia:
pip3 zainstaluj ISStreamer
Teraz jesteśmy gotowi do skonfigurowania czujnika temperatury z Pi, aby przesyłać temperaturę do pulpitu nawigacyjnego.
Krok 5: Rozwiązanie DHT22
DHT22 będzie miał trzy piny - 5V, Gnd i data. Powinna znajdować się etykieta pinów do zasilania DHT22 (np. „+” lub „5 V”). Podłącz to do pinu 2 (prawy górny pin, 5V) Pi. Pin Gnd będzie oznaczony jako „-” lub „Gnd” lub coś równoważnego. Podłącz to do pinu 6 Gnd (dwa piny poniżej pinu 5V) na Pi. Pozostały pin na DHT22 to pin danych i będzie oznaczony jako „out” lub „s” lub „data”. Podłącz to do jednego z pinów GPIO na Pi, takich jak GPIO4 (pin 7). Po podłączeniu włącz swoje Pi.
Zainstaluj moduł Adafruit DHT Python z wiersza poleceń, aby bardzo ułatwić odczytywanie danych czujnika DHT22:
$ sudo pip zainstaluj Adafruit_DHT
Po zainstalowaniu naszego systemu operacyjnego wraz z dwoma modułami Pythona do odczytywania danych z czujników i wysyłania danych do stanu początkowego, jesteśmy gotowi do napisania naszego skryptu w języku Python. Poniższy skrypt utworzy/dołączy do zasobnika danych stanu początkowego, odczyta dane z czujnika DHT22 i wyśle te dane do pulpitu nawigacyjnego w czasie rzeczywistym. Wszystko, co musisz zrobić, to zmodyfikować wiersze 6–11.
importuj Adafruit_DHT
from ISStreamer. Streamer import Streamer import time# --------- Ustawienia użytkownika --------- SENSOR_LOCATION_NAME = "Biuro" BUCKET_NAME = ":partly_sunny: Temperatura w pomieszczeniu" BUCKET_KEY = "rt0129" ACCESS_KEY = "TUTAJ UMIEŚĆ SWÓJ KLUCZ DOSTĘPU STANU POCZĄTKOWEGO" MINUTES_BETWEEN_READS = 10METRIC_UNITS = Fałsz # --------------------------------- streamer = Streamer(bucket_name=BUCKET_NAME, bucket_key=BUCKET_KEY, access_key=ACCESS_KEY) while True: wilgotność, temp_c = Adafruit_DHT.read_retry(Adafruit_DHT. DHT22, 4) if METRIC_UNITS: streamer.log(SENSOR_LOCATION_NAME + "Temperatura(C)else)", temp: temp_f = format(temp_c * 9.0 / 5.0 + 32.0, ".2f") streamer.log(NAZWA_LOKALIZACJI_CZUJNIKA + "Temperatura(F)", temp_f) wilgotność = format(wilgotność, ".2f") streamer.log(NAZWA_LOKALIZACJI_CZUJNIKA + " Wilgotność (%)", wilgotność) streamer.flush() time.sleep(60*MINUTES_BETWEEN_READS)
- Wiersz 6 - ta wartość powinna być unikalna dla każdego węzła/czujnika temperatury. Może to być nazwa pokoju węzła czujnika, lokalizacja fizyczna, unikalny identyfikator lub cokolwiek innego. Po prostu upewnij się, że jest unikalny dla każdego węzła, aby dane z tego węzła trafiały do własnego strumienia danych na pulpicie nawigacyjnym.
- Wiersz 7 - to jest nazwa zasobnika danych. Można to zmienić w dowolnym momencie w interfejsie użytkownika stanu początkowego.
- Linia 8 - To jest twój klucz do wiadra. Musi to być ten sam klucz zasobnika dla każdego węzła, który chcesz wyświetlić w tym samym panelu.
- Wiersz 9 - To jest klucz dostępu do konta stanu początkowego. Skopiuj i wklej ten klucz z konta stanu początkowego.
- Linia 10 - Jest to czas między odczytami czujnika. Zmień odpowiednio.
- Wiersz 11 - w wierszu 11 można określić jednostki metryczne lub imperialne.
Po ustawieniu wierszy 6–11 w skrypcie Pythona na swoim Pi, zapisz i wyjdź z edytora tekstu. Uruchom skrypt za pomocą następującego polecenia:
$ python tempsensor.py
Teraz będziesz mieć wysyłanie danych do pulpitu stanu początkowego. Przejdź do ostatniej sekcji tego artykułu, aby uzyskać szczegółowe informacje na temat dostosowywania pulpitu nawigacyjnego.
Krok 6: Rozwiązanie DSB18B20
Kabel taśmowy łączy się z pinami GPIO na Pi. DS18B20 ma trzy przewody. Czerwony przewód łączy się z 3,3V. Niebiesko-czarny przewód łączy się z uziemieniem. Żółty przewód łączy się z rezystorem podciągającym / stykiem 4. Po podłączeniu włącz swoje Pi.
Najnowsza wersja Raspbian (kernel 3.18) wymaga dodania do pliku /boot/config.txt, aby Pi mogło komunikować się z DS18B20. Uruchom następujące polecenie, aby edytować ten plik:
$ sudo nano /boot/config.txt
Jeśli następujący wiersz nie znajduje się jeszcze w tym pliku (jeśli tak jest, prawdopodobnie znajduje się na dole pliku), dodaj go i zapisz plik.
dtoverlay=w1-gpio, gpiopin=4
Zrestartuj swoje Pi, aby zmiany zaczęły obowiązywać.
$ restart sudo
Aby uruchomić interfejs odczytu czujnika temperatury musimy uruchomić dwie komendy. Przejdź do wiersza polecenia na swoim Pi lub SSH do swojego Pi. Wpisz następujące polecenia:
$ sudo modprobe w1-gpio$ sudo modprobe w1-therm
Wyjście czujnika temperatury jest teraz zapisywane do pliku na twoim Pi. Aby znaleźć ten plik:
$ cd /sys/bus/w1/urządzenia
W tym katalogu będzie podkatalog zaczynający się od „28-”. Po „28-” pojawia się numer seryjny czujnika. cd do tego katalogu. Wewnątrz tego katalogu plik o nazwie w1_slave zawiera dane wyjściowe twojego czujnika. Użyj nano, aby wyświetlić zawartość pliku. Po wejściu do pliku będzie on wyglądał mniej więcej tak:
a2 01 4b 46 7f ff 0e 10 d8: crc=d8 TAKa2 01 4b 46 7f ff 0e 10 d8 t=26125
Liczba po „t=” jest liczbą, którą chcemy. Jest to temperatura w 1/1000 stopni Celsjusza (w powyższym przykładzie temperatura wynosi 26,125 C). Potrzebujemy tylko prostego programu, który odczytuje ten plik i analizuje ten numer. Dojdziemy do tego za chwilę.
Wszystko jest teraz gotowe do rozpoczęcia strumieniowego przesyłania danych. Aby otworzyć edytor tekstu, wpisz w wierszu polecenia:
$ nano temperatura.py
Skopiuj i wklej poniższy kod do edytora tekstu.
importuj system
import glob import time z ISStreamer. Streamer import Streamerstreamer = Streamer(bucket_name="strumień temperatury", 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 lines def read_temp(): lines = read_temp_raw() while lines[0].strip()[-3:] != 'TAK': 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 zwraca temp_c podczas True: temp_c = read_temp() temp_f = temp_c * 9.0 / 5.0 + 32,0 streamer.log("temperatura (C)", temp_c) streamer.log("temperatura (F)", temp_f) time.sleep (.5)
Musisz umieścić swój klucz dostępu do stanu początkowego w wierszu 6 zamiast PUT_YOUR_ACCESS_KEY_HERE (skopiuj klucz przesyłania strumieniowego do schowka z „Moje konto” i wklej go do kodu w nano terminalu).
Wiersz 6 utworzy zasobnik o nazwie „Strumień temperatury” na Twoim koncie stanu początkowego (zakładając, że poprawnie określiłeś klucz dostępu w tym samym wierszu). Wiersze od 8 do 30 tego skryptu po prostu łączą się z czujnikiem DS18B20, aby odczytać jego temperaturę z pliku w1_slave, który omawialiśmy wcześniej. Funkcja read_temp_raw() w linii 15 odczytuje surowy plik w1_slave. Funkcja read_temp() w wierszu 21 analizuje temperaturę z tego pliku. Linia 34 wywołuje te funkcje, aby uzyskać aktualną temperaturę. Linia 35 zamienia temperaturę z Celsjusza na Fahrenheita. Linie 35 i 36 przesyłają temperaturę na Twoje konto stanu początkowego. Linia 37 zatrzymuje skrypt na 0,5 sekundy, ustawiając jak często czujnik temperatury będzie odczytywany i przesyłany strumieniowo.
Jesteśmy gotowi do rozpoczęcia transmisji. Uruchom następujące polecenie:
$ temperatura sudo Pythona.py
Wróć do konta stanu początkowego w przeglądarce internetowej i poszukaj nowego zasobnika danych o nazwie Strumień temperatury. Powinieneś zobaczyć przesyłane strumieniowo dane o temperaturze na żywo. Zmieniaj temperaturę czujnika, trzymając go w dłoni lub wkładając do szklanki lodu.
Teraz będziesz mieć wysyłanie danych do pulpitu stanu początkowego. Przejdź do ostatniej sekcji tego artykułu, aby uzyskać szczegółowe informacje na temat dostosowywania pulpitu nawigacyjnego.
Krok 7: Rozwiązanie BME280
Do zbudowania tego rozwiązania potrzebne będą następujące elementy:
-BME280 Czujnik ciśnienia, temperatury i wilgotności
Ten czujnik jest dostarczany z pinami, które musisz przylutować do czujnika. Zalecam użycie płytki stykowej z pinami długim bokiem w dół do płytki stykowej, aby ułatwić lutowanie. Po zakończeniu tego musimy podłączyć czujnik do Pi.
Podłącz pin VIN czujnika do pinu 1 3.3V na Pi. Podłącz pin GND na czujniku do pinu uziemienia 6 na Pi. Podłącz pin SCK na czujniku do pinu 5 SCL na Pi. Podłącz pin SDI na czujniku do pinu 3 SDA na Pi. Do tego rozwiązania musisz używać Pythona 3 i zainstalować moduł Initial State Streamer za pomocą metody instalacji pip3.
Będziesz także musiał zainstalować kilka bibliotek Adafruit Python.
pip3 zainstaluj adafruit-blinkapip3 zainstaluj pureio pip3 zainstaluj spidev pip3 zainstaluj adafruit-GPIO pip3 zainstaluj adafruit-circuitpython-bme280
Aby korzystać z czujnika, musimy włączyć I2C na Pi.
sudo raspi-config
Spowoduje to otwarcie narzędzia konfiguracji oprogramowania Raspberry Pi. Przejdź do Opcji 5 Opcje interfejsu. Stąd przejdź do I2C. Zostanie wyświetlony monit z pytaniem, czy chcesz włączyć I2C, wybierz Tak i Zakończ. Teraz masz włączone I2C do komunikacji z czujnikiem.
Możemy to przetestować, uruchamiając:
sudo i2cdetect -y 1
To zweryfikuje, czy Twoje Pi widzi czujnik. Sposób, w jaki jest podłączony, powinien pokazywać czujnik pod adresem 77. Jeśli nie wykryjesz czujnika, uruchom ponownie swoje Pi, włącz ponownie opcję interfejsu I2C w swoim Pi i spróbuj ponownie. Po wykryciu czujnika nadszedł czas uruchomić nasz główny kod, który wyśle dane do stanu początkowego. Utworzono plik o nazwie bme280sensor.py za pomocą polecenia nano. Skopiuj i wklej kod z Gist do edytora tekstu. Musisz wprowadzić zmiany w liniach 12–19.
czas importu
import board import busio import adafruit_bme280 z ISStreamer. Streamer import Streamer # Utwórz obiekt biblioteki za pomocą naszej magistrali I2C porti2c = busio. I2C(board. SCL, board. SDA) bme280 = adafruit_bme280. Adafruit_BME280_I2C(i2c) # ------- -- Ustawienia użytkownika --------- SENSOR_LOCATION_NAME = "Biuro" BUCKET_NAME = ":partly_sunny: Temperatura w pomieszczeniu" BUCKET_KEY = "temp1" ACCESS_KEY = "TUTAJ TWÓJ KLUCZ DOSTĘPU" # zmień to, aby dopasować ciśnienie lokalizacji (hPa) na poziomie morza bme280.sea_level_pressure = 1013.25 MINUTES_BETWEEN_READS = 10 METRIC_UNITS = False # --------------------------------- # LUB utwórz obiekt biblioteki używając naszego portu 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: wilgotność = format(bme280.humidity, ".1f") pressure = format(bme280.pressure, ".1f") temp_c = bme280.temperatu re if METRIC_UNITS: streamer.log(SENSOR_LOCATION_NAME + "Temperatura(C)", temp_c) else: temp_f = format(temp_c * 9.0 / 5.0 + 32.0, ".1f") streamer.log(SENSOR_LOCATION_NAME + "Temperatura(F)", temp_f) streamer.log(SENSOR_LOCATION_NAME + "Wilgotność(%)", wilgotność) streamer.log(SENSOR_LOCATION_NAME + "Ciśnienie(hPA)", ciśnienie) streamer.flush() time.sleep(60*MINUTES_BETWEEN_READS)
- Wiersz 12- Ta wartość powinna być unikalna dla każdego węzła/czujnika temperatury. Może to być nazwa pokoju węzła czujnika, lokalizacja fizyczna, unikalny identyfikator lub cokolwiek innego. Po prostu upewnij się, że jest unikalny dla każdego węzła, aby dane z tego węzła trafiały do własnego strumienia danych na pulpicie nawigacyjnym.
- Wiersz 13 - to jest nazwa zasobnika danych. Można to zmienić w dowolnym momencie w interfejsie użytkownika stanu początkowego.
- Linia 14- To jest twój klucz do wiadra. Musi to być ten sam klucz zasobnika dla każdego węzła, który chcesz wyświetlić w tym samym panelu.
- Linia 15- To jest twój klucz dostępu do konta stanu początkowego. Skopiuj i wklej ten klucz z konta stanu początkowego.
- Linia 17- to ciśnienie w Twojej lokalizacji (hPa) na poziomie morza. Informacje te można znaleźć na większości serwisów pogodowych.
- Linia 18 - Jest to czas pomiędzy odczytami czujnika. Zmień odpowiednio. Wiersz 19- Tutaj możesz określić jednostki metryczne lub imperialne.
Po ustawieniu wierszy od 12 do 19 w skrypcie Pythona w Pi Zero WH, zapisz i wyjdź z edytora tekstu. Uruchom skrypt za pomocą następującego polecenia:
$ python3 bme280sensor.py
Teraz będziesz mieć wysyłanie danych do pulpitu stanu początkowego. Przejdź do ostatniej sekcji tego artykułu, aby uzyskać szczegółowe informacje na temat dostosowywania pulpitu nawigacyjnego.
Krok 8: wyczuj kapelusz
Pierwszym krokiem w korzystaniu z Sense HAT jest fizyczne zainstalowanie go na twoim Pi. Przy wyłączonym Pi, przymocuj HAT, jak pokazano na rysunku.
Jeśli zdecydujesz się użyć rozwiązania, jak pokazano powyżej, możesz zauważyć, że odczyty temperatury Sense HAT będą nieco wysokie - to dlatego, że tak jest. Winowajcą jest ciepło generowane przez procesor Pi, które ogrzewa powietrze wokół Sense HAT, gdy siedzi on na górze Pi. Aby czujnik temperatury był użyteczny, musimy albo odsunąć HAT od Pi, albo spróbować skalibrować odczyt czujnika temperatury. Dobrym rozwiązaniem dla odsunięcia czujnika od Pi jest kabel, który pozwala Sense HAT zwisać z Pi. 6 , 40-pinowy przedłużacz IDE męski na żeński wystarczy.
Gdy zdecydujesz się na dwie opcje, włącz swoje Pi. Musimy zainstalować bibliotekę Pythona, aby ułatwić odczytywanie wartości czujników z Sense HAT. Najpierw musisz upewnić się, że wszystko jest aktualne w Twojej wersji Raspbian:
$ sudo apt-get update
Następnie zainstaluj bibliotekę Sense HAT Python:
$ sudo apt-get install sense-hat
Zrestartuj swoje Pi. Jesteśmy gotowi do przetestowania Sense HAT, odczytując z niego dane czujnika i wysyłając je do stanu początkowego.
Utwórz plik o nazwie sensehat i otwórz go w edytorze tekstu, wpisując w wierszu polecenia następujące polecenie:
$ nano sensehat.py
Skopiuj i wklej poniższy kod w edytorze tekstu.
z Sense_hat import SenseHat
import time import sys z ISStreamer. Streamer import Streamer # --------- Ustawienia użytkownika --------- BUCKET_NAME = "Pogoda w biurze" BUCKET_KEY = "sensehat" ACCESS_KEY = "Your_Access_Key" SENSOR_LOCATION_NAME = " Biuro" MINUTES_BETWEEN_SENSEHAT_READS = 0.1 # --------------------------------- streamer = Streamer(bucket_name=BUCKET_NAME, bucket_key=BUCKET_KEY, access_key=ACCESS_KEY) sense = SenseHat() while True: # Odczytaj czujniki temp_c = sense.get_temperature() wilgotność = sense.get_humidity() pressure_mb = sense.get_pressure() # Formatuj dane temp_f = temp_c * 9.0 / 5.0 + 32.0 temp_f = float("{0:.2f}".format(temp_f)) wilgotność = float("{0:.2f}".format(wilgotność)) pressure_in = 0.03937008*(pressure_mb) pressure_in = float("{ 0:.2f}.format(pressure_in)) # Drukuj i przesyłaj print SENSOR_LOCATION_NAME + " Temperature(F): " + str(temp_f) print SENSOR_LOCATION_NAME + " Humidity(%): " + str(humidity) print SENSOR_LOCATION_NAME + " Ciśnienie(we): " + str(pressure_in) streamer.log(":sunny: " + SEN SOR_LOCATION_NAME + " Temperatura(F)", temp_f) streamer.log(":sweat_drops: " + SENSOR_LOCATION_NAME + " Wilgotność(%)", wilgotność) streamer.log(":cloud: " + SENSOR_LOCATION_NAME + " Ciśnienie(IN)", ciśnienie_w) streamer.flush() time.sleep(60*MINUTES_BETWEEN_SENSEHAT_READS)
Zauważ w pierwszym wierszu, że importujemy bibliotekę SenseHat do skryptu. Zanim uruchomisz ten skrypt, musimy skonfigurować nasze parametry użytkownika.
# --------- Ustawienia użytkownika ---------
BUCKET_NAME = "Pogoda w biurze"BUCKET_KEY = "sensehat"ACCESS_KEY = "Twój_klucz_dostępu"SENSOR_LOCATION_NAME = "Biuro"MINUTES_BETWEEN_SENSEHAT_READS = 0.1# ----------------------------- --------
W szczególności musisz ustawić klucz ACCESS_KEY na klucz dostępu do konta stanu początkowego. Możesz zmienić BUCKET_NAME i SENSOR_LOCATION_NAME na rzeczywistą lokalizację czujnika. Zapisz i wyjdź z edytora tekstu.
W wierszu polecenia na swoim Pi uruchom skrypt:
$ sudo python sensehat.py
Teraz będziesz mieć wysyłanie danych do pulpitu stanu początkowego. Przejdź do ostatniej sekcji tego artykułu, aby uzyskać szczegółowe informacje na temat dostosowywania pulpitu nawigacyjnego.
Krok 9: Dostosuj swój początkowy pulpit nawigacyjny
Przejdź do swojego konta stanu początkowego i spójrz na swoje dane. Możesz kliknąć prawym przyciskiem myszy kafelek, aby zmienić typ wykresu i kliknąć Edytuj kafelki, aby zmienić rozmiar i przenieść kafelki. Zalecam używanie termostatu miernika do temperatury i poziomu cieczy miernika do wilgotności. Możesz tworzyć wykresy liniowe dla temperatury i wilgotności, aby zobaczyć zmiany w czasie. Możesz także dodać obraz tła do pulpitu nawigacyjnego.
Możesz ustawić alerty wyzwalacza, aby otrzymywać SMS-y lub e-maile, gdy temperatura spadnie poniżej lub przekroczy określony próg. Przejdź do swojego zasobnika danych i kliknij ustawienia. Stamtąd przejdź do zakładki Wyzwalacze. Wprowadź klucz strumienia, który chcesz monitorować, operatora, którego chcesz użyć, oraz wartość progową. Kliknij znak plus, aby dodać wyzwalacz. Następnie wpisz swój adres e-mail lub numer telefonu, aby otrzymać alert na i kliknij znak plus. Po ustawieniu wszystkich wyzwalaczy kliknij przycisk Gotowe na dole.
Teraz, gdy stworzyłeś monitor temperatury za pomocą czujnika temperatury i Raspberry Pi, możesz zacząć myśleć o tym, jakie inne dane środowiskowe możesz monitorować w następnej kolejności.