1、模拟SPI方式的IO配置
! N$ x# @! ^# u0 F6 |0 @/ J


2、驱动代码
3 s9 ^& Z$ X, ~/ m5 p; u2.1 头文件

1. #ifndef __W25QXX_H
   7 L1 d$ K- P) q
2. #define __W25QXX_H                           
   
3. #include "main.h"
   3 m% s1 `1 ]4 }% S& o: x
4. 
   
5. //W25X系列/Q系列芯片列表           
   3 T& g9 @/ S% Q6 ]
6. //W25Q80  ID  0XEF13
   : D. ]; [8 d5 U" t' c, g
7. //W25Q16  ID  0XEF14
   # M* r  Q6 b6 q1 D1 k2 [
8. //W25Q32  ID  0XEF15
   
9. //W25Q64  ID  0XEF16        
   / [7 w. |/ r( H+ A
10. //W25Q128 ID  0XEF17        
    
11. #define W25Q80         0XEF13         
    ' P- j! v) R' T) A# W) z
12. #define W25Q16         0XEF14
    
13. #define W25Q32         0XEF15
    6 g, j  b+ X) K# ]
14. #define W25Q64         0XEF16
    - f4 f( P& A( U" h
15. #define W25Q128        0XEF17
    
16. 
    
17. extern uint16_t W25QXX_TYPE;                                        //定义W25QXX芯片型号                  
    
18. extern uint32_t W25QXX_SIZE;                    //容量
    
19. extern uint8_t  W25QXX_UID[];                   //唯一ID
    
20. 
    
21. //
    # b; W, M! u2 T+ u
22. //指令表
    
23. #define W25X_WriteEnable                0x06
    
24. #define W25X_WriteDisable                0x04
    / z% f# j& Y" @: N( ^! a
25. #define W25X_ReadStatusReg                0x05
    * p" D3 \' Q9 S+ Q8 \; u
26. #define W25X_WriteStatusReg                0x01
    ! f" [' X0 q  z9 p- a  g4 Q
27. #define W25X_ReadData                        0x03
    ' ]: c" l! D* T1 x8 T
28. #define W25X_FastReadData                0x0B
    5 G% r* Q( r* O2 }2 F4 S) A
29. #define W25X_FastReadDual                0x3B
    ( r( t6 U# i) Q- R$ Z
30. #define W25X_PageProgram                0x02
    
31. #define W25X_BlockErase                        0xD8
    " N8 d; b; `3 y$ u
32. #define W25X_SectorErase                0x20
    9 k* j' o3 F; |0 m
33. #define W25X_ChipErase                        0xC7
    
34. #define W25X_PowerDown                        0xB9
    
35. #define W25X_ReleasePowerDown        0xAB
    
36. #define W25X_DeviceID                        0xAB
    
37. #define W25X_ManufactDeviceID        0x90
    6 `3 |' P$ k8 D7 O' E! c
38. #define W25X_JedecDeviceID                0x9F
    
39. 
    / A) k+ C1 A3 H6 b3 v- @
40. void W25QXX_Init(void);
    ) H6 d9 l$ l8 n/ K$ S5 X# W+ K$ u
41. uint16_t  W25QXX_ReadID(void);                              //读取FLASH ID
    
42. void W25QXX_ReadUniqueID(uint8_t UID[8]);       //读取唯一ID
    
43. uint32_t W25QXX_ReadCapacity(void);             //读取容量
    
44. uint8_t         W25QXX_ReadSR(void);                        //读取状态寄存器
    ! ~) R2 E3 _6 o* @% h9 u
45. void W25QXX_Write_SR(uint8_t sr);                          //写状态寄存器
    
46. void W25QXX_Write_Enable(void);                  //写使能
    ) ]2 \- q: Y% w9 t. ~7 \6 N( X
47. void W25QXX_Write_Disable(void);                //写保护
    1 t: J) p6 A" x0 e/ X7 R0 `! _
48. void W25QXX_Write_NoCheck(uint8_t* pBuffer,uint32_t WriteAddr,uint16_t NumByteToWrite);
    1 I0 Q# C9 B$ J8 m! \* O. Q
49. void W25QXX_Read(uint8_t* pBuffer,uint32_t ReadAddr,uint16_t NumByteToRead);   //读取flash
    8 v7 |" r9 ]( t
50. void W25QXX_Write(uint8_t* pBuffer,uint32_t WriteAddr,uint16_t NumByteToWrite);//写入flash
    4 W6 O" r# H- i, N9 a
51. void W25QXX_Erase_Chip(void);                      //整片擦除
    
52. void W25QXX_Erase_Sector(uint32_t Dst_Addr);        //扇区擦除
    1 P% g8 k( _2 L. U: M, z  z
53. void W25QXX_Wait_Busy(void);                   //等待空闲
    
54. void W25QXX_PowerDown(void);                //进入掉电模式
    # o6 ^5 m) R) a: n
55. void W25QXX_WAKEUP(void);                                //唤醒
    $ _& |: ^* E. s' c3 @, J9 T4 E) M8 K0 V
56. 
    
57. #endif
    

复制代码

5 ^. X$ M+ A- h' v% E2.2 源文件
2 i. r1 E# N7 N7 I+ b1 v5 M

1. #include "w25qxx.h"
   
2. 
   
3. 
   
4. uint16_t W25QXX_TYPE = 0;
   
5. uint32_t W25QXX_SIZE = 0;
   % U5 x" |0 ]  s0 D+ E
6. uint8_t  W25QXX_UID[8] = {0};
   
7. 
   ! D: ~4 K% @/ x% C2 n# ^
8. 
   ! W: Y/ h. O: a% S1 j4 ~
9. 
   
10. 
    7 k' t0 D) a& P! m7 o% e
11. ///
    - h5 \+ i& T9 M. G' d" T) l8 l
12. ///            移植修改区
    
13. ///
    3 l  k# @% K' V+ H$ Z# U% P& t
14. ///
    5 V9 _  c' Y/ \
15. 
    
16. #define W25QXX_CS_H()         HAL_GPIO_WritePin(GPIOA, GPIO_PIN_15, GPIO_PIN_SET)
    
17. #define W25QXX_CS_L()         HAL_GPIO_WritePin(GPIOA, GPIO_PIN_15, GPIO_PIN_RESET)
    * M5 t4 _- n+ y( ]
18. 
    0 m6 d& B2 E/ y" N1 q
19. #define W25QXX_SCK_H()        HAL_GPIO_WritePin(GPIOB, GPIO_PIN_3, GPIO_PIN_SET)
    
20. #define W25QXX_SCK_L()        HAL_GPIO_WritePin(GPIOB, GPIO_PIN_3, GPIO_PIN_RESET)
    
21. 
    4 G# j# o1 o0 x' |. H
22. #define W25QXX_MOSI_H()       HAL_GPIO_WritePin(GPIOB, GPIO_PIN_5, GPIO_PIN_SET)
    - U; X& i7 r# E; j. P
23. #define W25QXX_MOSI_L()       HAL_GPIO_WritePin(GPIOB, GPIO_PIN_5, GPIO_PIN_RESET)
    8 |9 i% e  D( `
24. 
    
25. #define W25QXX_MISO_GET()      (HAL_GPIO_ReadPin(GPIOB, GPIO_PIN_4) == GPIO_PIN_SET ? 1 : 0)
    
26. 
    
27. static void delay_us(uint32_t us)
    
28. {
    
29.     uint32_t delay = (HAL_RCC_GetHCLKFreq() / 4000000 * us);
      f' O! @' `/ I
30.     while (delay--)
    
31.     {
    
32.         ;
    
33.     }
    9 t. X0 O# D% P
34. }
    / }4 H( x9 a8 r: U0 x! h
35. 
    
36. static uint8_t W25QXX_SPI_ReadWriteByte(uint8_t TxData)
    
37. {
    5 K" j" I* t3 h% ]3 o
38.     int i = 0;
    9 L8 J0 ?6 l& P; ^
39.     uint8_t RxData = 0;
      @* n" O7 [9 t1 k7 b
40.     W25QXX_SCK_L();
    2 U# u4 F' O9 a3 D
41.     for(i = 7; i >= 0; i--)
    
42.     {
    % T, {3 U6 T2 g3 A
43.         W25QXX_SCK_L();
    
44.         if(TxData & (1 << i))
    
45.         {
    
46.             W25QXX_MOSI_H();
    - j+ [5 y: l0 D3 q& c/ A: O3 _
47.         }
    
48.         else
    : Z4 N# ?, A6 z/ T
49.         {
    
50.             W25QXX_MOSI_L();
    
51.         }
    
52.         delay_us(1);
    
53.         W25QXX_SCK_H();
    
54.         RxData <<= 1;
    3 d. ?& S5 z  L' x
55.         RxData |= W25QXX_MISO_GET();
    " P$ D4 x/ `$ `6 k( u. Y8 R
56.         delay_us(1);
    8 G4 K9 _$ W/ b
57.     }
    
58.     W25QXX_SCK_L();
    
59.     return RxData;
    
60. }
    & G7 h3 L& @# P
61. 
    : r/ @. U3 H4 K/ {
62. static void W25QXX_SPI_Init(void)
    7 N) U' F8 `5 T6 C/ z- `
63. {
      W2 K- Q: V: C: o. [/ N
64.         // 这里添加初始化IO的代码
    ( K9 Z1 \# T4 U5 P8 y
65. }
    
66. 
    
67. 
    % \% p* L+ J0 k2 X. p
68. 
    
69. ///
    % I4 x3 d, g7 f: m3 l
70. ///            驱动代码
    
71. ///
    
72. ///
    1 P) ]  v" M- \, B( z
73. 
    
74. 
    
75. //4Kbytes为一个Sector
    
76. //16个扇区为1个Block
    $ l  ^4 H6 J/ s7 @' p$ R' l
77. //W25Q128
    
78. //容量为16M字节,共有128个Block,4096个Sector
    ' U* L) R$ w9 m  T0 }. |- b
79. 
    " ^% N0 v7 z0 Y9 Q
80. //初始化SPI FLASH的IO口
    & E' y. k: L* V& p% ^
81. void W25QXX_Init(void)
    
82. {
    
83.         W25QXX_SPI_Init();
    
84.         W25QXX_CS_H();                // 取消片选
    
85.         W25QXX_SCK_L();               // 时钟空闲为低电平
    
86.     W25QXX_CS_L();
    
87.     W25QXX_SPI_ReadWriteByte(0XFF);
    
88.     W25QXX_CS_H();
    
89.     W25QXX_TYPE=W25QXX_ReadID();             //读取FLASH ID
    
90.         W25QXX_SIZE=W25QXX_ReadCapacity();       //读取容量
    6 `5 k3 W6 D7 Q! I7 y& ^/ ?1 ?
91.         W25QXX_ReadUniqueID(W25QXX_UID);         //读取唯一ID
    
92. }
    
93. 
    : B, E( A+ V( \2 v: c
94. uint32_t W25QXX_ReadCapacity(void)
    + E) j) y/ D+ f: @+ d4 {( j
95. {
    ' @8 P$ i& i4 K
96.         int i = 0;
    
97.         uint8_t arr[4] = {0,0,0,0};
    
98.     W25QXX_CS_L();
    ' w/ v, B% d5 i9 u, F2 D
99.     W25QXX_SPI_ReadWriteByte(0x5A);
    
100.     W25QXX_SPI_ReadWriteByte(0x00);
     
101.     W25QXX_SPI_ReadWriteByte(0x00);
     ' [7 _. t1 S7 I4 b+ M
102.     W25QXX_SPI_ReadWriteByte(0x84);
     ) c2 c4 x7 r" }+ P. z% |+ O8 s
103.         W25QXX_SPI_ReadWriteByte(0x00);
     1 G9 A3 {1 H" w. ^) r
104.         for(i = 0; i < sizeof(arr); i++)
     
105.         {
     " ?2 d1 w( s) X6 k% v. b0 o
106.                 arr<i> = W25QXX_SPI_ReadWriteByte(0xFF);
     8 {% a4 ?( |0 v
107.         }
     
108.     W25QXX_CS_H();
     ; \, |0 D0 G& ]1 Z9 g* `% R
109.     return ((((*(uint32_t *)arr)) + 1) >> 3);
     : |) p/ l+ I5 n: S# v
110. }
     
111. 
     
112. void W25QXX_ReadUniqueID(uint8_t UID[8])
     
113. {
     ) T, V3 |7 t! @" {6 f1 m: h9 F
114.         int i = 0;
     9 i' @: j: b+ K5 _6 T' |. L* N. v
115.         W25QXX_CS_L();
     , a2 `4 U& _4 D8 t0 s
116.     W25QXX_SPI_ReadWriteByte(0x4B);
     
117.     W25QXX_SPI_ReadWriteByte(0x00);
     0 S' X6 {) b6 {
118.     W25QXX_SPI_ReadWriteByte(0x00);
     
119.     W25QXX_SPI_ReadWriteByte(0x00);
     & j' [0 R6 z# k2 Q3 a7 H3 _
120.         W25QXX_SPI_ReadWriteByte(0x00);
     4 C0 k, }1 ?  {; v3 W7 G7 i! q- C
121.     for(i = 0; i < 8; i++)
     
122.         {
       y2 E% Z% z1 A: w1 v) `7 F
123.                 UID<i> = W25QXX_SPI_ReadWriteByte(0xFF);
     / f  s0 {1 P8 n" u, h
124.         }
     
125.         W25QXX_CS_H();
     
126. }
     
