Raspberry PI LED -väderstation: 8 steg

2024 Författare: John Day | [email protected]. Senast ändrad: 2024-01-30 12:39

Vi skapade en Raspberry PI Weather LED -station. Det berättar för användaren hur varm och kall en stad är genom att lysa upp och dimma lysdioder. Det har också en ledning att berätta för dem om det regnar i staden eller inte.

Skapad av Michael Andrews och Tio Marello.

Tillbehör

Verktyg

1. Lödkolv
2. Dremel
3. Fick syn på

Material

1. Hallon Pi 3 B+ ~ 40 dollar ~ 30 dollar
2. Kvinnliga till manliga bygelkablar ~ 7 dollar
3. 3 blå och 2 röda LED -dioder ~ 11 dollar
4. 100 Ohm motstånd ~ 13 dollar
5. 4 x 4 x 1/4 träplanka ~ 5 dollar
6. Lödning ~ 10 dollar
7. Koppartråd ~ 5 dollar

Steg 1: Kodning som problemlösning

Kodning är problemlösning

Så vad är vårt problem i vårt projekt? Vårt problem är att få väderdata och sedan använda den för att berätta för våra lysdioder om de är av eller på. Så detta delar upp vårt problem i tre områden.

1. Få väderdata

2. Använda den informationen

3. Använda lysdioder

Men språket vi använde för detta projekt, Python, och hårdvaran det körs på, Python, ger oss ett enkelt sätt att uppnå dessa mål.

Så, låt oss börja med det första problemet, att få väderdata.

Steg 2: Kodning: Få väderdata

Python i sig kan inte få väderdata. Vi måste importera två verktyg, samt en extern tjänst, för att få väderdata. För att göra detta använder vi tre verktyg.

1. Requests, en python -modul som tillåter webbskrapning

2. Json, en python -modul som tillåter oss att använda JSON -filformatet

3. OpenWeather, en webbplats som kan ge oss väderdata

Så vi tar med de två modulerna genom att skriva den här koden högst upp i vårt python -skript.

importförfrågningar

importera json

Innan vi använder dessa verktyg måste vi dock använda Openweather. För det måste vi skapa ett konto på deras webbplats och få en API -nyckel. Följ instruktionerna på deras webbplats så får du en rad bokstäver och siffror som låter oss använda deras tjänst. Hur?

openweather_api_key = "260a23f27f5324ef2ae763c779c32d7e" #Our API Key (Not Real)

base_call = "https://api.openweathermap.org/data/2.5/weather?q=" #OpenWeather Call #Här får vi användarens stad i form av textutskrift ("Skriv in en stad!") city_name = input () #Här samlade vi adressen vi ska ansluta till requests.get för att ta emot väderdata full_call = base_call+city_name+"& appid ="+openweather_api_key #Slutligen kallar vi request.get med vår adress, sedan konverterar vi den till en json -fil Response = requests.get (full_call) WeatherData = Response.json () #JSON -filer innehåller olika variabler som vi kan komma åt med hjälp av denna syntax #Här får vi väder -ID och temperaturen i Kelvin i staden som användaren skrev in WeatherID = WeatherData ["väder"] [0] ["id"] City_TemperatureK = WeatherData ["main"] ["temp"]

Här har vi koden som ger oss våra väderdata. Förfrågningar, i form av requests.get, tar in en webbadress och ger oss en fil från den webbplatsen tillbaka. OpenWeather ger oss en adress att ringa för att ge oss väderdata i form av en json. Vi samlar en adress som vi kopplar in förfrågningar och får tillbaka en json -fil. Sedan skapar vi två variabler och tilldelar dem temperaturen och väderleken i användarens stad.

Så nu, med den här koden, har vi två variabler. Vi har ett weatherID och en temperatur i Kelvin

Steg 3: Kodning: Användning av data

Nu när vi har dessa två variabler måste vi förbereda dem för användning för våra lysdioder. För denna aspekt behöver vi inte importera några moduler för detta.

Först konverterar vi kelvin till Fahrenheit.

Vi gör detta genom att skapa en variabel med denna syntax

City_TemperatureF = (City_TemperatureK - 273)*1.8 + 32

som konverterar från Kelvin till Fahrenheit (som verkligen konverterar från K -> C -> F)

Nästa är vårt väder -ID. WeatherID är ett ID som Openweather tillhandahåller som berättar om väderförhållandena i en stad.

openweathermap.org/weather-conditions Här är en lista över dem.

Vi märkte att allt under 700 -talet var någon form av nederbörd, så vi kollade bara om koden var under 700 för att se om det regnade.

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

Med det har vi våra två variabler förberedda för användning med våra Raspberry PI -stift och LED -dioder.

Steg 4: Kodning: Användning av RPi. GPIO och LED -dioder

