Pantalla LCD 16x2 I2C con Arduino: conexión, librería y código paso a paso

La pantalla LCD 16x2 es la forma más sencilla de que tu proyecto "hable": muestra la distancia de un sensor, la temperatura del salón, un contador o un mensaje de bienvenida sin depender del computador. El problema es que la LCD sola necesita muchos cables. Con el módulo I2C soldado por detrás, todo se reduce a cuatro cables. En esta guía vas a aprender a usar una LCD 16x2 I2C con Arduino paso a paso: la conexión, cómo instalar la librería, cómo encontrar la dirección (0x27 o 0x3F) con un escáner, el código "Hola Mundo" y la solución a los errores más comunes.

¿Qué es una LCD 16x2 I2C?

Una LCD 16x2 es una pantalla de cristal líquido que muestra 2 filas de 16 caracteres cada una, es decir, 32 caracteres al mismo tiempo. La mayoría usa el controlador HD44780 o uno compatible.

La pantalla sin módulo tiene 16 pines y, para manejarla desde Arduino, normalmente se usan 6 pines digitales más un potenciómetro externo para el contraste. Eso ocupa casi la mitad de los pines del Arduino Uno y llena la protoboard de cables.

El módulo I2C (también llamado backpack o adaptador) es una plaquita pequeña con un chip PCF8574 que se suelda a los 16 pines de la LCD. Ese chip recibe las órdenes por el bus I2C, que solo usa dos líneas de datos: SDA (datos) y SCL (reloj). Así, con GND, VCC, SDA y SCL ya controlas toda la pantalla. Si estás empezando, cómprala con el módulo ya soldado.

LCD sin módulo vs LCD con módulo I2C

Característica	LCD 16x2 sin módulo	LCD 16x2 con módulo I2C
Cables al Arduino	6 de datos + alimentación	4 en total (GND, VCC, SDA, SCL)
Contraste	Potenciómetro externo en la protoboard	Potenciómetro azul incluido en el módulo
Librería	LiquidCrystal (viene con el IDE)	LiquidCrystal_I2C (se instala aparte)
Pines libres para sensores	Pocos	Casi todos
Varias pantallas a la vez	Difícil	Posible, cambiando la dirección I2C

Materiales

• Arduino Uno (o Nano, que usa los mismos pines A4 y A5).
• Pantalla LCD 16x2 con módulo I2C soldado.
• 4 cables jumper hembra-macho (el módulo trae pines macho).
• Cable USB y el Arduino IDE instalado en el computador.
• Un destornillador pequeño de pala para ajustar el contraste.

Paso 1: conexión de la LCD I2C al Arduino Uno

La conexión es la parte más fácil. Con el Arduino desconectado del USB, conecta los cuatro pines del módulo así:

Pin del módulo I2C	Función	Pin del Arduino Uno
GND	Tierra (negativo)	GND
VCC	Alimentación	5V
SDA	Datos I2C	A4
SCL	Reloj I2C	A5

En el Arduino Uno R3 también hay dos pines marcados SDA y SCL cerca del botón de reset; están unidos internamente a A4 y A5, así que puedes usar cualquiera de los dos pares. En el Arduino Mega los pines I2C son el 20 (SDA) y el 21 (SCL), y en un ESP32 normalmente se usan el GPIO 21 (SDA) y el GPIO 22 (SCL).

Paso 2: instalar la librería LiquidCrystal_I2C

El IDE de Arduino no trae la librería para la versión I2C, así que hay que instalarla una sola vez:

1. Abre el Arduino IDE y entra a Herramientas > Administrar bibliotecas (en el IDE 2 también está el ícono de libros en la barra lateral).
2. En el buscador escribe LiquidCrystal I2C.
3. Busca la que dice "LiquidCrystal I2C by Frank de Brabander" y pulsa Instalar.
4. Cuando termine, ya puedes escribir #include <LiquidCrystal_I2C.h> en tu programa.

