Stație meteo LED Raspberry PI: 8 pași

2024 Autor: John Day | [email protected]. Modificat ultima dată: 2024-01-30 11:42

Am creat o stație LED pentru vreme Raspberry PI. Îi spune utilizatorului cât de fierbinte și de rece este un oraș prin aprinderea și diminuarea ledurilor. De asemenea, are un motiv pentru a le spune dacă plouă sau nu în orașul în care au tastat.

Creat de Michael Andrews și Tio Marello.

Provizii

Instrumente

1. Ciocan de lipit
2. Dremel
3. A văzut

Materiale

1. Raspberry Pi 3 B + ~ 40 dolari ~ 30 dolari
2. Sârmă jumper de la feminin la masculin ~ 7 dolari
3. 3 diode LED albastre și 2 roșii ~ 11 dolari
4. Rezistențe 100 Ohm ~ 13 dolari
5. 4 x 4 x 1/4 scândură de lemn ~ 5 dolari
6. Solder ~ 10 dolari
7. Sârmă de cupru ~ 5 dolari

Pasul 1: Codificarea ca rezolvare a problemelor

Codificarea este rezolvarea problemelor

Deci, în proiectul nostru, care este problema noastră? Problema noastră este să obținem date despre vreme și apoi să le folosim pentru a indica LED-urile noastre dacă sunt stinse sau aprinse. Deci, acest lucru împarte problema noastră în trei domenii.

1. Obținerea datelor meteo

2. Utilizarea acelor date

3. Utilizarea LED-urilor

Cu toate acestea, limbajul pe care l-am folosit pentru acest proiect, Python, și hardware-ul pe care rulează, Python, ne oferă o modalitate ușoară de a realiza aceste obiective.

Deci, vom începe cu prima problemă, obținerea datelor meteo.

Pasul 2: Codificare: obținerea datelor meteo

Python singur nu poate obține date despre vreme. Trebuie să importăm două instrumente, precum și un serviciu extern, pentru a obține date despre vreme. Pentru a face acest lucru, folosim trei instrumente.

1. Solicitări, un modul python care permite webscraping

2. Json, un modul python care ne permite să folosim formatul de fișier JSON

3. OpenWeather, un site web care ne poate oferi date despre vreme

Deci, aducem cele două module scriind acest cod în partea de sus a scriptului nostru Python.

solicitări de import

import json

Cu toate acestea, înainte de a utiliza aceste instrumente, trebuie să folosim Openweather. Pentru aceasta, trebuie să creăm un cont pe site-ul lor și să obținem o cheie API. Urmați instrucțiunile de pe site-ul lor web și veți primi un șir de litere și cifre care ne vor permite să folosim serviciul lor. Cum?

openweather_api_key = "260a23f27f5324ef2ae763c779c32d7e" #Cheia noastră API (nu este reală)

base_call = "https://api.openweathermap.org/data/2.5/weather?q=" #OpenWeather Call #Aici obținem orașul utilizatorului sub formă de text tipărit ("Tastați un oraș!") city_name = input () # Aici am asamblat adresa pe care o vom conecta la requests.get pentru a primi date despre vreme full_call = base_call + city_name + "& appid =" + openweather_api_key # În cele din urmă apelăm request.get cu adresa noastră, apoi o convertim într-un fișier json Response = requests.get (full_call) WeatherData = Response.json () Fișierele #JSON conțin diferite variabile pe care le putem accesa folosind această sintaxă. ["weather"] [0] ["id"] City_TemperatureK = WeatherData ["main"] ["temp"]

Aici avem codul care ne obține datele meteo. Solicitările, sub forma request.get, primesc o adresă a site-ului web și ne oferă un fișier din acel site înapoi. OpenWeather ne oferă o adresă de apelat pentru a ne oferi date despre vreme sub forma unui json. Asamblăm o adresă pe care o conectăm la solicitări și obținem un fișier json înapoi. Apoi creăm două variabile și le atribuim temperaturii și vremii din orașul utilizatorului.

Deci, acum, cu acest cod, avem două variabile. Avem un ID meteo și o temperatură în Kelvin

Pasul 3: Codificare: utilizarea acestor date

