Add missing timer methods to TactilityC (#443)

- Removed custom `TickType`
- Removed TactilityC functionality that is now covered by TactilityFreeRtos

.github/actions/bundle-artifacts/action.yml

@@ -6,10 +6,10 @@ runs:
     - name: 'Download artifacts'
       uses: actions/download-artifact@v4
       with:
-        path: firmwares
+        path: artifacts
     - name: 'Upload Artifact'
       uses: actions/upload-artifact@v4
       with:
-        name: 'all-firmwares'
+        name: 'all-artifacts'
-        path: firmwares/
+        path: artifacts/
         retention-days: 3

.github/actions/publish-firmware/action.yml

@@ -8,17 +8,17 @@ inputs:
 runs:
   using: 'composite'
   steps:
-    - name: 'Download all-firmwares'
+    - name: 'Download all-artifacts'
       uses: actions/download-artifact@v4
       with:
-        name: 'all-firmwares'
+        name: 'all-artifacts'
-        path: firmwares
+        path: artifacts
     - name: 'Install boto3'
       shell: bash
       run: pip install boto3
     - name: 'Generate files'
       shell: bash
-      run: version=`cat version.txt` && python Buildscripts/CDN/generate-files.py firmwares firmwares-cdn $version
+      run: version=`cat version.txt` && python Buildscripts/CDN/generate-firmware-files.py artifacts artifacts-cdn $version
     - name: 'Upload files'
       shell: bash
-      run: python Buildscripts/CDN/upload-files.py firmwares-cdn ${{ inputs.cdn_version }} ${{ env.CDN_ID }} ${{ env.CDN_TOKEN_NAME }} ${{ env.CDN_TOKEN_VALUE }}
+      run: python Buildscripts/CDN/upload-firmware-files.py artifacts-cdn ${{ inputs.cdn_version }} ${{ env.CDN_ID }} ${{ env.CDN_TOKEN_NAME }} ${{ env.CDN_TOKEN_VALUE }}

.github/actions/publish-sdk/action.yml

@@ -0,0 +1,19 @@
+name: Publish SDK
+
+runs:
+  using: 'composite'
+  steps:
+    - name: 'Download all-artifacts'
+      uses: actions/download-artifact@v4
+      with:
+        name: 'all-artifacts'
+        path: artifacts
+    - name: 'Install boto3'
+      shell: bash
+      run: pip install boto3
+    - name: 'Generate files'
+      shell: bash
+      run: version=`cat version.txt` && python Buildscripts/CDN/generate-sdk-files.py artifacts artifacts-cdn $version
+    - name: 'Upload files'
+      shell: bash
+      run: version=`cat version.txt` && python Buildscripts/CDN/upload-sdk-files.py artifacts-cdn $version ${{ env.CDN_ID }} ${{ env.CDN_TOKEN_NAME }} ${{ env.CDN_TOKEN_VALUE }}

.github/workflows/build.yml

@@ -78,7 +78,7 @@ jobs:
         with:
           board_id: ${{ matrix.board.id }}
           arch: ${{ matrix.board.arch }}
-  BundleFirmware:
+  BundleArtifacts:
     runs-on: ubuntu-latest
     needs: [ BuildFirmware ]
     if: |
@@ -86,11 +86,11 @@ jobs:
       (github.event_name == 'push' && startsWith(github.ref, 'refs/tags/v'))
     steps:
       - uses: actions/checkout@v4
-      - name: "Bundle Firmware"
+      - name: "Bundle Artifacts"
-        uses: ./.github/actions/bundle-firmware
+        uses: ./.github/actions/bundle-artifacts
   PublishFirmwareSnapshot:
     runs-on: ubuntu-latest
-    needs: [ BundleFirmware ]
+    needs: [ BundleArtifacts ]
     if: (github.event_name == 'push' && github.ref == 'refs/heads/main')
     steps:
       - uses: actions/checkout@v4
@@ -104,7 +104,7 @@ jobs:
           cdn_version: snapshot
   PublishFirmwareStable:
     runs-on: ubuntu-latest
-    needs: [ BundleFirmware ]
+    needs: [ BundleArtifacts ]
     if: (github.event_name == 'push' && startsWith(github.ref, 'refs/tags/v'))
     steps:
       - uses: actions/checkout@v4
@@ -115,4 +115,16 @@ jobs:
           CDN_TOKEN_VALUE: ${{ secrets.CDN_TOKEN_VALUE }}
         uses: ./.github/actions/publish-firmware
         with:
-          cdn_version: stable
+          cdn_version: stable
+  PublishSdk:
+    runs-on: ubuntu-latest
+    needs: [ BundleArtifacts ]
+    if: (github.event_name == 'push' && (github.ref == 'refs/heads/main' || startsWith(github.ref, 'refs/tags/v')))
+    steps:
+      - uses: actions/checkout@v4
+      - name: "Publish SDKs"
+        env:
+          CDN_ID: ${{ secrets.CDN_ID }}
+          CDN_TOKEN_NAME: ${{ secrets.CDN_TOKEN_NAME }}
+          CDN_TOKEN_VALUE: ${{ secrets.CDN_TOKEN_VALUE }}
+        uses: ./.github/actions/publish-sdk

Buildscripts/CDN/generate-firmware-files.py

@@ -45,14 +45,9 @@ class DeviceIndex:
     gitCommit: str
     devices: list
 
-if sys.platform == "win32":
+shell_color_red = "\033[91m"
-    shell_color_red = ""
+shell_color_orange = "\033[93m"
-    shell_color_orange = ""
+shell_color_reset = "\033[m"
-    shell_color_reset = ""
-else:
-    shell_color_red = "\033[91m"
-    shell_color_orange = "\033[93m"
-    shell_color_reset = "\033[m"
 
 def print_warning(message):
     print(f"{shell_color_orange}WARNING: {message}{shell_color_reset}")
@@ -61,7 +56,7 @@ def print_error(message):
     print(f"{shell_color_red}ERROR: {message}{shell_color_reset}")
 
 def print_help():
-    print("Usage: python generate-files.py [inPath] [outPath] [version]")
+    print("Usage: python generate-firmware-files.py [inPath] [outPath] [version]")
     print("     inPath   path with the extracted release files")
     print("     outPath  path where the CDN files will become available")
     print("     version  technical version name (e.g. 1.2.0)")
@@ -228,7 +223,7 @@ if __name__ == "__main__":
     # Argument validation
     if len(sys.argv) < 4:
         print_help()
-        sys.exit()
+        sys.exit(1)
     if "--verbose" in sys.argv:
         VERBOSE = True
         sys.argv.remove("--verbose")

Buildscripts/CDN/generate-sdk-files.py

@@ -0,0 +1,86 @@
+import subprocess
+from datetime import datetime, UTC
+import os
+import sys
+from dataclasses import dataclass, asdict
+import json
+import shutil
+
+VERBOSE = False
+
+@dataclass
+class SdkIndex:
+    version: str
+    created: str
+    gitCommit: str
+    platforms: dict
+
+shell_color_red = "\033[91m"
+shell_color_orange = "\033[93m"
+shell_color_reset = "\033[m"
+
+def print_warning(message):
+    print(f"{shell_color_orange}WARNING: {message}{shell_color_reset}")
+
+def print_error(message):
+    print(f"{shell_color_red}ERROR: {message}{shell_color_reset}")
+
+def exit_with_error(message):
+    print_error(message)
+    sys.exit(1)
+
+def print_help():
+    print("Usage: python generate-sdk-files.py [inPath] [outPath] [version]")
+    print("     inPath   path with the extracted release files")
+    print("     outPath  path where the CDN files will become available")
+    print("     version  technical version name (e.g. 1.2.0)")
+    print("Options:")
+    print("  --verbose                      Show extra console output")
+
+def get_git_commit_hash():
+    return subprocess.check_output(['git', 'rev-parse', 'HEAD']).decode('ascii').strip()
+
+def main(in_path: str, out_path: str, version: str):
+    if not os.path.exists(in_path):
+        exit_with_error(f"Input path not found: {in_path}")
+    if os.path.exists(out_path):
+        shutil.rmtree(out_path)
+    os.mkdir(out_path)
+    artifact_directories = os.listdir(in_path)
+    sdk_index = SdkIndex(
+        version=version,
+        created=datetime.now(UTC).strftime('%Y-%m-%dT%H:%M:%S'),
+        gitCommit=get_git_commit_hash(),
+        platforms={}
+    )
+    for artifact_directory in artifact_directories:
+        if VERBOSE:
+            print(f"Processing {in_path}/{artifact_directory}")
+        if not artifact_directory.startswith("TactilitySDK-"):
+            continue
+        sdk_platform = artifact_directory.removeprefix("TactilitySDK-")
+        if not sdk_platform:
+            exit_with_error(f"Cannot derive platform from directory name: {artifact_directory}")
+        sdk_index.platforms[sdk_platform] = f"{artifact_directory}.zip"
+        if VERBOSE:
+            print(f"Archiving {in_path}/{artifact_directory} to {out_path}/{artifact_directory}.zip")
+        shutil.make_archive(os.path.join(out_path, artifact_directory), 'zip', os.path.join(in_path, artifact_directory))
+    index_file_path = os.path.join(out_path, "index.json")
+    if VERBOSE:
+        print(f"Generating {index_file_path}")
+    with open(index_file_path, "w") as index_file:
+        json.dump(asdict(sdk_index), index_file, indent=2)
+
+if __name__ == "__main__":
+    print("Tactility CDN SDK File Generator")
+    if "--help" in sys.argv:
+        print_help()
+        sys.exit()
+    # Argument validation
+    if len(sys.argv) < 4:
+        print_help()
+        sys.exit(1)
+    if "--verbose" in sys.argv:
+        VERBOSE = True
+        sys.argv.remove("--verbose")
+    main(in_path=sys.argv[1], out_path=sys.argv[2], version=sys.argv[3])

Buildscripts/CDN/upload-firmware-files.py

@@ -2,14 +2,9 @@ import os
 import sys
 import boto3
 
-if sys.platform == "win32":
+SHELL_COLOR_RED = "\033[91m"
-    SHELL_COLOR_RED = ""
+SHELL_COLOR_ORANGE = "\033[93m"
-    SHELL_COLOR_ORANGE = ""
+SHELL_COLOR_RESET = "\033[m"
-    SHELL_COLOR_RESET = ""
-else:
-    SHELL_COLOR_RED = "\033[91m"
-    SHELL_COLOR_ORANGE = "\033[93m"
-    SHELL_COLOR_RESET = "\033[m"
 
 def print_warning(message):
     print(f"{SHELL_COLOR_ORANGE}WARNING: {message}{SHELL_COLOR_RESET}")
@@ -18,7 +13,7 @@ def print_error(message):
     print(f"{SHELL_COLOR_RED}ERROR: {message}{SHELL_COLOR_RESET}")
 
 def print_help():
-    print("Usage: python upload-files.py [path] [version] [cloudflareAccountId] [cloudflareTokenName] [cloudflareTokenValue]")
+    print("Usage: python upload-firmware-files.py [path] [version] [cloudflareAccountId] [cloudflareTokenName] [cloudflareTokenValue]")
     print("")
     print("Options:")
     print("  --index-only                   Upload only index.json")
@@ -52,14 +47,14 @@ def main(path: str, version: str, cloudflare_account_id, cloudflare_token_name:
             counter += 1
 
 if __name__ == "__main__":
-    print("Tactility CDN Uploader")
+    print("Tactility CDN Firmware Uploader")
     if "--help" in sys.argv:
         print_help()
         sys.exit()
     # Argument validation
     if len(sys.argv) < 6:
         print_help()
-        sys.exit()
+        sys.exit(1)
     main(
         path=sys.argv[1],
         version=sys.argv[2],

Buildscripts/CDN/upload-sdk-files.py

@@ -0,0 +1,65 @@
+import os
+import sys
+import boto3
+
+SHELL_COLOR_RED = "\033[91m"
+SHELL_COLOR_ORANGE = "\033[93m"
+SHELL_COLOR_RESET = "\033[m"
+
+def print_warning(message):
+    print(f"{SHELL_COLOR_ORANGE}WARNING: {message}{SHELL_COLOR_RESET}")
+
+def print_error(message):
+    print(f"{SHELL_COLOR_RED}ERROR: {message}{SHELL_COLOR_RESET}")
+
+def print_help():
+    print("Usage: python upload-sdk-files.py [path] [version] [cloudflareAccountId] [cloudflareTokenName] [cloudflareTokenValue]")
+    print("")
+    print("Options:")
+    print("  --index-only                   Upload only index.json")
+
+def exit_with_error(message):
+    print_error(message)
+    sys.exit(1)
+
+def main(path: str, version: str, cloudflare_account_id, cloudflare_token_name: str, cloudflare_token_value: str, index_only: bool):
+    if not os.path.exists(path):
+        exit_with_error(f"Path not found: {path}")
+    s3 = boto3.client(
+        service_name="s3",
+        endpoint_url=f"https://{cloudflare_account_id}.r2.cloudflarestorage.com",
+        aws_access_key_id=cloudflare_token_name,
+        aws_secret_access_key=cloudflare_token_value,
+        region_name="auto"
+    )
+    files_to_upload = os.listdir(path)
+    counter = 1
+    total = len(files_to_upload)
+    for file_name in files_to_upload:
+        if not index_only or file_name == 'index.json':
+            object_path = f"sdk/{version}/{file_name}"
+            print(f"[{counter}/{total}] Uploading {file_name} to {object_path}")
+            file_path = os.path.join(path, file_name)
+            try:
+                s3.upload_file(file_path, "tactility", object_path)
+            except Exception as e:
+                exit_with_error(f"Failed to upload {file_name}: {str(e)}")
+            counter += 1
+
+if __name__ == "__main__":
+    print("Tactility CDN SDK Uploader")
+    if "--help" in sys.argv:
+        print_help()
+        sys.exit()
+    # Argument validation
+    if len(sys.argv) < 6:
+        print_help()
+        sys.exit(1)
+    main(
+        path=sys.argv[1],
+        version=sys.argv[2],
+        cloudflare_account_id=sys.argv[3],
+        cloudflare_token_name=sys.argv[4],
+        cloudflare_token_value=sys.argv[5],
+        index_only="--index-only" in sys.argv
+    )

Buildscripts/CMake/CMakeLists.txt

@@ -1,5 +1,6 @@
 idf_component_register(
-    INCLUDE_DIRS "Libraries/TactilityC/Include" "Libraries/lvgl/Include"
+    INCLUDE_DIRS "Libraries/TactilityC/Include" "Libraries/lvgl/Include" "Libraries/TactilityFreeRtos/Include"
+    REQUIRES esp_timer
 )
 
 add_prebuilt_library(TactilityC Libraries/TactilityC/Binary/libTactilityC.a)

Buildscripts/logo.cmake

@@ -8,20 +8,12 @@ else ()
     set(TACTILITY_TARGET "  @ Simulator")
 endif ()
 
-if (NOT WIN32)
+string(ASCII 27 Esc)
-    string(ASCII 27 Esc)
+set(ColorReset "${Esc}[m")
-    set(ColorReset "${Esc}[m")
+set(Cyan "${Esc}[36m")
-    set(Cyan "${Esc}[36m")
+set(Grey "${Esc}[37m")
-    set(Grey "${Esc}[37m")
+set(LightPurple "${Esc}[1;35m")
-    set(LightPurple "${Esc}[1;35m")
+set(White "${Esc}[1;37m")
-    set(White "${Esc}[1;37m")
-else ()
-    set(ColorReset "")
-    set(Cyan "")
-    set(Grey "")
-    set(LightPurple "")
-    set(White "")
-endif ()
 
 # Some terminals (e.g. GitHub Actions) reset colour for every in a multiline message(),
 # so we add the colour to each line instead of assuming it would automatically be re-used.

Buildscripts/release-sdk.sh

@@ -24,6 +24,13 @@ find_target_dir=$build_dir/$tactility_library_path/Include/
 cp TactilityC/Include/* $find_target_dir
 cp Documentation/license-tactilitysdk.md $build_dir/$tactility_library_path/LICENSE.md
 
+# TactilityFreeRtos
+tactilityfreertos_library_path=$library_path/TactilityFreeRtos
+mkdir -p $tactilityfreertos_library_path/Include
+find_target_dir=$build_dir/$tactilityfreertos_library_path/Include/
+cp -r TactilityFreeRtos/Include/* $find_target_dir
+cp Documentation/license-tactilitysdk.md $build_dir/$tactilityfreertos_library_path/LICENSE.md
+
 # lvgl
 lvgl_library_path=$library_path/lvgl
 mkdir -p $lvgl_library_path/Binary

CMakeLists.txt

@@ -1,21 +1,14 @@
 cmake_minimum_required(VERSION 3.20)
 
-add_definitions(-DTT_DEBUG)
-
 set(CMAKE_CXX_STANDARD 23)
 set(CMAKE_CXX_STANDARD_REQUIRED ON)
 set(CMAKE_ASM_COMPILE_OBJECT "${CMAKE_CXX_COMPILER_TARGET}")
 
 include("Buildscripts/logo.cmake")
 
-if (NOT WIN32)
+string(ASCII 27 Esc)
-    string(ASCII 27 Esc)
+set(ColorReset "${Esc}[m")
-    set(ColorReset "${Esc}[m")
+set(Cyan "${Esc}[36m")
-    set(Cyan "${Esc}[36m")
-else ()
-    set(ColorReset "")
-    set(Cyan "")
-endif ()
 
 file(READ version.txt TACTILITY_VERSION)
 add_compile_definitions(TT_VERSION="${TACTILITY_VERSION}")
@@ -77,19 +70,16 @@ if (NOT DEFINED ENV{ESP_IDF_VERSION})
     add_subdirectory(TactilityCore)
     add_subdirectory(TactilityFreeRtos)
     add_subdirectory(Devices/simulator)
-endif ()
-
-if (NOT DEFINED ENV{ESP_IDF_VERSION})
-    # FreeRTOS
-    set(FREERTOS_CONFIG_FILE_DIRECTORY ${PROJECT_SOURCE_DIR}/Devices/simulator/Source CACHE STRING "")
-    set(FREERTOS_PORT GCC_POSIX CACHE STRING "")
-
     add_subdirectory(Libraries/cJSON)
-    add_subdirectory(Libraries/FreeRTOS-Kernel)
     add_subdirectory(Libraries/lv_screenshot)
     add_subdirectory(Libraries/QRCode)
     add_subdirectory(Libraries/minitar)
     add_subdirectory(Libraries/minmea)
+
+    # FreeRTOS
+    set(FREERTOS_CONFIG_FILE_DIRECTORY ${PROJECT_SOURCE_DIR}/Devices/simulator/Source CACHE STRING "")
+    set(FREERTOS_PORT GCC_POSIX CACHE STRING "")
+    add_subdirectory(Libraries/FreeRTOS-Kernel)
     target_compile_definitions(freertos_kernel PUBLIC "projCOVERAGE_TEST=0")
     target_include_directories(freertos_kernel
         PUBLIC Devices/Simulator/Source # for FreeRTOSConfig.h

TactilityC/Include/tt_hal_display.h

@@ -1,8 +1,8 @@
 #pragma once
 
-#include <tt_kernel.h>
 #include <tt_hal_device.h>
 #include <stdbool.h>
+#include <freertos/FreeRTOS.h>
 
 #ifdef __cplusplus
 extern "C" {
@@ -48,7 +48,7 @@ void tt_hal_display_driver_free(DisplayDriverHandle 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);
+bool tt_hal_display_driver_lock(DisplayDriverHandle handle, TickType_t timeout);
 
 /**
  * Unlock the display device. Must be called exactly once after locking.

TactilityC/Include/tt_hal_uart.h

@@ -3,7 +3,7 @@
 #include <stdbool.h>
 #include <stdint.h>
 #include <stddef.h>
-#include <tt_kernel.h>
+#include <freertos/FreeRTOS.h>
 
 #ifdef __cplusplus
 extern "C" {
@@ -91,7 +91,7 @@ bool tt_hal_uart_stop(UartHandle handle);
  *                to wait indefinitely.
  * @return The number of bytes read (0 on timeout with no data). Never exceeds bufferSize.
  */
-size_t tt_hal_uart_read_bytes(UartHandle handle, char* buffer, size_t bufferSize, TickType timeout);
+size_t tt_hal_uart_read_bytes(UartHandle handle, char* buffer, size_t bufferSize, TickType_t timeout);
 
 /**
  * @brief Read a single byte.
@@ -102,7 +102,7 @@ size_t tt_hal_uart_read_bytes(UartHandle handle, char* buffer, size_t bufferSize
  *                to wait indefinitely.
  * @return true if a byte was read and stored in output; false on timeout or failure.
  */
-bool tt_hal_uart_read_byte(UartHandle handle, char* output, TickType timeout);
+bool tt_hal_uart_read_byte(UartHandle handle, char* output, TickType_t timeout);
 
 /**
  * @brief Write up to bufferSize bytes from buffer.
@@ -117,7 +117,7 @@ bool tt_hal_uart_read_byte(UartHandle handle, char* output, TickType timeout);
  *                to wait indefinitely.
  * @return The number of bytes written (may be less than bufferSize on timeout).
  */
-size_t tt_hal_uart_write_bytes(UartHandle handle, const char* buffer, size_t bufferSize, TickType timeout);
+size_t tt_hal_uart_write_bytes(UartHandle handle, const char* buffer, size_t bufferSize, TickType_t timeout);
 
 /**
  * @brief Get the number of bytes currently available to read without blocking.

TactilityC/Include/tt_kernel.h

@@ -1,14 +0,0 @@
-#pragma once
-
-#include <stdint.h>
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-typedef unsigned long TickType;
-
-#define TT_MAX_TICKS ((TickType)(~(TickType)0))
-
-#ifdef __cplusplus
-}
-#endif

TactilityC/Include/tt_lock.h

@@ -1,7 +1,7 @@
 #pragma once
 
-#include "tt_kernel.h"
 #include <stdbool.h>
+#include <freertos/FreeRTOS.h>
 
 #ifdef __cplusplus
 extern "C" {
@@ -15,13 +15,6 @@ typedef enum {
     MutexTypeRecursive
 } TtMutexType;
 
-/**
- * Allocate a new mutex instance
- * @param[in] type specify if the mutex is either a normal one, or whether it can recursively (re)lock
- * @return the allocated lock handle
- */
-LockHandle tt_lock_alloc_mutex(TtMutexType type);
-
 /**
  * Allocate a lock for a file or folder.
  * Locking is required before reading files for filesystems that are on a shared bus (e.g. SPI SD card sharing the bus with the display)
@@ -36,7 +29,7 @@ LockHandle tt_lock_alloc_for_path(const char* path);
  * @param[in] timeout the maximum amount of ticks to wait when trying to lock
  * @return true when the lock was acquired
  */
-bool tt_lock_acquire(LockHandle handle, TickType timeout);
+bool tt_lock_acquire(LockHandle handle, TickType_t timeout);
 
 /**
  * Attempt to unlock the lock.

TactilityC/Include/tt_lvgl.h

@@ -1,6 +1,7 @@
 #pragma once
 
 #include <stdbool.h>
+#include <freertos/FreeRTOS.h>
 
 #ifdef __cplusplus
 extern "C" {
@@ -18,7 +19,7 @@ void tt_lvgl_start();
 void tt_lvgl_stop();
 
 /** Lock the LVGL context. Call this before doing LVGL-related operations from a non-LVLG thread */
-bool tt_lvgl_lock(TickType timeout);
+bool tt_lvgl_lock(TickType_t timeout);
 
 /** Unlock the LVGL context */
 void tt_lvgl_unlock();

TactilityC/Include/tt_message_queue.h

@@ -1,54 +0,0 @@
-#pragma once
-
-#include <freertos/FreeRTOS.h>
-#include <stdbool.h>
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-#include <stdint.h>
-#include <stdbool.h>
-
-/** A handle that represents a message queue instance */
-typedef void* MessageQueueHandle;
-
-/**
- * Allocate a new message queue in memory.
- * @param[in] capacity how many messages this queue can contain before it starts blocking input
- * @param[in] messageSize the size of a message
- */
-MessageQueueHandle tt_message_queue_alloc(uint32_t capacity, uint32_t messageSize);
-
-/** Free up the memory of a queue (dealloc) */
-void tt_message_queue_free(MessageQueueHandle handle);
-
-/**
- * Put (post) a message in the queue
- * @param[in] handle the queue handle
- * @param[in] message the message of the correct size - its data will be copied
- * @param[timeout] timeout the amount of ticks to wait until the message is queued
- * @return true if the item was successfully queued
- */
-bool tt_message_queue_put(MessageQueueHandle handle, const void* message, TickType_t timeout);
-
-/**
- * Get the oldest message from the queue.
- * @param[in] handle the queue handle
- * @param[out] message a pointer to a message of the correct size
- * @param[in] timeout the amount of ticks to wait until a message was copied
- * @return true if a message was successfully copied
- */
-bool tt_message_queue_get(MessageQueueHandle handle, void* message, TickType_t timeout);
-
-/** @return the current amount of items in the queue */
-uint32_t tt_message_queue_get_count(MessageQueueHandle handle);
-
-/**
- * Remove all items from the queue (if any)
- */
-void tt_message_queue_reset(MessageQueueHandle handle);
-
-#ifdef __cplusplus
-}
-#endif

TactilityC/Include/tt_semaphore.h

@@ -1,50 +0,0 @@
-#pragma once
-
-#include <freertos/FreeRTOS.h>
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-#include <stdint.h>
-#include <stdbool.h>
-
-/** A handle that represents a semaphore instance */
-typedef void* SemaphoreHandle;
-
-/**
- * Allocate a new semaphore instance.
- * @param[in] maxCount the maximum counter value
- * @param[in] initialCount the initial counter value
- * @return the handle that represents the new instance
- */
-SemaphoreHandle tt_semaphore_alloc(uint32_t maxCount, TickType_t initialCount);
-
-/** Free up the memory of a specified semaphore instance */
-void tt_semaphore_free(SemaphoreHandle handle);
-
-/**
- * Attempt to acquire a semaphore (increase counter)
- * @param[in] handle the instance handle
- * @param[in] timeout the maximum amount of ticks to wait while trying to acquire
- * @return true on successfully acquiring the semaphore (counter is increased)
- */
-bool tt_semaphore_acquire(SemaphoreHandle handle, TickType_t timeout);
-
-/**
- * Release an acquired semaphore (decrease counter)
- * @param[in] handle the instance handle
- * @return true on successfully releasing the semaphore (counter is decreased)
- */
-bool tt_semaphore_release(SemaphoreHandle handle);
-
-/**
- * Get the counter value of this semaphore instance
- * @param[in] handle the instance handle
- * @return the current counter value (acquisition count)
- */
-uint32_t tt_semaphore_get_count(SemaphoreHandle handle);
-
-#ifdef __cplusplus
-}
-#endif

TactilityC/Include/tt_thread.h

@@ -1,156 +0,0 @@
-#pragma once
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-#ifdef ESP_PLATFORM
-#include "freertos/FreeRTOS.h"
-#include "freertos/task.h"
-#else
-#include "FreeRTOS.h"
-#include "task.h"
-#endif
-
-#include <stdint.h>
-#include <stdbool.h>
-#include <stddef.h>
-
-/** The handle that represents the thread insance */
-typedef void* ThreadHandle;
-
-/** The state of a thread instance */
-typedef enum {
-    ThreadStateStopped,
-    ThreadStateStarting,
-    ThreadStateRunning,
-} ThreadState;
-
-/** The identifier that represents the thread */
-typedef TaskHandle_t TaskHandle;
-
-/** ThreadCallback Your callback to run in new thread
- * @warning never use osThreadExit in Thread
- */
-typedef int32_t (*ThreadCallback)(void* context);
-
-/** Thread state change callback called upon thread state change
- * @param state new thread state
- * @param context callback context
- */
-typedef void (*ThreadStateCallback)(ThreadState state, void* context);
-
-typedef enum {
-    ThreadPriorityNone = 0U, /**< Uninitialized, choose system default */
-    ThreadPriorityIdle = 1U,
-    ThreadPriorityLowest = 2U,
-    ThreadPriorityLow = 3U,
-    ThreadPriorityNormal = 4U,
-    ThreadPriorityHigh = 5U,
-    ThreadPriorityHigher = 6U,
-    ThreadPriorityHighest = 7U
-} ThreadPriority;
-
-/** @return a thread handle that represents a newly allocated thread instance */
-ThreadHandle tt_thread_alloc();
-
-/**
- * Allocate a thread and provide some common parameters so it's all ready to be started.
- * @param[in] name the name of the thread
- * @param[in] stackSize the size of the stack in bytes
- * @param[in] callback the callback to call from the thread
- * @param[in] callbackContext the data to pass to the callback
- */
-ThreadHandle tt_thread_alloc_ext(
-    const char* name,
-    uint32_t stackSize,
-    ThreadCallback callback,
-    void* _Nullable callbackContext
-);
-
-/**
- * Free up the memory of the thread that is represented by this handle
- * @param[in] handle the thread instance handle
- */
-void tt_thread_free(ThreadHandle handle);
-
-/**
- * Set the name of a thread
- * @param[in] handle the thread instance handle
- * @param[in] name the name to set
- */
-void tt_thread_set_name(ThreadHandle handle, const char* name);
-
-/**
- * Set the stack size of the thread (in bytes)
- * @param[in] handle the thread instance handle
- * @param[in] the size of the thread in bytes
- */
-void tt_thread_set_stack_size(ThreadHandle handle, size_t size);
-
-/** Set CPu core affinity for this thread
- * @param[in] handle the thread instance handle
- * @param[in] affinity -1 means not pinned, otherwise it's the core id (e.g. 0 or 1 on ESP32)
- */
-void tt_thread_set_affinity(ThreadHandle handle, int affinity);
-
-/**
- * Set the callback for a thread. This method is executed when the thread is started.
- * @param[in] handle the thread instance handle
- * @param[in] callback the callback to set
- * @param[in] callbackContext the data to pass to the callback
- */
-void tt_thread_set_callback(ThreadHandle handle, ThreadCallback callback, void* _Nullable callbackContext);
-
-/**
- * Set the priority of a thread
- * @param[in] handle the thread instance handle
- * @param[in] priority the priority to set
- */
-void tt_thread_set_priority(ThreadHandle handle, ThreadPriority priority);
-
-/**
- * Set the state callback for a thread
- * @param[in] handle the thread instance handle
- * @param[in] callback the callback to set
- * @param[in] callbackContext the data to pass to the callback
- */
-void tt_thread_set_state_callback(ThreadHandle handle, ThreadStateCallback callback, void* _Nullable callbackContext);
-
-/**
- * @param[in] handle the thread instance handle
- * @return the current state of a thread
- */
-ThreadState tt_thread_get_state(ThreadHandle handle);
-
-/**
- * Start a thread
- * @param[in] handle the thread instance handle
- */
-void tt_thread_start(ThreadHandle handle);
-
-/**
- * Wait (block) for the thread to finish.
- * @param[in] handle the thread instance handle
- * @warning make sure you manually interrupt any logic in your thread (e.g. by an EventGroup or boolean+Mutex)
- */
-bool tt_thread_join(ThreadHandle handle, TickType_t timeout);
-
-/**
- * Get thread task handle
- * @param[in] handle the thread instance handle
- * @return the task handle of a thread
- * */
-TaskHandle tt_thread_get_task_handle(ThreadHandle handle);
-
-/**
- * Get the return code of a thread
- * @warning crashes when state is not "stopped"
- * @param[in] handle the thread instance handle
- * @return the return code of a thread or
- */
-int32_t tt_thread_get_return_code(ThreadHandle handle);
-
-#ifdef __cplusplus
-}
-#endif

