Arduino ESP32 Freertos互斥锁的优化使用方案

已于 2023-04-04 11:34:37 修改
阅读量1k 收藏 4
点赞数 3
分类专栏： Arduino开发 文章标签： c++ Arduino Freertos Mutex ESP32
于 2023-04-03 23:23:24 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wwplh5520370/article/details/129942160
版权

说明

未经本人同意，禁止任何形式的转载！

前言

在复杂函数和语句或异常处理代码中，主动对Mutex的上锁和解锁操作容易出错，并且难以调试。举个栗子，在进入任务后成功锁定了Mutex，但是任务的具体逻辑比较复杂，可能存在很多if-else if-else或者switch，甚至某些条件分支存在return的情况，这个时候你可能要在多处对Mutex进行释放，稍不注意可能在某处忘记释放了就会导致任务无法继续对Mutex上锁。

解决方案

秉承“谁持有，谁释放”的基本原则，并且必须是先获取后释放，以下定义一个SmartLocker类，这是一个简化锁定和解锁互斥对象的方便类，实现互斥量的自动上锁和自动解锁，即构造函数实现上锁，析构函数实现解锁，如此SmartLocker的实例在离开作用域时就自动对Mutex解锁了。
注意：使用方法就是在需要上锁的地方创建一个SmartLocker局部对象，传入SemaphoreHandle_t变量和上锁的等待超时。

class SmartLocker
{
  //#define debugEnable
  public:
    SmartLocker(SemaphoreHandle_t* mutex, TickType_t xTicksToWait):m_Mutex(mutex)
    {
      if(m_Mutex != NULL)
      {
        isLocked = xSemaphoreTake(*m_Mutex, xTicksToWait) == pdTRUE;
        #ifdef debugEnable
        if(isLocked)
        {
          Serial.println("xSemaphoreTake is ok.");
        }
        else
        {
          Serial.println("xSemaphoreTake is error.");          
        }
        #endif
      }
    };
    ~SmartLocker()
    {
      if(isLocked)
      {
        xSemaphoreGive(*m_Mutex);
      }
    }
    bool IsLocked() const
    {
      return isLocked;
    }
  private:
    SemaphoreHandle_t* m_Mutex = NULL;
    bool isLocked = false;
};

示例

以下为SmartLocker的使用示例，基于Arduino ESP32中的Mutex示例进行修改。在任务中使用SmartLocker代替xSemaphoreTake和xSemaphoreGive的操作，简化软件复杂度。对“#define UseMutex”进行注释/取消注释，观察串口输出即可了解使用和不使用互斥锁的区别。

SemaphoreHandle_t shared_var_mutex = NULL;
int shared_variable = 0;
#define UseMutex

void Task(void *pvParameters)
{
  int task_num = *((int*)pvParameters);
  Serial.printf("%s\n", task_num ? " Starting        |" : "                 | Starting");
  while(1)
  {
    #ifdef UseMutex
    SmartLocker smartLocker(&shared_var_mutex, portMAX_DELAY);
    if(smartLocker.IsLocked())
    {
    #endif
      // Mutex successfully taken
      int new_value = random(1000);

      char str0[32]; sprintf(str0, " %d <- %d      |", shared_variable, new_value);
      char str1[32]; sprintf(str1, "                 | %d <- %d", shared_variable, new_value);
      Serial.printf("%s\n", task_num ? str0 : str1);

      shared_variable = new_value;
      delay(random(100)); // wait random time of max 100 ms - simulating some computation

      sprintf(str0, " R: %d          |", shared_variable);
      sprintf(str1, "                 | R: %d", shared_variable);
      Serial.printf("%s\n", task_num ? str0 : str1);

      if(shared_variable != new_value)
      {
        Serial.printf("%s\n", task_num ? " Mismatch!       |" : "                 | Mismatch!");
      }
    #ifdef UseMutex
    }
    #endif
    delay(10); // Allow other task to be scheduled
  } // Infinite loop
}

void setup()
{
  Serial.begin(115200);
  while(!Serial) delay(100);
  Serial.printf(" Task 0          | Task 1\n");
  shared_var_mutex = xSemaphoreCreateMutex(); // Create the mutex
  // Set up two tasks to run the same function independently.
  static int task_number0 = 0;
  xTaskCreate(
    Task
    ,  "Task 0" // A name just for humans
    ,  2048          // The stack size
    ,  (void*)&task_number0 // Pass reference to a variable describing the task number
    ,  1  // priority
    ,  NULL // Task handle is not used here - simply pass NULL
    );

  static int task_number1 = 1;
  xTaskCreate(
    Task
    ,  "Task 1"
    ,  2048  // Stack size
    ,  (void*)&task_number1 // Pass reference to a variable describing the task number
    ,  1  // Low priority
    ,  NULL // Task handle is not used here - simply pass NULL
    );
}

