ssd1306.py & sh1106.py

# Driver SSD1306 OLED — MicroPython
# Source : micropython/micropython-lib (MIT License)
# À copier sur l'ESP32 via Thonny (clic droit → Upload to /)

import framebuf

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(framebuf.FrameBuffer):
    def __init__(self, width, height, external_vcc):
        self.width = width
        self.height = height
        self.external_vcc = external_vcc
        self.pages = self.height // 8
        self.buffer = bytearray(self.pages * self.width)
        super().__init__(self.buffer, self.width, self.height, framebuf.MONO_VLSB)
        self.init_display()

    def init_display(self):
        for cmd in (
            SET_DISP | 0x00,           # off
            SET_MEM_ADDR, 0x00,        # horizontal
            SET_DISP_START_LINE | 0x00,
            SET_SEG_REMAP | 0x01,      # remap
            SET_MUX_RATIO, self.height - 1,
            SET_COM_OUT_DIR | 0x08,    # flip
            SET_DISP_OFFSET, 0x00,
            SET_COM_PIN_CFG, 0x02 if (self.width == 128 and self.height == 32) else 0x12,
            SET_DISP_CLK_DIV, 0x80,
            SET_PRECHARGE, 0x22 if self.external_vcc else 0xf1,
            SET_VCOM_DESEL, 0x30,
            SET_CONTRAST, 0xff,
            SET_ENTIRE_ON,
            SET_NORM_INV,
            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 poweron(self):
        self.write_cmd(SET_DISP | 0x01)

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


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)
        self.write_list = [b"\x40", None]
        super().__init__(width, height, external_vcc)

    def write_cmd(self, cmd):
        self.temp[0] = 0x80
        self.temp[1] = cmd
        self.i2c.writeto(self.addr, self.temp)

    def write_data(self, buf):
        self.write_list[1] = buf
        self.i2c.writevto(self.addr, self.write_list)

# Driver SH1106 OLED — MicroPython
# Compatible OLED 1.3 pouces (contrôleur SH1106)
# À copier sur l'ESP32 via Thonny (clic droit → Upload to /)

import framebuf
from time import sleep_ms

class SH1106(framebuf.FrameBuffer):

    def __init__(self, width, height, external_vcc=False):
        self.width        = width
        self.height       = height
        self.external_vcc = external_vcc
        self.pages        = height // 8
        self._buffer      = bytearray(self.pages * width)
        super().__init__(self._buffer, width, height, framebuf.MONO_VLSB)
        self.init_display()

    def init_display(self):
        self._write_cmd(0xAE)   # display off
        self._write_cmd(0xD5)   # clock div
        self._write_cmd(0x80)
        self._write_cmd(0xA8)   # multiplex
        self._write_cmd(self.height - 1)
        self._write_cmd(0xD3)   # display offset
        self._write_cmd(0x00)
        self._write_cmd(0x40)   # start line
        self._write_cmd(0xAD)   # charge pump
        self._write_cmd(0x8B if not self.external_vcc else 0x8A)
        self._write_cmd(0xA1)   # seg remap
        self._write_cmd(0xC8)   # com scan dir
        self._write_cmd(0xDA)   # com pins
        self._write_cmd(0x12)
        self._write_cmd(0x81)   # contrast
        self._write_cmd(0xFF)
        self._write_cmd(0xD9)   # precharge
        self._write_cmd(0x1F if not self.external_vcc else 0x22)
        self._write_cmd(0xDB)   # vcom deselect
        self._write_cmd(0x40)
        self._write_cmd(0xA4)   # entire display on
        self._write_cmd(0xA6)   # normal display
        self.fill(0)
        self.show()
        self._write_cmd(0xAF)   # display on

    def poweroff(self):
        self._write_cmd(0xAE)

    def poweron(self):
        self._write_cmd(0xAF)

    def sleep(self, on):
        self._write_cmd(0xAE if on else 0xAF)

    def contrast(self, contrast):
        self._write_cmd(0x81)
        self._write_cmd(contrast)

    def invert(self, invert):
        self._write_cmd(0xA7 if invert else 0xA6)

    def show(self):
        # Le SH1106 a un offset de 2 colonnes dans sa RAM interne
        for page in range(self.pages):
            self._write_cmd(0xB0 | page)        # page address
            self._write_cmd(0x02)               # col low  (offset 2)
            self._write_cmd(0x10)               # col high
            self._write_data(self._buffer[page * self.width:(page + 1) * self.width])


class SH1106_I2C(SH1106):

    def __init__(self, width, height, i2c, rst=None, addr=0x3C):
        self.i2c  = i2c
        self.addr = addr
        self.rst  = rst
        if rst is not None:
            rst.value(1)
        super().__init__(width, height)

    def _write_cmd(self, cmd):
        self.i2c.writeto(self.addr, bytes([0x00, cmd]))

    def _write_data(self, buf):
        self.i2c.writeto(self.addr, b'\x40' + bytes(buf))