Utilizar las esperas en Arduino y no romper nada en el intento

esperas en Arduino¿Qué tal andas peligro electrónico? Hoy te quería hablar de las esperas en Arduino. Ya que cuando quieres hacer una espera normalmente utilizas el delay pero esto tiene algunos peligros ocultos.

El delay es una función que hace una espera de los milisegundos que le digas. De esta manera lo que hace es generar un bucle que no hace nada durante ese tiempo. Esto sería cómo saber qué tienes que esperar media hora para salir de casa y te quedas la media hora mirando el reloj sin hacer nada más.

El problema del delay

La función delay es una espera bloqueante o espera activa. No te permite hacer nada más y esto es una auténtica putada si estás intentando medir algo o si estás jugando con interrupciones. Las interrupciones son como los guardianes de la noche (Night’s Watch), se dedican a vigilar un cambio en el pin que se les pide y si eso pasa paran toda la maquinaria y hacen la acción que se les ha pedido.

¿Te imaginas que en medio de la espera bloqueante se activa la interrupción? El programa va a la interrupción y ejecuta las instrucciones que tiene que hacer y al acabar vuelve al programa. Y sigue con la espera. ¿Qué sentido tiene la espera si se ha pausado la propia espera? Claro, si es que hemos tenido el horno encendido unos segundos más no importa demasiado, pero imagínate que has tenido en marcha un brazo mecánico que se mueve en horizontal. Y resulta que el brazo tenía el tiempo justo para no darse con una pared. Si el tiempo no es exacto se estampa. ¡Se ha liao el taco y no sabes aún cómo!

Por eso utilizar una espera bloqueante no está mal para salir del paso pero puede resultar en alguna catástrofe. Navegando me he encontrado las 7 razones para no utilizar este tipo de esperas, así que te las dejo por aquí.

La solución a las esperas bloqueantes

Bueno, ¿Y cómo solucionas este enredo con los delay? Con esperas NO bloqueantes. Estas esperas son más del rollo: He quedado en 30 minutos, así que en lugar de estar todo el tiempo mirando el reloj me pongo una alarma. Lo que se hace es poner una alarma que avisa cuando el tiempo se ha agotado.

Esto te permite estar haciendo otras cosas durante la espera y qué al utilizar interrupciones no se lie. Aquí tienes algunos métodos para hacerlo. Yo normalmente uso este:

unsigned long current_t = 0;
unsigned long previous_t = 0;
unsigned long delay_t = 6000;/*Tiempo elegido*/

void setup() {

}   

void loop(){
 current_t=millis();
 if(current_t - previous_t > delay_t){

/*Codigo a implementar tras la espera*/
 //Si lo hay...
 
 previous_t=current_t;
 }       
}

Al final lo que hago es simple. Pongo en una variable el momento temporal en qué estamos con la función millis, vamos que miro la hora. Después pongo la condición de que si la resta de la hora de ahora con la hora de antes es mayor que el tiempo que yo quería esperar quiere decir que mi espera ya ha terminado así que hago lo que tengo que hacer. De hecho si quieres puedes añadir líneas antes o después del if de manera que se haga algo durante los momentos de espera.

Conclusiones

El delay es el demonio que te lo hace todo muy fácil pero que en momentos en los que el tiempo es clave te putea y te juega una mala pasada. Si tienes claro que el tiempo no es una cosa crítica o que tan sólo vas a esperar 0.2 segundos y que en ese momento ninguna interrupción sucederá y si lo hace pues mira..adelante, utilízalo.

Si vas a utilizar interrupciones, el código de antes te permite saber dónde estás en el tiempo realmente. No sigue el contador desde dónde lo paró la interrupción como en el caso de las esperas bloqueantes. Además, dentro de las interrupciones está prohibido utilizar delays.

¡Si te ha resultado útil dame un +1 en Google Plus ahí en la barra lateral! Y ya sabes, ¿Eres de los que espera a que la pasta esté hecha o de los que se pone una alarma para que lo avise? ¡Cuidadín con las chispas y éxitos!

[Total:10    Promedio:3.5/5]
Opt In Image

Deja un comentario