nbrtos.h

/*NB_REVISION*/
 
/*NB_COPYRIGHT*/
 
 
#ifndef _NBRTOS_H
#define _NBRTOS_H
 
#include <predef.h>
#include <constants.h>
#include <basictypes.h>
#include <nbrtoscpu.h>
#include <predef.h>
 
#define OS_LO_PRIO (OS_MAX_PRIOS-1)     /* IDLE task priority      */
 
#define OS_STAT_RDY 0x00     
#define OS_STAT_MBOX 0x01    
#define OS_STAT_SEM 0x02     
#define OS_STAT_Q 0x04       
#define OS_STAT_FIFO 0x08    
#define OS_STAT_CRIT 0x10    
#define OS_STAT_DELAY 0x20   
#define OS_STAT_JOIN 0x40    
#define OS_STAT_RES4 0x40    
#define OS_STAT_RES5 0x80    
#define OS_NO_ERR 0         
#define OS_TIMEOUT 10       
#define OS_MBOX_FULL 20     
#define OS_Q_FULL 30        
#define OS_Q_EXISTS 31      
#define OS_PRIO_EXIST 40    
#define OS_PRIO_INVALID 41  
#define OS_SEM_ERR 50       
#define OS_SEM_OVF 51       
#define OS_CRIT_ERR 60      
#define OS_NO_MORE_TCB 70   
 // nbrtosErrorGroup
 
#define OS_TFLAG_IN_USE 0x80 
 // nbrtosTaskFlag
 
#define WAIT_FOREVER 0      
 
typedef volatile uint32_t tick_t;
 
 
// GLOBAL VARIABLES
extern vuint32_t Secs;             // Number of seconds since system start
extern volatile tick_t TimeTick;   // Number of time ticks since system start
 
// Is test_time later than now (TimeTick)
inline bool IsTickLater(uint32_t test_time)
{
    return ((int)(TimeTick - test_time) < 0);
}
 
// Is test_time NoworEarlier than TimeTick
inline bool IsTickNowOrEarlier(uint32_t test_time)
{
    return ((int)(TimeTick - test_time) >= 0);
}
 
// Compare two timetick values
inline bool Is2ndTickEarlier(uint32_t t1, uint32_t t2)
{
    return (((int)(t1 - t2)) > 0);
}
 
// Compare two timetick values
inline bool Is2ndTickNowOrEarlier(uint32_t t1, uint32_t t2)
{
    return (((int)(t1 - t2)) >= 0);
}
 
class TickTimeout;
struct RawTickTimeout_t
{
    tick_t expiration = 0;
 
    inline bool expired() const { return expiration ? (((int)(expiration - TimeTick)) <= 0) : false; }
    inline bool expired() volatile { return expiration ? (((int)(expiration - TimeTick)) <= 0) : false; }
    inline operator bool() const { return !expired(); }
    const RawTickTimeout_t &operator=(const TickTimeout &rhs);
    volatile RawTickTimeout_t &operator=(const TickTimeout &rhs) volatile;
 
    inline bool operator<(const RawTickTimeout_t &later)
    {
        if (!expiration)
            return false;
        if (!later.expiration)
            return true;
        return (((int)(expiration - later.expiration)) <= 0);
    }
 
    inline bool operator<(tick_t later)
    {
        if (!expiration)
            return false;
        return (((int)(expiration - later)) <= 0);
    }
 
    inline tick_t operator-(const tick_t &tick) { return expiration - tick; }
    inline tick_t operator-(const tick_t &tick) const { return expiration - tick; }
    inline tick_t operator-(const tick_t &tick) volatile { return expiration - tick; }
};
 
inline bool operator==(const RawTickTimeout_t &lhs, const int &rhs)
{
    return lhs.expiration == (tick_t)rhs;
}
 
inline bool operator==(const volatile RawTickTimeout_t &lhs, const int &rhs)
{
    return lhs.expiration == (tick_t)rhs;
}
 
class TickTimeout
{
    RawTickTimeout_t raw;
 
    void set(uint32_t timeout)
    {
        if (!timeout) { raw.expiration = 0; }
        else
        {
            raw.expiration = TimeTick + (timeout & 0x7FFFFFFF);
            // A 1 tick delay extension is introduced on TimeTick overflow
            // in order to allow for infinite delays to be indicated with an
            // expiration of zero
            if (timeout && !raw.expiration) { raw.expiration = 1; }
        }
    }
 
   public:
    class uint32_nonboolean_t
    {
        uint32_t value;
 
       public:
        uint32_nonboolean_t(uint32_t val) : value(val) {}
        inline explicit operator bool() { return (bool)value; }
        inline operator uint32_t() { return value; }
    };
 
