Cómo usar una pantalla LCD de 16×2 caracteres con Arduino

Este tutorial incluye todo lo que necesitas saber sobre cómo controlar un LCD de caracteres con Arduino. He incluido un diagrama de conexiones y muchos ejemplos de código. Estas pantallas son ideales para mostrar datos de sensores o texto y además son bastante económicas.

La primera parte de este artículo cubre los conceptos básicos para mostrar texto y números. En la segunda mitad, profundizaré en cómo mostrar caracteres personalizados y cómo puedes usar las otras funciones de la LiquidCrystal biblioteca de Arduino.

Como verás, necesitas bastantes conexiones para controlar estas pantallas. Por eso me gusta usarlas con un módulo I2C interface montado en la parte trasera. Con este módulo I2C, solo necesitas dos conexiones para controlar el LCD. Consulta el tutorial a continuación si también quieres usar un módulo I2C:

Suministros

Componentes de hardware

	16×2 character LCD	× 1	Amazon
	20×4 character LCD	× 1	Amazon
	Arduino Uno Rev3	× 1	Amazon
	Breadboard	× 1	Amazon
	Jumper wires	~ 10	Amazon
	10 kΩ potentiometer	× 1	Amazon
	USB cable type A/B	× 1	Amazon

Software

Arduino IDE

Makerguides is a participant in affiliate advertising programs designed to provide a means for sites to earn advertising fees by linking to Amazon, AliExpress, Elecrow, and other sites. As an Affiliate we may earn from qualifying purchases.

Descripción general del hardware

Estos LCD están disponibles en muchos tamaños diferentes (16×2 1602, 20×4 2004, 16×1, etc.), pero todos usan el mismo HD44780 chip controlador LCD con interfaz paralela de Hitachi. Esto significa que puedes intercambiarlos fácilmente. Solo necesitarás cambiar las especificaciones de tamaño en tu código Arduino.

Especificaciones del LCD 16×2

Voltaje de funcionamiento	5 V
Controlador	Controlador LCD Hitachi HD44780
Resolución de pantalla	2 líneas x 16 caracteres
Resolución de caracteres	5 x 8 píxeles
Dimensiones del módulo	80 x 36 x 12 mm
Dimensiones del área visible	64.5 x 16.4 mm
Precio	Check price

Para más información, puedes consultar las hojas de datos a continuación. Las hojas de datos de 16×2 y 20×4 incluyen las dimensiones del LCD y en la hoja de datos del HD44780 encontrarás más información sobre el controlador LCD de Hitachi.

Pinout del LCD 16×2

El LCD tiene 16 pines de conexión, numerados del 1 al 16 de izquierda a derecha.

El pinout de un LCD estándar HD44780 se muestra en la tabla a continuación:

Número de pin	Símbolo	Conexión	Función
1	VSS	GND Arduino	Masa de señal
2	VDD	5 V Arduino	Alimentación lógica para el LCD
3	V0	Potenciómetro de 10 kΩ	Ajuste de contraste
4	RS	Pin 2 Arduino	Señal de selección de registro
5	R/W	GND Arduino	Señal de selección lectura/escritura
6	E	Pin 3 Arduino	Señal de habilitación de operación
7 – 14	D0 – D7	–	Líneas del bus de datos usadas para modo de 8 bits
11 – 14	D4 – D7	Pin 4 – 7 Arduino	Líneas del bus de datos usadas para modo de 4 bits
15	A (LED+)	5 V Arduino	Ánodo para la retroiluminación del LCD
16	K (LED-)	GND Arduino	Cátodo para la retroiluminación del LCD

Probando el LCD y ajustando el contraste

Para probar la pantalla, necesitarás hacer las conexiones como se muestra en la figura a continuación.

La mayoría de los LCD tienen una resistencia en serie incorporada para la retroiluminación LED. Deberías encontrarla en la parte trasera del LCD conectada al pin 15 (Ánodo). Si tu pantalla no incluye una resistencia, deberás añadir una entre 5 V y el pin 15. Es seguro usar una resistencia de 220Ω, pero este valor podría hacer que la pantalla se vea un poco tenue. Puedes consultar la hoja de datos para conocer la corriente máxima de la retroiluminación y usarla para seleccionar un valor de resistencia adecuado.

