Estació meteorològica LED Raspberry PI: 8 passos

2024 Autora: John Day | [email protected]. Última modificació: 2024-01-30 08:12

Vam crear una estació LED Raspberry PI Weather. Indica a l’usuari el calor i el fred que té una ciutat il·luminant i atenuant els leds. També els ha permès dir-los si plou a la ciutat que han escrit.

Creat per Michael Andrews i Tio Marello.

Subministraments

Eines

1. Soldador
2. Dremel
3. va veure

Materials

1. Raspberry Pi 3 B + ~ 40 dòlars ~ 30 dòlars
2. Fils de pont femení a masculí ~ 7 dòlars
3. 3 díodes LED blaus i 2 vermells ~ 11 dòlars
4. Resistències de 100 ohms ~ 13 dòlars
5. Tauló de fusta de 4 x 4 x 1/4 ~ 5 dòlars
6. Soldadura ~ 10 dòlars
7. Fil de coure ~ 5 dòlars

Pas 1: Codificació com a solució de problemes

La codificació és la resolució de problemes

Per tant, en el nostre projecte, quin és el nostre problema? El nostre problema és obtenir dades meteorològiques i després utilitzar-les per indicar als nostres LEDS si estan apagats o encesos. Per tant, això divideix el nostre problema en tres àrees.

1. Obtenir dades meteorològiques

2. Ús d'aquestes dades

3. Ús de LEDS

Tanmateix, el llenguatge que hem utilitzat per a aquest projecte, Python, i el maquinari en què s’executa, Python, ens proporcionen una manera senzilla d’aconseguir aquests objectius.

Comencem, doncs, amb el primer problema: obtenir dades meteorològiques.

Pas 2: Codificació: obtenció de dades meteorològiques

Python per si mateix no pot obtenir dades meteorològiques. Hem d’importar dues eines, així com un servei extern, per obtenir dades meteorològiques. Per fer-ho, fem servir tres eines.

1. Sol·licituds, un mòdul Python que permet el rastreig web

2. Json, un mòdul python que ens permet utilitzar el format de fitxer JSON

3. OpenWeather, un lloc web que ens pot proporcionar dades meteorològiques

Per tant, aportem els dos mòduls escrivint aquest codi a la part superior del nostre script Python.

sol·licituds d’importació

importació json

Abans d’utilitzar aquestes eines, però, hem d’utilitzar Openweather. Per a això, hem de crear un compte al seu lloc i obtenir una clau API. Seguiu les instruccions del seu lloc web i obtindreu una sèrie de lletres i números que ens permetran utilitzar el seu servei. Com?

openweather_api_key = "260a23f27f5324ef2ae763c779c32d7e" #La nostra clau d'API (no real)

base_call = "https://api.openweathermap.org/data/2.5/weather?q=" #OpenWeather Call #Aquí obtenim la ciutat de l'usuari en forma d'impressió de text ("Escriviu una ciutat!") city_name = input () #Aquí hem reunit l'adreça que connectarem a requests.get per rebre dades meteorològiques full_call = base_call + city_name + "& appid =" + openweather_api_key #Finalment cridem requests.get amb la nostra adreça, i després la convertim en un fitxer json Response = requests.get (full_call) WeatherData = Response.json () Els fitxers #JSON contenen diferents variables a les quals podem accedir mitjançant aquesta sintaxi. ["weather"] [0] ["id"] City_TemperatureK = WeatherData ["main"] ["temp"]

Aquí tenim el codi que ens proporciona les nostres dades meteorològiques. Les sol·licituds, en forma de requests.get, prenen una adreça del lloc web i ens retornen un fitxer d’aquest lloc web. OpenWeather ens proporciona una adreça per trucar-nos per donar-nos dades meteorològiques en forma de json. Muntem una adreça que connectem a les sol·licituds i recuperem un fitxer json. A continuació, creem dues variables i les assignem a la temperatura i al clima de la ciutat de l'usuari.

Per tant, ara, amb aquest codi, tenim dues variables. Tenim un weatherID i una temperatura a Kelvin

Pas 3: Codificació: utilitzar aquestes dades