Acum că avem aceste două variabile, trebuie să le pregătim pentru a fi utilizate pentru LED-urile noastre. Pentru acest aspect, nu trebuie să importăm module pentru aceasta.

În primul rând, convertim kelvinul în Fahrenheit.

Facem acest lucru creând o variabilă cu această sintaxă

Oraș_TemperaturăF = (Oraș_TemperaturăK - 273) * 1,8 + 32

care convertește de la Kelvin la Fahrenheit (ceea ce convertește cu adevărat de la K -> C -> F)

Următorul nostru este weatherID. WeatherID este un ID furnizat de Openweather, care ne spune despre condițiile meteorologice ale unui oraș.

openweathermap.org/weather-conditions Iată o listă a acestora.

Am observat că totul sub numărul 700 a fost un fel de precipitații, așa că am verificat doar dacă codul era sub 700 pentru a vedea dacă plouă.

Def CheckRain (IdCode): dacă IdCode <700: returnează True else: returnează False

Cu aceasta, avem cele două variabile pregătite pentru utilizare cu pinii Raspberry PI și cu diodele LED.

Pasul 4: Codificare: Utilizarea RPi. GPIO și a diodelor LED

RaspberryPi vine cu un set de pini masculi pe care îi putem folosi pentru a comunica cu o serie de componente electrice, care în acest caz sunt diode LED; este asemănător cu Arduino și sistemul său. Cu toate acestea, Raspberry PI este un computer de uz general, spre deosebire de un microcontroler precum Arduino. Deci, trebuie să facem ceva mai multă muncă pentru a le folosi. Aceasta constă în configurarea pinilor de pe Raspberry Pi. Facem acest lucru folosind acest cod.

import RPi. GPIO ca GPIO # Importăm modulul pentru a-l putea folosi

# Configurați piniiGPIO.setmode (GPIO. BCM) GPIO.setwarnings (Fals)

#Pini la care sunt conectate LED-urile. Acestea pot fi diferite dacă îl construiți, deci asigurați-vă că comparați și modificați când este necesar

Extreme_Hot_LED_PIN = 26 Hot_LED_PIN = 16

Extreme_Cold_LED_PIN = 5

Cold_LED_PIN = 6

Rain_LED_PIN = 23

# Trecem prin fiecare pin, folosind comanda.setup, introducând numărul său și setându-l ca pin de ieșire

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)

Cu toate acestea, acest cod ne-ar permite doar să folosim două stări cu ledul, adică pornit și oprit. Cu toate acestea, avem nevoie de asta pentru a putea estompa luminile. Pentru a face acest lucru, folosim Modularea lățimii impulsurilor.

Utilizarea modulării lățimii impulsurilor

Modularea lățimii impulsurilor ne permite să emitem un semnal analogic folosind un pin digital. În esență, pornește și oprește sursa de semnal la o rată ridicată, care mediază la o anumită tensiune. RPi. GPIO ne permite să folosim acest lucru, deși cu un cod suplimentar.

#Creăm patru obiecte pin folosind comanda GPIO. PWM, care preia un număr de canal

# Al doilea număr este de câte ori se actualizează pe secundă

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)

Pentru următorul pas, va trebui să știți modul în care actualizăm acești pini.

Actualizăm pinii folosind comanda

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

ExtremeHotLED.start (x)

HotLED.start (x)

x în acest caz ar fi ciclul de funcționare, care determină cât de mult se oprește. Acesta variază de la 0 la 100, deci trebuie să ne bazăm următorul cod pe acest fapt.

Pasul 5: Codificare: Obținerea luminozității LED-urilor

Deoarece avem patru led-uri diferite, vrem să le aprindem în funcție de cum. rece sau cald este în orașul utilizatorului. Am decis să avem patru etape pentru condus.

#Funcții

def getmiddleleftledintensity (TemperatureinF): #Echuația stânga: y = - (50/20) x + 175 #Echuația dreaptă: y = (50/20) x - 75 return - (50/20) * TemperaturainF + 175

def getmiddlerightledintensity (TemperatureinF):

# Ecuația stânga: y = - (50/20) x + 175 # Ecuația dreaptă: y = (50/20) x - 75 return (50/20) * Temperatura înF - 75

def getextremeleftledintensity (TemperatureinF):

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

retur - (100/30) * Temperatura în F + 200

