FreeRTOS信号量常见陷阱

1. 引言

在嵌入式系统开发中，多任务编程是一种常见的设计模式，而FreeRTOS作为流行的嵌入式实时操作系统之一，为开发者提供了丰富的任务管理和同步工具。其中，信号量是FreeRTOS中最基础也是最常用的同步原语之一。

信号量在多任务环境中扮演着重要角色，它可以用来保护共享资源、同步任务执行、实现任务间通信等。掌握信号量的原理和正确使用方法，对于开发高效、稳定的嵌入式系统至关重要。

2. 信号量基础概念

2.1 什么是信号量

信号量本质上是一种用于多任务环境下同步和互斥的软件机制。它最初由计算机科学家Edsger Dijkstra提出，用于解决进程间的同步问题。在FreeRTOS中，信号量被实现为一个包含计数值的数据结构，任务可以"获取"(take)或"释放"(give)信号量，从而实现任务间的协调。

信号量的工作原理可以形象地比喻为许可证管理：

• 信号量维护着一定数量的"许可证"
• 任务需要获取许可证才能继续执行特定代码
• 如果没有可用的许可证，任务将被阻塞，直到许可证可用
• 任务完成工作后释放许可证，供其他任务使用
  

2.2 信号量的类型

FreeRTOS提供了四种类型的信号量，每种适用于不同的场景：

1. 二值信号量(Binary Semaphore)：

   • 只有0和1两个状态
   • 可用于任务同步和简单的互斥
   • 适合"任务通知"场景，如中断触发任务

2. 计数信号量(Counting Semaphore)：

   • 可以有多个计数值(>1)
   • 适用于资源计数和事件计数
   • 例如：管理有限资源的池，如内存缓冲区

3. 互斥信号量(Mutex)：

   • 特殊的二值信号量，具有优先级继承机制
   • 专门用于解决资源访问互斥问题
   • 防止优先级反转

4. 递归互斥信号量(Recursive Mutex)：

   • 允许同一个任务多次获取同一个互斥量
   • 需要同等次数的释放操作
   • 适用于递归调用的场景

2.3 信号量与其他同步原语的区别

FreeRTOS除了信号量外，还提供了其他同步机制，如任务通知、队列、事件组等。各种机制的对比：

选择合适的同步机制需要根据具体应用场景，考虑实时性要求、RAM资源限制和功能需求等因素。

3. FreeRTOS中的信号量API

FreeRTOS提供了一组全面的API函数来创建和操作各类信号量。本节将详细介绍这些API函数的用法。

3.1 二值信号量API

二值信号量是最简单的信号量类型，只有两个状态：可用(1)和不可用(0)。

创建二值信号量：

// 方法1：静态创建
StaticSemaphore_t xSemaphoreBuffer;
SemaphoreHandle_t xSemaphore;
xSemaphore = xSemaphoreCreateBinaryStatic(&xSemaphoreBuffer);

// 方法2：动态创建（常用）
SemaphoreHandle_t xSemaphore;
xSemaphore = xSemaphoreCreateBinary();

获取二值信号量：

// 阻塞式获取（等待最长xTicksToWait时间）
if (xSemaphoreTake(xSemaphore, xTicksToWait) == pdTRUE) {
    // 成功获取信号量
    // 执行受保护的代码
}

// 非阻塞式获取
if (xSemaphoreTake(xSemaphore, 0) == pdTRUE) {
    // 成功获取信号量
    // 执行受保护的代码
}

释放二值信号量：

// 任务中释放
xSemaphoreGive(xSemaphore);

// 中断中释放
BaseType_t xHigherPriorityTaskWoken = pdFALSE;
xSemaphoreGiveFromISR(xSemaphore, &xHigherPriorityTaskWoken);
if (xHigherPriorityTaskWoken) {
    portYIELD_FROM_ISR();  // 触发任务切换
}

3.2 计数信号量API

计数信号量维护一个计数值，可以大于1，适用于资源计数和事件计数场景。

