FreeRTOS基础入门指南：从原理到实践

1 FreeRTOS概述

1.1 FreeRTOS的定义

FreeRTOS(Free Real-Time Operating System)是一个专门面向微控制器和小型微处理器的实时操作系统。作为一个轻量级的操作系统，它的内核仅需要几个C文件就能完成核心功能，这种精简的特性使其非常适合资源受限的嵌入式系统。FreeRTOS采用MIT开源许可证，这意味着开发者可以自由地将其用于商业产品而无需公开源代码。

1.2 实时性特征

FreeRTOS的实时性主要体现在其调度机制上。它采用基于优先级的抢占式调度算法，可以用以下公式描述其响应时间：

其中，任务切换时间(Context switch)通常在几个微秒级别，这保证了系统能够快速响应外部事件。最大响应时间可以通过下面的公式计算：

1.3 可移植性设计

FreeRTOS采用了分层的架构设计，将硬件相关代码完全隔离在底层端口文件中。这种设计可以用以下层次结构表示：

应用层 → FreeRTOS API → 内核层 → 硬件抽象层(HAL) → 硬件

1.4 内存管理特性

FreeRTOS提供了灵活的内存管理机制，系统内存使用效率可以用以下公式衡量：

1.5 任务管理模型

在FreeRTOS中，每个任务都是一个独立的执行单元，拥有自己的栈空间和控制块(TCB - Task Control Block)。任务状态转换可以用以下关系表示：

Ready ⟷ Running ⟷ Blocked ⟷ Suspended

1.6 时间管理

FreeRTOS使用系统节拍(Tick)作为基本时间单位，任务延时精度可以通过以下公式计算：

其中，Tick_rate通常配置为100Hz或1000Hz。

1.7 资源占用

作为轻量级操作系统，FreeRTOS的资源占用非常小，典型配置下的资源占用如下：

• ROM占用：5-10KB
• RAM占用：基础内核小于1KB
• 每个任务额外开销：任务控制块(约50字节) + 任务栈

1.8 特性集成

FreeRTOS提供了丰富的功能组件：

1. 任务管理：创建、删除、挂起、恢复
2. 任务间通信：队列、信号量、互斥量、事件标志组
3. 时间管理：延时、周期性执行
4. 内存管理：多种堆实现方案
5. 软件定时器：精确的周期性任务执行

1.9 调试支持

FreeRTOS提供了多种调试机制，包括：

• 堆栈溢出检测
• 任务运行时间统计
• 队列注册表
• 跟踪记录功能

这些功能的使用率可以通过以下公式评估：

1.10 开发生态

FreeRTOS拥有庞大的用户社区和丰富的开发资源：

• 详细的官方文档
• 完整的示例工程
• 专业的技术支持
• 丰富的第三方组件

2 FreeRTOS核心特性

2.1 任务管理机制

FreeRTOS的核心是其任务管理系统。每个任务本质上是一个永久循环的C函数，拥有自己独立的执行上下文、栈空间和优先级。任务的内存开销可以用以下公式计算：

任务创建时需要指定优先级，范围从0到configMAX_PRIORITIES-1，数值越大优先级越高。以下是完整的任务创建示例：

void vTaskFunction(void *pvParameters) {
    // 任务初始化
    for(;;) {
        // 任务主体代码
        vTaskDelay(pdMS_TO_TICKS(100));  // 延时100ms
    }
}

// 任务创建
xTaskCreate(
    vTaskFunction,            // 任务函数
    "ExampleTask",           // 任务名称
    configMINIMAL_STACK_SIZE, // 栈大小
    NULL,                    // 传入参数
    tskIDLE_PRIORITY + 1,    // 优先级
    &xTaskHandle             // 任务句柄
);

2.2 调度算法

FreeRTOS采用优先级抢占式调度算法，同时支持时间片轮转。任务的实际执行时间可以通过以下公式估算：

其中，n为中断次数，m为被抢占次数。当多个任务具有相同优先级时，它们将轮流执行，每个时间片的长度为：

2.3 状态转换机制

FreeRTOS任务状态包括：Running（运行）、Ready（就绪）、Blocked（阻塞）、Suspended（挂起）。状态转换效率可以用以下公式表示：

2.4 中断管理

FreeRTOS将中断分为两类：

1. 基础中断处理：直接响应硬件中断
2. 延迟中断处理：通过任务方式处理较长的中断服务

中断响应时间计算公式：

2.5 临界区保护

FreeRTOS提供了多种临界区保护机制：

// 方法1：关闭所有中断
taskENTER_CRITICAL();
// 临界区代码
taskEXIT_CRITICAL();

// 方法2：挂起调度器
vTaskSuspendAll();
// 临界区代码
xTaskResumeAll();

2.6 优先级继承

为了解决优先级反转问题，FreeRTOS实现了优先级继承机制。临时提升的优先级计算公式：

2.7 空闲任务钩子

FreeRTOS允许在空闲任务中添加钩子函数：

void vApplicationIdleHook(void) {
    // 空闲任务钩子函数代码
    // 可以执行低优先级的后台任务
}

2.8 低功耗管理

FreeRTOS支持tickless低功耗模式，可以在系统空闲时关闭系统节拍中断。功耗节省计算公式:

2.9 任务通知

作为轻量级的任务间通信机制，任务通知比传统的队列和信号量更高效：

// 发送任务通知
xTaskNotify(xTaskHandle, 0x01, eSetBits);

// 等待任务通知
ulTaskNotifyTake(pdTRUE, portMAX_DELAY);

2.10 内存保护

在支持MPU的处理器上，FreeRTOS提供了内存保护功能，可以隔离任务的内存访问空间。保护区域的计算公式：

2.11 实时性分析

系统的实时性能可以通过以下指标评估：

3 FreeRTOS常用API

3.1 任务管理API

任务管理是FreeRTOS最基础的功能，主要包括任务的创建、删除、挂起和恢复等操作。创建任务的基本API如下：

BaseType_t xTaskCreate(
    TaskFunction_t pvTaskCode,
    const char * const pcName,
    uint16_t usStackDepth,
    void *pvParameters,
    UBaseType_t uxPriority,
    TaskHandle_t *pxCreatedTask
);

任务栈大小的计算公式：

任务控制相关的核心API包括：

void vTaskDelay(const TickType_t xTicksToDelay);
void vTaskDelayUntil(TickType_t *pxPreviousWakeTime, const TickType_t xTimeIncrement);
void vTaskDelete(TaskHandle_t xTask);
void vTaskSuspend(TaskHandle_t xTask);
void vTaskResume(TaskHandle_t xTask);

3.2 队列管理API

队列是FreeRTOS中最基本的任务间通信机制。队列的有效数据量可以用以下公式计算：

3.3 核心队列操作API：

QueueHandle_t xQueueCreate(UBaseType_t uxQueueLength, UBaseType_t uxItemSize);

BaseType_t xQueueSend(
    QueueHandle_t xQueue,
    const void *pvItemToQueue,
    TickType_t xTicksToWait
);

BaseType_t xQueueReceive(
    QueueHandle_t xQueue,
    void *pvBuffer,
    TickType_t xTicksToWait
);

3.4 信号量API

FreeRTOS提供了多种类型的信号量，每种都有其特定用途：

• 二值信号量：

SemaphoreHandle_t xSemaphoreCreateBinary(void);
BaseType_t xSemaphoreTake(SemaphoreHandle_t xSemaphore, TickType_t xTicksToWait);
BaseType_t xSemaphoreGive(SemaphoreHandle_t xSemaphore);

• 计数信号量：

SemaphoreHandle_t xSemaphoreCreateCounting(UBaseType_t uxMaxCount, UBaseType_t uxInitialCount);

信号量计数的有效范围：

3.5 互斥量API

互斥量是一种特殊的二值信号量，支持优先级继承：

SemaphoreHandle_t xSemaphoreCreateMutex(void);

3.6 事件组API

事件组用于多事件同步，支持复杂的事件等待逻辑：

EventGroupHandle_t xEventGroupCreate(void);

EventBits_t xEventGroupSetBits(
    EventGroupHandle_t xEventGroup,
    const EventBits_t uxBitsToSet
);

EventBits_t xEventGroupWaitBits(
    EventGroupHandle_t xEventGroup,
    const EventBits_t uxBitsToWaitFor,
    const BaseType_t xClearOnExit,
    const BaseType_t xWaitForAllBits,
    TickType_t xTicksToWait
);

3.7 软件定时器API

软件定时器提供了一种延时执行或周期性执行任务的机制：

TimerHandle_t xTimerCreate(
    const char * const pcTimerName,
    const TickType_t xTimerPeriod,
    const UBaseType_t uxAutoReload,
    void * const pvTimerID,
    TimerCallbackFunction_t pxCallbackFunction
);

BaseType_t xTimerStart(TimerHandle_t xTimer, TickType_t xTicksToWait);
BaseType_t xTimerStop(TimerHandle_t xTimer, TickType_t xTicksToWait);

定时器精度计算公式：

3.8 中断管理API

FreeRTOS提供了在中断中使用的特殊API版本：

BaseType_t xQueueSendFromISR(
    QueueHandle_t xQueue,
    const void *pvItemToQueue,
    BaseType_t *pxHigherPriorityTaskWoken
);

BaseType_t xQueueReceiveFromISR(
    QueueHandle_t xQueue,
    void *pvBuffer,
    BaseType_t *pxHigherPriorityTaskWoken
);

3.9 内存管理API

FreeRTOS提供了动态内存分配API：

3.10 任务通知API

任务通知是一种轻量级的任务间通信机制：

BaseType_t xTaskNotify(TaskHandle_t xTaskToNotify, uint32_t ulValue, eNotifyAction eAction);
BaseType_t xTaskNotifyWait(uint32_t ulBitsToClearOnEntry, uint32_t ulBitsToClearOnExit,
                          uint32_t *pulNotificationValue, TickType_t xTicksToWait);

3.11 调试辅助API

用于系统监控和调试的API：

UBaseType_t uxTaskGetStackHighWaterMark(TaskHandle_t xTask);
void vTaskList(char *pcWriteBuffer);
void vTaskGetRunTimeStats(char *pcWriteBuffer);

堆栈使用率计算公式：

4 FreeRTOS配置

4.1 基础配置文件

FreeRTOS通过FreeRTOSConfig.h文件进行系统配置，该文件包含了一系列预处理宏定义，决定了FreeRTOS的行为特征。基本配置文件结构如下：

#ifndef FREERTOS_CONFIG_H
#define FREERTOS_CONFIG_H

/* 基础系统配置 */
#define configUSE_PREEMPTION                    1
#define configCPU_CLOCK_HZ                      ( SystemCoreClock )
#define configTICK_RATE_HZ                      ( ( TickType_t ) 1000 )
#define configMAX_PRIORITIES                    ( 5 )
#define configMINIMAL_STACK_SIZE               ( ( unsigned short ) 128 )
#define configTOTAL_HEAP_SIZE                  ( ( size_t ) ( 10 * 1024 ) )

#endif /* FREERTOS_CONFIG_H */

4.2 内核配置参数

1. 调度器配置

系统节拍周期计算公式：

优先级范围计算：

关键配置项包括：

#define configUSE_TIME_SLICING                  1  // 启用时间片轮转
#define configIDLE_SHOULD_YIELD                 1  // 空闲任务让出CPU
#define configUSE_PORT_OPTIMISED_TASK_SELECTION 1  // 启用优化的任务选择

2. 内存管理配置

堆内存利用率计算公式：

相关配置：

#define configAPPLICATION_ALLOCATED_HEAP        0  // 堆由应用程序分配
#define configSUPPORT_DYNAMIC_ALLOCATION        1  // 支持动态内存分配
#define configSUPPORT_STATIC_ALLOCATION         0  // 支持静态内存分配

3. 钩子函数配置

#define configUSE_IDLE_HOOK                     0  // 空闲任务钩子
#define configUSE_TICK_HOOK                     0  // 时钟节拍钩子
#define configCHECK_FOR_STACK_OVERFLOW          2  // 栈溢出检测

4.3 功能模块配置

1.队列配置 队列实际容量计算：

#define configUSE_QUEUE_SETS                    1  // 启用队列集
#define configQUEUE_REGISTRY_SIZE              10  // 队列注册表大小

2.定时器配置

#define configUSE_TIMERS                        1  // 启用软件定时器
#define configTIMER_TASK_PRIORITY              (configMAX_PRIORITIES - 1)
#define configTIMER_QUEUE_LENGTH               10
#define configTIMER_TASK_STACK_DEPTH          configMINIMAL_STACK_SIZE

定时器精度计算：

4.4 调试配置

1.追踪功能配置

#define configUSE_TRACE_FACILITY                1  // 启用追踪
#define configGENERATE_RUN_TIME_STATS          1  // 启用运行时统计
#define configUSE_STATS_FORMATTING_FUNCTIONS    1  // 启用统计格式化

 2.断言配置

#define configASSERT(x) if((x) == 0) vAssertCalled(__FILE__, __LINE__)

4.5 中断配置

中断优先级配置：

#define configKERNEL_INTERRUPT_PRIORITY         [lowest priority]
#define configMAX_SYSCALL_INTERRUPT_PRIORITY    [highest priority]

中断响应时间计算：

4.6 低功耗配置

#define configUSE_TICKLESS_IDLE                 1  // 启用无节拍空闲模式

功耗节省计算：

4.7 任务通知配置

#define configUSE_TASK_NOTIFICATIONS            1  // 启用任务通知
#define configTASK_NOTIFICATION_ARRAY_ENTRIES   3  // 通知数组大小

4.8 性能优化配置

1.内存对齐配置

#define configMINIMAL_STACK_SIZE_ALLIGNMENT     8

 2.端口优化配置

#define configUSE_PORT_OPTIMISED_TASK_SELECTION 1

4.9 标准库集成配置

#define configUSE_NEWLIB_REENTRANT             1  // 支持newlib重入

4.10 应用程序特定配置

可以添加自定义配置来满足特定需求：

#define configAPP_CUSTOM_SETTING               100

4.11 配置验证

系统会在启动时验证配置的有效性，可以通过以下公式评估配置的合理性：

通过合理配置这些参数，可以实现：

• 优化系统性能
• 减少内存占用
• 提高实时响应能力
• 增强系统可靠性
• 便于调试和维护

 5 FreeRTOS内存管理

5.1 内存分配策略概述

FreeRTOS 提供了 5 种堆内存管理实现，每种实现都在 portable/MemMang 目录下以独立的 .c 文件存在。这些不同的实现方案针对不同的应用场景：

5.2 heap_1: 最简单的分配器

heap_1是最基础的内存分配方案。它只实现了内存分配功能，不支持内存释放。这种方案使用简单的指针递增方式来分配内存，内存一旦分配就不能被回收。它特别适合那些只需要在系统启动时分配内存，之后就不再需要动态分配的应用场景。由于不支持内存释放，它完全避免了内存碎片化的问题，实现简单且运行效率高。这是最基础的内存分配方案，特点是:

• 只实现 pvPortMalloc()，不实现 vPortFree()
• 适合那些只在启动时分配内存的应用
• 内存分配采用简单的指针递增方式

// heap_1 的基本实现框架
static uint8_t ucHeap[configTOTAL_HEAP_SIZE];
static size_t xNextFreeByte = 0;

void *pvPortMalloc(size_t xWantedSize) {
    void *pvReturn = NULL;
    
    // 确保对齐
    if((xWantedSize & portBYTE_ALIGNMENT_MASK) != 0) {
        xWantedSize += (portBYTE_ALIGNMENT - (xWantedSize & portBYTE_ALIGNMENT_MASK));
    }
    
    // 检查是否有足够空间
    if((xNextFreeByte + xWantedSize) <= configTOTAL_HEAP_SIZE) {
        pvReturn = &ucHeap[xNextFreeByte];
        xNextFreeByte += xWantedSize;
    }
    
    return pvReturn;
}

5.3 heap_2: 支持释放的分配器

heap_2提供了更完整的内存管理功能，它既支持内存分配也支持内存释放。这种方案采用最佳匹配算法来分配内存，即寻找大小最接近请求大小的空闲内存块。虽然这种方案提供了更灵活的内存管理，但随着系统运行时间的增加，可能会出现内存碎片化问题。当系统频繁进行内存分配和释放操作时，这个问题会变得更加明显。这个版本添加了内存释放功能：

• A：创建了3个任务
• B：删除了一个任务，空闲内存有3部分：顶层的、被删除任务的TCB空间、被删除任务的Stack空间
• C：创建了一个新任务，因为TCB、栈大小跟前面被删除任务的TCB、栈大小一致，所以刚好分配到原来的内存

• 使用最佳匹配算法(Best Fit)
• 支持 vPortFree()
• 可能产生内存碎片
• 内存块使用链表管理

关键数据结构：

typedef struct A_BLOCK_LINK {
    struct A_BLOCK_LINK *pxNextFreeBlock;  // 指向下一个空闲块
    size_t xBlockSize;                     // 当前块大小
} BlockLink_t;

5.4 heap_3:委托管理的分配器

heap_3是对标准C库malloc和free函数的封装。它直接使用标准库的内存管理函数，但增加了线程安全的保护机制。但需要注意的是，标准库的内存管理函数通常不是线程安全的，heap_3通过添加互斥机制来确保线程安全。这种方案的最大优势是与标准C库完全兼容，便于移植现有的应用程序。然而，由于标准库的内存管理函数通常不是为实时操作系统设计的，其性能和确定性可能不如其他方案。

5.5 heap_4: 支持合并的分配器

heap_4是一个比较完善的内存管理方案。它不仅支持内存分配和释放，还能自动合并相邻的空闲内存块，这大大减少了内存碎片化的问题。该方案使用首次适配算法，即使用第一个足够大的空闲块来满足分配请求。这种方案在提供灵活性的同时，也保持了较好的性能和内存利用率。heap_4 是一个更完善的实现：

• A：创建了3个任务
• B：删除了一个任务，空闲内存有2部分：
  • 顶层的
  • 被删除任务的TCB空间、被删除任务的Stack空间合并起来的
• C：分配了一个Queue，从第1个空闲块中分配空间
• D：分配了一个User数据，从Queue之后的空闲块中分配
• E：释放的Queue，User前后都有一块空闲内存
• F：释放了User数据，User前后的内存、User本身占据的内存，合并为一个大的空闲内存

• 使用首次适配算法(First Fit)
• 支持相邻空闲块的自动合并
• 内存块按地址排序，便于合并操作

内存碎片率计算公式：

FragmentationRatio = (TotalFreeSpace - LargestFreeBlock) / TotalFreeSpace × 100%

示例代码：

void vPortFree(void *pv) {
    uint8_t *puc = (uint8_t *)pv;
    BlockLink_t *pxLink;

    // 获取块头
    puc -= xHeapStructSize;
    pxLink = (BlockLink_t *)puc;

    // 插入空闲链表
    vListInsertEnd(&xFreeList, &(pxLink->xBlockListItem));

    // 尝试合并相邻块
    prvHeapCombineBlocks(pxLink);
}

5.6 heap_5: 多区域内存管理

heap_5是对heap_4的扩展，它支持管理多个不连续的内存区域。这对于那些硬件设计中存在内存空洞或多个独立内存区域的系统特别有用。它保持了heap_4的所有特性，包括自动合并相邻空闲块的功能，同时增加了跨内存区域分配的能力。heap_5 允许管理多个不连续的内存区域：

• 支持添加额外的内存区域
• 继承了 heap_4 的所有特性
• 适用于存在内存空洞的系统

初始化示例：

// 定义多个内存区域
static uint8_t ucHeap1[50 * 1024];  // 50KB
static uint8_t ucHeap2[10 * 1024];  // 10KB

void initHeap(void) {
    HeapRegion_t xHeapRegions[] = {
        { ucHeap1, sizeof(ucHeap1) },
        { ucHeap2, sizeof(ucHeap2) },
        { NULL, 0 }  // 结束标记
    };
    
    // 初始化内存管理器
    vPortDefineHeapRegions(xHeapRegions);
}

5.7 内存管理效率监控

FreeRTOS 提供了几个重要的 API 来监控内存使用情况：

// 获取当前空闲堆空间大小
size_t xPortGetFreeHeapSize(void);

// 获取到目前为止最小的空闲堆空间大小
size_t xPortGetMinimumEverFreeHeapSize(void);

// 在heap_4/5中，获取最大的连续空闲块大小
size_t xPortGetLargestFreeBlock(void);

使用这些 API 可以计算实时的内存碎片率：

float calculateFragmentation(void) {
    size_t totalFree = xPortGetFreeHeapSize();
    size_t largestBlock = xPortGetLargestFreeBlock();
    
    return ((float)(totalFree - largestBlock) / totalFree) * 100.0f;
}

5.8 选择建议

1. 系统的动态内存需求：如果系统只需要在启动时分配内存，heap_1就足够了。
2. 内存大小限制：在内存非常受限的系统中，简单的方案如heap_1可能更合适。
3. 性能需求：不同方案在分配和释放效率上有显著差异。
4. 碎片化问题：如果系统需要长期运行，应该选择具有防碎片化功能的方案。
5. 硬件架构：某些特殊的硬件设计可能需要使用heap_5来管理多个内存区域。

6  FreeRTOS任务间通信

FreeRTOS提供了丰富的任务间通信机制，每种机制都有其特定的应用场景和优势。

6.1 队列

队列(Queue)是最基础和使用最广泛的通信机制。它允许任务和中断将数据放入队列尾部，其他任务可以从队列头部获取数据。队列支持多个发送者和接收者，可以设置阻塞超时时间，使任务在等待数据时进入阻塞状态以节省CPU资源。队列还内置了优先级继承机制，可以有效防止优先级反转问题。

// 创建队列
QueueHandle_t xQueue = xQueueCreate(5, sizeof(uint32_t));

// 发送数据
uint32_t value = 100;
xQueueSend(xQueue, &value, portMAX_DELAY);

// 接收数据
uint32_t receivedValue;
if(xQueueReceive(xQueue, &receivedValue, portMAX_DELAY) == pdTRUE) {
    // 处理接收到的数据
}

特点：

• 支持多个发送者和接收者
• 可以设置阻塞超时时间
• 支持优先级继承以避免优先级反转

6.2 信号量

信号量(Semaphore)分为二值信号量和计数信号量两种。二值信号量类似于互斥量，主要用于简单的同步或互斥访问。它只有两种状态：可用和不可用。计数信号量则可以有多个计数值，常用于管理资源池或追踪事件发生的次数。比如，当管理一个有限的资源池时，可以创建一个初始值等于资源数量的计数信号量。

二值信号量

// 创建二值信号量
SemaphoreHandle_t xSemaphore = xSemaphoreCreateBinary();

// 获取信号量
if(xSemaphoreTake(xSemaphore, portMAX_DELAY) == pdTRUE) {
    // 访问共享资源
    xSemaphoreGive(xSemaphore);  // 释放信号量
}

计数信号量

// 创建计数信号量，最大计数为5
SemaphoreHandle_t xSemaphore = xSemaphoreCreateCounting(5, 0);

// 示例：用于资源池管理
void vResourceUser(void *pvParameters) {
    while(1) {
        if(xSemaphoreTake(xSemaphore, portMAX_DELAY) == pdTRUE) {
            // 使用资源
            xSemaphoreGive(xSemaphore);  // 归还资源
        }
    }
}

6.3 事件组

事件组(Event Groups)提供了一种多事件同步机制。每个事件组包含多个事件位，任务可以等待一个或多个事件位被设置。这在需要等待多个条件都满足时特别有用。例如，一个数据处理任务可能需要等待传感器数据和配置数据都准备好才能开始处理。事件组支持设置、清除和等待多个事件位，还可以选择是等待所有事件都发生还是任意一个事件发生。

事件组用于多事件同步：

// 创建事件组
EventGroupHandle_t xEventGroup = xEventGroupCreate();

