ESP32 FreeRTOS任务管理大全：概念、实现、优化与调试的一站式学习手册

最新推荐文章于 2026-01-06 08:38:59 发布

原创

最新推荐文章于 2026-01-06 08:38:59 发布 · 1.2k 阅读

26 ·

CC 4.0 BY-SA版权

文章标签：

#学习 #网络 #服务器 #stm32 #单片机 #物联网 #嵌入式硬件

文章总结（帮你们节约时间）

FreeRTOS任务管理是ESP32多任务编程的核心，理解任务状态转换是掌握实时系统的关键
任务调度器采用优先级抢占式调度算法，高优先级任务总是优先执行，同优先级任务采用时间片轮转
任务间通信机制包括队列、信号量、互斥锁等，是构建复杂应用的基础
合理的任务设计和资源管理直接影响系统的稳定性和实时性表现

什么是任务管理？揭开多任务系统的神秘面纱

你有没有想过，为什么你的手机能够同时播放音乐、接收消息、还能让你刷抖音？这背后的秘密就是多任务系统！就像一个优秀的厨师能够同时炒菜、煮汤、蒸米饭一样，计算机系统也能够"同时"处理多个任务。

等等，我说的"同时"其实是个善意的谎言！对于单核处理器来说，真正的同时执行是不可能的。那么这种"同时"是怎么实现的呢？答案就在于时间片轮转和任务调度！

想象一下，你是一个图书管理员，面前有100个读者排队借书。如果你按照先来后到的顺序，一个一个地为他们服务，那么最后一个读者可能要等上好几个小时！但是如果你采用"轮流服务"的策略：为第一个读者服务30秒，然后转向第二个读者服务30秒，依此类推。这样每个读者都不会等待太久，从他们的角度看，就好像你在"同时"为所有人服务一样！

这就是多任务系统的基本原理：CPU在不同的任务之间快速切换，每个任务轮流获得CPU的使用权。由于切换速度极快（通常在毫秒级别），用户感觉所有任务都在同时运行。

在ESP32这个强大的微控制器中，FreeRTOS（Free Real-Time Operating System，免费实时操作系统）扮演着这个"图书管理员"的角色。FreeRTOS是一个专门为嵌入式系统设计的实时操作系统内核，它提供了任务管理、时间管理、同步和通信等功能。

任务的本质：代码世界里的"生命体"

在深入了解任务管理之前，我们先来理解什么是"任务"。如果把程序比作一个繁忙的城市，那么任务就是城市里的各种"居民"——有些是勤劳的工人（执行数据处理），有些是敏感的哨兵（监听传感器），还有些是沟通的信使（处理网络通信）。

每个任务都有自己的"身份证"——任务控制块（Task Control Block，TCB）。这个TCB里记录着任务的所有重要信息：

任务的优先级：就像社会地位一样，决定了谁先谁后
任务的状态：告诉系统这个任务现在在做什么
堆栈指针：指向任务的"私人空间"，存放局部变量和函数调用信息
任务句柄：任务的"身份证号码"，用于系统识别

任务的创建过程就像生孩子一样：系统为新任务分配内存空间（堆栈），设置初始状态，然后将其添加到调度器的管理列表中。从此这个任务就有了"生命"，可以被调度器调度执行。

任务状态转换：任务的"人生轨迹"

每个任务就像一个有血有肉的人，在其生命周期中会经历不同的状态。FreeRTOS中定义了四种基本的任务状态，它们之间的转换就像人生的不同阶段：

就绪态（Ready）：蓄势待发的状态

就绪态的任务就像马拉松比赛中蹲在起跑线上的运动员，一切准备就绪，只等发令枪响！这些任务已经具备了运行的所有条件，只是暂时还没有获得CPU的使用权。

想象一个场景：你的ESP32正在执行一个高优先级的WiFi数据传输任务，此时定时器中断触发，需要读取温度传感器的数据。读取温度的任务立即从阻塞态转换为就绪态，但由于WiFi任务的优先级更高，温度读取任务只能在就绪队列中耐心等待。

就绪态任务按照优先级排列在就绪队列中，同一优先级的任务按照时间片轮转的方式排队。调度器每次都会选择优先级最高的就绪任务来执行。

运行态（Running）：风光无限的巅峰时刻

运行态就是任务的"高光时刻"！此时任务正在CPU上实际执行，享受着系统的全部注意力。但这种荣光是短暂的，因为在抢占式调度系统中，随时可能有更高优先级的任务抢夺CPU资源。

在单核系统中，任何时刻只能有一个任务处于运行态。这就像舞台上的聚光灯，永远只能照亮一个主角。但在ESP32的双核版本中，两个CPU核心可以同时运行两个不同的任务。

运行态任务的执行可能被以下情况打断：

更高优先级任务就绪：就像总统突然到访，所有人都要为他让路
时间片耗尽：民主社会里，即使是最重要的任务也要让其他同级任务有机会执行
主动让出CPU：任务主动调用延时函数或等待某个事件

阻塞态（Blocked）：耐心等待的智慧状态

阻塞态是任务的"修行"状态。任务因为等待某个事件（如延时、信号量、队列消息等）而无法继续执行，就像一个哲学家在思考人生的意义，暂时与世隔绝。

这种状态其实体现了系统设计的智慧！想象一下，如果一个任务需要等待用户按键，它有两种选择：

愚蠢的方式：不停地检查按键状态（忙等待），消耗大量CPU资源
聪明的方式：进入阻塞态，告诉系统"当按键按下时请叫醒我"，然后安心休息

显然第二种方式更优雅！阻塞态任务不占用CPU资源，让其他任务有机会运行，提高了整个系统的效率。

阻塞态可以分为几种情况：

时间阻塞：任务调用 vTaskDelay() 函数，等待指定时间
事件阻塞：等待信号量、互斥锁、队列消息等同步对象
IO阻塞：等待外设数据准备就绪

当等待的条件满足时，任务会自动从阻塞态转换为就绪态，重新获得被调度的机会。

挂起态（Suspended）：深度睡眠的特殊状态

挂起态就像任务进入了"冬眠"状态，它不参与任何调度，即使所有条件都满足也不会被执行。只有其他任务明确调用恢复函数，挂起的任务才能重新"苏醒"。

这种状态在实际应用中非常有用。比如在电池供电的项目中，某些非关键任务可以在低电量时被挂起，以节省系统资源。或者在调试过程中，可以临时挂起某个任务来观察系统行为。

挂起操作必须通过调用特定的API函数来实现：

vTaskSuspend()：挂起指定任务
vTaskResume()：从任务中恢复挂起的任务
xTaskResumeFromISR()：从中断中恢复挂起的任务

任务状态转换图：生命的轮回

任务状态之间的转换遵循严格的规则，就像自然界的生物循环一样。让我们用一个状态转换图来描述这个过程：

         创建任务
            ↓
        ┌─────────┐    高优先级任务就绪    ┌─────────┐
        │  就绪态  │ ←───────────────────── │  运行态  │
        │ Ready  │ ─────────────────────→ │Running │
        └─────────┘    获得CPU时间片       └─────────┘
            ↑                                  │
            │                                  │ 等待事件/延时
            │ 事件发生/延时到达                │
            │                                  ↓
        ┌─────────┐                      ┌─────────┐
        │  阻塞态  │                      │  挂起态  │
        │Blocked │                      │Suspended│
        └─────────┘                      └─────────┘
            ↑                                  │
            └──────────恢复任务─────────────────┘

这个状态转换过程是动态的、连续的。一个设计良好的多任务系统就像一个和谐的交响乐团，每个任务都在适当的时机"演奏"自己的"乐章"。

FreeRTOS任务调度器：系统的"指挥家"

如果把多任务系统比作一个交响乐团，那么任务调度器就是那个手持指挥棒的指挥家。它决定着什么时候哪个"乐手"（任务）应该"演奏"（执行），确保整个"音乐会"（系统）和谐有序。

FreeRTOS采用的是抢占式优先级调度算法，这听起来很复杂，但原理其实很简单：优先级高的任务总是优先执行！

优先级的哲学：不是所有任务都生而平等

在现实世界中，不同的事情有不同的重要性。救火比喝咖啡重要，接听老板电话比刷朋友圈重要。同样，在嵌入式系统中，不同的任务也有不同的优先级。

FreeRTOS中的优先级用数字表示，数字越大优先级越高。优先级的范围从0到 configMAX_PRIORITIES - 1，这个最大值在编译时确定。

让我们用一个生动的比喻来理解优先级调度：

想象你是一家医院的急诊科医生，面前有三个病人：

病人A：心脏病发作（优先级：紧急）
病人B：骨折（优先级：重要）
病人C：轻微感冒（优先级：一般）

作为医生，你会怎么安排治疗顺序？毫无疑问，你会先救治心脏病患者，然后处理骨折病人，最后才是感冒患者。这就是优先级调度的基本原理！

在程序中，这可能对应着：

高优先级任务：处理紧急中断、实时数据采集
中等优先级任务：网络通信、用户界面更新
低优先级任务：日志记录、系统监控

抢占式调度：强者为王的世界

抢占式调度的核心思想是：当有更高优先级的任务就绪时，当前运行的低优先级任务会立即被"踢下台"！

这就像古代的宫廷，当皇帝来到时，所有大臣都要立即停下手头的工作，向皇帝行礼。不管大臣们正在做什么重要的事情，皇帝的事情永远是最重要的！

让我们看一个具体的例子：

// 低优先级任务正在执行复杂计算
void lowPriorityTask(void *parameter) {
   
   
    while(1) {
   
   
        // 正在执行耗时的数学运算
        for(int i = 0; i < 1000000; i++) {
   
   
            complexCalculation();  // 假设这里有复杂计算
        }
        vTaskDelay(pdMS_TO_TICKS(100));
    }
}

// 高优先级任务处理紧急事件
void highPriorityTask(void *parameter) {
   
   
    while(1) {
   
   
        // 等待紧急信号
        ulTaskNotifyTake(pdTRUE, portMAX_DELAY);
        
        // 立即处理紧急事件
        handleEmergency();  // 这个函数会立即执行，不管低优先级任务在干什么
    }
}

当 highPriorityTask 收到通知时，不管 lowPriorityTask 执行到第几次循环，都会立即被中断，CPU控制权转移给高优先级任务。

时间片轮转：民主社会的智慧

但是，如果多个任务具有相同的优先级怎么办？总不能让它们打架决定谁先执行吧！

这时候就轮到时间片轮转（Round Robin）登场了！这是一个非常民主的调度方式，就像幼儿园老师分配玩具一样公平。

每个同优先级的任务都会获得一个固定的时间片（通常是1-10毫秒），在这个时间内任务可以独占CPU。时间片用完后，即使任务还没执行完，也要乖乖让出CPU给同优先级的下一个任务。

这种机制的妙处在于防止了"任务霸权"！想象一下，如果没有时间片限制，一个同优先级的任务可能会一直占用CPU，其他同级任务永远得不到执行机会。这就像一个贪心的小朋友拿到玩具后就不愿意分享给其他小朋友一样！

时间片的大小是一个需要仔细权衡的参数：

时间片太短：任务切换过于频繁，系统开销增大，就像换人太频繁反而影响工作效率
时间片太长：响应性变差，用户可能感觉到明显的延迟

调度器的工作流程：精密的时钟机制

FreeRTOS的调度器工作起来就像一个精密的瑞士钟表，每个齿轮都恰到好处地配合着：

系统滴答中断：这是调度器的"心跳"，通常每毫秒触发一次
就绪队列扫描：调度器检查所有就绪任务，找出优先级最高的那个
上下文切换：如果发现更高优先级的任务，立即进行任务切换
时间片管理：对于同优先级任务，管理时间片的分配和轮转

这个过程的数学表达可以用以下公式描述：

$\max_{i \in ReadyTasks}(Priority_i)$

其中， $R e a d y T a s k s$ 表示所有就绪态任务的集合， $Priority_i$ 表示任务i的优先级。

Arduino环境下的FreeRTOS任务函数：程序员的工具箱

在Arduino IDE中使用ESP32进行FreeRTOS编程，就像拥有了一个功能强大的工具箱。让我们来看看这个工具箱里都有哪些"神器"：

任务创建函数：生命的起源

xTaskCreate() 函数就像上帝创造亚当一样，赋予代码以"生命"：

BaseType_t xTaskCreate(
    TaskFunction_t pxTaskCode,      // 任务函数指针
    const char * const pcName,     // 任务名称（调试用）
    const uint32_t usStackDepth,   // 堆栈大小
    void * const pvParameters,     // 传递给任务的参数
    UBaseType_t uxPriority,        // 任务优先级
    TaskHandle_t * const pxCreatedTask  // 任务句柄
);

