Una pantalla LCD es un componente muy común en proyectos hechos con Arduino. Es una forma muy rápida y cómoda de mostrar diferentes mensajes que nos alerten del estado o nos indique un valor en el que estamos interesados.

Este tutorial es para las siguientes pantallas LCD:

Pantalla LCD de caracteres 1602 con los pines soldados

4,50 (3,72 IVA excl.)

Pantalla LCD de caracteres 1602 con pines sin soldar

3,00 (2,48 IVA excl.)

Pantalla LCD de caracteres 2004

8,40 (6,94 IVA excl.)

Lo primero es conectar tu pantalla LCD de caracteres a Arduino directamente o hacerlo a través del módulo I²C.

Instanciación del objeto que controla la pantalla

En Arduino IDE, empezamos por inicializar la pantalla. Antes de setup() y loop(), fuera de ambas funciones, incluimos la librería e instanciamos el objeto que controla la pantalla. El código cambia dependiendo de si estamos conectando la pantalla directamente a Arduino o utilizando el módulo I²C.

#include <LiquidCrystal.h>
LiquidCrystal lcd(12, 11, 5, 4, 3, 2);

 


 

La primera línea incluye la librería LiquidCristal, y en la segunda línea se inicializa la pantalla. lcd es el nombre que hemos dado al objeto, podríamos haber elegido otro, y los números que le siguen son los pines a los que hemos conectado la pantalla en este orden:

LCDVSSVDDRSRWED4D5D6D7AK
ArduinoGND5V12GND1154325VGND
#include <Wire.h> 
#include <LiquidCrystal_I2C.h>
LiquidCrystal_I2C lcd(0x27,16,2);

 


 

El bus I²C hace uso de la librería Wire, y tenemos que incluirla manualmente. La siguiente línea incluye la librería LiquidCrystal_I2C, que no debe confundirse con LiquidCrystal (sin _I2C). La tercera línea instancia el objeto que controla la pantalla, y sus parámetros en orden de aparición son:

  • La dirección I²C del módulo
  • Número de caracteres en una fila (columnas)
  • Número de filas o líneas

Inicialización

En la función setup() tenemos que inicializar la pantalla LCD.

void setup() {
  lcd.begin(16, 2);
}

 


 

Inicializamos la pantalla con la función begin(), a la cual se le dan dos argumentos: el número de caracteres que hay en una fila y el número de filas que tiene la pantalla.

void setup() {
  lcd.init();
  lcd.backlight();
}

 


 

Por un lado inicializamos la pantalla con la funcion init(). Además tendremos que encender la retroiluminación.

Nota: La mayoría de estas pantallas son retroiluminadas. Si es el caso, su lectura se hace muy difícil sin activar la retroiluminación. Sin embargo, si tienes una pantalla sin retroiluminación, podrás saltarte la función que la activa.

Escribiendo textos

Sin importar si hemos conectado nuestra pantalla LCD directamente a Arduino, o través del módulo I²C, para escribir textos vamos a hacer uso de 3 funciones diferentes:

setCursor(0, 0);

Esta define en qué parte de la pantalla vamos a escribir. El primer valor que se le pasa (que no tiene por qué ser 0) corresponde a la columna. El segundo valor corresponde a la fila. La esquina superior izquierda de la pantalla es el (0, 0).

print(“hola”);

Escribe el mensaje que se le pasa como argumento. El argumento debe ir entre comillas dobles (“) si es una cadena literal de caracteres lo que queremos mostrar.

clear();

Borra toda la pantalla dejándola en blanco.

Ejemplo

Vamos a mostrar los textos “Hola Maker” y “Adios Maker” de forma alterna, cada mensaje se muestra durante 2 segundos y en distintas filas.

void loop() {
  lcd.clear();              // Dejamos la pantalla en blanco
  lcd.setCursor(0,0);       // Escribe a la izquierda de la PRIMERA fila de la pantalla
  lcd.print("Hola Maker");  // Mostrar mensaje
  delay(2000);              // Esperar 2 segundos
  lcd.clear();              // Dejamos la pantalla en blanco
  lcd.setCursor(0,1);       // Escribe a la izquierda de la SEGUNDA fila de la pantalla
  lcd.print("Adios Maker"); // Mostrar mensaje
  delay(2000);              // Esperar 2 segundos
}

Estas pantallas tienen un juego de caracteres limitado. No pueden representar directamente caracteres con tildes o la letra Ñ entre otros. Por eso “adios” se ha escrito sin tilde.

Escribiendo valores numéricos

Para escribir un valor numérico, como el contenido de una variable o la lectura de un pin tanto digital como analógico, podemos utilizar las mismas funciones que hemos visto hasta ahora. La diferencia es que la función print() llevará en su argumento el número, la variable o el nombre de la función de la que se obtiene el valor que queremos mostrar en pantalla.

Ejemplo

Vamos a sacar en pantalla el valor numérico que se lee por el pin analógico A0:

void loop() {
  lcd.clear();               // Borrar contenido de la pantalla
  lcd.setCursor(0,0);        // Fijar el cursor al inicio
  lcd.print(analogRead(A0)); // Leer el pin A0 y escribir su valor en pantalla
  delay(2000);               // Esperar 2 segundos
}

En el ejemplo siguiente, vamos a hacer un contador de segundos:

int contador = 0; // Declarar la variable contador e inicializarla a 0

