Stazione meteorologica LED Raspberry PI: 8 passaggi

2024 Autore: John Day | [email protected]. Ultima modifica: 2024-01-30 10:01

Abbiamo creato una stazione LED meteo Raspberry PI. Racconta all'utente quanto è calda e fredda una città accendendo e attenuando i led. Ha anche un led per dire loro se piove o meno nella città in cui hanno digitato.

Creato da Michael Andrews e Tio Marello.

Forniture

Utensili

1. Saldatore
2. Dremel
3. Sega

Materiali

1. Raspberry Pi 3 B+ ~40 dollari ~ 30 dollari
2. Cavi jumper da femmina a maschio ~7 dollari
3. 3 diodi LED blu e 2 rossi ~ 11 dollari
4. Resistori da 100 Ohm ~ 13 Dollari
5. 4 x 4 x 1/4 tavola di legno ~ 5 dollari
6. Saldare ~ 10 dollari
7. Filo di rame ~ 5 dollari

Passaggio 1: codifica come risoluzione dei problemi

La codifica è la soluzione dei problemi

Quindi, nel nostro progetto, qual è il nostro problema? Il nostro problema è ottenere i dati meteorologici e quindi utilizzare quei dati per dire ai nostri LED se sono spenti o accesi. Quindi questo divide il nostro problema in tre aree.

1. Ottenere dati meteo

2. Utilizzo di quei dati

3. Utilizzo dei LED

Tuttavia, il linguaggio che abbiamo usato per questo progetto, Python, e l'hardware su cui è in esecuzione, Python, ci offrono un modo semplice per raggiungere questi obiettivi.

Quindi, iniziamo con il primo problema, ottenere i dati meteorologici.

Passaggio 2: codifica: ottenere dati meteorologici

Python da solo non può ottenere i dati meteorologici. Dobbiamo importare due strumenti, oltre a un servizio esterno, per ottenere i dati meteorologici. Per fare ciò, utilizziamo tre strumenti.

1. Requests, un modulo Python che consente il webscraping

2. Json, un modulo Python che ci consente di utilizzare il formato file JSON

3. OpenWeather, un sito web che può fornirci dati meteo

Quindi, portiamo i due moduli scrivendo questo codice nella parte superiore del nostro script python.

richieste di importazione

import json

Prima di utilizzare questi strumenti, tuttavia, dobbiamo utilizzare Openweather. Per questo, dobbiamo creare un account sul loro sito e ottenere una chiave API. Segui le istruzioni sul loro sito Web e otterrai una serie di lettere e numeri che ci consentiranno di utilizzare il loro servizio. Come?

openweather_api_key = "260a23f27f5324ef2ae763c779c32d7e" #La nostra chiave API (non reale)

base_call = "https://api.openweathermap.org/data/2.5/weather?q=" #OpenWeather Call #Qui otteniamo la città dell'utente sotto forma di testo print("Digita una città!") city_name = input () #Qui abbiamo assemblato l'indirizzo che collegheremo a request.get per ricevere i dati meteo full_call = base_call+city_name+"&appid="+openweather_api_key #Finalmente chiamiamo request.get con il nostro indirizzo, poi lo convertiamo in un file json Response = request.get(full_call) WeatherData = Response.json() #I file JSON contengono diverse variabili a cui possiamo accedere utilizzando questa sintassi #Qui otteniamo l'ID meteo e la temperatura in Kelvin della città digitata dall'utente in WeatherID = WeatherData ["weather"][0]["id"] City_TemperatureK = WeatherData["main"]["temp"]

Qui abbiamo il codice che ci fornisce i nostri dati meteorologici. Requests, sotto forma di request.get, accetta l'indirizzo di un sito web e ci restituisce un file da quel sito web. OpenWeather ci fornisce un indirizzo da chiamare per fornirci dati meteo sotto forma di json. Assembliamo un indirizzo che inseriamo nelle richieste e otteniamo indietro un file json. Quindi creiamo due variabili e le assegniamo alla temperatura e al meteo della città dell'utente.

Quindi ora, con questo codice, abbiamo due variabili. Abbiamo un weatherID e una temperatura in Kelvin

Passaggio 3: codifica: utilizzo di tali dati

Ora che abbiamo queste due variabili, dobbiamo prepararle per l'uso per i nostri LED. Per questo aspetto, non dobbiamo importare alcun modulo per questo.

