Comunicacion I2C entre Arduinos

https://electro2ar.wordpress.com/2014/06/19/comunicacion-i2c-entre-arduinos/
Este trabajo est hecho en base a lo presentado en la pgina cuyo link se muestra aqu.

Que es IC?
El bus IC, un estndar que facilita la comunicacin entre microcontroladores, memorias y
otros dispositivos con cierto nivel de inteligencia, slo requiere de dos lneas de seal y un
comn o masa. Fue diseado a este efecto por Philips y permite el intercambio de
informacin entre muchos dispositivos a una velocidad aceptable, de unos 100 Kbits por
segundo. La metodologa de comunicacin de datos del bus IC es en serie y sincrnica.
Una de las seales del bus marca el tiempo (pulsos de reloj) y la otra se utiliza para
intercambiar datos.
Puede haber un maestro y hasta 127 esclavos conectados a la misma linea de datos.
Vamos a hacer una introduccin rpida de uso de este protocolo para la comunicacin entre
estas dos placas Arduino. Vamos a realizar dos ejemplos, uno en que el Maestro enva una
peticin a un Esclavo y muestra la respuesta por el puerto serie del IDE Arduino, una cadena
de caracteres, y el segundo ejemplo el Maestro va a enviar un dato a un Esclavo, y sea lo
que sea este le devolver la lectura de un pin analgico para que el Maestro lo imprima por
el puerto serie del IDE Arduino.

Conexiones
Para poder empezar a comunicar a los Arduino, primero hay que cablearlos, para que los
bits fluyan! Uno ser Maestro y el otro Esclavo.
Se conectan con cables los pines A4 y A5 (seran las entradas Analgicas de la placa) del
Maestro con los mismos pines del Esclavo, o sea A4 con A4 y A5 con A5. Y obviamente un
tercer cable de GND o masa.

Es indistinto cual es el Maestro o el Esclavo. Tambin Se puede alimentar al Esclavo con 5

Volt del Maestro, con otro cable. Cada uno de los Arduinos se conecta a la PC con sus
cables USB, para tener disponibles las Pantallas Seriales.

Maestro/Esclavo envian Texto

Vamos a establecer un Arduino como Maestro, y este va a solicitar una respuesta de 20
bytes (una request) al Esclavo, que le pondremos el nmero 1. Podemos tener hasta 127.
Y el Esclavo 1 le va a responder, en este caso una cadena de caracteres, como se ve en la
siguiente imagen:
1

El Esclavo responde con una cadena de 20

caracteres, que es lo pedido por el Maestro. Se
muestra una cadena con caracteres nmeros. Es
para mostrar la practicidad de enviar de esta
manera, una cadena armada por ejemplo con el
resultado de 4 mediciones, que pueden ser de 4
sensores.
A123456, B7890, C12, D3456. Son 4 letras + 16
nmeros.
Identificando las letras, el Maestro separa los nmeros que le corresponden, los convierte de
caracteres a valores y los usa en lo que necesite.
El programa que hay que cargar en el Maestro es el siguiente:

Programa del Maestro

#include <Wire.h>

// Incluimos la librera de comunicacin I2C

void setup()

// Secuencia de configuracin, solo se ejecuta una vez

{
Wire.begin();
obligatoria

// Iniciamos la comunicacin I2C, en el maestro la direccin no es

Serial.begin(9600);
datos

// Iniciamos la comunicacin por el puerto serie para mostrar los

}
void loop()

// Secuencia en bucle, se repite una y otra vez

{
Wire.requestFrom(1, 20); // Manda una peticin al esclavo numero 2 de 12 bytes
while(Wire.available()) // Mientras tengamos datos en el buffer seguimos leyendo
{
char Datos = Wire.read(); // Leemos un byte y lo pasamos a una variable de tipo char
Serial.print(Datos); // Lo mostramos en el puerto serie (esto es un bucle donde van
llegando uno por uno cada carcter y se van imprimiendo por el serial)
}
delay(1500);

// Esperamos 1,5 segundos para que sea posible ver las respuestas

Serial.println(""); // Imprimimos una nueva linea, sino la respuestas van a ir pegadas*/

}
El programa que hay que cargar en el Esclavo (en este caso el Uno) es el siguiente:

Programa del Esclavo

#include <Wire.h>
2

void setup()
{
Wire.begin(1); // Nos aadimos al bus como esclavo, con la direccin 1
Wire.onRequest(requestEvent); // Registro de eventos
}
void loop()
{
delay(100);

// retraso de 100 mili-segundos

}
// Funcion que se ejecuta cuando recibe una peticin desde el maestro
void requestEvent()
{
Wire.write("A123456B7890C12D3456"); // Responde a la peticin del maestro de enviarle
20 bytes
}

Maestro y Esclavo envan valores

Bueno hasta ac fue fcil, ahora vamos a realizar el siguiente ejemplo donde el Maestro
envia un dato a un Esclavo, y sea lo que sea este le devolver la lectura de un pin analgico
para que el Maestro lo imprima por el puerto serie del IDE Arduino. En este caso tomamos la
lectura del pin analgico A0 dividindola por 4, para que el mximo de menor de 255, que es
el valor mximo que se puede enviar.
El valor que enviar es de ruidos que existen en el A0, pero se lo puede conectar a GND, 3.3
o 5 Volt para ver que funciona bien.
El esquema de conexiones no vara.

El de la izquierda es el Maestro. Enva el valor 0, y recibe el valor 85 que es 340 / 4. El de la

derecha es el Esclavo que muestra que recibe el valor 0 (Podra ser entre 0 y 254) y enva la
lectura del puerto analgico A0. El nmero que recibe el Esclavo lo puede utilizar para hacer
con el algo que necesite.
El programa que hay que cargar en el Maestro es el siguiente:

Programa del Maestro

#include <Wire.h>

//Incluimos la libreria i2c

3

void setup()
{
Wire.begin();

//Iniciamos el bus I2C

Serial.begin(9600);

//Iniciamos el Serial a 9600 baudios

}
void loop()
{
unsigned int lectura;
Wire.beginTransmission(1); // Enviamos a la direccin del esclavo 1
Wire.write(0);

// Enviamos entre 0 y 253

Wire.endTransmission();

// Terminamos la transmision

delayMicroseconds(100); // Esperamos para poder hacer visibles los datos (posiblemente

no haga falta en otras circunstancias)
Wire.requestFrom(1, 1);
while(Wire.available())

// Pedimos 1 bytes al esclavo 1

// Mientras tengamos datos en la entrada

{
lectura = Wire.read();

// Leemos el resultado y lo asignamos a la variable lectura

}
Serial.println(lectura);
delay(500);

// Imprimimos la lectura en el serial (podria ser un lcd tambien)

// Damos un tiempo de refresco

}
El programa que hay que cargar en el Esclavo es el siguiente:

Programa del Esclavo

#include <Wire.h>
unsigned char lectura=0;

// Incluimos la libreria i2c

// Establecemos una variable global, y la seteamos en cero

unsigned char pedido;

void setup()
{
Wire.begin(1);
vacio esto)
Serial.begin(9600);

// Nos asignamos el numero 1 como esclavos (de ser maestro va

// Iniciamos el serial 9600 baudios, para testear

Wire.onRequest(respuestaEvento); // Al activarse el evento de peticion, se ejecuta la

funcion respuestaEvento
Wire.onReceive(recibidoEvento); // Al activarse el evento de lectura, se ejecuta la funcion
recibidoEvento
}

void loop()
{
lectura = analogRead(A0)/4; // La variable global es igual a la lectura analogica del pin A0
dividido en 4 para que entre en un byte (0 a 255)
delay(100);

// Damos un respiro

} // FIN del void loop()

//*********************************************************
void respuestaEvento()
que le enviemos algun dato

// Evento de peticion se activa cuando un maestro nos pide

{
Wire.write(lectura);

// Enviamos el resultado de la lectura al maestro que lo solicito

Serial.println(lectura);

// Enviamos el resultado por el puerto serie para testear

}
//*********************************************************
void recibidoEvento(int howMany) // Evento de recepcion
{
while( Wire.available())
enviar el maestro

// Leemos hasta que no haya datos, osea el numero que va a

{
pedido = Wire.read();
Serial.println(pedido);

// Leemos el numero enviado

// Imprimimos por serial para testear

}
}
Los cuatro programas estn en el archivo ZIP que han bajado.