You signed in with another tab or window.Reload to refresh your session.You signed out in another tab or window.Reload to refresh your session.You switched accounts on another tab or window.Reload to refresh your session.Dismiss alert
Thempy_cross build command has been removed. It will be compiled automatically if it has not been compiled yet.
Thesubmodules build command has been removed. The build script takes care of this for you automatically.
Theclean command has changed behavior. All ports are cleaned prior to a build using makefile's clean routine.There are occasions where something gets stuck and the clean is not completed. That is where this command comes in. This wil do a completewipe of the micropython build folders no matter what is in them. On theunix andmacos ports using this command will removethe SDL2 compilation. the clean that gets performed prior to every build will not.
LVGL binding for Micropython
I have tried to make this as simple as possible for paople to use.There are some glitches still in it I am sure. If you come across an issueplease let me know.
I am still in development mode for the unix port. I am writing an SDL driverthat conforms To the rest of the driver framework. I have started working onwriting the frameworks for the different indev (input) types that LVGL supports.The frameworks are written to make it easier to write display and input driversfor the binding.
Supported displays and touch interfaces
Supported Display IC's
GC9A01
HX8357B
HX8357D
ILI9163
ILI9225
ILI9341
ILI9481
ILI9486
ILI9488
LT768x *WIP*
R61581
RA8876 *WIP*
RM68120
RM68140
S6D02A1
SSD1351
SSD1963_480
SSD1963_800
SSD1963_800ALT
SSD1963_800BD
ST7701S *WIP*
ST7735B
ST7735R_Red
ST7735R_Green
ST7789
ST7796
Supported Touch IC's
CST816S
FT5x06
FT5x16
FT5x26
FT5x36
FT5x46
FT6x06
FT6x36
GT911
STMPE610
XPT2046
Special use drivers
SDL2 *Only for the unix and macOS ports*
New changes
ALL MCU'sI have started to nail down a commoin API for the indev drivers, specifically the pointer/touch drivers.In order to do this I had to change the handling of the type of bus being used. Just like the displays thetouch/pointer driver IC's can sometimes accept an SPI bus or an I2C bus as the way to communicate.Instead of having to duplicate code for these driver IC's I decided to make the software driver completelyunaware of the bus that is being used. To do this i made the I2C driver work in the same manner as the SPI driver.
Here is a code example of how to use the I2C bus with a touch driver.
If a touch driver doesn't have the variableI2C_ADDR orBITS then that driverdoesn't support the I2C bus.
ESP32-ALL
--optimize-size: If you are having an issue with getting the firmware to fit into your esp32or if space is more of a concern than speed you can set this command line option. This will tell the compiler that thefirmware size is more important than performance and the compiled binary will be smaller as a result.
--flash-size={size}: Flash sizes that are able to be used are 4, 8, 16, 32, 64 and 128 across allvariants of the ESP32. It is up to the user to know what their board is using.
--ota: If you want to set the partitions so you can do an over the air update ofthe firmware. I do want to note that this does take up twice as much applicationstorage space. This feature applies to any board.
CONFIG_*={value}: You can alter the config settings of the esp-idf by using these settings. Refer to the ESP-IDF documentationfor further information
SPI: Themachine.SPI class has undergone a HUGE change. It is now split into 2 pieces.machine.SPI.Bus andmachine.SPI.DeviceThey exactly what they seem. It is easier to show a code example then it is to explain it.
from machine import SPIspi_bus = SPI.Bus( host=1, mosi=15, miso=16, sck=10)spi_device = SPI.Device( spi_bus=spi_bus, freq=10000000, cs=3, polarity=0, phase=0, bits=8, first_bit=SPI.MSB)# if you want to delete a device from being used you have to deinit it first# and then you can delete itspi_device.deinit()del spi_device# if you want to stop using a bus and all devices attached to itdel spi_busdel spi_device# The SPI.Bus instance you need to pass to machine.SDCard, lcd_bus.SPIBus# and any of the touch drivers that use SPI.
All methods that existed for the originalmachine.SPI are available inthemachine.SPI.Device class. They work exactly how they did before.
Confirmed working
Display Bus
ESP32 SPI
ESP32 RGB
ESP32 I8080
Memory
SRAM
SRAM DMA
PSRAM (SPIRAM)
PSRAM (SPIRAM) DMA
Display IC
ST7796
ST7789
ILI9341
SDL
RGB
ILI9488
Touch IC
XPT2046
GT911
Mouse
FT6x06
FT5x06
Build Instructions
I have changed the design of the binding so it is no longer a dependancy ofMicroPython. Instead MicroPython is now a dependency of the binding. By doingthis I have simplified the process up updating the MicroPython version. Onlysmall changes are now needed to support newer versions of MicroPython.
In order to make this all work I have written a Python script that handlesBuilding the binding. The only prerequesits are that you have a C compilerinstalled (gcc, clang, msvc) and the necessary support libs.
Requirements
compiling for ESP32
Ubuntu (Linux): you can install all of these usingapt-get install
build-essential
cmake
ninja-build
python
macOS
xcode-select -–install
brew install cmake
brew install ninja
brew install python
Compiling for RP2
Ubuntu (Linux): you can install all of these usingapt-get install
build-essential
cmake
ninja-build
python
gcc-arm-none-eabi
libnewlib-arm-none-eabi
macOS
command xcode-select–install
brew install make
brew install cmake
brew install ninja
brew install python
brew install armmbed/formulae/arm-none-eabi-gcc
Windows
Not yet supported
Compiling for STM32:
Ubuntu (Linux): you can install all of these usingapt-get install
gcc-arm-none-eabi
libnewlib-arm-none-eabi: maybe??
build-essential
ninja-build
python
macOS
command xcode-select–install
brew install make
brew install ninja
brew install python
brew install armmbed/formulae/arm-none-eabi-gcc
Windows
Not yet supported
Compiling for Ubuntu (Linux): you can install all of these usingapt-get install
build-essential
libffi-dev
pkg-config
cmake
ninja-build
gnome-desktop-testing
libasound2-dev
libpulse-dev
libaudio-dev
libjack-dev
libsndio-dev
libx11-dev
libxext-dev
libxrandr-dev
libxcursor-dev
libxfixes-dev
libxi-dev
libxss-dev
libxkbcommon-dev
libdrm-dev
libgbm-dev
libgl1-mesa-dev
libgles2-mesa-dev
libegl1-mesa-dev
libdbus-1-dev
libibus-1.0-dev
libudev-dev
fcitx-libs-dev
libpipewire-0.3-dev
libwayland-dev
libdecor-0-dev
Compiling for macOS
command xcode-select–install
brew install libffi
brew install ninja
brew install make
Compiling for Windows
not supported yet
Build Target
You are also going to need Python >= 3.10 installed for all builds
There is a single entry point for all builds. That is the make.py script in theroot of the repository.
The first argument is positional and it must be one of the following.
esp32
windows
macOS
stm32
unix
rp2
renesas-ra
nrf
mimxrt
samd
Build Options
The next few arguments are optional to some degree.
submodules**: collects all needed dependencies to perform the build
clean: cleans the build environment
mpy_cross**: compiles mpy-crossthis is not used for all builds. if it is not supported it will do nothing.
**must be run only one time when the build is intially started. after that you will not needto add these arguments. There is internal checking that is done to see if the argument needs tobe carried out. So you can also optionally leave it there if you want.
Identifying the MCU board
The next group of options are going to be port specific, some may have them and some may not.
BOARD: The MCU to build for. This follows the same symantics as what MIcroPython uses.
BOARD_VARIANT: if there is a variation of the board that it to be compiled for.
I will go into specifics for what what boards and variants are available for a specific port alittle bit further down.
Additional Arguments
LV_CFLAGS: additional compiler flags that get passed to the LVGL build only.
FROZEN_MANIFEST: path to a custom frozen manifest file
DISPLAY: this can either be the file name (less the .py) of a displaydriver that is in the driver/display folder or it can be the absolutepath to your own custom driver (with the .py extension)
INDEV: this can either be the file name (less the .py) of an indevdriver that is in the driver/indev folder or it can be the absolutepath to your own custom driver (with the .py extension)
ESP32 specific options
--skip-partition-resize: do not resize the firmware partition
--partition-size: set a custom firmware partition size
--octal-flash ¹: This is only available for the 16mb flash and the 32mb flash
--flash-size ² ³: This is how much flash storage is available.
Allowed Values are:
ESP32-S3: 4, 8, 16 and 32 (default is 8)
ESP32-S2: 2 and 4 (default is 4)
ESP32: 4, 8 and 16 (default is 4), The default is 8.
¹ Available for the ESP32-S3 whenBOARD_VARIANT is set toSPIRAM_OCT ² Available for the ESP32, ESP32-S2 and ESP32-S3 ³ Available only whenBOARD_VARIANT is set toSPIRAM orSPIRAM_OCT
I always recommend building with the clean command, this will ensure you get a good fresh build.
I will provide directions on how to use the driver framework and also the drivers that are includedwith the binding in the coming weeks.
SDL fpr Unix is working properly. Make sure you review the requirements needed to compile for unix!!!The build system compiles the latest version of SDL2 so the list is pretty long for the requirements.
DO NOT enable LV_USE_DRAW_SDL, I have not written code to allow for it's use (yet).
I recommend runninglv.task_handler once every 5 milliseconds, shorter than that and youwill have a lot of CPU time comsumed. Longer than that and your mouse response is notgoing to be great.
Here is some example code for the unix port
from micropython import const # NOQA_WIDTH = const(480)_HEIGHT = const(320)_BUFFER_SIZE = _WIDTH * _HEIGHT * 3import lcd_bus # NOQAbus = lcd_bus.SDLBus(flags=0)buf1 = bus.allocate_framebuffer(_BUFFER_SIZE, 0)import lvgl as lv # NOQAimport sdl_display # NOQAlv.init()display = sdl_display.SDLDisplay( data_bus=bus, display_width=_WIDTH, display_height=_HEIGHT, frame_buffer1=buf1, color_space=lv.COLOR_FORMAT.RGB888)display.init()import sdl_pointermouse = sdl_pointer.SDLPointer()scrn = lv.screen_active()scrn.set_style_bg_color(lv.color_hex(0x000000), 0)slider = lv.slider(scrn)slider.set_size(300, 25)slider.center()import task_handler# the duration needs to be set to 5 to have a good response from the mouse.# There is a thread that runs that facilitates double buffering. th = task_handler.TaskHandler(duration=5)
The touch screen drivers will handle the rotation that you set to the display.There is a single caviat to this. You MUST set up and initilize the display thencreate the touch drivers and after that has been done you can set the rotation.The touch driver must exist prior to the display rotation being set.
For the ESP32 SOC's there is NVRAM that is available to store data in. Thatdata is persistant between restarts of the ESP32. This feature is pur to use tostore calibration data for the touch screen. In the exmaple below it shows howto properly create a display driver and touch driver and how to set the rotationand also the calibration storage.
You are able to force the calibration at any time by callingindev.calibrate()regardless of whatindev.is_calibrate returns. This makes it possible to redothe calibration by either using a pin that you can check the state of or througha button in your UI that you provide to the user.
Thank again and enjoy!!
NOTE: On ESP32-S3, SPI host 0 and SPI host 1 share a common SPI bus.The main Flash and PSRAM are connected to the host 0. It is recommended to useSPI host 2 when connecting an SPI device like a display that is going to utilizethe PSRAM for the frame buffer.
Bit orders are a tuple of durations. The first 2 numbers define a bit as 0 and the second 2 define a bit as 1. Negitive numbers are the duration to hold low and positive are for how long to hold high"Res" or "Reset" is sent at the end of the data.