Emulación de reloj nakazaqui

[septiembre_negro]

  Pues bien que es el reloj nakazaqui pues no es nada más que un reloj despertador chino más común que corriente  .
El titulo lo ago a forma de burlarme  de mi mismo  . Ya  que  quede muy impresionado con el trabajo de emular un reloj Casio. Pero yo no tengo las capacidades técnicas para llevar a buen término un trabajo como el que menciono  .
Pero tampoco quiero quedarme con las ganas  así que yo boy a emular un reloj despertador nakazaqui  .
Así que para este desarrollo se utilizaran los siguientes dispositivos
Pic 16f84a
Ds1337 rtc con dos alarmas
Ds6958  controla 4 display de 7 segmentos y  9 leds individuales 
Continuara…….

[septiembre_negro]

Pues bien continuando con este proyecto siento que lo primero es resolver la parte de visualizar la información que nos a de arrogar el rtc. Así que atacaremos el chip max6958 de  la casa Dallas semiconductor.
Este chip controla 4 displey de 7 segmentos cátodo común y 9 leds individuales .la comunicación con el pic es por bus i2c, por lo cual es ideal para esta aplicación.
Los leds individuales se utilizaran como indicadores por ejemplo de am/pm día de la semana.
No me fue posible encontrar por la web alguna librería para este dispositivo así que la primer dificultad fue el desarrollar el sof   para que el pic y el max6958 se comunicaran  asunto que se complico ya  que mi ingles no es malo, simplemente no existe.
Así que después de mucho tiempo y diccionario en mano poco apoco el max6958 fue revelando sus secretos y al final resulta que es muy fácil trabajar con este dispositivo, de entrada nos evita engorrosas y complicadas rutinas de multiprexacion además de que el barrido de los displey no se nota,  algo que no se puede decir de otros métodos en definitiva este será mi chip de batalla cuando se tenga que trabajar con displey  no será la la opción mas económica pero simplifica bastante el trabajo tan solo hay que configurar el dispositivo unas cuantas líneas de código para apuntar al displey y el dato y listo .
Sin mas palabras e aquí el código preliminar de un contador 00-9999 visualizado a trabes de este magnifico dispositivo.

Código: [Seleccionar]


#include <16f877a.h>
#use delay(clock=20000000)
#define DS6958_SDA  PIN_C4
#define DS6958_SCL  PIN_C3
#use i2c(master, sda=DS6958_SDA, scl=DS6958_SCL)

#org 0x1eaf, 0x1FFF void loader16F877A(void) {} //protect bootloader code for the 8k 16F876/7

///////////////////////////////////////////////////////////////////////////////////////////////////
// Canal de Comunicación : usart
///////////////////////////////////////////////////////////////////////////////////////////////////
 
#define TTL_TX PIN_C6
#define TTL_RX PIN_C7
 
#use rs232(baud=9600, xmit=TTL_TX, rcv=TTL_RX)

//i2c adress

#define max6958_tarjet_read    0x71
#define max6958_tarjet_write   0x70

//// DS6958 register addresses

#define   no_op            0x00
#define   decode_mode      0x01
#define   intensity        0x02
#define   scan_limit       0x03
#define   configuracion    0x04
#define   display_test     0x07
#define   digit_0          0x20
#define   digit_1          0x21
#define   digit_2          0x22
#define   digit_3          0x23
#define   segments         0x24

long medida;


 //---------------------------------------------------
 //configurar max6958
 void max6958_config (void){
 
  disable_interrupts(GLOBAL);
      i2c_start();
      i2c_write(max6958_tarjet_write );
      i2c_write(decode_mode );   
      i2c_write(0x0f); //  decade mode                 
      i2c_write(0x3c); //  intensity
      i2c_write(0x03); //  scan limit
      i2c_write(0x01); //  configuracion
      i2c_stop();
      enable_interrupts(GLOBAL);
     
 
 }
 
 
 
   
   //----------------------------------------------
void max6958_write_byte(int8 address, int8 data) {

   disable_interrupts(GLOBAL);

   i2c_start();
   i2c_write(max6958_tarjet_write);
   i2c_write(address);
   i2c_write(data);
   i2c_stop();

   enable_interrupts(GLOBAL);

}

//----------------------------------------------
int8 DS1337_read_byte(int8 address) {

   int8 retval;

   disable_interrupts(GLOBAL);
   i2c_start();
   i2c_write(max6958_tarjet_write);
   i2c_write(address);
   i2c_start();
   i2c_write(max6958_tarjet_read);
   retval = i2c_read(0);
   i2c_stop();
   enable_interrupts(GLOBAL);

   return(retval);
}

//***************************separar digitos ********************************

void destripa()      //separa en digitos
{                   
int8 digit[5];
int8 z ;
  disable_interrupts(GLOBAL);

  digit[1]= medida%10;   
  digit[2]=(medida/10)%10;
  digit[3]=(medida/100)%10;
  digit[4]=(medida/1000)%10;
 
 
      i2c_start(); // Y envia al max6958
      i2c_write(max6958_tarjet_write );
      i2c_write(digit_0  );   
      i2c_write(digit[4]); //  u_m                 
      i2c_write(digit[3]); //  centena
      i2c_write(digit[2]); //  decena
      i2c_write(digit[1]); //  unidad
      i2c_stop();
      enable_interrupts(GLOBAL);
   
}
void main (){

max6958_config();


do{

for (medida=0;medida < 9999;medida++){
delay_ms(100);
destripa();

}

}
while(1);

}








[NANO1985]

que buen proyecto septiembre_negro... se espera avances... exitos!
saludos 

[septiembre_negro]

Continuando ahora le toca el turno al rtc ds1337 el motivo de su elección es que cuenta con dos alarmas programables las cuales a través de pines individuales generan una transición de high a low lo cual lo hace ideal para que el pic las trabaje por medio de las interrupción (pines rb4, rb7) el único  inconveniente es que en su momento no me percate de que no cuenta con respaldo de batería, situación que abra que resolver mas adelante.
En este código  preliminar  ya es posible visualizar la hora en el display . (Código más abajo)
Y es aquí donde surge el mayor problema en este proyecto, al contrario de lo que en algún momento imagine  seria lo mas fácil, setear la hora a trabes de botones se dislumbra una rutina arto compleja y mas se complica por que también hay que setear dia, fecha, mes, año, alarma1, alarma2.
El reloj original cuanta para setear  la hora con 3 botones los cuales son, run (el reloj comienza a trabajar), time (setear la hora), alarma (setear alarma), hs (incrementa hora), min (incrementa minutos).
En este momento estoy como  el perro que intenta morderse la cola por mas vueltas que me doy no le encuentro.
Alguna sugerencia de cómo desarrollar la rutina de botones para setear los datos ¿?

Código: [Seleccionar]