def getextremerightightintensity (TemperatureinF):

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

retur (100/30) * Temperatura inF - (400/3)

#Setarea luminilor LED

def GetLEDBrightness (temp):

dacă temp <= 0: extremecoldled = 100 coldled = 100 hotled = 0 extremehotled = 0

print ("LED extrem de rece:" + str (extrem de răcit))

print ("Led rece:" + str (rece)) print ("Extreme hot led" + str (extremehotled)) print ("Hot led:" + str (hotled))

ExtremeColdLED.start (extremecoldled)

ColdLED.start (rece)

ExtremeHotLED.start (extremehotled)

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

print ("LED extrem de rece:" + str (extrem de răcit))

print ("Led rece:" + str (rece)) print ("Extreme hot led" + str (extremehotled)) print ("Hot led:" + str (hotled))

ExtremeColdLED.start (extremecoldled)

ColdLED.start (rece)

ExtremeHotLED.start (extremehotled)

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

print ("LED extrem de rece:" + str (extrem de răcit))

print ("Led rece:" + str (rece)) print ("Extreme hot led" + str (extremehotled)) print ("Hot led:" + str (hotled))

ExtremeColdLED.start (extremecoldled)

ColdLED.start (rece)

ExtremeHotLED.start (extremehotled)

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

print ("LED extrem de rece:" + str (extrem de răcit))

print ("Led rece:" + str (rece)) print ("LED extrem de fierbinte" + str (extremehotled)) print ("Led fierbinte:" + str (hotled))

ExtremeColdLED.start (extremecoldled)

ColdLED.start (rece)

ExtremeHotLED.start (extremehotled)

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

print ("LED extrem de rece:" + str (extrem de răcit))

print ("Led rece:" + str (rece)) print ("Extreme hot led" + str (extremehotled)) print ("Hot led:" + str (hotled))

ExtremeColdLED.start (extremecoldled)

ColdLED.start (rece)

ExtremeHotLED.start (extremehotled)

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

rece = 100 - fierbinte

extremecoldled = 0

print ("LED extrem de rece:" + str (extrem de răcit))

print ("Led rece:" + str (rece)) print ("LED extrem de fierbinte" + str (extremehotled)) print ("Led fierbinte:" + str (hotled))

ExtremeColdLED.start (extremecoldled)

ColdLED.start (rece)

ExtremeHotLED.start (extremehotled)

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

print ("LED extrem de rece:" + str (extrem de răcit))

print ("Led rece:" + str (rece)) print ("Extreme hot led" + str (extremehotled)) print ("Hot led:" + str (hotled))

ExtremeColdLED.start (extremecoldled)

ColdLED.start (rece)

ExtremeHotLED.start (extremehotled)

HotLED.start (hotled)

Bine, această secțiune de cod este foarte lungă. De asemenea, este destul de greu de explicat. În esență, codul de mai sus privește temperatura în Fahrenheit și determină dacă se află într-un set de intervale. În funcție de domenii, acesta dă un număr pentru fiecare led și luminozitatea sa și apoi setează luminozitatea apelând comanda start (). Aceasta este explicația rapidă. Dacă este suficient, vă recomand să treceți la pasul următor, dar dacă doriți să vedeți explicația lungă și plictisitoare, continuați să citiți.

Când am programat, am decis că cel mai simplu mod de a obține o valoare de la o temperatură a fost sub forma unei funcții matematice. Deci, am creat un grafic în GeoGebra pentru a reprezenta relația dintre temperatura noastră și luminozitatea noastră; motivul pentru care depășește 100 este că extra ar intra în al doilea led. Cu toate acestea, ne-am confruntat cu problema obținerii unei singure funcții care să mapeze toate aceste puncte la o singură funcție. Am crezut că putem folosi o parabolă, dar am decis să ne mulțumim doar să folosim o serie de afirmații if. În esență, întregul cod este o funcție parțială.

Funcțiile din partea de sus sunt ecuația respectivă de linii. Odată ce determinăm unde se află temperatura pe grafic, o rulăm prin acea funcție, obținem luminozitatea și o trecem pe leduri.

Pasul 6: Codificare: pașii finali

În cele din urmă, adăugăm această afirmație la final.

încerca:

while (True): GetLEDBrightness (City_TemperatureF) GetRainLED (WeatherID) time.sleep (10) cu excepția KeyboardInterrupt: quit ()

Instrucțiunile try and except ne permit să ieșim din cod utilizând o scurtătură de la tastatură; în caz contrar, ar trebui să închidem Raspberry Pi pentru a reporni codul. Apoi avem o buclă de timp care rulează pentru totdeauna. Actualizăm ledurile, precum și actualizăm LED-ul de ploaie. Ne oprim timp de zece secunde; OpenWeather permite doar 60 de apeluri pentru date pe minut, iar 10 secunde sunt o mulțime de actualizări.

Și cu aceasta, codul nostru este terminat. Mai jos este codul terminat.

RaspberryPIWeatherStation.py

cereri de import

importRPi. GPIOasGPIO

importjson

timp de import

#Openweather idCodes mai puțin de 700 sunt toate precipitații

defCheckRain (IdCode):

ifIdCode <700:

returnAdevărat

altceva:

returnFals

defgetmiddleleftledintensity (TemperatureinF):

#Echuația stânga: y = - (50/20) x + 175

#Echuație dreaptă: y = (50/20) x - 75

retur- (50/20) * Temperatura în F + 175

defgetmiddlerightledintensity (TemperatureinF):

#Echuația stânga: y = - (50/20) x + 175

#Echuație dreaptă: y = (50/20) x - 75

retur (50/20) * Temperatura în F-75

defgetextremeleftledintensity (TemperatureinF):

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

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

retur- (100/30) * Temperatura în F + 200

defgetextremerightightintensity (TemperatureinF):

# Ecuația din stânga: y = - (100/30) x + 200

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

retur (100/30) * Temperatura inF- (400/3)

#GPIO Setup

GPIO.setmode (GPIO. BCM)

GPIO.setwarnings (Fals)

#Pini

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

rece = 100

hotled = 0

extremehotled = 0

print ("LED extrem de rece:" + str (extrem de răcit))

print ("Led rece:" + str (rece))

print ("LED extrem de fierbinte" + str (extremehotled))

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

ExtremeColdLED.start (extremecoldled)

ColdLED.start (rece)

ExtremeHotLED.start (extremehotled)

HotLED.start (hotled)

eliftemp> = 100:

extremecoldled = 0

rece = 0

hotled = 100

extremehotled = 100

print ("LED extrem de rece:" + str (extrem de răcit))

print ("Led rece:" + str (rece))

print ("LED extrem de fierbinte" + str (extremehotled))

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

ExtremeColdLED.start (extremecoldled)

ColdLED.start (rece)

ExtremeHotLED.start (extremehotled)

HotLED.start (hotled)

elif0 <temp <= 30:

extremecoldled = getextremeleftledintensity (temp) -100

rece = 100

hotled = 0

extremehotled = 0

print ("LED extrem de rece:" + str (extrem de răcit))

print ("Led rece:" + str (rece))

print ("LED extrem de fierbinte" + str (extremehotled))

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

ExtremeColdLED.start (extremecoldled)

ColdLED.start (rece)

ExtremeHotLED.start (extremehotled)

HotLED.start (hotled)

elif100> temp> = 70:

extremecoldled = 0

rece = 0

fierbinte = 100

extremehotled = getextremerightledintensity (temp) -100

print ("LED extrem de rece:" + str (extrem de răcit))

print ("Led rece:" + str (rece))

print ("LED extrem de fierbinte" + str (extremehotled))

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

ExtremeColdLED.start (extremecoldled)

ColdLED.start (rece)

ExtremeHotLED.start (extremehotled)

HotLED.start (hotled)

elif30 <temp <50:

extremecoldled = 0

coldled = getmiddleleftledintensity (temp)

hotled = 100-rece

extremehotled = 0

print ("LED extrem de rece:" + str (extrem de răcit))

print ("Led rece:" + str (rece))

print ("LED extrem de fierbinte" + str (extremehotled))

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

ExtremeColdLED.start (extremecoldled)

ColdLED.start (rece)

ExtremeHotLED.start (extremehotled)

HotLED.start (hotled)

elif50 <temp <70:

hotled = getmiddlerightledintensity (temp)

extremehotled = 0

rece = 100-fierbinte

extremecoldled = 0

