很糟糕的一本书，还卖那么贵，买回来仔细看才发现没什么内容

shaozh 再发一个

我同学刚买了一本，后悔死了，怎么早没看到这有下呢？

呵呵



好东西

这是项目中的实例



时间触发合作式调度器在avr中的移植（cvavr编译器）



/*****************************************************

This program was produced by the

CodeWizardAVR V1.24.7d Standard

Automatic Program Generator

?Copyright 1998-2005 Pavel Haiduc, HP InfoTech s.r.l.

http://www.hpinfotech.com

e-mail:office@hpinfotech.com



Project : os_mega16

Version :  

Date    : 2006-2-12

Author  : SHAOZH                           

Company : SZH                              

Comments:  





Chip type           : ATmega16L

Program type        : Application

Clock frequency     : 8.000000 MHz

Memory model        : Small

External SRAM size  : 0

Data Stack size     : 256

*****************************************************/



#include <mega16.h>



#define uchar unsigned char

#define uint  unsigned int

#define ulong unsigned long



void LED1_Flash(void);

void LED2_Flash(void);

void LED3_Flash(void);  

                             

/********************************************************

    ××××××××××××××公用数据类型声明××××××××××××××××××××

    每个任务的存储器总和为7个字节

********************************************************/

typedef struct {

                void (* pTask)(void);

                uint Delay;

                uint Period;

                uchar RunMe;  

               }sTask;         



/********************************************************

    ××××××××××××××公用的常数××××××××××××××××××××

    任务的最大数目

    注意：每个新建项目必须调整   

********************************************************/   

#define OS_MAX_TASKS   (4)           //每个新建项目必须调整  

//*******************************************************

#define ERROR_OS_MANY_TASKS    1      //任务满

#define ERROR_OS_DELETE_TASK   2      //任务删除

#define RETURN_ERROR           1      //任务删除  

#define RETURN_OK              0         

                 

/********************************************************

    ××××××××××××××公用变量定义××××××××××××××××××××

/********************************************************/

sTask OS_tasks_G[OS_MAX_TASKS];   //任务队列   

uchar Error_code_G=0;             //显示错误代码   

uchar old_Error_code_G=0;         //保存显示错误代码  

//*****************私有函数原型**************************

static void OS_Go_To_Sleep(void);

//*****************私有变量******************************

static uint Error_tick_count_G;   //跟踪自从上一次记录错误以来的时间

static uchar Last_error_code_G;   //上次错误代码（在一分钟后复位）



#define OS_REPORT_ERRORS  1       //1:显示错误代码  0:不显示错误代码函数   

#define OS_SLEEP_MODE     1       //1:进入空闲  0: 不进入空闲        



/********************************************************

    ××××××××××××××公用的函数原型××××××××××××××××××××

    调度器内核函数

********************************************************/               

void OS_Dispatch_Tasks(void);

uchar OS_Add_Task(void(*)(void),const uint ,const uint );

uchar OS_Delete_Task(const uchar);

void OS_Report_Status(void);   



/********************************************************

      ×××××××××××××××调度函数×××××××××××××××××

********************************************************/

void OS_Dispatch_Tasks(void)

     {uchar Index;

      for (Index=0;Index<OS_MAX_TASKS;Index++)

           {if(OS_tasks_G[Index].RunMe>0)     

              { (*OS_tasks_G[Index].pTask)();

                OS_tasks_G[Index].RunMe-=1;

                if(OS_tasks_G[Index].Period==0)

                  {OS_Delete_Task(Index);

                  }

              }

           }                           

     // OS_Report_Status();  //报告系统状态

     // OS_Go_To_Sleep();    //进入空闲模式      

     }

/********************************************************

      ×××××××××××××××加任务函数×××××××××××××××××

      Fn_P    任务名  （必须是无传人参数，无返回值的任务）

      DELAY   在任务第一次被运行之前的间隔（时标）

      PERIOD  如果为 0 ：该函数将在DELAY确定的时间被调用一次

              如果为非0 ： 该函数将按DELAY的值在确定的时间被重复调用

********************************************************/  