#include <16f877a.h>
#use delay(clock=4000000)
#define DS1337_SDA  PIN_C4
#define DS1337_SCL  PIN_C3
#use i2c(master, sda=DS1337_SDA, scl=DS1337_SCL,force_hw)
#org 0x1eaf, 0x1FFF void loader16F877A(void) {} //protect bootloader code for the 8k 16F876/7
#include <max6958_1.c>
///////////////////////////////////////////////////////////////////////////////////////////////////
// Canal de Comunicación : usart
///////////////////////////////////////////////////////////////////////////////////////////////////
 
#define TTL_TX PIN_C6
#define TTL_RX PIN_C7
 
#use rs232(baud=9600, xmit=TTL_TX, rcv=TTL_RX)

// i2c addresses
#define DS1337_I2C_WRITE_ADDR    0xD0
#define DS1337_I2C_READ_ADDR     0xD1

// DS1337 register addresses
#define DS1337_SECONDS_REG       0x00
#define DS1337_MINUTES_REG       0x01
#define DS1337_HOURS_REG         0x02
#define DS1337_DAY_OF_WEEK_REG   0x03
#define DS1337_DATE_REG          0x04
#define DS1337_MONTH_REG         0x05
#define DS1337_YEAR_REG          0x06
//DS1337 Unique Registers
#define DS1337_ALM1_SECONDS_REG  0x07
#define DS1337_ALM1_MINUTES_REG  0x08
#define DS1337_ALM1_HOURS_REG    0x09
#define DS1337_ALM1_DAYDATE_REG  0x0A
#define DS1337_ALM2_MINUTES_REG  0x0B
#define DS1337_ALM2_HOURS_REG    0x0C
#define DS1337_ALM2_DAYDATE_REG  0x0D
#define DS1337_CONTROL_REG       0x0E
#define DS1337_STATUS_REG        0x0F

//Enable Oscillator, Disable SQWV, Disable Ints
#define DS1337_CTRL_REG_INIT_VAL 0x04

//enable oscillator,disable sqwv,enable ints
#define DS1337_CTRL_REG_INIT_VAL2 0x07


//Clear OSF (Oscillator Stop Flag), A2F (Alarm 2 Flag), and A1F (Alarm 1 Flag)
#define DS1337_CLEAR_STATUS_VAL  0x00

   int8 seconds;    // 0 to 59
   int8 minutes;    // 0 to 59
   int8 hours;      // 0 to 23  (24-hour time)
   int8 day;        // 0 = Sunday, 1 = Monday, etc.
   int8 date;       // 1 to 31
   int8 month;      // 1 to 12
   int8 year;       // 00 to 99
   
 //---------------------------------------------------
 //configurar ds1337
 void ds1337_config (void){
 
  disable_interrupts(GLOBAL);
      i2c_start();
      i2c_write(DS1337_I2C_WRITE_ADDR);
      i2c_write(DS1337_CONTROL_REG  );   
      i2c_write(DS1337_CTRL_REG_INIT_VAL2); //                   
      i2c_write(DS1337_CLEAR_STATUS_VAL); //                   
      i2c_stop();
      enable_interrupts(GLOBAL);
 
 
 }
 
   
   
   
   //----------------------------------------------
void DS1337_write_byte(int8 address, int8 data) {

   disable_interrupts(GLOBAL);

   i2c_start();
   i2c_write(DS1337_I2C_WRITE_ADDR);
   i2c_write(address);
   i2c_write(data);
   i2c_stop();

   enable_interrupts(GLOBAL);

}

//----------------------------------------------
int8 DS1337_read_bytes(int8 address) { //<-----------------------1

  int8 retval;

   disable_interrupts(GLOBAL);
   i2c_start();
   i2c_write(DS1337_I2C_WRITE_ADDR);
   i2c_write(address);
   i2c_start();
   i2c_write(DS1337_I2C_READ_ADDR);
   retval = i2c_read(0);
   i2c_stop();
   enable_interrupts(GLOBAL);

   return(retval);
}



//----------------------------------------------
// This function converts an 8 bit binary value
// to an 8 bit BCD value.
// The input range must be from 0 to 99.

int8 bin2bcd(int8 value) {

   char retval;
   retval = 0;

   while(1)
     {
      // Get the tens digit by doing multiple subtraction
      // of 10 from the binary value.
      if(value >= 10)
        {
         value -= 10;
         retval += 0x10;
        }
      else // Get the ones digit by adding the remainder.
        {
         retval += value;
         break;
        }
      }

   return(retval);

}

//----------------------------------------------
// This function converts an 8 bit BCD value to
// an 8 bit binary value.
// The input range must be from 00 to 99.

char bcd2bin(char bcd_value) {

   char temp;

   temp = bcd_value;

   // Shifting the upper digit right by 1 is
   // the same as multiplying it by 8.
   temp >>= 1;

   // Isolate the bits for the upper digit.
   temp &= 0x78;

   // Now return: (Tens * 8) + (Tens * 2) + Ones
   return(temp + (temp >> 2) + (bcd_value & 0x0f));

}

//----------------------------------------------
void DS1337_set_datetime() {

   int8 bcd_sec;
   int8 bcd_min;
   int8 bcd_hrs;
   int8 bcd_day;
   int8 bcd_date;
   int8 bcd_mon;
   int8 bcd_year;

   // Convert the input date/time into BCD values
   // that are formatted for the DS1337 registers.
   bcd_sec  = bin2bcd(seconds);
   bcd_min  = bin2bcd(minutes);
   bcd_hrs  = bin2bcd(hours);    //default to 24 hour mode
   bcd_day  = bin2bcd(day);
   bcd_date = bin2bcd(date);
   bcd_mon  = bin2bcd(month);    //ignore century bit
   bcd_year = bin2bcd(year);

   // Write to the date and time registers.  Disable interrupts
   // so they can't disrupt the i2c operations.
   disable_interrupts(GLOBAL);

   i2c_start();
   i2c_write(DS1337_I2C_WRITE_ADDR);
   i2c_write(DS1337_SECONDS_REG);   // Start at seconds register
   i2c_write(bcd_sec);
   i2c_write(bcd_min);
   i2c_write(bcd_hrs);
   i2c_write(bcd_day);
   i2c_write(bcd_date);
   i2c_write(bcd_mon);
   i2c_write(bcd_year);
   i2c_stop();

   enable_interrupts(GLOBAL);

}

//----------------------------------------------
//setear alarma1_max6958

void ds1337_set_alarma1(void){


}



// seterar alarma2_max6958

void ds1337_set_alarma2(void){



}


