El Bus
2
IC
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-Master
Más de un master puede controlar el bus al mismo
tiempo sin corrupción de los mensajes
Arbitraje
Procedimiento 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ón
Procedimiento 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
E S Q U E M A D E C O N E X IO N E S
P 2_0
/R E S E T R X D 0
TXD 0
+5V
+ 3 ,3 V
+ 3 ,6 V
GND
EXTERNO
SD A
+Vcc
SCL
2K
8
7
WP
VCC
A2
5
P 4 .0
6
P 4 .1
SDA
3
SCL
SDA
SCL
2
A1
1
A0
GND
4
EEPROM
M SP430F149
Comunicación I2C en Memoria
EEPROM


Capacidad 64KB y preparada para operar a 400KHz
8 pines en total:
A0
A1
A2
GND
SDA
SCL
WP
Vcc
→
→
→
→
→
→
→
→
Direccionamiento
Direccionamiento
Conectado a +Vcc
Tierra
Señal Datos Serial
Señal Reloj
Bloque de escritura
+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
Bus Desocupado
Partida de Tx
Detención de Tx
Dato Válido
SDA
Alto
Canto de bajada
Canto de subida
Datos
SCL
Alto
Alto
Alto
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.
A sig n a ció n d e B its e n S ec u en c ia d e D ir ec cio n a m ien to
B y te d e C o n tro l
Direccionamiento
del Dispositivo
0
1
C ó d ig o
d e c o n tro l
0
B
0
A
1
A
0
R/
W
D ir.
M odo
B it
D
is
p
.
E s c ritu ra /
S e le c to r
L e c tu ra
de
B lo q u e
B y te D ire c c ió n A lta
X
A
A
A
A
A
14 13 12 11 10
A
9
A
8
A
1
A
0
tiem p o
1
B y te D ire c c ió n B a ja
A
7
A
6
A
5
A
4
A
3
A
2
X = B it s in im p o rta n c ia
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
Diagrama de Flujo: Programación.
SI
Inicializaciones
Start
Byte de
Control
SI
R/W=0 ?
NO
Configuración de
Puertos para dejar SDA y
SCL en niveles altos
Escribir
Datos
ACK=0 ?
Notar que para procesos
de Lectura Aleatoria y
Secuencial, se debe realizar
una secuencia de escritura para
direccionar.
NO
SI
Lectura de
Datos
Tres tipos:
•Lectura Aleatoria.
•Lectura Secuencial.
•Lectura Dirección Actual.
NO
ACK=0 ?
NO
STOP=1 ?
SI
Stop
Funciones de control de las
líneas del bus

SetLowSDA();
→

SetLowSCL();
→

SetHighSDA();
→

SetHighSCL();
→
Establece el pin SDA como
salida (P4DIR=1).
Baja la señal de SCL
(P4OUT=0).
Establece el pin SDA como
entrada (P4DIR=0).
Sube la señal de SCL
(P4OUT=1).
Funciones de control de las
líneas del bus
static void SetLowSDA(){
P4DIR |= SDA;
}
static void SetHighSDA(){
P4DIR &= ~SDA;
}
static void SetLowSCL(){
P4OUT &= ~SCL;
}
static void SetHighSCL(){
P4OUT |= SCL;
}
// SDA Salida
// SDA Entrada
Funciones de transferencia de Datos

ic2Init();
→

ic2Start();
→

ic2Stop();
→

ic2Read();
→

ic2Write();
→
Inicializa el bus (SDA y SCL en
alto).
Establece una condición de
partida.
Establece una condición de
termino.
El micro empieza a leer bytes
de datos que le envía la
EEPROM.
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 &=
P4SEL &=
~SDA;
~SCL;
// Funcion I/O para SDA Y SCL
P4OUT &= ~SCL;
P4OUT &= ~SDA;
// Salida a cero
// SDA Open Colector
P4DIR |= SCL;
P4DIR &= ~SDA;
// SCL COMO SALIDA
// SDA COMO ENTRADA
SetHighSCL();
SetLowSDA();
SetHighSDA();
// visto en el analizador logico como un pulso de
// 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();
else
SetLowSDA();
// Primero el bit mas significativo
SetHighSCL();
a <<= 1;
}
SetLowSCL();
/* ack Read */
SetHighSDA();
SetHighSCL();
if (P4IN & SDA)
retorno = NO_I2C_ACK;
else
retorno = OK_I2C_ACK;
SetLowSCL();
return(retorno);
}
// el slave no ha bajado la linea
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){
SetLowSDA();
}
SetHighSCL();
SetLowSCL();
return (caracter);
}
//Send ACK to sender
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);
while(!accesEEPROM)
accesEEPROM = i2cWrite(EEPROM);
i2cWrite(0x00);
i2cWrite(0x00);
i2cStart();
accesEEPROM = i2cWrite(EEPROM | 1 );
for (i = 0; i < strlen(texto) - 1; i++)
textoRead[i]= i2cRead(1);
textoRead[i]=i2cRead(0);
i2cStop();
}
//retorno de la función i2cwrite ()
//Mientras el slave no haya bajado la línea.
//Se espera ack
//Dirección a la cual queremos acceder.
//EEPROM 0xA1 (lectura)
//largo del texto que se escribió.
// Lectura Secuencial, con envío de ack
// Fin de la lectura secuencial