Reloj con DS1307 no arranca en la práctica

[arturkick]

Una contención lógica es cuando dos o más terminales (pines) entran en corto circuito.
Esto sucede más en sistemas bidireccionales, cuando ambas se comportan como salidas y sus niveles lógicos son opuestos.

En tu programa lo que puede estar causando esa falla, es la librería que estás usando para la pantalla.
Al no cumplir con los tiempos adecuados de I/O (Entrada y salida) para el bus de datos, entran en colisión.

Solución: Modificar los tiempos de I/O, o usar la librería que viene con el compilador. "lcd420.c"

Gracias, modificare eso de la librería, incluso supongo que también se podría solucionar con la instrucción -fast_io-, no se; intentare y lo solucionare, muchas gracias y estaré al pendiente con nuevas.

 

[D@rkbytes]

Incluso supongo que también se podría solucionar con la instrucción -fast_io-, no sé.

La instrucción "fast_io(puerto)", sirve para indicarle al compilador que utilice el puerto cómo se defina con la instrucción "set_tris_puerto()"

Por ejemplo, si tengo: #use fast_io(b)
// Defino los pines que serán entradas y salidas.
set_tris_b(0b11111000); // RB2, RB1 y RB0 como salidas.

Si después escribo, output_b(0xFF); // Únicamente se pondrán en 1 los bits declarados como salidas.
Si no se hubiera declarado "fast_io(puerto)", todo el puerto B se pondría en 1, aunque se haya declarado con "set_tris_b(valor);", que <RB7:RB3> sean entradas.

De esa forma el compilador respetará los pines definidos como entradas o salidas usando la instrucción "set_tris_x(valor)"
​

 

[arturkick]

La instrucción "fast_io(puerto)", sirve para indicarle al compilador que utilice el puerto cómo se defina con la instrucción "set_tris_puerto()"

Por ejemplo, si tengo: #use fast_io(b)
// Defino los pines que serán entradas y salidas.
set_tris_b(0b11111000); // RB2, RB1 y RB0 como salidas.

Si después escribo, output_b(0xFF); // Únicamente se pondrán en 1 los bits declarados como salidas.
Si no se hubiera declarado "fast_io(puerto)", todo el puerto B se pondría en 1, aunque se haya declarado con "set_tris_b(valor);", que <RB7:RB3> sean entradas.

De esa forma el compilador respetará los pines definidos como entradas o salidas usando la instrucción "set_tris_x(valor)"
​

gracias por el conocimiento d@rkbytes, entonces no es como yo creía, definitivamente veré como manejo eso de la flex lcd ya que la librería propia del compilador (lcd420) trae definido el pin RB0 para usarlo con la lcd y yo queria usarlo para hacer interrupción, creo que la librería de lcd420 no se puede modificar como la libreria de lcd 16x2 utilizando #define y reasignar los pines o si?

 

[D@rkbytes]

Creo que la librería de lcd420 no se puede modificar como la librería de lcd 16x2 utilizando #define y reasignar los pines. ¿O sí?

Si se puede modificar, yo ya lo he hecho y por aquí en el Foro podrás encontrar cómo se hace.

 

[arturkick]

Si se puede modificar, yo ya lo he hecho y por aquí en el Foro podrás encontrar cómo se hace.

muchas gracias D@RKBYTES, lo checare

 

[degeldeacuario]

Hola, buenas tardes,

Estoy diseñando un reloj con calendario y múltiples alarmas basado en el libro de microcontroladores pic de Carlos A Reyes. El relog es lo de menos por que esta copiado del libro y funciona. Se me esta complicando mucho con el tema de las alarmas. Estoy usando un pic 16f628a el cual se encarga de traducir los datos de un ds1703 y los compara con los datos guardados en una memoria 24lc04b los cuales son cofigurables.
Hasta ahora estoy comparando únicamente segundos para ver resultados rápidos. por ahora la comparación funciona y no tuve que convertir variables ni nada pero tengo este problema...
Por ejemplo: mientras seteo los segundos estos cuentan en exadecimal y por ejemplo si seteo 0A que seria el equivalente a 10, la comparación entre la memoria y el reloj no funciona, pero si seteo 10 que en exadecimal seria 16 me hace la comparación entre 10 hexadecimal del ds1703 y 16 (10) exadecimal de la memoria y se activa la alarma, lo cual no le encuentro sentido, pero estaba buscando la forma de que para modificar la variable de alarma poner un contador que cada vez que cuente 10 pulsos de seteo me sume 6 puntos para saltar del 09 al 10 sin problema. pero no pude, y ya estoy trabajando a prueba y error por que me quede sin ideas.
una vez que solucione esto la idea es replicarlo hasta que no de mas la memoria del 24lc04b por lo menos 100 veces.
Les dejo el adjunto con mi proyecto y un código desordenado por que ya no se que inventar
Aclaro que estuve revisando el proyecto de D@rkbytes y me parece muy bueno, pero no me quiero alejar mucho de lo que estoy haciendo, a no ser que no me quede otra opción :cabezon:

 

[D@rkbytes]

Necesitas convertir a BCD los datos que comparas, para que tengan el mismo formato.
No sé para qué son tantas variables, no las veo necesarias para lo que requieres.
En dado caso, puedes usar arreglos, por ejemplo: Hora Var Byte[23]

Por lo que veo hasta ahora del programa, (que no es mucho) yo si optaría por modificarlo para incluir las rutinas de conversión.

 

[degeldeacuario]

Hola d@rkbytes
Ahora estoy leyendo "basic para microcontroladores pic"
Ya leí sobre los array que es para guardar muchos datos diferentes en la misma variable dentro del microcontrolador, no se si se podrá aplicar a una memoria externa, tengo que probar y después les cuento.
Pero por eso puse tantas variables de horas y minutos, en el libro que estaba usando de guia no explica esto de los array, en total quiero que se puedan configurar 36 alarmas diferentes
Como explique el programa es poco, porque estoy probando la comparación y por eso programe únicamente los segundos para ver un resultado rápido, acá si te voy a tener que hacer caso entonces y poner el conversor, lo que no me queda claro por ejemplo, es que el ds1703 guarda los datos en exadecimal pero volviendo a la cuenta los datos de este saltan por ejemplo de 09 a 10 y no de 09 a 0A como en la memoria. lo que había hecho era que los datos de la memoria me los muestre el display con DEC2 pero al momento de comparar no me funcionaba ni comparando por ejemplo 10 con 10(0A) ni con 10(16) como explique en el mensaje anterior. Por eso el código por ahora quedo como esta escrito en el archivo.
Pero bueno.

Para no explicar tanto me parece que tengo que contar mi objetivo.

Lo que quiero hacer es un reloj calendario (hecho), que tenga la opción de configurar múltiples alarmas y guardarlas en una memoria externa(No terminado).

Gracias por la ayuda, saludos

 

[D@rkbytes]

El asunto es que el DS1307 no usa formato hexadecimal, si fuera así no habría problema entre formatos.
Para el microcontrolador es igual un 10 que un 0x0A, porque lo entenderá en binario, 0b1010

El DS1307 usa el BCD (Decimal codificado en binario), donde cada dígito decimal es codificado con una secuencia de 4 bits.

Usa la rutina de conversión del post #19 y tendrás ese problema resuelto.

 

[degeldeacuario]

Gracias D@rkbytes excelente, ya pude igualar el tipo de variables y ahora puedo hacer la comparación correctamente.
Ahora voy a seguir con los array a ver hasta donde llego.
Bueno gracias por esta mano, ahora tengo que seguir con una alarma completa y después con las 36 alarmas configurables para terminar.
Gracias nuevamente.

 

[degeldeacuario]

Buenas a todos,

Después de 2 meses volví a a retomar mi proyecto (aclaro que sigo experimentando) :estudiando:
Las variables array creo que ya las tengo dominadas (todavía no probé guardarlas en una memoria externa)
Volví a cambiar todo mi proyecto. pero volví a trabarme en el tema de la conversión y comparación.

CMCON = 7

DEFINE  I2C_SCLOUT  1    ;para que no necesite resistencia pull-up en SCL

DEFINE  LCD_DREG        PORTA         ; define pines del LCD  B4  a  B7 
DEFINE  LCD_DBIT          0      ; empezando desde el Puerto B4 hasta el B7 
DEFINE  LCD_RSREG       PORTB    ;define el puerto B para conectar el bit RS 
DEFINE  LCD_RSBIT         3      ;este es el puerto B3 
DEFINE  LCD_EREG        PORTB    ;define el puerto B para conectar el bit Enable 
DEFINE  LCD_EBIT          1      ;este es el puerto B2

DS1307  con %11010000
SCL     var PORTB.7        ; pin señal de reloj I2C
SDA     var PORTB.6        ; pin de datos I2C

Hrtc var byte
Mrtc var byte
Srtc var byte

Hbcd var byte
Mbcd var byte
BCDIn   Var Byte
BCDOut  Var Byte
BinHold Var Byte

Cuenta var byte
Hora var byte[24]
Minuto var byte[24]


    Hora[0]=00
    Hora[1]=01
    Hora[2]=02
    Hora[3]=03
    Hora[4]=04
    Hora[5]=05
    Hora[6]=06
    Hora[7]=07
    Hora[8]=08
    Hora[9]=09
    Hora[10]=10
    Hora[11]=11
    Hora[12]=12
    Hora[13]=13
    Hora[14]=14
    Hora[15]=15
    Hora[16]=16
    Hora[17]=17
    Hora[18]=18
    Hora[19]=19
    Hora[20]=20
    Hora[21]=21
    Hora[22]=22
    Hora[23]=23
    
    Minuto[0]=00
    Minuto[1]=02
    Minuto[2]=04
    Minuto[3]=06
    Minuto[4]=08
    Minuto[5]=10
    Minuto[6]=12
    Minuto[7]=14
    Minuto[8]=16
    Minuto[9]=18
    Minuto[10]=20
    Minuto[11]=22
    Minuto[12]=24
    Minuto[13]=26
    Minuto[14]=28
    Minuto[15]=30
    Minuto[16]=32
    Minuto[17]=34
    Minuto[18]=36
    Minuto[19]=38
    Minuto[20]=40
    Minuto[21]=42
    Minuto[22]=46
    Minuto[23]=48
        
lcdout $fe, 1

Inicio:

    for cuenta = 0 to 24
        LCDOut $FE,$80,"Alarma ",dec2 hora[cuenta],":", dec2 minuto[cuenta]
            
            I2CRead SDA,SCL,DS1307,0,[srtc]        
            I2CRead SDA,SCL,DS1307,1,[mrtc]
            I2CRead SDA,SCL,DS1307,2,[hrtc]
        
        LCDOut $FE,$C0,"Hora: ",Hex2 hrtc,":",Hex2 mrtc,":",Hex2 srtc," "
        
        BCDIn = hrtc
        GoSub DecToBCD
        hrtc = BCDOut
        BCDIn = mrtc
        GoSub DecToBCD
        mrtc = BCDOut
            
            if hora[cuenta] = hrtc then
                high porta.7
                pause 1000
            endif 
            
            pause 300
    next cuenta
        pause 300
    goto inicio

DecToBCD:
    BinHold = BCDIn
    BinHold = (BinHold Dig 1) * $10 + (BinHold Dig 0)
    BCDOut = BinHold
    Return

end

Probé convertir las alarmas a bcd y no me funciono, probé con las horas a bcd y tampoco me funciono.
La verdad... doy un paso para adelante y 4 para atrás :cabezon:
Adjunto el archivo que estoy usando para simular.
Sigue estando todo muy verde. ene este momento quiero resolver el tema de la comparación nada mas

Al final volví a convertir las alarmas. pero tuve que agregar 2 variables mas en el conversor para después usarlas para comparar Esta nueva etapa ya me quedo funcionando

 

[degeldeacuario]

Buenas,

Por suerte ya tengo el reloj terminado y funcionando, todo como se describe arriba y con alguna pequeñas mejoras de interfaz.
Como había comentado antes, ahora estoy experimentando con la memoria eeprom del módulo de reloj rtc que en este caso viene con una memoria 24C32n.

Como siempre me estoy apoyando en el libro "microcontroladores pic - programación en basic".
Bueno yendo al grano programó el ejemplo que viene en el libro de como escribir y leer una memoria eeprom (en este caso 24lc04b)
En este caso puedo escribir y leer perfectamente una cadena de texto, pero lamentablemente no puedo escribir y leer números (trate de entender el datasheet pero esta en ingles) pero bueno, tengo la satisfacción de que escribe y lee algo.

Paso a la memoria 24c32a (proteus no tiene la memoria 24c32n) Y en este caso me devuelve todos caracteres negros, tambien lei el datasheet para ver que podia comparar con el del 24lc04b, lo único que me llamo la atencion es que el bit de control cambia para la lectura y escritura, así que cree dos constantes, una para escribir y la otra para leer pero no surtió ningún efecto (lo raro es que el 24lc08b tampoco lo alteró y funcionó como describo en el párrafo anterior) así que también descarte esta opción.

