Hasta ahora, hemos medido el tiempo en milisegundos y usado el delay para temporizar las cosas, así usábamos un delay de unos 250 ms para que el blinking LED se encendiese y se apagase, tranquilamente.
El problema del delay () es que congela Arduino el tiempo especificado. Mientras no sea mucho, bueno, podemos aceptarlo, pero imagínate que queremos hacer el blinking LED para un semáforo, donde los tiempos de espera van de digamos 30 segundos a 1 minuto.
Podemos pedirle que haga un delay de 60 segundos * 1.000 = 60.000 millis, pero claro esto supone que no podremos hacer ninguna otra cosa hasta que no pase un minuto, ni ver si nos pulsan un botón, o refrescar una pantalla con el tiempo que queda de semáforo.
Así que no parece muy buena idea usar delays en muchas situaciones. No es raro que queramos programar tareas periódicas en nuestros Arduinos en rangos que van desde unos microsegundos hasta varios minutos, pero queremos hacerlo de un modo que entre tanto podamos seguir trabajando.
Para eso tenemos las interrupciones programadas o Timers, para que nos toquen el timbre cuando hay que ejecutar una función programada, sin necesidad de estar continuamente comprobando si es la hora.
Ya vimos en una sesión anterior el concepto de interrupción hardware. Es el equivalente a un timbre que nos avisa de que alguien está en la puerta y debemos atenderle.
Arduino dispone además de una segunda clase de interrupciones, los Timers, que hacen lo mismo que las interrupciones hardware, pero en lugar de dispararse cuando se cumple un cierto proceso hardware en uno de los pines, se dispara cuando ha transcurrido un tiempo preciso, previamente programado.
Es el equivalente del despertador, que cada mañana suena a la misma hora.
Los contadores internos de los Timers
Nuestros Arduinos UNOS y MEGAs tienen un cristal que bate a 16 MHz, o 16.000.00 de veces por segundo.
Teóricamente podríamos fijar una interrupción cada 1/16000000 segundos, lo que no sería muy útil porque cada instrucción de Arduino necesita varios pulsos de reloj para ejecutarse (y algunos muchos pulsos).
Por eso cada Timer dispone de un registro interno que indica cada cuantos ticks del reloj debe dispararse. Básicamente el que nos interesa es un Timer cuyo registro es un entero sin signo de 16 bits, lo que le permite contar hasta 216 = 65.536
Si este contador se disparase cada tick del cristal, no nos serviría de mucho porque, el máximo tiempo que el contador podría abarcar sería de:
Como es muy probable que necesitemos algo más de flexibilidad en los tiempos, los chicos que diseñaron el corazón e Arduino, el ATMEGA328, incluyeron unos divisores de esta frecuencia básica del cristal de cuarzo., de modo que solo salta un tick al contador cada ciertos ticks del patrón básico.
En Arduino UNO esos divisores pueden ser 1, 8, 64, 256 y 1024. De ese modo podemos “frenar” hasta mil veces la velocidad de incremento del contador de disparo.
Un cálculo rápido nos dice que el anterior máximo de disparo puede subir desde los 4 ms de antes a 1024 veces más, o sea alrededor de 5 segundos.
Como la explicación que hemos planteado para mostrar que la interrupción programada en el Timer saltará cuando el registro interno, alcance el valor fijado previamente (después de ralentizarlos con el divisor elegido) es algo, que cualquier memo puede entender, necesitamos complicarlo de algún modo que impida que esto se llene de paletos enredando con la electrónica.
Naturalmente el mejor modo de mantener este asunto entre señores, es complicar innecesariamente los nombres de las cosas de modo que los susodichos paletos salgan aullando nada más ver lo complicado que parece todo.
Así pues en la jerga de Arduino, no hablamos de contadores de disparo, (Seria una vergüenza, no), en su lugar les llamaremos Compare Match Registers o CTRs y a los divisores les llamaremos prescalers. Chúpate esa
Además, si leéis la documentación técnica que abunda en internet sobre los Timer Interrupts, os hablarán inmediatamente de los registros internos del chip y de cómo calcular la frecuencia de la interrupción en Hz y otras pavadas parecidas.
Me han levantado un dolor de cabeza superior.
Mi consejo es que os saltéis todo esto por ahora y os centréis en el uso de alguna librería sensata para controlar las interrupciones programadas como la TimerOne y punto. Y a eso vamos.
La librería TimerOne
Hay varias versiones de esta librería corriendo por ahí. Yo he elegido esta, básicamente porque parece soportar más modelos de Arduino (Incluyendo al MEGA) y porque parece que el código es más rápido que el original. Podéis descargarla Aquí TimerOne.zip
Las cosas importantes de la librería. Cuando la importéis tendréis esta línea:
#include <TimerOne.h>
Esto nos crea un objeto llamado Timer1 directamente, sin necesidad de instanciarlos. Lo siguiente es programar el intervalo de disparo en microsegundos:
Timer1.initialize(150000); // 150 ms
Y ya solo falta hacer el attach de la interrupción con el servicio de gestión o ISR:
Timer1.attachInterrupt( ISR_Callback) ;
Y con esto ya habéis programado una interrupción temporizada que saltara cada 150 ms y llamara la función ISR_Callback. ¿Fácil no?
Veamos ahora un programa que se aproveche de esto. Podeís descarlo completo aqui:
Empecemos definiendo cosas
#include <TimerOne.h> const int led = 13; // the pin with a LED int ledState = LOW; // El LED empieza apagado volatile unsigned long blinkCount = 0; // La definimos como volatile void setup(void) { pinMode(led, OUTPUT); Timer1.initialize(250000); // Dispara cada 250 ms Timer1.attachInterrupt(ISR_Blink); // Activa la interrupcion y la asocia a ISR_Blink Serial.begin(9600); }
Y ahora veamos la Función de servicio, recordad que conviene que una ISR sea la mínima expresion:
void ISR_Blink() { ledState = !ledState ; blinkCount++ ; // Contador veces se enciende el LED }
Cada vez que se invoca, invierte la situación del LED y aumenta blinkCount en uno para llevar la cuenta de las veces que invertimos el estado. Veamos la función principal:
void loop(void) { unsigned long N; // Haremos copia del blinkCount digitalWrite(led, ledState); // Asignamos el valor del // status a la salida noInterrupts(); // Suspende las interrupciones N = blinkCount; interrupts(); // Autoriza las interrupciones Serial.print("Ciclos = "); Serial.println(N); delay(100); }
Fíjate en que desactivamos las interrupciones en el momento que vamos a copiar el valor del contador, para evitar que entre otra interrupción a medio leer, y las volvemos a activar al finalizar.
Después podemos seguir con el programa normal sin preocuparnos de comprobar si toca o no toca saltar a la interrupción programada. ISR_Blink se ejecuta limpiamente cada tanto tiempo solita. Además podemos usar delays tranquilamente, porque las interrupciones tienen prioridad y se ejecutaran aun cuando el delay esté activo.
Aqui os dejo un mini video con el resultado
¿A que parece que es demasiado bueno para ser cierto? Pues tienes razón, en la vida no existe la felicidad completa y las interrupciones tienen ventajas e inconvenientes.
Entre las ventajas tenemos:
Pero como la felicidad completa no existe tenemos que hablar de los inconvenientes:
Resumen de la sesión
Hoy en nuestro curso incio para arduino hemos aprendido lo siguiente:
Material requerido