UCOS-III 主要全局变量及数据结构详解

TechIoT

已于 2024-07-31 06:34:26 修改

阅读量851

点赞数 11

分类专栏： UCOS-III 文章标签：实时操作系统 UCOS 嵌入式

于 2024-07-31 06:32:49 首次发布

本文链接：https://blog.csdn.net/sensorfeng/article/details/140811945

版权

UCOS-III 专栏收录该内容

26 篇文章 0 订阅

订阅专栏

UCOS-III 是一个功能强大且广泛使用的实时操作系统。了解其主要全局变量和数据结构对有效使用和优化系统性能至关重要。本文将详细介绍UCOS-III中的主要全局变量及关键数据结构，并对每个成员进行详细解析。

1. 全局变量

1.1 应用程序钩子

#if (OS_CFG_TASK_STK_REDZONE_EN > 0u)
OS_EXT           OS_APP_HOOK_TCB            OS_AppRedzoneHitHookPtr;
#endif
OS_EXT           OS_APP_HOOK_TCB            OS_AppTaskCreateHookPtr;
OS_EXT           OS_APP_HOOK_TCB            OS_AppTaskDelHookPtr;
OS_EXT           OS_APP_HOOK_TCB            OS_AppTaskReturnHookPtr;

OS_EXT           OS_APP_HOOK_VOID           OS_AppIdleTaskHookPtr;
OS_EXT           OS_APP_HOOK_VOID           OS_AppStatTaskHookPtr;
OS_EXT           OS_APP_HOOK_VOID           OS_AppTaskSwHookPtr;
OS_EXT           OS_APP_HOOK_VOID           OS_AppTimeTickHookPtr;

OS_AppRedzoneHitHookPtr：当任务堆栈超出警戒区域时调用
OS_AppTaskCreateHookPtr：任务创建时调用
OS_AppTaskDelHookPtr：任务删除时调用
OS_AppTaskReturnHookPtr：任务返回时调用
OS_AppIdleTaskHookPtr：空闲任务执行时调用
OS_AppStatTaskHookPtr：统计任务执行时调用
OS_AppTaskSwHookPtr：任务切换时调用
OS_AppTimeTickHookPtr：时钟节拍发生时调用

1.2 空闲任务

OS_TCB OSIdleTaskTCB;

OSIdleTaskTCB：保存系统空闲任务的任务控制块（TCB）

1.3 计数及标志

OS_NESTING_CTR OSIntNestingCtr;
OS_STATE OSRunning;
OS_STATE OSInitialized;

OSIntNestingCtr：中断嵌套计数器
OSRunning：指示操作系统是否正在运行的状态
OSInitialized：指示操作系统是否已初始化的状态

1.4 事件标志（Event Flags）

OS_FLAG_GRP OSFlagDbgListPtr;
OS_OBJ_QTY OSFlagQty;

OSFlagDbgListPtr：指向事件标志组的调试列表的指针。
OSFlagQty：系统中事件标志组的数量。

1.5 内存管理（Memory Management）

OS_MEM OSMemDbgListPtr;
OS_OBJ_QTY OSMemQty;

OSMemDbgListPtr：指向内存分区调试列表的指针。
OSMemQty：系统中内存分区的数量。

1.6 消息池（Message Pool）

OS_MSG_POOL OSMsgPool;

OSMsgPool：用于消息管理的消息池

1.7 互斥信号量（Mutex Management）

OS_MUTEX OSMutexDbgListPtr;
OS_OBJ_QTY OSMutexQty;

OSMutexDbgListPtr：指向互斥信号量调试列表的指针
OSMutexQty：系统中互斥信号量的数量

1.8 优先级（Priorities）

OS_PRIO OSPrioCur;
OS_PRIO OSPrioHighRdy;
CPU_DATA OSPrioTbl[OS_CFG_PRIO_TBL_SIZE];

