Pantalla LCD 162 con PIC (Librera en C para HD44780)

http://www.geekfactory.mx/tutoriales/tutoriales-pic/pantalla-lcd-16x2-con-piclibreria/

Cuando los simples indicadores luminosos con led ya no son suficientes, habitualmente el
siguiente paso para todo programador es ir por una pantalla lcd 162. Llegados a este
punto, encontramos que existen mdulos LCD que facilitan la interfaz con este perifrico.
El estndar en la industria para estos mdulos con controlador a bordo es el chipset
HD44780 (y otros ms compatibles desarrollados a partir de este), para los cuales
encontramos soporte en prcticamente cualquier plataforma: Arduino, PIC, AVR, MSP430,
etc.
En esta entrada introducimos la librera de control altamente portable a cualquier
microcontrolador, la cual puede ser utilizada tanto para PIC, como AVR y prcticamente
cualquier otro microcontrolador o computadora embebida que se nos ocurra.
Nuestra foto de portada para el artculo muestra mdulos LCD con iluminacin azul y
letras color blanco.

Conexiones bsicas de una pantalla lcd 162

El HD44780 permite conectarse a travs de un bus de 4 u 8 bits. El modo de 4 bits permite
usar solo 4 pines para el bus de datos, dndonos un total de 6 o 7 pines requeridos para la
interfaz con el LCD, mientras que el modo de 8 bits requiere 10 u 11 pines. El pin RW es
el nico que puede omitirse si se usa la pantalla en modo de solo escritura y deber
conectarse a tierra si no se usa. En este caso el microcontrolador no puede leer desde el
chip controlador de pantalla, pero en la mayora de las situaciones esto no es necesario y
nuestra librera no implementa aun esta funcionalidad.
Notese que todas estas configuraciones son ilustrativas, la pantalla se puede conectar a
cualquier combinacin de pines posible, ya que nuestra librera soporta usar cualquier pin
como parte del bus de datos y seales de control.
Diagrama para modo de 4 bits

Las conexiones para el mdo de 4 bits en un PIC16F88 se muestran a continuacin. Se

utilizan los primeros 4 bits del puerto A (RA0-RA3) como bus de datos. RB0 como seal de
habilitacin (E) y RB1 como seal de seleccin de registro (RS).

Diagrama para modo de 8 bits

Las conexiones para el mdo de 8 bits son algo ms complicadas, ya que requerimos las 8
lineas de datos activas. En este caso utilizaremos los 8 bits del puerto B, aunque se puede
usar cualquier combinacin de pines con nuestra librera. RA0 ahora funciona como seal
de seleccin de registro (RS) y RA1 como seal de habilitacin (E).

Comandos del controlador HD44780

Para conocer un poco mejor los comandos soportados por la librera para la pantalla lcd
162, es necesario estudiar el juego de instrucciones soportadas por el chip controlador de
pantalla, el cual se resume en la siguiente tabla que hemos traducido de la hoja de datos. La
mayora de los comandos listados pueden ser ejecutados llamando a una funcin en C de
nuestra librera.
Cdigo de Operacin
Instrucci
n
R R/ B B B B
B B
B3 B2
S W 7 6 5 4
1 0
Clear
display

Cursor
home

0 0 0 0

0 0 0 0

Descripcin

Borra el contenido de la pantalla

0 1 y retorna el cursor a la posicin 1.52 ms
home (direccin 0).

Retorna el cursor a la posicin

Home. Retorna tambin el rea
* de visin a la posicin inicial. El 1.52 ms
contenido de la DDRAM
permanece intacto.

Entry mode
0
set

0 0 0 0

Incrementar/Decrementar
direccin (I/D); Habilitar
1 I/D S corrimiento de pantalla (S). Estas
operaciones se realizan al leer o
escribir datos

Display
on/off
control

0 0 0 0

Cursor/displ
0
ay shift

0 0 0 1

Function
set

0 0 1

0 1

Set CGRAM
address

Tiempo
de
Ejecuci
n

Enciende o apaga el display (D),

C B Cursor encendido / apagado (C),
destello del cursor (blink) (B).

S/ R/
*
C L

D
N
L

37 s

37 s

Selecciona entre desplazamiento

de pantalla o de cursor (S/C),
selecciona la direccin de
*
desplazamiento (R/L). El
contenido de la DDRAM
permanece intacto.

37 s

Configurar en ancho de bus (4 u

* 8 bits) (DL),Numero de lineas de
display (N), y tipo de fuente (F).

37 s

CGRAM address

Escribe la direccin de CGRAM.

Los datos a almacenar en
CGRAM pueden ser enviados

37 s

despus de esta instruccin

Set DDRAM
0
address

DDRAM address

