თვალყური ადევნეთ ჰაერის ხარისხს Grafana და Raspberry Pi გამოყენებით: 7 ნაბიჯი

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

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

dzone.com/articles/raspberry-pi-iot-sensor…

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

მე ასევე შევეხები ჰაერის სენსორების MQ* მოდელების ეფექტურობას და გარკვეულწილად შეზღუდვას. MQ* სენსორები იაფი და საკმაოდ ეფექტურია და მათი დაყენება ძალიან მარტივია.

საერთო ჯამში ეს დაგეხმარებათ დაიწყოთ Arduino– ს ინტერნეტთან დაკავშირება უმარტივესი გზით და ადგენს გზას მსუბუქი ნაკვალევის მოდულების გამოყენებისათვის (ხელახლა: ESP8266).

Გაერთე!

ნაბიჯი 1: აღჭურვილობა + დაყენება

აღჭურვილობა

• Raspberry Pi დაყენებული Raspberry Pi
• ჟოლო Pi კვების წყარო
• Arduino Uno/ექვივალენტი
• მამაკაციდან მამაკაცამდე USB ტიპი B– დან A– მდე (უნდა მოყვეს თქვენი Arduino– სთან ერთად)
• ნებისმიერი MQ* სენსორი (მე გამოვიყენე MQ-2, 4, 5 და 135)
• მრავალფეროვანი ჯუმბერის მავთულები
• მინი პურის დაფა

Აწყობა

ეს გაკვეთილი იგულისხმება როგორც რბილი შესავალი Arduino და Raspberry Pi– ს გამოყენებისას - ის დაგეხმარებათ იცოდეთ როგორ გამოიყენოთ linux ტერმინალი. თუმცა, მე არ ვთვლი არდუინოზე ან ჟოლოს პიზე მუშაობის დიდ გამოცდილებას - ყველაფერი რაც თქვენ ნამდვილად გჭირდებათ არის აღჭურვილობა და ცნობისმოყვარე დამოკიდებულება.

• თქვენ უნდა შეასრულოთ ნაბიჯები ამ სახელმძღვანელოში.
• მე გირჩევთ გამოიყენოთ Secure Shell (SSH) Raspberry Pi– თან დასაკავშირებლად, რადგან ეს საშუალებას გაძლევთ მარტივად შეიყვანოთ ბრძანებები. SSH– ით დაკავშირება განსხვავდება Windows– ის, Linux– ის თუ Mac– ის გამოყენებით. Linux და Mac საკმაოდ ადვილია ssh– სთან დაკავშირებით (SSH– ის გახსნის ბრძანება ფაქტიურად ssh). შეამოწმეთ Putty Windows- ისთვის. გირჩევთ შეამოწმოთ ეკრანი, როგორც საშუალება თქვენი სესიის შესანარჩუნებლად პროექტის განმავლობაში.
• თქვენ ასევე დაგჭირდებათ პითონის დაყენება Raspbian– ზე. როდესაც ეს ნაბიჯები დავასრულე, მე გავაკეთე ძველი SD ბარათის ასლი, რომელიც მქონდა წინა პროექტიდან, რომელშიც უკვე დამონტაჟებული იყო პითონი. თუ NOOBS/Raspbian– ის თქვენს განაწილებას არ აქვს Python 3.7 ან ზემოთ, გადახედეთ ამ ნაბიჯებს პითონის წყაროს შესადგენად.
• გაეცანით git- ს და დააინსტალირეთ ის იმ შემთხვევაში, თუ ის უკვე არ არის დაინსტალირებული Raspbian– ის თქვენს გავრცელებაში.

ნაბიჯი 2: სქემის დაყენება

არის ერთი წრე, რომელიც გჭირდებათ Arduino– ში.

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

ყველა MQ-* გაზის სენსორის სილამაზე იმაში მდგომარეობს იმაში, რომ მას შემდეგ რაც 5 ვოლტიანი და სახმელეთო კავშირი გაკეთდება, არდუინოს ანალოგური ქინძისთავების შეყვანის წინააღმდეგობა საშუალებას აძლევს სენსორს სწორად იმუშაოს.

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

ნაბიჯი 3: Arduino კოდი და Flashing

ამ ნაბიჯის შემდგომ ნაბიჯში, ჩვენ დავაკავშირებთ Arduino დაფას Raspberry Pi- თან. სანამ ამას გავაკეთებთ, ჩვენ უნდა დავაბრმავოთ Arduino– ს კოდი სენსორის წასაკითხად, ასევე სენსორის მონაცემების გადაცემა Raspberry Pi– ზე. ეს შეიძლება გაკეთდეს ნებისმიერი გზით, როგორც წესი, კოდს არდუინოში აყენებთ. მე გამოვიყენე მესამე მხარის ინსტრუმენტი Arduino IDE– ს გარდა - შესაბამისად, მე Arduino ბიბლიოთეკას ვდებ თავზე. ეს არ არის საჭირო სხვა პროექტებისთვის.

