Raspberry PI LED-weerstation - Ajarnpa

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

We hebben een Raspberry PI Weather LED Station gemaakt. Het vertelt de gebruiker hoe warm en koud een stad is door leds op te lichten en te dimmen. Het heeft ook een aanwijzing om hen te vertellen of het regent in de stad die ze hebben ingetypt.

Gemaakt door Michael Andrews en Tio Marello.

Benodigdheden

Gereedschap

1. Soldeerbout
2. Dremel
3. Zaag

Materialen

1. Raspberry Pi 3 B+ ~ 40 dollar ~ 30 dollar
2. Vrouwelijke naar mannelijke jumperdraden ~ 7 dollar
3. 3 blauwe en 2 rode LED-diodes ~ 11 dollar
4. 100 Ohm Weerstanden ~ 13 Dollar
5. 4 x 4 x 1/4 houten plank ~ 5 dollar
6. Soldeer ~ 10 dollar
7. Koperdraad ~ 5 dollar

Stap 1: Coderen als probleemoplossing

Coderen is het oplossen van problemen

Dus, in ons project, wat is ons probleem? Ons probleem is om weergegevens te krijgen en die gegevens vervolgens te gebruiken om onze LEDS te vertellen of ze uit of aan zijn. Dit verdeelt ons probleem dus in drie gebieden.

1. Weergegevens ophalen

2. Die gegevens gebruiken

3. LEDS gebruiken

De taal die we voor dit project gebruikten, Python, en de hardware waarop het draait, Python, bieden ons echter een gemakkelijke manier om deze doelen te bereiken.

Dus laten we beginnen met het eerste probleem, het verkrijgen van weergegevens.

Stap 2: Coderen: weergegevens verkrijgen

Python kan op zichzelf geen weergegevens krijgen. We moeten twee tools importeren, evenals een externe service, om weergegevens te krijgen. Hiervoor gebruiken we drie tools.

1. Requests, een python-module die webscraping mogelijk maakt

2. Json, een python-module waarmee we het JSON-bestandsformaat kunnen gebruiken

3. OpenWeather, een website die ons weergegevens kan geven

Dus we brengen de twee modules door deze code bovenaan ons python-script te schrijven.

importverzoeken

import json

Voordat we deze tools gebruiken, moeten we echter Openweather gebruiken. Daarvoor moeten we een account op hun site maken en een API-sleutel krijgen. Volg de instructies op hun website en je krijgt een reeks letters en cijfers waarmee we hun service kunnen gebruiken. Hoe?

openweather_api_key = "260a23f27f5324ef2ae763c779c32d7e" #Onze API-sleutel (niet echt)

base_call = "https://api.openweathermap.org/data/2.5/weather?q=" #OpenWeather Call #Hier krijgen we de stad van de gebruiker in de vorm van tekst print("Typ een stad in!") city_name = input () #Hier hebben we het adres verzameld dat we in requests zullen pluggen. Get om weergegevens te ontvangen full_call = base_call+city_name+"&appid="+openweather_api_key #Eindelijk bellen we requests.get met ons adres, dan zetten we het om in een json-bestand Response = requests.get(full_call) WeatherData = Response.json() #JSON-bestanden bevatten verschillende variabelen waartoe we toegang hebben met deze syntaxis #Hier krijgen we de weer-ID en de temperatuur in Kelvin van de stad die de gebruiker heeft getypt WeatherID = WeatherData ["weather"][0]["id"] City_TemperatureK = WeatherData["main"]["temp"]

Hier hebben we de code die ons onze weergegevens geeft. Requests, in de vorm van requests.get, neemt een websiteadres op en geeft ons een bestand van die website terug. OpenWeather geeft ons een adres om te bellen om ons weergegevens te geven in de vorm van een json. We stellen een adres samen dat we in verzoeken pluggen en krijgen een json-bestand terug. Vervolgens maken we twee variabelen en wijzen deze toe aan de temperatuur en het weer van de stad van de gebruiker.

Dus nu, met deze code, hebben we twee variabelen. We hebben een WeatherID en een temperatuur in Kelvin

Stap 3: Coderen: die gegevens gebruiken

Nu we deze twee variabelen hebben, moeten we ze voorbereiden voor gebruik voor onze LEDS. Voor dit aspect hoeven we hiervoor geen modules te importeren.

