ჟოლოს PI LED ამინდის სადგური: 8 ნაბიჯი

2024 ავტორი: John Day | [email protected]. ბოლოს შეცვლილი: 2024-01-30 10:16

ჩვენ შევქმენით ჟოლოს PI ამინდის LED სადგური. ის მომხმარებელს ეუბნება, რამდენად ცხელია და ცივია ქალაქი განათებით და დაბნელებით. მას ასევე აქვს უფლება უთხრას მათ, წვიმს თუ არა წვიმა იმ ქალაქში, სადაც მათ ჩაწერეს.

შექმნილია მაიკლ ენდრიუსისა და ტიო მარელოს მიერ.

მარაგები

ინსტრუმენტები

1. გასაყიდი რკინა
2. დრემელი
3. დაინახა

მასალები

1. ჟოლო Pi 3 B+ ~ 40 დოლარი ~ 30 დოლარი
2. ქალი და მამაკაცი მხტუნავები 7 ფუნტი სტერლინგი
3. 3 ლურჯი და 2 წითელი LED დიოდი ~ 11 დოლარი
4. 100 Ohm რეზისტორების 13 დოლარი
5. 4 x 4 x 1/4 ხის ფიცარი ~ 5 დოლარი
6. გამდნარი 10 დოლარი
7. სპილენძის მავთულები ~ 5 დოლარი

ნაბიჯი 1: კოდირება როგორც პრობლემის გადაჭრა

კოდირება არის პრობლემის გადაჭრა

რა არის ჩვენი პრობლემა ჩვენს პროექტში? ჩვენი პრობლემაა ამინდის მონაცემების მიღება და შემდეგ ამ მონაცემების გამოყენება ჩვენი LEDS- ის გასაგებად, გამორთულია თუ ჩართული. ასე რომ, ეს ჩვენი პრობლემა სამ სფეროდ იყოფა.

1. ამინდის მონაცემების მიღება

2. ამ მონაცემების გამოყენება

3. LEDS- ის გამოყენება

ამასთან, ენა, რომელიც ჩვენ გამოვიყენეთ ამ პროექტისთვის, პითონი და აპარატურა, რომელზეც ის მუშაობს, პითონი, გვაძლევს ამ მიზნების მისაღწევად მარტივ გზას.

ასე რომ, ჩვენ დავიწყებთ პირველი პრობლემით, ამინდის მონაცემების მიღებით.

ნაბიჯი 2: კოდირება: ამინდის მონაცემების მიღება

პითონი თავისთავად ვერ იღებს ამინდის მონაცემებს. ამინდის მონაცემების მისაღებად ჩვენ უნდა შემოვიტანოთ ორი ინსტრუმენტი, ასევე გარე სერვისი. ამისათვის ჩვენ ვიყენებთ სამ ინსტრუმენტს.

1. მოთხოვნები, პითონის მოდული, რომელიც იძლევა ქსელის გადაღების საშუალებას

2. Json, პითონის მოდული, რომელიც საშუალებას გვაძლევს გამოვიყენოთ JSON ფაილის ფორმატი

3. OpenWeather, ვებგვერდი, რომელსაც შეუძლია მოგვაწოდოს ამინდის მონაცემები

ამრიგად, ჩვენ მოვიყვანთ ორ მოდულს ამ კოდის დაწერისას ჩვენი პითონის სკრიპტის ზედა ნაწილში.

იმპორტის მოთხოვნები

json იმპორტი

სანამ ამ ინსტრუმენტებს გამოვიყენებთ, ჩვენ უნდა გამოვიყენოთ Openweather. ამისათვის ჩვენ უნდა შევქმნათ ანგარიში მათ საიტზე და მივიღოთ API გასაღები. მიჰყევით მათ ვებგვერდზე მითითებებს და თქვენ მიიღებთ ასოებისა და რიცხვების სტრიქონს, რაც საშუალებას მოგვცემს გამოვიყენოთ მათი სერვისი. Როგორ?

openweather_api_key = "260a23f27f5324ef2ae763c779c32d7e" #ჩვენი API გასაღები (არარეალური)