RaspberryPi levereras med en uppsättning hanstift som vi kan använda för att kommunicera med en mängd elektriska komponenter, som i detta fall är LED -dioder; det liknar Arduino och dess system. Raspberry PI är dock en dator för allmänna ändamål, till skillnad från en mikrokontroller som Arduino. Så vi måste göra lite mer arbete för att använda dem. Detta består av att sätta upp stiften på Raspberry Pi. Vi gör detta genom att använda den här koden.

importera RPi. GPIO som GPIO #Vi importerar modulen så att vi kan använda den

#Sätt upp pinsGPIO.setmode (GPIO. BCM) GPIO.setwarnings (False)

#Stiften som lysdioderna är anslutna till. Dessa kan vara olika om du bygger det, så se till att jämföra och ändra när det behövs

Extreme_Hot_LED_PIN = 26 Hot_LED_PIN = 16

Extreme_Cold_LED_PIN = 5

Cold_LED_PIN = 6

Rain_LED_PIN = 23

#Vi går igenom varje stift, använder kommandot.setup, lägger in dess nummer och ställer in det som en utgångsstift

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_L_

Denna kod skulle dock bara låta oss använda två tillstånd med led, det vill säga på och av. Vi behöver det dock för att kunna dämpa lamporna. För att göra detta använder vi Pulse Width Modulation.

Använda pulsbreddsmodulering

Pulse Width Modulation låter oss mata ut en analog signal med hjälp av en digital stift. I huvudsak slår den på och av signalkällan med en hög hastighet, som i genomsnitt går ut till viss spänning. RPi. GPIO tillåter oss att använda detta, om än med lite extra kod.

#Vi skapar fyra stiftsobjekt med kommandot GPIO. PWM, som tar in ett kanalnummer

#Det andra numret är antalet gånger det uppdateras per 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)

För nästa steg måste du veta hur vi uppdaterar dessa stift.

Vi uppdaterar stiften med kommandot

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

ExtremeHotLED.start (x)

HotLED.start (x)

x i detta fall skulle vara arbetscykeln, som avgör hur mycket den pulserar av. Det sträcker sig från 0-100, så vi måste basera vår nästa kod på det faktumet.

Steg 5: Kodning: Få LED -ljusstyrka

Eftersom vi har fyra olika lysdioder vill vi tända dem beroende på hur. kallt eller varmt är det i användarens stad. Vi bestämde oss för att ha fyra etapper för ledningen.

#Funktioner

def getmiddleleddledintensity (TemperatureinF): #Left Equation: y = -(50/20) x + 175 #Right Equation: y = (50/20) x -75 return -(50/20)*TemperatureinF + 175

def getmiddlerightledintensity (TemperatureinF):

#Vänster ekvation: y = - (50/20) x + 175 #Höger ekvation: y = (50/20) x - 75 retur (50/20)*Temperatur iF - 75

def getextremeleftledintensity (TemperatureinF):

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

retur -(100/30)*Temperatur iF + 200

def getextremerightledintensity (TemperatureinF):

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

retur (100/30)*Temperatur iF - (400/3)

#Ställa in LED -lamporna

def GetLEDBrightness (temp):

om temp <= 0: extremcoldled = 100 coldled = 100 hotled = 0 extremhotled = 0

print ("Extreme cold led:" + str (extremcoldled))

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

ExtremeColdLED.start (extremcoldled)

ColdLED.start (coldled)

ExtremeHotLED.start (extremehotled)

HotLED.start (hotled) elif temp> = 100: extremcoldled = 0 coldled = 0 hotled = 100 extremhotled = 100

print ("Extreme cold led:" + str (extremcoldled))

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

ExtremeColdLED.start (extremcoldled)

ColdLED.start (coldled)

ExtremeHotLED.start (extremehotled)

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

print ("Extreme cold led:" + str (extremcoldled))

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

ExtremeColdLED.start (extremcoldled)

ColdLED.start (coldled)

ExtremeHotLED.start (extremehotled)

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

print ("Extreme cold led:" + str (extremcoldled))

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

ExtremeColdLED.start (extremcoldled)

ColdLED.start (coldled)

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 (extremcoldled))

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

ExtremeColdLED.start (extremcoldled)

ColdLED.start (coldled)

ExtremeHotLED.start (extremehotled)

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

coldled = 100 - hotled

extremt kallt = 0

print ("Extreme cold led:" + str (extremcoldled))

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

ExtremeColdLED.start (extremcoldled)

ColdLED.start (coldled)

ExtremeHotLED.start (extremehotled)

HotLED.start (hotled) elif temp == 50: extremcoldled = 0 coldled = 50 hotled = 50 extremhotled = 0

print ("Extreme cold led:" + str (extremcoldled))

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

ExtremeColdLED.start (extremcoldled)

ColdLED.start (coldled)

