23.1 初学者重要提示
8 ]% x% d/ y+ P" [  本章节主要是为下一章Cache的讲解做个铺垫，需要初学者把本章节涉及到的基础知识点掌握了。
  初学MPU时，可能有些知识点无法一下子就搞明白，在后续章节的各种应用后，会有一个较深的认识。这个知识点基本会贯穿整个教程。
23.2 MPU简介
MPU可以将memory map内存映射区分为多个具有一定访问规则的区域，通过这些规则可以实现如下功能：

  防止不受信任的应用程序访问受保护的内存区域。
9 `4 H. Z  q6 D  ?  防止用户应用程序破坏操作系统使用的数据。
  通过阻止任务访问其它任务的数据区。
  允许将内存区域定义为只读，以便保护重要数据。
  检测意外的内存访问。
+ j$ ]  Y& P  O% l6 c- n& Y. H简单的说就是内存保护、外设保护和代码访问保护。
# p( i1 I/ P! \% H8 v; J
内存映射
" X2 Z4 G+ t1 m. r2 i内存映射就是32位的CM7内核整体可以寻址的0 到2^32 -1共计4GB的寻址空间。通过这些地址可以访问RAM、Flash、外设等。下面是内存映射的轮廓图，IC厂家使用时，再做细分，添加相应的硬件功能。

' E7 z$ i- Y* L* \4 J* `

23.3 MPU的功能实现
' E$ P( f6 u- z' a; SMPU可以配置保护16个内存区域（这16个内存域是独立配置的），每个区域最小要求256字节，每个区域还可以配置为8个子区域。由于子区域一般都相同大小，这样每个子区域的大小就是32字节，正好跟Cache的Cache Line大小一样。
, W$ B3 m" {/ w/ j
MPU可以配置的16个内存区的序号范围是0到15，还有默认区 default region，也叫作背景区，序号-1。由于这些内存区可以嵌套和重叠，所以这些区域在嵌套或者重叠的时候有个优先级的问题。序号15的优先级最高，以此递减，序号-1，即背景区的优先级最低。这些优先级是固定的。

下面通过一个具体的实例帮助大家理解。如下所示共有7个区，背景区和序号0-5的区。内存区4跟内存区0和1有重叠部分，那么重叠部分将按照内存区4的配置规则执行；内存区5被完全包含在内存区3里面，那么这部分内存区将按照内存区5的配置规则执行。

4 L* q/ ?% N3 {# Q
23.4 MPU可以配置的三种内存类型
MPU可以配置的三种内存类型如下：
7 I! ?( U% D; I- N3 C
, Y% P) P* A9 i4 ~9 O  Normal memory
* o& W" e# e# N
, t2 }' i1 L& u8 T; @CPU以最高效的方式加载和存储字节、半字和字，对于这种内存区，CPU的加载或存储不一定要按照程序列出的顺序执行。

  Device memory