    explicit TickTimeout() { set(0); }
 
    TickTimeout(uint32_t timeout) { set(timeout); }
    TickTimeout(uint16_t timeout) { set(timeout); }
    TickTimeout(int      timeout) { set(timeout); }
 
 
    inline uint32_t val() const
    {
        if (!raw.expiration) { return raw.expiration; }
        int ret = raw.expiration - TimeTick;
        // Prevent passing an infinite or otherwise bogus timeout in a tick race
        return (ret > 0) ? ret : 1;
    }
 
    inline bool expired() const { return raw.expired(); }
 
    inline operator bool() const { return !expired(); }
 
    inline operator uint32_t() const { return val(); }
 
    inline operator uint16_t() const
    {
        uint32_t ret = val();
        return ret > 0xFFFF ? 0xFFFE : ret;
    }
 
    inline TickTimeout &operator=(const TickTimeout &rhs)
    {
        raw.expiration = rhs.raw.expiration;
        return *this;
    }
    inline TickTimeout &operator=(uint32_t val)
    {
        set(val);
        return *this;
    }
    inline bool operator<(TickTimeout later)
    {
        return raw < later.raw;
    }
    inline bool operator<(tick_t later)
    {
        return raw < later;
    }
    inline TickTimeout &operator+=(uint32_t val)
    {
        if (raw.expiration)
        {
            raw.expiration += (val & 0x7FFFFFFF);
            // A 1 tick delay extension is introduced on TimeTick overflow
            // in order to allow for infinite delays to be indicated with an
            // expiration of zero
            if (val && !raw.expiration) { raw.expiration = 1; }
        }
        return *this;
    }
 
    inline void SetUntil(uint32_t when) {raw.expiration = when; }
 
    friend void OSTimeWaitUntil(uint32_t systemTickValue);
 
    friend class RawTickTimeout_t;
};
 
inline const RawTickTimeout_t &RawTickTimeout_t::operator=(const TickTimeout &rhs)
{
    expiration = rhs.raw.expiration;
    return *this;
}
 
inline volatile RawTickTimeout_t &RawTickTimeout_t::operator=(const TickTimeout &rhs) volatile
{
    expiration = rhs.raw.expiration;
    return *this;
}
 
// The following class holds a list of tasks
 
class task_bit_list
{
   public:
    volatile uint32_t OSTbl[TASK_TABLE_SIZE];
 
    // task_bit_list();
    void Init() volatile;
    void Copy(volatile task_bit_list &rhs)
    {
        for (int i = 0; i < TASK_TABLE_SIZE; i++)
        {
            OSTbl[i] = rhs.OSTbl[i];
        }
    }
 
    // The following functions are all guaranteed to be atomic
    void set(int set_num) volatile;
    void clr(int clr_num) volatile;
 
    // The following functions return 0 if no bits are set.
    uint32_t gethigh() volatile;
    uint32_t get_high_and_clear() volatile;
 
    inline bool isSet(int num) volatile const { return (OSTbl[num / 32] & (0x80000000 >> (num % 32))); }
};
 
class OS_TCB;
 
// The common element of all the task objects
class OS_TASK_DLY_OBJ
{
    task_bit_list tasks_waiting;
 
   public:
    OS_TASK_DLY_OBJ();
    void Init();
 
    // Returns true if woken up, returns false if timed out
    bool Wait_when(uint8_t StatReason, TickTimeout &timeout);
 
    inline bool Wait(uint8_t StatReason, uint32_t to_count)
    {
        TickTimeout to_when(to_count);
        return Wait_when(StatReason, to_when);
    }
 
    // This releases the highest priority task waiting on this object.
    void MakeHighTaskWaitingReady(uint8_t StatReason);
    void MakeTaskWaitingReady(uint8_t taskPrio, uint8_t StatReason);
    void MakeAllWaitingReady(uint8_t StatReason);
 
    friend class OS_TCB;
 
} __attribute__((packed));
 
// class OS_TCB;//forward
 
class OS_TCB : public cpu_tcb
{
   public:
    uint8_t OSTCBStat;     // Holds the current status of the TCB
    uint8_t OSTCBResult;   // Basically holds the timeout or not flag when woken.
    uint8_t OSTCBPrio;     // Index to prio table.... not sure if we need to keep this.
    uint8_t OSTCBFlags;    // Make 32 bit aligned.
 
    RawTickTimeout_t OSTCBDly_when;   // When to release timeout the task, 0= never.
 
