freertos.h

Go to the documentation of this file.

// Copyright (c) 2026 Tinverse LLC. All rights reserved.
// SPDX-License-Identifier: LicenseRef-Tinverse-Commercial
 
 
#pragma once
 
#include <chrono>
#include <cstddef>
#include <type_traits>
#include <utility>
 
#include "tsm/runtime/executor.h"
#include "tsm/runtime/static_ring.h"
 
#include "FreeRTOS.h"
#include "queue.h"
#include "task.h"
 
constexpr int MaxEvents = 10; // Define your own queue size
 
namespace tsm::runtime::storage {
 
template<std::size_t Capacity>
struct freertos_queue
{
    static constexpr std::size_t capacity = Capacity;
 
    template<typename Event>
    class queue
    {
        static_assert(Capacity > 0,
                      "tsm: freertos_queue requires non-zero capacity");
 
      public:
        using value_type = Event;
 
        queue()
          : handle_(xQueueCreate(Capacity, sizeof(Event)))
        {
            configASSERT(handle_ != nullptr);
        }
 
        queue(queue const&) = delete;
        queue& operator=(queue const&) = delete;
 
        ~queue()
        {
            if (handle_ != nullptr) {
                vQueueDelete(handle_);
            }
        }
 
        [[nodiscard]] bool try_push(Event const& event)
        {
            return xQueueSendToBack(handle_, &event, 0) == pdTRUE;
        }
 
        [[nodiscard]] bool try_push(Event&& event)
        {
            return xQueueSendToBack(handle_, &event, 0) == pdTRUE;
        }
 
        [[nodiscard]] bool try_pop(Event& event)
        {
            return xQueueReceive(handle_, &event, 0) == pdTRUE;
        }
 
        [[nodiscard]] bool empty() const
        {
            return uxQueueMessagesWaiting(handle_) == 0;
        }
 
        [[nodiscard]] bool full() const
        {
            return uxQueueSpacesAvailable(handle_) == 0;
        }
 
        [[nodiscard]] std::size_t size() const
        {
            return uxQueueMessagesWaiting(handle_);
        }
 
        [[nodiscard]] QueueHandle_t native_handle() const
        {
            return handle_;
        }
 
      private:
        QueueHandle_t handle_{};
    };
};
 
template<std::size_t Capacity>
struct target_storage<Capacity, freertos_storage_tag>
{
    using type = freertos_queue<Capacity>;
};
 
} // namespace tsm::runtime::storage
 
namespace tsm {
 
struct FreeRTOSClock
{
    using duration = std::chrono::milliseconds;
    using period = duration::period;
    using rep = duration::rep;
    using time_point = std::chrono::time_point<FreeRTOSClock>;
 
    static constexpr bool is_steady = true;
 
    static time_point now() noexcept
    {
        TickType_t ticks = xTaskGetTickCount();
        auto elapsed =
          std::chrono::milliseconds(ticks * (1000 / configTICK_RATE_HZ));
        return time_point(duration(elapsed));
    }
};
 
struct FreeRTOSTickSource
{
    [[nodiscard]] tsm::tick_rep ticks() const noexcept
    {
        return static_cast<tsm::tick_rep>(xTaskGetTickCount());
    }
};
 
template<typename... Tasks>
class freertos_task_executor
{
  public:
    explicit freertos_task_executor(Tasks&... tasks)
      : ready_(tasks...)
    {
    }
 
    freertos_task_executor(freertos_task_executor const&) = delete;
    freertos_task_executor& operator=(freertos_task_executor const&) = delete;
 
    ~freertos_task_executor()
    {
        stop();
    }
 
    void start(char const* name = "tsm_exec",
               uint16_t stack_depth = configMINIMAL_STACK_SIZE,
               UBaseType_t priority = tskIDLE_PRIORITY + 1U)
    {
        if (task_handle_ != nullptr) {
            return;
        }
        stop_requested_ = pdFALSE;
        xTaskCreate(
          task_entry, name, stack_depth, this, priority, &task_handle_);
    }
 
