Stacja pogodowa Raspberry PI LED: 8 kroków

2024 Autor: John Day | [email protected]. Ostatnio zmodyfikowany: 2024-01-30 11:28

Stworzyliśmy Pogodową Stację Pogodową Raspberry PI. Informuje użytkownika, jak gorące i zimne jest miasto, zapalając i ściemniając diody led. Ma również diodę, która mówi im, czy pada deszcz w mieście, w którym wpisali.

Stworzony przez Michaela Andrewsa i Tio Marello.

Kieszonkowe dzieci

Narzędzia

1. Lutownica
2. Dremel
3. Piła

Materiały

1. Raspberry Pi 3 B+ ~40 dolarów ~ 30 dolarów
2. Przewody żeńsko-męskie ~7 dolarów
3. 3 niebieskie i 2 czerwone diody LED ~ 11 dolarów
4. Rezystory 100 Ohm ~ 13 dolarów
5. 4 x 4 x 1/4 deski drewnianej ~ 5 dolarów
6. Lutowane ~ 10 dolarów
7. Drut miedziany ~ 5 dolarów

Krok 1: Kodowanie jako rozwiązywanie problemów

Kodowanie to rozwiązywanie problemów

Więc w naszym projekcie, jaki jest nasz problem? Naszym problemem jest uzyskanie danych o pogodzie, a następnie wykorzystanie tych danych do poinformowania naszych diod LED, czy są wyłączone, czy włączone. To dzieli nasz problem na trzy obszary.

1. Uzyskiwanie danych o pogodzie

2. Korzystanie z tych danych

3. Korzystanie z diod LED

Jednak język, którego użyliśmy w tym projekcie, Python i sprzęt, na którym działa, Python, dają nam łatwy sposób na osiągnięcie tych celów.

Zaczniemy więc od pierwszego problemu, czyli uzyskania danych o pogodzie.

Krok 2: Kodowanie: Pobieranie danych o pogodzie

Sam Python nie może uzyskać danych pogodowych. Musimy zaimportować dwa narzędzia, a także zewnętrzną usługę, aby uzyskać dane pogodowe. W tym celu korzystamy z trzech narzędzi.

1. Requests, moduł Pythona umożliwiający webscraping

2. Json, moduł Pythona, który pozwala nam korzystać z formatu pliku JSON

3. OpenWeather, strona internetowa, która może dostarczyć nam dane pogodowe

Tak więc wprowadzamy dwa moduły, pisząc ten kod na początku naszego skryptu Pythona.

żądania importu

importuj json

Zanim jednak użyjemy tych narzędzi, musimy skorzystać z Openweathera. W tym celu musimy założyć konto na ich stronie i uzyskać klucz API. Postępuj zgodnie z instrukcjami na ich stronie internetowej, a otrzymasz ciąg liter i cyfr, które pozwolą nam korzystać z ich usług. Jak?

openweather_api_key = "260a23f27f5324ef2ae763c779c32d7e" #Nasz klucz API (nieprawdziwy)

base_call = "https://api.openweathermap.org/data/2.5/weather?q=" #OpenWeather Call #Tutaj otrzymujemy miasto użytkownika w postaci tekstu print("Wpisz miasto!") city_name = input () #Tu zestawiliśmy adres, który podłączymy do requests.get, aby otrzymać dane o pogodzie full_call = base_call+city_name+"&appid="+openweather_api_key #W końcu wywołujemy request.get naszym adresem, a następnie konwertujemy go do pliku json Response = requests.get(full_call) WeatherData = Response.json() #Pliki JSON zawierają różne zmienne, do których możemy uzyskać dostęp za pomocą tej składni #Tutaj otrzymujemy identyfikator pogody i temperaturę w Kelvinach miasta, które użytkownik wpisał w WeatherID = WeatherData ["pogoda"][0]["id"] City_TemperatureK = WeatherData["główna"]["temp"]

Tutaj mamy kod, który dostarcza nam nasze dane pogodowe. Requests, w postaci request.get, pobiera adres strony internetowej i zwraca nam plik z tej strony. OpenWeather podaje nam adres, pod który należy zadzwonić, aby przekazać nam dane pogodowe w postaci json. Łączymy adres, który podłączamy do żądań i odzyskujemy plik json. Następnie tworzymy dwie zmienne i przypisujemy je do temperatury i pogody w mieście użytkownika.

Więc teraz, z tym kodem, mamy dwie zmienne. Mamy identyfikator pogody i temperaturę w Kelwinach

Krok 3: Kodowanie: wykorzystanie tych danych

Teraz, gdy mamy te dwie zmienne, musimy przygotować je do użycia w naszych diodach LED. W tym aspekcie nie musimy do tego importować żadnych modułów.

Najpierw zamieniamy kelwin na stopnie Fahrenheita.

Robimy to, tworząc zmienną o tej składni

Miasto_Temperatura F = (Miasto_Temperatura K - 273)*1,8 + 32

który konwertuje z Kelvina na Fahrenheita (co tak naprawdę konwertuje z K -> C -> F)

Dalej jest nasz identyfikator pogody. WeatherID to identyfikator dostarczany przez Openweather, który informuje nas o warunkach pogodowych w mieście.

openweathermap.org/weather-conditions Oto ich lista.

Zauważyliśmy, że wszystko poniżej 700 to jakiś rodzaj opadów, więc po prostu sprawdziliśmy, czy kod jest poniżej 700, aby zobaczyć, czy pada deszcz.

def CheckRain(IdCode): if IdCode < 700: return True else: return False

Dzięki temu mamy nasze dwie zmienne przygotowane do użycia z naszymi pinami Raspberry PI i diodami LED.

Krok 4: Kodowanie: za pomocą RPi. GPIO i diod LED

RaspberryPi jest wyposażony w zestaw męskich pinów, których możemy użyć do komunikacji z wieloma komponentami elektrycznymi, którymi w tym przypadku są diody LED; jest podobny do Arduino i jego systemu. Jednak Raspberry PI jest komputerem ogólnego przeznaczenia, w przeciwieństwie do mikrokontrolera takiego jak Arduino. Tak więc musimy wykonać trochę więcej pracy, aby z nich korzystać. Polega to na ustawieniu pinów na Raspberry Pi. Robimy to za pomocą tego kodu.

import RPi. GPIO jako GPIO #Importujemy moduł, abyśmy mogli z niego korzystać

#Skonfiguruj pinyGPIO.setmode(GPIO. BCM) GPIO.setwarnings(False)

#Styki, do których podłączone są diody LED. Mogą się one różnić, jeśli je zbudujesz, więc pamiętaj, aby porównać i zmienić w razie potrzeby

Extreme_Hot_LED_PIN = 26 Hot_LED_PIN = 16

Extreme_Cold_LED_PIN = 5

Zimna_LED_PIN = 6

Deszcz_LED_PIN = 23

#Przechodzimy przez każdy pin, używając polecenia.setup, wpisując jego numer i ustawiając go jako pin wyjściowy

GPIO.setup(Rain_LED_PIN, GPIO. OUT)GPIO.setup(Extreme_Cold_LED_PIN, GPIO. OUT) GPIO.setup(Cold_LED_PIN, GPIO. OUT) GPIO.setup(Hot_LED_PIN, GPIO. OUT) GPIO.setup.(ExtremeLED_PIN, GPIO. OUT)

Jednak ten kod pozwoliłby nam używać tylko dwóch stanów z ledem, to znaczy włączenia i wyłączenia. Jednak potrzebujemy go, aby móc przyciemnić światła. W tym celu używamy modulacji szerokości impulsu.

Korzystanie z modulacji szerokości impulsu

Modulacja szerokości impulsu pozwala nam na wyprowadzenie sygnału analogowego za pomocą pinu cyfrowego. Zasadniczo włącza i wyłącza źródło sygnału z dużą szybkością, która uśrednia się do określonego napięcia. RPi. GPIO pozwala nam na użycie tego, aczkolwiek z dodatkowym kodem.

#Tworzymy cztery obiekty pinów za pomocą polecenia GPIO. PWM, które pobiera numer kanału

#Druga liczba to liczba aktualizacji na sekundę

ExtremeHotLED = GPIO. PWM(Extreme_Hot_LED_PIN, 100)HotLED = GPIO. PWM(Hot_LED_PIN, 100)

ExtremeColdLED = GPIO. PWM(Extreme_Cold_LED_PIN, 100)

ColdLED = GPIO. PWM(Cold_LED_PIN, 100)

W następnym kroku musisz wiedzieć, w jaki sposób aktualizujemy te szpilki.

Aktualizujemy szpilki za pomocą polecenia

ExtremeColdLED.start(x)ColdLED.start(x)

ExtremeHotLED.start(x)

HotLED.start(x)

xw tym przypadku byłby współczynnikiem wypełnienia, który określa, jak bardzo pulsuje. Waha się on od 0-100, więc musimy oprzeć nasz następny kod na tym fakcie.

Krok 5: Kodowanie: uzyskanie jasności LED

Ponieważ mamy cztery różne diody led, chcemy je zapalić w zależności od tego, jak. zimno lub gorąco jest w mieście użytkownika. Zdecydowaliśmy się na cztery etapy na czele.

#Funkcje

def getmiddleleftledintensity(TemperaturawF): #Równanie lewej strony: y=-(50/20)x + 175 #Równanie prawej strony: y = (50/20)x - 75 return -(50/20)*Temperatura wF + 175

def getmiddlerightledintensity(Temperatura w F):

#Równanie z lewej: y=-(50/20)x + 175 #Równanie z prawej: y = (50/20)x - 75 powrót (50/20)*Temperatura w F - 75

def getextremeleftledintensity(Temperatura wF):

#LeweRównanie: y = -(100/30)x + 200 #PraweRównanie: y = (100/30)x - (400/3)

powrót -(100/30)*Temperatura wF + 200

def getextremerightledintensity(Temperatura wF):

# LeftEquation: y = -(100/30)x + 200 # RightEquation: y = (100/30)x - (400/3)

powrót (100/30)*Temperatura wF - (400/3)

#Ustawianie świateł LED

def PobierzLEDJasność(temp):

jeśli temp <= 0: ekstremalnie zimna = 100 zimna = 100 zimna = 0 ekstremalnie zimna = 0

print("Ekstremalnie zimny led:" + str(ekstremalnie zimny))

print("Zimna dioda:" + str(zimna)) print("Skrajnie gorąca dioda" + str(ekstremalnie gorąca)) print("Gorąca dioda:" + str(gorąca))

ExtremeColdLED.start(ekstremalnie zimny)

ColdLED.start(schłodzony)

ExtremeHotLED.start(extremehotled)

HotLED.start(hotled) elif temp >= 100: extremecoldled = 0 coldled = 0 hotled = 100 extremehotled = 100

print("Ekstremalnie zimny led:" + str(ekstremalnie zimny))

print("Zimna dioda:" + str(zimna)) print("Skrajnie gorąca dioda" + str(ekstremalnie gorąca)) print("Gorąca dioda:" + str(gorąca))

ExtremeColdLED.start(ekstremalnie zimny)

ColdLED.start(schłodzony)

ExtremeHotLED.start(extremehotled)

HotLED.start(hotled) elif 0 < temp <= 30: extremecoldled = getextremeleftledintensity(temp) - 100 coldled = 100 hotled = 0 extremehotled = 0

print("Ekstremalnie zimny led:" + str(ekstremalnie zimny))

print("Zimna dioda:" + str(zimna)) print("Skrajnie gorąca dioda" + str(ekstremalnie gorąca)) print("Gorąca dioda:" + str(gorąca))

ExtremeColdLED.start(ekstremalnie zimny)

ColdLED.start(schłodzony)

ExtremeHotLED.start(extremehotled)

HotLED.start(hotled) elif 100 > temp >= 70: extremecoldled = 0 coldled = 0 hotled = 100 extremehotled = getextremerightledintensity(temp) - 100

print("Ekstremalnie zimny led:" + str(ekstremalnie zimny))

print("Zimna dioda:" + str(zimna)) print("Skrajnie gorąca dioda" + str(ekstremalnie gorąca)) print("Gorąca dioda:" + str(gorąca))

ExtremeColdLED.start(ekstremalnie zimny)

ColdLED.start(schłodzony)

ExtremeHotLED.start(extremehotled)

HotLED.start(hotled) elif 30 < temp < 50: extremecoldled = 0 coldled = getmiddleleftledintensity(temp) hotled = 100 - coldled extremehotled = 0

print("Ekstremalnie zimny led:" + str(ekstremalnie zimny))

print("Zimna dioda:" + str(zimna)) print("Skrajnie gorąca dioda" + str(ekstremalnie gorąca)) print("Gorąca dioda:" + str(gorąca))

ExtremeColdLED.start(ekstremalnie zimny)

ColdLED.start(schłodzony)

ExtremeHotLED.start(extremehotled)

HotLED.start(hotled) elif 50 < temp < 70: hotled = getmiddlerightledintensity(temp) extremehotled = 0

schłodzony = 100 - rozgrzany

skrajnie schłodzony = 0

print("Ekstremalnie zimny led:" + str(ekstremalnie zimny))

print("Zimna dioda:" + str(zimna)) print("Skrajnie gorąca dioda" + str(ekstremalnie gorąca)) print("Gorąca dioda:" + str(gorąca))

ExtremeColdLED.start(ekstremalnie zimny)

ColdLED.start(schłodzony)

ExtremeHotLED.start(extremehotled)

HotLED.start(hotled) elif temp == 50: extremecoldled = 0 coldled = 50 hotled = 50 extremehotled = 0

print("Ekstremalnie zimny led:" + str(ekstremalnie zimny))

print("Zimna dioda:" + str(zimna)) print("Skrajnie gorąca dioda" + str(ekstremalnie gorąca)) print("Gorąca dioda:" + str(gorąca))

ExtremeColdLED.start(ekstremalnie zimny)

ColdLED.start(schłodzony)

ExtremeHotLED.start(extremehotled)

HotLED.start(podgrzany)

W porządku, ta sekcja kodu jest naprawdę długa. To też dość trudne do wytłumaczenia. Zasadniczo powyższy kod sprawdza temperaturę w stopniach Fahrenheita i określa, czy mieści się ona w zbiorze zakresów. W zależności od zakresów podaje numer dla każdej diody i jej jasność, a następnie ustawia jasność wywołując komendę start(). To szybkie wyjaśnienie. Jeśli to wystarczy, radzę przejść do następnego kroku, ale jeśli chcesz zobaczyć długie i żmudne wyjaśnienie, czytaj dalej.

Kiedy programowaliśmy, zdecydowaliśmy, że najłatwiejszym sposobem uzyskania wartości z temperatury jest postać funkcji matematycznej. Stworzyliśmy więc wykres w GeoGebra, aby przedstawić zależność między naszą temperaturą a jasnością diody LED; powodem, dla którego przekracza 100, jest to, że dodatek przejdzie do drugiej diody led. Natknęliśmy się jednak na problem z uzyskaniem pojedynczej funkcji do mapowania wszystkich tych punktów na jedną funkcję. Pomyśleliśmy, że moglibyśmy użyć paraboli, ale postanowiliśmy po prostu zadowolić się użyciem serii instrukcji if. W istocie cały ten kod jest funkcją odcinkową.

