rtos.h

这是一个富士通单片机调试软件

  OS_EXTERN OS_TIMER   OS_DEFPTR          * OS_SADDR OS_pTimer;       /* linked list of all active Timers */
  OS_EXTERN OS_RSEMA   OS_DEFPTR          * OS_SADDR OS_pRSema;
  OS_EXTERN OS_MAILBOX OS_DEFPTR          * OS_SADDR OS_pMB;
  #if OS_DEBUG
    OS_EXTERN OS_TASK     OS_DEFPTR * OS_SADDR OS_pTask2Debug;                /* linked list of all Tasks */
    OS_EXTERN voidRoutine           * OS_SADDR OS_pfOnTask2Debug;
    extern   OS_CSEMA OS_CSEMAPTR* pCSema;
  #endif
#endif

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

/*
   *********************************************
   *                                           *
   *          Create Task routine and macros   *
   *                                           *
   *********************************************
*/
#if OS_TRACKNAME
  #define CTPARA_NAME "unnamed task",
#else
  #define CTPARA_NAME
#endif

#if __OS_RRSUPPORTED__
  #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



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

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

OS_DEFFUNC void OS__Delay(int ms);
OS_DEFFUNC void OS__Delay_Trace(int ms);
OS_DEFFUNC void OS__DelayUntil(int t0);
OS_DEFFUNC void OS__DelayUntil_Trace(int t0);
OS_DEFFUNC void OS__Terminate         (OS_TASK OS_DEFPTR *);
OS_DEFFUNC void OS__Terminate_Trace   (OS_TASK OS_DEFPTR *);
OS_DEFFUNC void OS_TerminateError    (void);
OS_DEFFUNC void OS__WakeTask          (OS_TASK OS_DEFPTR *);
OS_DEFFUNC void OS__WakeTask_Trace    (OS_TASK OS_DEFPTR *);
OS_DEFFUNC void OS_GetState           (OS_TASK OS_DEFPTR *);
OS_DEFFUNC void OS__SetPriority       (OS_TASK OS_DEFPTR *ptask, OS_U8 Priority);
OS_DEFFUNC void OS__SetPriority_Trace (OS_TASK OS_DEFPTR *ptask, OS_U8 Priority);
OS_DEFFUNC char OS_IsTask             (OS_TASK OS_DEFPTR *ptask);

#if OS_TRACE
  #define OS_Delay(p0)          OS__Delay_Trace(p0)
  #define OS_DelayUntil(p0)     OS__DelayUntil_Trace(p0)
  #define OS_SetPriority(p0,p1) OS__SetPriority_Trace(p0,p1)
  #define OS_Terminate(p0)      OS__Terminate_Trace(p0)
  #define OS_WakeTask(p0)       OS__WakeTask_Trace(p0)
#else
  #define OS_Delay(p0)          OS__Delay(p0)
  #define OS_DelayUntil(p0)     OS__DelayUntil(p0)
  #define OS_SetPriority(p0,p1) OS__SetPriority(p0,p1)
  #define OS_Terminate(p0)      OS__Terminate(p0)
  #define OS_WakeTask(p0)       OS__WakeTask(p0)
#endif

/*********************************************************************
*
*                      Info routines
*
**********************************************************************
*/

#define OS_TASKID OS_TASK OS_DEFPTR *
#define OS_GetTaskID() OS_pCurrentTask

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

#if OS_CHECKSTACK
  OS_DEFFUNC void  OS_CheckStack(void);              /* internal usage */
  OS_DEFFUNC int   OS_GetStackSpace  (OS_TASK OS_DEFPTR *);
  OS_DEFFUNC int   OS_GetStackUsed   (OS_TASK OS_DEFPTR *);
  OS_DEFFUNC int   OS_GetStackSize   (OS_TASK OS_TCBPTR *pt);
  OS_DEFFUNC void OS_STACKPTR* OS_GetStackBase   (OS_TASK OS_TCBPTR *pt);
#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

#if __OS_RRSUPPORTED__
  OS_U8 OS_SetTimeSlice(OS_TASK OS_DEFPTR *pTask, OS_U8 TimeSlice);
  OS_DEFFUNC 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

#if OS_DEBUG
  OS_DEFFUNC OS_U8    OS_GetPriority       (OS_TASK OS_DEFPTR *ptask);
#else
  #define OS_GetPriority(pt) pt->Priority 
#endif

OS_DEFFUNC int   OS_GetNumTasks       (void);
OS_DEFFUNC OS_TASK OS_DEFPTR * OS_TaskIndex2Ptr     (int TaskIndex);

#if OS_PROFILE >=1
  OS_DEFFUNC void OS_STAT_NotifyExecEnd(void);
  OS_DEFFUNC OS_U32 OS_STAT_GetExecTime_Cycles (OS_TASK OS_DEFPTR *pTask);
  OS_DEFFUNC int    OS_STAT_GetLoad            (OS_TASK OS_DEFPTR *pTask);
  OS_DEFFUNC OS_U32 OS_STAT_GetNumActivations  (OS_TASK OS_DEFPTR *pTask);
  OS_DEFFUNC OS_U32 OS_STAT_GetNumPreemptions  (OS_TASK OS_DEFPTR *pTask);
  OS_DEFFUNC void   OS_STAT_NotifyReadyStart   (OS_TASK OS_DEFPTR *pTask);
  OS_DEFFUNC void   OS_STAT_Sample(void);
  OS_DEFFUNC void   OS_STAT_SetClocksPerUnit(unsigned int ClocksPerUnit);
#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
*
**********************************************************************
*/

#define OS_EnterRegion() {OS_RegionCnt++; }
OS_DEFFUNC 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 */

#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_SwitchFromInt(); \
      } \
    } \
    OS_RegionCnt--; \
  }
#endif

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

#ifndef OS_LeaveInterruptNoSwitch   /* Allow override in OSChip.h */
  #define OS_LeaveInterruptNoSwitch() { \
    OS_MARK_OUTOF_ISR(); \
    OS_DICnt--; \
    OS_RegionCnt--; \
  }
#endif

#ifndef OS_LeaveNestableInterruptNoSwitch   /* Allow override in OSChip.h */
  #define OS_LeaveNestableInterruptNoSwitch() { \
    OS_MARK_OUTOF_ISR(); \
    OS_DI(); \
    OS_RegionCnt--; \
  }
#endif

#ifndef OS_EnterIntStack
  OS_DEFFUNC void OS__EnterIntStack(void);
  #define OS_EnterIntStack() {OS_DI(); OS__EnterIntStack(); OS_RestoreI(); }
#endif

#ifndef OS_LeaveIntStack
  OS_DEFFUNC void OS__LeaveIntStack(void);
  #define OS_LeaveIntStack() {OS_DI(); OS__LeaveIntStack(); }
#endif

/*********************************************************************
*
*                      Resource semaphores
*
**********************************************************************
*/

OS_DEFFUNC int      OS__Use             (OS_RSEMA OS_DEFPTR *);
OS_DEFFUNC int      OS__Use_Trace       (OS_RSEMA OS_DEFPTR *);
OS_DEFFUNC void     OS__Unuse           (OS_RSEMA OS_DEFPTR *);
OS_DEFFUNC void     OS__Unuse_Trace     (OS_RSEMA OS_DEFPTR *);
OS_DEFFUNC char     OS__Request         (OS_RSEMA OS_DEFPTR *);
OS_DEFFUNC char     OS__Request_Trace   (OS_RSEMA OS_DEFPTR *);
OS_DEFPTR  int      OS_GetSemaValue     (OS_RSEMA OS_DEFPTR *);   /* get current value of semaphore */
OS_DEFFUNC OS_TASK* OS_GetResourceOwner (OS_RSEMA OS_DEFPTR *);   /* get TaskID of task using semaphore */

OS_DEFFUNC void     OS__CreateRSema       (OS_RSEMA OS_DEFPTR *);
OS_DEFFUNC void     OS__CreateRSema_Trace (OS_RSEMA OS_DEFPTR *);

#define OS_CREATERSEMA(ps) OS_CreateRSema(ps)

#if OS_TRACE
  #define OS_CreateRSema(p0) OS__CreateRSema_Trace(p0)
  #define OS_Use(p0)         OS__Use_Trace(p0)
  #define OS_Unuse(p0)       OS__Unuse_Trace(p0)
  #define OS_Request(p0)     OS__Request_Trace(p0)
#else
  #define OS_CreateRSema(p0) OS__CreateRSema(p0)
  #define OS_Use(p0)         OS__Use(p0)
  #define OS_Unuse(p0)       OS__Unuse(p0)
  #define OS_Request(p0)     OS__Request(p0)
#endif


/*********************************************************************
*
*                      Counting semaphores
*
**********************************************************************
*/


OS_DEFFUNC void OS__CreateCSema           (OS_CSEMA OS_DEFPTR *, OS_U8 InitValue);
OS_DEFFUNC void OS__CreateCSema_Trace     (OS_CSEMA OS_DEFPTR *, OS_U8 InitValue);
OS_DEFFUNC void OS__DeleteCSema           (OS_CSEMA OS_DEFPTR *);
OS_DEFFUNC void OS__DeleteCSema_Trace     (OS_CSEMA OS_DEFPTR *);
OS_DEFPTR  int  OS_GetCSemaValue          (OS_CSEMA OS_DEFPTR *);
OS_DEFFUNC void OS__SignalCSema           (OS_CSEMA OS_DEFPTR *);
OS_DEFFUNC void OS__SignalCSema_Trace     (OS_CSEMA OS_DEFPTR *);
OS_DEFFUNC void OS__WaitCSema             (OS_CSEMA OS_DEFPTR *);
OS_DEFFUNC void OS__WaitCSema_Trace       (OS_CSEMA OS_DEFPTR *);
OS_DEFFUNC int  OS__WaitCSemaTimed        (OS_CSEMA OS_DEFPTR *pSema, int TimeOut);
OS_DEFFUNC int  OS__WaitCSemaTimed_Trace  (OS_CSEMA OS_DEFPTR *pSema, int TimeOut);
#define OS_CREATECSEMA(ps) OS_CreateCSema(ps,0)

#if OS_TRACE
  #define OS_CreateCSema(p0, p1)     OS__CreateCSema_Trace(p0, p1)
  #define OS_DeleteCSema(p0)         OS__DeleteCSema_Trace(p0)
  #define OS_SignalCSema(p0)         OS__SignalCSema_Trace(p0)
  #define OS_WaitCSema(p0)           OS__WaitCSema_Trace(p0)
  #define OS_WaitCSemaTimed(p0, p1)  OS__WaitCSemaTimed_Trace(p0, p1)
#else
  #define OS_CreateCSema(p0, p1)     OS__CreateCSema(p0, p1)
  #define OS_DeleteCSema(p0)         OS__DeleteCSema(p0)
  #define OS_SignalCSema(p0)         OS__SignalCSema(p0)
  #define OS_WaitCSema(p0)           OS__WaitCSema(p0)
  #define OS_WaitCSemaTimed(p0, p1)  OS__WaitCSemaTimed(p0, p1)
#endif

/*********************************************************************
*
*                      Mailboxes
*
**********************************************************************
*/
#define CREATEMB(MAILBOX, size, max, Buffer) OS_CreateMB(MAILBOX,size, max, Buffer);
OS_DEFFUNC void OS__CreateMB           (OS_MAILBOX OS_DEFPTR * pMB, OS_U8 sizeofMsg, OS_UINT maxnofMsg, void* Buffer);    /* initialize mailbox */
OS_DEFFUNC void OS__CreateMB_Trace     (OS_MAILBOX OS_DEFPTR * pMB, OS_U8 sizeofMsg, OS_UINT maxnofMsg, void* Buffer);    /* initialize mailbox */
OS_DEFFUNC void OS__ClearMB            (OS_MAILBOX OS_DEFPTR * pMB);
OS_DEFFUNC void OS__ClearMB_Trace      (OS_MAILBOX OS_DEFPTR * pMB);
OS_DEFFUNC void OS__PutMail            (OS_MAILBOX OS_DEFPTR * pMB, void* pmail);
OS_DEFFUNC void OS__PutMail_Trace      (OS_MAILBOX OS_DEFPTR * pMB, void* pmail);
OS_DEFFUNC char OS__PutMailCond        (OS_MAILBOX OS_DEFPTR * pMB, void* pmail);
OS_DEFFUNC char OS__PutMailCond_Trace  (OS_MAILBOX OS_DEFPTR * pMB, void* pmail);
OS_DEFFUNC void OS__GetMail            (OS_MAILBOX OS_DEFPTR * pMB, void* Result);
OS_DEFFUNC void OS__GetMail_Trace      (OS_MAILBOX OS_DEFPTR * pMB, void* Result);
OS_DEFFUNC char OS__GetMailCond        (OS_MAILBOX OS_DEFPTR * pMB, void* Result);
OS_DEFFUNC char OS__GetMailCond_Trace  (OS_MAILBOX OS_DEFPTR * pMB, void* Result);