1 t. a0 [3 j$ j. }+ B  O对于这种类型的内存区，加载和存储要严格按照次序进行，这样是为了确保寄存器按照正确顺序设置。
8 @; x% t8 r1 ]0 a5 W* P9 d& u
/ G4 L% m$ X5 x0 [4 U3 i$ B  Strongly ordered memory

程序完全按照代码顺序执行，CPU需要等待当前的加载/存储指令执行完毕后才执行下一条指令。这样会导致性能下降。

0 o2 I- i/ f. D- U5 V. f( z" K- P5 c23.5 MPU的寄存器和对应的库参数
/ i6 {+ [0 W3 \+ j7 @7 h关于MPU的寄存器介绍在STM32H7的编程手册有专门的讲解说明，我们这里重点讲解寄存器MPU_RASR和控制寄存器，此寄存器的定义如下：
% P6 L/ k0 |7 ~6 [
  \/ M% l7 t6 S2 Z9 [

23.5.1 RASR寄存器的XN位
2 d. ?+ Q, y% ~2 ]( g* _XN=0表示使能指令提取，即这块内存区可以执行程序代码，XN=1表示禁止指令提取，即这块内存区禁止执行程序代码。

对应的HAL库MPU参数如下：
) M& B4 ]/ T/ ]3 ~

1. /** @defgroup CORTEX_MPU_Instruction_Access CORTEX MPU Instruction Access
   
2.   * @{
   $ ^' r7 {5 R1 \. ^5 O9 G, Z
3.   */
   * z  F$ u+ Q- G9 T+ l
4. #define  MPU_INSTRUCTION_ACCESS_ENABLE      ((uint8_t)0x00)
   
5. #define  MPU_INSTRUCTION_ACCESS_DISABLE     ((uint8_t)0x01)

复制代码

23.5.2 RASR寄存器的AP位
AP的具体定义如下：

; p! h; G/ G5 \" b+ x6 V  Q
0 c# D6 e8 u6 a. z8 u+ l# I: W7 }这几个参数对应的HAL库MPU参数如下：
  U2 d+ ?+ G( F1 J& D
& {* z: e6 W% s& f# p, ]

1. /** @defgroup CORTEX_MPU_Region_Permission_Attributes CORTEX MPU Region Permission Attributes
     h8 T( F$ }* j( d8 i% t/ s+ b2 b
2.   * @{
   
3.   */
   
4. #define  MPU_REGION_NO_ACCESS      ((uint8_t)0x00)
     e3 q- J+ ?; v
5. #define  MPU_REGION_PRIV_RW        ((uint8_t)0x01)
   + r  `& C& Y9 i7 a# I' W4 |
6. #define  MPU_REGION_PRIV_RW_URO    ((uint8_t)0x02)
   
7. #define  MPU_REGION_FULL_ACCESS    ((uint8_t)0x03)
   / M' V5 p" `2 P1 Q
8. #define  MPU_REGION_PRIV_RO        ((uint8_t)0x05)
   
9. #define  MPU_REGION_PRIV_RO_URO    ((uint8_t)0x06)

复制代码

3 p% g3 Z3 w6 I" c9 S3 \2 a23.5.3 RASR寄存器的TEX，C，B和S位
（注，这几个位非常重要，当前先了解知识点即可，下个章节专门讲解具体的作用）
! a% S) `0 S+ Q7 `
6 O! K6 I! O0 h. iTEX，C，B和S的定义如下，这仅关注TEX = 0b000和0b001，其它的TEX配置基本用不到。
' d8 k! n7 H+ p4 h5 }" q

TEX用于配置Cache策略，支持如下四种情况，需要配合C和B位的配置才能实现。

# s, Z3 S- D9 V# {$ f+ P

2 j# s9 w0 t1 c( k& u; h" K' _7 O( f% s
& l5 V; f- L) c; w7 Y, h. rTEX对应的HAL库MPU参数给了三个，实际应用中仅用到前两个MPU_TEX_LEVEL0和MPU_TEX_LEVEL1
3 U& T4 e/ \7 P
  B9 z; R. D! D3 ~

1. /** @defgroup CORTEX_MPU_TEX_Levels MPU TEX Levels
   . d, \4 N# G. E; g1 S  V
2.   * @{
   . L+ q& l9 y  A- A; X+ P
3.   */
   
4. #define  MPU_TEX_LEVEL0    ((uint8_t)0x00)
   2 b# E9 C) k- L9 Z
5. #define  MPU_TEX_LEVEL1    ((uint8_t)0x01)
   % a& l# m# A; M, B3 l9 M
6. #define  MPU_TEX_LEVEL2    ((uint8_t)0x02)

复制代码

C位对应的HAL库MPU参数如下，用于使能或者禁止Cache。

$ Z: i& p# s$ m: M* Z! B! ?! e" L

1. /** @defgroup CORTEX_MPU_Access_Cacheable CORTEX MPU Instruction Access Cacheable
   + T0 d2 |+ [- l. [
2.   * @{
   7 q2 c1 t8 |0 i, J# l
3.   */
   
4. #define  MPU_ACCESS_CACHEABLE         ((uint8_t)0x01)
   
5. #define  MPU_ACCESS_NOT_CACHEABLE     ((uint8_t)0x00)

复制代码

/ b6 x2 b' m  y( z7 ^3 f$ zB位对应的HAL库MPU参数如下，用于配合C位实现Cache模式下是否使用缓冲。

2 X, y) l7 v( p

1. /** @defgroup CORTEX_MPU_Access_Bufferable CORTEX MPU Instruction Access Bufferable
   
2.   * @{
   ( }0 N+ @8 }2 W  {
3.   */
   
4. #define  MPU_ACCESS_BUFFERABLE         ((uint8_t)0x01)
   
5. #define  MPU_ACCESS_NOT_BUFFERABLE     ((uint8_t)0x00)

复制代码

: Q% Z$ J2 |/ ^* ]2 Z  b7 m6 XS位对应的HAL库MPU参数如下，用于解决多总线或者多核访问的共享问题。

1. /** @defgroup CORTEX_MPU_Access_Shareable CORTEX MPU Instruction Access Shareable
   
2.   * @{
   2 Q: j1 m# l6 v* ]
3.   */
   5 r* b- T+ G1 [& |
4. #define  MPU_ACCESS_SHAREABLE        ((uint8_t)0x01)
   # b7 U; s& T* L0 h  D  B# L5 W
5. #define  MPU_ACCESS_NOT_SHAREABLE    ((uint8_t)0x00)

复制代码

23.5.4 RASR寄存器的SRD位
这个位用于控制内存区的子区域，使用的是bit[15:8]，共计8个bit，一个bit控制一个子区域，0表示使能此子区域，1表示禁止此子区域。

一般情况，基本不使用子区域的禁止功能，所以配置HAL库的SubRegionDisable参数时，直接取值0x00即可，表示8个子区域均使能。

( \! w1 S  m0 @" o- L, M23.5.5 RASR寄存器的SIZE位
SIZE位使用的是bit[5:1]，共计5个bit，可以表示2^5 = 32种大小。 对应的HAL库给出了可以配置的28个参数：
6 a) ]$ _+ u  v) z
* X: R  Y7 n8 D4 I% v/ Y! v

1. /** @defgroup CORTEX_MPU_Region_Size CORTEX MPU Region Size
   ( ]1 \1 I* T. [3 l; O
2.   * @{
   
3.   */
   ! ]4 m1 K4 r5 ]% y+ V: V' U