Hay otras librerías con nombres parecidos. Si instalas una distinta, algunas funciones cambian (por ejemplo, unas usan lcd.begin() y otras lcd.init()). Los códigos de esta guía están pensados para la de Frank de Brabander. Si al compilar con un ESP32 aparece una advertencia de que la librería es para AVR, normalmente es solo un aviso y el programa funciona igual.

Paso 3: encontrar la dirección I2C con el escáner

Cada dispositivo I2C tiene una dirección, como si fuera el número de una casa en la misma calle. La mayoría de módulos para LCD usan 0x27 o 0x3F, según el chip que traigan: el PCF8574T suele venir en 0x27 y el PCF8574AT en 0x3F. Si pones la dirección equivocada en el código, la pantalla se enciende pero no muestra texto.

Para salir de dudas, carga este escáner I2C. Solo usa la librería Wire, que ya viene con el IDE:

#include <Wire.h>

void setup() {
  Wire.begin();
  Serial.begin(9600);
  Serial.println("Buscando dispositivos I2C...");
}

void loop() {
  int encontrados = 0;
  for (byte direccion = 1; direccion < 127; direccion++) {
    Wire.beginTransmission(direccion);
    if (Wire.endTransmission() == 0) {
      Serial.print("Dispositivo encontrado en 0x");
      if (direccion < 16) Serial.print("0");
      Serial.println(direccion, HEX);
      encontrados++;
    }
  }
  if (encontrados == 0) Serial.println("No se encontró nada. Revisa SDA y SCL.");
  delay(3000);
}

Sube el programa, abre el Monitor Serie (lupa arriba a la derecha) y elige 9600 baudios. Verás algo como Dispositivo encontrado en 0x27. Anota ese número: es el que va en el siguiente código.

Paso 4: código "Hola Mundo" en la LCD 16x2 I2C

Este es el primer programa que conviene probar. Muestra un texto en la fila de arriba y otro en la de abajo:

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

// dirección, columnas, filas (cambia 0x27 por 0x3F si tu escáner lo indica)
LiquidCrystal_I2C lcd(0x27, 16, 2);

void setup() {
  lcd.init();          // inicia la pantalla
  lcd.backlight();     // enciende la luz de fondo
  lcd.setCursor(0, 0); // columna 0, fila 0
  lcd.print("Hola Mundo!");
  lcd.setCursor(0, 1); // columna 0, fila 1
  lcd.print("LCD I2C lista");
}

void loop() {
}

Las funciones que más vas a usar son pocas:

• lcd.init(): prepara la pantalla; va una sola vez en setup().
• lcd.backlight() y lcd.noBacklight(): encienden o apagan la luz de fondo.
• lcd.setCursor(columna, fila): mueve el cursor a una posición.
• lcd.print(): escribe texto o números.
• lcd.clear(): borra toda la pantalla y vuelve el cursor a (0, 0).

Filas y columnas: cómo funciona setCursor

La pantalla se cuenta desde cero: las columnas van de 0 a 15 y las filas son 0 (arriba) y 1 (abajo). Por eso lcd.setCursor(2, 1) pone el texto en la tercera casilla de la segunda fila. Primero va la columna y después la fila, un orden que confunde a muchos al comienzo.

Paso 5: mostrar un valor que cambia (contador)

En los proyectos reales casi siempre vas a mostrar un número que cambia: segundos, distancia o temperatura. Este ejemplo muestra los segundos desde que se encendió el Arduino:

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

LiquidCrystal_I2C lcd(0x27, 16, 2);

void setup() {
  lcd.init();
  lcd.backlight();
  lcd.setCursor(0, 0);
  lcd.print("Tiempo encendido");
}

void loop() {
  lcd.setCursor(0, 1);
  lcd.print(millis() / 1000);
  lcd.print(" s     ");   // espacios para borrar restos
  delay(500);
}

Fíjate en los espacios después de " s": cuando un número pasa de tres cifras a dos (por ejemplo, de 100 a 99 en una cuenta regresiva), la pantalla no borra sola la cifra sobrante. Escribir espacios encima es más limpio que usar lcd.clear() en cada vuelta, que hace parpadear la pantalla.

