Conectar una pantalla LCD 16x2 directamente al Arduino te come 6 pines digitales como mínimo (4 de datos, RS y Enable), y eso sin contar los de alimentación y contraste. Si ya tienes sensores, botones y un par de motores conectados, simplemente te quedas sin pines libres. La solución clásica y barata es el módulo serial I2C: una placa pequeña que se suelda detrás del LCD y te deja controlarlo entero con apenas 2 cables de datos.

En esta guía vas a aprender qué hace por dentro este módulo, cómo soldarlo al display, cómo cablearlo al Arduino y cómo cargar un código de prueba para verificar que todo quedó bien. Al final también te dejo cómo encontrar la dirección I2C correcta cuando la pantalla no muestra nada, que es el error número uno de los principiantes.

Qué es el módulo I2C y por qué solo necesita 2 cables

El corazón del módulo es un chip expansor de puertos llamado PCF8574. Este integrado recibe datos por el bus I2C (los pines SDA y SCL) y los convierte en las 8 señales paralelas que el controlador del LCD (un HD44780 o compatible) necesita para funcionar. Dicho simple: el módulo traduce "2 cables seriales" a "los 16 pines del LCD", para que tú no tengas que cablear cada uno.

El bus I2C es un protocolo de comunicación donde varios dispositivos comparten las mismas 2 líneas. Cada dispositivo tiene una dirección única (un número hexadecimal). En estos módulos la dirección suele ser 0x27, aunque muchas placas vienen configuradas en 0x3F. Esto importa, porque si pones la dirección equivocada en el código, la pantalla no responde. Más abajo te muestro cómo descubrir la tuya.

Módulo serial I2C para LCD basado en el chip PCF8574

El módulo trae además un potenciómetro azul (el cuadradito con un tornillo) para ajustar el contraste, y un jumper que activa o desactiva la retroiluminación. Ese potenciómetro es clave: si está mal ajustado, el LCD puede estar funcionando perfecto y aun así verse en blanco o completamente negro.

Materiales que vas a necesitar

  • Módulo serial I2C (basado en PCF8574)
  • Arduino Uno, Nano o Mega
  • Display LCD 16x2 o 20x4 con controlador HD44780
  • Jumpers macho hembra para las conexiones
  • Cautín y estaño para soldar el módulo al LCD

Tanto el LCD 16x2 como el 20x4 tienen 16 pines en la parte superior, así que el mismo módulo I2C sirve para ambos sin cambios.

Paso 1: soldar el módulo al LCD

Antes de cablear nada, el módulo I2C tiene que quedar soldado a la tira de 16 pines del display. Esta es la parte que más cuesta a quien recién empieza, pero es directa: alineas los 16 pines del módulo con los 16 huecos del LCD y sueldas uno por uno, cuidando de no hacer puentes de estaño entre pines vecinos.

Módulo I2C soldado en la parte trasera de un LCD 16x2

Un consejo práctico: suelda primero los dos pines de los extremos para fijar el módulo en posición, revisa que quede recto y recién ahí suelda los 14 del medio. Si te queda torcido, con solo 2 puntos es fácil corregir; con los 16 ya hechos, es un dolor.

Paso 2: conectar el módulo al Arduino

Una vez soldado, el módulo expone 4 pines hacia afuera: GND, VCC, SDA y SCL. El cableado es mínimo:

  • VCC del módulo va al 5V del Arduino
  • GND del módulo va al GND del Arduino
  • SDA del módulo va al pin SDA del Arduino
  • SCL del módulo va al pin SCL del Arduino

Diagrama de conexión del módulo I2C a un Arduino Uno mostrando SDA y SCL

Acá viene un detalle importante que confunde a mucha gente: dónde están los pines SDA y SCL cambia según la placa. En la mayoría de los Arduino (Uno, Nano, Pro Mini) el SDA está en el pin analógico A4 y el SCL en el A5. En el Arduino Mega son los pines digitales 20 (SDA) y 21 (SCL), y en las placas más nuevas (Uno R3 en adelante) además hay pines SDA/SCL rotulados junto al pin AREF. Si tu placa los tiene rotulados, usa esos; si no, ve directo a A4 y A5.

Paso 3: instalar la librería correcta

El módulo I2C no funciona con la librería LiquidCrystal estándar que viene con el IDE de Arduino, porque esa controla el LCD en modo paralelo. Necesitas una librería específica para LCD por I2C. La más usada es LiquidCrystal_I2C, que reemplaza a la estándar y maneja la comunicación a través del PCF8574.

Instalala desde el gestor de librerías del IDE (Programa → Incluir Librería → Administrar bibliotecas) buscando "LiquidCrystal I2C", o descargá la versión clásica de Geeetech que enlazo al final. Si tienes una versión muy antigua del IDE, fíjate de bajar la librería compatible con esa versión.

