动手写简单的嵌入式操作系统一

业余时间想研究一下RTOS,但是现有的嵌入式系统很多，代码量也很大，厚厚的一本书，又是任务控制块，又是链表又是指针的指来指去，让人不耐心点根本看不下去，也没太多时间去研究。于是就有了自己动手去做的想法，这样可以提高兴趣.比看书有意思。慢慢的发现，操作系统也没有那么神秘。触发软中断，保存堆栈,开始进行任务切换。于是一个多任务就出来了，但是一个完整的操作系统并不简单，涉及到一系列的算法和数据结构的运用，还有系统的引导程序bootloader,内存管理，文件系统，网络管理，IO驱动管理等模块。

      有了想法，接下来就是付诸行动。但是还得学习汇编，这成了最大阻碍，工作任务多，下班后，没太多精力去学习它。不过只要能看的懂就可以。于是把ucos/II在stm32上移植部分的汇编代码招搬过来直接利用。这样可以把主要精力放在任务调度和任务间的同步和通讯上。这次任务创建和调度的原理很简单，效率肯定也不高。以后有更好的想法了，打算改进一下任务的调度算法，比如可以利用linux内核中的list_head双向循环链表，加入就绪队列和任务延时队列。利用keilRTX系统中的内存分配机制，动态allox()分配任务的TCB控制块，总之，多学习好的系统中的思想。

以下是汇编的代码OS_CPU_A.ASM,完成任务之间的切换和堆栈的保存。

主要是两个堆栈指针OSCurTCB，OSNewTCB。可以把主要精力放在用c写任务调度和任务间的同步与通信，

 

利用以下汇编代码，就可以暂时不管汇编部分，该任务调度时调用OSCtxSw(),传递最高优先级任务的堆栈指针给OSNewTCB，完成两个任务切换。

 

