Utilizando el modulo TMR1 del PIC16F
Gracias por visitar este blog dedicado a la electrónica y en particular a la programación de microcontroladores PIC, En esta ocasión aprenderemos a manejar el modulo TMR1 o TIMER1 del microcontrolador haciendo uso de los registros.
El objetivo de esta sección es poder utilizar este interesante modulo para generar rutinas de retardo en tiempo con una gran precisión, contar pulsos externos y sobre todo hacer un uso adecuado de este recurso logrando integrar la funcionalidad que ofrece a nuestro programa principal.
La programación se realizara utilizando el compilador XC8 y el entorno MPLABX disponibles en la pagina de microchip de forma gratuita, ademas también necesitara de los siguientes archivos peripheral.h y peripheral.c que contienen procedimientos y funciones básicas para el PIC16F887, puede prescindir de ellos o incluso modificarlos a su criterio si posee conocimientos sobre los registros SFR y sus respectivo bits.
Parte 1. Introducción al Modulo TMR1.
A menudo nos encontramos en la necesidad de manejar el tiempo con un mayor grado de precisión y confiabilidad, para lo cual es ideal que un micro-controlador disponga de recursos de hardware que ayuden con esta tarea, en un PIC este recurso se conoce como modulo TIMER y puede cumplir la función de contador o temporizador dependiendo de su diseño.
La serie de micro-controladores PIC16F, normalmente integra 3 módulos designados como:
- TMR0: Temporizador y Contador de 8 bits (Todos los modelos)
- TMR1: Temporizador y Contador de 16 bits (Revisar modelo)
- TMR2: Temporizador de 8 bits(Revisar modelo)
El principio básico de funcionamiento es similar en los tres modelos, pero presentan particularidades únicas que podrían adaptarse mejor a ciertas aplicaciones en nuestro programa.
De acuerdo a la entrada de este blog nos enfocaremos en como utilizar modulo TMR1, para ello simplificaremos su composición en tres etapas que se ilustran en la siguiente figura:
En la primera etapa (Modo) se debe definir si el modulo actuara como un Contador o Temporizador.
En un Contador los pulsos digitales provienen de forma externa ingresando por el pin T1CKI (pin RC0 en el PIC16F88x), el modulo capturara estos pulsos que podrían llegar en cualquier instante y a cualquier frecuencia. En un Temporizador los pulsos se generan desde el reloj del sistema, su frecuencia siempre sera un cuarto de la frecuencia del oscilador Fosc/4, el modulo captura estos pulsos internos que tienen un periodo igual al ciclo de maquina(4*Tosc) y servirán para determinar el tiempo transcurrido.
También es posible conectar un crystal de baja frecuencia 32.768KHz a los pines T1OSO y T1OSI para generar retardos de tiempo incluso cuando el PIC ingresa en modo de bajo consumo(sleep).
La segunda etapa(Pre-escala), aqui los pulsos capturados ingresan a un divisor que conforme al ajuste en su relación pueden dividir la frecuencia en 4 diferentes pre-escalas.
Por ejemplo para una pre-escala 1:4, la salida del divisor genera un pulso cada vez que se capturan cuatro pulsos.
La tercera etapa(registro Contador), finalmente los pulsos que salen del divisor incrementan un registro contador de 16 bits formado por los registros TMR1H(bits superiores) y TMR1L(bits inferiores), el rango de este contador sera de 0 a 65535 (0000h-FFFFh).
Es posible leer y escribir este registro en cualquier momento para calcular el tiempo transcurrido o contar el total de pulsos capturados en el pin T1CKI.
Cuando este registro contador esta en su limite de 65535, un incremento adicional provocara una condición conocida como desbordamiento que consiste en que el registro contador se reinicia con su valor inicial 0 y la bandera TMR1IF se activa para generar una interrupción si esta opción esta habilitada.
La configuración del modulo TMR1 se realiza mediante el registro T1CON que se describe en la siguiente imagen.
El modulo TMR1 posee otras particularidades que no se detallan en este blog, si desea conocer mejor las prestaciones de este recurso deberá consultar la hoja de datos.
Parte 2. Implementar un Contador.
Al implementar un contador lo que se busca es capturar pulsos externos que se generan desde un sensor, un oscilador externo o simplemente un pulsador que emite cambios de estado que deben contabilizarse en nuestra aplicación, para este fin veamos el siguiente ejemplo:
Si nuestra aplicación necesita detectar 700 pulsos externos que pueden darse en cuestión de segundos, horas, días, etc. debemos considerar los siguientes pasos:
- Se debe seleccionar el modo contador para que los pulsos externos ingresen por el pin T1CKI.
- Como la capacidad del registro contador TMR1H:TMR1L es de 0 a 65535, se seleccionara una pre-escala 1:1 para capturar los 700 pulsos.
- Para que la bandera TMR1IF se active al momento de captura los 700 pulsos, debemos ajustar el registro contador a un valor de 65536 - 700 para que se genere un desbordamiento cuando ingrese el total de pulsos.
- Se debe reiniciar la bandera TMR1IF y colocar en marcha el modulo TMR1.
- La rutina deberá esperar hasta que la bandera TMR1 se active.
Ahora realizaremos la programación necesaria para los pasos descritos anteriormente.
T1CONbits.TMR1CS = 1; //Modo contador
T1CONbits.T1CKPS = 0b00; //Ajuste pre-escala 1:1
TMR1H = 0xFD; //65536-700 = 64836 o FD44h
TMR1L = 0x44;
PIR1bits.TMR1IF = 0;; //Limpia la bandera
T1CONbits.TMR1ON = 1; //Arranca la captura
while(PIR1bits.TMR1IF == 0); //Espera hasta capturar los 700 pulsos
TMR1ON = 0; //Para la captura
//** 700 Pulsos capturados **//
T1CONbits.T1CKPS = 0b00; //Ajuste pre-escala 1:1
TMR1H = 0xFD; //65536-700 = 64836 o FD44h
TMR1L = 0x44;
PIR1bits.TMR1IF = 0;; //Limpia la bandera
T1CONbits.TMR1ON = 1; //Arranca la captura
while(PIR1bits.TMR1IF == 0); //Espera hasta capturar los 700 pulsos
TMR1ON = 0; //Para la captura
//** 700 Pulsos capturados **//
Ahora si nuestra aplicación requiere contar 500000 pulsos externos, notara que este excede el máximo valor del registro contador(65535), aquí la solución seria aplicar una pre-escala que permita obtener un múltiplo exacto, por ejemplo si dividimos los 5000000 entre 8 obtenemos como resultado 62500, entonces ajustaremos el registro contador a 65536 - 62500 con pre-escala 1:8 y nuestra aplicación detectara la captura de los 500000 pulsos cuando ocurran el desbordamiento.
El ajuste del contador para una determinada cantidad de pulsos externos obedece al siguiente calculo donde la pre-escala deberá ajustarse para que el valor nunca exceda los 65536, en caso de no lograr un valor inferior la implementación solo sera posible con apoyo de variables en la programación.
Parte 3. Implementar un Temporizador.
En este modo el modulo captura pulsos internos que poseen un tiempo de duración equivalente a un ciclo de maquina o instrucción Tcy, para determinar el valor adecuado del registro contador utilizaremos la siguiente ecuación, donde n representa el tiempo que se requiere en segundos y se debe seleccionar una pre-escala adecuada donde el resultado no supere el limite de 65535.
Veamos como implementar la programación de este ejemplo en las siguientes lineas.
T1CONbits.TMR1CS = 0; //Modo temporizador
T1CONbits.T1CKPS = 0b10; //Ajuste pre-escala 1:4
TMR1H = 0x9E; //65536-2500 = 40536 o 9E58h
TMR1L = 0x58;
PIR1bits.TMR1IF = 0;; //Limpia la bandera
T1CONbits.TMR1ON = 1; //Arranca la captura
while(PIR1bits.TMR1IF == 0); //Espera los 50ms
TMR1ON = 0; //Para la captura
//** Tiempo transcurrido de 50ms **//
Parte 4. Rutinas y uso de interrupciones
A fin de facilitar la rápida implementacion del modulo TMR1 en nuestra aplicación, se crearon los siguientes procedimientos y funciones incluidas en el archivo peripheral.c.
void TMR1Setup(char cs, char pre)
{
T1CONbits.TMR1CS = cs;
T1CONbits.T1CKPS = pre;
TMR1H = 0;
TMR1L = 0;
PIR1bits.TMR1IF = 0;
}
void TMR1Setval(unsigned int value)
{
TMR1L = value;
TMR1H = value >> 8;
}
unsigned int TMR1Getval()
{
unsigned int value;
value = TMR1H;
value = value << 8;
value |= TMR1L;
return value;
}
#define T1PRE8 3 //Definición de pre-escala 1:8
#define T1PRE4 2 //Definición de pre-escala 1:4
#define T1PRE2 1 //Definición de pre-escala 1:2
#define T1PRE1 0 //Definición de pre-escala 1:1
#define TMR1Start() T1CONbits.TMR1ON = 1 //Arranca el modulo TMR1
#define TMR1Stop() T1CONbits.TMR1ON = 0 //Para el modulo TMR1
El objetivo final de implementar un temporizador es calcular con una gran precisión un lapso o periodo de tiempo transcurrido, brindando la posibilidad de utilizar retardos, pausas controladas, generar de señales, alarmas y recordatorios en nuestra aplicación.
En este modo el modulo captura pulsos internos que poseen un tiempo de duración equivalente a un ciclo de maquina o instrucción Tcy, para determinar el valor adecuado del registro contador utilizaremos la siguiente ecuación, donde n representa el tiempo que se requiere en segundos y se debe seleccionar una pre-escala adecuada donde el resultado no supere el limite de 65535.
Por ejemplo si necesitamos generar un retardo de una décima de segundo (0.1), antes de realizar el calculo se debe conocer la frecuencia del oscilador y seleccionar un valor de pre-escala adecuada, en nuestro caso si la frecuencia es 4MHz y usamos una pre-escala 1:4, aplicamos el siguiente calculo:
Veamos como implementar la programación de este ejemplo en las siguientes lineas.
T1CONbits.TMR1CS = 0; //Modo temporizador
T1CONbits.T1CKPS = 0b10; //Ajuste pre-escala 1:4
TMR1H = 0x9E; //65536-2500 = 40536 o 9E58h
TMR1L = 0x58;
PIR1bits.TMR1IF = 0;; //Limpia la bandera
T1CONbits.TMR1ON = 1; //Arranca la captura
while(PIR1bits.TMR1IF == 0); //Espera los 50ms
TMR1ON = 0; //Para la captura
//** Tiempo transcurrido de 50ms **//
Parte 4. Rutinas y uso de interrupciones
A fin de facilitar la rápida implementacion del modulo TMR1 en nuestra aplicación, se crearon los siguientes procedimientos y funciones incluidas en el archivo peripheral.c.
Para la configuración inicial del modulo utilizaremos el siguiente procedimiento, donde los parámetros cs y pre deberán ser asignados al momento de la llamada.
void TMR1Setup(char cs, char pre)
{
T1CONbits.TMR1CS = cs;
T1CONbits.T1CKPS = pre;
TMR1H = 0;
TMR1L = 0;
PIR1bits.TMR1IF = 0;
}
Por ejemplo si necesitamos configurar el modulo como contador con una pre-escala de 1:4 debemos hacer la llamada así TMR1Setup(COUNTER, T1PRE4).
El siguiente procedimiento permite ajustar el valor del registro contador TMR1H:TMR1L, como parámetro se utiliza una variable(val) de 16 bits con la que se iniciara el registro contador, en el archivo peripheral.h se implementa este procedimiento como una definición.
void TMR1Setval(unsigned int value)
{
TMR1L = value;
TMR1H = value >> 8;
}
También es posible leer en cualquier instante el registro contador TMR1H:TMR1L, utilizando la siguiente función que nos retornara un valor de 16 bits correspondiente al contador.
unsigned int TMR1Getval()
{
unsigned int value;
value = TMR1H;
value = value << 8;
value |= TMR1L;
return value;
}
Seguidamente se listan algunas definiciones empleadas en el uso de los procedimientos y funciones descritas anteriormente.
#define T1PRE8 3 //Definición de pre-escala 1:8
#define T1PRE4 2 //Definición de pre-escala 1:4
#define T1PRE2 1 //Definición de pre-escala 1:2
#define T1PRE1 0 //Definición de pre-escala 1:1
#define TMR1Start() T1CONbits.TMR1ON = 1 //Arranca el modulo TMR1
#define TMR1Stop() T1CONbits.TMR1ON = 0 //Para el modulo TMR1
Es posible hacer uso de las interrupciones como un recurso que nos permite generar y capturar pulsos en un segundo plano, es decir fuera del programa principal, para esto se crea una rutina de interrupción que se ejecutara solo cuando ocurra un desbordamiento, esta rutina debe re-configurar los valores necesarios para una nueva captura y retornar al programa principal en el menor tiempo posible.
Los bits que deben activarse para esta funcionalidad son:
- TMR1IE Habilitador de la interrupción por desbordamiento del TMR1
- PEIE Habilitador de las interrupciones generadas por los periféricos(TMR1, TMR2, etc)
- GIE Habilitador de las interrupciones en el PIC
En la rutina de interrupción se verificara la bandera correspondiente para atender al evento, en caso de repetir nuevamente las tareas asignadas, la bandera deberá limpiarse antes de salir de la rutina, para evitar que la interrupción reingrese por la misma condición.
void interrupt isr()
{
if(PIR1bits.TMR1IF == 1)
{
PIR1bits.TMR1IF = 0; //Limpia la bandera
//** Ajustar TMR1 para una nueva captura**//
}
}
Parte 5. Prueba y Simulación.
Si llegaste hasta este punto y lograste comprender el funcionamiento del modulo TMR1, ahora tomaremos un par de ejemplos que nos darán mayores luces de como aprovechar este recurso en nuestra aplicación.
Ejemplo A. Tomando como referencia el circuito del diagrama inferior, se requiere elaborar un programa que destelle el LED1 cambiando de estado cada décima de segundo(100ms), por otra parte si el pulsador BUT1 es presionado, el LED2 deberá activarse por 1 segundo.
#pragma config FOSC = INTRCIO, WDTE = OFF
#include <xc.h>
#define _XTAL_FREQ 4000000
#include "peripheral.h"
#define pinBUT1 PORTBbits.RB4 //Define el pin RB4 para el pulsador
#define pinLED1 PORTAbits.RA4 //Define el pin RA4 para el LED1
#define pinLED2 PORTAbits.RA5 //Define el pin RA5 para el LED2
char estadoLED1; //Variable temporal para el estado del LED1
void main()
{
ANSEL = 0; //Deshabilita los puertos AN0-7
ANSELH = 0;//Deshabilita los pines AN8-13
TRISA = 0; //Configura los pines del PORTA como salida
TRISBbits.TRISB4 = 1; //Configura el pin RB4 como entrada
EnablePU(); //Activa las resistencias Pull-up del PORTA&B
while(1)
{
__delay_ms(100); //Retardo para el destello del LED1
estadoLED1 = !estadoLED1; //Cambia de lógica el valor
pinLED1 = estadoLED1; //Actualiza el estado del LED1
if(pinBUT1 == 0)//Si esta presionado el pulsador BUT1
{
pinLED2 = 1; //Activa el LED2
__delay_ms(1000);//Espera un segundo
pinLED2 = 0; //Apaga el LED2
}
}
}
Si corremos este programa y no presionamos el pulsador, el LED1 cambiara de estado según lo requerido(100ms). Si en cualquier instante se presiona el pulsador BUT1 sucede lo siguiente:
- Se activara por la condición el LED2 con una espera de 1 segundo para luego apagarse.
- El LED1 no destellara mientras dure la espera del LED2.
Sucede que al encontrarse las dos tareas en el mismo flujo o hilo del programa, la ejecución de una tarea(destellar el led) afectara en tiempo a la segunda(leer el pulsador y cambiar el led).
Aunque es posible modificar la programación en el bucle para mejorar la condición de ambas tareas, una manera practica de resolver esto es utilizando un temporizador y su evento de interrupción, veamos ahora el siguiente programa que ejecuta ambas tareas en flujos independientes:
#include <xc.h>
#define _XTAL_FREQ 4000000
#include "peripheral.h"
#define pinBUT1 PORTBbits.RB4 //Define el pin RB4 para el pulsador
#define pinLED1 PORTAbits.RA4 //Define el pin RA4 para el LED1
#define pinLED2 PORTAbits.RA5 //Define el pin RA5 para el LED2
char estadoLED1; //Variable temporal para el estado del LED1
void interrupt isr() //Rutina de interrupción
{
if(PIR1bits.TMR1IF == 1) //Esta bandera se activa cada 100ms
{
TMR1Setval(40536); //Vuelva a ajustar el registro contador
PIR1bits.TMR1IF = 0; //Limpia la bandera
estadoLED1 = !estadoLED1; //Cambia de logica el valor
pinLED1 = estadoLED1; //Actualiza el estado del LED1
}
}
void main()
{
ANSEL = 0; //Deshabilita los puertos AN0-7
ANSELH = 0;//Deshabilita los pines AN8-13
TRISA = 0; //Configura los pines del PORTA como salida
TRISBbits.TRISB4 = 1; //Configura el pin RB4 como entrada
EnablePU(); //Activa las resistencias Pull-up del PORTA&B
TMR1Setup(TIMER, T1PRE4); //Configura el modulo TMR1
TMR1Setval(40536); //Ajusta el registro contador para 100ms
PIE1bits.TMR1IE = 1; //Activa la interrupción del TMR1
INTCONbits.PEIE = 1; //Activa la interrupción de periféricos
INTCONbits.GIE = 1; //Habilita las interrupciones del PIC
TMR1Start(); //Arranca el modulo TMR1
while(1)
{
if(pinBUT1 == 0)//Si esta presionado el pulsador BUT1
{
pinLED2 = 1; //Activa el LED2
__delay_ms(1000);//Espera medio segungo
pinLED2 = 0; //Apaga el LED2
}
}
}
Recordemos que para ajustar el registro contador a un determinado tiempo aplicamos la siguiente formula considerando asignar una pre-escala 1:4.
#define _XTAL_FREQ 4000000
#include "peripheral.h"
#define pinBUT1 PORTBbits.RB4 //Define el pin RB4 para el pulsador
#define pinLED1 PORTAbits.RA4 //Define el pin RA4 para el LED1
#define pinLED2 PORTAbits.RA5 //Define el pin RA5 para el LED2
char estadoLED1; //Variable temporal para el estado del LED1
void interrupt isr() //Rutina de interrupción
{
if(PIR1bits.TMR1IF == 1) //Esta bandera se activa cada 100ms
{
TMR1Setval(40536); //Vuelva a ajustar el registro contador
PIR1bits.TMR1IF = 0; //Limpia la bandera
estadoLED1 = !estadoLED1; //Cambia de logica el valor
pinLED1 = estadoLED1; //Actualiza el estado del LED1
}
}
void main()
{
ANSEL = 0; //Deshabilita los puertos AN0-7
ANSELH = 0;//Deshabilita los pines AN8-13
TRISA = 0; //Configura los pines del PORTA como salida
TRISBbits.TRISB4 = 1; //Configura el pin RB4 como entrada
EnablePU(); //Activa las resistencias Pull-up del PORTA&B
TMR1Setup(TIMER, T1PRE4); //Configura el modulo TMR1
TMR1Setval(40536); //Ajusta el registro contador para 100ms
PIE1bits.TMR1IE = 1; //Activa la interrupción del TMR1
INTCONbits.PEIE = 1; //Activa la interrupción de periféricos
INTCONbits.GIE = 1; //Habilita las interrupciones del PIC
TMR1Start(); //Arranca el modulo TMR1
while(1)
{
if(pinBUT1 == 0)//Si esta presionado el pulsador BUT1
{
pinLED2 = 1; //Activa el LED2
__delay_ms(1000);//Espera medio segungo
pinLED2 = 0; //Apaga el LED2
}
}
}
Recordemos que para ajustar el registro contador a un determinado tiempo aplicamos la siguiente formula considerando asignar una pre-escala 1:4.
Parte 6. Conclusiones y Recomendaciones.
Debe considerar que el modulo TMR1 es un recurso compartido con otro modulo CCP, esto quiere decir que si su aplicación emplea el modulo CCP el uso del TMR1 quedara restringido.
El concepto de utilizar una interrupción es detectar una condición y ejecutar una tarea en el menor tiempo posible, las funciones y procedimientos llevadas a cabo en la rutina ISR no deberían generar ciclos de espera o condiciones indefinidas, ya que esto afectaría a la totalidad del programa.
Esperando que este pequeño aporte te pueda servir de algo, agradezco una vez mas tu visita al blog.
Debe considerar que el modulo TMR1 es un recurso compartido con otro modulo CCP, esto quiere decir que si su aplicación emplea el modulo CCP el uso del TMR1 quedara restringido.
El concepto de utilizar una interrupción es detectar una condición y ejecutar una tarea en el menor tiempo posible, las funciones y procedimientos llevadas a cabo en la rutina ISR no deberían generar ciclos de espera o condiciones indefinidas, ya que esto afectaría a la totalidad del programa.
Esperando que este pequeño aporte te pueda servir de algo, agradezco una vez mas tu visita al blog.
Pablo Zarate Arancibia
Ingeniero Electrónico
pablinzte@gmail.com
No hay comentarios.:
Publicar un comentario