Arduino Timամանակի մեթոդներ Միլիսի հետ (): 4 քայլ

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

Այս հոդվածում մենք ներկայացնում ենք millis (); գործառույթը և օգտագործեք այն ժամանակացույցի տարբեր օրինակներ ստեղծելու համար:

Միլլիս? Ոչ մի կապ չկա շրթունքների համտեսների հետ… հուսով ենք, որ դուք միլիին ճանաչել եք որպես թվային նախածանց ՝ հազարերորդ մասի համար. որը բազմապատկում է չափման միավորը 0.001 -ով (կամ տասը ՝ բացասական 3 -ի հզորությամբ):

Հետաքրքիր է, որ մեր Arduino համակարգերը կհաշվեն միլիվայրկյանների թիվը (հազար վայրկյան) էսքիզների սկզբից մինչև հաշվարկը հասնի այն առավելագույն թվին, որը կարող է պահվել փոփոխական տիպի անստորագիր երկար (32 բիթ [չորս բայթ] ամբողջ թվով) -որը տատանվում է զրոյից մինչև (2^32) -1: (2^32) -1, կամ 4294967295 միլիվայրկյան փոխակերպվում է 49.71027-կենտ օրերի:

Հաշվիչը վերակայվում է, երբ Arduino- ն վերակայվում է, այն հասնում է առավելագույն արժեքի կամ նոր ուրվագիծ է վերբեռնվում: Հաշվիչի արժեքը որոշակի պահին ստանալու համար պարզապես զանգահարեք գործառույթը `օրինակ.

սկիզբ = millis ();

Որտեղ սկիզբը անստորագիր երկար փոփոխական է: Ահա մի շատ պարզ օրինակ, որը ցույց կտա ձեզ millis () գործողության մեջ.

/ * millis () ցուցադրում */

անստորագիր երկար սկիզբ, ավարտված, անցած;

դատարկ կարգավորում ()

{Serial.begin (9600); }

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

{Serial.println («Սկսել …»); սկիզբ = millis (); ուշացում (1000); ավարտված = millis (); Serial.println («Ավարտված է»); անցած = ավարտված մեկնարկ; Serial.print (լրացել է); Serial.println («միլիվայրկյան անցավ»); Serial.println (); ուշացում (500); }

Էսքիզը սկզբում պահպանում է միլիլների ընթացիկ հաշվարկը, այնուհետև սպասում է մեկ վայրկյան, այնուհետև կրկին պահում է միլիիսի արժեքը ավարտված վիճակում: Ի վերջո, այն հաշվարկում է ուշացման անցած ժամանակը: Սերիական մոնիտորի հետևյալ էկրանի աղբանոցում կարող եք տեսնել, որ տևողությունը միշտ չէ, որ եղել է ուղիղ 1000 միլիվայրկյան, ինչպես ցույց է տրված նկարում:

Քայլ 1:

Պարզ ասած, millis ֆունկցիան օգտագործում է ներքին հաշվիչ ՝ ձեր Arduino- ի սրտում գտնվող ATmega միկրոկոնտրոլերի ներսում: Այս հաշվիչն ավելացնում է ժամացույցի յուրաքանչյուր ցիկլ, ինչը տեղի է ունենում (ստանդարտ Arduino- ում և համատեղելի սարքերում) 16 ՄՀց հաճախականությամբ: Այս արագությունը կառավարվում է Arduino- ի տախտակի բյուրեղով (արծաթե իրը, որի վրա դրոշմված է T16.000):

Քայլ 2:

Բյուրեղների ճշգրտությունը կարող է տարբեր լինել `կախված արտաքին ջերմաստիճանից և բյուրեղի ինքնին հանդուրժողականությունից: Սա իր հերթին կազդի ձեր միլիարդ արդյունքի ճշգրտության վրա: Անեկդոտային փորձը հայտնում է, որ ժամանակի ճշգրտության շեղումը կարող է լինել մոտ երեք կամ չորս վայրկյան քսանչորս ժամվա ընթացքում:

Եթե դուք օգտագործում եք տախտակ կամ ձեր սեփական տարբերակը, որը բյուրեղի փոխարեն օգտագործում է կերամիկական ռեզոնատոր, նշեք, որ դրանք այնքան էլ ճշգրիտ չեն և կներկայացնեն դրեյֆերի ավելի բարձր մակարդակների հնարավորություն: Եթե Ձեզ անհրաժեշտ է ժամանակի ճշգրտության շատ ավելի բարձր մակարդակ, հաշվի առեք որոշակի ժամաչափի IC- ներ, ինչպիսիք են Maxim DS3231- ը:

Այժմ մենք կարող ենք օգտագործել millis- ը տարբեր ժամանակային գործառույթների համար: Ինչպես ցույց տվեց նախորդ օրինակի ուրվագիծը, մենք կարող ենք հաշվարկել անցած ժամանակը: Այս գաղափարն առաջ տանելու համար եկեք մի պարզ վայրկյանաչափ պատրաստենք: Դա անելը կարող է լինել այնքան պարզ կամ որքան անհրաժեշտ է, բայց այս դեպքում մենք կշեղվենք դեպի պարզը:

