Scribd
Cargar
58 vistas20 páginas

Comunicación I2C

El documento describe el protocolo de comunicación I2C. I2C usa solo dos líneas, una para datos (SDA) y otra para el reloj (SCL). Los dispositivos en el bus I2C funcionan como maestros o esclavos, y el maestro inicia la comunicación enviando una condición de inicio. A continuación, el maestro envía la dirección del esclavo con el que desea comunicarse. El esclavo con esa dirección responde, y el maestro y esclavo intercambian datos.

Cargado por

palaciosfulgencio3
Derechos de autor
© © All Rights Reserved
Nos tomamos en serio los derechos de los contenidos. Si sospechas que se trata de tu contenido, reclámalo aquí.
Formatos disponibles
Descarga como PPTX, PDF, TXT o lee en línea desde Scribd
58 vistas20 páginas

Comunicación I2C

El documento describe el protocolo de comunicación I2C. I2C usa solo dos líneas, una para datos (SDA) y otra para el reloj (SCL). Los dispositivos en el bus I2C funcionan como maestros o esclavos, y el maestro inicia la comunicación enviando una condición de inicio. A continuación, el maestro envía la dirección del esclavo con el que desea comunicarse. El esclavo con esa dirección responde, y el maestro y esclavo intercambian datos.

Cargado por

palaciosfulgencio3
Derechos de autor
© © All Rights Reserved
Nos tomamos en serio los derechos de los contenidos. Si sospechas que se trata de tu contenido, reclámalo aquí.
Formatos disponibles
Descarga como PPTX, PDF, TXT o lee en línea desde Scribd
Está en la página 1/ 20

Comunicación I2C

I2C
• Es un bus de comunicaciones en serie. Su nombre viene de Inter-
Integrated Circuit (Inter-Circuitos Integrados). La versión 1.0 data del
año 1992 y la versión 2.1 del año 2000, su diseñador es Philips. La
velocidad es de 100 kbit/s en el modo estándar, aunque también
permite velocidades de 3.4 Mbit/s. Es un bus muy usado en la
industria, principalmente para comunicar microcontroladores y sus
periféricos en sistemas integrados (Embedded Systems) y
generalizando más para comunicar circuitos integrados entre si que
normalmente residen en un mismo circuito impreso.
Líneas de comunicación
• La principal característica de I²C es que utiliza dos líneas para
transmitir la información: una para los datos y otra para la señal de
reloj.
• SDA: datos
• SCL: reloj
Bus I2C
Proceso de comunicación del bus I2C
• El maestro comienza la comunicación enviando un patrón llamado “start condition”. Esto
alerta a los dispositivos esclavos, poniéndolos a la espera de una transmisión.
• El maestro se dirige al dispositivo con el que quiere hablar, enviando un byte que contiene
los siete bits (A7-A1) que componen la dirección del dispositivo esclavo con el que se
quiere comunicar, y el octavo bit (A0) de menor peso se corresponde con la operación
deseada (L/E), lectura=1 (recibir del esclavo) y escritura=0 (enviar al esclavo).
• La dirección enviada es comparada por cada esclavo del bus con su propia dirección, si
ambas coinciden, el esclavo se considera direccionado como esclavo-transmisor o esclavo-
receptor dependiendo del bit R/W.
• Cada byte leído/escrito por el maestro debe ser obligatoriamente reconocido por un bit
de ACK por el dispositivo maestro/esclavo.
• Cuando la comunicación finaliza, el maestro transmite una “stop condition” para dejar
libre el bus.
Tramas enviadas en canal

Las transacciones en el bus I2C tienen este formato:


| start | A7 A6 A5 A4 A3 A2 A1 R/W | ACK | … DATA … | ACK | stop | idle |
BUS I2C EN ARDUINO

MODELO SDA SCK


Uno A4 A5
Nano A4 A5
Mini Pro A4 A5
Mega 20 21
Práctica : Master Reader/Slave Sender
• Dispositivo maestro lee y el esclavo envía información
Diagrama de conexión
Master reader code
• #include <Wire.h>

void setup() {
Wire.begin(); // join i2c bus (address optional for master)
Serial.begin(9600); // start serial for output
}

void loop() {
Wire.requestFrom(8, 6); // request 6 bytes from slave device address#8

while (Wire.available()) { // slave may send less than requested


char c = Wire.read(); // receive a byte as character
Serial.print(c); // print the character
}

delay(500);
}
Slave Sender
• #include <Wire.h>

void setup() {
Wire.begin(8); // join i2c bus with address #8
Wire.onRequest(requestEvent); // register event
}

void loop() {
delay(100);
}

// function that executes whenever data is requested by master


// this function is registered as an event, see setup()
void requestEvent() {
Wire.write("hello "); // respond with message of 6 bytes
// as expected by master
}
Practica : Master Writer/Slave Receiver
• Maestro envía información y el esclavo recibe información
Master Writer code
• #include <Wire.h>

void setup() {
Wire.begin(); // join i2c bus (address optional for master)
}

byte x = 0;

void loop() {
Wire.beginTransmission(8); // transmit to device #8
Wire.write("x is "); // sends five bytes
Wire.write(x); // sends one byte
Wire.endTransmission(); // stop transmitting

x++;
delay(500);
}
Salve Receiver Code
• #include <Wire.h>

void setup() {
Wire.begin(8); // join i2c bus with address #8
Wire.onReceive(receiveEvent); // register event
Serial.begin(9600); // start serial for output
}

void loop() {
delay(100);
}

// function that executes whenever data is received from master


// this function is registered as an event, see setup()
void receiveEvent(int howMany) {
while (1 < Wire.available()) { // loop through all but the last
char c = Wire.read(); // receive byte as a character
Serial.print(c); // print the character
}
int x = Wire.read(); // receive byte as an integer
Serial.println(x); // print the integer
}
Práctica: Escáner de direcciones
• #include <Wire.h>
• void setup()
• {
• Wire.begin();
•
• Serial.begin(9600);
• while (!Serial); // Leonardo: wait for serial monitor
• Serial.println("\nI2C Scanner");
• }
•
•
• void loop()
• {
• byte error, address;
• int nDevices;
•
• Serial.println("Scanning...");
•
• nDevices = 0;
• for(address = 1; address < 127; address++ )
• {
• // The i2c_scanner uses the return value of
• // the Write.endTransmisstion to see if
• // a device did acknowledge to the address.
• Wire.beginTransmission(address);
• error = Wire.endTransmission();
•
• if (error == 0)
• {
• Serial.print("I2C device found at address 0x");
• if (address<16)
• Serial.print("0");
• Serial.print(address,HEX);
• Serial.println(" !");
•
• nDevices++;
• }
• else if (error==4)
• {
• Serial.print("Unknown error at address 0x");
• if (address<16)
• Serial.print("0");
• Serial.println(address,HEX);
• }
• }
• if (nDevices == 0)
• Serial.println("No I2C devices found\n");
• else
• Serial.println("done\n");
•
• delay(5000); // wait 5 seconds for next scan
• }
Practica 3. emulación de sensor
• El maestro solicita información al esclavo, practica muy común en
sensores que usan el protocolo I2C.
Master Sensor
• #include <Wire.h>
• char mensaje1;

• void setup()
• {
• Wire.begin();//INICIAMOS EL WIRE (I2C)
• Serial.begin(9600);// INICIAMOS EL SERIAL PARA MOSTRAR LOS MENSAJES
• }

• void loop()
• {
• if(Serial.available())//SI HAY ENTRADA DE DATOS POR SERIAL
• {
• char valor = Serial.read();//LEEMOS LA CADENA
• if(valor == 'a')//SI ES A
• {
• Wire.requestFrom(1,19);//REALIZAMOS UNA PETICION AL CANAL 1 DE 19 CARACTERES (BITS)
• Serial.println("Mesaje pedido");//IMPRIMIMOS DE QUE HEMOS PEDIDO EL MESNAJE AL DISPOSITIVO EN EL CANAL 1
• }
• }
• while(Wire.available())
• {
• mensaje1 = Wire.read();//GUARDAMOS EL MENSAJE EN LA CADENA MESAJE 1
• Serial.print(mensaje1);//IMPRIMIMOS EL MENSAJE
• delay(100);
• }
• }
Slave Sensor
• #include <Wire.h>

• void setup()
• {
• Wire.begin(1); // Abrimos el canal 1 (0x01) del I2C
• Wire.onRequest(peticion);// Creamos el evento que se relaizará cuando el Receptor llame a el emisor (Este Arduino)
• Serial.begin(9600);
• }

• void loop()
• {
• }

• void peticion()
• {
• Serial.print("Se pidio el mensaje, Enviando");//Imprimios cuando el receptor nos pide el mensaje
• Wire.write("Hola soy el canal 1");//Imprimimos cuando se realize la peticion ese mensaje y lo enviaremos por el canal 1
• }
Preguntas
Recordatorio
• UART (recepción-transmisión asíncrona universal) es uno de los protocolos serie más
utilizados. La mayoría de los microcontroladores disponen de hardware UART. Usa una línea
de datos simple para transmitir y otra para recibir datos. Comúnmente, 8 bits de datos son
transmitidos de la siguiente forma: un bit de inicio, a nivel bajo, 8 bits de datos y un bit de
parada a nivel alto. UART se diferencia de SPI y I2C en que es asíncrono y los otros están
sincronizados con señal de reloj. La velocidad de datos UART está limitado a 2Mbps
• SPI es otro protocolo serie muy simple. Un maestro envía la señal de reloj, y tras cada pulso
de reloj envía un bit al esclavo y recibe un bit de éste. Los nombres de las señales son por
tanto SCK para el reloj, MOSI para el Maestro Out Esclavo In, y MISO para Maestro In Esclavo
Out. Para controlar más de un esclavo es preciso utilizar SS (selección de esclavo).
• I2C es un protocolo síncrono. I2C usa solo 2 cables, uno para el reloj (SCL) y otro para el dato
(SDA). Esto significa que el maestro y el esclavo envían datos por el mismo cable, el cual es
controlado por el maestro, que crea la señal de reloj. I2C no utiliza selección de esclavo, sino
direccionamiento.

También podría gustarte