状态机自制os

/**自制一个简单的OS操作系统  
*任务API函数包括任务创建、任务删除、任务挂起和恢复、任务调度、任务时间分配等
*创建任务最大10个任务，创建函数后要在主函数中调用开始任务函数
*后续加入队列 信号量 引入中断机制机制、内存管理机制以及各种控制块
*
* 注：可以利用void add_task(void (*task_func)(void), int num_priority)调用任务API函数
* 
* 时间2023.03.29
*/

#include "DuOS.h"

int main(void) {
    creat_tasks();
    task_Start();      // 任务开始函数
    run_scheduler();   // 启动调度器
    return 0;
}

#ifndef _DUOS_H_
#define _DUOS_H_

#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>
#include <string.h>


#define MAX_TASKS  10          // 定义最大任务量
#define MAX_EVENTS 10         // 定义最大事件状态

#define IDLE       0;
#define RUNNING    1;
#define SUSPENDED  2;
#define SOPPEND    3;
#define WARRING    4;

extern int num_tasks;                           // 任务数量
extern int num_events;                          // 事件数量

// 定义队列结构体
typedef struct {
    void** data;   // 队列数组指针，存放元素的指针
    int head;      // 队列头指针，指向队头元素
    int tail;      // 队列尾指针，指向队尾元素的下一个位置
    int size;      // 队列大小，即数组大小
    int count;     // 队列元素数量，即队列中实际存放元素的数量
} queue_t;

// 定义任务状态
 typedef enum {
    TASK_IDLE,      // 空闲状态
    TASK_RUNNING,   // 运行状态
    TASK_SUSPENDED, // 挂起状态
    TASK_BLOCKED    // 阻塞状态
} task_state_t;


// 定义任务结构体
 typedef struct {
    int id;                     // 任务ID
    int priority;               // 任务优先级
    task_state_t state;         // 任务状态
    void (*task_func)(void);    // 任务函数指针
} task_t;


// 定义事件类型
 typedef enum {
    EVENT_NONE,     // 无事件
    EVENT_START,    // 启动事件
    EVENT_STOP,     // 停止事件
    EVENT_SUSPEND,  // 挂起事件
    EVENT_RESUME,   // 恢复事件
    EVENT_BLOCK,    // 阻塞事件
    EVENT_UNBLOCK   // 解除阻塞事件
} event_t;

// 定义事件队列结构体
 typedef struct {
    int id;                                  // 任务ID
    event_t event;                           // 事件类型
} event_queue_t;

 /**
 *各种任务API函数和任务调度、状态切换函数
 */
 void add_task(void (*task_func)(void), int num_priority);
 void start_task(int task_id);
 void stop_task(int task_id);
 void suspend_task(int task_id);
 void resume_task(int task_id);
 void block_task(int task_id);
 void unblock_task(int task_id);
 void add_event(int task_id, event_t event);
 void dispatch_events(void);
 void run_scheduler(void);
 void task_Start();
 void task1(void);
 void task2(void);
 void task3(void);
 void creat_tasks(void);

 // 创建队列
 queue_t *queue_create(int size);
 // 销毁队列
 void    queue_destroy(queue_t *q);
 // 插入元素
 int     queue_push(queue_t *q, void *data);
 // 弹出元素
 void    *queue_pop(queue_t *q);
 // 判断队列是否为空
 int     queue_empty(queue_t *q);
 //创建队列函数
 void    queue_tasks(int num);

#endif // !1

#include "DuOS.h"

int num_tasks = 0;
int num_events = 0;

task_t         tasks[MAX_TASKS];                     // 任务数组
event_queue_t  event_queue[MAX_EVENTS];       // 事件队列数组

// 添加任务
void add_task(void (*task_func)(void), int num_priority) {
    if (num_tasks < MAX_TASKS) {
        tasks[num_tasks].id = num_tasks;
        tasks[num_tasks].state = TASK_IDLE;
        tasks[num_tasks].priority = num_priority;
        tasks[num_tasks].task_func = task_func;
        num_tasks++;
    }

}

// 启动任务
void start_task(int task_id) {
    if (task_id < num_tasks) {
        tasks[task_id].state = TASK_RUNNING;
    }
}


// 停止任务
void stop_task(int task_id) {
    if (task_id < num_tasks) {
        tasks[task_id].state = TASK_IDLE;
    }
}

// 挂起任务
void suspend_task(int task_id) {
    if (task_id < num_tasks) {
        tasks[task_id].state = TASK_SUSPENDED;
    }
}

// 恢复任务
void resume_task(int task_id) {
    if (task_id < num_tasks) {
        tasks[task_id].state = TASK_RUNNING;
    }
}

// 阻塞任务
void block_task(int task_id) {
    if (task_id < num_tasks) {
        tasks[task_id].state = TASK_BLOCKED;
    }
}

// 解除阻塞任务
void unblock_task(int task_id) {
    if (task_id < num_tasks) {
        tasks[task_id].state = TASK_RUNNING;
    }
}

// 添加事件
void add_event(int task_id, event_t event) {
    if (num_events < MAX_EVENTS) {
        event_queue[num_events].id = task_id;
        event_queue[num_events].event = event;
        num_events++;
    }
}

// 分发事件
void dispatch_events(void) {
    int i;
    for (i = 0; i < num_events; i++) {
        int task_id = event_queue[i].id;
        event_t event = event_queue[i].event;
        switch (event) {
        case EVENT_START:
            start_task(task_id);
            break;
        case EVENT_STOP:
            stop_task(task_id);
            break;
        case EVENT_SUSPEND:
            suspend_task(task_id);
            break;
        case EVENT_RESUME:
            resume_task(task_id);
            break;
        case EVENT_BLOCK:
            block_task(task_id);
            break;
        case EVENT_UNBLOCK:
            unblock_task(task_id);
            break;
        default:
            break;
        }
    }
    num_events = 0;
}

// 调度器
void run_scheduler(void) {
    int i, j;
    task_t tasks_list;

    // 根据优先级对任务列表进行排序
    for (i = 0; i < num_tasks - 1; i++) {
        for (j = i + 1; j < num_tasks; j++) {
            if (tasks[i].priority < tasks[j].priority) {
                tasks_list = tasks[i];
                tasks[i] = tasks[j];
                tasks[j] = tasks_list;
            }
        }
    }

    while (1) {
        dispatch_events();
        for (i = 0; i < num_tasks; i++) {
            if (tasks[i].state == TASK_RUNNING) {
                tasks[i].task_func(); // 执行任务函数
            }
        }
    }
}

//定义一个函数指针，指向创建的task任务函数用来开启任务调度，相当于任务句柄
void (*task_handl)(int task_id);

//利用任务句柄让任务跑起来
void task_Start()
{
    int i;
    task_handl = start_task;
    for (i = 0;i < sizeof(tasks) / sizeof(tasks[num_tasks]);i++)
    {
        (*task_handl)(i);
    }
}

//创建任务函数
void creat_tasks(void)
{
    //支持最大任务10个 增加任务一次任务名称（数值越大，优先级越大）；
    add_task(task1, 0); // 添加任务1
    add_task(task2, 1); // 添加任务2
    add_task(task3, 2); // 添加任务3
}

// 创建队列
queue_t* queue_create(int size) {
    // 申请队列结构体内存
    queue_t *q = (queue_t*)malloc(sizeof(queue_t));
    if (q) {
        // 申请队列数组内存
        q->data = (void**)malloc(size * sizeof(void*));
        if (q->data) {
            q->head = 0;      // 队头指针初始化为0
            q->tail = 0;      // 队尾指针初始化为0
            q->size = size;   // 队列大小为size
            q->count = 0;     // 队列元素数量为0
        }
        else {
            free(q);  // 申请队列数组内存失败，释放队列结构体内存
            q = NULL;
        }
    }
    return q;
}

// 销毁队列
void queue_destroy(queue_t * q) {
    if (q) {
        if (q->data) {
            free(q->data);  // 释放队列数组内存
            q->data = NULL;
        }
        free(q);  // 释放队列结构体内存
    }
}
// 插入元素
int queue_push(queue_t* q, void* data) {
    if (q->count == q->size) {
        return -1;  // 队列已满，插入失败
    }
    q->data[q->tail] = data;  // 插入元素到队尾
    q->tail = (q->tail + 1) % q->size;  // 队尾指针后移一位，如果已经到达数组末尾，则指针回到数组开头
    q->count++;  // 队列元素数量加一
    return 0;
}
// 弹出元素
void* queue_pop(queue_t* q) {
    if (q->count == 0) {
        return NULL;  // 队列为空，弹出失败
    }
    void* data = q->data[q->head];  // 弹出队头元素
    q->head = (q->head + 1) % q->size;  // 队头指针后移一位，如果已经到达数组末尾，则指针回到数组开头
    q->count--;  // 队列元素数量减一
    return data;
}
// 判断队列是否为空
int queue_empty(queue_t* q) {
    return q->count == 0;
}

//队列任务函数
void queue_tasks(int num,int flag)
{
    int i;

    queue_t *q = queue_create(num);  // 创建一个容量为num的队列
    
        int* data = (int*)malloc(sizeof(int));
        *data = flag;
        queue_push(q, data);  // 插入元素   
}

void queue_finish(int num)
{
    queue_t* q = queue_create(num);
    if (!queue_empty(q)) {
        int* data = (int*)queue_pop(q);  // 弹出元素
        free(data);  // 记得释放内存
    }

    queue_destroy(q);  // 销毁队列
}


// 任务1
void task1(void) {
    printf("Task 1 is running.\n");
}

// 任务2
void task2(void) {
    printf("Task 2 is running.\n");
    //suspend_task(0);
}

//任务三
void task3(void)
{
    printf("Task 3 is running.\n");
    //add_event(0, EVENT_RESUME);
}