R_RTOS_inc.h

Go to the documentation of this file.

#ifndef HEADERS_R_RTOS_INC_H_
#define HEADERS_R_RTOS_INC_H_

/*
 * ##################################################
 * INCLUDES
 * ##################################################
 */

#include <stdint.h>
#include "R_RTOS_UsrDevs.h"

/*
 * ##################################################
 * END INCLUDES
 * ##################################################
 */

/*
 * ##################################################
 * DEFINES
 * ##################################################
 */

/* HELPER */
#undef NULL

#define NULL ((void *)0x0u)

#define ABS(x)  (((x)<0) ? (-1*(x)) : (x))

#define OFFSETOF(type, field)    ((uint8_t) &(((type *) 0)->field))
/* END HELPER */

#define MAX_TASKS           NR_OF_TSKS

/* STACK */
#define MIN_STACK_SIZE  ((StackSize)0x40u) // 64 Byte

#define MY_STACK_SIZE       ((StackSize)0x80u)  // 128 byte ??

#define IDLE_TSK_STACK_SIZE ((StackSize)0x60u)  // 96 byte

#define STACK_BLOCK_SIZE    ((uint8_t)0x4u)  // 4 byte blocksize

/* END STACK */

/* MESSAGE QUEUE */

#define MSGQ_TSK_ID_POS (uint8_t)0x0u

#define MSGQ_SYS_ID_POS (uint8_t)0x1u

#define SYS_ID_MSK  (uint16_t)0xFF00u

#define TSK_ID_MSK  (uint16_t)0x00FFu

/* END MESSAGE QUEUE */

/* SEMAPHORES */

/* END SEMAPHORES */

/* EVENTS */

/* END EVENTS */

/* SYSTICKTMR */

/* END SYSTICKTMR */

/* TIMER */

/* END TIMER */

/* TASK */
#define TSK_ID_IDLE                         ((TskID)0x0u)

#define TSK_ID_NO_TSK                       TSK_ID_IDLE//((TskID)0xfu)


/* END TASK */

/* FKT */
#define AMOUNT_SYS_FKT (uint8_t)0x8u

#define SYSFKT_INVALID_SYSFKT_ID (SysFktID)0xFFu
/* END FKT */

/* SYNC */

/* END SYNC */
/*
 * ##################################################
 * END DEFINES
 * ##################################################
 */

/*
 * ##################################################
 * MAKROS
 * ##################################################
 */
/* HELPER */
/* END HELPER */
/* STACK */
/* END STACK */

/* MESSAGE QUEUE */
//ToDO
#define DATATYPE_IS_PTR( dataType )     (uint8_t)( dataType & (uint8_t)0x4u)

#define MAKE_SYS_ID( id )   (uint16_t)((uint16_t)((uint8_t)id & (uint8_t)0xFFu) << (uint8_t)0x8u)

#define MAKE_TSK_ID( id )   (uint16_t)(uint16_t)((uint8_t)id & (uint8_t)0xFFu)

#define MQ_IS_TSK_ID( id )  (uint8_t)((uint16_t)id & (uint16_t)0xFFu)

/* END MESSAGE QUEUE */

/* SEMAPHORES */

/* END SEMAPHORES */

/* EVENTS */
#define CREATE_EVT_MSK(evtNr)   (EVTQSlots)((EVTQSlots)0x1u << evtNr)

/* END EVENTS */

/* TIMER */

/* END TIMER */

/* TASK */
#define TSK_GETSTATE(pTsk) (TskState)(pTsk->tskState)

#define TSK_STATE_IS_ERROR(pTsk) (TskState)(TSK_GETSTATE(pTsk) == TSK_STATE_ERROR)

#define TSK_STATE_IS_ACTIVE(pTsk) (TskState)(TSK_GETSTATE(pTsk) & TSK_STATE_ACTIVE)

#define TSK_STATE_IS_ACTIVE_RUNNING(pTsk) (TskState)(TSK_GETSTATE(pTsk) == TSK_STATE_ACTIVE_RUNNING )

#define TSK_STATE_IS_ACTIVE_SUSPENDED(pTsk) (TskState)(TSK_GETSTATE(pTsk) == TSK_STATE_ACTIVE_SUSPENDED )