uchar OS_ADD_Task(void (*pFunction)(),const uint DELAY,const uint PERIOD)

      {uchar Index=0;

       while ((OS_tasks_G[Index].pTask!=0)&&(Index<OS_MAX_TASKS))

             {Index++;

             }         

       if(Index==OS_MAX_TASKS)

         {Error_code_G=ERROR_OS_MANY_TASKS;   //设置全局错误变量

          return OS_MAX_TASKS;                //返回错误代码

         }      

       OS_tasks_G[Index].pTask=pFunction;

       OS_tasks_G[Index].Delay=DELAY;

       OS_tasks_G[Index].Period=PERIOD;

       OS_tasks_G[Index].RunMe=0;

       return Index;   

      }

/********************************************************

      ×××××××××××××××删除任务函数×××××××××××××××××

********************************************************/  

uchar OS_Delete_Task(const uchar TASK_INDEX)

    {bit Return_code;

     if(OS_tasks_G[TASK_INDEX].pTask==0)

        {Error_code_G=ERROR_OS_DELETE_TASK;  //设置全局错误变量

         Return_code=RETURN_ERROR;           //返回错误代码

        }

     else

        {Return_code=RETURN_OK;

        }  

     OS_tasks_G[TASK_INDEX].pTask=0x0000;

     OS_tasks_G[TASK_INDEX].Delay=0;

     OS_tasks_G[TASK_INDEX].Period=0;

     OS_tasks_G[TASK_INDEX].RunMe=0;

     return Return_code;                   //返回状态

    }                                                

/********************************************************

      ×××××××××××××××显示错误代码函数×××××××××××××××××

********************************************************/  

#if OS_REPORT_ERRORS

void OS_Report_Status()

     {

             if(Error_code_G!=old_Error_code_G)

               {  

                //在次处编写错误显示程序

                old_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;        //复位错误代码

                     }

                  }

               }                              

     }                                

#endif

/********************************************************

      ×××××××××××××××进入空闲函数×××××××××××××××××

********************************************************/  

#if OS_SLEEP_MODE   

#include <SLEEP.h>

void OS_Go_To_Sleep(void)

  { sleep_enable();  //使能进入空闲

    idle();          //进入空闲      

  }                             

#endif   

/********************************************************

      ×××××××××××××××调度器初始化函数×××××××××××××××××

********************************************************/

void OS_Init_T0(void)

     {uchar i;

      for(i=0;i<OS_MAX_TASKS;i++)

         {OS_Delete_Task(i);

         }                  

      Error_code_G=0;

      // Timer/Counter 0 initialization

// Clock source: System Clock

// Clock value: 125.000 kHz

      TCCR0=0x03;

      TCNT0=0x7D;

// Timer(s)/Counter(s) Interrupt(s) initialization

      TIMSK=0x01;   

     }                                             

/********************************************************

      ×××××××××××××××启动调度器函数×××××××××××××××××

********************************************************/      

OS_Start(void)

     {#asm("sei")

     }     

      

/********************************************************

      ×××××××××××××××调度中断函数×××××××××××××××××

********************************************************/

interrupt [TIM0_OVF] void timer0_ovf_isr(void)

{uchar Index;

TCNT0=0x7D;

for(Index=0;Index<OS_MAX_TASKS;Index++)

    {if(OS_tasks_G[Index].pTask)

       {if(OS_tasks_G[Index].Delay==0)

           {OS_tasks_G[Index].RunMe+=1;

            if(OS_tasks_G[Index].Period)

              {OS_tasks_G[Index].Delay=OS_tasks_G[Index].Period;

              }

           }                                                     

        else

          {OS_tasks_G[Index].Delay-=1;

          }   

       }

    }



}   





void main(void)

