Երթևեկության հաշվետվության ստուգում (NL) դռան գավազանով. 6 քայլ

2024 Հեղինակ: John Day | [email protected]. Վերջին փոփոխված: 2024-01-30 09:49

Այս ուսանելի հոդվածում ես նկարագրելու եմ, թե ինչպես կարելի է դռան գոգ կառուցել, որը կստուգի հոլանդական մայրուղիների երթևեկության հաշվետվությունները: Երբ դուրս գաք ձեր դռան գավազանով և ձեր ճանապարհին խցանում լինի, գորգը կդառնա կարմիր գույն: Երբ խցանում չկա, գորգը կանաչ կդառնա:

Ես աշխատելու եմ NodeMCU 1.0 (ESP0-12E մոդուլ) վրա: Այս նախագծի ծածկագիրը կարող է աշխատել նաև այլ սարքերի վրա (օրինակ ՝ Arduino տախտակներ): Այս նախագիծը հիմնված է երթևեկության հաշվետվությունների հոլանդական աղբյուրի `ANWB- ի վրա:

Այն, ինչ մեզ պետք է այս նախագծի համար.

- NodeMCU - Jumper լարեր - LED լույս կամ ժապավեն - Անալոգային ցուցիչ (Aluminiuim փայլաթիթեղ, սպունգ) - Wi -Fi միացում - դռան գոգ

Քայլեր, որոնք մենք պետք է կատարենք.

1. Միացրեք NodeMCu- ն Wi-Fi- ին 2. Հարցրեք տվյալները HTTPS- ի միջոցով ANWB.nl- ից 3. Տվյալները վերածեք օգտագործելի տեղեկատվության 4. Տեղադրեք ձգանը 5. Նախագծեք հետադարձ կապ

Քայլ 1. Միացրեք NodeMCU- ը Wi-Fi- ին

Այս քայլը ցույց կտա, թե ինչպես անել հաջող HTTPSRequest ՝ տեսնելու համար, թե արդյոք սարքը միացված է ինտերնետին:

Նախ տեղադրեք ESP8266 գրադարանը Arduino IDE- ում: Բացեք ESP8266> HTTPSRequest օրինակներից:

Լրացրեք ձեր 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* host = "www.anwb.nl";!! Եթե այլ աղբյուր եք օգտագործում, 3 -րդ քայլը տարբեր կլինի իմ ծածկագրից: Քայլ 3 -ին անհրաժեշտ է հատուկ կոդավորում `օգտագործելի տեղեկատվություն ստանալու համար:

Հաջորդը, գործառույթի տեղադրման տողի url- ը փոխեք «/feeds/gethf» - ի, այն ուղին, որտեղից տեղեկատվությունը վերցված է.

Լարային url = "/feeds/gethf";!! Եթե այլ աղբյուր եք օգտագործում, օգտագործեք ձեր աղբյուրի ուղին:

Երբ ծածկագիրը վերբեռնում եք, դուք պետք է ստանաք պատասխանը բոլոր տվյալներով ՝ www.anwb.nl/feeds/gethf կայքից: Այս կոդը պահվում է տող կոչվող տողի մեջ:

Քայլ 3: Տվյալները վերածեք օգտագործելի տեղեկատվության

Մինչ այժմ, կոդը գործում էր միայն NodeMCU- ի գործարկման կամ վերակայման ժամանակ, քանի որ ամբողջ ծածկագիրը տեղադրման գործառույթում է: Կոդը անընդհատ գործարկելու ձգանը դնելու համար դուք պետք է փոխեք HTTPS հարցումը գործարկող ծածկագրի դիրքը: Օղակի գործառույթի ներքևում ավելացնում եք մեկ այլ գործառույթ: Ես այն անվանել եմ անվավեր քաղվածք Data:

extractData () {

}

Կոդի մի մասը տեղադրման գործառույթից extractData () - ում: Սկսեք հետևյալ տողից մինչև կարգաբերման գործառույթի ավարտը.

եթե (! client.connect (հյուրընկալող, Կոդն այժմ ձեր նոր գործառույթում է, այնպես որ հեռացրեք պատճենված ծածկագիրը կարգաբերման գործառույթից:

Հաջորդը, հանգույցի գործառույթում կանչեք extractData գործառույթը և որոշ ուշացում ավելացրեք, որպեսզի հանգույցին տրամադրվի հանգստի ժամանակ.

դատարկ շրջան () {

extractData (); ուշացում (30000); // սա կհեռացվի ավելի ուշ, երբ անալոգային սենսոր ունենանք}

Քանի որ ձեր ստացած տվյալները պահվում են տողի մեջ և անհրաժեշտ են միայն այս տողի մասերը, դուք պետք է մի քանի օղակ գրեք:

Նախ, ստուգեք «ճանապարհ» բառի բոլոր դիրքերը: «Roadանապարհ» բառից հետո կհաջորդի ճանապարհի անվանումը (A1, A2 և այլն):

Նախքան loops գրելը սկսելը, դուք պետք է հայտարարեք որոշ փոփոխականներ, որոնք դուք պատրաստվում եք օգտագործել.

int noOfPos = 0;

բուլյան hasRunOnce = կեղծ; int- ից = 0; int roadArray [20];

Այժմ ժամանակն է գրել մի քանի օղակ: Ես գրել եմ օղակները for extractData գործառույթի ներքևում: Փորձեցի այն բաժանել առանձին գործառույթների, բայց չկարողացա գործի դնել:

Թիվ 1 հանգույցի համար. Գտեք տողերի տողում ճանապարհ բառի դիրքերը.

for (int i = 0; i <line.length (); i ++) {int pos = line.indexOf ("road \": ", from); roadArray [noOfPos] = pos; noOfPos+= 1; from = pos + 1; if (hasRunOnce == true && pos == line.indexOf ("ճանապարհ \": ")) {i = line.length (); } hasRunOnce = ճշմարիտ; }

Հաջորդը, ստուգեք, թե որ ճանապարհներին է խցանում առաջանում ՝ օգտագործելով վերևի for հանգույցի դիրքերը: Theանապարհների անվան դիրքը միշտ նույնն է և ճանապարհ բառից հետո սկսում են 7 նիշ և ավարտում 10 նիշ:

Այժմ մենք սահմանում ենք զանգվածի անունըOfRoadArray, որը հաջորդ օղակի համար կլրացվի:

Լարային անվանումըOfRoadArray [20];

Loանց 2 -ի համար. Գտեք ճանապարհների բոլոր անունները `մուտքագրելով համարի օղակը: 1

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

Oանգվածի անվանումըOfRoudArray պետք է լրացվի ազդանշանված բոլոր խցանումներով:

Հաջորդը, դուք պատրաստվում եք ստուգել, թե արդյոք ձեր ճանապարհը խցանումով ճանապարհների զանգվածում է: Տպեք անունըOfRoadArray ՝ ճանապարհներին տվյալների մեջ հայտնվելու համար: Դա արեք ՝ ավելացնելով Serial.println (nameOfRoadArray [k]); երկրորդի մեջ ՝ հանգույցի համար, ինչպիսին է ՝

համար (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]); }

Եթե դա ճիշտ է, ապա սերիական մոնիտորում կտեսնեք խցանումով բոլոր ճանապարհները:

Նախքան վերջին Forop օղակը գրելը, դուք պետք է հայտարարեք boolean- ը որպես գլոբալ փոփոխական: Բուլյան, որը կոչվում է trafficJam, լռելյայն կեղծ է և կփոխվի, եթե extractData ֆունկցիան ճշմարիտ դառնա խցանումների դեպքում: Հետևյալ կոդը անցնում է.ino ֆայլի վերևում.

բուլյան trafficJam = կեղծ;

Թիվ 3 հանգույցի համար. Ստուգեք, արդյոք ճանապարհը, այս դեպքում A1- ը, խցանումների ցուցակում է:

for (int l = 0; l <20; l ++) {if (nameOfRoadArray [l] == "A1 \" ") {// փոխել A1- ը ձեր նախընտրած ճանապարհին trafficJam = true;}

Եթե դուք տպում եք trafficJam սերիական մոնիտորի վրա, ապա գիտեք ՝ A1- ում խցանում կա, թե ոչ:

Տեղադրեք այս կոդը extractData գործառույթի ներքևում.

Serial.println (trafficJam); // տեսնել, թե արդյոք խցանում կա

Այս տեղեկատվության շնորհիվ մենք հետագայում կաշխատենք համակարգի հետադարձ կապի վրա 5 -րդ քայլում:

Քայլ 4: Տեղադրեք ձգանը

Քանի որ այժմ մենք կարող ենք տվյալները հաջողությամբ վերցնել աղբյուրից, ժամանակն է կառուցել սենսոր, որը կհանգեցնի nodeMCU- ին գործարկել extractData գործառույթը: Ես ընտրեցի անալոգային սենսոր սարքել իմ դռան մահճից: Դուք կարող եք փոխել ձգանը ՝ օգտագործելով մեկ այլ սենսոր:

Անալոգային սենսորի կառուցում

Ես օգտագործեցի 2 հատ ալյումինե փայլաթիթեղ, երկու թռիչքային լար և սպունգ:

Սպունգի մեջ փոս փորեք, սա այն վայրն է, որտեղ ալյումինե փայլաթիթեղները կապ կհաստատեն: Սպունգի երկու կողմերում կպցրեք ալյումինե փայլաթիթեղ: Միացրեք jumper լարերը ալյումինե փայլաթիթեղին: Միացրեք jumper լարերը nodeMCU- ին: Մի կողմը A0- պինին, իսկ մյուսը V3- պինին: Սպունգը դրեք ձեր դռան տակ և դուք պարզապես դռան մահճը դարձրեցիք սենսոր: Հիանալի!

Սենսորից արժեքը կարդալու կոդը ՝ տեսնելու, թե արդյոք ինչ -որ մեկը կանգնած է դռան գորգի վրա.

int sensorValue = analogRead (A0);

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

Երբ ալյումինե փայլաթիթեղը շփվում է (երբ ինչ -որ մեկը կանգնած է գորգի վրա), sensorValue- ն 1024 է: Սա հանգեցնում է extractData () գործառույթի կրակման: Եվ դա հենց այն է, ինչ մենք ցանկանում ենք անել համակարգը:

Քայլ 5. Դիզայնի հետադարձ կապ

Ես օգտագործեցի LEDstrip ՝ օգտվողին հետադարձ կապ հաղորդելու համար: Երբ խցանում է, լույսը կարմիր գույն կունենա: Երբ ճանապարհը լավ գնա, այն կանաչ կդառնա: Ես օգտագործել եմ adafruit neopixel գրադարանը ՝ իմ LEDstrip- ը վերահսկելու համար:

Գրեք այս ծածկագիրը ձեր ֆայլի վերևում `համոզվելու համար, որ LEDstrip- ը սահմանված է.

#ներառում

#սահմանել PIXEL_PIN D5 #սահմանել PIXEL_COUNT 10 #սահմանել PIXEL_TYPE NEO_GRB + NEO_KHZ800 Adafruit_NeoPixel պիքսել = Adafruit_NeoPixel (PIXEL_COUNT, PIXEL_PIN, PIXEL_TYPE);

Տեղադրման գործառույթում գրեք հաջորդ կոդը.

// նեոպիքսել

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

Եվ հանգույցի գործառույթի հետևյալ ծածկագիրը.

եթե (trafficJam == ճշմարիտ) {

(int i; i <PIXEL_COUNT; i ++) համար {pixels.setPixelColor (i, 255, 0, 0); // կարմիր pixels.show (); ուշացում (200); }} else {for (int i; i <PIXEL_COUNT; i ++) {pixels.setPixelColor (i, 0, 255, 0); // կանաչ pixels.show (); ուշացում (200); }

Վերևի ծածկագրում կա if/else գործառույթը: Երբ extractData գործառույթը վերադարձնում է խցանումների առկայությունը, LEDstrip- ը կարմիր կդառնա: Եթե ոչ, LED շերտի գույնը կանաչ կդառնա:

Քայլ 6: Գործարկեք ծածկագիրը

Եթե այժմ գործարկենք ամբողջական ծածկագիրը, սենսորը և լույսը պետք է աշխատեն: Երբ կանգնած եք դռան գորգի վրա, սենսորը կկապվի, և կգործի extractData գործառույթը: Երբ ճանապարհների անվանումների շարքում առկա է այն ճանապարհը, որը մենք փնտրում ենք, LED շերտը կարմիր կդառնա ՝ ազդանշանելով խցանում: Եթե այն զանգվածի մեջ չէ, ապա LEDstrip- ը կանաչ կդառնա, և դուք գիտեք, որ պատրաստ եք գնալ:

Անվտանգ ճանապարհորդություն և շնորհակալություն կարդալու համար: Հուսով եմ, որ գտել եք ինչ -որ ոգեշնչում կամ տեղեկատվություն: Եթե դուք ստացել եք որոշակի արձագանք, ազատ զգացեք արձագանքել: