I2C PIC Comunicación Serial

I2C PIC comunicación serial
I2C PIC es uno de los modos de trabajo del módudo SSP puerto serial síncrono
del microcontrolador PIC, en la comunicación I2C se utilizan 2 hilos a lo que se
conoce como bus I2C, a estos hilos se conectan los dispositivos que se puedan
comunicar mediante el protocolo I2C, por uno de los hilos se enviará una señal
de reloj para la sincronización y por el otro hilo se enviarán o recibirán datos,
se pueden conectar varios dispositivos de los que uno de ellos será el maestro,
es el que generará la señal de reloj además de decidir cuando se inicia o
finaliza la comunicación y si la comunicación será de recepción o transmisión de
datos, los demás dispositivos conectados al bus I2C se conocen como esclavos.
Cada uno de los dispositivos tiene una dirección, cuando el maestro necesita
comunicarse con alguno de los esclavos lo hará enviando la dirección del
esclavo a través del bus I2C, cuando el esclavo reciba su dirección podrá
comunicarse con el maestro, el maestro ademas tiene que enviar un bit
mediante el cual le indica al esclavo si quiere enviarle un dato o quiere recibir
un dato del esclavo.
El microcontrolador
PIC cuenta con el módulo SSP el que se utilizará en su modo de trabajo para la
comunicación serial I2C PIC, el microcontrolador PIC puede ser utilizado
como maestro o como esclavo en la comunicación serial I2C PIC.
Los pines que se utilizan en el modo I2C PIC son los nombrados
como SDA serial data y SCL serial clock, el pin SDA es para enviar o recibir los
datos, y el pin SCL es para la señal de reloj, estos pines deben ser declarados
como entradas digitales, ademas se les debe conectar mediante unas
resistencias que pueden ser de 4,7K a la tensión de alimentación del
microcontrolador PIC; los pines de los demás dispositivos conectados al bus I2C
también están nombrados como SDA y SCL, cuando no se estén
comunicando estos pines estarán normalmente en alto o a 1.
En la imagen se tiene la distribución de pines del PIC16F877A, se han resaltado

las ubicaciones de los pines SCL y SDA.
La velocidad de comunicación puede ser de hasta 100Kbps en el modo estandar

o normal, aunque puede llegar en el modo rápido hasta los 400Kbps y en la alta
hasta mas de 3Mbps, esto dependerá de los dispositivos utilizados, para ello es
recomendable revisar sus hojas de datos.
La comunicación I2C se realiza de la siguiente manera
 La señal del pin SDA del maestro pasa de un alto a un bajo mientras la
señal su pin SCL esté a un alto, esto es el inicio de la comunicación I2C, al
iniciar la comunicación se genera una señal de reloj por el pin SCL del
maestro y se empieza a enviar los datos por el pin SDA en grupos de 8
bits o un byte, que es lo mismo.
 El maestro enviará primero la dirección de identificación del esclavo con

el que se quiera comunicar junto con el bit de escritura lectura, si el
maestro quiere enviar o escribir un dato este bit será 0, si el maestro quiere
leer o recibir un dato este bit será 1, la dirección del esclavo normalmente
sera de 7 bits aunque también hay direcciones de 10bits.
 Cada vez que el esclavo reciba un byte el esclavo responderá enviando

un bit en bajo o 0 al maestro para indicar que se ha establecido la
comunicación, este es un bit de confirmación de hay comunicación y se le
llama ACK, si la comunicación no se establece el valor del bit ACK será un 1.
 Luego el maestro enviará el dato si lo que se quiere es enviar o escribir

un dato en el el registro del esclavo, el esclavo responderá enviando al
maestro el bit de confirmación ACK; pero si lo que se quiere es que el
maestro recibirá o lea algún dato desde algún registro del esclavo, ocurrirá
que si la recepción es correcta es maestro enviará al esclavo el bit de
confirmación ACK.
 Luego el maestro enviará el dato si lo que se quiere es enviar o escribir

un dato en el el registro del esclavo, el esclavo responderá enviando al
maestro el bit de confirmación ACK; o de lo contrario se recibirá algún dato
si se quiere leer o recibir un dato del registro del esclavo, si la recepción
es correcta es maestro enviará al esclavo el bit de confirmación ACK.
 Por último y para finalizar la comunicación la señal del pin SDA pasará
de un bajo a un alto mientras la señal de reloj en el pin SCL este en un alto,
en ese momento se deja de generar la señal de reloj y la comunicación
habrá terminado.
Las conexiones tienen que hacerse de tal manera que los nombres de los pines
coincidan, en la siguiente imagen se muestra como será la conexión para la
comunicación I2C PIC, al ser utilizado el PIC como maestro, con otros
dispositivos capaces de comunicarse con el protocolo I2C.
La intensión de esta sección es ver como utilizar el modo de trabajo I2C PIC del
módulo SSP para hacerlo trabajar con otros dispositivos, para mas información
sobre la comunicación I2C se puede visitar este enlace, este otro y muchos
mas.
I2C PIC PROGRAMACIÓN
Para programar la comunicación serial I2C PIC se recomienda mucho leer la
hoja de datos del PIC utilizado, es lo mejor que se puede hacer, como
referencia se verá para el PIC16F877A, para lo que se utilizan los siguientes
registros: el registro SSPSTAT, el registro SSPCON, el registro SSPCON2,
el registro SSPBUF, el registro SSPSR, el registro SSPADD y si se
utilizan interrupciones I2C PIC los registros PIE1 y PIR1.
El registro SSPSTAT es el registro para los estados del módulo la
comunicación serial síncrona SSP, en este caso en el modo I2C PIC.
El bit7 SMP este bit es para indicar si la la velocidad de la comunicación I2C

PIC será la estandar o en alta velocidad, si se pone a 1 la velocidad será la
standar, si se pone a 0 la velocidad será alta.
El bit6 CKE al poner este bit a 1 se utilizará en la comunicación I2C el bus del
tipo SMBUS, al poner este bit a 0 se utilizará en la comunicación I2C el bus del
tipo I2C.
El bit5 D/A este bit no tiene efecto en el maestro, para el esclavo si se pone a
1 indica que el último byte transmitido o recibido era un dato, si se pone a 0
indica que el último byte transmitido o recibido era una dirección.
El bit4 P este bit de estado si se pone a 1 indica que se ha detectado condición

