Contador 0-99 com pic - usando compilador CCS

Olá, para este post vamos ver como fazer um algoritmo que conta de 0 a 99 usando o compilador CCS, um projeto de Renato Lôbo. para isto vcs irão precisar: 

- Pic16F628 da Microchip
- Placa com display duplo de 7 segmentos de catodo comum
- Capacitor de 100nf para desacoplamento
- Cabinhos para ligação
- Matriz de contato
- Fonte de 5v 

O código fonte:

////////////////////////////////////////////////////////////////////////////////
// Projeto: Usando Varredura no acionamento de display de 7 segmentos.        //
// Nome: Renato Lôbo Rodrigues                                                //
// Data: 20/08/17                                                             //
// Email: lobosoft@oi.com.br                                                  //
////////////////////////////////////////////////////////////////////////////////
#include <16F628A.h>
#use delay (clock = 4Mhz)
//Configure os fusíveis em acordo com o pic selecionado
#fuses NOWDT
#fuses PUT
#fuses NOBROWNOUT
#fuses NOMCLR
#fuses INTRC_IO
#fuses PROTECT

#byte tris_portA     = 0x85
#byte tris_portB     = 0x86

#bit display0        = 0x05.0 //pino A0
#bit display1        = 0x05.1 //pino A1
#bit SegA            = 0x06.1 //pino B1
#bit SegB            = 0x06.2 //pino B2
#bit SegC            = 0x06.3 //pino B3
#bit SegD            = 0x06.4 //pino B4
#bit SegE            = 0x06.5 //pino B5
#bit SegF            = 0x06.6 //pino B6
#bit SegG            = 0x06.7 //pino B7


void digito(int8 num)
{
   switch(num)
   {
      case 0:  SegA=1;//  AAAA
               SegB=1;// F    B
               SegC=1;// F    B
               SegD=1;//   
               SegE=1;// E    C
               SegF=1;// E    C
               SegG=0;//  DDDD
               break;
      case 1:  SegA=0;//  
               SegB=1;//      B
               SegC=1;//      B
               SegD=0;// 
               SegE=0;//      C
               SegF=0;//      C
               SegG=0;//  
               break;
      case 2:  SegA=1;//  AAAA
               SegB=1;//      B
               SegC=0;//      B
               SegD=1;//  GGGG
               SegE=1;// E    
               SegF=0;// E    
               SegG=1;//  DDDD
               break; 
      case 3:  SegA=1;//  AAAA
               SegB=1;//      B
               SegC=1;//      B
               SegD=1;//  GGGG
               SegE=0;//      C
               SegF=0;//      C
               SegG=1;//  DDDD
               break; 
      case 4:  SegA=0;//  
               SegB=1;// F    B
               SegC=1;// F    B
               SegD=0;//  GGGG
               SegE=0;//      C
               SegF=1;//      C
               SegG=1;//  
               break; 
      case 5:  SegA=1;//  AAAA
               SegB=0;// F    
               SegC=1;// F    
               SegD=1;//  GGGG
               SegE=0;//      C
               SegF=1;//      C
               SegG=1;//  DDDD
               break;               
      case 6:  SegA=1;//  AAAA
               SegB=0;// F     
               SegC=1;// F     
               SegD=1;//  GGGG
               SegE=1;// E    C
               SegF=1;// E    C
               SegG=1;//  DDDD
               break; 
      case 7:  SegA=1;//  AAAA
               SegB=1;//      B
               SegC=1;//      B
               SegD=0;//
               SegE=0;//      C
               SegF=0;//      C
               SegG=0;//  
               break;
      case 8:  SegA=1;//  AAAA
               SegB=1;// F    B
               SegC=1;// F    B
               SegD=1;//  GGGG
               SegE=1;// E    C
               SegF=1;// E    C
               SegG=1;//  DDDD
               break;               
      case 9:  SegA=1;//  AAAA
               SegB=1;// F    B
               SegC=1;// F    B
               SegD=1;//  GGGG
               SegE=0;//      C
               SegF=1;//      C
               SegG=1;//  DDDD
               break;
   }
}
//___________________________________________
//Rotina principal
void main()
{
   int1        d = false;
   int8     dig0 = 0;
   int8     dig1 = 0;
   int8    valor = 0;
   int16   conta = 0;  
   
   tris_portA = 0b11111100;   
   tris_portB = 0b00000001;

 
   //DEFINE display0 e TODOS SEGMENTOS LIGADOS PARA TESTE DURANTE 1 SEGUNDO
   display0=1;display1=0;
   SegA=1;//  AAAA
   SegB=1;// F    B
   SegC=1;// F    B
   SegD=1;//   GG
   SegE=1;// E    C
   SegF=1;// E    C
   SegG=1;//  DDDD
   //aguarda 1 segundo
   delay_ms(1000);
   //DEFINE display1 e TODOS SEGMENTOS LIGADOS PARA TESTE DURANTE 1 SEGUNDO
   display0=0;display1=1;
   SegA=1;//  AAAA
   SegB=1;// F    B
   SegC=1;// F    B
   SegD=1;//   GG
   SegE=1;// E    C
   SegF=1;// E    C
   SegG=1;//  DDDD
   //aguarda 1 segundo
   delay_ms(1000);  
   
   while(true) //laço infinito
   {
      if(!d)                     //se d é falso
      {
         display0=1;display1=0;  //seleciona display0
         digito(dig0);           //chama rotina para digitos de 0 a 9
         d=1;                    //troca para display1
      }else{                     //se falso
         display0=0;display1=1;  //seleciona display1
         digito(dig1);           //chama rotina para digitos de 0 a 9
         d=0;                    //troca para display0
      }
      conta++;          //incremento de contagem para acertar um tempo de +/- 1S
      if(conta>=100)    //testa se ja venceu o tempo
      {
         if(valor<100){ //testa se o valor e maior que 100
            valor++;    //se verdadeiro incrementa o valor
         }else{ 
            valor=0;    // se falso atribui zero
         }
         
         dig0=valor%10; //extrai o resto da divisão para o display0
         dig1=valor/10; //extrai o inteiro da divisão para o display1
         
         conta=0;       //atribui zero para iniciar a contagem de tempo
      }
      delay_ms(10);     //tempo de espera para troca de display
   }
}

A demonstração: