Reloj pcf8583 tiempo real con 16f84

[lactoria]

Alguien sabe como usar pcf8583 reloj tiempo real, algún ejemplo en pbp o algo plisssssss

El registro de segundos y el de minutos cuenta hasta 80 y no hasta 60 porque sera


mi correo por si acaso
lactoria@telefonica.net

por cierto el proteus funciona de coña, falta el micocode studio pro especie en estincion

[chechosoft]

No conozco el integrado que estas usando pero la mayoria de los rtc dan el resultado en BCD (por eso llega a 80).
Una vez obtenido el valor desde el rtc la forma de enviarlo al display seria:
lcdout $fe,1,"Seg:",HEX2 (variable con el valor obtenido del rtc).

[lactoria]

No sabes cuanto te agradezco tu ayuda. Ya no sabia que hacer.

Y  pensar que era tan sencilla la solución.

Un saludo. y seguiré con mi proyecto

[litris]

Pero ¿tenéis ya algún esquema con reloj LCD?.

Lo he preguntado por ahí pero nadie contesta, no sabe o es que habrá que hacerse uno a la antigua usanza (Displays).(Lo del ic2 todavía no lo tengo claro.)

Saludos
FELIZ NAVIDAD Y PROSPERO AÑO 2003

[agrofe2]

yo tengo todo lo necesario para hacer funcionar el fantastico dispositivo reloj calendario pcf8583 lo he utilizado con el pic16f84 para hacer un reloj con displays de 7 segmentos y con un LCD pero de 2 hilos I2C concretamente el display de un telefono movil si quieres te paso las rutinas

[agrofe2]

esta es la rutina i2c para hacer funcioar el pcf8583







;**************************************************************************
;                               I2CLOW.INC
;
;         Autor: Mikel Etxebarria
;                    (c) Microsystems Engineering (Bilbao)
;
;Conjunto de rutinas de bajo nivel que permiten la transmisión/recepción
;a nivel de byte entre dispositivos I2C. Igualmente generan las condiciones
;de inicio y de stop así como detectar/generar los bits ACK y NACK. Estas
;rutinas están pensadas para ser utilizadas con elementos de la gama media
;16cXX
;
;                      
;***************************************************************************
;Definición de registros empleados por el software de interface al bus I2C
;con los dispositivos de la gama media 16cxx
;

Clkout          equ     CLKIN >> 2       ;Frecuencia de trabajo (Clkin/4)

_4uS_Delay      set     (Clkout/.250000) ;Constante para 4 uS
_47uS_Delay     set     (Clkout/.212766) ;Constante para 4.7 uS
_5uS_Delay      set     (Clkout/.200000) ;Constante para 5 uS


                CBLOCK  I2c_var ;Reserva de memoria a partir de I2c_var que
                      ;será la primera libre disponible
      DataByte        ;Dato que va a ser transmitido
                BitCount        ;Nº de bits a transmitir/recibir (0
                Bus_status      ;Registro de estado del bus I2C
                Bus_Control     ;Registro de control del bus I2C
                DelayCount      ;Variable de temporización
                DataByteCopy    ;Copia del dato a transmitir
                ENDC            ;Fin de la reserva

;***************************************************************************
;Definición de las líneas del bus I2C
;***************************************************************************

#define _SCL       porta,1
#define _SDA      porta,0
#define _SCL_TRIS       porta,1
#define _SDA_TRIS       porta,0
#define _WRITE_         0
#define _READ_          1

;***************************************************************************
;Definición de los bits del registro de estado del bus I2C
;***************************************************************************

#define _Bus_Busy       Bus_status,0    ;Bus I2C ocupado
#define _Abort          Bus_status,1    ;Comunicación abortada
#define _Txmt_Progreso  Bus_status,2    ;Transmisión en progreso
#define _Rcv_Progreso   Bus_status,3    ;Recepción en progreso
#define _Txmt_Acabada   Bus_status,4    ;Transmisión finalizada
#define _Rcv_Acabada    Bus_status,5    ;Recepción finalizada
#define _Fatal_Error    Bus_status,6    ;Error en comunicación
#define _ACK_Error      Bus_status,7    ;Error en bit ACK

;***************************************************************************
;Definición de los bits del registro de control del bus I2C
;***************************************************************************

#define _Ultimo_Byte    Bus_Control,2   ;Indica si es el último byte a recibir


;**************************************************************************
;               Macro de propósito general
;**************************************************************************

LIBERA_BUS      MACRO
                bsf   status,rp0   ;Selecciona banco 1                
                bsf     _SDA           ;SDA en triestado
                bsf     _SCL            ;SCL en triestado
                bcf   status,rp0   ;Selecciona banco 0 de dato
      bcf   _Bus_Busy
                ENDM

;**************************************************************************
;                               Inicia_Bus
;
;Inicialización del Bus I2C
;**************************************************************************

Inicia_Bus:

                bcf     status,rp0      ;Selecciona página 0 de datos
                ;movf    portb,W         ;Carga puerta B
                ;andlw   0x3f
                movf    porta,W         ;Carga puerta B
                andlw   b"00111100"
      movwf   porta          ;Pone a 0 los latch internos
                                        ;de las líneas SCL y SDA
                LIBERA_BUS              ;Coloca SDA y SCL en triestado
                clrf    Bus_Control     ;Borra registro de control
                clrf    Bus_status      ;Borra registro de estado                
      return

;**************************************************************************
;                       Txt_Start_Bit
;
;Transmisión de la condición de inicio
;**************************************************************************

Txt_Start_Bit:

      bsf     status,rp0      ;Selecciona página 1
                bsf     _SDA            ;Pone como entradas las señales SDA y
                bsf     _SCL            ;SCL que al estar con resistencia
                                       ;pull-up, las líneas SDA y SCL se man-
                                   ;tienen a "1"
                call    Delay4uS
                bcf     _SDA            ;La señal SDA se configura como salida
                                        ;que saca el "0" del latch interno ha-
                                        ;ciendo que la línea SDA caiga a "0"
                                        ;mientras SCL se mantiene a "1" (con-
                                        ;dición de inicio)
                call    Delay47uS
      bcf   status,rp0   ;Selecciona banco 0 de dato
                bsf    _Bus_Busy       ;Activa flag de bus ocupado      
                return

;**************************************************************************
;                               TxT_Stop_Bit
;
;Transmisión de la condición de stop
;**************************************************************************

Txt_Stop_Bit:
                bsf     status,rp0      ;Selecciona página 1 de datos
                bcf     _SCL            ;Las señales SCL y SDA se programan
                bcf     _SDA            ;como salidas. El contenido de los
                                        ;latch internos hace que las líneas
                                        ;SCL y SDA se pongan a "0"

                bsf     _SCL            ;Esta señal se programa ahora como
                                        ;entrada en alta impedancia que, gra-
                                        ;cias a las pull-up internas, pone a
                                        ;"1" la línea SCL.

                call    Delay4uS

                bsf     _SDA            ;Esta señal se programa ahora como
                                        ;entrada en alta impedancia que, gra-
                                        ;cias a las pull-up internas, genera un
                                        ;flanco de subida en la línea SDA (con-
                                        ;dición de stop).

                call    Delay47uS       ;Asegura que no se envía una nueva
                                         ;condición de start justo después de la
                                          ;de stop.
      bcf   status,rp0   ;Selecciona banco 0 de dato
                bcf     _Bus_Busy       ;Tras el stop se considera que el bus
                                        ;está libre, borrando el bit de estado
                return


;**************************************************************************
;                               Txt_Abort
;
;Abortar la transmisión
;**************************************************************************

Txt_Abort:

                call    Txt_Stop_Bit    ;Transmite la condición de stop
                bsf     _Abort          ;Activa flag en registro de estado
                return

;**************************************************************************
;                               Txt_Byte
;
;Transmisión de un byte de datos
;El Byte a transmitir debe cargarse previamente en el registro DataByte
;**************************************************************************

Txt_Byte:

                movf    DataByte,w      ;Realiza una copia del byte a trans-
                movwf   DataByteCopy    ;mitir (pos.0x0e)
                bsf     _Txmt_Progreso  ;Activa flag de transmisión en curso
                bcf     _Txmt_Acabada   ;Desactiva flag de finalización
                movlw   0x08
                movwf   BitCount        ;Número de bits a transmitir
                bsf     status,rp0      ;Selecciona página 1 de datos

TxtNextBit:     clrwdt                  ;Refresco del WDT
                bcf     _SCL            ;Pone a "0" la línea SCL
                rlf     DataByteCopy,f  ;Desplaza bit de más peso
                bcf     _SDA            ;Pone a "0" la l¡nea SDA
                btfsc   status,C        ;Testea bit a sacar sito en el carry
                bsf     _SDA            ;Saca "1" por la línea SDA poniendo
                                        ;la señal SDA como entrada pull-up
                call    Delay47uS
                bsf     _SCL            ;Pone a "1" la línea SCL poniendo
                                        ;la señal SCL como entrada pull-up
                call    Delay4uS
                decfsz  BitCount,f      ;Decrementa contador de bits
                goto    TxtNextBit

;Chequeo del bit ACK

                bcf     _SCL            ;Pone a "0" la línea SCL
                bsf     _SDA            ;Pone a "1" la línea SDA para detec-
                                        ;tar cuándo el slave la pone a "0"
                call    Delay47uS
                bsf     _SCL            ;Pone a "1" línea de reloj
                call    Delay4uS

                bcf     status,rp0      ;Selecciona página 0 de datos
                btfsc   _SDA            ;La señal SDA debe estar a "0" envia-
                                        ;do por el slave
                goto    TxtErrorAck
                bsf     status,rp0      ;Selecciona página 1 de datos
                bcf     _SCL            ;Pone a "0" la línea SCL

                bcf   status,rp0   ;Selecciona banco 0 de dato
      bcf     _Txmt_Progreso  ;Borra flag de transmisión en curso
                bsf     _Txmt_Acabada   ;Activa flag de fin de transmisión
                bcf     _ACK_Error      ;Bit ACK okey
                bcf     _Bus_Busy       ;Flag de que el bus está libre
                return

TxtErrorAck:    LIBERA_BUS              
                bcf     _Txmt_Progreso  ;Borra flag de transmisión en curso
                bcf     _Txmt_Acabada   ;Borra flag de fin de transmisión
                bsf     _ACK_Error      ;Activa bit de error ACK (NACK)
                return

;***************************************************************************
;                               RcvByte
;
;Recepción de un byte desde el slave
;El dato recibido se almacena en el registro DataByte.
;El bit _Ultimo_Byte del registro de control determina si se espera recibir
;más bytes desde el slave, en cuyo caso se le manda ACK o, si es el último,
;en cuyo caso se envía NACK.
;***************************************************************************

RcvByte:
                bsf     _Rcv_Progreso   ;Flag de recepción en curso
                bcf     _Rcv_Acabada    ;Desactiva flag de fin de recepción
                movlw   0x08            ;Carga el contador de bits a recibir
                movwf   BitCount

RcvNextBit:
                clrwdt                  ;Refresco del WDT
                bsf     status,rp0      ;Selección de página 1 de datos
                bcf     _SCL            ;Pone a "0" la línea de reloj
                bsf     _SDA            ;Pone a "1" la línea de datos
                call    Delay47uS
                bsf     _SCL            ;El reloj pasa a "1". El bit de datos
                                        ;es puesto por el slave
                call    Delay4uS

                bcf     status,rp0      ;Seleciona página 0 de datos
                bcf     status,C   ;Pone el flag carry a "0"
                btfsc   _SDA            ;Chequea el nivel en línea de datos
                bsf     status,C   ;Está a "1", activa el carry
                rlf     DataByte,f      ;Desplaza a la izda. (primero el bit
                                        ;de más peso)
                decfsz  BitCount,f      ;Decrementa contador de bits a recibir
                goto    RcvNextBit

;El Master genera ACK si no es el último byte a recibir. Si es el último
;se genera NACK y a continuación se debe generar la condición de stop.

                bsf     status,rp0      ;Selecciona página 1 de datos
                bcf     _SCL            ;Pone a "0" la línea de reloj
                bcf     _SDA            ;Pone a "0" la línea de datos (ACK)
                btfsc   _Ultimo_Byte    ;Determina si es el último byte
                bsf     _SDA            ;Pone a "1" la línea de datos (NACK)
                call    Delay47uS
                bsf     _SCL            ;Pone a "1" la línea de reloj
                call    Delay4uS
                bcf     _SCL            ;Pone a "0" la línea de reloj

                bcf   status,rp0   ;Selecciona banco 0 de dato
      bcf     _Rcv_Progreso   ;Desactiva flag de recepción en curso
                bsf     _Rcv_Acabada    ;Activa flag de fin de recepción
                bcf     _ACK_Error      ; ACK ok
                return

;****************************************************************************
;Rutinas de temporización de propósito general
;****************************************************************************
;
Delay5uS:
                movlw   ((_5uS_Delay-5)/3+1)
delay:
                movwf   DelayCount
                decfsz  DelayCount,f
                goto    $-1
                return

Delay47uS:      movlw   ((_47uS_Delay)-8/3+1)
                goto    delay

Delay4uS:       movlw   ((_4uS_Delay)-8/3+1)
                goto    delay

[agrofe2]

y aqui un programa de ejemplo para display de 7 segmentos donde aparecen minutos y horas la rutina de antes la teneis q llamar I2CPA.inc las patillas del pcf8583 son SDA porta0 del pic SCL porta1 del pic


      List   p=16F84      ;Tipo de procesador
      include   "P16F84.INC"   ;Definiciones de registros internos
      CONStANt VARS=0CH
      __CONFIG        3FF9H   ; Xt oscillator

CLKIN      equ   .4000000   ;Frecuencia de trabajo
                 
I2c_var      equ   0x0c      ;Inicio de las variables para rutinas I2C_LOW   
Key_var      equ   0x12      ;Inicio de las variables de manejo del teclado
Digito_1   equ   0x18
Digito_2   equ   0x19
Digito_3   equ   0x1a      
Digito_4   equ   0x1b      ;buffer de salida al SAA1064 de los 4 dígitos
N_Bytes      equ   0x1c      ;Número de bytes a leer
Dir_Ini      equ   0x1d      ;Dirección inicial a leer
buffer      equ   0x20      ;Inicio del buffer donde se depositan los bytes leídos
PDel0   equ   VARS+15
PDel1   equ   VARS+16
PDel2   equ   VARS+12
unidades   equ   VARS+13
decenas      equ   VARS+21
var3   equ   VARS+22
uni_minutos   equ   0x1f
dec_minutos   equ   VARS+26
var2   equ   VARS+19
var1   equ   VARS+27
var4   equ   VARS+28
STATUS   EQU   0X03

      cblock   0x29      ;Variables de la aplicación
      Centesimas      
      Segundos      
      minutos   
      minutos2
      minutos3
      unid_minutos      
      horas
      horas2
      horas3
      unid_horas
      es_24
      es_1a
      es_0a
      m_0a
      m_1a
      m_2a
      m_3a
      m_4a
      m_59         
      logico         
      logico1         
      Temp_1         
      Flags            
      endc


      
      org   0x00      ;Vector de reset
      goto   Inicio
      org   0x05      ;Salvar el vector de interrupción   

      include   "I2CPA.INC"   ;Incluye las rutinas de manejo del bus I2C
         


;*******************************************************************************************
;Lectura: Esta rutina lee desde el dispositivo PCF8583 tantos byte como indique la variable
;N_Bytes a partir de la dirección indicada por la variable Dir_Ini. Los bytes leidos se depo-
;sitan a partir del inicio del buffer (posición 0x30).

Lectura      movlw   buffer
      movwf   FSR      ;Inicia el buffer de recepción
      call   Inicia_Bus   ;Inicia líneas del bus I2C
      call   Txt_Start_Bit   ;Transmite secuencia de Inicio
      movlw   b"10100000"
      movwf   DataByte      
      call   Txt_Byte   ;Transmite dirección del dispositivo (escritura)
      movf   Dir_Ini,W
      movwf   DataByte
      call   Txt_Byte   ;Transmite dirección inicial a leer
      call   Txt_Start_Bit   ;Transmite secuencia de inicio
      movlw   b"10100001"
      movwf   DataByte
      call   Txt_Byte   ;Transmite dirección del dispositivo (lectura)
Lectura_1   decfsz   N_Bytes,F
      goto   Lec_no_fin
      goto   Lec_fin

Lec_no_fin   bcf   _Ultimo_Byte   ;Indica que no es el último byte a leer
      call   RcvByte      ;Recibe un byte
      movf   DataByte,W
      movwf   INDF      ;Lo almacena en el buffer
      incf   FSR,F      ;Apunta a la siguiente dirección del buffer
      goto   Lectura_1   ;Siguiente byte a leer

Lec_fin      bsf   _Ultimo_Byte   ;Indica que es el último byte a leer
      call   RcvByte      ;Recibe el último byte
      movf   DataByte,W
      movwf   INDF      ;Lo guarda en el buffer
      call   Txt_Stop_Bit   ;Envía secuencia de stop
      return

;*************************************************************************************
;
      
Inicio      clrf   porta
      clrf   portb
      
      bsf   status,rp0   ;Selecciona página 1 de datos
      movlw   b"00011100"
      movwf   trisa      ;RA2-RA4 entradas
      movlw   b"00000000"
      movwf   trisb   
      
      movlw   b"10000110"   ;Preescaler de 128 para el TMR0. Pull_Up Off
      movwf   option_reg            
      bcf   status,rp0   ;Selecciona página 0 de datos   

mira
      btfss    porta,3
      goto    mira2
      goto    restaura0
restaura0   
      movf   es_0a,w
      xorlw   h"9"
      btfss   STATUS,Z
      goto    restaura1
      movlw   h"0f"
      movwf   logico
      call   escribe_hora

restaura1   xorlw   h"0a"
      movwf   es_0a
      movf   es_1a,w
      xorlw   h"19"
      btfss   STATUS,Z
      goto    restaura2
      movlw   h"1f"
      movwf   logico
      call   escribe_hora      
restaura2   
      xorlw   h"1a"
      movwf   es_1a
      movf   es_24,w
      xorlw   h"23"
      btfss   STATUS,Z
      goto    incrementa
      movlw   h"ff"
      movwf   logico
      call   escribe_hora
incrementa
      incf   logico,F
      call    escribe_hora

      
mira2      
      btfss porta,4
      goto inicia
      goto restaura0b

restaura0b
      movf   m_0a,w
      xorlw   h"9"
      btfss   STATUS,Z
      goto    restaura1b
      movlw   h"0f"
      movwf   logico1
      call   escribe_minuto

restaura1b
      xorlw   h"0a"
      movwf   m_0a
      movf   m_1a,w
      xorlw   h"19"
      btfss   STATUS,Z
      goto    restaura2b
      movlw   h"1f"
      movwf   logico1
      call   escribe_minuto



      
restaura2b
      xorlw   h"1a"
      movwf   m_1a
      movf   m_2a,w
      xorlw   h"29"
      btfss   STATUS,Z
      goto    restaura3b
      movlw   h"2f"
      movwf   logico1
      call   escribe_minuto

restaura3b
      xorlw   h"2a"
      movwf   m_2a
      movf   m_3a,w
      xorlw   h"39"
      btfss   STATUS,Z
      goto    restaura4b
      movlw   h"3f"
      movwf   logico1
      call   escribe_minuto
restaura4b
      xorlw   h"3a"
      movwf   m_3a
      movf   m_4a,w
      xorlw   h"49"
      btfss   STATUS,Z
      goto    restaura5b
      movlw   h"4f"
      movwf   logico1
      call   escribe_minuto   
restaura5b
      xorlw   h"4a"
      movwf   m_4a
      movf   m_59,w
      xorlw   h"59"
      btfss   STATUS,Z
      goto    incrementa2
      movlw   h"ff"
      movwf   logico1
      call   escribe_minuto   
incrementa2
      incf   logico1,F
      call    escribe_minuto
      

inicia
      call   Inicia_Bus   ;Inicia el bus I2C
   
loop      clrwdt         ;Refresca el WDT
      movlw   h"1"
      movwf   Dir_Ini      ;Dirección inicial a leer (la 1)
      movlw   h"8"
      movwf   N_Bytes      ;Número de bytes a leer (
      call   Lectura      ;Lectura del dispositivo PCF8583
      
      movf   buffer+2,w   
      movwf   var1      ;mueve lo q hay en buffer+1 (segundos)
      movwf   var2
      movwf   minutos
      movwf   m_0a      ;a var1 y var2
      movwf   m_1a
      movwf   m_2a
      movwf   m_3a
      movwf   m_4a
      movwf   m_59
      movf   var1,w      ;multiplica var1 por 00001111 el  
      andlw   b"00001111"   ;resultado es 0000xxxx
      movwf   unidades        ;pasa lo q te de a"unidades" y al portb
      movwf    portb
      bcf   portb,7
      bsf   portb,4
      bcf    portb,6      ;pon a 1 pb7 señalizador de unidades de
      bcf   portb,5      ;segundo
            
      call    t1   
      movf   var2,w
      andlw   b"11110000"   ;multiplica var2 por 11110000 el  
      movwf   decenas      ;resultado es xxxx0000
      swapf    decenas,w   ;cambia de sitio los bits resultado es
      movwf   unid_minutos
      movwf    portb      ;0000xxxx visualizalo en portb
      bcf    portb,4
      bsf   portb,5
      bcf   portb,7      ;pon a 1 pb7 señalizador de decenas de
      bcf    portb,6      ;segundo
      call t1

loop2      clrwdt         ;Refresca el WDT
      movlw   h"1"
      movwf   Dir_Ini      ;Dirección inicial a leer (la 1)
      movlw   h"8"
      movwf   N_Bytes      ;Número de bytes a leer (
      call   Lectura
      movf   buffer+3,w
      movwf   var3
      movwf   var4
      movwf   horas
      movwf   es_24
      movwf   es_1a
      movwf   es_0a
      movf   var3,w
      andlw   b"00001111"
      movwf    portb
      bcf   portb,5
      bsf    portb,6
      bcf   portb,7
      bcf   portb,4
      movf   portb,w
      movwf   unid_horas

      call    t1   
      movf   var4,w
      andlw   b"11110000"
      movwf   dec_minutos
      swapf    dec_minutos,w
      movwf    portb
      bcf    portb,6
      bsf   portb,7
      bcf   portb,5
      
      bcf    portb,4
      call t1
      goto mira
      

escribe_hora
      call t500ms
      clrf   Flags
      call   Inicia_Bus   ;Inicia las líneas del bus I2C
      call   Txt_Start_Bit   ;Envía secuencia de inicio
      movlw   b"10100000"
      movwf   DataByte
      call   Txt_Byte   ;Transmite dirección del dispositivo (escritura)
      clrf   DataByte
      movlw   .10      ;si hay hasta n6 aqui un numero mas osea 7
      movwf   Temp_1      ;Nº de bytes a enviar al dispositivo
n1   
      call   Txt_Byte
      clrf   DataByte        
      decfsz   Temp_1,F
      goto   n2            
      goto   fin

n2      call   Txt_Byte        ;centesimas de segundo
      decfsz   Temp_1,F
      clrf   DataByte        
      goto   n3            
      goto   fin

n3      call   Txt_Byte        ;segundos
      decfsz   Temp_1,F
      movlw   h"0"
      movwf   DataByte      
      goto   n4            
      goto   fin

n4      call   Txt_Byte        ;minutos
      decfsz   Temp_1,F
      movf   minutos,w
      movwf   DataByte      
      goto   n5            
      goto   fin
      
n5      call   Txt_Byte        ;horas
      decfsz   Temp_1,F
      movf   logico,w
      movwf   DataByte          
      goto   n6            
      goto   fin

n6      call   Txt_Byte        ;numero del dia
      decfsz   Temp_1,F
      movlw   h"28"
      movwf   DataByte          
      goto   n7            
      goto   fin

n7      call   Txt_Byte        ;dia de la semana dom/lun/mar/mier/jue/vie/sab
      decfsz   Temp_1,F   ;
      movlw   h"2"
      movwf   DataByte          
      goto   n8            
      goto   fin

n8      call   Txt_Byte        ;mes
      decfsz   Temp_1,F
      movlw   h"12"
      movwf   DataByte          
      goto   n9            
      goto   fin

n9      call   Txt_Byte        ;año 2003 = h"03"
      decfsz   Temp_1,F
      movlw   h"03"
      movwf   DataByte          
      goto   n1            
      goto   fin


escribe_minuto

      call t500ms
      clrf   Flags
      call   Inicia_Bus   ;Inicia las líneas del bus I2C
      call   Txt_Start_Bit   ;Envía secuencia de inicio
      movlw   b"10100000"
      movwf   DataByte
      call   Txt_Byte   ;Transmite dirección del dispositivo (escritura)
      clrf   DataByte
      movlw   .10      ;si hay hasta n6 aqui un numero mas osea 7
      movwf   Temp_1      ;Nº de bytes a enviar al dispositivo
n1b   
      call   Txt_Byte
      clrf   DataByte        
      decfsz   Temp_1,F
      goto   n2b            
      goto   fin

n2b      call   Txt_Byte        ;centesimas de segundo
      decfsz   Temp_1,F
      clrf   DataByte        
      goto   n3b            
      goto   fin

n3b      call   Txt_Byte        ;segundos
      decfsz   Temp_1,F
      movlw   h"0"
      movwf   DataByte      
      goto   n4b            
      goto   fin

n4b      call   Txt_Byte        ;minutos
      decfsz   Temp_1,F
      movf   logico1,w
      movwf   DataByte      
      goto   n5            
      goto   fin
      
n5b      call   Txt_Byte        ;horas
      decfsz   Temp_1,F
      movf   horas,w
      movwf   DataByte          
      goto   n6b            
      goto   fin

n6b      call   Txt_Byte        ;numero del dia
      decfsz   Temp_1,F
      movlw   h"28"
      movwf   DataByte          
      goto   n7b            
      goto   fin

n7b      call   Txt_Byte        ;dia de la semana dom/lun/mar/mier/jue/vie/sab
      decfsz   Temp_1,F   ;
      movlw   h"2"
      movwf   DataByte          
      goto   n8b            
      goto   fin

n8b      call   Txt_Byte        ;mes
      decfsz   Temp_1,F
      movlw   h"12"
      movwf   DataByte          
      goto   n9b            
      goto   fin

n9b      call   Txt_Byte        ;año 2003 = h"03"
      decfsz   Temp_1,F
      movlw   h"03"
      movwf   DataByte          
      goto   n1b            
      goto   fin
fin
      return               
               ;buffer+1=segundos
               ;buffer+2=minutos
               ;buffer+3=horas
               ;buffer+4=año fecha
      

lee_eep
      
      incf   FSR,f
      movf   INDF,w
      movwf   portb
      
      call t1   
      goto   lee_eep


;t1 =3 ms
t1    
   movlw     .4        ; 1 set number of repetitions (B)
        movwf     PDel0     ; 1 |
PLoop1  movlw     .186      ; 1 set number of repetitions (A)
        movwf     PDel1     ; 1 |
PLoop2  clrwdt              ; 1 clear watchdog
        decfsz    PDel1, 1  ; 1 + (1) is the time over? (A)
        goto      PLoop2    ; 2 no, loop
        decfsz    PDel0,  1 ; 1 + (1) is the time over? (B)
        goto      PLoop1    ; 2 no, loop
PDelL1  goto PDelL2         ; 2 cycles delay
PDelL2  clrwdt              ; 1 cycle delay
        return              ; 2+2 Done


t500ms
   movlw     .197      ; 1 set number of repetitions (B)
        movwf     PDel0     ; 1 |
PLoop11  movlw     .253      ; 1 set number of repetitions (A)
        movwf     PDel1     ; 1 |
PLoop21  clrwdt              ; 1 clear watchdog
        clrwdt              ; 1 cycle delay
        decfsz    PDel1, 1  ; 1 + (1) is the time over? (A)
        goto      PLoop21    ; 2 no, loop
        decfsz    PDel0,  1 ; 1 + (1) is the time over? (B)
        goto      PLoop11    ; 2 no, loop
PDelL11  goto PDelL21        ; 2 cycles delay
PDelL21  
        return              ; 2+2 Done



                    end   

[lager]

Para hacer un reloj con LCD (display de cristal liquido) el compañero MGLSOFT subio un proyecto buenisimo que yo te recomiendo  es el siguiente:
****************************************************************
"*  Name    : UNTITLED.BAS                                      *
"*  Author  : Marcos Lazcano - MGLSOFT                          *
"*  Notice  : Copyright (c) 2003 - MGLSOFT                      *
"*          : All Rights Reserved                               *
"*  Date    : 14/05/03                                          *
"*  Version : 1.0                                               *
"*  Notes   : Este es un reloj con PIC, utilizando la interrup- *
"*          : cion para generar el incremento de los conteos.   *
"*          : Dispone de cuatro teclas para la puesta en hora.  *
"****************************************************************

" Define registros del LCD y bits
DEFINE  LCD_DREG        PORTA
DEFINE  LCD_DBIT        0
" Primer bit de datos en PortA.0 , en modo a 4 bits
DEFINE  LCD_RSREG       PORTB
DEFINE  LCD_RSBIT       0
" Señal del LCD RS en PortB.6
DEFINE  LCD_EREG        PORTB
DEFINE  LCD_EBIT        1
" Señal del LCD Enable en PortB.7

" Grupo de variables tipo Byte
Hora    var byte    " Variable con el dato de la hora.
DispH   var byte    " Hora a mostrar en el display.
Minuto  var byte    " Variable con el dato de los minutos.
Seg     var byte    " Variable con el dato de los segundos.
TicTac  var byte    " Variable con las fracciones de segundo.
Actual  var bit     " Bandera de actualizacion del display.
i       var byte    " Variable para retardos teclado.

"definicion del teclado
DecMin  var PORTB.7     "Tecla decrementar minutos
IncMin  var PORTB.6     "Tecla incrementar minutos
DecHora var PORTB.5     "Tecla decrementar hora
IncHora var PORTB.4     "Tecla incrementar hora

        clear       "borrar variables
        pause 300   " espera reactivacion display LCD
        Actual = 1  "fuerza actualizacion del display
       
"seteo del TMR0 para interrupcion cada 16.384 milisegundos
        OPTION_REG =$55     "Configura TMR0 y habilita PullUps
        INTCON = $A0        "Habilita interrupciones
        on interrupt goto Interr
       
Principal:
        PORTB = 0   "lineas en bajo para leer pulsadores
        TRISB = $f0 "habilita los pulsadores
       
        "chequea los pulsadores
        if DecMin = 0 then baja_min
        if IncMin = 0 then sube_min
        if DecHora = 0 then baja_hora
        if IncHora = 0 then sube_hora

"chequeo para ver si hay que actualizar display
Chequeo:
        if Actual = 1 then
            lcdout $fe, 1   "borra display
            "hora en formato hh:mm:ss
            DispH = Hora    "cambia hora entre 0 y 12
            if (Hora // 12) = 0 then
                    DispH = DispH + 12
            endif
           
            "chequea si es AM o PM
            if Hora < 12 then
                lcdout dec2 DispH,":", dec2 Minuto,":", dec2 Seg,"AM"
            else
                lcdout dec2 (DispH - 12),":", dec2 Minuto,":", dec2 Seg,"PM"
            endif
            Actual = 0  "display ya esta actualizado
        endif
       
        goto Principal  "loop infinito
"Rutinas
baja_min:
        Minuto = Minuto - 1
        if Minuto >= 60 then
            Minuto = 59
        endif
        goto Debounce
       
sube_min:
        Minuto = Minuto + 1
        if Minuto >= 60 then
            Minuto = 0
        endif
        goto Debounce

baja_hora:
        Hora = Hora - 1
        if Hora >= 24 then
            Hora = 23
        endif
        goto Debounce
       
sube_hora:
        Hora = Hora + 1
        if Hora >= 24 then
            Hora = 0
        endif
        goto Debounce
       
Debounce:
        for i = 1 to 25
            pause 10    "con 10 milisegundos no se perderan interrupciones
        next i
       
        Actual = 1      "actualizar display
       
        goto Chequeo

"rutina de interrupcion
    disable
Interr:
        TicTac= TicTac + 1
        if TicTac < 61 then SalirTic
        "paso un segundo, actualizar tiempo
        TicTac = 0
        Seg = Seg + 1
        if Seg >= 60 then
            Seg = 0
            Minuto = Minuto + 1
            if Minuto >= 60 then
                Minuto = 0
                Hora = Hora + 1
                if Hora >= 24 then
                    Hora = 0
                endif
            endif
        endif
        Actual = 1
SalirTic:
        INTCON.2 = 0    "resetea flag de interrupcion del timer
    resume
   
    end
             
       
analizalo y revisalo, si quieres bajarlo con la simulacion en Proteus, pidele a MGLSOFT que te diga donde lo subio,
y aprovecho para agradecerle a MGLSOFT este excelente programa
Saludos

Baygon!

Una razon mas para migrar a PBP PLUS!!

[Carlos_Gomez]

aqui tienen un ejemplo en pbp usando el pcf8583
  un saludo y suerte
  carlos