არდუინოს დროის მეთოდი მილიზთან ერთად (): 4 ნაბიჯი

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

ამ სტატიაში ჩვენ წარმოგიდგენთ millis (); ფუნქცია და გამოიყენეთ იგი სხვადასხვა დროის მაგალითების შესაქმნელად.

მილისი? არაფერ შუაშია ტუჩის შემმსუბუქებლებთან … იმედია თქვენ აღიარეთ მილი როგორც რიცხვითი პრეფიქსი მეათასედისათვის; რომელიც ზომავს ერთეულის ზომას 0.001 -ზე (ან ათი უარყოფით 3 -ზე).

საინტერესოა, რომ ჩვენი არდუინოს სისტემები ითვლიან მილიწამების რაოდენობას (ათასი წამი) ესკიზის დაწყებიდან მანამ, სანამ რაოდენობა არ მიაღწევს მაქსიმალურ რაოდენობას, რომელსაც შეუძლია შეინახოს ცვლადი ტიპის ხელმოუწერელი გრძელი (32 ბიტიანი [ოთხი ბაიტი] მთელი რიცხვი -რომელიც ნულიდან მერყეობს (2^32) -1. (2^32) -1, ანუ 4294967295 მილიწამი გარდაიქმნება 49.71027-კენტი დღეებად.

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

დაწყება = მილი ();

საიდან იწყება არის ხელმოუწერელი გრძელი ცვლადი. აქ არის ძალიან მარტივი მაგალითი, რომ გაჩვენოთ millis () მოქმედებაში:

/ * millis () დემონსტრაცია */

ხელმოუწერელი გრძელი დასაწყისი, დასრულებული, გასული;

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

{Serial.begin (9600); }

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

{Serial.println ("დაწყება …"); დაწყება = მილი (); დაგვიანება (1000); დასრულდა = მილი (); Serial.println ("დასრულებულია"); გასული = დასრულებული-დაწყებული; სერიული. ბეჭდვა (გასული); Serial.println ("გავიდა მილიწამი"); Serial.println (); დაგვიანება (500); }

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

Ნაბიჯი 1:

მარტივად რომ ვთქვათ, millis ფუნქცია იყენებს შიდა მრიცხველს ATmega მიკროკონტროლერში, თქვენი Arduino- ს გულში. ეს მრიცხველი ზრდის საათის ყოველ ციკლს - რაც ხდება (სტანდარტულ Arduino– ში და თავსებადებში) 16 Mhz საათის სიჩქარით. ამ სიჩქარეს აკონტროლებს ბროლი არდუინოს დაფაზე (ვერცხლის ნივთი, რომელზეც T16.000 არის დატანილი).

ნაბიჯი 2:

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

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

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

აპარატურის თვალსაზრისით, ჩვენ გვექნება ორი ღილაკი-დაწყება და გაჩერება-10k ohm ჩამოსაშლელი რეზისტენტებით, რომლებიც დაკავშირებულია ციფრულ ქინძისთავებთან 2 და 3 შესაბამისად. როდესაც მომხმარებელი დააჭერს დაწყებას ესკიზი აღნიშნავს მნიშვნელობას მილიში - შემდეგ გაჩერების დაჭერის შემდეგ ესკიზი კვლავ აღნიშნავს მილიონის ღირებულებას, გამოთვლის და აჩვენებს გასულ დროს. მომხმარებელს შეუძლია დააჭიროს დაწყებას, რომ გაიმეოროს პროცესი, ან შეაჩეროს განახლებული მონაცემები. აქ არის ესკიზი:

/* სუპერ ძირითადი წამზომი მილიის () გამოყენებით; */

ხელმოუწერელი გრძელი დასაწყისი, დასრულებული, გასული;

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

{Serial.begin (9600); pinMode (2, INPUT); // დაწყების ღილაკი pinMode (3, INPUT); // გაჩერების ღილაკი Serial.println ("დააჭირეთ 1 დაწყების/გადატვირთვისთვის, 2 გასული დროის განმავლობაში"); }

void displayResult ()

{float h, m, s, ms; ხელმოუწერელი დიდი ხანია; გასული = დასრულებული-დაწყებული; h = int (გასული/3600000); მეტი = გასული%3600000; m = int (მეტი/60000); მეტი = 60000%-ზე მეტი; s = int (მეტი/1000); ms = 1000 -ზე მეტი; Serial.print ("ნედლი გასული დრო:"); Serial.println (გასული); Serial.print ("გასული დრო:"); სერიული. ბეჭდვა (თ, 0); Serial.print ("თ"); სერიული. ბეჭდვა (მ, 0); Serial.print ("მ"); Serial.print (s, 0); Serial.print ("s"); Serial.print (ms, 0); Serial.println ("ms"); Serial.println (); }

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

{if (digitalRead (2) == HIGH) {დაწყება = მილი (); დაგვიანება (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 start, დასრულდა;

float გავიდა, დრო; float circMetric = 1.2; // ბორბლის გარშემოწერილობა სენსორის პოზიციასთან შედარებით (მეტრებში) float circImperial; // 1 კილომეტრის გამოყენებით = 0.621371192 მილის მცურავი სიჩქარე, სიჩქარე; // ფლობს გამოთვლილ სიჩქარეებს მეტრულ და იმპერიულ ენებზე

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

{attachInterrupt (0, speedCalc, RISING); // შეფერხება დარეკილია, როდესაც სენსორები აგზავნიან ციფრულ 2 სიმაღლეს (ყველა ბორბლის ბრუნვა) დაწყება = მილი (); // LCD lcd.init () დაყენება (); // lcd lcd.backlight- ის ინიციალიზაცია (); // ჩართეთ LCD განათება lcd.clear (); lcd.println ("ჩაიცვი მუზარადი!"); დაგვიანება (3000); lcd. წმინდა (); Serial.begin (115200); circImperial = circMetric*.62137; // გადააკეთეთ მეტრიკა იმპერიულად MPH გამოთვლებისთვის}

void speedCalc ()

{elapsed = millis ()-დაწყება; დაწყება = მილი (); speedk = (3600*circMetric)/გასული; // კმ/სთ speedm = (3600*circImperial)/გასული; // Მილი საათში }

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

{lcd.setCursor (0, 0); lcd.print (int (speedk)); lcd.print ("კმ/სთ"); lcd.print (int (speedm)); 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– ით - ყველაფერი მწარმოებლებისთვის და ელექტრონიკის მოყვარულთათვის, უფასო მიწოდებით მთელს მსოფლიოში.