Pantalla LCD 16×2 con Arduino y ESP32: Conexión I2C y Paralelo

En este tutorial aprenderás a conectar tu microcontrolador con una pantalla LCD y a hacer tu primer sketch para mostrar lo que quieras en la pantalla LCD.

Utilizamos diferentes tipos de pantallas:

• Pantalla LCD sin conexión I2C
• Pantalla LCD con conexión I2C

Como bonus te muestro cómo puedes crear caracteres personalizados como un corazón en la pantalla de forma súper rápida y sencilla.

La mayoría de las veces usamos el trazador serial del IDE de Arduino para visualizar nuestras soluciones o la salida de un boceto. Es genial y le ahorra mucho tiempo al crear prototipos. Pero hay un momento en que su sistema se activará. Si, por ejemplo, solo está enviando datos del sensor a una base de datos en una Raspberry Pi, puede ver la salida desde su PC de forma remota conectándose a la base de datos. Pero hay casos de uso como una estación meteorológica interior, en los que desea ver la salida como la temperatura actual directamente y no cuando está en su PC.

Que las pantallas son el camino a seguir. Hay diferentes tipos de pantallas, como la pantalla LED de 7 segmentos, la pantalla de 7 segmentos de 4 dígitos, la pantalla de matriz de puntos de 8 × 8, la pantalla OLED o la versión más simple y la pantalla de cristal líquido (LCD) más barata.

La mayoría de las pantallas LCD tienen 2 líneas con 16 caracteres por línea o 4 líneas con 20 caracteres por línea. Hay una pantalla LCD con y sin módulo I2C. Sugiero encarecidamente módulos con I2C porque la conexión a la placa es muy simple y solo se usan 2 pines en lugar de 6. Pero vamos a cubrir la pantalla LCD con y sin módulo I2C en este artículo.

Especificaciones de la pantalla LCD

La pantalla LCD tiene un voltaje de funcionamiento de 4,7 V a 5,3 V con un consumo de corriente de 1 mA sin luz de fondo y 120 mA con luz de fondo completa. Hay versiones con retroiluminación verde y azul. Cada carácter en la pantalla está construido por un cuadro de 5 × 8 píxeles y, por lo tanto, es capaz de mostrar caracteres generados personalizados. Debido a que cada carácter está construido por (5 × 8 = 40) 40 píxeles, una pantalla LCD de 16 × 2 tendrá 16x2x40 = 1280 píxeles en total. El módulo LCD puede funcionar en modo de 8 y 4 bits. La diferencia entre el modo de 4 y 8 bits es la siguiente:

• En el modo de 8 bits, solo se necesita una señal de pulso para mostrar un carácter en la pantalla LCD en lugar de dos señales de pulso.
• El modo de 4 bits utiliza solo cuatro pines de datos en comparación con los 8 pines de datos en el modo de 8 bits.
• Dado que se requieren dos señales de pulso (encender) para mostrar un solo carácter, la latencia del modo de 4 bits es mayor en comparación con el modo de 8 bits.

Pantalla LCD sin conexión I2C

Si usamos la versión LCD sin conexión I2C, necesitamos agregar el potenciómetro manualmente para controlar el contraste de la pantalla. La siguiente imagen muestra la distribución de pines de la pantalla LCD.

También agregué una tabla sobre cómo conectar la pantalla LCD con el Arduino Uno y el NodeMCU con una descripción del pin LCD. Para que le resulte lo más fácil posible conectar su microcontrolador a la pantalla, encontrará la imagen de conexión fritzing correspondiente para Arduino Uno y NodeMCU en este capítulo.

Conexión de la pantalla LCD al Arduino Uno sin I2C

La siguiente imagen muestra las conexiones entre la pantalla LCD y el Arduino Uno.

Conexión de la pantalla LCD al ESP8266 NodeMCU sin I2C

La siguiente imagen muestra las conexiones entre la pantalla LCD y el ESP8266 NodeMCU.

Por supuesto, queremos probar la conexión entre el microcontrolador y la pantalla LCD. Por lo tanto, encontrará un boceto de ejemplo en el IDE de Arduino. La siguiente sección muestra el código del boceto y una imagen del ejemplo en ejecución, más o menos porque es difícil hacer una imagen de la pantalla ;-). El ejemplo muestra «¡hola, mundo!» en la primera línea de la pantalla y cuenta cada segundo en la segunda línea. Estamos usando la conexión que describimos anteriormente para este ejemplo.

