Micropython with lvgl on the 7 inch viewe UEDX80480070E module

[predgington]

Moved this here from questions as decided this is probably a better place for it.

The UEDX80480070E is a 7 inch touch screen display with a 800x480 resolution and an esp32-S3. Its sort of a supersized CYD. It has 2 usb C ports labelled usb and uart.

Getting lvgl_micropython running on this and working with UI files created in Squareline Studio has been a multiday adventure to the point where I thought I should post this to help anyone considering doing the same. I should say that most of this has been done via the assistance of google gemini so though things appear to work I am in no way an expert in why they work!

Because the touch screen uses the same IO pins as the usb port you need to do some tweaking to disable the USB port (the UART one work fine). Also some of this may be overkill/redundant given gemini's suggestions to try multiple different things in a row as various problems arose.

I checked out from https://github.com/lvgl-micropython/lvgl_micropython. As I needed to edit details in the micropython submodule I went overkill and cloned everything.

git clone --recurse-submodules https://github.com/lvgl-micropython/lvgl_micropython.git

I then made the following edits as suggested by gemini.

Edited lib/micropython/ports/esp32/boards/ESP32_GENERIC_S3/sdkconfig.board and added this:

# Completely disable USB peripherals to free up pins 19 and 20 for Touch I2C
CONFIG_USB_ENABLED=n
CONFIG_USB_CDC_ENABLED=n
CONFIG_TINYUSB_CDC_ENABLED=n
CONFIG_ESP_CONSOLE_USB_CDC=n
CONFIG_ESP_CONSOLE_USB_SERIAL_JTAG=n
CONFIG_USB_OTG_SUPPORTED=n

# Re-route standard console output explicitly back to the physical UART0 hardwa>
CONFIG_ESP_CONSOLE_UART=y
CONFIG_ESP_CONSOLE_UART_NUM=0

# Force the Octal PSRAM data layer to burst at full 80MHz speed
CONFIG_SPIRAM_SPEED_80M=y
CONFIG_SPIRAM_SPEED=80

Edited lib/micropython/ports/esp32/boards/ESP32_GENERIC_S3/mpconfigboard.h

Added:

#define MICROPY_HW_USB_CDC          (0)
#define MICROPY_HW_USB_MAIN_DEV     (0)

Even after these it appeared the firmware included some USB initialisation so I also had to edit lib/micropython/ports/esp32/main.c and comment out the following usb initialisation lines in mp_task:

    usb_serial_jtag_init();
    usb_phy_init();

Note you should only do this is you are using a copy of the archive only for producing firmware for this given board as it will probably mess up firmware for other boards.

After doing that compile using the following command and upload the firmware to the board:

python3 make.py esp32 BOARD=ESP32_GENERIC_S3 BOARD_VARIANT=SPIRAM_OCT DISPLAY=rgb_display INDEV=gt911 --flash-size=16
In Squareline studio create a project. Select Micropython for Unix and other platforms. At the current time the latest, and most compatible, version of lvgl to use is 9.22.

As lvgl_micropython, at the current time, supports 9.4 and the nonstandard way squarespace studio does things there are some tweaks that need to be done. I was hoping not to have to edit the ui files created by squareline studios but that appears to not be feasible.

Firstly you need to create a file called lvgl_patched.py containing the following:

# Save this file strictly as: lvgl_patched.py
# Resolves the persistent background thread task_handler event attribute crash

import sys

# 1. Force load the underlying compiled read-only C binary library
import lvgl as native_lv

# 2. Mirror every single function, constant, and struct from the C core into this file
globals().update({name: getattr(native_lv, name) for name in dir(native_lv)})

# 3. Inject the missing font attribute fallback signature expected by SquareLine Studio
def font_default():
    return native_lv.font_montserrat_14

# Inject the missing fallback default theme initialization method wrapper
def theme_default_init(disp_obj, color_pri, color_sec, dark, font):
    return disp_obj.get_theme()

# 4. The Event Property Proxy
# Translates SquareLine's v9.1 'event.code' dot notations into functional v9.4 'event.get_code()' calls
class EventProxy:
    def __init__(self, real_event):
        self._event = real_event
        
    def __getattr__(self, name):
        if name == 'code':
            return self._event.get_code()
        return getattr(self._event, name)

# 5.  Core Function-Level Callback Interception
# This catches whenever ui.py calls the global functional: lv.obj_add_event_cb(...)
def obj_add_event_cb(obj, event_cb, filter_event, user_data=None):
    def wrapped_callback(e):
        # Wraps the raw incoming C event inside our proxy before forwarding it to ui.py
        return event_cb(EventProxy(e))
    return native_lv.obj_add_event_cb(obj, wrapped_callback, filter_event, user_data)

# 6. DYNAMIC INSTANCE METHOD INTERCEPTOR
# Wraps widget constructor methods to cleanly inject object-oriented event listening hooks
class WidgetWrapper:
    def __init__(self, original_creator):
        self._creator = original_creator

    # Fallback attribute gate for constants (like PALETTE, COLOR, or ALIGN properties)
    def __getattr__(self, name):
        return getattr(self._creator, name)

    def __call__(self, *args, **kwargs):
        # Call the original C widget constructor (e.g. native_lv.button)
        widget_instance = self._creator(*args, **kwargs)
        
        if widget_instance is not None:
            # Inject custom object-oriented method straight onto this specific widget instance.
            # This catches whenever ui.py hooks up a listener using: widget.add_event_cb(...)
            def instance_add_event_cb(event_cb, filter_event, user_data=None):
                def wrapped_callback(e):
                    return event_cb(EventProxy(e))
                return native_lv.obj_add_event_cb(widget_instance, wrapped_callback, filter_event, user_data)
            
            try:
                setattr(widget_instance, 'add_event_cb', instance_add_event_cb)
            except AttributeError:
                pass
                
        return widget_instance

