http://microcontroladores-mrelberni.com/timer0-pic/ DIR .
ELECTRONICA
En este caso se verá el uso del timer0 PIC como contador y temporizador,
en lo que sigue se comentará para el caso del PIC16F877A por lo que es
muy importante que se tenga a mano la hoja de datos del PIC16F877A,
para el caso de utilizar algún otro microcontrolador AVR el procedimiento
será muy similar a lo aquí comentado.
El timer0 PIC es un temporizador contador de 8 bits, el registro TMR0 es el
temporizador contador timer0 en si, es donde se guardan los valores del
timer0 PIC, cuando es utilizado como temporizador sus valores aumentaran
de uno en uno entre 0 y 255 con cada 4 ciclos de reloj, no olvidar que cada
ciclo de instrucción del microcontrolador PIC es realizado en 4 ciclos de
reloj, por ejemplo si el oscilador con el que está funcionando el
microcontrolador PIC es de 4MHz, entonces el registro TMR0 aumentará
una unidad en cada 1us, si el registro TMR0 se incrementa en 100 unidades
habrán transcurrido 100us; cuando el timer0 PIC es utilizado como
contador el registro TMR0 ya no aumenta su valor de uno en uno en cada 4
ciclos de reloj, sino que lo hará mediante el flanco de subida o el flanco de
bajada de alguna señal que llegue a un pin especial del PIC conectado al
timer0 PIC, este pin es identificado como T0CKI que en el PIC16F877A es
el pin6 o RA4, esto puede variar de acuerdo al microcontrolador
PIC utilizado, pero siempre se llamará T0CKI.
El registro TMR0 del timer0 PIC puede ser leído y escrito, puede ser
prescalado para que el tiempo en su incremento de valor en una unidad sea
mayor, el timer0 PIC cuando alcanza su valor máximo de 255 se reinicia,
volviendo a incrementar sus valores de 0 a 255, además cuando llega a su
valor máximo y se reinicia puede producir una interrupción, lo que se
decide por programa.
Timer0 AVR como contador
Para el PIC16F877A el registro TMR0 del timer0 PIC está formado por 8
bits por lo que se puede contar desde 0 hasta 255, al utilizar timer0
PIC como contador este no aumentará sus valores o su cuenta con cada
ciclo de instrucción, en este caso el timer0 estará conectado al pin
T0CKI por donde se le hará llegar una señal, la cual al cambiar de estado
hará que el timer0 PIC se incremente en una unidad, estos incrementos en
su cuenta pueden ser por cada flanco de subida o cada por flanco de bajada
de la señal, el flanco a utilizar se elige por programa, por ejemplo su se
elige el flanco de subida quiere decir que cada vez que la señal que llega al
pin T0CKI pase de un bajo a un alto o de 0 a 1, el registro TMR0
aumentará en una unidad, de esta manera se le puede utilizar como
contador, cuando la señal pase de un alto a un bajo o de 1 a 0 el registro
TMR0 no aumentará su valor o no se incrementará.
La programación del Timer0 PIC como contador se hace mediante el
bit5 o el bit T0CS del registro OPTION_REG.
El bit7 al poner este bit a 0 se activan unas resistencias pull up internas
que el microcontrolador tiene en el puerto B.
El bit6 es para cuando se utilice una interrupción externa por el pin INT,
con este bit se elige si se quiere que la interrupción sea por flanco de
subida o por flanco de bajada.
El bit5 T0CS este es el bit que en este caso interesa, al poner este bit a 1
se elige utilizar el timer0 PIC como contador, si se le pone a 0 se elige
utilizar el timer0 PIC como temporizador.
El bit4 T0SE con este bit se elige si se quiere que el timer0 PIC cuente por
flanco de subida, esto es cuando la señal que llega por el pin T0CKI pase
de 0 a 1, o que cuente por flanco de bajada , esto es cuando la señal que
llega por el pin T0CKI pase de 1 a 0, si T0SE=1 se contará por flanco de
bajada, si T0SE=0 se contará por flanco de subida.
Cada vez que la señal digital que llegue al pin T0CKI, de acuerdo a lo que
se halla elegido con el bit T0SE, el valor del contador, esto es el valor del
registro TMR0, aumentará en una unidad hasta un máximo de 255, luego
se pondrá nuevamente a 0 y otra vez comenzará a contar.
El bit3 es para la utilización del prescaler para el timer 0, el prescaler se le
puede asignar al timer0 o al WDT mediante este bit.
Los bits 2, 1 y 0 son para elegir el prescaler a utilizar, mediante las
combinaciones de estos bits se tienen diferentes valores para el prescaler,
el que a su vez dependerá de a quien se le a asignado el prescaler
mediante el bit3, tal como se ve en la imagen.
Timer0 PIC como contador ejemplo
El circuito utilizado para el ejemplo del uso del Timer0 como contador es el
que se muestra en la siguiente imagen, la señal que llega al pin T0CKI
se genera con la ayuda de un fotorresistor, cada vez que el fotorresistor
disminuya su valor al pin T0CKI le llegará un alto, lo que provocará que el
registro TMR0 aumente en una unidad por flanco de subida de la señal,
los valores que va tomando el registro TMR0 se verán en el puerto B por
medio de leds, estos valores se pueden contar en forma binaria desde el 0
hasta el 255.
La programación será hecha en el XC8 porque este permite trabajar
directamente con los registros, de esta manera se puede uno familiarizar
mas con el microcontrolador PIC
Configuración del registro OPTION_REG para el ejemplo
No se usarán resitencias interna pull up por lo que su bit7 se pone a 1, el
bit6 se puede dejar a 0 o a 1 es igual porque no se utilizar la interrupción
externa, el bit5 se pondrá a 1 porque se utilizará el timer0 PIC como
contador, el bit4 se pondrá a 0 porque el conteo será por flanco de subida,
el bit3 se pondrá a 1 para asignar el prescaler al registro WDT, para que
mediante la combinación 000 de los bits 2, 1 y 0 se elija que la señal no se
prescalará y el conteo ocurra en cada flanco de subida que suceda.
Luego el registro OPTION_REG en el XC8 quedará así:
OPTION_REG=0b10101000;//timer0 pic como contador, por flanco de
subida
El programa realizado en el MPLAB XC8 para el uso del timer0 PIC como
contador es el siguiente:
/////////////////////////////////////////////////
/////////////////////////////////////////////////
//////**microcontroladores-mrelbe
/////////** timer0 PIC como contado
/////////////////////////////////////////////////
1 /////////////////////////////////////////////////
2 /////////////////////////////////////////////////
3 //////**microcontroladores-mrelberni.com**///////
4 /////////** timer0 PIC como contador **//////////
5 /////////////////////////////////////////////////
6
7 //bits de configuración para el PIC16F877A
8 #pragma config FOSC = XT // Oscillator Selection bits (XT oscillator)
9 #pragma config WDTE = OFF // Watchdog Timer Enable bit (WDT disabled)
1 #pragma config PWRTE = ON // Power-up Timer Enable bit (PWRT enabled)
0 #pragma config BOREN = ON // Brown-out Reset Enable bit (BOR enabled)
1 #pragma config LVP = OFF // Low-Voltage (Single-Supply) In-Circuit Serial
1 Programming Enable bit
1 #pragma config CPD = OFF // Data EEPROM Memory Code Protection bit (Data
2 EEPROM code protection off)
1 #pragma config WRT = OFF // Flash Program Memory Write Enable bits (Write
3 protection off;
1 #pragma config CP = OFF // Flash Program Memory Code Protection bit (Code
4 protection off)
1
5 #define _XTAL_FREQ 4000000 //cristal utilizado de 4Mhz
1 #include "xc.h"
6
1 int main(void) {
7 TRISB=0;//Puerto B como salida para ver los valores del registro TMR0 en binario
1 PORTB=0;//El puerto B se inicia a 0
8
1 OPTION_REG=0b10101000;//timer0 pic como contador, por flanco de subida
9 TMR0=0;//El timer0 PIC se inicia a 0 para comenzar a contar
2
0 while(1){//ciclo de programa
2 PORTB=TMR0;//al puerto B se le asigna el valor del registro TMR0
1 __delay_ms(200);//Pausa para ver mejor los valores
2 }
2 return 0;
2 }
2
El siguiente es un vídeo publicado en el canal de youtube de MrElberni
donde se trata el tema de el uso del timer0 PIC como contador, en este
caso se utiliza una pantalla lcd la que es programada en el xc8 para ver los
valores que del registro TMR0 el la pantalla LCD al ser utilizado como
contador.
Timer0 PIC como temporizador.
Se verá en este caso el uso del timer0 PIC como temporizador,
normalmente el registro TMR0 del timer0 PIC irá aumentando sus valores
con cada ciclo de instrucción del microcontrolador PIC, y para estos
microcontroladores a cada ciclo de instrucción le toma 4 ciclos del oscilador
que se esté utilizando, si se usa por ejemplo un cristal de
Fosc=4Mhz entonces cada ciclo del oscilador será de 0,25us, luego cada
ciclo de instrucción tardará 4 veces este valor, es decir 4*(0,25us) lo que
viene a ser 1us, a esto se se conoce como ciclo máquina TCM=4/Fosc,
entonces el registro TMR0 aumentará en una unidad cada microsegundo
cuando el oscilador es de 4Mhz.
Como el registro TMR0 es de 8 bits este aumentará desde 0 o desde algún
valor que se le ponga como valor inicial hasta un máximo de 255, por
ejemplo si va desde 0 hasta 255 habrán transcurrido 255us luego volverá a
0 pero en esa vuelta a 0 transcurre 1us mas, por lo que en ir de 0 a 255 y
volver a 0 transcurren 256us; no siempre se utiliza una F OSC de 4Mhz esto
puede variar, por lo que como consecuencia variará el tiempo que trascurre
para que el registro TMR0 aumente su valor en una unidad.
El temporizador contador pic TMR0 cuenta con lo que se conoce como
prescaler esto hace que la frecuencia de trabajo F OSC se divida por este
prescaler, con lo que se logra que el temporizador contador pic tarde un
poco mas en aumentar su valor en una unidad; el prescaler del time0 PIC
para el PIC16F877A puede tomar el valor de 1, 2, 4, 8, 16, 32, 64, 128 o
256; estos valores se eligen mediante las combinaciones de los bits 0, 1 y 2
del registro OPTION_REG.
En la siguiente tabla se ve los valores que hay que dar a estos bits para
obtener los diferentes valores de los prescaler para el timer0 PIC.
Como se puede ver hay 2 posibilidades para asignar el prescaler al WDT o
al Timer 0, esto se realiza mediante el bit3 PSA del registro OPTION_REG.
Si el prescaler elegido es por ejemplo de 64 y la FOSC=4Mhz, entonces la
frecuencia de trabajo del temporizador Ftemp será de
Ftemp=FOSC/(4*prescaler), el tiempo que tardará ahora el
temporizador en aumentar una unidad será la inversa de este valor, a lo
que se le conoce como periodo del
temporizador Ttemp=(4*prescaler)/(FOSC), por lo que en este caso
Ttemp=(4*64)/(4Mhz) de donde Ttemp=64us, esto quiere decir que ahora
el temporizador aumentará en una unidad cada 64us y en este caso
entonces el registro TMR0 para ir de 0 a 255 tardará
255*Ttemp=255*64us=16320us=16,32ms, la misma idea es para los
demás prescaler.
Al utilizar los prescaler se tiene la ventaja de temporizar tiempos mas
largos, pero muchas veces se vuelven demasiado largos si el
registro TMR0 se inicia a 0, por lo que para temporizar tiempos que se
quieren por ejemplo para temporizar 50ms con el uso del timer0 PIC se
tendría que utilizar un prescaler adecuado e iniciar el registro TMR0 a un
valor también adecuado.
Utilizando una regla de 3 simple se llega a la siguiente ecuación que
ayudará a encontrar el valor inicial adecuado a cargar en el
registro TMR0 para obtener el tiempo buscado.
TMR0=28-Tretardo*(Fosc/(4*prescaler))-1
Donde TMR0 es el valor inicial a cargar en este registro para obtener la
temporización buscada, 28 porque el timer0 PIC es de 8 bits, Tretardo es el
tiempo que se quiere temporizar con el timer0 PIC, Fosc es la frecuencia
oscilador o del cristal utilizado, y prescaler será el prescaler elegido según
la tabla anterior.
Por ejemplo si se quiere temporizar 50ms, en este caso 50ms sería el
tiempo de retardo, y si el microcontrolador PIC trabaja con oscilador de
4Mhz, habrá que elegir entre los posibles prescaler que se tienen,
reemplazar en la ecuación anterior y ver si el número obtenido esta entre 0
y 255, de ser así la elección del prescaler es correcta, de lo contrario habrá
que utilizar otro, por ejemplo si se elige un prescaler de 256 se tendría:
TMR0=256-(50ms)(1Mhz)/256-1
TMR0=59,6875
El valor obtenido está entre 0 y 255 aunque no es un número entero, por lo
que hay que redondearlo a un entero cercano en este caso 60, al hacer
esto la temporización no será exactamente 50ms pero si un valor bastante
próximo y aceptable.
60 sería el valor inicial a cargar en el registro TMR0 para obtener una
temporización de 50ms con el timer0 PIC, esto quiere decir que si se inicia
el timer0 PIC con 60 y un prescaler de 256, cuando aumente su valor de 60
a 255 habrán transcurrido 50ms.
Los resultados obtenidos serán usados en el ejemplo de la utilización del
timer0 pic como temporizador.
Este proceso será el que se seguirá cuando se utilice el timer0 PIC como
temporizador.
La programación del Timer0 PIC ccomo temporizador se hace
mediante el bit5 o el bit T0CS del registro OPTION_REG.
El bit7 al poner este bit a 0 se activan unas resistencias pull up internas
que el microcontrolador tiene en el puerto B.
El bit6 es para cuando se utilice una interrupción externa por el pin INT,
con este bit se elige si se quiere que la interrupción sea por flanco de
subida o por flanco de bajada.
El bit5 T0CS este es el bit que en este caso interesa, al poner este bit a
0 se elige utilizar el timer0 PIC como temporizador, si se le pone a 1 se
elige utilizar el timer0 PIC como contador.
El bit4 T0SE este bit es útil cuando se usa el timer0 PIC como contador
con este bit se elige si el timer0 PIC contará por flanco de subida, esto es
cuando la señal que llega por el pin T0CKI pase de 0 a 1, o que cuente por
flanco de bajada , esto es cuando la señal que llega por el pin T0CKI pase
de 1 a 0, si T0SE=1 se contará por flanco de bajada, si T0SE=0 se contará
por flanco de subida.
En el modo temporizador este bit no se toma en cuenta, es igual si se pone
a 0 o a 1.
El bit3 es para la utilización del prescaler para el timer 0, el prescaler se le
puede asignar al timer0 o al WDT mediante este bit.
Los bits 2, 1 y 0 son para elegir el prescaler a utilizar, mediante las
combinaciones de estos bits se tienen diferentes valores para el prescaler,
el que a su vez dependerá de a quien se le a asignado el prescaler
mediante el bit3, tal como se ve en la imagen.
Timer0 PIC como temporizador ejemplo
El circuito de ejemplo utilizado para ver el uso del timer0 PIC como
temporizador es el siguiente, se hará cambiar el estado del pin RB7 cada
50ms, se utilizarán los resultados obtenidos cuando se comento sobre el
prescaler del timer0 PIC, se obtuvo que para temporizar 50ms se utiliza el
prescaler de 256 y el registro TMR0 se tiene que cargar en un inicio con 60,
esto es TMR0=60.
La programación será hecha en el XC8 porque este permite trabajar
directamente con los registros, de esta manera se puede uno familiarizar
mas con el microcontrolador PIC
Configuración del registro OPTION_REG para el ejemplo
No se usarán resitencias interna pull up por lo que su bit7 se pone a 1, el
bit6 se puede dejar a 0 o a 1 es igual porque no se utilizar la interrupción
externa, el bit5 se pondrá a 0 porque se utilizará el timer0 PIC como
temporizador, el bit4 se pondrá a 0, el bit3 se pondrá a 0 para asignar el
prescaler al registro TMR0, para que mediante la combinación 111 de los
bits 2, 1 y 0 se elija el prescaler de 256.
Luego el registro OPTION_REG en el XC8 quedará así:
OPTION_REG=0b10000111;//timer0 pic como temporizador, prescaler 256
El programa realizado en el MPLABX XC8 para el uso del timer0 PIC como
temporizador es el siguiente:
/////////////////////////////////////////////////
/////////////////////////////////////////////////
//////**microcontroladores-mrelbe
/////////** timer0 PIC como contado
/////////////////////////////////////////////////
1 /////////////////////////////////////////////////
2 /////////////////////////////////////////////////
3 //////**microcontroladores-mrelberni.com**///////
4 /////////** timer0 PIC como contador **//////////
5 /////////////////////////////////////////////////
6
7 //bits de configuración para el PIC16F877A
8 #pragma config FOSC = XT // Oscillator Selection bits (XT oscillator)
9 #pragma config WDTE = OFF // Watchdog Timer Enable bit (WDT disabled)
1 #pragma config PWRTE = ON // Power-up Timer Enable bit (PWRT enabled)
0 #pragma config BOREN = ON // Brown-out Reset Enable bit (BOR enabled)
1 #pragma config LVP = OFF // Low-Voltage (Single-Supply) In-Circuit Serial
1 Programming Enable bit (RB3 is digital I/O, HV on MCLR must be used for programming)
1 #pragma config CPD = OFF // Data EEPROM Memory Code Protection bit (Data
2 EEPROM code protection off)
1 #pragma config WRT = OFF // Flash Program Memory Write Enable bits (Write
3 protection off; all program memory may be written to by EECON control)
1 #pragma config CP = OFF // Flash Program Memory Code Protection bit (Code
4 protection off)
1
5 #define _XTAL_FREQ 4000000 //cristal utilizado de 4Mhz
1 #include "xc.h"
6
1 int main(void) {
7 TRISBbits.TRISB7=0;//Pin RB7 como salida digital, aquí se colocará el led
1 PORTBbits.RB7=0;//El led se inicia apagado
8
1 OPTION_REG=0b10000111;//timer0 pic como temporizador, prescaler 256
9 TMR0=60;//El timer0 PIC se inicia a 60 para temporizar 50ms
2 //cuando llegue a 255
0 while(1){//ciclo de programa
2 if(TMR0==255){//cuando transcurran 50ms
1 PORTB^=(1<<7);//cambia el estado del pin RB7
2 TMR0=60;//carga con 60 el timer0 pic para que cada vez que llegue
2 } //a 255 transcurran 50ms
2 }
3 return 0;
2 }
4
El uso del timer0 PIC como temporizador es mucho mas eficaz si se utiliza
mediante las interrupciones, este tema se ve en la sección de
interrupciones con el PIC.
Si he logrado ayudarte en cuanto al uso del timer0 PIC como contador y
temporizador comparte este enlace para poder ayudar a muchas personas
mas. Muchas Gracias.
Atte: MrElberni
