Test Pantalla LCD ssd1306, puede via THONNY mandar llamar la libreria en (library)

PantallaLCD.md

Raspberry Pi Pico SSD1306 OLED Display (MicroPython)

1. Escaneo de dispositivos I2C

Creditos: JUAN CARMONA VALDEZ via cavj83

🔍Observación: Cuidados del OLED Display y conexiones en protoboard

Durante el montaje del circuito con el display OLED, es fundamental prestar especial atención al orden correcto de los pines (VCC, GND, SDA, SCL). Un error común en el protoboard es invertir los cables de alimentación o comunicación, lo que puede ocasionar fallas de funcionamiento o incluso dañar permanentemente el módulo OLED. Por ello, se recomienda verificar el esquema antes de encender el circuito y utilizar cables de colores diferenciados (por ejemplo, rojo para VCC y negro para GND) para evitar confusiones. Asimismo, el display debe ser operado dentro de los valores de voltaje adecuados (3.3 V o 5 V según el modelo) y con un brillo moderado, garantizando un funcionamiento estable.

from machine import Pin, I2C
import time

# Configurar bus I2C
i2c = I2C(0, scl=Pin(1), sda=Pin(0))

# Escanear dispositivos conectados
devices = i2c.scan()
print("Dispositivos I2C detectados:", devices)

Debe mostrar [60] si lo detecta.

#Conexión de Pantalla en Raspberry

2. Mostrar Información en Pantalla OLD de 7 Lineas

"""
┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┓
┃ Raspberry Pi Pico SSD1306 OLED Display (MicroPython)     ┃
┃                                                          ┃
┃ A program to display Hola Pico! SSD1306, text, and a     ┃
┃ Texto Linea 0-7 al Final Muesta Finalizado :)            ┃
┃ connected to a Raspberry Pi Pico.                        ┃
┃                                                          ┃
┗━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┛
"""

from machine import Pin, I2C
import ssd1306
import time

# Inicializa I2C (ajusta si tus pines son distintos)
i2c = I2C(0, scl=Pin(1), sda=Pin(0))

print("Direcciones I2C detectadas:", i2c.scan())

# Inicializa pantalla OLED
oled = ssd1306.SSD1306_I2C(128, 64, i2c, addr=0x3C)

# Pantalla de inicio
oled.fill(0)
oled.text("Hola Pico!", 0, 0)
oled.text("SSD1306 OK", 0, 10)
oled.show()
time.sleep(2)  # ← espera 2 segundos

# Animación lenta
for i in range(0, 64, 8):
    oled.fill(0)
    oled.text(f"Linea {i//8}", 0, i)
    oled.show()
    time.sleep(1)  # ← espera 1 segundo entre líneas

# Mensaje final
oled.fill(0)
oled.text("Finalizado", 0, 0)
oled.text(":)", 100, 0)
oled.show()