这个函数的每个参数都有其深刻的含义：

pxTaskCode：任务的"灵魂"，指向实际执行的函数
pcName：任务的"姓名"，虽然系统运行时不需要，但对调试非常有用
usStackDepth：任务的"生存空间"，太小会导致栈溢出，太大浪费内存
pvParameters：任务的"出生礼物"，创建时传递的初始参数
uxPriority：任务的"社会地位"，决定调度优先级
pxCreatedTask：任务的"身份证"，用于后续操作

任务删除函数：优雅的告别

有生必有死，vTaskDelete() 函数负责任务的"善终"：

void vTaskDelete(TaskHandle_t xTaskToDelete);

删除任务时，系统会自动回收任务占用的内存资源。如果传入NULL作为参数，任务会"自杀"（删除自己）。但要注意，任务删除后，所有指向该任务的句柄都会变成"野指针"，使用时要格外小心！

任务延时函数：时间的艺术

在多任务系统中，合理的延时是一门艺术。FreeRTOS提供了两种延时函数：

绝对延时 - vTaskDelay()：

void vTaskDelay(const TickType_t xTicksToDelay);

这就像设定一个定时器，“我要休息100毫秒”。但这种延时是相对的，不考虑任务执行时间的变化。

相对延时 - vTaskDelayUntil()：

void vTaskDelayUntil(TickType_t *pxPreviousWakeTime, const TickType_t xTimeIncrement);

这是一种更精确的延时方式，确保任务以固定的频率执行。就像一个严格的闹钟，不管你昨晚几点睡，都会在固定时间叫醒你。

两者的区别可以用这个比喻来理解：

vTaskDelay()：像是说"我要睡8小时"，不管现在几点
vTaskDelayUntil()：像是说"我要每天7点起床"，保证固定的作息时间

任务优先级管理：社会地位的变迁

有时候，我们需要动态调整任务的优先级，就像现实中的职位升迁一样：

// 获取任务当前优先级
UBaseType_t uxTaskPriorityGet(TaskHandle_t xTask);

// 设置任务优先级
void vTaskPrioritySet(TaskHandle_t xTask, UBaseType_t uxNewPriority);

动态优先级调整在某些应用场景中非常有用，比如优先级继承协议，用来解决优先级反转问题。

任务状态查询：系统的"体检报告"

了解任务的当前状态对于系统调试和优化至关重要：

// 获取任务状态
eTaskState eTaskGetState(TaskHandle_t xTask);

// 获取系统中所有任务的信息
UBaseType_t uxTaskGetSystemState(TaskStatus_t * const pxTaskStatusArray,
                                const UBaseType_t uxArraySize,
                                uint32_t * const pulTotalRunTime);

这些函数就像系统的"体检报告"，告诉你每个任务的健康状况。

任务间通信：构建协作的桥梁

单个任务就像孤岛，只有通过通信机制，任务之间才能协作完成复杂的功能。FreeRTOS提供了多种通信机制，就像现实世界中的各种通信方式一样。

队列（Queue）：任务间的邮政系统

队列就像任务之间的邮政系统，发送方可以往队列里投递"邮件"（数据），接收方从队列中取出"邮件"。这种机制既安全又高效，是FreeRTOS中最常用的通信方式。

队列的特点：

FIFO原则：先进先出，就像排队买票一样公平
线程安全：多个任务可以同时操作同一个队列而不会出现数据竞争
阻塞特性：当队列满时发送会阻塞，当队列空时接收会阻塞

// 创建队列
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);

信号量（Semaphore）：资源访问的通行证

信号量就像停车场的通行证，控制着有限资源的访问。当停车位满了，后来的车只能等待；当有车离开，等待的车才能进入。

信号量分为两种类型：

二进制信号量：只有0和1两种状态，类似于互斥锁
计数信号量：可以有多个资源单位，适合管理多个相同资源

// 创建二进制信号量
SemaphoreHandle_t xSemaphoreCreateBinary(void);

// 创建计数信号量
SemaphoreHandle_t xSemaphoreCreateCounting(UBaseType_t uxMaxCount, UBaseType_t uxInitialCount);

// 获取信号量
BaseType_t xSemaphoreTake(SemaphoreHandle_t xSemaphore, TickType_t xTicksToWait);

