Cómo usar una pantalla LCD en Arduino y configurarla bien [Guía completa]

Para los conocedores de las placas Arduino y cómo utilizarlas el conocimiento del uso de pantallas LCD en la misma es algo indispensable para crear proyectos de gran envergadura. Si no lo sabías, Arduino es una serie de microcontroladores que ha venido a suplantar a los antiguos por ofrecer mejores prestaciones y más elementos integrados además del CPU. Allí es donde entran las pantallas LCD para poder aprovechar de mostrar mensajes, datos de mediciones o cualquier otro carácter que se quiera. Es por ello que en esta oportunidad te explicaremos cómo usar una pantalla LCD en Arduino y a configurarla bien con esta guía completa.

¿Cuáles son los materiales necesarios para crear la pantalla?

Antes de adentrarnos más a fondo sobre cómo usar una pantalla LCD y cómo configurarla es necesario tener todos los elementos o materiales necesarios para hacer uso de la misma. La pantalla LCD es un elemento en sí que se debe tener para poder realizar el montaje del circuito básico.

• Protoboard.
• Placa Arduino UNO.
• Potenciómetro de 10 kΩ.
• Cables.
• Resistencia de 200 Ω.
• Pantalla LCD 2x16.

Para esta guía se utilizará una pantalla LCD típica de 2 filas y 16 caracteres por fila, sin embargo, existen otros tipos de pantallas LCD que se pueden utilizar de acuerdo a la necesidad que tengas o la disposición de la misma.

¿Qué tipos de pantallas LCD se pueden utilizar?

Por lo general, las pantallas LCD más utilizadas son las clásicas que ves con pantalla verde y que muestran caracteres de color oscuro. Sin embargo, el mercado de la electrónica ha ido en constante crecimiento a tal punto que se pueden encontrar más tipos de pantallas LCD. Cada uno tiene características especiales que las hacen más adecuadas para uno u otro proyecto.

De líneas

Este tipo de pantalla LCD es el más utilizado hoy en día por su facilidad de uso y su precio económico. Se denominan pantallas LCD de líneas porque de esta forma muestran los caracteres: a través de líneas, por lo general dos líneas con un máximo de 16 caracteres.

Son utilizadas para enseñar información especifica sin agregar más caracteres especiales por lo que son fáciles de leer. De esa forma son ideales para una gran variedad de proyectos como termostatos o detectores de humo.

Por puntos

Así como la pantalla anterior, las pantallas LCD por puntos cuentan con un marco definido para mostrar caracteres. Así mismo, pueden mostrar inclusive imágenes además de poder variar el tamaño de los caracteres.

La diferencia radica en que cuentan con una matriz de puntos que se pueden configurar de forma individual para mostrar texto e imágenes en cualquier parte de la pantalla. No todos los modelos por puntos permiten variar el tamaño de la letra.

Tipo TFT

Finalmente están las pantallas LCD tipo TFT las cuales son lo último en tecnología para proyectos Arduino que requieran mostrar información. Estas cuentan con píxeles que se pueden configurar de forma individual de manera que se pueden mostrar letras, números, imágenes y cualquier tipo de información.

Para que tengas una mejor idea, estas pantallas utilizan la misma tecnología que los televisores u ordenadores. Son medidas en pulgadas ya que pueden mostrar de todo en el tamaño que ofrezcan. Sus contras son que consumen más energía y son más costosas.

De estos tres tipos de pantallas LCD el más utilizado es el de líneas por ser económico, fácil de usar y tener un consumo energético menor, siendo el que utilizaremos en esta guía. En el caso de que presentes problemas con la placa Arduino o con la pantalla LCD al hacer la conexión siempre puedes diagnosticar, reparar y configurar los problemas o errores de un puerto USB.

Pasos para conectar Arduino a la pantalla LCD de forma correcta

Como mencionamos anteriormente, utilizaremos una pantalla LCD de 16x2. Para simplificar los pasos para conectar Arduino lo dividiremos en cuatro procesos de conexión.

• Conectar la pantalla LCD de 16x2 al Arduino de manera que se alimente hasta la iluminación LED.
• Conectar el potenciómetro para ajustar el contraste.
• Conectar las salidas de datos del Arduino a la pantalla (8 bits).
• Conectar los pines de control RS, E y RW.

En el primer paso debemos fijarnos en la polaridad de la conexión para no dañar la pantalla LCD. Seguidamente conectaremos los pines 5V y GND del Arduino al protoboard de modo que hagamos la conexión en los pines VSS(-), VDD(+), A(+) y K(-) de la pantalla LCD para alimentarla. Cabe destacar que la resistencia de 200 Ω se debe colocar en serie a la entrada de la alimentación de la pantalla, o sea, en serie con VDD(+).

