操作系统是用来管理系统硬件、软件及数据资源,控制程序运行,并为其它应用软件提供支持的一种系统软件。根据不同的种类,又可分为实时操作系统、桌面操作系统、服务器操作系统等。对于一些小型的应用,对系统实时性要求高,硬件资源有限等的情况下,应尽量避免使用复杂庞大的操作系统(如Linux),使用小型的实时操作系统(如uCOS)更能满足应用的需求。笔者此处就uCOS-II的移植作一个简单的介绍。

1. 代码准备

uCOS-II V2.91源码,这个版本的源码是uCOS-II的最新版本。请读者自行从Micrium官网或其它网站下载这个版本的源码,当然,其它版本的uCOS-II也是一样方式移植的。Micrium官网也给出了一些cpu的移植范例,可供参考,此处是下载源码,一步一步进行移植。
s3c2416启动代码工程,启动代码是s3c2416/50/51这系列arm9芯片在运行用户c代码main函数之前必须先运行的代码,启动代码支持sd、Nand启动,为用户设置系统时钟,初始化内存,自动识别启动设备并搬移代码到RAM,MMU映射,中断管理等,用户只需专注于用c开发其它功能函数即可。关于启动代码以及启动代码的实现过程,笔者前面章节有非常详细的介绍。
此处以GCC下移植uCOS为讲解,下载”GCC启动代码工程应用实例”中的启动代码源码即可。如果在MDK下开发,下载“MDK启动代码工程应用实例”中的启动代码源码。
用户代码,用c开发的所有功能代码,其中,用户代码入口为main()函数,在这里实现uCOS多任何运行代码。

2. 工程搭建

在Linux操作系统下任一路径下新建一个uCOS的工程目录,该目录下新建uCOS-II目录用来保存uCOS相关部分。下载uCOS-II V2.91源码并解压,把Source目录全部拷贝到uCOS-II目录下,同时在目录下新建一个Cfg目录用来保存uCOS的配置文件,新建一个Ports目录用来保存uCOS移植接口文件。
把启动代码目录start_code拷贝到UCGUI目录下,这部分代码无需任何的修改。并保留其中的Makefile这些文件。GCC启动代码下的工程管理Makefile提取自uboot,可以方便地增加源代码以及代码目录。
在UCGUI目录下新建apps目录,用来保存应用相关的源码。
最终的UCGUI目录内容如下:

uCOS/start_code,保存s3c2416启动代码相关的部分
uCOS/app,保存工个工程的应用部分

uCOS/uCOS-II/Cfg,保存uCOS的配置部分
uCOS/uCOS-II/Ports,保存uCOS移植部分
uCOS/uCOS-II/Source,保存uCOS的源码,通常可直接替换更高版本的源码

3. uCOS移植

uCOS-II应用在不同的cpu,需要在uCOS-II/Ports目录中实现os_cpu.h、os_cpu_a.s、os_cpu_c.c这三个文件的修改编写。

3.1. os_cpu.h的编写

3.1.1. 外部声明

uCOS-II 用 OS_CPU_GLOBALS 和 OS_CPU_EXT 来声明外部的变量、符号,这部分如下:

#ifdef  OS_CPU_GLOBALS
#define OS_CPU_EXT
#else
#define OS_CPU_EXT  extern
#endif
3.1.2. 数据类型定义

为了确保uC/OS-II的可移植性,在os_cpu.h中声明了一系列的类型定义。这些类型不依赖于c数据类型如int、short、long等。数据类型定义如下:

typedef  unsigned  char   BOOLEAN;           /* 布尔变量*/
typedef  unsigned  char  INT8U;             /* 无符号8位整型变量*/
typedef  signed      char   INT8S;             /* 有符号8位整型变量*/
typedef  unsigned  short INT16U;            /* 无符号16位整型变量*/
typedef  signed    short INT16S;            /* 有符号16位整型变量*/
typedef  unsigned  int    INT32U;            /* 无符号32位整型变量*/
typedef  signed    int    INT32S;            /* 有符号32位整型变量*/
typedef  float            FP32;              /* 单精度浮点数(32位长度)*/
typedef  double           FP64;              /* 双精度浮点数(64位长度)*/
3.1.3. 栈配置