TactilityC/Include/tt_timer.h

@@ -1,97 +0,0 @@
-#pragma once
-
-#include "tt_kernel.h"
-#include "tt_thread.h"
-
-#include <stdint.h>
-#include <stdbool.h>
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-/** The handle that represents a timer instance */
-typedef void* TimerHandle;
-
-/** The behaviour of the timer */
-typedef enum {
-    TimerTypeOnce = 0, // Timer triggers once after time has passed
-    TimerTypePeriodic = 1 // Timer triggers repeatedly after time has passed
-} TimerType;
-
-typedef void (*TimerCallback)(void* context);
-typedef void (*TimerPendingCallback)(void* context, uint32_t arg);
-
-/**
- * Create a new timer instance
- * @param[in] callback the callback to call when the timer expires
- * @param[in] callbackContext the data to pass to the callback
- */
-TimerHandle tt_timer_alloc(TimerType type, TickType ticks, TimerCallback callback, void* callbackContext);
-
-/** Free up the memory of a timer instance */
-void tt_timer_free(TimerHandle handle);
-
-/**
- * Start the timer
- * @param[in] handle the timer instance handle
- * @return true when the timer was successfully started
- */
-bool tt_timer_start(TimerHandle handle);
-
-/**
- * Restart an already started timer
- * @param[in] handle the timer instance handle
- * @param[in] interval the timer new interval
- * @return true when the timer was successfully restarted
- */
-bool tt_timer_reset_with_interval(TimerHandle handle, TickType interval);
-
-    /**
- * Restart an already started timer
- * @param[in] handle the timer instance handle
- * @return true when the timer was successfully restarted
- */
-bool tt_timer_reset(TimerHandle handle);
-
-/**
- * Stop a started timer
- * @param[in] handle the timer instance handle
- * @return true when the timer was successfully stopped
- */
-bool tt_timer_stop(TimerHandle handle);
-
-/**
- * Check if a timer is started
- * @param[in] handle the timer instance handle
- * @return true when the timer is started (pending)
- */
-bool tt_timer_is_running(TimerHandle handle);
-
-/**
- * Get the expiry time of a timer
- * @param[in] handle the timer instance handle
- * @return the absolute timestamp at which the timer will expire
- */
-uint32_t tt_timer_get_expiry_time(TimerHandle handle);
-
-/**
- * Set the pending callback for a timer
- * @param[in] handle the timer instance handle
- * @param[in] callback the callback to set
- * @param[in] callbackContext the context to pass to the callback
- * @param[in] timeout the timeout for setting the callback
- * @return when the callback was successfully set
- */
-bool tt_timer_set_pending_callback(TimerHandle handle, TimerPendingCallback callback, void* callbackContext, uint32_t callbackArg, TickType_t timeout);
-
-/**
- * Set the thread priority for the callback of the timer
- * @param[in] handle the timer instance handle
- * @param[in] priority the thread priority to set
- */
-void tt_timer_set_thread_priority(TimerHandle handle, ThreadPriority priority);
-
-#ifdef __cplusplus
-}
-#endif

