Merge develop into main (#303)

- `DisplayDevice` improvements related `DisplayDriver`
- Replaced incorrect usage of `spiBusHandle` with `spiHostDevice` in all SPI display devices
- Disabled `DisplayDriver` support for RGB displays for now
- Updated `GraphicsDemo` project for the above changes
- TactilityC improvements:
  - created `tt_hal_device_find()`
  - created `tt_hal_display_*`
  - created `tt_hal_touch_*`
  - created `tt_lvgl_*`
  - export `tt_app_*` calls

TactilityC/Include/tt_hal_device.h

@@ -0,0 +1,33 @@
+#pragma once
+
+#include <stdint.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+enum DeviceType {
+    DEVICE_TYPE_I2C,
+    DEVICE_TYPE_DISPLAY,
+    DEVICE_TYPE_TOUCH,
+    DEVICE_TYPE_SDCARD,
+    DEVICE_TYPE_KEYBOARD,
+    DEVICE_TYPE_POWER,
+    DEVICE_TYPE_GPS
+};
+
+typedef uint32_t DeviceId;
+
+/**
+ * Find one or more devices of a certain type.
+ * @param[in] type the type to look for
+ * @param[inout] deviceIds the output ids, which should fit at least maxCount amount of devices
+ * @param[out] count the resulting number of device ids that were returned
+ * @param[in] maxCount the maximum number of items that the "deviceIds" output can contain (minimum value is 1)
+ * @return true if one or more devices were found
+ */
+bool tt_hal_device_find(DeviceType type, DeviceId* deviceIds, uint16_t* count, uint16_t maxCount);
+
+#ifdef __cplusplus
+}
+#endif

TactilityC/Include/tt_hal_display.h

@@ -0,0 +1,91 @@
+#pragma once
+
+#include <tt_kernel.h>
+
+#include "tt_hal_device.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef void* DisplayDriverHandle;
+
+enum ColorFormat {
+    COLOR_FORMAT_MONOCHROME, // 1 bpp
+    COLOR_FORMAT_BGR565,
+    COLOR_FORMAT_BGR565_SWAPPED,
+    COLOR_FORMAT_RGB565,
+    COLOR_FORMAT_RGB565_SWAPPED,
+    COLOR_FORMAT_RGB888
+};
+
+/**
+ * Check if the display driver interface is supported for this device.
+ * @param[in] displayId the identifier of the display device
+ * @return true if the driver is supported.
+ */
+bool tt_hal_display_driver_supported(DeviceId displayId);
+
+/**
+ * Allocate a driver object for the specified displayId.
+ * @warning check whether the driver is supported by calling tt_hal_display_driver_supported() first
+ * @param[in] displayId the identifier of the display device
+ * @return the driver handle
+ */
+DisplayDriverHandle tt_hal_display_driver_alloc(DeviceId displayId);
+
+/**
+ * Free the memory for the display driver.
+ * @param[in] handle the display driver handle
+ */
+void tt_hal_display_driver_free(DisplayDriverHandle handle);
+
+/**
+ * Lock the display device. Call this function before doing any draw calls.
+ * Certain display devices are on a shared bus (e.g. SPI) so they must run
+ * mutually exclusive with other devices on the same bus (e.g. SD card)
+ * @param[in] handle the display driver handle
+ * @param[in] timeout the maximum amount of ticks to wait for getting a lock
+ * @return true if the lock was acquired
+ */
+bool tt_hal_display_driver_lock(DisplayDriverHandle handle, TickType timeout);
+
+/**
+ * Unlock the display device. Must be called exactly once after locking.
+ * @param[in] handle the display driver handle
+ */
+void tt_hal_display_driver_unlock(DisplayDriverHandle handle);
+
+/**
+ * @param[in] handle the display driver handle
+ * @return the native color format for this display
+ */
+ColorFormat tt_hal_display_driver_get_colorformat(DisplayDriverHandle handle);
+
+/**
+ * @param[in] handle the display driver handle
+ * @return the horizontal resolution of the display
+ */
+uint16_t tt_hal_display_driver_get_pixel_width(DisplayDriverHandle handle);
+
+/**
+ * @param[in] handle the display driver handle
+ * @return the vertical resolution of the display
+ */
+uint16_t tt_hal_display_driver_get_pixel_height(DisplayDriverHandle handle);
+
+/**
+ * Draw pixels on the screen. Make sure to call the lock function first and unlock afterwards.
+ * Many draw calls can be done inbetween a single lock and unlock.
+ * @param[in] handle the display driver handle
+ * @param[in] xStart the starting x coordinate for rendering the pixel data
+ * @param[in] yStart the starting y coordinate for rendering the pixel data
+ * @param[in] xEnd the last x coordinate for rendering the pixel data (absolute pixel value, not relative to xStart!)
+ * @param[in] yEnd the last y coordinate for rendering the pixel data (absolute pixel value, not relative to yStart!)
+ * @param[in] pixelData a buffer of pixels. the data is placed as "RowRowRowRow". The size depends on the ColorFormat
+ */
+void tt_hal_display_driver_draw_bitmap(DisplayDriverHandle handle, int xStart, int yStart, int xEnd, int yEnd, const void* pixelData);
+
+#ifdef __cplusplus
+}
+#endif

