Add support for ST77916.

[Vincent1-python]

Add support for ST77916, because I have been unable to light up the initialization list with ESPIDF, only the backlight is on.

[Vincent1-python]

https://github.com/johnxx/lvgl_micropython/blob/jx/waveshare-esp32-s3-lcd-1.85/api_drivers/common_api_drivers/display/st77916/st77916.py
https://github.com/johnxx/lvgl_micropython/blob/jx/waveshare-esp32-s3-lcd-1.85/api_drivers/common_api_drivers/display/st77916/_st77916_init.py
Found it, please add it. @kdschlosser

[kdschlosser]

Your drivers are not going to work properly.

The parameters you are setting are not going to be passed correctly and they are not going to be passed necessarily in the correct order either.

doing this...

    (0xE0, {0x70, 0x09, 0x12, 0x0C, 0x0B, 0x27, 0x38, 0x54, 0x4E, 0x19, 0x15, 0x15, 0x2C, 0x2F}, 14, 0),

is the same thing as doing this..

    (0xE0, set(0x70, 0x09, 0x12, 0x0C, 0x0B, 0x27, 0x38, 0x54, 0x4E, 0x19, 0x15, 0x15, 0x2C, 0x2F), 14, 0),

which is actually this...

    (0xE0, set(0x70, 0x09, 0x12, 0x0C, 0x0B, 0x27, 0x38, 0x54, 0x4E, 0x19, 0x15, 0x2C, 0x2F), 14, 0),

If you are unfamiliar with what a python set is I recommend you do some reading about it.

The other thing is by declaring the init commands and parameters at the module level causes a lot of memory to be used that stays resident the entire time the ESP32 is running. There is a reason why the functions are formatted like so...

Click to see code!

# Copyright (c) 2024 - 2025 Kevin G. Schlosser

import time
from micropython import const  # NOQA

import lvgl as lv  # NOQA
import lcd_bus


_SWRESET = const(0x01)
_SLPOUT = const(0x11)
_MADCTL = const(0x36)
_COLMOD = const(0x3A)
_PORCTRL = const(0xB2)
_GCTRL = const(0xB7)
_VCOMS = const(0xBB)
_LCMCTRL = const(0xC0)
_VDVVRHEN = const(0xC2)
_VRHS = const(0xC3)
_VDVSET = const(0xC4)
_FRCTR2 = const(0xC6)
_PWCTRL1 = const(0xD0)
_INVON = const(0x21)
_CASET = const(0x2A)
_RASET = const(0x2B)
_PGC = const(0xE0)
_NGC = const(0xE1)
_DISPON = const(0x29)
_NORON = const(0x13)

_RAMCTRL = const(0xB0)
_RGB565SWAP = const(0x08)