de parada en la comunicación, si está a 0 indica que no hay condición de
parada en la comunicación.
El bit3 S este bit de estado si se pone a 1 indica que se ha detectado condición

de inicio en la comunicación, si está a 0 indica que no hay condición de inicio en
la comunicación.
El bit2 R/W en este bit se carga el bit que se envía junto con la dirección del
esclavo para hacer una lectura de datos del esclavo o una escritura de datos en
el esclavo, cuando es 1 indica que se hará una lectura de datos y cuando es 0
indica que se hará una escritura de datos.
El bit1 UA Este bit es para cuando la dirección del esclavo es de 10 bits, si se

pone a 1 indica que se necesita actualizar la dirección, si está a 0 no se la
necesita actualizar.
El bit0 BF Este bit indica el estado del registro SSPBUF, que es el registro

donde se pone el dato que se quiere transmitir o recibir en la comunicación I2C
PIC, cuando se transmite si este bit está a 1 indica que la transmisión está en
proceso o el registro SSPBUF está lleno, si está a 0 indica que se ha completado
la transmisión y que el registro SSPBUF está vacío, cuando se recibe si este bit
está a 1 indica que la recepción es completa o que el registro SSPBUF está
lleno, si está a 0 indica que la recepción no se ha completado o que el registro
SSBUF está vacío.
El registro SSPCON este es un registro de control para el módulo la

comunicación serial síncrona MSSP, en este caso en el modo I2C.
El bit7 WCOL para el maestro cuando este bit es 1 indica que se ha cargado

un dato en el registro SSPBUF sin que se cumplan las condiciones válidas del
I2C, si está a 0 todo esta bien; para el esclavo si este bit está a 1 indica que se
ha cargado un nuevo valor en este registro sin que se haya terminado de
transmitir el dato cargado previamente, si esta ha 0 todo esta bien.
El bit6 SSPOV este bit indica si han ocurrido sobreescrituras en el

registro SSPBUF, si se pone a 1 indica que ha ocurrido una sobreescritura sin
haberse leído el dato anterior, si está a 0 es porque se ha leído correctamente
el dato anterior.
El bit5 SSPEN este es el bit de habilitación del puerto serie asíncrono, es el bit

que permite el uso del I2C PIC, si se pone a 1 se habilita el uso del I2C PIC, si
se pone a 0 se deshabilita el uso del I2C PIC.
El bit4 CKP Este bit es para el control de la señal de reloj cuando el esclavo
está enviando un dato al maestro, mientras cargue el dato a enviar en el
registro SSPBUF este bit será puesto a 0 por el esclavo, cuando el dato enviar
esté cargado en el registro SSPBUF el esclavo pondrá este bit a 1.
Los bits 3, 2, 1 y 0 mediante las combinaciones de estos bits se elige la forma

de trabajo del módulo SSP, para el modo I2C se pueden hacer las siguiente
combinaciones:
Al elegir el modo maestro con la combinación 1000 se tendrá que utilizar la

fórmula que se ve para la velocidad de la comunicación, dependiendo de esta
velocidad se obtendrá un valor para cargar en el registro SSPADD.
El registro SSPCON2 este es otro registro de control para el módulo la

comunicación serial síncrona MSSP, en este caso en el modo I2C.
El bit7 GCEN este bit interviene cuando el PIC es utilizado como esclavo y

tiene su propia dirección de respuesta al maestro, al poner este bit a 1 el PIC
responde cuando el maestro envíe la dirección 0x0000 produciendo una
interrupción, si es puesto a 0 el bit no responderá a la llamada general.
El bit6 ACKSTAT este bit indica si se ha establecido la comunicación con el

esclavo, esto es si el esclavo le ha enviado el bit de reconocimiento ACK, si el
bit ACKSTAT se pone a 0 es que hay comunicación y se ha recibido el bit ACK
,si se pone a 1 es que no hay comunicación y el maestro no ha recibido el ACK.
El bit5 ACKDT este es el bit de reconocimiento que le enviará el maestro al

esclavo tras una recepción indicando que se ha recibido el dato, el bit de
reconocimiento se pondrá a 0 si se quiere seguir recibiendo mas datos del
esclavo, en caso que el maestro ya no quiera recibir mas datos se pondrá este
bit a 1.
El bit4 ACKEN si es puesto a 1 se habilita el envío por parte del maestro del
bit de reconocimiento ACK almacenado en el bit5 o ACKDT, si es puesto a 0 el
envío del bit ACKDT no estará habilitado.
El bit3 RCEN si es puesto a 1 se habilita la recepción I2C PIC de datos por
parte del maestro, si es puesto a 0 la recepción estará deshabilitada.
El bit2 PEN si es puesto a 1 detiene la comunicación I2C PIC, se pone a 0

automáticamente luego de detener la comunicación.
El bit1 RSEN si es puesto a 1 se reinicia la comunicación I2C PIC, luego se

pondrá a 0 automáticamente.
El bit0 SEN si es puesto a 1 inicia la comunicación I2C PIC, luego se pondrá

automáticamente a 0.
El registro SSPBUF en la comunicación I2C PIC en este registro se pondrá el

dato que se quiera transmitir hacia el esclavo, y también donde se encontrará
el dato recibido desde el esclavo, tiene esta doble función.
El registro SSPSR es un registro que trabaja junto con el registro SSPBUF, no

es accesible, cuando se carga un dato en el registro SSPBUF para ser enviado al
esclavo, el I2C PIC antes de enviar el dato lo carga en el registro SSPSR, desde
donde enviará el dato al esclavo; cuando se recibe un dato desde el esclavo, el
dato se recibe en el registro SSPSR, luego el I2C PIC lo pasa al registro SSPBUF
desde donde recién puede ser leido.
El registro SSPADD Cuando el microcontrolador es utilizado como esclavo, en