4. #define   MPU_REGION_SIZE_32B      ((uint8_t)0x04)
   ! v4 s, x! d9 L( E: c' J! m
5. #define   MPU_REGION_SIZE_64B      ((uint8_t)0x05)
   9 Z* z' m& _" E& K9 O5 _2 g
6. #define   MPU_REGION_SIZE_128B     ((uint8_t)0x06)
   
7. #define   MPU_REGION_SIZE_256B     ((uint8_t)0x07)
   
8. #define   MPU_REGION_SIZE_512B     ((uint8_t)0x08)
   
9. #define   MPU_REGION_SIZE_1KB      ((uint8_t)0x09)
   $ n; Z: e8 W8 N' G1 I
10. #define   MPU_REGION_SIZE_2KB      ((uint8_t)0x0A)
    
11. #define   MPU_REGION_SIZE_4KB      ((uint8_t)0x0B)
    $ j" B+ [2 s8 ~3 p7 q- H
12. #define   MPU_REGION_SIZE_8KB      ((uint8_t)0x0C)
    " C+ N* ]# m& x" R3 k1 \7 T0 F
13. #define   MPU_REGION_SIZE_16KB     ((uint8_t)0x0D)
    8 `8 p5 e$ w2 w3 p. ]' g
14. #define   MPU_REGION_SIZE_32KB     ((uint8_t)0x0E)
    
15. #define   MPU_REGION_SIZE_64KB     ((uint8_t)0x0F)
    
16. #define   MPU_REGION_SIZE_128KB    ((uint8_t)0x10)
    7 {, N* D5 V3 I* b; `; [, k
17. #define   MPU_REGION_SIZE_256KB    ((uint8_t)0x11)
    $ o% t+ G" y2 d' T
18. #define   MPU_REGION_SIZE_512KB    ((uint8_t)0x12)
    
19. #define   MPU_REGION_SIZE_1MB      ((uint8_t)0x13)
    
20. #define   MPU_REGION_SIZE_2MB      ((uint8_t)0x14)
    
21. #define   MPU_REGION_SIZE_4MB      ((uint8_t)0x15)
    
22. #define   MPU_REGION_SIZE_8MB      ((uint8_t)0x16)
    & {. g, b; m# _. x( B' y
23. #define   MPU_REGION_SIZE_16MB     ((uint8_t)0x17)
    5 h7 e9 a, F, b( n4 q* z. C3 @3 {" C
24. #define   MPU_REGION_SIZE_32MB     ((uint8_t)0x18)
    
25. #define   MPU_REGION_SIZE_64MB     ((uint8_t)0x19)
    
26. #define   MPU_REGION_SIZE_128MB    ((uint8_t)0x1A)
    
27. #define   MPU_REGION_SIZE_256MB    ((uint8_t)0x1B)
    / w8 Q+ P8 ]7 P, p1 B- H+ @
28. #define   MPU_REGION_SIZE_512MB    ((uint8_t)0x1C)
    
29. #define   MPU_REGION_SIZE_1GB      ((uint8_t)0x1D)
    $ X7 _( ]8 E' L, i2 J( }
30. #define   MPU_REGION_SIZE_2GB      ((uint8_t)0x1E)
    
31. #define   MPU_REGION_SIZE_4GB      ((uint8_t)0x1F)

复制代码

* L3 w# y& g: N7 A% v9 C23.5.6 CTRL寄存器的各个位
控制寄存器各个位定义如下如下：
/ [- y  j; e, |! B& B1 {4 T/ _

* m0 y+ g  S( k+ O6 v  U3 P0 H2 h
9 z7 x9 ]7 m8 x6 C23.6 MPU的配置函数
$ Q4 O% ?3 O. d; F$ j1 HHAL库的stm32h7xx_hal_cortex.c文件为MPU的配置提供了三个函数：
! E6 d4 ?' u2 Z' z: K2 O1 ]% ~- m
, n; }3 L6 x7 {; y0 H/ h  HAL_MPU_Disable
2 Z- R/ t  d' s- ~  HAL_MPU_Enable
) Y$ O( o: c; N( l+ |) B1 |  HAL_MPU_ConfigRegion
  Z7 ^. d, J2 S6 \6 M& R; T2 N
: p) G5 T1 y: W, ~. ]
三个函数的使用都比较简单，但是要让配置的内存区最大限度的发挥性能是需要大量的经验积累和测试的。具体工程要具体分析。

* [  L* G' j7 F. K+ r9 c% Q, L23.6.1 函数HAL_MPU_Disable
函数原型：

  t) v0 y! v' Q  c9 k

1. void HAL_MPU_Disable(void)
   6 ^( ]$ h' S- v$ n. q
2. {
   
3.   /* Make sure outstanding transfers are done */
   
4.   __DMB();
   3 f! x  _" J1 T3 M. z9 c' F
5. 
   2 W: v: ^9 m8 x  H# |) n/ r3 _  L4 M
6.   /* Disable fault exceptions */
   , c0 j! Y+ C1 d! ~/ q
7.   SCB->SHCSR &= ~SCB_SHCSR_MEMFAULTENA_Msk;
   
8. 
   / P& V2 `3 |* O  D9 T0 _& B/ W- t
9.   /* Disable the MPU and clear the control register*/
   
10.   MPU->CTRL = 0;
    : f, F% Z: I6 F) O' k
11. }

复制代码

$ L2 W! I% f$ Q# T* U9 ~函数描述：
+ X! m4 P% _9 U" _& X& }; l) S
此函数用于禁止MPU。配置MPU前要优先调用此函数禁止MPU，然后才可以配置。

+ ^( `  `8 |5 [+ y3 _% B9 S23.6.2 函数HAL_MPU_Enable
- U. s% |+ R! C2 g函数原型：
/ ?' K' t) |1 l- u

1. void HAL_MPU_Enable(uint32_t MPU_Control)
   
2. {
   
3.   /* Enable the MPU */
   
4.   MPU->CTRL = MPU_Control | MPU_CTRL_ENABLE_Msk;
   
5. 
   
6.   /* Enable fault exceptions */
   ' P) _4 c/ e: I) l  N& @) k
7.   SCB->SHCSR |= SCB_SHCSR_MEMFAULTENA_Msk;
   : a$ o1 e8 @) o- _8 [4 W/ t* t
8. 
   
9.   /* Ensure MPU setting take effects */
   
10.   __DSB();
    
11.   __ISB();
    9 d2 d! o6 l+ l0 i
12. }

复制代码

# y7 e" P1 V1 Z  U6 i$ ~9 ^) F: i函数描述：
) s$ p$ {5 F) k$ g9 S' r
此函数用于使能MPU，一般情况使用参数MPU_PRIVILEGED_DEFAULT。
& }* a8 B8 [( d
函数参数：
3 S6 P7 i; y7 \& O  L! Z/ C% Y
" c7 l0 \8 M6 b4 m/ c此函数支持以下几个参数：

/ L2 A, u) M' c9 i1、  MPU_HFNMI_PRIVDEF_NONE   ((uint32_t)0x00000000)
" p# b3 v( B8 z1 T- f4 X8 x- u6 Z
  此参数设置MPU的CTL控制寄存器的PRIVDEFENA位为0。
表示禁止了背景区，访问任何未使能MPU的区域均会造成内存异常MemFault。

  此参数设置MPU的CTL控制寄存器的HFNMIENA位为0。
表示NMI不可屏蔽中断服务程序和硬件异常中断服务程序执行期间会关闭MPU。
1 T1 G( D  \5 `
/ I9 `* A7 v' }% b- Q3 E  z2、  MPU_HARDFAULT_NMI           ((uint32_t)0x00000002)

  此参数设置MPU的CTL控制寄存器的PRIVDEFENA位为0。
7 v  |5 f9 `3 H: o1 f表示禁止了背景区，访问任何未使能MPU的区域均会造成内存异常MemFault。

3 Y! m. @9 e  j7 X' ~  此参数设置MPU的CTL控制寄存器的HFNMIENA位为1。
表示NMI不可屏蔽中断服务程序和硬件异常中断服务程序执行期间会保持继续开启MPU。
1 ^8 j; b7 `6 l
; `! Y) d% e7 S& D  u3、  MPU_PRIVILEGED_DEFAULT      ((uint32_t)0x00000004)

! q& J! z* Z' q0 P0 y: y) S( {  此参数设置MPU的CTL控制寄存器的PRIVDEFENA位为1。
表示使能了背景区，特权级模式可以正常访问任何未使能MPU的区域。
+ Y0 z( c7 O- F. n% \
+ H6 P: v& i+ B8 \7 I  此参数设置MPU的CTL控制寄存器的HFNMIENA位为0。
9 W& g  Z9 S4 C! T6 T表示NMI不可屏蔽中断服务程序和硬件异常中断服务程序执行期间会关闭MPU。

1 U9 _) }8 Z# {  A4、  MPU_HFNMI_PRIVDEF           ((uint32_t)0x00000006)

  此参数设置MPU的CTL控制寄存器的PRIVDEFENA位为1。
! D7 l+ \; E- O. ^表示禁止了背景区，访问任何未使能MPU的区域均会造成内存异常MemFault。

, B% ]1 Q/ ~7 ?8 Z! j  此参数设置MPU的CTL控制寄存器的HFNMIENA位为1。
% P7 q0 \/ o, E1 M- Q表示NMI不可屏蔽中断服务程序和硬件异常中断服务程序执行期间会保持继续开启MPU。
7 t* y8 g8 }- [2 g7 w+ q
23.6.3 函数HAL_MPU_ConfigRegion
函数原型：

1. void HAL_MPU_ConfigRegion(MPU_Region_InitTypeDef *MPU_Init)
   $ V; N: w2 h: p5 i
2. {
   
3.   /* Check the parameters */
   
4.   assert_param(IS_MPU_REGION_NUMBER(MPU_Init->Number));
   
5.   assert_param(IS_MPU_REGION_ENABLE(MPU_Init->Enable));
     ]& ^( V; l2 u5 W
6. 
     F2 o( f2 l/ |4 k2 A0 `9 E1 |
7.   /* Set the Region number */
   
8.   MPU->RNR = MPU_Init->Number;
   
9. 
   ! q5 x; _* q6 w$ ~5 n# ?4 s
10.   if ((MPU_Init->Enable) != RESET)
    7 i3 J5 E! r4 f2 |) i3 k
11.   {
    
12.     /* Check the parameters */
    & W2 |9 `7 L# _* o6 ?4 j  Z
13.     assert_param(IS_MPU_INSTRUCTION_ACCESS(MPU_Init->DisableExec));
    ( }/ V4 k! }$ ~8 _' }
14.     assert_param(IS_MPU_REGION_PERMISSION_ATTRIBUTE(MPU_Init->AccessPermission));
    $ n) |5 ]& t& U2 p5 w' S
