Merge develop into main (#316)

- Updated all boards to use `hal::Configuration.createDevices`
- Updated all boards to use new directory structure and file naming convention
- Refactored `Xpt2046SoftSpi` driver.
- Created `Axp2101Power` device in `Drivers/AXP2101`
- Removed global static instances from some drivers (instances that kept a reference to the Device*)
- Improved `SystemInfoApp` UI: better memory labels, hide external memory bar when there's no PSRAM
- Fix for HAL: register touch devices after displays are registered
- Fix for Boot splash hanging on WiFi init: unlock file lock after using it

Boards/M5stackCore2/Source/devices/Core2Power.cpp

@@ -0,0 +1,108 @@
+#include "Core2Power.h"
+#include <Tactility/TactilityCore.h>
+#include "axp192/axp192.h"
+
+constexpr auto TAG = "Core2Power";
+
+extern axp192_t axpDevice;
+
+bool Core2Power::supportsMetric(MetricType type) const {
+    switch (type) {
+        using enum MetricType;
+        case BatteryVoltage:
+        case ChargeLevel:
+        case IsCharging:
+            return true;
+        default:
+            return false;
+    }
+}
+
+bool Core2Power::getMetric(MetricType type, MetricData& data) {
+    switch (type) {
+        using enum MetricType;
+        case BatteryVoltage: {
+            float voltage;
+            if (axp192_read(&axpDevice, AXP192_BATTERY_VOLTAGE, &voltage) == ESP_OK) {
+                data.valueAsUint32 = (uint32_t)std::max((voltage * 1000.f), 0.0f);
+                return true;
+            } else {
+                return false;
+            }
+        }
+        case ChargeLevel: {
+            float vbat, charge_current;
+            if (
+                axp192_read(&axpDevice, AXP192_BATTERY_VOLTAGE, &vbat) == ESP_OK &&
+                axp192_read(&axpDevice, AXP192_CHARGE_CURRENT, &charge_current) == ESP_OK
+            ) {
+                float max_voltage = 4.20f;
+                float min_voltage = 2.69f; // From M5Unified
+                float voltage_correction = (charge_current > 0.01f) ? -0.1f : 0.f; // Roughly 0.1V drop when ccharging
+                float corrected_voltage = vbat + voltage_correction;
+                if (corrected_voltage > 2.69f) {
+                    float charge_factor = (corrected_voltage - min_voltage) / (max_voltage - min_voltage);
+                    data.valueAsUint8 = (uint8_t)(charge_factor * 100.f);
+                } else {
+                    data.valueAsUint8 = 0;
+                }
+                return true;
+            } else {
+                return false;
+            }
+        }
+        case IsCharging: {
+            float charge_current;
+            if (axp192_read(&axpDevice, AXP192_CHARGE_CURRENT, &charge_current) == ESP_OK) {
+                data.valueAsBool = charge_current > 0.001f;
+                return true;
+            } else {
+                return false;
+            }
+        }
+        case Current: {
+            float charge_current, discharge_current;
+            if (
+                axp192_read(&axpDevice, AXP192_CHARGE_CURRENT, &charge_current) == ESP_OK &&
+                axp192_read(&axpDevice, AXP192_DISCHARGE_CURRENT, &discharge_current) == ESP_OK
+            ) {
+                if (charge_current > 0.0f) {
+                    data.valueAsInt32 = (int32_t) (charge_current * 1000.0f);
+                } else {
+                    data.valueAsInt32 = -(int32_t) (discharge_current * 1000.0f);
+                }
+                return true;
+            } else {
+                return false;
+            }
+        }
+        default:
+            return false;
+    }
+}
+
+bool Core2Power::isAllowedToCharge() const {
+    uint8_t buffer;
+    if (axp192_read(&axpDevice, AXP192_CHARGE_CONTROL_1, &buffer) == ESP_OK) {
+        return buffer & 0x80;
+    } else {
+        return false;
+    }
+}
+
+void Core2Power::setAllowedToCharge(bool canCharge) {
+    uint8_t buffer;
+    if (axp192_read(&axpDevice, AXP192_CHARGE_CONTROL_1, &buffer) == ESP_OK) {
+        buffer = (buffer & 0x7F) + (canCharge ? 0x80 : 0x00);
+        axp192_write(&axpDevice, AXP192_CHARGE_CONTROL_1, buffer);
+    }
+}
+
+static std::shared_ptr<PowerDevice> power;
+
+std::shared_ptr<PowerDevice> createPower() {
+    if (power == nullptr) {
+        power = std::make_shared<Core2Power>();
+    }
+    return power;
+}

Boards/M5stackCore2/Source/devices/Core2Power.h

@@ -0,0 +1,26 @@
+#pragma once
+
+#include "Tactility/hal/power/PowerDevice.h"
+#include <memory>
+
+using tt::hal::power::PowerDevice;
+
+class Core2Power : public PowerDevice {
+
+public:
+
+    Core2Power() = default;
+    ~Core2Power() override = default;
+
+    std::string getName() const final { return "AXP192 Power"; }
+    std::string getDescription() const final { return "Power management via I2C"; }
+
+    bool supportsMetric(MetricType type) const override;
+    bool getMetric(MetricType type, MetricData& data) override;
+
+    bool supportsChargeControl() const override { return true; }
+    bool isAllowedToCharge() const override;
+    void setAllowedToCharge(bool canCharge) override;
+};
+
+std::shared_ptr<PowerDevice> createPower();

Boards/M5stackCore2/Source/devices/Display.cpp

@@ -0,0 +1,36 @@
+#include "Display.h"
+
+#include <Ft6x36Touch.h>
+#include <Ili934xDisplay.h>
+
+std::shared_ptr<tt::hal::touch::TouchDevice> createTouch() {
+    auto configuration = std::make_unique<Ft6x36Touch::Configuration>(
+        I2C_NUM_0,
+        GPIO_NUM_39,
+        CORE2_LCD_HORIZONTAL_RESOLUTION,
+        CORE2_LCD_VERTICAL_RESOLUTION
+    );
+
+    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() {
+    auto touch = createTouch();
+
+    auto configuration = std::make_unique<Ili934xDisplay::Configuration>(
+        CORE2_LCD_SPI_HOST,
+        CORE2_LCD_PIN_CS,
+        CORE2_LCD_PIN_DC,
+        CORE2_LCD_HORIZONTAL_RESOLUTION,
+        CORE2_LCD_VERTICAL_RESOLUTION,
+        touch,
+        false,
+        false,
+        false,
+        true
+    );
+
+    auto display = std::make_shared<Ili934xDisplay>(std::move(configuration));
+    return std::reinterpret_pointer_cast<tt::hal::display::DisplayDevice>(display);
+}

Boards/M5stackCore2/Source/devices/Display.h

@@ -0,0 +1,14 @@
+#pragma once
+
+#include "Tactility/hal/display/DisplayDevice.h"
+#include <memory>
+
+#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_DRAW_BUFFER_HEIGHT (CORE2_LCD_VERTICAL_RESOLUTION / 10)
+#define CORE2_LCD_DRAW_BUFFER_SIZE (CORE2_LCD_HORIZONTAL_RESOLUTION * CORE2_LCD_DRAW_BUFFER_HEIGHT)
+
+std::shared_ptr<tt::hal::display::DisplayDevice> createDisplay();

Boards/M5stackCore2/Source/devices/SdCard.cpp

@@ -0,0 +1,27 @@
+#include "SdCard.h"
+
+#include <Tactility/hal/sdcard/SpiSdCardDevice.h>
+#include <Tactility/lvgl/LvglSync.h>
+
+constexpr auto CORE2_SDCARD_PIN_CS = GPIO_NUM_4;
+constexpr auto CORE2_LCD_PIN_CS = GPIO_NUM_5;
+
+using tt::hal::sdcard::SpiSdCardDevice;
+
+std::shared_ptr<SdCardDevice> createSdCard() {
+    auto configuration = std::make_unique<SpiSdCardDevice::Config>(
+        CORE2_SDCARD_PIN_CS,
+        GPIO_NUM_NC,
+        GPIO_NUM_NC,
+        GPIO_NUM_NC,
+        SdCardDevice::MountBehaviour::AtBoot,
+        tt::lvgl::getSyncLock(),
+        std::vector {
+            CORE2_LCD_PIN_CS
+        }
+    );
+
+    return std::make_shared<SpiSdCardDevice>(
+        std::move(configuration)
+    );
+}

Boards/M5stackCore2/Source/devices/SdCard.h

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