este registro se guarda su dirección para ser reconocido por el maestro, cuando
el microcontrolador es utilizado como maestro, en este registro se cargará el
valor con el que se elige la velocidad de transmisión de los datos, esto es los
baudios o la cantidad de bits por segundo que se enviarán en la comunicación
I2C PIC.
El valor a cargar en el registro SSPADD se calcula con la siguiente fórmula que

dependerán de la velocidad elegida, y de la frecuencia del oscilador utilizado.
Velocidad=Fosc/(4*(SSPADD+1))
Esta formula se puede reacomodar para obtener la siguiente fórmula:
SSPADD=(Fosc/(4*Velocidad))-1
Si se quiere por ejemplo una velocidad d 100Kbps, y el oscilador es de 4Mhz, si
en la fórmula anterior se reemplaza y se despeja se tendrá:
SSPADD=(4000000/(4*100000))-1
de donde:
SSPADD=9
Por lo que para obtener un una velocidad de 100Kbps se tendrá que cargar el
registro SSPADD con 9.
I2C PIC PROGRAMACIÓN en el XC8

Para la programación de la comunicación serial I2C PIC, cuando el PIC sea el
maestro se utilizará el XC8, ya que este permite trabajar directamente con los
registros y esto es de gran ayuda para conocer mucho mas sobre el manejo de
los microcontroladores PIC, en este caso se comentará como se puede proceder
para utilizar el módulo SSP en modo I2C PIC del PIC16F877A, lo aquí
comentado es muy similar para otros microcontroladores PIC.
Para iniciar el I2C PIC, siendo el PIC el maestro.
Los pines del PIC16F877A para el manejo de la comunicación I2C PIC son el pin
RC3 para la señal de reloj por lo que en este caso se le llama pin SCL, y el pin
RC4 para la transmisión y recepción de datos, en este caso se le llama pin SDA,
los pines serial clock SCL y serial data SDA se tienen que configurar como
entradas digitales, esto en el XC8 se puede hacer así:
TRISCbits.TRISC3=1;//pin SCL como una entrada digital
TRISCbits.TRISC4=1;//pin SDA como una entrada digital
Configuración del registro SSPSTAT para elegir el tipo de velocidad de la

comunicación y el tipo de bus a utilizar.
El bit7 se pondrá a 1 para que la comunicación I2C PIC sea a velocidad

estándar de 100Kbps.
El bit6 se pondrá a 0 para que la comunicación sea con las especificaciones I2C.
El bit5 se pondrá a 0 ya que no afecta directamente al maestro.
El bit4 se pondrá a 0 porque se está inicializando el I2C PIC y por lo tanto no se

ha detectado ningún bit de parada.

ha detectado ningún bit de incio.

ha realizado ninguna transmisión.

hay ninguna dirección que necesite actualización.
El bit0 se pondrá a 0 porque se está inicializando el I2C PIC y por lo tanto el

registro SSPBUF estará vacío.
Luego en la inicialización de de la comunicación serial I2C PIC el registro

SSPSTAT en el XC8 quedará así:
SSPSTAT=0b10000000;// velocidad standar, bus I2C
Configuración del registro SSPCON para habilitar la comunicación serial I2C

PIC y poner al microcontrolador PIC como maestro.
El bit7 se pondrá a 0 porque se está inicializando el I2C PIC y por lo tanto

no hay colisión de datos.
El bit6 se pondrá a 0 porque se está inicializando el I2C PIC y por lo tanto

no hay sobreescritura de datos.
El bit5 se pone a 1 para habilitar el uso del módulo SSP en modo I2C PIC.
El bit4 se pone a 0 este bit es utilizado por el pic cuando está en modo esclavo.
Los bits 3, 2, 1 y 0 la combinación utilizada para estos bits será 1000, ya que el
pic será el maestro.
Luego en la inicialización de la comunicación serial I2C PIC el

registro SSPCON en el XC8 quedará así:
SSPCON=0b00101000;// I2C PIC habilitado en modo maestro

Configuración del registro SSPCON2
El bit7 se pondrá a 0 ya que este bit es utilizado cuando el PIC trabaja como
esclavo.
El bit6 este bit trabaja en forma automática, se inicia a 0 porque aún no hay
comunicación y por tanto el maestro no ha recibido el bit ACK.
El bit5 se pone a 0 para que el bit de reconocimiento sea 0.
El bit4 se pondrá a 0 porque se está inicializando el I2C PIC se habilitará

en programa
El bit3 se pondrá a 0 porque se está inicializando el I2C PIC, se habilitará

para la recepción de datos.

cuando se quiera detener la comunicación I2C PIC.

cuando se quiera repetir o reiniciar la comunicación I2C PIC.

cuando se quiera iniciar la comunicación I2C PIC.
Luego en la inicialización de la comunicación serial I2C PIC el

registro SSPCON2 en el XC8 quedará así:
SSPCON2=0b00000000;// comunicación I2C no iniciada
Carga del registro SSPADD para los baudios o la cantidad de bits por

segundo para la comunicación serial I2C PIC, como será a velocidad estándar
por lo que el bit SMP del registro SSPSTAT se puso a 1, se utilizará la fórmula.
El valor a cargar en el registro SSPADD se calcula con la siguiente fórmula que

dependerán de la velocidad elegida, y de la frecuencia del oscilador utilizado.
Velocidad=Fosc/(4*(SSPADD+1))
Esta formula se puede reacomodar para obtener la siguiente fórmula:
SSPADD=(Fosc/(4*Velocidad))-1
Se utilizará una velocidad d 100Kbps, y el oscilador es de 4Mhz, si en la

fórmula anterior se reemplaza y se despeja se tendrá:
SSPADD=(4000000/(4*100000))-1
de donde:
SSPADD=9
Por lo que para obtener un una velocidad de 100Kbps se tendrá que cargar el
registro SSPADD con 9, luego en el XC8 será:
SSPADD=9;//para una velocidad de 100Kbps con un oscilador de 4Mhz
Entonces se puede iniciar el módulo SSP en modo I2C PIC en el XC8 de la

