Uno de los elementos más vistosos que se pueden usar con una Raspberry Pi Pico es la pantalla LCD Grove. Prácticamente es el elemento faltante para tener una “computadora” en miniatura. Entre algunos de los métodos para comunicarse con este tipo de dispositivos existe el llamado protocolo I2C, el cual veremos de forma rápida. En este tutorial estaremos usando los siguientes materiales:
- Raspberry Pi Pico
- Cable micro USB
- Protoboard
- Pantalla LCD I2C de Grove
- Cable conector Grove a pines Macho
- Librería LCD I2C de Grove
Librería LCD I2C de Grove
Para manejar el módulo de LCD de Grove necesitarás utilizar una librería que contiene todas las funciones necesarias para controlar tu LCD. A grandes rasgos es un código que incluye como mover el cursor en la pantalla, borrarla y poner caracteres en ella. Para usarla solo copia el código en un archivo llamado grove_lcd_i2c.py y guárdalo en la carpeta donde tengas tu código o dentro de la Raspberry Pi Pico. Al final del post encontrarás el código.
Usando el puerto I2C
El puerto I2C permite conectar una gran diversidad de módulos con solo dos cables a tu Pico. Para lograr esto manda datos digitales a una dirección que corresponde al módulo que quieres usar y un comando. Puedes conectar tantos módulos como direcciones haya disponibles. En nuestro caso conectaremos la LCD en el puerto I2C_0 que está en los pines 0 y 1 de tu Pico.
Código
Este código es una prueba simple para desplegar mensajes en la Raspberry Pi Pico. Como puedes ver estamos asignando dos pines digitales, llamados LCD_SDA y LCD_SCL. Estos corresponden a los pines de datos del protocolo I2C. Además, definimos una variable LCD_ADDR, con un valor de 62. Esa es la dirección de nuestra pantalla LCD. Para iniciar la comunicación serial, usamos la función I2C() y para iniciar la pantalla LCD, usamos la función Grove_LCD_I2C(). Por último, la función home() manda el cursor de la pantalla al primer caracter y la función write() escribe el mensaje.
from machine import *
import utime
from grove_lcd_i2c import Grove_LCD_I2C
utime.sleep(1)
led = Pin(25, Pin.OUT)
LCD_SDA = Pin(0)
LCD_SCL = Pin(1)
LCD_ADDR = 62 # 0x3E or 62
i2c = I2C(0, sda=LCD_SDA, scl=LCD_SCL)
#print(i2c.scan())
lcd = Grove_LCD_I2C(i2c, LCD_ADDR)
lcd.home()
lcd.write("Raspberry Pi \nPico")
Leyendo una entrada analógica
La pantalla puede actualizarse con datos que leamos desde la Pico, no necesariamente datos de texto que hayamos programado previamente. Para lograr esto, podemos configurar una lectura analógica y mostrarla en la pantalla cada segundo. Para ello, solo tenemos que asignar el pin analógico, y guardar la lectura en una variable de texto tipo string. En este caso, el valor lo convertimos a un porcentaje, que representa el ancho de pulso de una salida PWM. En este caso, usamos una nueva función llamada clear() que nos permite borrar la pantalla.
from machine import *
import utime
from grove_lcd_i2c import Grove_LCD_I2C
utime.sleep(1)
led = Pin(25, Pin.OUT)
LCD_SDA = Pin(0)
LCD_SCL = Pin(1)
LCD_ADDR = 62 # 0x3E or 62
i2c = I2C(0, sda=LCD_SDA, scl=LCD_SCL)
lcd = Grove_LCD_I2C(i2c, LCD_ADDR)
adc = machine.ADC(26)
conversion_factor = 100 / (65535)
while True:
porcentaje = adc.read_u16() * conversion_factor
lcd.home()
lcd.clear()
out_string = "PWM %: " + str(porcentaje)
lcd.write(out_string)
utime.sleep(1)
Conclusiones:
Con estos comandos podrás mandar mensajes a tu pantalla LCD Grove, mientras quepan en la pantalla. Prueba a combinarlo con otros sensores, como un sensor de temperatura o de luz. Igual y si lo usas como una tarjeta de presentación en un negocio también está perfecto. ¡Te invitamos a que sigas los demás tutoriales de Raspberry Pi Pico que tenemos para ti!
Referencias:
Making A Lucky Draw Device Using Raspberry Pi Pico
#
# Grove 16x2 I2C LCD (White on Blue)
# - https://my.cytron.io/p-grove-16-x-2-lcd-white-on-blue?tracking=idris
#
# Update:
# 10 Jan 2021: Tested with MicroPython ESP32 V1.13
#
from machine import Pin, I2C
import utime
class Grove_LCD_I2C(object):
# Commands
LCD_CLEARDISPLAY = 0x01
LCD_RETURNHOME = 0x02
LCD_ENTRYMODESET = 0x04
LCD_DISPLAYCONTROL = 0x08
LCD_CURSORSHIFT = 0x10
LCD_FUNCTIONSET = 0x20
LCD_SETCGRAMADDR = 0x40
LCD_SETDDRAMADDR = 0x80
# Flags for display entry mode
LCD_ENTRYRIGHT = 0x00
LCD_ENTRYLEFT = 0x02
LCD_ENTRYSHIFTINCREMENT = 0x01
LCD_ENTRYSHIFTDECREMENT = 0x00
# Flags for display on/off control
LCD_DISPLAYON = 0x04
LCD_DISPLAYOFF = 0x00
LCD_CURSORON = 0x02
LCD_CURSOROFF = 0x00
LCD_BLINKON = 0x01
LCD_BLINKOFF = 0x00
# Flags for display/cursor shift
LCD_DISPLAYMOVE = 0x08
LCD_CURSORMOVE = 0x00
LCD_MOVERIGHT = 0x04
LCD_MOVELEFT = 0x00
# Flags for function set
LCD_8BITMODE = 0x10
LCD_4BITMODE = 0x00
LCD_2LINE = 0x08
LCD_1LINE = 0x00
LCD_5x10DOTS = 0x04
LCD_5x8DOTS = 0x00
def __init__(self, i2c, address, oneline=False, charsize=LCD_5x8DOTS):
self.i2c = i2c
self.address = address
self.disp_func = self.LCD_DISPLAYON # | 0x10
if not oneline:
self.disp_func |= self.LCD_2LINE
elif charsize != 0:
# For 1-line displays you can choose another dotsize
self.disp_func |= self.LCD_5x10DOTS
# Wait for display init after power-on
utime.sleep_ms(50) # 50ms
# Send function set
self.cmd(self.LCD_FUNCTIONSET | self.disp_func)
utime.sleep_us(4500) ##time.sleep(0.0045) # 4.5ms
self.cmd(self.LCD_FUNCTIONSET | self.disp_func)
utime.sleep_us(150) ##time.sleep(0.000150) # 150µs = 0.15ms
self.cmd(self.LCD_FUNCTIONSET | self.disp_func)
self.cmd(self.LCD_FUNCTIONSET | self.disp_func)
# Turn on the display
self.disp_ctrl = self.LCD_DISPLAYON | self.LCD_CURSOROFF | self.LCD_BLINKOFF
self.display(True)
# Clear it
self.clear()
# Set default text direction (left-to-right)
self.disp_mode = self.LCD_ENTRYLEFT | self.LCD_ENTRYSHIFTDECREMENT
self.cmd(self.LCD_ENTRYMODESET | self.disp_mode)
def cmd(self, command):
assert command >= 0 and command < 256
command = bytearray([command])
self.i2c.writeto_mem(self.address, 0x80, bytearray([]))
self.i2c.writeto_mem(self.address, 0x80, command)
def write_char(self, c):
assert c >= 0 and c < 256
c = bytearray([c])
self.i2c.writeto_mem(self.address, 0x40, c)
def write(self, text):
for char in text:
if char == '\n':
self.cursor_position(0, 1)
else:
self.write_char(ord(char))
def cursor(self, state):
if state:
self.disp_ctrl |= self.LCD_CURSORON
self.cmd(self.LCD_DISPLAYCONTROL | self.disp_ctrl)
else:
self.disp_ctrl &= ~self.LCD_CURSORON
self.cmd(self.LCD_DISPLAYCONTROL | self.disp_ctrl)
def cursor_position(self, col, row):
col = (col | 0x80) if row == 0 else (col | 0xc0)
self.cmd(col)
def autoscroll(self, state):
if state:
self.disp_ctrl |= self.LCD_ENTRYSHIFTINCREMENT
self.cmd(self.LCD_DISPLAYCONTROL | self.disp_ctrl)
else:
self.disp_ctrl &= ~self.LCD_ENTRYSHIFTINCREMENT
self.cmd(self.LCD_DISPLAYCONTROL | self.disp_ctrl)
def blink(self, state):
if state:
self.disp_ctrl |= self.LCD_BLINKON
self.cmd(self.LCD_DISPLAYCONTROL | self.disp_ctrl)
else:
self.disp_ctrl &= ~self.LCD_BLINKON
self.cmd(self.LCD_DISPLAYCONTROL | self.disp_ctrl)
def display(self, state):
if state:
self.disp_ctrl |= self.LCD_DISPLAYON
self.cmd(self.LCD_DISPLAYCONTROL | self.disp_ctrl)
else:
self.disp_ctrl &= ~self.LCD_DISPLAYON
self.cmd(self.LCD_DISPLAYCONTROL | self.disp_ctrl)
def clear(self):
self.cmd(self.LCD_CLEARDISPLAY)
utime.sleep_ms(2) # 2ms
def home(self):
self.cmd(self.LCD_RETURNHOME)
utime.sleep_ms(2) # 2m