Cómo usar una pantalla LCD I2C (16x2) con Arduino, ESP32 y Pico

La pantalla LCD de 16x2, que muestra 2 filas de 16 caracteres, es la más habitual en el mundo Arduino. Se usa para mostrar medidas como la temperatura o la distancia, menús, relojes y marcadores de juegos. La pantalla tiene 16 pines y por sí sola necesita al menos 6 pines digitales; el pequeño módulo I2C soldado por detrás lo reduce a solo 2 cables de datos. En este artículo verás paso a paso cómo conectar una LCD I2C, encontrar su dirección y escribir en ella lo que quieras.

¿Cómo funciona una pantalla LCD?

Estas pantallas funcionan con un chip controlador llamado HD44780. Cada carácter se dibuja en una pequeña celda de 5x8 píxeles y el chip lleva una tabla de caracteres con letras, números y algunos símbolos. Arduino solo envía la orden "escribe esta letra en esta posición"; convertir la letra en píxeles es tarea de la pantalla. La retroiluminación LED permite leer el texto a oscuras y la capa de cristal líquido forma el texto oscureciendo los píxeles.

¿Qué es I2C y por qué lo hace todo más fácil?

I2C es una forma de que varios dispositivos se comuniquen con solo dos cables: SDA lleva los datos y SCL la señal de reloj. Cada dispositivo tiene su propia dirección y Arduino llama al que quiere usando esa dirección. Los módulos LCD suelen usar la dirección 0x27 o 0x3F. En los mismos dos cables se pueden conectar un módulo de reloj, una pantalla OLED y sensores como el BME280; mientras sus direcciones sean distintas, todos funcionan juntos.

El chip PCF8574 del módulo convierte las órdenes que llegan por I2C en las 8 señales paralelas que espera la pantalla. Puedes usar la pantalla sin módulo I2C, pero entonces necesitas 6 pines, un potenciómetro y muchos cables. El módulo ahorra pines y simplifica el circuito.

Características técnicas

Conexión de la LCD I2C: Arduino, ESP32 y Pico

En todas las placas son los mismos cuatro cables; lo único que cambia es en qué pines están SDA y SCL. Para ver los pines I2C de tu placa, consulta la herramienta Pinout.

Encontrar la dirección I2C: el escáner

Si no sabes la dirección de tu pantalla, carga el código siguiente. Prueba todas las direcciones del 1 al 126 y escribe en el Monitor Serie la dirección de cada dispositivo que responde. Usarás esa dirección al configurar la pantalla.

1#include <Wire.h>
2
3void setup() {
4  Wire.begin();
5  Serial.begin(9600);
6  Serial.println("I2C taranıyor / scanning...");
7  for (byte addr = 1; addr < 127; addr++) {
8    Wire.beginTransmission(addr);
9    if (Wire.endTransmission() == 0) {   // cihaz cevap verdi / device answered
10      Serial.print("Bulundu / found: 0x");
11      Serial.println(addr, HEX);
12    }
13  }
14}
15
16void loop() {
17}

Instalar la librería y escribir texto

En el Gestor de librerías busca LiquidCrystal I2C e instala la librería de Frank de Brabander. El código siguiente escribe un saludo en la primera fila y, en la segunda, los segundos transcurridos desde que arrancó el Arduino.

1#include <Wire.h>
2#include <LiquidCrystal_I2C.h>
3
4LiquidCrystal_I2C lcd(0x27, 16, 2);  // adres, sütun, satır / address, columns, rows
5
6void setup() {
7  lcd.init();
8  lcd.backlight();               // arka ışığı aç / backlight on
9  lcd.setCursor(0, 0);           // sütun 0, satır 0 / column 0, row 0
10  lcd.print("Merhaba Dunya!");
11}
12
13void loop() {
14  lcd.setCursor(0, 1);           // ikinci satır / second row
15  lcd.print("Sure: ");
16  lcd.print(millis() / 1000);    // saniye / seconds
17  lcd.print(" sn   ");           // eski rakamları sil / clear old digits
18  delay(200);
19}

Los comandos más usados de la LCD

Texto desplazable

Para mostrar un texto de más de 16 caracteres puedes desplazar la pantalla. El código siguiente escribe el texto y lo mueve a la izquierda cada 300 milisegundos, de modo que un mensaje largo pasa por la pantalla como un rótulo.

