Estação meteorológica Raspberry PI LED: 8 etapas

2024 Autor: John Day | [email protected]. Última modificação: 2024-01-30 11:35

Criamos uma estação de LED climático Raspberry PI. Ele informa ao usuário o quão quente e fria uma cidade está acendendo e escurecendo os leds. Também tem um led para informar se está chovendo ou não na cidade em que eles digitaram.

Criado por Michael Andrews e Tio Marello.

Suprimentos

Ferramentas

1. Ferro de solda
2. Dremel
3. Serra

Materiais

1. Raspberry Pi 3 B + ~ 40 dólares ~ 30 dólares
2. Fios de ligação fêmea para macho ~ 7 dólares
3. 3 diodos LED azuis e 2 vermelhos de ~ 11 dólares
4. Resistores de 100 Ohm ~ 13 dólares
5. 4 x 4 x 1/4 Tábua de madeira ~ 5 dólares
6. Solda ~ 10 dólares
7. Fio de cobre ~ 5 dólares

Etapa 1: codificação como solução de problemas

Codificar é a solução de problemas

Então, em nosso projeto, qual é o nosso problema? Nosso problema é obter dados meteorológicos e, em seguida, usar esses dados para dizer aos nossos LEDS se eles estão desligados ou ligados. Portanto, isso divide nosso problema em três áreas.

1. Obtendo dados meteorológicos

2. Usando esses dados

3. Usando LEDS

No entanto, a linguagem que usamos para este projeto, Python, e o hardware em que está sendo executado, Python, nos fornecem uma maneira fácil de atingir esses objetivos.

Então, vamos começar com o primeiro problema, obter dados meteorológicos.

Etapa 2: Codificação: Obtendo dados meteorológicos

O Python sozinho não consegue obter dados meteorológicos. Temos que importar duas ferramentas, além de um serviço externo, para obter dados meteorológicos. Para fazer isso, usamos três ferramentas.

1. Requests, um módulo python que permite webscraping

2. Json, um módulo python que nos permite usar o formato de arquivo JSON

3. OpenWeather, um site que pode nos fornecer dados meteorológicos

Então, trazemos os dois módulos escrevendo este código no topo do nosso script Python.

pedidos de importação

import json

Antes de usarmos essas ferramentas, no entanto, precisamos usar o Openweather. Para isso, temos que criar uma conta em seu site e obter uma chave API. Siga as instruções em seu site e você receberá uma sequência de letras e números que nos permitirá usar seu serviço. Como?

openweather_api_key = "260a23f27f5324ef2ae763c779c32d7e" #Nossa chave API (não real)

base_call = "https://api.openweathermap.org/data/2.5/weather?q=" #OpenWeather Call #Aqui temos a cidade do usuário na forma de texto print ("Digite uma cidade!") city_name = input () #Aqui montamos o endereço que conectaremos em requests.get para receber dados meteorológicos full_call = base_call + city_name + "& appid =" + openweather_api_key #Finalmente chamamos requests.get com nosso endereço, então o convertemos em um arquivo json Response = requests.get (full_call) WeatherData = Response.json () # Arquivos JSON contêm diferentes variáveis que podemos acessar usando esta sintaxe #Aqui obtemos o ID do tempo e a temperatura em Kelvin da cidade que o usuário digitou em WeatherID = WeatherData ["clima"] [0] ["id"] City_TemperatureK = WeatherData ["main"] ["temp"]

Aqui temos o código que nos fornece nossos dados meteorológicos. Requests, na forma de requests.get, leva o endereço de um site e nos dá um arquivo desse site de volta. OpenWeather nos dá um endereço para ligar para nos fornecer dados meteorológicos na forma de um json. Montamos um endereço que inserimos nas solicitações e obtemos um arquivo json de volta. Em seguida, criamos duas variáveis e as atribuímos à temperatura e ID do tempo da cidade do usuário.

Portanto, agora, com este código, temos duas variáveis. Temos um ID do tempo e uma temperatura em Kelvin

Etapa 3: Codificação: usando esses dados

