Guía Completa: Escribe en Pantallas LCD con Arduino

La computación física nos permite tender puentes entre el mundo digital y el entorno real, y para ello, los sensores y actuadores son herramientas indispensables. Al igual que en un ordenador interactuamos con teclados y pantallas, en el universo de las placas microcontroladoras como Arduino, contamos con componentes específicos que cumplen funciones similares. Uno de los actuadores más versátiles y ampliamente utilizados es la pantalla LCD, un dispositivo que transforma las señales eléctricas de tu placa en información visual clara y comprensible para el ser humano. Dominar tanto sus conexiones como su programación es crucial, ya que el LCD se convierte en una ventana invaluable para mostrar datos en tiempo real, desde lecturas de temperatura y humedad hasta presión y voltaje, abriendo un abanico de posibilidades para tus proyectos.

¿Qué es una Pantalla LCD (Liquid Crystal Display)?

El término LCD es el acrónimo de Liquid Crystal Display, que en español se traduce como Pantalla de Cristal Líquido. Aunque pueda parecer una tecnología moderna, el LCD ha estado presente en nuestras vidas durante mucho tiempo. Basta con recordar los icónicos relojes Casio o las calculadoras de bolsillo que nos acompañaron en nuestras clases de matemáticas. Su omnipresencia a lo largo de las décadas es testimonio de su eficacia y durabilidad.

Tradicionalmente, estamos familiarizados con los tres estados fundamentales de la materia: sólido, líquido y gaseoso. Sin embargo, ya en el siglo XIX, se descubrió que la materia podía existir en otros estados intermedios. El cristal líquido es uno de ellos, posicionándose en una fase que se encuentra entre el estado sólido y el líquido, poseyendo propiedades únicas que permiten su manipulación para fines de visualización.

No es el objetivo de este artículo adentrarnos en la compleja física que subyace al funcionamiento de los LCDs. Baste decir que estas pantallas aprovechan las propiedades de la luz polarizada para revelar información visual. Mediante una ingeniosa disposición de filtros y una iluminación de fondo, se consigue que los caracteres y gráficos se hagan visibles para el ojo humano.

Existe una amplia variedad de pantallas LCD compatibles con Arduino, que se diferencian no solo por sus funcionalidades adicionales, sino principalmente por su tamaño y capacidad de visualización, expresada en el número de filas y columnas. Por ejemplo, una pantalla LCD de 16x1 puede mostrar una fila de 16 caracteres simultáneamente, mientras que una de 20x4 ofrece cuatro filas de 20 caracteres cada una, permitiendo una mayor densidad de información.

Para los ejemplos prácticos de este artículo, nos centraremos en un LCD de 16x2, que es uno de los modelos más comunes y accesibles. Esto significa que tendremos dos filas, cada una capaz de mostrar hasta 16 caracteres, lo cual es suficiente para una gran cantidad de aplicaciones básicas y proyectos de iniciación.

Conexiones Esenciales del LCD con Arduino

La mayoría de las pantallas LCD modernas que encontrarás en el mercado suelen venir equipadas con una hilera de dieciséis pines. Los primeros catorce pines son fundamentales para controlar la visualización de los caracteres, mientras que los dos últimos están dedicados a la alimentación y control de la iluminación de fondo de la pantalla.

Tabla de Pines del LCD 16x2

Es importante tener en cuenta la disposición física de estos pines. Cuando conectes el LCD a una protoboard, es probable que los pines estén invertidos horizontalmente con respecto a la imagen que podrías encontrar en diagramas, así que asegúrate de verificar la numeración.

Componentes Necesarios y Montaje del Circuito

Una vez familiarizados con la función de cada pin, el siguiente paso es ensamblar el circuito básico. Para este proyecto, necesitarás los siguientes materiales:

• Una placa Arduino UNO o similar.
• Una protoboard.
• Cables de conexión (jumpers).
• Una pantalla LCD 16x2.
• Un potenciómetro de 10 kΩ.
• Una resistencia de 200 Ω.

El cableado es relativamente sencillo. La resistencia de 200 Ω se utiliza para regular el voltaje de entrada de la alimentación del LCD, protegiéndolo de posibles sobrecargas. El potenciómetro de 10 kΩ es crucial, ya que permite ajustar el contraste de la pantalla, lo cual es fundamental para que los caracteres sean visibles y legibles en diferentes condiciones de luz. Los potenciómetros son resistencias variables que modifican su valor al girar un regulador, ofreciendo un control preciso sobre esta característica.

Para la conexión, sigue este esquema general:

• Pin 1 (GND) del LCD a GND de Arduino.
• Pin 2 (VCC) del LCD a 5V de Arduino.
• Pin 3 (Vo) del LCD al pin central del potenciómetro de 10kΩ. Los extremos del potenciómetro van a 5V y GND.
• Pin 4 (RS) del LCD a un pin digital de Arduino (ej. 12).
• Pin 5 (RW) del LCD a GND. (Para escritura, no necesitamos lectura).
• Pin 6 (Enable) del LCD a un pin digital de Arduino (ej. 11).
• Pines 7-10 del LCD (D0-D3) quedan sin conectar (usaremos modo de 4 bits).
• Pines 11-14 del LCD (D4-D7) a pines digitales de Arduino (ej. 5, 4, 3, 2 respectivamente).
• Pin 15 (LED+) del LCD a 5V de Arduino a través de la resistencia de 200Ω.
• Pin 16 (LED-) del LCD a GND de Arduino.

Programando tu LCD: Primeros Pasos con Arduino

Para interactuar con la pantalla LCD desde Arduino, haremos uso de una librería muy conveniente llamada LiquidCrystal.h. La gran ventaja es que esta librería viene preinstalada en el entorno de desarrollo oficial de Arduino (IDE), lo que significa que no tendrás que realizar ninguna instalación adicional. Simplemente necesitas incluirla en tu sketch (programa) para poder utilizar sus funciones.

A continuación, exploraremos un ejemplo básico para escribir un texto simple en el LCD, desglosando cada parte del código para una comprensión clara. Nuestro objetivo será mostrar la frase "Hola Mundo!!!!!!" en la primera fila y "Probando el LCD" en la segunda fila de nuestra pantalla 16x2.

Importaciones, Declaraciones de Constantes y Variables

Lo primero es incluir la librería LiquidCrystal.h:

// Incluimos la libreria externa para poder utilizarla #include <LiquidCrystal.h> // Entre los simbolos <> buscara en la carpeta de librerias configurada 

La librería LiquidCrystal.h no está limitada a un LCD de 16x2; es compatible con diferentes configuraciones de filas y columnas. Por ello, es buena práctica definir las dimensiones de nuestra pantalla mediante constantes:

// Definimos las constantes para las dimensiones del LCD #define COLS 16 // Columnas del LCD #define ROWS 2 // Filas del LCD 

Una vez que la librería ha sido incluida, debemos inicializarla indicando los pines de Arduino a los que hemos conectado el LCD. Esto se hace a través del constructor LiquidCrystal(...). Esta función puede aceptar diferentes números de parámetros dependiendo de la configuración (por ejemplo, si usas el modo de 4 bits o 8 bits, o si el pin RW está conectado). Para nuestra configuración básica (modo de 4 bits, RW a GND), pasaremos los pines RS, Enable, y los cuatro pines de datos (D4, D5, D6, D7):

// Inicializamos la libreria indicando los pins de la interfaz LiquidCrystal lcd(12, 11, 5, 4, 3, 2); 

En el ejemplo anterior, 12 corresponde al pin de Arduino conectado a RS, 11 al pin conectado a Enable, y 5, 4, 3, 2 a los pines de datos D4, D5, D6 y D7 respectivamente. La palabra lcd es el nombre que le asignamos a esta instancia de la clase LiquidCrystal, y puedes modificarlo siempre que sigas las reglas de nomenclatura del lenguaje y no uses palabras reservadas.

Función setup()

La función setup() se ejecuta una única vez al inicio del programa y es ideal para realizar configuraciones iniciales. En nuestro caso, configuraremos el monitor serie (útil para depuración) e inicializaremos la interfaz del LCD, especificando sus dimensiones (16 columnas y 2 filas):