ამ ნაწილის ბოლოს შეამოწმეთ კოპირების/ჩასმის კოდი.

რას აკეთებს კოდი

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

მარყუჟში ჩვენ ვამოწმებთ, ითხოვს თუ არა Raspberry Pi მონაცემებს ჩვენგან. აქედან გამომდინარე, ჩვენ ვიყენებთ ძალიან მარტივ Master/Slave კონფიგურაციას, სადაც Raspberry Pi განუწყვეტლივ მიმართავს Arduino– ს მონაცემებს. ეს ბევრად უფრო ადვილია, ვიდრე მრიცხველი არდუინოს კოდში, რადგან უფრო ადვილია შეამოწმო რა ღირებულებები მუშაობს ჟოლოს პიდან, იმის ნაცვლად, რომ არდოინოს ახალი მნიშვნელობები აანთო.

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

მარტივი ტესტირება…

მას შემდეგ რაც Arduino აანთებს და კოდს გაუშვებს, გახსენით Arduino IDE– ს სერიული მონიტორი. თუ თქვენ გაგზავნით ერთ პერსონაჟს "H" (უზრუნველყავით მისი კაპიტალი!) თქვენ მიიღებთ მონაცემთა დატვირთვას. გილოცავთ, მუშაობს!

MQ-* მონაცემების ნიმუში, ასინქრონული კოლექციონერი

#ჩართეთ

int mq2 = A2;

int mq4 = A3;

int mq5 = A4;

int mq135 = A5;

int incomingByte;

voidsetup () {

pinMode (mq2, INPUT);

pinMode (mq4, INPUT);

pinMode (mq5, INPUT);

pinMode (mq135, INPUT);

სერიული.დაწყება (9600);

}

/* valuePrint ბეჭდავს ამ ლეიბლის მნიშვნელობას.

* ქმნის მხოლოდ გვერდით ეფექტებს.

*/

voidvaluePrint (სიმებიანი ეტიკეტი, int კითხვა) {

Serial.print (ეტიკეტი);

Serial.print ("=");

სერიული. ბეჭდვა (კითხვა);

}

voidloop () {

// ნახე თუ არის შემომავალი სერიული მონაცემები:

if (Serial.available ()> 0) {

// წაიკითხეთ უძველესი ბაიტი სერიულ ბუფერში:

// "როდესაც თქვენ დარეკავთ Serial.read- ში ბაიტი ამოღებულია მიმღების ბუფერიდან და დაუბრუნდება თქვენს კოდს"

incomingByte = Serial.read ();

// თუ ეს არის დიდი H (ASCII 72), წაიკითხეთ მნიშვნელობები და გაუგზავნეთ ჟოლოს მასპინძელს.

// TODO: დარწმუნდით, რომ შეტყობინება ყოველთვის იგივე სიგრძეა, ყოველ ჯერზე

თუ (შემომავალიბაიტი == 72) {

int mq2Reading = analogRead (mq2);

int mq4Reading = analogRead (mq4);

int mq5Reading = analogRead (mq5);

int mq135Reading = analogRead (mq135);

Serial.print ("?");

valuePrint ("mq2", mq2 კითხვა);

Serial.print ("&");

valuePrint ("mq4", mq4Reading);

Serial.print ("&");

valuePrint ("mq5", mq5 კითხვა);

Serial.print ("&");

valuePrint ("mq135", mq135 კითხვა);

Serial.print ("\ n");

}

}

// წაიკითხეთ სერიალი მხოლოდ ყოველ წამს

დაგვიანება (1000);

}

rawmain.cpp ნახვა hosted ერთად GitHub

ნაბიჯი 4: ჟოლოს პი კოდი

ახლა, როდესაც თქვენ დააკონფიგურირეთ Raspberry Pi https://dzone.com/articles/raspberry-pi-iot-sensor… შესაბამისად, ახლა შეგიძლიათ გაუშვათ Raspberry Client კოდი, რომელიც მონაცემებს MQTT- ით გამოაგზავნის ჩვენს მონაცემთა ბაზაში, რომელიც ასევე აკავშირებს გრაფანასთან.

1. დარწმუნდით, რომ თქვენი ჟოლო ინტერნეტთან არის დაკავშირებული და შემდეგ შეასრულეთ git clone ბრძანება, რომ დააკოპიროთ მთელი კოდი Raspberry Pi– ში. შენი ბრძანება ცოტათი გამოიყურება:

   git კლონი

2. ჟოლოს პი ტერმინალში შეასრულეთ დირექტორიის შეცვლის ბრძანება (cd) "raspberry_client" - ში:

   cd raspberry_client.