siguiente manera:
1 /////////////////////////////////////////////////////////////
2 /////////////////////////////////////////////////////////////
3 //inicialización del módulo SSP en modo I2C PIC en el XC8////
4 //para el PIC16F877A como maestro
5 //a 100Kbps con un oscilador de 4Mhz
6
7
8 TRISCbits.TRISC3=1; //pin SCL como una entrada digital
9 TRISCbits.TRISC4=1; //pin SDA como una entrada digital
10 SSPSTAT=0b10000000; // velocidad standar, bus I2C
11 SSPCON=0b00101000; // I2C PIC habilitado en modo maestro velocidad=Fosc/(4*SSPADD+1)
12 SSPCON2=0b00000000; // comunicación I2C no iniciada
13 SSPADD=9; //para una velocidad de 100Kbps con un oscilador de 4Mhz
La inicialización podría hacerse dentro de una función a la que se le puede dar

el nombre que se quiera, en este caso se la llamará i2c_iniciar() lo que en el
XC8 será así:
1 ////////////////////////////////////////////////////////////////////////////
2 /////////////////////////////////////////////////////////////////////////////
3 //inicialización del módulo SSP en modo I2C PIC en el XC8 en una función////
6
7 void i2c_iniciar(){

14 }
Antes de empezar una comunicación I2C se verificará si se cumple algunas

condiciones, ya que de lo contrario se puede interferir si se está realizando ya
alguna comunicación, por lo que se tendrá que esperar a que no se ha iniciado
ninguna comunicación, ni recepción ni transmisión, ni un inicio, ni un reinicio y
ni una parada, esto se realizará con una función a la que se le
llamará i2c_espera(), la que en el XC8 puede ser hecha así:
1 /////////////////////////////////////////////////////////////
2 ////////////////////////////////////////////////////////////
3 // Función de espera: mientras se esté iniciada una comunicación,
4 // esté habilitado una recepción, esté habilitado una parada
5 // esté habilitado un reinicio de la comunicación, esté iniciada
6 // una comunicación o se este transmitiendo, el IC2 PIC se esperará
7 // antes de realizar algún trabajo
8
9 void i2c_espera(){
10 while((SSPCON2 & 0b00011111) || (SSPSTAT & 0b00000100));
11 }
Para iniciar la comunicación I2C PIC, una vez inicializado el módulo SSP en
modo I2C PIC se puede iniciar la comunicación poniendo el bit0 SEN del
registro SSPCON2 a 1, pero esperando que se cumplan las condiciones
adecuadas con la función de espera, el inicio de la comunicación se hará
mediante una función a la que se le llamará i2c_inicia_com(), se le puede
llamar como se quiera, en el XC8 se puede hacer así:
1 /////////////////////////////////////////////////////////////
2 ////////////////////////////////////////////////////////////
3 // Función de inicio de la comunicación I2C PIC
4
5 void i2c_inicia_com() {
6 i2c_espera(); //espera que se cumplan las condiciones adecuadas
7 SSPCON2bits.SEN = 1; //inicia la comunicación i2c
8}
Para reiniciar la comunicación I2C PIC, si se quiere seguir realizando una
comunicación I2C PIC que ya se ha estado realizando y está por terminar se
puede reiniciar la comunicación poniendo el bit1 RSEN del registro SSPCON2 a
1, pero esperando que se cumplan las condiciones adecuadas con la función de
espera, el reinicio de la comunicación se hará mediante una función a la que se
le llamará i2c_reinicia_com(), se le puede llamar como se quiera, en el XC8
se puede hacer así:
1 ////////////////////////////////////////////////////////////
2 ////////////////////////////////////////////////////////////
3 // Función de reinicio de la comunicación I2C PIC
4
5 void i2c_reinicia_com(){
7 SSPCON2bits.RSEN = 1; //reinicia la comunicación i2c
8}
Para detener la comunicación I2C PIC, si ya no se quiere seguir realizando
una comunicación I2C PIC se puede detener la comunicación poniendo el
bit2 PEN del registro SSPCON2 a 1, pero esperando que se cumplan las
condiciones adecuadas con la función de espera, la parada de la comunicación
se hará mediante una función a la que se le llamará i2c_detener(), se le
puede llamar como se quiera, en el XC8 se puede hacer así:
1 /////////////////////////////////////////////////////////////
2 ////////////////////////////////////////////////////////////
3 // Función de parada de la comunicación I2C PIC
4
5 void i2c_detener() {
7 SSPCON2bits.PEN = 1; //detener la comunicación i2c

8}
Para la transmisión de datos del maestro al esclavo se espera a que se
cumplan las condiciones adecuadas luego se carga en el registro SSPBUF el
dato que se quiera enviar, el envío de datos se hará mediante una función a la
que sel llamará i2c_envia_dato(), se le puede llamar como se quiera, esta
función devolverá un 0 que se encontrará en el bit6 ACKSTAT del registro
SSPCON2 si el esclavo a recibido el dato correctamente, en el XC8 se puede
hacer así:
1 //////////////////////////////////////////////////////////////////
2 /////////////////////////////////////////////////////////////////
3 //Función de transmisión de datos del maestro al esclavo
4 //esta función devolverá un 0 si el esclavo a recibido
5 //el dato
6
7 unsigned char i2c_envia_dato(unsigned char dato) {
9 SSPBUF = dato; //cargar en el registro SSPBUF el dato a enviar
10 return ACKSTAT;//devuelve un 0 si la transmisión es correcta
11 }
Para la recepción de los datos leídos por el maestro desde el esclavo se
creará una variable donde se almacenará el dato leído, luego el maestro tendrá
que enviar el bit de reconocimiento ACKDT al esclavo, si el bit enviado es 0 se
le indica al esclavo que se seguirán recibiendo mas datos, si es un 1 se le indica
al esclavo que ya no se recibirán mas datos, la recepción de datos se hará
mediante una función a la que sel llamará i2c_recibe_dato(), se le puede
llamar como se quiera, esta función devolverá el dato recibido, en el XC8 se
puede hacer así:
1 //////////////////////////////////////////////////////////////////
2 /////////////////////////////////////////////////////////////////
3 //Función de recepción de datos enviados por el esclavo al maestro
4 //esta función es para leer los datos que están en el esclavo
5
6 unsigned char i2c_recibe_dato(){
7
8 unsigned char datoleido; //variable para guardar el dato que se reciba o lea
9 //del esclavo
10
12 SSPCON2bits.RCEN = 1; //reinicia la comunicación i2c, ya que la comunicación
13 //se ha tenido que iniciar antes, para enviar la
14 //dirección del esclavo y del registro a leer
15
17 datoleido = SSPBUF; //el dato recibido en el registro SSPBUF
18 //se guarda en la variable datoleido
19
21
22 SSPCON2bits.ACKDT = 1; //el maestro lo pone a 1 después de leer o recibir el dato,
23 //luego el maestro habilitará ACKAEN y enviará al esclavo
24 //el ACKDT para indicarle al esclavo que ya no se leerán
25 //mas datos
26
27 SSPCON2bits.ACKEN = 1;//inicia secuencia final de reconocimiento de SDA y SCL por
28 //parte del maestro para enviarle al esclavo el valor de ACKDT
29 //en este caso le enviará un 1 para decirle que ya no se
30 //recibirán mas datos
31 return datoleido;
32 }
ARCHIVO DE CABECERA PARA EL

