任务调度器

typedef struct {
    void (*task_func)(void);
    uint32_t rate_ms;
    uint32_t last_run;
    uint8_t priority;  // 优先级，数值越小优先级越高
} priority_task_t;

// 任务按优先级排序函数
void sort_tasks_by_priority(void) {
    // 使用冒泡排序按优先级排序
    for (uint8_t i = 0; i < task_num - 1; i++) {
        for (uint8_t j = 0; j < task_num - i - 1; j++) {
            if (scheduler_task[j].priority > scheduler_task[j + 1].priority) {
                // 交换任务
                priority_task_t temp = scheduler_task[j];
                scheduler_task[j] = scheduler_task[j + 1];
                scheduler_task[j + 1] = temp;
            }
        }
    }
}

// 在调度器运行函数中添加低功耗管理
void scheduler_run(void)
{
    bool all_tasks_idle = true;
    uint32_t time_to_next_task = UINT32_MAX;
    uint32_t now_time = HAL_GetTick();
    
    // 检查是否有任务需要立即执行
    for (uint8_t i = 0; i < task_num; i++)
    {
        uint32_t time_to_task = (scheduler_task[i].last_run + 
                                scheduler_task[i].rate_ms) - now_time;
                                
        if (time_to_task == 0) {
            // 有任务需要立即执行
            scheduler_task[i].last_run = now_time;
            scheduler_task[i].task_func();
            all_tasks_idle = false;
        } else if (time_to_task < time_to_next_task) {
            // 记录最近需要执行的任务时间
            time_to_next_task = time_to_task;
        }
    }
    
    // 如果所有任务都不需要立即执行，进入低功耗模式
    if (all_tasks_idle && time_to_next_task > MIN_SLEEP_TIME) {
        // 进入低功耗模式直到下一个任务时间或外部中断
        HAL_PWR_EnterSLEEPMode(PWR_MAINREGULATOR_ON, PWR_SLEEPENTRY_WFI);
    }
}

#define MAX_TASKS 10

typedef struct {
    void (*task_func)(void);
    uint32_t rate_ms;
    uint32_t last_run;
    bool active;  // 任务是否激活
} dynamic_task_t;

dynamic_task_t scheduler_task[MAX_TASKS];
uint8_t task_num = 0;

// 添加任务
uint8_t add_task(void (*task_func)(void), uint32_t rate_ms) {
    if (task_num >= MAX_TASKS) {
        return 0xFF; // 任务已满
    }
    
    scheduler_task[task_num].task_func = task_func;
    scheduler_task[task_num].rate_ms = rate_ms;
    scheduler_task[task_num].last_run = HAL_GetTick();
    scheduler_task[task_num].active = true;
    
    return task_num++;
}

// 删除任务
bool remove_task(uint8_t task_id) {
    if (task_id >= task_num) {
        return false;
    }
    
    // 移动数组元素以填补空缺
    for (uint8_t i = task_id; i < task_num - 1; i++) {
        scheduler_task[i] = scheduler_task[i + 1];
    }
    
    task_num--;
    return true;
}

// 暂停任务
bool pause_task(uint8_t task_id) {
    if (task_id >= task_num) {
        return false;
    }
    
    scheduler_task[task_id].active = false;
    return true;
}

// 恢复任务
bool resume_task(uint8_t task_id) {
    if (task_id >= task_num) {
        return false;
    }
    
    scheduler_task[task_id].active = true;
    scheduler_task[task_id].last_run = HAL_GetTick();
    return true;
}