untitled1.txt

一个多任务调度器

unsigned char KW1_count=0;      //按键延迟计数器  
unsigned char KW3_count=0;      //按键延迟计数器  
unsigned char Key_delay_count=0;//无键按下延迟计数器  
unsigned char count_500ms=0;  
unsigned int  AUO_count_val=25200;//自动状态计数变量；  
unsigned char disp_buff[3]={0,0,0};   //显示寄存器  
//unsigned int  Sec_count=25200;   //0.5秒计数器  
                      
void Hex_Bcd(unsigned int x)         
{unsigned char i;  
unsigned int j;  
j=x;  
for(i=0;i<3;i++)  
    {disp_buff[i]=j%10;  
     j=j/10;  
    }  
}                      

void off_led(void)                 
{COM1=1;  
COM2=1;  
COM3=1;  
}  

void on_led(unsigned char x)         
{if(x==0)COM1=0;  
else if(x==1)COM2=0;  
else  COM3=0;  
}  
/*  
void delay_us(unsigned char x)      
{unsigned char i;  
for (i=0;i<x;i++);  
}  
*/  
void out_164(unsigned char x)       
{unsigned char i;  
for (i=0;i<8;i++)  
     { CLK=0;  
       CLK=0;  
       if((x<<i)&0x80)DATA=1;  
       else DATA=0;  
    //  CLK=0;  
    //  CLK=0;  
       CLK=1;  
       CLK=1;  
     }  
   
}  

void cpu_kz_Init(void)              //cpu端口初始化函数  
{P1=0xff;  
P3=0xff;  
}  

void Key_Update(void)               
{if(CU_AU==0)                       
    {start_one=1;                     
     CU_AU_down_fg=1;               
     if(++CU_AU_count>200)  
       {CU_AU_down_fg=0;  
        CU_AU_count=210;  
        Work_fg=1 ;      
       }  
    }  
  else                            
    {if(CU_AU_down_fg)             
       {if((CU_AU_count>1)&&(CU_AU_count<30))  
           {CU_AU_fg=~CU_AU_fg;                 
            Work_fg=0;  
            CU_AU_down_fg=0;  
            Key_delay_count=0;  
            OUT_1KW=LED_1KW=1;  
            OUT_3KW=LED_3KW=1;  
            KW3_fg=KW1_fg=0;  
            }  
       }  
     CU_AU_count=0;    
    }     
  if(CU_AU_fg==0)                  
    {if(KW1==0)                    
       {start_one=1;                     
        KW1_count++;}  
     else  
       {if(KW1_count>1)  
           {KW1_fg=~KW1_fg;  
            Work_fg=1;  
            }  
        KW1_count=0;  
       }  
     if(KW3==0)                   
       {start_one=1;                     
        KW3_count++;  
        }  
     else  
       {if(KW3_count>1)  
           {KW3_fg=~KW3_fg;  
            Work_fg=1;  
            }  
        KW3_count=0;  
       }    
  }     
if(start_one==0)  
        {if(++Key_delay_count>200)  
           {CU_AU_fg=1;         
            Work_fg=1;  
            start_one=1;  
            }  
        }  
}  

void Disp_Update(void)          
{off_led();  
if((CU_AU_fg==1)&&(Work_fg==1))   
     {  
      Hex_Bcd(AUO_count_val/240);    
      if(led_disp_index==0)   
         {if(Sec_500ms_fg)  
           { out_164(Tab[disp_buff][0]]&0x7f);}  
          else{out_164(Tab[disp_buff][0]]);}   
         }  
          else if(led_disp_index==1)out_164(Tab[disp_buff][1]]);  
          else if(led_disp_index==2)out_164(Tab[disp_buff][2]]);  
          on_led(led_disp_index);  
     }  
else if((CU_AU_fg==1)&&(Work_fg==0))   
      {if(led_disp_index==0) out_164(Tab[0]);  
          else if(led_disp_index==1)out_164(Tab[12]);  
          else if(led_disp_index==2)out_164(Tab[10]);  
          on_led(led_disp_index);  
      }   
else if((CU_AU_fg==0)&&(Work_fg==1))   
      {if(led_disp_index==0) out_164(Tab[0]);  
          else if(led_disp_index==1)out_164(Tab[12]);  
          else if(led_disp_index==2)out_164(Tab[11]);  
          on_led(led_disp_index);  
      }   