base_call = "https://api.openweathermap.org/data/2.5/weather?q=" #OpenWeather Call #აქ ჩვენ ვიღებთ მომხმარებლის ქალაქს ტექსტის ბეჭდვის სახით ("აკრიფეთ ქალაქი!") city_name = input () #აქ ჩვენ შევიკრიბეთ მისამართი, რომელსაც ჩვენ ჩავრთავთ მოთხოვნაში. მივიღოთ ამინდის მონაცემები full_call = base_call+city_name+"& appid ="+openweather_api_key #საბოლოოდ ჩვენ ვიძახებთ მოთხოვნებს. მიიღეთ ჩვენი მისამართი, შემდეგ კი მას json ფაილში ვაქცევთ პასუხი = request.get (full_call) WeatherData = Response.json () #JSON ფაილები შეიცავს სხვადასხვა ცვლადს, რომლის წვდომაც ჩვენ შეგვიძლია ამ სინტაქსის გამოყენებით #აქ მივიღებთ ამინდის ID- ს და ტემპერატურას ქალაქ კელვინში, მომხმარებლის მიერ აკრეფილი WeatherID = WeatherData ["ამინდი"] [0] ["id"] City_TemperatureK = ამინდის მონაცემები ["მთავარი"] ["ტემპი"]

აქ ჩვენ გვაქვს კოდი, რომელიც გვაძლევს ამინდის მონაცემებს. მოთხოვნები, request.get სახით, იღებს ვებსაიტის მისამართს და გვაძლევს ამ ვებ – გვერდის ფაილს უკან. OpenWeather გვაძლევს მისამართს, რომ დარეკოთ და მოგვაწოდოს ამინდის მონაცემები json– ის სახით. ჩვენ ვაგროვებთ მისამართს, რომელსაც ვუერთებთ მოთხოვნებს და ვიღებთ json ფაილს უკან. შემდეგ ჩვენ ვქმნით ორ ცვლადს და ვანიჭებთ მათ მომხმარებლის ტემპერატურასა და ამინდის ამინდს.

ახლა, ამ კოდთან ერთად, ჩვენ გვაქვს ორი ცვლადი. ჩვენ გვაქვს ამინდის ID და ტემპერატურა კელვინში

ნაბიჯი 3: კოდირება: ამ მონაცემების გამოყენება

ახლა, როდესაც ჩვენ გვაქვს ეს ორი ცვლადი, ჩვენ უნდა მოვამზადოთ ისინი ჩვენი LEDS– ებისთვის გამოსაყენებლად. ამ თვალსაზრისით, ჩვენ არ გვჭირდება რაიმე მოდულის იმპორტი ამისათვის.

პირველ რიგში, ჩვენ გადავაქციეთ კელვინი ფარენჰეიტზე.

ჩვენ ამას ვაკეთებთ ამ სინტაქსით ცვლადის შექმნით

City_TemperatureF = (City_TemperatureK - 273)*1.8 + 32

რომელიც გადადის კელვინიდან ფარენჰეიტში (რაც ნამდვილად გარდაქმნის K -> C -> F)

შემდეგი არის ჩვენი ამინდის ID. WeatherID არის ID, რომელსაც Openweather გვაწვდის და გვეუბნება ქალაქის ამინდის პირობებზე.

openweathermap.org/weather-conditions აქ არის მათი ჩამონათვალი.

ჩვენ შევამჩნიეთ, რომ ყველაფერი 700 ნომრის ქვემოთ იყო ერთგვარი ნალექი, ამიტომ ჩვენ უბრალოდ შევამოწმეთ არის თუ არა კოდი 700 ქვემოთ, რომ ნახოთ თუ წვიმს.

def CheckRain (IdCode): თუ IdCode <700: დაბრუნება True other: დაბრუნება False

ამასთან, ჩვენ გვაქვს ჩვენი ორი ცვლადი, რომლებიც მომზადებულია ჟოლოს PI ქინძისთავებისა და LED დიოდების გამოსაყენებლად.

ნაბიჯი 4: კოდირება: RPi. GPIO და LED დიოდების გამოყენება

RaspberryPi– ს გააჩნია მამრობითი ქინძისთავების ნაკრები, რომელიც ჩვენ შეგვიძლია გამოვიყენოთ უამრავ ელექტრო კომპონენტთან კომუნიკაციისთვის, რაც ამ შემთხვევაში არის LED დიოდები; ის არდუინოს და მის სისტემას ჰგავს. თუმცა, Raspberry PI არის ზოგადი დანიშნულების კომპიუტერი, განსხვავებით მიკროკონტროლერისგან, როგორიცაა Arduino. ამრიგად, ჩვენ უნდა გამოვიყენოთ ცოტა მეტი სამუშაო, რომ გამოვიყენოთ ისინი. ეს შედგება ჟოლოს პიზე ქინძისთავების დაყენებისგან. ჩვენ ამას ვაკეთებთ ამ კოდის გამოყენებით.

