Controla Displays LCD con Arduino: ¡Muestra Datos de tus Proyectos sin Esfuerzo!

Los displays de Cristal Líquido (LCD) son una forma increíblemente útil y popular de añadir una interfaz de usuario a tus proyectos de Arduino. Ya sea para mostrar lecturas de sensores, mensajes de estado o incluso un pequeño juego, un LCD puede transformar un proyecto de un circuito de luces parpadeantes a una pieza interactiva y comprensible. En esta guía completa, te enseñaremos cómo conectar y programar displays LCD de 16x2 y 20x4 caracteres con Arduino, explorando tanto la conexión directa como el uso del popular módulo I2C para simplificar drásticamente el cableado.

---

📖 ¿Qué es un Display LCD y Por Qué Usarlo?

Un display LCD (Liquid Crystal Display) es un dispositivo de visualización que utiliza cristales líquidos para mostrar texto, números y a veces incluso caracteres personalizados. Los modelos más comunes en el mundo de Arduino son los LCD 16x2 (16 caracteres por 2 líneas) y 20x4 (20 caracteres por 4 líneas).

✅ Ventajas de Usar un LCD:

• Feedback visual: Proporciona información instantánea y clara sobre el estado de tu proyecto.
• Depuración: Ayuda a depurar código mostrando valores de variables en tiempo real.
• Interfaz de usuario: Permite al usuario interactuar con el proyecto mostrando menús o mensajes.
• Versatilidad: Compatibles con una amplia gama de microcontroladores y proyectos.

---

🛠️ Materiales Necesarios

Para seguir este tutorial, necesitarás los siguientes componentes:

Componente	Cantidad	Descripción
---	---	---
Placa Arduino (Uno, Nano, Mega)	1	El cerebro de nuestro proyecto.
Display LCD 16x2 o 20x4	1	El protagonista, para mostrar datos.
---	---	---
Protoboard	1	Para realizar las conexiones sin soldar.
Jumpers (cables macho-macho)	~16 (sin I2C), ~4 (con I2C)	Para conectar los componentes.
---	---	---
Potenciómetro de 10kΩ	1	Para ajustar el contraste del LCD (no necesario con módulo I2C).
Resistencia de 220Ω	1	Para limitar la corriente de la retroiluminación (opcional, algunos LCDs tienen una integrada, otros no).
---	---	---
Módulo adaptador I2C para LCD	1 (opcional)	Simplifica el cableado a solo 4 pines.

---

🔌 Conexión del LCD Directamente al Arduino (Modo 4-bit)

La conexión directa de un LCD a Arduino es la forma tradicional. Aunque requiere más cables, es fundamental entenderla para comprender cómo funciona el LCD a bajo nivel. Utilizaremos el modo de 4 bits para ahorrar pines digitales en el Arduino.

📌 Esquema de Conexión (sin I2C)

Vamos a conectar los pines del LCD a tu Arduino. Presta mucha atención a los pines RS, EN, y los pines de datos D4-D7.

Aquí tienes la tabla de conexiones detallada:

Pin LCD	Función	Conexión Arduino / Otro Componente
---	---	---
VSS	Tierra	GND (Arduino)
VDD	Alimentación	5V (Arduino)
---	---	---
VO	Contraste	Patilla central de Potenciómetro 10kΩ. Los extremos del pot. a 5V y GND.
RS	Register Select	Pin Digital 12 (Arduino)
---	---	---
RW	Read/Write	GND (Arduino) (Siempre escribiremos, no leeremos)
EN	Enable	Pin Digital 11 (Arduino)
---	---	---
D0-D3	(No usado en modo 4-bit)	Dejar sin conectar
D4	Data Bit 4	Pin Digital 5 (Arduino)
---	---	---
D5	Data Bit 5	Pin Digital 4 (Arduino)
D6	Data Bit 6	Pin Digital 3 (Arduino)
---	---	---
D7	Data Bit 7	Pin Digital 2 (Arduino)
A	Anodo Backlight	5V (Arduino) a través de Resistencia 220Ω
---	---	---
K	Catodo Backlight	GND (Arduino)

✍️ Código Básico (sin I2C)

Una vez que tengas todo conectado, es hora de programar. Utilizaremos la librería LiquidCrystal que viene incluida con el IDE de Arduino.

#include <LiquidCrystal.h>

