zephyr.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 <cstddef>
#include <cstdint>
#include <utility>
 
#include "tsm/runtime/executor.h"
#include "tsm/runtime/static_ring.h"
 
#if defined(__ZEPHYR__)
#include <zephyr/kernel.h>
 
namespace tsm::runtime::storage {
 
template<std::size_t Capacity>
struct zephyr_msgq
{
    static constexpr std::size_t capacity = Capacity;
 
    template<typename Event>
    class queue
    {
        static_assert(Capacity > 0,
                      "tsm: zephyr_msgq requires non-zero capacity");
 
      public:
        using value_type = Event;
 
        queue()
        {
            k_msgq_init(
              &queue_, buffer_, sizeof(Event), static_cast<uint32_t>(Capacity));
        }
 
        queue(queue const&) = delete;
        queue& operator=(queue const&) = delete;
 
        [[nodiscard]] bool try_push(Event const& event)
        {
            return k_msgq_put(&queue_, &event, K_NO_WAIT) == 0;
        }
 
        [[nodiscard]] bool try_push(Event&& event)
        {
            return k_msgq_put(&queue_, &event, K_NO_WAIT) == 0;
        }
 
        [[nodiscard]] bool try_pop(Event& event)
        {
            return k_msgq_get(&queue_, &event, K_NO_WAIT) == 0;
        }
 
        [[nodiscard]] bool empty() const
        {
            return k_msgq_num_used_get(const_cast<k_msgq*>(&queue_)) == 0U;
        }
 
        [[nodiscard]] bool full() const
        {
            return k_msgq_num_free_get(const_cast<k_msgq*>(&queue_)) == 0U;
        }
 
        [[nodiscard]] std::size_t size() const
        {
            return k_msgq_num_used_get(const_cast<k_msgq*>(&queue_));
        }
 
        [[nodiscard]] k_msgq* native_handle()
        {
            return &queue_;
        }
        [[nodiscard]] k_msgq const* native_handle() const
        {
            return &queue_;
        }
 
      private:
        alignas(Event) char buffer_[Capacity * sizeof(Event)]{};
        k_msgq queue_{};
    };
};
 
template<std::size_t Capacity>
struct target_storage<Capacity, zephyr_storage_tag>
{
    using type = zephyr_msgq<Capacity>;
};
 
} // namespace tsm::runtime::storage
 
namespace tsm {
 
struct zephyr_tick_source
{
    [[nodiscard]] tsm::tick_rep ticks() const noexcept
    {
        return static_cast<tsm::tick_rep>(k_uptime_ticks());
    }
};
 
template<typename... Tasks>
class zephyr_task_executor
{
  public:
    explicit zephyr_task_executor(Tasks&... tasks)
      : ready_(tasks...)
    {
        k_sem_init(&wake_sem_, 0, 1);
    }
 
    void start() {}
    void stop() {}
 
    void wake()
    {
        k_sem_give(&wake_sem_);
    }
    void wake_from_isr()
    {
        wake();
    }
 
    void wait_for_work()
    {
        static_cast<void>(k_sem_take(&wake_sem_, K_MSEC(1)));
    }
 
    [[nodiscard]] bool step()
    {
        return ready_.step();
    }
 
    std::size_t run_ready()
    {
        const auto ran = ready_.run_ready();
        if (ran == 0U) {
            // The semaphore is the Zephyr wake primitive; runtime queues still
            // carry typed tsm events and coroutine wakeups.
            wait_for_work();
        }
        return ran;
    }
 
    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<zephyr_task_executor> spawner()
    {
        return runtime::task_spawner<zephyr_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();
    }
 
  private:
    runtime::cooperative_executor<Tasks...> ready_;
    k_sem wake_sem_{};
};
 
template<typename... Tasks>
zephyr_task_executor(Tasks&...) -> zephyr_task_executor<Tasks...>;
 
template<typename... Tasks>
using task_executor = zephyr_task_executor<Tasks...>;
 
} // namespace tsm
 
#endif // defined(__ZEPHYR__)