Traffic Report Check (NL) Doormat: 6 Steps

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

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

მე ვიმუშავებ NodeMCU 1.0-ზე (ESP0-12E მოდული). ამ პროექტის კოდს შეუძლია იმუშაოს სხვა მოწყობილობებზეც (მაგ. Arduino დაფები). ეს პროექტი ემყარება ჰოლანდიურ წყაროს ტრაფიკის ანგარიშებს, ANWB.

რა გვჭირდება ამ პროექტისთვის:

- NodeMCU - Jumper ხაზები - LEDlight ან ზოლები - ანალოგური სენსორი (Aluminiuim კილიტა, Sponge) - Wi -Fi კავშირი - Doormat

ნაბიჯები, რომლებიც ჩვენ უნდა გადავდოთ:

1. დაუკავშირეთ NodeMCu Wi-Fi– ს 2. მოითხოვეთ მონაცემები HTTPS– ით ANWB.nl– დან 3. გადააქციეთ მონაცემები გამოსაყენებელ ინფორმაციად 4. დააინსტალირეთ ტრიგერი 5. გამოხმაურების დიზაინი

ნაბიჯი 1: დაუკავშირეთ NodeMCU Wi-Fi– ს

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

პირველი, დააინსტალირეთ ESP8266 ბიბლიოთეკა Arduino IDE- ში. გახსენით მაგალითებიდან ESP8266>

შეავსეთ თქვენი Wi-Fi სერთიფიკატები თქვენი კოდის ზედა ნაწილში, როგორც ეს ნაჩვენებია ქვემოთ:

const char* ssid = "YOUR_SSID";

const char* პაროლი = "YOUR_PASS";

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

ნაბიჯი 2: მოითხოვეთ მონაცემები HTTPS– დან ANWB.nl– დან

ამ მეორე ეტაპზე თქვენ შეცვლით მონაცემთა წყაროს ნაგულისხმევიდან ამ პროექტისათვის საჭირო წყაროს: ANWB.nl.

თქვენი კოდის თავში შეცვალეთ char* მასპინძელი www.anwb.nl (ან სხვა წყაროდან, საიდანაც გსურთ მიიღოთ თქვენი მონაცემები):

const char* მასპინძელი = "www.anwb.nl";!! თუ თქვენ იყენებთ სხვა წყაროს, ნაბიჯი 3 განსხვავებული იქნება ჩემი კოდისგან. მე –3 ნაბიჯს სჭირდება კონკრეტული კოდირება გამოსაყენებელი ინფორმაციის მოსაპოვებლად!

შემდეგი, შეცვალეთ სტრიქონის url ფუნქციის კონფიგურაციაში "/feeds/gethf", გზა, საიდანაც მიიღება ინფორმაცია:

სიმებიანი url = "/feeds/gethf";!! თუ იყენებთ სხვა წყაროს, გამოიყენეთ თქვენი წყაროს გზა!

კოდის ატვირთვისას თქვენ უნდა მიიღოთ პასუხი ყველა მონაცემით www.anwb.nl/feeds/gethf. ეს კოდი ინახება სტრიქონში, რომელსაც ეწოდება ხაზი.

ნაბიჯი 3: გადააქციეთ მონაცემები გამოსაყენებელ ინფორმაციად

აქამდე, კოდი მუშაობდა მხოლოდ NodeMCU– ის დაწყების ან გადატვირთვისას, რადგან ყველა კოდი დაყენების ფუნქციაშია. კოდის განუწყვეტლივ გაშვების გამომწვევის დასაყენებლად თქვენ უნდა შეცვალოთ კოდის პოზიცია, რომელიც მუშაობს HTTPS მოთხოვნაზე. მარყუჟის ფუნქციის ქვემოთ, თქვენ დაამატებთ სხვა ფუნქციას. მე მას ვუწოდებ void extractData:

extractData () {

}

დააკოპირეთ კოდის ნაწილი დაყენების ფუნქციიდან extractData () - ში. დაიწყეთ შემდეგი ხაზით დაყენების ფუნქციის დასრულებამდე:

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

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

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

extractData (); დაგვიანება (30000); // ეს მოგვიანებით წაიშლება, როდესაც ჩვენ გვაქვს ანალოგური სენსორი}

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

პირველი, შეამოწმეთ სიტყვა "გზის" ყველა პოზიცია. სიტყვის "გზის" შემდეგ გზის სახელი მოყვება (A1, A2 და ა.შ.).

სანამ დაიწყებთ for მარყუჟების წერას, თქვენ უნდა გამოაცხადოთ რამდენიმე ცვლადი, რომელსაც აპირებთ გამოიყენოთ:

int noOfPos = 0;

ლოგიკური hasRunOnce = ყალბი; int საწყისი = 0; int roadArray [20];

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

მარყუჟისათვის No1: იპოვეთ სიტყვა გზის პოზიციები სიმებიანი ხაზით:

for (int i = 0; i <line.length (); i ++) {int pos = line.indexOf ("road \": ", from); roadArray [noOfPos] = pos; noOfPos+= 1; from = pos + 1; if (hasRunOnce == ჭეშმარიტი && pos == line.indexOf ("გზა \": ")) {i = line.length (); } hasRunOnce = ჭეშმარიტი; }

