Lag issue when switching between two interfaces containing PNG images.

[monskate]

I am trying to implement switching between two screen buffers, with frame_buffer1 and frame_buffer2 each sized at half the screen area. The issue is that when switching to a screen containing a PNG image, the refresh occurs in two distinct parts with a noticeable lag between them. How can I resolve this? I am using a 320x240 display driven by an ESP32-S3 (ST7789 controller).

[kdschlosser]

is the connection an SPI connection?

and how are you loading the images?

[monskate]

Thank you for your reply.,My screen is 320*240.My ui.py is ui.py,My screen initialization function is`
class Display:
def init(self):
self.spi = spi_bus
self.i2c = i2c_bus
display_bus = lcd_bus.SPIBus(spi_bus=self.spi,freq=80000000,dc=5,cs=4,)
self.s4s_state = ui.state
BUF_SIZE = 320 * 120 * 2

    buf1 = bytearray(BUF_SIZE)
    buf2 = bytearray(BUF_SIZE)
    self.display = st7789.ST7789(
        data_bus=display_bus,
        display_width=_WIDTH,
        display_height=_HEIGHT,
        frame_buffer1 = buf1,
        frame_buffer2 = buf2,
        backlight_pin=15,
        backlight_on_state=st7789.STATE_HIGH,
        reset_pin=6,
        reset_state=st7789.STATE_LOW,
        color_space=lv.COLOR_FORMAT.RGB565,
        color_byte_order=st7789.BYTE_ORDER_BGR,
        rgb565_byte_swap=True,
    )
    self.display.set_power(True)
    self.display.init()
    touch_dev = i2c.I2C.Device(bus=self.i2c, dev_id=ft6x36.I2C_ADDR, reg_bits=ft6x36.BITS)
    indev = ft6x36.FT6x36(touch_dev,debug = False)
    self.indev = indev
    if not indev.is_calibrated:
        self.display.set_backlight(100)
        indev.calibrate()
    indev.set_virtual_key_callback(self.vk_handler)
    th = task_handler.TaskHandler(duration=5)
    fs_drv = lv.fs_drv_t()
    fs_driver.fs_register(fs_drv, 'S')
    scr = lv.screen_active()
    scr.set_style_bg_color(lv.color_hex(0x000000), 0)
    scr.set_style_bg_opa(255, 0)
    lv.refr_now(None) 
def init(self):
    ui.init_ui()
    lv.refr_now(None)   # 立即刷新一帧
    self.display.set_backlight(100)
def vk_handler(self,key, event):
    if key == "A":
        if event == "pressed":
            button.a_button = True
        elif event == "released":
            button.a_button = False

    elif key == "B":
        if event == "pressed":
            button.b_button = True
        elif event == "released":
            button.b_button = False
def touch_calibration(self):
    self.indev.calibrate()

display = Display()`

[kdschlosser]

ok your single biggest issue is your buffer size. you are making to buffers that are literally the entire size of the display. this doesn't need to be done and it will be a lot faster if you just let the binding code handle the buffers.

also your code is incomplete so I am only going to be able to help with what you have posted.

for starters I recommend not wrapping the initilization code in a class. It's actually wasteful and consumes more memory and provides zero benefit

display_bus = lcd_bus.SPIBus(spi_bus=spi, freq=80000000, dc=5, cs=4)

display = st7789.ST7789(
    data_bus=display_bus,
    display_width=_WIDTH,
    display_height=_HEIGHT,
    backlight_pin=15,
    backlight_on_state=st7789.STATE_HIGH,
    reset_pin=6,
    reset_state=st7789.STATE_LOW,
    color_space=lv.COLOR_FORMAT.RGB565,
    color_byte_order=st7789.BYTE_ORDER_BGR,
    rgb565_byte_swap=True,
)
display.set_power(True)
display.init()
        
touch_dev = i2c.I2C.Device(bus=self.i2c, dev_id=ft6x36.I2C_ADDR, reg_bits=ft6x36.BITS)
indev = ft6x36.FT6x36(touch_dev, debug=False)
display.set_backlight(100)

# you should not need to calibrate that touch panel you are using. Only do the calibration is there is an actual issue otherwise
# the additional matrix math is going to slow down the input,
# if not indev.is_calibrated:
#     indev.calibrate()

# this alters the default behavior to provide more priority to user input.
# it allows for better scrolling and things of that nature where there is a 
# continious stream of user input. 
indev.enable_input_priority()
                    
# I do not recommend changing the default duration. leave it at 33 milliseconds
# otherwise it is going to consume a heck of a lot of processor time  doing actually nothing. 
th = task_handler.TaskHandler()

You have so much stuff mixed in with what you are doing it's hard to nail down exactly where there could be an issue with a slowdown happening.

Start off with the basics like getting the drivers all coded up at the module level without wrapping it in a class. If you want the driver to be accessible from anywhere in your code then put it into a different python source file and import that file in your main.py file at the very top. Then you can import that file anywhere else in your code and the driver will be available for you to access if you need to have access to it. If you don't need access then just put the driver code directly ni your main.py file.

Once you have the drivers all set with a simple slider test and the touch is working then remove the slider test code and add an image widget that loads a PNG file instead. register a callback to that widget so when you click on it it will change the image to a different one. that will give you a clean test bed to see if the PNG loading times are actually the issue. If they are then we can do some things to possibly speed it up depending on what ESP32 you are using. You do have to keep in mind that you are using a super slow connection to send the data to the display so the larger the area being updated on the screen the slower it is going to be to do it. If you have enough available RAM on the ESP32 what we can do is we can load the PNG and decode it to a raw RGB buffer at boot time and changing images will be faster to d because the image is only being decoded a single time. you have to remember that the larger the image the more memory is going to be consumed when doing this.