Agora que temos essas duas variáveis, temos que prepará-las para uso em nossos LEDS. Para este aspecto, não temos que importar nenhum módulo para isso.

Primeiro, convertemos o Kelvin em Fahrenheit.

Fazemos isso criando uma variável com esta sintaxe

City_TemperatureF = (City_TemperatureK - 273) * 1.8 + 32

que converte de Kelvin para Fahrenheit (que na verdade está convertendo de K -> C -> F)

O próximo é o nosso weatherID. O weatherID é um ID fornecido pela Openweather que nos informa sobre as condições meteorológicas de uma cidade.

openweathermap.org/weather-conditions Aqui está uma lista deles.

Percebemos que tudo abaixo de 700 era algum tipo de precipitação, então apenas verificamos se o código estava abaixo de 700 para ver se estava chovendo.

def CheckRain (IdCode): se IdCode <700: retorna True else: retorna False

Com isso, temos nossas duas variáveis preparadas para uso com nossos pinos Raspberry PI e diodos de LED.

Etapa 4: Codificação: usando RPi. GPIO e diodos de LED

O RaspberryPi vem com um conjunto de pinos machos que podemos usar para nos comunicarmos com uma série de componentes elétricos, que neste caso são diodos de LED; é semelhante ao Arduino e seu sistema. No entanto, o Raspberry PI é um computador de uso geral, ao contrário de um microcontrolador como o Arduino. Portanto, temos que trabalhar um pouco mais para usá-los. Isso consiste em configurar os pinos no Raspberry Pi. Fazemos isso usando este código.

importar RPi. GPIO como GPIO # Importamos o módulo para que possamos usá-lo

# Configure os pinsGPIO.setmode (GPIO. BCM) GPIO.setwarnings (False)

#Os pinos aos quais os LEDs estão conectados. Eles podem ser diferentes se você construí-lo, então certifique-se de comparar e alterar quando necessário

Extreme_Hot_LED_PIN = 26 Hot_LED_PIN = 16

Extreme_Cold_LED_PIN = 5

Cold_LED_PIN = 6

Rain_LED_PIN = 23

# Examinamos cada pino, usando o comando.setup, inserindo seu número e definindo-o como um pino de saída

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)

No entanto, esse código só nos permitiria usar dois estados com o led, ou seja, ligado e desligado. No entanto, precisamos dele para poder diminuir as luzes. Para fazer isso, usamos a modulação por largura de pulso.

Usando a modulação por largura de pulso

A modulação por largura de pulso nos permite gerar um sinal analógico usando um pino digital. Essencialmente, ele liga e desliga a fonte do sinal em uma taxa alta, que atinge a média de certa voltagem. O RPi. GPIO nos permite usar isso, embora com algum código extra.

# Nós criamos objetos de quatro pinos usando o comando GPIO. PWM, que leva em um número de canal

#O segundo número é o número de vezes que ele atualiza 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 a próxima etapa, você precisará saber como atualizamos esses pinos.

Nós atualizamos os pinos usando o comando

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

ExtremeHotLED.start (x)

HotLED.start (x)

x neste caso seria o ciclo de trabalho, que determina o quanto ele pulsa. Ele varia de 0 a 100, então temos que basear nosso próximo código nesse fato.

Etapa 5: Codificação: Obtendo o brilho do LED

Como temos quatro leds diferentes, queremos acendê-los dependendo de como. frio ou quente é na cidade do usuário. Decidimos ter quatro estágios para o liderado.

#Funções

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

# Equação esquerda: y = - (50/20) x + 175 # Equação direita: y = (50/20) x - 75 retorno (50/20) * Temperatura em F - 75

def getextremeleftledintensity (TemperatureinF):

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

retorno - (100/30) * Temperatura em F + 200

def getextremerightledintensity (TemperatureinF):

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

retorno (100/30) * Temperatura em F - (400/3)

# Ajustando as luzes LED

def GetLEDBrightness (temp):

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

print ("Led frio extremo:" + str (extremamente frio))

