UCOSII学习之路3 -任务同步之互斥

最新推荐文章于 2024-07-08 22:09:28 发布
最新推荐文章于 2024-07-08 22:09:28 发布
阅读量4.7k 收藏 7
点赞数 3
分类专栏： UCOS
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u014170207/article/details/75145668
版权
本文详细介绍了UCOSII中互斥信号量的概念和作用，区别于普通信号量，互斥信号量主要用于资源的互斥访问，防止优先级反转问题。文章通过代码解析了互斥信号量的创建、获取、删除和查询过程，揭示了其内部的工作机制，包括优先级提升和资源管理等关键点。
摘要由CSDN通过智能技术生成

上一节我们引入了信号量的概念，这一讲我们将揭晓互斥信号量的奥秘。

互斥信号量和信号量虽然都带了信号量的帽子，但是二者却有着不同的运用场合，互斥信号量相比而言经常用于一些资源的互斥访问，比如打印机、厕所等，这里的厕所指的是单厕，哈哈哈。这样有的人就要问了，那信号量设置起始cnt为1不也可以实现资源的互斥访问吗，这样的话我们直接使用信号量的实现不就可以了吗？答案当然是否认的，作为OS的开发者，哪些大咖们怎么可能没有想到这些问题。-----为了解决在信号量使用过程中一些任务的优先级反转问题(就是低优先级抢占CPU在高优先级任务前得到运行的现象)，于是乎给信号量来了一个优先级提升，但凡低优先级任务抢占CPU后，如果后面来了一个高优先级任务申请该"信号量"，那么低优先级任务将被提升到所有任务中最高优先级来保证"信号量"可以尽早的得到释放。然后就成了我们今天要谈的互斥信号量。


首先来看看互斥信号量在事件控制块的基础上使用了哪些资源。


从图中 可以看出，OSEventType用于指示资源的类型，而对于，其实OSEventCnt的高八位用于存放提升后的优先级，而前面则用于指示资源的状态，以及在优先级提升后短暂的存放开始的任务优先级，后两个OSEventGrp和OSEventTbl[]在任何一种类型的等待事件过程中都会使用，我们不讲，那我们就来说说OSEventPtr，很多人都任务在互斥里边他没有被使用，直接指向NULL，其实不然，他其实指向了任务的TCB。


互斥信号量的操作一共6个函数
OS_EVENT  *OSMutexCreate(INT8U  prio,  INT8U *perr); //互斥信号量的创建
void  OSMutexPend (OS_EVENT *pevent, INT32U timeout,  INT8U  *perr);//挂起
INT8U  OSMutexPost (OS_EVENT *pevent);//释放
BOOLEAN  OSMutexAccept (OS_EVENT  *pevent, INT8U     *perr);//无等待挂起
OS_EVENT  *OSMutexDel (OS_EVENT  *pevent, INT8U  opt,  INT8U     *perr);//删除互斥量
INT8U  OSMutexQuery (OS_EVENT  *pevent,  OS_MUTEX_DATA  *p_mutex_data);//查询

一个内部函数
static  void  OSMutex_RdyAtPrio (OS_TCB  *ptcb, INT8U    prio);

其通讯机理如下图



好了  相信大家对互斥信号量有了一个初步的认识。那我们继续

       与以往相同，我们来分析分析这些函数的内部实现

