Interfaz de un LCD I2C con Arduino

Conectar un display LCD a un Arduino puede parecer una tarea complicada, especialmente si se tienen en cuenta la cantidad de pines que se requieren. Sin embargo, gracias a la tecnología I2C, este proceso se simplifica considerablemente, haciéndolo más accesible para los entusiastas de la electrónica y la programación. En este artículo, exploraremos en profundidad cómo utilizar un display LCD I2C con Arduino, comenzando desde los aspectos básicos de hardware hasta ejemplos prácticos de código.

Visión general del hardware

Un display LCD típico que utiliza la interfaz I2C está compuesto por dos partes esenciales: un display LCD basado en el controlador HD44780 y un adaptador I2C. A continuación, desglosaremos cada uno de estos componentes para entender su funcionamiento y características.

Display LCD de caracteres

Los displays LCD de caracteres están diseñados específicamente para mostrar letras, números y símbolos. Un ejemplo común es el LCD de 16x2, que puede mostrar 16 caracteres en cada una de sus dos líneas.

Al observar de cerca la pantalla, se pueden identificar pequeños cuadros rectangulares que representan cada posición de carácter. Dentro de cada uno de estos cuadros, hay una cuadrícula de 5x8 puntos o píxeles. Estos píxeles se iluminan en diferentes patrones para formar letras, números o símbolos.

Para profundizar más en el funcionamiento de los displays LCD, puedes consultar nuestra guía completa sobre el tema.

Adaptador LCD I2C

El componente clave de este adaptador es un chip expander de I/O de 8 bits, conocido como PCF8574. Este ingenioso chip convierte los datos I2C provenientes del Arduino en el formato de datos paralelo que necesita el display LCD para funcionar.

Además, la placa adaptadora incluye un pequeño trimpot que permite ajustar el contraste del display. También se puede encontrar un jumper en la placa que alimenta la luz de fondo; si deseas controlar la intensidad de la retroiluminación, simplemente puedes quitar este jumper y conectar una fuente de voltaje externa al pin marcado como ‘LED’.

Dirección I2C del LCD

Si tienes varios dispositivos conectados al mismo bus I2C, es posible que necesites establecer una dirección I2C diferente para el adaptador del LCD para evitar conflictos. El adaptador tiene tres jumpers/pads de soldadura (etiquetados A0, A1 y A2) que se utilizan para este propósito.

Para un solo LCD, puedes dejar estos jumpers sin alterar; sin embargo, si conectas múltiples dispositivos I2C, deberás asegurarte de que cada uno tenga una dirección única modificando estos jumpers. Puedes cambiar la dirección cortando un jumper con una pequeña gota de soldadura.

Si tu LCD tiene el chip PCF8574 de Texas Instruments:

Según la hoja de datos de Texas Instruments, los tres bits de selección de dirección (A0, A1 y A2) se encuentran al final del registro de dirección I2C de 7 bits. Estos bits se pueden configurar, ya que cada uno puede estar en estado HIGH o LOW, lo que resulta en ocho combinaciones posibles (2^3 = 8).

Por defecto, todos los bits de dirección están en estado HIGH gracias a resistencias pull-up en la placa. Esto le da al PCF8574 una dirección I2C predeterminada de 0x27. Si cortas todos los jumpers, la dirección cambia a 0x20, y el rango de direcciones posibles varía de 0x20 a 0x27.

Si tu LCD tiene el chip PCF8574 de NXP:

De acuerdo con la hoja de datos de NXP Semiconductors, los bits de selección de dirección (A0, A1 y A2) también se encuentran en el mismo lugar que en el chip de Texas Instruments. Sin embargo, los bits restantes en el registro de dirección son diferentes.

Al igual que con el chip de Texas Instruments, hay ocho combinaciones posibles de dirección. La dirección predeterminada es 0x3F, y si cortas todos los jumpers, cambiaría a 0x38, variando la dirección de 0x38 a 0x3F.

Por lo general, la dirección I2C de tu LCD será 0x27 o 0x3F. Si no estás seguro de la dirección de tu LCD, no te preocupes; hay un método sencillo para descubrirla, que exploraremos más adelante.

Pinout del display LCD I2C