{

// Declare your local variables here



// Input/Output Ports initialization

// Port A initialization

// Func7=Out Func6=Out Func5=Out Func4=Out Func3=Out Func2=Out Func1=Out Func0=Out  

// State7=0 State6=0 State5=0 State4=0 State3=0 State2=0 State1=0 State0=0  

PORTA=0x00;

DDRA=0xFF;



// Port B initialization

// Func7=Out Func6=Out Func5=Out Func4=Out Func3=Out Func2=Out Func1=Out Func0=Out  

// State7=0 State6=0 State5=0 State4=0 State3=0 State2=0 State1=0 State0=0  

PORTB=0x00;

DDRB=0xFF;



// Port C initialization

// Func7=Out Func6=Out Func5=Out Func4=Out Func3=Out Func2=Out Func1=Out Func0=Out  

// State7=0 State6=0 State5=0 State4=0 State3=0 State2=0 State1=0 State0=0  

PORTC=0x00;

DDRC=0xFF;



// Port D initialization

// Func7=In Func6=Out Func5=In Func4=In Func3=In Func2=In Func1=In Func0=In  

// State7=T State6=0 State5=T State4=T State3=T State2=T State1=T State0=T  

PORTD=0x00;

DDRD=0x40;



// Timer/Counter 0 initialization

// Clock source: System Clock

// Clock value: 125.000 kHz

// Mode: Normal top=FFh

// OC0 output: Disconnected

TCCR0=0x03;

TCNT0=0x7D;

OCR0=0x00;



// Timer/Counter 1 initialization

// Clock source: System Clock

// Clock value: Timer 1 Stopped

// Mode: Normal top=FFFFh

// OC1A output: Discon.

// OC1B output: Discon.

// Noise Canceler: Off

// Input Capture on Falling Edge

// Timer 1 Overflow Interrupt: Off

// Input Capture Interrupt: Off

// Compare A Match Interrupt: Off

// Compare B Match Interrupt: Off

TCCR1A=0x00;

TCCR1B=0x00;

TCNT1H=0x00;

TCNT1L=0x00;

ICR1H=0x00;

ICR1L=0x00;

OCR1AH=0x00;

OCR1AL=0x00;

OCR1BH=0x00;

OCR1BL=0x00;



// Timer/Counter 2 initialization

// Clock source: System Clock

// Clock value: Timer 2 Stopped

// Mode: Normal top=FFh

// OC2 output: Disconnected

ASSR=0x00;

TCCR2=0x00;

TCNT2=0x00;

OCR2=0x00;



// External Interrupt(s) initialization

// INT0: Off

// INT1: Off

// INT2: Off

MCUCR=0x00;

MCUCSR=0x00;



// Timer(s)/Counter(s) Interrupt(s) initialization

TIMSK=0x01;



// Analog Comparator initialization

// Analog Comparator: Off

// Analog Comparator Input Capture by Timer/Counter 1: Off

ACSR=0x80;

SFIOR=0x00;

OS_ADD_Task(LED1_Flash,0,250);    //led1闪烁频率2Hz

OS_ADD_Task(LED2_Flash,3,500);    //led2闪烁频率1Hz

OS_ADD_Task(LED3_Flash,7,1000);   //led3闪烁频率0.5Hz

OS_Start();

// Global enable interrupts

//#asm("sei")



while (1)

      {

       OS_Dispatch_Tasks();

      };

}



/************************************************

my_mega16_dome.c

************************************************/

#define LED1   PORTD.6

#define LED2   PORTC

#define LED3   PORTA

void LED1_Flash(void)

{ LED1^=1;

}

void LED2_Flash(void)

{ LED2^=0xff;

}

void LED3_Flash(void)

{ LED3^=0xff;

}

以上程序硬件实验通过



－－－－－－－－－－项目实例－－－－－－－－－－－

#include "Main.H"





#define  CU_AU     P3_0

#define  KW1       P3_1

#define  KW3       P3_2

#define  LED_3KW   P3_3

#define  LED_1KW   P3_4

#define  LED_CUO   P3_5

#define  LED_AUO   P3_7

#define  OUT_1KW   P1_1

#define  OUT_3KW   P1_2

#define  COM1      P1_7

#define  COM2      P1_6

#define  COM3      P1_5

#define  DATA      P1_4

#define  CLK       P1_3

                          //  0     1    2    3    4    5    6   

const unsigned char Tab[13]={0xf9,0xc0,0xa4,0xb0,0x99,0x92,0x82,

                     //  7     8    9    A    C    U      

                        0xf8,0x80,0x90,0x88,0xc6,0xc1};





bit CU_AU_fg=0;       //  0  手动 ；1   自动；

bit Work_fg=0;        //  0  停止 ；1   工作；

bit AU_start_fg=0;    //  0  自动状态不工作；1 自动状态工作；

bit KW1_fg=0;         //  0  停止 ；1   工作；  

bit KW3_fg=0;         //  0  停止 ；1   工作；

bit CU_AU_down_fg=0;  //键按下标志；

bit Sec_500ms_fg=0;   //500ms标志；

bit start_one=0;      //开机有无键按下标志；

unsigned char led_disp_index=0; //数码管扫描指针；

unsigned int  CU_AU_count=0;    //按键延迟计数器

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=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)

   }