FreeRTOS学习记录（2）：内存管理、中断处理、定时器、优先级继承 (万字长文)

方案 1：heap_1（仅分配，不释放）最简单的内存管理方案，仅支持pvPortMalloc()分配内存，不提供vPortFree()释放接口。内存分配基于静态数组，分配时从数组起始地址向后连续分配，适合无需动态释放内存的场景（如任务创建后持续运行至系统结束），优点是代码简洁、无碎片、执行时间确定，缺点是内存无法复用。
方案 2：heap_2（支持分配与释放，无碎片合并）支持内存的分配与释放，但不具备碎片合并功能。采用 “最佳匹配” 算法，从空闲内存块链表中选择最接近申请大小的块分配，释放时仅将内存块归还给空闲链表，不合并相邻空闲块。适合内存块大小固定的场景（如频繁创建 / 删除相同栈大小的任务），避免碎片积累，缺点是长期动态分配不同大小内存时会产生碎片。
方案 3：heap_3（封装标准 C 库内存管理）直接封装标准 C 库的malloc()和free()函数，通过关闭中断保证线程安全（分配 / 释放时禁用任务调度和中断，分配完成后恢复）。优点是兼容性强，无需修改即可适配多数编译器，缺点是实时性差（malloc()/free()执行时间不确定）、易产生碎片，仅适合对实时性要求不高的场景。
方案 4：heap_4（支持分配、释放与碎片合并）最常用的内存管理方案，支持内存分配、释放及相邻空闲块合并（ coalescence）。采用 “首次适应” 算法，分配时从空闲链表起始位置查找首个满足大小的块，释放时会检查当前块的前后是否存在空闲块，若存在则合并为一个大的空闲块，有效减少内存碎片。支持动态调整堆大小，适配大多数嵌入式场景的需求。

代码示例

#include <Arduino.h>
#include <freertos/FreeRTOS.h>
#include <freertos/task.h>

// 任务句柄
TaskHandle_t memTestTaskHandle = NULL;

// 内存操作测试任务
void vMemTestTask(void *pvParameters) {
  for (;;) {
    // 1. 动态分配内存（使用pvPortMalloc，而非malloc）
    int *pIntBuffer = (int *)pvPortMalloc(10 * sizeof(int));
    if (pIntBuffer != NULL) {
      // 内存分配成功，写入测试数据
      for (int i = 0; i < 10; i++) {
        pIntBuffer[i] = i * 10;
      }
      // 打印分配的内存数据
      Serial2.print("分配的内存数据：");
      for (int i = 0; i < 10; i++) {
        Serial2.print(pIntBuffer[i]);
        Serial2.print(" ");
      }
      Serial2.println();

      // 2. 释放内存（使用vPortFree，而非free）
      vPortFree(pIntBuffer);
      pIntBuffer = NULL; // 避免野指针
      Serial2.println("内存释放完成");
    } else {
      Serial2.println("内存分配失败！");
    }

    vTaskDelay(2000 / portTICK_PERIOD_MS); // 每2秒执行一次
  }
}

void setup() {
  Serial2.begin(115200);
  while (!Serial2); // 等待串口连接

  // 创建内存测试任务
  xTaskCreate(
    vMemTestTask,       // 任务函数
    "MemTestTask",      // 任务名称（仅调试用）
    1024,               // 任务栈大小（单位：字，Arduino Uno中1字=2字节）
    NULL,               // 任务参数
    tskIDLE_PRIORITY + 1, // 任务优先级
    &memTestTaskHandle  // 任务句柄
  );

  vTaskStartScheduler(); // 启动任务调度器
}

void loop() {
  // 调度器启动后，loop函数不会执行
}

关键说明

Arduino+FreeRTOS 推荐使用pvPortMalloc()/vPortFree()替代标准 C 库malloc()/free()，避免线程安全问题和实时性不足的问题。
任务栈大小需根据任务实际需求配置（如上述代码中 1024 字 = 2048 字节），栈溢出会导致系统崩溃，可通过configCHECK_FOR_STACK_OVERFLOW配置栈溢出检测（在FreeRTOSConfig.h中）。
若需使用其他内存管理方案（如 heap_1），需替换 Arduino 安装目录下libraries\FreeRTOS\src\portable\MemMang中的heap_4.c为对应方案文件（如heap_1.c）。

2. 核心设计原则

FreeRTOS 内存管理的核心是 “确定性” 和 “灵活性”：堆空间由用户在配置文件FreeRTOSConfig.h中通过configTOTAL_HEAP_SIZE定义，分配 / 释放操作均通过内核接口封装，避免直接操作硬件内存；不同方案的选择需平衡实时性、内存利用率和开发复杂度，例如资源受限的 MCU 优先选择 heap_1 或 heap_2，复杂场景优先选择 heap_4。

二、FreeRTOS 的中断处理机制

中断是嵌入式系统响应外部事件的关键，FreeRTOS 的中断处理机制需兼顾 “实时性” 和 “线程安全”，核心是通过中断优先级划分和临界区保护实现中断与任务的协同。

1. 中断优先级的划分

FreeRTOS 将中断优先级分为两类，依赖硬件的中断控制器（如 ARM Cortex-M 的 NVIC）支持：

系统级中断（内核相关）：优先级由configMAX_SYSCALL_INTERRUPT_PRIORITY（在FreeRTOSConfig.h中配置）定义，该优先级以上的中断（数值更小，取决于硬件优先级编码）不允许调用 FreeRTOS 的 API 函数，仅用于处理紧急事件（如硬件故障），响应速度最快。
应用级中断（用户相关）：优先级低于或等于configMAX_SYSCALL_INTERRUPT_PRIORITY的中断，允许调用 FreeRTOS 提供的 “中断安全 API”（函数名后缀为FromISR，如xQueueSendFromISR()），用于与任务交互（如传递数据、唤醒任务）。

2. 中断处理的核心流程

外部事件触发中断后，CPU 暂停当前任务，保存上下文（寄存器值），跳转到中断服务函数（ISR）。
ISR 中执行核心处理（如读取传感器数据、清除中断标志），若需与任务交互，调用中断安全 API（不可直接调用普通 API，否则会破坏任务上下文）。
中断处理完成后，CPU 检查是否有更高优先级的任务被唤醒（如 ISR 通过 API 唤醒了高优先级任务），若有则触发任务切换，运行高优先级任务；否则恢复原任务的上下文，继续执行原任务。

代码示例

#include <Arduino.h>
#include <freertos/FreeRTOS.h>
#include <freertos/task.h>

// 定义队列（用于中断与任务通信）
QueueHandle_t xInterruptQueue;
// 外部中断引脚（Arduino Uno示例：2号引脚）
const int INTERRUPT_PIN = 2;

// 中断服务函数（ISR）
void IRAM_ATTR vExternalInterruptHandler() {
  static int interruptCount = 0;
  interruptCount++;

  // 向队列发送数据（使用中断安全API xQueueSendFromISR）
  BaseType_t xHigherPriorityTaskWoken = pdFALSE;
  xQueueSendFromISR(
    xInterruptQueue,       // 队列句柄
    &interruptCount,       // 发送的数据
    &xHigherPriorityTaskWoken // 标记是否需要触发任务切换
  );

  // 若需要切换任务，通知内核（ESP32/AVR通用）
  portYIELD_FROM_ISR(xHigherPriorityTaskWoken);
}

// 处理中断数据的任务
void vInterruptProcessTask(void *pvParameters) {
  int receivedCount = 0;
  for (;;) {
    // 从队列接收数据（阻塞等待，无超时）
    if (xQueueReceive(xInterruptQueue, &receivedCount, portMAX_DELAY) == pdPASS) {
      Serial.print("收到中断触发次数：");
      Serial.println(receivedCount);
    }
  }
}

void setup() {
  Serial.begin(115200);
  while (!Serial);

  // 创建队列（队列长度10，每个数据项为int类型）
  xInterruptQueue = xQueueCreate(10, sizeof(int));

  // 创建中断处理任务
  xTaskCreate(
    vInterruptProcessTask,
    "InterruptProcessTask",
    1024,
    NULL,
    tskIDLE_PRIORITY + 2,
    NULL
  );

  // 配置外部中断（上升沿触发）
  pinMode(INTERRUPT_PIN, INPUT_PULLDOWN);
  attachInterrupt(
    digitalPinToInterrupt(INTERRUPT_PIN), // 中断引脚映射
    vExternalInterruptHandler,            // 中断服务函数
    RISING                                // 触发方式（RISING（高电平）/FALLING（低电平）/CHANGE（电平改变））
  );

  vTaskStartScheduler();
}

void loop() {}

3. 固定优先级的说明

FreeRTOS没有统一的 “固定中断优先级”，中断优先级的划分依赖两个关键配置：

configMAX_SYSCALL_INTERRUPT_PRIORITY：定义应用级中断的最高优先级，由用户根据硬件和需求配置（如 ARM Cortex-M 中，优先级数值范围通常为 0~15，0 为最高，需确保该值不高于硬件支持的最大优先级）。
硬件本身的中断优先级：不同外设的中断优先级需在硬件初始化时配置（如 UART 中断、定时器中断），但必须遵循 “应用级中断优先级 ≤ configMAX_SYSCALL_INTERRUPT_PRIORITY” 的规则。

简单来说，FreeRTOS 通过配置值划分了 “可调用 API 的中断优先级范围”，而非固定某个具体优先级数值。

三、FreeRTOS 的软件定时器

软件定时器是 FreeRTOS 提供的基于系统时钟节拍（Tick）的定时服务，无需依赖硬件定时器，可实现周期性或单次性的定时任务触发。

1. 软件定时器的定义与分类

核心本质：基于系统 Tick 计数的 “延时触发器”，系统每产生一个 Tick（由硬件定时器周期性触发，周期由configTICK_RATE_HZ配置，如 1ms/Tick），软件定时器的计数器减 1，当计数器减至 0 时，触发预设的回调函数。
分类：
- 单次定时器：触发一次回调函数后自动停止，需手动重新启动。
- 周期定时器：周期性触发回调函数，直至被手动停止。

2. 工作原理

软件定时器的核心是 “定时器控制块（Timer_t）”，每个定时器对应一个控制块，存储定时器状态（运行 / 停止）、周期 / 延时 Tick 数、回调函数指针、参数等信息。
系统启动时，FreeRTOS 会创建一个 “定时器服务任务（Timer Service Task）”，优先级由configTIMER_TASK_PRIORITY配置（建议设为较高优先级，确保定时响应及时），栈大小由configTIMER_TASK_STACK_DEPTH配置。
当用户通过xTimerCreate()创建定时器、xTimerStart()启动定时器后，定时器控制块被加入到定时器链表中。
系统 Tick 中断触发时，内核会遍历定时器链表，更新每个运行中定时器的计数器；当计数器为 0 时，将该定时器的回调函数加入到 “定时器命令队列” 中。
定时器服务任务不断从命令队列中读取任务，执行对应的回调函数，完成定时触发。

代码示例

#include <Arduino.h>
#include <freertos/FreeRTOS.h>
#include <freertos/task.h>

// 定时器句柄（周期定时器+单次定时器）
TimerHandle_t xPeriodicTimer;
TimerHandle_t xOneShotTimer;

// 周期定时器回调函数
void vPeriodicTimerCallback(TimerHandle_t xTimer) {
  static int periodicCount = 0;
  periodicCount++;
  Serial.print("周期定时器触发：");
  Serial.println(periodicCount);
  // 回调函数中不可调用阻塞API（如vTaskDelay、xQueueReceive）
}

// 单次定时器回调函数
void vOneShotTimerCallback(TimerHandle_t xTimer) {
  Serial.println("单次定时器触发（仅执行一次）");
  // 可在回调函数中重启定时器（若需重复使用）
  // xTimerReset(xOneShotTimer, 0);
}

void setup() {
  Serial.begin(115200);
  while (!Serial);

  // 1. 创建周期定时器（周期2000ms，自动重载）
  xPeriodicTimer = xTimerCreate(
    "PeriodicTimer",      // 定时器名称
    pdMS_TO_TICKS(2000),  // 周期（转换为Tick数，1ms/Tick）
    pdTRUE,               // pdTRUE=周期定时器，pdFALSE=单次定时器
    (void *)0,            // 定时器ID（区分多个定时器）
    vPeriodicTimerCallback // 回调函数
  );

  // 2. 创建单次定时器（延时3000ms，不自动重载）
  xOneShotTimer = xTimerCreate(
    "OneShotTimer",
    pdMS_TO_TICKS(3000),
    pdFALSE,
    (void *)1,
    vOneShotTimerCallback
  );

  // 启动定时器（超时时间0表示立即启动）
  if (xPeriodicTimer != NULL) {
    xTimerStart(xPeriodicTimer, 0);
  }
  if (xOneShotTimer != NULL) {
    xTimerStart(xOneShotTimer, 0);
  }

  vTaskStartScheduler();
}

void loop() {}

关键说明

IRAM_ATTR：ESP32 平台需添加该属性，确保 ISR 函数存储在 RAM 中（执行速度更快）；AVR 平台（如 Uno）可省略。
中断安全 API：ISR 中必须使用xQueueSendFromISR()、xTaskResumeFromISR()等后缀为FromISR的 API，不可使用xQueueSend()、vTaskResume()等普通 API。
优先级配置：Arduino+FreeRTOS 中configMAX_SYSCALL_INTERRUPT_PRIORITY默认配置为适配硬件的值（如 AVR 平台为 3，ESP32 平台为 5），用户无需手动修改，只需确保外设中断优先级不高于该值。

3. 关键注意事项

回调函数的执行上下文是定时器服务任务，因此回调函数中不能调用会阻塞任务的 API（如vTaskDelay()、xQueueReceive()），否则会导致定时器服务任务阻塞，影响所有软件定时器的正常工作。
软件定时器的定时精度依赖系统 Tick 周期，实际定时时间为 “预设 Tick 数 × Tick 周期”，存在 ±1 个 Tick 的误差（如预设 10ms 定时，实际可能在 10ms~11ms 之间），适合对精度要求不高的场景。
多个软件定时器共享定时器服务任务和命令队列，若某个回调函数执行时间过长，会阻塞其他定时器的回调函数触发，需确保回调函数执行时间尽可能短。

四、FreeRTOS 的任务挂起与恢复机制

任务挂起（Suspend）与恢复（Resume）是 FreeRTOS 中任务状态管理的核心功能，用于临时暂停任务执行或恢复被暂停的任务，不涉及任务优先级的改变。

1. 任务状态背景

FreeRTOS 中任务的核心状态包括：就绪（Ready）、运行（Running）、阻塞（Blocked）、挂起（Suspended）。其中：

阻塞状态：任务因等待事件（如延时、队列数据、信号量）而暂停，事件满足后自动恢复为就绪状态。
挂起状态：任务被主动暂停，无自动恢复机制，必须通过显式的恢复操作才能回到就绪状态。

2. 挂起机制

函数接口：vTaskSuspend(TaskHandle_t xTaskToSuspend)，参数为目标任务的句柄（NULL 表示挂起当前任务）。
工作流程：调用该函数后，内核会将目标任务的状态从 “就绪” 或 “运行” 改为 “挂起”，并将其从就绪链表中移除；若挂起的是当前运行的任务，内核会立即切换到下一个最高优先级的就绪任务。
特点：挂起操作无超时机制，被挂起的任务不会参与任务调度，直至被恢复。

3. 恢复机制

函数接口：vTaskResume(TaskHandle_t xTaskToResume)（普通恢复）、xTaskResumeFromISR(TaskHandle_t xTaskToResume)（中断中恢复，返回值表示是否需要触发任务切换）。
工作流程：调用恢复函数后，内核会检查目标任务的状态，若为 “挂起” 则将其改为 “就绪”，并加入到对应优先级的就绪链表中；若恢复后的任务优先级高于当前运行任务的优先级，会触发任务切换（普通恢复在任务上下文执行，中断恢复需通过返回值通知内核切换）。
嵌套挂起与恢复：若任务被多次挂起（如两次调用vTaskSuspend()），需对应次数的恢复操作（两次调用vTaskResume()）才能恢复为就绪状态，内核会记录挂起次数，每次恢复操作递减计数，计数为 0 时才切换状态。

任务挂起与恢复代码示例

#include <Arduino.h>
#include <freertos/FreeRTOS.h>
#include <freertos/task.h>

// 任务句柄（被挂起/恢复的任务）
TaskHandle_t xTestTaskHandle = NULL;
// 控制引脚（通过按键触发恢复，Arduino Uno：3号引脚）
const int KEY_PIN = 3;

// 测试任务（会被挂起和恢复）
void vTestTask(void *pvParameters) {
  for (;;) {
    Serial.println("测试任务运行中...");
    vTaskDelay(1000 / portTICK_PERIOD_MS); // 每1秒打印一次

    // 运行5次后，主动挂起自己
    static int runCount = 0;
    runCount++;
    if (runCount == 5) {
      Serial.println("测试任务主动挂起");
      vTaskSuspend(NULL); // NULL=挂起当前任务
      runCount = 0; // 恢复后重置计数
    }
  }
}

// 按键中断服务函数（触发任务恢复）
void IRAM_ATTR vKeyInterruptHandler() {
  // 从中断中恢复任务（使用中断安全API）
  BaseType_t xHigherPriorityTaskWoken = pdFALSE;
  xTaskResumeFromISR(xTestTaskHandle);
  portYIELD_FROM_ISR(xHigherPriorityTaskWoken);
}

void setup() {
  Serial.begin(115200);
  while (!Serial);

  // 配置按键引脚（下拉输入，上升沿触发中断）
  pinMode(KEY_PIN, INPUT_PULLDOWN);
  attachInterrupt(digitalPinToInterrupt(KEY_PIN), vKeyInterruptHandler, RISING);

  // 创建测试任务
  xTaskCreate(
    vTestTask,
    "TestTask",
    1024,
    NULL,
    tskIDLE_PRIORITY + 1,
    &xTestTaskHandle
  );

  vTaskStartScheduler();
}

void loop() {}

关键说明

嵌套挂起 / 恢复：若任务被多次挂起（如vTaskSuspend(xTestTaskHandle)调用 2 次），需调用 2 次vTaskResume()才能恢复。
挂起当前任务：vTaskSuspend(NULL)等价于vTaskSuspend(xTaskGetCurrentTaskHandle())。

4. 应用场景

临时暂停非紧急任务：如系统进入低功耗模式前，挂起非必要的传感器采集任务。
故障恢复：任务执行异常时，挂起该任务进行故障处理，处理完成后恢复任务运行。
中断驱动的任务唤醒：中断检测到特定事件后（如按键按下），通过xTaskResumeFromISR()恢复对应的处理任务。

五、FreeRTOS 的任务优先级继承

优先级继承（Priority Inheritance）是 FreeRTOS 解决 “优先级反转” 问题的关键机制。优先级反转是指低优先级任务持有高优先级任务所需的资源（如互斥锁），导致高优先级任务被阻塞，而中优先级任务抢占低优先级任务运行，使得高优先级任务的响应延迟。

1. 优先级继承的核心原理

当高优先级任务因等待低优先级任务持有的互斥锁（Mutex）而阻塞时，FreeRTOS 会临时将低优先级任务的优先级提升至与高优先级任务相同的级别，直到低优先级任务释放互斥锁，再将其优先级恢复为原始值。

2. 实现流程

任务 A（高优先级）、任务 B（中优先级）、任务 C（低优先级）同时运行，任务 C 持有互斥锁 M。
任务 A 需要获取互斥锁 M，但此时 M 被任务 C 持有，任务 A 进入阻塞状态。
内核检测到优先级反转场景，将任务 C 的优先级提升至任务 A 的优先级。
任务 C 执行完成后释放互斥锁 M，内核将任务 C 的优先级恢复为原始低优先级。
任务 A 获取互斥锁 M，从阻塞状态转为就绪状态，因优先级最高而立即运行。

优先级继承代码示例（解决优先级反转）

#include <Arduino.h>
#include <freertos/FreeRTOS.h>
#include <freertos/task.h>

// 互斥锁句柄（用于保护共享资源）
SemaphoreHandle_t xMutex;

// 任务优先级定义（高>中>低）
#define HIGH_PRIORITY  (tskIDLE_PRIORITY + 3)
#define MID_PRIORITY   (tskIDLE_PRIORITY + 2)
#define LOW_PRIORITY   (tskIDLE_PRIORITY + 1)

// 共享资源（被三个任务访问）
int sharedResource = 0;

// 高优先级任务
void vHighPriorityTask(void *pvParameters) {
  for (;;) {
    Serial.println("高优先级任务：尝试获取互斥锁");
    if (xSemaphoreTake(xMutex, portMAX_DELAY) == pdPASS) {
      // 获取互斥锁成功，访问共享资源
      Serial.print("高优先级任务：访问共享资源，当前值=");
      Serial.println(sharedResource);
      sharedResource = 0; // 重置共享资源
      xSemaphoreGive(xMutex); // 释放互斥锁
      Serial.println("高优先级任务：释放互斥锁");
    }
    vTaskDelay(1000 / portTICK_PERIOD_MS);
  }
}

// 中优先级任务（仅占用CPU，无资源竞争）
void vMidPriorityTask(void *pvParameters) {
  for (;;) {
    Serial.println("中优先级任务：运行中（无资源竞争）");
    vTaskDelay(500 / portTICK_PERIOD_MS); // 频繁运行
  }
}

// 低优先级任务（持有互斥锁，可能导致优先级反转）
void vLowPriorityTask(void *pvParameters) {
  for (;;) {
    if (xSemaphoreTake(xMutex, portMAX_DELAY) == pdPASS) {
      Serial.println("低优先级任务：获取互斥锁，开始处理");
      // 模拟处理耗时（1.5秒）
      vTaskDelay(1500 / portTICK_PERIOD_MS);
      sharedResource++; // 修改共享资源
      Serial.println("低优先级任务：释放互斥锁");
      xSemaphoreGive(xMutex);
    }
    vTaskDelay(2000 / portTICK_PERIOD_MS);
  }
}

void setup() {
  Serial.begin(115200);
  while (!Serial);

  // 创建互斥锁（优先级继承依赖互斥锁）
  xMutex = xSemaphoreCreateMutex();

  // 创建三个任务
  xTaskCreate(vHighPriorityTask, "HighTask", 1024, NULL, HIGH_PRIORITY, NULL);
  xTaskCreate(vMidPriorityTask, "MidTask", 1024, NULL, MID_PRIORITY, NULL);
  xTaskCreate(vLowPriorityTask, "LowTask", 1024, NULL, LOW_PRIORITY, NULL);

  vTaskStartScheduler();
}

void loop() {}

关键说明

互斥锁与信号量区别：互斥锁支持优先级继承，信号量（xSemaphoreCreateCounting()）不支持，需根据场景选择。
优先级继承效果：低优先级任务持有互斥锁时，若高优先级任务请求该锁，低优先级任务会被临时提升至高优先级，避免中优先级任务抢占 CPU 导致的优先级反转。
死锁避免：多个任务获取多个互斥锁时，需确保所有任务获取顺序一致（如先锁 A 后锁 B）。

3. 关键注意事项

仅支持互斥锁：优先级继承机制仅适用于 FreeRTOS 的互斥锁（Mutex），不支持信号量（Semaphore），因为信号量通常用于同步或资源计数，无 “独占持有” 的特性。
避免嵌套死锁：若多个任务嵌套持有多个互斥锁，需确保所有任务获取互斥锁的顺序一致，否则可能导致死锁，优先级继承无法解决死锁问题。
配置依赖：需在FreeRTOSConfig.h中启用configUSE_MUTEXES（设为 1），才能使用互斥锁和优先级继承功能。

六、FreeRTOS 的 tickless 模式

tickless 模式（也称为低功耗模式）是 FreeRTOS 为降低系统功耗设计的核心特性，通过暂停系统 Tick 定时器、延长 CPU 休眠时间，减少不必要的时钟中断，适用于电池供电等对功耗敏感的嵌入式设备。

1. 传统 Tick 模式的功耗问题

传统模式下，系统 Tick 定时器会按照configTICK_RATE_HZ的周期（如 1ms）持续产生中断，唤醒 CPU 执行 Tick 处理函数（更新系统时间、检查定时器等）。即使所有任务都处于阻塞状态，CPU 也会被频繁唤醒，导致不必要的功耗消耗。

2. tickless 模式的工作原理

当所有任务都处于阻塞状态时，内核会计算当前所有阻塞任务的最短阻塞时间（或软件定时器的最短超时时间），记为xIdleTime。
内核暂停 Tick 定时器，将 CPU 配置为低功耗休眠模式，休眠时间为xIdleTime（无需在每个 Tick 周期唤醒）。
休眠期间，若有外部事件触发（如中断、任务唤醒条件满足），CPU 会被唤醒，内核恢复 Tick 定时器，更新系统时间（补偿休眠期间的 Tick 数），并切换到就绪状态的任务运行。
若休眠时间未结束但有事件触发，内核会计算剩余休眠时间，更新系统时间后立即响应事件。

修改 FreeRTOSConfig.h 配置

#define configUSE_TICKLESS_IDLE 1 // 启用tickless模式
#define configEXPECTED_IDLE_TIME_BEFORE_SLEEP 2 // 空闲时间≥2个Tick时进入休眠

3. 关键配置与注意事项

启用配置：需在FreeRTOSConfig.h中设置configUSE_TICKLESS_IDLE为 1（设为 2 时支持更深层次的低功耗，需手动实现休眠和唤醒逻辑）。
硬件依赖：需实现vPortSuppressTicksAndSleep()函数（FreeRTOS 提供模板），适配具体硬件的低功耗模式配置（如 ARM Cortex-M 的 WFI/WFE 指令）和 Tick 定时器的暂停 / 恢复逻辑。
定时精度：休眠时间由硬件定时器或 RTC（实时时钟）控制，需确保硬件支持足够的定时精度，避免系统时间偏差过大。

七、FreeRTOS 的流缓冲区

流缓冲区（Stream Buffer）是 FreeRTOS 提供的用于 “流式数据传输” 的内核对象，专为连续字节流（如 UART 数据、传感器数据流）设计，相比队列（Queue）更适合处理不定长、高吞吐量的数据流。

1. 流缓冲区的定义与核心特性

