rtos.h

This project should serve as an "easy start" with embOS. All pathes are relative to the project fil

/*
    Handle DEFinition (storage is actually allocted) versus DEClaration
    (reference) of RTOS variables depending upon who includes this header file.
*/
#ifdef __OSGLOBAL_C__
  #define OS_EXTERN        /* Declare variables if included by RTOSKERN.C */
#else
  #define OS_EXTERN extern /* Define variables if included by anyone else */
#endif

/*** Start of memory pragma areas ***
 Some compilers can not deal with memory attributes and need pragmas
*/
#if defined(__ghs) && defined(__V850)
  #pragma ghs startzda
#endif

#if OS_COMPILER_STORAGE_MODIFIER_LEFT  /* default */
  OS_EXTERN OS_SADDR  volatile OS_I32 OS_Time;
  OS_EXTERN OS_SADDR  int             OS_TimeDex;
  OS_EXTERN OS_SADDR  union { int Dummy; struct { OS_U8 Region, DI; } Cnt; } OS_Counters;

  OS_EXTERN OS_SADDR  OS_U8  OS_IntMSInc;
  OS_EXTERN OS_SADDR  OS_U8  OS_TimeSlice;
  OS_EXTERN OS_SADDR  OS_U8  OS_TimeSliceAtStart;
  OS_EXTERN OS_SADDR  OS_U8  OS_Pending;
  OS_EXTERN OS_SADDR  volatile OS_U8  OS_Status;

  #if OS_SUPPORT_TICKSTEP
    OS_EXTERN OS_SADDR  volatile OS_U8   OS_TickStep;
    OS_EXTERN OS_SADDR  volatile int     OS_TickStepTime;
  #endif
  #ifdef __RTOS_ALLOWFRACT__
    OS_EXTERN OS_SADDR        OS_UINT OS_TicksPerMS;
    OS_EXTERN OS_SADDR        int     OS_IntTicksInc;
  #endif
  #if OS_PROFILE
    OS_EXTERN OS_SADDR OS_U32 OS_TS_ExecStart;
    OS_EXTERN OS_SADDR OS_U8  ProfilingOn;
  #endif
  #if OS_DEBUG
    OS_EXTERN OS_SADDR int  OS_TaskSwitchFromIntCnt;
    OS_EXTERN OS_SADDR OS_U8 OS_InInt;
    OS_EXTERN OS_SADDR OS_U8 OS_InTimer;
  #endif

  /*** Pointers ***
    Unfortunately there is no real standard on how to define/declare
    pointers properly with extended memory attributes. There are
    currently 2 different standards, which we both support.
  */
  #if OS_COMPILER_LOCATION_LEFT
    OS_EXTERN OS_SADDR  OS_TASK    * OS_pTask;             /* linked list of all Tasks */
    OS_EXTERN OS_SADDR  OS_TASK    * OS_pCurrentTask;      /* pointer to current Task */
    OS_EXTERN OS_SADDR  OS_TASK volatile * volatile OS_pActiveTask;
    OS_EXTERN OS_SADDR  OS_TIMER   * OS_pTimer;            /* linked list of all active Timers */
    OS_EXTERN OS_SADDR  OS_TIMER   * OS_pCurrentTimer;     /* Actual expired timer which called callback */
    #if OS_LINK_RESOURCE_SEMAS
      OS_EXTERN OS_SADDR OS_RSEMA  * OS_pRSema;
    #endif
    #if OS_DEBUG
      OS_EXTERN OS_SADDR OS_TASK   * OS_pTask2Debug;       /* linked list of all Tasks */
      OS_EXTERN OS_SADDR voidRoutine         * OS_pfOnTask2Debug;
      extern OS_CSEMA OS_CSEMAPTR* OS_pCSema;
    #endif
  #else
    OS_EXTERN OS_TASK             * OS_SADDR OS_pTask;          /* linked list of all Tasks */
    OS_EXTERN OS_TASK             * OS_SADDR OS_pCurrentTask;   /* pointer to current Task */
    OS_EXTERN OS_TASK    volatile * OS_SADDR volatile OS_pActiveTask;
    OS_EXTERN OS_TIMER            * OS_SADDR OS_pTimer;         /* linked list of all active Timers */
    OS_EXTERN OS_TIMER            * OS_SADDR OS_pCurrentTimer;  /* Actual expired timer which called callback */
    #if OS_LINK_RESOURCE_SEMAS
      OS_EXTERN OS_RSEMA          * OS_SADDR OS_pRSema;
    #endif
    #if OS_DEBUG
      OS_EXTERN OS_TASK           * OS_SADDR OS_pTask2Debug;    /* linked list of all Tasks */
      OS_EXTERN voidRoutine                 * OS_SADDR OS_pfOnTask2Debug;
      extern OS_CSEMA OS_CSEMAPTR* OS_pCSema;
    #endif
  #endif

#else  /*  OS_COMPILER_STORAGE_MODIFIER_LEFT == 0, needed for Keil  */
  OS_EXTERN volatile OS_I32 OS_SADDR OS_Time;
  OS_EXTERN int             OS_SADDR OS_TimeDex;
  OS_EXTERN union { int Dummy; struct { OS_U8 Region, DI; } Cnt; } OS_SADDR OS_Counters;

  OS_EXTERN OS_U8 OS_SADDR OS_IntMSInc;
  OS_EXTERN OS_U8 OS_SADDR OS_TimeSlice;
  OS_EXTERN OS_U8 OS_SADDR OS_TimeSliceAtStart;
  OS_EXTERN OS_U8 OS_SADDR OS_Pending;
  OS_EXTERN volatile OS_U8 OS_SADDR OS_Status;

  #if OS_SUPPORT_TICKSTEP
    OS_EXTERN volatile OS_U8 OS_SADDR OS_TickStep;
    OS_EXTERN volatile int   OS_SADDR OS_TickStepTime;
  #endif
  #ifdef __RTOS_ALLOWFRACT__
    OS_EXTERN OS_UINT OS_SADDR OS_TicksPerMS;
    OS_EXTERN int     OS_SADDR OS_IntTicksInc;
  #endif
  #if OS_PROFILE
    OS_EXTERN OS_U32 OS_SADDR OS_TS_ExecStart;
    OS_EXTERN OS_U8  OS_SADDR ProfilingOn;
  #endif
  #if OS_DEBUG
    OS_EXTERN int   OS_SADDR OS_TaskSwitchFromIntCnt;
    OS_EXTERN OS_U8 OS_SADDR OS_InInt;
    OS_EXTERN OS_U8 OS_SADDR OS_InTimer;
  #endif

  /*** Pointers ***
    Unfortunately there is no real standard on how to define/declare
    pointers properly with extended memory attributes. There are
    currently 2 different standards, which we both support.
  */
  #if OS_COMPILER_LOCATION_LEFT
    OS_EXTERN OS_SADDR  OS_TASK    * OS_pTask;             /* linked list of all Tasks */
    OS_EXTERN OS_SADDR  OS_TASK    * OS_pCurrentTask;      /* pointer to current Task */
    OS_EXTERN OS_SADDR  OS_TASK volatile * volatile OS_pActiveTask;
    OS_EXTERN OS_SADDR  OS_TIMER   * OS_pTimer;            /* linked list of all active Timers */
    OS_EXTERN OS_SADDR  OS_TIMER   * OS_pCurrentTimer;     /* Actual expired timer which called callback */
    #if OS_DEBUG
      OS_EXTERN OS_SADDR OS_RSEMA  * OS_pRSema;
      OS_EXTERN OS_SADDR OS_TASK   * OS_pTask2Debug;       /* linked list of all Tasks */
      OS_EXTERN OS_SADDR voidRoutine         * OS_pfOnTask2Debug;
      extern OS_CSEMA OS_CSEMAPTR* OS_pCSema;
    #endif
  #else
    OS_EXTERN OS_TASK             * OS_SADDR OS_pTask;        /* linked list of all Tasks */
    OS_EXTERN OS_TASK             * OS_SADDR OS_pCurrentTask; /* pointer to current Task */
    OS_EXTERN OS_TASK    volatile * volatile OS_SADDR OS_pActiveTask;
    OS_EXTERN OS_TIMER            * OS_SADDR OS_pTimer;       /* linked list of all active Timers */
    OS_EXTERN OS_TIMER            * OS_SADDR OS_pCurrentTimer;  /* Actual expired timer which called callback */
    #if OS_DEBUG
      OS_EXTERN OS_RSEMA          * OS_SADDR OS_pRSema;
      OS_EXTERN OS_TASK           * OS_SADDR OS_pTask2Debug;  /* linked list of all Tasks */
      OS_EXTERN voidRoutine                 * OS_SADDR OS_pfOnTask2Debug;
      extern OS_CSEMA OS_CSEMAPTR* OS_pCSema;
    #endif
  #endif

#endif  /*  OS_COMPILER_STORAGE_MODIFIER_LEFT  */

/*** End of memory pragma areas ****/
#if defined(__ghs) && defined(__V850)
  #pragma ghs endzda
#endif

#define OS_RegionCnt OS_Counters.Cnt.Region
#define OS_DICnt     OS_Counters.Cnt.DI

/*********************************************************************
*
*       Create_Task routine and macros (Module OsKern.c)
*
**********************************************************************
*/

#if OS_TRACKNAME
  #define CTPARA_NAME "unnamed task",
#else
  #define CTPARA_NAME
#endif

#if OS_RR_SUPPORTED
  #define CTPARA_TIMESLICE ,2
#else
  #define CTPARA_TIMESLICE 
#endif

/*
   This is the old form. For compatibility reasons it is
   still supported.
*/
#define CREATETASK(pTask, Hook, Priority, pStack) \
OS_CreateTask (pTask,           \
               CTPARA_NAME      \
               Priority,        \
               Hook,            \
               (void OS_STACKPTR*)pStack, \
               sizeof(pStack)   \
               CTPARA_TIMESLICE \
               )

#if OS_TRACKNAME
  #define OS_CREATETASK(pTask, Name, Hook, Priority, pStack) \
  OS_CreateTask (pTask,            \
                  Name,            \
                  Priority,        \
                  Hook,            \
                  (void OS_STACKPTR*)pStack, \
                  sizeof(pStack)   \
                  CTPARA_TIMESLICE \
               )
#else
  #define OS_CREATETASK(pTask, Name, Hook, Priority, pStack) \
  OS_CreateTask (pTask,            \
                  Priority,        \
                  Hook,            \
                  (void OS_STACKPTR*)pStack, \
                  sizeof(pStack)   \
                  CTPARA_TIMESLICE \
               )
#endif

void OS_CreateTask(
        OS_TASK * pTask,
#if OS_TRACKNAME
        const char*Name,
#endif
        OS_U8 Priority,
        voidRoutine*pRoutine,
        void OS_STACKPTR *pStack,
        OS_UINT StackSize
#if OS_RR_SUPPORTED
        ,OS_UINT TimeSlice
#endif
        );

/*********************************************************************
*
*       Task related routines
*
**********************************************************************
*/

void OS_Delay(int ms);                    /* OSKern.c     */
void OS_DelayUntil(int t);                /* OSKern.c     */
void OS_Terminate      (OS_TASK* pTask);  /* OSTerm.c     */
void OS_TerminateError (void);            /* OSTermE.c    */
void OS_WakeTask       (OS_TASK* pTask);  /* OSWake.c     */
void OS_GetState       (OS_TASK* pTask);
void OS_SetPriority    (OS_TASK* pTask, OS_U8 Prio); /* OSSetP.c */
char OS_IsTask         (OS_TASK* pTask);  /* OSIsTask.c   */
void OS_Suspend        (OS_TASK* pTask);  /* OS_Suspend.c */
void OS_Resume         (OS_TASK* pTask);  /* OS_Suspend.c */