TactilityC/Include/tt_hal_touch.h

@@ -0,0 +1,47 @@
+#pragma once
+
+#include "tt_hal_device.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef void* TouchDriverHandle;
+/**
+ * Check if the touch driver interface is supported for this device.
+ * @param[in] touchDeviceId the identifier of the touch device
+ * @return true if the driver is supported.
+ */
+bool tt_hal_touch_driver_supported(DeviceId touchDeviceId);
+
+/**
+ * Allocate a driver object for the specified touchDeviceId.
+ * @warning check whether the driver is supported by calling tt_hal_touch_driver_supported() first
+ * @param[in] touchDeviceId the identifier of the touch device
+ * @return the driver handle
+ */
+TouchDriverHandle tt_hal_touch_driver_alloc(DeviceId touchDeviceId);
+
+/**
+ * Free the memory for the touch driver.
+ * @param[in] handle the touch driver handle
+ */
+void tt_hal_touch_driver_free(TouchDriverHandle handle);
+
+/**
+ * Get the coordinates for the currently touched points on the screen.
+ *
+ * @param[in] handle the touch driver handle
+ * @param[in] x array of X coordinates
+ * @param[in] y array of Y coordinates
+ * @param[in] strength array of strengths (with the minimum size of maxPointCount) or NULL
+ * @param[in] pointCount the number of points currently touched on the screen
+ * @param[in] maxPointCount the maximum number of points that can be touched at once
+ *
+ * @return true when touched and coordinates are available
+ */
+bool tt_hal_touch_driver_get_touched_points(TouchDriverHandle handle, uint16_t* x, uint16_t* y, uint16_t* strength, uint8_t* pointCount, uint8_t maxPointCount);
+
+#ifdef __cplusplus
+}
+#endif

TactilityC/Include/tt_kernel.h

@@ -0,0 +1,50 @@
+#pragma once
+
+#include <stdint.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef unsigned long TickType;
+
+/**
+ * Stall the current task for the specified amount of time.
+ * @param milliseconds the time in milliseconds to stall.
+ */
+void tt_kernel_delay_millis(uint32_t milliseconds);
+
+/**
+ * Stall the current task for the specified amount of time.
+ * @param milliseconds the time in microsends to stall.
+ */
+void tt_kernel_delay_micros(uint32_t microSeconds);
+
+/**
+ * Stall the current task for the specified amount of time.
+ * @param milliseconds the time in ticks to stall.
+ */
+void tt_kernel_delay_ticks(TickType ticks);
+
+/** @return the number of ticks since the device was started */
+TickType tt_kernel_get_ticks();
+
+/** Convert milliseconds to ticks */
+TickType tt_kernel_millis_to_ticks(uint32_t milliSeconds);
+
+/** Stall the current task until the specified timestamp
+ * @return false if for some reason the delay was broken off
+ */
+bool tt_kernel_delay_until_tick(TickType tick);
+
+/** @return the tick frequency of the kernel (commonly 1000 Hz when running FreeRTOS) */
+uint32_t tt_kernel_get_tick_frequency();
+
+/** @return the number of milliseconds that have passed since the device was started */
+uint32_t tt_kernel_get_millis();
+
+unsigned long tt_kernel_get_micros();
+
+#ifdef __cplusplus
+}
+#endif

