特别说明：
8 y" ]8 m) n% R% ~1.  本教程是安富莱电子原创。
2.  安富莱STM32F407开发板资料已经全部开源，开源地址：地址链接
3 s' Q! d7 ^" P3.  当前共配套300多个实例，4套用户手册。

( c' y3 ~5 f3 z3 w/ j. c

第4章  Cortex-M处理器的OS特性

    本期教程带领大家学习Cortex-M处理器的OS特性，主要是M3和M4，M4和M3反应在RTOS上，主要区别是M4多了一个浮点单元，用户可以根据需要选择是否使用浮点单元。本期教程主要学CM内核的操作模式，特权等级和双堆栈机制。这部分知识学习起来比较的枯燥，但是作为初学者一定要将本期教程认真的多看几遍，有兴趣继续学的，还需上ARM的官网多找些相关的资料进行学习，可以这么说，这部分知识直接关系着你对一款RTOS的认识程度。

    4.1 内核的OS特性

    4.2 寄存器组

    4.3 操作模式和特权等级

    4.4 双堆栈机制

    4.5 内核相关的API函数

    4.6 总结

4.1  内核的OS特性

    为了更好的支持RTOS的运行，Cortex-M系列处理器在这方面做出了很多的努力。当前至少有30多款RTOS支持Cortex-M系列处理器，这个数量还在增 加，下面总结了几条ARM公司为了使Cortex-M系列处理器更好的支持RTOS运行所做的努力：

   l  双堆栈指针：MSP指针用于OS内核和中断，PSP指针用于任务。

   l  SysTick定时器：可以很方便的用于OS的时钟节拍，嘀嗒定时器在第10章：SysTick实验有详细的讲解。

   l  SVC和PendSV异常：实现RTOS，这两个异常是必须的，特别是任务切换的实现。

   l  非特权级执行模式：程序运行在非特权级模式可以限制应用任务的访问权限，特权级模式和非特权级模式配合MPU（Memory Protection Unit 内存保护单元）可以有效的提高系统的鲁棒性。

l  独占式访问：独占式的存储和加载指令对于RTOS中的信号量和互斥操作的实现非常有用。

  l  另外，低的中断延迟（可以降低任务切换的开销）和指令的各种特性使得RTOS可以有效的工作。

    上面的这些特性对于提高RTOS的性能十分重要，当然，也不是每个RTOS都会用全这些特性，后面会跟大家具体的讲述，本期教程先把部分特性详细的讲解下。

4.2  寄存器组

        Cortex-M4/M3处理器拥有R0-R15的寄存器组。其中R13作为堆栈指针SP。SP有两个，但在同一时刻只能有一个可以看到，这也就是所谓的“banked”寄存器。

4.2.1      通用寄存器

        寄存器从R0到R12是通用寄存器。R0-R7被称作lowregisters，由于指令集有限的可用空间，很多的16位指令只能访问这些寄存器。R8-R12被称作high registers，这些寄存器可用于32位指令和部分的16位指令，比如MOV指令。R0-R12的初始值是不定的。

" N/ M+ e: _. Q( W/ N+ v4.2.2      堆栈指针寄存器

        Cortex-M3/M4拥有两个堆栈指针，然而它们是banked，因此任一时刻只能使用其中的一个，指针的切换通过特殊寄存器CONTROL实现。当引用R13（或写作SP）时，引用到的是当前正在使用的那一个，另一个必须用特殊的指令来访问（MRS,MSR指令）。这两个堆栈指针分别是：

  l  主堆栈指针（MSP）：这是缺省的堆栈指针，它由OS内核、异常服务例程以及所有需要特权访问的应用程序代码来使用。

  l  进程堆栈指针（PSP）：用于常规的应用程序代码（不处于异常服用例程中时）。

    说起堆栈指针就必须得说一下堆栈（在前面3.1.2小节有简单讲解和举例，后面会详细展开讨论），堆栈指针用于访问堆栈，并且PUSH指令和POP指令默认使用SP。在Cortex-M3/M4中，有专门的指令负责堆栈操作——PUSH和POP。它俩的汇编语言语法如下例所演示：

        PUSH {R0}    ; *(--R13)=R0。R13是long*的指针

        POP  {R0}    ; R0= *R13++

        请注意后面程序的注释，它诠释了所谓的“向下生长的满栈”（在本期教程后面讲到任务切换时还要展开论述），Cortex-M3/M4就是以这种方式使用堆栈的。因此，在PUSH新数据时，堆栈指针先减一个单元。通常在进入一个子程序后，第一件事就是把寄存器的值先PUSH入堆栈中，在子程序退出前再POP曾经PUSH的那些寄存器。另外，PUSH和POP还能一次操作多个寄存器，如下所示：

subroutine_1

PUSH   {R0-R7, R12,R14}    ; 保存寄存器列表

…                            ; 执行处理

POP {R0-R7, R12, R14}       ; 恢复寄存器列表

BX R14                      ; 返回到主调函数

        在程序中为了突出重点，可以一直把R13写作SP。在程序代码中，both MSP和PSP都被称为R13/SP。不过，我们可以通过MRS/MSR指令来指名道姓地访问具体的堆栈指针。MSP，亦 写作SP_main，这是复位后缺省使用堆栈指针，服务于操作系统内核和异常服务例程；而PSP，亦写作SP_process，典型地用于普通的用户线程中。

        寄存器的PUSH 和POP 操作永远都是4 字节对齐的——也就是说他们的地址必须是0x4,0x8,0xc,……。事实上，R13的最低两位被硬线连接到0,并且总是读出0（Read AsZero）。

        这里有两点大家要特别注意：

        Ø  大多数情况下的应用，只需使用指针MSP，而PSP多用于RTOS中。

        Ø  堆栈指针的最低两位永远是0，这意味着堆栈总是4字节对齐的。

4.2.3      连接寄存器

        R14也称作Link Register (LR)，当调用子程序或者函数时，这个函数用于保存返回地址。函数或者子程序结束时，程序将LR中的地址赋给PC返回到调用函数中。当调用子程序或者函数时，LR中的数值是自动更新的，如果此函数或者子程序嵌套调用其它函数或者子程序，需要保存LR中的数值到堆栈中，要不LR中的数值会由于函数调用而丢失。

        在中断服务程序中，LR中的数值自动更新给EXC_RETURN（(Exception Return），然后在中断服务程序的末尾触发异常返回。

        尽管Cortex-M处理器的返回地址是偶数（bit 0 = 0，因为指令需要半字对齐），LR的BIT 0是可读可写的，一些分支和调用操作需要LR的bit  0置一来表示Thumb状态（这是历史遗留的产物，CM3/CM4只需此位可读写）。

4.2.4      程序计数器

        R15是程序计数器，在汇编代码中一般我们都都叫它的外号“PC”。 因为 CM3/CM4内部使用了指令流水线，读PC时返回的值是当前指令的地址+4。比如说：

           0x1000:    MOV  R0,   PC   ; R0 = 0x1004

        如果向PC中写数据，就会引起一次程序的分支（但是不更新LR寄存器）。CM3/CM4中的指令至少是半字对齐的，所以PC的LSB总是读回0。然而，在分支时，无论是直接写PC的值还是使用分支指令，都必须保证加载到PC的数值是奇数（即LSB=1），用以表明这是在Thumb状态下执行。倘若写了0，则视为企图转入ARM模式，CM3将产生一个fault异常。

/ {1 S8 i8 w% b5 d; r

5 G. K7 l- Y0 O
4.2.5      特殊功能寄存器

    Cortex-M3/M4中的特殊功能寄存器包括：

  l  程序状态寄存器组（PSRs或曰xPSR）

  l  中断屏蔽寄存器组（PRIMASK, FAULTMASK,以及BASEPRI）

  l  控制寄存器（CONTROL）

     它们只能被专用的MSR/MRS指令访问，而且它们也没有与之相关联的访问地址。

        MRS   <gp_reg>,    <special_reg>  ;读特殊功能寄存器的值到通用寄存器。

        MSR   <special_reg>, <gp_reg>    ;写通用寄存器的值到特殊功能寄存器。

     这三组特殊功能寄存器都比较重要，初学者要有一定的了解。

l  程序状态寄存器组（PSRs或曰xPSR）

    程序状态寄存器在其内部又被分为三个子状态寄存器：

    Ø  应用程序PSR（APSR）

    Ø  中断号PSR（IPSR）

    Ø  执行PSR（EPSR）

通过MRS/MSR指令，这3个PSRs即可以单独访问，也可以组合访问（2个组合，3个组合都可以）。当使用三合一的方式访问时，应使用名字“xPSR”或者“PSR”。下图是三个子状态分别使用的那几位。

% F) b. {2 B4 U8 b) P4 k+ \

这里特别注意GE（这个是CM4新加的，CM3没有）和中断号PSR（IPSR）,后面将SVC异常的时候要用到。

l  中断屏蔽寄存器组（PRIMASK, FAULTMASK,以及BASEPRI）

这三个寄存器非常重要，初学者一定要了解，能记住最好。这里建立一个简单的表格，方便大家查看。

对于时间-关键任务而言，恰如其分地使用PRIMASK和BASEPRI来暂时关闭一些中断是非常重要的（FreeRTOS中这个两个寄存器都有用到，μCOS-II和μCOS-III中只用到了PRIMASK）。 而FAULTMASK(这个寄存器在当前比较流行的RTOS中还没有用到过)则可以被OS用于暂时关闭fault处理机能，这种处理在某个任务崩溃时可能需要。因为在任务崩溃时，常常伴随着一大堆faults。在系统料理“后事”时，通常不再需要响应这些fault，总之FAULTMASK就是专门留给OS用的。 要访问PRIMASK, FAULTMASK以及BASEPRI，同样要使用MRS/MSR指令,如： MRS   R0,    BASEPRI       ;读取BASEPRI到R0中 MRS   R0,    FAULTMASK   ;同上 MRS   R0,    PRIMASK      ;同上 MSR   BASEPRI, R0          ;写入R0到BASEPRI中 MSR   FAULTMASK, R0        ;同上 MSR   PRIMASK, R0         ;同上 只有在特权级下，才允许访问这3个寄存器。 其实，为了快速地开关中断，CM3还专门设置了一条CPS指令，有4种用法（在RTOS中用的比较多） CPSID  I   RIMASK=1，     ;关中断 CPSIE  I   RIMASK=0，     ;开中断 CPSID  F   ;FAULTMASK=1,    ;关异常 CPSIE  F   ;FAULTMASK=0     ;开异常 l  控制寄存器（CONTROL） 控制寄存器有两个用途，其一用于定义特权级别，其二用于选择当前使用哪个堆栈指针。由两个比特来行使这两个职能。这个寄存器也十分的重要，需认真学习。

CONTROL[1]

     在Cortex-M3/M4的handler模式中，CONTROL[1]总是0。在线程模式中则可以为0或1。因此，仅当处于特权级的线程模式下，此位才可写，其它场合下禁止写此位。改变处理器的模式也有其它的方式：在异常返回时，通过修改LR的位2，也能实现模式切换。这是LR在异常返回时的特殊用法，颠覆了对LR的传统使用方式。

     前面已经讲到，在进入异常服务程序后，将自动更新LR的值为特殊的EXC_RETURN。EXC_RETURN中高28位全为1的值，只有[3:0]的值有特殊含义，当异常服务例程把这个值送往PC时，就会启动处理器的中断返回序列。因为LR的值是由CM3/CM4自动设置的，所以只要没有特殊需求，就不要改动它。

    下面是EXC_RETURN位段详解。

总结一下上面的表，可以得出，合法的EXC_RETURN值共3个

" T, J4 i. {' p7 o4 o6 `6 ^

    如果主程序在线程模式下运行，并且在使用MSP时被中断，则在服务例程中LR=0xFFFF_FFF9（主程序被打断前的LR已被自动入栈）。

    如果主程序在线程模式下运行，并且在使用PSP时被中断，则在服务例程中LR=0xFFFF_FFFD（主程序被打断前的LR已被自动入栈）。

CONTROL[0]

    仅当在特权级下操作时才允许写该位。一旦进入了用户级，唯一返回特权级的途径，就是触发一个（软）中断，再由服务例程改写该位。

    CONTROL寄存器也是通过MRS和MSR指令来操作的：

MRS   R0,    CONTROL

MSR   CONTROL, R0

4.2.6      浮点寄存器

    Cortex-M4处理器提供了可选的浮点单元用于浮点数据处理，浮点单元还包含一个状态控制寄存器FPSCR，每个32位浮点寄存器S0-S31（S代表single precision单精度）可以通过浮点指令进行访问。也可以每两个为一对，也就是D0-D15（D代表double-precision双精度）进行访问。

4.3  操作模式和特权等级

        Cortex-M3/M4支持两个模式（handler模式，也就是中断模式和线程模式）和两个特权等级（特权级和非特权级，这里将其称为用户级）：

	特权级	用户级
异常handler的代码	Handler	错误的模式
主应用程序的代码	线程模式	线程模式

      当处理器处在线程状态下时，既可以使用特权级，也可以使用用户级；另一方面，handler模式总是特权级的。在复位后，处理器进入线程模式＋特权级。

        在特权级下的代码可以通过置位CONTROL[0]来进入用户级。而不管是任何原因产生了任何异常，处理器都将以特权级来运行其服务例程，异常返回后，系统将回到产生异常时所处的级别。用户级下的代码不能再试图修改CONTROL[0]来回到特权级。它必须通过一个异常handler，由那个异常handler来修改CONTROL[0]，才能在返回到线程模式后拿到特权级。下图是特权级线程模式和用户级线程模式的切换图：

                              

      一些简单的应用程序是不需要用户级线程模式的，如下图所示：

      把代码按特权级和用户级分开对待（当前流行的RTOS中，RTX支持此功能，用户可根据自己的需要进行配置），有利于使CM3/CM4的架构更加安全和健壮。例如，当某个用户程序代码出问题时，不会让它成为害群之马，因为用户级的代码是禁止写特殊功能寄存器和NVIC中断寄存器的。另外，如果还配有MPU，保护力度就更大，甚至可以阻止用户代码访问不属于它的内存区域。

      为了避免系统堆栈因应用程序的错误使用而毁坏，我们可以给应用程序专门配一个堆栈，不让它共享操作系统内核的堆栈。在这个管理制度下，运行在线程模式的用户代码使用PSP，而异常服务例程则使用MSP。这两个堆栈指针的切换是智能全自动的，就在异常服务的始末由硬件处理。

        如前所述，特权等级和堆栈指针的选择均由CONTROL负责。当CONTROL[0]=0时，在异常处理的始末，只发生了处理器模式的转换，如下图所示。

       但若CONTROL[0]=1（线程模式+用户级），则在中断响应的始末，both 处理器模式和特权等极都要发生变化，如下图所示。

; ], O5 H9 Z' r' `9 l5 l$ V7 v% j9 c

      CONTROL［0］只有在特权级下才能访问。用户级的程序如想进入特权级，通常都是使用一条“系统服务呼叫指令（SVC）”来触发“SVC异常”，该异常的服务例程可以视具体情况而修改CONTROL[0]。

        关于操作模式和特权级就跟大家说这么多，在讲解RTOS时，再跟大家详细讲解。有了上面的这些知识我们就可以讲解双堆栈机制了。

: u6 N& W  l# w4 u; t% Y) U

& _/ m  \5 [3 E
( M9 ]9 ~9 [+ A7 Y

4.4  双堆栈机制

     讲解双堆栈机制之前，大家要先对CM3/CM4对堆栈的处理方式有一个基本的了解。在CM3/CM4中，除了可以使用PUSH和POP指令来处理堆栈外，内核还会在异常处理的始末自动地执行PUSH与POP操作。

4.4.1      堆栈的基本操作

    笼统地讲，堆栈是一种存储器的使用模型。它由一块连续的内存和一个栈顶指针组成，用于实现“后进先出”的缓冲区（堆栈是LIFO的模式，和咱们前面讲的按键FIFO和串口FIFO不一样，别搞混了）。其最典型的应用，就是在数据处理前先保存寄存器的值，再在处理任务完成后从中恢复先前保护的这些值。堆栈操作就是对内存的读写操作，但是访问地址由SP给出。寄存器的数据通过PUSH操作存入堆栈，以后用POP操作从堆栈中取回。    在PUSH与POP的操作中，SP的值会按堆栈的使用法则自动调整，以保证后续的PUSH不会破坏先前PUSH进去的内容。下面的图片摘自Cortex-M4权威指南，看起来更形象。简单演示了PUSH操作和POP操作过程，堆栈地址由下往上表示从低地址到高地址，也就是所谓的“向下生长的满栈”模型。

    Cortex-M3/M4使用的就是“向下生长的满栈”模型（这个要谨记，后面讲RTOS任务切换的时候要用到）。堆栈指针SP指向最后一个被压入堆栈的32位数值。在下一次压栈时，SP先自减4，再存入新的数值。

    堆栈的功能就是把寄存器的数据临时备份在内存中，以便将来能恢复之——在一个任务或一段子程序执行完毕后恢复。正常情况下，PUSH与POP必须成对使用，而且参与的寄存器，不论是身份还是先后顺序都必须完全一致。当PUSH/POP指令执行时，SP指针的值也根着自减/自增。

主程序                            子程序

; R0=X, R1=Y,R2=Z

BL   Fx1 ------------------------------->

                                                    Fx1

                                                         PUSH  {R0 } ;把R0存入栈 & 调整SP

                                                         PUSH  {R1}  ;把R1存入栈 & 调整SP

                                                         PUSH  {R2}  ;把R2存入栈 & 调整SP

                                                         …        ;执行Fx1的功能，中途可以改变R0-R2的值

                                                         POP   {R2} ;恢复R2早先的值 & 再次调整SP

                                                         POP   {R1} ;恢复R1早先的值 & 再次调整SP

                                                         POP   {R0} ;恢复R0早先的值 & 再次调整SP

                                                         BX   LR   ;返回

<-------------------------------------------

;回到主程序

;R0=X, R1=Y,R2=Z （调用Fx1的前后R0-R2的值完好无损，从寄存器上下文来看，就好像什么都没发生过一样）。

PUSH/POP指令支持一次操作多个寄存器。在前面1.2.2小节有说明。

4.4.2      堆栈空间的分配

    为了让大家对堆栈有一个深入的了解，这里以STM32-V5开发板提高篇的第一个例子F4-001_按键检测和LED控制例程(V1.1)跟大家讲解下。在启动文件中定义了堆栈的大小：

Stack_Size      EQU    0x00004000

Heap_Size      EQU    0x00000400

    在main函数中添加malloc函数的调用，要不无法看到heap的使用情况。

uint32_t *p;

p = (uint32_t*)malloc(sizeof(uint32_t)*100);  //申请400个字节

    首先用MDK全编译工程，打开.map文件：

    工程文件生成的map文件信息量很大，涉及到的知识也很多，这里就先说下我们关系的堆栈空间的分配，看之前简易初学者再看看第6章STM32F4XX启动过程详解。

Image Symbol Table

0 _  _1 Q. E$ k2 U3 w% V9 O9 V& s

Local Symbols

Symbol Name                              Value       OvType        Size  Object(Section)

HEAP                                   0x200021c0   Section        1024 startup_stm32f4xx.o(HEAP)

STACK                                  0x200025c0   Section       16384  startup_stm32f4xx.o(STACK)

Global Symbols

Symbol Name                              Value       OvType        Size  Object(Section)

__heap_base                              0x200021c0   Data           0 startup_stm32f4xx.o(HEAP)

__heap_limit                             0x200025c0   Data           0 startup_stm32f4xx.o(HEAP)

__initial_sp                             0x200065c0   Data           0 startup_stm32f4xx.o(STACK)

& c4 p$ }) ]% E( a0 J: Q

Memory Map of the image

. H: f6 {3 L/ Z0 x& x

   Execution Region RW_IRAM1 (Base: 0x20000000,Size: 0x000065c0, Max: 0x00020000, ABSOLUTE)

0 I2 |' V7 T" w3 b9 k$ @

    Base Addr   Size         Type   Attr     Idx    E Section Name        Object

: {1 Z- Y' b0 v

    0x20000000  0x0000000d   Data   RW         322    .data               bsp_timer.o

    0x2000000d  0x00000001   Data   RW         423    .data               bsp_uart_fifo.o

    0x2000000e  0x00000010   Data   RW         694    .data               stm32f4xx_rcc.o

    0x2000001e   0x00000002  PAD

    0x20000020  0x00000014   Data   RW        1293    .data               system_stm32f4xx.o

    0x20000034  0x00000004   Data   RW        1621    .data               mc_w.l(stdout.o)

    0x20000038  0x00000004   Data   RW        1630    .data               mc_w.l(mvars.o)

    0x2000003c  0x00000004   Data   RW        1631    .data               mc_w.l(mvars.o)

    0x20000040  0x000000ad   Zero   RW         174    .bss                bsp_key.o

    0x200000ed  0x00000003   PAD

   0x200000f0   0x00000030   Zero  RW          320    .bss                bsp_timer.o

    0x20000120  0x000020a0   Zero   RW         422    .bss                bsp_uart_fifo.o

    0x200021c0  0x00000400   Zero   RW         643    HEAP                startup_stm32f4xx.o

    0x200025c0  0x00004000   Zero   RW         642    STACK               startup_stm32f4xx.o

    上面的这些信息还不够直接，这里借助Cortex-M3权威指南中的一个截图进行说明。

    先解释下这个截图的含义：在离开复位状态后，CM3做的第一件事就是读取下列两个32位整数的值

  l  从地址0x0000,0000处取出MSP的初始值（也就是上面的0x20008000）。

  l  从地址0x0000,0004处取出PC的初始值——这个值是复位向量，LSB必须是1。然后从这个值所对应的地址处取指。

    请注意，这与传统的ARM架构不同——其实也和绝大多数的其它单片机不同。传统的ARM架构总是从0地址开始执行第一条指令。它们的0地址处总是一条跳转指令。在CM3/CM4中，在0地址处提供MSP的初始值，然后紧跟着就是向量表（向量表在以后还可以被移至其它位置） 。向量表中的数值是32位的地址，而不是跳转指令。向量表的第一个条目指向复位后应执行的第一条指令。

    因为CM3/CM4使用的是向下生长的满栈，所以MSP的初始值必须是堆栈内存的末地址加1。举例来说，如果你的堆栈区域在0x20007C00-0x20007FFF之间，那么MSP的初始值就必须是0x20008000。

    向量表跟随在MSP的初始值之后——也就是第2个表目。要注意因为CM3/CM4是在Thumb态下执行，所以向量表中的每个数值都必须把LSB置1（也就是奇数）。正是因为这个原因，上图中使用0x101来表达地址0x100。当0x100处的指令得到执行后，就正式开始了程序的执行。在此之前初始化MSP是必需的，因为可能第1条指令还没来得及执行，就发生了NMI或是其它fault。MSP初始化好后就已经为它们的服务例程准备好了堆栈。

    对于不同的开发工具，需要使用不同的格式来设置MSP初值和复位向量。有些则由开发工具自行计算并生成。现在接着上面的.map文件进行说明，这个文件里面有一项是：

__initial_sp                             0x200065c0

    其实__initial_sp就是MSP的初始值，下面这个是Debug状态下的截图，MSP初始值和__initial_sp是一样的，也就是MDK帮我们计算好了MSP初始值。

     这里就跟大家讲这么多，后面的教程中继续的完善。

4 V) Q0 g6 W5 t$ L  I: E8 v; K

4.5  内核相关的API函数

    要访问上面提到的寄存器，可以通过ARM官方提供的CMSIS软件包，里面有个文件core_cmdFunc.h，相关API函数就在里面，提供了三个版本的函数支持：MDK，IAR，GCC。这里将MDK版本的函数摘录出来，方便大家查看。

1. /** \brief  Get Control Register
   6 W8 {' T& Z8 E; G' K+ a! s
2. 
   7 L( |7 J' p( B5 ?) ?: f5 {
3.     This function returns the content of the Control Register.
   
4. 
   . r4 J, j' _6 ]
5.     \return               Control Register value
   
6. */
   0 [" g+ J1 q/ o
7. __STATIC_INLINE uint32_t __get_CONTROL(void)
   
8. {
   
9.   register uint32_t __regControl         __ASM("control");
   
10.   return(__regControl);
    7 _8 h& T) p6 Z5 q- ?/ p
11. }
    
12. 
    
13. 
    ' `4 g2 S: ], s  G- S* c
