测试环境：
STM32F103RB
- w8 y3 `) i1 I- X" |20KBytes RAM
4 j( l' I6 Z6 ]9 E6 H9 @8 Y8 s128KBytes FLASH
注：本章节代码只适合STM32F1系列！
% I; V" x4 N( [, H
6 w6 G- [2 z3 S
. O6 i' G  n) |
头文件

1 d$ V9 w5 X# A5 \, ?

1. /**
   
2. * @brief Create by AnKun on 2019/10/10
   + I3 }7 i2 _; B% m1 d* n
3. */
   
4. 
   6 L( K( {/ N( K3 @. o
5. #ifndef __FLASH_H
   - V3 g) R7 o" D4 t) f# o
6. #define __FLASH_H
   1 \# n2 y3 c# J7 ~( t
7. 
   
8. #include "main.h"
   
9. 
   
10. 移植修改区 ///
    
11. 
    * f7 o( y# n) n1 {0 K8 e# y+ k+ T
12. /* FLASH大小：128K */
    : _$ Z1 r) h1 x+ d
13. #define STM32FLASH_SIZE  0x00020000UL
    
14. 
    ) ^6 d" {& F- Y
15. /* FLASH起始地址 */
    
16. #define STM32FLASH_BASE  FLASH_BASE
    
17. 
    
18. /* FLASH结束地址 */
    
19. #define STM32FLASH_END   (STM32FLASH_BASE | STM32FLASH_SIZE)
    ; N, x* W  m! N, P6 w5 Z! z7 {! s/ M; Z
20. 
    
21. /* FLASH页大小：1K */
    & x7 }  s) x1 V( @4 V% f6 ~: F( e
22. #define STM32FLASH_PAGE_SIZE FLASH_PAGE_SIZE
    
23. 
    ) c" y1 Z/ F! _  I0 W
24. /* FLASH总页数 */
      I& W* S1 X! n7 y, P2 d/ Q
25. #define STM32FLASH_PAGE_NUM  (STM32FLASH_SIZE / STM32FLASH_PAGE_SIZE)
    ( C3 G/ ~) U& Z! M
26. 
    " k# x$ v4 B4 ]  z8 x% r' j% A
27. /// 导出函数声明
    9 Y' E* K+ p) i/ a, t8 t
28. void FLASH_Init(void);
    , O8 q! p+ Y# b* P+ q6 A+ s
29. uint32_t FLASH_Read(uint32_t Address, void *Buffer, uint32_t Size);
    
30. uint32_t FLASH_Write(uint32_t Address, const uint16_t *Buffer, uint32_t NumToWrite);
    6 U& t3 B% z4 H' g3 \
31. int FLASH_ErasePage(uint32_t PageAddress, uint32_t NbPages);
    9 b6 I; H. ^" ^0 i5 U# ?8 A
32. uint32_t FLASH_WriteNotCheck(uint32_t Address, const uint16_t *Buffer, uint32_t NumToWrite);
    * R' T! C' l0 x  J0 Z# F
33. 
    
34. #endif // !__FLASH_H
    & J% C& T) b" X0 q$ q* @) [
35. 
    $ ]+ B3 Q- J; w& Y. ?
36. end of file
    

复制代码

) M7 U4 Q1 o/ Q* _0 n# n源文件

8 I- W0 @) p0 ]/ M6 I

1. /**
   
2. * @file  flash.c
   4 X" l; |" x0 _3 n
3. *
   
4. * @brief Create by AnKun on 2019/10/10
   
5. *
   
6. */
   
7. 
   
8. #include "flash.h"
   
9. #include <string.h>
   
10. 
    
11. static uint16_t FlashBuffer[STM32FLASH_PAGE_SIZE >> 1];
    2 R6 F$ B8 d0 R) _  t8 W) s
12. 
    
13. /// 初始化FLASH
    
14. void FLASH_Init(void)
    0 H5 j( N( O; S9 S+ t% G" z! A; m
15. {
    
16.     HAL_FLASH_Unlock();
    % M0 _! [/ S1 u/ p3 v
17.     __HAL_FLASH_CLEAR_FLAG(FLASH_FLAG_EOP | FLASH_FLAG_PGERR | FLASH_FLAG_WRPERR);
    4 M# p0 [5 u; J& ^" b% w1 K7 G8 r
18.     HAL_FLASH_Lock();
    + G& R6 g2 y( r0 W2 s  s
19. }
    9 h4 `8 n4 w7 ^2 o' Q
20. 
    
21. /**
    
22. * 读FLASH
    
23. * @param  Address 地址
    
24. * @param  Buffer  存放读取的数据
    
25. * @param  Size    要读取的数据大小，单位字节
    6 o9 V, |' K. p6 w, J
26. * @return         读出成功的字节数
    
27. */
    / c2 n% Q' k1 S# x$ k4 N: g; w7 t
28. uint32_t FLASH_Read(uint32_t Address, void *Buffer, uint32_t Size)
    / @$ f5 d' a0 E7 W) G1 B, `
29. {
    
30.     uint32_t nread = Size;
    
31.     uint8_t* d = (uint8_t *)Buffer;
    7 k1 e3 n: R' k, Q1 X7 R& o
32.     const uint8_t* s = (const uint8_t *)Address;
    * `% ~# Q4 Q# M! L$ O5 P) w1 `
33. 
    ! v$ [7 X2 O* `$ _1 f
34.     if (!Buffer || Address < STM32FLASH_BASE || Address >= STM32FLASH_END)
    
35.         return 0;
    
36. 
    ! u6 s! B' @/ F0 U, B$ o
37.     while (nread >= sizeof(uint32_t) && (((uint32_t)s) <= (STM32FLASH_END - 4)))
    
38.     {
    ! {# p4 w; p" g- ]' l9 `) t
39.         *(uint32_t *)d = *(uint32_t *)s;
    
40.         d += sizeof(uint32_t);
    
41.         s += sizeof(uint32_t);
    7 u) P5 S/ n$ `+ K4 d8 ~  y: e
42.         nread -= sizeof(uint32_t);
    - f3 d! I2 x5 n( t- l( m
43.     }
    
44. 
    1 S2 j% I/ C+ l3 S
45.     while (nread && (((uint32_t)s) < STM32FLASH_END))
    0 O1 ?( q" l- |/ _# r( Q4 E
46.     {
    1 \+ y; R; f$ B# _0 `% i$ M
47.         *d++ = *s++;
    
48.         nread--;
    - Y! ?$ p+ s! P, E7 Z( h/ k) y' x$ [$ F
49.     }
    
50. 
    
51.     return Size - nread;
    2 j' P4 o% r  T$ R4 V" i
52. }
    3 a3 B( j, a7 o. U* M
53. 
    
54. /**
    & F' }: P9 z, Y
55. * 写FLASH
    
56. * @param  Address    写入起始地址，！！！要求2字节对齐！！！
    
57. * @param  Buffer     待写入的数据，！！！要求2字节对齐！！！
    0 o0 J3 l. f! G" w* I
58. * @param  NumToWrite 要写入的数据量，单位：半字，！！！要求2字节对齐！！！
    * L! x# {9 s% n, ^! s/ m
59. * @return            实际写入的数据量，单位：字节
      i  s0 z  ]' q6 K7 |1 b
60. */
    ' F0 a/ q: V5 ~& d7 f  A
61. uint32_t FLASH_Write(uint32_t Address, const uint16_t *Buffer, uint32_t NumToWrite)
    
62. {
    / @3 K/ a+ ?. n6 S0 }5 I
63.     uint32_t i = 0;
    
64.     uint32_t pagepos = 0;         // 页位置
    4 }/ r. i/ e, m4 M1 s
65.     uint32_t pageoff = 0;         // 页内偏移地址
    ) K- P) |1 U6 j0 L
66.     uint32_t pagefre = 0;         // 页内空余空间
    9 ~$ v1 E, O% X: L
67.     uint32_t offset = 0;          // Address在FLASH中的偏移
    