Սարքավորման տեսանկյունից մենք կունենանք երկու կոճակ ՝ Start և Stop, որոնց 10k ohm քաշվող դիմադրիչները միացված են համապատասխանաբար 2 և 3 թվային կապումներին: Երբ օգտվողը սեղմում է, ուրվագիծը նշում է միլիոնի արժեքը, այնուհետև կանգառը սեղմելուց հետո էսքիզը կրկին նշում է միլիիսի արժեքը, հաշվարկում և ցուցադրում է անցած ժամանակը: Այնուհետև օգտվողը կարող է սեղմել կոճակը ՝ գործընթացը կրկնելու համար, կամ դադարեցնել թարմացված տվյալների համար: Ահա էսքիզը.

/* Գերհիմնական վայրկյանաչափ ՝ օգտագործելով millis (); */

անստորագիր երկար սկիզբ, ավարտված, անցած;

դատարկ կարգավորում ()

{Serial.begin (9600); pinMode (2, Մուտք); // մեկնարկի կոճակ pinMode (3, Մուտք); // կանգառի կոճակ Serial.println («Սկսելու/վերակայելու համար սեղմեք 1, անցած ժամանակ 2»); }

void displayResult ()

{բոց h, m, s, ms; երկար ժամանակ չստորագրված; անցած = ավարտված մեկնարկ; h = int (անցած/3600000); ավելի = անցած%3600000; m = int (ավելի/60000); ավելի քան = 60000 -ից ավելի; s = int (ավելի/1000); ms = ավելի քան%1000; Serial.print ("Հում անցած ժամանակ."); Serial.println (անցած); Serial.print («Անցած ժամանակը.»); Serial.print (h, 0); Serial.print («h»); Serial.print (մ, 0); Serial.print («մ»); Serial.print (ներ, 0); Serial.print («ներ»); Serial.print (ms, 0); Serial.println ("ms"); Serial.println (); }

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

{if (digitalRead (2) == HIGH) {սկիզբ = millis (); ուշացում (200); // դեբունսի համար Serial.println («Սկսվեց …»); } if (digitalRead (3) == HIGH) {ավարտված = millis (); ուշացում (200); // debounce displayResult (); }}

Հետաձգման () զանգերը օգտագործվում են անջատիչների անջատման համար. Դրանք պարտադիր չեն, և դրանց օգտագործումը կախված կլինի ձեր սարքավորումներից: Պատկերը էսքիզի սերիական մոնիտորի ելքի օրինակ է. Վայրկյանաչափը սկսված է, այնուհետև կոճակը երկուսը վեց անգամ սեղմվել է ժամանակի ընթացքում:

Քայլ 3: Արագաչափ…

Եթե դուք ֆիքսված հեռավորության սկզբում և վերջում ունեիք սենսոր, արագությունը կարող էր հաշվարկվել. Արագություն = հեռավորություն ÷ ժամանակ:

Կարող եք նաև արագաչափ պատրաստել անիվներով շարժման համար, օրինակ ՝ հեծանիվ: Ներկա պահին մենք հեծանիվ չունենք, որի հետ կարելի է խառնվել, սակայն կարող ենք նկարագրել դա անելու գործընթացը. Դա բավականին պարզ է: (Հրաժարում. Դա արեք ձեր ռիսկով և այլն)

Նախ, եկեք վերանայենք անհրաժեշտ մաթեմատիկան: Դուք պետք է իմանաք անիվի շրջագիծը: Սարքավորումներ - ձեզ հարկավոր է տվիչ: Օրինակ `եղեգի անջատիչ և մագնիս: Համոզվեք, որ եղեգի անջատիչը սովորաբար բաց կոճակ է և, ինչպես միշտ, միացեք 10k ohm քաշվող դիմադրիչով:

Մյուսները կարող են օգտագործել դահլիճի էֆեկտի ցուցիչ `յուրաքանչյուրն իր սեփականը): Հիշեք մաթեմատիկայի դասից, շրջագիծը հաշվարկելու համար `օգտագործեք բանաձևը` շրջանակ = 2πr, որտեղ r- ը շրջանագծի շառավիղն է:

Այժմ, երբ դուք ունեք անիվի շրջագիծը, այս արժեքը կարելի է համարել մեր «ֆիքսված հեռավորությունը», և, հետևաբար, արագությունը կարելի է հաշվարկել ՝ լրիվ պտույտի միջև անցած ժամանակը չափելով:

Ձեր սենսորը `տեղադրվելուց հետո, պետք է գործի նույն մեթոդով, ինչ սովորաբար բաց կոճակը, որը սեղմվում է յուրաքանչյուր պտույտով: Մեր ուրվագիծը չափելու է սենսորից յուրաքանչյուր զարկերակի միջև ընկած ժամանակը:

Դա անելու համար մեր օրինակը կունենա սենսորի ելքը միացված թվային 2 -րդ կապին, քանի որ դա արագություն հաշվարկելու համար ընդմիջում կհանգեցնի: Այլ կերպ ուրվագիծը արագությունը կցուցադրի նորմալ I2C ինտերֆեյսով LCD մոդուլի վրա: I2C ինտերֆեյսը առաջարկվում է, քանի որ դրա համար անհրաժեշտ է ընդամենը 4 լար Arduino- ի տախտակից մինչև LCD- ը: որքան քիչ լարեր, այնքան լավ:

Ահա ձեր ուսումնասիրության ուրվագիծը.

/*Millis () օգտագործող հիմնական արագաչափ */

#ներառել «Wire.h» // I2C ավտոբուսի LCD- ի համար

#ներառել «LiquidCrystal_I2C.h» // I2C ավտոբուսի LCD մոդուլի համար - https://bit.ly/m7K5wt LiquidCrystal_I2C LCD (0x27, 16, 2); // LCD հասցեն սահմանել 0x27 ՝ 16 նշանի և 2 տողի ցուցադրման համար

բոց մեկնարկ, ավարտված;

բոց է անցել, ժամանակ; float circMetric = 1.2; // անիվի շրջագիծ `համեմատած սենսորի դիրքի հետ (մետր) float circImperial; // օգտագործելով 1 կիլոմետր = 0.621371192 մղոն float speedk, speedm; // պահում է հաշվարկված արագության տատանումները մետրային և կայսերականում

դատարկ կարգավորում ()

{attachInterrupt (0, speedCalc, RISING); // ընդհատում, որը կոչվում է, երբ տվիչները ուղարկում են թվային 2 բարձր (յուրաքանչյուր անիվի պտույտ) սկիզբ = միլլիս (); // LCD LCD- ի տեղադրում lcd.init (); // նախաստորագրել lcd lcd.backlight (); // միացնել LCD լուսարձակը lcd.clear (); lcd.println («Սաղավարտ հագեք»); ուշացում (3000); lcd. հստակ (); Serial.begin (115200); circImperial = circMetric*.62137; // մետրը փոխարկել կայսերականի MPH հաշվարկների համար}

void speedCalc ()

{elapsed = millis ()-սկիզբ; սկիզբ = millis (); speedk = (3600*circMetric)/անցած; // կմ/ժ արագություն = (3600*շրջանային) և անցած; // մղոն ժամում}

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

{lcd.setCursor (0, 0); lcd.print (int (speedk)); lcd.print («կմ/ժ»); lcd.print (int (արագություն)); lcd.print ("MPH"); lcd.setCursor (0, 1); lcd.print (int (անցած)); lcd.print ("ms/rev"); ուշացում (1000); // հարմարեցրեք անձնական նախապատվությանը `թարթումը նվազագույնի հասցնելու համար}

Այդքան էլ տեղի չի ունենում. Ամեն անգամ, երբ անիվը կատարում է մեկ պտույտ, սենսորից ազդանշանը ցածրից բարձրանում է `առաջացնելով ընդհատում, որը կոչում է ֆունկցիան speedCalc ():

Սա տևում է միլիիսի () ընթերցում, այնուհետև հաշվարկում է ընթացիկ ընթերցման և նախորդ ընթերցման միջև եղած տարբերությունը.

float circMetric = 1.2;

և չափվում է մետրերով): Այն վերջապես հաշվարկում է արագությունը կմ/ժ -ով և MPH- ով: Ընդհատումների միջև էսքիզը ցուցադրում է LCD- ի արագության թարմացված տվյալները, ինչպես նաև յուրաքանչյուր հեղափոխության ժամանակի արժեքը `հանուն հետաքրքրության: Իրական կյանքում ես չեմ կարծում, որ ինչ -որ մեկը LCD- ը հեծանիվի վրա կտեղադրեր, գուցե LED էկրանն ավելի տեղին կլիներ:

Մինչդեռ, դուք կարող եք տեսնել, թե ինչպես է աշխատում այս օրինակը հետևյալ կարճ տեսահոլովակում: Հեծանիվի անիվի և եղեգի անջատիչի/մագնիսի համադրության փոխարեն ես ֆունկցիայի գեներատորից քառակուսի ալիքի միացումն ընդհատող քորոցին եմ դարձրել սենսորից իմպուլսները նմանեցնելու համար, այնպես որ կարող եք պատկերացում կազմել, թե ինչպես է այն աշխատում:

Քայլ 4:

Դա ընդամենը ամփոփում է միլիսի () օգտագործումը առայժմ: Կա նաև միկրո (); ֆունկցիա, որը հաշվում է միկրովայրկյաններ:

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

Այս գրառումը ձեզ է բերել pmdway.com- ը `ամեն ինչ արտադրողների և էլեկտրոնիկայի սիրահարների համար` անվճար առաքում ամբողջ աշխարհով: