# x* F- N9 ?% _
特别说明：
1.  本教程是安富莱电子原创。
2.  安富莱STM32F407开发板资料已经全部开源，开源地址：地址链接
3.  当前共配套300多个实例，4套用户手册。
. i$ [; I3 `6 |+ t% D

第5章  任务切换设计

    本期教程带领大家学习简易任务切换的设计，主要是学习SVC（Supervisor Call）和PendSV（Pendable Service Call）的使用，并在此基础上设计一个简单的时间片调度器。本期教程要涉及到一些汇编的知识，不过不用担心，用户只需了解一些简单的汇编命令就可以了，最重要的还是理解任务是如何实现切换的。

    5.1 中断的响应序列

    5.2 SVC异常

    5.3 PendSV异常

    5.4 实验例程说明

    5.5 实验总结

5.1  中断的响应序列

    由于SVC和PendSV中断需要用汇编来实现，用汇编来实现就得了解发生中断事件后，处理器内核是如何响应这个过程的。总的来说，当CM3/CM4开始响应一个中断时，会按照如下过程响应中断事件：

  l  入栈：不带浮点寄存器的情况下会有8个寄存器的值压入栈，带浮点寄存器的情况下会有26个寄存器压入栈。

  l  取向量：从向量表中找出对应的服务程序入口地址。

  l  选择堆栈指针MSP/PSP，更新堆栈指针SP，更新连接寄存器LR，更新程序计数器PC。

5.1.1      入栈

    响应异常的第一个行动，就是自动保存现场的必要部分：依次把xPSR,PC, LR, R12以及R3-R0由硬件自动压入适当的堆栈中（如果程序中做了浮点运算，还有18个浮点寄存器需要入栈）：如果当响应异常时，当前的代码正在使用PSP，则压入PSP，也就是使用进程堆栈；否则就压入MSP，使用主堆栈。一旦进入了服务例程，就将一直使用主堆栈。

    下表是带有浮点寄存器和不带有浮点寄存器的异常堆栈，地址由上到下递减。

    注意左侧的浮点寄存器列表，在寄存器FPSCR上面是一个保留寄存器，在给任务堆栈分配大小时要考虑到这个寄存器，同时要注意这些寄存器的存储顺序。上面的寄存器是自动入栈的，还有寄存器R4-R11以及浮点寄存器S16-S31需要手动入栈的。这里有三个知识点，大家要注意：

  l  双字对齐的堆栈工作模式（大家可以查阅Cortex-M3权威指南中文版9.1.1小节进行了解，Cortex-M4现在最新的r0p1版，不知道此功能是否自动打开，后面查阅相关资料了，再做详细介绍）。

  l  为什么R0-R3以及R12可以自动的入栈，而R4-R11是手动入栈?原因就在于ARM上，有一套的C函数调用标准约定（《C/C++ Procedure Call Standard for the ARM Architecture》，AAPCS,Ref5）。各种原因就在它上面：它使得中断服务例程能用C语言编写，编译器优先使用入栈了的寄存器来保存中间结果（当然，如果程序过大也可能要用到R4-R11，此时编译器负责生成代码来push它们）。

  l  为什么R0-R3, R12是最后被压进去的？这样可以更容易地使用SP基址来索引寻址，（这也方便了LDM等多重加载指令。因为LDM必须加载地址连续的一串数据，而现在R0-R3, R12的存储地址连续了）。这种顺序也舒展了参数的传递过程：使之可以方便地通过读取入栈了的R0-R3取出 （主要为系统软件所利用，多见于SVC与PendSV中的参数传递）。

5.1.2      取向量

     当数据总线（系统总线）正在进行入栈操作时，指令总线（I-Code总线）执行另一项重要的任务：从向量表中找出正确的异常向量，然后在服务程序的入口处预取指。由此可以看到各自都有专用总线的好处：入栈与取指这两个工作能同时进行。

5.1.3      更新寄存器

    在入栈和取向量操作完成之后，执行服务例程之前，还要更新一系列的寄存器：

  l  SP：在入栈后会把堆栈指针（PSP或MSP）更新到新的位置。在执行服务例程时，将由MSP负责对堆栈的访问。

  l  PSR：更新IPSR位段（地处PSR的最低部分）的值为新响应的异常编号。

  l  PC：在取向量完成后，PC将指向服务例程的入口地址。

  l  LR：在出入ISR的时候，LR的值将得到重新的诠释，这种特殊的值称为“EXC_RETURN”（这个在上期教程有讲解）在异常进入时由系统计算并赋给LR，并在异常返回时使用它。

    以上是在响应异常时通用寄存器的变化。另一方面，在NVIC中，也会更新若干个相关有寄存器。例如，新响应异常的悬起位将被清除，同时其活动位将被置位。

. r$ k0 {6 A" u4 l8 i

5.2  SVC异常

        SVC多用在上了操作系统的软件开发中，不过也不是OS设计所必须的，比如μCOS-III和μCOS-II就没有使用此中断，而RTX却充分的利用了这个中断，为了方便大家的学习，我们对SVC也做一个详细的介绍。

5.2.1      SVC功能介绍

        SVC用于产生系统函数的调用请求。例如，操作系统通常不让用户程序直接访问硬件，而是通过提供一些系统服务函数，让用户程序使用SVC发出对系统服务函数的呼叫请求，以这种方法调用它们来间接访问硬件。因此，当用户程序想要控制特定的硬件时，它就要产生一个SVC异常，然后操作系统提供的SVC异常服务例程得到执行，它再调用相关的操作系统函数，后者完成用户程序请求的服务。

SVC这种“提出要求——得到满足”的方式很好:

  l  它使用户程序从控制硬件的繁文缛节中解脱出来，而是由OS负责控制具体的硬件。

  l  OS的代码可以经过充分的测试，从而能使系统更加健壮和可靠。

  l  它使用户程序无需在特权级下执行，用户程序无需承担因误操作而瘫痪整个系统的风险。

  l  通过SVC的机制，还让用户程序变得与硬件无关，因此在开发应用程序时无需了解硬件的操作细节，从而简化了开发的难度和繁琐度，并且使应用程序跨硬件平台移植成为可能。开发应用程序唯一需要知道的就是操作系统提供的应用编程接口（API），并且在了解了各个请求代号和参数表后，就可以使用SVC来提出要求了（事实上，为使用方便，操作系统往往会提供一层封皮，以使系统调用的形式看起来和普通的函数调用一致。各封皮函数会正确使用SVC指令来执行系统调用）。其实，严格地讲，操作硬件的工作是由设备驱动程序完成的，只是对应用程序来说，它们也相当于操作系统的一部分。如下图所示：

        SVC异常通过执行”SVC”指令来产生。该指令需要一个立即数，充当系统调用代号。SVC异常服务例程稍后会提取出此代号，从而获知本次调用的具体要求，再调用相应的服务函数。例如，

          SVC  0x3 ; 调用3号系统服务

        在SVC服务例程执行后，上次执行的SVC指令地址可以根据自动入栈的返回地址计算出。找到了SVC指令后，就可以读取该SVC指令的机器码，从机器码中萃取出立即数，就获知了请求执行的功能代号。如果用户程序使用的是PSP，服务例程还需要先执行MRS Rn, PSP指令来获取应用程序的堆栈指针。通过分析LR的值，可以获知在SVC指令执行时，正在使用哪个堆栈。

        注意，我们不能在SVC服务例程中嵌套使用SVC指令（事实上这样做也没意义），因为同优先级的异常不能抢占自身。这种作法会产生一个用法fault。同理，在NMI服务例程中也不得使用SVC，否则将触发硬fault。

5.2.2      SVC触发方式

        SVC的异常号是11，支持可编程。SVC异常可以由SVC指令来触发，也可以通过NVIC来软件触发（通过寄存器NVIC->STIR触发软中断）。这两种方式触发SVC中断有一点不同：软件触发中断是不精确的，也就是说，抢占行为不一定会立即发生，即使当时它没有被掩蔽，也没有被其它ISR阻塞，也不能保证马上响应。这也是写缓冲造成的，会影响到与操作NVIC STIR相临的后一条指令：如果它需要根据中断服务的结果来决定如何工作（如条件跳转），则该指令可能会误动作——这也可以算是紊乱危象的一种表现形式。为解决这个问题，必须使用一条DSB指令，如下例所示：

MOV R0,#SOFTWARE_INTERRUPT_NUMBER

LDRR1,=0xE000EF00    ; 加载NVIC软件触发中断寄存器的地址

STR   R0,  [R1]        ; 触发软件中断

DSB                    ; 执行数据同步隔离指令

...

        但是这种方式还有另一种隐患：如果欲触发的软件中断被除能了，或者执行软件中断的程序自己也是个异常服务程序，软件中断就有可能无法响应。因此，必须在使用前检查这个中断已经在响应中了。为达到此目的，可以让软件中断服务程序在入口处设置一个标志。而SVC要精确很多，SVC指令后，只要此时没有其它高优先级的异常也发生了，SVC中断服务程序可以得到立即执行。

5.2.3      SVC的使用

        SVC是用于呼叫OS所提供的API（RTX是采用的这种方式）。用户程序只需知道传递给OS的参数，而不必知道各API函数的地址。SVC指令带一个8位的立即数，可以视为是它的参数，被封装在指令本身中，如：

SVC   3    ;呼叫3号系统服务

        则3被封装在这个SVC指令中。因此在SVC服务例程中，需要读取本次触发SVC异常的SVC指令，并提取出8位立即数所在的位段，来判断系统调用号，工作流程如下：

        上面的流程图用汇编来实现就是如下这样：

SVC_Handler

TST   LR,  #0x4        ; 测试EXC_RETURN的比特2

ITE   EQ               ; 如果为0,

MRSEQ  R0,  MSP     ; 则使用的是主堆栈，故把MSP的值取出

MRSNE  R0,  PSP      ; 否则, 使用的是进程堆栈，故把MSP的值取出

LDR   R1,  [R0,#24]    ; 从栈中读取PC的值

LDRB   R0,  [R1,#-2]   ; 从SVC指令中读取立即数放到R0

; 准备调用系统服务函数。这需要适当调整入栈的PC的值以及LR(EXC_RETURN)，来进入OS内部

BXLR     ; 借异常返回的形式，进入OS内部，最终调用系统服务函数.

        上面的汇编代码结合着流程图就很好理解了，目的只有一个：得到调用号，用它来调用系统服务函数。接下来我们说一下如何在C中使用SVC。

        因为晚到中断的关系（为什么这么说，请看Cortex-M3权威指南中文版11.6小节），SVC中不能再使用寄存器来传递参数，而是必须使用堆栈。因此，需要使用一段汇编代码来给SVC函数传参数。如果SVC服务例程的主部由C来写，则必须在前面伴随一个汇编写的封皮，用于把堆栈中的参数提取到寄存器中。下面给出一段代码来演示这个工作。这些代码是要使用ARM的编译(armcc)和汇编(armasm)工具来处理的，RVDS和Keil RVMDK都使用这个工具链。

1. /*汇编封皮，用于提出堆栈帧的起始位置，并放到R0中，然后跳转至实际的SVC服务例程中 */
   + U) A" C$ c# m$ P- r8 v- ]
2. __asmvoid SVC_Handler(void)
   
3. {
   ; B: Y  {7 ?$ L5 y* T
4. TSTLR, #4           ; Test bit 2 of EXC_RETURN
   $ c# a5 H$ n" n6 u7 m& p
5. ITEEQ
   
6. MRSEQR0, MSP     ; if 0, stackingused MSP, copy to R0
   
7. MRSNER0, PSP      ;if 1, stacking used PSP, copy to R0
   * i, D! i  H, M5 }  x/ g) w
8. B__cpp(SVC_Handler_C)
   0 I) r# q3 \9 W3 V0 t. v5 Y
9. ALIGN4
   
10. }
    4 V& e# f8 v7 ~
11. /*不必写下BX LR来返回，而是由svc_handler来做决定 */

复制代码

        接下来的SVC服务例程的主体就可以由C来写了，它使用R0作为输入参数（这也是堆栈帧的起始位置），用于进一步提取服务代号，并且传递参数（通过堆栈中的R0-R3）。

1. //堆栈内容:
   
2. //r0, r1, r2, r3, r12, r14, the return address and xPSR
   
3. //- Stacked R0 = svc_args[0]
   ) r: J  o' c- r; M. W" w" ~5 D/ m
4. //- Stacked R1 = svc_args[1]
   
5. //- Stacked R2 = svc_args[2]
   
6. //- Stacked R3 = svc_args[3]
   * S' t( i: i) S( d6 w* a
7. //- Stacked R12 = svc_args[4]
   
8. //- Stacked LR = svc_args[5]
   2 V! n: E7 t) @  g* [. \
9. //- Stacked PC = svc_args[6]
   ! D9 }! ?0 B/ F& p
10. //- Stacked xPSR= svc_args[7]
    ; [* F4 ?& W- a
11. voidSVC_Handler_C(unsigned int * svc_args)
    * m. o' o2 K) g5 h+ n* O
12. {
    4 r  B) G+ \1 S1 N/ M+ N
13. uint8_tsvc_number;
    0 v9 E- i- V; T1 j2 E
14. uint32_tstacked_r0, stacked_r1, stacked_r2, stacked_r3;
    
15. svc_number= ((char *) svc_args[6])[-2];  //Memory[(Stacked PC)-2]
    ' |# V$ ~0 h( H! ^9 ~
16. stacked_r0= svc_args[0];
    
17. stacked_r1= svc_args[1];
    
18. stacked_r2= svc_args[2];
    
19. stacked_r3= svc_args[3];
    
20. //.other processing
    4 K8 |* X1 D7 P0 c
21. .
    
22. // Return result (e.g. sum of first two arguments)
    
23. svc_args[0]= stacked_r0 + stacked_r1;
    : F8 [. K. z2 e2 G
24. return;
    
25. }

复制代码

    后面会有一个专门的例子跟大家讲解SVC的使用。

5.3  PendSV异常

        可以说PendSV (PendedService Call)是OS设计中最重要的中断，OS中可以没有SVC的支持，但是PendSV必须得有。PendSV的异常类型时14，优先级可编程。中断可以通过设置ICSR寄存器的挂起位进行触发。不像SVC，PendSV的中断是不准确的，所以它的挂起状态可以在其它高优先级中断服务程序中进行设置，等中断服务程序执行完以后再执行。

        鉴于这种特性，我们可以设置PendSV为最低优先级，这样等其它高优先级的中断任务执行完以后再执行PendSV中断，这种特性在OS的上下文切换中非常重要。

5.3.1      OS中使用PendSV

        首先，我们来看一下上下文切换的基本概念。在一个典型的嵌入式OS中，处理时间被分成很多的时间片。例如，在一个系统中有两个任务，两个任务的执行是可选择的，如下图所示（两个任务间通过SysTick进行轮转调度的简单模式），OS内核可以通过下面的方式进行触发：

  l  系统滴答定时器（SYSTICK）中断。

  l  用户任务执行SVC指令。比如，由于应用任务等待事件或者数据，此任务将被挂起，然后调用系统服务切换到另一个任务中。

3 \( D7 f  r5 O4 e! m

        上图是两个任务轮转调度的示意图。但若在产生SysTick异常时正在响应一个中断，如下图所示，则SysTick异常会抢占其ISR。在这种情况下，OS是不能执行上下文切换的，否则将使中断请求被延迟，而且在真实系统中延迟时间还往往不可预知——任何有一丁点实时要求的系统都决不能容忍这种事。因此，在CM3/CM4中也是严禁没商量——如果OS在某中断活跃时尝试切入线程模式，将触犯用法fault异常。

) H/ m/ a6 I1 ^! s1 d

        为解决此问题，早期的OS大多会检测当前是否有中断在活跃中，只有在无任何中断需要响应时，才执行上下文切换（切换期间无法响应中断）。然而，这种方法的弊端在于，它可以把任务切换动作拖延很久（因为如果抢占了IRQ，则本次SysTick在执行后不得作上下文切换，只能等待下一次SysTick异常），尤其是当某中断源的频率和SysTick异常的频率比较接近时，会发生“共振”，使上下文切换迟迟不能进行。

        现在好了，PendSV来完美解决这个问题了。PendSV异常会自动延迟上下文切换的请求，直到其它的ISR都完成了处理后才放行。为实现这个机制，需要把PendSV编程为最低优先级的异常。如果OS检测到某IRQ正在活动并且被SysTick抢占，它将悬起一个PendSV异常，以便缓期执行上下文切换。如下图所示。

+ h6 G( V; r% j# y' C  |

        为方便大家理解，下面是上图的执行流程：

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，同时系统再次进入线程模式。

% a9 p& S* j: w" w5.3.2      裸机中使用PendSV

        大家最常见的都是在OS中使用PendSV，在裸机中也用到PendSV。比如，一个中断服务程序需要大量的执行时间，这个程序中有一部分需要高优先级中断中执行，如果所有的中断服务程序都在这个高优先级任务中执行将阻塞低优先级中断的执行，为了解决这个问题，我们可以讲这个程序分为两个部分：

  l  前半部分是时间关键的部分，需要在高优先级任务中快速执行。我们将其放在高优先级的中断服务程序中，程序末尾将PendSV中断使能。

  l  后半部分放在PendSV中断中执行，此时PendSV被设置为最低优先级的中断。

5.4  实验例程说明

        一共为本期教程制作了3个例子，下面就跟大家详细讲解这3个例子。这个三个工程都不需要添加额外的文件，将代码都放在了main.c文件中实现。

                              

5.4.1      实验一：SVC的使用

实验目的：

        1.学习SVC异常的使用

实验内容：

        1.创建一个周期为500ms的自动重装定时器

        2.按键K1按下调用SVC 0

        3.按键K2按下调用SVC 1

        4.按键K3按下调用SVC 2

实验现象：

        请用USB转串口线连接PC机和开发板。PC机上运行SecureCRT软件，波特率设置为115200bps，无硬件流控。从PC机的软件界面观察程序执行结果：

程序设计：

本程序主要分为两个部分：

  Ø  SVC的实现

  Ø  主程序

1.    SVC的实现

1. /*
   & }+ T7 l+ @9 |' z* G
2. *********************************************************************************************************
   
3. *    函 数 名: SVC_Handler
     A& N9 v9 N0 z: f1 m% q, k4 [
4. *    功能说明: SVC异常，汇编的封皮用于获取使用的堆栈指针PSP或MSP
   
5. *    形    参：无
     _+ k7 g8 I' O% U1 ?4 l+ q7 q
6. *    返 回 值: 无
   
7. *********************************************************************************************************
   
8. */
   % M7 W3 j! U3 q2 m! M8 r
9. __asm void SVC_Handler(void)
   ; Z! c: N1 o. S2 t- K: q% V" d9 C" _
10. {
    " h! c" m' _7 {8 n
11.      TST LR, #4 ; Test bit 2 of EXC_RETURN
    
12.      ITE EQ
    # u- W% g- B/ U
13.      MRSEQ R0, MSP ; if 0, stacking used MSP, copy to R0
    ! }, \5 C, S6 }5 b- o5 O+ e) }
14.      MRSNE R0, PSP ; if 1, stacking used PSP, copy to R0
    
15.      B __cpp(SVC_Handler_C)
    ! g# F" a' G4 ^. d3 O
16.      ALIGN 4
    
17. }
    
18. 
    
19. /*
    4 q+ O# G" ^& Y: _& R3 Q" q
20. *********************************************************************************************************
    / f) Z4 ?# g3 W! i
21. *    函 数 名: SVC_Handler_C
    
22. *    功能说明: SVC异常C函数
    2 q" ]9 D7 S( I! M' I+ S
23. *    形    参：svc_args 堆栈起始地址
    4 o. q: z0 r( U9 n2 t
24. *    返 回 值: 无
    
25. *********************************************************************************************************
    ' A4 M* k, h3 H" j! B; Z  ^
26. */
    2 ]& |$ c. _* v7 h
27. void SVC_Handler_C(unsigned int * svc_args)
    2 R6 i! H6 I+ O
28. {
    ' k% F& _! J) N. p
29.      // 堆栈内容:
    $ W8 U" ^& t6 m( H) t
30.      // r0, r1, r2, r3, r12, r14, the return address and xPSR
    
31.      // - Stacked R0 = svc_args[0]
    
32.      // - Stacked R1 = svc_args[1]
    
33.      // - Stacked R2 = svc_args[2]
    % z3 X/ r5 m) J+ ?( N4 \! I. N- `/ i
34.      // - Stacked R3 = svc_args[3]
    
35.      // - Stacked R12 = svc_args[4]
    4 h$ s, w3 E$ o8 R9 N
36.      // - Stacked LR = svc_args[5]
    ; K3 t4 H/ V8 ~
37.      // - Stacked PC = svc_args[6]
    + a0 r( c) Z1 w6 G$ [9 N
38.      // - Stacked xPSR= svc_args[7]
      P. x* w1 b- ]6 }0 V1 c; H1 T
39.      unsigned int svc_number;
    
40.      svc_number = ((char *)svc_args[6])[-2];
    % V2 t0 e. A4 v) m$ w; R2 i, |7 I
41.      switch(svc_number)
    / H/ q! V; D6 ]7 k( A  I
42.      {
    $ w* ?4 m- c7 w. Y9 Y$ L1 s
43.          case 0: svc_args[0] = svc_args[0] + svc_args[1];
    
44.          break;
    
45.          case 1: svc_args[0] = svc_args[0] - svc_args[1];
    6 L. k& o& I% L1 B% L
46.          break;
    % b' p6 [9 N: X9 m2 }( G" Q6 P0 X
47.          case 2: svc_args[0] = svc_args[0] + 1;
      D  a! a/ V( ^2 F
48.          break;
      N3 m, K  u- i! V3 P( R2 w
49.          default: // 未知SVC请求
    ' _* J9 ^5 e* q( l( F  V* }" ]7 n
50.          break;
    
51.      }
    
52. }

复制代码

2.     主程序

这里特别的注意SVC在MDK中的调用方法。

1. /* 定义 SVC 函数 */
   
2. int __svc(0x00) svc_service_add(int x, int y); // 服务0 : 加法
   
3. int __svc(0x01) svc_service_sub(int x, int y); // 服务1 : 减法
   ' }1 y8 U& Z$ `
4. int __svc(0x02) svc_service_incr(int x);       // 服务2 : 自加
   
5. 
   
6. /*
   % a" q, `% D. [  y2 j3 T
7. *********************************************************************************************************
   
8. *    函 数 名: main
   # m  x0 i  L5 |1 j- P! _
9. *    功能说明: c程序入口
   . d7 j% a: l. Y! O5 _& L
10. *    形    参：无
    " @4 y% S6 A: T# {
11. *    返 回 值: 错误代码(无需处理)
    
12. *********************************************************************************************************
    
13. */
    " X% }8 I0 }5 o& n1 a7 L6 X
14. int main(void)
    
15. {   
    
16.      uint8_t x, y, z;
    
17.      uint8_t ucKeyCode;     /* 按键代码 */
    
18.    
      v6 |" X& t# a% |% ?
19.      bsp_Init();            /* 硬件初始化 */
    
20.    
    
21.      PrintfLogo();     /* 打印例程信息到串口1 */
    
22.    
    
23.      bsp_StartAutoTimer(0, 500); /* 启动1个500ms的自动重装的定时器 */
    # Y8 Q' S0 L- I& O" U
24. 
    3 {' \; q! m% D, b7 Z
25.      /* 进入主程序循环体 */
    
26.      while (1)
    9 m; h0 f/ U4 i, `* x8 s
27.      {
    
28.          bsp_Idle();        /* 这个函数在bsp.c文件。用户可以修改这个函数实现CPU休眠和喂狗 */
    
29. 
    ! S" z( |3 u$ D' p7 H# T7 ]
30.          if (bsp_CheckTimer(0)) /* 判断定时器超时时间 */
    
31.          {
    , G, ~: X. p- G6 u: |4 h7 y; Y
32.               /* 每隔500ms 进来一次 */
    1 t9 x5 [6 }  v  _
33.               bsp_LedToggle(4);  /* 翻转LED4的状态 */
    
34.          }
    5 V1 k1 q  k6 @0 u+ \# Z
35. 
    
36.          /* 按键滤波和检测由后台systick中断服务程序实现，我们只需要调用bsp_GetKey读取键值即可。 */
    
37.          ucKeyCode = bsp_GetKey();   /* 读取键值, 无键按下时返回 KEY_NONE = 0 */
    
38.          if (ucKeyCode != KEY_NONE)
    
39.          {
    $ W0 [( m: `2 O; B+ W/ z: B4 F& {" m
40.               switch (ucKeyCode)
    0 _# B  r. A( T1 }5 ]9 ?6 E% P
41.               {
    
42.                    case KEY_DOWN_K1:           /* K1键按下 */
    3 }! Z% v) }8 C( h) x6 n
43.                        x=3;
    8 R* L* G. F; v4 _8 q2 A
44.                        y=5;
    
45.                        z = svc_service_add(x, y);
    
46.                        printf ("3+5 = %d \r\n", z);
    
47.                   
    
48.                        break;
    
49. 
    ( D# x8 P/ G: y( O2 P$ \) p
50.                    case KEY_DOWN_K2:           /* K2键按下 */
    
51.                        x=9;
    
52.                        y=2;
    ( z& b& I5 }) a$ J4 f; @/ f
53.                        z = svc_service_sub(x, y);
    # m9 G& F& T5 e2 I! Q+ S
54.                        printf ("9-2 = %d \r\n", z);
    
55.                        break;
    
56. 
    ' _# q( T( T8 v
57.                    case KEY_DOWN_K3:           /* K3键按下 */
    $ T4 q: ~' k. `% U
58.                        x=3;
    + y7 S  |3 i+ k  z1 h/ \' @6 w
59.                        z = svc_service_incr(x);
    
60.                        printf ("3++ = %d \r\n", z);
    
61.                        break;
    
62.                   
    ' v1 E; q8 i7 I
63.                    default:
    
64.                        /* 其它的键值不处理 */
    . U& |) N# J- w) Q
65.                        break;
    ' X  X6 c$ f/ G) C% D2 K- \
66.               }
    
67.          }
    ; h) c: {+ B1 {5 J
68.      }
    
69. }

复制代码

+ ^8 M+ R* {# E6 V

（续）5.4实验例程说明
5.4.2      实验二：任务切换设计（时间片调度不带浮点）

实验目的：

        1.  学习PendSV和简易时间片调度的设计，对于初学者，此程序理解起来比较的难些，有不懂的地方一定要多读几遍，或者查阅相关的资料进行学习，我也争取给大家解释清楚。

实验内容：

        1.工程中创建了四个LED闪烁的任务，并设置嘀嗒定时器中断频率是1ms。

        2. 实现一个简单的时间片调度，每1ms进入嘀嗒定时器后更改要执行的任务并使能PendSV中断，这样退出嘀嗒定时器中断后就能进入PendSV中断实现任务的切换。

实验现象：

        1.    四个LED按照不同的频率进行闪烁。

        2.    请用USB转串口线连接PC机和开发板。PC机上运行SecureCRT软件，波特率设置为115200bps，无硬件流控。从PC机的软件界面观察程序执行结果：

如果程序进入硬件异常会打印如下的效果：

6 |! E0 ~; r  ]/ l. Z3 P1 q+ S

程序设计：

本程序主要分为五个部分：

    Ø  任务堆栈，PSP初始化

    Ø  嘀嗒定时器中断

    Ø  PendSV中断

    Ø  硬件异常

    Ø  四个任务和主程序