68.     uint32_t nwrite = NumToWrite; // 记录剩余要写入的数据量
    * \' c' r* F& ]5 @( P2 l
69.     const uint16_t *pBuffer = (const uint16_t *)Buffer;
    
70. 
    
71.     /* 非法地址 */
    
72.     if (Address < STM32FLASH_BASE || Address > (STM32FLASH_END - 2) || NumToWrite == 0 || pBuffer == NULL)
    " N+ I1 U0 m% p' x9 b$ v( I6 j
73.         return 0;
    
74. 
    
75.     /* 解锁FLASH */
    , L& u( N* a% G- ~
76.     HAL_FLASH_Unlock();
    . m; m9 w4 \$ t4 P2 W
77. 
    . d6 I' ^( d" ?
78.     /* 计算偏移地址 */
    
79.     offset = Address - STM32FLASH_BASE;
    8 m, W1 A1 B; N/ n: O  X
80. 
      J  {' w8 Z3 j/ {: R$ {) |' |  U
81.     /* 计算当前页位置 */
    
82.     pagepos = offset / STM32FLASH_PAGE_SIZE;
    
83. 
    
84.     /* 计算要写数据的起始地址在当前页内的偏移地址 */
    # b) m! Q; Z* f2 B* q' M
85.     pageoff = ((offset % STM32FLASH_PAGE_SIZE) >> 1);
    
86. 
    
87.     /* 计算当前页内空余空间 */
    
88.     pagefre = ((STM32FLASH_PAGE_SIZE >> 1) - pageoff);
    
89. 
    1 T# F$ n  F! G1 L& N
90.     /* 要写入的数据量低于当前页空余量 */
    
91.     if (nwrite <= pagefre)
    : A) P8 l9 l6 N
92.         pagefre = nwrite;
    
93. 
    
94.     while (nwrite != 0)
    
95.     {
    
96.         /* 检查是否超页 */
    # c# U+ T" ~- H: x
97.         if (pagepos >= STM32FLASH_PAGE_NUM)
    ( n, y( P9 A4 g- X! {; V) ]
98.             break;
    - P  W5 ?$ |7 U9 P' b& o# _- [
99. 
    
100.         /* 读取一页 */
     
101.         FLASH_Read(STM32FLASH_BASE + pagepos * STM32FLASH_PAGE_SIZE, FlashBuffer, STM32FLASH_PAGE_SIZE);
     
102. 
     " n" \7 i/ _3 A+ ^
103.         /* 检查是否需要擦除 */
     8 W$ ^9 Z1 F, }! g: F* O) r
104.         for (i = 0; i < pagefre; i++)
     - C4 {& c3 f* w8 {* ?  p: \) f
105.         {
     $ _2 p/ h9 B& C
106.             if (*(FlashBuffer + pageoff + i) != 0xFFFF) /* FLASH擦出后默认内容全为0xFF */
     % n6 f. H$ Y* R. k
107.                 break;
     9 ]' x+ m4 A7 d. |
108.         }
     
109. 
     
110.         if (i < pagefre)
     : H: T1 ~  U1 q( |
111.         {
     
112.             uint32_t count = 0;
       N9 n: j8 _) T0 k* T% K: [& y8 d
113.             uint32_t index = 0;
     
114.             uint32_t PageError = 0;
     ; l1 b/ A* D8 w6 Z
115.             FLASH_EraseInitTypeDef pEraseInit;
     
116. 
     
117.             /* 擦除一页 */
     * P  M6 R; U& ?4 t# z
118.             pEraseInit.TypeErase = FLASH_TYPEERASE_PAGES;
     
119.             pEraseInit.PageAddress = STM32FLASH_BASE + pagepos * STM32FLASH_PAGE_SIZE;
     + Q5 `) m; y/ {
120.             pEraseInit.Banks = FLASH_BANK_1;
     
121.             pEraseInit.NbPages = 1;
     - m) A0 {' g. {1 W# _! k' \7 L
122.             if (HAL_FLASHEx_Erase(&pEraseInit, &PageError) != HAL_OK)
     5 w8 n  o, E7 n2 Z1 I. i
123.                 break;
     
124. 
     
125.             /* 复制到缓存 */
     ; ^9 e; y7 Q) [# C
126.             for (index = 0; index < pagefre; index++)
     
127.             {
     
128.                 *(FlashBuffer + pageoff + index) = *(pBuffer + index);
     
129.             }
     * s+ P6 l, }/ z$ w7 q; p; F9 c
130. 
     
131.             /* 写回FLASH */
     7 ?; H: v: u2 _2 ^6 Q/ K' R+ F4 {) X
132.             count = FLASH_WriteNotCheck(STM32FLASH_BASE + pagepos * STM32FLASH_PAGE_SIZE, FlashBuffer, STM32FLASH_PAGE_SIZE >> 1);
     7 ^/ T. u/ M* ^  m2 L1 e
133.             if (count != (STM32FLASH_PAGE_SIZE >> 1))
     . ~! q& E! C' [
134.             {
     
135.                 nwrite -= count;
     
136.                 break;
     
137.             }
     
138.         }
     8 Y, q. s- u) f9 `' r& h7 x' K
139.         else
     ( N# p1 |6 |0 }3 H; e- l; E! [- j% f
140.         {
     
141.             /* 无需擦除，直接写 */
     
142.             uint32_t count = FLASH_WriteNotCheck(Address, pBuffer, pagefre);
     
143.             if (count != pagefre)
     
144.             {
       V2 H/ U7 `0 B) g4 Z! O: q
145.                 nwrite -= count;
     
146.                 break;
     
147.             }
     
148.         }
     
149. 
     
150.         pBuffer += pagefre;         /* 读取地址递增         */
     & A( d% o/ s- \  H
151.         Address += (pagefre << 1);  /* 写入地址递增         */
     : f% J! h+ ^9 d+ @4 F. ~+ F* ^
152.         nwrite -= pagefre;          /* 更新剩余未写入数据量 */
     , q, U* P( ?* d- o; L, a# E
153. 
     
154.         pagepos++;     /* 下一页           */
     
155.         pageoff = 0;   /* 页内偏移地址置零  */
     : Z+ [8 ~" q, ]
156. 
     & |( O+ ?. V9 O% }' r/ Q& ?0 ?
157.         /* 根据剩余量计算下次写入数据量 */
     5 M, S. g* l. m7 v
158.         pagefre = nwrite >= (STM32FLASH_PAGE_SIZE >> 1) ? (STM32FLASH_PAGE_SIZE >> 1) : nwrite;
     
159.     }
     - s, ?7 ^/ p' X
160. 
     # j- _* k( u* E" @6 T' u6 r) c
161.     /* 加锁FLASH */
     
162.     HAL_FLASH_Lock();
     
163. 
     % ^) M0 v5 _- o
164.     return ((NumToWrite - nwrite) << 1);
     $ z' h& K' T/ _$ O4 u* e+ _
165. }
     
166. 
     ) R: |6 A9 Y8 R- L
167. uint32_t FLASH_WriteNotCheck(uint32_t Address, const uint16_t *Buffer, uint32_t NumToWrite)
     & l  `! `6 }& p
168. {
     
169.     uint32_t nwrite = NumToWrite;
     
170.     uint32_t addrmax = STM32FLASH_END - 2;
     
171. 
     
172.     while (nwrite)
     + G4 {& |( D' V: J: T! {. |! f
173.     {
     ! i' S) `% ?+ s6 ]5 E' `: N
174.         if (Address > addrmax)
     . H- N3 n* D; i- k1 H
175.             break;
     $ ?% o" v% y6 D$ V; H5 Y* R/ M0 v. M
176. 
     2 D! H7 F2 C: J. _
177.         HAL_FLASH_Program(FLASH_TYPEPROGRAM_HALFWORD, Address, *Buffer);
     + X4 Y: v: L7 C% ]# I1 U8 a1 Q
178.         if ((*(__IO uint16_t*) Address) != *Buffer)
     
179.             break;
     4 X$ B5 |* B. k( F% Q& n
180. 
     
181.         nwrite--;
     ; i0 N* U  L8 V& P
182.         Buffer++;
     
183.         Address += 2;
     
184.     }
     
185.     return (NumToWrite - nwrite);
     
186. }
     
187. 
     
188. int FLASH_ErasePage(uint32_t PageAddress, uint32_t NbPages)
     
189. {
     
190.         uint32_t PageError = 0;
     
191.         FLASH_EraseInitTypeDef pEraseInit;
     5 @- L  y+ I  k: B5 W4 Z& q; K- t
192.         pEraseInit.TypeErase = FLASH_TYPEERASE_PAGES;
     
193.         pEraseInit.PageAddress = PageAddress;
     8 [& _) d9 Z5 s. t1 U0 M7 r& a
194.         pEraseInit.Banks = FLASH_BANK_1;
     - @! c8 T# b* N$ x0 T
195.         pEraseInit.NbPages = 1;
     ( C9 h( T* E5 H9 |& y
196.         if(HAL_FLASHEx_Erase(&pEraseInit, &PageError) != HAL_OK)
     
197.         {
     
198.                 return -1;
     
199.         }
     
200.         return 0;
     5 l, R+ x1 O9 c2 d+ D
201. }
     : x; c' @2 F+ y) e$ u7 I" D! L
202. 
     # U: E. j! a+ h
203. end of file

复制代码

/ L& S3 e' v2 c+ V6 `: k