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）——互斥量

一、头文件

二、互斥量

2.1 基本概念

2.2 运作机制

2.3 互斥量与递归互斥量

三、相关API说明

3.1 xSemaphoreCreateMutex

3.2 xSemaphoreCreateRecursiveMutex

3.3 vSemaphoreDelete

3.4 xSemaphoreTake

3.5 xSemaphoreTakeRecursive

3.6 xSemaphoreGive

3.7 xSemaphoreGiveRecursive

四、示例

相关文章

网友评论

延伸阅读

深度阅读

栏目导航

热点阅读

物联网loT从业者