print ("Led frio:" + str (coldled)) print ("led Extreme quente" + str (extremehotled)) print ("led quente:" + str (hotled))

ExtremeColdLED.start (extremecoldled)

ColdLED.start (coldled)

ExtremeHotLED.start (extremehotled)

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

print ("Led frio extremo:" + str (extremamente frio))

print ("Led frio:" + str (coldled)) print ("led Extreme quente" + str (extremehotled)) print ("led quente:" + str (hotled))

ExtremeColdLED.start (extremecoldled)

ColdLED.start (coldled)

ExtremeHotLED.start (extremehotled)

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

print ("Led frio extremo:" + str (extremamente frio))

print ("Led frio:" + str (coldled)) print ("led Extreme quente" + str (extremehotled)) print ("led quente:" + str (hotled))

ExtremeColdLED.start (extremecoldled)

ColdLED.start (coldled)

ExtremeHotLED.start (extremehotled)

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

print ("Led frio extremo:" + str (extremamente frio))

print ("Led frio:" + str (coldled)) print ("led Extreme quente" + str (extremehotled)) print ("led quente:" + str (hotled))

ExtremeColdLED.start (extremecoldled)

ColdLED.start (coldled)

ExtremeHotLED.start (extremehotled)

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

print ("Led frio extremo:" + str (extremamente frio))

print ("Led frio:" + str (coldled)) print ("led Extreme quente" + str (extremehotled)) print ("led quente:" + str (hotled))

ExtremeColdLED.start (extremecoldled)

ColdLED.start (coldled)

ExtremeHotLED.start (extremehotled)

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

coldled = 100 - hotled

extremecoldled = 0

print ("Led frio extremo:" + str (extremamente frio))

print ("Led frio:" + str (coldled)) print ("led Extreme quente" + str (extremehotled)) print ("led quente:" + str (hotled))

ExtremeColdLED.start (extremecoldled)

ColdLED.start (coldled)

ExtremeHotLED.start (extremehotled)

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

print ("Led frio extremo:" + str (extremamente frio))

print ("Led frio:" + str (coldled)) print ("led Extreme quente" + str (extremehotled)) print ("led quente:" + str (hotled))

ExtremeColdLED.start (extremecoldled)

ColdLED.start (coldled)

ExtremeHotLED.start (extremehotled)

HotLED.start (hotled)

Tudo bem, esta seção de código é muito longa. Também é muito difícil de explicar. Essencialmente, o código acima examina a temperatura em Fahrenheit e determina se ela está em um conjunto de intervalos. Dependendo das faixas, ele fornece um número para cada led e seu brilho e, em seguida, define o brilho chamando o comando start (). Essa é a explicação rápida. Se for suficiente, recomendo que você passe para a próxima etapa, mas se quiser ver a explicação longa e tediosa, continue lendo.

Quando programamos, decidimos que a maneira mais fácil de obter um valor de uma temperatura era na forma de uma função matemática. Então, criamos um gráfico no GeoGebra para representar qual a relação entre nossa temperatura e nosso brilho do led; a razão de ultrapassar 100 é que o extra iria para o segundo led. No entanto, encontramos o problema de obter uma única função para mapear todos esses pontos para uma única função. Achamos que poderíamos usar uma parábola, mas decidimos apenas usar uma série de declarações if. Em essência, todo esse código é uma função por partes.

As funções no topo são as respectivas equações de linhas. Depois de determinar onde está a temperatura no gráfico, passamos por essa função, obtemos o brilho e o passamos para os leds.

Etapa 6: Codificação: etapas finais

Finalmente, adicionamos esta declaração no final.

Experimente:

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

As instruções try e except nos permitem sair do código usando um atalho de teclado; de qualquer forma, teríamos que desligar o Raspberry Pi para reiniciar o código. Então temos um loop while que funciona para sempre. Nós atualizamos os leds, bem como atualizamos o LED de chuva. Fazemos uma pausa de dez segundos; O OpenWeather permite apenas 60 chamadas de dados por minuto e 10 segundos são muitas atualizações.

