一、什么是PendSV

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

---

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

PendSV的典型使用场合是在上下文切换时（在不同任务之间切换）。例如，一个系统中有两个就绪的任务，上下文切换被触发的场合可以是：
1、执行一个系统调用
2、系统滴答定时器（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
   * G( ^6 y0 \( N- x$ V; U) A; D( A
2.     CPSID I ; 关中断
   ' w  K8 i7 Z' d' W5 Y& J' ^
3.     ;保存上文
   
4.     ;.......................
   
5.     ;切换下文
   
6.     CPSIE I ;开中断
   
7.     BX LR ;异常返回

复制代码

* A5 b1 r4 Z: _2 N

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

1. NVIC_INT_CTRL EQU 0xE000ED04 ; 中断控制寄存器
   
2. NVIC_SYSPRI14 EQU 0xE000ED22 ; 系统优先级寄存器(优先级14).
   - [/ a8 ]4 X5 `- b' {& Q
3. NVIC_PENDSV_PRI EQU 0xFF ; PendSV优先级(最低). NVIC_PENDSVSET EQU 0x10000000 ; PendSV触发值
   
4. 
   0 N% R  _+ c8 v
5. ; 设置PendSV的异常中断优先级
   
6. 
   ! H( {& E9 _& `+ G: @7 c' n
7. LDR R0, =NVIC_SYSPRI14
   
8. LDR R1, =NVIC_PENDSV_PRI
   
9. STRB R1, [R0] ; 触发PendSV异常
   . e0 ]0 H5 N4 S5 G
10. LDR R0, =NVIC_INT_CTRL
    
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
   / b/ b8 y8 Y8 j# I  a4 ^
2.     ORR     LR, LR, #0x04                                   ; Ensure exception return uses process stack

复制代码

+ N, |  V  V/ G& T

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

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

1. EXTERN  OS_CPU_ExceptStkBase
   % q1 Y; [! t  T6 K
2.    ;PSP清零，作为首次上下文切换的标志
   
3.    MOVS    R0, #0
   
4.    MSR     PSP, R0
   ; \1 C6 B% S" B: H' }
5.    ;将MSP设为我们为其分配的内存地址
   
6.    LDR     R0, =OS_CPU_ExceptStkBase
   & a) P9 B: P  G8 y9 [4 [
7.    LDR     R1, [R0]
   0 t6 b" X7 N2 K# M* |5 k; {* X
8.    MSR     MSP, R1

复制代码

2 ~: Z; z. y, @

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

1. MRS     R0, PSP
   
2.     SUBS   R0, R0, #0x20        ;压入R4-R11
   1 ?- {: l  a7 P" a
3.     STM     R0, {R4-R11}
   8 _2 R9 |. o2 W2 H
4. 
   
5.     LDR     R1, =Cur_TCB_Point    ;当前任务的指针
   
6.     LDR     R1, [R1]
   
7.     STR     R0, [R1]            ; 更新任务堆栈指针

复制代码

出栈类似，但要注意顺序

1. LDR     R1, =TCB_Point    ;要切换的任务指针
   
2.     LDR     R2, [R1]
   . x: H4 F( Z+ ?& Z
3.     LDR     R0, [R2]          ; R0为要切换的任务堆栈地址
   # T* d) @+ T% S# p( r
4.   
   
5.     LDM     R0, {R4-R11}     ; 弹出R4-R11
   
6.     ADDS    R0, R0, #0x20
   % ~2 L3 Q, c/ s; t& P
7. 
   
8.     MSR     PSP, R0        ;更新PSP

复制代码

三、OS实战

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

1. NVIC_INT_CTRL   EQU     0xE000ED04                              ; Interrupt control state register.
   % r9 I2 [" M7 t0 G5 {
2. NVIC_SYSPRI14   EQU     0xE000ED22                              ; System priority register (priority 14).
   8 ~, b1 h* ^: d- q0 Q  K; b
3. NVIC_PENDSV_PRI EQU           0xFF                              ; PendSV priority value (lowest).
   % f" j! T5 w! U; ^5 G. v, G
4. NVIC_PENDSVSET  EQU     0x10000000                              ; Value to trigger PendSV exception.
   
5. 
   
6.   RSEG CODE:CODE:NOROOT(2)
   & c7 s% q7 I- u- N8 z( ]) u5 B
7.   THUMB
   & K8 [* b8 m% t4 |- g
8. 
   % k; w2 N- D5 ?8 k# X) z
9. 
   & D' _0 r5 x2 m3 C
10.   EXTERN  g_OS_CPU_ExceptStkBase
    / v2 U) t$ U: B3 t% N
11.   
    $ @( S3 d4 o- L4 ]: h
12.   EXTERN  g_OS_Tcb_CurP
      j! Q, {# K' \. z2 D: l7 c: I
13.   EXTERN  g_OS_Tcb_HighRdyP
    . F, J6 `1 d& L: k. Q" q
14. 
    
15.   PUBLIC OSStart_Asm
    
16.   PUBLIC PendSV_Handler
    ; R4 |$ E7 M- G: g9 A" B" q; _
17.   PUBLIC OSCtxSw
    
18. 
    6 q, J$ x( i  v) Z8 P' ^6 n
19. OSCtxSw
    ; [) ?8 }* v6 W4 Q' M+ l
20.     LDR     R0, =NVIC_INT_CTRL
    - {8 [3 Z2 |" |
21.     LDR     R1, =NVIC_PENDSVSET
    ; N" W: A# H- l! [* @5 j- G
22.     STR     R1, [R0]
    
23.     BX      LR                                                ; Enable interrupts at processor level
    3 Z6 D# H5 w, E' s3 k
24. 
    " U& D1 H2 n& x+ g/ L- E8 u& t
25. OSStart_Asm
    
26.     LDR     R0, =NVIC_SYSPRI14                                  ; Set the PendSV exception priority
    6 v* ~+ V& `! ]( E  C
27.     LDR     R1, =NVIC_PENDSV_PRI
    8 x; C: Q& k' x7 p- X* K
28.     STRB    R1, [R0]
    
29. 
    
30.     MOVS    R0, #0                                              ; Set the PSP to 0 for initial context switch call
    
31.     MSR     PSP, R0
    ' c9 _4 {, y5 Q7 ~
32. 
    
33.     LDR     R0, =g_OS_CPU_ExceptStkBase                           ; Initialize the MSP to the OS_CPU_ExceptStkBase
    ; |# U' ]' W: C% o3 C6 K
34.     LDR     R1, [R0]
    
35.     MSR     MSP, R1   
    6 s: S% |! i  C0 C& g  W$ ^
36. 
    4 F8 {6 K: ?0 V2 S9 X) T
37.     LDR     R0, =NVIC_INT_CTRL                                  ; Trigger the PendSV exception (causes context switch)
    
38.     LDR     R1, =NVIC_PENDSVSET
    
39.     STR     R1, [R0]
    
40. 
    . T+ a4 m& v$ k. u
41.     CPSIE   I                                                   ; Enable interrupts at processor level
    ; S0 c3 ^1 J" ~+ l/ t+ l
42. 
    
43. OSStartHang
    
44.     B       OSStartHang                                         ; Should never get here
    
45.    
    
46.    
    + B$ u- I# v: |) s! H$ [' o; ^; ?
47. 
    
48. PendSV_Handler
    
49.     CPSID   I                                                   ; Prevent interruption during context switch
    6 c# D# y- X7 o$ v
50.     MRS     R0, PSP                                             ; PSP is process stack pointer
    
51.     CBZ     R0, OS_CPU_PendSVHandler_nosave                     ; Skip register save the first time
      H7 o0 _, P9 g0 O+ v( R5 ]+ A% J# F; [
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
    3 g( k: I# r" R4 O3 C7 n. g
59. 
    + V8 k% \3 J: Q
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;
    1 [; ]" S# s+ h* m& l
63.     LDR     R1, =g_OS_Tcb_HighRdyP
    
64.     LDR     R2, [R1]
    & g' t9 }8 G" ?0 c2 ^8 G; K' ]
65.     STR     R2, [R0]
    6 d8 H  p+ Q6 t& S1 {- r
66. 
    ( v% t0 J" u8 w1 N8 J: [0 V2 P! \
67.     LDR     R0, [R2]                                       ; R0 is new process SP; SP = OSTCBHighRdy->OSTCBStkPtr;
    ! y9 k+ m+ T- Y5 Y3 H& _
68.   
    2 M3 q$ F% V. C1 B4 X3 ~$ }9 G+ B
69.     LDM     R0, {R4-R11}                                        ; Restore r4-11 from new process stack
    9 q; K7 e. P& U  N
70.     ADDS    R0, R0, #0x20
    0 ]$ ?6 g; r4 L! y. \% ]( Q# }
71.             
    
72.     MSR     PSP, R0                                             ; Load PSP with new process SP
    
73.     ORR     LR, LR, #0x04                                       ; Ensure exception return uses process stack
    . K9 _: M' p: I- ?
74.    
    * D& k6 [) N+ W) C$ w) E) z% `
75.     CPSIE   I
    & m. a$ ?4 i5 ]) Z; l  \6 Y* `3 O
76.     BX      LR                                                  ; Exception return will restore remaining context
    # v; P% u" e& m7 }
77.   
    ) w- s9 N* r% \% h; q- Z
78.     END

复制代码

( E0 p: |; c+ x  g

main.c内容如下：

1. #include "stdio.h"
   
2. #define OS_EXCEPT_STK_SIZE 1024
   ! |) {8 {4 g/ V
3. #define TASK_1_STK_SIZE 1024
   
4. #define TASK_2_STK_SIZE 1024
   
5. 
   0 N$ Z( Z9 u4 t+ P
6. typedef unsigned int OS_STK;
   
7. typedef void (*OS_TASK)(void);
   + r5 I* j+ ]$ j, {% \' f
8. 
   % k! E4 v# D! e0 i6 l
9. typedef struct OS_TCB
   
10. {
    , L7 m; X. _8 i- C. M, D+ h
11.   OS_STK *StkAddr;
    * a2 ^# F1 Q$ u1 c
12. }OS_TCB,*OS_TCBP;
    ! j) p$ W7 P4 [* s1 S2 p5 ~8 U
13. 
    & a: m; t  ?9 s! t( ?4 i! ?$ L
14. 
    
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];
    8 @. V/ I2 s: b# F! Y) q% F( `
19. OS_STK *g_OS_CPU_ExceptStkBase;
    
20. 
    
21. static OS_TCB TCB_1;
    ) {' p2 F7 [" J; ~, n
22. static OS_TCB TCB_2;
    ' }( X, a! j% t1 d1 ?7 J. \
23. static OS_STK TASK_1_STK[TASK_1_STK_SIZE];
    ( t- ^2 v/ r3 w( l/ P( W
24. static OS_STK TASK_2_STK[TASK_2_STK_SIZE];
    7 |5 A6 x1 d4 O0 `+ I
25. 
    ' y- R$ w! T6 r% J! e1 q
26. extern void OSStart_Asm(void);
    * N! F1 _7 j/ G$ V
27. extern void OSCtxSw(void);
    
28. 
    ; j! e# N  w) a+ T8 m+ k
29. void Task_Switch()
    1 A  P( v1 ]$ C8 N7 _4 i
30. {
    1 c/ I7 Y7 g1 K, w/ j
31.   if(g_OS_Tcb_CurP == &TCB_1)
    
32.     g_OS_Tcb_HighRdyP=&TCB_2;
    + R, a9 \& I7 {9 H. l: Z7 B$ {( W
33.   else
    4 ?' `, O0 Q$ n$ U+ c
34.     g_OS_Tcb_HighRdyP=&TCB_1;
    
35. 
    ; a$ ]' v3 X/ e8 \* {* O) P
36.   OSCtxSw();
    
37. }
    ' N/ g! b6 f1 x) D, N) M7 L
38. 
    
39. 
    ! i0 r* m3 |# R- p
40. void task_1()
    
41. {
    
42.   printf("Task 1 Running!!!\n");
    6 o' i' x+ e- k5 R+ m* Q; \0 W
43.   Task_Switch();
    : v) j3 p: l3 |+ [- g% I
44.   printf("Task 1 Running!!!\n");
    ) N5 a  e" N# d% Y
45.   Task_Switch();
    9 M) C( p- J7 [
46. }
    9 V' Y% R0 j1 ~' _) t6 T
47. 
    
48. void task_2()
    1 l2 c$ o  j' H# b( o9 j6 Z0 x
49. {
    
50.   
      q9 s0 h. N  f9 s0 N" F
51.   printf("Task 2 Running!!!\n");
    
52.   Task_Switch();
    0 f/ ~. E5 A: a4 U3 q" e4 i
53.   printf("Task 2 Running!!!\n");
    0 V7 q% @0 o1 y+ b- L6 ]
54.   Task_Switch();
    
55. }
    
56. 
    
57. void Task_End(void)
    # U( f/ z0 H! ?9 R- o
58. {
    
59.   printf("Task End\n");
    + H, ^0 D3 S9 L
60.   while(1)
    ) e5 K7 |' e7 M% `0 b; }
61.   {}
    
62. }
    - g: X( c8 g  q8 j
63. 
    / s1 B. k, S6 Z
64. void Task_Create(OS_TCB *tcb,OS_TASK task,OS_STK *stk)
    
65. {
    1 Y1 n( {1 q9 J! [9 x' B
66.     OS_STK  *p_stk;
    
67.     p_stk      = stk;
    
68.     p_stk      = (OS_STK *)((OS_STK)(p_stk) & 0xFFFFFFF8u);
    6 }* p4 c/ y! ?
69.    
    
70.     *(--p_stk) = (OS_STK)0x01000000uL;                          //xPSR
    
71.     *(--p_stk) = (OS_STK)task;                                  // Entry Point
    1 q# Q" G; V" ~; q2 T1 f) c
72.     *(--p_stk) = (OS_STK)Task_End;                                     // R14 (LR)
    : M* h: l: l& u3 |' T
73.     *(--p_stk) = (OS_STK)0x12121212uL;                          // R12
    & n4 L. o0 t$ p7 k/ k
74.     *(--p_stk) = (OS_STK)0x03030303uL;                          // R3
    2 A) t- R( z# w# w3 M% l
75.     *(--p_stk) = (OS_STK)0x02020202uL;                          // R2
    
76.     *(--p_stk) = (OS_STK)0x01010101uL;                          // R1
    % x4 A) I- S1 u/ a# I& v
77.     *(--p_stk) = (OS_STK)0x00000000u;                           // R0
    0 w- {  U% ~7 P
78.    
    3 p. C: a- x/ ?& T5 Q% v5 L' V; v
79.     *(--p_stk) = (OS_STK)0x11111111uL;                          // R11
    
80.     *(--p_stk) = (OS_STK)0x10101010uL;                          // R10
    1 w* Z# w) ~  v$ F# T4 p. P, x1 J! W
81.     *(--p_stk) = (OS_STK)0x09090909uL;                          // R9
    . l; L0 D. D# y3 T* O8 a
82.     *(--p_stk) = (OS_STK)0x08080808uL;                          // R8
    0 W9 n9 P! x$ X+ J- v
83.     *(--p_stk) = (OS_STK)0x07070707uL;                          // R7
    0 D9 a8 z% N; A: r& Y' q
84.     *(--p_stk) = (OS_STK)0x06060606uL;                          // R6
    ' c( O* ?& o& P
85.     *(--p_stk) = (OS_STK)0x05050505uL;                          // R5
    
86.     *(--p_stk) = (OS_STK)0x04040404uL;                          // R4
    3 i9 c9 R9 w4 J0 T7 c
87.    
    4 T$ @8 a6 T; x# z
88.     tcb->StkAddr=p_stk;
    
89. }
    & i7 v5 D6 i. X  x8 ^
90. 
    & F. T  u1 b* ?* |4 l" k( X7 q
91. 
    % u2 {8 W% f- P' [6 `2 e; D
92. int main()
    * z$ l7 e  m+ C. `
93. {
    
94.   
    
95.   g_OS_CPU_ExceptStkBase = OS_CPU_ExceptStk + OS_EXCEPT_STK_SIZE - 1;
    
96.   
    
97.   Task_Create(&TCB_1,task_1,&TASK_1_STK[TASK_1_STK_SIZE-1]);
    & L) q  i+ G  P( |+ A$ }9 p
98.   Task_Create(&TCB_2,task_2,&TASK_2_STK[TASK_1_STK_SIZE-1]);
    
99.    
    # O+ ^0 i# i0 O4 w1 `0 R
100.   g_OS_Tcb_HighRdyP=&TCB_1;
     2 R7 p* T* m! v. ?" J
101.   
     9 K8 d: b" a6 w4 W/ r
102.   OSStart_Asm();
     ; \9 S5 o  [0 F$ o. b
103.   
     
104.   return 0;
     
105. }

复制代码

" s. D9 t- \" |

编译下载并调试：

4 Z/ ]- F, e, S+ X' X! ^0 C

在此处设置断点

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

  j4 \9 g) K1 Z6 ~) ^; n) r

IO输出如下：

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