else if((CU_AU_fg==0)&&(Work_fg==0))   
      {if(led_disp_index==0) out_164(Tab[0]);  
          else if(led_disp_index==1)out_164(Tab[12]);  
          else if(led_disp_index==2)out_164(Tab[11]);  
          on_led(led_disp_index);  
      }             
  if(++led_disp_index>2)led_disp_index=0;      
}  

void Work_Update(void)            
{if((CU_AU_fg==1)&&(Work_fg==1))   
   {if(AUO_count_val>0)  
      { if(++count_500ms>=2)  
           {Sec_500ms_fg=~Sec_500ms_fg;   
            count_500ms=0;  
            }    
        AUO_count_val-=1;  
        if(AUO_count_val>43200)        
          {LED_CUO=1;  
           LED_AUO=0;  
           OUT_1KW=LED_1KW=0;  
           OUT_3KW=LED_3KW=0;  
          }   
        else if(AUO_count_val>0)          
               {LED_CUO=1;  
                LED_AUO=0;  
                OUT_1KW=LED_1KW=0;  
                OUT_3KW=LED_3KW=1;  
               }   
        else {LED_CUO=1;LED_AUO=0;       
              OUT_1KW=LED_1KW=1;  
              OUT_3KW=LED_3KW=1;  
              Sec_500ms_fg=0;  
             }  
       }   
    }        
else if((CU_AU_fg==1)&&(Work_fg==0))    
         {LED_CUO=1;LED_AUO=0;  
          OUT_1KW=LED_1KW=1;  
          OUT_3KW=LED_3KW=1;  
         }                               
else if((CU_AU_fg==0)&&(Work_fg==1))   
        {AUO_count_val=50400;  
         LED_CUO=0;LED_AUO=1;  
         if(KW1_fg)OUT_1KW=LED_1KW=0;  
         else OUT_1KW=LED_1KW=1;  
         if(KW3_fg)OUT_3KW=LED_3KW=0;  
         else OUT_3KW=LED_3KW=1;  
        }  
else if((CU_AU_fg==0)&&(Work_fg==0))   
        {AUO_count_val=50400;  
         LED_CUO=0;LED_AUO=1;  
         OUT_1KW=LED_1KW=1;  
         OUT_3KW=LED_3KW=1;  
        }   
}  

/**************************************************  
OS_main.c  
**************************************************/  
#include "Main.h"  

static void SCH_Go_To_Sleep(void);  
static tWord Error_tick_count_G;  
static tByte Last_error_code_G;  
void SCH_Init_T0(void);         
void SCH_Start(void);  

/*****************************************  
以下程序需要根据实际情况修改  
/*****************************************/  
void cpu_kz_Init(void);  
void Key_Update(void);  
void Disp_Update(void);  
void Work_Update(void);   
/*****************************************/  
    
typedef data struct   
   {void (code * pTask)(void);    
    tWord Delay;         
    tWord Period;         
    tByte RunMe;         
   } sTask;   

void  SCH_Dispatch_Tasks(void);  
tByte SCH_Add_Task(void (code*) (void), const tWord, const tWord);    
bit   SCH_Delete_Task(const tByte);  
void  SCH_Report_Status(void);  

sTask SCH_tasks_G[SCH_MAX_TASKS];  
tByte Error_code_G = 0;  

void SCH_Dispatch_Tasks(void)   
   {  
   tByte Index;  
   for (Index = 0; Index < SCH_MAX_TASKS; Index++)  
      {  
      if (SCH_tasks_G[Index].RunMe > 0)   
         {  
         (*SCH_tasks_G[Index].pTask)();  // Run the task  
          SCH_tasks_G[Index].RunMe -= 1;   // Reset / reduce RunMe flag  
          if (SCH_tasks_G[Index].Period == 0)  
             {  
             SCH_Delete_Task(Index);  
             }  
         }  
      }  
    SCH_Report_Status();    
    SCH_Go_To_Sleep();            
   }  

tByte SCH_Add_Task(void (code * pFunction)(),   
                   const tWord DELAY,   
                   const tWord PERIOD)      
   {  
   tByte Index = 0;  
   while ((SCH_tasks_G[Index].pTask != 0) && (Index < SCH_MAX_TASKS))  
      {  
      Index++;  
      }    
   if (Index == SCH_MAX_TASKS)  
      {  
      Error_code_G = ERROR_SCH_TOO_MANY_TASKS;  
      return SCH_MAX_TASKS;    
      }  
        
   SCH_tasks_G[Index].pTask  = pFunction;  
   SCH_tasks_G[Index].Delay  = DELAY;  
   SCH_tasks_G[Index].Period = PERIOD;  
   SCH_tasks_G[Index].RunMe  = 0;  

   return Index;   
   }  