Código para pantallas OLED pequeñas (0.91", 128x32)

Inicialización de pantalla OLED SSD1306 (128x32)

from machine import Pin, I2C
import ssd1306
import time

# Configurar I2C
i2c = I2C(0, scl=Pin(1), sda=Pin(0))

# Crear objeto OLED: resolución 128x32 para pantallas 0.91"
oled = ssd1306.SSD1306_I2C(128, 32, i2c)

# Limpiar pantalla
oled.fill(0)

# Mostrar texto
oled.text("OLED 0.91", 0, 0)
oled.text("SSD1306 OK", 0, 10)
oled.text(":)", 0, 20)

# Actualizar pantalla
oled.show()

Nota: Antes de usar la pantalla OLED con MicroPython, es necesario guardar el archivo ssd1306.py en la Raspberry Pi Pico.

Esto permite importar el módulo con import ssd1306 sin errores.
Puedes hacerlo usando Thonny:

1. Abrir ssd1306.py en Thonny.
2. Seleccionar Archivo > Guardar como y elegir Raspberry Pi Pico como destino.

ssd1306.py

# MicroPython SSD1306 OLED driver, I2C and SPI interfaces
#
# library taken from repository at:
# https://github.com/micropython/micropython/blob/master/drivers/display/ssd1306.py
#
from micropython import const
import framebuf
import time

# Register definitions
SET_CONTRAST = const(0x81)
SET_ENTIRE_ON = const(0xA4)
SET_NORM_INV = const(0xA6)
SET_DISP = const(0xAE)
SET_MEM_ADDR = const(0x20)
SET_COL_ADDR = const(0x21)
SET_PAGE_ADDR = const(0x22)
SET_DISP_START_LINE = const(0x40)
SET_SEG_REMAP = const(0xA0)
SET_MUX_RATIO = const(0xA8)
SET_COM_OUT_DIR = const(0xC0)
SET_DISP_OFFSET = const(0xD3)
SET_COM_PIN_CFG = const(0xDA)
SET_DISP_CLK_DIV = const(0xD5)
SET_PRECHARGE = const(0xD9)
SET_VCOM_DESEL = const(0xDB)
SET_CHARGE_PUMP = const(0x8D)

# Subclassing FrameBuffer provides support for graphics primitives
# http://docs.micropython.org/en/latest/pyboard/library/framebuf.html
class SSD1306(framebuf.FrameBuffer):
    def __init__(self, width, height, external_vcc):
        self.width = width
        self.height = height
        self.external_vcc = external_vcc
        self.pages = self.height // 8
        self.buffer = bytearray(self.pages * self.width)
        super().__init__(self.buffer, self.width, self.height, framebuf.MONO_VLSB)
        self.init_display()

    def init_display(self):
        for cmd in (
            SET_DISP | 0x00,  # off
            # Address setting
            SET_MEM_ADDR,
            0x00,  # horizontal
            # Resolution and layout
            SET_DISP_START_LINE | 0x00,
            SET_SEG_REMAP | 0x01,  # Column addr 127 mapped to SEG0
            SET_MUX_RATIO,
            self.height - 1,
            SET_COM_OUT_DIR | 0x08,  # Scan from COM[N] to COM0
            SET_DISP_OFFSET,
            0x00,
            SET_COM_PIN_CFG,
            0x02 if self.width > 2 * self.height else 0x12,
            # Timing and driving scheme
            SET_DISP_CLK_DIV,
            0x80,
            SET_PRECHARGE,
            0x22 if self.external_vcc else 0xF1,
            SET_VCOM_DESEL,
            0x30,  # 0.83*Vcc
            # Display
            SET_CONTRAST,
            0xFF,  # maximum
            SET_ENTIRE_ON,  # Output follows RAM contents
            SET_NORM_INV,  # Not inverted
            # Charge pump
            SET_CHARGE_PUMP,
            0x10 if self.external_vcc else 0x14,
            SET_DISP | 0x01,
        ):  # On
            self.write_cmd(cmd)
        self.fill(0)
        self.show()

    def poweroff(self):
        self.write_cmd(SET_DISP | 0x00)

    def poweron(self):
        self.write_cmd(SET_DISP | 0x01)

    def contrast(self, contrast):
        self.write_cmd(SET_CONTRAST)
        self.write_cmd(contrast)

    def invert(self, invert):
        self.write_cmd(SET_NORM_INV | (invert & 1))

    def show(self):
        x0 = 0
        x1 = self.width - 1
        if self.width == 64:
            # Displays with width of 64 pixels are shifted by 32
            x0 += 32
            x1 += 32
        self.write_cmd(SET_COL_ADDR)
        self.write_cmd(x0)
        self.write_cmd(x1)
        self.write_cmd(SET_PAGE_ADDR)
        self.write_cmd(0)
        self.write_cmd(self.pages - 1)
        self.write_data(self.buffer)


class SSD1306_I2C(SSD1306):
    def __init__(self, width, height, i2c, addr=0x3C, external_vcc=False):
        self.i2c = i2c
        self.addr = addr
        self.temp = bytearray(2)
        self.write_list = [b"\x40", None]  # Co=0, D/C#=1
        super().__init__(width, height, external_vcc)

    def write_cmd(self, cmd):
        self.temp[0] = 0x80  # Co=1, D/C#=0
        self.temp[1] = cmd
        self.i2c.writeto(self.addr, self.temp)

    def write_data(self, buf):
        self.write_list[1] = buf
        self.i2c.writevto(self.addr, self.write_list)

# Only required for SPI version (not covered in this project)
class SSD1306_SPI(SSD1306):
    def __init__(self, width, height, spi, dc, res, cs, external_vcc=False):
        self.rate = 10 * 1024 * 1024
        dc.init(dc.OUT, value=0)
        res.init(res.OUT, value=0)
        cs.init(cs.OUT, value=1)
        self.spi = spi
        self.dc = dc
        self.res = res
        self.cs = cs

        self.res(1)
        time.sleep_ms(1)
        self.res(0)
        time.sleep_ms(10)
        self.res(1)
        super().__init__(width, height, external_vcc)

    def write_cmd(self, cmd):
        self.spi.init(baudrate=self.rate, polarity=0, phase=0)
        self.cs(1)
        self.dc(0)
        self.cs(0)
        self.spi.write(bytearray([cmd]))
        self.cs(1)

    def write_data(self, buf):
        self.spi.init(baudrate=self.rate, polarity=0, phase=0)
        self.cs(1)
        self.dc(1)
        self.cs(0)
        self.spi.write(buf)
        self.cs(1)