PIC 18F45XX - ies luis de lucena

PIC 18F45XX
EL TIMER 0
1. Hardware asociado
2. Características
• Se puede configurar como temporizador o contador de 8/16 bits.
• Se puede leer o escribir en él a través del registro TMR0.
• Dispone de un preescaler de 8 bits programable por software.
• Puede trabajar con señal de reloj interna o externa (RA4/T0CKI).
• Puede generar una interrupción por desbordamiento.
• En modo contador se puede programar para que incremente su valor por flanco
ascendente o descendente por el pin (RA4/T0CKI).
• En modo temporizador el valor del registro TMR0 se incrementa a intervalos de 1Tcy,
es decir (4/Fosc segundos). (0.2us para 20Mhz / 0.0833us para 48Mhz)
• El registro T0CON (SFR:0xFD5) controla la configuración del módulo
3. Registro de configuración
4. Modo temporizador de 8/16 bits
Para configurar el Timer-0 en modo temporizador de 8 bits hay que:
• Habilitar el módulo poniendo a uno el bit TMR0ON (T0CON<7>).
• Seleccionar el modo temporizador de 8/16 bits poniendo a uno/cero el bit T08BIT
(T0CON<6>)
• Seleccionar la fuente de reloj interna poniendo a cero el bit T0CS (T0CON<5>)
• Habilitar (o no) el preescaler según convenga poniendo a uno o cero el bit PSA
(T0CON<3>)
• En modo temporizador de 8/16 bits, el Timer 0 incrementa el valor del registro
TMR0<TMR0H:TMR0L> con cada ciclo de instrucción (Tcy), sin preescaler .
• Si se escribe en el registro TMR0, éste deja de incrementarse durante 2 ciclos de
instrucción.
• Si el registro TMR0 se desborda (0xFF->0x00) se pone a uno la bandera TMR0IF
(INTCON<2>) y se produce una interrupción si está habilitado el bit TMR0IE (INTCON<5>)
y el bit GIE (INTCON<7>)
5. Modo contador de 8/16 bits
Para configurar el Timer 0 en modo contador de 8/16 bits hay que:
• Habilitar el módulo poniendo a uno el bit TMR0ON (T0CON<7>).
• Seleccionar el modo contador 8/16 bits poniendo a uno/cero el bit T08BIT (T0CON<6>)
• Seleccionar la fuente de reloj externa (RA4/T0CKI) poniendo a uno el bit T0CS
(T0CON<5>)
• Habilitar (o no) el preescaler según convenga poniendo a cero o uno el bit PSA
(T0CON<3>)
• En modo contador de 8/16 bits, el Timer 0 incrementa el valor del registro TMR0 con
cada flanco ascendente (bit INTCON.T0SE=1) o descendente (bit INTCON.T0SE=0) en el
pin (RA4/T0CKI) sin preescaler .
• Si el registro TMR0 se desborda (0xFF->0x00 para 8 bits o 0xFFFF->0x0000 para 16 bits)
se pone a uno la bandera TMR0IF (INTCON<2>)
• Se puede generar una interrupción si está habilitado el bit TMR0IE (INTCON<5>) y el bit
GIE (INTCON<7>)
6. Registros asociados
7. Funciones asociadas en C18
Todas las funciones asociadas al TIMER0 se encuentran en el archivo <timers.h>
Ejemplo 1: Configuración como: temporizador 16bits, interrrupción habilitada, sin
preescaler:
OpenTimer0(TIMER_INT_ON & T0_SOURCE_INT & T0_16BIT & T0_PS_1_1 );
INTCONbits.GIE=1; // Habilitación general de interrupciones
INTCONbits.PEIE=1; // Habilitada interrupción de periféricos
Para controlar el Timer0 se utilizan además las funciones:
void CloseTimer0 (void);
// Deshabilita el Timer0
unsigned int ReadTimer0 (void);
// Leer valor
void WriteTimer0 ( unsigned int timer0); // Escribir valor
Cuando el Timer0 se desborda pone a uno la bandera <INTCONbits.TMR0IF>. Se puede chequear
este bit para conseguir retardos precisos, recargando el TIMER0 y esperando a que se desborde.
Ejemplo de uso: while(INTCONbits.TMR0IF==0); // Esperar desbordamiento
Para ver todas las posibilidades de configuración leer el documento:
“PIC18F Peripheral Library Help Document.chm” situado en ..\mplabc18\v3.4\doc
7.1 Ejemplo de configuración (modo contador)
Ejemplo 2: Configuración como: contador 8bits, sin interrupción, flanco de bajada, sin preescaler:
OpenTimer0(TIMER_INT_OFF & T0_SOURCE_EXT & TO_EDGE_FALL & T0_8BIT & T0_PS_1_1 );
Ejemplo 3: Configuración como: contador 16bits, sin interrupción, flanco subida, preescaler 1:4:
OpenTimer0(TIMER_INT_OFF & T0_SOURCE_EXT & TO_EDGE_RISE & T0_16BIT & T0_PS_1_4 );
En modo contador si ponemos a cero el registro (WriteTimer0(0x00);), cada vez que se produce
un flanco de subida/bajada en el pin RA4 se incrementa en una unidad el registro asociado.
Si tenemos fijado un preescaler “1:PR” el registro se incrementará en una unidad cada “PR”
flancos recibidos en RA4. Por ejemplo, para un preescaler de 1:4 cada cuatro flancos de
subida/bajada se incrementa en una unidad el registro del Timer0.
Cuando el Timer0 alcanza el valor de 0xFFFF (16bits) o 0xFF (8bits), un nuevo flanco provocará su
desbordamiento y que la bandera <INTCONbits.TMR0IF> se ponga a uno. Cuando la bandera se
pone a uno se puede producir una interrupción si éstas están habilitadas.
Para ver todas las posibilidades de configuración leer el documento:
“PIC18F Peripheral Library Help Document.chm” situado en ..\mplabc18\v3.4\doc
8. Ejemplos de lectura / escritura
Para leer el contenido del TIMER0 (modo 16bits) se utiliza la función: ReadTimer0();
Ejemplo:
unsigned int valor;
// Declarar una variable de 16 bits
valor=ReadTimer0();
// Asignamos el valor leído a la variable
Para escribir un valor en el registro TMR0 se utiliza la función:
void WriteTimer0 ( unsigned int timer0);
Ejemplo:
unsigned int valor=1500; // Declarar una variable de 16 bits
WriteTimer0 (valor);
// Asignamos el valor 1500 al timer
Como regla general para conseguir un retardo de “RET” micro segundos:
WriteTimer0 (0-Valor_recarga);
Donde: Valor_recarga= [RET / (TCY * PREESCALER)]
Ejemplo: Para conseguir un retardo de 30ms con un preescaler de 1:4 (Xtal:20Mhz)
Valor_recarga = (30.000/(0.2*4)) = 37500
9. Procedimiento general (I)
Para conseguir un retardo determinado utilizando el Timer 0 como temporizador de
16 bits hay que determinar primero el valor del preescaler (en caso de necesitarlo)
PREESCALER
1:1 (Sin preescaler)
RETARDO MAXIMO
(F=20Mhz)
65536*0,2=13,1ms
1:2
65536*0,2*2=26,21ms
1:4
65536*0,2*4=52,42ms
1:8
65536*0,2*8=104,86ms
1:16
65536*0,2*16=209,72ms
1:32
65536*0,2*32=419,44ms
1:64
65536*0,2*64=838,86ms
1:128
65536*0,2*128=1677,72ms
1:256
65536*0,2*256=3355,44ms (*)
(*) Valor del retardo máximo ~ 3,35 segundos para preescaler de 256
10. Procedimiento general (II)
Para conseguir un retardo de RET microsegundos con el Timer 0 como temporizador
de 16 bits
1º. Fijar el valor del preescaler, según la tabla anterior, para que
(RETARDO MÁXIMO > RET)
2º. Calcular el valor de recarga usando la expresión:
Valor_recarga=(RET / (0.2000*PRESCALER)) → 20Mhz
Valor_recarga=(RET / (0.0833*PRESCALER)) → 48Mhz
3º. Programar el código siguiendo los tres pasos básicos:
• Reset bandera TIMER0
=> INTCONbits.TMR0IF=0;
• Recargar TIMER0
=> WriteTimer0(0-Valor_recarga);
• Esperar desbordamiento => while(INTCONbits.TMR0IF==0);
9. Programa de ejemplo
Utilizar el módulo Timer0 como temporizador de 16bits con preescaler para generar
un retardo de 640ms y realizar un programa que muestre un contador binario en
los cuatro bits de menor peso del PORTB. Mostrar en el lcd el texto que aparece en
la figura.
Solución
No olvidar añadir después de la cabecera: #include <timers.h>
Simulación