Estación meteorológica Raspberry PI LED: 8 pasos

2024 Autor: John Day | [email protected]. Última modificación: 2024-01-30 08:41

Creamos una estación LED meteorológica Raspberry PI. Indica al usuario el calor y el frío de una ciudad encendiendo y atenuando los leds. También tiene un indicador para indicarles si está lloviendo o no en la ciudad en la que escribieron.

Creado por Michael Andrews y Tio Marello.

Suministros

Instrumentos

1. Soldador
2. Dremel
3. Vio

Materiales

1. Raspberry Pi 3 B + ~ 40 dólares ~ 30 dólares
2. Cables de puente hembra a macho ~ 7 dólares
3. 3 diodos LED azules y 2 rojos ~ 11 dólares
4. Resistencias de 100 ohmios ~ 13 dólares
5. Tablón de madera de 4 x 4 x 1/4 ~ 5 dólares
6. Soldar ~ 10 dólares
7. Alambre de cobre ~ 5 dólares

Paso 1: Codificar como resolución de problemas

Codificar es resolver problemas

Entonces, en nuestro proyecto, ¿cuál es nuestro problema? Nuestro problema es obtener datos meteorológicos y luego usarlos para decirle a nuestros LEDS si están apagados o encendidos. Así que esto divide nuestro problema en tres áreas.

1. Obtención de datos meteorológicos

2. Usando esos datos

3. Uso de LED

Sin embargo, el lenguaje que usamos para este proyecto, Python, y el hardware en el que se ejecuta, Python, nos brindan una manera fácil de lograr estos objetivos.

Entonces, comencemos con el primer problema, obtener datos meteorológicos.

Paso 2: Codificación: obtención de datos meteorológicos

Python por sí solo no puede obtener datos meteorológicos. Tenemos que importar dos herramientas, además de un servicio externo, para obtener datos meteorológicos. Para hacer esto, usamos tres herramientas.

1. Solicitudes, un módulo de Python que permite el rastreo web

2. Json, un módulo de Python que nos permite usar el formato de archivo JSON

3. OpenWeather, un sitio web que puede brindarnos datos meteorológicos

Entonces, traemos los dos módulos escribiendo este código en la parte superior de nuestro script de Python.

solicitudes de importación

importar json

Sin embargo, antes de usar estas herramientas, debemos usar Openweather. Para eso, tenemos que crear una cuenta en su sitio y obtener una clave API. Siga las instrucciones en su sitio web y obtendrá una serie de letras y números que nos permitirán utilizar su servicio. ¿Cómo?

openweather_api_key = "260a23f27f5324ef2ae763c779c32d7e" #Nuestra clave API (no real)

base_call = "https://api.openweathermap.org/data/2.5/weather?q=" #OpenWeather Call #Aquí obtenemos la ciudad del usuario en forma de texto impreso ("¡Escriba una ciudad!") city_name = input () #Aquí reunimos la dirección que conectaremos a las solicitudes.get para recibir los datos meteorológicos full_call = base_call + city_name + "& appid =" + openweather_api_key #Finalmente llamamos a las solicitudes.get con nuestra dirección, luego lo convertimos en un archivo json Response = request.get (full_call) WeatherData = Response.json () Los archivos #JSON contienen diferentes variables a las que podemos acceder usando esta sintaxis #Aquí obtenemos el ID del clima y la temperatura en Kelvin de la ciudad que el usuario ingresó WeatherID = WeatherData ["weather"] [0] ["id"] City_TemperatureK = WeatherData ["main"] ["temp"]

Aquí tenemos el código que nos proporciona nuestros datos meteorológicos. Requests, en forma de request.get, toma la dirección de un sitio web y nos devuelve un archivo de ese sitio web. OpenWeather nos da una dirección a la que llamar para darnos datos meteorológicos en forma de json. Reunimos una dirección que conectamos a las solicitudes y recuperamos un archivo json. Luego creamos dos variables y las asignamos a la temperatura y climaid de la ciudad del usuario.

Entonces ahora, con este código, tenemos dos variables. Tenemos un weatherID y una temperatura en Kelvin

Paso 3: Codificación: uso de esos datos

Ahora que tenemos estas dos variables, tenemos que prepararlas para usarlas en nuestros LEDS. Para este aspecto, no tenemos que importar ningún módulo para esto.

Primero, convertimos el kelvin a Fahrenheit.

Hacemos esto creando una variable con esta sintaxis

City_TemperatureF = (City_TemperatureK - 273) * 1.8 + 32

que convierte de Kelvin a Fahrenheit (que en realidad se convierte de K -> C -> F)

El siguiente es nuestro weatherID. El weatherID es un ID que proporciona Openweather y que nos informa sobre las condiciones meteorológicas de una ciudad.

openweathermap.org/weather-conditions Aquí hay una lista de ellos.

Nos dimos cuenta de que todo lo que estaba por debajo del número 700 era una especie de precipitación, por lo que simplemente verificamos si el código estaba por debajo de 700 para ver si estaba lloviendo.

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

Con eso, tenemos nuestras dos variables preparadas para usar con nuestros pines Raspberry PI y diodos LED.

Paso 4: Codificación: uso de diodos LED y RPi. GPIO

El RaspberryPi viene con un juego de pines macho que podemos usar para comunicarnos con una gran cantidad de componentes eléctricos, que en este caso, son diodos LED; es similar a Arduino y su sistema. Sin embargo, Raspberry PI es una computadora de propósito general, a diferencia de un microcontrolador como el Arduino. Entonces, tenemos que trabajar un poco más para usarlos. Consiste en configurar los pines de la Raspberry Pi. Hacemos esto usando este código.

importar RPi. GPIO como GPIO # Importamos el módulo para poder usarlo

# Configure los pinsGPIO.setmode (GPIO. BCM) GPIO.setwarnings (Falso)

# Los pines a los que están conectados los LED. Estos pueden ser diferentes si los construye, así que asegúrese de compararlos y cambiarlos cuando sea necesario

Extreme_Hot_LED_PIN = 26 Hot_LED_PIN = 16

Extreme_Cold_LED_PIN = 5

Cold_LED_PIN = 6

Rain_LED_PIN = 23

# Pasamos por cada pin, usando el comando.setup, ingresando su número y configurándolo como un pin de salida

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.configuración (Extreme_Hot_LED. OUT), GPIO.setup (Extreme_Hot_LED. OUT)

Sin embargo, este código solo nos permitiría utilizar dos estados con el led, es decir, encendido y apagado. Sin embargo, lo necesitamos para poder atenuar las luces. Para hacer esto, usamos la modulación por ancho de pulso.

Uso de la modulación de ancho de pulso

La modulación de ancho de pulso nos permite emitir una señal analógica mediante un pin digital. Esencialmente, enciende y apaga la fuente de señal a una velocidad alta, que promedia un cierto voltaje. El RPi. GPIO nos permite usar esto, aunque con algún código extra.

# Creamos objetos de cuatro pines usando el comando GPIO. PWM, que toma un número de canal

# El segundo número es la cantidad de veces que se actualiza por segundo

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)

Para el siguiente paso, deberá conocer la forma en que actualizamos estos pines.

Actualizamos los pines usando el comando

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

ExtremeHotLED.start (x)

HotLED.start (x)

x en este caso sería el ciclo de trabajo, que determina cuánto se apaga. Va de 0 a 100, por lo que tenemos que basar nuestro siguiente código en ese hecho.

Paso 5: Codificación: obtención de brillo LED

Como tenemos cuatro leds diferentes, queremos encenderlos en función de cómo. hace frío o calor en la ciudad del usuario. Decidimos tener cuatro etapas para el led.

#Funciones

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

def getmiddlerightledintensity (TemperatureinF):

# Ecuación izquierda: y = - (50/20) x + 175 # Ecuación derecha: y = (50/20) x - 75 return (50/20) * TemperatureinF - 75

def getextremeleftledintensity (TemperatureinF):

# Ecuación izquierda: y = - (100/30) x + 200 # Ecuación derecha: y = (100/30) x - (400/3)

retorno - (100/30) * TemperatureinF + 200

def getextremerightledintensity (TemperatureinF):

# Ecuación izquierda: y = - (100/30) x + 200 # Ecuación derecha: y = (100/30) x - (400/3)

retorno (100/30) * TemperatureinF - (400/3)

# Configuración de las luces LED

def GetLEDBrightness (temp):

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

print ("LED de frío extremo:" + str (frío extremo))

print ("Led frío:" + str (coldled)) print ("Led extremadamente caliente" + str (extremehotled)) print ("Led caliente:" + str (hotled))