Hasta ahora lei:
"Manual original del pic basic compiler pro" traducido al español por Luis Frino
https://www.forosdeelectronica.com/f24/escribir-leer-eeprom-externa-15824/
https://www.forosdeelectronica.com/f24/usar-eeprom-pics-23626/
https://www.forosdeelectronica.com/f24/programa-eeprom-24xxx-ser-leida-pic-96291/
que me llevo a
https://www.forosdeelectronica.com/f24/matriz-leds-7x80-animada-18135/
En este caso el usuario cevollin logra leer desde una memoria 24c32a sin problemas (pero en el código "Basic" no veo nada sobre escritura pero si sobre lectura) simule el circuito y funciona perfecto.
A mi circuito por ejemplo le faltaban las resistencias de 10KΩ que puso cevollin en las patas sda y scl, se las puse pero en el circuito no surtió efecto. Asi que decidi dejarlo como en el ejemplo del libro que tengo de guia 4,7KΩ en la pata sda.

Ahora bien, ¿que quiero hacer? guardar mis alarmas en esta memoria (esto a futuro)
Ahora quiero poder escribir y leer en la memoria 24c32a texto y números.
Y me gustaria saber en que le estoy errando después de haber leído tanto:cabezon:

Este es el codigo que estoy usando:

DEFINE   I2C_SCLOUT  1    ;para que no necesite resistencia pull-up en SCL 

DEFINE  LCD_DREG        PORTB         ; define pines del LCD  B4  a  B7 
DEFINE  LCD_DBIT          0      ; empezando desde el Puerto B4 hasta el B7 
DEFINE  LCD_RSREG       PORTB    ;define el puerto B para conectar el bit RS 
DEFINE  LCD_RSBIT         5      ;este es el puerto B3 
DEFINE  LCD_EREG        PORTB    ;define el puerto B para conectar el bit Enable 
DEFINE  LCD_EBIT          4      ;este es el puerto B2
 
escribir   CON   %10100000        ;escribir en eeprom 24c32a
lectura    con   %10100000        ;leer desde eeprom 24c32a
PinSCL     VAR   Portb.7          ;pin señal de reloj I2C 
PinSDA     VAR   Portb.6          ;pin de datos I2C 
dato       VAR byte               ;variable para almacenar dato leído
 
Inicio: 
LCDOUT $fe,1," Grabando..."       ;limpiar y sacar el texto en LCD 
PAUSE 1000 
 
I2CWRITE PinSDA,PinSCL,escribir,0,["1"]      ;guarda la H en posición 0 
    PAUSE 100                                       ;pause para la grabación 
I2CWRITE PinSDA,PinSCL,escribir,1,[2]      ;guarda la O en posición 1 
    PAUSE 100                                       ;pause para la grabación 
I2CWRITE PinSDA,PinSCL,escribir,2,[$3]      ;guarda la L en posición 2 
    PAUSE 100                                       ;pause para la grabación 
I2CWRITE PinSDA,PinSCL,escribir,3,["a"]      ;guarda la A en posición 3 
    PAUSE 100                                      ;pause para la grabación 
 
LCDOUT $fe,1,"Leer memoria"      ;limpiar y sacar el texto en LCD 
 
PAUSE 1000 
LCDOUT $FE,1                                ;limpiar pantalla del LCD 
 
leer:                                         ;programa para leer la memoria serial. 
 
I2CREAD PinSDA,PinSCL,lectura,0,[dato]      ;leer la mem. 0 y guardar en dato
    LCDOUT, dato                           ;mostrar dato en el LCD
    PAUSE 1000                                ;esperar 1 seg. 
I2CREAD PinSDA,PinSCL,lectura,1,[dato]      ;leer la mem. 1 y guardar en dato 
    LCDOUT, dato                            ;mostrar dato en el LCD 
    PAUSE 1000                                ;esperar 1 seg. 
I2CREAD PinSDA,PinSCL,lectura,2,[dato]      ;leer la mem. 2 y guardar en dato 
    LCDOUT, dato                            ;mostrar dato en el LCD 
    PAUSE 1000                                ;esperar 1 seg. 
I2CREAD PinSDA,PinSCL,lectura,3,[dato]      ;leer la mem. 3 y guardar en dato 
    LCDOUT, dato                            ;mostrar dato en el LCD
    PAUSE 1000
