Tutorial completo Arduino LCD 16×2: Conexión, programación y visualización de datos

En este tutorial de Arduino aprenderemos cómo conectar y utilizar una pantalla LCD (Liquid Crystal Display) con Arduino. Las pantallas LCD como estas son muy populares y ampliamente utilizadas en muchos proyectos electrónicos, ya que son excelentes para mostrar información simple, como datos de sensores, siendo muy asequibles.

Ya las he usado en varios de mis proyectos de Arduino, y puedes consultarlos aquí:

• Proyecto Sistema de Seguridad y Alarma con Arduino
• Máquina Expendedora DIY – Proyecto Mecatrónico basado en Arduino
• Proyecto Medidor de Distancia y Nivel Digital con Arduino

Puedes ver el siguiente vídeo o leer el tutorial escrito a continuación. Incluye todo lo que necesitas saber sobre el uso de una pantalla LCD de caracteres con Arduino, como el pinout, diagrama de conexiones y varios códigos de ejemplo.

¿Qué es una pantalla LCD de caracteres?

Una pantalla LCD de caracteres es un tipo único de display que solo puede mostrar caracteres ASCII individuales con tamaño fijo. Usando estos caracteres individuales podemos formar texto.

Si observamos de cerca la pantalla, notaremos que hay pequeñas áreas rectangulares compuestas por una cuadrícula de 5×8 píxeles. Cada píxel puede encenderse individualmente, permitiéndonos generar caracteres dentro de cada cuadrícula.

El número de áreas rectangulares define el tamaño de la LCD. La más popular es la LCD 16×2, que tiene dos filas con 16 áreas rectangulares o caracteres. Por supuesto, existen otros tamaños como 16×1, 16×4, 20×4, etc., pero todas funcionan con el mismo principio. Además, estas LCD pueden tener diferentes colores de fondo y texto.

Pinout de la LCD 16×2

Tiene 16 pines y el primero de izquierda a derecha es el pin Ground (GND). El segundo pin es el VCC, que conectamos al pin de 5 voltios de la placa Arduino. El siguiente es el pin Vo, al que podemos conectar un potenciómetro para controlar el contraste de la pantalla.

Luego viene el pin RS (Register Select), usado para seleccionar si enviaremos comandos o datos a la LCD. Por ejemplo, si el pin RS está en estado bajo (0 voltios), enviamos comandos como: posicionar el cursor, limpiar la pantalla, apagar el display, etc. Cuando el pin RS está en estado alto (5 voltios), enviamos datos o caracteres a la LCD.

El siguiente es el pin R/W, que selecciona el modo de lectura o escritura. El modo escritura es obvio: se usa para enviar comandos y datos. El modo lectura lo usa la propia LCD al ejecutar el programa, no es necesario profundizar en este tutorial.

Luego está el pin E (Enable), que habilita la escritura en los registros, o los siguientes 8 pines de datos D0 a D7. A través de estos pines enviamos los 8 bits de datos al escribir en los registros. Por ejemplo, para mostrar la letra 'A' mayúscula, enviamos 0100 0001 según la tabla ASCII. Los dos últimos pines A y K (ánodo y cátodo) son para la retroiluminación LED.

En definitiva, no tenemos que preocuparnos mucho por el funcionamiento interno, ya que la librería LiquidCrystal se encarga de casi todo. En la web oficial de Arduino puedes consultar las funciones de la librería. Podemos usarla en modo 4 u 8 bits; en este tutorial usaremos modo 4 bits (solo 4 de los 8 pines de datos).

Cómo conectar Arduino a LCD – Diagrama de conexiones

Así es como debemos conectar la pantalla LCD 16×2 a una placa Arduino.

Usaremos solo 6 pines digitales de Arduino. Los registros de la LCD D4 a D7 se conectan a los pines digitales 4 a 7 de Arduino. El pin Enable al pin 2 y el pin RS al pin 1. El pin R/W a GND y el pin Vo al pin central del potenciómetro.

Puedes conseguir los componentes en los siguientes enlaces:

• LCD Caracteres 16×2……………………..
• Potenciómetro …………………………….
• Placa Arduino ……………………………
• Protoboard y cables jumpers ………

Ajuste del contraste de la LCD

Podemos ajustar el contraste variando el voltaje en el pin Vo. Usamos un potenciómetro para afinar fácilmente el contraste, ajustando el voltaje de entrada de 0 a 5V.

¿Puedo usar la LCD sin potenciómetro?

Sí, si no tienes potenciómetro, puedes ajustar el contraste con un divisor de tensión hecho con dos resistencias. Necesitas establecer un voltaje entre 0 y 5V para buen contraste. En mi caso, unos 1V funcionaron bien; usé resistencias de 1K y 220 ohmios.

También puedes ajustar el contraste suministrando una señal PWM desde Arduino al pin Vo de la LCD. Conecta el pin Vo a cualquier pin PWM de Arduino y en el setup() usa:

analogWrite(11, 100); // Genera señal PWM en pin D11, valor 100 (de 255)

Esto genera una señal PWM en el pin D11 con valor 100/255, equivaliendo a unos 2V en el pin Vo de la LCD.

Código Arduino para LCD

Aquí tienes un código simple que explica el funcionamiento de la librería LiquidCrystal. Es el código del primer ejemplo del vídeo:

/* 
 * Tutorial Arduino LCD 
 * Creado por Dejan Nedelkovski, 
 * www.HowToMechatronics.com 
 */
#include <LiquidCrystal.h> // Incluye la librería LiquidCrystal
LiquidCrystal lcd(1, 2, 4, 5, 6, 7); // Crea objeto LCD. Parámetros: (rs, enable, d4, d5, d6, d7)