Eerst converteren we de kelvin naar Fahrenheit.

We doen dit door een variabele te maken met deze syntaxis

Stad_TemperatuurF = (Stad_TemperatuurK - 273)*1.8 + 32

die converteert van Kelvin naar Fahrenheit (wat echt converteert van K -> C -> F)

Het volgende is onze weatherID. De weatherID is een ID die Openweather verstrekt die ons vertelt over de weersomstandigheden van een stad.

openweathermap.org/weather-conditions Hier is een lijst van.

We merkten dat alles onder het 700-nummer een soort neerslag was, dus we hebben net gecontroleerd of de code lager was dan 700 om te zien of het regende.

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

Daarmee hebben we onze twee variabelen voorbereid voor gebruik met onze Raspberry PI-pinnen en LED-diodes.

Stap 4: Coderen: RPi. GPIO en LED-diodes gebruiken

De RaspberryPi wordt geleverd met een set mannelijke pinnen die we kunnen gebruiken om te communiceren met een groot aantal elektrische componenten, in dit geval LED-diodes; het is verwant aan Arduino en zijn systeem. De Raspberry PI is echter een computer voor algemene doeleinden, in tegenstelling tot een microcontroller zoals de Arduino. We moeten dus wat meer werk doen om ze te gebruiken. Dit bestaat uit het opzetten van de pinnen op de Raspberry Pi. Dit doen we door middel van deze code.

importeer RPi. GPIO als GPIO #We importeren de module zodat we deze kunnen gebruiken

#Stel de pinsGPIO.setmode(GPIO. BCM) GPIO.setwarnings(False) in

#De pinnen waarop de LED's zijn aangesloten. Deze kunnen anders zijn als je het bouwt, dus zorg ervoor dat je vergelijkt en wijzig indien nodig

Extreme_Hot_LED_PIN = 26 Hot_LED_PIN = 16

Extreme_Cold_LED_PIN = 5

Koud_LED_PIN = 6

Rain_LED_PIN = 23

#We doorlopen elke pin, gebruiken het.setup-commando, voeren het nummer in en stellen het in als een output-pin

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_IN,Hot_LED_P)

Met deze code zouden we echter slechts twee toestanden met de led kunnen gebruiken, dat wil zeggen aan en uit. We hebben het echter nodig om de lichten te kunnen dimmen. Hiervoor gebruiken we Pulse Width Modulation.

Pulsbreedtemodulatie gebruiken

Met pulsbreedtemodulatie kunnen we een analoog signaal uitvoeren met behulp van een digitale pin. In wezen schakelt het de signaalbron met een hoge snelheid in en uit, wat uitloopt op een bepaald voltage. De RPi. GPIO stelt ons in staat om dit te gebruiken, zij het met wat extra code.

#We maken objecten met vier pinnen met behulp van de opdracht GPIO. PWM, die een kanaalnummer inneemt

#Het tweede getal is het aantal keren dat het per seconde wordt bijgewerkt

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)

Voor de volgende stap moet je weten hoe we deze pinnen bijwerken.

We werken de pinnen bij met het commando

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

ExtremeHotLED.start(x)

HotLED.start(x)

x zou in dit geval de duty cycle zijn, die bepaalt hoeveel het pulseert. Het varieert van 0-100, dus we moeten onze volgende code op dat feit baseren.

Stap 5: Coderen: LED-helderheid verkrijgen

Omdat we vier verschillende leds hebben, willen we ze afhankelijk van hoe ze oplichten. koud of warm is het in de stad van de gebruiker. We besloten om vier fasen voor de led te hebben.

#Functies

def getmiddleleftledintensity(TemperatureinF): #Linker Vergelijking: y=-(50/20)x + 175 #Right Vergelijking: y = (50/20)x - 75 return -(50/20)*TemperatuurinF + 175

def getmiddlerightledintensity(TemperatuurinF):

#Linkervergelijking: y=-(50/20)x + 175 #Rechtse vergelijking: y = (50/20)x - 75 retour (50/20)*TemperatuurinF - 75

def gettextremeleftledintensity(TemperatureinF):

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

retour -(100/30)*TemperatuurinF + 200

def gettextremerightledintensity(TemperatureinF):

# Linkervergelijking: y = -(100/30)x + 200 # Rechtervergelijking: y = (100/30)x - (400/3)