创建计数信号量：

// 动态创建计数信号量
SemaphoreHandle_t xSemaphore;
// 最大计数值为10，初始计数值为0
xSemaphore = xSemaphoreCreateCounting(10, 0);

// 静态创建计数信号量
StaticSemaphore_t xSemaphoreBuffer;
SemaphoreHandle_t xSemaphore;
xSemaphore = xSemaphoreCreateCountingStatic(10, 0, &xSemaphoreBuffer);

操作计数信号量：
获取和释放操作与二值信号量相同，使用xSemaphoreTake()和xSemaphoreGive()函数。

获取信号量当前计数值：

UBaseType_t uxSemaphoreGetCount(SemaphoreHandle_t xSemaphore);

3.3 互斥信号量API

互斥信号量是专为互斥访问设计的，具有优先级继承机制，可有效避免优先级反转问题。

创建互斥信号量：

// 动态创建
SemaphoreHandle_t xMutex;
xMutex = xSemaphoreCreateMutex();

// 静态创建
StaticSemaphore_t xMutexBuffer;
SemaphoreHandle_t xMutex;
xMutex = xSemaphoreCreateMutexStatic(&xMutexBuffer);

互斥信号量的获取和释放操作与二值信号量相同。

3.4 递归互斥信号量API

递归互斥信号量允许同一个任务多次获取同一个信号量，但需要对应次数的释放操作。

创建递归互斥信号量：

// 动态创建
SemaphoreHandle_t xRecursiveMutex;
xRecursiveMutex = xSemaphoreCreateRecursiveMutex();

// 静态创建
StaticSemaphore_t xMutexBuffer;
SemaphoreHandle_t xRecursiveMutex;
xRecursiveMutex = xSemaphoreCreateRecursiveMutexStatic(&xMutexBuffer);

操作递归互斥信号量：

// 获取递归互斥信号量
xSemaphoreTakeRecursive(xRecursiveMutex, xTicksToWait);

// 释放递归互斥信号量
xSemaphoreGiveRecursive(xRecursiveMutex);

信号量API使用实例

以下是ESP32中使用互斥信号量的实际代码示例，用于保护共享资源：

// 定义互斥信号量句柄
SemaphoreHandle_t mutex = NULL;

void app_main(void)
{
    // 创建互斥信号量
    mutex = xSemaphoreCreateMutex();
    if (mutex == NULL) {
        ESP_LOGE("MAIN", "创建互斥锁失败");
        return;
    }
    
    // 创建两个任务共享资源
    xTaskCreate(task_one, "Task1", 2048, NULL, 5, NULL);
    xTaskCreate(task_two, "Task2", 2048, NULL, 5, NULL);
}

void task_one(void *pvParameters)
{
    while (1) {
        // 尝试获取互斥锁
        if (xSemaphoreTake(mutex, portMAX_DELAY) == pdTRUE) {
            // 成功获取互斥锁，访问共享资源
            ESP_LOGI("TASK1", "获取互斥锁");
            
            // 模拟处理共享资源
            vTaskDelay(pdMS_TO_TICKS(1000));
            
            // 释放互斥锁
            ESP_LOGI("TASK1", "释放互斥锁");
            xSemaphoreGive(mutex);
        }
        
        vTaskDelay(pdMS_TO_TICKS(500));
    }
}

void task_two(void *pvParameters)
{
    // 类似于task_one的实现
    // ...
}

4. 信号量使用场景与示例

信号量在嵌入式系统开发中有广泛的应用，本节将结合实际场景，展示信号量的常见用法。

4.1 任务同步

任务同步是信号量最基本的应用场景之一。当一个任务需要等待另一个任务或中断完成某些操作后才能继续执行时，二值信号量是理想的选择。

示例：中断触发任务执行

在以下示例中，使用二值信号量实现中断触发任务执行的同步机制：

// 定义二值信号量
SemaphoreHandle_t xBinarySemaphore = NULL;

