原创 Small RTOS51学习（转帖）

{
    OSWaitTick[OSTaskID] = ticks;               /* 设置超时时间         */
                                                /* 可以优化寄存器的使用  */
    switch(typ)
    {
    case K_SIG:                                 /* 等待信号，即挂起自己  */
        OSWaitTick[OSTaskID] = 0;               /* 没有超时处理         */
        OSClearSignal(OSTaskID);                /* 任务进入等待状态     */
        OSSched();                              /* 运行下一个任务       */
        return SIG_EVENT;
    case K_TMO:                                 /* 等待超时，即延时一段时间 */
        OS_ENTER_CRITICAL();
        while (OSWaitTick[OSTaskID] != 0)       /* 判断超时时间是否到   */
        {
            OSClearSignal(OSTaskID);            /* 任务进入等待状态     */
            OSSched();                          /* 运行下一个任务       */
        }
        OS_EXIT_CRITICAL();
        return TMO_EVENT;
    case (K_TMO | K_SIG):                       /* 等待信号（挂起自己）直到超时  */
                                                /* 别的任务或中断可以恢复它 */
        OS_ENTER_CRITICAL();
        if (OSWaitTick[OSTaskID] == 0)          /* 判断超时时间是否到   */
        {
            return TMO_EVENT;
        }
        OSClearSignal(OSTaskID);                /* 任务进入等待状态     */
        OS_EXIT_CRITICAL();
        OSSched();                              /* 运行下一个任务       */
        if (OSWaitTick[OSTaskID] != 0)
        {
            OSWaitTick[OSTaskID] = 0;
            return SIG_EVENT;
        }
        return TMO_EVENT;
    default:
        OSWaitTick[OSTaskID] = 0;
        return NOT_OK;
    }
}
这个是内核函数来的，包含在OS_core.c中,靠定时器0中断调用OSTimeTick函数来
使 OSWaitTick[OSTASKID] -- 直至OSWaitTick[OSTASKID]为0，当不为零的时候
 OSClearSignal(OSTaskID)会使任务进入等待状态，OSSched()函数将会将下一个
 就绪任务运行，现在我们就来看看如何将该任务取消运行进入等待状态的

 void OSClearSignal(uint8 TaskId)
 {
  //  判断当前任务是否在许可范围内否则返回
    if (TaskId < OS_MAX_TASKS)
    {
  // 进入临界状态
        OS_ENTER_CRITICAL();
#if OS_MAX_TASKS < 9
/* 将OSTaskRuning的相应位复位
现在我们来看看OSTaskRuning的定义
#if OS_MAX_TASKS < 9
uint8 OSTaskRuning = 0xff;
#else
uint16 OSTaskRuning = 0xffff; 它被定义为一个全局变量每一位代表一个任务的状态
为1表示任务就绪，为零表示任务挂起。
uint8 const OSMapTbl[] = {0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80, 0x00};
*/
        // 总任务数要是小于9，那么用UINT可以表示，则可以直接用TABLE表清零
        OSTaskRuning &= ~OSMapTbl[TaskId];
#else
    // 任务总数大于9，若是当前任务小于8，那么将低8位操作就可以了
        if (TaskId < 8)
        {
            ((uint8 *)(&OSTaskRuning))[LOW_BYTE] &= ~OSMapTbl[TaskId];
        }
    // 任务若是大于8，那么必须操作高8位
        else
        {
            ((uint8 *)(&OSTaskRuning))[HIGH_BYTE] &= ~OSMapTbl[TaskId & 0x07];
        }
#endif
        OS_EXIT_CRITICAL();
    }
}
这个我也可以理解，呵呵。现在我们似乎要看看调度算法了
明天一起再看看调度算法的执行过程，一步一步理下去，我相信就可以理解了，呵呵

while (OSWaitTick[OSTaskID] != 0)       /* 判断超时时间是否到   */
        {
            OSClearSignal(OSTaskID);            /* 任务进入等待状态     */
            OSSched();                          /* 运行下一个任务       */
        }
