中文代码内核文件－－调度

//版权声明：
//  本代码为开源代码，作者拥有代码版权，但你可以在任何非商业用途程序中引用，但请标注出处，你
// 也可以对代码进行更改。作者对代码中所包括的错误以及所造成的一切后果将不负任何责任。如果你发
// 现代码中有任何问题或错误，请与我联系。
//  联系方法：QQ 2367051920，Email：nvwa-xt@qq.com
//                                                     －－－－－作者：朱晓辉 2013年11月11日
//======================
//--------调度--------
//======================
//-----------开始-----------------

无返回值  定时器启动(无参数);

//=======================================
//函名    :       调度器上锁
//传入参数:       无
//返回值  :       无
//=======================================
无返回值  调度器_关(无参数)
{
  　中断=禁止中断;
  如果((系统管理块.系统运行标志==系统运行)&&(系统管理块.调度锁==0))
    　　　{ 系统管理块.调度锁=1; }
  　中断=允许中断;
}
//=======================================
//函名    :       调度器解锁
//传入参数:       无
//返回值  :       无
//=======================================
无返回值  调度器_开(无参数)
{
  中断=禁止中断;
  如果((系统管理块.系统运行标志==系统运行)&&(系统管理块.调度锁 > 0))
    　　　　{ 系统管理块.调度锁=0; }
  中断=允许中断;
}
//==========================================
//函名    :       从普通队列中取出任务号
//传入参数:       无
//返回值  :       无
//==========================================
整数8  任务号(无参数)
{
  整数8  运行号;
  整数8  就绪号;
  整数8  任务号;
  任务号=运行表[0];

  如果(运行表[0] !=0)
   {
     循环(就绪号=1,运行号=0;就绪号<任务总数;就绪号++)
      {
         运行表[ 就绪号-1 ]=0;  
                        　　　　　　　　　　　　　　 //后一个清零       
      如果(运行表[就绪号] != 0)
          {
            运行表[运行号]=运行表[就绪号];          //移动任务号的位置,
            运行号++;
          }
           
      如果((运行表[就绪号] != 0) && (就绪号==(任务总数-1)))
          {
            运行表[就绪号]=0;
          }        
       }
    }

  返回(任务号); 

}
//==========================================
//函名    :       从优先队列中取出任务号  
//传入参数:       无
//返回值  :       无
//==========================================
整数8  优先_任务号(无参数)
{
  整数8  运行号;
  整数8  就绪号;
  整数8  任务号;
  任务号=优先_运行表[0];

  如果(优先_运行表[0] !=0) 　　　　　　　　　　　　　　　　　　　　//0号位不为0,更新事件运行表,
   {
     循环(就绪号=1,运行号=0;就绪号<任务总数;就绪号++)
      {
         优先_运行表[ 就绪号-1 ]=0;                   　　　　　　　　//后一个清零       
     如果(优先_运行表[就绪号] != 0)
          {
            优先_运行表[运行号]=优先_运行表[就绪号];       　　　　//移动任务号的位置,
            运行号++;
          }          
     如果((优先_运行表[就绪号] != 0) && (就绪号==(任务总数-1)))
          　　{ 优先_运行表[就绪号]=0; }                          
       }
    } 
  　　如果(优先_运行表[0] ==0)    　　　　　　　　　　　　　　　　　　　//运行队列有无任务判断,
   　　　　　　{ 优先运行=无优先任务;}
  　　返回(任务号);
}
//==========================================
//函名    :       更新普通运行队列
//传入参数:       无
//返回值  :       无
//==========================================
无返回值   运行表_更新(无参数)
{
  整数8  运行号;
  整数8  就绪号;
 
  循环(运行号=0,就绪号=0;就绪号<任务总数;就绪号++)
   {
     如果(运行表[就绪号]!=0)
      { 运行表[运行号]=运行表[就绪号];        
        运行号++;
       }
     如果((运行表[就绪号]!=0)&&(就绪号==任务总数-1)&&(运行号<就绪号))  
      { 运行表[就绪号]=0 ;} 
   }
}
//==========================================
//函名    :       更新优先运行队列
//传入参数:       无
//返回值  :       无
//==========================================
无返回值   优先运行表_更新(无返回值)
{
  整数8  运行号;
  整数8  就绪号;
 
  循环(运行号=0,就绪号=0;就绪号<任务总数;就绪号++)
   {
     如果(优先_运行表[就绪号]!=0)
          { 优先_运行表[运行号]=优先_运行表[就绪号];       
           运行号++;
          }
     如果((优先_运行表[就绪号]!=0)&&(就绪号==任务总数-1)&&(运行号<就绪号))  
            {  优先_运行表[就绪号]=0 ;} 
   }
}
//==========================================
//函名    :       普通运行对列登记
//传入参数:       任务号
//返回值  :       无
//==========================================
无返回值  运行表登记(整数8  登记号)
{
  整数8  位;

       循环(位=0;位<任务总数;位++)       　　　　　　　 //在运行队列中登记,
         {
           如果(运行表[位]==0)
             {
                运行表[位]=登记号;
                系统任务块[登记号].任务状态=运行;
                位=任务总数;
              }
         }
}
//==========================================
//函名    :       优先运行队列登记
//传入参数:       任务号
//返回值  :       无
//==========================================
无返回值  优先运行表登记(整数8  登记号) 
{
  整数8  位;

    循环(位=0;位<任务总数;位++)       
          {
            如果(优先_运行表[位]==0)
             {
               优先_运行表[位]=登记号;
               系统任务块[登记号].任务状态=运行;
               位=任务总数;
             }
           }
  　 优先运行=有优先任务;     //有优先任务要运行,  
}
//==========================================
//函名    :       清除就绪登记（普通队列） 
//传入参数:       任务号
//返回值  :       无
//==========================================
无返回值  运行表清除( 整数8  清除号) 
{
     整数8  位;

         循环(位=0;位<任务总数;位++)
             　 {  如果(运行表[位]==清除号)  　　　//查找相应的任务号,
                  {
                    运行表[位]=0;
                    运行表_更新();             //运行队列更新,    
                    位=任务总数;                                        
                   }       
               　}    
}
//==========================================
//函名    :       清除就绪登记（优先队列） 
//传入参数:       任务号
//返回值  :       无
//==========================================
整数8  优先运行表清除( 整数8  清除号) 
{
     整数8  位;
     整数8  操作信息;

     操作信息=0x00;
         循环(位=0;位<任务总数;位++)
              {  如果(优先_运行表[位]==清除号)  //查找相应的任务号,
                  {
                    优先_运行表[位]=0;
                    优先运行表_更新();             //运行队列更新,    
                    位=任务总数;
                    操作信息=0xff;       
                   }       
               }    
     　　返回(操作信息);
}　
//==========================================
//函名    :       任务调度
//传入参数:       无
//返回值  :       无
//==========================================
无返回值   任务调度(无参数)      　　　 //数据自动进栈
{
#如果   任务调度_形式 == 1
整数8   地址;
整数8   任务栈位置;
整数8   公共栈位置;
整数8   i;
#如果结束 

  中断=禁止中断;

  如果(系统管理块.系统运行标志!=系统运行)      　　　　　 //运行标志
   { 中断=允许中断;返回;}

  如果(系统管理块.调度锁!=0)          　　　　　　　　　//调度锁
   { 中断=允许中断;返回;}

  如果(系统管理块.中断嵌套!=0)          　　　　　　　　//中断嵌套
   { 中断=允许中断;返回;}

  如果(系统管理块.系统状态==服务模式)     　　　　　//模式
   { 中断=允许中断;返回;}

  如果(系统管理块.时间片!=0)         　　　　　//时间片
   { 中断=允许中断;返回;}
 
#如果 实时任务==0 　　　　　　　　　　　　　　　//实时任务功能无效
  如果(系统管理块.新运行号==0)
   { 如果( 优先运行==有优先任务)
      { 系统管理块.新运行号=优先_任务号();}   　　　　//从优先队列中取得任务号,
     否则
      { 系统管理块.新运行号=任务号(); }     　　　　　//从普通队列中取得任务号,
    }
#如果结束
#如果 实时任务==1
  如果(系统管理块.新运行号==0)
   {
  如果(就绪表!=0)
  {系统管理块.新运行号=实时任务号();}
   否则
   {
     如果( 系统管理块.优先运行=有优先任务)
        { 系统管理块.新运行号=优先_任务号();}   　　　　　　　　　　　　//从优先队列中取得任务号,
        否则
        { 系统管理块.新运行号=任务号(); }     　　　　　　　　　　　　//从普通队列中取得任务号,
      }
#如果结束
 如果(系统任务块[系统管理块.新运行号].任务类型==普通任务)
  {系统管理块.时间片 = 时间片_长度; }          　　　　　　　　　　　//重新配置时间片,

#如果  任务调度_形式  == 0
  如果(系统管理块.运行号!=系统管理块.新运行号)
   {
     入栈；     //保存运行任务的断点数据　　　　　　入栈函数还没写，需要用汇编才行，这里暂时用这表明下
   
  
           系统任务块[系统管理块.运行号].任务栈顶=堆栈指针; //保存栈顶地址　　　　　　　　　　　　堆栈指针＝ＳＰ　
           系统管理块.运行号=系统管理块.新运行号;
           系统管理块.新运行号=0;
           堆栈指针=系统任务块[系统管理块.运行号].任务栈顶; //取得栈顶地址
    
     出栈；        //恢复新任务的断点数据　　　　　　　　　　　　　出栈函数还没写，需要用汇编才行，这里暂时用这表明下
    
 
    }

#如果结束

#如果   任务调度_形式 == 1
//-----
     如果(系统管理块.运行号!=系统管理块.新运行号)
         {
     　　　入栈；

           地址=运行栈;
           系统任务块[系统管理块.运行号].任务栈顶=堆栈指针 - 地址;
//-----
           任务栈位置=0;
           公共栈位置=0;          
           循环(i=系统任务块[系统管理块.运行号].任务栈顶; i>0 ; i--)
            {
              公共栈位置 ++;
              任务栈位置 ++;
              任务栈[系统管理块.运行号][任务栈位置] = 运行栈[公共栈位置];
             }
//-----
           系统管理块.运行号=系统管理块.新运行号;
           系统管理块.新运行号=0;
//-----
           任务栈位置=0;
           公共栈位置=0;          
           循环(i=系统任务块[系统管理块.运行号].任务栈顶; i>0 ; i--)
            {
              公共栈位置 ++;
              任务栈位置 ++;
              运行栈[ 公共栈位置 ] =  任务栈[系统管理块.运行号][任务栈位置] ;
             }
           堆栈指针=运行栈 + 系统任务块[系统管理块.运行号].任务栈顶 ;
         
    　　　　出栈；

     }         
#如果结束
  中断=允许中断;
} 
//==========================================
//函名    :       系统启动 
//设计人  :       陈 旭 武
//传入参数:       无
//返回值  :       无
//==========================================
无返回值  系统_启动(无参数)
{
#如果   任务调度_形式 == 1
整数8   任务栈位置;
整数8   公共栈位置;
整数8   i;
#如果结束 

  中断=禁止中断;
  系统管理块.系统运行标志 = 系统运行;    //运行标志为真  
  系统管理块.系统状态 = 运行模式;  //系统进入运行模式

  定时器启动();               //定时器启动,
 
  如果(系统管理块.新运行号==0)
   { 如果( 优先运行==有优先任务)
      { 系统管理块.新运行号=优先_任务号();}    //从优先队列中取得任务,
     否则
      { 系统管理块.新运行号=任务号(); }      //从普通队列中取得任务,
    }
  　　　系统管理块.时间片 = 时间片_长度;            //为运行任务配置一个时间片,
#如果  任务调度_形式  ==  0

        系统管理块.运行号=系统管理块.新运行号;
        系统管理块.新运行号=0;
        堆栈指针=系统任务块[系统管理块.运行号].任务栈顶; //取得栈顶地址
 　　　出栈；

#如果结束

#如果  任务调度_形式  ==  1

           系统管理块.运行号=系统管理块.新运行号;
           系统管理块.新运行号=0;

           任务栈位置=0;
           公共栈位置=0;          
           循环(i=系统任务块[系统管理块.运行号].任务栈顶; i>0 ; i--)
            {
              公共栈位置 ++;
              任务栈位置 ++;
              运行栈[ 公共栈位置 ] =  任务栈[系统管理块.运行号][任务栈位置] ;
             }
           堆栈指针=运行栈 + 系统任务块[系统管理块.运行号].任务栈顶 ;
         
　　　　　　出栈；
#如果结束

  中断=允许中断;
}             

//====================================
//--------------结束------------------
//====================================

转载于:https://my.oschina.net/896822132/blog/175421