//----------------------------------------------
// Read the Date and Time from the hardware registers
// in the DS1337.
void DS1337_read_datetime() {

   int8 bcd_sec;
   int8 bcd_min;
   int8 bcd_hrs;
   int8 bcd_day;
   int8 bcd_date;
   int8 bcd_mon;
   int8 bcd_year;

   // Disable interrupts so the i2c process is not disrupted.
   disable_interrupts(GLOBAL);

   // Read the date/time registers from the DS1337.
   i2c_start();
   i2c_write(DS1337_I2C_WRITE_ADDR);
   i2c_write(DS1337_SECONDS_REG);   // Start at seconds register
   i2c_start();
   i2c_write(DS1337_I2C_READ_ADDR);

   bcd_sec  = i2c_read();
   bcd_min  = i2c_read();
   bcd_hrs  = i2c_read();
   bcd_day  = i2c_read();
   bcd_date = i2c_read();
   bcd_mon  = i2c_read();
   bcd_year = i2c_read(0);
   i2c_stop();

   enable_interrupts(GLOBAL);

   // Convert the date/time values from BCD to
   // unsigned 8-bit integers. Unpack bits in
   // DS1337 registers where required.
   seconds = bcd2bin(bcd_sec  & 0x7F);
   minutes = bcd2bin(bcd_min  & 0x7F);
   hours   = bcd2bin(bcd_hrs  & 0x3F);
   day     = bcd2bin(bcd_day  & 0x07);
   date    = bcd2bin(bcd_date & 0x3F);
   month   = bcd2bin(bcd_mon  & 0x1F);
   year    = bcd2bin(bcd_year);

}







//----------------------------------------------
//If there has been an oscillator failure since last
//init, then init DS1337. A default time and date is set as well.
void DS1337_init(void) {

    int8 temp = 0;

    //Read the status register to see if the oscillator has failed.
    temp = DS1337_read_bytes(DS1337_STATUS_REG);//<-------------------2
    //Unpack OSF bit
    temp = temp >> 7;

    //If oscillator has failed then init DS1337
    if(temp) {
      disable_interrupts(GLOBAL);
      i2c_start();
      i2c_write(DS1337_I2C_WRITE_ADDR);
      i2c_write(DS1337_SECONDS_REG);
      i2c_write(0x00);                     //seconds
      i2c_write(0x00);                     //minutes
      i2c_write(0x40);                     //hours & 12/24 hour mode
      i2c_write(0x00);                     //day
      i2c_write(0x01);                     //date
      i2c_write(0x01);                     //month
      i2c_write(0x06);                     //year
      i2c_write(0x00);                     //alm1 seconds
      i2c_write(0x00);                     //alm1 minutes
      i2c_write(0x00);                     //alm1 hours
      i2c_write(0x00);                     //alm1 day/date
      i2c_write(0x00);                     //alm2 minutes
      i2c_write(0x00);                     //alm2 hours
      i2c_write(0x00);                     //alm2 day/date
      i2c_write(DS1337_CTRL_REG_INIT_VAL); //Turn off the squarewave output pin.
      i2c_write(DS1337_CLEAR_STATUS_VAL);  //Clear the status registers
      i2c_stop();
      enable_interrupts(GLOBAL);
   }
}
VOID MAIN (){
long data;
seconds=00;    // 0 to 59
minutes=30;    // 0 to 59
hours=12;      // 0 to 23  (24-hour time)
day=3;        // 0 = Sunday, 1 = Monday, etc.
date=9;       // 1 to 31
month=11;      // 1 to 12
year=9;       // 00 to 99
DS1337_set_datetime();
ds1337_config();
max6958_config();
do{
DS1337_init();
DS1337_read_datetime();
data=hours*1000;
data=data/10;
data=data+minutes;
max6958_send_num( data);
printf("dta=%lu",data);
printf("hora:%d",hours);
printf(":%d",minutes);
printf(":%d \n\r",seconds);
delay_ms(1000);
}
while(1);

}



[septiembre_negro]

Una vez mas mi viejo amigo pic Basic viene al rescate con la rutina para setear los datos del rtc con botones ahora solo es cuestión de modificarla.
La Liberia del max6958 es 100% operativa con lo cual ya controlo los 4 displey de 7segmentos y 8 leds individuales.
Ahora el siguiente pasó en terminar la rutina del rtc.
Aquí la rutina de los botones en Basic por si a alguien le interesa

Código: [Seleccionar]

This routine sets the time.
'variables "minvalue" and "maxvalue" set the low and high values for year(0-99),month(1-12),
'date(1-31,1-30,1-28 and leap year 1-29),day(1-7,mon to sun),hour(0-23)and minute(0-59).

time_set:
If setup=0 Then GoTo time_set  'debounce button if still pressed from previous routine
Cls
second=0  'clears second display at end of setup


Print At 1,1,"Set"
'the setting of the clock is done "year" first and ends with the "minute", seconds can not be set by the user
'the 1307 will start the clock with zero seconds whenever it is initialised after the time is sent to it.

buttonvalue=year:index=0:maxvalue=99:minvalue=0:GoSub buttons:year=buttonvalue  'work on the YEAR first
buttonvalue=month:index=1:maxvalue=12:minvalue=1:GoSub buttons:month=buttonvalue  'next to the MONTH

buttonvalue=date:index=2:maxvalue=monthlength:minvalue=1:GoSub buttons:date=buttonvalue     'change the DATE
buttonvalue=day:index=3:maxvalue=7:minvalue=1:GoSub buttons:day=buttonvalue     'change the DAY
buttonvalue=hour:index=4:maxvalue=23:minvalue=0:GoSub buttons:hour=buttonvalue     'change the HOUR
buttonvalue=minute:index=5:maxvalue=59:minvalue=0:GoSub buttons:minute=buttonvalue     'change the MINUTE

'this routine uses the "up" and "down" buttons to select the values you require when setting the clock and prints the setup menu

buttons:
If up=0 Then Inc buttonvalue:DelayMS 200       'if up button is pressed then increase "buttonvalue" by one
If buttonvalue>maxvalue Then buttonvalue=minvalue 'if "buttonvalue" goes above its maximum then make it equal to "minvalue"
If down=0 Then Dec buttonvalue:DelayMS 200 'if down button is pressed then decrease "buttonvalue" by one
If buttonvalue<minvalue Or buttonvalue=255 Then buttonvalue=maxvalue 'if "buttonvalue" goes below its minimum, or 255 if the minimum is 0, then make it equal to "maxvalue"



[septiembre_negro]

Pues bien ahora que el código de los periféricos se encuentran en archivos  .c el código es mas legible.
Tengo un inconveniente ya que no  logro activar las alarmas hay que hacer una combinación con los registros que habilitan las int y aun no logro entenderlo.

Código: [Seleccionar]

#include <16f877a.h>
#use delay(clock=4000000)
#org 0x1eaf, 0x1FFF void loader16F877A(void) {} //protect bootloader code for the 8k 16F876/7
#include <max6958_1.c>
#include <ds1337.c>
///////////////////////////////////////////////////////////////////////////////////////////////////
// Canal de Comunicación : usart
///////////////////////////////////////////////////////////////////////////////////////////////////
 
