Circuito de relógio digital com led

Lucas1989 · 1 de fevereiro de 2008

Bom pessoal, estava vendo essa página

http://www.instructables.com/id/Solid-Wood-Digital-Clock/

onde tem esse relógio de madeira, fiquei interessado em montar o mesmo, só que ele tem muitas "frescuras" que eu não queria. Então gostaria de saber se algum de vocês não teria um circuito de relógio digital que usasse leds, e não displays de 7 segmentos.

Na página até tem o circuito do relógio, só q ele tem muitos extras que não me interessam. Eu gostaria apenas de um relógio, n precisa nem de calendário.

Obs.: ouvi falar que os relógios digitais que usam microcontrolador são pouco precisos, a informação procede?

Obrigado desde já,

Lucas.

Maurício2006 · 1 de fevereiro de 2008

Salve, Lucas.

Lucas1989 disse:
Obs.: ouvi falar que os relógios digitais que usam microcontrolador são pouco precisos, a informação procede?

É... realmente não é das tarefas mais simples fazer um relógio preciso com MCUs. Depende do MCU, depende do programa, depende do cristal....

Depende de um monte de coisas!

No caso dos AVRs, é mais simples porque eles possuem contadores dedicados para tempo real (RTC).

Tú coloca um cristal de 32768Hz e o bixo vira um relógio.

Mas, o que é mais usual, é usar um RTC dedicado (eu uso Holtek HT1380) e usar o MCU pra ler o RTC e fazer a varredura dos displays, no caso de ser de LEDs.

Eu estou pra fazer um relógio aqui, usando displays gigantes! Quando o projeto sair (sabe-se lá quando ), eu vou disponibilizar o circuito elétrico e o programa, usando Atmel AVR ATmega8, com 4 displays e alarme.

[]'s

Lucas1989 · 2 de fevereiro de 2008

Maurício2006 disse:
Salve, Lucas.
É... realmente não é das tarefas mais simples fazer um relógio preciso com MCUs. Depende do MCU, depende do programa, depende do cristal....

Depende de um monte de coisas!

No caso dos AVRs, é mais simples porque eles possuem contadores dedicados para tempo real (RTC).

Tú coloca um cristal de 32768Hz e o bixo vira um relógio.

Mas, o que é mais usual, é usar um RTC dedicado (eu uso Holtek HT1380) e usar o MCU pra ler o RTC e fazer a varredura dos displays, no caso de ser de LEDs.

Eu estou pra fazer um relógio aqui, usando displays gigantes! Quando o projeto sair (sabe-se lá quando ), eu vou disponibilizar o circuito elétrico e o programa, usando Atmel AVR ATmega8, com 4 displays e alarme.

[]'s

Opa Maurício2006, então seria possivel fazer um relógio com uma precisão razoável (tipo um relógio doméstico mesmo, que é a ideia do projeto), pelo q eu entendi.

Agora um detalhe, o projeto com os displays eu até já achei na net, não lembro exatamente qual era o microcontrolador. Seria possível então adaptar um circuito já pronto com displays e trocar os mesmos por led's.

Obg,

Lucas.

Maurício2006 · 2 de fevereiro de 2008

Lucas1989 disse:
Opa Maurício2006, então seria possivel fazer um relógio com uma precisão razoável (tipo um relógio doméstico mesmo, que é a ideia do projeto), pelo q eu entendi.
Agora um detalhe, o projeto com os displays eu até já achei na net, não lembro exatamente qual era o microcontrolador. Seria possível então adaptar um circuito já pronto com displays e trocar os mesmos por led's.

Obg,

Lucas.

Sim, claro! O problema de fazer no software, é que as instruções tb gastam tempo! Então, você precisa ficar descontando o tempo que elas levam pra ajustar o relógio da melhor maneira possível. Por isso é que a maioria dos circuitos com MCU que usam relógio, trabalham com RTCs externos. É muito mais prático e barato dessa forma! O MCU fica desocupado dessa tarefa de gerar tempos reais e com isso, você ganha em velocidade de processamento pra fazer outras coisas, como varredura em alta velocidade.

No caso de alguns modelos de AVRs, eles já possuem circuitos de RTC interno. Em alguns modelos (tipo o Mega128), você pode inclusive trabalhar com dois cristais: um para o processamento geral e outro de baixa frequência só pro RTC.

