Paso 1: Abrir y cerrar sin Delay()
Hasta ahora que hemos estado usando la función delay() para poner en pausa el sketch de Arduino momentáneamente así un poco de tiempo puede pasar entre dos comandos de Arduino. En el bosquejo de parpadeo de LED, utilizamos delay() para establecer la cantidad de tiempo que se encendió el Arduino y la cantidad de tiempo que fue dado vuelta apagado:
digitalWrite (ledPin, HIGH); //turn LED en
Delay(1000); / / espera de 1000 milisegundos (1 segundo)
digitalWrite (ledPin, LOW); //turn LED apagado
Delay (1000); //wait un segundo
A veces usar delay() no es una buena opción porque el Arduino no puede realizar ninguna tarea secundaria mientras ocurre la demora. Imagina que queríamos parpadear un LED y detectar una pulsación en el mismo tiempo usando delay():
Loop() {}
digitalWrite (ledPin, HIGH);
Delay(1000);
digitalWrite (ledPin, LOW);
Delay(1000);
buttonState booleano = digitalRead(7);
}
En el código anterior, estamos sólo midiendo el botón una vez cada dos segundos, así que puede tomar hasta dos segundos antes de que se detecta una pulsación y prensas muy breves pueden no siempre Haz detectados en todos.
Millis() nos da control sobre cuando eventos suceden sin poner pausa en el bosquejo. Cada vez que llamamos millis() en un sketch de Arduino, devuelve el número de milisegundos desde el Arduino se activó.
Ejecute el siguiente código para ver cómo funciona millis():
Aquí es cómo utilizar millis() a parpadear un LED sin utilizar delay().
El bosquejo anterior presenta algunas novedades:
sin firmar largo es otro tipo de datos (hasta ahora hemos visto int y boolean). Sin firmar largo es igual que int, pero más grande, voy a explicar... Cada tipo de datos requiere una cierta cantidad de espacio en la memoria de Arduino, y la cantidad de espacio que libera el Arduino para una variable dada dicta el min y max valores que la variable puede almacenar. Por ejemplo, el int puede ir desde-32,768 hasta 32.767, si has intentado hacer algo como esto:
myVariable int = 100.000;
Termina con un error muy extraño en tu código. Esto puede parecer como un rango arbitrario, pero viene del hecho de que int requiere 16 bits de espacio en la memoria de Arduino, y con 16 bits de binario puede almacenar números desde 0 hasta (2 ^ 16 - 1) = 65535. Pero la gente decidió que int debe ser capaz de almacenar números negativos también, así que uno de los bits en el número de 16 bits se utiliza para almacenar el signo (positivo o negativo) y los 15 bits restantes almacenar el valor: 2 ^ 15 = 32768. Incluyendo 0, terminamos con la gama-32,768 a 32.767. Otro tipo de datos llamado un insigne int no almacena el signo, por lo que obtiene el intervalo de 0 a 65535 que calculé antes, pero no puede almacenar un número negativo en un insigne int.
Cuando necesitamos utilizar números mayores que 65535 o menos-32768, utilizamos un tipo de datos llamado largo. Durante mucho tiempo se asigna 32 bits de espacio en la memoria de Arduino. 2 ^ 32 = 4,294,967,296, este centro alrededor de cero para obtener una gama de:-2,147,483,648 a 2,147,483,647. Sin firmar largo tiene, como unsigned int siempre es positivo, así que van desde 0 hasta 4,294,967,295.
Hay ningún tipo de datos más grande para almacenar números de largo, así que si usted necesita almacenar un número mayor de 4,294,967,295, tendrás que subir con una manera diferente de almacenar (tal vez los primeros 9 bits en un número y los nueve últimos en otro?). Esta limitación tiene algunas consecuencias interesantes para la función millis(). Millis devuelve sin firmar longs, y continuamente está contando en milisegundos, millis() realmente volverá atrás a cero una vez se alcanza:
4,294,967,295 ms
= 4.294, 967seconds
= días 49.71
Si usas millis() y usted planea guardar que proyecto correr durante largos períodos de tiempo sin nunca apagar o reiniciar, deben ser conscientes de ello.
Un comentario más acerca de tipos de datos: podríamos haber sido con de largo o sin firmar largo todo este tiempo cuando declaramos números pin u otras variables en los dibujos de ejemplo hasta ahora, pero en general es una buena idea para utilizar los datos más pequeños tipo posibles para una variable, de esa manera usted tiene un montón de espacio en la memoria de Arduino para otras cosas. En Arduino, longs se utilizan raramente, pero millis() es un buen ejemplo de cuando vienen prácticos.
Volviendo al bosquejo, la idea general es almacenar la última vez que se enciende el LED de encendido o apagado y comparar con la hora devuelta por millis(). Una vez que la diferencia entre esos dos veces mayor que un intervalo, sabes que es tiempo para cambiar el LED nuevo. Para ello he configurado algunas nuevas variables de almacenamiento de información:
int ledState = bajo; //current estado del LED
timeOfLastLedEvent largo sin signo = 0; //the última vez actualizó el LED
intervalON int = 1000; //how mucho queremos que el LED permanezca
int intervalOFF = 500; //how mucho queremos que el LED permanezca apagado
En el loop() hay un montón de lógica que comprueba ver si da tiempo ha pasado y si es así, cambia el LED, actualiza la variable "timeOfLastLedEvent" y cambia el estado almacenado de lo LED. La lógica se repite dos veces, una vez que para el caso de que el LED es alta y una vez para el caso de que el LED es bajo, te repito el caso baja a continuación:
Si (currentMillis - timeOfLastLedEvent > intervalOFF) {//and suficiente tiempo ha pasado
digitalWrite (ledPin, HIGH); //turn en
ledState = alto; //store su estado actual
timeOfLastLedEvent = currentMillis; //update el tiempo de este nuevo evento
}
currentMillis es un sin firmar largo que representa la hora que se actualiza cada vez que comienza la función loop() de Arduino. (currentMillis - timeOfLastLedEvent) da el seno del tiempo estado de LED ultima fue cambiado, comparamos esto contra el intervalOFF para ver si es momento de apagar el LED, si no es el Arduino mantendrá la actualización currentMillis y verificar de nuevo hasta el momento.