იმპორტი RPi. GPIO როგორც GPIO #ჩვენ იმპორტის მოდული ასე რომ ჩვენ შეგვიძლია გამოვიყენოთ იგი

#დააყენეთ ქინძისთავები GPIO.setmode (GPIO. BCM) GPIO.setwarnings (false)

#ქინძისთავები, რომლებიც LED- ებს ჩართულია. ეს შეიძლება იყოს განსხვავებული, თუ თქვენ ააშენებთ მას, ასე რომ დარწმუნდით, რომ შეადაროთ და შეცვალოთ საჭიროების შემთხვევაში

Extreme_Hot_LED_PIN = 26 ცხელი_LED_PIN = 16

ექსტრემალური_ ცივი_LED_PIN = 5

ცივი_LED_PIN = 6

წვიმა_LED_PIN = 23

#ჩვენ გავდივართ ყველა პინზე,.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. POT)

თუმცა, ეს კოდი გვაძლევს მხოლოდ ორი მდგომარეობის გამოყენებას led- ით, ანუ ჩართვით და გამორთვით. თუმცა, ჩვენ გვჭირდება, რომ შევძლოთ შუქის ჩაქრობა. ამისათვის ჩვენ ვიყენებთ პულსის სიგანის მოდულაციას.

პულსის სიგანის მოდულაციის გამოყენება

პულსის სიგანის მოდულაცია გვაძლევს საშუალებას გამოვიტანოთ ანალოგური სიგნალი ციფრული პინის გამოყენებით. არსებითად, ის ჩართავს და გამორთავს სიგნალის წყაროს მაღალი სიჩქარით, რაც საშუალოდ გამოდის გარკვეულ ძაბვამდე. RPi. GPIO საშუალებას გვაძლევს გამოვიყენოთ ეს, თუმცა დამატებითი კოდით.

#ჩვენ ვქმნით ოთხ პინის ობიექტს GPIO. PWM ბრძანების გამოყენებით, რომელიც იღებს არხის ნომერს

#მეორე ნომერი არის რამდენჯერ განახლდება ის წამში

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)

შემდეგი ნაბიჯისათვის თქვენ უნდა იცოდეთ როგორ განვაახლებთ ამ ქინძისთავებს.

ჩვენ ვაახლებთ ქინძისთავებს ბრძანების გამოყენებით

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

ExtremeHotLED. დაწყება (x)

HotLED. დაწყება (x)

x ამ შემთხვევაში იქნება მოვალეობათა ციკლი, რომელიც განსაზღვრავს რამდენს გამოიტოვებს. ის მერყეობს 0-100-დან, ამიტომ ჩვენ უნდა დავამყაროთ შემდეგი კოდი ამ ფაქტზე.

ნაბიჯი 5: კოდირება: მიიღეთ LED სიკაშკაშე

იმის გამო, რომ ჩვენ გვაქვს ოთხი განსხვავებული led, ჩვენ გვსურს მათი განათება იმის მიხედვით, თუ როგორ. ცივი ან ცხელი ის არის მომხმარებლის ქალაქში. ჩვენ გადავწყვიტეთ, რომ ოთხი ეტაპი გვქონდეს ლიდერისთვის.

#ფუნქციები

def getmiddleleftledintensity (TemperatureinF): #მარცხენა განტოლება: y = -(50/20) x + 175 #მარჯვენა განტოლება: y = (50/20) x -75 დაბრუნება -(50/20)*ტემპერატურა F + 175

def getmiddlerightledintensity (TemperatureinF):

#მარცხენა განტოლება: y = - (50/20) x + 175 #სწორი განტოლება: y = (50/20) x - 75 დაბრუნება (50/20)*ტემპერატურა F - 75

def getextremeleftledintensity (TemperatureinF):

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

დაბრუნება -(100/30)*ტემპერატურა F + 200

defextremerightledintensity (TemperatureinF):

# მარცხენაგანათლება: y = - (100/30) x + 200 # მარჯვენა

დაბრუნება (100/30)*ტემპერატურა F - (400/3)

#LED განათების დაყენება

def GetLEDBrightness (ტემპერატურა):