Eu ainda não experimentei, mas, já que você levantou a lebre, vou ver se faço um relógio com AVR só usando o cristal de 32K, pra ver qual a resposta do conjunto, principalmente no que diz respeito à exibição nos displays....

Sim! Dá pra trocar os displays por LEDs sem problemas, afinal, os displays tb são LEDs, só que em outra configuração.

No lugar de um segmento, você coloca 3, 4, 7 LEDs em série, depende do tamanho do segmento que você quer criar. Mas precisa dimensionar a fonte de alimentação para essa associação. Cada LED comum consome 1,6V.

Quando eu uso LEDs, normalmente uso driver ULN pra manipular os bixinhos, ou então, transistores, mas, o ULN é mais prático.

[]'s

Lucas1989 · 14 de fevereiro de 2008

Maurício2006 disse:
Sim, claro! O problema de fazer no software, é que as instruções tb gastam tempo! Então, você precisa ficar descontando o tempo que elas levam pra ajustar o relógio da melhor maneira possível. Por isso é que a maioria dos circuitos com MCU que usam relógio, trabalham com RTCs externos. É muito mais prático e barato dessa forma! O MCU fica desocupado dessa tarefa de gerar tempos reais e com isso, você ganha em velocidade de processamento pra fazer outras coisas, como varredura em alta velocidade.
No caso de alguns modelos de AVRs, eles já possuem circuitos de RTC interno. Em alguns modelos (tipo o Mega128), você pode inclusive trabalhar com dois cristais: um para o processamento geral e outro de baixa frequência só pro RTC.

Eu ainda não experimentei, mas, já que você levantou a lebre, vou ver se faço um relógio com AVR só usando o cristal de 32K, pra ver qual a resposta do conjunto, principalmente no que diz respeito à exibição nos displays....

Sim! Dá pra trocar os displays por LEDs sem problemas, afinal, os displays tb são LEDs, só que em outra configuração.

No lugar de um segmento, você coloca 3, 4, 7 LEDs em série, depende do tamanho do segmento que você quer criar. Mas precisa dimensionar a fonte de alimentação para essa associação. Cada LED comum consome 1,6V.

Quando eu uso LEDs, normalmente uso driver ULN pra manipular os bixinhos, ou então, transistores, mas, o ULN é mais prático.

[]'s

Bom Maurício2006 obrigado pela explicação. Demorei um pouco, mas acho q deu pra entender quase tudo.

Então você poderia me recomendar algum uControlador que eu não tivesse que me preocupar muito com a programação (esquema de ter que ficar descontando o tempo que ele leva pra executar as operações)??

Só uma coisa que eu fiquei sem entender: o que seria ele ULN e como é que eu poderia fazer a substituição de um display de 7 segmentos pelos leds (se tiver algum tipo de ligação, ou alguma coisa do tipo).

Valeu.

cyberpaiva · 30 de setembro de 2009

Olá mauricio, tudo tranquilo?

Amigão, gostaria de te pedir uma ajuda, e é realmente

importante para mim:

vì no fórum que você trabalha com o ht1380 rtc.

estou trabalhando com um pic 18f452 e estou tentando fazer a leitura do módulo e demonstrar a hora num lcd...quanto ao hardware está tranquilo e está tudo ligado.

mas não consigo ler nada no módulo rtc!

estou programando em c no mplab...

será que você pode me dar uma luz?

agradeceria muito se você tivesse um exemplo de programa!

desde já meu muito obrigado e até breve!

Maurício2006 disse:
Sim, claro! O problema de fazer no software, é que as instruções tb gastam tempo! Então, você precisa ficar descontando o tempo que elas levam pra ajustar o relógio da melhor maneira possível. Por isso é que a maioria dos circuitos com MCU que usam relógio, trabalham com RTCs externos. É muito mais prático e barato dessa forma! O MCU fica desocupado dessa tarefa de gerar tempos reais e com isso, você ganha em velocidade de processamento pra fazer outras coisas, como varredura em alta velocidade.
No caso de alguns modelos de AVRs, eles já possuem circuitos de RTC interno. Em alguns modelos (tipo o Mega128), você pode inclusive trabalhar com dois cristais: um para o processamento geral e outro de baixa frequência só pro RTC.