#define TSK_STATE_IS_ACTIVE_READY(pTsk) (TskState)(TSK_GETSTATE(pTsk) == TSK_STATE_ACTIVE_READY )

#define TSK_STATE_IS_ACTIVE_CRITSEC(pTsk) (TskState)(TSK_GETSTATE(pTsk) == TSK_STATE_ACTIVE_CRITSEC )

#define TSK_STATE_IS_WAITING(pTsk) (TskState)(TSK_GETSTATE(pTsk) & TSK_STATE_WAITING)

#define TSK_STATE_IS_WAITING_TMR(pTsk) (TskState)(TSK_GETSTATE(pTsk) == TSK_STATE_WAITING_TMR)

#define TSK_STATE_IS_WAITING_MSGRCV(pTsk) (TskState)(TSK_GETSTATE(pTsk) == TSK_STATE_WAITING_MSGRCV)

#define TSK_STATE_IS_WAITING_MSGSND(pTsk) (TskState)(TSK_GETSTATE(pTsk) == TSK_STATE_WAITING_MSGSND)

#define TSK_STATE_IS_WAITING_EVT(pTsk) (TskState)(TSK_GETSTATE(pTsk) == TSK_STATE_WAITING_EVT)

#define TSK_STATE_IS_WAITING_SEM(pTsk) (TskState)(TSK_GETSTATE(pTsk) == TSK_STATE_WAITING_SEM)

#define TSK_STATE_IS_WAITING_MNTR(pTsk) (TskState)(TSK_GETSTATE(pTsk) == TSK_STATE_WAITING_MNTR)

#define TSK_STATE_IS_UNINIT(pTsk) (TskState)(TSK_GETSTATE(pTsk) & TSK_STATE_UNINIT)

#define TSK_STATE_IS_UNINIT_UNINIT(pTsk) (TskState)(TSK_GETSTATE(pTsk) == TSK_STATE_UNINIT_UNINIT)

#define TSK_STATE_IS_UNINIT_FAILED(pTsk) (TskState)(TSK_GETSTATE(pTsk) == TSK_STATE_UNINIT_FAILED)

#define TSK_STATE_IS_UNINIT_ENDED(pTsk) (TskState)(TSK_GETSTATE(pTsk) == TSK_STATE_UNINIT_ENDED)

/* END TASK */

/* FKT */

/* END FKT */

/* SYNC */

/* END SYNC */
/*
 * ##################################################
 * END MAKROS
 * ##################################################
 */

/*
 * ##################################################
 * TYPEDEFS
 * ##################################################
 */
/*
 * ##################################################
 * SIMPLE TYPES
 * ##################################################
 */
/* FKT */

typedef void (*FktCall)( void );

typedef void (*FktCallOneArg)( void * );

typedef uint8_t SysFktID;
/* END FKT */
/* STACK */
typedef uint16_t StackSize;

typedef uint32_t StackTypeT;

typedef StackTypeT *StackPtrT;
/* END STACK */

/* MESSAGE QUEUE */
typedef uint8_t DataSize;    // Size of Data

typedef uint32_t *Data;         // pointer to Data

typedef uint8_t QPrio;      // priority of a message queue

typedef void (*CallBackOnDataRecv)( Data );

typedef uint8_t QID;        // identifier for a message queue

typedef uint8_t MsgCntr;

typedef union partID
{
    uint16_t fullID;        
    uint8_t snglID[2];      
} PartID;
/* END MESSAGE QUEUE */

/* SEMAPHORES */
typedef uint8_t SemNr;


typedef uint8_t SemCntr;
/* END SEMAPHORES */

/* MUTEXES */
typedef uint8_t MtxNr;
/* END MUTEXES */

/* MNTRS */
typedef uint8_t MntrNr;
/* END MNTRS */

/* EVENTS */
typedef uint8_t EvtNr;

typedef uint32_t EvtMsk;
typedef uint32_t EVTQSlots;
/* END EVENTS */

/* TIMER */
typedef uint16_t WaitTime;

typedef uint32_t SysTime;

typedef uint8_t SysTicks;

typedef uint16_t TmrTime;

typedef uint32_t LifeTime;
/* END TIMER */

/* TASK */
typedef uint8_t TskID;