void setup() { // Configuracion monitor serie Serial.begin(9600); // Configuramos las filas y las columnas del LCD lcd.begin(COLS, ROWS); } 

Función loop()

La función loop() se ejecuta repetidamente después de setup(), conteniendo la lógica principal de nuestro programa. Para escribir en la pantalla LCD, utilizaremos tres métodos clave de la librería LiquidCrystal.h:

• clear(): Limpia completamente la pantalla, borrando cualquier texto o carácter previamente mostrado.
• setCursor(columna, fila): Posiciona el cursor en una ubicación específica de la pantalla. La escritura posterior comenzará a partir de esta posición. Es importante recordar que las columnas y filas se indexan desde 0 (índice cero). Es decir, la primera columna es la 0, y la primera fila es la 0.
• print(datos): Escribe los datos proporcionados (generalmente una cadena de caracteres o String) en la posición actual del cursor.

Comenzamos la función loop() limpiando la pantalla, posicionando el cursor en la primera columna (0) de la primera fila (0), y luego escribiendo nuestro primer mensaje:

void loop() { // Limpiamos la pantalla lcd.clear(); // Situamos el cursor en la columna 0 fila 0 lcd.setCursor(0,0); // Escribimos Hola Mundo!!!!!! lcd.print("Hola Mundo!!!!!!"); 

Para escribir el segundo texto, simplemente movemos el cursor a la nueva posición deseada. Queremos que aparezca justo debajo del primer mensaje, así que lo situamos en la fila 1 (la segunda fila) y la columna 0 (la primera columna). Después, escribimos el segundo texto. Finalmente, añadimos un delay para que el texto permanezca visible por un tiempo antes de que el ciclo se repita. Aunque no es estrictamente necesario para la funcionalidad de escritura, ayuda a la visualización y evita un parpadeo excesivo.

 // Situamos el cursor en la columna 0 fila 1 lcd.setCursor(0,1); // Escribimos Probando el LCD. lcd.print("Probando el LCD."); // Esperamos 2 segundos (2000 milisegundos) delay(2000); } 

Es importante notar que entre las dos llamadas a print(), no se realiza un clear(). Si lo hiciéramos, el primer texto se borraría antes de que el segundo fuera escrito, impidiendo que ambos mensajes se muestren simultáneamente.

Movimiento de Texto: Creando Efectos Dinámicos en el LCD

Más allá de simplemente mostrar texto estático, las pantallas LCD con Arduino nos permiten crear efectos dinámicos, como el desplazamiento horizontal de texto. Este tipo de efectos añade un toque profesional y atractivo a tus proyectos. Para lograrlo, necesitaremos aplicar conocimientos básicos de programación, haciendo uso de bucles de repetición y funciones de manipulación de cadenas de caracteres. Nuestro objetivo será desplazar un texto de izquierda a derecha en la primera fila (índice 0) y de derecha a izquierda en la segunda fila (índice 1).

El Algoritmo del Movimiento

Antes de sumergirnos en el código, es fundamental plantear un algoritmo claro. Esto no solo nos ahorrará tiempo, sino que también nos ayudará a estructurar la lógica de manera eficiente. No es necesario detallar variables o constantes en este punto, solo la secuencia de pasos:

1. Obtener el tamaño del texto a desplazar.
2. Entrada del texto por la derecha (primera fila):
   • Bucle que recorre los caracteres de mayor a menor índice.
   • Obtener un trozo de la subcadena desde el índice actual hasta el final.
   • Limpiar el LCD.
   • Situar el cursor en la columna 0, fila 0.
   • Mostrar el trozo de texto en la pantalla.
   • Esperar un tiempo (delay).
3. Desplazamiento de texto hacia la derecha (primera fila):
   • Bucle que recorre todas las columnas, desde la segunda hasta la última más uno (para que desaparezca).
   • Limpiar el LCD.
   • Situar el cursor en la columna correspondiente, fila 0.
   • Mostrar el texto completo en la pantalla.
   • Esperar un tiempo (delay).
4. Desplazamiento de texto hacia la izquierda (segunda fila):
   • Bucle que recorre las columnas desde la última más uno hasta la columna 1 (en sentido inverso).
   • Limpiar el LCD.
   • Situar el cursor en la columna correspondiente, fila 1.
   • Mostrar el texto completo en la pantalla.
   • Esperar un tiempo (delay).
5. Salida de texto por la izquierda (segunda fila):
   • Bucle que recorre los caracteres de menor a mayor índice.
   • Obtener un trozo de la subcadena desde el índice actual hasta el final.
   • Limpiar el LCD.
   • Situar el cursor en la columna 0, fila 1.
   • Mostrar el trozo de texto en la pantalla.
   • Esperar un tiempo (delay).

Este algoritmo, aunque parece complejo, se divide lógicamente en cuatro bloques principales: dos para el desplazamiento hacia la derecha y dos para el desplazamiento hacia la izquierda, creando un efecto de "vaivén" o aparición/desaparición controlada.

Código para el Texto en Movimiento con LCD y Arduino

Ahora, transformemos nuestro algoritmo en código Arduino. Es una excelente práctica intentar codificarlo por tu cuenta antes de revisar la solución; los errores son parte del aprendizaje y te ayudarán a consolidar la experiencia.

Declaración de Constantes y Variables

Además de las constantes de filas y columnas, introduciremos una constante VELOCIDAD para controlar la rapidez del desplazamiento, y una variable String para el texto que deseamos animar:

// Incluimos la libreria externa para poder utilizarla #include <LiquidCrystal.h> // Entre los simbolos <> buscara en la carpeta de librerias configurada // Definimos las constantes #define COLS 16 // Columnas del LCD #define ROWS 2 // Filas del LCD #define VELOCIDAD 300 // Velocidad a la que se mueve el texto (milisegundos) // Inicializamos la libreria indicando los pins de la interfaz LiquidCrystal lcd(12, 11, 5, 4, 3, 2); // Texto a desplazar String texto_fila = "Programarfacil.com"; 

Función setup() (Igual que en el ejemplo básico)

void setup() { // Configuracion monitor serie Serial.begin(9600); // Configuramos las filas y las columnas del LCD lcd.begin(COLS, ROWS); } 

Función loop() (Lógica del Movimiento)

Aquí reside la lógica principal del movimiento. Primero, obtenemos la longitud del texto usando length(), lo cual es esencial para controlar los bucles de desplazamiento. Recuerda que, debido al índice cero, si un texto tiene N caracteres, sus índices van de 0 a N-1.

void loop() { // Obtenemos el tamaño del texto int tam_texto = texto_fila.length(); 

Entrada del texto por la derecha (aparecer): Para simular que el texto "entra" por la derecha, no movemos el cursor. En su lugar, mostramos progresivamente trozos más grandes del texto, comenzando por el final. La función substring(numero) es clave aquí, ya que devuelve una parte de la cadena original a partir del índice especificado. Por ejemplo, "Hola Mundo".substring(2) devolvería "la Mundo".

 for(int i = tam_texto; i > 0 ; i--) { String texto = texto_fila.substring(i-1); // Limpiamos pantalla lcd.clear(); //Situamos el cursor en la primera columna (0) de la primera fila (0) lcd.setCursor(0, 0); // Escribimos el trozo de texto lcd.print(texto); // Esperamos para controlar la velocidad delay(VELOCIDAD); } 

Desplazamiento del texto hacia la derecha (mover): Una vez que el texto ha aparecido completamente, lo desplazamos a través de la pantalla. Aquí sí movemos el cursor (setCursor(i, 0)) en cada iteración del bucle, mostrando el texto completo en diferentes posiciones. El bucle va desde la columna 1 hasta la columna 16 (o incluso más allá para asegurar que desaparezca por completo).

 // Desplazamos el texto hacia la derecha for(int i = 1; i <= 16; i++) { // Recorre todas las columnas del LCD lcd.clear(); lcd.setCursor(i, 0); lcd.print(texto_fila); delay(VELOCIDAD); } 

Desplazamiento del texto hacia la izquierda (mover en segunda fila): Una vez que el texto ha desaparecido por la derecha, lo hacemos aparecer en la segunda fila y lo movemos de derecha a izquierda. La lógica es similar al desplazamiento hacia la derecha, pero el bucle de i va en sentido inverso y el cursor se sitúa en la fila 1.

 // Desplazamos el texto hacia la izquierda en la segunda fila for(int i = 16; i >= 0; i--) { // Recorre las columnas en sentido inverso (hasta 0 para que empiece a salir) lcd.clear(); lcd.setCursor(i, 1); lcd.print(texto_fila); delay(VELOCIDAD); } 

Salida del texto por la izquierda (desaparecer): Finalmente, simulamos que el texto desaparece por la izquierda en la segunda fila. De nuevo, usamos substring(), pero esta vez para mostrar trozos de texto que se van acortando desde el inicio, dando la sensación de que se desvanece.

 // Mostramos salida del texto por la izquierda for(int i = 1; i <= tam_texto ; i++) { String texto = texto_fila.substring(i-1); lcd.clear(); lcd.setCursor(0, 1); lcd.print(texto); delay(VELOCIDAD); } } // Fin de la funcion loop() 

Código Completo del Ejemplo Avanzado

Para tu comodidad y referencia, a continuación te proporcionamos el código completo del ejemplo avanzado de texto en movimiento. Puedes copiarlo directamente en tu IDE de Arduino, compilarlo y cargarlo en tu placa para ver el efecto en acción.

// Incluimos la libreria externa para poder utilizarla #include <LiquidCrystal.h> // Definimos las constantes #define COLS 16 // Columnas del LCD #define ROWS 2 // Filas del LCD #define VELOCIDAD 300 // Velocidad a la que se mueve el texto (milisegundos) // Inicializamos la libreria indicando los pins de la interfaz // LiquidCrystal lcd(RS, Enable, D4, D5, D6, D7); LiquidCrystal lcd(12, 11, 5, 4, 3, 2); // Texto a desplazar String texto_fila = "Programarfacil.com"; void setup() { // Configuracion monitor serie (opcional, para depuracion) Serial.begin(9600); // Configuramos las filas y las columnas del LCD lcd.begin(COLS, ROWS); } void loop() { // Obtenemos el tamaño del texto int tam_texto = texto_fila.length(); // --- Bloque 1: Entrada del texto por la derecha (primera fila) --- for(int i = tam_texto; i > 0 ; i--) { String texto = texto_fila.substring(i-1); lcd.clear(); lcd.setCursor(0, 0); lcd.print(texto); delay(VELOCIDAD); } // --- Bloque 2: Desplazamiento del texto hacia la derecha (primera fila) --- for(int i = 1; i <= COLS; i++) { // Recorre todas las columnas del LCD lcd.clear(); lcd.setCursor(i, 0); lcd.print(texto_fila); delay(VELOCIDAD); } // --- Bloque 3: Desplazamiento del texto hacia la izquierda (segunda fila) --- for(int i = COLS; i >= 0; i--) { // Recorre las columnas en sentido inverso lcd.clear(); lcd.setCursor(i, 1); lcd.print(texto_fila); delay(VELOCIDAD); } // --- Bloque 4: Salida del texto por la izquierda (segunda fila) --- for(int i = 1; i <= tam_texto ; i++) { String texto = texto_fila.substring(i-1); lcd.clear(); lcd.setCursor(0, 1); lcd.print(texto); delay(VELOCIDAD); } } 

Preguntas Frecuentes (FAQ) sobre LCDs con Arduino

¿Por qué mi pantalla LCD no muestra nada o solo cuadrados negros?

Esto es un problema común y generalmente se debe a un ajuste incorrecto del contraste o a una conexión errónea. Asegúrate de que el potenciómetro de 10 kΩ esté correctamente conectado y gíralo lentamente para ajustar el contraste. Si ves cuadrados negros, significa que el LCD está recibiendo energía, pero el contraste no es el adecuado o no hay datos siendo enviados. Revisa también las conexiones de los pines de datos (D4-D7) y los pines RS y Enable.

¿Puedo usar una pantalla LCD de diferente tamaño, como una 20x4, con el mismo código?

Sí, la librería LiquidCrystal.h es compatible con diferentes tamaños de LCD. Lo único que necesitarías cambiar en el código son las constantes COLS y ROWS para que coincidan con las dimensiones de tu nueva pantalla (por ejemplo, #define COLS 20 y #define ROWS 4 para una 20x4). Las funciones de escritura (print()) y posicionamiento (setCursor()) se adaptarán automáticamente.

¿Cómo ajusto el brillo de la luz de fondo del LCD?

El brillo de la luz de fondo del LCD se controla típicamente a través de la resistencia conectada al pin 15 (LED+). Si deseas ajustar el brillo, puedes reemplazar la resistencia fija de 200 Ω por un potenciómetro (por ejemplo, de 1 kΩ) o conectar el pin 15 a un pin PWM (Pulse Width Modulation) de Arduino y controlarlo por software mediante la función analogWrite().

¿Qué significa "índice cero" en la programación de LCDs?

El "índice cero" es una convención común en muchos lenguajes de programación (incluido Arduino/C++). Significa que el primer elemento de una secuencia (como las columnas y filas de un LCD o los caracteres de una cadena de texto) se referencia con el número 0, no con el 1. Así, la primera columna es la 0, la segunda la 1, y así sucesivamente. Esto es crucial al usar funciones como setCursor(columna, fila) o substring().

¿Es difícil aprender a programar pantallas LCD con Arduino?

No, con los ejemplos y explicaciones detalladas proporcionados, aprender a programar pantallas LCD con Arduino es bastante accesible. Los conceptos básicos de conexión y escritura son sencillos, y las funciones de la librería LiquidCrystal.h simplifican mucho el proceso. La clave está en practicar, probar los ejemplos y experimentar con tus propias ideas.

Conclusión

Las pantallas LCD son componentes increíblemente útiles en el mundo de la electrónica y la computación física con Arduino. Ofrecen una forma sencilla y efectiva de visualizar datos y proporcionar retroalimentación al usuario, transformando proyectos estáticos en interfaces interactivas y dinámicas. Desde la simple visualización de "Hola Mundo" hasta complejos desplazamientos de texto, hemos cubierto los fundamentos esenciales para que puedas empezar a integrar estos displays en tus propias creaciones. Con la información sobre conexiones, montaje de circuitos y ejemplos de código, estás listo para dar un paso más en tus habilidades de programación y hardware. ¡Anímate a experimentar y ver cómo tus datos cobran vida en la pantalla!

Si quieres conocer otros artículos parecidos a Guía Completa: Escribe en Pantallas LCD con Arduino puedes visitar la categoría Librerías.