Re-implement Core2 and other improvements (#141)

- Create real drivers instead of wrapping M5Unified/M5GFX
- Display HAL improvements (better default base class behaviour)
- Fixed bug with LVGL statusbar service locking (would hang indefinitely waiting for mutex, causing WDT issues)
- Fixes for `Critical.h`
- Fixes and improvements for `Dispatcher` and `DispatcherThread`

Boards/M5stackCore2/Source/hal/Core2Display.cpp

@@ -0,0 +1,164 @@
+#include "Core2Display.h"
+#include "Core2DisplayConstants.h"
+#include "Log.h"
+
+#include <TactilityCore.h>
+#include <esp_lcd_panel_commands.h>
+
+#include "driver/gpio.h"
+#include "esp_err.h"
+#include "esp_lcd_ili9341.h"
+#include "esp_lcd_panel_ops.h"
+#include "esp_lvgl_port.h"
+#include "Core2Touch.h"
+
+#define TAG "yellow_display"
+
+bool Core2Display::start() {
+    TT_LOG_I(TAG, "Starting");
+
+    const esp_lcd_panel_io_spi_config_t panel_io_config = ILI9341_PANEL_IO_SPI_CONFIG(
+        CORE2_LCD_PIN_CS,
+        CORE2_LCD_PIN_DC,
+        nullptr,
+        nullptr
+    );
+
+    if (esp_lcd_new_panel_io_spi((esp_lcd_spi_bus_handle_t)CORE2_LCD_SPI_HOST, &panel_io_config, &ioHandle) != ESP_OK) {
+        TT_LOG_E(TAG, "Failed to create panel");
+        return false;
+    }
+
+    const esp_lcd_panel_dev_config_t panel_config = {
+        .reset_gpio_num = GPIO_NUM_NC,
+        .rgb_ele_order = LCD_RGB_ELEMENT_ORDER_BGR,
+        .data_endian = LCD_RGB_DATA_ENDIAN_LITTLE,
+        .bits_per_pixel = CORE2_LCD_BITS_PER_PIXEL,
+        .flags = {
+            .reset_active_high = false
+        },
+        .vendor_config = nullptr
+    };
+
+    if (esp_lcd_new_panel_ili9341(ioHandle, &panel_config, &panelHandle) != ESP_OK) {
+        TT_LOG_E(TAG, "Failed to create ili9341");
+        return false;
+    }
+
+    if (esp_lcd_panel_reset(panelHandle) != ESP_OK) {
+        TT_LOG_E(TAG, "Failed to reset panel");
+        return false;
+    }
+
+    if (esp_lcd_panel_init(panelHandle) != ESP_OK) {
+        TT_LOG_E(TAG, "Failed to init panel");
+        return false;
+    }
+
+    if (esp_lcd_panel_mirror(panelHandle, false, false) != ESP_OK) {
+        TT_LOG_E(TAG, "Failed to set panel to mirror");
+        return false;
+    }
+
+    if (esp_lcd_panel_invert_color(panelHandle, true) != ESP_OK) {
+        TT_LOG_E(TAG, "Failed to set panel to invert");
+        return false;
+    }
+
+    if (esp_lcd_panel_disp_on_off(panelHandle, true) != ESP_OK) {
+        TT_LOG_E(TAG, "Failed to turn display on");
+        return false;
+    }
+
+    const lvgl_port_display_cfg_t disp_cfg = {
+        .io_handle = ioHandle,
+        .panel_handle = panelHandle,
+        .control_handle = nullptr,
+        .buffer_size = CORE2_LCD_DRAW_BUFFER_SIZE,
+        .double_buffer = true,
+        .trans_size = 0,
+        .hres = CORE2_LCD_HORIZONTAL_RESOLUTION,
+        .vres = CORE2_LCD_VERTICAL_RESOLUTION,
+        .monochrome = false,
+        .rotation = {
+            .swap_xy = false,
+            .mirror_x = false,
+            .mirror_y = false,
+        },
+        .color_format = LV_COLOR_FORMAT_RGB565,
+        .flags = {
+            .buff_dma = false,
+            .buff_spiram = true,
+            .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 Core2Display::stop() {
+    tt_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;
+}
+
+/**
+ * Note:
+ * The datasheet implies this should work, but it doesn't:
+ * https://www.digikey.com/htmldatasheets/production/1640716/0/0/1/ILI9341-Datasheet.pdf
+ *
+ * This repo claims it only has 1 curve:
+ * https://github.com/brucemack/hello-ili9341
+ *
+ * I'm leaving it in as I'm not sure if it's just my hardware that's problematic.
+ */
+void Core2Display::setGammaCurve(uint8_t index) {
+    uint8_t gamma_curve;
+    switch (index) {
+        case 0:
+            gamma_curve = 0x01;
+            break;
+        case 1:
+            gamma_curve = 0x04;
+            break;
+        case 2:
+            gamma_curve = 0x02;
+            break;
+        case 3:
+            gamma_curve = 0x08;
+            break;
+        default:
+            return;
+    }
+    const uint8_t param[] = {
+        gamma_curve
+    };
+
+    if (esp_lcd_panel_io_tx_param(ioHandle , LCD_CMD_GAMSET, param, 1) != ESP_OK) {
+        TT_LOG_E(TAG, "Failed to set gamma");
+    }
+}
+
+tt::hal::Touch* _Nullable Core2Display::createTouch() {
+    return static_cast<tt::hal::Touch*>(new Core2Touch());
+}
+
+tt::hal::Display* createDisplay() {
+    return static_cast<tt::hal::Display*>(new Core2Display());
+}

Boards/M5stackCore2/Source/hal/Core2Display.h

@@ -0,0 +1,34 @@
+#pragma once
+
+#include "lvgl.h"
+#include "hal/Display.h"
+
+#include <esp_lcd_types.h>
+
+extern lv_disp_t* displayHandle;
+
+class Core2Display : public tt::hal::Display {
+
+private:
+
+    esp_lcd_panel_io_handle_t ioHandle = nullptr;
+    esp_lcd_panel_handle_t panelHandle = nullptr;
+    lv_display_t* displayHandle = nullptr;
+
+public:
+
+    bool start() override;
+
+    bool stop() override;
+
+    tt::hal::Touch* _Nullable createTouch() override;
+
+    bool supportsBacklightDuty() const override { return false; }
+
+    void setGammaCurve(uint8_t index) override;
+    uint8_t getGammaCurveCount() const override { return 4; };
+
+    lv_display_t* _Nullable getLvglDisplay() const override { return displayHandle; }
+};
+
+tt::hal::Display* createDisplay();

Boards/M5stackCore2/Source/hal/Core2DisplayConstants.h

@@ -0,0 +1,11 @@
+#pragma once
+
+// Display
+#define CORE2_LCD_SPI_HOST SPI2_HOST
+#define CORE2_LCD_PIN_CS GPIO_NUM_5
+#define CORE2_LCD_PIN_DC GPIO_NUM_15
+#define CORE2_LCD_HORIZONTAL_RESOLUTION 320
+#define CORE2_LCD_VERTICAL_RESOLUTION 240
+#define CORE2_LCD_BITS_PER_PIXEL 16
+#define CORE2_LCD_DRAW_BUFFER_HEIGHT (CORE2_LCD_VERTICAL_RESOLUTION / 10)
+#define CORE2_LCD_DRAW_BUFFER_SIZE (CORE2_LCD_HORIZONTAL_RESOLUTION * CORE2_LCD_DRAW_BUFFER_HEIGHT * (CORE2_LCD_BITS_PER_PIXEL / 8))

Boards/M5stackCore2/Source/hal/Core2Power.cpp

@@ -0,0 +1,63 @@
+#include "Core2Power.h"
+
+#include "utility/AXP192_Class.hpp"
+#include "TactilityCore.h"
+
+#define TAG "core2_power"
+
+extern m5::AXP192_Class axpDevice;
+
+bool Core2Power::supportsMetric(MetricType type) const {
+    switch (type) {
+        case BATTERY_VOLTAGE:
+        case CHARGE_LEVEL:
+        case IS_CHARGING:
+            return true;
+        case CURRENT:
+            return false;
+    }
+
+    return false; // Safety guard for when new enum values are introduced
+}
+
+bool Core2Power::getMetric(Power::MetricType type, Power::MetricData& data) {
+    switch (type) {
+        case BATTERY_VOLTAGE:
+            data.valueAsUint32 = (uint32_t)TT_MAX((axpDevice.getBatteryVoltage() * 1000.f), 0.0f);
+            return true;
+        case CHARGE_LEVEL: {
+            auto level = axpDevice.getBatteryLevel();
+            if (level > 0) {
+                data.valueAsUint8 = (uint8_t)level;
+                return true;
+            } else {
+                return false;
+            }
+        }
+        case IS_CHARGING:
+            data.valueAsBool = axpDevice.isCharging();
+            return true;
+        case CURRENT:
+            return false;
+    }
+
+    return false; // Safety guard for when new enum values are introduced
+}
+
+bool Core2Power::isAllowedToCharge() const {
+    return allowedToCharge;
+}
+
+void Core2Power::setAllowedToCharge(bool canCharge) {
+    allowedToCharge = canCharge;
+    axpDevice.setBatteryCharge(canCharge);
+}
+
+static std::shared_ptr<Power> power;
+
+std::shared_ptr<Power> createPower() {
+    if (power == nullptr) {
+        power = std::make_shared<Core2Power>();
+    }
+    return power;
+}

Boards/M5stackCore2/Source/hal/Core2Power.h

@@ -0,0 +1,27 @@
+#pragma once
+
+#include "hal/Power.h"
+#include <memory>
+
+using namespace tt::hal;
+
+class Core2Power : public Power {
+
+private:
+
+    bool allowedToCharge = true;
+
+public:
+
+    Core2Power() = default;
+    ~Core2Power() override = default;
+
+    bool supportsMetric(MetricType type) const override;
+    bool getMetric(Power::MetricType type, Power::MetricData& data) override;
+
+    bool supportsChargeControl() const override { return true; }
+    bool isAllowedToCharge() const override;
+    void setAllowedToCharge(bool canCharge) override;
+};
+
+std::shared_ptr<Power> createPower();

Boards/M5stackCore2/Source/hal/Core2SdCard.cpp

@@ -0,0 +1,31 @@
+#include "Core2SdCard.h"
+
+#include "lvgl/LvglSync.h"
+#include "hal/SpiSdCard.h"
+
+#include <esp_vfs_fat.h>
+
+#define CORE2_SDCARD_SPI_FREQUENCY 800000U
+#define CORE2_SDCARD_PIN_CS GPIO_NUM_4
+#define CORE2_LCD_PIN_CS GPIO_NUM_5
+
+std::shared_ptr<SdCard> createSdCard() {
+    auto* configuration = new tt::hal::SpiSdCard::Config(
+        CORE2_SDCARD_SPI_FREQUENCY,
+        CORE2_SDCARD_PIN_CS,
+        GPIO_NUM_NC,
+        GPIO_NUM_NC,
+        GPIO_NUM_NC,
+        SdCard::MountBehaviourAtBoot,
+        tt::lvgl::getLvglSyncLockable(),
+        {
+            CORE2_LCD_PIN_CS
+        }
+    );
+
+    auto* sdcard = (SdCard*) new SpiSdCard(
+        std::unique_ptr<SpiSdCard::Config>(configuration)
+    );
+
+    return std::shared_ptr<SdCard>(sdcard);
+}

Boards/M5stackCore2/Source/hal/Core2SdCard.h

@@ -0,0 +1,7 @@
+#pragma once
+
+#include "hal/SdCard.h"
+
+using namespace tt::hal;
+
+std::shared_ptr<SdCard> createSdCard();

Boards/M5stackCore2/Source/hal/Core2Touch.cpp

@@ -0,0 +1,94 @@
+#include "Core2Touch.h"
+#include <esp_lvgl_port.h>
+
+#define TAG "core2_touch"
+
+static void touchReadCallback(lv_indev_t* indev, lv_indev_data_t* data) {
+    auto* touch = (Core2Touch*)lv_indev_get_driver_data(indev);
+    touch->readLast(data);
+}
+
+static int32_t threadCallback(void* context) {
+    auto* touch = (Core2Touch*)context;
+    touch->driverThreadMain();
+    return 0;
+}
+
+Core2Touch::Core2Touch() :
+    driverThread(tt::Thread("core2_touch", 4096, threadCallback, this))
+{ }
+
+void Core2Touch::driverThreadMain() {
+    TPoint point = { .x = 0, .y = 0 };
+    TEvent event = TEvent::None;
+
+    while (!shouldInterruptDriverThread()) {
+        driver.processTouch();
+        driver.poll(&point, &event);
+
+        if (mutex.lock(100)) {
+            switch (event) {
+                case TEvent::TouchStart:
+                case TEvent::TouchMove:
+                case TEvent::DragStart:
+                case TEvent::DragMove:
+                case TEvent::DragEnd:
+                    lastState = LV_INDEV_STATE_PR;
+                    lastPoint.x = point.x;
+                    lastPoint.y = point.y;
+                    break;
+                case TEvent::TouchEnd:
+                    lastState = LV_INDEV_STATE_REL;
+                    lastPoint.x = point.x;
+                    lastPoint.y = point.y;
+                    break;
+                case TEvent::Tap:
+                case TEvent::None:
+                    break;
+            }
+            mutex.unlock();
+        }
+    }
+}
+
+bool Core2Touch::shouldInterruptDriverThread() {
+    bool interrupt = false;
+    if (mutex.lock(50 / portTICK_PERIOD_MS)) {
+        interrupt = interruptDriverThread;
+        mutex.unlock();
+    }
+    return interrupt;
+}
+
+bool Core2Touch::start(lv_display_t* display) {
+    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)) {
+        TT_LOG_E(TAG, "driver.begin() failed");
+        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 Core2Touch::stop() {
+    lv_indev_delete(deviceHandle);
+    interruptDriverThread = true;
+    driverThread.join();
+    return true;
+}
+
+void Core2Touch::readLast(lv_indev_data_t* data) {
+    data->point = lastPoint;
+    data->state = lastState;
+}

Boards/M5stackCore2/Source/hal/Core2Touch.h

@@ -0,0 +1,32 @@
+#pragma once
+
+#include "hal/Touch.h"
+#include "TactilityCore.h"
+#include "ft6x36/FT6X36.h"
+
+class Core2Touch : public tt::hal::Touch {
+
+private:
+
+    lv_indev_t* _Nullable deviceHandle = nullptr;
+    FT6X36 driver = FT6X36(I2C_NUM_0, GPIO_NUM_39);
+    tt::Thread driverThread;
+    bool interruptDriverThread = false;
+    tt::Mutex mutex;
+
+    lv_point_t lastPoint = { .x = 0, .y = 0 };
+    lv_indev_state_t lastState = LV_INDEV_STATE_RELEASED;
+
+    bool shouldInterruptDriverThread();
+
+public:
+
+    Core2Touch();
+
+    bool start(lv_display_t* display) override;
+    bool stop() override;
+
+    void readLast(lv_indev_data_t* data);
+    lv_indev_t* _Nullable getLvglIndev() override { return deviceHandle; }
+    void driverThreadMain();
+};