Problemas para escribir en la EEPROM y las interruciones

[rhochoa]

Saludos amigos, nuevamente solicito su ayuda en un problema que estoy teniendo para escribir en la memoria EEPROM.
Me explico mejor para darme a entender
estoy intentando recibir datos y guardarlos en la EEPROM, pero para poder recibir los datos debí habilitar las interrupciones y esto me esta causando problemas he intentado desabilitar las interrupciones al principio de la escritura y luego habilitarlas al final pero igual me sigue dando problemas.

Coloco solo las subrutinas que estoy utilizando ya que el programa es un poco largo


 Esta es mi rutina de interrupciones
; ###########################################################################
;                        INTERRUPCION
; ###########################################################################
   ORG 0x04 ;Aqui defines acciones de las interrupciones
   ;################### SALVAR LOS ESTADOS################################
   movwf TEMP_W
   swapf STATUS,w
   movwf TEMP_STATUS
   bcf STATUS,RP0
   swapf FSR,W
   movwf TEMP_FSR
   ;###################### RUTINA DE INTERRUPCION ########################
   btfss PIR1,RCIF
   goto $-1
   movfw RCREG
   bcf PIR1,RCIF
   
   ;################### RESTAURAR  LOS ESTADOS############################
   swapf TEMP_FSR,w
   movwf FSR
   swapf TEMP_STATUS,w
   movwf STATUS
   swapf TEMP_W,w
   return


 para escritura de la EEPROM

 REGISTROS USADOS: EEADR=direccion ,EEDATA=data
wrmem
   BANK_0               ;
   bcf      INTCON,GIE      ;deshabilita la interrupciones
   BANK_3               ;
   bcf      EECON1,EEPGD   ;apunta a la memoria de datos
   bsf      EECON1,WREN      ;Habilita la escritura
   movlw   0x55         ;
   movwf   EECON2         ;
   movlw   0xAA         ;
   movwf   EECON2         ;
   bsf      EECON1,WR      ;habilita para iniciar la escritura
   btfsc   EECON1,WR      ;
   goto   $-1            ;
   BANK_0            ;banco 0
   bsf      INTCON,GIE   ; Habilita las interrupciones

   return               ;


 Este es el programa principal que planteo
Inicio
; #############Recibir y escribir en la EEPROM##################################################
prueba
   movlw .5
   movwf t1
   movlw 0x00
   movwf t0
   nop
   incf t0,1
   btfss PIR1,RCIF
   goto $-1
   call receive
   BANK_2
   movwf EEDATA
   movfw t0
   movwf EEADR
   call wrmem
   call send
   decfsz t1
   goto $-10
   goto prueba

 Si alguien me puede ayudar y decir donde esta elk fallo o que estoy haciendo mal estaría muy agradecido.
saludos y muchas gracias de antemano
   

[KILLERJC]

Cosas raras que veo en el codigo:

Código: ASM

1. ;###################### RUTINA DE INTERRUPCION ########################
2.    btfss PIR1,RCIF
3.    goto $-1
4.    movfw RCREG
5.    bcf PIR1,RCIF

No deberia ser asi... no deberias tener jamas un bucle infinito por mas que no se quede alli jamas. Otra cosa es que al leer RCREG se borra el flag RCIF por si solo.

Otra cosa mas que veo mal ahi, realmente siempre vi la instruccion MOVF  registro, W y nunca MOVFW, pero supongamos por un momento que esa instruccion existe. Y lo llevas a W, luego cuando salis y restoras el contexto, es decir restoras W a lo que era antes de entrar a la interrupcion, ese valor se pierde. Y deberias ponerlo en un registro a ese valor.

Código: ASM

1. btfss PIR1,RCIF
2.    goto $-1
3.    call receive
4.    BANK_2
5.    movwf EEDATA

Si tenes una interrupcion que al leer el dato va a limpiar el flag, entonces no saldria nunca de ese loop, siempre quedaria encerrado alli, ya que cuando se pone en 1 entrar a la interrupcion, lee, se pone a 0, y vuelve ahi siguiendo en 0 el RCIF.

Y por lo que se ve, esperas que en W este el dato, lo cual no es asi por lo que explique antes.

Código: ASM

1. goto $-10

Me parece todo bien cuando es 1, 2 o 3. Pero ya en ese extremo mejor usar una etiqueta como lo es "wrmem" y "prueba", ya que con esas cantidades lo unico que haces es complicar la lectura y no facilitarla, distinto a una distancia de 1 a 3 que no es necesario contarlas casi.

[rhochoa]

Saludos, KILLERJC gracias por tus consejos y observaciones, realmente lo he utilizado a asi porque ese código de la interrupción me sirvió para recibir datos de forma serial  rs-232 por un puerto db-9, era proveniente de un gps y realmente era muchos caracteres.

en atencion a tus observaciones voy a intentar modificar el codigo de la interrupción
estaba pensando en aprovechar que la interrupción  entra cuando hay un 1, luego pasar ese dato a un registro e intentar desde ese registro guardarlo en la EEPROM.
seria mas o menos así.

btfss PIR1,REIF
movfw RCREG    ;(movfw  funciona, siempre lo uso)
movwf registro   ; luego este registro lo voy a direccionar a la eeprom

Queria aprovechar para hacerte esta pregunta, si yo estoy desabilitando las interrupciones
(bcf      INTCON,GIE      ;deshabilita la interrupciones), antes de escribir el la eemprom como esta en la subrrutina que mostre, no entiendo porque me causa interferencia a la hora de escribir, existe una forma evitar que esto ocurra?

[KILLERJC]

El procedimiento que tenes que hacer es:

En la interrupcion:

Guardar el dato recibido en un registro, activar un bit de algun registro para indicar que llego el dato.

En el programa principal:

Leer el bit por si llego un dato, si llego procedo a grabar el dato en la EEPROM y borrar el bit antes de activar las interrupciones. Esto suponiendo que el loop principal sea lo suficientemente corto para que no ocurran 2 interrupciones antes que se lea el bit ese.

------------------

(bcf      INTCON,GIE      ;deshabilita la interrupciones), antes de escribir el la eemprom como esta en la subrrutina que mostre, no entiendo porque me causa interferencia a la hora de escribir, existe una forma evitar que esto ocurra?

A que te referis con "interferencia" ? Vas a deshabilitar el la interrupcion, grabar, y volverla a activar, una ves activa si llego un dato mientras estuvo desactivada, va a entrar a la interrupcion.
Si no llego nada entonces seguira su camino.

[rhochoa]

Saludos KILLERJC, gracias por tus recomendaciones de nuevo fueron de mucha ayuda,
al final no utilice las interrupciones sino que lo que recibo lo guardo  indirectamente en INDF y luego lo paso a la EEPROM, porque directamente no lo logre, aun quedan muchas cosas por hacer ya que lo que estoy diseñando es algo extenso.
Por los momentos me despido muy  agradecido