bclose

Arduino y los Timers

Las interrupciones temporizadas
tienda arduino

Objetivos

.

 
    • Presentar las interrupciones programadas o Timers.
    • Instalar una librería, la TimerOne.
    • Mostrar un ejemplo de programación de un evento con un Timer.
 

Material requerido.

 

Todo el material necesario para esta seguir este curso lo puede ver en nuesto kit arduino.

Imagen de Arduino UNOArduino UNO o equivalente.

 

vueltas con las interrupciones temporizadas

 

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:

Margen de tiempo

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.

 
  • Aunque pueda pareceros poco tiempo, ya es un margen considerable para atender a las cuestiones urgentes con precisión.
  • Naturalmente existen librerías que a partir de esto van incrementando contadores externos para multiplicar el plazo de disparo.
 

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.

 
  • No hace falta ninguna librería para programar un Timer en Arduino UNO. Basta con programar directamente los registros internos del ATMEGA328,  
  • Arduino soporta sus instrucciones y conoce todos los valores y funciones precisas, pero os obliga a conocer los entresijos a nivel de hardware del procesador y por ahora esto si que es como para salir aullando.
  • Así que de momento haced como todos, como que no existe y centraros en la librería TimerOne. Ya tendremos tiempo de volver  sobre el asunto en el doctorado.
 

 

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. Empecemos definiendo cosas  Prog_57_2

#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 funcion 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:

 
  • Código limpio y elegante. No tenemos que calcular en el loop si estaremos perdiéndonos algo o no. Cuando el tiempo programado se cumple la interrupción salta y se ejecuta limpiamente.
  • Conceptualmente la programación orientada a eventos es la predominante en los moderno sistemas operativos como Linux, Windows o OSX y si aprendéis a pensar así no os resultara difícil entender el concepto bajo Visual Basic o C#.
  • No importa que estemos en un delay, la interrupción salta impecable.
  • La medida del tiempo es muy precisa.
 

Pero como la felicidad completa no existe tenemos que hablar de los inconvenientes:

 
  • El primero y grave, es que si jugamos con los timers, muchas de las instrucciones que dependen de ellos dejaran de funcionar.
  • Entre estos están, los pines PWM y analogWrite() y la librería Servo. Dependiendo del modelo Arduino y del Timer que usemos la cosa es grave.
  • Si vuestro Timer entra en conflicto con algo puede ser muy complicado comprender el problema.
  • Si tu Servicio ISR tarda más en ejecutarse de lo que tarda en saltar la nueva interrupción (Y te puede pasar por un error de cálculo) antes de acabar puede volver a entrar porque ha disparado de nuevo el Timer. La situación alcanzara un nivel de peligro inmediato porque tu Arduino se colgará y no sabrás porque.
 

 

Resumen de la sesión

 

Hoy en nuestro curso incio para arduino hemos aprendido lo siguiente:

 

 

    • Hemos visto que además de las interrupciones por hardware podemos ejecutar interrupciones programadas mediante Timers.
    • Hemos visto una librería, la TimerOne con la que resulta asquerosamente sencillo programar una de estas interrupciones.
    • Hemos comentado que no conviene enredarnos por ahora en la programación interna del procesador.
    • Hemos creado un pequeño ejemplo de muestra, para provocar con una interrupción programada, un blinking LED.
 

 

 

No Comments

Give a Reply

WordPress Anti-Spam by WP-SpamShield