void loop() {
  // put your main code here, to run repeatedly:
}

后感

编写SmartLocker类的灵感是自己学习Freertos时突发奇想，参考Qt中的QMutexLocker实现的。Freertos中互斥锁、信号量、队列等内容跟windows、linux平台上线程同步的概念是类似的，如果是学过线程同步的概念再去学习Freertos就容易得多，反之则不然。目前大多数的Freertos教程是在单片机上做的，而且讲的很迷，对于初学者自学来说是很抽象的。如果你学过面向对象编程并且了解线程同步相关的概念，再学习嵌入式的rtos就比较容易理解了。这里纯属我自己的理解，如果你不同意我的观点，那就是你对！

完整代码

class SmartLocker
{
  //#define debugEnable
  public:
    SmartLocker(SemaphoreHandle_t* mutex, TickType_t xTicksToWait):m_Mutex(mutex)
    {
      if(m_Mutex != NULL)
      {
        isLocked = xSemaphoreTake(*m_Mutex, xTicksToWait) == pdTRUE;
        #ifdef debugEnable
        if(isLocked)
        {
          Serial.println("xSemaphoreTake is ok.");
        }
        else
        {
          Serial.println("xSemaphoreTake is error.");          
        }
        #endif
      }
    };
    ~SmartLocker()
    {
      if(isLocked)
      {
        xSemaphoreGive(*m_Mutex);
      }
    }
    bool IsLocked() const
    {
      return isLocked;
    }
  private:
    SemaphoreHandle_t* m_Mutex = NULL;
    bool isLocked = false;
};

SemaphoreHandle_t shared_var_mutex = NULL;
int shared_variable = 0;
#define UseMutex

void Task(void *pvParameters)
{
  int task_num = *((int*)pvParameters);
  Serial.printf("%s\n", task_num ? " Starting        |" : "                 | Starting");
  while(1)
  {
    #ifdef UseMutex
    SmartLocker smartLocker(&shared_var_mutex, portMAX_DELAY);
    if(smartLocker.IsLocked())
    {
    #endif
      // Mutex successfully taken
      int new_value = random(1000);

      char str0[32]; sprintf(str0, " %d <- %d      |", shared_variable, new_value);
      char str1[32]; sprintf(str1, "                 | %d <- %d", shared_variable, new_value);
      Serial.printf("%s\n", task_num ? str0 : str1);

      shared_variable = new_value;
      delay(random(100)); // wait random time of max 100 ms - simulating some computation

      sprintf(str0, " R: %d          |", shared_variable);
      sprintf(str1, "                 | R: %d", shared_variable);
      Serial.printf("%s\n", task_num ? str0 : str1);

      if(shared_variable != new_value)
      {
        Serial.printf("%s\n", task_num ? " Mismatch!       |" : "                 | Mismatch!");
      }
    #ifdef UseMutex
    }
    #endif
    delay(10); // Allow other task to be scheduled
  } // Infinite loop
}

void setup()
{
  Serial.begin(115200);
  while(!Serial) delay(100);
  Serial.printf(" Task 0          | Task 1\n");
  shared_var_mutex = xSemaphoreCreateMutex(); // Create the mutex
  // Set up two tasks to run the same function independently.
  static int task_number0 = 0;
  xTaskCreate(
    Task
    ,  "Task 0" // A name just for humans
    ,  2048          // The stack size
    ,  (void*)&task_number0 // Pass reference to a variable describing the task number
    ,  1  // priority
    ,  NULL // Task handle is not used here - simply pass NULL
    );

  static int task_number1 = 1;
  xTaskCreate(
    Task
    ,  "Task 1"
    ,  2048  // Stack size
    ,  (void*)&task_number1 // Pass reference to a variable describing the task number
    ,  1  // Low priority
    ,  NULL // Task handle is not used here - simply pass NULL
    );
}