//MAX 8 BITs
typedef uint8_t TskPrioLvl;

typedef uint8_t tskStateT;

typedef FktCall TskStartAddr;

typedef FktCall TskEndAddr;
/* END TASK */

/* SYNC */
typedef uint8_t SyncEleID;
/* END SYNC */
/*
 * ##################################################
 * END SIMPLE TYPES
 * ##################################################
 */
/*
 * ##################################################
 * TYPES
 * ##################################################
 */
/* STACK */
/* END STACK */

/* MESSAGE QUEUE */

/* END MESSAGE QUEUE */

/* SEMAPHORES */

/* END SEMAPHORES */

/* EVENTS */

/* END EVENTS */

/* TIMER */

/* END TIMER */

/* TASK */

/* END TASK */

/* FKT */

/* END FKT */

/* SYNC */

/* END SYNC */
/*
 * ##################################################
 * END TYPES
 * ##################################################
 */

/*
 * ##################################################
 * ENUM TYPES
 * ##################################################
 */
/* STACK */
/* END STACK */

/* MNTR */
typedef enum mntrAccssType
{
    MNTR_ACCESS_NONE = (uint8_t) 0x0u,    
    MNTR_ACCESS_READ = (uint8_t) 0x1u,    
    MNTR_ACCESS_WRITE = (uint8_t) 0x2u,    
    MNTR_ACCESS_DELETE = (uint8_t) 0x4u,    
    MNTR_ACCESS_MODIFY = (uint8_t) 0x8u    
} ACCSSType;
/* END MNTR */

/* MESSAGE QUEUE */
typedef enum dataTypes
{
    DataT_Undef = (uint8_t) 0x0u,    
    DataT_Int = (uint8_t) 0x1u,    
    DataT_Ptr = (uint8_t) 0x4u,    
    DataT_Int_Ptr,                
    DataT_String,                 
    DataT_FunCall = (uint8_t) 0x8u                 
} DataType;
/* END MESSAGE QUEUE */

/* SEMAPHORES */
/* END SEMAPHORES */

/* EVENTS */
/* END EVENTS */

/* TIMER */
typedef enum timerTypeEn
{
    SysTimerType = (uint8_t) 0x0u,    
    TskTimerType = (uint8_t) 0x1u,    
    SysTickTimerType = (uint8_t) 0x2u    
} TimerType;
/* END TIMER */

/* TASK */
typedef enum tskPrio
{
    TSK_PRIO_ERROR = (TskPrioLvl) 0x0u,    
    TSK_PRIO_LOWEST = (TskPrioLvl) 0x1u,    
    TSK_PRIO_LOWER,                 
    TSK_PRIO_LOW,                   
    TSK_PRIO_MED,                   
    TSK_PRIO_ABOVMED,               
    TSK_PRIO_HIG,                   
    TSK_PRIO_HIGHER,                
    TSK_PRIO_HIGHEST,               
    TSK_PRIO_ULT,                   
    TSK_PRIO_IDLE = (TskPrioLvl) 0xFu    
} TskPrio;


typedef enum tskState
{
    TSK_STATE_ERROR = (tskStateT) 0x00u,     
    TSK_STATE_ACTIVE = ( (tskStateT) 0x10u ),     
    TSK_STATE_ACTIVE_RUNNING = ( (tskStateT) 0x11u ),    
    TSK_STATE_ACTIVE_SUSPENDED = ( (tskStateT) 0x12u ),    
    TSK_STATE_ACTIVE_READY = ( (tskStateT) 0x14u ),    
    TSK_STATE_ACTIVE_CRITSEC = ( (tskStateT) 0x18u ),    
    TSK_STATE_WAITING_MSGNG = (tskStateT) 0x20u,    
    TSK_STATE_WAITING_MSGRCV = (tskStateT) 0x21u,    
    TSK_STATE_WAITING_MSGSND = (tskStateT) 0x22u,    
    TSK_STATE_WAITING_SYNC = (tskStateT) 0x40u,    
    TSK_STATE_WAITING_TMR = (tskStateT) 0x41u,    
    TSK_STATE_WAITING_EVT = (tskStateT) 0x42u,    
    TSK_STATE_WAITING_SEM_BIN = (tskStateT) 0x43u,    
    TSK_STATE_WAITING_SEM_CNT = (tskStateT) 0x44u,    
    TSK_STATE_WAITING_MTX = (tskStateT) 0x45u,    
    TSK_STATE_WAITING_MNTR = (tskStateT) 0x46u,    
    TSK_STATE_WAITING = (tskStateT) 0x60u,    
    TSK_STATE_UNINIT = (tskStateT) 0x80u,    
    TSK_STATE_UNINIT_UNINIT = (tskStateT) 0x81u,    
    TSK_STATE_UNINIT_FAILED = (tskStateT) 0x82u,    
    TSK_STATE_UNINIT_ENDED = (tskStateT) 0x88u,    
} TskState;

