Descargar

El bus de comunicación I2C

Enviado por Pablo Turmero


    edu.red

    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.

    edu.red

    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.

    edu.red

    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.

    edu.red

    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…

    edu.red

    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.

    edu.red

    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.

    edu.red

    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.

    edu.red

    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.

    edu.red

    Protocolo

    edu.red

    Terminología básica del Bus I2C

    edu.red

    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

    edu.red

    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"

    edu.red

    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.

    edu.red

    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.

    edu.red

    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.

    edu.red

    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.

    edu.red

    Procedimiento de Arbitraje entre dos Master

    edu.red

    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.

    edu.red

    Comunicación I2C entre Microcontrolador MSP430F149 y Memoria EEPROM 24LC515

    edu.red

    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.

    edu.red

    Esquema de conexiones I2C implementado en la tarjeta

    edu.red

    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]

    edu.red

    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.

    edu.red

    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

    edu.red

    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.

    edu.red

    Direccionamiento del Dispositivo

    edu.red

    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.

    edu.red

    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.

    edu.red

    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.

    edu.red

    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.

    edu.red

    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

    edu.red

    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).

    edu.red

    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

    edu.red

    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’

    edu.red

    Implementación de I2C por software para manejo de EEPROM en tarjeta Easy Web II

    edu.red

    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.

    edu.red

    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).

    edu.red

    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; }

    edu.red

    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.

    edu.red

    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 }

    edu.red

    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 */ }

    edu.red

    Funciones de transferencia de Datos /*************************/ /* Stop Transfer */ /*************************/

    void i2cStop(){ int j;

    SetLowSCL(); SetLowSDA();

    SetHighSCL(); SetLowSDA();

    SetHighSCL(); SetHighSDA(); }

    edu.red

    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); }

    edu.red

    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); }

    edu.red

    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();

    edu.red

    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(); }