#define TTL_TX PIN_C6
#define TTL_RX PIN_C7
#use rs232(baud=9600, xmit=TTL_TX, rcv=TTL_RX)


  
VOID MAIN (void){
int8 SEG_9;
long data;
seconds=00;                // 0 to 59
minutes=30;               // 0 to 59
hours=12;                // 0 to 23  (24-hour time)
day=3;                  // 0 = Sunday, 1 = Monday, etc.
date=9;                // 1 to 31
month=11;             // 1 to 12
year=9;              // 00 to 99
seg_9=0b11111111;
DS1337_set_datetime();
ds1337_config();
max6958_config();
do{
DS1337_init();
DS1337_read_datetime();
data=hours*1000;
data=data/10;
data=data+minutes;
max6958_send_num( data,seg_9);
//printf("dta=%lu",data);
//printf("hora:%d",hours);
//printf(":%d",minutes);
//printf(":%d \n\r",seconds);
delay_ms(1000);
}
while(1);

}



[septiembre_negro]

 








Pues bien después de algunas dificultades este proyecto llega a su fin.
La pcb no fue desarrollada ya que por ahora aun no me iniciado en ningún sof de diseño,
El cto. Fue montado en una placa de prototipos, es 100% operativo y fue testeado por 48hs.
Inicialmente se tenia considerado un pic 16f84 pero la capacidad de memoria del mismo fue pronto superada por lo que actualmente esta operando en un 16f877a y se tiene a consideración mudarlo a algún pic de 28 pines.
Aquél interesado en montarlo la pcb no representa mayor problema solo hay que mirar las hojas de datos del ds1337 y el max6958 los cuales no representan mayor problema en su conexión al pic.
Resumiendo un poco el proyecto
Se trata de un reloj en tiempo real con dos alarmas, la primera alarma se configura para horas, minutos, segundos, dia. La segunda se configura para hora, minutos, actualmente el indicador de alarma activada en un led que titila, pero puede fácilmente ser personalizada según los requerimientos de cada cual. Tengo pensado incorporar melodías para cada alarma la parte de las melodías ya las trate en un hilo anterior así que no hay pretextó para no despertar con su melodía favorita.
Los datos son visualizados en 4 display de 7 segmentos y cada día de la semana se visualiza en un led independiente, además de que es posible controlar la intensidad de los displey por sof.
Cabe mencionar que el rtc puede atacar las dos alarmas sobre un solo pin del rtc lo que nos daría la opción de activar un relee a una hora y desactivarlo a otra con un lapso incluso de meses .esta parte no esta desarrollada y no tiene mayor dificultad que hacer un par de cambios en los registros del rtc.
Sin más aquí les dejo las librerías y el código completo.
Cualquier comentario o sugerencia serán bienvenidas
Me daré por bien servido si alguien lo disfruta como lo e echo yo

Código: [Seleccionar]


////////////////////////////////////////////////////////////////////////////////
//                                                                            //
//                              ds1337.c                                      //
//                                                                            //
//                        void ds1337_config (void)                           //
//                                                                            //
//             void DS1337_write_byte(int8 address, int8 data)                //
//                                                                            //
//                   int8 DS1337_read_bytes(int8 address)                    //
//                                                                           //
//                      void DS1337_set_datetime()                           //
//                                                                           //
//                     void ds1337_set_alarma1(void)                         //
//                                                                           //
//                     void ds1337_set_alarma2(void)                         //
//                                                                           //
//////////////////////////////////////////////////////////////////////////////









#define DS1337_SDA  PIN_C4
#define DS1337_SCL  PIN_C3
#use i2c(master, sda=DS1337_SDA, scl=DS1337_SCL,force_hw)
// i2c addresses
#define DS1337_I2C_WRITE_ADDR    0xD0
#define DS1337_I2C_READ_ADDR     0xD1

// DS1337 register addresses
#define DS1337_SECONDS_REG       0x00
#define DS1337_MINUTES_REG       0x01
#define DS1337_HOURS_REG         0x02
#define DS1337_DAY_OF_WEEK_REG   0x03
#define DS1337_DATE_REG          0x04
#define DS1337_MONTH_REG         0x05
#define DS1337_YEAR_REG          0x06
//DS1337 Unique Registers
#define DS1337_ALM1_SECONDS_REG  0x07
#define DS1337_ALM1_MINUTES_REG  0x08
#define DS1337_ALM1_HOURS_REG    0x09
#define DS1337_ALM1_DAYDATE_REG  0x0A
#define DS1337_ALM2_MINUTES_REG  0x0B
#define DS1337_ALM2_HOURS_REG    0x0C
#define DS1337_ALM2_DAYDATE_REG  0x0D
#define DS1337_CONTROL_REG       0x0E
#define DS1337_STATUS_REG        0x0F

//opcion1= Enable Oscillator, Disable SQWV, Disable Ints
#define DS1337_CTRL_REG_INIT_VAL 0x04

//opcion2= enable oscillator,disable sqwv,enable ints
#define DS1337_CTRL_REG_INIT_VAL2 0x07


//Clear OSF (Oscillator Stop Flag), A2F (Alarm 2 Flag), and A1F (Alarm 1 Flag)
#define DS1337_CLEAR_STATUS_VAL  0x00
//////////////////////       variables clok           ////////////////////////

   int8 seconds;    // 0 to 59
   int8 minutes;    // 0 to 59
   int8 hours;      // 0 to 23  (24-hour time)
   int8 day;        // 0 = Sunday, 1 = Monday, etc.
   int8 date;       // 1 to 31
   int8 month;      // 1 to 12
   int8 year;       // 00 to 99
  
/////////////////////      variables alarma1 ////////////////////////////////

   int8 seconds_alm1;    // 0 to 59
   int8 minutes_alm1;    // 0 to 59
   int8 hours_alm1;      // 0 to 23  (24-hour time)
   int8 day_alm1;        // 0 = Sunday, 1 = Monday, etc.
  
////////////////////      variables alarma2 //////////////////////////////////

 //int8 seconds_alm2;    // 0 to 59
   int8 minutes_alm2;    // 0 to 59
   int8 hours_alm2;      // 0 to 23  (24-hour time)
   int8 day_alm2;        // 0 = Sunday, 1 = Monday, etc.













 //---------------------------------------------------
 //configurar ds1337
 void ds1337_config (void){
 
  disable_interrupts(GLOBAL);
      i2c_start();
      i2c_write(DS1337_I2C_WRITE_ADDR);
      i2c_write(DS1337_CONTROL_REG  );  
      i2c_write(DS1337_CTRL_REG_INIT_VAL2); //                    
      i2c_write(DS1337_CLEAR_STATUS_VAL); //                    
      i2c_stop();
      enable_interrupts(GLOBAL);
 
 
 }
 
  
  
  
   //----------------------------------------------
void DS1337_write_byte(int8 address, int8 data) {

   disable_interrupts(GLOBAL);

   i2c_start();
   i2c_write(DS1337_I2C_WRITE_ADDR);
   i2c_write(address);
   i2c_write(data);
   i2c_stop();

   enable_interrupts(GLOBAL);

}