OSPrioCur：当前任务的优先级
OSPrioHighRdy：最高优先级就绪任务的优先级
OSPrioTbl：优先级表

1.9 就绪列表（Ready List）

OS_RDY_LIST OSRdyList[OS_CFG_PRIO_MAX];

OSRdyList：就绪任务列表，根据优先级存储任务

1.10 任务调度（Scheduler）

CPU_TS_TMR OSSchedLockTimeBegin;
CPU_TS_TMR OSSchedLockTimeMax;
CPU_TS_TMR OSSchedLockTimeMaxCur;
OS_NESTING_CTR OSSchedLockNestingCtr;
OS_TICK OSSchedRoundRobinDfltTimeQuanta;
CPU_BOOLEAN OSSchedRoundRobinEn;

OSSchedLockTimeBegin：调度锁定时间开始时间戳
OSSchedLockTimeMax：调度锁定的最大时间
OSSchedLockTimeMaxCur：当前调度锁定的最大时间
OSSchedLockNestingCtr：调度锁定嵌套计数器
OSSchedRoundRobinDfltTimeQuanta：轮转调度的默认时间片

1.11 任务（Tasks）

OS_OBJ_QTY OSTaskQty;
OS_CTX_SW_CTR OSTaskCtxSwCtr;
OS_TCB OSTaskDbgListPtr;
OS_REG_ID OSTaskRegNextAvailID;

OSTaskQty：系统中任务的数量
OSTaskCtxSwCtr：任务上下文切换计数器
OSTaskDbgListPtr：指向任务调试列表的指针
OSTaskRegNextAvailID：下一个可用的任务寄存器ID

1.12 时钟节拍（Tick）

OS_TICK OSTickCtr;
OS_TICK_LIST OSTickList;
CPU_TS OSTickTime;
CPU_TS OSTickTimeMax;

OSTickCtr：系统启动以来的时钟节拍计数器
OSTickList：时钟节拍列表
OSTickTime：当前时钟节拍的时间戳
OSTickTimeMax：最大时钟节拍时间

1.13 定时器（Timers）

OS_TMR OSTmrListPtr;
OS_COND OSTmrCond;
OS_MUTEX OSTmrMutex;
OS_TCB OSTmrTaskTCB;
CPU_TS OSTmrTaskTime;
CPU_TS OSTmrTaskTimeMax;
OS_TICK OSTmrTaskTickBase;
OS_TICK OSTmrToTicksMult;

OSTmrListPtr：指向定时器列表的指针
OSTmrCond：定时器条件变量
OSTmrMutex：定时器互斥信号量
OSTmrTaskTCB：定时器任务的任务控制块
OSTmrTaskTime：定时器任务的时间戳
OSTmrTaskTimeMax：定时器任务的最大时间
OSTmrTaskTickBase：定时器任务的基础节拍
OSTmrToTicksMult：定时器时间转换为节拍的乘数

1.14 任务控制块

OS_TCB OSTCBCurPtr;
OS_TCB OSTCBHighRdyPtr;

OSTCBCurPtr：指向当前运行任务的任务控制块的指针
OSTCBHighRdyPtr：指向最高优先级就绪任务的任务控制块的指针

2. 数据结构

2.1 任务控制块（OS_TCB）


struct os_tcb {
    CPU_STK             *StkPtr;                            /* Pointer to current top of stack                        */

    void                *ExtPtr;                            /* Pointer to user definable data for TCB extension       */

    CPU_STK             *StkLimitPtr;                       /* Pointer used to set stack 'watermark' limit            */

#if (OS_CFG_DBG_EN > 0u)
    CPU_CHAR            *NamePtr;                           /* Pointer to task name                                   */
#endif

    OS_TCB              *NextPtr;                           /* Pointer to next     TCB in the TCB list                */
    OS_TCB              *PrevPtr;                           /* Pointer to previous TCB in the TCB list                */

#if (OS_CFG_TICK_EN > 0u)
    OS_TCB              *TickNextPtr;
    OS_TCB              *TickPrevPtr;
#endif

#if ((OS_CFG_DBG_EN > 0u) || (OS_CFG_STAT_TASK_STK_CHK_EN > 0u) || (OS_CFG_TASK_STK_REDZONE_EN > 0u))
    CPU_STK             *StkBasePtr;                        /* Pointer to base address of stack                       */
#endif 

#if defined(OS_CFG_TLS_TBL_SIZE) && (OS_CFG_TLS_TBL_SIZE > 0u)
    OS_TLS               TLS_Tbl[OS_CFG_TLS_TBL_SIZE];
#endif

#if (OS_CFG_DBG_EN > 0u)
    OS_TASK_PTR          TaskEntryAddr;                     /* Pointer to task entry point address                    */
    void                *TaskEntryArg;                      /* Argument passed to task when it was created            */
#endif

    OS_TCB              *PendNextPtr;                       /* Pointer to next     TCB in pend list.                  */
    OS_TCB              *PendPrevPtr;                       /* Pointer to previous TCB in pend list.                  */
    OS_PEND_OBJ         *PendObjPtr;                        /* Pointer to object pended on.                           */
    OS_STATE             PendOn;                            /* Indicates what task is pending on                      */
    OS_STATUS            PendStatus;                        /* Pend status                                            */

    OS_STATE             TaskState;                         /* See OS_TASK_STATE_xxx                                  */
    OS_PRIO              Prio;                              /* Task priority (0 == highest)                           */
#if (OS_CFG_MUTEX_EN > 0u)
    OS_PRIO              BasePrio;                          /* Base priority (Not inherited)                          */
    OS_MUTEX            *MutexGrpHeadPtr;                   /* Owned mutex group head pointer                         */
#endif

#if ((OS_CFG_DBG_EN > 0u) || (OS_CFG_STAT_TASK_STK_CHK_EN > 0u) || (OS_CFG_TASK_STK_REDZONE_EN > 0u))
    CPU_STK_SIZE         StkSize;                           /* Size of task stack (in number of stack elements)       */
#endif
    OS_OPT               Opt;                               /* Task options as passed by OSTaskCreate()               */

#if (OS_CFG_TS_EN > 0u)
    CPU_TS               TS;                                /* Timestamp                                              */
#endif
#if (defined(OS_CFG_TRACE_EN) && (OS_CFG_TRACE_EN > 0u))
    CPU_ADDR             SemID;                             /* Unique ID for third-party debuggers and tracers.       */
#endif
    OS_SEM_CTR           SemCtr;                            /* Task specific semaphore counter                        */