typedef enum tskSettings
{
    TskSet_NONE = (uint8_t) 0x00u,    
    TskSet_Periodic = (uint8_t) 0x01u,    
    TskSet_OneShot = (uint8_t) 0x02u,    
    TskSet_DUMMY_0 = (uint8_t) 0x04u,    
    TskSet_DUMMY_1 = (uint8_t) 0x08u,    
    TskSet_DUMMY_2 = (uint8_t) 0x10u,    
    TskSet_DUMMY_3 = (uint8_t) 0x20u,    
    TskSet_DUMMY_4 = (uint8_t) 0x40u,    
    TskSet_DUMMY_5 = (uint8_t) 0x80u    
} TskSettings;
typedef enum evtType
{
    EvtTMR = (uint8_t) 0x21u,    
    EvtMSGRCV = (uint8_t) 0x22u,    
    EvtMSGSND = (uint8_t) 0x24u,    
    EvtEVT = (uint8_t) 0x41u,    
    EvtSEM = (uint8_t) 0x42u,    
    EvtMNTR = (uint8_t) 0x48u    
} EvtType;
/* END TASK */

/* FKT */
/* END FKT */

/* SYNC */
typedef enum syncEleType
{
    SyncEle_TYPE_NOID = (uint8_t) 0x0u,    
    SyncEle_TYPE_TMR = (uint8_t) 0x1u,    
    SyncEle_TYPE_EVT = (uint8_t) 0x2u,    
    SyncEle_TYPE_SEM = (uint8_t) 0x3u,    //FALLBACK
    SyncEle_TYPE_BinSEM = (uint8_t) 0x3u,    
    SyncEle_TYPE_CntSEM = (uint8_t) 0x4u,    
    SyncEle_TYPE_MTX = (uint8_t) 0x5u,    
    SyncEle_TYPE_MNTR = (uint8_t) 0x6u    
} SyncEleType;
/* END SYNC */
/*
 * ##################################################
 * END ENUM TYPES
 * ##################################################
 */

/*
 * ##################################################
 * STRUCT TYPES
 * ##################################################
 */
/* STACK */
/* END STACK */

/* SYSTICKTMR */
typedef enum sysTckObjTypeEnum
{
    SysTckObj_Err = (uint8_t) 0x0u,    
    SysTckObj_Tsk = (uint8_t) 0x10u,    
    SysTckObj_TskBlck = (uint8_t) 0x11u,    
    SysTckObj_TskWait = (uint8_t) 0x12u,    
    SysTckObj_SysFkt = (uint8_t) 0x20u,    
    SysTckObj_SysFktBlck = (uint8_t) 0x21u,    
    SysTckObj_SysFktWait = (uint8_t) 0x22u,    
} SysTckEleType;

typedef union sysTickEleIDUnion
{
    TskID tskID;
    SysFktID sysFktID;
} SysTickEleID;

typedef struct sysTickTMRStruc
{
    struct sysTickTMRStruc * nxtSysTickTMR;    
    struct sysTickTMRStruc * prvSysTickTMR;    
    SysTckEleType sysTckObjType;    
    SysTickEleID sysTckObjID;    
    SysTicks remSysTicks;    
    SysTicks insrtnSysTicksTime;    
} SysTickTMR, *PSysTickTMR;
/* END SYSTICKTMR */

/* MESSAGE QUEUE */
typedef const uint32_t * CData;

typedef CData *PCData;

typedef struct mqData
{
    CData data;    
    PartID pubID;                  
    DataType dataType;              
    DataSize dataSize;               
} MQData, *PMQData;