因为此处的while循环，所以在OSWaitTick[OSTaskID]不被定时器调用OSTimeTick
清零之前，会一直在此处运行下去，接下来看看OSSched（）是如何运行的
 void  OSSched(void)
{
    uint8 temp;

    OS_ENTER_CRITICAL();
#if EN_OS_INT_ENTER > 0
    if (OSIntNesting == 0)              /* 是否是中断中调用 */
    {
#endif

#if OS_MAX_TASKS < 9
                /* 查找处于就绪状态的任务中优先级最高的任务 */
        temp = OSTaskRuning;
        for (OSNextTaskID = 0; OSNextTaskID < OS_MAX_TASKS; OSNextTaskID++)
        {
            if ((temp & 0x01) != 0)
            {
                break;
            }
            temp = temp >> 1;
        }
// 在os_cpu.h 中有如下宏定义 #define  OS_TASK_SW()         OSCtxSw()
   该OSCtxSw()在OS_CPU_A.ASM中定义，用汇编写的，将此处传递的OSNextTaskID作为参数使用

        OS_TASK_SW();                   /* 进行任务调度 */
#else
                /* 查找处于就绪状态的任务中优先级最高的任务 */
        temp = OSTaskRuning % 256;
        for (OSNextTaskID = 0; OSNextTaskID < 8; OSNextTaskID++)
        {
            if ((temp & 0x01) != 0)
            {
                goto TaskSw;
            }
            temp = temp >> 1;
        }

        temp = OSTaskRuning / 256 ;
        for (; OSNextTaskID < OS_MAX_TASKS; OSNextTaskID++)
        {
            if ((temp & 0x01) != 0)
            {
                break;
            }
            temp = temp >> 1;
        }
TaskSw:
        OS_TASK_SW();                   /* 进行任务调度 */
#endif

#if EN_OS_INT_ENTER > 0
    }
#endif
    OS_EXIT_CRITICAL();
}
这个函数都好理解，在没有中断嵌套的情况下，将OSTaskRuning中为1的查找出来，
也就是查找出任务就绪状态的任务ID号并赋给OSNextTaskID,用于在OSCtxSw中使用
看来最本质的东西还不在这里，这里只是查找出来而，而真正操作系统的保存环境
载入新任务的环境的实现方法还得继续追踪了
汇编是俺的弱项，所以这里要查资料一点一点分析了……
得去下载个汇编教程才能继续分析了，今天比较忙，就分析到这里了，呵呵

搞了一份KEIL手册来看汇编，呵呵，现在开始学习OSCtxSW这个函数

RSEG  ?PR?OSCtxSw?OS_CPU_A
OSCtxSw:
    USING 0                       ；使用BANK 0
                                    ;设置标志：任务再次恢复运行时不必恢复所有寄存器
    MOV     DPTR,#OSMapTbl          ；将OSMapTbl的地址作为基址

 //将OSTaskID作为便宜地址，就可以访问到SOMapTbl数组中相对应OSTaskID（也就是当前任务ID）的常量
    MOV     A,OSTaskID             
#if OS_MAX_TASKS < 9     // 判断任务数是否在9以下，也就是看是否使用8BIT的OSFastSwap可以表示
// 小于，那么直接将对应的常量跟OSFastSwap相或，既可将OSFastSwap中相应的位置位
// OSFastSwap相对应任务ID的位为高，则表示有任务调用，否则表示为中断调用
    MOVC    A,@A+DPTR   
    ORL     A,OSFastSwap
    MOV     OSFastSwap,A
#else
// 大于，将ACC的借位标志位CY清零，并将任务ID与8相减，若是任务号小于8，则CY会置为，通过
// 判断CY的高低就可以知道当前任务是否小于8（也就说任务小于8呢，将使用OSFastSwap的低八位）
// （若是任务大于8，那么肯定在OSFastSwap的高八位中表示）
    CLR     C
    SUBB    A,#8
    JC      OSCtxSw_1   ；小于8，跳转到OSCtxSW_1处执行
    MOVC    A,@A+DPTR   ； 大于8，那么将该任务ID减去8之后的值作为偏移量
    ORL     A,OSFastSwap
    MOV     OSFastSwap,A ；将A中的值与OSFastSwap高八位相或
    LJMP    C_OSCtxSw
