STM32 Cortex-M4+FreeRTOS下printf重定向USB CDC的线程安全与实现问题

首先咱们拆解你的核心问题：一是多线程下printf输出乱码，本质是无保护的多线程抢占导致字节交错；二是自定义printf实现没生效，说明你当前用的是编译器/库自带的默认printf，没优先链接你的printf-stdarg.c代码。下面一步步帮你解决：

第一步：让自定义printf正确生效 #

你需要确保自己的printf实现能覆盖默认库版本，这里给两个可靠方法：

方法1：用链接包裹强制替换默认printf #

在GCC编译选项中添加：

-Wl,--wrap=printf

然后在代码中实现包裹函数：

#include <stdarg.h>

// 你的底层打印函数
int print(int fd, const char *format, va_list args);

// 强制让所有printf调用转向自定义实现
int __wrap_printf(const char *format, ...) {
    va_list args;
    va_start(args, format);
    int ret = print(0, format, args);
    va_end(args);
    return ret;
}

这种方式会彻底绕开默认库的printf，强制使用你的实现。

方法2：强符号优先链接 #

在printf-stdarg.c的printf函数前加__attribute__((used))标记，确保编译器不会优化掉它，同时把该文件放在工程编译顺序的最前面，让链接器优先选择你的实现：

#include <stdarg.h>

int print(int fd, const char *format, va_list args);

__attribute__((used))
int printf(const char *format, ...) {
    va_list args;
    va_start(args, format);
    int ret = print(0, format, args);
    va_end(args);
    return ret;
}

第二步：实现线程安全的USB CDC输出 #

单字节调用CDC_Transmit_FS效率低且必然导致多线程字节交错，这里提供两种方案：

方案1：互斥锁保护原子打印（简单直接） #

适合小体量打印需求，用FreeRTOS互斥锁确保整个打印流程不被打断：

1. 全局声明并初始化互斥锁（在main创建任务前完成）：

#include "FreeRTOS.h"
#include "semphr.h"

SemaphoreHandle_t xPrintMutex;

int main(void) {
    // ... HAL、时钟等初始化代码

    // 创建打印互斥锁
    xPrintMutex = xSemaphoreCreateMutex();
    configASSERT(xPrintMutex != NULL); // 确保创建成功

    // ... 创建FreeRTOS任务
    vTaskStartScheduler();
}

2. 修改底层print函数，用互斥锁保护格式化+发送流程：

#define PRINT_BUFFER_SIZE 256 // 根据需求调整

int print(int fd, const char *format, va_list args) {
    char buffer[PRINT_BUFFER_SIZE];
    int len = vsnprintf(buffer, PRINT_BUFFER_SIZE, format, args);
    
    if (len > 0) {
        // 阻塞等待获取互斥锁，保证整个字符串输出原子性
        if (xSemaphoreTake(xPrintMutex, portMAX_DELAY) == pdTRUE) {
            CDC_Transmit_FS((uint8_t*)buffer, len);
            xSemaphoreGive(xPrintMutex); // 释放锁
        } else {
            len = -1; // 获取锁失败返回错误
        }
    }
    return len;
}

这里把单字节发送改成格式化后一次性发送整个字符串，配合互斥锁彻底避免字节交错。

方案2：队列+专用打印任务（适合高频/大体积打印） #

如果项目中有大量打印需求，或者在高优先级任务中调用printf，异步化处理更可靠，避免阻塞高优先级任务：

1. 全局声明队列与静态缓冲区池：

#include "FreeRTOS.h"
#include "queue.h"

#define PRINT_BUFFER_SIZE 256
#define PRINT_QUEUE_LENGTH 16 // 队列容纳的打印请求数
#define PRINT_BUFFER_POOL_SIZE 8 // 静态缓冲区数量

char printBuffers[PRINT_BUFFER_POOL_SIZE][PRINT_BUFFER_SIZE];
uint8_t bufferInUse[PRINT_BUFFER_POOL_SIZE] = {0};
QueueHandle_t xPrintQueue;

// 从缓冲区池获取空闲缓冲区
char* getFreeBuffer(void) {
    for (int i = 0; i < PRINT_BUFFER_POOL_SIZE; i++) {
        if (bufferInUse[i] == 0) {
            bufferInUse[i] = 1;
            return printBuffers[i];
        }
    }
    return NULL;
}

// 释放缓冲区回池
void releaseBuffer(char* buf) {
    for (int i = 0; i < PRINT_BUFFER_POOL_SIZE; i++) {
        if (buf == printBuffers[i]) {
            bufferInUse[i] = 0;
            break;
        }
    }
}

2. 创建专用打印任务：

void vUsbPrintTask(void *pvParameters) {
    char *pcBuffer;
    for (;;) {
        // 阻塞等待队列中的打印请求
        if (xQueueReceive(xPrintQueue, &pcBuffer, portMAX_DELAY) == pdTRUE) {
            // 等待USB CDC发送完成（处理非阻塞发送的忙碌状态）
            while (CDC_Transmit_FS((uint8_t*)pcBuffer, strlen(pcBuffer)) == USBD_BUSY) {
                vTaskDelay(pdMS_TO_TICKS(1));
            }
            releaseBuffer(pcBuffer); // 释放缓冲区
        }
    }
}

// 在main中初始化队列并创建任务
int main(void) {
    // ... 其他初始化

    xPrintQueue = xQueueCreate(PRINT_QUEUE_LENGTH, sizeof(char*));
    configASSERT(xPrintQueue != NULL);

    xTaskCreate(vUsbPrintTask, "USB Print Task", configMINIMAL_STACK_SIZE * 2, NULL, tskIDLE_PRIORITY + 1, NULL);

    vTaskStartScheduler();
}

3. 修改printf实现，异步发送到队列：

int printf(const char *format, ...) {
    va_list args;
    char *pcBuffer = getFreeBuffer();
    int len = -1;

    if (pcBuffer != NULL) {
        va_start(args, format);
        len = vsnprintf(pcBuffer, PRINT_BUFFER_SIZE, format, args);
        va_end(args);

        if (len > 0) {
            // 发送到打印队列，确保不会丢失请求
            xQueueSend(xPrintQueue, &pcBuffer, portMAX_DELAY);
        } else {
            releaseBuffer(pcBuffer);
        }
    }
    return len;
}

这种方式让打印操作异步化，主线程/其他线程只需把内容放到队列即可返回，不会被USB发送阻塞，同时专用任务保证输出的顺序性和原子性。

额外注意事项 #

• 确保CDC_Transmit_FS的发送缓冲区足够大，若打印内容超过缓冲区大小，需修改STM32CubeMX中的USB CDC缓冲区配置或实现分块发送。
• 如果在中断中需要打印，要使用中断安全版本的API：xSemaphoreTakeFromISR和xQueueSendFromISR。

内容的提问来源于stack exchange，提问作者po.pe