Interfaz de pantalla OLED SSD1306 con Raspberry Pi Pico

En este tutorial, aprenderemos sobre la interfaz de la pantalla OLED SSD1306 con Raspberry Pi Pico . Las pantallas OLED son una de las más atractivas disponibles para un microcontrolador . Tiene un buen ángulo de visión y densidad de píxeles, lo que lo hace confiable para mostrar gráficos de pequeño nivel.

La pantalla OLED SSD1306 está disponible en los módulos I2C y SPI . Pero en este tutorial, usaremos la pantalla OLED I2C de 0.96 ″, ya que solo requiere 2 cables para la interfaz. La Raspberry Pi Pico que viene con un microcontrolador RP2040 tiene dos pares de pines I2C . Puede utilizar cualquiera de los pines I2C de Raspberry Pi Pico para interconectar la pantalla OLED SSD1306 .

Aquí usaremos el código de Micropython para usar la pantalla OLED con placa Pico. El IDE de MicroPython requiere el código de controlador SSD1306 . Después de escribir el código del controlador, podemos escribir cualquier cosa y mostrarla en la pantalla OLED. Mostraremos el voltaje del valor analógico del potenciómetro en la pantalla OLED. Pero antes de eso, le recomendamos que consulte la guía de inicio: Primeros pasos con Raspberry Pi Pico en MicroPython

Elementos utilizados:

{Product:5380}{Product:1211}{Product:44}{Product:287}

Conexión

Ahora aprendamos cómo podemos conectar la pantalla OLED SSD1306 con Raspberry Pi Pico . La placa Raspberry Pi Pico tiene dos pares de pines I2C. Puede utilizar cualquiera de los pares de pines I2C para aplicaciones de interfaz.

En este ejemplo, alimentaremos el valor de entrada de voltaje analógico del potenciómetro al pin analógico GP28 de Raspberry Pi Pico. Luego mostraremos el voltaje analógico en la pantalla OLED. El esquema es muy simple y fácil de usar.

Conecte el Pin SDA y SCL de la pantalla OLED al Pin PICO GP8 y GP9 respectivamente. Conecte el pin VCC y GND de la pantalla OLED al pin de 3,3 V y GND de Pico. Puede usar una placa de pruebas (protoboard) para ensamblar todo el circuito.

Código

Para programar la placa Raspberry Pi Pico, usaremos el lenguaje de programación MicroPython . MicroPython es similar a Python. Puede usar Thonny IDE o uPyCraft IDE para programar y probar la placa.

En este ejemplo usaremos uPyCraft IDE para la programación, la cual se divide en dos partes principales:

1. SSD1306.py

2. Main.py

Esto se debe a que la pantalla OLED requiere primero el código de controlador SSD1306 . Primero tenemos que escribir el código para el controlador SSD1306. Después de cargar el código SSD1306, podemos ejecutar el código main.py.

SSD1306.py

Entonces, en uPyCraft IDE, cree un nuevo archivo. Copie el siguiente código y guarde el archivo con el nombre ssd1306.py .

# MicroPython SSD1306 OLED driver, I2C and SPI interfaces
 
from micropython import const
import framebuf
 
# 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)
 
 
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
        import time
 
        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)

Ahora presione el botón descargar y ejecutar. Entonces podrá ver el controlador SSD1306 guardado en la Raspberry Pi Pico.

main.py

Abra una nueva pestaña nuevamente en el IDE de uPyCraft . Copie el siguiente código y péguelo en la ventana IDE de uPyCraft. Guarde el archivo con el nombre main.py .

# Display Image & text on I2C driven ssd1306 OLED display 
from machine import Pin, I2C
from ssd1306 import SSD1306_I2C
import framebuf
import machine
import utime
 
sensor_temp = machine.ADC(28)
conversion_factor = 3.3 / (65535)
 
WIDTH  = 128                                            # oled display width
HEIGHT = 64                                             # oled display height
 
i2c = I2C(0, scl=Pin(9), sda=Pin(8), freq=200000)       # Init I2C using pins GP8 & GP9 (default I2C0 pins)
print("I2C Address      : "+hex(i2c.scan()[0]).upper()) # Display device address
print("I2C Configuration: "+str(i2c))                   # Display I2C config
 
 
oled = SSD1306_I2C(WIDTH, HEIGHT, i2c)                  # Init oled display
 
# Raspberry Pi logo as 32x32 bytearray
buffer = bytearray(b"\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00|?\x00\x01\x86@\x80\x01\x01\x80\x80\x01\x11\x88\x80\x01\x05\xa0\x80\x00\x83\xc1\x00\x00C\xe3\x00\x00~\xfc\x00\x00L'\x00\x00\x9c\x11\x00\x00\xbf\xfd\x00\x00\xe1\x87\x00\x01\xc1\x83\x80\x02A\x82@\x02A\x82@\x02\xc1\xc2@\x02\xf6>\xc0\x01\xfc=\x80\x01\x18\x18\x80\x01\x88\x10\x80\x00\x8c!\x00\x00\x87\xf1\x00\x00\x7f\xf6\x00\x008\x1c\x00\x00\x0c \x00\x00\x03\xc0\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00")
 
while True:
    reading = sensor_temp.read_u16() * conversion_factor
    # Load the raspberry pi logo into the framebuffer (the image is 32x32)
    fb = framebuf.FrameBuffer(buffer, 32, 32, framebuf.MONO_HLSB)
 
    # Clear the oled display in case it has junk on it.
    oled.fill(0)
 
    # Blit the image from the framebuffer to the oled display
    oled.blit(fb, 96, 0)
       
    
    # Add some text
    oled.text("ADC: ",5,8)
    oled.text(str(round(reading,2)),40,8)
 
 
    # Finally update the oled display so the image & text is displayed
    oled.show()

Ahora vuelve a pulsar el botón descargar y ejecutar . El código se guardará en la placa Raspberry Pi Pico.

Ahora estás listo para ir. La pantalla OLED comenzará a mostrar inmediatamente el logotipo de Raspberry Pi junto con el valor de voltaje analógico (ADC) leído del potenciómetro.

Puede girar la perilla del potenciómetro y ver la pantalla OLED mostrando los diferentes valores.

Así es como puede mostrar el texto o el logotipo en una pantalla OLED utilizando el código MicroPython. Por lo tanto, conectar la pantalla OLED SSD1306 con Raspberry Pi Pico es tan fácil como ves en este tutorial.

Esperemos que te haya sido de utilidad y puedas disfrutar de todas las aplicaciones que brinda esta pantalla OLED.