//----------------------------------------------
int8 DS1337_read_bytes(int8 address) { //<-----------------------1

  int8 retval;

   disable_interrupts(GLOBAL);
   i2c_start();
   i2c_write(DS1337_I2C_WRITE_ADDR);
   i2c_write(address);
   i2c_start();
   i2c_write(DS1337_I2C_READ_ADDR);
   retval = i2c_read(0);
   i2c_stop();
   enable_interrupts(GLOBAL);

   return(retval);
}



//----------------------------------------------
// This function converts an 8 bit binary value
// to an 8 bit BCD value.
// The input range must be from 0 to 99.

int8 bin2bcd(int8 value) {

   char retval;
   retval = 0;

   while(1)
     {
      // Get the tens digit by doing multiple subtraction
      // of 10 from the binary value.
      if(value >= 10)
        {
         value -= 10;
         retval += 0x10;
        }
      else // Get the ones digit by adding the remainder.
        {
         retval += value;
         break;
        }
      }

   return(retval);

}

//----------------------------------------------
// This function converts an 8 bit BCD value to
// an 8 bit binary value.
// The input range must be from 00 to 99.

char bcd2bin(char bcd_value) {

   char temp;

   temp = bcd_value;

   // Shifting the upper digit right by 1 is
   // the same as multiplying it by 8.
   temp >>= 1;

   // Isolate the bits for the upper digit.
   temp &= 0x78;

   // Now return: (Tens * 8) + (Tens * 2) + Ones
   return(temp + (temp >> 2) + (bcd_value & 0x0f));

}

//----------------------------------------------
void DS1337_set_datetime() {

   int8 bcd_sec;
   int8 bcd_min;
   int8 bcd_hrs;
   int8 bcd_day;
   int8 bcd_date;
   int8 bcd_mon;
   int8 bcd_year;

   // Convert the input date/time into BCD values
   // that are formatted for the DS1337 registers.
   bcd_sec  = bin2bcd(seconds);
   bcd_min  = bin2bcd(minutes);
   bcd_hrs  = bin2bcd(hours);    //default to 24 hour mode
   bcd_day  = bin2bcd(day);
   bcd_date = bin2bcd(date);
   bcd_mon  = bin2bcd(month);    //ignore century bit
   bcd_year = bin2bcd(year);

   // Write to the date and time registers.  Disable interrupts
   // so they can't disrupt the i2c operations.
   disable_interrupts(GLOBAL);

   i2c_start();
   i2c_write(DS1337_I2C_WRITE_ADDR);
   i2c_write(DS1337_SECONDS_REG);   // Start at seconds register
   i2c_write(bcd_sec);
   i2c_write(bcd_min);
   i2c_write(bcd_hrs);
   i2c_write(bcd_day);
   i2c_write(bcd_date);
   i2c_write(bcd_mon);
   i2c_write(bcd_year);
   i2c_stop();

   enable_interrupts(GLOBAL);

}

//----------------------------------------------
//setear alarma1_ds1337

void ds1337_set_alarma1(void){


  
   int8 bcd_sec_alm1;
   int8 bcd_min_alm1;
   int8 bcd_hrs_alm1;
   int8 bcd_day_alm1;
 
  

// Convert the input date/time into BCD values
   // that are formatted for the DS1337 registers.
   bcd_sec_alm1  = bin2bcd(seconds_alm1);
   bcd_min_alm1  =  bin2bcd(minutes_alm1);
   bcd_hrs_alm1  =  bin2bcd(hours_alm1);    //default to 24 hour mode
   bcd_day_alm1  =  bin2bcd(day_alm1);
  
  
  
     // Write to the date and time registers.  Disable interrupts
   // so they can't disrupt the i2c operations.
   disable_interrupts(GLOBAL);

   i2c_start();
   i2c_write(DS1337_I2C_WRITE_ADDR);
   i2c_write(DS1337_ALM1_SECONDS_REG);   // Start at seconds register
   i2c_write(bcd_sec_alm1);
   i2c_write(bcd_min_alm1);
   i2c_write(bcd_hrs_alm1);
   i2c_write(bcd_day_alm1);
   i2c_stop();

   enable_interrupts(GLOBAL);

}
  






// setear alarma2_max6958

void ds1337_set_alarma2(void){



 //int8 bcd_sec_alm2;
   int8 bcd_min_alm2;
   int8 bcd_hrs_alm2;
   int8 bcd_day_alm2;
 
  

// Convert the input date/time into BCD values
   // that are formatted for the DS1337 registers.
 //bcd_sec_alm2  = bin2bcd(seconds_alm2);
   bcd_min_alm2  =  bin2bcd(minutes_alm2);
   bcd_hrs_alm2  =  bin2bcd(hours_alm2);    //default to 24 hour mode
   bcd_day_alm2  =  bin2bcd(day_alm2);
  
  
  
     // Write to the date and time registers.  Disable interrupts
   // so they can't disrupt the i2c operations.
   disable_interrupts(GLOBAL);

   i2c_start();
   i2c_write(DS1337_I2C_WRITE_ADDR);
   i2c_write(DS1337_ALM2_MINUTES_REG );   // Start at minutes register  
   i2c_write(bcd_min_alm2);
   i2c_write(bcd_hrs_alm2);
   i2c_write(bcd_day_alm2);
   i2c_stop();

   enable_interrupts(GLOBAL);

}










//----------------------------------------------
// Read the Date and Time from the hardware registers
// in the DS1337.
void DS1337_read_datetime() {

   int8 bcd_sec;
   int8 bcd_min;
   int8 bcd_hrs;
   int8 bcd_day;
   int8 bcd_date;
   int8 bcd_mon;
   int8 bcd_year;

   // Disable interrupts so the i2c process is not disrupted.
   disable_interrupts(GLOBAL);

   // Read the date/time registers from the DS1337.
   i2c_start();
   i2c_write(DS1337_I2C_WRITE_ADDR);
   i2c_write(DS1337_SECONDS_REG);   // Start at seconds register
   i2c_start();
   i2c_write(DS1337_I2C_READ_ADDR);

   bcd_sec  = i2c_read();
   bcd_min  = i2c_read();
   bcd_hrs  = i2c_read();
   bcd_day  = i2c_read();
   bcd_date = i2c_read();
   bcd_mon  = i2c_read();
   bcd_year = i2c_read(0);
   i2c_stop();

   enable_interrupts(GLOBAL);

   // Convert the date/time values from BCD to
   // unsigned 8-bit integers. Unpack bits in
   // DS1337 registers where required.
   seconds = bcd2bin(bcd_sec  & 0x7F);
   minutes = bcd2bin(bcd_min  & 0x7F);
   hours   = bcd2bin(bcd_hrs  & 0x3F);
   day     = bcd2bin(bcd_day  & 0x07);
   date    = bcd2bin(bcd_date & 0x3F);
   month   = bcd2bin(bcd_mon  & 0x1F);
   year    = bcd2bin(bcd_year);

}