3. თქვენ დაგჭირდებათ ვირტუალური გარემოს გამოყენება*. უბრალო. გაიქეცი

   python3 -m venv envრა ეს შექმნის ვირტუალურ გარემოს სახელწოდებით "env", რომელსაც ჩვენ გამოვიყენებთ დამოკიდებულებების დასაყენებლად.

4. ახლა ჩვენ უნდა შევიდეთ ჩვენს ვირტუალურ გარემოში. გაშვება:

   წყარო env/bin/გააქტიურებარა თქვენ ახლა მზად ხართ დააინსტალიროთ პროექტის დამოკიდებულებები.

5. თქვენ მიერ კლონირებული პაკეტში არის ფაილი სახელწოდებით պահանջვები. Txt. გახსენით ეს ფაილი; თქვენ ნახავთ, რომ ჩვენ გვჭირდება paho-mqtt და pyserial პაკეტები, ასევე მათი შესაბამისი ვერსიები. თქვენ შეგიძლიათ ნახოთ ფაილის შინაარსი გაშვებით

   კატის მოთხოვნები. txtრა ამ პაკეტების დაყენების მიზნით, ru

   pip install -r მოთხოვნები. txt.

6. ეს ამთავრებს კონფიგურაციას.

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

რას აკეთებს კოდი…

Client.py ფაილი შემოიტანს ბიბლიოთეკების მარტივ კომპლექტს, მათ შორის ჩვენს საკუთარ arduinosensor- ს. მთავარ ფუნქციაში ჩვენ მივიღებთ მნიშვნელობებს Arduino– დან, გამოვაქვეყნებთ მონაცემებს MQTT ბროკერზე და შემდეგ ვიძინებთ 10 წამის განმავლობაში.

Arduinosensor.py ფაილი არის დამხმარე მეთოდების ერთობლიობა, რომელიც შემოიფარგლება paho.mqtt ბიბლიოთეკის გარშემო, ასევე უზრუნველყოფს სასარგებლო კომუნიკაციის სქემას Arduino– ს დატვირთვასთან (იხ.: parse_payload). რა თქმა უნდა, კოდი თან ერთვის ამ განყოფილების ბოლოს.

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

იმპორტირებულიდან იმპორტის_მოდული

იმპორტები

იმპორტის დრო

იმპორტარუინოსენსორი

defmain ():

# განსაზღვრული კლიენტის გახსნა

დაწყების_დრო = დრო. დრო ()

მართალია:

კითხვა = arduinosensor.get_values (os.environ.get ('PORT', "/dev/ttyUSB0"))

arduinosensor.pub ("python_client", payload = კითხვა)

დრო. ძილი (10.0- ((დრო. დრო () -დაწყების დრო) %10.0))

if_name _ == "_ მთავარი_":

მთავარი ()

rawclient.py– ს ნახვა GitHub– ით

ნაბიჯი 5: ყველაფერი ერთად ააწყვეთ

ჩვენ გვაქვს ჟოლოს პითონის კოდი დაყენებული და გვაქვს Arduino კლიენტის კოდი. მოდით გადავიდეთ ორივე ერთეულის ერთმანეთთან დაკავშირებაზე.

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

1. თქვენს Raspberry Pi ტერმინალზე გაუშვით

   პითონი -m serial.tools.list_portsრა ეს ჩამოთვლის ყველა USB პორტს, რომელიც მხარს უჭერს სერიულ კომუნიკაციას.

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

   პითონი -m serial.tools.list_ports კიდევ ერთხელ გაჩვენებთ პორტებს. თქვენ შეიძლება ნახოთ დამატებითი ჩამონათვალი გამოჩნდება - თუ ეს მართლაც ასეა, მაშინ ეს ახალი ჩანაწერი არის ჩანაწერი, რომელშიც თქვენი Arduino არის დაკავშირებული. ეს სავარაუდოდ იქნება "/dev/ttyUSB0".

3. სცადეთ გაუშვათ პითონის კოდი თქვენს ვირტუალურ გარემოში python3.7 client.py გაშვებით. დაელოდეთ რამდენიმე წამს (მაქსიმუმ ათი) - თუ გამონაკლისის წინაშე აღმოჩნდებით, ეს ნიშნავს, რომ ჩვენ უნდა შეცვალოთ ჟოლოს პიზე ჩვენი კომპორტის მნიშვნელობა. თუ დაინახავთ, რომ კოდი ბეჭდავს სტრიქონს დაწყებული "გაგზავნილი შემდეგი დატვირთვით: …" შემდეგ, კარგი იქნება, რომ გააგრძელოთ საბოლოო ნაბიჯი გრაფანასთან ერთად. რჩევა: დარწმუნდით, რომ გაუშვით

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

   1. COM პორტის მნიშვნელობის შესაცვლელად, თქვენ უნდა დააყენოთ გარემოს ცვლადი კოდის გაშვებამდე. თქვენ უნდა სცადოთ ეს გამომავალი ყველა შესაძლო მნიშვნელობისთვის, რაც მიიღეთ პითონის -m serial.tools.list_ports გაშვებისას. მაგალითად, თუ მე მივიღე ჩანაწერების რაოდენობა ორი და იყო შემდეგი:

      • /dev/ttyUSB6
      • /dev/acm0

