Mètodes de sincronització Arduino amb Millis (): 4 passos

2024 Autora: John Day | [email protected]. Última modificació: 2024-01-30 08:13

En aquest article introduïm el millis (); i utilitzeu-lo per crear diversos exemples de temps.

Millis? Res a veure amb els sincronitzadors de llavis … espero que reconeguis el mili com el prefix numèric per a la mil·lèsima part; que és multiplicar una unitat de mesura per 0,001 (o deu per la potència del negatiu 3).

Curiosament, els nostres sistemes Arduino comptaran el nombre de mil·lisegons (milers de segons) des de l’inici d’un esbós que s’executa fins que el recompte arriba al nombre màxim que pot emmagatzemar-se en el tipus variable sense signar llarg (un enter de 32 bits [quatre bytes]) - que oscil·la entre zero i (2 ^ 32) -1. (2 ^ 32) -1 o 4294967295 mil·lisegons es converteix en 49,71027 dies imparells.

El comptador es reinicia quan es reinicia l'Arduino, arriba al valor màxim o es penja un nou esbós. Per obtenir el valor del comptador en una conjuntura concreta, només cal que truqueu a la funció, per exemple:

inici = millis ();

On start és una variable llarga sense signar. Aquí teniu un exemple molt senzill per mostrar-vos millis () en acció:

/ * demostració millis () * /

inici llarg sense signar, acabat, transcorregut;

configuració nul·la ()

{Serial.begin (9600); }

bucle buit ()

{Serial.println ("Inici …"); inici = millis (); retard (1000); acabat = millis (); Serial.println ("Finalitzat"); transcorregut = finalitzat-inici; Serial.print (transcorregut); Serial.println ("mil·lisegons transcorreguts"); Serial.println (); retard (500); }

L’esbós emmagatzema el recompte actual de mil·lis a l’inici, després espera un segon i, a continuació, emmagatzema el valor de millis en acabat. Finalment calcula el temps transcorregut del retard. Al següent bolcat de pantalla del monitor sèrie, podeu veure que la durada no sempre era exactament de 1.000 mil·lisegons, tal com es mostra a la imatge.

Pas 1:

Per simplificar-ho, la funció millis fa servir un comptador intern dins del microcontrolador ATmega al cor del vostre Arduino. Aquest comptador augmenta cada cicle de rellotge, cosa que passa (en Arduino estàndard i compatibles) a una velocitat de rellotge de 16 Mhz. Aquesta velocitat està controlada pel cristall de la placa Arduino (la plata amb el T16.000 estampat).

Pas 2:

La precisió del cristall pot variar en funció de la temperatura externa i de la tolerància del mateix cristall. Al seu torn, això afectarà la precisió del resultat en mil·lis. L’experiència anecdòtica ha informat que la deriva en la precisió del temps pot rondar els tres o quatre segons per període de vint-i-quatre hores.

Si utilitzeu un tauler o la vostra pròpia versió que utilitza un ressonador ceràmic en lloc d’un cristall, tingueu en compte que no són tan precisos i introduiran la possibilitat de nivells de deriva més alts. Si necessiteu un nivell de precisió de temps molt més elevat, tingueu en compte ICs de temporitzador específics, com ara el Maxim DS3231.

Ara podem fer ús dels millis per a diverses funcions de sincronització. Com es demostra a l'esbós anterior de l'exemple, podem calcular el temps transcorregut. Per tirar endavant aquesta idea, fem un cronòmetre senzill. Fer-ho pot ser tan senzill o tan complex com sigui necessari, però en aquest cas anirem cap al simple.

Des de la perspectiva del maquinari, tindrem dos botons: Start i Stop, amb les resistències desplegables de 10 k ohm connectades als pins digitals 2 i 3 respectivament. Quan l'usuari prem el botó d'inici, l'esbós anotarà el valor de mil·lis; després de prémer la parada, l'esbós tornarà a notar el valor de mil·lis, calcularà i mostrarà el temps transcorregut. A continuació, l'usuari pot prémer Inici per repetir el procés o aturar-se per obtenir dades actualitzades. Aquí teniu l’esbós:

/ * Cronòmetre súper bàsic amb millis (); * /

inici llarg sense signar, acabat, transcorregut;

configuració nul·la ()

{Serial.begin (9600); pinMode (2, INPUT); // botó d'inici pinMode (3, INPUT); // botó d'aturada Serial.println ("Premeu 1 per iniciar / restablir, 2 per passar el temps"); }

void displayResult ()

{flotació h, m, s, ms; sense signar durant molt de temps; transcorregut = finalitzat-inici; h = int (transcorregut / 3600000); over = transcorregut% 3600000; m = int (més / 60000); over = over% 60000; s = int (més / 1000); ms = més de% 1000; Serial.print ("Temps transcorregut sense processar:"); Serial.println (transcorregut); Serial.print ("Temps transcorregut:"); 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 (); }

bucle buit ()

{if (digitalRead (2) == HIGH) {start = millis (); retard (200); // per debounce Serial.println ("Iniciat …"); } if (digitalRead (3) == HIGH) {acabat = millis (); retard (200); // per debounce displayResult (); }}

Les trucades a delay () s’utilitzen per rebutjar els commutadors: són opcionals i el seu ús dependrà del vostre maquinari. La imatge és un exemple de la sortida del monitor en sèrie de l’esbós: el cronòmetre ha començat i, a continuació, es prem el botó dos sis vegades durant períodes de temps.

Pas 3: velocímetre …

Si teníeu un sensor a l'inici i al final d'una distància fixa, es podria calcular la velocitat: velocitat = distància ÷ temps.

També podeu fer un velocímetre per a una forma de moviment amb rodes, per exemple una bicicleta. En aquest moment no tenim una bicicleta amb la qual desordenar-nos, però podem descriure el procés per fer-ho: és molt senzill. (Exempció de responsabilitat: feu-ho sota el vostre propi risc, etc.)

En primer lloc, repassem les matemàtiques necessàries. Haureu de conèixer la circumferència de la roda. Maquinari: necessitareu un sensor. Per exemple: un interruptor de canya i un imant. Considereu que l’interruptor reed és un botó obert normalment i connecteu-vos com és habitual amb una resistència desplegable de 10 k ohms.

Altres poden utilitzar un sensor d’efecte hall (cadascun al seu compte). Recordeu de la classe de matemàtiques, per calcular la circumferència: utilitzeu la fórmula: circumferència = 2πr on r és el radi del cercle.

Ara que teniu la circumferència de la roda, aquest valor es pot considerar com la nostra "distància fixa" i, per tant, la velocitat es pot calcular mesurant el temps transcorregut entre una rotació completa.

El sensor, un cop instal·lat, hauria d’actuar en el mateix mètode que un botó obert normalment que s’empeny cada rotació. El nostre esbós mesurarà el temps transcorregut entre cada impuls del sensor.

Per fer-ho, el nostre exemple tindrà la sortida del sensor connectada al pin digital 2, ja que provocarà una interrupció per calcular la velocitat. Altrament, l’esbós mostrarà la velocitat en un mòdul LCD d’interfície I2C normal. Es suggereix la interfície I2C, ja que només requereixen 4 cables de la placa Arduino a la pantalla LCD: com menys cables millor.

Aquí teniu l’esbós de la vostra lectura:

/ * Velocímetre bàsic amb millis (); * /

#include "Wire.h" // per a la pantalla LCD del bus I2C

#include "LiquidCrystal_I2C.h" // per al mòdul LCD del bus I2C - https://bit.ly/m7K5wt LiquidCrystal_I2C lcd (0x27, 16, 2); // configureu l'adreça LCD a 0x27 per a una pantalla de 16 caràcters i 2 línies

arrencada flotant, acabat;

flotador transcorregut, temps; float circMetric = 1,2; // circumferència de la roda en relació amb la posició del sensor (en metres) float circImperial; // utilitzant 1 quilòmetre = 0,621371192 milles float speedk, speedm; // manté les vàlvules de velocitat calculades en mètriques i imperials

configuració nul·la ()

{attachInterrupt (0, speedCalc, RISING); // interrupció cridada quan els sensors envien digital 2 high (cada rotació de la roda) start = millis (); // setup LCD lcd.init (); // inicialitzar el lcd lcd.backlight (); // activar la retroiluminació LCD lcd.clear (); lcd.println ("Utilitzeu un casc!"); retard (3000); lcd.clear (); Serial.begin (115200); circImperial = circMetric *.62137; // convertir mètrica a imperial per a càlculs MPH}

void speedCalc ()

{elapsed = millis () - inici; inici = millis (); speedk = (3600 * circMetric) / transcorregut; // km / h velocitat m = (3600 * circImperial) / transcorregut; // Milles per hora}

bucle buit ()

{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 (transcorregut)); lcd.print ("ms / rev"); retard (1000); // ajustar la preferència personal per minimitzar el parpelleig}

No passa tanta cosa: cada vegada que la roda fa una volta, el senyal del sensor passarà de menor a major, provocant una interrupció que crida a la funció speedCalc ().

Això fa una lectura de millis () i després calcula la diferència entre la lectura actual i la lectura anterior: aquest valor es converteix en el temps per cobrir la distància (que és la circumferència de la roda en relació amb el sensor) emmagatzemada a

float circMetric = 1,2;

i es mesura en metres). Finalment calcula la velocitat en km / hi MPH. Entre les interrupcions, l'esbós mostra les dades de velocitat actualitzades a la pantalla LCD, així com el valor del temps en brut per a cada revolució per motius de curiositat. A la vida real, no crec que ningú muntés una pantalla LCD en una bicicleta, potser seria més rellevant una pantalla LED.

Mentrestant, podeu veure com funciona aquest exemple al següent petit videoclip. En lloc d’una combinació de roda de bicicleta i interruptor de canya / imant, he connectat la sortida d’ona quadrada d’un generador de funcions al pin d’interrupció per simular els impulsos del sensor, de manera que pugueu fer-vos una idea de com funciona.

Pas 4:

Això resumeix gairebé l'ús de millis () de moment. També hi ha els micros (); funció que compta els microsegons.

Així ho teniu, una altra funció pràctica que pot permetre solucionar més problemes a través del món d’Arduino. Com sempre, ara depèn de vosaltres i de la vostra imaginació trobar alguna cosa per controlar o enfrontar-vos a altres embolics.

Aquest article us el proporciona pmdway.com: tot per a fabricants i aficionats a l'electrònica, amb lliurament gratuït a tot el món.