//----------------------------------------------
//If there has been an oscillator failure since last
//init, then init DS1337. A default time and date is set as well.
void DS1337_init(void) {

    int8 temp = 0;

    //Read the status register to see if the oscillator has failed.
    temp = DS1337_read_bytes(DS1337_STATUS_REG);//<-------------------2
    //Unpack OSF bit
    temp = temp >> 7;

    //If oscillator has failed then init DS1337
    if(temp) {
      disable_interrupts(GLOBAL);
      i2c_start();
      i2c_write(DS1337_I2C_WRITE_ADDR);
      i2c_write(DS1337_SECONDS_REG);
      i2c_write(0x00);                     //seconds
      i2c_write(0x00);                     //minutes
      i2c_write(0x40);                     //hours & 12/24 hour mode
      i2c_write(0x00);                     //day
      i2c_write(0x01);                     //date
      i2c_write(0x01);                     //month
      i2c_write(0x06);                     //year
      i2c_write(0x00);                     //alm1 seconds
      i2c_write(0x00);                     //alm1 minutes
      i2c_write(0x00);                     //alm1 hours
      i2c_write(0x00);                     //alm1 day/date
      i2c_write(0x00);                     //alm2 minutes
      i2c_write(0x00);                     //alm2 hours
      i2c_write(0x00);                     //alm2 day/date
      i2c_write(DS1337_CTRL_REG_INIT_VAL); //Turn off the squarewave output pin.
      i2c_write(DS1337_CLEAR_STATUS_VAL);  //Clear the status registers
      i2c_stop();
      enable_interrupts(GLOBAL);
   }
}









Código: [Seleccionar]


///////////////////////////////////////////////////////////////////////////////
//                                                                           //
//                                                                           //  
//                       max6958_1.c                                        //  
//                                                                           //
//                  max6958_config();                                      //
//                  max6958_send_num(long num_display ,INT8 SEG_9 );       //
//                                                                         //
//                                                                         //
//                                                                         //
/////////////////////////////////////////////////////////////////////////////




#define DS6958_SDA  PIN_C4
#define DS6958_SCL  PIN_C3

#use i2c(master, sda=DS6958_SDA, scl=DS6958_SCL,FORCE_HW)

//i2c adress

#define max6958_tarjet_read    0x71
#define max6958_tarjet_write   0x70

//// DS6958 register addresses

#define   no_op            0x00
#define   decode_mode      0x01
#define   intensity        0x02
#define   scan_limit       0x03
#define   configuracion    0x04
#define   display_test     0x07
#define   digit_0          0x20
#define   digit_1          0x21
#define   digit_2          0x22
#define   digit_3          0x23
#define   segments         0x24

//long num_display;


//---------------------------------------------------
 //configurar max6958
 void max6958_config (void){
 
  disable_interrupts(GLOBAL);
      i2c_start();
      i2c_write(max6958_tarjet_write );
      i2c_write(decode_mode );  
      i2c_write(0x0f); //  decade mode                  
      i2c_write(0x3c); //  intensity
      i2c_write(0x03); //  scan limit
      i2c_write(0x01); //  configuracion
      i2c_stop();
      enable_interrupts(GLOBAL);
      
 
 }
 
 
 
    
   //----------------------------------------------
void max6958_write_byte(int8 address, int8 data) {

   disable_interrupts(GLOBAL);

   i2c_start();
   i2c_write(max6958_tarjet_write);
   i2c_write(address);
   i2c_write(data);
   i2c_stop();

   enable_interrupts(GLOBAL);

}

//----------------------------------------------
int8 DS1337_read_byte(int8 address) {

   int8 retval;

   disable_interrupts(GLOBAL);
   i2c_start();
   i2c_write(max6958_tarjet_write);
   i2c_write(address);
   i2c_start();
   i2c_write(max6958_tarjet_read);
   retval = i2c_read(0);
   i2c_stop();
   enable_interrupts(GLOBAL);

   return(retval);
}

//***************************Enviar datos a display ********************************

long max6958_send_num(long num_display,int8 dia_s )      //separa en digitos
{                  
int8 digit[5];
int8 seg_9;
  disable_interrupts(GLOBAL);

  digit[0]= num_display%10;    
  digit[1]=(num_display/10)%10;
  digit[2]=(num_display/100)%10;
  digit[3]=(num_display/1000)%10;
  
  
  switch (dia_s) {

    case 0:seg_9=0b00000011;//domingo


           break;

    case 1:seg_9=0b00000101;//lunes

           break;
    case 2:seg_9=0b00001001;//martes

           break;
          
    case 3:seg_9=0b00010001;//miercoles

           break;
          
    case 4:seg_9=0b00100001;//jueves

           break;
    case 5:seg_9=0b01000001;//viernes

           break;
    case 6:seg_9=0b10000001;//savado

           break;
          
   default:seg_9=0b00000001;;

            break; }


    


  
  
      i2c_start(); // Y envia al max6958
      i2c_write(max6958_tarjet_write );
      i2c_write(digit_0  );  
      i2c_write(digit[3]); //  u_m                
      i2c_write(digit[2]); //  centena
      i2c_write(digit[1]); //  decena
      i2c_write(digit[0]); //  unidad
      i2c_write(seg_9);    // dia de la semana
      i2c_stop();
      enable_interrupts(GLOBAL);
  
}












Código: [Seleccionar]

#include <16f877a.h>
#use delay(clock=4000000)
#org 0x1eaf, 0x1FFF void loader16F877A(void) {} //protect bootloader code for the 8k 16F876/7
#include <max6958_1.c>
#include <ds1337.c>
#use fast_io(a)
#use fast_io(b)


#define setup_hora           PIN_B0
#define up                   PIN_B1
#define down                 PIN_B2
#define exit_int             PIN_B3
#define setup_alm2           PIN_B4
#define setup_alm1           PIN_B5
#define int_alm2             PIN_B6
#define int_alm1             PIN_B7







////////////////////////////////////////////////////////////////////////////////
// Canal de Comunicación : usart
////////////////////////////////////////////////////////////////////////////////
 
#define TTL_TX PIN_C6
#define TTL_RX PIN_C7
#use rs232(baud=9600, xmit=TTL_TX, rcv=TTL_RX)







///////////////////////////////////////////////////////////////////////////////
//                  variables glovales                                       //
//////////////////////////////////////////////////////////////////////////////

int8 dia_s;
long data;
int8 index,max_value,min_value,button_value;
int8 flag_setup_hora,flag_int_alm1,flag_int_alm2,flag_setup_alm1,flag_setup_alm2;



///////////////////////////////////////////////////////////////////////////////
//                declaracion de funciones                                   //
//////////////////////////////////////////////////////////////////////////////



