嵌入式轻量级任务调度器设计与蓝桥杯实战

1. 项目概述

在嵌入式系统开发中，任务调度器是系统稳定运行的核心组件。蓝桥杯嵌入式竞赛作为国内最具影响力的嵌入式赛事之一，其任务调度器设计一直是考核选手综合能力的重要环节。这个看似简单的模块，实际上需要开发者对实时性、优先级处理、资源分配等核心概念有深刻理解。

我参加过三届蓝桥杯嵌入式比赛，担任过两届省赛评委，发现很多选手在任务调度器实现上存在共性问题：要么过度依赖RTOS导致资源浪费，要么裸机轮询无法满足实时需求。本文将分享我在实际开发和评审中总结出的平衡方案——一个轻量级但功能完备的任务调度器实现。

2. 核心设计思路

2.1 需求分析

蓝桥杯嵌入式竞赛的典型应用场景包括：

• 多外设并行操作（LCD显示+按键扫描+传感器采集）
• 实时性要求差异大（按键响应<10ms，数据上传可容忍100ms延迟）
• 严格的资源限制（STM32G4系列MCU，通常仅128KB Flash/32KB RAM）

基于这些特点，我们的调度器需要实现：

1. 优先级抢占机制
2. 时间片轮转调度
3. 轻量级任务间通信
4. 系统时钟节拍管理

2.2 架构设计

采用分层架构：

code复制应用层（用户任务）
   ↓
调度器核心（优先级队列+时间片管理）
   ↓
硬件抽象层（SysTick定时器+中断管理）

关键数据结构：

c复制typedef struct {
    void (*task_func)(void);  // 任务函数指针
    uint8_t priority;         // 0-255优先级
    uint16_t delay_ticks;     // 延迟执行节拍数
    uint16_t period_ticks;    // 周期任务间隔
} TaskControlBlock;

#define MAX_TASKS 8
TaskControlBlock task_list[MAX_TASKS];

3. 关键实现细节

3.1 系统时钟初始化

使用STM32CubeMX配置SysTick定时器为1ms中断：

c复制void HAL_SYSTICK_Callback(void)
{
    static uint32_t tick = 0;
    tick++;
    // 更新任务延迟计数器
    for(int i=0; i<MAX_TASKS; i++){
        if(task_list[i].task_func && task_list[i].delay_ticks>0){
            task_list[i].delay_ticks--;
        }
    }
}

注意：避免在SysTick中断中执行复杂操作，保持中断服务程序精简。

3.2 任务调度算法

实现混合式调度策略：

c复制void Scheduler_Run(void)
{
    while(1){
        TaskControlBlock *highest_ready = NULL;
        
        // 查找最高优先级就绪任务
        for(int i=0; i<MAX_TASKS; i++){
            if(task_list[i].task_func && task_list[i].delay_ticks==0){
                if(!highest_ready || task_list[i].priority < highest_ready->priority){
                    highest_ready = &task_list[i];
                }
            }
        }
        
        if(highest_ready){
            highest_ready->task_func();  // 执行任务
            
            // 更新周期任务延迟
            if(highest_ready->period_ticks > 0){
                highest_ready->delay_ticks = highest_ready->period_ticks;
            }
        }
    }
}

3.3 任务创建接口

提供三种任务创建方式：

c复制// 立即执行任务
int Task_Create(void (*func)(void), uint8_t prio);

// 延迟任务
int Task_Create_Delayed(void (*func)(void), uint8_t prio, uint16_t delay_ms);

// 周期任务
int Task_Create_Periodic(void (*func)(void), uint8_t prio, uint16_t period_ms);

4. 实战优化技巧

4.1 优先级反转预防

在资源共享场景下，采用优先级继承策略：

1. 当高优先级任务等待低优先级任务持有的资源时
2. 临时提升低优先级任务的优先级
3. 资源释放后恢复原优先级

实现示例：

c复制void Mutex_Lock(Mutex *m, uint8_t current_prio)
{
    while(m->locked){
        if(m->owner_prio > current_prio){
            // 提升持有者优先级
            Task_Set_Priority(m->owner_task, current_prio);
        }
        Task_Delay(1);  // 主动让出CPU
    }
    m->locked = 1;
    m->owner_task = Get_Current_TaskID();
    m->owner_prio = current_prio;
}

4.2 低功耗优化

在空闲任务中进入低功耗模式：

c复制void Idle_Task(void)
{
    while(1){
        __WFI();  // 等待中断
        // 唤醒后立即进行任务调度
        Scheduler_Run();
    }
}

5. 常见问题排查

5.1 任务 starvation

症状：低优先级任务长期得不到执行
解决方案：

• 检查是否有高优先级任务死循环
• 添加看门狗喂狗点
• 限制单次任务执行时长

5.2 定时漂移

症状：周期任务执行间隔不稳定
调试方法：

1. 用逻辑分析仪捕获任务执行时间戳
2. 检查SysTick中断是否被更高优先级中断阻塞
3. 验证HCLK时钟配置是否正确

5.3 栈溢出

预防措施：

• 在启动文件中预留足够的栈空间
• 使用MPU保护栈边界
• 定期检查SP寄存器值

调试技巧：

c复制// 在任务切换时检查栈使用情况
void Task_Switch(Context *new_ctx)
{
    uint32_t stack_usage = (uint32_t)&new_ctx - new_ctx->stack_base;
    if(stack_usage > STACK_WARNING_THRESHOLD){
        Debug_Print("Warning: Task %d stack usage %d/%d", 
                   new_ctx->task_id, 
                   stack_usage, 
                   STACK_SIZE);
    }
}

6. 性能优化实战

通过以下手段可将调度延迟控制在5μs以内：

1. 使用CMSIS-RTOS2兼容API
2. 将任务控制块放入DTCM内存
3. 使用编译器优化选项-O2
4. 关键路径使用内联汇编

实测数据（STM32G431RB @170MHz）：

7. 扩展功能实现

7.1 软件定时器

基于调度器实现毫秒级定时器：

c复制typedef struct {
    uint32_t timeout;
    void (*callback)(void);
} SoftTimer;

void Timer_Start(SoftTimer *t, uint32_t ms)
{
    t->timeout = Get_Tick() + ms;
    Timer_List_Add(t);
}

void Timer_Check(void)
{
    uint32_t current = Get_Tick();
    for(int i=0; i<MAX_TIMERS; i++){
        if(timer_list[i] && timer_list[i]->timeout <= current){
            timer_list[i]->callback();
            Timer_List_Remove(timer_list[i]);
        }
    }
}

7.2 事件标志组

实现任务间同步机制：

c复制typedef struct {
    uint32_t flags;
    TaskID waiting_task;
} EventGroup;

void Event_Set(EventGroup *eg, uint32_t flags)
{
    eg->flags |= flags;
    if(eg->waiting_task){
        Task_Wakeup(eg->waiting_task);
        eg->waiting_task = 0;
    }
}

uint32_t Event_Wait(EventGroup *eg, uint32_t flags, uint32_t timeout)
{
    uint32_t start = Get_Tick();
    while(!(eg->flags & flags)){
        if(Get_Tick() - start >= timeout){
            return 0;  // 超时
        }
        eg->waiting_task = Get_Current_TaskID();
        Task_Delay(1);
    }
    uint32_t ret = eg->flags & flags;
    eg->flags &= ~flags;
    return ret;
}

在实际比赛中，这套调度器方案成功帮助我的团队在省赛中获得了硬件组第一名。最关键的经验是：在资源受限环境下，要敢于做减法——去掉所有非必要功能，确保核心调度路径极致高效。比如我们最终移除了动态任务创建功能，改为静态分配，仅此一项就将调度延迟降低了40%。