print ("LED extrem de rece:" + str (extrem de răcit))

print ("Led rece:" + str (rece))

print ("LED extrem de fierbinte" + str (extremehotled))

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

ExtremeColdLED.start (extremecoldled)

ColdLED.start (rece)

ExtremeHotLED.start (extremehotled)

HotLED.start (hotled)

eliftemp == 50:

extremecoldled = 0

rece = 50

fierbinte = 50

extremehotled = 0

print ("LED extrem de rece:" + str (extrem de răcit))

print ("Led rece:" + str (rece))

print ("LED extrem de fierbinte" + str (extremehotled))

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

ExtremeColdLED.start (extremecoldled)

ColdLED.start (rece)

ExtremeHotLED.start (extremehotled)

HotLED.start (hotled)

defGetRainLED (idCode):

ifCheckRain (idCode):

GPIO.output (Rain_LED_PIN, GPIO. HIGH)

altceva:

GPIO.output (Rain_LED_PIN, GPIO. LOW)

Informații #Api: Repalce cheia API cu cheia API API oepnweather

openweather_api_key = "460a23f27ff324ef9ae743c7e9c32d7e"

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

print („Tastați un oraș!”)

city_name = input ()

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

# Obținerea datelor meteo

Răspuns = 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 # Convertiți în Fahrenheit

# Lucruri LED / GPIO

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

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

print (WeatherID)

încerca:

în timp ce (Adevărat):

GetLEDBrightness (City_TemperatureF)

GetRainLED (WeatherID)

time.sleep (10)

exceptie KeyboardInterrupt:

părăsi()

vizualizați rawRaspberryPIWeatherStation.py găzduit cu ❤ de GitHub

Pasul 7: Construirea și cablarea

Vai! După toate aceste codări, ajungem la clădire, ceea ce este mult mai ușor. Datorită comenzilor coronei de ședere la domiciliu, nu am putut ajunge la multe dintre instrumentele pe care ne așteptam să le avem la școală. Deci, această parte este puțin mai simplă decât am intenționat. Specificul în sine este, de asemenea, flexibil. Mai întâi am desenat un dreptunghi pe o scândură de lemn. Dimensiunea specifică nu prea contează prea mult, deoarece servește pur și simplu ca o platformă pentru a pune leduri și electronice.

Apoi am forat cinci 1/8 în găuri în bucata noastră de lemn.

Decupăm apoi dreptunghiul din scândură pentru a-l folosi ca platformă pentru electronica noastră.

(Atunci am început; am găsit un fierăstrău mai mare!)

Apoi împingem pinii anodului și catodului ledului în găuri; ledurile ar trebui să fie așezate pe partea de sus, becurile lor să iasă; urmăriți care picior este mai lung și mai scurt. Apoi ne-am pregătit să începem să lipim fire împreună. Mai întâi lipim rezistențele la piciorul anodic al LED-ului (piciorul mai lung).

Apoi, lipim picioarele catodice ale LED-urilor pe un singur fir de cupru pe care îl vom folosi ca pământ. Ar trebui să arate așa.

După ce facem acest lucru, lipim capetele masculine ale cablurilor jumper-mamă la capetele fiecărui rezistor și firul de împământare din cupru. Odată ce facem acest lucru, putem începe să conectăm firele la pinii GPIO cu zmeură. Iată o diagramă! Cu toate acestea, rețineți, pinii sunt cei din codul atins anterior.

Odată ce ați conectat totul, acum tot ce trebuie să faceți este să preluați fișierul Python pe raspberry Pi și să deschideți terminalul. rulați „python3 RaspberryPIWeatherStation.py” și apoi faceți cum arată.

Pasul 8: demonstrație și concluzie

Vă mulțumim că ați citit până la capăt! Voi atașa scriptul python de mai jos! Dacă am putea adăuga lucruri, probabil că ar fi …

1. Suport pentru diferite tipuri de intrare (orașe, puncte geografice etc.)

2. Suport pentru mai multe informații despre vreme

3. Adăugați un mic ecran pentru a afișa informații

Spune-ne gândurile tale! Acesta a fost un proiect distractiv de construit. Am învățat multe despre cereri și obținerea de documente pe internet folosind python și, de asemenea, am învățat multe despre utilizarea lipirii.