Eu ainda não experimentei, mas, já que você levantou a lebre, vou ver se faço um relógio com AVR só usando o cristal de 32K, pra ver qual a resposta do conjunto, principalmente no que diz respeito à exibição nos displays....

Sim! Dá pra trocar os displays por LEDs sem problemas, afinal, os displays tb são LEDs, só que em outra configuração.

No lugar de um segmento, você coloca 3, 4, 7 LEDs em série, depende do tamanho do segmento que você quer criar. Mas precisa dimensionar a fonte de alimentação para essa associação. Cada LED comum consome 1,6V.

Quando eu uso LEDs, normalmente uso driver ULN pra manipular os bixinhos, ou então, transistores, mas, o ULN é mais prático.

[]'s

Olá mauricio, tudo tranquilo?

Amigão, gostaria de te pedir uma ajuda, e é realmente

importante para mim:

vì no fórum que você trabalha com o ht1380 rtc.

estou trabalhando com um pic 18f452 e estou tentando fazer a leitura do módulo e demonstrar a hora num lcd...quanto ao hardware está tranquilo e está tudo ligado.

mas não consigo ler nada no módulo rtc!

estou programando em c no mplab...

será que você pode me dar uma luz?

agradeceria muito se você tivesse um exemplo de programa!

desde já meu muito obrigado e até breve!

Maurício2006 · 30 de setembro de 2009

Salve, cyberpaiva.

Aí está o código da bibilioteca que eu criei pra ele. Meus códigos são um tanto quanto confusos (ehehehehe), então, qualquer dúvida, dá um berro aí!

Como você pode notar, o código é para ser usado na linha AVR, mas, com algumas modificações, você pode adaptar aí pro seu MCU.

A primeira função que eu chamo depois do warm-up é a inicializa_RTC (void). Essa função tenta colocar o HT1380 pra oscilar. Se a função não conseguir fazer isso, devolve 1, indicando falha na inicialização.

Depois, é só ler os registradores do RTC, com as suas funções específicas.

Boa sorte.

[]´s

#include <delay.h>
#include <bcd.h>

#ifndef RTC_NO_ERRORS
#define RTC_NO_ERRORS 0
#define RTC_ERROR 1
#endif

#define QNTD_REGISTRADORES_RTC 7

flash unsigned char tabela_RTC_defaults[ QNTD_REGISTRADORES_RTC ] = { 0, // MINUTOS = 0;
0, // HORAS = 0;
1, // DATA DO DIA = 1; DIA PRIMEIRO
1, // MES = 1; JANEIRO
7, // DIA NA SEMANA = 7 SÁBADO
0, // DEZENAS DE ANOS = 0
0}; // SEGUNDOS = 0; CH = 0; OSCILADOR HABILITADO

enum registros_RTC { segundos=0x80,
minutos=0x82,
horas=0x84,
dia_do_mes=0x86,
mes_do_ano=0x88,
dia_semana=0x8A,
ano=0x8C,
write_protect=0x8E};

extern unsigned int ANO_atual;

//=============================================================================
// INICIO DO MÓDULO
//=============================================================================

/*****************************************
**** FUNÇÃO: INICIALIZA RTC
**** OBJETIVO: INICIALIZA A OPERAÇÃO DO RTC
**** SAÍDA: 0 --> FALHA; 1 --> OK
*****************************************/
unsigned char inicializa_RTC (void) // devolve 1 se não houve erros
{
unsigned char dado = 0xFF;
enum registros_RTC registro;

registro = segundos;
dado = RTC_ler ( registro ); // LE O REGISTRADOR DE SEGUNDOS DO RTC; EM BCD
if (dado & 0x80) // TESTA CH (BIT7). SE CH = 1, ENTÃO, OSCILADOR DESLIGADO
{
carregar_RTC_defaults ( ); // TENTA CARREGAR OS DEFAULTS DO RTC
// TESTA NOVAMENTE O BIT CH
dado = RTC_ler ( registro ); // LE O REGISTRADOR DE SEGUNDOS DO RTC
if ( dado & 0x80 ) // TESTA CH. SE CH = 1 ==> OSCILADOR DESLIGADO
{
return ( 0 ); // MARCOU BIT DE ERRO DE ESCRITA NO RTC
}
else
{
return ( 1 ); // OPERAÇÃO DE ESCRITA BEM SUCEDIDA; RTC FUNCIONAL
}
}
else // OSCILADOR OPERACIONAL
{
return ( 1 ); // OPERAÇÃO DE ESCRITA BEM SUCEDIDA; RTC FUNCIONAL
}
}

