Update LVGL to v9.1.0

4 files changed, 224 insertions, 0 deletions

diff --git a/lib/lvgl/docs/integration/framework/arduino.rst b/lib/lvgl/docs/integration/framework/arduino.rst
new file mode 100644
index 00000000..95c86e40
--- /dev/null
+++ b/lib/lvgl/docs/integration/framework/arduino.rst
@@ -0,0 +1,103 @@
+=======
+Arduino
+=======
+
+The `LVGL library <https://github.com/lvgl/lvgl>`__ is directly available as Arduino libraries.
+
+Note that you need to choose a board powerful enough to run LVGL and
+your GUI. See the `requirements of LVGL <https://docs.lvgl.io/master/intro/index.html#requirements>`__.
+
+For example ESP32 is a good candidate to create UI's with LVGL.
+
+Get the LVGL Arduino library
+----------------------------
+
+LVGL can be installed via the Arduino IDE Library Manager or as a .ZIP library.
+
+You can `Download <https://github.com/lvgl/lvgl/archive/refs/heads/master.zip>`__
+the latest version of LVGL from GitHub and simply copy it to Arduino's
+library folder.
+
+Set up drivers
+--------------
+
+To get started it's recommended to use `TFT_eSPI <https://github.com/Bodmer/TFT_eSPI>`__ library as a TFT
+driver to simplify testing. To make it work, setup ``TFT_eSPI``
+according to your TFT display type via editing either:
+
+- ``User_Setup.h``
+- or by selecting a configuration in the ``User_Setup_Select.h``
+
+Both files are located in ``TFT_eSPI`` library's folder.
+
+
+Configure LVGL
+--------------
+
+LVGL has its own configuration file called ``lv_conf.h``. When LVGL is
+installed, follow these configuration steps:
+
+1. Go to the directory of the installed Arduino libraries
+2. Go to ``lvgl`` and copy ``lv_conf_template.h`` as ``lv_conf.h`` into the Arduino Libraries directory next to the ``lvgl`` library folder.
+3. Open ``lv_conf.h`` and change the first ``#if 0`` to ``#if 1`` to enable the content of the file
+4. Set the color depth of you display in :c:macro:`LV_COLOR_DEPTH`
+
+Finally the layout with ``lv_conf.h`` should look like this:
+
+::
+
+   arduino
+    |-libraries
+      |-lvgl
+      |-other_lib_1
+      |-other_lib_2
+      |-lv_conf.h
+
+
+Initialize and run LVGL
+-----------------------
+
+Take a look at `LVGL_Arduino.ino <https://github.com/lvgl/lvgl/blob/master/examples/arduino/LVGL_Arduino/LVGL_Arduino.ino>`__
+to see how to initialize LVGL. ``TFT_eSPI`` is used as the display driver.
+
+In the INO file you can see how to register a display and a touchpad for
+LVGL and call an example.
+
+
+Use the examples and demos
+--------------------------
+
+Note that, there is no dedicated INO file for every example. Instead,
+you can load an example by calling an ``lv_example_...`` function. For
+example :cpp:func:`lv_example_btn_1`.
+
+:important: Due to some the limitations of Arduino's build system you
+            need to copy ``lvgl/examples`` to ``lvgl/src/examples``. Similarly for
+            the demos ``lvgl/demos`` to ``lvgl/src/demos``.
+
+
+Debugging and logging
+---------------------
+
+LVGL can display debug information in case of trouble. In the
+``LVGL_Arduino.ino`` example there is a ``my_print`` method, which sends
+this debug information to the serial interface. To enable this feature
+you have to edit the ``lv_conf.h`` file and enable logging in the
+section ``log settings``:
+
+.. code:: c
+
+   /*Log settings*/
+   #define USE_LV_LOG      1   /*Enable/disable the log module*/
+   #if LV_USE_LOG
+   /* How important log should be added:
+    * LV_LOG_LEVEL_TRACE       A lot of logs to give detailed information
+    * LV_LOG_LEVEL_INFO        Log important events
+    * LV_LOG_LEVEL_WARN        Log if something unwanted happened but didn't cause a problem
+    * LV_LOG_LEVEL_ERROR       Only critical issue, when the system may fail
+    * LV_LOG_LEVEL_NONE        Do not log anything
+    */
+   #  define LV_LOG_LEVEL    LV_LOG_LEVEL_WARN
+
+After enabling the log module and setting :c:macro:`LV_LOG_LEVEL` accordingly, the
+output log is sent to the ``Serial`` port @ 115200 bps.
diff --git a/lib/lvgl/docs/integration/framework/index.rst b/lib/lvgl/docs/integration/framework/index.rst
new file mode 100644
index 00000000..ca642818
--- /dev/null
+++ b/lib/lvgl/docs/integration/framework/index.rst
@@ -0,0 +1,11 @@
+==========
+Frameworks
+==========
+
+.. toctree::
+    :maxdepth: 2
+
+    arduino
+    platformio
+    tasmota-berry
+
diff --git a/lib/lvgl/docs/integration/framework/platformio.rst b/lib/lvgl/docs/integration/framework/platformio.rst
new file mode 100644
index 00000000..48c5534a
--- /dev/null
+++ b/lib/lvgl/docs/integration/framework/platformio.rst
@@ -0,0 +1,5 @@
+==========
+Platformio
+==========
+
+TODO
diff --git a/lib/lvgl/docs/integration/framework/tasmota-berry.rst b/lib/lvgl/docs/integration/framework/tasmota-berry.rst
new file mode 100644
index 00000000..1072b232
--- /dev/null
+++ b/lib/lvgl/docs/integration/framework/tasmota-berry.rst
@@ -0,0 +1,105 @@
+=================
+Tasmota and berry
+=================
+
+What is Tasmota?
+----------------
+
+`Tasmota <https://github.com/arendst/Tasmota>`__ is a widely used
+open-source firmware for ESP8266 and EPS32 based devices. It supports a
+wide variety of devices, sensors and integrations to Home Automation and
+Cloud services. Tasmota firmware is downloaded more than 200,000 times
+each month, and has an active and growing community.
+
+Tasmota provides access to hundreds of supported devices, full support
+of MQTT, HTTP(S), integration with major Home Automation systems, myriad
+of sensors, IR, RF, Zigbee, Bluetooth, AWS IoT, Azure IoT, Alexa and
+many more.
+
+What is Berry?
+--------------
+
+`Berry <https://github.com/berry-lang/berry>`__ is a ultra-lightweight
+dynamically typed embedded scripting language. It is designed for
+lower-performance embedded devices. The interpreter of Berry include a
+one-pass compiler and register-based VM, all the code is written in ANSI
+C99. Berry offers a syntax very similar to Python, and is inspired from
+LUA VM. It is fully integrated in Tasmota
+
+Highlights of Berry
+~~~~~~~~~~~~~~~~~~~
+
+Berry has the following advantages:
+
+- Lightweight: A well-optimized interpreter with very little resources. Ideal for use in microprocessors.
+- Fast: optimized one-pass bytecode compiler and register-based virtual machine.
+- Powerful: supports imperative programming, object-oriented programming, functional programming.
+- Flexible: Berry is a dynamic type script, and it's intended for embedding in applications.
+  It can provide good dynamic scalability for the host system.
+- Simple: simple and natural syntax, support garbage collection, and easy to use FFI (foreign function interface).
+- RAM saving: With compile-time object construction, most of the constant objects are stored
+  in read-only code data segments, so the RAM usage of the interpreter is very low when it starts.
+
+All features are detailed in the `Berry Reference Manual <https://github.com/berry-lang/berry/wiki/Reference>`__
+
+--------------
+
+Why LVGL + Tasmota + Berry?
+---------------------------
+
+In 2021, Tasmota added full support of LVGL for ESP32 based devices. It
+also introduced the Berry scripting language, a small-footprint language
+similar to Python and fully integrated in Tasmota.
+
+A comprehensive mapping of LVGL in Berry language is now available,
+similar to the mapping of Micropython. It allows to use +98% of all LVGL
+features. It is also possible to write custom widgets in Berry.
+
+Versions supported: LVGL v8.0.2, LodePNG v20201017, Freetype 2.10.4
+
+Tasmota + Berry + LVGL could be used for:
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+- Fast prototyping GUI.
+- Shortening the cycle of changing and fine-tuning the GUI.
+- Modelling the GUI in a more abstract way by defining reusable composite objects, taking
+  advantage of Berry's language features such as Inheritance, Closures, Exception Handling…
+- Make LVGL accessible to a larger audience. No need to know C to create a nice GUI on an embedded system.
+
+A higher level interface compatible with
+`OpenHASP <https://github.com/HASwitchPlate/openHASP>`__
+is also under development.
+
+--------------
+
+So what does it look like?
+--------------------------
+
+TL;DR: Similar to MicroPython, it's very much like the C API, but Object-Oriented for LVGL components.
+
+Let's dive right into an example!
+
+A simple example
+~~~~~~~~~~~~~~~~
+
+.. code:: python
+
+   lv.start()                 # start LVGL
+   scr = lv.screen_active()         # get default screen
+   btn = lv.btn(scr)          # create button
+   btn.center()
+   label = lv.label(btn)      # create a label in the button
+   label.set_text("Button")   # set a label to the button
+
+How can I use it?
+-----------------
+
+You can start in less than 10 minutes on a M5Stack or equivalent device
+in less than 10 minutes in this `short tutorial <https://tasmota.github.io/docs/LVGL_in_10_minutes/>`__
+
+Where can I find more information?
+----------------------------------
+
+- `Tasmota Documentation <https://tasmota.github.io/docs/>`__
+- `Berry Documentation <https://github.com/berry-lang/berry/wiki/Reference>`__
+- `Tasmota LVGL Berry documentation <https://tasmota.github.io/docs/LVGL/>`__