Tutorial de MicroPython ESP32 - Interfaz de pantalla OLED de 0,96 pulgadas

Tutorial de MicroPython ESP32 - Interfaz de pantalla OLED de 0,96 pulgadas

julio 18, 2020

MicroPython-ESP32-Tutorial-Interfacing-0_96-OLED-Display

1. Descripción general: MicroPython de ESP32 con pantalla OLED

En esta guía, aprenderá cómo interconectar la pantalla OLED de 0.96 pulgadas o la pantalla OLED de 1.3 "con ESP32 usando código MicroPython. Usaremos SSD1306 o SSD1315 I2C OLED Display con MakePython ESP32. Escribiremos el código de Micropython enIDE uPyCrafty cargue el firmware enESP32Tabla. Mostraremos los mensajes como "Hola mundo" o cualquier texto simple en la pantalla OLED.
 
Puede consultar elIntroducción a MicroPython en ESP32 con PyCraft IDEantes de proceder a este.

Puede obtener elPlaca MakePython ESP32DeMakerfabscomo se muestra en la imagen de abajo. El tablero contiene combinados ;Chip ESP32 + pantalla OLED I2C de 1.3 ",es compatible con MicroPython.
Placa MakePython-ESP32

2. Pantalla OLED

Este SSD1306 / SSD1315 es un módulo de pantalla OLED azul de 0.96 / 1.3 pulgadas. El módulo de visualización se puede interconectar con cualquier microcontrolador utilizando protocolos SPI / IIC. Tiene una resolución de 128x64. El paquete incluye tablero de visualización, pantalla, cabezal macho de 4 pines pre-soldado a la placa.

I2C-OLED
OLED (diodo orgánico emisor de luz) es una tecnología autoemisora de luz compuesta por una película orgánica delgada de varias capas colocada entre un ánodo y un cátodo. A diferencia de la tecnología LCD, OLED no requiere una luz de fondo. OLED posee un alto potencial de aplicación para prácticamente todos los tipos de pantallas y se considera la tecnología definitiva para la próxima generación de pantallas planas.
Puede consultar esta publicación donde usamos la pantalla OLED para mostrar la temperatura:Interfaz DS18B20 Sensor de temperatura con ESP32 y OLED.

3. Diagrama de circuito / Esquemas

Si está utilizando "MakePython ESP32 Board", no se necesita ninguna conexión. El OLED I2C de 1.3 "está conectado a GPIO5 (SCL) y GPIO4 (SDA) de la placa ESP32.

En caso de que esté utilizandoPlaca Espressif ESP32y pantalla OLED externa, debe realizar conexiones como se muestra en la imagen a continuación. El pin SDA y SCL de la pantalla OLED está conectado a ESP32 GPIO21 y GPIO22 respectivamente.

ESP32-OLED

4. Código MicroPython para interfaz OLED Display con ESP32

El código MicroPython para la interfaz OLED Display con ESP32 tiene dos partes.
1. Biblioteca SSD1306
2. Código principal

La biblioteca para escribir en la pantalla OLED no forma parte de la biblioteca estándar de MicroPython de forma predeterminada. Entonces, primero necesitamos cargar la biblioteca en la placa ESP32.

4.1 Biblioteca OLED SSD1306/SSD1315

# MicroPython SSD1306 OLED driver, I2C e interfaces SPI
Desde Micropython Import Const
Tiempo de importación
Importar framebuf
Importar sys
 
currentBoard=""
if(sys.platform=="esp8266"):
  currentBoard="esp8266"
elif(sys.platform=="esp32"):
  currentBoard="esp32"
elif(sys.platform=="pyboard"):
  currentBoard="pyboard"
  Importar pyb
# Definiciones de registro
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)
clase SSD1306:
  def __init__(propio, ancho, alto, external_vcc):
    self.width = ancho
    self.height = altura
    self.external_vcc = external_vcc
    self.pages = self.height // 8
    self.buffer = bytearray(self.pages * self.width)
    self.framebuf = framebuf. FrameBuffer(self.buffer, self.width, self.height, framebuf. MVLSB)
    self.poweron()
    self.init_display()
  def init_display(self):
    para cmd en (
      SET_DISP | 0x00, # desactivado
      Configuración de dirección #
      SET_MEM_ADDR, 0x00, # horizontal
      Resolución y diseño de #
      SET_DISP_START_LINE | 0x00,
      SET_SEG_REMAP | 0x01, # column addr 127 asignado a SEG0
      SET_MUX_RATIO, self.height - 1,
      SET_COM_OUT_DIR | 0x08, # escanear de COM[N] a COM0
      SET_DISP_OFFSET, 0x00,
      SET_COM_PIN_CFG, 0x02 si self.height == 32 más 0x12,
      # cronometraje y esquema de conducción
      SET_DISP_CLK_DIV, 0x80,
      SET_PRECHARGE, 0x22 si self.external_vcc más 0xf1,
      SET_VCOM_DESEL, 0x30, # 0.83*Vcc
      # pantalla
      SET_CONTRAST, 0xff, # máximo
      SET_ENTIRE_ON, la salida # sigue el contenido de RAM
      SET_NORM_INV, # no invertido
      # bomba de carga
      SET_CHARGE_PUMP, 0x10 si self.external_vcc más 0x14,
      SET_DISP | 0x01): # activado
      self.write_cmd(cmd)
    self.fill(0)
    self.show()
  def poweroff (self):
    self.write_cmd(SET_DISP | 0x00)
  Contraste def (propio, contraste):
    self.write_cmd(SET_CONTRAST)
    self.write_cmd(contraste)
  def invert(self, invert):
    self.write_cmd(SET_NORM_INV | (invertir & 1))
  def show (self):
    x0 = 0
    x1 = self.width - 1
    if self.width == 64:
      # pantallas con un ancho de 64 píxeles se desplazan en 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)
  def fill(self, col):
    self.framebuf.fill(col)
  Píxel de definición (propio, 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)
  def hline(self, x, y, w, col):
    self.framebuf.hline(x, y, w, col)
  def vline(self, x, y, h, col):
    self.framebuf.vline(x, y, h, col)
  Línea def (self, x1, y1, x2, y2, col):
    self.framebuf.line(x1, y1, x2, y2, col)
  def rect(self, x, y, w, h, col):
    self.framebuf.rect(x, y, w, h, col)
  def fill_rect(self, x, y, w, h, col):
    self.framebuf.fill_rect(x, y, w, h, col)
  def blit(self, fbuf, x, y):
    self.framebuf.blit(fbuf, x, y)
 