//*****************************************
// FUNCTION: RTC_ler
// DESCRIPTION: Lê um registrador do RTC. Devolve o resultado em BCD
// INPUT: Registrador de entrada
// OUTPUT: Dado lido do registrador de entrada
//*****************************************
unsigned char RTC_ler ( int registrador ) // LÊ UM REGISTRADOR DO RTC; DEVOLVE O RESULTADO EM BCD
{
unsigned char contador = 0, dado = 0;
bit dado_bit = 0;

registrador++; // INCREMENTA O VALOR DA VARIÁVEL REGISTRADOR PARA APONTAR
// O REGISTRO DE LEITURA DO RTC

RTC_DISABLE; // COLOCA ZERO NO PINO RESET DO RTC
RTC_CLK = LOW;
SET_RTC_DATA_OUT; // pinos de dados como saídas
RTC_ENABLE; // RTC HABILITADO

/****** ENVIA O REGISTRADOR A SER LIDO *********/

for (contador = 0; contador < 8; contador++)
{
RTC_DATA_OUT = (registrador & 0x01);
RTC_CLK = HIGH;
#asm("nop\nop\nop\nop")
RTC_CLK = LOW;
#asm("nop\nop\nop\nop")
registrador >>= 1;
}

/****** LE O REGISTRADOR *********/

RTC_CLK = LOW;
RTC_DATA_OUT = HIGH; // PINO DATA EM 1
SET_RTC_DATA_IN; // pinos como entradas

for (contador = 0; contador < 8; contador++)
{
RTC_CLK = LOW;
dado >>= 1;
#asm("nop\nop\nop\nop")
RTC_CLK = HIGH;
#asm("nop\nop\nop\nop")
dado_bit = RTC_DATA_IN;
if ( dado_bit ) dado |= 0x80; else dado &= 0x7F;
RTC_CLK = LOW;
#asm("nop\nop\nop\nop")
}

RTC_DISABLE;
RTC_CLK = LOW; // RTC DESABILITADO
RTC_DATA_OUT = LOW;
SET_RTC_DATA_OUT; // pinos como saídas

return ( dado );
}

//*****************************************
//*****************************************
void carregar_RTC_defaults (void)
{
// MATRIZ DE 7 ENDEREÇOS DE REGISTRADORES DO RTC
enum registros_RTC registros[ QNTD_REGISTRADORES_RTC ] = { minutos, horas, dia_do_mes, mes_do_ano, dia_semana, ano, segundos };

unsigned char contador = 0;

// INICIALIZA O RTC, DE ACORDO COM OS PARAMETROS DA TABELA
for (contador = 0; contador < QNTD_REGISTRADORES_RTC; contador++)
RTC_escrever(registros[contador], bin2bcd ( tabela_RTC_defaults [ contador ] ) );
}

//*****************************************
//*****************************************
void ler_calendario ( unsigned char *vetor )
{
ler_data_atual ( vetor ); // D_M_AA
ANO_atual = ((int) vetor [ ANO_HIGH ] << 8) & 0xFF00;
ANO_atual += vetor [ ANO_LOW ];
}

//*****************************************
//*****************************************
void habilitar_escrita_RTC ( void )
{
enum registros_RTC registrador;
unsigned char contador = 0;

registrador = write_protect;

RTC_DISABLE;
RTC_CLK = LOW; // RTC DESABILITADO
RTC_DATA_OUT = LOW;
SET_RTC_DATA_OUT; // pinos como saídas
RTC_ENABLE; // RTC HABILITADO

/******* SELECIONA O REGISTRADOR WRITE PROTECT ********/
//********** COMMAND BYTE *************
for (contador = 0; contador < 8; contador++)
{
RTC_DATA_OUT = (registrador & 0x01);
RTC_CLK = HIGH;
#asm("nop\nop\nop\nop")
RTC_CLK = LOW;
#asm("nop\nop\nop\nop")
registrador >>= 1;
}

/******* HABILITA ESCRITA NO RTC **********/
//********** DATA I/O *************
for (contador = 0; contador < 8; contador++)
{
RTC_DATA_OUT = 0;
RTC_CLK = HIGH;
#asm("nop\nop\nop\nop")
RTC_CLK = LOW;
#asm("nop\nop\nop\nop")
} // REGISTRADOR WP = 0X00; HABILITADO PARA ESCRITA

RTC_DISABLE;
RTC_CLK = LOW; // RTC DESABILITADO
RTC_DATA_OUT = LOW;
SET_RTC_DATA_OUT; // pinos como saídas
}