def init(self):
    param_buf = bytearray(14)
    param_mv = memoryview(param_buf)

    self.set_params(_SWRESET)

    time.sleep_ms(120)  # NOQA

    self.set_params(_SLPOUT)

    time.sleep_ms(120)  # NOQA

    self.set_params(_NORON)

    param_buf[0] = (
        self._madctl(
            self._color_byte_order,
            self._ORIENTATION_TABLE  # NOQA
        )
    )
    self.set_params(_MADCTL, param_mv[:1])

    param_buf[0] = 0x0A
    param_buf[1] = 0x82
    self.set_params(0xB6, param_mv[:2])

    # sets swapping the bytes at the hardware level.

    if (
        self._rgb565_byte_swap and
        isinstance(self._data_bus, lcd_bus.I80Bus) and
        self._data_bus.get_lane_count() == 8
    ):
        param_buf[0] = 0x00
        param_buf[1] = 0xF0 | _RGB565SWAP
        self.set_params(_RAMCTRL, param_mv[:2])

    color_size = lv.color_format_get_size(self._color_space)
    if color_size == 2:  # NOQA
        pixel_format = 0x55
    elif color_size == 3:
        pixel_format = 0x77
    else:
        raise RuntimeError(
            f'{self.__class__.__name__} IC only supports '
            'lv.COLOR_FORMAT.RGB565 or lv.COLOR_FORMAT.RGB888'
        )

    param_buf[0] = pixel_format
    self.set_params(_COLMOD, param_mv[:1])

    time.sleep_ms(10)  # NOQA

    param_buf[0] = 0x0C
    param_buf[1] = 0x0C
    param_buf[2] = 0x00
    param_buf[3] = 0x33
    param_buf[4] = 0x33
    self.set_params(_PORCTRL, param_mv[:5])

    param_buf[0] = 0x35
    self.set_params(_GCTRL, param_mv[:1])

    param_buf[0] = 0x28
    self.set_params(_VCOMS, param_mv[:1])

    param_buf[0] = 0x0C
    self.set_params(_LCMCTRL, param_mv[:1])

    param_buf[0] = 0x01
    self.set_params(_VDVVRHEN, param_mv[:1])

    param_buf[0] = 0x13
    self.set_params(_VRHS, param_mv[:1])

    param_buf[0] = 0x20
    self.set_params(_VDVSET, param_mv[:1])

    param_buf[0] = 0x0F
    self.set_params(_FRCTR2, param_mv[:1])

    param_buf[0] = 0xA4
    param_buf[1] = 0xA1
    self.set_params(_PWCTRL1, param_mv[:2])

    param_buf[0] = 0xD0
    param_buf[1] = 0x00
    param_buf[2] = 0x02
    param_buf[3] = 0x07
    param_buf[4] = 0x0A
    param_buf[5] = 0x28
    param_buf[6] = 0x32
    param_buf[7] = 0x44
    param_buf[8] = 0x42
    param_buf[9] = 0x06
    param_buf[10] = 0x0E
    param_buf[11] = 0x12
    param_buf[12] = 0x14
    param_buf[13] = 0x17
    self.set_params(_PGC, param_mv[:14])

    param_buf[0] = 0xD0
    param_buf[1] = 0x00
    param_buf[2] = 0x02
    param_buf[3] = 0x07
    param_buf[4] = 0x0A
    param_buf[5] = 0x28
    param_buf[6] = 0x31
    param_buf[7] = 0x54
    param_buf[8] = 0x47
    param_buf[9] = 0x0E
    param_buf[10] = 0x1C
    param_buf[11] = 0x17
    param_buf[12] = 0x1B
    param_buf[13] = 0x1E
    self.set_params(_NGC, param_mv[:14])

    self.set_params(_INVON)

    param_buf[0] = 0x00
    param_buf[1] = 0x00
    param_buf[2] = (self.display_width >> 8) & 0xFF
    param_buf[3] = self.display_width & 0xFF

    self.set_params(_CASET, param_mv[:4])

    # Page addresses
    param_buf[0] = 0x00
    param_buf[1] = 0x00
    param_buf[2] = (self.display_height >> 8) & 0xFF
    param_buf[3] = self.display_height & 0xFF

    self.set_params(_RASET, param_mv[:4])

    self.set_params(_DISPON)
    time.sleep_ms(120)  # NOQA

    self.set_params(_SLPOUT)
    time.sleep_ms(120)  # NOQA

The reason why it is formatted in this manner is because the allocation occurs on the stack so when the function exits running any memory consumed by the function gets released. So there is not a large amount of data that is just sitting there that only gets used a single time consuming memory that is able to be sued for other things.

the second is for readability. You can clearly see what is being sent and when it is being sent.

lastly, it makes it easier to debug an issue with the driver.

using const requires that the variable that is being set begins with an underscore (_) in order for the variable to behave like a C style macro (#define {NUM}). The purpose of it is to save memory and to also at the same time provide some insight as to what the value actually is for by being able to associate a name to that specific value. It works as a simple replacement where the variable name that is being used gets replaced with the value that has been set to that variable.

here is an example.

from micropython import const

_SOME_VAR = 10

def some_function(some_param=_SOME_VAR):
    ...

the code above ends up getting compiled as

def some_function(some_param=10):
    ...