71.1 初学者重要提示
! n! f. p& [, H  学习本章节前，务必优先学习第70章。
  使用内部Flash模拟EEPROM，务必告诉编译要使用的存储空间，防止这个空间存入了程序。
6 W8 Q' W& `1 z  E. F  STM32H7的Flash编程时，务必保证要编程的地址是32字节对齐的，即此地址对32求余为0。并且编程的数据必须32字节整数倍。
' M: H( _+ y2 v  STM32H743XI有两个独立的BANK，一个BANK的编程和擦除操作对另一个BANK没有任何影响。但是用户应用程序和要擦写的Flash扇区在同一个BANK，在执行擦写操作时，应用应用程序将停止运行，包括中断服务程序。
: ~7 ^( L. \. s6 g& r2 @  使用内部Flash模拟EEPROM要做到先擦除后使用。
71.2 模拟EEPROM驱动设计
$ v+ N8 a; ]  c  y' ]% w/ G, U这里重点把内部Flash的读取，编程和擦除做个说明。

71.2.1 内部Flash擦除的实现
内部Flash的擦除思路如下：

  第1步，获取擦除地址所处的扇区。
/ |3 X- H2 r2 c+ O1 l- K0 x; |  第2步，调用函数HAL_FLASH_Unlock解锁。
  第3步，调用函数HAL_FLASHEx_Erase擦除一个扇区。
6 d! e5 b* T2 Q. |4 m  第4步，调用函数HAL_FLASH_Lock上锁。
按照这个思路，程序实现如下：
/ G0 P1 l# ~5 m1 J+ j
" I2 V; @6 [6 p: _/ y- t+ F' M

1. 1.    /*
   + h1 W. t& f3 b8 P* ?. J
2. 2.    ******************************************************************************************************
   
3. 3.    *    函 数 名: bsp_EraseCpuFlash
   
4. 4.    *    功能说明: 擦除CPU FLASH一个扇区 （128KB)
   " r  o  g- ]/ X
5. 5.    *    形    参: _ulFlashAddr : Flash地址
   
6. 6.    *    返 回 值: 0 成功， 1 失败
   
7. 7.    *              HAL_OK       = 0x00,
   
8. 8.    *              HAL_ERROR    = 0x01,
   
9. 9.    *              HAL_BUSY     = 0x02,
   
10. 10.    *              HAL_TIMEOUT  = 0x03
    ! f$ _' T( d1 Q" X( B8 I% g
11. 11.    *
    
12. 12.    ******************************************************************************************************
    3 g. e) P5 ?! G$ W
13. 13.    */
    & ?# x; ^& l- Y" U& y! F
14. 14.    uint8_t bsp_EraseCpuFlash(uint32_t _ulFlashAddr)
      w5 u$ p( f% y
15. 15.    {
    
16. 16.        uint32_t FirstSector = 0, NbOfSectors = 0;
    $ |2 o  Q) C4 [* U5 e9 C
17. 17.        FLASH_EraseInitTypeDef EraseInitStruct;
    
18. 18.        uint32_t SECTORError = 0;
    
19. 19.        uint8_t re;
    
20. 20.   
    
21. 21.        /* 解锁 */
    
22. 22.        HAL_FLASH_Unlock();
    $ S8 B. W/ V( T# y# k% c9 Q
23. 23.        
    3 y' J) E4 l! V9 X- e
24. 24.        /* 获取此地址所在的扇区 */
    
25. 25.        FirstSector = bsp_GetSector(_ulFlashAddr);
    ; ^" E; d3 [; R* I6 L# r
26. 26.        
    
27. 27.        /* 固定1个扇区 */
    
28. 28.        NbOfSectors = 1;   
    
29. 29.   
    
30. 30.        /* 擦除扇区配置 */
    
31. 31.        EraseInitStruct.TypeErase     = FLASH_TYPEERASE_SECTORS;
    9 S* X" `7 c+ K
32. 32.        EraseInitStruct.VoltageRange  = FLASH_VOLTAGE_RANGE_3;
    ) |. l" J1 `$ W$ x
33. 33.        
    1 y- ~: s6 ~9 w
34. 34.        if (_ulFlashAddr >= ADDR_FLASH_SECTOR_0_BANK2)
    , ]$ d6 q4 v5 V; ?1 ], C2 H
35. 35.        {
    $ m* l5 Z9 R' S) p8 a7 W
36. 36.            EraseInitStruct.Banks         = FLASH_BANK_2;
    
37. 37.        }
    
38. 38.        else
    ) K' ~8 u; |) c" H
39. 39.        {
    
40. 40.            EraseInitStruct.Banks         = FLASH_BANK_1;
    0 W2 n( f7 ]. d/ B
41. 41.        }
    
42. 42.        
    
43. 43.        EraseInitStruct.Sector        = FirstSector;
    
44. 44.        EraseInitStruct.NbSectors     = NbOfSectors;
    ( h5 m; J7 o4 o4 G
45. 45.        
    
46. 46.        /* 扇区擦除 */   
    $ A4 U5 @: M7 n# q! I5 o7 D
47. 47.        re = HAL_FLASHEx_Erase(&EraseInitStruct, &SECTORError);
    ' ~) z# k+ @7 A0 G  R( f
48. 48.        
    ; \) W+ q, |6 K. s$ G; x* i
49. 49.        /* 擦除完毕后，上锁 */
    
50. 50.        HAL_FLASH_Lock();   
    ! |* G: N8 T: a
51. 51.        
    
52. 52.        return re;
    / B8 c+ @$ L1 q- A  C7 f
53. 53.    }

复制代码

! [, L, g' w) v: W9 G
这里将此程序设计的关键点为大家做个说明：
* i  P! k4 U* y, `' `
  第25行函数是通过函数bsp_GetSector获取要擦除地址所处的扇区。这个函数的实现比较简单，代码如下：
; B' C3 i$ C" z6 O' I* ^/ @% `

1. /*
   # _' _0 K# |, K4 T: j3 P
2. *********************************************************************************************************
   
3. *    函 数 名: bsp_GetSector
   
4. *    功能说明: 根据地址计算扇区首地址
   / B, f7 z) \# I) A! G! t& _
5. *    形    参: 无
   
6. *    返 回 值: 扇区号（0-7)
   
7. *********************************************************************************************************
   
8. */
   $ ?; i0 o) K! u* E
9. uint32_t bsp_GetSector(uint32_t Address)
   
10. {
    
11.     uint32_t sector = 0;
    
12. 
    
13.     if (((Address < ADDR_FLASH_SECTOR_1_BANK1) && (Address >= ADDR_FLASH_SECTOR_0_BANK1)) || \
    1 H. Z' O8 B, R# w# G% u1 {- x; o! w
14.         ((Address < ADDR_FLASH_SECTOR_1_BANK2) && (Address >= ADDR_FLASH_SECTOR_0_BANK2)))   
    
15.     {
    
16.         sector = FLASH_SECTOR_0;  
    9 H2 r/ K: b! V- n
17.     }
    1 {9 N( O9 E0 u- ]/ c
18.     else if (((Address < ADDR_FLASH_SECTOR_2_BANK1) && (Address >= ADDR_FLASH_SECTOR_1_BANK1)) || \
    " H' Z0 [" U/ b+ m4 v9 Q7 t) N( f
19.       ((Address < ADDR_FLASH_SECTOR_2_BANK2) && (Address >= ADDR_FLASH_SECTOR_1_BANK2)))   
    $ V1 c7 S; B; V+ P$ `& r- w7 T
20.     {
    
21.         sector = FLASH_SECTOR_1;  
    2 F0 L' ^. K* y4 @
22.     }
    
23.     else if (((Address < ADDR_FLASH_SECTOR_3_BANK1) && (Address >= ADDR_FLASH_SECTOR_2_BANK1)) || \
    + W4 d( a0 \7 D
24.       ((Address < ADDR_FLASH_SECTOR_3_BANK2) && (Address >= ADDR_FLASH_SECTOR_2_BANK2)))   
    % |; b7 C5 ?% p5 s& ]
25.     {
    6 f0 W6 v5 U' n
26.         sector = FLASH_SECTOR_2;  
    9 Y0 u! P. w- c; ^' K
27.     }
    
28.     else if (((Address < ADDR_FLASH_SECTOR_4_BANK1) && (Address >= ADDR_FLASH_SECTOR_3_BANK1)) || \
    : ^& p3 G: R7 C5 G( V5 K
29.       ((Address < ADDR_FLASH_SECTOR_4_BANK2) && (Address >= ADDR_FLASH_SECTOR_3_BANK2)))   
    
30.     {
    
31.         sector = FLASH_SECTOR_3;  
    - x9 J5 x' w: X
32.     }
    4 h- n4 @- Z4 o0 o1 c- s  T; }+ p$ T
33.     else if (((Address < ADDR_FLASH_SECTOR_5_BANK1) && (Address >= ADDR_FLASH_SECTOR_4_BANK1)) || \
    $ t7 O2 ^5 S* x5 ^8 `
34.       ((Address < ADDR_FLASH_SECTOR_5_BANK2) && (Address >= ADDR_FLASH_SECTOR_4_BANK2)))   
    
35.     {
    
36.         sector = FLASH_SECTOR_4;  
    
37.     }
    * g3 u# m: q3 [; c; O; B# ]
38.     else if (((Address < ADDR_FLASH_SECTOR_6_BANK1) && (Address >= ADDR_FLASH_SECTOR_5_BANK1)) || \
    
39.       ((Address < ADDR_FLASH_SECTOR_6_BANK2) && (Address >= ADDR_FLASH_SECTOR_5_BANK2)))   
    
40.     {
    # D  n/ M* u1 ]2 E1 p9 t8 S
41.         sector = FLASH_SECTOR_5;  
    
42.     }
    ) M% G  Z- `' ?; w4 q
43.     else if (((Address < ADDR_FLASH_SECTOR_7_BANK1) && (Address >= ADDR_FLASH_SECTOR_6_BANK1)) || \
    
44.       ((Address < ADDR_FLASH_SECTOR_7_BANK2) && (Address >= ADDR_FLASH_SECTOR_6_BANK2)))   
    
45.     {
    
46.         sector = FLASH_SECTOR_6;  
    
47.     }
    
48.     else if (((Address < ADDR_FLASH_SECTOR_0_BANK2) && (Address >= ADDR_FLASH_SECTOR_7_BANK1)) || \
    4 \9 z* p" k/ i
49.       ((Address < CPU_FLASH_END_ADDR) && (Address >= ADDR_FLASH_SECTOR_7_BANK2)))
    , o9 C( R5 r  C9 @6 _
50.     {
    
51.         sector = FLASH_SECTOR_7;  
    
52.     }
    
53.     else
    
54.     {
    
55.         sector = FLASH_SECTOR_7;
    
56.     }
    
57. 
    
58.     return sector;
    
59. }
    2 [$ N# B  t/ C' z6 [

复制代码

( q* h4 }6 g3 ~8 K2 \- {. V由于STM32H7的BANK1和BANK2是独立的，都有8个扇区，所以程序里面只需返回要擦除地址所处的扇区号即可。
, _4 e: s8 P! Z" q) E+ v, E
6 H7 O8 c- |/ f+ S" B  第47行的擦除函数HAL_FLASHEx_Erase在第70章的4.4小节有说明。
71.2.2 内部Flash编程的实现
内部Flash的编程思路如下：

0 J7 O& ~/ z# t  _. w! a( V$ v% `  第1步，判断是否要编写数据进去，如果数据已经在内部Flash里面。
7 Q2 D% ]2 {2 B+ B! Q9 b  第2步，调用函数HAL_FLASH_Unlock解锁。
  第3步，调用函数HAL_FLASH_Program对内部Flash编程数据。
  第4步，调用函数HAL_FLASH_Lock上锁。
, P! E: w( e- w8 }0 g) W1 i按照这个思路，程序实现如下：
8 c  [+ _' u# p: i% ?+ x8 g
1 _# a7 @0 o/ Z+ o0 a7 g( T

1. 1.    /*
   
2. 2.    ******************************************************************************************************
   4 }2 x2 a  Z. f6 ?% s# O* Z: P
3. 3.    *    函 数 名: bsp_WriteCpuFlash
   3 M7 ]3 r& A) j, R6 [; ^
4. 4.    *    功能说明: 写数据到CPU 内部Flash。 必须按32字节整数倍写。不支持跨扇区。扇区大小128KB. \
   
5. 5.    *              写之前需要擦除扇区. 长度不是32字节整数倍时，最后几个字节末尾补0写入.
   / l& b0 Q  d# U
6. 6.    *    形    参: _ulFlashAddr : Flash地址
   
7. 7.    *             _ucpSrc : 数据缓冲区
   
8. 8.    *             _ulSize : 数据大小（单位是字节, 必须是32字节整数倍）
   & M5 F: P2 @4 H/ C$ e# M
9. 9.    *    返 回 值: 0-成功，1-数据长度或地址溢出，2-写Flash出错(估计Flash寿命到)
   
10. 10.    ******************************************************************************************************
    : G  `& V0 R6 r8 n
11. 11.    */
      Q8 {" X( S  B
12. 12.    uint8_t bsp_WriteCpuFlash(uint32_t _ulFlashAddr, uint8_t *_ucpSrc, uint32_t _ulSize)
    
13. 13.    {
    & L3 H$ k0 C3 l" i* {1 X
14. 14.        uint32_t i;
    
15. 15.        uint8_t ucRet;
      u! q- l1 Z* f( u/ m: k0 O3 E
16. 16.   
      g% B8 Y! o% K: v+ m6 j* W. p
17. 17.        /* 如果偏移地址超过芯片容量，则不改写输出缓冲区 */
    # [% T0 r* |3 w( T! D  Y* O
18. 18.        if (_ulFlashAddr + _ulSize > CPU_FLASH_BASE_ADDR + CPU_FLASH_SIZE)
    0 I- s* T7 G* B! ~
19. 19.        {
    
20. 20.            return 1;
    0 e' @+ u6 f- {! I- _3 v) E, s
21. 21.        }
    $ z7 e4 s8 a2 I
22. 22.   
    3 P1 D' M$ q& p$ f  ^8 M; x) S7 E
23. 23.        /* 长度为0时不继续操作  */
    ; q2 ~# d6 ~: Y# o0 X+ T. d
24. 24.        if (_ulSize == 0)
      ^4 m, N1 u% D% G# H) K( o
25. 25.        {
    / X) B% A* k7 _9 Y* _3 s$ M4 _
26. 26.            return 0;
      M7 R: V6 t  j# c* s
27. 27.        }
    ) R' l: l& F1 F! Z
28. 28.   
    
29. 29.        ucRet = bsp_CmpCpuFlash(_ulFlashAddr, _ucpSrc, _ulSize);
    
30. 30.   
    ; {5 u2 E$ u; ?9 l6 C$ x
31. 31.        if (ucRet == FLASH_IS_EQU)
    
32. 32.        {
    $ l( q, H" f2 h/ y+ w" P
33. 33.            return 0;
    ' @& f& o* t4 e7 E0 t+ L
34. 34.        }
    
35. 35.   
    
36. 36.        __set_PRIMASK(1);          /* 关中断 */
    
37. 37.   
    1 F9 V( ~4 Z: B" ?7 P
38. 38.        /* FLASH 解锁 */
    & S2 c# g6 o5 H0 c5 N" ]- M
39. 39.        HAL_FLASH_Unlock();
    
40. 40.   
    7 P$ q% y" X8 \0 N
41. 41.        for (i = 0; i < _ulSize / 32; i++)   
    
42. 42.        {
    : d2 n1 X' V7 d9 ?3 Z1 N; i3 V
43. 43.            uint64_t FlashWord[4];
      A$ _+ q7 t! o( e* r' S
44. 44.            
    , s8 ]3 j0 W4 @+ i
45. 45.            memcpy((char *)FlashWord, _ucpSrc, 32);
    
46. 46.            _ucpSrc += 32;
    
47. 47.            
    
48. 48.            if (HAL_FLASH_Program(FLASH_TYPEPROGRAM_FLASHWORD, _ulFlashAddr,
    2 e* [$ Z' a/ d) g% p( i5 ]1 C
49. 49.                                      (uint64_t)((uint32_t)FlashWord)) == HAL_OK)
    
50. 50.            {
    
51. 51.                _ulFlashAddr = _ulFlashAddr + 32; /* 递增，操作下一个256bit */               
    * i9 z# f3 Q; c0 M( u) U* }8 D2 X9 M
52. 52.            }        
    
53. 53.            else
    ' C4 V+ ^& B) D6 A1 ^& h! ^
54. 54.            {
    1 }/ A2 V% o9 v! P# S$ o
55. 55.                goto err;
    
56. 56.            }
    
57. 57.        }
    
58. 58.        
    ; C; s, W4 e% Q/ d" w: |
59. 59.        /* 长度不是32字节整数倍 */
    
60. 60.        if (_ulSize % 32)
    * W8 f. n5 ]% f8 ]) f. A4 y
61. 61.        {
    5 B. p4 D0 a0 l# C- s( i
62. 62.            uint64_t FlashWord[4];
    $ f: k' U4 o0 U* R, w; m" J' T( S
63. 63.            
    
64. 64.            FlashWord[0] = 0;
    2 m: K' p" Y* S; p
65. 65.            FlashWord[1] = 0;
    ' E) m6 d2 G5 L* R0 ^
66. 66.            FlashWord[2] = 0;
    
67. 67.            FlashWord[3] = 0;
    
68. 68.            memcpy((char *)FlashWord, _ucpSrc, _ulSize % 32);
    : g, F1 X) e0 G( \& E# j3 c
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;
    7 q8 f' e6 ^, [4 p. P; ^% \3 p
73. 73.               
    : O' ]! b* P, D! V( m: {+ w
74. 74.            }        
    
75. 75.            else
    1 I* \! w6 @3 Y) d, Z. X
76. 76.            {
    $ }- `5 w3 P! O4 K
77. 77.                goto err;
    
78. 78.            }
    
79. 79.        }
    + i- g8 P. |# q3 W
80. 80.        
    
81. 81.          /* Flash 加锁，禁止写Flash控制寄存器 */
    
82. 82.          HAL_FLASH_Lock();
    
83. 83.   
    # s" r# L- ^2 ]5 q# A
84. 84.          __set_PRIMASK(0);          /* 开中断 */
    3 r7 i3 _" p7 @
85. 85.   
    # x) T. H2 G% j4 j. M: y
86. 86.        return 0;
    ' v1 @8 @8 T1 e: a: u) d  T7 h
87. 87.        
    + c8 X4 T( ?) L! i  h; J+ E, B' P
88. 88.    err:
    1 M. R) E$ Y! ?* m( P
89. 89.          /* Flash 加锁，禁止写Flash控制寄存器 */
    
90. 90.          HAL_FLASH_Lock();
    
91. 91.   
    7 s3 `) F. d- X$ f2 A
92. 92.          __set_PRIMASK(0);          /* 开中断 */
    / U$ ^3 w, \( J, m0 G
93. 93.   
    8 m6 B/ W3 M( }/ {7 ]% o8 `
94. 94.        return 1;
    0 h; a3 T1 t6 G3 N+ D
95. 95.    }
    * S4 g4 N2 e( ]: h6 V/ G2 [, u

复制代码

8 Z3 X) m; C" Y) W7 h关于此函数有几个要点：
% }8 d! Q, Q! i& Q  \
( l0 O0 Q  A7 W  J+ L  J  第1个参数必须32字节对齐，即要编程的Flash地址对32求余为0。
  第3个参数必须是32字节的整数倍，长度不是32字节整数倍时，最后几个字节补0写入。
  第29行，函数bsp_CmpCpuFlash放在这里只有一个作用，判断将要写入的数据是否已经在内部Flash存在，如果已经存在，无需重复写入，直接返回。
$ m# l. B$ ^. t; A5 r% \9 j* E/ H& K  第36行，做了一个关中断操作，这里有个知识点要给大家普及下，由于H7的BANK1和BANK2是独立的，当前正在擦除的扇区所处的BANK会停止所有在此BANK执行的程序，包含中断也会停止执行。比如当前的应用程序都在BANK1，如果要擦除或者编程BANK2，是不会不影响BANK1里面执行的程序。这里安全起见加上了开关中断。
* O9 m; u& o  q  第41到57行，先将32字节整数倍的数据通过函数HAL_FLASH_Program编程，此函数每次可以固定编程32字节数据。
# G& w2 z3 h5 u$ Z2 B4 n$ l  第60到79行，将剩余不足32字节的数据补0，凑齐32字节编程。
71.2.3 内部Flash读取的实现
内部Flash数据读取比较简单，采用总线方式读取，跟访问内部RAM是一样的。比如要读取地址
: F' r2 P6 S. d" H+ c, {4 V8 I
4 R9 {1 M9 i& V/ U: D0x08100000里面的一个32bit变量，我们就可以：

变量 = *(uint32_t *)(0x08100000)
* L! x1 @" @& q( B0 Z: n+ M9 \
8 {1 v6 m* J  |# ]) d& d8 i9 a0 K为了方便起见，也专门准备了一个函数：
# X! ]+ T3 z) ~  t9 W" n9 f
; a4 G2 t: R, {% L( q5 ]  ~0 t$ z, z( D

1. /*
   
2. *********************************************************************************************************
   7 h4 S6 r9 T$ k) W; \4 Q/ J& O0 ?
3. *    函 数 名: bsp_ReadCpuFlash
   
4. *    功能说明: 读取CPU Flash的内容
   8 J; K3 A% |+ y  v$ A( z
5. *    形    参:  _ucpDst : 目标缓冲区
   
6. *             _ulFlashAddr : 起始地址
   # f* J, @4 o& l5 o6 d& h, B
7. *             _ulSize : 数据大小（单位是字节）
   3 z: l" C+ U& [' a& x
8. *    返 回 值: 0=成功，1=失败
   
9. *********************************************************************************************************
   
10. */
    ) ^, j0 g9 b+ v- Q/ g7 n  F2 E4 g6 O' ~
11. uint8_t bsp_ReadCpuFlash(uint32_t _ulFlashAddr, uint8_t *_ucpDst, uint32_t _ulSize)
    
12. {
    
13.     uint32_t i;
    
14. 
    ( q7 }' Z3 M" b
15.     if (_ulFlashAddr + _ulSize > CPU_FLASH_BASE_ADDR + CPU_FLASH_SIZE)
    6 Q7 G6 G/ _, L$ P
16.     {
    . A4 ^3 \5 U0 C  l# e; a8 _
17.         return 1;
    
18.     }
    
19. 
    8 l" v( D, ~- i2 p$ R) c& C0 ?
20.     /* 长度为0时不继续操作,否则起始地址为奇地址会出错 */
    # `9 q# G; c0 y2 q
21.     if (_ulSize == 0)
    8 A; W% g% S  o7 |
22.     {
    
23.         return 1;
    
24.     }
    
25. 
    7 [$ b) G' j3 J- F7 P
26.     for (i = 0; i < _ulSize; i++)
    
27.     {
    
28.         *_ucpDst++ = *(uint8_t *)_ulFlashAddr++;
    ' x  Q) s+ z8 {+ ~9 B2 E
29.     }
    
30. 
    
31.     return 0;
    3 W" D4 d/ z8 U: V
32. }
    3 t; S2 N6 p) |  d. k3 H! }

复制代码

71.2.4 告诉编译器使用的扇区（重要）
使用内部Flash模拟EEPROM切不可随意定义一个扇区使用。因为编译器并不知道用户使用了这个扇区，导致应用程序也会编程到此扇区里面，所以就需要告诉编译器。

告诉MDK的方法如下（0x0810 0000是H7的BANK2首地址）：

  `1 l6 D+ ^0 Q1 T8 M9 W

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

复制代码

告诉IAR的方法如下：

" j, C# E1 P; F: o- n4 r( L( e

1. #pragma location=0x08100000
   
2. const uint8_t para_flash_area[128*1024];
   

复制代码

这里有两点特别注意：

/ C3 B# a, @& U( ~4 N4 \  模拟EEPROM的扇区可以定义到从第2个扇区开始的任何扇区，但不可以定义到首扇区，因为这个扇区是默认的boot启动地址。
  如果应用程序不大的话，不推荐定义到末尾扇区，以MDK为例，定义到末尾扇区后，会导致整个Flash空间都被使用，从而让程序下载下载时间变长。
71.3 模拟EEPROM板级支持包（bsp_cpu_flash.c）
模拟EEPROM的驱动文件bsp_cpu_flash.c主要实现了如下几个API供用户调用：
4 L, N1 J) A, @- \" W1 y8 n
  bsp_GetSector
  bsp_ReadCpuFlash
  bsp_CmpCpuFlash
  bsp_EraseCpuFlash
  bsp_WriteCpuFlash
71.3.1 函数bsp_GetSector
0 \2 D5 ], ~: V函数原型：

, ?6 V. f0 \2 w  W. }  w

1. uint32_t bsp_GetSector(uint32_t Address)

复制代码

函数描述：
0 W. S! W" N8 n  o8 k# B
此函数主要用于获取给定地址所处的扇区。

函数参数：
* u* \9 R6 @: O  H, Q& w; P1 K
" I8 ~! y$ `2 s- C' d  第1个参数是用户给定的地址。
1 H2 e! u- t% F! `* w$ C; p, a; h3 h  返回值，范围FLASH_SECTOR_0到FLASH_SECTOR_7。
/ ]5 Z, a. O7 q" k71.3.2 函数bsp_ReadCpuFlash
3 C  o% [# s3 n% Z函数原型：

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

复制代码

函数描述：

此函数用于从内部Flash读取数据
. b: j9 ^8 y; ]$ j+ G! V
# B" T$ n, h4 S& y函数参数：

  第1个参数读取的起始地址。
  j& B* I+ i5 J5 P  第2个参数是读取数据的存储地址
4 U- g. \/ L0 M! B) \' w4 ?& Z$ T  第3个参数是读取数据的大小，单位字节。
  返回值，0表示成功，1表示失败。
! d! ]  U, M/ M8 w- v( Y5 g! w71.3.3 函数bsp_CmpCpuFlash
函数原型：

uint8_t bsp_CmpCpuFlash(uint32_t _ulFlashAddr, uint8_t *_ucpBuf, uint32_t _ulSize)

% z4 b  ?& c  j函数描述：
+ e6 d5 l+ K5 a) N, ?
要编程的数据是否在内部Flash已经存在。
! n5 ~5 e3 i2 V9 S3 j) U
函数参数：
. ^' n4 O2 S7 I% B7 b9 f
  第1个参数是内部Flash地址。
  R" V; Q; s0 D9 l" h! ]% J$ M/ m  第2个参数是缓冲区地址。
  第3个参数是数据大小，单位字节。
  返回值：
FLASH_IS_EQU               0   Flash内容和待写入的数据相等，不需要擦除和写操作。

FLASH_REQ_WRITE          1     Flash不需要擦除，直接写。

FLASH_REQ_ERASE          2     Flash需要先擦除,再写。
$ Z) @, X' |9 c% _
FLASH_PARAM_ERR         3     函数参数错误。
& N% l) `4 t4 {( E
$ m" e6 e" `* ^# f' b7 B8 u9 c71.3.4 函数bsp_EraseCpuFlash
函数原型：
; b, P% n$ W$ Q
' ~$ P/ u: x; S: Quint8_t bsp_EraseCpuFlash(uint32_t _ulFlashAddr)

函数描述：

% @9 E) M2 ~5 h' M- f此函数用于擦除一个扇区，大小128KB

函数参数：

  第1个参数要擦除的扇区地址，可以是此扇区范围内的任意值，一般填扇区首地址即可。
  返回值：
! R7 Q# T% ]0 x1 FHAL_OK        = 0x00
# A2 \# A) t; @2 `  w! ~
8 y% ^5 j& W& ?5 a! A, L2 S) B6 yHAL_ERROR    = 0x01

HAL_BUSY      = 0x02

& ?+ I8 }8 r1 v/ XHAL_TIMEOUT  = 0x03

6 h9 Q1 s! U2 |71.3.5 函数bsp_WriteCpuFlash
函数原型：

0 b) E* v; l, l0 Yuint8_t bsp_WriteCpuFlash(uint32_t _ulFlashAddr, uint8_t *_ucpSrc, uint32_t _ulSize)

4 c5 y0 |* p8 u  w2 v! _2 J函数描述：
. V2 ~: B5 K$ L" p
此函数用于编程数据到内部Flash。

$ c( D) ]! g2 H+ r$ A2 q函数参数：

+ e  G" C1 c% ?* G5 L" [5 S) J" m9 H  第1个参数是要编程的内部Flash地址。
  第2个参数是数据缓冲区地址。
  第3个参数是数据大小，单位字节。
& w6 l: t) f( S% |  返回值，0-成功，1-数据长度或地址溢出，2-写Flash出错(估计Flash寿命到)。
2 h9 g+ v3 t4 |+ Q' g- y* |# O) ]9 {注意事项：
' q3 Y. g4 F- F% c
  第1个参数必须32字节对齐，即要编程的Flash地址对32求余为0。
  第3个参数必须是32字节的整数倍，长度不是32字节整数倍时，此函数会将几个字节补0写入
71.4 模拟EEPROM驱动移植和使用
. h) m  Q# ?1 k$ L* E) o模拟EEPROM移植步骤如下：
& [( n9 K6 i; D: r+ A! k$ ~2 g9 g
8 ^! c2 f1 w/ M4 W  第1步：复制bsp_cpu_flash.c和bsp_cpu_flash.h到自己的工程目录，并添加到工程里面。
  第2步：Flash驱动文件主要用到HAL库的Flash驱动文件，简单省事些可以添加所有HAL库C源文件进来。
  第3步，应用方法看本章节配套例子即可。
6 W, r0 a% a4 t, x2 t71.5 实验例程设计框架
( x- n  W- A+ U! b4 u# ~通过程序设计框架，让大家先对配套例程有一个全面的认识，然后再理解细节，本次实验例程的设计框架如下：
  ?% s0 V7 H4 T& H6 e

* J! p+ s) C; e! ]2 A. s6 v
  第1阶段，上电启动阶段：

这部分在第14章进行了详细说明。
* o/ r1 Y2 S# g; T  第2阶段，进入main函数：
# ~$ E, }; P5 @5 W/ w/ v
  第1部分，硬件初始化，主要是MPU，Cache，HAL库，系统时钟，滴答定时器和LED。
: ?* _0 S2 N9 i% p  第2部分，应用程序设计部分，实现内部Flash模拟EEPROM。
7 W7 ]  T6 O/ N71.6 实验例程说明（MDK）
7 I5 e8 L  ^& `' N* R- @配套例子：
( ^9 i, _& F2 F* m# A0 ~
V7-049_内部Flash模拟EEPROM
+ x; u4 ^& K' R. k/ E
, \% i4 I6 e' X4 a5 b实验目的：
6 B$ n8 E4 h) {8 [  H$ v6 l
, @0 F6 @2 N6 T: _学习内部Flash模拟EEPROM。
( F4 ]" V  \/ c- G+ n5 E实验内容：
; R( l. \, U$ e) k$ Y9 t
使用内部Flash模拟EEPROM，务必告诉编译要使用的存储空间，防止这个空间存入了程序。
对于同一个地址空间，仅支持一次编程(不推荐二次编程，即使是将相应bit由数值1编程0)。
( h3 j# \* ]; t# m  E& H0 }6 J) @只能对已经擦除的空间做编程，擦除1个扇区是128KB。
H7的Flash编程时，务必保证要编程的地址是32字节对齐的，即此地址对32求余为0。
; C( Q* N: p1 f3 p& P. ]并且编程的数据必须32字节整数倍，函数bsp_WriteCpuFlash对字节数不够32字节整数倍的情况自动补0。

实验操作：

& s0 R3 f( g* d0 ^5 rK1键按下，将8bit，16bit和32bit数据写入到内部Flash。
K2键按下，将结构体数据写入到内部Flash。
3 l5 Q6 s5 b: Q! x上电后串口打印的信息：

波特率 115200，数据位 8，奇偶校验位无，停止位 1。

* e4 f$ i! r5 Y% W1 G

) d! G) M) J  j' N" e2 V9 t0 y
程序设计：

  系统栈大小分配：

  RAM空间用的DTCM：

* G4 A! H5 S1 J+ c3 a! {: l

2 f( ?2 X% ^; w! q  硬件外设初始化
$ w+ n# B! d4 P( M- Y" R9 ?) t5 _4 R, V
硬件外设的初始化是在 bsp.c 文件实现：
1 V' m6 u) t6 H

1. /*
   
2. *********************************************************************************************************
   
3. *    函 数 名: bsp_Init
   
4. *    功能说明: 初始化所有的硬件设备。该函数配置CPU寄存器和外设的寄存器并初始化一些全局变量。只需要调用一次
   
5. *    形    参：无
   / I/ S7 k  a( B5 }
6. *    返 回 值: 无
   
7. *********************************************************************************************************
   % w% @" J  ?1 M7 r
8. */
   
9. void bsp_Init(void)
   
10. {
    " J8 O  y1 ?( d: W4 l( `, {
11.     /* 配置MPU */
    
12.     MPU_Config();
    
13. 
    ) ?+ l  ?4 l- v! C$ S9 n
14.     /* 使能L1 Cache */
    
15.     CPU_CACHE_Enable();
    
16. 
    # i. _4 W0 h6 A" j
17.     /*
    3 P, u7 y4 `1 K3 v
18.        STM32H7xx HAL 库初始化，此时系统用的还是H7自带的64MHz，HSI时钟:
    ' @! x8 q0 H; }- B
19.        - 调用函数HAL_InitTick，初始化滴答时钟中断1ms。
    3 q: n1 W1 x7 d" `
20.        - 设置NVIV优先级分组为4。
    ( f. D. V  e* K
21.      */
    
22.     HAL_Init();
    2 o6 e" _) O* i1 v* j$ i
23. 
    * z8 b' {2 u: _' c
24.     /*
    : p8 R  |2 b0 n  |0 ?
25.        配置系统时钟到400MHz
    
26.        - 切换使用HSE。
    
27.        - 此函数会更新全局变量SystemCoreClock，并重新配置HAL_InitTick。
    0 C" {* I0 z3 l9 b9 ^1 \- U1 Y
28.     */
    
29.     SystemClock_Config();
    
30. 
    
31.     /*
    % `  Z; ]8 z$ P7 }) `9 D5 V
32.        Event Recorder：
    - ^. v8 q: a2 u: v$ e
33.        - 可用于代码执行时间测量，MDK5.25及其以上版本才支持，IAR不支持。
    / _! `- e1 _3 q  p
34.        - 默认不开启，如果要使能此选项，务必看V7开发板用户手册第xx章
    
35.     */   
    , x  H7 C. H2 f4 W. k- ~
36. #if Enable_EventRecorder == 1  
    1 T" ~0 P, [9 q+ d/ R: K
37.     /* 初始化EventRecorder并开启 */
    0 h; ]3 M) K( S, j  d9 b" H
38.     EventRecorderInitialize(EventRecordAll, 1U);
    
39.     EventRecorderStart();
    
40. #endif
    / `1 l. G# p* L
41. 
    2 v/ X7 p+ m" S$ c+ \, `. @
42. bsp_InitDWT();      /* 初始化DWT时钟周期计数器 */      
    $ [) c  H! t0 o' M
43.     bsp_InitKey();        /* 按键初始化，要放在滴答定时器之前，因为按钮检测是通过滴答定时器扫描 */
    
44.     bsp_InitTimer();      /* 初始化滴答定时器 */
    
45.     bsp_InitLPUart();    /* 初始化串口 */
    
46.     bsp_InitExtIO();    /* 初始化FMC总线74HC574扩展IO. 必须在 bsp_InitLed()前执行 */   
    ' c, m  L0 T' d1 @; b0 F
47.     bsp_InitLed();        /* 初始化LED */   
    & B5 t! ^  {8 {+ d& a$ A2 z
48.     bsp_InitExtSDRAM(); /* 初始化SDRAM */
    ) S) N; W# X& C2 W. l7 D
49. }
    ' s* F+ C! q* ~; }6 m# v* m7 n

复制代码

3 Z* z# L8 J/ Y) g" P2 h  MPU配置和Cache配置：
) Y* R3 J( D* |+ [) V0 g
9 O% R* `6 e! N4 g+ V" a: |数据Cache和指令Cache都开启。配置了AXI SRAM区（本例子未用到AXI SRAM）和FMC的扩展IO区。

1. /*
   
2. *********************************************************************************************************
   % @3 n+ U$ _4 e5 ^3 }
3. *    函 数 名: MPU_Config
   $ S5 Y+ V; `/ \' T
4. *    功能说明: 配置MPU
   # u; a1 L) U  \7 G- ]
5. *    形    参: 无
   
6. *    返 回 值: 无
   7 ]5 X* e; c9 z/ X
7. *********************************************************************************************************
   
8. */
   + K4 w! s! R7 Y$ ]
9. static void MPU_Config( void )
   
10. {
    
11.     MPU_Region_InitTypeDef MPU_InitStruct;
    
12. 
    / ], Y& N' u, T, `
13.     /* 禁止 MPU */
    % C0 W% U0 W! ?1 D; P6 C- N1 B
14.     HAL_MPU_Disable();
    
15. 
    1 {% g  w1 L0 B: z3 f' Y5 \
16.     /* 配置AXI SRAM的MPU属性为Write back, Read allocate，Write allocate */
    
17.     MPU_InitStruct.Enable           = MPU_REGION_ENABLE;
    - o7 N2 H/ F& p$ F/ Q# m# f' h
18.     MPU_InitStruct.BaseAddress      = 0x24000000;
    & D) Y+ x9 P" @) b! ~
19.     MPU_InitStruct.Size             = MPU_REGION_SIZE_512KB;
    , A8 V0 ?" F! S) E4 a8 x8 h' h
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;
    2 G" c* `0 u8 O5 b( T7 S. U
25.     MPU_InitStruct.TypeExtField     = MPU_TEX_LEVEL1;
    " d) s9 L/ g; M; L% C
26.     MPU_InitStruct.SubRegionDisable = 0x00;
    1 X' `3 P: ~, h. i; g, i8 P
27.     MPU_InitStruct.DisableExec      = MPU_INSTRUCTION_ACCESS_ENABLE;
    
28. 
    
29.     HAL_MPU_ConfigRegion(&MPU_InitStruct);
    5 b& H# H, I# y
30. 
    
31. 
    ; r% U* p9 _* y+ m0 V& w2 Y
32.     /* 配置FMC扩展IO的MPU属性为Device或者Strongly Ordered */
    
33.     MPU_InitStruct.Enable           = MPU_REGION_ENABLE;
    8 `( I$ H) V/ T# m
34.     MPU_InitStruct.BaseAddress      = 0x60000000;
    
35.     MPU_InitStruct.Size             = ARM_MPU_REGION_SIZE_64KB;   
    ) [5 N) {% _2 g* z" }
36.     MPU_InitStruct.AccessPermission = MPU_REGION_FULL_ACCESS;
    9 Y2 `0 [" h5 e
37.     MPU_InitStruct.IsBufferable     = MPU_ACCESS_BUFFERABLE;
    
38.     MPU_InitStruct.IsCacheable      = MPU_ACCESS_NOT_CACHEABLE;   
    
39.     MPU_InitStruct.IsShareable      = MPU_ACCESS_NOT_SHAREABLE;
    
40.     MPU_InitStruct.Number           = MPU_REGION_NUMBER1;
    
41.     MPU_InitStruct.TypeExtField     = MPU_TEX_LEVEL0;
    $ F2 K, q2 T9 Q# f' |& }0 k! Z. a
42.     MPU_InitStruct.SubRegionDisable = 0x00;
    , i& S: e# X' g1 L
43.     MPU_InitStruct.DisableExec      = MPU_INSTRUCTION_ACCESS_ENABLE;
    
44. 
    ' _5 i- [/ v" {$ ?/ T: Y* R
45.     HAL_MPU_ConfigRegion(&MPU_InitStruct);
    2 \- ^- e! ]! F- B4 o6 N) k2 p
46. 
    # x: R  j) Y& r: \
47.     /*使能 MPU */
    
48.     HAL_MPU_Enable(MPU_PRIVILEGED_DEFAULT);
    
49. }
    
50. 
    
51. /*
    3 b: N1 B6 u7 @1 h1 |- [2 Q3 l
52. *********************************************************************************************************
    
53. *    函 数 名: CPU_CACHE_Enable
    ( M3 }. o( L: }8 g: |
54. *    功能说明: 使能L1 Cache
    / F4 I1 ]; o' ?5 i$ I$ }1 f( R
55. *    形    参: 无
    
56. *    返 回 值: 无
    7 P+ ~9 s! h" \/ U
57. *********************************************************************************************************
    + p5 S5 S5 m7 I  v% w% u! k
58. */
    ; [; p& o: t* D
59. static void CPU_CACHE_Enable(void)
    
60. {
    
61.     /* 使能 I-Cache */
    
62.     SCB_EnableICache();
    
63. 
    
64.     /* 使能 D-Cache */
    / Q" a& s: S# D- l+ x7 j
65.     SCB_EnableDCache();
    ! O3 @5 D- b" @6 J6 {* ]+ ]2 s
66. }

复制代码

/ _+ y* H8 W/ T3 U( A1 p) [( z  每10ms调用一次蜂鸣器处理：
1 g7 h. W8 R* a0 x# W
蜂鸣器处理是在滴答定时器中断里面实现，每10ms执行一次检测。

1. /*
   9 Z. V* Q1 X. K9 l$ \
2. *********************************************************************************************************
   & G4 a, }8 Q. ?8 s$ e6 ?
3. *    函 数 名: bsp_RunPer10ms
   
4. *    功能说明: 该函数每隔10ms被Systick中断调用1次。详见 bsp_timer.c的定时中断服务程序。一些处理时间要求
   8 I& a4 M$ E% c. Y1 E5 a8 s4 ?, U
5. *              不严格的任务可以放在此函数。比如：按键扫描、蜂鸣器鸣叫控制等。
   
6. *    形    参: 无
     n1 a' D5 Y9 N! V! q% b  B1 F9 z3 j
7. *    返 回 值: 无
   
8. *********************************************************************************************************
   ' B" v, h: l* r* G. y- K- D
9. */
   
10. void bsp_RunPer10ms(void)
    + n5 E7 \/ H; ?6 O+ }  Q) ~$ v
11. {
    
12.     bsp_KeyScan10ms();
    ! w) w7 G8 ^! {2 G6 K
13. }
    

复制代码

# B+ `2 R$ k* d1 Q8 t! L: @
8 v9 y5 I; g" _# D% G6 T; _  主功能：
8 Y6 S( l" J, v4 g0 O" w/ G8 b
: |; O% u2 I+ H" _3 {主程序实现如下操作：
  r7 I$ E% H4 o5 d- D" }
  启动一个自动重装软件定时器，每100ms翻转一次LED2。
  K1键按下，将8bit，16bit和32bit数据写入到内部Flash。
  K2键按下，将结构体数据写入到内部Flash。
  e2 j$ S* J+ C

1. /*
   
2. *********************************************************************************************************
   ! h9 n! \6 G0 V6 ^; e% Z' U
3. *    函 数 名: main
   - o9 J, @; v8 b2 q9 I
4. *    功能说明: c程序入口
   3 G9 r$ I% W6 T9 [2 ]3 I
5. *    形    参: 无
   
6. *    返 回 值: 错误代码(无需处理)
   
7. *********************************************************************************************************
   2 H. Q( ?) T6 O$ ~
8. */
   
9. int main(void)
   " [0 S& I! r8 V- ^0 G
10. {
    
11.     uint8_t ucKeyCode;    /* 按键代码 */
    
12.     uint8_t  ucTest, *ptr8;
    7 t( L8 K0 t, g+ \3 W- v
13.     uint16_t uiTest, *ptr16;
    
14.     uint32_t ulTest, *ptr32;
    - F% Y1 I1 G( E/ i, r) _5 _
15.     PARAM_T tPara, *paraptr;
    % O) `; `2 {4 N5 w. ]" R- b: @0 Z( R
16. 
    7 ?! b$ i3 g! O% s
17. 
    8 C! X( r+ R1 P3 f5 E
18.     /* 初始化数据 */
    
19.     tPara.Baud485 = 0x5555AAAA;
    
20.     tPara.ParamVer = 0x99;
    : J8 h! ~9 Z3 v3 b2 h
21.     tPara.ucBackLight = 0x7788;
    
22.     tPara.ucRadioMode = 99.99f;
    
23. 
    
24. 
    
25.     bsp_Init();        /* 硬件初始化 */
    0 O' _9 R6 E" H- ^% V& z
26.     PrintfLogo();    /* 打印例程名称和版本等信息 */
    
27.     PrintfHelp();    /* 打印操作提示 */
    ) a9 G4 h! q2 N- G, ~6 W
28. 
    - q& T0 m5 q/ h# V: D
29.     bsp_StartAutoTimer(0, 100);    /* 启动1个100ms的自动重装的定时器 */
    $ n* B7 Y4 Y4 c# ~. M
30.     while (1)
    : p5 `0 M2 h( E, k, w6 h
31.     {
    " G( ~2 M% ^% f* E. z2 Z
32.         bsp_Idle();        /* 这个函数在bsp.c文件。用户可以修改这个函数实现CPU休眠和喂狗 */
    # \2 }1 @7 Y8 ~2 r+ H& J% c8 y
33. 
    + C3 {8 Z- {& g, H: u: [
34.         /* 判断定时器超时时间 */
    7 A  ], w) H9 V' v7 Z
35.         if (bsp_CheckTimer(0))   
    6 |" w3 Z  H) ?5 _1 W. ~" b
36.         {
    ! q( t1 l3 @1 k) k: D7 ?6 b% `
37.             /* 每隔100ms 进来一次 */  
      f$ C" ~- ?% R# K
38.             bsp_LedToggle(2);
    
39.         }
    4 {- b/ K# L' _: ^$ k& ~
40. 
    
41.         /* 按键滤波和检测由后台systick中断服务程序实现，我们只需要调用bsp_GetKey读取键值即可。 */
    2 Y% A8 N8 p7 G( x7 q7 g) p
42.         ucKeyCode = bsp_GetKey();    /* 读取键值, 无键按下时返回 KEY_NONE = 0 */
    1 i! e& I9 K. j
43.         if (ucKeyCode != KEY_NONE)
    8 b. H/ m( z. n4 F
44.         {
    6 J1 c0 N! T  [6 }7 Y/ y
45.             switch (ucKeyCode)
    
46.             {
    2 f/ ]. D  n( c& U
47.                 case KEY_DOWN_K1:            /* K1键按下，将8bit，16bit和32bit数据写入到内部Flash */
    
48. 
    8 w" F0 M7 I6 h0 T
49.                 /*
    
50.                  1、对于同一个地址空间，仅支持一次编程(不推荐二次编程，即使是将相应bit由数值1编程0)。
    
51.                  2、只能对已经擦除的空间做编程，擦除1个扇区是128KB。
    
52.                  3、H7的Flash编程时，务必保证要编程的地址是32字节对齐的，即此地址对32求余为0。并且编
    
53. 程的数据必须32字节整数倍。函数bsp_WriteCpuFlash对字节数不够32字节整数倍的情况自动补
    ) b" c1 s4 P# o" u+ p7 {& e
54. 0。
    8 V3 a; P$ o3 K/ B) p4 w; w4 }
55.                 */
    
56.                      /* 擦除扇区 */
    6 E3 E3 V6 m/ y, m9 v$ n$ ^, K
57.                     bsp_EraseCpuFlash((uint32_t)para_flash_area);
    
58. 
    
59.                     ucTest = 0xAA;
    5 Q1 A8 b& n% M. @
60.                     uiTest = 0x55AA;
    3 @& f1 Z2 C( t3 t9 v4 a
61.                     ulTest = 0x11223344;
    
62. 
    
63.                     /* 扇区写入数据 */
    
64.                     bsp_WriteCpuFlash((uint32_t)para_flash_area + 32*0,  (uint8_t *)&ucTest,
    9 v+ k0 k& O! U  }9 z- o9 G
65. sizeof(ucTest));
    
66.                     bsp_WriteCpuFlash((uint32_t)para_flash_area + 32*1,  (uint8_t *)&uiTest,
    
67. sizeof(uiTest));
    
68.                     bsp_WriteCpuFlash((uint32_t)para_flash_area + 32*2,  (uint8_t *)&ulTest,
    
69. sizeof(ulTest));               
    7 E5 Y+ C* _, i3 B' h, q
70. 
    
71.                     /* 读出数据并打印 */
    
72.                     ptr8  = (uint8_t  *)(para_flash_area + 32*0);
    
73.                     ptr16 = (uint16_t *)(para_flash_area + 32*1);
    : S% h9 }& v% d2 h
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);
    9 W- F8 e( M+ g
78. 
    5 v+ N0 ]) K7 G0 w5 [0 i  K3 x
79.                     break;
    , o. {, R2 ]; _* [; W! c
80. 
    
81.                 case KEY_DOWN_K2:            /* K2键按下， 将结构体数据写入到内部Flash */
    , l; x- j" _+ w5 |7 `
82.                     /* 擦除扇区 */
    
83.                     bsp_EraseCpuFlash((uint32_t)para_flash_area);
    & ]- P3 Z' R% T) h
84. 
    % d! B: Z& j0 ~' \/ L
85.                     /* 扇区写入数据 */
    2 r/ v* v* L; |8 f: d0 j
86.                     bsp_WriteCpuFlash((uint32_t)para_flash_area,  (uint8_t *)&tPara, sizeof(tPara));            
    8 v& D$ z7 K/ D& H% A
87. 
    
88.                     /* 读出数据并打印 */
    
89.                     paraptr  = (PARAM_T  *)((uint32_t)para_flash_area);
    
90. 
    & ~' y0 X7 g- d" q
91. 
    
92.                     printf("写入数据：Baud485=%x, ParamVer=%x, ucBackLight=%x, ucRadioMode=%f\r\n",
    
93.                                                                        tPara.Baud485,
    ; v" ^9 {, ?: l# U
94.                                                                         tPara.ParamVer,
    ! }3 E: u3 B* @3 Y" L' p7 ]5 Y
95.                                                                         tPara.ucBackLight,
    6 k% ?: `# s7 t3 C$ W7 P% U
96.                                                                    paraptr->ucRadioMode);
    
97. 
    0 _( ^: b# w2 K
98.                     printf("读取数据：Baud485=%x, ParamVer=%x, ucBackLight=%x, ucRadioMode=%f\r\n",
    
99.                                                                         paraptr->Baud485,
    
100.                                                                             paraptr->ParamVer,
     - i( i% k- P2 y5 j) i2 `- o& {
101.                                                                            paraptr->ucBackLight,
     ' D5 z1 {" h! t3 Z4 W4 }' O
102.                                                                           paraptr->ucRadioMode);
     - ^. a! ?* i3 Z+ m& L
103.                     break;               
     / L/ B7 A3 f% L. k7 t  ^
104.                 default:
     ' J& R4 Z8 A6 v- T
105.                     /* 其它的键值不处理 */
     
106.                     break;
     
107.             }
     
108.         }
     3 V2 m0 Y& j/ k/ U7 S: X
109.     }
     
110. }
     

复制代码

* @3 D4 }# a; p8 S71.7 实验例程说明（IAR）
配套例子：

" G8 H# G- ~. z) H/ E$ dV7-049_内部Flash模拟EEPROM
9 Z2 D9 S- p; n4 `4 H
实验目的：

1 @' t" c7 k8 \& J2 A7 \" Z学习内部Flash模拟EEPROM。
实验内容：

; X! c) |1 K( }0 ~# h* |; p使用内部Flash模拟EEPROM，务必告诉编译要使用的存储空间，防止这个空间存入了程序。
) H; p7 V! W9 L5 I. M1 t对于同一个地址空间，仅支持一次编程(不推荐二次编程，即使是将相应bit由数值1编程0)。
只能对已经擦除的空间做编程，擦除1个扇区是128KB。
# q4 G" R% ~: `/ p( E+ W# uH7的Flash编程时，务必保证要编程的地址是32字节对齐的，即此地址对32求余为0。
并且编程的数据必须32字节整数倍，函数bsp_WriteCpuFlash对字节数不够32字节整数倍的情况自动补0。

. D7 a  @8 T1 H: s4 I实验操作：

K1键按下，将8bit，16bit和32bit数据写入到内部Flash。
K2键按下，将结构体数据写入到内部Flash。
' P2 z" U- o0 R0 K" S上电后串口打印的信息：
4 ^) Y4 e% U% q3 i+ `2 R
波特率 115200，数据位 8，奇偶校验位无，停止位 1。

程序设计：
* c8 m* z# @! R% J6 C6 `6 D
% z& u; E- ~9 `3 b  系统栈大小分配：

/ H1 H" n+ d! h0 n2 A

) [# [- e7 x" E: [- j  RAM空间用的DTCM：

2 q( K* z- Z7 a# O* ~

& ^( U3 P- U9 z* O) i" {( X" ]
! ~! I& X# k0 X  硬件外设初始化

硬件外设的初始化是在 bsp.c 文件实现：

& W, q7 J' }& n. M' f; W; f7 Y

1. /*
   
2. *********************************************************************************************************
   ! v" O7 m+ H* a3 A) P- G" o6 P2 ]& U2 J
3. *    函 数 名: bsp_Init
   
4. *    功能说明: 初始化所有的硬件设备。该函数配置CPU寄存器和外设的寄存器并初始化一些全局变量。只需要调用一次
   
5. *    形    参：无
   
6. *    返 回 值: 无
   + U0 |4 j+ W. @( t: P' V: @) p
7. *********************************************************************************************************
   
8. */
   
9. void bsp_Init(void)
   
10. {
    
11.     /* 配置MPU */
    
12.     MPU_Config();
    
13. 
    
14.     /* 使能L1 Cache */
    * ?0 A  p- S7 l' K
15.     CPU_CACHE_Enable();
    
16. 
    
17.     /*
    / }$ V$ h) F  T6 S# i# C$ F1 @/ H1 X
18.        STM32H7xx HAL 库初始化，此时系统用的还是H7自带的64MHz，HSI时钟:
    
19.        - 调用函数HAL_InitTick，初始化滴答时钟中断1ms。
    
20.        - 设置NVIV优先级分组为4。
    
21.      */
    , m' t4 H" i, x8 X& |6 n& w
22.     HAL_Init();
    ( ?" x0 h0 C* X7 }
23. 
    
24.     /*
    
25.        配置系统时钟到400MHz
      `. G* i' [( [: t* r
26.        - 切换使用HSE。
    
27.        - 此函数会更新全局变量SystemCoreClock，并重新配置HAL_InitTick。
    
28.     */
    
29.     SystemClock_Config();
    
30. 
    5 K0 i& X5 G1 n) l* r* P
31.     /*
    3 `# o7 G8 N- d& M9 \1 i  t
32.        Event Recorder：
    , S, N7 R- t3 h7 V3 j
33.        - 可用于代码执行时间测量，MDK5.25及其以上版本才支持，IAR不支持。
    
34.        - 默认不开启，如果要使能此选项，务必看V7开发板用户手册第xx章
    * W) t0 Z( K4 _1 f1 i, f5 I
35.     */   
    % \. w( n! `- L0 G' y. ]; J
36. #if Enable_EventRecorder == 1  
    - H, |/ I/ {1 P1 [
37.     /* 初始化EventRecorder并开启 */
    # W1 K. x' H+ r
38.     EventRecorderInitialize(EventRecordAll, 1U);
    # X( q- e8 D$ R" S  \, T; U# G
39.     EventRecorderStart();
    
40. #endif
    
41. 
    
42. bsp_InitDWT();      /* 初始化DWT时钟周期计数器 */      
    ' Y3 {1 ]' c( b; y- g
43.     bsp_InitKey();        /* 按键初始化，要放在滴答定时器之前，因为按钮检测是通过滴答定时器扫描 */
    
44.     bsp_InitTimer();      /* 初始化滴答定时器 */
    
45.     bsp_InitLPUart();    /* 初始化串口 */
    # {# U3 Y& P! Z; P! w
46.     bsp_InitExtIO();    /* 初始化FMC总线74HC574扩展IO. 必须在 bsp_InitLed()前执行 */   
    
47.     bsp_InitLed();        /* 初始化LED */   
    $ j8 s6 T3 ?+ T8 f/ P
48.     bsp_InitExtSDRAM(); /* 初始化SDRAM */
    . v0 T) [" n' @! D( O% w6 Q
49. }
    

复制代码

- U* b/ D5 M% k: [; W- ?9 [
  MPU配置和Cache配置：
$ H( d9 w. V, x' D3 Y2 p
+ o8 H6 q9 }# `9 [! ~: |数据Cache和指令Cache都开启。配置了AXI SRAM区（本例子未用到AXI SRAM）和FMC的扩展IO区。

1. /*
   , G/ l9 f% b5 `# u# d5 P
2. *********************************************************************************************************
   
3. *    函 数 名: MPU_Config
   
4. *    功能说明: 配置MPU
   . _8 Q% M/ b* T  ~( R. i: W
5. *    形    参: 无
   
6. *    返 回 值: 无
   $ m' J- [4 |! ~- T% n* G& S6 h
7. *********************************************************************************************************
   . S: n/ o: u+ ^# [: T) T# L
8. */
   
9. static void MPU_Config( void )
   
10. {
    8 q) s+ G& H" a. j. u9 z
11.     MPU_Region_InitTypeDef MPU_InitStruct;
    
12. 
    6 V  c, o2 X1 ]; N) K. [& k; J
13.     /* 禁止 MPU */
    ' y6 M- K/ @- ^; ^$ ~# A3 H6 P
14.     HAL_MPU_Disable();
    
15. 
    
16.     /* 配置AXI SRAM的MPU属性为Write back, Read allocate，Write allocate */
    
17.     MPU_InitStruct.Enable           = MPU_REGION_ENABLE;
    
18.     MPU_InitStruct.BaseAddress      = 0x24000000;
    ( Y# i5 p$ Q$ {( G3 x* Z; ~
19.     MPU_InitStruct.Size             = MPU_REGION_SIZE_512KB;
    
20.     MPU_InitStruct.AccessPermission = MPU_REGION_FULL_ACCESS;
    1 {! s0 {" m3 |7 L2 m
21.     MPU_InitStruct.IsBufferable     = MPU_ACCESS_BUFFERABLE;
    
22.     MPU_InitStruct.IsCacheable      = MPU_ACCESS_CACHEABLE;
    5 C0 o% d4 q& g8 ?& t
23.     MPU_InitStruct.IsShareable      = MPU_ACCESS_NOT_SHAREABLE;
    + E, @8 A# H8 G6 S6 M
24.     MPU_InitStruct.Number           = MPU_REGION_NUMBER0;
    0 N; G% u! [) d; e- |) V' Y" D
25.     MPU_InitStruct.TypeExtField     = MPU_TEX_LEVEL1;
    0 u" H0 L2 L# F* E/ h7 U* F
26.     MPU_InitStruct.SubRegionDisable = 0x00;
    
27.     MPU_InitStruct.DisableExec      = MPU_INSTRUCTION_ACCESS_ENABLE;
    
28. 
    - {3 k0 b! U/ I- |$ U* Z8 S
29.     HAL_MPU_ConfigRegion(&MPU_InitStruct);
    
30. 
    
31. 
    
32.     /* 配置FMC扩展IO的MPU属性为Device或者Strongly Ordered */
    
33.     MPU_InitStruct.Enable           = MPU_REGION_ENABLE;
    ; t3 c" o2 }- e8 z( O, z5 h/ _$ |
34.     MPU_InitStruct.BaseAddress      = 0x60000000;
    9 T& U6 H) ^* m# t8 {5 U
35.     MPU_InitStruct.Size             = ARM_MPU_REGION_SIZE_64KB;   
    
36.     MPU_InitStruct.AccessPermission = MPU_REGION_FULL_ACCESS;
    ! c0 V4 m- d1 P( ~+ A2 i
37.     MPU_InitStruct.IsBufferable     = MPU_ACCESS_BUFFERABLE;
    % V4 A1 E$ H: @/ B( v6 c
38.     MPU_InitStruct.IsCacheable      = MPU_ACCESS_NOT_CACHEABLE;   
    
39.     MPU_InitStruct.IsShareable      = MPU_ACCESS_NOT_SHAREABLE;
    
40.     MPU_InitStruct.Number           = MPU_REGION_NUMBER1;
    6 b2 x& l5 V5 B
41.     MPU_InitStruct.TypeExtField     = MPU_TEX_LEVEL0;
    
42.     MPU_InitStruct.SubRegionDisable = 0x00;
    
43.     MPU_InitStruct.DisableExec      = MPU_INSTRUCTION_ACCESS_ENABLE;
    + G6 |/ G- O. z$ z  f; W
44. 
    ' S8 m' o2 g3 x: Q9 f
45.     HAL_MPU_ConfigRegion(&MPU_InitStruct);
    
46. 
    
47.     /*使能 MPU */
    - o  n5 P; G. T9 l
48.     HAL_MPU_Enable(MPU_PRIVILEGED_DEFAULT);
    : s9 q/ N# s1 H# o- J- K* c
49. }
    / E: x3 x7 J+ ^- |9 ~& M# p" O
50. 
    
51. /*
    . j/ l& K* I0 A' [; o) C  `; k
52. *********************************************************************************************************
    9 ]$ J4 X7 e4 K
53. *    函 数 名: CPU_CACHE_Enable
    * A8 s" z8 \7 d( J+ J1 v/ \
54. *    功能说明: 使能L1 Cache
    ' y9 \. z6 W, \) O$ w- S3 a1 T' a
55. *    形    参: 无
    ; r- K, X5 f- Q* S; z, W
56. *    返 回 值: 无
    5 S$ q; x* W0 x8 s% J4 X
57. *********************************************************************************************************
    / @$ S2 ?' a, X9 _1 G, B
58. */
    * n9 A2 ]" z! T9 ~
59. static void CPU_CACHE_Enable(void)
    1 n$ g, R* V* W1 n% S4 V
60. {
    . b1 w9 l! m: K+ Z$ l7 m
61.     /* 使能 I-Cache */
    
62.     SCB_EnableICache();
    
63. 
    
64.     /* 使能 D-Cache */
    
65.     SCB_EnableDCache();
    
66. }

复制代码

" D1 Y. `2 y& E  每10ms调用一次蜂鸣器处理：

蜂鸣器处理是在滴答定时器中断里面实现，每10ms执行一次检测。

# G1 U; P" O( R0 m+ p7 C

1. /*
   
2. *********************************************************************************************************
   
3. *    函 数 名: bsp_RunPer10ms
   
4. *    功能说明: 该函数每隔10ms被Systick中断调用1次。详见 bsp_timer.c的定时中断服务程序。一些处理时间要求
   
5. *              不严格的任务可以放在此函数。比如：按键扫描、蜂鸣器鸣叫控制等。
   8 c' @+ m! z; A. T2 Q6 t% I# e
6. *    形    参: 无
   
7. *    返 回 值: 无
   
8. *********************************************************************************************************
   
9. */
   
10. void bsp_RunPer10ms(void)
    0 H$ I' W% M, ^! l$ ^0 q3 h
11. {
    7 P* Z* z& A; [9 m, v7 r
12.     bsp_KeyScan10ms();
    ) @' J& _9 H2 E" C
13. }
    

复制代码

. {2 R) f2 a7 H# Q) Q) u% o  主功能：
6 r& B  L& p) ^. b6 a; k% v7 t; Q
. C' q! L' r: e* f1 E主程序实现如下操作：

启动一个自动重装软件定时器，每100ms翻转一次LED2。
4 Y2 _1 O5 F# o5 S/ g4 j" q' F& P K1键按下，将8bit，16bit和32bit数据写入到内部Flash。
* H7 }/ D. @# M K2键按下，将结构体数据写入到内部Flash。

1. /*
   
2. *********************************************************************************************************
   $ V5 s1 E2 A$ q" g9 n6 [
3. *    函 数 名: main
   
4. *    功能说明: c程序入口
   
5. *    形    参: 无
   & M# `7 j: q# U+ {- [
6. *    返 回 值: 错误代码(无需处理)
   
7. *********************************************************************************************************
   ! _' I: i4 |( R) |' B
8. */
   ( [; M4 N$ Y% i6 E" K) i
9. int main(void)
   ) I+ w% u& O# |9 d. w6 U
10. {
    
11.     uint8_t ucKeyCode;    /* 按键代码 */
    
12.     uint8_t  ucTest, *ptr8;
    
13.     uint16_t uiTest, *ptr16;
    9 J/ ~0 S! o9 E7 w/ H9 g: d
14.     uint32_t ulTest, *ptr32;
    
15.     PARAM_T tPara, *paraptr;
    
16. 
    / y! `5 d2 {/ x; H. }- K; o
17. 
    
18.     /* 初始化数据 */
    % N/ |6 _% z" W9 Y% V
19.     tPara.Baud485 = 0x5555AAAA;
    
20.     tPara.ParamVer = 0x99;
    
21.     tPara.ucBackLight = 0x7788;
    9 {' o& |4 H- B
22.     tPara.ucRadioMode = 99.99f;
    0 _. J- @/ R7 e( z+ n. k( h  ?% c
23. 
    
24. 
    & _2 k  ^  T) R5 s5 K2 h0 f
25.     bsp_Init();        /* 硬件初始化 */
    
26.     PrintfLogo();    /* 打印例程名称和版本等信息 */
    
27.     PrintfHelp();    /* 打印操作提示 */
    8 A) H& u) X- B9 T5 |/ e4 d& ^
28. 
    
29.     bsp_StartAutoTimer(0, 100);    /* 启动1个100ms的自动重装的定时器 */
    
30.     while (1)
    5 ^. N/ a6 B4 d# l8 e
31.     {
    
32.         bsp_Idle();        /* 这个函数在bsp.c文件。用户可以修改这个函数实现CPU休眠和喂狗 */
    * A7 t. L5 G- ^& k1 \: r- H, ~+ w
33. 
    / L* {4 W  P& m
34.         /* 判断定时器超时时间 */
    4 k8 U* N5 {8 ^" a3 g5 O# P
35.         if (bsp_CheckTimer(0))   
    
36.         {
    
37.             /* 每隔100ms 进来一次 */  
    2 d  o7 k# s1 ?' Y2 T' ^& Z
38.             bsp_LedToggle(2);
    
39.         }
    ; @) q1 ?7 E6 G6 Q2 F
40. 
    
41.         /* 按键滤波和检测由后台systick中断服务程序实现，我们只需要调用bsp_GetKey读取键值即可。 */
    ! K3 U/ N( x7 w7 y2 t# c& Q7 }
42.         ucKeyCode = bsp_GetKey();    /* 读取键值, 无键按下时返回 KEY_NONE = 0 */
    : E& |$ {6 ^* G& r( {# ?
43.         if (ucKeyCode != KEY_NONE)
    7 V- O, \! M% ]- r
44.         {
    8 h, r* \/ c/ [9 E
45.             switch (ucKeyCode)
    6 ~+ \- L! E. Y8 T
46.             {
    * w. C! Y) ^1 O1 c2 H7 E$ H4 r6 U
47.                 case KEY_DOWN_K1:            /* K1键按下，将8bit，16bit和32bit数据写入到内部Flash */
    
48. 
    
49.                 /*
    
50.                  1、对于同一个地址空间，仅支持一次编程(不推荐二次编程，即使是将相应bit由数值1编程0)。
    : q% c& ]# N% k3 Q$ l* K
51.                  2、只能对已经擦除的空间做编程，擦除1个扇区是128KB。
    - w0 w7 e7 v- Q+ V) H
52.                  3、H7的Flash编程时，务必保证要编程的地址是32字节对齐的，即此地址对32求余为0。并且编
    5 m% g3 P/ p0 }! D0 d8 H: [; [% ^
53. 程的数据必须32字节整数倍。函数bsp_WriteCpuFlash对字节数不够32字节整数倍的情况自动补
    / g1 X& C  y" c' H8 w; z
54. 0。
    / H8 a* C8 l7 m6 X
55.                 */
    - S0 J! e/ {9 X( u# Y
56.                      /* 擦除扇区 */
    
57.                     bsp_EraseCpuFlash((uint32_t)para_flash_area);
    0 ?, \0 {. O# M/ G
58. 
    
59.                     ucTest = 0xAA;
    
60.                     uiTest = 0x55AA;
    
61.                     ulTest = 0x11223344;
    7 c% H$ B( W" }. C5 p. o
62. 
    ) n9 Q: c7 R. m- y7 f. P) w' }: ^4 e4 ?
63.                     /* 扇区写入数据 */
    
64.                     bsp_WriteCpuFlash((uint32_t)para_flash_area + 32*0,  (uint8_t *)&ucTest,
    
65. sizeof(ucTest));
    3 m( T7 V, b& B" t* X6 D% U
66.                     bsp_WriteCpuFlash((uint32_t)para_flash_area + 32*1,  (uint8_t *)&uiTest,
    & J$ u8 m; x+ _! `
67. sizeof(uiTest));
    
68.                     bsp_WriteCpuFlash((uint32_t)para_flash_area + 32*2,  (uint8_t *)&ulTest,
    
69. sizeof(ulTest));               
    
70. 
    
71.                     /* 读出数据并打印 */
    
72.                     ptr8  = (uint8_t  *)(para_flash_area + 32*0);
    ) s& D- D- p( M/ `
73.                     ptr16 = (uint16_t *)(para_flash_area + 32*1);
    7 D5 H; S/ w- n: _
74.                     ptr32 = (uint32_t *)(para_flash_area + 32*2);
    
75. 
    
76.                     printf("写入数据：ucTest = %x, uiTest = %x, ulTest = %x\r\n", ucTest, uiTest, ulTest);
    8 z9 ?  P( X3 A: ]9 `
77.                     printf("读取数据：ptr8 = %x, ptr16 = %x, ptr32 = %x\r\n", *ptr8, *ptr16, *ptr32);
    / _& N$ c  I! m( a: b  N3 I, k
78. 
    
79.                     break;
    ) K$ I8 D) k$ _& H$ t
80. 
    ! p: p4 ?8 t! U; |5 Y' X
81.                 case KEY_DOWN_K2:            /* K2键按下， 将结构体数据写入到内部Flash */
    
82.                     /* 擦除扇区 */
    9 [# S4 O! e( M9 E3 q
83.                     bsp_EraseCpuFlash((uint32_t)para_flash_area);
    
84. 
    3 q8 N9 [% Q) {) ~% d4 ~( n& O5 D
85.                     /* 扇区写入数据 */
    
86.                     bsp_WriteCpuFlash((uint32_t)para_flash_area,  (uint8_t *)&tPara, sizeof(tPara));            
    
87. 
    
88.                     /* 读出数据并打印 */
    / _, H6 S; W, X: o0 z5 H
89.                     paraptr  = (PARAM_T  *)((uint32_t)para_flash_area);
    
90. 
    ( G9 e  a; u7 h' F' T. Q' B
91. 
    + f6 j6 o2 O9 x
92.                     printf("写入数据：Baud485=%x, ParamVer=%x, ucBackLight=%x, ucRadioMode=%f\r\n",
    
93.                                                                        tPara.Baud485,
    
94.                                                                         tPara.ParamVer,
    " X( g5 V1 }, p  V  a% I+ F4 \
95.                                                                         tPara.ucBackLight,
    
96.                                                                    paraptr->ucRadioMode);
    8 ^! O% f+ Q* u& B4 p! o
97. 
    4 Y9 i* d3 b2 K+ Z% g
98.                     printf("读取数据：Baud485=%x, ParamVer=%x, ucBackLight=%x, ucRadioMode=%f\r\n",
    
99.                                                                         paraptr->Baud485,
    
100.                                                                             paraptr->ParamVer,
     
101.                                                                            paraptr->ucBackLight,
     ) w. j. X7 t1 h
102.                                                                           paraptr->ucRadioMode);
     2 t  Y- l8 P( g3 t
103.                     break;               
     
104.                 default:
     
105.                     /* 其它的键值不处理 */
     
106.                     break;
     
107.             }
     + u+ ^+ N4 L- L; w. T' o
108.         }
     
109.     }
     7 }% z6 Y0 O, [% }8 W4 m. D4 y
110. }

复制代码

0 m6 U2 J/ R% @0 R3 I

71.8 总结
- g7 Q0 O, S" D* N* b9 G本章节就为大家讲解这么多， 实际应用中的注意事项比较多，应用到项目之前务必实际测试熟悉下。