Funkcje na górze to odpowiednie równania linii. Gdy ustalimy, gdzie na wykresie jest temperatura, przepuszczamy ją przez tę funkcję, uzyskujemy jasność i przekazujemy ją na diody LED.

Krok 6: Kodowanie: Ostatnie kroki

Na koniec dodajemy to stwierdzenie na końcu.

próbować:

while(True): GetLEDBrightness(City_TemperatureF) GetRainLED(WeatherID) time.sleep(10) z wyjątkiem KeyboardInterrupt: quit()

Instrukcje try iexcept pozwalają nam wyjść z kodu za pomocą skrótu klawiaturowego; w przeciwnym razie musielibyśmy wyłączyć Raspberry Pi, aby ponownie uruchomić kod. Następnie mamy pętlę while, która działa w nieskończoność. Aktualizujemy diody led, a także aktualizujemy diodę deszczu. Zatrzymujemy się na dziesięć sekund; OpenWeather pozwala tylko na 60 połączeń danych na minutę, a 10 sekund to mnóstwo aktualizacji.

I na tym kończy się nasz kod. Poniżej gotowy kod.

RaspberryPIWeatherStation.py

importżądań

importRPi. GPIOasGPIO

importjson

czas importu

#IdCodes Openweather mniejsze niż 700 to wszystkie opady

defCheckRain(Kod Id):

ifIdCode<700:

returnTrue

w przeciwnym razie:

returnFałsz

defgetmiddleleftledintensity (temperatura w F):

#Równanie lewej: y=-(50/20)x + 175

#Równanie z prawej: y = (50/20)x - 75

powrót-(50/20)*Temperatura w F+175

defgetmiddlerightledintensity (Temperatura w F):

#Równanie lewej: y=-(50/20)x + 175

#Równanie z prawej: y = (50/20)x - 75

powrót (50/20)*Temperatura w F-75

defgetextremeleftledintensity (temperatura w F):

#LeftRównanie: y = -(100/30)x + 200

#RightEquation: y = (100/30)x - (400/3)

powrót-(100/30)*Temperatura w F+200

defgetextremerightledintensity (Temperatura w F):

# LeftEquation: y = -(100/30)x + 200

# RightEquation: y = (100/30)x - (400/3)

powrót (100/30)*Temperatura w F- (400/3)

#Konfiguracja GPIO

GPIO.setmode(GPIO. BCM)

GPIO.setwarnings (Fałsz)

#Szpilki

Extreme_Hot_LED_PIN=26

Hot_LED_PIN=16

Extreme_Cold_LED_PIN=5

Zimny_LED_PIN=6

Deszcz_LED_PIN=23

#Przypinanie konfiguracji

GPIO.setup(Rain_LED_PIN, GPIO. OUT)

GPIO.setup(Extreme_Cold_LED_PIN, GPIO. OUT)

GPIO.setup(Cold_LED_PIN, GPIO. OUT)

GPIO.setup(Hot_LED_PIN, GPIO. OUT)

GPIO.setup (Extreme_Hot_LED_PIN, GPIO. OUT)

ExtremeHotLED=GPIO. PWM(Extreme_Hot_LED_PIN, 100)

HotLED=GPIO. PWM(Hot_LED_PIN, 100)

ExtremeColdLED=GPIO. PWM(Extreme_Cold_LED_PIN, 100)

ColdLED=GPIO. PWM(Cold_LED_PIN, 100)

defGetLEDJasność(temp):

iftemp<=0:

ekstremalnie zimny=100

schłodzony=100

rozgrzany=0

ekstremalnie gorąco=0

print("Ekstremalnie zimno:"+str(ekstremalnie zimny))

print("Zimna dioda:"+str(zimna))

print("Extreme hot led"+str(extremehotled))

print("Gorąca dioda:"+str(podgrzana))

ExtremeColdLED.start(ekstremalnie zimny)

ColdLED.start(schłodzony)

