El Bus I2C

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

Términos Descripción

Transmisor El dispositivo que envía datos al Bus

Receptor El dispositivo que recibe datos desde el Bus

Master (Maestro)

El dispositivo que inicia una transferencia, genera las señales del reloj y termina un envío de datos

Slave (Esclavo) El dispositivo direccionado por un master

Multi-MasterMás de un master puede controlar el bus al mismo tiempo sin corrupción de los mensajes

ArbitrajeProcedimiento que asegura que si uno o mas master simultáneamente deciden controlar el Bus solo uno es permitido a controlarlo y el mensaje saliente no es deteriorado

SincronizaciónProcedimiento para sincronizar las señales del reloj de dos o mas dispositivos

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.

Arbitraje

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

WP7

A23

2A1

1A0

SDA

SCL

5

6VCC

8

GND

4

+Vcc

SDAP4.0

SCLP4.1

EEPROM

MSP430F149

EXTERNO

+3,6VP2_0 /RESET RXD0

SDA SCL

TXD0 +5V +3,3V GND

ESQUEMA DE CONEXIONES

2K

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

Asignación de Bits en Secuencia de Direccionamiento

1 R/W

A0

A1

B0

010

X A9

A10

A11

A12

A13

A14

A8

A1

A2

A3

A4

A5

A6

A7

A0

Byte Dirección Alta

Byte Dirección Baja

Byte de Control

Códigode control

BitSelector

de Bloque

Dir.Disp.

ModoEscritura/Lectura

X=Bit sin importancia

tiem

po

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 dePuertos para dejar SDA y SCL en niveles altos

Inicializaciones Start

Lectura de Datos

ACK=0 ?R/W=0 ?Escribir

Datos

Notar que para procesosde Lectura Aleatoria y Secuencial, se debe realizar una secuencia de escritura para direccionar.

ACK=0 ? STOP=1 ?

Stop

SISI

NONO

SISI

NONO

SISINONO

SISI

NONO

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 significativoelse 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 0xA0main(){ 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();}