// include the library code:
#include "LiquidCrystal_I2C.h"

// initialize the library by associating any needed LCD interface pin
// with the arduino pin number it is connected to
const int RS = D2, EN = D3, d4 = D5, d5 = D6, d6 = D7, d7 = D8;

// if you use the NodeMCU 12E the suggested pins are
// const int RS = 4, EN = 0, d4 = 12, d5 = 13, d6 = 15, d7 = 3;

LiquidCrystal lcd(RS, EN, d4, d5, d6, d7);

void setup() {
// set up the LCD's number of columns and rows:
lcd.begin(16, 2);
// Print a message to the LCD.
lcd.print("hello, world!");
}

void loop() {
// set the cursor to column 0, line 1
// (note: line 1 is the second row, since counting begins with 0):
lcd.setCursor(0, 1);
// print the number of seconds since reset:
lcd.print(millis() / 1000);
}

Parece muy complicado imprimir datos en la pantalla LCD. Pero no se preocupe, porque en la mayoría de los casos, si comienza a ensuciarse, hay una biblioteca para correr la voz por nosotros. Este también es el caso de la pantalla LCD sin una conexión I2C.

Por lo tanto, el siguiente paso es instalar la biblioteca “LiquidCrystal”. Aquí encontrará un artículo sobre cómo instalar una biblioteca externa a través del IDE de Arduino. Una vez instalada la biblioteca, puede incluirla a través de: #include .

Pantalla LCD con conexión I2C

El uso de una mochila de adaptación I2C basada en el expansor de 8 bits PCF8574 / PCF8574T simplifica el conexionado al reducir de 16 pines (o 6 en modo paralelo de 4 bits) a solo 4 conductores: alimentación (VCC), masa (GND) y el bus de dos hilos (SDA y SCL). Para establecer comunicación serie con el controlador HD44780, es indispensable conocer la dirección I2C hexadecimal del integrado y respetar las tolerancias de tensión.

Conexión I2C: Arduino Uno, ESP8266 y ESP32

La siguiente tabla resume el esquema de conexionado físico estandarizado para enlazar la pantalla LCD 16×2 o 20×4 mediante I2C con las plataformas de desarrollo más habituales:

Detección de la dirección I2C con escáner de bus

Las mochilas PCF8574 suelen emplear dos direcciones base según el fabricante del circuito integrado:

• 0x27: chip estándar PCF8574T (NXP / Texas Instruments).
• 0x3F: variante PCF8574AT.

Si la librería no detecta la pantalla con 0x27, carga este sketch escáner en tu placa (válido para Arduino Uno, Nano, ESP8266 y ESP32) para identificar en la consola serie a 115200 baudios la dirección exacta de respuesta ACK:

#include <Wire.h>

void setup() {
  Wire.begin();
  Serial.begin(115200);
  while (!Serial);
  Serial.println("\n--- Escaner de Bus I2C (ElOsciloscopio) ---");
}

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

  Serial.println("Escaneando bus I2C...");
  for (address = 1; address < 127; address++) {
    Wire.beginTransmission(address);
    error = Wire.endTransmission();

    if (error == 0) {
      Serial.print("Dispositivo encontrado en direccion 0x");
      if (address < 16) Serial.print("0");
      Serial.print(address, HEX);
      Serial.println(" !");
      nDevices++;
    } else if (error == 4) {
      Serial.print("Error desconocido en direccion 0x");
      if (address < 16) Serial.print("0");
      Serial.println(address, HEX);
    }
  }

  if (nDevices == 0) {
    Serial.println("No se encontraron dispositivos I2C. Verifica cables SDA/SCL y alimentacion.\n");
  } else {
    Serial.println("Escaneo completado.\n");
  }
  delay(5000);
}

Para usar la pantalla LCD I2C, necesitamos instalar la biblioteca requerida “LiquidCrystal_I2C” de Frank de Brabander. Aquí encontrará un artículo sobre cómo instalar una biblioteca externa a través del IDE de Arduino. Una vez instalada la biblioteca, puede incluirla a través de: #include LiquidCrystal_I2C.h>.

Este breve ejemplo le muestra cómo utilizar la biblioteca para controlar la pantalla LCD.

#include "Wire.h"
#include "LiquidCrystal_I2C.h"

// create an LCD object (Hex address, # characters, # rows)
// my LCD display in on Hex address 27 and is a 20x4 version
LiquidCrystal_I2C lcd(0x27, 20, 4); 

