uC/OS-III之资源管理--互斥型信号量

最新推荐文章于 2024-07-30 05:48:00 发布
最新推荐文章于 2024-07-30 05:48:00 发布
阅读量1.9k 收藏 1
点赞数 1
分类专栏： uC/OS-III 文章标签： uC-OS-III 资源管理 互斥型信号量
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/linuxweiyh/article/details/72846459
版权

1.uC/OS-III支持一种特殊的二进制信号量–互斥型信号量。

2.互斥型信号量通过安全优先级继承机制（一旦一个具有高优先级的任务H想要访问共享资源，占有该资源的任务的优先级将被提升至与任务H一样），来避免无界优先级翻转的问题。

3.互斥型信号量是一种被定义为OS_MUTEX数据类型的内核对象，它的定义位于os.h中。
注：与信号量一样，只有任务才能使用互斥型信号量（中断服务程序不可以）。

typedef  struct  os_mutex            OS_MUTEX;              // 625行

struct  os_mutex {                                          // 817行 - 830行
    OS_OBJ_TYPE          Type;                              // 互斥信号量的类型，必须设置成OS_OBJ_TYPE_MUTEX
    CPU_CHAR            *NamePtr;                           // 互斥信号量的名称
    OS_PEND_LIST         PendList;                          // 任务挂起表
#if OS_CFG_DBG_EN > 0u                                      // 调试相关
    OS_MUTEX            *DbgPrevPtr;
    OS_MUTEX            *DbgNextPtr;
    CPU_CHAR            *DbgNamePtr;
#endif
    OS_TCB              *OwnerTCBPtr;                       // 指向占有该互斥信号量的任务的任务控制块OS_TCB
    OS_PRIO              OwnerOriginalPrio;                 // 记录任务占有互斥信号量之前的优先级
    OS_NESTING_CTR       OwnerNestingCtr;                   // 互斥信号量的嵌套深度
    CPU_TS               TS;                                // 记录上一次被释放的时间
};

4.互斥型信号量通过OSMutexCreate()创建，它的定义位于os_mutex.c中。

void  OSMutexCreate (OS_MUTEX    *p_mutex,
                     CPU_CHAR    *p_name,
                     OS_ERR      *p_err)                    // 66行 - 118行
{
    CPU_SR_ALLOC();                                         // 声明变量cpu_sr，用来临时存储CPU的状态寄存器

#ifdef OS_SAFETY_CRITICAL                                   // 系统安全性检查
    if (p_err == (OS_ERR *)0) {
        OS_SAFETY_CRITICAL_EXCEPTION();
        return;
    }
#endif

#ifdef OS_SAFETY_CRITICAL_IEC61508                          // 系统安全性检查（IEC61508）
    if (OSSafetyCriticalStartFlag == DEF_TRUE) {
       *p_err = OS_ERR_ILLEGAL_CREATE_RUN_TIME;
        return;
    }
#endif

#if OS_CFG_CALLED_FROM_ISR_CHK_EN > 0u                      // 允许进行ISR调用检查
    if (OSIntNestingCtr > (OS_NESTING_CTR)0) {              // 不允许在ISR中调用
        *p_err = OS_ERR_CREATE_ISR;
        return;
    }
#endif

#if OS_CFG_ARG_CHK_EN > 0u                                  // 允许参数检查
    if (p_mutex == (OS_MUTEX *)0) {                         // 无效参数
        *p_err = OS_ERR_OBJ_PTR_NULL;
        return;
    }
#endif

    CPU_CRITICAL_ENTER();                                   // 进入临界区
    p_mutex->Type              =  OS_OBJ_TYPE_MUTEX;        // 标记结构体为互斥型信号量
    p_mutex->NamePtr           =  p_name;
    p_mutex->OwnerTCBPtr       = (OS_TCB       *)0;
    p_mutex->OwnerNestingCtr   = (OS_NESTING_CTR)0;         // 当OwnerNestingCtr为0时，互斥信号量可用
    p_mutex->TS                = (CPU_TS        )0;
    p_mutex->OwnerOriginalPrio =  OS_CFG_PRIO_MAX;
    OS_PendListInit(&p_mutex->PendList);                    // 初始化挂起表

#if OS_CFG_DBG_EN > 0u
    OS_MutexDbgListAdd(p_mutex);
#endif
    OSMutexQty++;                                           // 系统互斥信号量数目加1

    CPU_CRITICAL_EXIT();                                    // 退出临界区
    *p_err = OS_ERR_NONE;
}

5.等待互斥信号量使用OSMutexPend()，它的定义位于os_mutex.c中。