1.    任务堆栈，PSP初始化

        下表是第一次任务切换前，16个寄存器的存储顺序，由上向下地址递减。同时注意以下三点：

     Ø  执行第一个任务时PSP是指向任务的栈顶，后面三个任务第一次执行都是下面初始化时设置的位置。  

     Ø  堆栈空间是采用的双字的堆栈对齐方式，这个在前面5.1.1小节有说明，当然也可以将双字堆栈模式关闭。

     Ø  Task0任务要放在这个函数里面，要不出现硬件异常，造成这个问题的原因就在于从主堆栈指针MSP切换到进程堆栈指针PSP。在main函数中调用子函数OS_Start后部分寄存器会入栈，如果在这个子程序中做堆栈指针切换，退出的时候是用的PSP而不是MSP，用MSP入栈的寄存器数据将无法返回，从而造成失败。

1. /* 字访问 */
   ' ?1 Z$ f& y% P) ?
2. #define HW32_REG(ADDRESS)  (*((volatile unsigned long  *)(ADDRESS)))
   2 u  j+ s! l4 `2 k. q0 g
3. /* 当检测到错误时，用Breakpoint来停止任务(MDK特有的)*/
   3 f, ~4 S$ l& ~& V- c1 ^- D2 S. V5 v
4. /* 根据需要可以改成用while(1)来实现 */
   ) W9 B" x- s5 d, W
5. #define stop_cpu   __breakpoint(0)
   
6. 
   . D3 L. T$ b; O) D! R
7. /* 4个任务 */
   
8. void task0(void);      
   3 t/ I: a2 i+ l6 m6 z# s; B: U9 J
9. void task1(void);   
   
10. void task2(void);     
    
11. void task3(void);     
    1 n8 p. K. U" M5 Z1 P: H) l. _+ ~
12. void HardFault_Handler_C(unsigned int * svc_args);
    
13. 
    ( t+ |& o' u/ p, w
14. // 计数，用于切换任务
    
15. volatile uint32_t systick_count=0;
    7 H5 B2 z* s3 U/ \3 I
16. // 任务堆栈 (8Kbytes each - 1024 x 8 bytes) 这里也可以采用4字节，并将双字的堆栈对齐方式关闭
    
17. uint32_t task0_stack[1024], task1_stack[1024], task2_stack[1024], task3_stack[1024];
    ; i) _. C; z9 ^6 b& R: _; _
18. 
    
19. // 任务切换用到的数据
    
20. uint32_t  curr_task=0;     // 当前执行任务
    
21. uint32_t  next_task=1;     // 下一个任务
    
22. uint32_t  PSP_array[4];    // 用于在任务切换时记录PSP
    
23. 
    
24. /*
    * }3 a0 {: E" S  p
25. *********************************************************************************************************
    
26. *    函 数 名: OS_Start
    8 {6 K  ]# M5 h8 o8 t( d5 X
27. *    功能说明: 任务启动
    
28. *    形    参：无
    ; x2 N& g8 N5 M1 f1 w
29. *    返 回 值: 无         
    
30. *********************************************************************************************************
    
31. */
    
32. void OS_Start(void)
    0 w  ~5 V5 _5 X( O" H4 W) C' L
33. {
    5 y+ d) Q- o0 |4 n( l
34.      /* 创建任务0的堆栈 */
    ; K: H  e1 R7 ]: P
35.      PSP_array[0] = ((unsigned int) task0_stack) + (sizeof task0_stack) - 16*4;
    + m4 S( p% x$ ^- z! w( c& c
36.      HW32_REG((PSP_array[0] + (14<<2))) = (unsigned long) task0; /* PC */
    . q: a- K+ j+ g/ ~$ q# r
37.      HW32_REG((PSP_array[0] + (15<<2))) = 0x01000000;            /* xPSR */
    
38.         
    9 @2 R# Q2 P; e1 K. U4 U/ A. p$ Q
39.      /* 创建任务1的堆栈 */
    7 i: Q7 s+ q0 B, O  A; u, E! O7 C
40.      PSP_array[1] = ((unsigned int) task1_stack) + (sizeof task1_stack) - 16*4;
    ! v7 I5 y/ d1 Y5 p5 H. ^# [! m
41.      HW32_REG((PSP_array[1] + (14<<2))) = (unsigned long) task1; /* PC */
    
42.      HW32_REG((PSP_array[1] + (15<<2))) = 0x01000000;            /* xPSR */
    
43. 
    ! k  P1 J! q8 G3 r
44.      /* 创建任务2的堆栈 */
    / _+ s/ U; C$ F* e3 t1 F( _* @
45.      PSP_array[2] = ((unsigned int) task2_stack) + (sizeof task2_stack) - 16*4;
    3 k% j+ q1 Z4 p$ T: |! J: E8 H: T
46.      HW32_REG((PSP_array[2] + (14<<2))) = (unsigned long) task2; /* PC */
    
47.      HW32_REG((PSP_array[2] + (15<<2))) = 0x01000000;            /* xPSR */
    
48. 
    
49.      /* 创建任务3的堆栈 */
    
50.      PSP_array[3] = ((unsigned int) task3_stack) + (sizeof task3_stack) - 16*4;
    3 e; [1 W9 A$ g9 o6 a/ z: S" j' J
51.      HW32_REG((PSP_array[3] + (14<<2))) = (unsigned long) task3; /* PC */
    , @$ Q1 H; j; o5 O- i
52.      HW32_REG((PSP_array[3] + (15<<2))) = 0x01000000;            /* xPSR */
    2 {0 o) ]4 u9 B  h! u
53.    
    4 ]' j( ^) R. {' t' P
54.      /* 任务0先执行 */
    # C% W8 X  P! p" V* Y
55.      curr_task = 0;
    
56.       
    
57.      /* 设置PSP指向任务0堆栈的栈顶 */
    ) F3 b: c! {1 c, g+ r1 D
58.      __set_PSP((PSP_array[curr_task] + 16*4));
    
59.    
    
60.      /* 设置PendSV中断为最低优先级中断 */
    
61.      NVIC_SetPriority(PendSV_IRQn, 0xFF);
    
62.    
    7 }; B2 H/ D8 a
63.      /* 设置嘀嗒定时器的中断时1ms */
    ' l, f) |/ H6 [( O* e
64.      SysTick_Config(SystemCoreClock / 1000);
    
65.    
    - s# {; k/ y: u- G3 H5 O
66.      /* 使用堆栈指针，非特权级状态 */
    4 E/ M, N8 a, i% B
67.      __set_CONTROL(0x3);
    . U; A4 T0 ?- W) K
68.    
    
69.      /* 改变CONTROL后执行ISB (architectural recommendation) */
    1 S; \& x+ R2 ~9 I: t% Q; ~* B- r
70.      __ISB();
    7 @+ |" e' U* d  M5 ^. }0 w) ?
71.    
    ! a" O& C! Q; g7 S
72.      /* 启动任务0 */
    
73.      task0();
    . r& k1 o4 s# B+ x% P' r# ]
74. }

复制代码

2.    嘀嗒定时器中断

    嘀嗒定时器中断服务程序主要实现时间片的调度的时标，每进入一次实现一次任务切换（实际切换时通过PendSV中断实现）。并使能PendSV中断。

1. /*
   
2. *********************************************************************************************************
   
3. *    函 数 名: SysTick_Handler
   ( N0 x5 E( w2 I5 @
4. *    功能说明: 嘀嗒定时器中断
   8 g& W+ I( z& ?) R5 F! X) i* [
5. *    形    参：无
   " |; d9 ^- f7 F% v
6. *    返 回 值: 无
   / S1 ?6 o: ~- q: a
7. *********************************************************************************************************
   
8. */
   
9. void SysTick_Handler(void)
   
10. {
    
11.      systick_count++;
    
12.    
    7 u2 l+ {7 J- C. ]0 V
13.      // 简单的 round robin 调度器，时间片是1ms
    
14.      // 每ms切换一次。
    ( x2 [# W2 c9 ]7 p7 t
15.      switch(curr_task)
    + m  m  J+ X* o$ K- x
16.      {
    % t+ s- V/ y9 P& D% J
17.          case 0:
    - _9 m7 B) [3 I( b6 K; b7 B4 E
18.               next_task=1;
    
19.              break;
    8 u. W8 _9 h6 ^) C1 d6 \8 r' A+ Z
20.          case 1:
    ) I$ N" K6 Q- w
21.               next_task=2;
    : m" A: ~) s3 H5 Q8 r" s: @
22.              break;
    
23.          case 2:
    
24.               next_task=3;
    
25.              break;
    " B% p; l) b6 H) P) N% {! Z# Z5 {
26.          case 3:
    
27.               next_task=0;
    + `8 _/ [; m& }7 Z0 Q
28.              break;
    3 S& h3 C* z, H: Q7 X8 @' q3 C
29.          default:
    " {9 Z  i, ^3 t