შემდეგი, შეამოწმეთ რა გზებზეა საცობი, for for loop ზემოდან. გზების სახელის პოზიცია ყოველთვის ერთია და იწყება 7 სიმბოლო და მთავრდება 10 სიმბოლო სიტყვის შემდეგ.

ახლა ჩვენ განვსაზღვრავთ მასივის სახელსOfRoadArray, რომელიც ივსება შემდეგ მარყუჟში:

სიმებიანი სახელიOfRoadArray [20];

მარყუჟისათვის No2: იპოვეთ გზების ყველა დასახელება მარყუჟის no- დან. 1

for (int k = 0; k <20; k ++) {int pos = roadArray [k]; int positionOfRoadName = pos + 7; int endOfPositionOfRoadName = pos + 10; nameOfRoadArray [k] = line.substring (positionOfRoadName, endOfPositionOfRoadName); }

მასივის სახელიOfRoudArray უნდა იყოს შევსებული ყველა საცობზე.

შემდეგი, თქვენ აპირებთ შეამოწმოთ თქვენი გზა არის გზების მასივში საცობებით. დაბეჭდეთ სახელიOfRoadArray, რომ მიიღოთ გზები მონაცემებში. ამის გაკეთება Serial.println (nameOfRoadArray [k]) დამატებით; მე –2 მარყუჟისთვის, როგორიცაა:

for (int k = 0; k <20; k ++) {int pos = roadArray [k]; int positionOfRoadName = pos + 7; int endOfPositionOfRoadName = pos + 10; nameOfRoadArray [k] = line.substring (positionOfRoadName, endOfPositionOfRoadName); Serial.println (nameOfRoadArray [k]); }

თუ ეს სწორია, სერიულ მონიტორში ნახავთ ყველა გზას საცობებით.

ბოლო მარყუჟის ჩაწერამდე, თქვენ უნდა გამოაცხადოთ ლოგიკური გლობალური ცვლადი. ლოგიკური, რომელსაც ეწოდება trafficJam არის ნაგულისხმევი ყალბი და შეიცვლება, თუ ფუნქცია extractData დაბრუნდება true საცობის დროს. შემდეგი კოდი მიდის.ino ფაილის თავზე:

boolean trafficJam = false;

მარყუჟისათვის No3: შეამოწმეთ არის თუ არა გზა, ამ შემთხვევაში A1, საცობების სიაში.

for (int l = 0; l <20; l ++) {if (nameOfRoadArray [l] == "A1 \" ") {// შეცვალეთ A1 თქვენი სასარგებლოდ მიმავალი გზიდან trafficJam = true;}

თუ თქვენ დაბეჭდავთ trafficJam სერიულ მონიტორში, თქვენ იცით, არის თუ არა საცობი A1– ზე თუ არა.

განათავსეთ ეს კოდი extractData ფუნქციის ბოლოში:

Serial.println (trafficJam); // ნახეთ არის თუ არა საცობი

ამ ინფორმაციის საშუალებით ჩვენ ვაპირებთ შემდგომ მუშაობას სისტემის უკუკავშირზე მე –5 ნაბიჯში.

ნაბიჯი 4: დააინსტალირეთ გამომწვევი

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

ანალოგური სენსორის შექმნა

მე გამოვიყენე 2 ცალი ალუმინის კილიტა, ორი ჯუმბერის მავთული და ღრუბელი.

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

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

int sensorValue = analogRead (A0);

if (sensorValue == 1024) {extractData (); }

როდესაც ალუმინის კილიტა კონტაქტს ამყარებს (როდესაც ვინმე დგას ხალიჩაზე), sensorValue არის 1024. ეს იწვევს ფუნქციის extractData () სროლას. და ეს არის ზუსტად ის, რაც ჩვენ გვინდა გავაკეთოთ სისტემამ.

ნაბიჯი 5: დიზაინის კავშირი

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

ჩაწერეთ ეს კოდი თქვენი ფაილის თავში, რათა დარწმუნდეთ, რომ LED ზოლი განსაზღვრულია:

#ჩართეთ

#განსაზღვრეთ PIXEL_PIN D5 #განსაზღვრეთ PIXEL_COUNT 10 #განსაზღვრეთ PIXEL_TYPE NEO_GRB + NEO_KHZ800 Adafruit_NeoPixel pixels = Adafruit_NeoPixel (PIXEL_COUNT, PIXEL_PIN, PIXEL_TYPE);

ჩაწერეთ შემდეგი კოდი დაყენების ფუნქციაში:

// ნეოპიქსელი

pixels.begin (); pixels.show ();

და შემდეგი კოდი მარყუჟის ფუნქციაში:

თუ (trafficJam == ჭეშმარიტი) {

for (int i; i <PIXEL_COUNT; i ++) {pixels.setPixelColor (i, 255, 0, 0); // წითელი პიქსელები. ჩვენება (); დაგვიანება (200); }} სხვა {for (int i; i <PIXEL_COUNT; i ++) {pixels.setPixelColor (i, 0, 255, 0); // მწვანე პიქსელები. ჩვენება (); დაგვიანება (200); }

ზემოთ მოცემულ კოდში არის if/else ფუნქცია. როდესაც ფუნქცია extractData აბრუნებს საცობის არსებობას, LEDstrip გახდება წითელი. თუ არა, LEDstrip გახდება მწვანე.

ნაბიჯი 6: გაუშვით კოდი

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

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