// 释放信号量
BaseType_t xSemaphoreGive(SemaphoreHandle_t xSemaphore);

互斥锁（Mutex）：VIP专属通道

互斥锁就像VIP专属通道，同一时间只允许一个任务通过。它比二进制信号量更智能，具有优先级继承特性，可以防止优先级反转问题。

// 创建互斥锁
SemaphoreHandle_t xSemaphoreCreateMutex(void);

// 获取互斥锁（与信号量API相同）
BaseType_t xSemaphoreTake(SemaphoreHandle_t xMutex, TickType_t xTicksToWait);

// 释放互斥锁（与信号量API相同）
BaseType_t xSemaphoreGive(SemaphoreHandle_t xMutex);

实战演练：构建一个完整的多任务系统

理论说得再多，不如动手实践一次！让我们设计一个完整的ESP32多任务应用：一个智能环境监测系统。

这个系统包含以下功能：

传感器数据采集任务：定期读取温湿度传感器
数据处理任务：对采集到的数据进行滤波和分析
显示更新任务：在OLED屏幕上显示当前数据
网络通信任务：将数据上传到云端
用户交互任务：处理按键输入和LED指示

#include <Arduino.h>
#include <WiFi.h>
#include <DHT.h>

// 硬件定义
#define DHT_PIN 4
#define LED_PIN 2
#define BUTTON_PIN 0

// 创建DHT对象
DHT dht(DHT_PIN, DHT22);

// 任务句柄
TaskHandle_t sensorTaskHandle;
TaskHandle_t processTaskHandle;
TaskHandle_t displayTaskHandle;
TaskHandle_t networkTaskHandle;
TaskHandle_t userTaskHandle;

// 队列句柄
QueueHandle_t sensorDataQueue;
QueueHandle_t processedDataQueue;

// 信号量句柄
SemaphoreHandle_t displayMutex;
SemaphoreHandle_t networkSemaphore;

// 数据结构定义
typedef struct {
   
   
    float temperature;
    float humidity;
    uint32_t timestamp;
} SensorData_t;

typedef struct {
   
   
    float avgTemperature;
    float avgHumidity;
    float tempTrend;
    float humidityTrend;
    uint32_t timestamp;
} ProcessedData_t;

// 传感器数据采集任务
void sensorTask(void *parameter) {
   
   
    SensorData_t sensorData;
    TickType_t xLastWakeTime = xTaskGetTickCount();
    
    Serial.println("传感器任务启动 - 开始环境数据采集之旅！");
    
    while(1) {
   
   
        // 读取传感器数据
        sensorData.temperature = dht.readTemperature();
        sensorData.humidity = dht.readHumidity();
        sensorData.timestamp = millis();
        
        // 数据有效性检查
        if (!isnan(sensorData.temperature) && !isnan(sensorData.humidity)) {
   
   
            // 发送数据到处理队列
            if (xQueueSend(sensorDataQueue, &sensorData, pdMS_TO_TICKS(100)) != pdTRUE) {
   
   
                Serial.println("警告：传感器数据队列已满，数据丢失！");
            } else {
   
   
                Serial.printf("传感器数据采集成功 - 温度: %.1f°C, 湿度: %.1f%%\n", 
                             sensorData.temperature, sensorData.humidity);
            }
        } else {
   
   
            Serial.println("错误：传感器读取失败，请检查硬件连接！");
        }
        
        // 精确的周期性延时 - 每5秒采集一次
        vTaskDelayUntil(&xLastWakeTime, pdMS_TO_TICKS(5000));
    }
}

