Timer PIC Los temporizadores o Timers son una de las características más 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 versátiles y precisos, dado que con el macro de delay_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 PIC18F4550 tiene 4 temporizadores: 1. Timer 0 (8 bits) 2. Timer 1(16 bits) 3. Timer 2(8 bits) 4. Timer 3(16 bits) o configurable como contador

1. Timer PIC
Los temporizadores o Timers son una de las características más 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
versátiles y precisos, dado que con el macro de delay_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 PIC18F4550 tiene 4 temporizadores:
1. Timer 0 (8 bits)
2. Timer 1(16 bits)
3. Timer 2(8 bits)
4. Timer 3(16 bits) o configurable como contador
En este laboratorio vamos a tratar de entender cómo 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.
¿Qué 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).

2. 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 PIC18F4550 puede
utilizar cuatro tipos de oscilador diferentes. Estos tipos son:
• RC. Oscilador con resistencia y condensador.
• XT. Cristal. (interno o externo)
• 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.
Para entender el funcionamiento del Timer 0, como ejemplo se supone que se
necesita generar una interrupción cada 20 ms. (20.000 microsegundos).
¿Cuándo 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:
𝐶𝑎𝑟𝑔𝑎𝑇 =
𝑇𝑖𝑒𝑚𝑝𝑜(𝑠) ∗ 𝐹. 𝑂𝑠𝑐𝑖𝑙𝑎𝑑𝑜𝑟
4 ∗ 𝑉𝑎𝑙𝑜𝑟 𝑃𝑟𝑒𝑒𝑠𝑐𝑎𝑙𝑒𝑟
= 𝑣𝑎𝑙𝑜𝑟 𝑑𝑒𝑙 𝑇𝑖𝑚𝑒𝑟
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 habíamos dicho que el valor del Timer 0 puede ser dividido (preescaler) por un valor
aplicando alguna de las instrucciones citadas al comienzo.

3. 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
𝐶𝑎𝑟𝑔𝑎𝑇 =
0,02 ∗ 4 000 000
4 ∗ 8
= 2 500
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:
𝑣𝑎𝑙𝑜𝑟 𝑑𝑒𝑙 𝑡𝑖𝑚𝑒𝑟 = 𝑉𝑎𝑙𝑜𝑟 𝑖𝑛𝑖𝑐𝑖𝑎𝑙 𝑑𝑒𝑙 𝑇𝑖𝑚𝑒𝑟0 𝑥 𝑉𝑎𝑙𝑜𝑟 𝑑𝑒𝑙 𝑐𝑜𝑛𝑡𝑎𝑑𝑜𝑟 𝑎 𝑑𝑒𝑐𝑟𝑒𝑚𝑒𝑛𝑡𝑎𝑟
Vemos que tenemos dos incógnitas, esas dos incógnitas pueden ser valores aleatorios
inferiores a 256. Por ejemplo: 10 y 250. aquí puedo escoger cualquiera de los dos
valores para que sea el Valor Inicial del Timer (10)
Posterior a esta multiplicación, se hace:
256 – 𝑉𝑎𝑙𝑜𝑟 𝑖𝑛𝑖𝑐𝑖𝑎𝑙 𝑑𝑒𝑙 𝑡𝑖𝑚𝑒𝑟 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:
𝐶𝑎𝑟𝑔𝑎𝑇 =
1 ∗ 4 000 000
4 ∗ 𝑅𝑇𝐶𝐶_𝐷𝐼𝑉_𝑋

4. 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.
𝐶𝑎𝑟𝑔𝑎𝑇 =
1 ∗ 4 000 000
4 ∗ 256
= 3906,025 ≈ 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 deberá declararse entonces en el código como int16.
3906 = 18 * 217
Cualquiera de estos dos valores puede 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í tendremos 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 (1 000 000 microsegundos).
Instrucciones en CCS C
Ahora que conocemos la teoría, es hora de ver cuáles 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.

5. 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. Donde 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)

6. 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
Además de configurar el TIMER0 como temporizador, es posible hacer que este trabajo
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.
Ejemplo 1
Circuito de reloj con T = 2s
#include <18F4550.h> //Incluimos la librería 18F4550
#device ADC=10
#fuses HS, NOWDT,NOPROTECT, NOPUT, NOLVP //Configuración de fusibles.
#use delay(crystal=8MHz) //Frecuencia de oscilador 8MHz.
#use fast_io(b) //Define el Puerto B para respuesta.
#int_Timer0 //Habilitamos interrupción Timer 0
void DesbordeTimer0() //Función interrupción por desbordamiento T0.
{
output_bit(PIN_B0,!input(PIN_B0)); //Invierte calor en RB0
set_timer0(57724); //Cargamos TRM0=577724 para llegar a 1s.
}
void main (void) //Función Principal.
{
setup_adc_ports(NO_ANALOGS,VSS_VDD); //No se utilizan entradas analógicas
set_tris_b(0x00); //Configuramos el Puerto B como salida.
output_b(0x00); //Ponemos los bits de los pines del puerto B a cero.
setup_timer_0(rtcc_div_256|rtcc_internal); //Preescaler a 256, Timer0 interno, 16 bits automáti.
set_timer0(57724); //Fijamos TMR0l = 4, para obtener el tiempo de 32,256ms.

7. enable_interrupts(int_timer0); //Habilitamos la interrupcion TMR0
enable_interrupts(GLOBAL); //Habilitamos todas las interrupciones.
while(true)
{
}
}
TIMER PIC – EJEMPLO
Realizar un temporizador de 0 a 60 segundos empleando el TIMER del PIC

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

9. //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 interrupción del
timer
// Configuración Recomendada del TIMER0

10. SETUP_TIMER_0(RTCC_INTERNAL|RTCC_DIV_256|RTCC_8_bit);
ENABLE_INTERRUPTS(INT_RTCC); //Activa interrupción 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
da 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:
𝐶𝑎𝑟𝑡𝑎𝑇1 =
𝑇𝑖𝑒𝑚𝑝𝑜(𝑠) · 𝐹𝑜𝑠𝑐
4 · 𝑃𝑟𝑒𝑒𝑠𝑐𝑎𝑙𝑒𝑟
= 𝑉𝑎𝑙𝑜𝑟 𝑇𝑖𝑚𝑒𝑟1
El valor timer1 debe ser igual a la multiplicación entre el valor inicial del timer 1 y el
valor del contador a decrementar.
𝑉𝑎𝑙𝑜𝑟 𝑇𝑖𝑚𝑒𝑟1 = 𝑉𝑎𝑙𝑜𝑟 𝑖𝑛𝑖𝑐𝑖𝑎𝑙 𝑇𝑖𝑚𝑒𝑟 1 · 𝑉𝑎𝑙𝑜𝑟 𝑑𝑒𝑙 𝐶𝑜𝑛𝑡𝑎𝑑𝑜𝑟

11. 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 puede 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:
𝑣𝑎𝑙𝑢𝑒 = 𝑇𝑀𝑅1 − 𝑉𝑎𝑙𝑜𝑟 𝑖𝑛𝑖𝑐𝑖𝑎𝑙 𝑇𝑖𝑚𝑒𝑟1
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

12. {
//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 20 MHz. En este caso usamos un
preescaler de 8.
𝐶𝑎𝑟𝑡𝑎𝑇1 =
8 · 20 000 000
4 · 8
= 5 000 000
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:
50 000 000 = 50 000 ⋅ 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.
𝑇𝑖𝑚𝑒𝑟1 = 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 **** //

13. // ********************************* //
#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){
}
}