Raspberry Pi Python: LCD

Pantalla LCD con la Raspberry Pi

El tutorial asume que la tarjeta Raspberry Pi ya se encuentra configurada con el sistema operativo RASPBIAN. Si todavía no está instalado aquí lo pueden descargar y también pueden encontrar una guía de como grabar una imagen en la memoria SD con diferentes sistemas operativos.

http://www.raspberrypi.org/downloads/

Existen varias bibliotecas para controlar una LCD 16×2 estándar con una Raspberry PI, en este caso se presenta un script realizado en python para poder desplegar mensajes de una manera sencilla y sin el usar bibliotecas externas.

Primero que nada es necesario conocer un poco acerca de los pines de la LCD, en este caso, estaremos haciendo uso de un «LCD Keypad Shield»  y nuestra tarjeta interfaz para usar shields Arduino (no tenemos que conectar nada, solo montar una tarjeta sobre otra) pero de cualquier manera se puede conectar la LCD directo al GPIO, ya que la mayoria de las pantallas LCD con el controlador DH44780 funcionan con 3.3V

Como se menciona previamente, para nosotros solo es asignar los pines del GPIO a la pantalla, de cualquier manera a continuación se muestra una tabla en donde se puede ver la relación entre el GPIO, el HeTPro PiDuino y el LCD Keypad Shield. Si no tienes el PiDuino solo conecta el GPIO con el Bus de datos de la pantalla LCD. Ojo esta tabla no contempla los pines de alimentación ni de contraste para la LCD!!!.

La configuración para este ejemplo es la siguiente:

[code language=»python»]
# DEFINICIONES PARA ASIGNACIÓN DE PINES
LCD_RS = 27
LCD_E = 22
LCD_D4 = 24
LCD_D5 = 25
LCD_D6 = 4
LCD_D7 = 17
[/code]

Antes de poder escribir algo en la pantalla necesitamos inicializar otras definiciones de la misma, así como la configuración de los pines de la raspberry,

[code language=»python»]
# DEFINIR CONSTANTES DEL DISPOSITIVO
LCD_WIDTH = 16 # CARACTERES MAXIMOS POR FILA
LCD_CHR = True
LCD_CMD = False
LCD_LINE_1 = 0x80 # DIRECCION RAM PARA PRIMERA LINEA
LCD_LINE_2 = 0xC0 # DIRECCION RAM PARA SEGUNDA LINEA
E_PULSE = 0.00005 # CONSTANTES PARA RETARDOS
E_DELAY = 0.00005

def main():
# DEFINIR GPIO COMO SALIDA PARA USAR LA LCD
GPIO.setmode(GPIO.BCM) # USAR LA NOMENCLATURA BCM (HARDWARE)
GPIO.setup(LCD_E, GPIO.OUT) # E
GPIO.setup(LCD_RS, GPIO.OUT) # RS
GPIO.setup(LCD_D4, GPIO.OUT) # DB4
GPIO.setup(LCD_D5, GPIO.OUT) # DB5
GPIO.setup(LCD_D6, GPIO.OUT) # DB6
GPIO.setup(LCD_D7, GPIO.OUT) # DB7
[/code]

Una vez configuradas las definiciones (solo si se requiere, ya que las definiciones de retardos y direcciones son las estandar para la pantalla, y la configuración del GPIO como salida esta en función de las definiciones previas) es necesario realizar un proceso de inicialización de la pantalla, para esto se recomienda hacer referencia a la hoja de datos y revisar el proceso para 4 bits.

Hoja de datos HD44780

Revisar las paginas 42 a 44 y 46.

Para escribir algo en la pantalla solo se hara uso de la funcion «lcd_string». Cabe señalar que la misma solo es valida para una cadena de caracteres de longitud máxima de 16, una cadena mas larga sera truncada.

[code language=»python»]
# ENVIAR DATOS DE PRUEBA
lcd_byte(LCD_LINE_1, LCD_CMD)
lcd_string("Rasbperry Pi")
lcd_byte(LCD_LINE_2, LCD_CMD)
lcd_string("Model B")
time.sleep(5)

lcd_byte(LCD_LINE_1, LCD_CMD)
lcd_string("HeTPro")
lcd_byte(LCD_LINE_2, LCD_CMD)
lcd_string("PiDuino / LCD")
time.sleep(5)
[/code]

El código completo del programa se muestra a continuación.

