一、什么是PendSV

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

---

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

PendSV的典型使用场合是在上下文切换时（在不同任务之间切换）。例如，一个系统中有两个就绪的任务，上下文切换被触发的场合可以是：
3 [+ `) d! w, u7 I1 `3 P1、执行一个系统调用
1 z; ~, J4 E3 ?" s  K2、系统滴答定时器（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 ; 关中断
     l8 p- }( q- d3 j9 s
3.     ;保存上文
   
4.     ;.......................
   . G' o9 O6 E- s: c7 o" E8 J# q; P/ R
5.     ;切换下文
   ! M  E9 \0 ^/ M  Q6 A6 Q
6.     CPSIE I ;开中断
   ! A! ]0 Q6 M2 x# j. f; I  G' z
7.     BX LR ;异常返回

复制代码

) l2 s9 n/ x! N/ l% E

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

1. NVIC_INT_CTRL EQU 0xE000ED04 ; 中断控制寄存器
   8 T2 i4 N! r1 ^% n5 {
2. NVIC_SYSPRI14 EQU 0xE000ED22 ; 系统优先级寄存器(优先级14).
   ' S7 p  Z, G1 g' Z9 L3 M
3. NVIC_PENDSV_PRI EQU 0xFF ; PendSV优先级(最低). NVIC_PENDSVSET EQU 0x10000000 ; PendSV触发值
   
4. 
   0 z8 L& J( N8 C: g
5. ; 设置PendSV的异常中断优先级
   + R5 Y  V9 G  [8 v0 v
6. 
   
7. LDR R0, =NVIC_SYSPRI14
   
8. LDR R1, =NVIC_PENDSV_PRI
   
9. STRB R1, [R0] ; 触发PendSV异常
   - ^+ e$ I7 U  k
10. LDR R0, =NVIC_INT_CTRL
    8 [. F* {. _+ ~, y3 M( l7 p; F9 P
11. LDR R1, =NVIC_PENDSVSET
    
12. STR R1, [R0]

复制代码

/ z- q* Y! N, t

二、堆栈操作

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

1. MSR     PSP, R0                                             ; Load PSP with new process SP
   7 f$ Y2 C3 b- ?1 C  b& D
2.     ORR     LR, LR, #0x04                                   ; Ensure exception return uses process stack

复制代码

! w8 W" c5 ]7 B

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

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

1. EXTERN  OS_CPU_ExceptStkBase
   ) o7 h  r# p; Y% j4 T( ~( b$ ?- S
2.    ;PSP清零，作为首次上下文切换的标志
   7 n5 [% V2 I$ r" E# h- q
3.    MOVS    R0, #0
   
4.    MSR     PSP, R0
   0 V; F0 H" K2 O
5.    ;将MSP设为我们为其分配的内存地址
   . X8 q2 O7 e+ {9 l. l$ k6 W$ k
6.    LDR     R0, =OS_CPU_ExceptStkBase
   3 N3 L0 K1 S2 d
7.    LDR     R1, [R0]
   1 K8 C# \% i4 j- J. l
8.    MSR     MSP, R1

复制代码

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

1. MRS     R0, PSP
   & V; i" z$ V* p
2.     SUBS   R0, R0, #0x20        ;压入R4-R11
   
3.     STM     R0, {R4-R11}
   # L' C% b7 j, e  g* w8 ]+ F
4. 
     w3 {9 C1 R9 V! j& T
5.     LDR     R1, =Cur_TCB_Point    ;当前任务的指针
   " J: k, R' ?" O2 x& l9 {
6.     LDR     R1, [R1]
   
7.     STR     R0, [R1]            ; 更新任务堆栈指针

复制代码

: h2 ]/ f0 g% M8 V- v

出栈类似，但要注意顺序

1. LDR     R1, =TCB_Point    ;要切换的任务指针
   * M8 u8 q  I4 ?/ U( _+ J
2.     LDR     R2, [R1]
   4 G- ?, f; _; V! H: o& u4 ?+ w+ P, n
3.     LDR     R0, [R2]          ; R0为要切换的任务堆栈地址
   8 m3 Q3 Z% @" b# Y- T5 T
4.   
   
5.     LDM     R0, {R4-R11}     ; 弹出R4-R11
   
6.     ADDS    R0, R0, #0x20
   * h: h. r/ d9 ^; G0 R
7. 
   + x8 u7 m# y2 k: v  h
8.     MSR     PSP, R0        ;更新PSP

复制代码

. R4 l: [- \+ |

三、OS实战

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

1. NVIC_INT_CTRL   EQU     0xE000ED04                              ; Interrupt control state register.
   & t( L0 k+ E" U; b# g) e- U
2. NVIC_SYSPRI14   EQU     0xE000ED22                              ; System priority register (priority 14).
   8 W* W, `8 j: x  z! f
3. NVIC_PENDSV_PRI EQU           0xFF                              ; PendSV priority value (lowest).
   
4. NVIC_PENDSVSET  EQU     0x10000000                              ; Value to trigger PendSV exception.
   ; j- E- Q' ?5 f) [6 T4 Y
5. 
   
6.   RSEG CODE:CODE:NOROOT(2)
     C1 q% f+ P+ @* h
7.   THUMB
   ) V9 k6 }. C9 _& n
8. 
   
9. 
   7 u0 E& A; E5 {% J$ ~% A
10.   EXTERN  g_OS_CPU_ExceptStkBase
    8 S" v1 a  C) |7 o0 E; H! h
11.   
    
12.   EXTERN  g_OS_Tcb_CurP
    4 e( o: X7 h6 @4 \; t" i' Y* t
13.   EXTERN  g_OS_Tcb_HighRdyP
    
14. 
    8 ^+ ]) ^* d5 v+ m, T
15.   PUBLIC OSStart_Asm
    % s  ?: v: r* r( ]! @
16.   PUBLIC PendSV_Handler
    ) `3 V7 i* X" d# o) o% e& b) k
17.   PUBLIC OSCtxSw
    
18. 
    
19. OSCtxSw
    
20.     LDR     R0, =NVIC_INT_CTRL
    3 Y2 B+ }% |: r1 v' I3 b# g
21.     LDR     R1, =NVIC_PENDSVSET
    : X  d  a5 X9 I4 T* \7 w- M: w9 l
22.     STR     R1, [R0]
    
23.     BX      LR                                                ; Enable interrupts at processor level
    * z, `( u, Y2 j: w
24. 
    
25. OSStart_Asm
    
26.     LDR     R0, =NVIC_SYSPRI14                                  ; Set the PendSV exception priority
    
27.     LDR     R1, =NVIC_PENDSV_PRI
    
28.     STRB    R1, [R0]
    + g) M2 g& ]4 W) `& D2 X  [: E
29. 
    
30.     MOVS    R0, #0                                              ; Set the PSP to 0 for initial context switch call
    
31.     MSR     PSP, R0
    % O* u( d* I2 \: {. M$ y
32. 
    . Q3 R8 D% ?: e/ X7 a. O9 N) j
33.     LDR     R0, =g_OS_CPU_ExceptStkBase                           ; Initialize the MSP to the OS_CPU_ExceptStkBase
    , B2 ]. H$ C  V2 a$ A' @
34.     LDR     R1, [R0]
    4 Q2 x* B  k) B5 L
35.     MSR     MSP, R1   
    
36. 
    
37.     LDR     R0, =NVIC_INT_CTRL                                  ; Trigger the PendSV exception (causes context switch)
    
38.     LDR     R1, =NVIC_PENDSVSET
    " y! o9 W7 A- q0 |) Z
39.     STR     R1, [R0]
    , u6 v4 K0 D3 g7 p  D7 Q: @
40. 
    
41.     CPSIE   I                                                   ; Enable interrupts at processor level
    . j. P3 s8 `6 ?0 P, H, {( A
42. 
    - P5 @* g. b! q) z7 g8 i* K7 i
43. OSStartHang
    
44.     B       OSStartHang                                         ; Should never get here
    
45.    
    7 `9 q5 G6 F+ p8 \# [
46.    
    
47. 
    
48. PendSV_Handler
    4 \8 L! i* S  n  R2 D  b9 G' K
49.     CPSID   I                                                   ; Prevent interruption during context switch
      s8 ?% T2 x% O4 h3 X5 q# t
50.     MRS     R0, PSP                                             ; PSP is process stack pointer
    6 y" J% t5 m5 R
51.     CBZ     R0, OS_CPU_PendSVHandler_nosave                     ; Skip register save the first time
    + z1 S& Q( H5 m+ K6 x
52.    
    $ A% u6 s- o4 P7 Z; ^% c9 ]
53.     SUBS    R0, R0, #0x20                                       ; Save remaining regs r4-11 on process stack
    * a$ d$ h8 i& Z8 Z
54.     STM     R0, {R4-R11}
    
55. 
    
56.     LDR     R1, =g_OS_Tcb_CurP                                       ; OSTCBCur->OSTCBStkPtr = SP;
    
57.     LDR     R1, [R1]
    " x. o8 E2 f' X- N
58.     STR     R0, [R1]                                            ; R0 is SP of process being switched out
    7 z; A0 r1 g# ^  _- ]
59. 
    
60.                                                                 ; At this point, entire context of process has been saved
    4 ]8 r( V, b8 K- i( q/ P
61. OS_CPU_PendSVHandler_nosave
    
62.     LDR     R0, =g_OS_Tcb_CurP                                       ; OSTCBCur  = OSTCBHighRdy;
    
63.     LDR     R1, =g_OS_Tcb_HighRdyP
      q4 t! f: q7 d' T  ~, v- [5 k
64.     LDR     R2, [R1]
    
65.     STR     R2, [R0]
    0 G4 z9 a& A+ ]" R- B( u$ i
66. 
    
67.     LDR     R0, [R2]                                       ; R0 is new process SP; SP = OSTCBHighRdy->OSTCBStkPtr;
    
68.   
    - z  u8 F8 j+ O/ Y% n
69.     LDM     R0, {R4-R11}                                        ; Restore r4-11 from new process stack
    " i! n8 ]- Z1 u& i/ X! I6 _
70.     ADDS    R0, R0, #0x20
    
71.             
    8 V. H& ]5 q# w' M, H
72.     MSR     PSP, R0                                             ; Load PSP with new process SP
    5 a/ l5 k# Y9 u* I: P5 m
73.     ORR     LR, LR, #0x04                                       ; Ensure exception return uses process stack
    6 C/ ?7 a- Q. [  ]
74.    
    4 Y; W; N& V2 |  m" r$ s7 y# M7 o3 s
75.     CPSIE   I
    6 K" c" u5 ?: U+ R- u. [* m
76.     BX      LR                                                  ; Exception return will restore remaining context
    
77.   
    
78.     END

复制代码

main.c内容如下：

1. #include "stdio.h"
   3 G$ @1 z- f" @, M  S, w; T
2. #define OS_EXCEPT_STK_SIZE 1024
   
3. #define TASK_1_STK_SIZE 1024
   % Q& H& ~: m2 p: E! l* K4 n- ~
4. #define TASK_2_STK_SIZE 1024
   9 w' G! L8 {0 u' F
5. 
   ) ?/ i- T  X( P7 v8 W8 {6 ]
6. typedef unsigned int OS_STK;
   
7. typedef void (*OS_TASK)(void);
   
8. 
   
9. typedef struct OS_TCB
   , o! m- |+ X& u8 Q$ e  {% L7 j) E
10. {
    
11.   OS_STK *StkAddr;
    
12. }OS_TCB,*OS_TCBP;
    % ]" t/ a. [' U( p7 r( g
13. 
    ( Y  j7 d+ a: k' ^" x% S6 P- ]$ ]1 g
14. 
    $ c5 X) O) }. R2 W1 J+ W
15. OS_TCBP g_OS_Tcb_CurP;
    
16. OS_TCBP g_OS_Tcb_HighRdyP;
    ; N1 L8 p3 B! [6 {6 l5 v: r
17. 
    
18. static OS_STK OS_CPU_ExceptStk[OS_EXCEPT_STK_SIZE];
    
19. OS_STK *g_OS_CPU_ExceptStkBase;
    6 T5 E) h2 B3 J; O, H" h
20. 
    
21. static OS_TCB TCB_1;
    ' R: I8 E, k* {/ I7 y$ U
22. static OS_TCB TCB_2;
    
23. static OS_STK TASK_1_STK[TASK_1_STK_SIZE];
    
24. static OS_STK TASK_2_STK[TASK_2_STK_SIZE];
    0 i& e/ e& G1 |
25. 
    
26. extern void OSStart_Asm(void);
    5 x% H& ]3 J1 E% |- G
27. extern void OSCtxSw(void);
    
28. 
    2 M) b3 E9 B" M! l, J7 D4 r5 D
29. void Task_Switch()
    0 \5 `! f. Y" g# B' L: F  j
30. {
    8 l  B# G' O3 e2 C8 B
31.   if(g_OS_Tcb_CurP == &TCB_1)
    * u+ h7 N1 v; f7 n( e/ T6 ~% |
32.     g_OS_Tcb_HighRdyP=&TCB_2;
    
33.   else
    + t# ]5 G5 [: c- o6 \' h
34.     g_OS_Tcb_HighRdyP=&TCB_1;
    2 i$ E6 F) X( B$ A4 p, C
35. 
    
36.   OSCtxSw();
    & X. {, W7 K3 I2 i8 x! v2 H
37. }
    
38. 
    
39. 
    7 s9 a# y+ _% h# `/ s
40. void task_1()
    
41. {
    
42.   printf("Task 1 Running!!!\n");
    . }7 Q4 q3 s$ H  Z0 R& \! z5 C# y
43.   Task_Switch();
    % E8 L. Y9 o, [6 f3 W
44.   printf("Task 1 Running!!!\n");
    1 H7 i7 B9 a8 z  e; ^8 [' o4 N' ~
45.   Task_Switch();
    4 Z8 D# C3 d/ m5 t6 M4 ^
46. }
    
47. 
    
48. void task_2()
    / D- D4 a( S+ L6 z# R3 _( Z3 I
49. {
    + d/ t6 g9 n4 C! Z8 J& u' G: E8 ^
50.   
    
51.   printf("Task 2 Running!!!\n");
    ' ]& ^0 X- S5 g1 M
52.   Task_Switch();
    3 V4 k' U  i) _
53.   printf("Task 2 Running!!!\n");
    % S5 Q! Q4 B# \+ ^3 Q
54.   Task_Switch();
    
55. }
    
56. 
    
57. void Task_End(void)
    ' C+ ~& B" l! k5 T% X
58. {
    ( M) \5 O- I8 ]/ M$ g
59.   printf("Task End\n");
    # V* _: u; y/ ~, ~% i1 q3 N2 m2 D$ Z
60.   while(1)
    
61.   {}
    
62. }
    
63. 
    : I. ^9 h0 i  |$ h
64. void Task_Create(OS_TCB *tcb,OS_TASK task,OS_STK *stk)
    # r# F+ ?0 g( l/ M# Q: M- a% c
65. {
    
66.     OS_STK  *p_stk;
    
67.     p_stk      = stk;
    5 ~) t5 H; ]; \) b- k
68.     p_stk      = (OS_STK *)((OS_STK)(p_stk) & 0xFFFFFFF8u);
    
69.    
    + P6 ?- V. p/ X1 j  s
70.     *(--p_stk) = (OS_STK)0x01000000uL;                          //xPSR
    ; ^" V$ @7 @' }6 `7 Z: {% E
71.     *(--p_stk) = (OS_STK)task;                                  // Entry Point
    9 w, f, s- ]( Z1 \" a& d
72.     *(--p_stk) = (OS_STK)Task_End;                                     // R14 (LR)
    
73.     *(--p_stk) = (OS_STK)0x12121212uL;                          // R12
    1 T; v3 q4 p& ~* r8 |6 }
74.     *(--p_stk) = (OS_STK)0x03030303uL;                          // R3
    / |1 W6 p: |0 m  Z# E. K
75.     *(--p_stk) = (OS_STK)0x02020202uL;                          // R2
    
76.     *(--p_stk) = (OS_STK)0x01010101uL;                          // R1
    6 Z; R+ D+ P/ E$ i" x, y
77.     *(--p_stk) = (OS_STK)0x00000000u;                           // R0
    
78.    
    4 L( o8 V- p8 R+ F0 ~  Q1 g& o
79.     *(--p_stk) = (OS_STK)0x11111111uL;                          // R11
    , I# M% o; g: e9 q6 d, p6 D6 I
80.     *(--p_stk) = (OS_STK)0x10101010uL;                          // R10
    
81.     *(--p_stk) = (OS_STK)0x09090909uL;                          // R9
    7 h0 |  N- x6 X6 R# l: E
82.     *(--p_stk) = (OS_STK)0x08080808uL;                          // R8
    : f! n* }6 o- }9 h& U( y; j$ Z( T; E5 h
83.     *(--p_stk) = (OS_STK)0x07070707uL;                          // R7
    
84.     *(--p_stk) = (OS_STK)0x06060606uL;                          // R6
    
85.     *(--p_stk) = (OS_STK)0x05050505uL;                          // R5
    
86.     *(--p_stk) = (OS_STK)0x04040404uL;                          // R4
    
87.    
    2 _( p! p. A8 M+ F- v1 f1 D) i
88.     tcb->StkAddr=p_stk;
    , o: o4 R! a' {# ]
89. }
    / R& ~: R2 j; j' n: U
90. 
    
91. 
    
92. int main()
    2 O* W( w' z# y, }7 u9 q' W
93. {
    + j6 q/ }1 Z: F
94.   
    
95.   g_OS_CPU_ExceptStkBase = OS_CPU_ExceptStk + OS_EXCEPT_STK_SIZE - 1;
    8 a. z4 o5 B) P) p  e
96.   
    " t/ a/ l& W/ O: l6 b  Y
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]);
    " A# A* J! t* Y( u& p% @9 a1 K
99.    
    
100.   g_OS_Tcb_HighRdyP=&TCB_1;
     8 Q1 c# O4 O  {0 _% }  [; V
101.   
     
102.   OSStart_Asm();
     - x( ?/ I9 }% S, n
103.   
     
104.   return 0;
     
105. }

复制代码

( O* }& V6 _/ t; [6 a/ a

编译下载并调试：

- v7 [) a/ D, n2 Q- G1 E# E5 I# h

$ j5 j5 M: M0 l- L9 x5 B) d

在此处设置断点

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

3 i$ I* }9 ]0 D* Z

$ L" E6 t" i6 J+ m

IO输出如下：

3 T( C9 h7 m$ I& z

8 g( j6 X3 @' g3 @

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