// Inicializa la librería con los números de los pines de interfaz:
// LiquidCrystal(rs, enable, d4, d5, d6, d7);
LiquidCrystal lcd(12, 11, 5, 4, 3, 2);

void setup() {
  // Configura el número de columnas y filas del LCD:
  lcd.begin(16, 2);
  // Imprime un mensaje en el LCD.
  lcd.print("Hola, Mundo!");
}

void loop() {
  // Mueve el cursor a la columna 0, fila 1
  // (las filas y columnas se cuentan desde 0):
  lcd.setCursor(0, 1);
  // Imprime el número de segundos desde que el Arduino se inició:
  lcd.print(millis() / 1000);
}

Explicación del Código:

1. #include <LiquidCrystal.h>: Incluye la librería necesaria.
2. LiquidCrystal lcd(12, 11, 5, 4, 3, 2);: Declara un objeto lcd e indica a Arduino qué pines digitales están conectados a RS, EN, D4, D5, D6, y D7 respectivamente.
3. lcd.begin(16, 2);: Inicializa la interfaz del LCD. Debes especificar el número de columnas (16) y filas (2) de tu LCD.
4. lcd.print("Hola, Mundo!");: Muestra el texto "Hola, Mundo!" en la pantalla.
5. lcd.setCursor(0, 1);: Mueve el cursor a la columna 0, fila 1 (la segunda fila). Recuerda que la indexación es base 0.
6. lcd.print(millis() / 1000);: Muestra el tiempo en segundos desde el inicio del Arduino. millis() devuelve milisegundos, por lo que se divide entre 1000.

---

✨ Simplificando con el Módulo I2C para LCD

El módulo I2C (Inter-Integrated Circuit) es un pequeño adaptador que se solda a los pines de la parte trasera de tu LCD. Su gran ventaja es que reduce drásticamente el número de pines necesarios para controlar el LCD de 16 (o más) a solo 4: VCC, GND, SDA y SCL. Esto es ideal para proyectos donde los pines del Arduino son limitados.

📌 Esquema de Conexión (con I2C)

La conexión con el módulo I2C es mucho más sencilla:

Aquí la tabla de conexiones:

Pin Módulo I2C	Función	Conexión Arduino
---	---	---
VCC	Alimentación	5V (Arduino)
GND	Tierra	GND (Arduino)
---	---	---
SDA	Datos I2C	Pin Analógico A4 (Arduino Uno/Nano), Pin Digital 20 (Arduino Mega)
SCL	Reloj I2C	Pin Analógico A5 (Arduino Uno/Nano), Pin Digital 21 (Arduino Mega)

✍️ Código Básico (con I2C)

Para usar el módulo I2C, necesitaremos una librería diferente. La más popular es LiquidCrystal_I2C. Si no la tienes instalada, ve a Programa > Incluir Librería > Administrar Librerías... en el IDE de Arduino y busca "LiquidCrystal I2C" o "HD44780" de Frank de Brabander e instálala.

#include <Wire.h> 
#include <LiquidCrystal_I2C.h>

// Configura la dirección del I2C y el tamaño del LCD.
// La dirección I2C común es 0x27 o 0x3F. Si no funciona, prueba la otra.
// LiquidCrystal_I2C(dirección, columnas, filas);
LiquidCrystal_I2C lcd(0x27, 16, 2);

void setup() {
  // Inicializa el LCD I2C.
  lcd.init();
  // Enciende la retroiluminación (si tu módulo la tiene).
  lcd.backlight();

  // Imprime un mensaje en el LCD.
  lcd.print("LCD I2C OK!");
}

void loop() {
  // Mueve el cursor a la columna 0, fila 1
  lcd.setCursor(0, 1);
  // Imprime el número de segundos desde que el Arduino se inició:
  lcd.print(millis() / 1000);
}

Buscando la Dirección I2C:

Si el código no funciona, es muy probable que la dirección I2C de tu módulo sea diferente a 0x27. La dirección I2C varía entre fabricantes (0x3F es otra común). Puedes usar este scanner de direcciones para encontrar la correcta:

#include <Wire.h>

void setup() {
  Wire.begin();
  Serial.begin(9600);
  Serial.println("Escaneando direcciones I2C...");
  Serial.println("Si no encuentra nada, revisa las conexiones.");
}