Después, el segundo paso consistirá en conectar el potenciómetro de 10 kΩ donde los extremos del mismo irán al positivo y negativo de la alimentación. Por su parte, el cursor, o el pin del medio, irá conectado al pin VO de la pantalla LCD. Este pin es el número 3 y es el encargado del control del contraste. De esa manera se podrá regular el contraste de la pantalla LCD a través del potenciómetro.

Seguidamente tendremos que hacer las conexiones de los pines de datos que se mostrarán. En este caso haremos la conexión de 8 bits por lo que conectaremos los pines D0 hasta D7 con los pines 2 a 9 del Arduino.

Para finalizar haremos la conexión de los pines de control RS, E y RW con los pines 11, 12 y 13 del Arduino. Sin embargo, el pin RW puede omitirse en caso de querer ahorrar cables y tener una mejor presentación en el protoboard. Esta conexión no afectará en nada.

¿Cómo realizar la programación para iniciar a utilizarla?

Una vez tengamos hecha la conexión de forma correcta lo siguiente será crear el código de programación en el Arduino para que reconozca a la pantalla LCD. A continuación te enseñamos las líneas de código para iniciar a utilizar la pantalla:

1. #include  <LiquidCrystal.h> // Se incluye la librería de la pantalla LCD.
2. LiquidCrystal lcd(13, 12, 11, 9, 8, 7, 6, 5, 4, 3, 2); // Se activan los pines para la comunicación entre el Arduino y la pantalla.
3. void setup()
4. {
5. lcd.begin(16, 2); // Con esta línea se le hace saber al Arduino que la pantalla está conectada.
6. lcd.home(); // Esta línea coloca el cursor en la primera posición de la pantalla que sería (0,0).
7. lcd.print("Aprende cómo hacerlo"); // Mostramos el mensaje 'Aprende cómo hacerlo en la primera línea de la pantalla.
8. lcd.setCursor ( 0, 1 ); // Movemos el cursor a la segunda línea de la pantalla (1,0).
9. lcd.print("De forma sencilla"); // Imprimimos otro mensaje en la segunda línea.
10. delay(1000); // Un retraso de un segundo.
11. }
12. void loop()
13. {
14. // Este es el ciclo principal donde no colocaremos nada para simplificar el código.
15. }

De esta manera se puede comprobar la buena conexión de la pantalla LCD al Arduino. Al cargar este código y ejecutarlo se debería poder ver en la pantalla los mensajes 'Aprende cómo hacerlo' y 'De forma sencilla' uno encima de otro, ocupando las dos líneas de la pantalla.

En el caso de que no te haya quedado claro algo respecto a las conexiones o al código de programación, puedes revisar el tutorial de 'Hello World!' de Arduino donde encontrarás detalladamente esta información.

Por otro lado también es importante que para poder trabajar con Arduino se tenga actualizada la BIOS en tu PC en Windows 7 / 8 / 10 y puedes hacerlo a través de USB y desde internet.

Programación para poder mostrar el valor de un sensor

En el caso de que tengas un sensor a la mano y quieras aprovecharlo para implementarlo con la pantalla LCD, solo debes ejecutar las siguientes líneas de código para ello. En este caso se utilizará el potenciómetro para simular la entrada de un sensor.

1. #include  <LiquidCrystal.h> // Empezamos incluyendo la librería de la pantalla.
2. LiquidCrystal lcd(13, 12, 11, 9, 8, 7, 6, 5, 4, 3, 2); // Se configuran los pines de comunicación entre la pantalla y el Arduino.
3. void setup()
4. {
5. lcd.begin(16, 2); // Se inicia la comunicación.
6. lcd.clear(); // Se coloca el cursor en la posición inicial (0,0).
7. lcd.print(" Mostrar el valor de un sensor "); // Se imprime un mensaje inicial del proyecto.
8. delay(1000); // Se deja pasar un segundo.
9. }
10. void loop()
11. {
12. lcd.clear(); // Se limpia la pantalla.
13. lcd.print(" POTENCIOMETRO "); // Se imprime un encabezado de lo que se quiere mostrar.
14. unsigned int val = analogRead(A0); // Esta línea realiza la lectura analógica en el pin A0 donde está el potenciómetro.
15. float volts = (val * 5.0) / 1024.0; // Se convierte dicha señal en voltaje para imprimir.
16. lcd.setCursor(0, 1); // Se coloca el cursor en la segunda línea de la pantalla.
17. lcd.print(val); // Se imprime el valor directo que lee el convertidor analógico digital.
18. lcd.setCursor(6, 1); // Se mueve el cursor.
19. lcd.print(volts, 1); // Se imprime el valor leído en voltaje después de la lectura del convertidor analógico digital.
20. delay (1000); // Se espera un segundo antes de actualizar el valor.
21. }