USO DEL MÓDULO I2C PIC EN EL
XC8
Se puede agrupar todas la funciones vistas anteriormente para el uso del
módulo SSP en modo I2C PIC en el XC8 en modo maestro del PIC16F877A con
una velocidad de 100Kbps, en un archivo de cabecera al que se le llamará en
este caso i2c.h, aunque se le puede dar el nombre que se desee, se hará uso
de este archivo de cabecera en los ejemplos que se realizarán con el
PIC16F877A, si se utiliza otro pic u otra velocidad de comunicación es fácil
hacer los cambios que se necesiten dentro del archivo i2c.h, se verá algún
ejemplo.
1 ///////////////////////////////////////////////////////////////////////
2 ///////////////////////////////////////////////////////////////////////
3 //Archivo de cabecera para el uso del SSP en modo I2C PIC con el XC8///
4 //para el PIC 16F877A como maestro, la comunicación será a 100Kbps/////
5 //la frecuencia de trabajo del PIC16F877A es de 4Mhz, el archivo /////
6 //puede ser utilizado en otros PIC facilmente realizandole pequeños///
7 //cambios como los pines SCL y SDA, la Fosc, siempre revisar la hoja//
8 //de datos del PIC utilizado para comprobar los registros/////////////
9 ///////////////////////////////////////////////////////////////////////
10
11 #ifndef I2C_H
12 #define I2C_H
13
14 void i2c_iniciar(); //función para iniciar el módulo SSP en modo I2C PIC
15 void i2c_espera(); //función de espera
16 void i2c_inicia_com(); //función que inicia la comunicación I2C PIC
17 void i2c_reinicia_com(); //función que reinicia la comunicación I2C PIC
18 void i2c_detener(); //función que detiene la comunicación I2C PIC
19 unsigned char i2c_envia_dato(unsigned char ); //función para enviar o escribir
20 //datos en el esclavo
21 unsigned char i2c_recibe_dato(); //función para recibir o leer datos del esclavo
22
23 ///////////////////////////////////////////////////////////////////////////
24 /////////////////////////////////////////////////////////////////////////////

28
36 }
37
38 ////////////////////////////////////////////////////////////
39 ////////////////////////////////////////////////////////////
45
48 }
49
50 ////////////////////////////////////////////////////////////
51 ////////////////////////////////////////////////////////////
53
57 }
58
59 ////////////////////////////////////////////////////////////
60 ////////////////////////////////////////////////////////////

62
66 }
67
68 ////////////////////////////////////////////////////////////
69 ////////////////////////////////////////////////////////////
71
75 }
76
77 /////////////////////////////////////////////////////////////////
78 /////////////////////////////////////////////////////////////////
81 //el dato
82
87 }
88
89 /////////////////////////////////////////////////////////////////
90 /////////////////////////////////////////////////////////////////
93
95
97 //del esclavo
98
103
107
109
113 //mas datos
114
120 }
121
122 #endif /* I2C_H */

I2C PIC ejemplos
Compartir: 0
Anterior: I2C PIC Comunicación Serial.

I2C PIC ejemplos, en esta sección se realizarán algunos ejemplos realizados
con el XC8 sobre la utilización del módulo SSP en modo I2C PIC, esta es la
parte práctica de lo que se vio aquí, por lo que se recomienda antes de
continuar visitar el enlace indicado. Se utilizará el archivo de
cabecera i2c.h que se obtuvo para la transmisión y recepción de datos con el
I2C PIC, el microcontrolador PIC para realizar el I2C PIC ejemplos será
el PIC16F887A en un inicio, luego se complementará con otros PICS.
El archivo de cabecera i2c.h que se obtuvo para ser utilizado con el

PIC16F877A en el que la Fosc=4Mhz y la velocidad de comunicación será a
100Kbps es el siguiente, con algunas pequeñas modificaciones se puede utilizar
en cualquier otro PIC16xxx, si se utiliza otra Fosc y/o otra velocidad de
comunicación hay que hacer los cálculos
con SSPADD=(Fosc/(4*velocidad))-1 para el nuevo valor a cargar
en SSPADD.
1 ///////////////////////////////////////////////////////////////////////
2 ///////////////////////////////////////////////////////////////////////
3 //Archivo de cabecera para el uso del SSP en modo I2C PIC con el XC8///
4 //para el PIC 16F877A como maestro, la comunicación será a 100Kbps/////
5 //la frecuencia de trabajo del PIC16F877A es de 4Mhz, el archivo /////
6 //puede ser utilizado en otros PIC facilmente realizandole pequeños///
7 //cambios como los pines SCL y SDA, la Fosc, siempre rebisar la hoja//
8 //de datos del PIC utilizado para comprobar los registros/////////////
9 ///////////////////////////////////////////////////////////////////////
10
11 #ifndef I2C_H
12 #define I2C_H
13
14 void i2c_iniciar(); //función para iniciar el módulo SSP en modo I2C PIC
15 void i2c_espera(); //función de espera
16 void i2c_inicia_com(); //función que inicia la comunicación I2C PIC
17 void i2c_reinicia_com(); //función que reinicia la comunicación I2C PIC
18 void i2c_detener(); //función que detiene la comunicación I2C PIC
19 unsigned char i2c_envia_dato(unsigned char ); //función para enviar o escribir
20 //datos en el esclavo
21 unsigned char i2c_recibe_dato(); //función para recibir o leer datos del esclavo
22
23 ///////////////////////////////////////////////////////////////////////////
24 /////////////////////////////////////////////////////////////////////////////
28
36 }
37
38 ////////////////////////////////////////////////////////////
39 ////////////////////////////////////////////////////////////