ExtremeColdLED.start (extremecoldled)

ColdLED.start (enfriado)

ExtremeHotLED.start (extremehotled)

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

print ("LED de frío extremo:" + str (frío extremo))

print ("Led frío:" + str (coldled)) print ("Led extremadamente caliente" + str (extremehotled)) print ("Led caliente:" + str (hotled))

ExtremeColdLED.start (extremecoldled)

ColdLED.start (enfriado)

ExtremeHotLED.start (extremehotled)

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

print ("LED de frío extremo:" + str (frío extremo))

print ("Led frío:" + str (coldled)) print ("Led extremadamente caliente" + str (extremehotled)) print ("Led caliente:" + str (hotled))

ExtremeColdLED.start (extremecoldled)

ColdLED.start (enfriado)

ExtremeHotLED.start (extremehotled)

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

print ("LED de frío extremo:" + str (frío extremo))

print ("Led frío:" + str (coldled)) print ("Led extremadamente caliente" + str (extremehotled)) print ("Led caliente:" + str (hotled))

ExtremeColdLED.start (extremecoldled)

ColdLED.start (enfriado)

ExtremeHotLED.start (extremehotled)

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

print ("LED de frío extremo:" + str (frío extremo))

print ("Led frío:" + str (coldled)) print ("Led extremadamente caliente" + str (extremehotled)) print ("Led caliente:" + str (hotled))

ExtremeColdLED.start (extremecoldled)

ColdLED.start (enfriado)

ExtremeHotLED.start (extremehotled)

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

enfriado = 100 - caliente

frío extremo = 0

print ("LED de frío extremo:" + str (frío extremo))

print ("Led frío:" + str (coldled)) print ("Led extremadamente caliente" + str (extremehotled)) print ("Led caliente:" + str (hotled))

ExtremeColdLED.start (extremecoldled)

ColdLED.start (enfriado)

ExtremeHotLED.start (extremehotled)

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

print ("LED de frío extremo:" + str (frío extremo))

print ("Led frío:" + str (coldled)) print ("Led extremadamente caliente" + str (extremehotled)) print ("Led caliente:" + str (hotled))

ExtremeColdLED.start (extremecoldled)

ColdLED.start (enfriado)

ExtremeHotLED.start (extremehotled)

HotLED.start (hotled)

Muy bien, esta sección de código es muy larga. También es bastante difícil de explicar. Esencialmente, el código de arriba mira la temperatura en Fahrenheit y determina si está en un conjunto de rangos. Dependiendo de los rangos, da un número para cada led y su brillo y luego establece el brillo llamando al comando start (). Esa es la explicación rápida. Si es suficiente, te recomiendo que pases al siguiente paso, pero si quieres ver la explicación larga y tediosa, sigue leyendo.

Cuando programamos, decidimos que la forma más fácil de obtener un valor de una temperatura era en forma de función matemática. Entonces, creamos un gráfico en GeoGebra para representar cuál es la relación entre nuestra temperatura y el brillo de nuestro led; la razón por la que supera los 100 es que el extra iría al segundo led. Sin embargo, nos encontramos con el problema de obtener una sola función para asignar todos estos puntos a una sola función. Pensamos que podríamos usar una parábola, pero decidimos conformarnos con usar una serie de declaraciones if. En esencia, todo este código es una función por partes.

Las funciones en la parte superior son las respectivas ecuaciones de líneas. Una vez que determinamos dónde está la temperatura en el gráfico, la ejecutamos a través de esa función, obtenemos el brillo y lo pasamos a los leds.

Paso 6: Codificación: Pasos finales

Finalmente, agregamos esta declaración al final.

tratar:

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

Las declaraciones try y except nos permiten salir del código usando un atajo de teclado; en cualquier caso, tendríamos que apagar la Raspberry Pi para reiniciar el código. Luego tenemos un ciclo while que se ejecuta para siempre. Actualizamos los leds, así como actualizamos el LED de lluvia. Hacemos una pausa de diez segundos; OpenWeather permite solo 60 llamadas de datos por minuto, y 10 segundos son muchas actualizaciones.

Y con eso, nuestro código está terminado. A continuación se muestra el código terminado.

RaspberryPIWeatherStation.py

importrequests

importRPi. GPIOasGPIO

importjson

importtime

#Openweather idCodes inferiores a 700 son todos precipitaciones

defCheckRain (IdCode):