127. 
     5 B$ P7 V# Q. B: g
128. //读取W25QXX的状态寄存器
     
129. //BIT7  6   5   4   3   2   1   0
     
130. //SPR   RV  TB BP2 BP1 BP0 WEL BUSY
     $ M2 ?* j. |9 v" i% s- ^- b$ l
131. //SPR:默认0,状态寄存器保护位,配合WP使用
     
132. //TB,BP2,BP1,BP0:FLASH区域写保护设置
     
133. //WEL:写使能锁定
     ( ?+ H. A9 @' d7 a* ?, K0 J
134. //BUSY:忙标记位(1,忙;0,空闲)
     
135. //默认:0x00
     % Y) g( Q" |6 i6 h; G
136. uint8_t W25QXX_ReadSR(void)
     
137. {
     ! M4 h0 i6 U! r) d# S- @
138.     uint8_t byte=0;
     
139.     W25QXX_CS_L();                            //使能器件
     3 u4 a! c  t  F$ v( ]6 T( J2 [
140.     W25QXX_SPI_ReadWriteByte(W25X_ReadStatusReg); //发送读取状态寄存器命令
     + x4 j" L9 C- H. T3 p; p/ T! g) K
141.     byte=W25QXX_SPI_ReadWriteByte(0Xff);          //读取一个字节
     
142.     W25QXX_CS_H();                            //取消片选
     
143.     return byte;
     
144. }
     
145. //写W25QXX状态寄存器
     % L/ F' z) j6 P9 u6 p
146. //只有SPR,TB,BP2,BP1,BP0(bit 7,5,4,3,2)可以写!!!
     
147. void W25QXX_Write_SR(uint8_t sr)
     
148. {
     
149.     W25QXX_CS_L();                            //使能器件
     
150.     W25QXX_SPI_ReadWriteByte(W25X_WriteStatusReg);//发送写取状态寄存器命令
     ( f  L, q' f2 H2 x
151.     W25QXX_SPI_ReadWriteByte(sr);                       //写入一个字节
     7 W$ O; L9 G1 ?8 U5 Q
152.     W25QXX_CS_H();                            //取消片选
     
153. }
     
154. //W25QXX写使能
     
155. //将WEL置位
     
156. void W25QXX_Write_Enable(void)
     
157. {
     
158.     W25QXX_CS_L();                                  //使能器件
     " H9 i/ b' N4 n' m2 q9 X& [" z
159.     W25QXX_SPI_ReadWriteByte(W25X_WriteEnable);         //发送写使能
     - @. u  _- s6 |+ T" X! a2 A
160.     W25QXX_CS_H();                                   //取消片选
     ( H8 g/ I& b% e0 c7 Z
161. }
     
162. //W25QXX写禁止
     
163. //将WEL清零
     
164. void W25QXX_Write_Disable(void)
     7 U6 t0 b9 r2 ?! v% D/ D1 N" B
165. {
     
166.     W25QXX_CS_L();                            //使能器件
     ' @4 m; e3 B% u6 t$ o) d
167.     W25QXX_SPI_ReadWriteByte(W25X_WriteDisable);  //发送写禁止指令
     
168.     W25QXX_CS_H();                            //取消片选
     
169. }
     
170. //读取芯片ID
     ) B! C0 c- D* B, h& b9 F
171. //返回值如下:
     ; ~0 H" S) o1 q! x8 V, F" P
172. //0XEF13,表示芯片型号为W25Q80
     * S. q: Q, y" M! W2 F5 E$ X- _+ a
173. //0XEF14,表示芯片型号为W25Q16
     
174. //0XEF15,表示芯片型号为W25Q32
     
175. //0XEF16,表示芯片型号为W25Q64
     : q& p6 }) e" y% e4 G, N
176. //0XEF17,表示芯片型号为W25Q128
     
177. uint16_t W25QXX_ReadID(void)
     , G( ~: d2 {/ |/ X
178. {
     8 B, t; f( V8 d/ j# s4 H7 a6 w
179.     uint16_t Temp = 0;
     ! g# w9 }+ y. }' P
180.     W25QXX_CS_L();
     
181.     W25QXX_SPI_ReadWriteByte(0x90);//发送读取ID命令
     8 j% q/ s% k, A
182.     W25QXX_SPI_ReadWriteByte(0x00);
     
183.     W25QXX_SPI_ReadWriteByte(0x00);
     ( T1 b9 h% p5 j6 X/ E& B
184.     W25QXX_SPI_ReadWriteByte(0x00);
     
185.     Temp|=W25QXX_SPI_ReadWriteByte(0xFF)<<8;
     
186.     Temp|=W25QXX_SPI_ReadWriteByte(0xFF);
     
187.     W25QXX_CS_H();
     
188.     return Temp;
     
189. }
     
190. //读取SPI FLASH
     
191. //在指定地址开始读取指定长度的数据
     5 D; [' S7 w" k
192. //pBuffer:数据存储区
       z9 r# O! g1 z8 i1 p5 ?; }1 L
193. //ReadAddr:开始读取的地址(24bit)
     
194. //NumByteToRead:要读取的字节数(最大65535)
     0 o9 f5 H, |  m9 S. L) u
195. void W25QXX_Read(uint8_t* pBuffer,uint32_t ReadAddr,uint16_t NumByteToRead)
     
196. {
     
197.     uint16_t i;
     
198.     W25QXX_CS_L();                                    //使能器件
     & w' Q" i+ z  g" d; b$ t
199.     W25QXX_SPI_ReadWriteByte(W25X_ReadData);                 //发送读取命令
     
200.     W25QXX_SPI_ReadWriteByte((uint8_t)((ReadAddr)>>16));          //发送24bit地址
     9 U  j) t3 I7 H  X; j. y
201.     W25QXX_SPI_ReadWriteByte((uint8_t)((ReadAddr)>>8));
     
202.     W25QXX_SPI_ReadWriteByte((uint8_t)ReadAddr);
     # u8 M' t  v/ B6 }- X+ ^
203.     for(i=0; i<NumByteToRead; i++)
     2 z- `. ^8 m% ^( p, m' y6 w6 I9 i" |
204.     {
     + _% u' ^( x( K
205.         pBuffer<i>=W25QXX_SPI_ReadWriteByte(0XFF);           //循环读数
     ! k* b$ K  U' j, }1 z
206.     }
     
207.     W25QXX_CS_H();
     
208. }
     ) v: A- x6 M- h7 G' `) d
209. //SPI在一页(0~65535)内写入少于256个字节的数据
     
210. //在指定地址开始写入最大256字节的数据
     ! g' V8 c* h4 `" J9 `
211. //pBuffer:数据存储区
     
212. //WriteAddr:开始写入的地址(24bit)
     
213. //NumByteToWrite:要写入的字节数(最大256),该数不应该超过该页的剩余字节数!!!
     
214. void W25QXX_Write_Page(uint8_t* pBuffer,uint32_t WriteAddr,uint16_t NumByteToWrite)
     
215. {
     
216.     uint16_t i;
     
217.     W25QXX_Write_Enable();                          //SET WEL
     
218.     W25QXX_CS_L();                                    //使能器件
     6 f& f- a0 {/ J5 o4 y. q1 g
219.     W25QXX_SPI_ReadWriteByte(W25X_PageProgram);              //发送写页命令
     
220.     W25QXX_SPI_ReadWriteByte((uint8_t)((WriteAddr)>>16));         //发送24bit地址
     
221.     W25QXX_SPI_ReadWriteByte((uint8_t)((WriteAddr)>>8));
     
222.     W25QXX_SPI_ReadWriteByte((uint8_t)WriteAddr);
     
223.     for(i=0; i<NumByteToWrite; i++)W25QXX_SPI_ReadWriteByte(pBuffer<i>); //循环写数
     
224.     W25QXX_CS_H();                                    //取消片选
     ! ]" p: ]. k- v5 q# J# @- z5 u
225.     W25QXX_Wait_Busy();                                                           //等待写入结束
     
226. }
     
227. //无检验写SPI FLASH
       |+ r$ v' b4 T; p  G
228. //必须确保所写的地址范围内的数据全部为0XFF,否则在非0XFF处写入的数据将失败!
     
229. //具有自动换页功能
     . R+ W( y( B* S: a) M
230. //在指定地址开始写入指定长度的数据,但是要确保地址不越界!
     
231. //pBuffer:数据存储区
     0 N0 R5 g. ^9 e7 p+ A
232. //WriteAddr:开始写入的地址(24bit)
     8 H3 x# l2 Q, j+ a* N3 ?
233. //NumByteToWrite:要写入的字节数(最大65535)
     
234. //CHECK OK
     0 o2 C5 R2 p/ b+ y" z- v
235. void W25QXX_Write_NoCheck(uint8_t* pBuffer,uint32_t WriteAddr,uint16_t NumByteToWrite)
     2 e* I+ t; u2 u% T  G
236. {
     6 j9 \' A9 |. }0 g$ E9 r( E
237.     uint16_t pageremain;
     
238.     pageremain=256-WriteAddr%256; //单页剩余的字节数
     * i. N; `. h6 R: M- a3 _* c+ v! M, S
239.     if(NumByteToWrite<=pageremain)pageremain=NumByteToWrite;//不大于256个字节
     
240.     while(1)
     
241.     {
     
242.         W25QXX_Write_Page(pBuffer,WriteAddr,pageremain);
     
243.         if(NumByteToWrite==pageremain)break;//写入结束了
     & W/ T- |7 y: J1 R& ?7 }
244.         else //NumByteToWrite>pageremain
     9 }5 O+ w' h" ?; R5 ]$ K. z
245.         {
     , Z! Z  Q. b8 d' T3 E
246.             pBuffer+=pageremain;
     ; r, o7 `, _. ?0 t
247.             WriteAddr+=pageremain;
     
248. 
     
249.             NumByteToWrite-=pageremain;                          //减去已经写入了的字节数
     
250.             if(NumByteToWrite>256)pageremain=256; //一次可以写入256个字节
     
251.             else pageremain=NumByteToWrite;           //不够256个字节了
     3 X: Y  ]8 P- w% K
252.         }
     
253.     };
     
254. }
     
255. //写SPI FLASH
     5 o/ Y4 O, d- r2 d
256. //在指定地址开始写入指定长度的数据
     3 A5 w0 _7 |" y5 i* V( E
257. //该函数带擦除操作!
     
258. //pBuffer:数据存储区
     / ?' y; a1 j# \* X" r  M  }
259. //WriteAddr:开始写入的地址(24bit)
     ) D6 ]2 @. n! S# I
260. //NumByteToWrite:要写入的字节数(最大65535)
     
261. uint8_t W25QXX_BUFFER[4096];
     
262. void W25QXX_Write(uint8_t* pBuffer,uint32_t WriteAddr,uint16_t NumByteToWrite)
     & I4 |9 X" A! O0 I
263. {
     
264.     uint32_t secpos;
     ; E. Z% d, K2 p, b6 A3 ~
265.     uint16_t secoff;
     
266.     uint16_t secremain;
     3 u6 `( {9 |, D
267.     uint16_t i;
     
268.     uint8_t * W25QXX_BUF;
     3 p! [, h( ?5 V8 @4 x
269.     W25QXX_BUF=W25QXX_BUFFER;
     # }' R- ?/ \8 p1 R- f6 V
270.     secpos=WriteAddr/4096;//扇区地址
     
271.     secoff=WriteAddr%4096;//在扇区内的偏移
     
272.     secremain=4096-secoff;//扇区剩余空间大小
     
273.     if(NumByteToWrite<=secremain)secremain=NumByteToWrite;//不大于4096个字节
     
274.     while(1)
     * i9 b7 J! a! n( [! }- w4 |
275.     {
     
276.         W25QXX_Read(W25QXX_BUF,secpos*4096,4096);//读出整个扇区的内容
     
277.         for(i=0; i<secremain; i++) //校验数据
     
278.         {
     - F5 w5 ^! w  ]4 W7 h3 z
279.             if(W25QXX_BUF[secoff+i]!=0XFF)break;//需要擦除
     
280.         }
     ' F- a9 R6 p( ?
281.         if(i<secremain)//需要擦除
     ! a% l1 ^: M+ s0 I% o2 m5 z: F) g1 t
282.         {
     
283.             W25QXX_Erase_Sector(secpos);                //擦除这个扇区
       O% e  y+ _+ Q0 p5 T. X2 n0 P
284.             for(i=0; i<secremain; i++)                           //复制
     
285.             {
     
286.                 W25QXX_BUF[i+secoff]=pBuffer<i>;
     
287.             }
     
288.             W25QXX_Write_NoCheck(W25QXX_BUF,secpos*4096,4096);//写入整个扇区
     ) @. T% M/ G5 \9 W6 i* Y. j
289. 
     - B. {1 ^, y5 ?, K4 Q
290.         }
     
291.         else W25QXX_Write_NoCheck(pBuffer,WriteAddr,secremain); //写已经擦除了的,直接写入扇区剩余区间.
     
292.         if(NumByteToWrite==secremain)break;//写入结束了
     9 N- ^+ @4 G* |2 u
293.         else//写入未结束
     ; s9 [7 A% k3 r& F8 [0 g
294.         {
     7 b- n4 Y4 h! ~2 M
295.             secpos++;//扇区地址增1
     & n0 o3 t: c- Q. I4 l
296.             secoff=0;//偏移位置为0
     
297. 
     8 O5 h/ D  }! c3 r! |1 L
298.             pBuffer+=secremain;                                  //指针偏移
     ; M1 g6 C3 `3 z* l0 A
299.             WriteAddr+=secremain;                                //写地址偏移
     ) G% @' T9 S! M! u9 K, `8 E
