MICROCONTROLADORES < VISUALIZACION DE DATOS CARACTERES -GRAFICOS CON LC>

PRCTICAS CON LCD y ATMEGA8

PRACTICA1 VISUALIZACION DE CARACTERES

1.- Mostrar un mensaje de Hello World en el LCD es un programa casi tan trillado
como hacer parpadear un LED.
Segn la configuracin por defecto de la librera para el LCD, debemos usar la
conexin mostrada en el esquema de abajo. La configuracin de puertos y de pines a
usar se puede cambiar en archivo lcd.h.
El pin VEE (o Vo) del LCD establece el contraste de la pantalla. Muchas veces se
prefiere quitar el potencimetro y conectar VEE a tierra para fijar el mximo contraste.
En los siguientes circuitos haremos algo parecido.

/******************************************************************
* FileName:
main.c
* Purpose:
LCD - Visualizacin de texto
*******************************************************************/
#include "avr_compiler.h"
#include "lcd.h"
void delay_ms(unsigned int t)
{
while(t--)
delay_us(1000);
}
int main(void)

{
lcd_init();

// Inicializar LCD

MICROCONTROLADORES < VISUALIZACION DE DATOS CARACTERES -GRAFICOS CON LC>

while(1)
{
lcd_gotorc(1,7);
lcd_puts("Hello");
lcd_gotorc(2,7);
lcd_puts("World");
delay_ms(600);
lcd_clear();
delay_ms(400);

//
//
//
//

Cursor a fila 1 posicin 7

Escribir Hello
Cursor a fila 2 posicin 7
...

// Pausa de 600 ms
// Limpiar pantalla
// ...

}
}

PRACTICA2 : VISUALIZACIN DE NMEROS

2.- Los LCDs solo entienden de caracteres alfanumricos y algunos otros, pero no
saben reconocer nmeros. En esta prctica veremos cmo hacerlo implementando un
sencillo reloj. No ser el ms preciso, pero servir de buen ejemplo parar formatear
nmeros.
Para el circuito, de ahora en adelante, en vez del potencimetro, colocaremos un diodo
1N4148 en el pin VEE para fijar la tensin (VDD-VEE) a cerca de 4.3 V. En la mayora
de los LCDs este valor brinda un muy aceptable nivel de contraste de la pantalla.

La funcin lcd_puts recibe como parmetro un array de tipo char, que en su forma ms
usada sera una cadena texto.
Para visualizar nmeros en el LCD primero debemos convertirlos en cadenas de
texto.
La conocida funcin sprintf (acrnimo de string print formatted) puede formatear cadenas y
nmeros en diferentes bases y colocarlas en el array que recibe como primer parmetro.
Sprintf est basada en printf, as que tiene las mismas caractersticas y limitaciones. En este
programa solo se convierten nmeros enteros.
Pero si deseas utilizar nmeros de punto flotante tendrs que habilitar el uso de la librera que
contiene printf en versin completa.
Para ms informacin puedes revisar la seccin Configuracin de printf del captulo Atmel
Studio 6 y WinAVR.
2

MICROCONTROLADORES < VISUALIZACION DE DATOS CARACTERES -GRAFICOS CON LC>

Sprintf soporta varios formatos de nmeros e incluso en su modo bsico requiere de cierta
memoria que a veces podra ser de consideracin.
Para ese caso tambin se pueden usar otras funciones de la librera C estndar stdlib.h, como
itoa, por ejemplo. Normalmente no las uso porque tienen variaciones entre los compiladores y al
menos para las prcticas como sta prefiero no tocar esas divergencias.
/**********************************************************
* FileName:
main.c
* Purpose:
LCD - Visualizacin de nmeros
********************************************************************/
#include "avr_compiler.h"
#include "lcd.h"
void delay_ms(unsigned int t)
{
while(t--)
delay_us(1000);
}
int main(void)
{
char buff[17];
unsigned seg, min, hor;
seg = min = 0;
hor = 12;
lcd_init();
lcd_gotorc(1,4);
lcd_puts("easy clock");

// Array de 17 elementos tipo char

// Inicializar LCD
// Cursor a fila 1 posicin 4

for(;;)
{
sprintf(buff, "%2d:%02d:%02d ", hor, min, seg); // Formatear
lcd_gotorc(2,5);
// Cursor a fila 2 posicin 5
lcd_puts(buff);
// Enviar buffer a LCD
if(++seg > 59)
{
seg = 0;
if(++min > 59)
{
min = 0;
if(++hor > 12)
hor = 1;
}
}
delay_ms(998);
}
}