De esta forma sencilla se puede mostrar el valor de un sensor colocando el pin donde se configure el convertidor analógico digital. Es por ello que la línea 14 del anterior código es muy importante para poder mostrar los datos que mida un sensor a través de una pantalla LCD.

¿Cómo enviar caracteres personalizados a la pantalla?

Con las pantallas LCD y una placa Arduino también se pueden crear caracteres personalizados sabiendo cómo hacerlo. Estos medios gráficos se pueden crear aprovechando la distribución de bytes de la pantalla. Cada carácter especial se define como un grupo de 8 bytes donde se debe llevar al lenguaje de programación C para poder mostrarlos en la pantalla LCD.

Para enviar caracteres personalizados a una pantalla LCD se debe escribir el siguiente código en Arduino de manera que se representen en código binario:

1. #include  <LiquidCrystal.h> // Empezamos incluyendo la librería de la pantalla.
2. LiquidCrystal lcd(13, 12, 11, 9, 8, 7, 6, 5, 4, 3, 2); // Se configuran los pines de comunicación entre la pantalla y el Arduino.
3. byte smile[8] = { // En esta línea empezamos a definir los caracteres personalizados.
   0b00000000,
   0b00001010,
   0b00001010,
   0b00001010,
   0b00000000,
   0b00010001,
   0b00001110,
   0b00000000,
   };
4. byte sad[8] = {
   0b00000000,
   0b00001010,
   0b00001010,
   0b00001010,
   0b00000000,
   0b00001110,
   0b00010001,
   0b00000000,
5. };
6. byte body[8] = {
   0b00001110,
   0b00001110,
   0b00000100,
   0b00011111,
   0b00000100,
   0b00001010,
   0b00010001,
   0b00000000,
7. };
8. void setup()
9. {
10. lcd.begin(16, 2); // Iniciamos la pantalla LCD.
11. lcd.createChar (0, smile); // A partir de esta línea se empiezan a mandar los mapas de bits a la pantalla LCD.
12. lcd.createChar (1, sad);
13. lcd.createChar (2, body);
14. lcd.createChar (3, arrowr);
15. lcd.createChar (4, arrowu);
16. lcd.createChar (5, arrowd);
17. lcd.createChar (6, arrowl);
18. lcd.clear(); // Se limpia la pantalla y se mueve el cursor a la posición inicial.
19. lcd.print(" Aprende cómo hacerlo "); // Se imprime el encabezado.
20. lcd.setCursor(0, 1); // Se mueve el cursor a la segunda línea.
21. lcd.write((byte)0); // A partir de esta línea se empiezan a escribir los caracteres personalizados en la pantalla.
22. lcd.write((byte)1);
23. lcd.write((byte)2);
24. lcd.write((byte)3);
25. lcd.write((byte)4);
26. lcd.write((byte)5);
27. lcd.write((byte)6);
28. }
29. void loop()
30. {
31. // No se hace nada en el loop principal.
32. }

De esa manera se pueden crear caracteres personalizados aprovechando la representación en binario de cada uno. Por otro lado también es bueno ampliar o aumentar la memoria RAM de la PC para mejorar su rendimiento y poder trabajar en el IDE de Arduino de mejor manera.

Proyectos sencillos para realizar con Arduino y la pantalla

Ahora que te hemos enseñado cómo configurar una pantalla LCD con una placa Arduino de manera sencilla, que tienes las herramientas y los comandos necesarios, es posible empezar desde cero proyectos sencillos. Acá te mencionamos dos que puedes realizar sin problemas:

Estación meteorológica

Es uno de los proyectos más fáciles que se pueden hacer en Arduino con una pantalla LCD. Te recomendamos que lo intentes hacer si estás empezando con la programación con Arduino.

Para hacerlo necesitarás una placa Adafruit HUZZAH así como una pequeña pantalla OLED. Las conexiones y código de programación son similares a las antes expuestas para mostrar los datos de un sensor. De esa forma podrás crear tu propia estación meteorológica.

Un detector de humo

Para este proyecto necesitarás una placa Arduino con un sensor MQ-2. Al igual que el proyecto anterior solamente tendrás que configurar las entradas del sensor de modo que muestre una alarma en la pantalla LCD. Así mismo puede añadir un altavoz o buzzer para que suene al recibir la señal del sensor.

Este es uno de los proyectos que más utilidad se le puede dar por ser posible instalarlo en cualquier sitio donde se requiera una detector de humo. Espero que a partir de ahora puedas crear tus propios proyectos implementando una pantalla LCD junto a una placa Arduino, ¡hasta la próxima!