Tutorial de MicroPython ESP32 - Interfaz de pantalla OLED de 0,96 pulgadas
1. Descripción general: MicroPython de ESP32 con pantalla OLED
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.
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.
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.
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.addr1. Abra el IDE uPyCraft y cree un nuevo archivo haciendo clic en este icono.
2. Copie el código anterior en el directorioIDEventana &salvarcon el nombreSSD1306.py.
3. Haga clic en el botón "Descargar y ejecutar'icono. Esto cargará el archivo en elPlaca ESP32.
4. La ventana de la consola de uPyCraft debe aparecer en el siguiente mensaje.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.
2. Copie el código de arriba y luego cárguelo en la placa ESP32 haciendo clic en el botón "Descargar y ejecutar".
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.5. Explicación del código
desde el PIN de importación de la máquina, I2CEsto 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 SSD1306Esto 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 = 64Esta 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.