STM32和STR71X移植uCos-II操作系统比较分析

STM32和STR71X移植uCos-II操作系统比较分析

——ARM7 TDMI和ARMv7-M Cortex-M3 的异同

STM32F103ZE，大容量，ARMv7-M，Cortex-M3系列，双堆栈，handler模式和线程模式，中断比较简单，且中断向量表偏移也很容易；

STR710FZ2，ARM7TDMI，七种模式，快速中断和外部中断，中断执行流程比较复杂。

1 临界区的实现

1.1 STM32的实现

进入临界区#define  OS_ENTER_CRITICAL()  {cpu_sr = OS_CPU_SR_Save();}

OS_CPU_SR_Save

MRS     R0, PRIMASK      ; 保存到R0，即返回值cpu_sr就是R0的值

CPSID   I                    ;关中断，Cortex-M3特殊指令

BX      LR

退出临界区#define  OS_EXIT_CRITICAL()   {OS_CPU_SR_Restore(cpu_sr);}

OS_CPU_SR_Restore

MSR     PRIMASK, R0         ;传入的参数cpu_sr就是R0的值

BX      LR

程序中如何保护R0的，细看汇编发现，实际上在执行关中断后，将R0保存到了sp+8处，开中断时再取出来，这样才保证了不会被修改。

