Setting up LVGL+Micropython on ESP32-S3-Touch-LCD-4.3 from WaveShare

[Type-32]

This here is the board I have and are referencing: ESP32-S3-Touch-LCD-4.3 from WaveShare

I modified the python code that @kdschlosser provided in #138 and flashed it into my board.

import time
import network

def connect_wifi(ssid, password):
    wlan = network.WLAN(network.STA_IF)
    wlan.active(True)
    if not wlan.isconnected():
        print('Connecting to WiFi...')
        wlan.connect(ssid, password)
        while not wlan.isconnected():
            print('WiFi is not connected...', wlan.ifconfig())
            time.sleep(1)
    print('WiFi connected:', wlan.ifconfig())

from micropython import const  # NOQA
from i2c import I2C
import gt911
import lcd_bus
import task_handler
import lvgl as lv  # NOQA
import rgb_display


_WIDTH = const(800)
_HEIGHT = const(480)

_BUFFER_SIZE = const(768000)

_CTP_SCL = const(9)
_CTP_SDA = const(8)
_CTP_IRQ = const(4)

_SD_MOSI = const(11)
_SD_SCK = const(12)
_SD_MISO = const(13)

_LCD_FREQ = const(13000000)
_PCLK_ACTIVE_NEG = const(0)

_HSYNC_PULSE_WIDTH = const(10)
_HSYNC_BACK_PORCH = const(10)
_HSYNC_FRONT_PORCH = const(10)

_VSYNC_PULSE_WIDTH = const(10)
_VSYNC_BACK_PORCH = const(10)
_VSYNC_FRONT_PORCH = const(20)

_PCLK = const(7)
_HSYNC = const(46)
_VSYNC = const(3)
_DE = const(5)
_DISP = None
_BCKL = None
_DRST = None


I2C_BUS = I2C.Bus(
    host=1,
    scl=_CTP_SCL,
    sda=_CTP_SDA,
    freq=400000,
    use_locks=False
)

TOUCH_DEVICE = I2C.Device(
    I2C_BUS,
    dev_id=gt911.I2C_ADDR,
    reg_bits=gt911.BITS
)

_DATA15 = const(10)  # B7
_DATA14 = const(17)  # B6
_DATA13 = const(18)  # B5
_DATA12 = const(38)  # B4
_DATA11 = const(14)  # B3
_DATA10 = const(21)  # G7
_DATA9 = const(47)  # G6
_DATA8 = const(48)  # G5
_DATA7 = const(45)  # G4
_DATA6 = const(0)  # G3
_DATA5 = const(39)  # G2
_DATA4 = const(40)  # R7
_DATA3 = const(41)  # R6
_DATA2 = const(42)  # R5
_DATA1 = const(2)  # R4
_DATA0 = const(1)  # R3


bus = lcd_bus.RGBBus(
    hsync=_HSYNC,
    vsync=_VSYNC,
    de=_DE,
    pclk=_PCLK,
    disp=1,
    data0=_DATA0,
    data1=_DATA1,
    data2=_DATA2,
    data3=_DATA3,
    data4=_DATA4,
    data5=_DATA5,
    data6=_DATA6,
    data7=_DATA7,
    # I had to remove the following lines because it keeps giving me an error when running the program, excess params
    # data8=_DATA8,
    # data9=_DATA9,
    # data10=_DATA10,
    # data11=_DATA11,
    # data12=_DATA12,
    # data13=_DATA13,
    # data14=_DATA14,
    # data15=_DATA15,
    # data_pins=(
    #     _DATA0,
    #     _DATA1,
    #     _DATA2,
    #     _DATA3,
    #     _DATA4,
    #     _DATA5,
    #     _DATA6,
    #     _DATA7,
    #     _DATA8,
    #     _DATA9,
    #     _DATA10,
    #     _DATA11,
    #     _DATA12,
    #     _DATA13,
    #     _DATA14,
    #     _DATA15
    # ),
    freq=_LCD_FREQ,
    hsync_front_porch=_HSYNC_FRONT_PORCH,
    hsync_back_porch=_HSYNC_BACK_PORCH,
    hsync_pulse_width=_HSYNC_PULSE_WIDTH,
    hsync_idle_low=False,
    vsync_front_porch=_VSYNC_FRONT_PORCH,
    vsync_back_porch=_VSYNC_BACK_PORCH,
    vsync_pulse_width=_VSYNC_PULSE_WIDTH,
    vsync_idle_low=False,
    de_idle_high=False,
    pclk_idle_high=False,
    pclk_active_low=_PCLK_ACTIVE_NEG,
)


buf = bus.allocate_framebuffer(_BUFFER_SIZE, lcd_bus.MEMORY_SPIRAM)

display = rgb_display.RGBDisplay(
    data_bus=bus,
    display_width=_WIDTH,
    display_height=_HEIGHT,
    frame_buffer1=buf,
    frame_buffer2=None,
    color_space=lv.COLOR_FORMAT.RGB565,
    rgb565_byte_swap=True
)

display.set_power(True)
display.init()
display.set_backlight(100)
indev = gt911.GT911(TOUCH_DEVICE)

# display.set_rotation(lv.DISPLAY_ROTATION._90)  # NOQA

lv.init()
scrn = lv.obj()

btn = lv.button(scrn)
btn.center()

scrn.set_style_bg_color(lv.color_hex(0x000000), 0)
lv.screen_load(scrn)
lv.screen_active()

task_handler.TaskHandler()