[code language=»python»]
# 1 : GND
# 2 : 5V
# 3 : Contrast (0-5V)*
# 4 : RS (Register Select)
# 5 : R/W (Read Write) – GND
# 6 : Enable or Strobe
# 7 : Data Bit 0 – SIN USAR
# 8 : Data Bit 1 – SIN USAR
# 9 : Data Bit 2 – SIN USAR
# 10: Data Bit 3 – SIN USAR
# 11: Data Bit 4
# 12: Data Bit 5
# 13: Data Bit 6
# 14: Data Bit 7
# 15: LCD Backlight +5V**
# 16: LCD Backlight GND
# IMPORTAR BIBLIOTECAS NECESARIAS, SOLO GPIO Y TIME PARA RETARDOS
import RPi.GPIO as GPIO
import time

GPIO.cleanup()

# DEFINICIONES PARA ASIGNACION DE PINES
LCD_RS = 27
LCD_E = 22
LCD_D4 = 24
LCD_D5 = 25
LCD_D6 = 4
LCD_D7 = 17

# DEFINIR CONSTANTES DEL DISPOSITIVO
LCD_WIDTH = 16 # CARACTERES MAXIMOS POR FILA
LCD_CHR = True
LCD_CMD = False
LCD_LINE_1 = 0x80 # DIRECCION RAM PARA PRIMERA LINEA
LCD_LINE_2 = 0xC0 # DIRECCION RAM PARA SEGUNDA LINEA
E_PULSE = 0.00005 # CONSTANTES PARA RETARDOS
E_DELAY = 0.00005

def main():
# DEFINIR GPIO COMO SALIDA PARA USAR LA LCD
GPIO.setmode(GPIO.BCM) # USAR LA NOMENCLATURA BCM (HARDWARE)
GPIO.setup(LCD_E, GPIO.OUT) # E
GPIO.setup(LCD_RS, GPIO.OUT) # RS
GPIO.setup(LCD_D4, GPIO.OUT) # DB4
GPIO.setup(LCD_D5, GPIO.OUT) # DB5
GPIO.setup(LCD_D6, GPIO.OUT) # DB6
GPIO.setup(LCD_D7, GPIO.OUT) # DB7

# INICIALIZAR DISPLAY
lcd_init()

# ENVIAR DATOS DE PRUEBA
lcd_byte(LCD_LINE_1, LCD_CMD)
lcd_string("Rasbperry Pi")
lcd_byte(LCD_LINE_2, LCD_CMD)
lcd_string("Model B")
time.sleep(5)

lcd_byte(LCD_LINE_1, LCD_CMD)
lcd_string("HeTPro")
lcd_byte(LCD_LINE_2, LCD_CMD)
lcd_string("PiDuino / LCD")
time.sleep(5)

def lcd_init():
# PROCESO DE INICIALIZACION
lcd_byte(0x33,LCD_CMD)
lcd_byte(0x32,LCD_CMD)
lcd_byte(0x28,LCD_CMD)
lcd_byte(0x0C,LCD_CMD)
lcd_byte(0x06,LCD_CMD)
lcd_byte(0x01,LCD_CMD)

def lcd_string(message):
# ENVIAR UN STRING A LA LCD
message = message.ljust(LCD_WIDTH," ")
for i in range(LCD_WIDTH):
lcd_byte(ord(message[i]),LCD_CHR)

def lcd_byte(bits, mode):
# ENVIAR UN BYTE A LOS PINES DE DATOS
# bits = DATOS
# mode = True PARA CARACTER
# False PARA COMANDO
# VER HOJA DE DATOS

GPIO.output(LCD_RS, mode) # RS
GPIO.output(LCD_D4, False)
GPIO.output(LCD_D5, False)
GPIO.output(LCD_D6, False)
GPIO.output(LCD_D7, False)
if bits&0x10==0x10:
GPIO.output(LCD_D4, True)
if bits&0x20==0x20:
GPIO.output(LCD_D5, True)
if bits&0x40==0x40:
GPIO.output(LCD_D6, True)
if bits&0x80==0x80:
GPIO.output(LCD_D7, True)

time.sleep(E_DELAY)
GPIO.output(LCD_E, True)
time.sleep(E_PULSE)
GPIO.output(LCD_E, False)
time.sleep(E_DELAY)

GPIO.output(LCD_D4, False)
GPIO.output(LCD_D5, False)
GPIO.output(LCD_D6, False)
GPIO.output(LCD_D7, False)

if bits&0x01==0x01:
GPIO.output(LCD_D4, True)
if bits&0x02==0x02:
GPIO.output(LCD_D5, True)
if bits&0x04==0x04:
GPIO.output(LCD_D6, True)
if bits&0x08==0x08:
GPIO.output(LCD_D7, True)

time.sleep(E_DELAY)
GPIO.output(LCD_E, True)
time.sleep(E_PULSE)
GPIO.output(LCD_E, False)
time.sleep(E_DELAY)

if __name__ == ‘__main__’:
main()
[/code]