一、什么是PendSV

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

---

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

PendSV的典型使用场合是在上下文切换时（在不同任务之间切换）。例如，一个系统中有两个就绪的任务，上下文切换被触发的场合可以是：
! Y. O9 y: x6 z# M% ~0 E1、执行一个系统调用
% X; W7 a4 u0 z$ K4 W' U% W" W6 e2、系统滴答定时器（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
   
2.     CPSID I ; 关中断
   0 @0 [; e2 D2 |: s2 ]
3.     ;保存上文
   " ^# p6 F8 W( d2 T# f0 c0 X/ }
4.     ;.......................
   
5.     ;切换下文
   6 ^6 g. q8 b. |; q: t
6.     CPSIE I ;开中断
   
7.     BX LR ;异常返回

复制代码

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

1. NVIC_INT_CTRL EQU 0xE000ED04 ; 中断控制寄存器
   $ l' g' ^. p) U
2. NVIC_SYSPRI14 EQU 0xE000ED22 ; 系统优先级寄存器(优先级14).
   4 H) l8 t6 O  g5 F8 X9 ]
3. NVIC_PENDSV_PRI EQU 0xFF ; PendSV优先级(最低). NVIC_PENDSVSET EQU 0x10000000 ; PendSV触发值
   
4. 
   
5. ; 设置PendSV的异常中断优先级
   
6. 
   % I' b0 I% k  s& A7 P2 u0 R) G
7. LDR R0, =NVIC_SYSPRI14
   
8. LDR R1, =NVIC_PENDSV_PRI
   5 R6 [  n. N* n5 Q1 \
9. STRB R1, [R0] ; 触发PendSV异常
   
10. LDR R0, =NVIC_INT_CTRL
    
11. LDR R1, =NVIC_PENDSVSET
    : M) s0 d( ^" q3 i# U
12. STR R1, [R0]

复制代码

5 E! [% [. O' q) s6 O

二、堆栈操作

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

1. MSR     PSP, R0                                             ; Load PSP with new process SP
   
2.     ORR     LR, LR, #0x04                                   ; Ensure exception return uses process stack

复制代码

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

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

1. EXTERN  OS_CPU_ExceptStkBase
   . y& f0 T! X/ {" p! a
2.    ;PSP清零，作为首次上下文切换的标志
     f0 L# P& `2 K7 |' L" [. }2 Z
3.    MOVS    R0, #0
   % k2 L! n- B9 [! _. y8 `
4.    MSR     PSP, R0
   7 d2 t5 P2 G! T0 L' }1 K; D: Z
5.    ;将MSP设为我们为其分配的内存地址
   , q% X4 Z& ]2 a9 P
6.    LDR     R0, =OS_CPU_ExceptStkBase
   
7.    LDR     R1, [R0]
   9 [. ], b$ Y. Q) Z
8.    MSR     MSP, R1

复制代码

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

1. MRS     R0, PSP
   ' W! F6 o, a; z! B# s: n
2.     SUBS   R0, R0, #0x20        ;压入R4-R11
   
3.     STM     R0, {R4-R11}
   $ R) M/ n$ j7 @! N! ~
4. 
   ( n- k8 V& Q( c8 M
5.     LDR     R1, =Cur_TCB_Point    ;当前任务的指针
   
6.     LDR     R1, [R1]
   
7.     STR     R0, [R1]            ; 更新任务堆栈指针

复制代码

0 o! g7 n/ h9 a1 w4 l- C9 d

出栈类似，但要注意顺序

1. LDR     R1, =TCB_Point    ;要切换的任务指针
   
2.     LDR     R2, [R1]
   ; p. W2 ]# a% f6 I6 P% o0 i. {
3.     LDR     R0, [R2]          ; R0为要切换的任务堆栈地址
   
4.   
   6 D( `( ~! h  Z. @8 e- D, s' a
5.     LDM     R0, {R4-R11}     ; 弹出R4-R11
   
6.     ADDS    R0, R0, #0x20
   
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).
   
3. NVIC_PENDSV_PRI EQU           0xFF                              ; PendSV priority value (lowest).
   
4. NVIC_PENDSVSET  EQU     0x10000000                              ; Value to trigger PendSV exception.
   5 |$ w: h6 p! c! _3 Z
5. 
   + @1 e& l" j" V: o# R" ?) f
6.   RSEG CODE:CODE:NOROOT(2)
   
7.   THUMB
   % p0 i. P  B  e+ J  z
8. 
   
9. 
   0 ~- z+ U7 G! j
10.   EXTERN  g_OS_CPU_ExceptStkBase
    . I8 e! F6 V2 }* [+ N: s1 b$ o% S+ R
11.   
    
12.   EXTERN  g_OS_Tcb_CurP
    
13.   EXTERN  g_OS_Tcb_HighRdyP
    
14. 
    
15.   PUBLIC OSStart_Asm
    7 C& _" b- W. E& G* g$ O3 }
16.   PUBLIC PendSV_Handler
    
17.   PUBLIC OSCtxSw
    + |# \. k2 s( F2 x% [" @
18. 
    3 T7 N+ W$ u* J7 a
19. OSCtxSw
    
20.     LDR     R0, =NVIC_INT_CTRL
    5 D% N6 k* }9 t$ e0 Q! g
21.     LDR     R1, =NVIC_PENDSVSET
    
22.     STR     R1, [R0]
    + K( Z' Q! U& Y2 f$ f. ?
23.     BX      LR                                                ; Enable interrupts at processor level
    
24. 
    
25. OSStart_Asm
    2 G0 j- @8 d+ h" i. P, z
26.     LDR     R0, =NVIC_SYSPRI14                                  ; Set the PendSV exception priority
    4 r- F! W+ D1 l" ~
27.     LDR     R1, =NVIC_PENDSV_PRI
    
28.     STRB    R1, [R0]
    ) j6 c0 U$ l6 w" X: @8 w
29. 
    
30.     MOVS    R0, #0                                              ; Set the PSP to 0 for initial context switch call
    " Z5 R# J1 N8 D6 z; T
31.     MSR     PSP, R0
    
32. 
    
33.     LDR     R0, =g_OS_CPU_ExceptStkBase                           ; Initialize the MSP to the OS_CPU_ExceptStkBase
    
34.     LDR     R1, [R0]
    
35.     MSR     MSP, R1   
    ' ]" J# p9 A1 O5 o
36. 
    
37.     LDR     R0, =NVIC_INT_CTRL                                  ; Trigger the PendSV exception (causes context switch)
    & B$ A7 O+ f9 V# _
38.     LDR     R1, =NVIC_PENDSVSET
    % j, v* _% X( T
39.     STR     R1, [R0]
    & ]$ p& |4 D$ F8 Q/ o  D7 s% v9 S
40. 
    0 i4 }2 T1 \1 l2 ~
41.     CPSIE   I                                                   ; Enable interrupts at processor level
    
42. 
    ) t0 C8 j9 I( \5 H- g
43. OSStartHang
    
44.     B       OSStartHang                                         ; Should never get here
    
45.    
    
46.    
    0 |% ]/ B0 M6 _) {$ `
47. 
    
48. PendSV_Handler
    & ]$ D' ~$ _0 ?; a  Q/ }4 K2 ?
49.     CPSID   I                                                   ; Prevent interruption during context switch
    
50.     MRS     R0, PSP                                             ; PSP is process stack pointer
    1 \  r1 ?& {" c7 F* j- H! T
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. 
    
56.     LDR     R1, =g_OS_Tcb_CurP                                       ; OSTCBCur->OSTCBStkPtr = SP;
    
57.     LDR     R1, [R1]
    
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
    9 C* _! k/ \& M
62.     LDR     R0, =g_OS_Tcb_CurP                                       ; OSTCBCur  = OSTCBHighRdy;
    6 s* }, e2 ~- _4 u& F7 H  K+ |
63.     LDR     R1, =g_OS_Tcb_HighRdyP
    
64.     LDR     R2, [R1]
    ( n9 A# Z8 ]2 U: k* W, h4 |
65.     STR     R2, [R0]
    " h2 `7 m9 N* v; m, B
66. 
    
67.     LDR     R0, [R2]                                       ; R0 is new process SP; SP = OSTCBHighRdy->OSTCBStkPtr;
    : h+ r" g- V5 z3 h+ Q& n. \: ?  b
68.   
    
69.     LDM     R0, {R4-R11}                                        ; Restore r4-11 from new process stack
    & S1 L9 K$ L3 Q# z
70.     ADDS    R0, R0, #0x20
    
71.             
    
72.     MSR     PSP, R0                                             ; Load PSP with new process SP
    
73.     ORR     LR, LR, #0x04                                       ; Ensure exception return uses process stack
    
74.    
    
75.     CPSIE   I
    / @  u7 e: A4 L, k
76.     BX      LR                                                  ; Exception return will restore remaining context
    - o) o3 a- S( q
77.   
    - D: |5 K; L  M! Q0 |  H  b
78.     END

复制代码

9 K7 Q) l1 y. P. t

main.c内容如下：

1. #include "stdio.h"
   # M) }# m$ u: x* @
2. #define OS_EXCEPT_STK_SIZE 1024
   
3. #define TASK_1_STK_SIZE 1024
   : Y# k- W6 M' Z& l8 s* \
4. #define TASK_2_STK_SIZE 1024
   
5. 
   
6. typedef unsigned int OS_STK;
   
7. typedef void (*OS_TASK)(void);
   
8. 
   
9. typedef struct OS_TCB
   5 y" K* w9 M( C/ I6 A0 J$ W$ i4 E
10. {
    ; k7 W& p! E9 L, ^2 \5 m% o
11.   OS_STK *StkAddr;
    
12. }OS_TCB,*OS_TCBP;
    4 _! w; b, e- C* g3 |; `
13. 
    
14. 
    3 |1 E; z: V6 c
15. OS_TCBP g_OS_Tcb_CurP;
    5 H5 g. r/ O3 G2 z0 \6 ]$ J4 N) G& B9 s
16. OS_TCBP g_OS_Tcb_HighRdyP;
    
17. 
    / U. P  u, F; i+ l
18. static OS_STK OS_CPU_ExceptStk[OS_EXCEPT_STK_SIZE];
    
19. OS_STK *g_OS_CPU_ExceptStkBase;
    ! U+ G: {0 O% B& G; H; Q
20. 
    ! v2 ^9 _% m6 m6 l$ t; W- v
21. static OS_TCB TCB_1;
    9 a" B% Y$ m. c( w/ V1 v
22. static OS_TCB TCB_2;
    
23. static OS_STK TASK_1_STK[TASK_1_STK_SIZE];
    ) F( ~. l( B8 X1 Q
24. static OS_STK TASK_2_STK[TASK_2_STK_SIZE];
    , J) r/ i2 H1 N1 k# R
25. 
    ' ]6 d# X5 B6 w- I& g( F8 O
26. extern void OSStart_Asm(void);
    % {2 d; C/ s/ W4 l
27. extern void OSCtxSw(void);
    
28. 
    
29. void Task_Switch()
    - t4 `6 m% }* z1 c3 N
