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。

本文来源：https://www.2haoxitong.net/k/doc/32feb74ef46527d3240ce04b.html