Cómo usar un LCD de 16×2 caracteres con Arduino Deja un comentario

Tutoriales, Tutoriales Arduino

LCD y Arduino

Este tutorial incluye todo lo que necesitas saber sobre el control de una pantalla LCD de caracteres con Arduino. Hemos incluido un diagrama de cableado y muchos códigos de ejemplo. Estas pantallas, LCD, son ideales para mostrar datos o texto de los sensores y también son bastante baratas.

La primera parte de este artículo cubre los aspectos básicos de la visualización de texto y números. En la segunda mitad, entraremos en más detalles sobre cómo mostrar caracteres personalizados y cómo puedes usar las otras funciones de la biblioteca LiquidCrystal Arduino.

Como verás, se necesitan bastantes conexiones para controlar estas pantallas. Por lo tanto, se puede utilizar con un módulo de interfaz I2C montado en la parte posterior. Con este módulo I2C, sólo se necesitan dos conexiones para controlar la pantalla LCD.

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 utilizan el mismo chip controlador LCD de interfaz paralela HD44780 de Hitachi. Esto significa que puedes cambiarlos fácilmente. Sólo tendrás que cambiar las especificaciones de tamaño en tu código de Arduino.

  • Especificaciones de la pantalla: LCD 16×2
  • Tensión de funcionamiento: 5 V
  • Controlador Hitachi HD44780 Controlador LCD
  • 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 de visualización 64,5 x 16,4 mm

Pinout LCD 16×2

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

El pinout de una pantalla LCD HD44780 estándar se muestra en la siguiente tabla:

Pin no. Símbolo Conexión Función
1 VSS GND Arduino Masa de señal
2 VDD 5 V Arduino Alimentación lógica para LCD
3 V0 10 kΩ potenciómetro 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 de lectura/escritura
6 E Pin 3 Arduino Señal de habilitación de funcionamiento
7 – 14 D0 – D7 – Líneas de bus de datos utilizadas para el modo de 8 bits
11 – 14 D4 – D7 Pin 4 – 7 Arduino Líneas de bus de datos utilizadas para el 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

Para seguir este tutorial necesita los siguientes componentes:

Componentes de hardware:

Software:

Prueba de la pantalla LCD y ajuste del contraste

Para probar la pantalla, deberás realizar las conexiones como se muestra en la siguiente figura.

La mayoría de los LCD tienen una resistencia de serie incorporada para la retroiluminación LED. La encontrarás en la parte posterior de la pantalla LCD conectada a la clavija 15 (ánodo). Si tu pantalla no incluye una resistencia, tendrás que añadir una entre 5 V y el pin 15. Debería ser seguro usar una resistencia de 220Ω, pero este valor puede hacer que tu pantalla se oscurezca un poco. Puedes comprobar en la hoja de datos la máxima intensidad nominal de la retroiluminación y utilizarla para seleccionar un valor de resistencia adecuado.

Una vez que hayas cableado la pantalla LCD, tendrás que ajustar el contraste de la pantalla. Esto se hace girando el potenciómetro 10 kΩ en el sentido de las agujas del reloj o en sentido contrario.

Enchufa el conector USB del Arduino para alimentar la pantalla LCD. Deberías ver que la luz de fondo se ilumina. Ahora gira el potenciómetro hasta que aparezca una (16×2 LCD) o dos filas (20×4 LCD) de rectángulos.


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

Cómo conectar el LCD a Arduino UNO

Para poder controlar la pantalla LCD y los caracteres de la pantalla, tendrás que añadir algunas conexiones adicionales. Comprueba el diagrama de cableado que aparece a continuación y la tabla de pines de la introducción de este artículo.


Usaremos la pantalla LCD en modo de 4 bits, lo que significa que no es necesario conectar nada a D0-D3. La clavija R/W está conectada a tierra, esto tirará de la clavija LOW y ajustará la pantalla LCD al modo WRITE.

Una vez que hayas cableado todo, podemos empezar a programar la pantalla LCD.

Código Arduino de ejemplo para LCD

Para controlar la pantalla LCD utilizaremos la biblioteca LiquidCrystal. Esta librería debería venir preinstalada con el IDE de Arduino. Puedes encontrarla en Sketch > Incluir biblioteca > LiquidCrystal.

La biblioteca LiquidCrystal viene con muchas funciones incorporadas y hace que el control de las pantallas LCD de caracteres sea súper fácil.

El siguiente código de ejemplo muestra cómo mostrar un mensaje en la pantalla LCD. A continuación, te mostraremos cómo funciona el código y cómo puedes usar las otras funciones de la biblioteca LiquidCrystal.

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

// Include the library:
#include 

// 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 el siguiente texto de salida en la pantalla LCD:

Cómo funciona el código

Después de incluir la librería, 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 utilizamos los pines de Arduino a los que conectamos la pantalla. Ten en cuenta que hemos llamado a la pantalla’lcd’. Puedes darle un nombre diferente si lo desea como ‘menu_display’. Tendrás que cambiar ‘lcd’ por el nuevo nombre en el resto del sketch.