Escribe la direccin de DDRAM.

Los datos a almacenar en
DDRAM pueden ser enviados
despus de esta instruccin

CGRAM/DDRAM
address

Leer bandera Ocupado (Bussy

Flag) indicando si el controlador
est realizando alguna operacin
interna o esta listo para aceptar
datos/comandos. Lee la direccin
CGRAM o DDRAM (dependiendo
de la instruccin previa).

37 s

Read busy
flag
&address
counter

Write
CGRAM
orDDRAM

Write Data

Escribe datos a las memorias

CGRAM o DDRAM.

37 s

Read from
CG/DDRAM

Read Data

Lee datos desde las memorias

CGRAM o DDRAM.

37 s

B
F

Nombres y significado de de bits en instrucciones

I/D 0 = disminuir el contador de direccin, 1 = incrementar el contador de direccin;
S 0 = Sin corrimiento de display, 1 = Con corrimiento de display;
D 0 = Display Apagado, 1 = Display Encendido;
C 0 = Cursor Apagado, 1 = Cursor Encendido;
B 0 = Parpadeo cursor Apagado, 1 = Parpadeo Cursor Encendido;
S/C 0 = Mover Cursor, 1 = Corrimiento de pantalla;
R/L 0 = Mover/Correr a la izquierda, 1 = Mover/Correr a la derecha;
DL 0 = Interfaz de 4 bits, 1 = Interfaz de 8 bits;
N 0 = 1 linea, 1 = 2 lineas;
F 0 = 58 puntos, 1 = 510 puntos;
BF 0 = puede aceptar instruccin, 1 = operacin interna en progreso.

0 s

Librera para pantalla de 162 con PIC

Nuestra librera para pantalla lcd 162 se encuentra alojada en Github. La librera es
capaz de controlar una pantalla conectada en cualquier combinacin de pines del
microcontrolador. Adems es bastante fcil llevar esta librera a otros microcontroladores
PIC de mejor desempleo y tambin a microcontroladores de otras marcas (Atmel, TI
MSP430, etc). De igual forma, el cdigo esta pensado para admitir distintas capas de
abstraccin de hardware para el acceso a pines de entrada/salida en situaciones en las que
esto no sea tan sencillo como lo es en un microcontrolador (abordaremos esto en otra
entrada futura sobre la conexin de una pantalla a un Raspberry Pi).
La librera para pantalla lcd 162 puede encontrarse en el siguiente repositorio que puedes
clocar o bien descargar los archivos de la librera en formato ZIP.

https://github.com/geekfactory/LCD
Para obtener la ultima versin de la librera podemos usar git con el siguiente comando:
git clone --recursive https://github.com/geekfactory/LCD.git

La librera bsica para el PIC consiste en 4 archivos de cdigo fuente:

LCD.h Contiene la declaracin y documentacin de las funciones

(prototipos).
LCD.c Definicin del funcionamiento de las funciones de usuario (API)
de la pantalla LCD.

LCD-PIC16.h - Configuracin especfica para la LCD en la arquitectura

del microcontrolador PIC.

LCD-PIC16.c Definicin de las funciones especficas para acceso a los

pines de I/O en el PIC16.

Como ya dijimos, a veces utilizamos esta librera en otros microcontroladores, por esta
razn puedes encontrar otros archivos en github, pero estos 4 son los que se requieren para
trabajar en cualquier proyecto con PIC.

Configuracin de los pines en la librera

Para adecuar la librera para pantalla lcd 162 a nuestro circuito hay que editar el
archivo LCD-PIC16.h. Dentro de este, encontramos las definiciones de los pines utilizados
en la interfaz con el controlador de pantalla. En este caso definimos un bus de 4 bits en la
parte baja del puerto A (RA0 RA3) y lineas de control RS y E en los pines RB1 y RB0
respectivamente. Esto corresponde a la ilustracin del modo de 4 bits que se encuentra
arriba en esta pgina.

/**
* Definitions for common control lines
*/
#define
#define
#define
#define

LCD_PIN_RS PORTBbits.RB1
LCD_TRIS_RS
TRISBbits.TRISB1
LCD_PIN_E PORTBbits.RB0
LCD_TRIS_E TRISBbits.TRISB0

/**
* Configuration example for 4 bit mode
*/
#define LCD_TRIS_D4
TRISAbits.TRISA0
#define LCD_TRIS_D5
TRISAbits.TRISA1
#define LCD_TRIS_D6
TRISAbits.TRISA2
#define LCD_TRIS_D7
TRISAbits.TRISA3
#define LCD_PIN_D4 PORTAbits.RA0
#define LCD_PIN_D5 PORTAbits.RA1
#define LCD_PIN_D6 PORTAbits.RA2
#define LCD_PIN_D7 PORTAbits.RA3

