Como Poner Dibujos A LCD

Pantalla alfanumérica LCD 16X2 con
Arduino
by Admin | Oct 12, 2017 | Tutoriales Arduino | 26 comments
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.
Par esta experiencia, 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:
 Arduino UNO R3
 Protoboard de 830 puntos
 Cables para conexión
 Potenciómetro de 10K
 Pantalla LCD 16×2 compatible con HD4470
¿Cómo 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.
/**
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 <LiquidCrystal.h>
// 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:
/**
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.
*/

PANTALLA
void setup()
{
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.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:
/**
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.
*/

PANTALLA
// 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()
{
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
// 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
Pagina origen: https://www.geekfactory.mx/tutoriales/tutoriales-arduino/pantalla-lcd-16x2-

con-arduino/

Como Poner Dibujos A LCD

Cargado por

Copyright:

Formatos disponibles

Como Poner Dibujos A LCD

Cargado por

Información del documento

Título original

Derechos de autor

Formatos disponibles

Compartir este documento

Compartir o incrustar documentos

Opciones para compartir

¿Le pareció útil este documento?

¿Este contenido es inapropiado?

Copyright:

Formatos disponibles

Como Poner Dibujos A LCD

Cargado por

Copyright:

Formatos disponibles

Pantalla alfanumérica LCD 16X2 con

// CONSTRUCTOR PARA LA PANTALLA LCD 16X2

// DESPLAZAR LA PANTALLA A LA DERECHA 2 VECES

// DESPLAZAR LA PANTALLA A LA IZQUIERDA 2 VECES

Mostrar el valor de un sensor en la pantalla LCD

// CONSTRUCTOR PARA LA PANTALLA LCD 16X2

// REALIZAR LECTURA ANALOGICA EN PIN A0

// IMPRIMIR VALORES EN LA SEGUNDA LINEA, COMENZANDO POR EL VALOR

// IMPRIMIR EL VALOR EN VOLTAJE, DESPUES DE LA LECTURA DEL ADC

// ESPERAR UN SEGUNDO ANTES DE CONTUNUAR

Traducido a código en C quedaría de la siguiente forma:

EN ESTE EJEMPLO MOSTRAMOS COMO DEFINIR CARACTERES PERSONALIZADOS

// CONSTRUCTOR PARA LA PANTALLA LCD 16X2

// DEFINICION DE CARACTERES PERSONALIZADOS

// ENVIAR LOS MAPAS DE BITS AL CONTROLADOR DE PANTALLA

// LIMPIAR LA PANTALLA Y MOVER EL CURSOR A LA PRIMERA POSICION

Pagina origen: https://www.geekfactory.mx/tutoriales/tutoriales-arduino/pantalla-lcd-16x2-

También podría gustarte