;*************estas lineas son unicamente para la simulacion**************
LCDOUT $fe,1,"fin de lectura"               ;limpiar y sacar el texto en LCD 
 
PAUSE 1000 
LCDOUT $FE,1                                ;limpiar pantalla del LCD  
goto inicio
;*************estas lineas son unicamente para la simulacion**************

END

Dejo todas las capturas del funcionamiento del circuito:
Primero con el 24lc04b donde se ve que no me reconoce los números.
Segundo con el 24c32a donde me devuelve todos caracteres negros.
Tercero en el debug las primeras 8 líneas son de escritura y lectura del 24lc04b y el segundo grupo de 8 son los datos de escritura y lectura del 24c32a.

Bueno espero no haber molestado a nadie, D@rkbytes por favor, decime si hago un tema nuevo por esto o sigo aca. En el caso de que tenga que hacer un tema nuevo por favor no me borren el mensaje asi lo copio a un post nuevo.

Desde ya muchas gracias por evacuar mis dudas

 

[D@rkbytes]

No es lo mismo escribir caracteres cómo letras, que números cómo enteros decimales.
O sea, no es lo mismo "1" que 1
El número 1 entre comillas es cómo texto, y sin comillas equivale al ASCII 49

Por ejemplo:
Si guardas el número 255 sin comillas, y después quieres verlo en LCD, verás un cuadro negro.
Si lo guardas con comillas ("255") se ocuparán 3 bytes, porque equivale a una cadena de texto.
Así que dependiendo de la forma en que debe interpretarse el dato, así debe ser leído y también procesado.

Para visualizar el 255 cómo texto, se usa un formateo de datos.
Dato = 255
I2CWrite SDA, SCL, $A0, 0, [Dato] ; Escribir 255 en la posición 0 de la EEPROM.
Dato = 0 ; Limpiar la variable "Dato" (Sólo para comprobar lectura)
I2CRead SDA, SCL, $A0, 0, [Dato] ; Leer la posición 0 de la EEPROM.
LCDOut $FE, $80, "Dato = ", Dec3 Dato ; Mostrar el dato leído en pantalla.

Dec3 hace el formateo de decimal a cadena de texto, y de esa forma podrá ser visualizado en pantalla.
Cuando son letras no hay problema y ya no se usa DecX (Donde X equivale a la cantidad de dígitos)
Para mostrar números también se puede usar el comodín #
Ejemplo:
LCDOut $FE, $80, "Dato = ", #Dato
Pero de esa forma el número será mostrado sin formato, y si la variable cambia de valor, se montará el nuevo resultado sobre el valor anterior, lo cual puede causar confusiones de interpretación.

 

[degeldeacuario]

Gracias D@rkbytes, siempre salvandome

Probe ahora el formateo tal cual me dijiste y funciono perfectamente en el 24lc04b

Ahora en el 24c32a lo único que hace es mostrarme 255 por cada carácter. Para mi le tengo que estar errando en alguna declaración de escritura en esta memoria, ya que la lectura la realiza pero por lo visto la escritura no. No se, ¿que te parece? ya puse las resistencias de pull up como cevollin y nada. y en las páginas y manuales que lei no dice mas nada aparte de la declaración de la función que obviamente es siempre la misma en PBP
Pensaba que era un problema de simulación, pero lo descarto totalmente porque al fin de cuentas la memoria 24lc04b esta funcionando perfectamente ahora.

Gracias nuevamente

 

[D@rkbytes]

Las memorias nuevas o vírgenes, vienen por defecto con 255 en todas sus locaciones.
Eso se debe tener en cuenta al momento de leer una dirección, porque puedes tomar como válido un 0xFF en lugar del dato adecuado.
Así que no esperes leer otra cosa si la memoria no ha sido grabada.
Eso no quiere decir que no se pueda tomar como válido un valor de 255, pero eso lo determinarás tú.

PD: Las resistencias pullup si son necesarias, coloca resistencias de 4.7 KΩ

 

[degeldeacuario]

D@rkbytes ya puse la resistencia pull up que faltaba en el pin SCK y sigo sin resultados en la memoria 24c32a.
Te adjunto mi simulación de proteus y el archivo HEX, ¿podrias hacerme el favor de verificarlos? esta todo tal cual las imágenes e incluyen las mejoras que me recomendaste. ¿Quiero saber que es lo que se me está escapando?
En la simulación hay una selectora para leer cada memoria a gusto, no es parte del proyecto original ni siquiera el 24lc04b, están únicamente para probar el código sin interrupciones.