    void stop()
    {
        stop_requested_ = pdTRUE;
        wake();
        if (task_handle_ != nullptr) {
            vTaskDelete(task_handle_);
            task_handle_ = nullptr;
        }
    }
 
    void wake()
    {
        if (task_handle_ != nullptr) {
            // Task notification is only a wake surface. Event storage remains
            // in the selected runtime queue topology.
            xTaskNotifyGive(task_handle_);
        }
    }
 
    void wake_from_isr()
    {
        if (task_handle_ != nullptr) {
            BaseType_t higher_priority_task_woken = pdFALSE;
            vTaskNotifyGiveFromISR(task_handle_, &higher_priority_task_woken);
            portYIELD_FROM_ISR(higher_priority_task_woken);
        }
    }
 
    void wait_for_work()
    {
        static_cast<void>(ulTaskNotifyTake(pdTRUE, 1));
    }
 
    [[nodiscard]] bool step()
    {
        return ready_.step();
    }
 
    std::size_t run_ready()
    {
        return ready_.run_ready();
    }
 
    std::size_t tick(tsm::tick_rep elapsed_ticks = 1U)
    {
        const auto resumed = ready_.tick(elapsed_ticks);
        if (resumed != 0U) {
            wake();
        }
        return resumed;
    }
 
    std::size_t tick(tsm::tick_count elapsed_ticks)
    {
        return tick(elapsed_ticks.count());
    }
 
    void start_all()
    {
        ready_.start_all();
    }
 
    template<auto Entry, std::size_t Instance = 0U>
    [[nodiscard]] spawn_result start()
    {
        auto result = ready_.template start<Entry, Instance>();
        if (result == spawn_result::started) {
            wake();
        }
        return result;
    }
 
    template<auto Entry, typename... Args>
    [[nodiscard]] spawn_result spawn(Args&&... args)
    {
        auto result = ready_.template spawn<Entry>(std::forward<Args>(args)...);
        if (result == spawn_result::started) {
            wake();
        }
        return result;
    }
 
    [[nodiscard]] runtime::task_spawner<freertos_task_executor> spawner()
    {
        return runtime::task_spawner<freertos_task_executor>{ *this };
    }
 
    template<auto Entry, std::size_t Instance = 0U>
    [[nodiscard]] task_status task_status() const
    {
        return ready_.template task_status<Entry, Instance>();
    }
 
    template<auto Entry, std::size_t Instance = 0U>
    [[nodiscard]] task_failure_reason task_failure_reason() const
    {
        return ready_.template task_failure_reason<Entry, Instance>();
    }
 
    template<auto Entry, std::size_t Instance = 0U>
    [[nodiscard]] bool cancel() noexcept
    {
        const bool cancelled = ready_.template cancel<Entry, Instance>();
        if (cancelled) {
            wake();
        }
        return cancelled;
    }
 
    void cancel_all() noexcept
    {
        ready_.cancel_all();
        wake();
    }
 
  protected:
    tsm::runtime::cooperative_executor<Tasks...> ready_;
    TaskHandle_t task_handle_{};
    BaseType_t stop_requested_{ pdTRUE };
 
    static void task_entry(void* pv_parameters)
    {
        auto* executor = static_cast<freertos_task_executor*>(pv_parameters);
        executor->run_task();
    }
 
    void run_task()
    {
        while (!stop_requested_) {
            if (ready_.run_ready() == 0U) {
                // No cooperative work is ready, so the executor task blocks
                // briefly until an event, spawned task, or tick wakes it.
                wait_for_work();
            }
        }
    }
};
 
template<typename... Tasks>
freertos_task_executor(Tasks&...) -> freertos_task_executor<Tasks...>;
 
template<typename... Tasks>
using task_executor = freertos_task_executor<Tasks...>;
 
} // namespace tsm