Station météo Raspberry PI LED : 8 étapes

2024 Auteur: John Day | [email protected]. Dernière modifié: 2024-01-30 09:06

Nous avons créé une station météo LED Raspberry PI. Il indique à l'utilisateur à quel point une ville est chaude et froide en allumant et en diminuant les LED. Il a également une led pour leur dire s'il pleut ou non dans la ville dans laquelle ils ont tapé.

Créé par Michael Andrews et Tio Marello.

Fournitures

Outils

1. Fer à souder
2. Dremel
3. Vu

Matériaux

1. Raspberry Pi 3 B+ ~40 Dollars ~ 30 Dollars
2. Fils de cavalier femelle à mâle ~ 7 dollars
3. 3 diodes LED bleues et 2 rouges ~ 11 dollars
4. Résistances 100 Ohm ~ 13 Dollars
5. 4 x 4 x 1/4 planche de bois ~ 5 dollars
6. Soudure ~ 10 dollars
7. Fil de cuivre ~ 5 dollars

Étape 1: coder en tant que résolution de problèmes

Le codage est la résolution de problèmes

Alors, dans notre projet, quel est notre problème ? Notre problème est d'obtenir des données météorologiques, puis d'utiliser ces données pour indiquer à nos LED si elles sont éteintes ou allumées. Cela divise donc notre problème en trois domaines.

1. Obtenir des données météorologiques

2. Utiliser ces données

3. Utilisation des LED

Cependant, le langage que nous avons utilisé pour ce projet, Python, et le matériel sur lequel il s'exécute, Python, nous permettent d'atteindre facilement ces objectifs.

Alors, commençons par le premier problème, obtenir des données météorologiques.

Étape 2: Codage: Obtenir des données météorologiques

Python par lui-même ne peut pas obtenir de données météorologiques. Nous devons importer deux outils, ainsi qu'un service externe, pour obtenir des données météorologiques. Pour ce faire, nous utilisons trois outils.

1. Requests, un module python qui permet le webscraping

2. Json, un module python qui nous permet d'utiliser le format de fichier JSON

3. OpenWeather, un site Web qui peut nous fournir des données météorologiques

Ainsi, nous apportons les deux modules en écrivant ce code en haut de notre script python.

demandes d'importation

importer json

Avant d'utiliser ces outils, cependant, nous devons utiliser Openweather. Pour cela, nous devons créer un compte sur leur site et obtenir une clé API. Suivez les instructions sur leur site Web et vous obtiendrez une chaîne de lettres et de chiffres qui nous permettront d'utiliser leur service. Comment?

openweather_api_key = "260a23f27f5324ef2ae763c779c32d7e" #Notre clé API (pas réelle)

base_call = "https://api.openweathermap.org/data/2.5/weather?q=" #OpenWeather Call #Ici, nous obtenons la ville de l'utilisateur sous forme de texte print("Tapez une ville!") city_name = input () #Ici, nous avons assemblé l'adresse que nous allons connecter à request.get pour recevoir les données météo full_call = base_call+city_name+"&appid="+openweather_api_key #Enfin nous appelons request.get avec notre adresse, puis nous la convertissons en un fichier json Response = request.get(full_call) WeatherData = Response.json() #Les fichiers JSON contiennent différentes variables auxquelles nous pouvons accéder en utilisant cette syntaxe #Ici, nous obtenons l'ID météo et la température en Kelvin de la ville que l'utilisateur a tapée WeatherID = WeatherData ["weather"][0]["id"] City_TemperatureK = WeatherData["main"]["temp"]

Ici, nous avons le code qui nous fournit nos données météorologiques. Requests, sous la forme de request.get, prend une adresse de site Web et nous renvoie un fichier de ce site Web. OpenWeather nous donne une adresse à appeler pour nous donner des données météo sous la forme d'un json. Nous assemblons une adresse que nous intégrons dans les requêtes et récupérons un fichier json. Ensuite, nous créons deux variables et les affectons à la température et à l'ID météo de la ville de l'utilisateur.

Alors maintenant, avec ce code, nous avons deux variables. Nous avons un WeatherID et une température en Kelvin

Étape 3: Codage: Utilisation de ces données