El display LCD I2C cuenta con solo cuatro pines, que se describen a continuación:

• GND: Es el pin de tierra.
• VCC: Es el pin de alimentación. Conéctalo a la salida de 5V del Arduino o a una fuente de alimentación externa de 5V.
• SDA: Es el pin de datos I2C.
• SCL: Es el pin de reloj I2C.

Conexión de un display LCD I2C a un Arduino

Conectar un display LCD I2C es mucho más sencillo que conectar un LCD estándar, ya que solo necesitas conectar cuatro pines en lugar de muchos más. Aquí está la forma correcta de hacerlo:

1. Conecta el pin VCC a la salida de 5V del Arduino y el pin GND a la tierra del Arduino.
2. Conecta los pines utilizados para la comunicación I2C. Es importante recordar que diferentes placas Arduino tienen diferentes pines I2C, los cuales deben conectarse correctamente. En las placas Arduino con el diseño R3, los pines SDA (línea de datos) y SCL (línea de reloj) se encuentran en los encabezados de pines cerca del pin AREF; sin embargo, internamente son los mismos que los pines A4 (SDA) y A5 (SCL).

A continuación, se presenta una tabla que muestra todas las conexiones necesarias:

Ajustando el contraste del LCD

Una vez que hayas terminado de conectar el LCD a tu Arduino, es necesario ajustar el contraste del display. Busca un pequeño trimpot en la placa adaptadora I2C, ya que esto controla el contraste del LCD.

Enciende tu Arduino y deberías ver que la luz de fondo se ilumina de inmediato. Usando un destornillador pequeño, ajusta suavemente el potenciómetro. A medida que lo haces, comenzarás a ver las primeras filas de rectángulos aparecer en la pantalla, que son donde aparecerán los caracteres. Si puedes ver esos rectángulos claramente, ¡felicidades! Tu LCD está funcionando perfectamente y está listo para mostrar texto.

Determinando la dirección I2C

Antes de iniciar con el código de ejemplo, necesitarás conocer la dirección I2C de tu LCD para poder comunicarte correctamente con él. Como mencionamos anteriormente, la dirección de tu LCD es probablemente 0x27 o 0x3F. Esta dirección puede estar impresa en una etiqueta que vino con tu LCD o listada en la información del producto.

Si no puedes encontrar esta información, no te preocupes; hay una forma sencilla de descubrirla: puedes ejecutar un simple sketch de escáner I2C que te ayudará a identificar la dirección correcta. Aquí te mostramos cómo:

1. Abre tu programa Arduino IDE. Luego, haz clic en el icono Library Manager en la barra lateral izquierda.
2. Escribe “i2c_scanner” en el cuadro de búsqueda para filtrar tus resultados.
3. Carga el sketch i2c_scanner en tu Arduino IDE.

#include <Wire.h>

void setup() {
  Wire.begin();
  Serial.begin(9600);
  while (!Serial); // Espera el monitor serial
  Serial.println("nEscáner I2C");
}

void loop() {
  int nDevices = 0;
  Serial.println("Escaneando...");
  for (byte address = 1; address < 127; ++address) {
    Wire.beginTransmission(address);
    byte error = Wire.endTransmission();
    if (error == 0) {
      Serial.print("Dispositivo I2C encontrado en la dirección 0x");
      if (address < 16) {
        Serial.print("0");
      }
      Serial.print(address, HEX);
      Serial.println("  !");
      ++nDevices;
    } else if (error == 4) {
      Serial.print("Error desconocido en la dirección 0x");
      if (address < 16) {
        Serial.print("0");
      }
      Serial.println(address, HEX);
    }
  }
  if (nDevices == 0) {
    Serial.println("No se encontraron dispositivos I2Cn");
  } else {
    Serial.println("Liston");
  }
  delay(5000); // Espera 5 segundos para el siguiente escaneo
}

Después de subir este código a tu Arduino, abre el monitor serial y configúralo a 9600 baudios. En unos momentos, deberías ver la dirección I2C de tu display LCD aparecer en la pantalla.

Asegúrate de anotar esta dirección en un lugar seguro, ya que la necesitarás más adelante al trabajar con el LCD en ejemplos posteriores.

Instalación de la biblioteca

Para controlar el LCD I2C, utilizaremos la biblioteca de Arduino LiquidCrystal_I2C. Esta biblioteca facilita la escritura en el LCD, ya que maneja toda la comunicación I2C compleja en segundo plano. Hay varias versiones de esta biblioteca disponibles, pero una de las más confiables es la creada por Frank de Brabander.

Para instalar la biblioteca:

1. Abre tu programa Arduino IDE y haz clic en el icono Library Manager en la barra lateral izquierda.
2. Escribe “liquidcrystal” en el cuadro de búsqueda para filtrar tus resultados.
3. Busca la biblioteca “LiquidCrystal I2C library” creada por Frank de Brabander.
4. Haz clic en el botón Instalar para agregarla a tu Arduino IDE.

Sketch básico de Arduino – Hello World

Con el hardware conectado y la biblioteca instalada, podemos escribir un sketch simple de Arduino para mostrar texto en el LCD. En este ejemplo, imprimiremos ‘¡Hola Mundo!’ en la primera línea del LCD y ‘Tutorial LCD’ en la segunda línea.

Antes de subir el sketch, debes hacer dos cambios importantes para que funcione con tu LCD específico: ingresar la dirección I2C correcta de tu LCD (que encontramos anteriormente) y especificar las dimensiones del display en el constructor LiquidCrystal_I2C(). Si estás utilizando un LCD de 16x2, ingresa 16 y 2; si utilizas un LCD de 20x4, ingresa 20 y 4.

// ingresa la dirección I2C y las dimensiones de tu LCD aquí
LiquidCrystal_I2C lcd(0x3F, 16, 2);

Una vez que hayas realizado estos cambios, estás listo para probar el siguiente código completo:

#include <LiquidCrystal_I2C.h>

LiquidCrystal_I2C lcd(0x3F, 16, 2);  // establece la dirección del LCD a 0x3F para un display de 16 caracteres y 2 líneas

void setup() {
  lcd.init();
  lcd.clear();         
  lcd.backlight();      // Asegúrate de que la luz de fondo esté encendida
  
  // Imprime un mensaje en ambas líneas del LCD.
  lcd.setCursor(2, 0);   // Establece el cursor en el carácter 2 de la línea 0
  lcd.print("¡Hola Mundo!");
  
  lcd.setCursor(2, 1);   // Mueve el cursor al carácter 2 de la línea 1
  lcd.print("Tutorial LCD");
}

void loop() {
}

Después de subir este código a tu Arduino, deberías ver la siguiente salida en la pantalla:

Explicación del código:

El sketch comienza incluyendo la biblioteca LiquidCrystal_I2C, que proporciona todas las funciones necesarias para controlar el LCD.

#include <LiquidCrystal_I2C.h>

A continuación, creamos un objeto de la clase LiquidCrystal_I2C. El constructor de LiquidCrystal_I2C necesita tres piezas de información: la dirección I2C, el número de columnas y el número de filas de tu display.

LiquidCrystal_I2C lcd(0x3F, 16, 2);

En la función de configuración, llamamos a tres funciones importantes. Primero, la función init() inicializa la interfaz del LCD. Segundo, la función clear() borra cualquier cosa en la pantalla del LCD y mueve el cursor a la esquina superior izquierda. Tercero, la función backlight() enciende la luz de fondo del LCD para que podamos ver el texto.

lcd.init();
lcd.clear();         
lcd.backlight();

La función setCursor(2, 0) mueve el cursor a la tercera columna de la primera fila. (Recuerda que la numeración comienza en 0, por lo que la columna 2 es, en realidad, la tercera columna). La posición del cursor indica al LCD dónde colocar el nuevo texto en la pantalla. La esquina superior izquierda se considera la posición (0,0).

Después, utilizamos la función print() para mostrar el texto “¡Hola mundo!” en el LCD.

lcd.print("¡Hola Mundo!");

Del mismo modo, las siguientes dos líneas de código mueven el cursor a la tercera columna de la segunda fila e imprimen ‘Tutorial LCD’ en el LCD.

lcd.setCursor(2, 1);
lcd.print("Tutorial LCD");

Ejemplo de texto desplazante

