Raspberry PI LED orų stotis: 8 žingsniai

2024 Autorius: John Day | [email protected]. Paskutinį kartą keistas: 2024-01-30 10:45

Mes sukūrėme Raspberry PI Weather LED stotį. Jis parodo vartotojui, koks karštas ir šaltas yra miestas, apšviesdamas ir pritemdydamas šviesos diodus. Tai taip pat paskatino juos pasakyti, ar lyja, ar ne, mieste, kurį jie įvedė.

Sukūrė Michaelas Andrewsas ir Tio Marello.

Prekės

Įrankiai

1. Lituoklis
2. „Dremel“
3. Pjūklas

Medžiagos

1. Aviečių Pi 3 B+ ~ 40 dolerių ~ 30 dolerių
2. „Jumper“laidai nuo patelių iki vyrų ~ 7 doleriai
3. 3 mėlyni ir 2 raudoni LED diodai ~ 11 dolerių
4. 100 omų rezistoriai ~ 13 dolerių
5. 4 x 4 x 1/4 medžio lentos ~ 5 doleriai
6. Lydmetalis ~ 10 dolerių
7. Varinė viela ~ 5 doleriai

1 žingsnis: kodavimas kaip problemos sprendimas

Kodavimas yra problemų sprendimas

Taigi, kokia yra mūsų projekto problema mūsų projekte? Mūsų problema yra gauti orų duomenis ir tada naudoti tuos duomenis, kad mūsų šviesos diodai pasakytų, ar jie išjungti, ar įjungti. Taigi tai suskirsto mūsų problemą į tris sritis.

1. Oro duomenų gavimas

2. Tų duomenų naudojimas

3. Šviesos diodų naudojimas

Tačiau kalba, kurią naudojome šiam projektui, „Python“, ir aparatinė įranga, su kuria ji veikia, „Python“suteikia mums paprastą būdą šiems tikslams pasiekti.

Taigi, pradėkime nuo pirmosios problemos - gauti orų duomenis.

2 veiksmas: kodavimas: orų duomenų gavimas

Python pats negali gauti orų duomenų. Norėdami gauti orų duomenis, turime importuoti du įrankius ir išorinę paslaugą. Norėdami tai padaryti, mes naudojame tris įrankius.

1. Užklausos, python modulis, leidžiantis įbrėžti žiniatinklį

2. Json, python modulis, leidžiantis naudoti JSON failo formatą

3. „OpenWeather“- svetainė, kuri gali mums pateikti orų duomenis

Taigi, du modulius pristatome rašydami šį kodą mūsų python scenarijaus viršuje.

importo užklausų

importuoti json

Tačiau prieš naudodami šiuos įrankius, turime naudoti „Openweather“. Norėdami tai padaryti, turime sukurti paskyrą jų svetainėje ir gauti API raktą. Vykdykite jų svetainėje pateiktas instrukcijas ir gausite raidžių ir skaičių eilutę, kuri leis mums naudotis jų paslaugomis. Kaip?

openweather_api_key = "260a23f27f5324ef2ae763c779c32d7e" #Our API raktas (netikras)

base_call = "https://api.openweathermap.org/data/2.5/weather?q=" #OpenWeather skambutis #Čia gauname vartotojo miestą teksto spausdinimo forma („Įveskite miestą!“) city_name = input () #Čia mes surinkome adresą, kurį prijungsime prie užklausų. Gauti orų duomenis Response = request.get (full_call) WeatherData = Response.json () #JSON failai turi skirtingus kintamuosius, kuriuos galime pasiekti naudodami šią sintaksę #Čia mes gauname orų ID ir temperatūrą Kelvine miesto, kurį vartotojas įvedė WeatherID = WeatherData ["weather"] [0] ["id"] City_TemperatureK = WeatherData ["main"] ["temp"]

Čia mes turime kodą, kuris suteikia mums orų duomenis. Užklausos request.get pavidalu užima svetainės adresą ir grąžina mums failą iš tos svetainės. „OpenWeather“suteikia mums adresą, kuriuo galime paskambinti, kad pateiktume orų duomenis „json“pavidalu. Mes surenkame adresą, kurį prijungiame prie užklausų, ir atgauname „json“failą. Tada sukuriame du kintamuosius ir priskiriame juos vartotojo miesto temperatūrai ir oro sąlygoms.

Taigi dabar su šiuo kodu turime du kintamuosius. Turime weatherID ir Kelvino temperatūrą

3 žingsnis: kodavimas: šių duomenų naudojimas

Dabar, kai turime šiuos du kintamuosius, turime juos paruošti naudoti mūsų šviesos diodams. Šiuo aspektu mums nereikia importuoti jokių modulių.

Pirma, mes konvertuojame kelviną į Fahrenheitą.

Tai darome sukurdami kintamąjį pagal šią sintaksę

Miesto_temperatūraF = (Miesto_temperatūraK - 273)*1,8 + 32

kuris konvertuoja iš Kelvino į Farenheitą (tai tikrai konvertuoja iš K -> C -> F)

Kitas yra mūsų weatherID. „WeatherID“yra „Openweather“pateiktas ID, nurodantis miesto oro sąlygas.

openweathermap.org/weather-conditions Čia yra jų sąrašas.

Pastebėjome, kad viskas, mažesnė nei 700, buvo kažkokie krituliai, todėl tik patikrinome, ar kodas yra žemiau 700, kad pamatytume, ar nelyja.

def CheckRain (IdCode): jei IdCode <700: grąžinkite True else: grąžinkite False

Dėl to mes turime du kintamuosius, kurie bus paruošti naudoti su mūsų aviečių PI kaiščiais ir LED diodais.

4 žingsnis: kodavimas: RPi. GPIO ir LED diodų naudojimas

„RaspberryPi“komplektuojamas su kištukinių kaiščių rinkiniu, kuriuo galime bendrauti su daugybe elektros komponentų, kurie šiuo atveju yra LED diodai; jis panašus į „Arduino“ir jo sistemą. Tačiau „Raspberry PI“yra bendrosios paskirties kompiuteris, o ne toks mikrovaldiklis kaip „Arduino“. Taigi, norėdami juos naudoti, turime šiek tiek daugiau dirbti. Tai apima „Raspberry Pi“kaiščių nustatymą. Mes tai darome naudodami šį kodą.

importuokite RPi. GPIO kaip GPIO #Importuojame modulį, kad galėtume jį naudoti

#Nustatykite kaiščiusGPIO.setmode (GPIO. BCM) GPIO.setwarnings (klaidinga)

#Kištukai, prie kurių prijungti šviesos diodai. Jie gali skirtis, jei jį kuriate, todėl būtinai palyginkite ir prireikus pakeiskite

„Extreme_Hot_LED_PIN“= 26 karšti_LED_PIN = 16

„Extreme_Cold_LED_PIN“= 5

Šaltas_LED_PIN = 6

Lietus_LED_PIN = 23

#Mes einame per kiekvieną kaištį, naudodami komandą.setup, įvesdami jo numerį ir nustatydami jį kaip išvesties kaištį

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 (Hot_LED_PIN, GPIO. OUT) GPIO.setup (Extreme_Hot_)

Tačiau šis kodas leistų mums naudoti tik dvi būsenas su šviesos diodais, tai yra įjungti ir išjungti. Tačiau mums to reikia, kad galėtume pritemdyti šviesas. Norėdami tai padaryti, mes naudojame pulso pločio moduliaciją.

Naudojant pulso pločio moduliaciją

Impulso pločio moduliacija leidžia mums išvesti analoginį signalą naudojant skaitmeninį kaištį. Iš esmės jis įjungia ir išjungia signalo šaltinį dideliu greičiu, kuris vidutiniškai pasiekia tam tikrą įtampą. „RPi. GPIO“leidžia mums tai naudoti, nors ir su papildomu kodu.

#Mes sukuriame keturis kontaktinius objektus naudodami komandą GPIO. PWM, kuri priima kanalo numerį

#Antrasis skaičius reiškia, kiek kartų jis atnaujinamas per 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 („Cold_LED_PIN“, 100)

Kitame žingsnyje turėsite žinoti, kaip mes atnaujiname šiuos kaiščius.

Mes atnaujiname kaiščius naudodami komandą

