¿Quiere que tus proyectos Arduino muestren mensajes de estado o lecturas de sensores? Entonces estas pantallas LCD pueden encajar perfectamente. Son una forma extremadamente común y rápida de agregar una interfaz legible a tu proyecto.
Este tutorial te ayudará a poner en marcha no solo con LCD de 16 × 2 caracteres, sino también con cualquier LCD de caracteres (16 × 4, 16 × 1, 20 × 4, etc.) que esté basado en el chip controlador LCD de Hitachi: HD44780.
Debido a que la comunidad de Arduino ya ha desarrollado una biblioteca para manejar las pantallas LCD HD44780, puedes conectarlas en poco tiempo.
¿Sabías que?
LCD es la abreviatura de pantalla de cristal líquido. Es básicamente una unidad de visualización que utiliza cristales líquidos para formar una imagen visual.
Cuando se aplica corriente a estos cristales, se vuelven opacos y bloquean la luz de fondo que reside detrás de la pantalla. Como resultado, esa área en particular estará oscura en comparación con las demás. Y así es como se muestran los caracteres en la pantalla.
Descripción general del hardware
Fieles a su nombre, estas pantallas LCD son ideales para mostrar solo texto/caracteres. Una pantalla LCD de 16 × 2 caracteres, por ejemplo, tiene retroiluminación LED y puede mostrar 32 caracteres ASCII en dos filas de 16 caracteres cada una.
Si miras de cerca, puede ver pequeños rectángulos para cada carácter en la pantalla y los píxeles que componen un carácter. Cada uno de estos rectángulos es una cuadrícula de 5×8 píxeles.
Los hay de muchos tamaños y colores: por ejemplo, 16×1, 16×4, 20×4, texto blanco sobre fondo azul o texto negro sobre verde y muchos otros.
La buena noticia es que todas estas pantallas son ‘intercambiables’, lo que significa que, si creas tu proyecto con una, simplemente puede desenchufarla y usar otra pantalla LCD de tamaño/color de tu elección. ¡El código cambiará un poco, pero al menos el cableado sigue siendo el mismo!
Configuración de pines LCD de 16 × 2 caracteres
Antes de profundizar en la conexión y el código de ejemplo, echemos un vistazo primero al pinout.
GND está conectado a tierra del Arduino.
VCC es la fuente de alimentación para la pantalla LCD que conectamos al pin de 5V en el Arduino.
Vo (contraste LCD) controla el contraste y el brillo de la pantalla LCD. Usando un simple divisor de voltaje con un potenciómetro, podemos hacer ajustes finos al contraste.
RS (selección de registro) pin se establece en BAJO cuando se envían comandos a la pantalla LCD (como colocar el cursor en una ubicación específica, borrar la pantalla, etc.) y ALTO cuando se envían datos a la pantalla LCD. Básicamente, este pin se usa para separar el comando de los datos.
R/W (lectura/escritura) pin que permite leer datos de la pantalla LCD o escribir datos. Dado que solo estamos usando esta pantalla LCD como dispositivo de salida, vamos a configurar este pin en BAJO. Esto lo fuerza al modo ESCRIBIR.
E (Habilitar) este pin se utiliza para habilitar la pantalla. Cuando se establece en BAJO, a la pantalla LCD no le importa lo que sucede en las líneas de bus de datos, R/W y RS. Cuando este pin se establece en ALTO, la pantalla LCD procesa los datos entrantes.
D0-D7 (Bus de datos) Los pines llevan los datos de 8 bits que enviamos a la pantalla. Por ejemplo, si queremos ver un carácter ‘A’ en mayúscula en la pantalla, configuramos estos pines en 0100 0001 (según la tabla ASCII).
AK (ánodo y cátodo) Los pines se utilizan para controlar la luz de fondo de la pantalla LCD
Probando un LCD de caracteres
Ahora vayamos a las cosas interesantes. Probemos la pantalla LCD.
Primero, conecta los pines de 5V y GND del Arduino al riel de alimentación de la placa de pruebas y conecta tu LCD a la placa de pruebas.
Ahora encenderemos la pantalla LCD. La pantalla LCD tiene dos conexiones de alimentación separadas; Uno para la pantalla LCD (pin 1 y pin 2) y el otro para la retroiluminación de la pantalla LCD (pin 15 y pin 16). Conecta los pines 1 y 16 de la pantalla LCD a GND y 2 y 15 a 5V.
La mayoría de las pantallas LCD tienen una resistencia en serie integrada para la retroiluminación LED. Lo encontrará cerca del pin 15 en la parte posterior de la pantalla LCD. Si el LCD no incluye una resistencia de este tipo o no estás seguro, deberás agregar una entre 5 V y el pin 15. Es seguro usar una resistencia de 220 ohms, aunque un valor tan alto puede hacer la retroiluminación un poco tenue. Para obtener mejores resultados, consulta la hoja de datos para conocer la corriente de retroiluminación máxima y seleccionar un valor de resistencia adecuado.
A continuación, haremos la conexión para el pin 3 en la pantalla LCD que controla el contraste y el brillo. Para ajustar el contraste, conectaremos un potenciómetro de 10K entre 5V y GND y conectaremos el pin central del potenciómetro (wiper) al pin 3 en la pantalla LCD.
Eso es todo. Ahora energiza el Arduino. Verás que se enciende la luz de fondo. Ahora, al girar la perilla del potenciómetro, comenzarás a ver la primera fila de rectángulos. Si eso sucede, ¡Felicidades! Tu LCD está funcionando bien.
Conexión de una pantalla LCD de 16 × 2 caracteres a un Arduino
Terminemos de conectar la pantalla LCD al Arduino. Ya hemos hecho las conexiones para alimentar el LCD, ahora solo nos queda hacer las conexiones necesarias para la comunicación.
Sabemos que hay 8 pines de datos que llevan datos a la pantalla. Sin embargo, los LCD basados en HD44780 están diseñados de tal manera que podemos comunicarnos con el LCD utilizando solo 4 pines de datos (modo de 4 bits) en lugar de 8 (modo de 8 bits). ¡Esto nos ahorra 4 pines!
Entonces, para conectar la pantalla LCD usando el modo de 4 bits, solo necesitamos conectar 6 pines: RS, EN, D7, D6, D5 y D4.
Conecta los cuatro pines de datos de la pantalla LCD (D4-D7) a los pines digitales #5-2 de Arduino, el pin EN al pin digital #11 y el pin RS al pin digital #12.
El siguiente diagrama muestra cómo conectar todo.
Diferencia entre el modo de 4 y 8 bits
El modo de 8 bits es mucho más rápido que el modo de 4 bits porque lleva la mitad del tiempo. En el modo de 8 bits, escribe los datos de una sola vez. Mientras que, en el modo de 4 bits, debe dividir un byte en 2 nibbles (conjunto de cuatro dígitos binarios) y realizar dos operaciones de escritura.
El modo de 4 bits se usa a menudo para guardar pines de E/S. Sin embargo, el modo de 8 bits se usa mejor cuando se requiere velocidad en una aplicación y hay al menos 10 pines de E/S disponibles.
Código de ejemplo de Arduino
// include the library code:
#include <LiquidCrystal.h>
// Creates an LCD object. Parameters: (rs, enable, d4, d5, d6, d7)
LiquidCrystal lcd(12, 11, 5, 4, 3, 2);
void setup()
{
// set up the LCD's number of columns and rows:
lcd.begin(16, 2);
// Clears the LCD screen
lcd.clear();
}
void loop()
{
// Print a message to the LCD.
lcd.print(" Hello world!");
// 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 a message to the LCD.
lcd.print(" LCD Tutorial");
}El código de ejemplo imprime el mensaje ‘Hello World’ en la pantalla LCD. Pruebalo primero y luego entraremos en mas detalles.
Si todo va bien, deberías ver algo como esto en la pantalla.
Explicación del código:
El sketch comienza incluyendo la biblioteca LiquidCrystal. La comunidad Arduino tiene una biblioteca llamada LiquidCrystal que hace que la programación de módulos LCD sea menos difícil. Puedes encontrar más información sobre la biblioteca en el sitio web oficial de Arduino.
// include the library code:
#include <LiquidCrystal.h>Primero creamos un objeto LiquidCrystal. Este objeto utiliza 6 parámetros y especifica qué pines Arduino están conectados a RS, EN y cuatro pines de datos de la pantalla LCD.
// Creates an LCD object. Parameters: (rs, enable, d4, d5, d6, d7)
LiquidCrystal lcd(12, 11, 5, 4, 3, 2);
Una vez declarado el objeto LiquidCrystal, puedes acceder a los métodos de objetos específicos de la pantalla LCD.
En ‘setup’ llamamos a dos funciones. La primera función es begin(). Se utiliza para especificar las dimensiones (número de columnas y filas) de la pantalla. Si estás utilizando una pantalla LCD de 16 × 2 caracteres, pasa el 16 y el 2; Si estás utilizando una pantalla LCD de 20 × 4, pasa 20 y 4. ¡Entendido el punto!
lcd.begin(16, 2);
lcd.clear();La segunda función es clear(). Esto borra la pantalla LCD y mueve el cursor a la esquina superior izquierda.
// Print a message to the LCD.
lcd.print(" Hello world!");En el ‘bucle’, primero imprimimos el mensaje ‘Hello World’ en la pantalla LCD usando la función print().
lcd.setCursor(0, 1);
lcd.print(" LCD Tutorial");Después de eso, establecemos la posición del cursor en la segunda fila llamando a la función setCursor(). La posición del cursor especifica la ubicación en la que desea que se muestre el nuevo texto en la pantalla LCD. Se supone que la esquina superior izquierda es col=0, fila=0.
Otras funciones útiles en LiquidCrystal Library
Hay algunas funciones útiles que puede usar con objetos LiquidCrystal. Algunos de ellos se enumeran a continuación:
- lcd.home(), se utiliza para colocar el cursor en la parte superior izquierda de la pantalla LCD sin borrar la pantalla.
- lcd.blink(), muestra un bloque parpadeante de 5×8 píxeles en la posición en la que se escribirá el siguiente carácter.
- lcd.cursor(), muestra un guión bajo (línea) en la posición en la que se escribirá el siguiente carácter.
- lcd.noBlink(), apaga el cursor LCD parpadeante.
- lcd.noCursor(), oculta el cursor LCD.
- lcd.scrollDisplayRight() La función desplaza el contenido de la pantalla un espacio hacia la derecha. Si deseas que el texto se desplace continuamente, debes usar esta función dentro de un bucle for.
- lcd.scrollDisplayLeft() La función desplaza el contenido de la pantalla un espacio hacia la izquierda. Similar a la función anterior, usa esto dentro de un ciclo for para desplazamiento continuo.
Generación de caracteres personalizados para LCD 16 × 2
Si encuentras los caracteres en la pantalla aburridos, puede crear tus propios caracteres personalizados (glifos) y símbolos para su pantalla LCD. Son extremadamente útiles cuando desea mostrar un carácter que no forma parte del conjunto de caracteres ASCII estándar.
Como se discutió anteriormente en este tutorial, un caracter se compone de una matriz de 5 × 8 píxeles, por lo que debes definir el caracter personalizado dentro de esa matriz. Puedes usar la función createChar() para definir un carácter.
Para usar createChar(), primero configura una matriz de 8 bytes. Cada byte de la matriz representa una fila de caracteres en una matriz de 5×8. Mientras que 0 y 1 en un byte indican qué píxel de la fila debe estar ENCENDIDO y cuál debe estar APAGADO.
Todos estos caracteres definidos por el usuario se almacenan en la CGRAM de la pantalla LCD.
CGROM y CGRAM
Todas las pantallas LCD basadas en el controlador Hitachi HD44780 tienen dos tipos de memoria: CGROM y CGRAM (Generador de caracteres ROM y RAM).
CGROM es una memoria no volátil y no se puede modificar, mientras que CGRAM es una memoria volátil y se puede modificar en cualquier momento.
CGROM se usa para almacenar todas las fuentes permanentes que se muestran usando códigos ASCII. Por ejemplo, si enviamos 0x41 a la pantalla LCD, la letra ‘A’ se imprimirá en la pantalla.
CGRAM es otra memoria utilizada para almacenar caracteres definidos por el usuario. Esta RAM está limitada a 64 bytes. Para una pantalla LCD de 5 × 8 píxeles, solo se pueden almacenar 8 caracteres definidos por el usuario en CGRAM. Y para LCD basado en 5 × 10 píxeles, solo se pueden almacenar 4 caracteres definidos por el usuario.
Generador de caracteres personalizados
¡Crear caracteres personalizados nunca ha sido tan fácil! Hemos creado una pequeña aplicación llamada Custom Character Generator . ¿Puedes ver la cuadrícula azul a continuación? Puedes hacer clic en cualquier píxel de 5 × 8 para establecer/borrar ese píxel en particular. Y al hacer clic, el código del caracter se genera junto a la cuadrícula. Este código se puede usar directamente en tu código de Arduino.
La imaginación es ilimitada. La única limitación es que la biblioteca LiquidCrystal solo admite ocho caracteres personalizados. Pero no te desanimes, mira el lado positivo, al menos tenemos ocho personajes.
Código de ejemplo de Arduino
El siguiente programa muestra cómo mostrar caracteres personalizados en la pantalla LCD.
// include the library code:
#include <LiquidCrystal.h>
// initialize the library with the numbers of the interface pins
LiquidCrystal lcd(12, 11, 5, 4, 3, 2);
// make some custom characters:
byte Heart[8] = {
0b00000,
0b01010,
0b11111,
0b11111,
0b01110,
0b00100,
0b00000,
0b00000
};
byte Bell[8] = {
0b00100,
0b01110,
0b01110,
0b01110,
0b11111,
0b00000,
0b00100,
0b00000
};
byte Alien[8] = {
0b11111,
0b10101,
0b11111,
0b11111,
0b01110,
0b01010,
0b11011,
0b00000
};
byte Check[8] = {
0b00000,
0b00001,
0b00011,
0b10110,
0b11100,
0b01000,
0b00000,
0b00000
};
byte Speaker[8] = {
0b00001,
0b00011,
0b01111,
0b01111,
0b01111,
0b00011,
0b00001,
0b00000
};
byte Sound[8] = {
0b00001,
0b00011,
0b00101,
0b01001,
0b01001,
0b01011,
0b11011,
0b11000
};
byte Skull[8] = {
0b00000,
0b01110,
0b10101,
0b11011,
0b01110,
0b01110,
0b00000,
0b00000
};
byte Lock[8] = {
0b01110,
0b10001,
0b10001,
0b11111,
0b11011,
0b11011,
0b11111,
0b00000
};
void setup()
{
// initialize LCD and set up the number of columns and rows:
lcd.begin(16, 2);
// create a new character
lcd.createChar(0, Heart);
// create a new character
lcd.createChar(1, Bell);
// create a new character
lcd.createChar(2, Alien);
// create a new character
lcd.createChar(3, Check);
// create a new character
lcd.createChar(4, Speaker);
// create a new character
lcd.createChar(5, Sound);
// create a new character
lcd.createChar(6, Skull);
// create a new character
lcd.createChar(7, Lock);
// Clears the LCD screen
lcd.clear();
// Print a message to the lcd.
lcd.print("Custom Character");
}
// Print All the custom characters
void loop()
{
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));
}La salida se ve así.
Explicación del código:
Después de incluir la biblioteca, tenemos que definir una matriz de caracteres personalizada de ocho bytes como esta:
byte Heart[8] = {
0b00000,
0b01010,
0b11111,
0b11111,
0b01110,
0b00100,
0b00000,
0b00000
};En setup(), necesitamos crear un caracter personalizado usando la funcion createChar(). Esta función toma dos parámetros, el primero es un número entre 0 y 7 para reservar uno de los 8 caracteres personalizados admitidos. El segundo es el nombre de la matriz.
// create a new character
lcd.createChar(0, Heart);Luego en loop, para mostrar el carácter personalizado, simplemente usamos la función write() y le pasamos el número del carácter que reservamos anteriormente.
// byte(0) represents Heart character.
lcd.write(byte(0));Interfacing 16×2 character LCD module with Arduino. Last Minute Engineers. https://lastminuteengineers.com/arduino-1602-character-lcd-tutorial/