// Include the library:
#include 

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

En setup() la pantalla LCD se inicia con la función begin(cols,rows). Cuando utilices una pantalla LCD de 20×4 cambie 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 el loop() el cursor se coloca en la tercera columna y primera fila de la pantalla LCD con lcd.setCursor(2,0). Ten en cuenta que el conteo comienza en 0, y el primer argumento especifica la columna. Si no se especifica la posición del cursor, el texto se imprimirá en la posición de inicio predeterminada (0,0) si la pantalla está vacía, o detrás del último carácter impreso.

A continuación, la cadena “Hello World” se imprime con lcd.print (“Hello World!”). Ten en cuenta que debe colocar comillas (“”) alrededor del texto. Cuando desees imprimir números o variables, no se necesitan 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");
}

Puedes ver cómo usar un sensor ultrasónico HC-SR04 con una pantalla LCD en este tutorial.

Otras funciones de la biblioteca LiquidCrystal

La librería LiquidCrystal Arduino tiene muchas otras funciones incorporadas que te pueden resultar útiles. Puedes encontrar una descripción general de ellos abajo con explicaciones y algunos fragmentos de código.

clear()

Borra la pantalla LCD y posiciona el cursor en la esquina superior izquierda (primera fila y primera columna) de la pantalla. Puedes utilizar esta función para visualizar diferentes palabras en un ciclo.

#include 

// 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);
}

inicio()

Posiciona el cursor en la esquina superior izquierda de la pantalla LCD. Utilice clear() si también desea borrar la pantalla.

cursor()

Muestra el cursor de la pantalla LCD: un guión bajo (línea) en la posición del siguiente carácter que se va a imprimir.

noCursor()

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

#include 

// 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 LCD estilo bloque parpadeante: un rectángulo parpadeante en la posición del siguiente carácter a imprimir.

noBlink()

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

#include 

// 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 se haya impreso en la pantalla.

noDisplay()

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

El siguiente ejemplo crea un efecto de texto intermitente.

write()

Esta función se puede utilizar para escribir un carácter en la pantalla LCD. Consulte la sección sobre la creación y visualización de caracteres personalizados más abajo para obtener más información.

scrollDisplayLeft()

Desplaza el contenido de la pantalla (texto y cursor) un espacio a la izquierda. Puedes utilizar esta función en la sección de bucle del código en combinación con delay(500), para crear una animación de texto desplazable.

#include 

// 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 de la pantalla LCD. Esto hace que la salida de cada carácter a la pantalla empuje los caracteres anteriores más de un espacio. Si la dirección actual del texto es de izquierda a derecha (la predeterminada), la pantalla se desplaza hacia la izquierda; si la dirección actual es de derecha a izquierda, la pantalla se desplaza hacia la derecha. Esto tiene el efecto de enviar cada nuevo carácter a la misma ubicación en la pantalla LCD.

El siguiente esquema de ejemplo permite el desplazamiento automático e imprime el carácter 0 a 9 en la posición (16,0) de la pantalla LCD. Cámbielo a (20,0) para una pantalla LCD de 20×4.

#include 

// 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 de la pantalla 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 la pantalla LCD. Esto es especialmente útil si desea visualizar un carácter que no forma parte del juego de caracteres ASCII estándar.

Información técnica. Las pantallas LCD que se basan en el controlador LCD Hitachi HD44780 tienen dos tipos de memorias: CGROM y CGRAM (ROM y RAM del Generador de Caracteres). CGROM genera todos los patrones de caracteres de 5 x 8 puntos a partir de los códigos de caracteres 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.

Caracteres personalizados Código de ejemplo de Arduino

El siguiente esquema 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. */

#include 

// 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 la pantalla LCD:

Cómo funciona el código

Después de incluir la biblioteca y crear el objeto LCD, se definen las matrices de caracteres personalizadas. Cada matriz 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 de cerca la matriz, 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 herramienta visual en GitHub. Esta aplicación crea automáticamente la matriz de caracteres y puede hacer clic en los píxeles para activarlos o desactivarlos.

En 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 es la matriz de caracteres que hemos creado.

// 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 el loop() todos los caracteres se muestran con lcd.write(). Como parámetro utilizamos el número del carácter que reservamos.

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

Conclusión

En este artículo te hemos enseñado cómo usar una pantalla LCD alfanumérica con Arduino. Esperamos que te haya resultado útil e informativo. Si lo hiciste, por favor compártelo con un amigo que también le guste la electrónica y hacer cosas con su placa Arduino.

Última actualización el 2019-10-27 / Enlaces de afiliados / Imágenes de la API para Afiliados

También te puede interesar

 

Deja una respuesta

Tu dirección de correo electrónico no será publicada. Los campos obligatorios están marcados con *

Este sitio usa Akismet para reducir el spam. Aprende cómo se procesan los datos de tus comentarios.

Enviar Whatsapp
Hola 👋
¿En qué podemos ayudarte?