feat: LVGL driver

include/graphics/driver/LGFXDriver.h → include/graphics/LGFX/LGFXDriver.h

@@ -1,5 +1,6 @@
 #pragma once
 
+#ifdef LGFX_DRIVER
 #include "LovyanGFX.h"
 #include "graphics/driver/DisplayDriverConfig.h"
 #include "graphics/driver/TFTDriver.h"
@@ -465,3 +466,5 @@ template <class LGFX> void LGFXDriver<LGFX>::printConfig(void)
         ILOG_DEBUG("BL pin assigned");
     }
 }
+
+#endif

include/graphics/LGFX/LGFX_GENERIC.h

@@ -12,6 +12,7 @@
  * build_flags =
  *  -D LGFX_DRIVER_TEMPLATE
  *  -D LGFX_DRIVER=LGFX_GENERIC
+ *  -D GFX_DRIVER_INC=\"graphics/LGFX/LGFX_GENERIC.h\"
  *  -D LGFX_PANEL=ST7789
  *  -D LGFX_TOUCH=XPT2046
  *  -D LGFX_INVERT_COLOR=true
@@ -30,6 +31,8 @@
  */
 
 #define LGFX_USE_V1
+#include "hal/gpio_types.h"
+#include "util/ILog.h"
 #include <LovyanGFX.hpp>
 
 #ifndef SPI_FREQUENCY
@@ -206,6 +209,20 @@ class LGFX_GENERIC : public lgfx::LGFX_Device
 
     bool hasButton(void) { return false; }
 