// 中断服务程序
void IRAM_ATTR gpio_isr_handler(void* arg)
{
    BaseType_t xHigherPriorityTaskWoken = pdFALSE;
    
    // 从中断中给出信号量
    xSemaphoreGiveFromISR(xBinarySemaphore, &xHigherPriorityTaskWoken);
    
    // 如果释放信号量导致高优先级任务解除阻塞，则在中断退出时进行上下文切换
    if (xHigherPriorityTaskWoken) {
        portYIELD_FROM_ISR();
    }
}

// 等待中断的任务
void interrupt_task(void *pvParameters)
{
    while(1) {
        // 等待信号量
        if (xSemaphoreTake(xBinarySemaphore, portMAX_DELAY) == pdTRUE) {
            // 信号量已获取，表明中断已发生
            ESP_LOGI("INT_TASK", "检测到中断，执行处理...");
            
            // 处理中断事件
            process_interrupt_event();
        }
    }
}

void app_main(void)
{
    // 创建二值信号量
    xBinarySemaphore = xSemaphoreCreateBinary();
    
    // 创建任务
    xTaskCreate(interrupt_task, "interrupt_task", 2048, NULL, 10, NULL);
    
    // 配置GPIO中断
    gpio_install_isr_service(0);
    gpio_set_intr_type(GPIO_NUM_0, GPIO_INTR_NEGEDGE);
    gpio_isr_handler_add(GPIO_NUM_0, gpio_isr_handler, NULL);
}

在这个示例中，当GPIO引脚检测到下降沿时触发中断，中断处理函数释放信号量，从而唤醒正在等待的任务执行相应的处理逻辑。

这种模式的好处是可以将中断处理与实际业务逻辑分离，中断服务程序保持简短，复杂的处理逻辑放在任务中执行，提高系统的响应性和稳定性。

4.2 资源保护

互斥信号量是用于保护共享资源的最佳选择，它可以确保同一时间只有一个任务访问共享资源，防止数据竞争和破坏。

示例：Modbus RTU通信模块中的互斥锁

以下是一个真实的Modbus RTU模块实现中使用互斥锁保护共享资源的示例：

// Modbus RTU状态结构
typedef struct {
    modbus_uart_config_t uart_config;
    modbus_device_item_t devices[MODBUS_MAX_DEVICES];
    int device_count;
    bool running;
    TaskHandle_t poll_task_handle;
    SemaphoreHandle_t mutex;
    uint32_t response_timeout_ms;
} modbus_rtu_t;

// 全局Modbus RTU状态
static modbus_rtu_t modbus_rtu = {
    .device_count = 0,
    .running = false,
    .poll_task_handle = NULL,
    .mutex = NULL,
    .response_timeout_ms = MODBUS_DEFAULT_TIMEOUT_MS
};

// 初始化Modbus RTU
esp_err_t modbus_rtu_init(int uart_num, int baud_rate, int data_bits, int stop_bits, 
                         char parity, int tx_pin, int rx_pin, int rts_pin)
{
    ESP_LOGI("MODBUS_RTU", "初始化Modbus RTU: 串口=%d, 波特率=%d", uart_num, baud_rate);
    
    // 创建互斥锁
    modbus_rtu.mutex = xSemaphoreCreateMutex();
    if (modbus_rtu.mutex == NULL) {
        ESP_LOGE("MODBUS_RTU", "创建互斥锁失败");
        return ESP_ERR_NO_MEM;
    }
    
    // ... 其他初始化代码 ...
    
    return ESP_OK;
}

