上传《时间触发嵌入式系统设计模式 8051系列微控制器开发可靠应用》PDF

winter

下载的超星格式，然后自己转成PDF的



点击此处打开armok01153597.pdf

caolong

好东西  顶！！！！！！！！！！！！！！！！！！

zhanjay

非常好的东东，谢谢

luo730210

好东西

yangsen

收下，谢谢了

Gorgon_Meducer

强烈推荐这本书！我买过！

archeng504

想必是好书，下来看看，谢了

powerful

楼主辛苦了！

abc2001

非常感谢．

sswanglei

我来补上本书带的光盘相关代码~

点击此处下载armok01153619.rar

jerico

谢谢你们的资料,这本书好不好呢..

diannaoza

非常谢谢

shabby

Gorgon Meducer 傻孩子 都推荐这本书，不下不行呀。

ansion520

好东东,顶你!

ATmega8515

这本书多少钱一本？

winter

当当和卓越都卖60

sswanglei

看电子版就行啦。我买了本，都没怎么看。  这本书挺厚，但字间距比较大，内容并不是很多，价格还比较贵。

liuqian

谢谢

AuToCTRL

下载了,呵呵

finenesszhang

已下载。。。

谢谢

eddia2000

我一直在找它啊,今天能下到它真是好開心,謝謝樓主的共享!!!

swordKING

前几天刚刚看到说这是一本好书,谢谢

cyberjok

这书没有什么的，看看它的代码就行，没有什么独到之处，书要85啊，好像，不值。。。

TonyCai

抢了，谢了，小林=winter

shaozh

我两年前发的时间触发嵌入式系统设计模式在avrM8中的移植贴，老早就被删啦!唉！还有完整的实例呢！

zhuyi

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

AVR_AFA

我买过这本书，很好的一本书。



讲了很多很实用的东西，电子基础方面及时间调度系统都写的非常好。



谢谢楼主分享。

ningmeng7294

shaozh 再发一个

wj414

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

呵呵



好东西

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)

   }

shaozh

多发啦
-----此内容被shaozh于2007-05-15,15:28:47编辑过

eddia2000

不錯哦.收下了.

ddllxxrr

看这大家都说不错，那一定没错，我收了，谢谢

Forever

一定要顶一下，太好了！强烈支持！

mtxmxt

谢谢楼主、9楼的朋友。

zhiwei

多谢分享。

mljda

跟风学习

chendaon

顶一下，跟风学习

lan_boy001

值得赞扬！！能够把超星的转成PDF！！

lan_boy001

怎么下载速度只有几K啊？？amoke现在这个速度怎么这么慢呐、、、、、、、、、？？？？？？？？？？？

7782736

已下载。。。

谢谢

edawn

感谢感谢，可以不用去买了。

下载中....

jacky2602000

呵呵,找了很久了啊.终于等到了.感谢!!!

simone

网上有一个版本，档案大小跟这个一样，不知是不是同一个版本

分辨度不够，看来不够清楚

leon11hk

下载了两天,看了之後觉得好像看故事书-.-

引用了超大量例子说明一件事情但却表明不了在说明的问题所要用到的详细解决方法.其它看到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自动分配给任务,要是任务多了,就会所有任务的运作都会变慢...

难道这书是要介绍这样的软件设计结构吗!!!!!!??????

//

哪位大侠可以教教我这个合作式调度器 或者说调度器到底是什麽一个概念呢?

bobowu

谢谢lz,收下了,好好学习学习

liyangbbs

最近在学校图书馆借的。光盘也有。感觉光盘内容很不错的，推荐一下。既然上面已经有仁兄上载了，我也省了。

poppush

记号        要看

ycii

谢谢了..又有一些感悟.

btjlp

非常感谢

fugeone

此书相当好！！！买过了！！！

andyli

好东西，谢谢。

dgdzov

好东西，顶一下

liqu

Gorgon Meducer,你的书名是什么，什么时间出版？

stevenlu

在书店看到了，好厚哦，
支持一下

ecat

26兆，好大的文件啊。

zgx2008

顶!

huys02

的确好书，最近从图书馆刚借的，还在看，硬件软件设计思想讲的很清晰。

astankvai

呵呵，我在学校看过这本书，当时没有什么时间看(应试教育要忙着考试)，可惜，下了超星的，现在超星要收费了，麻烦。这个是好东东来的啊，顶起来。

huys02

传文件很慢啊，还想把一本“电子学艺术”这本电子书也上传的，英文版的，The Art of Electronics。

huys02

500多M的随书CD上传就失败了，就传 The Art of Electronics
Djvu格式的，该阅读器（绿色版）可以另外再下，
上传文件的确很要耐性。。比下载慢多了

bozai

顶！这书我有一本。很不错。

wqsjob

先顶一下

lane1984ks

谢谢楼主分享

viqomk

还可以,谢啦!~正在学习中!

blocksky

好东西！支持，感谢！

hlb_312991

谢了！

shawn_17

楼主能不能也把光盘源码共享出来啊？期待中

winter

9楼小乐传了

lovechenhui

呵呵，顶一个，图书馆有，但是要考试了，没时间看，呵呵～

hnywx

顶一个                                   .

gvren

太好了，我正准备买，先看看再说。感谢楼主。

proco

谢谢共享

stayzhang

有看过，不要犹豫，是本好书。

vxfxv

谢谢！上次下到99%然后断在那了。终于又找到了。

xlxlab

真是不错

tiandinanhai

好东西，感谢好人的无私奉献
宝贝！！

jiu123

3q

dk7725

好东西

RayXP

mark

jjj206

好书不下对不起自己~

kucooboy

顶上

chiwenhu

这书我在书城
也看过
不错

lengqing1309

MARK

wangff2531

时间触发嵌入式系统设计模式 8051系列微控制器开发可靠应用  留个记号

chjf

不错，正在下载。

tonysu

好书共享

xingli99

谢谢!!!顶你!

LBH101

支持一下，好资料

dasuantou

顶你一W次. 支持好书PDF免费化,这也是强迫"开源".

dzyong

公司下一次，家里再来下一次，傻孩子都说好，一定值得下！~~~~~~~~

smiler

好书，以前一点都看不懂、现在有点晕，但每看一次都有收获。

zkf0100007

多谢分享

maxsuntech

頂

xlshaoscu

嘿嘿，刚从图书馆借了这本书正在看，很好的一本书，正在研读中

tear086

mark

AIHHLI

按个爪印...

tedden

顶，谢谢楼主分享～

yihongmeilang

谢谢

wukaka

感谢：
楼主和【29楼】 shaozh
提供的好资料！