30. {
    . b) K5 ^8 \2 \2 g4 f
31.   if(g_OS_Tcb_CurP == &TCB_1)
      s9 ~9 N, }  v, F0 i
32.     g_OS_Tcb_HighRdyP=&TCB_2;
    9 }1 Y% ]7 T- x( b7 Z
33.   else
    - b& H7 z3 |3 F6 |! Z' O
34.     g_OS_Tcb_HighRdyP=&TCB_1;
    
35. 
    
36.   OSCtxSw();
    
37. }
    
38. 
    
39. 
    - u, y6 h, k- [! L: E9 q$ O7 ]; {) w
40. void task_1()
    
41. {
    
42.   printf("Task 1 Running!!!\n");
    # a' L- P0 [1 ~4 N& G
43.   Task_Switch();
    ! h, {5 p" Q! r
44.   printf("Task 1 Running!!!\n");
    , o1 J3 y  G4 |9 G9 K
45.   Task_Switch();
    
46. }
    
47. 
    
48. void task_2()
    7 V, K1 O) L* v% ]( z3 W7 P2 f' z
49. {
    
50.   
    0 `8 U) t# v$ E- F0 b  ]) I+ I  ]
51.   printf("Task 2 Running!!!\n");
    " b4 q& r) `8 \3 T  r- P3 [
52.   Task_Switch();
    
53.   printf("Task 2 Running!!!\n");
    
54.   Task_Switch();
    
55. }
    
56. 
    
57. void Task_End(void)
    . @1 a: J1 J6 n. Z, L2 {
58. {
    
59.   printf("Task End\n");
    7 k  N- n- D' h2 ~! [
60.   while(1)
    + r0 [6 ?5 E: p9 U! X* w
61.   {}
    $ {6 w* Q5 P. ?
62. }
    
63. 
    
64. void Task_Create(OS_TCB *tcb,OS_TASK task,OS_STK *stk)
    3 b4 e% {6 D. S4 ~1 J3 o# k$ w4 s
65. {
    
66.     OS_STK  *p_stk;
    # ~" f6 k! z6 T( |- w7 x7 t7 _
67.     p_stk      = stk;
    
68.     p_stk      = (OS_STK *)((OS_STK)(p_stk) & 0xFFFFFFF8u);
    ; X, n+ W* U/ x+ s! G
69.    
    9 {8 G. Q* C. K& M0 J% Q
70.     *(--p_stk) = (OS_STK)0x01000000uL;                          //xPSR
    
71.     *(--p_stk) = (OS_STK)task;                                  // Entry Point
    % |/ [& Q2 d2 J4 I4 c. Y' Q1 F
72.     *(--p_stk) = (OS_STK)Task_End;                                     // R14 (LR)
    
73.     *(--p_stk) = (OS_STK)0x12121212uL;                          // R12
    0 m* j9 n- E1 h$ o
74.     *(--p_stk) = (OS_STK)0x03030303uL;                          // R3
    
75.     *(--p_stk) = (OS_STK)0x02020202uL;                          // R2
    6 d( _) r9 H( `4 Y: D. a
76.     *(--p_stk) = (OS_STK)0x01010101uL;                          // R1
    / V* E0 p  L8 K: M
77.     *(--p_stk) = (OS_STK)0x00000000u;                           // R0
    9 Y; V6 w0 T9 F7 ~0 E
78.    
    + Y5 w1 a- ]. j
79.     *(--p_stk) = (OS_STK)0x11111111uL;                          // R11
    
80.     *(--p_stk) = (OS_STK)0x10101010uL;                          // R10
    
81.     *(--p_stk) = (OS_STK)0x09090909uL;                          // R9
    
82.     *(--p_stk) = (OS_STK)0x08080808uL;                          // R8
    5 E3 G( W& u! }8 G3 a
83.     *(--p_stk) = (OS_STK)0x07070707uL;                          // R7
    . T& w: R" m8 v& m& ^- e* J% \5 h
84.     *(--p_stk) = (OS_STK)0x06060606uL;                          // R6
    
85.     *(--p_stk) = (OS_STK)0x05050505uL;                          // R5
    8 O" _9 s% O6 O- l8 J( _: J
86.     *(--p_stk) = (OS_STK)0x04040404uL;                          // R4
    # Q& ?: w) m! D; {
87.    
    
88.     tcb->StkAddr=p_stk;
    
89. }
    ) U! m/ W$ c, P
90. 
    
91. 
    
92. int main()
    
93. {
    : l1 D# t* M; e) z, L) L4 O
94.   
    4 O8 A+ B+ x: q3 l9 l0 n4 O. z9 `+ ?
95.   g_OS_CPU_ExceptStkBase = OS_CPU_ExceptStk + OS_EXCEPT_STK_SIZE - 1;
    3 h' M, w9 Y* u
96.   
    
97.   Task_Create(&TCB_1,task_1,&TASK_1_STK[TASK_1_STK_SIZE-1]);
    0 x8 n: {) {+ F" f2 U6 n2 y
98.   Task_Create(&TCB_2,task_2,&TASK_2_STK[TASK_1_STK_SIZE-1]);
    3 y; w5 L+ W, `+ a* }; `1 E0 X
99.    
    " z! G7 q- P. J, P6 `
100.   g_OS_Tcb_HighRdyP=&TCB_1;
     : ?/ S/ p9 z& M
101.   
     
102.   OSStart_Asm();
     ) s9 T+ _. J  M# a; c3 ]( J! H
103.   
     
104.   return 0;
     . k! O  T  x* j+ x2 _
105. }

复制代码

" t" m9 {% e3 k+ X6 S( a& N7 `

编译下载并调试：

+ L, a/ |# c& K3 X4 A7 r. a6 l( c

2 i0 C. v7 \. s" Y! B9 ]+ P! d

在此处设置断点

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

IO输出如下：

( n0 ?. c  ?. X0 Z. U

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

+ L- @" `- X2 X4 F8 _3 M