„ExtremeColdLED.start“(x) „ColdLED.start“(x)

„ExtremeHotLED.start“(x)

„HotLED.start“(x)

x šiuo atveju būtų darbo ciklas, kuris nustato, kiek jis impulsuoja. Jis svyruoja nuo 0 iki 100, todėl kitą kodą turime pagrįsti tuo faktu.

5 žingsnis: kodavimas: šviesos diodų ryškumo gavimas

Kadangi turime keturis skirtingus šviesos diodus, norime juos uždegti priklausomai nuo to, kaip. šalta ar karšta, tai yra vartotojo mieste. Mes nusprendėme turėti keturis etapus.

#Funkcijos

def getmiddleleftledensensity (TemperatureinF): #Kairė lygtis: y = -(50/20) x + 175 #Teisinga lygtis: y = (50/20) x -75 grįžimas -(50/20)*Temperatūra F + 175

vidinio apšvietimo jautrumo riba (temperatūra F):

#Kairė lygtis: y = - (50/20) x + 175 #Teisinga lygtis: y = (50/20) x - 75 grįžimas (50/20)*Temperatūra F - 75

def getextremeleftledintensity (temperatūra F):

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

grįžimas -(100/30)*Temperatūra F + 200

def getextremerightlingintensity (TemperatūraF):

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

grįžimas (100/30)*Temperatūra F - (400/3)

#LED lempučių nustatymas

def GetLEDBrightness (temperatūra):

jei temperatūra <= 0: ekstremaliai šalta = 100 šalta = 100 karšta = 0 kraštutinė temperatūra = 0

spausdinti („Ekstremaliai šalta lemputė:“+ str (ekstremaliai šalta))

