Raspberry PI LED-Wetterstation - Gunook

2024 Autor: John Day | [email protected]. Zuletzt bearbeitet: 2024-01-30 07:16

Wir haben eine Raspberry PI Wetter-LED-Station erstellt. Es zeigt dem Benutzer an, wie heiß und kalt eine Stadt ist, indem es LEDs aufleuchtet und dimmt. Es hat auch eine LED, die ihnen sagt, ob es in der Stadt, die sie eingegeben haben, regnet oder nicht.

Erstellt von Michael Andrews und Tio Marello.

Lieferungen

Werkzeuge

1. Lötkolben
2. Dremel
3. Sah

Materialien

1. Raspberry Pi 3 B+ ~40 Dollar ~ 30 Dollar
2. Buchse zu Stecker Überbrückungsdrähte ~7 Dollar
3. 3 blaue und 2 rote LED-Dioden ~ 11 Dollar
4. 100 Ohm Widerstände ~ 13 Dollar
5. 4 x 4 x 1/4 Holzbrett ~ 5 Dollar
6. Löten ~ 10 Dollar
7. Kupferdraht ~ 5 Dollar

Schritt 1: Codierung als Problemlösung

Codieren ist Problemlösen

Was ist also unser Problem in unserem Projekt? Unser Problem besteht darin, Wetterdaten zu erhalten und diese Daten dann zu verwenden, um unseren LEDs mitzuteilen, ob sie aus oder an sind. Das teilt unser Problem also in drei Bereiche auf.

1. Wetterdaten abrufen

2. Verwendung dieser Daten

3. Verwendung von LEDs

Die Sprache, die wir für dieses Projekt verwendet haben, Python, und die Hardware, auf der es läuft, Python, bieten uns jedoch eine einfache Möglichkeit, diese Ziele zu erreichen.

Beginnen wir also mit dem ersten Problem, dem Abrufen von Wetterdaten.

Schritt 2: Codierung: Wetterdaten abrufen

Python allein kann keine Wetterdaten abrufen. Wir müssen zwei Tools sowie einen externen Dienst importieren, um Wetterdaten zu erhalten. Dazu verwenden wir drei Tools.

1. Requests, ein Python-Modul, das Webscraping ermöglicht

2. Json, ein Python-Modul, mit dem wir das JSON-Dateiformat verwenden können

3. OpenWeather, eine Website, die uns Wetterdaten liefern kann

Also bringen wir die beiden Module mit, indem wir diesen Code oben in unser Python-Skript schreiben.

Importanfragen

json importieren

Bevor wir diese Tools verwenden, müssen wir jedoch Openweather verwenden. Dafür müssen wir ein Konto auf ihrer Website erstellen und einen API-Schlüssel erhalten. Folgen Sie den Anweisungen auf ihrer Website und Sie erhalten eine Reihe von Buchstaben und Zahlen, mit denen wir ihren Service nutzen können. Wie?

openweather_api_key = "260a23f27f5324ef2ae763c779c32d7e" #Unser API-Schlüssel (nicht echt)

base_call = "https://api.openweathermap.org/data/2.5/weather?q=" #OpenWeather Call #Hier erhalten wir die Stadt des Benutzers in Form von Text print("Geben Sie eine Stadt ein!") city_name = input () #Hier haben wir die Adresse zusammengestellt, die wir in request.get stecken, um Wetterdaten zu erhalten full_call = base_call+city_name+"&appid="+openweather_api_key #Schließlich rufen wir request.get mit unserer Adresse auf und konvertieren sie in eine Json-Datei Response = request.get(full_call) WeatherData = Response.json() #JSON-Dateien enthalten verschiedene Variablen, auf die wir mit dieser Syntax zugreifen können #Hier erhalten wir die Wetter-ID und die Temperatur in Kelvin der Stadt, die der Benutzer in WeatherID = WeatherData eingegeben hat ["weather"][0]["id"] City_TemperatureK = WeatherData["main"]["temp"]

