TIMER PIC [Timer 0 y Timer 1] Explicados PIC C Compiler

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

Contenidos mostrar

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:

$CargaT=\dfrac{Tiempo(s)*F.Oscilador}{4*Valor\ Preescaler}=valor\hspace{0.2cm}del\hspace{0.2cm}timer$

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

$CargaT=\dfrac{0.02*4000000}{4*8}=2500$

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:

$valor\hspace{0.2cm}del\hspace{0.2cm}timer=Valor\hspace{0.2cm}inicial\hspace{0.2cm}del\hspace{0.2cm}Timer0\times Valor\hspace{0.2cm}del\hspace{0.2cm}contador\hspace{0.2cm}a\hspace{0.2cm}decrementar$

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:

$CargaT=\dfrac{1*4000000}{4*RTCC\_DIV\_X}$

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.

$CargaT=\dfrac{1*4000000}{4*256}=3906.25\approx 3906$

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:

Bestseller No. 1

Soldering Iron Kit, 80W 110V Fast Heat up in 10s...

RebajasBestseller No. 2

Soldering Iron Kit, 80W 110V LCD Digital Soldering...

RebajasBestseller No. 3

Soldering Iron Kit, 60W Soldering Iron with...

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);

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

Volver al Curso de Microcontroladores PIC

Sergio A. Castaño Giraldo

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.