Paso 4: cargar el código de prueba

Con la librería instalada, este sketch muestra dos mensajes alternados en la pantalla. Sirve perfecto para confirmar que el módulo, la soldadura y la dirección I2C están bien:

C++ 
/*ElectroCrea.com
Módulo Serial I2C     Arduino
----------------------------
 VCC                  5V
 GND                  GND
 SCL                  SCL
 SDA                  SDA              
*/
#include <Wire.h>                 
#include <LiquidCrystal_I2C.h>    
LiquidCrystal_I2C lcd(0x27, 2, 1, 0, 4, 5, 6, 7, 3, POSITIVE);//Direccion de LCD
////////////////////////////////////////////////////////////////////VOID SETUP
void setup()   { 
lcd.begin(16,2);// Indicamos medidas de LCD        
}
////////////////////////////////////////////////////////////////////VOID LOOP
void loop() {
lcd.clear();//Elimina todos los simbolos del LCD
lcd.setCursor(0,0);//Posiciona la primera letra despues del segmento 5 en linea 1             
lcd.print("ElectroCrea.com");
delay (2000);//Dura 2 segundos
lcd.clear();
lcd.setCursor(3,1);//Posiciona la primera letra despues del segmento 6 en linea 2            
lcd.print("Visitanos!");
delay (1000);//Dura 1 segundo
  
}
//Mas información en ElectroCrea.com

Fíjate en la primera línea de código relevante: lcd(0x27, ...). Ese 0x27 es la dirección I2C. Si tu pantalla queda en blanco aun con el contraste ajustado, lo más probable es que tu módulo sea 0x3F: cambia ese valor y vuelve a cargar.

Para lcd.print puedes usar texto plano. lcd.setCursor(columna, fila) mueve el cursor (la primera columna y la primera fila son el 0), y lcd.clear() borra todo lo que hay en pantalla.

Los 2 errores más comunes (y cómo arreglarlos)

Si cargaste el código y la pantalla no muestra el mensaje, casi siempre es una de estas dos cosas:

  1. No ajustaste el potenciómetro de contraste. Gira lentamente el tornillo del potenciómetro azul del módulo con un destornillador chico. Vas a ver cómo aparecen y desaparecen los bloques de caracteres. El punto justo es donde el texto se lee nítido sobre el fondo.
  2. La librería o la dirección están mal. Si solo se enciende el backlight pero no sale texto, revisa que instalaste la librería I2C correcta (no la LiquidCrystal estándar) y que la dirección del código coincide con la de tu módulo.

Para descubrir tu dirección real sin adivinar, carga el sketch I2C Scanner (viene de ejemplo en muchas librerías). Recorre todas las direcciones del bus y te imprime en el Monitor Serial cuál respondió. Esa es la que va en tu LiquidCrystal_I2C lcd(...).

Variantes y mejoras

Una vez que tienes el LCD andando por I2C, se abren varias posibilidades que no estaban en el tutorial original:

  • Reloj en tiempo real: agrega un módulo RTC DS1307 o DS3231 (que también es I2C) y muestra la hora y fecha actualizándose en la pantalla. Como ambos comparten el bus, solo tienes que seguir usando SDA y SCL.
  • Estación de temperatura: conecta un sensor DHT22 o un DS18B20 y muestra temperatura y humedad en vivo en el LCD. Ideal para un termómetro de pieza o invernadero.
  • Varios dispositivos en el mismo bus: como I2C permite múltiples direcciones sobre las mismas 2 líneas, puedes encadenar el LCD junto con sensores, expansores y un RTC sin agregar más cables de datos. Solo asegúrate de que cada dispositivo tenga una dirección distinta.
  • Mensajes desde el PC: usa Serial.read() para recibir texto desde el computador por USB y mostrarlo en la pantalla con lcd.print(), convirtiendo tu Arduino en un display de mensajes.

Personalización para Chile

En Chile consigues todo lo necesario para este proyecto en MechatronicStore, con stock local y despacho a todo el país:

  • Módulo I2C para LCD (SKU D-108), $2.490 CLP. Es exactamente la placa expansora PCF8574 de este tutorial.
  • LCD 1602A 16x2 (wc 692), $3.200 CLP. La pantalla de 16 caracteres por 2 líneas donde sueldas el módulo.
  • Arduino Uno R3 (SKU X4-8), $9.990 CLP. La placa donde corre el código; cualquier Uno, Nano o Mega sirve.
  • Cables macho hembra 30cm (SKU C-418), $1.990 CLP. Para conectar los 4 pines del módulo a los headers del Arduino.

Si prefieres saltarte la soldadura, en el catálogo también existe la Pantalla LCD1602 con I2C incorporado, que ya viene con el módulo soldado de fábrica: la enchufas directo y te ahorras el cautín.

Recursos

Versión chilena con componentes en stock local en MechatronicStore.