                                                            /* DELAY / TIMEOUT                                        */
#if (OS_CFG_TICK_EN > 0u)
    OS_TICK              TickRemain;                        /* Number of ticks remaining                              */
    OS_TICK              TickCtrPrev;                       /* Used by OSTimeDlyXX() in PERIODIC mode                 */
#endif

#if (OS_CFG_SCHED_ROUND_ROBIN_EN > 0u)
    OS_TICK              TimeQuanta;
    OS_TICK              TimeQuantaCtr;
#endif

#if (OS_MSG_EN > 0u)
    void                *MsgPtr;                            /* Message received                                       */
    OS_MSG_SIZE          MsgSize;
#endif

#if (OS_CFG_TASK_Q_EN > 0u)
    OS_MSG_Q             MsgQ;                              /* Message queue associated with task                     */
#if (OS_CFG_TASK_PROFILE_EN > 0u)
    CPU_TS               MsgQPendTime;                      /* Time it took for signal to be received                 */
    CPU_TS               MsgQPendTimeMax;                   /* Max amount of time it took for signal to be received   */
#endif
#endif

#if (OS_CFG_TASK_REG_TBL_SIZE > 0u)
    OS_REG               RegTbl[OS_CFG_TASK_REG_TBL_SIZE];  /* Task specific registers                                */
#endif

#if (OS_CFG_FLAG_EN > 0u)
    OS_FLAGS             FlagsPend;                         /* Event flag(s) to wait on                               */
    OS_FLAGS             FlagsRdy;                          /* Event flags that made task ready to run                */
    OS_OPT               FlagsOpt;                          /* Options (See OS_OPT_FLAG_xxx)                          */
#endif

#if (OS_CFG_TASK_SUSPEND_EN > 0u)
    OS_NESTING_CTR       SuspendCtr;                        /* Nesting counter for OSTaskSuspend()                    */
#endif

#if (OS_CFG_TASK_PROFILE_EN > 0u)
    OS_CPU_USAGE         CPUUsage;                          /* CPU Usage of task (0.00-100.00%)                       */
    OS_CPU_USAGE         CPUUsageMax;                       /* CPU Usage of task (0.00-100.00%) - Peak                */
    OS_CTX_SW_CTR        CtxSwCtr;                          /* Number of time the task was switched in                */
    CPU_TS               CyclesDelta;                       /* value of OS_TS_GET() - .CyclesStart                    */
    CPU_TS               CyclesStart;                       /* Snapshot of cycle counter at start of task resumption  */
    OS_CYCLES            CyclesTotal;                       /* Total number of # of cycles the task has been running  */
    OS_CYCLES            CyclesTotalPrev;                   /* Snapshot of previous # of cycles                       */

    CPU_TS               SemPendTime;                       /* Time it took for signal to be received                 */
    CPU_TS               SemPendTimeMax;                    /* Max amount of time it took for signal to be received   */
#endif

#if (OS_CFG_STAT_TASK_STK_CHK_EN > 0u)
    CPU_STK_SIZE         StkUsed;                           /* Number of stack elements used from the stack           */
    CPU_STK_SIZE         StkFree;                           /* Number of stack elements free on   the stack           */
#endif

#ifdef CPU_CFG_INT_DIS_MEAS_EN
    CPU_TS               IntDisTimeMax;                     /* Maximum interrupt disable time                         */
#endif
#if (OS_CFG_SCHED_LOCK_TIME_MEAS_EN > 0u)
    CPU_TS               SchedLockTimeMax;                  /* Maximum scheduler lock time                            */
#endif

#if (OS_CFG_DBG_EN > 0u)
    OS_TCB              *DbgPrevPtr;
    OS_TCB              *DbgNextPtr;
    CPU_CHAR            *DbgNamePtr;
#endif
#if (defined(OS_CFG_TRACE_EN) && (OS_CFG_TRACE_EN > 0u))
    CPU_ADDR             TaskID;                            /* Unique ID for third-party debuggers and tracers.       */
#endif
};