Ara que tenim aquestes dues variables, hem de preparar-les per utilitzar-les per als nostres LEDS. Per a aquest aspecte, no hem d'importar cap mòdul per a això.

En primer lloc, convertim el kelvin a Fahrenheit.

Ho fem creant una variable amb aquesta sintaxi

Ciutat_TemperaturaF = (Ciutat_TemperaturaK - 273) * 1,8 + 32

que converteix de Kelvin a Fahrenheit (que realment s'està convertint de K -> C -> F)

El següent és el nostre weatherID. WeatherID és un identificador que Openweather proporciona que ens informa sobre les condicions meteorològiques d’una ciutat.

openweathermap.org/weather-conditions Aquí teniu una llista.

Vam observar que tot el nombre inferior a 700 era una mena de precipitació, així que vam comprovar si el codi era inferior a 700 per veure si plovia.

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

Amb això, tenim preparades les nostres dues variables per utilitzar-les amb els nostres pins Raspberry PI i els díodes LED.

Pas 4: Codificació: utilitzant díodes RPi. GPIO i LED

El RaspberryPi ve amb un conjunt de pins masculins que podem utilitzar per comunicar-nos amb una gran quantitat de components elèctrics, que en aquest cas són díodes LED; és similar a Arduino i el seu sistema. Tanmateix, el Raspberry PI és un ordinador de propòsit general, a diferència d’un microcontrolador com l’Arduino. Per tant, hem de fer una mica més de feina per utilitzar-los. Això consisteix a configurar els pins al Raspberry Pi. Ho fem mitjançant aquest codi.

importar RPi. GPIO com GPIO # Importem el mòdul perquè el puguem utilitzar

# Configureu els pinsGPIO.setmode (GPIO. BCM) GPIO.setwarnings (fals)

# Els pins als quals estan connectats els LED. Poden ser diferents si el construïu, així que assegureu-vos de comparar i canviar quan calgui

Extreme_Hot_LED_PIN = 26 Hot_LED_PIN = 16

Extreme_Cold_LED_PIN = 5

Fred_LED_PIN = 6

Pluja_LED_PIN = 23

#Entreguem tots els pins utilitzant l'ordre.setup, introduint el seu número i configurant-lo com a pin de sortida

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, Tot i això, aquest codi només ens permetria utilitzar dos estats amb el led, és a dir, encès i apagat. Tot i això, ho necessitem per poder enfosquir els llums. Per fer-ho, fem servir la modulació d’amplada de pols.

Utilitzant la modulació d’amplada de pols

La modulació d’amplada de pols ens permet emetre un senyal analògic mitjançant un pin digital. Bàsicament, encén i apaga la font del senyal a un ritme elevat, que es produeix de mitjana fins a cert voltatge. El RPi. GPIO ens permet utilitzar-ho, encara que amb algun codi addicional.

#Creem quatre objectes de pin mitjançant l'ordre GPIO. PWM, que pren un número de canal

#El segon número és el nombre de vegades que s’actualitza per segon

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)

Per al següent pas, haureu de saber la manera com actualitzem aquests pins.

Actualitzem els pins mitjançant l’ordre

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

ExtremeHotLED.start (x)

HotLED.start (x)

x, en aquest cas, seria el cicle de treball, que determina la quantitat de polsos. Va del 0 al 100, de manera que hem de basar el nostre següent codi en aquest fet.

Pas 5: Codificació: Obtenir la brillantor del LED

Com que tenim quatre leds diferents, els volem il·luminar en funció de com. fred o calor, és a la ciutat de l'usuari. Vam decidir tenir quatre etapes per al liderat.

#Funcions

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

def getmiddlerightledintensity (TemperatureinF):

# Equació esquerra: y = - (50/20) x + 175 # Equació dreta: y = (50/20) x - 75 retorn (50/20) * Temperatura en F - 75

def getextremeleftledintensity (TemperatureinF):

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

retorn - (100/30) * Temperatura en F + 200

def getextremerightledintensity (TemperatureinF):

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

retorn (100/30) * Temperatura en F - (400/3)

#Configuració de les llums LED

