I2C

Una cosa que he notado con los PIC16F1827 a diferencia de su antecesor PIC16F886, es que el reloj interno esta descalibrado de fabrica, no sé si son solo mis microcontroladores pero he programado en dos chips diferentes y es la misma cosa pero bueno, no importa, por fortuna podemos calibrar el reloj interno, esto lo menciono porque en los archivos asm que suelo dejar para que comprueben su código van a notar un segmento que no tiene nada que ver con la configuración del modulo MSSP así que de una vez lo pongo para que no se espanten.

NOTA: El código no utiliza las definiciones del archivo inc.

Esto es por dos razones, la primera es porque me gusta explorar el microcontrolador, ir a su banco y echarle ojo a los registros, y la segunda es porque le agrega un grado de ofuscación al código, así si por algún motivo alguien quiere usar tu código, de mínimo le va a costar trabajo interpretarlo, pero bueno ya queda al gusto de cada quien, de todas maneras a la derecha dejo su registro correspondiente para que lo cambien en caso de usar el inc.

;Configurando el reloj a 8MHZ
bsf 0x08,0 ;Banco 1
movlw 0x72
movwf 0x99 ;OSCCON
btfss 0x9A,4;OSCSTAT
goto $-1
btfss 0x9A,3
goto $-1
btfss 0x9A,0
goto $-1


Empezamos con la escritura-lectura de la memoria EEPROM, en este caso voy a utilizar la 24LC512.
Si leyeron la teoría, la primer secuencia después de iniciar la comunicación corresponde al Byte de control, pues bien, aquí esta el porque se le llama así, se debe a que este byte contiene el nibble de control < 4bits>, dirección del dispositivo < 3 bits> y el modo de operación (escritura/lectura) < 1 bit>.

El nibble de control, no es otra cosa si no un identificador, por ejemplo, supongamos que tenemos una memoria 24LC512 y un RTCC sobre el mismo bus, si quisiéramos acceder a la memoria, obviamente necesitaríamos un identificador, caso contrario, estaríamos accediendo al RTCC o viceversa, es por eso que cada dispositivo cuenta con un identificador.

Los siguientes 3 bits corresponden a la dirección, la memoria tiene 3 pines para indicar la dirección, los pines que lo controlan son los siguientes:

• A0
• A1
• A2

El valor va a depender de la conexión de los pines, por ejemplo, si ponen A0,A1 y A2 a gnd (Vss), este tendría un valor de 000, caso contrario, si A0 =+5V (Vcc), A1 y A2 los ponemos a tierra (Vss), el valor seria 001, y así sucesivamente.
Por lo tanto, esto quiere decir que sobre el mismo bus podemos acceder hasta 8 memorias diferentes, haciendo cuentas, esta memoria es de 8x64K = 512Kbytes, ahora 8x512k = 4096kbytes = 4 Mbytes de memoria.

El último bit, establece el modo de escritura/lectura, para la memoria 24LC512 el byte de control para:

•Escritura: <nibble>< 3 bits de dirección><0>
•Lectura: <nibble>< 3 bits de dirección><1>

Ejemplo practico, memoria 24LC512:
El nibble (id) para este dispositivo es 1010 (0xA), los siguientes 3 bits corresponden a la dirección del dispositivo (depende de la conexión de los pines A0,A1 y A2), entonces:

Para escritura el Byte de control sería: 0xA0 ↦ [id = 1010] [dirección = 000] [modo = 0] (escritura)
Para lectura el Byte de control sería: 0xA1 ↦ [id = 1010] [dirección = 000] [modo = 1] (lectura)

Escritura

Podemos escribir los datos de dos formas diferentes, ya sea de manera secuencial (page write), donde solo es necesario indicar la posición de inicio y la memoria se encarga automáticamente de guardar los datos en la posición siguiente, o de forma manual (byte write), donde tu le indicas en que posición quieres guardar el dato, para datos pequeños, algo asi como 4 registros o menos supongo que la manera manual esta bien, pero ya para datos muy grandes estar asignando las direcciones no se me hace muy eficiente, pero bueno, tu lo puedes hacer como más se adapte a tus necesidades.

Como soy muy buena persona lo vamos a hacer de las dos maneras, solo no olvides presionar el botón de donaciones.
Ya sea que utilices byte o page write en ambos casos necesitamos una subrutina para saber si el modulo esta listo para enviar y recibir datos al dispositivo esclavo.

Subrutina de espera:

 

i2c_espera_escritura clrf 0x08 ;Banco 0
btfss 0x11,3 ;SSP1IF = 1?
goto $-1 ;El modulo I2C todavia no esta listo
bcf 0x11,3 ;SSP1IF =0 (El modulo ya esta listo)
bsf 0x08,2 ;Banco 4 (Los registros del modulo estan en el banco 4)
return ;Necesita explicación? (Salimos de la subrutina)


 

Byte Write

 

bsf 0x216,0 ;SSP1CON2 (Secuencia S)
call i2c_espera_escritura ;Esta listo el modulo?
movlw 0xA0 ;Byte de control para escritura.
movwf 0x211 ;SSP1BUF (Enviamos el dato por la linea)
call i2c_espera_escritura ;Esta listo el modulo?
btfsc 0x216,6 ;ACKSTAT = 0? (ACK)
goto $-1 ;Esperamos el ACK
movlw 0x00 ;Adress High
movwf 0x211 ;SSP1BUF
call i2c_espera_escritura
btfsc 0x216,6 ;ACKSTAT = 0?
goto $-1
movlw 0x00 ;Adress Low
movwf 0x211 ;SSP1BUF
call i2c_espera_escritura
btfsc 0x216,6 ;ACKSTAT = 0?
goto $-1
movlw 0x0E ;Valor del dato
movwf 0x211 ;SSP1BUF
call i2c_espera_escritura
btfsc 0x216,6 ;ACKSTAT = 0?
goto $-1
bsf 0x216,1 ;R (Recuerdas la teoria?)
call i2c_espera_escritura ;Esta listo el modulo?
movlw 0xA0 ;Byte de control para escritura.
movwf 0x211 ;SSP1BUF (Enviamos el dato por la linea)
call i2c_espera_escritura ;Esta listo el modulo?
btfsc 0x216,6 ;ACKSTAT = 0? (ACK)
goto $-1 ;Esperamos el ACK
movlw 0x00 ;Adress High
movwf 0x211 ;SSP1BUF
call i2c_espera_escritura
btfsc 0x216,6 ;ACKSTAT = 0?
goto $-1
movlw 0x01 ;Adress Low
movwf 0x211 ;SSP1BUF
call i2c_espera_escritura
btfsc 0x216,6 ;ACKSTAT = 0?
goto $-1
movlw 0x0D ;Valor del dato
movwf 0x211 ;SSP1BUF
call i2c_espera_escritura
btfsc 0x216,6 ;ACKSTAT = 0?
goto $-1
bsf 0x216,2 ;STOP = 1
call i2c_espera_escritura
goto $+0 ;Fin


Eso sería todo en cuanto al método por byte write, como te puedes dar cuenta no es muy eficiente porque tienes que volver a mandar el byte de control cada vez que quieres añadir un nuevo dato, el más afectado sería la memoria programa del microcontrolador, por lo tanto no lo recomiendo, pero como siempre, todo depende de ti y tu aplicación.

Page Write

Para utilizar la escritura secuencial, es necesario definir dos variables, que nos van a ayudar a controlar la escritura.

clrf 0x220 ;Index del Program Counter.
movlw 0x08 ;Numero total de registros.
movwf 0x221


 

bsf 0x216,0 ;SPP1CON2 (Secuencia S)
call i2c_espera_escritura ;Esta listo el modulo?
movlw 0xA0 ;Byte de control para escritura
movwf 0x211 ;SSP1BUF (Lo enviamos por la linea)
call i2c_espera_escritura
btfsc 0x216,6 ;ACKSTAT = 0?
goto $-1
movlw 0x00 ;Hight adress byte
movwf 0x211 ;SSP1BUF
call i2c_espera_escritura
btfsc 0x216,6 ;ACKSTAT = 0?
goto $-1
movlw 0x00 ;Low adress byte
movwf 0x211 ;SSP1BUF
call i2c_espera_escritura
btfsc 0x216,6 ;ACKSTAT = 0?
goto $-1
n_datos movf 0x220,0
call datos
movwf 0x211 ;SSP1BUF
call i2c_espera_escritura
btfsc 0x216,6 ;ACKSTAT = 0?
goto $-1
incf 0x220,1
decfsz 0x221,1
goto n_dato
bsf 0x216,2 ;STOP = 1
call i2c_espera_escritura
goto $+0 ;Fin

datos addwf 0x02,1
dt 0x00,0x01,0x02,0x3,0x4,0x5,0x06,0x07 ;Datos a guardar en la EEPROM


Esto seria todo en cuanto a la programación por pagina, con solo este pequeño código podemos almacenar la cantidad de información que queramos, desde 4 bytes hasta 4Mb, para esta ejemplo solo guardamos ocho datos (0x00-0x07).
¿Te atreves a intentarlo con byte write?.

Lectura

