71.1 初学者重要提示
4 B% J) N, I# D7 r# r6 A  学习本章节前，务必优先学习第70章。
  使用内部Flash模拟EEPROM，务必告诉编译要使用的存储空间，防止这个空间存入了程序。
  STM32H7的Flash编程时，务必保证要编程的地址是32字节对齐的，即此地址对32求余为0。并且编程的数据必须32字节整数倍。
  STM32H743XI有两个独立的BANK，一个BANK的编程和擦除操作对另一个BANK没有任何影响。但是用户应用程序和要擦写的Flash扇区在同一个BANK，在执行擦写操作时，应用应用程序将停止运行，包括中断服务程序。
5 {5 o1 V$ @, M. G  使用内部Flash模拟EEPROM要做到先擦除后使用。
* z0 ]  ]8 k7 Y: G2 ~4 q5 M71.2 模拟EEPROM驱动设计
这里重点把内部Flash的读取，编程和擦除做个说明。
9 J: {7 ?3 q( m6 R
71.2.1 内部Flash擦除的实现
内部Flash的擦除思路如下：

  第1步，获取擦除地址所处的扇区。
  第2步，调用函数HAL_FLASH_Unlock解锁。
  第3步，调用函数HAL_FLASHEx_Erase擦除一个扇区。
  第4步，调用函数HAL_FLASH_Lock上锁。
按照这个思路，程序实现如下：
, T" k& p; D# `' h( o

1. 1.    /*
   , P8 W  d; T' s( V8 p
2. 2.    ******************************************************************************************************
   
3. 3.    *    函 数 名: bsp_EraseCpuFlash
   ! c. v, S# ~! i  u
4. 4.    *    功能说明: 擦除CPU FLASH一个扇区 （128KB)
   
5. 5.    *    形    参: _ulFlashAddr : Flash地址
   
6. 6.    *    返 回 值: 0 成功， 1 失败
   5 B, N& W! L' S8 x9 |9 u7 {/ u8 d8 F
7. 7.    *              HAL_OK       = 0x00,
   ' n! s! v# _( C4 x: z
8. 8.    *              HAL_ERROR    = 0x01,
   9 d! x& S2 }7 n% y
9. 9.    *              HAL_BUSY     = 0x02,
   / F6 r( m% K0 _) C
10. 10.    *              HAL_TIMEOUT  = 0x03
    + p% A4 q3 \# ?' E
11. 11.    *
    9 r$ X& K7 O( M
12. 12.    ******************************************************************************************************
    , f' X+ K! G2 p3 c+ u! ~
13. 13.    */
    5 y% h; r) a) M; C5 h& o
14. 14.    uint8_t bsp_EraseCpuFlash(uint32_t _ulFlashAddr)
    2 ^& D  T8 ?' s4 b
15. 15.    {
    
16. 16.        uint32_t FirstSector = 0, NbOfSectors = 0;
    ( i( p3 C' b% [# [1 I3 F5 ]
17. 17.        FLASH_EraseInitTypeDef EraseInitStruct;
    
18. 18.        uint32_t SECTORError = 0;
    $ Z- s+ W& o% r5 j; \  Y" h
19. 19.        uint8_t re;
    % b; y5 j# i  f6 q0 t4 E7 m0 R
20. 20.   
    
21. 21.        /* 解锁 */
    
22. 22.        HAL_FLASH_Unlock();
    & W0 @' B* j) \( }# V$ s
23. 23.        
    , z. v7 i6 ]8 i, M6 W
24. 24.        /* 获取此地址所在的扇区 */
    6 U- N/ o& N: i! Q7 ?5 f
25. 25.        FirstSector = bsp_GetSector(_ulFlashAddr);
    
26. 26.        
    $ |1 P) @1 a0 u. @# i
27. 27.        /* 固定1个扇区 */
    - t5 `5 r0 S. a7 c9 g. ]" k  \
28. 28.        NbOfSectors = 1;   
    , a- I) |# G( ^/ H0 K' r
29. 29.   
    
30. 30.        /* 擦除扇区配置 */
    
31. 31.        EraseInitStruct.TypeErase     = FLASH_TYPEERASE_SECTORS;
    
32. 32.        EraseInitStruct.VoltageRange  = FLASH_VOLTAGE_RANGE_3;
    " s" n( s- i& Q7 e! {/ }6 ~5 U
33. 33.        
    3 _. i! m/ B. `
34. 34.        if (_ulFlashAddr >= ADDR_FLASH_SECTOR_0_BANK2)
    
35. 35.        {
    $ s1 G- @9 A+ d  ?- u
36. 36.            EraseInitStruct.Banks         = FLASH_BANK_2;
    
37. 37.        }
    
38. 38.        else
    
39. 39.        {
    2 Z5 m: Y: \; n- B7 W' M
40. 40.            EraseInitStruct.Banks         = FLASH_BANK_1;
    2 e0 `, }: C& D5 P/ ~: K
41. 41.        }
    ' \4 E0 ^6 k% K9 u1 l9 r6 U
42. 42.        
    
43. 43.        EraseInitStruct.Sector        = FirstSector;
    9 {  ?& M" a8 \. j
44. 44.        EraseInitStruct.NbSectors     = NbOfSectors;
    
45. 45.        
    
46. 46.        /* 扇区擦除 */   
    , @! S9 P( `* R4 g- l2 S! T
47. 47.        re = HAL_FLASHEx_Erase(&EraseInitStruct, &SECTORError);
    
48. 48.        
    
49. 49.        /* 擦除完毕后，上锁 */
    
50. 50.        HAL_FLASH_Lock();   
    ) o" K, u4 m  |
51. 51.        
    . \4 Z: _) _0 _
52. 52.        return re;
    ; W; x  @6 v) F4 g
53. 53.    }

复制代码

3 @  I- V' M' U: \2 a4 V  N8 j
这里将此程序设计的关键点为大家做个说明：

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

1. /*
   
2. *********************************************************************************************************
   3 f$ [* D0 _/ b
3. *    函 数 名: bsp_GetSector
   9 R% S$ R2 o$ B% T- v6 h: J
4. *    功能说明: 根据地址计算扇区首地址
   / G' W" O) b# h( u7 A
5. *    形    参: 无
   
6. *    返 回 值: 扇区号（0-7)
   ( r- l# y; g  S7 _# \6 r8 n
7. *********************************************************************************************************
   6 j! q8 l9 x7 a* L. }) m+ ~
8. */
   ) J* A# A6 ^7 R0 f/ n+ d0 }
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)) || \
    
14.         ((Address < ADDR_FLASH_SECTOR_1_BANK2) && (Address >= ADDR_FLASH_SECTOR_0_BANK2)))   
    . F3 o8 o5 R( M1 f, O5 H8 q
15.     {
    
16.         sector = FLASH_SECTOR_0;  
    
17.     }
    
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)))   
    
20.     {
    
21.         sector = FLASH_SECTOR_1;  
    % K' ^3 A4 N& c) f( C: c, L. {
22.     }
      S* I& ]' w; g% E" q! ?; c2 p
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)))   
    
25.     {
    . D& J' a) [% ]. R! }6 i
26.         sector = FLASH_SECTOR_2;  
    + i$ x* [2 P3 B5 Z
27.     }
    
28.     else if (((Address < ADDR_FLASH_SECTOR_4_BANK1) && (Address >= ADDR_FLASH_SECTOR_3_BANK1)) || \
    6 m/ W; ?! z& K/ o; {) @9 ~6 B
29.       ((Address < ADDR_FLASH_SECTOR_4_BANK2) && (Address >= ADDR_FLASH_SECTOR_3_BANK2)))   
    : i( M% Z! }/ \' x, N7 g
30.     {
    6 G1 ]# s: d/ y2 u% Q: J' k7 M+ T
31.         sector = FLASH_SECTOR_3;  
    
32.     }
    
33.     else if (((Address < ADDR_FLASH_SECTOR_5_BANK1) && (Address >= ADDR_FLASH_SECTOR_4_BANK1)) || \
    ! N- H$ F6 v9 m' S
34.       ((Address < ADDR_FLASH_SECTOR_5_BANK2) && (Address >= ADDR_FLASH_SECTOR_4_BANK2)))   
    
35.     {
    
36.         sector = FLASH_SECTOR_4;  
    & c+ I# N) ~, u) A
37.     }
    
38.     else if (((Address < ADDR_FLASH_SECTOR_6_BANK1) && (Address >= ADDR_FLASH_SECTOR_5_BANK1)) || \
    4 J3 @! |( s& o, v! c& u
39.       ((Address < ADDR_FLASH_SECTOR_6_BANK2) && (Address >= ADDR_FLASH_SECTOR_5_BANK2)))   
    ) L8 |$ P3 x' L  F) E- N
40.     {
    9 e. k  u7 o1 H( f; l' c% E
41.         sector = FLASH_SECTOR_5;  
    
42.     }
    ! ]* |8 n( H) h+ C0 ?
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)))   
    ' n$ ?( A6 `+ D
45.     {
    
46.         sector = FLASH_SECTOR_6;  
    - S% \1 w; h+ X
47.     }
    ( x' U5 C$ J' E% u8 ?. x3 H
48.     else if (((Address < ADDR_FLASH_SECTOR_0_BANK2) && (Address >= ADDR_FLASH_SECTOR_7_BANK1)) || \
    2 j4 }3 }" [" `3 i+ X( l& Y
49.       ((Address < CPU_FLASH_END_ADDR) && (Address >= ADDR_FLASH_SECTOR_7_BANK2)))
    
50.     {
    
51.         sector = FLASH_SECTOR_7;  
    + J5 ]- w+ B' K* H7 b0 u/ p
52.     }
    
53.     else
    
54.     {
    
55.         sector = FLASH_SECTOR_7;
    ( l5 _+ `: A2 P+ T" i& b
56.     }
    $ W; Y2 I: S7 s& L) Y; k
57. 
    
58.     return sector;
    
59. }
    ! V6 |. J! O) V7 K9 F  f- b

复制代码

2 n% [* e# C; G0 Y9 r
7 p4 U- T+ y( z( l, _9 Q由于STM32H7的BANK1和BANK2是独立的，都有8个扇区，所以程序里面只需返回要擦除地址所处的扇区号即可。
( [2 r6 p5 V, R6 K  S7 t
- o6 g5 l& ?) a1 |, e  第47行的擦除函数HAL_FLASHEx_Erase在第70章的4.4小节有说明。
; c4 _& b" d) i% g3 D% K; K# M1 _6 ~71.2.2 内部Flash编程的实现
5 D3 B$ q) U1 n# U, X5 L) Q, a内部Flash的编程思路如下：

( O5 X) h6 u. E9 O+ f  第1步，判断是否要编写数据进去，如果数据已经在内部Flash里面。
1 [, s) P1 _2 \/ Z) m7 M  第2步，调用函数HAL_FLASH_Unlock解锁。
7 Q/ |1 g1 h) W0 [5 B3 S  第3步，调用函数HAL_FLASH_Program对内部Flash编程数据。
  第4步，调用函数HAL_FLASH_Lock上锁。
6 Q6 P! W% Z* e按照这个思路，程序实现如下：

  {' _- p' S7 k! h  k% c

1. 1.    /*
   
2. 2.    ******************************************************************************************************
   # Y6 Z& ?: `  J
3. 3.    *    函 数 名: bsp_WriteCpuFlash
   
4. 4.    *    功能说明: 写数据到CPU 内部Flash。 必须按32字节整数倍写。不支持跨扇区。扇区大小128KB. \
   
5. 5.    *              写之前需要擦除扇区. 长度不是32字节整数倍时，最后几个字节末尾补0写入.
   
6. 6.    *    形    参: _ulFlashAddr : Flash地址
   1 ~$ C6 f' M/ e7 R0 F+ q- S( R
7. 7.    *             _ucpSrc : 数据缓冲区
   2 `4 Q; B: `! v( ]' d$ D( }5 o( A
8. 8.    *             _ulSize : 数据大小（单位是字节, 必须是32字节整数倍）
   ' n$ X: l+ A  Q
9. 9.    *    返 回 值: 0-成功，1-数据长度或地址溢出，2-写Flash出错(估计Flash寿命到)
   % ]5 x) G) T& G& `
10. 10.    ******************************************************************************************************
    # _4 o; X+ i2 g% ^7 G8 Q" a; ^
11. 11.    */
    
12. 12.    uint8_t bsp_WriteCpuFlash(uint32_t _ulFlashAddr, uint8_t *_ucpSrc, uint32_t _ulSize)
    8 d3 Y/ @. Y( Q0 I
13. 13.    {
    8 Y& N" g$ z9 [( y$ G5 v
14. 14.        uint32_t i;
    
15. 15.        uint8_t ucRet;
    
16. 16.   
    
17. 17.        /* 如果偏移地址超过芯片容量，则不改写输出缓冲区 */
    
18. 18.        if (_ulFlashAddr + _ulSize > CPU_FLASH_BASE_ADDR + CPU_FLASH_SIZE)
    
19. 19.        {
    . A6 c/ D+ Z- Z. b& O6 _* B
20. 20.            return 1;
    
21. 21.        }
    / l3 k% N; I" p) M
22. 22.   
    
23. 23.        /* 长度为0时不继续操作  */
    
24. 24.        if (_ulSize == 0)
    
25. 25.        {
    ' Q' P7 G! ]# f4 `& n! I
26. 26.            return 0;
    0 _1 m2 A: ~  h5 z& z5 W( j# U1 S+ [
27. 27.        }
    
28. 28.   
    ) z7 `8 h0 k: x
29. 29.        ucRet = bsp_CmpCpuFlash(_ulFlashAddr, _ucpSrc, _ulSize);
    * V& U2 _! u6 n/ o* _( j& q5 `0 I
30. 30.   
    ' |3 L  @: ]6 T0 n! q* m1 A- j
31. 31.        if (ucRet == FLASH_IS_EQU)
    
32. 32.        {
    ) J! \. q; p6 {* y3 R
33. 33.            return 0;
    
34. 34.        }
      h4 x& f, ], v' Z
35. 35.   
    9 }) G' U. X. }3 Z. `2 W3 U+ w$ J
36. 36.        __set_PRIMASK(1);          /* 关中断 */
    
37. 37.   
    2 I! S. ^5 Q8 A; q7 j
38. 38.        /* FLASH 解锁 */
    7 J& o* L9 a2 e7 m( g- p7 n" b/ l
39. 39.        HAL_FLASH_Unlock();
    
40. 40.   
    
41. 41.        for (i = 0; i < _ulSize / 32; i++)   
    * X2 I, i3 U, i) a1 }7 a3 w  p$ Y
42. 42.        {
    0 e8 h- ]" R. r5 p; F
43. 43.            uint64_t FlashWord[4];
    
44. 44.            
    % p+ E9 P# v) F: b; C7 l5 B
45. 45.            memcpy((char *)FlashWord, _ucpSrc, 32);
    
46. 46.            _ucpSrc += 32;
    , J8 Q7 w6 f# T& t
47. 47.            
    * }# y& H5 c3 `% i
48. 48.            if (HAL_FLASH_Program(FLASH_TYPEPROGRAM_FLASHWORD, _ulFlashAddr,
    
49. 49.                                      (uint64_t)((uint32_t)FlashWord)) == HAL_OK)
    + B; u# P# Q% a6 B) X
50. 50.            {
    
51. 51.                _ulFlashAddr = _ulFlashAddr + 32; /* 递增，操作下一个256bit */               
    
52. 52.            }        
    3 z& q5 g5 s! B+ N) U# K7 @% e# v
53. 53.            else
    1 Y1 ~: o* T( l' j
54. 54.            {
    & W) h; R1 o+ e; E
55. 55.                goto err;
    
56. 56.            }
    
57. 57.        }
    $ B, Q" X4 Q6 I5 ~
58. 58.        
    
59. 59.        /* 长度不是32字节整数倍 */
    
60. 60.        if (_ulSize % 32)
    ' X" w; y& S+ \% }% q* I. Y
61. 61.        {
    " L' k1 W# s& j9 q
62. 62.            uint64_t FlashWord[4];
    + O( ]* p" X3 H& u
63. 63.            
    $ x2 O$ J- m7 d$ `/ @9 @* d. l
64. 64.            FlashWord[0] = 0;
    
65. 65.            FlashWord[1] = 0;
    
66. 66.            FlashWord[2] = 0;
    
67. 67.            FlashWord[3] = 0;
    
68. 68.            memcpy((char *)FlashWord, _ucpSrc, _ulSize % 32);
    ; d) j) |  x8 f4 ]
69. 69.            if (HAL_FLASH_Program(FLASH_TYPEPROGRAM_FLASHWORD, _ulFlashAddr,
    
70. 70.                                               (uint64_t)((uint32_t)FlashWord)) == HAL_OK)
    
71. 71.            {
    
72. 72.                ; // _ulFlashAddr = _ulFlashAddr + 32;
    
73. 73.               
    & C, z. h8 q- o9 j4 s6 e0 R) v4 f
74. 74.            }        
    
75. 75.            else
    " s" a5 N; E$ h& U/ m8 g, V0 g' @# j; Q7 F
76. 76.            {
    6 b) M4 l3 r6 L) V/ s$ s* {% b% U
77. 77.                goto err;
    # J( R, o2 ^) l, [: ^/ K3 Q
78. 78.            }
    4 P& J6 i% `5 U8 B8 P6 |9 Y' K  B
79. 79.        }
    $ j2 V2 J9 c. B' K
80. 80.        
    % G9 l& L% L5 z1 {, J0 N9 R. H
81. 81.          /* Flash 加锁，禁止写Flash控制寄存器 */
    / i% Z) B6 k8 l; U" j* J# d
