μ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^;
 void del10ms()
 {
     unsigned char a,b,c;
     for (c=;c>;c--)
         for(b=;b<;b++)
            for(a=;a<;a++);
 }
 void task_1()
 {
     while()
     {
         if(K1==)
             del10ms();
           if(K1==)
             {
                 task_switch();
             }
     }
 }

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

 void task_3()
 {

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

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

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

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]+;　　　　　//这里取出了当前正在运行的任务的函数地址的高八位存为指针
     OS_Stack[T_ID][] = (unsigned int)FN & 0xff;  //低八位存0
     OS_Stack[T_ID][] = (unsigned int)FN << ; 　　//高八位存在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=;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; 
 }

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

么么哒，求赞=_=