typedef struct msgQMsgProvStruc
{
    QID msgQID;    
    volatile MsgCntr msgsNew;    
} MsgQMsgProv, *PMsgQMsgProv;

typedef uint8_t MsgID;

typedef struct tskMsgProvStruc
{
    volatile TskID tskProvID;    
    volatile MsgID msgID;    
} TskMsgProv, *PTskMsgProv;

typedef struct sysMsgProvStruc
{
    volatile SysFktID sysProvID;    
    volatile MsgID msgID;    
} SysMsgProv, *PSysMsgProv;

typedef struct dummyMsgProvStruc
{
    uint8_t dummyID;
    uint8_t dummyDummy;
} DummyMsgProv, *PDummyMsgProv;

typedef enum msgProvTypeEnum
{
    MsgQ_Prov = (uint8_t) 0x0u,    
    Tsk_Prov = (uint8_t) 0x1u,    
    Sys_Prov = (uint8_t) 0x2u,    
    Dummy_Prov = (uint8_t) 0xFFu    
} MsgProvType;

typedef union msgPrvdrsUnion
{
    MsgQMsgProv msgQMsgProv;    
    TskMsgProv tskMsgProv;    
    SysMsgProv sysMsgProv;     
    DummyMsgProv dummyMsgProv;    
} MsgPrvdrs, *PMsgPrvdrs;
typedef struct tskMailBox
{
    /*4*/volatile struct tskMailBox *nxtTskMB;    
//    volatile uint16_t msgMntnr;    //!< flags to keep track of which messages have been read and which haven't been read yet
//    MsgCntr msgsNew;          //!< amount of new messages since the subscription
    /*2*/MsgPrvdrs msgProv;          
    /*1*/MsgProvType msgProvType;    
    uint8_t dummyByte;
} TskMB, *PTskMB;
/* END MESSAGE QUEUE */
/* FKT */

typedef struct tmrFktCallStruc
{
    FktCall sysFktCall;   
    LifeTime expirationTime;    
    TmrTime reloadTime;    
    SysFktID nxtFktCall;    
    SysFktID fktID;       
} TmrFktCall, *PTmrFktCall;

typedef struct sysTckFktCallstruc
{
    FktCall sysFktCall;
    volatile PSysTickTMR sysTckTmr;    
    SysTicks reloadTime;
    uint8_t dummy8;
    uint16_t dummy16;
} SysTckFktCall, *PSysTckFktCall;

typedef struct msgFktCallStruc
{
    FktCallOneArg sysFktCall;    
    MsgPrvdrs msgProv;    
    MsgProvType msgProvType;    
} MsgFktCall, *PMsgFktCall;

typedef struct dummyFktCallStruc
{
    void * sysFktCall;/*4*/
    uint32_t dummy32;/*4*/
    uint16_t dummy16;/*2*/
    uint8_t dummy8_1;/*1*/
    uint8_t dummy8_2;/*1*/
} DummyFktCall, *PDummyFktCall;

typedef struct sysFkt
{
    //ToDO think about how to specify the type of the sysFkt... mind the memory usage, since the array is preallocated
    union fktCallTypeUnion
    {
        TmrFktCall tmrFktCall;    
        SysTckFktCall sysTckFktCall;    
        MsgFktCall msgFktCall;    
        DummyFktCall dummyfktCall; 
    } fktCallType;
} SysFkt, *PSysFkt;

/* END FKT */
/* SEMAPHORES */

typedef enum semTypeEnum
{
    SemBin = (uint8_t) 0x0u, 
    SemCnt = (uint8_t) 0x1u  
} SemType;

#define SEM_NR_OF_TSK_REF_BYTES (uint8_t)((NR_OF_TSKS >> 3) + 1) // NR_OF_TSKS / 8 + 1 gives the number of bits needed for all tasks

typedef struct semStruc
{
    uint8_t tskReferences[SEM_NR_OF_TSK_REF_BYTES]; 
    //TskID semQStrtTskID;        //!< TskID of the first task in the waiting queue
    TskPrio prioInheritPrio;    
    SemType semType;    
    SemCntr maxCntrVal; 

    union semSignalUnion
    {
        SemCntr semCntrSig;     
        SemCntr semBinSig;      
    } semSignal;
} Sem, *PSem;
/* END SEMAPHORES */

