原创 建立一个属于自己的AVR的RTOS(问题分析)

   如果大家读过黄健昌先生的《建立一个属于自己的AVR的RTOS》一文，相信一定会佩服他对OS的见解，可见水平之高。据我所知，这篇文章是黄先生在很短时间内完成的，黄先生是一位擅长Java、JavaEE和Web服务技术的顾问，目前就职于Sun中国工程研究院,任职Technical Consultant，负责Sun Java Enterprise System(JES)产品支持和Java技术咨询. 您可以通过Jason.Huang@Sun.com与他联系。另他的著作有《GlassFish——开源的 JAVA EE应用服务器》，喜欢开源的朋友可以看一下。
    那么现在我就黄先生写的建立一个属于自己的AVR的RTOS中的一部分难理解的内容作我个人的解释，由于本人水平很菜，切入到AVR时间不长，有两个月时间，所以个人观点可能不完全正确，如果您是高手，就不要看下去了，相信您一定对这些问题研究上百遍了，然而对于新手来说，对OS的理解相当有帮助！
    时间原因，不能一一解释，如果大家还有疑问，可以给我发邮件，我会尽快回复！
/*********************************************************************************************************************************************/
/*
第六篇:时间片轮番调度法的内核  

                                 Round-Robin Sheduling 

    时间片轮调法是非常有趣的。本篇中的例子，建立了3个任务，任务没有优先级，在时间中断的调度下，每个任务都轮流运行相同的时间。如果在内核中没有加入其它服务，感觉上就好像是有三个大循环在同时运行。 

    本例只是提供了一个用时间中断进行调度的内核，大家可以根据自己的需要，添加相应的服务。 
    要注意到:  
    1,由于在时间中断内调用了任务切换函数，因为在进入中断时，已经将一系列的寄存器入栈。 
    2,在中断内进行调度，是直接通过"RJMP Int_OSSched"进入任务切换和调度的，这是GCC AVR的一个特点，为用C编写内核提供了极大的方便。 
    3,在阅读代码的同时，请对照阅读编译器产生的 *.lss文件，会对你理解例子有很大的帮助。 
*/      
/*
第六篇:时间片轮番调度法的内核  

                                 Round-Robin Sheduling 

    时间片轮调法是非常有趣的。本篇中的例子，建立了3个任务，任务没有优先级，在时间中断的调度下，每个任务都轮流运行相同的时间。如果在内核中没有加入其它服务，感觉上就好像是有三个大循环在同时运行。 

    本例只是提供了一个用时间中断进行调度的内核，大家可以根据自己的需要，添加相应的服务。 
    要注意到:  
    1,由于在时间中断内调用了任务切换函数，因为在进入中断时，已经将一系列的寄存器入栈。 
    2,在中断内进行调度，是直接通过"RJMP Int_OSSched"进入任务切换和调度的，这是GCC AVR的一个特点，为用C编写内核提供了极大的方便。 
    3,在阅读代码的同时，请对照阅读编译器产生的 *.lst文件，会对你理解例子有很大的帮助。 
*/    
#include <avr/io.h> 
#include <avr/interrupt.h>

unsigned char Stack[400]; 

register unsigned char OSRdyTbl          asm("r2");    //任务运行就绪表 
register unsigned char OSTaskRunningPrio asm("r3");    //正在运行的任务 

#define OS_TASKS 3                    //设定运行任务的数量 

struct TaskCtrBlock 
{ 
unsigned int OSTaskStackTop;  //保存任务的堆栈顶 
unsigned int OSWaitTick;      //任务延时时钟 
} TCB[OS_TASKS+1]; 

//防止被编译器占用 
register unsigned char tempR4  asm("r4"); 
register unsigned char tempR5  asm("r5"); 
register unsigned char tempR6  asm("r6"); 
register unsigned char tempR7  asm("r7"); 
register unsigned char tempR8  asm("r8"); 
register unsigned char tempR9  asm("r9"); 
register unsigned char tempR10 asm("r10"); 
register unsigned char tempR11 asm("r11"); 
register unsigned char tempR12 asm("r12"); 
register unsigned char tempR13 asm("r13"); 
register unsigned char tempR14 asm("r14"); 
register unsigned char tempR15 asm("r15"); 
register unsigned char tempR16 asm("r16"); 
register unsigned char tempR17 asm("r17"); 


//建立任务 
void OSTaskCreate(void (*Task)(void),unsigned char *Stack,unsigned char TaskID) 
{ 
  *Stack--=(unsigned int)Task;     //将任务的地址低位压入堆栈， 
  *Stack--=(unsigned int)Task>>8;           //将任务的地址高位压入堆栈， 
     
  *Stack--=0x00;                      //R1 __zero_reg__             
  *Stack--=0x00;                      //R0 __tmp_reg__ 
  *Stack--=0x80;                                         

//SREG 在任务中，开启全局中断         
  for(unsigned char i=0;i<14;i++)     //在 avr-libc 中的 FAQ中的 What registers are used by the C compiler? 
  {    
*Stack--=i;                     //描述了寄存器的作用     
      }

  TCB[TaskID].OSTaskStackTop=(unsigned int)Stack;    //将人工堆栈的栈顶，保存到堆栈的数组中 
  OSRdyTbl|=0x01<<TaskID;           //任务就绪表已经准备好 
} 