15.     assert_param(IS_MPU_TEX_LEVEL(MPU_Init->TypeExtField));
    
16.     assert_param(IS_MPU_ACCESS_SHAREABLE(MPU_Init->IsShareable));
    - v, \$ G9 _  r' g. C
17.     assert_param(IS_MPU_ACCESS_CACHEABLE(MPU_Init->IsCacheable));
    
18.     assert_param(IS_MPU_ACCESS_BUFFERABLE(MPU_Init->IsBufferable));
    
19.     assert_param(IS_MPU_SUB_REGION_DISABLE(MPU_Init->SubRegionDisable));
    
20.     assert_param(IS_MPU_REGION_SIZE(MPU_Init->Size));
    
21. 
    
22.     MPU->RBAR = MPU_Init->BaseAddress;
    
23.     MPU->RASR = ((uint32_t)MPU_Init->DisableExec             << MPU_RASR_XN_Pos)   |
    
24.                 ((uint32_t)MPU_Init->AccessPermission        << MPU_RASR_AP_Pos)   |
    / q8 L/ r6 o/ F# K1 l4 ]
25.                 ((uint32_t)MPU_Init->TypeExtField            << MPU_RASR_TEX_Pos)  |
    # @% x8 B! P- C8 G% b2 m6 Q# C- R& e