45
48 }
49
50 ////////////////////////////////////////////////////////////
51 ////////////////////////////////////////////////////////////
53
57 }
58
59 ////////////////////////////////////////////////////////////
60 ////////////////////////////////////////////////////////////
62
66 }
67
68 ////////////////////////////////////////////////////////////
69 ////////////////////////////////////////////////////////////
71
75 }
76
77 /////////////////////////////////////////////////////////////////
78 /////////////////////////////////////////////////////////////////
81 //el dato
82
87 }
88
89 /////////////////////////////////////////////////////////////////
90 /////////////////////////////////////////////////////////////////

93
95
97 //del esclavo
98
103
107
109
113 //mas datos
114

120 }
121
122 #endif /* I2C_H */
I2C PIC EJEMPLOS
I2C PIC ejemplos 1 En este primer ejemplo se realizará la comunicación
serial I2C PIC entre el PIC16F877A, y la memoria EEPROM 24LC256 (revisar
su hoja de datos) la que está fabricada para
ser utilizada como esclavo en

la comunicación I2C, este integrado trae una dirección de fábrica para ser
utilizado como esclavo de 7 bits que es 1010(A2)(A1)(A0) los primeros 4 bits
son fijos los siguientes 3 se pueden elegir poniendo los pines A2, A1 y A0 a 0 o
a 1, si se utiliza una sola de estas memorias normalmente estos pines se ponen
a 0 para que su dirección sea 1010000, aunque se puede elegir otra
combinación.
El pin 8 es para la alimentación, el pin 4 es para el negativo, el pin 7 es para

bloquear la escritura en la eeprom si se pone a 1, se el pin 7 no se conecta o se
pone a 0 se podrá escribir en la eeprom.
El pin 6 SCL se conectará al pin SCL del PIC16F877A y el pin 5 SDA se

conectará al pin SDA del PIC.
Las direcciones de los registros de la EEPROM 24LC256 donde se guardarán los

datos están constituidos por 2 bytes, en este integrado se pueden almacenar
hasta 256Kbites.
El el ejemplo se enviarán o escribirán datos en la EEPROM mediante la

comunicación I2C, luego se leerán los datos enviados a la EEPROM y serán
vistos en forma binaria en el puerto D del PIC16F877A que será el maestro.
El ejemplo es sencillo para no complicar el código, pero se puede hacer lo que
se quiera mediante la comunicación I2C. La idea es muy similar por no decir la
misma si se utiliza otro tipo de dispositivo que se pueda utilizar como esclavo
en la comunicación I2C PIC.
En este ejemplo lo que se busca es que se vea como utilizar el archivo de

cabecera i2c.h ya que será el utilizado en los siguientes I2C PIC ejemplos.
En la siguiente imagen se ha creado un proyecto llamado i2c_ejemplo_1, con

el archivo fuente llamado i2c_ejemplo_1.c, en la parte resaltada Header
Files se hace click derecho y en New se selecciona C Header File…, en la
ventana que aparece dentro de File Name se le da el nombre
de i2c en Extension debe estar selecciona da la opción h, y se pulsa
sobre Finish así se creará el archivo llamado i2c.h, luego se hace doble click
sobre el archivo i2c.h creado para abrir el editor i2c.h, se borra todo lo que el
programa genere, que quede limpio, se copia el contenido mostrado lineas
arriba y se pega dentro de i2c.h, el resultado debe ser similar al que se ve en la
siguiente imagen.
A partir de este momento ya se puede utilizar el archivo de cabecera i2c.h para
realizar la comunicación serial con el módulo SSP en modo I2C PIC
El circuito utilizado para el I2C PIC ejemplos 1 es el siguiente:

En el código para el PIC16F877A que será el maestro se tiene que crear una
función para la escritura y otra función para la lectura de la memoria EEPROM,
hay que seguir un orden en cuanto a la lectura y escritura en la comunicación
serial I2C PIC, eso se puede ver aquí, será realizado en el XC8, los pasos que
se siguen estarán comentados en el código, en caso de utilizar otro dispositivo
como esclavo se seguirán los mismos pasos.
1 //////////////////////////////////////////////
2 ///////*********************************///////
3 ///*** microcontroladores-mrelberni.com ***////
4 ///////*****************************//////////
5 //* I2C PIC ejemplos 1 código para el maestro PIC16F877A* //
6 ///////********************************///////
7
8 //bits de configuración del PIC16F877A
9 #pragma config FOSC = XT // Oscillator Selection bits (XT oscillator)
10 #pragma config WDTE = OFF // Watchdog Timer Enable bit (WDT disabled)
11 #pragma config PWRTE = ON // Power-up Timer Enable bit (PWRT enabled)
12 #pragma config BOREN = ON // Brown-out Reset Enable bit (BOR enabled)
13 #pragma config LVP = OFF // Low-Voltage (Single-Supply) In-Circuit
14 #pragma config CPD = OFF // Data EEPROM Memory Code Protection bit
15 #pragma config WRT = OFF // Flash Program Memory Write Enable bits
16 #pragma config CP = OFF // Flash Program Memory Code Protection bit
17
18 #define _XTAL_FREQ 4000000 //cristal de 4Mhz
19 #include <xc.h>
20 #include "i2c.h" //incluye el archivo de cabecera el que se ha creado
21 //en Header Files para utilizar la funciones necesarias,
22 //para el uso del módulo SSP en modo I2C PIC
23
24 void escribe_eeprom(unsigned int dir_men_eep, unsigned char dato); //prototipo de función
25 //para escribir o enviar datos a la memoria EEPROM 24LC256
26
27 unsigned char leer_eeprom(unsigned int dir_men_eep); //prototipo de función para leer
28 //o recibir datos de la memoria EEPROM 24LC256
29
30 void main(void) {
31 TRISD=0b00000000; //todos los pines de puerto D como salidas para conectar los leds
32 //que permitirán ver el dato leido desde la EEPROM en forma binaria
33 PORTD=0x00; //Los leds inician apagados
34
35 i2c_iniciar(); //inicia el móduco SSP en modo I2C PIC
36
37 while(1){//ciclo del programa
38
39 for(unsigned char i=0;i<=50;i++){//en las direccienes que van desde 0 a 50
40 escribe_eeprom(i,i); //de la EEPROM se enviarán o escribirán sus
41 //mismas direccione
42 __delay_ms(20); //pausa de 20ms para darle tiempo a la eepron
43 } //a que reciba bien los datos
44
45 for(unsigned char i=0;i<=50;i++){//para las direcciones de memoria de la EEPROM
46 //de la 0 a la 50
47 PORTD=leer_eeprom(i); //menvia al puerto D el valor leido en la
48 //posición de memoria, será visto en forma
49 //binaria con leds
50
51 for(int j=0;j<1000;j++){//pausa para que el dato leido en el
52 __delay_ms(1); //puerto D sea visto cada segundo
53 }
54 }
55 }
56 return;
57 }
58
59 //Función para enviar o escribir datos en la memoria EEPROM 24LC256
60 //creada con las funciones que están en el archivo de cabecera i2c.h
61 //la función se le ha llamado escribe_eeprom, hay que darle dos parámetros
62 //el primero es la dirección del registro de la memoria EEPROM donde se quiere
63 //esccribir el dato, y el segundo el dato a ser escrito
64
65 void escribe_eeprom(unsigned int dir_men_eep, unsigned char dato){
66 i2c_inicia_com(); //inicia la comunicación serial i2C PIC
67
68 i2c_envia_dato(0xa0);//envía la dirección del esclavo con el que el maestro se
69 //se quiere comunicar, en este cado de la EEPROM de quien su
70 //dirección es de 7 bits (1010000) junto con el bit 0
71 //que es el que le indica al esclavo que el maestro quiere
72 //enviar o escribir un dato en la EEPROM,
73 //por lo que se envia 10100000 que en hexadecimal es 0xa0
74
75 //lo que sigue es enviar la dirección del registro de la memoria EEPROM donde se
76 //escribirá el dato enviado por el maestro PIC16F877A, como estas direcciones en
77 //la EEPROM 24LC256 son de 2 bytes, se envía primero la parte alta de esta dirección
78 //y luego la parte baja de esta dirección
79 i2c_envia_dato(dir_men_eep>>8); //envia parte alta de la direccion del registro

80 //de la EEPROM donde se guardará el dato
81 i2c_envia_dato(dir_men_eep); //envia parte baja de la direccion del registro
82 //de la EEPROM donde se guardará el dato
83
84 //Lo que sigue es enviar el dato a la dirección del registro de la memoria EEPROM
85 //donde se guardará el dato.
86 i2c_envia_dato(dato);//envia o escribe el dato en la dirección del registro
87 //elegido de la memoria EEPROM
88
89 //una vez que el esclavo recibe el dato se terminará la comunicación I2C PIC
90 i2c_detener(); //finaliza la comunicación I2C PIC
91 }
92
93 //Función para recibir o leer datos desde la memoria EEPROM 24LC256
94 //creada con las funciones que están en el archivo de cabecera i2c.h
95 //la función se le ha llamado leer_eeprom, hay que darle un parámetro
96 //que será la dirección del registro de la memoria EEPROM que se desea leer
97 //o de donde se quiere recibir el dato
98 unsigned char leer_eeprom(unsigned int dir_men_eep){
99 unsigned char dato;//variable donde se guardará el dato leído desde la EEPROM
100
101 i2c_inicia_com(); //inicia la comunicación serial i2C PIC
102
103 i2c_envia_dato(0xa0);//envía la dirección del esclavo con el que el maestro se

104 //se quiere comunicar, en este cado de la EEPROM de quien su
105 //dirección es de 7 bits (1010000) junto con el bit 0
106 //que es el que le indica al esclavo que el maestro quiere
107 //enviar o escribir un dato en la EEPROM,
108 //por lo que se envia 10100000 que en hexadecimal es 0xa0
109
110 //lo que sigue es enviar la dirección del registro de la memoria EEPROM de donde
111 //el maestro PIC16F877A leerá o recibirá el dato, como estas direcciones en
112 //la EEPROM 24LC256 son de 2 bytes, se envía primero la parte alta de esta dirección
113 //y luego la parte baja de esta dirección
114 i2c_envia_dato(dir_men_eep>>8); //envia la parte alta de la direccion del registro
115 //de la EEPROM de donde se leerá el dato
116 i2c_envia_dato(dir_men_eep); //envia la parte baja de la direccion del registro
117 //de la EEPROM de donde se leerá el dato
118
119 //lo que sigue una vez que ya se le dijo al esclavo donde se leerá es reiniciar la
120 //comunicación serial I2C PIC
121 i2c_reinicia_com();//reinicia la comunicación I2C PIC
122
123 //a continuación se vuelve a enviar la dirección del esclavo con el que el maestro se
124 //está comunicanco, en este cado de la EEPROM de quien su dirección es de 7 bits (1010000)
125 //pero esta vez junto con el bit 1 que es el que le indica al esclavo que el maestro
126 //quiere leer o recibir un dato de la EEPROM, por lo que se envia 10100001
127 //que en hexadecimal es 0xa1

128 i2c_envia_dato(0xa1);//dirección de la eeprom junto con el 1 para lectura
129
130 //luego se lee el dato de la ubicación de la memoria elegida de la EEPROM
131 //y se guarda en la variable dato creada en un inicio dentro de esta función
132 dato=i2c_recibe_dato();//lectura del dato de la ubicación de la memoria elegida
133
134 //una vez que el maestro lee o recibe el dato se terminará la comunicación I2C PIC
135 i2c_detener(); //finaliza la comunicación I2C PIC
136
137 return dato; //la función devolverá el dato leído desde la EEPROM y guardado en
138 //la variable dato
139 }
La siguiente es una imagen del circuito de prueba realizado para el I2C PIC
ejemplos 1
I2C PIC ejemplos 1

