Relógio Digital com PIC16F628 em Linguagem C

Que tal montar seu próprio Relógio Digital?


Este artigo mostra o projeto de um Relógio Digital simples com 4 displays do tipo 7 Segmentos para fins didáticos.
 

 Figura 1 - Display 7 segmentos do Relógio Digital

Para a montagem são utilizados poucos componentes:
- 1 microcontrolador PIC16F628;
- 4 displays 7 segmentos;
- 2 botões para ajuste de hora e minuto;
- 8 resistores de 330 ohms para os segmentos do display;
- 2 resistores de 10 kohms para pullup dos botões;
- 4 resistores de 1 kohms para acionamento dos transistores.

O diagrama de interligação é mostrado na Figura 2.

Figura 2 - Diagrama do Circuito

A montagem pode ser feita em Matriz de Contatos. Veja a Figura 3.

Figura 3 - Circuito montado em Matriz de Contatos

O Vídeo a seguir mostra a Simulação do circuito no Proteus.

Video Relógio Digital rodando no Proteus

O programa do PIC

O programa do Relógio Digital foi escrito em Linguagem C no MPLAB IDE e compilado com o CCS. No Anexo 1 você encontra o código fonte.


A interrupção do Timer0 é utilizada como base de tempo para o relógio (clock).


Todo programa escrito em C inicia-se com a função main ( ).

Após a inicialização algumas variáveis são carregadas com seus valores iniciais. 

A função config_microcontrolador( ) se encarrega de configurar os pinos do microcontrolador como entrada (valor 1) ou saída (valor 0) através dos registros TRISA e TRISB. Os comparadores analógicos internos são desabilitados, pois não são utilizados.

Em setup_timer_0 ( ) é configurado o temporizador timer0 para utilizar a fonte de pulsos internos com presscaler em 1:8 (divisão de pulsos). Esta configuração proporciona um tempo de 2048 us para cada interrupção.

No final das configurações são habilitadas as interrupções do Timer0 e global.

O programa passa então para um loop infinito, em while(true), lendo o status dos botões 1 e 2 para ajuste do minuto e da hora do relógio respectivamente.


A rotina de interrupção do Timer0 é chamada a cada 2048 us.


A cada interrupção é alternado o display que fica aceso, seguindo um processo de multiplexação. Pela cintilação do olho humano enxergamos os 4 displays acesos, mas na verdade apenas um se mantém ligado, e são alternados a cada 2048 us!


A cada interrupção a variável timer é incrementada. 


A cada 29297 interrupções é completado 1 minuto:


29297 x 2048 us = 60000,256 ms ~ 1 minuto


É incrementada a variável do minuto e se necessário a variável de hora.


O horário do relógio é atualizado.


A cada 500 ms o "ponto" do relógio é invertido de status, para "piscar" a cada segundo.


Os "2 pontos" do relógio são formados invertendo-se a montagem do terceiro display de 7 segmentos em 180°.


Você agora pode implementar o código e criar um horário de alarme para adicionar a função de despertador para o seu Relógio Digital!



Obs: 

Este é um circuito didático para ensinar o princípio de funcionamento de um relógio digital. Para menor erro na temporização utilizar cristal externo (XT) de 4 MHz ao invés do oscilador interno (RC).

Note que o minuto não é exato, mas sim de  60000,256 ms, o que acumula um erro de 0,000000042667 %.

Isso quer dizer que o relógio irá adiantar pouco mais de 2 minutos por ano!

(60 minutos x 24 horas x 365 dias = 525600 minutos/ano * 0,256 ms = 134,5536 s)

Para precisão no relógio deve-se utilzar um Relógio de Tempo Real (Real Time Clock - RTC), como por exemplo o DS1302  com cristal de 32,768 kHz ou um PIC com o módulo RTC interno.

Exemplos de circuitos com RTCC:
https://www.youtube.com/watch?v=zR0KW0H_dD4
https://www.youtube.com/watch?v=k_SVMvWyYak

O circuito também não pode ser desligado da alimentação, senão perde a hora, pois não tem bateria de backup.

Anexo 1 - O código fonte do Relógio Digital em Linguagem C

// ***********************************************************
//                          Relogio Digital
// ***********************************************************
// Arquivo:   Relogio.c
// Microcontrolador: PIC16F628    
// Compilador: CCS C Compiler com MPLAB IDE 
// Rev 1.0 03/04/2014
// Rev 1.1 05/04/2014 - alterado pic p 628, adicionado ponto
// Desenvolvido por M.R.G.
// ***********************************************************

/*     Relogio Digital com display 7 segmentos
    com 2 teclas para ajuste de hora e minuto
    utiliza interrupcao do Timer 0 para o clock

*/

