IoT ამინდის სადგური RPi და ESP8266: 10 ნაბიჯი

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

წინა გაკვეთილებზე ჩვენ ვთამაშობდით NodeMCU– სთან, სენსორებთან და ვსწავლობთ როგორ დავიჭიროთ და შევიტანოთ მონაცემები ThingSpeak (ნივთების ინტერნეტი (IoT) პლატფორმაზე, რომელიც გაძლევთ საშუალებას შეაგროვოთ და შეინახოთ ღრუბელში სენსორული მონაცემები და შეიმუშაოთ IoT პროგრამები):

IOT MASE EASY: გადაღების დისტანციური ამინდის მონაცემები: ულტრაიისფერი და ჰაერის ტემპერატურა და ტენიანობა

ამ ახალი გაკვეთილით, ჩვენ ვისწავლით თუ როგორ უნდა გავაკეთოთ იგივე, მაგრამ ამ დროს, Raspberry Pi– ს გამოყენებით სხვადასხვა სენსორების მონაცემების მოსაპოვებლად და ასევე მოწყობილობებსა და ინტერნეტს შორის კომუნიკაციის სხვადასხვა გზების შესწავლით:

სენსორები და კომინაციის ტიპი:

• DHT22 (ტემპერატურა და ტენიანობა) ==> ციფრული კომუნიკაცია
• BMP180 (ტემპერატურა და წნევა) ==> I2C პროტოკოლი
• DS18B20 (ტემპერატურა) ==> 1-მავთულის პროტოკოლი

ბლოკის დიაგრამა გვიჩვენებს რას მივიღებთ ბოლოს ამ პროექტით:

ნაბიჯი 1: BoM - მასალების შედგენა

1. ჟოლო Pi V3 - 32,00 აშშ დოლარი
2. DHT22 ტემპერატურისა და ტენიანობის შედარებითი სენსორი - 9.95 აშშ დოლარი
3. რეზისტორი 4K7 ohm
4. DS18B20 წყალგაუმტარი ტემპერატურის სენსორი - 5.95 აშშ დოლარი
5. რეზისტორი 4K7 ohm
6. BMP180 ბარომეტრიული წნევის, ტემპერატურისა და სიმაღლის სენსორი - 6.99 აშშ დოლარი

ნაბიჯი 2: ტემპერატურისა და ტენიანობის სენსორის დაყენება

პირველი სენსორი, რომელიც დაინსტალირდება იქნება DHT22 ჰაერის ტემპერატურის და ფარდობითი ტენიანობის მონაცემების დასაფიქსირებლად. ADAFRUIT საიტი იძლევა დიდ ინფორმაციას ამ სენსორების შესახებ. ქვემოთ, ზოგიერთი ინფორმაცია ამოღებულია იქიდან:

მიმოხილვა

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

DHT22 ძირითადი მახასიათებლები:

• Დაბალი ფასი
• 3 -დან 5V სიმძლავრის და I/O
• 2.5mA მაქსიმალური მიმდინარე გამოყენება კონვერტაციის დროს (მონაცემების მოთხოვნისას)
• კარგია 0-100% ტენიანობის კითხვისთვის 2-5% სიზუსტით
• კარგია -40 -დან 125 ° C ტემპერატურის მაჩვენებლებისთვის ± 0.5 ° C სიზუსტისთვის
• შერჩევის სიჩქარე არაუმეტეს 0.5 ჰც (ყოველ 2 წამში ერთხელ)
• სხეულის ზომა 15.1 მმ x 25 მმ x 7.7 მმ
• 4 ქინძისთავები 0,1 "ინტერვალით

როგორც წესი, თქვენ გამოიყენებთ სენსორს 20 მ -ზე ნაკლებ დისტანციებზე, 4K7 ohm რეზისტორი უნდა იყოს დაკავშირებული მონაცემთა და VCC ქინძისთავებს შორის. DHT22 გამომავალი მონაცემთა პინი დაუკავშირდება ჟოლოს GPIO 16. შეამოწმეთ ზემოხსენებული ელექტრული დიაგრამა, დაუკავშირეთ სენსორი RPi ქინძისთავებს, როგორც ქვემოთ:

1. პინი 1 - Vcc ==> 3.3V
2. პინი 2 - მონაცემები ==> GPIO 16
3. პინი 3 - არ არის დაკავშირებული
4. პინი 4 - Gnd ==> Gnd

არ დაგავიწყდეთ დააინსტალიროთ 4K7 ohm რეზისტორი Vcc და Data ქინძისთავებს შორის

როდესაც სენსორი დაკავშირებულია, ჩვენ ასევე უნდა დავაინსტალიროთ მისი ბიბლიოთეკა ჩვენს RPi– ზე.

DHT ბიბლიოთეკის დაყენება:

თქვენს ჟოლოზე, დაწყებული /სახლში, გადადით /დოკუმენტები

cd დოკუმენტები

შექმენით დირექტორია, რომ დააინსტალიროთ ბიბლიოთეკა და გადახვიდეთ იქ:

mkdir DHT22_ სენსორი

cd DHT22_ სენსორი

თქვენს ბრაუზერში გადადით Adafruit GitHub– ზე:

github.com/adafruit/Adafruit_Python_DHT

ჩამოტვირთეთ ბიბლიოთეკა დაწკაპუნებით გადმოსაწერი zip ბმულით მარჯვნივ და გახსენით არქივი თქვენს Raspberry Pi ახლახანს შექმნილ საქაღალდეში. შემდეგ გადადით ბიბლიოთეკის დირექტორიაში (ქვესაქაღალდე, რომელიც ავტომატურად იქმნება ფაილის გახსნისას) და შეასრულეთ ბრძანება:

sudo python3 setup.py ინსტალაცია

გახსენით სატესტო პროგრამა (DHT22_test.py) ჩემი GITHUB– დან

იმპორტი Adafruit_DHT

DHT22Sensor = Adafruit_DHT. DHT22 DHTpin = 16 ტენიანობა, ტემპერატურა = Adafruit_DHT.read_retry (DHT22Sensor, DHTpin) თუ ტენიანობა არ არის და ტემპერატურა არ არის: print ('Temp = {0: 0.1f}*C ტენიანობა = {1: 0.1 f}%'. ფორმატი (ტემპერატურა, ტენიანობა)) სხვა: ბეჭდვა ("კითხვა ვერ მოხერხდა. სცადე ხელახლა!")

შეასრულეთ პროგრამა ბრძანებით:

python3 DHT22_test.py

ქვემოთ მოცემული ტერმინალური ბეჭდვის ეკრანი აჩვენებს შედეგს.

ნაბიჯი 3: DS18B20 - ტემპერატურის სენსორის დაყენება

სენსორის მიმოხილვა:

ამ გაკვეთილში ჩვენ გამოვიყენებთ DS18B20 სენსორის წყალგაუმტარი ვერსიას. ძალიან სასარგებლოა დისტანციური ტემპერატურისთვის სველ პირობებში, მაგალითად ტენიან ნიადაგში. სენსორი იზოლირებულია და შეუძლია გაზომოს 125oC– მდე (ადაფრუტი არ გირჩევთ მის გამოყენებას 100oC– ზე ზემოთ საკაბელო PVC ქურთუკის გამო).

DS18B20 არის ციფრული სენსორი, რის გამოც მისი გამოყენება კარგია თუნდაც დიდ დისტანციებზე! ეს 1 მავთულის ციფრული ტემპერატურის სენსორები საკმაოდ ზუსტია (± 0.5 ° C დიაპაზონში) და შეუძლია 12 ბიტამდე სიზუსტე მისცეს ციფრული ანალოგურ გადამყვანზე. ისინი მშვენივრად მუშაობენ NodeMCU– სთან ერთი ციფრული პინის გამოყენებით, და თქვენ შეგიძლიათ დააკავშიროთ რამოდენიმე ერთსა და იმავე პინს, თითოეულს აქვს უნიკალური 64 ბიტიანი პირადობის მოწმობა ქარხანაში, რომელიც მათ განასხვავებს.

სენსორი მუშაობს 3.0 -დან 5.0 ვ -მდე, რაც იმას ნიშნავს, რომ ის შეიძლება იკვებებოდეს უშუალოდ 3.3 ვ -იდან ჟოლოს ერთ – ერთი ქინძისთავით (1 ან 17).

სენსორს აქვს 3 მავთული:

• შავი: GND
• წითელი: VCC
• ყვითელი: 1 მავთულის მონაცემები

აქ თქვენ შეგიძლიათ ნახოთ სრული მონაცემები: DS18B20 მონაცემთა ცხრილი

სენსორის დაყენება:

მიჰყევით ზემოთ მოცემულ დიაგრამას და დაამყარეთ კავშირები:

• Vcc ==> 3.3V
• Gnd ==> Gnd
• მონაცემები ==> GPIO 4 (ნაგულისხმევი ბიბლიოთეკისთვის)

პითონის ბიბლიოთეკის დაყენება:

შემდეგი, მოდით დააყენოთ პითონის ბიბლიოთეკა, რომელიც გაუმკლავდება სენსორს:

sudo pip3 დააინსტალირეთ w1thermsensor

სენსორის შესამოწმებლად სკრიპტის გაშვებამდე შეამოწმეთ ჩართულია თუ არა "1-Wire" ინტერფეისი თქვენს RPi– ში (იხ. დაბეჭდვის ეკრანი ზემოთ)

არ დაგავიწყდეთ თქვენი RPi გადატვირთვა, მისი კონფიგურაციის შეცვლის შემდეგ

სენსორის ტესტირება:

სენსორის შესამოწმებლად შეგიძლიათ გამოიყენოთ მარტივი პითონის სკრიპტი:

იმპორტის დრო

w1thermsensor იმპორტიდან W1ThermSensor ds18b20Sensor = W1ThermSensor () ხოლო True: temperature = ds18b20Sensor.get_temperature () print ("The temperature is % s celsius" % temperature) time.sleep (1)

ნაბიჯი 4: დააინსტალირეთ BMP180

სენსორის მიმოხილვა:

BMP180 არის BMP085– ის მემკვიდრე, ახალი თაობის მაღალი სიზუსტის ციფრული წნევის სენსორები სამომხმარებლო პროგრამებისთვის. BMP180– ის ულტრა დაბალი სიმძლავრის, დაბალი ძაბვის ელექტრონიკა ოპტიმიზირებულია მობილური ტელეფონებისთვის, PDA– ებისთვის, GPS სანავიგაციო მოწყობილობებისთვის და გარე მოწყობილობებისთვის. დაბალი სიმაღლის ხმაურით მხოლოდ 0.25 მ სწრაფი კონვერტაციის დროს, BMP180 გთავაზობთ საუკეთესო შესრულებას. I2C ინტერფეისი იძლევა სისტემის მარტივ ინტეგრაციას მიკროკონტროლერთან. BMP180 ემყარება პიეზო-რეზისტენტულ ტექნოლოგიას EMC გამძლეობის, მაღალი სიზუსტისა და ხაზოვანობის, ასევე გრძელვადიანი სტაბილურობისთვის.

BMP– ის სრული ფურცელი შეგიძლიათ იხილოთ აქ: BMP180 - ციფრული წნევის სენსორი

სენსორის დაყენება: მიჰყევით ზემოთ მოცემულ დიაგრამას და დაამყარეთ კავშირები:

• Vin ==> 3.3V
• GND ==> GND
• SCL ==> GPIO 3
• SDA ==> GPIO 2

I2C ინტერფეისის ჩართვა

გადადით RPi კონფიგურაციაზე და დაადასტურეთ, რომ I2C ინტერფეისი ჩართულია. თუ არა, ჩართეთ იგი და გადატვირთეთ RPi.

BMP180– ის გამოყენებით

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

პირველი რაც უნდა გააკეთოთ არის შეამოწმოთ ხედავს თუ არა Pi თქვენს BMP180. სცადეთ შემდეგი ტერმინალის ფანჯარაში:

sudo i2cdetect -y 1

თუ ბრძანება მუშაობდა, თქვენ უნდა ნახოთ მსგავსი რამ ზემოთ მოცემული ტერმინალის ბეჭდვის ეკრანზე, რომელიც აჩვენებს, რომ BMP180 არის არხზე '77'.

BMP180 ბიბლიოთეკის დაყენება:

შექმენით დირექტორია ბიბლიოთეკის დასაყენებლად:

mkdir BMP180_Sensorcd BMP180_Sensor

თქვენს ბრაუზერში გადადით Adafruit GITHub– ზე:

github.com/adafruit/Adafruit_Python_BMP

ჩამოტვირთეთ ბიბლიოთეკა დაწკაპუნებით გადმოსაწერი zip ბმულით მარჯვნივ და გახსენით არქივი თქვენს Raspberry Pi შექმნილ საქაღალდეში. შემდეგ გადადით შექმნილ ქვესაქაღალდეში და შეასრულეთ შემდეგი ბრძანება ბიბლიოთეკის დირექტორიაში:

sudo python3 setup.py ინსტალაცია

გახსენით თქვენი Python IDE და შექმენით სატესტო პროგრამა და დაასახელეთ, მაგალითად BMP180Test.py

იმპორტი Adafruit_BMP. BMP085 როგორც BMP085sensor = BMP085. BMP085 () ბეჭდვა ('Temp = {0: 0.2f} *C'.format (sensor.read_temperature ())) print (' წნევა = {0: 0.2f} Pa " ფორმატი (sensor.read_pressure ())) ბეჭდვა ('სიმაღლე = {0: 0.2f} მ'. ფორმატი (sensor.read_altitude ())] ბეჭდვა ('Sealevel Pressure = {0: 0.2f} Pa'. ფორმატი (სენსორი. წაიკითხე_დაჯერებული_წნევი ()))

შეასრულეთ სატესტო პროგრამა:

python3 BMP180Test.py

ზემოხსენებული ტერმინალური ბეჭდვის ეკრანი აჩვენებს შედეგს.

გაითვალისწინეთ, რომ წნევა წარმოდგენილია Pa- ში (Pascals). იხილეთ შემდეგი ნაბიჯი ამ ერთეულის უკეთ გასაგებად.

ნაბიჯი 5: ამინდისა და სიმაღლის გაზომვა BMP180– ით

მოდით დრო დაუთმოთ ცოტა მეტი იმის გაგებას, თუ რას მივიღებთ BMP კითხვებით. შეგიძლიათ გამოტოვოთ გაკვეთილის ეს ნაწილი, ან დაბრუნდეთ მოგვიანებით.

თუ გსურთ მეტი იცოდეთ სენსორული კითხვის შესახებ, გადადით ამ დიდ სამეურვეო პროგრამაზე:

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

რა არის ატმოსფერული წნევა?

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

თუ აიღებ 1 სმ სიგანის ჰაერის სვეტს, ის იწონის დაახლოებით 1 კგ

ეს წონა, ამ სვეტის ნაკვალევზე დაჭერით, ქმნის ატმოსფერულ წნევას, რომლის გაზომვაც ჩვენ შეგვიძლია BMP180- ის მსგავსი სენსორებით. იმის გამო, რომ ჰაერის ეს სმ სიგანე იწონის დაახლოებით 1 კგ, აქედან გამომდინარეობს, რომ ზღვის დონის საშუალო წნევაა დაახლოებით 101325 პასკალი, ან უკეთესი, 1013.25 hPa (1 hPa ასევე ცნობილია როგორც მილიბარი - mbar). ეს დაეცემა დაახლოებით 4% ყოველ 300 მეტრზე ასვლისას. რაც უფრო მაღლა ახვალთ, მით უფრო მცირე წნევას დაინახავთ, რადგან ატმოსფეროს თავზე არსებული სვეტი გაცილებით მოკლეა და, შესაბამისად, ნაკლები იწონის. ამის ცოდნა სასარგებლოა, რადგან წნევის გაზომვით და მათემატიკის გაკეთებით თქვენ შეგიძლიათ განსაზღვროთ თქვენი სიმაღლე.

ჰაერის წნევა 3, 810 მეტრზე ზღვის დონიდან მხოლოდ ნახევარია.

BMP180 გამოაქვს აბსოლუტური წნევა პასკალებში (პა). ერთი პასკალი არის ძალიან მცირე წნევა, დაახლოებით იმ რაოდენობას, რასაც ფურცელი გამოაქვეყნებს მაგიდაზე. თქვენ უფრო ხშირად ნახავთ გაზომვებს ჰექტოპასკალებში (1 hPa = 100 Pa). აქ გამოყენებული ბიბლიოთეკა იძლევა გამომავალი მცურავი წერტილების მნიშვნელობებს hPa- ში, რაც ასევე უდრის ერთ მილიბარს (mbar).

აქ არის რამოდენიმე გარდაქმნა სხვა წნევის ერთეულებზე:

• 1 hPa = 100 Pa = 1 mbar = 0.001 ბარი
• 1 hPa = 0.75006168 Torr
• 1 hPa = 0.01450377 psi (ფუნტი კვადრატულ ინჩზე)
• 1 hPa = 0.02953337 inHg (ვერცხლისწყლის ინჩი)
• 1 hpa = 0.00098692 ატმ (სტანდარტული ატმოსფერო)

ტემპერატურის ეფექტები

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

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

აბსოლუტური წნევის გაზომვა

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

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

ამინდის დაკვირვებები

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

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

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

სიმაღლის განსაზღვრა

ვინაიდან წნევა განსხვავდება სიმაღლის მიხედვით, თქვენ შეგიძლიათ გამოიყენოთ წნევის სენსორი სიმაღლის გასაზომად (რამდენიმე გაფრთხილებით). ზღვის დონეზე ატმოსფეროს საშუალო წნევაა 1013.25 hPa (ან mbar). ეს ნულამდე ეცემა, როდესაც თქვენ მიდიხართ სივრცის ვაკუუმისკენ. იმის გამო, რომ ამ ვარდნის მრუდი კარგად არის გაგებული, თქვენ შეგიძლიათ გამოთვალოთ სიმაღლის სხვაობა წნევის ორ გაზომვას შორის (p და p0) კონკრეტული განტოლების გამოყენებით.

თუ თქვენ იყენებთ ზღვის დონის წნევას (1013.25 hPa) საბაზისო წნევად (p0), განტოლების გამომუშავება იქნება თქვენი ამჟამინდელი სიმაღლე ზღვის დონიდან. ბიბლიოთეკაში არის ფუნქცია სახელწოდებით სიმაღლე (P, P0), რომელიც გაძლევთ საშუალებას მიიღოთ "გამოთვლილი სიმაღლე".

ზემოაღნიშნული ახსნა ამოღებულია BMP 180 Sparkfun სახელმძღვანელოდან.

ნაბიჯი 6: სრული HW

ნაბიჯი 7: მონაცემების გაგზავნა ThingSpeak– ში

ამ ეტაპზე, ჩვენ ვისწავლეთ როგორ მოვამზადოთ RPi სამივე სენსორის მონაცემების მოსაპოვებლად და მათი დაბეჭდვისთვის ტერმინალზე. ახლა, დროა ვნახოთ, როგორ გავაგზავნოთ ეს მონაცემები IoT პლატფორმაზე, ThingSpeak.

Მოდით დავიწყოთ!

პირველ რიგში, თქვენ უნდა გქონდეთ ანგარიში ThinkSpeak.com– ზე

მიჰყევით ინსტრუქციას არხის შესაქმნელად და გაითვალისწინეთ თქვენი არხის ID და ჩაწერეთ API გასაღები

ჩამოტვირთეთ პითონის სკრიპტი ჩემი GitHub– დან: localData ToTS_v1_EXT.py

მოდით გავაკეთოთ კომენტარი კოდის ყველაზე მნიშვნელოვან ნაწილებზე:

პირველი, მოდით შემოვიტანოთ ThingSpeak ბიბლიოთეკა, განვსაზღვროთ WiFi კლიენტი და განვსაზღვროთ თქვენი ადგილობრივი როუტერი და Thinkspeak სერთიფიკატები:

იმპორტი რამ

ThingSpeak– თან კომუნიკაციის რამდენიმე გზა არსებობს, უმარტივესი გზა იქნება კლიენტთა ბიბლიოთეკის გამოყენება thingspeak.com API– სთვის, რომელიც შემუშავებულია მიკოლაჯ ჩვალიზისა და კეით ელისის მიერ.

ბიბლიოთეკის ჩამოტვირთვა შესაძლებელია https://github.com/mchwalisz/thingspeak ან ტერმინალზე PIP გამოყენებით:

sudo pip3 დააინსტალირეთ thingspeak

შემდეგი, სკრიპტის შიგნით განაახლოთ ThingSpeak არხის რწმუნებათა სიგელები

chId = 9999999 # შეიყვანეთ თქვენი არხის ID

tsKey = 'შეიყვანეთ თქვენი არხი დაწერეთ გასაღები' tsUrl = 'https://api.thingspeak.com/update' ts = thingspeak. არხი (chId, tsUrl, tsKey)

მოდით, დავიწყოთ სამი სენსორის ინიციალიზაცია:

# DS18B20 1 მავთულის ბიბლიოთეკა

w1thermsensor იმპორტიდან W1ThermSensor ds18b20Sensor = W1ThermSensor () # ნაგულისხმევად GPIO 4 გამოიყენება ბიბლიოთეკის მიერ # DHT22 ბიბლიოთეკა იმპორტი Adafruit_DHT DHT22Sensor = Adafruit_DHT. DHT22 DHTpin = 16 # BMP180 ბიბლიოთეკა იმპორტი Adafruit_85MP თქვენ უნდა განსაზღვროთ რეალური სიმაღლე, სადაც მდებარეობს თქვენი ამინდის სადგური და განაახლოთ გლობალური ცვლადი "altReal". ჩემს შემთხვევაში, ჩემი სადგური მდებარეობს ზღვის დონიდან 950 მეტრზე

გლობალური ალტერნატიული

altReal = 950

სადგურის რეალური სიმაღლით შესვლისთანავე შეგვიძლია მივიღოთ აბსოლუტური წნევა, ზღვის დონის წნევა, ტემპერატურა და სიმაღლე ფუნქციის გამოყენებით bmp180GetData (სიმაღლე):

def bmp180GetData (სიმაღლე):

temp = bmp180Sensor.read_temperature () pres = bmp180Sensor.read_pressure () alt=bmp180Sensor.read_altitude () presSeaLevel = pres/pow (1.0 - სიმაღლე/44330.0, 5.255) temp = რაუნდი (temp, 1) pres = რაუნდი (pres/100, 2) # აბსოლუტური წნევა hPa (ან mbar) alt=მრგვალი (alt) presSeaLevel = მრგვალი (presSeaLevel/100, 2) # აბსოლუტური წნევა hPa (ან mbar) დაბრუნების ტემპერატურა, pres, alt, presSeaLevel

ფუნქცია getLocalData (), დააბრუნებს ყველა ადგილობრივ მონაცემს, რომელიც გადაღებულია ჩვენი სადგურის მიერ:

def getLocalData ():

გლობალური დრო string გლობალური humLab გლობალური tempExt გლობალური tempLab გლობალური presSL გლობალური altLab გლობალური presAbs # მიიღეთ დრო კითხვისთვის ახლა = datetime.datetime.now () timeString = now.strftime ("%Y-%m-%d%H:%M") # გარე ტემპერატურის წაკითხვა (1 მეტრის მანძილი) tempExt = მრგვალი (ds18b20Sensor.get_temperature (), 1) tempLab, presAbs, altLab, presSL = bmp180GetData (altReal) humDHT, tempDHT = Adafruit_DHT.read_retry (DHT22Tensor) და tempDHT არ არის არც ერთი: humLab = მრგვალი (humDHT

მას შემდეგ რაც ზემოთ მოყვანილი ფუნქციები დაიპყრობს ყველა მონაცემს, თქვენ უნდა გაგზავნოთ ისინი ThingSpeak– ში. თქვენ ამას გააკეთებთ ფუნქციის sendDataTs () გამოყენებით:

def sendDataTs ():

data = {"field1": tempLab, "field2": tempExt, "field3": humLab, "field4": presSL, "field5": altLab} ts. განახლება (მონაცემები) ამობეჭდვა ("[INFO] მონაცემები გაიგზავნა 5 ველზე: ", tempLab, tempExt, humLab, presSL, altLab)

თქვენი არხის მონაცემების განახლებით შეინახეთ სკრიპტი და შეასრულეთ იგი თქვენს ტერმინალში:

sudo Python3 localData_ToTs_v1_EXT.py

საკომუნიკაციო პროტოკოლების შესახებ

გაითვალისწინეთ, რომ "thingspeak ბიბლიოთეკის" გამოყენებით ხდება "მოთხოვნების ბიბლიოთეკის" იმპორტირება, ეს არის Apache2 ლიცენზირებული HTTP ბიბლიოთეკა, დაწერილი პითონში. ოფიციალური მოთხოვნის ინსტალაციის დოკუმენტაცია შეგიძლიათ იხილოთ აქ:

docs.python-requests.org/en/latest/user/install/

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

sudo pip3 ინსტალაციის მოთხოვნა

სურვილისამებრ შეგიძლიათ გამოიყენოთ MTTQ, როგორც მეთოდი ThingSpeak– ში მონაცემების გაგზავნისთვის. MQTT განსხვავდება HTTP– ისგან, ერთხელ იგი სპეციალურად შექმნილია მსუბუქი და განკუთვნილია ჩამონტაჟებული მოწყობილობებისთვის დაბალი ოპერატიული მეხსიერებით და პროცესორის მუშაობით. ასევე, უმეტეს შემთხვევაში, MQTT იყენებს ნაკლებ გამტარობას.

მიმართეთ ამ სახელმძღვანელოს: განაახლოთ ThingSpeak არხი MQTT გამოყენებით Raspberry Pi– ზე მეტი დეტალებისთვის.

ნაბიჯი 8: დისტანციური მონაცემების გაგზავნა ThingSpeak– ში ESP8266– ის გამოყენებით

ამ ნაბიჯისათვის ჩვენ გამოვიყენებთ იმავე HW- ს, რომელიც განმარტებულია muy tutorial– ში:

IOT MASE EASY: გადაღების დისტანციური ამინდის მონაცემები: ულტრაიისფერი და ჰაერის ტემპერატურა და ტენიანობა

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

პირველ რიგში, მოდით დავრეკოთ ESP8266 ბიბლიოთეკაში, განვსაზღვროთ WiFi კლიენტი და განვსაზღვროთ თქვენი ადგილობრივი როუტერი და Thinkspeak სერთიფიკატები:

/ * NodeMCU ESP12-E */

#მოიცავს WiFiClient კლიენტს; const char* MY_SSID = "შედი შენი SSDID- ით"; const char* MY_PWD = "შედი შენი პაროლით"; /* Thinkspeak*/ const char* TS_SERVER = "api.thingspeak.com"; სიმებიანი TS_API_KEY = "შედი შენი დაწერილი გასაღებით";

მეორე, მოდით ჩავრთოთ ძალიან მნიშვნელოვანი ბიბლიოთეკა IoT პროექტებისთვის: SimpleTimer.h:

/ * ტაიმერი */

#მოიცავს SimpleTimer ტაიმერს;

მესამე, დაყენების დროს (), ჩვენ დავიწყებთ სერიულ კომუნიკაციას, მოვუწოდებთ ფუნქციას connectWiFi () და ვადგენთ ქრონომეტრებს. გაითვალისწინეთ, რომ კოდის ხაზი: timer.setInterval (60000L, sendDataTS); დარეკავს ფუნქციას sendDataTS () ყოველ 60 წამში ერთხელ, რათა ატვირთოს მონაცემები ThinkSpeak არხზე.

ბათილად დაყენება ()

{… Serial.begin (115200); დაგვიანება (10); … ConnectWifi (); timer.setInterval (60000L, sendDataTS); …}

ბოლოს და ბოლოს, მარყუჟის დროს (), ერთადერთი ბრძანება საჭიროა ტაიმერის ინიცირება და ეს არის!

ბათილი მარყუჟი ()

{… Timer.run (); // იწყებს SimpleTimer} - ს

ქვემოთ შეგიძლიათ ნახოთ ორი მნიშვნელოვანი ფუნქცია, რომლებიც გამოიყენება Thinkspeak კომუნიკაციის დასამუშავებლად:

ESP12-E კავშირი თქვენს WiFi ქსელთან:

/***************************************************

*WiFi დაკავშირება ******************************************** ***/ void connectWifi () {Serial.print ("დაკავშირება"+*MY_SSID); WiFi. დასაწყისი (MY_SSID, MY_PWD); while (WiFi.status ()! = WL_CONNECTED) {დაგვიანებით (1000); Serial.print ("."); } Serial.println (""); Serial.println ("WiFi დაკავშირებულია"); Serial.println (""); }

ESP12-E აგზავნის მონაცემებს ThinkSpeak– ში:

***************************************************

*მონაცემების გაგზავნა Thinkspeak არხზე **************************************** ******/ void sendDataTS (void) {if (client.connect (TS_SERVER, 80)) {String postStr = TS_API_KEY; postStr += "& field6 ="; postStr += სიმებიანი (ტემპი); postStr += "& field7 ="; postStr += სიმებიანი (hum); postStr += "& field8 ="; postStr += სიმებიანი (dataSensorUV); postStr += "\ r / n / r / n"; client.print ("POST /განახლება HTTP /1.1 / n"); client.print ("მასპინძელი: api.thingspeak.com / n"); client.print ("კავშირი: დახურვა / n"); client.print ("X-THINGSPEAKAPIKEY:" + TS_API_KEY + "\ n"); client.print ("შინაარსი-ტიპი: განცხადება/x-www-form-urlencoded / n"); client.print ("შინაარსი-სიგრძე:"); client.print (postStr.length ()); client.print ("\ n / n"); client.print (postStr); დაგვიანება (1000); } გაგზავნილი ++; client.stop (); }

სრული კოდი შეგიძლიათ იხილოთ ჩემს GitHub– ზე: NodeMCU_UV_DHT_Sensor_OLED_TS_EXT

მას შემდეგ რაც კოდი აიტვირთება თქვენს NodeMCU- ში. მოდით დავუკავშიროთ გარე ბატარეა და გავაკეთოთ გაზომვები მზის ქვეშ. დისტანციური სადგური სახურავზე დავაყენე და ვიწყებ მონაცემების გადაღებას ThingSpeak.com– ზე, როგორც ეს მოცემულია ზემოთ მოცემულ ფოტოებში.

ნაბიჯი 9: საბოლოო შენიშვნები

ამ გაკვეთილის მთავარი მიზანი იყო იმის ჩვენება, თუ როგორ უნდა დაუკავშიროთ Raspberry Pi ThingSpeak– ს. ეს შესანიშნავია მონაცემების გადასაღებად და IoT პლატფორმაზე შესასვლელად.

შანსის გამოყენებით ჩვენ ასევე გავაგზავნეთ მონაცემები იმ კონკრეტულ არხზე, ვიღებთ მათ დისტანციური სადგურიდან ESP8266 გამოყენებით. ეს მიდგომა ნორმალურია, მაგრამ არა საუკეთესო. იმის გამო, რომ ჩვენ გვაქვს "ასინქრონული" ოპერაცია, ზოგჯერ, ორივე, RPi და ESP8266 ცდილობენ ჩაწერონ ერთდროულად (ან მცირე ინტერვალით) ის, რასაც უარყოფს ThingSpeak. იდეალური იქნებოდა ESP8266 გაგზავნოს მონაცემები ადგილობრივად Raspberry Pi– ში და ბოლო იყოს პასუხისმგებელი ყველა მონაცემის დამუშავებაზე. ამის გაკეთება, "მთავარ სადგურს" (ჟოლოს პი), შეეძლო 3 რამის გაკეთება:

• ჩაწერეთ ყველა მონაცემი ადგილობრივ მონაცემთა ბაზაში
• წარმოადგინეთ ყველა მონაცემი ადგილობრივ ვებგვერდზე (გამოიყენეთ Flask როგორც ნაჩვენებია ზემოთ ფოტოში)
• ყველა მონაცემის გაგზავნა ThingSpeak– ში ერთდროულად.

მომავალ გაკვეთილზე ჩვენ შევისწავლით ამ ვარიანტებს.

ნაბიჯი 10: დასკვნა

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

დეტალებისა და საბოლოო კოდისათვის ეწვიეთ ჩემს GitHub საცავს: RPi-NodeMCU- ამინდის სადგური

მეტი პროექტისთვის ეწვიეთ ჩემს ბლოგს: MJRoBot.org

Ადევნეთ თვალყური! შემდეგი გაკვეთილი ჩვენ გავაგზავნით მონაცემებს დისტანციური ამინდის სადგურიდან ცენტრალურზე, Raspberry Pi ვებ სერვერზე დაყრდნობით:

სალუდო მსოფლიოს სამხრეთიდან!

შევხვდებით ჩემს შემდეგ ინსტრუქტაჟში!

Გმადლობთ, მარსელო