Descripción
El display LCD 16×2 es ideal para utilizarse como dispositivo de salida e interfaz de usuario en proyectos con Arduino, Raspberry Pi y otros microcontroladores. Es compatible con el juego de comandos estándar del controlador HD44780 en el que se basan la mayoría de los displays de este tipo y permite visualizar hasta 2 lineas de texto de 16 caracteres cada una.
El chip controlador de esta pantalla es extremadamente común y el código necesario se encuentra disponible libremente en internet. Se puede utilizar fácilmente con cualquier microcontrolador que tenga al menos 6 pines disponibles, ya que para su conexión se utiliza un bus paralelo de 4 u 8 bits y al menos dos señales de control.
En Arduino podemos utilizarla sin necesidad de instalar software adicional gracias a la librería LiquidCrystal y en general la mayoría de las plataformas cuentan con alguna librería o biblioteca de software para manejar este tipo de displays.
En nuestra tienda virtual podrás encontrar gran variedad de pantallas y displays para satisfacer las necesidades de cualquier proyecto.
Características de Display LCD 16×2 caracteres alfanumérico
- Marca: Genérico
- Modelo / Número de parte: 1602A
- Tipo de display: Alfanumérico, Monocromático
- Tecnología de display: LCD
- Resolución: 2 lineas de 16 caracteres de 8 x 5 píxeles cada uno
- Tamaño diagonal: 71 mm
- Área visible: 14.5 x 69.6 mm
- Controlador gráfico: Compatible con HD44780
- Controlador y panel táctil: Ninguno
- Interfaz: Bus paralelo de 4 u 8 bits + 3 señales de control
- Voltaje de alimentación: 5 VDC ± 10 %
- Corriente típica (sin backlight): 1.1 mA
- Color de iluminación: disponible en colores
- Retroiluminación verde, letras negras
- Retroiluminación azul, letras blancas
- Otras características:
- Perforaciones para montaje con tornillos 2.8 mm de diámetro
- Apto para interfaces de usuario sencillas
- Ideal para prácticas escolares
- Peso: 0.032 kg
- Dimensiones:
- Largo: 8.0 cm
- Ancho: 3.6 cm
- Alto: 1.1 cm
¿Qué es el display LCD 16×2 caracteres alfanumérico?
El display LCD 16×2 es un dispositivo de salida muy común en proyectos con microcontroladores como Arduino. Este dispositivo permite mostrar texto y números en una disposición de dos lineas de texto de 16 caracteres cada una. Esta conformado por dos partes principalmente: un PCB que aloja el controlador de pantalla LCD y la pantalla de cristal liquido (LCD) propiamente.
Normalmente el display se vende suelto, por lo que habrá que soldarle los conectores hembra o macho que se requieran para nuestro proyecto. También será necesario agregar un potenciómetro para poder ajustar el contraste del display. En términos generales el circuito requerido para operar un display LCD 16×2 es muy sencillo.
Las aplicaciones comunes de este tipo de displays son:
- Equipos de laboratorio
- Automatización de estacionamientos
- Máquinas de vending
- Equipos de audio
- Equipos de telecomunicaciones y redes
- Prototipos electrónicos
¿Cómo funciona un display LCD 16×2 caracteres alfanumérico?
El display LCD 16×2 es un dispositivo que se comunica mediante un bus paralelo de 4 u 8 bits, por lo que nuestro microcontrolador deberá manipular varios pines de salida de forma simultanea para transferir la información que deseamos transmitir al controlador de pantalla HD44780.
Para escribir información en la pantalla, lo que debemos hacer es básicamente:
- Colocar los pines RS, RW en estado bajo (0)
- Colocar cada uno de los bits que conforman un carácter en el bus de datos (D0 a D7)
- Enviar un pulso en el pin EN para realizar la operación de escritura
Las librerías como LiquidCrystal en Arduino realizarán este proceso de forma transparente por nosotros y solamente deberemos llamar a las funciones o métodos adecuados.
Comunicación con el microcontrolador
La siguiente tabla resume las conexiones del módulo LCD y la función de cada uno de los pines.
| Pin | Nombre | Función |
|---|---|---|
| 1 | Vas | GND, tierra |
| 2 | Vcc | +5 volts, alimentación positiva |
| 3 | VE | Control de contraste |
| 4 | RS | Register Select, controla si estamos en modo de comando (0) o de datos (1) |
| 5 | RW | Read / Write, controla si estamos leyendo (1) o escribiendo (0) datos a la pantalla |
| 6 | EN | Enable – el controlador transfiere los datos presentes en el bus cuando este pin transiciona de estado alto a bajo |
| 7 a 14 | D0 a D7 | Data0 a Data7, conforman el bus paralelo del controlador de pantalla |
| 15 | LED+ | Ánodo del LED utilizado para iluminación de fondo |
| 16 | LED- | Cátido del LED utilizado para ilumniación de fondo |
Tutorial pantalla LCD 16×2 con Arduino
En este tutorial enseñaremos a utilizar la pantalla LCD 16×2 con Arduino. Comenzaremos abordando el tema desde lo más básico: la conexión de la pantalla con el Arduino. Posteriormente realizaremos ejercicios para mostrar texto, mostrar la lectura de un sensor y finalmente llegaremos a generar caracteres personalizados para hacer aún más vistosos nuestros proyectos.
¿Cómo conectar un display LCD 16×2 con Arduino?
Usar una pantalla o display 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 dos fases para hacerlo más claro:
- Conectar la alimentación de 5 volts, incluyendo la iluminación LED y colocar un potenciómetro para el ajuste de contraste.
- Conectar los 4 pines de datos a la pantalla (modo de 4 bits) y las señales de control RS y EN (R/W va a tierra para ahorrar un pin).
En los diagramas a continuación se muestran los dos pasos.
Prácticas y ejemplos con display LCD 16×2 alfanumérico
Para realizar los ejercicios que se muestran en esta página se requieren los siguientes materiales:
- Arduino UNO (también funciona con otras tarjetas de la gama Arduino)
- Pantalla o display LCD 16×2 alfanumérica (este producto)
- Cables dupont
- Protoboard
- Potenciómetro de 10 Kohms
Programa que muestra texto móvil en pantalla
El siguiente programa es un ejemplo básico para comenzar a utilizar nuestra pantalla y probar que las conexiones son correctas. Al cargarlo, debemos ver letras moviéndose de un lado a otro de 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, recomendamos ajustar el potenciómetro del contraste y 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 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 | /** Geek Factory - "Dale vuelo a tus proyectos" Tienda de electrónica, Arduino, Raspberry Pi, IoT www.geekfactory.mx GEEK FACTORY INVIERTE TIEMPO Y RECURSOS EN DESARROLLAR ESTOS EJEMPLOS Y TUTORIALES. SI ENCUENTRAS ÚTIL ESTE CÓDIGO, CONSIDERA REALIZAR UNA COMPRA CON NOSOTROS. EJEMPLO DISPLAY LCD 16x2 1 Descripción: Ejemplo básico para el uso de un display LCD 16x2 con Arduino. En este ejemplo se muestra un texto que recorre la pantalla de un lado a otro. Este programa sirve para comprobar el correcto funcionamiento de las pantallas y permite conocer la funcionalidad básica de la librería LiquidCrystal. */ // incluir la librería en nuestro programa #include <LiquidCrystal.h> // constructor de la clase LiquidCrystal, se crea un objeto llamado "lcd" // mediante el cual se accede a toda la funcionalidad de la librería // aquí se configuran los pines para comunicarse con la pantalla LiquidCrystal lcd(7, 6, 5, 4, 3, 2); /** Función setup: se ejecuta una vez cuando encendemos el arduino */ void setup() { // indicar a la librería que tenemos conectada una pantalla de 16x2 lcd.begin(16, 2); // mover el cursor a la primera posición de la pantalla (0,0) // y al mismo tiempo borramos su contenido lcd.clear(); // 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 la posición actual del cursor lcd.print("GEEKFACTORY"); // esperar un segundo delay(1000); } /** Función loop: se ejecuta continuamente mientras el arduino permanece encendido */ void loop() { // en el ciclo principal solamente recorremos el mensaje de un lado a otro // variable utilizada en el control de ciclos int i; // desplazar el contenido de la pantalla 5 veces a la derecha for ( int i = 0; i < 5; i++ ) { lcd.scrollDisplayRight(); delay (1000); } // desplazar el contenido de la pantalla 5 veces a la izquierda for ( int i = 0; i < 5; i++ ) { lcd.scrollDisplayLeft(); delay (1000); } } |
Programa que muestra el valor de un sensor en la pantalla
Otro de los usos comunes para el display LCD 16×2 es mostrar el valor medido por algún sensor. El siguiente programa nos enseñará a desplegar el valor medido por un sensor 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 | /** Geek Factory - "Dale vuelo a tus proyectos" Tienda de electrónica, Arduino, Raspberry Pi, IoT www.geekfactory.mx GEEK FACTORY INVIERTE TIEMPO Y RECURSOS EN DESARROLLAR ESTOS EJEMPLOS Y TUTORIALES. SI ENCUENTRAS ÚTIL ESTE CÓDIGO, CONSIDERA REALIZAR UNA COMPRA CON NOSOTROS. EJEMPLO DISPLAY LCD 16x2 2 Descripción: Ejemplo básico para el uso de un display LCD 16x2 con Arduino. En este ejemplo se muestra el valor de un sensor en la pantalla. Utilizamos un potenciómetro para controlar el voltaje en el pin A0 y mostrar el valor leido por el ADC y también su equivalente en volts. */ // incluir la librería en nuestro programa #include <LiquidCrystal.h> // constructor de la clase LiquidCrystal, se crea un objeto llamado "lcd" // mediante el cual se accede a toda la funcionalidad de la librería // aquí se configuran los pines para comunicarse con la pantalla LiquidCrystal lcd(7, 6, 5, 4, 3, 2); /** Función setup: se ejecuta una vez cuando encendemos el arduino */ void setup() { // indicar a la librería que tenemos conectada una pantalla de 16x2 lcd.begin(16, 2); // mover el cursor a la primera posición de la pantalla (0,0) // y al mismo tiempo borramos su contenido lcd.clear(); // imprimir en la primera linea lcd.print(" GEEKFACTORY.MX "); // esperar dos segundos delay(2000); } /** Función loop: se ejecuta continuamente mientras el arduino permanece encendido */ void loop() { // borramos toda la pantalla para actualizarla por completo cada segundo lcd.clear(); // imprimir un encabezado en la pantalla lcd.print(" POTENCIOMETRO "); // realizar una lectura analógica en el pin A0 y convertir el valor // leido a voltaje (asumimos que el arduino se alimenta a 5 volts) unsigned int val = analogRead(A0); 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, justo después de la lectura del ADC lcd.setCursor(6, 1); lcd.print(volts, 1); // esperar un segundo delay (1000); } |
Caracteres personalizados en display LCD 16×2
Otro de los usos de la pantalla LCD de 16×2 con Arduino es mostrar información gráfica. En este ejemplo, te enseñamos cómo definir caracteres personalizados. Podemos utilizar esta característica de nuestro display para generar interfaces de usuario más amigables.
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 un arreglo en el lenguaje de programación C++ o C quedaría de la siguiente forma:
1 2 3 4 5 6 7 8 9 10 | byte smile[8] = { 0b00000000, 0b00001010, 0b00001010, 0b00001010, 0b00000000, 0b00010001, 0b00001110, 0b00000000, }; |
El programa completo para mostrar los caracteres personalizados quedaría como se muestra a continuació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 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 132 133 134 135 136 137 138 139 140 141 142 143 144 145 | /** Geek Factory - "Dale vuelo a tus proyectos" Tienda de electrónica, Arduino, Raspberry Pi, IoT www.geekfactory.mx GEEK FACTORY INVIERTE TIEMPO Y RECURSOS EN DESARROLLAR ESTOS EJEMPLOS Y TUTORIALES. SI ENCUENTRAS ÚTIL ESTE CÓDIGO, CONSIDERA REALIZAR UNA COMPRA CON NOSOTROS. EJEMPLO DISPLAY LCD 16x2 3 Descripción: Ejemplo básico para el uso de un display LCD 16x2 con Arduino. En este ejemplo se crean caracteres definidos por el usuario y se muestran dichos caracteres en la pantalla LCD. */ // incluir la librería en nuestro programa #include <LiquidCrystal.h> // constructor de la clase LiquidCrystal, se crea un objeto llamado "lcd" // mediante el cual se accede a toda la funcionalidad de la librería // aquí se configuran los pines para comunicarse con la pantalla LiquidCrystal lcd(12, 11, 5, 4, 3, 2); // definicion de arreglos con 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, }; /** Función setup: se ejecuta una vez cuando encendemos el arduino */ void setup() { // indicar a la librería 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); // mover el cursor a la primera posición de la pantalla (0,0) // y al mismo tiempo borramos su contenido lcd.clear(); // imprimir titulo en la primera linea lcd.print(" GEEKFACTORY.MX "); // mover el cursor a la segunda linea lcd.setCursor(0, 1); // mostramos los caracteres personalizados que creamos al inicio 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); } /** Función loop: se ejecuta continuamente mientras el arduino permanece encendido */ void loop() { // no hacemos nada en el loop } |
ALFOO –
Solo tienes una?
Anónimo –
Buen día, tenemos más en existencia, si requiere más por favor indíquenos la cantidad para modificar la publicación. El equipo de geek factory agradece su interés.