void setup()
{
  lcd.init();

  lcd.backlight();
  lcd.setCursor(1, 0);
  lcd.print("This is");
  lcd.setCursor(1, 1);
  lcd.print("ElOsciloscopio");
}

void loop(){}

Funciones de la biblioteca LiquidCrystal y LiquidCrystal_I2C

La biblioteca LiquidCrystal tiene 20 funciones integradas que resultan útiles cuando desea trabajar con la pantalla LCD. En la siguiente parte de este artículo, repasaremos todas las funciones con una descripción junto con un boceto de muestra y un video corto para que veas lo que hace la función.

Ejemplo de pantalla parpadeante, de cursor y de desplazamiento

Para mostrarle algunos ejemplos básicos de las bibliotecas LiquidCrystal y LiquidCrystal_I2C, puede copiar el siguiente ejemplo que muestra tres funciones diferentes de la biblioteca:

1. Muestre u oculte un campo de carácter intermitente para mostrarle al usuario su aplicación que, por ejemplo, se necesita una entrada o se está cargando una aplicación.
2. Muestre u oculte un cursor útil («_») al crear un menú como una barra de navegación de izquierda a derecha o de arriba a abajo, dependiendo de una barra de menú horizontal o vertical. Si está interesado en crear un menú básico con el microcontrolador ESP o Arduino en combinación con la pantalla, encontrará un tutorial aquí.
3. Mueva todos los caracteres a la derecha para una visualización de desplazamiento.

El siguiente código le muestra el programa Arduino para usar las tres funciones de la pantalla LCD en la biblioteca divididas en tres funciones separadas. El video después del programa también muestra las funciones en acción.

#include "Wire.h"
#include "LiquidCrystal_I2C.h"

// set the LCD address to 0x27 for a 16 chars and 2 line display
LiquidCrystal_I2C lcd(0x27, 20, 4); 

void setup()
{
  lcd.init();
  lcd.backlight();
  lcd.clear();
}

void loop(){
  show_blink();
  show_cursor();
  scroll_display();
  }

void show_blink(){
  lcd.clear();
  lcd.setCursor(0,2);
  lcd.print("Blink is on");
  lcd.setCursor(0,0);
  lcd.blink();
  delay(5000);
  lcd.setCursor(0,2);
  lcd.print("Blink is off");
  lcd.setCursor(0,0);
  lcd.noBlink();
  delay(5000);
}

void show_cursor(){
  lcd.clear();
  lcd.setCursor(0,2);
  lcd.print("Cursor is on");
  lcd.setCursor(0,0);
  lcd.cursor();
  delay(5000);
  lcd.setCursor(0,2);
  lcd.print("Cursor is off");
  lcd.setCursor(0,0);
  lcd.noCursor();
  delay(5000);
}

void scroll_display(){
  lcd.clear();
  lcd.setCursor(0,2);
  lcd.print("Scroll display");
  lcd.scrollDisplayRight();
  delay(1000);
  lcd.scrollDisplayRight();
  delay(1000);
  lcd.scrollDisplayRight();
  delay(1000);
  lcd.scrollDisplayRight();
  delay(3000);
}

¿Cómo visualizo los caracteres generados personalizados?

Crear personajes personalizados es muy fácil si usa las bibliotecas mencionadas anteriormente. Tanto LiquidCrystal como la biblioteca LiquidCrystal_I2C tienen la función “lcd.createChar ()” para crear un carácter personalizado a partir de los 5 × 8 píxeles de un personaje. Para diseñar sus propios personajes, debe crear una matriz binaria de su personaje personalizado a partir de un generador de caracteres LCD o mapearlo usted mismo. Este código crea un hombre que se retuerce.

#include "Wire.h"
#include "LiquidCrystal_I2C.h"

// Set the LCD address to 0x27 in PCF8574 by NXP and Set to 0x3F in PCF8574A by Ti
LiquidCrystal_I2C lcd(0x27, 20, 4); 

byte customChar1[] = {
  B01110,
  B01110,
  B00100,
  B11111,
  B00100,
  B01110,
  B01010,
  B01010
};

byte customChar2[] = {
  B01110,
  B01110,
  B10101,
  B01110,
  B00100,
  B00100,
  B01010,
  B10001
};

void setup() {
  lcd.init();
  lcd.backlight();
}

