本文探讨RTOS中的优先级反转问题及其解决方案。通过分析任务间共享资源时的优先级变化，揭示了优先级反转现象。介绍了互斥信号量的概念及其实现机制，演示了如何使用互斥信号量避免优先级反转，确保实时系统的稳定性和响应性。
一、优先级反转分析
(1) 任务 H 和任务 M 处于挂起状态，等待某一事件的发生，任务 L 正在运行。
(2) 某一时刻任务 L 想要访问共享资源，在此之前它必须先获得对应该资源的信号量。
(3) 任务 L 获得信号量并开始使用该共享资源。
(4) 由于任务 H 优先级高，它等待的事件发生后便剥夺了任务 L 的 CPU 使用权。
(5) 任务 H 开始运行。
(6) 任务 H 运行过程中也要使用任务 L 正在使用着的资源，由于该资源的信号量还被任务
L 占用着，任务 H 只能进入挂起状态，等待任务 L 释放该信号量。
(7) 任务 L 继续运行。
(8) 由于任务 M 的优先级高于任务 L，当任务 M 等待的事件发生后，任务 M 剥夺了任务 L
的 CPU 使用权。
(9) 任务 M 处理该处理的事。
(10) 任务 M 执行完毕后，将 CPU 使用权归还给任务 L。
(11) 任务 L 继续运行。
(12) 最终任务 L 完成所有的工作并释放了信号量，到此为止，由于实时内核知道有个高优
先级的任务在等待这个信号量，故内核做任务切换。
(13) 任务 H 得到该信号量并接着运行。
在这种情况下，任务 H 的优先级实际上降到了任务 L 的优先级水平。因为任务 H 要一直
等待直到任务 L 释放其占用的那个共享资源。由于任务 M 剥夺了任务 L 的 CPU 使用权，使得
任务 H 的情况更加恶化， 这样就相当于任务 M 的优先级高于任务 H，导致优先级反转。
二、互斥信号量
为避免优先级反转这个问题，UCOSIII有种特殊的二进制信号量——互斥信号量，用于解决优先级反转问题
(1) 任务 H 与任务 M 处于挂起状态，等待某一事件的发生，任务 L 正在运行中。
(2) 某一时刻任务 L 想要访问共享资源，在此之前它必须先获得对应资源的互斥型信号量。
(3) 任务 L 获得互斥型信号量并开始使用该共享资源。
(4) 由于任务 H 优先级高，它等待的事件发生后便剥夺了任务 L 的 CPU 使用权。
(5) 任务 H 开始运行。
(6) 任务 H 运行过程中也要使用任务 L 在使用的资源，考虑到任务 L 正在占用着资源，
UCOSIII 会将任务 L 的优先级升至同任务 H 一样， 使得任务 L 能继续执行而不被其他中等优先
级的任务打断。
(7) 任务 L 以任务 H 的优先级继续运行，注意此时任务 H 并没有运行，因为任务 H 在等待
任务 L 释放掉互斥信号量。
(8) 任务 L 完成所有的任务，并释放掉互斥型信号量， UCOSIII 会自动将任务 L 的优先级
恢复到提升之前的值，然后 UCOSIII 会将互斥型信号量给正在等待着的任务 H。
(9) 任务 H 获得互斥信号量开始执行。
(10) 任务 H 不再需要访问共享资源，于是释放掉互斥型信号量。
(11) 由于没有更高优先级的任务需要执行，所以任务 H 继续执行。
(12) 任务 H 完成所有工作，并等待某一事件发生，此时 UCOSIII 开始运行在任务 H 或者
任务 L 运行过程中已经就绪的任务 M。
(13) 任务 M 继续执行。
注意！只有任务才能使用互斥信号量(中断服务程序则不可以)， UCOSIII 允许用户嵌套使
用互斥型信号量，一旦一个任务获得了一个互斥型信号量，则该任务最多可以对该互斥型信号
量嵌套使用 250 次，当然该任务只有释放相同的次数才能真正释放这个互斥型信号量。
与普通信号量一样，对于互斥信号量也可以进行许多操作，如表 9.3.1 所示，文件 os_mutex.c
是关于互斥信号量的。
三、相关API函数
1、定义互斥信号量
OS_MUTEX TEST_MUTEX; //定义一个互斥信号量
2、OSMutexCreate() 创建互斥信号量
OSMutexCreate( (OS_MUTEX*) &TEST_MUTEX,
(CPU_CHAR*) "TEST_MUTEX",
(OS_ERR*) &err);
void OSMutexCreate (OS_MUTEX *p_mutex, //指向互斥信号量
CPU_CHAR *p_name, //名字
OS_ERR *p_err) //错误码
3、OSMutexPend() 请求互斥信号量
OSMutexPend( &TEST_MUTEX, 0, OS_OPT_PEND_BLOCKING , 0, &err);
void OSMutexPend ( OS_MUTEX *p_mutex, //指向信号量
OS_TICK timeout, //超时等待时间
OS_OPT opt, //是否使用阻塞模式
CPU_TS *p_ts, //时间戳
OS_ERR *p_err) //错误码
4、OSMutexPost() 发送互斥信号量
OSMutexPost( &TEST_MUTEX,OS_ERR_NONE, &err );
void OSMutexPost ( OS_MUTEX *p_mutex, //指向信号量
OS_OPT opt, //选项
OS_ERR *p_err) //错误码
OS_OPT opt OS_OPT_POST_NONE 不指定特定的选项
OS_OPT_POST_NO_SCHED 禁止在本函数内执行任务调度操作。
四、实验设计
1、设计一个程序，任务A创建一个互斥信号量，和优先级由高到低的任务H、M、L
其中任务H、L都需要通过信号量请求访问共享资源，L长时间占用共享资源。
2、当不使用互斥信号量时，H、M优先级反转。
3、当使用互斥信号量时，程序正常运行。
五、程序源码
#include "led.h"
#include "delay.h"
#include "sys.h"
#include "bsp_key.h"
#include "usart.h"
#include "includes.h"
//任务优先级
#define START_TASK_PRIO 3
//任务堆栈大小
#define START_STK_SIZE 512
//任务控制块
OS_TCB StartTaskTCB;
//任务堆栈
CPU_STK START_TASK_STK[START_STK_SIZE];
//任务函数
void start_task(void *p_arg);
//任务优先级
#define TASK1_TASK_PRIO 4
//任务堆栈大小
#define TASK1_STK_SIZE 128
//任务控制块
OS_TCB Task1TaskTCB;
//任务堆栈
CPU_STK TASK1_TASK_STK[TASK1_STK_SIZE];
//任务函数
void task1_task(void *p_arg);
//任务优先级
#define TASK2_TASK_PRIO 5
//任务堆栈大小
#define TASK2_STK_SIZE 128
//任务控制块
OS_TCB Task2TaskTCB;
//任务堆栈
CPU_STK TASK2_TASK_STK[TASK2_STK_SIZE];
//任务函数
void task2_task(void *p_arg);
//任务优先级
#define TASK3_TASK_PRIO 6
//任务堆栈大小
#define TASK3_STK_SIZE 128
//任务控制块
OS_TCB Task3TaskTCB;
//任务堆栈
CPU_STK TASK3_TASK_STK[TASK3_STK_SIZE];
//任务函数
void task3_task(void *p_arg);
OS_MUTEX TEST_MUTEX; //定义一个互斥信号量
int main(void)
{
OS_ERR err;
CPU_SR_ALLOC();
delay_init ();
NVIC_PriorityGroupConfig (NVIC_PriorityGroup_2); //设置中断优先级
uart_init (115200); //初始化串口
printf("串口初始化完成\r\n");
LED_Init();
Key_GPIO_Config();
OSInit(&err);
OS_CRITICAL_ENTER(); //进入临界区
OSTaskCreate( (OS_TCB*) &StartTaskTCB, //任务控制块
(CPU_CHAR*) "start_task ", //任务名称
(OS_TASK_PTR) start_task, //任务函数
(void*) 0, //参数
(OS_PRIO) START_TASK_PRIO, //任务优先级
(CPU_STK*) &START_TASK_STK[0], //任务堆栈基地址
(CPU_STK_SIZE) START_STK_SIZE/10, //任务堆栈深度限位
(CPU_STK_SIZE) START_STK_SIZE, //任务堆栈大小
(OS_MSG_QTY) 0, //任务内部消息队列能够接收的最大消息数目,为0时禁止接收消息
(OS_TICK) 0, //当使能时间片轮转时的时间片长度，为0时为默认长度
(void*) 0, //用户补充的存储区
(OS_OPT) OS_OPT_TASK_STK_CHK|OS_OPT_TASK_STK_CLR, //任务选项
(OS_ERR*) &err); //存放该函数错误时的返回值
OS_CRITICAL_EXIT(); //退出临界区
OSStart(&err);
}
//开始任务函数
void start_task(void *p_arg)
{
OS_ERR err;
CPU_SR_ALLOC();
p_arg = p_arg;
CPU_Init();
#if OS_CFG_STAT_TASK_EN > 0u
OSStatTaskCPUUsageInit(&err); //统计任务
#endif
#ifdef CPU_CFG_INT_DIS_MEAS_EN //如果使能了测量中断关闭时间
CPU_IntDisMeasMaxCurReset();
#endif
#if OS_CFG_SCHED_ROUND_ROBIN_EN //当使用时间片轮转的时候
//使能时间片轮转调度功能,时间片长度为1个系统时钟节拍，既1*5=5ms
OSSchedRoundRobinCfg(DEF_ENABLED,1,&err);
#endif
OS_CRITICAL_ENTER(); //进入临界区
OSMutexCreate( (OS_MUTEX*) &TEST_MUTEX,
(CPU_CHAR*) "TEST_MUTEX",
(OS_ERR*) &err);
OSTaskCreate( (OS_TCB*) &Task1TaskTCB, //任务控制块
(CPU_CHAR*) "task1_task ", //任务名称
(OS_TASK_PTR) task1_task, //任务函数
(void*) 0, //参数
(OS_PRIO) TASK1_TASK_PRIO, //任务优先级
(CPU_STK*) &TASK1_TASK_STK[0],
(CPU_STK_SIZE) TASK1_STK_SIZE/10,
(CPU_STK_SIZE) TASK1_STK_SIZE,
(OS_MSG_QTY) 0,
(OS_TICK) 0,
(void*) 0,
(OS_OPT) OS_OPT_TASK_STK_CHK|OS_OPT_TASK_STK_CLR,
(OS_ERR*) &err);
OSTaskCreate( (OS_TCB*) &Task2TaskTCB, //任务控制块
(CPU_CHAR*) "task2_task ", //任务名称
(OS_TASK_PTR) task2_task, //任务函数
(void*) 0, //参数
(OS_PRIO) TASK2_TASK_PRIO, //任务优先级
(CPU_STK*) &TASK2_TASK_STK[0],
(CPU_STK_SIZE) TASK2_STK_SIZE/10,
(CPU_STK_SIZE) TASK2_STK_SIZE,
(OS_MSG_QTY) 0,
(OS_TICK) 0,
(void*) 0,
(OS_OPT) OS_OPT_TASK_STK_CHK|OS_OPT_TASK_STK_CLR,
(OS_ERR*) &err);
OSTaskCreate( (OS_TCB*) &Task3TaskTCB, //任务控制块
(CPU_CHAR*) "task3_task ", //任务名称
(OS_TASK_PTR) task3_task, //任务函数
(void*) 0, //参数
(OS_PRIO) TASK3_TASK_PRIO, //任务优先级
(CPU_STK*) &TASK3_TASK_STK[0],
(CPU_STK_SIZE) TASK3_STK_SIZE/10,
(CPU_STK_SIZE) TASK3_STK_SIZE,
(OS_MSG_QTY) 0,
(OS_TICK) 0,
(void*) 0,
(OS_OPT) OS_OPT_TASK_STK_CHK|OS_OPT_TASK_STK_CLR,
(OS_ERR*) &err);
OS_CRITICAL_EXIT(); //退出临界区
OSTaskDel ((OS_TCB*)&StartTaskTCB,&err); //删除任务自身
}
void task1_task(void *p_arg)
{
u8 task1_num=0;
OS_ERR err;
CPU_SR_ALLOC();
p_arg = p_arg;
while(1)
{
OSTimeDlyHMSM(0,0,0,500,OS_OPT_TIME_HMSM_STRICT,&err); //延时500MS
printf("任务1请求信号量\r\n");
OSMutexPend( &TEST_MUTEX, 0, OS_OPT_PEND_BLOCKING , 0, &err);
printf("任务1运行\r\n");
OSMutexPost( &TEST_MUTEX,OS_ERR_NONE, &err );
OSTimeDlyHMSM(0,0,0,500,OS_OPT_TIME_HMSM_STRICT,&err); //延时500MS
}
}
void task2_task(void *p_arg)
{
u8 task2_num=0;
OS_ERR err;
CPU_SR_ALLOC();
p_arg = p_arg;
while(1)
{
printf("任务2运行\r\n");
LED1=~LED1;
OSTimeDlyHMSM(0,0,1,0,OS_OPT_TIME_HMSM_STRICT,&err); //延时1s
}
}
void task3_task(void *p_arg)
{
static u32 i;
OS_ERR err;
CPU_SR_ALLOC();
p_arg = p_arg;
while(1)
{
OSMutexPend( &TEST_MUTEX, 0, OS_OPT_PEND_BLOCKING , 0, &err);
printf("任务3运行中\r\n");
for(i=0;i<5000000;i++)
{
OSSched();
}
OSMutexPost( &TEST_MUTEX,OS_ERR_NONE, &err );
OSTimeDlyHMSM(0,0,1,0,OS_ERR_NONE,&err); //延时1s
}
}
扫一扫
139
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
