一、芯片FLASH容量分类：

可以看到我们今天介绍的这款芯片的flash大小是64K的，网上也有人说它可以支持到128K，但是官方给出的解释是前64K是有保证的，后面的无法保证，所以想要使用的小伙伴需要慎重。
* a4 R& v5 Q, P+ X现在芯片的flash大小我们知道了，下面就可以看看这个flash是怎么划分的了，通过芯片数据手册，我们能看到今天说的STM32F103C8T6是属于中等容量的设备。

既然是中等容量的设备了，那我们就来看看flash划分吧，在STM32的闪存编程手册中有这样一段话：按照不同容量，
" d& i, v% a/ w3 `, x" F6 x存储器组织成：
3 {% S2 ~( J) m1 q' s32个1K字节/页(小容量)
' x  l; N& v, Q% l  T  O+ |4 T128个1K字节/页(中容量)
+ p, H7 k+ x2 }$ c. O  _- T256个2K字节/页(大容量)
: b  O7 t  f: A- E这段话怎么理解呢，就是告诉我们小容量的设备（内存是6K和32K）的设备是由1K字节每页组成的，
中容量的设备（内存是64K和128K）的设备是由1K字节每页组成的，
! |+ t: r3 e5 D9 o- \. n大容量的设备（内存是256K、384K和512K）的设备是由2K字节每页组成的，
举个例子吧：
2 F3 z! `. S# {: f* j; o, T6 b一个芯片的存储容量是64K，这64K是什么呢，就是64*1024个BYTE，一个BYTE是由8位0或1组成的，（比如0000 1111 这8个二进制数组成了一个字节，用十进制来说就是15）
小结一下：64K的flash可以存储64*1024个字节的数据。
咱们继续说，这64K的数据怎么划分，存储是按照页为单位进行存储的，一页1K的容量，也就说一页可以存储1024个字节
一共是多少页？
+ n, @) x9 m& U! ~答案是：64页，我们看一下官方是不是这么说的

在闪存编程手册里确实是这么说的，所以我们刚才说是64页是正确的

二、 读写步骤：
上面我们知道了芯片是怎么分类的，下面我们就重点来讲解一下芯片是怎么读写的。
" t! ?% s1 n7 t& e3 p/ j/ E, m内部flash我们参照HAL库或者标准库，直接调用ST公司给我们封装好的库进行编程就可以了，这里我用的是标准库，有兴趣的小伙伴可以去看看HAL库
是不是有小伙伴会疑问什么是标准库，什么是HAL库？
在这里给大家解释一下，这两个库都是ST公司，直接把寄存器封装成函数，供大家直接调用某一个函数，就可以完成各种寄存器的配置，不容大家直面芯片的寄存器，方便阅读和使用，因为每个函数的名称功能都是不一样的，在调用前可以参考函数的注释，在F0和F4的标准库里甚至有每个函数的用法，不知道为什么在F1的库里把使用步骤去掉了。
7 D& B! G( `% N0 i, X. r+ G. M咱们继续，读写的话库函数分为：

1. /*------------ Functions used for all STM32F10x devices -----*/
   
2. 
   
3. void FLASH_SetLatency(uint32_t FLASH_Latency);
   
4. 
   
5. void FLASH_HalfCycleAccessCmd(uint32_t FLASH_HalfCycleAccess);
   
6. 
   * G( i- l  B( O6 d3 t* M
7. void FLASH_PrefetchBufferCmd(uint32_t FLASH_PrefetchBuffer);
   
8. 
   1 q/ ]. _+ n6 ~3 S9 I$ F  M
9. void FLASH_Unlock(void);
   . x& O3 v5 K; z# o
10. 
    
11. void FLASH_Lock(void);
    4 x$ t) |) {. r- a6 N  v' U
12. 
    5 A) v( r2 e' d! {% y- c& U
13. FLASH_Status FLASH_ErasePage(uint32_t Page_Address);
    
14. 
    : k9 i5 y- F" N( z
15. FLASH_Status FLASH_EraseAllPages(void);
    
16. 
    5 v% Q8 v8 Y7 p0 e: r# |
17. FLASH_Status FLASH_EraseOptionBytes(void);
    
18. 
    
19. FLASH_Status FLASH_ProgramWord(uint32_t Address, uint32_t Data);
    # L1 O# w. x. \! A0 G2 M
20. 
    6 j; Q( {7 [7 C* U0 r; a
21. FLASH_Status FLASH_ProgramHalfWord(uint32_t Address, uint16_t Data);
    1 E% }7 Q% G/ c0 T* j. s0 D- k
22. 
    - C; F& }% P$ w7 k
23. FLASH_Status FLASH_ProgramOptionByteData(uint32_t Address, uint8_t Data);
    
24. 
    : a3 _  Q0 `- m+ ~# G; s% ^5 z
25. FLASH_Status FLASH_EnableWriteProtection(uint32_t FLASH_Pages);
    
26. 
    4 F( _9 [9 K0 X/ Y* S4 n9 |& `* G
27. FLASH_Status FLASH_ReadOutProtection(FunctionalState NewState);
    
28. 
    + X! x) [9 F7 r* l
29. FLASH_Status FLASH_UserOptionByteConfig(uint16_t OB_IWDG, uint16_t OB_STOP, uint16_t OB_STDBY);
    
30. 
    5 Q- f: |& h& v; w9 ]5 T9 M
31. uint32_t FLASH_GetUserOptionByte(void);
    
32. 
    
33. uint32_t FLASH_GetWriteProtectionOptionByte(void);
    
34. 
    & V4 I$ }9 ~3 v) n6 r6 @
35. FlagStatus FLASH_GetReadOutProtectionStatus(void);
    
36. 
    - T& }- n8 j7 l) o& ]4 I
37. FlagStatus FLASH_GetPrefetchBufferStatus(void);
    
38. 
    9 B0 g- r& q1 l$ e( w. E/ w0 h
39. void FLASH_ITConfig(uint32_t FLASH_IT, FunctionalState NewState);
    : z* v9 T! p' J( q7 r6 \3 v
40. 
    
41. FlagStatus FLASH_GetFlagStatus(uint32_t FLASH_FLAG);
    
42. 
    ; u+ w* b, @( {& A' x
43. void FLASH_ClearFlag(uint32_t FLASH_FLAG);
    1 ?0 ?! Y. V5 S; I% V! `
44. 
    
45. FLASH_Status FLASH_GetStatus(void);
    ' T/ B5 g0 J8 ^) f1 G0 N! q$ A
46. 
    
47. FLASH_Status FLASH_WaitForLastOperation(uint32_t Timeout);
    ( Y* @$ t( A7 p1 L
48. 
    9 ]; t4 E% w) T+ S
49. 
    
50. 
    
51. /*------------ New function used for all STM32F10x devices -----*/
    0 R4 Y/ g/ N, |/ J# x" U* m; q
52. 
    
53. void FLASH_UnlockBank1(void);
    ( |; s2 u! \3 I6 m
54. 
    
55. void FLASH_LockBank1(void);
    
56. 
    
57. FLASH_Status FLASH_EraseAllBank1Pages(void);
    & {8 J2 A: \! a$ R- p8 X
58. 
    5 Q7 J! h$ ]  B
59. FLASH_Status FLASH_GetBank1Status(void);
    
60. 
    4 W6 W' w2 ?+ s* `+ C3 K
61. FLASH_Status FLASH_WaitForLastBank1Operation(uint32_t Timeout);

复制代码

& ^. x9 T( n5 ^+ n+ W

在这里就不一个一个的详细说了，我们说一下常用的就行
0 C$ G2 V1 A# z3 s2 T! W  S# G1. 解锁

void FLASH_Unlock(void);

" ~4 l: ~, Z) n" n+ I2. 上锁

void FLASH_Lock(void);
7 [6 b# l3 \. o. M2 R

3. 页擦除

FLASH_Status FLASH_ErasePage(uint32_t Page_Address);4. 半字写入
FLASH_Status FLASH_ProgramHalfWord(uint32_t Address, uint16_t Data);上面这4个函数就是我们最常用的。下面说一下数据写入的步骤，第一步：解锁第二步：判断写入的数据是否被擦除过，也就是判断写入的地址内存放的是不是0xFFFF 这里要重点说一下，为什么要判断是不是0xFFFF而不是判断是不是0xFF呢？因为我们每次写入数据都要写入半字，也就是两个字节的数据才行，而且写入的地址只能是2的整数倍，不能是奇数。这里大家注意一下。第三步：写入数据 STM32F103C8T6只能按照半字的方式进行数据写入，写入前的数据必须是0XFFFF，因为FLASH数据写入，只能写0，不能写1，这也就是为什么我们要先确保写入前的数据是被擦除了的原因。第四步：上锁第五步：验证写入是否正确其实第五步可以省略。我们看看官方给的写入过
1 q6 G1 u. x2 g9 e

* C  [. D, B# W: k* o1 q好了，其实是一样的。
下面我就和大家来分享一下（百分之九十九参考的正点原子的例程）

1. //不检查的写入
   
2. 
   
3. //WriteAddr:起始地址
   
4. 
   
5. //pBuffer:数据指针
     U8 ]& s+ p) A" _& P5 X' W) l( l
6. 
   ( m2 q3 W1 a1 ]& x
7. //NumToWrite:半字(16位)数   
   , {1 e, [3 N/ c; C- d
8. 
   
9. void STMFLASH_Write_NoCheck(u32 WriteAddr,u16 *pBuffer,u16 NumToWrite)   
   
10. 
    7 T. X  v) ]+ h5 u+ s/ i
11. {                                          
    ! D) Q% J0 s/ U3 V% X
12. 
    
13.         u16 i;
    
14. 
    ; }6 f- \. w/ X% q& c1 _, T' u
15.         for(i=0;i<NumToWrite;i++)
    ) N' B/ H% y8 l
16. 
    
17.         {
    
18. 
    ' R5 }+ }# @5 v( F* L
19.                 FLASH_ProgramHalfWord(WriteAddr,pBuffer);
    
20. 
    / U3 ^- Q1 z& v: j, K, W
21.             WriteAddr+=2;//地址增加2.
    
22. 
    
23.         }  
    
24. 
    
25. }

复制代码

1. //从指定地址开始写入指定长度的数据
   3 j& G$ M( M" H" e5 q; P
2. 
   
3. //WriteAddr:起始地址(此地址必须为2的倍数!!)
     o* h% o7 H3 T' N0 ]
4. 
   
5. //pBuffer:数据指针
   ' j/ n& Q( I' P* N1 o5 f6 ?* T
6. 
   
7. //NumToWrite:半字(16位)数(就是要写入的16位数据的个数.)
   6 m$ y  b8 B1 G  f6 W
8. 
   
9. 
   ( ~" a# s, C5 C/ Q* S, I" G; F
10. 
    0 e; Z8 t2 q  \
11. u16 STMFLASH_BUF[STM_SECTOR_SIZE/2];//最多是2K字节
    
12. 
    
13. void STMFLASH_Write(u32 WriteAddr,u16 *pBuffer,u16 NumToWrite)        
    1 C% Y$ k7 l$ K' [
14. 
    3 \- M" ]2 t- Z, ^- z
15. {
    + B/ `$ ~/ a# S4 m
16. 
    
17.         u32 secpos;           //扇区地址
    
18. 
    
19.         u16 secoff;           //扇区内偏移地址(16位字计算)
    
20. 
    5 j& j; _2 r* p; k: M6 r: s* ]) c% f
21.         u16 secremain; //扇区内剩余地址(16位字计算)           
    ! v; R0 F, t3 ~* P
22. 
    
23.          u16 i;   
    ! g/ X4 R! y% D; X
24. 
    7 i/ o- H! S9 ~- l. s( v' E
25.         u32 offaddr;   //去掉0X08000000后的地址
    
26. 
    
27.         if(WriteAddr<STM32_FLASH_BASE||(WriteAddr>=(STM32_FLASH_BASE+1024*STM32_FLASH_SIZE)))return;//非法地址
    , x5 M$ Y6 [8 L( T0 k0 s
28. 
    
29.         FLASH_Unlock();                                                //解锁
    
30. 
    & f1 F4 E/ q, u7 @3 U2 w
31.         offaddr=WriteAddr-STM32_FLASH_BASE;                //实际偏移地址.
    
32. 
    % e' j, n( E: P: l
33.         secpos=offaddr/STM_SECTOR_SIZE;                        //扇区地址  0~127 for STM32F103RBT6
    8 A' J0 f7 ]0 x9 L( {
34. 
    
35.         secoff=(offaddr%STM_SECTOR_SIZE)/2;                //在扇区内的偏移(2个字节为基本单位.)
    
36. 
    
37.         secremain=STM_SECTOR_SIZE/2-secoff;                //扇区剩余空间大小   
      t8 }# r8 F- q$ J
38. 
    - b) F6 }, d+ ^1 Q% Z: k: N. L
39.         if(NumToWrite<=secremain)
    7 p& S6 u6 ?  Z& \" c6 H
40. 
    
41.         {
    ; I. L' D. t' {8 E4 v& G, X/ T
42. 
    " s4 c2 a! O/ m4 _
43.           secremain=NumToWrite;//不大于该扇区范围
    ' x4 g- @% m5 K5 R6 s  k( b& s
44. 
    # M/ ]! p3 f) J& D- M
45.         }
    6 G6 A$ {  J2 K% I  A! q, }) b
46. 
    
47.         while(1)
    
48. 
    / w! j: B) R/ N* O; J
49.         {        
    
50. 
    
51.                 STMFLASH_Read(((secpos*STM_SECTOR_SIZE)+STM32_FLASH_BASE),STMFLASH_BUF,STM_SECTOR_SIZE/2);//读出整个扇区的内容
    8 w( g5 M9 t% V. M
52. 
    * ]0 Z" \; [) i+ T- ]8 o0 S* Y
53.                 for(i=0;i<secremain;i++)//校验数据
    , p5 H5 z. W- z" q* v
54. 
    
55. //                for(i=0;i<(STM_SECTOR_SIZE/2);i++)//校验数据
    # F" Z8 I" g8 {% j& ]% B
56. 
    
57.                 {
    5 u% D% @% y7 \8 Z9 n# I, Z
58. 
    ' O0 [% \. W4 ]
59.                         if(STMFLASH_BUF[secoff+i]!=0XFFFF)break;//需要擦除  
    / o2 s+ W  I/ A" d
60. 
    
61. //        if(STMFLASH_BUF!=0XFFFF)break;//需要擦除                        
    ; i1 K5 }# N# K6 v
62. 
    
63.                 }
    $ H, b+ B' G/ `9 s# @0 g
64. 
    
65.                 FLASH_ClearFlag(FLASH_FLAG_EOP | FLASH_FLAG_PGERR | FLASH_FLAG_WRPRTERR);
    9 ]0 S# o& J$ M0 e! L! v
66. 
    . r$ m+ b# h$ O. @) U+ |) e
67.                 if(i<secremain)//需要擦除
    ! k: H4 Z2 @+ |# `6 E. s* v; h% B% F! G
68. 
    
69. //                if(i<(STM_SECTOR_SIZE/2))//需要擦除
    
70. 
    & H- e' \# l% C6 Z" V
71.                 {
    
72. 
    : U0 q) `/ ?+ C2 c& w+ u' M2 {
73.                         FLASH_ClearFlag(FLASH_FLAG_EOP | FLASH_FLAG_PGERR | FLASH_FLAG_WRPRTERR);
      U' I  m* a8 a
74. 
    
75. 
    
76. 
    % u0 j0 r* k$ t# z
77.                         FLASH_ErasePage(secpos*STM_SECTOR_SIZE+STM32_FLASH_BASE);//擦除这个扇区
    
78. 
    * R, Z  d! n5 @
79.                         for(i=0;i<secremain;i++)//复制
    " x4 u8 V" v9 g' k: z
80. 
    / p9 K7 k7 V0 ?! s8 q+ \6 z8 A
81.                         {
    
82. 
    2 g9 |) B' D% ^
83.                                 STMFLASH_BUF[i+secoff]=pBuffer;         
    
84. 
    
85.                         }
    
86. 
    $ M, c( s" s3 j# h3 K. V
87.                         STMFLASH_Write_NoCheck(secpos*STM_SECTOR_SIZE+STM32_FLASH_BASE,STMFLASH_BUF,STM_SECTOR_SIZE/2);//写入整个扇区  
    & R7 `! J6 Y* o! b' p2 G1 X0 t# k
88. 
    
89.                 }else STMFLASH_Write_NoCheck(WriteAddr,pBuffer,secremain);//写已经擦除了的,直接写入扇区剩余区间.                                    
    / U1 n; a: o9 {8 n
90. 
    - P% H- L+ Y7 W
91.                 if(NumToWrite==secremain)break;//写入结束了
    
92. 
    ; q2 A8 ?: O: k- D  t8 l
93.                 else//写入未结束
    - L  q6 K: [0 ^& u8 W
94. 
    + j/ L8 ~# u$ l8 x" R) b7 C$ y2 l
95.                 {
    3 f7 ~8 N- i9 d1 z) j4 _7 }
96. 
    # ~; `. l  H8 `
97.                                 secpos++;                                //扇区地址增1
    3 |% @2 w" d0 w9 w
98. 
    2 L, R. e+ k6 f0 D, i8 F
99.                                 secoff=0;                                //偏移位置为0         
    
100. 
     
101.                                   pBuffer+=secremain;          //指针偏移
     . F5 W- j, C7 T1 X+ ]& l$ N9 u
102. 
     
103.                                 WriteAddr+=（secremain*2）;        //写地址偏移           
       J& C" L6 ~; v: o% m; _
104. 
     ) P/ R; y& f( b) s3 j
105.                                  NumToWrite-=secremain;        //字节(16位)数递减
     2 P: n6 w/ ^! z( k1 _
106. 
     
107.                                 if(NumToWrite>(STM_SECTOR_SIZE/2))
     
108. 
     ! B7 P7 a0 i' H
109.                                 {
     
110. 
     4 `7 ?6 z8 Q3 M7 y; g
111.                                   secremain=STM_SECTOR_SIZE/2;//下一个扇区还是写不完
     2 Z8 x% P" ?# k6 _; y/ ]' O2 Y5 O/ A
112. 
     , }* |( J& d& m! R
113.                                 }
     
114. 
     
115.                                 else
     
116. 
     " ~7 S. x( G0 h) {( u5 V
117.                                 {
     
118. 
     4 |! x! w" m9 E1 u3 [
119.                                   secremain=NumToWrite;//下一个扇区可以写完了
     " y: n8 o9 e  T- x: i! r
120. 
     9 n: _0 V" U3 K
121.                                 }
     9 j' r5 ?  ~  n7 H9 V5 T5 P
122. 
     2 `* m2 ]0 l9 Y2 u7 }
123.                 }         
     
