Bienvenido a mi blog, hoy hablaremos un poco de como realizar
un manejo básico de un modulo I2C LCD, de 2 filas por 16 columnas, con nuestra Raspberry Pi
Pico usando MicroPython. Inicialmente, debemos conocer las funciones del I2C con Micropython para poder determinar la
dirección I2C del componente y posteriormente, conectar la Raspberry Pi
Pico al LCD 16×2 I2C. A partir de la documentación oficial de MicroPython podemos determinar:
i2c = machine.I2C(id
= -1 , * , scl , sda , frecuencia = 400000)
Se construye el objeto I2C usando los siguientes
parámetros:
-
id identifica un periférico I2C en particular. El
valor predeterminado de -1 selecciona una implementación de software de
I2C que puede funcionar (en la mayoría de los casos) con
pines arbitrarios para SCL y SDA. Si id es -1, entonces se deben
especificar los pines scl y sda . Otros valores permitidos para id
dependen del puerto/placa en particular, dado que hay placas que poseen
varios puertos I2C y la especificación de scl y sda puede
o no ser requerida o permitida en este caso.
-
scl debe ser un objeto tipo pin que especifique el pin que se
utilizará para SCL.
-
sda debe ser un objeto tipo pin que especifique el pin que se
utilizará para SDA.
-
freq debe ser un número entero que establezca la frecuencia máxima
para SCL.
"Construir un objeto en Micropython significa crear una instancia de una clase. Una clase es un modelo o plantilla para crear objetos con atributos y métodos específicos. Para construir un objeto, primero se define la clase y luego se crea una instancia de esa clase utilizando paréntesis".
Para esta publicación asumo que el usuario ya ha cargado previamente el
firmware de Micropython en su Raspberry Pi Pico y que ya tiene instalado
el IDE de Thonny, además de que ya tenga bases de manejo de LCD en
otras plataformas como Arduino o PIC.
No es el objetivo de este articulo abordar toda la teoría y la historia de
las pantallas lcd, así que hare un breve resumen acotando que la LCD (Liquid
Crystal Display) o pantalla de cristal líquido, es un dispositivo empleado
para la visualización de contenidos o información de una forma gráfica,
mediante caracteres, símbolos o pequeños dibujos. La pantalla LCD de 16×2
esta basada en el controlador HD44780 de Hitachi, dicha
pantalla es un periférico que se utiliza ampliamente en proyectos con
microcontroladores y el modulo I2C está gobernado internamente por un controlador PCF8574, el cúal es un expansor de Entradas y Salidas digitales controlado
por I2C que dirige todo su funcionamiento. En este caso vamos a emplear una LCD
de 16x2, esto quiere decir que dispone de 2 filas de 16 caracteres cada una.
En la siguiente imagen se puede observar la estructura de sus pines. La
podemos dividir en, los pines de alimentación, los
pines de control y los pines del bus de datos bidireccional.
Por lo general podemos encontrar además, en su estructura, los pines de
Ánodo (+) de led backlight y cátodo (-) de led backlight [Los pines 15 y 16
de backligth se deben manejar de manera pulsante con una frecuencia de 60Hz,
también se puede utilizar una resistencia fija de 10 ohmios 1/2 watio para
alimentar el positivo del backligth en caso de hacerlo manualmente sin
modulo I2C].
Si estamos empleando en nuestro proyecto una LCD con la Raspberry Pi Pico,
necesitamos determinar la dirección del dispositivo. Podemos usar el
siguiente código estándar con MicroPython para averiguar cúal es la dirección del
Módulo
I2C, para ello utilizaremos el IDE de
Thonny (recuerda que este scanner es general para cualquier
dispositivo I2C que conectes a tu Raspberry Pi Pico respetando el conexionado de sus
pines):
# ----------------------------------------------------------------------------
# (| " I2C_Scan.py "|)
# (| " Este es un sencillo sketch para escanear buscando un dispositivo "|)
# (| " I2C conectado en I2C cero, localizandolo e imprimiendo la dirección "|)
# (| " encontrada en hexadecimal, en la shell o consola, con una raspberry "|)
# (| " pi pico y MicroPython. "|)
# (| " "|)
# (| " Usaremos los valores predeterminados de I2C0, para el dispositivo "|)
# (| " I2C: SCL= Pin GP9, SDA= Pin GP8 Vcc= VBUS GND= GND de la raspberry "|)
# (| " pi pico. "|)
# (| " "|)
# (| " Este código de ejemplo es de dominio público. "|)
# (| " "|)
# (| " Maker: jorgechac© "|)
# (| " Visita https://jorgechac.blogspot.com "|)
# (| " "|)
# (| " Venta de accesorios Arduino/Raspberry Pi Pico/ESP32 "|)
# (| " Whatsapp y Ventas NEQUI +573177295861 "|)
# (| " Bucaramanga - Colombia "|)
# (| " Simulaciön https://wokwi.com/projects/339117994278912596 "|)
# (| " Descarga gratis este sketch desde el Repositorio de GitHub: "|)
# (| " https://github.com/jorgechacblogspot/micropython_pico "|)
# (| " https://jorgechac.blogspot.com/2021/04/raspberry-pi-pico-pin-mapping.html "|)
# ----------------------------------------------------------------------------------
from machine import Pin # importamos la funcion pin del
# modulo machine
from machine import I2C # importamos la funcion I2C del
# modulo machine
import utime
sda = Pin(8) # objeto tipo pin que especifica
# el pin que se utilizará para SDA,
# en este caso utilizaremos GP8
# como sda
scl = Pin(9) # objeto tipo pin que especifica
# el pin que se utilizará para SCL,
# en este caso utilizaremos GP9
# como scl
i2c = I2C(0,sda=sda,scl=scl,freq=400000) # le decimos que vamos a usar
# I2C cero y frecuencia max de
# 400k para scl
direccion = hex(i2c.scan()[0]) # primera posicion que entrega
# i2c.scan
print('I2C Scanner')
print('Scanning...')
print('Dispositivo I2C encontrado en la direccion hexadecimal', direccion,'!')
|
| Figura 1 |
👉Simulación Wokwi del I2C Scan👈
Utilizaremos el pin 40 VBUS de la pico para alimentar la LCD con los +5
voltios del puerto USB de la PC, el pin 38 que es GND de la pico irá a GND de la LCD, el pin GP8 de la pico irá a
SDA de la LCD y el pin GP9 de la pico irá a SCL de la LCD, como vimos en el simulador wokwi y como podemos ver
en el siguiente esquemático hecho con Fritzing (aquí podemos ver el pin mapping de la pico):
Después de montado el circuito y programado el I2C Scan en Thonny, podremos ver en la shell o consola que nos muestra la sesión del
interprete de python, la dirección hexadecimal de nuestro dispositivo, la
cual utilizaremos para crear ahora un pequeño sketch que maneje nuestra lcd,
inicialmente deberemos descargar alguna librería que sea capaz de controlar
la LCD vía I2C directamente con MicroPython, para este caso usaremos las
librerías "lcd_api.py" y "pico_i2c_lcd.py" que podemos descargar gratis
desde este
repositorio en github.
Para que funcionen estas librerías, debemos pasar los archivos lcd_api.py y
pico_i2c_lcd.py a la memoria interna de la Raspberry Pi Pico. Eso lo podemos
hacer con el IDE de Thonny, dando click en VIEW/FILES, se abrirá la ventana
de archivos, donde en la parte superior te muestra los archivos que tiene tu
computador y en la parte inferior los archivos de tu raspberry pi pico,
debemos dar click derecho sobre los archivos que deseamos pasar a la memoria
de la pico y dar click donde dice "Upload to/"
Finalmente verificamos que los archivos se encuentren dentro de la Flash de
la PICO inspeccionando la parte inferior izquierda de la Figura 1.
Funciones de la librería:
-
lcd.putstr (“¡El texto va aquí!”) – Envía una cadena de caracteres
a la pantalla. IMPORTANTE: para imprimir una variable puedes usar la
siguiente instrucción: lcd.putstr (str (Variable)) [Convierte la variable en una cadena]
-
lcd.show_cursor() / lcd.hide_cursor()
– Mostrar / Ocultar el cursor de la pantalla lcd (barra blanca)
-
lcd.blink_cursor_on() / lcd.blink_cursor_off()
– Enciende / apaga el cursor parpadeante al imprimir
-
lcd.backlight_on() / lcd.backlight_off()
– Enciende / apaga la luz de fondo de la pantalla LCD (controlada por un
pequeño transistor en la biblioteca)
-
lcd.display_on() / lcd.display_off()
– Enciende / apaga la pantalla (no la retroiluminación sino todo el
chip)
-
lcd.clear() - borra todos los caracteres o cualquier cosa escrita en la
pantalla
-
lcd.move_to(Col, Row)
– Mover a la posición según los valores de fila y col (Y, X)
-
lcd.custom_char(Num, bytearray ([caracteres HEX])))
– Num puede ser cualquier número entero 0 – 8 (escribiendo en ubicaciones
CGRAM) simplemente utilizado para numerar. Los caracteres HEX pueden ser
creados usando este enlace: https://maxpromer.github.io/LCD-Character-Creator/
. El cual proporciona una cadena de caracteres hexadecimales que pueden
reemplazar los “caracteres HEX” en el comando de ejemplo.
Código en MicroPython Display LCD – I2C
El siguiente código puede ser usado con la Raspberry Pi Pico a modo de
ejemplo, si se desea modificar basta solo configurar los pines empleados
para la comunicación I2C:
from time import sleep_ms
from machine import I2C, Pin
from pico_i2c_lcd import I2cLcd
DEFAULT_I2C_ADDR = 0x27
def test_main():
print("Running test_main")
i2c = I2C(0,scl=Pin(9), sda=Pin(8), freq=400000)
lcd = I2cLcd(i2c, DEFAULT_I2C_ADDR, 2, 16)
lcd.putstr("PROTOCOLO I2C\nLCD 2x16")
sleep_ms(3000)
lcd.clear()
count = 0
while True:
lcd.move_to(0, 0)
lcd.putstr(" SUBSCRIBETE! ")
sleep_ms(1000)
lcd.clear()
sleep_ms(1000)
test_main()
Finalmente vamos a visualizar un
mensaje inicial y lanzaremos una animación de números en esquinas, efecto
backspace y uso de la función backlight on y off por 3 segundos como ejemplo:
#
------------------------------------------------------------------------------------------------------------------
# pico_i2c_lcd_test2.py Sketch que implementa una pantalla LCD 2x16
HD44780
# conectada a través de PCF8574 via I2C.
# Se utiliza I2C 0 y SDA GP8 (pin 11) y SCL GP9 (pin 12).
# Visita https://jorgechac.blogspot.com Venta de accesorios
Arduino/Raspberry Pi Pico
#
------------------------------------------------------------------------------------------------------------------
import utime
from machine import I2C,Pin
from lcd_api import LcdApi
from pico_i2c_lcd import I2cLcd
# El PCF8574 tiene una dirección seleccionable por jumper: 0x20 a
0x27
# la direccion de la LCD puede cambiar, utilice el I2C_Scan.py primero
por favor!
I2C_ADDR = 0x27
I2C_NUM_ROWS = 2 # numero de filas de la lcd
I2C_NUM_COLS = 16 # numero de columnas de la lcd
i2c = I2C(0, sda=Pin(8), scl=Pin(9), freq=400000)
lcd = I2cLcd(i2c, I2C_ADDR, I2C_NUM_ROWS, I2C_NUM_COLS)
def lcd_str(message, col, row):
lcd.move_to(col, row)
lcd.putstr(message)
def main():
while True:
lcd.clear()
lcd.move_to(0,0)
lcd.putstr("PROTOCOLO
I2C ")
utime.sleep(2)
lcd.move_to(0,1)
lcd.putstr("LCD 2x16
")
utime.sleep(2)
lcd.clear()
lcd_str(" MicroPython by ", 0, 0)
utime.sleep(2)
lcd_str(" Raspberry Pico ",
0, 1)
utime.sleep(3)
lcd.clear()
lcd_str("Numeros en", 3,0)
lcd_str("Esquinas", 4,1)
utime.sleep(1)
lcd_str("1", 0,0)
utime.sleep(1)
lcd_str("2", 15,0)
utime.sleep(1)
lcd_str("3", 0,1)
utime.sleep(1)
lcd_str("4", 15,1)
utime.sleep(1)
lcd.clear()
lcd_str("Suscribete", 0,
0)
lcd_str("Activa: CAMPANA", 0,
1)
lcd.blink_cursor_on()
utime.sleep(2)
#Efecto Backspace
for j in range(1, -1,
-1): # iterador J objeto que permite recorrer un
contenedor
for i in
range(15, -1, -1): # contador decremental
lcd.move_to(i, j)
lcd.putstr(' ')
utime.sleep_ms(100)
utime.sleep(1)
lcd.hide_cursor()
#BackLight OFF por 3 segundos
lcd.clear()
lcd.backlight_off()
lcd_str("BackLight OFF", 0,
0)
utime.sleep(3)
#BackLight ON por 3 segundos
lcd.clear()
lcd.backlight_on()
lcd_str("BackLight ON", 0,
0)
utime.sleep(3)
if __name__ == '__main__':
main()
Las librerías y los códigos .py de los ejemplos anteriores los puedes
descargar gratis del repositorio de github que mencione mas arriba.
Finalmente recordemos que con las pantallas OLED estos módulos lcd irán
descontinuándose poco a poco.
Quieres aportar algo que complemente este articulo? crees que hay algo
que se deba corregir?
Escríbenos este
blog es para todos.
Recuerda que en https://jorgechac.blogspot.com nos dedicamos a construir
una electrónica mejor! y apoyamos el proyecto
CTC GO!
(Creative Technologies in the Classroom) que es un programa de educación
steam personalizable.
Si te sirvió deja un comentario de agradecimiento, comparte el post en tus redes sociales o recomiéndale el blog a un amigo, eso me motiva a seguir realizando estos pequeños posts y espero que vuelvas a mi blog, publico nuevo material con base en los softwares y apps que utilizo y la experiencia que he adquirido. Por último si deseas colaborar voluntariamente y crees que mi trabajo y mi tiempo lo ameritan, considere hacer una pequeña donación a mi NEQUI +573177295861.
También te puede interesar:
Nuevo Microcontrolador Raspberry Pi Pico
Convierte fácilmente una Fuente ATX de PC en una Fuente para alimentar tus
proyectos Arduino y/o Raspberry Pi
Como Grabar el Bootloader de Arduino
Bootloader USB para Microcontroladores PIC 18F2550 y PIC18F4550
Diseño y fabricación de PCB profesionales con Fritzing
Conociendo La Familia de los Módulos WiFi para Arduino ESP8266
Cómo Detectar un Arduino Falsificado
ChipKIT™ Max32™ El Arduino de Microchip