ExtremeHotLED.start (extremehotled)

HotLED.start (hotled)

Okej, den här delen av koden är riktigt lång. Det är också ganska svårt att förklara. I huvudsak tittar koden ovan på temperaturen i Fahrenheit och avgör om den är i en uppsättning intervall. Beroende på intervallet ger den ett nummer för varje LED och dess ljusstyrka och ställer sedan in ljusstyrkan genom att ringa kommandot start (). Det är den snabba förklaringen. Om det räcker rekommenderar jag att du går vidare till nästa steg, men om du vill se den långa och tråkiga förklaringen, fortsätt läsa.

När vi programmerade bestämde vi oss för att det enklaste sättet att få ett värde från en temperatur var i form av en matematisk funktion. Så, vi skapade en graf i GeoGebra för att representera förhållandet mellan vår temperatur och vår ledda ljusstyrka; anledningen till att det går över 100 är att det extra skulle gå in i den andra ledningen. Men vi stötte på frågan om att få en enda funktion för att kartlägga alla dessa punkter till en enda funktion. Vi trodde att vi kunde använda en parabel, men vi bestämde oss för att bara nöja oss med att använda en rad if -uttalanden. I huvudsak är hela denna kod en bitvis funktion.

Funktionerna överst är respektive linjeekvation. När vi bestämmer var temperaturen är på grafen kör vi den genom den funktionen, får ljusstyrkan och skickar den till lysdioderna.

Steg 6: Kodning: Slutsteg

Slutligen lägger vi till detta uttalande i slutet.

Prova:

while (True): GetLEDBrightness (City_TemperatureF) GetRainLED (WeatherID) time.sleep (10) utom KeyboardInterrupt: avsluta ()

Med försöks- och undantagsuttalanden kan vi avsluta koden med hjälp av en kortkommando; i alla fall måste vi stänga av Raspberry Pi för att starta om koden. Sedan har vi en stundslinga som löper för alltid. Vi uppdaterar lysdioderna, samt uppdaterar regndioden. Vi pausar i tio sekunder; OpenWeather tillåter bara 60 samtal för data per minut, och 10 sekunder är gott om uppdateringar.

Och med det är vår kod klar. Nedan är den färdiga koden.

HallonPIWeatherStation.py

importfrågor

importRPi. GPIOasGPIO

importjson

importtid

#Oppväder -idKoder mindre än 700 är alla nederbörd

defCheckRain (IdCode):

ifIdCode <700:

returnTrue

annan:

returnFalse

defgetmiddleleftledintensity (TemperatureinF):

#Vänster ekvation: y =-(50/20) x + 175

#Rätt ekvation: y = (50/20) x - 75

retur- (50/20)*Temperatur iF+175

defgetmiddlerightledintensity (TemperatureinF):

#Vänster ekvation: y =-(50/20) x + 175

#Rätt ekvation: y = (50/20) x - 75

retur (50/20)*Temperatur i F-75

defgetextremeleftledintensity (TemperatureinF):

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

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

retur- (100/30)*Temperatur iF+200

defgetextremerightledintensity (TemperatureinF):

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

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

retur (100/30)*Temperatur iF- (400/3)

#GPIO -inställning

GPIO.setmode (GPIO. BCM)

GPIO.setwarnings (falskt)

#Nålar

Extreme_Hot_LED_PIN = 26

Hot_LED_PIN = 16

Extreme_Cold_LED_PIN = 5

Cold_LED_PIN = 6

Rain_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)

defGetLEDBrightness (temp):

iftemp <= 0:

extremt kallt = 100

kallt = 100

hotled = 0

extremhotad = 0

print ("Extreme cold led:"+str (extremcoldled))

print ("Cold led:"+str (coldled))

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

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

ExtremeColdLED.start (extremcoldled)

ColdLED.start (coldled)

ExtremeHotLED.start (extremehotled)

HotLED.start (hotled)

eliftemp> = 100:

extremt kallt = 0

kallt = 0

hotled = 100

extremhotad = 100

print ("Extreme cold led:"+str (extremcoldled))

print ("Cold led:"+str (coldled))

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

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

ExtremeColdLED.start (extremcoldled)

ColdLED.start (coldled)

ExtremeHotLED.start (extremehotled)

HotLED.start (hotled)

elif0 <temp <= 30:

extremcoldled = getextremeleftledintensity (temp) -100

kallt = 100

hotled = 0

extremhotad = 0

print ("Extreme cold led:"+str (extremcoldled))

print ("Cold led:"+str (coldled))

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

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

ExtremeColdLED.start (extremcoldled)

ColdLED.start (coldled)

ExtremeHotLED.start (extremehotled)

HotLED.start (hotled)

elif100> temp> = 70:

extremt kallt = 0

kallt = 0

hotled = 100

extremhotled = getextremerightledintensity (temp) -100

