71.1 初学者重要提示
  学习本章节前，务必优先学习第70章。
  使用内部Flash模拟EEPROM，务必告诉编译要使用的存储空间，防止这个空间存入了程序。
  STM32H7的Flash编程时，务必保证要编程的地址是32字节对齐的，即此地址对32求余为0。并且编程的数据必须32字节整数倍。
  STM32H743XI有两个独立的BANK，一个BANK的编程和擦除操作对另一个BANK没有任何影响。但是用户应用程序和要擦写的Flash扇区在同一个BANK，在执行擦写操作时，应用应用程序将停止运行，包括中断服务程序。
* o% Q. M9 z; T3 S2 X  使用内部Flash模拟EEPROM要做到先擦除后使用。
4 N5 N1 E, F6 E+ U2 t71.2 模拟EEPROM驱动设计
这里重点把内部Flash的读取，编程和擦除做个说明。

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

  第1步，获取擦除地址所处的扇区。
8 B/ x# V4 u' U  第2步，调用函数HAL_FLASH_Unlock解锁。
; g$ F8 D4 S$ @# y  第3步，调用函数HAL_FLASHEx_Erase擦除一个扇区。
3 b* T/ \2 D% x* r" `  第4步，调用函数HAL_FLASH_Lock上锁。
按照这个思路，程序实现如下：

1. 1.    /*
   " P$ I: ?7 J+ }8 T; ?
2. 2.    ******************************************************************************************************
   
3. 3.    *    函 数 名: bsp_EraseCpuFlash
   
4. 4.    *    功能说明: 擦除CPU FLASH一个扇区 （128KB)
   
5. 5.    *    形    参: _ulFlashAddr : Flash地址
   ( f- N& J) x  y" x' f9 {( D
6. 6.    *    返 回 值: 0 成功， 1 失败
   
7. 7.    *              HAL_OK       = 0x00,
   
8. 8.    *              HAL_ERROR    = 0x01,
   : C0 y9 t* v. ~9 V. d
9. 9.    *              HAL_BUSY     = 0x02,
   & V) |5 Q4 V! N) A8 k/ [) {
10. 10.    *              HAL_TIMEOUT  = 0x03
    4 w3 q5 t' z! F3 ~$ _" m
11. 11.    *
    
12. 12.    ******************************************************************************************************
    
13. 13.    */
    6 t! }; H  D5 I/ P* \+ ?$ ]6 E
14. 14.    uint8_t bsp_EraseCpuFlash(uint32_t _ulFlashAddr)
    2 F" j- d1 D5 X2 J( Z/ q8 b. T
15. 15.    {
    
16. 16.        uint32_t FirstSector = 0, NbOfSectors = 0;
    ! w% [' B4 c( _! k- E" l/ F5 L
17. 17.        FLASH_EraseInitTypeDef EraseInitStruct;
    
18. 18.        uint32_t SECTORError = 0;
    
19. 19.        uint8_t re;
    2 E5 b! h/ B" y, U# _% j1 T5 z4 L
20. 20.   
    ) M6 q# }* b8 A& B; ?1 _
21. 21.        /* 解锁 */
    . V3 P% q, l  a4 Y( J$ X5 V* y
22. 22.        HAL_FLASH_Unlock();
    5 P5 l. [/ ~7 s! v8 v& h
23. 23.        
    + d5 P8 b" Z7 {8 q: j
24. 24.        /* 获取此地址所在的扇区 */
    . t0 o' U  c9 T
25. 25.        FirstSector = bsp_GetSector(_ulFlashAddr);
    
26. 26.        
    
27. 27.        /* 固定1个扇区 */
    
28. 28.        NbOfSectors = 1;   
    
29. 29.   
    
30. 30.        /* 擦除扇区配置 */
    
31. 31.        EraseInitStruct.TypeErase     = FLASH_TYPEERASE_SECTORS;
    
32. 32.        EraseInitStruct.VoltageRange  = FLASH_VOLTAGE_RANGE_3;
      j" ?4 m/ Y- q6 X8 K' S
33. 33.        
    
34. 34.        if (_ulFlashAddr >= ADDR_FLASH_SECTOR_0_BANK2)
    
35. 35.        {
    7 S* ^' f( f5 m2 [; U
36. 36.            EraseInitStruct.Banks         = FLASH_BANK_2;
    $ w* w' Y4 B5 B, U( u5 y6 I& u. ~
37. 37.        }
    
38. 38.        else
    
39. 39.        {
    $ c* O3 r5 O2 A# f! [6 g
40. 40.            EraseInitStruct.Banks         = FLASH_BANK_1;
    
41. 41.        }
    / D" p4 E) c- Q) h
42. 42.        
    
43. 43.        EraseInitStruct.Sector        = FirstSector;
    
44. 44.        EraseInitStruct.NbSectors     = NbOfSectors;
    
45. 45.        
    : _% [7 [+ m/ x3 b. u' A/ r" `- O" J
46. 46.        /* 扇区擦除 */   
    2 ~* d) S2 `1 V; X
47. 47.        re = HAL_FLASHEx_Erase(&EraseInitStruct, &SECTORError);
    - a% {0 _* J9 e! e/ g
48. 48.        
    
49. 49.        /* 擦除完毕后，上锁 */
    
50. 50.        HAL_FLASH_Lock();   
    
51. 51.        
    
52. 52.        return re;
    * m! s2 X; `' ?0 M4 ^6 D7 n
53. 53.    }

复制代码

4 ~& i1 f  z0 \* K$ p# t

这里将此程序设计的关键点为大家做个说明：

  第25行函数是通过函数bsp_GetSector获取要擦除地址所处的扇区。这个函数的实现比较简单，代码如下：
. `8 T; v: m& j% |8 a

1. /*
   
2. *********************************************************************************************************
   
3. *    函 数 名: bsp_GetSector
   7 b: p5 k* ~4 X: S/ M  M& ?4 @# Q
4. *    功能说明: 根据地址计算扇区首地址
   
5. *    形    参: 无
   ) D) K( S7 p+ _6 C
6. *    返 回 值: 扇区号（0-7)
   
7. *********************************************************************************************************
   
8. */
   
9. uint32_t bsp_GetSector(uint32_t Address)
   ; n9 g6 ^" M& [1 p# K" O: Z, w
10. {
    4 x/ S+ f( ^" @+ [8 h2 f
11.     uint32_t sector = 0;
    
12. 
    
13.     if (((Address < ADDR_FLASH_SECTOR_1_BANK1) && (Address >= ADDR_FLASH_SECTOR_0_BANK1)) || \
    . a# T# n) S- t% w* {% X, b
14.         ((Address < ADDR_FLASH_SECTOR_1_BANK2) && (Address >= ADDR_FLASH_SECTOR_0_BANK2)))   
      t4 J# e: e" F: T
15.     {
    
16.         sector = FLASH_SECTOR_0;  
    
17.     }
    7 y, K0 j6 \+ U
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;  
    8 @9 a* d/ A. C" ^/ {  c' f
22.     }
    
23.     else if (((Address < ADDR_FLASH_SECTOR_3_BANK1) && (Address >= ADDR_FLASH_SECTOR_2_BANK1)) || \
    . i7 `( n8 ^& @. ~+ l
24.       ((Address < ADDR_FLASH_SECTOR_3_BANK2) && (Address >= ADDR_FLASH_SECTOR_2_BANK2)))   
    & V+ Q% Q. S7 `; }. V9 N; ^5 W, B
25.     {
    
26.         sector = FLASH_SECTOR_2;  
    , E3 Z5 b: v! {# v4 ^
27.     }
    ( B. O5 p& t) j) y# o
28.     else if (((Address < ADDR_FLASH_SECTOR_4_BANK1) && (Address >= ADDR_FLASH_SECTOR_3_BANK1)) || \
    & x! R+ K3 w& f1 q% D
29.       ((Address < ADDR_FLASH_SECTOR_4_BANK2) && (Address >= ADDR_FLASH_SECTOR_3_BANK2)))   
    5 U/ v2 b. i7 E* v2 Y0 ?3 ^* E' s# l
30.     {
    & r' s  r9 X1 j8 y
31.         sector = FLASH_SECTOR_3;  
    
32.     }
    
33.     else if (((Address < ADDR_FLASH_SECTOR_5_BANK1) && (Address >= ADDR_FLASH_SECTOR_4_BANK1)) || \
    
34.       ((Address < ADDR_FLASH_SECTOR_5_BANK2) && (Address >= ADDR_FLASH_SECTOR_4_BANK2)))   
    / O2 q& |, o3 P8 Q1 m( I2 o# ]/ Q( q
35.     {
    
36.         sector = FLASH_SECTOR_4;  
    + R3 R+ x1 Y# t8 V6 b
37.     }
    
38.     else if (((Address < ADDR_FLASH_SECTOR_6_BANK1) && (Address >= ADDR_FLASH_SECTOR_5_BANK1)) || \
    : J# k6 ?1 s, G6 R
39.       ((Address < ADDR_FLASH_SECTOR_6_BANK2) && (Address >= ADDR_FLASH_SECTOR_5_BANK2)))   
    
40.     {
    # T) _5 n5 a7 u! B  }: _7 c
41.         sector = FLASH_SECTOR_5;  
    4 b. ?5 M. \  b0 r; D: E3 l
42.     }
    0 G# K# N, _3 @
43.     else if (((Address < ADDR_FLASH_SECTOR_7_BANK1) && (Address >= ADDR_FLASH_SECTOR_6_BANK1)) || \
    1 j8 v( c! h- g+ b& g. [
44.       ((Address < ADDR_FLASH_SECTOR_7_BANK2) && (Address >= ADDR_FLASH_SECTOR_6_BANK2)))   
    + N+ C$ e6 k. U* [
45.     {
    
46.         sector = FLASH_SECTOR_6;  
    . _$ m" B1 E' c" v( z. W  V  y' d
47.     }
    & v( h9 S6 r) x
48.     else if (((Address < ADDR_FLASH_SECTOR_0_BANK2) && (Address >= ADDR_FLASH_SECTOR_7_BANK1)) || \
    # I- d" O8 F! h  d, ^
49.       ((Address < CPU_FLASH_END_ADDR) && (Address >= ADDR_FLASH_SECTOR_7_BANK2)))
    ( u$ O% d. c5 z- b! T
50.     {
    
51.         sector = FLASH_SECTOR_7;  
    8 ?" @6 f: R: Y( z) u! W
52.     }
    ' @1 N/ b/ L  I& A& a
53.     else
    
54.     {
    
55.         sector = FLASH_SECTOR_7;
    1 U4 ]9 t$ ?: y% @! z5 @
56.     }
    " n) z. k  f- W: a& G3 z8 Y
57. 
    
58.     return sector;
    - c1 o( f* u. B7 I- f3 l$ n. }
59. }
    

复制代码

' A2 Q0 ]% u) F1 J9 W" f& {
4 N7 b5 a; T* P由于STM32H7的BANK1和BANK2是独立的，都有8个扇区，所以程序里面只需返回要擦除地址所处的扇区号即可。
$ p  s% n# W! z5 T2 ~' P8 M
4 g* ?# o, U! A$ q' i  第47行的擦除函数HAL_FLASHEx_Erase在第70章的4.4小节有说明。
71.2.2 内部Flash编程的实现
8 n& U* d7 x) s( G( Z$ B内部Flash的编程思路如下：
  {* r& \& b! [; i5 \5 E  f
  第1步，判断是否要编写数据进去，如果数据已经在内部Flash里面。
- s; w( ]* a1 ?  第2步，调用函数HAL_FLASH_Unlock解锁。
  第3步，调用函数HAL_FLASH_Program对内部Flash编程数据。
; F/ _) t6 n( D  G2 K) }0 {  第4步，调用函数HAL_FLASH_Lock上锁。
# ~) Q; l  `2 K2 E7 b按照这个思路，程序实现如下：

# F+ M# `; Z; z6 j6 e

1. 1.    /*
   % V5 n5 D6 I! A5 L7 s# p0 `
2. 2.    ******************************************************************************************************
   ; \! Q& Z  Z9 Z' W3 V
3. 3.    *    函 数 名: bsp_WriteCpuFlash
   . y5 O6 }$ z' Q( h% m* |6 y
4. 4.    *    功能说明: 写数据到CPU 内部Flash。 必须按32字节整数倍写。不支持跨扇区。扇区大小128KB. \
   2 n) m; C. \2 r
5. 5.    *              写之前需要擦除扇区. 长度不是32字节整数倍时，最后几个字节末尾补0写入.
   
6. 6.    *    形    参: _ulFlashAddr : Flash地址
   
7. 7.    *             _ucpSrc : 数据缓冲区
   ! ~6 r) A- |3 s+ Z4 z$ b# p  v
8. 8.    *             _ulSize : 数据大小（单位是字节, 必须是32字节整数倍）
   6 h1 D1 B. A& O+ _4 L
9. 9.    *    返 回 值: 0-成功，1-数据长度或地址溢出，2-写Flash出错(估计Flash寿命到)
   # _( x8 x+ }1 e3 k6 P1 M
10. 10.    ******************************************************************************************************
    8 x1 i& g: {4 A  B; h
11. 11.    */
    " \/ D6 F+ O. H" W
12. 12.    uint8_t bsp_WriteCpuFlash(uint32_t _ulFlashAddr, uint8_t *_ucpSrc, uint32_t _ulSize)
    9 w* |/ V9 F! A" L4 }( e2 u$ z+ b1 ^
13. 13.    {
    
14. 14.        uint32_t i;
    . A9 [  T( ~2 f3 c; X/ ^
15. 15.        uint8_t ucRet;
    7 A5 l' j9 V( E' n' C
16. 16.   
    
17. 17.        /* 如果偏移地址超过芯片容量，则不改写输出缓冲区 */
    
18. 18.        if (_ulFlashAddr + _ulSize > CPU_FLASH_BASE_ADDR + CPU_FLASH_SIZE)
    
19. 19.        {
    " H4 d, b. c$ n- \$ l( C5 W
20. 20.            return 1;
    $ q% l' Q( T" t$ B0 H
21. 21.        }
    
22. 22.   
    7 M$ Q( D  J6 p8 C9 h
23. 23.        /* 长度为0时不继续操作  */
    & [! n9 T% S. y: E1 e
24. 24.        if (_ulSize == 0)
    
25. 25.        {
    
26. 26.            return 0;
    , i) Y6 G5 s' r0 u
27. 27.        }
    
28. 28.   
    
29. 29.        ucRet = bsp_CmpCpuFlash(_ulFlashAddr, _ucpSrc, _ulSize);
    
30. 30.   
    
31. 31.        if (ucRet == FLASH_IS_EQU)
    . ]2 A; U. n/ ?4 Y) v
32. 32.        {
    
33. 33.            return 0;
    
34. 34.        }
    
35. 35.   
    $ a. E# G& [2 d9 q0 [4 B% e; `; X' \
36. 36.        __set_PRIMASK(1);          /* 关中断 */
    
37. 37.   
    
38. 38.        /* FLASH 解锁 */
    & X0 \! M1 N7 f1 J5 \
39. 39.        HAL_FLASH_Unlock();
    
40. 40.   
    
41. 41.        for (i = 0; i < _ulSize / 32; i++)   
    ! S" J) @; W8 z6 ]
42. 42.        {
    ) h8 W: W. i2 [
43. 43.            uint64_t FlashWord[4];
    , A6 m4 t# o5 n9 s
44. 44.            
    . \) z" D% s1 S4 ~- Y+ V
45. 45.            memcpy((char *)FlashWord, _ucpSrc, 32);
    
46. 46.            _ucpSrc += 32;
    
47. 47.            
    ; }8 ~& e, t- J  E
48. 48.            if (HAL_FLASH_Program(FLASH_TYPEPROGRAM_FLASHWORD, _ulFlashAddr,
    
49. 49.                                      (uint64_t)((uint32_t)FlashWord)) == HAL_OK)
    
50. 50.            {
    1 ~7 L6 C* V# O/ @. @3 V
51. 51.                _ulFlashAddr = _ulFlashAddr + 32; /* 递增，操作下一个256bit */               
    
52. 52.            }        
    
53. 53.            else
    
54. 54.            {
    . S: e3 H8 A3 Q0 Y3 n
55. 55.                goto err;
    8 _3 c+ u! E: U
56. 56.            }
    
57. 57.        }
    
58. 58.        
    
59. 59.        /* 长度不是32字节整数倍 */
    
60. 60.        if (_ulSize % 32)
    4 z& N  `5 l& b/ s2 K+ u
61. 61.        {
    3 n" n8 c4 a, g3 o7 B* C+ v/ E: c
62. 62.            uint64_t FlashWord[4];
    
63. 63.            
    
64. 64.            FlashWord[0] = 0;
    / ]: }% u  g+ M9 b/ w# ?  E) X' [
65. 65.            FlashWord[1] = 0;
    
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,
    
70. 70.                                               (uint64_t)((uint32_t)FlashWord)) == HAL_OK)
    ' g0 U  u% y( ]+ C
71. 71.            {
    1 }* p; A' X' [$ S0 W/ g7 C
72. 72.                ; // _ulFlashAddr = _ulFlashAddr + 32;
    7 `& e; f4 m! w3 U& I) @
73. 73.               
      a8 P! {/ j2 P6 S. ?$ @
74. 74.            }        
    
75. 75.            else
    
76. 76.            {
    
77. 77.                goto err;
    
78. 78.            }
    
79. 79.        }
    
80. 80.        
    
81. 81.          /* Flash 加锁，禁止写Flash控制寄存器 */
    
82. 82.          HAL_FLASH_Lock();
    , g7 B" n# V' E& i4 `0 `- v+ v
83. 83.   
    
84. 84.          __set_PRIMASK(0);          /* 开中断 */
    $ E0 d8 j4 l0 I/ n# U
85. 85.   
    
86. 86.        return 0;
    
87. 87.        
    
88. 88.    err:
    & E2 K" Q, H* Z) J8 s
89. 89.          /* Flash 加锁，禁止写Flash控制寄存器 */
      G" w5 Y5 Q* a! k- c& i2 N; N; r
90. 90.          HAL_FLASH_Lock();
    
91. 91.   
    
92. 92.          __set_PRIMASK(0);          /* 开中断 */
    
93. 93.   
    , u/ @% Z# k  n, k, d
94. 94.        return 1;
    
95. 95.    }
    " }$ {" a' L1 o" J4 L) v7 |% Z

复制代码

关于此函数有几个要点：
- S+ H/ h1 S' {
  第1个参数必须32字节对齐，即要编程的Flash地址对32求余为0。
& e8 T4 m5 X$ H- d+ a  第3个参数必须是32字节的整数倍，长度不是32字节整数倍时，最后几个字节补0写入。
5 I3 Q0 }, g7 n: A: h  第29行，函数bsp_CmpCpuFlash放在这里只有一个作用，判断将要写入的数据是否已经在内部Flash存在，如果已经存在，无需重复写入，直接返回。
3 o% l; d( N  R8 H/ ~  第36行，做了一个关中断操作，这里有个知识点要给大家普及下，由于H7的BANK1和BANK2是独立的，当前正在擦除的扇区所处的BANK会停止所有在此BANK执行的程序，包含中断也会停止执行。比如当前的应用程序都在BANK1，如果要擦除或者编程BANK2，是不会不影响BANK1里面执行的程序。这里安全起见加上了开关中断。
  第41到57行，先将32字节整数倍的数据通过函数HAL_FLASH_Program编程，此函数每次可以固定编程32字节数据。
  第60到79行，将剩余不足32字节的数据补0，凑齐32字节编程。
71.2.3 内部Flash读取的实现
( f- `) }& \$ ~5 \( i- ]) `内部Flash数据读取比较简单，采用总线方式读取，跟访问内部RAM是一样的。比如要读取地址

0x08100000里面的一个32bit变量，我们就可以：
5 ~/ U% u, [0 a3 j/ X
变量 = *(uint32_t *)(0x08100000)
; c# ^: e6 F* t( H2 y/ z3 D
为了方便起见，也专门准备了一个函数：

7 c. ?8 j% W# C! }2 O3 G9 h

1. /*
   
2. *********************************************************************************************************
   0 k7 S2 W" Z2 p9 |
3. *    函 数 名: bsp_ReadCpuFlash
   
4. *    功能说明: 读取CPU Flash的内容
   3 `( u9 q& q+ h) c
5. *    形    参:  _ucpDst : 目标缓冲区
   % t" J; |: t" K* V
6. *             _ulFlashAddr : 起始地址
     r0 M' E5 t2 x) B1 d# {  A
7. *             _ulSize : 数据大小（单位是字节）
   . L5 \( b5 r9 Y- g) y. O9 ~& U
8. *    返 回 值: 0=成功，1=失败
   
9. *********************************************************************************************************
   6 ^. q/ q' @+ Z( V% H& M
10. */
    6 _) p) \% {$ W$ c# Q7 w# I( M
11. uint8_t bsp_ReadCpuFlash(uint32_t _ulFlashAddr, uint8_t *_ucpDst, uint32_t _ulSize)
    
12. {
    
13.     uint32_t i;
    
14. 
    , i1 S: n* F6 D
15.     if (_ulFlashAddr + _ulSize > CPU_FLASH_BASE_ADDR + CPU_FLASH_SIZE)
    ' @5 _/ L6 _) B4 _
16.     {
    
17.         return 1;
    
18.     }
    + [& @' Z1 v7 j: }
19. 
    , v+ m& B" t5 r3 L4 c/ H
20.     /* 长度为0时不继续操作,否则起始地址为奇地址会出错 */
    
21.     if (_ulSize == 0)
      A. f, U  w, h, U3 g$ G
22.     {
    
23.         return 1;
    
24.     }
    , U; l! `+ d# @5 \/ H
25. 
    ) A% o1 }2 ]9 e- H) S* h
26.     for (i = 0; i < _ulSize; i++)
    
27.     {
    
28.         *_ucpDst++ = *(uint8_t *)_ulFlashAddr++;
    
29.     }
    
30. 
    ) O( e9 R" i9 q3 k
31.     return 0;
    
32. }
    0 M& e! X+ f' R' Q

复制代码

% i* {. c" U- j0 B' E71.2.4 告诉编译器使用的扇区（重要）
使用内部Flash模拟EEPROM切不可随意定义一个扇区使用。因为编译器并不知道用户使用了这个扇区，导致应用程序也会编程到此扇区里面，所以就需要告诉编译器。
/ E. z2 N8 Z( o$ {$ }, n3 B1 _
' w9 R3 V; U; U# T% I3 n  p告诉MDK的方法如下（0x0810 0000是H7的BANK2首地址）：
; B* ?! a  n- H! ^7 V" X5 U
5 P! a4 y  V! }4 m

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

复制代码

+ Y7 L4 h8 i$ E. o5 Q- R告诉IAR的方法如下：
1 K3 Q9 D1 p1 w; c+ X

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

复制代码

' r/ M6 L: H- \6 @# |2 Y4 P7 p3 w这里有两点特别注意：

  模拟EEPROM的扇区可以定义到从第2个扇区开始的任何扇区，但不可以定义到首扇区，因为这个扇区是默认的boot启动地址。
  如果应用程序不大的话，不推荐定义到末尾扇区，以MDK为例，定义到末尾扇区后，会导致整个Flash空间都被使用，从而让程序下载下载时间变长。
3 I" F6 O' A' J9 w: w71.3 模拟EEPROM板级支持包（bsp_cpu_flash.c）
模拟EEPROM的驱动文件bsp_cpu_flash.c主要实现了如下几个API供用户调用：
) E. P2 ]. r) F) Z: A* p
" V. |0 l& p5 U8 X1 R! E  bsp_GetSector
  bsp_ReadCpuFlash
$ i4 n; n2 n# y% L  bsp_CmpCpuFlash
* L* I: p" U( f, H' g+ ~) d7 r0 R  O  bsp_EraseCpuFlash
# Z" t* v6 z8 Y) V% z, d  bsp_WriteCpuFlash
% E( H* u0 ^1 C7 D. m71.3.1 函数bsp_GetSector
# v/ d+ M  V  p函数原型：
0 m; j9 |1 `% m7 l" P' Y: H

1. uint32_t bsp_GetSector(uint32_t Address)

复制代码

函数描述：
, A9 V. R  V0 V* E
+ B; S: e* E1 L9 R! [4 `3 j此函数主要用于获取给定地址所处的扇区。
3 R+ C" k' [- S, M* E# b
函数参数：

. Q1 j7 Z/ d3 d( F, i  第1个参数是用户给定的地址。
3 H# \5 z/ c& ^. f$ J# n8 A9 `  返回值，范围FLASH_SECTOR_0到FLASH_SECTOR_7。
8 f, `3 |, I+ R) @& z* E& U, i4 w71.3.2 函数bsp_ReadCpuFlash
函数原型：
" [. r' L! }" I3 W) L3 _  P1 ^- g" }

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

复制代码

函数描述：

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

函数参数：

3 H$ g# J6 y# a5 D# l' F  第1个参数读取的起始地址。
$ Z4 O$ m5 X4 y6 D; x! G0 n  第2个参数是读取数据的存储地址
  第3个参数是读取数据的大小，单位字节。
5 z4 ~  l$ b/ X( X6 L. m2 n* [  返回值，0表示成功，1表示失败。
* ~0 a( u1 w* l. I& `. L% v9 U71.3.3 函数bsp_CmpCpuFlash
函数原型：
. E. d) K% W. y7 I6 ~
9 r- X& \- j0 e, X5 Juint8_t bsp_CmpCpuFlash(uint32_t _ulFlashAddr, uint8_t *_ucpBuf, uint32_t _ulSize)

% |' O4 I, T8 \$ {1 g: B# Z函数描述：
( q" l/ x% k: u4 p4 G
要编程的数据是否在内部Flash已经存在。
; ]# z; D9 t- m% V. f# q# r
5 _; h. F$ ?$ c& K) [: ^" }7 f( e8 D函数参数：
: s3 D, \, @9 H2 y# `% ^% }0 o
; W" V+ g. g9 `' j  第1个参数是内部Flash地址。
  第2个参数是缓冲区地址。
  第3个参数是数据大小，单位字节。
( R5 O6 ], b6 c( f' g  返回值：
FLASH_IS_EQU               0   Flash内容和待写入的数据相等，不需要擦除和写操作。
1 P7 H! ]0 j1 \! J. W- m' }
: `! v/ L; u& B# ]4 A% U# U- zFLASH_REQ_WRITE          1     Flash不需要擦除，直接写。

) ~$ d- E3 t$ ]1 HFLASH_REQ_ERASE          2     Flash需要先擦除,再写。

FLASH_PARAM_ERR         3     函数参数错误。

9 q/ q( u/ h% K* K- r  N71.3.4 函数bsp_EraseCpuFlash
) M7 e  j" Q/ _+ |函数原型：
% H: Z' @1 S$ i+ o9 o
uint8_t bsp_EraseCpuFlash(uint32_t _ulFlashAddr)
0 p- P$ g) I  ~) P9 w
( L% ~( T; u5 m# e5 |+ E函数描述：

/ }- Z6 j8 y- }) F$ m4 d此函数用于擦除一个扇区，大小128KB
; D: ?! r0 `- J) c- K) m! n3 M
函数参数：
$ `6 s- t5 S1 H) n- @+ T5 e, _
  第1个参数要擦除的扇区地址，可以是此扇区范围内的任意值，一般填扇区首地址即可。
  返回值：
6 S" _) q- Y9 C% [! oHAL_OK        = 0x00

8 G& |5 b0 s( c& T) O* MHAL_ERROR    = 0x01
* c' L# w: E! N+ {
% k- R. d6 Z0 cHAL_BUSY      = 0x02
# T* W9 M: a% n& m! l) {# E5 X8 Y
HAL_TIMEOUT  = 0x03
2 i$ \. ~) L8 h. k
71.3.5 函数bsp_WriteCpuFlash
函数原型：
. q. W4 H6 j& T6 B
% Y  b+ l! K: H& J, r% N4 n% R$ `uint8_t bsp_WriteCpuFlash(uint32_t _ulFlashAddr, uint8_t *_ucpSrc, uint32_t _ulSize)

+ \( Q( I3 n8 b/ M; F: K" I, k函数描述：

9 M% D) G' L3 [9 K# b6 _8 i5 J此函数用于编程数据到内部Flash。

函数参数：
' _$ d2 @  }5 k9 N  v
  第1个参数是要编程的内部Flash地址。
! m, N% \2 L& Z9 h) h9 U  第2个参数是数据缓冲区地址。
  第3个参数是数据大小，单位字节。
  返回值，0-成功，1-数据长度或地址溢出，2-写Flash出错(估计Flash寿命到)。
5 `8 q6 D) \4 V# ~注意事项：
) m/ `1 R" ^* e/ ]
6 D3 j' G8 t( x6 t8 a9 |9 z  第1个参数必须32字节对齐，即要编程的Flash地址对32求余为0。
  第3个参数必须是32字节的整数倍，长度不是32字节整数倍时，此函数会将几个字节补0写入
. n3 O3 m, M+ ]1 K71.4 模拟EEPROM驱动移植和使用
模拟EEPROM移植步骤如下：

) L% {; b9 V3 t  第1步：复制bsp_cpu_flash.c和bsp_cpu_flash.h到自己的工程目录，并添加到工程里面。
  第2步：Flash驱动文件主要用到HAL库的Flash驱动文件，简单省事些可以添加所有HAL库C源文件进来。
! e8 }( W" H+ z  第3步，应用方法看本章节配套例子即可。
, l6 r+ P' g& X+ }: U  K! \9 F71.5 实验例程设计框架
通过程序设计框架，让大家先对配套例程有一个全面的认识，然后再理解细节，本次实验例程的设计框架如下：

3 ]7 J+ B1 k$ R0 q% W

  第1阶段，上电启动阶段：
