En el mundo de la electrónica y la programación, el MicroPython ha cobrado cada vez más relevancia por su facilidad de uso y versatilidad. En este artículo, exploraremos cómo utilizar MicroPython para trabajar con pantallas OLED en dispositivos ESP32 y ESP8266. ¡Descubre cómo dar vida a tus proyectos con esta poderosa combinación de tecnologías!
En esta guía aprenderá cómo usar la pantalla OLED SSD1306 de 0,96 pulgadas con un ESP32 o ESP8266 usando el firmware MicroPython. Como ejemplo, le mostraremos cómo mostrar un mensaje sencillo de «¡Hola mundo!». Más adelante también le mostraremos cómo utilizar otras funciones útiles para interactuar con la pantalla OLED.
Quizás también quieras leer nuestras instrucciones dedicadas para ESP con pantalla OLED usando el IDE de Arduino:
- Pantalla OLED ESP32 con Arduino IDE
- Pantalla OLED ESP8266 con Arduino IDE
requisitos
Para seguir este tutorial, debe tener instalado el firmware MicroPython en sus placas ESP32 o ESP8266. También necesitarás un IDE para escribir el código y subirlo a tu placa. Recomendamos utilizar Thonny IDE o uPyCraft IDE:
- IDE de Thonny:
- Instalación y primeros pasos con Thonny IDE
- Actualización del firmware MicroPython con esptool.py
- IDE de UpyCraft:
- Comenzando con uPyCraft IDE
- Instale uPyCraft IDE (Windows, Mac OS X, Linux)
- Flashear/cargar firmware MicroPython a ESP32 y ESP8266
Obtenga más información sobre MicroPython: Programación de MicroPython con ESP32 y ESP8266 eBook
Introducción de la pantalla OLED
En esta guía utilizamos el Pantalla OLED SSD1306 de 0,96 pulgadas es decir, 128 × 64 píxeles y utiliza el protocolo de comunicación I2C.
comunicación I2C
Para la pantalla OLED I2C, debe realizar las siguientes conexiones:
| OLED | ESP32 | ESP8266 |
| vino | 3,3 V | 3,3 V |
| Dimensiones | Dimensiones | Dimensiones |
| SCL | GPIO22 | GPIO5 (D1) |
| ASD | GPIO21 | GPIO4 (D2) |
Piezas requeridas
Aquí hay una lista de las piezas que necesitará para este proyecto:
- Pantalla OLED de 0,96 pulgadas
- ESP32 o ESP8266 (leer ESP32 frente a ESP8266)
- tablero de circuitos
- Cables de puente
Puedes utilizar los enlaces anteriores o ir directamente MakerAdvisor.com/tools ¡Para encontrar todas las piezas para tus proyectos al mejor precio!
Diagrama de cableado – ESP32
Siga el siguiente diagrama esquemático si está utilizando una placa ESP32:
Recomendaciones de literatura: Guía de referencia de asignación de pines ESP32
Diagrama de circuito – ESP8266
Siga el siguiente esquema si está utilizando una placa ESP8266:
Recomendaciones de literatura: Guía de referencia de asignación de pines ESP8266
Biblioteca OLED SSD1306
De forma predeterminada, la biblioteca para escribir en la pantalla OLED no forma parte de la biblioteca estándar de MicroPython. Entonces necesitas cargar la biblioteca en tu placa ESP32/ESP8266.
# MicroPython SSD1306 OLED driver, I2C and SPI interfaces created by Adafruit
import time
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)
class SSD1306:
def __init__(self, width, height, external_vcc):
self.width = width
self.height = height
self.external_vcc = external_vcc
self.pages = self.height // 8
# Note the subclass must initialize self.framebuf to a framebuffer.
# This is necessary because the underlying data buffer is different
# between I2C and SPI implementations (I2C needs an extra byte).
self.poweron()
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.height == 32 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 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_framebuf()
def fill(self, col):
self.framebuf.fill(col)
def pixel(self, x, y, col):
self.framebuf.pixel(x, y, col)
def scroll(self, dx, dy):
self.framebuf.scroll(dx, dy)
def text(self, string, x, y, col=1):
self.framebuf.text(string, x, y, col)
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)
# Add an extra byte to the data buffer to hold an I2C data/command byte
# to use hardware-compatible I2C transactions. A memoryview of the
# buffer is used to mask this byte from the framebuffer operations
# (without a major memory hit as memoryview doesn't copy to a separate
# buffer).
self.buffer = bytearray(((height // 8) * width) + 1)
self.buffer[0] = 0x40 # Set first byte of data buffer to Co=0, D/C=1
self.framebuf = framebuf.FrameBuffer1(memoryview(self.buffer)[1:], width, height)
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_framebuf(self):
# Blast out the frame buffer using a single I2C transaction to support
# hardware I2C interfaces.
self.i2c.writeto(self.addr, self.buffer)
def poweron(self):
pass
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.buffer = bytearray((height // 8) * width)
self.framebuf = framebuf.FrameBuffer1(self.buffer, width, height)
super().__init__(width, height, external_vcc)
def write_cmd(self, cmd):
self.spi.init(baudrate=self.rate, polarity=0, phase=0)
self.cs.high()
self.dc.low()
self.cs.low()
self.spi.write(bytearray([cmd]))
self.cs.high()
def write_framebuf(self):
self.spi.init(baudrate=self.rate, polarity=0, phase=0)
self.cs.high()
self.dc.high()
self.cs.low()
self.spi.write(self.buffer)
self.cs.high()
def poweron(self):
self.res.high()
time.sleep_ms(1)
self.res.low()
time.sleep_ms(10)
self.res.high()
Siga las siguientes instrucciones para el IDE que está utilizando:
- A. Cargue la biblioteca OLED con IDE de UpyCraft
- B. Cargar la biblioteca OLED con IDE de Thonny
A. Cargue la biblioteca OLED usando uPyCraft IDE
Esta sección muestra cómo cargar una biblioteca usando uPyCraft IDE. Si está utilizando Thonny IDE, lea la siguiente sección.
1. Crea un nuevo archivo presionando archivo nuevo Botón.
2. Copie el código de la biblioteca OLED a este archivo. El código de la biblioteca OLED se puede encontrar aquí.
Nota: La biblioteca de pantallas OLED SSD1306 fue desarrollada por Adafruit y ya no está disponible
estar actualizado. De momento esta funcionando bien. Sin embargo, actualizaremos esta guía cuando lo hagamos.
Encuentre una biblioteca similar que funcione tan bien como esta.
3. Después de copiar el código, guarde el archivo presionando el botón Ahorrar Botón.
4. Nombra este nuevo archivo “ssd1306.py» y presione DE ACUERDO.
5. presione eso Descargar y ejecutar Botón.
El archivo debe estar en la carpeta del dispositivo llamada «ssd1306.py» como
se destaca en la siguiente figura.
Ahora puede utilizar las funciones de la biblioteca en su código importando la biblioteca.
B. Cargar la biblioteca OLED con Thonny IDE
Si está utilizando Thonny IDE, siga los siguientes pasos:
1. Cree un nuevo archivo en Thonny IDE y copie el código de la biblioteca. El código de la biblioteca OLED se puede encontrar aquí.
2. Ir a archivo > Ahorrar como y elegir Dispositivo MicroPython.
3. Nombra el archivo ssd1306.py y haga clic DE ACUERDO para guardar el archivo en el sistema de archivos ESP.
Y eso fue todo. La biblioteca se ha subido a tu tablero. Ahora puede utilizar las funciones de la biblioteca en su código importando la biblioteca.
código
Después de cargar la biblioteca en ESP32 o ESP8266, copie el siguiente código en el
principal.py Archivo. Simplemente imprime el '¡Hola Mundo!' El mensaje aparece tres veces en la pantalla.
# Complete project details at https://RandomNerdTutorials.com/micropython-programming-with-esp32-and-esp8266/
from machine import Pin, SoftI2C
import ssd1306
from time import sleep
# ESP32 Pin assignment
i2c = SoftI2C(scl=Pin(22), sda=Pin(21))
# ESP8266 Pin assignment
#i2c = SoftI2C(scl=Pin(5), sda=Pin(4))
oled_width = 128
oled_height = 64
oled = ssd1306.SSD1306_I2C(oled_width, oled_height, i2c)
oled.text('Hello, World 1!', 0, 0)
oled.text('Hello, World 2!', 0, 10)
oled.text('Hello, World 3!', 0, 20)
oled.show()
Cómo funciona el código
Comience importando los módulos necesarios para interactuar con los GPIO y enviar datos a la pantalla OLED a través de la comunicación I2C. Tienes que Bolígrafo Y suaveI2C clases de la máquina Módulo.
from machine import Pin, SoftI2CTambién debe importar la biblioteca OLED que cargó previamente en la placa como ssd1306.py Archivo.
import ssd1306Los pines I2C estándar ESP32 son GPIO22 (SCL) y GPIO21 (ADS). Los pines I2C estándar del ESP8266 son GPIO5 (SLC) y GPIO4 (ADS).
Utilice la siguiente línea si está utilizando una placa ESP32:
# ESP32 Pin assignment
i2c = SoftI2C(scl=Pin(22), sda=Pin(21))Comente la línea anterior y descomente la siguiente línea si está utilizando una placa ESP8266:
#ESP8266 Pin assignment
i2c = SoftI2C(scl=Pin(5), sda=Pin(4))Defina el ancho y el alto de la pantalla OLED utilizando las siguientes variables:
oled_width = 128
oled_height = 64Luego crea uno SSD1306_I2C Objeto nombrado OLED. Este objeto acepta el ancho, alto y pines I2C de OLED que definiste previamente.
oled = ssd1306.SSD1306_I2C(oled_width, oled_height, i2c)Después de inicializar la pantalla OLED, es suficiente Texto() función en el OLED Objeto para escribir texto. Después Texto() Tienes que usar la función. espectáculo() Método para actualizar el OLED.
oled.text('Hello, World 1!', 0, 0)
oled.text('Hello, World 2!', 0, 10)
oled.text('Hello, World 3!', 0, 20)
oled.show()El Texto() El método acepta los siguientes argumentos (en este orden):
- Noticias: debe ser de tipo String
- Posición X: donde comienza el texto
- Posición Y: donde el texto se muestra verticalmente
- Color de texto: puede ser blanco o negro. El color predeterminado es el blanco y este parámetro es opcional.
- 0 = negro
- 1 = blanco
Por ejemplo, la siguiente línea escribe el mensaje «¡Hola, mundo 1!» en color blanco. El texto comienza en x = 0 e y = 0.
oled.text('Hello, World 1!', 0, 0)La siguiente línea de código escribe el texto en la siguiente línea (y =10).
oled.text('Hello, World 2!', 0, 10)Finalmente, para que los cambios surtan efecto, utilice el espectáculo() método en el OLED Objeto.
oled.show()demostración
Sube el código a tu tablero. Su pantalla OLED ahora debería verse así:
Más funciones OLED
La biblioteca ofrece métodos adicionales para interactuar con la pantalla OLED.
Llena la pantalla
Para llenar toda la pantalla con blanco, use el llenar() Funciona de la siguiente manera:
oled.fill(1)
oled.show()
Para borrar la pantalla, utilice el llenar() Método como pase 0 como argumento. (Establece todos los píxeles en negro):
oled.fill(0)
oled.show()dibujar un píxel
Para dibujar un píxel, utilice el Píxel() método seguido por el espectáculo() Método. El Píxel() El método acepta los siguientes argumentos:
- Coordenada X: Posición del píxel horizontalmente
- Coordenada Y: Posición de píxel vertical
- Color de píxel: puede ser blanco o negro
- 0 = negro
- 1 = blanco
Por ejemplo, para dibujar un píxel blanco en la esquina superior izquierda:
oled.pixel(0, 0, 1)
oled.show()
Colores invertidos
También puedes invertir los colores OLED: blanco con negro y viceversa, con eso volviendo atrás() Método:
oled.invert(True)
Para restaurar los colores originales utilice:
oled.invert(False)Ver datos de sensores
El Texto() La función sólo acepta variables de tipo String como mensajes. Los valores del sensor generalmente se almacenan en variables int o float.
Si desea mostrar los valores del sensor y están almacenados en variables int o float, debe convertirlos en una cadena. Para convertir los datos a una cadena, puede utilizar el cadena() Función:
temperature = 12.34
temperature_string = str(temperature)Entonces tú puedes Cadena de temperatura Variable en el OLED con el Texto() Y espectáculo() Métodos:
oled.text(temperature_string, 0, 0)
oled.show()Envolver
Esta guía rápida le mostró cómo utilizar las funciones básicas de OLED: escribir texto y dibujar píxeles con ESP32 y ESP8266 usando MicroPython. Ahora puedes utilizar el OLED en tus propios proyectos para mostrar mensajes o valores de sensores.
Tenemos otros tutoriales de MicroPython que también te pueden gustar:
- MicroPython: ESP32/ESP8266 con DHT11/DHT22
- MicroPython: ESP32/ESP8266 con servidor web DHT11/DHT22
- MicroPython: LED RGB direccionables WS2812B con ESP32 y ESP8266
Si desea obtener más información sobre la programación de las placas ESP32 y ESP8266 con MicroPython, consulte nuestro libro electrónico: Programación MicroPython con ESP32 y ESP8266.
MicroPython: pantalla OLED con ESP32 y ESP8266
En esta guía, aprenderás cómo usar la pantalla OLED SSD1306 de 0.96 pulgadas con un ESP32 o ESP8266 utilizando el firmware de MicroPython. Como ejemplo, te mostraremos cómo mostrar un simple mensaje de ‘¡Hola, Mundo!’. Posteriormente, también te mostraremos cómo utilizar otras funciones útiles para interactuar con la pantalla OLED.
Preguntas Frecuentes
- ¿Qué se necesita para seguir este tutorial?
- ¿Qué es la comunicación I2C?
- ¿Qué funciones ofrece la biblioteca SSD1306 OLED?
- ¿Cómo se carga la biblioteca OLED en la placa?
- ¿Qué otras funcionalidades puedo utilizar con la pantalla OLED?
Para seguir este tutorial, necesitas tener instalado el firmware de MicroPython en tus placas ESP32 o ESP8266. También necesitas un IDE para escribir y cargar el código en tu placa. Te sugerimos usar Thonny IDE o uPyCraft IDE.
La comunicación I2C es un protocolo de comunicación serial que se utiliza para la comunicación entre dispositivos. En el caso de la pantalla OLED, se utilizan conexiones específicas para garantizar una comunicación correcta entre la placa ESP y la pantalla.
La biblioteca SSD1306 OLED proporciona funciones para escribir en la pantalla OLED, como mostrar texto, dibujar píxeles, llenar la pantalla con un color específico, invertir los colores y mostrar datos provenientes de sensores.
Para cargar la biblioteca OLED en la placa, puedes utilizar uPyCraft IDE o Thonny IDE. Sigue los pasos indicados en la guía para llevar a cabo la carga de la biblioteca en tu placa.
Además de mostrar texto en la pantalla OLED, puedes llenar la pantalla con un color específico, dibujar píxeles, invertir los colores y mostrar datos provenientes de sensores. Estas funcionalidades te permiten personalizar la visualización en la pantalla OLED según tus necesidades.
Si deseas más información sobre MicroPython, asegúrate de consultar nuestro eBook: Programación de MicroPython con ESP32 y ESP8266.
¡Increíble! Justo lo que estaba buscando para darle un toque más avanzado a mis proyectos con ESP32 y ESP8266. Gracias por la inspiración y la guía. ¡A probar se ha dicho! 🚀
¡Esto es genial! Me encanta la idea de usar MicroPython con una pantalla OLED en mi ESP32. Definitivamente voy a probarlo en mis proyectos. ¡Gracias por compartir! 🚀
¡Qué buena idea! Me encanta experimentar con nuevas tecnologías y esta parece ser una opción interesante. ¡Gracias por el artículo!
¡Muy útil! Me gusta la combinación de MicroPython con la pantalla OLED en los ESP32 y ESP8266. Definitivamente voy a probar esto en mis proyectos. ¡Gracias por compartir!
¡Interesante! Definitivamente voy a probar esto en mi ESP32. Gracias por compartir.