TactilityC/Include/tt_lvgl.h

@@ -0,0 +1,18 @@
+#pragma once
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/** @return true if LVGL is started and active */
+bool tt_lvgl_is_started();
+
+/** Start LVGL and related background services */
+void tt_lvgl_start();
+
+/** Stop LVGL and related background services */
+void tt_lvgl_stop();
+
+#ifdef __cplusplus
+}
+#endif

TactilityC/Source/tt_hal_device.cpp

@@ -0,0 +1,48 @@
+#include "tt_hal_device.h"
+
+#include "Tactility/Check.h"
+
+#include <Tactility/hal/Device.h>
+
+static tt::hal::Device::Type toTactilityDeviceType(DeviceType type) {
+    switch (type) {
+        case DEVICE_TYPE_I2C:
+            return tt::hal::Device::Type::I2c;
+        case DEVICE_TYPE_DISPLAY:
+            return tt::hal::Device::Type::Display;
+        case DEVICE_TYPE_TOUCH:
+            return tt::hal::Device::Type::Touch;
+        case DEVICE_TYPE_SDCARD:
+            return tt::hal::Device::Type::SdCard;
+        case DEVICE_TYPE_KEYBOARD:
+            return tt::hal::Device::Type::Keyboard;
+        case DEVICE_TYPE_POWER:
+            return tt::hal::Device::Type::Power;
+        case DEVICE_TYPE_GPS:
+            return tt::hal::Device::Type::Gps;
+        default:
+            tt_crash("Device::Type not supported");
+    }
+}
+
+extern "C" {
+
+bool tt_hal_device_find(DeviceType type, DeviceId* deviceIds, uint16_t* count, uint16_t maxCount) {
+    assert(maxCount > 0);
+
+    int16_t currentIndex = -1;
+    uint16_t maxIndex = maxCount - 1;
+
+    findDevices(toTactilityDeviceType(type), [&](const std::shared_ptr<tt::hal::Device>& device) {
+        currentIndex++;
+        deviceIds[currentIndex] = device->getId();
+        // Continue if there is storage capacity left
+        return currentIndex < maxIndex;
+    });
+
+    *count = currentIndex + 1;
+
+    return currentIndex >= 0;
+}
+
+}

TactilityC/Source/tt_hal_display.cpp

