Aveņu PI LED meteostacija: 8 soļi

2024 Autors: John Day | [email protected]. Pēdējoreiz modificēts: 2024-01-30 10:53

Mēs izveidojām Raspberry PI Weather LED staciju. Tas norāda lietotājam, cik karsta un auksta ir pilsēta, izgaismojot un aptumšojot gaismas diodes. Tas arī noveda pie tā, lai viņiem pateiktu, vai pilsētā, kurā viņi rakstīja, līst lietus.

Izveidoja Michael Andrews un Tio Marello.

Piegādes

Rīki

1. Lodāmurs
2. Dremel
3. Ieraudzīja

Materiāli

1. Aveņu Pi 3 B+ ~ 40 dolāri ~ 30 dolāri
2. Džempera vadi no sievietes līdz vīrietim ~ 7 dolāri
3. 3 zilas un 2 sarkanas LED diodes ~ 11 dolāri
4. 100 omu rezistori ~ 13 dolāri
5. 4 x 4 x 1/4 koka dēlis ~ 5 dolāri
6. Lodēt ~ 10 dolāri
7. Vara stieple ~ 5 dolāri

1. darbība. Kodēšana kā problēmu risinājums

Kodēšana ir problēmu risināšana

Tātad, kāda ir mūsu problēma mūsu projektā? Mūsu problēma ir iegūt laika apstākļu datus un pēc tam izmantot šos datus, lai pastāstītu mūsu gaismas diodēm, vai tie ir izslēgti vai ieslēgti. Tādējādi mūsu problēma tiek sadalīta trīs jomās.

1. Laika datu iegūšana

2. Šo datu izmantošana

3. Izmantojot gaismas diodes

Tomēr valoda, ko izmantojām šim projektam, Python, un aparatūra, kurā tā darbojas, Python, sniedz mums vienkāršu veidu, kā sasniegt šos mērķus.

Tātad, sāksim ar pirmo problēmu, laika apstākļu datu iegūšanu.

2. darbība: kodēšana: laika apstākļu datu iegūšana

Python pats nevar iegūt laika apstākļu datus. Lai iegūtu laika apstākļu datus, mums ir jāimportē divi rīki, kā arī ārējs pakalpojums. Lai to izdarītu, mēs izmantojam trīs rīkus.

1. Pieprasījumi - python modulis, kas ļauj veikt tīmekļa skrāpēšanu

2. Json, python modulis, kas ļauj mums izmantot JSON faila formātu

3. OpenWeather - vietne, kas var sniegt mums laika apstākļu datus

Tātad, mēs piedāvājam abus moduļus, ierakstot šo kodu mūsu python skripta augšpusē.

importēšanas pieprasījumus

importēt json

Pirms šo rīku izmantošanas mums tomēr jāizmanto Openweather. Lai to izdarītu, mums ir jāizveido konts viņu vietnē un jāsaņem API atslēga. Izpildiet norādījumus viņu vietnē, un jūs saņemsiet virkni burtu un ciparu, kas ļaus mums izmantot viņu pakalpojumus. Kā?

openweather_api_key = "260a23f27f5324ef2ae763c779c32d7e" #Mūsu API atslēga (nav īsta)

base_call = "https://api.openweathermap.org/data/2.5/weather?q=" #OpenWeather Call #Šeit iegūstam lietotāja pilsētu teksta drukas veidā ("Ierakstiet pilsētu!") city_name = input () #Šeit mēs apkopojām adresi, kuru pievienosim pieprasījumiem. Saņemt laikapstākļu datus full_call = base_call+city_name+"& appid ="+openweather_api_key #Beidzot mēs izsaucam request.get ar savu adresi, pēc tam pārvēršam to par json failu Response = request.get (full_call) WeatherData = Response.json () #JSON faili satur dažādus mainīgos, kuriem mēs varam piekļūt, izmantojot šo sintaksi #Šeit mēs iegūstam laika apstākļu ID un temperatūru Kelvinos pilsētā, ko lietotājs ierakstīja WeatherID = WeatherData ["weather"] [0] ["id"] City_TemperatureK = WeatherData ["main"] ["temp"]