OSCtxSw_1:
    MOV     A,OSTaskID 
    MOVC    A,@A+DPTR
    ORL     A,OSFastSwap+1 ；与OSFastSwap低八位操作
    MOV     OSFastSwap+1,A
#endif
    LJMP    C_OSCtxSw

 当看这段代码的时候，我十分不解的地方有两个，不过都是因为逻辑能力太弱和
 汇编匮乏引起的，一个就是，如果最大任务大于9且当前任务大于8的时候，常量表中
 只有9个量呀。假如当前任务是12，那么将超出常量表的最大表示范围了，后来才看
 原来用了SUBB后，结果是存放在A中的，也就是说相当于偏移量其实是4，那么，用OSFastSwap的
 高八位与常量表的第四位相或，其实就实现了呀，作者实现得真是非常巧妙，呵呵
 还有一点就是KEIL对双字节变量在内存中的存储方式不了解，后来查看了资料，翻看了调试中的
 汇编代码，知道了KEIL在存放双字节变量的时候，是先放高字节，再放低字节的，所以OSFastSWap+1
 也就可以理解了。

 继续看代码...........跳转到C_OSCtxSw
 貌似这里才是最关键的地方哦，真正的任务堆栈处理就在这里

 这段代码作者有用汇编来写了，为了提高效率

 RSEG  ?PR?C_OSCtxSw?OS_CPU_C
C_OSCtxSw:
    PUSH    Os_Enter_Sum            ;保存关中断计数器
    mov     r2,sp  ；保存堆栈指针（若是OSTaskID = OSNextTaskID）就直接函数返回
   
;     cp1 = (unsigned char idata *)SP +1; 将CP1指向栈顶
    MOV     R0,SP

IF EN_SP2  <> 0
    mov     sp,#(Sp2-1)             ;堆栈指向临时空间，允许“软非屏蔽中断”
ENDIF

    INC     R0
；temp用于保存OSnextTaskID的栈底地址
;     temp = (unsigned char )OSTsakStackBotton[OSNextTaskID+1];
    MOV     A,#LOW (OSTsakStackBotton+01H)
    ADD     A,OSNextTaskID
    MOV     R1,A
    MOV     A,@R1
    MOV     R7,A
；CP2保存当前任务的栈底地址
;     cp2 = OSTsakStackBotton[OSTaskID+1];
    MOV     A,#LOW (OSTsakStackBotton+01H)
    ADD     A,OSTaskID
    MOV     R1,A
    MOV     A,@R1
    MOV     R1,A
；如果当前任务小于下个任务
;     if( OSNextTaskID > OSTaskID)
    MOV     A,OSNextTaskID
    SETB    C
    SUBB    A,OSTaskID
    JC      ?C0001
;     {
；将OSNextTaskID堆栈复制到当前栈顶处
;         while(cp2 != (unsigned char idata *)temp)
;         {
;             *cp1++ = *cp2++;
;         }
    MOV     A,R7
    CLR     C
    SUBB    A,R1
    MOV     R6,A
?C0002:
    MOV     A,@R1
    MOV     @R0,A
    INC     R0
    INC     R1
    DJNZ    R6,?C0002
?C0003:
;         temp = OSTsakStackBotton[OSTaskID+1] - (unsigned char idata *)SP-1;
    MOV     A,#LOW (OSTsakStackBotton+1)
    ADD     A,OSTaskID
    MOV     R1,A
    MOV     A,@R1
    SETB    C
    ;SUBB    A,sp
    SUBB    A,r2
    MOV     R7,A
；SP指向刚移动好的下个任务堆栈的地方
;         SP = (unsigned char )cp1 - 1;
    DEC     R0;
    MOV     SP,R0
；重新给任务分配空间
;         for(i = OSTaskID+1;i < OSNextTaskID+1; i++)
;         {
;             OSTsakStackBotton -= temp;
;         }
    MOV     A,OSNextTaskID
    CLR     C
    SUBB    A,OSTaskID
    MOV     R6,A
    JZ      ?C0005