// **************** M.R.G. **************************************
// **** Desenvolvido no Brasil *** Made in Brazil ***************
// ********* Build The World ************************************

// Pinos utilizados do microcontrolador:
// RA0 - display unidade
// RA1 - display dezena
// RA2 - display centena
// RA3 - display milhar
// RA4 - saida coletor aberto - botao1
// RA5 - MCLR - entrada digital - botao2
//
// RB0 - segmento ponto
// RB1 - segmento a
// RB2 - segmento b
// RB3 - segmento c
// RB4 - segmento d
// RB5 - segmento e
// RB6 - segmento f 
// RB7 - segmento g



// ******** Inclui ficheiros *********************************

#include <16F628.H> // Define processador

// ******** Configuracao do microcontrolador ******************
#use delay(clock=4000000,RESTART_WDT)

// ******* confifura fuses ***********************************
#fuses INTRC_IO,PUT,WDT,BROWNOUT,NOMCLR,NOLVP,NOCPD
//XT         oscilador externo com cristal
//INTRC_IO    Clock interno, RA6 e RA7 como I/O
//PUT              Ativa tempo de inicialização
//WDT        Ativa Watch Dog Timer
//NOWDT       desativa Wotch Dog Timer
//NOPROTECT       nao protege memoria de programa
//NOBROWNOUT    Não usa brownout reset
//NOMCLR    Pino Master Clear usado como I/O
//NOLVP        Não usa baixa voltagem para programação,
// pino B3 usado como I/O
//NOCPD           Não protege EEPROM




//********** Declara constantes **************************************

#byte porta = 5 // endereco do port a
#byte portb = 6 // endereco do port b


#bit botao1  = porta.4 //botao de incremento de minuto
#bit botao2  = porta.5 //botao de incremento de hora
#bit ponto   = portb.0 //ponto do display

//********** Declara variáveis globais ******************************

unsigned int digito, unidade, dezena, centena, milhar;
unsigned long int tempo;


// **************** Declara protótipos ******************************

void le_botao1 (void);
void le_botao2 (void);



// *************** Rotina de interrupçcao do Timer0 ***************
#int_timer0
void timer0interrupt()                 // 2048 us por interrupcao

{
unsigned int portAPino, portBValor, portBPino;


    digito++;
    
    if (digito == 5)
        digito = 1;




    
// identifica o digito (display) que deve ser aceso

   switch (digito){                //verifica qual digito a acender

     case 1:{                 //codigo para acender o display 1
       portAPino = 0b00000001;
       portBValor = unidade;
         break;}

      case 2:{                 //codigo para acender o display 2
       portAPino = 0b00000010;
       portBValor = dezena;
         break;}

      case 3:{                 //codigo para acender o display 3
       portAPino = 0b00000100;
       portBValor = centena;
         break;}

      case 4:{                 //codigo para acender o display 4
       portAPino = 0b00001000;
       portBValor = milhar;
         break;}

      default:{

         break;}
      }



// carrega valor do numero a acender no diaplay

   switch (portBValor){        //verifica qual valor do numero
      case 0:{                 //codigo para acender o digito 0
        portBPino = 0b01111110;
         break;}

     case 1:{                 //codigo para acender o digito 1
       portBPino = 0b00001100;
         break;}

      case 2:{                 //codigo para acender o digito 2
       portBPino = 0b10110110;
         break;}

      case 3:{                 //codigo para acender o digito 3
       portBPino = 0b10011110;
         break;}

      case 4:{                 //codigo para acender o digito 4
       portBPino = 0b11001100;
         break;}

      case 5: {                //codigo para acender o digito 5
       portBPino = 0b11011010;
         break;}

      case 6: {                //codigo para acender o digito 6
       portBPino = 0b11111010;
         break;}

     case 7: {                //codigo para acender o digito 7
       portBPino = 0b00001110;
         break;}

      case 8: {                //codigo para acender o digito 8
       portBPino = 0b11111110;
         break;}

      case 9: {                //codigo para acender o digito 9
       portBPino = 0b11011110;
         break;}

      default:{

         break;}
      }

    porta = 0;                //apaga todos os digitos
    portB = portBPino;            //acende segmentos
                        //carrega valor do numero no digito 

// pisca os 2 pontos do relogio
        if( (bit_test(tempo,8)) && (bit_test(tempo,7)) && ( (digito == 2)||(digito == 3)) )
            ponto = 1;
        else
            ponto = 0;


    porta = portAPino;             //acende o digito com multiplexacao


// ***** ajusta a hora e minuto  *****

    tempo++;

    if (tempo >= 29297)       //29297 * 2048 us = 60000,256 us = 1 minuto
    {                        //488 = 1 segundo
        unidade++;
        tempo = 0;
    }


// verifica incremento de minuto e hora
    if (unidade >= 10)
    {
        dezena++;
        unidade = 0;
    }

    if (dezena >= 6)
    {
        centena++;
        dezena = 0;
    }

    if ((centena == 4) && (milhar == 2))
    {
        milhar = 0;
        centena = 0;
    }
    if (centena >= 10)
    {
        milhar++;
        centena = 0;    
    }

//    fim da interrupcao

    clear_interrupt(int_rtcc); // clears the timer0 interrupt flag
}