Šeit mums ir kods, kas mums sniedz mūsu laika apstākļu datus. Pieprasījumi request.get veidā pieņem vietnes adresi un atdod mums failu no šīs vietnes. OpenWeather dod mums adresi, uz kuru zvanīt, lai sniegtu mums laika apstākļu datus json formā. Mēs apkopojam adresi, kuru pievienojam pieprasījumiem, un saņemam atpakaļ json failu. Tad mēs izveidojam divus mainīgos un piešķiram tos lietotāja pilsētas temperatūrai un laika apstākļiem.

Tātad tagad, izmantojot šo kodu, mums ir divi mainīgie. Mums ir laika apstākļi un Kelvina temperatūra

3. darbība: kodēšana: šo datu izmantošana

Tagad, kad mums ir šie divi mainīgie, mums tie ir jāsagatavo lietošanai mūsu gaismas diodēm. Šim nolūkam mums nav jāimportē nekādi moduļi.

Pirmkārt, mēs pārvēršam kelvinu par Fārenheitu.

Mēs to darām, izveidojot mainīgo ar šo sintaksi

City_TemperatureF = (City_TemperatureK - 273)*1,8 + 32

kas pārveido no Kelvina uz Fārenheitu (kas patiešām pārveido no K -> C -> F)

Nākamais ir mūsu weatherID. WeatherID ir ID, ko sniedz Openweather un kas mums stāsta par pilsētas laika apstākļiem.

openweathermap.org/weather-conditions Šeit ir to saraksts.

Mēs pamanījām, ka viss, kas ir mazāks par 700, bija kaut kādi nokrišņi, tāpēc mēs vienkārši pārbaudījām, vai kods ir zemāks par 700, lai redzētu, vai nelīst.

def CheckRain (IdCode): ja IdCode <700: atgriežas True else: atgriežas False

Līdz ar to mūsu divi mainīgie ir sagatavoti lietošanai kopā ar mūsu aveņu PI tapām un LED diodēm.

4. darbība. Kodēšana: RPi. GPIO un LED diodes izmantošana

RaspberryPi ir komplektā vīriešu tapas, kuras mēs varam izmantot, lai sazinātos ar virkni elektrisko komponentu, kas šajā gadījumā ir LED diodes; tas ir līdzīgs Arduino un tā sistēmai. Tomēr Raspberry PI ir universāls dators, atšķirībā no tāda mikrokontrollera kā Arduino. Tāpēc mums ir jāpieliek nedaudz vairāk darba, lai tos izmantotu. Tas sastāv no tapu uzstādīšanas uz Raspberry Pi. Mēs to darām, izmantojot šo kodu.

importēt RPi. GPIO kā GPIO #Mēs importējam moduli, lai mēs to varētu izmantot

#Iestatiet tapasGPIO.setmode (GPIO. BCM) GPIO.setwarnings (False)

#Tapas, kurās gaismas diodes ir pievienotas. Tās var atšķirties, ja to veidojat, tāpēc noteikti salīdziniet un mainiet, ja nepieciešams

Extreme_Hot_LED_PIN = 26 Karsts_LED_PIN = 16

Extreme_Cold_LED_PIN = 5

Auksts_LED_PIN = 6

Lietus_LED_PIN = 23

#Mēs ejam cauri katrai tapai, izmantojot komandu.setup, ievadot tā numuru un iestatot to kā izvades tapu

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_), Tomēr šis kods ļautu mums izmantot tikai divus stāvokļus ar LED, tas ir, ieslēgt un izslēgt. Tomēr mums tas ir vajadzīgs, lai spētu aptumšot gaismas. Lai to izdarītu, mēs izmantojam impulsa platuma modulāciju.

Pulsa platuma modulācijas izmantošana

Pulsa platuma modulācija ļauj mums izvadīt analogo signālu, izmantojot digitālo tapu. Būtībā tas ieslēdz un izslēdz signāla avotu ar augstu ātrumu, kas vidēji sasniedz noteiktu spriegumu. RPi. GPIO ļauj mums to izmantot, kaut arī ar papildu kodu.

#Mēs izveidojam četrus pin objektus, izmantojot komandu GPIO. PWM, kas ievada kanāla numuru

#Otrais skaitlis ir reižu skaits, kad tas tiek atjaunināts sekundē

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 (auksts_LED_PIN, 100)

Nākamajā solī jums būs jāzina, kā mēs atjauninām šīs tapas.

Mēs atjauninām tapas, izmantojot komandu

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

ExtremeHotLED.start (x)

HotLED.start (x)

x šajā gadījumā būtu darba cikls, kas nosaka, cik daudz tas pulsē. Tas svārstās no 0 līdz 100, tāpēc mums ir jābalstās uz nākamo kodu, pamatojoties uz šo faktu.

5. solis: Kodēšana: LED spilgtuma iegūšana

Tā kā mums ir četras dažādas gaismas diodes, mēs vēlamies tās iedegt atkarībā no tā, kā. auksts vai karsts tas atrodas lietotāja pilsētā. Mēs nolēmām vadīt četrus posmus.

#Funkcijas

def getmiddleleftledintensity (TemperatureinF): #Kreisais vienādojums: y = -(50/20) x + 175 #Pareizais vienādojums: y = (50/20) x -75 atgriešanās -(50/20)*TemperatūraF + 175

vidējās gaismas mazināšanas intensitāte (temperatūra F):

#Kreisais vienādojums: y = - (50/20) x + 175 #Pareizais vienādojums: y = (50/20) x - 75 atgriešanās (50/20)*Temperatūra F - 75

def getextremeleftledintensity (TemperatūraF):

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

atgriešanās -(100/30)*TemperatūraF + 200

def getextremerightledintensity (TemperatūraF):

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

atgriešanās (100/30)*Temperatūra F - (400/3)

#LED gaismas iestatīšana

def GetLEDBrightness (temp):

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

drukāt ("Īpaši auksts LED:" + str (galēji auksts))

print ("Cold led:" + str (auksts)) print ("Extreme hot led" + str (extremehotled)) print ("Hot led:" + str (hotled))

ExtremeColdLED.start (extremecoldled)

ColdLED.start (atdzesēts)

ExtremeHotLED.start (extremehotled)

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

drukāt ("Īpaši auksts LED:" + str (galēji auksts))

print ("Cold led:" + str (auksts)) print ("Extreme hot led" + str (extremehotled)) print ("Hot led:" + str (hotled))

ExtremeColdLED.start (extremecoldled)

ColdLED.start (atdzesēts)

ExtremeHotLED.start (extremehotled)

HotLED.start (hotled) elif 0 <temp <= 30: extremecoldled = getextremeleftledintensity (temp) - 100 atdzesēts = 100 karsts = 0 ekstremāls = 0

drukāt ("Īpaši auksts LED:" + str (galēji auksts))

print ("Cold led:" + str (auksts)) print ("Extreme hot led" + str (extremehotled)) print ("Hot led:" + str (hotled))

ExtremeColdLED.start (extremecoldled)

ColdLED.start (atdzesēts)

ExtremeHotLED.start (extremehotled)

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

drukāt ("Īpaši auksts LED:" + str (galēji auksts))

print ("Cold led:" + str (auksts)) print ("Extreme hot led" + str (extremehotled)) print ("Hot led:" + str (hotled))

ExtremeColdLED.start (extremecoldled)

ColdLED.start (atdzesēts)

ExtremeHotLED.start (extremehotled)

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

drukāt ("Īpaši auksts LED:" + str (galēji auksts))

print ("Cold led:" + str (auksts)) print ("Extreme hot led" + str (extremehotled)) print ("Hot led:" + str (hotled))

ExtremeColdLED.start (extremecoldled)

ColdLED.start (atdzesēts)

ExtremeHotLED.start (extremehotled)

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

atdzesēts = 100 - karsts

galēji auksts = 0

drukāt ("Īpaši auksts LED:" + str (galēji auksts))

print ("Cold led:" + str (auksts)) print ("Extreme hot led" + str (extremehotled)) print ("Hot led:" + str (hotled))

ExtremeColdLED.start (extremecoldled)

ColdLED.start (atdzesēts)

ExtremeHotLED.start (extremehotled)

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

drukāt ("Īpaši auksts LED:" + str (galēji auksts))

print ("Cold led:" + str (auksts)) print ("Extreme hot led" + str (extremehotled)) print ("Hot led:" + str (hotled))

ExtremeColdLED.start (extremecoldled)

ColdLED.start (atdzesēts)

ExtremeHotLED.start (extremehotled)

HotLED.start (karsts)

Labi, šī koda sadaļa ir patiešām gara. To ir arī diezgan grūti izskaidrot. Būtībā iepriekš norādītais kods aplūko temperatūru Fārenheitā un nosaka, vai tas ir diapazonu komplektā. Atkarībā no diapazoniem tas dod skaitli katrai gaismas diodei un tās spilgtumam un pēc tam iestata spilgtumu, izsaucot komandu start (). Tas ir ātrais skaidrojums. Ja ar to pietiek, iesaku pāriet uz nākamo soli, bet, ja vēlaties redzēt garo un garlaicīgo skaidrojumu, turpiniet lasīt.

Kad mēs programmējām, mēs nolēmām, ka vienkāršākais veids, kā iegūt vērtību no temperatūras, ir matemātiskas funkcijas veidā. Tātad, mēs izveidojām grafiku GeoGebra, lai attēlotu attiecības starp mūsu temperatūru un mūsu gaismas spilgtumu; iemesls, kāpēc tas pārsniedz 100, ir tas, ka papildus būtu jāiet uz otro vadību. Tomēr mēs saskārāmies ar jautājumu, kā iegūt vienu funkciju, lai visus šos punktus kartētu vienā funkcijā. Mēs domājām, ka varam izmantot parabolu, taču nolēmām vienkārši samierināties ar virkni if paziņojumu. Būtībā viss šis kods ir gabala funkcija.

Augšpusē esošās funkcijas ir attiecīgais līniju vienādojums. Kad esam noteikuši grafika temperatūru, mēs to izlaižam caur šo funkciju, iegūstam spilgtumu un nododam to gaismas diodēm.

6. darbība: kodēšana: pēdējie soļi

Visbeidzot, mēs pievienojam šo paziņojumu beigās.

pamēģini:

kamēr (True): GetLEDBrightness (City_TemperatureF) GetRainLED (WeatherID) time.sleep (10), izņemot tastatūruInterrupt: quit ()

Izmēģinājuma paziņojumi ļauj iziet no koda, izmantojot īsinājumtaustiņu; vai nu mums būtu jāslēdz Raspberry Pi, lai restartētu kodu. Tad mums ir kāda laika cilpa, kas darbojas mūžīgi. Mēs atjauninām gaismas diodes, kā arī lietus gaismas diodes. Mēs pārtraucam desmit sekundes; OpenWeather atļauj tikai 60 zvanus datiem minūtē, un 10 sekundes ir daudz atjauninājumu.

Un līdz ar to mūsu kods ir pabeigts. Zemāk ir gatavs kods.

RaspberryPIWeatherStation.py

importa pieprasījumi

importRPi. GPIOasGPIO

importjson

importēšanas laiks

#Openweather idCodes mazāk nekā 700 ir nokrišņi

defCheckRain (IdCode):

ifIdCode <700:

returnPatiesība

cits:

returnFalse

vidējās kreisās puses intensitātes samazināšana (temperatūra F):

#Kreisais vienādojums: y =-(50/20) x + 175

#Pareizais vienādojums: y = (50/20) x - 75

atgriešanās (50/20)*Temperatūra F+175

defgetmiddlerightlentensity (TemperatūraF):

#Kreisais vienādojums: y =-(50/20) x + 175

#Pareizais vienādojums: y = (50/20) x - 75

atgriešanās (50/20)*Temperatūra F-75

defgetext galējā kreisā intensitāte (temperatūra F):

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

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

atgriešanās (100/30)*Temperatūra F+200

defgetextremerightledintensity (TemperatūraF):

# Kreisais vienādojums: y = -(100/30) x + 200

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

atgriešanās (100/30)*Temperatūra F- (400/3)

#GPIO iestatīšana

GPIO.setmode (GPIO. BCM)

GPIO.setwarnings (nepatiess)

#Pins

