嵌入式操作系统

FreeRTOS 内核功能

功能模块	说明	关键函数
任务管理	创建、删除、挂起、恢复任务	xTaskCreate, vTaskDelete, vTaskSuspend
调度器	优先级抢占式调度 + 时间片轮转	vTaskStartScheduler
队列	任务间传递数据	xQueueCreate, xQueueSend, xQueueReceive
信号量	任务同步和资源计数	xSemaphoreCreateBinary, xSemaphoreTake
互斥锁	保护共享资源，支持优先级继承	xSemaphoreCreateMutex
事件标志组	多事件组合同步	xEventGroupCreate, xEventGroupWaitBits
软件定时器	定时回调函数	xTimerCreate, xTimerStart
内存管理	动态内存分配（5种策略）	pvPortMalloc, vPortFree
任务通知	轻量级任务间通信	xTaskNotify, xTaskNotifyWait

任务函数原型

// 任务函数原型（必须是无限循环）
void vTaskFunction(void *pvParameters)
{
    // 初始化代码（只执行一次）
    
    for(;;)
    {
        // 任务主循环代码
        LED_Toggle();
        vTaskDelay(500); // 延时 500ms，让出 CPU
    }
}

xTaskCreate() 函数原型

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

创建任务完整示例

// 任务 1：LED 闪烁
void vTaskLED(void *pvParameters)
{
    for(;;)
    {
        HAL_GPIO_TogglePin(GPIOA, GPIO_PIN_0);
        vTaskDelay(500); // 延时 500ms
    }
}

// 任务 2：串口打印
void vTaskUART(void *pvParameters)
{
    for(;;)
    {
        printf("Hello FreeRTOS!\r\n");
        vTaskDelay(1000); // 延时 1000ms
    }
}

// 主函数
int main(void)
{
    HAL_Init();
    SystemClock_Config();
    LED_Init();
    UART_Init();
    
    // 创建任务 1（优先级 2）
    xTaskCreate(vTaskLED, "LED", 128, NULL, 2, NULL);
    // 创建任务 2（优先级 1）
    xTaskCreate(vTaskUART, "UART", 128, NULL, 1, NULL);
    
    // 启动调度器
    vTaskStartScheduler();
    
    // 不应该运行到这里
    for(;;);
}

队列操作函数

// 创建队列
QueueHandle_t xQueueCreate(
    UBaseType_t uxQueueLength,   // 队列长度（能存几个元素）
    UBaseType_t uxItemSize       // 每个元素大小（字节）
);

// 发送到队列（任务中使用）
BaseType_t xQueueSend(
    QueueHandle_t xQueue,        // 队列句柄
    const void *pvItemToQueue,   // 要发送的数据指针
    TickType_t xTicksToWait      // 等待时间（portMAX_DELAY=永久等待）
);

// 从队列接收（任务中使用）
BaseType_t xQueueReceive(
    QueueHandle_t xQueue,        // 队列句柄
    void *pvBuffer,              // 接收缓冲区
    TickType_t xTicksToWait      // 等待时间
);

// 从中断发送到队列
BaseType_t xQueueSendFromISR(
    QueueHandle_t xQueue,
    const void *pvItemToQueue,
    BaseType_t *pxHigherPriorityTaskWoken
);

队列使用完整示例

// 定义队列句柄
QueueHandle_t xQueue;

// 任务 1：发送数据
void vTaskSender(void *pvParameters)
{
    uint32_t count = 0;
    for(;;)
    {
        count++;
        xQueueSend(xQueue, &count, portMAX_DELAY);
        printf("发送: %d\r\n", count);
        vTaskDelay(1000);
    }
}

// 任务 2：接收数据
void vTaskReceiver(void *pvParameters)
{
    uint32_t received;
    for(;;)
    {
        if(xQueueReceive(xQueue, &received, portMAX_DELAY) == pdPASS)
        {
            printf("接收: %d\r\n", received);
        }
    }
}

// 主函数
int main(void)
{
    // 创建队列（能存 10 个 uint32_t 数据）
    xQueue = xQueueCreate(10, sizeof(uint32_t));
    
    xTaskCreate(vTaskSender, "Sender", 128, NULL, 2, NULL);
    xTaskCreate(vTaskReceiver, "Receiver", 128, NULL, 1, NULL);
    vTaskStartScheduler();
}

信号量操作函数

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

// 创建计数信号量
SemaphoreHandle_t xSemaphoreCreateCounting(
    UBaseType_t uxMaxCount,      // 最大计数值
    UBaseType_t uxInitialCount   // 初始计数值
);

// 获取信号量（等待/减 1）
BaseType_t xSemaphoreTake(
    SemaphoreHandle_t xSemaphore,
    TickType_t xTicksToWait
);

// 释放信号量（通知/加 1）
BaseType_t xSemaphoreGive(
    SemaphoreHandle_t xSemaphore
);

// 从中断释放信号量
BaseType_t xSemaphoreGiveFromISR(
    SemaphoreHandle_t xSemaphore,
    BaseType_t *pxHigherPriorityTaskWoken
);

二值信号量示例：中断通知任务

SemaphoreHandle_t xSemaphore;

// 中断服务程序
void EXTI0_IRQHandler(void)
{
    HAL_GPIO_EXTI_IRQHandler(GPIO_PIN_0);
    BaseType_t xHigherPriorityTaskWoken = pdFALSE;
    xSemaphoreGiveFromISR(xSemaphore, &xHigherPriorityTaskWoken);
    portYIELD_FROM_ISR(xHigherPriorityTaskWoken);
}

// 任务：等待中断通知
void vTaskButton(void *pvParameters)
{
    for(;;)
    {
        // 等待信号量（中断给的）
        if(xSemaphoreTake(xSemaphore, portMAX_DELAY) == pdPASS)
        {
            printf("按键按下！\r\n");
            HAL_GPIO_TogglePin(GPIOA, GPIO_PIN_0);
        }
    }
}

int main(void)
{
    xSemaphore = xSemaphoreCreateBinary(); // 创建二值信号量
    xTaskCreate(vTaskButton, "Btn", 128, NULL, 2, NULL);
    vTaskStartScheduler();
}

互斥锁使用示例：保护共享资源

SemaphoreHandle_t xMutex;

// 任务 A：使用串口
void vTaskA(void *pvParameters)
{
    for(;;)
    {
        xSemaphoreTake(xMutex, portMAX_DELAY); // 获取锁
        printf("TaskA: 正在使用串口...\r\n");
        vTaskDelay(100);
        xSemaphoreGive(xMutex);                 // 释放锁
        vTaskDelay(500);
    }
}

// 任务 B：使用串口
void vTaskB(void *pvParameters)
{
    for(;;)
    {
        xSemaphoreTake(xMutex, portMAX_DELAY); // 获取锁
        printf("TaskB: 正在使用串口...\r\n");
        vTaskDelay(100);
        xSemaphoreGive(xMutex);                 // 释放锁
        vTaskDelay(500);
    }
}

int main(void)
{
    xMutex = xSemaphoreCreateMutex(); // 创建互斥锁
    xTaskCreate(vTaskA, "A", 128, NULL, 2, NULL);
    xTaskCreate(vTaskB, "B", 128, NULL, 1, NULL);
    vTaskStartScheduler();
}

事件标志组操作函数

// 创建事件标志组
EventGroupHandle_t xEventGroupCreate(void);

// 设置事件标志
EventBits_t xEventGroupSetBits(
    EventGroupHandle_t xEventGroup,
    const EventBits_t uxBitsToSet
);

// 等待事件标志
EventBits_t xEventGroupWaitBits(
    EventGroupHandle_t xEventGroup,
    const EventBits_t uxBitsToWaitFor,  // 要等待的位
    const BaseType_t xClearOnExit,      // 退出时清除
    const BaseType_t xWaitForAllBits,   // TRUE=与, FALSE=或
    TickType_t xTicksToWait
);

任务通知操作函数

// 发送通知（可以携带数据）
BaseType_t xTaskNotify(
    TaskHandle_t xTaskToNotify,
    uint32_t ulValue,
    eNotifyAction eAction
);

// 等待通知
BaseType_t xTaskNotifyWait(
    uint32_t ulBitsToClearOnEntry,
    uint32_t ulBitsToClearOnExit,
    uint32_t *pulNotificationValue,
    TickType_t xTicksToWait
);

// 从中断发送通知
BaseType_t xTaskNotifyFromISR(
    TaskHandle_t xTaskToNotify,
    uint32_t ulValue,
    eNotifyAction eAction,
    BaseType_t *pxHigherPriorityTaskWoken
);

周期性任务示例

// 方式 1：vTaskDelay（周期不准确）
void vTask1(void *pvParameters)
{
    for(;;)
    {
        LED_Toggle();
        vTaskDelay(pdMS_TO_TICKS(100)); // 延时 100ms
        // 实际周期 = 100ms + 任务执行时间
    }
}

// 方式 2：vTaskDelayUntil（周期准确）
void vTask2(void *pvParameters)
{
    TickType_t xLastWakeTime = xTaskGetTickCount();
    const TickType_t xPeriod = pdMS_TO_TICKS(100); // 100ms 周期
    
    for(;;)
    {
        LED_Toggle();
        vTaskDelayUntil(&xLastWakeTime, xPeriod);
        // 实际周期 = 100ms（准确）
    }
}

软件定时器操作函数

// 创建定时器
TimerHandle_t xTimerCreate(
    const char * const pcTimerName,  // 定时器名称
    const TickType_t xTimerPeriod,   // 周期（节拍数）
    const UBaseType_t uxAutoReload,  // TRUE=自动重载, FALSE=单次
    void * const pvTimerID,          // 定时器 ID
    TimerCallbackFunction_t pxCallbackFunction // 回调函数
);

// 启动定时器
BaseType_t xTimerStart(TimerHandle_t xTimer, TickType_t xTicksToWait);

// 停止定时器
BaseType_t xTimerStop(TimerHandle_t xTimer, TickType_t xTicksToWait);

// 修改周期
BaseType_t xTimerChangePeriod(TimerHandle_t xTimer, TickType_t xNewPeriod, TickType_t xTicksToWait);

软件定时器示例

// 定时器回调函数（不能阻塞！）
void vTimerCallback(TimerHandle_t xTimer)
{
    HAL_GPIO_TogglePin(GPIOA, GPIO_PIN_0); // 翻转 LED
}

int main(void)
{
    // 创建定时器，500ms 周期，自动重载
    TimerHandle_t xTimer = xTimerCreate(
        "LED_Timer",
        pdMS_TO_TICKS(500),
        pdTRUE,        // 自动重载
        NULL,
        vTimerCallback
    );
    
    // 启动定时器
    xTimerStart(xTimer, 0);
    
    vTaskStartScheduler();
}

内存管理函数

// 动态分配内存
void *pvPortMalloc(size_t xSize);

// 释放内存
void vPortFree(void *pv);

// 获取剩余空闲内存
size_t xPortGetFreeHeapSize(void);

// 获取历史最小空闲内存（水位线）
size_t xPortGetMinimumEverFreeHeapSize(void);

FreeRTOSConfig.h 关键配置

// FreeRTOSConfig.h 关键配置
#define configUSE_PREEMPTION        1    // 1=抢占式调度
#define configCPU_CLOCK_HZ          72000000  // CPU 主频
#define configTICK_RATE_HZ          1000  // 时钟节拍 1kHz（1ms）
#define configMAX_PRIORITIES        5    // 最大优先级数
#define configMINIMAL_STACK_SIZE    128  // 最小堆栈大小
#define configTOTAL_HEAP_SIZE       10240 // 堆大小（10KB）
#define configUSE_MUTEXES           1    // 启用互斥锁
#define configUSE_COUNTING_SEMAPHORES 1  // 启用计数信号量
#define configUSE_TIMERS            1    // 启用软件定时器
#define configUSE_TASK_NOTIFICATIONS 1   // 启用任务通知

例题：创建两个任务，分别以不同频率闪烁 LED 要求：任务 1 每 500ms 翻转 LED1，任务 2 每 1000ms 翻转 LED2。

// 任务 1
void vTaskLED1(void *pvParameters)
{
    for(;;)
    {
        HAL_GPIO_TogglePin(GPIOA, GPIO_PIN_0);
        vTaskDelay(pdMS_TO_TICKS(500));
    }
}

// 任务 2
void vTaskLED2(void *pvParameters)
{
    for(;;)
    {
        HAL_GPIO_TogglePin(GPIOA, GPIO_PIN_1);
        vTaskDelay(pdMS_TO_TICKS(1000));
    }
}

// 主函数
int main(void)
{
    HAL_Init();
    SystemClock_Config();
    LED_Init();
    
    xTaskCreate(vTaskLED1, "LED1", 128, NULL, 2, NULL);
    xTaskCreate(vTaskLED2, "LED2", 128, NULL, 1, NULL);
    
    vTaskStartScheduler();
    for(;;);
}

关键点：① 任务函数必须是无限循环；② 必须有延时或阻塞，让出 CPU；③ 优先级高的任务先执行。

例题：按键任务通过队列通知 LED 任务切换状态 要求：按键按下时发送消息到队列，LED 任务接收消息后翻转 LED。

QueueHandle_t xQueue;

// 按键任务
void vTaskButton(void *pvParameters)
{
    uint8_t msg = 1;
    for(;;)
    {
        if(HAL_GPIO_ReadPin(GPIOB, GPIO_PIN_0) == GPIO_PIN_RESET)
        {
            vTaskDelay(20); // 消抖
            if(HAL_GPIO_ReadPin(GPIOB, GPIO_PIN_0) == GPIO_PIN_RESET)
            {
                xQueueSend(xQueue, &msg, portMAX_DELAY);
                while(HAL_GPIO_ReadPin(GPIOB, GPIO_PIN_0) == GPIO_PIN_RESET);
            }
        }
        vTaskDelay(10);
    }
}

// LED 任务
void vTaskLED(void *pvParameters)
{
    uint8_t received;
    for(;;)
    {
        if(xQueueReceive(xQueue, &received, portMAX_DELAY) == pdPASS)
        {
            HAL_GPIO_TogglePin(GPIOA, GPIO_PIN_0);
        }
    }
}

int main(void)
{
    xQueue = xQueueCreate(5, sizeof(uint8_t));
    xTaskCreate(vTaskButton, "Btn", 128, NULL, 2, NULL);
    xTaskCreate(vTaskLED, "LED", 128, NULL, 1, NULL);
    vTaskStartScheduler();
}

例题：外部中断通知任务处理事件 要求：按键触发外部中断，中断释放信号量，任务获取信号量后处理。

SemaphoreHandle_t xSemaphore;

// 中断服务程序
void EXTI0_IRQHandler(void)
{
    HAL_GPIO_EXTI_IRQHandler(GPIO_PIN_0);
}

void HAL_GPIO_EXTI_Callback(uint16_t GPIO_Pin)
{
    BaseType_t xHigherPriorityTaskWoken = pdFALSE;
    xSemaphoreGiveFromISR(xSemaphore, &xHigherPriorityTaskWoken);
    portYIELD_FROM_ISR(xHigherPriorityTaskWoken);
}

// 处理任务
void vTaskHandler(void *pvParameters)
{
    for(;;)
    {
        if(xSemaphoreTake(xSemaphore, portMAX_DELAY) == pdPASS)
        {
            printf("中断触发，处理事件！\r\n");
            HAL_GPIO_TogglePin(GPIOA, GPIO_PIN_0);
        }
    }
}

int main(void)
{
    xSemaphore = xSemaphoreCreateBinary();
    xTaskCreate(vTaskHandler, "Handler", 256, NULL, 2, NULL);
    vTaskStartScheduler();
}

例题：两个任务交替使用串口打印 要求：任务 A 和任务 B 都要使用串口，用互斥锁保护，避免打印混乱。

SemaphoreHandle_t xMutex;

void vTaskA(void *pvParameters)
{
    for(;;)
    {
        xSemaphoreTake(xMutex, portMAX_DELAY);
        printf("[TaskA] Hello from A\r\n");
        vTaskDelay(100);
        xSemaphoreGive(xMutex);
        vTaskDelay(500);
    }
}

void vTaskB(void *pvParameters)
{
    for(;;)
    {
        xSemaphoreTake(xMutex, portMAX_DELAY);
        printf("[TaskB] Hello from B\r\n");
        vTaskDelay(100);
        xSemaphoreGive(xMutex);
        vTaskDelay(700);
    }
}

int main(void)
{
    xMutex = xSemaphoreCreateMutex();
    xTaskCreate(vTaskA, "A", 128, NULL, 2, NULL);
    xTaskCreate(vTaskB, "B", 128, NULL, 1, NULL);
    vTaskStartScheduler();
}