void setup() {
  lcd.begin(16, 2); // Inicializa la interfaz y especifica dimensiones (ancho, alto)
}

void loop() {
  lcd.print("Arduino"); // Imprime "Arduino" en la LCD
  delay(3000); // Espera 3 segundos
  lcd.setCursor(2, 1); // Posiciona cursor (columna 2, fila 1)
  lcd.print("LCD Tutorial");
  delay(3000);
  lcd.clear(); // Limpia la pantalla
  lcd.blink(); // Muestra cursor parpadeante
  delay(4000);
  lcd.setCursor(7, 1);
  delay(3000);
  lcd.noBlink(); // Apaga cursor parpadeante
  lcd.cursor(); // Muestra subrayado en posición del siguiente carácter
  delay(4000);
  lcd.noCursor(); // Oculta cursor
  lcd.clear(); // Limpia pantalla
}

Explicación del código:

Primero incluimos la librería LiquidCrystal: Sketch > Include Library > Liquid Crystal. Luego creamos un objeto LC con los pines digitales correspondientes a los pines de la LCD: (RS, Enable, D4, D5, D6, D7). En setup() inicializamos la interfaz y especificamos las dimensiones con begin().

En loop() escribimos el programa principal. Con print() escribimos en la LCD.

lcd.print("Arduino"); // Imprime "Arduino" en la LCD

La función setCursor() establece la ubicación donde se mostrará el texto subsiguiente.

lcd.setCursor(2, 1); // Establece la ubicación (columna 2, fila 1)

Las funciones blink() y noBlink() controlan el cursor parpadeante. cursor() y noCursor() controlan el cursor de subrayado. clear() limpia la pantalla.

lcd.clear(); // Limpia la pantalla LCD

Ejemplo de texto desplazable en LCD 16×2 con Arduino

Si el texto supera 16 caracteres, podemos desplazarlo usando scrollDisplayLeft() o scrollDisplayRight() de la librería LiquidCrystal.

Código de ejemplo:

#include <LiquidCrystal.h>
LiquidCrystal lcd(1, 2, 4, 5, 6, 7); // (rs, enable, d4, d5, d6, d7)

void setup() {
  lcd.begin(16, 2);
  lcd.print("Scrolling Text Example");
}

void loop() {
  lcd.scrollDisplayLeft();
  delay(500);
}

Podemos elegir dirección con scrollDisplayLeft() o scrollDisplayRight(). La velocidad se controla con delay().

Para mayor control, podemos implementar el desplazamiento manual con un bucle for:

#include <LiquidCrystal.h>
LiquidCrystal lcd(1, 2, 4, 5, 6, 7);

void setup() {
  lcd.begin(16, 2);
}

void loop() {
  // Desplazar texto a la derecha
  for (int i = 0; i <= 13; i++) {
    lcd.setCursor(i, 0);
    lcd.print("LCD");
    delay(500);
    lcd.clear();
  }
  // Desplazar texto a la izquierda
  for (int i = 12; i >= 1; i--) {
    lcd.setCursor(i, 0);
    lcd.print("LCD");
    delay(500);
    lcd.clear();
  }
}

Cómo generar y mostrar caracteres personalizados en la LCD

Además de los caracteres ASCII, con la librería LiquidCrystal podemos crear y mostrar caracteres personalizados.

Definimos la apariencia de cada carácter con un array de 8 bytes. Ejemplo:

#include <LiquidCrystal.h>

byte heart[8] = {
  B00000, B01010, B11111, B11111,
  B01110, B00100, B00000, B00000
};

byte smile[8] = {
  B00000, B00000, B01010, B00000,
  B10001, B01110, B00000, B00000
};

byte lock[8] = {
  B01110, B10001, B10001, B11111,
  B11011, B11011, B11111, B00000
};

byte character[8] = {
  B11111, B10101, B11111, B01010,
  B01110, B11111, B01110, B01110
};

LiquidCrystal lcd(1, 2, 4, 5, 6, 7);

void setup() {
  lcd.begin(16, 2);
  lcd.createChar(0, heart);
  lcd.createChar(1, smile);
  lcd.createChar(2, lock);
  lcd.createChar(3, character);
  lcd.clear();
  lcd.print("Custom Character");
}

void loop() {
  lcd.setCursor(1, 1);
  lcd.write(byte(0)); // Corazón
  lcd.setCursor(5, 1);
  lcd.write(byte(1)); // Sonrisa
  lcd.setCursor(9, 1);
  lcd.write(byte(2)); // Candado
  lcd.setCursor(13, 1);
  lcd.write(byte(3)); // Personaje
}

Vemos cómo se define la apariencia cambiando 0s por 1s en la cuadrícula 5×8.

En setup() creamos el carácter personalizado con createChar().

lcd.createChar(0, heart); // Crea carácter personalizado

El primer parámetro (0-7) reserva uno de los 8 caracteres personalizados soportados. El segundo es el nombre del array de bytes.

Escribimos el carácter en el display con write() usando su número:

lcd.write(byte(0)); // Muestra carácter personalizado 0 (corazón)

Ver también: Tutorial Pantalla Táctil Arduino | TFT LCD

Conclusión

Hemos cubierto prácticamente todo lo necesario para usar una LCD con Arduino. Estos displays de caracteres son muy útiles para mostrar información en muchos proyectos electrónicos. En los ejemplos usé una LCD 16×2, pero el mismo principio aplica a cualquier otro tamaño.

Espero que hayas disfrutado este tutorial y aprendido algo nuevo. Siéntete libre de preguntar en los comentarios y no olvides revisar mi colección completa de 30+ proyectos con Arduino.