PRACTICA3 MOSTRAR TEXTO EN DESPLAZAMIENTO EN LCD

3.- Como parte de su funcionalidad, el controlador interno del LCD puede ejecutar
instrucciones para desplazar lo mostrado en la pantalla una posicin hacia la izquierda
o la derecha.
Los cdigos para desplazar la pantalla (ver la seccin referida) son 0x1C y 0x18. Con
eso en el cdigo solo tendramos que escribir
lcd_cmd(0x1C);
Para mover todo el display incluyendo el cursor a la derecha, y
lcd_cmd(0x18);
Para mover el display a la izquierda.
Puede parecer interesante, pero como lo comprobars en la prctica Comunicacin
PC-AVR-LCD, funciona en un rango restringido y no es til cuando solo queremos
desplazar el texto de una sola lnea. Estas limitaciones llevan a muchos a realizar esos efectos
3

MICROCONTROLADORES < VISUALIZACION DE DATOS CARACTERES -GRAFICOS CON LC>

mediante rutinas software, como lo que haremos en esta prctica: Mostrar por el LCD un
mensaje que pasa como una marquesina.

El Cdigo fuente
/********************************************************************
* FileName:
main.c
* Purpose:
LCD - Textos en desplazamiento
*******************************************************************/
#include "avr_compiler.h"
#include "lcd.h"
#define

LCD_LEN

16

// Para LCD de 216

PROGMEM const char Taine[] = "

\"EL HAMBRE PRODUCE POEMAS INMORTALES.

\LA ABUNDANCIA, SOLAMENTE INDIGESTIONES Y TORPEZAS\"
";
void delay_ms(unsigned int t)
{
while(t--)
delay_us(1000);
}
int main(void)
{
unsigned char j;
unsigned char i;
char c;

// ndice relativo
// ndice base

lcd_init();
lcd_puts(" Scrolling text ");

// Escribir "Scrolling text" en LCD

while(1)
{

MICROCONTROLADORES < VISUALIZACION DE DATOS CARACTERES -GRAFICOS CON LC>

start:
i = 0;
for(;;)
{
lcd_cmd(LCD_LINE2);

// Cursor a inicio de lnea 2

for(j=0; j<LCD_LEN-1; j++)

{
c = pgm_read_byte(&Taine[i+j]); // Obtener dato de matriz
if(c)
// Si es dato vlido,
lcd_data(c);
// enviarlo a LCD
else
// Si no (c = 0x00 = fin),
goto start;
// salir de los dos bucles for
}
delay_ms(400);
i++;
}
}
}

Descripcin del programa

El texto de la pantalla se desplaza una posicin cada 400 ms. Si te parece que avanza
muy lento, puedes disminuir esta pausa. No obstante, podras empezar a ver como si
hubiera dos letras por casillero de la pantalla. Ello se debe a que el carcter enviado al
LCD no se muestra ni se borra de inmediato. Es lo que sus datasheets indican como
tiempo de respuesta de visualizacin.
En general, a diferencia del Basic, en C es muy mal visto el uso de un goto, salvo un
caso extremo. goto funciona como en el ensamblador: salta a otro punto del programa,
identificado con una etiqueta. Mi goto salta a la etiqueta start para salir de dos bucles
al mismo tiempo. Dicen que se es uno de los pocos casos considerados extremos:
salir intempestivamente de varios bucles anidados. A decir verdad, siempre hay
algoritmos alternativos para evitar el goto.

MICROCONTROLADORES < VISUALIZACION DE DATOS CARACTERES -GRAFICOS CON LC>

PRACTICA4

CARACTERES GRFICOS EN LCD

