Relogio Microprocessado

EJARDIM · 18 de fevereiro de 2016

Eu tenho um feito, inclusive rodando

.if · 19 de fevereiro de 2016

Legal! Publique-o pra nós. Jardim tem que ter flores né? kk ... é... não é muito engraçado... Mas perdoe e publique assim mesmo!

xyko-2020 · 19 de fevereiro de 2016

@EJARDIM

Seja bem vindo.

Por favor, coloque as informações do projeto.

Do jeito que está, não acrescenta nado ao forum e possivelmente poderá até ser apagado.

Grato!

EJARDIM · 19 de fevereiro de 2016

6 horas atrás, Isadora Ferraz disse:

Legal! Publique-o pra nós. Jardim tem que ter flores né? kk ... é... não é muito engraçado... Mas perdoe e publique assim mesmo!

main.c

ckto.DSN

lcd biblioteca.c

.if · 19 de fevereiro de 2016

Legal mano! você nem usou rtc. Só o timer interno mesmo. Tem vantagens e outras nem tanto. Mas tá valendo!

Pra quem tem preguiça de baixar, veja abaixo os fontes dele...
main.c

Spoiler

#include <16F877A.h> // Tipo do microprocessador
#use delay(clock=4M) // frequencia do cristal oscilador
#fuses xt,put,nowdt,noprotect,nobrownout,NOLVP,NOCPD,NOWRT // configurações
#include <lcd biblioteca.c>
int set, a = 1 ;
    int sec= 50 ;
    int min= 59;
    int hrs= 23;
    int day= 20;
    int mth =8;
    int yr =13 ;


//===========================Temporizador Timer1================================
// 20 mhz clock, no prescaler, set timer 0
// to overflow in 35us
//set_timer0(81);        // 256-(.000035/(4/20000000))
#int_timer0 // Função DEBUGER com utilização do TIMER1
void timer0(void) {
static int conta;
set_timer1(131 + get_timer0());
conta++;

   if (conta == 61) { // Se estourou 62 vezes = 1 segundo
      sec++;
      conta = 0;
   }
   if (sec==60){ // testes para cronometrar
      sec=0;
      min++;
   }
   if (min==60){
      min=0;
      hrs++;
   }
   if (hrs==24){
      hrs=0;
   }
}
//==============================Função Principal================================
void main()
{
   setup_timer_0 (RTCC_INTERNAL | RTCC_DIV_64);
   set_timer0(131);
   enable_interrupts(global | int_timer0); //

   inicializa_lcd(); // inicializa o lcd
//---------------------------------Loop Eterno----------------------------------
   while(TRUE)
   { //loop infinito
   
      while(a==1)
      {
         if(!input(pin_a0)){  //botão set para ajustes
            a= a + 1;
            set = 1;
            while(!input(pin_a0)){}
         }
      
         printf(escreve_lcd,"%02i:%02i:%02i" ,hrs,min,sec );
         envia_byte_lcd(0,0xc0); //função para outra linha
         printf(escreve_lcd,"%i/%i/%i " ,day,mth,yr );
         delay_ms(300);
         limpa_lcd();
     }
    while(a==2)
    {
   
      while(set==1)
      {
         if(!input(pin_a1))
         {
           hrs++ ;
           if(hrs >=24)
           {
             hrs=0;
           }
           while(!input(pin_a1)){}
         }
         if(!input(pin_a2))
         {
            hrs-- ;
            if(hrs == -1)
            {
              hrs = 23 ;
            }
            while(!input(pin_a2)){}
         }
   
         if(!input(pin_a0)){
            set = 2 ;
            while(!input(pin_a0)){}
         }
         
         printf(escreve_lcd," Seta Hora: %i " ,hrs );
         delay_ms(100);
         limpa_lcd();
      }
   
    while(set==2){
   
         if(!input(pin_a1)){
            min++ ;
            if(min >=59){
               min=0;
            }
            while(!input(pin_a1)){}
         }
         if(!input(pin_a2)){
            min-- ;
            if(min == -1){
               min = 59 ;
            }
            while(!input(pin_a2)){}
         }
   
         if(!input(pin_a0)){
            set = 3 ;
            while(!input(pin_a0)){}
         }
         printf(escreve_lcd," Seta Min: %i " ,min );
         delay_ms(100);
         limpa_lcd();
   }
   
       while(set == 3){
         printf(escreve_lcd," Hora Setada ! ");
         delay_ms(1000);
         limpa_lcd();
         set = 4;
       }
       while(set==4){
         if(!input(pin_a1)){
            day++ ;
            if(day >=32){
               day=1;
            }
            while(!input(pin_a1)){}
         }
         if(!input(pin_a2)){
            day-- ;
            if(day == -1){
               day = 31 ;
            }
            while(!input(pin_a2)){}
         }
   
         if(!input(pin_a0)){
            delay_ms(500);
            set = 5 ;
            delay_ms(500);
            while(!input(pin_a0)){}
         }
         printf(escreve_lcd," Seta o Dia: %i " ,day );
         delay_ms(100);
         limpa_lcd();
       }
      while(set==5){
      
         if(!input(pin_a1)){
            mth++ ;
            if(mth >=13){
               mth=1;
            }
            while(!input(pin_a1)){}
         }
         if(!input(pin_a2)){
            mth-- ;
            if(mth == -1){
               mth = 31 ;
            }
            while(!input(pin_a2)){}
         }
         
         if(!input(pin_a0)){
            delay_ms(500);
            set = 6 ;
            delay_ms(500);
            while(!input(pin_a0)){}
         }
         printf(escreve_lcd," Seta o Mes: %i " ,mth );
         delay_ms(100);
         limpa_lcd();
      }
   
      while(set==6){
      
         if(!input(pin_a1)){
            yr++ ;  
            while(!input(pin_a1)){}
         }
         if(!input(pin_a2)){
            yr-- ;
            while(!input(pin_a2)){}
         }
         
         if(!input(pin_a0)){
            delay_ms(500);
            set = 7 ;
            delay_ms(500);
            while(!input(pin_a0)){}
         }
         printf(escreve_lcd," Seta o Ano: %i " ,yr );
         delay_ms(100);
         limpa_lcd();  
      }
      while(set == 7){
         printf(escreve_lcd," Data Setada ! ");
         delay_ms(2000);
         limpa_lcd();
         set = 0;
         a=1;  
      }
    }
  }
}