1#include <Wire.h>
2#include <LiquidCrystal_I2C.h>
3
4LiquidCrystal_I2C lcd(0x27, 16, 2);
5
6void setup() {
7  lcd.init();
8  lcd.backlight();
9  lcd.print("BlueGrays ile elektronik ogren");  // 16 karakterden uzun / longer than 16 chars
10}
11
12void loop() {
13  lcd.scrollDisplayLeft();   // bir adım sola / one step left
14  delay(300);
15}

Caracteres personalizados y letras con tilde

La tabla de caracteres del HD44780 no incluye letras como á, é, í, ó, ú o ñ en su forma habitual; si intentas escribirlas verás símbolos sin sentido. La solución es definir hasta 8 caracteres personalizados de 5x8 píxeles. Cada fila se escribe como un byte y los bits a 1 son los píxeles encendidos. El ejemplo siguiente dibuja un corazón; del mismo modo puedes dibujar la ñ o cualquier letra con tilde.

1byte heart[8] = {
2  0b00000,
3  0b01010,
4  0b11111,
5  0b11111,
6  0b01110,
7  0b00100,
8  0b00000,
9  0b00000
10};
11
12// setup() içinde / inside setup()
13lcd.createChar(0, heart);   // 0. yuvaya kaydet / store in slot 0
14lcd.setCursor(15, 0);
15lcd.write(byte(0));         // kalbi göster / show the heart

LCD I2C con el ESP32 y la Raspberry Pi Pico

En el ESP32 funcionan el mismo código de Arduino y la misma librería; Wire.begin() usa por defecto GPIO 21 (SDA) y GPIO 22 (SCL). Si quieres otros pines, escribe Wire.begin(SDA, SCL). En la Raspberry Pi Pico con MicroPython, copia en la Pico dos archivos pequeños llamados lcd_api.py y pico_i2c_lcd.py y úsalos así:

1from machine import I2C, Pin
2from pico_i2c_lcd import I2cLcd   # Pico'ya kopyalanan dosya / file copied to the Pico
3
4i2c = I2C(0, sda=Pin(4), scl=Pin(5), freq=400000)
5addr = i2c.scan()[0]              # ilk bulunan adres / first found address
6lcd = I2cLcd(i2c, addr, 2, 16)    # 2 satır, 16 sütun / 2 rows, 16 columns
7
8lcd.putstr("Merhaba Pico!")
9lcd.move_to(0, 1)                 # sütun 0, satır 1 / column 0, row 1
10lcd.putstr("BlueGrays")

Ideas de proyectos con LCD I2C

• Termómetro digital: muestra temperatura y humedad en la pantalla; para el sensor, mira Sensor de temperatura y humedad DHT11.
• Indicador de distancia: muestra en centímetros la distancia medida con un HC-SR04; detalles en Sensor de distancia HC-SR04.
• Voltímetro digital: muestra la tensión que lees en un pin analógico.
• Cerradura con clave: muestra con asteriscos la clave introducida en un teclado matricial.
• Sistema de menús: recorre las opciones de la pantalla con un potenciómetro o dos botones.
• Minijuego: haz que un corredor dibujado con caracteres personalizados esquive obstáculos.

Errores comunes y cómo solucionarlos

• Pantalla encendida pero sin texto: el contraste no está ajustado; gira el trimpot.
• Bloques llenos en la fila superior: la pantalla recibe corriente pero no se ha inicializado; la dirección puede ser incorrecta, SDA y SCL pueden estar invertidos o falta lcd.init().
• Dirección equivocada: el código pone 0x27 pero la pantalla es 0x3F; encuentra la dirección real con el escáner.
• Quedan cifras antiguas: un número que baja de 100 a 99 aparece como 990; escribe unos espacios después del número. lcd.clear() también sirve, pero es lento y hace parpadear la pantalla si lo llamas a menudo en el bucle.
• Letras con tilde estropeadas: no están en la tabla de la pantalla; define caracteres personalizados o evítalas.
• Texto que se corrompe al azar: cables largos y flojos o piezas ruidosas como motores pueden alterar el bus I2C; usa cables cortos y alimenta los motores aparte.

Combinar la pantalla con un sensor es la forma más rápida de hacer tu primer proyecto de verdad. En la app BlueGrays encontrarás decenas de proyectos con LCD I2C, con esquemas y código listo para usar; y para cambiar valores con una rueda te será útil ¿Qué es un potenciómetro?