• uC/OS-II全局变量定义


    /*
    *********************************************************************************************************
    *                                                uC/OS-II
    *                                          The Real-Time Kernel
    *
    *                            (c) Copyright 1992-2002, Jean J. Labrosse, Weston, FL
    *                                           All Rights Reserved
    *
    * File : uCOS_II.H
    * By   : Jean J. Labrosse
    *********************************************************************************************************
    */

    /*
    *********************************************************************************************************
    *                                             MISCELLANEOUS
    *********************************************************************************************************
    */

    #define  OS_VERSION              252                    /* Version of uC/OS-II (Vx.yy mult. by 100)    */

    #ifdef   OS_GLOBALS
    #define  OS_EXT
    #else
    #define  OS_EXT  extern
    #endif

    #ifndef  FALSE
    #define  FALSE                     0
    #endif

    #ifndef  TRUE
    #define  TRUE                      1
    #endif

    #define  OS_PRIO_SELF           0xFF                    /* Indicate SELF priority                      */

    #if OS_TASK_STAT_EN > 0
    #define  OS_N_SYS_TASKS            2                    /* Number of system tasks                      */
    #else
    #define  OS_N_SYS_TASKS            1
    #endif

    #define  OS_STAT_PRIO       (OS_LOWEST_PRIO - 1)        /* Statistic task priority                     */
    #define  OS_IDLE_PRIO       (OS_LOWEST_PRIO)            /* IDLE      task priority                     */

    #define  OS_EVENT_TBL_SIZE ((OS_LOWEST_PRIO) / 8 + 1)   /* Size of event table                         */
    #define  OS_RDY_TBL_SIZE   ((OS_LOWEST_PRIO) / 8 + 1)   /* Size of ready table                         */

    #define  OS_TASK_IDLE_ID       65535                    /* I.D. numbers for Idle and Stat tasks        */
    #define  OS_TASK_STAT_ID       65534

    #define  OS_EVENT_EN       (((OS_Q_EN > 0) && (OS_MAX_QS > 0)) || (OS_MBOX_EN > 0) || (OS_SEM_EN > 0) || (OS_MUTEX_EN > 0))

    /*$PAGE*/
    /*
    *********************************************************************************************************
    *                              TASK STATUS (Bit definition for OSTCBStat)
    *********************************************************************************************************
    */
    #define  OS_STAT_RDY            0x00        /* Ready to run                                            */
    #define  OS_STAT_SEM            0x01        /* Pending on semaphore                                    */
    #define  OS_STAT_MBOX           0x02        /* Pending on mailbox                                      */
    #define  OS_STAT_Q              0x04        /* Pending on queue                                        */
    #define  OS_STAT_SUSPEND        0x08        /* Task is suspended                                       */
    #define  OS_STAT_MUTEX          0x10        /* Pending on mutual exclusion semaphore                   */
    #define  OS_STAT_FLAG           0x20        /* Pending on event flag group                             */

    /*
    *********************************************************************************************************
    *                                        OS_EVENT types
    *********************************************************************************************************
    */
    #define  OS_EVENT_TYPE_UNUSED      0
    #define  OS_EVENT_TYPE_MBOX        1
    #define  OS_EVENT_TYPE_Q           2
    #define  OS_EVENT_TYPE_SEM         3
    #define  OS_EVENT_TYPE_MUTEX       4
    #define  OS_EVENT_TYPE_FLAG        5

    /*
    *********************************************************************************************************
    *                                         EVENT FLAGS
    *********************************************************************************************************
    */
    #define  OS_FLAG_WAIT_CLR_ALL      0        /* Wait for ALL    the bits specified to be CLR (i.e. 0)   */
    #define  OS_FLAG_WAIT_CLR_AND      0

    #define  OS_FLAG_WAIT_CLR_ANY      1        /* Wait for ANY of the bits specified to be CLR (i.e. 0)   */
    #define  OS_FLAG_WAIT_CLR_OR       1

    #define  OS_FLAG_WAIT_SET_ALL      2        /* Wait for ALL    the bits specified to be SET (i.e. 1)   */
    #define  OS_FLAG_WAIT_SET_AND      2

    #define  OS_FLAG_WAIT_SET_ANY      3        /* Wait for ANY of the bits specified to be SET (i.e. 1)   */
    #define  OS_FLAG_WAIT_SET_OR       3


    #define  OS_FLAG_CONSUME        0x80        /* Consume the flags if condition(s) satisfied             */


    #define  OS_FLAG_CLR               0
    #define  OS_FLAG_SET               1

    /*
    *********************************************************************************************************
    *       Possible values for 'opt' argument of OSSemDel(), OSMboxDel(), OSQDel() and OSMutexDel()
    *********************************************************************************************************
    */
    #define  OS_DEL_NO_PEND            0
    #define  OS_DEL_ALWAYS             1

    /*
    *********************************************************************************************************
    *                                     OS???PostOpt() OPTIONS
    *
    * These #defines are used to establish the options for OSMboxPostOpt() and OSQPostOpt().
    *********************************************************************************************************
    */
    #define  OS_POST_OPT_NONE       0x00        /* Post to highest priority task waiting                   */
    #define  OS_POST_OPT_BROADCAST  0x01        /* Broadcast message to ALL tasks waiting                  */  
    #define  OS_POST_OPT_FRONT      0x02        /* Post to highest priority task waiting                   */

    /*
    *********************************************************************************************************
    *                                 TASK OPTIONS (see OSTaskCreateExt())
    *********************************************************************************************************
    */
    #define  OS_TASK_OPT_STK_CHK  0x0001        /* Enable stack checking for the task                      */
    #define  OS_TASK_OPT_STK_CLR  0x0002        /* Clear the stack when the task is create                 */
    #define  OS_TASK_OPT_SAVE_FP  0x0004        /* Save the contents of any floating-point registers       */

    /*
    *********************************************************************************************************
    *                                             ERROR CODES
    *********************************************************************************************************
    */
    #define OS_NO_ERR                 0

    #define OS_ERR_EVENT_TYPE         1
    #define OS_ERR_PEND_ISR           2
    #define OS_ERR_POST_NULL_PTR      3
    #define OS_ERR_PEVENT_NULL        4
    #define OS_ERR_POST_ISR           5
    #define OS_ERR_QUERY_ISR          6
    #define OS_ERR_INVALID_OPT        7
    #define OS_ERR_TASK_WAITING       8

    #define OS_TIMEOUT               10
    #define OS_TASK_NOT_EXIST        11

    #define OS_MBOX_FULL             20

    #define OS_Q_FULL                30

    #define OS_PRIO_EXIST            40
    #define OS_PRIO_ERR              41
    #define OS_PRIO_INVALID          42

    #define OS_SEM_OVF               50

    #define OS_TASK_DEL_ERR          60
    #define OS_TASK_DEL_IDLE         61
    #define OS_TASK_DEL_REQ          62
    #define OS_TASK_DEL_ISR          63

    #define OS_NO_MORE_TCB           70

    #define OS_TIME_NOT_DLY          80
    #define OS_TIME_INVALID_MINUTES  81
    #define OS_TIME_INVALID_SECONDS  82
    #define OS_TIME_INVALID_MILLI    83
    #define OS_TIME_ZERO_DLY         84

    #define OS_TASK_SUSPEND_PRIO     90
    #define OS_TASK_SUSPEND_IDLE     91

    #define OS_TASK_RESUME_PRIO     100
    #define OS_TASK_NOT_SUSPENDED   101

    #define OS_MEM_INVALID_PART     110
    #define OS_MEM_INVALID_BLKS     111
    #define OS_MEM_INVALID_SIZE     112
    #define OS_MEM_NO_FREE_BLKS     113
    #define OS_MEM_FULL             114
    #define OS_MEM_INVALID_PBLK     115
    #define OS_MEM_INVALID_PMEM     116
    #define OS_MEM_INVALID_PDATA    117
    #define OS_MEM_INVALID_ADDR     118

    #define OS_ERR_NOT_MUTEX_OWNER  120

    #define OS_TASK_OPT_ERR         130

    #define OS_ERR_DEL_ISR          140
    #define OS_ERR_CREATE_ISR       141

    #define OS_FLAG_INVALID_PGRP    150
    #define OS_FLAG_ERR_WAIT_TYPE   151
    #define OS_FLAG_ERR_NOT_RDY     152
    #define OS_FLAG_INVALID_OPT     153
    #define OS_FLAG_GRP_DEPLETED    154

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

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


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

    #if (OS_VERSION >= 251) && (OS_FLAG_EN > 0) && (OS_MAX_FLAGS > 0)
    typedef struct {                            /* 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                                   */
    } OS_FLAG_GRP;    

        
        
    typedef struct {                            /* 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


    /*
    *********************************************************************************************************
    *                                          MESSAGE MAILBOX DATA
    *********************************************************************************************************
    */

    #if OS_MBOX_EN > 0
    typedef struct {
        void   *OSMsg;                         /* Pointer to message in mailbox                            */
        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  */
    } OS_MBOX_DATA;
    #endif

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

    #if (OS_MEM_EN > 0) && (OS_MAX_MEM_PART > 0)
    typedef struct {                       /* 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          */
    } OS_MEM;


    typedef struct {
        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 {
        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 */
        INT8U   OSValue;                        /* Mutex value (0 = used, 1 = 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 {
        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                                       */
        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     */
    } OS_Q_DATA;
    #endif

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

    #if OS_SEM_EN > 0
    typedef struct {
        INT16U  OSCnt;                          /* Semaphore count                                         */
        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 */
    } OS_SEM_DATA;
    #endif

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

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

    /*$PAGE*/
    /*
    *********************************************************************************************************
    *                                          TASK CONTROL BLOCK
    *********************************************************************************************************
    */

    typedef struct os_tcb {
        OS_STK        *OSTCBStkPtr;        /* Pointer to current top of stack                              */

    #if OS_TASK_CREATE_EXT_EN > 0
        void          *OSTCBExtPtr;        /* Pointer to user definable data for TCB extension             */
        OS_STK        *OSTCBStkBottom;     /* Pointer to bottom of stack                                   */
        INT32U         OSTCBStkSize;       /* Size of task stack (in number of stack elements)             */
        INT16U         OSTCBOpt;           /* Task options as passed by OSTaskCreateExt()                  */
        INT16U         OSTCBId;            /* Task ID (0..65535)                                           */
    #endif

        struct os_tcb *OSTCBNext;          /* Pointer to next     TCB in the TCB list                      */
        struct os_tcb *OSTCBPrev;          /* Pointer to previous TCB in the TCB list                      */

    #if ((OS_Q_EN > 0) && (OS_MAX_QS > 0)) || (OS_MBOX_EN > 0) || (OS_SEM_EN > 0) || (OS_MUTEX_EN > 0)
        OS_EVENT      *OSTCBEventPtr;      /* Pointer to event control block                               */
    #endif

    #if ((OS_Q_EN > 0) && (OS_MAX_QS > 0)) || (OS_MBOX_EN > 0)
        void          *OSTCBMsg;           /* Message received from OSMboxPost() or OSQPost()              */
    #endif

    #if (OS_VERSION >= 251) && (OS_FLAG_EN > 0) && (OS_MAX_FLAGS > 0)
    #if OS_TASK_DEL_EN > 0
        OS_FLAG_NODE  *OSTCBFlagNode;      /* Pointer to event flag node                                   */
    #endif    
        OS_FLAGS       OSTCBFlagsRdy;      /* Event flags that made task ready to run                      */
    #endif

        INT16U         OSTCBDly;           /* Nbr ticks to delay task or, timeout waiting for event        */
        INT8U          OSTCBStat;          /* Task status                                                  */
        INT8U          OSTCBPrio;          /* Task priority (0 == highest, 63 == lowest)                   */

        INT8U          OSTCBX;             /* Bit position in group  corresponding to task priority (0..7) */
        INT8U          OSTCBY;             /* Index into ready table corresponding to task priority        */
        INT8U          OSTCBBitX;          /* Bit mask to access bit position in ready table               */
        INT8U          OSTCBBitY;          /* Bit mask to access bit position in ready group               */

    #if OS_TASK_DEL_EN > 0
        BOOLEAN        OSTCBDelReq;        /* Indicates whether a task needs to delete itself              */
    #endif
    } OS_TCB;

    /*$PAGE*/
    /*
    *********************************************************************************************************
    *                                            GLOBAL VARIABLES
    *********************************************************************************************************
    */

    OS_EXT  INT32U            OSCtxSwCtr;               /* Counter of number of context switches           */

    #if (OS_EVENT_EN > 0) && (OS_MAX_EVENTS > 0)
    OS_EXT  OS_EVENT         *OSEventFreeList;          /* Pointer to list of free EVENT control blocks    */
    OS_EXT  OS_EVENT          OSEventTbl[OS_MAX_EVENTS];/* Table of EVENT control blocks                   */
    #endif

    #if (OS_VERSION >= 251) && (OS_FLAG_EN > 0) && (OS_MAX_FLAGS > 0)
    OS_EXT  OS_FLAG_GRP       OSFlagTbl[OS_MAX_FLAGS];  /* Table containing event flag groups              */
    OS_EXT  OS_FLAG_GRP      *OSFlagFreeList;           /* Pointer to free list of event flag groups       */
    #endif

    #if OS_TASK_STAT_EN > 0
    OS_EXT  INT8S             OSCPUUsage;               /* Percentage of CPU used                          */
    OS_EXT  INT32U            OSIdleCtrMax;             /* Max. value that idle ctr can take in 1 sec.     */
    OS_EXT  INT32U            OSIdleCtrRun;             /* Val. reached by idle ctr at run time in 1 sec.  */
    OS_EXT  BOOLEAN           OSStatRdy;                /* Flag indicating that the statistic task is rdy  */
    OS_EXT  OS_STK            OSTaskStatStk[OS_TASK_STAT_STK_SIZE];      /* Statistics task stack          */
    #endif

    OS_EXT  INT8U             OSIntNesting;             /* Interrupt nesting level                         */
    OS_EXT  INT8U             OSIntExitY;

    OS_EXT  INT8U             OSLockNesting;            /* Multitasking lock nesting level                 */

    OS_EXT  INT8U             OSPrioCur;                /* Priority of current task                        */
    OS_EXT  INT8U             OSPrioHighRdy;            /* Priority of highest priority task               */

    OS_EXT  INT8U             OSRdyGrp;                        /* Ready list group                         */
    OS_EXT  INT8U             OSRdyTbl[OS_RDY_TBL_SIZE];       /* Table of tasks which are ready to run    */

    OS_EXT  BOOLEAN           OSRunning;                       /* Flag indicating that kernel is running   */

    OS_EXT  INT8U             OSTaskCtr;                       /* Number of tasks created                  */

    OS_EXT  volatile  INT32U  OSIdleCtr;                                 /* Idle counter                   */

    OS_EXT  OS_STK            OSTaskIdleStk[OS_TASK_IDLE_STK_SIZE];      /* Idle task stack                */


    OS_EXT  OS_TCB           *OSTCBCur;                        /* Pointer to currently running TCB         */
    OS_EXT  OS_TCB           *OSTCBFreeList;                   /* Pointer to list of free TCBs             */
    OS_EXT  OS_TCB           *OSTCBHighRdy;                    /* Pointer to highest priority TCB R-to-R   */
    OS_EXT  OS_TCB           *OSTCBList;                       /* Pointer to doubly linked list of TCBs    */
    OS_EXT  OS_TCB           *OSTCBPrioTbl[OS_LOWEST_PRIO + 1];/* Table of pointers to created TCBs        */
    OS_EXT  OS_TCB            OSTCBTbl[OS_MAX_TASKS + OS_N_SYS_TASKS];   /* Table of TCBs                  */

    #if (OS_MEM_EN > 0) && (OS_MAX_MEM_PART > 0)
    OS_EXT  OS_MEM           *OSMemFreeList;            /* Pointer to free list of memory partitions       */
    OS_EXT  OS_MEM            OSMemTbl[OS_MAX_MEM_PART];/* Storage for memory partition manager            */
    #endif

    #if (OS_Q_EN > 0) && (OS_MAX_QS > 0)
    OS_EXT  OS_Q             *OSQFreeList;              /* Pointer to list of free QUEUE control blocks    */
    OS_EXT  OS_Q              OSQTbl[OS_MAX_QS];        /* Table of QUEUE control blocks                   */
    #endif

    #if OS_TIME_GET_SET_EN > 0   
    OS_EXT  volatile  INT32U  OSTime;                   /* Current value of system time (in ticks)         */
    #endif

    extern  INT8U  const      OSMapTbl[];               /* Priority->Bit Mask lookup table                 */
    extern  INT8U  const      OSUnMapTbl[];             /* Priority->Index    lookup table                 */

    /*$PAGE*/
    /*
    *********************************************************************************************************
    *                                          FUNCTION PROTOTYPES
    *                                     (Target Independent Functions)
    *********************************************************************************************************
    */

    /*
    *********************************************************************************************************
    *                                         EVENT FLAGS MANAGEMENT
    *********************************************************************************************************
    */

    #if (OS_VERSION >= 251) && (OS_FLAG_EN > 0) && (OS_MAX_FLAGS > 0)

    #if OS_FLAG_ACCEPT_EN > 0
    OS_FLAGS      OSFlagAccept(OS_FLAG_GRP *pgrp, OS_FLAGS flags, INT8U wait_type, INT8U *err);
    #endif

    OS_FLAG_GRP  *OSFlagCreate(OS_FLAGS flags, INT8U *err);

    #if OS_FLAG_DEL_EN > 0
    OS_FLAG_GRP  *OSFlagDel(OS_FLAG_GRP *pgrp, INT8U opt, INT8U *err);
    #endif

    OS_FLAGS      OSFlagPend(OS_FLAG_GRP *pgrp, OS_FLAGS flags, INT8U wait_type, INT16U timeout, INT8U *err);
    OS_FLAGS      OSFlagPost(OS_FLAG_GRP *pgrp, OS_FLAGS flags, INT8U operation, INT8U *err);

    #if OS_FLAG_QUERY_EN > 0
    OS_FLAGS      OSFlagQuery(OS_FLAG_GRP *pgrp, INT8U *err);
    #endif
    #endif

    /*
    *********************************************************************************************************
    *                                        MESSAGE MAILBOX MANAGEMENT
    *********************************************************************************************************
    */

    #if OS_MBOX_EN > 0

    #if OS_MBOX_ACCEPT_EN > 0
    void         *OSMboxAccept(OS_EVENT *pevent);
    #endif

    OS_EVENT     *OSMboxCreate(void *msg);

    #if OS_MBOX_DEL_EN > 0
    OS_EVENT     *OSMboxDel(OS_EVENT *pevent, INT8U opt, INT8U *err);
    #endif

    void         *OSMboxPend(OS_EVENT *pevent, INT16U timeout, INT8U *err);

    #if OS_MBOX_POST_EN > 0
    INT8U         OSMboxPost(OS_EVENT *pevent, void *msg);
    #endif

    #if OS_MBOX_POST_OPT_EN > 0
    INT8U         OSMboxPostOpt(OS_EVENT *pevent, void *msg, INT8U opt);
    #endif

    #if OS_MBOX_QUERY_EN > 0
    INT8U         OSMboxQuery(OS_EVENT *pevent, OS_MBOX_DATA *pdata);
    #endif
    #endif

    /*
    *********************************************************************************************************
    *                                           MEMORY MANAGEMENT
    *********************************************************************************************************
    */

    #if (OS_MEM_EN > 0) && (OS_MAX_MEM_PART > 0)

    OS_MEM       *OSMemCreate(void *addr, INT32U nblks, INT32U blksize, INT8U *err);
    void         *OSMemGet(OS_MEM *pmem, INT8U *err);
    INT8U         OSMemPut(OS_MEM *pmem, void *pblk);

    #if OS_MEM_QUERY_EN > 0
    INT8U         OSMemQuery(OS_MEM *pmem, OS_MEM_DATA *pdata);
    #endif

    #endif

    /*
    *********************************************************************************************************
    *                                MUTUAL EXCLUSION SEMAPHORE MANAGEMENT
    *********************************************************************************************************
    */

    #if OS_MUTEX_EN > 0

    #if OS_MUTEX_ACCEPT_EN > 0
    INT8U         OSMutexAccept(OS_EVENT *pevent, INT8U *err);
    #endif

    OS_EVENT     *OSMutexCreate(INT8U prio, INT8U *err);

    #if OS_MUTEX_DEL_EN > 0
    OS_EVENT     *OSMutexDel(OS_EVENT *pevent, INT8U opt, INT8U *err);
    #endif

    void          OSMutexPend(OS_EVENT *pevent, INT16U timeout, INT8U *err);
    INT8U         OSMutexPost(OS_EVENT *pevent);

    #if OS_MUTEX_QUERY_EN > 0
    INT8U         OSMutexQuery(OS_EVENT *pevent, OS_MUTEX_DATA *pdata);
    #endif

    #endif

    /*$PAGE*/
    /*
    *********************************************************************************************************
    *                                         MESSAGE QUEUE MANAGEMENT
    *********************************************************************************************************
    */

    #if (OS_Q_EN > 0) && (OS_MAX_QS > 0)

    #if OS_Q_ACCEPT_EN > 0
    void         *OSQAccept(OS_EVENT *pevent);
    #endif

    OS_EVENT     *OSQCreate(void **start, INT16U size);

    #if OS_Q_DEL_EN > 0
    OS_EVENT     *OSQDel(OS_EVENT *pevent, INT8U opt, INT8U *err);
    #endif

    #if OS_Q_FLUSH_EN > 0
    INT8U         OSQFlush(OS_EVENT *pevent);
    #endif

    void         *OSQPend(OS_EVENT *pevent, INT16U timeout, INT8U *err);

    #if OS_Q_POST_EN > 0
    INT8U         OSQPost(OS_EVENT *pevent, void *msg);
    #endif

    #if OS_Q_POST_FRONT_EN > 0
    INT8U         OSQPostFront(OS_EVENT *pevent, void *msg);
    #endif

    #if OS_Q_POST_OPT_EN > 0
    INT8U         OSQPostOpt(OS_EVENT *pevent, void *msg, INT8U opt);
    #endif

    #if OS_Q_QUERY_EN > 0
    INT8U         OSQQuery(OS_EVENT *pevent, OS_Q_DATA *pdata);
    #endif

    #endif

    /*$PAGE*/
    /*
    *********************************************************************************************************
    *                                          SEMAPHORE MANAGEMENT
    *********************************************************************************************************
    */
    #if OS_SEM_EN > 0

    #if OS_SEM_ACCEPT_EN > 0
    INT16U        OSSemAccept(OS_EVENT *pevent);
    #endif

    OS_EVENT     *OSSemCreate(INT16U cnt);

    #if OS_SEM_DEL_EN > 0
    OS_EVENT     *OSSemDel(OS_EVENT *pevent, INT8U opt, INT8U *err);
    #endif

    void          OSSemPend(OS_EVENT *pevent, INT16U timeout, INT8U *err);
    INT8U         OSSemPost(OS_EVENT *pevent);

    #if OS_SEM_QUERY_EN > 0
    INT8U         OSSemQuery(OS_EVENT *pevent, OS_SEM_DATA *pdata);
    #endif

    #endif

    /*$PAGE*/
    /*
    *********************************************************************************************************
    *                                            TASK MANAGEMENT
    *********************************************************************************************************
    */
    #if OS_TASK_CHANGE_PRIO_EN > 0
    INT8U         OSTaskChangePrio(INT8U oldprio, INT8U newprio);
    #endif

    #if OS_TASK_CREATE_EN > 0
    INT8U         OSTaskCreate(void (*task)(void *pd), void *pdata, OS_STK *ptos, INT8U prio);
    #endif

    #if OS_TASK_CREATE_EXT_EN > 0
    INT8U         OSTaskCreateExt(void  (*task)(void *pd),
                                  void   *pdata,
                                  OS_STK *ptos,
                                  INT8U   prio,
                                  INT16U  id,
                                  OS_STK *pbos,
                                  INT32U  stk_size,
                                  void   *pext,
                                  INT16U  opt);
    #endif

    #if OS_TASK_DEL_EN > 0
    INT8U         OSTaskDel(INT8U prio);
    INT8U         OSTaskDelReq(INT8U prio);
    #endif

    #if OS_TASK_SUSPEND_EN > 0
    INT8U         OSTaskResume(INT8U prio);
    INT8U         OSTaskSuspend(INT8U prio);
    #endif

    #if OS_TASK_CREATE_EXT_EN > 0
    INT8U         OSTaskStkChk(INT8U prio, OS_STK_DATA *pdata);
    #endif

    #if OS_TASK_QUERY_EN > 0
    INT8U         OSTaskQuery(INT8U prio, OS_TCB *pdata);
    #endif

    /*$PAGE*/
    /*
    *********************************************************************************************************
    *                                            TIME MANAGEMENT
    *********************************************************************************************************
    */

    void          OSTimeDly(INT16U ticks);

    #if OS_TIME_DLY_HMSM_EN > 0
    INT8U         OSTimeDlyHMSM(INT8U hours, INT8U minutes, INT8U seconds, INT16U milli);
    #endif

    #if OS_TIME_DLY_RESUME_EN > 0
    INT8U         OSTimeDlyResume(INT8U prio);
    #endif

    #if OS_TIME_GET_SET_EN > 0
    INT32U        OSTimeGet(void);
    void          OSTimeSet(INT32U ticks);
    #endif

    void          OSTimeTick(void);

    /*
    *********************************************************************************************************
    *                                             MISCELLANEOUS
    *********************************************************************************************************
    */

    void          OSInit(void);

    void          OSIntEnter(void);
    void          OSIntExit(void);

    #if OS_SCHED_LOCK_EN > 0
    void          OSSchedLock(void);
    void          OSSchedUnlock(void);
    #endif

    void          OSStart(void);

    void          OSStatInit(void);

    INT16U        OSVersion(void);

    /*$PAGE*/
    /*
    *********************************************************************************************************
    *                                      INTERNAL FUNCTION PROTOTYPES
    *                            (Your application MUST NOT call these functions)
    *********************************************************************************************************
    */

    #if OS_TASK_DEL_EN > 0
    void          OS_Dummy(void);
    #endif

    #if ((OS_Q_EN > 0) && (OS_MAX_QS > 0)) || (OS_MBOX_EN > 0) || (OS_SEM_EN > 0) || (OS_MUTEX_EN > 0)
    INT8U         OS_EventTaskRdy(OS_EVENT *pevent, void *msg, INT8U msk);
    void          OS_EventTaskWait(OS_EVENT *pevent);
    void          OS_EventTO(OS_EVENT *pevent);
    void          OS_EventWaitListInit(OS_EVENT *pevent);
    #endif

    #if (OS_VERSION >= 251) && (OS_FLAG_EN > 0) && (OS_MAX_FLAGS > 0)
    void          OS_FlagInit(void);
    void          OS_FlagUnlink(OS_FLAG_NODE *pnode);
    #endif

    #if (OS_MEM_EN > 0) && (OS_MAX_MEM_PART > 0)
    void          OS_MemInit(void);
    #endif

    #if OS_Q_EN > 0
    void          OS_QInit(void);
    #endif

    void          OS_Sched(void);

    void          OS_TaskIdle(void *data);

    #if OS_TASK_STAT_EN > 0
    void          OS_TaskStat(void *data);
    #endif

    INT8U         OS_TCBInit(INT8U prio, OS_STK *ptos, OS_STK *pbos, INT16U id, INT32U stk_size, void *pext, INT16U opt);

    /*$PAGE*/
    /*
    *********************************************************************************************************
    *                                          FUNCTION PROTOTYPES
    *                                      (Target Specific Functions)
    *********************************************************************************************************
    */

    #if OS_VERSION >= 204
    void          OSInitHookBegin(void);
    void          OSInitHookEnd(void);
    #endif

    void          OSIntCtxSw(void);

    void          OSStartHighRdy(void);

    void          OSTaskCreateHook(OS_TCB *ptcb);
    void          OSTaskDelHook(OS_TCB *ptcb);

    #if OS_VERSION >= 251
    void          OSTaskIdleHook(void);
    #endif

    void          OSTaskStatHook(void);
    OS_STK       *OSTaskStkInit(void (*task)(void *pd), void *pdata, OS_STK *ptos, INT16U opt);
    void          OSTaskSwHook(void);

    #if OS_VERSION >= 204
    void          OSTCBInitHook(OS_TCB *ptcb);
    #endif

    void          OSTimeTickHook(void);

    /*
    *********************************************************************************************************
    *                                          FUNCTION PROTOTYPES
    *                                  (Compiler Specific ISR prototypes)
    *********************************************************************************************************
    */

    #ifndef OS_ISR_PROTO_EXT
    void          OSCtxSw(void);
    void          OSTickISR(void);
    #endif

    /*$PAGE*/
    /*
    *********************************************************************************************************
    *                                   LOOK FOR MISSING #define CONSTANTS
    *
    * This section is used to generate ERROR messages at compile time if certain #define constants are
    * MISSING in OS_CFG.H.  This allows you to quickly determine the source of the error.
    *
    * You SHOULD NOT change this section UNLESS you would like to add more comments as to the source of the
    * compile time error.
    *********************************************************************************************************
    */

    /*
    *********************************************************************************************************
    *                                            EVENT FLAGS
    *********************************************************************************************************
    */

    #ifndef OS_FLAG_EN
    #error  "OS_CFG.H, Missing OS_FLAG_EN: Enable (1) or Disable (0) code generation for Event Flags"
    #else
        #ifndef OS_MAX_FLAGS
        #error  "OS_CFG.H, Missing OS_MAX_FLAGS: Max. number of Event Flag Groups in your application"
        #else
            #if     OS_MAX_FLAGS == 0
            #error  "OS_CFG.H, OS_MAX_FLAGS must be > 0"
            #endif
            #if     OS_MAX_FLAGS > 255
            #error  "OS_CFG.H, OS_MAX_FLAGS must be <= 255"
            #endif
        #endif

        #ifndef OS_FLAG_WAIT_CLR_EN
        #error  "OS_CFG.H, Missing OS_FLAG_WAIT_CLR_EN: Include code for Wait on Clear EVENT FLAGS"
        #endif

        #ifndef OS_FLAG_ACCEPT_EN
        #error  "OS_CFG.H, Missing OS_FLAG_ACCEPT_EN: Include code for OSFlagAccept()"
        #endif

        #ifndef OS_FLAG_DEL_EN
        #error  "OS_CFG.H, Missing OS_FLAG_DEL_EN: Include code for OSFlagDel()"
        #endif

        #ifndef OS_FLAG_QUERY_EN
        #error  "OS_CFG.H, Missing OS_FLAG_QUERY_EN: Include code for OSFlagQuery()"
        #endif
    #endif

    /*
    *********************************************************************************************************
    *                                           MESSAGE MAILBOXES
    *********************************************************************************************************
    */

    #ifndef OS_MBOX_EN
    #error  "OS_CFG.H, Missing OS_MBOX_EN: Enable (1) or Disable (0) code generation for MAILBOXES"
    #else
        #ifndef OS_MBOX_ACCEPT_EN
        #error  "OS_CFG.H, Missing OS_MBOX_ACCEPT_EN: Include code for OSMboxAccept()"
        #endif

        #ifndef OS_MBOX_DEL_EN
        #error  "OS_CFG.H, Missing OS_MBOX_DEL_EN: Include code for OSMboxDel()"
        #endif

        #ifndef OS_MBOX_POST_EN
        #error  "OS_CFG.H, Missing OS_MBOX_POST_EN: Include code for OSMboxPost()"
        #endif

        #ifndef OS_MBOX_POST_OPT_EN
        #error  "OS_CFG.H, Missing OS_MBOX_POST_OPT_EN: Include code for OSMboxPostOpt()"
        #endif

        #ifndef OS_MBOX_QUERY_EN
        #error  "OS_CFG.H, Missing OS_MBOX_QUERY_EN: Include code for OSMboxQuery()"
        #endif
    #endif

    /*
    *********************************************************************************************************
    *                                           MEMORY MANAGEMENT
    *********************************************************************************************************
    */

    #ifndef OS_MEM_EN
    #error  "OS_CFG.H, Missing OS_MEM_EN: Enable (1) or Disable (0) code generation for MEMORY MANAGER"
    #else
        #ifndef OS_MAX_MEM_PART
        #error  "OS_CFG.H, Missing OS_MAX_MEM_PART: Max. number of memory partitions"
        #else
            #if     OS_MAX_MEM_PART == 0
            #error  "OS_CFG.H, OS_MAX_MEM_PART must be > 0"
            #endif
            #if     OS_MAX_MEM_PART > 255
            #error  "OS_CFG.H, OS_MAX_MEM_PART must be <= 255"
            #endif
        #endif

        #ifndef OS_MEM_QUERY_EN
        #error  "OS_CFG.H, Missing OS_MEM_QUERY_EN: Include code for OSMemQuery()"
        #endif
    #endif

    /*
    *********************************************************************************************************
    *                                       MUTUAL EXCLUSION SEMAPHORES
    *********************************************************************************************************
    */

    #ifndef OS_MUTEX_EN
    #error  "OS_CFG.H, Missing OS_MUTEX_EN: Enable (1) or Disable (0) code generation for MUTEX"
    #else
        #ifndef OS_MUTEX_ACCEPT_EN
        #error  "OS_CFG.H, Missing OS_MUTEX_ACCEPT_EN: Include code for OSMutexAccept()"
        #endif

        #ifndef OS_MUTEX_DEL_EN
        #error  "OS_CFG.H, Missing OS_MUTEX_DEL_EN: Include code for OSMutexDel()"
        #endif

        #ifndef OS_MUTEX_QUERY_EN
        #error  "OS_CFG.H, Missing OS_MUTEX_QUERY_EN: Include code for OSMutexQuery()"
        #endif
    #endif

    /*
    *********************************************************************************************************
    *                                              MESSAGE QUEUES
    *********************************************************************************************************
    */

    #ifndef OS_Q_EN
    #error  "OS_CFG.H, Missing OS_Q_EN: Enable (1) or Disable (0) code generation for QUEUES"
    #else
        #ifndef OS_MAX_QS
        #error  "OS_CFG.H, Missing OS_MAX_QS: Max. number of queue control blocks"
        #else
            #if     OS_MAX_QS == 0
            #error  "OS_CFG.H, OS_MAX_QS must be > 0"
            #endif
            #if     OS_MAX_QS > 255
            #error  "OS_CFG.H, OS_MAX_QS must be <= 255"
            #endif
        #endif

        #ifndef OS_Q_ACCEPT_EN
        #error  "OS_CFG.H, Missing OS_Q_ACCEPT_EN: Include code for OSQAccept()"
        #endif

        #ifndef OS_Q_DEL_EN
        #error  "OS_CFG.H, Missing OS_Q_DEL_EN: Include code for OSQDel()"
        #endif

        #ifndef OS_Q_FLUSH_EN
        #error  "OS_CFG.H, Missing OS_Q_FLUSH_EN: Include code for OSQFlush()"
        #endif

        #ifndef OS_Q_POST_EN
        #error  "OS_CFG.H, Missing OS_Q_POST_EN: Include code for OSQPost()"
        #endif

        #ifndef OS_Q_POST_FRONT_EN
        #error  "OS_CFG.H, Missing OS_Q_POST_FRONT_EN: Include code for OSQPostFront()"
        #endif

        #ifndef OS_Q_POST_OPT_EN
        #error  "OS_CFG.H, Missing OS_Q_POST_OPT_EN: Include code for OSQPostOpt()"
        #endif

        #ifndef OS_Q_QUERY_EN
        #error  "OS_CFG.H, Missing OS_Q_QUERY_EN: Include code for OSQQuery()"
        #endif
    #endif

    /*
    *********************************************************************************************************
    *                                              SEMAPHORES
    *********************************************************************************************************
    */

    #ifndef OS_SEM_EN
    #error  "OS_CFG.H, Missing OS_SEM_EN: Enable (1) or Disable (0) code generation for SEMAPHORES"
    #else
        #ifndef OS_SEM_ACCEPT_EN
        #error  "OS_CFG.H, Missing OS_SEM_ACCEPT_EN: Include code for OSSemAccept()"
        #endif

        #ifndef OS_SEM_DEL_EN
        #error  "OS_CFG.H, Missing OS_SEM_DEL_EN: Include code for OSSemDel()"
        #endif

        #ifndef OS_SEM_QUERY_EN
        #error  "OS_CFG.H, Missing OS_SEM_QUERY_EN: Include code for OSSemQuery()"
        #endif
    #endif

    /*
    *********************************************************************************************************
    *                                             TASK MANAGEMENT
    *********************************************************************************************************
    */

    #ifndef OS_MAX_TASKS
    #error  "OS_CFG.H, Missing OS_MAX_TASKS: Max. number of tasks in your application"
    #else
        #if     OS_MAX_TASKS == 0
        #error  "OS_CFG.H,         OS_MAX_TASKS must be >= 2"
        #endif
        #if     OS_MAX_TASKS > 63
        #error  "OS_CFG.H,         OS_MAX_TASKS must be <= 63"
        #endif
    #endif

    #ifndef OS_TASK_IDLE_STK_SIZE
    #error  "OS_CFG.H, Missing OS_TASK_IDLE_STK_SIZE: Idle task stack size"
    #endif

    #ifndef OS_TASK_STAT_EN
    #error  "OS_CFG.H, Missing OS_TASK_STAT_EN: Enable (1) or Disable(0) the statistics task"
    #endif

    #ifndef OS_TASK_STAT_STK_SIZE
    #error  "OS_CFG.H, Missing OS_TASK_STAT_STK_SIZE: Statistics task stack size"
    #endif

    #ifndef OS_TASK_CHANGE_PRIO_EN
    #error  "OS_CFG.H, Missing OS_TASK_CHANGE_PRIO_EN: Include code for OSTaskChangePrio()"
    #endif

    #ifndef OS_TASK_CREATE_EN
    #error  "OS_CFG.H, Missing OS_TASK_CREATE_EN: Include code for OSTaskCreate()"
    #endif

    #ifndef OS_TASK_CREATE_EXT_EN
    #error  "OS_CFG.H, Missing OS_TASK_CREATE_EXT_EN: Include code for OSTaskCreateExt()"
    #endif

    #ifndef OS_TASK_DEL_EN
    #error  "OS_CFG.H, Missing OS_TASK_DEL_EN: Include code for OSTaskDel()"
    #endif

    #ifndef OS_TASK_SUSPEND_EN
    #error  "OS_CFG.H, Missing OS_TASK_SUSPEND_EN: Include code for OSTaskSuspend() and OSTaskResume()"
    #endif

    #ifndef OS_TASK_QUERY_EN
    #error  "OS_CFG.H, Missing OS_TASK_QUERY_EN: Include code for OSTaskQuery()"
    #endif

    /*
    *********************************************************************************************************
    *                                             TIME MANAGEMENT
    *********************************************************************************************************
    */

    #ifndef OS_TICKS_PER_SEC
    #error  "OS_CFG.H, Missing OS_TICKS_PER_SEC: Sets the number of ticks in one second"
    #endif

    #ifndef OS_TIME_DLY_HMSM_EN
    #error  "OS_CFG.H, Missing OS_TIME_DLY_HMSM_EN: Include code for OSTimeDlyHMSM()"
    #endif

    #ifndef OS_TIME_DLY_RESUME_EN
    #error  "OS_CFG.H, Missing OS_TIME_DLY_RESUME_EN: Include code for OSTimeDlyResume()"
    #endif

    #ifndef OS_TIME_GET_SET_EN
    #error  "OS_CFG.H, Missing OS_TIME_GET_SET_EN: Include code for OSTimeGet() and OSTimeSet()"
    #endif

    /*
    *********************************************************************************************************
    *                                            MISCELLANEOUS
    *********************************************************************************************************
    */

    #ifndef OS_MAX_EVENTS
    #error  "OS_CFG.H, Missing OS_MAX_EVENTS: Max. number of event control blocks in your application"
    #else
        #if     OS_MAX_EVENTS == 0
        #error  "OS_CFG.H, OS_MAX_EVENTS must be > 0"
        #endif
        #if     OS_MAX_EVENTS > 255
        #error  "OS_CFG.H, OS_MAX_EVENTS must be <= 255"
        #endif
    #endif

    #ifndef OS_LOWEST_PRIO
    #error  "OS_CFG.H, Missing OS_LOWEST_PRIO: Defines the lowest priority that can be assigned"
    #endif

    #ifndef OS_ARG_CHK_EN
    #error  "OS_CFG.H, Missing OS_ARG_CHK_EN: Enable (1) or Disable (0) argument checking"
    #endif

    #ifndef OS_CPU_HOOKS_EN
    #error  "OS_CFG.H, Missing OS_CPU_HOOKS_EN: uC/OS-II hooks are found in the processor port files when 1"
    #endif

    #ifndef OS_SCHED_LOCK_EN
    #error  "OS_CFG.H, Missing OS_SCHED_LOCK_EN: Include code for OSSchedLock() and OSSchedUnlock()"
    #endif

  • 相关阅读:
    计算机网络通信
    javap查看class文件
    JDK动态代理与CGLib动态代理
    error the @annotation pointcut expression is only supported at Java 5 compliance
    redis清空缓存
    利用HttpURLConnection发送请求
    linux下用命令导出mysql表数据
    adb push和pull使用
    mysqld.exe占比cpu 100% 解决方案
    养成好习惯
  • 原文地址:https://www.cnblogs.com/wxb20/p/6230858.html
Copyright © 2020-2023  润新知