Placa OLED incorporada ESP32 (Wemos Lolin32): distribución de pines, bibliotecas y control OLED

La combinación del ESP32 y una placa OLED incorporada como la Wemos Lolin32 es una opción poderosa para proyectos de IoT y dispositivos portátiles. En este artículo, exploraremos la distribución de pines de esta placa, las bibliotecas disponibles y cómo controlar la pantalla OLED para sacar el máximo provecho de tu proyecto. ¡Sigue leyendo para descubrir todo lo que necesitas saber para trabajar con esta emocionante tecnología!

Wemos Lolin32 OLED es una placa de desarrollo ESP32 con una pantalla OLED integrada. En esta guía, veremos rápidamente la placa, su distribución de pines y cómo controlar la pantalla OLED usando Arduino IDE o MicroPython.

Placa OLED incorporada ESP32 (Wemos Lolin32): distribución de pines, bibliotecas y control OLED

Wemos Lolin32 ESP32 OLED Descripción general

El WeMos Lolin32 OLED Es una placa de desarrollo con ESP32 y pantalla OLED I2C I2C de 0,96 pulgadas y 128 × 64 integrada.

Placa OLED incorporada ESP32 (Wemos Lolin32): distribución de pines, bibliotecas y control OLED

Como placa ESP32 normal, tiene un botón BOOT y EN (RST). Algunos modelos tienen los botones en la parte trasera, algunos los tienen ambos en la parte delantera y otros tienen uno en la parte delantera y otro en la parte trasera. Sin embargo, todas las placas deberían funcionar de manera similar.

Placa OLED incorporada ESP32 (Wemos Lolin32): distribución de pines, bibliotecas y control OLED

¿Donde comprar?

Puedes ir al… WeMos Lolin32 ESP32 OLED Página arriba Asesor de creadores para encontrar el mejor precio en diferentes tiendas.

Configuración de pines OLED de Lolin32

La placa OLED Lolin32 no tiene tantos GPIO accesibles como un ESP32 normal. Sin embargo, puede resultar muy conveniente para proyectos que requieren una pantalla OLED sin circuitos adicionales.

La siguiente figura muestra la distribución de pines de la placa OLED Lolin32 ESP32.

Placa OLED incorporada ESP32 (Wemos Lolin32): distribución de pines, bibliotecas y control OLED
Imagen adaptada de (Ver código fuente)

La pantalla OLED se comunica con el ESP32 a través del protocolo de comunicación I2C. Utiliza los siguientes pines para SDA/SCL:

ASD GPIO5
SCL GPIO4

Recomendaciones de literatura: Guía de referencia de asignación de pines ESP32

Controla el OLED con Arduino IDE

Para controlar la placa con Arduino IDE, se debe instalar el complemento ESP32. Puedes seguir la guía a continuación:

  • Instalación de la placa ESP32 en el IDE Arduino (Windows, Mac OS X, Linux)

Bibliotecas OLED para Arduino IDE

Hay varias bibliotecas disponibles para controlar la pantalla OLED con el ESP32. En este tutorial usaremos dos bibliotecas de Adafruit: Biblioteca Adafruit_SSD1306 Y Biblioteca Adafruit_GFX.

Siga los siguientes pasos para instalar estas bibliotecas.

1. Abra su IDE de Arduino y vaya a Bosquejo > incluir biblioteca > Administrar bibliotecas. El administrador de la biblioteca debería abrirse.

2. Ingrese «SSD1306”en el cuadro de búsqueda e instale la biblioteca SSD1306 de Adafruit.

Placa OLED incorporada ESP32 (Wemos Lolin32): distribución de pines, bibliotecas y control OLED

3. Después de instalar la biblioteca SSD1306 de Adafruit, escriba «gráfico“ en el campo de búsqueda e instale la biblioteca.

Placa OLED incorporada ESP32 (Wemos Lolin32): distribución de pines, bibliotecas y control OLED

4. Reinicie su IDE de Arduino después de instalar las bibliotecas.

Controla el OLED

Las bibliotecas de Adafruit utilizan GPIO 22 y GPIO 21 como pines I2C estándar, pero puedes cambiar los pines agregando dos líneas de código.

En el configuración()necesita iniciar una comunicación I2C con GPIO5 Y GPIO4Entonces necesitas agregar la siguiente línea:

Wire.begin(5, 4);