    const char *pOSTCBName;
    OS_TCB *OSTCBNext;
    OS_TCB *OSTCBPrev;
 
#ifdef NBRTOS_PRIO_PROMOTION
    // These pointers are for handling Priority Promotion when OS_CRITs create
    // an inversion situation
    volatile OS_TCB *pPromotedTo;
    volatile OS_TCB *pDisplacedBy;
    OS_TASK_DLY_OBJ *pWaiting;
    uint32_t displacedByOrigPrio;
 
    void PromoteToCurPrio() volatile;
    void Demote() volatile;
#endif
 
    static volatile OS_TCB *GetCur();
 
#ifdef NBRTOS_TIME
    unsigned long switchTimeTick;
    unsigned long switchTimeFraction;
    unsigned long runningTime;
    unsigned long runningTimeFraction;
#endif
    //  OS_TCB(); //Zero everything
    void Init();
 
    // Set up TCB assuming that the STACK has already been setup and properly initalized.
    bool Init(uint8_t prio, void *pActualTop, void *pstk, long *pbot, const char *name);
};
 
/* Forward Declaration */
struct OS_CRIT;
 
struct OS_SEM : public OS_TASK_DLY_OBJ
{
    volatile uint32_t OSSemCnt;
    volatile uint32_t OSSemUsed;
 
   private:
    bool Claim();
 
   public:
    inline OS_SEM(int32_t cnt = 0) : OS_TASK_DLY_OBJ() { Init(cnt); }
 
    uint8_t Init(int32_t cnt = 0);
 
    uint8_t Post();
 
    inline uint8_t Pend(uint32_t timeoutTicks = WAIT_FOREVER){TickTimeout tt(timeoutTicks); return Pend(tt);};
 
    inline uint8_t PendUntil(uint32_t timeout_time){TickTimeout tt(0); tt.SetUntil(timeout_time); return Pend(tt);};
 
    uint8_t Pend(TickTimeout &t);
 
    uint8_t PendNoWait();
 
    inline uint32_t Avail() { uint32_t v; USER_ENTER_CRITICAL();  v=OSSemCnt-OSSemUsed; USER_EXIT_CRITICAL(); return v;};
 
} __attribute__((packed));
 
struct OS_MBOX : public OS_TASK_DLY_OBJ
{
    void *OSMboxMsg;
    bool OSMboxDataAvail;
 
    bool Claim(void *&Result);
 
   public:
    inline OS_MBOX() : OS_TASK_DLY_OBJ() { Init(); }
 
    inline OS_MBOX(void *msg) : OS_TASK_DLY_OBJ() { Init(msg); }
 
    uint8_t Init(void *msg = NULL);
 
    uint8_t Post(void *msg);
 
    inline void *Pend(uint32_t timeoutTicks, uint8_t &result){TickTimeout tt(timeoutTicks); return Pend(tt,result);};
 
    void *Pend(TickTimeout &t, uint8_t &result);
 
    inline void *Pend(uint32_t timeoutTicks = WAIT_FOREVER)
    {
        uint8_t unused;
        return Pend(timeoutTicks, unused);
    };
 
    inline void *PendUntil(uint32_t timeoutTime, uint8_t &result){TickTimeout tt(0); tt.SetUntil(timeoutTime); return Pend(tt,result);};
 
    void *PendNoWait(uint8_t &result);
 
    inline void *PendNoWait()
    {
        uint8_t unused;
        return PendNoWait(unused);
    };
};
 
 
template<typename T>
class TEMPL_MBOX
{
   protected:
    OS_MBOX m_mbox;
 
   public:
    TEMPL_MBOX(const T *msg) : m_mbox((void *)msg) {}
    inline uint8_t Init(const T *msg) { return m_mbox.Init((void *)msg); }
    inline uint8_t Post(const T *msg) { return m_mbox.Post((void *)msg); }
 
    inline T *Pend(uint32_t timeoutTicks, uint8_t &result) { return static_cast<T *>(m_mbox.Pend(timeoutTicks, result)); };
 
    inline T *PendNoWait(uint8_t &result) { return static_cast<T *>(m_mbox.PendNoWait(result)); };
 
    inline T *Pend(uint32_t timeoutTicks = WAIT_FOREVER) { return static_cast<T *>(m_mbox.Pend(timeoutTicks)); };
 
    inline T *PendNoWait() { return static_cast<T *>(m_mbox.PendNoWait()); };
};
 
 
struct OS_Q : public OS_TASK_DLY_OBJ
{
    void **OSQStart;
    void **OSQEnd;
    void **OSQIn;
    void **OSQOut;
    uint8_t OSQSize;
    uint8_t OSQEntries;
 
    bool Claim(void *&Result);
 
   public:
    inline OS_Q(void **pQueueStorage, uint8_t size) : OS_TASK_DLY_OBJ() { Init(pQueueStorage, size); }
 
