一、什么是PendSV

PendSV是可悬起异常，如果我们把它配置最低优先级，那么如果同时有多个异常被触发，它会在其他异常执行完毕后再执行，而且任何异常都可以中断它。更详细的内容在《Cortex-M3 权威指南》里有介绍，下面我摘抄了一段。

---

OS 可以利用它“缓期执行”一个异常——直到其它重要的任务完成后才执行动 作。悬起 PendSV 的方法是：手工往 NVIC的 PendSV悬起寄存器中写 1。悬起后，如果优先级不够 高，则将缓期等待执行。

PendSV的典型使用场合是在上下文切换时（在不同任务之间切换）。例如，一个系统中有两个就绪的任务，上下文切换被触发的场合可以是：
1、执行一个系统调用
7 L& _. L& b- z4 e) I2、系统滴答定时器（SYSTICK）中断，（轮转调度中需要）

让我们举个简单的例子来辅助理解。假设有这么一个系统，里面有两个就绪的任务，并且通过SysTick异常启动上下文切换。但若在产生 SysTick 异常时正在响应一个中断，则 SysTick异常会抢占其 ISR。在这种情况下，OS是不能执行上下文切换的，否则将使中断请求被延迟，而且在真实系统中延迟时间还往往不可预知——任何有一丁点实时要求的系统都决不能容忍这 种事。因此，在 CM3 中也是严禁没商量——如果 OS 在某中断活跃时尝试切入线程模式，将触犯用法fault异常。

为解决此问题，早期的 OS 大多会检测当前是否有中断在活跃中，只有在无任何中断需要响应 时，才执行上下文切换（切换期间无法响应中断）。然而，这种方法的弊端在于，它可以把任务切 换动作拖延很久（因为如果抢占了 IRQ，则本次 SysTick在执行后不得作上下文切换，只能等待下 一次SysTick异常），尤其是当某中断源的频率和SysTick异常的频率比较接近时，会发生“共振”， 使上下文切换迟迟不能进行。现在好了，PendSV来完美解决这个问题了。PendSV异常会自动延迟上下文切换的请求，直到 其它的 ISR都完成了处理后才放行。为实现这个机制，需要把 PendSV编程为最低优先级的异常。如果 OS检测到某 IRQ正在活动并且被 SysTick抢占，它将悬起一个 PendSV异常，以便缓期执行 上下文切换。

使用 PendSV 控制上下文切换个中事件的流水账记录如下：

1. 任务 A呼叫 SVC来请求任务切换（例如，等待某些工作完成）

2. OS接收到请求，做好上下文切换的准备，并且悬起一个 PendSV异常。

3. 当 CPU退出 SVC后，它立即进入 PendSV，从而执行上下文切换。

4. 当 PendSV执行完毕后，将返回到任务 B，同时进入线程模式。

5. 发生了一个中断，并且中断服务程序开始执行

6. 在 ISR执行过程中，发生 SysTick异常，并且抢占了该 ISR。

7. OS执行必要的操作，然后悬起 PendSV异常以作好上下文切换的准备。

8. 当 SysTick退出后，回到先前被抢占的 ISR中，ISR继续执行

9. ISR执行完毕并退出后，PendSV服务例程开始执行，并且在里面执行上下文切换

10. 当 PendSV执行完毕后，回到任务 A，同时系统再次进入线程模式。

---

我们在uCOS的PendSV的处理代码中可以看到：

1. OS_CPU_PendSVHandler
   " a! q/ A: K* C1 d