124. 
     + |( K2 E( K/ e4 E8 N2 Q9 H
125.         }        
     
126. 
     ; ?7 j; j5 H5 a3 j
127.         FLASH_Lock();//上锁
     
128. 
     # G- Y% V9 u( d
129. }
     

复制代码

5 ^& W/ @0 U9 w) h& F4 w最终我们调用STMFLASH_Write（）函数进行数据的写入，是不是有没看懂的小伙伴，我给大家解释一下写入的过程吧
% i1 a; R( }) i4 c, e
这个STMFLASH_Write（）函数，是说给定一个写入的地址、数据和写入的个数，然后按照给定的地址开始写数据，注意红色字体。
写数据是怎么做的呢
7 {( M2 d4 A5 ^' M/ c9 F首先是整理一下写入的页地址和需要写入多少页，每一页写入的话起始地址是什么
然后开始一页一页的写，当遇到跨页写入的时候，把第二页的地址写进去，写的个数继续写入就行
如果还有不明白的可以在下面留言，我给大家解答
还有一个地方很重要，就是我修改了库函数

0 h" A: E& B+ o
1. /**
   % A. }! u% y  {9 W' |9 ^
2.   * [url=home.php?mod=space&uid=247401]@brief[/url]  Programs a half word at a specified address.
   
3.   * [url=home.php?mod=space&uid=536309]@NOTE[/url]   This function can be used for all STM32F10x devices.
   
4.   * @param  Address: specifies the address to be programmed.
   
5.   * @param  Data: specifies the data to be programmed.
   . x: v* Z/ ^5 Q( [1 G# L
6.   * @retval FLASH Status: The returned value can be: FLASH_ERROR_PG,
   
7.   *         FLASH_ERROR_WRP, FLASH_COMPLETE or FLASH_TIMEOUT.
   
8.   */
   
9. 
   ; W4 D3 Q# N8 l8 {: [
10. FLASH_Status FLASH_ProgramHalfWord(uint32_t Address, uint16_t Data)
    
11. 
    % s: W' X1 D( A  m9 g, b
12. {
    
13. 
    
14.         FLASH_ClearFlag(FLASH_FLAG_EOP | FLASH_FLAG_PGERR | FLASH_FLAG_WRPRTERR);
    ' k) q& b8 O, i, w( G+ P
15. 
    
16.   FLASH_Status status = FLASH_COMPLETE;
    
17. 
    
18.   /* Check the parameters */
    
19. 
    2 V) M' s2 |6 x
20.   assert_param(IS_FLASH_ADDRESS(Address));
    
21. 
    
22. 
    
23. 
    # o/ n, F; q' n# A
24. #ifdef STM32F10X_XL
    
25. 
      M& r/ z1 }& ]/ n
