ucos_ii.h

事件驱动程序设计很好的框架

#define OS_ERR_TIME_ZERO_DLY         84u
#define OS_ERR_TIME_DLY_ISR          85u

#define OS_ERR_MEM_INVALID_PART      90u
#define OS_ERR_MEM_INVALID_BLKS      91u
#define OS_ERR_MEM_INVALID_SIZE      92u
#define OS_ERR_MEM_NO_FREE_BLKS      93u
#define OS_ERR_MEM_FULL              94u
#define OS_ERR_MEM_INVALID_PBLK      95u
#define OS_ERR_MEM_INVALID_PMEM      96u
#define OS_ERR_MEM_INVALID_PDATA     97u
#define OS_ERR_MEM_INVALID_ADDR      98u
#define OS_ERR_MEM_NAME_TOO_LONG     99u

#define OS_ERR_NOT_MUTEX_OWNER      100u

#define OS_ERR_FLAG_INVALID_PGRP    110u
#define OS_ERR_FLAG_WAIT_TYPE       111u
#define OS_ERR_FLAG_NOT_RDY         112u
#define OS_ERR_FLAG_INVALID_OPT     113u
#define OS_ERR_FLAG_GRP_DEPLETED    114u
#define OS_ERR_FLAG_NAME_TOO_LONG   115u

#define OS_ERR_PIP_LOWER            120u

#define OS_ERR_TMR_INVALID_DLY      130u
#define OS_ERR_TMR_INVALID_PERIOD   131u
#define OS_ERR_TMR_INVALID_OPT      132u
#define OS_ERR_TMR_INVALID_NAME     133u
#define OS_ERR_TMR_NON_AVAIL        134u
#define OS_ERR_TMR_INACTIVE         135u
#define OS_ERR_TMR_INVALID_DEST     136u
#define OS_ERR_TMR_INVALID_TYPE     137u
#define OS_ERR_TMR_INVALID          138u
#define OS_ERR_TMR_ISR              139u
#define OS_ERR_TMR_NAME_TOO_LONG    140u
#define OS_ERR_TMR_INVALID_STATE    141u
#define OS_ERR_TMR_STOPPED          142u
#define OS_ERR_TMR_NO_CALLBACK      143u

/*
*********************************************************************************************************
*                                    OLD ERROR CODE NAMES (< V2.84)
*********************************************************************************************************
*/
#define OS_NO_ERR                    OS_ERR_NONE
#define OS_TIMEOUT                   OS_ERR_TIMEOUT
#define OS_TASK_NOT_EXIST            OS_ERR_TASK_NOT_EXIST
#define OS_MBOX_FULL                 OS_ERR_MBOX_FULL
#define OS_Q_FULL                    OS_ERR_Q_FULL
#define OS_Q_EMPTY                   OS_ERR_Q_EMPTY
#define OS_PRIO_EXIST                OS_ERR_PRIO_EXIST
#define OS_PRIO_ERR                  OS_ERR_PRIO
#define OS_PRIO_INVALID              OS_ERR_PRIO_INVALID
#define OS_SEM_OVF                   OS_ERR_SEM_OVF
#define OS_TASK_DEL_ERR              OS_ERR_TASK_DEL
#define OS_TASK_DEL_IDLE             OS_ERR_TASK_DEL_IDLE
#define OS_TASK_DEL_REQ              OS_ERR_TASK_DEL_REQ
#define OS_TASK_DEL_ISR              OS_ERR_TASK_DEL_ISR
#define OS_NO_MORE_TCB               OS_ERR_TASK_NO_MORE_TCB
#define OS_TIME_NOT_DLY              OS_ERR_TIME_NOT_DLY
#define OS_TIME_INVALID_MINUTES      OS_ERR_TIME_INVALID_MINUTES
#define OS_TIME_INVALID_SECONDS      OS_ERR_TIME_INVALID_SECONDS
#define OS_TIME_INVALID_MS           OS_ERR_TIME_INVALID_MS
#define OS_TIME_ZERO_DLY             OS_ERR_TIME_ZERO_DLY
#define OS_TASK_SUSPEND_PRIO         OS_ERR_TASK_SUSPEND_PRIO
#define OS_TASK_SUSPEND_IDLE         OS_ERR_TASK_SUSPEND_IDLE
#define OS_TASK_RESUME_PRIO          OS_ERR_TASK_RESUME_PRIO
#define OS_TASK_NOT_SUSPENDED        OS_ERR_TASK_NOT_SUSPENDED
#define OS_MEM_INVALID_PART          OS_ERR_MEM_INVALID_PART
#define OS_MEM_INVALID_BLKS          OS_ERR_MEM_INVALID_BLKS
#define OS_MEM_INVALID_SIZE          OS_ERR_MEM_INVALID_SIZE
#define OS_MEM_NO_FREE_BLKS          OS_ERR_MEM_NO_FREE_BLKS
#define OS_MEM_FULL                  OS_ERR_MEM_FULL
#define OS_MEM_INVALID_PBLK          OS_ERR_MEM_INVALID_PBLK
#define OS_MEM_INVALID_PMEM          OS_ERR_MEM_INVALID_PMEM
#define OS_MEM_INVALID_PDATA         OS_ERR_MEM_INVALID_PDATA
#define OS_MEM_INVALID_ADDR          OS_ERR_MEM_INVALID_ADDR
#define OS_MEM_NAME_TOO_LONG         OS_ERR_MEM_NAME_TOO_LONG
#define OS_TASK_OPT_ERR              OS_ERR_TASK_OPT
#define OS_FLAG_INVALID_PGRP         OS_ERR_FLAG_INVALID_PGRP
#define OS_FLAG_ERR_WAIT_TYPE        OS_ERR_FLAG_WAIT_TYPE
#define OS_FLAG_ERR_NOT_RDY          OS_ERR_FLAG_NOT_RDY
#define OS_FLAG_INVALID_OPT          OS_ERR_FLAG_INVALID_OPT
#define OS_FLAG_GRP_DEPLETED         OS_ERR_FLAG_GRP_DEPLETED

/*$PAGE*/
/*
*********************************************************************************************************
*                                          EVENT CONTROL BLOCK
*********************************************************************************************************
*/

#if (OS_EVENT_EN) && (OS_MAX_EVENTS > 0)
typedef struct os_event {
    INT8U    OSEventType;                    /* Type of event control block (see OS_EVENT_TYPE_xxxx)    */
    void    *OSEventPtr;                     /* Pointer to message or queue structure                   */
    INT16U   OSEventCnt;                     /* Semaphore Count (not used if other EVENT type)          */
#if OS_LOWEST_PRIO <= 63
    INT8U    OSEventGrp;                     /* Group corresponding to tasks waiting for event to occur */
    INT8U    OSEventTbl[OS_EVENT_TBL_SIZE];  /* List of tasks waiting for event to occur                */
#else
    INT16U   OSEventGrp;                     /* Group corresponding to tasks waiting for event to occur */
    INT16U   OSEventTbl[OS_EVENT_TBL_SIZE];  /* List of tasks waiting for event to occur                */
#endif

#if OS_EVENT_NAME_SIZE > 1
    INT8U    OSEventName[OS_EVENT_NAME_SIZE];
#endif
} OS_EVENT;
#endif


/*
*********************************************************************************************************
*                                       EVENT FLAGS CONTROL BLOCK
*********************************************************************************************************
*/

#if (OS_FLAG_EN > 0) && (OS_MAX_FLAGS > 0)

#if OS_FLAGS_NBITS == 8                     /* Determine the size of OS_FLAGS (8, 16 or 32 bits)       */
typedef  INT8U    OS_FLAGS;
#endif

#if OS_FLAGS_NBITS == 16
typedef  INT16U   OS_FLAGS;
#endif

#if OS_FLAGS_NBITS == 32
typedef  INT32U   OS_FLAGS;
#endif


typedef struct os_flag_grp {                /* Event Flag Group                                        */
    INT8U         OSFlagType;               /* Should be set to OS_EVENT_TYPE_FLAG                     */
    void         *OSFlagWaitList;           /* Pointer to first NODE of task waiting on event flag     */
    OS_FLAGS      OSFlagFlags;              /* 8, 16 or 32 bit flags                                   */
#if OS_FLAG_NAME_SIZE > 1
    INT8U         OSFlagName[OS_FLAG_NAME_SIZE];
#endif
} OS_FLAG_GRP;



typedef struct os_flag_node {               /* Event Flag Wait List Node                               */
    void         *OSFlagNodeNext;           /* Pointer to next     NODE in wait list                   */
    void         *OSFlagNodePrev;           /* Pointer to previous NODE in wait list                   */
    void         *OSFlagNodeTCB;            /* Pointer to TCB of waiting task                          */
    void         *OSFlagNodeFlagGrp;        /* Pointer to Event Flag Group                             */
    OS_FLAGS      OSFlagNodeFlags;          /* Event flag to wait on                                   */
    INT8U         OSFlagNodeWaitType;       /* Type of wait:                                           */
                                            /*      OS_FLAG_WAIT_AND                                   */
                                            /*      OS_FLAG_WAIT_ALL                                   */
                                            /*      OS_FLAG_WAIT_OR                                    */
                                            /*      OS_FLAG_WAIT_ANY                                   */
} OS_FLAG_NODE;
#endif

/*$PAGE*/
/*
*********************************************************************************************************
*                                          MESSAGE MAILBOX DATA
*********************************************************************************************************
*/

#if OS_MBOX_EN > 0
typedef struct os_mbox_data {
    void   *OSMsg;                         /* Pointer to message in mailbox                            */
#if OS_LOWEST_PRIO <= 63
    INT8U   OSEventTbl[OS_EVENT_TBL_SIZE]; /* List of tasks waiting for event to occur                 */
    INT8U   OSEventGrp;                    /* Group corresponding to tasks waiting for event to occur  */
#else
    INT16U  OSEventTbl[OS_EVENT_TBL_SIZE]; /* List of tasks waiting for event to occur                 */
    INT16U  OSEventGrp;                    /* Group corresponding to tasks waiting for event to occur  */
#endif
} OS_MBOX_DATA;
#endif

/*
*********************************************************************************************************
*                                     MEMORY PARTITION DATA STRUCTURES
*********************************************************************************************************
*/

#if (OS_MEM_EN > 0) && (OS_MAX_MEM_PART > 0)
typedef struct os_mem {                   /* MEMORY CONTROL BLOCK                                      */
    void   *OSMemAddr;                    /* Pointer to beginning of memory partition                  */
    void   *OSMemFreeList;                /* Pointer to list of free memory blocks                     */
    INT32U  OSMemBlkSize;                 /* Size (in bytes) of each block of memory                   */
    INT32U  OSMemNBlks;                   /* Total number of blocks in this partition                  */
    INT32U  OSMemNFree;                   /* Number of memory blocks remaining in this partition       */
#if OS_MEM_NAME_SIZE > 1
    INT8U   OSMemName[OS_MEM_NAME_SIZE];  /* Memory partition name                                     */
#endif
} OS_MEM;


typedef struct os_mem_data {
    void   *OSAddr;                    /* Pointer to the beginning address of the memory partition     */
    void   *OSFreeList;                /* Pointer to the beginning of the free list of memory blocks   */
    INT32U  OSBlkSize;                 /* Size (in bytes) of each memory block                         */
    INT32U  OSNBlks;                   /* Total number of blocks in the partition                      */
    INT32U  OSNFree;                   /* Number of memory blocks free                                 */
    INT32U  OSNUsed;                   /* Number of memory blocks used                                 */
} OS_MEM_DATA;
#endif

/*$PAGE*/
/*
*********************************************************************************************************
*                                    MUTUAL EXCLUSION SEMAPHORE DATA
*********************************************************************************************************
*/

#if OS_MUTEX_EN > 0
typedef struct os_mutex_data {
#if OS_LOWEST_PRIO <= 63
    INT8U   OSEventTbl[OS_EVENT_TBL_SIZE];  /* List of tasks waiting for event to occur                */
    INT8U   OSEventGrp;                     /* Group corresponding to tasks waiting for event to occur */
#else
    INT16U  OSEventTbl[OS_EVENT_TBL_SIZE];  /* List of tasks waiting for event to occur                */
    INT16U  OSEventGrp;                     /* Group corresponding to tasks waiting for event to occur */
#endif
    BOOLEAN OSValue;                        /* Mutex value (OS_FALSE = used, OS_TRUE = available)      */
    INT8U   OSOwnerPrio;                    /* Mutex owner's task priority or 0xFF if no owner         */
    INT8U   OSMutexPIP;                     /* Priority Inheritance Priority or 0xFF if no owner       */
} OS_MUTEX_DATA;
#endif

/*
*********************************************************************************************************
*                                          MESSAGE QUEUE DATA
*********************************************************************************************************
*/

#if OS_Q_EN > 0
typedef struct os_q {                   /* QUEUE CONTROL BLOCK                                         */
    struct os_q   *OSQPtr;              /* Link to next queue control block in list of free blocks     */
    void         **OSQStart;            /* Pointer to start of queue data                              */
    void         **OSQEnd;              /* Pointer to end   of queue data                              */
    void         **OSQIn;               /* Pointer to where next message will be inserted  in   the Q  */
    void         **OSQOut;              /* Pointer to where next message will be extracted from the Q  */
    INT16U         OSQSize;             /* Size of queue (maximum number of entries)                   */
    INT16U         OSQEntries;          /* Current number of entries in the queue                      */
} OS_Q;


typedef struct os_q_data {
    void          *OSMsg;               /* Pointer to next message to be extracted from queue          */
    INT16U         OSNMsgs;             /* Number of messages in message queue                         */
    INT16U         OSQSize;             /* Size of message queue                                       */
#if OS_LOWEST_PRIO <= 63
    INT8U          OSEventTbl[OS_EVENT_TBL_SIZE];  /* List of tasks waiting for event to occur         */
    INT8U          OSEventGrp;          /* Group corresponding to tasks waiting for event to occur     */
#else
    INT16U         OSEventTbl[OS_EVENT_TBL_SIZE];  /* List of tasks waiting for event to occur         */
    INT16U         OSEventGrp;          /* Group corresponding to tasks waiting for event to occur     */
#endif
} OS_Q_DATA;
#endif

/*
*********************************************************************************************************
*                                           SEMAPHORE DATA
*********************************************************************************************************
*/

#if OS_SEM_EN > 0
typedef struct os_sem_data {
    INT16U  OSCnt;                          /* Semaphore count                                         */
#if OS_LOWEST_PRIO <= 63
    INT8U   OSEventTbl[OS_EVENT_TBL_SIZE];  /* List of tasks waiting for event to occur                */
    INT8U   OSEventGrp;                     /* Group corresponding to tasks waiting for event to occur */
#else
    INT16U  OSEventTbl[OS_EVENT_TBL_SIZE];  /* List of tasks waiting for event to occur                */
    INT16U  OSEventGrp;                     /* Group corresponding to tasks waiting for event to occur */
#endif
} OS_SEM_DATA;
#endif

/*
*********************************************************************************************************
*                                            TASK STACK DATA
*********************************************************************************************************
*/

#if OS_TASK_CREATE_EXT_EN > 0
typedef struct os_stk_data {
    INT32U  OSFree;                    /* Number of free bytes on the stack                            */
    INT32U  OSUsed;                    /* Number of bytes used on the stack                            */
} OS_STK_DATA;
#endif