kmk_firmware/kmk/extensions/peg_oledDisplay.py

import busio
import gc

import adafruit_displayio_ssd1306
import displayio
import terminalio
from adafruit_display_text import label

from kmk.extensions import Extension


class oled(Extension):
    def __init__(
        self,
        board,
        views,
        toDisplay: str = 'TXT',
        oWidth: int = 128,
        oHeight: int = 32,
        flip: bool = False,
    ):
        displayio.release_displays()
        self._views = views
        self._toDisplay = toDisplay
        i2c = busio.I2C(board.SCL, board.SDA)
        self.width = (oWidth,)
        self.height = (oHeight,)
        self.rotation = 180 if flip else 0
        self._display = adafruit_displayio_ssd1306.SSD1306(
            displayio.I2CDisplay(i2c, device_address=0x3C),
            width=oWidth,
            height=oHeight,
            rotation=self.rotation,
        )
        self._prevLayers = 0
        gc.collect()

    def returnCurrectRenderText(self, layer, singleView):
        # for now we only have static things and react to layers. But when we react to battery % and wpm we can handle the logic here
        if singleView[0] == 'STATIC':
            return singleView[1][0]
        if singleView[0] == 'LAYER':
            return singleView[1][layer]

    def renderOledTextLayer(self, layer):
        splash = displayio.Group()
        self._display.show(splash)
        splash.append(
            label.Label(
                terminalio.FONT,
                text=self.returnCurrectRenderText(layer, self._views[0]),
                color=0xFFFFFF,
                x=0,
                y=10,
            )
        )
        splash.append(
            label.Label(
                terminalio.FONT,
                text=self.returnCurrectRenderText(layer, self._views[1]),
                color=0xFFFFFF,
                x=64,
                y=10,
            )
        )
        splash.append(
            label.Label(
                terminalio.FONT,
                text=self.returnCurrectRenderText(layer, self._views[2]),
                color=0xFFFFFF,
                x=0,
                y=25,
            )
        )
        splash.append(
            label.Label(
                terminalio.FONT,
                text=self.returnCurrectRenderText(layer, self._views[3]),
                color=0xFFFFFF,
                x=64,
                y=25,
            )
        )
        gc.collect()

    def renderOledImgLayer(self, layer):
        splash = displayio.Group()
        self._display.show(splash)
        odb = displayio.OnDiskBitmap(
            '/' + self.returnCurrectRenderText(layer, self._views[0])
        )
        image = displayio.TileGrid(odb, pixel_shader=odb.pixel_shader)
        splash.append(image)
        gc.collect()

    def updateOLED(self, sandbox):
        if self._toDisplay == 'TXT':
            self.renderOledTextLayer(sandbox.active_layers[0])
        if self._toDisplay == 'IMG':
            self.renderOledImgLayer(sandbox.active_layers[0])
        gc.collect()

    def on_runtime_enable(self, sandbox):
        return

    def on_runtime_disable(self, sandbox):
        return

    def during_bootup(self, sandbox):
        self.renderOledImgLayer(0)
        return

    def before_matrix_scan(self, sandbox):
        if sandbox.active_layers[0] != self._prevLayers:
            self._prevLayers = sandbox.active_layers[0]
            self.updateOLED(sandbox)
        return

    def after_matrix_scan(self, sandbox):

        return

    def before_hid_send(self, sandbox):
        return

    def after_hid_send(self, sandbox):
        return

    def on_powersave_enable(self, sandbox):
        return

    def on_powersave_disable(self, sandbox):
        return