[cpp]  view plain   copy
  1. OS_EVENT  *OSMutexCreate (INT8U   prio,  
  2.                          INT8U  *perr)  
  3. {  
  4.     OS_EVENT  *pevent;  
  5. #if OS_CRITICAL_METHOD == 3u                               /* Allocate storage for CPU status register */  
  6.     OS_CPU_SR  cpu_sr = 0u;  
  7. #endif  
  8.   
  9. #ifdef OS_SAFETY_CRITICAL  
  10.     if (perr == (INT8U *)0) {  
  11.         OS_SAFETY_CRITICAL_EXCEPTION();  
  12.         return ((OS_EVENT *)0);  
  13.     }  
  14. #endif  
  15.   
  16. #ifdef OS_SAFETY_CRITICAL_IEC61508  
  17.     if (OSSafetyCriticalStartFlag == OS_TRUE) {  
  18.         OS_SAFETY_CRITICAL_EXCEPTION();  
  19.         return ((OS_EVENT *)0);  
  20.     }  
  21. #endif  
  22.   
  23. #if OS_ARG_CHK_EN > 0u  
  24.     if (prio != OS_PRIO_MUTEX_CEIL_DIS) { //Prio安全范围检测，其可通过OS_PRIO_MUTEX_CEIL_DIS来失能  
  25.         if (prio >= OS_LOWEST_PRIO) {                      /* Validate PCP                             */  
  26.            *perr = OS_ERR_PRIO_INVALID;  
  27.             return ((OS_EVENT *)0);  
  28.         }  
  29.     }  
  30. #endif  
  31.     if (OSIntNesting > 0u) {                               /* See if called from ISR ...               */  
  32.         *perr = OS_ERR_CREATE_ISR;                         /* ... can't CREATE mutex from an ISR       */  
  33.         return ((OS_EVENT *)0);  
  34.     }  
  35.     OS_ENTER_CRITICAL();  
  36.     if (prio != OS_PRIO_MUTEX_CEIL_DIS) { //  
  37.         if (OSTCBPrioTbl[prio] != (OS_TCB *)0) {        //检查提升的优先级是否占用  
  38.             OS_EXIT_CRITICAL();                            /* Task already exist at priority ...       */  
  39.            *perr = OS_ERR_PRIO_EXIST;       
  40.             return ((OS_EVENT *)0);  
  41.         }  
  42.         OSTCBPrioTbl[prio] = OS_TCB_RESERVED;              //没有被占用 将保留                 */  
  43.     }  
  44.   
  45.     pevent = OSEventFreeList;                              /* Get next free event control block        */  
  46.     if (pevent == (OS_EVENT *)0) {            //事件控制块资源耗尽              
  47.         if (prio != OS_PRIO_MUTEX_CEIL_DIS) { //  
  48.             OSTCBPrioTbl[prio] = (OS_TCB *)0;      //释放占用的TCB优先级资源  
  49.         }  
  50.         OS_EXIT_CRITICAL();  
  51.        *perr = OS_ERR_PEVENT_NULL;                         /* No more event control blocks             */  
  52.         return (pevent);  
  53.     }  
  54.     OSEventFreeList     = (OS_EVENT *)OSEventFreeList->OSEventPtr; /* Adjust the free list             */  
  55.     OS_EXIT_CRITICAL();  
  56.     pevent->OSEventType = OS_EVENT_TYPE_MUTEX;  
  57.     pevent->OSEventCnt  = (INT16U)((INT16U)prio << 8u) | OS_MUTEX_AVAILABLE;// 将提升的优先级放到cnt的高八位  
  58.     pevent->OSEventPtr  = (void *)0;                       /* No task owning the mutex                 */  
  59. #if OS_EVENT_NAME_EN > 0u  
  60.     pevent->OSEventName = (INT8U *)(void *)"?";  
  61. #endif  
  62.     OS_EventWaitListInit(pevent);//初始化事件等待list  
  63.    *perr = OS_ERR_NONE;  
  64.     return (pevent);  
  65. }  
该函数的目的是初始化事件控制块为互斥信号量，其中，当prio输入为OS_PRIO_MUTEX_CEIL_DIS，任务将不进行优先级提升，此时和单一的信号量的作用是相同的。还有一点也是需要特别留意，如果任务的优先级提升了，那么任务在使用完指定资源过后，怎么重新恢复他原有的优先级呢？想必看过源码的都已经了解了，这也是UCOS设计者的另外一个高明之处---变量的复用，通过将提升后的任务优先级放到OSEventCnt的高八位，从而保存该优先级而不需要重新定义变量，节省了系统对RAM的要求。