# Scan through and safely wrap only specific layout widget constructor profiles
for name in dir(native_lv):
    attr = getattr(native_lv, name)
    if name in ['button', 'label', 'image', 'dropdown', 'slider', 'switch', 'table', 'textarea', 'keyboard', 'obj', 'tabview', 'arc', 'bar', 'checkbox', 'roller', 'scale', 'spinbox', 'tileview']:
        globals()[name] = WidgetWrapper(attr)

This is mainly to reduce the editing of the ui files to a minimum.

In the ui.py file created in squareline studio you need to change the initial lvgl import so:
import lvgl as lv becomes
import lvgl_patched as lv
Then in any call back you have created from button etc you need to change:

event = event_struct.code to
event = event_struct.get_code()
Finally you need a main.py. This example included one example of defining a callback for a button press.

import machine
import time
import sys
import lcd_bus
import rgb_display_framework
import gt911
import i2c
import task_handler
import lvgl as lv  # Clean, direct native import

# Protect global instances from the MicroPython Garbage Collector (GC)
th_instance = None
touch_device = None

# =========================================================================
# THE CUSTOM EVENT FUNCTION CALLED BY SQUARELINE STUDIO
# =========================================================================
def button_event_handler(event_struct):
    print("⚡ Hardware Event Caught by main.py!")     
    return

# =========================================================================
# 1. PHYSICAL HARDWARE WAKEUP PULSE SEQUENCE
# =========================================================================
print("Executing clean GT911 Hardware Wakeup Sequence...")
rst_pin = machine.Pin(38, machine.Pin.OUT)
int_pin = machine.Pin(18, machine.Pin.OUT)

rst_pin.value(0)
int_pin.value(0)
time.sleep_ms(20)

int_pin.value(0)
time.sleep_ms(2)
rst_pin.value(1)
time.sleep_ms(10)

int_pin = machine.Pin(18, machine.Pin.IN)
print("GT911 hardware awake and locked to address 0x5D.")

# =========================================================================
# 2. INITIALISE DISPLAY ENGINE
# =========================================================================
lv.init()

backlight = machine.Pin(2, machine.Pin.OUT)
backlight.on()

bus = lcd_bus.RGBBus(
    hsync=39, vsync=41, de=40, pclk=42, freq=14000000,
    hsync_front_porch=40, hsync_back_porch=88, hsync_pulse_width=48,
    vsync_front_porch=13, vsync_back_porch=32, vsync_pulse_width=3,
    pclk_active_low=True, 
    data0=45, data1=48, data2=47, data3=21, data4=14,  # Red
    data5=5,  data6=6,  data7=7,  data8=15, data9=16, data10=4, # Green
    data11=8, data12=3, data13=46, data14=9, data15=1   # Blue
)

disp = rgb_display_framework.RGBDisplayDriver(
    data_bus=bus, 
    display_width=800, 
    display_height=480,
    color_space=lv.COLOR_FORMAT.RGB565,
    rgb565_byte_swap=True
)
disp.init()
disp.set_power(True)

print("Waiting for display driver stabilization...")
time.sleep_ms(200)

# =========================================================================
# 3. INITIALISE TOUCH CONTROLLER
# =========================================================================
i2c_bus = i2c.I2C.Bus(host=0, sda=19, scl=20, freq=400000)
touch_i2c_dev = i2c.I2C.Device(i2c_bus, 0x5D, 16) 

touch_device = gt911.GT911(
    touch_i2c_dev,
    reset_pin=None,
    interrupt_pin=None
)

if hasattr(touch_device, '_indev') and touch_device._indev is not None:
    touch_device._indev.set_display(disp)
elif hasattr(touch_device, 'set_display'):
    touch_device.set_display(disp)

print("Display and touch driver engine successfully cross-linked.")

# =========================================================================
# 4. START AUTOMATED EVENT TIMER RUNTIME LAYER
# =========================================================================
th_instance = task_handler.TaskHandler()
print("Asynchronous tracking background loop running.")

# =========================================================================
# 5. IMPORT AND BOOTSTRAP SQUARELINE STUDIO UI WITH FUNCTION INJECTION
# =========================================================================
print("Loading SquareLine Studio layout files...")

import ui  

# CRITICAL FIX: Inject our custom Python handler into SquareLine's namespace
# This tells ui.py exactly where to route the button_event_handler call when pressed!
ui.button_event_handler= button_event_handler

print("Executing layout initialisation...")
if hasattr(ui, 'ui_init'):
    ui.ui_init()
elif hasattr(ui, 'init'):
    ui.init()

# Find the exported screen layer and force load it onto the canvas
target_screen = None
for attr_name in dir(ui):
    if attr_name.startswith("ui_") and "Screen" in attr_name:
        possible_screen = getattr(ui, attr_name)
        if isinstance(possible_screen, lv.obj):
            target_screen = possible_screen
            break

if target_screen is not None:
    print(f"Loading screen view: '{attr_name}'...")
    lv.screen_load(target_screen)
else:
    if hasattr(ui, 'ui_Screen1'):
        lv.screen_load(ui.ui_Screen1)
    elif hasattr(ui, 'Screen1'):
        lv.screen_load(ui.Screen1)

print("SquareLine Studio UI running successfully!")

# =========================================================================
# 6. APPLICATION KEEP-ALIVE STATE LOOP
# =========================================================================
print("\nEntering infinite application run state. Screen interaction active.")
while True:
    time.sleep_ms(1000)

I have only just reached this point and I am sure that more issues will raise their heads but hopefully this helps someone.