TactilityC/Source/symbols/freertos.cpp

@@ -3,12 +3,20 @@
 
 #include <symbols/freertos.h>
 
-#include <Tactility/freertoscompat/RTOS.h>
+#include <freertos/FreeRTOS.h>
-#include <freertos/task.h>
 #include <freertos/event_groups.h>
+#include <freertos/queue.h>
+#include <freertos/semphr.h>
+#include <freertos/task.h>
+#include <freertos/timers.h>
 
 const esp_elfsym freertos_symbols[] = {
     // Task
+    ESP_ELFSYM_EXPORT(uxTaskGetStackHighWaterMark),
+    ESP_ELFSYM_EXPORT(uxTaskGetNumberOfTasks),
+    ESP_ELFSYM_EXPORT(uxTaskGetTaskNumber),
+    ESP_ELFSYM_EXPORT(uxTaskPriorityGet),
+    ESP_ELFSYM_EXPORT(uxTaskPriorityGetFromISR),
     ESP_ELFSYM_EXPORT(vTaskDelay),
     ESP_ELFSYM_EXPORT(vTaskDelete),
     ESP_ELFSYM_EXPORT(vTaskDeleteWithCaps),
@@ -28,13 +36,10 @@ const esp_elfsym freertos_symbols[] = {
     ESP_ELFSYM_EXPORT(xTaskDelayUntil),
     ESP_ELFSYM_EXPORT(xTaskGenericNotify),
     ESP_ELFSYM_EXPORT(xTaskGenericNotifyFromISR),
+    ESP_ELFSYM_EXPORT(xTaskGetTickCount),
+    ESP_ELFSYM_EXPORT(xTaskGetTickCountFromISR),
     ESP_ELFSYM_EXPORT(pvTaskGetThreadLocalStoragePointer),
     ESP_ELFSYM_EXPORT(pvTaskIncrementMutexHeldCount),
-    ESP_ELFSYM_EXPORT(uxTaskGetStackHighWaterMark),
-    ESP_ELFSYM_EXPORT(uxTaskGetNumberOfTasks),
-    ESP_ELFSYM_EXPORT(uxTaskGetTaskNumber),
-    ESP_ELFSYM_EXPORT(uxTaskPriorityGet),
-    ESP_ELFSYM_EXPORT(uxTaskPriorityGetFromISR),
     // EventGroup
     ESP_ELFSYM_EXPORT(xEventGroupCreate),
     ESP_ELFSYM_EXPORT(xEventGroupCreateWithCaps),
@@ -49,11 +54,6 @@ const esp_elfsym freertos_symbols[] = {
     ESP_ELFSYM_EXPORT(xEventGroupSync),
     ESP_ELFSYM_EXPORT(xEventGroupWaitBits),
     // Queue
-    ESP_ELFSYM_EXPORT(xQueueGenericCreate),
-    ESP_ELFSYM_EXPORT(xQueueGenericCreateStatic),
-    ESP_ELFSYM_EXPORT(xQueueGenericReset),
-    ESP_ELFSYM_EXPORT(xQueueGenericSend),
-    ESP_ELFSYM_EXPORT(xQueueGenericSendFromISR),
     ESP_ELFSYM_EXPORT(vQueueDelete),
     ESP_ELFSYM_EXPORT(vQueueDeleteWithCaps),
     ESP_ELFSYM_EXPORT(vQueueSetQueueNumber),
@@ -62,7 +62,23 @@ const esp_elfsym freertos_symbols[] = {
     ESP_ELFSYM_EXPORT(uxQueueMessagesWaiting),
     ESP_ELFSYM_EXPORT(uxQueueMessagesWaitingFromISR),
     ESP_ELFSYM_EXPORT(uxQueueSpacesAvailable),
+    ESP_ELFSYM_EXPORT(xQueueCreateCountingSemaphore),
+    ESP_ELFSYM_EXPORT(xQueueCreateCountingSemaphoreStatic),
+    ESP_ELFSYM_EXPORT(xQueueCreateMutex),
+    ESP_ELFSYM_EXPORT(xQueueCreateMutexStatic),
+    ESP_ELFSYM_EXPORT(xQueueCreateSet),
+    ESP_ELFSYM_EXPORT(xQueueGetMutexHolder),
+    ESP_ELFSYM_EXPORT(xQueueGetMutexHolderFromISR),
+    ESP_ELFSYM_EXPORT(xQueueGiveMutexRecursive),
+    ESP_ELFSYM_EXPORT(xQueueTakeMutexRecursive),
+    ESP_ELFSYM_EXPORT(xQueueGenericCreate),
+    ESP_ELFSYM_EXPORT(xQueueGenericCreateStatic),
+    ESP_ELFSYM_EXPORT(xQueueGenericReset),
+    ESP_ELFSYM_EXPORT(xQueueGenericSend),
+    ESP_ELFSYM_EXPORT(xQueueGenericSendFromISR),
+    ESP_ELFSYM_EXPORT(xQueueSemaphoreTake),
     // Timer
+    ESP_ELFSYM_EXPORT(pvTimerGetTimerID),
     ESP_ELFSYM_EXPORT(xTimerCreate),
     ESP_ELFSYM_EXPORT(xTimerCreateStatic),
     ESP_ELFSYM_EXPORT(xTimerGenericCommand),
@@ -71,7 +87,15 @@ const esp_elfsym freertos_symbols[] = {
     ESP_ELFSYM_EXPORT(xTimerPendFunctionCall),
     ESP_ELFSYM_EXPORT(xTimerPendFunctionCallFromISR),
     ESP_ELFSYM_EXPORT(xTimerGetPeriod),
+    ESP_ELFSYM_EXPORT(uxTimerGetReloadMode),
+    ESP_ELFSYM_EXPORT(uxTimerGetTimerNumber),
+    ESP_ELFSYM_EXPORT(vTimerSetReloadMode),
+    ESP_ELFSYM_EXPORT(vTimerSetTimerID),
+    ESP_ELFSYM_EXPORT(vTimerSetTimerNumber),
     // portmacro.h
+    ESP_ELFSYM_EXPORT(vPortYield),
+    ESP_ELFSYM_EXPORT(vPortEnterCritical),
+    ESP_ELFSYM_EXPORT(vPortExitCritical),
     ESP_ELFSYM_EXPORT(xPortInIsrContext),
     ESP_ELFSYM_EXPORT(xPortCanYield),
     ESP_ELFSYM_EXPORT(xPortGetCoreID),

TactilityC/Source/symbols/stl.cpp

@@ -11,6 +11,7 @@ const esp_elfsym stl_symbols[] = {
     { "_ZSt28__throw_bad_array_new_lengthv", (void*)&(std::__throw_bad_array_new_length) },
     { "_ZSt25__throw_bad_function_callv", (void*)&(std::__throw_bad_function_call) },
     { "_ZSt20__throw_length_errorPKc", (void*)&(std::__throw_length_error) },
+    { "_ZSt19__throw_logic_errorPKc", (void*)&std::__throw_logic_error },
     // { "", (void*)&(std::) },
     // delimiter
     ESP_ELFSYM_END

TactilityC/Source/tt_hal_display.cpp

@@ -55,7 +55,7 @@ void tt_hal_display_driver_free(DisplayDriverHandle handle) {
     delete wrapper;
 }
 
-bool tt_hal_display_driver_lock(DisplayDriverHandle handle, TickType timeout) {
+bool tt_hal_display_driver_lock(DisplayDriverHandle handle, TickType_t timeout) {
     auto wrapper = static_cast<DriverWrapper*>(handle);
     return wrapper->driver->getLock()->lock(timeout);
 }

TactilityC/Source/tt_hal_uart.cpp

@@ -53,15 +53,15 @@ bool tt_hal_uart_stop(UartHandle handle) {
     return HANDLE_AS_UART(handle)->stop();
 }
 
-size_t tt_hal_uart_read_bytes(UartHandle handle, char* buffer, size_t bufferSize, TickType timeout) {
+size_t tt_hal_uart_read_bytes(UartHandle handle, char* buffer, size_t bufferSize, TickType_t timeout) {
     return HANDLE_AS_UART(handle)->readBytes(reinterpret_cast<std::byte*>(buffer), bufferSize, timeout);
 }
 
-bool tt_hal_uart_read_byte(UartHandle handle, char* output, TickType timeout) {
+bool tt_hal_uart_read_byte(UartHandle handle, char* output, TickType_t timeout) {
     return HANDLE_AS_UART(handle)->readByte(reinterpret_cast<std::byte*>(output), timeout);
 }
 
-size_t tt_hal_uart_write_bytes(UartHandle handle, const char* buffer, size_t bufferSize, TickType timeout) {
+size_t tt_hal_uart_write_bytes(UartHandle handle, const char* buffer, size_t bufferSize, TickType_t timeout) {
     return HANDLE_AS_UART(handle)->writeBytes(reinterpret_cast<const std::byte*>(buffer), bufferSize, timeout);
 }
 

TactilityC/Source/tt_init.cpp

@@ -17,12 +17,8 @@
 #include "tt_lvgl_keyboard.h"
 #include "tt_lvgl_spinner.h"
 #include "tt_lvgl_toolbar.h"
-#include "tt_message_queue.h"
 #include "tt_preferences.h"
-#include "tt_semaphore.h"
-#include "tt_thread.h"
 #include "tt_time.h"
-#include "tt_timer.h"
 #include "tt_wifi.h"
 
 #include "symbols/esp_event.h"
@@ -49,7 +45,6 @@
 #include <esp_random.h>
 #include <esp_sntp.h>
 #include <esp_netif.h>
-#include <esp_wifi.h>
 #include <dirent.h>
 #include <sys/stat.h>
 #include <time.h>
@@ -199,7 +194,6 @@ const esp_elfsym main_symbols[] {
     ESP_ELFSYM_EXPORT(tt_app_get_user_data_child_path),
     ESP_ELFSYM_EXPORT(tt_app_get_assets_path),
     ESP_ELFSYM_EXPORT(tt_app_get_assets_child_path),
-    ESP_ELFSYM_EXPORT(tt_lock_alloc_mutex),
     ESP_ELFSYM_EXPORT(tt_lock_alloc_for_path),
     ESP_ELFSYM_EXPORT(tt_lock_acquire),
     ESP_ELFSYM_EXPORT(tt_lock_release),
@@ -281,12 +275,6 @@ const esp_elfsym main_symbols[] {
     ESP_ELFSYM_EXPORT(tt_lvgl_toolbar_add_switch_action),
     ESP_ELFSYM_EXPORT(tt_lvgl_toolbar_add_spinner_action),
     ESP_ELFSYM_EXPORT(tt_lvgl_toolbar_clear_actions),
-    ESP_ELFSYM_EXPORT(tt_message_queue_alloc),
-    ESP_ELFSYM_EXPORT(tt_message_queue_free),
-    ESP_ELFSYM_EXPORT(tt_message_queue_put),
-    ESP_ELFSYM_EXPORT(tt_message_queue_get),
-    ESP_ELFSYM_EXPORT(tt_message_queue_get_count),
-    ESP_ELFSYM_EXPORT(tt_message_queue_reset),
     ESP_ELFSYM_EXPORT(tt_preferences_alloc),
     ESP_ELFSYM_EXPORT(tt_preferences_free),
     ESP_ELFSYM_EXPORT(tt_preferences_opt_bool),
@@ -295,35 +283,6 @@ const esp_elfsym main_symbols[] {
     ESP_ELFSYM_EXPORT(tt_preferences_put_bool),
     ESP_ELFSYM_EXPORT(tt_preferences_put_int32),
     ESP_ELFSYM_EXPORT(tt_preferences_put_string),
-    ESP_ELFSYM_EXPORT(tt_semaphore_alloc),
-    ESP_ELFSYM_EXPORT(tt_semaphore_free),
-    ESP_ELFSYM_EXPORT(tt_semaphore_acquire),
-    ESP_ELFSYM_EXPORT(tt_semaphore_release),
-    ESP_ELFSYM_EXPORT(tt_semaphore_get_count),
-    ESP_ELFSYM_EXPORT(tt_thread_alloc),
-    ESP_ELFSYM_EXPORT(tt_thread_alloc_ext),
-    ESP_ELFSYM_EXPORT(tt_thread_free),
-    ESP_ELFSYM_EXPORT(tt_thread_set_name),
-    ESP_ELFSYM_EXPORT(tt_thread_set_stack_size),
-    ESP_ELFSYM_EXPORT(tt_thread_set_affinity),
-    ESP_ELFSYM_EXPORT(tt_thread_set_callback),
-    ESP_ELFSYM_EXPORT(tt_thread_set_priority),
-    ESP_ELFSYM_EXPORT(tt_thread_set_state_callback),
-    ESP_ELFSYM_EXPORT(tt_thread_get_state),
-    ESP_ELFSYM_EXPORT(tt_thread_start),
-    ESP_ELFSYM_EXPORT(tt_thread_join),
-    ESP_ELFSYM_EXPORT(tt_thread_get_task_handle),
-    ESP_ELFSYM_EXPORT(tt_thread_get_return_code),
-    ESP_ELFSYM_EXPORT(tt_timer_alloc),
-    ESP_ELFSYM_EXPORT(tt_timer_free),
-    ESP_ELFSYM_EXPORT(tt_timer_start),
-    ESP_ELFSYM_EXPORT(tt_timer_reset),
-    ESP_ELFSYM_EXPORT(tt_timer_reset_with_interval),
-    ESP_ELFSYM_EXPORT(tt_timer_stop),
-    ESP_ELFSYM_EXPORT(tt_timer_is_running),
-    ESP_ELFSYM_EXPORT(tt_timer_get_expiry_time),
-    ESP_ELFSYM_EXPORT(tt_timer_set_pending_callback),
-    ESP_ELFSYM_EXPORT(tt_timer_set_thread_priority),
     ESP_ELFSYM_EXPORT(tt_timezone_set),
     ESP_ELFSYM_EXPORT(tt_timezone_get_name),
     ESP_ELFSYM_EXPORT(tt_timezone_get_code),

TactilityC/Source/tt_lock.cpp

@@ -8,27 +8,12 @@
 
 extern "C" {
 
-LockHandle tt_lock_alloc_mutex(TtMutexType type) {
-    auto* lock_holder = new LockHolder();
-    switch (type) {
-        case MutexTypeNormal:
-            lock_holder->lock = std::make_shared<tt::Mutex>();
-            break;
-        case MutexTypeRecursive:
-            lock_holder->lock = std::make_shared<tt::RecursiveMutex>();
-            break;
-        default:
-            tt_crash("Type not supported");
-    }
-    return lock_holder;
-}
-
 LockHandle tt_lock_alloc_for_path(const char* path) {
     const auto lock = tt::file::getLock(path);
     return new LockHolder(lock);
 }
 
-bool tt_lock_acquire(LockHandle handle, TickType timeout) {
+bool tt_lock_acquire(LockHandle handle, TickType_t timeout) {
     return HANDLE_AS_LOCK(handle)->lock(timeout);
 }
 

TactilityC/Source/tt_lvgl.cpp

@@ -1,4 +1,3 @@
-#include <tt_kernel.h>
 #include <Tactility/lvgl/Lvgl.h>
 #include <Tactility/lvgl/LvglSync.h>
 
@@ -16,8 +15,8 @@ void tt_lvgl_stop() {
     tt::lvgl::stop();
 }
 
-void tt_lvgl_lock(TickType timeout) {
+bool tt_lvgl_lock(TickType_t timeout) {
-    tt::lvgl::getSyncLock()->lock(timeout);
+    return tt::lvgl::getSyncLock()->lock(timeout);
 }
 
 void tt_lvgl_unlock() {

TactilityC/Source/tt_message_queue.cpp

@@ -1,32 +0,0 @@
-#include "tt_message_queue.h"
-#include <Tactility/MessageQueue.h>
-
-#define HANDLE_TO_MESSAGE_QUEUE(handle) ((tt::MessageQueue*)(handle))
-
-extern "C" {
-
-MessageQueueHandle tt_message_queue_alloc(uint32_t capacity, uint32_t messageSize) {
-    return new tt::MessageQueue(capacity, messageSize);
-}
-
-void tt_message_queue_free(MessageQueueHandle handle) {
-    delete HANDLE_TO_MESSAGE_QUEUE(handle);
-}
-
-bool tt_message_queue_put(MessageQueueHandle handle, const void* message, TickType_t timeout) {
-    return HANDLE_TO_MESSAGE_QUEUE(handle)->put(message, timeout);
-}
-
-bool tt_message_queue_get(MessageQueueHandle handle, void* message, TickType_t timeout) {
-    return HANDLE_TO_MESSAGE_QUEUE(handle)->get(message, timeout);
-}
-
-uint32_t tt_message_queue_get_count(MessageQueueHandle handle) {
-    return HANDLE_TO_MESSAGE_QUEUE(handle)->getCount();
-}
-
-void tt_message_queue_reset(MessageQueueHandle handle) {
-    return HANDLE_TO_MESSAGE_QUEUE(handle)->reset();
-}
-
-}

TactilityC/Source/tt_semaphore.cpp

@@ -1,28 +0,0 @@
-#include "tt_semaphore.h"
-#include <Tactility/Semaphore.h>
-
-extern "C" {
-
-#define HANDLE_AS_SEMAPHORE(handle) ((tt::Semaphore*)(handle))
-
-SemaphoreHandle tt_semaphore_alloc(uint32_t maxCount, TickType_t initialCount) {
-    return new tt::Semaphore(maxCount, initialCount);
-}
-
-void tt_semaphore_free(SemaphoreHandle handle) {
-    delete HANDLE_AS_SEMAPHORE(handle);
-}
-
-bool tt_semaphore_acquire(SemaphoreHandle handle, TickType_t timeoutTicks) {
-    return HANDLE_AS_SEMAPHORE(handle)->acquire(timeoutTicks);
-}
-
-bool tt_semaphore_release(SemaphoreHandle handle) {
-    return HANDLE_AS_SEMAPHORE(handle)->release();
-}
-
-uint32_t tt_semaphore_get_count(SemaphoreHandle handle) {
-    return HANDLE_AS_SEMAPHORE(handle)->getAvailable();
-}
-
-}

TactilityC/Source/tt_thread.cpp

@@ -1,77 +0,0 @@
-#include "tt_thread.h"
-#include <Tactility/Thread.h>
-
-extern "C" {
-
-#define HANDLE_AS_THREAD(handle) ((tt::Thread*)(handle))
-
-ThreadHandle tt_thread_alloc() {
-    return new tt::Thread();
-}
-
-ThreadHandle tt_thread_alloc_ext(
-    const char* name,
-    uint32_t stackSize,
-    ThreadCallback callback,
-    void* _Nullable callbackContext
-) {
-    return new tt::Thread(
-        name,
-        stackSize,
-        [callback, callbackContext] {
-            return callback(callbackContext);
-        }
-    );
-}
-
-void tt_thread_free(ThreadHandle handle) {
-    delete HANDLE_AS_THREAD(handle);
-}
-
-void tt_thread_set_name(ThreadHandle handle, const char* name) {
-    HANDLE_AS_THREAD(handle)->setName(name);
-}
-
-void tt_thread_set_stack_size(ThreadHandle handle, size_t size) {
-    HANDLE_AS_THREAD(handle)->setStackSize(size);
-}
-
-void tt_thread_set_affinity(ThreadHandle handle, int affinity) {
-    HANDLE_AS_THREAD(handle)->setAffinity(affinity);
-}
-
-void tt_thread_set_callback(ThreadHandle handle, ThreadCallback callback, void* _Nullable callbackContext) {
-    HANDLE_AS_THREAD(handle)->setMainFunction([callback, callbackContext]() {
-        return callback(callbackContext);
-    });
-}
-
-void tt_thread_set_priority(ThreadHandle handle, ThreadPriority priority) {
-    HANDLE_AS_THREAD(handle)->setPriority((tt::Thread::Priority)priority);
-}
-
-void tt_thread_set_state_callback(ThreadHandle handle, ThreadStateCallback callback, void* _Nullable callbackContext) {
-    HANDLE_AS_THREAD(handle)->setStateCallback((tt::Thread::StateCallback)callback, callbackContext);
-}
-
-ThreadState tt_thread_get_state(ThreadHandle handle) {
-    return (ThreadState)HANDLE_AS_THREAD(handle)->getState();
-}
-
-void tt_thread_start(ThreadHandle handle) {
-    HANDLE_AS_THREAD(handle)->start();
-}
-
-bool tt_thread_join(ThreadHandle handle, TickType_t timeout) {
-    return HANDLE_AS_THREAD(handle)->join(timeout);
-}
-
-TaskHandle tt_thread_get_task_handle(ThreadHandle handle) {
-    return HANDLE_AS_THREAD(handle)->getTaskHandle();
-}
-
-int32_t tt_thread_get_return_code(ThreadHandle handle) {
-    return HANDLE_AS_THREAD(handle)->getReturnCode();
-}
-
-}

TactilityC/Source/tt_timer.cpp

@@ -1,61 +0,0 @@
-#include "tt_timer.h"
-#include <Tactility/Timer.h>
-
-struct TimerWrapper {
-    std::unique_ptr<tt::Timer> timer;
-};
-
-#define HANDLE_TO_WRAPPER(handle) static_cast<TimerWrapper*>(handle)
-
-extern "C" {
-
-TimerHandle tt_timer_alloc(TimerType type, TickType ticks, TimerCallback callback, void* callbackContext) {
-    auto wrapper = new TimerWrapper;
-    wrapper->timer = std::make_unique<tt::Timer>(static_cast<tt::Timer::Type>(type), ticks, [callback, callbackContext](){ callback(callbackContext); });
-    return wrapper;
-}
-
-void tt_timer_free(TimerHandle handle) {
-    auto* wrapper = static_cast<TimerWrapper*>(handle);
-    wrapper->timer = nullptr;
-    delete wrapper;
-}
-
-bool tt_timer_start(TimerHandle handle) {
-    return HANDLE_TO_WRAPPER(handle)->timer->start();
-}
-
-bool tt_timer_reset(TimerHandle handle) {
-    return HANDLE_TO_WRAPPER(handle)->timer->reset();
-}
-
-bool tt_timer_reset_with_interval(TimerHandle handle, TickType interval) {
-    return HANDLE_TO_WRAPPER(handle)->timer->reset(interval);
-}
-
-bool tt_timer_stop(TimerHandle handle) {
-    return HANDLE_TO_WRAPPER(handle)->timer->stop();
-}
-
-bool tt_timer_is_running(TimerHandle handle) {
-    return HANDLE_TO_WRAPPER(handle)->timer->isRunning();
-}
-
-uint32_t tt_timer_get_expiry_time(TimerHandle handle) {
-    return HANDLE_TO_WRAPPER(handle)->timer->getExpiryTime();
-}
-
-bool tt_timer_set_pending_callback(TimerHandle handle, TimerPendingCallback callback, void* callbackContext, uint32_t callbackArg, TickType_t timeoutTicks) {
-    return HANDLE_TO_WRAPPER(handle)->timer->setPendingCallback(
-        callback,
-        callbackContext,
-        callbackArg,
-        timeoutTicks
-    );
-}
-
-void tt_timer_set_thread_priority(TimerHandle handle, ThreadPriority priority) {
-    HANDLE_TO_WRAPPER(handle)->timer->setCallbackPriority(static_cast<tt::Thread::Priority>(priority));
-}
-
-}