void time_set(void);        //configura hora actual
void time_set_alm1(void);   //Configura alarma 1
void time_set_alm2(void);   //CONFIGURA alarma 2
void buttons (void);        // Incrementa y decrementa
void muestra_menu (VOID);   //Transfiere al display 4dig 7seg
void run_set_led (void);    //indica entrada a menu






/* *************************************************************************
  DESCRIPTION:  Manejador de interrupciones
  RETURN:       none
  ALGORITHM:    none
  NOTES:        Controla los botones de setup y las interrupciones del rtc
            
 *************************************************************************** */    







#INT_EXT                // CONFIGURAR HORA
void IntRB0(){
flag_setup_hora=1;

 }
 
 
 
 
 
 #INT_RB
VOID Interrupcion_RB()
{  

IF (input(int_alm1)==0){           // interrupcion alarma 1
flag_int_alm1=1;
}


IF (input(int_alm2)==0){      //interrupcion alarma 2
flag_int_alm2=1;
}


IF (input(setup_alm1)==0){      //configurar hora alarma 1
flag_setup_alm1=1;
}

IF (input(setup_alm2)==0){      //configurar hora alarma 2
flag_setup_alm2=1;
}

 output_b(input_b());      // Lee portb según hoja de datos
  
}







 /* *************************************************************************
  DESCRIPTION:  Recorre los distintos menús de setup
  RETURN:       none
  ALGORITHM:    none
  NOTES:        Al finalizar el recorrido por los menú comfigura año,mes,fecha,
                dia,hora,minutos
 *************************************************************************** */    

void time_set(void){
printf("inicia_ano \n\r");
index=0;
max_value=99;
min_value=0;
buttons();
year=button_value;// año

printf("inicia_mes \n\r");
index=1;
max_value=12;
min_value=1;
buttons();
month=button_value;//  mes

printf("inicia_fecha \n\r");
index=2;
max_value=31;
min_value=1;
buttons();
date=button_value;// fecha

printf("inicia_dia \n\r");
index=3;
max_value=6;
min_value=0;
buttons();
day=button_value;// dia

printf("inicia_hora \n\r");
index=4;
max_value=23;
min_value=0;
buttons();
hours=button_value;// hora

printf("inicia_minutos \n\r");
index=5;
max_value=59;
min_value=0;
buttons();
minutes=button_value;// minutos



seconds=0;
printf("setea_rtc\n\r");
DS1337_set_datetime();// configura  el rtc

return;
}




 /* *************************************************************************
  DESCRIPTION:   menu  configura  alarma 1
  RETURN:       none
  ALGORITHM:    none
  NOTES:       al finalisar configura horas,minutos,segundos,dia
               también se configura los bits del tipo de alarma
               a1m1,alm2,alm3,alm4,dy/dt segun hoja de datos
 *************************************************************************** */
 
void time_set_alm1(void){



index=6;
max_value=23;
min_value=0;
buttons();
hours_alm1=button_value;          // hora alarma 1
bit_clear(hours_alm1, 7);         //bit alm3

index=7;
max_value=59;
min_value=0;
buttons();
minutes_alm1=button_value;        //  minutos alarma 1
bit_clear(minutes_alm1, 7);      // bit alm2

index=8;
max_value=59;
min_value=0;
buttons();
seconds_alm1=button_value;     // segundos alarma1
bit_clear(seconds_alm1, 7);   // bit alm1

index=9;
max_value=7;
min_value=1;
buttons();
day_alm1=button_value;    // dia alarma 1
bit_clear(day_alm1, 7);  //  bit alm4
bit_set(day_alm1, 6);     //  bit dy/dt



DS1337_write_byte(DS1337_STATUS_REG,DS1337_CLEAR_STATUS_VAL ); //borrar banderas de int
ds1337_set_alarma1();// configura rtc alm1



}



 /* *************************************************************************
  DESCRIPTION:  menu  configura  alarma 2
  RETURN:       none
  ALGORITHM:    none
  NOTES:        Al finalizar configura horras minutos,
                También se configura los bits del tipo de alarma
                a2m2, a2m3, a2m4, según hoja de datos

                
              
 *************************************************************************** */
 
 void time_set_alm2(void){
 
index=10;
max_value=23;
min_value=0;
buttons();
hours_alm2=button_value;          // hora alarma 1
bit_clear(hours_alm2, 7);         //bit a2m3

index=11;
max_value=59;
min_value=0;
buttons();
minutes_alm2=button_value;        //  minutos alarma 1
bit_clear(minutes_alm2, 7);      // bit a2m2

day_alm2=0;                      // no utilizado
bit_set(day_alm2,7 );            //bit a2m4

DS1337_write_byte(DS1337_STATUS_REG,DS1337_CLEAR_STATUS_VAL ); //borrar banderas de int                                                      
ds1337_set_alarma2();            //configura alarma 2
 
 }
 
 
 
/* *************************************************************************
  DESCRIPTION:  alarma1
  RETURN:       none
  ALGORITHM:    none
  NOTES:        Se ejecuta si el rtc activa la interrupción 1
                Y solo sale de la misma so se activa exit_int

                
                
 *************************************************************************** */
  
 void alarma_run_1(void){
 
 
 while(1){
 output_toggle(PIN_A0);      
 delay_ms(100);
 
 IF (input(exit_int )==0){
 delay_ms(500);
 flag_int_alm1=0;
 clear_interrupt(INT_EXT);// Para evitar posible interrupción indeseada antes de tiempo
 DS1337_write_byte(DS1337_STATUS_REG,DS1337_CLEAR_STATUS_VAL ); //Borrar banderas de int
 return;
 }
 
 
 }
 
 }
 
 
 
 /* *************************************************************************
  DESCRIPTION:  alarma2
  RETURN:       none
  ALGORITHM:    none
  NOTES:        Se ejecuta si el rtc activa la interrupción 2
                Y solo sale de la misma so se activa exit_int
              
                
 *************************************************************************** */

void alarma_run_2(void){


while(1){
 output_toggle(PIN_A0);      
 delay_ms(100);
 
 IF (input(exit_int )==0){
 delay_ms(500);
 flag_int_alm2=0;
 clear_interrupt(INT_EXT);// Para evitar posible interrupción indeseada antes de tiempo
 DS1337_write_byte(DS1337_STATUS_REG,DS1337_CLEAR_STATUS_VAL ); //borrar banderas de int
 return;
 }
 
 
 }




}




 

/* *************************************************************************
  DESCRIPTION:  Incrementa y decrementa las variables de menú
  RETURN:       none
  ALGORITHM:    none
  NOTES:        none
 *************************************************************************** */
 
