Contador de 0 a 99

En esta ocasión les traigo este circuito que hace un conteo de 0 a 99 y repite, se realiza con un PIC 16F84A y con 2 transistores 2N2222, el conteo se muestra por medio de 2 displays cátodo común.

Aquí el código del programa. 

//***********************************************************************************************//
//  Ejemplo 2_Contador 0 a 99                                                                                                     
//  MICROCONTROLADOR: PIC16F84a                                                                      
//  WEB:  www.ElectronicPIC.blogspot.com                                                                  
//  COMPILADOR:  CCS C Compiler v.4023                                                                
//  DESCRIPCION: Programa que realiza el conteo de 0 a 99 por medio de interrup-
//                          ción por desbordamiento del Timer0 con el PIC16F84A                                      
//***********************************************************************************************//
#include <16F84A.h>
//***********************************************************************************************//

//                                            CONFIGURACIÓN DEL MICROCONTROLADOR                      
//***********************************************************************************************//

#FUSES NOWDT,XT,PUT                    //No Watch Dog Timer, OscCrystal, PowerUP
#byte portb = 0x06
#byte trisb = 0x86
#byte porta = 0x05
#byte trisa = 0x85
#use delay(clock=4000000)
//***********************************************************************************************//
#define Enciende      Output_High
#define Apaga         Output_Low
#define Conmuta       Output_toggle
#define LED           PIN_B0
//***********************************************************************************************//contador=0,decenas=0;
int delay=15;                              
int cod7seg [10] = {0x3f,0x06,0x5b,0x4f,0x66,0x6d,0x7d,0x07,0x7f,0x67};
#int_TIMER0                 
void timer0()
{
   delay--;                                                       //Cuando se desborda el Timer0 entra y disminuye delay -1
   if(delay==0){                                               //Si delay llega a 0:
     if(decenas>9){                                          //Cuando decenas llega a 10, decenas se reinicia
decenas=0;
     }
     contador++;
     if(contador==10) {                                   //Cuando contador llega a 10 entra:
         contador=0;                                       // Se reinicia contador a 0
         decenas++;                                       //aumentan las decenas +1
     }
     delay=15;                                             //65.5ms * delay = aprox [851.5ms. Tiempo de variación de
}                                                               //contador, se reinicia antes de salir.
   set_timer0(0);                                        //Se reinicia Timer0 y vuelve a contar para el prox. desbordamiento
}

//PRINCIPAL
void main(void)
{
   trisb=(0x00);
   trisa=(0x00);
   setup_timer_0 ( RTCC_INTERNAL | RTCC_DIV_256 );     /// configura a timer0 con reloj
                                                                               /// interno y un divisor de 256                                    
  
                   /*La formula para saber cada cuando se ejecutara nuestra
                     interrupción con el timer0 es T=N*M*(4/FOSC) donde:
                     T= tiempo
                     N= preescalador del timer o divisor
                     M= numero de iteraciones
                     Así por ejemplo con un preescalador de 256 un numero de
                     iteraciones de 256 y un cristal de 4mhz nos da un resultado
                     de 65.5 milisegundos por interrupción */
                    
   enable_interrupts(GLOBAL);                        /// permitir interrupciones
   enable_interrupts(INT_timer0);                     ///activar interrupcion en timer0
   set_timer0(0);                                                ///Cargamos el timer0
   portb=cod7seg[0];                                         ///Iniciamos con portb=0 en cod7seg
  
   while(true)
   {
   porta=0x01;                                                                   //Encendemos el display 1 por 5ms y le damos el valor de cod7seg
   portb=cod7seg[contador];                                             //de contador que son las unidades
   delay_ms(10);
  
   porta=0x02;                                                                   //Encendemos el display 2 por 5ms y le damos el valor de cod7seg
   portb=cod7seg[decenas];                                              //en decenas
   delay_ms(10);                                                                
   }
}
//***********************************************************************************************///*El intervalo de encendido y apagado de los displays es tan rápido que no se alcanza a percibir.
La activación se hace por medio de transistores conectador al CC del display y  a masa activados por RA0 y RA1
*/

Una mirada al circuito simulado con Proteus.


Sin mas,  aquí el CODIGO y el archivo de SIMULACIÓN
Saludos .