Hier haben wir den Code, der uns unsere Wetterdaten liefert. Requests in Form von request.get nimmt eine Website-Adresse auf und gibt uns eine Datei von dieser Website zurück. OpenWeather gibt uns eine Adresse, die wir anrufen können, um uns Wetterdaten in Form eines Jsons zu geben. Wir stellen eine Adresse zusammen, die wir in Anfragen einfügen und erhalten eine Json-Datei zurück. Dann erstellen wir zwei Variablen und weisen sie der Temperatur und dem Wetter der Stadt des Benutzers zu.

Mit diesem Code haben wir jetzt zwei Variablen. Wir haben eine Wetter-ID und eine Temperatur in Kelvin

Schritt 3: Codierung: Verwenden dieser Daten

Da wir nun diese beiden Variablen haben, müssen wir sie für die Verwendung für unsere LEDs vorbereiten. Für diesen Aspekt müssen wir dafür keine Module importieren.

Zuerst wandeln wir Kelvin in Fahrenheit um.

Wir tun dies, indem wir eine Variable mit dieser Syntax erstellen

City_TemperatureF = (City_TemperatureK - 273)*1.8 + 32

die von Kelvin in Fahrenheit konvertiert (was wirklich von K -> C -> F konvertiert)

Als nächstes kommt unsere Wetter-ID. Die WeatherID ist eine von Openweather bereitgestellte ID, die uns über die Wetterbedingungen einer Stadt informiert.

openweathermap.org/weather-conditions Hier ist eine Liste von ihnen.

Wir haben festgestellt, dass alles unter 700 eine Art Niederschlag war, also haben wir nur überprüft, ob der Code unter 700 liegt, um zu sehen, ob es regnet.

def CheckRain(IdCode): wenn IdCode < 700: True zurückgeben sonst: False zurückgeben

Damit haben wir unsere beiden Variablen für die Verwendung mit unseren Raspberry PI-Pins und LED-Dioden vorbereitet.

Schritt 4: Codierung: Mit RPi. GPIO und LED-Dioden

Der RaspberryPi wird mit einem Satz männlicher Pins geliefert, mit denen wir mit einer Vielzahl elektrischer Komponenten kommunizieren können, in diesem Fall LED-Dioden. es ist mit Arduino und seinem System verwandt. Der Raspberry PI ist jedoch ein Allzweckcomputer, im Gegensatz zu einem Mikrocontroller wie dem Arduino. Wir müssen also ein bisschen mehr Arbeit leisten, um sie zu verwenden. Dies besteht darin, die Pins auf dem Raspberry Pi einzurichten. Wir tun dies, indem wir diesen Code verwenden.

RPi. GPIO als GPIO importieren #Wir importieren das Modul, damit wir es verwenden können

#Einrichten der PinsGPIO.setmode(GPIO. BCM) GPIO.setwarnings(False)

#Die Pins, in die die LEDs eingesteckt sind. Diese können unterschiedlich sein, wenn Sie es erstellen, also vergleichen und ändern Sie es bei Bedarf

Extreme_Hot_LED_PIN = 26 Hot_LED_PIN = 16

Extreme_Cold_LED_PIN = 5

Kalt_LED_PIN = 6

Regen_LED_PIN = 23

#Wir gehen jeden Pin durch, verwenden den Befehl.setup, geben seine Nummer ein und setzen ihn als Ausgangspin

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.

Mit diesem Code können wir jedoch nur zwei Zustände mit der LED verwenden, dh ein und aus. Wir brauchen es jedoch, um das Licht dimmen zu können. Dazu verwenden wir Pulsweitenmodulation.

Verwenden der Pulsweitenmodulation

Mit Pulsweitenmodulation können wir ein analoges Signal über einen digitalen Pin ausgeben. Im Wesentlichen schaltet es die Signalquelle mit einer hohen Rate ein und aus, die auf eine bestimmte Spannung gemittelt wird. Das RPi. GPIO ermöglicht es uns, dies zu verwenden, wenn auch mit etwas zusätzlichem Code.

