71.1 初学者重要提示
9 f4 r# s+ p- \0 N8 [+ D  学习本章节前，务必优先学习第70章。
4 ^( r. m* _8 W+ K  使用内部Flash模拟EEPROM，务必告诉编译要使用的存储空间，防止这个空间存入了程序。
  STM32H7的Flash编程时，务必保证要编程的地址是32字节对齐的，即此地址对32求余为0。并且编程的数据必须32字节整数倍。
  STM32H743XI有两个独立的BANK，一个BANK的编程和擦除操作对另一个BANK没有任何影响。但是用户应用程序和要擦写的Flash扇区在同一个BANK，在执行擦写操作时，应用应用程序将停止运行，包括中断服务程序。
7 a4 O8 w; G2 {% n! V  使用内部Flash模拟EEPROM要做到先擦除后使用。
2 G+ i/ y8 ^9 b* d3 n4 D71.2 模拟EEPROM驱动设计
$ K% X1 ?9 j* l( z! C这里重点把内部Flash的读取，编程和擦除做个说明。

71.2.1 内部Flash擦除的实现
内部Flash的擦除思路如下：
5 E  v1 x$ `; y0 R7 @; P8 ^+ |
  第1步，获取擦除地址所处的扇区。
  第2步，调用函数HAL_FLASH_Unlock解锁。
  第3步，调用函数HAL_FLASHEx_Erase擦除一个扇区。
3 @9 t3 O3 n. b! e% g0 j& \* |  第4步，调用函数HAL_FLASH_Lock上锁。
按照这个思路，程序实现如下：
6 j( x" C1 I" l+ M7 R* J0 H

1. 1.    /*
   
2. 2.    ******************************************************************************************************
   & u1 c4 n. M" M% M  D% v6 n
3. 3.    *    函 数 名: bsp_EraseCpuFlash
   - D; B' l1 F3 S% `6 w
4. 4.    *    功能说明: 擦除CPU FLASH一个扇区 （128KB)
   
5. 5.    *    形    参: _ulFlashAddr : Flash地址
   
6. 6.    *    返 回 值: 0 成功， 1 失败
   + R* H5 V! W7 v2 T
7. 7.    *              HAL_OK       = 0x00,
   
8. 8.    *              HAL_ERROR    = 0x01,
   1 k, Z  G' p6 Y, H% n/ h
9. 9.    *              HAL_BUSY     = 0x02,
   
10. 10.    *              HAL_TIMEOUT  = 0x03
    
11. 11.    *
    
12. 12.    ******************************************************************************************************
    % B& N1 g$ f1 o% ~
13. 13.    */
    , W4 |: c: [# H5 s6 E
14. 14.    uint8_t bsp_EraseCpuFlash(uint32_t _ulFlashAddr)
    # \7 p8 `$ c, g$ C
15. 15.    {
    . C( p$ a; G4 f* z
16. 16.        uint32_t FirstSector = 0, NbOfSectors = 0;
    
17. 17.        FLASH_EraseInitTypeDef EraseInitStruct;
    
18. 18.        uint32_t SECTORError = 0;
    3 B3 U' z1 y5 n
19. 19.        uint8_t re;
    - @: Z8 y( n) ^' Q8 r
20. 20.   
    , ~" ~. V# k. r3 v$ n" b# G* X; N
21. 21.        /* 解锁 */
    
22. 22.        HAL_FLASH_Unlock();
    
23. 23.        
    
24. 24.        /* 获取此地址所在的扇区 */
    
25. 25.        FirstSector = bsp_GetSector(_ulFlashAddr);
    
26. 26.        
    
27. 27.        /* 固定1个扇区 */
    
28. 28.        NbOfSectors = 1;   
    5 Y4 X2 G7 F# t7 s7 ~' w- t) c
29. 29.   
    
30. 30.        /* 擦除扇区配置 */
    # f' d: Q3 ]& j: E
31. 31.        EraseInitStruct.TypeErase     = FLASH_TYPEERASE_SECTORS;
    
32. 32.        EraseInitStruct.VoltageRange  = FLASH_VOLTAGE_RANGE_3;
    
33. 33.        
    ' A8 s" X4 Q. \7 R, ]2 z
34. 34.        if (_ulFlashAddr >= ADDR_FLASH_SECTOR_0_BANK2)
    & S/ i' {; ]6 |' X4 B& E, L; Z
35. 35.        {
    " w2 I1 j" Z) d0 r
36. 36.            EraseInitStruct.Banks         = FLASH_BANK_2;
    
37. 37.        }
    : l# S0 I, B& p; E- I. s
38. 38.        else
    " w) F+ e! A% z$ k# v. g
39. 39.        {
    + J" M4 _% I3 S  q; J4 j
40. 40.            EraseInitStruct.Banks         = FLASH_BANK_1;
    6 t- i8 T, {/ T4 j
41. 41.        }
    
42. 42.        
    
43. 43.        EraseInitStruct.Sector        = FirstSector;
    . D( E" I* Y$ `8 }7 G
44. 44.        EraseInitStruct.NbSectors     = NbOfSectors;
    
45. 45.        
    ! d4 V. L, z) u& R9 H
46. 46.        /* 扇区擦除 */   
    
47. 47.        re = HAL_FLASHEx_Erase(&EraseInitStruct, &SECTORError);
    - c1 Q; E  ~4 ~
48. 48.        
    
49. 49.        /* 擦除完毕后，上锁 */
    
50. 50.        HAL_FLASH_Lock();   
    5 W4 G) {4 O" k' |
51. 51.        
    
52. 52.        return re;
    
53. 53.    }

复制代码

$ e- F3 |; t0 W  V* @& V7 v这里将此程序设计的关键点为大家做个说明：

  第25行函数是通过函数bsp_GetSector获取要擦除地址所处的扇区。这个函数的实现比较简单，代码如下：

1. /*
   / J& Y6 w+ |1 M/ ^' v+ }8 ]& b
2. *********************************************************************************************************
   
3. *    函 数 名: bsp_GetSector
   3 E: @* U' G* a6 X' C$ \
4. *    功能说明: 根据地址计算扇区首地址
   
5. *    形    参: 无
   
6. *    返 回 值: 扇区号（0-7)
   
7. *********************************************************************************************************
   
8. */
   
9. uint32_t bsp_GetSector(uint32_t Address)
   7 R) I( A) R' j- w" b: c3 `  N+ e
10. {
    
11.     uint32_t sector = 0;
    
12. 
    
13.     if (((Address < ADDR_FLASH_SECTOR_1_BANK1) && (Address >= ADDR_FLASH_SECTOR_0_BANK1)) || \
    
14.         ((Address < ADDR_FLASH_SECTOR_1_BANK2) && (Address >= ADDR_FLASH_SECTOR_0_BANK2)))   
    
15.     {
    
16.         sector = FLASH_SECTOR_0;  
    
17.     }
    + R8 o3 g: }7 e) `
18.     else if (((Address < ADDR_FLASH_SECTOR_2_BANK1) && (Address >= ADDR_FLASH_SECTOR_1_BANK1)) || \
    
19.       ((Address < ADDR_FLASH_SECTOR_2_BANK2) && (Address >= ADDR_FLASH_SECTOR_1_BANK2)))   
    . E4 `# S" A9 k% H+ _2 W
20.     {
    
21.         sector = FLASH_SECTOR_1;  
    ; X' u3 g( \; }3 \+ O7 _
22.     }
    
23.     else if (((Address < ADDR_FLASH_SECTOR_3_BANK1) && (Address >= ADDR_FLASH_SECTOR_2_BANK1)) || \
    . P2 q0 o- u2 \& M2 I
24.       ((Address < ADDR_FLASH_SECTOR_3_BANK2) && (Address >= ADDR_FLASH_SECTOR_2_BANK2)))   
    * C( l9 i+ y+ J% ~
25.     {
      U3 V; {) e0 Z+ K5 W, }: T" ?
26.         sector = FLASH_SECTOR_2;  
    8 B  q1 z5 ~& h9 j
27.     }
    5 w  z2 Y2 P. l, Y8 Q% Q9 G
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)))   
    ( `. m& i/ o* F. a1 T- Z
30.     {
    
31.         sector = FLASH_SECTOR_3;  
    * N# L' f2 ?' o
32.     }
    
33.     else if (((Address < ADDR_FLASH_SECTOR_5_BANK1) && (Address >= ADDR_FLASH_SECTOR_4_BANK1)) || \
    2 E5 n3 g4 |/ L% l) g
34.       ((Address < ADDR_FLASH_SECTOR_5_BANK2) && (Address >= ADDR_FLASH_SECTOR_4_BANK2)))   
    + L' L+ e' S& r/ P& Q' M
35.     {
    + D+ ?" ?8 _- W% J! d. t
36.         sector = FLASH_SECTOR_4;  
    ! X( }7 I# _- w( Y( K! s
37.     }
    
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)))   
      ~& {+ f" ]- }; c/ k( p: [
40.     {
    ; h- l) M- F& D4 W
41.         sector = FLASH_SECTOR_5;  
    
42.     }
    
43.     else if (((Address < ADDR_FLASH_SECTOR_7_BANK1) && (Address >= ADDR_FLASH_SECTOR_6_BANK1)) || \
      C( v9 W2 k) Z
44.       ((Address < ADDR_FLASH_SECTOR_7_BANK2) && (Address >= ADDR_FLASH_SECTOR_6_BANK2)))   
    5 T0 O6 S8 Y' E! C
45.     {
    
46.         sector = FLASH_SECTOR_6;  
    
47.     }
    
48.     else if (((Address < ADDR_FLASH_SECTOR_0_BANK2) && (Address >= ADDR_FLASH_SECTOR_7_BANK1)) || \
    
49.       ((Address < CPU_FLASH_END_ADDR) && (Address >= ADDR_FLASH_SECTOR_7_BANK2)))
    - \1 w7 |- y+ u' x9 p
50.     {
    
51.         sector = FLASH_SECTOR_7;  
    ' J+ B5 o. d1 x5 d6 z; u8 G6 U
52.     }
    
53.     else
    
54.     {
    3 K) j. e& _7 C! ?6 I
55.         sector = FLASH_SECTOR_7;
    
56.     }
    4 m4 ]: L! Y) T# i: q( r
57. 
    
58.     return sector;
    8 H1 ?& J7 Z; D
59. }
    

复制代码

# D% ]( l/ y2 S1 T& W1 _) M# k
2 W* W) X/ s$ M4 e$ a# F由于STM32H7的BANK1和BANK2是独立的，都有8个扇区，所以程序里面只需返回要擦除地址所处的扇区号即可。

* p* m  n* n  W8 E  第47行的擦除函数HAL_FLASHEx_Erase在第70章的4.4小节有说明。
71.2.2 内部Flash编程的实现
9 K/ \% S  b9 S内部Flash的编程思路如下：

  第1步，判断是否要编写数据进去，如果数据已经在内部Flash里面。
+ B1 ^3 ]& i# s) v$ a6 p6 }  第2步，调用函数HAL_FLASH_Unlock解锁。
5 N0 i- I3 n  w: K& h+ x  第3步，调用函数HAL_FLASH_Program对内部Flash编程数据。
$ I; S$ f9 K0 \9 f1 p8 ~  第4步，调用函数HAL_FLASH_Lock上锁。
按照这个思路，程序实现如下：

8 }& Q- ?) z" V, i7 P, I

1. 1.    /*
   
2. 2.    ******************************************************************************************************
   
3. 3.    *    函 数 名: bsp_WriteCpuFlash
   
4. 4.    *    功能说明: 写数据到CPU 内部Flash。 必须按32字节整数倍写。不支持跨扇区。扇区大小128KB. \
   
5. 5.    *              写之前需要擦除扇区. 长度不是32字节整数倍时，最后几个字节末尾补0写入.
   : O/ z1 Z1 `, m0 L, q- t, P
6. 6.    *    形    参: _ulFlashAddr : Flash地址
   - m% z2 H- ]7 X
7. 7.    *             _ucpSrc : 数据缓冲区
   
8. 8.    *             _ulSize : 数据大小（单位是字节, 必须是32字节整数倍）
   4 |; k0 r3 J/ L
9. 9.    *    返 回 值: 0-成功，1-数据长度或地址溢出，2-写Flash出错(估计Flash寿命到)
   9 s  M% k3 P4 m' G3 x: q
10. 10.    ******************************************************************************************************
    ( l! q, u* Y' {8 |! o# G) |, ]1 E
11. 11.    */
    
12. 12.    uint8_t bsp_WriteCpuFlash(uint32_t _ulFlashAddr, uint8_t *_ucpSrc, uint32_t _ulSize)
    
13. 13.    {
    
14. 14.        uint32_t i;
    
15. 15.        uint8_t ucRet;
    
16. 16.   
    
17. 17.        /* 如果偏移地址超过芯片容量，则不改写输出缓冲区 */
    - |4 i0 S& p- V$ U1 w8 _
18. 18.        if (_ulFlashAddr + _ulSize > CPU_FLASH_BASE_ADDR + CPU_FLASH_SIZE)
    
19. 19.        {
    
20. 20.            return 1;
    . Y* G6 {1 A/ R. U9 }
21. 21.        }
    
22. 22.   
    . R! l- c( \" H: O/ ?: a% y
23. 23.        /* 长度为0时不继续操作  */
    
24. 24.        if (_ulSize == 0)
    * c2 B: f$ B. b6 p( `) B
25. 25.        {
    
26. 26.            return 0;
    
27. 27.        }
    5 w3 m* O9 h! B% o" m
28. 28.   
    
29. 29.        ucRet = bsp_CmpCpuFlash(_ulFlashAddr, _ucpSrc, _ulSize);
    1 _' p* d/ w. D3 s- G
30. 30.   
    
31. 31.        if (ucRet == FLASH_IS_EQU)
    ! ?( J0 D  j- C! e& i5 B) d
32. 32.        {
    
33. 33.            return 0;
    
34. 34.        }
    
35. 35.   
    " I" V, `8 G& E: F7 ^* b% y0 |
36. 36.        __set_PRIMASK(1);          /* 关中断 */
    
37. 37.   
    
38. 38.        /* FLASH 解锁 */
    ' Q% z0 X8 ^0 L7 h
39. 39.        HAL_FLASH_Unlock();
    
40. 40.   
    3 K: O3 P3 h' f
41. 41.        for (i = 0; i < _ulSize / 32; i++)   
    . {9 }8 g8 Z9 l/ Z9 i% R
42. 42.        {
    
43. 43.            uint64_t FlashWord[4];
    
44. 44.            
    
45. 45.            memcpy((char *)FlashWord, _ucpSrc, 32);
      O  {9 g& T# ?5 s8 S; b
46. 46.            _ucpSrc += 32;
    
47. 47.            
    
48. 48.            if (HAL_FLASH_Program(FLASH_TYPEPROGRAM_FLASHWORD, _ulFlashAddr,
    $ G4 }  j3 h, N2 h8 i
49. 49.                                      (uint64_t)((uint32_t)FlashWord)) == HAL_OK)
    
50. 50.            {
    $ w; U8 K1 L6 f
51. 51.                _ulFlashAddr = _ulFlashAddr + 32; /* 递增，操作下一个256bit */               
    % s5 _% O4 T2 L
52. 52.            }        
    
53. 53.            else
    3 @9 f) d. \- ]% k7 X0 H" }  y
54. 54.            {
    
55. 55.                goto err;
    
56. 56.            }
    ) `, w0 Y* U1 X" j3 ]) `
57. 57.        }
    6 _; `0 b* E; g& y+ f
58. 58.        
    
59. 59.        /* 长度不是32字节整数倍 */
    
60. 60.        if (_ulSize % 32)
    + c( a0 s5 v  T" |9 q, V0 ^& D$ m
61. 61.        {
    
62. 62.            uint64_t FlashWord[4];
    
63. 63.            
    % C9 D4 W1 h# Q
64. 64.            FlashWord[0] = 0;
    ( s5 c$ {2 X' R
65. 65.            FlashWord[1] = 0;
    
66. 66.            FlashWord[2] = 0;
    , `: G3 {$ F- F
67. 67.            FlashWord[3] = 0;
    : g% ]6 i1 g) z' `# o: G6 k: b
68. 68.            memcpy((char *)FlashWord, _ucpSrc, _ulSize % 32);
    
69. 69.            if (HAL_FLASH_Program(FLASH_TYPEPROGRAM_FLASHWORD, _ulFlashAddr,
    
70. 70.                                               (uint64_t)((uint32_t)FlashWord)) == HAL_OK)
    
71. 71.            {
    " y3 Z. T1 |  p& }8 B* Y+ y
72. 72.                ; // _ulFlashAddr = _ulFlashAddr + 32;
    7 E: a, U, D2 u: {( i4 M" d3 [: x
73. 73.               
    ) d' {1 Z/ v) I0 R" t  z5 @
74. 74.            }        
    9 ]5 E# z5 Z5 i: [3 r# @
75. 75.            else
    8 t9 c, h& Y& l
76. 76.            {
    ; o1 Q% w) C& x( m* x
77. 77.                goto err;
    ! G# l4 @  x; b
78. 78.            }
    & K+ W. f! L# ]4 w' e
79. 79.        }
    
80. 80.        
    $ A+ g6 t2 X- M7 h6 G- z6 T* t
81. 81.          /* Flash 加锁，禁止写Flash控制寄存器 */
    8 s4 S# g3 d: x( w6 M+ @
82. 82.          HAL_FLASH_Lock();
    
83. 83.   
    0 u( A  @3 A* K  f, s3 H7 n2 }
84. 84.          __set_PRIMASK(0);          /* 开中断 */
    " L8 q6 i2 Y# |
85. 85.   
    - F( X' X3 B. i
86. 86.        return 0;
    
87. 87.        
    
88. 88.    err:
    
89. 89.          /* Flash 加锁，禁止写Flash控制寄存器 */
    
90. 90.          HAL_FLASH_Lock();
    ) a9 j, N. w" X! q* t4 ]5 s
91. 91.   
    - B$ \5 [$ X1 F0 ]! J4 x
92. 92.          __set_PRIMASK(0);          /* 开中断 */
    
93. 93.   
    3 s  C: z" H3 {5 G4 @1 ?9 {3 J
94. 94.        return 1;
    
95. 95.    }
    & Z/ b# M; \5 I

复制代码

关于此函数有几个要点：

  第1个参数必须32字节对齐，即要编程的Flash地址对32求余为0。
  第3个参数必须是32字节的整数倍，长度不是32字节整数倍时，最后几个字节补0写入。
" h. {& w9 |2 V& `  第29行，函数bsp_CmpCpuFlash放在这里只有一个作用，判断将要写入的数据是否已经在内部Flash存在，如果已经存在，无需重复写入，直接返回。
) {) ^8 i$ ]1 t3 R/ `; l  第36行，做了一个关中断操作，这里有个知识点要给大家普及下，由于H7的BANK1和BANK2是独立的，当前正在擦除的扇区所处的BANK会停止所有在此BANK执行的程序，包含中断也会停止执行。比如当前的应用程序都在BANK1，如果要擦除或者编程BANK2，是不会不影响BANK1里面执行的程序。这里安全起见加上了开关中断。
  第41到57行，先将32字节整数倍的数据通过函数HAL_FLASH_Program编程，此函数每次可以固定编程32字节数据。
  第60到79行，将剩余不足32字节的数据补0，凑齐32字节编程。
71.2.3 内部Flash读取的实现
& }  V) |% t* D内部Flash数据读取比较简单，采用总线方式读取，跟访问内部RAM是一样的。比如要读取地址
+ b9 A2 l$ }' w7 {
* @3 u$ }5 N( q# F( z0x08100000里面的一个32bit变量，我们就可以：

! F# N: s8 w( a9 c变量 = *(uint32_t *)(0x08100000)

为了方便起见，也专门准备了一个函数：

1. /*
   
2. *********************************************************************************************************
   ) K- D/ {  k, O% }
3. *    函 数 名: bsp_ReadCpuFlash
   * m& i8 N+ R% Z
4. *    功能说明: 读取CPU Flash的内容
   8 M( J3 I! M% @9 B% P4 ]' }2 x
5. *    形    参:  _ucpDst : 目标缓冲区
   
6. *             _ulFlashAddr : 起始地址
   
7. *             _ulSize : 数据大小（单位是字节）
   
8. *    返 回 值: 0=成功，1=失败
   * d2 _% e- ~  P: _  q; Q
9. *********************************************************************************************************
   1 V3 z+ Z; X7 P3 f1 c+ m$ Q
10. */
    
11. uint8_t bsp_ReadCpuFlash(uint32_t _ulFlashAddr, uint8_t *_ucpDst, uint32_t _ulSize)
    7 [6 D5 A: O: v; E% x
12. {
    * d6 p' b4 H" @) r7 z' L
13.     uint32_t i;
    5 R' L0 c4 T% K3 ?
14. 
    
15.     if (_ulFlashAddr + _ulSize > CPU_FLASH_BASE_ADDR + CPU_FLASH_SIZE)
    
16.     {
    
17.         return 1;
    
18.     }
    
19. 
    ; B; \1 U' B( q5 P5 J  {
20.     /* 长度为0时不继续操作,否则起始地址为奇地址会出错 */
    / R$ G. V; _' Z/ B. V
21.     if (_ulSize == 0)
    7 X- `* k0 v% \& n; L- q$ G4 C
22.     {
    ( a1 ?6 H% _3 _4 @9 J8 Y6 r
23.         return 1;
    
24.     }
    
25. 
    
26.     for (i = 0; i < _ulSize; i++)
    
27.     {
    9 f8 c2 m7 F9 B6 \2 j
28.         *_ucpDst++ = *(uint8_t *)_ulFlashAddr++;
    $ j7 |$ E8 N& {
29.     }
    
30. 
    ( J! l8 a) x9 c" v1 n
31.     return 0;
    
32. }
    # D, w. N3 j2 x( r. b% z5 f

复制代码

  U) L# l$ ?" e
71.2.4 告诉编译器使用的扇区（重要）
1 b: ~$ D1 z4 a0 }使用内部Flash模拟EEPROM切不可随意定义一个扇区使用。因为编译器并不知道用户使用了这个扇区，导致应用程序也会编程到此扇区里面，所以就需要告诉编译器。
5 n* O$ e& [1 Z3 p
3 o! T* t! H- B& j; @) \2 ]# r告诉MDK的方法如下（0x0810 0000是H7的BANK2首地址）：

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

复制代码

; `7 u- @( B6 ~0 ]告诉IAR的方法如下：

& c$ }4 Z) v8 t7 T

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

复制代码

. v" T8 l! H3 z. O6 \这里有两点特别注意：
) T' e- i" C4 [/ v7 q, c0 |% `
  模拟EEPROM的扇区可以定义到从第2个扇区开始的任何扇区，但不可以定义到首扇区，因为这个扇区是默认的boot启动地址。
  如果应用程序不大的话，不推荐定义到末尾扇区，以MDK为例，定义到末尾扇区后，会导致整个Flash空间都被使用，从而让程序下载下载时间变长。
71.3 模拟EEPROM板级支持包（bsp_cpu_flash.c）
模拟EEPROM的驱动文件bsp_cpu_flash.c主要实现了如下几个API供用户调用：

2 ^' R) A7 W/ Z/ J  \  bsp_GetSector
  bsp_ReadCpuFlash
  bsp_CmpCpuFlash
3 Z% @8 S+ K# r6 r5 Z  bsp_EraseCpuFlash
  bsp_WriteCpuFlash
% m" U6 ^- ]  k9 M& W2 y. P71.3.1 函数bsp_GetSector
% a! O2 S1 n; j* V函数原型：

1 |8 J, y% L0 P1 u

1. uint32_t bsp_GetSector(uint32_t Address)

复制代码

( ^6 N- T1 v( d% \0 w* R) e# d3 L函数描述：
7 }3 V7 y) n& P$ j$ w  \1 J
此函数主要用于获取给定地址所处的扇区。
/ m! y! X& e+ E. t
函数参数：

( N1 F1 X/ C$ J3 h, U  第1个参数是用户给定的地址。
  返回值，范围FLASH_SECTOR_0到FLASH_SECTOR_7。
71.3.2 函数bsp_ReadCpuFlash
函数原型：

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

复制代码

7 F  j' I$ v4 A5 [函数描述：
7 @- m1 [$ J+ W  C/ W
此函数用于从内部Flash读取数据

4 R0 R  Y9 T; L函数参数：

  第1个参数读取的起始地址。
  第2个参数是读取数据的存储地址
  第3个参数是读取数据的大小，单位字节。
  返回值，0表示成功，1表示失败。
. r4 {' Y  |: I- A: D71.3.3 函数bsp_CmpCpuFlash
$ h' B3 S7 t5 W函数原型：

: T$ j3 q  U* fuint8_t bsp_CmpCpuFlash(uint32_t _ulFlashAddr, uint8_t *_ucpBuf, uint32_t _ulSize)
! v+ q1 q( J% Y7 j. e6 C" E+ H: @
函数描述：
& f. ~* I8 \* b! K
, P; j8 ^* h6 X3 Y! N要编程的数据是否在内部Flash已经存在。

4 i; f8 r- m4 O8 m0 w函数参数：
8 V/ @6 A4 ]9 J" t, E
  第1个参数是内部Flash地址。
$ c) E* F# v+ B- ]1 J9 @8 y5 v  第2个参数是缓冲区地址。
  第3个参数是数据大小，单位字节。
  返回值：
% {7 s7 @1 r. I5 B/ V) ?FLASH_IS_EQU               0   Flash内容和待写入的数据相等，不需要擦除和写操作。

# M2 J: j2 B( {* T+ H/ W" HFLASH_REQ_WRITE          1     Flash不需要擦除，直接写。

FLASH_REQ_ERASE          2     Flash需要先擦除,再写。
; R+ M2 b4 m+ y
% g( `) T2 B9 u: I: M6 SFLASH_PARAM_ERR         3     函数参数错误。

71.3.4 函数bsp_EraseCpuFlash
函数原型：
, r: \( `* t. F+ [6 H! Z* k
5 {+ Y5 G5 l, n3 q- }+ h5 puint8_t bsp_EraseCpuFlash(uint32_t _ulFlashAddr)
; u, m8 Q' u2 q; ]8 D5 s$ z
函数描述：
# |8 G) J3 W7 V* c4 x) ]6 M* b% \
7 O- C- {9 K+ q/ P9 v此函数用于擦除一个扇区，大小128KB
8 [+ K  y: i' k
, ~' |9 g% h. Y, L函数参数：

  第1个参数要擦除的扇区地址，可以是此扇区范围内的任意值，一般填扇区首地址即可。
  返回值：
7 ]8 @& g( P/ ^. LHAL_OK        = 0x00
& Y; Y5 S' P5 |1 @0 T2 Y6 c2 ^
# [% x" }- v# p7 E. n7 a0 T2 kHAL_ERROR    = 0x01

% z7 }% \4 q( }' B. `HAL_BUSY      = 0x02
4 J' Y# S) }% T5 F: l5 U  V5 ^
HAL_TIMEOUT  = 0x03

0 V/ H; y  c$ M* Z" x71.3.5 函数bsp_WriteCpuFlash
函数原型：

uint8_t bsp_WriteCpuFlash(uint32_t _ulFlashAddr, uint8_t *_ucpSrc, uint32_t _ulSize)
7 e' Y; d5 y# a% h' L: [/ P% q
函数描述：

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

2 s9 n2 Q) ?% N9 p+ ]1 H' m函数参数：

  第1个参数是要编程的内部Flash地址。
  第2个参数是数据缓冲区地址。
( L6 G2 U4 Q0 J+ s8 T/ f. O. p( ]  第3个参数是数据大小，单位字节。
- r( c2 R' K9 @3 q2 f* V  返回值，0-成功，1-数据长度或地址溢出，2-写Flash出错(估计Flash寿命到)。
2 y- |: t+ f6 f5 ?: J- u* T( [- |注意事项：

  第1个参数必须32字节对齐，即要编程的Flash地址对32求余为0。
( d# |  r. n9 n0 G  第3个参数必须是32字节的整数倍，长度不是32字节整数倍时，此函数会将几个字节补0写入
71.4 模拟EEPROM驱动移植和使用
模拟EEPROM移植步骤如下：

  第1步：复制bsp_cpu_flash.c和bsp_cpu_flash.h到自己的工程目录，并添加到工程里面。
9 @/ k& I9 O7 k, n  第2步：Flash驱动文件主要用到HAL库的Flash驱动文件，简单省事些可以添加所有HAL库C源文件进来。
( M/ C# X" A7 H. R; |% w  第3步，应用方法看本章节配套例子即可。
71.5 实验例程设计框架
通过程序设计框架，让大家先对配套例程有一个全面的认识，然后再理解细节，本次实验例程的设计框架如下：

( ~! g6 H" |1 d

* ?! y7 U2 K( O% i) @
. k  ]8 r& Z2 F$ w! ^4 t9 X2 Z  第1阶段，上电启动阶段：

( P) i. Z; E  s3 f这部分在第14章进行了详细说明。
  第2阶段，进入main函数：
: @& k) Q* J1 e6 t+ f7 |) H
  第1部分，硬件初始化，主要是MPU，Cache，HAL库，系统时钟，滴答定时器和LED。
) ^5 W, p( a1 z: J( u  第2部分，应用程序设计部分，实现内部Flash模拟EEPROM。
5 W# _, F, D, [& W" V. T1 X  t# ^71.6 实验例程说明（MDK）
配套例子：
; r; r# p- f$ K7 Z
V7-049_内部Flash模拟EEPROM

6 ~; l; ]% W4 u# w% _" o6 R* a& x实验目的：

5 d( J2 U$ ~6 ?# e学习内部Flash模拟EEPROM。
实验内容：

0 E3 b6 c2 N5 d1 I% r; o使用内部Flash模拟EEPROM，务必告诉编译要使用的存储空间，防止这个空间存入了程序。
对于同一个地址空间，仅支持一次编程(不推荐二次编程，即使是将相应bit由数值1编程0)。
只能对已经擦除的空间做编程，擦除1个扇区是128KB。
H7的Flash编程时，务必保证要编程的地址是32字节对齐的，即此地址对32求余为0。
9 ]6 s7 |% S* B/ q1 `: g' e5 {$ x并且编程的数据必须32字节整数倍，函数bsp_WriteCpuFlash对字节数不够32字节整数倍的情况自动补0。
( `3 T# P. W$ U+ N
! H, A) Y# E% B实验操作：

K1键按下，将8bit，16bit和32bit数据写入到内部Flash。
6 K" j) l2 A" [- j- V, p- H/ `K2键按下，将结构体数据写入到内部Flash。
上电后串口打印的信息：
: P0 b5 k. K8 r' _1 A
波特率 115200，数据位 8，奇偶校验位无，停止位 1。

# d3 e. `! k5 l) Q9 W- }+ ]2 _7 z4 q# ~

) P  r# ~/ E0 v- B0 D5 L% M) ?( P
  h( G1 V) {7 L3 ^程序设计：

# n3 ^- V, N1 S' h8 ]* n  系统栈大小分配：

! M/ Q" T+ x. {) d0 F# [
  RAM空间用的DTCM：
! I# w. A8 [. U

  硬件外设初始化

. N, u% U, `# f硬件外设的初始化是在 bsp.c 文件实现：

1. /*
   " W! {7 u' v  l5 r5 R. _
2. *********************************************************************************************************
   ' |  ^" u6 S) `  }
3. *    函 数 名: bsp_Init
   
4. *    功能说明: 初始化所有的硬件设备。该函数配置CPU寄存器和外设的寄存器并初始化一些全局变量。只需要调用一次
   3 |3 q9 O4 C/ F+ E& R9 X
5. *    形    参：无
   
6. *    返 回 值: 无
   
7. *********************************************************************************************************
   
8. */
   0 Q/ V8 W3 u+ I  w
9. void bsp_Init(void)
   
10. {
    
11.     /* 配置MPU */
    
12.     MPU_Config();
    / c* J! m7 d3 j+ T
13. 
    
14.     /* 使能L1 Cache */
    7 _5 n* c5 _- ?$ \# ~& ?6 e; |3 M
15.     CPU_CACHE_Enable();
    $ O5 G7 y. \! ]$ ?! F% A/ @3 J5 w
16. 
    , ~) W) u4 k' n% L8 `# P% i
17.     /*
    ! j2 i8 |4 e0 b% v) s) O
18.        STM32H7xx HAL 库初始化，此时系统用的还是H7自带的64MHz，HSI时钟:
    
19.        - 调用函数HAL_InitTick，初始化滴答时钟中断1ms。
    
20.        - 设置NVIV优先级分组为4。
    
21.      */
    ; h; \: b0 E) s) Z. I
22.     HAL_Init();
    5 W8 a2 k; b1 j! a
23. 
    
24.     /*
    8 Q# y' N! Z% i, [: x/ d
25.        配置系统时钟到400MHz
    * [0 s9 E+ Q2 B' K! _
26.        - 切换使用HSE。
    7 Q4 u4 x6 G% X) k" @
27.        - 此函数会更新全局变量SystemCoreClock，并重新配置HAL_InitTick。
    . J# `( }) m! X! [+ p7 d
28.     */
    
29.     SystemClock_Config();
    9 Z1 R: ?8 V( h2 }: u3 _0 K3 G& u( t; k% J
30. 
    . k" _1 P) b- Z4 N
31.     /*
    : t1 _* Y) i# E, S; X( ]$ t
32.        Event Recorder：
    & [! s( R' `; \$ T1 V3 o, o
33.        - 可用于代码执行时间测量，MDK5.25及其以上版本才支持，IAR不支持。
    
34.        - 默认不开启，如果要使能此选项，务必看V7开发板用户手册第xx章
    $ t9 p1 o) f& Y4 a
35.     */   
    $ B/ Y6 b8 P! V# |
36. #if Enable_EventRecorder == 1  
    $ k/ b  v8 d* @- E
37.     /* 初始化EventRecorder并开启 */
    0 }5 d8 I, a% {9 V/ s, ^% i1 q
38.     EventRecorderInitialize(EventRecordAll, 1U);
    ( T$ R6 c! {6 m+ w& r5 Y- }. H! W
39.     EventRecorderStart();
    
40. #endif
    0 |# W4 U1 C8 R  i. q
41. 
    
42. bsp_InitDWT();      /* 初始化DWT时钟周期计数器 */      
    
43.     bsp_InitKey();        /* 按键初始化，要放在滴答定时器之前，因为按钮检测是通过滴答定时器扫描 */
    . d$ v& _( s! b: A  @- V: o8 Q
44.     bsp_InitTimer();      /* 初始化滴答定时器 */
    
45.     bsp_InitLPUart();    /* 初始化串口 */
    
46.     bsp_InitExtIO();    /* 初始化FMC总线74HC574扩展IO. 必须在 bsp_InitLed()前执行 */   
    
47.     bsp_InitLed();        /* 初始化LED */   
    / A0 z- |" x$ ^/ s+ q) T$ d5 i
48.     bsp_InitExtSDRAM(); /* 初始化SDRAM */
    
49. }
    9 A0 @4 e+ e, {! H9 H) {5 r$ K2 A  }

复制代码

  MPU配置和Cache配置：

数据Cache和指令Cache都开启。配置了AXI SRAM区（本例子未用到AXI SRAM）和FMC的扩展IO区。
& N/ w) Z! ?$ F: m
* h8 P- Y. J' u

1. /*
   ; c% A% R# O+ ?8 c5 B
2. *********************************************************************************************************
   
3. *    函 数 名: MPU_Config
   
4. *    功能说明: 配置MPU
   : t9 `0 E5 V- A; U, h* r& z
5. *    形    参: 无
   
6. *    返 回 值: 无
   
7. *********************************************************************************************************
   ! U, h% c* b3 f3 \3 U, R
8. */
   - J6 G4 C5 q5 b7 k
9. static void MPU_Config( void )
   
10. {
    
11.     MPU_Region_InitTypeDef MPU_InitStruct;
      V5 F; ^0 A2 ^% Q$ ?
12. 
    
13.     /* 禁止 MPU */
    ! ?4 G- [8 M7 s0 a  z- z
14.     HAL_MPU_Disable();
    
15. 
    
16.     /* 配置AXI SRAM的MPU属性为Write back, Read allocate，Write allocate */
    ' K# k* [, Z( M
17.     MPU_InitStruct.Enable           = MPU_REGION_ENABLE;
    
18.     MPU_InitStruct.BaseAddress      = 0x24000000;
    
19.     MPU_InitStruct.Size             = MPU_REGION_SIZE_512KB;
    
20.     MPU_InitStruct.AccessPermission = MPU_REGION_FULL_ACCESS;
    $ V+ y9 g) t( c$ ^
21.     MPU_InitStruct.IsBufferable     = MPU_ACCESS_BUFFERABLE;
    ) a* d7 k5 p0 C9 w! u. Q8 Y% o
22.     MPU_InitStruct.IsCacheable      = MPU_ACCESS_CACHEABLE;
    / p+ G3 D/ R2 y7 j( W3 v* o9 u
23.     MPU_InitStruct.IsShareable      = MPU_ACCESS_NOT_SHAREABLE;
    
24.     MPU_InitStruct.Number           = MPU_REGION_NUMBER0;
    . q' Z2 \& G& M3 M$ a1 n
25.     MPU_InitStruct.TypeExtField     = MPU_TEX_LEVEL1;
    - M0 |: X- t% |; j0 i; x
26.     MPU_InitStruct.SubRegionDisable = 0x00;
    ' k0 x8 g7 }/ k8 B* G) K& h
27.     MPU_InitStruct.DisableExec      = MPU_INSTRUCTION_ACCESS_ENABLE;
    
28. 
    
29.     HAL_MPU_ConfigRegion(&MPU_InitStruct);
    
30. 
    
31. 
    + {5 Y: i# [; k) V4 j% R7 ^
32.     /* 配置FMC扩展IO的MPU属性为Device或者Strongly Ordered */
    . [" J3 Y* u/ ^8 d7 \/ k7 O" d
33.     MPU_InitStruct.Enable           = MPU_REGION_ENABLE;
    ' O6 Q+ }9 I# g2 p- O
34.     MPU_InitStruct.BaseAddress      = 0x60000000;
    + C/ _+ I+ }, x! {* ?
35.     MPU_InitStruct.Size             = ARM_MPU_REGION_SIZE_64KB;   
    ) y/ h' P3 d5 _6 X! z  S- ~5 {
36.     MPU_InitStruct.AccessPermission = MPU_REGION_FULL_ACCESS;
    
37.     MPU_InitStruct.IsBufferable     = MPU_ACCESS_BUFFERABLE;
    9 b6 ~$ ~2 A4 w, K5 z0 ?9 I6 A7 Y
38.     MPU_InitStruct.IsCacheable      = MPU_ACCESS_NOT_CACHEABLE;   
    
39.     MPU_InitStruct.IsShareable      = MPU_ACCESS_NOT_SHAREABLE;
    6 \5 g* _7 i+ _0 o& U$ s
40.     MPU_InitStruct.Number           = MPU_REGION_NUMBER1;
    $ t& w( Q! W: i
41.     MPU_InitStruct.TypeExtField     = MPU_TEX_LEVEL0;
    $ v4 ]! }* p, P+ i
42.     MPU_InitStruct.SubRegionDisable = 0x00;
    
43.     MPU_InitStruct.DisableExec      = MPU_INSTRUCTION_ACCESS_ENABLE;
    ' P3 T& e& K# a; z
44. 
    $ Q) s, x. k& s4 j; u% Z9 M
45.     HAL_MPU_ConfigRegion(&MPU_InitStruct);
    
46. 
    ' W% A; q. }* l1 D0 r' w
47.     /*使能 MPU */
    
48.     HAL_MPU_Enable(MPU_PRIVILEGED_DEFAULT);
    
49. }
    & T% ]2 G! q, Y* X
50. 
    
51. /*
    
52. *********************************************************************************************************
    * [% |! O- g( W/ l5 f
53. *    函 数 名: CPU_CACHE_Enable
    
54. *    功能说明: 使能L1 Cache
    
55. *    形    参: 无
    
56. *    返 回 值: 无
    
57. *********************************************************************************************************
    
58. */
    
59. static void CPU_CACHE_Enable(void)
    
60. {
    
61.     /* 使能 I-Cache */
    8 w% ^9 {+ \# G& _
62.     SCB_EnableICache();
    ' T0 K7 _' ]3 [
63. 
    * p! p- t1 v5 `; k! U
64.     /* 使能 D-Cache */
    $ x4 K2 B2 [  s  M1 t
65.     SCB_EnableDCache();
    
66. }

复制代码

, ?+ F. G/ Q, U8 _" y% B! E8 d; P

: Q4 M% }6 w: P! j' X$ _  每10ms调用一次蜂鸣器处理：
/ p% O/ a5 H7 y
蜂鸣器处理是在滴答定时器中断里面实现，每10ms执行一次检测。

  X( \# T' A# |! `3 l! R

1. /*
   
2. *********************************************************************************************************
   
3. *    函 数 名: bsp_RunPer10ms
   
4. *    功能说明: 该函数每隔10ms被Systick中断调用1次。详见 bsp_timer.c的定时中断服务程序。一些处理时间要求
   9 }' a+ k) D4 {/ Q
5. *              不严格的任务可以放在此函数。比如：按键扫描、蜂鸣器鸣叫控制等。
   5 r) n& r  ~2 |) b6 Y
6. *    形    参: 无
   3 ^5 N( o8 V/ T$ W
7. *    返 回 值: 无
   # w) d/ W" h% I% K
8. *********************************************************************************************************
   
9. */
   
10. void bsp_RunPer10ms(void)
    
11. {
    + z' `/ t# q% \0 \% X- N# l! D
12.     bsp_KeyScan10ms();
    
13. }
    

复制代码

( f4 Z7 D9 q8 ^0 u6 ]
  主功能：

& x% p1 {# ?9 A$ F; Z$ v" K' w/ n主程序实现如下操作：

  启动一个自动重装软件定时器，每100ms翻转一次LED2。
& x1 C: [9 b% t9 D  K1键按下，将8bit，16bit和32bit数据写入到内部Flash。
  K2键按下，将结构体数据写入到内部Flash。
8 a% P2 Y/ s5 E8 J5 c

1. /*
   
2. *********************************************************************************************************
   
3. *    函 数 名: main
   
4. *    功能说明: c程序入口
   
5. *    形    参: 无
   
6. *    返 回 值: 错误代码(无需处理)
   
7. *********************************************************************************************************
   ' _6 r4 _3 l2 A+ {( G* [
8. */
   
9. int main(void)
   2 t# [& G& c* c6 E1 c  g9 F
10. {
    ; M+ [% o( {4 k: \2 }; Z
11.     uint8_t ucKeyCode;    /* 按键代码 */
    
12.     uint8_t  ucTest, *ptr8;
    
13.     uint16_t uiTest, *ptr16;
    1 ^2 u7 z! ?& h
14.     uint32_t ulTest, *ptr32;
    
15.     PARAM_T tPara, *paraptr;
    
16. 
    
17. 
    
18.     /* 初始化数据 */
    / p. m, _% S& i; M+ B7 m: |
19.     tPara.Baud485 = 0x5555AAAA;
    
20.     tPara.ParamVer = 0x99;
    - o) R, i6 q2 I( h* ~# f+ I3 Y
21.     tPara.ucBackLight = 0x7788;
    
22.     tPara.ucRadioMode = 99.99f;
    
23. 
    ( c% n# ]# @8 {5 @
24. 
    
25.     bsp_Init();        /* 硬件初始化 */
    
26.     PrintfLogo();    /* 打印例程名称和版本等信息 */
    
27.     PrintfHelp();    /* 打印操作提示 */
    
28. 
    
29.     bsp_StartAutoTimer(0, 100);    /* 启动1个100ms的自动重装的定时器 */
    , C9 Q3 I: D; H: I2 ^, J
30.     while (1)
    - w  k2 \6 J& J! f$ E2 t6 s
31.     {
    
32.         bsp_Idle();        /* 这个函数在bsp.c文件。用户可以修改这个函数实现CPU休眠和喂狗 */
    
33. 
    ; Y& A1 f7 z- X5 e
34.         /* 判断定时器超时时间 */
    ) `4 p( h$ ^/ U- v- X! U0 j1 @: H
35.         if (bsp_CheckTimer(0))   
    
36.         {
    
37.             /* 每隔100ms 进来一次 */  
    
38.             bsp_LedToggle(2);
    
39.         }
    
40. 
    
41.         /* 按键滤波和检测由后台systick中断服务程序实现，我们只需要调用bsp_GetKey读取键值即可。 */
    
42.         ucKeyCode = bsp_GetKey();    /* 读取键值, 无键按下时返回 KEY_NONE = 0 */
    
43.         if (ucKeyCode != KEY_NONE)
    ; }( N. Z! K  W4 G% i% ?0 t
44.         {
    ' D5 R' _$ q$ v6 u2 b2 |2 y
45.             switch (ucKeyCode)
    
46.             {
    
47.                 case KEY_DOWN_K1:            /* K1键按下，将8bit，16bit和32bit数据写入到内部Flash */
    : @1 A7 p! p" s# W
48. 
    4 F. x5 d9 s' \
49.                 /*
    
50.                  1、对于同一个地址空间，仅支持一次编程(不推荐二次编程，即使是将相应bit由数值1编程0)。
    
51.                  2、只能对已经擦除的空间做编程，擦除1个扇区是128KB。
    ! b, x. \8 F6 e# }  M
52.                  3、H7的Flash编程时，务必保证要编程的地址是32字节对齐的，即此地址对32求余为0。并且编
    
53. 程的数据必须32字节整数倍。函数bsp_WriteCpuFlash对字节数不够32字节整数倍的情况自动补
    
54. 0。
    $ @: z9 }* }7 \. w9 l
55.                 */
    
56.                      /* 擦除扇区 */
    
57.                     bsp_EraseCpuFlash((uint32_t)para_flash_area);
    
58. 
    
59.                     ucTest = 0xAA;
    
60.                     uiTest = 0x55AA;
    
61.                     ulTest = 0x11223344;
    ! H5 {" w+ ]! N* i+ f! b0 w( F
62. 
    
63.                     /* 扇区写入数据 */
    
64.                     bsp_WriteCpuFlash((uint32_t)para_flash_area + 32*0,  (uint8_t *)&ucTest,
    6 m6 y' G/ ~7 s. g* A+ P
65. sizeof(ucTest));
    : t( U* d$ [) u2 {. d3 h
66.                     bsp_WriteCpuFlash((uint32_t)para_flash_area + 32*1,  (uint8_t *)&uiTest,
    
67. sizeof(uiTest));
    + }: U$ W" I' ^7 D0 h
68.                     bsp_WriteCpuFlash((uint32_t)para_flash_area + 32*2,  (uint8_t *)&ulTest,
    ' d& `. k5 P  L4 t  Y+ R2 X+ k% G
69. sizeof(ulTest));               
    
70. 
    & Z  E1 p! d0 K- a7 Z7 B  D5 ~
71.                     /* 读出数据并打印 */
    0 i) Q  S% k8 n
72.                     ptr8  = (uint8_t  *)(para_flash_area + 32*0);
    6 g# c# j+ a3 J) C. T3 U% `
73.                     ptr16 = (uint16_t *)(para_flash_area + 32*1);
    9 i! ]& y7 ]2 g) D' _9 T
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);
    + P8 y$ x& @/ V$ W
78. 
    
79.                     break;
    
80. 
    % s" @/ d5 g: c$ w, q
81.                 case KEY_DOWN_K2:            /* K2键按下， 将结构体数据写入到内部Flash */
    - V& A' A- w/ A# j4 x4 R6 w6 S
82.                     /* 擦除扇区 */
    % }0 D' c6 t4 s# }' \1 L
83.                     bsp_EraseCpuFlash((uint32_t)para_flash_area);
    $ g7 Q+ F: z0 v
84. 
    ) C& E  |! S- ?& c+ I4 m3 [+ ^
85.                     /* 扇区写入数据 */
    
86.                     bsp_WriteCpuFlash((uint32_t)para_flash_area,  (uint8_t *)&tPara, sizeof(tPara));            
    6 c+ a# N3 i  Q3 d8 t
87. 
    5 W% M1 E( e, v2 E( C1 D# z
88.                     /* 读出数据并打印 */
    
89.                     paraptr  = (PARAM_T  *)((uint32_t)para_flash_area);
    0 ?# N# j4 z2 Q$ }0 M3 q
90. 
    0 h0 h& w; O( t' T/ N; U0 Y
91. 
    
92.                     printf("写入数据：Baud485=%x, ParamVer=%x, ucBackLight=%x, ucRadioMode=%f\r\n",
    
93.                                                                        tPara.Baud485,
    
94.                                                                         tPara.ParamVer,
    ) t" H* e+ U9 x5 Y& g9 f" B8 e
95.                                                                         tPara.ucBackLight,
    
96.                                                                    paraptr->ucRadioMode);
    ' V# i! k6 @4 G. p: R
97. 
    1 J3 x* O+ T; `4 }- P- N2 F
98.                     printf("读取数据：Baud485=%x, ParamVer=%x, ucBackLight=%x, ucRadioMode=%f\r\n",
    
99.                                                                         paraptr->Baud485,
    
100.                                                                             paraptr->ParamVer,
     9 C) H. I. p: N
101.                                                                            paraptr->ucBackLight,
     , q' l, Z, G: c
102.                                                                           paraptr->ucRadioMode);
     1 R! O, n5 ]$ z, l! w
103.                     break;               
     7 h: v2 G. g: ?" C8 s7 j' F) h+ v
104.                 default:
     
105.                     /* 其它的键值不处理 */
     ' {# K% X- t# p. m% d( c4 E
106.                     break;
     8 Y% l8 ]" D. r# E$ P
107.             }
     
108.         }
     
109.     }
     : W8 y$ u2 K& W  p' z# W2 |
110. }
     + N  g6 ], E) x

复制代码

8 u& j; b+ ]& F
71.7 实验例程说明（IAR）
! ?4 F  t5 V$ A2 K& z配套例子：
. f9 p' s. s: n5 R3 e
V7-049_内部Flash模拟EEPROM

; N. w, o2 y" q4 M1 t) ]! B5 {! S实验目的：

学习内部Flash模拟EEPROM。
实验内容：

使用内部Flash模拟EEPROM，务必告诉编译要使用的存储空间，防止这个空间存入了程序。
对于同一个地址空间，仅支持一次编程(不推荐二次编程，即使是将相应bit由数值1编程0)。
只能对已经擦除的空间做编程，擦除1个扇区是128KB。
5 a' z; b9 a% S. u7 j! ^H7的Flash编程时，务必保证要编程的地址是32字节对齐的，即此地址对32求余为0。
' p8 Z: V/ J; h, C' h' F1 ?: n9 g( g并且编程的数据必须32字节整数倍，函数bsp_WriteCpuFlash对字节数不够32字节整数倍的情况自动补0。
+ Y4 r4 I. P, q9 X( H
! {9 \+ b% F5 n- R实验操作：

K1键按下，将8bit，16bit和32bit数据写入到内部Flash。
K2键按下，将结构体数据写入到内部Flash。
上电后串口打印的信息：
9 X' _" \+ T, z
4 Y/ O7 p: m. H; \波特率 115200，数据位 8，奇偶校验位无，停止位 1。
. H# B! F" A5 P& G

程序设计：

/ j# J$ j! j+ e2 g& k2 R  a6 Y  系统栈大小分配：
( w( O, ]  f2 n
6 ^+ @: S8 L  k/ i( R! T

% t5 N/ ^5 z8 J3 b7 u; ]) c
* H# x5 e/ g0 B  ~6 j4 M) `  RAM空间用的DTCM：
1 u5 J3 f. _/ [, p) }. H8 D  D3 b
9 N- ]# R3 k; R+ o1 v: k- W

  硬件外设初始化

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

1. /*
   
2. *********************************************************************************************************
   + b7 z) A% w% N3 D! O( w' T
3. *    函 数 名: bsp_Init
   
4. *    功能说明: 初始化所有的硬件设备。该函数配置CPU寄存器和外设的寄存器并初始化一些全局变量。只需要调用一次
   
5. *    形    参：无
   , M  c; T8 F! p0 w6 i
6. *    返 回 值: 无
   / o1 X- i* W' B' w$ b
7. *********************************************************************************************************
   $ W  Y$ i! o; }+ ?; Q! L
8. */
   
9. void bsp_Init(void)
   
10. {
    
11.     /* 配置MPU */
    ( c4 b8 z/ j, r" v6 J; j! v
12.     MPU_Config();
    
13. 
    
14.     /* 使能L1 Cache */
    9 J; s1 b! Y' R4 S6 a
15.     CPU_CACHE_Enable();
    
16. 
    ( x1 b2 P4 L% j
17.     /*
    1 q5 N" n8 |  c# ^( ]1 W
18.        STM32H7xx HAL 库初始化，此时系统用的还是H7自带的64MHz，HSI时钟:
    3 s$ p8 G1 _" I/ ~' r" A
19.        - 调用函数HAL_InitTick，初始化滴答时钟中断1ms。
    
20.        - 设置NVIV优先级分组为4。
    
21.      */
    9 T7 C! K  |/ O! r! a1 v* K/ K
22.     HAL_Init();
    + ^0 ^: }2 u7 |" B  \  l
23. 
    
24.     /*
    & w0 a7 t: k/ D$ F& M* p" ~  ]
25.        配置系统时钟到400MHz
    
26.        - 切换使用HSE。
    
27.        - 此函数会更新全局变量SystemCoreClock，并重新配置HAL_InitTick。
    - p7 r3 Q" U+ j# ]# J) R1 x3 r; g
28.     */
    5 W  P6 V! v5 v* V6 \
29.     SystemClock_Config();
    
30. 
    7 v: z$ u9 r; r( l' e/ J" ~
31.     /*
    
32.        Event Recorder：
    + H2 R, V$ r- f: I
33.        - 可用于代码执行时间测量，MDK5.25及其以上版本才支持，IAR不支持。
    
34.        - 默认不开启，如果要使能此选项，务必看V7开发板用户手册第xx章
    
35.     */   
    
36. #if Enable_EventRecorder == 1  
    
37.     /* 初始化EventRecorder并开启 */
    : [! \; Z7 V4 x  u* K7 y- p
38.     EventRecorderInitialize(EventRecordAll, 1U);
    5 `5 X! p7 [/ R, q
39.     EventRecorderStart();
    
40. #endif
    % e; L) ^2 j, S
41. 
    ( L( E* a4 z: E% N8 F+ H
42. bsp_InitDWT();      /* 初始化DWT时钟周期计数器 */      
    / Y. f* {$ [2 r0 ]9 }; A
43.     bsp_InitKey();        /* 按键初始化，要放在滴答定时器之前，因为按钮检测是通过滴答定时器扫描 */
    2 M1 i% M, V( C) x
44.     bsp_InitTimer();      /* 初始化滴答定时器 */
    
45.     bsp_InitLPUart();    /* 初始化串口 */
    
46.     bsp_InitExtIO();    /* 初始化FMC总线74HC574扩展IO. 必须在 bsp_InitLed()前执行 */   
    
47.     bsp_InitLed();        /* 初始化LED */   
    / ^, k4 O: I/ ?
48.     bsp_InitExtSDRAM(); /* 初始化SDRAM */
    8 W. w- s5 S& N* i
49. }
    

复制代码

  MPU配置和Cache配置：

5 G8 e2 F4 E, ]数据Cache和指令Cache都开启。配置了AXI SRAM区（本例子未用到AXI SRAM）和FMC的扩展IO区。
! ]5 `1 l1 _1 a
) v. ?' K  s. G, k8 m  s; ]5 c

1. /*
   
2. *********************************************************************************************************
   
3. *    函 数 名: MPU_Config
   
4. *    功能说明: 配置MPU
   - r* p. {& N) ^  ?$ c- {
5. *    形    参: 无
   1 T+ B2 T+ D; X; i% `* S; \5 y' V
6. *    返 回 值: 无
   , D$ @3 R% u# w- f- n9 d' ~6 T
7. *********************************************************************************************************
   ) {6 q( R2 O1 T# f. ]2 l
8. */
   / i' U. h# `" b- g* O
9. static void MPU_Config( void )
   2 e( j5 k' S% {
10. {
    7 }/ w+ i/ i2 q8 {: G
11.     MPU_Region_InitTypeDef MPU_InitStruct;
    
12. 
    
13.     /* 禁止 MPU */
    
14.     HAL_MPU_Disable();
    : ~9 P9 E2 w2 h' [8 b
15. 
    ; o4 F7 s9 C% P' x
16.     /* 配置AXI SRAM的MPU属性为Write back, Read allocate，Write allocate */
    # }6 |( k+ S& f$ `6 `9 h  F( G/ a$ }
17.     MPU_InitStruct.Enable           = MPU_REGION_ENABLE;
    
18.     MPU_InitStruct.BaseAddress      = 0x24000000;
    
19.     MPU_InitStruct.Size             = MPU_REGION_SIZE_512KB;
    
20.     MPU_InitStruct.AccessPermission = MPU_REGION_FULL_ACCESS;
    1 O$ j: Q# b5 P; }
21.     MPU_InitStruct.IsBufferable     = MPU_ACCESS_BUFFERABLE;
    # p$ g& u1 X, g: M& i
22.     MPU_InitStruct.IsCacheable      = MPU_ACCESS_CACHEABLE;
      S6 [4 P5 S7 Z* {  G1 E; ?
23.     MPU_InitStruct.IsShareable      = MPU_ACCESS_NOT_SHAREABLE;
    
24.     MPU_InitStruct.Number           = MPU_REGION_NUMBER0;
    8 g' r3 E6 o2 c! o: ]& E2 B
25.     MPU_InitStruct.TypeExtField     = MPU_TEX_LEVEL1;
    9 X7 N# u* Y* N% t
26.     MPU_InitStruct.SubRegionDisable = 0x00;
    # |$ d9 q( o( }# o
27.     MPU_InitStruct.DisableExec      = MPU_INSTRUCTION_ACCESS_ENABLE;
    
28. 
    0 w6 u0 b' G. }& R5 A
29.     HAL_MPU_ConfigRegion(&MPU_InitStruct);
    
30. 
    
31. 
    % a; c- j" Z5 w' M
32.     /* 配置FMC扩展IO的MPU属性为Device或者Strongly Ordered */
    & k& }& {  n' K5 d1 E0 H
33.     MPU_InitStruct.Enable           = MPU_REGION_ENABLE;
    
34.     MPU_InitStruct.BaseAddress      = 0x60000000;
    
35.     MPU_InitStruct.Size             = ARM_MPU_REGION_SIZE_64KB;   
    
36.     MPU_InitStruct.AccessPermission = MPU_REGION_FULL_ACCESS;
    
37.     MPU_InitStruct.IsBufferable     = MPU_ACCESS_BUFFERABLE;
    
38.     MPU_InitStruct.IsCacheable      = MPU_ACCESS_NOT_CACHEABLE;   
    
39.     MPU_InitStruct.IsShareable      = MPU_ACCESS_NOT_SHAREABLE;
    9 y! L% j& w7 G9 j7 }
40.     MPU_InitStruct.Number           = MPU_REGION_NUMBER1;
    0 K/ \; G" l, X; [2 |* T  N$ D
41.     MPU_InitStruct.TypeExtField     = MPU_TEX_LEVEL0;
    
42.     MPU_InitStruct.SubRegionDisable = 0x00;
    
43.     MPU_InitStruct.DisableExec      = MPU_INSTRUCTION_ACCESS_ENABLE;
    
44. 
    
45.     HAL_MPU_ConfigRegion(&MPU_InitStruct);
    
46. 
    
47.     /*使能 MPU */
    
48.     HAL_MPU_Enable(MPU_PRIVILEGED_DEFAULT);
    
49. }
    6 z: O1 H. w; t4 q0 t/ [- J
50. 
    
51. /*
    8 d/ I, W- z5 G" D* f) s  O
52. *********************************************************************************************************
    
53. *    函 数 名: CPU_CACHE_Enable
    
54. *    功能说明: 使能L1 Cache
    ' Z; p; @$ r3 r+ `
55. *    形    参: 无
    $ Y3 I( v7 Z7 f+ F: q0 `7 f
56. *    返 回 值: 无
      P" v3 Q1 S" U8 j. L
57. *********************************************************************************************************
    
58. */
    
59. static void CPU_CACHE_Enable(void)
    
60. {
    
61.     /* 使能 I-Cache */
    
62.     SCB_EnableICache();
    # m. q/ L4 b1 g4 @+ G, |
63. 
    1 [% a: K# _  C, R0 v+ o
64.     /* 使能 D-Cache */
    
65.     SCB_EnableDCache();
    
66. }

复制代码

3 }; r9 n% Y. e* i* `2 M

  每10ms调用一次蜂鸣器处理：
. r: b" R5 s* q6 |2 E# m% m& C: x
: j/ n' G2 e2 D9 }蜂鸣器处理是在滴答定时器中断里面实现，每10ms执行一次检测。

1. /*
   
2. *********************************************************************************************************
   
3. *    函 数 名: bsp_RunPer10ms
   
4. *    功能说明: 该函数每隔10ms被Systick中断调用1次。详见 bsp_timer.c的定时中断服务程序。一些处理时间要求
   : l& ]) o; s* u
5. *              不严格的任务可以放在此函数。比如：按键扫描、蜂鸣器鸣叫控制等。
   
6. *    形    参: 无
   9 L7 N* w  \+ u9 z
7. *    返 回 值: 无
   
8. *********************************************************************************************************
   
9. */
   
10. void bsp_RunPer10ms(void)
    : O' X- T- C1 M5 L
11. {
    ( n+ C9 w0 |6 M% K0 B- c0 `+ R2 Z2 a: F
12.     bsp_KeyScan10ms();
    
13. }
    

复制代码

( q/ V+ z2 ~: N) l3 j, a
  主功能：

& G! z' i0 K! W5 w( S3 a3 O主程序实现如下操作：

启动一个自动重装软件定时器，每100ms翻转一次LED2。
) @5 K. v/ F- g7 P K1键按下，将8bit，16bit和32bit数据写入到内部Flash。
K2键按下，将结构体数据写入到内部Flash。
: N) `8 O* s  Z% K4 @

1. /*
   
2. *********************************************************************************************************
   
3. *    函 数 名: main
   . [! F. \/ U* Y
4. *    功能说明: c程序入口
   
5. *    形    参: 无
   - B, @8 ^9 u6 F# E) u3 q
6. *    返 回 值: 错误代码(无需处理)
   % h9 v0 ~1 I0 E# h$ r/ Q7 ]0 `
7. *********************************************************************************************************
   
8. */
   6 y! R; i. N9 o2 e/ L  ?6 k
9. int main(void)
   
10. {
      L1 w  O. I$ l5 D* [) I7 d) M
11.     uint8_t ucKeyCode;    /* 按键代码 */
    4 q  ^- a' h6 R6 p* @
12.     uint8_t  ucTest, *ptr8;
    7 S) d! D- Y( g
13.     uint16_t uiTest, *ptr16;
    " ~1 P/ ]" f0 E6 j
14.     uint32_t ulTest, *ptr32;
    
15.     PARAM_T tPara, *paraptr;
    6 F0 N% {% D" G: ?
16. 
    
17. 
    
18.     /* 初始化数据 */
    / q- O7 r7 g% _
19.     tPara.Baud485 = 0x5555AAAA;
    
20.     tPara.ParamVer = 0x99;
    ! R& }) {4 `( u1 _6 C8 ], k
21.     tPara.ucBackLight = 0x7788;
    / b# h* f. a- H% K, t  u3 Z7 p+ l, |
22.     tPara.ucRadioMode = 99.99f;
    % J2 d! ]. T9 x0 F% w% e- v2 R
23. 
    8 w$ j  Q9 N8 d
24. 
    
25.     bsp_Init();        /* 硬件初始化 */
    9 |* u' @! G+ C4 Y9 F% ^1 F
26.     PrintfLogo();    /* 打印例程名称和版本等信息 */
    - `+ U/ T( t: m+ q) U; Q
27.     PrintfHelp();    /* 打印操作提示 */
    
28. 
    
29.     bsp_StartAutoTimer(0, 100);    /* 启动1个100ms的自动重装的定时器 */
    
30.     while (1)
    
31.     {
    ; N6 z+ d7 J. s& N" N/ g! v. X
32.         bsp_Idle();        /* 这个函数在bsp.c文件。用户可以修改这个函数实现CPU休眠和喂狗 */
    " s1 V3 w/ u8 j5 |4 P, _
33. 
    
34.         /* 判断定时器超时时间 */
    
35.         if (bsp_CheckTimer(0))   
    
36.         {
    
37.             /* 每隔100ms 进来一次 */  
    0 l; H* G; u) i! x6 u* |/ @
38.             bsp_LedToggle(2);
    ( o# g) S0 l2 L0 e
39.         }
    
40. 
    
41.         /* 按键滤波和检测由后台systick中断服务程序实现，我们只需要调用bsp_GetKey读取键值即可。 */
    
42.         ucKeyCode = bsp_GetKey();    /* 读取键值, 无键按下时返回 KEY_NONE = 0 */
    - K. ?9 @( W* l0 E, x' A
43.         if (ucKeyCode != KEY_NONE)
    
44.         {
    
45.             switch (ucKeyCode)
    ' ]( m; m4 n9 k" W( z% \% T
46.             {
    + x( x2 g4 I: l$ _+ o, Q6 ^, Z
47.                 case KEY_DOWN_K1:            /* K1键按下，将8bit，16bit和32bit数据写入到内部Flash */
    $ X7 R+ N* i8 A7 x
48. 
    
49.                 /*
    
50.                  1、对于同一个地址空间，仅支持一次编程(不推荐二次编程，即使是将相应bit由数值1编程0)。
    
51.                  2、只能对已经擦除的空间做编程，擦除1个扇区是128KB。
    
52.                  3、H7的Flash编程时，务必保证要编程的地址是32字节对齐的，即此地址对32求余为0。并且编
    ! y8 I$ b* A! N- P) L& I3 o) p) o
53. 程的数据必须32字节整数倍。函数bsp_WriteCpuFlash对字节数不够32字节整数倍的情况自动补
    
54. 0。
    
55.                 */
    , h. ]  ?% g0 u6 i: {2 c- _
56.                      /* 擦除扇区 */
    
57.                     bsp_EraseCpuFlash((uint32_t)para_flash_area);
    
58. 
    
59.                     ucTest = 0xAA;
    
60.                     uiTest = 0x55AA;
    
61.                     ulTest = 0x11223344;
    - `) d3 x; m: W  U: t4 L! z% \
62. 
    
63.                     /* 扇区写入数据 */
    + {( l' g. a& P
64.                     bsp_WriteCpuFlash((uint32_t)para_flash_area + 32*0,  (uint8_t *)&ucTest,
    
65. sizeof(ucTest));
    1 P  u0 C5 E7 {5 v! R  P
66.                     bsp_WriteCpuFlash((uint32_t)para_flash_area + 32*1,  (uint8_t *)&uiTest,
    7 V6 n" d4 u/ D4 n
67. sizeof(uiTest));
    
68.                     bsp_WriteCpuFlash((uint32_t)para_flash_area + 32*2,  (uint8_t *)&ulTest,
    ; L; [% K4 l% Q5 }$ B2 G, I
69. sizeof(ulTest));               
    
70. 
    7 K% O. Z9 H9 J8 N9 |$ V5 G8 n
71.                     /* 读出数据并打印 */
    
72.                     ptr8  = (uint8_t  *)(para_flash_area + 32*0);
    
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);
    
78. 
    
79.                     break;
    8 F- B' F1 n9 S6 n2 R% _! g  ~
80. 
    
81.                 case KEY_DOWN_K2:            /* K2键按下， 将结构体数据写入到内部Flash */
    - q9 P  i8 P7 v  f
82.                     /* 擦除扇区 */
    & X* S8 g: D3 d& a) J, }/ ]3 U* G
83.                     bsp_EraseCpuFlash((uint32_t)para_flash_area);
    $ P( z: j5 F' I  w0 H9 @
84. 
    
85.                     /* 扇区写入数据 */
    
86.                     bsp_WriteCpuFlash((uint32_t)para_flash_area,  (uint8_t *)&tPara, sizeof(tPara));            
    + X" v+ B) s4 H) T# G9 C
87. 
    + A, i4 ?( v3 k, Z: u0 p, x
88.                     /* 读出数据并打印 */
    
89.                     paraptr  = (PARAM_T  *)((uint32_t)para_flash_area);
    
90. 
    
91. 
    
92.                     printf("写入数据：Baud485=%x, ParamVer=%x, ucBackLight=%x, ucRadioMode=%f\r\n",
    
93.                                                                        tPara.Baud485,
    
94.                                                                         tPara.ParamVer,
    
95.                                                                         tPara.ucBackLight,
    
96.                                                                    paraptr->ucRadioMode);
    3 |, w8 p+ b! k! I; z
97. 
    
98.                     printf("读取数据：Baud485=%x, ParamVer=%x, ucBackLight=%x, ucRadioMode=%f\r\n",
    
99.                                                                         paraptr->Baud485,
    
100.                                                                             paraptr->ParamVer,
     
101.                                                                            paraptr->ucBackLight,
     1 D1 L# s/ w7 ?; y+ r
102.                                                                           paraptr->ucRadioMode);
     + [8 C7 E( s/ p3 u* Q* f1 \
103.                     break;               
     , p! [9 F- Y/ @
104.                 default:
     
105.                     /* 其它的键值不处理 */
     
106.                     break;
     9 P5 |# \( ^0 i3 o: j* l
107.             }
     9 @5 B1 F) v5 d2 X9 i
108.         }
     
109.     }
     
110. }

复制代码

0 ^( ~4 f3 E, y% Y8 t
! e0 k4 A+ M' T6 u2 c* \
+ l8 r/ R$ U( x71.8 总结
9 [+ T* Q# k( Z5 {本章节就为大家讲解这么多， 实际应用中的注意事项比较多，应用到项目之前务必实际测试熟悉下。