En esta entrada entenderemos como funciona el Timer del microcontrolador PIC, donde veremos que realmente existen diferentes timers o temporizadores dentro de nuestro sistema embebido.
Antes de comenzar la clase, te invito para que veas el
👉👉👉 CURSO GRATIS DE MICROCONTROLADORES PIC
Y te invito a VER LA LISTA DE REPRODUCCIÓN DE YOUTUBE
Antes de Comenzar suscríbete al canal para aprender todo sobre PIC con el compilador CCS C
Timer PIC
Los temporizadores o Timers son una de las características mas importantes para un programador de sistemas embebidos. Cada aplicación que diseñamos involucrará de alguna manera una aplicación de tiempo, como encender o apagar algún dispositivo después de un intervalo de tiempo específico.
A diferencia de simplemente usar el delay_ms() del CCS C, los timers son mucho más versatiles y precisos, dado que con el macro de dalay_ms() lo que hacemos es detener la ejecución del PIC, sin embargo con el timer, podemos continuar nuestra ejecución y realizar el conteo o temporización en segundo plano.
El microcontrolador PIC16F887 tiene 3 temporizadores:
- Timer 0 (8 bits)
- Timer 1(16 bits)
- Timer 2(8 bits)
En esta entrada vamos a tratar de entender como podemos configurarlos usando el compilador CCS C PIC C.
Timer 0
A pesar del Timer 0 ser de 8 bits, este es el temporizador principal.
El Timer0 pic también llamado RTCC se puede cargar con un valor cualquiera entre 0 y 255 y puede ser incrementado a través del Reloj interno y dividido por un valor que se puede escoger entre los que se indican a continuación. Esto se conoce como el valor del preescalador (Valor de Preescaler):
RTCC_DIV_2, RTCC_DIV_4, RTCC_DIV_8, RTCC_DIV_16, RTCC_DIV_32, RTCC_DIV_64, RTCC_DIV_128, RTCC_DIV_256.
pero….¿Que es un preescalador?
Un preescalador o preescaler como lo pudimos observar en los valores anteriores predefinidos en el PIC C Compiler, es simplemente la velocidad del microcontrolador dividido por algún número de potencia 2 (2, 4, 8, 16, 32, 64, 128, 256)
Desborde del TIMER 0 en PIC
La interrupción RTCC o timer PIC se produce cada vez que el contador TIMER0 pasa de 255 para 0.
Ya hemos trabajado anteriormente nuestros proyectos con cristales de cuarzo. Recordemos lo siguiente:
Todo microcontrolador requiere un circuito externo que le indique la velocidad a la que debe trabajar. Este circuito, que se conoce como oscilador o reloj, es muy simple pero de vital importancia para el buen funcionamiento del sistema. El PIC16F887 puede utilizar cuatro tipos de oscilador diferentes. Estos tipos son:
- RC. Oscilador con resistencia y condensador.
- XT. Cristal.
- HS. Cristal de alta velocidad.
- LP. Cristal para baja frecuencia y bajo consumo de potencia.
Si se trabaja el Microcontrolador con un cristal de 4 Mhz, esta frecuencia se divide internamente por 4, es decir realmente trabaja a 1Mhz, o sea que cada ciclo de reloj dura aproximadamente 1 microsegundo.
Si te interesa entender como funcionan los tiempos dentro de un microcontrolador PIC, tenemos una entrada que explica sobre los tipos de reloj (clock) del microcontrolador PIC.
Para entender el funcionamiento del Timer 0, como ejemplo se supone que se necesita generar una interrupción cada 20 ms. (20.000 microsegundos).
¿Cuando se trabaja con el TIMER del PIC, qué fórmula usar para determinar con que valor se debe cargar inicialmente el Timer 0 y que valor de preescaler o división se debe utilizar?
La fórmula para aplicar es la siguiente recordando que primero debemos pasar el tiempo de temporización a segundos es:
Sin embargo, se debe tener en cuenta que la interrupción solo se genera cuando el timer pasa de 255 a 0, esto quiere decir que debemos restarle al valor total del timer (256) el valor de carga inicial que tenga el Timer 0:
256 – Valor inicial del Timer 0
Ya habiamos dicho que el valor del Timer 0 puede ser dividido (preescaler) por un valor aplicando alguna de las instrucciones citadas al comienzo del post.
Cuando nosotros seleccionemos dicho preescaler o división, debemos tratar de obtener un valor entero al dividir el tiempo del retardo sobre el preescaler.
Este valor no puede ser mayor a 256. En caso de ser mayor, significa que antes de cumplir el retardo el Microcontrolador habrá generado más de una interrupción.
En este caso se combina entonces la programación del Timer 0 PIC y cada vez que el Timer0 PIC genere una interrupción se decrementa un contador tantas veces como sea necesario hasta completar el tiempo de temporización.
Finalmente el procedimiento que se debe seguir para calcular el valor inicial del timer y el valor del contador a decrementar es el siguiente, suponiendo que escogemos un preescaler de 8
RTCC_DIV_8
Vemos entonces que se generó un valor mayor a 255, por lo tanto es necesario calcular cuantas veces debe generarse una interrupción (a través de un contador) antes de completar el retardo de 20 milisegundos.
El resultado de la división anterior debe ser igual a:
2500=valor inicial del timer * valor del contador a decrementar
Vemos que tenemos dos incoginitas, esas dos incognitas pueden ser valores aleatorios inferiores a 256. Por ejemplo: 10 y 250. Aqui puedo escoger cualquiera de los dos valores para que sea el Valor Inicial del Timer (10)
Posterior a esta multiplicación, se hace:
256 – Valor inicial del timer 0
256-10=246
Con esto tengo que mi timer del PIC o RTCC es 246 y que mi contador debe contar hasta 250.
Ejemplo Timer de 1 segundo.
Para generar un retardo de un segundo usando el timer del PIC, con preescaler de 256, se procede de la siguiente manera:
X = Este valor puede ser cualquiera de los indicados al principio, el que se elija será con el que se seguirá trabajando en la programación. En este caso el RTCC escogido es 256.
El valor anterior, es decir 3906 debe ser igual a la multiplicación entre el valor inicial del timer 0 y el valor del contador a decrementar.
3906= valor inicial del timer * valor del contador a decrementar
Observación: estos dos valores son aleatorios y la única condición que se debe cumplir es que uno de estos dos números (valor inicial) debe ser siempre menor a 256, el contador puede ser mayor, pero debera declararse entonces en el código como int16.
3906 = 18 * 217
Cualquiera de estos dos valores pueden ser el valor inicial del timer 0. En este caso, se elige 18 como valor inicial del timer 0. Al obtener el valor inicial del timer 0 se debe restar el RTCC utilizado, en este caso 256 para obtener el número donde el temporizador debe iniciar para que en el momento que incremente las 18 veces llegue al valor del RTCC utilizando (256) y produzca la interrupción ó salto. Es decir:
RTCC – Valor inicial del timer
256 – 18 = 238
Ya con estos valores, tenemos el valor que debemos cargar en el Timer y el valor que debemos cargar en el contador. Quedaría de la siguiente manera:
RTCC=238
Contador=217
Así tendriamos el temporizador para 1 segundo usando el timer del pic, porque el RTCC se carga con 238, cada ciclo de reloj, va incrementando y cuando llega a 256 (Pasados 18 ciclos de reloj), decrementa el contador en 1 unidad, y vuelve y carga el RTCC con 238. Así nuevamente el RTCC va incrementando y cuando llega a 256 vuelve y decrementa en 1 unidad el contador. Cuando el contador por fin llegue a Cero (0), quiere decir que ya paso 1 segundo (1000000 micro segundos).
Instrucciones en CCS C
Ahora que conocemos la teoría, es hora de ver cuales son las instrucciones que el compilador de CCS C nos proporciona para poder manipular el Timer en PIC.
Para inicializar el contador del TIMER0 usamos la siguiente instrucción donde la variable value puede ser de 8 o 16 bits, dependiendo del dispositivo que se esté trabajando.
set_rtcc(value);
Para configurar el TIMER0 en modo temporizador tal y como lo hemos visto a lo largo de este post utilizamos la siguiente Función:
setup_timer_0(RTCC_INTERNAL | RTCC_DIV_N | RTCC_M_bits);
RTCC_INTERNAL, indica que estamos usando el timer0 en modo temporizador.
RTCC_DIV_N configura el preescaler en función de N. Donde N puede tomar uno de los siguientes valores: 1,2,4,8,16,32,64,128,256.
RTCC_M_bits indica el número de bits del temporizador en función de M. Dondem M puede tomar uno de los siguientes valores: 8, 16.
Finalmente, se debe activar la interrupción por desbordamiento del Timer0:
enable_interrupts(INT_RTCC);
enable_interrupts(GLOBAL);
Y colocar el macro de la interrupción por timer, que corresponde a la función que realizará el PIC una vez el desbordamiento se cumpla. En esta función es donde deberemos decrementar el contador para alcanzar el valor deseado:
#INT_RTCC //TIMER0 void timer0(void){ contador--; //Se decrementa hasta llegar a cero set_rtcc(value); //Timer0 if (contador<=0) // Si llega a cero, se cumplió tiempo { //Su Codigo aqui...... contador=valor_contador; // Inicializa el contador para el próximo periodo } }
Nota 1:
Existe un comando paralelo para configurar el TIMER0 como temporizador o como contador que hace exactamente lo mismo que setup_timer_0:
setup_counters (rtcc_state, RTCC_DIV_N)
rtcc_state: puede ser una de las constantes definidas en el archivo .h de dispositivos.
RTCC_INTERNAL
RTCC_EXT_L_TO_H
RTCC_EXT_H_TO_L
Sin embargo esta última función se proporciona para compatibilidad con versiones anteriores. setup_timer_0 y setup_WDT son los reemplazos recomendados cuando sea posible. Para dispositivos PCB si se usa un reloj RTCC externo y se usa un preescalador WDT, entonces esta función debe usarse.
Nota 2 – Timer0 como Contador
Ademas de configurar el TIMER0 como temporizador, es posible hacer que este trabaje como contador de eventos.
Para configurar el TIMER0 en modo contador se utiliza una de las funciones siguientes:
setup_timer_0(RTCC_EXT_L_TO_H | RTCC_DIV_N );
O bien:
setup_timer_0(RTCC_EXT_H_TO_L | RTCC_DIV_N );
RTCC_EXT_L_TO_H, configura el modo contador y hace que el registro TIMER0 se incremente con cada flanco ascendente en RA4.
RTCC_EXT_L_TO_H, configura el modo contador y hace que el registro TIMER0 se incremente con cada flanco descendente en RA4.
KIT para PIC BARATOS
A continuación te dejo algunas placas de desarrollo BARATAS para que puedas aprender más facilmente sobre los microcontroladores PIC y los puedas adquirir desde cualquier parte del MUNDO, a través del sitio web chino de Aliexpress.
Es importante destacar que para la construcción de nuestros proyectos electrónicos con microcontroladores podemos comprarlos también desde la comodidad de nuestra casa en Amazon que tiene envios para cualquier lugar de latinoamerica y para europa:
TIMER PIC – EJEMPLO
Realizar un temporizador de 0 a 60 segundos empleando el TIMER del PIC
#INCLUDE<16f887.h> #USE DELAY(CRYSTAL=4000000) #fuses XT,NOPROTECT,NOWDT,NOBROWNOUT,PUT,NOLVP Byte CONST display[10]= {0x3f,0x06,0x5b,0x4f,0x66,0x6d,0x7d,0x07,0x7f,0x67}; #DEFINE U PORTC,0 #DEFINE D PORTC,1 #byte PORTB= 6 #byte PORTC= 7 INT VECES,SEG; // Función para mostrar los segundos en el Display VOID MOSTRAR( ) //Rutina mostrar { INT UNI,DEC; //Declarar las variables UNI, DEC //como un entero, es decir de 8bits DEC=SEG/10; UNI=SEG%10; PORTB=(DISPLAY[UNI]); //Muestra lo que hay en unidades //en el display BIT_SET (U); //Enciende el display de unidades DELAY_MS(1); //Retardo de 1 milisegundos BIT_CLEAR(U); //Apaga el display de unidades PORTB=(DISPLAY[DEC]); //Muestra lo que hay en unidades //en el display BIT_SET (D); //Enciende el display de decenas DELAY_MS(1); //Retardo de 1 milisegundos BIT_CLEAR(D); //Apaga el display de decenas } //Rutina de interrupción por RTCC (TIMER) #INT_RTCC RELOJ() { VECES--; //Se decrementa la variable VECES SET_RTCC(238); //Se carga el timer con 238 IF(VECES==0) //Pregunta si VECES ya llego a cero { SEG++; //Cuando VECES llega a cero incrementa SEG (Transcurrio 1 seg) VECES=217; //Vuelvo y cargo VECES con el valor 217 } } //Programa Principal VOID MAIN() { SET_TRIS_B(0); //Configura PUERTO B como salida SET_TRIS_C(0); //Configura PUERTO C como salida VECES=217; //Carga VECES con 217 para efectuar la cuenta de 1 seg con el timer SEG=0; //Inicializa los segundos en cero SET_RTCC(238); //Cargo valor inicial del timer // Configuración ANTIGUA del TIMER0 //SETUP_COUNTERS(RTCC_INTERNAL, RTCC_DIV_256); //Configura interrupcion del timer // Configuración Recomendada del TIMER0 SETUP_TIMER_0(RTCC_INTERNAL|RTCC_DIV_256|RTCC_8_bit); ENABLE_INTERRUPTS(INT_RTCC); //Activa interrupcion del timer ENABLE_INTERRUPTS(GLOBAL); //Activa TODAS las interrupciones WHILE(TRUE) //Haga por siempre { IF(SEG==60) //Pregunta si ya se llego a 60 segundos SEG=0; //Si si, vuelva a SEG a cero ELSE //Si no, MOSTRAR(); //Muestre el valor de SEG en los Display 7 Segmentos } }
Timer 1
Como ya vimos el Timer 1 es un temporizador de 16 bits, y su funcionamiento es similar al que detallamos en el Timer 0, por eso será fundamental que hayas leído y entendido dicho temporizador.
En este timer 1 a diferencia del timer 0, es que al poseer 16 bits su desbordamiento se dan cuando el valor del timer pasa del valor 65536 a 0.
Los valores de Preescaler para el timer 1 también cambian, en este caso solo podemos dividir por 1, 2, 4 y 8, y en CCS C se definen como:
T1_DIV_BY_1 T1_DIV_BY_2 T1_DIV_BY_4 T1_DIV_BY_8
Aplicando el mismo procedimiento visto para el Timer 0, procedemos a encontrar la carga del Timer 1:
\rm CargaT_1=\dfrac{Tiempo(s)\cdot F_{osc}}{4\cdot Preescaler}= Valor\ Timer1
El valor timer1 debe ser igual a la multiplicación entre el valor inicial del timer 1 y el valor del contador a decrementar.
\rm Valor\ Timer1 = Valor\ inicial\ Timer1 \cdot Valor\ del\ Contador
Donde Valor Inicial Timer1 y Valor del Contador son dos valores enteros aleatorios que no pueden ser superiores a 65536.
Cualquiera de estos dos valores pueden ser el valor inicial del timer 1. Al obtener el valor inicial del timer 1 se debe restar el TMR1 utilizado, en este caso 65536 para obtener el número donde el temporizador debe iniciar para que en el momento que incremente las veces establecidas en la variable Valor del Contador llegue al valor del TMR1 utilizando (65536) y produzca la interrupción o salto. Es decir:
\rm value=TMR1- Valor\ inicial\ Timer1
Ya con estos valores, tenemos el valor que debemos cargar en el Timer y el valor que debemos cargar en el contador.
Instrucciones en CCS C
Para inicializar el contador del TIMER1 usamos la siguiente instrucción donde la variable value puede ser de 8 o 16 bits, dependiendo del dispositivo que se esté trabajando.
set_timer_1(value);
Para configurar el TIMER1 en modo temporizador utilizamos la siguiente Función:
setup_timer_1(mode);
Donde mode puede ser configurado como:
T1_DISABLED, T1_INTERNAL, T1_EXTERNAL, T1_EXTERNAL_SYNC T1_CLK_OUT T1_DIV_BY_1, T1_DIV_BY_2, T1_DIV_BY_4, T1_DIV_BY_8
Finalmente, se debe activar la interrupción por desbordamiento del Timer1:
enable_interrupts(INT_TIMER1);
enable_interrupts(GLOBAL);
Y colocar el macro de la interrupción por timer, que corresponde a la función que realizará el PIC una vez el desbordamiento se cumpla. En esta función es donde deberemos decrementar el contador para alcanzar el valor deseado:
#int_timer1 //TIMER1 void timer1(void){ contador--; //Se decrementa hasta llegar a cero set_timer1(value); //Carga de nuevo el timer1 if (contador<=0) // Si llega a cero, se cumplió el tiempo { //Codigo aqui...... contador=valor_contador; // Inicializa el contador para el próximo periodo } }
Temporizador de 8 seg (Timer 1)
Vamos a crear un temporizador de 8 segundo usando el timer 1 y el PIC C Compiler, usando en este caso un reloj de Cristal de Cuarzo de 20MHz. En este caso usamos un preescaler de 8.
\rm CargaT_1=\dfrac{8\cdot 20.000.000}{4\cdot 8}= 5000000
Vemos entonces que se generó un valor mayor a 65536, por lo tanto es necesario calcular cuantas veces debe generarse una interrupción (a través de un contador) antes de completar el retardo de 8 segundos.
Por lo tanto el valor inicial del timer puede ser 50.000 y el valor del contador puede ser 100 para alcanzar la carga del timer1:
\rm 50.000.000 = 50.000 \cdot 100
Por último realizamos la resta del valor inicial del timer con el valor máximo del timer1 para saber con cuanto inicializamos nuestro temporizador.
\rm Timer1 = 65.536-50.000 = 15536
#include <18f4550.h> #DEVICE ADC=10 #USE DELAY(crystal=20000000) #FUSES HS,NOPROTECT,NOWDT,NOBROWNOUT,PUT,NOLVP #byte porta = 0xf80 // Identificador para el puerto A. #byte portb = 0xf81 // Identificador para el puerto B. #byte portc = 0xf82 // Identificador para el puerto C. #byte portd = 0xf83 // Identificador para el puerto D. #byte porte = 0xf84 // Identificador para el puerto E. int16 Ts_cont=0; // ********************************* // // ******* Interrupción Timer 1 **** // // ********************************* // #int_timer1 //TIMER1 void sampling_time(void){ Ts_cont--; //Se decrementa hasta llegar a cero set_timer1(15536);//Carga de nuevo el timer1 if (Ts_cont<=0) // Si llega a cero, se cumplió el periodo de muestreo { output_toggle(pin_d0); Ts_cont=100; // Inicializa el contador para el próximo periodo } } // ********************************* // // ****** Programa Principal ******* // // ********************************* // void main() { set_tris_d(0b0); //Configura el pin D0 como salida (LED) // Configura el Timer 1 setup_timer_1 ( T1_INTERNAL | T1_DIV_BY_8 ); Ts_cont=100; //Carga Contrador para Calcular el Periodo de Muestreo set_timer1(15536); // Inicializa el Timer 1 para calcular 8 Segundos de Ts // Habilitar las interrupciones del PIC enable_interrupts(int_timer1); enable_interrupts(GLOBAL); while(1){ } }
No olvides compartir el contenido en Redes sociales, para que me ayudes a hacer crecer el sitio, y que la información pueda llegarle a mas personas que lo necesiten y quieran aprender sobre este interesante mundo de los microcontroladores. Hasta la próxima.
Eso es todo por la entrada del dia de hoy, espero les haya gustado y hayan aprendido algo nuevo. Si te ha servido el contenido de esta entrada, de los videos y los códigos de implementación y deseas apoyar mi trabajo invitandome a un café super barato, puedes hacerlo en el siguiente link:
👉 Invitar a Sergio a un Café ☕️
Que esten muy bien, nos vemos en la siguiente entrada.
Mi nombre es Sergio Andres Castaño Giraldo, y en este sitio web voy a compartir una de las cosas que mas me gusta en la vida y es sobre la Ingeniería de Control y Automatización. El sitio web estará en constante crecimiento, voy a ir publicando material sobre el asunto desde temas básicos hasta temas un poco más complejos. Suscríbete al sitio web, dale me gusta a la página en Facebook y únete al canal de youtube. Espero de corazón que la información que comparto en este sitio, te pueda ser de utilidad. Y nuevamente te doy las gracias y la bienvenida a control automático educación.