print ("Šaltasis ledas:" + str.

„ExtremeColdLED.start“(„extremecoldled“)

„ColdLED.start“(šalta)

„ExtremeHotLED.start“(„extremehotled“)

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

spausdinti („Ekstremaliai šalta lemputė:“+ str (ekstremaliai šalta))

print ("Šaltasis ledas:" + str.

„ExtremeColdLED.start“(„extremecoldled“)

„ColdLED.start“(šalta)

„ExtremeHotLED.start“(„extremehotled“)

„HotLED.start“(karštas) elifas 0 <temp <= 30: extremecoldled = getextremeleftledintensity (temp) - 100 šalta = 100 karštųjų = 0 itin karšta = 0

spausdinti („Ekstremaliai šalta lemputė:“+ str (ekstremaliai šalta))

print ("Šaltas ledas:" + str.

„ExtremeColdLED.start“(„extremecoldled“)

„ColdLED.start“(šalta)

„ExtremeHotLED.start“(„extremehotled“)

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

spausdinti („Ekstremaliai šalta lemputė:“+ str (ekstremaliai šalta))

print ("Šaltasis ledas:" + str.

„ExtremeColdLED.start“(„extremecoldled“)

„ColdLED.start“(šalta)

„ExtremeHotLED.start“(„extremehotled“)

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

spausdinti („Ekstremaliai šalta lemputė:“+ str (ekstremaliai šalta))

print ("Šaltasis ledas:" + str.

„ExtremeColdLED.start“(„extremecoldled“)

„ColdLED.start“(šalta)

„ExtremeHotLED.start“(„extremehotled“)

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

šalta = 100 - karšta

ekstremaliai šalta = 0

spausdinti („Ekstremaliai šalta lemputė:“+ str (ekstremaliai šalta))

print ("Šaltasis ledas:" + str.

„ExtremeColdLED.start“(„extremecoldled“)

„ColdLED.start“(šalta)

„ExtremeHotLED.start“(„extremehotled“)

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

spausdinti („Ekstremaliai šalta lemputė:“+ str (ekstremaliai šalta))

print ("Šaltas ledas:" + str.

„ExtremeColdLED.start“(„extremecoldled“)

„ColdLED.start“(šalta)

„ExtremeHotLED.start“(„extremehotled“)

„HotLED.start“(karštas)

Gerai, šis kodo skyrius yra tikrai ilgas. Tai taip pat gana sunku paaiškinti. Iš esmės aukščiau pateiktas kodas žiūri į Farenheito temperatūrą ir nustato, ar jis yra diapazonų rinkinyje. Priklausomai nuo diapazonų, jis pateikia skaičių kiekvienam šviesos diodui ir jo ryškumą, o tada nustato ryškumą, iškviesdamas komandą start (). Tai greitas paaiškinimas. Jei to pakanka, rekomenduoju pereiti prie kito žingsnio, bet jei norite pamatyti ilgą ir varginantį paaiškinimą, skaitykite toliau.

Kai programavome, nusprendėme, kad lengviausias būdas gauti vertę iš temperatūros yra matematinės funkcijos forma. Taigi, mes sukūrėme grafiką „GeoGebra“, kad parodytume, koks yra mūsų temperatūros ir mūsų šviesos ryškumo santykis; priežastis, dėl kurios ji viršija 100, yra ta, kad papildoma suma patenka į antrąjį LED. Tačiau susidūrėme su viena funkcija, kad visi šie taškai būtų susieti su viena funkcija. Mes manėme, kad galime naudoti parabolę, bet nusprendėme tiesiog pasitenkinti tam, kad panaudotume keletą teiginių. Iš esmės visas šis kodas yra vienetinė funkcija.

Funkcijos viršuje yra atitinkama linijų lygtis. Kai nustatysime, kur grafike yra temperatūra, paleidžiame ją per šią funkciją, gauname ryškumą ir perduodame ant šviesos diodų.

6 žingsnis: kodavimas: paskutiniai žingsniai

Galiausiai pridedame šį teiginį pabaigoje.

bandyti:

o (tiesa): GetLEDBrightness (City_TemperatureF) GetRainLED (WeatherID) time.sleep (10), išskyrus klaviatūrąInterrupt: quit ()

Išbandymo ir išrašų teiginiai leidžia mums išeiti iš kodo naudojant spartųjį klavišą; bet kuriuo atveju, norėdami iš naujo paleisti kodą, turėtume išjungti „Raspberry Pi“. Tada mes turime laiko ciklą, kuris tęsiasi amžinai. Atnaujiname šviesos diodus, taip pat atnaujiname lietaus šviesos diodus. Sustojame dešimt sekundžių; „OpenWeather“leidžia tik 60 skambučių per minutę, o 10 sekundžių yra daug atnaujinimų.

Ir tuo mūsų kodas baigtas. Žemiau yra baigtas kodas.

RaspberryPIWeatherStation.py

importo prašymai

importRPi. GPIOasGPIO

importjson

importo laikas

#Openweather idCodes mažiau nei 700 yra visi krituliai

defCheckRain (IdCode):

ifIdCode <700:

returnTiesa

Kitas:

returnFalse

vidutiniškai kairysis vidinis jautrumas (temperatūra F):

#Kairė lygtis: y =-(50/20) x + 175

#Teisinga lygtis: y = (50/20) x - 75

grįžimas- (50/20)*Temperatūra F+175

vidinio šviesos intensyvumo mažinimas (temperatūra F):

#Kairė lygtis: y =-(50/20) x + 175

#Teisinga lygtis: y = (50/20) x - 75

grįžimas (50/20)*F-75 temperatūra

defgetext kraštutinis kairės pusės intensyvumas (temperatūra F):

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

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

grįžimas (100/30)*Temperatūra F+200

defgetextremerightlingintensity (Temperatūra F):

# Kairė lygtis: y = -(100/30) x + 200

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

grįžimas (100/30)*Temperatūra F- (400/3)

#GPIO sąranka

GPIO.setmode (GPIO. BCM)

GPIO.setwarnings (klaidinga)

#Smeigtukai

„Extreme_Hot_LED_PIN“= 26

„Hot_LED_PIN“= 16

„Extreme_Cold_LED_PIN“= 5

Šaltas_LED_PIN = 6

Lietus_LED_PIN = 23

#Pin sąranka

GPIO.setup (lietus_LED_PIN, GPIO. OUT)

GPIO.setup (Extreme_Cold_LED_PIN, GPIO. OUT)

GPIO.setup (šaltas_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 (temperatūra):

iftemp <= 0:

ekstremaliai šalta = 100

atšaldytas = 100

įkaitęs = 0

ekstremalus = 0

spausdinti („Ekstremaliai šalta lemputė:“+str (ekstremaliai šalta))

spausdinti („Šaltas ledas:“+str (šalta))

spausdinti („Extreme hot led“+str (extremehotled))

spausdinti („Karštas ledas:“+str (karšta))

„ExtremeColdLED.start“(„extremecoldled“)

„ColdLED.start“(šalta)

„ExtremeHotLED.start“(„extremehotled“)

„HotLED.start“(karštas)

eliftemp> = 100:

ekstremaliai šalta = 0

atšaldytas = 0

karštas = 100

ekstremalus = 100

spausdinti („Ekstremaliai šalta lemputė:“+str (ekstremaliai šalta))

spausdinti ("Šaltas ledas:"+str (šalta))

spausdinti („Extreme hot led“+str (extremehotled))

spausdinti („Karštas ledas:“+str (karšta))

„ExtremeColdLED.start“(„extremecoldled“)

„ColdLED.start“(šalta)

„ExtremeHotLED.start“(„extremehotled“)

„HotLED.start“(karštas)

elif0 <temperatūra <= 30:

ekstremaliai šalta = getekstremusis kairysisintensyvumas (temperatūra) -100

atšaldytas = 100

įkaitęs = 0

ekstremalus = 0

spausdinti („Ekstremaliai šalta lemputė:“+str (ekstremaliai šalta))

spausdinti („Šaltas ledas:“+str (šalta))

spausdinti („Extreme hot led“+str (extremehotled))

spausdinti („Karštas ledas:“+str (karšta))

„ExtremeColdLED.start“(„extremecoldled“)

„ColdLED.start“(šalta)

„ExtremeHotLED.start“(„extremehotled“)

„HotLED.start“(karštas)

elif100> temp> = 70:

ekstremaliai šalta = 0

atšaldytas = 0

karštas = 100

extremehotled = getextremerightledintensity (temp) -100

spausdinti („Ekstremaliai šalta lemputė:“+str (ekstremaliai šalta))

spausdinti ("Šaltas ledas:"+str (šalta))

spausdinti („Extreme hot led“+str (extremehotled))

spausdinti („Karštas ledas:“+str (karšta))

„ExtremeColdLED.start“(„extremecoldled“)

„ColdLED.start“(šalta)

„ExtremeHotLED.start“(„extremehotled“)

„HotLED.start“(karštas)

elif30 <temperatūra <50:

ekstremaliai šalta = 0

šaltas = getmiddleleftledintensity (temp)

karšta = 100 šalta

ekstremalus = 0

spausdinti („Ekstremaliai šalta lemputė:“+str (ekstremaliai šalta))

spausdinti („Šaltas ledas:“+str (šalta))

spausdinti („Extreme hot led“+str (extremehotled))

spausdinti („Karštas ledas:“+str (karšta))

„ExtremeColdLED.start“(„extremecoldled“)

„ColdLED.start“(šalta)

„ExtremeHotLED.start“(„extremehotled“)

„HotLED.start“(karštas)

elif50 <temperatūra <70:

karšta = gaukite vidutinį šviesos intensyvumą (temperatūra)

ekstremalus = 0

atšaldytas = 100 karštų

ekstremaliai šalta = 0

spausdinti („Ekstremaliai šalta lemputė:“+str (ekstremaliai šalta))

spausdinti ("Šaltas ledas:"+str (šalta))

spausdinti („Extreme hot led“+str (extremehotled))

spausdinti („Karštas ledas:“+str (karšta))

„ExtremeColdLED.start“(„extremecoldled“)

„ColdLED.start“(šalta)

„ExtremeHotLED.start“(„extremehotled“)

„HotLED.start“(karštas)

eliftemp == 50:

ekstremaliai šalta = 0

atšaldytas = 50

įkaitęs = 50

ekstremalus = 0

spausdinti („Ekstremaliai šalta lemputė:“+str (ekstremaliai šalta))

spausdinti („Šaltas ledas:“+str (šalta))

spausdinti („Extreme hot led“+str (extremehotled))

spausdinti („Karštas ledas:“+str (karšta))

„ExtremeColdLED.start“(„extremecoldled“)

„ColdLED.start“(šalta)

„ExtremeHotLED.start“(„extremehotled“)

„HotLED.start“(karštas)

defGetRainLED (idCode):

ifCheckRain (idCode):

GPIO išėjimas (lietus_LED_PIN, GPIO. HIGH)

Kitas:

GPIO išėjimas (lietus_LED_PIN, GPIO. LOW)

#Api informacija: pakeiskite API raktą naudodami „oepnweather“API raktą

openweather_api_key = "460a23f27ff324ef9ae743c7e9c32d7e"

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

spausdinti („Įveskite miestą!“)

miesto_pavadinimas = įvestis ()

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

#Gaunami orų duomenys

Atsakymas = 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#Konvertuoti į Farenheitą

#LED/GPIO daiktai

spausdinti („K:“+str („City_TemperatureK“))

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

spausdinti (WeatherID)

bandyti:

o (tiesa):

„GetLEDBrightness“(„City_TemperatureF“)

„GetRainLED“(„WeatherID“)

laikas. miegas (10)

išskyrus klaviatūros pertrauką:

mesti ()

peržiūrėti rawRaspberryPIWeatherStation.py, kurį su ❤ priglobia „GitHub“

7 žingsnis: statymas ir prijungimas

Vau! Po viso to kodavimo mes pasiekiame pastatą, kuris yra žymiai lengvesnis. Dėl koronos buvimo namuose užsakymų negalėjome pasinaudoti daugeliu įrankių, kurių tikėjomės turėti mokykloje. Taigi, ši dalis yra šiek tiek paprastesnė, nei mes norėjome. Pati specifika taip pat yra lanksti. Pirmiausia ant medinės lentos nupiešėme stačiakampį. Konkretus dydis iš tikrųjų neturi per daug reikšmės, nes jis tiesiog tarnauja kaip platforma lempoms ir elektronikai įjungti.

Tada mes išgręžėme penkis 1/8 skyles savo medžio gabalėlyje.

Tada iš lentos iškirpome stačiakampį, kuris bus naudojamas kaip mūsų elektronikos platforma.

(Tai buvo tada, kai pradėjome; radome didesnį pjūklą!)

Tada į skylutes įstumiame LED anodo ir katodo kaiščius; šviesos diodai turėtų būti dedami ant viršaus, jų lemputės išlindusios; stebėkite, kuri koja yra ilgesnė ir trumpesnė. Tada mes pradėjome lituoti laidus. Pirmiausia lituojame rezistorius prie šviesos diodo anodo kojos (ilgesnės kojos).

Tada lituojame šviesos diodų katodines kojas į vieną varinę vielą, kurią naudosime kaip įžeminimą. Tai turėtų atrodyti taip.

Kai tai padarysime, lituosime jungiamųjų kabelių patelių galus prie kiekvieno rezistoriaus ir vario įžeminimo laido galų. Kai tai padarysime, galime pradėti prijungti laidus prie aviečių PI GPIO kaiščių. Štai diagrama! Tačiau atkreipkite dėmesį, kad smeigtukai yra tie, kurie buvo nurodyti anksčiau minėtame kode.

Kai viskas bus prijungta, dabar viskas, ką jums reikia padaryti, yra įkelti „Python“failą į aviečių Pi ir atidaryti terminalą. paleiskite „python3 RaspberryPIWeatherStation.py“ir darykite taip, kaip parodyta.

8 žingsnis: demonstravimas ir išvados

Ačiū, kad perskaitėte visą kelią! Pridedu python scenarijų žemiau! Jei būtų dalykų, kuriuos galėtume pridėti, tai tikriausiai būtų…

1. Parama įvairiems įvesties tipams (miestai, geografiniai taškai ir kt.)

2. Daugiau informacijos apie orus palaikymas

3. Pridėkite nedidelį ekraną informacijai rodyti

Praneškite mums savo mintis! Tai buvo įdomus projektas. Mes daug sužinojome apie užklausas ir interneto dokumentų gavimą naudojant „python“, taip pat daug sužinojome apie litavimo naudojimą.