μc/osⅡ简化版任务机制浅析

　　去年玩过一阵单片机，也用过μc/osⅡ的系统，但是就理解内核而言，整个即时操作系统还是过于冗杂，很多的东西很不适合初学者来动手操作，多方查找我发现他的任务机制可以进行功能的进一步简化，

可以类似于任务栈的方式，使用纯C写成而不用汇编代码，闲话少说上代码吧。

　　我的github上有我的渣代码=_=：https://github.com/lfkdsk

　　灵魂画作任务图： 

随手就是灵魂画作=-=

　　1.主函数：

#include "OS_task.h"
#include "89c51.h"
#include "main.h"
#include "task_switch.h"
#include <reg52.h>
sbit K1=P0^0;
void del10ms()
{
    unsigned char a,b,c;
    for (c=1;c>0;c--)
        for(b=0;b<38;b++)
           for(a=0;a<130;a++);
}
void task_1()
{
    while(1)
    {
        if(K1==0)
            del10ms();
          if(K1==0)
            {
                task_switch();    
            }
    }
}

void task_2()
{
    while(1)
    {
        if(K1==0)
            del10ms();
          if(K1==0)
            {
                task_switch();    
            }
    }
}

void task_3()
{

    while(1)
    {
        if(K1==0)　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　//这里是五个放在任务栈里的空函数，只用里一个循环来循环监听按键，可以再循环中加入自己的东西，比如亮起小灯啊，什么的易于观察的现象
            del10ms();
          if(K1==0)
            {
                task_switch();    
            }
    }
}

void task_4()
{
    while(1)
    {
        if(K1==0)
            del10ms();
          if(K1==0)
            {
                task_switch();    
            }
    }
}

void task_5()
{
    while(1)
    {
        if(K1==0)
            del10ms();
          if(K1==0)
            {
                task_switch();    
            }
    }
}
void main(void)
{
//    载入函数 优先级 任务名 任务ID
    task_load(2,task_1, 0);
    task_load(3,task_2, 1);
    task_load(4,task_3, 2);
    task_load(5,task_4, 3);
    task_load(6,task_4, 4);
    OS_Start(0);
}

2.任务装载（核心）：

#ifndef __OS_TASK_H__
#define __OS_TASK_H__
//任务功能
    //最大任务数
#define MAX_TASK 5
    //堆栈深度
#define SRACK_DEPTH 20
    //保存切换任务时软件压栈字节数
#define Num_PUSH_bytes 13
    //程序控制块结构
typedef struct 
{
     unsigned char Task_SP;       //任务堆栈指针
     unsigned char Priority;      //优先级，值越小，优先级越高

}PCB;

extern idata volatile PCB OS_PCB[MAX_TASK];//定义堆栈
extern volatile unsigned char OS_TASK_ID;//定义任务ID
void task_load(unsigned char PRI,unsigned int FN,unsigned char T_ID);
void OS_Start(T_ID);
#endif

//系统任务程序
#include "OS_task.h"
#include "89c51.h"
#include "main.h"
#include "task_switch.h"
#include <reg52.h>
//程序控制块
idata volatile PCB OS_PBC[MAX_TASK];　　　　//volatile是为了每次必须读值　这个是任务栈的最大任务数，任务栈名字叫PCB=-=

//当前运行任务的ID号
volatile unsigned char OS_TASK_ID;　　　　　　

//声明堆栈，由最大任务数和栈深定义的二维数组
unsigned char idata OS_Stack[MAX_TASK][SRACK_DEPTH];　　　　

//任务装载函数
void task_load(unsigned char PRI,unsigned int FN,unsigned char T_ID)
{
    OS_PCB[T_ID].Priority=PRI;　　　　　　　　　　　　//因为是简化的，所以我手动设置了优先级
    OS_PCB[T_ID].Task_SP=OS_Stack[T_ID]+1;　　　　　//这里取出了当前正在运行的任务的函数地址的高八位存为指针
    OS_Stack[T_ID][0] = (unsigned int)FN & 0xff;  //低八位存0
    OS_Stack[T_ID][1] = (unsigned int)FN << 8; 　　//高八位存在1里
}

//任务运行函数
void OS_Start(T_ID)
{
    OS_TASK_ID=T_ID;
    SP=OS_PCB[OS_TASK_ID].Task_SP;    　　　　//传入一个id，然后把sp指针指向它，sp指针是系统的任务指针，用于指向执行任务的
    　　　　　　　　　　　　　　　　　//之后就不管了，就会按照自己的方式运行了
}

3.任务切换：

//任务交换程序
#include "OS_task.h"
#include "89c51.h"
#include "main.h"
#include "task_switch.h"
#include <reg52.h>
//任务调度函数
void task_switch(){
    static int i;
    unsigned char j,MAX; 
    OS_PCB[OS_TASK_ID].Task_SP = SP; 　　　　　　//先把运行的指针地址存到该任务id对应的指针空间中
    for(i=0;i<MAX_TASK;i++)
    {
        MAX=j;　　　　　　　　　　　　　　　　　　　　//然后在循环找到优先级最高的（Priority最小的）
if(OS_PCB[j].Priority<OS_PCB[i].Priority||j!=OS_TASK_ID) //如果优先级高，则切换之 
 { 
　　　　j=i; 
 　　　　} 
 } 
　　　　OS_TASK_ID=j; 
　　　　SP = OS_PCB[OS_TASK_ID].Task_SP; 
}

好了，到这我们的精简版任务机制就搞定了，大家可以去试试啦，利用类堆栈的存储函数运行地址的方式进行挂起操作，来循环运行任务

么么哒，求赞=_=