// 定义事件位
#define EVENT_TEMP_READY     (1 << 0)
#define EVENT_HUMID_READY    (1 << 1)
#define ALL_EVENTS           (EVENT_TEMP_READY | EVENT_HUMID_READY)

// 设置事件
xEventGroupSetBits(xEventGroup, EVENT_TEMP_READY);

// 等待多个事件
EventBits_t uxBits = xEventGroupWaitBits(
    xEventGroup,     // 事件组句柄
    ALL_EVENTS,      // 等待的位
    pdTRUE,         // 清除这些位
    pdTRUE,         // 等待所有位
    portMAX_DELAY   // 无限等待
);

6.4 消息缓冲区

消息缓冲区(Message Buffer)专门用于处理变长数据的传输。与队列不同，消息缓冲区不要求固定大小的数据项，而是提供了类似流式处理的接口。这对于处理串行数据流或网络数据包等场景特别有用。消息缓冲区在发送数据时会同时传输数据长度信息，接收方可以准确知道每条消息的大小。

适用于变长数据传输：

// 创建消息缓冲区
MessageBufferHandle_t xMessageBuffer = xMessageBufferCreate(100);

// 发送数据
const char *message = "Hello World";
size_t xBytesSent = xMessageBufferSend(
    xMessageBuffer,
    (void *)message,
    strlen(message),
    portMAX_DELAY
);

// 接收数据
char receiveBuffer[20];
size_t xBytesReceived = xMessageBufferReceive(
    xMessageBuffer,
    receiveBuffer,
    sizeof(receiveBuffer),
    portMAX_DELAY
);

6.5 流缓冲区

流缓冲区(Stream Buffer)与消息缓冲区类似，但更适合处理连续的字节流数据。它不会在数据中添加长度信息，而是直接传输原始数据。这使得流缓冲区特别适合处理需要连续传输的数据流，如串行通信数据。

类似消息缓冲区，但更适合字节流：

// 创建流缓冲区
StreamBufferHandle_t xStreamBuffer = xStreamBufferCreate(100, 20);

// 发送数据
uint8_t data[] = {0x01, 0x02, 0x03};
size_t xBytesSent = xStreamBufferSend(
    xStreamBuffer,
    data,
    sizeof(data),
    portMAX_DELAY
);

// 接收数据
uint8_t receiveBuffer[10];
size_t xBytesReceived = xStreamBufferReceive(
    xStreamBuffer,
    receiveBuffer,
    sizeof(receiveBuffer),
    portMAX_DELAY
);

6.6 任务通知

任务通知(Task Notification)是一种轻量级的任务间通信机制。每个任务都有一个32位的通知值，其他任务可以直接修改这个值来实现通信。任务通知的性能优于队列和信号量，因为它不需要创建额外的内核对象。它特别适合简单的一对一通信场景。

轻量级的任务间通信机制：

// 发送任务通知
xTaskNotify(xTargetTask, 0x01, eSetBits);

// 等待任务通知
uint32_t ulNotificationValue;
if(xTaskNotifyWait(0x00, 0xFFFFFFFF, &ulNotificationValue, portMAX_DELAY) == pdTRUE) {
    // 处理通知
}

6.7 选择通信机制

在选择通信机制时，需要考虑几个关键因素：功能需求、性能要求和资源限制。对于简单的一对一通信，任务通知是最轻量级的选择。如果需要数据缓冲或多个发送者/接收者，队列是更好的选择。当需要管理共享资源时，信号量是合适的工具。对于需要多个条件同步的场景，事件组提供了便捷的解决方案。而在处理变长数据或连续数据流时，消息缓冲区和流缓冲区则是专门的解决方案。

不同通信机制的开销比较（从低到高）：

1. 任务通知（最轻量）
2. 二值信号量
3. 队列（单元素）
4. 计数信号量
5. 事件组
6. 队列（多元素）
7. 消息/流缓冲区（最重）

使用这些通信机制时要注意避免一些常见问题，如死锁、优先级反转等。FreeRTOS提供了优先级继承等机制来帮助处理这些问题，但良好的系统设计和仔细的实现也是确保系统可靠性的关键。