RTOS 实时操作系统完全指南 2026

// FreeRTOS TCB 简化结构
typedef struct tskTaskControlBlock {
    StackType_t *pxTopOfStack;      // 栈顶指针（用于上下文切换）
    StackType_t *pxStack;           // 栈底指针（用于栈溢出检测）
    char pcTaskName[16];            // 任务名称（调试用）
    UBaseType_t uxPriority;         // 优先级（0 = 最低）
    TaskState_t eTaskState;         // 任务状态（运行/就绪/阻塞/挂起）
    TickType_t xBlockTime;          // 阻塞超时时间
    void *pvMutexesHeld;            // 持有的互斥量列表
    EventBits_t uxEventBits;        // 事件组标志
    // ... 更多字段
} TCB_t;

// 任务列表（调度器使用）
TCB_t *pxCurrentTCB;                // 当前运行任务的 TCB
TCB_t pxReadyTasksLists[configMAX_PRIORITIES];  // 就绪任务列表

// 伪代码：抢占式调度器
void vTaskSchedule(void) {
    TaskHandle_t highestPriorityTask = NULL;
    
    // 遍历所有优先级（从高到低）
    for (int prio = configMAX_PRIORITIES - 1; prio >= 0; prio--) {
        if (pxReadyTasksLists[prio] != NULL) {
            highestPriorityTask = pxReadyTasksLists[prio];
            break;  // 找到最高优先级任务
        }
    }
    
    // 如果有更高优先级任务，进行切换
    if (highestPriorityTask != pxCurrentTCB) {
        vTaskSwitchContext(highestPriorityTask);
    }
}

// FreeRTOS 任务创建示例
void vTaskFunction(void *pvParameters) {
    while (1) {
        // 任务代码
        GPIO_Toggle();
        vTaskDelay(pdMS_TO_TICKS(100));  // 延时 100ms
    }
}

// 创建任务
xTaskCreate(
    vTaskFunction,    // 任务函数
    "LED_Task",       // 任务名称
    1024,             // 栈大小（字）
    NULL,             // 参数
    3,                // 优先级（数字越大优先级越高）
    NULL              // 任务句柄
);

// FreeRTOS 配置
#define configUSE_TIME_SLICING 1      // 启用时间片轮转
#define configTICK_RATE_HZ 1000       // 系统滴答频率（1ms）

// 时间片 = configTICK_RATE_HZ 的倒数 = 1ms
// 每个同优先级任务执行 1ms 后切换到下一个

// 示例：两个同优先级任务
void vTask1(void *pvParameters) {
    while (1) {
        // 任务 1 代码
        vTaskDelay(pdMS_TO_TICKS(10));
    }
}

void vTask2(void *pvParameters) {
    while (1) {
        // 任务 2 代码
        vTaskDelay(pdMS_TO_TICKS(10));
    }
}

// 两个任务优先级相同，轮流执行
xTaskCreate(vTask1, "Task1", 512, NULL, 2, NULL);
xTaskCreate(vTask2, "Task2", 512, NULL, 2, NULL);

// FreeRTOS 配置
#define configUSE_PREEMPTION 0  // 禁用抢占，启用协作式调度

// 任务必须主动让出 CPU
void vTaskFunction(void *pvParameters) {
    while (1) {
        // 执行工作
        DoWork();
        
        // 主动让出 CPU（必须调用！）
        taskYIELD();
    }
}

; PendSV_Handler - 上下文切换的核心
PendSV_Handler:
    ; 禁用 SysTick 中断（防止切换过程中被打断）
    CPSID I
    
    ; 保存当前任务上下文
    MRS R0, PSP              ; 获取进程栈指针（PSP）
    STMDB R0!, {R4-R11}      ; 保存寄存器 R4-R11 到栈
    LDR R1, =pxCurrentTCB    ; 获取当前 TCB 地址
    LDR R2, [R1]             ; 读取当前 TCB 指针
    STR R0, [R2]             ; 保存 SP 到 TCB（保存上下文）
    
    ; 调用调度器选择下一个任务
    BL vTaskSwitchContext
    
    ; 恢复新任务上下文
    LDR R1, =pxCurrentTCB
    LDR R2, [R1]             ; 获取新 TCB
    LDR R0, [R2]             ; 从 TCB 读取 SP
    LDMIA R0!, {R4-R11}      ; 恢复寄存器 R4-R11
    MSR PSP, R0              ; 设置进程栈指针
    
    ; 恢复 SysTick 中断
    CPSIE I
    
    BX LR                    ; 返回（继续执行新任务）

// 方式 1：中断释放信号量，任务等待信号量
SemaphoreHandle_t xISR_Semaphore;

// 中断服务程序
void HAL_GPIO_EXTI_Callback(uint16_t GPIO_Pin) {
    BaseType_t xHigherPriorityTaskWoken = pdFALSE;
    
    // 在中断中释放信号量
    xSemaphoreGiveFromISR(xISR_Semaphore, &xHigherPriorityTaskWoken);
    
    // 如果有更高优先级任务被唤醒，触发上下文切换
    portYIELD_FROM_ISR(xHigherPriorityTaskWoken);
}

// 任务函数
void vTaskFunction(void *pvParameters) {
    while (1) {
        // 等待信号量（阻塞）
        if (xSemaphoreTake(xISR_Semaphore, portMAX_DELAY) == pdTRUE) {
            // 信号量到达，处理事件
            ProcessEvent();
        }
    }
}

// 方式 2：中断发送队列消息
QueueHandle_t xISR_Queue;

void TIM_IRQHandler(void) {
    uint32_t data = GetTimerValue();
    BaseType_t xHigherPriorityTaskWoken = pdFALSE;
    
    // 在中断中发送队列消息
    xQueueSendFromISR(xISR_Queue, &data, &xHigherPriorityTaskWoken);
    portYIELD_FROM_ISR(xHigherPriorityTaskWoken);
}

// 方式 3：使用任务通知（最快，推荐）
void EXTI_IRQHandler(void) {
    BaseType_t xHigherPriorityTaskWoken = pdFALSE;
    
    // 直接通知任务（无需信号量/队列对象）
    vTaskNotifyGiveFromISR(xTaskHandle, &xHigherPriorityTaskWoken);
    portYIELD_FROM_ISR(xHigherPriorityTaskWoken);
}

// 任务接收通知
void vTaskFunction(void *pvParameters) {
    while (1) {
        // 等待通知（替代 xSemaphoreTake）
        ulTaskNotifyTake(pdTRUE, portMAX_DELAY);
        ProcessEvent();
    }
}

// Cortex-M4 中断优先级配置
// 优先级分组：4 位抢占优先级，0 位子优先级
NVIC_SetPriorityGrouping(NVIC_PRIORITYGROUP_4);

// 配置中断优先级（0 = 最高，15 = 最低）
NVIC_SetPriority(SysTick_IRQn, 0);      // SysTick 最高优先级
NVIC_SetPriority(PendSV_IRQn, 15);      // PendSV 最低优先级（重要！）
NVIC_SetPriority(SVCall_IRQn, 0);       // SVC 最高优先级

// 注意：PendSV 必须设为最低优先级，确保其他中断不被延迟
// 否则会影响中断响应时间

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

// 释放信号量（中断/任务中）
xSemaphoreGive(xBinarySemaphore);

// 获取信号量（任务中）
if (xSemaphoreTake(xBinarySemaphore, portMAX_DELAY) == pdTRUE) {
    // 成功获取
    HandleEvent();
}

// 带超时的获取
if (xSemaphoreTake(xBinarySemaphore, pdMS_TO_TICKS(100)) == pdTRUE) {
    // 100ms 内收到信号
} else {
    // 超时
    HandleTimeout();
}

// 创建计数信号量（最大计数 10，初始计数 0）
SemaphoreHandle_t xCountingSemaphore = xSemaphoreCreateCounting(10, 0);

// 释放（计数 +1）
xSemaphoreGive(xCountingSemaphore);

// 获取（计数 -1）
xSemaphoreTake(xCountingSemaphore, portMAX_DELAY);

// 应用场景：处理批量数据
void DataAcquisition_Task(void *pvParameters) {
    while (1) {
        // 等待数据到达（可能一次到达多个）
        xSemaphoreTake(xCountingSemaphore, portMAX_DELAY);
        
        // 处理所有到达的数据
        while (uxSemaphoreGetCount(xCountingSemaphore) > 0) {
            ProcessData();
            xSemaphoreTake(xCountingSemaphore, 0);
        }
    }
}

// 创建互斥量
SemaphoreHandle_t xMutex = xSemaphoreCreateMutex();

// 获取互斥量
if (xSemaphoreTake(xMutex, portMAX_DELAY) == pdTRUE) {
    // 临界区：访问共享资源
    AccessSharedResource();
    
    // 释放互斥量
    xSemaphoreGive(xMutex);
}

// 互斥量 vs 信号量对比
| 特性 | 互斥量 | 信号量 |
|------|--------|--------|
| 所有权 | 有（谁获取谁释放） | 无 |
| 优先级继承 | 支持 | 不支持 |
| 嵌套获取 | 支持 | 不支持 |
| 使用场景 | 资源保护 | 同步/计数 |

// 创建队列（10 个消息，每个 32 字节）
QueueHandle_t xQueue = xQueueCreate(10, 32);

// 发送数据
int data = 42;
if (xQueueSend(xQueue, &data, portMAX_DELAY) == pdTRUE) {
    // 发送成功
}

// 接收数据
int received;
if (xQueueReceive(xQueue, &received, portMAX_DELAY) == pdTRUE) {
    // 接收成功，处理数据
    ProcessData(received);
}

// 带超时的接收
if (xQueueReceive(xQueue, &received, pdMS_TO_TICKS(100)) == pdTRUE) {
    // 100ms 内收到数据
} else {
    // 超时
}

// 队列前端发送（高优先级消息）
xQueueSendToFront(xQueue, &urgent_data, 0);

// 发送通知（中断中，最快）
void EXTI_IRQHandler(void) {
    BaseType_t xHigherPriorityTaskWoken = pdFALSE;
    vTaskNotifyGiveFromISR(xTaskHandle, &xHigherPriorityTaskWoken);
    portYIELD_FROM_ISR(xHigherPriorityTaskWoken);
}

// 接收通知（任务中）
void vTaskFunction(void *pvParameters) {
    while (1) {
        // 等待通知（替代 xSemaphoreTake）
        ulTaskNotifyTake(pdTRUE, portMAX_DELAY);
        // 处理事件
        ProcessEvent();
    }
}

// 性能对比
| IPC 机制 | 发送耗时 | 接收耗时 | 内存占用 |
|----------|---------|---------|---------|
| 任务通知 | ~0.5μs | ~0.5μs | 0 字节（内置在 TCB） |
| 二值信号量 | ~2μs | ~2μs | ~80 字节 |
| 消息队列 | ~5μs | ~5μs | 队列大小 + 开销 |

// 静态分配 TCB 和栈
StaticTask_t xTaskBuffer;
StackType_t xStack[1024];

TaskHandle_t xTask = xTaskCreateStatic(
    vTaskCode,
    "TaskName",
    1024,
    NULL,
    5,
    xStack,
    &xTaskBuffer
);

// 静态分配信号量
StaticSemaphore_t xSemaphoreBuffer;
SemaphoreHandle_t xSemaphore = xSemaphoreCreateBinaryStatic(&xSemaphoreBuffer);

// 优点：
// - 无内存碎片
// - 编译时确定内存使用
// - 无分配失败风险

// 缺点：
// - 灵活性差
// - 代码冗长

// heap_4.c 配置
#define configTOTAL_HEAP_SIZE ((size_t)(32 * 1024))  // 32KB 堆

// 内存分配
void *pv = pvPortMalloc(1024);  // 分配 1KB
vPortFree(pv);                   // 释放（自动合并相邻空闲块）

// 内存碎片问题：
// 频繁分配/释放不同大小的块会导致碎片
// heap_4.c 通过合并相邻空闲块缓解此问题

// 创建内存池（10 个块，每块 256 字节）
#define BLOCK_SIZE 256
#define NUM_BLOCKS 10
uint8_t ucMemoryPool[BLOCK_SIZE * NUM_BLOCKS];
uint8_t ucBlockStatus[NUM_BLOCKS];

void *pvGetBlock(void) {
    for (int i = 0; i < NUM_BLOCKS; i++) {
        if (ucBlockStatus[i] == 0) {
            ucBlockStatus[i] = 1;
            return &ucMemoryPool[i * BLOCK_SIZE];
        }
    }
    return NULL;  // 无可用块
}

void vReleaseBlock(void *pv) {
    int index = ((uint8_t*)pv - ucMemoryPool) / BLOCK_SIZE;
    ucBlockStatus[index] = 0;
}

// FreeRTOS 互斥量实现优先级继承
SemaphoreHandle_t xMutex = xSemaphoreCreateMutex();

// 当高优先级任务 H 请求互斥量时：
// 1. 检测到互斥量被 L 持有
// 2. 临时提升 L 的优先级到 H 的级别
// 3. L 释放互斥量后，恢复原始优先级

// 伪代码
void prvGiveMutexFromISR(StaticSemaphore_t *pxMutex, TaskHandle_t pxHolder) {
    if (pxMutex->ucQueueType == queueQUEUE_TYPE_MUTEX) {
        // 恢复持有者的原始优先级
        vTaskPrioritySet(pxHolder, pxMutex->uxBasePriority);
    }
}

// 使用互斥量（自动启用优先级继承）
void AccessSharedResource(void) {
    if (xSemaphoreTake(xMutex, portMAX_DELAY) == pdTRUE) {
        // 临界区
        SharedResource++;
        xSemaphoreGive(xMutex);
    }
}

// 错误示例：频繁切换
for (int i = 0; i < 100; i++) {
    xQueueSend(xQueue, &data[i], portMAX_DELAY);
    // 每次都触发切换
}

// 正确示例：批量处理
for (int i = 0; i < 100; i++) {
    xQueueSend(xQueue, &data[i], 0);  // 不阻塞
}
taskYIELD();  // 手动切换一次

// 使用指针队列
QueueHandle_t xPtrQueue = xQueueCreate(10, sizeof(void*));

// 发送指针
Data_t *pData = pvPortMalloc(sizeof(Data_t));
xQueueSend(xPtrQueue, &pData, 0);

// 接收指针
Data_t *pReceived;
xQueueReceive(xPtrQueue, &pReceived, portMAX_DELAY);

// 处理完成后释放
vPortFree(pReceived);

// Cortex-M7 紧耦合内存
// 将关键代码放在 ITCM（零等待执行）
void __attribute__((section(".itcm"))) Critical_ISR_Handler(void) {
    // 实时性要求极高的代码
}

// 将关键数据放在 DTCM（零等待访问）
uint32_t __attribute__((section(".dtcm"))) Critical_Data[256];

// 延迟过程调用（Deferred Procedure Call）
SemaphoreHandle_t xDPC_Semaphore;

void Fast_ISR_Handler(void) {
    // 只做最紧急的工作（< 1μs）
    ClearInterruptFlag();
    ReadHardwareRegister();
    
    // 唤醒 DPC 任务处理剩余工作
    BaseType_t xHigherPriorityTaskWoken = pdFALSE;
    xSemaphoreGiveFromISR(xDPC_Semaphore, &xHigherPriorityTaskWoken);
    portYIELD_FROM_ISR(xHigherPriorityTaskWoken);
}

void vDPCTask(void *pvParameters) {
    while (1) {
        xSemaphoreTake(xDPC_Semaphore, portMAX_DELAY);
        // 处理非紧急工作（可耗时较长）
        ProcessDeferredWork();
    }
}

// FreeRTOS 配置
#define configCHECK_FOR_STACK_OVERFLOW 2  // 启用栈溢出检测

// 栈溢出钩子
void vApplicationStackOverflowHook(TaskHandle_t xTask, char *pcTaskName) {
    // 栈溢出！记录错误
    Error_Log("Stack overflow: %s", pcTaskName);
    
    // 调试：打印调用栈
    PrintCallStack(xTask);
    
    // 处理：重启或进入安全模式
    while (1);
}

// 运行时监测栈余量
void CheckStackUsage(void) {
    UBaseType_t uxHighWaterMark = uxTaskGetStackHighWaterMark(NULL);
    if (uxHighWaterMark < 50) {
        // 栈余量不足 50 字
        Warning_Log("Low stack: %d words remaining", uxHighWaterMark);
    }
}

// 检测死锁的简单方法
void DetectDeadlock(void) {
    TaskStatus_t *pxTaskStatusArray;
    UBaseType_t uxArraySize = uxTaskGetNumberOfTasks();
    
    pxTaskStatusArray = pvPortMalloc(uxArraySize * sizeof(TaskStatus_t));
    
    if (pxTaskStatusArray != NULL) {
        uxArraySize = uxTaskGetSystemState(pxTaskStatusArray, uxArraySize, NULL);
        
        // 检查是否有任务长时间阻塞
        for (int i = 0; i < uxArraySize; i++) {
            if (pxTaskStatusArray[i].eCurrentState == eBlocked) {
                if (pxTaskStatusArray[i].xCurrentPriority < LOW_PRIORITY_THRESHOLD) {
                    // 低优先级任务长时间阻塞，可能死锁
                    Warning_Log("Possible deadlock: %s", pxTaskStatusArray[i].pcTaskName);
                }
            }
        }
        
        vPortFree(pxTaskStatusArray);
    }
}

// 启用运行时统计
#define configGENERATE_RUN_TIME_STATS 1
#define portCONFIGURE_TIMER_FOR_RUN_TIME_STATS() ConfigureTimer()
#define portGET_RUN_TIME_COUNTER_VALUE() GetTimerCount()

// 获取任务 CPU 使用率
void PrintTaskCPUUsage(void) {
    TaskStatus_t *pxTaskStatusArray;
    UBaseType_t uxArraySize = uxTaskGetNumberOfTasks();
    uint32_t ulTotalRunTime;
    
    pxTaskStatusArray = pvPortMalloc(uxArraySize * sizeof(TaskStatus_t));
    
    if (pxTaskStatusArray != NULL) {
        uxArraySize = uxTaskGetSystemState(pxTaskStatusArray, uxArraySize, &ulTotalRunTime);
        ulTotalRunTime /= 100;  // 转为百分比
        
        printf("Task Name\tPriority\tCPU%%\n");
        for (int i = 0; i < uxArraySize; i++) {
            printf("%s\t%d\t%d%%\n", 
                   pxTaskStatusArray[i].pcTaskName,
                   pxTaskStatusArray[i].uxCurrentPriority,
                   pxTaskStatusArray[i].ulRunTimeCounter / ulTotalRunTime);
        }
        
        vPortFree(pxTaskStatusArray);
    }
}