E com isso, nosso código está concluído. Abaixo está o código finalizado.

RaspberryPIWeatherStation.py

importrequests

importRPi. GPIOasGPIO

importjson

importtime

#Openweather idCodes menores que 700 são todos precipitação

defCheckRain (IdCode):

ifIdCode <700:

returnTrue

outro:

retorna falso

defgetmiddleleftledintensity (TemperatureinF):

# Equação da esquerda: y = - (50/20) x + 175

# Equação direita: y = (50/20) x - 75

retorno- (50/20) * Temperatura em F + 175

defgetmiddlerightledintensity (TemperatureinF):

# Equação da esquerda: y = - (50/20) x + 175

# Equação direita: y = (50/20) x - 75

retorno (50/20) * Temperatura em F-75

defgetextremeleftledintensity (TemperatureinF):

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

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

return- (100/30) * Temperatura em F + 200

defgetextremerightledintensity (TemperatureinF):

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

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

retorno (100/30) * Temperatura em F- (400/3)

#GPIO Setup

GPIO.setmode (GPIO. BCM)

GPIO.setwarnings (False)

#Pins

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:

extremecoldled = 100

coldled = 100

hotled = 0

extremhotled = 0

print ("Led frio extremo:" + str (extremamente frio))

imprimir ("Led frio:" + str (coldled))

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

imprimir ("LED quente:" + str (quente))

ExtremeColdLED.start (extremecoldled)

ColdLED.start (coldled)

ExtremeHotLED.start (extremehotled)

HotLED.start (hotled)

eliftemp> = 100:

extremecoldled = 0

coldled = 0

hotled = 100

extremehotled = 100

print ("Led frio extremo:" + str (extremamente frio))

imprimir ("Led frio:" + str (coldled))

imprimir ("Led extremamente quente" + str (Extremehotled))

imprimir ("LED quente:" + str (quente))

ExtremeColdLED.start (extremecoldled)

ColdLED.start (coldled)

ExtremeHotLED.start (extremehotled)

HotLED.start (hotled)

elif0 <temp <= 30:

extremecoldled = getextremeleftledintensity (temp) -100

coldled = 100

hotled = 0

extremhotled = 0

print ("Led frio extremo:" + str (extremamente frio))

imprimir ("Led frio:" + str (coldled))

imprimir ("Led extremamente quente" + str (Extremehotled))

imprimir ("LED quente:" + str (quente))

ExtremeColdLED.start (extremecoldled)

ColdLED.start (coldled)

ExtremeHotLED.start (extremehotled)

HotLED.start (hotled)

elif100> temp> = 70:

extremecoldled = 0

coldled = 0

hotled = 100

extremehotled = getextremerightledintensity (temp) -100

print ("Led frio extremo:" + str (extremamente frio))

imprimir ("Led frio:" + str (coldled))

imprimir ("Led extremamente quente" + str (Extremehotled))

imprimir ("LED quente:" + str (quente))

ExtremeColdLED.start (extremecoldled)

ColdLED.start (coldled)

ExtremeHotLED.start (extremehotled)

HotLED.start (hotled)

elif30 <temp <50:

extremecoldled = 0

coldled = getmiddleleftledintensity (temp)

hotled = 100-coldled

extremhotled = 0

print ("Led frio extremo:" + str (extremamente frio))

imprimir ("Led frio:" + str (coldled))

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

imprimir ("LED quente:" + str (quente))

ExtremeColdLED.start (extremecoldled)

ColdLED.start (coldled)

ExtremeHotLED.start (extremehotled)

HotLED.start (hotled)

elif50 <temp <70:

hotled = getmiddlerightledintensity (temp)

extremhotled = 0

coldled = 100-hotled

extremecoldled = 0

print ("Led frio extremo:" + str (extremamente frio))

imprimir ("Led frio:" + str (coldled))

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

imprimir ("LED quente:" + str (quente))

ExtremeColdLED.start (extremecoldled)

ColdLED.start (coldled)

ExtremeHotLED.start (extremehotled)

