裸机下多任务框架设计与实现（gd32裸机配置lwip 网络ping不通）

在嵌入式系统中，特别是在没有操作系统支持的裸机环境下，实现多任务执行是一个常见的挑战。本文将详细介绍一种基于定时器的多任务框架设计，通过全局时钟和状态机机制，实现任务的非阻塞调度，确保任务执行中不会出现超过5ms的阻塞延时。

系统需求与设计目标

在裸机环境下实现多任务框架，需要满足以下核心需求：

1. 全局时钟：通过硬件定时器实现一个统一的时钟基准，用于任务调度。
2. 任务运行判断：每个任务根据全局时钟自行判断是否需要运行。
3. 无阻塞延时：任务执行过程中，任何操作的阻塞时间不得超过5ms。
4. 状态机机制：通过状态机对任务进行切片处理，避免阻塞并实现多任务的“并发”执行。

系统架构

1. 全局时钟实现

全局时钟是整个框架的核心，负责为任务调度提供时间基准。我们利用硬件定时器（如Cortex-M系列的SysTick）生成周期性中断，在中断服务例程（ISR）中更新一个全局变量global_tick，表示系统运行的tick数。

• 实现步骤： 配置定时器以固定周期（如1ms）触发中断。在中断处理函数中递增global_tick。
• 代码示例：

volatile uint32_t global_tick = 0;

void SysTick_Handler(void)

{

global_tick++;

}

2. 任务定义与管理

任务是框架的基本执行单元，每个任务需要包含以下信息：

• 任务函数指针：指向任务的具体执行逻辑。
• 运行周期：任务需要周期性运行的时间间隔（以tick为单位）。
• 上次运行时间：记录任务上次执行的global_tick值。
• 状态变量：用于状态机，跟踪任务的执行阶段。

我们定义一个任务结构体如下：

typedef struct {

void (*task_func)(void); // 任务函数指针

uint32_t period; // 运行周期（tick）

uint32_t last_run; // 上次运行时间（tick）

uint32_t state; // 状态机状态

} Task;

任务存储在一个全局任务列表中，例如：

Task task_list[10]; // 假设最多支持10个任务

uint8_t task_count = 0; // 当前任务数量

3. 任务调度

任务调度在主循环中执行，通过检查全局时钟和任务的运行周期，判断哪些任务需要运行：

• 对于每个任务，计算global_tick - task.last_run。
• 如果结果大于等于task.period，则调用任务函数并更新task.last_run。
• 调度代码：

void task_scheduler(void)

{

for (uint8_t i = 0; i < task_count; i++)

{

Task *task = &task_list[i];

if (global_tick - task->last_run >= task->period)

{

task->task_func();

task->last_run = global_tick;

}

}

}

• 主循环：

int main(void)

{

// 初始化定时器和其他硬件

while (1)

{

task_scheduler();

}

}

4. 状态机机制

为了避免任务中出现超过5ms的阻塞延时，每个任务被设计为一个状态机。任务的执行逻辑被切分为多个小的状态，每个状态的执行时间严格控制在5ms以内。

• 设计原则： 任务函数在每次调用时，根据当前状态执行一个代码片段。执行完成后更新状态变量，等待下次调度。如果某个操作耗时较长（如等待硬件响应），将其分解为多个状态。
• 示例任务： 假设一个任务需要点亮LED，等待500ms后熄灭：

void led_task(void) {

static uint32_t state = 0;

static uint32_t start_tick = 0;

switch (state)

{

case 0: // 点亮LED

LED_ON();

start_tick = global_tick;

state = 1;

break;

case 1: // 检查延时

if (global_tick - start_tick >= 500)

{

LED_OFF();

state = 0; // 回到初始状态

}

break;

}

}

• 任务注册：

void register_task(Task *task, void (*func)(void), uint32_t period)

{

task->task_func = func;

task->period = period;

task->last_run = 0;

task->state = 0;

task_list[task_count++] = *task;

}

实现细节与优化

1. 避免阻塞

• 时间控制：每个状态的代码必须经过测试，确保执行时间不超过5ms。
• 分解长操作：对于耗时操作（如I2C通信），使用状态机分步完成。例如，发送起始信号、等待ACK、发送数据等分别放在不同状态。

2. 任务优先级

当前设计中所有任务平等调度。如果需要优先级，可以在task_scheduler中按优先级排序任务列表，或为高优先级任务分配更短的调度周期。

3. 资源限制

任务数量受限于task_list大小和MCU性能。开发者需根据硬件资源调整框架参数。

示例代码

以下是一个完整的示例，包含两个任务：LED闪烁和串口打印。

#include <stdint.h>

volatile uint32_t global_tick = 0;

Task task_list[10];

uint8_t task_count = 0;

void SysTick_Handler(void)

{

global_tick++;

}

void led_task(void)

{

static uint32_t state = 0;

static uint32_t start_tick = 0;

switch (state)

{

case 0:

LED_ON();

start_tick = global_tick;

state = 1;

break;

case 1:

if (global_tick - start_tick >= 500) {

LED_OFF();

start_tick = global_tick;

state = 0;

}

break;

}

}

void uart_task(void) {

static uint32_t state = 0;

switch (state) {

case 0:

UART_Send("Hello\n");

state = 1;

break;

case 1:

// 假设发送完成需要检查标志位

if (UART_TxComplete()) {

state = 0;

}

break;

}

}

void task_scheduler(void) {

for (uint8_t i = 0; i < task_count; i++) {

Task *task = &task_list[i];

if (global_tick - task->last_run >= task->period) {

task->task_func();

task->last_run = global_tick;

}

}

}

int main(void) {

Task task1, task2;

// 初始化硬件（略）

SysTick_Config(1000); // 1ms中断

register_task(&task1, led_task, 100); // 每100ms运行一次

register_task(&task2, uart_task, 1000); // 每1000ms运行一次

while (1) {

task_scheduler();

}

}

优势与局限

优势

• 轻量级：无需操作系统，减少资源开销。
• 可预测性：基于定时器的调度确保任务执行的确定性。
• 灵活性：状态机机制适用于各种复杂任务。

局限

• 开发复杂度：状态机的设计和调试需要额外工作。
• 扩展性有限：任务数量和复杂度受硬件资源限制。

结论

通过定时器实现的全局时钟和状态机机制，我们在裸机环境下构建了一个高效的多任务框架。该方法特别适用于资源受限的嵌入式系统，能够在不依赖操作系统的情况下，实现任务的非阻塞调度和并发执行。开发者可以根据具体应用需求，进一步优化任务管理和调度策略。