Información extraída de Last Minute ENGINEERS

Este tutorial explica como programar las pantallas LCD de caracteres. No sólamente las de 16x2 (1602) sino cualquier LCD de caracteres (p.ej. 16x4, 16x1, 20x4, etc.) ya que todas se basan en el mismo chip controlador de Hitachi: el HD44780

¿Sabías que...?

LCD es la abreviatura de Liquid Crystal Display (Pantalla de Cristal Líquido). Básicamente es una pantalla que usa cristales en estado líquido para producir las imágenes.

Al aplicar corriente en este tipo de cristales, se vuelve opaco bloqueando la luz que hay detras la pantalla. Como resultado esa zona queda más oscura que el resto. De esta manera es como se muestran los caracteres en pantalla.

Resumen del Hardware

Estas pantallas LCDs son ideales para mostrar texto/caracteres únicamente, de ahí su nombre LCD de caracteres. La pantalla tiene una luz trasera tipo LED y puede mostrar 32 caracteres ASCII en dos columnas con 16 caracteres por columna.

Si miras de cerca una de estas pantallas podrás ver la zona rectangular correspondiente a cada caracter. Cada uno de los caracteres está formado de diminutos cuadraditos que son pixels que constituyen el caracter. Cada caracter está formado por una rejilla de 5x8 pixels.

Hay una gran variedad de modelos, tamaños y colores: por ejemplo, 16x1, 16x4, 20x4, con texto blanco sobre fondo azul, texto negro sobre fondo verde, etc.

La buena noticia es que todas estas pantallas se usan y programan de la misma forma. El código se deberá ajustar al tamaño de filas/columnas de la pantalla, pero el cableado y resto de programación son idénticos.

Pinout LCD 16x2 de Caracteres

Antes de adentrarnos en el código de ejemplo, veamos primero como se conectan estas pantallas.

ATENCIÓN

En esta sección veremos el conexionado y programación de los LCD de 16 pines. La ventaja de estas pantallas es que son muy comunes y el IDE de Arduino ya tiene una librería para programarlos directamente de forma fácil. El inconveniente es que usan muchos pines de nuestra placa, por eso existen alternativas que necesitan menos pines. Una solución es usar un módulo de expansión I2C con lo que se reduce el conexionado a sólo cuatro cables.

Si tu LCD tiene cuatro pines de conexión o usa un módulo I2C consulta el siguiente tutorial:

• Display 16x2 Character LCD Expansión I2C

• GND o VSS Se conecta al ground de Arduino

• VCC o VDD Es la alimentación del LCD y necesita 5V. Puedes conectarlo a la salida de 5V de Arduino

• Vo (Contraste LCD) Controla el contraste y brillo del LCD. Usando un simple divisor de tensión con un potenciómetro, podemos ajustar el contraste manualmente.

• RS (Register Select) Le dice al microcontrolador que el LCD está enviando comandos o datos. Básicamente este pin se usa para diferenciar si envia un comando o un dato.

• R/W (Read/Write) Controla si se está leyendo o escribiendo del/al LCD. En general siempre usaremos el LCD como dispositivo de SALIDA, por tanto pondremos este pin a LOW (GND). De esta manera el LCD siempre estará en modo WRITE (Escritura).

• E (Enable) Se utiliza para habilitar el dispositivo. Es decir, si este pin está a LOW, el LCD ignora lo que ocurra en R/W, RS y las líneas de datos. Cuando el pin está en HIGH, el LCD procesa los datos y señales de entrada.

• D0-D7 (Bus de Datos) Transportan los datos de 8 bits que enviamos a la pantalla. Por ejemplo, si queremos ver una 'A' mayúscula pondremos estos pines a 0100 0001 (correspondiente al código ASCII 65, que precisamente es la 'A').

• 'A-K (Ánodo & Cátodo)` Normalmente se usan para controlar la luz trasera del LCD.

Prueba del LCD

Pasemos a cosas más interesantes. Vamos a probar el LCD, todavía sin programar nada.

Primero, conecta los 5V y GND de Arduino a los railes de alimentación de la protoboard y enchufa el LCD a la protoboard.

Ahora alimenta el LCD. Hay dos dos conexiones para alimentación diferenciadas; la primera -pin 1 y pin 2- para el LCD en sí mismo y la otra -pin 15 y pin 16- para la iluminación trasera del LCD. Conecta los pines 1 y 16 del LCD a GND y los pines 2 y 15 del LCD a 5V.

La mayoría de LCDs tiene una resistencia interna que protege el LED de iluminación trasera. Si tu LCD no incluye esta resistencia, deberás añadir una entre 5V y el pin 15. Una resistencia de 220 Ohm suele ser un valor seguro.

A continuación conecta el pin 3 del LCD, que controla el brillo y contraste de la pantalla. Para poder controlar gradualmente el contraste conectaremos un potenciómetro de 10K entre 5V y GND; conectando el pin central (wiper) del potenciómetro al pin 3 del LCD.

¡Listo! Ahora alimenta la placa Arduino (conéctalo p.ej. al USB del ordenador) y verás el LCD encenderse. A medida que rotes el potenciómetro, deberías notar como la fila de rectángulos del LCD desaparece. Si esto sucede, ¡enhorabuena! El LCD funciona correctamente.

Conexión - Conectar el LCD de 16x2 Caracteres a Arduino UNO

Antes de cargar el programa y enviar datos a la pantalla, veamos cómo conectarla a Arduino.

El LCD tiene un monton de pines (16 en total) que mostraremos como conectar. La buena noticia es que no hace falta conectar todos los pines.

Sabemos que hay 8 líneas de datos que transportan los datos a la pantalla. Pero el HD44780 está diseñado para poder comunicarse con el LCD usando sólo 4 pines de datos (modo 4-bits) en lugar de 8 (modo 8-bits). Esto nos ahorra 4 pines.

Diferencia entre el modo 4-bit y el modo 8-bit

Es más rápido usar el modo 8-bit ya que tarda la mitad de tiempo en enviar los datos. Esto es así porque en el modo 8-bit se envía el dato de una sola vez. En cambio, en el modo de 4-bit, hay que dividir el envío de datos en dos mitades (2 nibbles), se envía primero los 4 bits superiores y luego, en una segunda operación, se envían los 4 bits restantes.

Por tanto, hay un compromiso entre velocidad y pines utilizados: 4-bit usa menos pines, pero es más lento, 8-bit usa más pines pero es más rápido.

Resumiendo, usaremos el modo de 4-bit para comunicarnos con el LCD usando, por tanto, 6 pines: RS, EN, D7, D6, D5, D4.

Ahora, procedamos a conectar el LCD a Arduino. Conectaremos cuatro pines de datos del LCD (D4-D7) a los pines digitales de Ardino #5-2. El pin E (Enable) del LCD lo conectaremos al pin de Arduino #11 y el pin RS del LCD al pin 12

Ya tenemos todo listo para empezar a programar nuestra pantalla LCD.

Código Arduino

El código a continuación escribirá 'Hola Mundo!' por la pantalla del LCD. Prueba el programa y después lo veremos con más detalle.

// incluimos la librería del LCD
#include <LiquidCrystal.h>

// Creamos un objeto para controlar el LCD object. 
// Orden de parámetros: (rs, enable, d4, d5, d6, d7)
LiquidCrystal lcd(12, 11, 5, 4, 3, 2);

void setup() 
{
    // establece el número de columnas, filas del LCD
    lcd.begin(16, 2);

    // Borra la pantalla del LCD 
    lcd.clear();
}

void loop() 
{
    // Establece el cursor a la columna 3, línea 0
    // (nota: línea 0 es la primera fila, ya que comienza a contar por la 0)
    lcd.setCursor(2,0);
    // Muestra un mensaje 
    lcd.print("Hola Mundo!");

    // Establece el cursor a la columna 3, línea 1
    // (nota: línea 1 es la segunda fila, ya que comienza a contar por la 1)
    lcd.setCursor(2, 1);
    // Muestra mensaje 
    lcd.print("===========");   // 11 guiones
}

Explicación del Código

Comenzamos incluyendo la librería LiquidCrystal. Esta es una librería que viene ya con el editor de Arduino, así que no hace falta instalar nada adicional. Puedes obtener más información sobre esta librería en la documentación oficial de Arduino.

    // incluimos la librería del LCD
    #include <LiquidCrystal.h>

A continuación creamos un objeto de tipo LiquidCrystal. Este objeto necesita que especifiquemos qué pines de Arduino están conectados al LCD. Si miramos la documentación de Arduino para construir un objeto de tipo LiquidCrystal, veremos que hay varias maneras de construir el objeto.

En conreto, en nuestro código usamos la versión que recibe 6 parámetros que indican, en este orden, los pines RS, Enable y los pines de datos d4, d5, d6, d7.

    // Creamos un objeto para controlar el LCD object. 
    // Orden de parámetros: (rs, enable, d4, d5, d6, d7)
    LiquidCrystal lcd(12, 11, 5, 4, 3, 2);

Ahora que ya tenemos un objeto para controlar el LCD, podemos usar unos métodos especiales (es decir, funciones propias del objeto) que son específicas para el LCD.

En la función setup usamos dos métodos. El primero es begin(). Este método se usa para indicar las dimensiones de la pantalla, es decir, cuantas files y columnas hay en pantalla. Si usas un LCD de 16x2 caracteres especificarás 16,2. Si usas un LCD de 20x4 pondrás 20,4.

El segundo método que usamos es clear(). Este método limpia la pantalla del LCD y mueve el cursor a la posición izquierda superior de pantalla.

    // establece el número de columnas, filas del LCD
    lcd.begin(16, 2);

    // Borra la pantalla del LCD 
    lcd.clear();

en la función loop() usamos el método setCursor() para posicionar el cursor en la columna 3, fila 0. El cursor le indica al LCD dónde debe escribir el siguiente caracter. De esta forma indicamos que queremos que el cursor esté situado en el tercer cuadradito de la primera fila.

A continuación el método print() se usa para mostrar el mensaje "Hola Mundo!" a partir de la posición del cursor establecida antes con setCursor().

    // Establece el cursor a la columna 3, línea 0
    // (nota: línea 0 es la primera fila, ya que comienza a contar por la 0)
    lcd.setCursor(2,0);
    // Muestra un mensaje 
    lcd.print("Hola Mundo!");

Despues establecemos el cursor a la tercera columna de la segunda fila usando, de nuevo, el método setCursor(). Finalmente escribimos por pantalla unos '=' a modo de simular un efecto de subrayado.

    // Establece el cursor a la columna 3, línea 1
    // (nota: línea 1 es la segunda fila, ya que comienza a contar por la 1)
    lcd.setCursor(2, 1);
    // Muestra mensaje 
    lcd.print("===========");   // 11 guiones

Funciones útiles de la librería LiquidCrystal

TODO!

Generación de caracteres propios

TODO!