print ("Extreme cold led:"+str (extremcoldled))

print ("Cold led:"+str (coldled))

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

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

ExtremeColdLED.start (extremcoldled)

ColdLED.start (coldled)

ExtremeHotLED.start (extremehotled)

HotLED.start (hotled)

elif30 <temp <50:

extremt kallt = 0

coldled = getmiddleleftledintensity (temp)

hotled = 100-coldled

extremhotad = 0

print ("Extreme cold led:"+str (extremcoldled))

print ("Cold led:"+str (coldled))

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

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

ExtremeColdLED.start (extremcoldled)

ColdLED.start (coldled)

ExtremeHotLED.start (extremehotled)

HotLED.start (hotled)

elif50 <temp <70:

hotled = getmiddlerightledintensity (temp)

extremhotad = 0

coldled = 100-hotled

extremt kallt = 0

print ("Extreme cold led:"+str (extremcoldled))

print ("Cold led:"+str (coldled))

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

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

ExtremeColdLED.start (extremcoldled)

ColdLED.start (coldled)

ExtremeHotLED.start (extremehotled)

HotLED.start (hotled)

eliftemp == 50:

extremt kallt = 0

kallt = 50

hotled = 50

extremhotad = 0

print ("Extreme cold led:"+str (extremcoldled))

print ("Cold led:"+str (coldled))

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

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

ExtremeColdLED.start (extremcoldled)

ColdLED.start (coldled)

ExtremeHotLED.start (extremehotled)

HotLED.start (hotled)

defGetRainLED (idCode):

ifCheckRain (idCode):

GPIO.output (Rain_LED_PIN, GPIO. HIGH)

annan:

GPIO.output (Rain_LED_PIN, GPIO. LOW)

#Api -information: Omvärdera API -nyckeln med din oepnweather api -nyckel

openweather_api_key = "460a23f27ff324ef9ae743c7e9c32d7e"

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

print ("Skriv in en stad!")

city_name = input ()

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

#Skaffa väderdata

Svar = request.get (full_call)

WeatherData = Response.json ()

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

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

City_TemperatureF = (City_TemperatureK-273)*1.8+32#Konvertera till Fahrenheit

#LED/GPIO -saker

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

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

print (WeatherID)

Prova:

medan (Sant):

GetLEDBrightness (City_TemperatureF)

GetRainLED (WeatherID)

tid. sover (10)

utomKeyboardInterrupt:

sluta med()

visa rawRaspberryPIWeatherStation.py värd med ❤ av GitHub

Steg 7: Bygga och koppla upp

Oj! Efter all den kodningen kommer vi till byggnaden, vilket är betydligt enklare. På grund av corona -vistelsen hemma kunde vi inte komma till många av de verktyg vi förväntade oss att ha i skolan. Så den här delen är lite enklare än vad vi tänkt oss. Specifikationerna i sig är också flexibla. Först ritade vi en rektangel på en träplanka. Den specifika storleken spelar egentligen inte så stor roll, eftersom den helt enkelt fungerar som en plattform för att sätta lysdioder och elektronik på.

Sedan borrade vi fem 1/8 i hål i vår vedbit.

Vi skar sedan ut rektangeln från planken för att använda som vår plattform för vår elektronik.

(Det var när vi började; vi hittade en större såg!)

Vi skjuter sedan anod- och katodstiftet i ledningen in i hålen; lysdioderna ska ligga på toppen, deras lökar sticker ut; hålla reda på vilket ben som är längre och kortare. Vi började sedan lödda ihop trådar. Först löder vi motstånden mot lysdiodens anodben (det längre benet).

Sedan lödar vi katodbenen på lysdioderna till en enda koppartråd som vi ska använda som jord. Det ska se ut så här.

Efter att vi gjort det, lödde vi hanändarna på hona-hankopplingskablar till ändändarna på varje motstånd och koppartrådstråden. När vi har gjort det kan vi börja ansluta ledningarna till hallon PI GPIO -stiften. Här är ett diagram! Observera dock att stiften är de i den tidigare berörda koden.

När du väl har gjort allt är det bara att hämta Python -filen till hallon Pi och öppna terminalen. kör "python3 RaspberryPIWeatherStation.py" och gör sedan som det visas.

Steg 8: Demonstration och slutsats

Tack för att du läste hela vägen! Jag bifogar python -skriptet nedan! Om det fanns saker vi kunde lägga till, skulle det förmodligen vara …

1. Stöd för olika ingångstyper (städer, geografiska punkter, etc.)

2. Stöd för mer väderinformation

3. Lägg till en liten skärm för att visa information

Låt oss veta dina tankar! Detta var ett roligt projekt att bygga. Vi lärde oss mycket om förfrågningar och att få internetdokument med python, och vi lärde oss också mycket om att använda lödning.