ifIdCode <700:

returnTrue

demás:

falso retorno

defgetmiddleleftledintensity (TemperatureinF):

# Ecuación izquierda: y = - (50/20) x + 175

# Ecuación de la derecha: y = (50/20) x - 75

retorno- (50/20) * TemperatureinF + 175

defgetmiddlerightledintensity (TemperatureinF):

# Ecuación izquierda: y = - (50/20) x + 175

# Ecuación de la derecha: y = (50/20) x - 75

retorno (50/20) * TemperatureinF-75

defgetextremeleftledintensity (TemperatureinF):

# EcuaciónIzquierda: y = - (100/30) x + 200

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

retorno- (100/30) * TemperatureinF + 200

defgetextremerightledintensity (TemperatureinF):

# Ecuación izquierda: y = - (100/30) x + 200

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

retorno (100/30) * TemperatureinF- (400/3)

# Configuración de GPIO

GPIO.setmode (GPIO. BCM)

GPIO.setwarnings (falso)

#Patas

Extreme_Hot_LED_PIN = 26

Hot_LED_PIN = 16

Extreme_Cold_LED_PIN = 5

Cold_LED_PIN = 6

Rain_LED_PIN = 23

# Configuración de PIN

Configuración de GPIO (Rain_LED_PIN, GPIO. OUT)

Configuración de GPIO (Extreme_Cold_LED_PIN, GPIO. OUT)

Configuración de GPIO (Cold_LED_PIN, GPIO. OUT)

Configuración de GPIO (Hot_LED_PIN, GPIO. OUT)