Después de conectar el LCD, necesitarás ajustar el contraste de la pantalla. Esto se hace girando el potenciómetro de 10 kΩ en sentido horario o antihorario.

Conecta el Arduino por USB para alimentar el LCD. Deberías ver que la retroiluminación se enciende. Ahora gira el potenciómetro hasta que aparezca una fila (LCD 16×2) o dos filas (LCD 20×4) de rectángulos.

Puedes ajustar el contraste más adelante si es necesario.

Cómo conectar el LCD al Arduino UNO

Para controlar el LCD y mostrar caracteres, necesitarás añadir algunas conexiones extra. Consulta el diagrama de conexiones a continuación y la tabla de pinout del inicio de este artículo.

Usaremos el LCD en modo de 4 bits, esto significa que no necesitas conectar nada a D0-D3. El pin R/W está conectado a tierra, esto lo pone en LOW y configura el LCD en modo ESCRITURA.

Una vez que hayas conectado todo, podemos empezar a programar el LCD.

Código de ejemplo Arduino para LCD de caracteres

Para controlar el LCD usaremos la LiquidCrystal biblioteca. Esta biblioteca debería venir preinstalada con el IDE de Arduino. Puedes encontrarla yendo a Sketch > Include Library > LiquidCrystal.

La biblioteca LiquidCrystal incluye muchas funciones integradas y hace que controlar LCDs de caracteres sea muy fácil.

El código de ejemplo a continuación te muestra cómo mostrar un mensaje en el LCD. Luego te explicaré cómo funciona el código y cómo usar las otras funciones de la biblioteca LiquidCrystal.

/* Basic Arduino example code for displaying text 
  on 16x2, 20x4 etc. character LCDs. 
  www.www.makerguides.com */

// Include the library:
#include "LiquidCrystal.h"

// Create an LCD object. Parameters: (RS, E, D4, D5, D6, D7):
LiquidCrystal lcd = LiquidCrystal(2, 3, 4, 5, 6, 7);

void setup() {
  // Specify the LCD's number of columns and rows. Change to (20, 4) for a 20x4 LCD:
  lcd.begin(16, 2);
}

void loop() {
  // Set the cursor on the third column and the first row, counting starts at 0:
  lcd.setCursor(2, 0);
  // Print the string 'Hello World!':
  lcd.print("Hello World!");
  // Set the cursor on the third column and the second row:
  lcd.setCursor(2, 1);
  // Print the string 'LCD tutorial':
  lcd.print("LCD tutorial");
}

Deberías ver la siguiente salida en el LCD:

Cómo funciona el código

Después de incluir la biblioteca, el siguiente paso es crear una nueva instancia de la clase LiquidCrystal. Esto se hace con la función LiquidCrystal(rs, enable, d4, d5, d6, d7). Como parámetros usamos los pines de Arduino a los que conectamos la pantalla. Nota que hemos llamado al display ‘lcd’. Puedes darle otro nombre si quieres, como ‘menu_display’. Tendrás que cambiar ‘lcd’ por el nuevo nombre en el resto del sketch.

// Include the library:
#include "LiquidCrystal.h"

// Create an LCD object. Parameters: (RS, E, D4, D5, D6, D7):
LiquidCrystal lcd = LiquidCrystal(2, 3, 4, 5, 6, 7);

En la setup() el LCD se inicia con la función begin(cols,rows). Si usas un LCD 20×4 cambia esta línea a lcd.begin(20,4);

void setup() {
  // Specify the LCD's number of columns and rows. Change to (20, 4) for a 20x4 LCD:
  lcd.begin(16, 2);
}

En la loop() el cursor se posiciona en la tercera columna y primera fila del LCD con lcd.setCursor(2,0). Ten en cuenta que la cuenta empieza en 0, y el primer argumento especifica la columna. Si no especificas la posición del cursor, el texto se imprimirá en la posición inicial por defecto (0,0) si la pantalla está vacía, o detrás del último carácter impreso.