// 轮询任务
static void modbus_poll_task(void *pvParameters)
{
    ESP_LOGI("MODBUS_RTU", "Modbus轮询任务已启动");
    
    while (modbus_rtu.running) {
        // 获取当前时间
        int64_t current_time = esp_timer_get_time() / 1000; // 毫秒
        
        // 获取互斥锁，保护共享数据
        xSemaphoreTake(modbus_rtu.mutex, portMAX_DELAY);
        
        // 遍历所有设备
        for (int i = 0; i < MODBUS_MAX_DEVICES; i++) {
            if (modbus_rtu.devices[i].valid && modbus_rtu.devices[i].device.enabled) {
                modbus_device_item_t *device = &modbus_rtu.devices[i];
                
                // 处理设备数据
                // ...
            }
        }
        
        // 释放互斥锁
        xSemaphoreGive(modbus_rtu.mutex);
        
        // 轮询间隔
        vTaskDelay(pdMS_TO_TICKS(100));
    }
    
    ESP_LOGI("MODBUS_RTU", "Modbus轮询任务已停止");
    vTaskDelete(NULL);
}

// 添加设备
esp_err_t modbus_rtu_add_device(modbus_device_t *device, int *device_id)
{
    // 获取互斥锁
    xSemaphoreTake(modbus_rtu.mutex, portMAX_DELAY);
    
    // 查找空闲槽位
    int slot = -1;
    for (int i = 0; i < MODBUS_MAX_DEVICES; i++) {
        if (!modbus_rtu.devices[i].valid) {
            slot = i;
            break;
        }
    }
    
    if (slot < 0) {
        ESP_LOGE("MODBUS_RTU", "设备已满");
        xSemaphoreGive(modbus_rtu.mutex);
        return ESP_ERR_NO_MEM;
    }
    
    // 添加设备信息
    memcpy(&modbus_rtu.devices[slot].device, device, sizeof(modbus_device_t));
    modbus_rtu.devices[slot].valid = true;
    modbus_rtu.devices[slot].last_poll_time = 0;
    modbus_rtu.device_count++;
    
    // 返回设备ID
    if (device_id) {
        *device_id = slot;
    }
    
    ESP_LOGI("MODBUS_RTU", "添加Modbus设备: ID=%d, 从站地址=%d", 
             slot, device->slave_id);
    
    // 释放互斥锁
    xSemaphoreGive(modbus_rtu.mutex);
    
    return ESP_OK;
}

在这个模块中，互斥信号量用于保护Modbus设备列表等共享资源，确保不同任务（轮询任务和API调用任务）对共享数据的访问是互斥的，避免数据竞争问题。

4.3 计数与事件管理

计数信号量适用于需要追踪可用资源数量或事件发生次数的场景。

示例：缓冲区池管理

下面的示例展示了如何使用计数信号量管理有限的缓冲区资源：

// 定义缓冲区结构
#define BUFFER_SIZE 128
#define NUM_BUFFERS 5

typedef struct {
    uint8_t data[BUFFER_SIZE];
    bool in_use;
} buffer_t;

// 缓冲区池
static buffer_t buffer_pool[NUM_BUFFERS];

// 计数信号量，表示可用缓冲区数量
static SemaphoreHandle_t buffer_semaphore;

// 互斥锁，保护缓冲区分配操作
static SemaphoreHandle_t buffer_mutex;

// 初始化缓冲区池
void buffer_pool_init(void)
{
    // 创建计数信号量，初始值为缓冲区总数
    buffer_semaphore = xSemaphoreCreateCounting(NUM_BUFFERS, NUM_BUFFERS);
    
    // 创建互斥锁
    buffer_mutex = xSemaphoreCreateMutex();
    
    // 初始化所有缓冲区为未使用状态
    for (int i = 0; i < NUM_BUFFERS; i++) {
        buffer_pool[i].in_use = false;
    }
}

// 分配缓冲区
buffer_t* buffer_alloc(TickType_t wait_ticks)
{
    buffer_t* buffer = NULL;
    
    // 尝试获取信号量，表示请求一个缓冲区
    if (xSemaphoreTake(buffer_semaphore, wait_ticks) == pdTRUE) {
        // 获取互斥锁，保护分配操作
        xSemaphoreTake(buffer_mutex, portMAX_DELAY);
        
        // 查找未使用的缓冲区
        for (int i = 0; i < NUM_BUFFERS; i++) {
            if (!buffer_pool[i].in_use) {
                buffer_pool[i].in_use = true;
                buffer = &buffer_pool[i];
                break;
            }
        }
        
        xSemaphoreGive(buffer_mutex);
    }
    
    return buffer;
}