void  OSMutexPend (OS_MUTEX   *p_mutex,
                   OS_TICK     timeout,
                   OS_OPT      opt,
                   CPU_TS     *p_ts,
                   OS_ERR     *p_err)                         // 329行 - 493行
{
    OS_PEND_DATA  pend_data;
    OS_TCB       *p_tcb;
    CPU_SR_ALLOC();                                           // 声明变量cpu_sr，用来临时存储CPU的状态寄存器

#ifdef OS_SAFETY_CRITICAL                                   // 系统安全性检查
    if (p_err == (OS_ERR *)0) {
        OS_SAFETY_CRITICAL_EXCEPTION();
        return;
    }
#endif

#if OS_CFG_CALLED_FROM_ISR_CHK_EN > 0u                      // 允许进行ISR调用检查
    if (OSIntNestingCtr > (OS_NESTING_CTR)0) {              // 不允许在ISR中调用该函数
       *p_err = OS_ERR_PEND_ISR;
        return;
    }
#endif

#if OS_CFG_ARG_CHK_EN > 0u                                  // 允许进行参数检查
    if (p_mutex == (OS_MUTEX *)0) {                         // 无效的参数
        *p_err = OS_ERR_OBJ_PTR_NULL;
        return;
    }
    switch (opt) {
        case OS_OPT_PEND_BLOCKING:
        case OS_OPT_PEND_NON_BLOCKING:
             break;
        default:                                            // 无效的选项
             *p_err = OS_ERR_OPT_INVALID;
             return;
    }
#endif

#if OS_CFG_OBJ_TYPE_CHK_EN > 0u                             // 允许进行类型检查
    if (p_mutex->Type != OS_OBJ_TYPE_MUTEX) {               // 确保互斥型已被创建
        *p_err = OS_ERR_OBJ_TYPE;
        return;
    }
#endif

    if (p_ts != (CPU_TS *)0) {
       *p_ts  = (CPU_TS  )0;                                // 初始化返回的时间戳参数
    }

    CPU_CRITICAL_ENTER();                                   // 进入临界区
    if (p_mutex->OwnerNestingCtr == (OS_NESTING_CTR)0) {    // 嵌套层数OwnerNestingCtr为0时，表示互斥信号量可用
        p_mutex->OwnerTCBPtr       =  OSTCBCurPtr;
        p_mutex->OwnerOriginalPrio =  OSTCBCurPtr->Prio;
        p_mutex->OwnerNestingCtr   = (OS_NESTING_CTR)1;
        if (p_ts != (CPU_TS *)0) {
           *p_ts                   = p_mutex->TS;           // 返回上次释放互斥信号量的时间
        }
        CPU_CRITICAL_EXIT();                                // 退出临界区
        *p_err                     =  OS_ERR_NONE;
        return;
    }
                                                            // 互斥信号量不可用
    if (OSTCBCurPtr == p_mutex->OwnerTCBPtr) {              // 当前任务正在使用互斥信号量
        p_mutex->OwnerNestingCtr++;                         // 嵌套层数加1
        if (p_ts != (CPU_TS *)0) {
           *p_ts  = p_mutex->TS;
        }
        CPU_CRITICAL_EXIT();                                // 退出临界区
        *p_err = OS_ERR_MUTEX_OWNER;                        // 说明一下当前任务已拥有该互斥信号量
        return;
    }

    if ((opt & OS_OPT_PEND_NON_BLOCKING) != (OS_OPT)0) {    // 非阻塞型
        CPU_CRITICAL_EXIT();                                // 退出临界区
        *p_err = OS_ERR_PEND_WOULD_BLOCK;
        return;
    } else {                                                // 阻塞型
        if (OSSchedLockNestingCtr > (OS_NESTING_CTR)0) {    // 调度器是锁定
            CPU_CRITICAL_EXIT();                            // 退出临界区
            *p_err = OS_ERR_SCHED_LOCKED;
            return;
        }
    }
                                                            // 阻塞型
    OS_CRITICAL_ENTER_CPU_CRITICAL_EXIT();                  // 进入临界区，使能中断
    p_tcb = p_mutex->OwnerTCBPtr;                           // 执行占有该互斥信号量的任务的任务控制块OS_TCB
    if (p_tcb->Prio > OSTCBCurPtr->Prio) {                  // 拥有互斥信号量的任务的优先级低于当前任务的优先级
        switch (p_tcb->TaskState) {
            case OS_TASK_STATE_RDY:
                 OS_RdyListRemove(p_tcb);                   // 把当前任务从就绪表中删除
                 p_tcb->Prio = OSTCBCurPtr->Prio;           // 提升拥有互斥信号量的任务的优先级
                 OS_PrioInsert(p_tcb->Prio);                // 更新优先级位映射表
                 OS_RdyListInsertHead(p_tcb);               // 插入到任务就绪表中
                 break;
            case OS_TASK_STATE_DLY:
            case OS_TASK_STATE_DLY_SUSPENDED:
            case OS_TASK_STATE_SUSPENDED:
                 p_tcb->Prio = OSTCBCurPtr->Prio;           // 仅仅提高拥有互斥信号量的任务的优先级
                 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:
                 OS_PendListChangePrio(p_tcb,
                                       OSTCBCurPtr->Prio);  // 改变挂起表中的优先级
                 break;

            default:
                 OS_CRITICAL_EXIT();                        // 退出临界区
                 *p_err = OS_ERR_STATE_INVALID;
                 return;
        }
    }

    OS_Pend(&pend_data,                                     // ？？？
             (OS_PEND_OBJ *)((void *)p_mutex),
             OS_TASK_PEND_ON_MUTEX,
             timeout);

    OS_CRITICAL_EXIT_NO_SCHED();                            // 退出临界区，不调度
    OSSched();                                              // 执行调度程序

    CPU_CRITICAL_ENTER();                                   // 进入临界区
    switch (OSTCBCurPtr->PendStatus) {
        case OS_STATUS_PEND_OK:                             // 得到互斥信号量
             if (p_ts != (CPU_TS *)0) {
                *p_ts  = OSTCBCurPtr->TS;
             }
             *p_err = OS_ERR_NONE;
             break;
        case OS_STATUS_PEND_ABORT:                          // 等待被禁止
             if (p_ts != (CPU_TS *)0) {
                *p_ts  = OSTCBCurPtr->TS;
             }
             *p_err = OS_ERR_PEND_ABORT;
             break;
        case OS_STATUS_PEND_TIMEOUT:                        // 等待超时
             if (p_ts != (CPU_TS *)0) {
                *p_ts  = (CPU_TS  )0;
             }
             *p_err = OS_ERR_TIMEOUT;
             break;
        case OS_STATUS_PEND_DEL:                            // 互斥信号量被删除
             if (p_ts != (CPU_TS *)0) {
                *p_ts  = OSTCBCurPtr->TS;
             }
             *p_err = OS_ERR_OBJ_DEL;
             break;
        default:
             *p_err = OS_ERR_STATUS_INVALID;
             break;
    }
    CPU_CRITICAL_EXIT();                                    // 退出临界区
}