//*****************************************
//*****************************************
void desabilitar_escrita_RTC ( void )
{
enum registros_RTC registrador;
unsigned char contador = 0, variavel = 0x00;

registrador = write_protect;

RTC_DISABLE;
RTC_CLK = LOW; // RTC DESABILITADO
RTC_DATA_OUT = LOW;
SET_RTC_DATA_OUT; // pinos como saídas
RTC_ENABLE; // RTC HABILITADO

/******* SELECIONA O REGISTRADOR WRITE PROTECT ********/
//********** COMMAND BYTE *************
for (contador = 0; contador < 8; contador++)
{
RTC_DATA_OUT = (registrador & 0x01);
RTC_CLK = HIGH;
#asm("nop\nop\nop\nop")
RTC_CLK = LOW;
#asm("nop\nop\nop\nop")
registrador >>= 1;
}

/******* DESABILITA ESCRITA NO RTC **********/
//********** DATA I/O *************
variavel = 0x80; // WP = 1 - ESCRITA NO RTC DESABILITADA
for (contador = 0; contador < 8; contador++)
{
RTC_DATA_OUT = ( variavel & 0x01 );
RTC_CLK = HIGH;
#asm("nop\nop\nop\nop")
RTC_CLK = LOW;
#asm("nop\nop\nop\nop")
variavel >>= 1;
} // REGISTRADOR WP = 0X00; HABILITADO PARA ESCRITA

RTC_DISABLE;
RTC_CLK = LOW; // RTC DESABILITADO
RTC_DATA_OUT = LOW;
SET_RTC_DATA_OUT; // pinos como saídas
}

//*****************************************
//*****************************************
void RTC_escrever ( int registrador, unsigned char dado ) // dados de entrada do RTC em BCD
{
unsigned char contador = 0;

habilitar_escrita_RTC ( );

RTC_DISABLE;
RTC_CLK = LOW; // RTC DESABILITADO
RTC_DATA_OUT = LOW;
SET_RTC_DATA_OUT; // pinos como saídas
RTC_ENABLE; // RTC HABILITADO

/******** ENVIA O REGISTRADOR A SER ESCRITO ***********/
//********** COMMAND BYTE *************
for (contador = 0; contador < 8; contador++)
{
RTC_DATA_OUT = (registrador & 0x01);
RTC_CLK = HIGH;
#asm("nop\nop\nop\nop")
RTC_CLK = LOW;
#asm("nop\nop\nop\nop")
registrador >>= 1;
}

/******** ENVIA O DADO PARA O REGISTRADOR SELECIONADO **********/
for (contador = 0; contador < 8; contador++)
{
RTC_DATA_OUT = (dado & 0x01);
RTC_CLK = HIGH;
#asm("nop\nop\nop\nop")
RTC_CLK = LOW;
#asm("nop\nop\nop\nop")
dado >>= 1;
}

RTC_DISABLE;
RTC_CLK = LOW; // RTC DESABILITADO
RTC_DATA_OUT = LOW;
SET_RTC_DATA_OUT; // pinos como saídas

desabilitar_escrita_RTC ( );
}

//*****************************************
//*****************************************
void incrementar_horas ( void )
{
unsigned char dado_lido = 0;
enum registros_RTC registrador;

registrador = horas;
dado_lido = bcd2bin ( RTC_ler ( registrador ) ); // LÊ UM REGISTRADOR DO RTC; DEVOLVE O RESULTADO EM HEXA
if (++dado_lido > 23) dado_lido = 0;
dado_lido = bin2bcd ( dado_lido ); // CONVERTE PARA BCD
RTC_escrever(registrador, dado_lido); // dados do RTC em BCD (Binário Codificado em Decimal)
}