@@ -0,0 +1,88 @@
+#include "tt_hal_display.h"
+
+#include "Tactility/Check.h"
+#include "Tactility/hal/Device.h"
+#include "Tactility/hal/display/DisplayDevice.h"
+#include "Tactility/hal/display/DisplayDriver.h"
+
+static ColorFormat toColorFormat(tt::hal::display::ColorFormat format) {
+    switch (format) {
+        case tt::hal::display::ColorFormat::Monochrome:
+            return COLOR_FORMAT_MONOCHROME;
+        case tt::hal::display::ColorFormat::BGR565:
+            return COLOR_FORMAT_BGR565;
+        case tt::hal::display::ColorFormat::BGR565Swapped:
+            return COLOR_FORMAT_BGR565_SWAPPED;
+        case tt::hal::display::ColorFormat::RGB565:
+            return COLOR_FORMAT_RGB565;
+        case tt::hal::display::ColorFormat::RGB565Swapped:
+            return COLOR_FORMAT_RGB565_SWAPPED;
+        case tt::hal::display::ColorFormat::RGB888:
+            return COLOR_FORMAT_RGB888;
+        default:
+            tt_crash("ColorFormat not supported");
+    }
+}
+
+struct DriverWrapper {
+    std::shared_ptr<tt::hal::display::DisplayDriver> driver;
+    DriverWrapper(std::shared_ptr<tt::hal::display::DisplayDriver> driver) : driver(driver) {}
+};
+
+static std::shared_ptr<tt::hal::display::DisplayDevice> findValidDisplayDevice(tt::hal::Device::Id id) {
+    auto device = tt::hal::findDevice(id);
+    if (device == nullptr || device->getType() != tt::hal::Device::Type::Display) {
+        return nullptr;
+    }
+    return std::reinterpret_pointer_cast<tt::hal::display::DisplayDevice>(device);
+}
+
+extern "C" {
+
+bool tt_hal_display_driver_supported(DeviceId id) {
+    auto display = findValidDisplayDevice(id);
+    return display != nullptr && display->supportsDisplayDriver();
+}
+
+DisplayDriverHandle tt_hal_display_driver_alloc(DeviceId id) {
+    auto display = findValidDisplayDevice(id);
+    assert(display->supportsDisplayDriver());
+    return new DriverWrapper(display->getDisplayDriver());
+}
+
+void tt_hal_display_driver_free(DisplayDriverHandle handle) {
+    auto wrapper = static_cast<DriverWrapper*>(handle);
+    delete wrapper;
+}
+
+bool tt_hal_display_driver_lock(DisplayDriverHandle handle, TickType timeout) {
+    auto wrapper = static_cast<DriverWrapper*>(handle);
+    return wrapper->driver->getLock()->lock(timeout);
+}
+
+void tt_hal_display_driver_unlock(DisplayDriverHandle handle) {
+    auto wrapper = static_cast<DriverWrapper*>(handle);
+    wrapper->driver->getLock()->unlock();
+}
+
+ColorFormat tt_hal_display_driver_get_colorformat(DisplayDriverHandle handle) {
+    auto wrapper = static_cast<DriverWrapper*>(handle);
+    return toColorFormat(wrapper->driver->getColorFormat());
+}
+
+uint16_t tt_hal_display_driver_get_pixel_width(DisplayDriverHandle handle) {
+    auto wrapper = static_cast<DriverWrapper*>(handle);
+    return wrapper->driver->getPixelWidth();
+}
+
+uint16_t tt_hal_display_driver_get_pixel_height(DisplayDriverHandle handle) {
+    auto wrapper = static_cast<DriverWrapper*>(handle);
+    return wrapper->driver->getPixelHeight();
+}
+
+void tt_hal_display_driver_draw_bitmap(DisplayDriverHandle handle, int xStart, int yStart, int xEnd, int yEnd, const void* pixelData) {
+    auto wrapper = static_cast<DriverWrapper*>(handle);
+    wrapper->driver->drawBitmap(xStart, yStart, xEnd, yEnd, pixelData);
+}
+
+}

TactilityC/Source/tt_hal_touch.cpp