void loop() {
  // put your main code here, to run repeatedly:
}
ESP32FreeRTOS开发笔记：2.定义、多任务与优先级调度
qq_53529450的博客
08-08 519
FreeRTOS 是一种免费且开源的实时操作系统（RTOS），专为嵌入式系统设计。与一般 RTOS 类似，它提供实时性、多任务调度和低延迟等功能。FreeRTOS 的优势在于其免费性和开源性，允许开发者自由使用和修改代码，并享有广泛的社区支持。通过任务优先级调度，FreeRTOS 可确保关键任务的及时执行。相较于裸机编程，FreeRTOS 提供了更强大的任务管理能力，简化了任务调度过程，使开发者更专注于应用逻辑。
Arduino与FreeRTOS-互斥(Mutex)锁与避免避免优先级倒置
视觉与物联智能
12-30 1241
FreeRTOS 互斥(Mutex)锁与避免避免优先级倒置 资源管理是设计基于实时操作系统的应用程序的关键因素。 在 RTOS 中，多个任务彼此共享资源，例如外设、数据或外部设备。 因此，FreeRTOS 提供了一个互斥信号量来安全地在任务之间共享资源并且不会损坏数据。 在本实例中，我们将学习使用 FreeRTOS API 和 Arduino 使用互斥锁。 让我们从互斥锁的介绍开始。 之后，我们将学习在 Arduino 中使用 FreeRTOS mutex API。 1、互斥体介绍 1）什么是互斥体 Mut
ESP32的简单使用——Freertso的实验（任务创建、互斥锁）
hdh546的博客
09-03 1592
ESP32的简单使用——Freertso的实验（任务创建、互斥锁）
实验作业之FreeRTOS实操
CNLWW的博客
12-04 734
实验作业之FreeRTOS实操1.在stm32最小系统电路原理中添加 AHT20数据采集原理电路 1.在stm32最小系统电路原理中添加 AHT20数据采集原理电路 本次实验，我将使用AHT20数据采集电路以及FreeRTOS的实操
【FreeRTOS 教程 七】互斥锁与递归互斥锁
The_xz的博客
02-02 1292
互斥锁是包含优先级继承机制的二进制信号量。鉴于二进制信号量是实现同步（任务之间或任务与中断之间）的更好方式，因此互斥锁更适合实现简单的相互排斥（即互斥）。用于互斥时，互斥锁就像用于保护资源的令牌。当一个任务希望访问资源时，必须首先获得（“获取”）该令牌。使用完资源后，任务必须“返还”令牌，以便其他任务有机会访问相同的资源。用户可对一把递归互斥锁重复加锁。只有用户为每个成功的 xSemaphoreTakeRecursive() 请求调用 xSemaphoreGiveRecursive() 后，
十三、freeRTOS_调试与优化
qq_41682371的博客
08-10 2762
freeRTOS_资源管理
freertos————互斥锁
qq_39854159的博客
09-01 6598
访问全局变量时需要添加互斥锁
FreeRTOSConfig.h 配置优化及深入
图书馆
06-22 959
本篇目标：基于上一篇的移植freertos(stm32f4_freertos)上，修改 FreeRTOSConfig.h 文件的相关配置来优化辅助 FreeRtos 的使用，并且建立一些基本功能（信号量、消息地列等）的简单应用位于(stm32f4_os_app)工程。 资料准备： 最后工程：项目工程(github分支) project 文件夹下的 stm32f4_os_app 工程。 配置优化简介 之前的移植功能只是将从源文件 demo中拷贝了一份 FreeRTOSConfig.h 做了一些移植修改而
FreeRTOS操作系统（优化版）pdf
01-27
FreeRTOS操作系统 基于stm32 优化版 实时操作系统 可用于飞控 FreeRTOS操作系统 基于stm32 优化版 实时操作系统 可用于飞控
arduino esp32 freertos
03-08
### Arduino ESP32 FreeRTOS 使用教程 #### 创建任务 FreeRTOS允许创建多个独立的任务来执行不同的功能。对于ESP32上的Arduino项目，可以利用`xTaskCreatePinnedToCore()`或`xTaskCreateUniversal()`函数创建新任务...
arduino freertos互斥锁
最新发布
03-15
</think>### Arduino中使用FreeRTOS互斥锁的示例 #### 1. 环境准备 确保已安装支持FreeRTOS的Arduino库（如`FreeRTOS`或`Arduino_FreeRTOS_Library`）。不同开发板需确认FreeRTOS兼容性，例如ESP32/ESP8266已内置...
arduino esp32 s3 freertos
12-27
### Arduino ESP32-S3 上使用 FreeRTOS 的教程 #### 1. 安装必要的库和支持包 为了在Arduino IDE中支持ESP32-S3开发板以及FreeRTOS功能，需安装对应的硬件支持包。通过Arduino IDE首选项页面添加URL指向Espressif ...
ESP-IDF与Arduino结合的ESP32 FreeRTOS开发指南
在ESP-IDF中使用FreeRTOS进行多任务编程，开发者需要创建任务、信号量、互斥锁、队列等，来管理任务之间的数据交换和资源共享。正确地使用FreeRTOS提供的API能够使ESP32的多核处理能力得到充分利用，这对于需要高效...
freertos优化版printf、sprintf、snprintf
gogo0707的博客
04-25 2611
本文简单介绍了freertos栈效率优化版的printf相关函数
FREERTOS移植专栏（4.3）--性能优化
MHD0815的博客
11-10 957
通过上述措施，你可以显著提高 FreeRTOS 应用程序的性能。任务优先级优化：合理设置任务优先级，确保关键任务得到及时处理。内存管理优化：使用静态内存分配和内存池，避免内存泄漏和碎片化。中断处理优化：使用 FreeRTOS 提供的 ISR 宏，确保中断处理的安全性。任务调度优化：减少任务切换开销，避免不必要的任务延时。同步机制优化：使用信号量、互斥锁和事件组来同步任务，防止死锁和竞态条件。代码优化：使用编译器优化选项，选择高效的算法，优化循环结构。
【嵌入式】FreeRTOS的移植、任务运行状态以及源码的优化改进
spiremoon的博客
12-07 4191
目录前言一、FreeRTOS移植的注意事项二、任务运行状态的获取三、任务运行状态的源码优化 前言 FreeRTOS因其简洁小巧、功能齐全而深受嵌入式领域欢迎，如下图所示，除Linux外，FreeRTOS为全球嵌入式领域市场份额最多的实时操作系统。与之对标的uCOS、RTX、ThreadX等都被远远的甩在其后。加之近年又被亚马逊收购，FreeRTOS的应用应该会进一步扩大。网上已有很多各实时操作系统的对比，我也使用过几种操作系统包括FreeRTOS、uCOS等，但FreeRTOS给我的最深的印象就是移植方便，
freertos互斥锁使用
weixin_45379397的博客
05-10 1231
互斥锁用来保护共享资源，防止多线程同时使用共享资源导致一些不可预知的结果。
freertos优化cli终端组件
Jack Yi的博客
07-12 961
在使用freertos的过程中，逐渐发现其自带的cli终端组件真是一个好好东西，非常方便调试。直接可以使用串口终端助手与mcu进行交互。类似于linux中的终端，可以执行一些命令，看系统堆栈状态，任务状态等等。同时也发现一个用起来不太友好的地方，定义命令的回调函数过于复杂，与cli中断勾连太多，不够简洁易懂。
FreeRTOS互斥锁
热门推荐
lushoumin的博客
03-09 1万+
信号量API函数实际上都是宏，它使用现有的队列机制。这些宏定义在semphr.h文件中。如果使用信号量或者互斥量，需要包含semphr.h头文件。 信号量包括二值信号量、计数信号量、互斥信号量和递归互斥信号量。和普通队列比起来，信号量虽然没有队列项实体，但是信号量值等同于队列项个数。 互斥锁和递归互斥锁：互斥锁是用来保证共享数据操作的完整性，同时只能有一个任务访问共享数据。递归互斥...
ESP32线程锁lock
03-08
### ESP32 中线程同步使用 Lock 实现互斥锁 在 ESP32 的开发环境中，通常采用 FreeRTOS 提供的任务间同步机制来管理多个任务之间的访问冲突。对于互斥锁的应用场景而言，FreeRTOS 支持创建并配置多种类型的 mutex 来保护共享资源免受并发修改的影响。 为了实现在 ESP32 上利用 lock 进行线程同步的操作，下面给出一段基于 C 语言编写的代码片段作为演示： ```c #include "freertos/FreeRTOS.h" #include "freertos/task.h" #include "freertos/semphr.h" // 定义全局变量用于存储互斥量句柄 SemaphoreHandle_t xMutex; void TaskFunction(void *pvParameters) { // 尝试获取互斥锁 if (xSemaphoreTake(xMutex, portMAX_DELAY) == pdTRUE) { // 成功获取到互斥锁后的临界区代码... // 执行完成后再释放互斥锁 xSemaphoreGive(xMutex); } } void app_main() { // 创建一个二进制互斥型信号量 xMutex = xSemaphoreCreateMutex(); // 如果创建失败则处理错误 if (xMutex != NULL) { // 启动两个新任务去争夺同一把锁 xTaskCreate(TaskFunction, "Task1", configMINIMAL_STACK_SIZE, NULL, tskIDLE_PRIORITY + 1, NULL); xTaskCreate(TaskFunction, "Task2", configMINIMAL_STACK_SIZE, NULL, tskIDLE_PRIORITY + 1, NULL); // 主循环保持运行状态 while(1){ vTaskDelay(pdMS_TO_TICKS(100)); } } } ``` 上述程序展示了如何初始化一个互斥锁 `xMutex` 并将其应用于两个独立的任务当中；每当某个特定任务想要执行某些关键操作之前都会先尝试占有这把锁，一旦成功便意味着其他任何试图占用它的进程都得暂时挂起直到前者主动放弃控制权为止[^4]。 值得注意的是，在实际项目里应当依据具体需求调整参数设置以及优化逻辑结构以确保最佳性能表现。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值