26.                 ((uint32_t)MPU_Init->IsShareable             << MPU_RASR_S_Pos)    |
    $ n; W( a: q: ]3 k, D" X* ?
27.                 ((uint32_t)MPU_Init->IsCacheable             << MPU_RASR_C_Pos)    |
    " L7 B8 M' S  s
28.                 ((uint32_t)MPU_Init->IsBufferable            << MPU_RASR_B_Pos)    |
    
29.                 ((uint32_t)MPU_Init->SubRegionDisable        << MPU_RASR_SRD_Pos)  |
    
30.                 ((uint32_t)MPU_Init->Size                    << MPU_RASR_SIZE_Pos) |
    
31.                 ((uint32_t)MPU_Init->Enable                  << MPU_RASR_ENABLE_Pos);
    / X" L) Z3 W# G7 a% \2 X1 W( E
32.   }
    
33.   else
    
34.   {
    
35.     MPU->RBAR = 0x00;
    : P8 V/ u3 Z- h* }9 O9 n7 ~% [8 E
36.     MPU->RASR = 0x00;
    , p1 k/ O% N) t6 k8 L5 n
37.   }
    
38. }

复制代码

函数描述：

此函数用于配置MPU。

: W" s8 H+ X1 w5 \) o函数参数：

3 d: I9 i6 n3 S& w# j$ j1 c此函数的形参是一个MPU_Region_InitTypeDef类型的结构体变量，定义如下：