Al igual que la escritura, la lectura se puede hacer dos maneras distintas, la primera es secuencial, en este modo necesitamos indicarle desde que posición de memoria (registro) queremos empezar y la memoria se encarga de ir automáticamente a la siguiente, y el segundo método es de manera aleatoria, en este modo se puede acceder a cualquier registro de la memoria de manera aleatoria, ambos modos utilizan la misma secuencia de inicialización, la única diferencia es que en modo secuencial después de que se transmite el primer byte de datos, el maestro le envia un ACK en lugar de un STOP como sucede en el modo aleatorio.

Hasta el día de hoy solo he utilizado el modo secuencial un par de ocaciones y eso para tareas muy especificas, en la practica he utilizado más el modo aleatorio, este modo es especialmente útil cuando por ejemplo, quieres mostrar un formato de fecha especifico basado en el DS1307, o quieres leer los registros de manera decremental, cosa que no se podría hacer en modo secuencial debido a que es n+1 posiciones de memoria.

NOTA: Con lo anterior no quiero decir que no es posible lograrlo de manera secuencial, por ejemplo se podría hacer la lectura de todos los registros de memoria, almacenarlos en algún registro ram local y después darle el formato, la única desventaja que le veo es que tienes que utilizar RAM y pudiera ser que mas ciclos de reloj de los necesarios.

Vamos a utilizar de nuevo la subrutina de i2c_espera_escritura, de echo vamos a definirla con otro nombre para que no haya confusiones, pero ten en cuenta que son exactamente lo mismo.

i2c_espera clrf 0x08
btfss 0x11,3
goto $-1
bcf 0x11,3
bsf 0x08,2
return


 

Lectura Aleatoria

 

clrf 0x220 ;Indice Program Counter
movlw 0x09
movwf 0x221 ;Numero total de registros+1


 

inicio decfsz 0x221,1
goto $+2
goto$+0
repetir bsf 0x216,1
call i2c_espera
movlw 0xA0 ;Control Byte (Escritura)
movwf 0x211 ;SSP1BUF
call i2c_espera
btfsc 0x216,6 ;ACKSTAT=0?
goto repetir ;Algunas veces es necesario volver a enviarle toda la secuencia
movlw 0x00 ;Hight address byte
movwf 0x211 ;SSP1BUF
call i2c_espera
btfsc 0x216,6 ;ACKSTAT=0?
goto $-1
movf 0x220,0
call registros ;Orden de las localidades de memoria a leer
movwf 0x211 ;SPP1BUF
call i2c_espera
btfsc 0x216,6 ;ACKSTAT=0?
goto $-1
bsf 0x216,1 ;RSEN
call i2c_espera
movlw 0xA1 ;Control Byte (Lectura)
movwf 0x211 ;SSP1BUF
call i2c_espera
btfsc 0x216,6 ;ACKSTAT=0?
goto $-1
bsf 0x216,3 ;RCEN=1 ;Obtenermos el dato
call i2c_espera
bsf 0x216,5 ;ACKDT=1
bsf 0x216,4 ;ACKEN=1
call i2c_espera
bsf 0x216,2 ;PEN=1
call i2c_espera
movf 0x211,0 ;Guardando lo recibido
call transmite ;Enviando el dato
incf 0x220,1
goto inicio


 

registros addwf 0x02,1
dt 0x07,0x06,0x05,0x04,0x03,0x02,0x01,0x00 ;Registros con la secuencia de lecura 


Con este código podemos leer de forma secuencial incremental, secuencial decremental o aleatoria la memoria EEPROM, por cierto la llamada a la subrutina transmite depende de su aplicación pueden por ejemplo sacar los datos por el puerto, o guardarlos en la EEPROM del microcontrolador, tal vez hacer operaciones, etc, la puse para que sepan en que parte ya pueden utilizar los datos.

Si tienen alguna duda de como usarlo, en la sección de Resultados pueden encontrar el código para leer la memoria EEPROM y mandar la salida por el puerto A del microcontrolador, espero que con esto les quede más claro como se utiliza.

ADVERTENCIA 1: Recuerden que los registros que controlan el MSSP para este microcontrolador están en el banco #4, por lo tanto su subrutina a la salida debe de poner de nuevo el registro BSR en 4.

ADVERTENCIA 2: Este código es validó únicamente para comunicarnos con la memoria 24LC512 o cualquier otro dispositivo que tenga las mismas secuencias, esto es debido a que utiliza dos bytes para establecer la dirección del registro, esto no quiere decir que no se pueda usar con otro dispositivo, solo es necesario revisar la secuencia y quitar ya sea el Hight o Low Address Byte.