内存保护（MPU）实验
. d6 N. [7 [* }" A  \9 ZSTM32的Cortex M4（STM32F3/F4系列）和Cortex M7（STM32H7/H7系列）系列的产品，都带有内存保护单元（memory protection unit），简称：MPU。使用MPU可以设置不同存储区域的存储器访问特性（如只支持特权访问或全访问）和存储器属性（如可缓存、可共享），从而提高嵌入式系统的健壮性，使系统更加安全。接下来，我们将以STM32H750为例，给大家介绍STM32H7内存保护单元（MPU）的使用。
$ |7 _+ C7 K: h; v' N; C" Y
3 ]+ J* }; H( z- ^! z- `7 t24.1 MPU简介
# t. ]6 d& X/ n9 H( TMPU，即内存保护单元，可以设置不同存储区域的存储器访问特性（如只支持特权访问或全访问）和存储器属性（如可缓存、可缓冲、可共享），对存储器（主要是内存和外设）提供保护，从而提高系统可靠性：
1，阻止用户应用程序破坏操作系统使用的数据。
0 a. Z9 S$ t! x* U! [1 u2，阻止一个任务访问其他任务的数据区，从而隔离任务。
, z: t5 v$ M$ n- [) b' |3，可以把关键数据区域设置为只读，从根本上解决被破坏的可能。
: z/ b; g5 n% e% ]3 F# M4，检测意外的存储访问，如堆栈溢出，数组越界等。
5，将SRAM或者RAM空间定义为不可执行（用不执行，XN），防止代码注入攻击。
注意，MPU不仅可以保护内存区域（SRAM区），还可以保护外设区（比如FMC）。我们可以通过MPU设置存储器的访问权限，当存储器访问和MPU定义的访问权限相冲突的时候，则访问会被阻止，并且触发一次错误异常（一般是MemManage异常）。然后，在异常处理的时候，就可以确定系统是否应该复位或者执行其他操作。
STM32H7的MPU提供多达16个可编程保护区域（region），每个区域（region）都有自己的可编程起始地址、大小及设置。MPU功能必须开启才会有效，默认条件下，MPU是关闭的，所以，我们要向使用MPU，必须先打开MPU才行。
3 O/ p1 e$ P- s$ k- G16个可编程保护区域（region），一般来说是足够使用的了，如果觉得不够，每个区域（region）还可以被进一步划分为更小的子区域（sub region），另外，还允许启用一个背景区域（即没有MPU设置的其他所有地址空间），背景区域只允许特权访问。在启用MPU后，就不得再访问定义之外的地址区间，也不得访问未经授权的区域（region），否则，将以“访问违例”处理，触发MemManage异常。
此外，MPU定义的区域（region）还可以相互交迭。如果某块内存落在多个区域（region）中，则访问属性和权限将由编号最大的region来决定。比如，若2号region与5号region交迭，则交迭的部分受5号region控制。
MPU设置是由CTRL、RNR、RBAR和RASR等寄存器控制的，接下来，我们分别介绍一下这几个寄存器。
首先是MPU控制寄存器（CTRL），该寄存器只有最低三位有效，其描述如表24.1.1所示：
: [! M5 \/ {$ a6 D
; t/ L8 q. w! D% a) j
. [9 o& p( c, e' m6 X' H
表24.1.1 MPU_CTRL寄存器各位描述
PRIVDEFENA位用于设置是否开启背景区域（region），通过设置该位为1，可以在没有建立任何region就使能MPU的情况下，依然允许特权级程序访问所有地址，而只有用户级程序被卡死。但是，如果设置了其它的region（最多16个region）并使能MPU，则背景region与这些region重合的部分，就要受各region的限制。HFNMIENA位用于控制是否在NMI和硬件fault中断服务例程中禁止MPU，一般设置为0即可。ENABLE位，则用于控制是否使能MPU，我们一般在MPU配置完）以后，才对其进行使能，从而开启MPU。
接下来，介绍MPU区域编号寄存器（RNR），该寄存器只有低8位有效，其描述如表24.1.2所示：

6 i' i$ I0 ?' f% y  B3 A9 C
- {! @8 w1 l' T/ ~* x  j
& Q3 ~" M* I4 X3 i+ ]表24.1.2 MPU_RNR寄存器各位描述
* O/ x7 h  M! Y' J7 [0 p! K0 z在配置任何一个区域（region）之前，必须先在MPU内选中这个区域，我们可以通过将区域编号写入MPU_RNR寄存器来完成这个操作。该寄存器只有低8位有效，不过由于STM32H7最多只支持16个区域，所以，实际上只有最低4位有效（0~15）。在配置完区域编号以后，我们就可以对区域属性进行设置了。
接下来，介绍MPU基地址寄存器（RBAR），该寄存器各位描述如表24.1.3所示：
/ F3 K4 u7 d6 b8 E/ E; V
1 o( v! E* y/ [9 U6 L' q. `
$ M- W8 Y4 \8 ^: c8 q6 Z7 d
. P2 p% \3 B) r2 ?/ Y表24.1.3 MPU_RBAR寄存器各位描述
4 [5 l, S- W6 D: ^6 L# C$ P注意，表中ADDR字段所设置的基址必须对齐到区域（region）容量的边界。例如，我们定义某个region的容量是64KB（通过RASR寄存器设置），那么它的基址（ADDR）就必须能被64KB整除，比如0X0001 0000、0X0002 0000、0X0003 0000等（低16位全为0）。
VALID用于控制REGION段（bit[3:0]）的数据是否有效，如果VALID=1，则REGION段的区域编号将覆盖MPU_RNR寄存器所设置的区域编号，否则将使用MPU_RNR所设置的区域编号。我们一般设置VALID为0，这样MPU_RBAR寄存器的低5位就没有用到。
0 N% Q+ K! {% q" m3 X特别注意，表17.1.3中的N值最少也是5，所以，基址必须是32的倍数，从而可以知道我们设置region的容量，必须是32字节的倍数。
% _) c1 d0 s2 n: P1 q最后，我们介绍MPU区域属性和容量寄存器（RASR），该寄存器各位描述如表24.1.4所示：
" G1 b' ]& f$ l0 o  ?$ @) [
# n, @/ [' q7 V' s% j

表24.1.4 MPU_RASR寄存器各位描述
9 Y# B8 a) \+ Q2 m) @. eXN位，用于控制是否允许从此区域取指，如果XN=1，说明禁止从区域取指，如果强行取指，将产生一个MemManage异常。如果设置XN=0，则允许取指。
: X; j' n5 v) A0 m, YAP位，由3个位（bit[26:24]）组成，用于控制数据的访问权限（访问许可），控制关系如表24.1.5所示：



8 a6 l" F' C/ N, w: Y表24.1.5 不同AP设置及其访问权限
TEX、S、C和B等位，对应着存储系统中比较高级的概念，可以通过对这些位段的编程，来支持多样的内存管理模型，这些位组合的详细功能如表24.1.6所示：
9 X6 y& W9 J+ c. O7 H% i$ N# y
) u3 W6 C' l9 P+ B6 E
6 c6 z1 o/ a/ s" h0 C0 P6 o3 D& r
/ J& r) |! l3 R) z4 W表24.1.6 TEX、S、C和B对存储器类型的定义
有些情况下，内部和外部内存可能需要不同的缓存策略，次数需要设置TEX的第二位为1，这样TEX[1:0]的定义就会变为外部策略表（表17.1.6种表示为BB），而C和B位则会变为内部策略表（表17.1.6种表示为AA）。缓存策略的定义（AA和BB）如表24.1.7所示：
; c  q3 @" X; \- m6 h- m
6 y4 m# B6 k8 b6 B
) F5 E% [8 b  f: f
表24.1.7 TEX最高位为1时内外缓存策略编码
S位用于控制存储器的共享特性，设置S=1，则二级存储器不可以缓存（Cache），如果设置S=0，则可以缓存（Cache），一般我们设置该位为0即可。
' r0 m  o  x8 T( Y5 nC位用于控制存储器的缓存特性，也就是是否可以Cache，STM32H7自带Cache，如果我们想要某个存储器可以被Cache，则必须设置C=1。此位需要根据具体的需要设置。
8 L2 _, t1 q2 f! r" ^# y4 h7 AB位用于控制存储器的缓冲特性，设置B=1，则二级存储器可以缓冲，即写回模式，设置B=0，则二级存储器不可以缓冲，即写通模式。此位需根据具体的需要进行设置。
3 u9 E" ?. k3 a- l- n6 J; z, YSRD[15:8]，这8个位用于控制子区域（sub region）使能。前面提到，STM32H7的MPU最多支持8个region，有时候可能不够用，通过子区域的概念，可以将每个region的内部进一步划分成更小的块，这就是sub region，每个sub region可以独立地使能或除能（相当于可以部分地使能一个region）。
4 D5 [5 y2 j" G  }  tsub region的使用必须满足：
1，每个region必须8等分，每份是一个sub region，其属性与主region完全相同。
$ g, b7 r( N8 h& Y! }- {2，可以被分为8个sub region的region，其大小必须大于等于256字节。
SRD中的8个位，每个位控制一个sub region是否被除能。如SRD.4=0，则4号sub region被除能。如果某个sub region被除能，且其对应的地址范围又没有落在其它region中，则对该区的访问将引发fault。
$ }/ L8 J# a$ O- BREGIONSIZE[5:1]，这5个位用于控制region的容量（大小），计算关系如下：
5 |' x8 k+ ~, I2 o: g3 L% [rsize=2^(REGIONSIZE+1)
rsize即region的容量，必须大于等于32字节，即REGIONSIZE必须大于等于4。region的容量范围为：32B~4GB，根据实际需要进行设置。
" j/ E' ^! u, h4 A" J& ?SZENABLE位，用于设置region的使能。该位一般最后设置，设置为1，则启用此region，使能MPU保护。
至此，关于MPU的简介就介绍完了，关于MPU更详细的说明，请参考：《STM32H7编程手册.pdf》 、《STM32 MPU说明》和《Cortex M3权威指南(中文)》第14章。
24.2 硬件设计
% @7 N& L2 T! I) L1 M1.例程功能
本实验使用STM32H7自带的MPU功能，对一个特定的内存空间（数组，地址：0X20002000）进行写访问保护。开机时，串口调试助手显示：MPU closed，表示默认是没有写保护的。按KEY0可以往数组里面写数据，按KEY1，可以读取数组里面的数据。按KEY_UP则开启MPU保护，此时，如果再按KEY0往数组写数据，就会引起MemManage错误，进入MemManage_Handler中断服务函数，此时LED1点亮，同时打印错误信息，最后软件复位，系统重启。LED0用于提示程序正在运行，所有信息都是通过串口1输出，需要用串口调试助手查看。
2.硬件资源
& A4 g% s: B* N$ D1）RGB灯
RED ：LED0 - PB4
GREEN ：LED1 - PE6
6 E1 v; D- G" ]# I5 I# X$ v; h0 y2）独立按键
  y6 W% x$ Y( r4 q$ BKEY0 - PA1
: o: s: E: Q2 P" E; [9 R7 }% IKEY1 - PA15
WK_UP - PA0
3）串口1(PA9/PA10连接在板载USB转串口芯片CH340上面)
" W7 N* t* {# `' D3.原理图
/ @- m  M* {7 z+ nMPU属于STM32H750的内部资源，只需要软件设置好即可正常工作。我们借助按键和LED灯验证MPU工作是否正常，然后通过电脑串口上位机软件观察打印出来的信息。

24.3 程序设计
24.3.1 MPU的HAL库驱动
MPU在HAL库中的驱动代码在stm32h7xx_hal_cortex.c文件（及其头文件）中。
4.HAL_MPU_ConfigRegion函数
MPU的初始化函数，其声明如下：
  L* n! R: K* }" R5 p+ Hvoid HAL_MPU_ConfigRegion(MPU_Region_InitTypeDef *MPU_Init);
$ v' Q# m7 b: j. w' S( o+ O  X5 h函数描述：
用于配置MPU。
9 D6 z. Y2 A9 @. K函数形参：
形参1是MPU_Region_InitTypeDef结构体类型指针变量，其定义如下：

1. typedef struct
   0 I7 ?: I- ~" a  u
2. {
   * W9 u  u6 H; W  ~5 D
3.   uint8_t                Enable;                     /* 区域使能/禁止 */
   8 z5 U- B4 U$ T9 q
4.   uint8_t                Number;                     /* 区域编号 */         
   
5.   uint32_t               BaseAddress;               /* 配置区域基地址 */      
   
6.   uint8_t                Size;                        /* 区域容量 */         
   
7.   uint8_t                SubRegionDisable;         /* 子region除能位段设置 */      
   8 E* B! }6 T7 `: T# e
8.   uint8_t                TypeExtField;              /* 类型扩展级别 */                    
   
9.   uint8_t                AccessPermission;         /* 设置访问权限 */           
   
10.   uint8_t                DisableExec;               /* 允许/禁止取指 */               
    
11.   uint8_t                IsShareable;               /* 禁止/允许共享 */              
    
12.   uint8_t                IsCacheable;               /* 禁止/允许缓存 */               
    
13.   uint8_t                IsBufferable;              /* 禁止/允许缓冲 */         
    
14. }MPU_Region_InitTypeDef;

复制代码

该结构体成员变量很多，每个成员变量的含义我们都在上面定义中有注释。这里大家注意，除了BaseAddress和Number两个成员变量是分别用来配置MPU->RBAR和MPU->RNR寄存器之外，其他成员变量都是用来配置MPU->RASR寄存器相关位，大家如果对这些配置项不理解的话，可以直接对照我们前面讲解的寄存器MPU->RASR各个位含义来理解。
函数返回值：
# z2 H+ U- d5 k6 L) H; S无
2. HAL_MPU_Enable函数
HAL_MPU_Enable函数是MPU使能函数。其声明如下：
void HAL_MPU_Enable(uint32_t MPU_Control);
函数描述：
该函数用于使能MPU，形参一般使用MPU_PRIVILEGED_DEFAULT。
# e  G; M8 W4 ]9 o7 {函数形参：
形参1是uint32_t类型变量，共有四个选择，对应设置如表24.1.1的 MPU_CTRL寄存器，四个选择参数设置情况如下：
* B( ]6 M" ]% K" ?9 [#define MPU_HFNMI_PRIVDEF_NONE ((uint32_t)0x00000000)
0 y5 @; P6 |8 Y. o该参数设置MPU的CTL控制寄存器的PRIVDEFENA位为0，即禁止了背景区，访问任何未使能 MPU的区域均会造成内存异常MemFault。
此参数设置MPU的CTL控制寄存器的HFNMIENA位为0，即NMI不可屏蔽中断服务程序和硬件异常中断服务程序执行期间会强制关闭MPU。
#define MPU_HARDFAULT_NMI ((uint32_t)0x00000002)
该参数设置MPU的CTL控制寄存器的PRIVDEFENA位为0，即禁止了背景区，访问任何未使能 MPU 的区域均会造成内存异常MemFault。
此参数设置MPU的CTL控制寄存器的HFNMIENA位为1，即NMI不可屏蔽中断服务程序和硬件异常中断服务程序执行期间会继续开启MPU。
#define MPU_PRIVILEGED_DEFAULT ((uint32_t)0x00000004)
: N' `* ]$ w6 p  ~该参数设置MPU的CTL控制寄存器的PRIVDEFENA位为1，即使能了背景区，特权级下可以正常访问任何未使能MPU的区域。
! P4 v5 l! [4 ~" B+ v! B$ Q4 R8 f此参数设置MPU的CTL控制寄存器的HFNMIENA位为0，即NMI不可屏蔽中断服务程序和硬件异常中断服务程序执行期间会强制关闭MPU。
: `( ^+ c! S+ h/ D8 u! k9 h#define MPU_HFNMI_PRIVDEF ((uint32_t)0x00000006)
该参数设置MPU的CTL控制寄存器的PRIVDEFENA位为1，即使能了背景区，特权级下可以正常访问任何未使能MPU的区域。
+ S6 t1 O3 |$ r7 a. g此参数设置MPU的CTL控制寄存器的HFNMIENA位为1，即NMI不可屏蔽中断服务程序和硬件异常中断服务程序执行期间会继续开启MPU。
% b& |0 h3 F, `+ Y0 ?# k" ^# n4 m8 n函数返回值：
无
3. HAL_MPU_Disable函数
HAL_MPU_Disable函数是MPU失能函数。其声明如下：
/ D" J( q# l* w! vvoid HAL_MPU_Disable (void);
函数描述：
该函数用于禁止MPU，我们配置MPU前需要先调用该函数禁止MPU，才能进行配置。
, ~" t: M7 d1 z+ @! u3 [4 v8 w/ D' o8 E函数形参：
2 T/ w; f: v  h& H+ y; P无
函数返回值：
无
8 D) ^+ ^# t9 }1 B* l* t, eMPU配置步骤
& I+ s3 ~% Q4 Y+ B' D" o. }  |1）禁止MPU以及MemManage中断
调用HAL_MPU_Disable函数禁止MPU以及MemManage中断。
2）配置某个区域的MPU保护参数
在进行MPU配置之前我们必须先通过MPU_RNR区域编号寄存器用来选择下一个要配置的区域，然后通过配置MPU_RBAR基地址寄存器来配置基地址，最后通过区域属性和容量寄存器RASR来配置区域相关属性和参数。这些过程都可以通过调用HAL_MPU_ConfigRegion函数来完成。除了BaseAddress和Number两个成员变量是分别用来配置MPU->RBAR和MPU->RNR寄存器之外，其他成员变量都是用来配置MPU->RASR寄存器相关位，大家如果对这些配置项不理解的话，可以直接对照我们前面讲解的寄存器MPU->RASR各个位含义来理解。
3）使能MPU以及MemManage中断
调用HAL_MPU_Enable函数禁止MPU以及MemManage中断。

24.3.2 程序流程图

% ~7 s$ Z% C& Z5 H9 m& S- x
$ T: n, X' P% r) Q/ `
: Z  N! a6 W2 G' V3 ]9 `+ Q图24.3.2.1 内存保护（MPU）实验程序流程图

24.3.3 程序解析
1.MPU驱动代码
这里我们只讲解核心代码，详细的源码请大家参考光盘本实验对应源码。MPU驱动源码包括两个文件：mpu.c和mpu.h。
mpu.h头文件只有函数声明，就不看了，所以我们直接看mpu.c文件，先看设置某个区域的MPU保护函数：

1. /**
   9 J, K$ N/ I, }  n" Y5 i
2. * @brief       设置某个区域的MPU保护
   
3. * @param       baseaddr: MPU保护区域的基址(首地址)
   0 m( e6 E6 }3 S" V6 |: B! O
4. * @param       size:MPU保护区域的大小(必须是32的倍数,单位为字节)
   
5. * @param       rnum:MPU保护区编号,范围:0~7,最大支持8个保护区域
   
6. * @param       de:禁止指令访问;0,允许指令访问;1,禁止指令访问
   
7. * @param       ap:访问权限,访问关系如下:
   4 J7 ?1 c; |5 s3 D
8. *   @arg       0,无访问（特权&用户都不可访问）
   
9. *   @arg       1,仅支持特权读写访问
   
10. *   @arg       2,禁止用户写访问（特权可读写访问）
    ( S' y& u; [& ~
11. *   @arg       3,全访问（特权&用户都可访问）
    % n- r* s( c3 Z! q+ i
12. *   @arg       4,无法预测(禁止设置为4!!!)
    
13. *   @arg       5,仅支持特权读访问
    & O. e- g8 j+ J5 m4 p* I1 {
14. *   @arg       6,只读（特权&用户都不可以写）
    : u6 h4 U% v# L5 [
15. *   @note      详见:STM32H7编程手册.pdf,4.6.6节,Table 91.
    
16. * @param       sen:是否允许共用;0,不允许;1,允许
    
17. * @param       cen:是否允许cache;0,不允许;1,允许
    * P4 G/ v; a- V1 O7 w
18. * @param       ben:是否允许缓冲;0,不允许;1,允许
    
19. * @retval      0, 成功; 1, 错误;
    ) ], _$ ^$ m! G* t" z6 a1 i5 _  k# j7 a
20. */
    ' v; {( \' t# {" u3 B
21. uint8_t mpu_set_protection(uint32_t baseaddr, uint32_t size, uint32_t rnum,
    ( K# |- Y1 C: z) i2 x2 F7 i( s
22. uint8_t de, uint8_t ap, uint8_t sen, uint8_t cen, uint8_t ben)
    8 G6 Y* L$ Q, G, t0 p0 k
23. {
    ; g  I5 Y* M  k- g0 D
24.     MPU_Region_InitTypeDef mpu_region_init_handle;      /* MPU初始化句柄 */
    
25.     HAL_MPU_Disable();              /* 配置MPU之前先关闭MPU,配置完成以后在使能MPU */
    
26. 
    & h( N1 T6 Z" Z3 e; G
27.     mpu_region_init_handle.Enable = MPU_REGION_ENABLE;        /* 使能该保护区域 */
    3 e8 K2 l. D  D+ g! I; k  f
28.     mpu_region_init_handle.Number = rnum;                 /* 设置保护区域 */
    0 q% X& K* `9 V# P) m! F- R* E; z
29.     mpu_region_init_handle.BaseAddress = baseaddr;      /* 设置基址 */
    
30.     mpu_region_init_handle.Size = size;                   /* 设置保护区域大小 */
    2 r  R% h: n, E4 e
31.     mpu_region_init_handle.SubRegionDisable = 0X00;            /* 禁止子区域 */
    
32.     mpu_region_init_handle.TypeExtField =MPU_TEX_LEVEL0;/*设置类型扩展域为level0*/
    4 W: A) E* A; N- M) j
33.     mpu_region_init_handle.AccessPermission = ap;               /* 设置访问权限 */
    , X6 F, e, F' Q& m, D3 r
34.     mpu_region_init_handle.DisableExec = de;                     /* 是否允许指令访问 */
    
35.     mpu_region_init_handle.IsShareable = sen;                    /* 是否允许共用 */
    0 r& a4 T3 X# h9 E
36.     mpu_region_init_handle.IsCacheable = cen;            /* 是否允许cache */
    
37.     mpu_region_init_handle.IsBufferable = ben;           /* 是否允许缓冲 */
    
38.     HAL_MPU_ConfigRegion(&mpu_region_init_handle);              /* 配置MPU */
    7 z2 q0 K6 q* I
39.     HAL_MPU_Enable(MPU_PRIVILEGED_DEFAULT);                      /* 开启MPU */
    . h. o/ c, |/ A: S7 Q( b
40.     return 0;
    
41. }

复制代码

0 ~" ^4 {; n0 L$ Z9 z该函数使用HAL_MPU_ConfigRegion函数对MPU_Region_InitTypeDef结构体变量进行配置。注意：配置之前我们要调用HAL_MPU_Disable函数禁止MPU才能进行配置，最后再调用HAL_MPU_Enable函数开启MPU。
接着，要介绍的是mpu_memory_protection函数，其定义如下：
7 K9 p0 U4 y9 u

1. /**
   ( _( W+ l4 n) H! Y
2. * @brief       设置需要保护的存储块
   $ |4 D5 o8 C* c7 a7 N+ |  n) }* W
3. * @note        必须对部分存储区域进行MPU保护,否则可能导致程序运行异常
   3 \9 ~: z# A/ e! J
4. *              比如MCU屏不显示,摄像头采集数据出错等等问题
   
5. * @param       无
   - Y: r/ J( Y1 g
6. * @retval      nbytes以2为底的指数值
   
7. */
   ( o7 E+ j$ f2 ]$ d6 E) b  `$ q
8. void mpu_memory_protection(void)
   - R- Q- ]2 H- Q: O# u# ~! {5 `6 L
9. {
   $ @9 i. D6 d8 r9 D
10.     /* 保护整个DTCM,共128K字节,允许指令访问,禁止共用,允许cache,允许缓冲 */
    
11. mpu_set_protection(0x20000000, MPU_REGION_SIZE_128KB, MPU_REGION_NUMBER1,
    ! W1 R/ t, Y8 b) J6 P! n; e
12. MPU_INSTRUCTION_ACCESS_ENABLE, MPU_REGION_FULL_ACCESS,
    + N- {3 r1 X: }2 B0 d7 L5 {% T6 c$ ?# k
13. MPU_ACCESS_NOT_SHAREABLE, MPU_ACCESS_CACHEABLE, MPU_ACCESS_BUFFERABLE);
    8 l6 z7 k- }2 g! S( L
14. 
    4 w1 |' N; H) i3 [0 s
15.     /* 保护整个AXI SRAM,共512K字节,允许指令访问,禁止共用,允许cache,允许缓冲 */
    2 W' A7 A. u# R" H* G
16. mpu_set_protection(0x24000000, MPU_REGION_SIZE_512KB,MPU_REGION_NUMBER2,
    & \" ]: a, C" T* \
17. MPU_INSTRUCTION_ACCESS_ENABLE, MPU_REGION_FULL_ACCESS,
    + V4 B. q# i) F5 s
18. MPU_ACCESS_NOT_SHAREABLE, MPU_ACCESS_CACHEABLE, MPU_ACCESS_BUFFERABLE);
    
19. 
    
20.     /* 保护整个SRAM1~SRAM3,共288K字节,允许指令访问,禁止共用,允许cache,允许缓冲 */
    
21. mpu_set_protection(0x30000000, MPU_REGION_SIZE_512KB,MPU_REGION_NUMBER3,
    8 @8 d4 k, Y. b# x
22. MPU_INSTRUCTION_ACCESS_ENABLE, MPU_REGION_FULL_ACCESS,
    7 i/ n+ h- }+ H$ M
23. MPU_ACCESS_NOT_SHAREABLE, MPU_ACCESS_CACHEABLE, MPU_ACCESS_BUFFERABLE);
    
24. 
    
25.     /* 保护整个SRAM4,共64K字节,允许指令访问,禁止共用,允许cache,允许缓冲 */
    , p3 M4 j* U  j: ?
26. mpu_set_protection(0x38000000, MPU_REGION_SIZE_64KB, MPU_REGION_NUMBER4,
    , U' N: ]& {0 k
27. MPU_INSTRUCTION_ACCESS_ENABLE, MPU_REGION_FULL_ACCESS,
    ; U( l" ?7 O" `& Q6 G7 u% S( c
28. MPU_ACCESS_NOT_SHAREABLE, MPU_ACCESS_CACHEABLE, MPU_ACCESS_BUFFERABLE);
    
29. 
    2 o6 z: F* [& G8 Y' O- y1 a* `1 z
30.     /*保护MCU LCD屏所在的FMC区域,,共64M字节,允许指令访问,禁止共用,禁止cache,禁止缓冲*/
    
31. mpu_set_protection(0x60000000, MPU_REGION_SIZE_64MB, MPU_REGION_NUMBER5,
    $ O5 ?' |& c3 I0 S6 }
32. MPU_INSTRUCTION_ACCESS_ENABLE, MPU_REGION_FULL_ACCESS,
    
33. MPU_ACCESS_NOT_SHAREABLE, MPU_ACCESS_NOT_CACHEABLE,
    * L4 Y7 @9 r, N( Z) x5 l
34. MPU_ACCESS_NOT_BUFFERABLE);
    - P# q7 F; I  b& Y
35. 
    
36.     /* 保护SDRAM区域,共64M字节,允许指令访问,禁止共用,允许cache,允许缓冲 */
    
37. mpu_set_protection(0XC0000000, MPU_REGION_SIZE_64MB, MPU_REGION_NUMBER6,
    * a: }/ E" r# S$ A! o
38. MPU_INSTRUCTION_ACCESS_ENABLE, MPU_REGION_FULL_ACCESS,
    
39. MPU_ACCESS_NOT_SHAREABLE, MPU_ACCESS_CACHEABLE, MPU_ACCESS_BUFFERABLE);
    
40. 
    
41.     /* 保护整个NAND FLASH区域,共256M字节,禁止指令访问,禁止共用,禁止cache,禁止缓冲 */
    , ^9 ]5 H  H+ K3 d6 [9 K( G, Y! E$ w
42. mpu_set_protection(0X80000000, MPU_REGION_SIZE_256MB, MPU_REGION_NUMBER7,
    # k4 r4 M# G  G: Q& |) M
43. MPU_INSTRUCTION_ACCESS_DISABLE, MPU_REGION_FULL_ACCESS,
    
44. MPU_ACCESS_NOT_SHAREABLE, MPU_ACCESS_NOT_CACHEABLE,
    ( D7 U6 w- E7 C0 w+ u
45. MPU_ACCESS_NOT_BUFFERABLE);
    % i0 J$ d1 `% I8 j/ O) h
46. }

复制代码

& _& M$ e$ N* r: x1 B( ]: K& b* xmpu_memory_protection函数，用于设置整个代码里面，我们需要保护的存储块，这里我们对7个存储块（使用了7个区域（region））进行了保护：
' g- l/ E" ?7 x3 ~0 `( r5 P1，从0x20000000地址开始的128KB DTCM地址空间，允许指令访问，禁止共用，允许cache，允许缓冲。
2 Y9 u4 Z/ }# D6 E' ?5 z; h+ i2，从0x24000000地址开始的512KB AXI SRAM地址空间，允许指令访问，禁止共用，允许cache，允许缓冲。
3，从0x30000000地址开始的288KB SRAM1~SRAM3地址空间，允许指令访问，禁止共用，允许cache，允许缓冲。
- Y( D. s4 h: q* G2 P1 w4，从0x38000000地址开始的64KB SRAM4地址空间，允许指令访问，禁止共用，允许cache，允许缓冲。
( S! j$ E" u+ p) @0 i5，从0x60000000地址开始的64MB地址空间，允许指令访问，禁止共用，禁止cache，禁止缓冲，保护MCU LCD屏的访问地址取件，如不进行设置，可能导致MCU LCD白屏。
* |, s$ ^0 q2 O6 h6，从0XC0000000地址开始的64MB地址空间，即SDRAM的地址范围，允许指令访问，禁止共用，允许cache，允许缓冲。
& w8 C8 }- b& G$ s7，从0X80000000地址开始的256MB地址空间，即NAND FLASH区域，禁止指令访问，禁止共用，禁止cache，禁止缓冲，如不进行设置，可能导致NAND FLASH访问异常。
这七个地址空间的保护设置，可以提高代码的稳定性（其实就是减少使用cache导致的各种莫名奇妙的问题），请大家不要随意改动。此函数在本例程没有用到，不过我们在后续代码都会用到。
最后，MemManage_Handler函数，用于处理产生MemManage错误的中断服务函数，在该函数里面点亮了LED1，并输出一些串口信息，对系统进行软复位，以便观察本例程的实验结果。函数定义如下：
# A2 E) A3 o7 N( @& F2 h

1. /**
   % O0 M6 Y5 _, f# i9 _9 T
2. * @brief       MemManage错误处理中断
   
3. *   @note      进入此中断以后,将无法恢复程序运行!!
   
4. *
   7 C$ L* j% u& ]" J1 L
5. * @param       无
   " u' y2 p6 g: u# W' L0 }  G
6. * @retval      nbytes以2为底的指数值
   
7. */
   , b9 A2 o: f: j$ w  ~
8. void MemManage_Handler(void)
   ! p* D! ~, M" W: y6 K
9. {
     J: l4 I! d+ P( a; ~$ P
10.     LED1(0);                                       /* 点亮LED1(GREEN LED) */
    
11.     printf("Mem Access Error!!\r\n");         /* 输出错误信息 */
    3 U; Z3 M' a7 f( u- j( [2 n
12.     delay_ms(1000);
    $ Y" G; N; ^& G. K5 |: S
13.     printf("Soft Reseting...\r\n");           /* 提示软件重启 */
    
14.     delay_ms(1000);
    
15.     NVIC_SystemReset();                         /* 软复位 */
    ; \& g) s8 g( [3 G
16. }

复制代码

mpu.c的内容介绍就到此，下面开始main.c文件的介绍。
2. main.c代码
在main.c文件代码如下：
  c- Z, ^. O# F/ b9 O: K7 @9 N  r

1. uint8_t mpudata[128] __attribute__((at(0X20002000)));   /* 定义一个数组 */
   ( w: a& j% }6 S) \4 W2 v
2. 
   " N$ v: C4 t( ~( b" B
3. int main(void)
   
4. {
   
5.     uint8_t key = 0;
   ) t0 K4 j( F5 z! S$ ]2 ]* b2 w
6.     uint8_t t = 0;
   # c; ~5 u9 _( `9 ?0 x9 u& W
7.     sys_cache_enable();                            /* 打开L1-Cache */
   ! E& F( k9 n; ~1 }4 Y2 _5 Q
8.     HAL_Init();                                      /* 初始化HAL库 */
   
9.     sys_stm32_clock_init(240, 2, 2, 4);         /* 设置时钟, 480Mhz */
   
10.     delay_init(480);                                /* 延时初始化 */
    ! k1 \5 B1 [9 j2 ~# e1 w
11.     usart_init(115200);                            /* 串口初始化为115200 */
    4 m' s8 ^1 J1 ^) j+ C7 D5 k
12.     led_init();                                      /* 初始化LED */
    
13.     key_init();                                      /* 初始化按键 */
    - C; r( i3 X$ w2 V& v
14.     printf("\r\n\r\nMPU closed!\r\n");          /* 提示MPU关闭 */
    
15. 
    : i& H2 `1 a% ^4 S8 z  F) x
16.     while (1)
    ) D) B4 d! V' r% U7 A0 J+ a7 z3 }
17.     {
    
18.         key = key_scan(0);
    
19. 
    
20.         if (key == WKUP_PRES)                   /* 使能MPU保护数组 mpudata */
    
21.         {
    
22.             mpu_set_protection(0X20002000, MPU_REGION_SIZE_128B,
    : N+ U. h* o- }5 _% c
23. MPU_REGION_NUMBER0, MPU_REGION_FULL_ACCESS, MPU_REGION_PRIV_RO_URO,
    
24. MPU_ACCESS_NOT_SHAREABLE, MPU_ACCESS_NOT_CACHEABLE,
    
25. MPU_ACCESS_BUFFERABLE);           /* 只读,禁止共用,禁止catch,允许缓冲 */
    
26.             printf("MPU open!\r\n");            /* 提示MPU打开 */
    
27.         }
    
28. /* 向数组中写入数据，如果开启了MPU保护的话会进入内存访问错误！ */
    6 F+ v9 J- _( ]; d* J( Q8 Y( q
29.         else if (key == KEY0_PRES)
    
30.         {
    & }. u: l6 b. U0 Y. ~6 s6 j1 l
31.             printf("Start Writing data...\r\n");
    
32.             sprintf((char *)mpudata, "MPU test array %d", t);
    " r+ v6 |( w7 @) a. a. z
33.             printf("Data Write finshed!\r\n");
    - i& b! f8 q9 ^2 g* z( f
34.         }
    & p/ e# D, K( I' z' K6 R
35. /* 从数组中读取数据，不管有没有开启MPU保护都不会进入内存访问错误！ */
    6 M' z# h! {" w6 t0 l. o% X
36.         else if (key == KEY1_PRES)      
    
37.         {
    
38.             printf("Array data is:%s\r\n", mpudata);
    
39.         }
    2 I2 n7 O; Y1 v7 r3 }2 ?
40.         else
    
41.         {
    ) H, j. h+ }/ ^
42.             delay_ms(10);
    # c. P0 u: R' U& z5 U
43.         }
    5 L' D6 i1 C  B
44. 
    3 r$ t& x( ]" Z8 E2 W) }8 R
45.         t++;
    - o7 o, ^/ G) @1 @
46. 
    
47.         if ((t % 50) == 0) LED0_TOGGLE();   /* LED0取反 */
    9 a" D7 Q" _, A4 D9 I# l2 u
48.     }
    6 ]# {! X) u  e0 f
49. }
    # ^! R$ S1 Q9 |" N4 u) ]

复制代码

在main函数前面，我们定义了一个128字节大小的数组：mpudata，其首地址为0X20002000，默认情况下，MPU保护关闭，可以对该数组进行读写访问。当我们按下KEY_UP按键的时候，通过mpu_set_protection函数，对其0X20002000为起始地址，大小为128字节的内存空间进行保护，仅支持特权读访问，此时如果再按KEY0，对数组进行写入操作，则会引起MemManage访问异常，进入MemManage_Handler中断服务函数，执行相关操作。
: U) t8 C, T9 g- t其他的代码比较简单，这里就不多做说明了，在整个代码编译通过之后，我们就可以开始下载验证了。
2 ]) U; }/ P' B7 I9 C- ?24.4 下载验证
. M$ C) a% `6 J3 z" C8 C下载代码后，LED0不停的闪烁，提示程序已经在运行了。然后，打开串口调试助手（XCOM V2.6），设置串口为开发板的USB转串口（CH340虚拟串口，得根据你自己的电脑选择，我的电脑是COM8，另外，请注意：波特率是115200），可以看到如图24.4.1所示信息（如果没有提示信息，请先按复位）：

  F% I- |2 }0 k6 c& g3 e$ ~3 ~

图24.4.1 复位后串口调试助手收到的信息
, s+ s2 R7 L. b. @; }7 W/ a从图24.4.1可以看出，此时串口助手提示：MPU Closed，即MPU保护是关闭的，我们可以按KEY0往数组里面写入数据，按KEY1，可以读取刚刚写入的数据，按KEY_UP，则开启MPU保护，提示：MPU open!，此时，如果再按KEY0，往数组里面写数据的话，则会引起MemManage访问异常，进入MemManage_Handler中断服务函数，点亮LED1，并提示：Mem Access Error!!，并在1秒钟以后，重启系统（软复位），如图24.4.2所示：

5 B9 ]& e( G3 D; ]6 d( @

图24.4.2 串口调试助手显示运行结果
整个过程，验证了我们代码的正确性，通过MPU实现了对特定内存的写保护功能。通过MPU，我们可以提高系统的可靠性，使代码更加安全的运行。
————————————————
版权声明：正点原子
! c: t: |' \) q8 Q
: ~/ K) p. i. V$ }/ G# v