STM32 FreeRTOS （五）互斥量

ODF..

已于 2023-01-10 22:48:18 修改

阅读量1k

点赞数

分类专栏： STM32 FreeRTOS 文章标签： stm32 嵌入式硬件单片机 Powered by 金山文档

于 2023-01-10 00:44:07 首次发布

本文链接：https://blog.csdn.net/DOF526570/article/details/128622903

版权

STM32 FreeRTOS 专栏收录该内容

6 篇文章 2 订阅

订阅专栏

简介:

基本概念

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

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

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

运作机制

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

互斥量与递归互斥量

互斥量更适合于可能会引起优先级翻转的情况。

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

工程创建:

1.配置RCC时钟

2.配置SYS，将Timebase Source修改为除滴答定时器外的其他定时器。

3.开启FreeRTOS，v1与v2版本不同，一般选用v1即可

4.创建任务Task

我们创建三个任务，一个高优先级任务，一个中优先级任务，一个低优先级任务。

Task Name：任务名称

Priority：优先级，在 FreeRTOS 中，数值越大优先级越高，0 代表最低优先级

Stack Size (Words)：堆栈大小，单位为字，在32位处理器（STM32），一个字等于4字节，如果传入512那么任务大小为512*4字节

Entry Function：入口函数

Code Generation Option：代码生成选项

Parameter：任务入口函数形参，不用的时候配置为0或NULL即可

Allocation：分配方式：Dynamic 动态内存创建

Buffer Name：缓冲区名称

Conrol Block Name：控制块名称

创建互斥量Mutex

在 Mutexes 进行配置。

Mutex Name：互斥量名称

Allocation：分配方式：Dynamic 动态内存创建

Conrol Block Name：控制块名称

5.UART串口打印

6.生成代码设置

相关API：

库函数：

hal库：

创建互斥量：osMutexCreate

osMutexId osMutexCreate (const osMutexDef_t *mutex_def)

函数描述：用于创建一个互斥量，并返回一个互斥量ID。

参数：mutex_def：引用由osMutexDef定义的互斥量

返回值：成功返回互斥量ID，失败返回0

创建递归互斥量：osRecursiveMutexCreate

osMutexId osRecursiveMutexCreate (const osMutexDef_t *mutex_def)

函数描述：

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

参数：mutex_def：引用由osMutexDef定义的互斥量

返回值：成功返回互斥量ID，失败返回0

要想使用该函数必须在 Config parameters 中把 USE_RECURSIVE_MUTEXES 选择 Enabled 来使能。

删除互斥量： osMutexDelete

osStatus osMutexDelete (osMutexId mutex_id)

函数描述：用于删除一个互斥量。

参数：mutex_id：互斥量ID

返回值：错误码

获取互斥量：osMutexWait

osStatus osMutexWait (osMutexId mutex_id, uint32_t millisec)

函数描述：用于获取互斥量，但是递归互斥量并不能使用这个 API 函数获取。

参数：

mutex_id：互斥量ID

**millisec：**等待信号量可用的最大超时时间，单位为 tick（即系统节拍周期）。如果宏 INCLUDE_vTaskSuspend 定义为 1 且形参 xTicksToWait 设置为 portMAX_DELAY ，则任务将一直阻塞在该信号量上（即没有超时时间）

返回值：错误码

获取递归互斥量：osRecursiveMutexWait

osStatus osRecursiveMutexWait (osMutexId mutex_id, uint32_t millisec)

函数描述：

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

参数：

mutex_id：递归互斥量ID

**millisec：**等待信号量可用的最大超时时间，单位为 tick（即系统节拍周期）。如果宏 INCLUDE_vTaskSuspend 定义为 1 且形参 xTicksToWait 设置为 portMAX_DELAY ，则任务将一直阻塞在该信号量上（即没有超时时间）

返回值：错误码

要想使用该函数必须在 Config parameters 中把 USE_RECURSIVE_MUTEXES 选择 Enabled 来使能。

释放互斥量：osMutexRelease

osStatus osMutexRelease (osMutexId mutex_id)