//开始任务调度,从最低优先级的任务的开始 
void OSStartTask()         
{ 
  OSTaskRunningPrio=OS_TASKS; 
  SP=TCB[OS_TASKS].OSTaskStackTop+17; 
  __asm__ __volatile__(    "reti"   );  
} 

//进行任务调度 
void OSSched(void) 
{  
   //  根据中断时保存寄存器的次序入栈，模拟一次中断后，入栈的情况   
  __asm__ __volatile__("PUSH __zero_reg__          \t");  //R1 
  __asm__ __volatile__("PUSH __tmp_reg__           \t");  //R0  
  __asm__ __volatile__("IN   __tmp_reg__,__SREG__  \t");  //保存状态寄存器SREG 
  __asm__ __volatile__("PUSH __tmp_reg__           \t"); 
  __asm__ __volatile__("CLR  __zero_reg__          \t");  //R0重新清零 
  __asm__ __volatile__("PUSH R18                   \t"); 
  __asm__ __volatile__("PUSH R19                   \t"); 
  __asm__ __volatile__("PUSH R20                   \t"); 
  __asm__ __volatile__("PUSH R21                   \t"); 
  __asm__ __volatile__("PUSH R22                   \t"); 
  __asm__ __volatile__("PUSH R23                   \t"); 
  __asm__ __volatile__("PUSH R24                   \t"); 
  __asm__ __volatile__("PUSH R25                   \t"); 
  __asm__ __volatile__("PUSH R26                   \t"); 
  __asm__ __volatile__("PUSH R27                   \t"); 
  __asm__ __volatile__("PUSH R30                   \t");     
  __asm__ __volatile__("PUSH R31                   \t"); 
          __asm__ __volatile__("Int_OSSched:               \t");  //当中断要求调度，直接进入这里
          __asm__ __volatile__("PUSH R29                   \t");  //R28与R29用于建立在堆栈上的指针 
  __asm__ __volatile__("PUSH R28                   \t");  //入栈完成 

     
  TCB[OSTaskRunningPrio].OSTaskStackTop=SP;           //将正在运行的任务的堆栈底保存 

  if(++OSTaskRunningPrio>=OS_TASKS) //轮流运行各个任务，没有优先级 
  {
  OSTaskRunningPrio=0; 
   }

  //cli();  //保护堆栈转换 
  SP=TCB[OSTaskRunningPrio].OSTaskStackTop; 
  //sei(); 
     
    //根据中断时的出栈次序     
  __asm__ __volatile__("POP  R28                   \t");     
  __asm__ __volatile__("POP  R29                   \t");         
  __asm__ __volatile__("POP  R31                   \t");     
  __asm__ __volatile__("POP  R30                   \t");     
  __asm__ __volatile__("POP  R27                   \t");     
  __asm__ __volatile__("POP  R26                   \t");     
  __asm__ __volatile__("POP  R25                   \t");     
  __asm__ __volatile__("POP  R24                   \t");     
  __asm__ __volatile__("POP  R23                   \t");     
  __asm__ __volatile__("POP  R22                   \t");     
  __asm__ __volatile__("POP  R21                   \t");     
  __asm__ __volatile__("POP  R20                   \t");     
  __asm__ __volatile__("POP  R19                   \t"); 
  __asm__ __volatile__("POP  R18                   \t"); 
  __asm__ __volatile__("POP  __tmp_reg__           \t");      //SERG 出栈并恢复 
  __asm__ __volatile__("OUT  __SREG__,__tmp_reg__  \t");      // 
  __asm__ __volatile__("POP  __tmp_reg__           \t");      //R0 出栈 
  __asm__ __volatile__("POP  __zero_reg__          \t");      //R1 出栈 
  __asm__ __volatile__("RETI                       \t");     //返回并开中断 
  //中断时出栈完成 
} 


void IntSwitch(void) 
{     
  __asm__ __volatile__("POP R31           \t");
          __asm__ __volatile__("POP R31           \t"); 
          __asm__ __volatile__("RJMP Int_OSSched           \t");  //重新调度 
} 


void Task0() 
{ 
  unsigned int j=0; 
  while(1) 
  {             
    PORTB=j++; 
    //OSTimeDly(50); 
  } 
} 

void Task1() 
{ 
  unsigned int j=0; 
  while(1) 
  { 
    PORTC=j++; 
    //OSTimeDly(5); 
  } 
} 

void Task2() 
{ 
  unsigned int j=0; 
  while(1) 
  { 
    PORTD=j++;  
    //OSTimeDly(5);   
  } 
} 



void TaskScheduler() 
{  
  while(1) 
  {         
     OSSched();      //反复进行调度 
  } 
} 
void TCN0Init(void)    // 计时器0 
{ 
  TCCR0 = 0; 
  TCCR0 |= (1<<CS02);  // 256预分频 
  TIMSK |= (1<<TOIE0); // T0溢出中断允许                   
  TCNT0 = 100;         // 置计数起始值     
} 