uCOS-II适用于8位、16位、32位的cpu,不同字长的cpu,其栈字长也是不一样的,uCOS-II用OS_STK表栈类型,同时栈的生长方式可以由高地址到低地址,也可由低地址到高地址。对于arm架构cpu,栈可以向下,也可以向上增长。但对于各个编译器是约定栈由高地址向低地址增长的,栈字长为32位。栈配置内容如下:

typedef   INT32U         OS_STK;               /* 栈是32位宽度*/
#define   OS_STK_GROWTH    1                   /*  栈是从高往下生长*/
3.1.4. 临界区访问

对于可抢占式操作系统,有一小段关键代码必须独占访问,如果有一个任务(线程)正在访问临界代码,则其它任务(线程)不能再进入该段代码,直到占有访问权的任务(线程)退出这个临界区。
uCOS-II在访问内核临界区时是通过 OS_ENTER_CRITICAL()/OS_EXIT_CRITICAL() 这两个宏开关中断 来禁止任务抢占来确保临界区不被破坏。通常,临界区访问有三种方式,一是直接开关中断,二是从栈中保存/恢复中断状态再开关中断,三是从局部变量保存/恢复中断状态再开关中断。uCOS-II采用了第三种开关中断方式,需实现状态保存恢复开关中断CPU_SR_Save()/CPU_SR_Restore(),需引入一个OS_CPU_SR类型的变量保存cpu中断状态,临界区中断访问内容如下:

#define     OS_CRITICAL_METHOD    3  /*局部变量保存/恢复状态再开关中断 */
typedef      INT32U         OS_CPU_SR;  /*开关中断前用来保存/恢复中断状态*/
#define     OS_ENTER_CRITICAL()    {cpu_sr = CPU_SR_Save ();}  /*  关中断  */
#define     OS_EXIT_CRITICAL()   {CPU_SR_Restore (cpu_sr);}     /*  开中断*/

3.1.5. 函数声明

uCOS-II需汇编实现开关中断、任务切换这些与体系结构相关的功能,在汇编文件os_cpu_a.s中进行实现,头文件进行函数声明,声明有如下几个函数:

#define    OS_TASK_SW()           OSCtxSw()     /*  任务级任务切换函数*/
OS_CPU_SR    CPU_SR_Save(void);
void   CPU_SR_Restore(OS_CPU_SR cpu_sr);
void   OSStartHighRdy(void);
void   OSCtxSw(void);
void   OSIntCtxSw(void);

3.2. os_cpu_a.s的编写

高级语言不能实现保存/恢复寄存器,因此uCOS-II需要编写汇编实现六个简单的函数,CPU_SR_Save ()、CPU_SR_Restore()、OSStartHighRdy()、OSCtxSw()、OSIntCtxSw()、IRQ_SaveContext()。

3.2.1. CPU_SR_Save()函数

由于采用从局部变量保存/恢复中断状态再开关中断的方式,用R0返回中断状态,并关闭中断,该函数是OS_ENTER_CRITICAL()的宏实现。

    .globl   CPU_SR_Save
CPU_SR_Save:
    MRS     R0, CPSR
    ORR     R1, R0, #0xC0 // 设置IRQ,FIQ均禁止中断
    MSR     CPSR_c, R1
    BX     LR        // 禁止中断,返回中断状态到R0中
3.2.2. CPU_SR_Restore()函数

临界区访问完后,需恢复关中断前的中断状态,该函数是OS_EXIT_CRITICAL()的宏实现。

    .globl   CPU_SR_Restore
CPU_SR_Restore:    
    MSR     CPSR_c, R0
    BX     LR
3.2.3. OSStartHighRdy()函数

当用户通过OSStart()启动uCOS内核进行管理时,OSStart()会首先调用OSStartHighRdy()来运行已创建任务中优先级最高的任务,OSStartHighRdy()需完成以下工作:
(1) 禁止中断切换到管理模式,所有任务均工作在管理模式
(2) 调用任务切换钩子函数,即先调用OSTaskSwHook()函数
(3) 标记uCOS-II内核已启动运行,OSRunning = 1
(4) 获得最高优先级任务TCB,得到任务栈指针,SP切换到任务栈
(5) 出栈SP中的任务栈,包括任务状态寄存器CPSR,R0-R12,LR,继续执行任务。

