Texto en movimiento en un LCD con Arduino Deja un comentario
Dentro de la computación física, tenemos sensores y actuadores. Estos componentes son las interfaces hardware que ponen en contacto el mundo físico con el mundo virtual. Al igual que con los ordenadores tenemos teclado, ratón, altavoces, etc…, con las placas microcontroladoras como Arduino, tenemos hardware que harán la misma función. En este caso vamos a ver un actuador, una pantalla LCD con Arduino.
Este componente se encarga de convertir las señales eléctricas de la placa en información visual fácilmente entendible por los seres humanos. Debemos de dominar tanto la conexiones como la programación de la pantalla LCD con Arduino ya que es un componente muy útil en muchos proyectos. La gran ventaja es que gracias a la pantalla LCD, podremos mostrar información de datos como temperatura, humedad, presión o voltaje.
LCD Liquid Crystal Display
LCD es el acrónimo de Liquid Crystal Display (en español Pantalla de Cristal Líquido). No podemos considerar que se trate de una tecnología novedosa. El LCD lleva con nosotros mucho tiempo, solo tenemos que echar la mirada hacia atrás y recordar esos relojes Casio o las calculadoras que llevamos a clase de matemáticas.
Estamos acostumbrados a que la materia pueda estar en estado sólido, líquido o gaseoso, los llamados estados de la materia. Pero ya en el siglo XIX se descubrió que había más estados en los que podía encontrarse la materia. El cristal líquido se encuentra en algún lugar entre el sólido y líquido.
No es el objetivo de este artículo explicar la física involucrada detrás de los LCD, solo decir que utiliza las propiedades de la luz polarizada para mostrarnos la información en una pantalla. A partir de una serie de filtros, se consigue mostrar la información gracias a la iluminación de fondo.
Hay una amplia gama de pantallas LCDs que podemos utilizar con Arduino. Aparte de las funcionalidades extra que nos puedan dar cada una de ellas, las podemos diferenciar por el número de filas y columnas, su tamaño.
Por ejemplo, una pantalla LCD de 16×1 tendrá una fila de 16 caracteres es decir, solo podremos mostrar 16 caracteres simultáneamente, al igual que un LCD de 20×4 tendrá 4 filas de 20 caracteres cada una.
En este artículo vamos a trabajar con un LCD típico, de 16×2. Esto significa que vamos a poder mostrar 16 caracteres en la primera fila y los mismos en la segunda fila.
Conexiones de un LCD con Arduino
La mayoría de las pantallas LCD que se están haciendo ahora, vienen con una fila de dieciséis pines. Los primeros catorce pines se utilizan para controlar la visualización. Los dos últimos son para la iluminación de fondo.
| Pin | Función |
|---|---|
| 1 | GND (Tierra) |
| 2 | 5 Voltios |
| 3 | Control de contraste pantalla |
| 4 | RS – Selector entre comandos y datos |
| 5 | RW – Escritura y lectura de comandos y datos |
| 6 | Sincronización de lectura de datos |
| 7-14 | Pines de datos de 8-bit |
| 15 | Alimentación luz de fondo (5V) |
| 16 | GND (Tierra) luz de fondo (0V) |
En la siguiente imagen te muestro la correspondencia con los pines físicos del LCD.
Esta imagen muestra la parte de abajo del LCD. Cuando lo conectes a la protoboard los pines estarán invertidos horizontalmente.
Montando el circuito
Una vez conocemos los conectores, ya podemos montar el circuito básico. El material que vamos a utilizar es el siguiente
- Arduino UNO o similiar
- Protoboard
- Cables
- Pantalla LCD 16X2
- Potenciómetro de 10 kΩ
- Resistencia 200 Ω
En la siguiente imagen te muestro cómo hacer el cableado.
Como puedes comprobar, el circuito es muy sencillo. La resistencia de 200 Ω permite regular el voltaje a la entrada de la alimentación del LCD. El potenciómetro se utiliza para regular el contrastes de la pantalla.
Es muy importante que el potenciómetro sea de 10 kΩ. Los potenciómetros son resistencias variables es decir, que cambian el valor de resistencia al girar un regulador.
Ejemplo básico LCD con Arduino
Para programar con el código nativo de Arduino, vamos a utilizar una librería que nos hará más fácil el desarrollo. Esta librería es LiquidCrystal.h. No hace falta instalarla en el entorno de desarrollo oficial ya que viene por defecto. Lo único que tenemos que hacer es añadirla como un include en nuestro programa o sketch. Vamos a ver un ejemplo muy simple donde escribamos un texto en el LCD.
En este ejemplo vamos a escribir la frase “Hola Mundo!!!!!!” en la primera fila y “Probando el LCD” en la segunda fila. Vamos a ir viendo el código parte por parte así quedará más claro.
Importaciones, declaraciones de constantes y variables
Importamos la librería LiquidCrystal.h
|
// Incluímos la libreria externa para poder utilizarla #include // Entre los símbolos <> buscará en la carpeta de librerías configurada |
La librería LyquidCrystal.h no es exclusiva para un LCD de 16×2. También puede ser utilizada por otro tipo de LCDs con diferente número de filas y columnas. En las siguientes líneas de código vamos a definir dos constantes que nos indiquen las filas y columnas de nuestro LCD.
|
// Definimos las constantes #define COLS 16 // Columnas del LCD #define ROWS 2 // Filas del LCD |
Una vez incluida, debemos indicar los pines que vamos a utilizar para enviar los datos. esto lo hacemos a través del constructor LyquidCrystal(…). Esta función permite diferente número de parámetros que dependerá de la configuración que estemos utilizando. En la llamada más básica, la que vamos a utilizar, debemos pasar como parámetros el RS, la sincronización, y los 4 pines para enviar datos. La función quedaría de la siguiente manera LyquidCrystal(RW, sincronización, d4, d5, d6, d7). Si sustituimos estos datos con los pines de Arduino tenemos lo siguiente.
|
// Lo primero is inicializar la librería indicando los pins de la interfaz LiquidCrystal lcd(12, 11, 5, 4, 3, 2); |
Donde 12 es el pin de Arduino donde hemos conectado el pin RW, el pin 11 es el de sincronización y el 5, 4, 3 y 2 son los pines correspondientes a los datos.
La palabra lcd es el nombre que le vamos a dar a esta variable (clase). Este nombre puede ser modificado siguiendo las reglas del lenguaje y no utilizando palabras reservadas.
Función setup()
Con esto ya podemos pasar a la función setup(). Esta función nos sirve para hacer una configuración inicial en nuestros programas. Lo primero que hacemos es configurar el monitor serie y luego inicializamos la interfaz del LCD con Arduino y especificamos las dimensiones (16 columnas y 2 filas).
|
void setup() { // Configuración monitor serie Serial.begin(9600); // Configuramos las filas y las columnas del LCD en este caso 16 columnas y 2 filas lcd.begin(COLS, ROWS); } |
Función loop()
Ahora ya podemos empezar a escribir en la pantalla del LCD. Para ello vamos a utilizar tres métodos:
- clear(): limpia la pantalla.
- setCursor(columna, fila): sitúa el cursor en una columna y una fila para después escribir a partir de esa posición.
- print(datos): escribe en la posición definida por setCursor(columna, fila) los datos. Normalmente los datos son una cadena de caracteres (String).
setCursor comienza desde 0 es decir, si queremos escribir en la columna 1 fila 1 debemos poner setCursor(0,0). Esta característica de un lenguaje se suele llamar índice cero (del inglés zero index).
Comenzamos la función loop(…) donde lo primero que hacemos es limpiar el LCD, situar el cursor en la columna 0 (sería la primera columna) y la fila 0 (sería la primera fila). Por último escribimos el primer texto “Hola Mundo!!!!!!”.
|
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, tenemos que mover el cursor a la nueva posición. Queremos que se sitúe justo debajo así que movemos a la siguiente fila (fila 1 que corresponde con la segunda fila) y la columna será la 0 (primera columna). Después escribimos el texto. Por último ponemos un delay() (esperar un tiempo) más que nada para que no esté constantemente mandando datos. Esto último no sería necesario.
|
// 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 igual a 2000 milisegundos delay(2000); } |
Entre las dos llamadas de la función print(), no se realiza el clear ya que esto supondría borrar lo anteriormente escrito.
Moviendo el texto horizontalmente en un LCD con Arduino
En el siguiente ejemplo vamos a ver cómo podemos mover el texto de forma horizontal. Para realizar este ejemplo es importante tener ciertos conocimientos de programación ya que vamos a utilizar bucles de repetición y funciones de caracteres. El fin es poder desplazar un texto en horizontal de izquierda a derecha en la fila 1 (índice 0) y de derecha a izquierda en la fila 2 (índice 1).
El algoritmo
Antes de empezar a programar, es conveniente plantear el algoritmo. Esto nos ahorrará tiempo a la hora de codificar con el lenguaje nativo de Arduino. Desarrollaremos la idea en sucesivos pasos bien estructurados y ordenados. En este punto, no hay que profundizar en cuántas variables o constantes necesito. Lo único que debemos plasmar son la secuencia de pasos.
- Obtenemos el tamaño del texto
- Entrada del texto por la derecha primera fila
- Bucle recorriendo los caracteres de mayor a menor índice
- Obtenemos un trozo de la subcadena desde el índice hasta el final
- Limpiamos LCD
- Situamos el cursor en la columna 0 fila 0
- Mostramos trozo de texto en la pantalla del LCD
- Esperamos tiempo
- Bucle recorriendo los caracteres de mayor a menor índice
- Desplazamiento de texto hacia la derecha primera fila
- Bucle recorriendo todas las columnas desde la segunda hasta la última más uno
- Limpiamos LCD
- Situamos el cursor en la columna correspondiente fila 0
- Mostramos texto completo en la pantalla del LCD
- Esperamos tiempo
- Bucle recorriendo todas las columnas desde la segunda hasta la última más uno
- Desplazamiento de texto hacia la izquierda segunda fila
- Bucle recorriendo las columnas desde la última más uno hasta la columna 1
- Limpiamos LCD
- Situamos el cursor en la columna correspondiente fila 0
- Mostramos texto completo en la pantalla del LCD
- Esperamos tiempo
- Bucle recorriendo las columnas desde la última más uno hasta la columna 1
- Salida de texto por la izquierda segunda fila
- Bucle recorriendo los caracteres de menor a mayor índice
- Obtenemos un trozo de la subcadena desde el índice hasta el final
- Limpiamos LCD
- Situamos el cursor en la columna 0 fila 0
- Mostramos trozo de texto en la pantalla del LCD
- Esperamos tiempo
- Bucle recorriendo los caracteres de menor a mayor índice
Es un algoritmo un poco complejo que se divide en 4 bloques. Los dos primeros nos servirán para desplazar el texto hacia la derecha y los dos siguientes para desplazarlo hacia la izquierda.
Código del texto en movimiento con LCD y Arduino
Una vez tenemos claro lo que queremos hacer, pasamos a traducirlo al lenguaje de programación con Arduino. Es importante hacer el paso anterior y, en este punto, te recomiendo que intentes hacerlo tu mismo. Seguramente te equivocarás y no sabrás cómo hacerlo, pero a base de practicar es como se adquiere la experiencia para poder desarrollar tus propios proyectos.
Declaración de constantes y variables
Lo primero es declarar las constantes y variables necesarias. Algunas ya las hemos visto en el ejercicio básico. Para este ejemplo he añadido una constante, VELOCIDAD, que nos permitirá controlar la velocidad de desplazamiento del texto. Además he creado una variable del tipo String que contendrá el texto que queremos desplazar.
|
// Incluímos la libreria externa para poder utilizarla #include // Entre los símbolos <> buscará en la carpeta de librerías 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 // Lo primero is inicializar la librería indicando los pins de la interfaz LiquidCrystal lcd(12, 11, 5, 4, 3, 2); // Textos String texto_fila = “Programarfacil.com”; |
Función setup()
La función setup() es exactamente igual que en el ejemplo básico.
|
void setup() { // Configuración monitor serie Serial.begin(9600); // Configuramos las filas y las columnas del LCD en este caso 16 columnas y 2 filas lcd.begin(COLS, ROWS); } |
Función loop()
Aquí es donde vamos a tener toda la lógica para mostrar el texto en movimiento. Vamos a ir viendo parte por parte con la explicación necesaria para que entiendas cómo lo he hecho. Lo primero que hacemos es obtener el tamaño del texto es decir, el número de caracteres que tiene nuestro texto. Para ello utilizamos la función length() que nos devuelve un número entero indicando su tamaño.
|
void loop() { // Obtenemos el tamaño del texto int tam_texto=texto_fila.length(); |
La función length() nos devuelve el número de caracteres de un texto. Si queremos recorrer todos los caracteres empezaremos por 0 y acabaremos en número de caracteres – 1. Característica de los lenguajes índice cero.
En la siguiente parte vamos a mostrar cómo entra el texto por la parte derecha. En esta parte no vamos a trabajar con el LCD ya que siempre se encontrará en la misma posición, columna 0 fila 0. El truco está en ir cogiendo trozos de texto, de más pequeño a más grande, y mostrarlos en el LCD. Esto nos dará la sensación de que se está moviendo hacia la derecha aunque en realidad lo que hacemos es mostrar cada vez un texto diferente.
|
for(int i=tam_texto; i>0 ; i—) { String texto = texto_fila.substring(i–1); // Limpiamos pantalla lcd.clear(); //Situamos el cursor lcd.setCursor(0, 0); // Escribimos el texto lcd.print(texto); // Esperamos delay(VELOCIDAD); } |
La función substring(numero) nos devuelve un trozo del texto. El número indica a partir de qué letra vamos a coger por ejemplo si hacemos “Hola Mundo”.substring(2) nos devolverá “la Mundo”. Recuerda que es un lenguaje de índice cero, el primer carácter del texto empieza por cero.
Ahora si que toca desplazar el texto. Para ello hacemos un simple bucle que recorra todas las columnas del LCD. Además tenemos que forzar para que la última visualización sea en la columna 17 y así simularemos que el texto ha desaparecido por la derecha.
|
// Desplazamos el texto hacia la derecha for(int i=1; i<=16;i++) { // Limpiamos pantalla lcd.clear(); //Situamos el cursor lcd.setCursor(i, 0); // Escribimos el texto lcd.print(texto_fila); // Esperamos delay(VELOCIDAD); } |
Una vez que ha desaparecido por la derecha, lo vamos a mover de derecha a izquierda. Si te fijas en el código, es exactamente igual que en los pasos anteriores. Lo único que cambia es como se recorren los bucles, ahora en sentido contrario. Lo primero es desplazar el texto a través de la función setCursor() e indicando en que posición mostrar el texto.
|
// Desplazamos el texto hacia la izquierda en la segunda fila for(int i=16;i>=1;i—) { // Limpiamos pantalla lcd.clear(); //Situamos el cursor lcd.setCursor(i, 1); // Escribimos el texto lcd.print(texto_fila); // Esperamos delay(VELOCIDAD); } |
Por último, lo hacemos desaparecer por la izquierda. La idea es igual que cuando lo hacemos aparecer por la derecha. En este caso lo que hacemos es ir mostrando de más caracteres a menos caracteres. Esto da la sensación de que estamos desplazando el texto hacia la izquierda.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 |
// Mostramos salida del texto por la izquierda for(int i=1; i<=tam_texto ; i++) { String texto = texto_fila.substring(i–1); // Limpiamos pantalla lcd.clear(); //Situamos el cursor lcd.setCursor(0, 1); // Escribimos el texto lcd.print(texto); // Esperamos delay(VELOCIDAD); } |
Código completo
A continuación te dejo el código completo. Cualquier duda o sugerencia te agradecería que dejaras un comentario en este artículo.
|
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 |
// Incluímos la libreria externa para poder utilizarla #include // Entre los símbolos <> buscará en la carpeta de librerías 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 // Lo primero is inicializar la librería indicando los pins de la interfaz LiquidCrystal lcd(12, 11, 5, 4, 3, 2); // Textos String texto_fila = “Programarfacil.com”; void setup() { // Configuración monitor serie Serial.begin(9600); // Configuramos las filas y las columnas del LCD en este caso 16 columnas y 2 filas lcd.begin(COLS, ROWS); } void loop() { // Obtenemos el tamaño del texto int tam_texto=texto_fila.length(); // Mostramos entrada texto por la izquierda for(int i=tam_texto; i>0 ; i—) { String texto = texto_fila.substring(i–1); // Limpiamos pantalla lcd.clear(); //Situamos el cursor lcd.setCursor(0, 0); // Escribimos el texto lcd.print(texto); // Esperamos delay(VELOCIDAD); } // Desplazamos el texto hacia la derecha for(int i=1; i<=16;i++) { // Limpiamos pantalla lcd.clear(); //Situamos el cursor lcd.setCursor(i, 0); // Escribimos el texto lcd.print(texto_fila); // Esperamos delay(VELOCIDAD); } // Desplazamos el texto hacia la izquierda en la segunda fila for(int i=16;i>=1;i—) { // Limpiamos pantalla lcd.clear(); //Situamos el cursor lcd.setCursor(i, 1); // Escribimos el texto lcd.print(texto_fila); // Esperamos delay(VELOCIDAD); } // Mostramos salida del texto por la izquierda for(int i=1; i<=tam_texto ; i++) { String texto = texto_fila.substring(i–1); // Limpiamos pantalla lcd.clear(); //Situamos el cursor lcd.setCursor(0, 1); // Escribimos el texto lcd.print(texto); // Esperamos delay(VELOCIDAD); } } |