    uint8_t Init(void **pQueueStorage, uint8_t size);
 
    uint8_t Post(void *pItem);
 
    uint8_t PostFirst(void *pItem);
 
    uint8_t PostUnique(void *pItem);
 
    uint8_t PostUniqueFirst(void *msg);
 
    inline void *Pend(uint32_t timeoutTicks, uint8_t &result){TickTimeout tt(timeoutTicks); return Pend(tt,result);};
 
    void *Pend(TickTimeout &t, uint8_t &result);
 
    inline void *Pend(uint32_t timeoutTicks = WAIT_FOREVER)
    {
        uint8_t unused;
        return Pend(timeoutTicks, unused);
    };
 
    inline void *PendUntil(uint32_t timeoutTime, uint8_t &result){TickTimeout tt(0); tt.SetUntil(timeoutTime); return Pend(tt,result);};
 
    void *PendNoWait(uint8_t &result);
 
    inline void *PendNoWait()
    {
        uint8_t unused;
        return PendNoWait(unused);
    };
};
 
template<typename T>
struct TEMPL_Q
{
   protected:
    OS_Q m_q;
 
   public:
    TEMPL_Q() {}
    TEMPL_Q(T **pQueueStorage, uint8_t size)
        : m_q((void**)pQueueStorage,size) { }
    uint8_t Init(T **pQueueStorage, uint8_t size) { return m_q.Init((void **)pQueueStorage, size); }
    uint8_t Post(T *item) { return m_q.Post((void *)item); }
    uint8_t PostFirst(T *item) { return m_q.PostFirst((void *)item); };
    uint8_t PostUnique(T *item) { return m_q.PostUnique((void *)item); };
    uint8_t PostUniqueFirst(T *item) { return m_q.PostUniqueFirst((void *)item); };
 
    inline T *Pend(uint32_t timeoutTicks, uint8_t &result) { return static_cast<T *>(m_q.Pend(timeoutTicks, result)); };
 
    inline T *Pend(uint32_t timeoutTicks = WAIT_FOREVER) { return static_cast<T *>(m_q.Pend(timeoutTicks)); };
 
    inline T *PendNoWait() { return static_cast<T *>(m_q.PendNoWait()); };
 
    inline T *PendNoWait(uint8_t &result) { return static_cast<T *>(m_q.PendNoWait(result)); };
};
 
typedef struct os_fifo_el
{
    union
    {
        struct os_fifo_el *pNextFifo_El;    
        puint8_t pAsBytePtr;                
    };
} OS_FIFO_EL;
 
struct OS_FIFO : public OS_TASK_DLY_OBJ
{
    OS_FIFO_EL *pHead;
    OS_FIFO_EL *pTail;
 
    bool Claim(volatile OS_FIFO_EL *&pToRet);
 
   public:
    inline OS_FIFO() : OS_TASK_DLY_OBJ() { Init(); }
 
    uint8_t Init();
 
    uint8_t Post(OS_FIFO_EL *pToPost);
 
    uint8_t PostFirst(OS_FIFO_EL *pToPost);
 
    inline OS_FIFO_EL *Pend(uint32_t timeoutTicks, uint8_t &result){TickTimeout tt(timeoutTicks); return Pend(tt,result);};
 
    OS_FIFO_EL *Pend(TickTimeout &t, uint8_t &result);
 
    inline OS_FIFO_EL *Pend(uint32_t timeoutTicks = WAIT_FOREVER)
    {
        uint8_t unused;
        return Pend(timeoutTicks, unused);
    };
 
    inline OS_FIFO_EL *PendUntil(uint32_t timeoutTime, uint8_t &result){TickTimeout tt(0); tt.SetUntil(timeoutTime); return Pend(tt,result);};
 
    OS_FIFO_EL *PendNoWait(uint8_t &result);
 
 
    inline OS_FIFO_EL *PendNoWait()
    {
        uint8_t unused;
        return PendNoWait(unused);
    };
};
 
 
 
template<typename T>
struct TEMPL_FIFO
{
   protected:
    OS_FIFO m_fifo;
 
   public:
    TEMPL_FIFO() { m_fifo.Init(); }
    uint8_t Init() { return m_fifo.Init(); }
    uint8_t Post(T *item) { return m_fifo.Post((OS_FIFO_EL *)item); }
    uint8_t PostFirst(T *item) { return m_fifo.PostFirst((OS_FIFO_EL *)item); };
 
    inline T *Pend(uint32_t timeoutTicks, uint8_t &result) { return static_cast<T *>(m_fifo.Pend(timeoutTicks, result)); };
 
    inline T *Pend(uint32_t timeoutTicks = WAIT_FOREVER) { return static_cast<T *>(m_fifo.Pend(timeoutTicks)); };
 