#define  I_Bit      0x80// IRQ中断禁止位
#define  F_Bit      0x40// FIQ中断禁止位
#define  Mode_SVC   0x13 // 管理模式
#define  Mode_SYS   0x1f // 系统模式
    .extern  OSTaskSwHook
    .extern  OSRunning
   .extern  OSTCBHighRdy
    .globl   OSStartHighRdy
OSStartHighRdy:
    MSR     CPSR_c, #(I_Bit+F_Bit+Mode_SVC) // 禁止中断切换到管理模式

    LDR     R0, =OSTaskSwHook // 调用任务切换钩子函数
    MOV     LR, PC            // 准备函数返回地址
    BX      R0            // 支持Thumb、ARM混编

    LDR  R0, =OSRunning    //设置OSRunning为1
    MOV  R1, #1
    STRB    R1, [R0]

    LDR     R0, =OSTCBHighRdy     // 获得最高优先级任务TCB
    LDR     R0, [R0]              // 获得任务栈指针
    LDR     SP, [R0]              // 切换到新任务栈

    LDMFD   SP!, {R0}             // 出栈新任务的CPSR
    MSR     SPSR_cxsf, R0
    LDMFD   SP!, {R0-R12, LR, PC}^ // 出栈新任务的上下文
3.2.4. OSCtxSw()函数

uCOS-II通过OS_Sched()函数进行任务的调度,通过调用OS_TASK_SW()进行实质的任务切换,OSCtxSw()即为OS_TASK_SW()的宏实现,任务切换函数OSCtxSw()需完成以下的工作:
(1) 保存当前任务的上下文(R0-R12,LR,任务打断的PC地址,状态寄存器CPSR)到当前任务栈中
(2) 根据当前任务TCB(任务控制块),获得当前任务栈指针,并把当前任务SP栈保存进栈指针
(3) 调用任务切换钩子函数,即先调用OSTaskSwHook()函数
(4) 把即将运行的最高优先级任务优先级更新到当前优先级变量中
(5) 把即将运行的最高优先级任务TCB(任务控制块)地址更新到当前TCB(任务控制块)地址变量中
(6) 获得最高优先级任务栈指针,SP切换到最高优先级任务栈,并出栈新任务的上下文,执行新任务。

#define  Mode_THUMB 0x20 // THUMB模式
    .extern  OSTCBCur
        .extern  OSTCBHighRdy
        .extern  OSPrioCur
        .extern  OSPrioHighRdy

        .globl   OSCtxSw
        .globl   OSIntCtxSw
OSCtxSw:
    STMFD   SP!, {LR} // 压栈当前任务PC
    STMFD   SP!, {LR} // 压栈当前任务LR
    STMFD   SP!, {R0-R12}  // 压栈当前任务R0-R12
    MRS     R0, CPSR       // 获得当前任务CPSR
    TST     LR, #1         // 测试任务是否工作在Thumb模式
    ORRNE   R0, R0, #Mode_THUMB  // 是Thumb则状态改成Thumb模式
    STMFD   SP!, {R0}            // 压栈CPSR

    LDR     R0, =OSTCBCur     // 获得当前任务TCB
    LDR     R1, [R0]          // 由TCB获得当前任务栈指针
    STR     SP, [R1]          // SP栈保存进当前任务栈指针

OSIntCtxSw:
    LDR     R0, =OSTaskSwHook // 调用任务切换钩子函数
    MOV     LR, PC            // 准备函数返回地址
    BX      R0

    LDR     R0, =OSPrioCur    // 获得当前任务优先级保存指针
    LDR     R1, =OSPrioHighRdy // 获得最高优先级任务优先级保存指针
    LDRB    R2, [R1]           // 获得最高优先级任务优先级
    STRB    R2, [R0]           // 保存进当前任务优先级指针变量中

    LDR     R0, =OSTCBCur      // 获得当前任务TCB保存指针
    LDR     R1, =OSTCBHighRdy  // 获得最高优先级任务TCB保存指针
    LDR     R2, [R1]           // 最高优先级TCB地址保存进当前任务TCB指针
    STR     R2, [R0]

    LDR     SP, [R2]             // SP切换到最高优先级任务栈
    LDMFD   SP!, {R0}            // 出栈新任务的CPSR
    MSR     SPSR_cxsf, R0
    LDMFD   SP!, {R0-R12, LR, PC}^  // 出栈新任务的上下文