def GetLEDBrightness (temp):

si temp <= 0: extremedolded = 100 coldled = 100 hotled = 0 extremehotled = 0

print ("LED extrem extrem:" + str (extremecoldled))

print ("Led en fred:" + str (refredat)) imprimir ("Led en extrem extrem" + str (extremhotled)) imprimir ("Led en calent:" + str (hotled))

ExtremeColdLED.start (extremecoldled)

ColdLED.start (refredat)

ExtremeHotLED.start (extremehotled)

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

print ("LED extrem extrem:" + str (extremecoldled))

print ("Led en fred:" + str (refredat)) imprimir ("Led en extrem extrem" + str (extremhotled)) imprimir ("Led en calent:" + str (hotled))

ExtremeColdLED.start (extremecoldled)

ColdLED.start (refredat)

ExtremeHotLED.start (extremehotled)

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

print ("LED extrem extrem:" + str (extremecoldled))

print ("Led fred:" + str (refredat)) imprimir ("LED extrem calent" + str (extremhotled)) imprimir ("Led fred:" + str (refredat))

ExtremeColdLED.start (extremecoldled)

ColdLED.start (refredat)

ExtremeHotLED.start (extremehotled)

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

print ("LED extrem extrem:" + str (extremecoldled))

print ("Led fred:" + str (refredat)) imprimir ("LED extrem calent" + str (extremhotled)) imprimir ("Led fred:" + str (refredat))

ExtremeColdLED.start (extremecoldled)

ColdLED.start (refredat)

ExtremeHotLED.start (extremehotled)

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

print ("LED extrem extrem:" + str (extremecoldled))

print ("Led en fred:" + str (refredat)) imprimir ("Led en extrem extrem" + str (extremhotled)) imprimir ("Led en calent:" + str (hotled))

ExtremeColdLED.start (extremecoldled)

ColdLED.start (refredat)

ExtremeHotLED.start (extremehotled)

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

refredat = 100 - calent

extremecoldled = 0

print ("LED extrem extrem:" + str (extremecoldled))

print ("Led en fred:" + str (refredat)) imprimir ("Led en extrem extrem" + str (extremhotled)) imprimir ("Led en calent:" + str (hotled))

ExtremeColdLED.start (extremecoldled)

ColdLED.start (refredat)

ExtremeHotLED.start (extremehotled)

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

print ("LED extrem extrem:" + str (extremecoldled))

print ("Led en fred:" + str (refredat)) imprimir ("Led en extrem extrem" + str (extremhotled)) imprimir ("Led en calent:" + str (hotled))

ExtremeColdLED.start (extremecoldled)

ColdLED.start (refredat)

ExtremeHotLED.start (extremehotled)

HotLED.start (hotled)

Molt bé, aquesta secció de codi és realment llarga. També és bastant difícil d’explicar. Bàsicament, el codi que apareix a dalt analitza la temperatura en Fahrenheit i determina si es troba en un conjunt d’intervals. Depenent dels intervals, dóna un número per a cada led i la seva brillantor i, a continuació, estableix la brillantor trucant a l'ordre start (). Aquesta és la ràpida explicació. Si n’hi ha prou, us recomano passar al següent pas, però si voleu veure la llarga i tediosa explicació, continueu llegint.

Quan vam programar, vam decidir que la forma més senzilla d’obtenir un valor a partir d’una temperatura era en forma de funció matemàtica. Per tant, hem creat un gràfic a GeoGebra per representar quina és la relació entre la nostra temperatura i la nostra brillantor de led; la raó per la qual supera els 100 és que l’extra entraria al segon led. No obstant això, ens vam trobar amb el problema d’aconseguir una funció única per assignar tots aquests punts a una sola funció. Vam pensar que podríem utilitzar una paràbola, però vam decidir conformar-nos amb l’ús d’una sèrie d’afirmacions if. En essència, tot aquest codi és una funció a trossos.

Les funcions de la part superior són l’equació de línies respectiva. Un cop determinem on es troba la temperatura al gràfic, la passem per aquesta funció, obtenim la brillantor i la passem als leds.

Pas 6: Codificació: passos finals