1. typedef struct
   5 n2 H9 @8 n$ g
2. {
   
3.   uint8_t                Enable;            
   
4.   uint8_t                Number;               
   % U" M! M) X& c1 a, K
5.   uint32_t               BaseAddress;        
   
6.   uint8_t                Size;                 
   
7.   uint8_t                SubRegionDisable;     
   
8.   uint8_t                TypeExtField;         
   * Q1 W6 x- B+ u# T  a& l: g  A7 e$ r
9.   uint8_t                AccessPermission;   
   3 |# @8 {7 Y1 |! [& {! z+ t
10.   uint8_t                DisableExec;           
    ! p& ^) T& {0 Z2 G6 M
11.   uint8_t                IsShareable;         
    
12.   uint8_t                IsCacheable;         
    1 z5 q$ d# Q8 [
13.   uint8_t                IsBufferable;        
    
14. }MPU_Region_InitTypeDef;

复制代码

, m3 b6 a7 x3 _除了参数Number和BaseAddress，其它几个参数在本章23.5小节进行了说明。

% o7 R: |/ Q. W9 g" m  结构体成员Number
' k0 N1 G7 S5 d: V9 a
$ ?6 X4 c, K7 a8 p4 u, Q这个成员是用来设置内存区序号的，用户配置的时候，推荐从Number0开始配置，最多到Number15，共计16个。对应的HAL库参数如下：