Maintenant que nous avons ces deux variables, nous devons les préparer pour nos LEDS. Pour cet aspect, nous n'avons pas à importer de modules pour cela.

Tout d'abord, nous convertissons le kelvin en Fahrenheit.

Nous le faisons en créant une variable avec cette syntaxe

City_TemperatureF = (City_TemperatureK - 273)*1.8 + 32

qui convertit de Kelvin en Fahrenheit (qui convertit vraiment de K -> C -> F)

Vient ensuite notre WeatherID. Le WeatherID est un identifiant fourni par Openweather qui nous renseigne sur les conditions météorologiques d'une ville.

openweathermap.org/weather-conditions Voici une liste d'entre eux.

Nous avons remarqué que tout ce qui était inférieur à 700 était une sorte de précipitation, nous avons donc vérifié si le code était inférieur à 700 pour voir s'il pleuvait.

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

Avec cela, nous avons nos deux variables préparées pour une utilisation avec nos broches Raspberry PI et nos diodes LED.

Étape 4: Codage: Utilisation de RPi. GPIO et des diodes LED

Le RaspberryPi est livré avec un ensemble de broches mâles que nous pouvons utiliser pour communiquer avec une multitude de composants électriques, qui dans ce cas, sont des diodes LED; cela s'apparente à Arduino et à son système. Cependant, le Raspberry PI est un ordinateur à usage général, par opposition à un microcontrôleur comme l'Arduino. Donc, nous devons faire un peu plus de travail pour les utiliser. Cela consiste à configurer les broches sur le Raspberry Pi. Nous le faisons en utilisant ce code.

importer RPi. GPIO en tant que GPIO #Nous importons le module pour pouvoir l'utiliser

#Configurer les brochesGPIO.setmode(GPIO. BCM) GPIO.setwarnings(False)

#Les broches sur lesquelles les LED sont branchées. Ceux-ci peuvent être différents si vous le construisez, alors assurez-vous de comparer et de changer si nécessaire

Extreme_Hot_LED_PIN = 26 Hot_LED_PIN = 16

Extrême_Froid_LED_PIN = 5

Cold_LED_PIN = 6

Pluie_LED_PIN = 23

#Nous parcourons chaque broche, en utilisant la commande.setup, en entrant son numéro et en la définissant comme broche de sortie

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)

Cependant, ce code ne nous permettrait d'utiliser que deux états avec la led, c'est-à-dire allumé et éteint. Cependant, nous en avons besoin pour pouvoir tamiser les lumières. Pour ce faire, nous utilisons la modulation de largeur d'impulsion.

Utilisation de la modulation de largeur d'impulsion

La modulation de largeur d'impulsion nous permet de produire un signal analogique à l'aide d'une broche numérique. Essentiellement, il allume et éteint la source de signal à un taux élevé, ce qui correspond à une certaine tension. Le RPi. GPIO nous permet de l'utiliser, mais avec du code supplémentaire.

#Nous créons des objets à quatre broches à l'aide de la commande GPIO. PWM, qui prend un numéro de canal

#Le deuxième nombre est le nombre de fois qu'il se met à jour par seconde

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)

Pour la prochaine étape, vous devrez connaître la façon dont nous mettons à jour ces broches.

Nous mettons à jour les broches à l'aide de la commande

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

ExtremeHotLED.start(x)

HotLED.start(x)

x dans ce cas serait le rapport cyclique, qui détermine combien il s'éteint. Il va de 0 à 100, nous devons donc baser notre prochain code sur ce fait.

Étape 5: Codage: Obtenir la luminosité des LED

Parce que nous avons quatre leds différentes, nous voulons les allumer en fonction de la façon dont. froid ou chaud c'est dans la ville de l'utilisateur. Nous avons décidé d'avoir quatre étapes pour le conduit.

#Les fonctions

def getmiddleleftledintensity(TemperatureinF): #Équation de gauche: y=-(50/20)x + 175 #Équation de droite: y = (50/20)x - 75 return -(50/20)*TemperatureinF + 175

def getmiddlerightledintensity(TemperatureinF):

#Équation de gauche: y=-(50/20)x + 175 #Équation de droite: y = (50/20)x - 75 retour (50/20)*TemperatureinF - 75

def getextremeleftledintensity(TemperatureinF):

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

retour -(100/30)*TempératureenF + 200

def getextremerightledintensity(TemperatureinF):

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

retour (100/30)*TempératureenF - (400/3)

#Réglage des lumières LED

def GetLEDBrightness(temp):

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

print("Led froid extrême:" + str(extrême froid))

print("LED froide:" + str(froid)) print("LED chaude extrême" + str(extremehotled)) print("LED chaude:" + str(hotled))

ExtremeColdLED.start (extrêmement froid)

ColdLED.start (froid)

ExtremeHotLED.start(extrêmement chaud)

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

print("Led froid extrême:" + str(extrême froid))

print("LED froide:" + str(froid)) print("LED chaude extrême" + str(extremehotled)) print("LED chaude:" + str(hotled))

ExtremeColdLED.start (extrêmement froid)

ColdLED.start (froid)

ExtremeHotLED.start(extrêmement chaud)

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

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

print( LED froide: » + str(froid)) print(« LED extrêmement chaude » + str(extremehotled)) print(« LED chaude: » + str(hotled))

ExtremeColdLED.start (extrêmement froid)

ColdLED.start (froid)

ExtremeHotLED.start(extrêmement chaud)

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

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

print("LED froide:" + str(froid)) print("LED chaude extrême" + str(extremehotled)) print("LED chaude:" + str(hotled))

ExtremeColdLED.start (extrêmement froid)

ColdLED.start (froid)

ExtremeHotLED.start(extrêmement chaud)

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

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

print( LED froide: » + str(froid)) print(« LED extrêmement chaude » + str(extremehotled)) print(« LED chaude: » + str(hotled))

ExtremeColdLED.start (extrêmement froid)

ColdLED.start (froid)

ExtremeHotLED.start(extrêmement chaud)

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

froid = 100 - chaud

extrêmement froid = 0

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

print("LED froide:" + str(froid)) print("LED chaude extrême" + str(extremehotled)) print("LED chaude:" + str(hotled))

ExtremeColdLED.start (extrêmement froid)

ColdLED.start (froid)

ExtremeHotLED.start(extrêmement chaud)

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

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

print("LED froide:" + str(froid)) print("LED chaude extrême" + str(extremehotled)) print("LED chaude:" + str(hotled))

ExtremeColdLED.start (extrêmement froid)

ColdLED.start (froid)

ExtremeHotLED.start(extrêmement chaud)

HotLED.start(hotled)

D'accord, cette section de code est vraiment longue. C'est aussi assez difficile à expliquer. Essentiellement, le code ci-dessus examine la température en degrés Fahrenheit et détermine si elle se situe dans un ensemble de plages. Selon les gammes, il donne un numéro pour chaque led et sa luminosité puis règle la luminosité en appelant la commande start(). C'est l'explication rapide. Si cela suffit, je vous recommande de passer à l'étape suivante, mais si vous voulez voir l'explication longue et fastidieuse, continuez à lire.

Lorsque nous avons programmé, nous avons décidé que le moyen le plus simple d'obtenir une valeur à partir d'une température était sous la forme d'une fonction mathématique. Nous avons donc créé un graphique dans GeoGebra pour représenter quelle est la relation entre notre température et la luminosité de notre led; la raison pour laquelle il dépasse 100 est que l'extra irait dans la deuxième led. Cependant, nous avons rencontré le problème d'obtenir une seule fonction pour mapper tous ces points à une seule fonction. Nous pensions pouvoir utiliser une parabole, mais nous avons décidé de nous contenter d'une série d'instructions if. En substance, tout ce code est une fonction par morceaux.

Les fonctions en haut sont l'équation respective des droites. Une fois que nous avons déterminé où se trouve la température sur le graphique, nous l'exécutons à travers cette fonction, obtenons la luminosité et la transmettons aux LED.

Étape 6: Codage: dernières étapes

Enfin, nous ajoutons cette déclaration à la fin.

essayer:

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

Les instructions try et except nous permettent de quitter le code en utilisant un raccourci clavier; dans tous les cas, nous devrons arrêter le Raspberry Pi pour redémarrer le code. Ensuite, nous avons une boucle while qui s'exécute indéfiniment. Nous mettons à jour les leds, ainsi que la led de pluie. Nous faisons une pause de dix secondes; OpenWeather n'autorise que 60 appels de données par minute, et 10 secondes représentent de nombreuses mises à jour.

Et avec ça, notre code est terminé. Ci-dessous le code terminé.

RaspberryPIWeatherStation.py

demandes d'importation

importRPi. GPIOasGPIO

importjson

heure d'importation

#Openweather Les idCodes inférieurs à 700 sont tous des précipitations

defCheckRain(IdCode):

ifIdCode<700:

returnTrue

autre:

returnFalse

defgetmiddleleftledintensity(TemperatureinF):

#Équation de gauche: y=-(50/20)x + 175

#Équation juste: y = (50/20)x - 75

retour-(50/20)*TempératureenF+175

defgetmilieudroitledintensity(TemperatureinF):

#Équation de gauche: y=-(50/20)x + 175

#Équation juste: y = (50/20)x - 75

retour (50/20)*TempératuredansF-75

defgetextremeleftledintensity(TemperatureinF):

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

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

retour-(100/30)*TempératureenF+200

defgetextremerightledintensity(TemperatureinF):

# Équation de gauche: y = -(100/30)x + 200

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

retour (100/30)*TempératureenF- (400/3)

#Configuration GPIO

GPIO.setmode(GPIO. BCM)

GPIO.setwarnings(False)

#Épingles

Extreme_Hot_LED_PIN=26

Hot_LED_PIN=16

Extrême_Froid_LED_PIN=5

Froid_LED_PIN=6

Pluie_LED_PIN=23

#Configuration des broches

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)

defGetLEDLuminosité(temp):

iftemp<=0:

extrêmefroid=100

froid=100

hotled=0

extremehotled=0

print("Led froid extrême:"+str(extrême froid))

print("LED froide:"+str(froid))

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

print("Led chaude:"+str(hotled))

ExtremeColdLED.start (extrêmement froid)

ColdLED.start (froid)

ExtremeHotLED.start(extrêmement chaud)

HotLED.start(hotled)

elifetemp>=100:

extrêmefroid=0

froid=0

hotled=100

extremehotled=100

print("Led froid extrême:"+str(extrême froid))

print("LED froide:"+str(froid))

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

print("Led chaude:"+str(hotled))

ExtremeColdLED.start (extrêmement froid)

ColdLED.start (froid)

ExtremeHotLED.start(extrêmement chaud)

HotLED.start(hotled)

elif0<temp<=30:

extremecoldled=getextremeleftledintensity(temp) -100

froid=100

hotled=0

extremehotled=0

print("Led froid extrême:"+str(extrême froid))

print("LED froide:"+str(froid))

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

print("Led chaude:"+str(hotled))

ExtremeColdLED.start (extrêmement froid)

ColdLED.start (froid)

ExtremeHotLED.start(extrêmement chaud)

HotLED.start(hotled)

elif100>temp>=70:

extrêmefroid=0

froid=0

hotled=100

extremehotled=getextremerightledintensity(temp) -100

print("Led froid extrême:"+str(extrême froid))

print("LED froide:"+str(froid))

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

print("Led chaude:"+str(hotled))

ExtremeColdLED.start (extrêmement froid)

ColdLED.start (froid)

ExtremeHotLED.start(extrêmement chaud)

HotLED.start(hotled)

elif30<temp<50:

extrêmefroid=0

coldled=getmiddleleftledintensity(temp)

hotled=100-froid

extremehotled=0

print("Led froid extrême:"+str(extrême froid))

print("LED froide:"+str(froid))

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

print("Led chaude:"+str(hotled))

ExtremeColdLED.start (extrêmement froid)

ColdLED.start (froid)

ExtremeHotLED.start(extrêmement chaud)

HotLED.start(hotled)

elif50<temp<70:

hotled=getmiddlerightledintensity(temp)

extremehotled=0

coldled=100-hotled

extrêmefroid=0

print("Led froid extrême:"+str(extrême froid))

print("LED froide:"+str(froid))

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

print("Led chaude:"+str(hotled))

ExtremeColdLED.start (extrêmement froid)

ColdLED.start (froid)