30.               next_task=0;
    % S: |9 z; U( Z4 ?0 o
31.               printf("ERROR:curr_task = %x\n", curr_task);
    
32.               stop_cpu;
    
33.               break; // 程序不该运行到这里
    : c5 \  r% n* ^0 u6 H" n  B2 @
34.      }
    / Z# O. O) @& x& O) o( ?0 l1 u
35.      if (curr_task!=next_task)
    
36.      {
    
37.          SCB->ICSR |= SCB_ICSR_PENDSVSET_Msk; // Set PendSV to pending
    - M- i" @$ D# }) j) D& h
38.      }
    8 u% W9 R9 e( C8 I% B2 a) \
39. 
    
40. }

复制代码

( g- T$ \3 F& y

7 R7 a, |3 [7 o0 i（续）5.4.2 实验二：任务切换设计（时间片调度不带浮点）

3.     PendSV中断

        PendSV中断是实现任务切换的关键，主要作用是保存当前任务的寄存器内容到任务堆栈中，并从一个任务的堆栈中恢复这个任务的寄存器内容。这里大家要着重的学习以下两个汇编指令：

    STMDB.W  Rd!, {寄存器列表}  存储多个字到Rd处。每存一个字前Rd自减一次，32位宽度。

    LDMDB.W  Rd!, {寄存器列表}  从Rd处读取多个字，并依次送到寄存器列表中的寄存器。每读一个字前Rd自减一次，32位宽度

        如果Rd是R13（即SP），则与 POP/PUSH指令等效。(LDMIA->POP, STMDB ->PUSH)

    STMDB  SP!, {R0-R3, LR} 等效于 PUSH {R0-R3, LR}

    LDMIA  SP!, {R0-R3, PC} 等效于 PUSH {R0-R3, PC}

        Rd后面的“！”是什么意思？它表示要自增(Increment)或自减（Decrement）基址寄存器Rd的值，时机是在每次访问前(Before)或访问后(After)。增/减单位：字（4字节）。例如，记R8=0x8000，则下面两条指令：

    STMIA.WR8!,  {r0-R3} ;  R8值变为0x8010，每存一次增一次，先存储后自增

    STMDB.W R8,   {R0-R3} ; R8值的“一个内部复本”先自减后再存储数据，但R8的值不变

        感叹号还可以用于单一加载与存储指令——LDR/STR。这也就是所谓的 “带预索引”(Pre-indexing)的LDR和STR。例如：

     LDR.W  R0,  [R1,   #20]!    ;预索引

         该指令先把地址R1+offset处的值加载到R0，然后，R1 = R1+ 20（offset也可以是负数）。这里的“！”就是指在传送后更新基址寄存器R1的值。“！”是可选的。如果没有“！”，则该指令就是普通的带偏移量加载指令，不会自动调整R0的值。带预索引的数据传送可以用在多种数据类型上，并且既可用于加载，又可用于存储。

1. /*
   + a& b5 l8 C7 I% {4 p! S
2. *********************************************************************************************************
   ) y3 G5 W! K& e8 `, U
3. *    函 数 名: PendSV_Handler
   
4. *    功能说明: 任务切换的实现，这里特别的注意一点：
   / ~0 f" I8 c2 Z0 u5 ^4 s
5. *             当前任务的16个寄存器全部保存后，PSP指向最后一个寄存器。
   
6. *    形    参：无
   8 K2 C1 D: I: e: [) v
7. *    返 回 值: 无
   7 W9 I. Y# f: ]( S6 v  h9 V
8. *********************************************************************************************************
   
9. */
   
10. __asm void PendSV_Handler(void)
    : k0 @; b- {0 N' Y
11. {
    2 v9 a1 Y' `, p
12.      // 保存当前任务的内容
    0 j/ ^" V) W3 j/ [, {9 T
13.      MRS    R0, PSP     // 得到PSP  R0 = PSP
      s9 V1 b4 a  J6 ^7 n4 U
14.                         // xPSR, PC, LR, R12, R0-R3已自动保存
    
15.      STMDB  R0!,{R4-R11}// 保存R4-R11共8个寄存器得到当前任务堆栈
    5 ]2 ^9 a. K! W3 e4 s0 O
16.      LDR    R1,=__cpp(&curr_task)
    8 e# G) o$ m) i9 C5 k
17.      LDR    R2,[R1]     // 得到任务ID
    
18.      LDR    R3,=__cpp(&PSP_array)
      z" ^3 U* \2 q' S/ W) ~
19.      STR    R0,[R3, R2, LSL #2] // 保存PSP到相应的PSP_array中 R0 = [R3 + R2 << 2]
    - b8 M3 J) R8 |' Q' I
20.                                // 左移两位是因为PSP_array是4字节的数组。
    
21.    
    : P" z" J+ P% k) m* p) W
22.      // 加载下一个任务的内容
    # H. C8 G$ p: H# M" T2 b, [2 S, c
23.      LDR    R4,=__cpp(&next_task)
    
24.      LDR    R4,[R4]     // 得到下一个任务的ID
    # j' f& @/ _9 G! v! s
25.      STR    R4,[R1]     // 设置 curr_task = next_task
    6 t1 _; [( O9 s: D3 \
26.      LDR    R0,[R3, R4, LSL #2] // 从PSP_array中获取PSP的值
    : N: H# ^5 H* B9 q
27.      LDMIA  R0!,{R4-R11}// 将任务堆栈中的数值加载到R4-R11中
    
28.      MSR    PSP, R0     // 设置PSP指向此任务
    3 p2 a# ?! z$ {0 i7 T
29.      BX     LR          // 返回
    # f. \1 N6 r; f1 N
30.                        // xPSR, PC, LR, R12, R0-R3会自动的恢复
    
31.      ALIGN  4
    # C! N) m$ j' t9 e9 T
32. }

复制代码

4.    硬件异常

1. /*
   % A0 C: d3 Y! X8 V0 Q
2. *********************************************************************************************************
   7 A+ d+ _4 W& z, t
3. *    函 数 名: HardFault_Handler
   
4. *    功能说明: 硬件故障中断服务程序
   2 ?* v! h: p- p& K
5. *    形    参：无
   
6. *    返 回 值: 无
   & P! l% `5 y5 l& E6 b% {; ]) Q
7. *********************************************************************************************************
   8 X# B; m+ m/ r. n2 C4 F0 k
8. */
   
9. __asm void HardFault_Handler(void)
   , E, i2 ]: ^) N3 h9 Y6 h. J! N7 k- U# @# {
10. {
    
11.      TST    LR, #4
    
12.      ITE    EQ
    + j" q) b" R$ p4 B6 k
13.      MRSEQ  R0, MSP
    
14.      MRSNE  R0, PSP
    
15.      B      __cpp(HardFault_Handler_C)
    + A1 C# C6 _) R2 v5 V
16. }   
    1 c9 J1 E3 _+ s9 Y% ]) N3 a, Z3 [" K
17. 
    
18. /*
    
19. *********************************************************************************************************
    1 |. B5 o' y; ~: G( P
20. *    函 数 名: HardFault_Handler_C
    / Y' L, J: G) A3 _) L! z% T; }
21. *    功能说明: 进入硬件异常后，打印相关变量
    
22. *    形    参：无
    
23. *    返 回 值: 无
    
24. *********************************************************************************************************
    ( P/ m5 C  \( ]3 }. i% K
25. */
    
26. void HardFault_Handler_C(unsigned int * svc_args)
    * Y$ D4 }# @0 m0 N8 Z' ^; E
