自制OS系统

最新推荐文章于 2024-09-09 22:29:12 发布
最新推荐文章于 2024-09-09 22:29:12 发布
阅读量199 收藏
点赞数 2
文章标签： visual studio vscode macos
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/DU_xiansheng/article/details/129807951
版权

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

/**
*声明几个全局变量测试
*/

// 定义任务结构体
typedef struct {
    void (*taskFunc)(void); // 任务函数指针
    int delay; // 任务延迟时间
    int period; // 任务周期
    int runMe; // 任务是否需要执行标志
    int suspended; // 任务是否被挂起标志
} task_t;

// 定义任务数组
task_t tasks[3];

// 定义信号量结构体
typedef struct {
    int count; // 信号量计数器
} semaphore_t;

// 定义信号量数组
semaphore_t semaphores[2];

// 定义中断处理函数指针类型
typedef void (*isr_t)(void);

// 定义中断结构体
typedef struct {
    isr_t isrFunc; // 中断处理函数指针
    int priority; // 中断优先级
} interrupt_t;

// 定义中断数组
interrupt_t interrupts[2];

//这里提供另一种任务创建函数将
/*
// 初始化任务数组
void initTasks(void) {
    tasks[0].taskFunc = task1;
    tasks[0].delay = 0;
    tasks[0].period = 1000;
    tasks[0].runMe = 0;
    tasks[0].suspended = 0;

    tasks[1].taskFunc = task2;
    tasks[1].delay = 0;
    tasks[1].period = 2000;
    tasks[1].runMe = 0;
    tasks[1].suspended = 0;

    tasks[2].taskFunc = task3;
    tasks[2].delay = 0;
    tasks[2].period = 500;
    tasks[2].runMe = 0;
    tasks[2].suspended = 0;
}
*/

// 创建任务
void createTask(void (*taskFunc)(void), int delay, int period) {
    int i;
    for (i = 0; i < sizeof(tasks) / sizeof(task_t); i++) {
        if (tasks[i].taskFunc == NULL) {
            tasks[i].taskFunc = taskFunc;
            tasks[i].delay = delay;
            tasks[i].period = period;
            tasks[i].runMe = 0;
            tasks[i].suspended = 0;
            break;
        }
    }
}

// 删除任务
void deleteTask(void (*taskFunc)(void)) {
    int i;
    for (i = 0; i < sizeof(tasks) / sizeof(task_t); i++) {
        if (tasks[i].taskFunc == taskFunc) {
            tasks[i].taskFunc = NULL;
            tasks[i].delay = 0;
            tasks[i].period = 0;
            tasks[i].runMe = 0;
            tasks[i].suspended = 0;
            break;
        }
    }
}

// 挂起任务
void suspendTask(void (*taskFunc)(void)) {
    int i;
    for (i = 0; i < sizeof(tasks) / sizeof(task_t); i++) {
        if (tasks[i].taskFunc == taskFunc) {
            tasks[i].suspended = 1;
            break;
        }
    }
}

// 恢复任务
void resumeTask(void (*taskFunc)(void)) {
    int i;
    for (i = 0; i < sizeof(tasks) / sizeof(task_t); i++) {
        if (tasks[i].taskFunc == taskFunc) {
            tasks[i].suspended = 0;
            break;
        }
    }
}

// 任务循环执行
void taskScheduler(void) {
    int i;
    while (1) {
        for (i = 0; i < sizeof(tasks) / sizeof(task_t); i++) {
            if (tasks[i].taskFunc != NULL && tasks[i].suspended == 0) {
                if (tasks[i].delay == 0) {
                    tasks[i].runMe = 1;
                    tasks[i].delay = tasks[i].period - 1;
                }
                else {
                    tasks[i].delay--;
                }
            }
        }

        for (i = 0; i < sizeof(tasks) / sizeof(task_t); i++) {
            if (tasks[i].runMe == 1) {
                tasks[i].taskFunc();
                tasks[i].runMe = 0;
                tasks[i].delay = tasks[i].period - 1;
            }
        }
    }
}

// 初始化信号量数组
void initSemaphores(void) {
    semaphores[0].count = 0;
    semaphores[1].count = 0;
}

// 创建信号量
void createSemaphore(int index, int count) {
    semaphores[index].count = count;
}

// 等待信号量
void waitSemaphore(int index) {
    while (semaphores[index].count == 0) {
        // 等待信号量
    }
    semaphores[index].count--;
}

// 发送信号量
void signalSemaphore(int index) {
    semaphores[index].count++;
}

// 初始化中断数组
void initInterrupts(void) {
    interrupts[0].isrFunc = NULL;
    interrupts[0].priority = 0;
    interrupts[1].isrFunc = NULL;
    interrupts[1].priority = 0;
}

// 注册中断处理函数
void registerInterrupt(isr_t isrFunc, int priority) {
    int i;
    for (i = 0; i < sizeof(interrupts) / sizeof(interrupt_t); i++) {
        if (interrupts[i].isrFunc == NULL) {
            interrupts[i].isrFunc = isrFunc;
            interrupts[i].priority = priority;
            break;
        }
    }
}

// 中断处理函数
void handleInterrupts(void) {
    int i, j;
    for (i = 0; i < sizeof(interrupts) / sizeof(interrupt_t); i++) {
        if (interrupts[i].isrFunc != NULL) {
            interrupts[i].isrFunc();
        }

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

/**
*声明几个全局变量测试
*/





// 定义任务结构体
typedef struct {
    void (*taskFunc)(void); // 任务函数指针
    int delay; // 任务延迟时间
    int period; // 任务周期
    int runMe; // 任务是否需要执行标志
    int suspended; // 任务是否被挂起标志
} task_t;

// 定义任务数组
task_t tasks[3];

// 定义信号量结构体
typedef struct {
    int count; // 信号量计数器
} semaphore_t;

// 定义信号量数组
semaphore_t semaphores[2];

// 定义中断处理函数指针类型
typedef void (*isr_t)(void);

// 定义中断结构体
typedef struct {
    isr_t isrFunc; // 中断处理函数指针
    int priority; // 中断优先级
} interrupt_t;

// 定义中断数组
interrupt_t interrupts[2];



//这里提供另一种任务创建函数将
/*
// 初始化任务数组
void initTasks(void) {
    tasks[0].taskFunc = task1;
    tasks[0].delay = 0;
    tasks[0].period = 1000;
    tasks[0].runMe = 0;
    tasks[0].suspended = 0;

    tasks[1].taskFunc = task2;
    tasks[1].delay = 0;
    tasks[1].period = 2000;
    tasks[1].runMe = 0;
    tasks[1].suspended = 0;

    tasks[2].taskFunc = task3;
    tasks[2].delay = 0;
    tasks[2].period = 500;
    tasks[2].runMe = 0;
    tasks[2].suspended = 0;
}
*/



// 创建任务
void createTask(void (*taskFunc)(void), int delay, int period) {
    int i;
    for (i = 0; i < sizeof(tasks) / sizeof(task_t); i++) {
        if (tasks[i].taskFunc == NULL) {
            tasks[i].taskFunc = taskFunc;
            tasks[i].delay = delay;
            tasks[i].period = period;
            tasks[i].runMe = 0;
            tasks[i].suspended = 0;
            break;
        }
    }
}

// 删除任务
void deleteTask(void (*taskFunc)(void)) {
    int i;
    for (i = 0; i < sizeof(tasks) / sizeof(task_t); i++) {
        if (tasks[i].taskFunc == taskFunc) {
            tasks[i].taskFunc = NULL;
            tasks[i].delay = 0;
            tasks[i].period = 0;
            tasks[i].runMe = 0;
            tasks[i].suspended = 0;
            break;
        }
    }
}

// 挂起任务
void suspendTask(void (*taskFunc)(void)) {
    int i;
    for (i = 0; i < sizeof(tasks) / sizeof(task_t); i++) {
        if (tasks[i].taskFunc == taskFunc) {
            tasks[i].suspended = 1;
            break;
        }
    }
}

// 恢复任务
void resumeTask(void (*taskFunc)(void)) {
    int i;
    for (i = 0; i < sizeof(tasks) / sizeof(task_t); i++) {
        if (tasks[i].taskFunc == taskFunc) {
            tasks[i].suspended = 0;
            break;
        }
    }
}

// 任务循环执行
void taskScheduler(void) {
    int i;
    while (1) {
        for (i = 0; i < sizeof(tasks) / sizeof(task_t); i++) {
            if (tasks[i].taskFunc != NULL && tasks[i].suspended == 0) {
                if (tasks[i].delay == 0) {
                    tasks[i].runMe = 1;
                    tasks[i].delay = tasks[i].period - 1;
                }
                else {
                    tasks[i].delay--;
                }
            }
        }

        for (i = 0; i < sizeof(tasks) / sizeof(task_t); i++) {
            if (tasks[i].runMe == 1) {
                tasks[i].taskFunc();
                tasks[i].runMe = 0;
                tasks[i].delay = tasks[i].period - 1;
            }
        }
    }
}

// 初始化信号量数组
void initSemaphores(void) {
    semaphores[0].count = 0;
    semaphores[1].count = 0;
}

// 创建信号量
void createSemaphore(int index, int count) {
    semaphores[index].count = count;
}

// 等待信号量
void waitSemaphore(int index) {
    while (semaphores[index].count == 0) {
        // 等待信号量
    }
    semaphores[index].count--;
}

// 发送信号量
void signalSemaphore(int index) {
    semaphores[index].count++;
}

// 初始化中断数组
void initInterrupts(void) {
    interrupts[0].isrFunc = NULL;
    interrupts[0].priority = 0;
    interrupts[1].isrFunc = NULL;
    interrupts[1].priority = 0;
}

// 注册中断处理函数
void registerInterrupt(isr_t isrFunc, int priority) {
    int i;
    for (i = 0; i < sizeof(interrupts) / sizeof(interrupt_t); i++) {
        if (interrupts[i].isrFunc == NULL) {
            interrupts[i].isrFunc = isrFunc;
            interrupts[i].priority = priority;
            break;
        }
    }
}

// 中断处理函数
void handleInterrupts(void) {
    int i, j;
    for (i = 0; i < sizeof(interrupts) / sizeof(interrupt_t); i++) {
        if (interrupts[i].isrFunc != NULL) {
            interrupts[i].isrFunc();
        }
    }
}

// 定义任务函数
void task1(void) {

    
    printf("Task 1 is running.\n");
}

void task2(void) {
    printf("Task 2 is running.\n");
}

void task3(void) {
    printf("Task 3 is running.\n");
}

int main(void) {
    //initTasks(); // 初始化任务数组

    createTask(task1, 0, 100000); // 创建任务1，延迟0ms，周期1000ms
    createTask(task2, 0, 100000); // 创建任务2，延迟0ms，周期2000ms
    createTask(task3, 0, 100000); // 创建任务3，延迟0ms，周期500ms

    taskScheduler(); // 任务循环执行

    return 0;
}


    }
}

// 定义任务函数
void task1(void) {

    
    printf("Task 1 is running.\n");
}

void task2(void) {
    printf("Task 2 is running.\n");
}

void task3(void) {
    printf("Task 3 is running.\n");
}

int main(void) {
    //initTasks(); // 初始化任务数组

    createTask(task1, 0, 100000); // 创建任务1，延迟0ms，周期1000ms
    createTask(task2, 0, 100000); // 创建任务2，延迟0ms，周期2000ms
    createTask(task3, 0, 100000); // 创建任务3，延迟0ms，周期500ms

    taskScheduler(); // 任务循环执行

    return 0;
}


 

DU_xiansheng
关注
  • 2
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
typedef void(*Func)(void) 理解
weixin_47057981的博客
06-01 895
题外话： 跟typedef有个很类似的关键字时#define，两者其实是有区别的。typedef语句是在编译过程中被解析的，而#define是在编译之前的预处理过程中被解析的。#define所进行的只是对自定义别名的简单替换，而typedef则要灵活得多。总的来说，typedef可以做到#define所能做的所有事情，而且可以做得更好。 正式内容： 1、 typedef—声明 简称 typedef，为现有类型创建一个新的名字。比如人们常常使用 typedef 来编写更美观和可读的代码。所谓美观，意指 typ
自制 os 极简教程1：写一个操作系统有多难
墨鱼菜鸡
09-09 1353
点击上方“五分钟学算法”，选择“星标”公众号 重磅干货，第一时间送达 不知道正在阅读本文的你，是否是因为想自己动手写一个操作系统。我觉得可能每个程序员都有个操作系统梦，或许是想亲自动手写出来一个，或许是想彻底吃透操作系统的知识。不论是为了满足程序员们自带的成就感，还是为了面试找工作时能更深入地和面试官探讨(装逼)。 那写一个操作系统究竟有...
智能小车知识点总结
勾栏听曲_0的博客
06-11 3676
STM23控制智能小车的基本知识，涉及红外，中断，定时，蓝牙等
如何理解typedef void (*pfun)(void)
liu19891226的博客
06-06 9470
问题：      在刚接触typedef void (*pfun)(void) 这个结构的时候，存在疑惑，为什么typedef后只有一“块”东西，而不是两“块”东西呢？那是谁“替代”了谁啊？我总结了一下，一方面是对typedef的概念不清晰，另一方面受了#define的影响，犯了定向思维的错误。 概念理解：typedef 只对已有的类型进行别名定义，不产生新的类型；#define 只是在预处理过程...
简述typedef void (*pfun)(void)的含义
weixin_43311390的博客
10-13 2585
typedef void (pfun)(void) 把typedef去掉， void (pfun)(void) 这句话就是定义了一个指针，这个指针指向一个函数，类似于 float g 这里的g就是被定义成了一个指向一个float类型的指针，加上typedef，就是用原本被定义的符号来替代这个类型，还是上面那个例子，原本是g被定义成了float这个类型， 加上typedef，g就能够替代float* 因此typedef void (pfun)(void)的意思就是用【pfun】这个关键字来替代了void ()
typedef void(*T)(void *)的含义
qq_38635597的博客
10-17 7235
对于typedef void(*T)(void *)，我们进行一层层的剖析 首先写成 void(*T)() 可以看出 T是一个指针，是一个指向返回值为void ，参数为空的类型的函数指针 在加上(void *)  为 void(*T)(void *)  就变成了一个指向 返回值为void，参数为void *类型的指针 在加上上typedef ，加上后，T就不再是一个函数指针了，它代表着一种类...
Ora-OS自制操作系统
09-08
Ora-OS自制操作系统
自制OS的源码
12-06
标题 "自制OS的源码" 提供了一个关于操作系统（OS）开发的主题，特别是指向一个名为 "Haribote OS" 的项目。这个标题暗示了我们将会深入到操作系统的基础构造和编程中，这对于那些对计算机系统底层运作有兴趣或者想...
自制OS雏形
10-08
当然问题多多，不是要写一个系统，而是学习的记录。如果你是大牛就pass吧。如果你是 如我一样的菜鸟，学linux内核不知从哪下手，可以看看。在过程中碰到了很多困难，也解决了很多问题。总体觉得比捧着厚厚的内核书籍...
Linux0.11和30天自制os的联合调试
02-07
Linux0.11 Linux0.12 30天自制操作系统 os 可以运行，要在Linux0.12上编译运行
一个完整的自制操作系统
05-07
一个小型的自制操作系统，可以很好的用来学习OS原理，代码可直接在X86的任何平台上运行，并提供了丰富的开发工具以及使用说明，很适合初学者
SDK2.0之I2S的中断callback函数
清风晓月的专栏
11-01 1843
Introduce在LPC5411x上有多个Flexcomm接口可供选择使用。每一个Flexcomm接口都可以提供一种外设功能，包括USART、SPI、I2C、I2S（不是所有flexcomm都支持I2S）。对于USART、SPI和I2S的数据传输可以使用FIFO，但I2C并不能使用Flexcomm的FIFO；本博客主要分析当Flexcomm Interface6和Interface7选作I2S外设
C语言之typedef void (*T) (void *)
心跳包的博客
05-28 4001
typedef void (*T) (void *);定义了一个指向函数的指针T，其返回值 void 类型，参数也是后面的（void *）接下来我们就可以直接使用 T 来定义这种指针变量，比如：T fn1; //等价于void fn1 (void *);使用：void func(void *); //声明函数T fn1; //定义变量fn1=func; //赋值(*fn1)(); //执行...
typedef void (*sighandler_t)(int);类型说明
angelo
05-17 1190
原文链接：http://blog.sina.com.cn/s/blog_7090a2d1010163ol.html       typedef void (*sighandler_t)(int); sighandler_t signal(int signum, sighandler_t handler);   此处由于加了typedef自定义了一个新类
嵌入式经典面试题汇总2
qq_37560166的博客
07-26 1779
**1、int a[10]={1,2,3,4,5,6,7,8,9,0}; int *p=&a[1]; 则p[6]等于8 2、整数数组清零：bzero(),memset()。 3、sizeof();测试变量所占地址的字节数 4、 main() { char *str[]={“ab”,“cd”,“ef”,“gh”,“ij”,“kl”}; char t; t=(str+4)[-1]; print...
如何在Visual Studio中调试.NET源码
zhaotianff的专栏
09-09 363
有时候如果我们想在Visual Studio中单步调试.NET的源码，可以按下面的方式操作。今天偶然在看别人代码时，发现在他的代码里使用了Any判断List<T>是否为空。测试了一下，大量数据情况下，耗时几乎都是0ms，所以应该差别不大。我一般的做法是先判断是否为null，再判断Count。（仅.NET Core）仓库里的源码，找到对应的文件。此时再调试时，就能单步调试.NET源码。如果提示找不到某个符号，可以下载。
【Visual Studio 报错】vs 在使用二进制写入文件时弹窗报错：使用简体中文 gb2312 编码加载文件
最新发布
唯有忍受别人不能忍受的，才能享受别人不能享受的
09-09 100
vs 在使用二进制写入文件时弹窗报错：使用简体中文 gb2312 编码加载文件
自制操作系统：一个月打造你的OS
操作系统（OS）是计算机的核心，负责管理硬件资源和软件应用的交互，常见的如Windows、Linux和MacOS等。在开始开发之前，书中讨论了开发操作系统的各种方法，强调了无知与无畏的心态在创新中的重要性。尽管大型操作...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值