clase SSD1306_I2C(SSD1306):
  def __init__(self, width, height, i2c, addr=0x3c, external_vcc=False):
    self.i2c = i2c
    self.addr = addr
    self.temp = bytearray(2)
    super().__init__(ancho, alto, external_vcc)
  def write_cmd(self, cmd):
    self.temp[0] = 0x80 # Co=1, D/C#=0
    self.temp[1] = cmd
    #IF SYS :
    currentBoard global
    if currentBoard=="esp8266" o currentBoard=="esp32":
      self.i2c.writeto(self.addr, self.temp)
    elif currentBoard=="pyboard":
      self.i2c.send(self.temp,self.addr)
    #ELSE:
          
def write_data(self, buf):
    self.temp[0] = self.addr 

                                    
1. Abra el IDE uPyCraft y cree un nuevo archivo haciendo clic en este icono.
Nuevo archivo

2. Copie el código anterior en el directorioIDEventana &salvarcon el nombreSSD1306.py.
SSD1306

3. Haga clic en el botón "Descargar y ejecutar'icono. Esto cargará el archivo en elPlaca ESP32.
Descargar-Ejecutar

4. La ventana de la consola de uPyCraft debe aparecer en el siguiente mensaje.
UpyCraft-Consola

Ahora puede importar la biblioteca SSD1306 y usarla en la parte de código.

4.2 Código principal

Después de descargar elSSD1306.pyen la placa ESP32, ahora cargue el código principal.

desde el PIN de importación de la máquina, I2C
Importar SSD1306
Desde el momento de la importación de la suspensión
 
# ESP32 Asignación de pines
i2c = I2C(-1, scl=Pin(5), sda=Pin(4))
 
oled_width = 128
oled_height = 64
OLED = SSD1306. SSD1306_I2C(oled_width, oled_height, i2c)
 
oled.text('Bienvenido', 0, 0)
oled.text('Pantalla OLED', 0, 10)
oled.text('how2electronics', 0, 20)
oled.text('Makerfabs', 0, 30)
        
oled.show()
1. Cree una nueva pestaña en uPyCraft IDE y guárdela con el nombremain.py.
mainpy-new-tab

2. Copie el código de arriba y luego cárguelo en la placa ESP32 haciendo clic en el botón "Descargar y ejecutar".
mainpy-nueva-consola

3. Después de que las ventanas de la consola muestren el mensaje anterior, ahora puede verificar la pantalla OLED y ver el siguiente mensaje como se indica en el código.
MicroPython-OLED-Display-ESP32

5. Explicación del código

desde el PIN de importación de la máquina, I2C
Esto importa la biblioteca OLED que se cargó previamente en la placa. Esta línea importa las clases Pin e I2C desde el módulo de la máquina para que los datos se puedan enviar a la pantalla OLED a través de la comunicación I2C.
 
Importar SSD1306
Esto importa la biblioteca OLED que se cargó previamente en la placa.
 
i2c = I2C(-1, scl=Pin(5), sda=Pin(4))
Estamos definiendo los pines I2C de la placa ESP32 aquí. Los pines I2C predeterminados de ESP32 son GPIO22 (SCL) y GPIO21 (SDA). En el caso de la placa MakePython ESP32, los pines GPIO son GPIO5 (SCL) y GPIO4 (SDA).
 
oled_width = 128
oled_height = 64
Esta línea define la altura y anchura OLED.
 
OLED = SSD1306. SSD1306_I2C(oled_width, oled_height, i2c)
Luego creamos un objeto SSD1306_I2C llamado oled. Este objeto acepta el ancho OLED, el alto y los pines I2C definidos anteriormente.
 
oled.text('Bienvenido', 0, 0)
oled.text('Pantalla OLED', 0, 10)
Usando oled estamos inicializando la pantalla OLED y usando la función text() estamos escribiendo texto.
 
oled.show()
Usando esta línea llamamos al método show() para actualizar el OLED.

Puedes consultar esta guía de vídeo:

Esta guía se publicó originalmente enHow2Electronics.Si tiene más preguntas o necesita alguna placa PCBA personalizada basada en esas placas MakePython IoT, póngase en contacto conservice@makerfabs.com.corazón

Contáctenos