// 释放缓冲区
void buffer_free(buffer_t* buffer)
{
    if (buffer == NULL) {
        return;
    }
    
    // 确保缓冲区属于池
    if (buffer >= &buffer_pool[0] && buffer <= &buffer_pool[NUM_BUFFERS-1]) {
        // 获取互斥锁
        xSemaphoreTake(buffer_mutex, portMAX_DELAY);
        
        // 标记为未使用
        buffer->in_use = false;
        
        xSemaphoreGive(buffer_mutex);
        
        // 释放信号量，表示一个缓冲区可用
        xSemaphoreGive(buffer_semaphore);
    }
}

在这个示例中，计数信号量buffer_semaphore用于跟踪可用缓冲区的数量。当任务需要缓冲区时，先获取计数信号量，然后再从池中分配具体的缓冲区。当缓冲区被释放时，先归还到池中，然后释放计数信号量，表示增加了一个可用缓冲区。

这种设计可以确保任务在没有可用缓冲区时等待，而不是轮询检查，提高了系统效率和实时性。

5. 信号量使用中的常见错误

在使用FreeRTOS信号量时，有一些常见的错误模式可能导致系统行为异常，甚至引发严重的运行时错误。本节将介绍这些常见错误及其解决方法。

5.1 死锁问题

死锁是多任务编程中最常见也是最严重的问题之一。当两个或多个任务互相等待对方持有的资源时，就会发生死锁，导致这些任务永远无法继续执行。

死锁示例

// 定义两个互斥信号量
SemaphoreHandle_t xMutex1, xMutex2;

void task1(void *pvParameters)
{
    while (1) {
        // 先获取互斥锁1
        xSemaphoreTake(xMutex1, portMAX_DELAY);
        
        // 执行一些操作
        vTaskDelay(pdMS_TO_TICKS(10));
        
        // 尝试获取互斥锁2
        xSemaphoreTake(xMutex2, portMAX_DELAY);
        
        // 临界区代码
        // ...
        
        // 释放互斥锁
        xSemaphoreGive(xMutex2);
        xSemaphoreGive(xMutex1);
        
        vTaskDelay(pdMS_TO_TICKS(100));
    }
}

void task2(void *pvParameters)
{
    while (1) {
        // 先获取互斥锁2 - 与task1获取顺序相反
        xSemaphoreTake(xMutex2, portMAX_DELAY);
        
        // 执行一些操作
        vTaskDelay(pdMS_TO_TICKS(10));
        
        // 尝试获取互斥锁1
        xSemaphoreTake(xMutex1, portMAX_DELAY);
        
        // 临界区代码
        // ...
        
        // 释放互斥锁
        xSemaphoreGive(xMutex1);
        xSemaphoreGive(xMutex2);
        
        vTaskDelay(pdMS_TO_TICKS(100));
    }
}

在这个示例中，如果task1获取了xMutex1并等待xMutex2，同时task2获取了xMutex2并等待xMutex1，就会发生死锁。

解决方法

1. 固定获取顺序：确保所有任务按照相同的顺序获取互斥锁
2. 超时机制：使用带超时的信号量获取，而不是无限等待
3. 避免循环依赖：重构代码，消除资源之间的循环依赖关系
4. 使用递归互斥锁：在某些情况下，递归互斥锁可以避免自锁

5.2 优先级反转

优先级反转是指低优先级任务持有高优先级任务所需的资源，而中优先级任务抢占了低优先级任务的执行时间，导致高优先级任务被不定时间地阻塞。

解决方法

FreeRTOS的互斥信号量内置了优先级继承机制，可以有效解决优先级反转问题：

// 创建互斥信号量
SemaphoreHandle_t xMutex = xSemaphoreCreateMutex();

