MCU开发必备：时间片轮询任务调度实战指南（附STM32代码）

MCU开发必备：时间片轮询任务调度实战指南（附STM32代码）

在嵌入式开发的世界里，裸机编程仍然占据着重要地位。当你面对STM32这样的MCU平台，需要同时处理按键检测、传感器采集、屏幕刷新等多个周期性任务时，一个优雅的时间片轮询调度方案能让你事半功倍。本文将带你深入三种实现方式，从最基础的标志位法到完整的调度框架，每种方法都配有可直接移植的STM32代码示例。

1. 时间片轮询的核心概念与应用场景

时间片轮询本质上是一种通过时间划分来调度多个任务的技术。想象一下餐厅里忙碌的服务员，他不需要一直盯着某一个顾客，而是按照固定的节奏依次检查每桌的需求——这就是时间片轮询的生动比喻。

在嵌入式系统中，这种技术特别适合以下典型场景：

• 人机交互：每20ms扫描一次按键状态，防止抖动
• 数据采集：每100ms读取一次温度传感器数据
• 显示刷新：每10ms更新一段LCD屏幕内容
• 设备控制：电机每运行10秒后停止1分钟

// 典型任务示例 void read_sensor() { /* 传感器读取实现 */ } void check_key() { /* 按键检测实现 */ } void update_lcd() { /* 屏幕刷新实现 */ }

与RTOS相比，时间片轮询的优势在于：

提示：当你的任务数量超过8个或需要复杂同步时，建议考虑RTOS方案

2. 基础实现方案对比与选择

2.1 标志位法：简单但难以维护

这是最直观的实现方式，通过在定时器中断中设置标志位，在主循环中检测并执行对应任务。

// 全局标志位 volatile uint8_t key_flag = 0; volatile uint8_t sensor_flag = 0; // 1ms定时器中断 void TIM2_IRQHandler() { static uint16_t tick = 0; if(TIM2->SR & TIM_SR_UIF) { TIM2->SR &= ~TIM_SR_UIF; tick++; if(tick % 20 == 0) key_flag = 1; // 20ms按键检测 if(tick % 100 == 0) sensor_flag = 1; // 100ms传感器读取 } } int main() { // 硬件初始化... while(1) { if(key_flag) { key_flag = 0; check_key(); } if(sensor_flag) { sensor_flag = 0; read_sensor(); } } }

优点：

• 实现简单直观
• 适合初学者理解

缺点：

• 标志位数量随任务增长
• 全局变量多，耦合度高
• 难以实现动态调整周期

2.2 时间戳比对法：减少全局变量

这种方法利用系统滴答时钟和上次执行时间戳进行比较，避免了大量标志位。

volatile uint32_t systick = 0; void SysTick_Handler() { systick++; } uint32_t millis() { return systick; } int main() { uint32_t last_key = 0, last_sensor = 0; while(1) { uint32_t now = millis(); if(now - last_key >= 20) { last_key = now; check_key(); } if(now - last_sensor >= 100) { last_sensor = now; read_sensor(); } } }

改进后的版本将时间判断逻辑封装到函数内部：

typedef struct { uint32_t interval; uint32_t last_run; void (*task)(void); } Task; void run_task(Task* t, uint32_t now) { if(now - t->last_run >= t->interval) { t->last_run = now; t->task(); } }

3. 高级时间片调度框架实现

基于前两种方法的不足，我们可以设计一个完整的调度框架，具有以下特性：

1. 统一的任务管理接口
2. 动态调整任务周期
3. 任务执行时间统计
4. 低耦合度的设计

3.1 数据结构设计

#define MAX_TASKS 8 typedef struct { void (*func)(void); // 任务函数指针 uint32_t interval; // 执行间隔(ms) uint32_t last_run; // 上次执行时间戳 uint8_t enabled; // 任务使能标志 uint32_t run_time; // 最近一次执行耗时(us) } Task; typedef struct { Task tasks[MAX_TASKS]; uint8_t count; uint32_t sys_time; } Scheduler;

3.2 核心调度实现

void scheduler_init(Scheduler* sched) { sched->count = 0; sched->sys_time = 0; } uint8_t scheduler_add(Scheduler* sched, void (*task)(void), uint32_t interval) { if(sched->count >= MAX_TASKS) return 0; sched->tasks[sched->count] = (Task){ .func = task, .interval = interval, .last_run = 0, .enabled = 1, .run_time = 0 }; sched->count++; return 1; } void scheduler_run(Scheduler* sched) { uint32_t now = sched->sys_time; for(uint8_t i=0; i<sched->count; i++) { Task* t = &sched->tasks[i]; if(t->enabled && (now - t->last_run >= t->interval)) { uint32_t start = DWT->CYCCNT; // 使用DWT计数器测量时间 t->func(); t->run_time = (DWT->CYCCNT - start) / (SystemCoreClock/1000000); t->last_run = now; } } } // 1ms定时器中断更新系统时间 void TIMx_IRQHandler() { if(TIMx->SR & TIM_SR_UIF) { TIMx->SR &= ~TIM_SR_UIF; scheduler.sys_time++; } }

3.3 实际使用示例

Scheduler scheduler; void task1() { /* ... */ } void task2() { /* ... */ } int main() { // 初始化硬件和调度器 scheduler_init(&scheduler); // 添加任务 scheduler_add(&scheduler, task1, 10); // 每10ms执行 scheduler_add(&scheduler, task2, 100); // 每100ms执行 while(1) { scheduler_run(&scheduler); __WFI(); // 进入低功耗模式 } }

4. 性能优化与高级技巧

4.1 动态调整任务周期

void scheduler_set_interval(Scheduler* sched, uint8_t id, uint32_t interval) { if(id < sched->count) { sched->tasks[id].interval = interval; } }

4.2 任务执行时间监控

void scheduler_monitor(Scheduler* sched) { for(uint8_t i=0; i<sched->count; i++) { Task* t = &sched->tasks[i]; printf("Task%d: %luus\n", i, t->run_time); // 如果任务执行时间超过间隔的50%，发出警告 if(t->run_time > t->interval * 500) { printf("Warning: Task%d overrun!\n", i); } } }

4.3 低功耗优化

uint8_t scheduler_get_next_timeout(Scheduler* sched) { uint32_t min_timeout = 0xFFFFFFFF; uint32_t now = sched->sys_time; for(uint8_t i=0; i<sched->count; i++) { Task* t = &sched->tasks[i]; if(!t->enabled) continue; uint32_t elapsed = now - t->last_run; if(elapsed >= t->interval) return 0; // 有任务需要立即执行 uint32_t remaining = t->interval - elapsed; if(remaining < min_timeout) { min_timeout = remaining; } } return min_timeout; // 返回可休眠的最长时间(ms) } // 在主循环中使用 uint32_t timeout = scheduler_get_next_timeout(&scheduler); if(timeout > 0) { HAL_PWR_EnterSLEEPMode(PWR_MAINREGULATOR_ON, PWR_SLEEPENTRY_WFI); }

4.4 任务优先级实现

通过简单的扩展，可以实现基本优先级机制：

void scheduler_run_priority(Scheduler* sched) { uint32_t now = sched->sys_time; // 第一轮：执行高优先级任务(0-3) for(uint8_t i=0; i<sched->count && i<4; i++) { Task* t = &sched->tasks[i]; if(t->enabled && (now - t->last_run >= t->interval)) { t->func(); t->last_run = now; } } // 第二轮：执行低优先级任务(4-7) for(uint8_t i=4; i<sched->count; i++) { Task* t = &sched->tasks[i]; if(t->enabled && (now - t->last_run >= t->interval)) { t->func(); t->last_run = now; } } }