1. /** @defgroup CORTEX_MPU_Region_Number CORTEX MPU Region Number
   
2.   * @{
   7 d+ K1 Q8 o( x% n; m, P1 n
3.   */
   
4. #define  MPU_REGION_NUMBER0    ((uint8_t)0x00)
   8 R& p  u  L& l
5. #define  MPU_REGION_NUMBER1    ((uint8_t)0x01)
   
6. #define  MPU_REGION_NUMBER2    ((uint8_t)0x02)
   ( z# W, q% N3 c* u* R
7. #define  MPU_REGION_NUMBER3    ((uint8_t)0x03)
   
8. #define  MPU_REGION_NUMBER4    ((uint8_t)0x04)
   
9. #define  MPU_REGION_NUMBER5    ((uint8_t)0x05)
   , w; j0 y& k5 I9 r
10. #define  MPU_REGION_NUMBER6    ((uint8_t)0x06)
    
11. #define  MPU_REGION_NUMBER7    ((uint8_t)0x07)
    
12. #define  MPU_REGION_NUMBER8    ((uint8_t)0x08)
    
13. #define  MPU_REGION_NUMBER9    ((uint8_t)0x09)
    
14. #define  MPU_REGION_NUMBER10   ((uint8_t)0x0A)
    
15. #define  MPU_REGION_NUMBER11   ((uint8_t)0x0B)
    
16. #define  MPU_REGION_NUMBER12   ((uint8_t)0x0C)
    
17. #define  MPU_REGION_NUMBER13   ((uint8_t)0x0D)
    
18. #define  MPU_REGION_NUMBER14   ((uint8_t)0x0E)
    ; L* T/ N; C4 s3 U& w) C% k) b# E
19. #define  MPU_REGION_NUMBER15   ((uint8_t)0x0F)

复制代码

  结构体成员BaseAddress
) p1 e' y. Q. l- T; b
/ A4 u* ?& `' E2 C  w4 [这个结构体成员用来设置内存区的首地址。这个参数跟结构体成员Size的配置是比较考究的，一定要保证首地址跟内存区的大小对齐，比如配置的是64KB大小的内存区，那么设置的首地址务必是64KB对齐的，也就是这个地址对64KB，即0x00010000求余数等于0，切记。
' r+ I0 V" W! d- b2 r* R
' ?$ K( s: W! m使用举例：
1 W; |- _* D7 b
% o$ f# y5 h6 v7 P9 G  f  S下面配置了两组。

! z1 |- q( v& V! F3 c, V

1. /*
   
2. *********************************************************************************************************
   . g. `" y: [- E. M+ m6 }
3. *        函 数 名: MPU_Config
   
4. *        功能说明: 配置MPU
   
5. *        形    参: 无
   
6. *        返 回 值: 无
   
7. *********************************************************************************************************
     @: j7 F2 m$ E# W
