一、芯片FLASH容量分类：

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

既然是中等容量的设备了，那我们就来看看flash划分吧，在STM32的闪存编程手册中有这样一段话：按照不同容量，
$ Z! [( [" [2 r) @* W$ H$ b4 h存储器组织成：
32个1K字节/页(小容量)
128个1K字节/页(中容量)
256个2K字节/页(大容量)
这段话怎么理解呢，就是告诉我们小容量的设备（内存是6K和32K）的设备是由1K字节每页组成的，
0 }9 ~1 N2 {$ I! O' K6 L) ]1 N中容量的设备（内存是64K和128K）的设备是由1K字节每页组成的，
' Y3 L5 e/ v9 n0 a/ t大容量的设备（内存是256K、384K和512K）的设备是由2K字节每页组成的，
举个例子吧：
一个芯片的存储容量是64K，这64K是什么呢，就是64*1024个BYTE，一个BYTE是由8位0或1组成的，（比如0000 1111 这8个二进制数组成了一个字节，用十进制来说就是15）
, L+ d, a+ e1 K# w5 d小结一下：64K的flash可以存储64*1024个字节的数据。
6 i( T7 `# ~2 {8 c, \4 w咱们继续说，这64K的数据怎么划分，存储是按照页为单位进行存储的，一页1K的容量，也就说一页可以存储1024个字节
0 ?: {8 Y% Q+ M$ n6 [0 Q* l一共是多少页？
答案是：64页，我们看一下官方是不是这么说的

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

二、 读写步骤：
& l9 h' |2 }* Q! T9 ^上面我们知道了芯片是怎么分类的，下面我们就重点来讲解一下芯片是怎么读写的。
内部flash我们参照HAL库或者标准库，直接调用ST公司给我们封装好的库进行编程就可以了，这里我用的是标准库，有兴趣的小伙伴可以去看看HAL库
9 f. _3 b  @+ R, w9 U% s是不是有小伙伴会疑问什么是标准库，什么是HAL库？
% L3 L3 D3 e. o. d. A在这里给大家解释一下，这两个库都是ST公司，直接把寄存器封装成函数，供大家直接调用某一个函数，就可以完成各种寄存器的配置，不容大家直面芯片的寄存器，方便阅读和使用，因为每个函数的名称功能都是不一样的，在调用前可以参考函数的注释，在F0和F4的标准库里甚至有每个函数的用法，不知道为什么在F1的库里把使用步骤去掉了。
咱们继续，读写的话库函数分为：

1. /*------------ Functions used for all STM32F10x devices -----*/
   
2. 
   
3. void FLASH_SetLatency(uint32_t FLASH_Latency);
   
4. 
   2 T( y0 W3 h  ?* C1 x
5. void FLASH_HalfCycleAccessCmd(uint32_t FLASH_HalfCycleAccess);
   + B& f3 b4 _( z0 W. z% f
6. 
   
7. void FLASH_PrefetchBufferCmd(uint32_t FLASH_PrefetchBuffer);
   ; R, D/ i! H+ p3 z( h& S" a
8. 
   
9. void FLASH_Unlock(void);
   
10. 
    0 ^1 ^' Q  h# u3 e
11. void FLASH_Lock(void);
    
12. 
    
13. FLASH_Status FLASH_ErasePage(uint32_t Page_Address);
    
14. 
    ; A0 i3 W$ k3 E" t1 `0 R- y7 f
15. FLASH_Status FLASH_EraseAllPages(void);
    
16. 
    9 Z+ k( o. Q) p) f5 {1 V
17. FLASH_Status FLASH_EraseOptionBytes(void);
    8 h3 X# w6 m; x9 I
18. 
    . ?9 v4 K/ ]3 K  w$ A1 [% M
19. FLASH_Status FLASH_ProgramWord(uint32_t Address, uint32_t Data);
    ' [5 S/ l! q6 V8 p  n
20. 
    
21. FLASH_Status FLASH_ProgramHalfWord(uint32_t Address, uint16_t Data);
    & L8 x4 U) e6 ~9 S
22. 
    $ x( Z0 y, Q6 z
23. FLASH_Status FLASH_ProgramOptionByteData(uint32_t Address, uint8_t Data);
    
24. 
    
25. FLASH_Status FLASH_EnableWriteProtection(uint32_t FLASH_Pages);
    - a. Y/ X, Y' T2 V) f, `' x8 `9 ]) H: v
26. 
    
27. FLASH_Status FLASH_ReadOutProtection(FunctionalState NewState);
    
28. 
    2 v+ c( u/ c) ?- x2 u$ e6 b+ H! Q, B, V
29. FLASH_Status FLASH_UserOptionByteConfig(uint16_t OB_IWDG, uint16_t OB_STOP, uint16_t OB_STDBY);
    1 t+ V. b; \6 k7 n' ~
30. 
    * Z' u' ]9 i# g6 E3 F" u- }
31. uint32_t FLASH_GetUserOptionByte(void);
    
32. 
    
33. uint32_t FLASH_GetWriteProtectionOptionByte(void);
    
34. 
    9 a1 y* u, ?$ p1 o# P
35. FlagStatus FLASH_GetReadOutProtectionStatus(void);
    
36. 
    $ l' K9 \0 T& T' W" a% w
37. FlagStatus FLASH_GetPrefetchBufferStatus(void);
    ' v: K$ `1 I" Z  ?# c. @, I" S
38. 
    , M- a; r( L! }3 [4 F2 i! p1 w
39. void FLASH_ITConfig(uint32_t FLASH_IT, FunctionalState NewState);
    9 L2 B: v6 a0 q. C' e
40. 
    , [4 Z8 a1 b5 D
41. FlagStatus FLASH_GetFlagStatus(uint32_t FLASH_FLAG);
    9 X) b' Z9 g  B
42. 
    
43. void FLASH_ClearFlag(uint32_t FLASH_FLAG);
    ( P3 W' [- O( |& O9 @6 Z0 O0 S
44. 
    8 K9 I( }' V+ Y' y/ H3 p8 \
45. FLASH_Status FLASH_GetStatus(void);
    8 B5 x4 }' V/ u( b6 W6 J7 o
46. 
    
47. FLASH_Status FLASH_WaitForLastOperation(uint32_t Timeout);
    - c0 F$ j* z5 M
48. 
    
49. 
    # h2 b0 I1 \5 R& t
50. 
    / `, H1 ]! z3 I  B$ b2 ?6 j4 }
51. /*------------ New function used for all STM32F10x devices -----*/
    / t. o- {6 I. ?5 O: e
52. 
    ) X' o$ t2 Q6 h/ L8 [
53. void FLASH_UnlockBank1(void);
      p' z9 F1 W+ v  x
54. 
    9 F) M* E$ c1 R6 j
55. void FLASH_LockBank1(void);
    , @5 |1 [4 P7 C4 S5 u: @
56. 
    
57. FLASH_Status FLASH_EraseAllBank1Pages(void);
    
58. 
    3 m# i9 A7 G# {( a& Q# h
59. FLASH_Status FLASH_GetBank1Status(void);
    
60. 
    
61. FLASH_Status FLASH_WaitForLastBank1Operation(uint32_t Timeout);

复制代码

在这里就不一个一个的详细说了，我们说一下常用的就行
3 g0 R5 Z; C7 G1 K1. 解锁

void FLASH_Unlock(void);

2. 上锁

void FLASH_Lock(void);

# E  Y0 c5 g  }& U. @% H3. 页擦除

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，这也就是为什么我们要先确保写入前的数据是被擦除了的原因。第四步：上锁第五步：验证写入是否正确其实第五步可以省略。我们看看官方给的写入过

$ ~- u3 p6 o$ K+ c8 o0 j! S好了，其实是一样的。
4 v* X" c) u" Y7 u+ H下面我就和大家来分享一下（百分之九十九参考的正点原子的例程）

1. //不检查的写入
   
2. 
   8 n6 Z6 [, I9 c6 [
3. //WriteAddr:起始地址
   , C6 J! F8 F) t/ H+ r  E( T
4. 
   
5. //pBuffer:数据指针
   
6. 
   : ^' ^: G! w, p2 E4 ?. M3 T
7. //NumToWrite:半字(16位)数   
   2 F: |, [! R% f
8. 
   
9. void STMFLASH_Write_NoCheck(u32 WriteAddr,u16 *pBuffer,u16 NumToWrite)   
   
10. 
    
11. {                                          
    
12. 
    
13.         u16 i;
    , m- ]  \% y- x0 c0 J
14. 
    
15.         for(i=0;i<NumToWrite;i++)
    9 o7 z4 R8 ?) j
16. 
    5 ]- u1 |4 D2 d, Z  {* x
17.         {
    
18. 
    
19.                 FLASH_ProgramHalfWord(WriteAddr,pBuffer);
    8 m/ A  X  N! r5 W
20. 
    3 E* k# o& q9 D7 W' J
21.             WriteAddr+=2;//地址增加2.
    ) J, D4 [8 m" A; K
22. 
    + f& d$ z; M% I5 U8 U. |
23.         }  
    / p3 @+ d' B4 h
24. 
    
25. }

复制代码

1. //从指定地址开始写入指定长度的数据
   + ~5 j  `2 b2 j
2. 
   ' W. V. v& j! Z. [; y2 S! v
3. //WriteAddr:起始地址(此地址必须为2的倍数!!)
   
4. 
   
5. //pBuffer:数据指针
   
6. 
   - p: J. k; S. U4 ]' A1 `$ d* q
7. //NumToWrite:半字(16位)数(就是要写入的16位数据的个数.)
   
8. 
   # E" G5 K+ n; d7 a) O
9. 
   : F% ^7 `% g: f
10. 
    
11. u16 STMFLASH_BUF[STM_SECTOR_SIZE/2];//最多是2K字节
    ' v$ W2 A  i5 `0 G* L0 b% F$ Q: m
12. 
    
13. void STMFLASH_Write(u32 WriteAddr,u16 *pBuffer,u16 NumToWrite)        
    
14. 
    
15. {
    % k/ a2 [4 V7 J) T; G) Z+ p5 ]# F
16. 
      Z0 F- x# I. o4 o3 }& ?- P
17.         u32 secpos;           //扇区地址
    , W! L5 H8 G( H2 _* B
18. 
    ) n$ ?, S, c8 I' }& S( S
19.         u16 secoff;           //扇区内偏移地址(16位字计算)
    8 _, x8 L: q  ?* K; Y
20. 
    
21.         u16 secremain; //扇区内剩余地址(16位字计算)           
    
22. 
    
23.          u16 i;   
    
24. 
    , ~9 H, A% L- R* R
25.         u32 offaddr;   //去掉0X08000000后的地址
    $ F/ T+ w4 a6 Y+ y% X( W
26. 
    0 t" g. A# b' X$ H% |# x7 Y6 y
27.         if(WriteAddr<STM32_FLASH_BASE||(WriteAddr>=(STM32_FLASH_BASE+1024*STM32_FLASH_SIZE)))return;//非法地址
    1 r; m8 u( x8 f' _" d4 d4 _
28. 
    
29.         FLASH_Unlock();                                                //解锁
    5 L- K: m5 O, ?8 v: H  m8 y
30. 
    
31.         offaddr=WriteAddr-STM32_FLASH_BASE;                //实际偏移地址.
    1 l) L' [* t4 {% D  U' x. r
32. 
    
33.         secpos=offaddr/STM_SECTOR_SIZE;                        //扇区地址  0~127 for STM32F103RBT6
    : ^. C" o- g9 Y: {+ c  Q
34. 
    
35.         secoff=(offaddr%STM_SECTOR_SIZE)/2;                //在扇区内的偏移(2个字节为基本单位.)
    
36. 
    ! |$ \/ Y3 g1 i$ A: v1 L
37.         secremain=STM_SECTOR_SIZE/2-secoff;                //扇区剩余空间大小   
    ) M' z6 C, S: {# A, c3 i; O
38. 
    2 o, \0 S2 r9 r6 c# u9 A9 S9 h3 |/ V, S
39.         if(NumToWrite<=secremain)
    5 e6 o# _: C: y! Z( a& X
40. 
    7 r" O; s  D4 R% M0 G
41.         {
    
42. 
    
43.           secremain=NumToWrite;//不大于该扇区范围
    
44. 
    0 w. ^- N$ ?0 T" `9 X) H
45.         }
    
46. 
    , V1 b( z) f$ v8 Z
47.         while(1)
    7 e' e) d5 S5 m- N9 D  F6 Y9 Z
48. 
    
49.         {        
    : J' b, M7 s5 ~5 W" y, m8 q
50. 
    . x( j) I9 d. \0 ^' o1 N
51.                 STMFLASH_Read(((secpos*STM_SECTOR_SIZE)+STM32_FLASH_BASE),STMFLASH_BUF,STM_SECTOR_SIZE/2);//读出整个扇区的内容
    
52. 
    
53.                 for(i=0;i<secremain;i++)//校验数据
    . _' A$ f. `! t6 ~  k, l
54. 
    ; ?0 S* O* T) W, ~2 [- Y
55. //                for(i=0;i<(STM_SECTOR_SIZE/2);i++)//校验数据
      c: e5 e/ w# S$ ~/ l( q/ J: E& s
56. 
    
57.                 {
    + v+ c2 \6 }/ H, {' a0 Z1 Y) r4 F
58. 
    
59.                         if(STMFLASH_BUF[secoff+i]!=0XFFFF)break;//需要擦除  
    # ], K! y3 b3 Z. G
60. 
    
61. //        if(STMFLASH_BUF!=0XFFFF)break;//需要擦除                        
    6 F: s' m0 i% f+ e$ A( e( @- V
62. 
    ) ?- Y; Z, G# M! m- e
63.                 }
    
64. 
    
65.                 FLASH_ClearFlag(FLASH_FLAG_EOP | FLASH_FLAG_PGERR | FLASH_FLAG_WRPRTERR);
    
66. 
    
67.                 if(i<secremain)//需要擦除
    / ~, N8 c3 h$ d3 s8 j
68. 
    $ U2 X7 X- k5 [
69. //                if(i<(STM_SECTOR_SIZE/2))//需要擦除
    
70. 
    
71.                 {
    ( q/ i% q( m0 t5 v$ Y+ @
72. 
    
73.                         FLASH_ClearFlag(FLASH_FLAG_EOP | FLASH_FLAG_PGERR | FLASH_FLAG_WRPRTERR);
    0 h1 W. x4 h7 s: m
74. 
    ) Q0 C$ B6 P; d' c; U6 u1 I
75. 
    3 `" D) x' W$ [: j' o7 ^
76. 
    , {; U: ?; X, a* T( }8 v
77.                         FLASH_ErasePage(secpos*STM_SECTOR_SIZE+STM32_FLASH_BASE);//擦除这个扇区
    " Z9 R( b2 i5 o& r8 N- f  T  m
78. 
    & @9 _! P  n5 ~) S) D* f
79.                         for(i=0;i<secremain;i++)//复制
    
80. 
    $ R5 x6 s0 x  I3 `; K
81.                         {
    " D6 {3 [0 N7 [9 G7 t8 S! l
82. 
    / M1 ]! B0 y: e# a. U  _
83.                                 STMFLASH_BUF[i+secoff]=pBuffer;         
    7 a/ @: `0 @# L; Q: o6 Y1 g
84. 
    
85.                         }
    
86. 
    3 K- x, _7 R$ F8 f
87.                         STMFLASH_Write_NoCheck(secpos*STM_SECTOR_SIZE+STM32_FLASH_BASE,STMFLASH_BUF,STM_SECTOR_SIZE/2);//写入整个扇区  
    
88. 
    
89.                 }else STMFLASH_Write_NoCheck(WriteAddr,pBuffer,secremain);//写已经擦除了的,直接写入扇区剩余区间.                                    
    
90. 
    
91.                 if(NumToWrite==secremain)break;//写入结束了
    1 e+ f' k* k8 r, G( a" e
92. 
    9 D" D( ~+ v2 Q& _. _# y/ q
93.                 else//写入未结束
    
94. 
    ) L" u9 l( e. D( B, U% L
95.                 {
    1 o0 A$ `( L+ g5 c, q
96. 
    ; W# U; G# T* q
97.                                 secpos++;                                //扇区地址增1
    & P  l/ D2 [* b+ K
98. 
    8 y, ~" ~( j( ~0 N/ |
99.                                 secoff=0;                                //偏移位置为0         
    8 ]" k; R2 w* J
100. 
     0 r, U# \, m, R5 ?5 X
101.                                   pBuffer+=secremain;          //指针偏移
     
102. 
     
103.                                 WriteAddr+=（secremain*2）;        //写地址偏移           
     
104. 
     
105.                                  NumToWrite-=secremain;        //字节(16位)数递减
     $ L1 j5 S; j, `: R- ^5 w
106. 
     
107.                                 if(NumToWrite>(STM_SECTOR_SIZE/2))
     ! I$ e2 q; N. b# J
108. 
     9 `) n9 m; C' d) r
109.                                 {
     
110. 
     
111.                                   secremain=STM_SECTOR_SIZE/2;//下一个扇区还是写不完
     
112. 
     
113.                                 }
     . o  Q) l$ W2 z5 t/ n9 t
114. 
     
115.                                 else
       a( k" F1 @/ A$ x5 Z
116. 
     3 q$ G$ h+ V! d3 [8 {* ]' k
117.                                 {
     $ _2 C* v/ J3 V
118. 
     
119.                                   secremain=NumToWrite;//下一个扇区可以写完了
     
120. 
     , X! p7 Z9 g  z3 t) `! N
121.                                 }
     * K2 i: F4 z! _. M/ |- @  ]
122. 
     9 _' \) R% t5 K# d$ B
123.                 }         
     
124. 
     
125.         }        
     - C" j* m5 t1 g; @6 P1 z. I
126. 
     4 Z7 Y" ^, l/ G
127.         FLASH_Lock();//上锁
     , D2 R' A' e: D9 @; l# G! T
128. 
     
129. }
     " s( a3 d+ R1 N0 G: G: y

复制代码

$ n6 j4 F3 `. m1 C* {+ k

$ L6 x& Y+ f, R1 T& `3 ]  u最终我们调用STMFLASH_Write（）函数进行数据的写入，是不是有没看懂的小伙伴，我给大家解释一下写入的过程吧
2 s3 K9 b4 c3 v( h7 j
这个STMFLASH_Write（）函数，是说给定一个写入的地址、数据和写入的个数，然后按照给定的地址开始写数据，注意红色字体。
写数据是怎么做的呢
首先是整理一下写入的页地址和需要写入多少页，每一页写入的话起始地址是什么
然后开始一页一页的写，当遇到跨页写入的时候，把第二页的地址写进去，写的个数继续写入就行
# `( |+ w2 l1 a+ k! L% @如果还有不明白的可以在下面留言，我给大家解答
& q' i' ~& H: i  V  C还有一个地方很重要，就是我修改了库函数

8 M; d8 w& X3 ^: W" z6 S
1. /**
   1 k; H4 [4 Q' e5 x' a
2.   * [url=home.php?mod=space&uid=247401]@brief[/url]  Programs a half word at a specified address.
   + b. v* ?8 W% @) I* K6 A
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.
   
6.   * @retval FLASH Status: The returned value can be: FLASH_ERROR_PG,
   % m; k6 h1 s5 r4 o
7.   *         FLASH_ERROR_WRP, FLASH_COMPLETE or FLASH_TIMEOUT.
   * C7 t/ J$ s4 k3 u, E
8.   */
   7 v$ k; j' _- [4 E  q% Q
9. 
   8 f8 p. [# M5 _1 p* d
10. FLASH_Status FLASH_ProgramHalfWord(uint32_t Address, uint16_t Data)
    # B# t# G* e" W8 s
11. 
    
12. {
    
13. 
    
14.         FLASH_ClearFlag(FLASH_FLAG_EOP | FLASH_FLAG_PGERR | FLASH_FLAG_WRPRTERR);
    / t% x9 ~) N9 o+ o
15. 
    
16.   FLASH_Status status = FLASH_COMPLETE;
    # C2 b8 `& ]1 F1 K8 U
17. 
    
18.   /* Check the parameters */
    
19. 
    " A0 f: ]0 T5 ]3 W/ f. v
20.   assert_param(IS_FLASH_ADDRESS(Address));
    
21. 
      b4 |1 Y9 k" W+ g" o( F
22. 
    - r% ~5 {1 n% f- |$ `* t
23. 
    
24. #ifdef STM32F10X_XL
    
25. 
    ) Q4 p# W7 A7 P/ {; e5 B. y
26.   /* Wait for last operation to be completed */
    8 ^0 x9 U; N7 \) Z. t' _; e  G
27. 
    
28.   status = FLASH_WaitForLastOperation(ProgramTimeout);
    
29. 
    
30. 
    + w$ |9 f1 Z$ H: X  Q; ?% j: P( N
31. 
    
32.   if(Address < FLASH_BANK1_END_ADDRESS)
    $ [) @7 Z- c- r: Z5 t
33. 
    , ]3 C; q% j9 {/ K! e
34.   {
    
35. 
    * ]/ i& U/ u; V3 P; C2 P* f
36.     if(status == FLASH_COMPLETE)
    
37. 
    
38.     {
    & Y9 A2 @" L: h$ J
39. 
    
40.       /* if the previous operation is completed, proceed to program the new data */
    . f9 t8 [) S4 `1 S, t
41. 
    9 ?) P! Y5 D# D: H% G, ~
42.       FLASH->CR |= CR_PG_Set;
    
43. 
    , p- I# A- }: G8 J4 h  ~: K
44. 
    ' V: q4 M( o* a: p1 x& J
45. 
    
46.       *(__IO uint16_t*)Address = Data;
    
47. 
    # ?7 E! S, M% }: @$ V" F
48.       /* Wait for last operation to be completed */
    
49. 
      ~+ F. \' H6 Y! }8 _. w# \( q, r
50.       status = FLASH_WaitForLastBank1Operation(ProgramTimeout);
    / a- W4 W# o: g
51. 
    ! N! z9 h/ q. I! v% C6 \
52. 
    , l! q, Z% k* S& Z# B
53. 
    . T1 Z8 V3 H+ q, {  J5 ?& ?6 k) _
54.       /* Disable the PG Bit */
    
55. 
    
56.       FLASH->CR &= CR_PG_Reset;
    & u0 a7 i8 O' f8 \' x% R
57. 
    
58.     }
    / I; m6 x! X* e' P& V8 H3 p- R
59. 
    $ t# Z2 E* _2 ~; H+ Z
60.   }
    2 v. a$ S+ X9 X, ~' c
61. 
    7 ^1 K2 \) \! I7 S* r
62.   else
    " H0 L/ K- O& X$ q$ V0 p% G
63. 
    
64.   {
    
65. 
    8 z1 R4 |) }* v0 F- m$ v$ a- H
66.     if(status == FLASH_COMPLETE)
    $ g: x) a# }' w% U3 P8 w( W- C
67. 
    
68.     {
    
69. 
    
70.       /* if the previous operation is completed, proceed to program the new data */
      O1 \1 x  Z& l
71. 
    
72.       FLASH->CR2 |= CR_PG_Set;
      T7 q3 y; I1 j7 D6 v' ?0 S
73. 
    * h0 _# w- i' u6 z$ g
74. 
    
75. 
    
76.       *(__IO uint16_t*)Address = Data;
    $ c3 H/ I' ]5 c- Q+ e( m
77. 
    0 P+ i- ~: X1 {5 ]& V2 a3 I
78.       /* Wait for last operation to be completed */
    : }4 O+ O" |2 w" W7 L0 P
79. 
    - m) a5 E* X" K% o. M
80.       status = FLASH_WaitForLastBank2Operation(ProgramTimeout);
    
81. 
    
82. 
    3 r: r, d2 D. U) Q/ N
83. 
    2 J1 [3 P0 E# |. j: K: A5 |# W
84.       /* Disable the PG Bit */
    
85. 
    ' w: s' K1 D0 j3 z: h0 m* `# }( W
86.       FLASH->CR2 &= CR_PG_Reset;
    
87. 
    
88.     }
    # _' S. \, _4 H7 ]
89. 
    
90.   }
    
91. 
    
92. #else
    ; d* b; h8 @4 h! L
93. 
    
94.   /* Wait for last operation to be completed */
    
95. 
    2 C6 Y0 G' J9 E- N
96.   status = FLASH_WaitForLastOperation(ProgramTimeout);
    
97. 
    
98. 
    
99. 
    
100.   if(status == FLASH_COMPLETE)
     
101. 
       {  X  ?. n% a  s7 o% [9 N6 X
102.   {
     
103. 
     & K& M4 Q' S7 ^, l7 r
104.     /* if the previous operation is completed, proceed to program the new data */
     2 s4 G" M0 r  F) H1 j+ E
105. 
     ) y* J5 q8 F6 r
106.     FLASH->CR |= CR_PG_Set;
     
107. 
     3 h3 L6 s! H8 y  V4 l- @! ?" b
108. 
     
109. 
     9 b& q7 e( F6 m7 T
110.     *(__IO uint16_t*)Address = Data;
     
111. 
     
112.     /* Wait for last operation to be completed */
     . i$ w2 J( J' d0 |  R2 M
113. 
     
114.     status = FLASH_WaitForLastOperation(ProgramTimeout);
     4 b  G9 J7 X5 V
115. 
     * q% z' {5 }. Y  @4 J7 P' [2 z* ?
116. 
     # G1 d# G3 G; L1 h
117. 
     
118.     /* Disable the PG Bit */
     
119. 
     
120.     FLASH->CR &= CR_PG_Reset;
     2 a+ `8 O& x, b7 m
121. 
     : o$ O; j) `7 b' v' x  T  _
122.   }
     $ d- ~8 Y+ `& Q1 W$ |9 e! [
123. 
     1 S8 v5 t7 U0 C
124. #endif  /* STM32F10X_XL */
     1 B: |! f5 b6 X& w8 t# w0 M; y
125. 
     
126. 
     
127. 
     
128.   /* Return the Program Status */
     
129. 
     
130.   return status;
     
131. 
     " c- a# N5 x4 e& U4 f3 {% A
132. }
复制代码

: G( b7 p, q! ~$ \$ n& M  M% r

' e3 o4 T, q- o! o, F大家能看出来吗?就是红色字体部分，增加了一个每次写入前清除所有异常状态。
; d1 O1 ?, e5 Y& Q; k为什么添加这个呢？
因为，如果你写入的数据的地址没有擦除，你就写入的话会导致异常状态的发生，而这个异常状态时要手动清除的，如果你没有清除这个异常状态，而继续写入数据的话，那么你后面写入任何数据都会报错，均写不进去，所以我在这里增加了一个异常状态清除，如果前面写入的数据报错了，不会影响我接下来的数据写入。
这里大家就清除为什么了吧。
; j4 @0 w: T* p$ d1 J) M写数据会了，那么再说一下读数据，其实这里读数据要比外部flash读取容易的多，我们直接读取地址，返回的就是地址存放的数据，是不是很简单
看下面的函数

1. 
   ' [0 W% ]9 M$ U8 r
2. //读取指定地址的半字(16位数据)
   
3. 
   
4. //faddr:读地址(此地址必须为2的倍数!!)
   
5. 
   
6. //返回值:对应数据.
   8 [4 X# U+ e" q  C- n7 K6 b1 _
7. 
   
8. u16 STMFLASH_ReadHalfWord(u32 faddr)
   
9. 
   
10. {
    2 |, i. c* q& [
11. 
    
12.         return *(vu16*)faddr;
    & V; |0 v& _* E
13. 
    7 L' B$ ?$ D* g, r/ a
14. }
    
15. 
    
16. 
    
17. 
    
18. //从指定地址开始读出指定长度的数据
    : M% [6 W8 A: H' k# W8 W
19. 
    
20. //ReadAddr:起始地址
    
21. 
    : |, M4 T& n$ t, E
22. //pBuffer:数据指针
    ( @1 _3 m, H  l* T- Z$ \7 z" Q% ~
23. 
    
24. //NumToWrite:半字(16位)数
    
25. 
    ! t! X3 t# g' L+ \
26. 
    ) c1 P: s2 ~: g- c+ N8 B
27. 
    ! g# t* s0 x6 @9 e
28. void STMFLASH_Read(u32 ReadAddr,u16 *pBuffer,u16 NumToRead)           
    . N3 z7 w! n0 A: c8 f
29. 
    
30. {
    
31. 
    
32.         u16 i;
    2 f6 h2 j, N9 q9 R- d
33. 
    . f. z4 d! O  b
34.         for(i=0;i<NumToRead;i++)
      G5 F. z  X2 d1 ]4 d
35. 
    ' g1 O( }4 o8 S2 [! u1 N- K% g+ P7 b
36.         {
    , r6 h. E$ p  f& X
37. 
    8 V0 N8 z4 J; g$ m' G
38.                 pBuffer=STMFLASH_ReadHalfWord(ReadAddr);//读取2个字节.
    ! c1 N2 d& p3 ^- n' X
39. 
    
40.                 ReadAddr+=2;//偏移2个字节.        
    
41. 
    9 _" d2 F( |; }) S
42.         }
    
43. 
    : Q3 [! j2 i  p/ x
44. }
    

复制代码

有没有很开心，读写数据就是这么简单就完成了。
7 O, L0 }, Q4 Z9 Q
& f9 q. ]6 ]% L8 x---------------------
作者：binoo7

& j  `" N& ~* X$ t  O" p, M2 C