//*****************************************
//*****************************************
void decrementar_horas(void)
{
unsigned char dado_lido = 0;
enum registros_RTC registrador;

registrador = horas;
dado_lido = bcd2bin ( RTC_ler ( registrador ) ); // LÊ UM REGISTRADOR DO RTC; DEVOLVE O RESULTADO EM HEXA
if (--dado_lido == 0xFF ) dado_lido = 23;
dado_lido = bin2bcd ( dado_lido ); // CONVERTE PARA BCD
RTC_escrever(registrador, dado_lido); // dados do RTC em BCD (Binário Codificado em Decimal)
}

//*****************************************
//*****************************************
void incrementar_minutos(void)
{
unsigned char dado_lido = 0;
enum registros_RTC registrador;

registrador = minutos;
dado_lido = bcd2bin ( RTC_ler ( registrador ) ); // LÊ UM REGISTRADOR DO RTC; DEVOLVE O RESULTADO EM HEXA
if (++dado_lido > 59) dado_lido = 0;
dado_lido = bin2bcd ( dado_lido ); // CONVERTE PARA BCD
RTC_escrever(registrador, dado_lido); // dados do RTC em BCD (Binário Codificado em Decimal)
}

//*****************************************
//*****************************************
void incrementar_segundos(void)
{
unsigned char dado_lido = 0;
enum registros_RTC registrador;

registrador = segundos;
dado_lido = bcd2bin ( RTC_ler ( registrador ) ); // LÊ UM REGISTRADOR DO RTC; DEVOLVE O RESULTADO EM HEXA
if (++dado_lido > 59) dado_lido = 0;
dado_lido = bin2bcd ( dado_lido ); // CONVERTE PARA BCD
RTC_escrever(registrador, dado_lido); // dados do RTC em BCD (Binário Codificado em Decimal)
}

//*****************************************
//*****************************************
void decrementar_minutos(void)
{
unsigned char dado_lido = 0;
enum registros_RTC registrador;

registrador = minutos;
dado_lido = bcd2bin ( RTC_ler ( registrador ) ); // LÊ UM REGISTRADOR DO RTC; DEVOLVE O RESULTADO EM HEXA
if (--dado_lido == 0xFF ) dado_lido = 59;
dado_lido = bin2bcd ( dado_lido ); // CONVERTE PARA BCD
RTC_escrever(registrador, dado_lido); // dados do RTC em BCD (Binário Codificado em Decimal)
}

//*****************************************
//*****************************************
void decrementar_segundos(void)
{
unsigned char dado_lido = 0;
enum registros_RTC registrador;

registrador = segundos;
dado_lido = bcd2bin ( RTC_ler ( registrador ) ); // LÊ UM REGISTRADOR DO RTC; DEVOLVE O RESULTADO EM HEXA
if (--dado_lido == 0xFF ) dado_lido = 59;
dado_lido = bin2bcd ( dado_lido ); // CONVERTE PARA BCD
RTC_escrever(registrador, dado_lido); // dados do RTC em BCD (Binário Codificado em Decimal)
}

/*****************************************
RETORNO: A função devolve uma string no formato: HHMMSS
FORMATO DE RETORNO: BCD
*****************************************/
void ler_relogio ( unsigned char *string )
{
enum registros_RTC registrador;
unsigned char indice = 2;

registrador = segundos;
string [ indice-- ] = RTC_ler ( registrador );// LÊ UM REGISTRADOR DO RTC; DEVOLVE O RESULTADO EM HEXA;

registrador = minutos;
string [ indice-- ] = RTC_ler ( registrador );// LÊ UM REGISTRADOR DO RTC; DEVOLVE O RESULTADO EM HEXA;

registrador = horas;
string [ indice-- ] = RTC_ler( registrador );// LÊ UM REGISTRADOR DO RTC; DEVOLVE O RESULTADO EM HEXA;
}

/*****************************************
RETORNO: A função devolve uma string no formato: DMAA
FORMATO DE RETORNO: HEXADECIMAL ==> 0x00 (DIAS); 0x00 (MES); 0x0000 (ANO)
*****************************************/
void ler_data_atual ( unsigned char *string ) // D_M_AA
{
enum registros_RTC registrador;
unsigned int var = 0;

registrador = dia_do_mes;
string [ DIA ] = bcd2bin ( RTC_ler( registrador ) );// LÊ UM REGISTRADOR DO RTC; DEVOLVE O RESULTADO EM HEXA;

registrador = mes_do_ano;
string [ MES ] = bcd2bin ( RTC_ler( registrador ) );// LÊ UM REGISTRADOR DO RTC; DEVOLVE O RESULTADO EM HEXA;

registrador = ano; //
var = bcd2bin ( RTC_ler( registrador ) ); // LE O REGISTRADOR DE ANOS; DEVOLVE EM BCD

var += 2000; // ANO CONVERTIDO EM HEXA ==> DE 2000 À 2099
string [ ANO_HIGH ] = ( var & 0xFF00 ) >> 8;
string [ ANO_LOW ] = var & 0x00FF;
}