8. */
   ! {6 I% C/ L5 M9 z% s% r
9. static void MPU_Config( void )
   
10. {
    8 S( ~( X4 j+ F# F* ]' g8 {4 t
11.         MPU_Region_InitTypeDef MPU_InitStruct;
    6 W8 q2 i6 E2 e; p( H! N0 C* {0 g+ h
12. 
    
13.         /* 禁止 MPU */
    6 R$ G6 Z5 t' `- @  }
14.         HAL_MPU_Disable();
    
15. 
    1 u' W6 J: D* ^8 l" D
16.         /* 配置AXI SRAM的MPU属性为Write back, Read allocate，Write allocate */
    . y$ u1 O% z6 ]( H7 n4 e: E+ q
17.         MPU_InitStruct.Enable           = MPU_REGION_ENABLE;
    
18.         MPU_InitStruct.BaseAddress      = 0x24000000;
    
19.         MPU_InitStruct.Size             = MPU_REGION_SIZE_512KB;
    6 X; S9 s: @: V9 o+ f: R
20.         MPU_InitStruct.AccessPermission = MPU_REGION_FULL_ACCESS;
    0 Y( v& i0 r, v  q9 h* Z' e& p
21.         MPU_InitStruct.IsBufferable     = MPU_ACCESS_BUFFERABLE;
    
22.         MPU_InitStruct.IsCacheable      = MPU_ACCESS_CACHEABLE;
    
23.         MPU_InitStruct.IsShareable      = MPU_ACCESS_NOT_SHAREABLE;
    2 t" l. j7 f( @
24.         MPU_InitStruct.Number           = MPU_REGION_NUMBER0;
    8 B, C1 g# i6 t( }; T: G$ Q
25.         MPU_InitStruct.TypeExtField     = MPU_TEX_LEVEL1;
    
26.         MPU_InitStruct.SubRegionDisable = 0x00;
    / N2 O2 }; B4 x
27.         MPU_InitStruct.DisableExec      = MPU_INSTRUCTION_ACCESS_ENABLE;
    # A# _) u8 m( @) y" P4 f7 E9 H) ]& s3 v
28. 
    $ a! q2 E! _1 {# N
29.         HAL_MPU_ConfigRegion(&MPU_InitStruct);
    6 y) t$ u  }8 l5 b4 `
30.         
    
31.         
    $ G6 k3 a- _9 @1 z0 t" M7 D5 _
32.         /* 配置FMC扩展IO的MPU属性为Device或者Strongly Ordered */
    3 x0 l1 c9 ]. Y+ y" s
33.         MPU_InitStruct.Enable           = MPU_REGION_ENABLE;
    
34.         MPU_InitStruct.BaseAddress      = 0x60000000;
    
35.         MPU_InitStruct.Size             = ARM_MPU_REGION_SIZE_64KB;        
    
36.         MPU_InitStruct.AccessPermission = MPU_REGION_FULL_ACCESS;
    # i/ t: t! o1 U+ a. E( i
37.         MPU_InitStruct.IsBufferable     = MPU_ACCESS_BUFFERABLE;
    
38.         MPU_InitStruct.IsCacheable      = MPU_ACCESS_NOT_CACHEABLE;        
    : c; ^5 x1 k# L. j
39.         MPU_InitStruct.IsShareable      = MPU_ACCESS_NOT_SHAREABLE;
    
40.         MPU_InitStruct.Number           = MPU_REGION_NUMBER1;
    
41.         MPU_InitStruct.TypeExtField     = MPU_TEX_LEVEL0;
    
42.         MPU_InitStruct.SubRegionDisable = 0x00;
    
43.         MPU_InitStruct.DisableExec      = MPU_INSTRUCTION_ACCESS_ENABLE;
    
44.         
    
45.         HAL_MPU_ConfigRegion(&MPU_InitStruct);
    
46. 
    - s! f: b7 |6 Y, `
47.         /*使能 MPU */
    ; D4 p, m5 V' J  y4 q, N
48.         HAL_MPU_Enable(MPU_PRIVILEGED_DEFAULT);
    3 \7 @0 I$ n& j* Z
49. }

复制代码

23.7 总结
本章节就为大家讲解这么多，还是本章开头那句话，可能有些知识点无法一下子就搞明白，在学习了后续章节的各种应用后，会有一个较深的认识。
. G' y) D- B; ]2 U" A1 e1 g