Rename Boards/ to Devices/ (#414)

2025-11-13 23:50:43 +01:00
parent c7c9618f48
commit c1ff024657
314 changed files with 105 additions and 99 deletions
@@ -0,0 +1,27 @@
+cmake_minimum_required(VERSION 3.20)
+
+if (NOT DEFINED ENV{ESP_IDF_VERSION})
+
+    file(GLOB_RECURSE SOURCES "Source/*.c*")
+    file(GLOB_RECURSE HEADERS "Source/*.h*")
+
+    add_library(Simulator OBJECT)
+
+    target_sources(Simulator
+        PRIVATE ${SOURCES}
+        PUBLIC ${HEADERS}
+    )
+
+    target_link_libraries(Simulator
+        PRIVATE Tactility
+        PRIVATE TactilityCore
+        PRIVATE lvgl
+        PRIVATE SDL2-static
+    )
+
+    target_link_libraries(Simulator PRIVATE ${SDL2_LIBRARIES})
+
+    add_definitions(-D_Nullable=)
+    add_definitions(-D_Nonnull=)
+
+endif()
@@ -0,0 +1,86 @@
+#pragma once
+
+extern void vAssertCalled(unsigned long line, const char* const file);
+
+#define configUSE_PREEMPTION                    1
+#define configUSE_PORT_OPTIMISED_TASK_SELECTION 0
+#define configUSE_TICKLESS_IDLE                 0
+#define configTICK_RATE_HZ                      1000 // Must be the same as ESP32!
+#define configMAX_PRIORITIES                    10
+#define configMINIMAL_STACK_SIZE                2048
+#define configMAX_TASK_NAME_LEN                 16
+#define configUSE_16_BIT_TICKS                  0
+#define configIDLE_SHOULD_YIELD                 1
+#define configUSE_TASK_NOTIFICATIONS            1
+#define configTASK_NOTIFICATION_ARRAY_ENTRIES   2 // Must be the same as ESP32!
+#define configUSE_MUTEXES                       1
+#define configUSE_RECURSIVE_MUTEXES             1
+#define configUSE_COUNTING_SEMAPHORES           1
+#define configUSE_ALTERNATIVE_API               0 /* Deprecated! */
+#define configQUEUE_REGISTRY_SIZE               10
+#define configUSE_QUEUE_SETS                    1
+#define configUSE_TIME_SLICING                  0
+#define configUSE_NEWLIB_REENTRANT              0
+#define configENABLE_BACKWARD_COMPATIBILITY     1
+#define configNUM_THREAD_LOCAL_STORAGE_POINTERS 5
+#define configUSE_MINI_LIST_ITEM                1
+#define configSTACK_DEPTH_TYPE                  uint16_t
+#define configMESSAGE_BUFFER_LENGTH_TYPE        size_t
+#define configHEAP_CLEAR_MEMORY_ON_FREE         1
+#define configUSE_APPLICATION_TASK_TAG          0
+
+/* Memory allocation related definitions. */
+#define configSUPPORT_STATIC_ALLOCATION             0
+#define configSUPPORT_DYNAMIC_ALLOCATION            1
+#define configTOTAL_HEAP_SIZE                       (1024 * 1024)
+#define configAPPLICATION_ALLOCATED_HEAP            0
+#define configSTACK_ALLOCATION_FROM_SEPARATE_HEAP   0 // TODO: Compare with ESP defaults
+
+/* Hook function related definitions. */
+#define configUSE_IDLE_HOOK                     0
+#define configUSE_TICK_HOOK                     0
+#define configCHECK_FOR_STACK_OVERFLOW          0
+#define configUSE_MALLOC_FAILED_HOOK            0
+#define configUSE_DAEMON_TASK_STARTUP_HOOK      0
+#define configUSE_SB_COMPLETED_CALLBACK         0
+
+/* Run time and task stats gathering related definitions. */
+#define configGENERATE_RUN_TIME_STATS           0
+#define configUSE_TRACE_FACILITY                1
+#define configUSE_STATS_FORMATTING_FUNCTIONS    0
+
+/* Co-routine related definitions. */
+#define configUSE_CO_ROUTINES                   0
+#define configMAX_CO_ROUTINE_PRIORITIES         1
+
+/* Software timer related definitions. */
+#define configUSE_TIMERS                        1
+#define configTIMER_TASK_PRIORITY               3
+#define configTIMER_QUEUE_LENGTH                10
+#define configTIMER_TASK_STACK_DEPTH            10240
+
+/* Define to trap errors during development. */
+#define configASSERT(x) if( ( x ) == 0 ) vAssertCalled(__LINE__, __FILE__)
+
+/* FreeRTOS MPU specific definitions. */
+#define configINCLUDE_APPLICATION_DEFINED_PRIVILEGED_FUNCTIONS 0
+
+/* Optional functions - most linkers will remove unused functions anyway. */
+/* Ensure these are closely match ESP32: you can activate more features, but not less. */
+#define INCLUDE_vTaskPrioritySet                1
+#define INCLUDE_uxTaskPriorityGet               1
+#define INCLUDE_vTaskDelete                     1
+#define INCLUDE_vTaskSuspend                    1
+#define INCLUDE_vTaskDelayUntil                 1
+#define INCLUDE_vTaskDelay                      1
+#define INCLUDE_xTaskGetSchedulerState          1
+#define INCLUDE_xTaskGetCurrentTaskHandle       1
+#define INCLUDE_uxTaskGetStackHighWaterMark     1
+#define INCLUDE_uxTaskGetStackHighWaterMark2    1
+#define INCLUDE_xTaskGetIdleTaskHandle          1
+#define INCLUDE_eTaskGetState                   1
+#define INCLUDE_xTimerPendFunctionCall          1
+#define INCLUDE_xTaskAbortDelay                 1
+#define INCLUDE_xTaskGetHandle                  1
+#define INCLUDE_xTaskResumeFromISR              1
+#define INCLUDE_xQueueGetMutexHolder            1
@@ -0,0 +1,107 @@
+#include "LvglTask.h"
+
+#include <Tactility/Log.h>
+#include <Tactility/lvgl/LvglSync.h>
+#include <Tactility/Mutex.h>
+#include <Tactility/Thread.h>
+
+#include <lvgl.h>
+
+#define TAG "lvgl_task"
+
+// Mutex for LVGL drawing
+static tt::Mutex lvgl_mutex(tt::Mutex::Type::Recursive);
+static tt::Mutex task_mutex(tt::Mutex::Type::Recursive);
+
+static uint32_t task_max_sleep_ms = 10;
+// Mutex for LVGL task state (to modify task_running state)
+static bool task_running = false;
+
+lv_disp_t* displayHandle = nullptr;
+
+static void lvgl_task(void* arg);
+
+static bool task_lock(TickType_t timeout) {
+    return task_mutex.lock(timeout);
+}
+
+static void task_unlock() {
+    task_mutex.unlock();
+}
+
+static void task_set_running(bool running) {
+    assert(task_lock(configTICK_RATE_HZ / 100));
+    task_running = running;
+    task_unlock();
+}
+
+bool lvgl_task_is_running() {
+    assert(task_lock(configTICK_RATE_HZ / 100));
+    bool result = task_running;
+    task_unlock();
+    return result;
+}
+
+static bool lvgl_lock(uint32_t timeoutMillis) {
+    return lvgl_mutex.lock(pdMS_TO_TICKS(timeoutMillis));
+}
+
+static void lvgl_unlock() {
+    lvgl_mutex.unlock();
+}
+
+void lvgl_task_interrupt() {
+    tt_check(task_lock(portMAX_DELAY));
+    task_set_running(false); // interrupt task with boolean as flag
+    task_unlock();
+}
+
+void lvgl_task_start() {
+    TT_LOG_I(TAG, "lvgl task starting");
+
+    tt::lvgl::syncSet(&lvgl_lock, &lvgl_unlock);
+
+    // Create the main app loop, like ESP-IDF
+    BaseType_t task_result = xTaskCreate(
+        lvgl_task,
+        "lvgl",
+        8192,
+        nullptr,
+        static_cast<UBaseType_t>(tt::Thread::Priority::High), // Should be higher than main app task
+        nullptr
+    );
+
+    assert(task_result == pdTRUE);
+}
+
+static void lvgl_task(TT_UNUSED void* arg) {
+    TT_LOG_I(TAG, "lvgl task started");
+
+    /** Ideally. the display handle would be created during Simulator.start(),
+     * but somehow that doesn't work. Waiting here from a ThreadFlag when that happens
+     * also doesn't work. It seems that it must be called from this task. */
+    displayHandle = lv_sdl_window_create(320, 240);
+    lv_sdl_window_set_title(displayHandle, "Tactility");
+
+    uint32_t task_delay_ms = task_max_sleep_ms;
+
+    task_set_running(true);
+
+    while (lvgl_task_is_running()) {
+        if (lvgl_lock(10)) {
+            task_delay_ms = lv_timer_handler();
+            lvgl_unlock();
+        }
+        if ((task_delay_ms > task_max_sleep_ms) || (1 == task_delay_ms)) {
+            task_delay_ms = task_max_sleep_ms;
+        } else if (task_delay_ms < 1) {
+            task_delay_ms = 1;
+        }
+        vTaskDelay(pdMS_TO_TICKS(task_delay_ms));
+    }
+
+    lv_disp_remove(displayHandle);
+    displayHandle = nullptr;
+    vTaskDelete(nullptr);
+}
+
@@ -0,0 +1,5 @@
+#pragma once
+
+void lvgl_task_start();
+bool lvgl_task_is_running();
+void lvgl_task_interrupt();
@@ -0,0 +1,62 @@
+#include "Main.h"
+#include <Tactility/TactilityCore.h>
+#include <Tactility/Thread.h>
+
+#include "FreeRTOS.h"
+#include "task.h"
+
+#define TAG "freertos"
+
+namespace simulator {
+
+MainFunction mainFunction = nullptr;
+
+void setMain(MainFunction newMainFunction) {
+    mainFunction = newMainFunction;
+}
+
+static void freertosMainTask(TT_UNUSED void* parameter) {
+    TT_LOG_I(TAG, "starting app_main()");
+    assert(simulator::mainFunction);
+    mainFunction();
+    TT_LOG_I(TAG, "returned from app_main()");
+    vTaskDelete(nullptr);
+}
+
+void freertosMain() {
+    BaseType_t task_result = xTaskCreate(
+        freertosMainTask,
+        "main",
+        8192,
+        nullptr,
+        static_cast<UBaseType_t>(tt::Thread::Priority::Normal),
+        nullptr
+    );
+
+    assert(task_result == pdTRUE);
+
+    // Blocks forever
+    vTaskStartScheduler();
+}
+
+} // namespace
+
+/**
+ * Assert implementation as defined in the FreeRTOSConfig.h
+ * It allows you to set breakpoints and debug asserts.
+ */
+void vAssertCalled(unsigned long line, const char* const file) {
+    static portBASE_TYPE xPrinted = pdFALSE;
+    volatile uint32_t set_to_nonzero_in_debugger_to_continue = 0;
+
+    TT_LOG_E(TAG, "assert triggered at %s:%d", file, line);
+    taskENTER_CRITICAL();
+    {
+        // Step out by attaching a debugger and setting set_to_nonzero_in_debugger_to_continue
+        while (set_to_nonzero_in_debugger_to_continue == 0) {
+            // NO-OP
+        }
+    }
+    taskEXIT_CRITICAL();
+}
+
@@ -0,0 +1,3 @@
+#pragma once
+
+typedef void (*MainFunction)();
@@ -0,0 +1,89 @@
+#include "LvglTask.h"
+#include "hal/SdlDisplay.h"
+#include "hal/SdlKeyboard.h"
+#include "hal/SimulatorPower.h"
+#include "hal/SimulatorSdCard.h"
+
+#include <src/lv_init.h> // LVGL
+#include <Tactility/hal/Configuration.h>
+
+#define TAG "hardware"
+
+using namespace tt::hal;
+
+static bool initBoot() {
+    lv_init();
+    lvgl_task_start();
+    return true;
+}
+
+TT_UNUSED static void deinitPower() {
+    lvgl_task_interrupt();
+    while (lvgl_task_is_running()) {
+        tt::kernel::delayMillis(10);
+    }
+
+#if LV_ENABLE_GC || !LV_MEM_CUSTOM
+    lv_deinit();
+#endif
+}
+
+static std::vector<std::shared_ptr<Device>> createDevices() {
+    return {
+        std::make_shared<SdlDisplay>(),
+        std::make_shared<SdlKeyboard>(),
+        std::make_shared<SimulatorPower>(),
+        std::make_shared<SimulatorSdCard>()
+    };
+}
+
+extern const Configuration hardwareConfiguration = {
+    .initBoot = initBoot,
+    .createDevices = createDevices,
+    .i2c = {
+        i2c::Configuration {
+            .name = "Internal",
+            .port = I2C_NUM_0,
+            .initMode = i2c::InitMode::ByTactility,
+            .isMutable = false,
+            .config = (i2c_config_t) {
+                .mode = I2C_MODE_MASTER,
+                .sda_io_num = 1,
+                .scl_io_num = 2,
+                .sda_pullup_en = true,
+                .scl_pullup_en = true,
+                .master = {
+                    .clk_speed = 400000
+                },
+                .clk_flags = 0
+            }
+        },
+        i2c::Configuration {
+            .name = "External",
+            .port = I2C_NUM_1,
+            .initMode = i2c::InitMode::ByTactility,
+            .isMutable = true,
+            .config = (i2c_config_t) {
+                .mode = I2C_MODE_MASTER,
+                .sda_io_num = 3,
+                .scl_io_num = 2,
+                .sda_pullup_en = false,
+                .scl_pullup_en = false,
+                .master = {
+                    .clk_speed = 400000
+                },
+                .clk_flags = 0
+            }
+        }
+    },
+    .uart = {
+        uart::Configuration {
+            .name = "/dev/ttyUSB0",
+            .baudRate = 115200
+        },
+        uart::Configuration {
+            .name = "/dev/ttyACM0",
+            .baudRate = 115200
+        }
+    }
+};
@@ -0,0 +1,21 @@
+#pragma once
+
+#include "Main.h"
+
+namespace simulator {
+    /** Set the function pointer of the real app_main() */
+    void setMain(MainFunction mainFunction);
+    /** The actual main task */
+    void freertosMain();
+}
+
+extern "C" {
+void app_main(); // ESP-IDF's main function, implemented in the application
+}
+
+int main() {
+    // Actual main function that passes on app_main() (to be executed in a FreeRTOS task) and bootstraps FreeRTOS
+    simulator::setMain(app_main);
+    simulator::freertosMain();
+    return 0;
+}
@@ -0,0 +1,28 @@
+#pragma once
+
+#include "SdlTouch.h"
+#include <Tactility/hal/display/DisplayDevice.h>
+
+/** Hack: variable comes from LvglTask.cpp */
+extern lv_disp_t* displayHandle;
+
+class SdlDisplay final : public tt::hal::display::DisplayDevice {
+
+public:
+
+    std::string getName() const override { return "SDL Display"; }
+    std::string getDescription() const override { return ""; }
+
+    bool start() override { return true; }
+    bool stop() override { tt_crash("Not supported"); }
+
+    bool supportsLvgl() const override { return true; }
+    bool startLvgl() override { return displayHandle != nullptr; }
+    bool stopLvgl() override { tt_crash("Not supported"); }
+    lv_display_t* _Nullable getLvglDisplay() const override { return displayHandle; }
+
+    std::shared_ptr<tt::hal::touch::TouchDevice> _Nullable getTouchDevice() override { return std::make_shared<SdlTouch>(); }
+
+    bool supportsDisplayDriver() const override { return false; }
+    std::shared_ptr<tt::hal::display::DisplayDriver> _Nullable getDisplayDriver() override { return nullptr; }
+};
@@ -0,0 +1,25 @@
+#pragma once
+
+#include <Tactility/hal/keyboard/KeyboardDevice.h>
+#include <Tactility/TactilityCore.h>
+
+class SdlKeyboard final : public tt::hal::keyboard::KeyboardDevice {
+
+    lv_indev_t* _Nullable handle = nullptr;
+
+public:
+
+    std::string getName() const override { return "SDL Keyboard"; }
+    std::string getDescription() const override { return "SDL keyboard device"; }
+
+    bool startLvgl(lv_display_t* display) override {
+        handle = lv_sdl_keyboard_create();
+        return handle != nullptr;
+    }
+
+    bool stopLvgl() override { tt_crash("Not supported"); }
+
+    bool isAttached() const override { return true; }
+
+    lv_indev_t* _Nullable getLvglIndev() override { return handle; }
+};
@@ -0,0 +1,35 @@
+#pragma once
+
+#include "Tactility/hal/touch/TouchDevice.h"
+#include <Tactility/TactilityCore.h>
+
+class SdlTouch final : public tt::hal::touch::TouchDevice {
+
+    lv_indev_t* _Nullable handle = nullptr;
+
+public:
+
+    std::string getName() const override { return "SDL Mouse"; }
+
+    std::string getDescription() const override { return "SDL mouse/touch pointer device"; }
+
+    bool start() override { return true; }
+
+    bool stop() override { tt_crash("Not supported"); }
+
+    bool supportsLvgl() const override { return true; }
+
+    bool startLvgl(lv_display_t* display) override {
+        handle = lv_sdl_mouse_create();
+        return handle != nullptr;
+    }
+
+    bool stopLvgl() override { tt_crash("Not supported"); }
+
+    lv_indev_t* _Nullable getLvglIndev() override { return handle; }
+
+    bool supportsTouchDriver() override { return false; }
+
+    std::shared_ptr<tt::hal::touch::TouchDriver> _Nullable getTouchDriver() override { return nullptr; };
+};
+
@@ -0,0 +1,36 @@
+#include "SimulatorPower.h"
+
+constexpr auto* TAG = "SimulatorPower";
+
+bool SimulatorPower::supportsMetric(MetricType type) const {
+    switch (type) {
+        using enum MetricType;
+        case IsCharging:
+        case Current:
+        case BatteryVoltage:
+        case ChargeLevel:
+            return true;
+    }
+
+    return false; // Safety guard for when new enum values are introduced
+}
+
+bool SimulatorPower::getMetric(MetricType type, MetricData& data) {
+    switch (type) {
+        using enum MetricType;
+        case IsCharging:
+            data.valueAsBool = true;
+            return true;
+        case Current:
+            data.valueAsInt32 = 42;
+            return true;
+        case BatteryVoltage:
+            data.valueAsUint32 = 4032;
+            return true;
+        case ChargeLevel:
+            data.valueAsUint8 = 100;
+            return true;
+    }
+
+    return false; // Safety guard for when new enum values are introduced
+}
@@ -0,0 +1,26 @@
+#pragma once
+
+#include <Tactility/hal/power/PowerDevice.h>
+#include <memory>
+
+using tt::hal::power::PowerDevice;
+
+class SimulatorPower final : public PowerDevice {
+
+    bool allowedToCharge = false;
+
+public:
+
+    SimulatorPower() = default;
+    ~SimulatorPower() override = default;
+
+    std::string getName() const override { return "Power Mock"; }
+    std::string getDescription() const override { return ""; }
+
+    bool supportsMetric(MetricType type) const override;
+    bool getMetric(MetricType type, MetricData& data) override;
+
+    bool supportsChargeControl() const override { return true; }
+    bool isAllowedToCharge() const override { return allowedToCharge; }
+    void setAllowedToCharge(bool canCharge) override { allowedToCharge = canCharge; }
+};
@@ -0,0 +1,42 @@
+#pragma once
+
+#include "Tactility/hal/sdcard/SdCardDevice.h"
+#include <Tactility/Mutex.h>
+#include <memory>
+
+using tt::hal::sdcard::SdCardDevice;
+
+class SimulatorSdCard final : public SdCardDevice {
+
+    State state;
+    std::shared_ptr<tt::Lock> lock;
+    std::string mountPath;
+
+public:
+
+    SimulatorSdCard() : SdCardDevice(MountBehaviour::AtBoot),
+        state(State::Unmounted),
+        lock(std::make_shared<tt::Mutex>(tt::Mutex::Type::Recursive))
+    {}
+
+    std::string getName() const override { return "Mock SD Card"; }
+    std::string getDescription() const override { return ""; }
+
+    bool mount(const std::string& newMountPath) override {
+        state = State::Mounted;
+        mountPath = newMountPath;
+        return true;
+    }
+
+    bool unmount() override {
+        state = State::Unmounted;
+        mountPath = "";
+        return true;
+    }
+
+    std::string getMountPath() const override { return mountPath; }
+
+    std::shared_ptr<tt::Lock> getLock() const override { return lock; }
+
+    State getState(TickType_t timeout) const override { return state; }
+};