Luego, la cadena ‘Hello World!’ se imprime con lcd.print("Hello World!"). Recuerda que debes poner comillas (” “) alrededor del texto. Cuando quieras imprimir números o variables, no necesitas comillas.

void loop() {
  // Set the cursor on the third column and the first row, counting starts at 0:
  lcd.setCursor(2, 0);
  // Print the string 'Hello World!':
  lcd.print("Hello World!");
  // Set the cursor on the third column and the second row:
  lcd.setCursor(2, 1);
  // Print the string 'LCD tutorial':
  lcd.print("LCD tutorial");
}

Si quieres ver un ejemplo para mostrar (cambiar) variables en el LCD, consulta mi tutorial sobre How to use a HC-SR04 Ultrasonic Distance Sensor with Arduino.

En el ejemplo usé un display LCD I2C pero el código después del setup es el mismo para ambos.

Otras funciones de la biblioteca LiquidCrystal

La biblioteca LiquidCrystal de Arduino tiene muchas otras funciones integradas que pueden serte útiles. A continuación tienes un resumen con explicación y algunos fragmentos de código.

clear()

Limpia la pantalla LCD y posiciona el cursor en la esquina superior izquierda (primera fila y primera columna) de la pantalla. Puedes usar esta función para mostrar diferentes palabras en un bucle.

#include "LiquidCrystal.h"

// Creates an LCD object. Parameters: (RS, E, D4, D5, D6, D7)
LiquidCrystal lcd = LiquidCrystal(2, 3, 4, 5, 6, 7);

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

void loop() {
  lcd.clear();
  lcd.print("Monday");
  delay(2000);
  lcd.clear();
  lcd.print("13:45");
  delay(2000);
}

home()

Posiciona el cursor en la esquina superior izquierda del LCD. Usa clear() si también quieres limpiar la pantalla.

cursor()

Muestra el cursor del LCD: un guion bajo (línea) en la posición del siguiente carácter a imprimir.

noCursor()

Oculta el cursor del LCD. El siguiente ejemplo crea un cursor parpadeante al final de “cursor()”.

#include "LiquidCrystal.h"

// Creates an LCD object. Parameters: (RS, E, D4, D5, D6, D7)
LiquidCrystal lcd = LiquidCrystal(2, 3, 4, 5, 6, 7);

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

void loop() {
  lcd.cursor();
  delay(500);
  lcd.noCursor();
  delay(500);
}

blink()

Crea un cursor de estilo bloque parpadeante en el LCD: un rectángulo que parpadea en la posición del siguiente carácter a imprimir.

noBlink()

Desactiva el cursor de estilo bloque. El siguiente ejemplo muestra el cursor parpadeante durante 5 segundos y luego lo desactiva durante 2 segundos.

#include "LiquidCrystal.h"

// Creates an LCD object. Parameters: (RS, E, D4, D5, D6, D7)
LiquidCrystal lcd = LiquidCrystal(2, 3, 4, 5, 6, 7);

void setup() {
  lcd.begin(16, 2);
  lcd.print("blink() example");
}

void loop() {
  lcd.blink();
  delay(5000);
  lcd.noBlink();
  delay(2000);
}

display()

Esta función enciende la pantalla LCD y muestra cualquier texto o cursor que haya sido impreso en la pantalla.

noDisplay()

Esta función apaga cualquier texto o cursor impreso en el LCD. El texto/datos no se borran de la memoria del LCD. Esto significa que se mostrarán de nuevo cuando se llame a la función display().

El siguiente ejemplo crea un efecto de texto parpadeante.

#include "LiquidCrystal.h"

// Creates an LCD object. Parameters: (RS, E, D4, D5, D6, D7)
LiquidCrystal lcd = LiquidCrystal(2, 3, 4, 5, 6, 7);

void setup() {
  lcd.begin(16, 2);
  lcd.print("Blinking text");
}