82. 82.          HAL_FLASH_Lock();
    % ~* O- z  x4 y4 _4 D0 v: W( L/ {
83. 83.   
    ( ?5 z8 I* u5 s7 f- {
84. 84.          __set_PRIMASK(0);          /* 开中断 */
    0 L7 V* V/ T) ?
85. 85.   
    8 F% i3 s$ Q1 @: b2 k: @" p
86. 86.        return 0;
    $ @' |7 x1 r: ~) Q
87. 87.        
    " W; x4 I5 B  ^; f2 g2 b
88. 88.    err:
      }- ?% a8 [* O+ S- {
89. 89.          /* Flash 加锁，禁止写Flash控制寄存器 */
    
90. 90.          HAL_FLASH_Lock();
    
91. 91.   
    & N( ]3 f" @; H% q
92. 92.          __set_PRIMASK(0);          /* 开中断 */
    2 l  v9 y9 M" I$ O& U
93. 93.   
    7 t4 V. e( w& P2 ^. V
94. 94.        return 1;
    
95. 95.    }
    4 R) e9 R/ g3 Q$ g

复制代码

关于此函数有几个要点：
, X, V- V; ?/ z" f* _" f
% I) [3 e& I# x8 Z7 [  第1个参数必须32字节对齐，即要编程的Flash地址对32求余为0。
% d( \4 ~2 y# u; f  第3个参数必须是32字节的整数倍，长度不是32字节整数倍时，最后几个字节补0写入。
  第29行，函数bsp_CmpCpuFlash放在这里只有一个作用，判断将要写入的数据是否已经在内部Flash存在，如果已经存在，无需重复写入，直接返回。
% V+ @& }: P, i  t* I! F6 w) U6 w  第36行，做了一个关中断操作，这里有个知识点要给大家普及下，由于H7的BANK1和BANK2是独立的，当前正在擦除的扇区所处的BANK会停止所有在此BANK执行的程序，包含中断也会停止执行。比如当前的应用程序都在BANK1，如果要擦除或者编程BANK2，是不会不影响BANK1里面执行的程序。这里安全起见加上了开关中断。
4 O" |6 G+ Z4 Q8 }- Z  第41到57行，先将32字节整数倍的数据通过函数HAL_FLASH_Program编程，此函数每次可以固定编程32字节数据。
5 l( N5 D5 M  y- Y8 }2 l; A9 Y  第60到79行，将剩余不足32字节的数据补0，凑齐32字节编程。
71.2.3 内部Flash读取的实现
内部Flash数据读取比较简单，采用总线方式读取，跟访问内部RAM是一样的。比如要读取地址

- L. z2 H1 J$ o% |4 p0x08100000里面的一个32bit变量，我们就可以：
! `) n+ `! V0 w
变量 = *(uint32_t *)(0x08100000)
. N  T  r# ~7 E
为了方便起见，也专门准备了一个函数：
) v1 U$ I# H0 d/ M

1. /*
   & _2 h4 z- {6 ~- W- t1 s6 D
2. *********************************************************************************************************
   . ~) ~) u; L9 j) W
3. *    函 数 名: bsp_ReadCpuFlash
   
4. *    功能说明: 读取CPU Flash的内容
   ; S, b* n% n& j- {4 c
5. *    形    参:  _ucpDst : 目标缓冲区
   
6. *             _ulFlashAddr : 起始地址
   ; D4 U$ J! t6 c9 g8 ~$ }
7. *             _ulSize : 数据大小（单位是字节）
   
8. *    返 回 值: 0=成功，1=失败
   " i1 z  [& `! C, i% k1 {( C
9. *********************************************************************************************************
   
10. */
    
11. uint8_t bsp_ReadCpuFlash(uint32_t _ulFlashAddr, uint8_t *_ucpDst, uint32_t _ulSize)
    
12. {
    2 u( C/ M! y! X! X# B
13.     uint32_t i;
    
14. 
    9 \8 b, q/ Y. B' l( i) p; |. z4 T8 ~
15.     if (_ulFlashAddr + _ulSize > CPU_FLASH_BASE_ADDR + CPU_FLASH_SIZE)
    
16.     {
    ! I2 s! K9 G- i: a/ z6 i' a7 s  p+ J
17.         return 1;
    
18.     }
    " q+ q6 ^+ d0 k
19. 
    2 @& b- b9 m; Y3 t
20.     /* 长度为0时不继续操作,否则起始地址为奇地址会出错 */
    
21.     if (_ulSize == 0)
    
22.     {
    
23.         return 1;
    , X5 U& w9 Y/ J  r7 L6 k
24.     }
    
25. 
    0 b3 O9 i& w0 @( I0 g3 P
26.     for (i = 0; i < _ulSize; i++)
    
27.     {
    
28.         *_ucpDst++ = *(uint8_t *)_ulFlashAddr++;
    
29.     }
    
30. 
      x' |# f& C3 `7 G  Y! V
31.     return 0;
    ) f1 o) K8 @$ t+ L, G* I
32. }
    

复制代码

% A% y- o5 z# `2 c8 b4 l71.2.4 告诉编译器使用的扇区（重要）
使用内部Flash模拟EEPROM切不可随意定义一个扇区使用。因为编译器并不知道用户使用了这个扇区，导致应用程序也会编程到此扇区里面，所以就需要告诉编译器。
2 B1 X4 t0 z" O2 ]* d1 q2 B
告诉MDK的方法如下（0x0810 0000是H7的BANK2首地址）：
  @7 Y5 \+ q/ I! U8 p/ S
; A5 A& ^& e. m% ?3 N

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

复制代码

4 F3 h: e3 _/ ]2 x4 E- B0 K告诉IAR的方法如下：
/ `  v- N+ J# [! |, N

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

复制代码

4 Y& w- E- h" s1 F" P这里有两点特别注意：

  模拟EEPROM的扇区可以定义到从第2个扇区开始的任何扇区，但不可以定义到首扇区，因为这个扇区是默认的boot启动地址。
  如果应用程序不大的话，不推荐定义到末尾扇区，以MDK为例，定义到末尾扇区后，会导致整个Flash空间都被使用，从而让程序下载下载时间变长。
71.3 模拟EEPROM板级支持包（bsp_cpu_flash.c）
" B; i7 B1 `9 p8 Y模拟EEPROM的驱动文件bsp_cpu_flash.c主要实现了如下几个API供用户调用：
; B( `/ H# F3 ^
  bsp_GetSector
  bsp_ReadCpuFlash
  bsp_CmpCpuFlash
  bsp_EraseCpuFlash
  bsp_WriteCpuFlash
71.3.1 函数bsp_GetSector
函数原型：

1. uint32_t bsp_GetSector(uint32_t Address)

复制代码

. j5 |4 D8 g+ V% ?+ c  K  n0 v函数描述：
% q$ i3 g) b% N# Q( G
9 S/ E; k+ d6 t2 E% e2 c  p( h0 s  N) j此函数主要用于获取给定地址所处的扇区。

# d% [5 y- {5 A8 `- G函数参数：

6 |% V& l, N4 t  第1个参数是用户给定的地址。
  返回值，范围FLASH_SECTOR_0到FLASH_SECTOR_7。
7 m# R1 ]1 @; @( O+ F7 E* H0 z71.3.2 函数bsp_ReadCpuFlash
* f; d' c/ R: x函数原型：
0 E+ r- d) ~- b, t( y  P
' s( U" n+ Z  d- ~, l6 P

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

复制代码

函数描述：

此函数用于从内部Flash读取数据
' b- j2 J# ~! f; g4 @! t
7 V; N! w+ C. ^& R, c函数参数：
# N+ R/ Q2 ], d) @( n
% I5 x$ M- e! a0 {: @  第1个参数读取的起始地址。
3 ^9 u; s' b, p5 Q* z6 ^  第2个参数是读取数据的存储地址
  第3个参数是读取数据的大小，单位字节。
+ a' e6 y8 ?  G, }+ _1 ?  返回值，0表示成功，1表示失败。
71.3.3 函数bsp_CmpCpuFlash
函数原型：
0 f8 p* q$ ], b* @7 D" t
uint8_t bsp_CmpCpuFlash(uint32_t _ulFlashAddr, uint8_t *_ucpBuf, uint32_t _ulSize)
9 `9 J. `! Z8 ?
; m  \. v& C( w5 R  B$ P& u函数描述：

要编程的数据是否在内部Flash已经存在。
$ @) Y: S: `% l$ M9 p" J
函数参数：
. C/ s/ z0 L2 C6 Q) s
  第1个参数是内部Flash地址。
  第2个参数是缓冲区地址。
) a- w3 Q7 h2 l" {. m  第3个参数是数据大小，单位字节。
9 F1 p  L4 T3 U# Y6 G: r- w6 y  返回值：
: i5 z5 r. f5 F6 a7 |2 zFLASH_IS_EQU               0   Flash内容和待写入的数据相等，不需要擦除和写操作。
* D: m( Z, v5 [. j5 `' U
9 `; d5 K8 k2 Z6 p5 R) AFLASH_REQ_WRITE          1     Flash不需要擦除，直接写。
" v6 E' P9 O, e9 p& A0 j
FLASH_REQ_ERASE          2     Flash需要先擦除,再写。
- U; n1 F9 ~7 E3 D& R
FLASH_PARAM_ERR         3     函数参数错误。

7 M8 w1 z! S0 {5 N3 i) m71.3.4 函数bsp_EraseCpuFlash
3 X: I& `; U& y$ |- j; \& B函数原型：
! ]( A3 j& o( m" h7 k
$ g  y$ B( {! p% h4 n" nuint8_t bsp_EraseCpuFlash(uint32_t _ulFlashAddr)
) Y9 T7 \; n  z. Y
函数描述：
* u  O+ x- u  k# j
此函数用于擦除一个扇区，大小128KB

7 S0 v/ b, \$ `- [函数参数：

2 X2 M  {4 ]$ s" p/ l/ |  第1个参数要擦除的扇区地址，可以是此扇区范围内的任意值，一般填扇区首地址即可。
) y9 x! m% u8 w% p: W( w. N  返回值：
9 y; R! q; N: y# v1 Y/ lHAL_OK        = 0x00

$ ~, |- Q: b7 ~HAL_ERROR    = 0x01

HAL_BUSY      = 0x02

HAL_TIMEOUT  = 0x03

/ E% Y* \' m: T0 r) P/ b71.3.5 函数bsp_WriteCpuFlash
函数原型：
/ f  G& T* k! g5 v( h+ [$ c6 `
uint8_t bsp_WriteCpuFlash(uint32_t _ulFlashAddr, uint8_t *_ucpSrc, uint32_t _ulSize)

函数描述：

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

( S. C% _+ \& h3 l函数参数：
- y% [# ~! N7 {( X
  第1个参数是要编程的内部Flash地址。
2 Q& c# x! N* x; m  第2个参数是数据缓冲区地址。
- z! h( \& D" E# o* _  第3个参数是数据大小，单位字节。
  返回值，0-成功，1-数据长度或地址溢出，2-写Flash出错(估计Flash寿命到)。
% _& {! p. W- l8 k* v4 H: ^; Z1 W注意事项：

  第1个参数必须32字节对齐，即要编程的Flash地址对32求余为0。
+ e- P7 G" X2 r+ i  第3个参数必须是32字节的整数倍，长度不是32字节整数倍时，此函数会将几个字节补0写入
71.4 模拟EEPROM驱动移植和使用
模拟EEPROM移植步骤如下：
& @' m5 g6 J3 o) v
+ a: i' |  c6 i! L4 D  第1步：复制bsp_cpu_flash.c和bsp_cpu_flash.h到自己的工程目录，并添加到工程里面。
0 x3 |  P3 F7 @- a$ A. \2 W3 M  第2步：Flash驱动文件主要用到HAL库的Flash驱动文件，简单省事些可以添加所有HAL库C源文件进来。
# L& p3 g3 u. E  第3步，应用方法看本章节配套例子即可。
: j" N5 i9 Y) u* P5 U' F71.5 实验例程设计框架
通过程序设计框架，让大家先对配套例程有一个全面的认识，然后再理解细节，本次实验例程的设计框架如下：
0 B- {7 i1 M$ X8 j

. H4 m% w& m! j% [0 ?4 ?8 W( l1 R
0 D3 w/ @/ ?$ n# ]: F- `/ o  第1阶段，上电启动阶段：

6 x7 b) F* K& O+ q) H0 {这部分在第14章进行了详细说明。
  第2阶段，进入main函数：
) n% `* k/ ]9 b) x5 B7 c
  第1部分，硬件初始化，主要是MPU，Cache，HAL库，系统时钟，滴答定时器和LED。
8 ^- C7 ~! C+ l% Y' [, Z" v  第2部分，应用程序设计部分，实现内部Flash模拟EEPROM。
6 A. K. D+ ^; a71.6 实验例程说明（MDK）
2 U! G- o( H8 S配套例子：
" b7 ^6 z% c! e
V7-049_内部Flash模拟EEPROM

实验目的：

学习内部Flash模拟EEPROM。
8 A  ?) X1 X4 E/ r% u实验内容：
4 I/ f/ k% {6 d; U5 d/ C- E' `
使用内部Flash模拟EEPROM，务必告诉编译要使用的存储空间，防止这个空间存入了程序。
; y  }( z( `8 M+ a" p对于同一个地址空间，仅支持一次编程(不推荐二次编程，即使是将相应bit由数值1编程0)。
只能对已经擦除的空间做编程，擦除1个扇区是128KB。
0 J+ Z: a* m! m3 MH7的Flash编程时，务必保证要编程的地址是32字节对齐的，即此地址对32求余为0。
并且编程的数据必须32字节整数倍，函数bsp_WriteCpuFlash对字节数不够32字节整数倍的情况自动补0。

; v' ^1 n8 d5 [, |3 S/ f实验操作：

' p5 f$ w/ v  F- u( LK1键按下，将8bit，16bit和32bit数据写入到内部Flash。
K2键按下，将结构体数据写入到内部Flash。
上电后串口打印的信息：

波特率 115200，数据位 8，奇偶校验位无，停止位 1。
8 @9 |' k" M" Y

9 h0 f. X, y( W" r' _) ~
程序设计：
& O4 ~) k+ A5 Q- Z, P
  系统栈大小分配：

4 H+ ~( d" x# n( _% P0 ~1 [3 T

  \  {: X0 ^* U/ n8 g& G4 _: T/ m: ]
  RAM空间用的DTCM：
: m# k. H& A4 U& d

+ Q6 o$ H( p% P% _: `
  硬件外设初始化
8 f" @! j6 _: p' b; r8 T
1 q7 X$ r0 ~& Y% q  x+ \硬件外设的初始化是在 bsp.c 文件实现：

1. /*
   
2. *********************************************************************************************************
   6 S7 b) R1 N4 C3 @$ ?
3. *    函 数 名: bsp_Init
   
4. *    功能说明: 初始化所有的硬件设备。该函数配置CPU寄存器和外设的寄存器并初始化一些全局变量。只需要调用一次
   
5. *    形    参：无
   - X, G( ]( ]% e8 F2 r6 \( @
6. *    返 回 值: 无
   
7. *********************************************************************************************************
   5 W5 g  H$ @) ?' y' f$ W+ L
8. */
   
9. void bsp_Init(void)
   
10. {
    
11.     /* 配置MPU */
    8 V4 o/ z  n9 {& M0 X+ o
12.     MPU_Config();
    ' v0 K- O) Y0 w8 O0 u7 r
13. 
    ' ^. K& q8 i4 w
14.     /* 使能L1 Cache */
    $ U! S# E+ o6 f3 h0 ?, q8 T8 N- ?3 `
15.     CPU_CACHE_Enable();
    7 L8 ^, ~9 R# H, o3 U9 m
16. 
    . C+ S% w, c# g5 U5 z
17.     /*
    
18.        STM32H7xx HAL 库初始化，此时系统用的还是H7自带的64MHz，HSI时钟:
    
19.        - 调用函数HAL_InitTick，初始化滴答时钟中断1ms。
    
20.        - 设置NVIV优先级分组为4。
    
21.      */
    
22.     HAL_Init();
    7 J! [) o* P+ w' e9 }7 G* s% q
23. 
    
24.     /*
    
25.        配置系统时钟到400MHz
    4 z- T8 R6 C# O; v# r+ u
26.        - 切换使用HSE。
    3 u' a9 ~( U( ^5 o7 \+ l
27.        - 此函数会更新全局变量SystemCoreClock，并重新配置HAL_InitTick。
    
28.     */
    & o/ ^0 f7 U9 \  Y* I% j
29.     SystemClock_Config();
    
30. 
    
31.     /*
    ; y2 s) I) A* @3 s' q
32.        Event Recorder：
    % R1 r1 l1 q; W
33.        - 可用于代码执行时间测量，MDK5.25及其以上版本才支持，IAR不支持。
    
34.        - 默认不开启，如果要使能此选项，务必看V7开发板用户手册第xx章
    9 y1 l% I% O+ c( U
35.     */   
    
36. #if Enable_EventRecorder == 1  
    ' f% E% W" W( O
37.     /* 初始化EventRecorder并开启 */
    
38.     EventRecorderInitialize(EventRecordAll, 1U);
    . Y) u- ?, p5 t$ f! C! G) y
39.     EventRecorderStart();
    + P$ h# H( l! y: k+ h
40. #endif
    
41. 
    1 W4 [  c3 Q0 E- A8 `* g
42. bsp_InitDWT();      /* 初始化DWT时钟周期计数器 */      
    4 b& b% f  ?7 C0 v
43.     bsp_InitKey();        /* 按键初始化，要放在滴答定时器之前，因为按钮检测是通过滴答定时器扫描 */
    
44.     bsp_InitTimer();      /* 初始化滴答定时器 */
    
45.     bsp_InitLPUart();    /* 初始化串口 */
    
46.     bsp_InitExtIO();    /* 初始化FMC总线74HC574扩展IO. 必须在 bsp_InitLed()前执行 */   
    
47.     bsp_InitLed();        /* 初始化LED */   
    
48.     bsp_InitExtSDRAM(); /* 初始化SDRAM */
    ; |+ Q0 D" M  s; I: x2 F/ _
49. }
    ( k& _5 R( X. l9 T" `# q

复制代码

( s: N, ?' S/ O3 U/ P7 B: K
  MPU配置和Cache配置：

数据Cache和指令Cache都开启。配置了AXI SRAM区（本例子未用到AXI SRAM）和FMC的扩展IO区。

: G. W8 |# J* Q% _& \: M0 P$ [

1. /*
   
2. *********************************************************************************************************
   5 \- K/ ]/ D/ s% q
3. *    函 数 名: MPU_Config
   . U. R7 L6 S& j* i
4. *    功能说明: 配置MPU
   3 i$ p8 A! D7 |. b$ \* U+ [
5. *    形    参: 无
   ) t0 v4 x! S2 o/ C
6. *    返 回 值: 无
   " d# n  c. V" `. o# [" g
7. *********************************************************************************************************
   
8. */
   
9. static void MPU_Config( void )
   
10. {
    ( v# m; y3 E  G
11.     MPU_Region_InitTypeDef MPU_InitStruct;
    
12. 
    
13.     /* 禁止 MPU */
    & ]( V3 r- J3 h8 D% n. z2 t# i" w
14.     HAL_MPU_Disable();
    
15. 
    * e% w) |3 R* ]4 G  \
16.     /* 配置AXI SRAM的MPU属性为Write back, Read allocate，Write allocate */
    
17.     MPU_InitStruct.Enable           = MPU_REGION_ENABLE;
    
18.     MPU_InitStruct.BaseAddress      = 0x24000000;
    + V! m- K/ Z1 b" J
19.     MPU_InitStruct.Size             = MPU_REGION_SIZE_512KB;
    
20.     MPU_InitStruct.AccessPermission = MPU_REGION_FULL_ACCESS;
    0 w8 ~) M: [% S& A% l$ e' K4 y: i4 @" t- }
21.     MPU_InitStruct.IsBufferable     = MPU_ACCESS_BUFFERABLE;
    
22.     MPU_InitStruct.IsCacheable      = MPU_ACCESS_CACHEABLE;
    0 d3 C( K& q; A4 @& R5 j' a, F
23.     MPU_InitStruct.IsShareable      = MPU_ACCESS_NOT_SHAREABLE;
    . C9 ~- f' s! G3 d
24.     MPU_InitStruct.Number           = MPU_REGION_NUMBER0;
    
25.     MPU_InitStruct.TypeExtField     = MPU_TEX_LEVEL1;
    ; v3 C6 H+ L% k
26.     MPU_InitStruct.SubRegionDisable = 0x00;
    7 v9 N2 A7 G/ N' N! U" g4 B
27.     MPU_InitStruct.DisableExec      = MPU_INSTRUCTION_ACCESS_ENABLE;
    
28. 
    $ I/ P9 u) ^0 q- p0 K0 k  m
29.     HAL_MPU_ConfigRegion(&MPU_InitStruct);
    1 h# g  \; W2 I2 H$ l
30. 
    + h5 f7 w+ v9 |  K1 e9 h
31. 
    
32.     /* 配置FMC扩展IO的MPU属性为Device或者Strongly Ordered */
    1 h2 T/ ?' q3 c
33.     MPU_InitStruct.Enable           = MPU_REGION_ENABLE;
    
34.     MPU_InitStruct.BaseAddress      = 0x60000000;
    
35.     MPU_InitStruct.Size             = ARM_MPU_REGION_SIZE_64KB;   
    ! G; `9 ^- i# O  `7 W  m
36.     MPU_InitStruct.AccessPermission = MPU_REGION_FULL_ACCESS;
    $ B9 ^; r  [+ L' ?
37.     MPU_InitStruct.IsBufferable     = MPU_ACCESS_BUFFERABLE;
    2 N& b. {2 t& `, E( V: _9 B
38.     MPU_InitStruct.IsCacheable      = MPU_ACCESS_NOT_CACHEABLE;   
    
39.     MPU_InitStruct.IsShareable      = MPU_ACCESS_NOT_SHAREABLE;
    1 O2 O2 V  E/ m1 a" S! r. h- p. F
40.     MPU_InitStruct.Number           = MPU_REGION_NUMBER1;
    * `& n) R5 \8 s. r. ^
41.     MPU_InitStruct.TypeExtField     = MPU_TEX_LEVEL0;
    & u1 J& B6 F% b; X0 \( \8 b9 J
42.     MPU_InitStruct.SubRegionDisable = 0x00;
    " r/ I! D: b. S% q5 Q3 s% G
43.     MPU_InitStruct.DisableExec      = MPU_INSTRUCTION_ACCESS_ENABLE;
    
44. 
    
45.     HAL_MPU_ConfigRegion(&MPU_InitStruct);
    1 h: t" n2 D8 }# O! q
46. 
    7 b5 x0 U4 b3 T1 Z$ w
47.     /*使能 MPU */
    ) f; Z9 f: z% j6 V2 b; b/ {$ z
48.     HAL_MPU_Enable(MPU_PRIVILEGED_DEFAULT);
    
49. }
    
50. 
    
51. /*
    
52. *********************************************************************************************************
    + y* A4 l; j, e
53. *    函 数 名: CPU_CACHE_Enable
    
54. *    功能说明: 使能L1 Cache
    
55. *    形    参: 无
    
56. *    返 回 值: 无
    5 o9 }) S) \, G' r* ^3 b* `" y8 @
57. *********************************************************************************************************
    8 y6 R/ d3 ~9 X5 O, j
58. */
    
59. static void CPU_CACHE_Enable(void)
    2 m( d: |) m1 T3 j& Y
60. {
    6 e% Y- s8 F! L! a8 `0 \
61.     /* 使能 I-Cache */
    
62.     SCB_EnableICache();
    " Q0 D$ t8 Z1 N% F/ v% Y
63. 
    
64.     /* 使能 D-Cache */
    # [1 t3 |& w! v+ v# a; L8 J
65.     SCB_EnableDCache();
    . @& Q, M- X! V- {" x3 v
66. }

复制代码

  每10ms调用一次蜂鸣器处理：
! y3 r" M( T0 l
  k' |, s% T4 [2 \8 l# F1 b蜂鸣器处理是在滴答定时器中断里面实现，每10ms执行一次检测。

1. /*
   
2. *********************************************************************************************************
   6 a& S5 E. S3 l: i8 ~/ L
3. *    函 数 名: bsp_RunPer10ms
   9 P. ~7 e- W5 l; Y
4. *    功能说明: 该函数每隔10ms被Systick中断调用1次。详见 bsp_timer.c的定时中断服务程序。一些处理时间要求
   
5. *              不严格的任务可以放在此函数。比如：按键扫描、蜂鸣器鸣叫控制等。
   
6. *    形    参: 无
   / f; [$ g. O9 a$ ]
7. *    返 回 值: 无
   8 h4 c% f  w7 v: ?
8. *********************************************************************************************************
   
9. */
     n" M5 B) f7 I) w7 O" [
10. void bsp_RunPer10ms(void)
    
11. {
    - j" r: ?( z( J
12.     bsp_KeyScan10ms();
    + j% T* ]2 c2 u1 L) B7 }2 L8 p  J
13. }
    , n" `0 \. k9 P  j

复制代码

  主功能：
7 n; d5 P. F- F. [+ |+ A9 @2 G
主程序实现如下操作：
2 I$ J* `+ [2 K) B5 z
8 b$ Y$ q* ]" z3 C5 L  启动一个自动重装软件定时器，每100ms翻转一次LED2。
3 Y: W* T4 M$ k  K1键按下，将8bit，16bit和32bit数据写入到内部Flash。
  K2键按下，将结构体数据写入到内部Flash。
" F* i) O6 B! \0 f

1. /*
   ; p: _* U" ]5 U: x  @. Z
2. *********************************************************************************************************
   2 k- E- l# z) ]' o
3. *    函 数 名: main
   
4. *    功能说明: c程序入口
   1 s, K! O6 i& p8 i* l
5. *    形    参: 无
   
6. *    返 回 值: 错误代码(无需处理)
   * [7 K0 _6 R% U) n$ M7 a
7. *********************************************************************************************************
   
8. */
   
9. int main(void)
   
10. {
    
11.     uint8_t ucKeyCode;    /* 按键代码 */
    
12.     uint8_t  ucTest, *ptr8;
    % c, ^! J: C) q: n- ]
13.     uint16_t uiTest, *ptr16;
    9 e0 h; a# |+ d  l( \  j& f" g3 X
14.     uint32_t ulTest, *ptr32;
    
15.     PARAM_T tPara, *paraptr;
    ; X/ f! N* e& e1 |- Y: Y
16. 
    
17. 
    
18.     /* 初始化数据 */
    9 M3 s- Q$ R8 Z- a9 Z( m# @( f1 w1 b
19.     tPara.Baud485 = 0x5555AAAA;
    
20.     tPara.ParamVer = 0x99;
    
21.     tPara.ucBackLight = 0x7788;
    
22.     tPara.ucRadioMode = 99.99f;
      p+ ]$ F* |2 [4 k3 Z
23. 
    
24. 
    ) }2 Y  f* D) L7 N1 l9 E
25.     bsp_Init();        /* 硬件初始化 */
    0 [' H. b0 W; b1 N
26.     PrintfLogo();    /* 打印例程名称和版本等信息 */
    * }9 D' W& x! I' ^# ?8 ?4 U/ ~
27.     PrintfHelp();    /* 打印操作提示 */
    
28. 
    ) v/ P7 i8 h. d0 r/ `1 A& s7 O# G
29.     bsp_StartAutoTimer(0, 100);    /* 启动1个100ms的自动重装的定时器 */
    ' u' P: ^' O  V% Y& E6 M3 d) Q; m
30.     while (1)
    
31.     {
    1 o3 \( l3 b: C* ^" K  F" Y
32.         bsp_Idle();        /* 这个函数在bsp.c文件。用户可以修改这个函数实现CPU休眠和喂狗 */
    ! E# m( I9 N* u
33. 
    $ L3 O! S# [9 j, j( t, }+ R
34.         /* 判断定时器超时时间 */
    
35.         if (bsp_CheckTimer(0))   
    2 w1 E0 u: S. i" T: S5 d" g/ Y
36.         {
    9 b+ u8 T- H' }
37.             /* 每隔100ms 进来一次 */  
    ( \% a9 a6 _! U2 m0 C1 ]. Z# q
38.             bsp_LedToggle(2);
    
39.         }
    2 c9 v1 e7 k) S: C+ R
40. 
    
41.         /* 按键滤波和检测由后台systick中断服务程序实现，我们只需要调用bsp_GetKey读取键值即可。 */
    
42.         ucKeyCode = bsp_GetKey();    /* 读取键值, 无键按下时返回 KEY_NONE = 0 */
    . o5 ?1 o8 |3 F2 G! t+ ?
43.         if (ucKeyCode != KEY_NONE)
    
44.         {
    
45.             switch (ucKeyCode)
    3 \7 W# C. t0 @) ~! U7 z& o! L' O2 ^
46.             {
    0 e" n# D, M& S2 o- F/ ?
47.                 case KEY_DOWN_K1:            /* K1键按下，将8bit，16bit和32bit数据写入到内部Flash */
    0 M2 v' |* }( C. E
48. 
    - H, H* A, U  |: }* ?7 C
49.                 /*
    
50.                  1、对于同一个地址空间，仅支持一次编程(不推荐二次编程，即使是将相应bit由数值1编程0)。
    
51.                  2、只能对已经擦除的空间做编程，擦除1个扇区是128KB。
    
52.                  3、H7的Flash编程时，务必保证要编程的地址是32字节对齐的，即此地址对32求余为0。并且编
    
53. 程的数据必须32字节整数倍。函数bsp_WriteCpuFlash对字节数不够32字节整数倍的情况自动补
    + y( r' W; s+ z$ Y) D& c( [
54. 0。
    & N1 l- l/ `1 @1 r" n$ r) T- j& V/ t
55.                 */
    - {0 v; Z8 ]- N# @; F; }4 r7 ~7 U
56.                      /* 擦除扇区 */
    , f1 z+ @( ]6 l2 j) b
57.                     bsp_EraseCpuFlash((uint32_t)para_flash_area);
    4 W) Y3 R4 c$ X+ w* X. R! Z
58. 
    
59.                     ucTest = 0xAA;
    
60.                     uiTest = 0x55AA;
    ; j% ?6 ~: ?# b
61.                     ulTest = 0x11223344;
    % o  e9 X9 G# T  M
62. 
    " K+ Q, @, v: T* H, \8 z/ z, i" Z
63.                     /* 扇区写入数据 */
    8 \* E" j; v1 O8 A- |- n# N- ]
64.                     bsp_WriteCpuFlash((uint32_t)para_flash_area + 32*0,  (uint8_t *)&ucTest,
    7 p5 g) ^8 J, |- q+ w8 p
65. sizeof(ucTest));
    
66.                     bsp_WriteCpuFlash((uint32_t)para_flash_area + 32*1,  (uint8_t *)&uiTest,
    
67. sizeof(uiTest));
    
68.                     bsp_WriteCpuFlash((uint32_t)para_flash_area + 32*2,  (uint8_t *)&ulTest,
    
69. sizeof(ulTest));               
    
70. 
    
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);
    # C. p$ Q  h# I
77.                     printf("读取数据：ptr8 = %x, ptr16 = %x, ptr32 = %x\r\n", *ptr8, *ptr16, *ptr32);
    
78. 
    % h0 O$ p( K% g& w8 m5 ]
79.                     break;
    
80. 
    & p* L4 l6 O- K! V( w7 v) B3 h; W
81.                 case KEY_DOWN_K2:            /* K2键按下， 将结构体数据写入到内部Flash */
    3 Y$ r3 x) R, z. A3 b) s
82.                     /* 擦除扇区 */
    8 L0 k. r* e/ t6 q. Q
83.                     bsp_EraseCpuFlash((uint32_t)para_flash_area);
    
84. 
    ' A' Q4 K9 U% Y/ Q/ A+ B" \
85.                     /* 扇区写入数据 */
    % W" z2 ~  f0 {- }. U$ M* I
86.                     bsp_WriteCpuFlash((uint32_t)para_flash_area,  (uint8_t *)&tPara, sizeof(tPara));            
    " N# P" K1 R: Q8 R+ f# G
87. 
    
88.                     /* 读出数据并打印 */
    % z. P( j0 V) k' t
89.                     paraptr  = (PARAM_T  *)((uint32_t)para_flash_area);
    
90. 
    ! j+ l! h9 }9 d3 T' r- V7 ]
91. 
    
92.                     printf("写入数据：Baud485=%x, ParamVer=%x, ucBackLight=%x, ucRadioMode=%f\r\n",
    . L, X. ^; e& [  H4 [* h% @7 k
93.                                                                        tPara.Baud485,
    ' x& z* Y" _: n
94.                                                                         tPara.ParamVer,
    
95.                                                                         tPara.ucBackLight,
    
96.                                                                    paraptr->ucRadioMode);
    7 Z4 k: E) `: s' u5 Z, i$ f
97. 
    8 _$ o  M/ y! q. w" H
98.                     printf("读取数据：Baud485=%x, ParamVer=%x, ucBackLight=%x, ucRadioMode=%f\r\n",
    
99.                                                                         paraptr->Baud485,
    5 x0 [* W% v! R; q4 s: }
100.                                                                             paraptr->ParamVer,
     
101.                                                                            paraptr->ucBackLight,
     / Z) T  m8 f0 s" z$ a/ X7 z
102.                                                                           paraptr->ucRadioMode);
     
103.                     break;               
     % i% ]! N/ ~4 H0 W) S  A
104.                 default:
     + x- G; H/ x/ I6 ]0 `3 d7 f
105.                     /* 其它的键值不处理 */
     
106.                     break;
     
107.             }
     
108.         }
     / P# C$ f/ O1 l# P& o
109.     }
     
110. }
     ( s7 s* z1 e7 h

复制代码

71.7 实验例程说明（IAR）
, K, d6 v! f# Y& P* X配套例子：
- O- I5 ^3 `/ W4 u8 a3 ?
V7-049_内部Flash模拟EEPROM

实验目的：
/ i( p: |; X6 t! h$ G. t6 ]
9 w+ h) _0 q7 _1 L7 [学习内部Flash模拟EEPROM。
实验内容：
0 g2 V* @- s3 G; `4 W
使用内部Flash模拟EEPROM，务必告诉编译要使用的存储空间，防止这个空间存入了程序。
对于同一个地址空间，仅支持一次编程(不推荐二次编程，即使是将相应bit由数值1编程0)。
只能对已经擦除的空间做编程，擦除1个扇区是128KB。
% Q6 C! k+ r7 M+ fH7的Flash编程时，务必保证要编程的地址是32字节对齐的，即此地址对32求余为0。
并且编程的数据必须32字节整数倍，函数bsp_WriteCpuFlash对字节数不够32字节整数倍的情况自动补0。

实验操作：
0 p3 l; e& {0 N# d3 N# m
! \+ C# R0 G$ c8 @' MK1键按下，将8bit，16bit和32bit数据写入到内部Flash。
2 v: f! R$ ]2 f4 ]K2键按下，将结构体数据写入到内部Flash。
上电后串口打印的信息：
  H, v: W$ |7 [/ Q1 }
* M  o* D0 r5 \0 m; Z9 O波特率 115200，数据位 8，奇偶校验位无，停止位 1。

9 e; W4 X( @  A# P: X程序设计：

* P; f2 f8 d0 A3 m# e" k  系统栈大小分配：
- \% K1 e/ R3 n7 {$ I. u1 S) e

1 g8 P  B# W( [! D! c. k
" {3 `5 Z( |* B  j! D  RAM空间用的DTCM：

  硬件外设初始化

6 z% h/ y1 {" n) ^; b/ Y硬件外设的初始化是在 bsp.c 文件实现：

1. /*
   / u0 ^" F1 E, j9 q0 H3 k0 v' z. E3 H
2. *********************************************************************************************************
   
3. *    函 数 名: bsp_Init
   ) f2 y# w" l3 z3 |+ i+ X
4. *    功能说明: 初始化所有的硬件设备。该函数配置CPU寄存器和外设的寄存器并初始化一些全局变量。只需要调用一次
   
5. *    形    参：无
   
6. *    返 回 值: 无
   - {- N/ K4 B, h# F/ P  z# \" ?( l
7. *********************************************************************************************************
   1 m. n: b6 ~6 O7 o2 v8 H
8. */
   8 Y2 S5 s6 v& h  h  N
9. void bsp_Init(void)
   
10. {
    
11.     /* 配置MPU */
    
12.     MPU_Config();
    3 f/ k2 A% B( t0 S" S7 D1 ^
13. 
    . X6 _' i+ s5 h4 v& m8 b! ]5 w5 i
14.     /* 使能L1 Cache */
    
15.     CPU_CACHE_Enable();
    
16. 
    
17.     /*
    " s: ~. p/ f3 W: Y% r" j- |1 y
18.        STM32H7xx HAL 库初始化，此时系统用的还是H7自带的64MHz，HSI时钟:
    ' m% @3 N# k5 i1 g$ @% G3 d
19.        - 调用函数HAL_InitTick，初始化滴答时钟中断1ms。
    ( k; V9 K8 p5 K1 O& }) @5 `
20.        - 设置NVIV优先级分组为4。
    
21.      */
    
22.     HAL_Init();
    
23. 
    ' t+ t% F/ ]$ O4 K1 x1 |% M. N
24.     /*
    
25.        配置系统时钟到400MHz
    8 h" o' @& }+ l5 u( U; c
26.        - 切换使用HSE。
    
27.        - 此函数会更新全局变量SystemCoreClock，并重新配置HAL_InitTick。
      h8 h; C4 m3 o/ d! H3 V3 b
28.     */
    
29.     SystemClock_Config();
    
30. 
    
31.     /*
    & S% \+ h# w/ X% a% j% U& s6 S
32.        Event Recorder：
    
33.        - 可用于代码执行时间测量，MDK5.25及其以上版本才支持，IAR不支持。
    ( x. V& g; y, }1 q8 Q
34.        - 默认不开启，如果要使能此选项，务必看V7开发板用户手册第xx章
    * T0 t3 |% ^* q" r3 V0 w' ?
35.     */   
    
36. #if Enable_EventRecorder == 1  
    
37.     /* 初始化EventRecorder并开启 */
    
38.     EventRecorderInitialize(EventRecordAll, 1U);
    
39.     EventRecorderStart();
    3 t) Z5 \, X7 q
40. #endif
    
41. 
    8 n! ?6 U; M& ?
42. bsp_InitDWT();      /* 初始化DWT时钟周期计数器 */      
    
43.     bsp_InitKey();        /* 按键初始化，要放在滴答定时器之前，因为按钮检测是通过滴答定时器扫描 */
    
44.     bsp_InitTimer();      /* 初始化滴答定时器 */
    
45.     bsp_InitLPUart();    /* 初始化串口 */
    
46.     bsp_InitExtIO();    /* 初始化FMC总线74HC574扩展IO. 必须在 bsp_InitLed()前执行 */   
    
47.     bsp_InitLed();        /* 初始化LED */   
    
48.     bsp_InitExtSDRAM(); /* 初始化SDRAM */
    9 ^) B$ b1 S+ w) X, x2 j% U
49. }
    

复制代码

% T9 b" l6 ^3 ?. y  MPU配置和Cache配置：
; O1 w# f1 \9 F: o* G, Q
/ q. S; l$ E& u6 N; U: v6 ]数据Cache和指令Cache都开启。配置了AXI SRAM区（本例子未用到AXI SRAM）和FMC的扩展IO区。

1. /*
   0 H) ^, A% r, q- K
2. *********************************************************************************************************
   
3. *    函 数 名: MPU_Config
   
4. *    功能说明: 配置MPU
   . [3 F; z& f& Y; s' l- q
5. *    形    参: 无
   * e/ x6 \) V8 {  f
6. *    返 回 值: 无
   
7. *********************************************************************************************************
   
8. */
   
9. static void MPU_Config( void )
   
10. {
    $ h, b$ |2 |6 l" @( p$ s% J
11.     MPU_Region_InitTypeDef MPU_InitStruct;
    
12. 
    : `$ Y+ A$ j9 f
13.     /* 禁止 MPU */
    1 L' Q4 R# o: P' m2 W7 |5 I
14.     HAL_MPU_Disable();
    + a+ l# l! \1 p1 b! Q' g- o
15. 
    
16.     /* 配置AXI SRAM的MPU属性为Write back, Read allocate，Write allocate */
    . ?9 q( n- N0 l, ?6 |
17.     MPU_InitStruct.Enable           = MPU_REGION_ENABLE;
    
18.     MPU_InitStruct.BaseAddress      = 0x24000000;
    ( e" i3 T" X1 E% U- ]' a
19.     MPU_InitStruct.Size             = MPU_REGION_SIZE_512KB;
    
20.     MPU_InitStruct.AccessPermission = MPU_REGION_FULL_ACCESS;
    ) A, g' @' f/ w$ N- h  B0 y( e; D: U
21.     MPU_InitStruct.IsBufferable     = MPU_ACCESS_BUFFERABLE;
    
22.     MPU_InitStruct.IsCacheable      = MPU_ACCESS_CACHEABLE;
    : s1 l* |0 W# I  S: F
23.     MPU_InitStruct.IsShareable      = MPU_ACCESS_NOT_SHAREABLE;
    
24.     MPU_InitStruct.Number           = MPU_REGION_NUMBER0;
    2 h, y4 j5 ?5 w. o
25.     MPU_InitStruct.TypeExtField     = MPU_TEX_LEVEL1;
    
26.     MPU_InitStruct.SubRegionDisable = 0x00;
    
27.     MPU_InitStruct.DisableExec      = MPU_INSTRUCTION_ACCESS_ENABLE;
    
28. 
    ) k) E; z0 N( H: m
29.     HAL_MPU_ConfigRegion(&MPU_InitStruct);
    
30. 
    ( T% v7 H- l- j0 A8 r2 `
31. 
    + v% B! @# U( R, m
32.     /* 配置FMC扩展IO的MPU属性为Device或者Strongly Ordered */
    : S9 _, m6 Q" u' q; i# s
33.     MPU_InitStruct.Enable           = MPU_REGION_ENABLE;
    ! B, @' j, s) C% h8 d; q
34.     MPU_InitStruct.BaseAddress      = 0x60000000;
    
35.     MPU_InitStruct.Size             = ARM_MPU_REGION_SIZE_64KB;   
    
36.     MPU_InitStruct.AccessPermission = MPU_REGION_FULL_ACCESS;
    # p4 ^' Z& T' @" D8 p% x& l3 N" l2 j
37.     MPU_InitStruct.IsBufferable     = MPU_ACCESS_BUFFERABLE;
    
38.     MPU_InitStruct.IsCacheable      = MPU_ACCESS_NOT_CACHEABLE;   
    ! o; o5 D: I; Y# V; }8 e# n
39.     MPU_InitStruct.IsShareable      = MPU_ACCESS_NOT_SHAREABLE;
    
40.     MPU_InitStruct.Number           = MPU_REGION_NUMBER1;
    
41.     MPU_InitStruct.TypeExtField     = MPU_TEX_LEVEL0;
    
42.     MPU_InitStruct.SubRegionDisable = 0x00;
    
43.     MPU_InitStruct.DisableExec      = MPU_INSTRUCTION_ACCESS_ENABLE;
    9 }2 ^6 V: O) W8 {$ X( @3 g( O5 v
44. 
    
45.     HAL_MPU_ConfigRegion(&MPU_InitStruct);
    4 j0 Q1 M$ [; h' l# `
46. 
    1 r* D' f6 ^& `& T' ]0 Z* a
47.     /*使能 MPU */
    
48.     HAL_MPU_Enable(MPU_PRIVILEGED_DEFAULT);
    
49. }
    
50. 
    * ~4 l5 T: R$ v' v4 p" J
51. /*
    ' s- h# Q0 ]' ?1 s
52. *********************************************************************************************************
    . \7 I' J9 y1 g* l+ e3 y- y
53. *    函 数 名: CPU_CACHE_Enable
    4 K9 P; ^0 J* `+ Q0 a4 |
54. *    功能说明: 使能L1 Cache
    
55. *    形    参: 无
    . a9 }8 T, f/ E8 A( f. w
56. *    返 回 值: 无
    
57. *********************************************************************************************************
    ) E0 a( ^# X6 B5 t
58. */
    
59. static void CPU_CACHE_Enable(void)
    
60. {
    
61.     /* 使能 I-Cache */
    
62.     SCB_EnableICache();
    - N0 l4 w& G/ W: e" M
63. 
    
64.     /* 使能 D-Cache */
    7 z( Q/ k$ Z9 f. y% n
65.     SCB_EnableDCache();
    % ~" ^9 u( p9 F3 b. l) ~
66. }

复制代码

& y6 H6 [! F+ l, K

  每10ms调用一次蜂鸣器处理：

! E& ^2 g; T8 t# w+ [% P蜂鸣器处理是在滴答定时器中断里面实现，每10ms执行一次检测。
# l! ?; M! w" {4 ~; p( g# Z

1. /*
   
2. *********************************************************************************************************
   8 z2 a2 c) p& W+ b5 f7 D
3. *    函 数 名: bsp_RunPer10ms
   7 [1 K7 ?  J' z3 B" C7 G0 @: G3 ~
4. *    功能说明: 该函数每隔10ms被Systick中断调用1次。详见 bsp_timer.c的定时中断服务程序。一些处理时间要求
   ( B$ l7 W! D! w+ X  l, [4 \# X
5. *              不严格的任务可以放在此函数。比如：按键扫描、蜂鸣器鸣叫控制等。
   
6. *    形    参: 无
   
7. *    返 回 值: 无
   9 ?9 s( ~4 g' m# i% r  |
8. *********************************************************************************************************
   ) ^% P/ _' T# v% ~) S1 D- d
9. */
   
10. void bsp_RunPer10ms(void)
    ! q5 @- V1 }$ r
11. {
    $ |5 B' a0 y" ?* u5 y( Q
12.     bsp_KeyScan10ms();
    
13. }
    

复制代码

) T" ]8 U# G9 A' [5 s$ \& L
  主功能：

. b  d7 A, O9 k! w# Y5 b( f5 ]* I主程序实现如下操作：
5 F& i# d* R% l
启动一个自动重装软件定时器，每100ms翻转一次LED2。
K1键按下，将8bit，16bit和32bit数据写入到内部Flash。
K2键按下，将结构体数据写入到内部Flash。
* \& ^5 S" f- q7 P7 G' {

1. /*
   ( v4 Z# L- H2 C% D9 p3 K# s2 D, R& a+ h
2. *********************************************************************************************************
   0 {1 v+ Z4 X$ Y* |5 {2 x  L
3. *    函 数 名: main
   1 {# C' B, x# E# Q& E& ]
4. *    功能说明: c程序入口
   
5. *    形    参: 无
   
6. *    返 回 值: 错误代码(无需处理)
   
7. *********************************************************************************************************
   ! ~1 J* ^0 S, D1 B
8. */
   , M) k0 I4 j# z6 f6 [
9. int main(void)
   9 z. O7 f( G  _
10. {
    
11.     uint8_t ucKeyCode;    /* 按键代码 */
    
12.     uint8_t  ucTest, *ptr8;
    
13.     uint16_t uiTest, *ptr16;
    
14.     uint32_t ulTest, *ptr32;
    
15.     PARAM_T tPara, *paraptr;
    0 f" V# ?3 W( V' R! e7 K( U
16. 
    6 ]& M! F: g& b1 O3 z" `- Q3 a
17. 
    
18.     /* 初始化数据 */
    # ~! r( S5 B6 Z+ w5 w6 y
19.     tPara.Baud485 = 0x5555AAAA;
    
20.     tPara.ParamVer = 0x99;
    ) D" F3 L$ E% M) |$ F
21.     tPara.ucBackLight = 0x7788;
    
22.     tPara.ucRadioMode = 99.99f;
    
23. 
    : y: r; ^6 n( H; G; q
24. 
    
25.     bsp_Init();        /* 硬件初始化 */
    / f; c) L+ V1 _' E
26.     PrintfLogo();    /* 打印例程名称和版本等信息 */
    
27.     PrintfHelp();    /* 打印操作提示 */
    
28. 
    5 G+ T7 x8 |; H
29.     bsp_StartAutoTimer(0, 100);    /* 启动1个100ms的自动重装的定时器 */
    $ `! I9 X. w+ s+ E
30.     while (1)
    0 o: N) v) D* K' T: I3 y
31.     {
    
32.         bsp_Idle();        /* 这个函数在bsp.c文件。用户可以修改这个函数实现CPU休眠和喂狗 */
    
33. 
    , p7 e% W/ K+ g$ L3 P& u: i; j
34.         /* 判断定时器超时时间 */
    , i* s. t1 L! G# w- W8 v' O
35.         if (bsp_CheckTimer(0))   
    $ i4 t6 C4 s0 I+ p
36.         {
    , {1 L: i& i4 }# o) U1 `. F: O
37.             /* 每隔100ms 进来一次 */  
    / z0 t. m, K& S% E2 `
38.             bsp_LedToggle(2);
    9 r: s9 n5 z% L( ~* _3 u0 W
39.         }
    ) E$ [9 Q5 z! e( T) j
40. 
    
41.         /* 按键滤波和检测由后台systick中断服务程序实现，我们只需要调用bsp_GetKey读取键值即可。 */
    
42.         ucKeyCode = bsp_GetKey();    /* 读取键值, 无键按下时返回 KEY_NONE = 0 */
    
43.         if (ucKeyCode != KEY_NONE)
      J; ?1 I+ o2 `: x; x4 x. B
44.         {
    % _6 ^; [' t# J# T6 a, v9 n( F
45.             switch (ucKeyCode)
    + y$ V7 P7 q6 s; ~) O
46.             {
    : c) Z$ y9 Y6 N5 ]8 Q. r! q6 h5 _
47.                 case KEY_DOWN_K1:            /* K1键按下，将8bit，16bit和32bit数据写入到内部Flash */
    " e5 ~" H4 _" @
48. 
    
49.                 /*
    
50.                  1、对于同一个地址空间，仅支持一次编程(不推荐二次编程，即使是将相应bit由数值1编程0)。
    
51.                  2、只能对已经擦除的空间做编程，擦除1个扇区是128KB。
    
52.                  3、H7的Flash编程时，务必保证要编程的地址是32字节对齐的，即此地址对32求余为0。并且编
    6 d  V+ J1 _# ~
53. 程的数据必须32字节整数倍。函数bsp_WriteCpuFlash对字节数不够32字节整数倍的情况自动补
    
54. 0。
    9 |: \4 r3 t, A
55.                 */
    9 T: u9 d, d' d% h
56.                      /* 擦除扇区 */
    
57.                     bsp_EraseCpuFlash((uint32_t)para_flash_area);
    
58. 
    2 b7 `/ X4 F' c1 y% {6 ]
59.                     ucTest = 0xAA;
    1 t$ F( {7 \2 B
60.                     uiTest = 0x55AA;
    " M6 \: \6 X" B7 @$ h
61.                     ulTest = 0x11223344;
    ! n: u# r  U9 k' }" K/ _& ]3 g
62. 
    
63.                     /* 扇区写入数据 */
    " R# n4 y2 k! Q. u; Z
64.                     bsp_WriteCpuFlash((uint32_t)para_flash_area + 32*0,  (uint8_t *)&ucTest,
    
65. sizeof(ucTest));
    " x( f! H) @1 N& R+ d& G0 s6 U
66.                     bsp_WriteCpuFlash((uint32_t)para_flash_area + 32*1,  (uint8_t *)&uiTest,
    ) l2 V; s' D$ e
67. sizeof(uiTest));
    # y, {3 j( ?" g9 b( F
68.                     bsp_WriteCpuFlash((uint32_t)para_flash_area + 32*2,  (uint8_t *)&ulTest,
    
69. sizeof(ulTest));               
    " l8 q& L5 O3 t8 l$ g- ~1 o
70. 
    8 l) U. ^% f8 O4 p, `1 E* E
71.                     /* 读出数据并打印 */
    6 G8 ~: ?& I) z0 |3 a; N
72.                     ptr8  = (uint8_t  *)(para_flash_area + 32*0);
    ; S, h1 ~( I6 C+ Z- i, L6 |
73.                     ptr16 = (uint16_t *)(para_flash_area + 32*1);
    
74.                     ptr32 = (uint32_t *)(para_flash_area + 32*2);
    ! e- g/ `: c9 i1 B
75. 
    & C0 N3 \/ E" k, X# R' K
76.                     printf("写入数据：ucTest = %x, uiTest = %x, ulTest = %x\r\n", ucTest, uiTest, ulTest);
    ' g/ s, i- C$ J. L# n0 x2 B
77.                     printf("读取数据：ptr8 = %x, ptr16 = %x, ptr32 = %x\r\n", *ptr8, *ptr16, *ptr32);
    
78. 
    / ^, o, P2 ~3 T$ o" B; G. |
79.                     break;
    
80. 
    
81.                 case KEY_DOWN_K2:            /* K2键按下， 将结构体数据写入到内部Flash */
    
82.                     /* 擦除扇区 */
    . Q8 i' @, Y. D
83.                     bsp_EraseCpuFlash((uint32_t)para_flash_area);
    
84. 
    9 f) I2 B  T: C
85.                     /* 扇区写入数据 */
    5 \' b$ S/ x5 A* W4 i8 E. L" M  A
86.                     bsp_WriteCpuFlash((uint32_t)para_flash_area,  (uint8_t *)&tPara, sizeof(tPara));            
    8 Q2 s' X& t1 ]. D  M
87. 
    3 {$ c$ I  T8 q; Z( p
88.                     /* 读出数据并打印 */
    
89.                     paraptr  = (PARAM_T  *)((uint32_t)para_flash_area);
    7 U% f. a$ q# m; o: y. z0 V
90. 
    
91. 
    
92.                     printf("写入数据：Baud485=%x, ParamVer=%x, ucBackLight=%x, ucRadioMode=%f\r\n",
    $ f0 L2 P5 A  P( j
93.                                                                        tPara.Baud485,
    
94.                                                                         tPara.ParamVer,
    
95.                                                                         tPara.ucBackLight,
    
96.                                                                    paraptr->ucRadioMode);
    
97. 
    . h/ P% W  h: H
98.                     printf("读取数据：Baud485=%x, ParamVer=%x, ucBackLight=%x, ucRadioMode=%f\r\n",
    $ g+ u- {% q4 N! c6 c4 }' p) Y
99.                                                                         paraptr->Baud485,
    
100.                                                                             paraptr->ParamVer,
     
101.                                                                            paraptr->ucBackLight,
     
102.                                                                           paraptr->ucRadioMode);
     
103.                     break;               
     ; T0 P1 w) i4 y7 H% C1 ~3 M
104.                 default:
     1 x% P# ^0 N/ ?) O
105.                     /* 其它的键值不处理 */
     
106.                     break;
     ; V) @! |: ]  t0 e- i2 }
107.             }
     
108.         }
     
109.     }
     3 e, R7 X$ J5 }- j* e% f. N
110. }

复制代码

2 U: `& Y- i0 y& k9 d/ S- x

& d. e1 _3 W2 D71.8 总结
! g5 F0 I; W- q- k1 c本章节就为大家讲解这么多， 实际应用中的注意事项比较多，应用到项目之前务必实际测试熟悉下。
9 {) Z( E5 W8 G5 m' H