bit SCH_Delete_Task(const tByte TASK_INDEX)   
   {  
   bit Return_code;  

   if (SCH_tasks_G[TASK_INDEX].pTask == 0)  
      {  

      Error_code_G = ERROR_SCH_CANNOT_DELETE_TASK;  

      Return_code = RETURN_ERROR;  
      }  
   else  
      {  
      Return_code = RETURN_NORMAL;  
      }        
     
   SCH_tasks_G[TASK_INDEX].pTask   = 0x0000;  
   SCH_tasks_G[TASK_INDEX].Delay   = 0;  
   SCH_tasks_G[TASK_INDEX].Period  = 0;  

   SCH_tasks_G[TASK_INDEX].RunMe   = 0;  

   return Return_code;       // return status  
   }  

void SCH_Report_Status(void)  
   {  
#ifdef SCH_REPORT_ERRORS  

   if (Error_code_G != Last_error_code_G)  
      {  
      Error_port = 255 - Error_code_G;  
        
      Last_error_code_G = Error_code_G;  

      if (Error_code_G != 0)  
         {  
         Error_tick_count_G = 60000;  
         }  
      else  
         {  
         Error_tick_count_G = 0;  
         }  
      }  
   else  
      {  
      if (Error_tick_count_G != 0)  
         {  
         if (--Error_tick_count_G == 0)  
            {  
            Error_code_G = 0; // Reset error code  
            }  
         }  
      }  
#endif  
   }  


void SCH_Go_To_Sleep()  
   {  
   PCON |= 0x01;     
   //PCON |= 0x01;    // Enter idle mode (#1)  
   //PCON |= 0x20;    // Enter idle mode (#2)  
   }  

 
　  下载了两天,看了之後觉得好像看故事书-.- 
引用了超大量例子说明一件事情但却表明不了在说明的问题所要
用到的详细解决方法.其它看到210页中的一个例仔是这样子的: 
void main(void) 
{ 
        //设置调度器 
        SCH_Init_T2(); 
        //为"Flash_LED"任务准备 
        LED_Flash_Init(); 
        //增加"Flash LED"任务(1000ms亮,1000ms灭) 
        //定时单位为时标(1ms时标间隔) 
        //(最大的间隔/延迟是65535个时标) 
        SCH_Add_Task(LED_Flash_Update, 0, 1000); 
        //开始调度 
        SCH_Start();//刷新任务 
        while(1) 
        { 
                SCH_Disptch_Tasks(); 
        } 
} 
void SCH_Update(void) interrupt INTRTTUPT_Timer_2_Overflow 
{ 
        //刷新任务 
        ...... 
} 
// 
这个例子到底是如何表达这个 "合作式调度器" 呢!? 
其实是不是说在一个程程式运行的时後,就不知道将要做些什麽,要接到一些输入或者本身想要定时 
做一些时情,而家些事情将会在main 主体中置位,但是是在其中一个中断里作这些加到到的事件,当然 
在做这些事之前要先将某些要做的动作置位,这样中断里就可以利用这些置位和相关的参数做中断里
事!? 当中断(这个我想在设置调度器的时後要先输入一些参数,如是多少间隔就要查一下你有没
有事要做) 
里查到你有事要做,而参数要你做一次或多次或每隔一段时间做事的. 
假如中断查到要做一个动作就是闪led的一个动作置位了就检查这个事件的参数,
如果一次就做完後就把 
这个动作清0 如果要是做多次的就把这个参数减1 看看是否等於0,如果是的话清0(当然可以加很多动作) 
// 
但是如果加入有10个任务,检查做处理都是一个一个的顺序做把? 
我是看不太懂里面所说的调度器是不是我想的那一种.... 
// 
最初想到的一些概念是来自linux,看到书里介和网上介绍了一些linux处理任务的问题, 
要是有一个任务要做,系铳就是做这件事,要是有n种任务,它可以同时处理n个,而这种处理是自动按时 
按要用到的ram自动分配给任务,要是任务多了,就会所有任务的运作都会变慢... 
难道这书是要介绍这样的软件设计结构吗!!!!!!?????? 
// 
哪位大侠可以教教我这个合作式调度器 或者说调度器到底是什麽一个概念呢?