    inline T *PendNoWait() { return static_cast<T *>(m_fifo.PendNoWait()); };
 
    inline T *PendNoWait(uint8_t &result) { return static_cast<T *>(m_fifo.PendNoWait(result)); };
 
    inline OS_FIFO *GetRawFIFO() { return &m_fifo; }
};
 
/*
 * Critical Section DATA STRUCTURES
 *
 * Added by PTB 5/09/99
 * Modified by DEC 3/21/16
 */
 
class BufferCriticalLock;
class fifo_buffer_storage;
class OS_RRCB;
 
struct OS_CRIT : public OS_TASK_DLY_OBJ
{
    OS_TCB *OSCritOwnerTCB;
    uint32_t OSCritDepthCount;
 
    bool Claim();
    OS_TCB *GetOwner() { return (OS_TCB*)(((uint32_t)OSCritOwnerTCB)&~0x1ul); }
    void SetOwner(OS_TCB *newOwner)
    {
        OSCritOwnerTCB =
            (OS_TCB*) (((uint32_t)newOwner) | (((uint32_t)OSCritOwnerTCB)&0x1));
    }
 
   public:
    OS_CRIT() { Init(); }
 
    uint8_t Init();
 
    uint8_t LockAndEnter(uint32_t timeoutTicks = WAIT_FOREVER);
 
    uint8_t Enter(TickTimeout &t);
 
    inline uint8_t Enter(uint32_t timeoutTicks = WAIT_FOREVER) {TickTimeout tt(timeoutTicks); return Enter(tt);};
 
    uint8_t EnterNoWait();
 
    uint8_t Leave();
 
    uint8_t LeaveAndUnlock();
 
    friend class BufferCriticalLock;
    friend class fifo_buffer_storage;
    friend class OS_RRCB;
 
    bool UsedFromISR() { return (((uint32_t)OSCritOwnerTCB)&0x1ul); }
 
    void SetUseFromISR(bool enableFromISR)
    {
        if (enableFromISR)
        {
            OSCritOwnerTCB = (OS_TCB*)(((uint32_t)OSCritOwnerTCB)|0x1ul);
        }
        else
        {
            OSCritOwnerTCB = (OS_TCB*)(((uint32_t)OSCritOwnerTCB)&~0x1ul);
        }
    }
 
    bool OwnedByCurTask();
 
    uint32_t CurDepth() { return OSCritDepthCount; }
 
    friend void ForceReboot(bool fromIRQ);
} __attribute__((packed));
 
 
 
struct OS_FLAGS_WAIT;
 
struct OS_FLAGS
{
   protected:
    vuint32_t  m_current_flags;
    void *m_pWaitinglist;
    void TestFlags();
    void AddOFW(OS_FLAGS_WAIT *ofw);
    void RemoveOFW(OS_FLAGS_WAIT *ofw);
 
   public:
    OS_FLAGS();
 
    void Init();
 
    void Set(uint32_t bits_to_set);
 
    void Clear(uint32_t bits_to_clr);
 
 
    void Write(uint32_t bits_to_force);
 
    uint32_t State();
 
    uint8_t PendAny(uint32_t bit_mask, uint16_t timeout = WAIT_FOREVER){TickTimeout tt(timeout); return PendAny(bit_mask,tt);}
 
    uint8_t PendAny(uint32_t bit_mask, TickTimeout & timeout);
 
 
    uint8_t PendAnyUntil(uint32_t bit_mask, uint32_t end_time){TickTimeout tt(0); tt.SetUntil(end_time); return PendAny(bit_mask,tt);}
 
 
    uint8_t PendAnyNoWait(uint32_t bit_mask);
 
    uint8_t PendAll(uint32_t bit_mask, uint16_t timeout = WAIT_FOREVER){TickTimeout tt(timeout); return PendAll(bit_mask,tt);}
 
    uint8_t PendAll(uint32_t bit_mask,TickTimeout & timeout);
 
    uint8_t PendAllUntil(uint32_t bit_mask, uint32_t end_time){TickTimeout tt(0); tt.SetUntil(end_time); return PendAll(bit_mask,tt);}
 
 
    uint8_t PendAllNoWait(uint32_t bit_mask);
 
};
 
 
/* Create and initialize an OS flags object
This function must be called before you use an OS_FLAGS object.
*/
[[deprecated]] inline void OSFlagCreate(OS_FLAGS *pf)
{
    pf->Init();
};
 
[[deprecated]] inline void OSFlagSet(OS_FLAGS *flags, uint32_t bits_to_set)
{
    flags->Set(bits_to_set);
};
 