Extreme_Hot_LED_PIN = 26

Karstā_LED_PIN = 16

Extreme_Cold_LED_PIN = 5

Auksts_LED_PIN = 6

Lietus_LED_PIN = 23

#Piespraudes iestatīšana

GPIO.setup (lietus_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 (auksts_LED_PIN, 100)

defGetLEDBrightness (temp):

iftemp <= 0:

galēji auksti = 100

atdzesēts = 100

karsts = 0

galēji karsts = 0

drukāt ("Īpaši auksts LED:"+str (galēji auksts))

drukāt ("Cold led:"+str (atdzesēts))

drukāt ("Extreme hot led"+str (extremehotled))

drukāt ("Karstais LED:"+str (karsts))

ExtremeColdLED.start (extremecoldled)

ColdLED.start (atdzesēts)

ExtremeHotLED.start (extremehotled)

HotLED.start (karsts)

eliftemp> = 100:

galēji auksts = 0

atdzesēts = 0

karsts = 100

galēji karsts = 100

drukāt ("Īpaši auksts LED:"+str (galēji auksts))

drukāt ("Cold led:"+str (atdzesēts))

drukāt ("Extreme hot led"+str (extremehotled))

drukāt ("Karstais LED:"+str (karsts))

ExtremeColdLED.start (extremecoldled)

ColdLED.start (atdzesēts)

ExtremeHotLED.start (extremehotled)

HotLED.start (karsts)

elif0 <temperatūra <= 30:

galējais aukstums = ģetextremeleftledintensity (temp) -100

atdzesēts = 100

karsts = 0

galēji karsts = 0

drukāt ("Īpaši auksts LED:"+str (galēji auksts))

drukāt ("Cold led:"+str (atdzesēts))

drukāt ("Extreme hot led"+str (extremehotled))

drukāt ("Karstais LED:"+str (karsts))

ExtremeColdLED.start (extremecoldled)

ColdLED.start (atdzesēts)

ExtremeHotLED.start (extremehotled)

HotLED.start (karsts)

elif100> temp> = 70:

galēji auksts = 0

atdzesēts = 0

karsts = 100

galējais karstums = ģeotekstramerightledintensity (temp) -100

drukāt ("Īpaši auksts LED:"+str (galēji auksts))

drukāt ("Cold led:"+str (atdzesēts))

drukāt ("Extreme hot led"+str (extremehotled))

drukāt ("Karstais LED:"+str (karsts))

ExtremeColdLED.start (extremecoldled)

ColdLED.start (atdzesēts)

ExtremeHotLED.start (extremehotled)

HotLED.start (karsts)

elif30 <temperatūra <50:

galēji auksts = 0

auksts = getmiddleleftledintensity (temp)

karsts = 100 atdzesēts

galēji karsts = 0

drukāt ("Īpaši auksts LED:"+str (galēji auksts))

drukāt ("Cold led:"+str (atdzesēts))

drukāt ("Extreme hot led"+str (extremehotled))

drukāt ("Karstais LED:"+str (karsts))

ExtremeColdLED.start (extremecoldled)

ColdLED.start (atdzesēts)

ExtremeHotLED.start (extremehotled)

HotLED.start (karsts)

elif50 <temperatūra <70:

karstā = getmiddlerightledintensity (temp)

galēji karsts = 0

atdzesēts = 100 karsts

galēji auksts = 0

drukāt ("Īpaši auksts LED:"+str (galēji auksts))

drukāt ("Cold led:"+str (atdzesēts))

drukāt ("Extreme hot led"+str (extremehotled))

drukāt ("Karstais LED:"+str (karsts))

ExtremeColdLED.start (extremecoldled)

ColdLED.start (atdzesēts)

ExtremeHotLED.start (extremehotled)

HotLED.start (karsts)

eliftemp == 50:

galēji auksts = 0

atdzesēts = 50

karsts = 50

galēji karsts = 0

drukāt ("Īpaši auksts LED:"+str (galēji auksts))

drukāt ("Cold led:"+str (atdzesēts))

drukāt ("Extreme hot led"+str (extremehotled))

drukāt ("Karstais LED:"+str (karsts))

ExtremeColdLED.start (extremecoldled)

ColdLED.start (atdzesēts)

ExtremeHotLED.start (extremehotled)

HotLED.start (karsts)

defGetRainLED (idCode):

ifCheckRain (idCode):

GPIO.izvade (lietus_LED_PIN, GPIO. HIGH)

cits:

GPIO izvade (lietus_LED_PIN, GPIO. LOW)

#Api informācija: nomainiet API atslēgu ar savu apewewe api atslēgu

openweather_api_key = "460a23f27ff324ef9ae743c7e9c32d7e"

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

drukāt ("Ierakstiet pilsētu!")

city_name = ievade ()

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

#Laika datu iegūšana

Atbilde = 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#Pārvērst par Fārenheitu

#LED/GPIO lietas

drukāt ("K:"+str (City_TemperatureK))

drukāt ("F:"+str (City_TemperatureF))

drukāt (WeatherID)

pamēģini:

kamēr (taisnība):

GetLEDBrightness (City_TemperatureF)

GetRainLED (WeatherID)

laiks. miegs (10)

izņemot tastatūras pārtraukumu:

atmest ()

skatīt rawRaspberryPIWeatherStation.py, ko mitina GitHub ar ❤

7. darbība: izveidošana un elektroinstalācija

Vau! Pēc visas šīs kodēšanas mēs nokļūstam ēkā, kas ir ievērojami vieglāk. Sakarā ar korona uzturēšanos mājās, mēs nevarējām piekļūt daudziem instrumentiem, kādus mēs gaidījām skolā. Tātad, šī daļa ir nedaudz vienkāršāka nekā mēs iecerējām. Arī specifika ir elastīga. Vispirms uz koka dēļa uzzīmējām taisnstūri. Konkrētajam izmēram patiesībā nav pārāk lielas nozīmes, jo tas vienkārši kalpo kā platforma LED un elektronikas ieslēgšanai.

Tad mēs urbām piecus 1/8 caurumus mūsu koka gabalā.

Pēc tam mēs no dēļa izgriezām taisnstūri, lai to izmantotu kā mūsu elektronikas platformu.

(Tas bija tad, kad mēs sākām; mēs atradām lielāku zāģi!)

Pēc tam mēs iespiežam LED anoda un katoda tapas caurumos; gaismas diodēm jāatrodas virspusē, spuldzēm izceļoties; sekojiet, kura kāja ir garāka un īsāka. Pēc tam mēs sākām lodēt kopā vadus. Vispirms mēs pielodējam rezistorus pie LED anoda kājas (garākā kāja).

Pēc tam mēs pielodējam gaismas diožu katoda kājas vienā vara vadā, ko izmantosim kā zemējumu. Tam vajadzētu izskatīties šādi.

Pēc tam mēs pielodējam sieviešu-vīriešu džemperu kabeļu vīriešu galus līdz katra rezistora un vara zemējuma stieples galiem. Kad mēs to izdarīsim, mēs varam sākt pieslēgt vadus aveņu PI GPIO tapām. Šeit ir diagramma! Tomēr ņemiet vērā, ka tapas ir tās, kuras ir iekļautas iepriekš pieminētajā kodā.

Kad viss ir savienots, tagad viss, kas jums jādara, ir iegūt Python failu aveņu Pi un atvērt termināli. palaidiet "python3 RaspberryPIWeatherStation.py" un pēc tam rīkojieties, kā parādīts.

8. solis: demonstrācija un secinājumi

Paldies, ka lasījāt līdz galam! Es pievienošu pitona skriptu zemāk! Ja būtu lietas, ko mēs varētu pievienot, tas droši vien būtu…

1. Atbalsts dažādiem ievades veidiem (pilsētas, ģeogrāfiskie punkti utt.)

2. Atbalsts vairāk laika apstākļu informācijas

3. Pievienojiet nelielu ekrānu, lai parādītu informāciju

Paziņojiet mums savas domas! Šis bija jautrs projekts, ko veidot. Mēs daudz uzzinājām par pieprasījumiem un interneta dokumentu iegūšanu, izmantojot python, kā arī daudz uzzinājām par lodēšanas izmantošanu.