Si tienes un mensaje que es más largo que 16 caracteres, o deseas crear un efecto de marquesina desplazante, puedes usar las funciones scrollDisplayLeft() o scrollDisplayRight() en un bucle para mover el texto a través de la pantalla.

Código de ejemplo de Arduino para desplazamiento

El siguiente sketch muestra cómo desplazar un mensaje continuamente hacia la izquierda:

#include <LiquidCrystal_I2C.h>

LiquidCrystal_I2C lcd(0x3F, 16, 2);  // establece la dirección del LCD a 0x3F para un display de 16 caracteres y 2 líneas

void setup() {
  lcd.init();
  lcd.clear();         
  lcd.backlight();      // Asegúrate de que la luz de fondo esté encendida
  
  // Imprime un mensaje
  lcd.print("Demo de Texto Desplazante");
  delay(1000);  // pausa para leer el mensaje inicialmente
}

void loop() {
  lcd.scrollDisplayLeft();   // desplaza todo hacia la izquierda por una posición
  delay(300);                // pequeña pausa para que la velocidad de desplazamiento sea visible
}

Al subir este código a tu Arduino, el LCD mostrará algo como esto:

Explicación del código de desplazamiento:

En este ejemplo, imprimimos un mensaje que tiene 30 caracteres de longitud (“Demo de Texto Desplazante”) en el LCD. Dado que el display solo puede mostrar 16 caracteres a la vez, solo los primeros 16 caracteres serán visibles inicialmente.

lcd.print("Demo de Texto Desplazante");

En la función loop(), llamamos a lcd.scrollDisplayLeft(), que mueve todo el contenido del display una posición hacia la izquierda. Al repetir esto con un pequeño retraso entre cada desplazamiento, el mensaje parece moverse suavemente a través de la pantalla.

void loop() {
  lcd.scrollDisplayLeft();   // desplaza todo hacia la izquierda por una posición
  delay(300);                // pequeña pausa para que la velocidad de desplazamiento sea visible
}

A medida que el texto se desplaza, los caracteres que se mueven fuera del borde izquierdo desaparecen y aparecen espacios en blanco en el lado derecho de la pantalla. Si deseas que el mensaje se repita continuamente, necesitarías agregar un código que vuelva a imprimir el mensaje periódicamente.

Para desplazar en la dirección opuesta (de derecha a izquierda), puedes usar lcd.scrollDisplayRight() en su lugar.

Otras funciones útiles de la biblioteca LiquidCrystal_I2C

El objeto LiquidCrystal_I2C ofrece muchas funciones útiles para controlar tu LCD. Aquí hay algunas de las más importantes:

• lcd.home(): Mueve el cursor de vuelta a la esquina superior izquierda del LCD (la primera posición en la primera fila). A diferencia de clear(), no borra lo que ya está en la pantalla, simplemente mueve el cursor a la posición inicial.
• lcd.blink() y lcd.noBlink(): Encienden o apagan un cursor en forma de bloque que parpadea. Cuando se activa con blink(), verás un bloque sólido que parpadea en la posición del cursor actual. Esto es excelente para atraer la atención del usuario o indicar dónde aparecerá el texto a continuación. Si no deseas el parpadeo, utiliza noBlink() para desactivarlo.
• lcd.cursor() y lcd.noCursor(): Controlan si aparece una línea de subrayado (_) en la posición donde se escribirá el siguiente carácter. La función cursor() muestra esta línea, mientras que noCursor() la oculta.
• lcd.display() y lcd.noDisplay(): Permiten encender o apagar todo el display sin borrar nada. Al usar noDisplay(), la pantalla se pone en blanco, pero todo el texto sigue almacenado en la memoria del LCD. Cuando vuelves a llamar a display(), todo reaparece. Esto es perfecto para crear efectos de parpadeo o ahorrar energía cuando el display no es necesario.

Intenta experimentar con estas funciones en tu propio código para ver cómo funcionan. ¡Te ayudarán a crear displays más interactivos y dinámicos para tus proyectos!

Crear y mostrar caracteres personalizados