#Wir erstellen vier Pin-Objekte mit dem Befehl GPIO. PWM, der eine Kanalnummer aufnimmt

#Die zweite Zahl ist die Anzahl der Aktualisierungen pro Sekunde

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)

Für den nächsten Schritt müssen Sie wissen, wie wir diese Pins aktualisieren.

Wir aktualisieren die Pins mit dem Befehl

ExtremColdLED.start(x)ColdLED.start(x)

ExtremeHotLED.start(x)

HotLED.start(x)

x wäre in diesem Fall das Tastverhältnis, das bestimmt, wie stark es pulsiert. Er reicht von 0-100, also müssen wir unseren nächsten Code auf dieser Tatsache aufbauen.

Schritt 5: Codierung: LED-Helligkeit erhalten

Da wir vier verschiedene LEDs haben, wollen wir sie je nach Art zum Leuchten bringen. kalt oder heiß ist es in der Stadt des Benutzers. Wir haben uns für vier Stufen für die LED entschieden.

#Funktionen

def getmiddleleftledintensity(TemperatureinF): #Linke Gleichung: y=-(50/20)x + 175 #Rechte Gleichung: y = (50/20)x - 75 return -(50/20)*TemperatureinF + 175

def getmiddlerightledintensity(TemperatureinF):

#Linke Gleichung: y=-(50/20)x + 175 #Rechte Gleichung: y = (50/20)x - 75 zurück (50/20)*TemperatureinF - 75

def getextremeleftledintensity(TemperatureinF):

#LinksGleichung: y = -(100/30)x + 200 #RechtsGleichung: y = (100/30)x - (400/3)

Rücklauf -(100/30)*TemperatureinF + 200

def getextremerightledintensity(TemperatureinF):

# Linksgleichung: y = -(100/30)x + 200 # Rechtsgleichung: y = (100/30)x - (400/3)

Rücklauf (100/30)*TemperatureinF - (400/3)

#Einstellung der LED-Beleuchtung

def GetLEDHelligkeit(temp):

wenn temp <= 0: extrem kalt = 100 kalt = 100 warm = 0 extrem warm = 0

print("Extreme Cold LED:" + str(extremecolled))

print("Cold led:" + str(coldled)) print("Extreme hot led" + str(extremehotled)) print("Heiß led:" + str(hotled))

ExtremeColdLED.start(extremegekühlt)

ColdLED.start (kalt)

ExtremeHotLED.start(extremehotled)

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

print("Extreme Cold LED:" + str(extremecolled))

print("Cold led:" + str(coldled)) print("Extreme hot led" + str(extremehotled)) print("Heiß led:" + str(hotled))

ExtremeColdLED.start(extremegekühlt)

ColdLED.start (kalt)

ExtremeHotLED.start(extremehotled)

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

print("Extreme Cold LED:" + str(extremecolled))

print("Cold led:" + str(coldled)) print("Extreme hot led" + str(extremehotled)) print("Heiß led:" + str(hotled))

ExtremeColdLED.start(extremegekühlt)

ColdLED.start (kalt)

ExtremeHotLED.start(extremehotled)

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

print("Extreme Cold LED:" + str(extremecolled))

print("Cold led:" + str(coldled)) print("Extreme hot led" + str(extremehotled)) print("Heiß led:" + str(hotled))

ExtremeColdLED.start(extremegekühlt)

ColdLED.start (kalt)

ExtremeHotLED.start(extremehotled)

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

print("Extreme Cold LED:" + str(extremecolled))

print("Cold led:" + str(coldled)) print("Extreme hot led" + str(extremehotled)) print("Heiß led:" + str(hotled))

ExtremeColdLED.start(extremegekühlt)

ColdLED.start (kalt)

ExtremeHotLED.start(extremehotled)

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

kalt = 100 - heiß

extrem kalt = 0

print("Extreme Cold LED:" + str(extremecolled))