retour (100/30)*TemperatuurinF - (400/3)

#De LED-verlichting instellen

def GetLEDBrightness(temp):

if temp <= 0: extreem koud = 100 koud = 100 warm = 0 extreem koud = 0

print("Extreem koud led:" + str(extreem koud))

print("Cold led:" + str(coldled)) print("Extreme hot led" + str(extreemhot)) print("Hot led:" + str(hotled))

ExtremeColdLED.start(extreem koud)

ColdLED.start (koud)

ExtremeHotLED.start(extreem heet)

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

print("Extreem koud led:" + str(extreem koud))

print("Cold led:" + str(coldled)) print("Extreme hot led" + str(extreemhot)) print("Hot led:" + str(hotled))

ExtremeColdLED.start(extreem koud)

ColdLED.start (koud)

ExtremeHotLED.start(extreem heet)

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

print("Extreem koud led:" + str(extreem koud))

print("Cold led:" + str(coldled)) print("Extreme hot led" + str(extreemhot)) print("Hot led:" + str(hotled))

ExtremeColdLED.start(extreem koud)

ColdLED.start (koud)

ExtremeHotLED.start(extreem heet)

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

print("Extreem koud led:" + str(extreem koud))

print("Cold led:" + str(coldled)) print("Extreme hot led" + str(extreemhot)) print("Hot led:" + str(hotled))

ExtremeColdLED.start(extreem koud)

ColdLED.start (koud)

ExtremeHotLED.start(extreem heet)

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

print("Extreem koud led:" + str(extreem koud))

print("Cold led:" + str(coldled)) print("Extreme hot led" + str(extreemhot)) print("Hot led:" + str(hotled))

ExtremeColdLED.start(extreem koud)

ColdLED.start (koud)

ExtremeHotLED.start(extreem heet)

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

coldled = 100 - hotled

extreemkoud = 0

print("Extreem koud led:" + str(extreem koud))

print("Cold led:" + str(coldled)) print("Extreme hot led" + str(extreemhot)) print("Hot led:" + str(hotled))

ExtremeColdLED.start(extreem koud)

ColdLED.start (koud)

ExtremeHotLED.start(extreem heet)

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

print("Extreem koud led:" + str(extreem koud))

print("Cold led:" + str(coldled)) print("Extreme hot led" + str(extreemhot)) print("Hot led:" + str(hotled))

ExtremeColdLED.start(extreem koud)

ColdLED.start (koud)

ExtremeHotLED.start(extreem heet)

HotLED.start(verhit)

Oké, dit gedeelte van de code is erg lang. Het is ook best moeilijk uit te leggen. In wezen kijkt de bovenstaande code naar de temperatuur in Fahrenheit en bepaalt of deze binnen een reeks bereiken valt. Afhankelijk van het bereik, geeft het een nummer voor elke led en zijn helderheid en stelt het vervolgens de helderheid in door het start() commando aan te roepen. Dat is de snelle uitleg. Als het voldoende is, raad ik je aan naar de volgende stap te gaan, maar als je de lange en vervelende uitleg wilt zien, blijf dan lezen.

Toen we programmeerden, besloten we dat de gemakkelijkste manier om een waarde uit een temperatuur te halen, was in de vorm van een wiskundige functie. Dus hebben we een grafiek gemaakt in GeoGebra om weer te geven wat de relatie is tussen onze temperatuur en onze led-helderheid; de reden dat het boven de 100 gaat, is dat de extra in de tweede led zou gaan. We kwamen echter het probleem tegen om een enkele functie te krijgen om al deze punten aan een enkele functie toe te wijzen. We dachten dat we een parabool konden gebruiken, maar we besloten om gewoon genoegen te nemen met het gebruik van een reeks if-statements. In wezen is deze hele code een stukgewijze functie.

De functies bovenaan zijn de respectieve lijnenvergelijking. Als we eenmaal hebben bepaald waar de temperatuur in de grafiek staat, doorlopen we die functie, krijgen de helderheid en geven deze door aan de leds.

Stap 6: Coderen: laatste stappen

Ten slotte voegen we deze verklaring aan het einde toe.

proberen:

while(True): GetLEDBrightness(City_TemperatureF) GetRainLED(WeatherID) time.sleep (10) behalve KeyboardInterrupt: quit()