" O; |& c  L3 f' x+ z( e& g, t
' w+ ?7 X( q' m: [) Q* e% A$ n8 q* Y这部分在第14章进行了详细说明。
  第2阶段，进入main函数：

4 x0 P0 {" ?+ V% x  第1部分，硬件初始化，主要是MPU，Cache，HAL库，系统时钟，滴答定时器和LED。
  第2部分，应用程序设计部分，实现内部Flash模拟EEPROM。
71.6 实验例程说明（MDK）
配套例子：

V7-049_内部Flash模拟EEPROM

6 w9 C6 C9 S0 D5 S) s1 Z3 F实验目的：

, h) Q+ m+ a" [# z5 C9 }" P4 t学习内部Flash模拟EEPROM。
实验内容：

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

实验操作：
" Q! `4 y; r2 g1 I* _* O! b8 Y. ~
5 b, e8 ^& W2 J) W3 j: W4 nK1键按下，将8bit，16bit和32bit数据写入到内部Flash。
3 s5 p$ O3 ]/ Q; _% k5 eK2键按下，将结构体数据写入到内部Flash。
上电后串口打印的信息：
' R7 y$ L3 C1 s' s/ s# J" e7 c9 |9 z
  G% N9 Q$ g4 L9 t" W波特率 115200，数据位 8，奇偶校验位无，停止位 1。

5 }2 M! s6 h1 t6 l' Z+ X
程序设计：

4 u5 |; k- H1 T2 v& B  系统栈大小分配：

1 V# k1 Z' _; z" N, U2 S3 ^
/ ?; Q% u; K- d1 |( B  RAM空间用的DTCM：

  硬件外设初始化
1 \# w& Q: G5 M& j; J) T( Y
硬件外设的初始化是在 bsp.c 文件实现：

1. /*
   6 t$ d( V0 b2 B% ^
2. *********************************************************************************************************
   
3. *    函 数 名: bsp_Init
   - J: i% v2 f" ~: m
4. *    功能说明: 初始化所有的硬件设备。该函数配置CPU寄存器和外设的寄存器并初始化一些全局变量。只需要调用一次
   % z9 t1 s1 i  w" S9 F$ H* y4 _
5. *    形    参：无
   $ ~& k' h- U: Z" C( V
6. *    返 回 值: 无
   " a- m/ \3 M0 ^  r1 \
7. *********************************************************************************************************
   
8. */
   
9. void bsp_Init(void)
   
10. {
    ; @* i, Z, V9 C" h8 w
11.     /* 配置MPU */
    
12.     MPU_Config();
    1 w: ~7 d0 u) b' \9 n
13. 
    
14.     /* 使能L1 Cache */
    
15.     CPU_CACHE_Enable();
    
16. 
    
17.     /*
    
18.        STM32H7xx HAL 库初始化，此时系统用的还是H7自带的64MHz，HSI时钟:
    ' K& z6 c5 c9 a- `8 k% k3 `& L
19.        - 调用函数HAL_InitTick，初始化滴答时钟中断1ms。
    9 D5 `- [; G# t$ B& x" \" g" v
20.        - 设置NVIV优先级分组为4。
    . \: ?) |1 Q! S
21.      */
    
22.     HAL_Init();
    
23. 
    $ ]  Y1 c$ r6 B4 H  ^5 i: _
24.     /*
    
25.        配置系统时钟到400MHz
    
26.        - 切换使用HSE。
    
27.        - 此函数会更新全局变量SystemCoreClock，并重新配置HAL_InitTick。
    5 x/ n+ D( N; j% I
28.     */
    
29.     SystemClock_Config();
    2 l1 }7 P$ R7 f
30. 
    
31.     /*
    $ F$ c% r. P7 Z! |
32.        Event Recorder：
    
33.        - 可用于代码执行时间测量，MDK5.25及其以上版本才支持，IAR不支持。
    
34.        - 默认不开启，如果要使能此选项，务必看V7开发板用户手册第xx章
    * ?" [0 Z7 V/ V" X- V2 a
35.     */   
    
36. #if Enable_EventRecorder == 1  
    
37.     /* 初始化EventRecorder并开启 */
    $ q' [+ d+ l. [( ^# d* f
38.     EventRecorderInitialize(EventRecordAll, 1U);
    3 h( \" p! t) o3 d6 P- B
39.     EventRecorderStart();
    , _1 |) S( E0 m& I0 w8 L
40. #endif
    # f! g, l: Q' b3 L1 g+ S# q
41. 
    4 @: |( j9 E0 o  c. ]  h
42. bsp_InitDWT();      /* 初始化DWT时钟周期计数器 */      
    
43.     bsp_InitKey();        /* 按键初始化，要放在滴答定时器之前，因为按钮检测是通过滴答定时器扫描 */
    
44.     bsp_InitTimer();      /* 初始化滴答定时器 */
    2 C. t' g' m2 R& A! w: l$ N
45.     bsp_InitLPUart();    /* 初始化串口 */
    
46.     bsp_InitExtIO();    /* 初始化FMC总线74HC574扩展IO. 必须在 bsp_InitLed()前执行 */   
    
47.     bsp_InitLed();        /* 初始化LED */   
    
48.     bsp_InitExtSDRAM(); /* 初始化SDRAM */
    / l; @% B- [3 f, s5 I( N
49. }
    

复制代码

1 W# A( b8 d, I
  MPU配置和Cache配置：

4 k2 V& ^( O# G+ M+ u( K数据Cache和指令Cache都开启。配置了AXI SRAM区（本例子未用到AXI SRAM）和FMC的扩展IO区。
3 u& G1 g; j0 e7 t) ]0 ^# ~# T

1. /*
   4 ?3 Q7 G" i3 F+ T$ B
2. *********************************************************************************************************
   2 G' _& }4 \+ |$ V
3. *    函 数 名: MPU_Config
   1 ?7 Z- Y8 H0 ]. E/ X& K4 U; _
4. *    功能说明: 配置MPU
   % B/ |# x+ f. K, r" u
5. *    形    参: 无
   6 k( r+ [2 ]; H9 I; ?7 T7 V
6. *    返 回 值: 无
   
7. *********************************************************************************************************
   
8. */
   ! E- L; r: k$ U0 _
9. static void MPU_Config( void )
   ) c, b1 }, E" Q8 B0 P6 c, D( N
10. {
    & x- ^5 B. S' L1 d! A2 z" j- n
11.     MPU_Region_InitTypeDef MPU_InitStruct;
    
12. 
    
13.     /* 禁止 MPU */
    ( f- A; A- k- n7 Z
14.     HAL_MPU_Disable();
    % U' z4 d2 i0 u! R1 T4 j
15. 
    $ ?$ v) Q2 y1 w) a& {
16.     /* 配置AXI SRAM的MPU属性为Write back, Read allocate，Write allocate */
    & v1 ~  t) y+ u& `' ?
17.     MPU_InitStruct.Enable           = MPU_REGION_ENABLE;
    1 ^( k& [. B/ \
18.     MPU_InitStruct.BaseAddress      = 0x24000000;
    / }8 d7 `- ^5 Z2 ]( W& R9 [
19.     MPU_InitStruct.Size             = MPU_REGION_SIZE_512KB;
    ; M8 X: ?4 p  U7 N+ C% P9 U$ E. |
20.     MPU_InitStruct.AccessPermission = MPU_REGION_FULL_ACCESS;
    
21.     MPU_InitStruct.IsBufferable     = MPU_ACCESS_BUFFERABLE;
    
22.     MPU_InitStruct.IsCacheable      = MPU_ACCESS_CACHEABLE;
    * f/ W. `  t1 W9 m: z
23.     MPU_InitStruct.IsShareable      = MPU_ACCESS_NOT_SHAREABLE;
    " N. S( _% g; d8 P: U, E. ~  e
24.     MPU_InitStruct.Number           = MPU_REGION_NUMBER0;
    
25.     MPU_InitStruct.TypeExtField     = MPU_TEX_LEVEL1;
      J. ^% z+ m" Y) ?& ]
26.     MPU_InitStruct.SubRegionDisable = 0x00;
    
27.     MPU_InitStruct.DisableExec      = MPU_INSTRUCTION_ACCESS_ENABLE;
    # E$ ^# x- C% F
28. 
    
29.     HAL_MPU_ConfigRegion(&MPU_InitStruct);
    9 b3 u) A' \. S) `3 J
30. 
    
31. 
    
32.     /* 配置FMC扩展IO的MPU属性为Device或者Strongly Ordered */
    ; \! m/ w$ J) f. u% ^, i
33.     MPU_InitStruct.Enable           = MPU_REGION_ENABLE;
    ; O/ Q6 r( ^. C- D
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;
    & _9 ?+ @, l- c/ V" ~) C
38.     MPU_InitStruct.IsCacheable      = MPU_ACCESS_NOT_CACHEABLE;   
    
39.     MPU_InitStruct.IsShareable      = MPU_ACCESS_NOT_SHAREABLE;
    - x4 U. Q' w0 U+ k0 y- ]
40.     MPU_InitStruct.Number           = MPU_REGION_NUMBER1;
    6 v7 F" k  `/ u$ M. W. e
41.     MPU_InitStruct.TypeExtField     = MPU_TEX_LEVEL0;
    
42.     MPU_InitStruct.SubRegionDisable = 0x00;
    * z) u8 t' q. j+ L' B6 ?6 h
43.     MPU_InitStruct.DisableExec      = MPU_INSTRUCTION_ACCESS_ENABLE;
    
44. 
    $ Q! N/ {6 D; F8 y$ g
45.     HAL_MPU_ConfigRegion(&MPU_InitStruct);
    
46. 
    + u+ f- u4 T% u3 p
47.     /*使能 MPU */
    
48.     HAL_MPU_Enable(MPU_PRIVILEGED_DEFAULT);
    
49. }
    , B4 P& |5 x- R% Q
50. 
    
51. /*
    
52. *********************************************************************************************************
    % B( w! S, Y- M8 b
53. *    函 数 名: CPU_CACHE_Enable
    6 W! _' e5 y6 }1 G5 y$ F6 ]2 C% s, T
54. *    功能说明: 使能L1 Cache
    ; F7 @' f) Y+ _8 c$ X4 H" y
55. *    形    参: 无
    6 ?7 Z# ?  g* X) U" ?6 I4 c
56. *    返 回 值: 无
    8 H$ w/ O6 F3 Z- A
57. *********************************************************************************************************
    % X) K% L% m8 \6 q4 g' F% l) ?& `
58. */
    / E: {; p  t# k1 e% N& j( z
59. static void CPU_CACHE_Enable(void)
    
60. {
    
61.     /* 使能 I-Cache */
    
62.     SCB_EnableICache();
    
63. 
    7 T) E) z/ j5 m) @6 \( U/ w
64.     /* 使能 D-Cache */
      K: D, Z9 J9 A, w  ~
65.     SCB_EnableDCache();
    
66. }

复制代码

7 C1 F, h& V9 Z$ G# s

  w9 _6 t8 g) Z  C/ w* H) z1 C  每10ms调用一次蜂鸣器处理：
4 ?2 \3 J/ I7 }% s6 ]$ [; r
蜂鸣器处理是在滴答定时器中断里面实现，每10ms执行一次检测。
- Y! k' ~4 t% Y/ p# d5 {* c4 b3 k

1. /*
   
2. *********************************************************************************************************
   : o6 K2 b. X6 G+ m
3. *    函 数 名: bsp_RunPer10ms
   
4. *    功能说明: 该函数每隔10ms被Systick中断调用1次。详见 bsp_timer.c的定时中断服务程序。一些处理时间要求
   
5. *              不严格的任务可以放在此函数。比如：按键扫描、蜂鸣器鸣叫控制等。
   5 C9 ]& ?8 |% C  [
6. *    形    参: 无
   8 G% d# N+ a+ J$ B5 R2 G
7. *    返 回 值: 无
   : [9 P" d- Q  Q5 u* R0 d# X; \' C4 R
8. *********************************************************************************************************
   5 I. Z) Z* S" r1 |7 _8 C3 f
9. */
   
10. void bsp_RunPer10ms(void)
    . |% V( N; Q* k" C; D, c4 g. W- z6 X
11. {
    1 J' U; A0 n! e( f3 S6 A! q/ h( K
12.     bsp_KeyScan10ms();
    ; O+ V2 y* N8 G, }* l' n
13. }
    / f# w2 V: j' O& ]

复制代码

  主功能：

主程序实现如下操作：
8 [, Z7 u; \9 J+ l/ I( ^2 h
( O* s) N% A1 D0 C; n  启动一个自动重装软件定时器，每100ms翻转一次LED2。
  K1键按下，将8bit，16bit和32bit数据写入到内部Flash。
  K2键按下，将结构体数据写入到内部Flash。

1. /*
   + ~" @) k9 d+ a
2. *********************************************************************************************************
   
3. *    函 数 名: main
   
4. *    功能说明: c程序入口
   
5. *    形    参: 无
   
6. *    返 回 值: 错误代码(无需处理)
   
7. *********************************************************************************************************
   
8. */
   ! `' o9 B/ ^4 p: L
9. int main(void)
   
10. {
    
11.     uint8_t ucKeyCode;    /* 按键代码 */
    " {, u9 c" S) ^
12.     uint8_t  ucTest, *ptr8;
    
13.     uint16_t uiTest, *ptr16;
    ) x8 \0 p7 f# @& Q8 c
14.     uint32_t ulTest, *ptr32;
    
15.     PARAM_T tPara, *paraptr;
    ) Z! J; U! {% J6 f3 U
16. 
    
17. 
    $ {- }" V  P- n" B$ a9 h" p: S2 ?. ^
18.     /* 初始化数据 */
    
19.     tPara.Baud485 = 0x5555AAAA;
    ; T/ d; _, W/ E6 J" i) `
20.     tPara.ParamVer = 0x99;
    ' d% p8 |& m5 ^+ x( Y6 H
21.     tPara.ucBackLight = 0x7788;
    ; U! Z/ S( p# L  B9 T3 s7 K
22.     tPara.ucRadioMode = 99.99f;
    
23. 
    
24. 
    * L. `3 H1 n; U4 _- {
25.     bsp_Init();        /* 硬件初始化 */
    % s$ x( ]7 t) u: b: M) W
26.     PrintfLogo();    /* 打印例程名称和版本等信息 */
    
27.     PrintfHelp();    /* 打印操作提示 */
    0 v- R/ g  ]  }3 ?* O. _: i
28. 
    . T- F! @- V. W0 ]- i
29.     bsp_StartAutoTimer(0, 100);    /* 启动1个100ms的自动重装的定时器 */
    % R- V: A1 d$ h
30.     while (1)
    8 V2 P1 B- q# c* y. ?6 j
31.     {
    
32.         bsp_Idle();        /* 这个函数在bsp.c文件。用户可以修改这个函数实现CPU休眠和喂狗 */
    
33. 
    
34.         /* 判断定时器超时时间 */
    
35.         if (bsp_CheckTimer(0))   
    ; I/ ?. q7 u, ?5 {. C0 y
36.         {
    
37.             /* 每隔100ms 进来一次 */  
    
38.             bsp_LedToggle(2);
    . o3 L! j( w' i; ~8 J0 A' c
39.         }
    
40. 
    
41.         /* 按键滤波和检测由后台systick中断服务程序实现，我们只需要调用bsp_GetKey读取键值即可。 */
    $ ^) v) {0 D3 e' {9 m0 j3 K! ]7 b
42.         ucKeyCode = bsp_GetKey();    /* 读取键值, 无键按下时返回 KEY_NONE = 0 */
    
43.         if (ucKeyCode != KEY_NONE)
    3 [6 E$ Z: L2 x, K# |) ]4 m
44.         {
    
45.             switch (ucKeyCode)
    ! j+ i9 _/ ]2 C# m
46.             {
    & E4 @' t% c9 W) p
47.                 case KEY_DOWN_K1:            /* K1键按下，将8bit，16bit和32bit数据写入到内部Flash */
    : k$ i# b; _$ |1 y4 k2 [
48. 
    $ B5 I; |8 D* S( u
49.                 /*
    6 x" u5 P; b# F$ u5 U! B' r
50.                  1、对于同一个地址空间，仅支持一次编程(不推荐二次编程，即使是将相应bit由数值1编程0)。
    4 u2 a  H; U1 a8 z! H' V6 T
51.                  2、只能对已经擦除的空间做编程，擦除1个扇区是128KB。
    
52.                  3、H7的Flash编程时，务必保证要编程的地址是32字节对齐的，即此地址对32求余为0。并且编
    
53. 程的数据必须32字节整数倍。函数bsp_WriteCpuFlash对字节数不够32字节整数倍的情况自动补
    & [  U. O$ A7 T' D* F. u* F
54. 0。
    ; ~2 ~9 C8 O. r$ ]
55.                 */
    
56.                      /* 擦除扇区 */
    5 Q5 h9 L1 D% q
57.                     bsp_EraseCpuFlash((uint32_t)para_flash_area);
    
58. 
    , b3 r1 n" K! C
59.                     ucTest = 0xAA;
    
60.                     uiTest = 0x55AA;
    & P0 v/ O- {" g9 q" P$ h5 q+ o# y4 P
61.                     ulTest = 0x11223344;
    
62. 
    
63.                     /* 扇区写入数据 */
    
64.                     bsp_WriteCpuFlash((uint32_t)para_flash_area + 32*0,  (uint8_t *)&ucTest,
    
65. sizeof(ucTest));
    " E! x6 P7 H8 ~) b9 q3 T6 w
66.                     bsp_WriteCpuFlash((uint32_t)para_flash_area + 32*1,  (uint8_t *)&uiTest,
    ) K" I7 B  H! ?+ V7 _) E* e
67. sizeof(uiTest));
    ; N" A4 l! N1 V& K' ^" h$ N
68.                     bsp_WriteCpuFlash((uint32_t)para_flash_area + 32*2,  (uint8_t *)&ulTest,
    4 Q1 ?( \7 m, l4 p: x* O1 K
69. sizeof(ulTest));               
    5 _1 v7 a$ e* }% q9 D! O7 h+ ]
70. 
    $ W2 d) ^4 s. ?9 I% H! b- S
71.                     /* 读出数据并打印 */
    6 B0 b8 }( F0 ]5 @0 I: P$ i5 J5 F& s
72.                     ptr8  = (uint8_t  *)(para_flash_area + 32*0);
      G! d. }; f0 a8 B' ]9 A
73.                     ptr16 = (uint16_t *)(para_flash_area + 32*1);
    
74.                     ptr32 = (uint32_t *)(para_flash_area + 32*2);
    5 D0 ~& L0 D8 s8 v) N; u; Q) {
75. 
    
76.                     printf("写入数据：ucTest = %x, uiTest = %x, ulTest = %x\r\n", ucTest, uiTest, ulTest);
    
77.                     printf("读取数据：ptr8 = %x, ptr16 = %x, ptr32 = %x\r\n", *ptr8, *ptr16, *ptr32);
    * `" m) E6 x- y) Z7 s+ N
78. 
    / k. i0 H% V$ c# h+ v
79.                     break;
    7 g0 s* ?' j6 D
80. 
    / |0 z8 J2 l% ~$ Y
81.                 case KEY_DOWN_K2:            /* K2键按下， 将结构体数据写入到内部Flash */
    
82.                     /* 擦除扇区 */
    / x2 j5 v  I* }* X
83.                     bsp_EraseCpuFlash((uint32_t)para_flash_area);
    0 y* ~1 P6 a* B' a% y0 Y
84. 
    
85.                     /* 扇区写入数据 */
    
86.                     bsp_WriteCpuFlash((uint32_t)para_flash_area,  (uint8_t *)&tPara, sizeof(tPara));            
    * x* d, W) ~! Y) T2 S
87. 
    
88.                     /* 读出数据并打印 */
    
89.                     paraptr  = (PARAM_T  *)((uint32_t)para_flash_area);
    $ d! `- g. I" L' \/ A2 a
90. 
    
91. 
    0 F% N: n6 X# ]/ H) D7 j3 E
92.                     printf("写入数据：Baud485=%x, ParamVer=%x, ucBackLight=%x, ucRadioMode=%f\r\n",
    
93.                                                                        tPara.Baud485,
    3 [) u7 z2 z2 w# x) [- u! F6 J* ]
94.                                                                         tPara.ParamVer,
    * W+ A( E; O* d6 \8 A3 K
95.                                                                         tPara.ucBackLight,
    
96.                                                                    paraptr->ucRadioMode);
    * ~4 w  z9 g- \! ~( `& ?1 g
97. 
    
98.                     printf("读取数据：Baud485=%x, ParamVer=%x, ucBackLight=%x, ucRadioMode=%f\r\n",
    3 G" D8 B: X( Q( @6 m5 y# w
99.                                                                         paraptr->Baud485,
    
100.                                                                             paraptr->ParamVer,
     ! F" S8 o& B1 S
101.                                                                            paraptr->ucBackLight,
     1 D2 J# ?9 y( }: U4 c2 u9 H" g$ x
102.                                                                           paraptr->ucRadioMode);
     8 H" o: r. e: h/ m# d
103.                     break;               
     
104.                 default:
     
105.                     /* 其它的键值不处理 */
     8 X3 a# [8 y* [7 ~' A
106.                     break;
     
107.             }
     
108.         }
     : N3 o, s) R9 w$ c! k% `2 y
109.     }
     
110. }
     

复制代码

( H9 t5 {* x2 `- B" P" t4 ^5 _
! W0 j9 @' e# N, @/ o, o! l6 K71.7 实验例程说明（IAR）
, M' ^# ~" \: x4 ]# D配套例子：

V7-049_内部Flash模拟EEPROM
* t1 D2 O+ Q7 n. x1 b4 h+ q
/ x+ c3 V" H% M) x: D8 D实验目的：
& |( X; A2 f0 r8 ]2 I6 p7 D
学习内部Flash模拟EEPROM。
; q6 _% P& q4 h) r. l4 `实验内容：

使用内部Flash模拟EEPROM，务必告诉编译要使用的存储空间，防止这个空间存入了程序。
) d9 G+ E' K; n0 m对于同一个地址空间，仅支持一次编程(不推荐二次编程，即使是将相应bit由数值1编程0)。
只能对已经擦除的空间做编程，擦除1个扇区是128KB。
H7的Flash编程时，务必保证要编程的地址是32字节对齐的，即此地址对32求余为0。
$ Y! f" i9 T& L, ]并且编程的数据必须32字节整数倍，函数bsp_WriteCpuFlash对字节数不够32字节整数倍的情况自动补0。

实验操作：
; k% B+ E+ I& }8 T* L8 J- Q
K1键按下，将8bit，16bit和32bit数据写入到内部Flash。
! c4 Z) m) G9 P) iK2键按下，将结构体数据写入到内部Flash。
8 Q3 y7 B: C$ D/ f- C) ^2 h4 B' {上电后串口打印的信息：
& X9 y- l) M$ T8 D0 n6 U3 S% ?8 j
波特率 115200，数据位 8，奇偶校验位无，停止位 1。

4 u6 I2 |9 G# ?" |) R9 N# P7 B程序设计：

  系统栈大小分配：

: j3 I- E+ d) j( G' ]

  {, [$ z% Z7 s) a$ Y# p) D' {/ \
  RAM空间用的DTCM：

; h! e0 {4 @( m, V; {, A

- ~) i) t: J# N" p7 u& s5 d
% ^2 @  f0 Y3 ]: A1 M  硬件外设初始化
& P: g' r: E/ O0 n! l; C' N
硬件外设的初始化是在 bsp.c 文件实现：

1 |! w1 D# f0 q' y

1. /*
   , Z" ~/ z/ I  A
2. *********************************************************************************************************
   1 |) y) k: i4 r( A% T
3. *    函 数 名: bsp_Init
   
4. *    功能说明: 初始化所有的硬件设备。该函数配置CPU寄存器和外设的寄存器并初始化一些全局变量。只需要调用一次
   
5. *    形    参：无
   
6. *    返 回 值: 无
   $ t2 t' X7 P, a7 d. R
7. *********************************************************************************************************
   ) M1 l) u  D$ o% Y
8. */
   
9. void bsp_Init(void)
   ' K1 z& K( d/ s5 a
10. {
    9 Z2 s9 H& e6 \* W
11.     /* 配置MPU */
    
12.     MPU_Config();
    9 \' l6 Q$ z2 U( r
13. 
    
14.     /* 使能L1 Cache */
    
15.     CPU_CACHE_Enable();
    
16. 
    % H! ]( Y" f7 b/ @7 P3 t' y; h
17.     /*
    
18.        STM32H7xx HAL 库初始化，此时系统用的还是H7自带的64MHz，HSI时钟:
    " [8 S3 ^" f: t6 P& {$ H
19.        - 调用函数HAL_InitTick，初始化滴答时钟中断1ms。
    7 H; i0 y" R+ P0 g; K+ M4 Z) G. }
20.        - 设置NVIV优先级分组为4。
    
21.      */
    4 T! ?9 i# h/ }, O) v% a
22.     HAL_Init();
    
23. 
    : w) U' p+ l9 _& [7 |4 W6 A; ^/ v9 U
24.     /*
    
25.        配置系统时钟到400MHz
    $ U) w0 Z- V3 r. R  U8 S
26.        - 切换使用HSE。
    , I2 D% Q# D: O
27.        - 此函数会更新全局变量SystemCoreClock，并重新配置HAL_InitTick。
    
28.     */
    ( ?5 X/ f; ]+ F3 x7 k. v* M
29.     SystemClock_Config();
    
30. 
    : H# x1 C) B. g/ E7 L# ?
31.     /*
    
32.        Event Recorder：
    
33.        - 可用于代码执行时间测量，MDK5.25及其以上版本才支持，IAR不支持。
    - N2 X3 [2 g; o3 ?( o
34.        - 默认不开启，如果要使能此选项，务必看V7开发板用户手册第xx章
    - A1 f' g8 M' c/ j% X3 ]! K5 U# K
35.     */   
    
36. #if Enable_EventRecorder == 1  
    
37.     /* 初始化EventRecorder并开启 */
    
38.     EventRecorderInitialize(EventRecordAll, 1U);
    8 }! I" t/ ?3 I5 G
39.     EventRecorderStart();
    
40. #endif
    ( r( F/ q' Z* E( [
41. 
    
42. bsp_InitDWT();      /* 初始化DWT时钟周期计数器 */      
    7 V$ {$ s% W- \4 t; L. S% Z
43.     bsp_InitKey();        /* 按键初始化，要放在滴答定时器之前，因为按钮检测是通过滴答定时器扫描 */
    
44.     bsp_InitTimer();      /* 初始化滴答定时器 */
    & L0 |: e9 `* S6 ^5 p" r# M
45.     bsp_InitLPUart();    /* 初始化串口 */
    
46.     bsp_InitExtIO();    /* 初始化FMC总线74HC574扩展IO. 必须在 bsp_InitLed()前执行 */   
    
47.     bsp_InitLed();        /* 初始化LED */   
    
48.     bsp_InitExtSDRAM(); /* 初始化SDRAM */
    
49. }
    

复制代码

  MPU配置和Cache配置：
  }( i) {9 X0 ]8 r
) m: T0 m  a; q5 {! t+ }( O+ E% Z数据Cache和指令Cache都开启。配置了AXI SRAM区（本例子未用到AXI SRAM）和FMC的扩展IO区。
  n6 M7 {9 n& N  E: B
7 ]6 r( v' |3 d! l9 H+ ?

1. /*
   # C; ~$ M. r" e
2. *********************************************************************************************************
   
3. *    函 数 名: MPU_Config
   8 }: m  o% k' G1 {# u( l& X( N
4. *    功能说明: 配置MPU
   , U' F( _2 Z' L3 x% E1 L
5. *    形    参: 无
   
6. *    返 回 值: 无
   , P" J5 ^- h' W$ m( a# f8 Q2 L* y# X) F  m
7. *********************************************************************************************************
   
8. */
   1 H/ C% u! k" ^$ f# ~4 t) a; V
9. static void MPU_Config( void )
   ( j. }( c; `# y" I4 h: ?0 E
10. {
    
11.     MPU_Region_InitTypeDef MPU_InitStruct;
    
12. 
    
13.     /* 禁止 MPU */
    ' A9 A$ }- Q3 }$ c7 a
14.     HAL_MPU_Disable();
    
15. 
    # d, o; {1 ]* a+ h* m6 P
16.     /* 配置AXI SRAM的MPU属性为Write back, Read allocate，Write allocate */
    ! `' l1 I& Y: F5 t/ x  u& g+ c
17.     MPU_InitStruct.Enable           = MPU_REGION_ENABLE;
    ' d5 e% x' ?  ~( q2 Y; m
18.     MPU_InitStruct.BaseAddress      = 0x24000000;
    
19.     MPU_InitStruct.Size             = MPU_REGION_SIZE_512KB;
    
20.     MPU_InitStruct.AccessPermission = MPU_REGION_FULL_ACCESS;
    + z- X0 M( Z6 z- u& @" {
21.     MPU_InitStruct.IsBufferable     = MPU_ACCESS_BUFFERABLE;
    9 c) ^( p7 ~/ C- \# |8 K, A$ A
22.     MPU_InitStruct.IsCacheable      = MPU_ACCESS_CACHEABLE;
    
23.     MPU_InitStruct.IsShareable      = MPU_ACCESS_NOT_SHAREABLE;
    / q3 K5 n" d) N& J5 r( E5 c; U
24.     MPU_InitStruct.Number           = MPU_REGION_NUMBER0;
    
25.     MPU_InitStruct.TypeExtField     = MPU_TEX_LEVEL1;
    6 ?  G8 c; B( ?& g  _+ y2 R
26.     MPU_InitStruct.SubRegionDisable = 0x00;
    
27.     MPU_InitStruct.DisableExec      = MPU_INSTRUCTION_ACCESS_ENABLE;
    ( h% H; z) g$ ]. O- Z! O* Q
28. 
    + M+ q4 T* C& D3 G4 H
29.     HAL_MPU_ConfigRegion(&MPU_InitStruct);
    
30. 
    
31. 
    
32.     /* 配置FMC扩展IO的MPU属性为Device或者Strongly Ordered */
    / ^; y2 c/ q" ~, Z2 u1 \
33.     MPU_InitStruct.Enable           = MPU_REGION_ENABLE;
    ! o5 q5 X7 Q, [1 C! H
34.     MPU_InitStruct.BaseAddress      = 0x60000000;
    
35.     MPU_InitStruct.Size             = ARM_MPU_REGION_SIZE_64KB;   
    0 ]7 t( S  |2 R" m& e1 v
36.     MPU_InitStruct.AccessPermission = MPU_REGION_FULL_ACCESS;
    
37.     MPU_InitStruct.IsBufferable     = MPU_ACCESS_BUFFERABLE;
    % w4 E# H6 M/ |: \  Z( ]+ ^( f; N
38.     MPU_InitStruct.IsCacheable      = MPU_ACCESS_NOT_CACHEABLE;   
    2 t; a! Q7 T8 I6 R) b) @3 y+ v  Z
39.     MPU_InitStruct.IsShareable      = MPU_ACCESS_NOT_SHAREABLE;
    - t+ a4 D4 `( A1 F3 R) t8 A
40.     MPU_InitStruct.Number           = MPU_REGION_NUMBER1;
    - E/ l; k5 a5 d4 A' m8 t
41.     MPU_InitStruct.TypeExtField     = MPU_TEX_LEVEL0;
    
42.     MPU_InitStruct.SubRegionDisable = 0x00;
    4 O1 [& d- m8 D+ k# ]
43.     MPU_InitStruct.DisableExec      = MPU_INSTRUCTION_ACCESS_ENABLE;
    
44. 
    
45.     HAL_MPU_ConfigRegion(&MPU_InitStruct);
    
46. 
    6 p( u% X. l) i, A. j6 h! l; [
47.     /*使能 MPU */
    
48.     HAL_MPU_Enable(MPU_PRIVILEGED_DEFAULT);
    
49. }
    
50. 
    
51. /*
    
52. *********************************************************************************************************
    4 @' `9 K$ O  J9 G: i9 n
53. *    函 数 名: CPU_CACHE_Enable
    
54. *    功能说明: 使能L1 Cache
    
55. *    形    参: 无
    / \3 {2 L0 z: w( R
56. *    返 回 值: 无
    % C8 r. _/ a/ o. H/ M. ?1 n& d
57. *********************************************************************************************************
    ) ]. M9 F* `% R/ o9 a- ?- ?& `
58. */
    : E7 v( R$ g: R$ Y3 e
59. static void CPU_CACHE_Enable(void)
    
60. {
    
61.     /* 使能 I-Cache */
    % Q7 P+ m. S" L% N3 d
62.     SCB_EnableICache();
    6 J- |, M. [3 C) I5 D7 {
63. 
    
64.     /* 使能 D-Cache */
    
65.     SCB_EnableDCache();
    . a/ d1 _/ g% \" }9 |) i' _6 `# T
66. }

复制代码

. k5 f# v' Q+ u  z2 g% n/ v

. ]1 U5 g- i7 D" M! m' R  每10ms调用一次蜂鸣器处理：

6 F! S; j! ^% H8 E, }. `* e蜂鸣器处理是在滴答定时器中断里面实现，每10ms执行一次检测。
( ]. L0 B8 T3 \, f5 t( v7 i
$ D! W2 c" a! j$ x5 J

1. /*
   
2. *********************************************************************************************************
   
3. *    函 数 名: bsp_RunPer10ms
   
4. *    功能说明: 该函数每隔10ms被Systick中断调用1次。详见 bsp_timer.c的定时中断服务程序。一些处理时间要求
   
5. *              不严格的任务可以放在此函数。比如：按键扫描、蜂鸣器鸣叫控制等。
   
6. *    形    参: 无
   " ?  x# C7 S% R+ `4 S
7. *    返 回 值: 无
   ( ?: b$ Q: N3 w# A
8. *********************************************************************************************************
   6 ]1 T& U6 f4 |( Y5 a* D
9. */
   2 Y. c- M% p+ s: s) ~. ]- ?& i
10. void bsp_RunPer10ms(void)
    
11. {
    
12.     bsp_KeyScan10ms();
    
13. }
    

复制代码

+ L: R5 o6 g$ ?( V5 u+ D* ~  S
9 K5 M$ j# p' ?9 H4 a5 A; X/ n  主功能：

主程序实现如下操作：

. N" e1 ~. H; O2 V3 u0 b2 i1 R 启动一个自动重装软件定时器，每100ms翻转一次LED2。
K1键按下，将8bit，16bit和32bit数据写入到内部Flash。
/ v9 A+ y% O9 d K2键按下，将结构体数据写入到内部Flash。

1. /*
   
2. *********************************************************************************************************
   
3. *    函 数 名: main
   $ q5 ?, {- w: M
4. *    功能说明: c程序入口
   
5. *    形    参: 无
   ) @# F/ R0 Y: C6 w
6. *    返 回 值: 错误代码(无需处理)
   
7. *********************************************************************************************************
   * p1 R8 J7 z, B8 l) R- E
8. */
     E# Y7 H2 H( z5 g# S
9. int main(void)
   
10. {
      j7 |" d6 j. a+ J9 M! n7 e: s( u
11.     uint8_t ucKeyCode;    /* 按键代码 */
    
12.     uint8_t  ucTest, *ptr8;
    
13.     uint16_t uiTest, *ptr16;
    % ?: o" v' g1 W8 S) ]
14.     uint32_t ulTest, *ptr32;
    & }7 y* ?/ R4 Y- Z* |
15.     PARAM_T tPara, *paraptr;
    
16. 
    5 ?5 T* V. ~9 l. t, _+ [4 b
17. 
    . R% X/ N! Y2 {/ J$ U! E
18.     /* 初始化数据 */
    
19.     tPara.Baud485 = 0x5555AAAA;
    
20.     tPara.ParamVer = 0x99;
    
21.     tPara.ucBackLight = 0x7788;
    % _! {( _$ R) `  Z- k! [# C5 u3 R
22.     tPara.ucRadioMode = 99.99f;
    # H: O( t, V, c5 A
23. 
    
24. 
    
25.     bsp_Init();        /* 硬件初始化 */
    ' ^% I0 E/ R4 R+ w, G1 F
26.     PrintfLogo();    /* 打印例程名称和版本等信息 */
    0 k. X' t" c3 E, z
27.     PrintfHelp();    /* 打印操作提示 */
    5 p  P  t- L2 @
28. 
    % W' i& O4 E8 @8 I7 @% `, S
29.     bsp_StartAutoTimer(0, 100);    /* 启动1个100ms的自动重装的定时器 */
    
30.     while (1)
    
31.     {
    
32.         bsp_Idle();        /* 这个函数在bsp.c文件。用户可以修改这个函数实现CPU休眠和喂狗 */
    ) @1 y9 |0 A, D6 N( E5 V
33. 
    ! M% y7 i! w% P  z5 W1 P: }
34.         /* 判断定时器超时时间 */
    & @0 W* `6 O! R( C- `6 b2 M! K8 ]
35.         if (bsp_CheckTimer(0))   
    
36.         {
    . G4 s# F& u  |% U2 |5 A
37.             /* 每隔100ms 进来一次 */  
    
38.             bsp_LedToggle(2);
    9 V  B0 d  k" y- Y/ k, Z
39.         }
    4 T0 K3 w/ O- I% g
40. 
    + G! h; B7 O$ S6 Q4 x& p
41.         /* 按键滤波和检测由后台systick中断服务程序实现，我们只需要调用bsp_GetKey读取键值即可。 */
    
42.         ucKeyCode = bsp_GetKey();    /* 读取键值, 无键按下时返回 KEY_NONE = 0 */
    - T. V! p8 i! Q, G4 {* g
43.         if (ucKeyCode != KEY_NONE)
    
44.         {
    
45.             switch (ucKeyCode)
    
46.             {
    ) q/ O7 @$ B! [# d0 X
47.                 case KEY_DOWN_K1:            /* K1键按下，将8bit，16bit和32bit数据写入到内部Flash */
    + J8 g/ x* H$ H! A
48. 
      r2 }) c' r; R8 _! {$ [. F
49.                 /*
    
50.                  1、对于同一个地址空间，仅支持一次编程(不推荐二次编程，即使是将相应bit由数值1编程0)。
    
51.                  2、只能对已经擦除的空间做编程，擦除1个扇区是128KB。
    
52.                  3、H7的Flash编程时，务必保证要编程的地址是32字节对齐的，即此地址对32求余为0。并且编
    
53. 程的数据必须32字节整数倍。函数bsp_WriteCpuFlash对字节数不够32字节整数倍的情况自动补
    * c+ F& s3 c; x- i8 o# {
54. 0。
    
55.                 */
    
56.                      /* 擦除扇区 */
    
57.                     bsp_EraseCpuFlash((uint32_t)para_flash_area);
    
58. 
    0 W) E! o# ^4 \% n! v% o
59.                     ucTest = 0xAA;
    
60.                     uiTest = 0x55AA;
    
61.                     ulTest = 0x11223344;
    
62. 
    
63.                     /* 扇区写入数据 */
      }0 z' z" T. ]4 H" v
64.                     bsp_WriteCpuFlash((uint32_t)para_flash_area + 32*0,  (uint8_t *)&ucTest,
    
65. sizeof(ucTest));
    
66.                     bsp_WriteCpuFlash((uint32_t)para_flash_area + 32*1,  (uint8_t *)&uiTest,
    % c# ^& o9 T1 F8 b
67. sizeof(uiTest));
    - B, K0 Z+ f* ]# m
68.                     bsp_WriteCpuFlash((uint32_t)para_flash_area + 32*2,  (uint8_t *)&ulTest,
    
69. sizeof(ulTest));               
    & f: l( I2 ?' Z: J; T& S& m
70. 
    ! t1 ~3 N  @  f
71.                     /* 读出数据并打印 */
    
72.                     ptr8  = (uint8_t  *)(para_flash_area + 32*0);
    
73.                     ptr16 = (uint16_t *)(para_flash_area + 32*1);
    $ W& b0 ^" I* f* E" ^1 `2 z* k
74.                     ptr32 = (uint32_t *)(para_flash_area + 32*2);
    % f' ]; l1 J7 I7 [: e3 ^- `2 A. X
75. 
    
76.                     printf("写入数据：ucTest = %x, uiTest = %x, ulTest = %x\r\n", ucTest, uiTest, ulTest);
    
77.                     printf("读取数据：ptr8 = %x, ptr16 = %x, ptr32 = %x\r\n", *ptr8, *ptr16, *ptr32);
    1 q9 X6 ^6 M+ @" Y1 n/ `# V
78. 
    ! a& k+ y1 E8 D6 A# J' \  ^
79.                     break;
    
80. 
    
81.                 case KEY_DOWN_K2:            /* K2键按下， 将结构体数据写入到内部Flash */
    
82.                     /* 擦除扇区 */
    ; F& C1 Q- l2 {& F0 Z& t
83.                     bsp_EraseCpuFlash((uint32_t)para_flash_area);
    
84. 
    2 Q1 E! k. X+ t4 I. ]
85.                     /* 扇区写入数据 */
    . Z" }9 l4 B: `1 t+ `  e
86.                     bsp_WriteCpuFlash((uint32_t)para_flash_area,  (uint8_t *)&tPara, sizeof(tPara));            
    8 @0 V8 {# k7 E9 l! M- \0 b, S
87. 
    
88.                     /* 读出数据并打印 */
    
89.                     paraptr  = (PARAM_T  *)((uint32_t)para_flash_area);
    ; N1 c! [! d' K6 ?
90. 
    2 v$ f7 `9 H- N6 i5 C! a5 |- y
91. 
    
92.                     printf("写入数据：Baud485=%x, ParamVer=%x, ucBackLight=%x, ucRadioMode=%f\r\n",
    
93.                                                                        tPara.Baud485,
    
94.                                                                         tPara.ParamVer,
    5 L% I) ^# k- ?! x
95.                                                                         tPara.ucBackLight,
    
96.                                                                    paraptr->ucRadioMode);
    7 b1 e1 C" m: G) |0 H0 c/ r1 o
97. 
    
98.                     printf("读取数据：Baud485=%x, ParamVer=%x, ucBackLight=%x, ucRadioMode=%f\r\n",
    3 i! v0 \2 Z* K. z
99.                                                                         paraptr->Baud485,
    
100.                                                                             paraptr->ParamVer,
     ( y2 }; B, [# r: a( d2 a7 {! g5 G
101.                                                                            paraptr->ucBackLight,
     + |) N! ^  t2 x9 B
102.                                                                           paraptr->ucRadioMode);
     % L* t) t  L. j* E# Q8 k* d- \
103.                     break;               
     
104.                 default:
     
105.                     /* 其它的键值不处理 */
     
106.                     break;
     
107.             }
     
108.         }
     ( V: i. E" E1 d  B2 E' V$ u
109.     }
     
110. }

复制代码

/ T( Y2 g6 [6 d71.8 总结
+ ?4 o8 }* P4 ^  [9 h2 ?本章节就为大家讲解这么多， 实际应用中的注意事项比较多，应用到项目之前务必实际测试熟悉下。