adding freeRtos API from different project

components/freeRtosApi/include/Task.hpp

@@ -0,0 +1,184 @@
+/**
+ * @file task.hpp
+ * @author Gustice
+ * @brief Task Wrapper
+ *
+ * @copyright Copyright (c) 2024
+ */
+
+#pragma once
+
+#include "freertos/FreeRTOS.h"
+#include "freertos/task.h"
+#include <cassert>
+#include <string_view>
+#include <Semaphore.hpp>
+#define DEFAULT_STACKSIZE 0x1000uL
+
+namespace fos {
+    /**
+     * @brief Base class for tasks
+     */
+    class TaskBase {
+      protected:
+        TaskHandle_t _handle;
+
+        static void disposeFrameConditionally() {
+            if constexpr (INCLUDE_vTaskDelete != 0) {
+                vTaskDelete(NULL);
+                // NOTE: This only compiles if symbol INCLUDE_vTaskDelete is defined
+            }
+        }
+
+        Semaphore _finished;
+
+      public:
+        /// @brief Priority type (redefinition for convenience)
+        using Priority = unsigned short;
+        /// @brief Tick type (redefinition for convenience)
+        using Tick = TickType_t;
+        /// @brief Definition for endless waittime
+        static constexpr Tick MaxDelay = portMAX_DELAY;
+
+        /// @brief Maximum delay
+        static constexpr int MaximumDelay = portMAX_DELAY;
+
+        /// @brief Default Stack size
+        static constexpr size_t DefaultStackSize = DEFAULT_STACKSIZE;
+
+        /// @brief Lowest priority for new tasks
+        static constexpr Priority MIN_PRIORITY = tskIDLE_PRIORITY + 1;
+
+        /// @brief Highest priority for new tasks
+        static constexpr Priority MAX_PRIORITY = configMAX_PRIORITIES;
+
+        /// @brief Kill a task
+        /// @note It can lead to undefined behaviour when one task deletes another task on a
+        ///   multi-core system. Hence a task should clear itself.
+        void kill() { // NOTE: this leads to undefined behavior if interferes with Destructor
+            vTaskDelete(_handle);
+        }
+
+        /// @brief Join threads
+        /// @param timeout timeout to wait for join else kill
+        /// @return joined successfully
+        bool join(Tick timeout = MaxDelay) {
+            auto success = _finished.take(timeout);
+            if(not success) {
+                kill();
+            }
+            return success;
+        }
+
+        /// @brief Get task state
+        /// @return FreeRTOS Task state
+        eTaskState getState() {
+            return eTaskGetState(_handle);
+        }
+
+        /// @brief Get task handle
+        /// @return FreeRTOS Task handle
+        TaskHandle_t getHandle() {
+            return _handle;
+        }
+
+        /// @brief Delay function
+        /// @param msToDelay Milliseconds to delay
+        /// @note The minimal resolution for the delay is tick based
+        static void delayMs(unsigned int msToDelay) {
+            // pdMS_TO_TICKS(_timeout)
+            vTaskDelay(msToDelay / portTICK_PERIOD_MS);
+        }
+
+        /// @brief Delay function
+        /// @param ticksToDelay Ticks to delay
+        static void delayTicks(unsigned int ticksToDelay) {
+            vTaskDelay(ticksToDelay);
+        }
+
+        virtual ~TaskBase() {
+            kill();
+        }
+    };
+
+    /**
+     * @brief Simple task without task parameter
+     */
+    class Task : public TaskBase {
+      private:
+        /// @brief Signature for task-implementation-callback
+        using TaskSignature = void (*)();
+
+        static void TaskFrame(void *_this) {
+            auto &task = *reinterpret_cast<Task *>(_this);
+            task._call();
+            // Tasks shall not return, however if this happens dispose task
+            disposeFrameConditionally();
+            task._finished.give();
+        }
+
+        TaskSignature _call;
+
+      public:
+        /// @brief Constructor for task without passed argument
+        /// @param call Function pointer to implementation
+        /// @param name Name of task
+        /// @param stack Stacksize if not default
+        /// @param prio Priority if not default
+        Task(TaskSignature call, const char *name, size_t stack = DefaultStackSize,
+             Priority prio = MIN_PRIORITY)
+            : _call{call} {
+            auto ret = xTaskCreate(TaskFrame, name, stack, this, MIN_PRIORITY, &_handle);
+            assert(pdPASS == ret && "Task create must finish successfully");
+        }
+    };
+
+    /**
+     * @brief Task with task parameter
+     * @tparam T Type of task parameter on call
+     */
+    template <typename T>
+    class TaskT : public TaskBase {
+      private:
+        /// @brief Signature for task-implementation-callback
+        using TaskSignature = void (*)(T);
+
+        template <typename TS>
+        struct Param {
+            TaskSignature call;
+            const TS &arg;
+        };
+        Param<T> _param;
+
+        static void TaskFrame(void *_this) {
+            auto &task = *reinterpret_cast<TaskT *>(_this);
+            auto &param = task._param;
+            param.call(param.arg);
+            // Tasks shall not return, however if this happens dispose task
+            disposeFrameConditionally();
+            task._finished.give();
+        }
+
+      public:
+        /// @brief Constructor for task with passed argument
+        /// @param call Function pointer to implementation
+        /// @param param Parameter ot pass task implementation
+        /// @param name Name of task
+        /// @param stack Stacksize if not default
+        /// @param prio Priority if not default
+        TaskT(TaskSignature call, const T &param, const char *name, size_t stack = DefaultStackSize,
+              Priority prio = MIN_PRIORITY)
+            : _param{call, param} {
+            auto ret = xTaskCreate(TaskFrame, name, stack, this, MIN_PRIORITY, &_handle);
+            assert(pdPASS == ret && "Task create must finish successfully");
+        }
+    };
+
+    class Timing {
+        public:
+        static uint32_t getTickCount() {
+            return xTaskGetTickCount();
+        }
+    };
+
+} // namespace fos