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

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