一、什么是PendSV

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

---

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

PendSV的典型使用场合是在上下文切换时（在不同任务之间切换）。例如，一个系统中有两个就绪的任务，上下文切换被触发的场合可以是：
1、执行一个系统调用
) Q: j: U' j) E$ B2、系统滴答定时器（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 ; 关中断
   & e; g+ ^4 U5 F/ U; e
3.     ;保存上文
   1 v- S7 n* ]/ n2 t
4.     ;.......................
   $ A% G" w4 t( u8 g$ C9 C
5.     ;切换下文
   8 _$ {# l& V- R# H; y
6.     CPSIE I ;开中断
   # ?) A4 ^  v% Y' j4 {/ e7 M1 {; _
7.     BX LR ;异常返回

复制代码

/ @9 e+ y0 [: }3 i# L& V

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

1. NVIC_INT_CTRL EQU 0xE000ED04 ; 中断控制寄存器
   
2. NVIC_SYSPRI14 EQU 0xE000ED22 ; 系统优先级寄存器(优先级14).
   
3. NVIC_PENDSV_PRI EQU 0xFF ; PendSV优先级(最低). NVIC_PENDSVSET EQU 0x10000000 ; PendSV触发值
   
4. 
   / m' s/ {# B, d. B% K  Z+ k  u
5. ; 设置PendSV的异常中断优先级
   
6. 
   9 K1 K' Z" N8 c: |
7. LDR R0, =NVIC_SYSPRI14
   
8. LDR R1, =NVIC_PENDSV_PRI
   
9. STRB R1, [R0] ; 触发PendSV异常
   & J4 S4 _8 _* R2 K
10. LDR R0, =NVIC_INT_CTRL
    # D3 c( q8 O+ T3 g5 B+ ~/ G
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
   2 p: ~7 `5 f  G7 r
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清零，作为首次上下文切换的标志
   
3.    MOVS    R0, #0
   5 G5 o: S0 i& \0 Z
4.    MSR     PSP, R0
   
5.    ;将MSP设为我们为其分配的内存地址
   
6.    LDR     R0, =OS_CPU_ExceptStkBase
   # N9 K6 z% I7 `5 i, W
7.    LDR     R1, [R0]
   
8.    MSR     MSP, R1

复制代码

$ a/ ~+ B6 \$ T: n" b+ T6 y* H

然后就是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
   - D, n/ o5 t3 |, y  g8 Q% F
3.     STM     R0, {R4-R11}
   : k  [1 g8 [6 ^
4. 
   
5.     LDR     R1, =Cur_TCB_Point    ;当前任务的指针
   " d, V. u# W* b7 l' l
6.     LDR     R1, [R1]
   $ c/ g. w6 F0 D0 j1 c7 L5 U! k
7.     STR     R0, [R1]            ; 更新任务堆栈指针

复制代码

& h6 v$ a; q# Y0 m

出栈类似，但要注意顺序

1. LDR     R1, =TCB_Point    ;要切换的任务指针
   
2.     LDR     R2, [R1]
   
3.     LDR     R0, [R2]          ; R0为要切换的任务堆栈地址
   
4.   
   
5.     LDM     R0, {R4-R11}     ; 弹出R4-R11
   
6.     ADDS    R0, R0, #0x20
   . P+ c/ D5 Q$ L8 X
7. 
   ; f" W! v! w- d( ]0 ]3 x$ c7 ~  K
8.     MSR     PSP, R0        ;更新PSP

复制代码

! P4 j" N+ \$ |0 q- g% e+ p7 T! g* v

三、OS实战

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

1. NVIC_INT_CTRL   EQU     0xE000ED04                              ; Interrupt control state register.
   
2. NVIC_SYSPRI14   EQU     0xE000ED22                              ; System priority register (priority 14).
   ; f. U$ ~7 k! d5 [5 H0 |) _
3. NVIC_PENDSV_PRI EQU           0xFF                              ; PendSV priority value (lowest).
   # q( F1 r7 w+ ]; n, L
4. NVIC_PENDSVSET  EQU     0x10000000                              ; Value to trigger PendSV exception.
   
5. 
   
6.   RSEG CODE:CODE:NOROOT(2)
   ; M1 h# ~: Q2 E  `9 V) ^+ k
7.   THUMB
   
8. 
   9 {8 l4 `) L9 D- N. o8 }
9. 
   * ?+ p$ A. j: V0 |5 D. Y& |. e. \# ^3 i
10.   EXTERN  g_OS_CPU_ExceptStkBase
    : M$ P0 M8 t9 V4 P5 j& E& r
11.   
    , o1 C- I) q' Y) m  E
12.   EXTERN  g_OS_Tcb_CurP
    # @! c' I/ U7 m0 F
13.   EXTERN  g_OS_Tcb_HighRdyP
    
14. 
    
15.   PUBLIC OSStart_Asm
    ; ]3 c% d# s. Z8 z
16.   PUBLIC PendSV_Handler
    
17.   PUBLIC OSCtxSw
    ( U; e2 x* e  u+ Y6 L# f
18. 
    
19. OSCtxSw
    + l  V/ r9 n6 F7 m
20.     LDR     R0, =NVIC_INT_CTRL
    7 q" O  B3 u* y/ t9 j3 ^  t, y/ T( M
21.     LDR     R1, =NVIC_PENDSVSET
    , j7 ^9 W# {6 [- `, i1 P5 ~
22.     STR     R1, [R0]
    
23.     BX      LR                                                ; Enable interrupts at processor level
    ( l' K$ L9 \0 O& O5 V1 v- g
24. 
    - W8 q! @7 K5 u2 g4 {& Z  S6 |* `
25. OSStart_Asm
    
26.     LDR     R0, =NVIC_SYSPRI14                                  ; Set the PendSV exception priority
    
27.     LDR     R1, =NVIC_PENDSV_PRI
    : {8 v! i) g: y# v7 J% n) _+ p: F
28.     STRB    R1, [R0]
    
29. 
    + Z9 |' l& w4 p
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
    
34.     LDR     R1, [R0]
    * h! ]2 S( q# ?* X: H7 r" ^
35.     MSR     MSP, R1   
    
36. 
    
37.     LDR     R0, =NVIC_INT_CTRL                                  ; Trigger the PendSV exception (causes context switch)
    
38.     LDR     R1, =NVIC_PENDSVSET
    0 X0 ]; f5 K% b; \- u) H1 W
39.     STR     R1, [R0]
    6 }7 X5 `! i! \/ ~6 |& p
40. 
    
41.     CPSIE   I                                                   ; Enable interrupts at processor level
    % I- ]) h6 g, b  L$ [. o
42. 
    
43. OSStartHang
    
44.     B       OSStartHang                                         ; Should never get here
    ( m# `7 ]1 ~# a
45.    
    % A$ Z6 [/ i( C& U8 k. w& P
46.    
    
47. 
    0 V) K4 Q  i5 D7 J/ ~2 ^6 j/ B
48. PendSV_Handler
    9 B1 |6 ]+ V! `8 |4 ?6 A
49.     CPSID   I                                                   ; Prevent interruption during context switch
    
50.     MRS     R0, PSP                                             ; PSP is process stack pointer
    / n/ z. N! C; q
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
    $ e& \/ A5 q4 v5 d( f
54.     STM     R0, {R4-R11}
    
55. 
    9 w, }/ F4 ^) O. @
56.     LDR     R1, =g_OS_Tcb_CurP                                       ; OSTCBCur->OSTCBStkPtr = SP;
    . k! t  ]8 @8 i7 x
57.     LDR     R1, [R1]
    0 j7 a# r0 w' `0 @. X! U% b
58.     STR     R0, [R1]                                            ; R0 is SP of process being switched out
    
59. 
    
60.                                                                 ; At this point, entire context of process has been saved
    " [$ a  h" W6 A- K4 ^6 V$ r& q1 ^6 n+ J
61. OS_CPU_PendSVHandler_nosave
    / f; Y  `2 |- S# W2 k
62.     LDR     R0, =g_OS_Tcb_CurP                                       ; OSTCBCur  = OSTCBHighRdy;
      E( z6 L1 |6 Z9 Y4 G
63.     LDR     R1, =g_OS_Tcb_HighRdyP
    6 d& X0 e/ t; [, I% w  I0 W' B: e
64.     LDR     R2, [R1]
    
65.     STR     R2, [R0]
    
66. 
    - x& E7 S: Y7 b) H% F* @+ l! \
67.     LDR     R0, [R2]                                       ; R0 is new process SP; SP = OSTCBHighRdy->OSTCBStkPtr;
    
68.   
    5 {# n3 {/ c. B5 G: W4 h& \# [
69.     LDM     R0, {R4-R11}                                        ; Restore r4-11 from new process stack
    6 w- d, v* j2 O) a
70.     ADDS    R0, R0, #0x20
    4 b1 u+ ?: o" l. s( ]5 i6 L. k
71.             
    5 Z  Q* V4 v1 }1 \
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
    9 p0 K6 k& h1 ~
76.     BX      LR                                                  ; Exception return will restore remaining context
    " ^. Q% L' @  J6 @6 t
77.   
    2 M7 {5 ]" ]  U
78.     END

复制代码

. ?% m! Q3 {' e3 R# X- ^$ d

main.c内容如下：

1. #include "stdio.h"
   ! r: f2 t6 d& l; K  o) h: r6 |' N$ L8 c
2. #define OS_EXCEPT_STK_SIZE 1024
   
3. #define TASK_1_STK_SIZE 1024
   
4. #define TASK_2_STK_SIZE 1024
   & ~5 \$ [. |$ M6 t
5. 
   , y6 S* g8 I8 r0 y
6. typedef unsigned int OS_STK;
   
7. typedef void (*OS_TASK)(void);
   
8. 
   
9. typedef struct OS_TCB
   - v0 E+ D) L: w! V& o# _- R  h
10. {
    
11.   OS_STK *StkAddr;
    & u6 L" @4 O- \! g0 c; t# c7 n
12. }OS_TCB,*OS_TCBP;
    
13. 
      X2 i' M9 R# f7 y5 Y! c* o
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];
    
19. OS_STK *g_OS_CPU_ExceptStkBase;
    
20. 
    
21. static OS_TCB TCB_1;
    
22. static OS_TCB TCB_2;
    
23. static OS_STK TASK_1_STK[TASK_1_STK_SIZE];
    ; O" b( h3 H2 I" g) I. p! }8 f1 q
24. static OS_STK TASK_2_STK[TASK_2_STK_SIZE];
    ( }& P+ K4 g& W& m8 p+ D
25. 
    
26. extern void OSStart_Asm(void);
    
27. extern void OSCtxSw(void);
    + s  ]/ ]+ v2 w( n
28. 
    
29. void Task_Switch()
    
30. {
    
31.   if(g_OS_Tcb_CurP == &TCB_1)
    ' }- _+ o/ w, p* \
32.     g_OS_Tcb_HighRdyP=&TCB_2;
    ! x2 i5 Y( t) s+ J
33.   else
      h% C- e- o$ \% l
34.     g_OS_Tcb_HighRdyP=&TCB_1;
    . D# _6 f& T7 K: o7 t; F
35. 
    : ]' H% v* r8 Q6 Z! V8 ~7 G
36.   OSCtxSw();
    0 S) f! a* t; d. W% p% S" ^- |7 e
37. }
    
38. 
    5 ~9 B' O# w+ w4 x. S3 L  w
39. 
    
40. void task_1()
    
41. {
    
42.   printf("Task 1 Running!!!\n");
    : z* l3 x  f4 t. g$ R
43.   Task_Switch();
    9 I$ {, y' _- J% l- ]$ Z& v& L1 V" |
44.   printf("Task 1 Running!!!\n");
    ) F0 v* C' V/ f4 N% W* E! `
45.   Task_Switch();
    ( m& a$ M7 V# p0 [; ^  i+ {
46. }
    
47. 
    
48. void task_2()
    + K4 A( B" q" k0 Y0 n' P
49. {
    1 N' S+ r: @) M  W( \" D
50.   
    + D  l0 l6 a6 y5 S# L  ~
51.   printf("Task 2 Running!!!\n");
      Q5 b' i6 B/ C9 p: K
52.   Task_Switch();
    
53.   printf("Task 2 Running!!!\n");
    ' l" k/ V+ x  n# ^  u: d5 C  _1 J4 t
54.   Task_Switch();
    / _* J* C, [! @1 P8 e
55. }
    ! b: a" ]9 X" H7 M& Y/ ~3 j* c; I
56. 
    3 \. f2 _2 y0 c5 l3 q
57. void Task_End(void)
    
58. {
    + u& [* D: H; A' a' P+ b! q
59.   printf("Task End\n");
    3 t5 B) F: q- S' x% G, o! r6 S
60.   while(1)
    
61.   {}
    
62. }
    * Q6 I! g/ c8 L, A7 `, _
63. 
    7 Q& t# r0 |* f0 |) C* X# k
64. void Task_Create(OS_TCB *tcb,OS_TASK task,OS_STK *stk)
    " D6 y% A+ k% }5 m' F
65. {
    
66.     OS_STK  *p_stk;
    
67.     p_stk      = stk;
    ; J8 q3 M8 P' t5 a, B$ ^! s, v$ \: n
68.     p_stk      = (OS_STK *)((OS_STK)(p_stk) & 0xFFFFFFF8u);
    1 U3 y5 ~% ]$ e5 x, G8 X# a8 D
69.    
    1 Y: x$ N: _$ y8 c8 K0 O
70.     *(--p_stk) = (OS_STK)0x01000000uL;                          //xPSR
    
71.     *(--p_stk) = (OS_STK)task;                                  // Entry Point
    
72.     *(--p_stk) = (OS_STK)Task_End;                                     // R14 (LR)
    
73.     *(--p_stk) = (OS_STK)0x12121212uL;                          // R12
    3 O1 x0 f6 ~5 {% F% l0 \
74.     *(--p_stk) = (OS_STK)0x03030303uL;                          // R3
    6 z) a' T. I9 [- c  L
75.     *(--p_stk) = (OS_STK)0x02020202uL;                          // R2
    
76.     *(--p_stk) = (OS_STK)0x01010101uL;                          // R1
    5 h6 T9 s7 p1 B& f# T  ~# u" ^% R
77.     *(--p_stk) = (OS_STK)0x00000000u;                           // R0
    
78.    
    9 v$ i  S% E% q
79.     *(--p_stk) = (OS_STK)0x11111111uL;                          // R11
    
80.     *(--p_stk) = (OS_STK)0x10101010uL;                          // R10
    9 h2 @( v: p" J( b5 Z' S
81.     *(--p_stk) = (OS_STK)0x09090909uL;                          // R9
    
82.     *(--p_stk) = (OS_STK)0x08080808uL;                          // R8
    
83.     *(--p_stk) = (OS_STK)0x07070707uL;                          // R7
    + V! {. B) @8 T% K6 v
84.     *(--p_stk) = (OS_STK)0x06060606uL;                          // R6
    6 ], x% M& \- k. u3 g* F" B$ `) T
85.     *(--p_stk) = (OS_STK)0x05050505uL;                          // R5
    
86.     *(--p_stk) = (OS_STK)0x04040404uL;                          // R4
    + }0 D9 _( t- A" z/ J: L
87.    
    
88.     tcb->StkAddr=p_stk;
    
89. }
    8 u& M5 K* x+ W- }# `
90. 
    
91. 
      b; ^1 E9 @/ o% @- S- R( ?
92. int main()
    
93. {
    
94.   
    
95.   g_OS_CPU_ExceptStkBase = OS_CPU_ExceptStk + OS_EXCEPT_STK_SIZE - 1;
    
96.   
    * q7 j- K' c/ {6 w& y2 P
97.   Task_Create(&TCB_1,task_1,&TASK_1_STK[TASK_1_STK_SIZE-1]);
    # l# x0 m9 R) a# O9 G+ t+ a; K
98.   Task_Create(&TCB_2,task_2,&TASK_2_STK[TASK_1_STK_SIZE-1]);
    3 k- I) }3 j6 M3 r4 k/ X1 U7 u+ c
99.    
    % T- P/ ?- i% |& E9 P
100.   g_OS_Tcb_HighRdyP=&TCB_1;
     
101.   
     
102.   OSStart_Asm();
     2 o) O5 b1 `  k  S2 n
103.   
       }6 ^  a/ p& V" E
104.   return 0;
     1 `& \+ ]: U/ q) @0 s
105. }

复制代码

编译下载并调试：

* ~+ @7 c* ]* h! M

在此处设置断点

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

2 C2 P: y4 I+ e5 n

+ k) E! W( `& n% y/ W

IO输出如下：

7 j7 D" Z% n1 e4 C4 y

" Y/ }$ l, y2 l% k1 M0 h& q

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