@@ -0,0 +1,43 @@
+#include "tt_hal_touch.h"
+
+#include "Tactility/hal/Device.h"
+#include "Tactility/hal/touch/TouchDevice.h"
+#include "Tactility/hal/touch/TouchDriver.h"
+
+struct DriverWrapper {
+    std::shared_ptr<tt::hal::touch::TouchDriver> driver;
+    DriverWrapper(std::shared_ptr<tt::hal::touch::TouchDriver> driver) : driver(driver) {}
+};
+
+static std::shared_ptr<tt::hal::touch::TouchDevice> findValidTouchDevice(tt::hal::Device::Id id) {
+    auto device = tt::hal::findDevice(id);
+    if (device == nullptr || device->getType() != tt::hal::Device::Type::Touch) {
+        return nullptr;
+    }
+    return std::reinterpret_pointer_cast<tt::hal::touch::TouchDevice>(device);
+}
+
+extern "C" {
+
+bool tt_hal_touch_driver_supported(DeviceId id) {
+    auto touch = findValidTouchDevice(id);
+    return touch != nullptr && touch->supportsTouchDriver();
+}
+
+TouchDriverHandle tt_hal_touch_driver_alloc(DeviceId id) {
+    auto touch = findValidTouchDevice(id);
+    assert(touch->supportsTouchDriver());
+    return new DriverWrapper(touch->getTouchDriver());
+}
+
+void tt_hal_touch_driver_free(TouchDriverHandle handle) {
+    DriverWrapper* wrapper = static_cast<DriverWrapper*>(handle);
+    delete wrapper;
+}
+
+bool tt_hal_touch_driver_get_touched_points(TouchDriverHandle handle, uint16_t* x, uint16_t* y, uint16_t* _Nullable strength, uint8_t* pointCount, uint8_t maxPointCount) {
+    DriverWrapper* wrapper = static_cast<DriverWrapper*>(handle);
+    return wrapper->driver->getTouchedPoints(x, y, strength, pointCount, maxPointCount);
+}
+
+}

TactilityC/Source/tt_init.cpp

@@ -6,7 +6,12 @@
 #include "tt_app_selectiondialog.h"
 #include "tt_bundle.h"
 #include "tt_gps.h"
+#include "tt_hal_device.h"
+#include "tt_hal_display.h"
 #include "tt_hal_i2c.h"
+#include "tt_hal_touch.h"
+#include "tt_kernel.h"
+#include "tt_lvgl.h"
 #include "tt_lvgl_keyboard.h"
 #include "tt_lvgl_spinner.h"
 #include "tt_lvgl_toolbar.h"
