stk_helper.h

Go to the documentation of this file.

/*
 * SuperTinyKernel(TM) RTOS: Lightweight High-Performance Deterministic C++ RTOS for Embedded Systems.
 *
 * Source: https://github.com/SuperTinyKernel-RTOS
 *
 * Copyright (c) 2022-2026 Neutron Code Limited <stk@neutroncode.com>. All Rights Reserved.
 * License: MIT License, see LICENSE for a full text.
 */
 
#ifndef STK_HELPER_H_
#define STK_HELPER_H_
 
#include "stk_common.h"
#include "stk_arch.h"

 
namespace stk {

template <size_t _StackSize, EAccessMode _AccessMode>
class Task : public ITask
{
public:
    enum { STACK_SIZE = _StackSize }; 
 
    Word *GetStack() const { return const_cast<Word *>(m_stack); }
    size_t GetStackSize() const { return _StackSize; }
    size_t GetStackSizeBytes() const { return _StackSize * sizeof(Word); }
    EAccessMode GetAccessMode() const { return _AccessMode; }

    virtual void OnDeadlineMissed(uint32_t duration) { STK_UNUSED(duration); }

    virtual void OnExit() {}

    virtual int32_t GetWeight() const { return 1; }

    virtual TId GetId() const { return hw::PtrToWord(this); }

    virtual const char *GetTraceName() const { return nullptr; }
 
protected:
    STK_NONCOPYABLE_CLASS(Task);

    Task() : m_stack()
    {}

    ~Task()
    {}
 
private:
    typename StackMemoryDef<_StackSize>::Type m_stack; 
};

template <int32_t _Weight, size_t _StackSize, EAccessMode _AccessMode>
class TaskW : public ITask
{
public:
    enum { STACK_SIZE = _StackSize }; 
 
    Word *GetStack() const { return const_cast<Word *>(m_stack); }
    size_t GetStackSize() const { return _StackSize; }
    size_t GetStackSizeBytes() const { return _StackSize * sizeof(Word); }
    EAccessMode GetAccessMode() const { return _AccessMode; }

    virtual void OnDeadlineMissed(uint32_t duration) { STK_ASSERT(false); STK_UNUSED(duration); }

    virtual void OnExit() {}

    virtual int32_t GetWeight() const { return _Weight; }

    virtual TId GetId() const { return hw::PtrToWord(this); }

    virtual const char *GetTraceName() const { return nullptr; }
 
protected:
    STK_NONCOPYABLE_CLASS(TaskW);

    TaskW() : m_stack() {}

    ~TaskW()
    {}
 
private:
    typename StackMemoryDef<_StackSize>::Type m_stack; 
};

template <size_t _StackSize>
class StackMemoryWrapper : public IStackMemory
{
public:
    typedef typename StackMemoryDef<_StackSize>::Type MemoryType;

    explicit StackMemoryWrapper(MemoryType *stack) : m_stack(stack)
    {
        STK_STATIC_ASSERT(_StackSize >= STACK_SIZE_MIN);
    }

    ~StackMemoryWrapper()
    {}

    Word *GetStack() const { return (*m_stack); }

    size_t GetStackSize() const { return _StackSize; }

    size_t GetStackSizeBytes() const { return _StackSize * sizeof(Word); }
 
private:
    MemoryType *m_stack; 
};

__stk_forceinline TId GetTid()
{
    return IKernelService::GetInstance()->GetTid();
}

__stk_forceinline int64_t GetMsFromTicks(int64_t ticks, int32_t resolution)
{
    return (ticks * resolution) / 1000;
}

__stk_forceinline Ticks GetTicksFromMs(int64_t ms, int32_t resolution)
{
    return ms * 1000 / resolution;
}

__stk_forceinline Ticks GetTicks()
{
    return IKernelService::GetInstance()->GetTicks();
}

__stk_forceinline int32_t GetTickResolution()
{
    return IKernelService::GetInstance()->GetTickResolution();
}

__stk_forceinline Ticks GetTicksFromMs(int64_t ms)
{
    return GetTicksFromMs(ms, GetTickResolution());
}

static inline int64_t GetTimeNowMs()
{
    IKernelService *service = IKernelService::GetInstance();
    int32_t resolution = service->GetTickResolution();
 
    if (resolution == 1000) // fast path: tick == 1 ms, no conversion needed
        return service->GetTicks();
    else
        return (service->GetTicks() * resolution) / 1000;
}

__stk_forceinline Cycles GetSysTimerCount()
{
    return IKernelService::GetInstance()->GetSysTimerCount();
}

__stk_forceinline uint32_t GetSysTimerFrequency()
{
    return IKernelService::GetInstance()->GetSysTimerFrequency();
}

__stk_forceinline void Sleep(Timeout ticks)
{
    IKernelService::GetInstance()->Sleep(ticks);
}

static inline void SleepMs(Timeout ms)
{
    Sleep(static_cast<Timeout>(GetTicksFromMs(ms)));
}

__stk_forceinline void SleepUntil(Ticks timestamp)
{
    IKernelService::GetInstance()->SleepUntil(timestamp);
}

__stk_forceinline void Yield()
{
    IKernelService::GetInstance()->SwitchToNext();
}

__stk_forceinline void Delay(Timeout ticks)
{
    IKernelService::GetInstance()->Delay(ticks);
}

static inline void DelayMs(Timeout ms)
{
    Delay(static_cast<Timeout>(GetTicksFromMs(ms)));
}
 
} // namespace stk
 
#endif /* STK_HELPER_H_ */