StkPtr：当前堆栈指针
ExtPtr：用户定义的扩展指针
StkLimitPtr：堆栈限制指针
NamePtr：任务名称指针
NextPtr：指向下一个TCB的指针
PrevPtr：指向上一个TCB的指针
TickNextPtr：时钟节拍链表中的下一个TCB指针
TickPrevPtr：时钟节拍链表中的上一个TCB指针
StkBasePtr：堆栈基地址指针
TLS_Tbl：任务本地存储表
TaskEntryAddr：任务入口地址
TaskEntryArg：任务入口参数
PendNextPtr：等待链表中的下一个TCB指针
PendPrevPtr：等待链表中的上一个TCB指针
PendObjPtr：等待对象指针
PendOn：任务等待状态
PendStatus：等待状态
TaskState：任务状态
Prio：任务优先级
BasePrio：原始优先级（未继承）
MutexGrpHeadPtr：互斥信号量组头指针
StkSize：堆栈大小
Opt：任务选项
TS：时间戳
SemID：信号量ID
SemCtr：信号量计数器
TickRemain：剩余时钟节拍
TickCtrPrev：上一个时钟节拍计数器
TimeQuanta：时间片
TimeQuantaCtr：时间片计数器
MsgPtr：消息指针
MsgSize：消息大小
MsgQ：消息队列
MsgQPendTime：消息等待时间
MsgQPendTimeMax：消息等待最大时间
RegTbl：任务寄存器表
FlagsPend：等待的事件标志
FlagsRdy：就绪的事件标志
FlagsOpt：事件标志选项
SuspendCtr：任务挂起计数器
CPUUsage：任务CPU使用率
CPUUsageMax：任务CPU使用率最大值
CtxSwCtr：上下文切换计数
CyclesDelta：周期差值
CyclesStart：任务恢复时的周期快。
CyclesTotal：任务运行的总周期数
CyclesTotalPrev：上一个周期快照
SemPendTime：信号量等待时间
SemPendTimeMax：信号量等待最大时间
StkUsed：已用堆栈
StkFree：空闲堆栈
IntDisTimeMax：最大中断禁止时间
SchedLockTimeMax：最大调度锁定时间
DbgPrevPtr：调试链表中的上一个TCB指针
DbgNextPtr：调试链表中的下一个TCB指针
DbgNamePtr：调试名称指针
TaskID：任务ID

2.2 事件标志组（Event Flags Group）



struct  os_flag_grp {                                       /* Event Flag Group                                       */
                                                            /* ------------------ GENERIC  MEMBERS ------------------ */
#if (OS_OBJ_TYPE_REQ > 0u)
    OS_OBJ_TYPE          Type;                              /* Should be set to OS_OBJ_TYPE_FLAG                      */
#endif
#if (OS_CFG_DBG_EN > 0u)
    CPU_CHAR            *NamePtr;                           /* Pointer to Event Flag Name (NUL terminated ASCII)      */
#endif
    OS_PEND_LIST         PendList;                          /* List of tasks waiting on event flag group              */
#if (OS_CFG_DBG_EN > 0u)
    OS_FLAG_GRP         *DbgPrevPtr;
    OS_FLAG_GRP         *DbgNextPtr;
    CPU_CHAR            *DbgNamePtr;
#endif
                                                            /* ------------------ SPECIFIC MEMBERS ------------------ */
    OS_FLAGS             Flags;                             /* 8, 16 or 32 bit flags                                  */
#if (OS_CFG_TS_EN > 0u)
    CPU_TS               TS;                                /* Timestamp of when last post occurred                   */
#endif
#if (defined(OS_CFG_TRACE_EN) && (OS_CFG_TRACE_EN > 0u))
    CPU_ADDR             FlagID;                            /* Unique ID for third-party debuggers and tracers.       */
#endif
};

Type：对象类型
NamePtr：事件标志名称指针
PendList：等待任务列表
DbgPrevPtr：调试列表中的上一个事件标志组指针
DbgNextPtr：调试列表中的下一个事件标志组指针
Flags：事件标志
TS：时间戳
FlagID：唯一ID

2.3 内存管理（Memory Management）



struct os_mem {                                             /* MEMORY CONTROL BLOCK                                   */
#if (OS_OBJ_TYPE_REQ > 0u)
    OS_OBJ_TYPE          Type;                              /* Should be set to OS_OBJ_TYPE_MEM                       */
#endif
#if (OS_CFG_DBG_EN > 0u)
    CPU_CHAR            *NamePtr;
#endif
    void                *AddrPtr;                           /* Pointer to beginning of memory partition               */
    void                *FreeListPtr;                       /* Pointer to list of free memory blocks                  */
    OS_MEM_SIZE          BlkSize;                           /* Size (in bytes) of each block of memory                */
    OS_MEM_QTY           NbrMax;                            /* Total number of blocks in this partition               */
    OS_MEM_QTY           NbrFree;                           /* Number of memory blocks remaining in this partition    */
#if (OS_CFG_DBG_EN > 0u)
    OS_MEM              *DbgPrevPtr;
    OS_MEM              *DbgNextPtr;
#endif
#if (defined(OS_CFG_TRACE_EN) && (OS_CFG_TRACE_EN > 0u))
    CPU_ADDR             MemID;                             /* Unique ID for third-party debuggers and tracers.       */
#endif
};