Con esta misma idea puedes mostrar la medida del sensor ultrasónico HC-SR04 con Arduino: en lugar de millis() / 1000 imprimes la distancia en centímetros. También puedes indicar el ángulo de un servomotor SG90 con Arduino o si un módulo relé con Arduino está encendido o apagado.

Paso 6: ajustar el contraste con el potenciómetro

Por detrás del módulo hay un potenciómetro azul con una ranura. Ese es el control de contraste. Es muy común cargar el código y ver la pantalla iluminada pero sin letras, o con una fila de cuadros negros. En la mayoría de casos no es un problema del programa: solo falta girar el potenciómetro.

1. Deja el Arduino conectado y con el código "Hola Mundo" cargado.
2. Con un destornillador pequeño gira el potenciómetro despacio hacia un lado.
3. Si no aparece nada, gíralo hacia el otro lado. Detente cuando las letras se vean nítidas y el fondo de las casillas casi no se note.

Al lado del potenciómetro también hay un jumper (un puente negro) marcado LED. Si lo quitas, la luz de fondo se apaga aunque el código tenga lcd.backlight().

Errores comunes con la LCD 16x2 I2C

• Se ilumina pero no muestra letras: casi siempre es el contraste. Gira el potenciómetro azul. Si sigue igual, revisa que la dirección del código sea la que encontró el escáner.
• Muestra una fila de cuadros negros: la pantalla tiene alimentación pero no recibe datos. Revisa SDA en A4, SCL en A5 y la dirección (0x27 o 0x3F).
• El escáner dice que no encontró nada: cables flojos, SDA y SCL cruzados, o falta el GND. Prueba otros jumpers; los cables baratos a veces están rotos por dentro.
• Error "LiquidCrystal_I2C.h: No such file or directory": la librería no está instalada o el nombre del #include está mal escrito. Repite el paso 2.
• Error con lcd.init() o lcd.begin(): tienes instalada otra librería con nombre parecido. Usa la función que indica su ejemplo o instala la de Frank de Brabander.
• Quedan números "fantasma": escribe espacios después del valor, como en el ejemplo del contador.

Preguntas frecuentes

¿Cuál es la dirección I2C de la LCD 16x2?

Las más comunes son 0x27 y 0x3F. Depende del chip del módulo (PCF8574T o PCF8574AT) y de los puentes A0, A1 y A2. La forma segura de saberlo es cargar el escáner I2C de esta guía.

¿La LCD I2C funciona con 3,3 V?

La mayoría de pantallas 16x2 comunes están pensadas para 5 V; con 3,3 V el contraste suele quedar muy débil. En placas de 3,3 V como el ESP32 se suele alimentar el módulo con 5 V; como las líneas SDA y SCL del módulo quedan a 5 V, lo más seguro es usar un conversor de nivel lógico.

¿Puedo conectar dos pantallas LCD I2C al mismo Arduino?

Sí, siempre que tengan direcciones diferentes. Se cambia la dirección de una de ellas uniendo con estaño alguno de los puentes A0, A1 o A2 del módulo, y en el código se crean dos objetos, por ejemplo lcd1(0x27, 16, 2) y lcd2(0x26, 16, 2).

¿Sirve el mismo código para una LCD 20x4?

Sí. Solo cambias el constructor a LiquidCrystal_I2C lcd(0x27, 20, 4); y tendrás columnas de 0 a 19 y filas de 0 a 3.

Conclusión

Usar una LCD 16x2 I2C con Arduino es sencillo cuando sigues el orden correcto: conecta GND, 5V, SDA a A4 y SCL a A5; instala la librería LiquidCrystal_I2C; corre el escáner para confirmar la dirección; carga el "Hola Mundo" y ajusta el contraste con el potenciómetro azul. A partir de ahí, la pantalla se vuelve la salida de casi todos tus proyectos: sensores de distancia, temperatura, contadores y alarmas. Si la pantalla se ilumina y no muestra nada, recuerda la regla de oro: primero el contraste, luego la dirección.