[cpp] view plain copy
  1. ;/*********************** (C) COPYRIGHT 2010 Libraworks ************************* 
  2. ;* File Name : os_cpu_a.asm  
  3. ;* Author  : Librae  
  4. ;* Version  : V1.0 
  5. ;* Date   : 06/10/2010 
  6. ;* Description : μCOS-II asm port for STM32 
  7. ;*******************************************************************************/  
  8.   IMPORT  OSCurTCB                    ; External references  
  9.   IMPORT  OSNewTCB  
  10.   IMPORT  OSTaskSwHook  
  11.                      
  12.   EXPORT  OSStartTask  
  13.   EXPORT  OSCtxSw  
  14.   EXPORT  OSIntCtxSw  
  15.   EXPORT  OS_CPU_SR_Save                       ; Functions declared in this file  
  16.   EXPORT  OS_CPU_SR_Restore         
  17.   EXPORT  PendSV_Handler   
  18.        
  19. NVIC_PENDSV_PRI  EQU     0xFFFF0000               ; PendSV priority value (lowest)  
  20. NVIC_PENDSVSET   EQU     0x10000000               ; value to trigger PendSV exception  
  21. NVIC_INT_CTRL    EQU     0xE000ED04               ; interrupt control state register  
  22. NVIC_SYSPRI2     EQU     0xE000ED20               ; system priority register (2)  
  23.   
  24.   PRESERVE8   
  25.     
  26.   AREA    |.text|, CODE, READONLY  
  27.         THUMB   
  28.       
  29.              
  30. ;********************************************************************************************************  
  31. ;                                   CRITICAL SECTION METHOD 3 FUNCTIONS  
  32. ;  
  33. ;********************************************************************************************************  
  34. OS_CPU_SR_Save  
  35.     MRS     R0, PRIMASK   ;读取PRIMASK到R0,R0为返回值   
  36.     CPSID   I    ;PRIMASK=1,关中断(NMI和硬件FAULT可以响应)  
  37.     BX      LR       ;返回  
  38. OS_CPU_SR_Restore  
  39.     MSR     PRIMASK, R0     ;读取R0到PRIMASK中,R0为参数;open interrupt  
  40.     BX      LR    ;返回  
  41.   
  42. ;/************************************************************************************** 
  43. ;* 函数名称: OSStartTask 
  44. ;* 
  45. ;* 功能描述: 使用调度器运行第一个任务 
  46. ;*  
  47. ;* 参    数: None 
  48. ;* 
  49. ;* 返 回 值: None 
  50. ;**************************************************************************************/    
  51. OSStartTask  
  52.         LDR     R4, =NVIC_SYSPRI2      ; set the PendSV exception priority  
  53.         LDR     R5, =NVIC_PENDSV_PRI  
  54.         STR     R5, [R4]  
  55.         MOV     R4, #0                 ; set the PSP to 0 for initial context switch call  
  56.         MSR     PSP, R4  
  57.                                        ;切换到最高优先级的任务  
  58.         LDR     R4, =NVIC_INT_CTRL     ;rigger the PendSV exception (causes context switch)  
  59.         LDR     R5, =NVIC_PENDSVSET    ;触发PendSV异常 (causes context switch)  
  60.         STR     R5, [R4]  
  61.         CPSIE   I                      ;enable interrupts at processor level  
  62. OSStartHang  
  63.         B       OSStartHang            ;should never get here  
  64. ;/************************************************************************************** 
  65. ;* 函数名称: OSCtxSw 
  66. ;* 
  67. ;* 功能描述: 任务级上下文切换          
  68. ;* 
  69. ;* 参    数: None 
  70. ;* 
  71. ;* 返 回 值: None 
  72. ;***************************************************************************************/  
  73.     
  74. OSCtxSw  
  75.   PUSH    {R4, R5}  
  76.         LDR     R4, =NVIC_INT_CTRL   ;触发PendSV异常 (causes context switch)  
  77.         LDR     R5, =NVIC_PENDSVSET  
  78.         STR     R5, [R4]  
  79.   POP     {R4, R5}  
  80.         BX      LR  
  81.   NOP  
  82. ;/************************************************************************************** 
  83. ;* 函数名称: OSIntCtxSw 
  84. ;* 
  85. ;* 功能描述: 中断级任务切换 
  86. ;* 
  87. ;* 参    数: None 
  88. ;* 
  89. ;* 返 回 值: None 
  90. ;***************************************************************************************/  
  91. OSIntCtxSw  
  92.   PUSH    {R4, R5}  
  93.         LDR     R4, =NVIC_INT_CTRL      ;触发PendSV异常 (causes context switch)  
  94.         LDR     R5, =NVIC_PENDSVSET  
  95.         STR     R5, [R4]  
  96.   POP     {R4, R5}  
  97.         BX      LR  
  98.         NOP  
  99. ;/************************************************************************************** 
  100. ;* 函数名称: OSPendSV 
  101. ;* 
  102. ;* 功能描述: OSPendSV is used to cause a context switch. 
  103. ;* 
  104. ;* 参    数: None 
  105. ;* 
  106. ;* 返 回 值: None 
  107. ;***************************************************************************************/  
  108. PendSV_Handler  
  109.         CPSID   I                                   ; Prevent interruption during context switch  
  110.         MRS     R0, PSP                             ; PSP is process stack pointer 如果在用PSP堆栈,则可以忽略保存寄存器,参考CM3权威中的双堆栈-白菜注  
  111.         CBZ     R0, PendSV_Handler_Nosave           ; Skip register save the first time  
  112.         SUBS    R0, R0, #0x20           
  113.         STM     R0, {R4-R11}                        ; Save remaining regs r4-11 on process stack  
  114.         LDR     R1, =OSCurTCB      
  115.         LDR     R1, [R1]  
  116.         STR     R0, [R1]                             ; R0 is SP of process being switched out            
  117. PendSV_Handler_Nosave  
  118.         PUSH    {R14}                                ; Save LR exc_return value  
  119.         LDR     R0, =OSTaskSwHook                    ; OSTaskSwHook();  
  120.         BLX     R0  
  121.         POP     {R14}  
  122.         LDR     R0, =OSCurTCB                         ;OSCurTCB=OSNewTCB;       
  123.         LDR     R1, =OSNewTCB  
  124.         LDR     R2, [R1]  
  125.         STR     R2, [R0]  
  126.         LDR     R0, [R2]                              ; R0 is new process SP; SP = OSCurTCB;         
  127.         LDM     R0, {R4-R11}                ; Restore r4-11 from new process stac  
  128.         ADD     R0, R0, #0x20  
  129.         MSR     PSP, R0               
  130.         ORR     LR, LR, #0x04  
  131.   CPSIE   I                                 ; Exception return will restore remaining context  
  132.         BX      LR                     
  133.   end    