// 数据处理任务
void processTask(void *parameter) {
   
   
    SensorData_t rawData;
    ProcessedData_t processedData;
    
    // 滑动平均滤波器参数
    const int FILTER_SIZE = 5;
    float tempBuffer[FILTER_SIZE] = {
   
   0};
    float humidityBuffer[FILTER_SIZE] = {
   
   0};
    int bufferIndex = 0;
    bool bufferFull = false;
    
    Serial.println("数据处理任务启动 - 准备进行数据魔法变换！");
    
    while(1) {
   
   
        // 等待原始数据
        if (xQueueReceive(sensorDataQueue, &rawData, portMAX_DELAY) == pdTRUE) {
   
   
            
            // 将新数据加入滤波器缓冲区
            tempBuffer[bufferIndex] = rawData.temperature;
            humidityBuffer[bufferIndex] = rawData.humidity;
            bufferIndex = (bufferIndex + 1) % FILTER_SIZE;
            
            if (bufferIndex == 0) {
   
   
                bufferFull = true;
            }
            
            // 计算滑动平均值
            if (bufferFull) {
   
   
                float tempSum = 0, humiditySum = 0;
                for (int i = 0; i < FILTER_SIZE; i++) {
   
   
                    tempSum += tempBuffer[i];
                    humiditySum += humidityBuffer[i];
                }
                
                processedData.avgTemperature = tempSum / FILTER_SIZE;
                processedData.avgHumidity = humiditySum / FILTER_SIZE;
                
                // 简单的趋势分析（这里只是示例，实际应用中可以更复杂）
                static float lastTemp = 0, lastHumidity = 0;
                processedData.tempTrend = processedData.avgTemperature - lastTemp;
                processedData.humidityTrend = processedData.avgHumidity - lastHumidity;
                lastTemp = processedData.avgTemperature;
                lastHumidity = processedData.avgHumidity;
                
                processedData.timestamp = millis();
                
                // 发送处理后的数据
                if (xQueueSend(processedDataQueue, &processedData, pdMS_TO_TICKS(100)) == pdTRUE) {
   
   
                    Serial.printf("数据处理完成 - 平均温度: %.1f°C (趋势: %+.1f), 平均湿度: %.1f%% (趋势: %+.1f)\n",
                                 processedData.avgTemperature, processedData.tempTrend,
                                 processedData.avgHumidity, processedData.humidityTrend);
                }
            }
        }
    }
}

// 显示更新任务
void displayTask(void *parameter) {
   
   
    ProcessedData_t displayData;
    
    Serial.println("显示任务启动 - 准备为用户呈现精美数据！");
    
    while(1) {
   
   
        // 等待处理后的数据
        if (xQueueReceive(processedDataQueue, &displayData, pdMS_TO_TICKS(1000)) == pdTRUE) {
   
   
            
            // 获取显示互斥锁，确保显示操作的原子性
            if (xSemaphoreTake(displayMutex, pdMS_TO_TICKS(100)) == pdTRUE) {
   
   
                
                // 模拟OLED显示更新（实际项目中这里会是真正的显示代码）
                Serial.println("=== 显示屏更新 ===");
                Serial.printf("温度: %.1f°C %s\n", displayData.avgTemperature, 
                             displayData.tempTrend > 0 ? "↗" : (displayData.tempTrend < 0 ? "↘" : "→"));
                Serial.printf("湿度: %.1f%% %s\n", displayData.avgHumidity,
                             displayData.humidityTrend > 0 ? "↗" : (displayData.humidityTrend < 0 ? "↘" : "→"));
                Serial.printf("更新时间: %lu ms\n", displayData.timestamp);
                Serial.println("==================");
                
                // 释放显示互斥锁
                xSemaphoreGive(displayMutex);
                
                // 触发网络上传
                xSemaphoreGive(networkSemaphore);
            }
        }
        
        // 即使没有新数据，也要定期刷新显示（防止屏幕休眠）
        vTaskDelay(pdMS_TO_TICKS(100));
    }
}

// 网络通信任务
void networkTask(void *parameter) {
   
   
    ProcessedData_t networkData;
    
    Serial.println("网络任务启动 - 准备连接云端世界！");
    
    // 初始化WiFi连接
    WiFi.begin("YourWiFiSSID", "YourWiFiPassword");
    while (WiFi.status() != WL_CONNECTED) {
   
   
        Serial.print(".");
        vTaskDelay(pdMS_TO_TICKS(500));
    }
    Serial.println("\nWiFi连接成功！");
    
    while(1) {
   
   
        // 等待上传信号
        if (xSemaphoreTake(networkSemaphore, portMAX_DELAY) == pdTRUE) {
   
   
            
            // 获取最新的处理数据
            if (xQueuePeek(processedDataQueue, &networkData, 0) == pdTRUE) {
   
   
                
                // 模拟网络上传过程
                Serial.println("开始数据上传...");
                
                // 构造JSON数据包
                String jsonData = "{";
                jsonData += "\"temperature\":" + String(networkData

最低0.47元/天解锁文章