14. /** \brief  Set Control Register
    % p/ R$ G& C0 d! \( g4 u
15. 
    
16.     This function writes the given value to the Control Register.
    
17. 
    
18.     \param [in]    control  Control Register value to set
    1 C; g$ j8 a  f  \
19. */
    
20. __STATIC_INLINE void __set_CONTROL(uint32_t control)
    
21. {
    - g# d- C0 m: B+ U6 Z& k0 I
22.   register uint32_t __regControl         __ASM("control");
    
23.   __regControl = control;
    % i) W# K7 A# |7 L
24. }
    5 i& Y: t! p! ^4 O/ C6 d+ m
25. 
    
26. 
    # T3 I2 \! n8 k7 u8 q% E6 E" ~
27. /** \brief  Get IPSR Register
    
28. 
    
29.     This function returns the content of the IPSR Register.
    % ^4 V; P: l9 g0 h7 N! b4 N  E
30. 
    
31.     \return               IPSR Register value
    ) {( E, N6 b9 V# P* O
32. */
    $ ~2 v5 R6 @# r* Y, H
33. __STATIC_INLINE uint32_t __get_IPSR(void)
    
34. {
    
35.   register uint32_t __regIPSR          __ASM("ipsr");
    7 o) s) ^; n" g. x) r% o0 s% x
36.   return(__regIPSR);
    5 \" ~, o+ v  ]1 d6 G2 P
37. }
    4 v4 V; D) c) O' s" Y0 J
38. 
    , g  f+ y6 l+ q$ ^$ t$ d
39. 
    
40. /** \brief  Get APSR Register
    
41. 
    : r: y' A+ ~9 s: Y# \& j
42.     This function returns the content of the APSR Register.
    
43. 
    
44.     \return               APSR Register value
    
45. */
    
46. __STATIC_INLINE uint32_t __get_APSR(void)
    
47. {
    4 @9 j% n$ R! t
48.   register uint32_t __regAPSR          __ASM("apsr");
    ! t9 C* M, }; U/ k( U$ e, Z9 S6 h
49.   return(__regAPSR);
    
50. }
    ) F2 K8 y( J6 I9 D  o
51. 
    2 H/ K$ Z3 B; z; J- X, }% w7 }
52. 
    
53. /** \brief  Get xPSR Register
    2 z5 I& [" J# E& }7 e* X
54. 
    
55.     This function returns the content of the xPSR Register.
    # o, f% Y2 T+ F, _, O5 \) G
56. 
    ! N/ g# W6 h& h8 I8 q
57.     \return               xPSR Register value
    $ ]6 Y  T, ?# z( U5 T  l
58. */
    
59. __STATIC_INLINE uint32_t __get_xPSR(void)
    
60. {
    
61.   register uint32_t __regXPSR          __ASM("xpsr");
    
62.   return(__regXPSR);
    ) i  j) C* ]  l# h$ E
63. }
    , @* g* G& t1 I: _: ]6 B
64. 
    
65. 
    
66. /** \brief  Get Process Stack Pointer
    
67. 
    2 e4 q7 M# H0 F1 w# x3 [
68.     This function returns the current value of the Process Stack Pointer (PSP).
    
69. 
    6 O1 U" p6 Y1 C7 a: R( y
70.     \return               PSP Register value
    % Y: b. I; a7 A2 R, d; i; {
71. */
    + [( @: k( n; @3 @- @' f3 }8 Q% B
72. __STATIC_INLINE uint32_t __get_PSP(void)
    
73. {
    
74.   register uint32_t __regProcessStackPointer  __ASM("psp");
    
75.   return(__regProcessStackPointer);
    
76. }
    1 \; L: f7 b# ^5 b
77. 
    
78. 
    ) Z! d9 w; a- q" F) h. k; [* K
79. /** \brief  Set Process Stack Pointer
    ' t) U' f0 C0 E6 G0 r
80. 
    
81.     This function assigns the given value to the Process Stack Pointer (PSP).
    . y$ ?: V% e! D$ s4 |
82. 
    1 @8 {$ O6 ~) ?( M
83.     \param [in]    topOfProcStack  Process Stack Pointer value to set
    ' c3 |0 Q) `+ {( J+ x
84. */
    5 p- s+ s) |2 H# @
85. __STATIC_INLINE void __set_PSP(uint32_t topOfProcStack)
    
86. {
    + n5 A# I  T' m( l0 Q
87.   register uint32_t __regProcessStackPointer  __ASM("psp");
    * X& R0 ?1 c8 c8 ?
88.   __regProcessStackPointer = topOfProcStack;
    : G. b, e# N9 {* ?
89. }
    
90. 
    
91. 
    / r" n* z+ w) o! g
92. /** \brief  Get Main Stack Pointer
    + g( N6 i, q  M! C0 g
93. 
    
94.     This function returns the current value of the Main Stack Pointer (MSP).
      u6 P3 g* `9 F+ }( e" o
95. 
    
96.     \return               MSP Register value
    
97. */
    
98. __STATIC_INLINE uint32_t __get_MSP(void)
    
99. {
    
100.   register uint32_t __regMainStackPointer     __ASM("msp");
     ; E9 ^/ @) U$ \6 o
101.   return(__regMainStackPointer);
     
102. }
     