La memoria 24lc04b sigue funcionando sin problemas

 

[D@rkbytes]

Las memorias del tipo 24LC32 en adelante, son memorias Smart y se direccionan con un puntero Word. (16 Bits)
Así que no puedes leer o escribir ambas por el mismo procedimiento que una Estándar. (P.E. 24LC04)

 

[degeldeacuario]

Buenas gente,

Ya pude leer y escribir en la memoria 24C32a.
Después voy a publicar un tutorial en pic basic pro, para que les sirva de guía a los que puedan llegar a tener este problema, ya que me costó bastante conseguir esta información y al final era realmente sencillo
Gracias por la orientación

 

[dcsalg]

Hola, estoy tratando de hacer funcionar en Proteus el Pic con el reloj DS1307 y un LCD. El LCD lo controlo con un PCF8574, donde al principio utilizaba tanto el DS1307 como el control del PCF8574 en el mismo I2C pero no funciono el display muestra valores 00:00:00 00/00/00 pense porque estaban ambos en el mismo I2C , entonces cambia y coloque el display en el I2C numero 2 dado que el pic tiene 2 I2C pasa exactamente lo mismo. a mi me gustaria controlar ambas cosas en un mismo I2C perop nose porque el display Funciona pero el DS1307 no. Me podrian Ayudar es seguro tema de programacioon pero no le encuentro el error. Adjunto los Dos Archivos ZIP uno del CCS y el otro del proteus. El Archivo FSC01.zip es el programa en C con CCS, y testeo01.zip es el de proteus.
En el programa el clock esta en 4MHZ hay que pasarlo a 8MHZ que es la frecuencia que utilizare. Gracias

#include <18F46K22.h>
#device ADC=10
#device  *=16


#fuses NOWDT

#use delay(internal=8MHz)
#use STANDARD_IO( C )
#use STANDARD_IO( B )

#use i2c(Master, I2C1,slow, STREAM=I2COM1) //,sda=SDA1,scl=SCL1)
#use i2c(Master,FAST, I2C2, STREAM=I2COM2) //,sda=SDA1,scl=SCL1)



#ZERO_RAM

unsigned int fh=0;

/******************************* MODULO LCD I2C ***************************************/
//#use i2c(Master, Fast, I2C1, force_hw)  
#define clear_lcd       (printf(lcd_putc_i2c,"\f"))       //MACRO BORRA LCD
#define send_lcd(dat)   (printf(lcd_putc_i2c,dat))    //MACRO ESCRIBE LCD
#define PCF8574A                 // tipo de modulo que se utiliza           
#define A2_A1_A0 0B111           // direccion del modulo (A2 A1 A0) PCF8574A/PCF8574.
#define LCD20X4                  // tipo de display a utilizar o  LCD 16x2
#include <lcd_i2c_pcf8574_DCS.c>
/**************************************************************************************/

#include <DS1307_dcs.c>


#INT_TIMER0
void  TIMER0_isr(void) 
{
   fh++;
   set_timer0(6);
}

void main()
{
   
   ds1307_init(DS1307_OUT_ENABLED | DS1307_OUT_1_HZ);
   
   ds1307_set_date_time(15,03,17,1,20,00,50);   
   setup_timer_0(RTCC_INTERNAL|RTCC_DIV_16); //|RTCC_8_BIT);      //64,0 us overflow
   set_timer0(6);
      
   enable_interrupts(INT_TIMER0);
   enable_interrupts(GLOBAL);
   
   lcd_init_i2c();   //Inicializa lcd i2c 
   
   while(TRUE)
   {
      
      if(fh>4) { 
         disable_interrupts(INT_TIMER0); 
         fh=0;
         ds1307_get_date(day,month,yr,dow);
        ds1307_get_time(hrs,min,sec);
        lcd_gotoxy_i2c(1,1);
        printf(lcd_putc_i2c,"%02u/%02u/%02u       %02u:%02u",day,month,yr,hrs,min);
         enable_interrupts(INT_TIMER0);
      }
      
   }

}

 

[D@rkbytes]

Para simular correctamente el bus I2C en proteus, debes establecer que las resistencias pull-up sean digitales.
En tu esquema son las resistencias R11 y R12

Cambia sus propiedades y verás que todo debe funcionar, incluso por el mismo bus I2C.