71.1 初学者重要提示
  学习本章节前，务必优先学习第70章。
  使用内部Flash模拟EEPROM，务必告诉编译要使用的存储空间，防止这个空间存入了程序。
  STM32H7的Flash编程时，务必保证要编程的地址是32字节对齐的，即此地址对32求余为0。并且编程的数据必须32字节整数倍。
5 _% @. L, B8 I( f. p# D  STM32H743XI有两个独立的BANK，一个BANK的编程和擦除操作对另一个BANK没有任何影响。但是用户应用程序和要擦写的Flash扇区在同一个BANK，在执行擦写操作时，应用应用程序将停止运行，包括中断服务程序。
  使用内部Flash模拟EEPROM要做到先擦除后使用。
71.2 模拟EEPROM驱动设计
* o6 Q/ ^+ N& ^5 d0 [这里重点把内部Flash的读取，编程和擦除做个说明。
! `6 L0 `, r2 r$ G9 P0 S
71.2.1 内部Flash擦除的实现
内部Flash的擦除思路如下：
. o$ g, e% ~& ?8 k
$ D! T8 B* v7 c( A" N3 g0 w  第1步，获取擦除地址所处的扇区。
  第2步，调用函数HAL_FLASH_Unlock解锁。
  第3步，调用函数HAL_FLASHEx_Erase擦除一个扇区。
  第4步，调用函数HAL_FLASH_Lock上锁。
5 N1 k) A2 g3 ^' P按照这个思路，程序实现如下：

1. 1.    /*
   # _& m4 V" G' Q' p( S+ b# i8 _
2. 2.    ******************************************************************************************************
   3 O1 m2 h. w# s8 E+ G
3. 3.    *    函 数 名: bsp_EraseCpuFlash
   ' k+ N/ r; Z2 {, P2 V9 q5 W; l# c
4. 4.    *    功能说明: 擦除CPU FLASH一个扇区 （128KB)
   , P8 L# p5 N8 J" ]
5. 5.    *    形    参: _ulFlashAddr : Flash地址
   
6. 6.    *    返 回 值: 0 成功， 1 失败
   . x" H# P* t* F/ J+ K2 d9 d1 d5 m' b
7. 7.    *              HAL_OK       = 0x00,
   
8. 8.    *              HAL_ERROR    = 0x01,
   6 ~- q* F+ a9 o$ M3 B
9. 9.    *              HAL_BUSY     = 0x02,
   . m3 B  {3 j; \# X: v5 a9 a
10. 10.    *              HAL_TIMEOUT  = 0x03
    9 k8 E& ~7 ]. O3 T. d( {
11. 11.    *
    ) M/ g9 n! i5 y: i9 a
12. 12.    ******************************************************************************************************
    
13. 13.    */
    ; C- P2 z6 G1 h
14. 14.    uint8_t bsp_EraseCpuFlash(uint32_t _ulFlashAddr)
    
15. 15.    {
    1 w$ U' U+ `6 j* `  o6 B
16. 16.        uint32_t FirstSector = 0, NbOfSectors = 0;
    
17. 17.        FLASH_EraseInitTypeDef EraseInitStruct;
    8 L- c" p8 I2 K' P3 q' h" V
18. 18.        uint32_t SECTORError = 0;
    
19. 19.        uint8_t re;
    2 E2 A# ~# Q; S- p3 ^1 C& @
20. 20.   
    
21. 21.        /* 解锁 */
    5 S8 ~& t/ Z" T3 _0 Y' m, w! u
22. 22.        HAL_FLASH_Unlock();
    
23. 23.        
    + e7 K( i  X; m5 {& \  i$ Z) x! D
24. 24.        /* 获取此地址所在的扇区 */
    - A: D, s9 {! O8 W3 C1 @
25. 25.        FirstSector = bsp_GetSector(_ulFlashAddr);
    % ^( \$ N7 f% N; E
26. 26.        
    
27. 27.        /* 固定1个扇区 */
    
28. 28.        NbOfSectors = 1;   
    
29. 29.   
    ; J6 a- P6 {5 v3 a
30. 30.        /* 擦除扇区配置 */
    
31. 31.        EraseInitStruct.TypeErase     = FLASH_TYPEERASE_SECTORS;
    3 g7 ?# [# Y7 V4 S9 c5 i* \3 x$ @
32. 32.        EraseInitStruct.VoltageRange  = FLASH_VOLTAGE_RANGE_3;
    
33. 33.        
    
34. 34.        if (_ulFlashAddr >= ADDR_FLASH_SECTOR_0_BANK2)
    
35. 35.        {
    
36. 36.            EraseInitStruct.Banks         = FLASH_BANK_2;
    # D- |% ?  [. {' H# n; d3 @
37. 37.        }
    1 M0 X  m0 o2 b. H8 y; w7 u
38. 38.        else
    
39. 39.        {
    
40. 40.            EraseInitStruct.Banks         = FLASH_BANK_1;
    
41. 41.        }
    ( u+ u+ n5 O5 ~
42. 42.        
    9 G+ Q8 o  a! m1 _4 n
43. 43.        EraseInitStruct.Sector        = FirstSector;
    
44. 44.        EraseInitStruct.NbSectors     = NbOfSectors;
    
45. 45.        
    $ ]6 h# u. x2 m" o) T4 i! r
46. 46.        /* 扇区擦除 */   
    
47. 47.        re = HAL_FLASHEx_Erase(&EraseInitStruct, &SECTORError);
    
48. 48.        
    5 }+ }! E% p" n6 U
49. 49.        /* 擦除完毕后，上锁 */
    0 [1 \: o7 Y8 \6 ^9 L3 g
50. 50.        HAL_FLASH_Lock();   
    0 A7 a0 U1 D" J: ^, G. A
51. 51.        
    
52. 52.        return re;
    
53. 53.    }

复制代码

0 X" V9 B" x/ c$ |* A

这里将此程序设计的关键点为大家做个说明：
# w, z9 E3 K( b: [
0 k& Y2 a' |2 R  第25行函数是通过函数bsp_GetSector获取要擦除地址所处的扇区。这个函数的实现比较简单，代码如下：

1. /*
   
2. *********************************************************************************************************
   3 k9 j, {3 {; ?7 K
3. *    函 数 名: bsp_GetSector
   
4. *    功能说明: 根据地址计算扇区首地址
   
5. *    形    参: 无
   
6. *    返 回 值: 扇区号（0-7)
   
7. *********************************************************************************************************
   4 L! N. w% l* U
8. */
   , U0 D) u- ~* g! {0 x5 F
9. uint32_t bsp_GetSector(uint32_t Address)
   
10. {
    4 t7 ?4 U# D/ @4 C  q/ g' A
11.     uint32_t sector = 0;
    ) U& l9 J5 ^$ a( x" c! g2 t( F9 c
12. 
    
13.     if (((Address < ADDR_FLASH_SECTOR_1_BANK1) && (Address >= ADDR_FLASH_SECTOR_0_BANK1)) || \
    7 i3 F" N" w: M
14.         ((Address < ADDR_FLASH_SECTOR_1_BANK2) && (Address >= ADDR_FLASH_SECTOR_0_BANK2)))   
    
15.     {
    , ^! J- F7 ~) b
16.         sector = FLASH_SECTOR_0;  
    ; J3 h3 B  Z& _) ~. j
17.     }
    7 f+ a9 Q& B" ]/ h, g
18.     else if (((Address < ADDR_FLASH_SECTOR_2_BANK1) && (Address >= ADDR_FLASH_SECTOR_1_BANK1)) || \
    # f( j$ Z; E! E) h" G  k
19.       ((Address < ADDR_FLASH_SECTOR_2_BANK2) && (Address >= ADDR_FLASH_SECTOR_1_BANK2)))   
    
20.     {
    
21.         sector = FLASH_SECTOR_1;  
    
22.     }
    
23.     else if (((Address < ADDR_FLASH_SECTOR_3_BANK1) && (Address >= ADDR_FLASH_SECTOR_2_BANK1)) || \
    & A/ Y6 {! K( W4 I% u$ J
24.       ((Address < ADDR_FLASH_SECTOR_3_BANK2) && (Address >= ADDR_FLASH_SECTOR_2_BANK2)))   
    # f1 v. A7 {+ T5 {) q7 _
25.     {
    7 k5 k$ M6 u9 f
26.         sector = FLASH_SECTOR_2;  
    
27.     }
    4 u# B- U' p, u
28.     else if (((Address < ADDR_FLASH_SECTOR_4_BANK1) && (Address >= ADDR_FLASH_SECTOR_3_BANK1)) || \
    
29.       ((Address < ADDR_FLASH_SECTOR_4_BANK2) && (Address >= ADDR_FLASH_SECTOR_3_BANK2)))   
    0 N( W+ R. _' ?+ d; F& M- b0 z  S
30.     {
    6 k5 d7 x' b) U, G: W  J! X. T% T, g
31.         sector = FLASH_SECTOR_3;  
    
32.     }
    % `4 L8 ^  x0 s, f1 i7 x: ?
33.     else if (((Address < ADDR_FLASH_SECTOR_5_BANK1) && (Address >= ADDR_FLASH_SECTOR_4_BANK1)) || \
    ! T1 G( ]; l) k& H- Z6 `
34.       ((Address < ADDR_FLASH_SECTOR_5_BANK2) && (Address >= ADDR_FLASH_SECTOR_4_BANK2)))   
    
35.     {
    
36.         sector = FLASH_SECTOR_4;  
    # M. L) \7 V- j5 Y4 @$ K
37.     }
    2 {6 Z8 w. |5 B7 y- y' A3 v
38.     else if (((Address < ADDR_FLASH_SECTOR_6_BANK1) && (Address >= ADDR_FLASH_SECTOR_5_BANK1)) || \
    1 U, k4 @: G, {$ x# A- n- P: o3 ^
39.       ((Address < ADDR_FLASH_SECTOR_6_BANK2) && (Address >= ADDR_FLASH_SECTOR_5_BANK2)))   
    
40.     {
    
41.         sector = FLASH_SECTOR_5;  
    
42.     }
    
43.     else if (((Address < ADDR_FLASH_SECTOR_7_BANK1) && (Address >= ADDR_FLASH_SECTOR_6_BANK1)) || \
    / w. o6 W" C; c5 B3 v* h
44.       ((Address < ADDR_FLASH_SECTOR_7_BANK2) && (Address >= ADDR_FLASH_SECTOR_6_BANK2)))   
    : S3 _% K4 b) s7 Q' ~  f$ _
45.     {
    
46.         sector = FLASH_SECTOR_6;  
    6 s! L" K0 G* Y! o
47.     }
    
48.     else if (((Address < ADDR_FLASH_SECTOR_0_BANK2) && (Address >= ADDR_FLASH_SECTOR_7_BANK1)) || \
    ' a2 {8 Y; R$ l$ |
49.       ((Address < CPU_FLASH_END_ADDR) && (Address >= ADDR_FLASH_SECTOR_7_BANK2)))
    
50.     {
    
51.         sector = FLASH_SECTOR_7;  
      D' s. {3 g( l' ?; i
52.     }
    ' _. s. r& D8 W' {; W/ }& `
53.     else
    
54.     {
    
55.         sector = FLASH_SECTOR_7;
    8 P! d) q; M7 x# Y, w$ n5 L4 m# X
56.     }
    
57. 
      D: Q8 Y2 i! F. Y
58.     return sector;
    * Q& f9 i3 p( |1 ~$ F6 v4 T
59. }
    & z, |( J( o% n( ?6 Q

复制代码

+ _- x7 }; b, \0 C" x由于STM32H7的BANK1和BANK2是独立的，都有8个扇区，所以程序里面只需返回要擦除地址所处的扇区号即可。

  第47行的擦除函数HAL_FLASHEx_Erase在第70章的4.4小节有说明。
71.2.2 内部Flash编程的实现
内部Flash的编程思路如下：
. ]$ k! V9 ]9 R  A% O- \- w
  第1步，判断是否要编写数据进去，如果数据已经在内部Flash里面。
  第2步，调用函数HAL_FLASH_Unlock解锁。
  第3步，调用函数HAL_FLASH_Program对内部Flash编程数据。
; y8 _4 I" A( F' f/ O  第4步，调用函数HAL_FLASH_Lock上锁。
按照这个思路，程序实现如下：
6 [$ c  C7 Z  ^8 }9 y4 _  q. Z( i
  `5 n  ~  W6 h9 y, P3 ?

1. 1.    /*
   
2. 2.    ******************************************************************************************************
   
3. 3.    *    函 数 名: bsp_WriteCpuFlash
   
4. 4.    *    功能说明: 写数据到CPU 内部Flash。 必须按32字节整数倍写。不支持跨扇区。扇区大小128KB. \
   ( |( S) P" R& c  O" b
5. 5.    *              写之前需要擦除扇区. 长度不是32字节整数倍时，最后几个字节末尾补0写入.
   
6. 6.    *    形    参: _ulFlashAddr : Flash地址
   
7. 7.    *             _ucpSrc : 数据缓冲区
   / _4 O  E& B& X  x' @  q" ~* q
8. 8.    *             _ulSize : 数据大小（单位是字节, 必须是32字节整数倍）
   3 W9 Q, }% X/ g! s4 n
9. 9.    *    返 回 值: 0-成功，1-数据长度或地址溢出，2-写Flash出错(估计Flash寿命到)
   8 j3 L! c/ s" j6 J: E
10. 10.    ******************************************************************************************************
    ( J* [) X; ?3 R* t/ p( x! P
11. 11.    */
    9 X$ r" L. t3 u) m
12. 12.    uint8_t bsp_WriteCpuFlash(uint32_t _ulFlashAddr, uint8_t *_ucpSrc, uint32_t _ulSize)
    
13. 13.    {
    
14. 14.        uint32_t i;
    % ~. R; a( E1 ^3 n
15. 15.        uint8_t ucRet;
    
16. 16.   
    7 i7 m9 R. C- @6 k$ q6 n' X) o$ [
17. 17.        /* 如果偏移地址超过芯片容量，则不改写输出缓冲区 */
    
18. 18.        if (_ulFlashAddr + _ulSize > CPU_FLASH_BASE_ADDR + CPU_FLASH_SIZE)
    . v4 @" y  }# G! V9 r% Y6 ]" v
19. 19.        {
    
20. 20.            return 1;
    : T. E/ ^9 S8 i. g
21. 21.        }
    ) R( P& J4 ~; X1 O* V+ x
22. 22.   
    
23. 23.        /* 长度为0时不继续操作  */
    
24. 24.        if (_ulSize == 0)
    + z+ n) ~  {* o: u% ^! F/ Z, d
25. 25.        {
    2 N9 y/ B; u: {8 \3 z" W
26. 26.            return 0;
    
27. 27.        }
    2 d& k, }  ]$ B! y; D3 C2 S  T- w
28. 28.   
    
29. 29.        ucRet = bsp_CmpCpuFlash(_ulFlashAddr, _ucpSrc, _ulSize);
    
30. 30.   
    $ P- Q6 ]6 b+ I3 H
31. 31.        if (ucRet == FLASH_IS_EQU)
    
32. 32.        {
    # G1 l% m5 o9 V9 j4 t
33. 33.            return 0;
    
34. 34.        }
    
35. 35.   
    ; x2 E  ~7 \! c
36. 36.        __set_PRIMASK(1);          /* 关中断 */
    
37. 37.   
    
38. 38.        /* FLASH 解锁 */
    
39. 39.        HAL_FLASH_Unlock();
    - T* o' ~5 y- U- M3 i( L- V8 w
40. 40.   
    1 i2 B  H$ b- p$ g
41. 41.        for (i = 0; i < _ulSize / 32; i++)   
    & F  V1 A: h# c9 j' O  `" V! A
42. 42.        {
    
43. 43.            uint64_t FlashWord[4];
    
44. 44.            
    - x& D, Q1 Z0 x& @  `! k
45. 45.            memcpy((char *)FlashWord, _ucpSrc, 32);
    8 ]" B1 t6 n- `. X# B
46. 46.            _ucpSrc += 32;
    / i& D& g3 l7 d; n1 [
47. 47.            
    1 k4 H, E" P% }- k2 N' l$ B
48. 48.            if (HAL_FLASH_Program(FLASH_TYPEPROGRAM_FLASHWORD, _ulFlashAddr,
    
49. 49.                                      (uint64_t)((uint32_t)FlashWord)) == HAL_OK)
    ) P8 c9 e6 x( P0 V: V( h* Q; S
50. 50.            {
    6 P3 D. |/ V7 `% V, u0 A) b
51. 51.                _ulFlashAddr = _ulFlashAddr + 32; /* 递增，操作下一个256bit */               
    
52. 52.            }        
    % d$ ]/ m( ~2 C
53. 53.            else
    
54. 54.            {
    
55. 55.                goto err;
    + x/ c: |8 O0 o7 V/ l' i
56. 56.            }
    ( w3 z) ]" Y7 E( M
57. 57.        }
    
58. 58.        
    
59. 59.        /* 长度不是32字节整数倍 */
    
60. 60.        if (_ulSize % 32)
    
61. 61.        {
    7 u* f6 _5 K, R% D. A; Z  e0 k  ]" H4 M
62. 62.            uint64_t FlashWord[4];
    
63. 63.            
    7 _/ y4 a5 A. n! G) ?7 @2 x
64. 64.            FlashWord[0] = 0;
    
65. 65.            FlashWord[1] = 0;
    
66. 66.            FlashWord[2] = 0;
    
67. 67.            FlashWord[3] = 0;
    
68. 68.            memcpy((char *)FlashWord, _ucpSrc, _ulSize % 32);
    , s9 v+ s) s; e. }5 E: o
69. 69.            if (HAL_FLASH_Program(FLASH_TYPEPROGRAM_FLASHWORD, _ulFlashAddr,
    
70. 70.                                               (uint64_t)((uint32_t)FlashWord)) == HAL_OK)
    
71. 71.            {
    
72. 72.                ; // _ulFlashAddr = _ulFlashAddr + 32;
    2 Z% S/ B$ e8 i$ f5 n2 K
73. 73.               
    $ W: V# t1 b& F) M+ r
74. 74.            }        
    
75. 75.            else
    
76. 76.            {
    ) ?5 S/ E. u) F$ u; n6 R; ?7 m
77. 77.                goto err;
    6 t0 ]9 R: ^! ]; r. k) Y% ^
78. 78.            }
    # I: o1 S0 \4 T( i  P/ T( Q  I
79. 79.        }
    . @( |) X. q& b( n' z
80. 80.        
    ( n  D7 ^* a# @6 M0 c7 f
81. 81.          /* Flash 加锁，禁止写Flash控制寄存器 */
    
82. 82.          HAL_FLASH_Lock();
    4 P, V" }4 E; ~7 N
83. 83.   
    & K! `2 q* Q5 \  |  a# e% N  {
84. 84.          __set_PRIMASK(0);          /* 开中断 */
    ) |) S- R9 d% U
85. 85.   
    
86. 86.        return 0;
    ( L% u- v6 r9 U: A# b
87. 87.        
    ; u; W6 n4 V$ L" t0 h7 }( E, y
88. 88.    err:
    
89. 89.          /* Flash 加锁，禁止写Flash控制寄存器 */
    
90. 90.          HAL_FLASH_Lock();
    . J9 N/ P, E& m  l' P; x
91. 91.   
    
92. 92.          __set_PRIMASK(0);          /* 开中断 */
    
93. 93.   
    
94. 94.        return 1;
    
95. 95.    }
    

复制代码

3 f# O: T4 [) o关于此函数有几个要点：

  第1个参数必须32字节对齐，即要编程的Flash地址对32求余为0。
3 {) S5 O3 [5 J" E  M7 T  第3个参数必须是32字节的整数倍，长度不是32字节整数倍时，最后几个字节补0写入。
( P5 |. h& t) [( D$ F  第29行，函数bsp_CmpCpuFlash放在这里只有一个作用，判断将要写入的数据是否已经在内部Flash存在，如果已经存在，无需重复写入，直接返回。
  第36行，做了一个关中断操作，这里有个知识点要给大家普及下，由于H7的BANK1和BANK2是独立的，当前正在擦除的扇区所处的BANK会停止所有在此BANK执行的程序，包含中断也会停止执行。比如当前的应用程序都在BANK1，如果要擦除或者编程BANK2，是不会不影响BANK1里面执行的程序。这里安全起见加上了开关中断。
" W8 a+ i% a* w+ V6 }  第41到57行，先将32字节整数倍的数据通过函数HAL_FLASH_Program编程，此函数每次可以固定编程32字节数据。
  第60到79行，将剩余不足32字节的数据补0，凑齐32字节编程。
71.2.3 内部Flash读取的实现
内部Flash数据读取比较简单，采用总线方式读取，跟访问内部RAM是一样的。比如要读取地址
* P& H6 v* y7 D0 v& c) y
0x08100000里面的一个32bit变量，我们就可以：
- \  a4 T. S0 R6 H' ^( X
变量 = *(uint32_t *)(0x08100000)

5 x( Y. c2 @" f/ c! ]! S& G, J为了方便起见，也专门准备了一个函数：

! H0 Y, ~' ?1 i

1. /*
   
2. *********************************************************************************************************
   + ]4 v! h' l8 v
3. *    函 数 名: bsp_ReadCpuFlash
   
4. *    功能说明: 读取CPU Flash的内容
   
5. *    形    参:  _ucpDst : 目标缓冲区
   - Q6 ^2 f& {, l7 l. E8 z8 }4 a
6. *             _ulFlashAddr : 起始地址
   
7. *             _ulSize : 数据大小（单位是字节）
   
8. *    返 回 值: 0=成功，1=失败
   
9. *********************************************************************************************************
   5 b, [( f: c, c  k+ ?
10. */
    
11. uint8_t bsp_ReadCpuFlash(uint32_t _ulFlashAddr, uint8_t *_ucpDst, uint32_t _ulSize)
    
12. {
    
13.     uint32_t i;
    
14. 
    5 W# K% R9 B. Z7 D
15.     if (_ulFlashAddr + _ulSize > CPU_FLASH_BASE_ADDR + CPU_FLASH_SIZE)
    ! r5 p: N  p) b0 T2 J7 C3 Z5 n% x
16.     {
    
17.         return 1;
    # k# p& f( C# p$ A) \# x/ d: L
18.     }
    6 ?5 I$ d6 X# F) v7 R4 b" |$ Y
19. 
    3 M: d' Z2 c9 n. N! U
20.     /* 长度为0时不继续操作,否则起始地址为奇地址会出错 */
    
21.     if (_ulSize == 0)
    % ~* s3 d  d2 D6 m' r7 s2 K
22.     {
    
23.         return 1;
      `1 C0 ]2 B( n; q# Z
24.     }
    
25. 
    $ u% d) G1 Z7 |, r6 X, `* [
26.     for (i = 0; i < _ulSize; i++)
    
27.     {
    2 O. t4 a8 m7 G2 q3 `: B
28.         *_ucpDst++ = *(uint8_t *)_ulFlashAddr++;
    
29.     }
    
30. 
    1 A, \" X0 [: |2 t0 c2 n
31.     return 0;
    
32. }
    

复制代码

71.2.4 告诉编译器使用的扇区（重要）
# ^" b7 d; {4 l! F' @" W. B/ g使用内部Flash模拟EEPROM切不可随意定义一个扇区使用。因为编译器并不知道用户使用了这个扇区，导致应用程序也会编程到此扇区里面，所以就需要告诉编译器。
* x% N8 \1 x2 ^2 ~
告诉MDK的方法如下（0x0810 0000是H7的BANK2首地址）：

1. const uint8_t para_flash_area[128*1024] __attribute__((at(0x08100000)));

复制代码

告诉IAR的方法如下：

" J, L' q0 [, F; d4 m& O

1. #pragma location=0x08100000
   # H3 x+ B% x0 }% b7 h; \
2. const uint8_t para_flash_area[128*1024];
   

复制代码

$ D6 k8 R6 |0 @9 G/ G( C, A这里有两点特别注意：

  模拟EEPROM的扇区可以定义到从第2个扇区开始的任何扇区，但不可以定义到首扇区，因为这个扇区是默认的boot启动地址。
$ V3 P8 b7 Q, o2 F3 w: N) X  如果应用程序不大的话，不推荐定义到末尾扇区，以MDK为例，定义到末尾扇区后，会导致整个Flash空间都被使用，从而让程序下载下载时间变长。
71.3 模拟EEPROM板级支持包（bsp_cpu_flash.c）
模拟EEPROM的驱动文件bsp_cpu_flash.c主要实现了如下几个API供用户调用：
, j8 R# z% b' [# T7 P
  bsp_GetSector
! y3 [1 i5 G$ _. y  bsp_ReadCpuFlash
  bsp_CmpCpuFlash
  bsp_EraseCpuFlash
  bsp_WriteCpuFlash
71.3.1 函数bsp_GetSector
函数原型：

1. uint32_t bsp_GetSector(uint32_t Address)

复制代码

函数描述：

+ ?6 a- K/ ^3 x8 D" ?' A. s此函数主要用于获取给定地址所处的扇区。

函数参数：

  第1个参数是用户给定的地址。
. v. D# t% d/ z$ N  返回值，范围FLASH_SECTOR_0到FLASH_SECTOR_7。
7 E7 ]) I2 k6 G$ [- b1 @71.3.2 函数bsp_ReadCpuFlash
! i- Z8 _& W* @( e8 n! w函数原型：

* g- H( S: R# v8 s; |& \

1. uint8_t bsp_ReadCpuFlash(uint32_t _ulFlashAddr, uint8_t *_ucpDst, uint32_t _ulSize)

复制代码

, V  U' S8 p' ^6 `2 h函数描述：
1 J9 G6 W) u+ J' e: A. r
此函数用于从内部Flash读取数据
( p& K) m4 n! `& j" ?5 t
函数参数：

" j, D8 O! e& w5 Y8 P  第1个参数读取的起始地址。
, J; F( u5 M4 e  D$ N! ?  第2个参数是读取数据的存储地址
  第3个参数是读取数据的大小，单位字节。
% _# D2 f) ]) U5 [) P; R  返回值，0表示成功，1表示失败。
$ O5 E$ {. C1 u4 g+ e2 n71.3.3 函数bsp_CmpCpuFlash
函数原型：

# X6 B. g" R/ }7 [! G" u# R' nuint8_t bsp_CmpCpuFlash(uint32_t _ulFlashAddr, uint8_t *_ucpBuf, uint32_t _ulSize)

函数描述：

要编程的数据是否在内部Flash已经存在。
( ?, A" t" A5 p5 A) t% n
函数参数：
$ S8 Q- E/ `& k% m$ |
  第1个参数是内部Flash地址。
3 r  X$ a; ^6 \2 |" C  第2个参数是缓冲区地址。
1 `. d7 B5 T1 Q% z2 A# ~  第3个参数是数据大小，单位字节。
) F4 K3 b9 h: \1 l# `  返回值：
FLASH_IS_EQU               0   Flash内容和待写入的数据相等，不需要擦除和写操作。

5 j" l1 ]$ \5 Z. a, ?5 ~FLASH_REQ_WRITE          1     Flash不需要擦除，直接写。
. h! N# x+ m" V8 ^5 w) u
FLASH_REQ_ERASE          2     Flash需要先擦除,再写。

$ d1 @$ S& W# I7 l2 `: D6 n" ]FLASH_PARAM_ERR         3     函数参数错误。

71.3.4 函数bsp_EraseCpuFlash
函数原型：
  l* S$ p4 S9 a) u4 ], {
6 B+ a. V1 {6 Zuint8_t bsp_EraseCpuFlash(uint32_t _ulFlashAddr)

函数描述：
. e& q& S" ^, D
" N) M% [. h/ v. h此函数用于擦除一个扇区，大小128KB

函数参数：
" ?, z, O7 Q; e, C
% y) B& u9 j$ `0 r3 c8 Q  第1个参数要擦除的扇区地址，可以是此扇区范围内的任意值，一般填扇区首地址即可。
  返回值：
4 H. B( b: b) V. THAL_OK        = 0x00

HAL_ERROR    = 0x01

HAL_BUSY      = 0x02

4 O6 O3 y( t2 L3 WHAL_TIMEOUT  = 0x03

9 ]1 _  j1 J2 G- V1 U& ?71.3.5 函数bsp_WriteCpuFlash
函数原型：
/ X1 G5 p& b7 n" W* h( G
uint8_t bsp_WriteCpuFlash(uint32_t _ulFlashAddr, uint8_t *_ucpSrc, uint32_t _ulSize)

函数描述：

此函数用于编程数据到内部Flash。

5 r- R8 k  X$ ]& M7 C) y. h1 i函数参数：
; u% f/ C. K, O; i) v
  第1个参数是要编程的内部Flash地址。
% y4 e+ V1 q* D- u4 D) c: R  第2个参数是数据缓冲区地址。
! h. _; A1 @5 C# X8 G) ?4 u* }1 p  第3个参数是数据大小，单位字节。
  返回值，0-成功，1-数据长度或地址溢出，2-写Flash出错(估计Flash寿命到)。
注意事项：
0 Z2 _$ Z* K! [& G* @' Y6 a; ~4 Z$ i2 |
  第1个参数必须32字节对齐，即要编程的Flash地址对32求余为0。
7 B' S* c1 `' N* n( l7 i  第3个参数必须是32字节的整数倍，长度不是32字节整数倍时，此函数会将几个字节补0写入
& d/ ^6 R; t' ?5 E: L/ U  Q; T71.4 模拟EEPROM驱动移植和使用
模拟EEPROM移植步骤如下：

  第1步：复制bsp_cpu_flash.c和bsp_cpu_flash.h到自己的工程目录，并添加到工程里面。
/ p' x# c7 X; r3 S5 X4 I* v  第2步：Flash驱动文件主要用到HAL库的Flash驱动文件，简单省事些可以添加所有HAL库C源文件进来。
  第3步，应用方法看本章节配套例子即可。
1 S9 o. G/ x6 R2 B71.5 实验例程设计框架
通过程序设计框架，让大家先对配套例程有一个全面的认识，然后再理解细节，本次实验例程的设计框架如下：
/ e3 s) \/ h1 i: K
" c; I+ O+ _: \0 |6 G

9 U0 s2 b2 Q$ e; y. n' P. K  第1阶段，上电启动阶段：
2 d4 l# F% C4 {3 Z* g" r
  k' y! w) ]% g( R) j7 p5 w% c8 V9 r这部分在第14章进行了详细说明。
  第2阶段，进入main函数：
8 o+ f& k% Q' d" e4 X
- \& ^/ g/ B1 V2 U1 M  第1部分，硬件初始化，主要是MPU，Cache，HAL库，系统时钟，滴答定时器和LED。
. i4 |$ f& `! d  第2部分，应用程序设计部分，实现内部Flash模拟EEPROM。
71.6 实验例程说明（MDK）
配套例子：

V7-049_内部Flash模拟EEPROM

实验目的：
& p5 ~1 f  S& }+ K) s. U
学习内部Flash模拟EEPROM。
/ m2 k2 o. i" Q7 ]实验内容：
. G1 d- A" x% e  t: ^
9 T  I8 L( ?6 Y6 I" a0 K使用内部Flash模拟EEPROM，务必告诉编译要使用的存储空间，防止这个空间存入了程序。
! t1 a9 m5 \- x; |对于同一个地址空间，仅支持一次编程(不推荐二次编程，即使是将相应bit由数值1编程0)。
只能对已经擦除的空间做编程，擦除1个扇区是128KB。
H7的Flash编程时，务必保证要编程的地址是32字节对齐的，即此地址对32求余为0。
! a/ ]0 T5 k0 {并且编程的数据必须32字节整数倍，函数bsp_WriteCpuFlash对字节数不够32字节整数倍的情况自动补0。

( c3 }7 V) g8 i' m6 F* ^9 m* T+ H1 ~实验操作：

6 Z/ R0 n8 H! z, r2 v7 ]2 V6 g7 jK1键按下，将8bit，16bit和32bit数据写入到内部Flash。
K2键按下，将结构体数据写入到内部Flash。
上电后串口打印的信息：
  J% H8 d! a: g+ v  O# G
; C1 i: q7 Y4 r0 t9 |" q波特率 115200，数据位 8，奇偶校验位无，停止位 1。

8 d/ `9 \6 t2 c- i& S

( L. J; R  l; _* j+ U5 t
程序设计：
' y2 ^+ q9 o3 x1 @# I) ~" E
- R  e1 W; h$ Q# M3 v  系统栈大小分配：
5 E0 G3 O% m" W
" v" S5 f9 p& {; w: y

, j8 g& I$ {- N3 ?0 r6 O
  RAM空间用的DTCM：

/ K8 F* f" x2 b' ^9 D# x. j

" ~( v  u( C' v" A$ _  x  硬件外设初始化

  J( k/ \  J9 S  Q9 C硬件外设的初始化是在 bsp.c 文件实现：

1. /*
   
2. *********************************************************************************************************
   
3. *    函 数 名: bsp_Init
   
4. *    功能说明: 初始化所有的硬件设备。该函数配置CPU寄存器和外设的寄存器并初始化一些全局变量。只需要调用一次
   " N  n( Y1 q# d  Q2 L
5. *    形    参：无
   
6. *    返 回 值: 无
   
7. *********************************************************************************************************
   
8. */
   5 d' Z$ {  p8 a
9. void bsp_Init(void)
   $ n1 v  {3 x, c7 W' O, _
10. {
    
11.     /* 配置MPU */
    
12.     MPU_Config();
    
13. 
    $ ~5 h9 }5 y$ d$ i  a5 K. C
14.     /* 使能L1 Cache */
    7 ~1 Y7 M4 Z% s1 Q% ]8 \7 P
15.     CPU_CACHE_Enable();
    
16. 
    ; o$ F. f# V- w  c1 Q
17.     /*
    
18.        STM32H7xx HAL 库初始化，此时系统用的还是H7自带的64MHz，HSI时钟:
    
19.        - 调用函数HAL_InitTick，初始化滴答时钟中断1ms。
    
20.        - 设置NVIV优先级分组为4。
    
21.      */
    
22.     HAL_Init();
    
23. 
    
24.     /*
    % D3 D9 }- n% ]" }3 l
25.        配置系统时钟到400MHz
    
26.        - 切换使用HSE。
    
27.        - 此函数会更新全局变量SystemCoreClock，并重新配置HAL_InitTick。
    
28.     */
    
29.     SystemClock_Config();
    . u4 `/ c% V6 X: R6 m
30. 
    4 \: F3 B, y, y0 s3 m" V+ t
31.     /*
    
32.        Event Recorder：
    . d, B2 f, J2 I3 A) ^% B
33.        - 可用于代码执行时间测量，MDK5.25及其以上版本才支持，IAR不支持。
    
34.        - 默认不开启，如果要使能此选项，务必看V7开发板用户手册第xx章
    0 P  T6 G# p+ h
35.     */   
    
36. #if Enable_EventRecorder == 1  
    8 g: ]9 ]! |) ^$ B4 l
37.     /* 初始化EventRecorder并开启 */
    6 u- a) b7 {2 g
38.     EventRecorderInitialize(EventRecordAll, 1U);
    
39.     EventRecorderStart();
    
40. #endif
    
41. 
    ( P! X* K+ A8 f" D% G
42. bsp_InitDWT();      /* 初始化DWT时钟周期计数器 */      
    
43.     bsp_InitKey();        /* 按键初始化，要放在滴答定时器之前，因为按钮检测是通过滴答定时器扫描 */
    4 V( [' u" X2 r
44.     bsp_InitTimer();      /* 初始化滴答定时器 */
    
45.     bsp_InitLPUart();    /* 初始化串口 */
    2 f( z( ^1 ~$ H, ~
46.     bsp_InitExtIO();    /* 初始化FMC总线74HC574扩展IO. 必须在 bsp_InitLed()前执行 */   
    
47.     bsp_InitLed();        /* 初始化LED */   
    
48.     bsp_InitExtSDRAM(); /* 初始化SDRAM */
    
49. }
    

复制代码

$ ~4 R+ B3 O5 l% S; A
- h! M/ s; D) U  MPU配置和Cache配置：

/ ^* Q* H1 b) Q6 g" h" N  x0 F# }数据Cache和指令Cache都开启。配置了AXI SRAM区（本例子未用到AXI SRAM）和FMC的扩展IO区。

1. /*
   
2. *********************************************************************************************************
   7 O0 P* O- d+ ~3 w  ]) y, ?* [6 `
3. *    函 数 名: MPU_Config
   
4. *    功能说明: 配置MPU
   
5. *    形    参: 无
   # S5 W; _3 i1 h% x5 _9 b0 A
6. *    返 回 值: 无
   
7. *********************************************************************************************************
   
8. */
   $ g' T6 z6 Y& Q
9. static void MPU_Config( void )
   
10. {
    , R. O9 U  [8 v3 o/ J, Z
11.     MPU_Region_InitTypeDef MPU_InitStruct;
    
12. 
    ; @8 I1 d0 X5 P# H
13.     /* 禁止 MPU */
    
14.     HAL_MPU_Disable();
    
15. 
    3 p& ~/ Z3 l) a% C* `
16.     /* 配置AXI SRAM的MPU属性为Write back, Read allocate，Write allocate */
    : w- o2 d8 P4 j+ T; _. j! ^
17.     MPU_InitStruct.Enable           = MPU_REGION_ENABLE;
    % f+ t; i/ o$ }+ V
18.     MPU_InitStruct.BaseAddress      = 0x24000000;
    
19.     MPU_InitStruct.Size             = MPU_REGION_SIZE_512KB;
    # m9 C9 R) ~8 i2 c
20.     MPU_InitStruct.AccessPermission = MPU_REGION_FULL_ACCESS;
    
21.     MPU_InitStruct.IsBufferable     = MPU_ACCESS_BUFFERABLE;
    
22.     MPU_InitStruct.IsCacheable      = MPU_ACCESS_CACHEABLE;
    
23.     MPU_InitStruct.IsShareable      = MPU_ACCESS_NOT_SHAREABLE;
    
24.     MPU_InitStruct.Number           = MPU_REGION_NUMBER0;
    
25.     MPU_InitStruct.TypeExtField     = MPU_TEX_LEVEL1;
    ) ~6 q$ [2 o# Y9 R$ J
26.     MPU_InitStruct.SubRegionDisable = 0x00;
    ' p9 ?8 p1 o) P9 {0 B
27.     MPU_InitStruct.DisableExec      = MPU_INSTRUCTION_ACCESS_ENABLE;
    
28. 
    
29.     HAL_MPU_ConfigRegion(&MPU_InitStruct);
    ( n! e1 U0 G3 ~
30. 
    : |5 n3 `2 l! o9 N) M$ x
31. 
    2 z: w0 z' N( f# [& ]
32.     /* 配置FMC扩展IO的MPU属性为Device或者Strongly Ordered */
    7 ~+ ~" K3 |8 M( h
33.     MPU_InitStruct.Enable           = MPU_REGION_ENABLE;
    1 B# L' z4 Y+ W8 l! @5 N7 X( W9 R
34.     MPU_InitStruct.BaseAddress      = 0x60000000;
    
35.     MPU_InitStruct.Size             = ARM_MPU_REGION_SIZE_64KB;   
    
36.     MPU_InitStruct.AccessPermission = MPU_REGION_FULL_ACCESS;
    
37.     MPU_InitStruct.IsBufferable     = MPU_ACCESS_BUFFERABLE;
    
38.     MPU_InitStruct.IsCacheable      = MPU_ACCESS_NOT_CACHEABLE;   
    
39.     MPU_InitStruct.IsShareable      = MPU_ACCESS_NOT_SHAREABLE;
    ; N: X- `+ h/ ]7 K; x- ~
40.     MPU_InitStruct.Number           = MPU_REGION_NUMBER1;
    7 S# ~$ A! y9 m3 t
41.     MPU_InitStruct.TypeExtField     = MPU_TEX_LEVEL0;
    " P% n5 q7 f9 R% E) v; B
42.     MPU_InitStruct.SubRegionDisable = 0x00;
    , E6 }1 F1 f" c( i6 h
43.     MPU_InitStruct.DisableExec      = MPU_INSTRUCTION_ACCESS_ENABLE;
    
44. 
    ) \! g! Q$ q8 A( \! F
45.     HAL_MPU_ConfigRegion(&MPU_InitStruct);
    + x5 S! O  ~1 B0 J
46. 
    ) O; y6 _* t3 B! G/ }( G1 W! f
47.     /*使能 MPU */
    , t6 T/ `& Z4 @" A4 l; Y
48.     HAL_MPU_Enable(MPU_PRIVILEGED_DEFAULT);
    
49. }
    $ E# \3 Q" [" h
50. 
    " U) C, _+ w+ M# Z' g% T
51. /*
    5 d' ~9 Y. |/ _
52. *********************************************************************************************************
    
53. *    函 数 名: CPU_CACHE_Enable
    ; A7 \% n8 w# M* q: A
54. *    功能说明: 使能L1 Cache
    1 @  P1 ]# g1 ~: B  y* p; D
55. *    形    参: 无
    
56. *    返 回 值: 无
    
57. *********************************************************************************************************
    2 X( w, {3 `7 i4 M* T- C9 P
58. */
    
59. static void CPU_CACHE_Enable(void)
    
60. {
    & b2 q5 M" G3 }% H0 L
61.     /* 使能 I-Cache */
    * Y& Y$ b3 M1 v0 T" g0 z% p
62.     SCB_EnableICache();
    
63. 
    
64.     /* 使能 D-Cache */
    
65.     SCB_EnableDCache();
    0 _% y5 \& y, H6 k+ f. ]7 U
66. }

复制代码

* s8 K# u' S1 f( w# K
  每10ms调用一次蜂鸣器处理：

7 n5 @7 Z3 p% t" O& R4 D, J$ V- F蜂鸣器处理是在滴答定时器中断里面实现，每10ms执行一次检测。
+ Y# B8 S& O7 C% J/ A
1 H8 u  f: I. \( r

1. /*
   7 s1 {- k  Z  R  I9 i2 u" L9 Z9 z
2. *********************************************************************************************************
   
3. *    函 数 名: bsp_RunPer10ms
   
4. *    功能说明: 该函数每隔10ms被Systick中断调用1次。详见 bsp_timer.c的定时中断服务程序。一些处理时间要求
   / ^# a7 ?# Y' ~
5. *              不严格的任务可以放在此函数。比如：按键扫描、蜂鸣器鸣叫控制等。
   / k0 M6 y9 Z( @- w2 R& K$ I( n
6. *    形    参: 无
   8 p2 G2 F; W7 c; Y
7. *    返 回 值: 无
   , a# _3 J! C4 Q8 w( E' {+ p
8. *********************************************************************************************************
   0 V" r+ @. _2 f0 I6 x, m! N5 r  I
9. */
   & V4 i2 u5 l4 x, S' ?. n
10. void bsp_RunPer10ms(void)
    
11. {
    ! n' _! u( Q6 n. o! v: Z+ _: q, t
12.     bsp_KeyScan10ms();
    
13. }
    

复制代码

5 Q- _5 Y6 \. s% m. d6 B
  主功能：
- y6 C  F5 ]; I% y, P' E
/ u5 y: r5 i. X" s主程序实现如下操作：

- d  T0 c+ k! Z3 x& z0 c, x  启动一个自动重装软件定时器，每100ms翻转一次LED2。
0 w/ ?0 q' G) C' I/ e9 Z  K1键按下，将8bit，16bit和32bit数据写入到内部Flash。
2 C: d3 B8 ]$ p; {; H1 m2 u  K2键按下，将结构体数据写入到内部Flash。
* k4 |$ |4 Q  w2 S( F/ H

1. /*
   
2. *********************************************************************************************************
   
3. *    函 数 名: main
   
4. *    功能说明: c程序入口
   
5. *    形    参: 无
   ; @" Z% i+ ~" l+ X
6. *    返 回 值: 错误代码(无需处理)
   / I4 [% _; `4 y! w6 r6 Q' R1 P! y  m
7. *********************************************************************************************************
   % w+ Y4 T, N4 R4 g4 I
8. */
   
9. int main(void)
   9 B% y) X! [( S+ \
10. {
    
11.     uint8_t ucKeyCode;    /* 按键代码 */
    
12.     uint8_t  ucTest, *ptr8;
    9 S' P. m* i9 U& j# _% S
13.     uint16_t uiTest, *ptr16;
    
14.     uint32_t ulTest, *ptr32;
    
15.     PARAM_T tPara, *paraptr;
    & c# V1 p! I) `: _+ Y
16. 
    $ i7 s4 m, Z0 p7 T$ B
17. 
    3 P% [3 H: A/ u1 l! ]7 I5 g
18.     /* 初始化数据 */
    % A7 s" S' _! o* ^- P2 |
19.     tPara.Baud485 = 0x5555AAAA;
      T9 W3 Q6 A% b, p
20.     tPara.ParamVer = 0x99;
    
21.     tPara.ucBackLight = 0x7788;
    
22.     tPara.ucRadioMode = 99.99f;
    
23. 
    
24. 
    + U3 w( w' h* \( z
25.     bsp_Init();        /* 硬件初始化 */
    7 N: `( _. T. j. j, k  b
26.     PrintfLogo();    /* 打印例程名称和版本等信息 */
    
27.     PrintfHelp();    /* 打印操作提示 */
    
28. 
    - i+ \  V! n# v# K( E0 c
29.     bsp_StartAutoTimer(0, 100);    /* 启动1个100ms的自动重装的定时器 */
    / F; b! `' O8 e2 Z' _! F# h
30.     while (1)
    
31.     {
    
32.         bsp_Idle();        /* 这个函数在bsp.c文件。用户可以修改这个函数实现CPU休眠和喂狗 */
    
33. 
    7 q; g% b9 A4 X
34.         /* 判断定时器超时时间 */
    7 V2 Y8 \3 R* ?1 S: [+ O2 m0 r
35.         if (bsp_CheckTimer(0))   
    8 H0 ~8 ~5 E. K2 y0 b9 N
36.         {
    8 a* m* d! Y& F9 k) ~4 j* c
37.             /* 每隔100ms 进来一次 */  
    
38.             bsp_LedToggle(2);
    
39.         }
    
40. 
    
41.         /* 按键滤波和检测由后台systick中断服务程序实现，我们只需要调用bsp_GetKey读取键值即可。 */
    
42.         ucKeyCode = bsp_GetKey();    /* 读取键值, 无键按下时返回 KEY_NONE = 0 */
    
43.         if (ucKeyCode != KEY_NONE)
    
44.         {
    8 U0 q2 V* m6 C0 x* X
45.             switch (ucKeyCode)
    + v' H7 ~- D  ?3 N4 E" d9 V
46.             {
    
47.                 case KEY_DOWN_K1:            /* K1键按下，将8bit，16bit和32bit数据写入到内部Flash */
    
48. 
    
49.                 /*
    ( h# Q" u9 ^: k. h3 }
50.                  1、对于同一个地址空间，仅支持一次编程(不推荐二次编程，即使是将相应bit由数值1编程0)。
    " T! P1 b* ]4 h
51.                  2、只能对已经擦除的空间做编程，擦除1个扇区是128KB。
    % Y2 S( A4 }/ Y+ T
52.                  3、H7的Flash编程时，务必保证要编程的地址是32字节对齐的，即此地址对32求余为0。并且编
    
53. 程的数据必须32字节整数倍。函数bsp_WriteCpuFlash对字节数不够32字节整数倍的情况自动补
    
54. 0。
    4 L, t& U2 B7 Q$ K0 {2 M! z+ I! [. M
55.                 */
    
56.                      /* 擦除扇区 */
    
57.                     bsp_EraseCpuFlash((uint32_t)para_flash_area);
    / T$ X% Z1 t% L) o. N+ A: F
58. 
    6 F3 p/ M' N. G+ O
59.                     ucTest = 0xAA;
    3 X5 n$ C2 I' r7 l/ V
60.                     uiTest = 0x55AA;
    
61.                     ulTest = 0x11223344;
    6 ?3 U: J% V2 P: k" M0 q
62. 
    6 ~$ I$ U: g& O6 ^
63.                     /* 扇区写入数据 */
    3 F8 i( ^- b6 E% v- [' M
64.                     bsp_WriteCpuFlash((uint32_t)para_flash_area + 32*0,  (uint8_t *)&ucTest,
    ' D: v/ V& g; \2 V# c; A
65. sizeof(ucTest));
    
66.                     bsp_WriteCpuFlash((uint32_t)para_flash_area + 32*1,  (uint8_t *)&uiTest,
    
67. sizeof(uiTest));
      p( K, I1 V# k2 g9 h
68.                     bsp_WriteCpuFlash((uint32_t)para_flash_area + 32*2,  (uint8_t *)&ulTest,
    9 d7 t8 ^0 }0 g2 u
69. sizeof(ulTest));               
    
70. 
    
71.                     /* 读出数据并打印 */
    
72.                     ptr8  = (uint8_t  *)(para_flash_area + 32*0);
    $ q" c/ R1 a' X  F' m
73.                     ptr16 = (uint16_t *)(para_flash_area + 32*1);
    $ b) u/ r4 d* d$ |; p& R  m
74.                     ptr32 = (uint32_t *)(para_flash_area + 32*2);
    
75. 
    . o  V5 N  K; [$ ?2 t# R' p. U5 T
76.                     printf("写入数据：ucTest = %x, uiTest = %x, ulTest = %x\r\n", ucTest, uiTest, ulTest);
    
77.                     printf("读取数据：ptr8 = %x, ptr16 = %x, ptr32 = %x\r\n", *ptr8, *ptr16, *ptr32);
    
78. 
    $ R7 w, \9 F) s6 ^
79.                     break;
    ( ?* ~: q9 D/ ?, D5 S4 K5 B9 }; b" |
80. 
    
81.                 case KEY_DOWN_K2:            /* K2键按下， 将结构体数据写入到内部Flash */
    
82.                     /* 擦除扇区 */
    / c( o1 v# i( C
83.                     bsp_EraseCpuFlash((uint32_t)para_flash_area);
    0 K6 }, ?1 b; b  u* @$ N' G
84. 
    
85.                     /* 扇区写入数据 */
    
86.                     bsp_WriteCpuFlash((uint32_t)para_flash_area,  (uint8_t *)&tPara, sizeof(tPara));            
    
87. 
    0 P: v' I( d5 `6 x) ?
88.                     /* 读出数据并打印 */
    
89.                     paraptr  = (PARAM_T  *)((uint32_t)para_flash_area);
    
90. 
    & E0 w7 J% L( {4 w
91. 
    
92.                     printf("写入数据：Baud485=%x, ParamVer=%x, ucBackLight=%x, ucRadioMode=%f\r\n",
    
93.                                                                        tPara.Baud485,
    
94.                                                                         tPara.ParamVer,
    
95.                                                                         tPara.ucBackLight,
    9 p! O6 c% {- W( x
96.                                                                    paraptr->ucRadioMode);
    
97. 
    
98.                     printf("读取数据：Baud485=%x, ParamVer=%x, ucBackLight=%x, ucRadioMode=%f\r\n",
    . P7 ?+ B( a( n; c' s4 o- ?
99.                                                                         paraptr->Baud485,
    
100.                                                                             paraptr->ParamVer,
     # L9 P0 J4 w, Q5 w) J
101.                                                                            paraptr->ucBackLight,
     
102.                                                                           paraptr->ucRadioMode);
     
103.                     break;               
     
104.                 default:
     
105.                     /* 其它的键值不处理 */
     " k2 M( s! P: U
106.                     break;
     3 ]' ]) u5 n+ ^1 M: {
107.             }
     0 e3 b; @. R( J3 l  V6 z
108.         }
     
109.     }
     
110. }
     7 l& n  G) G) p* S4 J" ^5 a/ e5 Z; W

复制代码

71.7 实验例程说明（IAR）
* P4 }- N6 e! S0 G/ s配套例子：

V7-049_内部Flash模拟EEPROM

4 j  ~, H2 N% |2 v0 b' @. ^8 M+ p实验目的：

' q' h5 z5 ?' D/ `3 H" a/ i5 y% R学习内部Flash模拟EEPROM。
/ [5 T" N; ~% t& {- d, z; t实验内容：

使用内部Flash模拟EEPROM，务必告诉编译要使用的存储空间，防止这个空间存入了程序。
对于同一个地址空间，仅支持一次编程(不推荐二次编程，即使是将相应bit由数值1编程0)。
只能对已经擦除的空间做编程，擦除1个扇区是128KB。
H7的Flash编程时，务必保证要编程的地址是32字节对齐的，即此地址对32求余为0。
, a7 v# w6 h+ e$ Y; ~并且编程的数据必须32字节整数倍，函数bsp_WriteCpuFlash对字节数不够32字节整数倍的情况自动补0。
5 E( B) Y9 ^" ~
5 i6 d4 H- h  X& ^+ m, x实验操作：
, T' w. b* l0 e% X; c% o1 d3 S" e" a
K1键按下，将8bit，16bit和32bit数据写入到内部Flash。
K2键按下，将结构体数据写入到内部Flash。
8 y' u* a! J3 \5 @4 ?- l* z! F/ s上电后串口打印的信息：

* N0 ?* y! T7 m: {% w波特率 115200，数据位 8，奇偶校验位无，停止位 1。
; X' a3 S% O* o% @- T9 a0 _
, q: {$ c! c. @

! A4 R/ {3 `! d; q! a程序设计：
3 h" j. l! l  V2 ~+ L
& J$ q' o. E! f  系统栈大小分配：

  RAM空间用的DTCM：

# B: {7 N# |( N2 E+ o( m
" y! V; M9 Q. S- H1 k/ {1 E  硬件外设初始化
$ K" Y! P) p# j9 T: m5 R: S
硬件外设的初始化是在 bsp.c 文件实现：
' M7 m5 E6 w/ Y; L: ^5 d9 b0 O
# I4 r3 P& m8 X+ ]8 `

1. /*
   ) v. l/ S7 J! G! B( v  _
2. *********************************************************************************************************
   ( F/ j- h5 c8 m4 F3 d
3. *    函 数 名: bsp_Init
   5 H0 p: {  @6 L' s; A6 A) q
4. *    功能说明: 初始化所有的硬件设备。该函数配置CPU寄存器和外设的寄存器并初始化一些全局变量。只需要调用一次
   
5. *    形    参：无
   
6. *    返 回 值: 无
   * ]+ M+ f. p+ N# q
7. *********************************************************************************************************
   0 X, [. l& B0 u4 Y2 q
8. */
   ! \% H- ~5 w/ W, a( d0 M
9. void bsp_Init(void)
   9 J& N2 l6 s9 {1 j
10. {
    ' l! w; [! J9 ^9 X
11.     /* 配置MPU */
    % c( p: g2 o/ E6 \: W6 ?0 N9 Y' m
12.     MPU_Config();
    
13. 
    
14.     /* 使能L1 Cache */
    3 ^- B' A$ ^4 V* y+ a5 u
15.     CPU_CACHE_Enable();
    ( n7 J0 @4 V/ U2 ~" a
16. 
    
17.     /*
    
18.        STM32H7xx HAL 库初始化，此时系统用的还是H7自带的64MHz，HSI时钟:
    * S- q4 ]- w% [! h6 p
19.        - 调用函数HAL_InitTick，初始化滴答时钟中断1ms。
    
20.        - 设置NVIV优先级分组为4。
    
21.      */
    0 u% P9 f/ Z3 m& I3 w0 F+ d
22.     HAL_Init();
    / ^8 {  B& @! R! g; a# i* y
23. 
    0 B, d, {! }/ w) {% Q" u
24.     /*
    
25.        配置系统时钟到400MHz
    , J4 |- K# R  d5 b- g& e
26.        - 切换使用HSE。
    5 d) u% N# ^5 {* l2 s) o; _: [
27.        - 此函数会更新全局变量SystemCoreClock，并重新配置HAL_InitTick。
    ( @& U& Q4 y7 ~+ k# n6 _3 w
28.     */
      T+ X9 s. m% N' t+ u5 O0 l
29.     SystemClock_Config();
    
30. 
    ' h( z+ m' g1 z# u, H" \
31.     /*
    
32.        Event Recorder：
    
33.        - 可用于代码执行时间测量，MDK5.25及其以上版本才支持，IAR不支持。
    8 F4 F. p0 |9 Q# ?
34.        - 默认不开启，如果要使能此选项，务必看V7开发板用户手册第xx章
    ; i( n2 W8 ^1 j
35.     */   
    
36. #if Enable_EventRecorder == 1  
    
37.     /* 初始化EventRecorder并开启 */
      n! m# w  c2 l6 r* X
38.     EventRecorderInitialize(EventRecordAll, 1U);
    ( [3 h* E' F( t2 f  y) b
39.     EventRecorderStart();
    3 M. Y0 G2 c1 x
40. #endif
    
41. 
    
42. bsp_InitDWT();      /* 初始化DWT时钟周期计数器 */      
    6 Q9 x- o: ]$ \* q! Y! ^5 V% f# T6 E. f
43.     bsp_InitKey();        /* 按键初始化，要放在滴答定时器之前，因为按钮检测是通过滴答定时器扫描 */
    
44.     bsp_InitTimer();      /* 初始化滴答定时器 */
    % B9 X: W! w3 p2 ?% Y
45.     bsp_InitLPUart();    /* 初始化串口 */
    9 g$ F  d- N. m1 a3 v" e
46.     bsp_InitExtIO();    /* 初始化FMC总线74HC574扩展IO. 必须在 bsp_InitLed()前执行 */   
    ' a( C4 x  o/ j8 k
47.     bsp_InitLed();        /* 初始化LED */   
    . b. ?7 d1 s/ l: ?- w7 _! r! F
48.     bsp_InitExtSDRAM(); /* 初始化SDRAM */
      y0 M6 b; G' I8 e
49. }
    

复制代码

  MPU配置和Cache配置：
) e, h6 W4 E4 v( Z
! Z4 O, Z# F9 Y数据Cache和指令Cache都开启。配置了AXI SRAM区（本例子未用到AXI SRAM）和FMC的扩展IO区。
1 ^3 O( P* S5 o: h- y

1. /*
   
2. *********************************************************************************************************
     ^5 ~" F& K  F! c
3. *    函 数 名: MPU_Config
   - n2 u. k5 q% [8 y0 j; s
4. *    功能说明: 配置MPU
   
5. *    形    参: 无
   
6. *    返 回 值: 无
   & c, E( j9 K  Y& W# ~; o8 M, W
7. *********************************************************************************************************
   + s% u) I9 t  n2 G' c# t; K+ F
8. */
   
9. static void MPU_Config( void )
   ' E) b5 `# f3 X; K7 M
10. {
    
11.     MPU_Region_InitTypeDef MPU_InitStruct;
    * k" L3 |7 x, M5 v7 t
12. 
    
13.     /* 禁止 MPU */
    ( M) G: r* I! N, k, l/ R
14.     HAL_MPU_Disable();
    % D2 y; U/ c- t! S% g
15. 
    
16.     /* 配置AXI SRAM的MPU属性为Write back, Read allocate，Write allocate */
    9 r' i7 _/ l* I# R2 F' F% e! S; Y
17.     MPU_InitStruct.Enable           = MPU_REGION_ENABLE;
    
18.     MPU_InitStruct.BaseAddress      = 0x24000000;
    2 H6 x# R6 ~% p: a2 V" G
19.     MPU_InitStruct.Size             = MPU_REGION_SIZE_512KB;
    ( X' T; M! N( i* Y; k
20.     MPU_InitStruct.AccessPermission = MPU_REGION_FULL_ACCESS;
    # P- K7 j3 J" r) a
21.     MPU_InitStruct.IsBufferable     = MPU_ACCESS_BUFFERABLE;
    # w2 K% z/ x& H8 _
22.     MPU_InitStruct.IsCacheable      = MPU_ACCESS_CACHEABLE;
    - q3 L6 S, \9 O" z2 j( b1 r
23.     MPU_InitStruct.IsShareable      = MPU_ACCESS_NOT_SHAREABLE;
    0 z9 X: x" t+ c5 |
24.     MPU_InitStruct.Number           = MPU_REGION_NUMBER0;
      p4 q8 |. u5 H  l4 @1 V$ f
25.     MPU_InitStruct.TypeExtField     = MPU_TEX_LEVEL1;
    - l5 b% K7 V7 l/ W6 e0 P
26.     MPU_InitStruct.SubRegionDisable = 0x00;
    
27.     MPU_InitStruct.DisableExec      = MPU_INSTRUCTION_ACCESS_ENABLE;
      n7 U+ {& e2 P8 e" v
28. 
    9 \% b7 l; J5 G  n4 y  l2 Y- t
29.     HAL_MPU_ConfigRegion(&MPU_InitStruct);
    
30. 
    
31. 
    
32.     /* 配置FMC扩展IO的MPU属性为Device或者Strongly Ordered */
    
33.     MPU_InitStruct.Enable           = MPU_REGION_ENABLE;
    
34.     MPU_InitStruct.BaseAddress      = 0x60000000;
    ! p: W1 a  k/ i& ?% o- F  j, |
35.     MPU_InitStruct.Size             = ARM_MPU_REGION_SIZE_64KB;   
    ' d0 `& N" l" z1 z# `, p/ @- J
36.     MPU_InitStruct.AccessPermission = MPU_REGION_FULL_ACCESS;
    . F4 D! K+ O/ L; y5 j& B8 F0 E2 P6 E+ [
37.     MPU_InitStruct.IsBufferable     = MPU_ACCESS_BUFFERABLE;
    
38.     MPU_InitStruct.IsCacheable      = MPU_ACCESS_NOT_CACHEABLE;   
    & F% Y( g  U3 [& E
39.     MPU_InitStruct.IsShareable      = MPU_ACCESS_NOT_SHAREABLE;
    ; H4 y  h) U$ S4 x) i
40.     MPU_InitStruct.Number           = MPU_REGION_NUMBER1;
    
41.     MPU_InitStruct.TypeExtField     = MPU_TEX_LEVEL0;
    : _  t9 u1 c3 k2 B) x) Y
42.     MPU_InitStruct.SubRegionDisable = 0x00;
    1 G: ^, U% ~. O( E# x+ }5 o  w+ W
43.     MPU_InitStruct.DisableExec      = MPU_INSTRUCTION_ACCESS_ENABLE;
    ) J6 i" E7 q- s, G$ r
44. 
    
45.     HAL_MPU_ConfigRegion(&MPU_InitStruct);
    0 [- l" u4 U5 ^9 Z7 X
46. 
    , l  @$ K0 H6 G1 p7 ~, l; \! R
47.     /*使能 MPU */
    
48.     HAL_MPU_Enable(MPU_PRIVILEGED_DEFAULT);
    7 T% o0 c; m! ~/ C  L% U$ d
49. }
    0 ]3 C6 S1 L2 O: C
50. 
      e6 V: \, ?6 n* W
51. /*
    
52. *********************************************************************************************************
    $ V0 C9 N" b/ r' Y
53. *    函 数 名: CPU_CACHE_Enable
    4 u0 v  E. p: c
54. *    功能说明: 使能L1 Cache
    
55. *    形    参: 无
    
56. *    返 回 值: 无
    + ?5 D# H4 w/ q; o1 }4 n$ r
57. *********************************************************************************************************
    " h" j# N3 A9 B2 N3 O- q, q
58. */
    
59. static void CPU_CACHE_Enable(void)
    
60. {
    
61.     /* 使能 I-Cache */
    & E) a% e( y7 ~; b3 ?( f- Y
62.     SCB_EnableICache();
    
63. 
    3 m" i+ D+ M. }) R
64.     /* 使能 D-Cache */
    ( J, X" r  f/ K) Q8 b
65.     SCB_EnableDCache();
    4 T8 [4 S" {4 S$ c! s% B5 r
66. }

复制代码

: p4 q, p1 p* x& a. Z, H6 t5 |& \4 T
2 e7 x9 q, u! O, Q, Z3 x" x% W/ O
1 q2 }6 ]" M% R( T" R/ K  每10ms调用一次蜂鸣器处理：

% i) D9 v* a0 T+ l# V& E蜂鸣器处理是在滴答定时器中断里面实现，每10ms执行一次检测。

6 E1 Z9 W2 \# ?2 g/ o

1. /*
   
2. *********************************************************************************************************
   5 _2 ~+ x# ?5 s% k7 G' M2 m6 X  C
3. *    函 数 名: bsp_RunPer10ms
   & A* U% k3 z: T3 n' l) Z
4. *    功能说明: 该函数每隔10ms被Systick中断调用1次。详见 bsp_timer.c的定时中断服务程序。一些处理时间要求
   
5. *              不严格的任务可以放在此函数。比如：按键扫描、蜂鸣器鸣叫控制等。
   
6. *    形    参: 无
   & |1 F) ^3 l) N; k, \/ d7 y
7. *    返 回 值: 无
   9 s1 |6 ^; f1 L; y/ O! @
8. *********************************************************************************************************
   
9. */
   
10. void bsp_RunPer10ms(void)
    + N4 _  @. J. m$ ]0 R
11. {
    
12.     bsp_KeyScan10ms();
    7 X1 T2 N6 i! d6 Y! Z3 c
13. }
    ) J2 u, k; _. k( m, Q, N

复制代码

9 q8 n3 l! g* m) C( k* w/ n
8 ~* Q3 T; S, u/ K4 b0 R  主功能：

1 \5 o9 b  k: J( F主程序实现如下操作：

: j  S; c5 d  S8 y& S4 Q- Q 启动一个自动重装软件定时器，每100ms翻转一次LED2。
K1键按下，将8bit，16bit和32bit数据写入到内部Flash。
K2键按下，将结构体数据写入到内部Flash。

1. /*
   
2. *********************************************************************************************************
   7 @3 }6 t+ Q- N7 d* r
3. *    函 数 名: main
   
4. *    功能说明: c程序入口
   
5. *    形    参: 无
   1 Q8 P" C7 J2 D+ G8 Q  h
6. *    返 回 值: 错误代码(无需处理)
   
7. *********************************************************************************************************
   & j% k# v1 w% J9 q/ u
8. */
   
9. int main(void)
   * Q6 Y2 e& L3 s- ^. ]
10. {
    
11.     uint8_t ucKeyCode;    /* 按键代码 */
    
12.     uint8_t  ucTest, *ptr8;
    
13.     uint16_t uiTest, *ptr16;
    ' J) L5 d" }' a5 C9 j" G
14.     uint32_t ulTest, *ptr32;
    , b1 S/ Z/ O/ }) }9 P% O( l. l
15.     PARAM_T tPara, *paraptr;
    
16. 
    
17. 
    - E/ `+ W$ r: f
18.     /* 初始化数据 */
    3 P5 p% T1 d, @3 b% ^
19.     tPara.Baud485 = 0x5555AAAA;
    * U2 j7 h& g7 n- s2 k. @1 ?
20.     tPara.ParamVer = 0x99;
    + X4 ?: b. P! t! r1 }  w& `) u
21.     tPara.ucBackLight = 0x7788;
    
22.     tPara.ucRadioMode = 99.99f;
    ( H, e* m% x0 ~
23. 
    * G# Z' V( d, \3 o8 P# \
24. 
    
25.     bsp_Init();        /* 硬件初始化 */
    
26.     PrintfLogo();    /* 打印例程名称和版本等信息 */
    8 z7 k( P9 J, e5 i% [) o7 s1 F
27.     PrintfHelp();    /* 打印操作提示 */
    
28. 
    
29.     bsp_StartAutoTimer(0, 100);    /* 启动1个100ms的自动重装的定时器 */
    ) p2 f; G4 F. ]
30.     while (1)
    " D! L# D7 ^/ i0 p2 W2 A$ ~
31.     {
    7 m) i0 q0 K2 I$ C4 R
32.         bsp_Idle();        /* 这个函数在bsp.c文件。用户可以修改这个函数实现CPU休眠和喂狗 */
    " _- P: p5 _) `; F+ a( K
33. 
    
34.         /* 判断定时器超时时间 */
    
35.         if (bsp_CheckTimer(0))   
    , D: V( J, J! J! Q" c% ^1 e9 F
36.         {
    
37.             /* 每隔100ms 进来一次 */  
    
38.             bsp_LedToggle(2);
    : ^/ }: A: H- M7 m7 Q6 G
39.         }
    ( }& P+ z; T2 T' g4 v1 H
40. 
    4 X( b! s7 ?) P# }0 p8 u4 g
41.         /* 按键滤波和检测由后台systick中断服务程序实现，我们只需要调用bsp_GetKey读取键值即可。 */
    , C3 k3 q9 o* }& ^) l, J; e
42.         ucKeyCode = bsp_GetKey();    /* 读取键值, 无键按下时返回 KEY_NONE = 0 */
    + O4 u! |% E' W: z& u5 w
43.         if (ucKeyCode != KEY_NONE)
    
44.         {
    * h) c9 [% M; p2 I4 J/ V" z
45.             switch (ucKeyCode)
    
46.             {
    / X- M- t- d9 |0 ~% \
47.                 case KEY_DOWN_K1:            /* K1键按下，将8bit，16bit和32bit数据写入到内部Flash */
    % J. q2 d5 g/ F. ~
48. 
    
49.                 /*
    
50.                  1、对于同一个地址空间，仅支持一次编程(不推荐二次编程，即使是将相应bit由数值1编程0)。
    6 r2 |- w/ J9 r4 ^; L
51.                  2、只能对已经擦除的空间做编程，擦除1个扇区是128KB。
    
52.                  3、H7的Flash编程时，务必保证要编程的地址是32字节对齐的，即此地址对32求余为0。并且编
    ) I2 n5 D0 z  D( w; ^9 r6 d
53. 程的数据必须32字节整数倍。函数bsp_WriteCpuFlash对字节数不够32字节整数倍的情况自动补
    3 b/ f* k4 s9 M, k
54. 0。
    
55.                 */
    7 Z: W- y4 X; v# t5 |. ?. y
56.                      /* 擦除扇区 */
    - x( t% B; D+ M4 y8 \9 `
57.                     bsp_EraseCpuFlash((uint32_t)para_flash_area);
    
58. 
    ; ^- H# G2 P& C1 T* M$ Z
59.                     ucTest = 0xAA;
    
60.                     uiTest = 0x55AA;
    
61.                     ulTest = 0x11223344;
    / Q. n# l3 L- {# c( M; v
62. 
    - D8 b' t7 [5 L- H1 r5 m: r6 _( C
63.                     /* 扇区写入数据 */
    / F( {8 {  g) ?3 p2 x0 x6 {+ z
64.                     bsp_WriteCpuFlash((uint32_t)para_flash_area + 32*0,  (uint8_t *)&ucTest,
    6 h0 P) W+ d  I  F1 E" B" F1 z& }4 K
65. sizeof(ucTest));
    
66.                     bsp_WriteCpuFlash((uint32_t)para_flash_area + 32*1,  (uint8_t *)&uiTest,
    
67. sizeof(uiTest));
    $ j. H- `# q0 ~4 @
68.                     bsp_WriteCpuFlash((uint32_t)para_flash_area + 32*2,  (uint8_t *)&ulTest,
    
69. sizeof(ulTest));               
    
70. 
    % f! ?) h/ e! M" U6 a% K
71.                     /* 读出数据并打印 */
    
72.                     ptr8  = (uint8_t  *)(para_flash_area + 32*0);
    / S1 I# ^4 ~# ^- J
73.                     ptr16 = (uint16_t *)(para_flash_area + 32*1);
    
74.                     ptr32 = (uint32_t *)(para_flash_area + 32*2);
    
75. 
    
76.                     printf("写入数据：ucTest = %x, uiTest = %x, ulTest = %x\r\n", ucTest, uiTest, ulTest);
    
77.                     printf("读取数据：ptr8 = %x, ptr16 = %x, ptr32 = %x\r\n", *ptr8, *ptr16, *ptr32);
    2 s- R) a5 ?  u) y% M2 B
78. 
    , u  ]! o  h  w4 W+ e9 Z0 w
79.                     break;
    
80. 
    
81.                 case KEY_DOWN_K2:            /* K2键按下， 将结构体数据写入到内部Flash */
    ! p( X4 T- t4 b2 j$ z% j9 @
82.                     /* 擦除扇区 */
    
83.                     bsp_EraseCpuFlash((uint32_t)para_flash_area);
    ' [/ f* h; ~" J8 X+ K# e, q& e5 R
84. 
    ! N+ U) R3 U3 I0 R7 C8 |
85.                     /* 扇区写入数据 */
    - J) m6 r9 C# ^- o8 q
86.                     bsp_WriteCpuFlash((uint32_t)para_flash_area,  (uint8_t *)&tPara, sizeof(tPara));            
    
87. 
    
88.                     /* 读出数据并打印 */
    / ]. j  O+ r( R% m
89.                     paraptr  = (PARAM_T  *)((uint32_t)para_flash_area);
    , j' v( _! ~* V! c7 E( p
90. 
    ) @4 L2 r+ q( a0 d( S9 }
91. 
    
92.                     printf("写入数据：Baud485=%x, ParamVer=%x, ucBackLight=%x, ucRadioMode=%f\r\n",
    
93.                                                                        tPara.Baud485,
    
94.                                                                         tPara.ParamVer,
    
95.                                                                         tPara.ucBackLight,
    8 L! {! {* o; E# C: U% W) V6 _
96.                                                                    paraptr->ucRadioMode);
    " i; I0 H; \( u! Z3 `7 O) ]! y
97. 
    
98.                     printf("读取数据：Baud485=%x, ParamVer=%x, ucBackLight=%x, ucRadioMode=%f\r\n",
    
99.                                                                         paraptr->Baud485,
    0 }6 @' E9 G0 k. L
100.                                                                             paraptr->ParamVer,
     5 j. ]! x+ J( `& q& W
101.                                                                            paraptr->ucBackLight,
     
102.                                                                           paraptr->ucRadioMode);
     
103.                     break;               
     ( g8 {- I$ X  c- w& v5 R1 T1 o
104.                 default:
     
105.                     /* 其它的键值不处理 */
     
106.                     break;
     
107.             }
     
108.         }
     
109.     }
     
110. }

复制代码

! j, V& N5 u" n7 m! {2 f' c- o5 v
0 }) M6 d; d$ u! c" c6 h! {
( z, z6 g' Y6 Y- S) N; S3 y; j71.8 总结
) m$ |9 W$ T$ h! N$ l- X本章节就为大家讲解这么多， 实际应用中的注意事项比较多，应用到项目之前务必实际测试熟悉下。

. g  x: r) n! R( C1 n5 P+ S