Arduino Millis vs demora
Qué ¿Es la función Millis () en Arduino??
Esta función proporciona el tiempo total a partir de la ejecución del código Arduino y continuará ejecutándose hasta que el programa se esté ejecutando. Del mismo modo, esta función proporciona el tiempo transcurrido en milisegundos y tiene la capacidad de ejecutarse durante 50 días después de eso, esta función restablecerá su valor a cero y comenzará de nuevo desde.
La importancia de esta función es que se puede usar en el programa Arduino si una instrucción se ejecuta solo en un momento específico solo. Para una ilustración adicional, hemos explicado el funcionamiento de la función Millis con el ejemplo.
Supongamos que tenemos que ejecutar una instrucción después de cada 5 segundos, por lo que primero hemos definido el tiempo en milisegundos, después de lo cual la instrucción específica se ejecutará.
Unsigned Long Executiontime = 5000;
Entonces, definimos la variable constante nombrada Tiempo de ejecución Tener un valor de 5000 milisegundos, para verificar la hora actual del programa, utilizaremos la función Millis y almacenaremos su valor en el tiempo presente variable.
Unsigned Long Time;
Presenttime = Millis ();
A continuación, tenemos que hacer la condición para el tiempo en la que se ejecutará la instrucción. Entonces, creamos una condición IF que será verdadera cuando la diferencia de tiempo actual y pasado alcance 5000 milisegundos y la instrucción dentro de la condición IF se ejecutará. Para tales condiciones, también tenemos que declarar otra variable que ahorrará el tiempo anterior o la hora pasada.
Podemos diseñar esta condición de tal manera que cuando la diferencia de la corriente y el tiempo anterior sea mayor que igual al tiempo de ejecución, ejecute las siguientes instrucciones. Después de ejecutar la instrucción respectiva, guarde esa hora actual en la variable de pasatiempo.
pasatiempo largo sin firmar = 0;
if (presente-pasta-pasttime> = ejecutiontime)
// Ejecute la instrucción
PASTIME = CurrentTime;
Aquí una cosa es recordarse que hemos utilizado el tipo de datos largo debido a la función Millis (), ya que tiene valores considerablemente grandes.
Código Arduino para el funcionamiento de la función Millis ()
El código completo para comprender el funcionamiento de la función Millis se da como:
const sin firmar Long Executiontime = 5000; /*hora en la que se ejecutará la instrucción*/
Unsigned Long Pasado = 0; // Variable para Fuerte el tiempo pasado
Unsigned Long presente = 0; // variable para almacenar el tiempo presente
setup () void
De serie.Begin (9600); // Inicialización de la comunicación en serie
bucle void ()
Presenttime = Millis (); // Actualización del valor de presente
/ * Este es el evento */
if (presenteTime - pastor> = Ejecuttime) / *condición de tiempo en la que se ejecutará las instrucciones * /
De serie.imprimir ("El tiempo presente es:");
De serie.println (presente); // mostrando la hora presente
De serie.imprimir (""); // incluyendo espacio
De serie.imprimir ("instrucción para ser ejecutada:");
De serie.println ("Bienvenido a Linuxhint"); // instrucción para ser ejecutada
PASTIME = Presente; // Actualización del valor de tiempo pasado
El código Arduino funcionará de tal manera que, por ejemplo, en la primera iteración, el valor del pasatiempo es cero y digamos que la hora actual es de 400 milisegundos. De acuerdo con la condición IF, la respuesta será de 400, que es menos de 5000 milisegundos, por lo que la condición IF será falsa.
Del mismo modo, en la tercera o cuarta iteración, el "tiempo presente" es de 5000 milisegundos, entonces la diferencia será de 5000 milisegundos, ya que el valor del "pasatiempo" sigue siendo cero. Entonces, la instrucción se ejecutará y se actualizará el valor para el pasatiempo.
De esta manera podemos usar la función Millis para ejecutar una instrucción específica en un momento específico.
Salida del código Arduino para la función Millis ()
En el monitor en serie se puede ver claramente que cuando hay una diferencia de "tiempo presente" y "pasatiempo" es 5000, entonces la condición será cierta. La imagen publicada a continuación muestra los valores del "tiempo presente" en el que la condición if es verdadera y la instrucción que se ejecutará.
Si simplemente imprimimos el valor de la función Millis () que se almacena en el nombre de la variable "Presenttime" se verá así como en la imagen que se proporciona a continuación:
¿Qué es una función de retraso () en Arduino?
La función de retraso () se usa principalmente para detener el código Arduino durante algún tiempo. En otras palabras, esta función crea un retraso de algún tiempo especificado por el usuario en el funcionamiento del código Arduino.
Esta función se puede usar en el programa donde el valor de cualquier variable se actualizará con frecuencia. Entonces, al dar la pausa al programa Arduino, dará tiempo para que el sensor actualice su valor.
Del mismo modo, podemos usar la función de retraso para dar una pausa entre la ejecución de múltiples instrucciones. La función de retraso toma el tiempo en milisegundos, ya que su entrada y la sintaxis para la función de retraso se proporciona a continuación:
retraso (tiempo en milisegundos);
Código Arduino para usar la función de retraso
Para demostrar la funcionalidad de la función de retraso (), hemos compilado un código Arduino que se proporciona como:
setup () void
De serie.Begin (9600); // Inicialización de la comunicación en serie
bucle void ()
De serie.imprimir ("Hola y bienvenido"); // Instrucción antes del retraso
retraso (5000); // Creando una pausa de 5000 milisegundos
De serie.println ("\ n to linuxhint.com "); // instrucción después del retraso
En el código Arduino hemos dado dos instrucciones que imprimirán los datos en el monitor en serie. Ambas instrucciones se ejecutan con un retraso de 5000 milisegundos. En otras palabras, después de la ejecución de la primera instrucción, hemos utilizado una función de retraso que pausará el código Arduino para 5000 milisegundos. Después de 5000 milisegundos, el programa se iniciará desde donde se detuvo, y la segunda instrucción se ejecutará.
Salida del código Arduino para usar la función de demora ()
La imagen publicada a continuación es la primera instrucción dada antes de que se use la función de retraso ().
Después de esta instrucción, el programa se detiene por 5000 milisegundos y luego se lleva a cabo la ejecución de la segunda instrucción. La siguiente figura muestra que el programa ha ejecutado la segunda instrucción.
Comparación de la función Millis () y demora ()
Las diferencias entre el milis () y la función de retraso se dan en la tabla a continuación:
| función de milis () | función de retraso () |
|---|---|
| Se puede usar para ejecutar una instrucción específica en el momento específico | Esta función solo crea una pausa en el flujo del código Arduino |
| Esta función da el tiempo en milisegundos desde cuando se inicia el código Arduino y puede subir a la hora durante 50 días | Esta función lleva tiempo en milisegundos a medida que la entrada del usuario y se ejecuta durante ese tiempo específico |
| Esta función no se detiene o detiene el código | Esta función detiene todo el código por algún tiempo |
¿Cómo puedo usar Millis () en lugar de demora ()?
Usamos la función Millis en lugar de la demora simplemente usando la condición if para el tiempo específico en el que queremos ejecutar cada instrucción. Hacer esto dará un retraso automáticamente entre la ejecución de dos o más instrucciones y se puede servir el propósito del retraso. La principal ventaja para usar el milis en lugar de la demora es que todo el programa Arduino no se detiene; Solo la ejecución de alguna determinada instrucción se detiene. Sin embargo, la función de retraso detiene todo el programa y el uso de la función de retraso puede perder algo las entradas externas al programa porque todo el programa se detiene.
Para ilustrar aún más, hemos proporcionado el código Arduino de cómo podemos usar la función Millis en lugar de la función de retraso:
const sin firmar Long Executiontime = 6000; /*hora en la que se ejecutará la primera instrucción*/
const sin signo de ejecución tiempo1 = 2000; /*Tiempo en el que se ejecutará la segunda instrucción*/
Unsigned Long Pasado = 0; // Variable para el tiempo pasado de la primera instrucción de la primera instrucción
Unsigned Long presente = 0; // Variable para almacenar tiempo presente
Unsigned Long Pasado1 = 0; // Variable para el tiempo pasado de la segunda instrucción de la segunda instrucción
setup () void
De serie.Begin (9600); // Inicialización de la comunicación en serie
bucle void ()
Presenttime = Millis (); // Actualización del valor de presente
/ * Este es el evento */
if (presenteTime - pastor> = Ejecuttime) / *condición de tiempo en la que se ejecutará las instrucciones * /
De serie.imprimir ("El tiempo presente es:");
De serie.println (presente); // mostrando la hora presente
De serie.imprimir (""); // incluyendo espacio
De serie.imprimir ("instrucción para ser ejecutada:");
De serie.println ("Mantenga las luces apagadas"); // instrucción para ser ejecutada
PASTIME = Presente; // Actualización del valor de tiempo pasado
if (PresentTime - Pasttime1> = ExecutionTime1) / * condición de tiempo en la que se ejecutará las instrucciones * /
De serie.imprimir ("la hora actual");
De serie.println (presente); // mostrando la hora presente
De serie.imprimir (""); // incluyendo el espacio
De serie.imprimir ("instrucción para ser ejecutada:");
De serie.println ("encender las luces"); // Instrcution para ser ejecutado
PASTTIME1 = Presenttime; // Actualización de la hora actual de la instrucción de Scodn
Aquí en el código hemos utilizado la función Millis para ejecutar las dos instrucciones con un retraso de casi 4 segundos. Hemos publicado una imagen de la salida del código Arduino compilado para explicar cómo se puede usar la función Millis reemplazándola con la función de retraso.
En la salida podemos ver que cuando la hora es de 2 segundos, la segunda instrucción se ejecuta hasta que la hora alcanza los 6 segundos. Cuando la hora alcanza 6 segundos, se ejecuta la primera instrucción.
Conclusión
Para crear una lógica de cualquier tarea que debe realizarse utilizando Arduino, hay múltiples funciones que se pueden usar. Estas funciones hacen que la funcionalidad del código Arduino sea eficiente y fácil de implementar la lógica creada.Hay dos funciones que hemos discutido en detalle, una es la función Millis y la otra es la función de retraso. La función Millis ejecuta una instrucción específica en un momento específico, mientras que la función de retraso detiene el código Arduino por algún tiempo.