bclose

Arduino y los Timers

Las interrupciones temporizadas

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.

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

 

 

 

    • 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.
 

 

 

(89) Comments

    • Adrian

    Muy buenas,

    Actualmente estoy intentando implementar un reloj de pared (con unos SSD bien grandotes que he comprado) y una placa arduino. Ayer realice todo el montaje HW y el conexionado con la placa de arduino, y el reloj funcionaba perfectamente.

    Utilizo una placa arduino mega2560 (sin un modulo RTC externo) y la libreria “TimerONE.h”. Genero una interrupción cada Timer1.initialize(500000); //0,5segs para hacer parpadear el segundero, y acumulo la cuenta en una variable, realizando la actualización de la hora y minutos mostrados una vez que la variable alcanza el 120.
    Como ya he dicho, todo el reloj parece funcionar correctamente, si no fuera porque lo conecte ayer a las 20:00 (+ o -), y hoy a las 7:00 llevaba unos 5 minutos de retraso (tengo implementados mecanismos para verificar si la placa se ha reiniciado, y no ha sido el caso).

    Entiendo que puede deberse a que el preescalado que hacen las funciones de TimerONE arrastran un pequeño error que se va acumulando, aunque según mis cálculos no debería ser así. Se os ocurre alguna explicación de porque ocurre el error y alguna forma de solucionarlo de forma fiable?

    Muchas gracias 😉

    • Hola Adrían, pues tiene toda la pinta de que és por lo que tu comentas… Lo más sencillo es que uses un RTC, pero asegúrate que tenga compensación para la deriva térmica, o te ocurrirá lo mismo. Un saludo.

  • queria preguntar si hay alguna forma de poder alterar el valor del timer una vez que el programa esta en funcionamiento

    • Hola Julio, si puedes hacerlo, creo que con esta función: setPeriod(period)

  • Gracias por responder mi mensaje…
    He implementado esta programación pero me pone resultados erróneos
    unsigned long previousMicros=0; //para contar milisegundos
    unsigned long currentMicros=0;
    float Aradian=0;
    float fp=0;
    void setup() {
    pinMode(18,INPUT);
    pinMode(19,INPUT);
    attachInterrupt( 5, VOLTAGEINT, RISING); //ACTIVA interrupcion 5 DE VOLTAJE
    attachInterrupt( 4, CURRENTINT, RISING); //ACTIVA interrupcion 4 DE CORRIENTE
    }
    void fp() {
    Aradian=currentMicros*0.000377; // conversión del tiempo en micro segundos en angulo en radianes
    fp=cos(Aradian);
    myGLCD.setFont(BigFont);
    myGLCD.setColor(255, 255, 255);
    myGLCD.setBackColor(0, 0, 0);
    myGLCD.print(“fpv”,110,80 );
    myGLCD.printNumF (fp,2,CENTER ,100);
    // delay (100);
    }
    void VOLTAGEINT(){
    previousMicros=micros();//iniciar timer 1
    }
    void CURRENTINT(){
    currentMicros=previousMicros-micros();//detener timer 1
    }

  • Hola, buena tarde, me preguntaba como podría hacer para medir el factor de potencia utilizando un timer… he implementado circuitos para lanzar pulsos cuando las ondas de voltaje y corriente crucen por cero… pero la dificultad es como hacer para que se pueda medir el tiempo de desfase entre las 2 ondas..implemente interrupciones mediante los pines 20 y 21 pero no funciona. Ayuda..no se como hacer esta complicado

    • Hola Victor,
      En principio puedes disparar una interrupcion en el paso por cero y otra cuando abres la conduccion de la puerta. Puedes hacer un servicio de interrupcion de la primera que simplemente pone a 0 un timer… y lo lees cunado hacer el disparo de puerta. El valor de este contador deberia ser lo que buscas

  • Hola, se me parte la cabeza tengo un problema con el tiempo y arduino, tengo un motor de una puerta corrediza con encoder interno que registra cuando gira, el proyecto es saber cuando el motor se detiene por algun objeto (pie o fuerza de una persona), osea si el motor gira para cerrar la puerta el encoder da valores incrementados por dar un numero 99, 100, 101, 102 y supongamos que se detiene y queda en 102 eso me da a entender que algo lo ha frenado, y debo rápidamente por ejemplo en menos de 500ms quitarle al energía sino quemaría el circuito del motor haciendo fuerza, mi pregunta es, que harías, no te digo que resuelvas mi problema, no se que hacer, se que estas muy ocupado, pero seria una gran ayuda aunque sea un simple consejo. Mi idea era registar cada 100ms X cantidad de giro del motor, si no cumple con la distancia de giro entonces sabre que algo ha frenado el motor, pero necesitaria 2 o mas relojes que no detengan arduino, ni tampoco lo dejen colgado. que podria hacer? Muchas Gracias.

    • Alex, hazlo como dice éste tutorial, mediante temporizaciones hardware. No necesitarías más de un temporizador, con uno sólo bastaría, por ejemplo suponiendo que pogramas el timer para 100 ms y quieres comprobar que lleva 500 ms parado, declaras una variable global y con la directiva “volatile” que se llame “cuenta”. Cuando entras a la interrupción compruebas si ha girado: si ha girado pones cuenta a cero, si no lo ha hecho incrementas “cuenta”. Después compruebas si “cuenta” vale 5: si no vale cinco no haces nada pero si vale cinco significa que has entrado 5 veces (500 ms) y no ha girado -> algo lo está bloqueando.

Give a Reply

WordPress Anti-Spam by WP-SpamShield

¡Ofertón!

Robot Rover 4×4

Ahora por sólo

50€ + IVA

¡Lo quiero!