თუ ტემპერატურა <= 0: extremecoldled = 100 გაცივებული = 100 hotled = 0 extremehotled = 0

ბეჭდვა ("უკიდურესი სიცივე გამოიწვია:" + სტრიქონი (ექსკლუზიურად გაცივებული))

ბეჭდვა ("ცივი led:" + str (გაცივებული)) ბეჭდვა ("Extreme hot led" + str (extremehotled)) print ("Hot led:" + str (hotled))

ExtremeColdLED.start (extremecoldled)

ColdLED. დაწყება (გაცივებული)

ExtremeHotLED. დაწყება (ექსტრემალური ცხელი)

HotLED. დაწყება (ცხელი) elif temp> = 100: extremecoldled = 0 გაცივებული = 0 ცხელი = 100 ექსტრემალური ცხელი = 100

ბეჭდვა ("უკიდურესი სიცივე გამოიწვია:" + სტრიქონი (ექსკლუზიურად გაცივებული))

ბეჭდვა ("ცივი led:" + str (გაცივებული)) ბეჭდვა ("Extreme hot led" + str (extremehotled)) print ("Hot led:" + str (hotled))

ExtremeColdLED.start (extremecoldled)

ColdLED. დაწყება (გაცივებული)

ExtremeHotLED. დაწყება (ექსტრემალური ცხელი)

HotLED. დაწყება (ცხელი) elif 0 <temp <= 30: extremecoldled = getextremeleftledintensity (temp) - 100 coldled = 100 hotled = 0 extremehotled = 0

ბეჭდვა ("უკიდურესი სიცივე გამოიწვია:" + სტრიქონი (ექსკლუზიურად გაცივებული))

ბეჭდვა ("ცივი led:" + str (გაცივებული)) ბეჭდვა ("Extreme hot led" + str (extremehotled)) print ("Hot led:" + str (hotled))

ExtremeColdLED.start (extremecoldled)

ColdLED. დაწყება (გაცივებული)

ExtremeHotLED. დაწყება (ექსტრემალური ცხელი)

HotLED. დაწყება (ცხელი) elif 100> temp> = 70: extremecoldled = 0 coldled = 0 hotled = 100 extremehotled = მიიღეთ მეტი ძალაუფლება (ტემპერატურა) - 100

ბეჭდვა ("უკიდურესი სიცივე გამოიწვია:" + სტრიქონი (ექსკლუზიურად გაცივებული))

ბეჭდვა ("ცივი led:" + str (გაცივებული)) ბეჭდვა ("Extreme hot led" + str (extremehotled)) ბეჭდვა ("Hot led:" + str (hotled))

ExtremeColdLED.start (extremecoldled)

ColdLED. დაწყება (გაცივებული)

ExtremeHotLED. დაწყება (ექსტრემალური ცხელი)

ცხელი

ბეჭდვა ("უკიდურესი სიცივე გამოიწვია:" + სტრიქონი (ექსკლუზიურად გაცივებული))

ბეჭდვა ("ცივი led:" + str (გაცივებული)) ბეჭდვა ("Extreme hot led" + str (extremehotled)) ბეჭდვა ("Hot led:" + str (hotled))

ExtremeColdLED.start (extremecoldled)

ColdLED. დაწყება (გაცივებული)

ExtremeHotLED. დაწყება (ექსტრემალური ცხელი)

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

გაცივებული = 100 - ცხელი

უკიდურესად გაცივებული = 0

ბეჭდვა ("უკიდურესი სიცივე გამოიწვია:" + სტრიქონი (ექსკლუზიურად გაცივებული))

ბეჭდვა ("ცივი led:" + str (გაცივებული)) ბეჭდვა ("Extreme hot led" + str (extremehotled)) print ("Hot led:" + str (hotled))

ExtremeColdLED.start (extremecoldled)

ColdLED. დაწყება (გაცივებული)

ExtremeHotLED. დაწყება (ექსტრემალური ცხელი)

HotLED. დაწყება (ცხელი) elif temp == 50: extremecoldled = 0 coldled = 50 hotled = 50 extremehotled = 0

ბეჭდვა ("უკიდურესი სიცივე გამოიწვია:" + სტრიქონი (ექსკლუზიურად გაცივებული))

ბეჭდვა ("ცივი led:" + str (გაცივებული)) ბეჭდვა ("Extreme hot led" + str (extremehotled)) print ("Hot led:" + str (hotled))

ExtremeColdLED.start (extremecoldled)

ColdLED. დაწყება (გაცივებული)

ExtremeHotLED. დაწყება (ექსტრემალური ცხელი)

HotLED. დაწყება (ცხელი)

კარგი, კოდის ეს მონაკვეთი მართლაც გრძელია. ასევე საკმაოდ ძნელია ახსნა. არსებითად, ზემოთ მოყვანილი კოდი უყურებს ტემპერატურას ფარენჰეიტში და განსაზღვრავს, არის თუ არა იგი დიაპაზონის ნაკრებში. დიაპაზონების მიხედვით, ის აძლევს რიცხვს თითოეული led და მისი სიკაშკაშე და შემდეგ ადგენს სიკაშკაშეს დაწყების () ბრძანების გამოძახებით. ეს არის სწრაფი ახსნა. თუ ეს საკმარისია, გირჩევთ გადადით შემდეგ საფეხურზე, მაგრამ თუ გსურთ გრძელი და დამღლელი ახსნა ნახოთ, განაგრძეთ კითხვა.

როდესაც ჩვენ ვპროგრამებდით, ჩვენ გადავწყვიტეთ უმარტივესი გზა ტემპერატურის მნიშვნელობის მისაღებად მათემატიკური ფუნქციის სახით. ამრიგად, ჩვენ შევქმენით გრაფიკი გეოგებრაში, რათა წარმოვაჩინოთ რა კავშირი გვაქვს ჩვენს ტემპერატურასა და ჩვენს სიკაშკაშეს შორის; მიზეზი იმისა, რომ ის 100 -ზე მაღლა მიდის არის ის, რომ დამატებითი იქნება მეორე led– ში. თუმცა, ჩვენ შევეჯახეთ საკითხს, რომ მივიღოთ ერთი ფუნქცია ყველა ამ წერტილის ერთ ფუნქციაზე გამოსახვისათვის. ჩვენ გვეგონა, რომ შეგვეძლო გამოგვეყენებინა პარაბოლა, მაგრამ ჩვენ გადავწყვიტეთ, რომ შევჩერდეთ მხოლოდ if განცხადებების სერიის გამოყენებით. არსებითად, მთელი ეს კოდი ნაწილობრივი ფუნქციაა.

ზედა ფუნქციები არის ხაზების შესაბამისი განტოლება. მას შემდეგ, რაც ჩვენ განვსაზღვრავთ, თუ სად არის ტემპერატურა გრაფიკზე, ჩვენ გავდივართ მას ამ ფუნქციის საშუალებით, ვიღებთ სიკაშკაშეს და გადავცემთ მას led- ებზე.

ნაბიჯი 6: კოდირება: საბოლოო ნაბიჯები

და ბოლოს, ჩვენ დავამატებთ ამ განცხადებას დასასრულს.

სცადე:

while (True): GetLEDBrightness (City_TemperatureF) GetRainLED (WeatherID) დრო. ძილი (10) კლავიატურის გარდა უწყვეტი: quit ()

ცდები და გამონაკლისი განცხადებები გვაძლევს საშუალებას გამოვიდეთ კოდიდან კლავიატურის შემოკლებით; ნებისმიერ შემთხვევაში, ჩვენ უნდა დავხუროთ Raspberry Pi კოდის გადატვირთვისთვის. შემდეგ ჩვენ გვაქვს მარყუჟი, რომელიც სამუდამოდ მუშაობს. ჩვენ ვაახლებთ led- ებს, ასევე ვაახლებთ წვიმის LED- ს. ჩვენ ვაჩერებთ ათი წამი; OpenWeather იძლევა მხოლოდ 60 ზარს მონაცემებისთვის წუთში, ხოლო 10 წამი არის უამრავი განახლება.

და ამით, ჩვენი კოდი დასრულებულია. ქვემოთ მოცემულია დასრულებული კოდი.

RaspberryPIWeatherStation.py

იმპორტის მოთხოვნები

იმპორტი RPi. GPIOasGPIO

იმპორტიორი

იმპორტის დრო

#ღია ამინდის ამინდის კოდი 700 -ზე ნაკლები არის ნალექი

defCheckRain (IdCode):

ifIdCode <700:

დაბრუნება მართალია

სხვა:

დაბრუნება მცდარი

defgetmiddleleftledintensity (TemperatureinF):

#მარცხენა განტოლება: y =-(50/20) x + 175

#სწორი განტოლება: y = (50/20) x - 75