I2C PIC Comunicación Serial

Cargado por

Información del documento

Título original

Derechos de autor

Formatos disponibles

Compartir este documento

Compartir o incrustar documentos

Opciones para compartir

¿Le pareció útil este documento?

¿Este contenido es inapropiado?

Copyright:

Formatos disponibles

I2C PIC Comunicación Serial

Cargado por

Copyright:

Formatos disponibles

I2C PIC comunicación serial

En la imagen se tiene la distribución de pines del PIC16F877A, se han resaltado

La velocidad de comunicación puede ser de hasta 100Kbps en el modo estandar

La comunicación I2C se realiza de la siguiente manera

 El maestro enviará primero la dirección de identificación del esclavo con

 Cada vez que el esclavo reciba un byte el esclavo responderá enviando

 Luego el maestro enviará el dato si lo que se quiere es enviar o escribir

 Luego el maestro enviará el dato si lo que se quiere es enviar o escribir

El bit7 SMP este bit es para indicar si la la velocidad de la comunicación I2C

El bit4 P este bit de estado si se pone a 1 indica que se ha detectado condición

El bit3 S este bit de estado si se pone a 1 indica que se ha detectado condición

El bit1 UA Este bit es para cuando la dirección del esclavo es de 10 bits, si se

El bit0 BF Este bit indica el estado del registro SSPBUF, que es el registro

El registro SSPCON este es un registro de control para el módulo la

El bit7 WCOL para el maestro cuando este bit es 1 indica que se ha cargado

El bit6 SSPOV este bit indica si han ocurrido sobreescrituras en el

El bit5 SSPEN este es el bit de habilitación del puerto serie asíncrono, es el bit

Los bits 3, 2, 1 y 0 mediante las combinaciones de estos bits se elige la forma

Al elegir el modo maestro con la combinación 1000 se tendrá que utilizar la

El registro SSPCON2 este es otro registro de control para el módulo la

El bit7 GCEN este bit interviene cuando el PIC es utilizado como esclavo y

El bit6 ACKSTAT este bit indica si se ha establecido la comunicación con el

El bit5 ACKDT este es el bit de reconocimiento que le enviará el maestro al

El bit2 PEN si es puesto a 1 detiene la comunicación I2C PIC, se pone a 0

El bit1 RSEN si es puesto a 1 se reinicia la comunicación I2C PIC, luego se

El bit0 SEN si es puesto a 1 inicia la comunicación I2C PIC, luego se pondrá

El registro SSPBUF en la comunicación I2C PIC en este registro se pondrá el

El registro SSPSR es un registro que trabaja junto con el registro SSPBUF, no

El registro SSPADD Cuando el microcontrolador es utilizado como esclavo, en

El valor a cargar en el registro SSPADD se calcula con la siguiente fórmula que

Esta formula se puede reacomodar para obtener la siguiente fórmula:

I2C PIC PROGRAMACIÓN en el XC8

TRISCbits.TRISC3=1;//pin SCL como una entrada digital

TRISCbits.TRISC4=1;//pin SDA como una entrada digital

Configuración del registro SSPSTAT para elegir el tipo de velocidad de la

El bit7 se pondrá a 1 para que la comunicación I2C PIC sea a velocidad

El bit5 se pondrá a 0 ya que no afecta directamente al maestro.

El bit4 se pondrá a 0 porque se está inicializando el I2C PIC y por lo tanto no se

El bit3 se pondrá a 0 porque se está inicializando el I2C PIC y por lo tanto no se

El bit2 se pondrá a 0 porque se está inicializando el I2C PIC y por lo tanto no se

El bit1 se pondrá a 0 porque se está inicializando el I2C PIC y por lo tanto no se

El bit0 se pondrá a 0 porque se está inicializando el I2C PIC y por lo tanto el

Luego en la inicialización de de la comunicación serial I2C PIC el registro

Configuración del registro SSPCON para habilitar la comunicación serial I2C

El bit7 se pondrá a 0 porque se está inicializando el I2C PIC y por lo tanto

El bit6 se pondrá a 0 porque se está inicializando el I2C PIC y por lo tanto

Luego en la inicialización de la comunicación serial I2C PIC el

SSPCON=0b00101000;// I2C PIC habilitado en modo maestro

El bit5 se pone a 0 para que el bit de reconocimiento sea 0.

El bit4 se pondrá a 0 porque se está inicializando el I2C PIC se habilitará

El bit3 se pondrá a 0 porque se está inicializando el I2C PIC, se habilitará

El bit2 se pondrá a 0 porque se está inicializando el I2C PIC, se habilitará

El bit1 se pondrá a 0 porque se está inicializando el I2C PIC, se habilitará

El bit0 se pondrá a 0 porque se está inicializando el I2C PIC, se habilitará

Luego en la inicialización de la comunicación serial I2C PIC el

SSPCON2=0b00000000;// comunicación I2C no iniciada

Carga del registro SSPADD para los baudios o la cantidad de bits por

El valor a cargar en el registro SSPADD se calcula con la siguiente fórmula que

Esta formula se puede reacomodar para obtener la siguiente fórmula:

Se utilizará una velocidad d 100Kbps, y el oscilador es de 4Mhz, si en la

Entonces se puede iniciar el módulo SSP en modo I2C PIC en el XC8 de la

3 //inicialización del módulo SSP en modo I2C PIC en el XC8////

4 //para el PIC16F877A como maestro