print("Cold led:" + str(coldled)) print("Extreme hot led" + str(extremehotled)) print("Heiß led:" + str(hotled))

ExtremeColdLED.start(extremegekühlt)

ColdLED.start (kalt)

ExtremeHotLED.start(extremehotled)

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

print("Extreme Cold LED:" + str(extremecolled))

print("Cold led:" + str(coldled)) print("Extreme hot led" + str(extremehotled)) print("Heiß led:" + str(hotled))

ExtremeColdLED.start(extremegekühlt)

ColdLED.start (kalt)

ExtremeHotLED.start(extremehotled)

HotLED.start (hotled)

Okay, dieser Codeabschnitt ist wirklich lang. Es ist auch ziemlich schwer zu erklären. Im Wesentlichen betrachtet der obige Code die Temperatur in Fahrenheit und bestimmt, ob sie in einer Reihe von Bereichen liegt. Abhängig von den Bereichen gibt es eine Nummer für jede LED und ihre Helligkeit und stellt dann die Helligkeit durch Aufrufen des Befehls start() ein. Das ist die schnelle Erklärung. Wenn es ausreicht, empfehle ich Ihnen, mit dem nächsten Schritt fortzufahren, aber wenn Sie die lange und mühsame Erklärung sehen möchten, lesen Sie weiter.

Beim Programmieren haben wir entschieden, dass der einfachste Weg, einen Wert aus einer Temperatur zu erhalten, die Form einer mathematischen Funktion ist. Also haben wir in GeoGebra ein Diagramm erstellt, um die Beziehung zwischen unserer Temperatur und unserer LED-Helligkeit darzustellen. Der Grund, warum es über 100 geht, ist, dass das Extra in die zweite LED gehen würde. Wir sind jedoch auf das Problem gestoßen, eine einzelne Funktion zu erhalten, um all diese Punkte einer einzelnen Funktion zuzuordnen. Wir dachten, wir könnten eine Parabel verwenden, haben uns aber entschieden, uns einfach mit einer Reihe von if-Anweisungen zufriedenzugeben. Im Wesentlichen ist dieser gesamte Code eine stückweise Funktion.

Die Funktionen ganz oben sind die jeweiligen Geradengleichungen. Sobald wir festgestellt haben, wo sich die Temperatur in der Grafik befindet, führen wir sie durch diese Funktion, ermitteln die Helligkeit und geben sie an die LEDs weiter.

Schritt 6: Codierung: Letzte Schritte

Schließlich fügen wir diese Aussage am Ende hinzu.

Versuchen:

while(True): GetLEDBrightness(City_TemperatureF) GetRainLED(WeatherID) time.sleep(10) außer KeyboardInterrupt: quit()

Die try- und Exception-Anweisungen ermöglichen es uns, Code mithilfe einer Tastenkombination zu beenden; In beiden Fällen müssten wir den Raspberry Pi herunterfahren, um den Code neu zu starten. Dann haben wir eine while-Schleife, die ewig läuft. Wir aktualisieren die LEDs sowie die Regen-LED. Wir halten zehn Sekunden inne; OpenWeather erlaubt nur 60 Datenaufrufe pro Minute und 10 Sekunden reichen für Updates.

Und damit ist unser Code fertig. Unten ist der fertige Code.

RaspberryPIWeatherStation.py

Importanfragen

importRPi. GPIOasGPIO

importjson

Importzeit

#Openweather idCodes unter 700 sind alle Niederschläge

defCheckRain(IdCode):

ifIdCode<700:

returnTrue

anders:

falsch zurückgeben

defgetmiddleleftledintensity(TemperatureinF):

#Linke Gleichung: y=-(50/20)x + 175

#Rechte Gleichung: y = (50/20)x - 75

Rücklauf-(50/20)*TemperatureinF+175

defgetmiddlerightledintensity(TemperatureinF):

#Linke Gleichung: y=-(50/20)x + 175