103. 
     5 i, e$ M2 _7 c( \" V
104. 
     
105. /** \brief  Set Main Stack Pointer
     
106. 
     
107.     This function assigns the given value to the Main Stack Pointer (MSP).
     4 k6 D1 N% C9 t# V* m$ w7 f
108. 
     7 e2 Y! n( K% T8 S) j- X% C9 i+ q
109.     \param [in]    topOfMainStack  Main Stack Pointer value to set
     
110. */
     & g9 x+ j5 p' k  J
111. __STATIC_INLINE void __set_MSP(uint32_t topOfMainStack)
     
112. {
     
113.   register uint32_t __regMainStackPointer     __ASM("msp");
     : E7 {+ r2 d% D4 f" U" o, J6 w. M
114.   __regMainStackPointer = topOfMainStack;
     : ^8 g9 R0 v0 N1 B+ a
115. }
     
116. 
     
117. 
     
118. /** \brief  Get Priority Mask
     
119. 
     
120.     This function returns the current state of the priority mask bit from the Priority Mask Register.
     
121. 
     . W: B3 U0 v, r" {* r, M7 L
122.     \return               Priority Mask value
     8 U( X, b/ q3 s! j9 t
123. */
     ) X$ b1 q) I+ G( B$ K3 t9 a
124. __STATIC_INLINE uint32_t __get_PRIMASK(void)
     % A, M; H. Q) O7 V