函数描述：用于释放互斥量，但不能释放由函数 osRecursiveMutexCreate() 创建的递归互斥量。

参数：mutex_id：互斥量ID

返回值：错误码

释放递归互斥量：osRecursiveMutexRelease

osStatus osRecursiveMutexRelease (osMutexId mutex_id)

函数描述：

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

参数：mutex_id：互斥量ID

返回值：错误码

要想使用该函数必须在 Config parameters 中把 USE_RECURSIVE_MUTEXES 选择 Enabled 来使能。

实验示例：

串口重定义：

/* USER CODE BEGIN 4 */
/**
  * @brief 重定向c库函数printf到USARTx
  * @retval None
  */
int fputc(int ch, FILE *f)
{
  HAL_UART_Transmit(&huart1, (uint8_t *)&ch, 1, 0xffff);
  return ch;
}
 
/**
  * @brief 重定向c库函数getchar,scanf到USARTx
  * @retval None
  */
int fgetc(FILE *f)
{
  uint8_t ch = 0;
  HAL_UART_Receive(&huart1, &ch, 1, 0xffff);
  return ch;
}
/* USER CODE END 4 */

这里是三个任务函数：

/* USER CODE BEGIN Header_LowTask */
/**
* @brief Function implementing the myLowTask thread.
* @param argument: Not used
* @retval None
*/
/* USER CODE END Header_LowTask */
void LowTask(void const * argument)
{
  /* USER CODE BEGIN LowTask */
  /* Infinite loop */
  static uint32_t i; 
  osStatus xReturn;
  /* Infinite loop */
  for(;;)
  {
    printf("LowPriority_Task Get Mutex\r\n");
    //获取互斥量 MuxSem,没获取到则一直等待 
    xReturn = osMutexWait(myMuSemHandle,     /* 互斥量句柄 */ 
                          osWaitForever);   /* 等待时间 */
    if(osOK == xReturn) 
    {
        printf("LowPriority_Task Runing\r\n"); 
    }
    
    for(i = 0; i < 2000000; i++) 
    { //模拟低优先级任务占用互斥量 
        taskYIELD();//发起任务调度 
    } 
    
    printf("LowPriority_Task Release Mutex\r\n"); 
    xReturn = osMutexRelease(myMuSemHandle);//给出互斥量 
    
    osDelay(1000);
  }

  /* USER CODE END LowTask */
}

/* USER CODE BEGIN Header_MidTask */
/**
* @brief Function implementing the myMidTask thread.
* @param argument: Not used
* @retval None
*/
/* USER CODE END Header_MidTask */
void MidTask(void const * argument)
{
  /* USER CODE BEGIN MidTask */
  /* Infinite loop */
  for(;;)
  {
    printf("MidPriority_Task Runing\r\n"); 
    osDelay(1000);
  }
  /* USER CODE END MidTask */
}

/* USER CODE BEGIN Header_HighTask */
/**
* @brief Function implementing the myHighTask thread.
* @param argument: Not used
* @retval None
*/
/* USER CODE END Header_HighTask */
void HighTask(void const * argument)
{
  /* USER CODE BEGIN HighTask */
  osStatus xReturn;
  /* Infinite loop */
  for(;;)
  {
    printf("HighPriority_Task Get Mutex\r\n"); 
    //获取互斥量 MuxSem,没获取到则一直等待 
    xReturn = osMutexWait(myMuSemHandle,     /* 互斥量句柄 */ 
                          osWaitForever);   /* 等待时间 */
    if(osOK == xReturn) 
    {
        printf("HighPriority_Task Runing\r\n"); 
    }
  
    printf("HighPriority_Task Release Mutex\r\n"); 
    xReturn = osMutexRelease(myMuSemHandle);//给出互斥量

    osDelay(1000);
  }

  /* USER CODE END HighTask */
}

/* Private application code --------------------------------------------------*/
/* USER CODE BEGIN Application */

/* USER CODE END Application */

ODF..

关注

0
点赞
踩
4

收藏

觉得还不错? 一键收藏
0
评论
STM32 FreeRTOS （五）互斥量

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

扫一扫