71.1 初学者重要提示
  学习本章节前，务必优先学习第70章。
% J! j7 S  _/ d7 P& D+ e2 Z( ?  使用内部Flash模拟EEPROM，务必告诉编译要使用的存储空间，防止这个空间存入了程序。
0 ~2 }: I1 s3 P6 K/ W  i# G  STM32H7的Flash编程时，务必保证要编程的地址是32字节对齐的，即此地址对32求余为0。并且编程的数据必须32字节整数倍。
  STM32H743XI有两个独立的BANK，一个BANK的编程和擦除操作对另一个BANK没有任何影响。但是用户应用程序和要擦写的Flash扇区在同一个BANK，在执行擦写操作时，应用应用程序将停止运行，包括中断服务程序。
  使用内部Flash模拟EEPROM要做到先擦除后使用。
71.2 模拟EEPROM驱动设计
这里重点把内部Flash的读取，编程和擦除做个说明。
  Y1 v+ K, g/ A: i  E( C6 Q
% E" n3 J( g/ o3 ]: j! e( W5 [71.2.1 内部Flash擦除的实现
内部Flash的擦除思路如下：
0 X4 q) r0 K% V2 t. |/ E
  第1步，获取擦除地址所处的扇区。
  第2步，调用函数HAL_FLASH_Unlock解锁。
  第3步，调用函数HAL_FLASHEx_Erase擦除一个扇区。
4 ?' |6 ]) U6 T% E# X! x# n- j  第4步，调用函数HAL_FLASH_Lock上锁。
: V& K, r- m- w! J  M7 |0 }$ N; q按照这个思路，程序实现如下：

1. 1.    /*
   $ |2 [5 D8 g  l0 p+ Z" W9 R
2. 2.    ******************************************************************************************************
   
3. 3.    *    函 数 名: bsp_EraseCpuFlash
   9 O/ Z9 O3 v% M! ]& J! Y/ v
4. 4.    *    功能说明: 擦除CPU FLASH一个扇区 （128KB)
     b5 c8 g& b* C5 ~5 q' k8 o  P
5. 5.    *    形    参: _ulFlashAddr : Flash地址
   % \3 e* L9 {! D' F( x
6. 6.    *    返 回 值: 0 成功， 1 失败
   0 X$ g7 C$ L7 Y# ~1 m
7. 7.    *              HAL_OK       = 0x00,
   
8. 8.    *              HAL_ERROR    = 0x01,
   5 D8 }6 H7 _2 R* L+ s
9. 9.    *              HAL_BUSY     = 0x02,
   
10. 10.    *              HAL_TIMEOUT  = 0x03
    
11. 11.    *
    
12. 12.    ******************************************************************************************************
    
13. 13.    */
    & C6 o4 D/ p' v; P0 T+ [* }* s+ ?
14. 14.    uint8_t bsp_EraseCpuFlash(uint32_t _ulFlashAddr)
    
15. 15.    {
    , _8 k, N8 A( D; W
16. 16.        uint32_t FirstSector = 0, NbOfSectors = 0;
    
17. 17.        FLASH_EraseInitTypeDef EraseInitStruct;
    + Y/ D! v7 ?: b
18. 18.        uint32_t SECTORError = 0;
    - o; I2 b3 s; T5 r; t5 {/ c9 S5 V
19. 19.        uint8_t re;
    
20. 20.   
    
21. 21.        /* 解锁 */
    ( B. |# q1 |6 R9 O2 |
22. 22.        HAL_FLASH_Unlock();
    
23. 23.        
    , J; R! e) Z3 ]( X
24. 24.        /* 获取此地址所在的扇区 */
    
25. 25.        FirstSector = bsp_GetSector(_ulFlashAddr);
    8 I1 z. T" W: k( n  v7 l
26. 26.        
    9 A! E: c! W6 Y, R4 ?- o
27. 27.        /* 固定1个扇区 */
    1 b" g1 s4 f3 a1 N. V) U. ?
28. 28.        NbOfSectors = 1;   
    ' |8 f- x/ t4 l1 Z/ i; F: ^& F9 \
29. 29.   
    
30. 30.        /* 擦除扇区配置 */
    
31. 31.        EraseInitStruct.TypeErase     = FLASH_TYPEERASE_SECTORS;
    6 Z- {7 k- {  @( h# Q& ]; g, l
32. 32.        EraseInitStruct.VoltageRange  = FLASH_VOLTAGE_RANGE_3;
    6 Y9 k2 G& F) D2 T
33. 33.        
    
34. 34.        if (_ulFlashAddr >= ADDR_FLASH_SECTOR_0_BANK2)
    
35. 35.        {
    
36. 36.            EraseInitStruct.Banks         = FLASH_BANK_2;
    
37. 37.        }
    9 N- R& V6 [( K8 G2 i7 R  p
38. 38.        else
    * d) K5 b4 A4 ]$ a" {
39. 39.        {
    
40. 40.            EraseInitStruct.Banks         = FLASH_BANK_1;
    
41. 41.        }
    
42. 42.        
    9 h; T* w% s9 \9 f5 s  p8 n, `
43. 43.        EraseInitStruct.Sector        = FirstSector;
    
44. 44.        EraseInitStruct.NbSectors     = NbOfSectors;
    ' i1 Y: _1 L1 y0 A9 B* ^; i0 {
45. 45.        
    
46. 46.        /* 扇区擦除 */   
    
47. 47.        re = HAL_FLASHEx_Erase(&EraseInitStruct, &SECTORError);
    / s5 P) W9 S; k/ Y) ?0 C, B
48. 48.        
    8 A9 |& I6 s  |. g( ^/ q
49. 49.        /* 擦除完毕后，上锁 */
    , x, W8 E' v' f/ K
50. 50.        HAL_FLASH_Lock();   
    
51. 51.        
    ; i, i. {# G- [3 i  @. \1 y5 A5 K
52. 52.        return re;
    ) j. T2 I; D, z# E  n& @
53. 53.    }

复制代码

! S4 ]/ O8 ]1 Q3 c/ }( ^( ^( Q
这里将此程序设计的关键点为大家做个说明：
* F$ x. V* v% z. M7 t5 w
, Q7 M6 L5 \  G& I" D( Y' ^9 r! m  第25行函数是通过函数bsp_GetSector获取要擦除地址所处的扇区。这个函数的实现比较简单，代码如下：

1. /*
   6 `5 Z+ ]# N# l4 i$ ~) r+ a1 z1 s
2. *********************************************************************************************************
   # L1 |7 a9 ]' F) E
3. *    函 数 名: bsp_GetSector
   
4. *    功能说明: 根据地址计算扇区首地址
   2 S. ^: q9 U& f8 s* z! M
5. *    形    参: 无
   2 I- f2 W" \' M9 M8 A' {, }
6. *    返 回 值: 扇区号（0-7)
   " k8 B. U, e+ h% ?
7. *********************************************************************************************************
   
8. */
   2 [) Z# y4 W  G$ P' c, L
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)) || \
    " n: u( ?) A. W3 H
14.         ((Address < ADDR_FLASH_SECTOR_1_BANK2) && (Address >= ADDR_FLASH_SECTOR_0_BANK2)))   
    $ I: Z  l, ^: t) V% C: p- U$ r
15.     {
    % i" M9 U, b7 X1 s+ W7 y
16.         sector = FLASH_SECTOR_0;  
    . k4 I* Q" b, v' S# j6 c* [5 g
17.     }
    ; b! N! ~8 G' a$ v4 q
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)))   
    5 |1 O- Q. L3 y
20.     {
    ( C9 b% Z3 o5 Z+ ^( W# ~+ Y' K
21.         sector = FLASH_SECTOR_1;  
    
22.     }
    
23.     else if (((Address < ADDR_FLASH_SECTOR_3_BANK1) && (Address >= ADDR_FLASH_SECTOR_2_BANK1)) || \
    
24.       ((Address < ADDR_FLASH_SECTOR_3_BANK2) && (Address >= ADDR_FLASH_SECTOR_2_BANK2)))   
    ! h  W% p* l+ f/ W6 ?3 K
25.     {
    
26.         sector = FLASH_SECTOR_2;  
    2 t5 d4 r* e% f! S! x
27.     }
    8 _  `$ a2 D7 e. C# ]
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)))   
    
30.     {
    
31.         sector = FLASH_SECTOR_3;  
    - \+ E! J# Q) T6 c- r2 g% ~. b, P
32.     }
    8 S+ w  n/ y  K
33.     else if (((Address < ADDR_FLASH_SECTOR_5_BANK1) && (Address >= ADDR_FLASH_SECTOR_4_BANK1)) || \
    
34.       ((Address < ADDR_FLASH_SECTOR_5_BANK2) && (Address >= ADDR_FLASH_SECTOR_4_BANK2)))   
    7 H2 Q, X1 h/ Z# |
35.     {
    
36.         sector = FLASH_SECTOR_4;  
    # O( z0 w- o9 q0 _
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)))   
    5 x" ^" }( }8 C2 ~
40.     {
    
41.         sector = FLASH_SECTOR_5;  
    & A" Z& G2 e( ~' C6 \
42.     }
    " q0 ~. y$ K! |9 I
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.     {
    / U+ F# y9 u! m& T% Z! j4 a) l
46.         sector = FLASH_SECTOR_6;  
    
47.     }
    
48.     else if (((Address < ADDR_FLASH_SECTOR_0_BANK2) && (Address >= ADDR_FLASH_SECTOR_7_BANK1)) || \
    ) E1 H* R7 O9 ]5 c0 w  z, p
49.       ((Address < CPU_FLASH_END_ADDR) && (Address >= ADDR_FLASH_SECTOR_7_BANK2)))
    5 G7 e0 u/ ^6 a3 k7 Z
50.     {
    
51.         sector = FLASH_SECTOR_7;  
    $ y: ], }' z) ~6 a% l
52.     }
    6 O& F" i- _. h( T
53.     else
    
54.     {
    3 j# }1 [5 E8 G, m
55.         sector = FLASH_SECTOR_7;
    
56.     }
    
57. 
    - @0 U  _6 H+ d3 s7 U
58.     return sector;
    ( }" ]+ o9 x% M6 V8 y( e
59. }
    6 Z- H5 o+ q' J6 i" i: O/ Q! |

复制代码

7 Q0 A8 k2 N- i8 s由于STM32H7的BANK1和BANK2是独立的，都有8个扇区，所以程序里面只需返回要擦除地址所处的扇区号即可。

& P" y  `9 |+ R) r2 x5 I0 c  第47行的擦除函数HAL_FLASHEx_Erase在第70章的4.4小节有说明。
71.2.2 内部Flash编程的实现
内部Flash的编程思路如下：

  第1步，判断是否要编写数据进去，如果数据已经在内部Flash里面。
  第2步，调用函数HAL_FLASH_Unlock解锁。
9 @. Q9 l% I9 G- i4 P6 A" _  第3步，调用函数HAL_FLASH_Program对内部Flash编程数据。
  第4步，调用函数HAL_FLASH_Lock上锁。
按照这个思路，程序实现如下：
. a3 W% x' R8 a- s

1. 1.    /*
   # }- |5 B+ S1 ~; q2 J! F
2. 2.    ******************************************************************************************************
   * V2 B1 a+ i- J4 G' E1 ]
3. 3.    *    函 数 名: bsp_WriteCpuFlash
   
4. 4.    *    功能说明: 写数据到CPU 内部Flash。 必须按32字节整数倍写。不支持跨扇区。扇区大小128KB. \
   & B8 Q* m# R$ t4 y, s! ^5 W
5. 5.    *              写之前需要擦除扇区. 长度不是32字节整数倍时，最后几个字节末尾补0写入.
   0 r4 i5 o# x4 Z) X) u
6. 6.    *    形    参: _ulFlashAddr : Flash地址
   
7. 7.    *             _ucpSrc : 数据缓冲区
   4 F3 ?9 ]2 q- z1 n9 v
8. 8.    *             _ulSize : 数据大小（单位是字节, 必须是32字节整数倍）
   ) L! e) F3 Q% l% J
9. 9.    *    返 回 值: 0-成功，1-数据长度或地址溢出，2-写Flash出错(估计Flash寿命到)
   / ?/ v- M; \) A: @2 i4 m2 _" U" z
10. 10.    ******************************************************************************************************
    
11. 11.    */
    
12. 12.    uint8_t bsp_WriteCpuFlash(uint32_t _ulFlashAddr, uint8_t *_ucpSrc, uint32_t _ulSize)
    & t) o5 F% S- y$ B6 K+ B) U( n
13. 13.    {
    
14. 14.        uint32_t i;
    8 h' e  n$ u, F. X  j
15. 15.        uint8_t ucRet;
    3 ~2 a5 w' R& v, h
16. 16.   
    1 L, W, p' h( H$ c6 @' t
17. 17.        /* 如果偏移地址超过芯片容量，则不改写输出缓冲区 */
    
18. 18.        if (_ulFlashAddr + _ulSize > CPU_FLASH_BASE_ADDR + CPU_FLASH_SIZE)
    
19. 19.        {
    
20. 20.            return 1;
    
21. 21.        }
    6 P& t8 {" r) g& U! b+ H' m
22. 22.   
    + G( L5 d6 X' G0 F
23. 23.        /* 长度为0时不继续操作  */
    , O: s7 i8 p0 s# r' D
24. 24.        if (_ulSize == 0)
    
25. 25.        {
    
26. 26.            return 0;
    
27. 27.        }
    2 [7 L% x7 c0 G, O. S# R2 E
28. 28.   
    + l% l$ c  R) H/ |* S+ }2 S
29. 29.        ucRet = bsp_CmpCpuFlash(_ulFlashAddr, _ucpSrc, _ulSize);
    
30. 30.   
    & u6 f6 I- G; g  X
31. 31.        if (ucRet == FLASH_IS_EQU)
    4 H% u4 {* b3 v& Z6 C  {9 N5 _5 z! {
32. 32.        {
    ; \) l! \( _2 |3 Y" X
33. 33.            return 0;
    
34. 34.        }
    
35. 35.   
    
36. 36.        __set_PRIMASK(1);          /* 关中断 */
    
37. 37.   
      }, C3 m  m: {% _
38. 38.        /* FLASH 解锁 */
    
39. 39.        HAL_FLASH_Unlock();
    
40. 40.   
    7 ^/ Y/ |/ N3 Y6 c; L
41. 41.        for (i = 0; i < _ulSize / 32; i++)   
    
42. 42.        {
    
43. 43.            uint64_t FlashWord[4];
    3 P$ O. o: U6 x4 C
44. 44.            
    
45. 45.            memcpy((char *)FlashWord, _ucpSrc, 32);
    
46. 46.            _ucpSrc += 32;
    0 @4 i  u% r; G
47. 47.            
    
48. 48.            if (HAL_FLASH_Program(FLASH_TYPEPROGRAM_FLASHWORD, _ulFlashAddr,
    . ~( X9 ]. u. ^4 i% b' l
49. 49.                                      (uint64_t)((uint32_t)FlashWord)) == HAL_OK)
    
50. 50.            {
    : q4 l; c8 V, V7 o' F  w. V
51. 51.                _ulFlashAddr = _ulFlashAddr + 32; /* 递增，操作下一个256bit */               
    
52. 52.            }        
    % Z4 ~5 f' z. y# _4 @, V9 p
53. 53.            else
    
54. 54.            {
    
55. 55.                goto err;
    
56. 56.            }
    ' |5 C, Q/ y" o0 d- F% o
57. 57.        }
    
58. 58.        
    
59. 59.        /* 长度不是32字节整数倍 */
    3 {2 [/ g6 c( `4 _1 Y* ?! ]( b" @
60. 60.        if (_ulSize % 32)
    
61. 61.        {
    3 W: g0 E8 Z/ w) ]7 q
62. 62.            uint64_t FlashWord[4];
    
63. 63.            
    ! Z3 D1 d6 y! N& @, }7 \, L
64. 64.            FlashWord[0] = 0;
    
65. 65.            FlashWord[1] = 0;
    . b& q+ C" G' o/ |- r) e: d$ s+ M
66. 66.            FlashWord[2] = 0;
    * ]! O8 {4 K% H2 l8 B
67. 67.            FlashWord[3] = 0;
    ; ~. G1 m9 z1 t" p
68. 68.            memcpy((char *)FlashWord, _ucpSrc, _ulSize % 32);
    & e8 H- Y# \! N$ d) c9 @1 s
69. 69.            if (HAL_FLASH_Program(FLASH_TYPEPROGRAM_FLASHWORD, _ulFlashAddr,
    ( d- w. C& \3 f8 F3 f) p( V
70. 70.                                               (uint64_t)((uint32_t)FlashWord)) == HAL_OK)
    / }2 N9 H7 J/ u2 {$ V) ~
71. 71.            {
    9 ~. C! T, ]+ p) t+ M% M% s
72. 72.                ; // _ulFlashAddr = _ulFlashAddr + 32;
    
73. 73.               
      c9 E, j/ U8 x. d0 {
74. 74.            }        
    
75. 75.            else
    : M7 P/ A% y5 K' O7 A
76. 76.            {
    1 q" r7 J0 `8 u6 s5 b# E0 U* {
77. 77.                goto err;
    
78. 78.            }
    : y/ C8 O* U. q( B& E0 `# u  y; q
79. 79.        }
    " f5 b0 f5 [# O% T4 ?$ w: ~: n
80. 80.        
    6 o/ B: L: C0 |0 N! w
81. 81.          /* Flash 加锁，禁止写Flash控制寄存器 */
    $ {  H' ?* a1 J7 _0 S  l
82. 82.          HAL_FLASH_Lock();
    9 d& V1 K9 O4 H/ l  E/ G6 a" a
83. 83.   
    " r6 @, `9 W* v4 N, T  n
84. 84.          __set_PRIMASK(0);          /* 开中断 */
    
85. 85.   
    
86. 86.        return 0;
      l/ y2 y& P& g. F* b/ k
87. 87.        
    ( k7 o% L- L8 a( i
88. 88.    err:
    
89. 89.          /* Flash 加锁，禁止写Flash控制寄存器 */
    
90. 90.          HAL_FLASH_Lock();
    
91. 91.   
    
92. 92.          __set_PRIMASK(0);          /* 开中断 */
    7 n& A, k& }. n* Q
93. 93.   
    + |% _2 R2 o) r. m1 J4 l1 U. `3 ?
94. 94.        return 1;
    
95. 95.    }
    ; D$ Y) K  x$ y; M8 ^3 ?; J

复制代码

2 ?0 l+ v; }8 J关于此函数有几个要点：

1 a2 t0 G6 R8 Y3 b+ S  第1个参数必须32字节对齐，即要编程的Flash地址对32求余为0。
  第3个参数必须是32字节的整数倍，长度不是32字节整数倍时，最后几个字节补0写入。
0 K& z2 [; Q9 @9 J. R6 W- @" z6 b  第29行，函数bsp_CmpCpuFlash放在这里只有一个作用，判断将要写入的数据是否已经在内部Flash存在，如果已经存在，无需重复写入，直接返回。
  第36行，做了一个关中断操作，这里有个知识点要给大家普及下，由于H7的BANK1和BANK2是独立的，当前正在擦除的扇区所处的BANK会停止所有在此BANK执行的程序，包含中断也会停止执行。比如当前的应用程序都在BANK1，如果要擦除或者编程BANK2，是不会不影响BANK1里面执行的程序。这里安全起见加上了开关中断。
, r; U. {3 q# u$ ?+ c) B  第41到57行，先将32字节整数倍的数据通过函数HAL_FLASH_Program编程，此函数每次可以固定编程32字节数据。
7 Q' V7 v, w7 L0 b  第60到79行，将剩余不足32字节的数据补0，凑齐32字节编程。
+ W/ q4 D% y/ H9 a71.2.3 内部Flash读取的实现
内部Flash数据读取比较简单，采用总线方式读取，跟访问内部RAM是一样的。比如要读取地址
) @. b  \7 D1 G8 N1 f5 }) B
. W8 F& Z$ P, {. v4 k! R0x08100000里面的一个32bit变量，我们就可以：

; [4 L. O+ b4 f2 ]' N% X2 |变量 = *(uint32_t *)(0x08100000)

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

! ?- z  T& ?9 b3 u

1. /*
   : M" }, M! k/ C: Q' A. n; [! `
2. *********************************************************************************************************
   
3. *    函 数 名: bsp_ReadCpuFlash
   ! R1 k0 T) a2 Y0 {# k
4. *    功能说明: 读取CPU Flash的内容
   8 q+ x5 G- M7 O: v& I# C9 {8 |
5. *    形    参:  _ucpDst : 目标缓冲区
   
6. *             _ulFlashAddr : 起始地址
     T% v; v1 x  t$ h1 b
7. *             _ulSize : 数据大小（单位是字节）
   8 y5 ?8 j" Q9 L. m8 L3 B
8. *    返 回 值: 0=成功，1=失败
   
9. *********************************************************************************************************
   
10. */
    $ G+ o6 O( |% K6 s1 ]
11. uint8_t bsp_ReadCpuFlash(uint32_t _ulFlashAddr, uint8_t *_ucpDst, uint32_t _ulSize)
    
12. {
    
13.     uint32_t i;
    4 B+ t% R% e9 X$ }* m5 q5 P) u' O
14. 
    
15.     if (_ulFlashAddr + _ulSize > CPU_FLASH_BASE_ADDR + CPU_FLASH_SIZE)
    
16.     {
    0 C$ P9 b3 F+ O
17.         return 1;
    0 c8 X* u. T8 H5 q6 h- o% t5 R/ b5 a
18.     }
    , n: W" f! x0 c! q! e9 y
19. 
    
20.     /* 长度为0时不继续操作,否则起始地址为奇地址会出错 */
      B8 U. W5 d  J6 e  L/ n9 q
21.     if (_ulSize == 0)
    , Q. ^$ G) s% M2 g
22.     {
    
23.         return 1;
    
24.     }
    
25. 
    
26.     for (i = 0; i < _ulSize; i++)
    & L9 j( T6 G8 g8 n5 D$ }; Y5 p
27.     {
    8 H4 `# K, S( z7 u
28.         *_ucpDst++ = *(uint8_t *)_ulFlashAddr++;
    % l0 o& |) _+ G; L
29.     }
    
30. 
    ( Z- E" M3 T) z2 C7 X7 c' q8 C
31.     return 0;
    
32. }
    ' C5 }/ ^) ?7 C# `, [" j0 c

复制代码

3 f7 E/ B* Q' M3 g71.2.4 告诉编译器使用的扇区（重要）
使用内部Flash模拟EEPROM切不可随意定义一个扇区使用。因为编译器并不知道用户使用了这个扇区，导致应用程序也会编程到此扇区里面，所以就需要告诉编译器。
! l( A5 ~+ @4 Q& E& c4 K* L
告诉MDK的方法如下（0x0810 0000是H7的BANK2首地址）：
" }% P9 d0 h1 V  t6 `

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

复制代码

* q; a9 i. T' ]! U告诉IAR的方法如下：
0 \) W& E( Q  E# ]1 g7 y
9 k! r) z+ k' C% [9 Q

1. #pragma location=0x08100000
   
2. const uint8_t para_flash_area[128*1024];
   3 i2 A6 P3 i4 K( _' c- v. [, ~

复制代码

这里有两点特别注意：
# c6 }2 @# D- u" w; S( A6 d0 k4 z
  模拟EEPROM的扇区可以定义到从第2个扇区开始的任何扇区，但不可以定义到首扇区，因为这个扇区是默认的boot启动地址。
  如果应用程序不大的话，不推荐定义到末尾扇区，以MDK为例，定义到末尾扇区后，会导致整个Flash空间都被使用，从而让程序下载下载时间变长。
* s4 y- c8 H; h% }71.3 模拟EEPROM板级支持包（bsp_cpu_flash.c）
+ C. M0 B! Y, {+ o# \模拟EEPROM的驱动文件bsp_cpu_flash.c主要实现了如下几个API供用户调用：
, k9 J( B3 V' j0 r1 N
3 h; H: G# T0 v, i) F6 U0 O- g2 B  bsp_GetSector
6 \1 u/ n) O- O1 f  bsp_ReadCpuFlash
  bsp_CmpCpuFlash
  bsp_EraseCpuFlash
! n! B4 O( i" U1 E. B: p  bsp_WriteCpuFlash
71.3.1 函数bsp_GetSector
  f" d( m& T; V0 G- Q函数原型：
5 P' K  D1 T1 l5 k0 q$ b

1. uint32_t bsp_GetSector(uint32_t Address)

复制代码

函数描述：
, H  f0 H2 B! X8 E) y$ M. x. ~( F
此函数主要用于获取给定地址所处的扇区。

函数参数：

; g" [7 X% Y. K) k( t, {! G5 Y9 J  第1个参数是用户给定的地址。
5 W6 n/ h+ w2 I6 f7 I  返回值，范围FLASH_SECTOR_0到FLASH_SECTOR_7。
0 L0 l- t- {; n3 ~6 Z4 E71.3.2 函数bsp_ReadCpuFlash
函数原型：
- \3 b% y  x, ]; M& Z6 s" N

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

复制代码

+ Z" U* }0 }0 W: |  s函数描述：
/ x! z+ V* z8 ^( a
此函数用于从内部Flash读取数据
7 B/ u9 W5 Q, ]5 s2 b6 c. Y
6 y  e: T: V, L" \函数参数：
* v, t6 k$ B2 ?, C& X
  第1个参数读取的起始地址。
" ?" n+ z6 U  L  第2个参数是读取数据的存储地址
6 H4 E2 q' Q" X+ _  第3个参数是读取数据的大小，单位字节。
  返回值，0表示成功，1表示失败。
71.3.3 函数bsp_CmpCpuFlash
% y* d) E- m# e$ E! a) F; h函数原型：

0 r, k/ z# e7 Tuint8_t bsp_CmpCpuFlash(uint32_t _ulFlashAddr, uint8_t *_ucpBuf, uint32_t _ulSize)
% N2 j2 T2 j& x5 \" ^9 J
函数描述：

' P# E% y0 F2 P; K要编程的数据是否在内部Flash已经存在。

9 X: Z+ b$ }% L, b函数参数：

# l7 x3 E5 v* p! S  第1个参数是内部Flash地址。
  第2个参数是缓冲区地址。
  第3个参数是数据大小，单位字节。
  返回值：
/ q) o  C4 b  X+ Q- WFLASH_IS_EQU               0   Flash内容和待写入的数据相等，不需要擦除和写操作。

FLASH_REQ_WRITE          1     Flash不需要擦除，直接写。
2 H5 U( x* E6 n* \1 r1 d8 z# |
FLASH_REQ_ERASE          2     Flash需要先擦除,再写。
# Q& T8 m4 g. M: l1 Y
& H3 ?; K6 F& }" eFLASH_PARAM_ERR         3     函数参数错误。
( j8 f& r) s4 L' n6 K& d
71.3.4 函数bsp_EraseCpuFlash
函数原型：

uint8_t bsp_EraseCpuFlash(uint32_t _ulFlashAddr)
2 L* o: S- F7 K0 |/ {4 }) C
函数描述：
- h& P; S, t0 S; q0 a0 v
此函数用于擦除一个扇区，大小128KB
  V9 M  K) f# @/ U) B9 x
函数参数：

  第1个参数要擦除的扇区地址，可以是此扇区范围内的任意值，一般填扇区首地址即可。
4 Y' x4 u; ]! \& c* @6 a" B0 g. m  返回值：
. L- ^& P) N: @9 P( L/ A% ^# d  K$ B' @/ FHAL_OK        = 0x00
6 o6 M6 {( P* G
HAL_ERROR    = 0x01
: a5 q: i7 J6 X- ]8 m( U2 C
; t$ L( p4 V  g  }4 |& B  l2 LHAL_BUSY      = 0x02

0 ?' c$ }) e: FHAL_TIMEOUT  = 0x03
7 ^. I% Q% c7 Q# Z
71.3.5 函数bsp_WriteCpuFlash
函数原型：
/ e: v- Z% g' K$ ]( y
uint8_t bsp_WriteCpuFlash(uint32_t _ulFlashAddr, uint8_t *_ucpSrc, uint32_t _ulSize)

函数描述：
1 H/ T5 @) N8 L
此函数用于编程数据到内部Flash。

函数参数：

& Q5 q, ]- m; X. t* v  第1个参数是要编程的内部Flash地址。
  第2个参数是数据缓冲区地址。
  @2 }7 W& s0 P  Q3 J, `/ x9 O  第3个参数是数据大小，单位字节。
6 P2 k& v4 w! g) n  返回值，0-成功，1-数据长度或地址溢出，2-写Flash出错(估计Flash寿命到)。
注意事项：

  第1个参数必须32字节对齐，即要编程的Flash地址对32求余为0。
: _1 X7 ^1 Z5 D8 q8 j; Q9 _* [  第3个参数必须是32字节的整数倍，长度不是32字节整数倍时，此函数会将几个字节补0写入
! q" e6 \% K" j9 ?/ n* B71.4 模拟EEPROM驱动移植和使用
模拟EEPROM移植步骤如下：
- _9 L$ o1 \- P- R
8 q4 |: C" ?) |4 t6 \  第1步：复制bsp_cpu_flash.c和bsp_cpu_flash.h到自己的工程目录，并添加到工程里面。
  第2步：Flash驱动文件主要用到HAL库的Flash驱动文件，简单省事些可以添加所有HAL库C源文件进来。
2 \0 w2 d+ ^5 e- U3 J  [  第3步，应用方法看本章节配套例子即可。
# U. v3 b1 h# I- \71.5 实验例程设计框架
通过程序设计框架，让大家先对配套例程有一个全面的认识，然后再理解细节，本次实验例程的设计框架如下：
& I5 H6 b: ~. i
4 q; k7 d9 ]3 D& G: @; [

  第1阶段，上电启动阶段：
$ v$ Q' L, s  l
这部分在第14章进行了详细说明。
9 s6 q! N6 }; _) z( d7 z, H  第2阶段，进入main函数：
" _& V  S' }3 Q0 E# Z5 ~
2 E' u) S/ U6 x, D' |& n  第1部分，硬件初始化，主要是MPU，Cache，HAL库，系统时钟，滴答定时器和LED。
  第2部分，应用程序设计部分，实现内部Flash模拟EEPROM。
8 d' G: n) K: |1 q  X71.6 实验例程说明（MDK）
: n/ [$ o+ Z1 j; B配套例子：
3 a9 B2 z: H, \/ r9 {; M# M
$ t+ P4 \+ f" B; V& oV7-049_内部Flash模拟EEPROM

, r9 H2 l# T2 Z5 ~实验目的：

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

1 P" e4 v& g1 K3 h+ t  z& `使用内部Flash模拟EEPROM，务必告诉编译要使用的存储空间，防止这个空间存入了程序。
对于同一个地址空间，仅支持一次编程(不推荐二次编程，即使是将相应bit由数值1编程0)。
只能对已经擦除的空间做编程，擦除1个扇区是128KB。
H7的Flash编程时，务必保证要编程的地址是32字节对齐的，即此地址对32求余为0。
并且编程的数据必须32字节整数倍，函数bsp_WriteCpuFlash对字节数不够32字节整数倍的情况自动补0。

/ s4 m0 k( Z; c. t* {* z; m实验操作：

8 [; f9 x4 y0 P- x) C( n: K' wK1键按下，将8bit，16bit和32bit数据写入到内部Flash。
& F; T' Z* X3 z+ X4 _; k) qK2键按下，将结构体数据写入到内部Flash。
2 T. D. Z  ?5 ?! w上电后串口打印的信息：

波特率 115200，数据位 8，奇偶校验位无，停止位 1。
% A0 H/ a6 S( h# c  W7 C

( b9 |: r  I  H$ m& x; W
# @7 J% o8 z" q: j# l2 Y程序设计：

9 z4 N1 b- N7 E) X! E! H  z  系统栈大小分配：
6 ^: N% i+ t4 F/ ~$ Y+ Z0 [

  RAM空间用的DTCM：

  硬件外设初始化
3 B2 B% Q' O* ?# q9 }/ r* w
硬件外设的初始化是在 bsp.c 文件实现：

) L! K3 U; M* \+ B" H! R

1. /*
   . i0 g6 H6 C/ T. @- O( f" m/ ]
2. *********************************************************************************************************
   
3. *    函 数 名: bsp_Init
   
4. *    功能说明: 初始化所有的硬件设备。该函数配置CPU寄存器和外设的寄存器并初始化一些全局变量。只需要调用一次
   % R# Y% O" U2 u4 h' Z2 j
5. *    形    参：无
   
6. *    返 回 值: 无
   
7. *********************************************************************************************************
   
8. */
   ) j, V6 j' o+ v! t
9. void bsp_Init(void)
   
10. {
    
11.     /* 配置MPU */
    , O) o6 @7 p, O
12.     MPU_Config();
    1 k: P8 {* ^8 d% p1 \! p8 O
13. 
    
14.     /* 使能L1 Cache */
    # k/ A8 R: k/ c1 N) _
15.     CPU_CACHE_Enable();
    
16. 
    
17.     /*
    4 B! J* j" E5 K, }: [, o; i
18.        STM32H7xx HAL 库初始化，此时系统用的还是H7自带的64MHz，HSI时钟:
    
19.        - 调用函数HAL_InitTick，初始化滴答时钟中断1ms。
    ; `  D  J2 R( x) d- W
20.        - 设置NVIV优先级分组为4。
    
21.      */
    . s2 Q$ \9 i: b- f! h$ n
22.     HAL_Init();
    
23. 
    
24.     /*
    / C/ f* J% e5 Y0 `) g
25.        配置系统时钟到400MHz
    - n" w' a7 [1 g% k( O5 O1 X
26.        - 切换使用HSE。
    $ |3 p! @3 t% j; t3 k
27.        - 此函数会更新全局变量SystemCoreClock，并重新配置HAL_InitTick。
    
28.     */
    ) C3 I  F; F, U5 R! ?# C! Y
29.     SystemClock_Config();
    
30. 
    5 B4 u6 b2 T# q6 D& w
31.     /*
    , b; D6 v  ]7 I7 b3 k- b
32.        Event Recorder：
    
33.        - 可用于代码执行时间测量，MDK5.25及其以上版本才支持，IAR不支持。
    
34.        - 默认不开启，如果要使能此选项，务必看V7开发板用户手册第xx章
    5 k* W+ y7 L! [6 [/ O$ h0 r+ k# y
35.     */   
    
36. #if Enable_EventRecorder == 1  
    7 k% `0 w2 |7 p. f3 w0 ~" B4 o0 b
37.     /* 初始化EventRecorder并开启 */
    8 z1 a* W* g  E5 l0 A/ ~
38.     EventRecorderInitialize(EventRecordAll, 1U);
    
39.     EventRecorderStart();
    6 g5 M: J1 D* K  L* w9 x
40. #endif
    2 u! G( |: B$ j# ^( Q7 Q
41. 
    - g7 X$ ]1 T1 x; ?3 Q1 R0 ?
42. bsp_InitDWT();      /* 初始化DWT时钟周期计数器 */      
    % M5 {6 ]( x. Y8 W
43.     bsp_InitKey();        /* 按键初始化，要放在滴答定时器之前，因为按钮检测是通过滴答定时器扫描 */
    
44.     bsp_InitTimer();      /* 初始化滴答定时器 */
    4 u6 {  A9 a2 {9 ?% ?/ R2 I
45.     bsp_InitLPUart();    /* 初始化串口 */
    * u# p8 v/ ?6 [
46.     bsp_InitExtIO();    /* 初始化FMC总线74HC574扩展IO. 必须在 bsp_InitLed()前执行 */   
    ; B3 _1 s5 F+ V3 Q! W3 O6 m# @. {
47.     bsp_InitLed();        /* 初始化LED */   
    , t- f, g) J: e7 W
48.     bsp_InitExtSDRAM(); /* 初始化SDRAM */
    
49. }
    8 Y" r6 T& x% S! J% P

复制代码

  MPU配置和Cache配置：

/ G8 P  S( z/ r' `" a数据Cache和指令Cache都开启。配置了AXI SRAM区（本例子未用到AXI SRAM）和FMC的扩展IO区。

' ~. Z. b) }5 i3 v

1. /*
   
2. *********************************************************************************************************
   # B4 E/ x% ~$ |: T7 f
3. *    函 数 名: MPU_Config
   4 ?5 l) [* U( C
4. *    功能说明: 配置MPU
   
5. *    形    参: 无
   % V- n* q8 _; l# U  A6 m
6. *    返 回 值: 无
   
7. *********************************************************************************************************
   
8. */
   ) L/ q/ u  i% z6 A
9. static void MPU_Config( void )
   
10. {
    2 _8 k3 K" ^& n
11.     MPU_Region_InitTypeDef MPU_InitStruct;
    
12. 
    " |$ |$ p& f! X/ ]/ i
13.     /* 禁止 MPU */
    , Q$ B/ u4 c8 x- I- L
14.     HAL_MPU_Disable();
    ; ~" F; G) u" E  B8 R) K$ w% v+ o
15. 
    
16.     /* 配置AXI SRAM的MPU属性为Write back, Read allocate，Write allocate */
    
17.     MPU_InitStruct.Enable           = MPU_REGION_ENABLE;
    
18.     MPU_InitStruct.BaseAddress      = 0x24000000;
    
19.     MPU_InitStruct.Size             = MPU_REGION_SIZE_512KB;
    . J; m) _. ?$ s; P% r
20.     MPU_InitStruct.AccessPermission = MPU_REGION_FULL_ACCESS;
    
21.     MPU_InitStruct.IsBufferable     = MPU_ACCESS_BUFFERABLE;
    6 G; m; r/ w, g8 m+ n$ Y8 Q
22.     MPU_InitStruct.IsCacheable      = MPU_ACCESS_CACHEABLE;
    
23.     MPU_InitStruct.IsShareable      = MPU_ACCESS_NOT_SHAREABLE;
    ( n, V, y8 n, H  e) `$ Y: G
24.     MPU_InitStruct.Number           = MPU_REGION_NUMBER0;
    1 D) w# o' p  E, U7 a# h0 t  u2 z
25.     MPU_InitStruct.TypeExtField     = MPU_TEX_LEVEL1;
    
26.     MPU_InitStruct.SubRegionDisable = 0x00;
    % \! t, S4 O; q, D  J
27.     MPU_InitStruct.DisableExec      = MPU_INSTRUCTION_ACCESS_ENABLE;
    * L7 _. L! q, k9 N. [+ A
28. 
    . K5 f1 O: S  R1 [. R. B4 ?: n( H
29.     HAL_MPU_ConfigRegion(&MPU_InitStruct);
    5 q& Q6 ^& ?& T; a
30. 
    
31. 
    
32.     /* 配置FMC扩展IO的MPU属性为Device或者Strongly Ordered */
    $ ^+ a( ^# V4 E2 g9 F" W
33.     MPU_InitStruct.Enable           = MPU_REGION_ENABLE;
    
34.     MPU_InitStruct.BaseAddress      = 0x60000000;
    
35.     MPU_InitStruct.Size             = ARM_MPU_REGION_SIZE_64KB;   
    2 E5 P- h& V. J8 ]; b* D% E
36.     MPU_InitStruct.AccessPermission = MPU_REGION_FULL_ACCESS;
    ; i$ ]) x" y( N# ?9 ]8 V
37.     MPU_InitStruct.IsBufferable     = MPU_ACCESS_BUFFERABLE;
    . e  v, o0 y  U* ^; ^' Q
38.     MPU_InitStruct.IsCacheable      = MPU_ACCESS_NOT_CACHEABLE;   
    
39.     MPU_InitStruct.IsShareable      = MPU_ACCESS_NOT_SHAREABLE;
    2 l$ J. H9 H7 V) T4 T
40.     MPU_InitStruct.Number           = MPU_REGION_NUMBER1;
    / c& ~1 \( f1 j( O- A
41.     MPU_InitStruct.TypeExtField     = MPU_TEX_LEVEL0;
    3 l3 s4 r# M; q+ Q
42.     MPU_InitStruct.SubRegionDisable = 0x00;
    & Q$ N) V* I, G; y: I. A; Q
43.     MPU_InitStruct.DisableExec      = MPU_INSTRUCTION_ACCESS_ENABLE;
    
44. 
    5 A& T" N% \5 t
45.     HAL_MPU_ConfigRegion(&MPU_InitStruct);
    
46. 
    5 }) k, A* m$ \* H0 G  g/ M( ]1 T
47.     /*使能 MPU */
      q' H/ Q- S9 J0 a/ z
48.     HAL_MPU_Enable(MPU_PRIVILEGED_DEFAULT);
    * i% c$ @3 Z+ m* q
49. }
    
50. 
    : Q& N( H3 M, i# m' m* X# n
51. /*
    6 n6 A, G3 _9 F
52. *********************************************************************************************************
    1 G) y2 x! ]% G/ S; f1 E, b
53. *    函 数 名: CPU_CACHE_Enable
    
54. *    功能说明: 使能L1 Cache
    5 h/ S8 a3 D4 I0 ?  P+ X# r
55. *    形    参: 无
    
56. *    返 回 值: 无
    ! l! `0 Q- k1 ?# `2 S. E$ ^6 Y' n
57. *********************************************************************************************************
    
58. */
    0 T* [& O- s! F* K% e
59. static void CPU_CACHE_Enable(void)
    9 `$ \! C1 u0 J9 h. G- m  u
60. {
    3 C! X/ a+ M# r
61.     /* 使能 I-Cache */
    # d0 m3 C" s) N. ?4 c
62.     SCB_EnableICache();
    ( t' y! m& m: A# V
63. 
    7 K  Q9 X0 b/ j/ j
64.     /* 使能 D-Cache */
    
65.     SCB_EnableDCache();
    
66. }

复制代码

  每10ms调用一次蜂鸣器处理：
& ~1 D% c2 p4 |$ q/ U# t7 ?: O/ M% k$ ^
+ g" i  \( E5 k# c& v' ~蜂鸣器处理是在滴答定时器中断里面实现，每10ms执行一次检测。

- V9 V0 F1 I) M- ~: N3 f

1. /*
   
2. *********************************************************************************************************
   ' G: k7 \9 G0 F8 a. a; `
3. *    函 数 名: bsp_RunPer10ms
   
4. *    功能说明: 该函数每隔10ms被Systick中断调用1次。详见 bsp_timer.c的定时中断服务程序。一些处理时间要求
   
5. *              不严格的任务可以放在此函数。比如：按键扫描、蜂鸣器鸣叫控制等。
   3 Q8 V& p' v7 ^6 |
6. *    形    参: 无
   
7. *    返 回 值: 无
   " t% X7 j8 {, h' {0 s) l
8. *********************************************************************************************************
   
9. */
   
10. void bsp_RunPer10ms(void)
    
11. {
    8 [' W( t7 U! K
12.     bsp_KeyScan10ms();
    
13. }
    

复制代码

  主功能：
3 Q9 p% i/ u; _: K* |! D5 E0 i
主程序实现如下操作：
5 l0 \' }* Z8 J/ V% Z
& }% Q# N7 b2 @  启动一个自动重装软件定时器，每100ms翻转一次LED2。
( m& W4 D& f4 y6 M  K1键按下，将8bit，16bit和32bit数据写入到内部Flash。
. I: b: {9 D* ]$ V2 L; h* T  K2键按下，将结构体数据写入到内部Flash。
2 c$ d6 o- m) J# t/ E

1. /*
   
2. *********************************************************************************************************
   
3. *    函 数 名: main
   4 M5 N/ ?2 i: H# @2 u, R
4. *    功能说明: c程序入口
   1 y' y$ W% x# f, G
5. *    形    参: 无
   
6. *    返 回 值: 错误代码(无需处理)
   . Q+ J; T" U6 y) S
7. *********************************************************************************************************
   
8. */
   
9. int main(void)
   " O) ^6 }, J3 Z- o- @
10. {
    8 }8 w  d& q, N! }
11.     uint8_t ucKeyCode;    /* 按键代码 */
    ( B) E2 b2 `$ u/ i% ]+ E- m
12.     uint8_t  ucTest, *ptr8;
    5 U/ b; X8 n( c5 b9 r$ h  A
13.     uint16_t uiTest, *ptr16;
    7 U2 V0 I" B6 h/ q! v( o2 ?- S( S
14.     uint32_t ulTest, *ptr32;
    5 R1 n" w3 Y. x- v
15.     PARAM_T tPara, *paraptr;
    
16. 
    ' Y8 Z; D  T; t1 `
17. 
    
18.     /* 初始化数据 */
    / ^$ X/ |0 r: R# k2 \6 {% P
19.     tPara.Baud485 = 0x5555AAAA;
    
20.     tPara.ParamVer = 0x99;
    
21.     tPara.ucBackLight = 0x7788;
    9 V6 [/ c9 K/ F+ B% O8 F3 a
22.     tPara.ucRadioMode = 99.99f;
    
23. 
    % |5 r# Q8 q" m6 S( z+ D. p
24. 
    
25.     bsp_Init();        /* 硬件初始化 */
    
26.     PrintfLogo();    /* 打印例程名称和版本等信息 */
    * \# t) a/ L  E: v1 y6 b4 x
27.     PrintfHelp();    /* 打印操作提示 */
    / h; e. ?' M1 w
28. 
    
29.     bsp_StartAutoTimer(0, 100);    /* 启动1个100ms的自动重装的定时器 */
    + m; a) `. g# k6 h1 C) ]
30.     while (1)
    ; P. ~$ @& r- j
31.     {
    
32.         bsp_Idle();        /* 这个函数在bsp.c文件。用户可以修改这个函数实现CPU休眠和喂狗 */
    
33. 
    " k; s6 X- j. @) _6 |8 f
34.         /* 判断定时器超时时间 */
    
35.         if (bsp_CheckTimer(0))   
    
36.         {
      a7 P4 ~( C: F5 e  ^. t
37.             /* 每隔100ms 进来一次 */  
    6 k8 i! s+ e! ?$ l
38.             bsp_LedToggle(2);
    # w% G+ \8 h0 f# u8 U  r
39.         }
    ; C& s- @: l5 ?; K% F- J
40. 
    
41.         /* 按键滤波和检测由后台systick中断服务程序实现，我们只需要调用bsp_GetKey读取键值即可。 */
    
42.         ucKeyCode = bsp_GetKey();    /* 读取键值, 无键按下时返回 KEY_NONE = 0 */
    
43.         if (ucKeyCode != KEY_NONE)
    4 a6 s' e, S, {2 h
44.         {
    - U2 J( o+ s& {9 j  K
45.             switch (ucKeyCode)
    % N. v$ v, J! D4 [; t. ^. n* Y
46.             {
    
47.                 case KEY_DOWN_K1:            /* K1键按下，将8bit，16bit和32bit数据写入到内部Flash */
    4 |- f4 {5 C) F* a" m' ?5 l  ~
48. 
    4 Y5 \4 ?* U6 y# G% c: G0 ~
49.                 /*
    + o3 y$ W' p" R1 B0 ]" [
50.                  1、对于同一个地址空间，仅支持一次编程(不推荐二次编程，即使是将相应bit由数值1编程0)。
    3 |2 g. Y" q- n, N
51.                  2、只能对已经擦除的空间做编程，擦除1个扇区是128KB。
    # E8 i+ g+ I6 Q' o2 r7 o* l+ g* w
52.                  3、H7的Flash编程时，务必保证要编程的地址是32字节对齐的，即此地址对32求余为0。并且编
    ) D0 }8 H, z# r! W% \; U0 t1 s
53. 程的数据必须32字节整数倍。函数bsp_WriteCpuFlash对字节数不够32字节整数倍的情况自动补
    4 |, Q7 f& Z/ A, u, o
54. 0。
    , W5 E$ ?5 U( E% F
55.                 */
    8 a, n! `/ \6 \. i0 w
56.                      /* 擦除扇区 */
    " I% k/ X. s/ Y2 y( q# L$ Y8 b
57.                     bsp_EraseCpuFlash((uint32_t)para_flash_area);
    4 _$ K1 X# ^* l2 f9 j/ t* |
58. 
    
59.                     ucTest = 0xAA;
    
60.                     uiTest = 0x55AA;
    
61.                     ulTest = 0x11223344;
    
62. 
    ( V1 q) U; s8 Z9 @! P0 Q% q
63.                     /* 扇区写入数据 */
    9 Q+ j- K4 |9 h: I4 s
64.                     bsp_WriteCpuFlash((uint32_t)para_flash_area + 32*0,  (uint8_t *)&ucTest,
    
65. sizeof(ucTest));
    * \5 v/ V) z8 v2 t) g1 K/ p& N
66.                     bsp_WriteCpuFlash((uint32_t)para_flash_area + 32*1,  (uint8_t *)&uiTest,
    $ |  }# J1 J; j, ^3 E+ u
67. sizeof(uiTest));
    
68.                     bsp_WriteCpuFlash((uint32_t)para_flash_area + 32*2,  (uint8_t *)&ulTest,
    
69. sizeof(ulTest));               
    . G. N! `' E5 |% V4 w6 [
70. 
    
71.                     /* 读出数据并打印 */
    
72.                     ptr8  = (uint8_t  *)(para_flash_area + 32*0);
    
73.                     ptr16 = (uint16_t *)(para_flash_area + 32*1);
    ( c0 {6 A4 ^6 C% @! _! t% d
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;
    * Q" j: Q3 f, l, k& s
80. 
    & S' ~# X* L; T6 s* F
81.                 case KEY_DOWN_K2:            /* K2键按下， 将结构体数据写入到内部Flash */
    
82.                     /* 擦除扇区 */
    / z5 i0 v. n9 O
83.                     bsp_EraseCpuFlash((uint32_t)para_flash_area);
    * r* @* N! [4 j
84. 
    
85.                     /* 扇区写入数据 */
    ( C# c6 d" R( O; l) B$ w
86.                     bsp_WriteCpuFlash((uint32_t)para_flash_area,  (uint8_t *)&tPara, sizeof(tPara));            
    ( [: e7 y. o1 L4 X& p2 D% e* |
87. 
    1 I5 `6 J% i$ B7 x
88.                     /* 读出数据并打印 */
    
89.                     paraptr  = (PARAM_T  *)((uint32_t)para_flash_area);
    2 E! {  z' j/ P0 T  O
90. 
    
91. 
    6 E2 W) A  h! r/ W6 h7 T
92.                     printf("写入数据：Baud485=%x, ParamVer=%x, ucBackLight=%x, ucRadioMode=%f\r\n",
    , q3 o. z' A' {. F& p
93.                                                                        tPara.Baud485,
    + h8 S' z+ c9 y+ e1 `2 v0 |/ x# x
94.                                                                         tPara.ParamVer,
    ' U) V7 C# T$ \& J0 _
95.                                                                         tPara.ucBackLight,
    
96.                                                                    paraptr->ucRadioMode);
    1 `0 m' k# J- m& O% ~
97. 
    ; E& ~- m- A' Y: @" w" h& y  G- m
98.                     printf("读取数据：Baud485=%x, ParamVer=%x, ucBackLight=%x, ucRadioMode=%f\r\n",
    8 a( E$ V, q. M6 S
99.                                                                         paraptr->Baud485,
    5 q3 }! Y! B5 J5 O  h
100.                                                                             paraptr->ParamVer,
     
101.                                                                            paraptr->ucBackLight,
     
102.                                                                           paraptr->ucRadioMode);
     & I, M, e# \1 V/ q
103.                     break;               
     
104.                 default:
     8 A+ B! ?0 j, e2 X7 J4 M: f
105.                     /* 其它的键值不处理 */
     ( @" n: p8 b3 z$ ]1 i5 J
106.                     break;
     % H  N: e( N4 _8 `# w2 B
107.             }
     ! o3 c$ ]' @# G# e# g  d/ Y$ Y
108.         }
     
109.     }
     2 O: g1 E2 Z" ]4 f- i6 m, {8 ?. T
110. }
     

复制代码

. ~% P7 d3 Y; z1 b71.7 实验例程说明（IAR）
配套例子：
4 S) L  z5 c$ `& E
0 u+ C6 ?; x+ h! D, g" vV7-049_内部Flash模拟EEPROM
+ K2 }4 [( e# a  W3 \; ~
实验目的：

' W! ~+ s, o3 ]9 l  l学习内部Flash模拟EEPROM。
实验内容：
. d7 q3 `/ W( R/ B
使用内部Flash模拟EEPROM，务必告诉编译要使用的存储空间，防止这个空间存入了程序。
对于同一个地址空间，仅支持一次编程(不推荐二次编程，即使是将相应bit由数值1编程0)。
只能对已经擦除的空间做编程，擦除1个扇区是128KB。
H7的Flash编程时，务必保证要编程的地址是32字节对齐的，即此地址对32求余为0。
并且编程的数据必须32字节整数倍，函数bsp_WriteCpuFlash对字节数不够32字节整数倍的情况自动补0。
- P5 @/ v8 n0 E+ n: ?4 ^/ P
实验操作：

! l! H1 {1 ~- [4 j$ V2 hK1键按下，将8bit，16bit和32bit数据写入到内部Flash。
! A$ d' Z/ s% w9 V' K! T- a4 WK2键按下，将结构体数据写入到内部Flash。
1 L' H6 J3 ~& t5 \上电后串口打印的信息：

波特率 115200，数据位 8，奇偶校验位无，停止位 1。
% t, l: j0 z7 D/ q  ~$ p. a
% H2 F5 U# W( l, |' t" k( J; [

2 d" }( V3 h7 @; k程序设计：

; j0 b& Q7 U! ?9 D0 ^  系统栈大小分配：

, C2 B$ ]: H- l; {) p7 L5 k3 }" c5 t
  RAM空间用的DTCM：
7 z  P7 [: w/ w/ \; t9 A% b
$ n7 A5 R" z; l7 s

% |7 V1 H  `2 h. _; a4 u/ }9 `
  硬件外设初始化
- _4 F: r0 l# J! z3 u6 o" `" q$ z
硬件外设的初始化是在 bsp.c 文件实现：

6 Q( C: D2 \5 @- _9 l

1. /*
   
2. *********************************************************************************************************
   
3. *    函 数 名: bsp_Init
   2 n. r7 J7 f8 b  D% M9 P3 ^$ E
4. *    功能说明: 初始化所有的硬件设备。该函数配置CPU寄存器和外设的寄存器并初始化一些全局变量。只需要调用一次
   
5. *    形    参：无
     Z; C, q, Z% s6 O8 \* C- @
6. *    返 回 值: 无
   ) t5 @3 Q) X4 Q5 R6 I# M) f; D9 m
7. *********************************************************************************************************
   : \# _) o, T  J' ]) C& N: e8 J! q
8. */
   9 L" I. ]1 M9 ~" f% K: J( g
9. void bsp_Init(void)
   
10. {
    
11.     /* 配置MPU */
    4 c" P- {" J2 e% ~- |0 ?
12.     MPU_Config();
    
13. 
    
14.     /* 使能L1 Cache */
    9 I( ]  d7 L2 r0 v) M+ R3 T$ V4 O
15.     CPU_CACHE_Enable();
    1 l, S; u/ B, y1 B2 M0 ]% u6 K
16. 
    
17.     /*
    
18.        STM32H7xx HAL 库初始化，此时系统用的还是H7自带的64MHz，HSI时钟:
    
19.        - 调用函数HAL_InitTick，初始化滴答时钟中断1ms。
      _! R3 {0 H' s
20.        - 设置NVIV优先级分组为4。
    3 Z: {! l9 b8 r" t! F5 n
21.      */
    
22.     HAL_Init();
    
23. 
    
24.     /*
    
25.        配置系统时钟到400MHz
    / }5 H7 i  A7 W: {
26.        - 切换使用HSE。
    
27.        - 此函数会更新全局变量SystemCoreClock，并重新配置HAL_InitTick。
    ) j# T  z9 d! Z' n4 S/ o
28.     */
    
29.     SystemClock_Config();
    
30. 
    # T8 `& _; q1 h- X
31.     /*
    
32.        Event Recorder：
    
33.        - 可用于代码执行时间测量，MDK5.25及其以上版本才支持，IAR不支持。
    
34.        - 默认不开启，如果要使能此选项，务必看V7开发板用户手册第xx章
    : d! d. Y; Q8 h
35.     */   
    
36. #if Enable_EventRecorder == 1  
    3 E$ F" R  D0 E0 `; y
37.     /* 初始化EventRecorder并开启 */
    
38.     EventRecorderInitialize(EventRecordAll, 1U);
    
39.     EventRecorderStart();
    2 c4 N; b# m7 {3 x1 L! F2 u
40. #endif
    ' T+ z1 O9 Z: o$ [+ D4 ~, [7 u
41. 
    
42. bsp_InitDWT();      /* 初始化DWT时钟周期计数器 */      
    
43.     bsp_InitKey();        /* 按键初始化，要放在滴答定时器之前，因为按钮检测是通过滴答定时器扫描 */
    
44.     bsp_InitTimer();      /* 初始化滴答定时器 */
    2 f  F7 R; C. l. ^) }1 l; k# H/ u
45.     bsp_InitLPUart();    /* 初始化串口 */
    
46.     bsp_InitExtIO();    /* 初始化FMC总线74HC574扩展IO. 必须在 bsp_InitLed()前执行 */   
    
47.     bsp_InitLed();        /* 初始化LED */   
    
48.     bsp_InitExtSDRAM(); /* 初始化SDRAM */
    
49. }
    9 q. [$ G9 A  S5 J5 R2 f4 _

复制代码

  MPU配置和Cache配置：

4 G. _5 M7 K% ~7 g8 a0 Z数据Cache和指令Cache都开启。配置了AXI SRAM区（本例子未用到AXI SRAM）和FMC的扩展IO区。

$ f9 j/ r# G2 U& J" P

1. /*
   . f9 R* D2 H5 l/ _  S+ a$ E) p
2. *********************************************************************************************************
   
3. *    函 数 名: MPU_Config
   . q$ R' F2 m/ }2 T; O& J' @/ f* \1 j
4. *    功能说明: 配置MPU
   0 v( A5 B+ L# k$ Q
5. *    形    参: 无
   
6. *    返 回 值: 无
   
7. *********************************************************************************************************
   3 V/ T9 N" Y. t; N- e" b, M
8. */
   
9. static void MPU_Config( void )
   
10. {
    ' n: t  o5 z2 e4 D$ h  Y
11.     MPU_Region_InitTypeDef MPU_InitStruct;
    / L* d0 Q2 D& u$ ?! y& ?; X: I. X7 g1 X
12. 
    5 I4 o# `6 e3 t. H
13.     /* 禁止 MPU */
    
14.     HAL_MPU_Disable();
    . o$ ?' w. q3 p6 Y% Z2 M- W& i/ W. j
15. 
    8 x3 M& F3 A+ V
16.     /* 配置AXI SRAM的MPU属性为Write back, Read allocate，Write allocate */
    6 `% Q: t* i( ~4 P, d/ m. O
17.     MPU_InitStruct.Enable           = MPU_REGION_ENABLE;
    
18.     MPU_InitStruct.BaseAddress      = 0x24000000;
    # f% b1 b7 |. D/ z
19.     MPU_InitStruct.Size             = MPU_REGION_SIZE_512KB;
    - x" p; `1 v. V: ~
20.     MPU_InitStruct.AccessPermission = MPU_REGION_FULL_ACCESS;
    
21.     MPU_InitStruct.IsBufferable     = MPU_ACCESS_BUFFERABLE;
    
22.     MPU_InitStruct.IsCacheable      = MPU_ACCESS_CACHEABLE;
    / e5 S$ c" g1 a
23.     MPU_InitStruct.IsShareable      = MPU_ACCESS_NOT_SHAREABLE;
    . f% V3 H+ F) M, G
24.     MPU_InitStruct.Number           = MPU_REGION_NUMBER0;
    
25.     MPU_InitStruct.TypeExtField     = MPU_TEX_LEVEL1;
    
26.     MPU_InitStruct.SubRegionDisable = 0x00;
    
27.     MPU_InitStruct.DisableExec      = MPU_INSTRUCTION_ACCESS_ENABLE;
    8 y5 x# t. [, ]
28. 
    8 l9 K$ V- g+ |0 E/ Y) _
29.     HAL_MPU_ConfigRegion(&MPU_InitStruct);
    2 c8 F  `$ O; K4 }! {6 M
30. 
    
31. 
    + n$ }+ p/ Z/ I% z7 k$ ?
32.     /* 配置FMC扩展IO的MPU属性为Device或者Strongly Ordered */
    1 m$ t  k$ U8 `% V& T7 |
33.     MPU_InitStruct.Enable           = MPU_REGION_ENABLE;
    % Q  C& L5 O4 d5 q
34.     MPU_InitStruct.BaseAddress      = 0x60000000;
    
35.     MPU_InitStruct.Size             = ARM_MPU_REGION_SIZE_64KB;   
    
36.     MPU_InitStruct.AccessPermission = MPU_REGION_FULL_ACCESS;
    ' L' U: Y% O! Q& C
37.     MPU_InitStruct.IsBufferable     = MPU_ACCESS_BUFFERABLE;
    & }3 _* C4 K4 ]* A% g3 l
38.     MPU_InitStruct.IsCacheable      = MPU_ACCESS_NOT_CACHEABLE;   
    5 g2 {( b$ h/ z( S, B0 z9 y3 m
39.     MPU_InitStruct.IsShareable      = MPU_ACCESS_NOT_SHAREABLE;
    
40.     MPU_InitStruct.Number           = MPU_REGION_NUMBER1;
    ! I' O- F  P- R( W' ~6 p% C' r
41.     MPU_InitStruct.TypeExtField     = MPU_TEX_LEVEL0;
    
42.     MPU_InitStruct.SubRegionDisable = 0x00;
    
43.     MPU_InitStruct.DisableExec      = MPU_INSTRUCTION_ACCESS_ENABLE;
    + j0 z7 d, r7 q% W0 d; l) m
44. 
    
45.     HAL_MPU_ConfigRegion(&MPU_InitStruct);
    5 Q7 v, N$ {  Q% k
46. 
    
47.     /*使能 MPU */
    1 C9 U* U) t7 v, d$ b$ b) O5 k
48.     HAL_MPU_Enable(MPU_PRIVILEGED_DEFAULT);
    , _, U5 X5 W" [& {
49. }
    . q/ I$ V0 T" l
50. 
      [$ T! G. K- M4 _  \
51. /*
    ( y# ]2 m. R; D  [3 o
52. *********************************************************************************************************
    
53. *    函 数 名: CPU_CACHE_Enable
    
54. *    功能说明: 使能L1 Cache
    
55. *    形    参: 无
    
56. *    返 回 值: 无
    
57. *********************************************************************************************************
    
58. */
    - i# l! t0 \/ g, N2 }# X
59. static void CPU_CACHE_Enable(void)
    8 y: P3 }' k% }1 l2 A, v
60. {
    
61.     /* 使能 I-Cache */
    2 M  G6 L+ l6 [, P3 p
62.     SCB_EnableICache();
    
63. 
    ' `6 K) C; F/ J% l1 l! T
64.     /* 使能 D-Cache */
    
65.     SCB_EnableDCache();
    5 s5 h( {* w3 K8 x/ i4 K
66. }

复制代码

. ~4 J9 B1 R" [, m4 M
  每10ms调用一次蜂鸣器处理：

蜂鸣器处理是在滴答定时器中断里面实现，每10ms执行一次检测。
, x" V% E" P9 }9 Y# [, d- @
9 Y. i1 v  }3 d. B7 s8 j7 a& g

1. /*
   
2. *********************************************************************************************************
   2 q! I- U! c7 t6 J9 O9 R& {
3. *    函 数 名: bsp_RunPer10ms
   9 E- ]$ u% x. m1 B
4. *    功能说明: 该函数每隔10ms被Systick中断调用1次。详见 bsp_timer.c的定时中断服务程序。一些处理时间要求
   , x: @6 I3 {  Z$ R( k, P
5. *              不严格的任务可以放在此函数。比如：按键扫描、蜂鸣器鸣叫控制等。
   2 ~7 Y) ?" ~# s* L$ g' H
6. *    形    参: 无
   # _" J  c. N7 ^* X- p  C
7. *    返 回 值: 无
   & q+ l: r! x8 a2 o; @6 G7 l
8. *********************************************************************************************************
   4 P  w0 y; c2 c  ]1 w
9. */
   
10. void bsp_RunPer10ms(void)
    
11. {
    5 d4 n" z) {; ]/ [4 I  W7 P0 ^
12.     bsp_KeyScan10ms();
    ! \; i' l) q6 n2 E: j! o
13. }
    

复制代码

  主功能：
' E4 h0 T$ T' c9 K. I8 b
主程序实现如下操作：
5 j8 _+ S/ Y% {2 H$ z7 Z2 ^2 A7 w$ v
启动一个自动重装软件定时器，每100ms翻转一次LED2。
K1键按下，将8bit，16bit和32bit数据写入到内部Flash。
/ S" Z( p# L" j9 j% ^* @ K2键按下，将结构体数据写入到内部Flash。
! r+ ]& O9 u6 y! m' H$ y2 _6 f

1. /*
   
2. *********************************************************************************************************
   1 Z% c$ W( M# z7 b0 u8 Y
3. *    函 数 名: main
   7 y( D, _" r* x. d" H/ ?. J# d  N) I
4. *    功能说明: c程序入口
   & F! H& N1 I+ |+ h
5. *    形    参: 无
   
6. *    返 回 值: 错误代码(无需处理)
   # w. n# _& P0 ~9 K; t% _
7. *********************************************************************************************************
   
8. */
   
9. int main(void)
   ( \3 s$ Z0 S% [
10. {
    
11.     uint8_t ucKeyCode;    /* 按键代码 */
    
12.     uint8_t  ucTest, *ptr8;
    9 L7 H+ a5 |4 S0 V2 C6 G
13.     uint16_t uiTest, *ptr16;
    ( E3 s5 C; Z2 i
14.     uint32_t ulTest, *ptr32;
    6 |" }! E; X: p+ j* K% `
15.     PARAM_T tPara, *paraptr;
    
16. 
    ' q& |& o- r1 ^$ {* v
17. 
    ) L7 s2 E, w8 G/ Q
18.     /* 初始化数据 */
    
19.     tPara.Baud485 = 0x5555AAAA;
    
20.     tPara.ParamVer = 0x99;
    
21.     tPara.ucBackLight = 0x7788;
    3 g" x9 n' u4 d) }, X8 B( B  I
22.     tPara.ucRadioMode = 99.99f;
    / h4 L  A! @' c; f- q4 c
23. 
    % ^$ k0 k+ u& L8 F
24. 
    1 ?4 V5 f8 G* P' x
25.     bsp_Init();        /* 硬件初始化 */
    7 g+ L0 t6 j" `" K
26.     PrintfLogo();    /* 打印例程名称和版本等信息 */
    
27.     PrintfHelp();    /* 打印操作提示 */
    
28. 
    & X* D, z3 @3 ^" o" \! _1 x
29.     bsp_StartAutoTimer(0, 100);    /* 启动1个100ms的自动重装的定时器 */
    
30.     while (1)
    6 o8 _6 o# t6 P$ H) f) F
31.     {
    
32.         bsp_Idle();        /* 这个函数在bsp.c文件。用户可以修改这个函数实现CPU休眠和喂狗 */
    % f* d: E* M/ I, `0 Q* m: g
33. 
    3 c; @1 Q$ r& n4 `
34.         /* 判断定时器超时时间 */
    
35.         if (bsp_CheckTimer(0))   
    
36.         {
    
37.             /* 每隔100ms 进来一次 */  
    " x1 k1 K# F7 C! |! [1 f# z$ i
38.             bsp_LedToggle(2);
    
39.         }
    
40. 
    
41.         /* 按键滤波和检测由后台systick中断服务程序实现，我们只需要调用bsp_GetKey读取键值即可。 */
    2 v& n" d5 r9 j, v
42.         ucKeyCode = bsp_GetKey();    /* 读取键值, 无键按下时返回 KEY_NONE = 0 */
    
43.         if (ucKeyCode != KEY_NONE)
    ' y. K4 }( D/ k/ X1 X
44.         {
    1 @9 t0 Y* D9 M9 n
45.             switch (ucKeyCode)
    
46.             {
    # O" d4 l6 h+ r7 L. V% s
47.                 case KEY_DOWN_K1:            /* K1键按下，将8bit，16bit和32bit数据写入到内部Flash */
    
48. 
    
49.                 /*
    " T; D1 J5 Z9 s  m9 q; S
50.                  1、对于同一个地址空间，仅支持一次编程(不推荐二次编程，即使是将相应bit由数值1编程0)。
    
51.                  2、只能对已经擦除的空间做编程，擦除1个扇区是128KB。
    
52.                  3、H7的Flash编程时，务必保证要编程的地址是32字节对齐的，即此地址对32求余为0。并且编
      g$ }- R4 q! _! n9 P0 o
53. 程的数据必须32字节整数倍。函数bsp_WriteCpuFlash对字节数不够32字节整数倍的情况自动补
    / c. Y5 w- K6 E" r$ a
54. 0。
    . [/ U7 e6 T0 f7 a* ?7 c/ z+ L3 e% F
55.                 */
    
56.                      /* 擦除扇区 */
    
57.                     bsp_EraseCpuFlash((uint32_t)para_flash_area);
    
58. 
    ) @& }5 F/ Y* {7 Q9 e
59.                     ucTest = 0xAA;
    9 Y: S9 I5 s; R9 z# f
60.                     uiTest = 0x55AA;
    1 C' O5 K6 I# k9 C' P" K
61.                     ulTest = 0x11223344;
    
62. 
    " f' j: B  V5 S) y3 O
63.                     /* 扇区写入数据 */
    & U! u) W+ i0 Y  S" ^- U% q
64.                     bsp_WriteCpuFlash((uint32_t)para_flash_area + 32*0,  (uint8_t *)&ucTest,
    / m1 K$ B1 m8 M* z4 w
65. sizeof(ucTest));
    ( ?/ s1 J/ n3 t& Z, ]. Y
66.                     bsp_WriteCpuFlash((uint32_t)para_flash_area + 32*1,  (uint8_t *)&uiTest,
    
67. sizeof(uiTest));
    : ^0 O: r7 J" o$ Z3 ^
68.                     bsp_WriteCpuFlash((uint32_t)para_flash_area + 32*2,  (uint8_t *)&ulTest,
    / \0 m, g9 p; _* t/ E2 }4 P( O
69. sizeof(ulTest));               
    
70. 
    - G, C; l, z% K, x! ?
71.                     /* 读出数据并打印 */
    / L0 Y9 a  {' j! _
72.                     ptr8  = (uint8_t  *)(para_flash_area + 32*0);
    / a; k, h( B5 Y
73.                     ptr16 = (uint16_t *)(para_flash_area + 32*1);
    ( e& A7 V& W; ?7 m: V
74.                     ptr32 = (uint32_t *)(para_flash_area + 32*2);
    
75. 
    
76.                     printf("写入数据：ucTest = %x, uiTest = %x, ulTest = %x\r\n", ucTest, uiTest, ulTest);
    0 i0 w' t% v7 r$ {0 c) W9 ]
77.                     printf("读取数据：ptr8 = %x, ptr16 = %x, ptr32 = %x\r\n", *ptr8, *ptr16, *ptr32);
    
78. 
    
79.                     break;
    ; Q# F  I- U- \" W
80. 
    * q3 R% h5 Z$ {5 I# K
81.                 case KEY_DOWN_K2:            /* K2键按下， 将结构体数据写入到内部Flash */
    / ^: K) S3 x! i, z9 r; {4 C
82.                     /* 擦除扇区 */
    * o/ y8 w0 d" V- h& k0 ]/ @
83.                     bsp_EraseCpuFlash((uint32_t)para_flash_area);
    5 C0 B+ J2 L9 Q
84. 
    
85.                     /* 扇区写入数据 */
    
86.                     bsp_WriteCpuFlash((uint32_t)para_flash_area,  (uint8_t *)&tPara, sizeof(tPara));            
    : B9 X7 C6 Z/ _
87. 
    ; ^+ s; D' @) ]/ L* H% l! N
88.                     /* 读出数据并打印 */
    
89.                     paraptr  = (PARAM_T  *)((uint32_t)para_flash_area);
    
90. 
    
91. 
    / S8 l5 J1 n9 B* ?  g
92.                     printf("写入数据：Baud485=%x, ParamVer=%x, ucBackLight=%x, ucRadioMode=%f\r\n",
    
93.                                                                        tPara.Baud485,
    1 g0 G+ b* X( z" m: N6 ~0 `1 Z
94.                                                                         tPara.ParamVer,
    
95.                                                                         tPara.ucBackLight,
    
96.                                                                    paraptr->ucRadioMode);
    
97. 
    
98.                     printf("读取数据：Baud485=%x, ParamVer=%x, ucBackLight=%x, ucRadioMode=%f\r\n",
    
99.                                                                         paraptr->Baud485,
    + a% [" Z7 M# ^0 x
100.                                                                             paraptr->ParamVer,
     
101.                                                                            paraptr->ucBackLight,
     
102.                                                                           paraptr->ucRadioMode);
     ; E9 C. D( y6 i& B$ p8 l
103.                     break;               
     
104.                 default:
     
105.                     /* 其它的键值不处理 */
     
106.                     break;
     
107.             }
     
108.         }
     
109.     }
     ' m5 B" ]3 P# t/ F
110. }

复制代码

" P9 Z" U+ g2 s
" q; r' I/ A6 B
1 t! I  X: L& u% d( g* V8 B8 f71.8 总结
7 k; G; v8 z  F# G* E/ ~本章节就为大家讲解这么多， 实际应用中的注意事项比较多，应用到项目之前务必实际测试熟悉下。
# T1 L6 @+ d+ d. D" f0 ^( w5 `  d