Innanzitutto, convertiamo il kelvin in Fahrenheit.

Lo facciamo creando una variabile con questa sintassi

Città_TemperaturaF = (Città_TemperaturaK - 273)*1.8 + 32

che converte da Kelvin a Fahrenheit (che in realtà converte da K -> C -> F)

Il prossimo è il nostro weatherID. Il weatherID è un ID fornito da Openweather che ci informa sulle condizioni meteorologiche di una città.

openweathermap.org/weather-conditions Eccone un elenco.

Abbiamo notato che tutto al di sotto del numero 700 era una sorta di precipitazione, quindi abbiamo appena controllato se il codice era inferiore a 700 per vedere se stava piovendo.

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

Con ciò, abbiamo le nostre due variabili preparate per l'uso con i nostri pin Raspberry PI e diodi LED.

Passaggio 4: codifica: utilizzo di RPi. GPIO e diodi LED

Il RaspberryPi viene fornito con una serie di pin maschio che possiamo usare per comunicare con una serie di componenti elettrici, che in questo caso sono diodi LED; è simile ad Arduino e al suo sistema. Tuttavia, il Raspberry PI è un computer generico, al contrario di un microcontrollore come Arduino. Quindi, dobbiamo fare un po' più di lavoro per usarli. Consiste nell'impostare i pin sul Raspberry Pi. Lo facciamo usando questo codice.

import RPi. GPIO as GPIO #Importiamo il modulo in modo da poterlo utilizzare

#Imposta i pinsGPIO.setmode(GPIO. BCM) GPIO.setwarnings(False)

#I pin a cui sono collegati i LED. Questi potrebbero essere diversi se lo costruisci, quindi assicurati di confrontare e cambiare quando necessario

Extreme_Hot_LED_PIN = 26 Hot_LED_PIN = 16

Extreme_Cold_LED_PIN = 5

Cold_LED_PIN = 6

Pioggia_LED_PIN = 23

#Passiamo attraverso ogni pin, usando il comando.setup, inserendo il suo numero e impostandolo come pin di output

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)

Tuttavia, questo codice ci consentirebbe solo di utilizzare due stati con il led, ovvero acceso e spento. Tuttavia, ne abbiamo bisogno per poter abbassare le luci. Per fare ciò, utilizziamo la modulazione dell'ampiezza dell'impulso.

Utilizzo della modulazione dell'ampiezza dell'impulso

Pulse Width Modulation ci consente di emettere un segnale analogico utilizzando un pin digitale. Essenzialmente, accende e spegne la sorgente del segnale ad un'alta velocità, che media fino a una certa tensione. L'RPi. GPIO ci permette di usarlo, anche se con qualche codice in più.

#Creiamo quattro oggetti pin usando il comando GPIO. PWM, che accetta un numero di canale

#Il secondo numero è il numero di aggiornamenti al secondo

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 il passaggio successivo, dovrai conoscere il modo in cui aggiorniamo questi pin.

Aggiorniamo i pin usando il comando

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

ExtremeHotLED.start(x)

HotLED.start(x)

x in questo caso sarebbe il duty cycle, che determina quanto si spegne. Va da 0 a 100, quindi dobbiamo basare il nostro prossimo codice su questo fatto.

Passaggio 5: codifica: ottenere la luminosità del LED

Poiché abbiamo quattro led diversi, vogliamo accenderli a seconda di come. freddo o caldo è nella città dell'utente. Abbiamo deciso di avere quattro fasi per il led.

#Funzioni

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

#Equazione sinistra: y=-(50/20)x + 175 #Equazione destra: y = (50/20)x - 75 ritorno (50/20)*TemperaturainF - 75

def getextremeleftledintensity(TemperatureinF):

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

ritorno -(100/30)*TemperaturainF + 200

def getextremerightledintensity(TemperatureinF):

# Equazione Sinistra: y = -(100/30)x + 200 # Equazione Destra: y = (100/30)x - (400/3)

ritorno (100/30)*TemperaturainF - (400/3)

#Impostazione delle luci a LED

def GetLEDBrightness(temp):

se temp <= 0: estremo freddo = 100 freddo caldo = 100 caldo caldo = 0 caldo estremo = 0

print("Led estremamente freddo:" + str(estremo freddo))

print("LED freddo:" + str(coldled)) print("led caldo estremo" + str(hotled estremo)) print("led caldo:" + str(hotled))

ExtremeColdLED.start(estremofreddo)

ColdLED.start (raffreddato)

ExtremeHotLED.start(extremehotled)

HotLED.start(hotled) elif temp >= 100: estremofreddo = 0 freddo = 0 caldo = 100 estremo caldo = 100

print("Led estremamente freddo:" + str(estremo freddo))

print("LED freddo:" + str(coldled)) print("led caldo estremo" + str(hotled estremo)) print("led caldo:" + str(hotled))

ExtremeColdLED.start(estremofreddo)

ColdLED.start (raffreddato)

ExtremeHotLED.start(extremehotled)

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

print("Led estremamente freddo:" + str(estremo freddo))

print("LED freddo:" + str(coldled)) print("led caldo estremo" + str(hotled estremo)) print("led caldo:" + str(hotled))

ExtremeColdLED.start(estremofreddo)

ColdLED.start (raffreddato)

ExtremeHotLED.start(extremehotled)

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

print("Led estremamente freddo:" + str(estremo freddo))

print("LED freddo:" + str(coldled)) print("led caldo estremo" + str(hotled estremo)) print("led caldo:" + str(hotled))

ExtremeColdLED.start(estremofreddo)

ColdLED.start (raffreddato)

ExtremeHotLED.start(extremehotled)

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

print("Led estremamente freddo:" + str(estremo freddo))

print("LED freddo:" + str(coldled)) print("led caldo estremo" + str(hotled estremo)) print("led caldo:" + str(hotled))

ExtremeColdLED.start(estremofreddo)

ColdLED.start (raffreddato)

ExtremeHotLED.start(estremohotled)

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

freddo = 100 - caldo

estremamente freddo = 0

print("Led estremamente freddo:" + str(estremo freddo))

print("LED freddo:" + str(coldled)) print("led caldo estremo" + str(hotled estremo)) print("led caldo:" + str(hotled))

ExtremeColdLED.start(estremofreddo)

ColdLED.start (raffreddato)

ExtremeHotLED.start(estremohotled)

HotLED.start(hotled) elif temp == 50: estremofreddo = 0 freddo caldo = 50 caldo caldo = 50 estremo caldo = 0

print("Led estremamente freddo:" + str(estremo freddo))

print("LED freddo:" + str(coldled)) print("led caldo estremo" + str(hotled estremo)) print("led caldo:" + str(hotled))

ExtremeColdLED.start(estremofreddo)

ColdLED.start (raffreddato)

ExtremeHotLED.start(extremehotled)

HotLED.start(hotled)

Bene, questa sezione di codice è davvero lunga. È anche piuttosto difficile da spiegare. In sostanza, il codice sopra esamina la temperatura in Fahrenheit e determina se è compresa in una serie di intervalli. A seconda dei range, assegna un numero per ogni led e la sua luminosità e poi imposta la luminosità chiamando il comando start(). Questa è la rapida spiegazione. Se è sufficiente, ti consiglio di passare al passaggio successivo, ma se vuoi vedere la spiegazione lunga e noiosa, continua a leggere.

Quando abbiamo programmato, abbiamo deciso che il modo più semplice per ottenere un valore da una temperatura era sotto forma di una funzione matematica. Quindi, abbiamo creato un grafico in GeoGebra per rappresentare quale sia la relazione tra la nostra temperatura e la luminosità del nostro led; il motivo per cui va sopra 100 è che l'extra andrebbe nel secondo led. Tuttavia, ci siamo imbattuti nel problema di ottenere una singola funzione per mappare tutti questi punti su una singola funzione. Pensavamo di poter usare una parabola, ma abbiamo deciso di accontentarci di usare una serie di istruzioni if. In sostanza, l'intero codice è una funzione a tratti.

Le funzioni in alto sono le rispettive equazioni di rette. Una volta determinata la posizione della temperatura sul grafico, la eseguiamo attraverso quella funzione, otteniamo la luminosità e la passiamo ai led.

Passaggio 6: codifica: passaggi finali

Infine, aggiungiamo questa affermazione alla fine.

Tentativo:

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

Le istruzioni try ed accept ci permettono di uscire dal codice usando una scorciatoia da tastiera; in entrambi i casi, dovremmo spegnere il Raspberry Pi per riavviare il codice. Quindi abbiamo un ciclo while che viene eseguito per sempre. Aggiorniamo i led, così come aggiorniamo il LED pioggia. Ci fermiamo per dieci secondi; OpenWeather consente solo 60 chiamate per dati al minuto e 10 secondi sono molti aggiornamenti.

E con questo, il nostro codice è finito. Di seguito è riportato il codice finito.

RaspberryPIWeatherStation.py

richieste di importazione

importRPi. GPIOasGPIO

importjson

importtime

#Openweather idCode inferiori a 700 sono tutte precipitazioni

defCheckRain(IdCode):

ifIdCode<700:

ritornoVero

altro:

ritornoFalse

defgetmiddleleftledintensity(TemperatureinF):

#Equazione sinistra: y=-(50/20)x + 175

#Equazione a destra: y = (50/20)x - 75

ritorno-(50/20)*TemperaturainF+175

defgetmiddlerightledintensity(TemperatureinF):

#Equazione sinistra: y=-(50/20)x + 175

#Equazione a destra: y = (50/20)x - 75

ritorno (50/20)*TemperaturainF-75

defgetextremeleftledintensity(TemperatureinF):

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

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

ritorno-(100/30)*TemperaturainF+200

defgetextremerightledintensity(TemperatureinF):

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

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

ritorno (100/30)*TemperaturainF- (400/3)

#Impostazione GPIO

GPIO.setmode(GPIO. BCM)

GPIO.setwarnings(Falso)

#Pin

Extreme_Hot_LED_PIN=26

Hot_LED_PIN=16

Extreme_Cold_LED_PIN=5

Cold_LED_PIN=6

Pioggia_LED_PIN=23

#Configurazione 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)

defGetLEDLuminosità(temp):

iftemp<=0:

estremamente freddo=100

freddo=100

caldo=0

puntata estrema=0

print("LED estremamente freddo:"+str(estremo freddo))

print("LED freddo:"+str(freddo))

print("Led caldo estremo"+str(hotled estremo))

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

ExtremeColdLED.start(estremofreddo)

ColdLED.start (raffreddato)

ExtremeHotLED.start(estremohotled)

HotLED.start(hotled)

eliftemp>=100:

estremamente freddo=0

freddo=0

caldo=100

puntata estrema = 100

print("LED estremamente freddo:"+str(estremo freddo))

print("LED freddo:"+str(freddo))

print("Led estremamente caldo"+str(extremehotled))

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

ExtremeColdLED.start(estremofreddo)

ColdLED.start (raffreddato)

ExtremeHotLED.start(extremehotled)

HotLED.start(hotled)

elif0<temp<=30:

extremecoldled=getextremeleftledintensità(temp) -100

freddo=100

caldo=0

puntata estrema=0

print("LED estremamente freddo:"+str(estremo freddo))

print("LED freddo:"+str(freddo))

print("Led caldo estremo"+str(hotled estremo))

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

ExtremeColdLED.start(estremofreddo)

ColdLED.start (raffreddato)

ExtremeHotLED.start(extremehotled)

HotLED.start(hotled)

elif100>temp>=70:

estremamente freddo=0

freddo=0

caldo=100

extremehotled=getextremerightledintensity(temp) -100

print("LED estremamente freddo:"+str(estremo freddo))

print("LED freddo:"+str(freddo))

print("Led caldo estremo"+str(hotled estremo))

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

ExtremeColdLED.start(estremofreddo)

ColdLED.start (raffreddato)

ExtremeHotLED.start(estremohotled)

HotLED.start(hotled)

elif30<temp<50:

estremamente freddo=0

coldled=getmiddleleftledintensity(temp)

caldo=100-freddo

puntata estrema=0

print("LED estremamente freddo:"+str(estremo freddo))

print("LED freddo:"+str(freddo))

print("Led estremamente caldo"+str(extremehotled))

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

ExtremeColdLED.start(estremofreddo)

ColdLED.start (raffreddato)

ExtremeHotLED.start(extremehotled)

HotLED.start(hotled)

elif50<temp<70:

hotled=getmiddlerightledintensity(temp)

puntata estrema=0

freddo=100-caldo

estremamente freddo=0

print("LED estremamente freddo:"+str(estremo freddo))

print("LED freddo:"+str(freddo))

print("Led estremamente caldo"+str(extremehotled))

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

ExtremeColdLED.start(estremofreddo)

ColdLED.start (raffreddato)

ExtremeHotLED.start(extremehotled)

HotLED.start(hotled)

eliftemp==50:

estremamente freddo=0

freddo=50

caldo=50

puntata estrema=0

print("LED estremamente freddo:"+str(estremo freddo))

print("LED freddo:"+str(freddo))

print("Led caldo estremo"+str(hotled estremo))

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

ExtremeColdLED.start(estremofreddo)

ColdLED.start (raffreddato)

ExtremeHotLED.start(extremehotled)

HotLED.start(hotled)

defGetRainLED(idCode):

ifCheckRain(idCode):

GPIO.output(Rain_LED_PIN, GPIO. HIGH)

altro:

GPIO.output(Rain_LED_PIN, GPIO. LOW)

#Informazioni API: sostituisci la chiave API con la tua chiave API oepnweather

openweather_api_key="460a23f27ff324ef9ae743c7e9c32d7e"

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

print("Digita una città!")

nome_città=input()

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

#Ottenere dati meteo

Risposta=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#Converti in Fahrenheit

#LED/GPIO Roba

print("K:"+str(Città_TemperaturaK))

print("F:"+str(Città_TemperaturaF))

stampa (ID meteo)

Tentativo:

mentre (vero):

OttieniLEDLuminosità(Città_TemperaturaF)

GetRainLED(MeteoID)

tempo.sonno(10)

tranneKeyboardInterrupt:

uscire()

visualizza rawRaspberryPIWeatherStation.py ospitato con ❤ da GitHub

Passaggio 7: costruzione e cablaggio

Wow! Dopo tutta quella codifica, arriviamo all'edificio, che è molto più semplice. A causa degli ordini di soggiorno a casa della corona, non siamo riusciti a ottenere molti degli strumenti che ci aspettavamo di avere a scuola. Quindi, questa parte è un po' più semplice di quanto intendevamo. Anche le specifiche stesse sono flessibili. Per prima cosa abbiamo disegnato un rettangolo su un'asse di legno. La dimensione specifica non ha molta importanza, in quanto funge semplicemente da piattaforma su cui posizionare i led e l'elettronica.

Quindi abbiamo praticato cinque fori da 1/8 nel nostro pezzo di legno.

Abbiamo quindi ritagliato il rettangolo dalla tavola da utilizzare come piattaforma per la nostra elettronica.

(Questo è stato quando abbiamo iniziato; abbiamo trovato una sega più grande!)

Successivamente spingiamo nei fori i perni di anodo e catodo del led; i led dovrebbero essere adagiati sopra, con le lampadine sporgenti; tieni traccia di quale gamba è più lunga e più corta. Quindi ci siamo preparati per iniziare a saldare insieme i fili. Per prima cosa saldiamo i resistori alla gamba dell'anodo del LED (la gamba più lunga).

Quindi, saldiamo le gambe del catodo dei LED a un singolo filo di rame che utilizzeremo come massa. Dovrebbe sembrare come questo.

Dopo averlo fatto, saldiamo le estremità maschio dei cavi jumper femmina-maschio alle estremità di ciascun resistore e al filo di terra in rame. Una volta fatto ciò, possiamo iniziare a collegare i fili ai pin GPIO di Raspberry PI. Ecco uno schema! Tuttavia, tieni presente che i pin sono quelli nel codice precedentemente toccato.

Una volta che hai tutto cablato, ora tutto ciò che devi fare è ottenere il file Python sul Raspberry Pi e aprire il terminale. esegui "python3 RaspberryPIWeatherStation.py" e poi fai come mostrato.

Passaggio 8: dimostrazione e conclusione

Grazie per aver letto fino in fondo! Allegherò lo script python di seguito! Se ci fossero cose che potremmo aggiungere, probabilmente sarebbe…

1. Supporto per diversi tipi di input (città, punti geografici, ecc.)

2. Supporto per ulteriori informazioni meteo

3. Aggiungi un piccolo schermo per mostrare le informazioni

Fateci sapere i vostri pensieri! Questo è stato un progetto divertente da costruire. Abbiamo imparato molto sulle richieste e sull'ottenimento di documenti Internet utilizzando Python e abbiamo anche imparato molto sull'utilizzo della saldatura.