ESP32S3+VSCode+PlatformIO+FreeRTOS+Arduino多核编程实战：FreeRTOS任务创建+任务调度详解

ESP32S3+VSCode+PlatformIO+FreeRTOS+Arduino多核编程实战：FreeRTOS任务调度详解

前言

ESP32作为一款功能强大的双核处理器，如何充分利用其多核特性一直是开发者关注的焦点。本文将详细介绍如何在ESP32上使用FreeRTOS进行多任务编程，通过实例代码讲解任务创建、调度和核心分配，帮助大家快速掌握ESP32多核编程技巧。无论你是嵌入式开发新手还是有经验的开发者，都能从中获得实用的知识和技巧。

一、FreeRTOS简介

1.1 什么是FreeRTOS？

FreeRTOS是一个小型、开源的实时操作系统，专为嵌入式设备设计。它提供了任务管理、时间管理、信号量、消息队列等功能，能够帮助开发者更好地组织代码，提高系统响应速度和稳定性。

1.2 为什么在ESP32上使用FreeRTOS？

ESP32是一款双核处理器，拥有两个独立的Xtensa LX6 CPU核心。使用FreeRTOS可以：

• 充分利用双核性能，提高系统处理能力
• 简化多任务编程，使代码更加模块化
• 提供可预测的实时响应
• 更好地管理系统资源

二、代码结构解析

我们将通过一个实际的例子来讲解ESP32上的FreeRTOS多任务编程。首先看一下项目的文件结构：

2.1 头文件 (my_freertos.h)

#ifndef _MY_FREERTOS_H
#define _MY_FREERTOS_H

// 任务初始化函数
void freertos_init(void);

// 任务优先级定义
#define TASK_PRIORITY_LOW    1    // 低优先级，用于不紧急的后台任务
#define TASK_PRIORITY_MEDIUM 2    // 中优先级，用于一般的周期性任务
#define TASK_PRIORITY_HIGH   3    // 高优先级，用于需要快速响应的任务

// 任务栈大小定义 (单位：字)
#define TASK_STACK_SIZE_SMALL  (2*1024)    // 小栈空间，适用于简单任务
#define TASK_STACK_SIZE_MEDIUM (4*1024)    // 中等栈空间，适用于一般任务
#define TASK_STACK_SIZE_LARGE  (6*1024)    // 大栈空间，适用于复杂任务

#endif // _MY_FREERTOS_H 

头文件中定义了任务优先级和栈大小的常量，这些常量使代码更加清晰易读。同时声明了freertos_init()函数，用于初始化和创建FreeRTOS任务。

2.2 源文件 (my_freertos.cpp)

#include "my_freertos.h"
#include "freertos/FreeRTOS.h"    // FreeRTOS核心头文件
#include "freertos/task.h"        // FreeRTOS任务管理头文件
#include <Arduino.h>              // Arduino核心库

// 全局变量定义
int task1_status = 0;    // 任务1状态变量，用于任务间通信
int task2_status = 0;    // 任务2状态变量，用于任务间通信

// 任务1函数
void task1_function(void *param)
{
    // 任务初始化
    int counter = 0;    // 局部计数器变量
    
    // 任务主循环
    while (1)    // 无限循环，确保任务持续运行
    {
        // 任务处理逻辑
        counter++;    // 计数器递增
        task1_status = counter % 5;    // 更新任务状态，取余操作产生循环变化的状态值
        
        // 打印调试信息
        Serial.print("任务1运行中，计数: ");
        Serial.println(counter);
        
        // 延时，让出CPU
        vTaskDelay(500 / portTICK_PERIOD_MS);    // 500毫秒延迟，防止任务独占CPU
    }
}

// 任务2函数
void task2_function(void *param)
{
    while (1)    // 无限循环，确保任务持续运行
    {
        // 根据任务1状态执行不同操作
        if (task1_status > 2)    // 当任务1状态值大于2时
        {
            task2_status = 1;    // 激活任务2
            Serial.println("任务2：状态已激活");
        }
        else
        {
            task2_status = 0;    // 未激活任务2
            Serial.println("任务2：状态未激活");
        }
        
        // 延时
        vTaskDelay(1000 / portTICK_PERIOD_MS);    // 1秒延迟，控制任务执行频率
    }
}

// 初始化函数，创建任务
void freertos_init(void)
{
    // 创建任务1，运行在核心0上
    xTaskCreatePinnedToCore(
        task1_function,        // 任务函数指针
        "task1",               // 任务名称，便于调试
        TASK_STACK_SIZE_SMALL, // 任务栈大小
        NULL,                  // 任务参数，此处不需要传参
        TASK_PRIORITY_MEDIUM,  // 任务优先级
        NULL,                  // 任务句柄，不需要时可设为NULL
        0                      // 指定运行的核心，0表示在核心0上运行
    );
    
    // 创建任务2，运行在核心1上
    xTaskCreatePinnedToCore(
        task2_function,        // 任务函数指针
        "task2",               // 任务名称，便于调试
        TASK_STACK_SIZE_SMALL, // 任务栈大小
        NULL,                  // 任务参数，此处不需要传参
        TASK_PRIORITY_LOW,     // 任务优先级
        NULL,                  // 任务句柄，不需要时可设为NULL
        1                      // 指定运行的核心，1表示在核心1上运行
    );
} 

三、代码详解

3.1 全局变量与任务间通信

int task1_status = 0;
int task2_status = 0;

这两个全局变量用于任务间通信。在多任务编程中，不同任务可能需要共享数据或状态。这里task1_status由任务1更新，任务2通过读取这个变量来决定自己的行为。

注意：在实际项目中，对共享变量的访问应考虑使用互斥锁或信号量等同步机制，防止数据竞争。本例为了简单起见未使用同步机制。

3.2 任务函数实现

每个FreeRTOS任务都需要一个任务函数，这个函数通常包含一个无限循环，确保任务持续运行。

任务1函数

void task1_function(void *param)
{
    int counter = 0;
    
    while (1)
    {
        counter++;
        task1_status = counter % 5;
        
        Serial.print("任务1运行中，计数: ");
        Serial.println(counter);
        
        vTaskDelay(500 / portTICK_PERIOD_MS);
    }
}

任务1每500毫秒执行一次，递增计数器并更新状态变量。vTaskDelay函数非常重要，它让任务进入阻塞状态，释放CPU资源给其他任务使用。

任务2函数

void task2_function(void *param)
{
    while (1)
    {
        if (task1_status > 2)
        {
            task2_status = 1;
            Serial.println("任务2：状态已激活");
        }
        else
        {
            task2_status = 0;
            Serial.println("任务2：状态未激活");
        }
        
        vTaskDelay(1000 / portTICK_PERIOD_MS);
    }
}

任务2每1000毫秒执行一次，根据任务1的状态变量做出不同响应。这展示了一个简单的任务间通信机制。

3.3 任务创建与核心分配

void freertos_init(void)
{
    xTaskCreatePinnedToCore(
        task1_function,
        "task1",
        TASK_STACK_SIZE_SMALL,
        NULL,
        TASK_PRIORITY_MEDIUM,
        NULL,
        0
    );
    
    xTaskCreatePinnedToCore(
        task2_function,
        "task2",
        TASK_STACK_SIZE_SMALL,
        NULL,
        TASK_PRIORITY_LOW,
        NULL,
        1
    );
}

freertos_init函数使用xTaskCreatePinnedToCore创建两个任务，并将它们分别分配到ESP32的两个核心上。这是ESP32多核编程的关键部分。

xTaskCreatePinnedToCore函数参数详解：

1. 任务函数指针：指向任务函数的指针
2. 任务名称：字符串，用于调试
3. 栈大小：任务栈空间大小，单位为字
4. 任务参数：传递给任务函数的参数
5. 优先级：任务优先级，数值越大优先级越高
6. 任务句柄：可用于后续控制该任务
7. 核心ID：指定任务运行的核心（0或1）

四、实际应用与扩展

4.1 在Arduino项目中集成FreeRTOS

要在Arduino项目中使用上面的代码，只需在主程序中包含头文件并调用初始化函数：

#include <Arduino.h>
#include "my_freertos.h"

void setup() {
  Serial.begin(115200);  // 初始化串口通信
  Serial.println("ESP32 FreeRTOS多任务示例");
  
  freertos_init();  // 初始化FreeRTOS任务
  
  // 其他初始化代码...
}

void loop() {
  // Arduino loop函数可以留空
  // 或者执行一些低优先级的任务
  delay(1000);
}

4.2 任务优先级与调度

FreeRTOS使用优先级抢占式调度算法。高优先级任务准备好运行时，会抢占低优先级任务。在我们的例子中：

• 任务1的优先级为MEDIUM (2)
• 任务2的优先级为LOW (1)

这意味着当两个任务同时需要运行时，任务1会优先获得CPU资源。但由于它们被分配到不同的核心，所以实际上可以并行执行。

4.3 任务同步与互斥

在更复杂的应用中，多个任务可能需要访问共享资源。FreeRTOS提供了多种同步机制：

互斥量（Mutex）示例

// 定义互斥量
SemaphoreHandle_t xMutex = NULL;

// 在任务中使用互斥量
void task_function(void *param) {
    while(1) {
        // 尝试获取互斥量
        if(xSemaphoreTake(xMutex, portMAX_DELAY) == pdTRUE) {
            // 安全访问共享资源
            
            // 操作完成，释放互斥量
            xSemaphoreGive(xMutex);
        }
        vTaskDelay(10 / portTICK_PERIOD_MS);
    }
}

// 在初始化函数中创建互斥量
void freertos_init(void) {
    // 创建互斥量
    xMutex = xSemaphoreCreateMutex();
    
    // 创建任务...
}

信号量（Semaphore）示例

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

// 任务1：等待信号量
void task1_function(void *param) {
    while(1) {
        // 等待信号量
        if(xSemaphoreTake(xBinarySemaphore, portMAX_DELAY) == pdTRUE) {
            Serial.println("任务1收到信号，开始处理");
        }
        vTaskDelay(10 / portTICK_PERIOD_MS);
    }
}

// 任务2：发送信号量
void task2_function(void *param) {
    while(1) {
        // 发送信号量
        xSemaphoreGive(xBinarySemaphore);
        Serial.println("任务2发送信号");
        vTaskDelay(1000 / portTICK_PERIOD_MS);
    }
}

// 初始化
void freertos_init(void) {
    // 创建二值信号量
    xBinarySemaphore = xSemaphoreCreateBinary();
    
    // 创建任务...
}

4.4 任务通知（Task Notification）

任务通知是FreeRTOS提供的一种轻量级的任务间通信机制，比信号量更高效：

// 定义任务句柄
TaskHandle_t xTask1Handle = NULL;

// 接收通知的任务
void task1_function(void *param) {
    uint32_t ulNotificationValue;
    
    while(1) {
        // 等待通知
        if(xTaskNotifyWait(0, ULONG_MAX, &ulNotificationValue, portMAX_DELAY) == pdTRUE) {
            Serial.print("任务1收到通知，值为: ");
            Serial.println(ulNotificationValue);
        }
    }
}

// 发送通知的任务
void task2_function(void *param) {
    int counter = 0;
    
    while(1) {
        counter++;
        // 发送通知
        xTaskNotify(xTask1Handle, counter, eSetValueWithOverwrite);
        Serial.println("任务2发送通知");
        vTaskDelay(1000 / portTICK_PERIOD_MS);
    }
}

// 初始化
void freertos_init(void) {
    // 创建任务1，保存任务句柄
    xTaskCreatePinnedToCore(
        task1_function,
        "task1",
        TASK_STACK_SIZE_SMALL,
        NULL,
        TASK_PRIORITY_MEDIUM,
        &xTask1Handle,  // 保存任务句柄
        0
    );
    
    // 创建任务2
    xTaskCreatePinnedToCore(
        task2_function,
        "task2",
        TASK_STACK_SIZE_SMALL,
        NULL,
        TASK_PRIORITY_LOW,
        NULL,
        1
    );
}

五、实际操作流程

5.1 环境准备

1. 安装Arduino IDE ：从Arduino官网下载并安装最新版本
2. 安装ESP32开发板 ：
   • 打开Arduino IDE
   • 进入"文件 > 首选项"
   • 在"附加开发板管理器网址"中添加：https://raw.githubusercontent.com/espressif/arduino-esp32/gh-pages/package_esp32_index.json
   • 进入"工具 > 开发板 > 开发板管理器"
   • 搜索"esp32"并安装

5.2 创建项目

1. 打开Arduino IDE，创建新项目
2. 创建两个文件：my_freertos.h和my_freertos.cpp，复制本文提供的代码
3. 创建主程序文件main.ino：

#include <Arduino.h>
#include "my_freertos.h"

void setup() {
  Serial.begin(115200);
  delay(1000);  // 等待串口稳定
  
  Serial.println("ESP32 FreeRTOS多任务示例启动");
  Serial.println("任务1运行在核心0，任务2运行在核心1");
  
  freertos_init();  // 初始化FreeRTOS任务
}

void loop() {
  // Arduino主循环，此处留空
  delay(1000);
}

5.3 编译与上传

1. 选择正确的开发板：工具 > 开发板 > ESP32 Dev Module
2. 选择正确的端口：工具 > 端口 > (选择你的ESP32设备对应的端口)
3. 点击"上传"按钮编译并上传代码到ESP32

5.4 查看结果

1. 打开串口监视器：工具 > 串口监视器
2. 设置波特率为115200
3. 观察输出结果，应该能看到两个任务交替执行的信息

六、常见问题与解决方案

6.1 栈溢出问题

如果任务执行过程中出现异常重启，可能是栈空间不足导致的栈溢出。解决方法：

1. 增加任务栈大小：修改TASK_STACK_SIZE_SMALL的值
2. 优化任务代码，减少局部变量使用
3. 使用FreeRTOS提供的调试功能检测栈使用情况：

// 在任务中周期性检查栈使用情况
UBaseType_t uxHighWaterMark;
uxHighWaterMark = uxTaskGetStackHighWaterMark(NULL);
Serial.print("任务栈剩余: ");
Serial.println(uxHighWaterMark);