void loop() {
  lcd.clear();             // Borrar contenido de la pantalla
  lcd.setCursor(0,0);      // Fijar el cursor al inicio
  lcd.print(contador);     // Escribir el valor de la variable "contador" en pantalla
  contador = contador + 1; // Sumar 1 al contador
  delay(1000);             // Esperar 1 segundo
}

Creando nuestros propios iconos y caracteres

Estas pequeñas pantallas tienen unas celdas individuales en las que se representa cada carácter. La 1602 tiene 16 celdas en horizontal por 2 filas en vertical, con un total de 32 celdas. La 2004 tiene 20 celdas en horizontal por 4 filas en vertical, con un total de 80 celdas.

Cada una de estas celdas está formada por 40 píxeles, distribuidos en 5 columnas y 8 filas. Manipulando cada uno de estos píxeles podemos crear nuestros propios iconos y caracteres personalizados.

Definiendo nuestros caracteres e iconos

Cada píxel de la celda es representado en binario, con 1 o 0. Si queremos que el píxel aparezca pintado, lo representamos con el número 1. Si, por el contrario, no queremos que aparezca, pondremos un 0. De esta forma la primera línea del icono de la imagen estará representada por 00000, la segunda por 01110 y así hasta completar nuestro diseño.

Para almacenar estos valores vamos a crear una variable byte de tipo array. ¿Una variable qué?

Los arrays son conjuntos de varios valores que se organizan bajo el nombre de una única variable. Cada array tiene un tipo que indica el tipo de valor que el array contiene. Por ejemplo, podemos tener arrays de tipo int, que serán arrays que contengan un conjunto de números enteros. Todos los elementos del mismo array tienen que ser del mismo tipo.

En este caso, vamos a crear un array de 8 bytes (cada byte corresponde una fila), en el que cada byte contiene los 5 bits que representan los 5 píxeles de su fila. Un byte es una posición de memoria que contiene 8 bits, pero ignoraremos los 3 bits que nos sobran.

Existen varias formas de crear variables de tipo array, y en este caso vamos a crearlo especificando su tipo, su tamaño y los valores que contiene.

byte coco[8] = {
0b00000,
0b01110,
0b11111,
0b10101,
0b11111,
0b11111,
0b11111,
0b10101
};

Como ves, todos los valores de los bytes están precedidos por “0b”. Si escribiésemos solo 01110, el compilador de Arduino lo interpretaría como el número decimal 1.110, lo convertiría a binario (10001010110) y lo intentaría guardar en la variable byte que, como hemos explicado solo almacena 8 bits. Para indicar explícitamente que el valor que estamos introduciendo es binario, lo precedemos de “0b”.

Guardando nuestros caracteres e iconos en la pantalla

Los caracteres e iconos personalizados deben guardarse en la memoria de la pantalla con la función createChar(0, coco);.

El número indica la posición de la memoria de la pantalla donde hemos guardado el caracter personalizado. Esta pantalla tiene 8 posiciones de memoria que van de 0 a 7, por lo que si queremos guardar un noveno diseño tendremos que sustituir algunos de los guardados anteriormente. El siguiente argumento es el nombre que hemos dado al array donde lo hemos diseñado, en este caso, coco.

Esta función, en principio, la llamaremos dentro de setup() para guardar nuestro carácter o icono personalizado en la memoria de la pantalla.

Dibujando nuestros caracteres e iconos en la pantalla

Para dibujar nuestros caracteres e iconos personalizados en la pantalla no se utiliza la función print(), sino write(byte(0));

Esta función escribe el carácter que hayamos guardado en la posición de memoria indicada, en este caso, 0.

Es caracter o icono se dibuja en la posición donde el cursor esté situado. No olvides utilizar setCursor() para dibujar el caracter o icono donde desees.

Ejemplo completo

Vamos a dibujar un coco que cambia entre 3 posiciones distintas en la pantalla.

#include "LiquidCrystal.h"
LiquidCrystal lcd(12, 11, 5, 4, 3, 2);

byte coco[8] = {
  0b00000,
  0b01110,
  0b11111,
  0b10101,
  0b11111,
  0b11111,
  0b11111,
  0b10101
};

void setup() {
  lcd.begin(16, 2);
  lcd.createChar(0, coco);
}

void loop() {
  lcd.clear();
  lcd.setCursor(5,0);
  lcd.write(byte(0));
  delay(2000);
  lcd.clear();
  lcd.setCursor(7,1);
  lcd.write(byte(0));
  delay(2000);
  lcd.clear();
  lcd.setCursor(12,0);
  lcd.write(byte(0));
  delay(2000);
}
#include "Wire.h"
#include "LiquidCrystal_I2C.h"

LiquidCrystal_I2C lcd(0x27, 16, 2);

byte coco[8] = {
  0b00000,
  0b01110,
  0b11111,
  0b10101,
  0b11111,
  0b11111,
  0b11111,
  0b10101
};

void setup() {
  lcd.init();
  lcd.backlight();
  lcd.createChar(0, coco);
}

void loop() {
  lcd.clear();
  lcd.setCursor(5,0);
  lcd.write(byte(0));
  delay(2000);
  lcd.clear();
  lcd.setCursor(7,1);
  lcd.write(byte(0));
  delay(2000);
  lcd.clear();
  lcd.setCursor(12,0);
  lcd.write(byte(0));
  delay(2000);
}

Deja un comentario