Para utilizar la librera con un bus de 8 bits, es necesario definir los pines restantes del bus
de datos: LCD_PIN_D0 a LCD_PIN_D3.
Escribir caracteres a la pantalla

Cada uno de los caracteres que escribimos a la pantalla son almacenados en una ubicacin
en la memoria RAM apuntada por la direccin del cursor. Cuando escribimos un carcter,
el cdigo ASCII correspondiente a este, se almacena en la memoria interna conocida como
Display Data RAM o DDRAM. Para escribir caracteres a la DDRAM utilizamos las
funciones lcd_write() y lcd_puts(), que escriben un caracter y una cadena, respectivamente.
// Podemos mover el cursor a donde deseamos comenzar a escribir
lcd_goto( 0, 0 );
// Enviamos texto a la pantalla (DDRAM)
lcd_puts( "Hola Mundo" );
// Enviar un solo caracter (signo de admiracion)
lcd_write("!");

Definir nuestros propios caracteres personalizados en una pantalla lcd

162

El controlador HD44780 en la pantalla lcd 162 nos permite tambin definir caracteres
especiales definidos por el usuario (hasta 8 caracteres). Cuando deseamos escribir un
carcter personalizado, el mapa de bits que lo compone se almacenan en otro segmento de
memoria independiente conocida como Character Generator RAM o simplemente
CGRAM. Cada carcter se define como un grupo de 8 bytes que se envan a la memoria
CGRAM. Por ejemplo, podemos crear un cono con una carita feliz de la siguiente forma:

Mapa de bits para caracteres personalizados (CGRAM) en pantalla HD44780

En lenguaje C podemos declarar un array con el caracter personalizado que mostramos en
la figura anterior de la siguiente manera:
// Caracter personalizado carita feliz :)
const char smile[8] = {
0b00000000,
0b00001010,
0b00001010,
0b00001010,
0b00000000,
0b00010001,
0b00001110,
0b00000000,
};

Para usar el caracter, es necesario transferirlo al controlador de pantalla mediante la funcin

lcd_create_char() y luego mostrarlo en pantalla enviando el cdigo correspondiente al

caracter con la funcin lcd_write(). El cdigo para mostrar el carcter que acabamos de
crear quedara de la siguiente manera:
// Cargar el caracter a CGRAM
// El primer parmetro es el cdigo del caracter (0 - 7)
// El segundo es el apuntador a donde se guarda el bitmap (el array declarado
anteriormente)
lcd_create_char(0, smile);
// Borrar la pantalla despues de terminar de escribir a CGRAM
lcd_clear();
// Escribir el cdigo de carita feliz (nmero 0 de 7)
lcd_write(0);

Ejemplo completo MPLAB pantalla LCD 162

En el programa de ejemplo aplicamos lo aprendido para iniciar la pantalla, mostrar letras,
mover el cursor y escribir caracteres personalizados. Dentro del repositorio de Github
podemos encontrar el proyecto demo para MPLAB X listo para compilarse para un
PIC16F88 pero que podemos utilizar fcilmente con cualquier microcontrolador de la
familia PIC16F.
El programa requiere un PIC16F88 con cristal de 4 Mhz conectado en los pines
correspondientes y la pantalla conectada como se muestra en la ilustracin de Modo de 4
bits mostrada ms arriba.
#define CONFIG_TIMING_MAIN_CLOCK 1000000
#include <xc.h>
// Encabezado para el compilador XC8
#include "../LCD.h"
/* Device specific configuration */
#pragma config FOSC = XT
// Oscillator Selection bits (XT oscillator)
#pragma config WDTE = OFF
// Watchdog Timer Enable bit (WDT disabled)
#pragma config PWRTE = OFF
// Power-up Timer Enable bit (PWRT disabled)
#pragma config MCLRE = ON
// RA5/MCLR/VPP Pin Function Select bit
// (RA5/MCLR/VPP pin function is MCLR)
#pragma config BOREN = OFF
// Brown-out Reset Enable bit (BOR disabled)
#pragma config LVP = OFF
// Low-Voltage Programming Enable bit (RB3 is
// digital I/O, HV on MCLR must be used for
// programming)
#pragma config CPD = OFF
// Data EE Memory Code Protection bit (Code
// protection off)
#pragma config WRT = OFF
// Flash Program Memory Write Enable bits (Write
// protection off)
#pragma config CCPMX = RB0
// CCP1 Pin Selection bit (CCP1 function on RB0)
#pragma config CP = OFF
// Flash Program Memory Code Protection bit
// (Code protection off)
#pragma config FCMEN = OFF
// Fail-Safe Clock Monitor Enable bit (Fail-Safe
// Clock Monitor disabled)

