Introducción
1980: Philips desarrolla el Bus de 2 alambres I2C para la comunicación de circuitos integrados.
Se han otorgado licencias a mas de 50 compañías, encontrándonos con más de 1000 dispositivos electrónicos compatibles con I2C.
Originalmente fue especificado para 100 kbits/s, e intencionalmente, para el control simple de señales, esto, sumado a su bajo costo, versatilidad técnica y simplicidad aseguraron su popularidad.
Evolución Del Bus I2C
Actualmente el Bus ha sido modificado para alcanzar velocidades de hasta 3.4 Mbits/s.
Combinado con una función de desplazamiento del nivel de voltaje, en modo High-speed (Hs-mode) ofrece una solución ideal para los sistemas de tecnología mezclada, donde las altas velocidades y la variedad de voltajes (5 V, 3 V o menor) son comúnmente usados.
El modo Hs es compatible con todos los sistemas existentes del bus I2C, incluyendo el estándar original (S-mode) y el modo Fast (F-mode), actualización introducida en 1992, proveyendo 400 kbits/s en transferencia.
Diferentes sistemas de velocidad pueden ser mezclados fácilmente, con un dispositivo maestro en modo Hs especialmente desarrollado, la conexión en paralelo es usada para conectar las partes más lentas del sistema, todos los dispositivos en modo Hs se comunicarán bidireccionalmente a toda velocidad mientras se utilicen los modos F/S (Fast/Standard) de velocidades con las partes más lentas del sistema.
Principales Equipos Con El Bus Incorporado
Los procesadores de señal o "jungla" en televisores (LA7610, TA1223, DTC810,…)
Memorias 24Cxx
Codificadores de video de reproductores de DVD (SAA 7128, TC 90A32F,…)
Preamplificadores de video en monitores (KB 2502 )
Etc…
Características más salientes del bus I2C son:
Se necesitan solamente dos líneas, la de datos (SDA) y la de reloj (SCL).
Cada dispositivo conectado al bus tiene un código de dirección seleccionable mediante software. Habiendo permanentemente una relación Master/ Slave entre el micro y los dispositivos conectados.
El bus permite la conexión de varios Masters, ya que incluye un detector de colisiones.
El protocolo de transferencia de datos y direcciones posibilita diseñar sistemas completamente definidos por software.
Los datos y direcciones se transmiten con palabras de 8 bits.
Criterios para Utilizar I2C
Un sistema consiste en al menos un microcontrolador y varios sistemas periféricos como memorias o circuitos diversos.
El costo de conexión entre los varios dispositivos dentro del sistema debe de ser el mínimo.
El sistema que utiliza este Bus no requiere una alta tasa de transferencia de datos.
La total eficacia del sistema depende de la correcta selección de la naturaleza de los dispositivos y de la interconexión de la estructura del bus.
Protocolo
Terminología básica del Bus I2C
Instrucciones en el I2C Bus
Para operar un esclavo sobre el Bus I2C solo son necesarios seis simples pasos, suficientes para enviar o recibir información.
Un bit de Inicio
7-bit o 10-bit de direccionamiento
Un R/W bit que define si el esclavo es transmisor o receptor
Un bit de reconocimiento
Mensaje dividido en bytes
Un bit de Stop
Condiciones de Inicio (Start) y Stop
Dentro del proceso de transferencia de datos en el bus I2C hay dos situaciones básicas que son el inicio y el Stop de toda transferencia de datos. Estas son:
– INICIO (START) – Una transición de "1" a "0" (caída) en la línea de datos (SDA) mientras la línea del reloj (SCL) esta a "1".
– PARADA (STOP) – Una transición de "0" a "1" (ascenso) en la línea de datos (SDA) mientras la línea de reloj (SCL) esta a "1"
Las condiciones de Inicio y Stop son siempre generadas por el Master. El Bus I2C se considera ocupado después de la condición de Inicio. El Bus se considera libre de nuevo después de un cierto tiempo tras la condición de Stop.
Transfiriendo datos
El numero de bytes que se envíen a la línea SDA no tiene restricción.
Si un dispositivo esclavo no puede recibir o transmitir un byte de datos completo hasta que haya acabado alguno de los trabajos que realiza, puede mantener la línea SCL a "0" lo que fuerza al Master a permanecer en un estado de espera. Los datos continúan transfiriéndose cuando el dispositivo esclavo esta listo para otro byte de datos y desbloquea la línea de reloj SCL.
Reconocimiento
El bit de reconocimiento es obligatorio en la transferencia de datos. El pulso de reloj correspondiente al bit de reconocimiento (ACK) es generado por el Master. El Transmisor desbloquea la línea SDA ("1") durante el pulso de reconocimiento. El receptor debe poner a "0" la línea SDA durante el pulso ACK de modo que siga siendo "0" durante el tiempo que el master genera el pulso "1" de ACK.
Un master puede iniciar una transmisión solo si el bus esta libre. Dos o mas master pueden generar una condición de Inicio en el bus lo que da como resultado una condición de Inicio general. Cada Master debe comprobar si el bit de datos que transmite junto a su pulso de reloj, coincide con el nivel lógico en la línea de datos SDA. El sistema de arbitraje actúa sobre la línea de datos SDA, mientras la línea SCL esta a nivel "1", de una manera tal que el master que transmite un nivel "1", pierde el arbitraje sobre otro master que envía un nivel "0" a la línea de datos SDA. Esta situación continua hasta que se detecte la condición de Stop generada por el master que se hizo cargo del Bus.
Procedimiento de Arbitraje entre dos Master
Formato
Los datos transferidos tienen la siguiente forma estándar:
Después de la condición de Start un código de dirección de un esclavo es enviada, esta dirección tiene 7 bits seguidos por un octavo código que corresponde a una dirección R/W (0-indica transmisión/1-indica solicitud de datos). Una transferencia de datos siempre acaba con una condición de Stop generado por el master, sin embargo si un master todavía desea comunicarse con el bus, puede generar repetidamente condiciones de Start y direccionar a otro esclavo sin generar primero la condición de stop.
Comunicación I2C entre Microcontrolador MSP430F149 y Memoria EEPROM 24LC515
Comunicación I2C entre Microcontrolador MSP430F149 y Memoria EEPROM 24LC515
MSP430F149 no posee hardware para el protocolo I2C, entonces debe ser implementado por software.
En la tarjeta EasyWeb se comunica el microcontrolador (maestro) y la memoria EEPROM (esclavo), a través de I2C:
-Comunicación I2C en memoria EEPROM.
-Comunicación I2C en microcontrolador.
Esquema de conexiones I2C implementado en la tarjeta
Comunicación I2C en Memoria EEPROM
Capacidad 64KB y preparada para operar a 400KHz
8 pines en total:
A0 ? Direccionamiento
A1 ? Direccionamiento
A2 ? Conectado a +Vcc
GND ? Tierra
SDA ? Señal Datos Serial
SCL ? Señal Reloj
WP ? Bloque de escritura
Vcc ? +2.5 [V] a +5.5 [V]
Comunicación I2C en Memoria EEPROM
2 bits para direccionamiento ? 4 dispositivos esclavos en paralelo (ej: 4 EEPROM).
Un Bus de dos líneas bi-direccionales SDA y SCL, el dispositivo maestro controla el Bus a través de la señal SCL.
Tanto maestro (microcontrolador) y esclavo (EEPROM) pueden transmitir o recibir.
Comunicación I2C en Memoria EEPROM
Por cada Byte enviado correctamente el receptor debe generar un pulso de “acuso de recibo” (ACK). (Transmisor debe desocupar la línea).
Existen cuatro estados de interés del Bus:
Estado SDA SCL
Bus Desocupado Alto Alto
Partida de Tx Canto de bajada Alto
Detención de Tx Canto de subida Alto
Dato Válido Datos Bajo
Direccionamiento del Dispositivo
Byte de Control:
– Código control ? código que indica modo de operar. (1010 = R/W).
– Bit B0 para acceder a cada mitad de memoria.
– A0 y A1 coincide con pines ? selecciona el dispositivo.
– R/W un ‘1’ si se lee y un ‘0’ si se ecribe.
Se envía en dos bytes la dirección de memoria con que se pretende operar.
Direccionamiento del Dispositivo
Escritura en Memoria
2 formas de escribir en memoria (el bit R/W del Byte de control debe estar en ‘0’):
– Escritura por byte.
– Escritura por Página.
Escritura en Memoria
Escritura por Byte:
-Se direcciona la parte de la memoria que será escrita.
-Se envía byte que se desea escribir.
-Luego se genera condición de parada y se detiene comunicación.
-Se escribe byte en memoria.
Escritura en Memoria
Escritura por Página:
-Igual que escritura por byte, pero en ves de generar la parada se sigue enviando bytes.
-Se genera condición de parada.
-Se escribe en memoria TODOS los bytes enviados.
Lectura en Memoria
Existe un puntero local de direccionamiento en la memoria.
3 maneras de leer la memoria EEPROM (bit R/W de Byte de control debe estar en ‘1’):
– Lectura de Dirección Actual.
– Lectura Aleatoria.
– Lectura Secuencial.
Lectura en Memoria
Lectura de Dirección Actual:
-Se envía byte de control con bit R/W en ‘1’.
-Memoria responde con contenido de la dirección a la que apunta el puntero local de direccionamiento .
-Condición de parada
Lectura en Memoria
Lectura Aleatoria:
-Se direcciona el Byte que será leído (bit R/W en escritura ‘0’) .
-Se genera condición de partida nuevamente (no mueve puntero).
-Se envía Byte de control con bit R/W en lectura ‘1’.
-EEPROM responde contenido de la dirección deseada.
-Condición de parada (puntero sobre siguiente dirección).
Lectura en Memoria
Lectura Secuencial:
-Se direcciona el Byte que será leído (bit R/W en escritura ‘0’)
-Se genera condición de partida nuevamente (no mueve puntero)
-Se envía Byte de control con bit R/W en lectura ‘1’
-EEPROM responde contenido de la dirección deseada.
-Microcontrolador envía ACK
-EEPROM transmite siguiente contenido de dirección secuencial
-Para interrumpir, en vez de ACK se envía condición de parada
Comunicación I2C en Microcontrolador
Se utiliza los pines 0 y 1 del puerto 4:
-Pin P4.0 es la línea SDA (transmisión de datos)
-Pin P4.1 es la línea SCL (reloj)
Configuración de Puerto 4 necesita de 4 registros:
-P4IN registro que almacena dato recibido (entrada).
-P4OUT registro que almacena dato transmitido (salida).
-P4DIR registro que controla si se actuará como receptor o transmisor. (Transmisor-> ‘1’ Receptor->’0’).
-P4SEL registro que indica que función cumplirá el pin, para operar en modalidad I2C debe estar en ‘0’
Implementación de I2C por software para manejo de EEPROM en tarjeta Easy Web II
Configuración de
Puertos para dejar SDA y
SCL en niveles altos
Inicializaciones
Start
Lectura de
Datos
ACK=0 ?
R/W=0 ?
Escribir
Datos
Notar que para procesos
de Lectura Aleatoria y
Secuencial, se debe realizar
una secuencia de escritura para
direccionar.
ACK=0 ?
STOP=1 ?
Stop
SI
NO
SI
NO
SI
NO
SI
NO
Tres tipos:
Lectura Aleatoria.
Lectura Secuencial.
Lectura Dirección Actual.
Byte de
Control
Diagrama de Flujo: Programación.
Funciones de control de las líneas del bus
SetLowSDA(); ? Establece el pin SDA como salida (P4DIR=1).
SetLowSCL(); ? Baja la señal de SCL (P4OUT=0).
SetHighSDA(); ? Establece el pin SDA como entrada (P4DIR=0).
SetHighSCL(); ? Sube la señal de SCL (P4OUT=1).
Funciones de control de las líneas del bus
static void SetLowSDA(){
P4DIR |= SDA; // SDA Salida
}
static void SetHighSDA(){
P4DIR &= ~SDA; // SDA Entrada
}
static void SetLowSCL(){
P4OUT &= ~SCL;
}
static void SetHighSCL(){
P4OUT |= SCL;
}
Funciones de transferencia de Datos
ic2Init(); ? Inicializa el bus (SDA y SCL en alto).
ic2Start(); ? Establece una condición de partida.
ic2Stop(); ? Establece una condición de termino.
ic2Read(); ? El micro empieza a leer bytes de datos que le envía la EEPROM.
ic2Write(); ? El micro empieza a escribir bytes en la EEPROM.
Funciones de transferencia de Datos
/*************************/
/* Inicializar las lineas*/
/* y el bus */
/*************************/
void i2cInit(){
int j;
P4SEL &= ~SDA;
P4SEL &= ~SCL; // Funcion I/O para SDA Y SCL
P4OUT &= ~SCL; // Salida a cero
P4OUT &= ~SDA; // SDA Open Colector
P4DIR |= SCL; // SCL COMO SALIDA
P4DIR &= ~SDA; // SDA COMO ENTRADA
SetHighSCL();
SetLowSDA(); // visto en el analizador logico como un pulso de
SetHighSDA(); // 5 a 3.56 microsegundos aprox.
// Ambas lineas quedan en alto
}
Funciones de transferencia de Datos
/*************************/
/* Start Data Transfer */
/*************************/
void i2cStart(){
SetHighSCL();
SetHighSDA();
SetHighSCL();
SetLowSDA();
SetLowSCL();
SetHighSDA();
/* Visto en el analizador lógico como:
* SCL ——————_________________
* SDA —–____________________———
* 0 2.7 5.5 microsegundos
*/
}
Funciones de transferencia de Datos
/*************************/
/* Stop Transfer */
/*************************/
void i2cStop(){
int j;
SetLowSCL();
SetLowSDA();
SetHighSCL();
SetLowSDA();
SetHighSCL();
SetHighSDA();
}
Funciones de transferencia de Datos
/*************************/
/* Write Transfer */
/*************************/
int i2cWrite(char a){
int i,j;
int retorno;
for (i=0; i< 8; i++){
SetLowSCL();
if (a & 0x80) SetHighSDA(); // Primero el bit mas significativo
else SetLowSDA();
SetHighSCL();
a < < = 1;
}
SetLowSCL();
/* ack Read */
SetHighSDA();
SetHighSCL();
if (P4IN & SDA) retorno = NO_I2C_ACK; // el slave no ha bajado la linea
else retorno = OK_I2C_ACK;
SetLowSCL();
return(retorno);
}
Funciones de transferencia de Datos
/*************************/
/* Read Transfer */
/*************************/
char i2cRead(int ack){
int i,j;
char caracter = 0x00;
SetLowSCL();
SetHighSDA();
for (i=0; i< 8; i++){
caracter = caracter < < 1;
SetHighSCL();
if (P4IN & SDA)
caracter = caracter + 1;
SetLowSCL();
}
if (ack){ //Send ACK to sender
SetLowSDA();
}
SetHighSCL();
SetLowSCL();
return (caracter);
}
Ejemplo de escritura.
#define EEPROM 0xA0
main(){
int i;
char writeText[] = "I2C la lleva";
i2cInit (); //Inicializamos los puertos.
i2cStart ();
i2cWrite(EEPROM); //Se envía el byte de control de la EEPROM
i2cWrite(0x00); //Bits más significativos para direccionamiento.
i2cWrite(0x00); //Bits menos significativos del direccionamiento.
for(i = 0; i < strlen(writeText); i++)
i2cWrite(writeText[i]); // Se escriben los datos en la EEPROM.
i2cStop();
Ejemplo de Lectura Secuencial.
#include "i2c.h"
#define EEPROM 0xA0
main()
{
int i, accesEEPROM;
char textoRead[64]; // Arreglo del largo que se necesite
i2cStart();
accesEEPROM = i2cWrite(EEPROM); //retorno de la función i2cwrite ()
while(!accesEEPROM) //Mientras el slave no haya bajado la línea.
accesEEPROM = i2cWrite(EEPROM); //Se espera ack
i2cWrite(0x00); //Dirección a la cual queremos acceder.
i2cWrite(0x00);
i2cStart();
accesEEPROM = i2cWrite(EEPROM | 1 ); //EEPROM 0xA1 (lectura)
for (i = 0; i < strlen(texto) – 1; i++) //largo del texto que se escribió.
textoRead[i]= i2cRead(1); // Lectura Secuencial, con envío de ack
textoRead[i]=i2cRead(0); // Fin de la lectura secuencial
i2cStop();
}