LVGL micropython API to build the GUI

Mishal_Ferrao · June 30, 2023, 11:11am

I have successfully built the lv_micropython for RP port. I am using a 3.5inch 480x320 display. My next step is to create the GUI in micropython. I am using the online simulator. But how do I access LVGL’s micropython API? I have tried printing help(lvgl) in REPL. It gives a list of all the functions, modules. But I am not able to figure out what are the input arguments to the functions.

amirgon · June 30, 2023, 2:04pm

Since the Micropython API is automatically generated from the C API, you can use the C API as a reference.

Here is a GitHub issue that covers how the Micropython API maps to the C API.
When I have time I’ll turn that into a README or a help page:

github.com/lvgl/lv_binding_micropython

I have some questions about the naming convention used in micropython for lvgl

opened 05:11AM - 20 Dec 22 UTC

kdschlosser

waiting for user input

I am writing a script that reads the documentation files and generates stub file…s. These stub files can then be added to an IDE which would provide type hinting and autocomplete. It would make it a whole lot easier to write code for LVGL. There are no Python source files that can be viewed for lvgl and to be quite honest the documentation for lvgl running in Micropython is a tad on the lacking side of things (trying to be nice). I am confused on things like the enumerations and why they are like this., Using the LV_OBJ_FLAG_* enumerations as an example.. They are enumerations and are defined as ```c enum { LV_OBJ_FLAG_HIDDEN, LV_OBJ_FLAG_CLICKABLE, LV_OBJ_FLAG_CLICK_FOCUSABLE, LV_OBJ_FLAG_CHECKABLE, LV_OBJ_FLAG_SCROLLABLE, LV_OBJ_FLAG_SCROLL_ELASTIC, LV_OBJ_FLAG_SCROLL_MOMENTUM, LV_OBJ_FLAG_SCROLL_ONE, LV_OBJ_FLAG_SCROLL_CHAIN_HOR, LV_OBJ_FLAG_SCROLL_CHAIN_VER, LV_OBJ_FLAG_SCROLL_CHAIN, LV_OBJ_FLAG_SCROLL_ON_FOCUS, LV_OBJ_FLAG_SCROLL_WITH_ARROW, LV_OBJ_FLAG_SNAPPABLE, LV_OBJ_FLAG_PRESS_LOCK, LV_OBJ_FLAG_EVENT_BUBBLE, LV_OBJ_FLAG_GESTURE_BUBBLE, LV_OBJ_FLAG_ADV_HITTEST, LV_OBJ_FLAG_IGNORE_LAYOUT, LV_OBJ_FLAG_FLOATING, LV_OBJ_FLAG_OVERFLOW_VISIBLE, LV_OBJ_FLAG_LAYOUT_1, LV_OBJ_FLAG_LAYOUT_2, LV_OBJ_FLAG_WIDGET_1, LV_OBJ_FLAG_WIDGET_2, LV_OBJ_FLAG_USER_1, LV_OBJ_FLAG_USER_2, LV_OBJ_FLAG_USER_3, LV_OBJ_FLAG_USER_4, }; ``` and when it gets compiled the arrangement of an enumeration follows this kind of Python code ```python class OBJ: """ Make the object hidden. (Like it wasn't there at all) """ class FLAG: # Make the object clickable by the input devices CLICKABLE: int = ... # Toggle checked state when the object is clicked CHECKABLE: int = ... # Make the object scrollable SCROLLABLE: int = ... # If scroll snap is enabled on the parent it can snap to this object SNAPPABLE: int = ... # Do not scroll the object when the parent scrolls and ignore layout FLOATING: int = ... # Custom flag, free to use by layouts LAYOUT_1: int = ... # Custom flag, free to use by layouts LAYOUT_2: int = ... # Custom flag, free to use by widget WIDGET_1: int = ... # Custom flag, free to use by widget WIDGET_2: int = ... # Custom flag, free to use by user USER_1: int = ... # Custom flag, free to use by user USER_2: int = ... # Custom flag, free to use by user USER_3: int = ... # Custom flag, free to use by user USER_4: int = ... class CLICK: # Add focused state to the object when clicked FOCUSABLE: int = ... class SCROLL: # Allow scrolling inside but with slower speed ELASTIC: int = ... # Make the object scroll further when "thrown" MOMENTUM: int = ... # Allow scrolling only one snappable children ONE: int = ... CHAIN: int = ... class CHAIN: # Allow propagating the horizontal scroll to a parent HOR: int = ... # Allow propagating the vertical scroll to a parent VER: int = ... class ON: # Automatically scroll object to make it visible when focused FOCUS: int = ... class WITH: # Allow scrolling the focused object with arrow keys ARROW: int = ... class PRESS: # Keep the object pressed even if the press slid from the object LOCK: int = ... class EVENT: # Propagate the events to the parent too BUBBLE: int = ... class GESTURE: # Propagate the gestures to the parent BUBBLE: int = ... class ADV: # Allow performing more accurate hit (click) test. E.g. consider rounded corners. HITTEST: int = ... class IGNORE: # Make the object position-able by the layouts LAYOUT: int = ... class OVERFLOW: # Do not clip the children's content to the parent's boundary VISIBLE: int = ... ``` and the enumerations are accessed using `OBJ.FLAG.SCROLL.WITH.ARROW` What are the rules for doing this? There are enumerations that have `8BIT` after the last underscore and that would be invalid to use. You also have accessing that enum above is actually `obj.FLAG.SCROLLABLE` and not `OBJ.FLAG.SCROLLABLE` and not all of the enumerations are like that, `ALIGN.CENTER` is an example. I am trying to understand the logic behind the naming convention so I can build the stub file. If I can generate the stub files properly when sphinx can be used to generate documentation for lvgl in Micropython.

Another thing I can suggest is to follow the examples and demos. On the docs you can find a Micropython example next to each C example.

All the examples, C and Python, are under the LVGL repo:

There was also an attempt by @kdschlosser to automatically generate Python docs for Micropython. I’m not sure what is the status of that, in any case, it’s not (yet) a part of the formal LVGL Micropython bindings.

Mishal_Ferrao · July 5, 2023, 9:29am

I am referring the examples from the LVGL repo. I trying to build a GUI from scratch and it needs the montserrat font. I tried loading it this way, (reference )

try:
    font_montserrat_16 = lv.font_load("S:" + script_path + "/../../assets/font/montserrat-16.fnt")
    style_sub.set_text_font(font_montserrat_12,0)            
except:
    print("Cannot load font file montserrat-12.fnt")

Its throwing an exception. I would like to try MIcropython LVGL on a simulator but I think right now the only simulator available is the online simulator for micropython. Please correct me if I am wrong

kdschlosser · July 7, 2023, 4:28am

Oh I can do that super easy. I need to have the JSON output from the code generator be a little more specific on things. Like supplying the fully qualified python name and the LVGL name for each and every single thing that is in the Binding. So class methods would need to point to the LVGL function that is used and each parameter name must point to the parameter in the LVGL function and the type for each parameter needs to point to the ctype for each parameter as well.

I thought I had given you a JSON layout of the information that would be needed. Once That is done I can write the code to handle the documentation generation.