认识任务管理的函数
- 建立任务：OSTaskCreate()
- 堆栈检验：OSTaskStkChk()
- 删除任务：OSTaskDel()
- 改变任务优先级：OSTaskChangePrio()
- 挂起任务：OSTaskSuspend()
- 恢复任务：OSTaskResume()
任务可以是一个无线的循环，也可以是在一次执行完毕后被删除掉。
注意：任务代码并非真正被删除了，而是操作系统不会再理会该任务代码，所以该任务代码不会再运行
任务从来不会返回，所以任务的类型都是Void型
一、建立任务
任务可以在多任务开始前被建立，即OSStart()函数执行前。也可以在其他任务的执行过程中被创建
但在多任务调度开始前必须建立至少一个任务，但千万不要再中断服务函数中建立任务
我们可以使用OSTaskCreate与OSTaskCreateExt这两个函数来建立任务
void OSTaskCreate (OS_TCB *p_tcb,指向任务的TCB指针CPU_CHAR *p_name,用于为任务提供名称OS_TASK_PTR p_task,指向任务的代码void *p_arg,为任务传递参数OS_PRIO prio,任务优先级，数字越小优先级越高CPU_STK *p_stk_base,指向任务的堆栈基址指针CPU_STK_SIZE stk_limit,限制堆栈元素数CPU_STK_SIZE stk_size,堆栈大小OS_MSG_QTY q_size,可以发送到任务的最大消息数OS_TICK time_quanta,时间片void *p_ext,OS_OPT opt,任务行为信息OS_ERR *p_err)错误返回值
{CPU_STK_SIZE i;
#if OS_CFG_TASK_REG_TBL_SIZE > 0uOS_REG_ID reg_nbr;
#endif
#if defined(OS_CFG_TLS_TBL_SIZE) && (OS_CFG_TLS_TBL_SIZE > 0u)OS_TLS_ID id;
#endifCPU_STK *p_sp;CPU_STK *p_stk_limit;CPU_SR_ALLOC();#ifdef OS_SAFETY_CRITICALif (p_err == (OS_ERR *)0) {OS_SAFETY_CRITICAL_EXCEPTION();return;}
#endif#ifdef OS_SAFETY_CRITICAL_IEC61508if (OSSafetyCriticalStartFlag == DEF_TRUE) {*p_err = OS_ERR_ILLEGAL_CREATE_RUN_TIME;return;}
#endif#if OS_CFG_CALLED_FROM_ISR_CHK_EN > 0uif (OSIntNestingCtr > (OS_NESTING_CTR)0) { /* ---------- CANNOT CREATE A TASK FROM AN ISR ---------- */*p_err = OS_ERR_TASK_CREATE_ISR;return;}
#endif#if OS_CFG_ARG_CHK_EN > 0u /* ---------------- VALIDATE ARGUMENTS ------------------ */if (p_tcb == (OS_TCB *)0) { /* User must supply a valid OS_TCB */*p_err = OS_ERR_TCB_INVALID;return;}if (p_task == (OS_TASK_PTR)0) { /* User must supply a valid task */*p_err = OS_ERR_TASK_INVALID;return;}if (p_stk_base == (CPU_STK *)0) { /* User must supply a valid stack base address */*p_err = OS_ERR_STK_INVALID;return;}if (stk_size < OSCfg_StkSizeMin) { /* User must supply a valid minimum stack size */*p_err = OS_ERR_STK_SIZE_INVALID;return;}if (stk_limit >= stk_size) { /* User must supply a valid stack limit */*p_err = OS_ERR_STK_LIMIT_INVALID;return;}if (prio >= OS_CFG_PRIO_MAX) { /* Priority must be within 0 and OS_CFG_PRIO_MAX-1 */*p_err = OS_ERR_PRIO_INVALID;return;}
#endif#if OS_CFG_ISR_POST_DEFERRED_EN > 0uif (prio == (OS_PRIO)0) {if (p_tcb != &OSIntQTaskTCB) {*p_err = OS_ERR_PRIO_INVALID; /* Not allowed to use priority 0 */return;}}
#endifif (prio == (OS_CFG_PRIO_MAX - 1u)) {if (p_tcb != &OSIdleTaskTCB) {*p_err = OS_ERR_PRIO_INVALID; /* Not allowed to use same priority as idle task */return;}}OS_TaskInitTCB(p_tcb); /* Initialize the TCB to default values */*p_err = OS_ERR_NONE; /* --------------- CLEAR THE TASK'S STACK --------------- */if ((opt & OS_OPT_TASK_STK_CHK) != (OS_OPT)0) { /* See if stack checking has been enabled */if ((opt & OS_OPT_TASK_STK_CLR) != (OS_OPT)0) { /* See if stack needs to be cleared */p_sp = p_stk_base;for (i = 0u; i < stk_size; i++) { /* Stack grows from HIGH to LOW memory */*p_sp = (CPU_STK)0; /* Clear from bottom of stack and up! */p_sp++;}}} /* ------- INITIALIZE THE STACK FRAME OF THE TASK ------- */
#if (CPU_CFG_STK_GROWTH == CPU_STK_GROWTH_HI_TO_LO)p_stk_limit = p_stk_base + stk_limit;
#elsep_stk_limit = p_stk_base + (stk_size - 1u) - stk_limit;
#endifp_sp = OSTaskStkInit(p_task,p_arg,p_stk_base,p_stk_limit,stk_size,opt);/* -------------- INITIALIZE THE TCB FIELDS ------------- */p_tcb->TaskEntryAddr = p_task; /* Save task entry point address */p_tcb->TaskEntryArg = p_arg; /* Save task entry argument */p_tcb->NamePtr = p_name; /* Save task name */p_tcb->Prio = prio; /* Save the task's priority */p_tcb->StkPtr = p_sp; /* Save the new top-of-stack pointer */p_tcb->StkLimitPtr = p_stk_limit; /* Save the stack limit pointer */p_tcb->TimeQuanta = time_quanta; /* Save the #ticks for time slice (0 means not sliced) */
#if OS_CFG_SCHED_ROUND_ROBIN_EN > 0uif (time_quanta == (OS_TICK)0) {p_tcb->TimeQuantaCtr = OSSchedRoundRobinDfltTimeQuanta;} else {p_tcb->TimeQuantaCtr = time_quanta;}
#endifp_tcb->ExtPtr = p_ext; /* Save pointer to TCB extension */p_tcb->StkBasePtr = p_stk_base; /* Save pointer to the base address of the stack */p_tcb->StkSize = stk_size; /* Save the stack size (in number of CPU_STK elements) */p_tcb->Opt = opt; /* Save task options */#if OS_CFG_TASK_REG_TBL_SIZE > 0ufor (reg_nbr = 0u; reg_nbr < OS_CFG_TASK_REG_TBL_SIZE; reg_nbr++) {p_tcb->RegTbl[reg_nbr] = (OS_REG)0;}
#endif#if OS_CFG_TASK_Q_EN > 0uOS_MsgQInit(&p_tcb->MsgQ, /* Initialize the task's message queue */q_size);
#else(void)&q_size;
#endifOSTaskCreateHook(p_tcb); /* Call user defined hook */#if defined(OS_CFG_TLS_TBL_SIZE) && (OS_CFG_TLS_TBL_SIZE > 0u)for (id = 0u; id < OS_CFG_TLS_TBL_SIZE; id++) {p_tcb->TLS_Tbl[id] = (OS_TLS)0;}OS_TLS_TaskCreate(p_tcb); /* Call TLS hook */
#endif /* --------------- ADD TASK TO READY LIST --------------- */OS_CRITICAL_ENTER();OS_PrioInsert(p_tcb->Prio);OS_RdyListInsertTail(p_tcb);#if OS_CFG_DBG_EN > 0uOS_TaskDbgListAdd(p_tcb);
#endifOSTaskQty++; /* Increment the #tasks counter */if (OSRunning != OS_STATE_OS_RUNNING) { /* Return if multitasking has not started */OS_CRITICAL_EXIT();return;}OS_CRITICAL_EXIT_NO_SCHED();OSSched();
}
OSTaskCreate函数的大致流程为：
-
是否可以创建任务
创建失败的原因：
- 在中断中创建 ERR：OS_ERR_TASK_CREATE_ISR
- 用户没有为任务传输相关参数
- 缺少指向任务的TCB指针 ERR：OS_ERR_TCB_INVALID
- 缺少指向任务的代码 ERR：OS_ERR_TASK_INVALID
- 缺少指向任务的堆栈基址指针 ERR：OS_ERR_STK_INVALID
- 缺少堆栈大小 ERR：OS_ERR_STK_SIZE_INVALID
- 限制堆栈元素数大于堆栈大小 ERR：OS_ERR_STK_LIMIT_INVALID
- pero>max or pero == 0 ERR：OS_ERR_PRIO_INVALID
- 占用已使用特定任务的优先级 ERR：OS_ERR_PRIO_INVALID
-
进行TCB的初始化，调用OSTaskStkInit进行堆栈初始化
-
判断是否打开了轮询调度
-
确定任务的时间片大小
-
将TCB的初始为传入的参数
-
初始化任务的消息队列
-
设置任务的钩子函数，呼叫钩子函数
-
进入临界区后将任务插入就绪队列，任务数变量自加一
如果轮询调度开启退出临界区进行任务调度，创建好的任务在内存形式如下：
二、删除任务
**OSTaskDel(OS_TCB p_tcb,OS_ERR p_err)
该函数可以通过指定NULL来删除自己。
删除一个任务。根据任务状态，将p_tcb从RDyList,TickList,PendList中删除，释放Queue中的所有OS_MSG，调用钩子函数，清空TCB， p_tcb->TaskState = (OS_STATE)OS_TASK_STATE_DEL,启动调度
void OSTaskDel (OS_TCB *p_tcb,OS_ERR *p_err)
{CPU_SR_ALLOC();#ifdef OS_SAFETY_CRITICALif (p_err == (OS_ERR *)0) {OS_SAFETY_CRITICAL_EXCEPTION();return;}
#endif#if OS_CFG_CALLED_FROM_ISR_CHK_EN > 0uif (OSIntNestingCtr > (OS_NESTING_CTR)0) { /* See if trying to delete from ISR */*p_err = OS_ERR_TASK_DEL_ISR;return;}
#endifif (p_tcb == &OSIdleTaskTCB) { /* Not allowed to delete the idle task */*p_err = OS_ERR_TASK_DEL_IDLE;return;}#if OS_CFG_ISR_POST_DEFERRED_EN > 0uif (p_tcb == &OSIntQTaskTCB) { /* Cannot delete the ISR handler task */*p_err = OS_ERR_TASK_DEL_INVALID;return;}
#endifif (p_tcb == (OS_TCB *)0) { /* Delete 'Self'? */CPU_CRITICAL_ENTER();p_tcb = OSTCBCurPtr; /* Yes. */CPU_CRITICAL_EXIT();}OS_CRITICAL_ENTER();switch (p_tcb->TaskState) {case OS_TASK_STATE_RDY:OS_RdyListRemove(p_tcb);break;case OS_TASK_STATE_SUSPENDED:break;case OS_TASK_STATE_DLY: /* Task is only delayed, not on any wait list */case OS_TASK_STATE_DLY_SUSPENDED:OS_TickListRemove(p_tcb);break;case OS_TASK_STATE_PEND:case OS_TASK_STATE_PEND_SUSPENDED:case OS_TASK_STATE_PEND_TIMEOUT:case OS_TASK_STATE_PEND_TIMEOUT_SUSPENDED:OS_TickListRemove(p_tcb);switch (p_tcb->PendOn) { /* See what we are pending on */case OS_TASK_PEND_ON_NOTHING:case OS_TASK_PEND_ON_TASK_Q: /* There is no wait list for these two */case OS_TASK_PEND_ON_TASK_SEM:break;case OS_TASK_PEND_ON_FLAG: /* Remove from wait list */case OS_TASK_PEND_ON_MULTI:case OS_TASK_PEND_ON_MUTEX:case OS_TASK_PEND_ON_Q:case OS_TASK_PEND_ON_SEM:OS_PendListRemove(p_tcb);break;default:break;}break;default:OS_CRITICAL_EXIT();*p_err = OS_ERR_STATE_INVALID;return;}#if OS_CFG_TASK_Q_EN > 0u(void)OS_MsgQFreeAll(&p_tcb->MsgQ); /* Free task's message queue messages */
#endifOSTaskDelHook(p_tcb); /* Call user defined hook */#if defined(OS_CFG_TLS_TBL_SIZE) && (OS_CFG_TLS_TBL_SIZE > 0u)OS_TLS_TaskDel(p_tcb); /* Call TLS hook */
#endif#if OS_CFG_DBG_EN > 0uOS_TaskDbgListRemove(p_tcb);
#endifOSTaskQty--; /* One less task being managed */OS_TaskInitTCB(p_tcb); /* Initialize the TCB to default values */p_tcb->TaskState = (OS_STATE)OS_TASK_STATE_DEL; /* Indicate that the task was deleted */OS_CRITICAL_EXIT_NO_SCHED();*p_err = OS_ERR_NONE; /* See Note #1. */OSSched(); /* Find new highest priority task */
}
三、暂停任务
**OSTaskSuspend(OS_TCB p_tcb,OS_ERR p_err)
调用该函数可以暂停任务，p_tcb为NULL时可以暂停自己，最前面的是安全认证相关不用理会。中断中不可调用、不可暂停空闲函数、不可暂停中断服务函数、转到函数OS_TaskSuspend 中。
void OSTaskSuspend (OS_TCB *p_tcb,OS_ERR *p_err)
{
#ifdef OS_SAFETY_CRITICALif (p_err == (OS_ERR *)0) {OS_SAFETY_CRITICAL_EXCEPTION();return;}
#endif#if (OS_CFG_ISR_POST_DEFERRED_EN == 0u) && \(OS_CFG_CALLED_FROM_ISR_CHK_EN > 0u)if (OSIntNestingCtr > (OS_NESTING_CTR)0) { /* Not allowed to call from an ISR */*p_err = OS_ERR_TASK_SUSPEND_ISR;return;}
#endifif (p_tcb == &OSIdleTaskTCB) { /* Make sure not suspending the idle task */*p_err = OS_ERR_TASK_SUSPEND_IDLE;return;}#if OS_CFG_ISR_POST_DEFERRED_EN > 0uif (p_tcb == &OSIntQTaskTCB) { /* Not allowed to suspend the ISR handler task */*p_err = OS_ERR_TASK_SUSPEND_INT_HANDLER;return;}if (OSIntNestingCtr > (OS_NESTING_CTR)0) { /* See if called from an ISR */OS_IntQPost((OS_OBJ_TYPE)OS_OBJ_TYPE_TASK_SUSPEND, /* Post to ISR queue */(void *)p_tcb,(void *)0,(OS_MSG_SIZE)0,(OS_FLAGS )0,(OS_OPT )0,(CPU_TS )0,(OS_ERR *)p_err);return;}
#endifOS_TaskSuspend(p_tcb, p_err);
}
进入临界区，如果传入指针为NULL则将指针指向当前任务TCB指针，如果调度器上锁了不可以调度，根据任务所处的状态处理任务。开启调度。如果成功挂起任务，任务状态会变为暂停态，把他从就绪队列中移除，并设置暂停计数器为1，挂起一次累加一次。
void OS_TaskSuspend (OS_TCB *p_tcb,OS_ERR *p_err)
{CPU_SR_ALLOC();CPU_CRITICAL_ENTER();if (p_tcb == (OS_TCB *)0) { /* See if specified to suspend self */p_tcb = OSTCBCurPtr;}if (p_tcb == OSTCBCurPtr) {if (OSSchedLockNestingCtr > (OS_NESTING_CTR)0) { /* Can't suspend when the scheduler is locked */CPU_CRITICAL_EXIT();*p_err = OS_ERR_SCHED_LOCKED;return;}}*p_err = OS_ERR_NONE;switch (p_tcb->TaskState) {case OS_TASK_STATE_RDY:OS_CRITICAL_ENTER_CPU_EXIT();p_tcb->TaskState = OS_TASK_STATE_SUSPENDED;p_tcb->SuspendCtr = (OS_NESTING_CTR)1;OS_RdyListRemove(p_tcb);OS_CRITICAL_EXIT_NO_SCHED();break;case OS_TASK_STATE_DLY:p_tcb->TaskState = OS_TASK_STATE_DLY_SUSPENDED;p_tcb->SuspendCtr = (OS_NESTING_CTR)1;CPU_CRITICAL_EXIT();break;case OS_TASK_STATE_PEND:p_tcb->TaskState = OS_TASK_STATE_PEND_SUSPENDED;p_tcb->SuspendCtr = (OS_NESTING_CTR)1;CPU_CRITICAL_EXIT();break;case OS_TASK_STATE_PEND_TIMEOUT:p_tcb->TaskState = OS_TASK_STATE_PEND_TIMEOUT_SUSPENDED;p_tcb->SuspendCtr = (OS_NESTING_CTR)1;CPU_CRITICAL_EXIT();break;case OS_TASK_STATE_SUSPENDED:case OS_TASK_STATE_DLY_SUSPENDED:case OS_TASK_STATE_PEND_SUSPENDED:case OS_TASK_STATE_PEND_TIMEOUT_SUSPENDED:p_tcb->SuspendCtr++;CPU_CRITICAL_EXIT();break;default:CPU_CRITICAL_EXIT();*p_err = OS_ERR_STATE_INVALID;return;}OSSched();
}
四、恢复任务
**OSTaskResume (OS_TCB p_tcb, OS_ERR p_err)
调用函数可以恢复暂停的，函数首先判断是否在中断中、是否是自己调用。执行函数 OS_TaskResume(p_tcb, p_err);我们看这个函数足以。首先进入临界区、根据恢复暂停的任务状态来执行操作。状态为OS_TASK_STATE_SUSPENDED时暂停计数器减一，如果计数器减为0才可以将状态改为就绪态，将其放入就绪队列中。执行任务调度
void OS_TaskResume (OS_TCB *p_tcb,OS_ERR *p_err)
{CPU_SR_ALLOC();CPU_CRITICAL_ENTER();*p_err = OS_ERR_NONE;switch (p_tcb->TaskState) {case OS_TASK_STATE_RDY:case OS_TASK_STATE_DLY:case OS_TASK_STATE_PEND:case OS_TASK_STATE_PEND_TIMEOUT:CPU_CRITICAL_EXIT();*p_err = OS_ERR_TASK_NOT_SUSPENDED;break;case OS_TASK_STATE_SUSPENDED:OS_CRITICAL_ENTER_CPU_EXIT();p_tcb->SuspendCtr--;if (p_tcb->SuspendCtr == (OS_NESTING_CTR)0) {p_tcb->TaskState = OS_TASK_STATE_RDY;OS_TaskRdy(p_tcb);}OS_CRITICAL_EXIT_NO_SCHED();break;case OS_TASK_STATE_DLY_SUSPENDED:p_tcb->SuspendCtr--;if (p_tcb->SuspendCtr == (OS_NESTING_CTR)0) {p_tcb->TaskState = OS_TASK_STATE_DLY;}CPU_CRITICAL_EXIT();break;case OS_TASK_STATE_PEND_SUSPENDED:p_tcb->SuspendCtr--;if (p_tcb->SuspendCtr == (OS_NESTING_CTR)0) {p_tcb->TaskState = OS_TASK_STATE_PEND;}CPU_CRITICAL_EXIT();break;case OS_TASK_STATE_PEND_TIMEOUT_SUSPENDED:p_tcb->SuspendCtr--;if (p_tcb->SuspendCtr == (OS_NESTING_CTR)0) {p_tcb->TaskState = OS_TASK_STATE_PEND_TIMEOUT;}CPU_CRITICAL_EXIT();break;default:CPU_CRITICAL_EXIT();*p_err = OS_ERR_STATE_INVALID;return;}OSSched();
}
五、查看任务堆栈使用量和剩余量
OSTaskStkChk()
检查p_tcb堆栈的使用量和剩余量，为了适应系统以后的升级和扩展，用户应该多分配10％－100％的堆栈空间。在堆栈检验中，用户所得到的只是一个大致的堆栈使用情况，并不能说明堆栈使用的全部实际情况。函数主要功能是不能在中断中检测、判断地址是否可用，进入临界区，p_tcb==NULL则为查询自身的，查看传入任务是否存在，查看堆栈的选项是否开启，判断完后退出临界区。根据栈的生长方式计算出空闲区域的大小，用栈的总量减去刚得出空闲区域的大小为已使用区域的大小。具体示意如图所示
void OSTaskStkChk (OS_TCB *p_tcb,CPU_STK_SIZE *p_free,CPU_STK_SIZE *p_used,OS_ERR *p_err)
{CPU_STK_SIZE free_stk;CPU_STK *p_stk;CPU_SR_ALLOC();#ifdef OS_SAFETY_CRITICALif (p_err == (OS_ERR *)0) {OS_SAFETY_CRITICAL_EXCEPTION();return;}
#endif#if OS_CFG_CALLED_FROM_ISR_CHK_EN > 0uif (OSIntNestingCtr > (OS_NESTING_CTR)0) { /* See if trying to check stack from ISR */*p_err = OS_ERR_TASK_STK_CHK_ISR;return;}
#endif#if OS_CFG_ARG_CHK_EN > 0uif (p_free == (CPU_STK_SIZE*)0) { /* User must specify valid destinations for the sizes*/*p_err = OS_ERR_PTR_INVALID;return;}if (p_used == (CPU_STK_SIZE*)0) {*p_err = OS_ERR_PTR_INVALID;return;}
#endifCPU_CRITICAL_ENTER();if (p_tcb == (OS_TCB *)0) { /* Check the stack of the current task? */p_tcb = OSTCBCurPtr; /* Yes */}if (p_tcb->StkPtr == (CPU_STK*)0) { /* Make sure task exist */CPU_CRITICAL_EXIT();*p_free = (CPU_STK_SIZE)0;*p_used = (CPU_STK_SIZE)0;*p_err = OS_ERR_TASK_NOT_EXIST;return;}if ((p_tcb->Opt & OS_OPT_TASK_STK_CHK) == (OS_OPT)0) { /* Make sure stack checking option is set */CPU_CRITICAL_EXIT();*p_free = (CPU_STK_SIZE)0;*p_used = (CPU_STK_SIZE)0;*p_err = OS_ERR_TASK_OPT;return;}CPU_CRITICAL_EXIT();free_stk = 0u;
#if CPU_CFG_STK_GROWTH == CPU_STK_GROWTH_HI_TO_LOp_stk = p_tcb->StkBasePtr; /* Start at the lowest memory and go up */while (*p_stk == (CPU_STK)0) { /* Compute the number of zero entries on the stk */p_stk++;free_stk++;}
#elsep_stk = p_tcb->StkBasePtr + p_tcb->StkSize - 1u; /* Start at the highest memory and go down */while (*p_stk == (CPU_STK)0) {free_stk++;p_stk--;}
#endif*p_free = free_stk;*p_used = (p_tcb->StkSize - free_stk); /* Compute number of entries used on the stack */*p_err = OS_ERR_NONE;
}
六、改变任务优先级
OSTaskChangePrio()
使用该函数可以动态的设置任务的优先级，优先级必须可用。根据状态对任务进行处理，当任务处于就绪状态时，将任务从就绪列表上移除，改变其优先级，再将他插入回就绪队列。若为暂停状态则直接改变优先级。执行调度。
void OSTaskChangePrio (OS_TCB *p_tcb,OS_PRIO prio_new,OS_ERR *p_err)
{CPU_BOOLEAN self;CPU_SR_ALLOC();#ifdef OS_SAFETY_CRITICALif (p_err == (OS_ERR *)0) {OS_SAFETY_CRITICAL_EXCEPTION();return;}
#endif#if OS_CFG_CALLED_FROM_ISR_CHK_EN > 0uif (OSIntNestingCtr > (OS_NESTING_CTR)0) { /* ---------- CANNOT CREATE A TASK FROM AN ISR ---------- */*p_err = OS_ERR_TASK_CHANGE_PRIO_ISR;return;}
#endif#if OS_CFG_ISR_POST_DEFERRED_EN > 0uif (prio_new == 0) { /* Cannot set to IntQueue Task priority */*p_err = OS_ERR_PRIO_INVALID;return;}
#endifif (prio_new >= (OS_CFG_PRIO_MAX - 1u)) { /* Cannot set to Idle Task priority */*p_err = OS_ERR_PRIO_INVALID;return;}if (p_tcb == (OS_TCB *)0) { /* See if want to change priority of 'self' */CPU_CRITICAL_ENTER();p_tcb = OSTCBCurPtr;CPU_CRITICAL_EXIT();self = DEF_TRUE;} else {self = DEF_FALSE;}OS_CRITICAL_ENTER();switch (p_tcb->TaskState) {case OS_TASK_STATE_RDY:OS_RdyListRemove(p_tcb); /* Remove from current priority */p_tcb->Prio = prio_new; /* Set new task priority */OS_PrioInsert(p_tcb->Prio);if (self == DEF_TRUE) {OS_RdyListInsertHead(p_tcb);} else {OS_RdyListInsertTail(p_tcb);}break;case OS_TASK_STATE_DLY: /* Nothing to do except change the priority in the OS_TCB */case OS_TASK_STATE_SUSPENDED:case OS_TASK_STATE_DLY_SUSPENDED:p_tcb->Prio = prio_new; /* Set new task priority */break;case OS_TASK_STATE_PEND:case OS_TASK_STATE_PEND_TIMEOUT:case OS_TASK_STATE_PEND_SUSPENDED:case OS_TASK_STATE_PEND_TIMEOUT_SUSPENDED:switch (p_tcb->PendOn) { /* What to do depends on what we are pending on */case OS_TASK_PEND_ON_TASK_Q: /* Nothing to do except change the priority in the OS_TCB */case OS_TASK_PEND_ON_TASK_SEM:case OS_TASK_PEND_ON_FLAG:p_tcb->Prio = prio_new; /* Set new task priority */break;case OS_TASK_PEND_ON_MUTEX:case OS_TASK_PEND_ON_MULTI:case OS_TASK_PEND_ON_Q:case OS_TASK_PEND_ON_SEM:OS_PendListChangePrio(p_tcb,prio_new);break;default:break;}break;default:OS_CRITICAL_EXIT();*p_err = OS_ERR_STATE_INVALID;return;}OS_CRITICAL_EXIT_NO_SCHED();OSSched(); /* Run highest priority task ready */*p_err = OS_ERR_NONE;
}
![[uCOS/RTOS]uC/OS-II中的任务堆栈大小检测](https://img-blog.csdnimg.cn/c77100eddc3e4f04935b29a43d54014e.png)
![[pascal入门]数组](https://dn-anything-about-doc.qbox.me/c/7-13.jpg)