/* MUTEXES */
typedef struct mtxStruc
{
    TskID mtxQStrtTskID;    
    TskID mtxOccTskID;    
} Mtx, *PMtx;
/* END MUTEXES */

/* EVENTS */
typedef struct evtStruc
{
    EVTQSlots evtQ_Slots;    
    TskID evtObjs[EVT_QUEUE_SIZE ];    
} Evt, *PEvt;
/* END EVENTS */

/* TIMER */
typedef struct sysTimerStruc
{
    SysFktID sysFktIDQStrt;    
} SysTimer, *PSysTimer;

typedef struct tskTimerStruc
{
    TskID tskIDQStrt;               
} TskTimer, *PTskTimer;

typedef struct timerStruc
{
    LifeTime expirationTime;    
    TimerType timerType;        

    union specTimerUnion
    {
        SysTimer sysTimer; 
        TskTimer tskTimer; 
    } specTimer;
} Timer, *PTimer;
/* END TIMER */

/* SYNC */
typedef struct syncEleStruc
{
    SyncEleType syncEleType;    
    SyncEleID syncEleID;    
    //SysTicks maxBlckTime;    //!< maximum remaining blocking time in SysTicks

    union multipurposeByte
    {
        ACCSSType mntrAccssType;    
        uint8_t someDummy;
    } MultiPurposeByte;    

    union syncEleHandle
    {
        //EVENT
        struct evtSyncEle
        {
            EvtMsk evtMsk;    
        } EvtSyncEle;
        //TIMER
        struct tmrSyncEle
        {
            LifeTime expireTime;    
        } TmrSyncEle;
        //SEMAPHORE
        struct semSyncEle
        {
            uint8_t dummy1;
            uint8_t dummy2;
            uint8_t dummy3;
            uint8_t dummy4;
        } SemSyncEle;
        //Mutex
        struct mtxSyncEle
        {
            uint8_t dummy1;
            uint8_t dummy2;
            uint8_t dummy3;
            uint8_t dummy4;
        } MtxSyncEle;
        //MONITOR
        struct mntrSyncEle
        {
            ACCSSType mntrAccssType;    

        } MntrSyncEle;
    } SyncEleHandle;    
} SyncEle, *PSyncEle;
/* END SYNC */

typedef struct advTskPrio_struc
{
    volatile TskPrio actualTskPrio; 
    volatile TskPrio visibleTskPrio; 
} AdvTskPrio;

/* TASK */
typedef struct tskTCB
{
    /*STCK*//*4*/volatile StackPtrT pStckPtr;    
    /*STCK*//*4*/StackPtrT pStckTop;            

    /*STAT*//*4*/TskStartAddr pTskStrt;    
    /*STAT*//*4*/TskEndAddr pTskEnd;    

    /*MSGG*//*4*/volatile PTskMB tskMailBox;     

    /*SYNC*//*4*/volatile PSysTickTMR sysTckTmr;    
    /*SYNC*//*4*/volatile PSyncEle tskSync;    

    /*STCK*//*2*/StackSize stckSze;        

    // /*STAT*//*1*/volatile TskSettings tskSets; //!< Settings for the task

    /*SCHD*//*1*/AdvTskPrio tskPrio;    
    /*STAT*//*1*/volatile TskState tskState;     

    /*SCHD*//*1*/TskID tskID;                    
    /*SCHD*//*1*/volatile TskID nxtTsk;    
    /*SCHD*//*1*/volatile TskID prvTsk;    
} TskTCB, *PTskTCB;/*36*/

/* END TASK */

/*
 * ##################################################
 * END STRUCT TYPES
 * ##################################################
 */
/*
 * ##################################################
 * END TYPEDEFS
 * ##################################################
 */

/* STACK */
/* END STACK */

/* MESSAGE QUEUE */

/* END MESSAGE QUEUE */

/* SEMAPHORES */

/* END SEMAPHORES */

/* EVENTS */

/* END EVENTS */

/* TIMER */

/* END TIMER */

/* TASK */

/* END TASK */

/* FKT */

/* END FKT */