STR      r0,[sp,#0x08]tPendTimes = 0;

同时，开中断， LDR      r0,[sp,#0x08]，则从sp+8处取出来，保存到R0中。

需要说明的是，如果先执行了一次关中断（执行CPSID   I 后，PRIMASK的值变为了1）再执行一次关中断（保存PRIMASK的值到R0中，但是此刻PRIMASK的值已经是1了），然后再执行开中断（将R0保存到PRIMASK，实际值仍然是1，无法打开中断）。

1.2   STR71X的实现

进入临界区#define  OS_ENTER_CRITICAL()  {cpu_sr = OS_CPU_SR_Save();}

OS_CPU_SR_Save

MRS     R0,CPSR             ; 将CPSR保存到R0中

ORR     R1,R0,#NO_INT               ;NO_INT-C0,则将CPSR的I、F位设为1

MSR     CPSR_c,R1                ;将R1的值存入CPSR的低8位，控制域

MRS     R1,CPSR           ;下面四句确保I、F位变为1了

AND     R1,R1,#NO_INT

CMP     R1,#NO_INT

BNE     OS_CPU_SR_Save              ; Not properly disabled (try again)

BX      LR                          ;

退出临界区#define  OS_EXIT_CRITICAL()   {OS_CPU_SR_Restore(cpu_sr);}

OS_CPU_SR_Restore

MSR     CPSR_c,R0                ;将传入的参数cpu_sr保存到CPSR的控制域

BX      LR

2任务的调度、切换

2.1 STM32的实现

STM32是Cortex-M3的内核，有双堆栈功能，且支持软中断，故很容易实现。实现的机理是触发一个软中断，然后在软中断里执行任务调度。

2.1.1 任务堆栈的初始化

任务建立以后，需要对其堆栈进行初始化操作，实际就是将需要用到的通用寄存器入栈，不同的芯片，入栈次序不同。Cortex-M3在发生中断时，由硬件自动将R0等8个寄存器入栈了，为了配合这一特性，堆栈初始化函数写成下面的。

函数的有4个参数，第一个是建立的任务地址，第二是建立任务时携带的参数，第三个是任务的栈顶（堆栈方向增长方向是向下），第4个是可选的参数。

其中装载的这些寄存器:

R1-R12没有什么意义；

R0是传入的参数；

R14是连接寄存器，初值是0xFFFF FFFE，最低4位是E，是个非法值，主要目的是不让使用R14，即任务无法返回；

R15是PC指针，指向任务的入口；

XPSR由APSR、IPSR、EPSR 3个组合而成，第24位必须为1。

OS_STK *OSTaskStkInit (void (*task)(void *p_arg), void *p_arg, OS_STK *ptos, INT16U opt)

{

OS_STK *stk;

(void)opt;                                 /*  'opt' 不需要可选参数 */

stk       = ptos;                          /* 装载栈顶 */

/* 这8个寄存器中断发生时，会自动入栈 */

*(stk)    = (INT32U)0x01000000L;           /* xPSR，第24位必须为1 */

*(--stk)  = (INT32U)task;                  /* Entry Point ，PC 指针，执行任务的地址*/

*(--stk)  = (INT32U)0xFFFFFFFEL;           /* R14 (LR) (init value will cause fault if ever used)    */

*(--stk)  = (INT32U)0x12121212L;           /* R12  */

*(--stk)  = (INT32U)0x03030303L;           /* R3   */

*(--stk)  = (INT32U)0x02020202L;           /* R2   */

*(--stk)  = (INT32U)0x01010101L;           /* R1   */

*(--stk)  = (INT32U)p_arg;                 /* R0 : argument，传入的参数 */

/* 这8个也需要保存  */

*(--stk)  = (INT32U)0x11111111L;           /* R11    */

*(--stk)  = (INT32U)0x10101010L;           /* R10   */

*(--stk)  = (INT32U)0x09090909L;           /* R9    */

*(--stk)  = (INT32U)0x08080808L;           /* R8    */

*(--stk)  = (INT32U)0x07070707L;           /* R7    */

*(--stk)  = (INT32U)0x06060606L;           /* R6    */

*(--stk)  = (INT32U)0x05050505L;           /* R5    */

*(--stk)  = (INT32U)0x04040404L;           /* R4    */

return (stk);

}

2.1.2 开始多任务调度

在main函数的末尾调用OSStart函数，此函数计算处就绪任务表中优先级最高的那个，然后调用下面的函数，触发软中断，开始多任务调度，然后永远都不会在返回main函数。

OSStartHighRdy

LDR     R0, =NVIC_SYSPRI2        ; 设置OSPendSV的优先级是255，最低

LDR     R1, =NVIC_PENDSV_PRI

STRB    R1, [R0]

MOVS    R0, #0                    ; PSP线程堆栈指针的值设为0

MSR     PSP, R0

LDR     R0, __OS_Running           ; 将OS_Running设为1，开始多任务调度

MOVS    R1, #1

STRB    R1, [R0]

LDR     R0, =NVIC_INT_CTRL       ; 触发一次OSPendSV的软中断

LDR     R1, =NVIC_PENDSVSET

STR     R1, [R0]

CPSIE   I                                             ;开总中断

2.1.3 多任务调度的处理

真正实现任务的切换是在OSPendSV的中断里实现的，需要说明的是cortex-M3在发生中断时，由硬件自动将R0、R1、R2、R3、R12、R14、R15、XPSR等8个寄存器入栈了。

OSPendSV

CPSID   I       ;任务切换期间需要关中断

MRS     R0, PSP                ; 判断PSP是否是0，首次切换时是0

CBZ     R0, OSPendSV_nosave    ; 若是首次切换，不需要执行下面的

;首次切换时，任务刚创建，R4-R11已经在堆栈中

SUBS    R0, R0, #0x20           ; R0 = R0 – 0x20，将R4-R11这8个寄存器入栈

STM     R0, {R4-R11}

LDR     R1, __OS_TCBCur        ; OSTCBCur->OSTCBStkPtr = SP;

LDR     R1, [R1]                            ;OSTCBCur的第一个元素的地址就是它本身地

STR     R0, [R1]                 ; 址，此时R1中保存的是要被切换的任务的堆栈

;地址，实际是保存被切换时的堆栈

OSPendSV_nosave

PUSH    {R14}                            ;R14入栈，执行OS_TaskSwHook函数，然后出栈

LDR     R0, __OS_TaskSwHook

BLX     R0

POP     {R14}

LDR     R0, __OS_PrioCur         ; OS_PrioCur变为OS_PrioHighRdy

LDR     R1, __OS_PrioHighRdy

LDRB    R2, [R1]

STRB    R2, [R0]

LDR     R0, __OS_TCBCur           ; OS_TCBCur变为OS_TCBHighRdy

LDR     R1, __OS_TCBHighRdy

LDR     R2, [R1]

STR     R2, [R0]

LDR     R0, [R2]                        ; R0是新任务的SP

LDM     R0, {R4-R11}               ; 弹出R4-R11等8个寄存器的值

ADDS    R0, R0, #0x20

MSR     PSP, R0                        ;PSP变为R0的值

ORR     LR, LR, #0x04               ; 见权威指南P40页，确保使用线程堆栈

CPSIE   I                                              ; 开总中断

BX      LR

2.1.4 线程中请求任务调度

当任务主动让出CPU时，需要进行任务切换，则会执行OS_Sched函数，此函数调用采用OS_TASK_SW完成任务切换。

#define  OS_TASK_SW()         OSCtxSw()

OSCtxSw                 ;悬起PSV异常

LDR     R0, =NVIC_INT_CTRL        ; 触发PSV中断

LDR     R1, =NVIC_PENDSVSET

STR     R1, [R0]

BX      LR

2.1.5 中断中请求任务调度

中断执行完毕后，如果需要执行任务切换，则会执行void  OSIntExit (void)函数，此函数中调用OSIntCtxSw();完成任务切换。

OSIntCtxSw      ;悬起PSV异常

LDR     R0, =NVIC_INT_CTRL         ; 触发PSV中断

LDR     R1, =NVIC_PENDSVSET

STR     R1, [R0]

BX      LR

这样在中断里请求调度和在任务里请求调度，变得没有区别，Cortex-M3的特殊机制，采用触发软中断的方式，让任务的切换在中断里进行，而中断发生后，硬件又会自动将R0等8个寄存器入栈，这样使得操作起来变得容易，需要切换时，只需要触发一个软中断。

2.1.6 时钟节拍

STM32提供滴答计时器，可以用来实现，或者任意采用一个其它的定时器中断实现，主要内容如下。

void TIM2_IRQHandler(void)

{

OS_CPU_SR  cpu_sr;

OS_ENTER_CRITICAL();   /* Tell uC/OS-II that we are starting an ISR*/

OSIntNesting++;

OS_EXIT_CRITICAL();

OSTimeTick();          //调用TimeTick，处理延时

OSIntExit();                 //触发软中断，调度任务

}

2.2 STR71X的实现

STR71X没有软中断，且只有一个堆栈指针（线程和中断使用一个堆栈），任务切换时，修改堆栈指针，指向不同的地方，完成切换。

2.2.1任务堆栈的初始化

ARM7 TDMI中断发生时，硬件不会让寄存器自动入栈，因此需要将R0-R15等寄存器全部入栈，需要说明的是，STR71X的程序状态寄存器保存再了最后。ARM_SVC_MODE主要信息是特权模式、允许中断和快速中断、使用THUMB指令。

OS_STK *OSTaskStkInit (void (*task)(void *p_arg), void *p_arg, OS_STK *ptos, INT16U opt)

{

OS_STK *stk;

opt      = opt;                         /* 'opt' is not used, prevent warning                      */

stk      = ptos;                        /* Load stack pointer                                      */

*(stk)   = (OS_STK)task;                /* Entry Point                                             */

*(--stk) = (INT32U)0x14141414L;         /* R14 (LR)                                                */

*(--stk) = (INT32U)0x12121212L;         /* R12                                                     */

*(--stk) = (INT32U)0x11111111L;         /* R11                                                     */

*(--stk) = (INT32U)0x10101010L;         /* R10                                                     */

*(--stk) = (INT32U)0x09090909L;         /* R9                                                      */

*(--stk) = (INT32U)0x08080808L;         /* R8                                                      */

*(--stk) = (INT32U)0x07070707L;         /* R7                                                      */

*(--stk) = (INT32U)0x06060606L;         /* R6                                                      */

*(--stk) = (INT32U)0x05050505L;         /* R5                                                      */

*(--stk) = (INT32U)0x04040404L;         /* R4                                                      */

*(--stk) = (INT32U)0x03030303L;         /* R3                                                      */

*(--stk) = (INT32U)0x02020202L;         /* R2                                                      */

*(--stk) = (INT32U)0x01010101L;         /* R1                                                      */

*(--stk) = (INT32U)p_arg;               /* R0 : argument                                           */

*(--stk) = (INT32U)ARM_SVC_MODE;        /* CPSR  (Enable both IRQ and FIQ interrupts)              */

return (stk);

}

2.2.2 开始多任务调度

Main函数的结尾，调用OSStart函数，此函数调用下面的代码，实现任务的调度，然后永远都不会在返回。首先切换到特权模式，然后获取优先级最高的任务的堆栈，弹出保存的CPSR信息，弹出PC指针等，开始进入任务中执行。

OSStartHighRdy

MSR     CPSR_c, #(NO_INT | SVC32_MODE)      ；切换到特权模式，关闭I、F中断

LDR     R0, =OSTaskSwHook       ; 执行OSTaskSwHook();

MOV     LR, PC

BX      R0

LDR     R4, =OSRunning           ; OSRunning = TRUE，允许多任务调度

MOV     R5, #1

STRB    R5, [R4]

; SP切换到优先级最高的任务堆栈

LDR     R4, =OSTCBHighRdy       ;

LDR     R4, [R4]                  ;

LDR     SP, [R4]                  ; SP就是任务的堆栈

LDR     R4,  [SP], #4             ; 弹出CPSR

MSR     SPSR_cxsf,R4                     ;保存到SPSR

LDMFD   SP!, {R0-R12,LR,PC}^     ; 弹出R0-R12，LR，PC

2.2.3 线程中请求任务调度

当任务主动让出CPU时，需要进行任务切换，则会执行OS_Sched函数，此函数调用OS_TASK_SW完成任务切换。

#define  OS_TASK_SW()         OSCtxSw()

OSCtxSw

STMFD   SP!, {LR}               ; 不知道为什么入栈两次，这样PC岂不是

STMFD   SP!, {LR}                        ;与LR一样了？

STMFD   SP!, {R0-R12}           ;     Push registers

MRS     R4,  CPSR               ;     Push current CPSR

TST     LR, #1                  ;     See if called from Thumb mode

ORRNE   R4,  R4, #0x20          ;     If yes, Set the T-bit

STMFD   SP!, {R4}

LDR     R4, =OSTCBCur           ; OSTCBCur->OSTCBStkPtr = SP;

LDR     R5, [R4]

STR     SP, [R5]

LDR     R0, =OSTaskSwHook       ; OSTaskSwHook();

MOV     LR, PC

BX      R0

LDR     R4, =OSPrioCur          ; OSPrioCur = OSPrioHighRdy

LDR     R5, =OSPrioHighRdy

LDRB    R6, [R5]

STRB    R6, [R4]

LDR     R4, =OSTCBCur           ; OSTCBCur  = OSTCBHighRdy;

LDR     R6, =OSTCBHighRdy

LDR     R6, [R6]

STR     R6, [R4]

LDR     SP, [R6]                ; SP = OSTCBHighRdy->OSTCBStkPtr;

LDMFD   SP!, {R4}               ;    弹出R4

MSR     SPSR_cxsf, R4

LDMFD   SP!, {R0-R12,LR,PC}^    ;    弹出R0-R12，LR，PC

2.2.4 中断里请求任务调度

中断里请求任务调度，则会执行void  OSIntExit (void)函数，此函数中调用OSIntCtxSw();完成任务切换。与任务中请求调度相比，省去了保存原来堆栈的寄存器部分，因为在进入中断时已经保存过一次了，想见下面的分析

OSIntCtxSw

LDR     R0, =OSTaskSwHook       ; OSTaskSwHook();

MOV     LR, PC

BX      R0

LDR     R4,=OSPrioCur           ; OSPrioCur = OSPrioHighRdy

LDR     R5,=OSPrioHighRdy

LDRB    R6,[R5]

STRB    R6,[R4]

LDR     R4,=OSTCBCur            ; OSTCBCur  = OSTCBHighRdy;

LDR     R6,=OSTCBHighRdy

LDR     R6,[R6]

STR     R6,[R4]

LDR     SP,[R6]                 ; SP = OSTCBHighRdy->OSTCBStkPtr;

LDMFD   SP!, {R4}               ;    Pop new task's CPSR

MSR     SPSR_cxsf, R4

LDMFD   SP!, {R0-R12,LR,PC}^    ;    Pop new task's context

2.2.5 时钟节拍

STR71X系列没有滴答定时器，要想实现时钟节拍，需要借助定时器的中断，代码如下。

void T2TIMI_IRQHandler(void)

{

OSTimeTick();       //中断服务程序只需要执行这个，前后两步采用汇编实现

}

STR71X的中断分为外部中断和快速中断，其处理流程是很复杂的。

（1）外部中断

OS_CPU_IRQ_ISR

STMFD   SP!, {R1-R3}    ;任务被打断以后，保存R1-R3到IRQ模式的堆栈中

MOV     R1, SP          ; R1暂存IRQ模式堆栈的位置

ADD     SP, SP,#12       ; 恢复IRQ模式堆栈原来位置

SUB     R2, LR,#4        ; R2成为PC指针位置

MRS     R3, SPSR        ;将任务此刻的CPSR保存到R3

MSR     CPSR_c, #(NO_INT | SVC32_MODE) ; Change to SVC mode

STMFD   SP!, {R2}        ;保存PC

STMFD   SP!, {LR}        ;保存LR

STMFD   SP!, {R4-R12}    ;保存R4-R12

LDMFD   R1!, {R4-R6}     ;IRQ模式堆栈中恢复原来的R1-R3到R4-R6

STMFD   SP!, {R4-R6}       ;保存原来的R1-R3

STMFD   SP!, {R0}        ;保存R0

STMFD   SP!, {R3}        ;保存CPSR的值

; HANDLE NESTING COUNTER

LDR     R0, =OSIntNesting              ; OSIntNesting++;

LDRB    R1, [R0]

ADD     R1, R1,#1

STRB    R1, [R0]

CMP     R1, #1             ; 中断没有嵌套，执行下面的

BNE     OS_CPU_IRQ_ISR_1

LDR     R4, =OSTCBCur     ;中断无嵌套，将SP的值付给当前任务的堆栈

LDR     R5, [R4]                     ;保存被中断时的堆栈

STR     SP, [R5]             ;

OS_CPU_IRQ_ISR_1

MSR     CPSR_c, #(NO_INT | IRQ32_MODE) ; 切换到IRQ模式

EIC_base_addr         EQU    0xFFFFF800; EIC base address.

CICR_off_addr         EQU    0x04      ; Current Interrupt Channel Register.

IVR_off_addr          EQU    0x18      ; Interrupt Vector Register.

IPR_off_addr          EQU    0x40      ; Interrupt Pending Register.

LDR     R0, =(EIC_base_addr + IVR_off_addr)

MOV     LR, PC

BX      R0                     ; 跳转到相应的IRQ中断处理程序

LDR     R0, =EIC_base_addr

LDR     R2, [R0, #CICR_off_addr]       ; Get the IRQ channel number.

MOV     R3, #1

MOV     R3, R3, LSL r2

STR     R3, [R0, #IPR_off_addr]        ; 清楚中断标志.

MSR     CPSR_c, #(NO_INT | SVC32_MODE) ; 切换到特权模式

LDR     R0, =OSIntExit                 ; 中断完成，请求任务切换

MOV     LR, PC

BX      R0

; 执行新任务

LDMFD   SP!, {R4}                      ;    Pop new task's CPSR

MSR     SPSR_cxsf, R4

LDMFD   SP!, {R0-R12,LR,PC}^           ;    Pop new task's context

（2）快速中断

快速中断的处理流程与外部中断基本相同，流程一致。

OS_CPU_FIQ_ISR

STMFD   SP!, {R1-R3}                   ;

MOV     R1, SP                         ; Save   FIQ stack pointer

ADD     SP, SP,#12                     ; Adjust FIQ stack pointer

SUB     R2, LR,#4                      ; Adjust PC for return address to task

MRS     R3, SPSR                       ; Copy SPSR (i.e. interrupted task's

MSR     CPSR_c, #(NO_INT | SVC32_MODE) ; Change to SVC mode

STMFD   SP!, {R2}                      ;    Push task's Return PC

STMFD   SP!, {LR}                      ;    Push task's LR

STMFD   SP!, {R4-R12}                  ;    Push task's R12-R4

LDMFD   R1!, {R4-R6}                   ;    Move task's R1-R3 from FIQ

STMFD   SP!, {R4-R6}

STMFD   SP!, {R0}                      ;    Push task's R0    onto task's

STMFD   SP!, {R3}                      ;    Push task's CPSR (i.e. FIQ's

; HANDLE NESTING COUNTER

LDR     R0, =OSIntNesting              ; OSIntNesting++;

LDRB    R1, [R0]

ADD     R1, R1,#1

STRB    R1, [R0]

CMP     R1, #1                         ; if (OSIntNesting == 1) {

BNE     OS_CPU_FIQ_ISR_1

LDR     R4, =OSTCBCur                  ; OSTCBCur->OSTCBStkPtr = SP

LDR     R5, [R4]

STR     SP, [R5]                       ;

OS_CPU_FIQ_ISR_1

MSR     CPSR_c, #(NO_INT | FIQ32_MODE) ; Change to FIQ mode

LDR     R0, =FIQ_Handler               ; FIQ_Handler();

MOV     LR, PC

BX      R0

MSR     CPSR_c, #(NO_INT | SVC32_MODE) ; Change to SVC mode

LDR     R0, =OSIntExit                 ; OSIntExit();

MOV     LR, PC

BX      R0

; RESTORE NEW TASK'S CONTEXT

LDMFD   SP!, {R4}                      ;    Pop new task's CPSR

MSR     SPSR_cxsf, R4

LDMFD   SP!, {R0-R12,LR,PC}^           ;    Pop new task's context

3 任务调度中模式切换之间的区别

3.1 STR71X的模式切换

ARM7有7种模式，用户、系统、特权、外部中断、快速中断、数据访问中止、未定义指令中止等。

特权模式用于执行任务操作；

系统模式用于执行中断服务程序和main函数；

外部中断和快速中断模式则用于处理中断。

各种模式切换流程：

系统上电复位后，进入系统模式，执行完main函数后，切换到特权模式执行任务；

中断到来后：

先进入中断模式，

然后进入特权模式，保护寄存器到任务的堆栈空间，

再切换到中断模式查找中断向量对应的服务程序地址，找到以后，

切换到系统模式执行服务程序，完毕后再切换到中断模式，

返回后，切换到特权模式，执行中断请求任务调度，

中断返回，仍然是特权模式。

3.2 STM32的模式

Cortex-M3有特权级和用户级两个等级，以及线程模式和异常模式。

异常模式只能使用MSP主堆栈指针，而线程模式可以使用MSP或者PSP。

执行任务的代码是在特权级线程模式，执行中断的代码在特权级异常模式。

系统上电复位后，进入特权级线程模式，使用MSP，开始多任务调用后，使用PSP。