void loop() {
  lcd.display();
  delay(2000);
  lcd.noDisplay();
  delay(2000);
}

write()

Esta función se puede usar para escribir un carácter en el LCD. Consulta la sección sobre cómo crear y mostrar caracteres personalizados más abajo para más información.

scrollDisplayLeft()

Desplaza el contenido de la pantalla (texto y cursor) un espacio a la izquierda. Puedes usar esta función en la sección loop del código junto con delay(500), para crear una animación de texto desplazándose.

#include "LiquidCrystal.h"

// Creates an LCD object. Parameters: (RS, E, D4, D5, D6, D7)
LiquidCrystal lcd = LiquidCrystal(2, 3, 4, 5, 6, 7);

void setup() {
  lcd.begin(16, 2);
  lcd.print("scrollDisplayLeft() example");
}

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

scrollDisplayRight()

Desplaza el contenido de la pantalla (texto y cursor) un espacio a la derecha.

autoscroll()

Esta función activa el desplazamiento automático del LCD. Esto hace que cada carácter que se imprima empuje los caracteres anteriores un espacio. Si la dirección actual del texto es de izquierda a derecha (por defecto), la pantalla se desplaza hacia la izquierda; si la dirección es de derecha a izquierda, la pantalla se desplaza hacia la derecha. Esto tiene el efecto de imprimir cada nuevo carácter en la misma posición del LCD.

El siguiente sketch de ejemplo activa el desplazamiento automático e imprime los caracteres del 0 al 9 en la posición (16,0) del LCD. Cambia esto a (20,0) para un LCD 20×4.

#include "LiquidCrystal.h"

// Creates an LCD object. Parameters: (RS, E, D4, D5, D6, D7)
LiquidCrystal lcd = LiquidCrystal(2, 3, 4, 5, 6, 7);

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

void loop() {
  lcd.autoscroll();
  lcd.setCursor(16, 0);
  for (int x = 0; x < 10; x++) {
    lcd.print(x);
    delay(500);
  }
  lcd.clear();
}

noAutoscroll()

Desactiva el desplazamiento automático del LCD.

leftToRight()

Esta función hace que el texto fluya hacia la derecha desde el cursor, como si la pantalla estuviera justificada a la izquierda (por defecto).

rightToLeft()

Esta función hace que el texto fluya hacia la izquierda desde el cursor, como si la pantalla estuviera justificada a la derecha.

¿Cómo crear y mostrar caracteres personalizados?

Con la función createChar() es posible crear y mostrar caracteres personalizados en el LCD. Esto es especialmente útil si quieres mostrar un carácter que no forma parte del conjunto estándar ASCII.

Información técnica: Los LCD basados en el controlador Hitachi HD44780 tienen dos tipos de memoria: CGROM y CGRAM (Character Generator ROM y RAM). CGROM genera todos los patrones de caracteres de 5 x 8 puntos a partir de los códigos estándar de 8 bits. CGRAM puede generar patrones de caracteres definidos por el usuario.

Para pantallas de 5 x 8 puntos, CGRAM puede escribir hasta 8 caracteres personalizados y para pantallas de 5 x 10 puntos 4. Para más información consulta la hoja de datos.

Código de ejemplo Arduino para caracteres personalizados

El siguiente sketch de ejemplo crea y muestra ocho caracteres personalizados (numerados del 0 al 7).

/* Example sketch to create and display custom characters on 
   character LCD with Arduino and LiquidCrystal library. 
   For more info see www.www.makerguides.com */

#include "LiquidCrystal.h"

// Creates an LCD object. Parameters: (RS, E, D4, D5, D6, D7)
LiquidCrystal lcd = LiquidCrystal(2, 3, 4, 5, 6, 7);