ExtremeHotLED.start(extremehotled)

HotLED.start(podgrzany)

temp.wyj>=100:

ekstremalnie zimny=0

schłodzony=0

rozgrzany=100

ekstremalnie gorąco=100

print("Ekstremalnie zimno:"+str(ekstremalnie zimny))

print("Zimna dioda:"+str(zimna))

print("Extreme hot led"+str(extremehotled))

print("Gorąca dioda:"+str(podgrzana))

ExtremeColdLED.start(ekstremalnie zimny)

ColdLED.start(schłodzony)

ExtremeHotLED.start(extremehotled)

HotLED.start(podgrzany)

elif0<temp<=30:

extremecoldled=getextremeleftledintensity(temp) -100

schłodzony=100

rozgrzany=0

ekstremalnie gorąco=0

print("Ekstremalnie zimno:"+str(ekstremalnie zimny))

print("Zimna dioda:"+str(zimna))

print("Extreme hot led"+str(extremehotled))

print("Gorąca dioda:"+str(podgrzana))

ExtremeColdLED.start(ekstremalnie zimny)

ColdLED.start(schłodzony)

ExtremeHotLED.start(extremehotled)

HotLED.start(podgrzany)

elif100>temp>=70:

ekstremalnie zimny=0

schłodzony=0

rozgrzany=100

extremehotled=getextremerightledintensity(temp) -100

print("Ekstremalnie zimno:"+str(ekstremalnie zimny))

print("Zimna dioda:"+str(zimna))

print("Extreme hot led"+str(extremehotled))

print("Gorąca dioda:"+str(podgrzana))

ExtremeColdLED.start(ekstremalnie zimny)

ColdLED.start(schłodzony)

ExtremeHotLED.start(extremehotled)

HotLED.start(podgrzany)

elif30<temp<50:

ekstremalnie zimny=0

coldled=getmiddleleftledintensity(temp)

gorący = 100-schłodzony

ekstremalnie gorąco=0

print("Ekstremalnie zimno:"+str(ekstremalnie zimny))

print("Zimna dioda:"+str(zimna))

print("Extreme hot led"+str(extremehotled))

print("Gorąca dioda:"+str(podgrzana))

ExtremeColdLED.start(ekstremalnie zimny)

ColdLED.start(schłodzony)

ExtremeHotLED.start(extremehotled)

HotLED.start(podgrzany)

elif50<temp<70:

hotled=getmiddlerightledintensity(temp)

ekstremalnie gorąco=0

coldled = 100-hotled

ekstremalnie zimny=0

print("Ekstremalnie zimny:"+str(ekstremalnie zimny))

print("Zimna dioda:"+str(zimna))

print("Extreme hot led"+str(extremehotled))

print("Gorąca dioda:"+str(podgrzana))

ExtremeColdLED.start(ekstremalnie zimny)

ColdLED.start(schłodzony)

ExtremeHotLED.start(extremehotled)

HotLED.start(podgrzany)

elifttemp==50:

ekstremalnie zimny=0

schłodzony=50

rozgrzany=50

ekstremalnie gorąco=0

print("Ekstremalnie zimno:"+str(ekstremalnie zimny))

print("Zimna dioda:"+str(zimna))

print("Extreme hot led"+str(extremehotled))

print("Gorąca dioda:"+str(podgrzana))

ExtremeColdLED.start(ekstremalnie zimny)

ColdLED.start(schłodzony)

ExtremeHotLED.start(extremehotled)

HotLED.start(podgrzany)

defGetRainLED(idCode):

ifCheckRain(idCode):

GPIO.wyjście (deszcz_LED_PIN, GPIO. HIGH)

w przeciwnym razie:

GPIO.output(Rain_LED_PIN, GPIO. LOW)

#Informacje API: zamień klucz API na klucz api oepnweather

openweather_api_key="460a23f27ff324ef9ae743c7e9c32d7e"