void highPriorityTask(void *pvParameters)
{
    while (1) {
        // 高优先级任务尝试获取互斥锁
        xSemaphoreTake(xMutex, portMAX_DELAY);
        
        // 临界区代码
        // ...
        
        xSemaphoreGive(xMutex);
        
        vTaskDelay(pdMS_TO_TICKS(100));
    }
}

void lowPriorityTask(void *pvParameters)
{
    while (1) {
        // 低优先级任务获取互斥锁
        xSemaphoreTake(xMutex, portMAX_DELAY);
        
        // 临界区代码 - 当高优先级任务尝试获取互斥锁时
        // 低优先级任务的优先级会临时提升到与高优先级任务相同
        // ...
        
        xSemaphoreGive(xMutex);
        
        vTaskDelay(pdMS_TO_TICKS(100));
    }
}

在这个例子中，当高优先级任务尝试获取已被低优先级任务持有的互斥锁时，低优先级任务的优先级会临时提升到与高优先级任务相同的级别，确保它能尽快完成临界区操作并释放互斥锁。

5.3 看门狗超时

在嵌入式系统中，通常会启用看门狗定时器来监控系统运行状态。如果任务长时间阻塞在信号量获取操作上，可能导致看门狗无法及时喂狗而触发系统重启。

错误示例

void task_with_watchdog(void *pvParameters)
{
    // 初始化看门狗
    esp_task_wdt_init(5, true); // 5秒超时，超时后复位系统
    esp_task_wdt_add(NULL);     // 将当前任务添加到看门狗监控
    
    while (1) {
        // 喂狗
        esp_task_wdt_reset();
        
        // 尝试获取可能永远不会可用的信号量
        xSemaphoreTake(xSemaphore, portMAX_DELAY);
        
        // 如果信号量永远不可用，这里的代码永远不会执行
        // 看门狗将在5秒后触发系统重启
        
        // ...
        
        xSemaphoreGive(xSemaphore);
    }
}

解决方法

1. 使用带超时的信号量获取：

const TickType_t xMaxBlockTime = pdMS_TO_TICKS(3000); // 3秒超时

while (1) {
    // 喂狗
    esp_task_wdt_reset();
    
    // 尝试获取信号量，最多等待3秒
    if (xSemaphoreTake(xSemaphore, xMaxBlockTime) == pdTRUE) {
        // 成功获取信号量
        // ...
        xSemaphoreGive(xSemaphore);
    } else {
        // 处理超时情况
    }
}

2. 在等待过程中定期喂狗：

while (1) {
    // 尝试获取信号量，但分多次短时间等待，每次等待后喂狗
    const TickType_t xShortWait = pdMS_TO_TICKS(500); // 500毫秒
    int attempts = 0;
    bool got_semaphore = false;
    
    while (attempts < 10) { // 最多尝试10次，共5秒
        if (xSemaphoreTake(xSemaphore, xShortWait) == pdTRUE) {
            got_semaphore = true;
            break;
        }
        
        // 喂狗
        esp_task_wdt_reset();
        attempts++;
    }
    
    if (got_semaphore) {
        // 成功获取信号量
        // ...
        xSemaphoreGive(xSemaphore);
    } else {
        // 多次尝试后仍未获取信号量
        ESP_LOGW("TAG", "多次尝试获取信号量失败");
    }
}

6. 最佳实践

基于前面讨论的内容，以下是使用FreeRTOS信号量的一些最佳实践建议：

6.1 选择合适的信号量类型

• 二值信号量：用于简单的任务同步和事件通知
• 计数信号量：用于资源计数和多事件管理
• 互斥信号量：用于资源互斥访问，特别是当有优先级反转风险时
• 递归互斥信号量：仅在确实需要递归锁定时使用，因为它比普通互斥锁开销更大

6.2 信号量使用规范

1. 始终检查创建结果：信号量创建可能因内存不足而失败

SemaphoreHandle_t xSemaphore = xSemaphoreCreateMutex();
if (xSemaphore == NULL) {
    // 处理创建失败情况
    ESP_LOGE("TAG", "创建互斥锁失败");
    // 可能需要重启或进入安全模式
}

