Tutorial LCD

Ya sabemos accionar luces y motores.  Ahora veamos como visualizar informacion en una pantalla LCD que es una tarea muy común para mostrar informacion obtenida de sensores.

Requisitos:

1. Computadora (mac)
2. Arduino MEGA (u otra variante Arduino) o incluso Arduino clone, Edison, Raspberry…  Este tutorial en particular usa una Arduino MEGA.
3. Pantalla LCD
4. Breadboard
5. Arduino IDE (https://www.arduino.cc/en/Main/Software)

Una pantalla LCD es un componente un poco mas complicado.  Como pueden ver ya viene montado sobre una tarjeta de circuitos.  Pero no es de asustarse, una tarjeta de circuitos lo único que es, es una conexión de varios componentes de manera fija.  Es mas, en los tutoriales anteriores que hicimos interconexiones usando la breadboard, todos esos cables y resistores y diodos son exactamente eso.  La diferencia es que en una breadboard se ensaya y cuando ya se tiene un circuito bien probado, para no tener todos esos cables colgando, se reduce todo en tamaño y se fijan los cables a una tarjeta de circuitos.

En este caso la pantalla es sencilla (hay mas complicadas) pero lo mas importante es que tiene 16 pines que podemos ver en la esquina inferior derecha.  Estan nombrados:

– VSS, VDD, VO: VDD (+), VSS (-) & V0 (contraste)

– RS, RW, E: RS (registro), RW (Read/Write) & E (enable)

– D0 – D7: D0-D3 (no data), D4-D7 (data)

– A & K: A (backlight) & K (backlight GND)

Las conexiones aquí se vuelven un poco mas complicadas asi que prepárense.  Si hay una conexión mas sencilla ahora utilizando un protocolo llamado I2C pero siempre es bueno empezar por lo tradicional y crecer desde allí.

Se mira complicado pero no lo es.  Vamos por partes:

• Primero alimentamos la breadboard con 5V de la MEGA (cable rojo superior izquierdo) y con el GND (cable negro en el centro de la imagen).  Esto es VSS y VDD.
• Luego un cable azul pequeño en el breadboard conecta al 3er pin en el LCD denominado V0.  Este dijimos que es el contraste.  Es común que las LCDs tenga un controlados de contraste ya que dependiendo de la luz ambiental se puede ver mejor si se ajusta el mismo.  Esto se hace variando la corriente al LCD y ya sabemos que para variar la corriente con un dial, un pot es ideal.
• Ahora viene un cable rojo vino del pin 12 de la MEGA (RS), un cable negro al GND (R/W) y un cable blanco al pin 11 de la MEGA (E).
• Luego los pines D0-D3 están libres en este caso.
• Siguen los 4 pines de datos que se conectan a los pines 2-5 del LCD. (NOTA: usar 4 pines es equivalente a usar el LCD en modo 4-bits y usar los 8 pines es usarlo en modo 8-bits)
• Finalmente tenemos un resistor al 5V en el backlight (A) y el GND al backlight GND (K).

La alimentacion de VSS y VDD no necesita explicación, es la fuente de poder para la LCD.  La alimentación para el backlight, A & K, tampoco.  Los 4 pines de data es donde enviaremos la data y los 4 pines vacíos pues no hay nada que explicar.  El pin V0 al pot es para regular el contraste.

Lo único que requiere explicación es RS, RW y E.

RS determina si la LCD esta en modo instrucción o caracteres.  En modo instrucción la LCD responde a comandos como limpiar el display o mover el cursor.  A diferencia del modo caracteres que dice a la LCD que reciba data tipo alfanumerica o de símbolos.  Si el RS esta a voltaje bajo o GND, esta en modo instrucción.  Si esta a voltaje alto o 5V esta en modo caracteres.

RW es similar y la distincion radica entre modo de lectura del display (READ) o modo de escritura al display (WRITE).  Read es poco comun pero existe.  Nosotros principalmente estaremos usando el modo write.

Finalmente, E, habilita y deshabilita los dos RS y RW.  Es decir, cuando E tiene voltaje bajo, RS y RW no importan, la LCD no recibe data.  Cuando E recibe voltaje alto entonces lee datos entrantes.

Bueno suficiente explicación, ahora veamos la conexión:

Parece complejo pero es tan sencillo como el diagrama que vimos arriba con algunas modificaciones.

De derecha a izquierda

El primer par rojo/negro (err: en la imagen falta el cable negro) es el que alimenta de la MEGA.  El segundo par rojo/negro que sale hacia la esquina inferior derecha son los que alimentan el pot.  El tercer par rojo/negro son los que entran directamente al LCD en sus pines VDD/VSS.  Luego viene el cable verde en la LCD que va al wiper del pot.  Le sigue el cable verde (RS) al pin 12, cable negro(RW) a GND comun y otro cable verde(E) al pin 11.  A continuacion los 4 pines vacios seguidos de los 4 pines (D4-D7) con cables de data.  Finalmente esta el ultimo par rojo/negro a los pines A/K respectivamente.  En resumen deberiamos tener:

LCD -> MEGA -> Breadboard -> Color de Cable –> Otro

VSS –> GND —>  SI ————-> Negro

VDD –> 5V ——> SI ————–> Rojo

V0 ——————> NO ————> Verde —————> Wiper del Pot

RS —–> 12 ——> NO ————> Verde

RW —-> GND —> SI ————–> Negro

E ——-> 11 ——> NO ————> Verde

D0-D3

D4-D7 -> 5-2 ————————-> 5&4 naranja, 3&2 amarillos

A ——-> 5V ——-> SI ————-> Rojo

K ——-> GND —-> SI ————-> Negro

Finalmente el codigo:

//#include // Esta no la usaremos, es para LCDs con una conexión distinta pero mas avanzada
#include
// initializamos el objeto LiquidCrystal, similar como el Servo
LiquidCrystal lcd(12, 11, 5, 4, 3, 2);
void setup() {
// Nuestro LCD es 16 cols x 2 filas
lcd.begin(16, 2);
// Imprimimos al LCD
lcd.print("Hola Arduino HN!");
}
void loop() {
// Cada loop reseteamos el cursor a col0, linea1
// linea 1 es la 2da fila porque linea 0 es la primera
lcd.setCursor(0, 1);
// Imprimimos segundos desde reinicio...
lcd.print(millis() / 2000);
delay(1000);
}


Y ahora el resultado final…bueno, al menos el mio…

Ok, repasando lo que aprendimos:

• Aprendimos a usar componentes con varios pines.
• Tenemos una manera mas amigable para visualizar la data de un proyecto en una pantalla.

Ahora podemos relacionar esto al uso de una pantalla mas sofisticada como una TFT para ver mas datos o incluso TFT touchscreen que nos permite una interacción intuitiva entre el usuario y la data.

En el proximo tutorial aprenderemos a leer data de un sensor.  La idea es comenzar a trabajar con componentes mas sofisticados y con libraries para ir conectándolos de manera que podamos incorporar a nuestro proyecto de datos, la comunicación de esos datos.