Mga Paraan ng Oras ng Arduino Sa Millis (): 4 na Hakbang

2024 May -akda: John Day | [email protected]. Huling binago: 2024-01-30 13:13

Sa artikulong ito ipinakilala namin ang millis (); pagpapaandar at ilagay ito upang magamit upang lumikha ng iba't ibang mga halimbawa ng tiyempo.

Millis? Walang kinalaman sa mga lip-syncer … sana nakilala mo ang milli bilang ang bilang na pangunahin para sa isang-libu-libo; na nagpaparami ng isang yunit ng sukat ng 0.001 (o sampu sa lakas ng negatibong 3).

Kapansin-pansin ang aming mga system ng Arduino na bibilangin ang bilang ng mga milliseconds (libu-libong isang segundo) mula sa pagsisimula ng isang sketch na tumatakbo hanggang sa maabot ng bilang ang maximum na bilang na may kakayahang maimbak sa variable type na hindi pirmado nang matagal (isang 32-bit [apat na byte] na integer - mula sa zero hanggang (2 ^ 32) -1. (2 ^ 32) -1, o 4294967295 milliseconds na nagko-convert sa 49.71027-kakaibang araw.

Nagre-reset ang counter kapag na-reset ang Arduino, naabot nito ang maximum na halaga o na-upload ang isang bagong sketch. Upang makuha ang halaga ng counter sa isang partikular na junkure, tawagan lamang ang pagpapaandar - halimbawa:

simulan = millis ();

Kung saan ang pagsisimula ay isang unsigned long variable. Narito ang isang napaka-simpleng halimbawa upang maipakita sa iyo ang millis () sa aksyon:

/ * millis () demonstration * /

unsigned matagal na pagsisimula, tapos, lumipas;

walang bisa ang pag-setup ()

{Serial.begin (9600); }

walang bisa loop ()

{Serial.println ("Start…"); simulan = millis (); pagkaantala (1000); tapos = millis (); Serial.println ("Tapos na"); lumipas = tapos-simula; Serial.print (lumipas); Serial.println ("milliseconds lumipas"); Serial.println (); pagkaantala (500); }

Iniimbak ng sketch ang kasalukuyang bilang ng millis sa simula, pagkatapos ay naghihintay ng isang segundo, pagkatapos ay iniimbak muli ang halaga ng millis sa tapos na. Sa wakas kinakalkula nito ang lumipas na oras ng pagkaantala. Sa sumusunod na screen dump ng serial monitor, makikita mo na ang tagal ay hindi palaging eksaktong 1000 milliseconds, tulad ng ipinakita sa imahe.

Hakbang 1:

Upang ilagay ito nang simple, ang pagpapaandar ng millis ay gumagamit ng isang panloob na counter sa loob ng ATmega microcontroller sa gitna ng iyong Arduino. Ang counter na ito ay nagdaragdag ng bawat cycle ng orasan - na nangyayari (sa karaniwang Arduino at mga kompatible) sa bilis ng orasan na 16 Mhz. Ang bilis na ito ay kinokontrol ng kristal sa Arduino board (ang pilak na bagay na may T16.000 na nakatatak dito).

Hakbang 2:

Ang katumpakan ng kristal ay maaaring mag-iba depende sa panlabas na temperatura, at ang pagpapaubaya ng mismong kristal. Ito naman ang makakaapekto sa kawastuhan ng iyong resulta sa millis. Ang karanasan sa anecdotal ay iniulat na ang naaanod sa kawastuhan ng tiyempo ay maaaring humigit-kumulang tatlo o apat na segundo bawat dalawampu't apat na oras na oras.

Kung gumagamit ka ng isang board o iyong sariling bersyon na gumagamit ng isang ceramic resonator sa halip na isang kristal, tandaan na hindi sila tumpak at ipapakilala ang posibilidad ng mas mataas na mga antas ng naaanod. Kung kailangan mo ng mas mataas na antas ng kawastuhan ng tiyempo, isaalang-alang ang mga tukoy na timer IC tulad ng Maxim DS3231.

Maaari na nating magamit ang millis para sa iba't ibang mga pag-andar ng tiyempo. Tulad ng ipinakita sa nakaraang halimbawa ng sketch, maaari nating kalkulahin ang lumipas na oras. Upang maisulong ang ideyang ito, gumawa tayo ng isang simpleng stopwatch. Ang paggawa nito ay maaaring maging kasing simple o kumplikado kung kinakailangan, ngunit para sa kasong ito ay susubukan kami patungo sa simple.

Sa pananaw ng hardware, magkakaroon kami ng dalawang mga pindutan - Magsimula at Itigil - gamit ang 10k ohm pull-down resistors na konektado sa mga digital na pin 2 at 3 ayon sa pagkakabanggit. Kapag pinindot ng gumagamit ang simulan ang sketch ay mapapansin ang halaga para sa millis - pagkatapos pagkatapos ay pinindot ang paghinto, muling tandaan ng sketch ang halaga para sa millis, kalkulahin at ipakita ang lumipas na oras. Pagkatapos ay maaaring pindutin ng gumagamit ang simula upang ulitin ang proseso, o huminto para sa na-update na data. Narito ang sketch:

/ * Super-basic na stopwatch gamit ang millis (); * /

unsigned matagal na pagsisimula, tapos, lumipas;

walang bisa ang pag-setup ()

{Serial.begin (9600); pinMode (2, INPUT); // start button pinMode (3, INPUT); // stop button Serial.println ("Pindutin ang 1 para sa Start / reset, 2 para sa lumipas na oras"); }

walang bisa ang displayResult ()

{float h, m, s, ms; matagal nang hindi pinirmahan; lumipas = tapos-simula; h = int (lumipas / 3600000); higit sa = lumipas na% 3600000; m = int (higit sa / 60000); higit sa = higit sa% 60000; s = int (higit sa / 1000); ms = higit sa% 1000; Serial.print ("Raw lumipas na oras:"); Serial.println (lumipas); Serial.print ("Lumipas na oras:"); Serial.print (h, 0); Serial.print ("h"); Serial.print (m, 0); Serial.print ("m"); Serial.print (s, 0); Serial.print ("s"); Serial.print (ms, 0); Serial.println ("ms"); Serial.println (); }

walang bisa loop ()

{if (digitalRead (2) == TAAS) {start = millis (); pagkaantala (200); // for debounce Serial.println ("Started…"); } kung (digitalRead (3) == TAAS) {tapos = millis (); pagkaantala (200); // para sa debounce displayResult (); }}

Ang mga tawag upang maantala () ay ginagamit upang i-debug ang mga switch - opsyonal ito at ang kanilang paggamit ay nakasalalay sa iyong hardware. Ang imahe ay isang halimbawa ng output ng serial monitor ng sketch - ang stopwatch ay nagsimula na, at pagkatapos ang pindutan ng dalawa ay pinindot nang anim na beses sa buong tagal ng panahon.

Hakbang 3: Speedometer…

Kung mayroon kang isang sensor sa simula at pagtatapos ng isang nakapirming distansya, maaaring kalkulahin ang bilis: bilis = distansya ÷ oras.

Maaari ka ring gumawa ng isang speedometer para sa isang gulong na anyo ng paggalaw, halimbawa ng bisikleta. Sa kasalukuyang oras wala kaming bisikleta na makikipag-usap, subalit maaari naming ilarawan ang proseso upang gawin ito - ito ay medyo simple. (Pagwawaksi - gawin ito sa iyong sariling panganib atbp.)

Una sa lahat, suriin natin ang kinakailangang matematika. Kakailanganin mong malaman ang paligid ng gulong. Hardware - kakailanganin mo ng isang sensor. Halimbawa - isang switch ng tambo at magnet. Isaalang-alang ang switch ng tambo upang maging isang normal na bukas na pindutan, at kumonekta tulad ng dati sa isang 10k ohm pull-down risistor.

Ang iba ay maaaring gumamit ng sensor ng hall-effect - bawat isa sa kanilang sarili). Tandaan mula sa klase sa matematika, upang makalkula ang bilog - gamitin ang pormula: sirkulasyon = 2πr kung saan ang r ay ang radius ng bilog.

Ngayon na mayroon kang bilog na gulong, ang halagang ito ay maaaring isaalang-alang bilang aming 'nakapirming distansya', at samakatuwid ang bilis ay maaaring kalkulahin sa pamamagitan ng pagsukat ng lumipas na oras sa pagitan ng isang buong pag-ikot.

Ang iyong sensor - sa sandaling marapat - ay dapat kumilos sa parehong pamamaraan bilang isang normal na bukas na pindutan na itinulak sa bawat pag-ikot. Susukat ng aming sketch ang oras na lumipas sa pagitan ng bawat pulso mula sa sensor.

Upang gawin ito, ang aming halimbawa ay magkakaroon ng output ng sensor na konektado sa digital pin 2 - dahil magpapalitaw ito ng isang nakakagambala upang makalkula ang bilis. Ang sketch ay kung hindi man ay ipinapakita ang bilis sa isang normal na module ng LCD na I2C-interface. Iminungkahi ang interface ng I2C dahil nangangailangan lamang ito ng 4 na mga wire mula sa Arduino board hanggang sa LCD - mas mababa ang mga wire.

Narito ang sketch para sa iyong pagtingin:

/ * Pangunahing speedometer gamit ang millis (); * /

# isama ang "Wire.h" // para sa LCD LCD ng I2C

# isama ang "LiquidCrystal_I2C.h" // para sa I2C bus LCD module - https://bit.ly/m7K5wt LiquidCrystal_I2C lcd (0x27, 16, 2); // itakda ang LCD address sa 0x27 para sa isang 16 chars at 2 line display

pagsisimula ng float, tapos;

lumipas ang float, oras; float circMetric = 1.2; // ligid ng gulong na may kaugnayan sa posisyon ng sensor (sa metro) float circImperial; // using 1 kilometer = 0.621371192 miles float speedk, speedm; // humahawak ng kinakalkula na mga bilis ng takbo sa sukatan at imperyal

walang bisa ang pag-setup ()

{attachInterrupt (0, speedCalc, RISING); // makagambala tinawag kapag ang mga sensor ay nagpapadala ng digital 2 mataas (bawat pag-ikot ng gulong) simulan = millis (); // setup LCD lcd.init (); // ipasimula ang lcd lcd.backlight (); // i-on ang LCD backlight lcd. malinaw (); lcd.println ("Magsuot ng helmet!"); pagkaantala (3000); lcd.clear (); Serial.begin (115200); circImperial = circMetric *.62137; // convert metric to imperial for MPH calculations}

walang bisa speedCalc ()

{elapsed = millis () - start; simulan = millis (); speedk = (3600 * circMetric) / lumipas; // km / h speedm = (3600 * circImperial) / lumipas; // Milya kada oras }

walang bisa loop ()

{lcd.setCursor (0, 0); lcd.print (int (speedk)); lcd.print ("km / h"); lcd.print (int (speedm)); lcd.print ("MPH"); lcd.setCursor (0, 1); lcd.print (int (lumipas)); lcd.print ("ms / rev"); pagkaantala (1000); // ayusin para sa personal na kagustuhan na i-minimize ang flicker}

Walang gaanong nangyayari - sa tuwing nakakumpleto ang gulong ng isang rebolusyon ang signal mula sa sensor ay magmumula sa mababa hanggang sa mataas - na nagpapalitaw ng isang nakakagambala na tumatawag sa pagpapaandar na speedCalc ().

Ito ay tumatagal ng isang pagbabasa ng millis () at pagkatapos ay kinakalkula ang pagkakaiba sa pagitan ng kasalukuyang pagbabasa at ng nakaraang pagbabasa - ang halagang ito ay nagiging oras upang masakop ang distansya (na kung saan ay ang bilog ng gulong na may kaugnayan sa sensor - nakaimbak sa

float circMetric = 1.2;

at sinusukat sa metro). Sa wakas kinakalkula nito ang bilis sa km / h at MPH. Sa pagitan ng mga nakakagambala ay ipinapakita ng sketch ang na-update na data ng bilis sa LCD pati na rin ang hilagang halaga ng oras para sa bawat rebolusyon alang-alang sa pag-usisa. Sa totoong buhay sa palagay ko hindi sinuman ang mag-mount ng isang LCD sa isang bisikleta, marahil ang isang LED display ay magiging mas nauugnay.

Pansamantala, makikita mo kung paano gumagana ang halimbawang ito sa sumusunod na maikling video clip. Sa halip na isang gulong ng bisikleta at kombinasyon ng switch / tambo na kombinasyon, nakakonekta ko ang square-wave output mula sa isang generator ng function sa makagambala na pin upang gayahin ang mga pulso mula sa sensor, upang makakuha ka ng isang ideya kung paano ito gumagana.

Hakbang 4:

Iyon lamang tungkol sa kabuuan ang paggamit ng millis () sa ngayon. Mayroon ding micros (); pagpapaandar na binibilang ang mga microsecond.

Kaya't mayroon ka nito - isa pang praktikal na pagpapaandar na maaaring payagan ang maraming mga problema na malutas sa pamamagitan ng mundo ng Arduino. Tulad ng dati, nasa sa iyo at sa iyong imahinasyon lamang ang makahanap ng isang bagay na makokontrol o makarating sa ibang mga shenanigan.

Ang post na ito ay dinala sa iyo ng pmdway.com - lahat para sa mga tagagawa ng tagahanga at electronics, na may libreng paghahatid sa buong mundo.