71.1 初学者重要提示
  学习本章节前，务必优先学习第70章。
4 g8 r) H* T! o4 x  使用内部Flash模拟EEPROM，务必告诉编译要使用的存储空间，防止这个空间存入了程序。
  STM32H7的Flash编程时，务必保证要编程的地址是32字节对齐的，即此地址对32求余为0。并且编程的数据必须32字节整数倍。
4 F: I* r% ?; H- \! ~  STM32H743XI有两个独立的BANK，一个BANK的编程和擦除操作对另一个BANK没有任何影响。但是用户应用程序和要擦写的Flash扇区在同一个BANK，在执行擦写操作时，应用应用程序将停止运行，包括中断服务程序。
7 G. I, Z" C( @' v- H  使用内部Flash模拟EEPROM要做到先擦除后使用。
71.2 模拟EEPROM驱动设计
8 Y, j- B2 {1 |* o/ ]0 ?这里重点把内部Flash的读取，编程和擦除做个说明。

+ ]7 L/ J( v- Z8 c0 [. y71.2.1 内部Flash擦除的实现
内部Flash的擦除思路如下：
2 H% U- W* K3 N+ Q( `
  第1步，获取擦除地址所处的扇区。
  第2步，调用函数HAL_FLASH_Unlock解锁。
  第3步，调用函数HAL_FLASHEx_Erase擦除一个扇区。
  第4步，调用函数HAL_FLASH_Lock上锁。
按照这个思路，程序实现如下：
7 K3 K- _" v+ F. d7 U

1. 1.    /*
   5 \3 I+ \8 h  B- D0 ~2 R
2. 2.    ******************************************************************************************************
   8 T3 P6 d/ m3 D3 s, ~
3. 3.    *    函 数 名: bsp_EraseCpuFlash
   
4. 4.    *    功能说明: 擦除CPU FLASH一个扇区 （128KB)
     B" _1 _0 X' g9 R. R5 M
5. 5.    *    形    参: _ulFlashAddr : Flash地址
   
6. 6.    *    返 回 值: 0 成功， 1 失败
   2 N) y$ H% f" o8 q7 O' G( M( V
7. 7.    *              HAL_OK       = 0x00,
   1 c& |! L8 ]3 ?3 _
8. 8.    *              HAL_ERROR    = 0x01,
   
9. 9.    *              HAL_BUSY     = 0x02,
   0 X  w* @: L; }2 e
10. 10.    *              HAL_TIMEOUT  = 0x03
    * `( ^1 u9 N% c& r" h7 D9 ^
11. 11.    *
    
12. 12.    ******************************************************************************************************
    , v* }: q% k' q9 |: \- ^+ ]6 x4 R5 I& }
13. 13.    */
    8 a- a8 C$ C' Q' W! x# q1 X7 k
14. 14.    uint8_t bsp_EraseCpuFlash(uint32_t _ulFlashAddr)
    8 \6 W; w4 @$ g* {; d! O
15. 15.    {
    ! p# O$ A5 r5 a0 [8 s6 y
16. 16.        uint32_t FirstSector = 0, NbOfSectors = 0;
    
17. 17.        FLASH_EraseInitTypeDef EraseInitStruct;
    ' m2 [6 L7 N6 B, `& Y
18. 18.        uint32_t SECTORError = 0;
    / K; M$ }7 x& e, L$ D' j4 \& i0 ?
19. 19.        uint8_t re;
    
20. 20.   
    
21. 21.        /* 解锁 */
    
22. 22.        HAL_FLASH_Unlock();
    ; W, a* T6 }9 K8 @# ?! l
23. 23.        
    # a- E: C  B9 o, U
24. 24.        /* 获取此地址所在的扇区 */
    * t! y# Y+ C4 D1 l7 {) P
25. 25.        FirstSector = bsp_GetSector(_ulFlashAddr);
    
26. 26.        
    & A  I& \4 c, C! I& \4 g; b
27. 27.        /* 固定1个扇区 */
    3 y' r0 X  F( z/ p1 v
28. 28.        NbOfSectors = 1;   
    * o) D2 s# t5 A3 j- \1 I
29. 29.   
    : p: L+ C3 ^% @1 e/ u# m- C3 e7 u
30. 30.        /* 擦除扇区配置 */
    
31. 31.        EraseInitStruct.TypeErase     = FLASH_TYPEERASE_SECTORS;
    
32. 32.        EraseInitStruct.VoltageRange  = FLASH_VOLTAGE_RANGE_3;
    
33. 33.        
    $ C$ }$ U- w5 w6 L6 n
34. 34.        if (_ulFlashAddr >= ADDR_FLASH_SECTOR_0_BANK2)
    ' j2 S" H5 @) I' t$ ]- u
35. 35.        {
    / x5 E, H" [8 l1 ]2 W
36. 36.            EraseInitStruct.Banks         = FLASH_BANK_2;
    6 z4 H+ g5 m2 i( E! x* N8 e. G
37. 37.        }
    9 R' L; U0 r+ c6 z
38. 38.        else
    
39. 39.        {
    
40. 40.            EraseInitStruct.Banks         = FLASH_BANK_1;
    
41. 41.        }
    
42. 42.        
    
43. 43.        EraseInitStruct.Sector        = FirstSector;
    * i. D( U" k8 g9 `8 P
44. 44.        EraseInitStruct.NbSectors     = NbOfSectors;
    
45. 45.        
    
46. 46.        /* 扇区擦除 */   
    9 s2 N3 ?( H& e5 C0 B8 I
47. 47.        re = HAL_FLASHEx_Erase(&EraseInitStruct, &SECTORError);
    
48. 48.        
    ( P6 U  b! g' r. n5 N" W0 w4 a1 f
49. 49.        /* 擦除完毕后，上锁 */
    ! F% J6 N% ^: J2 c7 t: W6 }
50. 50.        HAL_FLASH_Lock();   
    
51. 51.        
    7 q& G" C  G) d' q' M$ u
52. 52.        return re;
    9 ~, [) s, @1 s( g' y
53. 53.    }

复制代码

! {' Q1 l, L, `8 {7 G& _; L9 r
9 O6 J, O. I* W. \4 P
, D! f# I! Q( o- ^7 A$ [! s# Y$ t( r这里将此程序设计的关键点为大家做个说明：

" x5 J" X5 S1 S2 g) L  第25行函数是通过函数bsp_GetSector获取要擦除地址所处的扇区。这个函数的实现比较简单，代码如下：
: r8 o( e# R! V. `

1. /*
   6 }# Y, l0 D, h; t6 A, i0 k$ F, B! r
2. *********************************************************************************************************
   
3. *    函 数 名: bsp_GetSector
   
4. *    功能说明: 根据地址计算扇区首地址
   - r. A& b' A2 d( f; q# m8 H0 I0 e
5. *    形    参: 无
   
6. *    返 回 值: 扇区号（0-7)
   
7. *********************************************************************************************************
   
8. */
   
9. uint32_t bsp_GetSector(uint32_t Address)
   
10. {
    
11.     uint32_t sector = 0;
    , `+ L1 V* P' d. z6 F0 j
12. 
    
13.     if (((Address < ADDR_FLASH_SECTOR_1_BANK1) && (Address >= ADDR_FLASH_SECTOR_0_BANK1)) || \
    " T: ]+ g: l7 D8 `) j8 s
14.         ((Address < ADDR_FLASH_SECTOR_1_BANK2) && (Address >= ADDR_FLASH_SECTOR_0_BANK2)))   
    
15.     {
    / I! P" K! O( Z: [0 H
16.         sector = FLASH_SECTOR_0;  
    % R  _) G1 i( \( Q8 `
17.     }
    6 y6 L3 f, d+ ~7 c+ L/ g8 S3 a8 Z
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)))   
    , f9 Z/ s! X2 a1 M
20.     {
    1 n! Y7 B& M! s$ o6 `9 F# Q( T
21.         sector = FLASH_SECTOR_1;  
    ' ~' v' e) ]6 h1 D" ^( u- }" S
22.     }
    
23.     else if (((Address < ADDR_FLASH_SECTOR_3_BANK1) && (Address >= ADDR_FLASH_SECTOR_2_BANK1)) || \
    
24.       ((Address < ADDR_FLASH_SECTOR_3_BANK2) && (Address >= ADDR_FLASH_SECTOR_2_BANK2)))   
    
25.     {
    : M. K- V9 Z& X' J1 f4 S  V
26.         sector = FLASH_SECTOR_2;  
    
27.     }
    
28.     else if (((Address < ADDR_FLASH_SECTOR_4_BANK1) && (Address >= ADDR_FLASH_SECTOR_3_BANK1)) || \
    & \0 w& X# q% b( \
29.       ((Address < ADDR_FLASH_SECTOR_4_BANK2) && (Address >= ADDR_FLASH_SECTOR_3_BANK2)))   
    
30.     {
    
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)))   
    5 @* U, M! p' {& Y8 I: Q! ?
35.     {
    7 V1 [& G8 E7 g- g1 O; b( i
36.         sector = FLASH_SECTOR_4;  
    & z% W/ B3 _5 v9 `, U1 I
37.     }
    8 X, O+ h8 X* T. {2 i- r
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)))   
    , ~- n5 i2 z3 H* l
40.     {
    
41.         sector = FLASH_SECTOR_5;  
    # P' v8 z9 n2 @5 {! ?. h
42.     }
    : G, ?) b: E7 [: g1 J" q
43.     else if (((Address < ADDR_FLASH_SECTOR_7_BANK1) && (Address >= ADDR_FLASH_SECTOR_6_BANK1)) || \
    
44.       ((Address < ADDR_FLASH_SECTOR_7_BANK2) && (Address >= ADDR_FLASH_SECTOR_6_BANK2)))   
    ) Y. B! |) N7 `/ d6 n: J
45.     {
    ' Y6 w5 `3 z0 ?! e) |& g  B
46.         sector = FLASH_SECTOR_6;  
    
47.     }
    
48.     else if (((Address < ADDR_FLASH_SECTOR_0_BANK2) && (Address >= ADDR_FLASH_SECTOR_7_BANK1)) || \
    
49.       ((Address < CPU_FLASH_END_ADDR) && (Address >= ADDR_FLASH_SECTOR_7_BANK2)))
    5 ~, T8 Z* v/ D5 l' Y
50.     {
    
51.         sector = FLASH_SECTOR_7;  
    1 A. T' O" J! x* E" T
52.     }
    
53.     else
    , J% Q8 G) K4 z% u0 L! p( G5 d1 G
54.     {
    
55.         sector = FLASH_SECTOR_7;
    0 U8 O  w8 S4 w/ Z6 C
56.     }
    1 I- ~  }2 g0 z( V) i9 ^& q$ K9 U
57. 
    
58.     return sector;
    
59. }
    

复制代码

- y* g$ X9 C# M
& x- Z& Z  g& D; T7 v. i由于STM32H7的BANK1和BANK2是独立的，都有8个扇区，所以程序里面只需返回要擦除地址所处的扇区号即可。

  第47行的擦除函数HAL_FLASHEx_Erase在第70章的4.4小节有说明。
71.2.2 内部Flash编程的实现
内部Flash的编程思路如下：

. [4 k, f4 i' u7 [, X  第1步，判断是否要编写数据进去，如果数据已经在内部Flash里面。
  第2步，调用函数HAL_FLASH_Unlock解锁。
6 W, A) I: z4 ?" }, }  第3步，调用函数HAL_FLASH_Program对内部Flash编程数据。
  第4步，调用函数HAL_FLASH_Lock上锁。
按照这个思路，程序实现如下：

; M* b/ o$ @% {' ]

1. 1.    /*
   1 N& `4 C, B; h" q2 |4 n
2. 2.    ******************************************************************************************************
   $ l' }5 b, g; f  e3 e3 C
3. 3.    *    函 数 名: bsp_WriteCpuFlash
   : A: |% N$ a6 V' T! n
4. 4.    *    功能说明: 写数据到CPU 内部Flash。 必须按32字节整数倍写。不支持跨扇区。扇区大小128KB. \
   ; Y- s7 ]% G, }5 H, \
5. 5.    *              写之前需要擦除扇区. 长度不是32字节整数倍时，最后几个字节末尾补0写入.
   ( v' x5 D$ k* Z# j  }5 O1 O) O
6. 6.    *    形    参: _ulFlashAddr : Flash地址
   3 I0 N! l" |1 A/ E
7. 7.    *             _ucpSrc : 数据缓冲区
   : I7 N- d* T7 ?4 n& \2 Y' B
8. 8.    *             _ulSize : 数据大小（单位是字节, 必须是32字节整数倍）
   
9. 9.    *    返 回 值: 0-成功，1-数据长度或地址溢出，2-写Flash出错(估计Flash寿命到)
   # o! @! e  w/ g8 O5 N
10. 10.    ******************************************************************************************************
    7 A! E- M3 a* r& n, }% I
11. 11.    */
    0 \6 d9 e6 x. }) Q( ~" e
12. 12.    uint8_t bsp_WriteCpuFlash(uint32_t _ulFlashAddr, uint8_t *_ucpSrc, uint32_t _ulSize)
    
13. 13.    {
    4 \( {# T" J: `$ d, X7 }+ {! w9 J
14. 14.        uint32_t i;
    
15. 15.        uint8_t ucRet;
    & \" [  D& J% y- q5 R; g4 W
16. 16.   
    % f: U& e$ u( z; k
17. 17.        /* 如果偏移地址超过芯片容量，则不改写输出缓冲区 */
    0 Z1 F" a2 Z' i4 e# _# T
18. 18.        if (_ulFlashAddr + _ulSize > CPU_FLASH_BASE_ADDR + CPU_FLASH_SIZE)
    ; L/ m  f) r9 Z: ]( s
19. 19.        {
    
20. 20.            return 1;
    
21. 21.        }
    
22. 22.   
    1 B) _2 k7 m3 z/ h
23. 23.        /* 长度为0时不继续操作  */
    
24. 24.        if (_ulSize == 0)
    + G3 ~; \, @; T: i
25. 25.        {
    
26. 26.            return 0;
    
27. 27.        }
    ; ~5 I$ [1 W3 i4 _  k3 j9 Z
28. 28.   
    8 U8 i5 o5 _8 U- n% d
29. 29.        ucRet = bsp_CmpCpuFlash(_ulFlashAddr, _ucpSrc, _ulSize);
    2 q. {; p. I( e
30. 30.   
    
31. 31.        if (ucRet == FLASH_IS_EQU)
    / ^2 O; \, f. B' f. b
32. 32.        {
    
33. 33.            return 0;
    
34. 34.        }
    : S( p7 t2 C0 O0 U& {# E
35. 35.   
    : E9 Q. c5 Z2 y, J8 G5 n( s* I# R( \
36. 36.        __set_PRIMASK(1);          /* 关中断 */
    * i# J, n4 |$ r4 ^; H' k
37. 37.   
    
38. 38.        /* FLASH 解锁 */
    : _" E  e8 b' t
39. 39.        HAL_FLASH_Unlock();
    
40. 40.   
    
41. 41.        for (i = 0; i < _ulSize / 32; i++)   
    $ Q4 J9 T5 w: ]1 E
42. 42.        {
    
43. 43.            uint64_t FlashWord[4];
    
44. 44.            
    
45. 45.            memcpy((char *)FlashWord, _ucpSrc, 32);
    ' i+ S& O( B6 b" r
46. 46.            _ucpSrc += 32;
    1 k& |8 l- q& |% R4 C
47. 47.            
    ! a- _3 n2 J  u8 x& K3 N- J
48. 48.            if (HAL_FLASH_Program(FLASH_TYPEPROGRAM_FLASHWORD, _ulFlashAddr,
    
49. 49.                                      (uint64_t)((uint32_t)FlashWord)) == HAL_OK)
    
50. 50.            {
    , j2 F( U0 H; d  Q$ ~3 }
51. 51.                _ulFlashAddr = _ulFlashAddr + 32; /* 递增，操作下一个256bit */               
    7 _" G/ }/ L( h+ ?7 f: \) k# o9 z5 g
52. 52.            }        
    
53. 53.            else
    
54. 54.            {
    6 M2 z# F1 h) E: G3 `7 a) v# ?
55. 55.                goto err;
    & z  e. o5 A# }0 R* C6 T, X9 H
56. 56.            }
    
57. 57.        }
    
58. 58.        
    6 [2 W0 @! E1 }6 y$ y0 D+ j0 L
59. 59.        /* 长度不是32字节整数倍 */
    
60. 60.        if (_ulSize % 32)
    
61. 61.        {
    ! Y9 I7 ?7 J/ x
62. 62.            uint64_t FlashWord[4];
    , `# P5 f7 S( V  r6 I  l* @/ U
63. 63.            
    " q3 j: p9 B$ F% M! J, V( B
64. 64.            FlashWord[0] = 0;
    ) q7 o1 |* V0 q; C) |
65. 65.            FlashWord[1] = 0;
    
66. 66.            FlashWord[2] = 0;
    ; t6 k0 [9 v. Z
67. 67.            FlashWord[3] = 0;
    4 z% l# i; T- z- s3 _( Y
68. 68.            memcpy((char *)FlashWord, _ucpSrc, _ulSize % 32);
    2 `  t  V  H1 ]/ Q- x
69. 69.            if (HAL_FLASH_Program(FLASH_TYPEPROGRAM_FLASHWORD, _ulFlashAddr,
      W$ {2 a# D% Q% z5 v' i
70. 70.                                               (uint64_t)((uint32_t)FlashWord)) == HAL_OK)
    " n. a# e: `( Z! e7 S, A
71. 71.            {
    
72. 72.                ; // _ulFlashAddr = _ulFlashAddr + 32;
    ! {- u8 c) p+ x) l/ s5 u( m
73. 73.               
    
74. 74.            }        
    7 C1 y) P' {' F6 r5 J/ q
75. 75.            else
    
76. 76.            {
    
77. 77.                goto err;
    : o1 k/ g2 m; j" ?! [
78. 78.            }
    " c1 D: [% p& ?  {
79. 79.        }
    
80. 80.        
    0 t2 Y. G6 S$ g, }  t. {& r$ a1 c) I
81. 81.          /* Flash 加锁，禁止写Flash控制寄存器 */
    
82. 82.          HAL_FLASH_Lock();
    0 g/ P* }) L8 B
83. 83.   
    / I- Q1 o5 L) E# q  Q/ M
84. 84.          __set_PRIMASK(0);          /* 开中断 */
    5 d6 G  M+ \8 p9 u
85. 85.   
    ) @; |4 X" u- `$ i+ {/ U& o
86. 86.        return 0;
    , h! Y% D: N! b+ y" H  o3 }0 G9 H
87. 87.        
    
88. 88.    err:
    
89. 89.          /* Flash 加锁，禁止写Flash控制寄存器 */
    0 X* Z0 R7 i1 J0 v9 Z* b- ]6 x
90. 90.          HAL_FLASH_Lock();
    2 y. f. p, C8 K% D
91. 91.   
    
92. 92.          __set_PRIMASK(0);          /* 开中断 */
    2 q8 r, t# }( Q% Q; F+ ?) F. ]
93. 93.   
    
94. 94.        return 1;
    
95. 95.    }
    ; L6 H/ C; C% k2 b: y. H1 ?

复制代码

. W, ~/ C  u. h+ t1 V  j关于此函数有几个要点：

  第1个参数必须32字节对齐，即要编程的Flash地址对32求余为0。
  m" s% `, p: w  第3个参数必须是32字节的整数倍，长度不是32字节整数倍时，最后几个字节补0写入。
  第29行，函数bsp_CmpCpuFlash放在这里只有一个作用，判断将要写入的数据是否已经在内部Flash存在，如果已经存在，无需重复写入，直接返回。
  第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读取的实现
6 d' h. `4 ^* @$ T3 q内部Flash数据读取比较简单，采用总线方式读取，跟访问内部RAM是一样的。比如要读取地址
7 @6 v1 g5 u+ c* w6 A
6 j- l8 ]" P: K) S# V0x08100000里面的一个32bit变量，我们就可以：

. K5 f) W5 W% _5 i7 D2 x3 q变量 = *(uint32_t *)(0x08100000)
1 ^) m6 V8 e% [3 @
为了方便起见，也专门准备了一个函数：

) G5 W# L/ @7 Z6 @( a; a2 Z

1. /*
   
2. *********************************************************************************************************
   . [- H& `0 g1 A. k0 Y) U
3. *    函 数 名: bsp_ReadCpuFlash
   
4. *    功能说明: 读取CPU Flash的内容
   
5. *    形    参:  _ucpDst : 目标缓冲区
   
6. *             _ulFlashAddr : 起始地址
   
7. *             _ulSize : 数据大小（单位是字节）
   ' `# k5 H: b  h" e5 M
8. *    返 回 值: 0=成功，1=失败
   ' f- {4 }& D: v  m
9. *********************************************************************************************************
   
10. */
    
11. uint8_t bsp_ReadCpuFlash(uint32_t _ulFlashAddr, uint8_t *_ucpDst, uint32_t _ulSize)
    & E! V/ u- l, P- a; O& Q
12. {
    " Q0 p3 D) f5 e' b5 _
13.     uint32_t i;
    8 [( G- Q! q( Q. S
14. 
    5 _3 O, o2 S9 X8 v* [$ E# Y
15.     if (_ulFlashAddr + _ulSize > CPU_FLASH_BASE_ADDR + CPU_FLASH_SIZE)
    / _' j. \6 R8 V+ F: u6 }
16.     {
    
17.         return 1;
    7 D5 m1 u- m6 f& U7 {
18.     }
    
19. 
    * T0 l3 D6 h1 H! a& p  p4 I/ v
20.     /* 长度为0时不继续操作,否则起始地址为奇地址会出错 */
    
21.     if (_ulSize == 0)
    
22.     {
    
23.         return 1;
    : E; ^0 L/ a  @3 ~
24.     }
    
25. 
    
26.     for (i = 0; i < _ulSize; i++)
    9 d, L1 z9 [6 M( C
27.     {
    ! Q6 Y% ]$ m1 V9 D2 d# q
28.         *_ucpDst++ = *(uint8_t *)_ulFlashAddr++;
    ! @' H3 |) [3 ]  {: J
29.     }
    1 O4 p* o% C8 @5 S
30. 
    
31.     return 0;
    
32. }
    . w* v9 j$ b$ Q; V

复制代码

71.2.4 告诉编译器使用的扇区（重要）
使用内部Flash模拟EEPROM切不可随意定义一个扇区使用。因为编译器并不知道用户使用了这个扇区，导致应用程序也会编程到此扇区里面，所以就需要告诉编译器。

  H' j9 g, I! T: {2 c; y告诉MDK的方法如下（0x0810 0000是H7的BANK2首地址）：
' z$ c% y. _6 C$ n& k# M: B

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

复制代码

+ s8 n- q8 i8 t. W( n告诉IAR的方法如下：
+ z) A6 G- |1 X: ^

1. #pragma location=0x08100000
   
2. const uint8_t para_flash_area[128*1024];
   , G! k3 [" x1 R4 ?; p: z

复制代码

7 M% i, T) s0 T5 f7 D) \这里有两点特别注意：
8 K  @: e$ K6 D) L- `( P8 H
2 P1 E) ^2 D  ?$ n; {  模拟EEPROM的扇区可以定义到从第2个扇区开始的任何扇区，但不可以定义到首扇区，因为这个扇区是默认的boot启动地址。
  如果应用程序不大的话，不推荐定义到末尾扇区，以MDK为例，定义到末尾扇区后，会导致整个Flash空间都被使用，从而让程序下载下载时间变长。
71.3 模拟EEPROM板级支持包（bsp_cpu_flash.c）
- B* p$ f9 f7 i! Y  r模拟EEPROM的驱动文件bsp_cpu_flash.c主要实现了如下几个API供用户调用：
, R. d' I6 j0 _1 u( Q  k+ I
  bsp_GetSector
7 a# v% A) M0 F9 }  bsp_ReadCpuFlash
  bsp_CmpCpuFlash
  bsp_EraseCpuFlash
  Q$ o! U8 l7 o& g  bsp_WriteCpuFlash
71.3.1 函数bsp_GetSector
5 O! Y$ O! t- g9 ?$ A+ M6 ~函数原型：

1. uint32_t bsp_GetSector(uint32_t Address)

复制代码

函数描述：
2 u6 f4 _0 m9 {: u
此函数主要用于获取给定地址所处的扇区。
5 M) v) i# ]9 X2 `0 C
, _  E1 p! A. X' D  r5 ]; J! |/ M函数参数：
0 J9 t" a3 }2 i" K5 e+ e4 a8 S& i
  第1个参数是用户给定的地址。
  返回值，范围FLASH_SECTOR_0到FLASH_SECTOR_7。
71.3.2 函数bsp_ReadCpuFlash
0 U0 n0 y- D: |4 s0 d3 _. |函数原型：

5 X6 N6 e4 r! U7 e8 k+ e

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

复制代码

函数描述：

* @# ^2 S; e$ W此函数用于从内部Flash读取数据

函数参数：

  第1个参数读取的起始地址。
  第2个参数是读取数据的存储地址
  第3个参数是读取数据的大小，单位字节。
  返回值，0表示成功，1表示失败。
0 i  Y8 _6 ?( y/ J! c3 O71.3.3 函数bsp_CmpCpuFlash
; A3 \/ H/ ^) U! C: q6 p  \& ^9 u函数原型：
5 g! H. z; F% t
uint8_t bsp_CmpCpuFlash(uint32_t _ulFlashAddr, uint8_t *_ucpBuf, uint32_t _ulSize)

2 E% r5 R- m" Y2 T7 H  X4 m. f函数描述：

+ R3 V1 G9 z4 f) K! o要编程的数据是否在内部Flash已经存在。
9 y) F. M$ p0 y+ B5 p) n
, R: |5 T; m7 B2 j$ L函数参数：

/ x- \% Q# g7 r4 P. H$ @  第1个参数是内部Flash地址。
  第2个参数是缓冲区地址。
; P1 T3 q0 h( k2 ^  第3个参数是数据大小，单位字节。
  返回值：
, Z4 m* _) V  uFLASH_IS_EQU               0   Flash内容和待写入的数据相等，不需要擦除和写操作。

* e/ {9 D: P2 X. RFLASH_REQ_WRITE          1     Flash不需要擦除，直接写。

FLASH_REQ_ERASE          2     Flash需要先擦除,再写。
4 y) a* @1 R2 x/ j" T% t) E$ E
3 y* F7 a. f% `( kFLASH_PARAM_ERR         3     函数参数错误。

71.3.4 函数bsp_EraseCpuFlash
  P( D* A  a5 V- Z- O函数原型：

7 X, D( z% W" l$ ouint8_t bsp_EraseCpuFlash(uint32_t _ulFlashAddr)
3 z; w% A# P! I3 X
( r3 Q. N0 C( i  X! \5 x' n函数描述：
$ \: U: |5 Z8 y5 F4 \
此函数用于擦除一个扇区，大小128KB
! w+ u* Q, e. u  H9 l
' v3 H9 q. _4 F( _. C5 ~0 Y" O函数参数：
/ X! N8 ?9 u5 ^+ }
0 {1 L+ Q4 F+ Y/ Z  第1个参数要擦除的扇区地址，可以是此扇区范围内的任意值，一般填扇区首地址即可。
  返回值：
HAL_OK        = 0x00
) V6 M( Q9 S& d8 M- E+ U
HAL_ERROR    = 0x01

6 O; B! B& g- O. u* l, FHAL_BUSY      = 0x02

0 O# r. g% S5 K. EHAL_TIMEOUT  = 0x03

71.3.5 函数bsp_WriteCpuFlash
函数原型：

6 u( E0 N: H* T" ?# t, ]uint8_t bsp_WriteCpuFlash(uint32_t _ulFlashAddr, uint8_t *_ucpSrc, uint32_t _ulSize)
: @7 u& e# A* U$ a3 ^/ A% `
8 x8 F! z& P5 f6 t5 V函数描述：
4 I# p4 s, L$ U( Q6 b
此函数用于编程数据到内部Flash。
( u( C: \# N* P' |! U! l
函数参数：

# ^0 {$ k2 m# @+ L* e% S; Q9 T4 n  第1个参数是要编程的内部Flash地址。
  第2个参数是数据缓冲区地址。
6 b! U- m! G3 J2 X2 ^, c/ _6 W  第3个参数是数据大小，单位字节。
- C# \  {$ _+ t1 O  返回值，0-成功，1-数据长度或地址溢出，2-写Flash出错(估计Flash寿命到)。
5 N* W/ g- ?6 \注意事项：

6 }" e' B7 M/ S$ c) j1 Q, T  第1个参数必须32字节对齐，即要编程的Flash地址对32求余为0。
  第3个参数必须是32字节的整数倍，长度不是32字节整数倍时，此函数会将几个字节补0写入
71.4 模拟EEPROM驱动移植和使用
模拟EEPROM移植步骤如下：
  j7 Z' V0 X( G2 q# T
  第1步：复制bsp_cpu_flash.c和bsp_cpu_flash.h到自己的工程目录，并添加到工程里面。
  第2步：Flash驱动文件主要用到HAL库的Flash驱动文件，简单省事些可以添加所有HAL库C源文件进来。
; N- V4 }, T9 c* T1 s5 I* m% g  第3步，应用方法看本章节配套例子即可。
71.5 实验例程设计框架
! n* b$ R0 D/ X& l  E通过程序设计框架，让大家先对配套例程有一个全面的认识，然后再理解细节，本次实验例程的设计框架如下：
$ v! G0 o9 f, k/ R! {' u9 a
+ T2 T) _! p$ e3 \

  第1阶段，上电启动阶段：
! m, N1 ?5 _7 z7 f* K
. v9 N% O: [% A' I9 p: \9 L这部分在第14章进行了详细说明。
  第2阶段，进入main函数：

  第1部分，硬件初始化，主要是MPU，Cache，HAL库，系统时钟，滴答定时器和LED。
1 Y' H% e4 P  x5 J9 `% Y, L' t  第2部分，应用程序设计部分，实现内部Flash模拟EEPROM。
71.6 实验例程说明（MDK）
; y3 O* g  `9 @2 J7 t2 _9 S; |配套例子：
, a# ~, f+ A' A1 F
V7-049_内部Flash模拟EEPROM

实验目的：

学习内部Flash模拟EEPROM。
实验内容：
9 U, o1 r) U6 J) a# \, a" t
* _6 l- K( T* Q: o# k. f. `使用内部Flash模拟EEPROM，务必告诉编译要使用的存储空间，防止这个空间存入了程序。
+ c( ?3 @1 B4 q, u对于同一个地址空间，仅支持一次编程(不推荐二次编程，即使是将相应bit由数值1编程0)。
6 s9 Z  Z3 V7 [; L只能对已经擦除的空间做编程，擦除1个扇区是128KB。
% d! _5 }, G/ y0 F) X3 VH7的Flash编程时，务必保证要编程的地址是32字节对齐的，即此地址对32求余为0。
4 t- n( [2 {9 M* x并且编程的数据必须32字节整数倍，函数bsp_WriteCpuFlash对字节数不够32字节整数倍的情况自动补0。

7 o! _* G/ |% }0 V# P3 H实验操作：

K1键按下，将8bit，16bit和32bit数据写入到内部Flash。
K2键按下，将结构体数据写入到内部Flash。
8 J6 e' [8 T4 W) k上电后串口打印的信息：
& @7 a* B/ \0 T8 m5 ~5 _: ~
波特率 115200，数据位 8，奇偶校验位无，停止位 1。
, M- I$ K( }7 t( F9 T( \1 ^6 k+ b
6 a0 Z+ D, _4 X

$ f. C$ A' H' ^+ y  J程序设计：
1 N  ?$ @- `2 V, s8 v
  系统栈大小分配：
' u8 _7 D' o* T) F3 d7 H( `1 D

( u4 S+ U0 ?, z: [7 q& V
/ |+ N- k! b% G  RAM空间用的DTCM：

, q% U% r) [6 X' c, Q" T

5 \, g7 {; A3 B
  硬件外设初始化
( ~4 a6 R4 ?* F/ s
硬件外设的初始化是在 bsp.c 文件实现：
3 |1 \. I5 y* j# G! J+ y

1. /*
   4 r9 H- A' K. c- i1 w9 Q3 @3 i
2. *********************************************************************************************************
   $ H6 c) |! I8 D" U$ x
3. *    函 数 名: bsp_Init
   ! [! G) ~/ D! M7 n  e! `
4. *    功能说明: 初始化所有的硬件设备。该函数配置CPU寄存器和外设的寄存器并初始化一些全局变量。只需要调用一次
   
5. *    形    参：无
   
6. *    返 回 值: 无
   ' b1 Q) X" \/ V/ V0 ]
7. *********************************************************************************************************
   
8. */
   
9. void bsp_Init(void)
   
10. {
    
11.     /* 配置MPU */
    
12.     MPU_Config();
    
13. 
    9 O2 z1 p' h" a+ u
14.     /* 使能L1 Cache */
    
15.     CPU_CACHE_Enable();
    . H6 n( j$ H4 d9 O; L% \/ g% k
16. 
    . t3 l1 _- f# l
17.     /*
    ; |# y9 r5 v7 C; z: a' _, N
18.        STM32H7xx HAL 库初始化，此时系统用的还是H7自带的64MHz，HSI时钟:
    
19.        - 调用函数HAL_InitTick，初始化滴答时钟中断1ms。
    1 U% k# O# P: k9 \8 r3 s/ p
20.        - 设置NVIV优先级分组为4。
    1 M' h8 ^% ~& w& x8 y% Q: m5 f
21.      */
    
22.     HAL_Init();
    " {9 H* p% I0 q7 k) C7 S( h
23. 
    2 Y5 u: V( I1 f' B; T4 @6 j3 J
24.     /*
    
25.        配置系统时钟到400MHz
    
26.        - 切换使用HSE。
    3 z, S( u; w& d+ s- N& P
27.        - 此函数会更新全局变量SystemCoreClock，并重新配置HAL_InitTick。
    ! `. l+ _3 b/ Q  r! x2 g, x
28.     */
    + ]8 d/ r8 X5 u% y. M: K$ H4 C
29.     SystemClock_Config();
    
30. 
    
31.     /*
      C. ?8 F8 z" r8 q
32.        Event Recorder：
    
33.        - 可用于代码执行时间测量，MDK5.25及其以上版本才支持，IAR不支持。
    
34.        - 默认不开启，如果要使能此选项，务必看V7开发板用户手册第xx章
    5 L3 z3 N! |+ y5 |
35.     */   
    % O  J) g2 L1 y4 z& e
36. #if Enable_EventRecorder == 1  
    - y( e: S% b  w" z% l& V# J7 t
37.     /* 初始化EventRecorder并开启 */
    
38.     EventRecorderInitialize(EventRecordAll, 1U);
    
39.     EventRecorderStart();
    
40. #endif
    $ b( ]5 J- ]3 w2 Y  w  X
41. 
    ! [* U- v5 Q3 p7 W% H3 U/ J0 x
42. bsp_InitDWT();      /* 初始化DWT时钟周期计数器 */      
    
43.     bsp_InitKey();        /* 按键初始化，要放在滴答定时器之前，因为按钮检测是通过滴答定时器扫描 */
    ; I" t1 Z% R# Q' [5 L6 a4 A+ D3 g
44.     bsp_InitTimer();      /* 初始化滴答定时器 */
    
45.     bsp_InitLPUart();    /* 初始化串口 */
    
46.     bsp_InitExtIO();    /* 初始化FMC总线74HC574扩展IO. 必须在 bsp_InitLed()前执行 */   
    2 U* g& j& B6 ^& Z  I5 P8 m
47.     bsp_InitLed();        /* 初始化LED */   
    $ f8 s" ]- c) |* @, p
48.     bsp_InitExtSDRAM(); /* 初始化SDRAM */
    : M$ Y" r% @2 W! D  G% f" r9 {( }
49. }
    

复制代码

3 ^3 @' b$ v5 @; A1 s3 B
  F- H0 p/ u' c. b2 I  MPU配置和Cache配置：

" ~/ v* Q4 y. X- ?数据Cache和指令Cache都开启。配置了AXI SRAM区（本例子未用到AXI SRAM）和FMC的扩展IO区。

1. /*
   
2. *********************************************************************************************************
   
3. *    函 数 名: MPU_Config
   
4. *    功能说明: 配置MPU
   
5. *    形    参: 无
   % T" D9 {" m0 n: ^
6. *    返 回 值: 无
   + {4 ?$ ^/ L1 ]6 r9 |" P7 y
7. *********************************************************************************************************
   % Y: C- C1 o6 Y" [5 P! f0 V
8. */
   2 ^; _8 o" \4 t3 r" X3 F8 g" u! j& [
9. static void MPU_Config( void )
   7 J. |5 M' F# ]* f* }
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 */
    " b# ~* n1 t% F: S. q5 {
17.     MPU_InitStruct.Enable           = MPU_REGION_ENABLE;
    ( e- J/ f) V4 C; e0 R3 G
18.     MPU_InitStruct.BaseAddress      = 0x24000000;
    
19.     MPU_InitStruct.Size             = MPU_REGION_SIZE_512KB;
    
20.     MPU_InitStruct.AccessPermission = MPU_REGION_FULL_ACCESS;
    
21.     MPU_InitStruct.IsBufferable     = MPU_ACCESS_BUFFERABLE;
    : Q4 L0 U" M- V
22.     MPU_InitStruct.IsCacheable      = MPU_ACCESS_CACHEABLE;
    
23.     MPU_InitStruct.IsShareable      = MPU_ACCESS_NOT_SHAREABLE;
    
24.     MPU_InitStruct.Number           = MPU_REGION_NUMBER0;
    ' \8 |+ p0 o6 X/ V0 l( |$ p9 M
25.     MPU_InitStruct.TypeExtField     = MPU_TEX_LEVEL1;
    8 b( L' p! ]7 M+ z# R, M
26.     MPU_InitStruct.SubRegionDisable = 0x00;
    
27.     MPU_InitStruct.DisableExec      = MPU_INSTRUCTION_ACCESS_ENABLE;
    % R7 k7 t5 Y( U: N5 ]9 a7 G5 ]
28. 
    
29.     HAL_MPU_ConfigRegion(&MPU_InitStruct);
    1 ?9 v: Z8 A/ f  [+ B
30. 
    
31. 
    
32.     /* 配置FMC扩展IO的MPU属性为Device或者Strongly Ordered */
    . h& d* f+ w- I2 U1 O
33.     MPU_InitStruct.Enable           = MPU_REGION_ENABLE;
    
34.     MPU_InitStruct.BaseAddress      = 0x60000000;
    
35.     MPU_InitStruct.Size             = ARM_MPU_REGION_SIZE_64KB;   
    ' i9 c; T4 {) g3 T6 h/ t! Z
36.     MPU_InitStruct.AccessPermission = MPU_REGION_FULL_ACCESS;
    1 a1 c: _7 Q0 |3 p
37.     MPU_InitStruct.IsBufferable     = MPU_ACCESS_BUFFERABLE;
    & @+ p! i2 f( H5 V1 P
38.     MPU_InitStruct.IsCacheable      = MPU_ACCESS_NOT_CACHEABLE;   
    
39.     MPU_InitStruct.IsShareable      = MPU_ACCESS_NOT_SHAREABLE;
    
40.     MPU_InitStruct.Number           = MPU_REGION_NUMBER1;
    
41.     MPU_InitStruct.TypeExtField     = MPU_TEX_LEVEL0;
    1 S+ ~1 o, {4 Q4 Q3 q& _
42.     MPU_InitStruct.SubRegionDisable = 0x00;
    5 n5 N5 Z$ ]  u2 t) x& m
43.     MPU_InitStruct.DisableExec      = MPU_INSTRUCTION_ACCESS_ENABLE;
    
44. 
    
45.     HAL_MPU_ConfigRegion(&MPU_InitStruct);
    
46. 
    * J. K9 t0 B+ _+ }# m
47.     /*使能 MPU */
    ( W; p9 ], d/ C
48.     HAL_MPU_Enable(MPU_PRIVILEGED_DEFAULT);
    5 R4 r9 ~0 r  b6 y
49. }
    2 i- ^5 s  z! @9 J8 y4 U( B" P( K
50. 
    
51. /*
    
52. *********************************************************************************************************
    - y0 \1 @! }/ i& P/ r1 A6 G
53. *    函 数 名: CPU_CACHE_Enable
    ; |: _" A8 S+ r* t' G0 A7 p/ U
54. *    功能说明: 使能L1 Cache
    9 ?# Q. L! |6 S
55. *    形    参: 无
    8 K/ G* I8 f' _0 B
56. *    返 回 值: 无
    2 e, P# D  v2 D* \7 G* A
57. *********************************************************************************************************
    
58. */
    
59. static void CPU_CACHE_Enable(void)
    
60. {
    6 X" J( l; I7 j/ E  M
61.     /* 使能 I-Cache */
    
62.     SCB_EnableICache();
    5 ]) A& t5 ]+ ^3 l
63. 
    7 v. r! s- k, |0 U( Z5 r) Z
64.     /* 使能 D-Cache */
    
65.     SCB_EnableDCache();
    
66. }

复制代码

: i' u/ q; ?- G2 I% n: f
  每10ms调用一次蜂鸣器处理：
% z0 V- A7 L3 W* f; a+ r
" {* v3 E9 X4 C2 O5 u& n) U' A蜂鸣器处理是在滴答定时器中断里面实现，每10ms执行一次检测。

( K. q  b% ?6 Z& x# {4 O

1. /*
   
2. *********************************************************************************************************
   ( P9 ?3 x/ }& O5 \( b  e6 A
3. *    函 数 名: bsp_RunPer10ms
   
4. *    功能说明: 该函数每隔10ms被Systick中断调用1次。详见 bsp_timer.c的定时中断服务程序。一些处理时间要求
   " v; u, Q- B/ r
5. *              不严格的任务可以放在此函数。比如：按键扫描、蜂鸣器鸣叫控制等。
   
6. *    形    参: 无
   9 ~5 g! r- B4 q% J1 D
7. *    返 回 值: 无
   
8. *********************************************************************************************************
   - @. H0 q  Y( \  B
9. */
   9 X( H* W- v; m6 T. d/ @" Z
10. void bsp_RunPer10ms(void)
    2 v0 }# Y/ w& Y2 l/ l. q7 {
11. {
    
12.     bsp_KeyScan10ms();
    0 h1 ?  s2 I- B+ f2 l
13. }
    

复制代码

0 V; o8 T& @) g$ H2 O8 L  \& y& s
1 s/ ?- V' t3 i, w* `7 m  主功能：
5 p5 |9 d# H4 s  c  P
5 I! E+ a$ e5 G# |主程序实现如下操作：
! [" t* b! ~# u8 w
* ^$ }5 A0 y/ j2 l  启动一个自动重装软件定时器，每100ms翻转一次LED2。
6 Q; n  S. `- `  K1键按下，将8bit，16bit和32bit数据写入到内部Flash。
' t0 r, {( V9 H  `5 a  K2键按下，将结构体数据写入到内部Flash。

1. /*
   
2. *********************************************************************************************************
   " Q( U3 l1 G6 `: s4 {$ ]
3. *    函 数 名: main
   1 I+ m! j" x  f
4. *    功能说明: c程序入口
   
5. *    形    参: 无
   / m; e' W% L! x0 G4 S
6. *    返 回 值: 错误代码(无需处理)
     ~8 A# g) U! ]* g2 U0 g5 ]7 [
7. *********************************************************************************************************
   
8. */
   
9. int main(void)
   # T- o$ T# S: v6 T( q9 }& ?4 ~% o
10. {
    
11.     uint8_t ucKeyCode;    /* 按键代码 */
    ; O3 s4 i4 p& _% V5 Z# |
12.     uint8_t  ucTest, *ptr8;
    
13.     uint16_t uiTest, *ptr16;
    4 K# K& G) C  B# \
14.     uint32_t ulTest, *ptr32;
    0 o5 d2 O0 e7 V; w4 g1 v
15.     PARAM_T tPara, *paraptr;
    
16. 
    ! X3 G/ V! |+ R0 S
17. 
    7 O" d# X4 p/ x8 l" Z7 k
18.     /* 初始化数据 */
    $ L( v6 m+ V7 a6 u* E
19.     tPara.Baud485 = 0x5555AAAA;
    
20.     tPara.ParamVer = 0x99;
    / S- {* Z' g: l3 n5 w# d% e
21.     tPara.ucBackLight = 0x7788;
    
22.     tPara.ucRadioMode = 99.99f;
    
23. 
    ' `1 S7 o4 `6 k: {# ~
24. 
    
25.     bsp_Init();        /* 硬件初始化 */
    % L  e, c( f# m2 q
26.     PrintfLogo();    /* 打印例程名称和版本等信息 */
    
27.     PrintfHelp();    /* 打印操作提示 */
    
28. 
    ! I8 p# M# t$ E
29.     bsp_StartAutoTimer(0, 100);    /* 启动1个100ms的自动重装的定时器 */
    + a. k, ?$ H4 j1 y; K
30.     while (1)
    0 D1 l0 i. h6 s& Q8 C# C; i
31.     {
    % U0 ~/ ?5 T' O; U4 T
32.         bsp_Idle();        /* 这个函数在bsp.c文件。用户可以修改这个函数实现CPU休眠和喂狗 */
      s% h5 X% U4 ^" x# Q+ R6 [
33. 
    ' @- u. Y* ~1 I" ?! a, K1 B% ?: Z2 ?  W8 ~
34.         /* 判断定时器超时时间 */
    & X3 \& X  F# N
35.         if (bsp_CheckTimer(0))   
    , O  |/ S! R- U" b/ q4 P/ k! t
36.         {
    
37.             /* 每隔100ms 进来一次 */  
    : y+ l. h$ i7 h7 y1 k
38.             bsp_LedToggle(2);
    
39.         }
    # H& Z; n' V8 ~$ f( L5 S, x
40. 
    . j! q/ L. ^5 W. o9 n0 s
41.         /* 按键滤波和检测由后台systick中断服务程序实现，我们只需要调用bsp_GetKey读取键值即可。 */
    ( i6 O* ~- I" Z9 C7 \$ Z2 G
42.         ucKeyCode = bsp_GetKey();    /* 读取键值, 无键按下时返回 KEY_NONE = 0 */
    ( _6 |7 N9 B! Y2 w  F/ Y9 F
43.         if (ucKeyCode != KEY_NONE)
    4 D) |! D8 }& g4 Y2 q
44.         {
    . f0 S, c; g( s6 B$ r
45.             switch (ucKeyCode)
    ; J% O' v1 q% q
46.             {
    
47.                 case KEY_DOWN_K1:            /* K1键按下，将8bit，16bit和32bit数据写入到内部Flash */
    1 c  ~  U( k4 B% h9 I  a8 J
48. 
    / R/ @, S. P8 f3 S
49.                 /*
    
50.                  1、对于同一个地址空间，仅支持一次编程(不推荐二次编程，即使是将相应bit由数值1编程0)。
    
51.                  2、只能对已经擦除的空间做编程，擦除1个扇区是128KB。
    , n5 i& [# ?; E" D3 O
52.                  3、H7的Flash编程时，务必保证要编程的地址是32字节对齐的，即此地址对32求余为0。并且编
    
53. 程的数据必须32字节整数倍。函数bsp_WriteCpuFlash对字节数不够32字节整数倍的情况自动补
    + t  d8 p& r4 Y$ N) C9 k; d1 k
54. 0。
    
55.                 */
    0 V8 S; r( v6 k
56.                      /* 擦除扇区 */
    ; t* K. i* X0 B  [
57.                     bsp_EraseCpuFlash((uint32_t)para_flash_area);
    : u; q0 |8 w- H' o
58. 
    
59.                     ucTest = 0xAA;
    0 w# G# ^! M$ F- c( G$ h  U" d+ O- d
60.                     uiTest = 0x55AA;
      Q4 j$ m" g( `. ?6 j' i8 r
61.                     ulTest = 0x11223344;
    
62. 
    
63.                     /* 扇区写入数据 */
    
64.                     bsp_WriteCpuFlash((uint32_t)para_flash_area + 32*0,  (uint8_t *)&ucTest,
    ( r) M. J+ }9 l, O6 s: f/ o" G* j
65. sizeof(ucTest));
    
66.                     bsp_WriteCpuFlash((uint32_t)para_flash_area + 32*1,  (uint8_t *)&uiTest,
      J" K! n9 M1 u% t8 H6 n1 M: c* W
67. sizeof(uiTest));
    : J; B' X: c0 G1 j+ [3 K5 S
68.                     bsp_WriteCpuFlash((uint32_t)para_flash_area + 32*2,  (uint8_t *)&ulTest,
    9 S! g2 ]3 v! u& G( t) w# p! K
69. sizeof(ulTest));               
    ( `. Q4 U7 {. x
70. 
    
71.                     /* 读出数据并打印 */
    
72.                     ptr8  = (uint8_t  *)(para_flash_area + 32*0);
    
73.                     ptr16 = (uint16_t *)(para_flash_area + 32*1);
    
74.                     ptr32 = (uint32_t *)(para_flash_area + 32*2);
    7 R( M0 T3 u7 L% P! Z3 Q3 ]8 q
75. 
    * `0 e( a5 b  J0 F( Q) N( S
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);
    8 {+ h. L; y9 ?
78. 
    ( m& B0 S1 H1 |
79.                     break;
    
80. 
    ' H. [! Y3 z3 h% T5 }, {% C$ g
81.                 case KEY_DOWN_K2:            /* K2键按下， 将结构体数据写入到内部Flash */
    
82.                     /* 擦除扇区 */
    
83.                     bsp_EraseCpuFlash((uint32_t)para_flash_area);
    
84. 
    8 e7 \5 O& P6 `* y: i* V! G
85.                     /* 扇区写入数据 */
    ; R: b* E7 H! g4 l0 v9 F* i
86.                     bsp_WriteCpuFlash((uint32_t)para_flash_area,  (uint8_t *)&tPara, sizeof(tPara));            
    7 R4 x8 q5 \& c3 D
87. 
    
88.                     /* 读出数据并打印 */
    " _5 \' n# s8 o  Y5 ^* @
89.                     paraptr  = (PARAM_T  *)((uint32_t)para_flash_area);
    
90. 
    
91. 
    8 k0 i( Z3 p; u& \. G" \
92.                     printf("写入数据：Baud485=%x, ParamVer=%x, ucBackLight=%x, ucRadioMode=%f\r\n",
    
93.                                                                        tPara.Baud485,
    
94.                                                                         tPara.ParamVer,
    ) ]8 s# o; ]: E4 o( W. @& d/ R
95.                                                                         tPara.ucBackLight,
    1 U2 h, r3 ^; @- X5 J) V3 R
96.                                                                    paraptr->ucRadioMode);
    
97. 
    
98.                     printf("读取数据：Baud485=%x, ParamVer=%x, ucBackLight=%x, ucRadioMode=%f\r\n",
    " P$ [9 M/ D/ I8 d8 {3 ~
99.                                                                         paraptr->Baud485,
    ; e, x0 ?+ H" T' W* k; ], }' N
100.                                                                             paraptr->ParamVer,
     ! m- N1 }: m% V6 @9 m1 Q5 `
101.                                                                            paraptr->ucBackLight,
     
102.                                                                           paraptr->ucRadioMode);
     
103.                     break;               
       u: y0 ]( p* [, r+ W8 W
104.                 default:
     5 h* X0 {9 o* L# r8 ^
105.                     /* 其它的键值不处理 */
     & d! n% I6 {7 [. {, I% F. T% m
106.                     break;
     # J0 y0 B$ O7 d/ b7 s6 j- T4 ^! t
107.             }
     
108.         }
     
109.     }
     
110. }
     0 a* ~1 x& E, Z/ w/ E; O; ?

复制代码

71.7 实验例程说明（IAR）
% j9 O3 ^) d2 `, l, c3 r配套例子：

' r6 X  V, L5 ^8 RV7-049_内部Flash模拟EEPROM

实验目的：
1 q  |$ y0 b' _+ O
$ o; o9 |  s2 G5 |4 K, P  W学习内部Flash模拟EEPROM。
  L  Q3 l' @8 O) P! ?/ J实验内容：
% }0 T' Z) i& C: r( _
使用内部Flash模拟EEPROM，务必告诉编译要使用的存储空间，防止这个空间存入了程序。
1 ?/ z( ]% F1 u+ R+ \对于同一个地址空间，仅支持一次编程(不推荐二次编程，即使是将相应bit由数值1编程0)。
( s+ B0 i/ x. X$ z只能对已经擦除的空间做编程，擦除1个扇区是128KB。
: @; a+ ?6 {+ G0 a- R2 eH7的Flash编程时，务必保证要编程的地址是32字节对齐的，即此地址对32求余为0。
8 E5 @+ ^' ~9 }) @1 n& D0 H5 l并且编程的数据必须32字节整数倍，函数bsp_WriteCpuFlash对字节数不够32字节整数倍的情况自动补0。
# I% k( c( v- C
: f1 e: m. O" t+ b& l实验操作：

6 v& S" i( J1 y0 O+ k1 RK1键按下，将8bit，16bit和32bit数据写入到内部Flash。
K2键按下，将结构体数据写入到内部Flash。
上电后串口打印的信息：

" o' \( C5 m9 y- m7 @: `波特率 115200，数据位 8，奇偶校验位无，停止位 1。

& J: j# {# s2 d% }6 X7 B

4 d7 L1 O1 I$ m  U: j! D
程序设计：
$ I! \1 K3 f. \8 m3 I
  系统栈大小分配：

! H* {$ _* e6 ]4 Q- c

0 k: {9 g$ g4 w) v0 `
' a1 ]" f$ P9 W# a% Y2 a" e  RAM空间用的DTCM：
7 R) e! B( f8 v  Q3 C
# g' r7 E, _8 \8 R

  硬件外设初始化
. g# t" T, g! p" m( c* `0 U
3 h# Z4 V' R3 D" @+ F' o硬件外设的初始化是在 bsp.c 文件实现：
5 m" w2 @3 ~6 ]+ r
& L- _4 _1 {! T+ `! N

1. /*
   0 L! X* ?) }! [5 l  `7 o
2. *********************************************************************************************************
   
3. *    函 数 名: bsp_Init
   7 a, }: |1 r" a( U
4. *    功能说明: 初始化所有的硬件设备。该函数配置CPU寄存器和外设的寄存器并初始化一些全局变量。只需要调用一次
   
5. *    形    参：无
   + u/ A0 m- W1 m' L2 u. D+ t3 i. D
6. *    返 回 值: 无
   4 U4 j" f* I+ t' K3 i
7. *********************************************************************************************************
   + V! M. n9 l( L* Z+ P2 X% z7 Y
8. */
   6 }  X* z7 c  K2 B2 Y
9. void bsp_Init(void)
   
10. {
    1 j2 k, S* @! e0 D% H
11.     /* 配置MPU */
    ) w# ]8 t9 X' j0 N
12.     MPU_Config();
    / m1 c/ A6 F, ?& j2 ^% P! c
13. 
    
14.     /* 使能L1 Cache */
    , W6 q( e0 i3 m7 P) o4 x# ^) P
15.     CPU_CACHE_Enable();
    
16. 
    
17.     /*
    
18.        STM32H7xx HAL 库初始化，此时系统用的还是H7自带的64MHz，HSI时钟:
    6 i+ ?7 j7 R# |  ]" q; O( q% ]
19.        - 调用函数HAL_InitTick，初始化滴答时钟中断1ms。
    $ m  }0 k! u, L- \: Z( j) W
20.        - 设置NVIV优先级分组为4。
      w" X9 t/ m$ K% v5 h  F/ g
21.      */
    
22.     HAL_Init();
    # b% M/ f) Y% s5 o) w
23. 
    
24.     /*
    * p6 E( u. M! L# ^. |: {; u
25.        配置系统时钟到400MHz
    % A: ~3 ^% b4 F, J
26.        - 切换使用HSE。
    
27.        - 此函数会更新全局变量SystemCoreClock，并重新配置HAL_InitTick。
    
28.     */
    # I0 w( x+ ?) B' b8 l
29.     SystemClock_Config();
    6 n' ~$ y5 Q) Z- X$ K+ B
30. 
    6 l$ a4 ^0 h& j1 \
31.     /*
    
32.        Event Recorder：
      C; f0 K& K  Q$ ^! s5 v
33.        - 可用于代码执行时间测量，MDK5.25及其以上版本才支持，IAR不支持。
    
34.        - 默认不开启，如果要使能此选项，务必看V7开发板用户手册第xx章
    + C1 r: p# Y$ C2 J/ ]! M/ E
35.     */   
    + l* S( p4 {! Y& I8 D! l  J
36. #if Enable_EventRecorder == 1  
    3 [- c, D5 r' f; N4 Q0 Q  V9 Q
37.     /* 初始化EventRecorder并开启 */
    
38.     EventRecorderInitialize(EventRecordAll, 1U);
    
39.     EventRecorderStart();
    
40. #endif
    8 G' D4 i7 y+ e8 ?! \1 E  S5 _
41. 
    5 B7 j9 ^  F, g
42. bsp_InitDWT();      /* 初始化DWT时钟周期计数器 */      
      t+ c; b2 S8 s- |2 i
43.     bsp_InitKey();        /* 按键初始化，要放在滴答定时器之前，因为按钮检测是通过滴答定时器扫描 */
    
44.     bsp_InitTimer();      /* 初始化滴答定时器 */
    
45.     bsp_InitLPUart();    /* 初始化串口 */
    , s1 }2 \$ `# y
46.     bsp_InitExtIO();    /* 初始化FMC总线74HC574扩展IO. 必须在 bsp_InitLed()前执行 */   
    
47.     bsp_InitLed();        /* 初始化LED */   
    
48.     bsp_InitExtSDRAM(); /* 初始化SDRAM */
    ' u& m* v! J0 X4 S6 L% D3 N
49. }
    0 J! `: {! o5 e1 ]& O, t; P3 @

复制代码

- v4 A" T2 [* T7 P4 h% o  MPU配置和Cache配置：
" R. I  `- Q9 k, W, W7 {
5 n9 N: \' c; M4 A$ j" r数据Cache和指令Cache都开启。配置了AXI SRAM区（本例子未用到AXI SRAM）和FMC的扩展IO区。
' I" f0 p# z7 u9 i: o, Q
) }, h# l6 U: D5 A, l6 O$ e

1. /*
   2 }- e6 |( Q4 v6 w8 @9 X' J
2. *********************************************************************************************************
   
3. *    函 数 名: MPU_Config
   
4. *    功能说明: 配置MPU
   
5. *    形    参: 无
   ' z% h: c+ `1 o  J+ p
6. *    返 回 值: 无
   5 v5 M) D) G0 a# e
7. *********************************************************************************************************
   * ]- _' l2 _$ Y  D
8. */
   + T! D0 X, C4 _
9. static void MPU_Config( void )
   4 J# P, Z" s6 E8 U0 Y! ~  `4 ]1 t4 Y
10. {
    
11.     MPU_Region_InitTypeDef MPU_InitStruct;
    
12. 
    
13.     /* 禁止 MPU */
    
14.     HAL_MPU_Disable();
    3 M* j1 ~5 G$ m( c6 P9 w) O, e1 ^
15. 
    
16.     /* 配置AXI SRAM的MPU属性为Write back, Read allocate，Write allocate */
    
17.     MPU_InitStruct.Enable           = MPU_REGION_ENABLE;
    ) {1 X; X) L/ H( Y) H0 i& \
18.     MPU_InitStruct.BaseAddress      = 0x24000000;
    % r8 P6 W1 H8 C8 G
19.     MPU_InitStruct.Size             = MPU_REGION_SIZE_512KB;
    
20.     MPU_InitStruct.AccessPermission = MPU_REGION_FULL_ACCESS;
    
21.     MPU_InitStruct.IsBufferable     = MPU_ACCESS_BUFFERABLE;
    
22.     MPU_InitStruct.IsCacheable      = MPU_ACCESS_CACHEABLE;
    
23.     MPU_InitStruct.IsShareable      = MPU_ACCESS_NOT_SHAREABLE;
    
24.     MPU_InitStruct.Number           = MPU_REGION_NUMBER0;
    
25.     MPU_InitStruct.TypeExtField     = MPU_TEX_LEVEL1;
    9 C- Y4 M  v  \- I' Q( R5 v
26.     MPU_InitStruct.SubRegionDisable = 0x00;
    . I3 `* {2 j' [5 d& x; N3 y9 L
27.     MPU_InitStruct.DisableExec      = MPU_INSTRUCTION_ACCESS_ENABLE;
    : d3 W1 {: e; J, i9 N
28. 
    4 T- O) V$ e' ~6 y5 j) j9 ^
29.     HAL_MPU_ConfigRegion(&MPU_InitStruct);
    ( T4 m, {) E: H9 K) K& \
30. 
    
31. 
    . p+ E0 f5 L) O3 ~; p
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;   
    9 x* _3 G" Y+ \, e- z% ~
36.     MPU_InitStruct.AccessPermission = MPU_REGION_FULL_ACCESS;
    - m, u3 R  g& ]4 o+ u
37.     MPU_InitStruct.IsBufferable     = MPU_ACCESS_BUFFERABLE;
    9 F: Q7 p/ }7 x( {4 T
38.     MPU_InitStruct.IsCacheable      = MPU_ACCESS_NOT_CACHEABLE;   
    ( l( C" ~" ~5 n0 a: l
39.     MPU_InitStruct.IsShareable      = MPU_ACCESS_NOT_SHAREABLE;
    1 ?( u# D& o! m) E& O* J
40.     MPU_InitStruct.Number           = MPU_REGION_NUMBER1;
    ' d8 e7 S$ y5 _, l
41.     MPU_InitStruct.TypeExtField     = MPU_TEX_LEVEL0;
    0 |6 N5 t, q! X3 t* M% d2 I- p
42.     MPU_InitStruct.SubRegionDisable = 0x00;
    
43.     MPU_InitStruct.DisableExec      = MPU_INSTRUCTION_ACCESS_ENABLE;
    
44. 
    % Q# F& m8 C8 J8 T+ \8 P
45.     HAL_MPU_ConfigRegion(&MPU_InitStruct);
    4 ?/ i# Q9 w2 _/ i! p4 a+ g
46. 
    
47.     /*使能 MPU */
    
48.     HAL_MPU_Enable(MPU_PRIVILEGED_DEFAULT);
      Y7 ^) _1 f, L( Q
49. }
    1 q# l$ d6 }/ t. U  A
50. 
    
51. /*
    
52. *********************************************************************************************************
      U) N; |5 @# G5 ?. i4 ^$ D+ m4 x2 G0 r3 Q
53. *    函 数 名: CPU_CACHE_Enable
    * M9 A" x2 x! b" B7 n
54. *    功能说明: 使能L1 Cache
    
55. *    形    参: 无
    
56. *    返 回 值: 无
    4 ~: D) H3 l# j9 M5 j
57. *********************************************************************************************************
    
58. */
    
59. static void CPU_CACHE_Enable(void)
    0 O9 u* M+ E5 _7 L' N5 V& o
60. {
    
61.     /* 使能 I-Cache */
    6 ]! s6 G! C' \/ w: Y2 G0 r8 q
62.     SCB_EnableICache();
    
63. 
    1 ]9 k8 e4 i9 i
64.     /* 使能 D-Cache */
    
65.     SCB_EnableDCache();
    & e2 K! L. c7 x5 p/ C% Z+ }
66. }

复制代码

3 A7 y; E- H0 @

8 _) n" C7 k* |) P0 \  每10ms调用一次蜂鸣器处理：
" I$ {' E' M' Z% w
4 L8 _% K! M2 O7 t  `蜂鸣器处理是在滴答定时器中断里面实现，每10ms执行一次检测。
2 b* d' E4 g& c9 M0 P; V
! x# e8 `& `8 R4 W" K7 m% @

1. /*
   ; |) F- ^# i+ C0 D* L. ^# l: w. p6 y
2. *********************************************************************************************************
   1 r4 n; X; s+ J
3. *    函 数 名: bsp_RunPer10ms
   , g9 w& z; w1 |) O, S0 i, f1 q
4. *    功能说明: 该函数每隔10ms被Systick中断调用1次。详见 bsp_timer.c的定时中断服务程序。一些处理时间要求
   
5. *              不严格的任务可以放在此函数。比如：按键扫描、蜂鸣器鸣叫控制等。
     q% z* g+ }/ T4 Y' t/ K
6. *    形    参: 无
   * v5 F8 h: H, Y7 k1 _
7. *    返 回 值: 无
   5 P4 s* Q/ v# ?9 l* d
8. *********************************************************************************************************
   ' G8 A! _! C) `4 J1 O- \9 ?, v
9. */
   8 e; I: [  J- ?* ]; d. @/ w! ?
10. void bsp_RunPer10ms(void)
    , b1 i8 e* k; }: e3 G% a; Y+ j
11. {
    / {1 D" j7 h- N
12.     bsp_KeyScan10ms();
    9 l) Y/ A6 g9 k- B4 C* H5 K; L( f
13. }
    2 }1 h4 }- e2 K" r5 ^& O1 w* {& v8 p

复制代码

( P3 D& A: ~5 O+ O4 h% l. |6 P3 h  主功能：

9 U7 j% T3 g( O, l. M7 b! g主程序实现如下操作：
6 Q5 r4 I3 L& L: H5 S4 a
启动一个自动重装软件定时器，每100ms翻转一次LED2。
- m; b; O% n! m6 T2 ` K1键按下，将8bit，16bit和32bit数据写入到内部Flash。
K2键按下，将结构体数据写入到内部Flash。
7 u+ o- u8 Z4 r9 e0 x8 i

1. /*
   
2. *********************************************************************************************************
   
3. *    函 数 名: main
   
4. *    功能说明: c程序入口
   * i) n" K5 a7 N9 Y, ]
5. *    形    参: 无
   
6. *    返 回 值: 错误代码(无需处理)
   7 z9 [) j3 Z$ o( T
7. *********************************************************************************************************
   
8. */
   ' t% ~$ M6 |4 }4 e
9. int main(void)
   # f8 R- \7 C2 C: Z+ E( P3 s) k
10. {
    
11.     uint8_t ucKeyCode;    /* 按键代码 */
    ! ^* _1 h, d( z3 r6 p: E* o
12.     uint8_t  ucTest, *ptr8;
    # w, G9 J, x% Q) M3 z
13.     uint16_t uiTest, *ptr16;
    6 ~. G- Z( A: v) F) y
14.     uint32_t ulTest, *ptr32;
    
15.     PARAM_T tPara, *paraptr;
    7 }, Y9 v- h3 ~! e$ w4 G
16. 
    4 g* C9 O" E% q
17. 
    9 R9 M7 |$ ?) @, W. A5 c: ?
18.     /* 初始化数据 */
    3 l) s* P; G/ e/ i3 D
19.     tPara.Baud485 = 0x5555AAAA;
    
20.     tPara.ParamVer = 0x99;
    : z$ x& ~" C, \9 E2 _" |4 p. E
21.     tPara.ucBackLight = 0x7788;
    
22.     tPara.ucRadioMode = 99.99f;
    2 D/ L: Q2 }) X- h0 E  y* h% h
23. 
    ) f. R& {& |7 O5 Z* Z* _
24. 
    
25.     bsp_Init();        /* 硬件初始化 */
    - c0 Q! ~( U; C/ ]
26.     PrintfLogo();    /* 打印例程名称和版本等信息 */
    8 G" p& A1 Q) \  Z) e( n
27.     PrintfHelp();    /* 打印操作提示 */
    . A' n8 [) ~; k) H
28. 
    $ W& ]3 S. T6 ^9 a$ E
29.     bsp_StartAutoTimer(0, 100);    /* 启动1个100ms的自动重装的定时器 */
    
30.     while (1)
    : s5 _5 R+ C5 }2 o: @) O/ I$ w+ m
31.     {
    ' G- _! s1 J/ V" h, d
32.         bsp_Idle();        /* 这个函数在bsp.c文件。用户可以修改这个函数实现CPU休眠和喂狗 */
    9 B4 I9 t: J5 R, s) i
33. 
    
34.         /* 判断定时器超时时间 */
    " _* I/ X2 @2 b" ~- m
35.         if (bsp_CheckTimer(0))   
    & N  j( ?- j/ X% i" n: S, m* K9 F
36.         {
    
37.             /* 每隔100ms 进来一次 */  
    
38.             bsp_LedToggle(2);
    
39.         }
    / x) y* ^+ E, m
40. 
    
41.         /* 按键滤波和检测由后台systick中断服务程序实现，我们只需要调用bsp_GetKey读取键值即可。 */
    
42.         ucKeyCode = bsp_GetKey();    /* 读取键值, 无键按下时返回 KEY_NONE = 0 */
    
43.         if (ucKeyCode != KEY_NONE)
    
44.         {
    
45.             switch (ucKeyCode)
    
46.             {
    
47.                 case KEY_DOWN_K1:            /* K1键按下，将8bit，16bit和32bit数据写入到内部Flash */
    . k& d1 `; t8 D4 ^" O4 c3 g% ]
48. 
    5 I' q9 b6 Z9 w' |6 |) r, W% z
49.                 /*
    
50.                  1、对于同一个地址空间，仅支持一次编程(不推荐二次编程，即使是将相应bit由数值1编程0)。
    # F, e5 }- W8 E! E! v" ]
51.                  2、只能对已经擦除的空间做编程，擦除1个扇区是128KB。
    & L% \1 p7 E6 ]2 I
52.                  3、H7的Flash编程时，务必保证要编程的地址是32字节对齐的，即此地址对32求余为0。并且编
    . q0 [8 j0 s2 w0 y- d2 H
53. 程的数据必须32字节整数倍。函数bsp_WriteCpuFlash对字节数不够32字节整数倍的情况自动补
    3 P- j9 l) J( C8 Y
54. 0。
    
55.                 */
      S' Y- g( e8 |* c8 S
56.                      /* 擦除扇区 */
    / F7 p9 f$ K7 @5 d& Z' v
57.                     bsp_EraseCpuFlash((uint32_t)para_flash_area);
    
58. 
    
59.                     ucTest = 0xAA;
    
60.                     uiTest = 0x55AA;
    
61.                     ulTest = 0x11223344;
    
62. 
    
63.                     /* 扇区写入数据 */
    & w  `: G: p$ p6 ?1 U
64.                     bsp_WriteCpuFlash((uint32_t)para_flash_area + 32*0,  (uint8_t *)&ucTest,
    
65. sizeof(ucTest));
    / @7 U9 g4 w; ~# D! ^, a, i1 }( A7 I* H( N
66.                     bsp_WriteCpuFlash((uint32_t)para_flash_area + 32*1,  (uint8_t *)&uiTest,
    
67. sizeof(uiTest));
    ! u4 F  d2 r$ a; v7 F( x
68.                     bsp_WriteCpuFlash((uint32_t)para_flash_area + 32*2,  (uint8_t *)&ulTest,
    " W) M) i. B$ E4 ^6 q; p
69. sizeof(ulTest));               
    
70. 
    
71.                     /* 读出数据并打印 */
    
72.                     ptr8  = (uint8_t  *)(para_flash_area + 32*0);
    , b' r8 @; j/ Z2 j3 h) e, F2 i
73.                     ptr16 = (uint16_t *)(para_flash_area + 32*1);
    ' o( s9 [% u& ^+ Y0 S2 H: X" M0 y% a
74.                     ptr32 = (uint32_t *)(para_flash_area + 32*2);
    
75. 
    
76.                     printf("写入数据：ucTest = %x, uiTest = %x, ulTest = %x\r\n", ucTest, uiTest, ulTest);
    # v! B3 M3 k: t0 A) s9 Y+ s
77.                     printf("读取数据：ptr8 = %x, ptr16 = %x, ptr32 = %x\r\n", *ptr8, *ptr16, *ptr32);
    5 P' n3 E* I% `& V
78. 
    3 {, W8 W% M2 m. C6 |
79.                     break;
    
80. 
    9 y$ o6 _: \" Z8 Q3 a* B4 |
81.                 case KEY_DOWN_K2:            /* K2键按下， 将结构体数据写入到内部Flash */
    
82.                     /* 擦除扇区 */
    5 j5 _8 H$ t2 @) D# h' j+ I
83.                     bsp_EraseCpuFlash((uint32_t)para_flash_area);
    
84. 
    
85.                     /* 扇区写入数据 */
    
86.                     bsp_WriteCpuFlash((uint32_t)para_flash_area,  (uint8_t *)&tPara, sizeof(tPara));            
    
87. 
    : N, G/ k$ s2 {1 w3 h/ Q
88.                     /* 读出数据并打印 */
    
89.                     paraptr  = (PARAM_T  *)((uint32_t)para_flash_area);
    " I* P- G. B$ e7 I, A! w1 l& Q1 w
90. 
    
91. 
    * N+ @# B5 f" E9 A
92.                     printf("写入数据：Baud485=%x, ParamVer=%x, ucBackLight=%x, ucRadioMode=%f\r\n",
    ) x: B# q1 z$ C; o# K& E5 e
93.                                                                        tPara.Baud485,
    1 y" Q) f2 B0 W! l* Z7 D- J
94.                                                                         tPara.ParamVer,
    
95.                                                                         tPara.ucBackLight,
    % R/ ~  _( D/ n# I* q. J
96.                                                                    paraptr->ucRadioMode);
      B+ F, m8 i' Q+ N1 Z( P! F: j
97. 
    
98.                     printf("读取数据：Baud485=%x, ParamVer=%x, ucBackLight=%x, ucRadioMode=%f\r\n",
    
99.                                                                         paraptr->Baud485,
    , i. Q# k9 y( b! f* M
100.                                                                             paraptr->ParamVer,
     
101.                                                                            paraptr->ucBackLight,
     
102.                                                                           paraptr->ucRadioMode);
     / K1 w; `+ L5 I& s
103.                     break;               
     
104.                 default:
     
105.                     /* 其它的键值不处理 */
     
106.                     break;
     ; P, }3 M% ~, v: m; k
107.             }
     
108.         }
     
109.     }
     
110. }

复制代码

. b2 d  j9 j9 h. g- j/ H9 x1 A
71.8 总结
本章节就为大家讲解这么多， 实际应用中的注意事项比较多，应用到项目之前务必实际测试熟悉下。
, o' |7 y6 u( k' a+ r# s( c