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
////////////////////////////////////////////////////////////////////////////////
// //
// 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);
}
}
///////////////////////////////////////////////////////////////////////////////
// //
// //
// 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);
}
#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);
}