Arduino időzítési módszerek Millis -szel (): 4 lépés

2024 Szerző: John Day | [email protected]. Utoljára módosítva: 2024-01-30 09:41

Ebben a cikkben bemutatjuk a millis (); függvényt, és különféle időzítési példák létrehozásához használja.

Millis? Semmi köze az ajakfúvókhoz … remélhetőleg felismerte, hogy milli az ezredrész számszerű előtagja; azaz a mértékegységet megszorozzuk 0,001 -gyel (vagy tízzel a negatív 3 -ig).

Érdekes módon Arduino rendszereink ezredmásodpercek számát (ezer másodpercet) számítják a futó vázlat kezdetétől, amíg a szám el nem éri azt a maximális számot, amely tárolható a változó típusú, előjel nélküli hosszú (32 bites [négy bájtos] egész szám) -amely nulla és (2^32) -1 között van (2^32) -1, vagy 4294967295 ezredmásodperc 49.71027 páratlan napra változik.

A számláló alaphelyzetbe áll, amikor az Arduino visszaáll, eléri a maximális értéket, vagy új vázlatot tölt fel. Ha meg szeretné kapni a számláló értékét egy adott időpontban, hívja meg a függvényt - például:

start = millis ();

Ahol a start egy előjel nélküli hosszú változó. Íme egy nagyon egyszerű példa, amely megmutatja a millis () működését:

/ * millis () bemutató */

előjel nélküli hosszú kezdés, kész, eltelt;

üres beállítás ()

{Serial.begin (9600); }

üres hurok ()

{Serial.println ("Start…"); start = millis (); késleltetés (1000); kész = millis (); Serial.println ("Kész"); eltelt = kész-rajt; Serial.print (eltelt); Serial.println ("ezredmásodperc telt el"); Sorozat.println (); késleltetés (500); }

A vázlat kezdetben tárolja az aktuális milliszámot, majd várakozik egy másodpercet, majd ismét a milliszámot tárolja készben. Végül kiszámítja a késleltetés eltelt idejét. A soros monitor következő képernyőképén látható, hogy az időtartam nem mindig volt pontosan 1000 milliszekundum, amint az a képen is látható.

1. lépés:

Egyszerűen fogalmazva, a millis funkció az ATmega mikrokontroller belső számlálóját használja az Arduino szívében. Ez a számláló minden órajel ciklusonként növekszik - ez történik (szabványos Arduino és kompatibilis eszközök esetén) 16 Mhz órajel mellett. Ezt a sebességet az Arduino táblán lévő kristály szabályozza (az ezüst színű, T166.000 -es pecséttel).

2. lépés:

A kristály pontossága a külső hőmérséklettől és a kristály tűrőképességétől függően változhat. Ez viszont befolyásolja milliméteres eredményének pontosságát. Az anekdotikus tapasztalatok szerint az időzítési pontosság eltolódása körülbelül három vagy négy másodperc lehet huszonnégy órás időszakonként.

Ha táblát vagy saját verziót használ, amely kerámia rezonátort használ kristály helyett, akkor vegye figyelembe, hogy ezek nem olyan pontosak, és magasabb sodródási szinteket eredményeznek. Ha sokkal magasabb szintű időzítési pontosságra van szüksége, vegye figyelembe az időzítő IC -ket, például a Maxim DS3231 -et.

Most már használhatjuk a millit különböző időzítési funkciókhoz. Amint azt az előző példavázlat bemutatta, kiszámíthatjuk az eltelt időt. Ennek az ötletnek a továbbviteléhez készítsünk egy egyszerű stopperórát. Ennek végrehajtása a lehető legegyszerűbb vagy bonyolultabb lehet, de ebben az esetben az egyszerű felé fordulunk.

Hardveres szempontból két gombunk lesz-Start és Stop-a 10 k ohmos lehúzható ellenállásokkal, amelyek a 2-es és 3-as digitális tüskékhez vannak csatlakoztatva. Amikor a felhasználó megnyomja a start gombot, a vázlat megjegyzi a milliméteres értéket, majd a stop megnyomása után a vázlat ismét feljegyzi a millis értéket, kiszámítja és megjeleníti az eltelt időt. A felhasználó ezután megnyomhatja a start gombot a folyamat megismétléséhez, vagy a stop gombot a frissített adatokért. Itt a vázlat:

/* Szuper-alapú stopperóra millis () használatával; */

előjel nélküli hosszú kezdés, kész, eltelt;

üres beállítás ()

{Serial.begin (9600); pinMode (2, BEMENET); // indító gomb pinMode (3, INPUT); // stop gomb Serial.println ("Nyomja meg az 1 gombot a Start/reset, a 2 gombot az eltelt időhöz"); }

void displayResult ()

{úszó h, m, s, ms; aláíratlan régóta; eltelt = kész-rajt; h = int (eltelt/3600000); over = eltelt%3600000; m = int (több mint/60000); több mint = több mint 6000000; s = int (több mint/1000); ms =%1000 felett; Serial.print ("Nyers eltelt idő:"); Serial.println (eltelt); Serial.print ("Eltelt idő:"); Sorozatnyomat (h, 0); Serial.print ("h"); Sorozatnyomat (m, 0); Soros.nyomtatás ("m"); Sorozatnyomat (s, 0); Serial.print ("s"); Soros.nyomtatás (ms, 0); Serial.println ("ms"); Sorozat.println (); }

üres hurok ()

{if (digitalRead (2) == HIGH) {start = millis (); késleltetés (200); // debounce Serial.println ("Elindult…"); } if (digitalRead (3) == HIGH) {kész = millis (); késleltetés (200); // debounce displayResult (); }}

A késleltetés () hívások a kapcsolók kikapcsolására szolgálnak - ezek nem kötelezőek, és használatuk a hardvertől függ. A kép egy példa a vázlat soros monitor kimenetére - a stopper elindult, majd a második gombot hatszor megnyomták bizonyos időtartamok alatt.

3. lépés: Sebességmérő…

Ha volt egy érzékelője a rögzített távolság elején és végén, a sebesség kiszámítható: sebesség = távolság ÷ idő.

Készíthet sebességmérőt kerekes mozgásformákhoz is, például kerékpárhoz. Jelenleg nincs kerékpárunk, amellyel bajlódnánk, de leírhatjuk a folyamatot - ez nagyon egyszerű. (Jogi nyilatkozat - saját felelősségre, stb.)

Először is nézzük át a szükséges matematikát. Tudnia kell a kerék kerületét. Hardver - szükség lesz egy érzékelőre. Például - nádkapcsoló és mágnes. Tekintsük a nádkapcsolót normálisan nyitott gombnak, és csatlakoztassuk a szokásos módon egy 10 k ohmos lehúzható ellenállással.

Mások használhatnak hall-effektus-érzékelőt-mindegyik saját). Ne feledje, hogy a matematika órából a kerület kiszámításához használja a képletet: kerület = 2πr ahol r a kör sugara.

Most, hogy megvan a kerék kerülete, ez az érték a „rögzített távolságunknak” tekinthető, és ezért a sebesség kiszámítható a teljes körforgás között eltelt idő mérésével.

Az érzékelőnek-ha már fel van szerelve-ugyanúgy kell eljárnia, mint egy normálisan nyitott gombnak, amelyet minden fordulaton megnyomnak. Vázlatunk mérni fogja az érzékelő minden impulzusa között eltelt időt.

Ehhez példánkban az érzékelő kimenetét a 2 -es digitális tüskéhez csatlakoztatjuk - mivel megszakítást vált ki a sebesség kiszámításához. A vázlat egyébként a normál I2C interfész LCD modulon mutatja a sebességet. Az I2C interfész javasolt, mivel ehhez mindössze 4 vezeték szükséges az Arduino kártyától az LCD -hez - minél kevesebb vezeték, annál jobb.

Íme a vázlat az olvasáshoz:

/*Alapsebességmérő millis (); */

#include "Wire.h" // I2C busz LCD -hez

#include "LiquidCrystal_I2C.h" // I2C busz LCD modulhoz - https://bit.ly/m7K5wt LiquidCrystal_I2C lcd (0x27, 16, 2); // állítsa az LCD címet 0x27 értékre 16 karakter és 2 soros kijelző esetén

úszó kezdés, kész;

úszó eltelt, idő; float circMetric = 1,2; // kerék kerülete az érzékelő helyzetéhez viszonyítva (méterben) float circImperial; // 1 kilométer használatával = 0.621371192 mérföld úszó speedk, speedm; // számított sebességértékeket tart metrikus és imperial értékben

üres beállítás ()

{attachInterrupt (0, speedCalc, RISING); // megszakítás hívva, amikor az érzékelők digitális 2 magas (minden kerékfordulat) küld start = millis (); // LCD beállítása lcd.init (); // inicializálja az LCD -t lcd.backlight (); // az LCD háttérvilágítás bekapcsolása lcd.clear (); lcd.println ("Viseljen sisakot!"); késleltetés (3000); lcd.clear (); Sorozat.kezdet (115200); circImperial = circMetric*.62137; // metrika konvertálása imperialra MPH számításokhoz}

void speedCalc ()

{eltelt = millis ()-kezdés; start = millis (); speedk = (3600*circMetric)/eltelt; // km/h speedm = (3600*circImperial)/eltelt; // Mérföld per óra }

üres hurok ()

{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 (eltelt)); lcd.print ("ms/rev"); késleltetés (1000); // állítsa be személyes preferenciáit a villódzás minimalizálása érdekében}

Nem sok minden történik - minden alkalommal, amikor a kerék egy fordulatot teljesít, az érzékelő jele alacsonyról magasra emelkedik - megszakítást vált ki, amely meghívja a speedCalc () funkciót.

Ez milliméteres () értéket vesz fel, majd kiszámítja az aktuális és az előző leolvasás közötti különbséget - ez az érték lesz az idő, ameddig meg kell tenni a távolságot (ami a kerék kerülete az érzékelőhöz viszonyítva)

float circMetric = 1,2;

és méterben mérik). Végül kiszámítja a sebességet km/h -ban és MPH -ban. A megszakítások között a vázlat a frissített sebességadatokat jeleníti meg az LCD -n, valamint az egyes fordulatok nyers időértékét a kíváncsiság kedvéért. A való életben nem hiszem, hogy bárki szerelne LCD -t kerékpárra, talán a LED -es kijelző lenne relevánsabb.

Közben a következő rövid videoklipben megtekintheti, hogyan működik ez a példa. A kerékpárkerék és a nádkapcsoló/mágnes kombináció helyett a funkciógenerátor négyzethullámú kimenetét a megszakító csaphoz kötöttem, hogy szimuláljam az érzékelő impulzusait, így képet kaphat a működéséről.

4. lépés:

Ez nagyjából összefoglalja a millis () használatát egyelőre. Ott van a micros () is; funkció, amely mikroszekundumokat számít.

Itt van ez - egy másik praktikus funkció, amely lehetővé teszi több probléma megoldását az Arduino világán keresztül. Mint mindig, most is rajtad és a fantáziádon múlik, hogy találsz -e valamit, amit irányíthatsz, vagy felkelhetsz más cselszövésekre.

Ezt a bejegyzést a pmdway.com hozta neked - mindent a gyártóknak és az elektronika rajongóinak, ingyenes szállítással világszerte.