Type：对象类型
NamePtr：内存分区名称指针
AddrPtr：内存分区起始地址
FreeListPtr：空闲内存块列表指针
BlkSize：内存块大小
NbrMax：内存块数量
NbrFree：空闲内存块数量
DbgPrevPtr：调试列表中的上一个内存分区指针
DbgNextPtr：调试列表中的下一个内存分区指针

2.4 消息（Message）

struct  os_msg {                                            /* MESSAGE CONTROL BLOCK                                  */
    OS_MSG              *NextPtr;                           /* Pointer to next message                                */
    void                *MsgPtr;                            /* Actual message                                         */
    OS_MSG_SIZE          MsgSize;                           /* Size of the message (in # bytes)                       */
#if (OS_CFG_TS_EN > 0u)
    CPU_TS               MsgTS;                             /* Time stamp of when message was sent                    */
#endif
};

NextPtr：下一个消息指针
MsgPtr：消息内容指针
MsgSize：消息大小
MsgTS：消息时间戳

2.5 消息池（Message Pool）

struct  os_msg_pool {                                       /* OS_MSG POOL                                            */
    OS_MSG              *NextPtr;                           /* Pointer to next message                                */
    OS_MSG_QTY           NbrFree;                           /* Number of messages available from this pool            */
    OS_MSG_QTY           NbrUsed;                           /* Current number of messages used                        */
#if (OS_CFG_DBG_EN > 0u)
    OS_MSG_QTY           NbrUsedMax;                        /* Peak number of messages used                           */
#endif
};

NextPtr：下一个消息指针
NbrFree：空闲消息数量
NbrUsed：已用消息数量
NbrUsedMax：最大已用消息数量

2.6 互斥信号量（Mutex）


struct  os_mutex {                                          /* Mutual Exclusion Semaphore                             */
                                                            /* ------------------ GENERIC  MEMBERS ------------------ */
#if (OS_OBJ_TYPE_REQ > 0u)
    OS_OBJ_TYPE          Type;                              /* Should be set to OS_OBJ_TYPE_MUTEX                     */
#endif
#if (OS_CFG_DBG_EN > 0u)
    CPU_CHAR            *NamePtr;                           /* Pointer to Mutex Name (NUL terminated ASCII)           */
#endif
    OS_PEND_LIST         PendList;                          /* List of tasks waiting on mutex                         */
#if (OS_CFG_DBG_EN > 0u)
    OS_MUTEX            *DbgPrevPtr;
    OS_MUTEX            *DbgNextPtr;
    CPU_CHAR            *DbgNamePtr;
#endif
                                                            /* ------------------ SPECIFIC MEMBERS ------------------ */
    OS_MUTEX            *MutexGrpNextPtr;
    OS_TCB              *OwnerTCBPtr;
    OS_NESTING_CTR       OwnerNestingCtr;                   /* Mutex is available when the counter is 0               */
#if (OS_CFG_TS_EN > 0u)
    CPU_TS               TS;
#endif
#if (defined(OS_CFG_TRACE_EN) && (OS_CFG_TRACE_EN > 0u))
    CPU_ADDR             MutexID;                           /* Unique ID for third-party debuggers and tracers.       */
#endif
};

Type：对象类型
NamePtr：互斥信号量名称指针
PendList：等待任务列表
DbgPrevPtr：调试列表中的上一个互斥信号量指针
DbgNextPtr：调试列表中的下一个互斥信号量指针
MutexGrpNextPtr：互斥信号量组的下一个指针
OwnerTCBPtr：拥有互斥信号量的任务控制块指针
OwnerNestingCtr：互斥信号量嵌套计数器
TS：时间戳
MutexID：唯一ID