/*********************************************************************
*
*       Info routines (OSInfo.c)
*
**********************************************************************
*/

const char* OS_GetCPU(void);
const char* OS_GetLibMode(void);
const char* OS_GetModel(void);
const char* OS_GetLibName(void);
#define OS_GetVersion() ((unsigned int)OS_VERSION)
#define OS_GetType() OS_GetLibMode()

#define OS_TASKID OS_TASK *
#define OS_GetTaskID() OS_pCurrentTask

#define OS_GetpCurrentTask()  OS_pCurrentTask
#define OS_GetpCurrentTimer() OS_pCurrentTimer

#if OS_TRACKNAME
  const char* OS_GetTaskName(OS_TASK *);
#else
  #define OS_GetTaskName(pt)  ((char*)NULL)
#endif

#if OS_CHECKSTACK
  void OS_CheckStack(void);              /* internal usage */
  int  OS_GetStackSpace(OS_TASK * pTask);
  int  OS_GetStackUsed (OS_TASK * pTask);
  int  OS_GetStackSize (OS_TASK OS_TCBPTR * pTask);
  void OS_STACKPTR* OS_GetStackBase(OS_TASK OS_TCBPTR *pTask);
#else
  #define OS_CheckStack()
  #define OS_GetStackSpace(pt) 0
  #define OS_GetStackUsed(pt)  0
  #define OS_GetStackSize(pt)  0
  #define OS_GetStackBase(pt)  0
#endif

OS_STACK_ADR OS_GetSysStackBase(void);  /* RTOS asm part */
unsigned int OS_GetSysStackSize(void);  /* RTOS asm part */
OS_STACK_ADR OS_GetIntStackBase(void);  /* RTOS asm part */
unsigned int OS_GetIntStackSize(void);  /* RTOS asm part */

#if OS_RR_SUPPORTED
  OS_U8 OS_SetTimeSlice(OS_TASK * pTask, OS_U8 TimeSlice);
  OS_U8 OS_GetTimeSliceRem(OS_TASK OS_TCBPTR * pTask);
  #define OS_GetTimeSliceReload(pTask)  pTask->TimeSliceReload
#else
  #define OS_GetTimeSliceRem(pTask)     0
  #define OS_GetTimeSliceReload(pTask)  0
#endif

OS_U8    OS_GetPriority(OS_TASK * pTask);  /* OS_GetPrio.c       */
#define OS_GET_PRIORITY(pt) pt->Priority 
                                                      /* OS_GetNumTasks.c   */
int   OS_GetNumTasks(void);
OS_TASK* OS_TaskIndex2Ptr(int TaskIndex);  /* OS_TaskIndex2Ptr.c */

#if OS_PROFILE >=1
  OS_U32 OS_STAT_GetExecTime_Cycles (OS_TASK *pTask);  /* OSStat.c   */
  int    OS_STAT_GetLoad            (OS_TASK *pTask);  /* OSStatGL.c */
  OS_U32 OS_STAT_GetNumActivations  (OS_TASK *pTask);  /* OSStat.c   */
  OS_U32 OS_STAT_GetNumPreemptions  (OS_TASK *pTask);  /* OSStat.c   */
  void   OS_STAT_NotifyReadyStart   (OS_TASK *pTask);  /* OSStat.c   */
  void   OS_STAT_Sample(void);                         /* OSStat.c   */
#else
  #define OS_STAT_NotifyExecEnd()
  #define OS_STAT_GetExecTime_Cycles(pTask)   0
  #define OS_STAT_GetLoad(pTask)              0
  #define OS_STAT_GetNumActivations(pTask)    0
  #define OS_STAT_GetNumPreemptions(pTask)    0
  #define OS_STAT_Sample()
  #define OS_STAT_SetClocksPerUnit(ClocksPerUnit)
  #define OS_STAT_NOTIFYREADYSTART(pTask)
#endif

#if OS_PROFILE >=2
  #define OS_STAT_NOTIFYREADYSTART(pTask) OS_STAT_NotifyReadyStart(pTask)
#else
  #define OS_STAT_NOTIFYREADYSTART(pTask)
#endif

/*********************************************************************
*
*       Critical regions (OsKern.c)
*
**********************************************************************
*/

#define OS_EnterRegion() {OS_RegionCnt++; }
void OS_LeaveRegion(void);

/* Macro for OS_Leaveregion.
   Main purposes:
   - Used in OS-Kernel
   - Offers the high speed variant (macro) instead of the function call
*/

#define OS_LEAVEREGION_STD() \
 OS_DI(); \
 if (!--OS_RegionCnt) { \
   if (OS_Pending) OS_Switch(); \
  } OS_RestoreI();

#if OS_DEBUG
 #define OS_LEAVEREGION() \
   if (!OS_RegionCnt) OS_Error(OS_ERR_LEAVEREGION_BEFORE_ENTERREGION); \
   OS_LEAVEREGION_STD()
#else
 #define OS_LEAVEREGION()  OS_LEAVEREGION_STD()
#endif

/*********************************************************************
*
*       Interrupt save/disable/restore macros
*
**********************************************************************
*/
#define OS_IncDI()       { OS_ASSERT_DICnt(); OS_DI(); OS_DICnt++; }
#define OS_DecRI()       { OS_ASSERT_DICnt(); if (--OS_DICnt==0) OS_EI(); }
#define OS_RestoreI()    { OS_ASSERT_DICnt(); if (OS_DICnt==0)   OS_EI(); }

/*********************************************************************
*
*       ISR (Interrupt service routine) support
*
**********************************************************************
*/

#define RTOS_PPENDING           (1)     /*      Preemption  pending */
#define RTOS_TSPENDING          (2)     /*      Task switch pending */
#define RTOS_RRPENDING          (4)     /*      Round robin pending */


#ifndef OS_PREPARE_SWITCH_FROM_INT
  #define OS_PREPARE_SWITCH_FROM_INT()
#endif

#if OS_DEBUG
  #define OS_MARK_IN_ISR()         {OS_InInt++;}
  #define OS_MARK_OUTOF_ISR()      {if (!OS_InInt--) OS_Error(OS_ERR_LEAVEINT);}
#else
  #define OS_MARK_IN_ISR()
  #define OS_MARK_OUTOF_ISR()
#endif

#ifndef OS_EnterInterrupt   /* Allow override in OSChip.h */
  #define OS_EnterInterrupt() { \
    OS_MARK_IN_ISR(); \
    OS_RegionCnt++; \
    OS_DICnt++; \
  }
#endif

#ifndef OS_EnterNestableInterrupt   /* Allow override in OSChip.h */
  #define OS_EnterNestableInterrupt() { \
    OS_MARK_IN_ISR();  \
    OS_RegionCnt++; \
    OS_EI(); \
  }
#endif

#ifndef OS_LeaveInterrupt   /* Allow override in OSChip.h */
  #define OS_LeaveInterrupt() { \
    OS_MARK_OUTOF_ISR(); \
    OS_DICnt--; /* Must have been zero initially ! (We could put =0 instead) */\
    if (OS_RegionCnt==1) { \
      if (OS_Pending) { \
        OS_PREPARE_SWITCH_FROM_INT(); \
        OS_SwitchFromInt(); \
      } \
    } \
    OS_RegionCnt--; \
  }
#endif

#ifndef OS_LeaveNestableInterrupt   /* Allow override in OSChip.h */
  #define OS_LeaveNestableInterrupt() { \
    OS_DI();                \
    OS_MARK_OUTOF_ISR();    \
    if (OS_RegionCnt==1) {  \
      if (OS_Pending) {     \
        OS_PREPARE_SWITCH_FROM_INT(); \