接下来定义一个任务控制块：

 

[cpp] view plain copy
  1. typedef struct taskControlBlock  
  2. {  
  3.  /*当前的栈顶指针*/  
  4.  OS_STK     *pStackTop;    
  5.  /*当前优先级*/  
  6.  PRIO_TYPE    CurPriority;   
  7.  /*任务状态*/  
  8.  uint8      TaskStat;  
  9.  /*等待时间片的个数*/  
  10.  int32     TCBDelay;  
  11.    
  12. } TCB;  
  13. /*当前运行的任务*/  
  14. TCB   *OSCurTCB;  
  15. /*当前准备新运行的任务*/  
  16. TCB   *OSNewTCB;  
  17. /*当前OS中所有的任务*/  
  18. uint8  TaskNUM=0;  
  19. TCB   OSTCBTable[MAX_TASK_NUM];  

 

OSCurTCB和OSNewTCB分别是当前运行任务的堆栈指针和要运行的新任务的堆栈指针。

下一步就是任务的创建了，任务是如何创建的。每个任务都有自己的堆栈空间，就像是单独占用CPU一样，所以创建任务还需完成任务堆栈的初始化。

需要知道CPU是如何出栈压栈的，保存了哪些寄存器，顺序是什么，堆栈的增长方向是什么。参考《cortexM3权威指南》，书中有详细的介绍。

 

以下是c语言写的任务堆栈的初始化函数，位于文件OS_CPU.c中，如果需要移植，除了汇编部分OS_CPU_A.asm文件修改外，OS_CPU.c和OS_TYPE.h等文件也需要修改。仅这几个文件。
OS_STK实际上就是int32,因为stm32上堆栈指针就是32位长度。第一个参数是任务的地址，即函数的地址，第二个参数是任务的堆栈指针。

 

[cpp] view plain copy
  1. OS_STK *OSTaskStkInit (void (*task),OS_STK *ptos)  
  2. {  
  3.     OS_STK *stk;  
  4.     stk    = ptos;                          /* get stack point       */  
  5.     *(stk)    = (uint32)0x01000000L;        /* xPSR                  */  
  6.     *(--stk)  = (uint32)task;               /* Entry Point           */  
  7.     *(--stk)  = (uint32)0xFFFFFFFEL;        /* R14 (LR)              */  
  8.     *(--stk)  = (uint32)0x12121212L;        /* R12                   */  
  9.     *(--stk)  = (uint32)0x03030303L;        /* R3                    */  
  10.     *(--stk)  = (uint32)0x02020202L;        /* R2                    */  
  11.     *(--stk)  = (uint32)0x01010101L;        /* R1                    */  
  12.     *(--stk)  = (uint32)0;                  /* R0 : argument         */  
  13.                                             /* Remaining registers   */  
  14.     *(--stk)  = (uint32)0x11111111L;        /* R11                   */  
  15.     *(--stk)  = (uint32)0x10101010L;        /* R10                   */  
  16.     *(--stk)  = (uint32)0x09090909L;        /* R9                    */  
  17.     *(--stk)  = (uint32)0x08080808L;        /* R8                    */  
  18.     *(--stk)  = (uint32)0x07070707L;        /* R7                    */  
  19.     *(--stk)  = (uint32)0x06060606L;        /* R6                    */  
  20.     *(--stk)  = (uint32)0x05050505L;        /* R5                    */  
  21.     *(--stk)  = (uint32)0x04040404L;        /* R4                    */  
  22.     return (stk);  
  23. }  
[cpp] view plain copy
  1. /* 
  2.  * 创建新的任务 
  3. */  
  4. TCB*  OSTaskCreate(void* task, OS_STK *stack,PRIO_TYPE prio)  
  5. {  
  6.  TCB *pTCB;  
  7.  OS_CPU_SR  cpu_sr = 0;  
  8.    
  9.  OS_ENTER_CRITICAL();  
  10.    
  11.  pTCB = OSGetFreeTCB(prio);  
  12.  if (NULL == pTCB)  
  13.  {  
  14.   OS_EXIT_CRITICAL();  
  15.   return NULL;  
  16.  }  
  17.  pTCB->pStackTop = OSTaskStkInit(task, stack);  
  18.  pTCB->CurPriority = prio;  
  19.  pTCB->TCBDelay = 0;  
  20.    
  21.  TaskNUM++;  
  22.  OS_EXIT_CRITICAL();  
  23.  return pTCB;  
  24. }  

 