void loop() {
  lcd.createChar(0, customChar1);
  lcd.home();
  lcd.write(0);
  delay(1000);
  lcd.createChar(0, customChar2);
  lcd.home();
  lcd.write(0);
  delay(1000);
  }

Puede utilizar la siguiente herramienta para crear caracteres generados personalizados de forma fácil y rápida: http://omerk.github.io/lcdchargen/

Códigos de control importantes para la pantalla LCD

En la sección de asignación de pines de la pantalla LCD sin I2C, vimos que si configuramos el pin RS en cómo, podemos enviar comandos a la pantalla LCD. Estos comandos se envían a través de los pines de datos y se representan en la siguiente tabla como código HEX.

Conclusión

Espero que hayas aprendido mucho de este artículo. No dude en probar los bocetos de muestra con su microcontrolador. ¿Tiene preguntas sobre este artículo? Utilice la sección de comentarios a continuación y responderé su pregunta.

Diagnóstico y decodificación del bus I2C en la pantalla LCD con osciloscopio

Cuando un display LCD 16×2 o 20×4 I2C no muestra caracteres o la comunicación se bloquea periódicamente, un multímetro digital resulta insuficiente porque solo mide el valor medio de tensión continua en las líneas. La inspección con un osciloscopio digital con decodificación de protocolos serie por hardware permite diagnosticar en menos de dos minutos el origen exacto del fallo técnico:

• Configuración de canales y disparo (Trigger): conecta la sonda del Canal 1 a la señal SCL (Reloj) y la sonda del Canal 2 a la señal SDA (Datos). Ambas sondas deben configurarse en atenuación 10X para no cargar la línea capacitivamente (la capacidad de una sonda 1X de ~100 pF deforma los flancos del bus I2C). Ajusta el acoplamiento en DC, la escala vertical en 1 V/div o 2 V/div y el disparo en flanco de bajada de SCL o directamente en condición de Trigger I2C: Start Condition.
• Comprobación del tiempo de subida (t_r) y resistencias pull-up: al tratarse de un bus de drenador abierto (open-drain), el nivel alto se genera exclusivamente por la corriente suministrada por las resistencias pull-up. Si las resistencias son de valor excesivo (por ejemplo 10 kΩ o cables de conexión largos que añaden más de 200 pF de capacidad parásita), el flanco de subida adopta una curva exponencial lenta que impide alcanzar la tensión mínima de nivel alto V_IH (3,5 V en PCF8574 alimentado a 5 V) antes del siguiente pulso de reloj. Con el osciloscopio se verifica que el tiempo de subida se mantenga inferior a 1.000 ns en modo estándar (100 kHz).
• Verificación del bit de reconocimiento (ACK / NACK): en el protocolo I2C, cada byte transmitido consta de 8 bits de datos seguidos por un noveno ciclo de reloj donde el emisor libera la línea SDA. Durante este noveno ciclo, el integrado PCF8574 debe forzar activamente SDA a nivel bajo (ACK = 0 V) para confirmar la recepción. Si en la pantalla del osciloscopio observas que SDA permanece a 5 V durante el noveno pulso de SCL (NACK), el chip no está reconociendo la dirección enviada (error entre 0x27 y 0x3F), el integrado carece de alimentación VCC, o el pin de direccionamiento A0-A2 está en flotación.
• Decodificación de tramas de inicialización HD44780: activando la función de decodificación en pantalla (menú Decode > I2C), el osciloscopio traduce los niveles analógicos a bytes legibles en hexadecimal. Podrás comprobar cómo el microcontrolador envía la secuencia de configuración del bus de 4 bits (nibbles altos y bajos alternados con el pin de habilitación E): comandos 0x33, 0x32, modo función 0x28 (2 líneas, caracteres 5×8) y control de display 0x0C.

A continuación se comparan cuatro osciloscopios recomendados para análisis de buses digitales serie (I2C, SPI y UART) en bancos de desarrollo con Arduino y ESP32:

Especificaciones técnicas contrastadas con las hojas de datos oficiales de Rigol Technologies, Siglent Technologies y Hantek Instruments. Enlaces de consulta técnica bajo directrices de afiliación transparente.

RIGOL DS1054Z - Osciloscopio Digital de Banco (50 MHz, 4 Canales, 1 GSa/s, 24 Mpts)

VER MEJOR PRECIO

Preguntas frecuentes cuando la pantalla LCD 16×2 no muestra texto