15_GCC下uCOS的移植(1) - S3C2416 裸机开发

操作系统是用来管理系统硬件、软件及数据资源，控制程序运行，并为其它应用软件提供支持的一种系统软件。根据不同的种类，又可分为实时操作系统、桌面操作系统、服务器操作系统等。对于一些小型的应用，对系统实时性要求高，硬件资源有限等的情况下，应尽量避免使用复杂庞大的操作系统(如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);
}