Jugando con arduino + LCD

Tratando de amigarme nuevamente con este bicho, arranque por repasar antiguos conocimientos y darle una vuelta de rosca.

Anteriormente habia realizado una suerte de ruleta electrónica, donde en un display mostraba información sobre la bolilla que salio y su color.  El desafío en ese entonces fue darle un pantallaso al IDE de arduino y tener un primer proyecto.

Vamos ahora a analizar en profundidad el LCD y ver de que forma exprimirlo, para que en próximos proyectos nos sea un gran aliado a la hora de presentarnos información

 

Generalidades sobre el display y su manejo:

Algo muy importante a considerar, es que no vamos a controlar un display LCD a lo guapo, si no que vamos a hacerlo a través de un controlador de LCD generalmente basado en el HD44780 de Hitachi. Este controlador es el encargado de hacer gran parte de la magia polarizando todos los puntos que sean necesarios hasta formar el carácter que nosotros queramos…. pero nosotros solo le enviamos el carácter en ascii y donde lo queremos.

En una breve mirada al datasheet del HD44780 podemos destacar las siguientes características:

  • Compatible con Microprocesadores de 4 y 8 bits
  • Caracteres alfanuméricos, kanji japoneses y símbolos
  • 240 fuentes de caracteres diferentes (208 fuentes de 5 x 7 y 32 fuentes de 5 × 10).
  • Se alimenta con poca tension (2.7V a 5.5V), ideal para equipos alimentados a bateria
  • 8-bit display RAM (80 caracteres máximo.)
  • Amplio juego de instrucciones, entre ellos: Display clear, cursor home, display on/off, cursor on/off, display character blink, cursor shift, display shift, etc.

HD44780U Block Diagram

HD44780U Pin functions

Conexión del display a la placa Arduino:

Programación:

Ahora que ya conocemos como esta compuesto el HD44780,  reconocemos sus pines junto con su funcionamiento y logramos conectarlo al microcontrolador, solo nos resta enviarle la info.

A continuación, podemos ver el diagrama de tiempos para su programación.

HD44780U Bit transfer

A diferencia del modo de 8 bits que requiere de 8 hilos, el modo 4bits tiene como ventaja el empleo de la mitad de hilos de datos. Estos son los de mayor peso, es decir desde el pin DB4 al DB7, pero como no todo es color de rosa, y los caracteres son de 8bits….. se deben enviar los 4bites mas altos y luego los 4bites mas bajos, es decir, los de menor peso. Recordar que una vez finalizado el envío de 8 bits (dos tandas de 4bits) debemos escuchar o mirar el BF (Busy Flag) para poder saber cuando el HD44780 terminó la transferencia y ya se encuentra nuevamente ready… en ese momento el pin R/W estará en 0 (cero)

Bueno bien ya sabemos como y cuando enviar la información… pero que le mando ?  continuando con la lectura rápida del datasheet (ya les diré por qué) tenemos el listado de comandos a enviar y algunos de los caracteres para que se den una idea.

HD44780U instrucciones

HD44780U caracteres

Ya tenemos casi todo, solo nos falta comprender que es lo que realmente vemos en el display, o mejor dicho como materializamos esos caracteres que hasta ahora habíamos cargado en la memoria RAM para que exiban en el display

Comentamos al principio de todo que el HD44780 cuenta con una memoria RAM de 8bits y que son 80 caracteres. En un display de 2×16, es decir, dos filas y 16 columnas vamos 2 filas o renglones de 40 caracteres y nuesto display que es mas pequeño podriamos verlo como si fuera una ventana que nos permte ver esa memoria y nos permie desplazarnos hacia ambos lados. manteniendo los datos en memoria. Porsupuesto que se puede hacer mucho mas… el limite lo pones vos.

HD44780U distribucion memoriaCon el set de instrucciones y el de caracteres, doy por concluida la etapa introductoria donde aprendimos brevemente como operar el display.
Si te parece que es bastante engorroso, pues si, un poco.. pero quienes cuenten con internet pueden googlear o buscar la rutina para hacer funcionar este controlador de LCD con el micotrolador / microprocesador que tengan.

Algo importante a saber es que el IDE de Arduino ya cuenta con toda una libreria dedicada al LCD llamada LiquidCrystal. Dicho sea de paso, de ahora en adelante solo me enfocare en desarmar y analizar esta libreria. Jugando, aprendiendo, romiendo y arreglando todo lo relacionado a esta libreria. Tal vez salga algo bueno

Introducción a la libreria LiquidCrystal:

Dicha librería cuenta con las siguientes funciones:

  • LiquidCrystal() : Inicia el Display, indicando que ports del Arduino utilizaremos y modo del mismo, (4bits u 8 bits).
  • begin(): Especifica las dimensiones del display, cantidad de columnas y filas.
  • clear(): Borra la pantalla y posiciona el cursor en la esquina superior izquierda.
  • home(): Solo posiciona el cursor en la esquina superior izquierda.
  • setCursor(): Posiciona el cursor en las coordenadas indicadas (columna,fila) para luego mostrar los caracteres escritos.
  • write(): Escribe uno o varios caracteres en el Display
  • print(): Imprime un Texto en el Display
  • cursor(): Muestra el cursor (guion).
  • noCursor(): Oculta el cursor (guion).
  • blink(): Hace titilar el cursor (cuadrado completo).
  • noBlink(): Deja de hacer titilar el cursor (cuadrado completo).
  • display(): Enciende la pantalla LCD, después de haber sido apagado con nodisplay (). Esto restaurará el texto (y cursor) que estaba en la pantalla.
  • noDisplay(): Apaga la pantalla LCD, sin perder el texto que figura actualmente en él
  • scrollDisplayLeft(): Desplaza el contenido de la pantalla (texto y el cursor) un espacio hacia la izquierda.
  • scrollDisplayRight(): Desplaza el contenido de la pantalla (texto y el cursor) un espacio hacia la derecha.
  • autoscroll(): Activa el desplazamiento automático de la pantalla LCD. Esto hace que cada salida carácter a la pantalla para empujar personajes anteriores sobre por un espacio.
  • noAutoscroll(): Desactiva el desplazamiento automatico de la pantalla LCD.
  • leftToRight(): Establezca la dirección para el texto escrito a la pantalla LCD de izquierda a derecha, el valor predeterminado. Esto significa que los caracteres escritos posteriores a la pantalla irán de izquierda a derecha, pero no afecta el texto previamente salida.
  • rightToLeft(): Establezca la dirección para el texto escrito a la pantalla LCD de derecha a izquierda, el valor predeterminado. Esto significa que los caracteres escritos posteriores a la pantalla irán de izquierda a derecha, pero no afecta el texto previamente salida.
  • createChar() : Permite generar hasta 8 caracteres personalizados de 5×7

Ejercicio integrador:

Vamos a realizar ahora un ejercicio mostrando algunas de las funciones que me parecieron más interesantes. Desde luego que se pueden utilizar cualquiera de las mencionadas anteriormente, modificar el código a gusto y hacer cosas aun más locas.

/****************************************************************** 
* Ejercicio integrador se funciones predefinidas en la librería  
* LiquidCristal() del IDE de Arduino 
*****************************************************************/
//Definiciones
#define INTRO         0
#define TITILAR       1
#define DESPLAZAR     2
#define CREATECHAR    3
#define BACKLIGHT     4


#include <LiquidCrystal.h>
LiquidCrystal lcd(12, 11, 5, 4, 3, 2);  
void setup() 
{
  lcd.begin(16,2);
   //lcd.print("Sabado 17/10/2015 07:11hs.   ");
  
}
void loop ()
{
  //Declaración de variables locales
  char n,estado;
  //Declaración de caracteres especiales
  byte smiley[8] = {
  B00000,
  B10001,
  B00000,
  B00000,
  B10001,
  B01110,
  B00000,
  };
  byte centrigrado[8] = {
  B01000,
  B10100,
  B01000,
  B00011,
  B00100,
  B00100,
  B00011,
  B00000
};
byte flechad[8] = {
  B00000,
  B00100,
  B00010,
  B11111,
  B00010,
  B00100,
  B00000,
  B00000
};
byte flechai[8] = {
  B00000,
  B00100,
  B01000,
  B11111,
  B01000,
  B00100,
  B00000,
  B00000
};
byte diametro[8] = {
  B00000,
  B01101,
  B10010,
  B10101,
  B01001,
  B10110,
  B00000,
  B00000
};
byte boldfaceh[8] = {
  B11000,
  B11000,
  B11110,
  B11111,
  B11011,
  B11011,
  B11011,
  B00000
};
byte ohm[8] = {
  B00000,
  B01110,
  B10001,
  B10001,
  B10001,
  B01010,
  B11011,
  B00000
};
byte micro[8] = {
  B00000,
  B00000,
  B00000,
  B10010,
  B10010,
  B10010,
  B11100,
  B10000
};
  

  



lcd.createChar(0, smiley);
lcd.createChar(1, centrigrado);
lcd.createChar(2, flechad);
lcd.createChar(3, flechai);
lcd.createChar(4, diametro);
lcd.createChar(5, boldfaceh);
lcd.createChar(6, ohm);
lcd.createChar(7, micro);
  
estado=INTRO;
while(1)
  {
switch (estado)
{

case INTRO:
              /*********************************************
              * Imprimo la presentación durante unos segundos
              *********************************************/
              digitalWrite(6, HIGH); //Enciendo la Backlight
              lcd.setCursor(0,0); //posiciono el cursor en la primer columna y fila
              lcd.print("Epelbyte"); //imprimo
              lcd.setCursor(0,1); //posiciono el cursor en la primer columna y segunda fila 
              lcd.print("Mi primer ejercicio"); //imprimo
              delay (5000);
              estado=TITILAR;
              break;

case TITILAR:
              /***************************************************
              * Hago titilar la presentación durante unos segundos
              ***************************************************/
              digitalWrite(6, HIGH);
              for (n=0; n<=10; n++)
              {
                lcd.noDisplay();
                delay(500);
                lcd.display();
                delay(500);
              }
              estado=DESPLAZAR;
              break;
              
case DESPLAZAR:
              /***************************************************
              * Se desplaza una frase hacia la izquierda 5 segundos
              * y luego hacia la derecha unos segundos
              ***************************************************/
              lcd.clear(); //borra la pantalla y posiciona el cursor en 0,0
              //lcd.setCursor(0,1); //posiciono el cursor en la primer columna y segunda fila
              lcd.print("scrollDisplayLeft  "); //imprimo
              for (n=0; n<=24; n++)
              {
                lcd.scrollDisplayLeft();
                delay(500);
              }
              lcd.clear();
              lcd.print("scrollDisplayRight  "); //imprimo
              for (n=0; n<=24; n++)
              {
                lcd.scrollDisplayRight();
                delay(500);
              }
              estado=CREATECHAR;
              break;
              
case CREATECHAR:
              /***************************************************
              * Se imprimen una suerte de caracteres especiales
              ***************************************************/
              lcd.clear();
              lcd.write(byte(0));
              lcd.write(byte(1));
              lcd.write(byte(2));
              lcd.write(byte(3));
              lcd.write(byte(4));
              lcd.write(byte(5));
              lcd.write(byte(6));
              lcd.write(byte(7));
              delay(5000);
              estado=BACKLIGHT;
              break;

case BACKLIGHT:
              /***********************************************************                          *  La backlight se encuentra conectada al pin 6 mediante                
              *  un transistor NPN como driver        
              ***********************************************************/
              for ( n=0; n<=10; n++)
              {
                lcd.clear();
                lcd.print("Epelbyte");
                digitalWrite(6, HIGH);   // Enciendo la salida 6
                delay(200);              // espero 200ms
                digitalWrite(6, LOW);    // Apago la salida 6 
                delay(200);
              }
              estado=INTRO;
              break;                         
}
  }
}


Así queda nuestro ejercicio en el display

 

Saludos!!

 

Fuentes:
Datasheet Hitachi HD44780
Cómo gobernar un display LCD alfanumérico basado en el controlador HD44780

Módulo LCD HD44780 de Hitachi – Carlos Canto
Arduino LiquidCrystal()

 

Dejá un comentario

Tu dirección de correo electrónico no será publicada. Los campos necesarios están marcados *

*