+    bool init_impl(bool use_reset, bool use_clear) override
+    {
+        // increase output power to SPI GPIOs to be able to run with higher frequency
+        if (LGFX_PIN_SCK >= 0) {
+            gpio_set_direction((gpio_num_t)LGFX_PIN_SCK, GPIO_MODE_OUTPUT);
+            gpio_set_drive_capability((gpio_num_t)LGFX_PIN_SCK, GPIO_DRIVE_CAP_3);
+        }
+        if (LGFX_PIN_MOSI >= 0) {
+            gpio_set_direction((gpio_num_t)LGFX_PIN_SCK, GPIO_MODE_OUTPUT);
+            gpio_set_drive_capability((gpio_num_t)LGFX_PIN_MOSI, GPIO_DRIVE_CAP_3);
+        }
+        return lgfx::LGFX_Device::init_impl(use_reset, use_clear);
+    }
+
     LGFX_GENERIC(void)
     {
         {

include/graphics/LVGL/LVGLConfig.h

@@ -0,0 +1,41 @@
+#pragma once
+
+#include "graphics/LVGL/LVGLDriver.h"
+#include "graphics/LVGL/LVGLSpiBusDriver.h"
+#include "graphics/driver/DisplayDriverConfig.h"
+#include "lvgl.h"
+#include "strings.h"
+#include "util/ILog.h"
+
+class DisplayDeviceDriver;
+
+/**
+ * @brief Runtime configuration class for lvgl driver
+ *
+ */
+class LVGLConfig
+{
+  public:
+    uint16_t screenWidth = 0;
+    uint16_t screenHeight = 0;
+
+    LVGLConfig(void);
+    LVGLConfig(const DisplayDriverConfig &cfg);
+    void init(void);
+    lv_display_t *create(uint32_t hor_res, uint32_t ver_res);
+    void touchpad_read(lv_indev_t *indev_driver, lv_indev_data_t *data);
+
+    bool hasButton(void);
+    bool hasTouch(void);
+    bool light(void);
+
+    uint8_t getBrightness(void);
+    void setBrightness(uint8_t setBrightness);
+
+    ~LVGLConfig();
+
+  protected:
+  private:
+    const DisplayDriverConfig *config;
+    DisplayDeviceDriver *lvglDeviceDriver;
+};

include/graphics/LVGL/LVGLDriver.h

@@ -0,0 +1,130 @@
+#pragma once
+
+#ifdef LVGL_DRIVER
+#include "drivers/display/lcd/lv_lcd_generic_mipi.h"
+#include "graphics/driver/DisplayDriverConfig.h"
+#include "graphics/driver/TFTDriver.h"
+#include "input/InputDriver.h"
+#include "util/ILog.h"
+
+/**
+ * Base class for all specific LVGL drivers classes
+ */
+template <class LVGL> class LVGLDriver : public TFTDriver<LVGL>
+{
+  public:
+    const uint32_t defaultScreenTimeout = 60 * 1000;
+    const uint32_t defaultScreenLockTimeout = 5 * 1000;
+    const uint32_t defaultBrightness = 153;
+
+    LVGLDriver(uint16_t width, uint16_t height);
+    LVGLDriver(const DisplayDriverConfig &cfg);
+    void init(DeviceGUI *gui) override;
+    bool hasTouch(void) override;
+    bool hasButton(void) override { return lvgldriver->hasButton(); }
+    bool hasLight(void) override { return lvgldriver->light(); }
+    bool isPowersaving(void) override { return powerSaving; }
+    void task_handler(void) override;
+
+    uint8_t getBrightness(void) override { return lvgldriver->getBrightness(); }
+    void setBrightness(uint8_t brightness) override {} // TODO
+
+    uint16_t getScreenTimeout() override { return screenTimeout / 1000; }
+    void setScreenTimeout(uint16_t timeout) override { screenTimeout = timeout * 1000; };
+
+    ~LVGLDriver() { delete lvgldriver; }
+
+  protected:
+    void init_lvgl(void);
+    static void touchpad_read(lv_indev_t *indev_driver, lv_indev_data_t *data)
+    {
+        return lvgldriver->touchpad_read(indev_driver, data);
+    }
+
+    uint32_t screenTimeout;
+    uint32_t lastBrightness;
+    bool powerSaving;
+
+  private:
+    static LVGL *lvgldriver;
+    lv_display_t *display;
+    size_t bufsize;
+    std::pair<lv_color_t *, lv_color_t *> drawBuffer = {nullptr, nullptr};
+};
+
+template <class LVGL> LVGL *LVGLDriver<LVGL>::lvgldriver = nullptr;
+
+template <class LVGL>
+LVGLDriver<LVGL>::LVGLDriver(uint16_t width, uint16_t height)
+    : TFTDriver<LVGL>(lvgldriver ? lvgldriver : new LVGL, width, height), screenTimeout(defaultScreenTimeout),
+      lastBrightness(defaultBrightness), powerSaving(false), display(nullptr), bufsize(0)
+{
+    lvgldriver = this->tft;
+}
+
+template <class LVGL>
+LVGLDriver<LVGL>::LVGLDriver(const DisplayDriverConfig &cfg)
+    : TFTDriver<LVGL>(lvgldriver ? lvgldriver : new LVGL(cfg), cfg.width(), cfg.height()), screenTimeout(defaultScreenTimeout),
+      lastBrightness(defaultBrightness), powerSaving(false), display(nullptr), bufsize(0)
+{
+    lvgldriver = this->tft;
+}
+
+template <class LVGL> void LVGLDriver<LVGL>::init(DeviceGUI *gui)
+{
+    ILOG_DEBUG("LVGLDriver<LVGL>::init...");
+    init_lvgl();
+    TFTDriver<LVGL>::init(gui);
+
+    // LVGL: setup display device driver
+    ILOG_DEBUG("LVGL display driver create...");
+    display = lvgldriver->create(DisplayDriver::screenWidth, DisplayDriver::screenHeight);
+
+    std::pair<lv_color_t *, lv_color_t *> draw_buffers = {nullptr, nullptr};
+    const auto buffer_size =
+        DisplayDriver::screenWidth * DisplayDriver::screenHeight * lv_color_format_get_size(lv_display_get_color_format(display));
+
+    ILOG_INFO("allocating %d bytes for LVGL draw buffers", buffer_size);
+    // ESP_ERROR_CHECK(esp_dma_malloc(EXAMPLE_LCD_H_RES * 100 * sizeof(lv_color_t), ESP_DMA_MALLOC_FLAG_PSRAM, draw_buffers.first,
+    // nullptr)); ESP_ERROR_CHECK(esp_dma_malloc(EXAMPLE_LCD_H_RES * 100 * sizeof(lv_color_t), ESP_DMA_MALLOC_FLAG_PSRAM,
+    // draw_buffers.second, nullptr));
+
+    draw_buffers.first = (lv_color_t *)lv_malloc(buffer_size);
+    if (draw_buffers.first == nullptr) {
+        LV_LOG_ERROR("display draw buffer malloc failed");
+        return;
+    }
+
+    draw_buffers.second = (lv_color_t *)lv_malloc(buffer_size);
+    if (draw_buffers.second == nullptr) {
+        LV_LOG_ERROR("display buffer malloc failed");
+        lv_free(draw_buffers.first);
+        return;
+    }
+    lv_display_set_buffers(display, draw_buffers.first, draw_buffers.second, buffer_size, LV_DISPLAY_RENDER_MODE_PARTIAL);
+
+    if (hasTouch()) {
+        lv_indev_t *indev = lv_indev_create();
+        lv_indev_set_type(indev, LV_INDEV_TYPE_POINTER);
+        lv_indev_set_read_cb(indev, touchpad_read);
+        lv_indev_set_display(indev, this->display);
+    }
+}
+
+template <class LGFX> void LVGLDriver<LGFX>::init_lvgl(void)
+{
+    lvgldriver->init();
+    lvgldriver->setBrightness(defaultBrightness);
+    // lvgldriver->fillScreen(LGFX::color565(0x3D, 0xDA, 0x83));
+}
+
+template <class LGFX> bool LVGLDriver<LGFX>::hasTouch(void)
+{
+    return lvgldriver->hasTouch();
+}
+
+template <class LGFX> void LVGLDriver<LGFX>::task_handler(void)
+{
+    DisplayDriver::task_handler();
+}
+#endif

include/graphics/LVGL/LVGLSpiBusDriver.h

@@ -0,0 +1,50 @@
+#pragma once
+
+#ifdef LVGL_DRIVER
+
+#include "SPI.h"
+#include "drivers/display/lcd/lv_lcd_generic_mipi.h"
+#include "graphics/driver/DisplayDeviceDriver.h"
+#include "graphics/driver/DisplayDriverConfig.h"
+#include <functional>
+
+class LVGLSpiBusDriver
+{
+  public:
+    using CreateCB =
+        std::function<lv_display_t *(uint32_t, uint32_t, lv_lcd_flag_t, lv_lcd_send_cmd_cb_t, lv_lcd_send_color_cb_t)>;
+
+    LVGLSpiBusDriver(uint16_t width, uint16_t height, CreateCB createDisplayFunc);
+    void init(int16_t spiBus, int16_t sclk, int16_t mosi, int16_t miso, int16_t dc, int16_t rst, int16_t cs);
+    lv_display_t *create(uint32_t hor_res, uint32_t ver_res);
+    virtual ~LVGLSpiBusDriver()
+    {
+        if (spi)
+            delete spi;
+    }
+
+  protected:
+    LVGLSpiBusDriver() = default;
+    virtual void connect(void);
+
+  private:
+    LVGLSpiBusDriver(const LVGLSpiBusDriver &) = delete;
+    LVGLSpiBusDriver &operator=(const LVGLSpiBusDriver &) = delete;
+
+    static void lcd_send_cmd_cb(lv_display_t *disp, const uint8_t *cmd, size_t cmd_size, const uint8_t *param, size_t param_size);
+    static void lcd_send_color_cb(lv_display_t *disp, const uint8_t *cmd, size_t cmd_size, uint8_t *param, size_t param_size);
+
+    int8_t rst;
+    int8_t dc;
+    int8_t cs;
+    int8_t sclk;
+    int8_t mosi;
+    int8_t miso;
+    int8_t spiBus;
+    SPISettings spiSettings;
+    static SPIClass *spi;
+    static LVGLSpiBusDriver *instance;
+    CreateCB createDisplay;
+};
+
+#endif

include/graphics/LVGL/LVGL_T_DECK.h

@@ -0,0 +1,35 @@
+#pragma once
+
+#ifdef LVGL_DRIVER
+
+#include "graphics/driver/LVGL_ST7789.h"
+#include "lvgl.h"
+#include "stdint.h"
+
+class LVGLSpiBusDriver;
+
+class LVGL_TDECK : public LVGL_ST7789
+{
+  public:
+    static constexpr uint16_t c_screenWidth = 320;
+    static constexpr uint16_t c_screenHeight = 240;
+
+    LVGL_TDECK(void);
+    LVGL_TDECK(const DisplayDriverConfig &cfg);
+
+    void init(void) override;
+    bool hasButton(void) const override { return true; }
+    bool hasTouch(void) const override { return true; }
+    bool light(void) override { return true; }
+    uint8_t getBrightness(void) const override { return 150; }
+    void setBrightness(uint8_t setBrightness) override {}
+
+    void touchpad_read(lv_indev_t *indev_driver, lv_indev_data_t *data);
+
+    ~LVGL_TDECK() {}
+
+  protected:
+  private:
+};
+
+#endif

include/graphics/driver/DisplayDeviceDriver.h

@@ -0,0 +1,36 @@
+#pragma once
+
+#include "lvgl.h"
+#include "stdint.h"
+
+/**
+ * Base class for all implemented display device drivers
+ */
+class DisplayDeviceDriver
+{
+  public:
+    DisplayDeviceDriver(uint16_t width, uint16_t height) : screenWidth(width), screenHeight(height){};
+
+    virtual void init(void) {}
+    virtual lv_display_t *create(uint32_t hor_res, uint32_t ver_res) = 0;
+
+    virtual uint8_t getBrightness(void) const { return 128; }
+    virtual void setBrightness(uint8_t brightness) {}
+
+    virtual uint16_t getScreenTimeout() const { return 0; }
+    virtual void setScreenTimeout(uint16_t timeout) {}
+
+    virtual bool hasButton(void) const { return false; }
+    virtual bool hasTouch(void) const { return false; }
+    virtual bool light(void) { return false; }
+
+    virtual ~DisplayDeviceDriver(){};
+
+  protected:
+    const uint16_t screenWidth;
+    const uint16_t screenHeight;
+
+  private:
+    DisplayDeviceDriver(const DisplayDeviceDriver &) = delete;
+    DisplayDeviceDriver &operator=(const DisplayDeviceDriver &) = delete;
+};

include/graphics/driver/DisplayDriverConfig.h

@@ -15,6 +15,8 @@ class DisplayDriver;
 class DisplayDriverConfig
 {
   public:
+    enum struct driver_t { LGFX, LVGL, ADAFRUIT, OTHER };
+
     enum struct device_t {
         NONE,
         CUSTOM_TFT,
@@ -40,6 +42,7 @@ class DisplayDriverConfig
 
     struct panel_config_t {
         char *type = nullptr;
+        driver_t driver = driver_t::LGFX;
         uint16_t panel_width = 0;
         uint16_t panel_height = 0;
         bool rotation = false;
@@ -166,6 +169,7 @@ class DisplayDriverConfig
   private:
     friend class DisplayDriverFactory;
     friend class LGFXConfig;
+    friend class LVGLConfig;
 
     enum device_t _device;
     panel_config_t _panel;