26.   /* Wait for last operation to be completed */
    5 {# K5 c9 V) W! l  T
27. 
    $ m. d* M( C6 z# _2 J
28.   status = FLASH_WaitForLastOperation(ProgramTimeout);
    
29. 
    ! a( J# _; X& l
30. 
    2 r1 r0 w. Q3 b# o6 v* U* I
31. 
    % @9 B4 r* Y  N; S" }& q' E% t
32.   if(Address < FLASH_BANK1_END_ADDRESS)
    
33. 
    2 ]2 s! x# \+ `6 g
34.   {
      z* L* k. {  G/ O3 ?& D
35. 
    7 J5 S, V1 u# d. K7 q
36.     if(status == FLASH_COMPLETE)
    
37. 
    + x; f7 `+ }& m# U+ c. Q
38.     {
    ' B% O! H' A, `7 q( K
39. 
    ) B7 |5 K$ H' {
40.       /* if the previous operation is completed, proceed to program the new data */
    7 [+ `0 ]2 N6 _, A$ }" [' W% n
41. 
    & ~' q6 [) C# f6 @
42.       FLASH->CR |= CR_PG_Set;
    
43. 
    6 j% q" j8 ?6 R. h2 Z! r
44. 
    
45. 
    9 |4 `& Z5 _5 S
46.       *(__IO uint16_t*)Address = Data;
    2 n. b! H/ T9 b# T, B0 W
47. 
    
48.       /* Wait for last operation to be completed */
    + G  i. K' F0 w( l
49. 
    
50.       status = FLASH_WaitForLastBank1Operation(ProgramTimeout);
    ( E$ _6 F- M$ w, \* s, F3 O% {3 N
51. 
    ' d' l# |8 |6 m1 [) P
52. 
    + F4 w! i# X- Y( o: F
53. 
    ; B1 i0 _# [% h0 _! t2 h4 m! ?
54.       /* Disable the PG Bit */
    
55. 
    6 \3 v( _( F6 T
56.       FLASH->CR &= CR_PG_Reset;
    6 M7 ^% D/ t* i5 O) L2 s3 \
57. 
    
58.     }
    ) c* |0 H1 H- z  _7 T! |7 _
59. 
    
60.   }
    
61. 
    5 m- s) r5 s7 R: n/ T6 _0 z
62.   else
    
63. 
    
64.   {
    
65. 
    
66.     if(status == FLASH_COMPLETE)
    
67. 
    / K* Z' ]! G7 _& b8 K# |! z! z
68.     {
    # i. ~, n5 x3 E4 V; C  u) T6 d
69. 
    1 X+ P. h7 q& y0 B
70.       /* if the previous operation is completed, proceed to program the new data */
    5 \0 C2 a7 b; h; ?4 A& `
71. 
    - f! x: z7 E& ^+ H8 J: G4 }4 A; [
72.       FLASH->CR2 |= CR_PG_Set;
    
73. 
    6 v( N' R( e$ O3 w' K  p' h1 y2 w
74. 
    
75. 
    5 E/ H" H! {* m& ^+ o
76.       *(__IO uint16_t*)Address = Data;
    
77. 
    7 G7 |  P" v! s- r- U
78.       /* Wait for last operation to be completed */
    
79. 
    
80.       status = FLASH_WaitForLastBank2Operation(ProgramTimeout);
    
81. 
    
82. 
    ) q( ?" x5 g( V! J' \
83. 
    
84.       /* Disable the PG Bit */
    ; S9 L/ o3 A, }2 B
85. 
      r2 S8 y3 O. T
86.       FLASH->CR2 &= CR_PG_Reset;
    
87. 
    3 P$ f4 Q& d& Z+ m
88.     }
    
89. 
    
90.   }
    
91. 
    
92. #else
    
93. 
    
94.   /* Wait for last operation to be completed */
    
95. 
    
96.   status = FLASH_WaitForLastOperation(ProgramTimeout);
    ; T& q. d7 L# H7 {
97. 
    
98. 
    3 H* }5 U$ M. ?) }$ P
99. 
    % a/ [7 [7 t( F/ g
100.   if(status == FLASH_COMPLETE)
     
101. 
     
102.   {
     , `: H" d0 m$ g. {- W4 ^
103. 
     6 c7 q" L, K: b) o. x$ ^
104.     /* if the previous operation is completed, proceed to program the new data */
     ! X, F2 ~$ _& @
105. 
     8 q8 c/ p7 o+ b* z; P" c% q. ^
106.     FLASH->CR |= CR_PG_Set;
     
107. 
     2 s+ F' ]& O: E
108. 
     
109. 
     + G3 V- g# R0 N7 z" i
110.     *(__IO uint16_t*)Address = Data;
       B0 D. M1 C& ^4 r; v
111. 
     
112.     /* Wait for last operation to be completed */
     + l: A1 }) ^! i: ^% z
113. 
     + C, @: M5 V( U% f, S
114.     status = FLASH_WaitForLastOperation(ProgramTimeout);
     
115. 
     ( \$ P7 q$ S7 n  N6 w7 x
116. 
     0 ?' A2 _% q2 W$ A
117. 
       s; ?& r4 g9 G
118.     /* Disable the PG Bit */
     
119. 
     5 l9 S: |2 y. O7 E
120.     FLASH->CR &= CR_PG_Reset;
     9 Y3 w  U' P5 r4 g$ y
121. 
       T) i( S, |% }% g" v# f
122.   }
     # Q/ D" p( {; N/ A$ a; A5 L2 V
123. 
     
124. #endif  /* STM32F10X_XL */
     / l' C7 a. S! c, o$ o1 y
125. 
     
126. 
       a& f7 R9 X  `% y: k
127. 
     
128.   /* Return the Program Status */
     + q0 P" c4 y1 h5 |9 b
129. 
     
130.   return status;
     ' z) T7 Y# o7 ~7 q* z
131. 
     3 U' U) a, z0 i, q; s' l$ P
132. }
复制代码

+ t& @4 t) t* W+ E4 j

大家能看出来吗?就是红色字体部分，增加了一个每次写入前清除所有异常状态。
" Q, x! w1 L1 H; y5 Z! d为什么添加这个呢？
5 C6 C3 V, r. N6 }% b3 U因为，如果你写入的数据的地址没有擦除，你就写入的话会导致异常状态的发生，而这个异常状态时要手动清除的，如果你没有清除这个异常状态，而继续写入数据的话，那么你后面写入任何数据都会报错，均写不进去，所以我在这里增加了一个异常状态清除，如果前面写入的数据报错了，不会影响我接下来的数据写入。
' y9 o5 Y# C8 V这里大家就清除为什么了吧。
写数据会了，那么再说一下读数据，其实这里读数据要比外部flash读取容易的多，我们直接读取地址，返回的就是地址存放的数据，是不是很简单
( P5 i; z- u. ~' v, `9 B, W看下面的函数

4 z  W" X# ~/ N. X/ e' G

1. 
   
2. //读取指定地址的半字(16位数据)
   + S5 W- |7 r4 u; z# H# D0 s, ?1 X
3. 
   
4. //faddr:读地址(此地址必须为2的倍数!!)
   
5. 
   / n4 s8 t* h; d( m+ Q9 l- O
6. //返回值:对应数据.
   - R& T1 A) p/ H& w
7. 
   9 _) _/ u0 z4 _6 J
8. u16 STMFLASH_ReadHalfWord(u32 faddr)
   ! m6 |' d% y5 B
9. 
   
10. {
    
11. 
    
12.         return *(vu16*)faddr;
    + y2 ~* N" P  I9 M8 E; |! ~
13. 
    
14. }
    : _% w2 O( X5 M' z
15. 
    ' D  }- _; G8 u3 i3 b" f6 V
16. 
    + N; v7 q0 c: D; u! p% o
17. 
    ' a% m6 }% r2 b, d0 ?7 f$ r  ?
18. //从指定地址开始读出指定长度的数据
    
19. 
    , a! `4 S/ o0 _2 y. j2 I
20. //ReadAddr:起始地址
    : L& o0 t0 Y* D+ I
21. 
    . h8 P6 ?0 T# p% ]5 i8 W
22. //pBuffer:数据指针
    
23. 
    0 m% ?" n% P8 I" r: X
24. //NumToWrite:半字(16位)数
      v( I7 Q8 N8 a) i. @2 Y7 A
25. 
    5 W! Q! i" G  K2 A& |- C
26. 
    * l4 F, ]9 @6 V+ G" e
27. 
      H, @! K6 H! k. v0 ^" ?
28. void STMFLASH_Read(u32 ReadAddr,u16 *pBuffer,u16 NumToRead)           
    
29. 
    
30. {
    
31. 
    
32.         u16 i;
    
33. 
    
34.         for(i=0;i<NumToRead;i++)
    
35. 
    
36.         {
      p. R2 C9 F1 p  a7 u2 B
37. 
    
38.                 pBuffer=STMFLASH_ReadHalfWord(ReadAddr);//读取2个字节.
    
39. 
    ' {% A5 M" A& f: l- M
40.                 ReadAddr+=2;//偏移2个字节.        
    ( _& d8 k4 s* ^2 Y
41. 
    " Q( i* k3 o1 A; z4 ^' d: [) i
42.         }
    
43. 
    9 ?3 O$ |2 @( N. C6 i0 C, w+ T
44. }
    * H3 z9 Z; H; m( C

复制代码

0 w7 A$ a/ V. ~* Z6 o- [3 R+ X有没有很开心，读写数据就是这么简单就完成了。
* {+ {1 _% T' \- ~( @3 O  c+ }& A
# _: [& @7 i/ G7 E" D! b---------------------
: f+ {* i( D) @1 m2 w作者：binoo7