自己摸了一个操作系统内核，发出来给大家看看。 -

#include <Task_Core.H>
#include <stdlib.h>
#include <Config.H>
void Free_Task();
struct Task_Control_Block_List{
uchar* head_Stack; //栈头指针
uchar* tail_Stack; //栈尾指针
uchar* event_Pointer; //时间指针
uchar event_End; //时间结束
uchar ready; //就绪状态
uchar priority; //优先级
struct Task_Control_Block_List* Next;
};
typedef struct Task_Control_Block_List Task_List;
struct Task_Priority_List{
struct Task_Priority_List * Next;
struct Task_Control_Block_List* Head_Task;
struct Task_Control_Block_List* Next_Task;
uchar priority;
}Task_Priority_List;
typedef struct Task_Priority_List Task_Ready_List;
//添加任务到优先级链
void ADD_Task_To_Priority_List(Task_List * list);
//从优先级链中删除任务
void DEC_Task_Of_Priority_List(Task_List * list);
static Task_List Block_List_Head; // 阻塞链表表头
static Task_List* Now_Task; // 目前启用任务
static Task_Ready_List Task_Ready_List_Head;// 优先级链表表头
static uchar data Stack_Start; // 栈开始
static uchar data Stack_Last; // 上一个栈尾
static uchar data Stack_St; // 中间变量
//任务调度函数
#pragma asm
CSEG AT 0000BH
LJMP Timer
#pragma endasm
void Timer() interrupt 1
{
Task_List* Task_Now;
Task_List* Task_Now1;
uchar* stack;
uchar a;
int i;
//禁止中断嵌套
EA = 0;
//保存上文
#pragma asm
MOV Stack_Last,SP
MOV SP, Stack_St
#pragma endasm
Now_Task->tail_Stack =(uchar *) Stack_Last;
// 搜索阻塞链表中达成条件的任务
for(Task_Now = &Block_List_Head; Task_Now->Next != NULL;)
{
if(Task_Now->Next->event_Pointer[0] >= Task_Now->Next->event_End)
{
//将其从阻塞链表中移除，并添加到优先级任务链表
Task_Now->Next->event_Pointer = NULL;
Task_Now->Next->ready = 1;
Task_Now1 = Task_Now->Next;
Task_Now->Next = Task_Now->Next->Next;
ADD_Task_To_Priority_List(Task_Now1);
continue;
}
Task_Now = Task_Now->Next;
}
//修改当前启用任务
Now_Task = Task_Ready_List_Head.Next->Next_Task;
//修改优先级链表中下一个启用任务
if(Now_Task->Next != NULL)// 当前启用任务不是最后一个任务
Task_Ready_List_Head.Next->Next_Task = Now_Task->Next;
else // 当前启用任务是最后一个任务
Task_Ready_List_Head.Next->Next_Task = Task_Ready_List_Head.Next->Head_Task;
//更换下文
Stack_Last = Now_Task->tail_Stack;
#pragma asm
MOV SP,Stack_Last
#pragma endasm
EA = 1;
}
//任务阻塞
void Task_Block(uchar *event_pointer, uchar event_end)
{
uchar i;
EA = 0;
Now_Task->event_Pointer = event_pointer;
Now_Task->event_End = event_end;
Now_Task->ready = 0;
DEC_Task_Of_Priority_List(Now_Task);
Now_Task->Next = Block_List_Head.Next;
Block_List_Head.Next = Now_Task;
EA = 1;
TF0 = 1;
for(i = 0; i < 8; i++);
}
//任务等待时间
void Task_Wait(uchar Ms)
{
uchar i;
EA = 0;
for(i = 0; i < 8; i++)
{
if(biao[i] < 128)break;
}
if(i == 8)return;
biao[i] = 128;
Task_Block(&biao[i], Ms+128);
biao[i] = 0;
}
void Task_Init()
{
TMOD = 0x00;
TH0 = 0xF6;
TL0 = 0x3B;
TR0 = 1;
ET0 = 1;
#pragma asm
MOV Stack_Start,SP
#pragma endasm
Stack_Start += 10;
// 初始化链表头
Task_Ready_List_Head.priority = 0;
Task_Ready_List_Head.Head_Task = NULL;
Task_Ready_List_Head.Next = NULL;
Task_Ready_List_Head.Next_Task = NULL;
}
// 添加任务
void Task_ADD(void * x, uchar Stack_Growth, uchar priority)
{
Task_List * list = malloc(sizeof(Task_List));// 定义任务链表
list->priority = priority; //优先级赋值
list->head_Stack =(uchar *)Stack_Start ; //栈头地址赋值
//将任务PC指针压入栈
#pragma asm
MOV Stack_Last,SP
MOV SP ,Stack_Start
MOV DPTR,#x?450
LCALL ?C?PLDXDATA
MOV R6,AR2
MOV R7,AR1
MOV A,R7
PUSH ACC
MOV A,R6
PUSH ACC
MOV SP, Stack_Last
#pragma endasm
Stack_Start += Stack_Growth + 15; //修改下一个栈开始位置
list->tail_Stack = &list->head_Stack[15]; //栈尾地址赋值
list->ready = 1; //阻塞/就绪态赋值
list->Next = NULL;
ADD_Task_To_Priority_List(list);
}
//从优先级任务链中删除一个任务(将任务从就绪态中移除)
void DEC_Task_Of_Priority_List(Task_List * list)
{
uchar priority = list->priority;
Task_Ready_List* priority_List;
Task_Ready_List* new_priority_List;
Task_List * list1;
//查找优先级链表内是否已有所需优先级
for(priority_List = &Task_Ready_List_Head; priority_List->Next != NULL; priority_List = priority_List->Next)
{
if(priority_List->Next->priority > priority)return;// 错误，没有找着所需优先级
if(priority_List->Next->priority == priority)break;// 当前链表优先级等于所需优先级
}
if(priority_List->Next == NULL)return;// 错误，没有找着所需优先级
if(priority_List->Next->Head_Task == NULL)goto ASDN;// 错误，当前优先级内没有任务
if(priority_List->Next->Head_Task == list)// 判断优先级任务头是不是所需任务
{
priority_List->Next->Head_Task = priority_List->Next->Head_Task->Next;// 删除改任务
goto ASDN;
}
//在当前优先级任务链内搜索所需任务
for(list1 = priority_List->Next->Head_Task; list1->Next != NULL; list1 = list1->Next)
{
if(list1->Next == list)
{
list1->Next = list1->Next->Next;// 从优先级任务链中删除任务
break;
}
}
ASDN:
if(priority_List->Next->Head_Task == NULL)//当前优先级内没有任何任务，删除当前优先级任务链
{
new_priority_List = priority_List->Next;
priority_List->Next = priority_List->Next->Next;
// free(new_priority_List);
}
}
//添加一个任务到优先级任务链(将任务添加到就绪态)
void ADD_Task_To_Priority_List(Task_List * list)
{
uchar priority = list->priority;
Task_Ready_List* priority_List;
Task_Ready_List* new_priority_List;
//查找优先级链表内是否已有当前优先级
for(priority_List = &Task_Ready_List_Head; priority_List->Next != NULL; priority_List = priority_List->Next)
{
if(priority_List->Next->priority > priority)goto NEWHEAD;
if(priority_List->Next->priority == priority)break;// 当前链表优先级等于当前优先级
}
if(priority_List->Next == NULL)// 优先级链表内没有当前优先级
{
NEWHEAD:
//新建一个优先级头
new_priority_List = malloc(sizeof(Task_Ready_List));
new_priority_List->Next = priority_List->Next;
priority_List->Next = new_priority_List;
priority_List->Next->priority = priority;
priority_List->Next->Next_Task = list;
priority_List->Next->Head_Task = NULL;
}
//更换优先级链内头任务
list->Next = priority_List->Next->Head_Task;
priority_List->Next->Head_Task = list;
}
void Task_Start()
{
uchar* a;
Task_Ready_List* priority_List;
#pragma asm
MOV Stack_St,SP
#pragma endasm
Task_ADD(Free_Task, 2,55);// 添加空闲任务
//设置优先级链表中下一个启用任务
for(priority_List = Task_Ready_List_Head.Next; priority_List != NULL; priority_List = priority_List->Next)
priority_List->Next_Task = priority_List->Head_Task;
//获得当前启用任务
Now_Task = Task_Ready_List_Head.Next->Head_Task;
//修改优先级链表中下一个启用任务
if(Now_Task->Next != NULL)// 当前启用任务不是最后一个任务
Task_Ready_List_Head.Next->Next_Task = Now_Task->Next;
else // 当前启用任务是最后一个任务
Task_Ready_List_Head.Next->Next_Task = Task_Ready_List_Head.Next->Head_Task;
// 修改栈指针指向位置
a = Task_Ready_List_Head.Next->Head_Task->tail_Stack;
#pragma asm
MOV SP, ACC
POP AR7
POP AR6
POP AR5
POP AR4
POP AR3
POP AR2
POP AR1
POP AR0
POP PSW
POP DPL
POP DPH
POP B
POP ACC
#pragma endasm
}
//空闲函数
void Free_Task()
{
while(1)
{
EA = 1;
}
}

复制代码

#include <Task_Core.H>
#include <stdlib.h>
#include <Config.H>
/*------任务TCB结构体-------
//提示：任务栈内不包括局部变量
----------------------------*/
struct Task_Control_Block_List{
uchar* head_Stack; //任务栈头
uchar* tail_Stack; //任务栈尾
uint Tick; //跳动计数，用于等待时间
void* event_function; //事件函数指针
uchar event_return; //事件返回值，用于确定唤醒任务的事件
uchar ready; //阻塞/就绪标志位
uchar priority; //优先级
struct Task_Control_Block_List* Next;
};
typedef struct Task_Control_Block_List Task_List;
struct Task_Priority_List{
struct Task_Priority_List * Next;
struct Task_Control_Block_List* Head_Task;
struct Task_Control_Block_List* Next_Task;
uchar priority;
}Task_Priority_List;
typedef struct Task_Priority_List Task_Ready_List;
static Task_List Block_List_Head; // 阻塞链表表头
static Task_List* Now_Task; // 目前启用任务
static Task_Ready_List Task_Ready_List_Head;// 优先级链表表头
static uchar data Stack_Start; // 栈开始
static uchar data Stack_Last; // 上一个栈尾
static uchar data Stack_St; // 中间变量
static uint Tick;
//事件函数返回不是0的数即代表触发事件
static uchar (*Event_Function)();
static void Free_Task();
static void ADD_Task_To_Priority_List(Task_List * list);
static void DEC_Task_Of_Priority_List(Task_List * list);
static void Timer() interrupt 1
{
Task_List* Task_Now;
Task_List* Task_Now1;
EA = 0;//禁止中断嵌套
//保存上文
Stack_Last = SP;
SP = Stack_St;
Now_Task->tail_Stack =(uchar *) Stack_Last;
// 搜索阻塞链表中达成条件的任务
for(Task_Now = &Block_List_Head; Task_Now->Next != NULL;)
{
uchar a;
Event_Function = Task_Now->Next->event_function;
a = Event_Function();
if(a || --Task_Now->Next->Tick == 0)
{
//将其从阻塞链表中移除，并添加到优先级任务链表
Task_Now->Next->event_return = a;
Task_Now->Next->event_function = NULL;
Task_Now->Next->ready = 1;
Task_Now1 = Task_Now->Next;
Task_Now->Next = Task_Now->Next->Next;
ADD_Task_To_Priority_List(Task_Now1);
}
else
Task_Now = Task_Now->Next;
}
Tick++;// 时钟跳动
//修改当前启用任务
Now_Task = Task_Ready_List_Head.Next->Next_Task;
//修改优先级链表中下一个启用任务
if(Now_Task->Next != NULL)// 当前启用任务不是最后一个任务
Task_Ready_List_Head.Next->Next_Task = Now_Task->Next;
else // 当前启用任务是最后一个任务
Task_Ready_List_Head.Next->Next_Task = Task_Ready_List_Head.Next->Head_Task;
//更换下文
Stack_Last =(uchar) Now_Task->tail_Stack;
SP = Stack_Last;
EA = 1;
}
//无事件，用于仅等待时间的任务
static uchar Not_Event()
{
return 0;
}
/*--------------------任务阻塞-------------------------
Tick,任务等待超时时间，具体时间根据调度函数进入频率确定
function，事件函数
-----------------------------------------------------*/
uchar Task_Block(void* function, uint Tick)
{
EA = 0;
if(function == NULL)function = Not_Event;
Now_Task->event_function = function;
Now_Task->event_return = 255;
Now_Task->Tick = Tick;
Now_Task->ready = 0;
DEC_Task_Of_Priority_List(Now_Task);
Now_Task->Next = Block_List_Head.Next;
Block_List_Head.Next = Now_Task;
EA = 1;
TF0 = 1;
return Now_Task->Next->event_return;
// for(i = 0; i < 8; i++);
}
//任务初始化
void Task_Init()
{
TMOD = 0x00;
TH0 = 0xF6;
TL0 = 0x3B;
TR0 = 1;
ET0 = 1;
Stack_Start = SP;
Stack_Start += 10;
Task_Ready_List_Head.priority = 0;
Task_Ready_List_Head.Head_Task = NULL;
Task_Ready_List_Head.Next = NULL;
Task_Ready_List_Head.Next_Task = NULL;
Block_List_Head.Next = NULL;
}
/*--------------添加任务------------
//x, 任务头函数
//Stack_Growth, 栈生长（内部已经加上寄存器以及函数头所需的空间）
//priority, 优先级
------------------------------------*/
void Task_ADD(uint x, uchar Stack_Growth, uchar priority)
{
Task_List * list = malloc(sizeof(Task_List));// 定义任务链表
list->priority = priority; //优先级赋值
list->head_Stack =(uchar *)Stack_Start ; //栈头地址赋值
((uchar*) Stack_Start)[0] = x % 256 ;
((uchar*) Stack_Start)[1] = x >> 8 ;
Stack_Start += Stack_Growth + 15; //修改栈结尾位置
list->tail_Stack = &list->head_Stack[14]; //栈尾地址赋值
list->ready = 1; //阻塞/就绪态赋值
list->Next = NULL;
ADD_Task_To_Priority_List(list);
}
//从优先级任务链中删除一个任务
static void DEC_Task_Of_Priority_List(Task_List * list)
{
uchar priority = list->priority;
Task_Ready_List* priority_List;
Task_Ready_List* new_priority_List;
Task_List * list1;
//查找优先级链表内是否已有所需优先级
for(priority_List = &Task_Ready_List_Head; priority_List->Next != NULL; priority_List = priority_List->Next)
{
if(priority_List->Next->priority > priority)return;// 错误，没有找着所需优先级
if(priority_List->Next->priority == priority)break;// 当前链表优先级等于所需优先级
}
if(priority_List->Next == NULL)return;// 错误，没有找着所需优先级
if(priority_List->Next->Head_Task == NULL);// 错误，当前优先级内没有任务
else if(priority_List->Next->Head_Task == list)// 判断优先级任务头是不是所需任务
{
priority_List->Next->Head_Task = priority_List->Next->Head_Task->Next;// 删除改任务
}
//在当前优先级任务链内搜索所需任务
else for(list1 = priority_List->Next->Head_Task; list1->Next != NULL; list1 = list1->Next)
{
if(list1->Next == list)
{
list1->Next = list1->Next->Next;// 从优先级任务链中删除任务
break;
}
}
if(priority_List->Next->Head_Task == NULL)//当前优先级内没有任何任务，删除当前优先级任务链
{
new_priority_List = priority_List->Next;
priority_List->Next = priority_List->Next->Next;
free(new_priority_List);
}
}
//添加一个任务到优先级任务链
static void ADD_Task_To_Priority_List(Task_List * list)
{
uchar priority = list->priority;
Task_Ready_List* priority_List;
Task_Ready_List* new_priority_List;
//查找优先级链表内是否已有当前优先级
for(priority_List = &Task_Ready_List_Head; priority_List->Next != NULL; priority_List = priority_List->Next)
{
if(priority_List->Next->priority > priority)goto NEWHEAD;
if(priority_List->Next->priority == priority)break;// 当前链表优先级等于当前优先级
}
if(priority_List->Next == NULL)// 优先级链表内没有当前优先级
{
NEWHEAD:
//新建一个优先级头
new_priority_List = malloc(sizeof(Task_Ready_List));
new_priority_List->Next = priority_List->Next;
priority_List->Next = new_priority_List;
priority_List->Next->priority = priority;
priority_List->Next->Next_Task = list;
priority_List->Next->Head_Task = NULL;
}
//更换优先级链内头任务
list->Next = priority_List->Next->Head_Task;
priority_List->Next->Head_Task = list;
}
void Task_Start()
{
Task_Ready_List* priority_List;
Stack_St = SP;
Task_ADD(Free_Task, 4,55);// 添加空闲任务
//设置优先级链表中下一个启用任务
for(priority_List = Task_Ready_List_Head.Next; priority_List != NULL; priority_List = priority_List->Next)
priority_List->Next_Task = priority_List->Head_Task;
//获得当前启用任务
Now_Task = Task_Ready_List_Head.Next->Head_Task;
//修改优先级链表中下一个启用任务
if(Now_Task->Next != NULL)// 当前启用任务不是最后一个任务
Task_Ready_List_Head.Next->Next_Task = Now_Task->Next;
else // 当前启用任务是最后一个任务
Task_Ready_List_Head.Next->Next_Task = Task_Ready_List_Head.Next->Head_Task;
// 修改栈指针指向位置
SP =(uchar) Task_Ready_List_Head.Next->Head_Task->head_Stack + 1;
EA = 1;
TF0 = 1;
}
static void Free_Task()
{
EA = 1;
while(1)
{
EA = 1;
}
}

复制代码