Pantalla alfanumérica LCD 16X2 con Arduino Deja un comentario
En este tutorial enseñaremos a utilizar la pantalla LCD 16X2 con Arduino. Abordaremos lo más básico: desde la conexión de la pantalla con el arduino, mostrar cadenas de texto, enviar la lectura de un sensor a la pantalla y finalmente llegaremos a generar caracteres personalizados en la pantalla para hacer aún más vistosos nuestros proyectos. Estaremos utilizando la librería LiquidCrystal que viene integrada en la instalación del IDE de arduino y nos permite controlar toda clase de pantallas compatibles con el controlador HD44780 ya sean de 16×2, 20×4 u otras configuraciones de caracteres.
Como adicional a este articulo recomendamos la lectura de nuestro otro artículo, donde explicamos como realizar la conexión de la pantalla LCD 16X2 a través de un adaptador I2C, esto permite la comunicación con pantallas de este tipo usando solamente dos pines.
Materiales necesarios para las prácticas
Para realizar las prácticas que se mencionan a continuación requerimos los siguientes materiales:
¿Como utilizar una pantalla LCD 16×2 con Arduino?
Usar una pantalla LCD 16×2 con Arduino puede ser algo complicado por la cantidad de lineas de conexión que se requieren, por lo tanto dividiremos el proceso en varias fases para facilitarlo:
- Conectar la pantalla LCD 16×2 a la alimentación de 5 volts, incluyendo la alimentación de la iluminación led
- Colocar un potenciómetro para el ajuste de contraste
- Conectar los pines de datos a la pantalla (modo de 4 bits o modo de 8 bits)
- Conectar los pines de control RS y EN (de manera opcional el pin RW).
A continuación se muestran los diagramas de cada parte de este proceso de conexión; El primer paso consiste en la conexión de la alimentación, hay que fijarnos en la polaridad para evitar dañar la pantalla. En este caso utilizaremos los pines VSS(-), VDD(+), A(+) y K(-) para brindar la alimentación.
El siguiente paso es conexión de un potenciómetro de 10K que permite el ajuste del contraste, los extremos del potenciómetro van al positivo y negativo de la alimentación, mientras que el cursor (centro) va al pin VO del módulo LCD.
A continuación conectamos los pines de datos D4, D5, D6, D7. Utilizaremos solamente estos 4 pines ya que operaremos la pantalla en Modo de 4 bits.
Finalmente realizamos la conexión de los pines de control RS y E. El pin RW es opcional y en este caso no lo usamos para ahorrar un pin y mantener todo más simple.
Programación de la pantalla LCD 16×2 con Arduino
El siguiente programa es un ejemplo básico para comenzar a utilizar nuestra pantalla y probar que las conexiones se encuentran correctas. Al cargarlo debemos ver letras en pantalla y además una animación del texto moviéndose en la pantalla. Hemos comentado lo más posible el código de manera que sea fácil de entender.
Si no se visualiza nada en la pantalla cuando se carga este programa, recomendamos mover el potenciómetro del contraste y/o revisar las conexiones.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 |
/** GeekFactory – “INNOVATING TOGETHER” Distribucion de materiales para el desarrollo e innovacion tecnologica www.geekfactory.mx EJEMPLO BASICO PARA EL USO DEL LCD 16X2 CON ARDUINO. MUESTRA UN TEXTO QUE RECORRE LA PANTALLA DE UN LADO A OTRO. ESTE PROGRAMA SIRVE COMO PRUEBA DEL CORRECTO FUNCIONAMIENTO DE NUESTRO CONEXIONADO Y TAMBIEN ILUSTRA COMO REALIZAR OPERACIONES CON EL CURSOR, BORRAR LA PANTALLA Y MOSTRAR CADENAS DE TEXTO. */ #include // CONSTRUCTOR PARA LA PANTALLA LCD 16X2 // AQUI SE CONFIGURAN LOS PINES PARA LA COMUNICACION CON LA PANTALLA LiquidCrystal lcd(12, 11, 5, 4, 3, 2); void setup() { // INDICAMOS QUE TENEMOS CONECTADA UNA PANTALLA DE 16X2 lcd.begin(16, 2); // MOVER EL CURSOR A LA PRIMERA POSICION DE LA PANTALLA (0, 0) lcd.home(); // IMPRIMIR “Hola Mundo” EN LA PRIMERA LINEA lcd.print(“Hola Mundo”); // MOVER EL CURSOR A LA SEGUNDA LINEA (1) PRIMERA COLUMNA (0) lcd.setCursor ( 0, 1 ); // IMPRIMIR OTRA CADENA EN ESTA POSICION lcd.print(“GEEKFACTORY”); // ESPERAR UN SEGUNDO delay(1000); } void loop() { // EN EL CICLO PRINCIPAL SOLAMENTE RECORREMOS EL MENSAJE DE UN LADO A OTRO // VARIABLE PARA CONTROL DE CICLOS int i; // DESPLAZAR LA PANTALLA A LA DERECHA 2 VECES for ( int i = 0; i < 5; i++ ) { lcd.scrollDisplayRight(); delay (1000); } // DESPLAZAR LA PANTALLA A LA IZQUIERDA 2 VECES for ( int i = 0; i < 5; i++ ) { lcd.scrollDisplayLeft(); delay (1000); } } |
Mostrar el valor de un sensor en la pantalla LCD 16X2 con Arduino
Otro de los usos comunes de la pantalla LCD de 16×2 es mostrar valores medidos por sensores. El siguiente programa esta diseñado para ser un ejemplo de como desplegar el valor medido por un sensor en la pantalla, en este ejemplo estaremos utilizando un potenciómetro para simular la entrada del sensor. De nueva cuenta, hemos comentado el código para que se facilite su comprensión:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 |
/** GeekFactory – “INNOVATING TOGETHER” Distribucion de materiales para el desarrollo e innovacion tecnologica www.geekfactory.mx EJEMPLO BASICO PARA EL USO DEL LCD 16X2 CON ARDUINO. MUESTRA UN TEXTO QUE RECORRE LA PANTALLA DE UN LADO A OTRO. ESTE PROGRAMA SIRVE COMO PRUEBA DEL CORRECTO FUNCIONAMIENTO DE NUESTRO CONEXIONADO Y TAMBIEN ILUSTRA COMO REALIZAR OPERACIONES CON EL CURSOR, BORRAR LA PANTALLA Y MOSTRAR CADENAS DE TEXTO. */ #include // CONSTRUCTOR PARA LA PANTALLA LCD 16X2 // AQUI SE CONFIGURAN LOS PINES PARA LA COMUNICACION CON LA PANTALLA LiquidCrystal lcd(12, 11, 5, 4, 3, 2); void setup() { // INDICAMOS QUE TENEMOS CONECTADA UNA PANTALLA DE 16X2 lcd.begin(16, 2); // MOVER EL CURSOR A LA PRIMERA POSICION DE LA PANTALLA Y BORRAR (0, 0) lcd.clear(); // IMPRIMIR CADENA EN LA PRIMERA POSICION lcd.print(” GEEKFACTORY.MX “); // ESPERAR UN SEGUNDO delay(1000); } void loop() { // BORRAMOS TODA LA PANTALLA PARA ACTUALIZARLA CADA SEGUNDO lcd.clear(); // IMPRIMIR UN ENCABEZADO lcd.print(” POTENCIOMETRO “); // REALIZAR LECTURA ANALOGICA EN PIN A0 unsigned int val = analogRead(A0); // CONVERTIR ESE VALOR A VOLTAJE (ASUMIENDO QUE EL ARDUINO SE ALIMENTA A 5 VOLTS) float volts = (val * 5.0) / 1024.0; // IMPRIMIR VALORES EN LA SEGUNDA LINEA, COMENZANDO POR EL VALOR DIRECTO DEL ADC lcd.setCursor(0, 1); lcd.print(val); // IMPRIMIR EL VALOR EN VOLTAJE, DESPUES DE LA LECTURA DEL ADC lcd.setCursor(6, 1); lcd.print(volts, 1); // ESPERAR UN SEGUNDO ANTES DE CONTUNUAR delay (1000); } |
Crear y enviar caracteres personalizados a la pantalla LCD 16X2
Otro de los usos de la pantalla LCD de 16×2 con arduino es mostrar información gráfica. En este ejemplo, mostramos como definir caracteres personalizados que pueden enviarse al controlador de pantalla. Con esta funcionalidad del controlador HD44780 se pueden obtener resultados bastante vistosos, como puede verse en los siguientes ejemplos que hemos encontrado navegando por internet:
Cada carácter se define como un grupo de 8 bytes que se envían a la memoria CGRAM. Por ejemplo, podemos crear un icono con una carita feliz de la siguiente forma: 
Traducido a código en C quedaría de la siguiente forma:
|
byte smile[8] = { 0b00000000, 0b00001010, 0b00001010, 0b00001010, 0b00000000, 0b00010001, 0b00001110, 0b00000000, }; |
A continuación mostramos el programa completo que define los caracteres personalizados y luego los muestra en la pantalla:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 |
/** GeekFactory – “INNOVATING TOGETHER” Distribucion de materiales para el desarrollo e innovacion tecnologica www.geekfactory.mx EN ESTE EJEMPLO MOSTRAMOS COMO DEFINIR CARACTERES PERSONALIZADOS EN UNA PANTALLA LCD 16X2 CON ARDUINO. EL CODIGO MUESTRA COMO DEFINIR LOS MAPAS DE BITS Y COMO INDICARLE AL CONTROLADOR DE PANTALLA QUE MUESTRE LOS CARACTERES PERSONALIZADOS EN POSICIONES ESPECIFICAS DE LA PANTALLA. */ #include // CONSTRUCTOR PARA LA PANTALLA LCD 16X2 // AQUI SE CONFIGURAN LOS PINES PARA LA COMUNICACION CON LA PANTALLA LiquidCrystal lcd(12, 11, 5, 4, 3, 2); // DEFINICION DE CARACTERES PERSONALIZADOS byte smile[8] = { 0b00000000, 0b00001010, 0b00001010, 0b00001010, 0b00000000, 0b00010001, 0b00001110, 0b00000000, }; byte sad[8] = { 0b00000000, 0b00001010, 0b00001010, 0b00001010, 0b00000000, 0b00001110, 0b00010001, 0b00000000, }; byte body[8] = { 0b00001110, 0b00001110, 0b00000100, 0b00011111, 0b00000100, 0b00001010, 0b00010001, 0b00000000, }; byte arrowr[8] = { 0b00001000, 0b00000100, 0b00000010, 0b00011111, 0b00000010, 0b00000100, 0b00001000, 0b00000000, }; byte arrowu[8] = { 0b00000100, 0b00001110, 0b00010101, 0b00000100, 0b00000100, 0b00000100, 0b00000100, 0b00000000, }; byte arrowd[8] = { 0b00000100, 0b00000100, 0b00000100, 0b00000100, 0b00010101, 0b00001110, 0b00000100, 0b00000000, }; byte arrowl[8] = { 0b00000010, 0b00000100, 0b00001000, 0b00011111, 0b00001000, 0b00000100, 0b00000010, 0b00000000, }; void setup() { // INDICAMOS QUE TENEMOS CONECTADA UNA PANTALLA DE 16X2 lcd.begin(16, 2);
// ENVIAR LOS MAPAS DE BITS AL CONTROLADOR DE PANTALLA lcd.createChar (0, smile); lcd.createChar (1, sad); lcd.createChar (2, body); lcd.createChar (3, arrowr); lcd.createChar (4, arrowu); lcd.createChar (5, arrowd); lcd.createChar (6, arrowl);
// LIMPIAR LA PANTALLA Y MOVER EL CURSOR A LA PRIMERA POSICION lcd.clear(); // IMPRIMIR TITULO EN LA PRIMERA LINEA lcd.print(” GEEKFACTORY.MX “); // MOVER EL CURSOR A LA SEGUNDA LINEA lcd.setCursor(0, 1); // AHORA ESCRIBIMOS (MOSTRAMOS) LOS CARACTERES A LA PANTALLA lcd.write((byte)0); lcd.write((byte)1); lcd.write((byte)2); lcd.write((byte)3); lcd.write((byte)4); lcd.write((byte)5); lcd.write((byte)6); } void loop() { // NO HACEMOS NADA EN EL LOOP } |
Conclusión
- En este artículo aprendimos a cablear una pantalla LCD 16X2 con Arduino en modo de 4 bits.
- Aprendimos que una pantalla puede usar un mínimo de 6 pines de conexión con el microcontrolador.
- Realizamos un programa que muestra el valor leído por un sensor en una pantalla LCD de 16×2 con Arduino.
- Exploramos las posibilidades que ofrecen los caracteres personalizados.
- Mencionamos la posibilidad de conectar este tipo de display a través del bus I2C.
