Display OLED Raspberry Pi Pico / ESP8266

En esta entrada aprenderemos a utilizar y programar una pantalla o display OLED con la Raspberry Pi Pico o una NODEMECU ESP8266, ESP32 utilizando MicroPython y el IDE de Thonny.

Antes de comenzar te hago la invitación para que veas nuestro curso gratuito de MicroPython.

Y que te suscribas al canal si te interesan los microcontroladores, la programación y sobre todo loa teoría del control:

OLED SSD1306

Con una pantalla OLED podemos integrar una forma de visualización de datos para el usuario de manera eficiente en nuestros proyectos de sistemas embebidos como la Raspberry Pi Pico o el ESP8266.

Esta pantalla posee un driver CMOS OLED de un solo chip: SSD1306. la cual se comunica con el microcontrolador de usando protocolos como el I2C y SPI .

El protocolo SPI es generalmente más rápido que el I2C pero requiere más pines de E / S. Mientras que I2C requiere solo dos pines y se puede compartir con otros periféricos I2C. Es una compensación entre los pines y la velocidad. 

Circuito OLED Raspberry Pi Pico / ESP8266

Antes que nada es MUY IMPORTANTE que mires la posición de VCC y GND en tu Display OLED, dado que dependiendo del fabricante estos dos pines pueden estar INVERTIDOS.

El circuito que vamos a emplear en la práctica del dia de hoy para programar una pantalla OLED con MicroPython en el ESP8266 y la Raspberry Pi Pico será el siguiente:

En esta práctica vamos a mostrar:

• Textos
• Gráficos
• Un plano cartesiano plotando el voltaje leido del potenciometro vs tiempo

Librería SSD1306 MicroPython

Lo primero que debemos hacer es descargar y grabar la librería dentro del dispositivo microcontrolador, esto se puede hacer directamente dentro del IDE de Thonny o a través de los siguientes enlaces:

Homepage: https://github.com/stlehmann/micropython-ssd1306

Uso básico de la librería

Importamos el modulo machine y creamos un objeto I2C

import machine
i2c = machine.I2C(sda=machine.Pin(23), scl=machine.Pin(22))

Creamos un objeto para nuestra pantalla OLED.

from ssd1306 import SSD1306_I2C
oled = SSD1306_I2C(128, 32, i2c)

Esto llena toda la pantalla con píxeles blancos:

oled.fill(1)
oled.show()

 Para borrar la pantalla:

oled.fill(0)
oled.show()

Para escribir algo de texto:

oled.text('Hello', 0, 0)
oled.text('World', 0, 10)
oled.show()

FrameBuffer

También podemos usar las instrucciones de la clase framebuffer con el objeto OLED creado anteriormente.

.pixel (x, y, B / N)

Para dibujar una línea horizontal, pasamos la posición X, Y y luego la longitud de esa línea. Si usa 0 como tercer parámetro, el píxel será negro. El píxel negro se puede utilizar para borrar un píxel iluminado en su posición o para resaltar un píxel en un fondo de píxel iluminado.

.hline (x, y, w, B / W)

Para dibujar una línea horizontal, pasamos la posición X, Y y luego la longitud de esa línea. 

.vline (x, y, w, B / W)

Exactamente los mismos parámetros que la línea horizontal, pero ahora vertical. 

.line (x1, y1, x2, y2, B / W)

Para dibujar una línea en cualquier dirección. Los parámetros son x1, y1, que se refieren al punto inicial x2, y y2, que se refieren al punto final. El último parámetro siempre está relacionado con el píxel (negro o blanco). 

.rect (x, y, w, h, B / W)

Dibujar un rectángulo. Aquí los parámetros son el punto de partida (x, y), el ancho y la altura del rectángulo, comenzando desde el punto de partida.

Imagen en el OLED

Hay una aplicación en línea llamada image2cpp – http://javl.github.io/image2cpp/ que puede convertir su imagen en una matriz.

Si ha seleccionado una imagen más grande que 128 × 64, cámbiela a 128 × 64 y seleccione la opción de Escala adecuada. Coloque como color de fondo Black o Transparente.

Una vez que esté satisfecho con el resultado, puede continuar generando la matriz de datos. Simplemente seleccione el formato de salida de código como plan bytes y haga clic en el botón Generar código.

Cree una lista en su código pegando dentro de los corchetes la matriz generada:

logo = [   Pegue aquí la matriz generada  ]

Podemos ahora generar la imagen en MicroPython usando la función bytearray

import framebuf
buffer = bytearray(logo)
fb = framebuf.FrameBuffer(buffer,WIDTH,HEIGHT,framebuf.MONO_HLSB)
oled.fill(0)
oled.blit(fb,0,0)
oled.show()

Código de Ejemplo

A continuación puedes descargar el código de ejemplo donde visualizamos un texto en el display, el logo de Raspberry Pi y finalmente creamos un plano cartesiano para graficar la variación de voltaje del potenciomentro. El código también lo puedes descargar de mi GITHUB.

Eso es todo por la entrada del dia de hoy, espero les haya gustado y hayan aprendido algo nuevo. Si te ha servido el contenido de esta entrada, de los videos y los códigos de implementación y deseas apoyar mi trabajo invitandome a un café super barato, puedes hacerlo en el siguiente link:

👉 Invitar a Sergio a un Café ☕️

Que esten muy bien, nos vemos en la siguiente entrada.