Publicado por: BrunoF en 21 de Marzo de 2006, 20:36:00
Aca posteo lo que programe(he sudado bastante pa lograrlo) para leer y escribir una EEPROM de 8kbits(24LC08B) desde un 16F877A en Assembler a FOSC = 20Mhz utilizando el modulo I2C de este PIC.
Lo que hace es grabar un dato en la posicion 0 de la EEPROM , y luego leerlo y mostrar el dato leido en el PuertoB del PIC.
]<span class="texto_mini">Codigo:</span>[hr /
;Made by Bruno Fascendini
;bipus24hs@hotmail.com
LIST P=PIC16F877A
#include <p16F877a.INC>
ERRORLEVEL -302
;////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
; CONSTANTES:
;////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
#define CLOCK D"0"
#define STROBE D"2"
#define SCL D"3"
#define SDA D"4"
;////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
;Memoria EEPROM
;////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
;////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
; MACROS
;////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
BANK0 MACRO
BCF STATUS,RP0
BCF STATUS,RP1
ENDM
BANK1 MACRO
BSF STATUS,RP0
BCF STATUS,RP1
ENDM
BANK2 MACRO
BSF STATUS,RP1
BCF STATUS,RP0
ENDM
BANK3 MACRO
BSF STATUS,RP1
BSF STATUS,RP0
ENDM
;GPR: GENERAL PURPOSE REGISTERS
;0x20 -> 0x47 Reservados Memoria cartel.
;////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
DIRL EQU 0X20
DIRH EQU 0X21
DATO EQU 0X22 ;temporar. byte a enviar/dato leido
flag EQU 0X24
cuenta EQU 0X25
CONTA0 EQU 0X26
CONTA1 EQU 0X27
DATASSP EQU 0x70
;////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
ORG 0X0000
GOTO INICIO
ORG 0X0004
return
ORG 0X0020
INICIO BANK0
BSF STATUS,RP0
MOVLW 0x06 ;PINS DEL PUERTO A Y PUERTO E TODOS DIGITALES.
MOVWF ADCON1
CLRW
MOVWF TRISA
BANK0
CLRF PORTA
BSF STATUS,RP0
MOVLW 0X00
MOVWF TRISB
BANK0
CLRF PORTB
BSF STATUS,RP0
MOVLW B"00011000"
MOVWF TRISC
BANK0
MOVLW B"00010000"
MOVWF PORTC
BSF STATUS,RP0
MOVLW 0X00
MOVWF TRISD
BANK0
CLRF PORTD
BSF STATUS,RP0
MOVLW 0X00
MOVWF TRISE
BANK0
CLRF PORTE
call i2c_init ;configurar y encender I2C
clrf DIRH ;cargar paginas de 24LC08B en las cuales escribir
clrf DIRL ;cargar direccion de 24LC08B en las cuales escribir
movlw 0xA0
movwf DATASSP ;cargar dato a escribir en la 24LC08B
call WriteI2CByte
btfss flag,0
goto errorcom
call DEMORA ;dar 10ms a que termine la escritura
clrf DIRH ;cargar paginas de 24LC08B de las cuales leer
clrf DIRL ;cargar direccion de 24LC08B de las cuales leer
call ReadI2CByte
btfss flag,0
goto errorcom
movlw .1 ;escritura y lectura OK. encender RA0, mostrar dato leido en PuertoB y loop eterno
movwf PORTA
movf DATO,w
movwf PORTB
nop
goto $-1
errorcom movlw .3 ;error de escritura o lectura, encender RA0 y RA1 y loop eterno
movwf PORTA
nop
goto $-1
;////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
DEMORA
movlw .55
movwf CONTA0
RET1
movlw .181
movwf CONTA1
RET2
nop
nop
decfsz CONTA1,1
goto RET2
decfsz CONTA0,1
goto RET1
return
;////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
i2c_init
movlw b"00011000"
banksel TRISC ;banco 1
iorwf TRISC,F
movlw b"00001011" ;.11 para 400khz @ 20 mhz
movwf SSPADD ;400 khz @ 20 mhz
clrf SSPSTAT
movlw b"00101000"
bcf STATUS,RP0 ;banco 0
movwf SSPCON
CLRF PIR1
call i2c_idle
return
;////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
i2c_idle
bsf STATUS,RP0 ;banco 1
btfsc SSPSTAT,R_W
goto $-1
movf SSPCON2,w
andlw 0x1F
btfss STATUS,Z
goto $-3
bcf STATUS,RP0 ;banco 0
return
;////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
i2c_start
call i2c_idle
bsf STATUS,RP0 ;banco 1
bsf SSPCON2,SEN
btfsc SSPCON2,SEN
goto $-1
bcf STATUS,RP0 ;banco 0
btfss PIR1,SSPIF
goto $-1
bcf PIR1,SSPIF
return
;////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
i2c_restart
bsf STATUS,RP0 ;banco 1
bsf SSPCON2,RSEN
btfsc SSPCON2,RSEN
goto $-1
bcf STATUS,RP0 ;banco 0
return
;////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
i2c_read
call i2c_idle
bsf STATUS,RP0 ;banco 1
bsf SSPCON2,RCEN ;activar modo lectura
btfsc SSPCON2,RCEN ;termino la recepcion?
goto $-1 ;no, esperar
btfss SSPSTAT,BF ;dato disponible en SSPBUF para ser leidos?
goto $-1 ;no, esperar
bcf STATUS,RP0 ;banco 0
movf SSPBUF,W
movwf DATO
return
;////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
i2c_write
bcf flag,0 ;inicializar flag como "error"
call i2c_idle
movf DATO,w ;mover DATO a W
movwf SSPBUF ;cargar dato en buffer I2C
bsf STATUS,RP0 ;banco 1
btfsc SSPSTAT,R_W ;esperar a que termine el envio
goto $-1
btfss SSPCON2,ACKSTAT ;checkear ack
goto okack
bsf SSPCON2,PEN ;error ack. enviar STOP
bcf STATUS,RP0 ;banco 0
return ;volver con flag= 0 error
okack bcf STATUS,RP0 ;banco 0
btfss PIR1,SSPIF ;esperar finalizacion del noveno clock
goto $-1
bcf PIR1,SSPIF
bsf flag,0 ;volver con flag = 1 OK!
return
;////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
i2c_sendack
bsf STATUS,RP0 ;banco 1
bcf SSPCON2,ACKDT
bsf SSPCON2,ACKEN
bcf STATUS,RP0 ;banco 0
return
;////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
i2c_sendnack
bsf STATUS,RP0 ;banco 1
bsf SSPCON2,ACKDT
bsf SSPCON2,ACKEN
bcf STATUS,RP0 ;banco 0
return
;////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
i2c_stop
bsf STATUS,RP0 ;banco 1
bsf SSPCON2,PEN ;enviar STOP
bcf STATUS,RP0 ;banco 0
return
;////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
;WriteI2CByte
;DIRH<1:0> ;paginas de la eeprom en las cuales grabar
;DIRL ;direccion baja de la posicion de eeprom en las cuales grabar
;DATASSP ;dato a grabar
;////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
WriteI2CByte
call i2c_start ;enviar START, esperar a que se libere el BUS
rlf DIRH,W
andlw b"00000110" ;solo 2 bits de paginas admitidas para esta eeprom. Asegurar bit0 =0 (write)
iorlw b"10100000" ;insertar identificador de la EEPROM(1010) en el mensaje
movwf DATO ;cargar byte en variable a enviar(DATO)
call i2c_write
btfss flag,0
return ;volver. error de escritura
movf DIRL,w
movwf DATO
call i2c_write
btfss flag,0
return ;volver. error de escritura
movf DATASSP,w
movwf DATO ;cargar en DATO
call i2c_write
btfss flag,0
return ;volver. error de escritura
call i2c_stop
return ;flag = 1 OK!
;////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
;ReadI2CByte
;DIRH<1:0> ;paginas de la eeprom de las cuales leer
;DIRL ;direccion baja de la posicion de eeprom de las cuales leer
;devuelve:
;DATO ;dato leido
;////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
ReadI2CByte
call i2c_start ;enviar START, esperar a que se libere el BUS
rlf DIRH,W
andlw b"00000110" ;solo 2 bits de paginas admitidas para esta eeprom. Asegurar bit0 =0 (write)
iorlw b"10100000" ;insertar identificador de la EEPROM(1010) en el mensaje
movwf DATO ;cargar byte en variable a enviar(DATO)
call i2c_write
btfss flag,0
return ;volver. error de escritura
movf DIRL,w
movwf DATO
call i2c_write
btfss flag,0
return ;volver. error de escritura
call i2c_restart ;enviar RESSTART
rlf DIRH,W
andlw b"00000110" ;solo 2 bits de paginas admitidas para esta eeprom.
iorlw b"10100001" ;insertar identificador de la EEPROM(1010) en el mensaje. Asegurar bit0 =1 (Read)
movwf DATO ;cargar byte en variable a enviar(DATO)
call i2c_write
btfss flag,0
return ;volver. error de escritura
call i2c_read
call i2c_sendnack
call i2c_stop
return ;flag = 1 OK!
;////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
END
Espero les sea de utilidad. Exitos!
Publicado por: Chaly29 en 22 de Marzo de 2006, 06:43:00
Un saludo
Publicado por: groundman en 11 de Mayo de 2008, 17:19:30
movf DATASSP,w
ya que DATASSP la has definido como un valor y aqui la has utilizado como un registro.
esta en el subprograma WriteI2CByte.
creo que deberia poner :movf SSPBUF,w
saludos
Publicado por: BrunoF en 11 de Mayo de 2008, 19:43:31
Si. es un error(y grave) ya que estaria trabajando sobre el registro del TMR0
Igualmente deberia compilar pese a eso.
Saludos y gracias.
Publicado por: RALF2 en 12 de Mayo de 2008, 22:35:18
BrunoF muy bueno el ejemplo yo hice algo similar ya hace tiempo utilizando para ello el i2c por hardware del pic16f876A. :D
Una observacion que pudiese facilitar las cosas a la hora de seleccionar los bancos :mrgreen:
Veo que creaste varios macros para la seleccion de los bancos ,pero, hay una instruccion que trae el mplab que se llama BANKSEL que te facilita enormemente el manejo de los bancos :mrgreen:
Saludos
Publicado por: BrunoF en 13 de Mayo de 2008, 01:49:03
Que tal amigos!
BrunoF muy bueno el ejemplo yo hice algo similar ya hace tiempo utilizando para ello el i2c por hardware del pic16f876A. :D
Una observacion que pudiese facilitar las cosas a la hora de seleccionar los bancos :mrgreen:
Veo que creaste varios macros para la seleccion de los bancos ,pero, hay una instruccion que trae el mplab que se llama BANKSEL que te facilita enormemente el manejo de los bancos :mrgreen:
Saludos
Bueno, si...existe BANKSEL y BANKSELW para la selección de bancos en MPLAB, pero si te fijas en el programa, solo uso las macros al inicio del programa y no en el resto del código. Se podría cambiar. Gracias.
Saludos.
Publicado por: tapi8 en 13 de Mayo de 2008, 15:32:00
Gracias Bruno me va a ser de utilidad.
saludos
Publicado por: groundman en 14 de Mayo de 2008, 11:01:42
saludos.
Publicado por: groundman en 14 de Mayo de 2008, 16:33:17
y es que creo que tiene varios errores.
he encontrado otro si no me equivoco,en la linea.
movwf DATASSP ;cargar dato a escribir en la 24LC08B
deberia poner : movwf DATO ;?????
Publicado por: BrunoF en 14 de Mayo de 2008, 17:18:09
Bueno, estuve mirando cómo había aplicado el módulo I2C en uno de los proyectos en los cuales lo he utilizado y esta distinto. No se porque lo he posteado mal aqui. Se ve que era alguna prueba en la que no habia visto ese detalle....Fijate que la mejor opcion es redefinir DATASSP.
Modifique el primer post de este hilo para que vean cómo debería quedar(es importante destacar que he elegido la posición de memoria 0x70 para DATASSP por ser accesible desde cualquiera de los 4 bancos de esta serie de 16F. Esto hace que uno se despreocupe de andar seleccionando banco a la hora de leer o escribir en DATASSP).
Saludos.
Publicado por: BrunoF en 14 de Mayo de 2008, 17:20:09
Saludos.
Publicado por: groundman en 14 de Mayo de 2008, 19:03:47
quiero modificarlo para utilizarlo en un 16f876.y la eeprom 24lc256.
pero las modificaciones que he hecho no han dado los resultados que queria.no se si sera porque este programa no vale para el direccionamiento de esta memoria,o porque he hecho algo mal.
tendre que tirarme todo el sabado y el domingo para intentar comprender el programa y hacerlo funcionar.
Publicado por: BrunoF en 14 de Mayo de 2008, 19:33:27
gracias por rectificarlo.
quiero modificarlo para utilizarlo en un 16f876.y la eeprom 24lc256.
pero las modificaciones que he hecho no han dado los resultados que queria.no se si sera porque este programa no vale para el direccionamiento de esta memoria,o porque he hecho algo mal.
tendre que tirarme todo el sabado y el domingo para intentar comprender el programa y hacerlo funcionar.
Bueno, yo he usado en un proyecto precisamente el 16F876A con una 24lc256 y si...hay que cambiar unas cositas...
Reemplaza las funciones por estas que son las que use para las 24lc256..
;////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
;WriteI2CByte
;DIRH<1:0> ;paginas de la eeprom en las cuales grabar
;DIRL ;direccion baja de la posicion de eeprom en las cuales grabar
;DATASSP ;dato a grabar
;////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
WriteI2CByte
call i2c_start ;enviar START, esperar a que se libere el BUS
movlw b'10100000' ;"1010"= identificador EEPROM. "000" = numero EEPROM "0"= Write
movwf DATO
call i2c_write
btfss flag,OK
return
movf DIRH,W
andlw b'01111111' ;solo 7 bits de paginas admitidas para esta eeprom.
movwf DATO ;cargar byte en variable a enviar(DATO)
call i2c_write
btfss flag,OK
return ;volver. error de escritura
movf DIRL,W
movwf DATO
call i2c_write
btfss flag,OK
return ;volver. error de escritura
movf DATASSP,W
movwf DATO ;cargar en DATO
call i2c_write
btfss flag,OK
return ;volver. error de escritura
call i2c_stop
return ;flag = 1 OK!
;////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
;ReadI2CByte
;DIRH<1:0> ;paginas de la eeprom de las cuales leer
;DIRL ;direccion baja de la posicion de eeprom de las cuales leer
;devuelve:
;DATASSP ;dato leido
;////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
ReadI2CByte
call i2c_start ;enviar START, esperar a que se libere el BUS
movlw b'10100000' ;1010=identificador EEPROM 000= numero EEPROM 0=write
movwf DATO ;cargar byte en variable a enviar(DATO)
call i2c_write
btfss flag,OK
return ;volver. error de escritura
movf DIRH,W
andlw b'01111111' ;solo 7 bits admitidos para esta EEPROM
movwf DATO
call i2c_write
btfss flag,OK
return
movf DIRL,W
movwf DATO
call i2c_write
btfss flag,OK
return ;volver. error de escritura
call i2c_restart ;enviar RESSTART
movlw b'10100001' ;1010=identificador EEPROM 000= numero EEPROM 1=read
movwf DATO ;cargar byte en variable a enviar(DATO)
call i2c_write
btfss flag,OK
return ;volver. error de escritura
call i2c_read
call i2c_sendnack
call i2c_stop
return ;flag = 1 OK!
;////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
CurrentI2CRead
call i2c_start ;enviar START, esperar a que se libere el BUS
movlw b'10100001' ;1010=identificador EEPROM 000= numero EEPROM 1= read
movwf DATO ;cargar byte en variable a enviar(DATO)
call i2c_write
btfss flag,OK
return ;volver. error de escritura
call i2c_read
call i2c_sendnack
call i2c_stop
return ;flag = 1 OK!
;////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
Publicado por: groundman en 15 de Mayo de 2008, 18:24:37
btfss flag,OK
ya que no puedo compilar.debido a que esta variable no esta declarada.
saludos.
Publicado por: BrunoF en 15 de Mayo de 2008, 18:32:16
#define OK D'0'
Igual funcionaría con cualquier valor entre 0 y 7 ;)
Saludos!
Publicado por: groundman en 16 de Mayo de 2008, 17:38:36
y queria hacerte otra pregunta.
el 24LC256 y toda esta serie tiene un pin WP que creo que es para la proteccion de escritura.
en el datasheet creo haber entendido de que este`pin tiene una resistencia interna que hace de que si el pin esta desconectado,el chip este desprotegido.
es realmente asi o por el contrario estaria protegido y puede que sea ese el motivo de que no me grabe nada?
ademas probando el pic ,me he dado cuenta de que se me queda parado en estas lineas:
bcf STATUS,RP0 ;banco 0
btfss PIR1,SSPIF ;espera a que salte la interrupcion por cambio del flag SSPIF
goto $-1
supongo que sera.que esta interrupcion no se sucede nunca.hay que activar gie?
y otra cosa que he visto:
movlw b'00001011' ;.11 para 400khz @ 20 mhz
movwf SSPADD ;400 khz @ 20 mhz
si este codigo esta optimizado para 20Mhz y yo estoy utilizando 4Mhz puede que el valor .11 no sirva para esta frecuencia.donde esta la tabla para poner el valor adecuado?
Publicado por: BrunoF en 16 de Mayo de 2008, 21:25:43
OK,entendido.
y queria hacerte otra pregunta.
el 24LC256 y toda esta serie tiene un pin WP que creo que es para la proteccion de escritura.
en el datasheet creo haber entendido de que este`pin tiene una resistencia interna que hace de que si el pin esta desconectado,el chip este desprotegido.
es realmente asi o por el contrario estaria protegido y puede que sea ese el motivo de que no me grabe nada?
Si no recuerdo mal, WP debe ir conectado a GND...
ademas probando el pic ,me he dado cuenta de que se me queda parado en estas lineas:
bcf STATUS,RP0 ;banco 0
btfss PIR1,SSPIF ;espera a que salte la interrupcion por cambio del flag SSPIF
goto $-1
supongo que sera.que esta interrupcion no se sucede nunca.hay que activar gie?
Nono. No utilice las interr del modulo en este ejemplo.
y otra cosa que he visto:
movlw b'00001011' ;.11 para 400khz @ 20 mhz
movwf SSPADD ;400 khz @ 20 mhz
si este codigo esta optimizado para 20Mhz y yo estoy utilizando 4Mhz puede que el valor .11 no sirva para esta frecuencia.donde esta la tabla para poner el valor adecuado?
Es probable que debas cambiarlo...consulta el datasheet. allí debe estar.
Saludos
Publicado por: groundman en 18 de Mayo de 2008, 20:04:04
ya que todabia estoy estancado en el codigo.se me ha ocurrido empezar de la forma mas facil.y es grabar un dato en la eeprom directamente con el programador.
y despues leerlo con el codigo que has diseñado.
ya he eliminado las instrucciones relacionadas con las interrupciones.pero sigue quedandose el programa estancado en esta linea:
btfsc SSPSTAT,R_W ;esperar a que termine el envio
goto $-1
esta en el subprograma i2c_write.no se que puede dar lugar a que no salga de este bucle. tienes alguna idea?
Publicado por: BrunoF en 18 de Mayo de 2008, 20:32:15
¿Pusiste las pullups en las lineas, no?
WP y D2,D1 y D0 de la EEPROM deberian ir a GND.
Debería funcionar...
Saludos.
Publicado por: groundman en 18 de Mayo de 2008, 20:36:08
Publicado por: BrunoF en 18 de Mayo de 2008, 21:55:34
Saludos.
Publicado por: groundman en 19 de Mayo de 2008, 10:43:56
ah.supongo que las resistencias hay que conectarlas entre los pin y vcc. no?
Publicado por: BrunoF en 19 de Mayo de 2008, 15:20:27
Ya me comentaras si arranca.
Tendrian que quedarte similar a esto la resistencias..
(http://www.mikroe.com/en/books/picbasicbook/05/eeprom.gif)
Saludos.
Publicado por: groundman en 19 de Mayo de 2008, 17:50:32
ya he puesto las resistencias,y el programa ha salido del bucle donde estaba pillado.
pero ahora se ha quedado pillado en otro, en el subprograma i2c_read.
btfsc SSPCON2,RCEN ;termino la recepcion?
goto $-1 ;no, esperar
yo tengo los pin A0,A1,A2 y WP a GND despues de poner las dos resistencias no creo que tenga mas fallos de hardware. o tu programa no esta puesto para que estos pin esten a GND?
ah las resistencias las he puesto de 10k como en el esquema.
Publicado por: BrunoF en 19 de Mayo de 2008, 18:10:50
Mi programa esta hecho para direccionar a la memoria 0, asi que deberia funcionar.
No he usado resistencias de 10k. Siempre use 4.7k. Igualmente supondria que deberia funcionar...:(
Publicado por: groundman en 20 de Mayo de 2008, 16:57:19
solo hay una cosa de tu programa que no encuentro ni en los datasheet del 16f876 ni en otro datasheet dedicado especificamente con el MSSP.
y es esta linea que te comente anteriormente.
movlw b'00001011' ;.11 para 400khz @ 20 mhz ;3º
movwf SSPADD ;400 khz @ 20 mhz
no se porque se pone este valor.y es que no encuentro ninguna tabla.sera que no existe?
esto es lo que he visto respecto al baud rate generator pero no lo entiendo todo.
in I2C master mode,the reload value for the BRG is located in the lower 7 bits of the SSPADD register.when the BRG is loaded with this value,the BRG counts down
to 0 and stop util another reload has taken place.in I2C master mode,the BRG is reloaded automatically.if clock arbitration is taking place for instance ,the BRG will be reloaded when SCL pin is sampled higt.
Publicado por: BrunoF en 20 de Mayo de 2008, 17:55:46
clock = Fosc / (4*(SSPADD+1))
Proba cargandole el valor .9 a SSPADD para que funcione a 100khz(@4mhz) o .4(@20mhz) segun tu oscilador.
Saludos.
Publicado por: groundman en 20 de Mayo de 2008, 18:59:16
ya he entendido lo que querias decirme. clock = Fosc / (4*(SSPADD+1)) 4Mhz/(4*(9+1))=100Khz
seguire comprobando que es lo que pasa.
saludos.
Publicado por: groundman en 21 de Mayo de 2008, 18:59:36
EUREKA¡¡¡.ya me funciona. :-/ :-/ :-/ :-/ :-/ :-/ :-/ :-/ :-/
tu programa esta perfecto despues de las modificaciones que me has estando diciendo que hiciera.y cambiando algunas
directivas del compilador para este pic 16f876.me ha funcionado en los 24LC16,24LC64 y 24LC256.
el problema era que desde que empeze a modificar tu programa para adaptarlo con este chip,modifque una linea que
luego no me acorde de activarla.ademas de las resistencias de 4K7 que no puse en los pin SCL y SDA a VCC,y entonces cree un nuevo asm y puse los dos ultimos programas que posteastes,y los demas
subprogramas.ademas de modificar todos los B"00000000" por b'00000000' es decir sin las comillas.
y el (#define OK D'0').y eliminar toda referencia hacia lor puertos PORTD y PORTE
abajo pongo el programa que me funciona.
saludos,y muchas gracias por tu tiempo. :-)
progama que graba dato A0 en la direccion 00h de una memoria eeprom externa mediante protocolo I2C
LIST P=16F876
#include "p16F876.INC"
__CONFIG _CP_OFF & _PWRTE_ON & _WDT_OFF & _XT_OSC & _BODEN_OFF &_LVP_OFF &_CPD_OFF ;&_WRT_ENABLE_OFF
ERRORLEVEL -302
;////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
; CONSTANTES:
;////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
#define CLOCK D'0'
#define STROBE D'2'
#define SCL D'3'
#define SDA D'4'
#define OK D'0'
;////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
;Memoria EEPROM
;////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
;////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
; MACROS
;////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
BANK0 MACRO
BCF STATUS,RP0
BCF STATUS,RP1
ENDM
BANK1 MACRO
BSF STATUS,RP0
BCF STATUS,RP1
ENDM
BANK2 MACRO
BSF STATUS,RP1
BCF STATUS,RP0
ENDM
BANK3 MACRO
BSF STATUS,RP1
BSF STATUS,RP0
ENDM
;GPR: GENERAL PURPOSE REGISTERS
;0x20 -> 0x47 Reservados Memoria cartel.
;////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
DIRL EQU 0X20
DIRH EQU 0X21
DATO EQU 0X22 ;temporar. byte a enviar/dato leido
flag EQU 0X24
cuenta EQU 0X25
CONTA0 EQU 0X26
CONTA1 EQU 0X27
DATASSP EQU 0x70
;////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
ORG 0X0000
GOTO INICIO
ORG 0X0004
return
ORG 0X0020
INICIO BANK0
BSF STATUS,RP0
MOVLW 0x06 ;PINS DEL PUERTO A Y PUERTO E TODOS DIGITALES.
MOVWF ADCON1
CLRW
MOVWF TRISA
BANK0
CLRF PORTA
BSF STATUS,RP0
MOVLW 0X00
MOVWF TRISB
BANK0
CLRF PORTB
BSF STATUS,RP0
MOVLW B'00011000'
MOVWF TRISC
BANK0
MOVLW B'00010000'
MOVWF PORTC
BSF STATUS,RP0
;MOVLW 0X00
;MOVWF TRISD
BANK0
;CLRF PORTD
BSF STATUS,RP0
;MOVLW 0X00
;MOVWF TRISE
BANK0
;CLRF PORTE
call i2c_init ;configurar y encender I2C
clrf DIRH ;cargar paginas de 24LC08B en las cuales escribir
clrf DIRL ;cargar direccion de 24LC08B en las cuales escribir
movlw 0xA0
movwf DATASSP ;cargar dato a escribir en la 24LC08B
call WriteI2CByte
btfss flag,0
goto errorcom
call DEMORA ;dar 10ms a que termine la escritura
clrf DIRH ;cargar paginas de 24LC08B de las cuales leer
clrf DIRL ;cargar direccion de 24LC08B de las cuales leer
call ReadI2CByte
btfss flag,0
goto errorcom
movlw .1 ;escritura y lectura OK. encender RA0, mostrar dato leido en PuertoB y loop eterno
movwf PORTA
movf DATO,w
movwf PORTB
nop
goto $-1
errorcom movlw .3 ;error de escritura o lectura, encender RA0 y RA1 y loop eterno
movwf PORTA
nop
goto $-1
;////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
DEMORA
movlw .55
movwf CONTA0
RET1
movlw .181
movwf CONTA1
RET2
nop
nop
decfsz CONTA1,1
goto RET2
decfsz CONTA0,1
goto RET1
return
;////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
i2c_init
movlw b'00011000'
banksel TRISC ;banco 1
iorwf TRISC,F
movlw b'00001011' ;.11 para 400khz @ 20 mhz
movwf SSPADD ;400 khz @ 20 mhz
clrf SSPSTAT
movlw b'00101000'
bcf STATUS,RP0 ;banco 0
movwf SSPCON
CLRF PIR1
call i2c_idle
return
;////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
i2c_idle
bsf STATUS,RP0 ;banco 1
btfsc SSPSTAT,R_W
goto $-1
movf SSPCON2,w
andlw 0x1F
btfss STATUS,Z
goto $-3
bcf STATUS,RP0 ;banco 0
return
;////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
i2c_start
call i2c_idle
bsf STATUS,RP0 ;banco 1
bsf SSPCON2,SEN
btfsc SSPCON2,SEN
goto $-1
bcf STATUS,RP0 ;banco 0
btfss PIR1,SSPIF
goto $-1
bcf PIR1,SSPIF
return
;////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
i2c_restart
bsf STATUS,RP0 ;banco 1
bsf SSPCON2,RSEN
btfsc SSPCON2,RSEN
goto $-1
bcf STATUS,RP0 ;banco 0
return
;////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
i2c_read
call i2c_idle
bsf STATUS,RP0 ;banco 1
bsf SSPCON2,RCEN ;activar modo lectura
btfsc SSPCON2,RCEN ;termino la recepcion?
goto $-1 ;no, esperar
btfss SSPSTAT,BF ;dato disponible en SSPBUF para ser leidos?
goto $-1 ;no, esperar
bcf STATUS,RP0 ;banco 0
movf SSPBUF,W
movwf DATO
return
;////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
i2c_write
bcf flag,0 ;inicializar flag como "error"
call i2c_idle
movf DATO,w ;mover DATO a W
movwf SSPBUF ;cargar dato en buffer I2C
bsf STATUS,RP0 ;banco 1
btfsc SSPSTAT,R_W ;esperar a que termine el envio
goto $-1
btfss SSPCON2,ACKSTAT ;checkear ack
goto okack
bsf SSPCON2,PEN ;error ack. enviar STOP
bcf STATUS,RP0 ;banco 0
return ;volver con flag= 0 error
okack bcf STATUS,RP0 ;banco 0
btfss PIR1,SSPIF ;esperar finalizacion del noveno clock
goto $-1
bcf PIR1,SSPIF
bsf flag,0 ;volver con flag = 1 OK!
return
;////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
i2c_sendack
bsf STATUS,RP0 ;banco 1
bcf SSPCON2,ACKDT
bsf SSPCON2,ACKEN
bcf STATUS,RP0 ;banco 0
return
;////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
i2c_sendnack
bsf STATUS,RP0 ;banco 1
bsf SSPCON2,ACKDT
bsf SSPCON2,ACKEN
bcf STATUS,RP0 ;banco 0
return
;////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
i2c_stop
bsf STATUS,RP0 ;banco 1
bsf SSPCON2,PEN ;enviar STOP
bcf STATUS,RP0 ;banco 0
return
;////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
;WriteI2CByte
;DIRH<1:0> ;paginas de la eeprom en las cuales grabar
;DIRL ;direccion baja de la posicion de eeprom en las cuales grabar
;DATASSP ;dato a grabar
;////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
WriteI2CByte
call i2c_start ;enviar START, esperar a que se libere el BUS
movlw b'10100000' ;"1010"= identificador EEPROM. "000" = numero EEPROM "0"= Write
movwf DATO
call i2c_write
btfss flag,OK
return
movf DIRH,W
andlw b'01111111' ;solo 7 bits de paginas admitidas para esta eeprom.
movwf DATO ;cargar byte en variable a enviar(DATO)
call i2c_write
btfss flag,OK
return ;volver. error de escritura
movf DIRL,W
movwf DATO
call i2c_write
btfss flag,OK
return ;volver. error de escritura
movf DATASSP,W
movwf DATO ;cargar en DATO
call i2c_write
btfss flag,OK
return ;volver. error de escritura
call i2c_stop
return ;flag = 1 OK!
;////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
;ReadI2CByte
;DIRH<1:0> ;paginas de la eeprom de las cuales leer
;DIRL ;direccion baja de la posicion de eeprom de las cuales leer
;devuelve:
;DATASSP ;dato leido
;////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
ReadI2CByte
call i2c_start ;enviar START, esperar a que se libere el BUS
movlw b'10100000' ;1010=identificador EEPROM 000= numero EEPROM 0=write
movwf DATO ;cargar byte en variable a enviar(DATO)
call i2c_write
btfss flag,OK
return ;volver. error de escritura
movf DIRH,W
andlw b'01111111' ;solo 7 bits admitidos para esta EEPROM
movwf DATO
call i2c_write
btfss flag,OK
return
movf DIRL,W
movwf DATO
call i2c_write
btfss flag,OK
return ;volver. error de escritura
call i2c_restart ;enviar RESSTART
movlw b'10100001' ;1010=identificador EEPROM 000= numero EEPROM 1=read
movwf DATO ;cargar byte en variable a enviar(DATO)
call i2c_write
btfss flag,OK
return ;volver. error de escritura
call i2c_read
call i2c_sendnack
call i2c_stop
return ;flag = 1 OK!
;////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
CurrentI2CRead
call i2c_start ;enviar START, esperar a que se libere el BUS
movlw b'10100001' ;1010=identificador EEPROM 000= numero EEPROM 1= read
movwf DATO ;cargar byte en variable a enviar(DATO)
call i2c_write
btfss flag,OK
return ;volver. error de escritura
call i2c_read
call i2c_sendnack
call i2c_stop
return ;flag = 1 OK!
;////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
END
Publicado por: BrunoF en 21 de Mayo de 2008, 19:13:01
Felicitaciones! Y ahora a reventar esas EEPROMs
;)
:-/ :-/ :-/ :-/ :-/ :-/ :-/ :-/ :-/ :-/ :-/ :-/ :-/
Un abrazo.
Publicado por: groundman en 22 de Mayo de 2008, 10:28:56
intentare simplificarlo un poco,y poner algunas lineas de ayuda.de esta forma me ayudara a comprender mejor el I2C.y que a los demas tambien les
cueste menos su interpretacion.
saludos.
Publicado por: pibe en 18 de Diciembre de 2008, 12:06:14
He ensamblado el programa y todo ok.
Ahora el problema es que aún no tengo la 24lc256 fisicamente y me he puesto a simularlo en el PROTEUS, pero me da error.
Le he incluido unas lineas de más para saber si el error era de escritura o lectura y para que haga un loop escribiendo y leyendo en bucle cada 1 segundo.
Lo he puesto a 20mhz, .11 en para 400khz en registro , incluso lo he modificado para 100khz pero es peor.
Me da errores erráticos, a veces de escritura (PORTA,1), a veces OK (PORTA,0) , y a veces de lectura (PORTA,2) .
Se debe esto al simulador del proteus? O hay algo que falla en el programa? Le he puesto las resistencias correspondientes de 4k7 a las lineas SDA , SCL y el WP a masa junto con los A0-A2.
Aqui os dejo el programa , a ver si veis algo anormal.
LIST P=16F877A
#include "p16F877A.INC"
__CONFIG _CP_OFF & _PWRTE_ON & _WDT_OFF & _XT_OSC & _BODEN_OFF &_LVP_OFF &_CPD_OFF ;&_WRT_ENABLE_OFF
ERRORLEVEL -302
;////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
; CONSTANTES:
;////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
#define CLOCK D'0'
#define STROBE D'2'
#define SCL D'3'
#define SDA D'4'
#define OK D'0'
;////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
;Memoria EEPROM
;////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
;////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
; MACROS
;////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
BANK0 MACRO
BCF STATUS,RP0
BCF STATUS,RP1
ENDM
BANK1 MACRO
BSF STATUS,RP0
BCF STATUS,RP1
ENDM
BANK2 MACRO
BSF STATUS,RP1
BCF STATUS,RP0
ENDM
BANK3 MACRO
BSF STATUS,RP1
BSF STATUS,RP0
ENDM
;GPR: GENERAL PURPOSE REGISTERS
;0x20 -> 0x47 Reservados Memoria cartel.
;////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
DIRL EQU 0X20
DIRH EQU 0X21
DATO EQU 0X22 ;temporar. byte a enviar/dato leido
flag EQU 0X24
cuenta EQU 0X25
CONTA0 EQU 0X26
CONTA1 EQU 0X27
PDel0 equ 0x28; (registro)
PDel1 equ 0x29 ;(registro)
PDel2 equ 0x2A; (registro)
DATASSP EQU 0x70
;////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
ORG 0X0000
GOTO INICIO
ORG 0X0004
return
ORG 0X0020
INICIO BANK0
BSF STATUS,RP0
MOVLW 0x06 ;PINS DEL PUERTO A Y PUERTO E TODOS DIGITALES.
MOVWF ADCON1
CLRW
MOVWF TRISA
BANK0
CLRF PORTA
BSF STATUS,RP0
MOVLW 0X00
MOVWF TRISB
BANK0
CLRF PORTB
BSF STATUS,RP0
MOVLW B'00011000'
MOVWF TRISC
BANK0
MOVLW B'00010000'
MOVWF PORTC
BSF STATUS,RP0
MOVLW 0X00
MOVWF TRISD
BANK0
CLRF PORTD
BSF STATUS,RP0
MOVLW 0X00
MOVWF TRISE
BANK0
CLRF PORTE
call i2c_init ;configurar y encender I2C
ini
CLRF PORTB
CLRF PORTA
call DEMORA1s
clrf DIRH ;cargar paginas de 24LC08B en las cuales escribir
clrf DIRL ;cargar direccion de 24LC08B en las cuales escribir
movlw 0x55
movwf DATASSP ;cargar dato a escribir en la 24LC08B
call WriteI2CByte
btfss flag,0
goto errorescr
call DEMORA ;dar 10ms a que termine la escritura
call DEMORA ;dar 10ms a que termine la escritura
clrf DIRH ;cargar paginas de 24LC08B de las cuales leer
clrf DIRL ;cargar direccion de 24LC08B de las cuales leer
call ReadI2CByte
btfss flag,0
goto errorlect
;escritura y lectura OK. encender RA0, mostrar dato leido en PuertoB y loop eterno
bsf PORTA,0
movf DATO,w
movwf PORTB
call DEMORA1s
goto ini
errorescr bsf PORTA,1
call DEMORA1s
goto ini
errorlect bsf PORTA,2
call DEMORA1s
goto ini
;////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
DEMORA
movlw .55
movwf CONTA0
RET1
movlw .181
movwf CONTA1
RET2
nop
nop
decfsz CONTA1,1
goto RET2
decfsz CONTA0,1
goto RET1
return
;////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
i2c_init
movlw b'00011000'
banksel TRISC ;banco 1
iorwf TRISC,F
movlw .11; b'00001011' ;.9 para 100khz a 4mhz , .11 para 400khz @ 20 mhz
movwf SSPADD ;
clrf SSPSTAT
movlw b'00101000'
bcf STATUS,RP0 ;banco 0
movwf SSPCON
CLRF PIR1
call i2c_idle
return
;////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
i2c_idle
bsf STATUS,RP0 ;banco 1
btfsc SSPSTAT,R_W
goto $-1
movf SSPCON2,w
andlw 0x1F
btfss STATUS,Z
goto $-3
bcf STATUS,RP0 ;banco 0
return
;////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
i2c_start
call i2c_idle
bsf STATUS,RP0 ;banco 1
bsf SSPCON2,SEN
btfsc SSPCON2,SEN
goto $-1
bcf STATUS,RP0 ;banco 0
btfss PIR1,SSPIF
goto $-1
bcf PIR1,SSPIF
return
;////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
i2c_restart
bsf STATUS,RP0 ;banco 1
bsf SSPCON2,RSEN
btfsc SSPCON2,RSEN
goto $-1
bcf STATUS,RP0 ;banco 0
return
;////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
i2c_read
call i2c_idle
bsf STATUS,RP0 ;banco 1
bsf SSPCON2,RCEN ;activar modo lectura
btfsc SSPCON2,RCEN ;termino la recepcion?
goto $-1 ;no, esperar
btfss SSPSTAT,BF ;dato disponible en SSPBUF para ser leidos?
goto $-1 ;no, esperar
bcf STATUS,RP0 ;banco 0
movf SSPBUF,W
movwf DATO
return
;////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
i2c_write
bcf flag,0 ;inicializar flag como "error"
call i2c_idle
movf DATO,w ;mover DATO a W
movwf SSPBUF ;cargar dato en buffer I2C
bsf STATUS,RP0 ;banco 1
btfsc SSPSTAT,R_W ;esperar a que termine el envio
goto $-1
btfss SSPCON2,ACKSTAT ;checkear ack
goto okack
bsf SSPCON2,PEN ;error ack. enviar STOP
bcf STATUS,RP0 ;banco 0
return ;volver con flag= 0 error
okack
bcf STATUS,RP0 ;banco 0
btfss PIR1,SSPIF ;esperar finalizacion del noveno clock
goto $-1
bcf PIR1,SSPIF
bsf flag,0 ;volver con flag = 1 OK!
return
;////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
i2c_sendack
bsf STATUS,RP0 ;banco 1
bcf SSPCON2,ACKDT
bsf SSPCON2,ACKEN
bcf STATUS,RP0 ;banco 0
return
;////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
i2c_sendnack
bsf STATUS,RP0 ;banco 1
bsf SSPCON2,ACKDT
bsf SSPCON2,ACKEN
bcf STATUS,RP0 ;banco 0
return
;////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
i2c_stop
bsf STATUS,RP0 ;banco 1
bsf SSPCON2,PEN ;enviar STOP
bcf STATUS,RP0 ;banco 0
return
;////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
;WriteI2CByte
;DIRH<1:0> ;paginas de la eeprom en las cuales grabar
;DIRL ;direccion baja de la posicion de eeprom en las cuales grabar
;DATASSP ;dato a grabar
;////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
WriteI2CByte
bsf PORTC,0
call i2c_start ;enviar START, esperar a que se libere el BUS
movlw b'10100000' ;"1010"= identificador EEPROM. "000" = numero EEPROM "0"= Write
movwf DATO
call i2c_write
btfss flag,OK ;;volver. error de escritura
return
bcf PORTC,0
movf DIRH,W
andlw b'01111111' ;solo 7 bits de paginas admitidas para esta eeprom.
movwf DATO ;cargar byte en variable a enviar(DATO)
call i2c_write
btfss flag,OK
return ;volver. error de escritura
movf DIRL,W
movwf DATO
call i2c_write
btfss flag,OK
return ;volver. error de escritura
movf DATASSP,W
movwf DATO ;cargar en DATO
call i2c_write
btfss flag,OK
return ;volver. error de escritura
call i2c_stop
return ;flag = 1 OK!
;////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
;ReadI2CByte
;DIRH<1:0> ;paginas de la eeprom de las cuales leer
;DIRL ;direccion baja de la posicion de eeprom de las cuales leer
;devuelve:
;DATASSP ;dato leido
;////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
ReadI2CByte
call i2c_start ;enviar START, esperar a que se libere el BUS
movlw b'10100000' ;1010=identificador EEPROM 000= numero EEPROM 0=write
movwf DATO ;cargar byte en variable a enviar(DATO)
call i2c_write
btfss flag,OK
return ;volver. error de escritura
movf DIRH,W
andlw b'01111111' ;solo 7 bits admitidos para esta EEPROM
movwf DATO
call i2c_write
btfss flag,OK
return
movf DIRL,W
movwf DATO
call i2c_write
btfss flag,OK
return ;volver. error de escritura
call i2c_restart ;enviar RESSTART
movlw b'10100001' ;1010=identificador EEPROM 000= numero EEPROM 1=read
movwf DATO ;cargar byte en variable a enviar(DATO)
call i2c_write
btfss flag,OK
return ;volver. error de escritura
call i2c_read
call i2c_sendnack
call i2c_stop
return ;flag = 1 OK!
;////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
CurrentI2CRead
call i2c_start ;enviar START, esperar a que se libere el BUS
movlw b'10100001' ;1010=identificador EEPROM 000= numero EEPROM 1= read
movwf DATO ;cargar byte en variable a enviar(DATO)
call i2c_write
btfss flag,OK
return ;volver. error de escritura
call i2c_read
call i2c_sendnack
call i2c_stop
return ;flag = 1 OK!
DEMORA1s movlw .14 ; 1 set numero de repeticion (C)
movwf PDel0 ; 1 |
PLoop0 movlw .72 ; 1 set numero de repeticion (B)
movwf PDel1 ; 1 |
PLoop1 movlw .247 ; 1 set numero de repeticion (A)
movwf PDel2 ; 1 |
PLoop2 clrwdt ; 1 clear watchdog
decfsz PDel2, 1 ; 1 + (1) es el tiempo 0 ? (A)
goto PLoop2 ; 2 no, loop
decfsz PDel1, 1 ; 1 + (1) es el tiempo 0 ? (B)
goto PLoop1 ; 2 no, loop
decfsz PDel0, 1 ; 1 + (1) es el tiempo 0 ? (C)
goto PLoop0 ; 2 no, loop
PDelL1 goto PDelL2 ; 2 ciclos delay
PDelL2 clrwdt ; 1 ciclo delay
return ; 2+2 Fin.
;////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
END
Publicado por: BrunoF en 19 de Diciembre de 2008, 17:02:10
Puede que el simulador no ande bien, no sería raro. Yo no recuerdo haberlo probado. Si podés no hay nada como probarlo en la vida real.
Por lo pronto a mi me ha funcionado bien durante mucho tiempo, sin fallas. A gran demanda de velocidad. Y a groundman también le ha funcionado por lo que ha comentado.
Espero novedades.
Saludos.
Publicado por: BrunoF en 19 de Diciembre de 2008, 17:02:50
Si has leido bien el hilo, pos ya sabras entonces que con el I2C vas a tener que renegar..quieras o no...:D
;)
Publicado por: pibe en 20 de Diciembre de 2008, 11:09:13
He conseguido simular con una 25LC256 que es SPI y me va de muerte. Super rápida y mucho menos liosa.
Luego subo el código porque estoy en casa.
Ahora voy a por el DS1305 :) .
He encontrado en la página de MAXIM una aplicación para éste , pero que raro, han hecho el programa bit banging en vez de usar el SPI de hardware.
Ya os pediré ayuda seguramente :)
Publicado por: BrunoF en 21 de Diciembre de 2008, 03:27:06
Saludos.
Publicado por: pibe en 21 de Diciembre de 2008, 07:55:01
Cómo escribo toda la memoria?
Según entiendo la página del 25LC256 es de 64 bytes. Si le mando el comando escribir byte y no levanto el CS puedo seguir metiendo datos hasta llegar a 64, luego levanto CS y testeo el WIP del registro STATUS de la memoria para ver que finalizó la grabación de los datos.
Y luego?
Cómo salto a la próxima página? Lo hace automáticamente o debo manualmente enviarle la dirección de inicio de la próxima página?
Publicado por: antimason en 21 de Diciembre de 2008, 16:31:21
Publicado por: pibe en 21 de Diciembre de 2008, 17:12:46
Ahora para leer : CS, comando de lectura, 2 bytes de dirección del dato 1, lees dato 1, levantas CS . Muestras en puerto B el dato que tienes en el buffer. Haces una pausa para visualizarlo.
Y repite para el resto de datos, incrementando en 1 byte de dirección baja.
Publicado por: antimason en 21 de Diciembre de 2008, 18:30:50
Según lo que he leído simplemente activas CS, mandas palabra de comando de escritura, mandas los 2 bytes de dirección (00h ambos en tu caso), mandas el byte de datos 1 , el byte de datos 2, el byte de datos 3, el byte de datos 4, levantas CS y esperas entre 5-10 ms.
Ahora para leer : CS, comando de lectura, 2 bytes de dirección del dato 1, lees dato 1, levantas CS . Muestras en puerto B el dato que tienes en el buffer. Haces una pausa para visualizarlo.
Y repite para el resto de datos, incrementando en 1 byte de dirección baja.
¿No podrias poner algun ejemplo integrado en el asm de este mismo post?
Publicado por: antimason en 21 de Diciembre de 2008, 20:48:19
realiza una temporización de 5s y borra puerta B, a continuación escribe en memoria (se supone que en la siguiente posición) A0
y lo presenta en puerta B, temporiza otros 5s y finalmente lo borra. ¿Que os parece?.
;programa que graba dato AA en la direccion 00h y A0 en la siguiente posición de memoria de una memoria eeprom externa
;mediante protocolo I2C pic 16f876 24LC256
LIST P=16F876
#include "p16F876.INC"
__CONFIG _CP_OFF & _PWRTE_ON & _WDT_OFF & _XT_OSC & _BODEN_OFF &_LVP_OFF &_CPD_OFF ;&_WRT_ENABLE_OFF
ERRORLEVEL -302
;////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
; CONSTANTES:
;////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
#define CLOCK D'0'
#define STROBE D'2'
#define SCL D'3'
#define SDA D'4'
#define OK D'0'
;////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
;Memoria EEPROM
;////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
;////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
; MACROS
;////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
BANK0 MACRO
BCF STATUS,RP0
BCF STATUS,RP1
ENDM
BANK1 MACRO
BSF STATUS,RP0
BCF STATUS,RP1
ENDM
BANK2 MACRO
BSF STATUS,RP1
BCF STATUS,RP0
ENDM
BANK3 MACRO
BSF STATUS,RP1
BSF STATUS,RP0
ENDM
;GPR: GENERAL PURPOSE REGISTERS
;0x20 -> 0x47 Reservados Memoria cartel.
;////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
DIRL EQU 0X20
DIRH EQU 0X21
DATO EQU 0X22 ;temporar. byte a enviar/dato leido
flag EQU 0X24
cuenta EQU 0X25
CONTA0 EQU 0X26
CONTA1 EQU 0X27
R_ContA EQU 0x28
R_ContB EQU 0x29
R_ContC EQU 0x30
DATASSP EQU 0x70
;////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
ORG 0X0000
GOTO INICIO
ORG 0X0004
return
ORG 0X0020
INICIO BANK0
BSF STATUS,RP0
MOVLW 0x06 ;PINS DEL PUERTO A Y PUERTO C TODOS DIGITALES.
MOVWF ADCON1
CLRW
MOVWF TRISA
BANK0
CLRF PORTA
BSF STATUS,RP0
MOVLW 0X00
MOVWF TRISB
BANK0
CLRF PORTB
BSF STATUS,RP0
MOVLW B'00011000'
MOVWF TRISC
BANK0
MOVLW B'00010000'
MOVWF PORTC
BSF STATUS,RP0
call i2c_init ;configurar y encender I2C
clrf DIRH ;cargar paginas de 24LC08B en las cuales escribir
clrf DIRL ;cargar direccion de 24LC08B en las cuales escribir
movlw 0xAA
movwf DATASSP ;cargar dato a escribir en la 24LC08B
call WriteI2CByte
call DEMORA ;dar 10ms a que termine la escritura
clrf DIRH ;cargar paginas de 24LC08B de las cuales leer
clrf DIRL ;cargar direccion de 24LC08B de las cuales leer
call ReadI2CByte
movf DATO,w
movwf PORTB
incf DIRL,F
call Retardo_5s
clrf PORTB
call i2c_init ;configurar y encender I2C
clrf DIRH ;cargar paginas de 24LC08B en las cuales escribir
clrf DIRL ;cargar direccion de 24LC08B en las cuales escribir
movlw 0xA0
movwf DATASSP ;cargar dato a escribir en la 24LC08B
call WriteI2CByte
call DEMORA ;dar 10ms a que termine la escritura
clrf DIRH ;cargar paginas de 24LC08B de las cuales leer
clrf DIRL ;cargar direccion de 24LC08B de las cuales leer
call ReadI2CByte
movf DATO,w
movwf PORTB
call Retardo_5s
clrf PORTB
nop
goto $-1
;////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
DEMORA
movlw .55
movwf CONTA0
RET1
movlw .181
movwf CONTA1
RET2
nop
nop
decfsz CONTA1,1
goto RET2
decfsz CONTA0,1
goto RET1
return
;****************************************************************************************************************************
Retardo_5s ;
movlw d'50' ;
goto Retardo_1Decima
Retardo_1Decima
movwf R_ContC ;
R1Decima_BucleExterno2
movlw d'100' ;
movwf R_ContB ;
R1Decima_BucleExterno
movlw d'249' ;
movwf R_ContA ;
R1Decima_BucleInterno
nop ;
decfsz R_ContA,F ;
goto R1Decima_BucleInterno ;
decfsz R_ContB,F ;
goto R1Decima_BucleExterno ;
decfsz R_ContC,F ;
goto R1Decima_BucleExterno2 ;
return
;////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
i2c_init
movlw b'00011000'
banksel TRISC ;banco 1
iorwf TRISC,F
movlw b'00001011' ;.11 para 400khz @ 20 mhz
movwf SSPADD ;400 khz @ 20 mhz
clrf SSPSTAT
movlw b'00101000'
bcf STATUS,RP0 ;banco 0
movwf SSPCON
CLRF PIR1
call i2c_idle
return
;////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
i2c_idle
bsf STATUS,RP0 ;banco 1
btfsc SSPSTAT,R_W
goto $-1
movf SSPCON2,w
andlw 0x1F
btfss STATUS,Z
goto $-3
bcf STATUS,RP0 ;banco 0
return
;////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
i2c_start
call i2c_idle
bsf STATUS,RP0 ;banco 1
bsf SSPCON2,SEN
btfsc SSPCON2,SEN
goto $-1
bcf STATUS,RP0 ;banco 0
btfss PIR1,SSPIF
goto $-1
bcf PIR1,SSPIF
return
;////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
i2c_restart
bsf STATUS,RP0 ;banco 1
bsf SSPCON2,RSEN
btfsc SSPCON2,RSEN
goto $-1
bcf STATUS,RP0 ;banco 0
return
;////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
i2c_read
call i2c_idle
bsf STATUS,RP0 ;banco 1
bsf SSPCON2,RCEN ;activar modo lectura
btfsc SSPCON2,RCEN ;termino la recepcion?
goto $-1 ;no, esperar
btfss SSPSTAT,BF ;dato disponible en SSPBUF para ser leidos?
goto $-1 ;no, esperar
bcf STATUS,RP0 ;banco 0
movf SSPBUF,W
movwf DATO
return
;////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
i2c_write
bcf flag,0 ;inicializar flag como "error"
call i2c_idle
movf DATO,w ;mover DATO a W
movwf SSPBUF ;cargar dato en buffer I2C
bsf STATUS,RP0 ;banco 1
btfsc SSPSTAT,R_W ;esperar a que termine el envio
goto $-1
btfss SSPCON2,ACKSTAT ;checkear ack
goto okack
bsf SSPCON2,PEN ;error ack. enviar STOP
bcf STATUS,RP0 ;banco 0
return ;volver con flag= 0 error
okack bcf STATUS,RP0 ;banco 0
btfss PIR1,SSPIF ;esperar finalizacion del noveno clock
goto $-1
bcf PIR1,SSPIF
bsf flag,0 ;volver con flag = 1 OK!
return
;////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
i2c_sendack
bsf STATUS,RP0 ;banco 1
bcf SSPCON2,ACKDT
bsf SSPCON2,ACKEN
bcf STATUS,RP0 ;banco 0
return
;////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
i2c_sendnack
bsf STATUS,RP0 ;banco 1
bsf SSPCON2,ACKDT
bsf SSPCON2,ACKEN
bcf STATUS,RP0 ;banco 0
return
;////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
i2c_stop
bsf STATUS,RP0 ;banco 1
bsf SSPCON2,PEN ;enviar STOP
bcf STATUS,RP0 ;banco 0
return
;////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
;WriteI2CByte
;DIRH<1:0> ;paginas de la eeprom en las cuales grabar
;DIRL ;direccion baja de la posicion de eeprom en las cuales grabar
;DATASSP ;dato a grabar
;////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
WriteI2CByte
call i2c_start ;enviar START, esperar a que se libere el BUS
movlw b'10100000' ;"1010"= identificador EEPROM. "000" = numero EEPROM "0"= Write
movwf DATO
call i2c_write
btfss flag,OK
return
movf DIRH,W
andlw b'01111111' ;solo 7 bits de paginas admitidas para esta eeprom.
movwf DATO ;cargar byte en variable a enviar(DATO)
call i2c_write
btfss flag,OK
return ;volver. error de escritura
movf DIRL,W
movwf DATO
call i2c_write
btfss flag,OK
return ;volver. error de escritura
movf DATASSP,W
movwf DATO ;cargar en DATO
call i2c_write
btfss flag,OK
return ;volver. error de escritura
call i2c_stop
return ;flag = 1 OK!
;////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
;ReadI2CByte
;DIRH<1:0> ;paginas de la eeprom de las cuales leer
;DIRL ;direccion baja de la posicion de eeprom de las cuales leer
;devuelve:
;DATASSP ;dato leido
;////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
ReadI2CByte
call i2c_start ;enviar START, esperar a que se libere el BUS
movlw b'10100000' ;1010=identificador EEPROM 000= numero EEPROM 0=write
movwf DATO ;cargar byte en variable a enviar(DATO)
call i2c_write
btfss flag,OK
return ;volver. error de escritura
movf DIRH,W
andlw b'01111111' ;solo 7 bits admitidos para esta EEPROM
movwf DATO
call i2c_write
btfss flag,OK
return
movf DIRL,W
movwf DATO
call i2c_write
btfss flag,OK
return ;volver. error de escritura
call i2c_restart ;enviar RESSTART
movlw b'10100001' ;1010=identificador EEPROM 000= numero EEPROM 1=read
movwf DATO ;cargar byte en variable a enviar(DATO)
call i2c_write
btfss flag,OK
return ;volver. error de escritura
call i2c_read
call i2c_sendnack
call i2c_stop
return ;flag = 1 OK!
;////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
CurrentI2CRead
call i2c_start ;enviar START, esperar a que se libere el BUS
movlw b'10100001' ;1010=identificador EEPROM 000= numero EEPROM 1= read
movwf DATO ;cargar byte en variable a enviar(DATO)
call i2c_write
btfss flag,OK
return ;volver. error de escritura
call i2c_read
call i2c_sendnack
call i2c_stop
return ;flag = 1 OK!
;////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
END
Publicado por: pibe en 22 de Diciembre de 2008, 05:47:03
Muy buen trabajo. Lo has probado si funciona?
Publicado por: BrunoF en 22 de Diciembre de 2008, 06:17:43
e he atrevido a realizar modificaciones sobre el programa de Brunof...
Hola!
Bueno, la subrutina i2c_init debería ser llamada sólo la primera vez. Volver a llamarla puede provocar efectos indeseados.
...a continuación escribe en memoria (se supone que en la siguiente posición) A0
y lo presenta en puerta B, temporiza otros 5s y finalmente lo borra. ¿Que os parece?.
Lamentablemente supones mal. Y con esto voy a responderte a ti y a pibe.
Estas memorias pueden ser leidas de 3 maneras: Random Read, Current Access Read y Sequential Read. La Random Read implica que uno le pasa como parametros también la dirección que se desea leer, pudiendo elegir entre cualquiera presente en la memoria. Current Read implica que se leerá la posición de memoria a la cual apunte su puntero interno. ¿Que valor posee el puntero interno?
Luego de realizar una Random Read, el valor del puntero interno es el valor de la posición que se acaba de leer + 1. Es decir que el puntero se autoincrementa según la última posición a la cual se ha accedido.
Ejemplos:
Si realizo primero un Random Read de la posición 125 y luego realizo un Current Access Read, la memoria leerá el valor de la posición 126. Si realizo otro Current Access Read, leerá la posición 127.
Sequential Read sirve para leer muchas posiciones de memoria CONSECUTIVAS. Podés leer toda la memoria si querés. La diferencia es que leer de esta manera es muchísimo más rápido que en los otros dos modos.
Para escribir, hay dos modos: Byte Write(el que usan en mi ejemplo) y Block Write(que creo que no he publicado el algoritmo).
El byte write que es el que se usa para escribir un byte en la RAM, siempre exige que se defina la posición a escribir. Por lo que es necesario que se le pase la posición a la cual se desea acceder. Todas las operaciones afectan al puntero interno que es el que indica cual es la posicion actual a leer/escribir.
Ejemplo:
Escribo posición 0. (Luego de eso, el puntero interno valdrá 1)
Leo posición 0. Debo hacerlo usando el Random Read indicandole que quiero leer la posición 0.(si usase en su lugar el Current Access Read o Block Read, el primer byte leido seria el de la posicion 1).
Escribo posición 1. (Luego de eso, el puntero interno valdrá 2)
Leo posición 1. Nuevamente debo hacerlo usando el Random Read indicandole que quiero leer la posición 1.(si usase en su lugar el Current Access Read o Block Read, el primer byte leido seria el de la posicion 2).
Si se fijan bien en el protocolo, el Random Read comienza exáctamente igual que un Byte Write. Esto es porque de esta manera se logra modificar el puntero interno. Luego en la lectura se interrumpe la escritura y se procede a leer.
Se entendió?
Saludos.
Publicado por: pibe en 22 de Diciembre de 2008, 07:12:29
Una pregunta: En el secuencial byte read, puedo leer toda la memoria con una sola instrucción mientras le sigo mandando reloj y CS? O sólo los primeros 64 bytes de la página?
Publicado por: antimason en 22 de Diciembre de 2008, 15:33:43
Perdona pero es que no tenía el programa en casa.
Muy buen trabajo. Lo has probado si funciona?
En el Proteus funciona, aun así he seguido el consejo de Brunof de solo hacer una llamada "call i2c_init", que tambien he probado y funciona. Ahora solo queda asegurar que lo que se escribe y se lee es desde una posición conocida y esa información sale linea tras linea desde esa posición de memoria..............bufffffff, que entretenido es esto, por cierto la intrucción "goto $-1" es salto incondicional a.......¿$-1?, que es...es que he pasado de un pic 16f84a a este otro pic y no estoy muy suelto. El código ahora queda así:
ORG 0X0000
GOTO INICIO
ORG 0X0004
return
ORG 0X0020
INICIO BANK0
BSF STATUS,RP0
MOVLW 0x06 ;PINS DEL PUERTO A Y PUERTO C TODOS DIGITALES.
MOVWF ADCON1
CLRW
MOVWF TRISA
BANK0
CLRF PORTA
BSF STATUS,RP0
MOVLW 0X00
MOVWF TRISB
BANK0
CLRF PORTB
BSF STATUS,RP0
MOVLW B'00011000'
MOVWF TRISC
BANK0
MOVLW B'00010000'
MOVWF PORTC
BSF STATUS,RP0
call i2c_init ;configurar y encender I2C
clrf DIRH ;cargar paginas de 24LC08B en las cuales escribir
clrf DIRL ;cargar direccion de 24LC08B en las cuales escribir
movlw 0xAA
movwf DATASSP ;cargar dato a escribir en la 24LC08B
call WriteI2CByte
call DEMORA ;dar 10ms a que termine la escritura
clrf DIRH ;cargar paginas de 24LC08B de las cuales leer
clrf DIRL ;cargar direccion de 24LC08B de las cuales leer
call ReadI2CByte
movf DATO,w
movwf PORTB
incf DIRL,F
call Retardo_5s
clrf PORTB
clrf DIRH ;cargar paginas de 24LC08B en las cuales escribir
clrf DIRL ;cargar direccion de 24LC08B en las cuales escribir
movlw 0xA0
movwf DATASSP ;cargar dato a escribir en la 24LC08B
call WriteI2CByte
call DEMORA ;dar 10ms a que termine la escritura
clrf DIRH ;cargar paginas de 24LC08B de las cuales leer
clrf DIRL ;cargar direccion de 24LC08B de las cuales leer
call ReadI2CByte
movf DATO,w
movwf PORTB
call Retardo_5s
clrf PORTB
nop
goto $-1
Solo pongo la parte del programa sobre la que estoy trabajando porque supongo que el resto sufrira pocos cambios o ninguno (creo yo, a lo mejor me equivoco, je, je, je).
Publicado por: pibe en 22 de Diciembre de 2008, 19:07:30
Publicado por: antimason en 22 de Diciembre de 2008, 21:02:58
goto $-1 es volver a la instruccion anterior. Tambien puedes hacer -2 , -3, -4 etc
Gracias.
Publicado por: BrunoF en 22 de Diciembre de 2008, 22:38:29
Gracias Bruno por la aclaración.
Una pregunta: En el secuencial byte read, puedo leer toda la memoria con una sola instrucción mientras le sigo mandando reloj y CS? O sólo los primeros 64 bytes de la página?
Hola! No. Podés leer toda la memoria entera. Eso si, tene en cuenta que empezarás a leer desde la posición siguiente a la última que has leído. Es decir que primero deberías hacer un random access read a la posicion 0 por ejemplo, y dsps ya usar el secuential read y leer desde la 1 en adelante para asegurarte donde "estas parado".
antimason:
Tu programa escribe y lee siempre la posición 0. Si querés grabar la segunda vez en la posicion 1(que creo que esa era la idea), tenés que indicarlo en DIRH/DIRL antes de leer y grabar por segunda vez.
Saludos.
Publicado por: antimason en 25 de Diciembre de 2008, 21:59:37
Publicado por: antimason en 27 de Diciembre de 2008, 11:37:46
dato_1 call i2c_init ;configurar y encender I2C
clrf DIRH ;cargar paginas de 24LC08B en las cuales escribir
clrf DIRL ;cargar direccion de 24LC08B en las cuales escribir
movlw b'00000001' ;1 en código binario
movwf DATASSP ;cargar dato a escribir en la 24LC08B
call WriteI2CByte
call DEMORA ;dar 10ms a que termine la escritura
clrf DIRH ;cargar paginas de 24LC08B de las cuales leer
clrf DIRL ;cargar direccion de 24LC08B de las cuales leer
call ReadI2CByte
movf DATO,w
movwf PORTB
incf DIRL,F
call Retardo_5s
clrf PORTB
dato_2 clrf DIRH ;cargar paginas de 24LC08B en las cuales escribir
movlw b'00000001' ;Dirección 1 de página 0x00
movwf DIRL ;cargar direccion de 24LC08B en las cuales escribir
movlw b'00000010' ;2 en código binario
movwf DATASSP ;cargar dato a escribir en la 24LC08B
call WriteI2CByte
call DEMORA ;dar 10ms a que termine la escritura
clrf DIRH ;cargar paginas de 24LC08B de las cuales leer
movlw b'00000001'
movwf DIRL ;cargar direccion de 24LC08B de las cuales leer
call ReadI2CByte
movf DATO,w
movwf PORTB
call Retardo_5s
clrf PORTB
nop
goto $-1
Publicado por: pibe en 27 de Diciembre de 2008, 22:35:50
Entonces, deberias leer el dato en 00h, no incrementes, vuelves a leer dato.
A ver si te sale.
Publicado por: antimason en 28 de Diciembre de 2008, 08:28:48
Si no me equivoco, una vez has leido el puntero se incrementa automaticamente. Por eso , al hacer incf DIRL le estás diciendo que se salte una direccion de memoria , por lo tanto te lee FF que es el default que llevan grabadas las memorias.
Entonces, deberias leer el dato en 00h, no incrementes, vuelves a leer dato.
A ver si te sale.
Gracias majo, lo haré.
Publicado por: antimason en 28 de Diciembre de 2008, 08:46:48
call i2c_init ;configurar y encender I2C
clrf DIRH ;Pagina 0x00
clrf DIRL ;Dirección 0x00
movlw 0x01 ;00000001
movwf DATASSP ;cargar dato a escribir en la 24LC256
call WriteI2CByte
call DEMORA ;dar 10ms a que termine la escritura
clrf DIRH ;Pagina 0x00 a leer
clrf DIRL ;Dirección 0x00 a leer
call ReadI2CByte
movf DATO,w
movwf PORTB ;Lo saca por puerta B
call Retardo_5s
clrf PORTB
movlw 0x00
movwf DIRH ;Pagina 0x00
movlw 0x00
movwf DIRL ;Dirección 0x00
movlw 0x02 ;00000010
movwf DATASSP ;cargar dato a escribir en la 24LC256
call WriteI2CByte
call DEMORA ;dar 10ms a que termine la escritura
clrf DIRH ;Pagina 0x00 a leer
clrf DIRL ;Dirección 0x00 a leer
call ReadI2CByte
movf DATO,w
movwf PORTB ;Lo saca por puerta B
call Retardo_5s
clrf PORTB
nop
goto $-1 ;vuelve a línea anterior (nop)
Publicado por: pibe en 28 de Diciembre de 2008, 16:51:01
Aqui grabas el primer byte (1) en la posicion 00 00 h
call i2c_init ;configurar y encender I2C
clrf DIRH ;Pagina 0x00
clrf DIRL ;Dirección 0x00
movlw 0x01 ;00000001
movwf DATASSP ;cargar dato a escribir en la 24LC256
call WriteI2CByte
call DEMORA ;dar 10ms a que termine la escritura
Y aquí lo lees
clrf DIRH ;Pagina 0x00 a leer
clrf DIRL ;Dirección 0x00 a leer
call ReadI2CByte
movf DATO,w
movwf PORTB ;Lo saca por puerta B
call Retardo_5s
clrf PORTB
AQUI SOBREESCRIBES en la misma dirección 00 00h pero con dato (2)
movlw 0x00
movwf DIRH ;Pagina 0x00
movlw 0x00
movwf DIRL ;Dirección 0x00
movlw 0x02 ;00000010
movwf DATASSP ;cargar dato a escribir en la 24LC256
call WriteI2CByte
call DEMORA ;dar 10ms a que termine la escritura
Y aqui lo lees
clrf DIRH ;Pagina 0x00 a leer
clrf DIRL ;Dirección 0x00 a leer
call ReadI2CByte
movf DATO,w
movwf PORTB ;Lo saca por puerta B
call Retardo_5s
clrf PORTB
nop
goto $-1 ;vuelve a línea anterior (nop)
Yo es que si lees un post anterior mío, he desistido con el I2c porque no hubo manera que me funcionara. Me he volcado por la SPI que no tuve problemas.
Supongo que las maneras de manejar los datos y direcciones serán los mismos.
Ahora, lo que tendrías que hacer es :
GRABAR un dato en dirección 00 00
GRABAR un dato en dirección 00 01
Luego lees el dato en dirección 00 00 y lo muestras, luego lees el dato en dirección 00 01 y lo muestras.
Creo que incluso puedes leer ambos datos consecutivos sin dejar de enviarle reloj : Lees el dato en dirección 00 00 y la dirección se incrementa automáticamente y lees el dato 2 sin cortar el reloj, inmediatamente después de leer el dato 1.
O sea:
Grabas ambos datos en distintas direcciones.
Envias comando lectura
dirección 00 00
Lees byte 1
guardar en variable 1
Lees byte 2
guardar en variable 2
Mostrar variable 1
pausa
Mostrar variable 2
El truco aqui es que guardes en una variable cada byte leído, porque no puedes cortar el reloj para mostrar los datos.
Prueba y me cuentas
Publicado por: antimason en 28 de Diciembre de 2008, 21:37:38
Pibe te he hecho caso en lo de escribir los dos datos consecutivamente en memoria, pero no en lo de usar variables pues debo declararlas y ocupar memoria de programa, imagínate miles de datos en memoria con miles de variables declaradas (a lo mejor he dicho una burrada pero creo que es así), posteriormente he sacado los datos uno tras otro, pero al sacar el segundo dato se me ha ocurrido poner otra vez el "call i2c_init", y mira por donde ahora si me funciona, (¿que opinará Brunof?). De momento esto ya funciona, pero seguiré buscando otra estructura de programa que funcione, aquí el código pibe:
escribo_dato1 call i2c_init ;configurar y encender I2C
clrf DIRH ;Pagina 0x00
clrf DIRL ;Dirección 0x00
movlw 0x01 ;00000001
movwf DATASSP ;cargar dato a escribir en la 24LC256
call WriteI2CByte
call DEMORA ;dar 10ms a que termine la escritura
escribo_dato2 movlw 0x00
movwf DIRH ;Pagina 0x00
movlw 0x01
movwf DIRL ;Dirección 0x01
movlw 0x02 ;00000010
movwf DATASSP ;cargar dato a escribir en la 24LC256
call WriteI2CByte
call DEMORA ;dar 10ms a que termine la escritura
leo_primer_dato clrf DIRH ;Pagina 0x00 a leer
clrf DIRL ;Dirección 0x00 a leer
call ReadI2CByte
movf DATO,w
movwf PORTB ;Lo saca por puerta B
call Retardo_5s
clrf PORTB
call Retardo_5s
leo_segundo_dato call i2c_init ;configurar y encender I2C
clrf DIRH ;Pagina 0X00 a leer
movlw 0x01
movwf DIRL ;Direccion 0X01 a leer
clrw
call ReadI2CByte
movf DATO,w
movwf PORTB ;Lo saca por puerta B
call Retardo_5s
clrf PORTB
nop
goto $-1 ;vuelve a línea anterior (nop)
Publicado por: BrunoF en 30 de Diciembre de 2008, 03:03:02
Saludos.
Publicado por: antimason en 30 de Diciembre de 2008, 10:33:55
Hola. Mira, yo creo que debe ser un error del Proteus. Al menos esa es mi opinión porque estás haciendo los pasos correctamente. Tal vez sea hora de probarlo en la realidad si tienes la posibilidad.
Saludos.
Gracias, ¿pero te refieres al último código que he puesto o al anterior?.
Publicado por: BrunoF en 30 de Diciembre de 2008, 14:47:05
Saludos
Publicado por: antimason en 31 de Diciembre de 2008, 09:54:42
supongo que funcionaria en la realidad (grabando previamente en la eeprom externa claro), pero con el proteus que tengo no hay manera.
eo_primer_dato call i2c_init ;configurar y encender I2C
clrf DIRH ;Pagina 0x00 a leer
clrf DIRL ;Dirección 0x00 a leer
call ReadI2CByte
movf DATO,w
movwf PORTB ;Lo saca por puerta B
call Retardo_5s
clrf PORTB
call Retardo_5s
leo_segundo_dato clrf DIRH ;Pagina 0X00 a leer
movlw 0x01
movwf DIRL ;Direccion 0X01 a leer
clrw
call ReadI2CByte
movf DATO,w
movwf PORTB ;Lo saca por puerta B
call Retardo_5s
clrf PORTB
nop
goto $-1 ;vuelve a línea anterior (nop)
Publicado por: alogic.on en 17 de Enero de 2009, 19:45:27
Código: ASM
- CONFIG_I2C MACRO
- ;RC4=SDA
- ;RC3=SCL Y LOS DOS COMO ENTRADA??
- movlw B'00011000'
- banksel TRISC ;banco 1
- iorwf TRISC,F
- BANKSEL SSPSTAT
- MOVLW B'00000000' ;7----> SMP 0=VELOCIDAD 400KHZ
- ;6----> CKE 0=EL DATO SE TRANSMITE EN FLANCO DE SUBIDA
- ;5----> D/A 1=INDICA QUE EL ULTIMO DATO REC/TRANSMITIDO ERA UN DATO
- ; 0=INDICA QUE ERA UNA DIRECCION
- ;4----> P 1=INDICA QUE HA SIDO DETECTADA UNA CONDICION DE STOP
- ; 0=NO SE HA DETECTADO STOP
- ;3----> S 1=SE HA DETECTADO UNA CONDICION DE START
- ; 0=NO SE HA DETECTADO UNA CONDICION DE START
- ;2----> R_W 1=TRANSMISION EN PROGRESO
- ; 0=TRANSMISION FINALIZADA
- ;1----> UA SOLO EN I2C DIRECCION 10BITS
- ;0----> BF 1=LA TRANSMISION ESTA EN PROGRESO SSPBUF LLENO
- ; 0=LA TRANSMISION HA FINALIZADO SSPBUF VACIO
- MOVWF SSPSTAT
- ;-------------------------------
- BANKSEL SSPCON
- MOVLW B'00101000' ;7----> WCOL 0=NO HAY COLISION
- ; 1=SE HA ESCRITO SSPBUF MIENTRAS SE HACIA UNA TRANSMISION
- ;6----> SSPOV 0=NO HAY OVERFLOW
- ; 1=UN BYTE SE HA RECIBIDO SIN LEER EL ANTERIOR dEBE SER BORRADO POR SOFT
- ;5----> SSPEN 1=HABILITA EL I2C Y LOS PINES SDA SCL
- ;4----> CKP 0=MANTIENE EL RELOJ EN ESTADO BAJO
- ; 1=HABILITA EL RELOJ
- ;3-0--> SSPM3-0 1000=MAESTRO reloj=f_osc/4*(sspadd+1)
- MOVWF SSPCON
- ;-------------------------------
- BANKSEL SSPCON2
- MOVLW B'00010000'
- ;7----> GCEN SOLO EN ESCLAVO
- ;6----> ACKSTAT EN MODO MASTER TRANSMISION, EL ESCLAVO ENVIA EL ACK CUANDO HA RECIBIDO EL DATO
- ; 1=NO RECIBIDO ACK DEL ESCLAVO
- ; 0=ACK RECIBIDO DEL ESCLAVO
- ;5----> ACKDT EN MODO MASTER RECEPCION, EL MASTER ENVIA UN ACK CUANDO HA TERMINADO DE RECIBIR
- ; 1=NO ACK
- ; 0=SI ACK
- ;4----> ACKEN EN MODO MASTER RECEPCION
- ; 1= INICIA LA SECUENCIADE SDA SCL, Y TRANMITE EL ACKDT BORRADO POR HARDWARE
- ; 0=DESHABILITADO
- ;3----> RCEN EN MASTER I2C
- ; 1= RECEPCION HABILITADA
- ; 0= RECEPCION DESHABILITADA
- ;2----> PEN SOLO EN I2C MASTER
- ; 1=INICIA UNA SECUENCIA DE STOP BORRADO POR HARD
- ; 0=DESHABILITADA
- ;1----> RSEN SOLO EN I2C MASTER START REPETIDO
- ; 1=INICIA CONDICION DE SR BORRADO POR HARD
- ; 0=DESHABILITADO
- ;0----> SEN SOLO EN I2C MASTER
- ; 1=INICIA LA CONDICION START EN SCL SDA BORRADO POR HARD
- ; 0=DESHABILITADO
- MOVWF SSPCON2
- banksel SSPADD
- movlw b'00001011' ;.11 para 400khz @ 20 mhz
- movwf SSPADD ;400 khz @ 20 mhz
- ENDM
- I2C_BUS MACRO
- CALL RESET_DIRECCION ;APUNTA AL PAD 00, HABRA QUE BUSCAR LA FORMA DE SELECIONAR ENTRE VARIOS CADA 255 BYTES
- I2C_MEMO_READ
- BANKSEL SSPCON
- BSF SSPCON, CKP ;PRIMERO INICIA EL RELOJ
- CALL IIC_START ;ENVIA LA CONDICION DE START
- MOVLW B'10100001' ;CONTROL BYTE--> |STARTBIT|1|0|1|0|A2|A1|A0|RW|ACK
- CALL IIC_ENVIA ;Y SE LO ENVIA A LA EEPROM
- CALL IIC_ADRESS ;MANDA DIRH,ESPERA ACK,MANDA DIRL, ESPERA ACK, RETURN
- SIGUE_READ
- BANKSEL SSPCON2
- BSF SSPCON2,RCEN ;activar modo lectura
- BTFSC SSPCON2,RCEN ;termino la recepcion?
- GOTO $-1
- BTFSS SSPSTAT,BF ;dato disponible en SSPBUF para ser leido?
- GOTO $-1 ;no, esperar
- BANKSEL DIRL
- INCFSZ DIRL,F ;UNA VEZ LLEGA A 255 SALE DE LA RUTINA
- GOTO GUARDA_PADS
- IIC_STOP
- BANKSEL SSPCON2
- BSF SSPCON2,PEN
- BTFSC SSPCON2,PEN
- GOTO $-1
- BANKSEL SSPCON
- BCF SSPCON, CKP ;APAGA EL RELOJ
- RETURN
- GUARDA_PADS
- BANKSEL SSPBUF
- MOVF SSPBUF,W
- BANKSEL REG_MUESTRA
- MOVWF REG_MUESTRA
- CALL ESCRITURA_EEPROM_IIC ;Y GUARDA EL DATO EN LA EEPROM
- GOTO SIGUE_READ
- IIC_IDLE
- BANKSEL SSPSTAT
- BTFSC SSPSTAT,R_W
- GOTO $-1
- ; movf SSPCON2,w ; POR QUE SE HACE ESTO
- ; andlw 0x1F
- ; btfss STATUS,Z
- ; goto $-3
- RETURN
- ESCRITURA_EEPROM_IIC
- BANKSEL DIRL
- MOVF DIRL,W ;Data Memory
- BANKSEL EEADR
- MOVWF EEADR ;Address to write
- CLRW
- ADDWF EEADR,F ;DE ESTA FORMA SE COMIENZA A CONTAR DESDE EL REGISTRO DE POTES
- GOTO CONTINUA_ESCRITURA
- IIC_ADRESS
- BANKSEL DIRH
- MOVF DIRH,W
- CALL IIC_ENVIA
- BANKSEL DIRL
- MOVF DIRL,W
- CALL IIC_ENVIA
- RETURN
- IIC_ENVIA
- CALL IIC_IDLE ;ESERA A QUE TERMINE LA ULTIMA TRANSMISION
- BANKSEL SSPBUF
- MOVWF SSPBUF
- BANKSEL SSPCON2
- RETURN
- RESET_DIRECCION
- BANKSEL DIRH ;CARGAMOS EN LOS REGISTROS DE DIRECCION A LA QUE QUEREMOS ACCEDER
- CLRF DIRH ;DE MOMENTO DIRECCION 00
- CLRF DIRL
- RETURN
- IIC_START
- CALL IIC_IDLE
- BANKSEL SSPCON2
- BSF SSPCON2, SEN ;INICIA START
- BTFSC SSPCON2,SEN
- GOTO $-1
- BANKSEL PIR1
- BTFSS PIR1,SSPIF
- GOTO $-1
- BCF PIR1,SSPIF
- RETURN
- ENDM
- ;------------------------------------------
pero hay una cosa que no entiendo de la rutina i2c_idle
Código: ASM
- i2c_idle
- bsf STATUS,RP0 ;banco 1
- btfsc SSPSTAT,R_W
- goto $-1
- movf SSPCON2,w
- andlw 0x1F
- btfss STATUS,Z
- goto $-3
- bcf STATUS,RP0 ;banco 0
- return
y otra dudilla, he visto en el ejemplo que poneis SDA y SCL como entradas, es así?, los configura el modulo segun se este recibiendo o enviando??
un saludo y gracias
Publicado por: BrunoF en 23 de Enero de 2009, 15:16:21
Cita del datasheet:
Citar
Note: For bits ACKEN, RCEN, PEN, RSEN, SEN: If the I2C module is not in the IDLE mode, this bit may not be set (no spooling), and the SSPBUF may not be written (or writes to the SSPBUF are disabled).
Con respecto a la configuración E/S de los pines, no te preocupes. El uC los administra y configura según corresponda.
Saludos.
Publicado por: alogic.on en 24 de Enero de 2009, 07:10:31
creo que ya ta, la rutina que vuelca 255bytes en la eeprom. ahora solo me falta al verres, copiar el pad en la eeprom y la forma de seleccionar entre varias posiciones, donde guardar diferentes configuraciones de los potes y botones. a seguir currando¡¡
Código: ASM
- CONFIG_IIC MACRO
- BANKSEL SSPCON
- MOVLW B'00101000' ;7----> WCOL 0=NO HAY COLISION
- ; 1=SE HA ESCRITO SSPBUF MIENTRAS SE HACIA UNA TRANSMISION
- ;6----> SSPOV 0=NO HAY OVERFLOW
- ; 1=UN BYTE SE HA RECIBIDO SIN LEER EL ANTERIOR dEBE SER BORRADO POR SOFT
- ;5----> SSPEN 1=HABILITA EL I2C Y LOS PINES SDA SCL
- ;4----> CKP 0=MANTIENE EL RELOJ EN ESTADO BAJO
- ; 1=HABILITA EL RELOJ
- ;3-0--> SSPM3-0 1000=MAESTRO reloj=f_osc/4*(sspadd+1)
- banksel SSPADD
- movlw b'00001011' ;.11 para 400khz @ 20 mhz
- movwf SSPADD ;400 khz @ 20 mhz
- ENDM
Código: ASM
- IIC_BUS MACRO
- BULK_PATCH_IIC
- CALL DEMORA_20MS
- CALL RECARGA2
- BTFSC DATO
- RETURN
- bcf INTCON,GIE ;DESACTIVAMOS LAS INTERRUPCIONES
- CALL RESET_DIRECCION ;APUNTA AL PAD 00, HABRA QUE BUSCAR LA FORMA DE SELECIONAR ENTRE VARIOS CADA 255 BYTES
- IIC_MEMO_READ
- BANKSEL SSPCON
- CALL IIC_START ;ENVIA LA CONDICION DE START
- MOVLW B'10100001' ;CONTROL BYTE--> |STARTBIT|1|0|1|0|A2|A1|A0|1 AUNQUE EN EL MANUAL ESTA A 0 PARA R/W |ACK<---este lo devuelve el esclavo|
- CALL IIC_ENVIA ;Y SE LO ENVIA A LA EEPROM
- CALL IIC_ADRESS ;MANDA DIRH,ESPERA ACK,MANDA DIRL, ESPERA ACK = |0|0|0|0|0|0|0|0|ACK|0|0|0|0|0|0|0|0|ACK|_DATO_8BITS_|ACK|_DATO_8BITS_|ACK|
- SIGUE_READ
- BANKSEL SSPCON
- BSF SSPCON, CKP ;INICIA EL RELOJ
- BANKSEL SSPCON2
- BSF SSPCON2,RCEN ;activa la recepcion
- BTFSC SSPCON2,RCEN ;ESPERA A TERMINAR LA RECEPCION
- GOTO $-1
- BTFSS SSPSTAT,BF ;dato disponible en SSPBUF para ser leido?
- GOTO $-1 ;no, esperar
- CALL IIC_SEND_ACK ;DEVUELVE EL ACK PARA QUE SEA VALIDO
- BANKSEL SSPCON
- BCF SSPCON, CKP ;Y APAGA EL RELOJ
- BANKSEL DIRL
- INCFSZ DIRL,F ;UNA VEZ LLEGA DE 255-0 SALE DE LA RUTINA
- GOTO GUARDA_PADS
- CALL IIC_STOP
- BSF INTCON,GIE
- IIC_STOP
- BANKSEL SSPCON2
- BSF SSPCON, CKP ;INICIA EL RELOJ
- BSF SSPCON2,PEN ;INICIA EL ESTADO STOP EN SDA SCL
- BTFSC SSPCON2,PEN
- GOTO $-1 ;ESPERA A QUE TERMINE
- BANKSEL SSPCON
- BCF SSPCON, CKP ;Y APAGA EL RELOJ
- RETURN
- IIC_SEND_NACK
- BANKSEL SSPCON2
- BSF SSPCON2,ACKDT ;A UNO PARA NO-ACK
- BSF SSPCON2,ACKEN ;CON ESTO ACTIVAMOS LA SECUENCIA DE ACKDT(ANTERIOR)
- BTFSC SSPCON2,ACKEN
- GOTO $-1 ;Y ESPERAMOS A QUE LA TERMINE
- RETURN ;VUELVE
- IIC_SEND_ACK
- BANKSEL SSPCON2
- BCF SSPCON2,ACKDT ;A CERO PARA ACK
- BSF SSPCON2,ACKEN ;CON ESTO ACTIVAMOS LA SECUENCIA DE ACKDT(ANTERIOR)
- BTFSC SSPCON2,ACKEN
- GOTO $-1 ;Y ESPERAMOS A QUE LA TERMINE
- RETURN ;VUELVE
- GUARDA_PADS
- BANKSEL SSPBUF
- MOVF SSPBUF,W
- BANKSEL REG_MUESTRA
- MOVWF REG_MUESTRA
- CALL ESCRITURA_EEPROM_IIC ;Y GUARDA EL DATO EN LA EEPROM
- GOTO SIGUE_READ
- IIC_IDLE
- BANKSEL SSPSTAT
- BTFSC SSPSTAT,R_W
- GOTO $-1
- movf SSPCON2,w ; POR QUE SE HACE ESTO SI POR UN CASUAL LA PRIMERA VEZ NO SE PONE A UNO Z A LA SIGUIENTE TAMPOCO
- andlw 0x1F
- btfss STATUS,Z
- goto $-3
- RETURN
- ESCRITURA_EEPROM_IIC
- BANKSEL DIRL
- MOVF DIRL,W ;Data Memory
- BANKSEL EEADR
- MOVWF EEADR ;Address to write
- CLRW
- ADDWF EEADR,F ;DE ESTA FORMA SE COMIENZA A CONTAR DESDE EL REGISTRO DE POTES
- GOTO CONTINUA_ESCRITURA
- IIC_ADRESS
- BANKSEL DIRH
- ; MOVF DIRH,W
- clrw
- CALL IIC_ENVIA
- BANKSEL DIRL
- ; MOVF DIRL,W
- clrw
- CALL IIC_ENVIA
- RETURN
- IIC_ENVIA
- CALL IIC_IDLE ;ESERA A QUE TERMINE LA ULTIMA TRANSMISION
- BANKSEL SSPBUF
- MOVWF SSPBUF ;CARGA EL DATO EN SSPBUFF
- BSF SSPCON, CKP ;NO HABRIA QUE ACTIVAR AQUÍ EL RELOJ PARA QUE EMPIEZE A ENVIAR
- BANKSEL SSPSTAT
- btfsc SSPSTAT,R_W ;esperar a que termine el envio
- goto $-1
- btfss SSPCON2,ACKSTAT ;checkear ack
- GOTO NO_ACK
- SALE_NCK
- BANKSEL PIR1
- btfss PIR1,SSPIF ;esperar finalizacion del noveno clock
- goto $-1
- bcf PIR1,SSPIF ;BAJA LA BANDERA
- BCF SSPCON, CKP ;Y TRAS TERMINAR DE RRECONOCER EL ACK APAGAR EL RELOJ
- RETURN
- NO_ACK
- BANKSEL DIRL
- MOVLW .255
- MOVWF DIRL
- goto SALE_NCK ;ESTO OBLIGA A SALIR DE LA RUTINA AL SOBREPASAR LOS 255
- RESET_DIRECCION
- BANKSEL DIRH ;CARGAMOS EN LOS REGISTROS DE DIRECCION A LA QUE QUEREMOS ACCEDER
- CLRF DIRH ;DE MOMENTO DIRECCION 00
- CLRF DIRL
- RETURN
- IIC_START
- CALL IIC_IDLE
- BANKSEL SSPCON2
- BSF SSPCON, CKP ;PRIMERO INICIA EL RELOJ
- BSF SSPCON2, SEN ;INICIA START
- BTFSC SSPCON2,SEN ;
- GOTO $-1 ;ESPERA A QUE TERMINE
- BANKSEL PIR1
- BTFSS PIR1,SSPIF ;ESPERA A LA BANDERA POR INTRRUPCION
- GOTO $-1
- BCF PIR1,SSPIF ;Y LA BAJA
- BCF SSPCON, CKP ;Y APAGA EL RELOJ
- RETURN
- ENDM
- ;------------------------------------------
un saludo y gracias
Publicado por: ivanovic en 17 de Mayo de 2013, 10:46:33
Publicado por: BrunoF en 23 de Mayo de 2013, 01:50:50
Lamentablemente no tengo la simulación, pero no debería ser dificil de hacerla!
Saludos!
Publicado por: inventor1967 en 09 de Julio de 2013, 03:17:37
Estoy tratando de controlar una 24c512 con un 18f4550 y no ha sido posible alguien lo ha logrado?
por favor si alguien logra encontrar donde estoy fallando le Agradeceré, adjunto la parte del código.
Código: [Seleccionar]
LEER MOVLW 0X01
CALL COMLC ;borra la patalla lcd
CALL INIVAR ;iniciar las varables
CALL INI2C ;para inicializar el puerto i2c
NLEER BCF PIR1,3
BSF SSPCON2,SEN ;CONDICION DE ARANQUE
BTFSS PIR1,SSPIF
GOTO NLEER
BCF PIR1,SSPIF
MOVLW 0XA1 ;Direccion de la memoria con la para leer
MOVWF DATOF,1 ;regeistro para almacenar lo que se enviara
CALL TRANSMT
MOVF DIREC2,W
MOVWF DATOF
CALL TRANSMT
MOVF UG,W
MOVWF DATOF
CALL TRANSMT
BSF SSPCON2,RCEN ;activa recepcion
YLLE BTFSC SSPCON2,RCEN
GOTO YLLE
MOVF SSPBUF,W
CALL ENCAJA ;llama subrrutina para visualizar en la lcd
MOVLW 0X35
CPFSEQ UG
GOTO NLEERE
YP NOP
GOTO YP
NLEERE INCF UG,1
MOVF UG,W
CALL CARLC
GOTO NLEER
;********************************************************
; *
;RUTINA PARA ENVIAR DIRECCIONES Y DATOS A LA MEM *
; *
;********************************************************
TRANSMT
MOVF DATOF,W
MOVWF SSPBUF
FTRA BTFSS PIR1,SSPIF
GOTO FTRA
SREC BTFSC SSPCON2,ACKSTAT
GOTO SREC
RETURN
;>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
;
; rutina para inicializar variables
;
;>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
INIVAR
MOVLW 0X00
MOVWF DIREC2
MOVLW 0X30
CLRF UG
MOVWF DIREC1,1
MOVLW 0X47
MOVWF M
;>>>>>>>>>>>>>>>>>>>>>>>
;
; rutina para inicializar el puerto
;
;>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
INI2C CLRF LATB
CLRF TRISB
CLRF SSPSTAT
BSF SSPSTAT,SMP
BSF SSPCON1,SSPM3
BSF SSPCON1,SSPEN
MOVLW 0X31
MOVWF SSPADD
MOVLW 0X28
MOVWF SSPCON1
CLRF SSPCON2
BSF TRISB,0
BSF TRISB,1
RETURN
;<><><<><>><>>>>>>>>>>><<<<<><<<>
Publicado por: lucas0214 en 30 de Octubre de 2013, 21:18:01
Desde ya muchas gracias por el aporte de siempre!!!!