TIMER0_Como Temporizador

Es un registro de 8 bist y la cuenta máxima es 255, que puede funcionar de dos modos:
-Temporizador: cuenta los pulsos de reloj interno.
-Contador: Cuenta los los eventos externos a través de RA4 o TOCK1.
Una interrupción permite detener el programa y saltar a la función interrupción, luego que se termine de ejecutar la función interrupción, el PIC retorna a la misma dirección donde se había producido la interrupción y se ejecuta el programa con total normalidad, siempre que se produzca una interrupción el programa ara un salto y retorna cuando se finalice la interrupción.
El  tiempo de desbordamiento del TIMER0 lo calcularemos con la siguiente formula:
                                                       TIEMPO= ( 4/ (Fosc )) x PRESCALAR x ( 256 – CARGA_TIMER0 )
TIEMPO: Es el tiempo que deseamos, para el desbordamiento de nuestro porgrama.
Fosc: Es la Frecuencia del reloj(En este caso es de 4Mhz).
PRESCALAR: Este valor nosotros lo cargamos y puede ser 2,4,8,16,32,64,128 o 256.  
CARGA_TIMER0: Este valor tan bien lo cargamos nosotros y puede estar en el rango de 1-255.
En el siguiente ejemplo aremos que PIN_B0 cambie de estado por un tiempo de 50ms  con el TIMER0
si queremos 50ms
                                                        50ms= ( 1/1000000) x 256x ( 256 – CARGA_TIMER0 )
Despejamos y la CARGA_TIMER0=60.6875 lo aproximamos CARGA_TIMER0=60.6875=61  
Con este valor y un prescalar=256 tendremos un tiempo de desbordamiento aproximadamente de  50ms

Código:


#include <16F628A.h>
#fuses INTRC_IO,MCLR,NOWDT
#use delay(clock=4M)
#byte TRISB=0x86        // LLAMAMOS AL REGISTRO TRISB
#byte PORTB=0x06
#int_TIMER0
void TIMER_0(){         //FUNCION DEL TIMER
output_toggle(PIN_B0);
SET_TIMER0(61);  //CARGAMOS DE NUEVO AL TIMER
}
void main(){
TRISB=0x00;                               //CONFIGURADOS COMO SALIDA
PORTB=0x00;                               // UN CERO LOGICO INICIALMENTE
ENABLE_INTERRUPTS(INT_TIMER0);             //INTERRUPCION TIMER0 ACTIVADA
SETUP_TIMER_0(RTCC_INTERNAL |RTCC_DIV_256);//CONFIGURACION TMR0
                                                                                                  // RELOJ INTERNO Y UN PRESCALAR 256                        
SET_TIMER0(61);                            //CARGA TMR0
ENABLE_INTERRUPTS(GLOBAL);    
for(;;){}                                  //BUCLE INFINITO

}


                                     

Ahora si queremos generar tiempos mayores en el programa insertamos un contador

Código:


#include <16F628A.h>
#fuses INTRC_IO,MCLR,NOWDT
#use delay(clock=4M)
#byte TRISB=0x86        // LLAMAMOS AL REGISTRO TRISB
#byte PORTB=0x06
INT CONTADOR;
#int_TIMER0
void TIMER_0(){
contador++;
if(contador==10){    
output_toggle(PIN_B0); //FUNCION DEL TIMER
contador=0;
}SET_TIMER0(61);
}
void main(){
TRISB=0x00;                               //CONFIGURADOS COMO SALIDA
PORTB=0x00;                               // UN CERO LOGICO INICIALMENTE
ENABLE_INTERRUPTS(INT_TIMER0);             //INTERRUPCION TIMER0 ACTIVADA
SETUP_TIMER_0(RTCC_INTERNAL |RTCC_DIV_256);//CONFIGURACION TMR0, RELOJ INTERNO Y UN PRESCALAR 256
SET_TIMER0(61);                            //CARGA TMR0
ENABLE_INTERRUPTS(GLOBAL);    
for(;;){}                                  //BUCLE INFINITO

}


Lo que ara este contador es incrementarse cada ves que el timer se desborda, antes de que se ejecute la función el timer se tiene que desbordar 10 veces  y si multiplicamos 10*50ms=500ms ahora el timer se desboradara cada medio segundo, ahora si queremos para un segundo  en vez de  10 colocamos  20 y listo .

ARCHIVO EX  Y SIMULACION

Buenas siguiendo con el ilo, aca les traigo un nuevo programa, espero que les guste, dudas en los comentarios, ai nos vemos

Código:


#include <16f628A.h>               
#fuses INTRC_IO,MCLR    // ACTIVAMOS EL OSCILADOR INTERNO Y MCLR   
#use delay (clock=4M)  // LA FRECUENCIA DEL RELOJ     
#byte TRISB=0x86        // LLAMAMOS AL REGISTRO TRISB
#byte PORTB=0x06        // LLAMAMOS AL REGISTRO PORTB
#define UNIDAD PIN_A0  // UNIDAD AL PIN_A0
#define DECENA PIN_A1  // DECENA AL PIN_A1
int contador=0;        // VARIABLE PARA EL DESBORDAMIENTO DEL TIMER
int i=0;                // VARIABLE PARA LAS UNIDADES
int j=0;                // VARIABLE PARA LAS DECENAS
int display[10]={0b11000000,  //0
                0b11111001,  //1
                0b10100100,  //2
                0b10110000,  //3
                0b10011001,  //4
                0b10010010,  //5
                0b10000011,  //6
                0b11111000,  //7
                0b10000000,  //8
                0b10010000}; //9
#INT_TIMER0    //DEBAJO DE ESTA INSTRUCCION ESTARA LA FUNCION DEL TIMER
void timer(void)//FUNCION DEL TIMER
{  contador++;    //AUMENTAMOS EL CONTADOR
  if(contador==20) //50mS*20=1000mS=1 SEGUNDO
  {
      contador=0;  //REINICIAMOS AL CONTADOR
      i++;          //AUMENTAMOS EN UNO LA UNIDAD
      if(i==10)    //CUANDO LLEGA A 10 REINICIAMOS TODO
      {
        i=0;        //REINICIAMOS EL CONTADOR DE UNIDADES
        j++;        //AUMENTAMOS  EN UNO LAS DECENAS
      }
      if(j==10)
      j=0;          //REINICIAMOS LAS DECENAS
  }
  set_timer0(61);
}

void main(void)
{
     
  OUTPUT_LOW(DECENA);
  OUTPUT_LOW (UNIDAD);
  TRISB=0x00;
  PORTB=0x00;
  enable_interrupts(INT_TIMER0);            //INTERRUPCION TIMER0 ACTIVADA
  setup_timer_0(RTCC_INTERNAL |RTCC_DIV_256);//CONFIGURACION TMR0
  set_timer0(61);                            //CARGA TMR0
  enable_interrupts(GLOBAL);                //ACTIVA LAS INTERRUPCIONES
      while(TRUE)
      {  OUTPUT_HIGH(UNIDAD);                //PRENDE EL DISPLAY DE UNIDADES
        OUTPUT_LOW(DECENA);                //APAGA EL DISPLAY DE DECENAS
        PORTB=display[i];                  //SACA EL VALOR EN EL DISPLAY DE UNIDADES
        delay_ms(1);
        OUTPUT_HIGH(DECENA);
        OUTPUT_LOW(UNIDAD);
        PORTB=DISPLAY[J];
        delay_ms(1);
       
     
      }
}

CONTADOR