En ocasiones, puede que desees mostrar caracteres especiales que no forman parte del alfabeto estándar o de los números, como símbolos de caritas sonrientes, el símbolo de grado (°) para lecturas de temperatura o íconos divertidos como corazones, notas musicales o flechas.

Lo bueno es que los LCD basados en HD44780 permiten crear hasta 8 caracteres personalizados diseñados por ti. Como aprendimos anteriormente, cada carácter en el LCD se representa mediante una pequeña cuadrícula de píxeles dispuestos en un patrón de 5x8 (5 píxeles de ancho por 8 píxeles de alto). Para crear tu propio carácter, deberás decidir cuáles de estos pequeños puntos deben estar encendidos y cuáles deben estar apagados.

Para crear tu carácter personalizado, primero debes configurar un arreglo de 8 bytes en tu código. Cada byte en este arreglo representa una fila horizontal en tu carácter, comenzando desde la fila superior y bajando. Para cada byte, utilizarás los bits (los 1s y 0s en binario) para indicar qué píxeles deben estar ENCENDIDOS (1) y cuáles deben estar APAGADOS (0). Solo los primeros 5 bits de cada byte se utilizan, ya que el carácter tiene 5 píxeles de ancho.

Una vez que hayas diseñado tu carácter configurando este arreglo, puedes usar la función createChar() para almacenar tu carácter personalizado en la RAM de CG (Character Generator RAM) del LCD, que es un área de memoria especial diseñada solo para mantener caracteres personalizados.

¡Vamos a crear algunos caracteres personalizados geniales para tus proyectos!

CGROM vs. CGRAM

Todos los LCDs basados en el controlador Hitachi HD44780 tienen dos tipos de memoria: CGROM (Read-Only Memory de Generación de Caracteres) y CGRAM (Random Access Memory de Generación de Caracteres).

CGROM es memoria no volátil, lo que significa que conserva sus datos incluso cuando se apaga. Almacena patrones de puntos predefinidos para caracteres ASCII estándar, como letras, números y símbolos comunes. Cuando deseas mostrar una "A" en la pantalla, envías el código para "A" (que es 0x41 en hexadecimal), y el controlador del LCD busca el patrón de puntos para "A" en su CGROM y lo muestra. Esto facilita mucho la visualización de caracteres comunes.

Por otro lado, CGRAM es memoria volátil, por lo que pierde sus datos cuando se corta la energía. Esta memoria es flexible y te permite almacenar patrones de puntos personalizados que no forman parte del conjunto incorporado. Por ejemplo, puedes diseñar tus propios símbolos, íconos o caracteres únicos para tu proyecto. Sin embargo, CGRAM tiene un espacio limitado: solo 64 bytes en total. En un LCD estándar de 5x8 píxeles, esto significa que solo puedes almacenar 8 caracteres personalizados (ya que cada uno necesita 8 bytes). Si estás utilizando un LCD de 5x10 píxeles, solo puedes almacenar 4 caracteres personalizados porque cada uno necesita más memoria.

En resumen, CGROM es de solo lectura con patrones de caracteres fijos que no se pueden cambiar, mientras que CGRAM es escribible, lo que te permite crear y guardar caracteres personalizados según sea necesario.

Generador de caracteres personalizados

Crear caracteres personalizados nunca ha sido tan fácil. Hemos desarrollado una herramienta útil llamada Generador de Caracteres Personalizados. Puedes hacer clic en cualquier píxel en la cuadrícula azul para encenderlo o apagarlo, y a medida que lo haces, el código para tu carácter se genera automáticamente justo al lado de la cuadrícula. Puedes copiar este código directamente en tu sketch de Arduino.

Código de ejemplo de Arduino para caracteres personalizados

El siguiente sketch muestra exactamente cómo mostrar tus caracteres personalizados en el LCD:

#include <LiquidCrystal_I2C.h>

LiquidCrystal_I2C lcd(0x3F, 16, 2);  // establece la dirección del LCD a 0x3F para un display de 16 caracteres y 2 líneas

// define algunos caracteres personalizados:
byte Corazón[8] = {
  0b00000,
  0b01010,
  0b11111,
  0b11111,
  0b01110,
  0b00100,
  0b00000,
  0b00000
};

