美文网首页物联网loT从业者
FreeRTOS学习笔记(5)——互斥量

FreeRTOS学习笔记(5)——互斥量

作者: Leung_ManWah | 来源:发表于2020-11-23 17:40 被阅读0次

    一、头文件

    #include "FreeRTOS.h"
    #include "semphr.h"
    

    二、互斥量

    2.1 基本概念

    互斥量又称互斥信号量(本质是信号量),是一种特殊的二值信号量,它和信号量不同的是,它支持互斥量所有权、递归访问以及防止优先级翻转的特性,用于实现对临界资源的独占式处理。任意时刻互斥量的状态只有两种,开锁或闭锁。当互斥量被任务持有时,该互斥量处于闭锁状态,这个任务获得互斥量的所有权。当该任务释放这个互斥量时,该互斥量处于开锁状态,任务失去该互斥量的所有权。当一个任务持有互斥量时,其他任务将不能再对该互斥量进行开锁或持有。持有该互斥量的任务也能够再次获得这个锁而不被挂起,这就是递归访问,也就是递归互斥量的特性,这个特性与一般的信号量有很大的不同,在信号量中,由于已经不存在可用的信号量,任务递归获取信号量时会发生主动挂起任务最终形成死锁。

    如果想要用于实现同步(任务之间或者任务与中断之间),二值信号量或许是更好的选择,虽然互斥量也可以用于任务与任务、任务与中断的同步,但是互斥量更多的是用于保护资源的互锁。

    用于互锁的互斥量可以充当保护资源的令牌,当一个任务希望访问某个资源时,它必须先获取令牌。当任务使用完资源后,必须还回令牌,以便其它任务可以访问该资源。是不是很熟悉,在我们的二值信号量里面也是一样的,用于保护临界资源,保证多任务的访问井然有序。当任务获取到信号量的时候才能开始使用被保护的资源,使用完就释放信号量,下一个任务才能获取到信号量从而可用使用被保护的资源。但是信号量会导致的另一个潜在问题,那就是任务优先级翻转。而 FreeRTOS 提供的互斥量可以通过优先级继承算法,可以降低优先级翻转问题产生的影响,所以,用于临界资源的保护一般建议使用互斥量。

    2.2 运作机制


    用互斥量处理不同任务对临界资源的同步访问时,任务想要获得互斥量才能进行资源访问,如果一旦有任务成功获得了互斥量,则互斥量立即变为闭锁状态,此时其他任务会因为获取不到互斥量而不能访问这个资源,任务会根据用户自定义的等待时间进行等待,直到互斥量被持有的任务释放后,其他任务才能获取互斥量从而得以访问该临界资源,此时互斥量再次上锁,如此一来就可以确保每个时刻只有一个任务正在访问这个临界资源,保证了临界资源操作的安全性。

    2.3 互斥量与递归互斥量

    • 互斥量更适合于可能会引起优先级翻转的情况。
    • 递归互斥量更适用于任务可能会多次获取互斥量的情况下。这样可以避免同一任务多次递归持有而造成死锁的问题。

    三、相关API说明

    3.1 xSemaphoreCreateMutex

    用于创建一个互斥量,并返回一个互斥量句柄。

    函数 #define xSemaphoreCreateMutex() xQueueCreateMutex( queueQUEUE_TYPE_MUTEX )
    参数
    返回值 互斥量句柄

    要想使用该函数必须在 FreeRTOSConfig.h 中把 configSUPPORT_DYNAMIC_ALLOCATION 定义为 1 来使能。


    同时必须在 FreeRTOSConfig.h 中把 configUSE_MUTEXES 定义为 1 来使能。

    3.2 xSemaphoreCreateRecursiveMutex

    用于创建一个递归互斥量,不是递归的互斥量由函数 xSemaphoreCreateMutex() 或 xSemaphoreCreateMutexStatic()创建,且只能被同一个任务获取一次,如果同一个任务想再次获取则会失败。递归信号量则相反,它可以被同一个任务获取很多次,获取多少次就需要释放多少次。递归信号量与互斥量一样,都实现了优先级继承机制,可以减少优先级反转的反生。

    函数 #define xSemaphoreCreateRecursiveMutex() xQueueCreateMutex( queueQUEUE_TYPE_RECURSIVE_MUTEX )
    参数
    返回值 递归互斥量句柄

    要想使用该函数必须在 FreeRTOSConfig.h 中把 configSUPPORT_DYNAMIC_ALLOCATION 定义为 1 来使能。


    同时必须在 FreeRTOSConfig.h 中把 configUSE_RECURSIVE_MUTEXES 定义为 1 来使能。

    3.3 vSemaphoreDelete

    用于删除一个信号量,包括二值信号量,计数信号量,互斥量和递
    归互斥量。如果有任务阻塞在该信号量上,那么不要删除该信号量。

    函数 void vSemaphoreDelete( SemaphoreHandle_t xSemaphore )
    参数 xSemaphore: 信号量句柄
    返回值

    3.4 xSemaphoreTake

    用于获取信号量,不带中断保护。获取的信号量对象可以是二值信号量、计数信号量和互斥量,但是递归互斥量并不能使用这个 API 函数获取。

    函数 xSemaphoreTake( SemaphoreHandle_t xSemaphore, TickType_t xBlockTime )
    参数 xSemaphore: 信号量句柄
    xBlockTime: 等待信号量可用的最大超时时间,单位为 tick(即系统节拍周期)。如果宏 INCLUDE_vTaskSuspend 定义为 1 且形参 xTicksToWait 设置为 portMAX_DELAY ,则任务将一直阻塞在该信号量上(即没有超时时间)
    返回值 成功返回 pdTRUE,否则返回 errQUEUE_EMPTY

    3.5 xSemaphoreTakeRecursive

    用于获取递归互斥量的宏,与互斥量的获取函数一样,xSemaphoreTakeRecursive()也是一个宏定义,它最终使用现有的队列机制,实际执行的函数是 xQueueTakeMutexRecursive() 。 获取递归互斥量之前必须由 xSemaphoreCreateRecursiveMutex() 这个函数创建。要注意的是该函数不能用于获取由函数 xSemaphoreCreateMutex() 创建的互斥量。

    函数 #define xSemaphoreTakeRecursive( xMutex, xBlockTime ) xQueueTakeMutexRecursive( ( xMutex ), ( xBlockTime ) )
    参数 xMutex: 信号量句柄
    xBlockTime: 如果不是持有互斥量的任务去获取无效的互斥量,那么任务将进行等待用户指定超时时间,单位为 tick(即系统节拍周期)。如果宏 INCLUDE_vTaskSuspend 定义为 1 且形参 xTicksToWait 设置为portMAX_DELAY ,则任务将一直阻塞在该递归互斥量上(即没有超时时间)
    返回值 成功返回 pdTRUE,否则返回 errQUEUE_EMPTY

    要想使用该函数必须在 FreeRTOSConfig.h 中把configUSE_RECURSIVE_MUTEXES 定义为 1 来使能。

    3.6 xSemaphoreGive

    用于释放信号量的宏。释放的信号量对象必须是已经被创建的,可以用于二值信号量、计数信号量、互斥量的释放,但不能释放由函数 xSemaphoreCreateRecursiveMutex() 创建的递归互斥量。此外该函数不能在中断中使用。

    函数 xSemaphoreGive( SemaphoreHandle_t xSemaphore )
    参数 xSemaphore: 信号量句柄
    返回值 成功返回 pdTRUE,否则返回 pdFALSE

    3.7 xSemaphoreGiveRecursive

    用于释放一个递归互斥量。已经获取递归互斥量的任务可以重复获取该递归互斥量。使用 xSemaphoreTakeRecursive() 函数成功获取几次递归互斥量,就要使用 xSemaphoreGiveRecursive() 函数返还几次,在此之前递归互斥量都处于无效状态,别的任务就无法获取该递归互斥量。使用该函数接口时,只有已持有互斥量所有权的任务才能释放它,每释放一该递归互斥量,它的计数值就减 1。当该互斥量的计数值为 0 时(即持有任务已经释放所有的持有操作),互斥量则变为开锁状态,等待在该互斥量上的任务将被唤醒。如果任务的优先级被互斥量的优先级翻转机制临时提升,那么当互斥量被释放后,任务的优先级将恢复为原本设定的优先级。

    函数 #define xSemaphoreGiveRecursive( xMutex ) xQueueGiveMutexRecursive( ( xMutex ) )
    参数 xMutex : 信号量句柄
    返回值 成功返回 pdTRUE,否则返回 pdFALSE

    要想使用该函数必须在 FreeRTOSConfig.h 中把configUSE_RECURSIVE_MUTEXES 定义为 1 来使能。

    四、示例

    /* FreeRTOS 头文件 */
    #include "FreeRTOS.h"
    #include "task.h"
    #include "queue.h"
    #include "semphr.h"
    /* 开发板硬件 bsp 头文件 */
    #include "bsp_led.h"
    #include "bsp_usart.h"
    #include "bsp_key.h"
    /**************************** 任务句柄 ********************************/
    /*
    * 任务句柄是一个指针,用于指向一个任务,当任务创建好之后,它就具有了一个任务句柄
    * 以后我们要想操作这个任务都需要通过这个任务句柄,如果是自身的任务操作自己,那么
    * 这个句柄可以为 NULL。
    */
    static TaskHandle_t AppTaskCreate_Handle = NULL;/* 创建任务句柄 */
    static TaskHandle_t LowPriority_Task_Handle = NULL;/* LowPriority_Task 任务句柄 */
    static TaskHandle_t MidPriority_Task_Handle = NULL;/* MidPriority_Task 任务句柄 */
    static TaskHandle_t HighPriority_Task_Handle = NULL;/* HighPriority_Task 任务句柄 */
     
    /***************************** 内核对象句柄 *****************************/
    /*
    * 信号量,消息队列,事件标志组,软件定时器这些都属于内核的对象,要想使用这些内核
    * 对象,必须先创建,创建成功之后会返回一个相应的句柄。实际上就是一个指针,后续我
    * 们就可以通过这个句柄操作这些内核对象。
    *
    * 内核对象说白了就是一种全局的数据结构,通过这些数据结构我们可以实现任务间的通信,
    * 任务间的事件同步等各种功能。至于这些功能的实现我们是通过调用这些内核对象的函数
    * 来完成的
    *
    */
    SemaphoreHandle_t MuxSem_Handle = NULL;
    
    static void AppTaskCreate(void);/* 用于创建任务 */ 
    static void LowPriority_Task(void* pvParameters);/* LowPriority_Task 任务实现 */
    static void MidPriority_Task(void* pvParameters);/* MidPriority_Task 任务实现 */
    static void HighPriority_Task(void* pvParameters);/* HighPriority_Task 任务实现 */
    
    static void BSP_Init(void);/* 用于初始化板载相关资源 */
    
    int main(void)
    {
        BaseType_t xReturn = pdPASS;/* 定义一个创建信息返回值,默认为 pdPASS */
    
        /* 开发板硬件初始化 */
        BSP_Init();
        /* 创建 AppTaskCreate 任务 */
        xReturn = xTaskCreate((TaskFunction_t )AppTaskCreate,/* 任务入口函数 */
                              (const char* )"AppTaskCreate",/* 任务名字 */
                              (uint16_t )512, /* 任务栈大小 */
                              (void* )NULL,/* 任务入口函数参数 */
                              (UBaseType_t )1, /* 任务的优先级 */
                              (TaskHandle_t*)&AppTaskCreate_Handle);/* 任务控制块指针 */
        /* 启动任务调度 */
        if (pdPASS == xReturn)
        {
            vTaskStartScheduler(); /* 启动任务,开启调度 */
        }
        else
        {
            return -1;
        } 
    
        while (1); /* 正常不会执行到这里 */
    }
    
    /***********************************************************************
    * @ 函数名 : AppTaskCreate
    * @ 功能说明: 为了方便管理,所有的任务创建函数都放在这个函数里面
    * @ 参数 : 无
    * @ 返回值 : 无
    ***************************************************************/
    static void AppTaskCreate(void)
    {
        BaseType_t xReturn = pdPASS;/* 定义一个创建信息返回值,默认为 pdPASS */
      
        taskENTER_CRITICAL(); //进入临界区
       
        /* 创建 MuxSem */ 
        MuxSem_Handle = xSemaphoreCreateMutex();
        if (NULL != MuxSem_Handle) 
        {
            printf("MuxSem_Handle 互斥量创建成功!\r\n"); 
        }
    
        xReturn = xSemaphoreGive( MuxSem_Handle );//给出互斥量
      
        /* 创建 LowPriority_Task 任务 */
        xReturn = xTaskCreate((TaskFunction_t )LowPriority_Task,/* 任务入口函数 */
                              (const char* )"LowPriority_Task",/* 任务名字 */
                              (uint16_t )512, /* 任务栈大小 */
                              (void* )NULL, /* 任务入口函数参数 */
                              (UBaseType_t )2, /* 任务的优先级 */
                              (TaskHandle_t* )&LowPriority_Task_Handle);/* 任务控制块指针 */
        if (pdPASS == xReturn)
        {
            printf("创建 LowPriority_Task 任务成功!\r\n");
        }
      
        /* 创建 MidPriority_Task 任务 */
        xReturn = xTaskCreate((TaskFunction_t )MidPriority_Task,/* 任务入口函数 */
                              (const char* )"MidPriority_Task",/* 任务名字 */
                              (uint16_t )512, /* 任务栈大小 */
                              (void* )NULL, /* 任务入口函数参数 */
                              (UBaseType_t )2, /* 任务的优先级 */
                              (TaskHandle_t* )&MidPriority_Task_Handle);/* 任务控制块指针 */
        if (pdPASS == xReturn)
        {
            printf("创建 MidPriority_Task 任务成功!\r\n");
        }
    
        /* 创建 HighPriority_Task 任务 */
        xReturn = xTaskCreate((TaskFunction_t )HighPriority_Task,/* 任务入口函数 */
                              (const char* )"HighPriority_Task",/* 任务名字 */
                              (uint16_t )512, /* 任务栈大小 */
                              (void* )NULL, /* 任务入口函数参数 */
                              (UBaseType_t )2, /* 任务的优先级 */
                              (TaskHandle_t* )&HighPriority_Task_Handle);/* 任务控制块指针 */
        if (pdPASS == xReturn)
        {
            printf("创建 HighPriority_Task 任务成功!\r\n");
        }
    
        vTaskDelete(AppTaskCreate_Handle); //删除 AppTaskCreate 任务
        
        taskEXIT_CRITICAL(); //退出临界区
    }
    
    /**********************************************************************
    * @ 函数名 : LowPriority_Task
    * @ 功能说明: LowPriority_Task 任务主体
    * @ 参数 :
    * @ 返回值 : 无
    ********************************************************************/
    static void LowPriority_Task(void* parameter) 
    { 
        static uint32_t i; 
        BaseType_t xReturn = pdPASS;/* 定义一个创建信息返回值,默认为 pdPASS */ 
        while (1) 
        { 
            printf("LowPriority_Task 获取信号量\n"); 
            //获取互斥量 MuxSem,没获取到则一直等待 
            xReturn = xSemaphoreTake(MuxSem_Handle,/* 互斥量句柄 */ 
                                    portMAX_DELAY); /* 等待时间 */ 
            if (pdTRUE == xReturn) 
            {
                printf("LowPriority_Task Runing\n\n"); 
            }
    
            for (i=0; i<2000000; i++) 
            { //模拟低优先级任务占用互斥量 
                taskYIELD();//发起任务调度 
            } 
    
            printf("LowPriority_Task 释放信号量!\r\n"); 
            xReturn = xSemaphoreGive( MuxSem_Handle );//给出互斥量 
    
            LED1_TOGGLE; 
    
            vTaskDelay(1000); 
        }
    } 
    
    /**********************************************************************
    * @ 函数名 : MidPriority_Task
    * @ 功能说明: MidPriority_Task 任务主体
    * @ 参数 :
    * @ 返回值 : 无
    ********************************************************************/
    static void MidPriority_Task(void* parameter) 
    { 
        while (1) 
        { 
            printf("MidPriority_Task Runing\n"); 
            vTaskDelay(1000); 
        } 
    }
    
    /**********************************************************************
    * @ 函数名 : HighPriority_Task
    * @ 功能说明: HighPriority_Task 任务主体
    * @ 参数 :
    * @ 返回值 : 无
    ********************************************************************/
    static void HighPriority_Task(void* parameter) 
    { 
        BaseType_t xReturn = pdTRUE;/* 定义一个创建信息返回值,默认为 pdPASS */ 
        while (1) 
        { 
            printf("HighPriority_Task 获取信号量\n"); 
            //获取互斥量 MuxSem,没获取到则一直等待 
            xReturn = xSemaphoreTake(MuxSem_Handle,/* 互斥量句柄 */ 
                                    portMAX_DELAY); /* 等待时间 */ 
            if (pdTRUE == xReturn) 
            {
                printf("HighPriority_Task Runing\n"); 
            }
            LED1_TOGGLE; 
      
            printf("HighPriority_Task 释放信号量!\r\n"); 
            xReturn = xSemaphoreGive( MuxSem_Handle );//给出互斥量  
       
            vTaskDelay(1000); 
        }
    } 
    
    /***********************************************************************
    * @ 函数名 : BSP_Init
    * @ 功能说明: 板级外设初始化,所有板子上的初始化均可放在这个函数里面
    * @ 参数 :
    * @ 返回值 : 无
    *********************************************************************/
    static void BSP_Init(void)
    {
        /*
        * STM32 中断优先级分组为 4,即 4bit 都用来表示抢占优先级,范围为:0~15
        * 优先级分组只需要分组一次即可,以后如果有其他的任务需要用到中断,
        * 都统一用这个优先级分组,千万不要再分组,切忌。
        */
        NVIC_PriorityGroupConfig( NVIC_PriorityGroup_4 );
       
        /* LED 初始化 */
        LED_GPIO_Config();
      
        /* 串口初始化 */
        USART_Config();
       
        /* 按键初始化 */
        Key_GPIO_Config();     
    }
    

    • 由 Leung 写于 2020 年 11 月 23 日

    • 参考:野火FreeRTOS视频与PDF教程

    相关文章

      网友评论

        本文标题:FreeRTOS学习笔记(5)——互斥量

        本文链接:https://www.haomeiwen.com/subject/ulbmiktx.html