emos_core.h

emos是一个新的类似于ucos的内核

    struct emos_tcb* osTCBPrev;          /* Pointer to previous TCB in the TCB list     */

#if (EMOS_Q_EN && (EMOS_MAX_QS >= 2)) || EMOS_MBOX_EN || EMOS_SEM_EN
    EMOS_EVENT_T* osTCBEventPtr;      /* Pointer to event control block              */
#endif

#if (EMOS_Q_EN && (EMOS_MAX_QS >= 2)) || EMOS_MBOX_EN
    void          *osTCBMsg;           /* Message received from emosMboxPost() or emosQPost()              */
#endif    

    uint16         osTCBDly;           /* Nbr ticks to delay task or, timeout waiting for event        */
    uint8          osTCBStat;          /* Task status                                 */
    uint8          osTCBPrio;          /* Task priority (0 == highest, 63 == lowest)  */

    uint8          osTCBX;             /* Bit position in group  corresponding to task priority (0..7) */
    uint8          osTCBY;             /* Index into ready table corresponding to task priority        */
    uint8          osTCBBitX;          /* Bit mask to access bit position in ready table               */
    uint8          osTCBBitY;          /* Bit mask to access bit position in ready group               */
    
#if EMOS_TASK_DEL_EN    
/* Indicates whether a task needs to delete itself */
   bool            osTCBDelReq;        
#endif
} EMOS_TCB_T;


/**********************************************************************************************************
* GLOBAL VARIABLES
**********************************************************************************************************/
EMOS_EXT  uint8        gEmosError;
EMOS_EXT  uint32       gEmosDbgLevel;  

/* Counter of number of context switches */
EMOS_EXT  uint32       gEmosCtxSwCtr;               
EMOS_EXT  uint32       gEmosIdleCtr;  /* Idle counter*/
EMOS_EXT  uint32       gEmosIdleTickCnt;  /* Tick Idle counter*/
/* Current value of system time (in ticks)              */
EMOS_EXT  uint32       gEmosTime;         

#if(EMOS_MAX_EVENTS >= 2)
/* Pointer to list of free EVENT control blocks, 
   the MBox, Q, Semaphore will use this structure except for vxWorks like msgQ*/
EMOS_EXT  EMOS_EVENT_T*    gEmosEventFreeList; 

/* Table of EVENT control blocks*/
EMOS_EXT  EMOS_EVENT_T     gEmosEventTbl[EMOS_MAX_EVENTS];
#endif

#if EMOS_TASK_STAT_EN
EMOS_EXT  int8         gEmosCpuUsage;               /* Percentage of CPU used              */
EMOS_EXT  uint32       gEmosIdleCtrMax;             /* Maximum value that idle counter can take in 1 sec.   */
EMOS_EXT  uint32       gEmosIdleCtrRun;             /* Value reached by idle counter at run time in 1 sec.  */
EMOS_EXT  bool         gEmosStatRdy;                  /* Flag indicating that the statistic task is ready     */
#endif

EMOS_EXT  uint8        gEmosIntNesting;               /* Interrupt nesting level             */
EMOS_EXT  uint8        gEmosLockNesting;            /* Multitasking lock nesting level     */
EMOS_EXT  uint8        gEmosPrioCur;                     /* Priority of current task            */
EMOS_EXT  uint8        gEmosPrioHighRdy;            /* Priority of highest priority task   */

EMOS_EXT  uint8        gEmosRdyGrp;                        /* Ready list group             */
EMOS_EXT  uint8        gEmosRdyTbl[EMOS_RDY_TBL_SIZE];     /* Table of tasks which are ready to run         */

/* Flag indicating that kernel is running        */
EMOS_EXT  bool         gEmosRunning;                     

#if EMOS_TASK_CREATE_EN  || EMOS_TASK_CREATE_EXT_EN || EMOS_TASK_DEL_EN
EMOS_EXT  uint8       gEmosTaskCtr;  /* Number of tasks created      */
#endif

EMOS_EXT  EMOS_TCB_T*  gEmosTCBCur;       /* Pointer to currently running TCB              */
EMOS_EXT  EMOS_TCB_T*  gEmosTCBFreeList;  /* Pointer to list of free TCBs */
EMOS_EXT  EMOS_TCB_T*  gEmosTCBHighRdy;   /* Pointer to highest priority TCB ready to run  */
EMOS_EXT  EMOS_TCB_T*  gEmosTCBList;      /* Pointer to doubly linked list of TCBs         */
EMOS_EXT  EMOS_TCB_T*  gEmosTCBPrioTbl[EMOS_LOWEST_PRIO + 1];/* Table of pointers to created TCBs*/

extern  uint8 const    gEmosMapTbl[];               /* Priority->Bit Mask lookup table     */
extern  uint8 const    gEmosUnMapTbl[];             /* Priority->Index    lookup table     */



/**********************************************************************************************************
*   FUNCTION PROTOTYPES
*  (Target Independant Functions)
**********************************************************************************************************/
#ifdef __cplusplus
 extern "C" {
#endif


/**********************************************************************************************************
* MESSAGE MAILBOX MANAGEMENT
**********************************************************************************************************/
#if EMOS_MBOX_EN
EMOS_EVENT_T* emosMboxCreate(void *msg);
void*         emosMboxAccept(EMOS_EVENT_T *pevent);
void*         emosMboxPend(EMOS_EVENT_T *pevent, uint16 timeout, uint8 *err);
uint8         emosMboxPost(EMOS_EVENT_T *pevent, void *msg);
uint8         emosMboxQuery(EMOS_EVENT_T *pevent, EMOS_MBOX_DATA_T *pdata);
#endif

/**********************************************************************************************************
*  MEMORY MANAGEMENT
**********************************************************************************************************/
#if EMOS_MEM_EN && (EMOS_MAX_MEM_PART >= 2)
void           emosMemInit(void);
EMOS_MEM_T*    emosMemCreate(void *addr, uint32 nblks, uint32 blksize, uint8 *err);
void*          emosMemGet(EMOS_MEM_T  *pmem, uint8 *err);
uint8          emosMemPut(EMOS_MEM_T  *pmem, void *pblk);
uint8          emosMemQuery(EMOS_MEM_T  *pmem, EMOS_MEM_DATA_T *pdata);
#endif

/**********************************************************************************************************
* MESSAGE QUEUE MANAGEMENT
**********************************************************************************************************/
#if EMOS_Q_EN && (EMOS_MAX_QS >= 2)
EMOS_EVENT_T* emosQCreate(void **start, uint16 size);
void*         emosQAccept(EMOS_EVENT_T *pevent);
void*         emosQPend(EMOS_EVENT_T *pevent, uint16 timeout, uint8 *err);
uint8         emosQFlush(EMOS_EVENT_T *pevent);
uint8         emosQPost(EMOS_EVENT_T *pevent, void *msg);
uint8         emosQPostFront(EMOS_EVENT_T *pevent, void *msg);
uint8         emosQQuery(EMOS_EVENT_T *pevent, EMOS_Q_DATA_T *pdata);
#endif

#if EMOS_Q_EN && (EMOS_MAX_MSGQS >= 2)
struct EMOS_MSGQ_t;
typedef struct EMOS_MSGQ_t* EMOS_MSGQ_ID;
void emosMsgQInit();
EMOS_MSGQ_ID emosMsgQCreate(uint16 msgNum, uint16 msgLen);
EMOS_MSGQ_ID emosMsgQDelete(EMOS_MSGQ_ID ID );
int emosMsgQRecv(EMOS_MSGQ_ID ID, char* buf, uint16 size, int timeout);
int emosMsgQSend(EMOS_MSGQ_ID ID, char* buf, uint16 size);
#endif

/**********************************************************************************************************
* SEMAPHORE MANAGEMENT
**********************************************************************************************************/
#if EMOS_SEM_EN
EMOS_EVENT_T*  emosSemCreate(uint16 value);
uint16         emosSemAccept(EMOS_EVENT_T *pevent);
void           emosSemPend(EMOS_EVENT_T *pevent, uint16 timeout, uint8 *err);
uint8          emosSemPost(EMOS_EVENT_T *pevent);
uint8          emosSemQuery(EMOS_EVENT_T *pevent, EMOS_SEM_DATA_T *pdata);
#endif

/**********************************************************************************************************
* TASK MANAGEMENT
**********************************************************************************************************/
uint8       emosTaskCreate(void (*task)(void *pd), void *pdata, EMOS_STK *ptos, uint8 prio);
uint8       emosTaskQuery(uint8 prio, EMOS_TCB_T *pdata);

#if EMOS_TASK_CHANGE_PRIO_EN
uint8       emosTaskChangePrio(uint8 oldprio, uint8 newprio);
#endif

#if EMOS_TASK_CREATE_EXT_EN
uint8       emosTaskCreateExt(void  (*task)(void *pd), 
                            void   *pdata, 
                            EMOS_STK *ptos, 
                            uint8   prio,
                            uint16  id,
                            EMOS_STK *pbos,
                            uint32  stk_size,
                            void   *pext,
                            uint16  opt);
#endif   

#if EMOS_TASK_CREATE_EXT_EN
uint8       emosTaskStkChk(uint8 prio, EMOS_STK_DATA_T *pdata);
//uint8       emosTaskStkChk (uint8 prio, EMOS_STK_DATA_T *pdata);
#endif

#if EMOS_TASK_DEL_EN
uint8       emosTaskDel(uint8 prio);
uint8       emosTaskDelReq(uint8 prio);
#endif

#if EMOS_TASK_SUSPEND_EN
uint8       emosTaskResume(uint8 prio);
uint8       emosTaskSuspend(uint8 prio);
#endif


/**********************************************************************************************************
*  TIME MANAGEMENT
**********************************************************************************************************/
void         emosTimeDly(uint16 ticks);
void         emosTimeSet(uint32 ticks);
void         emosTimeTick(void);
uint8        emosTimeDlyHMSM(uint8 hours, uint8 minutes, uint8 seconds, uint16 milli);
uint8        emosTimeDlyResume(uint8 prio);
uint32       emosTimeGet(void);


/**********************************************************************************************************
*   MISCELLANEOUS
**********************************************************************************************************/
void        emosInit(void);
void        emosInitStart(void);
void        emosStart(void);
void        emosStatInit(void);
void        emosIntEnter(void);
void        emosIntExit(void);
void        emosSchedLock(void);
void        emosSchedUnlock(void);
uint16      emosVersion(void);
char*       emosVersionString(void);

/**********************************************************************************************************
* INTERNAL FUNCTION PROTOTYPES
* (Your application MUST NOT call these functions)
**********************************************************************************************************/
uint8 emosTCBInit(uint8 prio, EMOS_STK *ptos, EMOS_STK *pbos, uint16 id, uint16 stk_size, void *pext, uint16 opt);
void  emosSched(void);
void  emosTaskIdle(void *data);

#if EMOS_MBOX_EN || EMOS_Q_EN || EMOS_SEM_EN
void        emosEventTaskRdy(EMOS_EVENT_T *pevent, void *msg, uint8 msk);
void        emosEventTaskWait(EMOS_EVENT_T *pevent);
void        emosEventTo(EMOS_EVENT_T *pevent);
void        emosEventWaitListInit(EMOS_EVENT_T *pevent);
#endif

#if EMOS_Q_EN
void        emosQInit(void);
#endif

#if EMOS_TASK_STAT_EN
void        emosTaskStat(void *data);
#endif


/**********************************************************************************************************
*  FUNCTION PROTOTYPES
*  (Target Specific Functions, for different CPU, implemented as .asm )
**********************************************************************************************************/
void        emosCtxSw(void);  /*implement in cpu.asm of context switch*/
void        emosIntCtxSw(void);  /*implement in cpu.asm of interrupt context switch*/
void        emosStartHighRdy(void);  /*implement in cpu.asm of task switch*/
void        emosTickISR(void);  /*implement in cpu.asm of tick interrupt*/
void*       emosTaskStkInit(void (*task)(void *pd), void *pdata, void *ptos, uint16 opt);


/*implemented in the user files/core.c*/
void        emosTaskCreateHook(EMOS_TCB_T *ptcb);
void        emosTaskDelHook(EMOS_TCB_T *ptcb);
void        emosTaskStatHook(void);
void        emosTaskSwHook(void);
void        emosTimeTickHook(void);

/*added for debug*/
void emosDbgShow();
#define EMOS_DBGSTR_VAL(a) printf("==>Trace:"#a"=%x\r\n",(int)a)
#ifdef __cplusplus
	}
#endif

#endif

 /*
 * Please add "$" around "Id" and "Log".
 * $Id$
 * $Log$
 *
 */