After flashing it, the board screen glows white (which is better than showing nothing since the last five days I've been trying to get it to show something other than nothing). But after flashing the python program on to it, I can't connect the REPL anymore, including flashing any other python code on to the board.

Am I doing something wrong here, or is there something weird with the code I modified...? I honestly am a complete amateur to this type of development and I would appreciate any help (scolding also works). I'd also appreciate if there's other resources I can reference off of.

[kdschlosser]

I just recently made some changes that I am going to revert. I have to mess around with testing them locally to find out why they are not working properly.

[Type-32]

so it's not an issue with the code?

[Type-32]

Status update: i uncommented these lines:

    # data8=_DATA8,
    # data9=_DATA9,
    # data10=_DATA10,
    # data11=_DATA11,
    # data12=_DATA12,
    # data13=_DATA13,
    # data14=_DATA14,
    # data15=_DATA15,

and now it looks like this

Still can't access the REPL after flashing the code as well.

[kdschlosser]

Plug your USB cable into the other USB port. That is the reason why you are not able to access the REPL.

[Type-32]

I tried UART as well, which doesn't work

[kdschlosser]

have you tried using vanilla MicroPython to see if you get a REPL??

[Type-32]

Vanilla MicroPython works fine. I also tried the build command you gave at the next comment.
output.txt

I've updated the repo on my end and the build command failed.

[Type-32]

Update: I tried using my own build command but also failed. I think it's something with the rgb_bus.c.

[kdschlosser]

OK the RGB Bus is fixed.

[kdschlosser]

This is the build command I use for that display...

python3 make.py esp32 BOARD=ESP32_GENERIC_S3 BOARD_VARIANT=SPIRAM_OCT --flash-size=8 DISPLAY=rgb_display INDEV=gt911 CONFIG_FREERTOS_HZ=1000 CONFIG_ESP_DEFAULT_CPU_FREQ_MHZ_240=y CONFIG_ESPTOOLPY_FLASHMODE_QIO=y CONFIG_ESPTOOLPY_FLASHFREQ_120M=y CONFIG_IDF_EXPERIMENTAL_FEATURES=y and CONFIG_SPIRAM_SPEED_120M=y CONFIG_SPIRAM_FETCH_INSTRUCTIONS=y CONFIG_SPIRAM_RODATA=y CONFIG_ESP32S3_DATA_CACHE_LINE_64B=y CONFIG_COMPILER_OPTIMIZATION_PERF=y

and this is the code that I use to initialize the display...

from micropython import const  # NOQA
from i2c import I2C
import gt911
import lcd_bus
import task_handler
import lvgl as lv  # NOQA
import rgb_display


_WIDTH = const(800)
_HEIGHT = const(480)

_BUFFER_SIZE = const(76800)

_CTP_SCL = const(9)
_CTP_SDA = const(8)
_CTP_IRQ = const(4)

_SD_MOSI = const(11)
_SD_SCK = const(12)
_SD_MISO = const(13)

_LCD_FREQ = const(13000000)
_PCLK_ACTIVE_NEG = const(0)

_HSYNC_PULSE_WIDTH = const(10)
_HSYNC_BACK_PORCH = const(10)
_HSYNC_FRONT_PORCH = const(10)

_VSYNC_PULSE_WIDTH = const(10)
_VSYNC_BACK_PORCH = const(10)
_VSYNC_FRONT_PORCH = const(20)

_PCLK = const(7)
_HSYNC = const(46)
_VSYNC = const(3)
_DE = const(5)
_DISP = None
_BCKL = None
_DRST = None


I2C_BUS = I2C.Bus(
    host=1,
    scl=_CTP_SCL,
    sda=_CTP_SDA,
    freq=400000,
    use_locks=False
)

TOUCH_DEVICE = I2C.Device(
    I2C_BUS,
    dev_id=gt911.I2C_ADDR,
    reg_bits=gt911.BITS
)

_DATA15 = const(10)  # B7
_DATA14 = const(17)  # B6
_DATA13 = const(18)  # B5
_DATA12 = const(38)  # B4
_DATA11 = const(14)  # B3
_DATA10 = const(21)  # G7
_DATA9 = const(47)  # G6
_DATA8 = const(48)  # G5
_DATA7 = const(45)  # G4
_DATA6 = const(0)  # G3
_DATA5 = const(39)  # G2
_DATA4 = const(40)  # R7
_DATA3 = const(41)  # R6
_DATA2 = const(42)  # R5
_DATA1 = const(2)  # R4
_DATA0 = const(1)  # R3


bus = lcd_bus.RGBBus(
    hsync=_HSYNC,
    vsync=_VSYNC,
    de=_DE,
    pclk=_PCLK,
    data0=_DATA0,
    data1=_DATA1,
    data2=_DATA2,
    data3=_DATA3,
    data4=_DATA4,
    data5=_DATA5,
    data6=_DATA6,
    data7=_DATA7,
    data8= _DATA8,
    data9=_DATA9,
    data10= _DATA10,
    data11= _DATA11,
    data12=_DATA12,
    data13=_DATA13,
    data14=_DATA14,
    data15=_DATA15,
    freq=_LCD_FREQ,
    hsync_front_porch=_HSYNC_FRONT_PORCH,
    hsync_back_porch=_HSYNC_BACK_PORCH,
    hsync_pulse_width=_HSYNC_PULSE_WIDTH,
    hsync_idle_low=False,
    vsync_front_porch=_VSYNC_FRONT_PORCH,
    vsync_back_porch=_VSYNC_BACK_PORCH,
    vsync_pulse_width=_VSYNC_PULSE_WIDTH,
    vsync_idle_low=False,
    de_idle_high=False,
    pclk_idle_high=False,
    pclk_active_low=_PCLK_ACTIVE_NEG,
)


buf1 = bus.allocate_framebuffer(_BUFFER_SIZE, lcd_bus.MEMORY_SPIRAM)
buf2 = bus.allocate_framebuffer(_BUFFER_SIZE, lcd_bus.MEMORY_SPIRAM)

display = rgb_display.RGBDisplay(
    data_bus=bus,
    display_width=_WIDTH,
    display_height=_HEIGHT,
    frame_buffer1=buf1,
    frame_buffer2=buf2,
    color_space=lv.COLOR_FORMAT.RGB565,
    rgb565_byte_swap=True
)

display.set_power(True)
display.init()
display.set_backlight(100)
indev = gt911.GT911(TOUCH_DEVICE)


if indev.hw_size != (_WIDTH, _HEIGHT):
    fw_config = indev.firmware_config
    fw_config.width = _WIDTH
    fw_config.height = _HEIGHT
    fw_config.save()

    del fw_config
    

# display.set_rotation(lv.DISPLAY_ROTATION._90)  # NOQA

scrn = lv.screen_active()
scrn.set_style_bg_color(lv.color_hex(0x000000), 0)

slider = lv.slider(scrn)
slider.center()

task_handler.TaskHandler()

[kdschlosser]

That build command overclocks the SPI bus for the flash and for the SPIRAM to get some additional speed out of it so the display updates faster. The resolution of the display is pretty high and that is going to take a while for it to update....

[kdschlosser]

ooops. I have to edit that code. There is a mistake in it... I will fix it now...

EDIT

All fixed.

[kdschlosser]

I would leave the WiFi out for the time being. Once the display is up and running then worry about adding the WiFi back in.

[Type-32]

The display is running successfully. I can now see a slider.

Is there extra documentation for LVGL+MicroPython for V9.x?

[kdschlosser]

I am working on generating documentation. and you are correct it is not easy to do.

I did write a script at onme point that enumerated the entire LVGL module and it spat out the complete API, If you give me 15 minutes I can write it again and at least provide you with a picture of what the API looks like.

[Type-32]

I'd be more grateful if that can be a thing, but then again, I'm already grateful for the existence of this project. This is some amazing work. :) <3

[kdschlosser]

api.txt

Now the function parameters are not in that and neither are the fields for structures. Unfortunately there is only so much I am able to traverse through to collect the information. Al least you will get a basic understand of the layout of things.

[kdschlosser]

I do have a card inserted though... maybe it's loose or something? I'll try later.

The card readers can be real fickle about the card you are using. While the slot is called an SD Card slot you need to be using MMC cards. SD cards support encryption which the SPI (MMC) variant doesn't. You can use an MMC card in an SD card slot but you cannot use an SD card in an MMC slot. The slot you are using is an MMC slot.

[Type-32]

that's good to know. Thank you for the elaboration :)

[kdschlosser]

I found a better way of generating the code that is used in the binding and at some point I will write the generator code over again. The way it has been done is not the most efficient...

[Type-32]

How do I rotate the UI display from a horizontal display to a vertical display?

[Type-32]

Found a great tool for making LVGL V9.x UI and exporting as MicroPython: Squareline Studio
Squareline Studio does work to some extent, but most of the times the stuff it generates would throw weird errors. If you must use the software, maybe try designing the UI and then export it in python, then copy the parts that are usable to your test code.