2.7 条件变量（Condition Variable）

struct  os_cond {                                           /* Condition Variable                                     */
                                                            /* ------------------ GENERIC  MEMBERS ------------------ */
#if (OS_OBJ_TYPE_REQ > 0u)
    OS_OBJ_TYPE          Type;                              /* Should be set to OS_OBJ_TYPE_COND                      */
#endif
#if (OS_CFG_DBG_EN > 0u)
    CPU_CHAR            *NamePtr;                           /* Pointer to Mutex Name (NUL terminated ASCII)           */
#endif
    OS_PEND_LIST         PendList;                          /* List of tasks waiting on condition variable            */
#if (OS_CFG_DBG_EN > 0u)
    void                *DbgPrevPtr;
    void                *DbgNextPtr;
    CPU_CHAR            *DbgNamePtr;
#endif
                                                            /* ------------------ SPECIFIC MEMBERS ------------------ */
    OS_MUTEX            *Mutex;                             /* Mutex bound to the condition variable.                 */
};

Type：对象类型
NamePtr：条件变量名称指针
PendList：等待任务列表
DbgPrevPtr：调试列表中的上一个条件变量指针
DbgNextPtr：调试列表中的下一个条件变量指针
Mutex：条件变量绑定的互斥信号量

2.8 消息队列（Message Queue）

struct  os_q {                                              /* Message Queue                                          */
                                                            /* ------------------ GENERIC  MEMBERS ------------------ */
#if (OS_OBJ_TYPE_REQ > 0u)
    OS_OBJ_TYPE          Type;                              /* Should be set to OS_OBJ_TYPE_Q                         */
#endif
#if (OS_CFG_DBG_EN > 0u)
    CPU_CHAR            *NamePtr;                           /* Pointer to Message Queue Name (NUL terminated ASCII)   */
#endif
    OS_PEND_LIST         PendList;                          /* List of tasks waiting on message queue                 */
#if (OS_CFG_DBG_EN > 0u)
    OS_Q                *DbgPrevPtr;
    OS_Q                *DbgNextPtr;
    CPU_CHAR            *DbgNamePtr;
#endif
                                                            /* ------------------ SPECIFIC MEMBERS ------------------ */
    OS_MSG_Q             MsgQ;                              /* List of messages                                       */
};

Type：对象类型
NamePtr：消息队列名称指针
PendList：等待任务列表
DbgPrevPtr：调试列表中的上一个消息队列指针
DbgNextPtr：调试列表中的下一个消息队列指针
MsgQ：消息队列

2.9 信号量（Semaphore）


struct  os_sem {                                            /* Semaphore                                              */
                                                            /* ------------------ GENERIC  MEMBERS ------------------ */
#if (OS_OBJ_TYPE_REQ > 0u)
    OS_OBJ_TYPE          Type;                              /* Should be set to OS_OBJ_TYPE_SEM                       */
#endif
#if (OS_CFG_DBG_EN > 0u)
    CPU_CHAR            *NamePtr;                           /* Pointer to Semaphore Name (NUL terminated ASCII)       */
#endif
    OS_PEND_LIST         PendList;                          /* List of tasks waiting on semaphore                     */
#if (OS_CFG_DBG_EN > 0u)
    OS_SEM              *DbgPrevPtr;
    OS_SEM              *DbgNextPtr;
    CPU_CHAR            *DbgNamePtr;
#endif
                                                            /* ------------------ SPECIFIC MEMBERS ------------------ */
    OS_SEM_CTR           Ctr;
#if (OS_CFG_TS_EN > 0u)
    CPU_TS               TS;
#endif
#if (defined(OS_CFG_TRACE_EN) && (OS_CFG_TRACE_EN > 0u))
    CPU_ADDR             SemID;                             /* Unique ID for third-party debuggers and tracers.       */
#endif
};