[cpp]  view plain   copy
  1. void  OSMutexPend (OS_EVENT  *pevent,  
  2.                    INT32U     timeout,  
  3.                    INT8U     *perr)  
  4. {  
  5.     INT8U      pcp;                                        /* Priority Ceiling Priority (PCP)          */  
  6.     INT8U      mprio;                                      /* Mutex owner priority                     */  
  7.     BOOLEAN    rdy;                                        /* Flag indicating task was ready           */  
  8.     OS_TCB    *ptcb;  
  9.     OS_EVENT  *pevent2;  
  10.     INT8U      y;  
  11. #if OS_CRITICAL_METHOD == 3u                               /* Allocate storage for CPU status register */  
  12.     OS_CPU_SR  cpu_sr = 0u;  
  13. #endif  
  14.   
  15.   
  16.   
  17. #ifdef OS_SAFETY_CRITICAL  
  18.     if (perr == (INT8U *)0) {  
  19.         OS_SAFETY_CRITICAL_EXCEPTION();  
  20.         return;  
  21.     }  
  22. #endif  
  23.   
  24. #if OS_ARG_CHK_EN > 0u  
  25.     if (pevent == (OS_EVENT *)0) {                         /* Validate 'pevent'                        */  
  26.         *perr = OS_ERR_PEVENT_NULL;  
  27.         return;  
  28.     }  
  29. #endif  
  30.     if (pevent->OSEventType != OS_EVENT_TYPE_MUTEX) {      /* Validate event block type                */  
  31.         *perr = OS_ERR_EVENT_TYPE;  
  32.         return;  
  33.     }  
  34.     if (OSIntNesting > 0u) {                               /* See if called from ISR ...               */  
  35.         *perr = OS_ERR_PEND_ISR;                           /* ... can't PEND from an ISR               */  
  36.         return;  
  37.     }  
  38.     if (OSLockNesting > 0u) {                              /* See if called with scheduler locked ...  */  
  39.         *perr = OS_ERR_PEND_LOCKED;                        /* ... can't PEND when locked               */  
  40.         return;  
  41.     }  
  42. /*$PAGE*/       //前面全部是一些参数的范围检查之类的我们不做解释  
  43.     OS_ENTER_CRITICAL();  
  44.     pcp = (INT8U)(pevent->OSEventCnt >> 8u);               /* Get PCP from mutex                       */  
  45.                                                            /* Is Mutex available?                      */  
  46.     if ((INT8U)(pevent->OSEventCnt & OS_MUTEX_KEEP_LOWER_8) == OS_MUTEX_AVAILABLE) { //表明当前资源未被占用  
  47.         pevent->OSEventCnt &= OS_MUTEX_KEEP_UPPER_8;       //设置资源被占用  
  48.         pevent->OSEventCnt |= OSTCBCur->OSTCBPrio;         //将原优先级保存到cnt低八位  
  49.         pevent->OSEventPtr  = (void *)OSTCBCur;           //指向提升前的TCB块  
  50.         if ((pcp != OS_PRIO_MUTEX_CEIL_DIS) &&  
  51.             (OSTCBCur->OSTCBPrio <= pcp)) {                //进入表示允许优先级提升  
  52.              OS_EXIT_CRITICAL();                           /*      ... than current task!              */  
  53.             *perr = OS_ERR_PCP_LOWER;  //提升优先级失败，原因在于提升后的优先级<当前优先级  
  54.         } else {  
  55.              OS_EXIT_CRITICAL();  
  56.             *perr = OS_ERR_NONE;  
  57.         }  
  58.         return;  
  59.     } //以上为资源没有被占用的情况  
  60.     if (pcp != OS_PRIO_MUTEX_CEIL_DIS) {  
  61.         mprio = (INT8U)(pevent->OSEventCnt & OS_MUTEX_KEEP_LOWER_8); //获取原优先级  
  62.         ptcb  = (OS_TCB *)(pevent->OSEventPtr);                   /*     Point to TCB of mutex owner   */  
  63.         if (ptcb->OSTCBPrio > pcp) {                             //当提升优先级高于原优先级  
  64.             if (mprio > OSTCBCur->OSTCBPrio) { //同时当前申请互斥资源的任务优先级高于原优先级，将实现优先级提升  
  65.                 y = ptcb->OSTCBY; //获取以前优先级的组号  
  66.                 if ((OSRdyTbl[y] & ptcb->OSTCBBitX) != 0u) {      //存在就绪任务  
  67.                     OSRdyTbl[y] &= (OS_PRIO)~ptcb->OSTCBBitX;     /*     Yes, Remove owner from Rdy ...*/  
  68.                     if (OSRdyTbl[y] == 0u) {                      /*          ... list at current prio */  
  69.                         OSRdyGrp &= (OS_PRIO)~ptcb->OSTCBBitY;  
  70.                     }  
  71.                     rdy = OS_TRUE; //清除就绪标志 并设立标志  
  72.                 } else {  
  73.                     pevent2 = ptcb->OSTCBEventPtr;  
  74.                     if (pevent2 != (OS_EVENT *)0) {               /* Remove from event wait list       */  
  75.                         y = ptcb->OSTCBY;  
  76.                         pevent2->OSEventTbl[y] &= (OS_PRIO)~ptcb->OSTCBBitX;  
  77.                         if (pevent2->OSEventTbl[y] == 0u) {  
  78.                             pevent2->OSEventGrp &= (OS_PRIO)~ptcb->OSTCBBitY;  
  79.                         }  
  80.                     }  
  81.                     rdy = OS_FALSE;                        /* No                                       */  
  82.                 }  
  83.                 ptcb->OSTCBPrio = pcp;                     //提升原优先级为pcp        
  84. #if OS_LOWEST_PRIO <= 63u  
  85.                 ptcb->OSTCBY    = (INT8U)( ptcb->OSTCBPrio >> 3u);  
  86.                 ptcb->OSTCBX    = (INT8U)( ptcb->OSTCBPrio & 0x07u);  
  87. #else  
  88.                 ptcb->OSTCBY    = (INT8U)((INT8U)(ptcb->OSTCBPrio >> 4u) & 0xFFu);  
  89.                 ptcb->OSTCBX    = (INT8U)( ptcb->OSTCBPrio & 0x0Fu);  
  90. #endif  
  91.                 ptcb->OSTCBBitY = (OS_PRIO)(1uL << ptcb->OSTCBY);  
  92.                 ptcb->OSTCBBitX = (OS_PRIO)(1uL << ptcb->OSTCBX);  
  93.   
  94.                 if (rdy == OS_TRUE) {                     //完成未完成前任务的就绪状态  
  95.                     OSRdyGrp               |= ptcb->OSTCBBitY; /* ... make it ready at new priority.   */  
  96.                     OSRdyTbl[ptcb->OSTCBY] |= ptcb->OSTCBBitX;  
  97.                 } else {  
  98.                     pevent2 = ptcb->OSTCBEventPtr;  
  99.                     if (pevent2 != (OS_EVENT *)0) {        /* Add to event wait list                   */  
  100.                         pevent2->OSEventGrp               |= ptcb->OSTCBBitY;  
  101.                         pevent2->OSEventTbl[ptcb->OSTCBY] |= ptcb->OSTCBBitX;  
  102.                     }  
  103.                 }  
  104.                 OSTCBPrioTbl[pcp] = ptcb; //写入优先级组  
  105.             }  
  106.         }  
  107.     }  
  108.     OSTCBCur->OSTCBStat     |= OS_STAT_MUTEX;         /* Mutex not available, pend current task        */  
  109.     OSTCBCur->OSTCBStatPend  = OS_STAT_PEND_OK;  
  110.     OSTCBCur->OSTCBDly       = timeout;               /* Store timeout in current task's TCB           */  
最低0.47元/天 解锁文章
EtcFly
关注
  • 3
    点赞
  • 踩
  • 7
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
详解UCOS中的互斥信号量
路漫漫其修远兮,吾将上下而求索
04-23 8227
二值信号量主要用于进行共享资源的独占式访问，比如我们用一个变量来标志一个资源是否可用，当这个变量为1的时候表示资源可用，当这个资源为0的时候表示资源不可用，但是二值信号量容易产生优先级反转，影响系统的实时性。互斥信号量一般用于降解优先级反转，
实验51 UCOSII实验1-1-任务调度.zip
05-05
3. **事件控制块（OSEventCtrlBlk）**：UCOSII中的任务可能需要等待某些事件，如信号量、互斥锁或消息队列。任务通过调用OSWait函数挂起自己，直到指定的事件发生。 4. **任务状态**：任务有三种基本状态：就绪、...
【Ucos-III源码分析】——互斥信号量（互斥锁）
m0_58457065的博客
07-05 1132
mutex互斥信号量（互斥锁）
UCOS-III 任务同步机制-事件标志
最新发布
TechIoT - 探索物联网与嵌入式系统
07-08 295
UCOS-III任务同步机制-事件队列, 状态事件处理，瞬态事件处理
ucosii任务间的同步与通信
进步源于记录，优秀来自分享
03-01 3858
ucosii任务间的同步和通信都可以通过“事件”的方式来搞定，这个事件包括：信号量、互斥量、邮箱和消息队列其中信号量和互斥量用于同步，邮箱和消息队列可用于通信。任务中有任务控制块，同样，在“事件”中有事件控制块ECBtypedef struct os_event { INT8U OSEventType; /* Type of event cont...
uCOS学习笔记——任务调度机制（中断，临界区，信号量，互斥锁）
weixin_72589081的博客
03-24 2708
uCOS任务调度机制——中断，临界区，信号量，互斥锁
Ucos2之互斥锁
qq_35480173的博客
08-31 1415
本博客用于鄙人的每周总结，如有错误不妥之处，还望各位前辈指导。谢谢！ 一、互斥锁是什么东西? 互斥锁是一种uCos2对资源保护的措施，比如任务需要访问某些资源的，但是这些资源不能同时被几个任务访问，这个时候就需要互斥锁这类的技术。互斥锁保护的资源要求，同时访问该资源的任务只能有一个，如果其他任务需要访问，则需要等待。那么程序如何实现互斥锁了？这里我列出了，使用互斥锁所需要解决的问题。 怎么创...
ucosII-source-files-with-Chinese.rar_ucosii中文注释
09-19
这个压缩包“ucosII-source-files-with-Chinese.rar”包含了UCOS-II的源码，并且特别之处在于，源码中添加了中文注释，这对于中国开发者来说，无疑极大地降低了理解和使用UCOS-II的门槛。 UCOS-II的核心设计目标是...
UCOS-II_core9.rar_ucos ii 2._ucos-ii
09-19
《uCOS-II内核分析移植与驱动程序开发》是一本深入解析嵌入式实时操作系统（RTOS）uCOS-II的专业书籍，其第9章的源代码是本书的重点内容之一。uCOS-II是Micrium公司开发的一个小巧、高效且高度可移植的实时操作系统...
uCOS.rar_uCOS II_ucos_ucos 代码_ucos-ii
09-23
- uCOS-II的任务管理是其核心组件之一，它允许创建、删除、挂起和恢复任务。每个任务都有一个优先级，用于决定任务调度。 - 任务间通信通过消息队列、信号量、互斥信号量等机制实现，确保了任务间的同步与协调。 ...
ALIENTEK MINISTM32 UCOSII实验1-任务调度
05-17
此外，UCOSII还提供了其他功能，如信号量、互斥锁、消息队列和事件标志组，用于任务间的同步和通信。在ALIENTEK MINISTM32实验中，你可能会接触到这些机制，以实现不同任务之间的协作。 总之，通过ALIENTEK MINISTM...
ucosii 互斥信号量
07-17
ucosii 互斥信号量
stm32搭载ucosII互斥信号量的研究
07-13
stm32上搭载ucosII对于信号量的应用实例
UCOS2：对于信号量，互斥信号量，事件标志组的个人理解
06-27
UCOS2：对于信号量，互斥信号量，事件标志组的个人理解，看起来挺好的。
ucos实时操作系统学习笔记——任务间通信（互斥锁）
ba_wang_mao的专栏
01-22 763
想讲一下ucos任务间通信中的mutex，感觉其设计挺巧妙，同sem一样使用的是event机制实现的，代码不每一行都分析,因为讲的没邵贝贝老师清楚，主要讲一下mutex的内核是如何实现的。可以理解互斥锁是设置信号量值为1时候的特殊情况，与之不同的地方是互斥锁为了避免优先级反转采用了优先级继承机制，本文主要讲一下互斥锁的创建，pend和post，对应的函数是OSMutexCreate，OSMutex...
UCOSII互斥锁的使用
暗夜
10-16 6493
互斥性信号量的使用 互斥型信号量的使用与信号量的使用差不多，但还需要一个较高的空闲优先级，这个级别要比使用这个互斥型信号量的所有任务优先级都高（数字更小） 建立互斥型信号量： OS_EVENT *OSMutexCreate(INT8U prio,INT8U *err) 返回值赋给信号量 参数prio：较高的空闲优先级，用于任务提权 参数err：存放出错信息
ucosii基础-互斥
enjoy trouble
09-05 189
添加链接描述
ucos-ii信号量总结
热门推荐
OSKernelLAB(gatieme)
03-12 2万+
1． 信号量的理解 （1）uc/os-ii的信号量是由两个部分组成：一部分是16位的无符号整型信号量的计数值(0~65535)；另一部分是等待该信号量的任务组成的等待任务表。（另外参考事件控制块ECB） （2）信号量可以是2值的变量（称为二值信号量），也可以是计数式的。根据信号量的值，内核跟踪那些等待信号量的任务。 （3）建立信号量的工作必须在任务级代码中或者多任务启动之前完成。 （4）任
UCOS-III 互斥量
guyuani的博客
10-16 2243
互斥量本质是一种特殊的二值信号量，也不具备传递数据的功能。与二值信号量不同的是：它具有优先级继承机制、支持互斥量所有权、递归访问以及防止优先级翻转的特性，用于实现对临界资源的独占式处理。 任意时刻互斥量的状态只有两种，开锁或闭锁。当互斥量被任务持有时，该互斥量处于闭锁状态，这个任务获得互斥量的所有权。当该任务释放这个互斥量时，该互斥量处于开锁状态，任务失去该互斥量的所有权。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值