//***********************************************************************
// Configura o microcontrolador 
//***********************************************************************

void config_microcontrolador(void){

   set_tris_A(0b11110000);        //configura pinos de I/O 1 = entrada 0 = saida

   set_tris_B(0b00000000);        //configura pinos de I/O 1 = entrada 0 = saida
                              

   setup_comparator(nc_nc_nc_nc);      //desabilita comparadores internos
   setup_vref(FALSE);
    setup_wdt(WDT_2304MS);                    //habilita watch dog timer
    restart_WDT();                                //zera WDT


// OPTION_REG = B'00010010'    ; T0 interno, dividido por 8 (2 ms/interr)

      //timer 0 habilitado
    setup_timer_0 (RTCC_DIV_8|RTCC_INTERNAL);    //presscaler do Timer0 1:8
                                                //2048 us para interrupcao
    set_timer0(0);                                 //zera contador do Timer 0



    clear_interrupt(int_rtcc);         // clears the timer0 interrupt flag
    enable_interrupts(int_rtcc);     // enables the timer0 interrupt faz T0IE = 1
    enable_interrupts(global);

   return;
}



// ************************************************************************
// Função principal - inicio do programa
// *************************************************************************

void main() {

unsigned long int i;


// --- inicializa variáveis --------------------- 
    portb = 0; 
    digito = 0;
    tempo = 0;    
    unidade = 0;
    dezena = 0;
    centena = 0;
    milhar = 0;            

       config_microcontrolador();          //configura microcontrolador
       restart_WDT();





 while(TRUE)                        //loop infinito
   {
    
        if (!botao1)                   //botao 1 pressionado?
             le_botao1 ();

        if (!botao2)                   //botao 2 pressionado?
             le_botao2 ();

        restart_WDT();         //zera WDT    
               
    }
}



//******************************************************************************
// Le botao 1        - ajuste de minuto
//******************************************************************************

void le_botao1 ()
{                                  // Debouncing --> tempo para estabilizar
 int t;                             // a tecla e evitar repique
   for (t=0;t<50;t++)            // debouncing verifica se tecla pressionada durante tempo t
        {
         delay_ms(1);
         if (botao1) 
            {
              goto sair;   //tecla liberada antes do tempo
            }
          }

        delay_cycles( 2 ); //  NOP - nenhuma instrução
    
   while (!botao1)        //aguarda liberar a tecla
     {
        delay_cycles( 2 ); //  NOP - nenhuma instrução
        restart_WDT();                               //zera WDT
     }


    disable_interrupts (global); // desabilita interrupcao global GIE

    unidade++;            //incrementa minuto

    if (unidade >= 10)
    {
        dezena++;
        unidade = 0;
    }

    if (dezena >= 6)
    {
        dezena = 0;
    }    

  

sair:
    enable_interrupts(global);
    restart_WDT();         //zera WDT
     return;
}



//******************************************************************************
// Le botao 2        - ajuste de hora
//******************************************************************************

void le_botao2 ()
{                                  // Debouncing --> tempo para estabilizar
 int t;                                // a tecla e evitar repique
   for (t=0;t<50;t++)            // debouncing verifica se tecla pressionada durante tempo t
        {
         delay_ms(1);
         if (botao2) 
            {
              goto sair2;   //tecla liberada antes do tempo
            }
          }

        delay_cycles( 2 ); //  NOP - nenhuma instrução
    
   while (!botao2)        //aguarda liberar a tecla
     {
        delay_cycles( 2 ); //  NOP - nenhuma instrução
        restart_WDT();                               //zera WDT
     }


    disable_interrupts (global); // desabilita interrupcao global GIE

    centena++;            //incrementa hora

    if ((centena == 4) && (milhar == 2))
    {
        milhar = 0;
        centena = 0;
    }
    else if (centena == 10)
    {
        milhar ++;
        centena = 0;    
    }
  

sair2:
    enable_interrupts(global);
    restart_WDT();         //zera WDT
    return;
}


//******************************** M.R.G.***********************************