La creacin de caracteres grficos puede ser un tema superfluo. Aun as, suponiendo
que no faltarn algunas personas obsesivas como yo, que siempre quieren probarlo
todo, he preparado esta prctica para ir cerrando el captulo.
Hagamos un poco de memoria. Cuando enviamos el cdigo de un carcter
alfanumrico a la DDRAM del LCD, su chip interno buscar en la CGROM el patrn
correspondiente y luego lo visualizar en la pantalla. As se escriben todos textos (y
as hemos trabajado hasta ahora).
Ahora bien, si el cdigo enviado vale entre 0x00 y 0x07 (o 0x08 y 0x0F), el chip interno
buscar su patrn de visualizacin en la CGRAM. Siendo sta una RAM de
lectura/escritura, podemos programar en ella los diseos que se nos ocurran.

Mapa de memoria para la creacin de nuevos caracteres.

La CGRAM (Character Generator RAM) consta de 64 bytes en los que se pueden
escribir los patrones de 8 nuevos caracteres de 57 puntos 4 caracteres de 510
puntos. Aqu veremos el primer caso.

MICROCONTROLADORES < VISUALIZACION DE DATOS CARACTERES -GRAFICOS CON LC>

Cuando los caracteres son de 57 puntos los 64 bytes se dividen en 8 bloques de 8
bytes cada uno, y cada bloque almacena el patrn de un nuevo carcter. El esquema
mostrado arriba indica que:

El primer bloque de CGRAM, con direcciones desde 0b00000000 hasta

0b00000111, corresponde al cdigo 0x00 ( 0x80) de la DDRAM.
El segundo bloque CGRAM, con direcciones desde 0b00001000 hasta
0b00001111, corresponde al cdigo 0x01 ( 0x88) de la DDRAM; y as
sucesivamente.

Por ejemplo, la figura de arriba indica que se han rellenado los dos primeros bloques
con los patrones de dos pacman. Hasta ah solo se han creado dos nuevos caracteres.
Para mostrarlos en el LCD habra que escribir un cdigo as:
lcd_data(0x00); // Visualizar primer pacman
lcd_data(0x01); // Visualizar segundo pacman
Esquema

Se muestra en el LCD un pacman que se desplaza de uno a otro lado.

El cdigo fuente
/*******************************************************************
* FileName:
main.c
* Purpose:
LCD - Creacin de caracteres grficos personalizados
********************************************************************/
#include "avr_compiler.h"
#include "lcd.h"
#define LCD_LEN
16
// Para LCD de 216
/* Identificadores de los nuevos caracteres */
#define PacR1
0x00
#define PacR2
0x01
#define PacL1
0x02
#define PacL2
0x03

MICROCONTROLADORES < VISUALIZACION DE DATOS CARACTERES -GRAFICOS CON LC>

/* Patrones de los nuevos caracteres a crearse */
PROGMEM const char Pattern1[] =
{0x0F,0x1C,0x18,0x10,0x18,0x1C,0x0F,0x00};
PROGMEM const char Pattern2[] =
{0x00,0x0E,0x1F,0x10,0x1F,0x0E,0x00,0x00};
PROGMEM const char Pattern3[] =
{0x1E,0x07,0x03,0x01,0x03,0x07,0x1E,0x00};
PROGMEM const char Pattern4[] =
{0x00,0x0E,0x1F,0x01,0x1F,0x0E,0x00,0x00};
void delay_ms(unsigned int t)
{
while(t--)
delay_us(1000);
}
void create_char(unsigned char a, PGM_P p)
{
unsigned char i;
lcd_cmd(LCD_CGRAM + a);
// Instruccin Set CGRAM Address
for (i=0; i<8; i++)
lcd_data(pgm_read_byte(p+i));
}
int main(void)
{
signed char i;
// Debe ser variable con signo
lcd_init();
// Inicializar LCD
/* Crear los nuevos caracteres (los pacman's)
* Esto es volcar los patrones de los pacman en la CGRAM */
create_char(PacR1*8, Pattern1);
create_char(PacR2*8, Pattern2);
create_char(PacL1*8, Pattern3);
create_char(PacL2*8, Pattern4);
lcd_clear();
// Limpiar pantalla y regresar a DDRAM
lcd_puts(" Hungry Pacman ");
// Escribir "Hungry Pacman" en LCD
while(1)
{
/* Pacman desplazndose a la derecha */
for(i=0; i<LCD_LEN; i++)
{
lcd_cmd(LCD_LINE2+i);
// Cursor a posicin i de lnea 2
if(i & 0x01)
// Si bit 0 de i es 1,
lcd_data(PacR1);
// enviar pacman abierto
else
// Si no,
lcd_data(PacR2);
// enviar pacman cerrado
lcd_cmd(LCD_LINE2+i-1);//Cursor a posicin anterior de lnea 2
lcd_data(' ');
// para borrar pacman previo
delay_ms(200);
}
/* Pacman desplazndose a la izquierda */
for(i=LCD_LEN; i>=0; i--)
{
lcd_cmd(LCD_LINE2+i);
// Cursor a posicin i de lnea 2
if(i & 0x01)
// Si bit 0 de i es 1,
lcd_data(PacL1);
// enviar pacman abierto
else
// Si no,
lcd_data(PacL2);
// enviar pacman cerrado
//lcd_cmd(LCD_LINE2+i+1);//Cursor a posicin anterior de lnea 2
lcd_data(' ');
// para borrar pacman previo
delay_ms(200);
}
}
}