At least this is my workflow for now, which I know is not the best (but it's the only way I currently know) and am sure will change in the future.

[Type-32]

Okay... this may need some tweaking...

A fatal error occurred. The crash dump printed below may be used to help
determine what caused it. If you are not already running the most recent
version of MicroPython, consider upgrading. New versions often fix bugs.

To learn more about how to debug and/or report this crash visit the wiki
page at: https://github.com/micropython/micropython/wiki/ESP32-debugging

LVGL MPY version : 1.23.0 on 2024-10-07
IDF version : v5.2
Machine     : Generic ESP32S3 module with Octal-SPIRAM with ESP32S3

Guru Meditation Error: Core  1 panic'ed (LoadProhibited). Exception was unhandled.

Core  1 register dump:
PC      : 0x42081926  PS      : 0x00060d30  A0      : 0x820816fd  A1      : 0x3fcbe8f0  
A2      : 0x3c253550  A3      : 0x3c1d49d4  A4      : 0x00000005  A5      : 0x3c253532  
A6      : 0x000000f4  A7      : 0x3fcbe8f0  A8      : 0x81165115  A9      : 0x3c1d49d4  
A10     : 0x3c253550  A11     : 0x00000030  A12     : 0x3fca62d8  A13     : 0x3fca61ac  
A14     : 0x00000263  A15     : 0x3fcbe8c0  SAR     : 0x0000001e  EXCCAUSE: 0x0000001c  
EXCVADDR: 0x81165151  LBEG    : 0x40056f08  LEND    : 0x40056f12  LCOUNT  : 0x00000000  


Backtrace: 0x42081923:0x3fcbe8f0 0x420816fa:0x3fcbe920 0x42029e73:0x3fcbe980 0x420060f5:0x3fcbe9d0 0x420b85bd:0x3fcbea10 0x420b8685:0x3fcbea30 0x40379b56:0x3fcbea50 0x420b1a27:0x3fcbeaf0 0x420b85bd:0x3fcbeb60 0x420b862a:0x3fcbeb80 0x420d9079:0x3fcbebc0 0x420d9206:0x3fcbebf0 0x420b8704:0x3fcbece0 0x40379de3:0x3fcbed20 0x420b1a27:0x3fcbedc0 0x420b85bd:0x3fcbee10 0x420b862a:0x3fcbee30 0x420d9079:0x3fcbee70 0x420d9206:0x3fcbeea0 0x420b8704:0x3fcbef90 0x40379de3:0x3fcbefd0 0x420b1a27:0x3fcbf070 0x420b85bd:0x3fcbf0c0 0x420b85d2:0x3fcbf0e0 0x420c6557:0x3fcbf100 0x420c684c:0x3fcbf190 0x420cdd48:0x3fcbf1d0




ELF file SHA256: 34df4ed8d

Rebooting...
���ESP-ROM:esp32s3-20210327
Build:Mar 27 2021
rst:0xc (RTC_SW_CPU_RST),boot:0x8 (SPI_FAST_FLASH_BOOT)
Saved PC:0x40382df6
SPIWP:0xee
mode:DIO, clock div:1
load:0x3fce3820,len:0x105c
load:0x403c9700,len:0x4
load:0x403c9704,len:0xbd8
load:0x403cc700,len:0x2e30
entry 0x403c989c
Touch Product id: 911
Touch Firmware version: 0x1060
Touch Vendor id: 0x0
Touch resolution: width=800, height=480
LVGL MicroPython 1.23.0 on 2024-10-07; Generic ESP32S3 module with Octal-SPIRAM with ESP32S3
Type "help()" for more information.

this happens when I try to run the code generated by squareline studio.
osui.py.txt
ui_images.py.txt
ui.py.txt

I have no idea what this means but I'll try to tweak this thing until it works.

[Type-32]

I moved some parts of the ui.py into osui.py.

import lvgl as lv


# import ui
# import ui_images

dispp = lv.display_get_default()
theme = lv.theme_default_init(dispp, lv.palette_main(lv.PALETTE.BLUE), lv.palette_main(lv.PALETTE.RED), False, lv.font_default())
# dispp.set_theme(theme)

_ui_comp_table = {}
_ui_comp_prev = None
_ui_name_prev = None
_ui_child_prev = None
_ui_comp_table.clear()

def ui_OptionsModal_create(comp_parent):
    cui_OptionsModal = lv.obj(comp_parent)
    cui_OptionsModal.set_width(lv.pct(60))
    cui_OptionsModal.set_height(lv.SIZE_CONTENT)   # 50
    cui_OptionsModal.set_align( lv.ALIGN.CENTER)
    cui_OptionsModal.set_flex_flow(lv.FLEX_FLOW.COLUMN)
    cui_OptionsModal.set_flex_align(lv.FLEX_ALIGN.START, lv.FLEX_ALIGN.START, lv.FLEX_ALIGN.START)
    SetFlag(cui_OptionsModal, lv.obj.FLAG.SCROLLABLE, False)
    cui_ModalTitle = lv.label(cui_OptionsModal)
    cui_ModalTitle.set_text("ModalTitle")
    cui_ModalTitle.set_width(lv.pct(100))
    cui_ModalTitle.set_height(lv.SIZE_CONTENT)   # 1
    cui_ModalTitle.set_style_text_color(lv.color_hex(0x4C4C4C), lv.PART.MAIN | lv.STATE.DEFAULT )
    cui_ModalTitle.set_style_text_opa(255, lv.PART.MAIN| lv.STATE.DEFAULT )
    cui_ModalTitle.set_style_text_letter_space( 1, lv.PART.MAIN | lv.STATE.DEFAULT )
    cui_ModalTitle.set_style_text_line_space( 0, lv.PART.MAIN | lv.STATE.DEFAULT )
    # cui_ModalTitle.set_style_text_font( lv.font_montserrat_18, lv.PART.MAIN | lv.STATE.DEFAULT )
    cui_ModalContent = lv.label(cui_OptionsModal)
    cui_ModalContent.set_text("text")
    cui_ModalContent.set_width(lv.pct(100))
    cui_ModalContent.set_height(lv.SIZE_CONTENT)   # 1
    cui_ModalContent.set_align( lv.ALIGN.CENTER)
    cui_Options = lv.obj(cui_OptionsModal)
    cui_Options.remove_style_all()
    cui_Options.set_height(40)
    cui_Options.set_width(lv.pct(100))
    cui_Options.set_align( lv.ALIGN.CENTER)
    cui_Options.set_flex_flow(lv.FLEX_FLOW.ROW)
    cui_Options.set_flex_align(lv.FLEX_ALIGN.SPACE_EVENLY, lv.FLEX_ALIGN.CENTER, lv.FLEX_ALIGN.CENTER)
    SetFlag(cui_Options, lv.obj.FLAG.CLICKABLE, False)
    SetFlag(cui_Options, lv.obj.FLAG.SCROLLABLE, False)
    cui_Opt1 = lv.button(cui_Options)
    cui_Opt1.set_height(50)
    cui_Opt1.set_flex_grow(1)
    cui_Opt1.set_align( lv.ALIGN.CENTER)
    SetFlag(cui_Opt1, lv.obj.FLAG.SCROLLABLE, False)
    SetFlag(cui_Opt1, lv.obj.FLAG.SCROLL_ON_FOCUS, True)
    cui_Opt1Text = lv.label(cui_Opt1)
    cui_Opt1Text.set_text("Option1")
    cui_Opt1Text.set_width(lv.SIZE_CONTENT)	# 1
    cui_Opt1Text.set_height(lv.SIZE_CONTENT)   # 1
    cui_Opt1Text.set_align( lv.ALIGN.CENTER)
    cui_Container9 = lv.obj(cui_Options)
    cui_Container9.remove_style_all()
    cui_Container9.set_width(10)
    cui_Container9.set_height(lv.pct(100))
    cui_Container9.set_align( lv.ALIGN.CENTER)
    SetFlag(cui_Container9, lv.obj.FLAG.CLICKABLE, False)
    SetFlag(cui_Container9, lv.obj.FLAG.SCROLLABLE, False)
    cui_Opt2 = lv.button(cui_Options)
    cui_Opt2.set_height(50)
    cui_Opt2.set_flex_grow(1)
    cui_Opt2.set_align( lv.ALIGN.CENTER)
    SetFlag(cui_Opt2, lv.obj.FLAG.SCROLLABLE, False)
    SetFlag(cui_Opt2, lv.obj.FLAG.SCROLL_ON_FOCUS, True)
    cui_Option2Text = lv.label(cui_Opt2)
    cui_Option2Text.set_text("Option2")
    cui_Option2Text.set_width(lv.SIZE_CONTENT)	# 1
    cui_Option2Text.set_height(lv.SIZE_CONTENT)   # 1
    cui_Option2Text.set_align( lv.ALIGN.CENTER)
    _ui_comp_table[id(cui_OptionsModal)]= {"OptionsModal" : cui_OptionsModal,"ModalTitle" : cui_ModalTitle,"ModalContent" : cui_ModalContent,"Options" : cui_Options,"Options_Opt1" : cui_Opt1,"Options_Opt1_Opt1Text" : cui_Opt1Text,"Options_Container9" : cui_Container9,"Options_Opt2" : cui_Opt2,"Options_Opt2_Option2Text" : cui_Option2Text, "_CompName" : "OptionsModal"}
    return cui_OptionsModal

def SetFlag(obj, flag, value: bool):
    if (value):
        obj.add_flag(flag)
    else:
        obj.remove_flag(flag)
    return

def custom():
    ui_Screen1 = lv.obj()
    SetFlag(ui_Screen1, lv.obj.FLAG.SCROLLABLE, False)

    ui_MainContainer = lv.obj(ui_Screen1)
    ui_MainContainer.remove_style_all()
    ui_MainContainer.set_width(lv.pct(100))
    ui_MainContainer.set_height(lv.pct(100))
    ui_MainContainer.set_align(lv.ALIGN.CENTER)
    SetFlag(ui_MainContainer, lv.obj.FLAG.CLICKABLE, False)
    SetFlag(ui_MainContainer, lv.obj.FLAG.SCROLLABLE, False)

    ui_Interface = lv.obj(ui_MainContainer)
    ui_Interface.remove_style_all()
    ui_Interface.set_width(lv.pct(100))
    ui_Interface.set_height(lv.pct(100))
    ui_Interface.set_align(lv.ALIGN.CENTER)
    ui_Interface.set_flex_flow(lv.FLEX_FLOW.COLUMN)
    ui_Interface.set_flex_align(lv.FLEX_ALIGN.START, lv.FLEX_ALIGN.CENTER, lv.FLEX_ALIGN.CENTER)
    SetFlag(ui_Interface, lv.obj.FLAG.CLICKABLE, False)
    SetFlag(ui_Interface, lv.obj.FLAG.SCROLLABLE, False)

    ui_InfoHeader = lv.obj(ui_Interface)
    ui_InfoHeader.remove_style_all()
    ui_InfoHeader.set_height(20)
    ui_InfoHeader.set_width(lv.pct(100))
    ui_InfoHeader.set_align(lv.ALIGN.TOP_MID)
    ui_InfoHeader.set_flex_flow(lv.FLEX_FLOW.ROW)
    ui_InfoHeader.set_flex_align(lv.FLEX_ALIGN.CENTER, lv.FLEX_ALIGN.CENTER, lv.FLEX_ALIGN.CENTER)
    SetFlag(ui_InfoHeader, lv.obj.FLAG.CLICKABLE, False)
    SetFlag(ui_InfoHeader, lv.obj.FLAG.SCROLLABLE, False)
    ui_InfoHeader.set_style_bg_color(lv.color_hex(0xCCCCCC), lv.PART.MAIN | lv.STATE.DEFAULT)
    ui_InfoHeader.set_style_bg_opa(255, lv.PART.MAIN | lv.STATE.DEFAULT)

    ui_InfoHeader.set_style_pad_left(4, lv.PART.SCROLLBAR | lv.STATE.DEFAULT)
    ui_InfoHeader.set_style_pad_right(4, lv.PART.SCROLLBAR | lv.STATE.DEFAULT)
    ui_InfoHeader.set_style_pad_top(2, lv.PART.SCROLLBAR | lv.STATE.DEFAULT)
    ui_InfoHeader.set_style_pad_bottom(2, lv.PART.SCROLLBAR | lv.STATE.DEFAULT)

    ui_LeftSection = lv.obj(ui_InfoHeader)
    ui_LeftSection.remove_style_all()
    ui_LeftSection.set_height(lv.pct(100))
    ui_LeftSection.set_flex_grow(1)
    ui_LeftSection.set_align(lv.ALIGN.CENTER)
    ui_LeftSection.set_flex_flow(lv.FLEX_FLOW.ROW)
    ui_LeftSection.set_flex_align(lv.FLEX_ALIGN.START, lv.FLEX_ALIGN.START, lv.FLEX_ALIGN.CENTER)
    SetFlag(ui_LeftSection, lv.obj.FLAG.CLICKABLE, False)
    SetFlag(ui_LeftSection, lv.obj.FLAG.SCROLLABLE, False)

    ui_WifiStatus = lv.label(ui_LeftSection)
    ui_WifiStatus.set_text("Wifi: Not Connected")
    ui_WifiStatus.set_width(lv.SIZE_CONTENT)  # 1
    ui_WifiStatus.set_height(lv.SIZE_CONTENT)  # 1
    ui_WifiStatus.set_align(lv.ALIGN.CENTER)

    ui_MiddleSection = lv.obj(ui_InfoHeader)
    ui_MiddleSection.remove_style_all()
    ui_MiddleSection.set_height(lv.pct(100))
    ui_MiddleSection.set_flex_grow(1)
    ui_MiddleSection.set_align(lv.ALIGN.CENTER)
    ui_MiddleSection.set_flex_flow(lv.FLEX_FLOW.ROW)
    ui_MiddleSection.set_flex_align(lv.FLEX_ALIGN.CENTER, lv.FLEX_ALIGN.CENTER, lv.FLEX_ALIGN.CENTER)
    SetFlag(ui_MiddleSection, lv.obj.FLAG.CLICKABLE, False)
    SetFlag(ui_MiddleSection, lv.obj.FLAG.SCROLLABLE, False)

    ui_Time = lv.label(ui_MiddleSection)
    ui_Time.set_text("10:00")
    ui_Time.set_width(lv.SIZE_CONTENT)  # 1
    ui_Time.set_height(lv.SIZE_CONTENT)  # 1
    ui_Time.set_align(lv.ALIGN.CENTER)

    ui_RightSection = lv.obj(ui_InfoHeader)
    ui_RightSection.remove_style_all()
    ui_RightSection.set_height(lv.pct(100))
    ui_RightSection.set_flex_grow(1)
    ui_RightSection.set_align(lv.ALIGN.CENTER)
    ui_RightSection.set_flex_flow(lv.FLEX_FLOW.ROW)
    ui_RightSection.set_flex_align(lv.FLEX_ALIGN.END, lv.FLEX_ALIGN.CENTER, lv.FLEX_ALIGN.CENTER)
    SetFlag(ui_RightSection, lv.obj.FLAG.CLICKABLE, False)
    SetFlag(ui_RightSection, lv.obj.FLAG.SCROLLABLE, False)

    ui_Battery = lv.label(ui_RightSection)
    ui_Battery.set_text("90% Charge")
    ui_Battery.set_width(lv.SIZE_CONTENT)  # 1
    ui_Battery.set_height(lv.SIZE_CONTENT)  # 1
    ui_Battery.set_align(lv.ALIGN.CENTER)

    ui_AppInterface = lv.obj(ui_Interface)
    ui_AppInterface.remove_style_all()
    ui_AppInterface.set_width(lv.pct(100))
    ui_AppInterface.set_height(lv.pct(95))
    ui_AppInterface.set_align(lv.ALIGN.CENTER)
    SetFlag(ui_AppInterface, lv.obj.FLAG.CLICKABLE, False)
    SetFlag(ui_AppInterface, lv.obj.FLAG.SCROLLABLE, False)

    ui_OverInterface = lv.obj(ui_MainContainer)
    ui_OverInterface.remove_style_all()
    ui_OverInterface.set_width(lv.pct(100))
    ui_OverInterface.set_height(lv.pct(100))
    ui_OverInterface.set_align(lv.ALIGN.CENTER)
    SetFlag(ui_OverInterface, lv.obj.FLAG.CLICKABLE, False)
    SetFlag(ui_OverInterface, lv.obj.FLAG.SCROLLABLE, False)

    ui_MainKeyboard = lv.keyboard(ui_OverInterface)
    ui_MainKeyboard.set_width(lv.pct(100))
    ui_MainKeyboard.set_height(lv.pct(50))
    ui_MainKeyboard.set_align(lv.ALIGN.BOTTOM_MID)

    ui_ModalContainer = lv.obj(ui_OverInterface)
    ui_ModalContainer.remove_style_all()
    ui_ModalContainer.set_width(lv.pct(100))
    ui_ModalContainer.set_height(lv.pct(100))
    ui_ModalContainer.set_align(lv.ALIGN.CENTER)
    SetFlag(ui_ModalContainer, lv.obj.FLAG.CLICKABLE, False)
    SetFlag(ui_ModalContainer, lv.obj.FLAG.SCROLLABLE, False)

    ui_OptionsModal = ui_OptionsModal_create(ui_ModalContainer)
    ui_OptionsModal.set_x(0)
    ui_OptionsModal.set_y(0)

    lv.screen_load(ui_Screen1)


def main():
    pass

I ran it and I may have found the issue:

Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "osui.py", line 88, in custom
MemoryError: memory allocation failed, allocating 2147483656 bytes

For the last error I was mentioning, I think it's because of the task handler part in the main.py since it's running constantly and introducing another concurrent thread will probably make it panic (I am not familiar with the terminology but I have a general idea on what's going on and what might've caused the last issue.)

[Type-32]

Another annoying issue that has an annoying workaround:

"/Users/administrator/Documents/PyCharm Projects/GeneralPurposePDA/.venv/bin/python" "/Users/administrator/Library/Application Support/JetBrains/PyCharm2024.2/plugins/intellij-micropython/scripts/microupload.py" -C "/Users/administrator/Documents/PyCharm Projects/GeneralPurposePDA" -v /dev/cu.usbmodem58A60707701 "/Users/administrator/Documents/PyCharm Projects/GeneralPurposePDA/osui.py"
Connecting to /dev/cu.usbmodem58A60707701
Uploading files: 0% (0/1)
/Users/administrator/Documents/PyCharm Projects/GeneralPurposePDA/osui.py -> osui.py
Traceback (most recent call last):
  File "/Users/administrator/Library/Application Support/JetBrains/PyCharm2024.2/plugins/intellij-micropython/scripts/microupload.py", line 139, in <module>
    main(sys.argv[1:])
  File "/Users/administrator/Library/Application Support/JetBrains/PyCharm2024.2/plugins/intellij-micropython/scripts/microupload.py", line 79, in main
    files.put(remote_path, fd.read())
  File "/Users/administrator/Documents/PyCharm Projects/GeneralPurposePDA/.venv/lib/python3.12/site-packages/ampy/files.py", line 218, in put
    self._pyboard.exec_("f.write({0})".format(chunk))
  File "/Users/administrator/Documents/PyCharm Projects/GeneralPurposePDA/.venv/lib/python3.12/site-packages/ampy/pyboard.py", line 265, in exec_
    ret, ret_err = self.exec_raw(command)
                   ^^^^^^^^^^^^^^^^^^^^^^
  File "/Users/administrator/Documents/PyCharm Projects/GeneralPurposePDA/.venv/lib/python3.12/site-packages/ampy/pyboard.py", line 256, in exec_raw
    self.exec_raw_no_follow(command);
    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
  File "/Users/administrator/Documents/PyCharm Projects/GeneralPurposePDA/.venv/lib/python3.12/site-packages/ampy/pyboard.py", line 253, in exec_raw_no_follow
    raise PyboardError('could not exec command')
ampy.pyboard.PyboardError: could not exec command

Keep getting this when trying to flash my own program. Erasing the flash and reflashing the firmware does the job but I have to reflash the programs in again but only to be greeted with this after the first or second time of flashing my program on to the hardware.

[kdschlosser]

what I do to handle the positioning of things is I use Paint.NET (Windows) and create a new image the same size as the display. I create a layer for each widget/object that I would make for the GUI and I set a dotted outline to that layer to indicate the outside edges of the widget. then I position it where I want it to appear.. I hover the mouse over the top left corner to get the position. That's if I am creating a statically positioned and sized GUI. If the GUI is going to be designed so it is able to run on any size display then I create 2 displays one for the smallest size supported and one for the largest size supported and I remap the sizes and positions using the display width and height as inputs and the small display as the min input and the large display as the max input.

[Type-32]

You can pick through the generated code and make the corrections that are needed. But the code ran directly is not going to run right if it even runs at all...

That is one issue I'm facing. By far the code does run, but I have to like plug in to the USB port first, wait a few seconds until the UI comes out, then switch to UART port to flash my code changes. Sometimes it just spouts out errors which I don't know how and why even though the only change is just adding a non-code comment.

The stability in the code it generates is worrying; though, I am looking for other alternative workflows for this. Right now I'm sticking with this workflow to at least get something out and then consider about stability later in development.

[Type-32]

what I do to handle the positioning of things is I use Paint.NET (Windows) and create a new image the same size as the display. I create a layer for each widget/object that I would make for the GUI and I set a dotted outline to that layer to indicate the outside edges of the widget. then I position it where I want it to appear.. I hover the mouse over the top left corner to get the position. That's if I am creating a statically positioned and sized GUI. If the GUI is going to be designed so it is able to run on any size display then I create 2 displays one for the smallest size supported and one for the largest size supported and I remap the sizes and positions using the display width and height as inputs and the small display as the min input and the large display as the max input.

That is a very creative approach which I'll try later. Massive thanks for sharing it. :D

It's more or so on how to implement design in code, which I lack knowledge of. Until the documentation for this comes out I'm going to stick with Squareline for now.

[kdschlosser]

I added a function that does the remapping to the binding.

import lcd_utils

out_value = lcd_utils.remap(in_value, in_min, in_max, out_min, out_max)

it works like this...

from lcd_utils import remap


ORIGINAL_DISPLAY_WIDTH = 800
ORIGINAL_DISPLAY_HEIGHT = 480

DISPLAY_WIDTH = 320
DISPLAY_HEIGHT = 240


class DisplayScaling:

    def __init__(self, x, y, width, height, keep_aspect=True):

        self._x = x
        self._y = y
        self._width = width
        self._height = height
        self._keep_aspect = keep_aspect
        self._aspect = float(width) / float(height)

    @property
    def x(self):
        return remap(self._x, 0, ORIGINAL_DISPLAY_WIDTH, 0, DISPLAY_WIDTH)

    @property
    def y(self):
        y = remap(self._x, 0, ORIGINAL_DISPLAY_HEIGHT, 0, DISPLAY_HEIGHT)

        height_scalar = remap(self._height,0.0, ORIGINAL_DISPLAY_HEIGHT,0.0,1.0)

        offset = height_scalar * DISPLAY_HEIGHT
        
        y -= int(offset)

        if self._keep_aspect:
            y -= int((height_scalar * (self.height - self._height)) / 2)

        return int(y)

    @property
    def width(self):
        return remap(self._width, 0, ORIGINAL_DISPLAY_WIDTH, 0, DISPLAY_WIDTH)

    @property
    def height(self):
        if self._keep_aspect:
            return int(self.width / self._aspect)

        return remap(self._height, 0, ORIGINAL_DISPLAY_HEIGHT, 0, DISPLAY_HEIGHT)

    @property
    def pos(self):
        return self.x, self.y

    @property
    def size(self):
        return self.width, self.height


ds = DisplayScaling(299, 179, 200, 120, True)

print(ds.size)
print(ds.pos)

[Type-32]

what does remapping the binding do?

[Type-32]

One question: in what way is the main.py ran on the device (like runs when booting or loops after booting)? Is it running as a loop or something, or is it only just running one time? I've been trying to setup a realtime local time display but haven't succeeded yet.

[Type-32]

Solved. I'll post my repository here later for reference.

[Type-32]

I noticed something funny: with the rgb565_byte_swap property set to True, the color black and the ragged edges of white text becomes green for some reason, and red becomes black. with that property set to False, red turns blue, and blue turns red, but the texts and other colors remain normal.

Is there a way to fix this?
See next comment for fix.

[Type-32]

Another weird phenomenon: sometimes when I flash the UI code (this also happens with non-squareline-generated-code for some reason), all black text would become white. I'm using the UART port when flashing the code on to the device. If I unplug and leave it for five or so minutes, and power it on with the USB port, then the UI and text and other coloring (red and blue are still swapped) of UI elements becomes normal for some reason. Then I unplug and immediately switch back to UART, then everything stays normal until the next time I flash something in.

Related to:

theme = lv.theme_default_init(dispp, lv.palette_main(lv.PALETTE.BLUE), lv.palette_main(lv.PALETTE.RED), False, lv.font_default())

When False, black texts remain normal; when True, black texts becomes white. I'm guessing this is the option to toggle its dark and white mode.

[kdschlosser]

what is the bus on the display you are using?

[Type-32]

The RGBBus (or I2C Bus).

import time
from micropython import const  # NOQA
from i2c import I2C
import gt911
import lcd_bus
import task_handler
import lvgl as lv  # NOQA
import rgb_display

# SETUP block
_WIDTH = const(800)
_HEIGHT = const(480)

_BUFFER_SIZE = const(768000)

_CTP_SCL = const(9)
_CTP_SDA = const(8)
_CTP_IRQ = const(4)

_SD_MOSI = const(11)
_SD_SCK = const(12)
_SD_MISO = const(13)

_LCD_FREQ = const(13000000)
_PCLK_ACTIVE_NEG = const(0)

_HSYNC_PULSE_WIDTH = const(10)
_HSYNC_BACK_PORCH = const(10)
_HSYNC_FRONT_PORCH = const(10)

_VSYNC_PULSE_WIDTH = const(10)
_VSYNC_BACK_PORCH = const(10)
_VSYNC_FRONT_PORCH = const(20)

_PCLK = const(7)
_HSYNC = const(46)
_VSYNC = const(3)
_DE = const(5)
_DISP = None
_BCKL = None
_DRST = None

I2C_BUS = I2C.Bus(
    host=1,
    scl=_CTP_SCL,
    sda=_CTP_SDA,
    freq=400000,
    use_locks=False
)

TOUCH_DEVICE = I2C.Device(
    I2C_BUS,
    dev_id=gt911.I2C_ADDR,
    reg_bits=gt911.BITS
)

_DATA15 = const(10)  # B7
_DATA14 = const(17)  # B6
_DATA13 = const(18)  # B5
_DATA12 = const(38)  # B4
_DATA11 = const(14)  # B3
_DATA10 = const(21)  # G7
_DATA9 = const(47)  # G6
_DATA8 = const(48)  # G5
_DATA7 = const(45)  # G4
_DATA6 = const(0)  # G3
_DATA5 = const(39)  # G2
_DATA4 = const(40)  # R7
_DATA3 = const(41)  # R6
_DATA2 = const(42)  # R5
_DATA1 = const(2)  # R4
_DATA0 = const(1)  # R3

bus = lcd_bus.RGBBus(
    hsync=_HSYNC,
    vsync=_VSYNC,
    de=_DE,
    pclk=_PCLK,
    data0=_DATA0,
    data1=_DATA1,
    data2=_DATA2,
    data3=_DATA3,
    data4=_DATA4,
    data5=_DATA5,
    data6=_DATA6,
    data7=_DATA7,
    data8=_DATA8,
    data9=_DATA9,
    data10=_DATA10,
    data11=_DATA11,
    data12=_DATA12,
    data13=_DATA13,
    data14=_DATA14,
    data15=_DATA15,
    freq=_LCD_FREQ,
    hsync_front_porch=_HSYNC_FRONT_PORCH,
    hsync_back_porch=_HSYNC_BACK_PORCH,
    hsync_pulse_width=_HSYNC_PULSE_WIDTH,
    hsync_idle_low=False,
    vsync_front_porch=_VSYNC_FRONT_PORCH,
    vsync_back_porch=_VSYNC_BACK_PORCH,
    vsync_pulse_width=_VSYNC_PULSE_WIDTH,
    vsync_idle_low=False,
    de_idle_high=False,
    pclk_idle_high=False,
    pclk_active_low=_PCLK_ACTIVE_NEG,
)

[Type-32]

Here is my repo: https://github.com/Type-32/GeneralPurposePDA

[kdschlosser]

OK so when dealing with the RGBBus and using RGB565 with a 16 lane connection if your colors are off it is going to be because the pins are not defined correctly.

I have seen this more than once where for some crazy reason the pin order is goofed up.

so what you are going to need to do is double check the pins to see if they align with what the data sheet says. You will have to compare that with what is in the examples for the display as well. I have found that the datasheet is not always correct but the examples are and the examples also will give you a hint as to what pin actually does what.

[Type-32]

Thank you so much for this suggestion. I swapped the pin assignments around a bit and now it's correctly displaying the right colors.

My pin config is below

_DATA15 = const(40)  # R7
_DATA14 = const(41)  # R6
_DATA13 = const(42)  # R5
_DATA12 = const(2)   # R4
_DATA11 = const(1)   # R3
_DATA10 = const(21)  # G7
_DATA9 = const(47)   # G6
_DATA8 = const(48)   # G5
_DATA7 = const(45)   # G4
_DATA6 = const(0)    # G3
_DATA5 = const(39)   # G2
_DATA4 = const(10)   # B7
_DATA3 = const(17)   # B6
_DATA2 = const(18)   # B5
_DATA1 = const(38)   # B4
_DATA0 = const(14)   # B3

[kdschlosser]

sometimes it's like that. It's how RGB displays work. Since there are no commands that gets sent over those pins what does get sent is the RGB bit data. and in the case of RGB565 it is 16 bits which is one bit position for each lane. change them around and you change the color that gets displayed.

[kdschlosser]

Your display has a pixel color order of BGR

[Type-32]

is this pixel color order random of the produced product or configured by default on every product? (is it intentional or unintentional)

[kdschlosser]

it could be caused by any number of things. I have yet to test it to see if mine has changed. it could be an issue in my code.. when I get some time I will test it out.

[Type-32]

An update on the SD Card Slot thingy: i recently bought an MMC Micro card to see whether it'll work on the board and it does not fit lol. I now bought another micro SD card and am waiting for it to arrive.

[Type-32]

Update on the SD Card thingy: I rechecked the wiki again and it says that:

SD Cards require SPI Communication; Note that SD_CS will have to be driven by EXIO4 from CH422G

...whatever the hell that means.

[kdschlosser]

I was just being a smart ass is all. I figured you would be happy that I already had written a driver framework handle IO expanders and i it just so happened that I had written a driver for the IO expander you were using.

[danielcqar]

Hi, I'm developing an application running in a ESP32-S3-Touch-LCD-7 from Waveshare.

The application uses lvgl_micropython for a multiscreen UI and asyncio to run the access to DS3231 rtc vía I2C and polling an external device with ELAM protocol (kind a Modbus).
Thanks to several tips from @kdschlosser I found in this and another pages I got working the whole thing in a very short time.

You really are a nice guy... but (always there is a but), to finally add card support I tried io_expander.py but it didn't work for me, when I import it I get an "AttributeError: 'module' object has no attribute 'EXIO1'" error.
By the way, I'm using "LVGL (9.2.2) MicroPython (1.24.1) Binding compiled on 2025-03-10; Generic ESP32S3 module with Octal-SPIRAM with ESP32S3" (make.py esp32 BOARD=ESP32_GENERIC_S3 BOARD_VARIANT=SPIRAM_OCT DISPLAY=rgb_display INDEV=gt911 --enable-uart-repl=n --enable-cdc-repl=y --enable-jtag-repl=n).

I will appreciate very much any tip to solve this.

[kdschlosser]

well I'll be damned. Not sure why I do not have those define in the framework.

Use this attached one instead and see if that works for ya.
io_expander.py.txt

I do not have one of these expanders so this driver is untested. There are probably things that are going to need to be altered to get it to work.

If you have any other issues with it, please open an issue and we can go over what is wrong there.

[danielcqar]

Me again, only to say that the new io_expander.py solved the problem.
By the way, after reading again and again machine_hw_spi.c and machine_sdcard.c on micropy_updates/esp32 finally understand the right steps to put the sd slot to work.
Thank you very much for the io_expander.py in particular and for make the lvgl+micropython build much easier.

[kdschlosser]

I added a revised version of the driver to the repo so you can bake it into the firmware if you wanted to. Add the IO_EXPANDER= IC model number build command and that will compile the driver into the firmware for ya.

[gmeader]

I successfully built a .bin for the ESP32-S3-Touch-LCD-4.3 from WaveShare on both MacOS and Linux. There's lots of helpful info from kdschlosser in the Closed Issues for this repo regarding getting a build to actually work on MacOS and Linux - there are lots of things that might not work at first. I built a native binary for MacOS then Linux , then for the WaveShare board.

Here's the build command for the WaveShare board:
python3 make.py esp32 BOARD=ESP32_GENERIC_S3 BOARD_VARIANT=SPIRAM_OCT --flash-size=8 DISPLAY=rgb_display INDEV=gt911 CONFIG_FREERTOS_HZ=1000 CONFIG_ESP_DEFAULT_CPU_FREQ_MHZ_240=y CONFIG_ESPTOOLPY_FLASHMODE_QIO=y CONFIG_ESPTOOLPY_FLASHFREQ_120M=y CONFIG_IDF_EXPERIMENTAL_FEATURES=y CONFIG_SPIRAM_SPEED_120M=y CONFIG_SPIRAM_FETCH_INSTRUCTIONS=y CONFIG_SPIRAM_RODATA=y CONFIG_ESP32S3_DATA_CACHE_LINE_64B=y CONFIG_COMPILER_OPTIMIZATION_PERF=y

At the end of the build, it displays the command to flash the .bin onto the WaveShare board. You have to figure out the name of the USB serial port that appears on your computer when you plug the Waveshare board in using a USB cable. Replace "(PORT)" with that devicename. On my Linux box the device is /dev/ttyACM0
Once you got it flashed, you can fire up a serial terminal on that port and you will see the LVGL Micropython REPL. The USB cable connects to the USB-C port on the board labelled UART.

I installed mpremote on my Linux box so I could manipulate (copy from PC to board, etc.) Python files on the WaveShare board.
if Micropython is running on the board, then mpremote can connect to it.

I got some demo LVGL python demo code running on the board. The touchscreen works too.
Rename this to demo.py:
demo.py.txt

Copy the demo.py file to the board using mpremote fs cp demo.py :demo.py, then give just a mpremote command with no optionsand you'll get a REPL.

Type import demo in the REPL to run it and see the display on the board working.

[kdschlosser]

as a side note. If you want to give the file transfer a good swift kick in the arse you can optionally add
--uart-repl-bitrate={bitrate} to the build command. Replace the {bitrate} with the speed you want to use. The maximum is going to depend on the UART to USB bridge chip that is used on the board. I have had pretty decent luck with '921600'. I have not seen a bridge IC that had an issue with 460800. so that is a large jump up in speed at 4x the speed.

Now remember this setting alters the connection speed of the UART that handle the REPL. so you will need to adjust your terminal program accordingly. mpremote will also need to have it's default speed changed as well.

This is a really handy thing especially when transferring a lot of source files and images. When you start writing really complex UI's you are not going to want to code it all in a single source file. It becomes unmanageable. When uploading a lot of files the speed helps a lot.

[kdschlosser]

I did also want to note that macOS and Linux can be a little bit of a pain because of the very large differences in the OS with respect to the environment. It's not always cut and dry which is why it is very important to ask for some assistance. Don't pull your hair out over it. It could be something that has been seen before and is really simple to fix.

I can confirm that the build works on both Apple Silicon and Intel Silicon when running macOS. I am happy that it's all hammered out. I think I am going to add some code to the macOS build to locate FFI and SDL2 and to automatically handle setting the library and include paths. I am going to have to check and see what kind of an API is available for Homebrew to see if I am able to get the information that is needed form it without needing to do it using a subprocess and parsing output.

[gmeader]

Colors are still not correct. (even with Type-32's swapping pins fix from comment #142)
Here is an image of the results of the attached code (pal.py) that uses LVGL PALETTE colors as a test.
pal.py.txt
RGB colors constructed using lv.color_hex() are not correct either.
The fonts (in the default lv_conf.h) are too small on the ESP32-S3-Touch-LCD-4.3 from WaveShare, so I compiled a .bin with larger fonts enabled.

Another color demo program is: cdemo.py - draws a lot of buttons with the hex code for the background color as the label - with no font specified. cdemo.py.txt

[Type-32]

see context: #142 (comment)

my pin config: https://github.com/Type-32/GeneralPurposePDA/blob/dev/main.py

[Type-32]

related to your pin config: #142 (comment)

[Type-32]

try to switch around pin numbers until the colors are correct. at least, that's what i did

[gmeader]

Thanks, but I had already included your pin designation fix. Maybe I'm doing that wrong somehow?

[gmeader]

Here is the palette test code. I believe I have the correct pin config, from your post #142. And the pin numbers match what's in the board datasheet on the WaveShare website. The button labels show the name of the LVGL Palette and the hex code for that color.
pal.py.txt

in the following code I swapped the blue and green pins so that it is RGB instead of RBG, but that did not fix the color issue. It only made it make more sense. There is something incorrect about the pins, as some of another R, G or B gets involved when it is set to zero.
cdemo.py.txt

[kdschlosser]

scratch that. you are using an RGB display..

The correct pinout for the display you are using is

_DATA15 = const(10)  # B7
    _DATA14 = const(17)  # B6
    _DATA13 = const(18)  # B5
    _DATA12 = const(38)  # B4
    _DATA11 = const(14)  # B3
    _DATA10 = const(21)  # G7
    _DATA9 = const(47)  # G6
    _DATA8 = const(48)  # G5
    _DATA7 = const(45)  # G4
    _DATA6 = const(0)  # G3
    _DATA5 = const(39)  # G2
    _DATA4 = const(40)  # R7
    _DATA3 = const(41)  # R6
    _DATA2 = const(42)  # R5
    _DATA1 = const(2)  # R4
    _DATA0 = const(1)  # R3

set the color_space to RGB565 when constructing the display driver and also set rgb565_byte_swap to True.

The RGB565 byte swap doesn't reorder the pixel buffer for the RGB displays. It will move the pins around in software so the colors are correct.

[kdschlosser]

This is the actual working setup for that display...

    from i2c import I2C
    import gt911
    import rgb_display

    _CTP_SCL = const(9)
    _CTP_SDA = const(8)
    _CTP_IRQ = const(4)

    _SD_MOSI = const(11)
    _SD_SCK = const(12)
    _SD_MISO = const(13)

    _LCD_FREQ = const(13000000)

    _HSYNC_PULSE_WIDTH = const(10)
    _HSYNC_BACK_PORCH = const(10)
    _HSYNC_FRONT_PORCH = const(10)

    _VSYNC_PULSE_WIDTH = const(10)
    _VSYNC_BACK_PORCH = const(10)
    _VSYNC_FRONT_PORCH = const(20)

    _PCLK = const(7)
    _HSYNC = const(46)
    _VSYNC = const(3)
    _DE = const(5)
    _DISP = None
    _BCKL = None
    _DRST = None

    i2c_bus = I2C.Bus(
        host=1,
        scl=_CTP_SCL,
        sda=_CTP_SDA,
        freq=400000,
        use_locks=False
    )

    i2c_device = I2C.Device(
        i2c_bus,
        dev_id=gt911.I2C_ADDR,
        reg_bits=gt911.BITS
    )

    _DATA15 = const(10)  # B7
    _DATA14 = const(17)  # B6
    _DATA13 = const(18)  # B5
    _DATA12 = const(38)  # B4
    _DATA11 = const(14)  # B3
    _DATA10 = const(21)  # G7
    _DATA9 = const(47)  # G6
    _DATA8 = const(48)  # G5
    _DATA7 = const(45)  # G4
    _DATA6 = const(0)  # G3
    _DATA5 = const(39)  # G2
    _DATA4 = const(40)  # R7
    _DATA3 = const(41)  # R6
    _DATA2 = const(42)  # R5
    _DATA1 = const(2)  # R4
    _DATA0 = const(1)  # R3

    bus = lcd_bus.RGBBus(
        hsync=_HSYNC,
        vsync=_VSYNC,
        de=_DE,
        pclk=_PCLK,
        data0=_DATA0,
        data1=_DATA1,
        data2=_DATA2,
        data3=_DATA3,
        data4=_DATA4,
        data5=_DATA5,
        data6=_DATA6,
        data7=_DATA7,
        data8=_DATA8,
        data9=_DATA9,
        data10=_DATA10,
        data11=_DATA11,
        data12=_DATA12,
        data13=_DATA13,
        data14=_DATA14,
        data15=_DATA15,
        freq=_LCD_FREQ,
        hsync_front_porch=_HSYNC_FRONT_PORCH,
        hsync_back_porch=_HSYNC_BACK_PORCH,
        hsync_pulse_width=_HSYNC_PULSE_WIDTH,
        vsync_front_porch=_VSYNC_FRONT_PORCH,
        vsync_back_porch=_VSYNC_BACK_PORCH,
        vsync_pulse_width=_VSYNC_PULSE_WIDTH,
    )

    buf1 = bus.allocate_framebuffer(int(_WIDTH * _HEIGHT * 2 / 10), lcd_bus.MEMORY_INTERNAL)
    buf2 = bus.allocate_framebuffer(int(_WIDTH * _HEIGHT * 2 / 10), lcd_bus.MEMORY_INTERNAL)

    display = rgb_display.RGBDisplay(
        data_bus=bus,
        display_width=_WIDTH,
        display_height=_HEIGHT,
        frame_buffer1=buf1,
        frame_buffer2=buf2,
        color_space=lv.COLOR_FORMAT.RGB565,
        rgb565_byte_swap=True
    )

    display.set_power(True)
    display.init()
    display.set_backlight(100)
    indev = gt911.GT911(i2c_device)

    if indev.hw_size != (_WIDTH, _HEIGHT):
        fw_config = indev.firmware_config
        fw_config.width = _WIDTH
        fw_config.height = _HEIGHT
        fw_config.save()

        del fw_config

[gmeader]

Hmmm. That is the exact same code that is in the beginning of the program I posted that created the image (above) with the incorrect colors: pal.py
(you gave me this same code a couple of days ago - I just pasted it in.)
Note: I'm using your repo, compiled using your instructions that you have been helping me with over the last few days, unchanged, except for enabling some more fonts in lv_conf.h
I'm grateful for all your help on this.
Perhaps you want to run the code I posted above (pal.py) and see if it works correctly on on your hardware...

[kdschlosser]

If the colors are not coming out right then the company must have redesigned the board. That is the reason why I had to turn on the RGB565 swap was because the pinning was different on my board then what they had in their data sheet.

so try setting that RGB565 byte swap to False and see if the colors come out right.

[kdschlosser]

we will get the color issue sorted out. This is the problems we have to deal with when working with these types of boards. The data sheets are not always correct and we end up having to spend some time figuring out what the actual pinning is to the MCU.

I know it can be frustrating to say the least, Trust me when I say I feel your pain with this. I have a display here on my desk that I have been trying to get to work for months now without any luck at all. The company that makes it has not been any help at all and the documentation is not all that fantastic.

[gmeader]

Here is the pal.py display with rgb565_byte_swap=False

Here is the pal.py display with rgb565_byte_swap=True

Neither is correct. I'm looking at the hex color values trying to see if there is some way to figure out what might be mis-arranged.
So far I'm not seeing the pattern.

[kdschlosser]

How about this. 3 colors only and make them FF0000, 00FF00 and 0000FF It is going to be a whole lot easier to figure out what is going on if you have only those colors.

[gmeader]

Here's those 3 buttons and more.
Notice how something odd happens in the change from 7F to 80 in the middle byte (maybe the blue?)

This is with rgb565_byte_swap=FALSE
it is generated with code like this:

color_values=[0,127,128,255]
for r in color_values:
    for b in color_values
         for g in color_values:
            color = lv.color_make(r,g,b)
            hex = '{:02X}{:02X}{:02X}'.format(r,g,b)
            button.append(lv.button(button_container))
            button[-1].set_style_bg_color(color,0)
            button_label.set_text(hex)

[kdschlosser]

all I want is 3 colors. FF0000 00FF00 and 0000FF

[gmeader]

row 4, column 1 = 00FF00 full blue
row 5, column 2 = 0000FF full red
row 1, column 7 = FF0000 full green

any color with only FF or 00 seems correct.

[kdschlosser]

I think I figured out the pins. Give this a try...

_DATA15 = const(40) # R7
_DATA14 = const(41) # R6
_DATA13 = const(42) # R5
_DATA12 = const(2) # R4
_DATA11 = const(1) # R3

_DATA10 = const(21) # G7
_DATA9 = const(47) # G6
_DATA8 = const(48) # G5
_DATA7 = const(45) # G4
_DATA6 = const(0) # G3
_DATA5 = const(39) # G2

_DATA4 = const(10) # B7
_DATA3 = const(17) # B6
_DATA2 = const(18) # B5
_DATA1 = const(38) # B4
_DATA0 = const(14) # B3

[gmeader]

SUCCESS! Replaced the code in pal.py.txt with your new pin definitions and Voila!

[kdschlosser]

You just had to give me a little bit of time to look at the binary for the colors to figure out what was going on.

[gmeader]

When I try to connect to a WiFi network using the commands that are displayed when I run help() in the REPL, Micropython crashes on an illegal instruction and does a crash dump. The specific Python statement that crashes it is sta_if.connect()
This is after a succesful sta_if.scan() that shows a bunch of access points.
I'm wondering if this happens for you, or if you want the crash dump file, or have another suggestion.

[kdschlosser]

The WiFi has always been fickle with MicroPython and it needs to be done in a very specific way otherwise you end up with a crash that doesn't provide any useful help.

Have you tried the connection code that is in the MicroPython documentation???

import network

def do_connect():
    wlan = network.WLAN(network.WLAN.IF_STA)
    wlan.active(True)
    if not wlan.isconnected():
        print('connecting to network...')
        wlan.connect('ssid', 'key')
        while not wlan.isconnected():
            pass
    print('network config:', wlan.ipconfig('addr4'))

https://docs.micropython.org/en/latest/esp32/quickref.html#wlan

[kdschlosser]

One of the things that you need to do is activate the wlan and then you need to check and see if it is connected. The connection is persistent between reboots/crashes when the power is not cut from the ESP32 which is why it is important to check to see if it is connected before attempting to connect.

[gmeader]

Thanks. The code you posted works sometimes or crashes immediately.
I created a file called net.py with the code you posted, with my local SSID and password. I added do_connect() at the bottom of the file to execute the function.
I power-cycle the board, do mpremote to get the REPL and then do import net.
Sometimes I get the ipconfig result showing the IP address. Then after a few seconds it crashes and shows the dump.
It always crashes, sometimes before it displays the IP address, sometimes after (presumably having connected OK)
I'm wondering if you or others get the same result?

[kdschlosser]

I have not personally tested it. If you can decode the backtrace in the crash dump that would help me out to locate where the exact problem is happening.