void buttons(void){
printf("entra_buttonss\n\r");
printf("max_value %u \n\r",max_value);
printf("min_value %u \n\r",min_value);
printf("index %u \n\r",index);

while(1){


if (input(up)==0){
delay_ms(600);  // <-----ANTIREBOTE AQUI!!!
button_value++;
printf("button_value++= %u\n\r",button_value);
}

if (button_value > max_value){
button_value=min_value;
}

if(input(down)==0){
delay_ms(600);     // <-----ANTIREBOTE AQUI!!!
button_value--;
printf("button_value--= %u\n\r",button_value);
}

if (button_value < min_value ){
button_value=max_value;
}


 

muestra_menu ();            //Visualiza por  display

if (flag_setup_hora==1){
delay_ms(500);             // <-----ANTIREBOTE AQUI!!!
flag_setup_hora=0 ;          //Restablece bandera
return;
}


if (flag_setup_alm1==1){
delay_ms(500);    // <-----ANTIREBOTE AQUI!!!
flag_setup_alm1=0;
return;
}



if (flag_setup_alm2==1){
delay_ms(500);    // <-----ANTIREBOTE AQUI!!!
flag_setup_alm2=0;
return;
}


}
}
/* *************************************************************************
  DESCRIPTION:  Visualiza menú en display
  RETURN:       none
  ALGORITHM:    none
  NOTES:        none
 *************************************************************************** */    

void muestra_menu (){
      
      long auxiliar;


       switch (index) {

    case 0:auxiliar=button_value+100;
           run_set_led ();
           dia_s=0b00000000;//<-----------
           max6958_send_num( auxiliar,dia_S);
           auxiliar=0;

           break;

    case 1:auxiliar=button_value+200;
           run_set_led ();
           dia_s=0b00000000;
           max6958_send_num(auxiliar ,dia_S);
           auxiliar=0;

           break;
          
          
          
          
      case 2: auxiliar=button_value+300;
              run_set_led ();
              dia_s=0b00000000;
              max6958_send_num( auxiliar,dia_S);
              auxiliar=0;
          

              break;
            
      case 3:auxiliar=button_value+400;
             run_set_led ();
             dia_s=0b00000000;
             max6958_send_num( auxiliar,dia_S);
             auxiliar=0;
          

             break;
            
                    
       case 4:auxiliar=button_value+500;
              run_set_led ();
              dia_s=0b00000000;
              max6958_send_num( auxiliar,dia_S);
              auxiliar=0;
              break;
          
          
        case 5:auxiliar=button_value+600;
                run_set_led ();
                dia_s=0b00000000;
                max6958_send_num(auxiliar ,dia_S);
                auxiliar=0;
                 break;
            
//******************************************************************

         case 6:auxiliar=button_value+700;// hs lm1
                run_set_led ();
                dia_s=0b00000000;
                max6958_send_num(auxiliar ,dia_S);
                auxiliar=0;
                 break;

          
        
          
          case 7:auxiliar=button_value+800;//min lm1
                 run_set_led ();
                 dia_s=0b00000000;
                 max6958_send_num(auxiliar ,dia_S);
                 auxiliar=0;
                 break;
  
  
          case 8:auxiliar=button_value+900;//seg lm1
                 run_set_led ();
                 dia_s=0b00000000;
                 max6958_send_num(auxiliar ,dia_S);
                 auxiliar=0;
                 break;
  
  
  
  
  
         case 9:auxiliar=button_value+1000;//di alm1
                run_set_led ();
                dia_s=0b00000000;
                max6958_send_num(auxiliar ,dia_S);
                auxiliar=0;
                 break;
  
  //************************************************************
  
  
       case 10:auxiliar=button_value+1100;//di alm1
                run_set_led ();
                dia_s=0b00000000;
                max6958_send_num(auxiliar ,dia_S);
                auxiliar=0;
                 break;
  
  
       case 11:auxiliar=button_value+1200;//di alm1
                run_set_led ();
                dia_s=0b00000000;
                max6958_send_num(auxiliar ,dia_S);
                auxiliar=0;
                 break;}
  
        
}









/* *************************************************************************
  DESCRIPTION:  Encienden de forma intermitente segoA y segoB
  RETURN:       none
  ALGORITHM:    none
  NOTES:        Indican que se esta dentro de la rutina de seteo
 *************************************************************************** */

void run_set_led (void){

max6958_write_byte(0x24,0b00000001);
delay_ms(100);
max6958_write_byte(0x24,0b00000000);
delay_ms(100);


}

///////////////////////////////////////////////////////////////////////////////
//                                                                           //
//                  R U T I N A  P R I N C I P A L                           //
//                                                                          //
//                                                                          //
//////////////////////////////////////////////////////////////////////////////

  
VOID MAIN (VOID){

set_tris_b(0b11111111);
set_tris_a(0b00000000);
port_b_pullups(TRUE);
output_b(0);
clear_interrupt(INT_EXT);// Para evitar posible interrupción indeseada antes de tiempo
clear_interrupt(INT_rb); // Para evitar posible interrupción indeseada antes de tiempo
enable_interrupts(int_ext);    //activar interrupcion externa
ext_int_edge(H_TO_L);          //Le digo que el disparo sera de alto a bajo
enable_interrupts(INT_RB);     //avilito interrupciones rb4_rb7
enable_interrupts(GLOBAL);     //todas las interrupciones activadas
 

ds1337_config();           //    configuracion inicial
max6958_config();          //   configuracion inicial

flag_setup_hora=0;
flag_int_alm1=0;
flag_int_alm2=0;
flag_setup_alm1=0;
flag_setup_alm2=0;






do{

IF (flag_setup_hora==1){      //configurar hora y fecha
delay_ms(500);
flag_setup_hora=0;             // Restablece bandera
time_set();
}


IF (flag_setup_alm1==1){ // configurar alarma1
delay_ms(500);
flag_setup_alm1=0;         // restablece bandera
time_set_alm1();
}


IF (flag_setup_alm2==1){ // configurar alarma2
delay_ms(500);
flag_setup_alm2=0;         // restablece bandera
time_set_alm2();
 }


if (flag_int_alm1==1){  // si se activa int1 rtc
 //flag_int_alm1=0;
 alarma_run_1();
}



if (flag_int_alm2==1){  // si se activa int2 rtc
// flag_int_alm2=0;
 alarma_run_2();
}


DS1337_init();            //   configuracion en caso de power_off
DS1337_read_datetime();   //   leer rtc
data=hours*1000;          //Convertir a long hora y minutos
data=data/10;
data=data+minutes;
dia_s=day;
printf("%u",hours);
printf(":%u",minutes);
printf(":%u \n\r",seconds);
max6958_send_num( data,dia_S);// mostrar por displey 4dig 7seg
delay_ms(1000);
}
while(1);

}



[Nocturno]

Enhorabuena por conseguirlo y gracias por compartirlo.
Deberías corregir el link de la foto porque has linkado el thumbnail y se ve muy peque.

[septiembre_negro]

Un pequeño error de ratón, ya esta corregida la imagen aunque no hay mucho que ver el  reloj esta montado en una placa de prototipos, y la foto es malísima lo mejor que pude obtener de mi webcam.
Y no hay nada que agradecer la mayor parte de lo que aplique en el código del reloj lo e aprendido aquí