მაშინ ბრძანებები, რომლებსაც მე შევასრულებდი იქნება:

PORT = "/dev/ttyUSB6" python3.7 client.pyდა თუ ეს არ იმუშავებდა, მე შემდგომში ru

PORT = "/dev/acm0" python3.7 client.py

ამ ნაბიჯების დასრულების შემდეგ, კოდი მიანიჭებს მონაცემებს ჩვენს influxdb მონაცემთა ბაზის მაგალითს, რომელიც Grafana– სთან დაკავშირებისას მოგვცემს საშუალებას ნახოთ ჩვენი დაფა.

ნაბიჯი 6: Grafana კონფიგურაცია და დაფის ნახვა

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

1. დაუკავშირდით თქვენს გრაფანას მაგალითს. მას შემდეგ, რაც თქვენ დაიცავით დზონის ორიგინალური სტატიის ნაბიჯები, თქვენ უნდა შეგეძლოთ შესვლა თქვენი ადმინისტრატორის მომხმარებელთან. წადი და შედი.
2. მარცხენა სარკმელზე, გადაიტანეთ "დაფის" ხატზე - ოთხი კვადრატი. დააჭირეთ ღილაკს "მართვა".
3. ახალ გვერდზე დააჭირეთ ღილაკს "ახალი დაფა". შემდეგ დააჭირეთ ღილაკს "დაამატე ახალი პანელი".

4. ეს ხსნის Grafana რედაქტორს. ჩვენ შევქმნით მარტივ ხედს, რომელიც აჩვენებს ერთ მეტრს.

   1. მარჯვენა სარკმელში შეცვალეთ პანელის სათაური რაიმე მნიშვნელობით, მაგალითად "სამზარეულოს საკითხავი". თქვენ ასევე შეგიძლიათ შეიყვანოთ სურვილისამებრ აღწერა.
   2. ქვედა მარცხენა ნაწილში, "შეკითხვა", ჩვენ დავამატებთ ერთჯერადი დროის სერიას. Grafana ნამდვილად ანათებს აქ, რადგან ჩვენ შეგვიძლია მარტივად შევქმნათ SQL განცხადებები დაწკაპუნებით დაფუძნებული ინტერფეისით. "ნაგულისხმევი" პუნქტში აირჩიეთ InfluxDB.
   3. ახლა, "A" - ს წასაკითხად - FROM პუნქტში აირჩიეთ გაზომვა "airtestt". თუ თქვენ შეხედავთ პითონის ორიგინალურ კოდს arduinosensor.py- ის get_values ფუნქციაში, დაინახავთ, რომ ჩვენ განვსაზღვრავთ ამ airtestt ცხრილს კოდში.
   4. ნიმუშისთვის გადავიდეთ "SELECT" პუნქტში და ავირჩიოთ ველი (mq4). თავდაპირველად ჩვენი დაფა მოგვცემს არჩევანს "ნიშნავს ()" - დააწკაპუნეთ ამ არჩევანზე და აირჩიეთ "წაშლა". შემდეგ, დააწკაპუნეთ პლიუს ნიშანზე და "აგრეგაციების" განყოფილებაში აირჩიეთ "განსხვავებული ()". ეს აჩვენებს კონკრეტულ დროის წერტილებს. ჩვენ შეგვიძლია ავირჩიოთ სხვა ზომები, მაგრამ ამჟამად, ჩვენი პანელი აჩვენებს მკაფიო კითხვას mq4– დან.
   5. დააწკაპუნეთ შენახვაზე ზედა მარჯვენა კუთხეში და თქვენ დასრულებული ხართ!

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

ნაბიჯი 7: შეფუთვა

ამ გაკვეთილში თქვენ შეძელით შექმნათ ძლიერი MQTT ქსელი, რომელიც შედგება ერთი კვანძისა და ბროკერისგან. თქვენ ასევე შეძელით თქვენი IOT მონაცემების ვიზუალიზაცია Grafana– ს გამოყენებით. დაბოლოს, თქვენ შეძელით ამ მარტივი სისტემის არქიტექტურის შედგენა (იმედია) თქვენი ბრაუზერისა და კომპიუტერის კომფორტიდან SSH კავშირის გამოყენებით.

არის რაღაცეები, რისი გაუმჯობესებაც გვსურს.

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

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

დამატებითი კითხვები: