En uno de los tutoriales anteriores se habló de los display LCD 16×2 comunicados por comunicación paralela, donde una de las formas de optimizar el cableado es usar 4 de los 8 bit disponibles. Sin embargo, existe una forma de mejora mucho más efectiva, que permitirá la conexión de diversos dispositivos, por solo 4 cables, donde 2 son de alimentación y 2 de comunicación. El protocolo para esto es conocido como I2C (Inter-Integrated Circuit) conocido también como interface de 2 cables.
El estándar I2C es un bus de comunicación en serie, ello indica que envía o recibe un dato a la vez, trabajando con velocidades normales de 100kbit/s, pudiendo llegar hasta 3,4 Mbit/s. la comunicación se compone de 2 líneas, SDA (Serial Data) y SCL (Serial Clock), en otras palabras, datos seriales y reloj serial. Generalmente a la conexión en bus se le agregan 2 resistencias en pull-up de entre 2,2kΩ y 10kΩ una para SDA y otra para SCL.
Cuando existe una conversación entre varias personas, para mantener el orden y entender dicha conversación una persona habla, el resto escucha y contesta la persona a la que se hace alguna pregunta. Algo similar sucede en este protocolo, utiliza una comunicación maestro-esclavo, donde el maestro solicitará información y el esclavo al que se le solicite responderá. Cada esclavo tiene una dirección única. La información se mueve similar a un cartero, que buscara la dirección y cuando la encuentre entregara la información.
El maestro controla el SCL e inicia y detiene la comunicación. La información se envía de forma serial por la línea SDA. El esclavo suministra información al maestro. El esclavo no puede generar señal en SCL. El puerto I2C estará disponible solo si SDA y SCL están en niveles lógicos altos.
Teóricamente es posible conectar hasta 127 esclavos, sin embargo, la comunicación no será posible en multimaestro, entonces podremos tener un maestro y muchos esclavos esclavos.
Para este ejemplo usaremos una pantalla LCD con un controlador I2C, el que esta soldado a todos los pines del display y podemos conectar ahora solo con los cables mencionados con anterioridad para comunicarnos por este estándar de 2 cables.
El Arduino Uno, que será usado en este caso, tiene 2 conectores para I2C, para el ejemplo se usaran los pines analógicos A4 y A5 para SDA y SCL respectivamente. El segundo conector esta sobre la AREF, pero internamente es el mismo de las entradas analógicas
El conexionado esta vez no usara resistencias para SDA y SCL, principalmente porque es solo un esclavo el que está conectado. Puede que el sistema funcione bien sin ellas con más esclavos, pero la recomendación es usarlas para 2 o más esclavos.
Como se aprecia el conexionado es muy simple, alimentamos con 5V y GND, y comunicamos el SDA y SCL de ambos dispositivos. En el controlador I2C existe un potenciómetro que nos permitirá regular el contraste para los caracteres.
Lo primero, el Arduino es el controlador que tratara la información de acuerdo a nuestro diseño, esto significa que el enviará información cuando sea necesaria, será el maestro y la pantalla recibirá la información para mostrarla, será el esclavo. Entonces debemos identificar la dirección del esclavo para enviarle información, para ello cargaremos un programa que esta incluido en los ejemplos del IDE de Arduino llamado i2c_scanner dentro de los ejemplos de la librería wire. Específicamente deben acceder a Archivo/Ejemplos/Wire/i2c_scanner
El mensaje correcto recibido será
En caso de recibir el mensaje de “No I2C devices found” revisar correcta conexión de SDA y SCL.
Ahora que ya conocemos la dirección del esclavo, 0x3F, enviaremos información a la pantalla. Para esto tendremos que descargar la librería para el display I2C, específicamente LiquidCrystal I2C, de Frank Brabander. Tendremos que buscarla en el gestor de librerías.
Una vez descargado seguiremos con el programa para escribir en la pantalla LCD con I2C.
El programa es simple, se inician las comunicaciones en el setup y se hace un programa de escritura en el display, al ser solo un esclavo y tener librerías especificas para la pantalla lo hacemos directamente. Esta es una forma sencilla de optimizar los pines disponibles en la tarjeta, dejando espacio para otros elementos, recordemos que en los display sin controlador, quitando cables de alimentación, se necesitaban 7 cables para escribir, con este ejemplo solo se necesitan 2.
#include <Wire.h> //Librería I2C
#include <LiquidCrystal_I2C.h> //Librería LCD controlador I2C
LiquidCrystal_I2C lcd(0x3F, 16, 2); // Dirección 0x3F, 16 x 2
void setup()
{
lcd.init(); // Inicializa lcd
Wire.begin(); // Inicializa comunicación I2C
lcd.backlight(); // encendido luz de fondo
}
void loop()
{
lcd.setCursor(5, 0); // cursor en coordenada (5, 0)
lcd.print(“LCD I2C”); // impresión de mensaje en (5, 0)
lcd.setCursor(6, 1); // cursor en coordenada (6, 1)
lcd.print(random(0,20000)); // impresión de mensaje en (6, 1)
delay(500); // delay
}
Cabe mencionar que, si se quitase la librería wire, el programa funcionara de la misma forma y sin problemas, esto solo porque se utiliza el display y su librería. Al incluir otro esclavo la dirección debe ser especificada para ingresar a él, utilizar los comandos requeridos y cerrar la comunicación para abrir el I2C, esto se hace mediante instrucciones específicas como:
- beginTransmission(Dirección esclavo); accede al esclavo
- endTransmission()
- requestFrom(Dirección esclavo, bytes solicitados); pide información al esclavo
A modo de ejemplo, si quisiéramos respetar la estructura, el setup para el programa anterior quedaría entre el acceso al esclavo y la liberación del I2C. esta es una descripción muy global ya que sensores o actuadores usarían instrucciones más específicas.
Wire.beginTransmission(0x3F); // Acceder al esclavo 0x3F
lcd.setCursor(5, 0); // cursor en coordenada (5, 0)
lcd.print(“LCD I2C”); // impresión de mensaje en (5, 0)
lcd.setCursor(0, 1); // cursor en coordenada (0, 1)
lcd.print(random()); // impresión de mensaje en (5, 0)
Wire.endTransmission(); // Libera el bus I2C
delay(500); // delay