//======================================================
//======================================================
void incrementar_dia_do_mes(void)
{
unsigned char dado_lido = 0;
enum registros_RTC registrador;

registrador = dia_do_mes;
dado_lido = bcd2bin ( RTC_ler ( registrador ) ); // LÊ UM REGISTRADOR DO RTC; DEVOLVE O RESULTADO EM HEXA
if (++dado_lido > 31) dado_lido = 1;
dado_lido = bin2bcd ( dado_lido ); // CONVERTE PARA BCD
RTC_escrever(registrador, dado_lido); // dados do RTC em BCD (Binário Codificado em Decimal)
}

//======================================================
//======================================================
void decrementar_dia_do_mes(void)
{
unsigned char dado_lido = 0;
enum registros_RTC registrador;

registrador = dia_do_mes;
dado_lido = bcd2bin ( RTC_ler ( registrador ) ); // LÊ UM REGISTRADOR DO RTC; DEVOLVE O RESULTADO EM HEXA
if (dado_lido == 1)
dado_lido = 31;
else
--dado_lido;
dado_lido = bin2bcd ( dado_lido ); // CONVERTE PARA BCD
RTC_escrever(registrador, dado_lido); // dados do RTC em BCD (Binário Codificado em Decimal)
}

//======================================================
//======================================================
void incrementar_mes(void)
{
unsigned char dado_lido = 0;
enum registros_RTC registrador;

registrador = mes_do_ano;
dado_lido = bcd2bin ( RTC_ler ( registrador ) ); // LÊ UM REGISTRADOR DO RTC; DEVOLVE O RESULTADO EM HEXA
if (++dado_lido > 12) dado_lido = 1;
dado_lido = bin2bcd ( dado_lido ); // CONVERTE PARA BCD
RTC_escrever(registrador, dado_lido); // dados do RTC em BCD (Binário Codificado em Decimal)
}

//======================================================
//======================================================
void decrementar_mes(void)
{
unsigned char dado_lido = 0;
enum registros_RTC registrador;

registrador = mes_do_ano;
dado_lido = bcd2bin ( RTC_ler ( registrador ) ); // LÊ UM REGISTRADOR DO RTC; DEVOLVE O RESULTADO EM HEXA
if (!(--dado_lido)) dado_lido = 12;
dado_lido = bin2bcd ( dado_lido ); // CONVERTE PARA BCD
RTC_escrever(registrador, dado_lido); // dados do RTC em BCD (Binário Codificado em Decimal)
}

//======================================================
//======================================================
void incrementar_ano(void)
{
unsigned char dado_lido = 0;
enum registros_RTC registrador;

registrador = ano;
dado_lido = bcd2bin ( RTC_ler ( registrador ) ); // LÊ UM REGISTRADOR DO RTC;
// DEVOLVE O RESULTADO EM HEXA
if (++dado_lido > 99) dado_lido = 0;
dado_lido = bin2bcd ( dado_lido ); // CONVERTE PARA BCD
RTC_escrever(registrador, dado_lido); // dados do RTC em BCD (Binário Codificado em Decimal)
}

//======================================================
//======================================================
void decrementar_ano(void)
{
unsigned char dado_lido = 0;
enum registros_RTC registrador;

registrador = ano;
dado_lido = bcd2bin ( RTC_ler ( registrador ) ); // LÊ UM REGISTRADOR DO RTC;
// DEVOLVE O RESULTADO EM HEXA
if (!dado_lido) dado_lido = 99; else --dado_lido;
dado_lido = bin2bcd ( dado_lido ); // CONVERTE PARA BCD
RTC_escrever(registrador, dado_lido); // dados do RTC em BCD (Binário Codificado em Decimal)
}
#include <mega8.h>