Board update

Boards/ElecrowCrowpanelAdvance28/CMakeLists.txt

@@ -3,5 +3,5 @@ file(GLOB_RECURSE SOURCE_FILES Source/*.c*)
 idf_component_register(
     SRCS ${SOURCE_FILES}
     INCLUDE_DIRS "Source"
-    REQUIRES Tactility esp_lvgl_port FT5x06 ST7789 PwmBacklight driver
+    REQUIRES Tactility FT5x06 ST7789 PwmBacklight driver
 )

Boards/ElecrowCrowpanelAdvance28/Source/hal/CrowPanelDisplay.cpp

@@ -5,8 +5,6 @@
 #include <PwmBacklight.h>
 #include <St7789Display.h>
 
-#define TAG "crowpanel_display"
-
 static std::shared_ptr<tt::hal::touch::TouchDevice> createTouch() {
     // Note for future changes: Reset pin is 48 and interrupt pin is 47
     auto configuration = std::make_unique<Ft5x06Touch::Configuration>(
@@ -39,5 +37,6 @@ std::shared_ptr<tt::hal::display::DisplayDevice> createDisplay() {
 
     configuration->backlightDutyFunction = driver::pwmbacklight::setBacklightDuty;
 
-    return std::make_shared<St7789Display>(std::move(configuration));
+    auto display = std::make_shared<St7789Display>(std::move(configuration));
+    return std::reinterpret_pointer_cast<tt::hal::display::DisplayDevice>(display);
 }

Boards/ElecrowCrowpanelAdvance28/Source/hal/CrowPanelDisplay.h

@@ -1,40 +1,5 @@
 #pragma once
 
-#include "Tactility/hal/display/DisplayDevice.h"
-#include <esp_lcd_types.h>
-#include <lvgl.h>
-
-class CrowPanelDisplay : public tt::hal::display::DisplayDevice {
-
-private:
-
-    esp_lcd_panel_io_handle_t ioHandle = nullptr;
-    esp_lcd_panel_handle_t panelHandle = nullptr;
-    lv_display_t* displayHandle = nullptr;
-    bool poweredOn = false;
-
-public:
-
-    std::string getName() const final { return "ST7789"; }
-    std::string getDescription() const final { return "SPI display"; }
-
-    bool start() override;
-
-    bool stop() override;
-
-    void setPowerOn(bool turnOn) override;
-    bool isPoweredOn() const override { return poweredOn; };
-    bool supportsPowerControl() const override { return true; }
-
-    std::shared_ptr<tt::hal::touch::TouchDevice> _Nullable createTouch() override;
-
-    void setBacklightDuty(uint8_t backlightDuty) override;
-    bool supportsBacklightDuty() const override { return true; }
-
-    void setGammaCurve(uint8_t index) override;
-    uint8_t getGammaCurveCount() const override { return 4; };
-
-    lv_display_t* _Nullable getLvglDisplay() const override { return displayHandle; }
-};
+#include <Tactility/hal/display/DisplayDevice.h>
 
 std::shared_ptr<tt::hal::display::DisplayDevice> createDisplay();

Boards/ElecrowCrowpanelAdvance35/Source/hal/CrowPanelDisplay.cpp

@@ -36,5 +36,6 @@ std::shared_ptr<tt::hal::display::DisplayDevice> createDisplay() {
 
     configuration->backlightDutyFunction = driver::pwmbacklight::setBacklightDuty;
 
-    return std::make_shared<Ili9488Display>(std::move(configuration));
+    auto display = std::make_shared<Ili9488Display>(std::move(configuration));
+    return std::reinterpret_pointer_cast<tt::hal::display::DisplayDevice>(display);
 }

Boards/ElecrowCrowpanelAdvance35/Source/hal/CrowPanelDisplay.h

@@ -1,40 +1,5 @@
 #pragma once
 
-#include "Tactility/hal/display/DisplayDevice.h"
-#include <esp_lcd_types.h>
-#include <lvgl.h>
-
-class CrowPanelDisplay : public tt::hal::display::DisplayDevice {
-
-private:
-
-    esp_lcd_panel_io_handle_t ioHandle = nullptr;
-    esp_lcd_panel_handle_t panelHandle = nullptr;
-    lv_display_t* displayHandle = nullptr;
-    bool poweredOn = false;
-
-public:
-
-    std::string getName() const final { return "ST7789"; }
-    std::string getDescription() const final { return "SPI display"; }
-
-    bool start() override;
-
-    bool stop() override;
-
-    void setPowerOn(bool turnOn) override;
-    bool isPoweredOn() const override { return poweredOn; };
-    bool supportsPowerControl() const override { return true; }
-
-    std::shared_ptr<tt::hal::touch::TouchDevice> _Nullable createTouch() override;
-
-    void setBacklightDuty(uint8_t backlightDuty) override;
-    bool supportsBacklightDuty() const override { return true; }
-
-    void setGammaCurve(uint8_t index) override;
-    uint8_t getGammaCurveCount() const override { return 4; };
-
-    lv_display_t* _Nullable getLvglDisplay() const override { return displayHandle; }
-};
+#include <Tactility/hal/display/DisplayDevice.h>
 
 std::shared_ptr<tt::hal::display::DisplayDevice> createDisplay();

Boards/ElecrowCrowpanelAdvance50/Source/hal/CrowPanelDisplay.h

@@ -1,5 +1,5 @@
 #pragma once
 
-#include "Tactility/hal/display/DisplayDevice.h"
+#include <Tactility/hal/display/DisplayDevice.h>
 
 std::shared_ptr<tt::hal::display::DisplayDevice> createDisplay();

Boards/ElecrowCrowpanelBasic28/Source/hal/CrowPanelDisplay.cpp

@@ -35,5 +35,6 @@ std::shared_ptr<tt::hal::display::DisplayDevice> createDisplay() {
     configuration->mirrorX = true;
     configuration->backlightDutyFunction = driver::pwmbacklight::setBacklightDuty;
 
-    return std::make_shared<Ili934xDisplay>(std::move(configuration));
+    auto display = std::make_shared<Ili934xDisplay>(std::move(configuration));
+    return std::reinterpret_pointer_cast<tt::hal::display::DisplayDevice>(display);
 }

Boards/ElecrowCrowpanelBasic28/Source/hal/CrowPanelDisplay.h

@@ -1,40 +1,5 @@
 #pragma once
 
 #include "Tactility/hal/display/DisplayDevice.h"
-#include <esp_lcd_types.h>
-#include <lvgl.h>
-
-class CrowPanelDisplay : public tt::hal::display::DisplayDevice {
-
-private:
-
-    esp_lcd_panel_io_handle_t ioHandle = nullptr;
-    esp_lcd_panel_handle_t panelHandle = nullptr;
-    lv_display_t* displayHandle = nullptr;
-    bool poweredOn = false;
-
-public:
-
-    std::string getName() const final { return "ST7789"; }
-    std::string getDescription() const final { return "SPI display"; }
-
-    bool start() override;
-
-    bool stop() override;
-
-    void setPowerOn(bool turnOn) override;
-    bool isPoweredOn() const override { return poweredOn; };
-    bool supportsPowerControl() const override { return true; }
-
-    std::shared_ptr<tt::hal::touch::TouchDevice> _Nullable createTouch() override;
-
-    void setBacklightDuty(uint8_t backlightDuty) override;
-    bool supportsBacklightDuty() const override { return true; }
-
-    void setGammaCurve(uint8_t index) override;
-    uint8_t getGammaCurveCount() const override { return 4; };
-
-    lv_display_t* _Nullable getLvglDisplay() const override { return displayHandle; }
-};
 
 std::shared_ptr<tt::hal::display::DisplayDevice> createDisplay();

Boards/ElecrowCrowpanelBasic35/Source/hal/CrowPanelDisplay.cpp

@@ -42,5 +42,6 @@ std::shared_ptr<tt::hal::display::DisplayDevice> createDisplay() {
     configuration->mirrorX = true;
     configuration->backlightDutyFunction = driver::pwmbacklight::setBacklightDuty;
 
-    return std::make_shared<Ili9488Display>(std::move(configuration));
+    auto display = std::make_shared<Ili9488Display>(std::move(configuration));
+    return std::reinterpret_pointer_cast<tt::hal::display::DisplayDevice>(display);
 }

Boards/ElecrowCrowpanelBasic35/Source/hal/CrowPanelDisplay.h

@@ -1,40 +1,5 @@
 #pragma once
 
-#include "Tactility/hal/display/DisplayDevice.h"
-#include <esp_lcd_types.h>
-#include <lvgl.h>
-
-class CrowPanelDisplay : public tt::hal::display::DisplayDevice {
-
-private:
-
-    esp_lcd_panel_io_handle_t ioHandle = nullptr;
-    esp_lcd_panel_handle_t panelHandle = nullptr;
-    lv_display_t* displayHandle = nullptr;
-    bool poweredOn = false;
-
-public:
-
-    std::string getName() const final { return "ST7789"; }
-    std::string getDescription() const final { return "SPI display"; }
-
-    bool start() override;
-
-    bool stop() override;
-
-    void setPowerOn(bool turnOn) override;
-    bool isPoweredOn() const override { return poweredOn; };
-    bool supportsPowerControl() const override { return true; }
-
-    std::shared_ptr<tt::hal::touch::TouchDevice> _Nullable createTouch() override;
-
-    void setBacklightDuty(uint8_t backlightDuty) override;
-    bool supportsBacklightDuty() const override { return true; }
-
-    void setGammaCurve(uint8_t index) override;
-    uint8_t getGammaCurveCount() const override { return 4; };
-
-    lv_display_t* _Nullable getLvglDisplay() const override { return displayHandle; }
-};
+#include <Tactility/hal/display/DisplayDevice.h>
 
 std::shared_ptr<tt::hal::display::DisplayDevice> createDisplay();

Boards/ElecrowCrowpanelBasic35/Source/hal/CrowPanelSdCard.cpp

@@ -3,8 +3,6 @@
 #include <Tactility/lvgl/LvglSync.h>
 #include <Tactility/hal/sdcard/SpiSdCardDevice.h>
 
-#include <esp_vfs_fat.h>
-
 using tt::hal::sdcard::SpiSdCardDevice;
 
 std::shared_ptr<SdCardDevice> createSdCard() {

Boards/ElecrowCrowpanelBasic50/Source/hal/CrowPanelDisplay.cpp

@@ -101,5 +101,6 @@ std::shared_ptr<tt::hal::display::DisplayDevice> createDisplay() {
         driver::pwmbacklight::setBacklightDuty
     );
 
-    return std::make_shared<RgbDisplay>(std::move(configuration));
+    auto display = std::make_shared<RgbDisplay>(std::move(configuration));
+    return std::reinterpret_pointer_cast<tt::hal::display::DisplayDevice>(display);
 }

Boards/ElecrowCrowpanelBasic50/Source/hal/CrowPanelDisplay.h

@@ -1,5 +1,5 @@
 #pragma once
 
-#include "Tactility/hal/display/DisplayDevice.h"
+#include <Tactility/hal/display/DisplayDevice.h>
 
 std::shared_ptr<tt::hal::display::DisplayDevice> createDisplay();

Boards/LilygoTLoraPager/CMakeLists.txt

@@ -3,5 +3,5 @@ file(GLOB_RECURSE SOURCE_FILES Source/*.c*)
 idf_component_register(
     SRCS ${SOURCE_FILES}
     INCLUDE_DIRS "Source"
-    REQUIRES Tactility esp_lvgl_port esp_lcd ST7796 BQ27220 TCA8418 PwmBacklight driver esp_adc
+    REQUIRES Tactility esp_lcd ST7796 BQ27220 TCA8418 PwmBacklight driver esp_adc
 )

Boards/LilygoTLoraPager/Source/hal/TpagerDisplay.cpp

@@ -6,8 +6,6 @@
 
 #include <driver/spi_master.h>
 
-#define TAG "TPAGER_display"
-
 std::shared_ptr<tt::hal::display::DisplayDevice> createDisplay() {
     auto configuration = std::make_unique<St7796Display::Configuration>(
         TPAGER_LCD_SPI_HOST,
@@ -26,5 +24,6 @@ std::shared_ptr<tt::hal::display::DisplayDevice> createDisplay() {
 
     configuration->backlightDutyFunction = driver::pwmbacklight::setBacklightDuty;
 
-    return std::make_shared<St7796Display>(std::move(configuration));
+    auto display = std::make_shared<St7796Display>(std::move(configuration));
+    return std::reinterpret_pointer_cast<tt::hal::display::DisplayDevice>(display);
 }

Boards/LilygoTLoraPager/Source/hal/TpagerDisplay.h

@@ -1,40 +1,5 @@
 #pragma once
 
-#include "Tactility/hal/display/DisplayDevice.h"
-#include <esp_lcd_types.h>
-#include <lvgl.h>
-
-class TpagerDisplay : public tt::hal::display::DisplayDevice {
-
-private:
-
-    esp_lcd_panel_io_handle_t ioHandle = nullptr;
-    esp_lcd_panel_handle_t panelHandle = nullptr;
-    lv_display_t* displayHandle = nullptr;
-    bool poweredOn = false;
-
-public:
-
-    std::string getName() const final { return "ST7796"; }
-    std::string getDescription() const final { return "SPI display"; }
-
-    bool start() override;
-
-    bool stop() override;
-
-    void setPowerOn(bool turnOn) override;
-    bool isPoweredOn() const override { return poweredOn; };
-    bool supportsPowerControl() const override { return true; }
-
-    std::shared_ptr<tt::hal::touch::TouchDevice> _Nullable createTouch() override;
-
-    void setBacklightDuty(uint8_t backlightDuty) override;
-    bool supportsBacklightDuty() const override { return true; }
-
-    void setGammaCurve(uint8_t index) override;
-    uint8_t getGammaCurveCount() const override { return 4; };
-
-    lv_display_t* _Nullable getLvglDisplay() const override { return displayHandle; }
-};
+#include <Tactility/hal/display/DisplayDevice.h>
 
 std::shared_ptr<tt::hal::display::DisplayDevice> createDisplay();

Boards/LilygoTLoraPager/Source/hal/TpagerKeyboard.h

@@ -1,6 +1,5 @@
 #pragma once
 
-#include <Tactility/TactilityCore.h>
 #include <Tactility/hal/keyboard/KeyboardDevice.h>
 
 #include <Tca8418.h>
@@ -10,10 +9,7 @@
 
 #include <Tactility/Timer.h>
 
-
-class TpagerKeyboard : public tt::hal::keyboard::KeyboardDevice {
-
-private:
+class TpagerKeyboard final : public tt::hal::keyboard::KeyboardDevice {
 
     lv_indev_t* _Nullable kbHandle = nullptr;
     lv_indev_t* _Nullable encHandle = nullptr;
@@ -36,13 +32,13 @@ private:
 public:
 
     TpagerKeyboard(std::shared_ptr<Tca8418> tca) : keypad(std::move(tca)) {}
-    ~TpagerKeyboard() {}
 
-    std::string getName() const final { return "T-Lora Pager Keyboard"; }
-    std::string getDescription() const final { return "I2C keyboard with encoder"; }
+    std::string getName() const override { return "T-Lora Pager Keyboard"; }
+    std::string getDescription() const override { return "T-Lora Pager I2C keyboard with encoder"; }
 
     bool startLvgl(lv_display_t* display) override;
     bool stopLvgl() override;
+
     bool isAttached() const override;
     lv_indev_t* _Nullable getLvglIndev() override { return kbHandle; }
 

Boards/M5stackCore2/Source/hal/Core2Display.cpp

@@ -6,10 +6,13 @@
 std::shared_ptr<tt::hal::touch::TouchDevice> createTouch() {
     auto configuration = std::make_unique<Ft6x36Touch::Configuration>(
         I2C_NUM_0,
-        GPIO_NUM_39
+        GPIO_NUM_39,
+        CORE2_LCD_HORIZONTAL_RESOLUTION,
+        CORE2_LCD_VERTICAL_RESOLUTION
     );
 
-    return std::make_shared<Ft6x36Touch>(std::move(configuration));
+    auto touch = std::make_shared<Ft6x36Touch>(std::move(configuration));
+    return std::reinterpret_pointer_cast<tt::hal::touch::TouchDevice>(touch);
 }
 
 std::shared_ptr<tt::hal::display::DisplayDevice> createDisplay() {
@@ -28,5 +31,6 @@ std::shared_ptr<tt::hal::display::DisplayDevice> createDisplay() {
         true
     );
 
-    return std::make_shared<Ili934xDisplay>(std::move(configuration));
+    auto display = std::make_shared<Ili934xDisplay>(std::move(configuration));
+    return std::reinterpret_pointer_cast<tt::hal::display::DisplayDevice>(display);
 }

Boards/M5stackCore2/Source/hal/Core2Power.cpp

@@ -2,7 +2,7 @@
 #include <Tactility/TactilityCore.h>
 #include "axp192/axp192.h"
 
-#define TAG "core2_power"
+constexpr auto TAG = "Core2Power";
 
 extern axp192_t axpDevice;
 

Boards/M5stackCoreS3/Source/hal/CoreS3Display.cpp

@@ -1,5 +1,4 @@
 #include "CoreS3Display.h"
-
 #include "CoreS3Constants.h"
 
 #include <Ft5x06Touch.h>
@@ -7,7 +6,7 @@
 #include <Tactility/Log.h>
 #include <Tactility/hal/i2c/I2c.h>
 
-#define TAG "cores3"
+constexpr auto TAG = "CoreS3Display";
 
 static void setBacklightDuty(uint8_t backlightDuty) {
     const uint8_t voltage = 20 + ((8 * backlightDuty) / 255); // [0b00000, 0b11100] - under 20 is too dark
@@ -25,7 +24,8 @@ static std::shared_ptr<tt::hal::touch::TouchDevice> createTouch() {
         240
     );
 
-    return std::make_shared<Ft5x06Touch>(std::move(configuration));
+    auto touch = std::make_shared<Ft5x06Touch>(std::move(configuration));
+    return std::reinterpret_pointer_cast<tt::hal::touch::TouchDevice>(touch);
 }
 
 std::shared_ptr<tt::hal::display::DisplayDevice> createDisplay() {
@@ -46,5 +46,6 @@ std::shared_ptr<tt::hal::display::DisplayDevice> createDisplay() {
 
     configuration->backlightDutyFunction = ::setBacklightDuty;
 
-    return std::make_shared<Ili934xDisplay>(std::move(configuration));
+    auto display = std::make_shared<Ili934xDisplay>(std::move(configuration));
+    return std::reinterpret_pointer_cast<tt::hal::display::DisplayDevice>(display);
 }

Boards/M5stackCoreS3/Source/hal/CoreS3Display.h

@@ -1,5 +1,5 @@
 #pragma once
 
-#include "Tactility/hal/display/DisplayDevice.h"
+#include <Tactility/hal/display/DisplayDevice.h>
 
 std::shared_ptr<tt::hal::display::DisplayDevice> createDisplay();

Documentation/ideas.md

@@ -1,5 +1,6 @@
 # TODOs
 
+- Revisit TinyUSB mouse idea: the bugs related to cleanup seem to be fixed in the library.
 - Bug: When a Wi-Fi SSID is too long, then it fails to save the credentials
 - Add a Keyboard setting app to override the behaviour of soft keyboard hiding (e.g. keyboard hardware is present, but the user wants to use a soft keyboard)
 - HAL for display touch calibration

Drivers/EspLcdCompat/Source/EspLcdTouch.h

@@ -15,6 +15,8 @@ class EspLcdTouch : public tt::hal::touch::TouchDevice {
 
 protected:
 
+    esp_lcd_touch_handle_t _Nullable getTouchHandle() const { return touchHandle; }
+
     virtual bool createIoHandle(esp_lcd_panel_io_handle_t& ioHandle) = 0;
 
     virtual bool createTouchHandle(esp_lcd_panel_io_handle_t ioHandle, const esp_lcd_touch_config_t& configuration, esp_lcd_touch_handle_t& touchHandle) = 0;

Drivers/FT5x06/CMakeLists.txt

@@ -1,5 +1,5 @@
 idf_component_register(
     SRC_DIRS "Source"
     INCLUDE_DIRS "Source"
-    REQUIRES Tactility esp_lvgl_port esp_lcd_touch esp_lcd_touch_ft5x06 driver
+    REQUIRES Tactility EspLcdCompat esp_lcd_touch_ft5x06 driver
 )

Drivers/FT5x06/Source/Ft5x06Touch.cpp

@@ -8,15 +8,17 @@
 
 #define TAG "ft5x06"
 
-bool Ft5x06Touch::start(lv_display_t* display) {
+bool Ft5x06Touch::createIoHandle(esp_lcd_panel_io_handle_t& outHandle) {
     esp_lcd_panel_io_i2c_config_t io_config = ESP_LCD_TOUCH_IO_I2C_FT5x06_CONFIG();
+    return esp_lcd_new_panel_io_i2c(configuration->port, &io_config, &outHandle) == ESP_OK;
+}
 
-    if (esp_lcd_new_panel_io_i2c(configuration->port, &io_config, &ioHandle) != ESP_OK) {
-        TT_LOG_E(TAG, "Touch IO I2C creation failed");
-        return false;
-    }
+bool Ft5x06Touch::createTouchHandle(esp_lcd_panel_io_handle_t ioHandle, const esp_lcd_touch_config_t& configuration, esp_lcd_touch_handle_t& panelHandle) {
+    return esp_lcd_touch_new_i2c_ft5x06(ioHandle, &configuration, &panelHandle) == ESP_OK;
+}
 
-    esp_lcd_touch_config_t config = {
+esp_lcd_touch_config_t Ft5x06Touch::createEspLcdTouchConfig() {
+    return {
         .x_max = configuration->xMax,
         .y_max = configuration->yMax,
         .rst_gpio_num = configuration->pinReset,
@@ -35,47 +37,4 @@ bool Ft5x06Touch::start(lv_display_t* display) {
         .user_data = nullptr,
         .driver_data = nullptr
     };
-
-    if (esp_lcd_touch_new_i2c_ft5x06(ioHandle, &config, &touchHandle) != ESP_OK) {
-        TT_LOG_E(TAG, "Driver init failed");
-        cleanup();
-        return false;
-    }
-
-    const lvgl_port_touch_cfg_t touch_cfg = {
-        .disp = display,
-        .handle = touchHandle,
-    };
-
-    TT_LOG_I(TAG, "Adding touch to LVGL");
-    deviceHandle = lvgl_port_add_touch(&touch_cfg);
-    if (deviceHandle == nullptr) {
-        TT_LOG_E(TAG, "Adding touch failed");
-        cleanup();
-        return false;
-    }
-
-    return true;
-}
-
-bool Ft5x06Touch::stop() {
-    cleanup();
-    return true;
-}
-
-void Ft5x06Touch::cleanup() {
-    if (deviceHandle != nullptr) {
-        lv_indev_delete(deviceHandle);
-        deviceHandle = nullptr;
-    }
-
-    if (touchHandle != nullptr) {
-        esp_lcd_touch_del(touchHandle);
-        touchHandle = nullptr;
-    }
-
-    if (ioHandle != nullptr) {
-        esp_lcd_panel_io_del(ioHandle);
-        ioHandle = nullptr;
-    }
 }

Drivers/FT5x06/Source/Ft5x06Touch.h

@@ -4,10 +4,9 @@
 #include <Tactility/TactilityCore.h>
 #include <driver/i2c.h>
 
-#include <esp_lcd_panel_io_interface.h>
-#include <esp_lcd_touch.h>
+#include <EspLcdTouch.h>
 
-class Ft5x06Touch final : public tt::hal::touch::TouchDevice {
+class Ft5x06Touch final : public EspLcdTouch {
 
 public:
 
@@ -52,11 +51,12 @@ public:
 private:
 
     std::unique_ptr<Configuration> configuration;
-    esp_lcd_panel_io_handle_t _Nullable ioHandle = nullptr;
-    esp_lcd_touch_handle_t _Nullable touchHandle = nullptr;
-    lv_indev_t* _Nullable deviceHandle = nullptr;
 
-    void cleanup();
+    bool createIoHandle(esp_lcd_panel_io_handle_t& outHandle) override;
+
+    bool createTouchHandle(esp_lcd_panel_io_handle_t ioHandle, const esp_lcd_touch_config_t& configuration, esp_lcd_touch_handle_t& panelHandle) override;
+
+    esp_lcd_touch_config_t createEspLcdTouchConfig() override;
 
 public:
 
@@ -64,10 +64,7 @@ public:
         assert(configuration != nullptr);
     }
 
-    bool start(lv_display_t* display) override;
-    bool stop() override;
-    lv_indev_t* _Nullable getLvglIndev() override { return deviceHandle; }
+    std::string getName() const override { return "FT5x06"; }
 
-    std::string getName() const final { return "FT5x06"; }
-    std::string getDescription() const final { return "I2C Touch Driver"; }
+    std::string getDescription() const override { return "FT5x06 I2C touch driver"; }
 };

Drivers/FT6x36/Source/Ft6x36Touch.cpp

@@ -1,5 +1,6 @@
 #include "Ft6x36Touch.h"
 
+#include <Ft6x36Touch.h>
 #include <Tactility/Log.h>
 
 #include <esp_err.h>
@@ -7,22 +8,23 @@
 
 #define TAG "ft6x36"
 
-static void touchReadCallback(lv_indev_t* indev, lv_indev_data_t* data) {
+void Ft6x36Touch::touchReadCallback(lv_indev_t* indev, lv_indev_data_t* data) {
     auto* touch = (Ft6x36Touch*)lv_indev_get_driver_data(indev);
-    touch->readLast(data);
+    touch->mutex.lock();
+    data->point = touch->lastPoint;
+    data->state = touch->lastState;
+    touch->mutex.unlock();
 }
 
 Ft6x36Touch::Ft6x36Touch(std::unique_ptr<Configuration> inConfiguration) :
-    configuration(std::move(inConfiguration)),
-    driverThread(tt::Thread("ft6x36", 4096, [this]() {
-        driverThreadMain();
-        return 0;
-    }))
-{}
+    configuration(std::move(inConfiguration)) {
+    nativeTouch = std::make_shared<Ft6NativeTouch>(*this);
+}
 
 Ft6x36Touch::~Ft6x36Touch() {
-    if (driverThread.getState() != tt::Thread::State::Stopped) {
-        stop();
+    if (driverThread != nullptr && driverThread->getState() != tt::Thread::State::Stopped) {
+        interruptDriverThread = true;
+        driverThread->join();
     }
 }
 
@@ -59,7 +61,7 @@ void Ft6x36Touch::driverThreadMain() {
     }
 }
 
-bool Ft6x36Touch::shouldInterruptDriverThread() {
+bool Ft6x36Touch::shouldInterruptDriverThread() const {
     bool interrupt = false;
     if (mutex.lock(50 / portTICK_PERIOD_MS)) {
         interrupt = interruptDriverThread;
@@ -68,35 +70,65 @@ bool Ft6x36Touch::shouldInterruptDriverThread() {
     return interrupt;
 }
 
-bool Ft6x36Touch::start(lv_display_t* display) {
-    TT_LOG_I(TAG, "start");
+bool Ft6x36Touch::start() {
+    TT_LOG_I(TAG, "Start");
 
-    driverThread.start();
-
-    uint16_t width = lv_display_get_horizontal_resolution(display);
-    uint16_t height = lv_display_get_vertical_resolution(display);
-    if (!driver.begin(FT6X36_DEFAULT_THRESHOLD, width, height)) {
+    if (!driver.begin(FT6X36_DEFAULT_THRESHOLD, configuration->width, configuration->height)) {
         TT_LOG_E(TAG, "driver.begin() failed");
         return false;
     }
 
+    mutex.lock();
+
+    interruptDriverThread = false;
+
+    driverThread = std::make_shared<tt::Thread>("ft6x36", 4096, [this] {
+        driverThreadMain();
+        return 0;
+    });
+
+    driverThread->start();
+
+    mutex.unlock();
+
+    return true;
+}
+
+bool Ft6x36Touch::stop() {
+    TT_LOG_I(TAG, "Stop");
+
+    mutex.lock();
+    interruptDriverThread = true;
+    mutex.unlock();
+
+    driverThread->join();
+
+    mutex.lock();
+    driverThread = nullptr;
+    mutex.unlock();
+
+    return false;
+}
+
+bool Ft6x36Touch::startLvgl(lv_display_t* display) {
+    if (deviceHandle != nullptr) {
+        return false;
+    }
+
     deviceHandle = lv_indev_create();
     lv_indev_set_type(deviceHandle, LV_INDEV_TYPE_POINTER);
     lv_indev_set_driver_data(deviceHandle, this);
     lv_indev_set_read_cb(deviceHandle, touchReadCallback);
 
-    TT_LOG_I(TAG, "start success");
     return true;
 }
 
-bool Ft6x36Touch::stop() {
+bool Ft6x36Touch::stopLvgl() {
+    if (deviceHandle == nullptr) {
+        return false;
+    }
+
     lv_indev_delete(deviceHandle);
-    interruptDriverThread = true;
-    driverThread.join();
+    deviceHandle = nullptr;
     return true;
 }
-
-void Ft6x36Touch::readLast(lv_indev_data_t* data) {
-    data->point = lastPoint;
-    data->state = lastState;
-}

Drivers/FT6x36/Source/Ft6x36Touch.h

@@ -15,41 +15,76 @@ public:
 
         Configuration(
             i2c_port_t port,
-            gpio_num_t pinInterrupt
+            gpio_num_t pinInterrupt,
+            uint16_t width,
+            uint16_t height
         ) : port(port),
-            pinInterrupt(pinInterrupt)
+            pinInterrupt(pinInterrupt),
+            width(width),
+            height(height)
         {}
 
         i2c_port_t port;
         gpio_num_t pinInterrupt;
-    };
+        uint16_t width;
+        uint16_t height;
+};
 
 private:
 
     std::unique_ptr<Configuration> configuration;
     lv_indev_t* _Nullable deviceHandle = nullptr;
     FT6X36 driver = FT6X36(configuration->port, configuration->pinInterrupt);
-    tt::Thread driverThread;
+    std::shared_ptr<tt::Thread> driverThread;
     bool interruptDriverThread = false;
     tt::Mutex mutex;
+    std::shared_ptr<tt::hal::touch::NativeTouch> nativeTouch;
 
     lv_point_t lastPoint = { .x = 0, .y = 0 };
     lv_indev_state_t lastState = LV_INDEV_STATE_RELEASED;
 
-    bool shouldInterruptDriverThread();
+    bool shouldInterruptDriverThread() const;
+
+    void driverThreadMain();
+
+    static void touchReadCallback(lv_indev_t* indev, lv_indev_data_t* data);
 
 public:
 
     explicit Ft6x36Touch(std::unique_ptr<Configuration> inConfiguration);
-    ~Ft6x36Touch() final;
+    ~Ft6x36Touch() override;
 
-    std::string getName() const final { return "FT6x36"; }
-    std::string getDescription() const final { return "I2C touch driver"; }
+    std::string getName() const override { return "FT6x36"; }
+    std::string getDescription() const override { return "FT6x36 I2C touch driver"; }
 
-    bool start(lv_display_t* display) override;
+    bool start() override;
     bool stop() override;
 
-    void readLast(lv_indev_data_t* data);
+    bool supportsLvgl() const override { return true; }
+    bool startLvgl(lv_display_t* display) override;
+    bool stopLvgl() override;
+
     lv_indev_t* _Nullable getLvglIndev() override { return deviceHandle; }
-    void driverThreadMain();
+
+    class Ft6NativeTouch : public tt::hal::touch::NativeTouch {
+    public:
+        const Ft6x36Touch& parent;
+        Ft6NativeTouch(const Ft6x36Touch& parent) : parent(parent) {}
+
+        bool getTouchedPoints(uint16_t* x, uint16_t* y, uint16_t* _Nullable strength, uint8_t* pointCount, uint8_t maxPointCount) {
+            auto lock = parent.mutex.asScopedLock();
+            lock.lock();
+            if (parent.lastState == LV_INDEV_STATE_PRESSED) {
+                *x = parent.lastPoint.x;
+                *y = parent.lastPoint.y;
+                *pointCount = 1;
+                return true;
+            } else {
+                *pointCount = 0;
+                return false;
+            }
+        }
+    };
+
+    std::shared_ptr<tt::hal::touch::NativeTouch> _Nullable getNativeTouch() override { return nativeTouch; }
 };

Drivers/GT911/CMakeLists.txt

@@ -1,5 +1,5 @@
 idf_component_register(
     SRC_DIRS "Source"
     INCLUDE_DIRS "Source"
-    REQUIRES Tactility esp_lvgl_port esp_lcd_touch esp_lcd_touch_gt911 driver
+    REQUIRES Tactility EspLcdCompat esp_lcd_touch_gt911 driver
 )

Drivers/GT911/Source/Gt911Touch.h

@@ -4,9 +4,7 @@
 #include <Tactility/TactilityCore.h>
 #include <driver/i2c.h>
 
-#include <esp_lcd_touch.h>
-
-#include "../../EspLcdCompat/Source/EspLcdTouch.h"
+#include <EspLcdTouch.h>
 
 class Gt911Touch final : public EspLcdTouch {
 
@@ -58,7 +56,7 @@ private:
 
     bool createTouchHandle(esp_lcd_panel_io_handle_t ioHandle, const esp_lcd_touch_config_t& configuration, esp_lcd_touch_handle_t& panelHandle) override;
 
-    esp_lcd_touch_config_t createEspLcdTouchConfig();
+    esp_lcd_touch_config_t createEspLcdTouchConfig() override;
 
 public:
 

Drivers/ILI934x/Source/Ili934xDisplay.h

@@ -72,11 +72,11 @@ private:
 
     std::unique_ptr<Configuration> configuration;
 
-    bool createIoHandle(esp_lcd_panel_io_handle_t& outHandle);
+    bool createIoHandle(esp_lcd_panel_io_handle_t& outHandle) override;
 
-    bool createPanelHandle(esp_lcd_panel_io_handle_t ioHandle, esp_lcd_panel_handle_t& panelHandle);
+    bool createPanelHandle(esp_lcd_panel_io_handle_t ioHandle, esp_lcd_panel_handle_t& panelHandle) override;
 
-    lvgl_port_display_cfg_t getLvglPortDisplayConfig(esp_lcd_panel_io_handle_t ioHandle, esp_lcd_panel_handle_t panelHandle);
+    lvgl_port_display_cfg_t getLvglPortDisplayConfig(esp_lcd_panel_io_handle_t ioHandle, esp_lcd_panel_handle_t panelHandle) override;
 
 public:
 

Drivers/ILI9488/CMakeLists.txt

@@ -1,5 +1,5 @@
 idf_component_register(
     SRC_DIRS "Source"
     INCLUDE_DIRS "Source"
-    REQUIRES Tactility esp_lvgl_port esp_lcd esp_lcd_ili9488 driver
+    REQUIRES Tactility EspLcdCompat esp_lcd_ili9488 driver
 )

Drivers/ILI9488/Source/Ili9488Display.cpp

@@ -6,11 +6,9 @@
 #include <esp_lcd_panel_commands.h>
 #include <esp_lvgl_port.h>
 
-#define TAG "ili9488"
-
-bool Ili9488Display::start() {
-    TT_LOG_I(TAG, "Starting");
+#define TAG "ILI9488"
 
+bool Ili9488Display::createIoHandle(esp_lcd_panel_io_handle_t& outHandle) {
     const esp_lcd_panel_io_spi_config_t panel_io_config = {
         .cs_gpio_num = configuration->csPin,
         .dc_gpio_num = configuration->dcPin,
@@ -35,10 +33,10 @@ bool Ili9488Display::start() {
         }
     };
 
-    if (esp_lcd_new_panel_io_spi(configuration->spiBusHandle, &panel_io_config, &ioHandle) != ESP_OK) {
-        TT_LOG_E(TAG, "Failed to create panel");
-        return false;
-    }
+    return esp_lcd_new_panel_io_spi(configuration->spiBusHandle, &panel_io_config, &outHandle) == ESP_OK;
+}
+
+bool Ili9488Display::createPanelHandle(esp_lcd_panel_io_handle_t ioHandle, esp_lcd_panel_handle_t& panelHandle) {
 
     const esp_lcd_panel_dev_config_t panel_config = {
         .reset_gpio_num = configuration->resetPin,
@@ -51,14 +49,7 @@ bool Ili9488Display::start() {
         .vendor_config = nullptr
     };
 
-    uint32_t buffer_size;
-    if (configuration->bufferSize == 0) {
-        buffer_size = configuration->horizontalResolution * configuration->verticalResolution / 20;
-    } else {
-        buffer_size = configuration->bufferSize;
-    }
-
-    if (esp_lcd_new_panel_ili9488(ioHandle, &panel_config, buffer_size, &panelHandle) != ESP_OK) {
+    if (esp_lcd_new_panel_ili9488(ioHandle, &panel_config, configuration->bufferSize, &panelHandle) != ESP_OK) {
         TT_LOG_E(TAG, "Failed to create panel");
         return false;
     }
@@ -93,11 +84,16 @@ bool Ili9488Display::start() {
         return false;
     }
 
-    const lvgl_port_display_cfg_t disp_cfg = {
+    return true;
+}
+
+
+lvgl_port_display_cfg_t Ili9488Display::getLvglPortDisplayConfig(esp_lcd_panel_io_handle_t ioHandle, esp_lcd_panel_handle_t panelHandle) {
+    return {
         .io_handle = ioHandle,
         .panel_handle = panelHandle,
         .control_handle = nullptr,
-        .buffer_size = buffer_size,
+        .buffer_size = configuration->bufferSize,
         .double_buffer = false,
         .trans_size = 0,
         .hres = configuration->horizontalResolution,
@@ -118,26 +114,4 @@ bool Ili9488Display::start() {
             .direct_mode = false
         }
     };
-
-    displayHandle = lvgl_port_add_disp(&disp_cfg);
-
-    TT_LOG_I(TAG, "Finished");
-    return displayHandle != nullptr;
-}
-
-bool Ili9488Display::stop() {
-    assert(displayHandle != nullptr);
-
-    lvgl_port_remove_disp(displayHandle);
-
-    if (esp_lcd_panel_del(panelHandle) != ESP_OK) {
-        return false;
-    }
-
-    if (esp_lcd_panel_io_del(ioHandle) != ESP_OK) {
-        return false;
-    }
-
-    displayHandle = nullptr;
-    return true;
 }

Drivers/ILI9488/Source/Ili9488Display.h

@@ -2,14 +2,13 @@
 
 #include "Tactility/hal/display/DisplayDevice.h"
 
-#include <driver/spi_common.h>
+#include <EspLcdDisplay.h>
+
 #include <driver/gpio.h>
-#include <esp_lcd_panel_io.h>
-#include <esp_lcd_types.h>
 #include <functional>
 #include <lvgl.h>
 
-class Ili9488Display final : public tt::hal::display::DisplayDevice {
+class Ili9488Display final : public EspLcdDisplay {
 
 public:
 
@@ -39,8 +38,11 @@ public:
             mirrorY(mirrorY),
             invertColor(invertColor),
             bufferSize(bufferSize),
-            touch(std::move(touch))
-        {}
+            touch(std::move(touch)) {
+            if (this->bufferSize == 0) {
+                this->bufferSize = horizontalResolution * verticalResolution / 10;
+            }
+        }
 
         esp_lcd_spi_bus_handle_t spiBusHandle;
         gpio_num_t csPin;
@@ -62,9 +64,12 @@ public:
 private:
 
     std::unique_ptr<Configuration> configuration;
-    esp_lcd_panel_io_handle_t ioHandle = nullptr;
-    esp_lcd_panel_handle_t panelHandle = nullptr;
-    lv_display_t* displayHandle = nullptr;
+
+    bool createIoHandle(esp_lcd_panel_io_handle_t& outHandle) override;
+
+    bool createPanelHandle(esp_lcd_panel_io_handle_t ioHandle, esp_lcd_panel_handle_t& panelHandle) override;
+
+    lvgl_port_display_cfg_t getLvglPortDisplayConfig(esp_lcd_panel_io_handle_t ioHandle, esp_lcd_panel_handle_t panelHandle) override;
 
 public:
 
@@ -72,24 +77,19 @@ public:
         assert(configuration != nullptr);
     }
 
-    std::string getName() const final { return "ILI9488"; }
-    std::string getDescription() const final { return "ILI9488 display"; }
+    std::string getName() const override { return "ILI9488"; }
 
-    bool start() final;
+    std::string getDescription() const override { return "ILI9488 display"; }
 
-    bool stop() final;
+    std::shared_ptr<tt::hal::touch::TouchDevice> _Nullable getTouchDevice() override { return configuration->touch; }
 
-    std::shared_ptr<tt::hal::touch::TouchDevice> _Nullable createTouch() final { return configuration->touch; }
-
-    void setBacklightDuty(uint8_t backlightDuty) final {
+    void setBacklightDuty(uint8_t backlightDuty) override {
         if (configuration->backlightDutyFunction != nullptr) {
             configuration->backlightDutyFunction(backlightDuty);
         }
     }
 
-    bool supportsBacklightDuty() const final { return configuration->backlightDutyFunction != nullptr; }
-
-    lv_display_t* _Nullable getLvglDisplay() const final { return displayHandle; }
+    bool supportsBacklightDuty() const override { return configuration->backlightDutyFunction != nullptr; }
 };
 
 std::shared_ptr<tt::hal::display::DisplayDevice> createDisplay();

Drivers/ST7789/Source/St7789Display.cpp

@@ -7,7 +7,7 @@
 #include <esp_lcd_panel_st7789.h>
 #include <esp_lvgl_port.h>
 
-#define TAG "ST7789"
+constexpr auto TAG = "ST7789";
 
 bool St7789Display::createIoHandle(esp_lcd_panel_io_handle_t& outHandle) {
     TT_LOG_I(TAG, "Starting");
@@ -96,18 +96,11 @@ bool St7789Display::createPanelHandle(esp_lcd_panel_io_handle_t ioHandle, esp_lc
 }
 
 lvgl_port_display_cfg_t St7789Display::getLvglPortDisplayConfig(esp_lcd_panel_io_handle_t ioHandle, esp_lcd_panel_handle_t panelHandle) {
-    uint32_t buffer_size;
-    if (configuration->bufferSize == 0) {
-        buffer_size = configuration->horizontalResolution * configuration->verticalResolution / 10;
-    } else {
-        buffer_size = configuration->bufferSize;
-    }
-
     return lvgl_port_display_cfg_t {
         .io_handle = ioHandle,
         .panel_handle = panelHandle,
         .control_handle = nullptr,
-        .buffer_size = buffer_size,
+        .buffer_size = configuration->bufferSize,
         .double_buffer = false,
         .trans_size = 0,
         .hres = configuration->horizontalResolution,

Drivers/ST7789/Source/St7789Display.h

@@ -40,7 +40,11 @@ public:
             invertColor(invertColor),
             bufferSize(bufferSize),
             touch(std::move(touch))
-        {}
+        {
+            if (this->bufferSize == 0) {
+                this->bufferSize = horizontalResolution * verticalResolution / 10;
+            }
+        }
 
         esp_lcd_spi_bus_handle_t spiBusHandle;
         gpio_num_t csPin;
@@ -63,6 +67,12 @@ private:
 
     std::unique_ptr<Configuration> configuration;
 
+    bool createIoHandle(esp_lcd_panel_io_handle_t& ioHandle) override;
+
+    bool createPanelHandle(esp_lcd_panel_io_handle_t ioHandle, esp_lcd_panel_handle_t& panelHandle) override;
+
+    lvgl_port_display_cfg_t getLvglPortDisplayConfig(esp_lcd_panel_io_handle_t ioHandle, esp_lcd_panel_handle_t panelHandle) override;
+
 public:
 
     explicit St7789Display(std::unique_ptr<Configuration> inConfiguration) : configuration(std::move(inConfiguration)) {
@@ -70,14 +80,9 @@ public:
     }
 
     std::string getName() const override { return "ST7789"; }
+
     std::string getDescription() const override { return "ST7789 display"; }
 
-    bool createIoHandle(esp_lcd_panel_io_handle_t& ioHandle) override;
-
-    bool createPanelHandle(esp_lcd_panel_io_handle_t ioHandle, esp_lcd_panel_handle_t& panelHandle) override;
-
-    lvgl_port_display_cfg_t getLvglPortDisplayConfig(esp_lcd_panel_io_handle_t ioHandle, esp_lcd_panel_handle_t panelHandle) override;
-
     std::shared_ptr<tt::hal::touch::TouchDevice> _Nullable getTouchDevice() override { return configuration->touch; }
 
     void setBacklightDuty(uint8_t backlightDuty) override {

Drivers/ST7796/CMakeLists.txt

@@ -1,5 +1,5 @@
 idf_component_register(
     SRC_DIRS "Source"
     INCLUDE_DIRS "Source"
-    REQUIRES Tactility esp_lvgl_port esp_lcd_st7796 driver
+    REQUIRES Tactility EspLcdCompat esp_lcd_st7796 driver
 )

Drivers/ST7796/Source/St7796Display.cpp

@@ -2,16 +2,13 @@
 
 #include <Tactility/Log.h>
 
-#include <esp_lcd_panel_commands.h>
 #include <esp_lcd_panel_dev.h>
 #include <esp_lcd_st7796.h>
 #include <esp_lvgl_port.h>
 
-#define TAG "st7796"
-
-bool St7796Display::start() {
-    TT_LOG_I(TAG, "Starting");
+constexpr auto TAG = "ST7796";
 
+bool St7796Display::createIoHandle(esp_lcd_panel_io_handle_t& ioHandle) {
     const esp_lcd_panel_io_spi_config_t panel_io_config = {
         .cs_gpio_num = configuration->csPin,
         .dc_gpio_num = configuration->dcPin,
@@ -36,11 +33,10 @@ bool St7796Display::start() {
         }
     };
 
-    if (esp_lcd_new_panel_io_spi(configuration->spiBusHandle, &panel_io_config, &ioHandle) != ESP_OK) {
-        TT_LOG_E(TAG, "Failed to create panel");
-        return false;
-    }
+    return esp_lcd_new_panel_io_spi(configuration->spiBusHandle, &panel_io_config, &ioHandle) == ESP_OK;
+}
 
+bool St7796Display::createPanelHandle(esp_lcd_panel_io_handle_t ioHandle, esp_lcd_panel_handle_t& panelHandle) {
     static const st7796_lcd_init_cmd_t lcd_init_cmds[] = {
         {0x01, (uint8_t[]) {0x00}, 0, 120},
         {0x11, (uint8_t[]) {0x00}, 0, 120},
@@ -69,7 +65,6 @@ bool St7796Display::start() {
         .init_cmds_size = sizeof(lcd_init_cmds) / sizeof(st7796_lcd_init_cmd_t),
     };
 
-
     const esp_lcd_panel_dev_config_t panel_config = {
         .reset_gpio_num = configuration->resetPin, // Set to -1 if not use
 #if ESP_IDF_VERSION < ESP_IDF_VERSION_VAL(5, 0, 0)
@@ -92,7 +87,7 @@ bool St7796Display::start() {
         },
         .vendor_config = nullptr
     };
-*/
+    */
     if (esp_lcd_new_panel_st7796(ioHandle, &panel_config, &panelHandle) != ESP_OK) {
         TT_LOG_E(TAG, "Failed to create panel");
         return false;
@@ -133,18 +128,15 @@ bool St7796Display::start() {
         return false;
     }
 
-    uint32_t buffer_size;
-    if (configuration->bufferSize == 0) {
-        buffer_size = configuration->horizontalResolution * configuration->verticalResolution / 10;
-    } else {
-        buffer_size = configuration->bufferSize;
-    }
+    return true;
+}
 
-    const lvgl_port_display_cfg_t disp_cfg = {
+lvgl_port_display_cfg_t St7796Display::getLvglPortDisplayConfig(esp_lcd_panel_io_handle_t ioHandle, esp_lcd_panel_handle_t panelHandle) {
+    return {
         .io_handle = ioHandle,
         .panel_handle = panelHandle,
         .control_handle = nullptr,
-        .buffer_size = buffer_size,
+        .buffer_size = configuration->bufferSize,
         .double_buffer = false,
         .trans_size = 0,
         .hres = configuration->horizontalResolution,
@@ -158,28 +150,6 @@ bool St7796Display::start() {
         .color_format = LV_COLOR_FORMAT_NATIVE,
         .flags = {.buff_dma = true, .buff_spiram = false, .sw_rotate = false, .swap_bytes = true, .full_refresh = false, .direct_mode = false}
     };
-
-    displayHandle = lvgl_port_add_disp(&disp_cfg);
-
-    TT_LOG_I(TAG, "Finished");
-    return displayHandle != nullptr;
-}
-
-bool St7796Display::stop() {
-    assert(displayHandle != nullptr);
-
-    lvgl_port_remove_disp(displayHandle);
-
-    if (esp_lcd_panel_del(panelHandle) != ESP_OK) {
-        return false;
-    }
-
-    if (esp_lcd_panel_io_del(ioHandle) != ESP_OK) {
-        return false;
-    }
-
-    displayHandle = nullptr;
-    return true;
 }
 
 void St7796Display::setGammaCurve(uint8_t index) {
@@ -200,6 +170,7 @@ void St7796Display::setGammaCurve(uint8_t index) {
         default:
             return;
     }
+
     const uint8_t param[] = {
         gamma_curve
     };

Drivers/ST7796/Source/St7796Display.h

@@ -1,15 +1,10 @@
 #pragma once
 
-#include "Tactility/hal/display/DisplayDevice.h"
-
+#include <EspLcdDisplay.h>
 #include <driver/gpio.h>
-#include <driver/spi_common.h>
-#include <esp_lcd_panel_io.h>
-#include <esp_lcd_types.h>
 #include <functional>
-#include <lvgl.h>
 
-class St7796Display final : public tt::hal::display::DisplayDevice {
+class St7796Display final : public EspLcdDisplay {
 
 public:
 
@@ -43,7 +38,11 @@ public:
             gapX(gapX),
             gapY(gapY),
             bufferSize(bufferSize),
-            touch(std::move(touch)) {}
+            touch(std::move(touch)) {
+            if (this->bufferSize == 0) {
+                this->bufferSize = horizontalResolution * verticalResolution / 10;
+            }
+        }
 
         esp_lcd_spi_bus_handle_t spiBusHandle;
         gpio_num_t csPin;
@@ -67,9 +66,12 @@ public:
 private:
 
     std::unique_ptr<Configuration> configuration;
-    esp_lcd_panel_io_handle_t ioHandle = nullptr;
-    esp_lcd_panel_handle_t panelHandle = nullptr;
-    lv_display_t* displayHandle = nullptr;
+
+    bool createIoHandle(esp_lcd_panel_io_handle_t& ioHandle) override;
+
+    bool createPanelHandle(esp_lcd_panel_io_handle_t ioHandle, esp_lcd_panel_handle_t& panelHandle) override;
+
+    lvgl_port_display_cfg_t getLvglPortDisplayConfig(esp_lcd_panel_io_handle_t ioHandle, esp_lcd_panel_handle_t panelHandle) override;
 
 public:
 
@@ -77,27 +79,23 @@ public:
         assert(configuration != nullptr);
     }
 
-    std::string getName() const final { return "ST7796"; }
-    std::string getDescription() const final { return "ST7796 display"; }
+    std::string getName() const override { return "ST7796"; }
 
-    bool start() final;
+    std::string getDescription() const override { return "ST7796 display"; }
 
-    bool stop() final;
+    std::shared_ptr<tt::hal::touch::TouchDevice> _Nullable getTouchDevice() override { return configuration->touch; }
 
-    std::shared_ptr<tt::hal::touch::TouchDevice> _Nullable createTouch() final { return configuration->touch; }
-
-    void setBacklightDuty(uint8_t backlightDuty) final {
+    void setBacklightDuty(uint8_t backlightDuty) override {
         if (configuration->backlightDutyFunction != nullptr) {
             configuration->backlightDutyFunction(backlightDuty);
         }
     }
 
-    void setGammaCurve(uint8_t index) final;
-    uint8_t getGammaCurveCount() const final { return 4; };
+    void setGammaCurve(uint8_t index) override;
 
-    bool supportsBacklightDuty() const final { return configuration->backlightDutyFunction != nullptr; }
+    uint8_t getGammaCurveCount() const override { return 4; };
 
-    lv_display_t* _Nullable getLvglDisplay() const final { return displayHandle; }
+    bool supportsBacklightDuty() const override { return configuration->backlightDutyFunction != nullptr; }
 };
 
 std::shared_ptr<tt::hal::display::DisplayDevice> createDisplay();

Drivers/XPT2046/CMakeLists.txt

@@ -1,5 +1,5 @@
 idf_component_register(
     SRC_DIRS "Source"
     INCLUDE_DIRS "Source"
-    REQUIRES Tactility esp_lcd_touch esp_lcd_touch_xpt2046
+    REQUIRES Tactility EspLcdCompat esp_lcd_touch_xpt2046
 )

Drivers/XPT2046/Source/Xpt2046Power.cpp

@@ -2,11 +2,28 @@
 #include "Xpt2046Touch.h"
 
 #include <Tactility/Log.h>
+#include <Tactility/hal/Device.h>
 
-#define TAG "xpt2046_power"
+constexpr auto TAG = "Xpt2046Power";
+constexpr auto BATTERY_VOLTAGE_MIN = 3.2f;
+constexpr auto BATTERY_VOLTAGE_MAX = 4.2f;
+constexpr auto MAX_VOLTAGE_SAMPLES = 15;
 
-#define BATTERY_VOLTAGE_MIN 3.2f
-#define BATTERY_VOLTAGE_MAX 4.2f
+static std::shared_ptr<Xpt2046Touch> findXp2046TouchDevice() {
+    // Make a safe copy
+    auto touch = tt::hal::findFirstDevice<tt::hal::touch::TouchDevice>(tt::hal::Device::Type::Touch);
+    if (touch == nullptr) {
+        TT_LOG_E(TAG, "Touch device not found");
+        return nullptr;
+    }
+
+    if (touch->getName() != "XPT2046") {
+        TT_LOG_E(TAG, "Touch device name mismatch");
+        return nullptr;
+    }
+
+    return std::reinterpret_pointer_cast<Xpt2046Touch>(touch);
+}
 
 static uint8_t estimateChargeLevelFromVoltage(uint32_t milliVolt) {
     float volts = std::min((float)milliVolt / 1000.f, BATTERY_VOLTAGE_MAX);
@@ -47,25 +64,26 @@ bool Xpt2046Power::getMetric(MetricType type, MetricData& data) {
     }
 }
 
-bool Xpt2046Power::readBatteryVoltageOnce(uint32_t& output) const {
-    // Make a safe copy
-    auto touch = Xpt2046Touch::getInstance();
-    if (touch != nullptr) {
-        float vbat;
-        if (touch->getVBat(vbat)) {
-            // Convert to mV
-            output = (uint32_t)(vbat * 1000.f);
-            return true;
+bool Xpt2046Power::readBatteryVoltageOnce(uint32_t& output) {
+    if (xptTouch == nullptr) {
+        xptTouch = findXp2046TouchDevice();
+        if (xptTouch == nullptr) {
+            TT_LOG_E(TAG, "XPT2046 touch device not found");
+            return false;
         }
     }
 
-    return false;
+    float vbat;
+    if (!xptTouch->getVBat(vbat)) {
+        return false;
+    }
+
+    // Convert to mV
+    output = (uint32_t)(vbat * 1000.f);
+    return true;
 }
 
-
-#define MAX_VOLTAGE_SAMPLES 15
-
-bool Xpt2046Power::readBatteryVoltageSampled(uint32_t& output) const {
+bool Xpt2046Power::readBatteryVoltageSampled(uint32_t& output) {
     size_t samples_read = 0;
     uint32_t sample_accumulator = 0;
     uint32_t sample_read_buffer;

Drivers/XPT2046/Source/Xpt2046Power.h

@@ -1,8 +1,8 @@
 #pragma once
 
 #include <Tactility/hal/power/PowerDevice.h>
-#include <memory>
 
+class Xpt2046Touch;
 using tt::hal::power::PowerDevice;
 
 /**
@@ -11,9 +11,13 @@ using tt::hal::power::PowerDevice;
  */
 class Xpt2046Power : public PowerDevice {
 
+    std::shared_ptr<Xpt2046Touch> xptTouch;
+
+    bool readBatteryVoltageOnce(uint32_t& output);
+    bool readBatteryVoltageSampled(uint32_t& output);
+
 public:
 
-    Xpt2046Power() = default;
     ~Xpt2046Power() = default;
 
     std::string getName() const final { return "XPT2046 Power Measurement"; }
@@ -22,10 +26,6 @@ public:
     bool supportsMetric(MetricType type) const override;
     bool getMetric(MetricType type, MetricData& data) override;
 
-private:
-
-    bool readBatteryVoltageOnce(uint32_t& output) const;
-    bool readBatteryVoltageSampled(uint32_t& output) const;
 };
 
 std::shared_ptr<PowerDevice> getOrCreatePower();

Drivers/XPT2046/Source/Xpt2046Touch.cpp

@@ -7,19 +7,19 @@
 #include <esp_lcd_touch_xpt2046.h>
 #include <esp_lvgl_port.h>
 
-#define TAG "xpt2046_touch"
-
 Xpt2046Touch* Xpt2046Touch::instance = nullptr;
 
-bool Xpt2046Touch::start(lv_display_t* display) {
+bool Xpt2046Touch::createIoHandle(esp_lcd_panel_io_handle_t& outHandle) {
     const esp_lcd_panel_io_spi_config_t io_config = ESP_LCD_TOUCH_IO_SPI_XPT2046_CONFIG(configuration->spiPinCs);
+    return esp_lcd_new_panel_io_spi(SPI2_HOST, &io_config, &outHandle) == ESP_OK;
+}
 
-    if (esp_lcd_new_panel_io_spi(SPI2_HOST, &io_config, &ioHandle) != ESP_OK) {
-        TT_LOG_E(TAG, "Touch IO SPI creation failed");
-        return false;
-    }
+bool Xpt2046Touch::createTouchHandle(esp_lcd_panel_io_handle_t ioHandle, const esp_lcd_touch_config_t& config, esp_lcd_touch_handle_t& panelHandle) {
+    return esp_lcd_touch_new_spi_xpt2046(ioHandle, &config, &panelHandle) == ESP_OK;
+}
 
-    esp_lcd_touch_config_t config = {
+esp_lcd_touch_config_t Xpt2046Touch::createEspLcdTouchConfig() {
+   return {
         .x_max = configuration->xMax,
         .y_max = configuration->yMax,
         .rst_gpio_num = GPIO_NUM_NC,
@@ -38,61 +38,20 @@ bool Xpt2046Touch::start(lv_display_t* display) {
         .user_data = nullptr,
         .driver_data = nullptr
     };
-
-    if (esp_lcd_touch_new_spi_xpt2046(ioHandle, &config, &touchHandle) != ESP_OK) {
-        TT_LOG_E(TAG, "XPT2046 driver init failed");
-        cleanup();
-        return false;
-    }
-
-    const lvgl_port_touch_cfg_t touch_cfg = {
-        .disp = display,
-        .handle = touchHandle,
-    };
-
-    TT_LOG_I(TAG, "Adding touch to LVGL");
-    deviceHandle = lvgl_port_add_touch(&touch_cfg);
-    if (deviceHandle == nullptr) {
-        TT_LOG_E(TAG, "Adding touch failed");
-        cleanup();
-        return false;
-    }
-
-    instance = this;
-    return true;
-}
-
-bool Xpt2046Touch::stop() {
-    instance = nullptr;
-    cleanup();
-    return true;
-}
-
-void Xpt2046Touch::cleanup() {
-    if (deviceHandle != nullptr) {
-        lv_indev_delete(deviceHandle);
-        deviceHandle = nullptr;
-    }
-
-    if (touchHandle != nullptr) {
-        esp_lcd_touch_del(touchHandle);
-        touchHandle = nullptr;
-    }
-
-    if (ioHandle != nullptr) {
-        esp_lcd_panel_io_del(ioHandle);
-        ioHandle = nullptr;
-    }
 }
 
 bool Xpt2046Touch::getVBat(float& outputVbat) {
-    if (touchHandle != nullptr) {
-        // Shares the SPI bus with the display, so we have to sync/lock as this method might be called from anywhere
-        if (tt::lvgl::lock(50 / portTICK_PERIOD_MS)) {
-            esp_lcd_touch_xpt2046_read_battery_level(touchHandle, &outputVbat);
-            tt::lvgl::unlock();
-            return true;
-        }
+    auto touch_handle = getTouchHandle();
+    if (touch_handle == nullptr) {
+        return false;
     }
-    return false;
+
+    // Shares the SPI bus with the display, so we have to sync/lock as this method might be called from anywhere
+    if (!tt::lvgl::lock(50 / portTICK_PERIOD_MS)) {
+        return false;
+    }
+
+    esp_lcd_touch_xpt2046_read_battery_level(touch_handle, &outputVbat);
+    tt::lvgl::unlock();
+    return true;
 }

Drivers/XPT2046/Source/Xpt2046Touch.h

@@ -1,13 +1,11 @@
 #pragma once
 
-#include "Tactility/hal/touch/TouchDevice.h"
-
-#include <Tactility/TactilityCore.h>
+#include <Tactility/hal/touch/TouchDevice.h>
 
 #include <esp_lcd_panel_io_interface.h>
-#include <esp_lcd_touch.h>
+#include <EspLcdTouch.h>
 
-class Xpt2046Touch : public tt::hal::touch::TouchDevice {
+class Xpt2046Touch : public EspLcdTouch {
 
 public:
 
@@ -45,11 +43,12 @@ private:
     static Xpt2046Touch* instance;
 
     std::unique_ptr<Configuration> configuration;
-    esp_lcd_panel_io_handle_t _Nullable ioHandle = nullptr;
-    esp_lcd_touch_handle_t _Nullable touchHandle = nullptr;
-    lv_indev_t* _Nullable deviceHandle = nullptr;
 
-    void cleanup();
+    bool createIoHandle(esp_lcd_panel_io_handle_t& outHandle) override;
+
+    bool createTouchHandle(esp_lcd_panel_io_handle_t ioHandle, const esp_lcd_touch_config_t& configuration, esp_lcd_touch_handle_t& panelHandle) override;
+
+    esp_lcd_touch_config_t createEspLcdTouchConfig() override;
 
 public:
 
@@ -58,14 +57,8 @@ public:
     }
 
     std::string getName() const final { return "XPT2046"; }
-    std::string getDescription() const final { return "I2C touch driver"; }
 
-    bool start(lv_display_t* display) override;
-    bool stop() override;
-    lv_indev_t* _Nullable getLvglIndev() override { return deviceHandle; }
+    std::string getDescription() const final { return "XPT2046 I2C touch driver"; }
 
     bool getVBat(float& outputVbat);
-
-    /** Used for accessing getVBat() in Power driver */
-    static Xpt2046Touch* getInstance() { return instance; }
 };