Finalment, afegim aquesta afirmació al final.

provar:

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

Les sentències try and except ens permeten sortir del codi mitjançant una drecera de teclat; en qualsevol cas, hauríem d'apagar el Raspberry Pi per reiniciar el codi. Després tenim un bucle de temps que funciona per sempre. Actualitzem els leds i actualitzem el LED de pluja. Fem una pausa durant deu segons; OpenWeather només permet 60 trucades de dades per minut i 10 segons són moltes actualitzacions.

I amb això, el nostre codi s’ha acabat. A continuació es mostra el codi acabat.

RaspberryPIWeatherStation.py

sol·licituds d’importació

importRPi. GPIOasGPIO

importjson

temps d’importació

#Openweather idCodes de menys de 700 són precipitacions

defCheckRain (IdCode):

ifIdCode <700:

tornarCert

en cas contrari:

tornar Fals

defgetmiddleleftledintensity (TemperatureinF):

#Equació esquerra: y = - (50/20) x + 175

# Equació dreta: y = (50/20) x - 75

retorn- (50/20) * Temperatura en F + 175

defgetmiddlerightledintensity (TemperatureinF):

#Equació esquerra: y = - (50/20) x + 175

# Equació dreta: y = (50/20) x - 75

retorn (50/20) * Temperatura en F-75

defgetextremeleftledintensity (TemperatureinF):

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

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

retorn- (100/30) * Temperatura en F + 200

defgetextremerightledintensity (TemperatureinF):

# Equació esquerra: y = - (100/30) x + 200

# Equació dreta: y = (100/30) x - (400/3)

retorn (100/30) * Temperatura en F- (400/3)

Configuració #GPIO

GPIO.setmode (GPIO. BCM)

GPIO.setwarnings (fals)

#Pins

Extreme_Hot_LED_PIN = 26

Hot_LED_PIN = 16

Extreme_Cold_LED_PIN = 5

Fred_LED_PIN = 6

Rain_LED_PIN = 23

Configuració #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_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:

extremecoldled = 100

refredat = 100

hotled = 0

extremehotled = 0

print ("LED extrem extrem:" + str (extremecoldled))

print ("Led fred:" + str (refredat))

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

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

ExtremeColdLED.start (extremecoldled)

ColdLED.start (refredat)

ExtremeHotLED.start (extremehotled)

HotLED.start (hotled)

eliftemp> = 100:

extremecoldled = 0

refredat = 0

escalfat = 100

extremhotled = 100

print ("LED extrem extrem:" + str (extremecoldled))

print ("Led fred:" + str (refredat))

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

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

ExtremeColdLED.start (extremecoldled)

ColdLED.start (refredat)

ExtremeHotLED.start (extremehotled)

HotLED.start (hotled)

elif0 <temp <= 30:

extremecoldled = getextremeleftledintensity (temp) -100

refredat = 100

hotled = 0

extremehotled = 0

print ("LED extrem extrem:" + str (extremecoldled))

print ("Led fred:" + str (refredat))

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

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

ExtremeColdLED.start (extremecoldled)

ColdLED.start (refredat)

ExtremeHotLED.start (extremehotled)

HotLED.start (hotled)

elif100> temp> = 70:

extremecoldled = 0

refredat = 0

escalfat = 100

extremehotled = getextremerightledintensity (temp) -100

print ("LED extrem extrem:" + str (extremecoldled))

print ("Led fred:" + str (refredat))

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

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

ExtremeColdLED.start (extremecoldled)

ColdLED.start (refredat)

ExtremeHotLED.start (extremehotled)

HotLED.start (hotled)

elif30 <temp <50:

extremecoldled = 0

coldled = getmiddleleftledintensity (temp)

escalfat = 100-refredat

extremehotled = 0

print ("LED extrem extrem:" + str (extremecoldled))

print ("Led fred:" + str (refredat))

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

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

ExtremeColdLED.start (extremecoldled)

ColdLED.start (refredat)

ExtremeHotLED.start (extremehotled)

HotLED.start (hotled)

elif50 <temp <70:

hotled = getmiddlerightledintensity (temp)

