Menu

Jugando con arduino + LCD

25 octubre, 2015 - Arduino
Jugando con arduino + LCD

Tratando de amigarme nuevamente con este bicho, arranque por repasar antiguos conocimientos y darle una vueltita 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:

HD44780U Block Diagram

HD44780U Pin functions

Conexión del display a la placa Arduino:

LCD_bb

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:

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()

 

Etiquetas: ,

Dejá un comentario

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