ExtremeHotLED.start(extrêmement chaud)

HotLED.start(hotled)

elifetemp==50:

extrêmefroid=0

froid=50

hotled=50

extremehotled=0

print("Led froid extrême:"+str(extrême froid))

print("LED froide:"+str(froid))

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

print("Led chaude:"+str(hotled))

ExtremeColdLED.start (extrêmement froid)

ColdLED.start (froid)

ExtremeHotLED.start(extrêmement chaud)

HotLED.start(hotled)

defGetRainLED(idCode):

ifCheckRain(idCode):

GPIO.sortie(Rain_LED_PIN, GPIO. HIGH)

autre:

GPIO.sortie(Rain_LED_PIN, GPIO. LOW)

#Informations API: Repalce API key avec votre clé api oepnweather

openweather_api_key="460a23f27ff324ef9ae743c7e9c32d7e"

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

print("Tapez une ville !")

city_name=input()

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

#Obtenir des données météorologiques

Réponse=requests.get(full_call)

WeatherData=Response.json()

WeatherID=Données météo["météo"][0]["id"]

City_TemperatureK=Données météo["main"]["temp"]

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

#Contenus LED/GPIO

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

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

imprimer (ID Météo)

essayer:

tandis que (Vrai):

GetLEDBrightness(City_TemperatureF)

GetRainLED(WeatherID)

heure.sommeil(10)

saufKeyboardInterrupt:

quitter()

voir rawRaspberryPIWeatherStation.py hébergé avec ❤ par GitHub

Étape 7: Construire et câbler

Ouf! Après tout ce codage, nous arrivons au bâtiment, ce qui est beaucoup plus facile. En raison des commandes de séjour à domicile corona, nous n'avons pas pu accéder à la plupart des outils que nous nous attendions à avoir à l'école. Donc, cette partie est un peu plus simple que ce que nous voulions. Les détails eux-mêmes sont également flexibles. Nous avons d'abord dessiné un rectangle sur une planche de bois. La taille spécifique n'a pas vraiment d'importance, car elle sert simplement de plate-forme pour mettre des LED et de l'électronique.

Ensuite, nous avons percé cinq trous de 1/8 de pouce dans notre morceau de bois.

Nous avons ensuite découpé le rectangle dans la planche pour l'utiliser comme plate-forme pour nos appareils électroniques.

(C'était à ce moment-là que nous avons commencé; nous avons trouvé une scie plus grosse !)

Nous enfonçons ensuite les broches d'anode et de cathode de la led dans les trous; les leds doivent être posées sur le dessus, leurs ampoules dépassant; garder une trace de quelle jambe est plus longue et plus courte. Nous nous sommes ensuite préparés à commencer à souder les fils ensemble. Tout d'abord, nous soudons les résistances à la branche anodique de la LED (la branche la plus longue).

Ensuite, nous soudons les pattes cathodiques des LED à un seul fil de cuivre que nous utiliserons comme masse. Ça devrait ressembler à ça.

Après cela, nous soudons les extrémités mâles des câbles de démarrage femelle-mâle aux extrémités de chaque résistance et au fil de terre en cuivre. Une fois cela fait, nous pouvons commencer à brancher les fils dans les broches Raspberry PI GPIO. Voici un schéma ! Cependant, notez que les broches sont celles du code précédemment évoqué.

Une fois que tout est câblé, il ne vous reste plus qu'à récupérer le fichier Python sur le Raspberry Pi et à ouvrir le terminal. exécutez "python3 RaspberryPIWeatherStation.py" puis faites ce qu'il montre.

Étape 8: Démonstration et conclusion

Merci d'avoir lu jusqu'au bout ! Je joins le script python ci-dessous ! S'il y avait des choses que nous pouvions ajouter, ce serait probablement…

1. Prise en charge de différents types d'entrée (villes, points géographiques, etc.)

2. Prise en charge de plus d'informations météorologiques

3. Ajoutez un petit écran pour afficher les informations

Faites-nous part de vos réflexions ! C'était un projet amusant à construire. Nous avons beaucoup appris sur les requêtes et l'obtention de documents Internet en utilisant python, et nous avons également beaucoup appris sur l'utilisation de la soudure.