创建新任务函数很简单，只要懂了OSGetFreeTCB(prio);这个函数就没啥问题。创建的任务，是一个有序的表，就是一个存储元素为
TCB类型的数组TCB  OSTCBTable[MAX_TASK_NUM];在这个数组中，先在OSTCBTable[0]中创建一个任务，如果再创建一个任务，这个任务比上个任务的优先级高，那么OSTCBTable[0]中存储优先级高的任务，那个之前先创建的低优先级的任务搬移到OSTCBTable[1]中。如果再创建一个任务，任务优先级会与前两个任务对比，若比前两个都低，就放在第三个位置OSTCBTable[2]中，否则就重新排序，总之，使OSTCBTable数组中的任务始终是按优先级从高到低的顺序排列。
以下是这种思想实现的OSGetFreeTCB(prio)函数：

 

[cpp] view plain copy
  1. /*在TCB表中取一个空闲的节点，给新任务使用*/  
  2. /*对OSTCBTable表这个有序表进行插入排序*/  
  3. /*将优先级高的任务放在前面*/  
  4. TCB* OSGetFreeTCB(PRIO_TYPE prio)  
  5. {  
  6.  TCB *pTCB;  
  7.  int32 index=0,orgIndex;  
  8.  pTCB = &(OSTCBTable[0]);  
  9.  for (index = 0;index < TaskNUM+1;index++)  
  10.  {  
  11.   pTCB = OSTCBTable+index;  
  12.   /*已经是空闲TCB了，就直接使用*/  
  13.   if (NULL == pTCB->pStackTop)  
  14.   {  
  15.    return (TCB*)pTCB;  
  16.   }  
  17.   /*若新任务优先级比较低或相等，则向后继续找*/  
  18.   if (pTCB->CurPriority >= prio)  
  19.   {  
  20.    continue;  
  21.   }  
  22.   else /*pTCB->CurPriority < prio 找到了该插入的位置了*/  
  23.   {    
  24.    /*保存当前位置*/  
  25.    orgIndex = index;  
  26.    /*从当前节点遍历到最后一个使用了的节点*/  
  27.    for( index = TaskNUM ; index > orgIndex ; index-- )  
  28.    {  
  29.     pTCB = OSTCBTable+index;  
  30.     /*将前一个节点的数据，保存到当前节点*/  
  31.     _mem_copy((uint8 *)(pTCB),(uint8 *)(pTCB-1),sizeof(TCB));  
  32.    }  
  33.    _mem_clr((uint8 *)(pTCB-1),sizeof(TCB))  ;  
  34.       
  35.    return (TCB*)(pTCB-1);    
  36.   }  
  37.  }  
  38.  return (TCB*)NULL;  
  39. }  

任务创建是基于一个有序表。这种方法虽然简单直观，但也有很大缺点。比如如果建立了100个任务，又准备建立第101个任务，且第101个任务优先级是最高的。那么创建任务就很慢，需要前面一百个任务依次都向后移，第101个任务放在数组的最前面。这是十分耗时的操作，随着任务数的增加，创建任务的时间也随着增加。后面还要讲到，这种方法建立的任务查找最高优先级时，需要遍历数组，在效率上也是不快的，尤其是任务数目多时。

任务创建之后，接下来的事情就是何时需要任务切换，如何查找最高优先级了。先说下何时需要任务切换，每个任务都是一个while(1)死循环，在里面执行到OSTimedly()时就会挂起当前任务，查找最高优先级的任务。每个任务的控制块中都有个延时时间的变量，当这个延时时间变量大于0，说明这个任务还处于睡眠或挂起状态，不能够被执行。因此还需要一个系统时钟函数，作为整个系统的调度中心，每到一个系统时钟中断，让所有任务的延时时间减一。

 