lcd biblioteca.c

Spoiler

#define lcd_rs pin_B0      // pino rs do LCD
#define lcd_enable pin_B1  // pino enable do LCD
#define lcd_db4 pin_B4      // pino de dados d4 do LCD     // coloque os pinos que desejar
#define lcd_db5 pin_B5     // pino de dados d5 do LCD
#define lcd_db6 pin_B6     // pino de dados d6 do LCD
#define lcd_db7 pin_B7     // pino de dados d7 do LCD

void envia_nibble_lcd(int dado) {
   //Carrega as vias de dados (pinos) do LCD de acordo com o nibble lido

   output_bit(lcd_db4, bit_test(dado,0)); //Carrega DB4 do LCD com o bit DADO<0>
   output_bit(lcd_db5, bit_test(dado,1)); //Carrega DB5 do LCD com o bit DADO<1>
   output_bit(lcd_db6, bit_test(dado,2)); //Carrega DB6 do LCD com o bit DADO<2>
   output_bit(lcd_db7, bit_test(dado,3)); //Carrega DB7 do LCD com o bit DADO<3>

   //Gera um pulso de enable
   output_high(lcd_enable);   // ENABLE = 1
   delay_us(1);               // Recomendado para estabilizar o LCD
   output_low(lcd_enable);    // ENABLE = 0

   return;                    // Retorna ao ponto de chamada da função
}


void envia_byte_lcd(boolean endereco, int dado) {

   output_bit(lcd_rs,endereco);  // Seta o bit RS para instrução ou caractere
   delay_us(100);                // Aguarda 100 us para estabilizar o pino do LCD
   output_low(lcd_enable);       // Desativa a linha ENABLE
   envia_nibble_lcd(dado>>4);    // Envia a parte ALTA do dado/comando
   envia_nibble_lcd(dado & 0x0f);// Limpa a parte ALTA e envia a parte BAIXA do
                                 // dado/comando
   delay_us(40);                 // Aguarda 40us para estabilizar o LCD

   return;                       // Retorna ao ponto de chamada da função
}


void escreve_lcd(char c) {
   
   envia_byte_lcd(1,c);
}

/* * *  Função para limpar o LCD  * * * * * * * * * * * */

void limpa_lcd() {
   envia_byte_lcd(0,0x01);    // Envia instrução para limpar o LCD
   delay_ms(2);               // Aguarda 2ms para estabilizar o LCD

   return;                    // Retorna ao ponto de chamada da função
}


void inicializa_lcd() {
   output_low(lcd_db4);    // Garante que o pino DB4 estão em 0 (low)
   output_low(lcd_db5);    // Garante que o pino DB5 estão em 0 (low)
   output_low(lcd_db6);    // Garante que o pino DB6 estão em 0 (low)
   output_low(lcd_db7);    // Garante que o pino DB7 estão em 0 (low)
   output_low(lcd_rs);     // Garante que o pino RS estão em 0 (low)
   output_low(lcd_enable); // Garante que o pino ENABLE estão em 0 (low)
   delay_ms(15);           // Aguarda 15ms para estabilizar o LCD

   envia_nibble_lcd(0x03); // Envia comando para inicializar o display
   delay_ms(5);            // Aguarda 5ms para estabilizar o LCD
   envia_nibble_lcd(0x03); // Envia comando para inicializar o display
   delay_ms(5);            // Aguarda 5ms para estabilizar o LCD
   envia_nibble_lcd(0x03); // Envia comando para inicializar o display
   delay_ms(5);            // Aguarda 5ms para estabilizar o LCD
   envia_nibble_lcd(0x02); // CURSOR HOME - Envia comando para zerar o contador de
                           // caracteres e retornar à posição inicial (0x80).
   delay_ms(2);            // Aguarda 1ms para estabilizar o LCD
   envia_byte_lcd(0,0x28); // FUNCTION SET - Configura o LCD para 4 bits,
                           // 2 linhas, fonte 5X7.
   envia_byte_lcd(0,0x0c);
                           // DISPLAY CONTROL - Display ligado, sem cursor
   limpa_lcd();
                           // Limpa o LCD
   envia_byte_lcd(0,0x06);
                           // ENTRY MODE SET - Desloca o cursor para a direita
   return;                 // Retorna ao ponto de chamada da função
}

xyko-2020 · 19 de fevereiro de 2016

@EJARDIM

Agora sim!

Tomei a liberdade de postar o circuito, pois nem todos tem o Proteus para visualizar.

Uma das desvantagens a que a Isadora se refere é não contar com bateria de backup pra mantê-lo contando o tempo mesmo sem a alimentação principal.

Mas e daí... de vez em quando acordo com meu rádio relógio piscando!

O que vale é o aprendizado.

aphawk · 20 de fevereiro de 2016

Pelo custo de um pequeno módulo RTC com bateria tipo 2032, que pode ser adquirido no Ebay por menos de US$ 2 , acho que vale a pena fazer esta implementação !

Paulo