#pragma config IESO = OFF

// Internal External Switchover bit (Internal
// External Switchover mode disabled)
// Declaration of custom characters
const char arrowr[8] = {
0b00001000,
0b00000100,
0b00000010,
0b00011111,
0b00000010,
0b00000100,
0b00001000,
0b00000000,
};
const char arrowu[8] = {
0b00000100,
0b00001110,
0b00010101,
0b00000100,
0b00000100,
0b00000100,
0b00000100,
0b00000000,
};
const char arrowd[8] = {
0b00000100,
0b00000100,
0b00000100,
0b00000100,
0b00010101,
0b00001110,
0b00000100,
0b00000000,
};
const char arrowl[8] = {
0b00000010,
0b00000100,
0b00001000,
0b00011111,
0b00001000,
0b00000100,
0b00000010,
0b00000000,
};
void main()
{
int i;
ANSEL = 0x00;
TRISA = 0xFF;
TRISB = 0x7F;

// Initialize lcd driver

lcd_init(0, 16, 2);
// Load characters to CGRAM
lcd_create_char(0, arrowr);
lcd_create_char(1, arrowu);
lcd_create_char(2, arrowl);
lcd_create_char(3, arrowd);
// Clear screen to end write to character generator
lcd_clear();
// Turn on display
lcd_on();
// Display message on the first row
lcd_puts(" geekfactory.mx ");
// Move cursor to the fourth column on second line
lcd_goto(3, 1);
// Print a message there
lcd_puts("Hello World");
// Mover cursor to the sixteenth column on second row
lcd_goto(15, 1);
// Main loop
for (;;) {
for (i = 0; i < 4; i++) {
// 1 Hz led blink
delay_ms(500);
// Toggle pin RB7
PORTB ^= 0x80;
// Write custom defined character code (can be 0-7)
lcd_write(i);
// Goto the last visible position on the screen
lcd_goto(50, 50);
}
}
}

Resultado del programa de prueba

Al cargar y ejecutar de manera exitosa el programa de prueba en el microcontrolador,
deberamos ver en nuestra pantalla algo como lo siguiente:

Si no aparece nada en la pantalla o solamente aparecen caracteres que no se reconocen,

procederemos a revisar cada uno de los siguientes aspectos del montaje:

Revisar el potenciometro de contraste: cambiar de posicin hasta que

logremos ver algo
Revisar que las seales E y RS estn conectadas en los pines adecuados

Revisar las conexiones en el bus de datos, revisar que los pines

coincidan con los definidos en el programa

Revisar la velocidad de reloj, si el controlador no puede recibir

correctamente algunos comandos podra causar que la informacin no
se muestre correctamente.

Tips y trucos para el uso de esta librera

Revisa la ayuda incluida

Te recomendamos aprovechar al mximo el apoyo de la documentacin incluida. Si

estamos acostumbrados a trabajar con MPLAB X siempre podemos oprimir las teclas
CTRL + Espacio para acceder a la funcin de autocompletado. Esta funcin nos muestra
una ventana sobre nuestro editor de texto donde podemos observar la documentacin de la
librera. Esto incluye las funciones disponibles e informacin sobre los parmetros que
reciben. La ventana de autocompletado tiene la siguiente apariencia:

Use caracteres personalizados

La librera viene con funciones que permiten definir caracteres especiales. En el ejemplo de
la librera hemos definido 4 caracteres personalizados (flechas) que aparecen durante el
programa de demostracin. Sin embargo, la creatividad de cada persona permitir crear
caracteres que pueden utilizarse como iconos para los ms diversos usos.

Aporta tus ideas y correcciones

Nuestra librera de LCD esta alojada en github. Cualquier persona puede realizar
correcciones o mejoras al cdigo fuente y aportarlas al repositorio. Alguien en nuestro
equipo revisar los cambios propuestos y los integrar al cdigo principal en caso de ser
necesario.

Descargas y enlaces relacionados

Descarga de la hoja de datos de la pantalla en nuestra tienda virtual

Descarga de la hoja de datos del controlador HD44780 original

Compra tus pantallas LCD en nuestra tienda virtual

Conclusin
En este artculo, sentamos las bases para que puedas incluir de manera sencilla pantallas
LCD de 162 caracteres en tus diseos con microcontroladores PIC. Nosotros lo hacemos
habitualmente y encontrars muchos ejemplos que funcionan con esta librera dentro de
nuestro sitio web.
Como ya dijimos, te invitamos a crear una cuenta en Github y a mejorar la librera y aportar
cualquier mejora que creas conveniente. Ser un placer tambin recibir tus comentarios a
travs de este medio o mediante correo electrnico.