3.2.5. OSIntCtxSw()函数

OSIntCtxSw()用来实现中断级的任务切换,当所有的中断(可嵌套中断)执行完毕后,内核需切换到任务继续执行,因此中断级的任务切换与普通的任务切换是一致的,不同的是异常发生时已保存任务的上下文,中断级任务切换无需保存任务的上下文,比OSCtxSw()只少了步骤1和2,其它相同,因此OSIntCtxSw()可合并写在OSCtxSw()上,见OSCtxSw()上的OSIntCtxSw()函数标号。
(1) 调用任务切换钩子函数,即先调用OSTaskSwHook()函数
(2) 把即将运行的最高优先级任务优先级更新到当前优先级变量中
(3) 把即将运行的最高优先级任务TCB(任务控制块)地址更新到当前TCB(任务控制块)地址变量中
(4) 获得最高优先级任务栈指针,SP切换到最高优先级任务栈,并出栈新任务的上下文,执行新任务。

3.2.6. IRQ_SaveContext()函数

任何异常发生时,均会打断任务,进入异常应先保存当前任务的上下文到当前任务栈中,之后再执行异常处理。IRQ异常也不例外,因为uCOS-II需要一个定时器中断Tick,因此IRQ处理也是移植的一部分,IRQ_SaveContext()需完成以下工作:
(1) 临时性使用到一些寄存器,对用到的寄存器压栈到IRQ栈上
(2) 切换到管理模式,禁止中断,任务运行在管理模式,这步将切换SP到被中断打断的任务栈上
(3) 把被打断任务的上下文压入任务的栈。
(4) 跟踪中断嵌套计数,判断是任务被中断还是中断嵌套,中断嵌套不用更新任务栈
(5) 非中断嵌套,根据当前任务TCB(任务控制块)获得栈指针,并把打断任务SP栈保存进栈指针
(6) 调用OSIntEnter()函数进行中断嵌套加计数
(7) 切换到系统模式,并压栈LR,这步是为了使用系统模式栈来处理中断函数,减轻任务栈的使用。
(8) 调用IRQ_Handler()函数实质处理IRQ中断服务,在中断服务中可再打开IRQ中断,支持中断嵌套
(9) 中断服务执行完后,出栈LR,并切换到管理模式,禁止中断,此时SP将切换到被打断任务的任务栈上
(10) 调用OSIntExit()函数进行中断嵌套减计数,如果中断嵌套计数OSIntNesting为0,则说明所有中断退出,将调用OSIntCtxSw()进行中断级任务切换,继续执行任务
(11) 如果中断嵌套计数OSIntNesting不为0,中断未全部退出,则出栈上一个中断的上下文,执行被嵌套的上一级中断

        .extern  OSIntEnter
        .extern  OSIntExit
    .extern  OSIntNesting
        .extern  IRQ_Handler

        .globl   IRQ_SaveContext
IRQ_SaveContext:
    SUB     LR, LR, #4                  // IRQ异常返回地址LR-4
    STMFD   SP!, {R0-R2}                // 临时使用的工作寄存器压入IRQ栈
    MRS     R0, SPSR                    // 保存异常出现前的CPSR
    MOV     R1, LR                      // 保存LR
    MOV     R2, SP                      // 保存IRQ栈指针,用来出栈工作寄存器
    ADD     SP, SP, #(3 * 4)            // 调整回IRQ栈的位置

    MSR     CPSR_c, #(I_Bit+F_Bit+Mode_SVC) // 禁止中断切换到管理模式

    STMFD   SP!, {R1}                   // 压栈打断任务的PC
    STMFD   SP!, {LR}                   // 压栈打断任务的LR
    STMFD   SP!, {R3-R12}               // 压栈打断任务的R12-R3
    LDMFD   R2!, {R5-R7}                // 从IRQ栈恢复R2-R0
    STMFD   SP!, {R5-R7}                // 压栈打断任务的R2-R0
    STMFD   SP!, {R0}                   // 压栈打断任务的CPSR

    LDR  R0, =OSIntNesting           //获得中断嵌套计数
    LDRB    R1, [R0]
    CMP R1, #0                      //判断任务被中断还是中断嵌套
    BNE IntteruptNesting            // 中断嵌套不用更新任务栈指针

    LDR     R0, =OSTCBCur               // 任务被中断打断,获得打断任务TCB
    LDR     R1, [R0]                    // 获得打断任务栈指针
    STR     SP, [R1]                    // SP栈保存进打断任务栈指针

