71.1 初学者重要提示
  学习本章节前，务必优先学习第70章。
9 C0 ~$ [& |$ G+ ?' {  使用内部Flash模拟EEPROM，务必告诉编译要使用的存储空间，防止这个空间存入了程序。
  STM32H7的Flash编程时，务必保证要编程的地址是32字节对齐的，即此地址对32求余为0。并且编程的数据必须32字节整数倍。
8 [9 x: C2 I/ Q/ Y. u  STM32H743XI有两个独立的BANK，一个BANK的编程和擦除操作对另一个BANK没有任何影响。但是用户应用程序和要擦写的Flash扇区在同一个BANK，在执行擦写操作时，应用应用程序将停止运行，包括中断服务程序。
1 t. j* y% ~& |0 k( b& _  使用内部Flash模拟EEPROM要做到先擦除后使用。
' z  D8 @* p0 R- [$ G* w& ~71.2 模拟EEPROM驱动设计
+ A  d; r+ _: d  Z! k  `这里重点把内部Flash的读取，编程和擦除做个说明。

71.2.1 内部Flash擦除的实现
6 s0 V4 d1 ]3 n# f5 |+ @内部Flash的擦除思路如下：

; V7 Z7 S% W& t! s4 N  第1步，获取擦除地址所处的扇区。
  第2步，调用函数HAL_FLASH_Unlock解锁。
- ^9 p" ~1 }$ l% S* Y6 u) ~$ D  第3步，调用函数HAL_FLASHEx_Erase擦除一个扇区。
6 g: o. r3 k/ T* ^2 w  第4步，调用函数HAL_FLASH_Lock上锁。
按照这个思路，程序实现如下：
/ Q' t2 m" }9 ^+ Q

1. 1.    /*
   
2. 2.    ******************************************************************************************************
   1 S8 P8 w+ g0 s* E
3. 3.    *    函 数 名: bsp_EraseCpuFlash
   
4. 4.    *    功能说明: 擦除CPU FLASH一个扇区 （128KB)
   ( P: y0 W0 Y# P. c3 K! l. ~$ h
5. 5.    *    形    参: _ulFlashAddr : Flash地址
   . J! I7 b" E8 E8 X  a
6. 6.    *    返 回 值: 0 成功， 1 失败
   
7. 7.    *              HAL_OK       = 0x00,
     E  m2 k; i& Y8 v; q- {8 @
8. 8.    *              HAL_ERROR    = 0x01,
   
9. 9.    *              HAL_BUSY     = 0x02,
   
10. 10.    *              HAL_TIMEOUT  = 0x03
      z8 n, B- J9 n! U6 j* u
11. 11.    *
    
12. 12.    ******************************************************************************************************
    
13. 13.    */
    
14. 14.    uint8_t bsp_EraseCpuFlash(uint32_t _ulFlashAddr)
    
15. 15.    {
    * G* [# c" I0 \1 e9 d8 M3 h8 @
16. 16.        uint32_t FirstSector = 0, NbOfSectors = 0;
    
17. 17.        FLASH_EraseInitTypeDef EraseInitStruct;
    
18. 18.        uint32_t SECTORError = 0;
    
19. 19.        uint8_t re;
    ! X( S  Q  Z  K( ]/ K8 j$ K
20. 20.   
    * D: N! O- G- ~: ?/ A/ I! c7 s1 a6 q
21. 21.        /* 解锁 */
    
22. 22.        HAL_FLASH_Unlock();
    
23. 23.        
    
24. 24.        /* 获取此地址所在的扇区 */
    . H- C* P7 c3 o
25. 25.        FirstSector = bsp_GetSector(_ulFlashAddr);
    
26. 26.        
    
27. 27.        /* 固定1个扇区 */
    
28. 28.        NbOfSectors = 1;   
    
29. 29.   
    ; o, R3 T6 L7 Q6 o, P
30. 30.        /* 擦除扇区配置 */
    
31. 31.        EraseInitStruct.TypeErase     = FLASH_TYPEERASE_SECTORS;
    8 l9 v, [+ E* v: h1 c7 G
32. 32.        EraseInitStruct.VoltageRange  = FLASH_VOLTAGE_RANGE_3;
    
33. 33.        
    ( C+ p/ s7 `# s8 h, q( A7 [: q
34. 34.        if (_ulFlashAddr >= ADDR_FLASH_SECTOR_0_BANK2)
    4 P( c) G3 e; l
35. 35.        {
    
36. 36.            EraseInitStruct.Banks         = FLASH_BANK_2;
    
37. 37.        }
    ' a8 Y+ t1 M# F  o; i+ w
38. 38.        else
    $ Y; [# W; O9 ]2 ~0 T9 l" \, F
39. 39.        {
    
40. 40.            EraseInitStruct.Banks         = FLASH_BANK_1;
    . e! p/ ^* w9 I5 D" i
41. 41.        }
    
42. 42.        
    # G! ^* }: w2 ?  R* H1 O' u4 U
43. 43.        EraseInitStruct.Sector        = FirstSector;
    
44. 44.        EraseInitStruct.NbSectors     = NbOfSectors;
    
45. 45.        
    
46. 46.        /* 扇区擦除 */   
    ! C6 W5 B5 u0 e
47. 47.        re = HAL_FLASHEx_Erase(&EraseInitStruct, &SECTORError);
    5 d' i" t7 a( q; P$ @8 u) N
48. 48.        
      m0 G' ?9 I5 i% K6 S6 ]2 l# K
49. 49.        /* 擦除完毕后，上锁 */
    
50. 50.        HAL_FLASH_Lock();   
    
51. 51.        
    
52. 52.        return re;
    
53. 53.    }

复制代码

这里将此程序设计的关键点为大家做个说明：
! x3 z+ z. i# T$ ~/ M* K2 g
6 S& N# n$ ^; V  E$ C  第25行函数是通过函数bsp_GetSector获取要擦除地址所处的扇区。这个函数的实现比较简单，代码如下：
& a) Q" X/ ]! ^

1. /*
   
2. *********************************************************************************************************
   % U1 f( j, T9 [9 u
3. *    函 数 名: bsp_GetSector
   
4. *    功能说明: 根据地址计算扇区首地址
   0 A. F  x. B. e
5. *    形    参: 无
   " A7 i' q; Q, v3 b# v& Q/ n) t
6. *    返 回 值: 扇区号（0-7)
   8 V& W! h" }) {( X1 n7 L6 t
7. *********************************************************************************************************
   ' [0 ]4 {( {/ k* I$ x5 \. p- i
8. */
   
9. uint32_t bsp_GetSector(uint32_t Address)
   : K, z/ A, R- g0 M% O2 i
10. {
    / R) H6 \$ h  p
11.     uint32_t sector = 0;
    2 w; W4 }5 H# ?; v
12. 
    / F9 d0 K( E4 I% o' @; `4 M
13.     if (((Address < ADDR_FLASH_SECTOR_1_BANK1) && (Address >= ADDR_FLASH_SECTOR_0_BANK1)) || \
      x2 B" ^& c5 q; ]! p& n5 ]6 M
14.         ((Address < ADDR_FLASH_SECTOR_1_BANK2) && (Address >= ADDR_FLASH_SECTOR_0_BANK2)))   
    
15.     {
    , g8 ~! G) j# f
16.         sector = FLASH_SECTOR_0;  
    , J' M. g' }4 r9 Q* k
17.     }
    
18.     else if (((Address < ADDR_FLASH_SECTOR_2_BANK1) && (Address >= ADDR_FLASH_SECTOR_1_BANK1)) || \
    6 d# F6 K, ^5 |3 S& a; q7 T2 Q
19.       ((Address < ADDR_FLASH_SECTOR_2_BANK2) && (Address >= ADDR_FLASH_SECTOR_1_BANK2)))   
    
20.     {
    . k* k- v& q2 u& \9 N6 d
21.         sector = FLASH_SECTOR_1;  
    6 M& X& s3 Q$ o" l2 {9 u0 b7 f( ?
22.     }
    & S$ `5 X8 x+ ^$ M2 C/ R
23.     else if (((Address < ADDR_FLASH_SECTOR_3_BANK1) && (Address >= ADDR_FLASH_SECTOR_2_BANK1)) || \
    7 p3 c; _' y9 U0 Q3 G( P) J
24.       ((Address < ADDR_FLASH_SECTOR_3_BANK2) && (Address >= ADDR_FLASH_SECTOR_2_BANK2)))   
    
25.     {
    
26.         sector = FLASH_SECTOR_2;  
    
27.     }
    
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)))   
    + p; M1 v* k3 O0 v* L" h
30.     {
    * s/ S, U7 V% g. n
31.         sector = FLASH_SECTOR_3;  
    0 n; m/ \8 u5 e$ p) f; I; n" l3 y
32.     }
    
33.     else if (((Address < ADDR_FLASH_SECTOR_5_BANK1) && (Address >= ADDR_FLASH_SECTOR_4_BANK1)) || \
    5 a9 i; w5 j8 u9 ]/ S( ?4 L
34.       ((Address < ADDR_FLASH_SECTOR_5_BANK2) && (Address >= ADDR_FLASH_SECTOR_4_BANK2)))   
    - d: K1 p- o7 M9 }  n. Q$ E5 [2 v! }
35.     {
    
36.         sector = FLASH_SECTOR_4;  
    # S1 y& p- u9 m' T1 I  A% C" u, W
37.     }
    ( {1 x. w$ J( k) X2 Q2 {
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)))   
    * S- `3 l. d# u5 B
40.     {
    $ O# t$ g  j1 q1 {5 o
41.         sector = FLASH_SECTOR_5;  
    
42.     }
    $ L6 I$ Y- o  C. [: b
43.     else if (((Address < ADDR_FLASH_SECTOR_7_BANK1) && (Address >= ADDR_FLASH_SECTOR_6_BANK1)) || \
      e; Q: O' [5 c# r
44.       ((Address < ADDR_FLASH_SECTOR_7_BANK2) && (Address >= ADDR_FLASH_SECTOR_6_BANK2)))   
      R( n( Z6 \3 M0 s5 I
45.     {
    , t0 O, O: B! i- U( [# ~
46.         sector = FLASH_SECTOR_6;  
    8 W2 g/ c3 v3 V; A0 d
47.     }
    
48.     else if (((Address < ADDR_FLASH_SECTOR_0_BANK2) && (Address >= ADDR_FLASH_SECTOR_7_BANK1)) || \
    0 g4 K1 b/ r( x. Q1 q+ C
49.       ((Address < CPU_FLASH_END_ADDR) && (Address >= ADDR_FLASH_SECTOR_7_BANK2)))
    : C8 U) Q( Z& V) a, l; A- Z; g
50.     {
    
51.         sector = FLASH_SECTOR_7;  
    & V1 N- C5 O  c; `  U0 x
52.     }
    $ l. W, v5 }4 f/ ^
53.     else
    
54.     {
    ! I2 L5 l7 I: @( I
55.         sector = FLASH_SECTOR_7;
    % E# d" v$ y6 x8 e
56.     }
    
57. 
    
58.     return sector;
    
59. }
    

复制代码

5 D0 a- |1 K% q+ v1 q6 ]) M, W由于STM32H7的BANK1和BANK2是独立的，都有8个扇区，所以程序里面只需返回要擦除地址所处的扇区号即可。

  第47行的擦除函数HAL_FLASHEx_Erase在第70章的4.4小节有说明。
71.2.2 内部Flash编程的实现
8 e1 v* g+ [0 h6 ?! e) Q+ o内部Flash的编程思路如下：

! v5 N) B6 v4 f2 r& z9 R  第1步，判断是否要编写数据进去，如果数据已经在内部Flash里面。
. K* C; n6 i# I3 f( F  第2步，调用函数HAL_FLASH_Unlock解锁。
  第3步，调用函数HAL_FLASH_Program对内部Flash编程数据。
6 ~: J0 H9 q! z0 K4 G  第4步，调用函数HAL_FLASH_Lock上锁。
% D/ x. [) l4 {) z7 D按照这个思路，程序实现如下：

1. 1.    /*
   
2. 2.    ******************************************************************************************************
   ; @+ E3 `% D! q8 k' c+ g+ \2 X
3. 3.    *    函 数 名: bsp_WriteCpuFlash
   
4. 4.    *    功能说明: 写数据到CPU 内部Flash。 必须按32字节整数倍写。不支持跨扇区。扇区大小128KB. \
   
5. 5.    *              写之前需要擦除扇区. 长度不是32字节整数倍时，最后几个字节末尾补0写入.
   
6. 6.    *    形    参: _ulFlashAddr : Flash地址
   
7. 7.    *             _ucpSrc : 数据缓冲区
   
8. 8.    *             _ulSize : 数据大小（单位是字节, 必须是32字节整数倍）
   , h4 K* t) ~" Y" S
9. 9.    *    返 回 值: 0-成功，1-数据长度或地址溢出，2-写Flash出错(估计Flash寿命到)
   
10. 10.    ******************************************************************************************************
    
11. 11.    */
      [7 X# t8 G/ q/ z! l7 v
12. 12.    uint8_t bsp_WriteCpuFlash(uint32_t _ulFlashAddr, uint8_t *_ucpSrc, uint32_t _ulSize)
    
13. 13.    {
    % U% b3 a% j8 t+ h9 Q
14. 14.        uint32_t i;
    5 g; t! \/ C% x& ?0 {! G  M  l
15. 15.        uint8_t ucRet;
    # {2 B  c+ G' B& O$ z+ X0 Y
16. 16.   
    
17. 17.        /* 如果偏移地址超过芯片容量，则不改写输出缓冲区 */
    
18. 18.        if (_ulFlashAddr + _ulSize > CPU_FLASH_BASE_ADDR + CPU_FLASH_SIZE)
    
19. 19.        {
    
20. 20.            return 1;
    ' \1 P$ e* l9 |4 c' B% _* H5 e4 Z
21. 21.        }
    
22. 22.   
    
23. 23.        /* 长度为0时不继续操作  */
    
24. 24.        if (_ulSize == 0)
    : Q/ Z3 W7 ?6 l$ B
25. 25.        {
    
26. 26.            return 0;
    1 x1 |. W1 e; }0 \1 Q0 }4 _9 R
27. 27.        }
    
28. 28.   
    
29. 29.        ucRet = bsp_CmpCpuFlash(_ulFlashAddr, _ucpSrc, _ulSize);
    
30. 30.   
    / h/ k: h# A' \
31. 31.        if (ucRet == FLASH_IS_EQU)
    9 b3 }$ ?1 W: I3 I" j
32. 32.        {
    
33. 33.            return 0;
    7 Z6 P6 a( @: u% ]  \/ T7 v2 {5 O
34. 34.        }
    . Z+ z4 B' |! m! X* |& S
35. 35.   
    
36. 36.        __set_PRIMASK(1);          /* 关中断 */
    ! }. Z. O5 d' v  p# C
37. 37.   
      L$ A, y! @8 X' z9 v7 ~0 n
38. 38.        /* FLASH 解锁 */
      l! w& L. a" q$ Y7 I8 \4 F
39. 39.        HAL_FLASH_Unlock();
    & o! j1 G- |9 {3 z4 j% f
40. 40.   
    $ s4 Z6 k/ {3 {+ W2 s4 w
41. 41.        for (i = 0; i < _ulSize / 32; i++)   
    ; ]8 Y' `% `9 x8 x* y% _" y
42. 42.        {
    " B& A& Y/ a" c9 |! K* B. Z4 [
43. 43.            uint64_t FlashWord[4];
    ; z; }; _+ i# l! P2 F
44. 44.            
    5 E  |/ N6 ?  Y5 o! y( x, n
45. 45.            memcpy((char *)FlashWord, _ucpSrc, 32);
    + G( ^+ I& P( h$ B$ |8 Z$ ?
46. 46.            _ucpSrc += 32;
    3 u) {$ o! B) @8 O# f& ]; |* n
47. 47.            
    
48. 48.            if (HAL_FLASH_Program(FLASH_TYPEPROGRAM_FLASHWORD, _ulFlashAddr,
    8 L3 B" [. e3 b; {. s+ j6 l7 r
49. 49.                                      (uint64_t)((uint32_t)FlashWord)) == HAL_OK)
    , M; H3 [( U# q0 `
50. 50.            {
    * e# S$ J5 g% M9 M) K
51. 51.                _ulFlashAddr = _ulFlashAddr + 32; /* 递增，操作下一个256bit */               
    
52. 52.            }        
    - z$ d4 F8 a) O8 l8 D0 ^3 M
53. 53.            else
    & m' n# U4 x2 \$ \
54. 54.            {
    
55. 55.                goto err;
    
56. 56.            }
    
57. 57.        }
    
58. 58.        
    
59. 59.        /* 长度不是32字节整数倍 */
    
60. 60.        if (_ulSize % 32)
    ( j9 ~. \' ?9 t5 q. R5 l
61. 61.        {
    3 W8 ~( h: u* }9 W! R* C; `
62. 62.            uint64_t FlashWord[4];
    
63. 63.            
    
64. 64.            FlashWord[0] = 0;
    9 I+ ~$ |  ]& ^, n, Z% h; z# |
65. 65.            FlashWord[1] = 0;
    " ]( J2 z7 G9 W4 U
66. 66.            FlashWord[2] = 0;
    
67. 67.            FlashWord[3] = 0;
    
68. 68.            memcpy((char *)FlashWord, _ucpSrc, _ulSize % 32);
    
69. 69.            if (HAL_FLASH_Program(FLASH_TYPEPROGRAM_FLASHWORD, _ulFlashAddr,
    " U6 v1 d! k; B) a' F# j' R4 ^
70. 70.                                               (uint64_t)((uint32_t)FlashWord)) == HAL_OK)
    
71. 71.            {
    
72. 72.                ; // _ulFlashAddr = _ulFlashAddr + 32;
    ; _; b' ]: ]# I7 Y
73. 73.               
    # I0 r: e$ T) m* {9 I0 o# E" X; W
74. 74.            }        
    4 H, y/ ?1 a( J3 ]8 _4 [
75. 75.            else
    ) ?% T( T  {" V8 }4 I
76. 76.            {
    ) {) K- g: e+ O# T3 D
77. 77.                goto err;
    ( U& Y4 y7 |& l
78. 78.            }
    
79. 79.        }
    
80. 80.        
    
81. 81.          /* Flash 加锁，禁止写Flash控制寄存器 */
    
82. 82.          HAL_FLASH_Lock();
    
83. 83.   
    
84. 84.          __set_PRIMASK(0);          /* 开中断 */
    
85. 85.   
    
86. 86.        return 0;
    0 \1 `- g" O6 V! Q* S4 v, U" v: D5 P
87. 87.        
    
88. 88.    err:
    
89. 89.          /* Flash 加锁，禁止写Flash控制寄存器 */
    
90. 90.          HAL_FLASH_Lock();
    4 @- F# y. l1 T. y7 e  d7 |1 z! [
91. 91.   
    + v, r0 M0 L5 g- @( Z! d
92. 92.          __set_PRIMASK(0);          /* 开中断 */
    
93. 93.   
    
94. 94.        return 1;
    ) S- D! Y& M9 Z3 k2 P! N6 ^1 w
95. 95.    }
    9 q# G, s9 x/ R; w6 t

复制代码

关于此函数有几个要点：

  第1个参数必须32字节对齐，即要编程的Flash地址对32求余为0。
  第3个参数必须是32字节的整数倍，长度不是32字节整数倍时，最后几个字节补0写入。
  第29行，函数bsp_CmpCpuFlash放在这里只有一个作用，判断将要写入的数据是否已经在内部Flash存在，如果已经存在，无需重复写入，直接返回。
  第36行，做了一个关中断操作，这里有个知识点要给大家普及下，由于H7的BANK1和BANK2是独立的，当前正在擦除的扇区所处的BANK会停止所有在此BANK执行的程序，包含中断也会停止执行。比如当前的应用程序都在BANK1，如果要擦除或者编程BANK2，是不会不影响BANK1里面执行的程序。这里安全起见加上了开关中断。
  第41到57行，先将32字节整数倍的数据通过函数HAL_FLASH_Program编程，此函数每次可以固定编程32字节数据。
. n" L9 V2 w* k  R: `; c* w. Y  第60到79行，将剩余不足32字节的数据补0，凑齐32字节编程。
71.2.3 内部Flash读取的实现
2 q) B! K: Z- L& ]8 E4 t内部Flash数据读取比较简单，采用总线方式读取，跟访问内部RAM是一样的。比如要读取地址

0x08100000里面的一个32bit变量，我们就可以：

变量 = *(uint32_t *)(0x08100000)
4 ^/ B  f. r& v7 l1 h
( J+ u! [( l. K! y6 x6 w为了方便起见，也专门准备了一个函数：
* d: a5 O4 d/ A% o. F/ y
9 E- X. b4 @6 x! |% W! F1 \8 Z

1. /*
   
2. *********************************************************************************************************
   
3. *    函 数 名: bsp_ReadCpuFlash
   
4. *    功能说明: 读取CPU Flash的内容
   - a3 }8 P1 K- p# j4 v7 V
5. *    形    参:  _ucpDst : 目标缓冲区
   
6. *             _ulFlashAddr : 起始地址
   
7. *             _ulSize : 数据大小（单位是字节）
   
8. *    返 回 值: 0=成功，1=失败
   5 }) h1 ]/ V# ?) a* H5 {, q9 W: o
9. *********************************************************************************************************
   ( {6 c1 Q& l: d3 p7 I; }7 n
10. */
    ' V4 Q3 F0 @1 S% I5 W$ k; B
11. uint8_t bsp_ReadCpuFlash(uint32_t _ulFlashAddr, uint8_t *_ucpDst, uint32_t _ulSize)
    
12. {
    
13.     uint32_t i;
    $ E  R) c/ r8 V4 e# u# u
14. 
    
15.     if (_ulFlashAddr + _ulSize > CPU_FLASH_BASE_ADDR + CPU_FLASH_SIZE)
    ( M& e9 t' p6 Y
16.     {
    
17.         return 1;
    , T* ]+ D1 B6 T! \& d
18.     }
    8 g! `& w) U# D0 g5 A
19. 
    
20.     /* 长度为0时不继续操作,否则起始地址为奇地址会出错 */
    1 {5 A0 T# V2 i: T  k/ c
21.     if (_ulSize == 0)
    " o1 h) `* i5 H  t8 q# `
22.     {
    / S' H; f9 A  \
23.         return 1;
    
24.     }
    
25. 
    
26.     for (i = 0; i < _ulSize; i++)
    
27.     {
    : r4 f) s4 H6 c
28.         *_ucpDst++ = *(uint8_t *)_ulFlashAddr++;
    
29.     }
    ; Q( T% d7 C& I9 e
30. 
    
31.     return 0;
    
32. }
    # `! ~3 M+ V" A8 A3 v; M1 f

复制代码

+ {. o& S, A7 ?8 ?
71.2.4 告诉编译器使用的扇区（重要）
使用内部Flash模拟EEPROM切不可随意定义一个扇区使用。因为编译器并不知道用户使用了这个扇区，导致应用程序也会编程到此扇区里面，所以就需要告诉编译器。
6 W) P0 W) P6 j
8 l2 V8 y1 j+ F8 x3 ]告诉MDK的方法如下（0x0810 0000是H7的BANK2首地址）：

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

复制代码

告诉IAR的方法如下：

1. #pragma location=0x08100000
   
2. const uint8_t para_flash_area[128*1024];
   ) l7 {1 [( U: L' W" N

复制代码

: Q/ A3 ^' R' H0 v$ J! f! s这里有两点特别注意：
2 k% {. W& _' S* m& X* _; \
9 C( p9 Z  b* s8 F- Q" a. U# i  模拟EEPROM的扇区可以定义到从第2个扇区开始的任何扇区，但不可以定义到首扇区，因为这个扇区是默认的boot启动地址。
& K/ Z6 U3 Z( E  如果应用程序不大的话，不推荐定义到末尾扇区，以MDK为例，定义到末尾扇区后，会导致整个Flash空间都被使用，从而让程序下载下载时间变长。
71.3 模拟EEPROM板级支持包（bsp_cpu_flash.c）
; B# h( ~. e$ y1 g5 h1 f% d模拟EEPROM的驱动文件bsp_cpu_flash.c主要实现了如下几个API供用户调用：

  bsp_GetSector
% W; n) [8 _$ r0 m* \. ?  bsp_ReadCpuFlash
9 g( }& S2 \# S1 I  bsp_CmpCpuFlash
  bsp_EraseCpuFlash
  bsp_WriteCpuFlash
71.3.1 函数bsp_GetSector
  {& w# E( H, p( F函数原型：

1. uint32_t bsp_GetSector(uint32_t Address)

复制代码

函数描述：
- x, _$ y7 x7 k9 }! w
  N* ]& |6 g4 |6 k. W1 T/ i2 O- M0 y此函数主要用于获取给定地址所处的扇区。

函数参数：

  第1个参数是用户给定的地址。
9 `- R$ _; B1 \/ d* a5 q+ ?0 Y  返回值，范围FLASH_SECTOR_0到FLASH_SECTOR_7。
2 y3 E) Q2 p; P' V8 U71.3.2 函数bsp_ReadCpuFlash
函数原型：

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

复制代码

& d) y' G/ H7 _, [: l函数描述：

此函数用于从内部Flash读取数据

, E) _) s% R- z0 r) l) `函数参数：
: C# I+ C' ^" F3 T6 t7 ]
# C% r. l4 F3 K3 k, Q  第1个参数读取的起始地址。
  第2个参数是读取数据的存储地址
3 m: L2 W# O8 M+ a  B  第3个参数是读取数据的大小，单位字节。
6 M2 l% C& V" ?7 Q) d! l+ ]: p  返回值，0表示成功，1表示失败。
71.3.3 函数bsp_CmpCpuFlash
+ G! m5 N  t" @2 `: R" T函数原型：

% N0 i( }+ y* E- m$ d. n* e2 s: iuint8_t bsp_CmpCpuFlash(uint32_t _ulFlashAddr, uint8_t *_ucpBuf, uint32_t _ulSize)
! ]' F; Q' h6 e1 J" n" g
函数描述：
0 L; @) s' g. a) U5 Y
要编程的数据是否在内部Flash已经存在。

- ]+ l: m/ Q! M- s% Q函数参数：
6 a" I8 `4 ?0 b6 A
  第1个参数是内部Flash地址。
  第2个参数是缓冲区地址。
  第3个参数是数据大小，单位字节。
2 d2 d% }) o! k7 c7 w% @4 u6 ?  返回值：
2 u* ^, V) m4 H1 f7 S; L' \5 ?FLASH_IS_EQU               0   Flash内容和待写入的数据相等，不需要擦除和写操作。

FLASH_REQ_WRITE          1     Flash不需要擦除，直接写。
1 ]6 A( y4 G# W
7 ~8 G' \6 X6 U. ]FLASH_REQ_ERASE          2     Flash需要先擦除,再写。
) d9 K8 J: b, @  e. O; U/ `
FLASH_PARAM_ERR         3     函数参数错误。
9 d2 r6 E4 _4 v0 ]
71.3.4 函数bsp_EraseCpuFlash
函数原型：

0 T: C" L( E8 B% _8 V% |uint8_t bsp_EraseCpuFlash(uint32_t _ulFlashAddr)

0 O' ^$ k0 }* F5 C5 S! S! q8 F函数描述：

) Q* G  C; @1 Y' H3 R6 W此函数用于擦除一个扇区，大小128KB
9 T. F1 L6 u% c: \/ R
函数参数：

  第1个参数要擦除的扇区地址，可以是此扇区范围内的任意值，一般填扇区首地址即可。
  返回值：
# E# ?  v3 p( R* E) i. R" FHAL_OK        = 0x00

HAL_ERROR    = 0x01
5 {; q: \7 o7 C
HAL_BUSY      = 0x02

: b& k  ]8 `6 E" x- PHAL_TIMEOUT  = 0x03
1 u* Q/ A9 R0 f% e5 ~1 A" V
71.3.5 函数bsp_WriteCpuFlash
; W" ]/ c+ \2 c7 N9 E函数原型：

uint8_t bsp_WriteCpuFlash(uint32_t _ulFlashAddr, uint8_t *_ucpSrc, uint32_t _ulSize)

函数描述：

. b1 Z" i- h2 h1 h, |" l/ v此函数用于编程数据到内部Flash。

函数参数：

% b) j3 U2 y( h/ s1 ]4 n  第1个参数是要编程的内部Flash地址。
7 n1 L, Q1 P  t4 H' P7 [; @( u+ I  第2个参数是数据缓冲区地址。
0 N9 [. r- N, r7 L  第3个参数是数据大小，单位字节。
  返回值，0-成功，1-数据长度或地址溢出，2-写Flash出错(估计Flash寿命到)。
注意事项：
/ j3 Y! e5 }8 m# s( g% V) j9 d* b
! {1 f8 J. x7 |- [  第1个参数必须32字节对齐，即要编程的Flash地址对32求余为0。
. Y! s' ~; {; b; {  第3个参数必须是32字节的整数倍，长度不是32字节整数倍时，此函数会将几个字节补0写入
' r- R5 M% b% U2 @1 J71.4 模拟EEPROM驱动移植和使用
模拟EEPROM移植步骤如下：
/ H; Z7 X! @) ~3 B2 w" m
1 b( g; Z1 E) z" @( d1 P$ G  第1步：复制bsp_cpu_flash.c和bsp_cpu_flash.h到自己的工程目录，并添加到工程里面。
% o& ?# k: z) Q# G; R# z6 N  第2步：Flash驱动文件主要用到HAL库的Flash驱动文件，简单省事些可以添加所有HAL库C源文件进来。
  第3步，应用方法看本章节配套例子即可。
& h8 @  K. E0 \7 d. I8 v71.5 实验例程设计框架
通过程序设计框架，让大家先对配套例程有一个全面的认识，然后再理解细节，本次实验例程的设计框架如下：
2 A2 n: t9 k* p3 ?3 ^% z

  第1阶段，上电启动阶段：

) ]0 \9 [: v, U$ A9 }/ H这部分在第14章进行了详细说明。
1 a9 b( {* E) i  第2阶段，进入main函数：

  第1部分，硬件初始化，主要是MPU，Cache，HAL库，系统时钟，滴答定时器和LED。
  第2部分，应用程序设计部分，实现内部Flash模拟EEPROM。
5 c$ N4 P, Q& u6 ^6 Z71.6 实验例程说明（MDK）
) g2 j+ N7 C- g9 S8 {) l! B$ K- [配套例子：
) y( ?& [8 `" r4 M" V
) S3 R' i" l/ b) y" Q1 ZV7-049_内部Flash模拟EEPROM
8 B# H" g5 v1 j, D/ X' x( @  `
5 s5 z% n1 ?# J实验目的：

学习内部Flash模拟EEPROM。
. G" p7 _1 k0 Z* Y7 T9 U0 `实验内容：

使用内部Flash模拟EEPROM，务必告诉编译要使用的存储空间，防止这个空间存入了程序。
对于同一个地址空间，仅支持一次编程(不推荐二次编程，即使是将相应bit由数值1编程0)。
只能对已经擦除的空间做编程，擦除1个扇区是128KB。
H7的Flash编程时，务必保证要编程的地址是32字节对齐的，即此地址对32求余为0。
并且编程的数据必须32字节整数倍，函数bsp_WriteCpuFlash对字节数不够32字节整数倍的情况自动补0。
$ A+ f: Z, W3 B( e+ q4 w; i) u
实验操作：
+ Z/ A1 p7 D8 U* ?9 [& Z
K1键按下，将8bit，16bit和32bit数据写入到内部Flash。
$ h; ?. ~& O; x5 `: p7 tK2键按下，将结构体数据写入到内部Flash。
上电后串口打印的信息：
* j; ]7 f. I4 a1 G3 ]0 \! e
波特率 115200，数据位 8，奇偶校验位无，停止位 1。
! Z+ h7 {5 Z6 E1 h8 k; v9 h3 [  F& H
8 t4 D4 W  G- j

程序设计：
6 Z) m/ I8 h2 R/ u
1 q: Z5 q) P) F/ k$ M  系统栈大小分配：

5 h- r/ X5 m  [# K0 x- c

  RAM空间用的DTCM：
0 b8 \( ~; k6 s6 M8 l* S( f0 J" C
8 W3 L% P' x+ Z! C. u' b4 l. g

$ G1 s) r. z$ Z' E6 c: q) C
  硬件外设初始化

硬件外设的初始化是在 bsp.c 文件实现：
9 [+ m4 R3 u- U" x! T: U2 ^
% y/ G) U( g0 a

1. /*
   
2. *********************************************************************************************************
   / e- g# C' P! G
3. *    函 数 名: bsp_Init
   
4. *    功能说明: 初始化所有的硬件设备。该函数配置CPU寄存器和外设的寄存器并初始化一些全局变量。只需要调用一次
   ( N: ?) L+ n0 M2 T' j+ L, f2 j
5. *    形    参：无
   8 Q7 u2 g( N. Z
6. *    返 回 值: 无
   
7. *********************************************************************************************************
   
8. */
   & @" i4 h8 w- H" P  {6 `& @
9. void bsp_Init(void)
     U) w/ v: L% t6 C* b& R$ B8 k
10. {
    5 j7 u  M( m: u3 U
11.     /* 配置MPU */
    ) H5 \. g. V( `: E9 G: d
12.     MPU_Config();
    3 T  [& ?2 |0 J  e: v" ?
13. 
    4 O( [8 d3 T! J2 m  X
14.     /* 使能L1 Cache */
    ' r5 B9 E4 }0 U, e; ~3 h
15.     CPU_CACHE_Enable();
    . R: ^* G" K) N- ^, j' k
16. 
    
17.     /*
    
18.        STM32H7xx HAL 库初始化，此时系统用的还是H7自带的64MHz，HSI时钟:
    4 z; ?6 E; G- z& ]# [
19.        - 调用函数HAL_InitTick，初始化滴答时钟中断1ms。
    ' \, F" n- n" X
20.        - 设置NVIV优先级分组为4。
      y6 k. z' z5 [: F& ?* v0 ]
21.      */
    ! g0 t( \# A" C( h) B
22.     HAL_Init();
    
23. 
    8 f( A1 F0 P2 I1 b$ y
24.     /*
    4 O1 K2 M( W2 }6 [
25.        配置系统时钟到400MHz
    
26.        - 切换使用HSE。
    3 b  c) P7 n3 x4 d4 g
27.        - 此函数会更新全局变量SystemCoreClock，并重新配置HAL_InitTick。
    , V5 m" H# P5 R
28.     */
    
29.     SystemClock_Config();
    
30. 
    
31.     /*
    2 ?6 j, b/ X7 _& W
32.        Event Recorder：
    1 l7 x+ g! ~7 h$ i! w0 ]3 {% O4 E( Y
33.        - 可用于代码执行时间测量，MDK5.25及其以上版本才支持，IAR不支持。
    
34.        - 默认不开启，如果要使能此选项，务必看V7开发板用户手册第xx章
    
35.     */   
    
36. #if Enable_EventRecorder == 1  
    , g$ S+ }$ s# H0 }) D
37.     /* 初始化EventRecorder并开启 */
    " F. b& D7 Q. P
38.     EventRecorderInitialize(EventRecordAll, 1U);
    ; u2 d6 Z- p8 o+ Z+ [3 ~
39.     EventRecorderStart();
    ! y* |. t( F* R1 x
40. #endif
    . P8 c; O5 v! g+ M. D1 M
41. 
    $ c& S3 n* k9 w! o1 a
42. bsp_InitDWT();      /* 初始化DWT时钟周期计数器 */      
    
43.     bsp_InitKey();        /* 按键初始化，要放在滴答定时器之前，因为按钮检测是通过滴答定时器扫描 */
    1 q  d7 d, w3 z/ N; Q+ \( v
44.     bsp_InitTimer();      /* 初始化滴答定时器 */
    9 |" l! |4 G/ H6 }$ {
45.     bsp_InitLPUart();    /* 初始化串口 */
    
46.     bsp_InitExtIO();    /* 初始化FMC总线74HC574扩展IO. 必须在 bsp_InitLed()前执行 */   
    * E/ i4 _: R5 H0 J. C, a
47.     bsp_InitLed();        /* 初始化LED */   
    " M' l3 N3 }: o. \. d7 i  A
48.     bsp_InitExtSDRAM(); /* 初始化SDRAM */
    # m& T" i  ^3 `* a( z
49. }
    

复制代码

7 u( z. M  Q0 U2 e4 d% W& ]4 }  MPU配置和Cache配置：
. G  _$ o  C' a* j. ?% W3 g& G
数据Cache和指令Cache都开启。配置了AXI SRAM区（本例子未用到AXI SRAM）和FMC的扩展IO区。

; X1 h, _) B- N8 V1 N

1. /*
   
2. *********************************************************************************************************
   
3. *    函 数 名: MPU_Config
   ) h4 K& `) T. P5 \2 E6 B
4. *    功能说明: 配置MPU
   / |1 i0 V0 Q6 i' o5 o: _# E
5. *    形    参: 无
   
6. *    返 回 值: 无
   & X9 x) ~. R+ c% w, J7 |. V4 }
7. *********************************************************************************************************
   
8. */
   
9. static void MPU_Config( void )
   
10. {
    ! j. ]2 T2 O; ^! ]# [7 ?9 A
11.     MPU_Region_InitTypeDef MPU_InitStruct;
    
12. 
      C* d9 L6 G5 h
13.     /* 禁止 MPU */
    
14.     HAL_MPU_Disable();
    3 K. I1 v8 X  G' y- w
15. 
    ; J2 h* d; F0 Q, V6 c
16.     /* 配置AXI SRAM的MPU属性为Write back, Read allocate，Write allocate */
    
17.     MPU_InitStruct.Enable           = MPU_REGION_ENABLE;
    
18.     MPU_InitStruct.BaseAddress      = 0x24000000;
    - G7 p9 N3 }% n+ k4 k- ^( W0 p
19.     MPU_InitStruct.Size             = MPU_REGION_SIZE_512KB;
    
20.     MPU_InitStruct.AccessPermission = MPU_REGION_FULL_ACCESS;
    
21.     MPU_InitStruct.IsBufferable     = MPU_ACCESS_BUFFERABLE;
    1 H3 b; W8 v. R
22.     MPU_InitStruct.IsCacheable      = MPU_ACCESS_CACHEABLE;
    $ B2 U8 @3 d! Y2 a% O
23.     MPU_InitStruct.IsShareable      = MPU_ACCESS_NOT_SHAREABLE;
    % l8 B6 }0 `, g7 w+ V4 ]* Z
24.     MPU_InitStruct.Number           = MPU_REGION_NUMBER0;
    0 l3 F& `' [0 S4 ~) w( B
25.     MPU_InitStruct.TypeExtField     = MPU_TEX_LEVEL1;
    : Y! o3 i2 s9 k+ o1 I( ~9 N* ^8 t
26.     MPU_InitStruct.SubRegionDisable = 0x00;
    ( Y: Z1 w& X6 X, y/ }* Y( k2 [
27.     MPU_InitStruct.DisableExec      = MPU_INSTRUCTION_ACCESS_ENABLE;
    $ Z2 E* E* c9 k7 W! u: [1 {. `% C/ \
28. 
    1 f0 E9 m6 x7 y, u8 Z
29.     HAL_MPU_ConfigRegion(&MPU_InitStruct);
    7 p/ ^) M! \+ z+ ?' W2 p3 @
30. 
    
31. 
    
32.     /* 配置FMC扩展IO的MPU属性为Device或者Strongly Ordered */
    
33.     MPU_InitStruct.Enable           = MPU_REGION_ENABLE;
    ) ?9 O" P, z: F- ?
34.     MPU_InitStruct.BaseAddress      = 0x60000000;
    
35.     MPU_InitStruct.Size             = ARM_MPU_REGION_SIZE_64KB;   
    . i, J% s( |  P, Q
36.     MPU_InitStruct.AccessPermission = MPU_REGION_FULL_ACCESS;
    
37.     MPU_InitStruct.IsBufferable     = MPU_ACCESS_BUFFERABLE;
    . J% ?, Q2 @! M+ _
38.     MPU_InitStruct.IsCacheable      = MPU_ACCESS_NOT_CACHEABLE;   
    
39.     MPU_InitStruct.IsShareable      = MPU_ACCESS_NOT_SHAREABLE;
    
40.     MPU_InitStruct.Number           = MPU_REGION_NUMBER1;
    ( A0 S% c; o9 A& `9 {( `7 d
41.     MPU_InitStruct.TypeExtField     = MPU_TEX_LEVEL0;
    
42.     MPU_InitStruct.SubRegionDisable = 0x00;
    
43.     MPU_InitStruct.DisableExec      = MPU_INSTRUCTION_ACCESS_ENABLE;
    ( w. o0 q8 w' l5 A# M6 A2 L; Y: @4 \
44. 
    0 N3 D5 S/ g2 Q9 X3 G0 C, t
45.     HAL_MPU_ConfigRegion(&MPU_InitStruct);
    
46. 
    $ r3 v9 v8 C! l4 N* `: @  ?$ G
47.     /*使能 MPU */
    
48.     HAL_MPU_Enable(MPU_PRIVILEGED_DEFAULT);
    
49. }
    6 \. R* {/ |; H! Q
50. 
    
51. /*
    : ^1 e# Q7 L$ q2 V$ }
52. *********************************************************************************************************
    
53. *    函 数 名: CPU_CACHE_Enable
    
54. *    功能说明: 使能L1 Cache
    
55. *    形    参: 无
    
56. *    返 回 值: 无
    4 ^' z# s  c# R& G2 }, s: ~2 v- P
57. *********************************************************************************************************
    
58. */
    
59. static void CPU_CACHE_Enable(void)
    
60. {
    
61.     /* 使能 I-Cache */
    9 |, Q) N( s2 Q, a6 J# F' w5 ]) O
62.     SCB_EnableICache();
    
63. 
    
64.     /* 使能 D-Cache */
    
65.     SCB_EnableDCache();
    
66. }

复制代码

8 W2 h- ?! b( E, K0 T
' [+ A( E% ^2 w/ j+ Y  每10ms调用一次蜂鸣器处理：
  A  M, l5 r: [% I( U6 k$ c2 {; l
蜂鸣器处理是在滴答定时器中断里面实现，每10ms执行一次检测。

1. /*
   
2. *********************************************************************************************************
   0 W1 \$ y3 _2 R  [5 Z2 k
3. *    函 数 名: bsp_RunPer10ms
   
4. *    功能说明: 该函数每隔10ms被Systick中断调用1次。详见 bsp_timer.c的定时中断服务程序。一些处理时间要求
   ; q2 B7 U9 T  t  m! ?5 M0 B
5. *              不严格的任务可以放在此函数。比如：按键扫描、蜂鸣器鸣叫控制等。
   7 p& G; E# l! H! b4 W
6. *    形    参: 无
   " M; h" O& E! f. C
7. *    返 回 值: 无
   
8. *********************************************************************************************************
   ! z5 ~  u4 {, [& A
9. */
   
10. void bsp_RunPer10ms(void)
    
11. {
    , `, G0 M# a) h' U4 m
12.     bsp_KeyScan10ms();
    " A8 @0 K. j' s, X/ a0 E" ]
13. }
    

复制代码

  主功能：
8 V, o. `9 t3 J+ U- s  [- ^2 I
+ J) v' b6 ~+ b+ ^# M主程序实现如下操作：
! z+ n) y3 r& ?: o! E
8 O6 n5 ^% h( [2 R/ A# @( k  启动一个自动重装软件定时器，每100ms翻转一次LED2。
: A+ {( J: K; l2 f  K1键按下，将8bit，16bit和32bit数据写入到内部Flash。
  K2键按下，将结构体数据写入到内部Flash。

1. /*
   . B( ^  y5 K- b) P+ ~( h
2. *********************************************************************************************************
   7 H1 i. q  L' X+ K. |
3. *    函 数 名: main
   
4. *    功能说明: c程序入口
   + \1 K  z9 q* {$ J
5. *    形    参: 无
   
6. *    返 回 值: 错误代码(无需处理)
   " U" h+ T+ l  c9 @: j
7. *********************************************************************************************************
   
8. */
   
9. int main(void)
   
10. {
    
11.     uint8_t ucKeyCode;    /* 按键代码 */
    8 W/ ^, b1 y! M/ m+ F$ D( V1 E" Y
12.     uint8_t  ucTest, *ptr8;
    
13.     uint16_t uiTest, *ptr16;
    3 G4 O8 p2 T, Y  w# q; _; i; h
14.     uint32_t ulTest, *ptr32;
    
15.     PARAM_T tPara, *paraptr;
    
16. 
    3 S' C0 ^, X% ^( f
17. 
    
18.     /* 初始化数据 */
    # ~! l& X* B* Q5 v' R9 O7 z
19.     tPara.Baud485 = 0x5555AAAA;
    - W+ T! s% E5 K2 u- G9 V* }' O% ?
20.     tPara.ParamVer = 0x99;
    . R; S5 v* W, q
21.     tPara.ucBackLight = 0x7788;
    0 n( a' H% ?0 X% G2 M
22.     tPara.ucRadioMode = 99.99f;
    
23. 
    
24. 
    * y/ F7 C6 Z: @! s, j
25.     bsp_Init();        /* 硬件初始化 */
    ' [" D' G+ f' ~
26.     PrintfLogo();    /* 打印例程名称和版本等信息 */
    ( p* F! @% {+ {* Q4 U( ^" S
27.     PrintfHelp();    /* 打印操作提示 */
    # b/ j/ ?9 a6 E6 W3 ~# }- P- f0 O# U
28. 
    . Y5 C( m5 E- Q. N3 D
29.     bsp_StartAutoTimer(0, 100);    /* 启动1个100ms的自动重装的定时器 */
    
30.     while (1)
    ! A% }/ M) T9 @4 G& e$ @$ o% @
31.     {
    
32.         bsp_Idle();        /* 这个函数在bsp.c文件。用户可以修改这个函数实现CPU休眠和喂狗 */
    
33. 
    ) }! p( ?5 c; p1 v3 c2 u( k
34.         /* 判断定时器超时时间 */
    0 o. c& }& n2 s% v2 f0 }0 E( ~
35.         if (bsp_CheckTimer(0))   
    % I" T# [9 U1 P6 ?0 K4 h2 B
36.         {
    - p, i- {) ?: p6 C2 r) E# l
37.             /* 每隔100ms 进来一次 */  
    2 p$ T! k& T" m2 b! p/ w+ i8 j
38.             bsp_LedToggle(2);
    : T/ _5 E8 ^+ W
39.         }
    * a" r- }3 j) k: N; ?% R
40. 
    : q' g$ x  R# r
41.         /* 按键滤波和检测由后台systick中断服务程序实现，我们只需要调用bsp_GetKey读取键值即可。 */
    
42.         ucKeyCode = bsp_GetKey();    /* 读取键值, 无键按下时返回 KEY_NONE = 0 */
    
43.         if (ucKeyCode != KEY_NONE)
    # f7 X* f5 t! L8 Q) g7 T  T& N
44.         {
      p- b- A% t* f8 r9 a6 y9 ]$ K
45.             switch (ucKeyCode)
    
46.             {
    
47.                 case KEY_DOWN_K1:            /* K1键按下，将8bit，16bit和32bit数据写入到内部Flash */
    % w% ]/ M! v5 d  [  y
48. 
    ' d$ ]( n3 U8 w
49.                 /*
    
50.                  1、对于同一个地址空间，仅支持一次编程(不推荐二次编程，即使是将相应bit由数值1编程0)。
    
51.                  2、只能对已经擦除的空间做编程，擦除1个扇区是128KB。
    & n  `  j- ~+ _7 j2 X. n
52.                  3、H7的Flash编程时，务必保证要编程的地址是32字节对齐的，即此地址对32求余为0。并且编
    
53. 程的数据必须32字节整数倍。函数bsp_WriteCpuFlash对字节数不够32字节整数倍的情况自动补
    
54. 0。
    + z# x- d5 K$ o" c4 o5 f" \
55.                 */
    $ _# x# s+ H. N6 N8 n8 @
56.                      /* 擦除扇区 */
    ! J1 T5 I2 j3 z, Z1 {+ ?- E
57.                     bsp_EraseCpuFlash((uint32_t)para_flash_area);
    ; a2 h- y1 y9 J6 v1 p( D
58. 
    7 S) w  V9 `' y$ @! k. @
59.                     ucTest = 0xAA;
    , O& {0 E' i0 w' ~( a4 [! q3 I
60.                     uiTest = 0x55AA;
    
61.                     ulTest = 0x11223344;
      u# q- n) e2 H5 M) C
62. 
    1 t9 E' o4 }, X- J
63.                     /* 扇区写入数据 */
    
64.                     bsp_WriteCpuFlash((uint32_t)para_flash_area + 32*0,  (uint8_t *)&ucTest,
    
65. sizeof(ucTest));
    : l! t) W% _& n
66.                     bsp_WriteCpuFlash((uint32_t)para_flash_area + 32*1,  (uint8_t *)&uiTest,
      H5 L1 i* L; V/ S, a1 W% S
67. sizeof(uiTest));
    3 j& y" I2 _4 o* A0 a( m7 C+ X" N9 ?
68.                     bsp_WriteCpuFlash((uint32_t)para_flash_area + 32*2,  (uint8_t *)&ulTest,
    ( {2 b5 f* P  C! F: t
69. sizeof(ulTest));               
    
70. 
    - G. f  m; d  U0 R9 ~) c: w) @
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);
    ) F, r. R& o8 [; G" M. L5 l5 ]
75. 
    
76.                     printf("写入数据：ucTest = %x, uiTest = %x, ulTest = %x\r\n", ucTest, uiTest, ulTest);
    5 T. }/ B  }3 l: \- u
77.                     printf("读取数据：ptr8 = %x, ptr16 = %x, ptr32 = %x\r\n", *ptr8, *ptr16, *ptr32);
    
78. 
    
79.                     break;
    * C; L; x5 l5 j- F% E* b6 E
80. 
    
81.                 case KEY_DOWN_K2:            /* K2键按下， 将结构体数据写入到内部Flash */
    . p- o+ c2 E/ \; Z! [, V
82.                     /* 擦除扇区 */
    / r/ j! a) C" S; k  x) x. m3 z
83.                     bsp_EraseCpuFlash((uint32_t)para_flash_area);
    $ v/ k" X* ?3 N, O
84. 
    1 }2 h8 |0 y1 A! p% h3 p3 _9 `
85.                     /* 扇区写入数据 */
      c5 E* _: v& R
86.                     bsp_WriteCpuFlash((uint32_t)para_flash_area,  (uint8_t *)&tPara, sizeof(tPara));            
    - }9 Q! X% Q1 e* G
87. 
    ! _; l# k; o8 z/ X, I- D- S
88.                     /* 读出数据并打印 */
    
89.                     paraptr  = (PARAM_T  *)((uint32_t)para_flash_area);
    
90. 
    . W7 s- r1 a) {8 {4 j. Z; C  q1 T
91. 
    
92.                     printf("写入数据：Baud485=%x, ParamVer=%x, ucBackLight=%x, ucRadioMode=%f\r\n",
    3 k/ {) {) \" X9 R
93.                                                                        tPara.Baud485,
    
94.                                                                         tPara.ParamVer,
    $ z& F' v9 C  Z! o
95.                                                                         tPara.ucBackLight,
    
96.                                                                    paraptr->ucRadioMode);
    
97. 
    6 X7 W! Y0 B! s, P% F
98.                     printf("读取数据：Baud485=%x, ParamVer=%x, ucBackLight=%x, ucRadioMode=%f\r\n",
    2 _4 f5 Z' Q( V4 R% D' u4 Z
99.                                                                         paraptr->Baud485,
    ( I' }& c" ^3 {2 b" u& l+ P
100.                                                                             paraptr->ParamVer,
     - W: _6 X. B9 K
101.                                                                            paraptr->ucBackLight,
     0 y% W7 E: ~* z- B! f, [; @0 s
102.                                                                           paraptr->ucRadioMode);
     % q& B; e. [3 U4 L. o! }) m
103.                     break;               
     
104.                 default:
     
105.                     /* 其它的键值不处理 */
     
106.                     break;
     / l) u$ W& u' q4 D% K
107.             }
     
108.         }
     
109.     }
     
110. }
     $ X! s8 `  F+ p- e1 Z- ~. u

复制代码

% y# ~0 @; R( _7 k+ S. `
71.7 实验例程说明（IAR）
( S# N8 f4 m4 i' F# O! I配套例子：
$ ?9 A7 p7 [1 b7 p8 ^3 n
" u0 Z& n3 i1 d7 X* x) I" A- u9 AV7-049_内部Flash模拟EEPROM

1 p1 ^; i% U, o$ w实验目的：
$ r" t8 O9 F. f$ |# m: B4 m
学习内部Flash模拟EEPROM。
+ ?; z/ L7 @6 x9 ^2 @: A实验内容：

( f+ P1 e6 ^* ~0 Y3 R0 u% M1 A. W使用内部Flash模拟EEPROM，务必告诉编译要使用的存储空间，防止这个空间存入了程序。
4 _8 y7 s7 D0 U6 J$ i  A对于同一个地址空间，仅支持一次编程(不推荐二次编程，即使是将相应bit由数值1编程0)。
只能对已经擦除的空间做编程，擦除1个扇区是128KB。
' `7 X0 r8 c' ^+ PH7的Flash编程时，务必保证要编程的地址是32字节对齐的，即此地址对32求余为0。
并且编程的数据必须32字节整数倍，函数bsp_WriteCpuFlash对字节数不够32字节整数倍的情况自动补0。

- G, z- d( p$ B) o  ^( q- A; h实验操作：

K1键按下，将8bit，16bit和32bit数据写入到内部Flash。
K2键按下，将结构体数据写入到内部Flash。
上电后串口打印的信息：

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

/ X* B: Q% _9 K- E: H! b0 F/ L程序设计：

- R" a2 E3 t  n6 x5 b7 a/ R1 s0 V  系统栈大小分配：

# A  V& l5 M' R8 u9 n6 w

  RAM空间用的DTCM：

  硬件外设初始化
& s+ s7 J) s$ j- @
7 \# Q( N- r% R* S& \+ w! X: P硬件外设的初始化是在 bsp.c 文件实现：
( }4 }, Y& }( [( ?- l4 ]6 Q% ~3 t  A

1. /*
   
2. *********************************************************************************************************
   
3. *    函 数 名: bsp_Init
   
4. *    功能说明: 初始化所有的硬件设备。该函数配置CPU寄存器和外设的寄存器并初始化一些全局变量。只需要调用一次
   ; ]; }+ f) V1 _# a  }4 r
5. *    形    参：无
   + X9 ]. O1 }2 m( J  }* R. K+ \. i1 k4 W
6. *    返 回 值: 无
   
7. *********************************************************************************************************
   8 p9 @1 U* T8 T" n) X
8. */
   5 H: ]6 r0 ?, a
9. void bsp_Init(void)
   4 Y, q! u$ F. }
10. {
    1 c+ K  `( [9 e, e3 r
11.     /* 配置MPU */
    4 X$ e0 c! Z8 D- |+ ?- m
12.     MPU_Config();
    
13. 
    
14.     /* 使能L1 Cache */
    
15.     CPU_CACHE_Enable();
    
16. 
    2 k' z# M* S' k7 ~
17.     /*
    & q/ B/ V! {3 J- b7 l% B
18.        STM32H7xx HAL 库初始化，此时系统用的还是H7自带的64MHz，HSI时钟:
    
19.        - 调用函数HAL_InitTick，初始化滴答时钟中断1ms。
    
20.        - 设置NVIV优先级分组为4。
    / X& t) I4 S- c; V) u& M, I
21.      */
    ' r0 b" m8 V/ S# W2 X
22.     HAL_Init();
    
23. 
    + q( _, f. M/ T
24.     /*
    # ^+ }. ^8 d7 M" l# i- d7 G- w
25.        配置系统时钟到400MHz
    
26.        - 切换使用HSE。
    " u* @0 V0 f' f
27.        - 此函数会更新全局变量SystemCoreClock，并重新配置HAL_InitTick。
    " L( }: U8 {0 {4 t
28.     */
    
29.     SystemClock_Config();
    
30. 
    + s0 m/ r8 r. C: g
31.     /*
    
32.        Event Recorder：
    
33.        - 可用于代码执行时间测量，MDK5.25及其以上版本才支持，IAR不支持。
    # ^# @' K& {1 o# v3 T3 H/ r7 L
34.        - 默认不开启，如果要使能此选项，务必看V7开发板用户手册第xx章
    
35.     */   
    
36. #if Enable_EventRecorder == 1  
    
37.     /* 初始化EventRecorder并开启 */
    : @6 v$ [0 t7 v& A, k9 H, @# C
38.     EventRecorderInitialize(EventRecordAll, 1U);
    9 A# O9 u0 O% {# `  O2 b- t2 w
39.     EventRecorderStart();
    9 a1 Y# y; F8 g+ r
40. #endif
    9 G; \/ A& R) {& C# X2 v
41. 
    
42. bsp_InitDWT();      /* 初始化DWT时钟周期计数器 */      
    $ a$ m4 J& O  W+ t9 h( l! a0 |; h& N6 e( n
43.     bsp_InitKey();        /* 按键初始化，要放在滴答定时器之前，因为按钮检测是通过滴答定时器扫描 */
    * a! r+ m, P. t/ g
44.     bsp_InitTimer();      /* 初始化滴答定时器 */
      S3 h' C4 L8 Z3 ~8 Q
45.     bsp_InitLPUart();    /* 初始化串口 */
    
46.     bsp_InitExtIO();    /* 初始化FMC总线74HC574扩展IO. 必须在 bsp_InitLed()前执行 */   
    ) {# L, a3 u4 a; G
47.     bsp_InitLed();        /* 初始化LED */   
    
48.     bsp_InitExtSDRAM(); /* 初始化SDRAM */
    
49. }
    ; }/ m4 b) f+ R# `+ D  q6 K" o

复制代码

  MPU配置和Cache配置：

' N% ]  R) v* b数据Cache和指令Cache都开启。配置了AXI SRAM区（本例子未用到AXI SRAM）和FMC的扩展IO区。

1. /*
   ; A2 N; j1 q6 `+ Z& X7 a% M/ `
2. *********************************************************************************************************
   
3. *    函 数 名: MPU_Config
     d5 z% A$ ?# l7 [& V7 U' x0 B
4. *    功能说明: 配置MPU
   
5. *    形    参: 无
   + K8 |1 w  ^1 }7 v  b
6. *    返 回 值: 无
   
7. *********************************************************************************************************
   
8. */
   % r+ O6 g2 _4 P
9. static void MPU_Config( void )
   
10. {
    
11.     MPU_Region_InitTypeDef MPU_InitStruct;
    
12. 
    
13.     /* 禁止 MPU */
    
14.     HAL_MPU_Disable();
    
15. 
    
16.     /* 配置AXI SRAM的MPU属性为Write back, Read allocate，Write allocate */
    
17.     MPU_InitStruct.Enable           = MPU_REGION_ENABLE;
    8 H3 z7 o- \8 r  I) @
18.     MPU_InitStruct.BaseAddress      = 0x24000000;
    , }5 ~  ~  w5 O# S% C- ]& W
19.     MPU_InitStruct.Size             = MPU_REGION_SIZE_512KB;
    8 k) g+ C) Z+ C( S; D! B6 T
20.     MPU_InitStruct.AccessPermission = MPU_REGION_FULL_ACCESS;
    
21.     MPU_InitStruct.IsBufferable     = MPU_ACCESS_BUFFERABLE;
    & r; k4 R4 L/ g4 G
22.     MPU_InitStruct.IsCacheable      = MPU_ACCESS_CACHEABLE;
    
23.     MPU_InitStruct.IsShareable      = MPU_ACCESS_NOT_SHAREABLE;
    
24.     MPU_InitStruct.Number           = MPU_REGION_NUMBER0;
    + {( V  W. C$ ]$ s$ v; X
25.     MPU_InitStruct.TypeExtField     = MPU_TEX_LEVEL1;
      V4 f, c0 g  f! Z
26.     MPU_InitStruct.SubRegionDisable = 0x00;
    
27.     MPU_InitStruct.DisableExec      = MPU_INSTRUCTION_ACCESS_ENABLE;
    
28. 
    2 @6 Q7 f& O' j0 Y' n+ A% ~& X
29.     HAL_MPU_ConfigRegion(&MPU_InitStruct);
    / c9 p6 M$ R7 u- m( w' G$ R# W, {
30. 
    
31. 
    , H& i" p9 L; [1 q" M
32.     /* 配置FMC扩展IO的MPU属性为Device或者Strongly Ordered */
    
33.     MPU_InitStruct.Enable           = MPU_REGION_ENABLE;
    
34.     MPU_InitStruct.BaseAddress      = 0x60000000;
    
35.     MPU_InitStruct.Size             = ARM_MPU_REGION_SIZE_64KB;   
    
36.     MPU_InitStruct.AccessPermission = MPU_REGION_FULL_ACCESS;
    
37.     MPU_InitStruct.IsBufferable     = MPU_ACCESS_BUFFERABLE;
    
38.     MPU_InitStruct.IsCacheable      = MPU_ACCESS_NOT_CACHEABLE;   
    & I$ F: f0 p5 j. g
39.     MPU_InitStruct.IsShareable      = MPU_ACCESS_NOT_SHAREABLE;
    0 D$ V! G/ r" C' W
40.     MPU_InitStruct.Number           = MPU_REGION_NUMBER1;
    
41.     MPU_InitStruct.TypeExtField     = MPU_TEX_LEVEL0;
    9 n/ L  [; a# j; y* H$ m) ?' P5 f
42.     MPU_InitStruct.SubRegionDisable = 0x00;
    
43.     MPU_InitStruct.DisableExec      = MPU_INSTRUCTION_ACCESS_ENABLE;
    : q6 u5 w( g6 H, e
44. 
    1 }: v, D7 q1 i; \% R
45.     HAL_MPU_ConfigRegion(&MPU_InitStruct);
    
46. 
    
47.     /*使能 MPU */
    6 w! O) S5 f  s! k
48.     HAL_MPU_Enable(MPU_PRIVILEGED_DEFAULT);
    
49. }
    4 L9 E4 z0 N0 K8 I4 c$ q& U
50. 
    : U) p& v( R4 C8 z3 I+ x
51. /*
    - t3 ]9 p( j5 [; I3 I- k
52. *********************************************************************************************************
    1 s+ W0 h1 E% c; `0 j
53. *    函 数 名: CPU_CACHE_Enable
    , B7 X, U4 U$ {% j. L
54. *    功能说明: 使能L1 Cache
    % q) Q: Q4 o& b. Y- O9 ~
55. *    形    参: 无
    
56. *    返 回 值: 无
    
57. *********************************************************************************************************
    
58. */
    
59. static void CPU_CACHE_Enable(void)
    
60. {
    
61.     /* 使能 I-Cache */
    
62.     SCB_EnableICache();
    
63. 
    
64.     /* 使能 D-Cache */
    
65.     SCB_EnableDCache();
    
66. }

复制代码

8 ~$ J, J$ g+ G4 q# J
  每10ms调用一次蜂鸣器处理：

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

+ }' n  f1 b3 O, C

1. /*
   
2. *********************************************************************************************************
   5 }% R* @6 e% d! Y) k
3. *    函 数 名: bsp_RunPer10ms
   5 T* M6 n! J% h) v9 F4 o+ p4 R7 J" R
4. *    功能说明: 该函数每隔10ms被Systick中断调用1次。详见 bsp_timer.c的定时中断服务程序。一些处理时间要求
   
5. *              不严格的任务可以放在此函数。比如：按键扫描、蜂鸣器鸣叫控制等。
   
6. *    形    参: 无
   ; N1 B0 Q% [! P/ N9 o
7. *    返 回 值: 无
   
8. *********************************************************************************************************
   4 q- C; a5 b1 T, e1 ?( A0 x, Q
9. */
   6 }/ l. \6 v& F# Q& J( p4 \
10. void bsp_RunPer10ms(void)
    
11. {
    
12.     bsp_KeyScan10ms();
    
13. }
    

复制代码

# B7 w4 F% w) p7 ]9 l+ @$ v  主功能：
1 x& e8 E! o0 T: l$ G: ~, f
# G8 _( t  S& j% ^主程序实现如下操作：

启动一个自动重装软件定时器，每100ms翻转一次LED2。
K1键按下，将8bit，16bit和32bit数据写入到内部Flash。
K2键按下，将结构体数据写入到内部Flash。
+ U, M# [. I. G4 X9 u

1. /*
   
2. *********************************************************************************************************
   1 E4 e) m6 F& B
3. *    函 数 名: main
   
4. *    功能说明: c程序入口
   
5. *    形    参: 无
   4 ?4 h  ^7 }$ x, N5 z! D( p/ T" X( p
6. *    返 回 值: 错误代码(无需处理)
   
7. *********************************************************************************************************
   
8. */
   
9. int main(void)
   ! u% B5 I8 j1 L4 c2 P$ G" J
10. {
    % m6 o( ^) d$ z" ^
11.     uint8_t ucKeyCode;    /* 按键代码 */
    
12.     uint8_t  ucTest, *ptr8;
    * {& b& B; [& f+ H% t
13.     uint16_t uiTest, *ptr16;
      g0 T/ W1 V* p3 T" n' j
14.     uint32_t ulTest, *ptr32;
    5 M* r. k* K) B3 w9 K: B* N
15.     PARAM_T tPara, *paraptr;
      n; H* y1 I! [5 m8 Y6 L2 Q! F% g  X
16. 
    + l7 m7 r# c8 s+ z
17. 
    
18.     /* 初始化数据 */
    
19.     tPara.Baud485 = 0x5555AAAA;
    / i& i4 B6 b- J) U" a
20.     tPara.ParamVer = 0x99;
    
21.     tPara.ucBackLight = 0x7788;
    
22.     tPara.ucRadioMode = 99.99f;
    
23. 
    ! Z4 d3 ?+ T) @4 V( L0 R( z. m+ c
24. 
    : T, H3 G& |, s: C
25.     bsp_Init();        /* 硬件初始化 */
    
26.     PrintfLogo();    /* 打印例程名称和版本等信息 */
    
27.     PrintfHelp();    /* 打印操作提示 */
    
28. 
    4 @. u- K* s6 l- |2 u! s
29.     bsp_StartAutoTimer(0, 100);    /* 启动1个100ms的自动重装的定时器 */
    7 W* F9 e" e1 g4 R& M/ J8 d/ h
30.     while (1)
    
31.     {
    ! P* H' l8 u( }, T- M
32.         bsp_Idle();        /* 这个函数在bsp.c文件。用户可以修改这个函数实现CPU休眠和喂狗 */
    
33. 
    " x/ U4 s) }* b: Z" n# o4 ^5 Q9 f9 F
34.         /* 判断定时器超时时间 */
    
35.         if (bsp_CheckTimer(0))   
    2 k3 r2 n3 o; g( U& v0 _4 i
36.         {
    7 v* Z1 o, l* p% T4 R
37.             /* 每隔100ms 进来一次 */  
    
38.             bsp_LedToggle(2);
    & o, H  G3 _, B/ @
39.         }
    
40. 
    6 b! r4 X) s8 P2 v9 G
41.         /* 按键滤波和检测由后台systick中断服务程序实现，我们只需要调用bsp_GetKey读取键值即可。 */
    
42.         ucKeyCode = bsp_GetKey();    /* 读取键值, 无键按下时返回 KEY_NONE = 0 */
    
43.         if (ucKeyCode != KEY_NONE)
    7 b- O9 x2 B" a- K$ J; j( n; ~
44.         {
    8 x# J! j+ H: K3 u
45.             switch (ucKeyCode)
    5 t- H3 [$ C' N9 J
46.             {
    4 z" Z2 Q) b( ^* P+ B2 T, u. N/ k
47.                 case KEY_DOWN_K1:            /* K1键按下，将8bit，16bit和32bit数据写入到内部Flash */
    7 k+ n* e4 d6 n
48. 
    ) ^; S/ H- w; _9 L! j, k1 g
49.                 /*
    
50.                  1、对于同一个地址空间，仅支持一次编程(不推荐二次编程，即使是将相应bit由数值1编程0)。
    
51.                  2、只能对已经擦除的空间做编程，擦除1个扇区是128KB。
    2 Q9 o) f! Y0 c: c7 s6 n4 |, J8 F
52.                  3、H7的Flash编程时，务必保证要编程的地址是32字节对齐的，即此地址对32求余为0。并且编
    
53. 程的数据必须32字节整数倍。函数bsp_WriteCpuFlash对字节数不够32字节整数倍的情况自动补
    
54. 0。
    # w! M, g  \: O; f& d$ u0 b1 N
55.                 */
    
56.                      /* 擦除扇区 */
    7 a; H3 D% d% ~2 T
57.                     bsp_EraseCpuFlash((uint32_t)para_flash_area);
    
58. 
    & i& H, U- `& ~$ [; `
59.                     ucTest = 0xAA;
    
60.                     uiTest = 0x55AA;
    9 _. Z& b/ \. h9 U6 z1 J* D
61.                     ulTest = 0x11223344;
      t# ~$ J& i4 T( x* Y$ |; e
62. 
    5 [( S; l1 Y# m
63.                     /* 扇区写入数据 */
    
64.                     bsp_WriteCpuFlash((uint32_t)para_flash_area + 32*0,  (uint8_t *)&ucTest,
    
65. sizeof(ucTest));
    3 f2 U& \: N; K& L
66.                     bsp_WriteCpuFlash((uint32_t)para_flash_area + 32*1,  (uint8_t *)&uiTest,
    
67. sizeof(uiTest));
    " i. l; C7 G. C! Q2 d/ ]# g
68.                     bsp_WriteCpuFlash((uint32_t)para_flash_area + 32*2,  (uint8_t *)&ulTest,
    
69. sizeof(ulTest));               
    9 M' c" d: f# t% B% C
70. 
    
71.                     /* 读出数据并打印 */
    6 I; W& |6 L& T; {4 Q8 g" v1 K2 ^
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);
    ) K3 ]: D1 o8 i/ ~8 O3 L
75. 
    * D( K2 V$ k- C* j1 t* k5 E+ {. J
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;
    
80. 
    % @6 T* \5 o7 s) |5 I. a- V
81.                 case KEY_DOWN_K2:            /* K2键按下， 将结构体数据写入到内部Flash */
    3 r8 D" B+ i/ g- E4 |8 x/ `  X
82.                     /* 擦除扇区 */
    2 ?3 k5 [% ?: O0 e: i) p
83.                     bsp_EraseCpuFlash((uint32_t)para_flash_area);
    
84. 
    
85.                     /* 扇区写入数据 */
    
86.                     bsp_WriteCpuFlash((uint32_t)para_flash_area,  (uint8_t *)&tPara, sizeof(tPara));            
    
87. 
      ?% Z4 L- z! ~$ }( |. `
88.                     /* 读出数据并打印 */
    5 E9 U2 V, n( M
89.                     paraptr  = (PARAM_T  *)((uint32_t)para_flash_area);
      F( x( f$ o7 w( O
90. 
    * V: @  D9 a- J/ \: L0 m7 T
91. 
    , s) P/ F. k$ a5 L5 X
92.                     printf("写入数据：Baud485=%x, ParamVer=%x, ucBackLight=%x, ucRadioMode=%f\r\n",
    : z% ?/ i  `* q& X2 B- h0 @
93.                                                                        tPara.Baud485,
    
94.                                                                         tPara.ParamVer,
    
95.                                                                         tPara.ucBackLight,
    
96.                                                                    paraptr->ucRadioMode);
    0 Z" i5 Z2 S+ |
97. 
    9 Z% T* v6 D4 e" S# ^' y. V
98.                     printf("读取数据：Baud485=%x, ParamVer=%x, ucBackLight=%x, ucRadioMode=%f\r\n",
    0 K9 g! ]- @) @$ n, p
99.                                                                         paraptr->Baud485,
    ! x- M+ ~. b& D7 K: W) |) d
100.                                                                             paraptr->ParamVer,
     8 d- d5 d7 D$ Q
101.                                                                            paraptr->ucBackLight,
     
102.                                                                           paraptr->ucRadioMode);
     # _" }+ U' u! I1 _3 H- Y: P4 \: i
103.                     break;               
     
104.                 default:
     , z6 J8 [( @0 H! ]
105.                     /* 其它的键值不处理 */
     8 S- ~0 D$ Z# f& u9 G5 r) ^7 {. S
106.                     break;
     5 M: d/ f" L- \: f
107.             }
     $ D; d9 t, U" F9 F- V
108.         }
     , }: H4 [. I6 R) h3 @
109.     }
     - S( y) L+ e) g
110. }

复制代码

2 Q- n. ?0 z! [$ j! D' s

71.8 总结
$ V: G) B) V' Y! P* o; O' r5 A" W3 v% z本章节就为大家讲解这么多， 实际应用中的注意事项比较多，应用到项目之前务必实际测试熟悉下。

8 I! _5 ^1 T) ]& r/ A/ M4 R# P