დაბრუნება- (50/20)*ტემპერატურა F+175

defgetmiddlerightledintensity (ტემპერატურა F):

#მარცხენა განტოლება: y =-(50/20) x + 175

#სწორი განტოლება: y = (50/20) x - 75

დაბრუნება (50/20)*ტემპერატურა F-75

defgetextremeleftledintensity (ტემპერატურა F):

#მარცხენა ტოლობა: y = -(100/30) x + 200

#სწორი ექვივალენტი: y = (100/30) x - (400/3)

დაბრუნება- (100/30)*ტემპერატურა F+200

defgetextremerightledintensity (ტემპერატურა F):

# მარცხენა ტოლობა: y = -(100/30) x + 200

# მარჯვენა ექვივალენტი: y = (100/30) x - (400/3)

დაბრუნება (100/30)*ტემპერატურა F- (400/3)

#GPIO დაყენება

GPIO.setmode (GPIO. BCM)

GPIO.setwarnings (ყალბი)

#ქინძისთავები

უკიდურესი_ცხელი_LED_PIN = 26

ცხელი_LED_PIN = 16

ექსტრემალური_ ცივი_LED_PIN = 5

ცივი_LED_PIN = 6

წვიმა_LED_PIN = 23

#პინის დაყენება

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 (ცხელი_LED_PIN, 100)

ExtremeColdLED = GPIO. PWM (Extreme_Cold_LED_PIN, 100)

ColdLED = GPIO. PWM (Cold_LED_PIN, 100)

defGetLED სიკაშკაშე (ტემპერატურა):

iftemp <= 0:

უკიდურესად გაცივებული = 100

გაცივებული = 100

ცხელი = 0

ექსტრემალური ცხელი = 0

ბეჭდვა ("უკიდურესი სიცივე გამოიწვია:"+სტრიქონი (ექსკლუზიურად გაცივებული))

ბეჭდვა ("ცივი led:"+str (გაცივებული))

ბეჭდვა ("ექსტრემალური ცხელი led"+str (ექსტრემალური ცხელი))

ბეჭდვა ("ცხელი ლედ:"+სტრიქონი (ცხელი))

ExtremeColdLED.start (extremecoldled)

ColdLED. დაწყება (გაცივებული)

ExtremeHotLED. დაწყება (ექსტრემალური ცხელი)

HotLED. დაწყება (ცხელი)

eliftemp> = 100:

უკიდურესად გაცივებული = 0

გაცივებული = 0

გაცხელებული = 100

ექსტრემალური ცხელი = 100

ბეჭდვა ("უკიდურესი სიცივე გამოიწვია:"+სტრიქონი (ექსკლუზიურად გაცივებული))

ბეჭდვა ("ცივი led:"+str (გაცივებული))

ბეჭდვა ("ექსტრემალური ცხელი led"+str (extremehotled))

ბეჭდვა ("ცხელი ლედ:"+სტრიქონი (ცხელი))

ExtremeColdLED.start (extremecoldled)

ColdLED. დაწყება (გაცივებული)

ExtremeHotLED. დაწყება (ექსტრემალური ცხელი)

HotLED. დაწყება (ცხელი)

elif0 <temp <= 30:

extremecoldled = getextremeleftledintensity (ტემპერატურა) -100

გაცივებული = 100

ცხელი = 0

ექსტრემალური ცხელი = 0

ბეჭდვა ("უკიდურესი სიცივე გამოიწვია:"+სტრიქონი (ექსკლუზიურად გაცივებული))

ბეჭდვა ("ცივი led:"+str (გაცივებული))

ბეჭდვა ("ექსტრემალური ცხელი led"+str (extremehotled))

ბეჭდვა ("ცხელი ლედ:"+სტრიქონი (ცხელი))

ExtremeColdLED.start (extremecoldled)

ColdLED. დაწყება (გაცივებული)

ExtremeHotLED. დაწყება (ექსტრემალური ცხელი)

HotLED. დაწყება (ცხელი)

elif100> temp> = 70:

უკიდურესად გაცივებული = 0

გაცივებული = 0

გაცხელებული = 100

ექსტრემალური ცხელება = მიიღე ექსტრემალიზებული ინტენსივობა (ტემპერატურა) -100

ბეჭდვა ("უკიდურესი სიცივე გამოიწვია:"+სტრიქონი (ექსკლუზიურად გაცივებული))

