C++手搓RTOS

Eplankton

感谢EIDE的帮助，感谢作者的付出，新年快乐。
Gitee：https://gitee.com/Eplankton/mos-stm32
GitHub：https://github.com/Eplankton/mos-stm32

MOS-STM32 🦉

介绍 🚀

 A_A       _
o'' )_____//    [MOS-STM32]
 `_/  MOS  )    STM32F4, Cortex-M上的简单RTOS
 (_(_/--(_/     MOS <=> Mini-RTOS

- Board: Nucleo-144 F429ZI
- MCU:   STM32F429ZIT6 (256KB SRAM, 2MB FLASH)

cat~

仓库 🌏

Gitee | GitHub

结构 👾

USR/src

src
├── drivers                  硬件设备驱动抽象层(SPL, HAL...)
│   ├── stm32f4xx            STM32F4xx 系列的片上外设(USART, I2C, SPI...)
│   └── device               其他元件(LED, LCD...)
│
├── mos
│   ├── config.h             配置系统宏
│   ├── arch                 硬件架构相关
│   │   └── cpu.hpp          上下文切换汇编代码
│   │
│   ├── kernel               内核(硬件无关)
│   │   ├── macro.hpp        系统配置宏
│   │   ├── type.hpp         基础类型
│   │   ├── concepts.hpp     C++20 Concepts(可选)
│   │   ├── data_type.hpp    基本数据结构
│   │   ├── alloc.hpp        静态/动态内存分配
│   │   ├── global.hpp       内核全局变量
│   │   ├── printf.c         线程安全的 printf
│   │   ├── task.hpp         任务创建、阻塞、挂起、终止...
│   │   ├── sync.hpp         同步原语
│   │   ├── scheduler.hpp    调度器
│   │   └── utils.hpp        其他工具
│   │
│   ├── kernel.hpp           内核模块导入
│   └── shell.hpp            简单的 Shell
│
├── user
│   ├── gui                  GUI 相关
│   │   ├── GuiLite.h        GuiLite 框架
│   │   └── UICode.cpp       自定义图形界面
│   │
│   ├── global.hpp           用户全局变量
│   ├── bsp.hpp              板级支持包
│   ├── app.hpp              用户函数
│   └── test.hpp             测试函数
│
├── main.cpp                 入口函数
└── stm32f4xx_it.cpp         中断处理函数(部分)

示例 🍎

Shell交互
shell_demo

Mutex测试
mutex_test

LCD驱动与GUI库
lcd
gui

// MOS Kernel & Shell
#include "mos/kernel.hpp"
#include "mos/shell.hpp"

// HAL and device 
#include "drivers/stm32f4xx/hal.hpp"
#include "drivers/device/led.hpp"

namespace MOS::UserGlobal
{
    using namespace HAL::STM32F4xx;
    using namespace Driver::Device;
    using DataType::RxBuffer;
    
    // Serial TX/RX
    auto& uart = convert(USARTx);

    // RX Buffer
    RxBuffer<Macro::RX_BUF_SIZE> rx_buf;

    // LED red, green, blue
    LED_t leds[] = {...};
}

namespace MOS::Bsp
{
    using namespace Driver;
    using namespace UserGlobal;

    void LED_Config()
    {
        for (auto& led: leds) {
            led.init();
        }
    }

    void USART_Config()
    {
        // Simplified
        uart.init(9600-8-1-N)
            .rx_config(PDx) // RX -> PDx
            .tx_config(PDy) // TX -> PDy
            .it_enable(RXNE) // Enable RXNE interrupt
            .enable();
    }

    void config()
    {
        LED_Config();
        USART_Config();
        SysTick_Config();
    }
}

namespace MOS::App
{
    void Task1(void* argv)
    {
        using UserGlobal::leds;
        for (uint8_t i = 0; i < 20; i++) {
           leds[1].toggle();
           Task::delay(100);
        }
        kprintf("T1 exits...\n");
    }

    void Task0(void* argv)
    {
        using UserGlobal::leds;
        Task::create(Task1, nullptr, 1, "T1");
        while (true) {
            leds[0].toggle();
            Task::delay(200);
        }
    }
}

namespace MOS::Test
{
    static Sync::Mutex_t mutex; // 1-2-3 order

    void MutexTest(void* argv)
    {
        auto name = Task::current()->get_name();
        while (true) {
            mutex.exec([&] {
                for (uint8_t i = 0; i < 5; i++) {
                    kprintf("%s is working...\n", name);
                    Task::delay(100);
                }
            });
            Task::delay(5);
        }
    }
}

int main(void)
{
    using namespace MOS;
    using UserGlobal::rx_buf;

    // Init hardware and clocks
    Bsp::config();

    // Create Calendar with RTC
    Task::create(App::Calendar, nullptr, 0, "Calendar");

    // Create Shell with rx_buf
    Task::create(Shell::launch, &rx_buf, 1, "Shell");
    
    // Create LED task
    Task::create(App::Task0, nullptr, 1, "T0");

    // Test examples
    // Task::create(Test::MutexTest, nullptr, 1, "T1");
    // Task::create(Test::MutexTest, nullptr, 2, "T2");
    // Task::create(Test::MutexTest, nullptr, 3, "T3");
    
    // Start scheduling, never return
    Scheduler::launch();

    while (true) {
        // Never runs to here
    }
}

启动 ⚡

 A_A       _
o'' )_____//   Version @ x.x.x(...)
 `_/  MOS  )   Build   @ TIME, DATE
 (_(_/--(_/    Chip    @ MCU, ARCH

 Tid   Name   Priority   Status   Stack%
-----------------------------------------
 #0    idle      15      READY       10%
 #1    Shell      1      READY       21%
 #2    T0         2      RUNNING      9%
-----------------------------------------

版本 🧾

📦 初始版本 0.0.1，完成以下部分：
1. 基本的调度器与任务控制

📌 计划：
1. 定时器，时间片轮转调度
2. 进程间通信 IPC，管道、消息队列
3. 进程同步 Sync，信号量、互斥锁
4. 移植简单的 Shell
5. 可变页面大小，内存分配器
6. SPI 驱动，LVGL 图形库
7. 移植到其他开发板和架构，例如 ESP32-C3(RISC-V)

📦 版本 0.0.2，完成以下部分：
1. Sync::{Semaphore_t, Lock_t, Mutex_t<T>, MutexGuard_t}，同步原语
2. Policy::PreemptivePriority，相同优先级下以时间片轮转方式调度
3. Task::terminate() 在任务退出时隐式调用
4. Shell::{Command, CmdCall, launch}，简单的命令行交互
5. 添加 HAL::STM32F4xx::SPI_t and Driver::ST7735S_t 驱动, 移植 GuiLite 图形库
6. KernelGlobal::os_ticks 和 Task::delay()，阻塞延时
7. 重构项目组织为 {kernel, arch, drivers}
8. 支持 GCC 编译，兼容 STM32CubeMX HAL
9. 添加 HAL::STM32F4xx::RTC_t, CmdCall::date_cmd, App::Calendar

📌 计划：
1. 带有优先级继承机制的 Sync::{Mutex_t, Cond_t, Barrier_t}
2. 进程间通信，管道、消息队列等
3. 简单的动态内存分配器
4. 硬件定时器 Timer
5. 将 Page 映射到 BitMap，实现快速分配
6. 对 Scheduler 进行简单的形式化验证