/* SYNC */

/* END SYNC */

//SYSCTRL
#define NR_OF_MEMPOOLS (uint8_t)0x7u

//SYSCTRL

typedef uint8_t OsCode;
#define OS_FULL_DISPATCH                   ((OsCode)0x2u)

#define OS_DISPATCH_NEEDED                 ((OsCode)0x1u)

typedef uint8_t RetCode;
#define RET_NOK                            ((RetCode)0x0u)

#define RET_OK                             ((RetCode)0x1u)

#define RET_MEM_ALLOC_FAIL_TCB             ((RetCode)0x1Au)

#define RET_MEM_ALLOC_FAIL_STACK           ((RetCode)0x1Cu)

#define RET_TSK_TOO_MANY                   ((RetCode)0x2Fu)

#define RET_TSK_NO_IDLE_TSK                ((RetCode)0x20u)

#define RET_TSK_CONFLICTING_IDLE_TSK       ((RetCode)0x21u)

#define RET_TSK_STILL_RUNNING              ((RetCode)0x24u)

#define RET_TSK_IS_ABOUT_TO_RUN            ((RetCode)0x25u)

#define RET_STCK_ERR_FULL                  ((RetCode)0x3Fu)

#define RET_STCK_ERR_EMPTY                 ((RetCode)0x30u)

#define RET_STCK_ERR_INDEX_OVERFLOW        ((RetCode)0x31u)

#define RET_STCK_ERR_INDEX_UNDERFLOW       ((RetCode)0x32u)

#define RET_STCK_NO_STCKELEM_PTR           ((RetCode)0x33u)

#define RET_STCK_NO_STCKPTR                ((RetCode)0x34u)

/* MEMORY_MANAGEMENT */
typedef uint16_t MemSize;

/* END MEMORY_MANAGEMENT */

/* SCHEDULER */
typedef struct gStruc_OS_FLAGS
{
    volatile uint8_t g_DispatchFlag :2;    
    volatile uint8_t g_needsScheduling :1;    
    volatile uint8_t g_tskCriticalExecution :1;    
    volatile uint8_t gLPExit :1;    
    volatile uint8_t gWokenUp :1;    
} BitsOSFlags;

/* END SCHEDULER */

/* SVC */
typedef enum svcCode
{
    SVC_OS_START = (uint8_t) 0x0u,      
    SVC_TSK_INIT,                       
    SVC_TSK_SETPRIO,                    
    SVC_TSK_ACTV,                       
    SVC_TSK_KILL,                       
    SVC_TSK_SET_CRIT,                   
    SVC_TSK_RESET_CRIT,                 
    SVC_MTX_TAKE,                       
    SVC_MTX_GIVE,                       
    SVC_SEM_WAIT,                       
    SVC_SEM_SIGNAL,                     
    SVC_MNTR_INIT_MNTR,                 
    SVC_MNTR_REQ_READ_ACC,              
    SVC_MNTR_REQ_WRITE_ACC,             
    SVC_MNTR_REL_ACC,                   
    SVC_EVT_SEND,                       
    SVC_EVT_RECV,                       
    SVC_TMR_SET,                        
    SVC_SYSTCK_SET,                     
    SVC_MSGQ_CRT_Q,                     
    SVC_MSGQ_DEL_Q,                     
    SVC_MSGQ_REG_PUB,                   
    SVC_MSGQ_REG_TSK_SUB,               
    SVC_MSGQ_REG_SYS_SUB,               
    SVC_MSGQ_MSG_PUB,                   
    SVC_MSGQ_MSG_READ,                  
    SVC_MSGQ_MSG_READALLNEW,            
    SVC_MSGQ_MSG_READALL,               
    SVC_MSGQ_MSG_TAKE,                  
    SVC_MSGQ_MSG_TAKEALLNEW,            
    SVC_MSGQ_MSG_TAKEALL,               
    SVC_OS_SCHEDULE,                    
    SVC_CALL_FKT_PRIV,                  
    SVC_LP_ENTER,                       
    SVC_TRC_OUPUT,                      
    SVC_OS_ERROR = (uint8_t) 0xFFu,     
} SVCCode;

/* END SVC */
#endif /* HEADERS_R_RTOS_INC_H_ */