Luego inicialice la pantalla con los siguientes parámetros:

if(!display.begin(SSD1306_SWITCHCAPVCC, 0x3C, false, false)) { 

Los parámetros se establecen de la siguiente manera: INCORRECTO Asegúrese de que la biblioteca no utilice los pines I2C estándar, sino los pines definidos en el código (GPIO 5 y GPIO 4).

Al agregar estas dos líneas de código, puede usar cualquier ejemplo que use estas bibliotecas para controlar esta pantalla OLED.

Para probar su pantalla OLED, puede copiar el siguiente código en su IDE de Arduino.

/*********
  Rui Santos
  Complete project details at https://randomnerdtutorials.com  
*********/

#include <Wire.h>
#include <Adafruit_GFX.h>
#include <Adafruit_SSD1306.h>

#define SCREEN_WIDTH 128
#define SCREEN_HEIGHT 64

Adafruit_SSD1306 display(SCREEN_WIDTH, SCREEN_HEIGHT, &Wire, -1);

static const uint8_t image_data_Saraarray[1024] = {
    0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfe, 0x00, 0x00, 0x00, 0x1f, 0xff, 0xff, 0xff, 0xff, 0xff, 
    0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf8, 0x00, 0x00, 0x00, 0x0f, 0xff, 0xff, 0xff, 0xff, 0xff, 
    0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf8, 0x00, 0x00, 0x00, 0x07, 0xff, 0xff, 0xff, 0xff, 0xff, 
    0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf0, 0x00, 0x00, 0x00, 0x07, 0xff, 0xff, 0xff, 0xff, 0xff, 
    0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xe0, 0x00, 0x00, 0x00, 0x03, 0xff, 0xff, 0xff, 0xff, 0xff, 
    0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc0, 0x00, 0x00, 0x00, 0x01, 0xff, 0xff, 0xff, 0xff, 0xff, 
    0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x80, 0x00, 0x00, 0x00, 0x01, 0xff, 0xff, 0xff, 0xff, 0xff, 
    0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x80, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 
    0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x7f, 0xff, 0xff, 0xff, 0xff, 
    0xff, 0xff, 0xff, 0xff, 0xff, 0xfe, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3f, 0xff, 0xff, 0xff, 0xff, 
    0xff, 0xff, 0xff, 0xff, 0xff, 0xfc, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3f, 0xff, 0xff, 0xff, 0xff, 
    0xff, 0xff, 0xff, 0xff, 0xff, 0xfc, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1f, 0xff, 0xff, 0xff, 0xff, 
    0xff, 0xff, 0xff, 0xff, 0xff, 0xfc, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1f, 0xff, 0xff, 0xff, 0xff, 
    0xff, 0xff, 0xff, 0xff, 0xff, 0xfc, 0x00, 0x00, 0x00, 0x0a, 0x00, 0x1f, 0xff, 0xff, 0xff, 0xff, 
    0xff, 0xff, 0xff, 0xff, 0xff, 0xfc, 0x00, 0x00, 0x14, 0x9e, 0x00, 0x1f, 0xff, 0xff, 0xff, 0xff, 
    0xff, 0xff, 0xff, 0xff, 0xff, 0xfc, 0x00, 0x00, 0x36, 0x3f, 0x00, 0x1f, 0xff, 0xff, 0xff, 0xff, 
    0xff, 0xff, 0xff, 0xff, 0xff, 0xfc, 0x00, 0x00, 0x6d, 0xff, 0x00, 0x1f, 0xff, 0xff, 0xff, 0xff, 
    0xff, 0xff, 0xff, 0xff, 0xff, 0xfc, 0x00, 0x00, 0xfb, 0xff, 0x80, 0x1f, 0xff, 0xff, 0xff, 0xff, 
    0xff, 0xff, 0xff, 0xff, 0xff, 0xfc, 0x00, 0x03, 0xd7, 0xff, 0x80, 0x0f, 0xff, 0xff, 0xff, 0xff, 
    0xff, 0xff, 0xff, 0xff, 0xff, 0xf8, 0x00, 0x07, 0xef, 0xff, 0x80, 0x07, 0xff, 0xff, 0xff, 0xff, 
    0xff, 0xff, 0xff, 0xff, 0xff, 0xf8, 0x00, 0x0f, 0xdf, 0xff, 0x90, 0x07, 0xff, 0xff, 0xff, 0xff, 
    0xff, 0xff, 0xff, 0xff, 0xff, 0xf8, 0x00, 0x0f, 0xbf, 0xff, 0xd0, 0x07, 0xff, 0xff, 0xff, 0xff, 
    0xff, 0xff, 0xff, 0xff, 0xff, 0xf0, 0x00, 0x1d, 0x7f, 0xff, 0xd0, 0x07, 0xff, 0xff, 0xff, 0xff, 
    0xff, 0xff, 0xff, 0xff, 0xff, 0xf0, 0x01, 0x1b, 0xff, 0xff, 0xc0, 0x07, 0xff, 0xff, 0xff, 0xff, 
    0xff, 0xff, 0xff, 0xff, 0xff, 0xf0, 0x02, 0xa7, 0xff, 0xff, 0xc0, 0x07, 0xff, 0xff, 0xff, 0xff, 
    0xff, 0xff, 0xff, 0xff, 0xff, 0xe0, 0x00, 0x03, 0xff, 0xc0, 0x00, 0x07, 0xff, 0xff, 0xff, 0xff, 
    0xff, 0xff, 0xff, 0xff, 0xff, 0xe0, 0x00, 0x00, 0xff, 0x80, 0x00, 0x0b, 0xff, 0xff, 0xff, 0xff, 
    0xff, 0xff, 0xff, 0xff, 0xff, 0xc0, 0x03, 0xff, 0xff, 0xff, 0xf0, 0x0f, 0xff, 0xff, 0xff, 0xff, 
    0xff, 0xff, 0xff, 0xff, 0xff, 0x80, 0x07, 0xff, 0xff, 0xff, 0xf0, 0x0f, 0xff, 0xff, 0xff, 0xff, 
    0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x0f, 0x07, 0xff, 0xf8, 0xf8, 0x03, 0xff, 0xff, 0xff, 0xff, 
    0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x0e, 0x01, 0xff, 0xc0, 0x38, 0x07, 0xff, 0xff, 0xff, 0xff, 
    0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x1c, 0x46, 0xff, 0xb1, 0x18, 0x07, 0xff, 0xff, 0xff, 0xff, 
    0xff, 0xff, 0xff, 0xff, 0xfe, 0x00, 0x3f, 0x97, 0xff, 0xc0, 0x7a, 0x07, 0xff, 0xff, 0xff, 0xff, 
    0xff, 0xff, 0xff, 0xff, 0xfe, 0x00, 0x3f, 0xff, 0xff, 0xff, 0xfe, 0x03, 0xff, 0xff, 0xff, 0xff, 
    0xff, 0xff, 0xff, 0xff, 0xfe, 0x00, 0x3f, 0xff, 0xff, 0xff, 0xfe, 0x03, 0xff, 0xff, 0xff, 0xff, 
    0xff, 0xff, 0xff, 0xff, 0xfe, 0x01, 0x3f, 0xff, 0xff, 0xff, 0xfe, 0x01, 0xff, 0xff, 0xff, 0xff, 
    0xff, 0xff, 0xff, 0xff, 0xfe, 0x01, 0xbf, 0xff, 0xff, 0xff, 0xfe, 0x81, 0xff, 0xff, 0xff, 0xff, 
    0xff, 0xff, 0xff, 0xff, 0xfc, 0x00, 0xbf, 0xff, 0xff, 0xff, 0xfc, 0x81, 0xff, 0xff, 0xff, 0xff, 
    0xff, 0xff, 0xff, 0xff, 0xfc, 0x00, 0xff, 0xff, 0xfe, 0xff, 0xfd, 0x83, 0xff, 0xff, 0xff, 0xff, 
    0xff, 0xff, 0xff, 0xff, 0xf8, 0x00, 0xbf, 0xff, 0xfe, 0xff, 0xfd, 0x01, 0xff, 0xff, 0xff, 0xff, 
    0xff, 0xff, 0xff, 0xff, 0xf8, 0x00, 0x7f, 0xff, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff, 0xff, 0xff, 
    0xff, 0xff, 0xff, 0xff, 0xf0, 0x00, 0x7f, 0xff, 0xff, 0xff, 0xfb, 0x03, 0xff, 0xff, 0xff, 0xff, 
    0xff, 0xff, 0xff, 0xff, 0xe0, 0x00, 0x3f, 0xff, 0xdc, 0xff, 0xfa, 0x03, 0xff, 0xff, 0xff, 0xff, 
    0xff, 0xff, 0xff, 0xff, 0xd8, 0x00, 0x1f, 0xff, 0xff, 0xff, 0xf8, 0x03, 0xff, 0xff, 0xff, 0xff, 
    0xff, 0xff, 0xff, 0xff, 0xd0, 0x00, 0x1f, 0xff, 0xff, 0xff, 0xf8, 0x01, 0xff, 0xff, 0xff, 0xff, 
    0xff, 0xff, 0xff, 0xff, 0x90, 0x00, 0x1f, 0xff, 0xff, 0xff, 0xf8, 0x02, 0xff, 0xff, 0xff, 0xff, 
    0xff, 0xff, 0xff, 0xff, 0xb0, 0x00, 0x0f, 0xf5, 0xff, 0xd7, 0xf8, 0x01, 0xff, 0xff, 0xff, 0xff, 
    0xff, 0xff, 0xff, 0xff, 0xb0, 0x00, 0x0f, 0xff, 0xff, 0xff, 0xf8, 0x00, 0x5f, 0xff, 0xff, 0xff, 
    0xff, 0xff, 0xff, 0xff, 0xa0, 0x00, 0x0f, 0xfb, 0xff, 0xff, 0xf0, 0x00, 0x3f, 0xff, 0xff, 0xff, 
    0xff, 0xff, 0xff, 0xff, 0x80, 0x00, 0x0f, 0xfd, 0xff, 0xdf, 0xf0, 0x00, 0x3f, 0xff, 0xff, 0xff, 
    0xff, 0xff, 0xff, 0xff, 0x80, 0x00, 0x07, 0xff, 0xff, 0xbf, 0xf0, 0x00, 0x0f, 0xff, 0xff, 0xff, 
    0xff, 0xff, 0xff, 0xff, 0x80, 0x00, 0x07, 0xff, 0xff, 0xff, 0xe0, 0x00, 0x87, 0xff, 0xff, 0xff, 
    0xff, 0xff, 0xff, 0xff, 0x80, 0x00, 0x03, 0xff, 0xff, 0xff, 0xc0, 0x00, 0x43, 0xff, 0xff, 0xff, 
    0xff, 0xff, 0xff, 0xff, 0x60, 0x00, 0x01, 0xff, 0xff, 0xff, 0xc0, 0x00, 0x73, 0xff, 0xff, 0xff, 
    0xff, 0xff, 0xff, 0xfe, 0xe0, 0x00, 0x00, 0xff, 0xff, 0xff, 0x80, 0x00, 0x7b, 0xff, 0xff, 0xff, 
    0xff, 0xff, 0xff, 0xfd, 0xe0, 0x00, 0x00, 0x7f, 0xff, 0xfe, 0x00, 0x00, 0x33, 0xff, 0xff, 0xff, 
    0xff, 0xff, 0xff, 0xfd, 0xe0, 0x00, 0x00, 0x3f, 0xff, 0xf8, 0x00, 0x00, 0x27, 0xff, 0xff, 0xff, 
    0xff, 0xff, 0xff, 0xff, 0xe0, 0x00, 0x00, 0x0f, 0xff, 0xf0, 0x00, 0x00, 0x0f, 0xff, 0xff, 0xff, 
    0xff, 0xff, 0xff, 0xff, 0x60, 0x00, 0x00, 0x67, 0xff, 0xe0, 0x00, 0x00, 0x1b, 0xff, 0xff, 0xff, 
    0xff, 0xff, 0xff, 0xfd, 0x40, 0x00, 0x00, 0xf3, 0xff, 0xc4, 0x00, 0x00, 0x0b, 0xff, 0xff, 0xff, 
    0xff, 0xff, 0xff, 0xfe, 0x80, 0x00, 0x00, 0xfc, 0xff, 0x8c, 0x00, 0x00, 0x03, 0xff, 0xff, 0xff, 
    0xff, 0xff, 0xff, 0xfe, 0x00, 0x00, 0x00, 0x7f, 0x3c, 0x3c, 0x00, 0x00, 0x07, 0xff, 0xff, 0xff, 
    0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x3f, 0xc0, 0x7c, 0x00, 0x00, 0x03, 0xff, 0xff, 0xff, 
    0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x1f, 0xff, 0xfc, 0x00, 0x00, 0x03, 0xff, 0xff, 0xff
};
 
void setup() {
  Serial.begin(115200);
  
  // Start I2C Communication SDA = 5 and SCL = 4 on Wemos Lolin32 ESP32 with built-in SSD1306 OLED
  Wire.begin(5, 4);

  if(!display.begin(SSD1306_SWITCHCAPVCC, 0x3C, false, false)) {
    Serial.println(F("SSD1306 allocation failed"));
    for(;;);
  }
  delay(2000); // Pause for 2 seconds
 
  // Clear the buffer.
  display.clearDisplay();
  
  // Draw bitmap on the screen
  display.drawBitmap(0, 0, image_data_Saraarray, 128, 64, 1);
  display.display();
}
 
void loop() {
  
}

Ver código sin formato

Para obtener instrucciones más detalladas sobre cómo usar la pantalla OLED, consulte el siguiente tutorial:

  • Pantalla OLED ESP32 con Arduino IDE

Todos los ejemplos proporcionados en el tutorial son compatibles con esta pantalla siempre que agregue las líneas de código mencionadas anteriormente para configurar los pines I2C correctos.

Sube el código

Para cargar el código en la placa OLED Lolin32, conéctela a su computadora. Vaya a su IDE de Arduino Herramientas > Puerto y seleccione el puerto COM al que está conectado.

Entonces ve a eso Herramientas > tablón y elige WEMOS LOLIN32.

Placa OLED incorporada ESP32 (Wemos Lolin32): distribución de pines, bibliotecas y control OLED

demostración

Después de cargar el código, debería ver aparecer una cara en su pantalla.

Placa OLED incorporada ESP32 (Wemos Lolin32): distribución de pines, bibliotecas y control OLED

Controla el OLED con MicroPython

En esta sección, le mostraremos cómo controlar la pantalla OLED con MicroPython. Si no está familiarizado con MicroPython, puede comenzar con nuestra guía:

  • Comenzando con MicroPython en ESP32 y ESP8266

Biblioteca OLED para MicroPython

Para controlar la pantalla OLED con MicroPython utilizamos la biblioteca ssd1306 de Adafruit. El código de la biblioteca que utilizamos. lo encontraras aquiguárdalo en tu ESP con el nombre ssd1306.py:

# 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()

Ver código sin formato

Sube la biblioteca a tu tablero. Si no sabe cómo cargar la biblioteca, puede seguir nuestro tutorial OLED detallado con MicroPython.

Script MicroPython – Control OLED

Después de cargar la biblioteca en ESP32, copie el siguiente código en el arranque.py Archivo. Simplemente imprime el mensaje «¡Hola mundo!» tres veces en la pantalla.

# Complete project details at https://RandomNerdTutorials.com

from machine import Pin, SoftI2C
import ssd1306
from time import sleep

# Start I2C Communication SCL = 4 and SDA = 5 on Wemos Lolin32 ESP32 with built-in SSD1306 OLED
i2c = SoftI2C(scl=Pin(4), sda=Pin(5))

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()

Ver código sin formato

En nuestros ejemplos que utilizan MicroPython, normalmente utilizamos los pines ESP32 I2C estándar (GPIO 21 y GPIO 22). Sin embargo, el Wemos Lolin32 usa una placa OLED. GPIO4 Y GPIO5. Entonces necesitamos configurar esto en el script.

Para definir los pines I2C de su pantalla OLED, pase los pines SCL y SDA de la siguiente manera:

i2c = SoftI2C(scl=Pin(4), sda=Pin(5))

Para obtener una explicación de cómo escribir texto y mostrar formas en la pantalla OLED usando MicroPython, consulte el siguiente tutorial:

  • MicroPython: pantalla OLED con ESP32 y ESP8266

Todos los ejemplos son compatibles con esta placa siempre que configure los pines I2C correctos en sus scripts.

demostración

Después de reiniciar el tablero y ejecutar el script cargado, debería ver algo similar en su pantalla:

Placa OLED incorporada ESP32 (Wemos Lolin32): distribución de pines, bibliotecas y control OLED

Envolver

Esperamos que esta guía te haya resultado útil. Placa OLED Wemos Lolin32 útil. Controlar la pantalla OLED integrada del ESP32 es lo mismo que controlar un OLED I2C independiente de 0,96 pulgadas: solo necesita asignar los pines I2C correctos en su código.

Aprenda a escribir texto, configurar diferentes fuentes, dibujar formas y mostrar imágenes de mapa de bits usando la pantalla OLED:

  • Pantalla OLED ESP32 con Arduino IDE
  • MicroPython: pantalla OLED con ESP32 y ESP8266

Gracias por leer.

Error 403 The request cannot be completed because you have exceeded your quota. : quotaExceeded







Placa OLED incorporada ESP32 (Wemos Lolin32): distribución de pines, bibliotecas y control OLED

Placa Wemos Lolin32 ESP32 OLED

La placa Wemos Lolin32 OLED es una placa de desarrollo con ESP32 y una pantalla OLED de 0.96 pulgadas 128×64 I2C incorporada.

¿Dónde comprar?

Puedes consultar la página de Wemos Lolin32 ESP32 OLED en Maker Advisor para encontrar el mejor precio en diferentes tiendas.

Distribución de pines de la Lolin32 OLED

La placa Lolin32 OLED no tiene tantos GPIOs accesibles como un ESP32 regular. Sin embargo, puede ser muy útil en proyectos que requieran una pantalla OLED sin necesidad de circuitos adicionales.

Bibliotecas y control OLED con Arduino IDE

Hay varias bibliotecas disponibles para controlar la pantalla OLED con el ESP32. En este tutorial utilizaremos dos bibliotecas de Adafruit: la biblioteca Adafruit_SSD1306 y la biblioteca Adafruit_GFX.

  1. Abre tu Arduino IDE y ve a Sketch > Include Library > Manage Libraries. El Administrador de bibliotecas debería abrirse.
  2. Escribe «SSD1306» en la barra de búsqueda e instala la biblioteca SSD1306 de Adafruit.
  3. Después de instalar la biblioteca SSD1306 de Adafruit, escribe «GFX» en la barra de búsqueda e instala la biblioteca.
  4. Después de instalar las bibliotecas, reinicia tu Arduino IDE.

Control del OLED

Las bibliotecas de Adafruit utilizan GPIO 22 y GPIO 21 como pines I2C por defecto, pero puedes cambiar los pines simplemente agregando dos líneas de código.

Para definir los pines I2C de tu pantalla OLED en el setup(), necesitas iniciar una comunicación I2C utilizando GPIO 5 y GPIO 4.

    Wire.begin(5, 4);
  

Después de eso, inicializa la pantalla con los siguientes parámetros:

    if(!display.begin(SSD1306_SWITCHCAPVCC, 0x3C, false, false)) {
  

Si agregas estas dos líneas de código, puedes usar cualquier ejemplo que utilice estas bibliotecas para controlar esta pantalla OLED.

Control del OLED con MicroPython

En esta sección, te mostraremos cómo controlar el OLED con MicroPython. Para más información sobre cómo usar la pantalla OLED, puedes seguir nuestro tutorial específico.

Para controlar la pantalla OLED con MicroPython, usamos la biblioteca ssd1306 de Adafruit. El código de la biblioteca que estamos utilizando se puede encontrar aquí.

Sube la biblioteca a tu placa y copia el siguiente código en el archivo boot.py para mostrar un mensaje en la pantalla OLED.

Resumen

Esperamos que esta guía sobre la placa Wemos Lolin32 OLED haya sido útil. El control de la pantalla OLED incorporada en el ESP32 es similar al de una OLED I2C independiente, solo necesitas asignar los pines I2C correctos en tu código.


5 comentarios en «Placa OLED incorporada ESP32 (Wemos Lolin32): distribución de pines, bibliotecas y control OLED»

  1. ¡Me encantó este artículo! La información detallada sobre la distribución de pines y las bibliotecas recomendadas es justo lo que necesitaba para poder sacar el máximo provecho a la placa OLED en mi ESP32. ¡Gracias por compartir! 🙏🏼👩🏽‍💻

  2. ¡Qué buen aporte! Siempre es genial tener información detallada sobre la distribución de pines, bibliotecas y control de OLED para el ESP32. Me motiva a seguir experimentando con mi placa. ¡Gracias! 🤓👍🏼

  3. ¡Excelente artículo! Me encantó la forma en que detallan la distribución de pines y recomiendan bibliotecas para controlar la OLED en el ESP32. Definitivamente me inspira a probar nuevas cosas. ¡Gracias por la info! 🤩👏🏼

Deja un comentario