## 1. 轻量级任务调度框架cola_os设计与实现

### 1.1 框架概述
cola_os是一款基于软件定时器实现的时间片轮询框架，核心代码仅300余行。该框架适用于资源受限的MCU开发场景，当系统需要多任务管理但实时性要求不高时，可替代传统RTOS方案。

### 1.2 系统架构
框架包含三大核心模块：
- **任务管理模块**：基于链表的时间片轮询调度
- **设备抽象层**：统一硬件设备驱动接口
- **自动初始化**：仿Linux的initcall机制

## 2. 任务管理模块实现

### 2.1 任务数据结构
```c
typedef void (*cbFunc)(uint32_t event);

typedef struct task_s {
    uint8_t  timerNum;   // 定时器编号
    uint32_t period;     // 执行周期(ms)
    bool     oneShot;    // 单次执行标志
    bool     start;      // 启动标志
    uint32_t timerTick;  // 定时计数器
    bool     run;        // 任务就绪标志
    bool     taskFlag;   // 任务类型标志
    uint32_t event;      // 事件参数
    cbFunc   func;       // 回调函数
    struct task_s *next; // 链表指针
} task_t;

2.2 任务调度流程

1. 硬件定时器中断 （1ms时基）：

void SysTick_Handler(void) {
    cola_timer_ticker();
}

void cola_timer_ticker(void) {
    task_t *cur = task_list;
    while(cur != NULL) {
        if((TASK_TIMER == cur->taskFlag) && cur->start) {
            if(++cur->timerTick >= cur->period) {
                cur->timerTick = 0;
                if(cur->func != NULL) {
                    enter_critical();
                    cur->run = true;
                    exit_critical();
                }
            }
        }
        cur = cur->next;
    }
}

2. 主循环任务调度 ：

void cola_task_loop(void) {
    uint32_t events;
    task_t *cur = task_list;
    
    while(cur != NULL) {
        if(cur->run) {
            if(NULL != cur->func) {
                events = cur->event;
                if(events) {
                    enter_critical();
                    cur->event = 0;
                    exit_critical();
                }
                cur->func(events);
            }
            
            if(TASK_TIMER == cur->taskFlag) {
                enter_critical();
                cur->run = false;
                exit_critical();
            }
            
            if((cur->oneShot) && (TASK_TIMER == cur->taskFlag)) {
                cur->start = false;
            }
        }
        cur = cur->next;
    }
}

3. 设备驱动抽象层设计

3.1 设备操作接口

struct cola_device_ops {
    int (*init)(cola_device_t *dev);
    int (*open)(cola_device_t *dev, int noflag);
    int (*close)(cola_device_t *dev);
    int (*read)(cola_device_t *dev, int pos, void *buffer, int size);
    int (*write)(cola_device_t *dev, int pos, const void *buffer, int size);
    int (*control)(cola_device_t *dev, int cmd, void *args);
};

struct cola_device {
    const char *name;
    struct cola_device_ops *dops;
    struct cola_device *next;
};

3.2 LED设备驱动示例

static cola_device_t led_dev;

static int led_ctrl(cola_device_t *dev, int cmd, void *args) {
    if(LED_TOGGLE == cmd) {
        LED_GREEN_TOGGLE;
    }
    return 1;
}

static struct cola_device_ops ops = {
    .control = led_ctrl,
};

void led_register(void) {
    led_gpio_init();
    led_dev.dops = &ops;
    led_dev.name = "led";
    cola_device_register(&led_dev);
}

4. 自动初始化机制

4.1 初始化段定义

#define __used __attribute__((__used__))
typedef void (*initcall_t)(void);

#define __define_initcall(fn, id) \
    static const initcall_t __initcall_##fn##id __used \
    __attribute__((__section__("initcall" #id "init"))) = fn

#define pure_initcall(fn) __define_initcall(fn, 0)  // 系统时钟初始化
#define fs_initcall(fn)   __define_initcall(fn, 1)  // tick和调试接口
#define device_initcall(fn) __define_initcall(fn, 2)// 驱动初始化
#define late_initcall(fn) __define_initcall(fn, 3)  // 其他初始化

4.2 初始化函数遍历

void do_init_call(void) {
    extern initcall_t initcall0init$$Base[];
    extern initcall_t initcall0init$$Limit[];
    // ...其他段声明
    
    initcall_t *fn;
    for(fn = initcall0init$$Base; fn < initcall0init$$Limit; fn++) {
        if(fn) (*fn)();
    }
    // ...其他段遍历
}

5. 应用实例：双任务调度

5.1 任务创建与启动

static task_t timer_500ms;
static task_t timer_1000ms;

static void timer_500ms_cb(uint32_t event) {
    printf("task0 running...\n");
}

static void timer_1000ms_cb(uint32_t event) {
    printf("task1 running...\n");
}

int main(void) {
    HAL_Init();
    MX_GPIO_Init();
    MX_USART1_UART_Init();
    
    cola_timer_create(&timer_500ms, timer_500ms_cb);
    cola_timer_start(&timer_500ms, TIMER_ALWAYS, 500);
    
    cola_timer_create(&timer_1000ms, timer_1000ms_cb);
    cola_timer_start(&timer_1000ms, TIMER_ALWAYS, 1000);
    
    while(1) {
        cola_task_loop();
    }
}

5.2 定时器配置

void SystemClock_Config(void) {
    // STM32时钟树配置
    // ...
    HAL_SYSTICK_Config(HAL_RCC_GetHCLKFreq()/1000);
}

pure_initcall(SystemClock_Config);