byte Campana[8] = {
  0b00100,
  0b01110,
  0b01110,
  0b01110,
  0b11111,
  0b00000,
  0b00100,
  0b00000
};

byte Alien[8] = {
  0b11111,
  0b10101,
  0b11111,
  0b11111,
  0b01110,
  0b01010,
  0b11011,
  0b00000
};

byte Marca[8] = {
  0b00000,
  0b00001,
  0b00011,
  0b10110,
  0b11100,
  0b01000,
  0b00000,
  0b00000
};

byte Altavoz[8] = {
  0b00001,
  0b00011,
  0b01111,
  0b01111,
  0b01111,
  0b00011,
  0b00001,
  0b00000
};

byte Sonido[8] = {
  0b00001,
  0b00011,
  0b00101,
  0b01001,
  0b01001,
  0b01011,
  0b11011,
  0b11000
};

byte Calavera[8] = {
  0b00000,
  0b01110,
  0b10101,
  0b11011,
  0b01110,
  0b01110,
  0b00000,
  0b00000
};

byte Candado[8] = {
  0b01110,
  0b10001,
  0b10001,
  0b11111,
  0b11011,
  0b11011,
  0b11111,
  0b00000
};

void setup() {
  lcd.init();
  // Asegúrate de que la luz de fondo esté encendida
  lcd.backlight();

  // crea nuevos caracteres
  lcd.createChar(0, Corazón);
  lcd.createChar(1, Campana);
  lcd.createChar(2, Alien);
  lcd.createChar(3, Marca);
  lcd.createChar(4, Altavoz);
  lcd.createChar(5, Sonido);
  lcd.createChar(6, Calavera);
  lcd.createChar(7, Candado);

  // Limpia la pantalla del LCD
  lcd.clear();

  // Imprime un mensaje en el LCD.
  lcd.print("Carácter Personalizado");
}

// Imprime todos los caracteres personalizados
void loop() { 
  lcd.setCursor(0, 1);
  lcd.write(0);

  lcd.setCursor(2, 1);
  lcd.write(1);

  lcd.setCursor(4, 1);
  lcd.write(2);

  lcd.setCursor(6, 1);
  lcd.write(3);

  lcd.setCursor(8, 1);
  lcd.write(4);

  lcd.setCursor(10, 1);
  lcd.write(5);

  lcd.setCursor(12, 1);
  lcd.write(6);

  lcd.setCursor(14, 1);
  lcd.write(7);
}

Al subir este código a tu Arduino, el LCD mostrará algo similar a esto:

¡Prueba y experimenta creando tus propios caracteres únicos!

Explicación del código para caracteres personalizados:

Después de incluir la biblioteca LiquidCrystal_I2C y configurar el objeto LCD, el código define arreglos especiales para nuestros caracteres personalizados. Cada arreglo tiene exactamente 8 bytes, y cada byte controla una fila de puntos en nuestra cuadrícula de caracteres de 5x8.

El ejemplo incluye ocho caracteres personalizados diferentes. Tomemos como ejemplo el arreglo Corazón[8]:

byte Corazón[8] = {
  0b00000,
  0b01010,
  0b11111,
  0b11111,
  0b01110,
  0b00100,
  0b00000,
  0b00000
};

Cada línea representa una fila de píxeles, comenzando desde la parte superior del carácter. El “0b” al principio indica que se trata de un número binario (formado por 0s y 1s). Cada 0 significa “píxel apagado” y cada 1 significa “píxel encendido”. Si observas cuidadosamente el patrón, puedes ver cómo los 1s forman la forma de un corazón.

En la sección de configuración del código, utilizamos la función createChar() para almacenar nuestro carácter personalizado en la memoria del LCD. Esta función requiere dos piezas de información: un número entre 0 y 7 (que indica al LCD qué uno de los ocho slots de memoria disponibles utilizar) y el nombre del arreglo que contiene nuestro diseño de carácter.

El siguiente código almacena nuestro diseño de corazón en el slot 0 de la memoria CGRAM del LCD.

lcd.createChar(0, Corazón);

Finalmente, en la sección de loop, mostramos nuestro carácter personalizado usando la función write(). Le indicamos qué carácter mostrar pasando el número de slot de memoria:

lcd.write(byte(0));