HotLED.start (hotled)

eliftemp == 50:

extremecoldled = 0

coldled = 50

hotled = 50

extremhotled = 0

print ("Led frio extremo:" + str (extremamente frio))

imprimir ("Led frio:" + str (coldled))

imprimir ("Led extremamente quente" + str (Extremehotled))

imprimir ("LED quente:" + str (quente))

ExtremeColdLED.start (extremecoldled)

ColdLED.start (coldled)

ExtremeHotLED.start (extremehotled)

HotLED.start (hotled)

defGetRainLED (idCode):

ifCheckRain (idCode):

GPIO.output (Rain_LED_PIN, GPIO. HIGH)

outro:

GPIO.output (Rain_LED_PIN, GPIO. LOW)

#Api information: Repalce a chave de API com sua chave de API oepnweather

openweather_api_key = "460a23f27ff324ef9ae743c7e9c32d7e"

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

imprimir ("Digite uma cidade!")

city_name = input ()

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

#Getting Weather Data

Resposta = solicitações.get (full_call)

WeatherData = Response.json ()

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

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

City_TemperatureF = (City_TemperatureK-273) * 1.8 + 32 # Converter para Fahrenheit

# LED / GPIO Stuff

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

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

imprimir (WeatherID)

Experimente:

enquanto (verdadeiro):

GetLEDBrightness (City_TemperatureF)

GetRainLED (WeatherID)

tempo.sono (10)

exceptKeyboardInterrupt:

Sair()

veja rawRaspberryPIWeatherStation.py hospedado com ❤ por GitHub

Etapa 7: construção e fiação

Uau! Depois de toda essa codificação, chegamos ao prédio, que é significativamente mais fácil. Devido aos pedidos corona para ficar em casa, não conseguimos muitas das ferramentas que esperávamos ter na escola. Portanto, esta parte é um pouco mais simples do que pretendíamos. Os próprios detalhes também são flexíveis. Primeiro, desenhamos um retângulo em uma prancha de madeira. O tamanho específico não importa muito, pois ele simplesmente serve como uma plataforma para colocar leds e eletrônicos.

Em seguida, perfuramos cinco buracos de 1/8 de polegada em nosso pedaço de madeira.

Em seguida, recortamos o retângulo da prancha para usar como nossa plataforma para nossos eletrônicos.

(Foi quando começamos; encontramos uma serra maior!)

Em seguida, empurramos os pinos do ânodo e do cátodo do led nos orifícios; os leds devem estar colocados no topo, com as lâmpadas projetadas para fora; acompanhe qual perna é mais longa e mais curta. Em seguida, começamos a soldar os fios. Primeiro, soldamos os resistores na perna do ânodo do LED (a perna mais longa).

Em seguida, soldamos as pernas do cátodo dos LEDs a um único fio de cobre que usaremos como aterramento. Deve ser assim.

Depois de fazer isso, soldamos as extremidades macho dos cabos jumper fêmea-macho nas extremidades de cada resistor e do fio terra de cobre. Depois de fazer isso, podemos começar a conectar os fios nos pinos PI GPIO do framboesa. Aqui está um diagrama! No entanto, observe que os pinos são aqueles no código tocado anteriormente.

Depois de ter tudo conectado, agora tudo o que você precisa fazer é colocar o arquivo Python no raspberry Pi e abrir o terminal. execute "python3 RaspberryPIWeatherStation.py" e faça como mostrado.

Etapa 8: Demonstração e Conclusão

Obrigado por ler todo o caminho! Vou anexar o script Python abaixo! Se houvesse coisas que pudéssemos adicionar, provavelmente seria …

1. Suporte para diferentes tipos de entrada (cidades, pontos geográficos, etc.)

2. Suporte para mais informações meteorológicas

3. Adicione uma pequena tela para mostrar informações

Deixe-nos saber sua opinião! Este foi um projeto divertido de construir. Aprendemos muito sobre solicitações e obtenção de documentos da Internet usando python, e também aprendemos muito sobre como usar solda.