base_call="https://api.openweathermap.org/data/2.5/weather?q="

print("Wpisz miasto!")

nazwa_miasta=wejście()

full_call=base_call+nazwa_miasta+"&appid="+openweather_api_key

#Uzyskiwanie danych o pogodzie

Odpowiedź=requests.get(full_call)

WeatherData=Odpowiedź.json()

WeatherID=Dane Pogody["pogoda"][0]["id"]

City_TemperatureK=Dane pogody["główna"]["temp"]

Miasto_TemperaturaF= (Miasto_TemperaturaK-273)*1,8+32#Konwertuj na stopnie Fahrenheita

#LED/GPIO Rzeczy

print("K:"+str(Miasto_TemperaturaK))

print("F:"+str(Miasto_TemperaturaF))

drukuj (ID pogody)

próbować:

podczas (prawda):

GetLEDBrightness(City_TemperatureF)

GetRainLED(Identyfikator Pogody)

czas.sen(10)

z wyjątkiem przerwania klawiatury:

zrezygnować()

zobacz rawRaspberryPIWeatherStation.py hostowane z ❤ przez GitHub

Krok 7: Budowa i okablowanie

Uff! Po całym tym kodowaniu docieramy do budynku, co jest znacznie łatwiejsze. Ze względu na koronowe zamówienia na pobyt w domu, nie mogliśmy dostać się do wielu narzędzi, które oczekiwaliśmy w szkole. Tak więc ta część jest nieco prostsza niż zamierzaliśmy. Same specyfiki również są elastyczne. Najpierw na drewnianej desce narysowaliśmy prostokąt. Konkretny rozmiar nie ma większego znaczenia, ponieważ służy po prostu jako platforma do zakładania diod i elektroniki.

Następnie wywierciliśmy pięć otworów o rozmiarze 1/8 w naszym kawałku drewna.

Następnie wycinamy prostokąt z deski, aby wykorzystać ją jako platformę dla naszej elektroniki.

(Właśnie wtedy zaczęliśmy; znaleźliśmy większą piłę!)

Następnie wciskamy kołki anody i katody diody led do otworów; diody led powinny leżeć na wierzchu, z żarówkami wystającymi; śledź, która noga jest dłuższa i krótsza. Następnie przystąpiliśmy do lutowania przewodów. Najpierw lutujemy rezystory do nogi anodowej diody LED (noga dłuższa).

Następnie przylutowujemy nogi katod diod LED do pojedynczego drutu miedzianego, którego użyjemy jako uziemienia. To powinno wyglądać tak.

Po wykonaniu tej czynności lutujemy męskie końcówki żeńsko-męskich kabli połączeniowych do końcówek każdego rezystora i miedzianego przewodu uziemiającego. Gdy już to zrobimy, możemy zacząć wpinać przewody do pinów GPIO Raspberry PI. Oto schemat! Należy jednak pamiętać, że piny są tymi w kodzie, o którym wcześniej wspomniano.

Kiedy już to wszystko masz podłączone, teraz wszystko, co musisz zrobić, to pobrać plik Pythona na Raspberry Pi i otworzyć terminal. uruchom "python3 RaspberryPIWeatherStation.py", a następnie zrób to, co pokazuje.

Krok 8: Demonstracja i wnioski

Dzięki za przeczytanie całego tekstu! Poniżej dołączę skrypt Pythona! Gdyby były rzeczy, które moglibyśmy dodać, prawdopodobnie byłoby to…

1. Obsługa różnych typów danych wejściowych (miasta, punkty geograficzne itp.)

2. Wsparcie dla większej ilości informacji o pogodzie

3. Dodaj mały ekran, aby wyświetlić informacje

Podziel się z nami swoimi przemyśleniami! To był fajny projekt do zbudowania. Dużo dowiedzieliśmy się o żądaniach i uzyskiwaniu dokumentów internetowych za pomocą Pythona, a także o lutowaniu.