[[deprecated]] inline void OSFlagClear(OS_FLAGS *flags, uint32_t bits_to_clr)
{
    flags->Clear(bits_to_clr);
};
 
[[deprecated]] inline uint8_t OSFlagPendAny(OS_FLAGS *flags, uint32_t bit_mask, uint16_t timeout)
{
    return flags->PendAny(bit_mask, timeout);
};
 
[[deprecated]] inline uint8_t OSFlagPendAnyNoWait(OS_FLAGS *flags, uint32_t bit_mask)
{
    return flags->PendAnyNoWait(bit_mask);
};
 
[[deprecated]] inline uint8_t OSFlagPendAll(OS_FLAGS *flags, uint32_t bit_mask, uint16_t timeout)
{
    return flags->PendAll(bit_mask, timeout);
};
 
[[deprecated]] inline uint8_t OSFlagPendAllNoWait(OS_FLAGS *flags, uint32_t bit_mask)
{
    return flags->PendAllNoWait(bit_mask);
};
 
[[deprecated]] inline uint32_t OSFlagState(OS_FLAGS *flags)
{
    return flags->State();
};
 
/*
 ***********************************************************
 *                 NBRTOS GLOBAL VARIABLES
 ***********************************************************
 */
// Pointers to each of the OS_TCB structure sorted by priority
extern volatile OS_TCB *OSTCBPrioTbl[OS_MAX_PRIOS];
 
// taks bits for what tasks are ready to run
extern volatile task_bit_list OSTaskReadyList;
#ifdef NBRTOS_PRIO_PROMOTION
extern volatile task_bit_list OSInUsePrioList FAST_SYS_VAR;
extern volatile task_bit_list OSActivePrioList FAST_SYS_VAR;
#endif
 
extern OS_TCB OSTCBTbl[OS_MAX_TASKS];   // All the possible TCB's
 
extern OS_TCB *pOSActiveTCBList;   // Linked list of activ TCB's
 
// One of the following two variables wsill go away....
extern volatile uint32_t nPrioOfCurTask;     // Current task priority number
extern volatile uint32_t nPrioOfHighReady;   // highest task ready to run
extern volatile OS_TCB *OSTCBCur;
extern volatile OS_TCB *OSTCBHighRdy;
 
extern OS_TCB *pOSTCBFreeList;   // List of unused TCB's
 
extern volatile uint32_t OSIntNesting;
extern volatile uint32_t OSLockNesting;
extern volatile uint32_t OSISRLevel32;
 
extern volatile bool OSRunning;
 
// So non-recompilable files can reference the right struct size
extern unsigned long OSTcbStructSize;
 
#ifdef NBRTOS_TASK_LOG
extern void (*pTaskLogger)(uint8_t nextPrio);
#endif
/*
Removed
   extern volatile BOOLEAN OSShowTasksOnLeds;
*/
 
/*
***********************************************************
*                 NBRTOS FUNCTION PROTOTYPES
***********************************************************
*/
void OSInit(uint8_t maxtasks);
void OSStart(void);
void OSCreateIdleTask();
 
uint8_t OSTaskCreatewName(void (*task)(void *dptr),   // Function to call
                          void *data,                 // Data to pass as a parameter
                          void *pstktop,              // Stack top
                          void *pstkbot,              // Stack bottom
                          uint8_t prio,               // current priority
                          const char *name,           // task name
                          OS_TCB **pRetHandle = NULL  // ReturnPointer to task handle
);
 