300.             NumByteToWrite-=secremain;                        //字节数递减
     4 ]4 _# x, P  _; P# r# y# h
301.             if(NumByteToWrite>4096)secremain=4096;//下一个扇区还是写不完
     
302.             else secremain=NumByteToWrite;                //下一个扇区可以写完了
     8 p4 @/ G. S' @& H  H! }  N" O
303.         }
     4 V: Y2 a, O$ f' _7 \$ }
304.     };
     
305. }
     ! c5 i1 U7 H" O! x& \$ [0 l+ k4 V' t
306. //擦除整个芯片
     
307. //等待时间超长...
     5 r9 j; Q. K7 Q8 g, z  F7 h
308. void W25QXX_Erase_Chip(void)
     
309. {
     
310.     W25QXX_Write_Enable();                                  //SET WEL
     * X8 d* z, v/ v
311.     W25QXX_Wait_Busy();
     
312.     W25QXX_CS_L();                                    //使能器件
     
313.     W25QXX_SPI_ReadWriteByte(W25X_ChipErase);                //发送片擦除命令
     
314.     W25QXX_CS_H();                                    //取消片选
     
315.     W25QXX_Wait_Busy();                                                      //等待芯片擦除结束
     
316. }
     
317. //擦除一个扇区
     , s/ X8 {1 S' ?5 u9 q0 ?) h% B
318. //Dst_Addr:扇区地址 根据实际容量设置
     0 I7 J% U+ i' [: J& C0 e
319. //擦除一个山区的最少时间:150ms
     ) B' U6 d" M7 M/ j& a( a* ~$ i