本质：一块连续的内存区域，采用 “环形缓冲区” 结构，支持数据的写入（发送）和读取（接收），无需固定数据块大小（队列需提前定义数据项大小）。
核心特性：
- 支持不定长数据：写入时可指定数据长度，读取时可指定读取长度（或读取所有可用数据）。
- 阻塞 / 非阻塞操作：写入时若缓冲区满，可阻塞等待空闲空间；读取时若缓冲区空，可阻塞等待数据。
- 中断安全：提供xStreamBufferSendFromISR()、xStreamBufferReceiveFromISR()等中断安全 API，支持中断与任务间的数据流传输。

2. 工作原理

创建流缓冲区：通过xStreamBufferCreate(size_t xBufferSizeBytes, size_t xTriggerLevelBytes)创建，参数分别为缓冲区总字节数、触发读取的最小字节数（读取时需满足该字节数才返回，避免读取不完整数据）。
写入数据：调用xStreamBufferSend()，内核将数据从写入指针位置连续存储，写入指针循环移动（超过缓冲区末尾则回到起始位置）；若缓冲区剩余空间不足，可阻塞等待（超时时间由参数指定）。
读取数据：调用xStreamBufferReceive()，内核从读取指针位置连续读取数据，读取指针循环移动；若缓冲区数据量未达到触发级别，可阻塞等待（超时时间由参数指定）。
缓冲区状态管理：内核通过写入指针、读取指针和数据长度计数器，实时跟踪缓冲区的空闲空间和已用空间，避免数据覆盖。

流缓冲区代码示例（UART 数据传输）

#include <Arduino.h>
#include <freertos/FreeRTOS.h>
#include <freertos/task.h>
#include <freertos/stream_buffer.h>

// 流缓冲区句柄
StreamBufferHandle_t xUARTStreamBuffer;
// 流缓冲区配置（总大小1024字节，触发读取的最小字节数10字节）
#define BUFFER_SIZE 1024
#define TRIGGER_LEVEL 10

// UART接收中断服务函数（ESP32示例）
void IRAM_ATTR onSerialReceive() {
  while (Serial.available() > 0) {
    uint8_t data = Serial.read();
    // 写入流缓冲区（中断安全API）
    BaseType_t xHigherPriorityTaskWoken = pdFALSE;
    xStreamBufferSendFromISR(
      xUARTStreamBuffer,
      &data,
      sizeof(data),
      &xHigherPriorityTaskWoken
    );
    portYIELD_FROM_ISR(xHigherPriorityTaskWoken);
  }
}

// 流缓冲区读取任务
void vStreamBufferReadTask(void *pvParameters) {
  uint8_t rxBuffer[64]; // 接收缓冲区
  for (;;) {
    // 读取流缓冲区（阻塞等待，直到数据≥TRIGGER_LEVEL字节）
    size_t bytesRead = xStreamBufferReceive(
      xUARTStreamBuffer,
      rxBuffer,
      sizeof(rxBuffer),
      portMAX_DELAY
    );
    if (bytesRead > 0) {
      Serial.print("流缓冲区读取到字节数：");
      Serial.println(bytesRead);
      Serial.print("数据：");
      for (size_t i = 0; i < bytesRead; i++) {
        Serial.print((char)rxBuffer[i]);
      }
      Serial.println();
    }
  }
}

void setup() {
  Serial.begin(115200);
  while (!Serial);

  // 创建流缓冲区
  xUARTStreamBuffer = xStreamBufferCreate(BUFFER_SIZE, TRIGGER_LEVEL);

  // 启用UART接收中断（ESP32平台）
  Serial.onReceive(onSerialReceive);

  // 创建读取任务
  xTaskCreate(
    vStreamBufferReadTask,
    "StreamReadTask",
    1024,
    NULL,
    tskIDLE_PRIORITY + 2,
    NULL
  );

  vTaskStartScheduler();
}

void loop() {}