IntteruptNesting:  
    LDR  R0, =OSIntEnter             //调用OSIntEnter()进行中断嵌套计数
    MOV  LR, PC
    BX   R0

    MSR     CPSR_c, #(I_Bit+F_Bit+Mode_SYS) // 切换到系统模式,使用系统模式栈处理中断
    STMFD   SP!, {LR}           // 压栈系统模式LR

    LDR  R0, =IRQ_Handler               // 调用IRQ处理函数
    MOV  LR, PC
    BX  R0

    LDMFD   SP!, {LR}           // 出栈系统模式LR 
    MSR     CPSR_c, #(I_Bit+F_Bit+Mode_SVC)// 切换到管理模式,使用任务栈进行出栈

    LDR  R0, =OSIntExit      // 调用OSIntExit()进行中断减计数,可能不返回
    MOV  LR, PC
    BX   R0

    LDMFD   SP!, {R0}          // 中断发生嵌套,出栈上一个中断的上下文
    MSR     SPSR_cxsf, R0
    LDMFD   SP!, {R0-R12, LR, PC}^

3.3. os_cpu_c.c文件的编写

uCOS-II需要编写十个简单的钩子函数,如果没有特殊需求,可以留空。OSInitHookBegin()、OSInitHookEnd()、OSTaskCreateHook()、OSTaskDelHook()、OSTaskIdleHook()、OSTaskStatHook()、、OSTaskSwHook()、OSTCBInitHook()、OSTimeTickHook()、OSTaskReturnHook()。其中较重要的还有OSTaskStkInit()函数,这个函数用来初始化任务栈,任务状态的,是必需的。

3.3.1. OSTaskStkInit()函数
#define  Mode_SVC    0x13
#define  Mode_THUMB  0x20
#define  Mode_ARM   0x00
OS_STK  *OSTaskStkInit (void (*task)(void *pd), void *pdata, OS_STK *ptos,INT16U opt)
{
    OS_STK *stk;
    (void)opt;                              /* 避免编译器警告 */
    stk    = ptos;                          /* 获取堆栈指针   */

    *stk = (OS_STK) task;                   /*  pc  */
    *--stk = (OS_STK) task;                 /*  lr  */
    *--stk = 0;                             /*  r12  */
    *--stk = 0;                             /*  r11  */
    *--stk = 0;                             /*  r10  */
    *--stk = 0;                             /*  r9   */
    *--stk = 0;                             /*  r8   */
    *--stk = 0;                             /* r7   */
    *--stk = 0;                             /*  r6   */
    *--stk = 0;                             /*  r5   */
    *--stk = 0;                             /*  r4   */
    *--stk = 0;                             /*  r3   */
    *--stk = 0;                             /*  r2   */
    *--stk = 0;                             /*  r1   */
    *--stk = (unsigned int)pdata;          /*  使用R0传递参数 */
    if (((OS_STK)task & 0x01u) ==0x01u) { /* 判断任务是运行在Thumb模式还是在ARM模式 */
       *--stk = (OS_STK)(Mode_SVC |Mode_THUMB); /* CPSR,任务工作在Thumb状态管理模式 */
    } else {
       *--stk = (OS_STK)(Mode_SVC |Mode_ARM); /* CPSR,任务工作在ARM状态管理模式 */
    }
    return (stk);
}
3.3.2. 钩子函数

钩子函数可以扩展用户的代码到内核中,实现一些特定的功能,无特殊功能需求,可留空。

void OSInitHookBegin (void)
{
}
void OSInitHookEnd (void)
{

}
void OSTaskCreateHook (OS_TCB *ptcb)
{
    ptcb = ptcb;
}
void OSTaskDelHook (OS_TCB *ptcb)
{
    (void)ptcb;
}
void OSTaskSwHook (void)
{

}
void OSTaskStatHook (void)
{

}
void OSTCBInitHook (OS_TCB *ptcb)
{
    (void)ptcb;
}
void OSTimeTickHook (void)
{

}
void OSTaskIdleHook (void)
{

}
void OSTaskReturnHook(OS_TCB  *p_tcb)
{
    (void)(p_tcb);
}