6.任务释放互斥型信号量使用OSMutexPost()，它的定义位于os_mutex.c中。

void  OSMutexPost (OS_MUTEX  *p_mutex,
                   OS_OPT     opt,
                   OS_ERR    *p_err)                           // 636行 - 727行
{
    OS_PEND_LIST  *p_pend_list;
    OS_TCB        *p_tcb;
    CPU_TS         ts;
    CPU_SR_ALLOC();                                         // 声明变量cpu_sr，用来临时保存CPU的状态寄存器

#ifdef OS_SAFETY_CRITICAL                                   // 允许进行系统安全性检查
    if (p_err == (OS_ERR *)0) {
        OS_SAFETY_CRITICAL_EXCEPTION();
        return;
    }
#endif

#if OS_CFG_CALLED_FROM_ISR_CHK_EN > 0u                      // 允许进行ISR调用检查
    if (OSIntNestingCtr > (OS_NESTING_CTR)0) {              // 不允许在ISR中调用该函数
       *p_err = OS_ERR_POST_ISR;
        return;
    }
#endif

#if OS_CFG_ARG_CHK_EN > 0u                                  // 允许进行参数检查
    if (p_mutex == (OS_MUTEX *)0) {                         // 无效参数
        *p_err = OS_ERR_OBJ_PTR_NULL;
        return;
    }
#endif

#if OS_CFG_OBJ_TYPE_CHK_EN > 0u                             // 允许进行目标类型检查
    if (p_mutex->Type != OS_OBJ_TYPE_MUTEX) {               // 该对象不是互斥型信号量
        *p_err = OS_ERR_OBJ_TYPE;
        return;
    }
#endif

    CPU_CRITICAL_ENTER();                                   // 进入临界区
    if (OSTCBCurPtr != p_mutex->OwnerTCBPtr) {              // 当前任务不是拥有该互斥型信号量的任务
        CPU_CRITICAL_EXIT();                                // 退出临界区
        *p_err = OS_ERR_MUTEX_NOT_OWNER;
        return;
    }

    OS_CRITICAL_ENTER_CPU_CRITICAL_EXIT();                  // 进入临界区，使能中断
    ts          = OS_TS_GET();                              // 获取时间戳
    p_mutex->TS = ts;
    p_mutex->OwnerNestingCtr--;                             // 减少互斥信号量的嵌套层数
    if (p_mutex->OwnerNestingCtr > (OS_NESTING_CTR)0) {     // 嵌套层数不为0，表示操作未完成
        OS_CRITICAL_EXIT();                                 // 退出临界区
        *p_err = OS_ERR_MUTEX_NESTING;
        return;
    }

    p_pend_list = &p_mutex->PendList;                       // 获取挂起表
    if (p_pend_list->NbrEntries == (OS_OBJ_QTY)0) {         // 挂起表为空（没有任务等待该互斥信号量）
        p_mutex->OwnerTCBPtr     = (OS_TCB       *)0;
        p_mutex->OwnerNestingCtr = (OS_NESTING_CTR)0;
        OS_CRITICAL_EXIT();                                 // 退出临界区
        *p_err = OS_ERR_NONE;
        return;
    }
                                                            // 挂起表不为空
    if (OSTCBCurPtr->Prio != p_mutex->OwnerOriginalPrio) {  // 任务的当前优先级与它之前的优先级不同
        OS_RdyListRemove(OSTCBCurPtr);                      // 把当前任务从就绪表中删除
        OSTCBCurPtr->Prio = p_mutex->OwnerOriginalPrio;     // 恢复其之前的优先级
        OS_PrioInsert(OSTCBCurPtr->Prio);                   // 更新优先级位映射表
        OS_RdyListInsertTail(OSTCBCurPtr);                  // 插入到就绪表中的尾部
        OSPrioCur         = OSTCBCurPtr->Prio;
    }
                                                            // 获取挂起表中的头部的OS_TCB
    p_tcb                      = p_pend_list->HeadPtr->TCBPtr;
    p_mutex->OwnerTCBPtr       = p_tcb;                     // 给互斥型信号量一个新的拥有者
    p_mutex->OwnerOriginalPrio = p_tcb->Prio;
    p_mutex->OwnerNestingCtr   = (OS_NESTING_CTR)1;

    OS_Post((OS_PEND_OBJ *)((void *)p_mutex),               // 发送互斥型信号量
            (OS_TCB      *)p_tcb,
            (void        *)0,
            (OS_MSG_SIZE  )0,
            (CPU_TS       )ts);

    OS_CRITICAL_EXIT_NO_SCHED();                            // 退出临界区，不调度

    if ((opt & OS_OPT_POST_NO_SCHED) == (OS_OPT)0) {
        OSSched();                                          // 执行调度程序
    }
    *p_err = OS_ERR_NONE;
}
linuxweiyh
关注
专栏目录
ucosIII 共享资源（信号量、互斥信号量）
本地服务器
09-27 7917
共享资源：变量（静态或全局变量）、数据结构体、RAM表格、I/O设备等。OS在使用一些资源时候
UC/OS-III移植样例
10-26
UC/OS-III的核心包括任务管理、时间管理、内存管理、信号量、互斥锁、消息队列、事件标志组等组件。在STM32平台上，这些功能都需要通过C语言来实现，并与微控制器的硬件中断、定时器、存储器映射等特性紧密结合。 1...
互斥型信号量
hahayuihatano的博客
08-19 301
互斥信号量：在应用程序代码中解决优先级反转的问题。用于更好的分配cpu资源，以免产生阻塞现象。 ①互斥信号量建立 //互斥型信号量的建立 OS_EVENT *OSMutexCreate (INT8U prio, //自定义优先级用于继承优先级 INT8U *perr) //错误变量参数 { OS_EVENT *pevent; //互斥型信号量的地址 #if OS_CRITICAL_METHOD == 3u
UCOS-III 互斥锁接口详解
最新发布
TechIoT - 探索物联网与嵌入式系统
07-30 379
互斥锁接口详解，递归锁定， 优先级继承
第八章 互斥型信号量管理
Holi的专栏
07-24 370
2016-07-07 LT 互斥型信号量管理 任务可以用互斥型信号量实现对共享资源的独占处理。 与信号量管理区别不大。 实现优先级天花板协议。(OSEventCnt分为两部分，一部分存当前任务的优先级，另一部分存天花板优先级)
【读书笔记】usOS-II——互斥型信号量（mutex）
cike211的专栏
08-13 973
http://blog.csdn.net/yhmhappy2006/article/details/3357335 互斥型信号量（mutex） 互斥信号量功能： 1）  实现对资源的独占式访问（二值信号量）。 2）  降解优先级反转。 优先级反转： 使用实时内核,优先级反转问题是实时系统中出现得最多的问题。设，任务1优先级高于任务2，任务2优先级高于任务3。任务1和任务2处于挂
uc/os-iii学习笔记-资源管理（中断、信号、信号量、互斥信号量）
JosephGodVim的博客
07-20 1858
资源管理
嵌入式实时操作系统UC-OS-III
09-08
该系统提供了一整套功能服务，例如任务管理、时间管理、时间管理、事件控制块、信号量管理、互斥信号量管理、事件标志管理、消息邮箱管理、消息队列管理、内存管理和移植指南等。 此外，µC/OS-II的设计者在文档的...
CenterV1.1_uC/OS-III_emwin_STM32F470_
10-03
它提供了多任务调度、内存管理、信号量、事件标志组、互斥锁、定时器等功能，以支持复杂和实时的应用程序。uC/OS-III强调了确定性、可扩展性和易用性，适合于需要实时响应的IoT设备，如本例中的集中器。 2. **eMWin...
stm32学习笔记：基于uC/OS-III多任务实验
01-11
此外，uC/OS-III还包含了信号量、互斥锁、事件标志组等同步机制，以及任务间的通信工具，如消息队列和邮箱。 在STM32上配置uC/OS-III，首先需要下载并集成uC/OS-III的源代码库到项目中。通常，这包括设置编译器选项...
uC/OS-III书的光盘资源
12-17
学习这些资源时，首先需要理解uC/OS-III的基本概念，包括任务、信号量、互斥锁、事件标志组、消息队列等基本同步和通信机制。接着，通过阅读库文件，可以掌握如何配置任务、设置优先级、管理内存以及实现任务间的...
ucosii_os_cfg配置文件详细注释，仅供参考，
09-20
自己注释的ucosII操作系统中os_cfg.h的配置项名称，仅供参考，另外添加了配置手册，供使用ucos操作系统的时候方便查询。
UCOSiii难疑之——“OS_SAFETY_CRITICAL”
marks_001的博客
04-28 575
UCOSiii难疑之——“OS_SAFETY_CRITICAL” 在ucosiii内核对象创建时，几乎能在函数内容最前面出现如下代码： #ifdef OS_SAFETY_CRITICAL if (p_err == (OS_ERR *)0) { OS_SAFETY_CRITICAL_EXCEPTION(); return; } #endif 但是OS_SAFETY_CRITICAL和OS_SAFETY_CRITICAL_EXCEPTION()却找不到任何定义。
UCOSIII--任务内嵌消息队列
tyustli
10-17 1156
#define OS_CFG_TASK_Q_EN                1u   /* Include code for OSTaskQXXXX()                                        */ 要使用内嵌消息队列，将宏OS_CFG_TASK_Q_EN设置为1。 任务内嵌消息队列，顾名思义，就是使用任务内部的内嵌消息队列，无需创建新的消息队列，发送...
【Ucos-III源码分析】——互斥信号量（互斥锁）
m0_58457065的博客
07-05 1151
mutex互斥信号量（互斥锁）
UCOSIII---互斥信号量
weixin_43491077的博客
05-13 959
介绍互斥信号量之前，首先给大家简单的说一下优先级反转，优先级反转是实时操作系统中常要面对的一个问题，而且它只出现在使用基于优先级的可剥夺型内核时。 优先级反转栗子 在这种情况下，任务H的优先级实际上降到了任务L的优先级水平。因为任务H要一直等待直到任务L释放其占用的那个共享资源。由于任务M剥夺了任务L的CPU使用权，使得任务H的情况更加恶化，这样就相当于任务M的优先级高于任务H，导致优先级反转。 有一种方法可以避免这一现象的出现：在UCOSIII中有一种特殊的信号量可以胜任这一任务，那就是互斥信号量。
ucosIII OS_CFG.H 解释
@角色扮演#
07-05 5515
UCOS-III中的OS_CFG.H 详细解释 想要对ucos 的功能进行裁剪，必不可少的需要了解OS_CFG.H 文件。这里对官方的《ucosIII User's Manual.pdf》文档， B-1 μC/OS-III FEATURES (OS_CFG.H)章节，进行简要的翻译，如有歧义，以原文为主。 OS_CFG_PEND_MULTI_EN OS_CFG_APP_HOOKS_EN OS_CFG_CALLED_FROM_ISR_CHK_EN OS_CFG_DBG_EN OS_CFG_ISR_POST_D
【Ucos-III源码分析】——消息队列
m0_58457065的博客
07-06 771
ucos消息队列
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值