[cpp] view plain copy
  1. /* 
  2.  *系统时钟函数，在时钟中断中调用 
  3. */  
  4. void  OSTimeTick (void)  
  5. {  
  6.     int8 index;  
  7.     TCB  *pTCB;  
  8.     uint8 flagFirstTask=0;  
  9.     OS_CPU_SR  cpu_sr = 0;  
  10.     OS_ENTER_CRITICAL();  
  11.     /*初始化*/  
  12.     OSNewTCB = NULL;  
  13.  /*禁止调度*/  
  14.     if (OSScheLock != 0)  
  15.     {  
  16.        OS_EXIT_CRITICAL();  
  17.        return;  
  18.     }  
  19.  for (index = 0;index < TaskNUM;index++)  
  20.  {  
  21.      pTCB = OSTCBTable+index;  
  22.     /*该任务在睡眠状态，必须将所有时延都--*/  
  23.      if (pTCB->TCBDelay > 0)  
  24.      {  
  25.         pTCB->TCBDelay--;  
  26.         continue;  
  27.      }  
  28.      /*该任务被挂起*/  
  29.      if (pTCB->TaskStat == OS_Task_Pend)   
  30.      {  
  31.          continue;  
  32.      }  
  33.     /*任务优先级查找算法，以后考虑改进查找速度*/  
  34.    /* 是否找到了应该调度进去的就绪任务*/  
  35.   if (flagFirstTask==0)  
  36.   {  
  37.    /*找到了最高优先级的任务， 
  38.      并且比当前任务优先级高*/  
  39.      if (OSCurTCB->CurPriority < pTCB->CurPriority)  
  40.      {  
  41.         flagFirstTask = 1;  
  42.         OSNewTCB = pTCB;  
  43.         continue;  
  44.      }  
  45.     /*找到了比当前优先级低的任务*/  
  46.     if (OSCurTCB->CurPriority > pTCB->CurPriority)  
  47.    {  
  48.        if (OSNewTCB == NULL)  
  49.       {  
  50.           flagFirstTask = 1;  
  51.           OSNewTCB = pTCB;  
  52.           continue  ;   
  53.       }  
  54.       else  
  55.      {  
  56.          flagFirstTask = 1;  
  57.         continue  ;    
  58.       }  
  59.    }  
  60.      
  61.    /*找到了最高优先级的任务， 
  62.      并且跟当前任务优先级相等*/  
  63.    if (OSCurTCB->CurPriority == pTCB->CurPriority)  
  64.    {  
  65.     /*该任务在当前任务之后*/  
  66.     if ((pTCB > OSCurTCB)||(pTCB == OSCurTCB))  
  67.     {   
  68.      flagFirstTask = 1;  
  69.      OSNewTCB = pTCB;  
  70.      continue  ;    
  71.     }   
  72.     /*在当前任务之前或者就是当前任务 
  73.       则还需要继续向后搜索第一个同优先级的任务*/  
  74.     if ((pTCB < OSCurTCB)&&(OSNewTCB == NULL))  
  75.     {  
  76.       OSNewTCB = pTCB;  
  77.       continue;  
  78.     }  
  79.    }  
  80.    continue;  
  81.   }  
  82.     
  83.  }  
  84.  OS_EXIT_CRITICAL();  
  85. }  

在时钟中断里，需要调用这个函数，这个函数的作用很简单，一方面让每个任务的延时时间减一，一方面查找最高优先级的任务，找到了最高优先级的任务时，就把 OSNewTCB = pTCB;把最高优先级的任务堆栈指针赋给 OSNewTCB 。

[cpp] view plain copy
  1. void SysTick_Handler(void)  
  2. {  
  3.  OSIntEnter();  //进入中断  
  4.  OSTimeTick();  
  5.  OSIntExit();        //触发任务切换软中断  
  6. }  
[cpp] view plain copy
  1. /* 
  2. *记录中断嵌套层数 
  3. */  
  4. void  OSIntEnter (void)  
  5. {  
  6.     if (NULL != OSCurTCB)   
  7.    {  
  8.         if (OSIntNesting < 255u)   
  9.         {  
  10.             OSIntNesting++;                      /* Increment ISR nesting level                        */  
  11.         }  
  12.     }  
  13. }  