ბეჭდვა ("ცივი led:"+str (გაცივებული))

ბეჭდვა ("ექსტრემალური ცხელი led"+str (ექსტრემალური ცხელი))

ბეჭდვა ("ცხელი ლედ:"+სტრიქონი (ცხელი))

ExtremeColdLED.start (extremecoldled)

ColdLED. დაწყება (გაცივებული)

ExtremeHotLED. დაწყება (ექსტრემალური ცხელი)

HotLED. დაწყება (ცხელი)

elif30 <ტემპერატურა <50:

უკიდურესად გაცივებული = 0

გაცივებული = მიიღე შუალედური მარცხენა ინტენსივობა (ტემპერატურა)

ცხელი = 100 გაცივებული

ექსტრემალური ცხელი = 0

ბეჭდვა ("უკიდურესი სიცივე გამოიწვია:"+სტრიქონი (ექსკლუზიურად გაცივებული))

ბეჭდვა ("ცივი led:"+str (გაცივებული))

ბეჭდვა ("ექსტრემალური ცხელი led"+str (extremehotled))

ბეჭდვა ("ცხელი ლედ:"+სტრიქონი (ცხელი))

ExtremeColdLED.start (extremecoldled)

ColdLED. დაწყება (გაცივებული)

ExtremeHotLED. დაწყება (ექსტრემალური ცხელი)

HotLED. დაწყება (ცხელი)

elif50 <ტემპერატურა <70:

ცხელი = getmiddlerightledintensity (temp)

ექსტრემალური ცხელი = 0

გაცივებული = 100-ცხელი

უკიდურესად გაცივებული = 0

ბეჭდვა ("უკიდურესი სიცივე გამოიწვია:"+სტრიქონი (ექსკლუზიურად გაცივებული))

ბეჭდვა ("ცივი led:"+str (გაცივებული))

ბეჭდვა ("ექსტრემალური ცხელი led"+str (ექსტრემალური ცხელი))

ბეჭდვა ("ცხელი ლედ:"+სტრიქონი (ცხელი))

ExtremeColdLED.start (extremecoldled)

ColdLED. დაწყება (გაცივებული)

ExtremeHotLED. დაწყება (ექსტრემალური ცხელი)

HotLED. დაწყება (ცხელი)

eliftemp == 50:

უკიდურესად გაცივებული = 0

გაცივებული = 50

გაცხელებული = 50

ექსტრემალური ცხელი = 0

ბეჭდვა ("უკიდურესი სიცივე გამოიწვია:"+სტრიქონი (ექსკლუზიურად გაცივებული))

ბეჭდვა ("ცივი led:"+str (გაცივებული))

ბეჭდვა ("ექსტრემალური ცხელი led"+str (extremehotled))

ბეჭდვა ("ცხელი ლედ:"+სტრიქონი (ცხელი))

ExtremeColdLED.start (extremecoldled)

ColdLED. დაწყება (გაცივებული)

ExtremeHotLED. დაწყება (ექსტრემალური ცხელი)

HotLED. დაწყება (ცხელი)

defGetRainLED (idCode):

ifCheckRain (idCode):

GPIO.output (Rain_LED_PIN, GPIO. HIGH)

სხვა:

GPIO.output (Rain_LED_PIN, GPIO. LOW)

#Api ინფორმაცია: შეცვალეთ API გასაღები თქვენი oepnweather api გასაღებით

openweather_api_key = "460a23f27ff324ef9ae743c7e9c32d7e"

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

ბეჭდვა ("აკრიფეთ ქალაქი!")

ქალაქის სახელი = შეყვანა ()

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

#ამინდის მონაცემების მიღება

პასუხი = request.get (სრული_ძახილი)

WeatherData = Response.json ()

WeatherID = WeatherData ["ამინდი"] [0] ["id"]

City_TemperatureK = ამინდის მონაცემები ["მთავარი"] ["ტემპი"]

City_TemperatureF = (City_TemperatureK-273)*1.8+32#ფარენჰეიტზე გადაყვანა

#LED/GPIO პერსონალი

ბეჭდვა ("K:"+str (City_TemperatureK))

ბეჭდვა ("F:"+str (City_TemperatureF))

ბეჭდვა (WeatherID)

სცადე:

ხოლო (მართალია):

GetLEDBrightness (City_TemperatureF)

GetRainLED (ამინდის ID)

დრო. ძილი (10)

გარდა KeyboardIntruptrupt:

დატოვე ()

rawRaspberryPIWeatherStation.py ნახვა hosted ერთად GitHub

ნაბიჯი 7: მშენებლობა და გაყვანილობა

ვაი! ამდენი კოდირების შემდეგ, ჩვენ მივდივართ შენობაში, რაც მნიშვნელოვნად ადვილია.კორონას სახლში დარჩენის გამო, ჩვენ ვერ მივაღწიეთ ბევრ იმ ინსტრუმენტს, რომლის მოლოდინიც გვქონდა სკოლაში. ამრიგად, ეს ნაწილი ცოტა უფრო მარტივია, ვიდრე ჩვენ ვგეგმავდით. სპეციფიკა თავისთავად ასევე მოქნილია. პირველი ჩვენ დავხატეთ ოთხკუთხედი ხის ფიცარზე. კონკრეტულ ზომას ნამდვილად არ აქვს დიდი მნიშვნელობა, რადგან ის უბრალოდ ემსახურება როგორც led და ელექტრონიკის ჩასატარებლად.

შემდეგ ჩვენ გავთხარეთ ხუთი 1/8 მე –8 ხვრელები ჩვენი ხის ნაჭერში.

შემდეგ ჩვენ ამოვიღეთ ფიცარიდან ოთხკუთხედი, რომ გამოვიყენოთ როგორც პლატფორმა ჩვენი ელექტრონიკისთვის.

(ეს იყო როდესაც ჩვენ დავიწყეთ; ჩვენ ვიპოვეთ უფრო დიდი ხერხი!)

შემდეგ ჩვენ ვუბიძგებთ led– ის ანოდისა და კათოდის ქინძისთავებს ხვრელებში; led უნდა იყოს განთავსებული ontop, მათი ნათურებით sticking out; თვალყური ადევნეთ რომელი ფეხი უფრო გრძელი და მოკლეა. შემდეგ ჩვენ დავიწყეთ მავთულხლართების ერთმანეთთან შედუღება. პირველი ჩვენ solder რეზისტორების anode ფეხი LED (აღარ ფეხი).

შემდეგ, ჩვენ გავაერთიანეთ LED- ების კათოდური ფეხები ერთ სპილენძის მავთულზე, რომელსაც ჩვენ გამოვიყენებთ როგორც დასაბუთებლად. ასე უნდა გამოიყურებოდეს.

მას შემდეგ, რაც ჩვენ ამას ვაკეთებთ, ჩვენ ვასხამთ მამრობითი სქესის ქალ-მამრობითი ჯუმბერის კაბელების ბოლოებს თითოეული რეზისტორის ბოლოსა და სპილენძის გრუნტის მავთულს. მას შემდეგ რაც ამას გავაკეთებთ, ჩვენ შეგვიძლია დავიწყოთ მავთულის ჩამაგრება ჟოლოს PI GPIO ქინძისთავებში. აქ არის დიაგრამა! ამასთან, გაითვალისწინეთ, რომ ქინძისთავები არის ის, რაც ადრე იყო შეხებული კოდში.

მას შემდეგ რაც ყველაფერი გაწყობილი გექნებათ, ახლა ყველაფერი რაც თქვენ უნდა გააკეთოთ არის პითონის ფაილის გადმოტანა ჟოლოს პიზე და გახსნა ტერმინალი. გაუშვით "python3 RaspberryPIWeatherStation.py" და შემდეგ გააკეთეთ ისე, როგორც ჩანს.

ნაბიჯი 8: დემონსტრირება და დასკვნა

გმადლობთ, რომ ბოლომდე წაიკითხეთ! ქვემოთ დავამატებ პითონის სკრიპტს! თუკი რამის დამატება შეგვეძლო, ალბათ იქნებოდა…

1. მხარდაჭერა სხვადასხვა ტიპის შეყვანისთვის (ქალაქები, გეოგრაფიული წერტილები და ა.

2. ამინდის მეტი ინფორმაციის მხარდაჭერა

3. დაამატეთ პატარა ეკრანი ინფორმაციის საჩვენებლად

გაგვაგებინე შენი აზრი! ეს სახალისო პროექტი იყო. ჩვენ ბევრი რამ ვისწავლეთ პითონის გამოყენებით მოთხოვნათა და ინტერნეტ დოკუმენტების მიღების შესახებ, ასევე ბევრი ვისწავლეთ შედუღების გამოყენების შესახებ.