Met de try-and-behalve-statements kunnen we de code verlaten door een sneltoets te gebruiken; hoe dan ook, we zouden de Raspberry Pi moeten afsluiten om de code opnieuw te starten. Dan hebben we een while-lus die voor altijd loopt. We updaten de leds, evenals de regen-led. We pauzeren tien seconden; OpenWeather staat slechts 60 oproepen voor gegevens per minuut toe, en 10 seconden is genoeg updates.

En daarmee is onze code af. Hieronder staat de voltooide code.

RaspberryPIWeatherStation.py

importverzoeken

importRPi. GPIOasGPIO

importjson

invoertijd

#Openweather idCodes minder dan 700 zijn allemaal neerslag

defCheckRain(IdCode):

ifIdCode<700:

terugkeerTrue

anders:

returnFalse

defgetmiddleleftledintensity(TemperatuurinF):

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

#Juiste vergelijking: y = (50/20)x - 75

retour-(50/20)*TemperatuurinF+175

defgetmiddlerightledintensity(TemperatuurinF):

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

#Juiste vergelijking: y = (50/20)x - 75

retour (50/20)*TemperatuurinF-75

defgetextremeleftledintensity(TemperatureinF):

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

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

retour-(100/30)*TemperatuurinF+200

defgetextremerightledintensity(TemperatureinF):

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

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

retour (100/30)*TemperatuurinF- (400/3)

#GPIO-configuratie

GPIO.setmode(GPIO. BCM)

GPIO.setwaarschuwingen (False)

#Pinnen

Extreem_Hot_LED_PIN=26

Hot_LED_PIN=16

Extreme_Cold_LED_PIN=5

Koud_LED_PIN=6

Rain_LED_PIN=23

#Pin-instellingen

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)

defGetLEDBrightness(temp):

iftemp<=0:

extreemkoud=100

koud gekoeld=100

hotled=0

extreem heet=0

print("Extreem koud led:"+str(extreem koud))

print("Koude led:"+str(koud))

print("Extreem hete led"+str(extreem heet))

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

ExtremeColdLED.start(extreem koud)

ColdLED.start (koud)

ExtremeHotLED.start(extreem heet)

HotLED.start(verhit)

eliftemp>=100:

extreemkoud=0

koudgevroren=0

hotled=100

extreem heet=100

print("Extreem koud led:"+str(extreem koud))

print("Koude led:"+str(koud))

print("Extreem hete led"+str(extreem heet))

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

ExtremeColdLED.start(extreem koud)

ColdLED.start (koud)

ExtremeHotLED.start(extreem heet)

HotLED.start(verhit)

elif0<temp<=30:

extremecoldled=getextremeleftledintensity(temp) -100

koud gekoeld=100

hotled=0

extreem heet=0

print("Extreem koud led:"+str(extreem koud))

print("Koude led:"+str(koud))

print("Extreme hete led"+str(extreem heet))

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

ExtremeColdLED.start(extreem koud)

ColdLED.start (koud)

ExtremeHotLED.start(extreem heet)

HotLED.start(verhit)

elif100>temp>=70:

extreemkoud=0

koudgevroren=0

hotled=100

extremehotled=getextremerightledintensity(temp) -100

print("Extreem koud led:"+str(extreem koud))

print("Koude led:"+str(koud))

print("Extreme hete led"+str(extreem heet))

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

ExtremeColdLED.start(extreem koud)

ColdLED.start (koud)

ExtremeHotLED.start(extreem heet)

HotLED.start(verhit)

elif30<temp<50:

extreemkoud=0

coldled=getmiddleleftledintensity(temp)

hotled=100-coldled

extreem heet=0

print("Extreem koud led:"+str(extreem koud))

print("Koude led:"+str(koud))

print("Extreem hete led"+str(extreem heet))

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

ExtremeColdLED.start(extreem koud)

ColdLED.start (koud)

ExtremeHotLED.start(extreem heet)

HotLED.start(verhit)

elif50<temp<70:

hotled=getmiddlerightledintensity(temp)

extreem heet=0

coldled=100-hotled

extreemkoud=0

print("Extreem koud led:"+str(extreem koud))

print("Koude led:"+str(koud))

print("Extreme hete led"+str(extreem heet))

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

