1. # MicroPython SSD1306 OLED driver, I2C and SPI interfaces
    3. import time
    4. import framebuf
    7. # register definitions
    8. SET_CONTRAST        = const(0x81)
    9. SET_ENTIRE_ON       = const(0xa4)
    10. SET_NORM_INV        = const(0xa6)
    11. SET_DISP            = const(0xae)
    12. SET_MEM_ADDR        = const(0x20)
    13. SET_COL_ADDR        = const(0x21)
    14. SET_PAGE_ADDR       = const(0x22)
    15. SET_DISP_START_LINE = const(0x40)
    16. SET_SEG_REMAP       = const(0xa0)
    17. SET_MUX_RATIO       = const(0xa8)
    18. SET_COM_OUT_DIR     = const(0xc0)
    19. SET_DISP_OFFSET     = const(0xd3)
    20. SET_COM_PIN_CFG     = const(0xda)
    21. SET_DISP_CLK_DIV    = const(0xd5)
    22. SET_PRECHARGE       = const(0xd9)
    23. SET_VCOM_DESEL      = const(0xdb)
    24. SET_CHARGE_PUMP     = const(0x8d)
    27. class SSD1306:
    28.     def __init__(self, width, height, external_vcc):
    29.         self.width = width
    30.         self.height = height
    31.         self.external_vcc = external_vcc
    32.         self.pages = self.height // 8
    33.         # Note the subclass must initialize self.framebuf to a framebuffer.
    34.         # This is necessary because the underlying data buffer is different
    35.         # between I2C and SPI implementations (I2C needs an extra byte).
    36.         self.poweron()
    37.         self.init_display()
    39.     def init_display(self):
    40.         for cmd in (
    41.             SET_DISP | 0x00, # off
    42.             # address setting
    43.             SET_MEM_ADDR, 0x00, # horizontal
    44.             # resolution and layout
    45.             SET_DISP_START_LINE | 0x00,
    46.             SET_SEG_REMAP | 0x01, # column addr 127 mapped to SEG0
    47.             SET_MUX_RATIO, self.height - 1,
    48.             SET_COM_OUT_DIR | 0x08, # scan from COM[N] to COM0
    49.             SET_DISP_OFFSET, 0x00,
    50.             SET_COM_PIN_CFG, 0x02 if self.height == 32 else 0x12,
    51.             # timing and driving scheme
    52.             SET_DISP_CLK_DIV, 0x80,
    53.             SET_PRECHARGE, 0x22 if self.external_vcc else 0xf1,
    54.             SET_VCOM_DESEL, 0x30, # 0.83*Vcc
    55.             # display
    56.             SET_CONTRAST, 0xff, # maximum
    57.             SET_ENTIRE_ON, # output follows RAM contents
    58.             SET_NORM_INV, # not inverted
    59.             # charge pump
    60.             SET_CHARGE_PUMP, 0x10 if self.external_vcc else 0x14,
    61.             SET_DISP | 0x01): # on
    62.             self.write_cmd(cmd)
    63.         self.fill(0)
    64.         self.show()
    66.     def poweroff(self):
    67.         self.write_cmd(SET_DISP | 0x00)
    69.     def contrast(self, contrast):
    70.         self.write_cmd(SET_CONTRAST)
    71.         self.write_cmd(contrast)
    73.     def invert(self, invert):
    74.         self.write_cmd(SET_NORM_INV | (invert & 1))
    76.     def show(self):
    77.         x0 = 0
    78.         x1 = self.width - 1
    79.         if self.width == 64:
    80.             # displays with width of 64 pixels are shifted by 32
    81.             x0 += 32
    82.             x1 += 32
    83.         self.write_cmd(SET_COL_ADDR)
    84.         self.write_cmd(x0)
    85.         self.write_cmd(x1)
    86.         self.write_cmd(SET_PAGE_ADDR)
    87.         self.write_cmd(0)
    88.         self.write_cmd(self.pages - 1)
    89.         self.write_framebuf()
    91.     def fill(self, col):
    92.         self.framebuf.fill(col)
    94.     def pixel(self, x, y, col):
    95.         self.framebuf.pixel(x, y, col)
    97.     def scroll(self, dx, dy):
    98.         self.framebuf.scroll(dx, dy)
    100.     def text(self, string, x, y, col=1):
    101.         self.framebuf.text(string, x, y, col)
    104. class SSD1306_I2C(SSD1306):
    105.     def __init__(self, width, height, i2c, addr=0x3c, external_vcc=False):
    106.         self.i2c = i2c
    107.         self.addr = addr
    108.         self.temp = bytearray(2)
    109.         # Add an extra byte to the data buffer to hold an I2C data/command byte
    110.         # to use hardware-compatible I2C transactions.  A memoryview of the
    111.         # buffer is used to mask this byte from the framebuffer operations
    112.         # (without a major memory hit as memoryview doesn't copy to a separate
    113.         # buffer).
    114.         self.buffer = bytearray(((height // 8) * width) + 1)
    115.         self.buffer[0] = 0x40  # Set first byte of data buffer to Co=0, D/C=1
    116.         self.framebuf = framebuf.FrameBuffer1(memoryview(self.buffer)[1:], width, height)
    117.         super().__init__(width, height, external_vcc)
    119.     def write_cmd(self, cmd):
    120.         self.temp[0] = 0x80 # Co=1, D/C#=0
    121.         self.temp[1] = cmd
    122.         self.i2c.writeto(self.addr, self.temp)
    124.     def write_framebuf(self):
    125.         # Blast out the frame buffer using a single I2C transaction to support
    126.         # hardware I2C interfaces.
    127.         self.i2c.writeto(self.addr, self.buffer)
    129.     def poweron(self):
    130.         pass
    133. class SSD1306_SPI(SSD1306):
    134.     def __init__(self, width, height, spi, dc, res, cs, external_vcc=False):
    135.         self.rate = 10 * 1024 * 1024
    136.         dc.init(dc.OUT, value=0)
    137.         res.init(res.OUT, value=0)
    138.         cs.init(cs.OUT, value=1)
    139.         self.spi = spi
    140.         self.dc = dc
    141.         self.res = res
    142.         self.cs = cs
    143.         self.buffer = bytearray((height // 8) * width)
    144.         self.framebuf = framebuf.FrameBuffer1(self.buffer, width, height)
    145.         super().__init__(width, height, external_vcc)
    147.     def write_cmd(self, cmd):
    148.         self.spi.init(baudrate=self.rate, polarity=0, phase=0)
    149.         self.cs.high()
    150.         self.dc.low()
    151.         self.cs.low()
    152.         self.spi.write(bytearray([cmd]))
    153.         self.cs.high()
    155.     def write_framebuf(self):
    156.         self.spi.init(baudrate=self.rate, polarity=0, phase=0)
    157.         self.cs.high()
    158.         self.dc.high()
    159.         self.cs.low()
    160.         self.spi.write(self.buffer)
    161.         self.cs.high()
    163.     def poweron(self):
    164.         self.res.high()
    165.         time.sleep_ms(1)
    166.         self.res.low()
    167.         time.sleep_ms(10)
    168.         self.res.high()