el bus i 2 c. introducción 1980: philips desarrolla el bus de 2 alambres i 2 c para la...
Post on 28-Jan-2016
217 Views
Preview:
TRANSCRIPT
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();}
top related