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.
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].
# ----------------------------------------------------------------------------
# (| " 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
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
No hay comentarios.:
Publicar un comentario