6.2 任务优先级设置不当

如果低优先级任务无法获得执行时间，可能是优先级设置不合理：

1. 适当调整任务优先级
2. 在高优先级任务中添加适当的延时
3. 使用轮询调度（Round Robin）模式：

// 在FreeRTOSConfig.h中设置
#define configUSE_TIME_SLICING 1

6.3 任务同步问题

如果多个任务访问共享资源导致数据不一致：

1. 使用互斥量保护共享资源
2. 考虑使用消息队列代替全局变量
3. 减少共享数据，尽量使用任务本地变量

七、进阶应用

7.1 软件定时器

FreeRTOS提供软件定时器功能，可以在指定时间执行回调函数：

// 定时器句柄
TimerHandle_t xTimer;

// 定时器回调函数
void vTimerCallback(TimerHandle_t xTimer) {
    Serial.println("定时器触发！");
}

// 在初始化函数中创建定时器
void freertos_init(void) {
    // 创建软件定时器，2000ms触发一次
    xTimer = xTimerCreate(
        "MyTimer",              // 定时器名称
        pdMS_TO_TICKS(2000),    // 周期，单位为tick
        pdTRUE,                 // 是否自动重载
        (void *)0,              // 定时器ID
        vTimerCallback          // 回调函数
    );
    
    // 启动定时器
    if(xTimer != NULL) {
        xTimerStart(xTimer, 0);
    }
    
    // 创建其他任务...
}

7.2 事件组（Event Groups）

事件组用于多个事件的同步，一个任务可以等待多个事件：

// 定义事件组
EventGroupHandle_t xEventGroup;

// 定义事件位
#define EVENT_BIT_1 (1 << 0)
#define EVENT_BIT_2 (1 << 1)

// 等待事件的任务
void task1_function(void *param) {
    while(1) {
        // 等待所有事件位
        EventBits_t xBits = xEventGroupWaitBits(
            xEventGroup,           // 事件组句柄
            EVENT_BIT_1 | EVENT_BIT_2,  // 等待的事件位
            pdTRUE,                // 事件发生后是否清除事件位
            pdTRUE,                // pdTRUE:等待所有事件，pdFALSE:等待任一事件
            portMAX_DELAY          // 永久等待
        );
        
        Serial.println("所有事件已触发！");
    }
}

// 设置事件的任务
void task2_function(void *param) {
    while(1) {
        // 设置事件位1
        xEventGroupSetBits(xEventGroup, EVENT_BIT_1);
        Serial.println("事件1已设置");
        vTaskDelay(1000 / portTICK_PERIOD_MS);
        
        // 设置事件位2
        xEventGroupSetBits(xEventGroup, EVENT_BIT_2);
        Serial.println("事件2已设置");
        vTaskDelay(1000 / portTICK_PERIOD_MS);
    }
}

// 初始化
void freertos_init(void) {
    // 创建事件组
    xEventGroup = xEventGroupCreate();
    
    // 创建任务...
}

7.3 队列（Queue）

队列用于任务间数据传输：

// 定义队列句柄
QueueHandle_t xQueue;

// 发送数据的任务
void producer_task(void *param) {
    int count = 0;
    
    while(1) {
        count++;
        // 发送数据到队列
        if(xQueueSend(xQueue, &count, portMAX_DELAY) == pdPASS) {
            Serial.print("发送数据: ");
            Serial.println(count);
        }
        vTaskDelay(1000 / portTICK_PERIOD_MS);
    }
}

// 接收数据的任务
void consumer_task(void *param) {
    int receivedValue;
    
    while(1) {
        // 从队列接收数据
        if(xQueueReceive(xQueue, &receivedValue, portMAX_DELAY) == pdPASS) {
            Serial.print("接收数据: ");
            Serial.println(receivedValue);
        }
    }
}

// 初始化
void freertos_init(void) {
    // 创建队列，可存储5个整数
    xQueue = xQueueCreate(5, sizeof(int));
    
    // 创建生产者和消费者任务...
}

八、总结

本文详细介绍了ESP32上使用FreeRTOS进行多核多任务编程的方法。通过实例代码，我们学习了：

1. FreeRTOS的基本概念和优势
2. 如何创建任务并分配到不同核心
3. 任务间通信的多种方式
4. 任务同步与互斥的实现
5. 进阶应用如软件定时器、事件组和队列

ESP32的双核特性结合FreeRTOS的任务管理能力，为开发者提供了强大的并发编程能力。通过合理分配任务到不同核心，可以显著提高系统性能和响应速度，实现更加复杂的应用功能。

希望本文能帮助大家更好地理解和应用ESP32的多核编程技术。在实际项目中，根据应用需求合理设计任务结构、优先级和同步机制，才能充分发挥ESP32的性能优势。

---

如有问题或建议，欢迎在评论区留言交流！