Configuración de GPIO (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:

frío extremo = 100

enfriado = 100

hotled = 0

extremehotled = 0

print ("LED de frío extremo:" + str (frío extremo))

print ("Led frío:" + str (frío))

print ("LED extremadamente caliente" + str (extremehotled))

print ("Led caliente:" + str (led caliente))

ExtremeColdLED.start (extremecoldled)

ColdLED.start (enfriado)

ExtremeHotLED.start (extremehotled)

HotLED.start (hotled)

eliftemp> = 100:

frío extremo = 0

enfriado = 0

hotled = 100

extremehotled = 100

print ("LED de frío extremo:" + str (frío extremo))

print ("Led frío:" + str (frío))

print ("LED extremadamente caliente" + str (extremehotled))

print ("Led caliente:" + str (led caliente))

ExtremeColdLED.start (extremecoldled)

ColdLED.start (enfriado)

ExtremeHotLED.start (extremehotled)

HotLED.start (hotled)

elif0 <temp <= 30:

extremecoldled = getextremeleftledintensity (temp) -100

enfriado = 100

hotled = 0

extremehotled = 0

print ("LED de frío extremo:" + str (frío extremo))

print ("Led frío:" + str (frío))

print ("LED extremadamente caliente" + str (extremehotled))

print ("Led caliente:" + str (led caliente))

ExtremeColdLED.start (extremecoldled)

ColdLED.start (enfriado)

ExtremeHotLED.start (extremehotled)

HotLED.start (hotled)

elif100> temp> = 70:

frío extremo = 0

enfriado = 0

hotled = 100

extremehotled = getextremerightledintensity (temp) -100

print ("LED de frío extremo:" + str (frío extremo))

print ("Led frío:" + str (frío))

print ("LED extremadamente caliente" + str (extremehotled))

print ("Led caliente:" + str (led caliente))

ExtremeColdLED.start (extremecoldled)

ColdLED.start (enfriado)

ExtremeHotLED.start (extremehotled)

HotLED.start (hotled)

elif30 <temp <50:

frío extremo = 0

coldled = getmiddleleftledintensity (temp)

hotled = 100-coldled

extremehotled = 0

print ("LED de frío extremo:" + str (frío extremo))

print ("Led frío:" + str (frío))

print ("LED extremadamente caliente" + str (extremehotled))

print ("Led caliente:" + str (led caliente))

ExtremeColdLED.start (extremecoldled)

ColdLED.start (enfriado)

ExtremeHotLED.start (extremehotled)

HotLED.start (hotled)

elif50 <temp <70:

hotled = getmiddlerightledintensity (temp)

extremehotled = 0

coldled = 100-hotled

frío extremo = 0

print ("LED de frío extremo:" + str (frío extremo))

print ("Led frío:" + str (frío))

print ("LED extremadamente caliente" + str (extremehotled))

print ("Led caliente:" + str (led caliente))

ExtremeColdLED.start (extremecoldled)

ColdLED.start (enfriado)

ExtremeHotLED.start (extremehotled)

HotLED.start (hotled)

eliftemp == 50:

frío extremo = 0

enfriado = 50

hotled = 50

extremehotled = 0

print ("LED de frío extremo:" + str (frío extremo))

print ("Led frío:" + str (frío))

print ("LED extremadamente caliente" + str (extremehotled))

print ("Led caliente:" + str (led caliente))

ExtremeColdLED.start (extremecoldled)

ColdLED.start (enfriado)

ExtremeHotLED.start (extremehotled)

HotLED.start (hotled)

defGetRainLED (idCode):

ifCheckRain (idCode):

Salida GPIO (Rain_LED_PIN, GPIO. HIGH)

demás:

Salida GPIO (Rain_LED_PIN, GPIO. LOW)

#Información de API: Repalce la clave de API con su clave de API de oepnweather

openweather_api_key = "460a23f27ff324ef9ae743c7e9c32d7e"

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

print ("¡Escribe una ciudad!")

nombre_ciudad = input ()

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

# Obtención de datos meteorológicos

Respuesta = solicitudes.get (llamada_completa)

WeatherData = Response.json ()

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

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

City_TemperatureF = (City_TemperatureK-273) * 1.8 + 32 # Convertir a Fahrenheit

# Cosas LED / GPIO

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

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

imprimir (WeatherID)

tratar:

while (Verdadero):

GetLEDBrightness (City_TemperatureF)

GetRainLED (WeatherID)

hora de dormir (10)

exceptoKeyboardInterrupt:

dejar()

ver rawRaspberryPIWeatherStation.py alojado con ❤ por GitHub

Paso 7: construcción y cableado

¡Uf! Después de toda esa codificación, llegamos al edificio, que es significativamente más fácil. Debido a los pedidos de corona para quedarse en casa, no pudimos acceder a muchas de las herramientas que esperábamos tener en la escuela. Entonces, esta parte es un poco más simple de lo que pretendíamos. Los detalles en sí mismos también son flexibles. Primero dibujamos un rectángulo en una tabla de madera. El tamaño específico realmente no importa demasiado, ya que simplemente sirve como plataforma para colocar leds y electrónica.

Luego perforamos cinco agujeros de 1/8 en nuestra pieza de madera.

Luego cortamos el rectángulo de la tabla para usarlo como plataforma para nuestros dispositivos electrónicos.

(Aquí fue cuando comenzamos; ¡encontramos una sierra más grande!)

Luego empujamos los pines de ánodo y cátodo del led en los orificios; los leds deben estar colocados en la parte superior, sus bombillas sobresaliendo; Mantenga un registro de qué pierna es más larga y más corta. Luego nos dispusimos a empezar a soldar cables. Primero soldamos las resistencias a la pata del ánodo del LED (la pata más larga).

Luego, soldamos las patas del cátodo de los LED a un solo cable de cobre que usaremos como tierra. Debe tener un aspecto como este.

Después de hacer eso, soldamos los extremos macho de los cables de puente hembra-macho a los extremos de cada resistencia y al cable de tierra de cobre. Una vez que hagamos eso, podemos comenzar a conectar los cables en los pines GPIO de PI de frambuesa. ¡Aquí hay un diagrama! Sin embargo, tenga en cuenta que los pines son los que se encuentran en el código mencionado anteriormente.

Una vez que tenga todo conectado, ahora todo lo que tiene que hacer es colocar el archivo Python en la Raspberry Pi y abrir la terminal. ejecute "python3 RaspberryPIWeatherStation.py" y luego haga lo que muestra.

Paso 8: demostración y conclusión

¡Gracias por leer hasta el final! ¡Adjuntaré el script de Python a continuación! Si hubiera cosas que pudiéramos agregar, probablemente sería …

1. Soporte para diferentes tipos de entrada (ciudades, puntos geográficos, etc.)

2. Soporte para obtener más información meteorológica

3. Agrega una pequeña pantalla para mostrar información.

Háganos saber sus pensamientos! Este fue un proyecto divertido de construir. Aprendimos mucho sobre las solicitudes y la obtención de documentos de Internet usando Python, y también aprendimos mucho sobre el uso de la soldadura.