320. void W25QXX_Erase_Sector(uint32_t Dst_Addr)
     
321. {
     & n1 K7 N' e% s( ]
322.     //监视falsh擦除情况,测试用
     7 I( }' M( ]9 B! C2 d0 n% r/ e
323.     Dst_Addr*=4096;
     0 i; L# O* X# l$ x) N
324.     W25QXX_Write_Enable();                          //SET WEL
     $ t2 Z6 @7 V/ @
325.     W25QXX_Wait_Busy();
     
326.     W25QXX_CS_L();                                    //使能器件
     
327.     W25QXX_SPI_ReadWriteByte(W25X_SectorErase);              //发送扇区擦除指令
     , e: c( m  v2 e% l; ?9 P1 W
328.     W25QXX_SPI_ReadWriteByte((uint8_t)((Dst_Addr)>>16));          //发送24bit地址
     
329.     W25QXX_SPI_ReadWriteByte((uint8_t)((Dst_Addr)>>8));
     . V: A/ I* ]. Z- ^4 j
330.     W25QXX_SPI_ReadWriteByte((uint8_t)Dst_Addr);
     
331.     W25QXX_CS_H();                                    //取消片选
     + K  k9 U7 E  ~3 x9 O! @
332.     W25QXX_Wait_Busy();                                                      //等待擦除完成
     
333. }
     # w& E' L, g' q3 [6 F2 \9 n