#define OSSimpleTaskCreatewName(x, p, n) \
    [&]() { \
        static uint32_t func_##x##_Stk[USER_TASK_STK_SIZE] __attribute__((aligned(4))); \
        return OSTaskCreatewName(x, NULL, (void *)&func_##x##_Stk[USER_TASK_STK_SIZE], (void *)func_##x##_Stk, p, n); \
    }()
 
#define OSSimpleTaskCreatewNameSRAM(x, p, n) \
    [&]() { \
        static uint32_t func_##x##_Stk[USER_TASK_STK_SIZE] __attribute__((aligned(4))) FAST_USER_STK; \
        return OSTaskCreatewName(x, NULL, (void *)&func_##x##_Stk[USER_TASK_STK_SIZE], (void *)func_##x##_Stk, p, n); \
    }()
 
 
/* Helper macro*/
#define LambdaTask2(p,n,f,vn) static uint32_t func_##vn_Stk[USER_TASK_STK_SIZE] __attribute__((aligned(4)));OSTaskCreatewName(f, NULL, (void *)&func_##vn_Stk[USER_TASK_STK_SIZE], (void *)func_##vn_Stk, p, n)
 
#define OSSimpleTaskCreateLambda(p,n,f) LambdaTask2(p,n,[]( void * pv)f,__COUNTER__)
 
 
void OSTimeWaitUntil(uint32_t systemTickValue);
 
inline void OSTimeDly(uint32_t to_count)
{
    uint32_t to_when = to_count + TimeTick;
    if (!to_when) to_when++;
    OSTimeWaitUntil(to_when);
};
 
// void OSIntEnter( void );
 
extern "C"
{
    void OSIntExit(void);
    void OSCtxSw(void);
    void OSTickISR(void);
    void OSStartHighRdy(void);
    void OSSetupVBR(void);
    void OSSched(void);
    void OSTimeTick(void);
 
    void OSTaskDelete(void);
}
 
OS_TCB *OSTCBGetFree(void);
 
uint8_t OSChangePrio(uint32_t newp);
 
void OSSetName(const char *cp);
 
void OSLock(void);
 
void OSUnlock(void);
 
[[deprecated]] inline uint8_t OSSemInit(OS_SEM *psem, long value)
{
    return (psem != nullptr) ? psem->Init(value) : OS_CRIT_ERR;
}
 
[[deprecated]] inline uint8_t OSSemPost(OS_SEM *psem)
{
    return psem->Post();
}
 
[[deprecated]] inline uint8_t OSSemPend(OS_SEM *psem, uint16_t timeout)
{
    return psem->Pend(timeout);
}
 
[[deprecated]] inline uint8_t OSSemPendNoWait(OS_SEM *psem)
{
    return psem->PendNoWait();
}
 
[[deprecated]] inline uint8_t OSMboxInit(OS_MBOX *pmbox, void *msg)
{
    return (pmbox != nullptr) ? pmbox->Init(msg) : OS_CRIT_ERR;
}
 
[[deprecated]] inline uint8_t OSMboxPost(OS_MBOX *pmbox, void *msg)
{
    return pmbox->Post(msg);
}
 
[[deprecated]] inline void *OSMboxPend(OS_MBOX *pmbox, uint16_t timeout, uint8_t *err)
{
    return pmbox->Pend(timeout, *err);
}
 
[[deprecated]] inline void *OSMboxPendNoWait(OS_MBOX *pmbox, uint8_t *err)
{
    return pmbox->PendNoWait(*err);
}
 
[[deprecated]] inline uint8_t OSQInit(OS_Q *pq, void **start, uint8_t size)
{
    return (pq != nullptr) ? pq->Init(start, size) : OS_CRIT_ERR;
}
 
[[deprecated]] inline uint8_t OSQPost(OS_Q *pq, void *msg)
{
    return pq->Post(msg);
}
 
[[deprecated]] inline uint8_t OSQPostFirst(OS_Q *pq, void *msg)
{
    return pq->PostFirst(msg);
}
 
[[deprecated]] inline uint8_t OSQPostUnique(OS_Q *pq, void *msg)
{
    return pq->PostUnique(msg);
}
 
[[deprecated]] inline uint8_t OSQPostUniqueFirst(OS_Q *pq, void *msg)
{
    return pq->PostUniqueFirst(msg);
}
 
[[deprecated]] inline void *OSQPend(OS_Q *pq, uint16_t timeout, uint8_t *err)
{
    return pq->Pend(timeout, *err);
}
 
[[deprecated]] inline void *OSQPendNoWait(OS_Q *pq, uint8_t *err)
{
    return pq->PendNoWait(*err);
}
 
[[deprecated]] inline uint8_t OSFifoInit(OS_FIFO *pFifo)
{
    return (pFifo != nullptr) ? pFifo->Init() : OS_CRIT_ERR;
}
 
[[deprecated]] inline uint8_t OSFifoPost(OS_FIFO *pFifo, OS_FIFO_EL *pToPost)
{
    return pFifo->Post(pToPost);
}
[[deprecated]] inline uint8_t OSFifoPostFirst(OS_FIFO *pFifo, OS_FIFO_EL *pToPost)
{
    return pFifo->PostFirst(pToPost);
};
 
[[deprecated]] inline OS_FIFO_EL *OSFifoPend(OS_FIFO *pFifo, uint16_t timeout)
{
    return pFifo->Pend(timeout);
};
 
[[deprecated]] inline OS_FIFO_EL *OSFifoPendNoWait(OS_FIFO *pFifo)
{
    return pFifo->PendNoWait();
    ;
}
 
[[deprecated]] inline uint8_t OSCritInit(OS_CRIT *pCrit)
{
    return pCrit->Init();
}
[[deprecated]] inline uint8_t OSCritLockAndEnter(OS_CRIT *pCrit, uint16_t timeout)
{
    return pCrit->LockAndEnter(timeout);
}
 
[[deprecated]] inline uint8_t OSCritEnter(OS_CRIT *pCrit, uint16_t timeout)
{
    return pCrit->Enter(timeout);
}
 
[[deprecated]] inline uint8_t OSCritEnterNoWait(OS_CRIT *pCrit)
{
    return pCrit->EnterNoWait();
}
 
[[deprecated]] inline uint8_t OSCritLeave(OS_CRIT *pCrit)
{
    return pCrit->Leave();
}
[[deprecated]] inline uint8_t OSCritLeaveAndUnlock(OS_CRIT *pCrit)
{
    return pCrit->LeaveAndUnlock();
}
 
uint8_t OSTaskID(void);
 
enum class OSNextPrio {
    Maximum  = -2, 
    Above    = -1, 
    Below    = 0, 
    Next     = Below, 
    Minimum  = 1 
};
 
int OSGetNextPrio(OSNextPrio where=OSNextPrio::Below, int startingPrio = -1);
 
const char *OSTaskName();
 
void OSChangeTaskWhen(uint16_t task_prio, uint32_t to_when);
 
inline void OSChangeTaskDly(uint16_t task_prio, uint32_t to_count)
{
    uint32_t to_when = to_count + TimeTick;
    if (!to_when) to_when++;
    OSChangeTaskWhen(task_prio, to_when);
}
 
OS_TCB * OSGetTaskBlock(uint16_t task_prio);
 
uint8_t OSTaskJoin(OS_TCB *pTask, uint32_t timeoutDly = 0);
 
void OSDumpStack(void);
 
#if (defined NBRTOS_STACKOVERFLOW) || (defined NBRTOS_STACKUNDERFLOW)
void EnableOSStackProtector();
extern "C" void OSStackProtectCtxSw();      // ASM task switcher
extern "C" void OSStackProtectIntCtxSw();   // ASM task switcher
extern "C" void OSStackProtector();         // extern because must be called from ASM
#endif
 
#ifdef NBRTOS_STACKCHECK
void OSDumpTCBStacks(void);
 
void OSDumpTasks(void);
 
void OSStartTaskDumper(uint8_t prio, uint32_t reportInterval);
#endif
 
#ifdef NBRTOS_TASKLIST
void ShowTaskList(void);
#endif
 
#ifdef NBRTOS_TIME
uint32_t GetCurrentTaskTime(uint32_t *const TotalTicks);
void ShowTaskTimes(void);
void ClearTaskTimes(void);
#endif
 
class OSLockObj
{
   public:
    OSLockObj() { OSLock(); };
 
    ~OSLockObj() { OSUnlock(); };
} __attribute__((packed));
 
class OSCriticalSectionObj
{
    OS_CRIT *pcrit;
 
   public:
    OSCriticalSectionObj(OS_CRIT &ocrit)
    {
        pcrit = &ocrit;
        ocrit.Enter(0);
    };
 
    OSCriticalSectionObj(OS_CRIT &ocrit, bool NoWait, TickTimeout &timeout)
    {
        pcrit = &ocrit;
        if (NoWait)
            ocrit.EnterNoWait();
        else
            ocrit.Enter(timeout);
    };
 
    ~OSCriticalSectionObj() { pcrit->Leave(); }
} __attribute__((packed));
 
class OSLockAndCritObj
{
    OS_CRIT *pcrit;
 
   public:
    OSLockAndCritObj(OS_CRIT &ocrit) : pcrit(&ocrit) { pcrit->LockAndEnter(0); }
 
    ~OSLockAndCritObj() { pcrit->LeaveAndUnlock(); }
};
 
class OSSpinCrit
{
    OS_CRIT *pcrit;
 
   public:
    OSSpinCrit(OS_CRIT &ocrit) : pcrit(&ocrit)
    {
        while (pcrit->EnterNoWait() == OS_TIMEOUT) {}
    }
 
    ~OSSpinCrit() { pcrit->Leave(); }
};
 
 
class USERCritObj
{
   public:
    USERCritObj() { USER_ENTER_CRITICAL(); }
    ~USERCritObj() { USER_EXIT_CRITICAL(); }
};
 
 
 
inline bool OS_CRIT::OwnedByCurTask()
{
    return OSCritOwnerTCB == OSTCBCur;
}
 
class NBRtosInitObj
{
    static NBRtosInitObj * pHead;
    static bool bAlreadInited;
    NBRtosInitObj *pNext;
 
    protected:
      inline bool WasInitDone() {return bAlreadInited; }
      NBRtosInitObj();
     ~NBRtosInitObj();
 
    public:
         virtual void Notify()=0;
         static void InitWholeSet();   //Used internally
};
 
 
#endif
 
 
 
 
  // groupNBRTOS