// Make custom characters:
byte Heart[] = {
  B00000,
  B01010,
  B11111,
  B11111,
  B01110,
  B00100,
  B00000,
  B00000
};
byte Bell[] = {
  B00100,
  B01110,
  B01110,
  B01110,
  B11111,
  B00000,
  B00100,
  B00000
};
byte Alien[] = {
  B11111,
  B10101,
  B11111,
  B11111,
  B01110,
  B01010,
  B11011,
  B00000
};
byte Check[] = {
  B00000,
  B00001,
  B00011,
  B10110,
  B11100,
  B01000,
  B00000,
  B00000
};
byte Speaker[] = {
  B00001,
  B00011,
  B01111,
  B01111,
  B01111,
  B00011,
  B00001,
  B00000
};
byte Sound[] = {
  B00001,
  B00011,
  B00101,
  B01001,
  B01001,
  B01011,
  B11011,
  B11000
};
byte Skull[] = {
  B00000,
  B01110,
  B10101,
  B11011,
  B01110,
  B01110,
  B00000,
  B00000
};
byte Lock[] = {
  B01110,
  B10001,
  B10001,
  B11111,
  B11011,
  B11011,
  B11111,
  B00000
};

void setup() {
  // Specify the LCD's number of columns and rows:
  lcd.begin(16, 2);

  // Create a new characters:
  lcd.createChar(0, Heart);
  lcd.createChar(1, Bell);
  lcd.createChar(2, Alien);
  lcd.createChar(3, Check);
  lcd.createChar(4, Speaker);
  lcd.createChar(5, Sound);
  lcd.createChar(6, Skull);
  lcd.createChar(7, Lock);

  // Clears the LCD screen:
  lcd.clear();

  // Print a message to the lcd:
  lcd.print("Custom Character");
}

void loop() {
  // Print all the custom characters:
  lcd.setCursor(0, 1);
  lcd.write(byte(0));
  lcd.setCursor(2, 1);
  lcd.write(byte(1));
  lcd.setCursor(4, 1);
  lcd.write(byte(2));
  lcd.setCursor(6, 1);
  lcd.write(byte(3));
  lcd.setCursor(8, 1);
  lcd.write(byte(4));
  lcd.setCursor(10, 1);
  lcd.write(byte(5));
  lcd.setCursor(12, 1);
  lcd.write(byte(6));
  lcd.setCursor(14, 1);
  lcd.write(byte(7));
}

Deberías ver la siguiente salida en el LCD:

Cómo funciona el código

Después de incluir la biblioteca y crear el objeto LCD, se definen los arrays de caracteres personalizados. Cada array consta de 8 bytes, 1 byte por cada fila. En este ejemplo se crean 8 caracteres personalizados.

// Make custom characters:
byte Heart[] = {
  B00000,
  B01010,
  B11111,
  B11111,
  B01110,
  B00100,
  B00000,
  B00000
};

Al observar el array detenidamente, verás lo siguiente. Cada fila consta de 5 números que corresponden a los 5 píxeles en un carácter de 5 x 8 puntos. Un 0 significa píxel apagado y un 1 significa píxel encendido.

Es posible editar cada fila a mano, pero recomiendo usar esta visual tool en GitHub. Esta aplicación crea automáticamente el array de caracteres y puedes hacer clic en los píxeles para encenderlos o apagarlos.

En la setup(), los caracteres personalizados se crean con lcd.createChar(num, data).

El primer argumento de esta función es el número del carácter personalizado (0-7) y el segundo argumento es el array de caracteres que creamos.

  // Create a new characters:
  lcd.createChar(0, Heart);
  lcd.createChar(1, Bell);
  lcd.createChar(2, Alien);
  lcd.createChar(3, Check);
  lcd.createChar(4, Speaker);
  lcd.createChar(5, Sound);
  lcd.createChar(6, Skull);
  lcd.createChar(7, Lock);

En la loop() todos los caracteres se muestran con lcd.write(). Como parámetro usamos el número del carácter que reservamos.

  lcd.setCursor(0, 1);
  lcd.write(byte(0));

Conclusión

En este artículo te he mostrado cómo usar un LCD alfanumérico con Arduino. Espero que te haya resultado útil e informativo. Si tienes alguna pregunta, sugerencia o crees que falta algo en este tutorial, por favor deja un comentario abajo.

¡Feliz bricolaje! 😉