334. //等待空闲
     ' |# V4 y, `3 [7 m* J: I* m
335. void W25QXX_Wait_Busy(void)
     5 A4 }% Z6 L7 |; n
336. {
     
337.     while((W25QXX_ReadSR()&0x01)==0x01);                  // 等待BUSY位清空
     
338. }
     
339. //进入掉电模式
     
340. void W25QXX_PowerDown(void)
     $ E& E% ?* f2 t, ?* ^' y
341. {
     3 n6 D5 a0 Q( h* b+ ^  F
342.     W25QXX_CS_L();                                            //使能器件
     
343.     W25QXX_SPI_ReadWriteByte(W25X_PowerDown);        //发送掉电命令
     
344.     W25QXX_CS_H();                                    //取消片选
     
345.     delay_us(3);                               //等待TPD
     $ g, C0 q7 Y  Z+ S6 s; R, U
346. }
     0 [& C+ V6 U2 z. z
347. //唤醒
     - @( d; ~6 j/ h8 k6 L
348. void W25QXX_WAKEUP(void)
     2 K4 x% R7 E4 I3 V: w
349. {
     $ t. j: l& }! l: B4 z# y# G
350.     W25QXX_CS_L();                                    //使能器件
     
351.     W25QXX_SPI_ReadWriteByte(W25X_ReleasePowerDown);        //  send W25X_PowerDown command 0xAB
     % _9 ~; _6 Q- E, C; B
352.     W25QXX_CS_H();                                    //取消片选
     : r: `4 m0 y" @! X& c
353.     delay_us(3);                                    //等待TRES1
     
354. }
     0 v% e1 F- o, c) I2 U: V! H
355. 
     + m0 q4 z0 a6 c
356. </i></i></i></i></i>

复制代码