测试环境：
STM32F103RB
- q7 N' _" |, M* R; \" b; _: c* _20KBytes RAM
6 b, L. i6 |0 e9 N" p. V1 `128KBytes FLASH
# z" j& Z, t; C0 x. [注：本章节代码只适合STM32F1系列！
# t1 ^$ s3 h& ~0 m, r5 f( ?
9 I4 U: R* p) C& s2 j
! K- R; L, K1 e
0 K  I& K- G  G0 S  |头文件
! r6 v% I8 k4 q* J- Z, z' K5 E
% ~4 q# u. M7 ^( z

1. /**
   ! L8 k. P6 \$ S+ p4 L; Y5 [. c- K" o
2. * @brief Create by AnKun on 2019/10/10
   : ]& b" w* W7 y, K3 B
3. */
   " ?1 o2 k  |( O9 L3 D
4. 
   # v' k7 p* P( z3 b4 j% N* Y# U) y9 g
5. #ifndef __FLASH_H
   
6. #define __FLASH_H
   
7. 
   / H1 J. J4 R* \/ _  M! S) W
8. #include "main.h"
   " X! g, Z: Z( _% k& r
9. 
   6 j. P/ B2 l7 M; V6 Z
10. 移植修改区 ///
    : ]% [' ^0 b' E) N9 _( q0 `
11. 
    
12. /* FLASH大小：128K */
    
13. #define STM32FLASH_SIZE  0x00020000UL
    ! z: i& l' Y* s6 j+ l& _; s( l. O: q
14. 
    
15. /* FLASH起始地址 */
    
16. #define STM32FLASH_BASE  FLASH_BASE
    8 S. l$ j+ G6 G$ u0 N$ v* v3 b
17. 
    , |' Z6 L, q9 v. ?$ A
18. /* FLASH结束地址 */
    7 c9 b! t/ l, b- }9 H
19. #define STM32FLASH_END   (STM32FLASH_BASE | STM32FLASH_SIZE)
    # [- E9 V: ]5 O. p6 c$ X
20. 
    
21. /* FLASH页大小：1K */
    * o( f8 U$ D0 ?! y& S" w+ L5 L
22. #define STM32FLASH_PAGE_SIZE FLASH_PAGE_SIZE
    
23. 
    
24. /* FLASH总页数 */
    , ]9 s% @; R7 a. G! e( G  }* B$ U
25. #define STM32FLASH_PAGE_NUM  (STM32FLASH_SIZE / STM32FLASH_PAGE_SIZE)
    
26. 
    % k9 \( C- P, ?& I& x
27. /// 导出函数声明
    ! ]! D( A; s' x) o5 y
28. void FLASH_Init(void);
    
29. uint32_t FLASH_Read(uint32_t Address, void *Buffer, uint32_t Size);
    9 v, v' f0 z' M3 Y( s! f& z  S1 u
30. uint32_t FLASH_Write(uint32_t Address, const uint16_t *Buffer, uint32_t NumToWrite);
    3 H" `1 ?; s; H; ^- R5 j, u* A
31. int FLASH_ErasePage(uint32_t PageAddress, uint32_t NbPages);
    
32. uint32_t FLASH_WriteNotCheck(uint32_t Address, const uint16_t *Buffer, uint32_t NumToWrite);
    9 g8 s8 M  v% A3 n: K
33. 
    3 r( i# a( B) q9 k
34. #endif // !__FLASH_H
    7 r% P' m' [5 D; ?
35. 
    : N2 A- o1 O+ a& ~8 }
36. end of file
    4 `  I2 I( d0 U2 ^% t. B" v

复制代码

. y* R2 w* t; `/ v源文件
2 m$ _' ]2 h2 V1 B
+ A3 g- p, _# C1 {5 {8 t0 u% U

1. /**
   * Q$ f8 F# E/ ]4 ~
2. * @file  flash.c
   # D  C& a8 f( V- k
3. *
   
4. * @brief Create by AnKun on 2019/10/10
   , k6 G$ o3 @* g3 b/ w9 Z* ]! _+ e
5. *
   " P' ?: f$ e/ |; R7 B
6. */
   . ?4 ]* E) B: u3 }- {
7. 
   ( c& x2 Q) M& W0 w; m! ?. F5 P
8. #include "flash.h"
   
9. #include <string.h>
   3 E1 q5 A6 B1 u5 P9 h$ s1 s: w
10. 
    
11. static uint16_t FlashBuffer[STM32FLASH_PAGE_SIZE >> 1];
    - R1 C" ~  f" Y" V4 X. ?+ q
12. 
    - k: }5 B$ m# c
13. /// 初始化FLASH
    ) \; g8 Z8 y% f0 L. p/ }8 X
14. void FLASH_Init(void)
    
15. {
    
16.     HAL_FLASH_Unlock();
    
17.     __HAL_FLASH_CLEAR_FLAG(FLASH_FLAG_EOP | FLASH_FLAG_PGERR | FLASH_FLAG_WRPERR);
    
18.     HAL_FLASH_Lock();
    4 C' [, f% r/ |) M$ j# S5 c. `
19. }
    9 a. C5 E! `- X. R
20. 
    % K8 [. T* W' h  i! c$ U
21. /**
    5 i8 x; n; f( A0 I4 i3 j& M
22. * 读FLASH
    8 C0 g, P# t8 p. i* r9 ]1 ?4 e5 R7 m
23. * @param  Address 地址
    3 n* X/ R& _" S2 j. q; O: ]
24. * @param  Buffer  存放读取的数据
    ; _2 [6 h/ P& j& B1 H& ~: [0 Y
25. * @param  Size    要读取的数据大小，单位字节
    
26. * @return         读出成功的字节数
    
27. */
    
28. uint32_t FLASH_Read(uint32_t Address, void *Buffer, uint32_t Size)
    
29. {
    1 i  F  b2 r' N0 h
30.     uint32_t nread = Size;
    
31.     uint8_t* d = (uint8_t *)Buffer;
    
32.     const uint8_t* s = (const uint8_t *)Address;
    " S( t: v1 p; I0 |1 D9 j2 C0 Y
33. 
    
34.     if (!Buffer || Address < STM32FLASH_BASE || Address >= STM32FLASH_END)
    
35.         return 0;
    ! a, E7 W$ O8 L% i8 @$ f
36. 
    % T1 j1 A3 E$ }. f
37.     while (nread >= sizeof(uint32_t) && (((uint32_t)s) <= (STM32FLASH_END - 4)))
    4 H, ^5 x- a& w+ L: Z2 `) o2 q! i
38.     {
    
39.         *(uint32_t *)d = *(uint32_t *)s;
    4 z- z, q, d4 }  `' ~! O. N
40.         d += sizeof(uint32_t);
    6 A! E, @7 [4 d
41.         s += sizeof(uint32_t);
    
42.         nread -= sizeof(uint32_t);
    
43.     }
    
44. 
    
45.     while (nread && (((uint32_t)s) < STM32FLASH_END))
    + t9 O& E; X8 @- B* k( @% f/ u
46.     {
    
47.         *d++ = *s++;
    
48.         nread--;
    
49.     }
    
50. 
    & {7 N+ c4 ]0 C6 {
51.     return Size - nread;
    
52. }
    
53. 
    9 g2 ^$ [5 ]  {' I( F# Z$ L% z; f
54. /**
    
55. * 写FLASH
    " c" u" y* n0 A+ l
56. * @param  Address    写入起始地址，！！！要求2字节对齐！！！
    9 K) t. P) {& r* F: G- H
57. * @param  Buffer     待写入的数据，！！！要求2字节对齐！！！
    7 c/ x8 R; u4 U- u
58. * @param  NumToWrite 要写入的数据量，单位：半字，！！！要求2字节对齐！！！
    9 P" r3 }$ H8 v6 E
59. * @return            实际写入的数据量，单位：字节
    . R+ c  g2 W3 u; V
60. */
      o% [4 G7 q  Y4 A* X4 R& W" ~
61. uint32_t FLASH_Write(uint32_t Address, const uint16_t *Buffer, uint32_t NumToWrite)
    
62. {
    ( a# }2 W1 c/ }, j3 Y& }, V9 L
63.     uint32_t i = 0;
    2 o+ b" M. I$ k; V' T
64.     uint32_t pagepos = 0;         // 页位置
    
65.     uint32_t pageoff = 0;         // 页内偏移地址
    ' q+ q& k" R4 v, D3 c7 t8 m
66.     uint32_t pagefre = 0;         // 页内空余空间
    5 z  k  C( z  R; h/ A1 M
67.     uint32_t offset = 0;          // Address在FLASH中的偏移
    0 o+ o' O, _7 V
68.     uint32_t nwrite = NumToWrite; // 记录剩余要写入的数据量
    
69.     const uint16_t *pBuffer = (const uint16_t *)Buffer;
    
70. 
    8 n+ j% s" p. @+ @: }) H8 n  i/ ~
71.     /* 非法地址 */
    9 F9 H, `0 L7 n5 f: e- }" t
72.     if (Address < STM32FLASH_BASE || Address > (STM32FLASH_END - 2) || NumToWrite == 0 || pBuffer == NULL)
    7 h* Q) ?% I1 w$ V
73.         return 0;
    / ~2 u- o5 O- t( m( k& d: x
74. 
    
75.     /* 解锁FLASH */
    5 f3 y; Y% v2 X
76.     HAL_FLASH_Unlock();
    " m3 a# T' y) i$ c* R2 A
77. 
    # }. _" v+ K# w5 z- U) A
78.     /* 计算偏移地址 */
    0 |5 E3 H* |; u; Z& S
79.     offset = Address - STM32FLASH_BASE;
    7 v) J, q: \0 c: x/ @3 F1 e) e5 w4 X5 y
80. 
    / P( u0 M5 p4 u: m
81.     /* 计算当前页位置 */
    
82.     pagepos = offset / STM32FLASH_PAGE_SIZE;
    
83. 
    ; i: w4 {2 a+ a* Z3 Q4 l
84.     /* 计算要写数据的起始地址在当前页内的偏移地址 */
    
85.     pageoff = ((offset % STM32FLASH_PAGE_SIZE) >> 1);
    * _' j# E4 P5 r6 S! F. n% X) `7 a' m0 a
86. 
    
87.     /* 计算当前页内空余空间 */
    
88.     pagefre = ((STM32FLASH_PAGE_SIZE >> 1) - pageoff);
    8 E5 H$ N; t) O% R
89. 
    - ]% ]$ @$ S7 N$ h
90.     /* 要写入的数据量低于当前页空余量 */
    
91.     if (nwrite <= pagefre)
    
92.         pagefre = nwrite;
    
93. 
    2 e% V5 P+ F3 E( y9 U5 \. m: w
94.     while (nwrite != 0)
    
95.     {
    ! d' T8 I9 \3 ^; o1 Q4 t) x
96.         /* 检查是否超页 */
    ( ?8 P* j! [# x% B% l! o
97.         if (pagepos >= STM32FLASH_PAGE_NUM)
    
98.             break;
    * X5 f" E' ?+ a2 N
99. 
    
100.         /* 读取一页 */
     
101.         FLASH_Read(STM32FLASH_BASE + pagepos * STM32FLASH_PAGE_SIZE, FlashBuffer, STM32FLASH_PAGE_SIZE);
     
102. 
     ; X. p% d6 ^/ y* n, p+ c
103.         /* 检查是否需要擦除 */
     
104.         for (i = 0; i < pagefre; i++)
     : ?3 m  V. s% D
105.         {
     
106.             if (*(FlashBuffer + pageoff + i) != 0xFFFF) /* FLASH擦出后默认内容全为0xFF */
     
107.                 break;
     
108.         }
     0 ], r3 x- N8 ?3 w# g0 e9 ~: h2 [
109. 
     
110.         if (i < pagefre)
     
111.         {
     
112.             uint32_t count = 0;
     
113.             uint32_t index = 0;
     
114.             uint32_t PageError = 0;
     
115.             FLASH_EraseInitTypeDef pEraseInit;
     
116. 
     + ^$ w$ G, o+ F# c4 d% @1 s
117.             /* 擦除一页 */
       ^* t) U8 q" J3 x3 J$ s
118.             pEraseInit.TypeErase = FLASH_TYPEERASE_PAGES;
     # N) g. z# [* E
119.             pEraseInit.PageAddress = STM32FLASH_BASE + pagepos * STM32FLASH_PAGE_SIZE;
     , ]8 {- D, b, c' D5 z2 N$ l
120.             pEraseInit.Banks = FLASH_BANK_1;
     
121.             pEraseInit.NbPages = 1;
     
122.             if (HAL_FLASHEx_Erase(&pEraseInit, &PageError) != HAL_OK)
     
123.                 break;
     $ r1 n, |* q  R! y& u) H  D; H
124. 
     
125.             /* 复制到缓存 */
     
126.             for (index = 0; index < pagefre; index++)
     
127.             {
     ( C4 R. s* `$ i
128.                 *(FlashBuffer + pageoff + index) = *(pBuffer + index);
     . A. }. N& O$ t' Q$ D" s) B8 A3 c
129.             }
     + L* L) j6 H# F9 D, ?
130. 
     & T* V) Z1 ^* s5 w
131.             /* 写回FLASH */
     
132.             count = FLASH_WriteNotCheck(STM32FLASH_BASE + pagepos * STM32FLASH_PAGE_SIZE, FlashBuffer, STM32FLASH_PAGE_SIZE >> 1);
     * f8 P, x* @5 ^: M) q1 a0 H
133.             if (count != (STM32FLASH_PAGE_SIZE >> 1))
     
134.             {
     
135.                 nwrite -= count;
     / N8 H' q2 G. s# j7 N+ {$ c7 Y
136.                 break;
     
137.             }
     
138.         }
     
139.         else
     " n1 T/ _& R9 b
140.         {
     
141.             /* 无需擦除，直接写 */
     
142.             uint32_t count = FLASH_WriteNotCheck(Address, pBuffer, pagefre);
     
143.             if (count != pagefre)
     
144.             {
     
145.                 nwrite -= count;
     , H) S  T- Y5 E& T* Y  F
146.                 break;
     5 z) N# z7 T' f" L1 H
147.             }
     # _7 U( H# I' w" M/ x
148.         }
     1 |8 k" }/ `, U/ ^
149. 
     + s- P+ n1 s: E) d* O. i8 z9 R
150.         pBuffer += pagefre;         /* 读取地址递增         */
     ! c5 b0 [7 {& r) i5 G* o
151.         Address += (pagefre << 1);  /* 写入地址递增         */
     
152.         nwrite -= pagefre;          /* 更新剩余未写入数据量 */
     9 b0 `9 F/ Q5 D2 D3 Q6 \$ H
153. 
     
154.         pagepos++;     /* 下一页           */
     8 V' N3 S! ]% k1 n
155.         pageoff = 0;   /* 页内偏移地址置零  */
     7 m5 x& m$ y9 z$ E7 q+ c
156. 
     
157.         /* 根据剩余量计算下次写入数据量 */
     
158.         pagefre = nwrite >= (STM32FLASH_PAGE_SIZE >> 1) ? (STM32FLASH_PAGE_SIZE >> 1) : nwrite;
     : G" u$ v' U( Z7 L: E' p
159.     }
     , V) E3 a$ ~$ ?  R
160. 
       _& H& O5 p. h% Q, L0 ^# j
161.     /* 加锁FLASH */
     
162.     HAL_FLASH_Lock();
     
163. 
     3 n4 G1 d- B4 P7 O" M
164.     return ((NumToWrite - nwrite) << 1);
     2 V+ v3 @$ P, W: R- q9 \
165. }
     
166. 
     + R2 ~  ?7 g) N6 Q0 D, u. N1 k: ?
167. uint32_t FLASH_WriteNotCheck(uint32_t Address, const uint16_t *Buffer, uint32_t NumToWrite)
     9 _! k7 B; M, V, G
168. {
     
169.     uint32_t nwrite = NumToWrite;
     5 \8 x' y1 u4 P- n3 L2 e+ a
170.     uint32_t addrmax = STM32FLASH_END - 2;
     0 s. K3 D7 H, x/ y% q8 ^
171. 
     
172.     while (nwrite)
     & \% W" K" s/ [. O) I3 H7 X3 ^7 V
173.     {
     9 K2 H* E  {% E4 y# T3 Y
174.         if (Address > addrmax)
     
175.             break;
     . W( P  ~" s7 d. V
176. 
     
177.         HAL_FLASH_Program(FLASH_TYPEPROGRAM_HALFWORD, Address, *Buffer);
     & W1 G( m8 V: }$ H
178.         if ((*(__IO uint16_t*) Address) != *Buffer)
     
179.             break;
     
180. 
     ( w  e8 o6 @; B3 f
181.         nwrite--;
     " G9 c# U7 `' r# {/ w
182.         Buffer++;
     
183.         Address += 2;
     , l8 u! N: I9 ?, e! n9 r
184.     }
     ; ^, w. z' C' B( u4 L
185.     return (NumToWrite - nwrite);
     
186. }
     
187. 
     
188. int FLASH_ErasePage(uint32_t PageAddress, uint32_t NbPages)
     / P- Z  \7 m/ x5 A/ g( i' T
189. {
     
190.         uint32_t PageError = 0;
     ; ^+ y: a5 ]! r6 V$ o8 `
191.         FLASH_EraseInitTypeDef pEraseInit;
     
192.         pEraseInit.TypeErase = FLASH_TYPEERASE_PAGES;
     % @% i' [1 \: z
193.         pEraseInit.PageAddress = PageAddress;
     4 ~- T. A2 e! @
194.         pEraseInit.Banks = FLASH_BANK_1;
     7 X0 Q. T* ~9 T: ]/ q
195.         pEraseInit.NbPages = 1;
     $ G9 V7 K: E& P" B) y  T
196.         if(HAL_FLASHEx_Erase(&pEraseInit, &PageError) != HAL_OK)
     ' n& z* N" z' d# ?. B8 X' b
197.         {
     0 L9 q% N0 L4 S% J7 \: _3 g
198.                 return -1;
     5 O, _4 b6 {* Q+ d
199.         }
     2 N! z5 ^, q/ f0 f
200.         return 0;
     
201. }
     ! i2 p8 F- S. j3 D/ W
202. 
     ! V4 p' w9 P2 X' j) N
203. end of file

复制代码

+ l: O& m6 `7 B4 j) {; Q  |

( J; A6 \# H& A8 \* \
. @, m$ I6 J5 W2 P) g