#Rechte Gleichung: y = (50/20)x - 75

Rücklauf (50/20)*TemperatureinF-75

defgextremeleftledintensity(TemperatureinF):

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

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

Rücklauf-(100/30)*TemperatureinF+200

defgetextremerightledintensity(TemperatureinF):

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

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

Rücklauf (100/30)*TemperatureinF- (400/3)

#GPIO-Setup

GPIO.setmode(GPIO. BCM)

GPIO.setwarnings(Falsch)

#Pins

Extreme_Hot_LED_PIN=26

Hot_LED_PIN=16

Extreme_Cold_LED_PIN=5

Cold_LED_PIN=6

Regen_LED_PIN=23

#Pin-Setup

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)

defGetLEDHelligkeit(temp):

iftemp<=0:

extrem kalt=100

kalt = 100

hotled=0

extremhotled=0

print("Extreme kalte LED:"+str(extremecolled))

print("Kalt geführt:"+str(kalt))

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

print("Hot led:"+str(hotled))

ExtremeColdLED.start(extremegekühlt)

ColdLED.start (kalt)

ExtremeHotLED.start(extremehotled)

HotLED.start (hotled)

Höhentemp>=100:

extrem kalt=0

kalt=0

hotled=100

extremhotled=100

print("Extreme kalte LED:"+str(extremecolled))

print("Kalt geführt:"+str(kalt))

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

print("Hot led:"+str(hotled))

ExtremeColdLED.start(extremegekühlt)

ColdLED.start (kalt)

ExtremeHotLED.start(extremehotled)

HotLED.start (hotled)

elif0<temp<=30:

extremecoldled=getextremeleftledintensity(temp) -100

kalt = 100

hotled=0

extremhotled=0

print("Extreme kalte LED:"+str(extremecolled))

print("Kalt geführt:"+str(kalt))

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

print("Hot led:"+str(hotled))

ExtremeColdLED.start(extremegekühlt)

ColdLED.start (kalt)

ExtremeHotLED.start(extremehotled)

HotLED.start (hotled)

elif100>temp>=70:

extrem kalt=0

kalt=0

hotled=100

extremehotled=getextremerightledintensity(temp) -100

print("Extreme kalte LED:"+str(extremecolled))

print("Kalt geführt:"+str(kalt))

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

print("Hot led:"+str(hotled))

ExtremeColdLED.start(extremegekühlt)

ColdLED.start (kalt)

ExtremeHotLED.start(extremehotled)

HotLED.start (hotled)

elif30<temp<50:

extrem kalt=0

coldled=getmiddleleftledintensity(temp)

heiß=100-kalt

extremhotled=0

print("Extreme kalte LED:"+str(extremecolled))

print("Kalt geführt:"+str(kalt))

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

print("Hot led:"+str(hotled))

ExtremeColdLED.start(extremegekühlt)

ColdLED.start (kalt)

ExtremeHotLED.start(extremehotled)

HotLED.start (hotled)

elif50<temp<70:

hotled=getmiddlerightledintensity(temp)

extremhotled=0

kalt=100-gewärmt

extrem kalt=0

print("Extreme kalte LED:"+str(extremecolled))

print("Kalt geführt:"+str(kalt))

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

print("Hot led:"+str(hotled))

ExtremeColdLED.start(extremegekühlt)

ColdLED.start (kalt)

ExtremeHotLED.start(extremehotled)

HotLED.start (hotled)

Höhentemp==50:

extrem kalt=0

kalt=50

hotled=50

extremhotled=0

print("Extreme kalte LED:"+str(extremecolled))

print("Kalt geführt:"+str(kalt))

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

print("Hot led:"+str(hotled))

ExtremeColdLED.start(extremegekühlt)

ColdLED.start (kalt)

ExtremeHotLED.start(extremehotled)

HotLED.start (hotled)

defGetRainLED(idCode):

ifCheckRain(idCode):

GPIO.output(Rain_LED_PIN, GPIO. HIGH)