SIGNAL(SIG_OVERFLOW0) 
{ 
  TCNT0=100; 
  IntSwitch();        //任务调度 
} 


int main(void) 
{     
  TCN0Init(); 
  OSRdyTbl=0; 
  OSTaskCreate(Task0,&Stack[99],0); 
  OSTaskCreate(Task1,&Stack[199],1); 
  OSTaskCreate(Task2,&Stack[299],2); 
  OSTaskCreate(TaskScheduler,&Stack[399],OS_TASKS); 
  OSStartTask(); 
} 

/******************************************************************************************************************************************/
    以上是源程序，已经调试通过，没有问题。
    首先，我想说的是关于堆栈。生成代码使用2个堆栈：一个是用于子程序调用和中断操作的硬件堆栈；一个是用于堆栈结构传递参数、临时变量及局部变量的软件堆栈。硬件堆栈用于存储函数返回地址，软件堆栈，通常如果程序没有子程序调用，也不调用像带%f格式的printf()等库函数，那么默认的16B在大多数情况下有良好地工作，除了很繁的递归调用程序，最多40B的硬件堆栈就足够了。硬件堆栈是从数据内存的顶部开始分配的，而软件堆栈是在它下面一定数量字节处分配。硬件堆栈和数据内存的大小是受在编译器选项中的目标装置项设定限制的。
    看上面的调度时，大家会发现，先压入的是R1,而后是R0,SREG,R18-R27,R30,R31,R29,R28，是这样一个顺序，部分内容我已经改动，原来黄先生的是先压R28，再压入R29。为何我要改成R29,R28，是因为我在看汇编代码时发现，每调用一个子函数，都会先压入R29,再压入R28，这用来做堆栈上的指针，对是我就改了过来。那么这点理解后我们看下面的代码，在void IntSwitch(void) 函数中，为何要两次弹出R31？刚刚看这段程序时我也没有看明白，当看了注释后也不是太明白，后来我发现，这段代码是多余的。为什么我会这么说呢？下面我会讲到。请看下面的汇编：
@00000183: __vector_9
192:      { 
+00000183:   921F        PUSH      R1             Push register on stack
+00000184:   920F        PUSH      R0             Push register on stack
+00000185:   B60F        IN        R0,0x3F        In from I/O location
+00000186:   920F        PUSH      R0             Push register on stack
+00000187:   2411        CLR       R1             Clear Register
+00000188:   932F        PUSH      R18            Push register on stack
+00000189:   933F        PUSH      R19            Push register on stack
+0000018A:   934F        PUSH      R20            Push register on stack
+0000018B:   935F        PUSH      R21            Push register on stack
+0000018C:   936F        PUSH      R22            Push register on stack
+0000018D:   937F        PUSH      R23            Push register on stack
+0000018E:   938F        PUSH      R24            Push register on stack
+0000018F:   939F        PUSH      R25            Push register on stack
+00000190:   93AF        PUSH      R26            Push register on stack
+00000191:   93BF        PUSH      R27            Push register on stack
+00000192:   93EF        PUSH      R30            Push register on stack
+00000193:   93FF        PUSH      R31            Push register on stack
+00000194:   93DF        PUSH      R29            Push register on stack
+00000195:   93CF        PUSH      R28            Push register on stack <?xml:namespace prefix = o ns = "urn:schemas-microsoft-com:office:office" />

<?xml:namespace prefix = v ns = "urn:schemas-microsoft-com:vml" />

     这部分是进入中断时压入人工堆栈的寄存器，很明显，GCC已经将R29,R28压入了人工堆栈，此时SP就指向栈顶。那么你会问：“你还没有解释为何要弹出两次R31啊？”对，我想说的是这里两次弹出不是说不正确，对于黄先生的代码而言，这里必须要弹出两次，所以他才会在任务调度函数void OSSched(void)里再次压入R28,R29，这样就相当于把原来已经压入人工堆栈的R28,R29弹出来，再压进去！到这里大家应该已经明白为何要弹出两次R31了吧。
    其实可以这样修改一下void OSSched(void)函数，就是把__asm__ __volatile__("Int_OSSched: \t");放到__asm__ __volatile__("PUSH R28  \t");的后面，这样就不会重复压入两次R28,R29，然后把void IntSwitch(void) 函数中两次弹出R31的代码就可以删除了，这样阅读程序时是不是更容易理解。
    还有一点就是，在仿真时，最好是把优化选项关闭，否则可能会出现问题。关于这一点，大家可以去看一下AVR Studio里avr-libc中的Frequently Asked Questions第10个Why does the PC randomly jump around when single-stepping through my program in avr-gdb?这里面就建议在调试时最好off leaving optimizations enabled！！
    好了，到现在，大家应该能明白整个程序了吧。在理解时，一定要搞清楚RET,RETI,CALL这些函数的作用，还有就是中断以及程序进入与退出的机制是什么，只有把最底层的东西搞明白了，你才不会有太多的问题。因为我对AVR接触时间不长，难免会有些说法不当，请大家指正！