27. {
    1 @0 M$ E, R' a
28.      puts("程序进入HardFault\r\n");
    & d. _4 a9 I( {4 p- {! d' Q
29.      printf ("curr_task = %d\r\n", curr_task);
    , V; m* f7 d; U8 |1 I/ f& D/ X
30.      printf ("next_task = %d\r\n", next_task);
    " f$ d9 Y9 n# g. d9 h/ ]
31.      printf ("PSP #0 = %x\r\n", PSP_array[0]);
    
32.      printf ("PSP #1 = %x\r\n", PSP_array[1]);
    
33.      printf ("PSP #2 = %x\r\n", PSP_array[2]);
    + o5 I2 ], l6 ?  Z8 c2 m
34.      printf ("PSP #3 = %x\r\n", PSP_array[3]);
      |$ z8 \% f* O/ u
35.      printf ("Stacked PC = %x\r\n", svc_args[6]);
    " ^$ m0 {# T( v3 l2 r( X" K9 d
36.      stop_cpu;
    
37. }

复制代码

5.    四个任务和主程序

1. /*
   7 s$ P. T) U0 K2 \# r
2. *********************************************************************************************************
   
3. *    函 数 名: main
   6 m7 C/ a" t- [, ^# c# A2 v7 U- O
4. *    功能说明: c程序入口
   
5. *    形    参：无
   & ^# `8 j1 a5 i( R" E' Q5 `
6. *    返 回 值: 错误代码(无需处理)
   
7. *********************************************************************************************************
   
8. */
   
9. int main(void)
   ' t2 G( B6 Z' k9 D0 \+ N
10. {
    
11.      /* (在Cortex-M3 r1p1中需要开启，Cortex-M3 r2px 和 Cortex-M4是默认开启的) */
    0 b( `; X* s0 ]
12.      SCB->CCR |= SCB_CCR_STKALIGN_Msk; /* 使能双字的堆栈对齐方式 */
    
13.    
    
14.      bsp_Init();            /* 硬件初始化 */
    
15.    
    
16.      PrintfLogo();     /* 打印例程信息到串口1 */
    9 u5 n8 I" x; H( [
17.    
    
18.      OS_Start();  
    
19. 
    7 P3 A& _9 t/ @3 I( L0 ~
20.      /* 进入主程序循环体, 进入这里的话说明程序出错 */
    ! M5 F% r8 K# D; p
21.      while (1)
    * ]( Y. W$ Z% S
22.      {
    4 A- v( G3 k6 m1 U3 A$ z
23.          stop_cpu;
    
24.      }
    * j, x0 V: j" P3 b
25. }
    " D+ ~" }' m, ]% n% m0 l
26. 
    + R* p- l% E- x( Q" F
27. /*
      t  o( T+ F# G: ?5 W/ L
28. *********************************************************************************************************
    
29. *    函 数 名: task0
    
30. *    功能说明: 任务0实现LED1的闪烁
    
31. *    形    参：无
    2 x9 Y1 a6 d+ N2 K+ ?, K$ [
32. *    返 回 值: 无
    ' g6 q; b5 `( {9 X2 t
33. *********************************************************************************************************
    3 Q0 Z" U" i2 U% k9 h- g7 }
34. */
    ) o' S% J  e5 O6 p2 C. r3 e
35. void task0(void)
    ! X! o1 E7 I" G( r8 F+ I
36. {
    
37.      while (1)
    ' j( J$ n+ [) }: K+ Q
38.      {
    
39.          if (systick_count & 0x80)
    1 S# Z6 j; |- G, O$ m4 u/ A
40.          {
    
41.               bsp_LedOn(1);
    
42.          }
    ) T) x, `% X! I/ K  S
43.          else                     
    ! ~" W3 D: t, ]+ v7 O, y$ ^
44.          {
    
45.               bsp_LedOff(1);
    6 ]: u$ g& m3 \0 z8 ?4 A1 w
46.          }
    & J+ h, W/ N# O( K. q) U9 g  w5 M1 j
47.      }
    8 Q; o' `9 b/ v" ~2 v
48. }
    ' k0 ?5 J) {4 {" A
49. 
    * {. s' J5 t2 ~7 L9 M2 b
50. /*
    & X7 [( e9 i; _5 G' }* u) \
51. *********************************************************************************************************
    . F+ X7 T8 O' D0 F) G
52. *    函 数 名: task1
    
53. *    功能说明: 任务1实现LED2的闪烁
    * D# i: V% {, L  G; h
54. *    形    参：无
    5 z) x+ S% `' U  Z3 X, M/ M
55. *    返 回 值: 无
    # z/ m5 N) t. y$ c
56. *********************************************************************************************************
    
57. */
    4 H' e/ B- v1 `0 c2 @" ^/ ]
58. void task1(void)
    4 O0 H% [/ [7 E( x
59. {
    
60.      while (1)
    ' s  N' }) A6 `4 D
61.      {
    " y, m$ N( I! p% t- O
62.          if (systick_count & 0x100)
    6 N' L4 G' e! |& K" k, D% `
63.          {
    8 g0 v/ u9 P4 P# {
64.               bsp_LedOn(2);
    
65.          }
    . q( l+ M; T9 ?5 P
66.          else                     
    , ^& y  S. w3 J" J, Y7 p
67.          {
    
68.               bsp_LedOff(2);
    
69.          }
    
70.      }
    % s6 ?6 `) O, [* h; p
71. }
    
72. 
    # B" d0 d. l# W! }$ @
73. /*
    % A+ F" n9 W: P9 ~
74. *********************************************************************************************************
    
75. *    函 数 名: task2
    
76. *    功能说明: 任务2实现LED2的闪烁
      B) d- b; A: G* v2 u
77. *    形    参：无
    + G; L3 o" P, [" w# t5 X
78. *    返 回 值: 无
    
79. *********************************************************************************************************
    
80. */
    + ?  E2 R( P7 s0 \5 D
81. void task2(void)
    
82. {
    
83.      while (1)
    
84.      {
    ( E; V5 s: F  n
85.          if (systick_count & 0x200)
    + P' `7 y- c% {2 V6 M& j
86.          {
    
87.               bsp_LedOn(3);
    
88.          }
    
89.          else                     
    3 P" g- X0 N; |5 p+ |0 Q) U
90.          {
    4 w; t$ u4 y( V2 i+ l
91.               bsp_LedOff(3);
    7 j( q% d# R  h' Y$ D8 z
92.          }
    
93.      }
    / ?9 O! e% E' L4 k/ R) w6 O
94. }
    0 r5 r+ }* f+ l% _; L4 Q
95. 
    
96. /*
    9 f0 B2 x6 Z$ X. I( C" y
97. *********************************************************************************************************
    ) w. a0 @6 J9 l0 h4 Z
98. *    函 数 名: task3
    : f3 L8 T, k, ]5 S
99. *    功能说明: 任务3实现LED4的闪烁
    
100. *    形    参：无
     * X1 ~' [" s  ^  ?4 \
101. *    返 回 值: 无
       S& q2 G5 V' ^7 v; @
102. *********************************************************************************************************
     
103. */
     ( |; }$ w1 |" W; g4 w
104. void task3(void)
     
105. {
     . ~  y9 d" y7 S% x
106.      while (1)
     
107.      {
     
108.          if (systick_count & 0x400)
     % _9 ?; d, V8 S# F8 I! ^$ T9 P
109.          {
     * x3 n. n7 [; T4 U2 v' a& ^/ K
110.               bsp_LedOn(4);
     * X5 Z4 |9 T; S0 P  ~8 f
111.          }
     & v5 _; m3 D8 }0 {, a
112.          else                     
     5 z* }/ @$ e4 A3 F8 J; [( U1 P
113.          {
     
114.               bsp_LedOff(4);
     ( h5 x2 z9 H+ y
115.          }
     
116.      }
     
117. }

复制代码

5.4.3      实验三：任务切换设计（时间片调度带浮点）

实验目的：

        1. 学习SVC,PendSV和简易时间片调度的设计

实验内容：

        1. 工程中创建了四个LED闪烁的任务，并设置嘀嗒定时器中断频率是1ms

        2.实现一个简单的时间片调度，每1ms进入嘀嗒定时器后更改要执行的任务并使能PendSV中断。这样退出嘀嗒定时器中断后就能进入PendSV中断实现任务的切换。

        3.任务0打印浮点运行的结果。

实验现象：

        1.    四个LED按照不同的频率进行闪烁。

        2.    请用USB转串口线连接PC机和开发板。PC机上运行SecureCRT软件，波特率设置为115200bps，无硬件流控。从PC机的软件界面观察程序执行结果：

* E% M9 I$ E# g& I" A

程序设计：

本程序主要分为五个部分：

Ø  主程序和四个创建的任务

Ø  SVC中断

Ø  PendSV中断

Ø  滴答定时器中断

Ø  硬件异常

1.     主程序和四个创建的任务

1. /* 字访问 */
   
2. #define HW32_REG(ADDRESS)  (*((volatile unsigned long  *)(ADDRESS)))
   
3. /* 当检测到错误时，用Breakpoint来停止任务(MDK特有的)*/
   
4. /* 根据需要可以改成用while(1)来实现 */
   
5. #define stop_cpu   __breakpoint(0)
   ( D  z: u  f* V2 x) o! b
6. 
   
7. /* 4个任务 */
   $ q& P7 \: o. ?( B' b
8. void task0(void);      
   7 ?" w9 B# E4 T( d
9. void task1(void);   
   & l" A$ d! p6 m6 i# P2 }
10. void task2(void);     
    # O- K9 o' F: }' Y+ o8 l  @3 _) T
11. void task3(void);     
    % ?) f: o$ C+ [6 [. A* s; r2 s9 J
12. void HardFault_Handler_C(unsigned int * svc_args);
    3 {3 f4 m2 h6 A- x- g  R
13. void SVC_Handler_C(unsigned int * svc_args);
    
14. void __svc(0x00) os_start(void); // OS 初始化
    ' p6 N; C+ `) `! Q; P  Z. Q# W
15. 
    
16. // 计数，用于切换任务
    ' e2 ?. C( O3 P' O! V& {
17. volatile uint32_t systick_count=0;
    ) e, X) Q* \; U: N6 Q: L( Y) p  g" u
18. // 任务堆栈 (8Kbytes each - 1024 x 8 bytes)，8字节对齐
    
19. long long task0_stack[1024], task1_stack[1024], task2_stack[1024], task3_stack[1024];
    * X5 ^! u1 G+ |' n+ k8 Y, _
20. 
    
21. // 任务切换用到的数据
    
22. uint32_t  curr_task=0;     // 当前执行任务
    ( c& w: N" ^$ _# t4 i
23. uint32_t  next_task=1;     // 下一个任务
    5 g! W6 s5 s0 X
24. uint32_t  PSP_array[4];    // 用于在任务切换时记录PSP
    ; V8 y' ?# [4 I% r! W; H
25. uint32_t  svc_exc_return;  // EXC_RETURN use by SVC
    1 j+ Z$ _' q% p5 W1 s
26. 
    9 M1 v8 M( x, P! P$ {
27. /* 仅允许本文件内调用的函数声明 */
    
28. static void PrintfLogo(void);
    
29. 
    
30. /*
    
31. *********************************************************************************************************
    
32. *    函 数 名: main
    2 S  n) j' p/ L- j4 t0 c' V" t
33. *    功能说明: c程序入口
    
34. *    形    参：无
    
35. *    返 回 值: 错误代码(无需处理)
      T/ ~6 Z0 i7 i$ \8 P
36. *********************************************************************************************************
    
37. */
    9 w5 u. b5 A" j2 C: ?! o+ }
38. int main(void)
    
39. {
      m: F7 L; [' \
40.      bsp_Init();            /* 硬件初始化 */
    
41.    
    5 H. B1 C4 C8 p. y6 k! f
42.      PrintfLogo();     /* 打印例程信息到串口1 */
    
43.    
    
44.      os_start();   
    / m. w0 X: Y. C0 J; q/ o
45. 
    
46.      /* 进入主程序循环体 */
    3 {/ u: ^* l" k* h0 i+ X$ p( Y+ j
47.      while (1)
    
48.      {
    & _- o* ^/ V2 X$ S1 \
49.          stop_cpu;
    
50.      }
    8 M1 d1 S& u- i9 T0 v+ j, K' n
51. }
    
52. 
    
53. /*
    
54. *********************************************************************************************************
    
55. *    函 数 名: task0
    ; J) M6 C1 K! f3 e
56. *    功能说明: 任务0实现LED1的闪烁
    0 T/ I/ @0 O/ W- _: m) ]6 C2 \$ c
57. *    形    参：无
    - n' k& \' `5 E: k4 H- @! a# Q
58. *    返 回 值: 无
    ' Q' I5 I% h. b# D8 I  P6 v
59. *********************************************************************************************************
    ( |+ |* W* X6 Y* k5 O4 s
60. */
    
61. void task0(void)
    $ X2 N+ P/ j( |! Q4 K+ Q
62. {
    
63.      float Temp = 1.111111f;
    
64.    
    
65.      while (1)
    
66.      {
    9 ]$ t* M6 e# d1 T+ E
67.          if (systick_count & 0x80)
    
68.          {
      b" P/ T' C- N9 }: L( M- P
69.               bsp_LedOn(1);
    
70.               Temp = Temp + 0.000001f;
    
71.               printf("Temp = %f\r\n", Temp);
    % @: b) n" i, F! m, e
72.          }
    7 F5 f. \6 [8 w7 e  o. m$ O
73.          else                     
    ( m" E/ z/ U4 o8 [) B$ L
74.          {
    
75.               bsp_LedOff(1);
    
76.          }
    5 B! O2 J0 @! A, D' V) W( M
77.      };
    
78. }
    + v0 N+ _5 {4 W9 l/ @
79. 
    2 Z+ P8 H' r' G, g6 y5 C. ^" Z
80. /*
    8 c" m- ^5 u! z0 W  F* z
81. *********************************************************************************************************
    
82. *    函 数 名: task1
      j" \+ o7 m# d: s$ A
83. *    功能说明: 任务1实现LED2的闪烁
    0 h: c+ i8 Y8 ~' R! g9 R
84. *    形    参：无
    / }: \" F/ J; ]" r
85. *    返 回 值: 无
    
86. *********************************************************************************************************
    . j5 @. C0 B- t* Y% t$ |
87. */
    * h5 q, g% @1 ]1 C  i
88. void task1(void)
    
89. {
    
90.      while (1)
    9 E9 v; |% O  F& s. e
91.      {
    
92.          if (systick_count & 0x100)
    0 n" z% P$ C: R; f3 ]0 S6 [: B. p
93.          {
    / i: z3 r0 V$ N. N
94.               bsp_LedOn(2);
    % e9 m3 e+ ^0 E; S
95.          }
    6 b; @" x, |+ \
96.          else                     
    
97.          {
    ) a! w4 y4 i0 Q; Q
98.               bsp_LedOff(2);
    2 d) I4 C  o9 r+ ?! p5 m2 T
99.          }
    
100.      };
     
101. }
     
102. 
     * t: h; K8 J/ S* y+ r8 U, S
103. /*
     
104. *********************************************************************************************************
     
105. *    函 数 名: task2
     ' K3 J" W4 h# v+ h: Z  J
106. *    功能说明: 任务2实现LED2的闪烁
     
107. *    形    参：无
     
108. *    返 回 值: 无
     / f9 o; O7 S, ~1 a; N9 _
109. *********************************************************************************************************
     * p9 Y2 ]# [7 Z4 Y/ ~
110. */
     
111. void task2(void)
     
112. {
     
113.      while (1)
     
114.      {
     
115.          if (systick_count & 0x200)
     
116.          {
     
117.               bsp_LedOn(3);
     1 \9 y5 N2 m$ M9 [( f1 g
118.          }
     
119.          else                     
     5 I3 ^- s5 |. d2 a+ S- k2 H/ _
120.          {
     
121.               bsp_LedOff(3);
     . V; G, t/ R7 b. P$ [& u" X, S) n% |
122.          }
     
123.      };
     
124. }
     
125. 
     0 P; r* ]2 A4 W' B% j+ x
126. /*
     
127. *********************************************************************************************************
     
128. *    函 数 名: task3
     & B3 O. p4 F( p; {. `+ C
129. *    功能说明: 任务3实现LED4的闪烁
     
130. *    形    参：无
     ! C+ x7 V2 F1 S& v
131. *    返 回 值: 无
     ) j; C( Q* c) G8 c) S7 n0 G
132. *********************************************************************************************************
     6 L9 p4 t0 {+ K6 P
133. */
     
134. void task3(void)
     
135. {
     
136.      while (1)
     
137.      {
     
138.          if (systick_count & 0x400)
       P( ], q" g5 ]+ g" w
139.          {
     
140.               bsp_LedOn(4);
     
141.          }
     
142.          else                     
     
143.          {
     
144.               bsp_LedOff(4);
     4 b" A4 I+ D+ q# y0 f; H
145.          }
     
146.      };
     
147. }

复制代码

（续）5.4.3  实验三：任务切换设计（时间片调度带浮点）

2.     SVC中断

        任务堆栈的创建是在SVC中断中实现的。这个过程可以用下面的图来表示：

        寄存器在堆栈中的存储顺序和实验二是一样的，只是多了EXC_RETURN和CONTROL。

1. /*
   0 x* c/ Q# N, f5 R8 l( q
2. *********************************************************************************************************
   / V  q3 \  F! z+ Q
3. * 函 数 名: SVC_Handler
   / \- K# N* z/ \; G, u& S& d
4. * 功能说明: SVC异常中断服务程序
   
5. * 形 参：无
   5 g: o9 s/ L0 Q: H
6. * 返 回 值: 无
   
7. *********************************************************************************************************
   " u+ X4 J  l& d# C: l
8. */
   % i, T4 x9 e, G' a, U; Z
9. __asm void SVC_Handler(void)
   2 u# F5 I8 m6 ^& d$ y) u: R
10. {
    
11. TST LR, #4 // 获取使用的MSP还是PSP
    
12. ITE EQ
    2 P$ Y  _. g  V2 K3 C' j) w
13. MRSEQ R0, MSP
    
14. MRSNE R0, PSP
    
15. LDR R1, =__cpp(&svc_exc_return) // 保存当前 EXC_RETURN
    
16. STR LR, [R1]
    / D5 u0 `* B( D9 g; I
17. BL __cpp(SVC_Handler_C) // 运行 SVC_Handler 的C程序
    
18. LDR R1, =__cpp(&svc_exc_return) // 加载新的 EXC_RETURN
    
19. LDR LR, [R1]
    6 {& \8 b$ q6 A  m
20. BX LR
      Z9 d& T/ S+ n: p/ v- X3 }1 i5 s
21. ALIGN 4
    
22. }
    
23. 
    ' q0 j8 p& T* \5 {
24. /*
    
25. *********************************************************************************************************
    & p# X$ z% E, m/ V  T
26. * 函 数 名: SVC_Handler_C
    
27. * 功能说明: 在SVC异常中运行的C代码
    
28. * 形 参：无
    
29. * 返 回 值: 无*********************************************************************************************************
    
30. */
    
31. void SVC_Handler_C(unsigned int * svc_args)
    
32. {
    7 ^& Q& [) E; s2 Q) q( ?9 T- m
33. uint8_t svc_number;
    
34. svc_number = ((char *) svc_args[6])[-2]; // Memory[(Stacked PC)-2]
    . C  B  t$ Y1 Z0 S9 u
35. switch(svc_number)
    
36. {
    
37. /* 开始任务调度 */
    
38. case (0):
    5 W. u& ?* @+ c6 E( [. i
39. 
    
40. /* 创建任务0的堆栈 */
    + q9 }- X9 b7 c7 Q2 r& c$ _
41. PSP_array[0] = ((unsigned int) task0_stack) + (sizeof task0_stack) - 18*4;
    ( _$ A: S4 S( |" A0 p5 C
42. HW32_REG((PSP_array[0] + (16<<2))) = (unsigned long) task0; // 初始化PC
    
43. HW32_REG((PSP_array[0] + (17<<2))) = 0x01000000; // 初始化 xPSR
    
44. HW32_REG((PSP_array[0] )) = 0xFFFFFFFDUL; // 初始化 EXC_RETURN
    
45. HW32_REG((PSP_array[0] + ( 1<<2))) = 0x3;// 初始化 CONTROL : unprivileged, PSP, no FP
    
46. 
    - R0 q& V- A2 k
47. /* 创建任务1的堆栈 */
    
48. PSP_array[1] = ((unsigned int) task1_stack) + (sizeof task1_stack) - 18*4;
    
49. HW32_REG((PSP_array[1] + (16<<2))) = (unsigned long) task1; // 初始化 Program Counter
    & t; ?3 }' Z% \3 G
50. HW32_REG((PSP_array[1] + (17<<2))) = 0x01000000; // 初始化 xPSR
    1 B0 C( p0 a# |% z& r
51. HW32_REG((PSP_array[1] )) = 0xFFFFFFFDUL; // 初始化 EXC_RETURN
    
52. HW32_REG((PSP_array[1] + ( 1<<2))) = 0x3;// 初始化 CONTROL : unprivileged, PSP, no FP
    7 ~, r. s6 u5 p* B
53. 
    
54. /* 创建任务2的堆栈 */
    
55. PSP_array[2] = ((unsigned int) task2_stack) + (sizeof task2_stack) - 18*4;
    9 t, ?% q8 E( e6 B7 u
56. HW32_REG((PSP_array[2] + (16<<2))) = (unsigned long) task2; // 初始化 Program Counter
    
57. HW32_REG((PSP_array[2] + (17<<2))) = 0x01000000; // 初始化 xPSR
    : @# t* ]/ f1 C( z+ E
58. HW32_REG((PSP_array[2] )) = 0xFFFFFFFDUL; // 初始化 EXC_RETURN
    
59. HW32_REG((PSP_array[2] + ( 1<<2))) = 0x3;// 初始化 CONTROL : unprivileged, PSP, no FP
    5 K( I/ W' I8 S) |4 ?% n5 i
60. 
    ! D! @: M! A6 f5 o4 k
61. /* 创建任务3的堆栈 */
      ^) A6 o: m6 b2 w9 e  ], \/ z9 Z
62. PSP_array[3] = ((unsigned int) task3_stack) + (sizeof task3_stack) - 18*4;
    
63. HW32_REG((PSP_array[3] + (16<<2))) = (unsigned long) task3; // 初始化 Program Counter
    
64. HW32_REG((PSP_array[3] + (17<<2))) = 0x01000000; // 初始化 xPSR
    " i2 a; s% Q! `2 `: C+ |
65. HW32_REG((PSP_array[3] )) = 0xFFFFFFFDUL; // 初始化 EXC_RETURN
    
66. HW32_REG((PSP_array[3] + ( 1<<2))) = 0x3;// 初始化 CONTROL : unprivileged, PSP, no FP
    
67. 
    
68. curr_task = 0; // 切换到 task #0
    * j) J3 T( d+ N8 e2 v# h
69. svc_exc_return = HW32_REG((PSP_array[curr_task])); // 返回线程模式，PSP
    : i6 R0 B- O) n7 a; a$ t1 \
70. __set_PSP((PSP_array[curr_task] + 10*4)); // PSP = R0
    2 p8 P& S4 w- m8 `
71. NVIC_SetPriority(PendSV_IRQn, 0xFF); // 设置PSP为最低优先级
    
72. SysTick_Config(SystemCoreClock/1000);// 中断频率1000Hz
    
73. __set_CONTROL(0x3); // 切换到使用PSP,非特权级
    : j: p  v5 }1 r  M( a
74. __ISB();
    
75. break;
    
76. default:
    
77. puts ("ERROR: Unknown SVC service number");
    6 a3 G* ?0 Z7 B9 y1 ^- g
78. printf("- SVC number 0x%x\n", svc_number);
    . u8 t! m8 q7 \! q& Q
79. stop_cpu;
    . `  t3 G' v" f
80. break;
    
81. }
    " j( ^) \. A3 l4 p  A2 n
82. }

复制代码

* P  N! w6 [" a

（续）5.4.3  实验三：任务切换设计（时间片调度带浮点）

4.    滴答定时器中断

1. /*
   ( d/ W; \* ]( a, W' \6 t
2. *********************************************************************************************************
   $ ^  D5 L, S& t) c0 j2 e. v
3. *    函 数 名: SysTick_Handler
   
4. *    功能说明: 嘀嗒定时器中断
   7 l4 v4 H; U* J2 T( h
5. *    形    参：无
   
6. *    返 回 值: 无
   . P% s5 I* i, B6 {2 Q% R$ r$ `0 C
7. *********************************************************************************************************
   
8. */
   + p) H- L8 q  ^
9. void SysTick_Handler(void)
   
10. {
    
11.      systick_count++;
    
12.    
    + R1 W' t8 v/ J8 }+ z: h3 J, [
13.      // 简单的 round robin 调度器，时间片是1ms
    : W9 p/ I) p  ^
14.      // 每ms切换一次。
    
15.      switch(curr_task)
    
16.      {
    ; H9 ?- P: @* _
17.          case 0:
    " h) u0 Q; T' f1 L) v# w2 q
18.               next_task=1;
    
19.              break;
    5 P& [, T/ w, p/ R6 |( f
20.          case 1:
    
21.               next_task=2;
    
22.              break;
    
23.          case 2:
    
24.               next_task=3;
    & B* V  r. U0 S" q
25.              break;
    
26.          case 3:
    ! X& X- b9 v: @  N
27.               next_task=0;
    9 e: s0 x) v# ?& n$ u; m, w+ z1 `1 x
28.              break;
    
29.          default:
    ) k5 N3 e/ S: u! f3 [, R
30.               next_task=0;
    
31.               printf("ERROR:curr_task = %x\n", curr_task);
    
32.               stop_cpu;
    
33.               break; // 程序不该运行到这里
    
34.      }
    ( y. f; C  ?7 t9 |& e# R8 B
35.      if (curr_task!=next_task)
    
36.      {
    
37.          SCB->ICSR |= SCB_ICSR_PENDSVSET_Msk; // Set PendSV to pending
    : e9 d& d6 V' P6 a2 x6 R
38.      }
    9 H  h& p5 E6 t, O
39. }

复制代码

5.    硬件异常

1. /*
   ' ]+ f# y0 }! K; l
2. *********************************************************************************************************
   & z7 B) W$ N; H6 s# Y5 r+ V
3. *    函 数 名: HardFault_Handler
   : E6 ]9 i  @4 C' p
4. *    功能说明: 硬件故障中断服务程序
   
5. *    形    参：无
   # X1 C" }" x3 n8 G, a
6. *    返 回 值: 无
   8 |8 J: o/ K9 D" u$ u. A% h5 @
7. *********************************************************************************************************
   
8. */
   
9. __asm void HardFault_Handler(void)
   
10. {
    / L* ?7 }: p0 S" r
11.      TST    LR, #4
    
12.      ITE    EQ
    
13.      MRSEQ  R0, MSP
    
14.      MRSNE  R0, PSP
    # a% c: l4 I1 f! Q2 F6 F
15.      B      __cpp(HardFault_Handler_C)
    
16. }   
    
17. 
    
18. /*
    ' G+ e/ d) c. @0 z
19. *********************************************************************************************************
    8 o9 i0 [& W1 |% @
20. *    函 数 名: HardFault_Handler_C
    3 T5 b( G/ w. z4 x
21. *    功能说明: 进入硬件异常后，打印相关变量
    
22. *    形    参：无
    
23. *    返 回 值: 无
    
24. *********************************************************************************************************
    
25. */
    
26. void HardFault_Handler_C(unsigned int * svc_args)
    ( t) }! ^# R$ G5 D+ T2 S1 ~
27. {
    # Q- _* n1 d8 e. i* V
28.      puts("[HardFault]");
    
29.      printf ("curr_task = %d\n", curr_task);
    0 t- V& |, {: |3 F
30.      printf ("next_task = %d\n", next_task);
    
31.      printf ("PSP #0 = %x\n", PSP_array[0]);
    
32.      printf ("PSP #1 = %x\n", PSP_array[1]);
      B* l% N: W# O( N" f5 r9 u
33.      printf ("PSP #2 = %x\n", PSP_array[2]);
    5 v# c$ g5 V$ v- T
34.      printf ("PSP #3 = %x\n", PSP_array[3]);
    3 _& F" P  _; _: O8 R4 N0 b& ~
35.      printf ("Stacked PC = %x\n", svc_args[6]);
    
36.      stop_cpu;
    
37. }

复制代码

5.5  实验总结

    本期教程相对于前面几期要难一些，需要多花点时间去学习，掌握好了，后面学习μCOS-III事半功倍。

  F' E& C4 U* k% T
: ~6 l" V4 F* G: V

参考资料：

1.    Patterns fortime-triggered embedded systems英文版和中文版

2.    Cortex-M3权威指南中文版

3.    TheDefinitive Guide to Arm Cortex-M3 and Cortex-M4 Processors（M4权威指南）