bare_metal.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 <cstdint>
#include <utility>
 
#include "tsm/runtime/executor.h"
 
namespace tsm {
 
struct bare_metal_wake_hooks
{
    static void notify() noexcept {}
    static void wait_for_event() noexcept {}
};
 
class bare_metal_tick_source
{
  public:
    explicit constexpr bare_metal_tick_source(tsm::tick_rep volatile& counter)
      : counter_(&counter)
    {
    }
 
    [[nodiscard]] tsm::tick_rep ticks() const noexcept
    {
        return *counter_;
    }
 
  private:
    tsm::tick_rep volatile* counter_{};
};
 
template<typename... Tasks>
class bare_metal_task_executor
{
  public:
    explicit constexpr bare_metal_task_executor(Tasks&... tasks)
      : ready_(tasks...)
    {
    }
 
    [[nodiscard]] bool step()
    {
        return ready_.step();
    }
 
    std::size_t run_ready()
    {
        const auto ran = ready_.run_ready();
        if (ran == 0U) {
            // Idle behavior belongs to the board support package. The default
            // hook is empty; Cortex-M projects can map it to WFE or WFI.
            bare_metal_wake_hooks::wait_for_event();
        }
        return ran;
    }
 
    std::size_t tick(tsm::tick_rep elapsed_ticks = 1U)
    {
        // SysTick or another interrupt source should translate elapsed time to
        // integer ticks before calling this function.
        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 wake()
    {
        bare_metal_wake_hooks::notify();
    }
    void wake_from_isr()
    {
        wake();
    }
    void wait_for_work()
    {
        bare_metal_wake_hooks::wait_for_event();
    }
    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)
    {
        return ready_.template spawn<Entry>(std::forward<Args>(args)...);
    }
 
    [[nodiscard]] runtime::task_spawner<bare_metal_task_executor> spawner()
    {
        return runtime::task_spawner<bare_metal_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_;
};
 
template<typename... Tasks>
bare_metal_task_executor(Tasks&...) -> bare_metal_task_executor<Tasks...>;
 
template<typename... Tasks>
using task_executor = bare_metal_task_executor<Tasks...>;
 
} // namespace tsm