anders:

GPIO.output(Rain_LED_PIN, GPIO. LOW)

#Api-Informationen: Ersetzen Sie den API-Schlüssel durch Ihren oepnweather-API-Schlüssel

openweather_api_key="460a23f27ff324ef9ae743c7e9c32d7e"

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

print("Geben Sie eine Stadt ein!")

stadtname=eingabe()

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

#Wetterdaten abrufen

Antwort=requests.get(full_call)

WeatherData=Response.json()

WeatherID=WeatherData["weather"][0]["id"]

City_TemperatureK=WeatherData["main"]["temp"]

City_TemperatureF= (City_TemperatureK-273)*1.8+32#In Fahrenheit umwandeln

#LED/GPIO-Zeug

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

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

drucken (WetterID)

Versuchen:

während(wahr):

GetLEDHelligkeit(City_TemperatureF)

GetRainLED(WetterID)

Zeit. Schlaf(10)

außerKeyboardInterrupt:

Verlassen()

rawRaspberryPIWeatherStation.py anzeigen, gehostet mit ❤ von GitHub

Schritt 7: Aufbau und Verkabelung

Wütend! Nach all der Codierung kommen wir zum Gebäude, was wesentlich einfacher ist. Aufgrund der Corona-Aufträge zu Hause bleiben konnten wir viele der Utensilien, die wir in der Schule erwartet hatten, nicht erreichen. Dieser Teil ist also etwas einfacher als von uns beabsichtigt. Auch die Besonderheiten selbst sind flexibel. Zuerst haben wir ein Rechteck auf ein Holzbrett gezeichnet. Die spezifische Größe spielt keine große Rolle, da sie lediglich als Plattform zum Anbringen von LEDs und Elektronik dient.

Dann bohrten wir fünf 1/8 Löcher in unser Stück Holz.

Wir schneiden dann das Rechteck aus der Planke aus, um es als Plattform für unsere Elektronik zu verwenden.

(Damit haben wir angefangen; wir haben eine größere Säge gefunden!)

Dann schieben wir die Anoden- und Kathodenstifte der LED in die Löcher; die LEDs sollten oben liegen, ihre Glühbirnen ragen heraus; Behalten Sie im Auge, welches Bein länger und kürzer ist. Dann machten wir uns daran, Drähte zusammenzulöten. Zuerst löten wir die Widerstände an das Anodenbein der LED (das längere Bein).

Dann löten wir die Kathodenbeine der LEDs an einen einzelnen Kupferdraht, den wir als Masse verwenden. Es sollte so aussehen.

Danach löten wir die männlichen Enden der weiblich-männlichen Überbrückungskabel an die Enden jedes Widerstands und des Kupfererdungsdrahts. Sobald wir das getan haben, können wir mit dem Einstecken der Drähte in die Himbeer-PI-GPIO-Pins beginnen. Hier ist ein Diagramm! Beachten Sie jedoch, dass die Pins die im zuvor angesprochenen Code sind.

Sobald Sie das alles verkabelt haben, müssen Sie nur noch die Python-Datei auf den Raspberry Pi laden und das Terminal öffnen. Führen Sie "python3 RaspberryPIWeatherStation.py" aus und tun Sie dann, wie es angezeigt wird.

Schritt 8: Demonstration und Schlussfolgerung

Danke fürs Durchlesen! Ich werde das Python-Skript unten anhängen! Wenn wir noch etwas hinzufügen könnten, wäre es wahrscheinlich…

1. Unterstützung für verschiedene Eingabetypen (Städte, geografische Punkte usw.)

2. Unterstützung für weitere Wetterinformationen

3. Fügen Sie einen kleinen Bildschirm hinzu, um Informationen anzuzeigen

Teilen Sie uns Ihre Gedanken mit! Dies war ein lustiges Projekt zu bauen. Wir haben viel über Anfragen und das Abrufen von Internetdokumenten mit Python gelernt, und wir haben auch viel über Löten gelernt.