ExtremeColdLED.start(extreem koud)

ColdLED.start (koud)

ExtremeHotLED.start(extreem heet)

HotLED.start(verhit)

eliftemp==50:

extreemkoud=0

koudgevroren=50

hotled=50

extreem heet=0

print("Extreem koud led:"+str(extreem koud))

print("Koude led:"+str(koud))

print("Extreem hete led"+str(extreem heet))

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

ExtremeColdLED.start(extreem koud)

ColdLED.start (koud)

ExtremeHotLED.start(extreem heet)

HotLED.start(verhit)

defGetRainLED(idCode):

ifCheckRain(idCode):

GPIO.output (Rain_LED_PIN, GPIO. HIGH)

anders:

GPIO.output (Rain_LED_PIN, GPIO. LOW)

#Api-informatie: vervang API-sleutel met uw oepnweather api-sleutel

openweather_api_key="460a23f27ff324ef9ae743c7e9c32d7e"

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

print("Typ een stad in!")

city_name=invoer()

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

#Weersgegevens ophalen

Response=requests.get(full_call)

WeatherData=Reactie.json()

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

City_TemperatureK=Weergegevens["main"]["temp"]

City_TemperatureF= (City_TemperatureK-273)*1.8+32#Convert to Fahrenheit

#LED/GPIO-dingen

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

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

print(Weer-ID)

proberen:

terwijl (waar):

GetLEDBrightness(City_TemperatureF)

GetRainLED(Weer-ID)

tijd.slaap(10)

behalve Toetsenbordonderbreking:

ontslag nemen()

bekijk rawRaspberryPIWeatherStation.py gehost met ❤ door GitHub

Stap 7: Opbouwen en bekabelen

Wauw! Na al dat coderen komen we bij het gebouw, wat aanzienlijk eenvoudiger is. Door de corona thuisblijfbestellingen konden we niet aan veel van de hulpmiddelen komen die we op school verwachtten te hebben. Dit deel is dus iets eenvoudiger dan we bedoeld hadden. De specificaties zelf zijn ook flexibel. Eerst tekenden we een rechthoek op een plank van hout. Het specifieke formaat maakt niet zoveel uit, het dient gewoon als een platform om leds en elektronica op te plaatsen.

Daarna boorden we vijf 1/8e gaten in ons stuk hout.

Vervolgens snijden we de rechthoek uit de plank om te gebruiken als ons platform voor onze elektronica.

(Dit was toen we begonnen; we vonden een grotere zaag!)

Vervolgens duwen we de anode- en kathodepinnen van de led in de gaten; de leds zouden bovenop moeten liggen, hun lampen moeten uitsteken; houd bij welk been langer en korter is. Daarna zijn we begonnen met het aan elkaar solderen van draden. Eerst solderen we de weerstanden aan het anodebeen van de LED (het langere been).

Vervolgens solderen we de kathodepoten van de LED's aan een enkele koperdraad die we als aarde zullen gebruiken. Het zou er zo uit moeten zien.

Nadat we dat hebben gedaan, solderen we de mannelijke uiteinden van de vrouwelijke-mannelijke startkabels aan de uiteinden van elke weerstand en de koperen aardingsdraad. Zodra we dat hebben gedaan, kunnen we beginnen met het aansluiten van de draden op de Raspberry PI GPIO-pinnen. Hier is een schema! Houd er echter rekening mee dat de pinnen die in de eerder besproken code zijn.

Als je dat allemaal hebt aangesloten, hoef je nu alleen nog maar het Python-bestand op de Raspberry Pi te zetten en de terminal te openen. voer "python3 RaspberryPIWeatherStation.py" uit en doe wat het laat zien.

Stap 8: Demonstratie en conclusie

Bedankt voor het helemaal lezen! Ik zal het python-script hieronder bijvoegen! Als er dingen waren die we konden toevoegen, zou het waarschijnlijk zijn…

1. Ondersteuning voor verschillende invoertypes (steden, geografische punten, enz.)

2. Ondersteuning voor meer weersinformatie

3. Voeg een klein scherm toe om informatie weer te geven

Laat ons uw mening weten! Dit was een leuk project om te bouwen. We hebben veel geleerd over verzoeken en het verkrijgen van internetdocumenten met python, en we hebben ook veel geleerd over het gebruik van solderen.