【嵌入式】FreeRTOS串口等待vTaskDelay()

在串口发送指令后等待回复的场景中，使用 vTaskDelay 通常不是最佳选择，虽然在某些简单场景下可行，但存在明显缺陷。让我详细分析：

❌ 使用 vTaskDelay 的问题

c 复制代码

// 不好的做法
void SendCommandAndWait(char *cmd)
{
    UART_Send(cmd);  // 发送指令
    
    // 固定延迟等待回复
    vTaskDelay(pdMS_TO_TICKS(100));  // 问题1：固定等待时间
    
    // 检查是否有回复
    if(UART_HasData()) {
        UART_Read(reply);
    } else {
        // 超时，但可能回复还没到，或者早就到了但被延迟了
    }
}

主要问题：

时间浪费：必须等待固定时间，即使回复很快就到了
响应慢：如果回复在延迟中间到达，也要等到延迟结束
不可靠：不同网络条件/负载下，回复时间变化大，固定延迟不合适
CPU浪费：延迟期间任务处于阻塞状态，但其他任务可以运行，这点比轮询好，但不如信号量高效

✅ 更好的方案

方案1：使用队列（最推荐）

c 复制代码

// 全局队列句柄
QueueHandle_t xUART_ReplyQueue;

// 初始化
void UART_Init(void)
{
    // 创建队列，存储回复数据
    xUART_ReplyQueue = xQueueCreate(5, sizeof(reply_t));
    
    // 配置UART接收中断
    HAL_UART_Receive_IT(&huart, rx_buffer, 1);
}

// 发送指令并等待回复（在任务中调用）
int SendCommandAndWait(char *cmd, reply_t *reply, uint32_t timeout_ms)
{
    reply_t temp_reply;
    
    // 发送指令
    UART_Send(cmd, strlen(cmd));
    
    // 等待回复，使用队列阻塞等待
    if(xQueueReceive(xUART_ReplyQueue, &temp_reply, 
                     pdMS_TO_TICKS(timeout_ms)) == pdTRUE) {
        // 成功收到回复
        memcpy(reply, &temp_reply, sizeof(reply_t));
        return 0;  // 成功
    } else {
        // 超时未收到回复
        return -1; // 超时
    }
}

// UART接收中断（ISR）
void UART_IRQHandler(void)
{
    reply_t reply;
    
    // 接收数据并组装回复
    // ...
    
    // 将回复放入队列
    BaseType_t xHigherPriorityTaskWoken = pdFALSE;
    xQueueSendFromISR(xUART_ReplyQueue, &reply, &xHigherPriorityTaskWoken);
    
    // 如果放入队列导致更高优先级任务就绪，则进行任务切换
    portYIELD_FROM_ISR(xHigherPriorityTaskWoken);
}

方案2：使用任务通知（更高效）

c 复制代码

// 在任务中等待回复
int SendCommandAndWait(char *cmd, uint8_t *reply_buf, uint32_t timeout_ms)
{
    // 发送指令
    UART_Send(cmd, strlen(cmd));
    
    // 等待任务通知（作为回复就绪的标志）
    uint32_t ulNotificationValue;
    if(xTaskNotifyWait(0,           // 不清除任何位
                       ULONG_MAX,    // 退出时清除所有位
                       &ulNotificationValue,
                       pdMS_TO_TICKS(timeout_ms)) == pdTRUE) {
        // 收到通知，读取回复数据
        int len = UART_Read(reply_buf);
        return len;  // 返回接收到的数据长度
    } else {
        return -1;   // 超时
    }
}

// UART中断（ISR）
void UART_IRQHandler(void)
{
    TaskHandle_t xTaskToNotify = xTaskGetHandle("UART_Task");
    
    // 接收数据...
    
    // 通知等待的任务
    BaseType_t xHigherPriorityTaskWoken = pdFALSE;
    vTaskNotifyGiveFromISR(xTaskToNotify, &xHigherPriorityTaskWoken);
    portYIELD_FROM_ISR(xHigherPriorityTaskWoken);
}

方案3：使用二值信号量（简单场景）

c 复制代码

SemaphoreHandle_t xUART_Semaphore;

// 初始化
void UART_Init(void)
{
    xUART_Semaphore = xSemaphoreCreateBinary();
}

// 发送并等待
int SendCommandAndWait(char *cmd, timeout_ms)
{
    UART_Send(cmd, strlen(cmd));
    
    // 等待信号量
    if(xSemaphoreTake(xUART_Semaphore, pdMS_TO_TICKS(timeout_ms)) == pdTRUE) {
        // 收到回复，读取数据
        return UART_Read(reply_buf);
    } else {
        return -1;  // 超时
    }
}

// UART中断
void UART_IRQHandler(void)
{
    // 接收数据...
    
    // 给出信号量
    BaseType_t xHigherPriorityTaskWoken = pdFALSE;
    xSemaphoreGiveFromISR(xUART_Semaphore, &xHigherPriorityTaskWoken);
    portYIELD_FROM_ISR(xHigherPriorityTaskWoken);
}

方案对比

方案	优点	缺点	适用场景
vTaskDelay	实现简单	响应慢，不精确，浪费CPU	仅用于测试或非关键场景
队列	可传递数据，支持多个消息，最灵活	占用更多内存	复杂通信，需要传递数据
任务通知	最快（~45% 性能提升），内存占用小	只能通知一个任务	简单通知场景，一对一通信
信号量	实现简单，资源占用适中	只能传递事件，不能传数据	只需知道"收到回复"的场景

实际应用示例

c 复制代码

// 完整的串口通信任务示例
typedef struct {
    uint8_t cmd;
    uint8_t data[256];
    uint16_t len;
} uart_message_t;

void UART_Communication_Task(void *pvParameters)
{
    QueueHandle_t xUART_RxQueue = (QueueHandle_t)pvParameters;
    uart_message_t msg;
    
    while(1) {
        // 发送查询指令
        uint8_t query[] = {0x01, 0x03, 0x00, 0x00, 0x00, 0x01, 0x84, 0x0A};
        UART_Send(query, sizeof(query));
        
        // 等待回复，超时500ms
        if(xQueueReceive(xUART_RxQueue, &msg, pdMS_TO_TICKS(500)) == pdTRUE) {
            // 成功收到回复
            Process_Reply(&msg);
        } else {
            // 超时处理
            Handle_Timeout();
        }
        
        // 间隔1秒再次查询
        vTaskDelay(pdMS_TO_TICKS(1000));
    }
}

结论

对于"发送指令等待回复"的场景：

不推荐 使用 vTaskDelay ❌
推荐使用队列、任务通知或信号量 ✅
如果回复数据简单（只需知道有无回复），用任务通知 或二值信号量
如果需要传递复杂的回复数据，用队列
这样可以实现：
- 精确的超时控制
- 即时响应（回复到达立即处理）
- 高效的CPU利用（任务只在等待时阻塞）
- 更好的代码可维护性

这种基于RTOS同步机制的设计，才是真正发挥FreeRTOS优势的正确做法。