extremehotled = 0

refredat = 100 focs

extremecoldled = 0

print ("LED extrem extrem:" + str (extremecoldled))

print ("Led fred:" + str (refredat))

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

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

ExtremeColdLED.start (extremecoldled)

ColdLED.start (refredat)

ExtremeHotLED.start (extremehotled)

HotLED.start (hotled)

eliftemp == 50:

extremecoldled = 0

freda = 50

escalfat = 50

extremehotled = 0

print ("LED extrem extrem:" + str (extremecoldled))

print ("Led fred:" + str (refredat))

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

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

ExtremeColdLED.start (extremecoldled)

ColdLED.start (refredat)

ExtremeHotLED.start (extremehotled)

HotLED.start (hotled)

defGetRainLED (idCode):

ifCheckRain (idCode):

GPIO.output (Rain_LED_PIN, GPIO. HIGH)

en cas contrari:

GPIO.output (Rain_LED_PIN, GPIO. LOW)

Informació #Api: Repalqueu la clau API amb la vostra clau API oepnweather

openweather_api_key = "460a23f27ff324ef9ae743c7e9c32d7e"

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

print ("Escriu una ciutat!")

city_name = input ()

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

# Obtenció de dades meteorològiques

Response = 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 # Converteix a Fahrenheit

# Coses LED / GPIO

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

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

imprimir (WeatherID)

provar:

mentre que (cert):

GetLEDBrightness (City_TemperatureF)

GetRainLED (WeatherID)

time.sleep (10)

exceptKeyboardInterrupt:

deixar ()

visualitza rawRaspberryPIWeatherStation.py allotjat amb ❤ per GitHub

Pas 7: construcció i cablejat

Vaja! Després de tota aquesta codificació, arribem a l’edifici, cosa que és molt més fàcil. A causa de les comandes de permanència a casa, no vam poder arribar a moltes de les eines que esperàvem tenir a l’escola. Per tant, aquesta part és una mica més senzilla del que preteníem. Els detalls en si mateixos també són flexibles. Primer vam dibuixar un rectangle sobre una planxa de fusta. La mida específica realment no importa massa, ja que simplement serveix de plataforma per posar leds i electrònica.

Després vam perforar cinc 1/8 en forats del nostre tros de fusta.

A continuació, retallem el rectangle del tauler per utilitzar-lo com a plataforma per a la nostra electrònica.

(Va ser quan vam començar; vam trobar una serra més gran!)

A continuació, empenyem els passadors d'ànode i càtode del led als forats; els leds haurien d'estar posats a la part superior, amb les bombetes que sobresortissin; feu un seguiment de quina cama és més llarga i curta. Aleshores vam començar a soldar junts els cables. Primer soldem les resistències a la pota de l’ànode del LED (la pota més llarga).

Després, soldem les potes del càtode dels LEDs a un sol fil de coure que utilitzarem com a terra. Hauria de ser així.

Després de fer-ho, soldem els extrems mascle dels cables de pont femella-mascle als extrems finals de cada resistència i el fil de terra de coure. Un cop ho fem, podem començar a connectar els cables als pins GPIO gerds PI. Aquí teniu un diagrama! Tanmateix, tingueu en compte que els pins són els que apareixen al codi que heu tocat anteriorment.

Un cop tingueu tot això connectat, ara tot el que heu de fer és obtenir el fitxer Python al raspberry Pi i obrir el terminal. executeu "python3 RaspberryPIWeatherStation.py" i feu el que es mostra.

Pas 8: demostració i conclusió

Gràcies per llegir-ho completament. A continuació adjuntaré l’escriptura python. Si hi hagués coses que podríem afegir, probablement seria …

1. Suport per a diferents tipus d’entrada (ciutats, punts geogràfics, etc.)

2. Suport per obtenir més informació meteorològica

3. Afegiu una petita pantalla per mostrar informació

Feu-nos saber els vostres pensaments. Aquest va ser un divertit projecte per construir. Vam aprendre molt sobre les sol·licituds i l’obtenció de documents d’Internet mitjançant Python, i també vam aprendre molt sobre l’ús de la soldadura.