[cpp] view plain copy
  1. /* 
  2. *中断退出时调用，触发中断级任务切换 
  3. */  
  4. void  OSIntExit (void)  
  5. {  
  6.      OS_CPU_SR  cpu_sr = 0u;  
  7.     if (NULL!= OSCurTCB)  
  8.     {  
  9.         OS_ENTER_CRITICAL();  
  10.         if (OSIntNesting > 0u)  
  11.         {                             
  12.             OSIntNesting--;  
  13.         }  
  14.         if (OSIntNesting == 0u)   
  15.         {                            
  16.             /* 当所有的中断完成候再判断是否调度  */   
  17.             if (OSNewTCB != OSCurTCB)  
  18.             {  
  19.               /* 中断级任务切换  */  
  20.               OSIntCtxSw();      
  21.             }   
  22.         }  
  23.         OS_EXIT_CRITICAL();  
  24.     }  
  25. }  

在时钟中断里，退出时调用 OSIntExit();        //触发任务切换软中断

在这个函数中，比较当前任务指针是否发生了改变，若发生了改变，说明需要进行任务切换了。
下面再看看延时函数OSTimeDly (int32 ticks)

 

[cpp] view plain copy
  1. void  OSTimeDly (int32 ticks)  
  2. {  
  3.     OS_CPU_SR  cpu_sr = 0;  
  4.     int8   index;  
  5.     TCB    *pTCB;  
  6.    
  7.     OS_ENTER_CRITICAL();  
  8.     OSCurTCB->TCBDelay = ticks;  
  9.     OSNewTCB = NULL;  
  10.    /*任务优先级查找算法，从当前任务 
  11.     向后遍历，第一个最大的优先级的任务 
  12.     就是需要调度进去的任务*/  
  13.     for (index = 0; index < TaskNUM;index++)  
  14.     {  
  15.        pTCB = OSTCBTable+index;  
  16.        /*跳过睡眠任务*/  
  17.        if (pTCB->TCBDelay != 0)  
  18.        {  
  19.            continue;  
  20.        }  
  21.        /*跳过挂起任务*/  
  22.        if  (pTCB->TaskStat == OS_Task_Pend)   
  23.        {      
  24.             continue;  
  25.        }  
  26.       /*找到了最高优先级的任务， 
  27.        并且比当前任务优先级高*/  
  28.       if (OSCurTCB->CurPriority < pTCB->CurPriority)  
  29.      {  
  30.          OSNewTCB = pTCB;  
  31.          break;  
  32.       }  
  33.       /*找到了比当前优先级低的任务*/  
  34.      if (OSCurTCB->CurPriority > pTCB->CurPriority)  
  35.      {  
  36.          /*如果当前任务之前有同优先级的就绪任务， 
  37.          则选择该任务，否则就使用*/  
  38.         if (OSNewTCB == NULL)  
  39.         {  
  40.             OSNewTCB = pTCB;  
  41.         }          
  42.         break;  
  43.   }  
  44.      
  45.   /*找到了最高优先级的任务， 
  46.     并且跟当前任务优先级相等*/  
  47.   if (OSCurTCB->CurPriority == pTCB->CurPriority)  
  48.   {  
  49.      /*该任务在当前任务之后*/  
  50.      if ((pTCB > OSCurTCB))  
  51.      {   
  52.           OSNewTCB = pTCB;  
  53.           break  ;    
  54.      }   
  55.    /*在当前任务之前或者就是当前任务 
  56.      则还需要继续向后搜索第一个同优先级的任务*/  
  57.     if (((pTCB < OSCurTCB)||(pTCB == OSCurTCB))  
  58.         &&(OSNewTCB == NULL))  
  59.     {  
  60.          OSNewTCB = pTCB;  
  61.          continue;  
  62.     }  
  63.   }  
  64.    
  65.  }  
  66.  OS_EXIT_CRITICAL();  
  67.  OSTaskSche();   
  68. }  

延时函数也很简单，就是一方面把需要延时的时间给任务控制结构体中的延时变量，一方面查找最高优先级的任务开始进行任务切换。以上就完成了简单的任务切换和调度。从上面可以看出，查找效率是很低的，尤其是任务数目多的时候，需要从头到尾的遍历一遍数组。创建任务和查找高优先级的任务都有改进的空间，如果以后想到更好的更有效的方法再改一改，试一试。

以上实现了简单的任务调度和切换。接下来，就是任务间如何进行同步和通讯...

在CSDN资源中可以下载工程的源码，KEILMDK4.23的IDE

posted @ 2017-03-06 17:49  专注it  阅读(402)  评论(0)  编辑  收藏  举报