125. {
     ' O- y! f/ ?- @; H5 ^
126.   register uint32_t __regPriMask         __ASM("primask");
     ( l. L( I. n) T8 B+ a' [
127.   return(__regPriMask);
     
128. }
     3 s; l! q3 n1 @, W# p
129. 
     
130. 
     2 i  l! ]+ N! ?2 R
131. /** \brief  Set Priority Mask
     
132. 
     
133.     This function assigns the given value to the Priority Mask Register.
     
134. 
     
135.     \param [in]    priMask  Priority Mask
     
136. */
     
137. __STATIC_INLINE void __set_PRIMASK(uint32_t priMask)
     
138. {
     * o' _2 z. [) u8 [
139.   register uint32_t __regPriMask         __ASM("primask");
     
140.   __regPriMask = (priMask);
     
141. }
     
142. 
     ) Q% |! K3 Q. w2 i0 C+ y8 `
143. 
     0 t- e* c" p2 [: g/ y- |
144. #if       (__CORTEX_M >= 0x03)
     % R( E( k5 z6 Y) ^) T
145. 
     6 O7 N- B5 \/ ]* O, T
146. /** \brief  Enable FIQ
     ( L* z9 Y% P8 W9 P  W$ b
147. 
     
148.     This function enables FIQ interrupts by clearing the F-bit in the CPSR.
     
149.     Can only be executed in Privileged modes.
     ; f. l! q9 s$ u* y: g* ?& s  w7 a$ Q
150. */
     
151. #define __enable_fault_irq                __enable_fiq
     
152. 
     
153. 
     * q) w4 Z  h6 B4 r" t
154. /** \brief  Disable FIQ
     - m, z# N9 J  B) g
155. 
     0 p8 u* w! R9 i
156.     This function disables FIQ interrupts by setting the F-bit in the CPSR.
     
157.     Can only be executed in Privileged modes.
     
158. */
     
159. #define __disable_fault_irq               __disable_fiq
     7 }. o$ o9 J8 S6 e
160. 
     
161. 
     7 @6 e" g$ Z. g6 h0 C9 B& R
162. /** \brief  Get Base Priority
     6 f- k  \/ x* x: U6 }
163. 
     . v# M5 E$ f6 y: A$ t+ h1 ^9 J" h
164.     This function returns the current value of the Base Priority register.
     - F& S7 G6 Q4 a. C( m
165. 
     1 }- x( Z  P' F, _2 m8 ~
166.     \return               Base Priority register value
     
167. */
     
168. __STATIC_INLINE uint32_t  __get_BASEPRI(void)
     
169. {
     
170.   register uint32_t __regBasePri         __ASM("basepri");
     
171.   return(__regBasePri);
     
172. }
     ( T, I, g% j) V/ w# c
173. 
     
174. 
     ) `  G( R* I3 s" _
175. /** \brief  Set Base Priority
     5 A, E  [1 q+ O3 z
176. 
     1 F3 r) `7 I7 v/ V! I' o/ m
177.     This function assigns the given value to the Base Priority register.
     
178. 
     , b9 G8 \1 N; z+ N, `+ ?) h
179.     \param [in]    basePri  Base Priority value to set
     4 ~/ r" H, R' Z( D% h
180. */
     
181. __STATIC_INLINE void __set_BASEPRI(uint32_t basePri)
     $ e8 @" S7 G" L  Z/ H
182. {
     
183.   register uint32_t __regBasePri         __ASM("basepri");
     ( m- w9 B$ E3 \3 N8 G$ z7 h5 \
184.   __regBasePri = (basePri & 0xff);
     $ E$ Q9 L. i; [7 q
185. }
     * {) P1 p3 j  r: k, {1 u* Q( s
186. 
     
187. 
     
188. /** \brief  Get Fault Mask
     4 f9 Y$ D! P3 [
189. 
     $ V0 |! r$ _; a' f( l& f7 `
190.     This function returns the current value of the Fault Mask register.
     . R' K" ]) c3 O7 }6 W
191. 
     3 d; P) C0 z: d
192.     \return               Fault Mask register value
     . s$ s0 Q$ J/ u3 ~
193. */
     
194. __STATIC_INLINE uint32_t __get_FAULTMASK(void)
     # x7 W! b2 }  |7 w  O
195. {
     # H& l: T4 O$ [9 D; s+ F
196.   register uint32_t __regFaultMask       __ASM("faultmask");
     
197.   return(__regFaultMask);
     
198. }
     $ a+ W$ ^( ]4 H9 e% V8 g  o# W
199. 
     
200. 
     2 P, v% }( ~0 u/ l" P
201. /** \brief  Set Fault Mask
     
202. 
     3 |' F8 e5 e4 Y5 x# x6 t! Z  t
203.     This function assigns the given value to the Fault Mask register.
     
204. 
     
205.     \param [in]    faultMask  Fault Mask value to set
       [1 ?( B( i5 t2 u
206. */
     3 c* |( x; S: B- ]
207. __STATIC_INLINE void __set_FAULTMASK(uint32_t faultMask)
     
208. {
     
209.   register uint32_t __regFaultMask       __ASM("faultmask");
     $ b& {+ k2 {0 l# c
210.   __regFaultMask = (faultMask & (uint32_t)1);
     : H1 |; W7 h1 ~2 h1 u
211. }
     ( m" z# D/ ^+ c9 o$ h& `/ ?4 m' p7 \
212. 
     . w3 [7 _- {2 _/ U/ |, w* K5 N
213. #endif /* (__CORTEX_M >= 0x03) */
     3 ^4 @7 O9 a1 `( n& b; U
214. 
     - B- j1 c8 y5 U0 k* ^( I' O
215. 
     . _# Y: l% |, y: y; u3 ]5 s  Y
216. #if       (__CORTEX_M == 0x04)
     
217. 
     
218. /** \brief  Get FPSCR
     . r3 A0 m1 _. _9 P. J) Y
219. 
     
220.     This function returns the current value of the Floating Point Status/Control register.
     
221. 
     , X" @! E9 W0 B
222.     \return               Floating Point Status/Control register value
     
223. */
     ' q9 f+ R+ k+ b& |/ W  l* O. ~
224. __STATIC_INLINE uint32_t __get_FPSCR(void)
     
225. {
     
226. #if (__FPU_PRESENT == 1) && (__FPU_USED == 1)
     & N' I. \6 }* y( N5 E
227.   register uint32_t __regfpscr         __ASM("fpscr");
     $ i! p- C9 b% D: |6 c0 g
228.   return(__regfpscr);
       {* X6 G( h; S, t$ g
229. #else
     
230.    return(0);
     
231. #endif
     / Y6 H, z( c1 i8 [. O$ z4 l4 Y
232. }
     
233. 
     6 b( u, ^4 q, A* m9 v) x8 x
234. 
     $ s6 L5 L; }0 _
235. /** \brief  Set FPSCR
     ; R; h  R; y& K& d4 a
236. 
     * A; w! f! e; h2 P- d! b* H
237.     This function assigns the given value to the Floating Point Status/Control register.
     
238. 
     
239.     \param [in]    fpscr  Floating Point Status/Control value to set
     
240. */
     * m/ W( u- R5 A% \5 u: L
241. __STATIC_INLINE void __set_FPSCR(uint32_t fpscr)
     
242. {
     + N) y) ~5 ^, X- N5 n3 v
243. #if (__FPU_PRESENT == 1) && (__FPU_USED == 1)
     ! h! t) T3 r0 x# v$ {
244.   register uint32_t __regfpscr         __ASM("fpscr");
     
245.   __regfpscr = (fpscr);
     ' S$ I/ B+ Y) v) q# d2 K
246. #endif
     
247. }

复制代码

! h# O) r- U$ u* k8 u; k

4.6  总结

    对于初学者一下子掌握这么多的东西比较的困难，这里总结一下主要的几点，一般应用记住这几点即可，需要的时候再查阅这个知识点相关的内容：

  l  系统复位后默认使用的是MSP,复位后的状态是特权级线程状态，在这个状态下是允许修改寄存器的。进入到用户特权以后就不能修改这些寄存器了。

  l  用户特权的情况（也就是用户建立的非中断服务程序）下可以使用MSP或PSP，特权模式（中断服务程序）只能使用MSP。

  l  还有很重要的一条就是。假如在用户模式下使用的是PSP,那么寄存器的数值被保存到任务堆栈的空间，
4 l. V  q7 x5 i. L0 Y/ j. \进入中断程序后就开始使用MSP,如果还有一个高优先级的中断难么就继续的使用MSP,在程序推出最后一级中断的时候就用用户堆栈恢复寄存器。

  l  Cortex-M4的堆栈模型是向下生长的满栈。

    下期教程会做两个相关的例子帮大家深入的理解CM4内核方面的知识。

/ [9 x: T6 W. K1 Y9 ^; ~

1 A' M; {1 z/ c5 H

参考资料：

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

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

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