基于C++的多任务应用代码框架

Tue, 28 Jan 2025 23:09:28 +0800

项目结构

project/
├── arch/
│   ├── arch_stm32.cpp      // STM32 的上下文切换实现
│   ├── arch_stm32.hpp      // STM32 的硬件抽象层接口
│   ├── arch_pc.cpp         // PC 的上下文切换实现
│   ├── arch_pc.hpp         // PC 的硬件抽象层接口
│   └── arch.hpp            // 硬件抽象层通用接口
├── hal/
│   ├── hal_stm32.cpp       // STM32 的 HAL 实现
│   ├── hal_stm32.hpp       // STM32 的 HAL 接口
│   ├── hal_pc.cpp          // PC 的 HAL 实现
│   ├── hal_pc.hpp          // PC 的 HAL 接口
│   └── hal.hpp             // HAL 通用接口
├── drivers/
│   ├── uart/               // 串口驱动
│   │   ├── uart_stm32.cpp  // STM32 串口驱动
│   │   ├── uart_pc.cpp     // PC 串口驱动
│   │   └── uart.hpp        // 串口驱动接口
│   ├── display/            // 显示驱动
│   │   ├── display_8080.cpp // 8080 接口显示驱动
│   │   ├── display_rgb.cpp  // RGB 接口显示驱动
│   │   ├── display_mipi.cpp // MIPI 接口显示驱动
│   │   ├── display_vbe.cpp  // BIOS VBE3.0 显示驱动
│   │   ├── display_uefi.cpp // UEFI 图形显示驱动
│   │   └── display.hpp      // 显示驱动接口
│   ├── audio/              // 声音驱动
│   │   ├── audio_stm32.cpp // STM32 声音驱动
│   │   ├── audio_pc.cpp    // PC 声音驱动
│   │   └── audio.hpp       // 声音驱动接口
│   ├── input/              // 输入设备驱动
│   │   ├── keyboard.cpp    // 键盘驱动
│   │   ├── mouse.cpp       // 鼠标驱动
│   │   └── input.hpp       // 输入设备驱动接口
│   └── drivers.hpp         // 驱动模块通用接口
├── scheduler/
│   ├── scheduler.cpp       // 任务调度器实现
│   └── scheduler.hpp       // 任务调度器接口
├── tasks/
│   ├── task_led.cpp        // LED 任务实现
│   ├── task_button.cpp     // 按钮任务实现
│   └── tasks.hpp           // 任务函数声明
├── task_manager/
│   ├── task_manager.cpp    // 任务管理器实现
│   └── task_manager.hpp    // 任务管理器接口
├── task_base/
│   ├── task_base.cpp       // 任务基类实现
│   └── task_base.hpp       // 任务基类接口
└── main.cpp                // 主程序

#include "arch.h"
#include "stm32f1xx_hal.h"

// 保存和恢复上下文的汇编代码
__asm void arch_context_switch(uint32_t** current_stack, uint32_t* next_stack) {
    // 保存当前任务的上下文
    PUSH {R4-R11}          // 保存寄存器
    STR SP, [R0]           // 保存当前堆栈指针

    // 切换到下一个任务的上下文
    LDR SP, [R1]           // 加载下一个任务的堆栈指针
    POP {R4-R11}           // 恢复寄存器
    BX LR                  // 返回
}

arch.hpp（硬件抽象层接口）


#ifndef ARCH_HPP
#define ARCH_HPP

#include <cstdint>

class Arch {
public:
    // 上下文切换函数
    static void contextSwitch(uint32_t** currentStack, uint32_t* nextStack);

    // 初始化硬件相关功能
    static void init();
};

#endif // ARCH_HPP

arch_stm32.cpp（STM32 的上下文切换实现）


#include "arch.hpp"
#include "stm32f1xx_hal.h"

// 保存和恢复上下文的汇编代码
extern "C" void arch_context_switch(uint32_t** currentStack, uint32_t* nextStack);

void Arch::contextSwitch(uint32_t** currentStack, uint32_t* nextStack) {
    arch_context_switch(currentStack, nextStack);
}

void Arch::init() {
    HAL_Init();
    SystemClock_Config();
}

hal.hpp（HAL 接口）


#ifndef HAL_HPP
#define HAL_HPP

class HAL {
public:
    // 初始化 GPIO
    static void init();

    // 切换 GPIO 状态
    static void togglePin(int pin);
};

#endif // HAL_HPP

hal_stm32.cpp（STM32 的 HAL 实现）


#include "hal.hpp"
#include "stm32f1xx_hal.h"

void HAL::init() {
    __HAL_RCC_GPIOA_CLK_ENABLE();
    __HAL_RCC_GPIOB_CLK_ENABLE();

    GPIO_InitTypeDef GPIO_InitStruct = {0};
    GPIO_InitStruct.Pin = GPIO_PIN_5 | GPIO_PIN_0;
    GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP;
    GPIO_InitStruct.Pull = GPIO_NOPULL;
    GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW;
    HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);
    HAL_GPIO_Init(GPIOB, &GPIO_InitStruct);
}

void HAL::togglePin(int pin) {
    if (pin == 5) {
        HAL_GPIO_TogglePin(GPIOA, GPIO_PIN_5);
    } else if (pin == 0) {
        HAL_GPIO_TogglePin(GPIOB, GPIO_PIN_0);
    }
}

scheduler.hpp（任务调度器接口）

#ifndef SCHEDULER_HPP
#define SCHEDULER_HPP

#include <cstdint>
#include <functional>

class Scheduler {
public:
    // 任务函数类型
    using TaskFunction = std::function<void()>;

    // 添加任务
    static void addTask(TaskFunction taskFunc);

    // 启动调度器
    static void start();

private:
    // 任务结构体
    struct Task {
        TaskFunction taskFunction; // 任务函数
        uint32_t* stackPointer;    // 任务堆栈指针
        uint32_t stack[64];        // 任务堆栈
    };

    static const int MAX_TASKS = 3;
    static Task taskQueue[MAX_TASKS];
    static int currentTaskIndex;
};

#endif // SCHEDULER_HPP

scheduler.cpp（任务调度器实现）


#include "scheduler.hpp"
#include "arch.hpp"

Scheduler::Task Scheduler::taskQueue[Scheduler::MAX_TASKS];
int Scheduler::currentTaskIndex = -1;

void Scheduler::addTask(TaskFunction taskFunc) {
    static int taskCount = 0;
    if (taskCount < MAX_TASKS) {
        taskQueue[taskCount].taskFunction = taskFunc;
        taskQueue[taskCount].stackPointer = taskQueue[taskCount].stack + 63; // 初始化堆栈指针
        taskCount++;
    }
}

void Scheduler::start() {
    if (currentTaskIndex == -1) {
        currentTaskIndex = 0;
        taskQueue[currentTaskIndex].taskFunction();
    }
}

extern "C" void SysTick_Handler(void) {
    HAL_IncTick(); // 更新 HAL 库的 tick

    // 任务切换
    if (Scheduler::currentTaskIndex != -1) {
        int nextTaskIndex = (Scheduler::currentTaskIndex + 1) % Scheduler::MAX_TASKS;
        Arch::contextSwitch(&Scheduler::taskQueue[Scheduler::currentTaskIndex].stackPointer,
                            Scheduler::taskQueue[nextTaskIndex].stackPointer);
        Scheduler::currentTaskIndex = nextTaskIndex;
    }
}

上下文切换（PC 版）


// arch_pc.hpp
#ifndef ARCH_PC_HPP
#define ARCH_PC_HPP

#include <cstdint>
#include <csetjmp>

class Arch {
public:
    // 上下文切换函数
    static void contextSwitch(uint32_t** currentStack, uint32_t* nextStack);

    // 初始化硬件相关功能
    static void init();
};

#endif // ARCH_PC_HPP


// arch_pc.cpp
#include "arch_pc.hpp"
#include <iostream>

void Arch::contextSwitch(uint32_t** currentStack, uint32_t* nextStack) {
    // 使用 setjmp/longjmp 实现上下文切换
    static jmp_buf env;
    if (setjmp(env) == 0) {
        // 保存当前上下文
        *currentStack = reinterpret_cast<uint32_t*>(&env);
        // 切换到下一个上下文
        longjmp(env, 1);
    }
}

void Arch::init() {
    std::cout << "Arch initialized for PC." << std::endl;
}

定时器（PC 版）


// hal_pc.hpp
#ifndef HAL_PC_HPP
#define HAL_PC_HPP

#include <chrono>
#include <thread>

class HAL {
public:
    // 初始化 GPIO
    static void init();

    // 切换 GPIO 状态
    static void togglePin(int pin);

    // 延时函数
    static void delay(uint32_t ms);
};

#endif // HAL_PC_HPP


// hal_pc.cpp
#include "hal_pc.hpp"
#include <iostream>

void HAL::init() {
    std::cout << "HAL initialized for PC." << std::endl;
}

void HAL::togglePin(int pin) {
    std::cout << "Toggling pin " << pin << std::endl;
}

void HAL::delay(uint32_t ms) {
    std::this_thread::sleep_for(std::chrono::milliseconds(ms));
}

任务实现（PC 版）


// task_led.cpp
#include "task_base.hpp"
#include "hal_pc.hpp"

class TaskLed : public TaskBase {
public:
    TaskLed() : TaskBase(taskFunction, 128, 1) {}

private:
    static void taskFunction() {
        while (true) {
            HAL::togglePin(5); // 切换 LED 状态
            HAL::delay(500);   // 延时 500ms
        }
    }
};

// 静态对象，自动注册任务
static TaskLed taskLed;


// task_button.cpp
#include "task_base.hpp"
#include "hal_pc.hpp"

class TaskButton : public TaskBase {
public:
    TaskButton() : TaskBase(taskFunction, 128, 2) {}

private:
    static void taskFunction() {
        while (true) {
            HAL::togglePin(0); // 切换另一个 LED 状态
            HAL::delay(100);   // 延时 100ms
        }
    }
};

// 静态对象，自动注册任务
static TaskButton taskButton;

调度器（PC 版）

调度器的实现与之前相同，直接从任务管理器中获取任务并调度。

嵌入式架构 on 软件开发大郭的技术博客

基于C++的多任务应用代码框架

项目结构

arch.hpp（硬件抽象层接口）

arch_stm32.cpp（STM32 的上下文切换实现）

hal.hpp（HAL 接口）

hal_stm32.cpp（STM32 的 HAL 实现）

scheduler.hpp（任务调度器接口）

scheduler.cpp（任务调度器实现）

上下文切换（PC 版）

定时器（PC 版）

任务实现（PC 版）

调度器（PC 版）