2.     CPSID I ; 关中断
   + M+ i( C# w, X, d
3.     ;保存上文
   + w+ M3 E/ i1 M
4.     ;.......................
     l( U/ o& o  \( _7 D& K7 F/ V
5.     ;切换下文
   
6.     CPSIE I ;开中断
   9 s' J( e" M( z# y; v1 E4 M
7.     BX LR ;异常返回

复制代码

0 F" ]) C2 r% I  }3 [

它在异常一开始就关闭了中端，结束时开启中断，中间的代码为临界区代码，即不可被中断的操作。PendSV异常是任务切换的堆栈部分的核心，由他来完成上下文切换。PendSV的操作也很简单，主要有设置优先级和触发异常两部分：

1. NVIC_INT_CTRL EQU 0xE000ED04 ; 中断控制寄存器
   
2. NVIC_SYSPRI14 EQU 0xE000ED22 ; 系统优先级寄存器(优先级14).
   7 m- x) R" L1 v9 g$ k, ~
3. NVIC_PENDSV_PRI EQU 0xFF ; PendSV优先级(最低). NVIC_PENDSVSET EQU 0x10000000 ; PendSV触发值
   0 w3 t) [% p8 X* v- G8 P
4. 
   - h0 b% ^9 X  b5 D. P1 Y" l
5. ; 设置PendSV的异常中断优先级
   
6. 
   5 J& ]" y4 |# ^$ N; J) {' u- I
7. LDR R0, =NVIC_SYSPRI14
   ; r( _; q8 H& U- v0 }
8. LDR R1, =NVIC_PENDSV_PRI
   
9. STRB R1, [R0] ; 触发PendSV异常
   
10. LDR R0, =NVIC_INT_CTRL
    - x; K" b5 _% f" I% H1 o' w  l
11. LDR R1, =NVIC_PENDSVSET
    
12. STR R1, [R0]

复制代码

二、堆栈操作

Cortex M4有两个堆栈寄存器，主堆栈指针（MSP）与进程堆栈指针（PSP），而且任一时刻只能使用其中的一个。MSP为复位后缺省使用的堆栈指针，异常永远使用MSP，如果手动开启PSP，那么线程使用PSP，否则也使用MSP。怎么开启PSP？

1. MSR     PSP, R0                                             ; Load PSP with new process SP
   9 F5 a- E0 \0 ?
2.     ORR     LR, LR, #0x04                                   ; Ensure exception return uses process stack

复制代码

很容易就看出来了，置LR的位2为1，那么异常返回后，线程使用PSP。

写OS首先要将内存分配搞明白，单片机内存本来就很小，所以我们当然要斤斤计较一下。在OS运行之前，我们首先要初始化MSP和PSP，

1. EXTERN  OS_CPU_ExceptStkBase
   
2.    ;PSP清零，作为首次上下文切换的标志
   4 @0 D: g  M- i1 Y
3.    MOVS    R0, #0
   % \9 m' e: x& E9 H# G8 }
4.    MSR     PSP, R0
   + z# ^% J. Q0 B2 D4 G
5.    ;将MSP设为我们为其分配的内存地址
   % _! W0 N; ^7 V& {' i3 ^
6.    LDR     R0, =OS_CPU_ExceptStkBase
   6 G  F6 P5 k3 M' H  u7 C
7.    LDR     R1, [R0]
   % y4 A& O8 M+ n- N' r" J6 i
8.    MSR     MSP, R1

复制代码

0 l0 Y! C( L0 _4 L: {

然后就是PendSV上下文切换中的堆栈操作了，如果不使用FPU，则进入异常自动压栈xPSR，PC，LR，R12，R0-R3，我们还要把R4-R11入栈。如果开启了FPU，自动压栈的寄存器还有S0-S15，还需吧S16-S31压栈。

1. MRS     R0, PSP
   5 Y/ V, G" X/ {
2.     SUBS   R0, R0, #0x20        ;压入R4-R11
   ( `. K* c' N, o2 ?9 G& R7 U- R
3.     STM     R0, {R4-R11}
   / B7 t( T! s# U5 v' Q
4. 
   
5.     LDR     R1, =Cur_TCB_Point    ;当前任务的指针
   / e% \3 X( I% |" t% o, Q7 K3 n# s
6.     LDR     R1, [R1]
   6 E2 R2 j' B# b) t$ e
7.     STR     R0, [R1]            ; 更新任务堆栈指针

复制代码

出栈类似，但要注意顺序

1. LDR     R1, =TCB_Point    ;要切换的任务指针
   " \% k( g" u( _
2.     LDR     R2, [R1]
     K  P* N4 M9 T7 V2 L
3.     LDR     R0, [R2]          ; R0为要切换的任务堆栈地址
   , Z1 y; {  j& r8 @& {) w& x1 b
4.   
   
5.     LDM     R0, {R4-R11}     ; 弹出R4-R11
   
6.     ADDS    R0, R0, #0x20
   8 j5 K6 h& Q3 B- Z6 X- t8 y
7. 
   
8.     MSR     PSP, R0        ;更新PSP

复制代码

三、OS实战

新建os_port.asm文件，内容如下：

1. NVIC_INT_CTRL   EQU     0xE000ED04                              ; Interrupt control state register.
   
2. NVIC_SYSPRI14   EQU     0xE000ED22                              ; System priority register (priority 14).
   ( I( t- P' ]+ L& L% t' c
3. NVIC_PENDSV_PRI EQU           0xFF                              ; PendSV priority value (lowest).
   
4. NVIC_PENDSVSET  EQU     0x10000000                              ; Value to trigger PendSV exception.
   
5. 
   / o) m/ F4 P+ |9 W; H2 q# ^: s5 `2 V
6.   RSEG CODE:CODE:NOROOT(2)
   4 I8 _- O% ~7 U( k7 M+ v
7.   THUMB
   
8. 
   ) v1 `! ^( `* v2 {% d4 v, R
9. 
   
10.   EXTERN  g_OS_CPU_ExceptStkBase
    
11.   
    ; |$ C) b0 v, c3 N" u# I
12.   EXTERN  g_OS_Tcb_CurP
    6 z3 F4 Z0 I5 {" I
13.   EXTERN  g_OS_Tcb_HighRdyP
    
14. 
    . m- O# N) x. j/ y: q6 n8 A
15.   PUBLIC OSStart_Asm
    
16.   PUBLIC PendSV_Handler
    ; r6 K- l, Q2 [$ S6 \" a
17.   PUBLIC OSCtxSw
    . m) J: a* i7 O9 M0 k- A
18. 
    8 E9 z. E2 P, |7 b# \* b) _. l
19. OSCtxSw
    
20.     LDR     R0, =NVIC_INT_CTRL
    0 F0 J' U% \# _. C" z( [4 r) i
21.     LDR     R1, =NVIC_PENDSVSET
    * J: X  q) c+ ~1 E
22.     STR     R1, [R0]
    
23.     BX      LR                                                ; Enable interrupts at processor level
    
24. 
    2 [/ I  A- A% N# S" ~! a
25. OSStart_Asm
    ! |7 s9 B; {3 q( @$ i
26.     LDR     R0, =NVIC_SYSPRI14                                  ; Set the PendSV exception priority
    
27.     LDR     R1, =NVIC_PENDSV_PRI
    - I; `" s! y0 K3 V+ O. K, Y8 I
28.     STRB    R1, [R0]
    
29. 
    
30.     MOVS    R0, #0                                              ; Set the PSP to 0 for initial context switch call
    
31.     MSR     PSP, R0
    
32. 
    
33.     LDR     R0, =g_OS_CPU_ExceptStkBase                           ; Initialize the MSP to the OS_CPU_ExceptStkBase
    8 Q) k5 ^$ D" Z7 `
34.     LDR     R1, [R0]
    + E( C1 e/ }0 g$ a2 Z1 F& ]$ c* q
35.     MSR     MSP, R1   
    
36. 
    
37.     LDR     R0, =NVIC_INT_CTRL                                  ; Trigger the PendSV exception (causes context switch)
    
38.     LDR     R1, =NVIC_PENDSVSET
    
39.     STR     R1, [R0]
    " D' ?5 V  v' v! S  d
40. 
    
41.     CPSIE   I                                                   ; Enable interrupts at processor level
    
42. 
    " s+ F* @0 t8 f4 H9 J) Y0 |$ x, _
43. OSStartHang
    
44.     B       OSStartHang                                         ; Should never get here
    ) `' F1 |8 f6 Q
45.    
    
46.    
    
47. 
    - u& }( R5 c5 I: n+ [, O
48. PendSV_Handler
    9 j6 t; z2 r4 b# K: n: A+ ~
49.     CPSID   I                                                   ; Prevent interruption during context switch
    1 x+ `2 W. J+ J0 s5 |7 m9 W
50.     MRS     R0, PSP                                             ; PSP is process stack pointer
    
51.     CBZ     R0, OS_CPU_PendSVHandler_nosave                     ; Skip register save the first time
    
52.    
    
53.     SUBS    R0, R0, #0x20                                       ; Save remaining regs r4-11 on process stack
    
54.     STM     R0, {R4-R11}
    
55. 
    " h1 k4 @' [& H# U, q4 v
56.     LDR     R1, =g_OS_Tcb_CurP                                       ; OSTCBCur->OSTCBStkPtr = SP;
    
57.     LDR     R1, [R1]
    $ g/ ~' X2 ^2 {- K" [' K
58.     STR     R0, [R1]                                            ; R0 is SP of process being switched out
    
59. 
    
60.                                                                 ; At this point, entire context of process has been saved
    
61. OS_CPU_PendSVHandler_nosave
    
62.     LDR     R0, =g_OS_Tcb_CurP                                       ; OSTCBCur  = OSTCBHighRdy;
    ! Z/ R/ d: b, s! k
63.     LDR     R1, =g_OS_Tcb_HighRdyP
    " \/ P" {2 t2 u( Y0 w9 u* ^1 t6 u. D' j
64.     LDR     R2, [R1]
    
65.     STR     R2, [R0]
    + a6 P& P3 Y9 l! K, {
66. 
    2 [- ^% U, L, _% I
67.     LDR     R0, [R2]                                       ; R0 is new process SP; SP = OSTCBHighRdy->OSTCBStkPtr;
    6 e3 c+ P. b  q4 g; K  y
68.   
    3 U5 q1 O% O9 Q0 \, N( _
69.     LDM     R0, {R4-R11}                                        ; Restore r4-11 from new process stack
    + B/ B. L( X; Z) C
70.     ADDS    R0, R0, #0x20
    6 r# z5 d1 A+ A2 X  u/ q$ U
71.             
    ) {9 Y$ \2 W" D
72.     MSR     PSP, R0                                             ; Load PSP with new process SP
    
73.     ORR     LR, LR, #0x04                                       ; Ensure exception return uses process stack
    
74.    
    2 Y% F! x% m# v7 b$ }. J
75.     CPSIE   I
    
76.     BX      LR                                                  ; Exception return will restore remaining context
    ' Z' H1 R6 n/ N; Q4 d( D
77.   
    4 J1 v- E4 R8 j7 g  w
78.     END

复制代码

main.c内容如下：

1. #include "stdio.h"
   
2. #define OS_EXCEPT_STK_SIZE 1024
   
3. #define TASK_1_STK_SIZE 1024
   
4. #define TASK_2_STK_SIZE 1024
   - m5 P) B4 B4 V, q
5. 
   / l/ G+ S% D) q+ D9 U7 _: l6 }
6. typedef unsigned int OS_STK;
   5 o  w, V2 T6 d4 X' }
7. typedef void (*OS_TASK)(void);
   
8. 
   . |/ y2 i3 Q* Z! M9 @, U
9. typedef struct OS_TCB
   ; ^# V& n7 `, I/ w3 x
10. {
    
11.   OS_STK *StkAddr;
    , s, K8 d3 q/ w: [7 @& m. Q
12. }OS_TCB,*OS_TCBP;
    
13. 
    
14. 
    + |% U/ y7 D6 m  F
15. OS_TCBP g_OS_Tcb_CurP;
    
16. OS_TCBP g_OS_Tcb_HighRdyP;
    
17. 
    
18. static OS_STK OS_CPU_ExceptStk[OS_EXCEPT_STK_SIZE];
    
19. OS_STK *g_OS_CPU_ExceptStkBase;
    # T! h: r& Y# T7 \( i6 ?3 w
20. 
    2 N: U5 N; Z% d9 ^! G4 h
21. static OS_TCB TCB_1;
    
22. static OS_TCB TCB_2;
    1 z' a% r/ c# q; J: G6 F
23. static OS_STK TASK_1_STK[TASK_1_STK_SIZE];
    
24. static OS_STK TASK_2_STK[TASK_2_STK_SIZE];
    ; N% J: x7 k( x& }) t
25. 
    " Z, V' u$ Y, O1 p
26. extern void OSStart_Asm(void);
    + w  s% g: E) o+ \1 ~' p& D
27. extern void OSCtxSw(void);
    
28. 
    : [2 c9 _! t7 g; ~4 }
29. void Task_Switch()
    * B' {5 `/ {! Q" @) ^2 s( A# B
30. {
    
31.   if(g_OS_Tcb_CurP == &TCB_1)
    4 @) \/ O) D' ^/ `% c1 {7 E" a
32.     g_OS_Tcb_HighRdyP=&TCB_2;
    ( ~- S1 @8 Q: I- v
33.   else
    : W9 Z( C3 A8 K1 K. _' }! s
34.     g_OS_Tcb_HighRdyP=&TCB_1;
    
35. 
    / b  Q8 `$ F+ I' O* E5 `  a
36.   OSCtxSw();
    
37. }
    0 u: y* S; U2 p0 B; W9 [
38. 
    
39. 
    ( k8 T& L1 I% F- v4 m% Z8 W
40. void task_1()
    
41. {
    * Z& Q2 Z1 O: ]
42.   printf("Task 1 Running!!!\n");
    
43.   Task_Switch();
    
44.   printf("Task 1 Running!!!\n");
    
45.   Task_Switch();
    
46. }
    
47. 
    2 k: R1 j* {- {  ?# @* d) F
48. void task_2()
    
49. {
    
50.   
    - l1 `1 F& B; k0 b9 d- d$ i- f
51.   printf("Task 2 Running!!!\n");
    ' q4 Y# H6 F# L
52.   Task_Switch();
    4 \/ E$ V; t7 o  X
53.   printf("Task 2 Running!!!\n");
    " O& \8 u! ~1 b, [
54.   Task_Switch();
    
55. }
    1 A0 c8 }! d% m) Z. \+ a2 e
56. 
    
57. void Task_End(void)
    
58. {
    
59.   printf("Task End\n");
    " J: P2 g9 U# w. w1 \' P
60.   while(1)
    
61.   {}
    
62. }
    
63. 
      L, c, w1 D% I/ p' L) \
64. void Task_Create(OS_TCB *tcb,OS_TASK task,OS_STK *stk)
    
65. {
    
66.     OS_STK  *p_stk;
    
67.     p_stk      = stk;
    3 k; v9 ?3 _3 W6 q8 ?) ]5 b) A
68.     p_stk      = (OS_STK *)((OS_STK)(p_stk) & 0xFFFFFFF8u);
    8 y: j) t( D" w
69.    
    $ S; i6 G* C# b# @
70.     *(--p_stk) = (OS_STK)0x01000000uL;                          //xPSR
    
71.     *(--p_stk) = (OS_STK)task;                                  // Entry Point
    
72.     *(--p_stk) = (OS_STK)Task_End;                                     // R14 (LR)
    8 ^! Y- e7 K6 j0 B& y' I  t
73.     *(--p_stk) = (OS_STK)0x12121212uL;                          // R12
    
74.     *(--p_stk) = (OS_STK)0x03030303uL;                          // R3
    $ O7 C" y  j  G' K: b; u
75.     *(--p_stk) = (OS_STK)0x02020202uL;                          // R2
    
76.     *(--p_stk) = (OS_STK)0x01010101uL;                          // R1
    + [/ w+ ^8 v( E. e( i# W
77.     *(--p_stk) = (OS_STK)0x00000000u;                           // R0
    2 i9 r8 F# b3 C
78.    
    / v' f2 [- G7 L9 T8 \; ^
79.     *(--p_stk) = (OS_STK)0x11111111uL;                          // R11
    % m8 ?7 Q! w: y5 M
80.     *(--p_stk) = (OS_STK)0x10101010uL;                          // R10
    
81.     *(--p_stk) = (OS_STK)0x09090909uL;                          // R9
    
82.     *(--p_stk) = (OS_STK)0x08080808uL;                          // R8
    ! m( C  Q( `1 L; ^* w: f
83.     *(--p_stk) = (OS_STK)0x07070707uL;                          // R7
    , q, ?4 y; M. Q8 ^
84.     *(--p_stk) = (OS_STK)0x06060606uL;                          // R6
    
85.     *(--p_stk) = (OS_STK)0x05050505uL;                          // R5
    
86.     *(--p_stk) = (OS_STK)0x04040404uL;                          // R4
    ( F& w% a1 f6 p
87.    
    " U, l, S% Y* {% M1 n  o' |( i, p
88.     tcb->StkAddr=p_stk;
    
89. }
    
90. 
      b0 c" m# D% X5 Y5 }
91. 
    
92. int main()
    . K) Z+ `' Q( |; s! {7 p
93. {
    1 S2 k4 R- L: l3 V9 T6 y6 q7 K3 I6 ^
94.   
    
95.   g_OS_CPU_ExceptStkBase = OS_CPU_ExceptStk + OS_EXCEPT_STK_SIZE - 1;
    . b/ z6 }- h( f+ t& c
96.   
    
97.   Task_Create(&TCB_1,task_1,&TASK_1_STK[TASK_1_STK_SIZE-1]);
    
98.   Task_Create(&TCB_2,task_2,&TASK_2_STK[TASK_1_STK_SIZE-1]);
    ( r  D% _+ O# l0 F1 E9 j
99.    
    " [1 C/ r6 R1 @0 r& J
100.   g_OS_Tcb_HighRdyP=&TCB_1;
     
101.   
     7 J0 O! L3 Z2 z: K8 L4 I  s! o
102.   OSStart_Asm();
     4 f2 k. T) U5 i9 Q; ?
103.   
     0 o0 @. q- t: C: B
104.   return 0;
     
105. }

复制代码

编译下载并调试：

在此处设置断点

此时寄存器的值，可以看到R4-R11正是我们给的值，单步运行几次，可以看到进入了我们的任务task_1或task_2，任务里打印信息，然后调用Task_Switch进行切换，OSCtxSw触发PendSV异常。

6 G7 a' ]% ^2 T: ^9 ]7 H9 c

IO输出如下：

+ p& j2 t9 c* M' Z

至此我们成功实现了使用PenSV进行两个任务的互相切换。之后，我们使用使用SysTick实现比较完整的多任务切换。

! u' x" g. r6 L" d7 B2 f