ESP32 FreeRTOS (day1)入门教程 (ESP-IDF版):从超级循环到多任务的系统化思维

当您开始使用ESP-IDF（Espressif IoT Development Framework）进行ESP32开发时，您就正式进入了一个更为底层和强大的嵌入式世界。ESP-IDF从根本上就是构建在FreeRTOS之上的。这意味着，您编写的每一个ESP-IDF应用程序，本质上都是一个FreeRTOS程序。理解FreeRTOS不再是可选项，而是掌握ESP32开发的必经之路。

许多刚接触嵌入式开发的程序员会习惯于一种被称为"超级循环"的编程模型。在ESP-IDF中，这种模型通常体现在app_main函数里：

复制代码

// main.c
#include <stdio.h>
#include "freertos/FreeRTOS.h"
#include "freertos/task.h"
#include "esp_log.h"

static const char *TAG = "MyApp";

void app_main(void)
{
    esp_log_level_set(TAG, ESP_LOG_INFO);
    ESP_LOGI(TAG, "Application started.");

    // 典型的超级循环结构
    while (1) {
        // 任务1: 读取传感器
        ESP_LOGI(TAG, "Reading sensor...");
        // ... 耗时的读取代码 ...

        // 任务2: 检测按钮
        ESP_LOGI(TAG, "Checking button...");
        // ... 检测代码 ...

        // 任务3: 维持网络
        ESP_LOGI(TAG, "Maintaining network...");
        // ... 网络代码 ...

        // 一个笨拙的延时，试图控制循环速率
        vTaskDelay(pdMS_TO_TICKS(1000));
    }
}

这种在app_main中使用while(1)循环的模式，虽然在功能上可以工作，但当系统需求变得复杂时，它会暴露出几个致命的缺陷：

时序耦合与阻塞：循环内的所有操作是串行执行的。如果"读取传感器"这一步因为通信不稳定而耗时过长，后续的"检测按钮"和"维持网络"就会被严重延迟。任何一个环节的阻塞都会导致整个系统的响应性急剧下降。
资源利用率低下 ：在vTaskDelay期间，CPU虽然没有执行应用代码，但它也只是在运行一个空闲任务。更重要的是，如果某个步骤（比如网络重连）需要等待一个不确定的时长，整个循环就会停滞，无法处理任何其他事务。
代码扩展性与维护性差 ：随着项目功能增加，这个while(1)循环会迅速膨胀成一个臃肿、难以理解和维护的"上帝函数"，所有逻辑纠缠在一起，修改一处可能引发多处故障。

FreeRTOS提供了一种系统化的解决方案：多任务 。它允许我们将复杂的应用逻辑分解成多个独立的、并发执行的"任务"。在ESP-IDF中，app_main本身就是一个任务（由系统在启动时创建）。我们的目标是学会如何在这个初始任务的基础上，创建更多具有不同职责的任务，让它们协同工作，从而构建一个响应迅速、结构清晰、可扩展性强的应用程序。

本教程将引导您在ESP-IDF环境中，从零开始掌握FreeRTOS的核心编程范式。

第一部分：核心概念------任务、调度器与状态

在编写代码之前，必须深刻理解FreeRTOS的几个基本概念。

1.1 任务

在FreeRTOS中，任务是系统调度的基本单位。每个任务都是一个独立的执行流，拥有自己的：

程序计数器：记录当前执行到代码的哪一行。
栈空间：用于存储局部变量、函数调用参数和返回地址。
任务控制块：一个数据结构，存储了任务的所有信息，如状态、优先级、栈指针等。

任务在代码层面体现为一个遵循特定原型的函数：void TaskFunction(void *pvParameters)。这个函数通常包含一个无限循环（for(;;)或while(1)），因为一个长期存在的任务在被创建后，我们不期望它执行完毕就退出。

1.2 任务状态

一个任务在任何时刻都必然处于以下四种状态之一：

运行态：当前正获得CPU使用权，正在执行其代码。在单核处理器上，任何时刻只有一个任务处于运行态。ESP32是双核处理器，因此可以同时有两个任务处于运行态（每个核心一个）。
就绪态：任务已经准备好运行，所有运行条件均已满足，只是因为有一个或多个比它优先级更高的任务正在运行，所以它只能在"就绪列表"中排队等待。
阻塞态 ：任务因为等待某个事件而主动放弃运行。常见的事件包括：调用vTaskDelay()等待超时、等待队列中的数据、等待信号量等。一旦等待的事件发生，任务就会从阻塞态转移到就绪态。这是实现非阻塞并发编程的关键。
挂起态 ：与阻塞态类似，任务也处于非运行状态。但挂起态的任务无法通过等待的事件来自动唤醒，必须由其他代码显式调用vTaskResume()等API才能恢复。

1.3 调度器

调度器是FreeRTOS的内核，其职责是根据预设的算法，决定在某一刻应该运行哪个任务。ESP-IDF中的FreeRTOS主要采用抢占式调度与基于优先级的调度策略。

优先级 ：创建任务时必须为其指定一个优先级。优先级是一个从0到configMAX_PRIORITIES-1的整数。在ESP-IDF中，configMAX_PRIORITIES默认为25，数值越大，优先级越高。
抢占：当一个更高优先级的任务从阻塞态或挂起态变为就绪态时，调度器会立即中断当前正在运行的较低优先级的任务，将CPU使用权交给高优先级任务。这确保了关键任务总能得到最及时的响应。

比喻理解：将调度器比作一个公司的CEO

任务：公司的各个部门（销售、研发、生产）。
优先级：任务的紧急和重要程度。一个关乎公司生存的大客户订单（高优先级任务）显然比常规的行政工作（低优先级任务）重要。
CEO（调度器） ：CEO会时刻关注所有部门的状态。当研发部门（低优先级任务）正在按计划工作时，如果销售部门（高优先级任务）拿来了紧急订单，CEO会立即让研发部门暂停，调配所有资源先支持销售部门完成这个订单。这就是抢占。紧急订单处理完毕后，研发部门再从中断的地方继续工作。

第二部分：搭建ESP-IDF环境与创建项目

在编写代码之前，请确保您已经正确安装并配置了ESP-IDF开发环境。如果尚未完成，请参考Espressif官方文档进行操作。安装完成后，您需要打开终端，并执行ESP-IDF目录下的export.sh（或export.ps1）脚本来设置环境变量。

接下来，我们创建一个新的项目：

复制代码

# 导出ESP-IDF环境变量
# 例如在Linux或macOS上:
# source /path/to/esp-idf/export.sh

# 创建一个名为 "freertos_tutorial" 的新项目
idf.py create-project freertos_tutorial

# 进入项目目录
cd freertos_tutorial

创建完成后，您会看到如下的项目结构：

复制代码

freertos_tutorial/
├── CMakeLists.txt
├── main/
│   ├── CMakeLists.txt
│   └── main.c
└── README.md

我们的所有代码都将编写在main/main.c文件中。项目根目录下的CMakeLists.txt是整个项目的构建设置，而main/CMakeLists.txt则指定了main目录下的源文件。

第三部分：编写第一个多任务程序

我们将编写一个程序，创建两个任务，它们以不同的间隔在串口上打印信息。

3.1 修改 main.c 文件

打开main/main.c文件，用以下代码替换其全部内容。

复制代码

#include <stdio.h>
#include "freertos/FreeRTOS.h"
#include "freertos/task.h"
#include "esp_log.h"

// 定义一个日志标签，方便在串口监视器中过滤信息
static const char *TAG = "FREERTOS_DEMO";

// 任务1：每隔1000ms打印一次
void vTask1(void *pvParameters)
{
    // 任务函数通常是一个无限循环
    for (;;)
    {
        ESP_LOGI(TAG, "Task 1: Running... (1 second interval)");
        // 关键API：vTaskDelay()，让任务进入阻塞状态
        // 参数是延迟的"心跳"数。pdMS_TO_TICKS(1000)将1000毫秒转换为对应的心跳数
        vTaskDelay(pdMS_TO_TICKS(1000));
    }
}

// 任务2：每隔500ms打印一次
void vTask2(void *pvParameters)
{
    for (;;)
    {
        ESP_LOGI(TAG, "  Task 2: Running... (0.5 second interval)");
        vTaskDelay(pdMS_TO_TICKS(500));
    }
}

// ESP-IDF应用程序入口点
void app_main(void)
{
    ESP_LOGI(TAG, "ESP-IDF FreeRTOS Multi-Task Example Starting...");

    // xTaskCreate API 详解
    // BaseType_t xTaskCreate( TaskFunction_t pvTaskCode,
    //                         const char * const pcName,
    //                         const uint32_t usStackDepth,
    //                         void *pvParameters,
    //                         UBaseType_t uxPriority,
    //                         TaskHandle_t *pxCreatedTask );

    // 创建任务1
    xTaskCreate(
        vTask1,         // 任务函数的指针
        "Task_1",       // 任务名称（用于调试，最大长度由configMAX_TASK_NAME_LEN定义）
        4096,           // 任务堆栈大小，单位是字（word，在32位的ESP32上是4字节）。4096即16KB。
                        // 堆栈用于存储任务的局部变量、函数调用信息等，太小会导致堆栈溢出。
        NULL,           // 传递给任务的参数，我们不需要，所以为NULL
        1,              // 任务优先级，1是较低优先级
        NULL            // 任务句柄的指针。创建成功后，句柄会存储在这里。如果暂时不需要操作此任务，可设为NULL。
    );

    // 创建任务2
    xTaskCreate(
        vTask2,         // 任务函数的指针
        "Task_2",       // 任务名称
        4096,           // 任务堆栈大小
        NULL,           // 传递给任务的参数
        2,              // 任务优先级，2比1高，因此Task2将优先于Task1运行
        NULL            // 任务句柄的指针
    );

    // 在ESP-IDF中，app_main函数本身运行在一个名为"main"的任务中。
    // 当app_main函数返回后，这个任务会被自动删除。
    // 我们创建的任务会继续在后台运行。
    ESP_LOGI(TAG, "All tasks created. app_main function will now exit.");
}

关键点解析：

头文件 ：freertos/FreeRTOS.h和freertos/task.h是使用任务相关API的必备头文件。esp_log.h是ESP-IDF提供的日志系统，比printf更强大、更灵活。
ESP_LOGI(TAG, ...) ：这是ESP-IDF的日志打印函数。I代表Info（信息）级别。使用统一的TAG可以方便地在监视器中过滤出本程序的输出。
vTaskDelay(pdMS_TO_TICKS(time_ms)) ：这是FreeRTOS中实现任务非阻塞延时的核心API。vTaskDelay会使调用它的任务进入阻塞态，直到指定的心跳数过去。pdMS_TO_TICKS()宏将毫秒转换为心跳数，使代码更具可读性和可移植性。这与裸机开发中忙等待式的延时函数有本质区别。
xTaskCreate() API详解：
- pvTaskCode：指向任务函数的指针，例如vTask1。
- pcName：一个描述性的字符串，用于标识该任务。这个名称仅用于调试目的。
- usStackDepth：至关重要的参数。它定义了任务堆栈的大小，单位是字（4字节）。堆栈是任务的私有内存。如果分配过小，当任务中有深层函数调用或大的局部变量时，会发生堆栈溢出，导致系统崩溃。对于包含日志打印的简单任务，4096（16KB）是一个安全的起点。
- pvParameters：指向要传递给任务的数据的指针。任务函数内部通过pvParameters接收。本例中没有使用，故为NULL。
- uxPriority：任务的优先级。我们给vTask2设置了更高的优先级（2 > 1）。
- pxCreatedTask：一个指向TaskHandle_t变量的指针。如果函数成功，创建任务的句柄将被写入该变量。句柄是后续引用、删除或挂起任务的唯一标识。如果暂时用不到，可以传NULL。
app_main的角色 ：app_main是一个特殊的函数，它在系统启动时被自动调用，并且在一个名为"main"的任务上下文中运行。当app_main函数执行完毕返回后，系统会自动清理并删除这个"main"任务。而我们在app_main中创建的其他任务，由于它们是无限循环，将继续独立地运行下去。

第四部分：编译、上传与监控

现在，我们可以将代码编译并烧录到ESP32上了。在您的终端中（确保已经执行了export.sh），执行以下命令：

复制代码

# 配置项目（可选，但首次推荐执行）
# idf.py menuconfig

# 编译项目
idf.py build

# 将固件烧录到ESP32（将 /dev/ttyUSB0 替换为你的串口号）
idf.py -p /dev/ttyUSB0 flash

# 启动监视器查看串口输出
idf.py -p /dev/ttyUSB0 monitor

您也可以将最后两个步骤合并：

复制代码

idf.py -p /dev/ttyUSB0 flash monitor

第五部分：结果分析

成功烧录后，您的串口监视器应该会显示类似以下的输出：

复制代码

I (299) FREERTOS_DEMO: ESP-IDF FreeRTOS Multi-Task Example Starting...
I (299) FREERTOS_DEMO: All tasks created. app_main function will now exit.
I (299) FREERTOS_DEMO:   Task 2: Running... (0.5 second interval)
I (799) FREERTOS_DEMO: Task 1: Running... (1 second interval)
I (799) FREERTOS_DEMO:   Task 2: Running... (0.5 second interval)
I (1299) FREERTOS_DEMO:   Task 2: Running... (0.5 second interval)
I (1799) FREERTOS_DEMO: Task 1: Running... (1 second interval)
I (1799) FREERTOS_DEMO:   Task 2: Running... (0.5 second interval)
...

让我们详细分析一下执行流程，这能加深您对调度器工作原理的理解：

系统启动 ：系统启动后，app_main任务开始运行，打印出前两条信息。
任务创建 ：app_main调用两次xTaskCreate，创建了Task 1（优先级1）和Task 2（优先级2）。此时，这两个任务都处于就绪态。
app_main退出 ：app_main函数返回，"main"任务被删除。
调度器决策：现在系统中只剩下Task 1和Task 2。调度器查看就绪列表，发现Task 2的优先级更高，于是将CPU交给Task 2运行。
Task 2 第一次运行 ：Task 2打印信息，然后调用vTaskDelay(500)。Task 2进入阻塞态，并设置一个500毫秒后唤醒的定时器。
调度器再次决策：Task 2阻塞了，调度器查看就绪列表，发现Task 1是唯一就绪的任务。于是将CPU交给Task 1运行。
Task 1 第一次运行 ：Task 1打印信息，然后调用vTaskDelay(1000)。Task 1也进入阻塞态，并设置一个1000毫秒后唤醒的定时器。
系统空闲：此时，两个任务都处于阻塞态。调度器将运行一个优先级最低的Idle Task（空闲任务），让CPU进入低功耗状态。
时间流逝至500ms：Task 2的延时结束，从阻塞态转为就绪态。调度器立即抢占Idle Task，运行Task 2。Task 2再次打印，再次延时500ms。
时间流逝至1000ms ：在Task 2第二次运行后（即从app_main退出后的1000ms刻度），Task 1的延时也结束了，它变为就绪态。但此时Task 2也正处于就绪态（它刚完成运行）。由于Task 2优先级更高，调度器会继续选择运行Task 2。
后续：Task 2运行后再次进入500ms延时。此时系统中只有Task 1处于就绪态，于是Task 1得到运行机会。

这就是为什么您会看到Task 2有时会连续出现的原因：因为它在Task 1准备就绪的同一时刻也准备就绪了，而它更高的优先级确保了它总能被优先调度。

第六部分：进阶探讨------任务删除与参数传递

为了使您对FreeRTOS有更深的理解，我们来探讨两个非常有用的进阶技巧：删除任务和向任务传递参数。

6.1 任务的删除

并非所有任务都需要无限期运行。有些任务可能只需要执行一次性的工作。完成任务后，应该将其删除以释放它占用的内存和CPU资源。用于删除任务的API是vTaskDelete()。

让我们添加一个自我删除的任务。

在main.c中添加以下任务函数：

复制代码

void vSelfDeletingTask(void *pvParameters)
{
    // 执行一些一次性的工作
    ESP_LOGI(TAG, "Self-deleting task: I have done my job and will now delete myself.");
    
    // 删除自身
    // 传递NULL表示删除当前正在运行的任务
    vTaskDelete(NULL);
}

然后，在app_main函数中创建这个任务：

复制代码

void app_main(void)
{
    // ... 之前的代码 ...

    // 创建一个自我删除的任务
    xTaskCreate(
        vSelfDeletingTask,
        "SelfDelTask",
        2048,  // 这种任务堆栈可以小一些
        NULL,
        3,     // 给它一个更高的优先级，确保它能尽快执行
        NULL
    );
    
    // ... 之前的代码 ...
}

重新编译和上传。您会发现，"Self-deleting task"这条信息只会在程序启动时打印一次，之后再也不会出现。该任务执行完vTaskDelete(NULL)后，其占用的TCB和堆栈内存都会被系统回收。

6.2 向任务传递参数

回想xTaskCreate的第四个参数pvParameters。它允许我们创建通用的、可重用的任务函数。通过传递不同的参数，可以让同一个任务函数表现出不同的行为。

最佳实践是定义一个结构体来封装所有需要传递的参数。

1. 定义参数结构体：在`main.c`的开头添加：

复制代码

// 定义一个结构体来传递给任务
typedef struct {
    char task_name[20];
    uint32_t interval_ms;
} task_parameters_t;

2. 创建通用任务函数：创建一个新的任务函数，它使用传入的参数来定制自己的行为。

复制代码

// 通用的打印任务，其行为由传入的参数决定
void vGenericPrintTask(void *pvParameters)
{
    // 将传入的void*指针转换回我们的结构体指针
    task_parameters_t *params = (task_parameters_t *)pvParameters;
    
    // 使用参数中的信息
    for (;;)
    {
        ESP_LOGI(params->task_name, "Running with %lu ms interval.", params->interval_ms);
        vTaskDelay(pdMS_TO_TICKS(params->interval_ms));
    }
}

3. 在`app_main`中准备参数并创建任务：

复制代码

void app_main(void)
{
    ESP_LOGI(TAG, "ESP-IDF FreeRTOS Multi-Task Example Starting...");

    // 准备两个不同的参数集
    static task_parameters_t task1_params = {
        .task_name = "PrintTask_A",
        .interval_ms = 2000 // 2秒
    };

    static task_parameters_t task2_params = {
        .task_name = "PrintTask_B",
        .interval_ms = 700  // 0.7秒
    };

    // 使用相同的任务函数，但传递不同的参数，创建两个不同的任务
    xTaskCreate(
        vGenericPrintTask,          // 任务函数
        "Generic_Print_A",          // 调试名称
        4096,
        &task1_params,              // 传递指向第一个参数集的指针
        1,
        NULL
    );

    xTaskCreate(
        vGenericPrintTask,
        "Generic_Print_B",
        4096,
        &task2_params,              // 传递指向第二个参数集的指针
        1,
        NULL
    );
    
    ESP_LOGI(TAG, "All tasks created. app_main function will now exit.");
}

重要提示：

为什么task1_params和task2_params要声明为static？因为app_main函数退出后，它自己的栈空间会被释放。如果我们将参数定义为app_main内的局部变量，那么在app_main返回后，这些变量的内存将变为无效。新创建的任务在访问这些参数时，就会导致未定义行为（通常是崩溃）。将它们声明为static，可以使它们存储在程序的静态数据区，生命周期与整个应用程序一样长，从而确保了任务总能安全地访问到这些参数。

通过以上两个进阶技巧，您已经掌握了FreeRTOS任务管理的核心API，并学会了如何编写结构化、可重用的多任务代码。这是从入门到熟练的重要一步。接下来，您可以继续探索FreeRTOS的其他关键机制，如队列、信号量、互斥锁等，它们将帮助您解决任务间的通信与同步问题。