2. 使用适当的超时值：避免无限等待，特别是在有看门狗的系统中

// 根据应用需求选择合适的超时时间
const TickType_t xTimeout = pdMS_TO_TICKS(1000); // 1秒

if (xSemaphoreTake(xSemaphore, xTimeout) == pdTRUE) {
    // 成功获取信号量
} else {
    // 处理超时情况
}

3. 保持临界区简短：在持有信号量时尽量减少执行时间

// 不好的做法
xSemaphoreTake(xMutex, portMAX_DELAY);
perform_lengthy_operation();  // 长时间操作阻塞其他任务
xSemaphoreGive(xMutex);

// 好的做法
// 先准备数据
prepare_data();

// 只在必要的短暂操作中持有互斥锁
xSemaphoreTake(xMutex, portMAX_DELAY);
update_shared_resource();  // 快速操作
xSemaphoreGive(xMutex);

// 继续不需要互斥保护的操作
process_results();

4. 避免在持有信号量时调用可能阻塞的API：

// 不好的做法 - 可能导致长时间持有锁
xSemaphoreTake(xMutex, portMAX_DELAY);
http_request();  // 网络操作可能长时间阻塞
xSemaphoreGive(xMutex);

// 好的做法
// 先获取所需数据的副本
xSemaphoreTake(xMutex, portMAX_DELAY);
copy_required_data();
xSemaphoreGive(xMutex);

// 使用数据副本执行可能阻塞的操作
http_request();

5. 正确处理中断中的信号量操作：

// 在中断中释放信号量
void IRAM_ATTR gpio_isr_handler(void* arg)
{
    BaseType_t xHigherPriorityTaskWoken = pdFALSE;
    
    // 使用FromISR版本的API
    xSemaphoreGiveFromISR(xBinarySemaphore, &xHigherPriorityTaskWoken);
    
    // 如果需要任务切换，通知调度器
    if (xHigherPriorityTaskWoken) {
        portYIELD_FROM_ISR();
    }
}

6. 一致的获取和释放顺序：如果需要多个信号量，始终按照相同的顺序获取和释放

// 获取信号量的顺序
xSemaphoreTake(xMutexA, portMAX_DELAY);
xSemaphoreTake(xMutexB, portMAX_DELAY);

// 处理共享资源
// ...

// 释放信号量的顺序（与获取顺序相反）
xSemaphoreGive(xMutexB);
xSemaphoreGive(xMutexA);

6.3 调试技巧

1. 使用追踪工具：FreeRTOS提供了追踪功能，可以记录信号量操作

// 在FreeRTOSConfig.h中启用追踪
#define configUSE_TRACE_FACILITY 1

2. 实现超时处理：记录信号量获取超时事件，帮助诊断问题

if (xSemaphoreTake(xMutex, xTimeout) != pdTRUE) {
    // 记录超时事件
    ESP_LOGW("TAG", "获取互斥锁超时，可能的死锁: %s:%d", __FILE__, __LINE__);
    // 可以增加计数器或触发诊断
}

3. 使用断言：在关键点添加断言，确保信号量状态符合预期

// 确保在释放信号量前已经获取了信号量
configASSERT(mutex_is_acquired == true);
xSemaphoreGive(xMutex);
mutex_is_acquired = false;

7. 总结

FreeRTOS信号量是实现任务同步和互斥的强大工具，掌握其正确使用方法对于开发稳定、高效的嵌入式系统至关重要。

本文详细介绍了FreeRTOS中的四种信号量类型：二值信号量、计数信号量、互斥信号量和递归互斥信号量，它们各自适用于不同的应用场景。通过实际代码示例展示了信号量在任务同步、资源保护和计数管理中的应用，并讨论了使用信号量时可能遇到的常见问题，如死锁、优先级反转和看门狗超时等。
关注 嵌入式软件客栈 公众号，获取更多内容