void loop() {
  byte error, address;
  int nDevices;

  Serial.println("Escaneando...");

  nDevices = 0;
  for(address = 1; address < 127; address++ ) {
    // Escanea si hay un dispositivo en esta dirección
    Wire.beginTransmission(address);
    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 I2C.\n");
  else
    Serial.println("¡Listo!\n");

  delay(5000); // Espera 5 segundos antes de volver a escanear
}

Carga este sketch en tu Arduino, abre el Monitor Serie (a 9600 baudios) y te dirá la dirección I2C de tu módulo. Luego, actualiza la línea LiquidCrystal_I2C lcd(0x27, 16, 2); con la dirección correcta.

---

🚀 Funciones Útiles de la Librería LiquidCrystal (y LiquidCrystal_I2C)

Ambas librerías comparten muchas funciones similares. Aquí tienes algunas de las más comunes y útiles:

Básico

• lcd.begin(cols, rows);: Inicializa el LCD. Solo para LiquidCrystal. Para LiquidCrystal_I2C es lcd.init();
• lcd.print("texto");: Muestra texto en el LCD.
• lcd.setCursor(col, row);: Mueve el cursor a una posición específica. (0,0 es la esquina superior izquierda).
• lcd.clear();: Borra todo el contenido de la pantalla y vuelve el cursor a (0,0).
• lcd.home();: Mueve el cursor a (0,0) sin borrar la pantalla.

Control de Visualización

• lcd.noDisplay();: Apaga la visualización del texto (pero el texto permanece en la memoria del LCD).
• lcd.display();: Enciende la visualización del texto.
• lcd.noBlink();: Desactiva el parpadeo del cursor.
• lcd.blink();: Activa el parpadeo del cursor.
• lcd.noCursor();: Oculta el cursor (subrayado).
• lcd.cursor();: Muestra el cursor (subrayado).
• lcd.scrollDisplayLeft();: Desplaza el contenido de la pantalla un carácter a la izquierda.
• lcd.scrollDisplayRight();: Desplaza el contenido de la pantalla un carácter a la derecha.

Retroiluminación (Solo LiquidCrystal_I2C)

• lcd.backlight();: Enciende la retroiluminación del LCD.
• lcd.noBacklight();: Apaga la retroiluminación del LCD.

---

🌟 Proyecto Avanzado: Termómetro con LCD y Sensor DHT11/DHT22

Vamos a combinar lo aprendido con un sensor de temperatura y humedad, el DHT11 o DHT22, para crear un termómetro digital con pantalla LCD.

🛠️ Materiales Adicionales

• Sensor DHT11 o DHT22 (temperatura y humedad)
• Resistencia de 10kΩ (para el sensor DHT, opcional, algunos módulos ya la incluyen)

📌 Esquema de Conexión (LCD I2C + DHT)

Conecta el sensor DHT al pin digital 7 del Arduino. La conexión del LCD I2C es la misma que vimos antes.

✍️ Código para Termómetro con DHT y LCD I2C

Necesitarás instalar la librería DHT sensor library de Adafruit y la librería Adafruit Unified Sensor. Ambas están disponibles en el Administrador de Librerías del IDE de Arduino.

#include <Wire.h>
#include <LiquidCrystal_I2C.h>
#include <DHT.h>
#include <DHT_U.h> // Necesaria para la librería DHT de Adafruit

// Define el pin donde está conectado el sensor DHT
#define DHTPIN 7
// Define el tipo de sensor DHT que estás usando: DHT11 o DHT22
#define DHTTYPE DHT11 

// Inicializa el sensor DHT
DHT dht(DHTPIN, DHTTYPE);

// Inicializa el LCD I2C. Asegúrate de que la dirección sea correcta (0x27 o 0x3F)
// Y el tamaño de tu LCD (16,2 para 16x2; 20,4 para 20x4)
LiquidCrystal_I2C lcd(0x27, 16, 2);

void setup() {
  // Inicializa el LCD
  lcd.init();
  lcd.backlight(); // Enciende la retroiluminación
  lcd.clear(); // Limpia la pantalla
  lcd.print("Iniciando sensor...");

  // Inicializa el sensor DHT
  dht.begin();
  delay(2000);
  lcd.clear();
}

void loop() {
  // Espera unos segundos entre lecturas. Un delay de 2 segundos es bueno para DHT11.
  delay(2000);

  // Lee la humedad y la temperatura del sensor
  float h = dht.readHumidity();
  float t = dht.readTemperature(); // Temperatura en Celsius por defecto
  float f = dht.readTemperature(true); // Temperatura en Fahrenheit

  // Comprueba si alguna lectura falló y sale de la función si es así.
  if (isnan(h) || isnan(t) || isnan(f)) {
    lcd.setCursor(0,0);
    lcd.print("Error DHT!");
    lcd.setCursor(0,1);
    lcd.print("Revisa sensor");
    return;
  }

  // Calcula el índice de calor en Fahrenheit y Celsius
  float hif = dht.computeHeatIndex(f, h);
  float hic = dht.computeHeatIndex(t, h, false);

  // Muestra la humedad en la primera línea
  lcd.setCursor(0, 0);
  lcd.print("Hum: ");
  lcd.print(h);
  lcd.print(" % ");

  // Muestra la temperatura en la segunda línea
  lcd.setCursor(0, 1);
  lcd.print("Temp: ");
  lcd.print(t);
  lcd.print((char)223); // Carácter de grado (°) para LCD
  lcd.print("C");

  // Si tu LCD es 20x4, puedes mostrar más información:
  // lcd.setCursor(0, 2);
  // lcd.print("Fah: "); lcd.print(f); lcd.print((char)223); lcd.print("F");
  // lcd.setCursor(0, 3);
  // lcd.print("Sens: "); lcd.print(hic); lcd.print((char)223); lcd.print("C");
}

Consideraciones para LCD 20x4:

Si estás usando un LCD 20x4, simplemente cambia la línea de inicialización:

LiquidCrystal_I2C lcd(0x27, 20, 4); // Para un LCD 20x4

Y puedes usar las filas adicionales 2 y 3 (índices 1 y 2) con lcd.setCursor(col, row); para mostrar más datos, como los ejemplos comentados en el código.

---

troubleshooting 🔍 Problemas Comunes y Soluciones

Aquí tienes una tabla con algunos problemas comunes que puedes encontrar y cómo resolverlos:

Problema Común	Posible Causa	Solución
---	---	---
LCD muestra cuadrados negros	Contraste incorrecto, cableado VSS/VDD/VO incorrecto, o alimentación insuficiente.	Ajusta el potenciómetro. Revisa las conexiones de alimentación y contraste. Asegúrate de que 5V y GND estén bien.
LCD no muestra nada (en blanco)	Retroiluminación apagada, cableado incorrecto.	Si es I2C, usa lcd.backlight(). Revisa las conexiones de la retroiluminación (A y K) y la resistencia si es conexión directa.
---	---	---
Texto ilegible o caracteres raros	Dirección I2C incorrecta (para I2C), pines de datos incorrectos (sin I2C).	Usa el scanner I2C para encontrar la dirección correcta. Revisa cuidadosamente los pines D4-D7 y RS, EN en el modo directo.
"Error DHT!" en la pantalla	Sensor DHT mal conectado, tipo de sensor incorrecto en el código, librería no instalada.	Revisa las conexiones del DHT (VCC, GND, Data). Asegúrate de que #define DHTTYPE coincida con tu sensor (DHT11/DHT22). Instala las librerías DHT sensor library y Adafruit Unified Sensor.
---	---	---
No puedo cargar el código	Librería no instalada, error de sintaxis.	Instala todas las librerías mencionadas. Revisa que el código sea exactamente como el del tutorial.

¿Por qué el potenciómetro es necesario en la conexión directa?

El potenciómetro controla el voltaje aplicado al pin `VO` (Voltage Output) del LCD. Este voltaje es crucial para ajustar la polarización de los cristales líquidos y, por lo tanto, el contraste de los caracteres. Si el contraste no está bien ajustado, el texto puede ser muy pálido o, por el contrario, aparecer como bloques sólidos.

¿Puedo usar un LCD con más líneas o caracteres?

Sí, los principios son los mismos. Simplemente cambia los parámetros `(cols, rows)` en `lcd.begin()` o `LiquidCrystal_I2C lcd(address, cols, rows);` según el tamaño de tu LCD (por ejemplo, `20,4` para un 20x4).

---

🎯 Conclusión

¡Felicidades! Ahora tienes las herramientas y el conocimiento para integrar displays LCD en tus proyectos de Arduino. Ya sea que optes por la conexión directa para un mayor control o por la simplicidad del módulo I2C, los displays LCD abren un mundo de posibilidades para hacer tus proyectos más interactivos y fáciles de usar.

Experimenta con las funciones de las librerías, intenta mostrar datos de otros sensores, o incluso crea un pequeño menú interactivo. ¡El único límite es tu imaginación!