@@ -103,6 +108,9 @@ const esp_elfsym elf_symbols[] {
     ESP_ELFSYM_EXPORT(esp_log_write),
     ESP_ELFSYM_EXPORT(esp_log_timestamp),
     // Tactility
+    ESP_ELFSYM_EXPORT(tt_app_start),
+    ESP_ELFSYM_EXPORT(tt_app_start_with_bundle),
+    ESP_ELFSYM_EXPORT(tt_app_stop),
     ESP_ELFSYM_EXPORT(tt_app_register),
     ESP_ELFSYM_EXPORT(tt_app_get_parameters),
     ESP_ELFSYM_EXPORT(tt_app_set_result),
@@ -121,6 +129,16 @@ const esp_elfsym elf_symbols[] {
     ESP_ELFSYM_EXPORT(tt_bundle_put_string),
     ESP_ELFSYM_EXPORT(tt_gps_has_coordinates),
     ESP_ELFSYM_EXPORT(tt_gps_get_coordinates),
+    ESP_ELFSYM_EXPORT(tt_hal_device_find),
+    ESP_ELFSYM_EXPORT(tt_hal_display_driver_alloc),
+    ESP_ELFSYM_EXPORT(tt_hal_display_driver_draw_bitmap),
+    ESP_ELFSYM_EXPORT(tt_hal_display_driver_free),
+    ESP_ELFSYM_EXPORT(tt_hal_display_driver_get_colorformat),
+    ESP_ELFSYM_EXPORT(tt_hal_display_driver_get_pixel_height),
+    ESP_ELFSYM_EXPORT(tt_hal_display_driver_get_pixel_width),
+    ESP_ELFSYM_EXPORT(tt_hal_display_driver_lock),
+    ESP_ELFSYM_EXPORT(tt_hal_display_driver_unlock),
+    ESP_ELFSYM_EXPORT(tt_hal_display_driver_supported),
     ESP_ELFSYM_EXPORT(tt_hal_i2c_start),
     ESP_ELFSYM_EXPORT(tt_hal_i2c_stop),
     ESP_ELFSYM_EXPORT(tt_hal_i2c_is_started),
@@ -132,6 +150,22 @@ const esp_elfsym elf_symbols[] {
     ESP_ELFSYM_EXPORT(tt_hal_i2c_master_has_device_at_address),
     ESP_ELFSYM_EXPORT(tt_hal_i2c_lock),
     ESP_ELFSYM_EXPORT(tt_hal_i2c_unlock),
+    ESP_ELFSYM_EXPORT(tt_hal_touch_driver_supported),
+    ESP_ELFSYM_EXPORT(tt_hal_touch_driver_alloc),
+    ESP_ELFSYM_EXPORT(tt_hal_touch_driver_free),
+    ESP_ELFSYM_EXPORT(tt_hal_touch_driver_get_touched_points),
+    ESP_ELFSYM_EXPORT(tt_kernel_delay_millis),
+    ESP_ELFSYM_EXPORT(tt_kernel_delay_micros),
+    ESP_ELFSYM_EXPORT(tt_kernel_delay_ticks),
+    ESP_ELFSYM_EXPORT(tt_kernel_get_ticks),
+    ESP_ELFSYM_EXPORT(tt_kernel_millis_to_ticks),
+    ESP_ELFSYM_EXPORT(tt_kernel_delay_until_tick),
+    ESP_ELFSYM_EXPORT(tt_kernel_get_tick_frequency),
+    ESP_ELFSYM_EXPORT(tt_kernel_get_millis),
+    ESP_ELFSYM_EXPORT(tt_kernel_get_micros),
+    ESP_ELFSYM_EXPORT(tt_lvgl_is_started),
+    ESP_ELFSYM_EXPORT(tt_lvgl_start),
+    ESP_ELFSYM_EXPORT(tt_lvgl_stop),
     ESP_ELFSYM_EXPORT(tt_lvgl_software_keyboard_show),
     ESP_ELFSYM_EXPORT(tt_lvgl_software_keyboard_hide),
     ESP_ELFSYM_EXPORT(tt_lvgl_software_keyboard_is_enabled),

TactilityC/Source/tt_kernel.cpp

@@ -0,0 +1,42 @@
+#include "tt_kernel.h"
+#include <Tactility/kernel/Kernel.h>
+
+extern "C" {
+
+void tt_kernel_delay_millis(uint32_t milliseconds) {
+    tt::kernel::delayMillis(milliseconds);
+}
+
+void tt_kernel_delay_micros(uint32_t microSeconds) {
+    tt::kernel::delayMicros(microSeconds);
+}
+
+void tt_kernel_delay_ticks(TickType ticks) {
+    tt::kernel::delayTicks((TickType_t)ticks);
+}
+
+TickType tt_kernel_get_ticks() {
+    return tt::kernel::getTicks();
+}
+
+TickType tt_kernel_millis_to_ticks(uint32_t milliSeconds) {
+    return tt::kernel::millisToTicks(milliSeconds);
+}
+
+bool tt_kernel_delay_until_tick(TickType tick) {
+    return tt::kernel::delayUntilTick(tick);
+}
+
+uint32_t tt_kernel_get_tick_frequency() {
+    return tt::kernel::getTickFrequency();
+}
+
+uint32_t tt_kernel_get_millis() {
+    return tt::kernel::getMillis();
+}
+
+unsigned long tt_kernel_get_micros() {
+    return tt::kernel::getMicros();
+}
+
+}

TactilityC/Source/tt_lvgl.cpp

@@ -0,0 +1,17 @@
+#include <Tactility/lvgl/Lvgl.h>
+
+extern "C" {
+
+bool tt_lvgl_is_started() {
+    return tt::lvgl::isStarted();
+}
+
+void tt_lvgl_start() {
+    tt::lvgl::start();
+}
+
+void tt_lvgl_stop() {
+    tt::lvgl::stop();
+}
+
+}