MICROCONTROLADORES < VISUALIZACION DE DATOS CARACTERES -GRAFICOS CON LC>

Descripcin del programa

Despus de iniciado el LCD, los datos que se le enven irn a la DDRAM (para mostrar
caracteres en la pantalla). Como los patrones de los pacman deben ir en la CGRAM
necesitamos establecerla como destino. Para eso enviamos el comando Set CGRAM
Address con la direccin de CGRAM que queremos acceder. La funcin create_char
rellena con 8 bytes del array p que se le pasa como parmetro el segmento de
CGRAM que empieza en la direccin a.
void create_char(unsigned char a, PGM_P p)
{
unsigned char i;
lcd_cmd(LCD_CGRAM + a);
// Instruccin Set CGRAM Address
for (i=0; i<8; i++)
lcd_data(pgm_read_byte(p+i));
}

Notemos que al trmino de la funcin create_char el puntero de RAM sigue dirigido a

la CGRAM. Por tanto para visualizar los caracteres en la pantalla, incluyendo los
nuevos caracteres creados, tenemos que volver a seleccionar la DDRAM. Para esto
tenemos la instruccin Set DDRAM Address, Return Home y Clear Display.
Todas estas instrucciones estn relacionadas con el cursor, el cual a su vez no es otra
cosa que el puntero RAM trabajando sobre la DDRAM. Yo us la tercera opcin con
sentencia lcd_clear() que aparemtenente no tena sentido porque la pantalla ya est
limpia tras la inicializacin.
Como hemos creado los 4 pacman en los 4 primeros bloques (de 8 bytes) de la
CGRAM, los cdigos para accederlos sern 0 (PacR1), 1 (PacR2), 2 (PacL1) y 3
(PacL2), respectivamente.
Por si no qued claro cmo se forman los patrones de los pacman, aqu tenemos los
dos primeros. (Los bits no importan, pueden ser 1s o 0s.)

PROGMEM const char Pattern1 [] =

{0x0F,0x1C,0x18,0x10,0x18,0x1C,0x0F,0x00};
PROGMEM const char Pattern2 [] =
{0x00,0x0E,0x1F,0x10,0x1F,0x0E,0x00,0x00};

Solo debemos tener un poco de paciencia para elaborar los arrays de los patrones.
Ahora que si no la tienes o prefieres un atajo, puedes utilizar una de las tantas
herramientas que abundan (me gusta la flexibilidad de LCD Font Creator). Inclusive los
mismos compiladores como CodeVisionAVR o MikroC proveen los suyos. Abajo se ve
cmo el generador de caracteres de MikroC nos cambia el descifrado de cdigo
binario por simples clics. El cdigo generado incluye una funcin que crea y visualiza
el nuevo carcter, pero a m solo me interesa el array.
9

MICROCONTROLADORES < VISUALIZACION DE DATOS CARACTERES -GRAFICOS CON LC>

10