在头文件中简单修改一下片选引脚IO即可使用。
+ d5 ~1 X; Q* A* E. i
源文件

) P) W5 V2 C& C) f1 v6 M

1. /**
   
2. * @file  w25qxx.c
   ; T9 r  _2 U- I( m1 O: c1 o; b
3. *
   + i5 @% U2 V- Z+ B6 b
4. * @brief Create by AnKun on 2020/6/18
   4 G! D; F2 k/ m. N! j
5. *
   9 A( }1 z" P% k2 I8 k
6. */
   
7. 
   
8. #include "w25qxx.h"
   
9. #include "spi.h"
   4 ~' H7 k  ?7 @
10. 
    
11. uint16_t W25QXX_TYPE = 0;
    
12. uint32_t W25QXX_SIZE = 0;
    
13. uint8_t  W25QXX_UID[8];
    
14. 
    
15. static void delay_us(uint32_t us)
    
16. {
    7 P5 s; \4 _) W1 k' f- N5 W
17.     uint32_t delay = (HAL_RCC_GetHCLKFreq() / 4000000 * us);
    " b) i8 `: C6 C" O7 d0 |
18.     while (delay--)
    , ~5 t! p+ j% V7 \5 p$ [
19.     {
    3 [- p% e. p, K1 g6 x# A& ]; c
20.         ;
    0 w" O6 ]# h# b- r2 o+ J
21.     }
    
22. }
    
23. 
    1 L, F! D/ V" F2 d' |% d5 w: @6 n
24. //SPI读写一个字节
    
25. //TxData:要写入的字节
    0 N3 D+ b2 k4 m4 b
26. //返回值:读取到的字节
    
27. static uint8_t W25QXX_SPI_ReadWriteByte(uint8_t TxData)
    
28. {
    
29.         uint8_t RxData = 0X00;
    
30.         if(HAL_SPI_TransmitReceive(W25QXX_SPI_Handle, &TxData, &RxData, 1, 10) != HAL_OK)
    ' ^6 g5 X4 d2 b* f  j4 t5 g
31.         {
    / I) X3 u0 Z& P! O) v2 S+ {1 n
32.                 RxData = 0XFF;
    
33.         }
    
34.         return RxData;
    8 y5 S4 M; `6 c' i
35. }
    
36. 
    + ^  }6 K1 S1 h! ?& B  P" H! t
37. //4Kbytes为一个Sector
    
38. //16个扇区为1个Block
    - t6 ?+ a0 t. _0 a' V( T5 G
39. //W25Q128
    ; r: f! T: B; `. I; ?
40. //容量为16M字节,共有128个Block,4096个Sector
    
41. 
    , d6 a8 ~9 M: r) q
42. //初始化SPI FLASH的IO口
    6 v) n9 E# J( |* O
43. int W25QXX_Init(void)
    2 R0 S! k# p- H+ c& N) a
44. {
    ; d6 @3 ]6 q/ a: v' o. c
45.         MX_SPI1_Init();
    - |9 j4 I' E. Z! n! s3 r4 h1 u
46.     W25QXX_CS_L(); /* 拉低选中 */
    
47.     W25QXX_SPI_ReadWriteByte(0XFF);
    
48.     W25QXX_CS_H(); /* 拉高取消 */
    
49.     W25QXX_TYPE = W25QXX_ReadID();          // 读取FLASH ID.
    / c5 n0 s7 c) e  G/ ?( v
50.         W25QXX_SIZE = W25QXX_ReadCapacity();    // 读取容量
    
51.         W25QXX_ReadUniqueID(W25QXX_UID);        // 读取唯一ID
    ) K+ ?5 J( C5 o+ ^5 L6 Z4 z+ M
52.         if((W25QXX_TYPE & 0XEF00) != 0XEF00)
    5 ?/ s5 b$ L' t6 G1 W) {: j
53.         {
    ) z5 s9 g7 v" a# u+ Q
54.                 return -1;
    4 K/ C% h6 G: [. d0 {
55.         }
    
56.         return 0;
    
57. }
    7 F( I% O. X1 u; H; X  B, S
58. 
    ' i# G: s; w+ h( J( g$ G9 r+ ?  R
59. //读取W25QXX的状态寄存器
    
60. //BIT7  6   5   4   3   2   1   0
    1 R9 H8 U4 n" C6 W
61. //SPR   RV  TB BP2 BP1 BP0 WEL BUSY
    % i" o5 \) W5 t; z% e
62. //SPR:默认0,状态寄存器保护位,配合WP使用
    
63. //TB,BP2,BP1,BP0:FLASH区域写保护设置
    
64. //WEL:写使能锁定
    
65. //BUSY:忙标记位(1,忙;0,空闲)
    
66. //默认:0x00
    - X, C. m$ Q+ g- U7 Y+ D4 t; o% \9 |
67. uint8_t W25QXX_ReadSR(void)
    
68. {
    1 g# m2 p2 `& a9 k( Z
69.     uint8_t byte = 0;
    
70.     W25QXX_CS_L(); //使能器件
    
71.     W25QXX_SPI_ReadWriteByte(W25X_ReadStatusReg); //发送读取状态寄存器命令
    5 f( H9 i) B. u. F# X
72.     byte = W25QXX_SPI_ReadWriteByte(0Xff);          //读取一个字节
    & I5 v" U7 C3 C) f3 {7 u# k$ ]
73.     W25QXX_CS_H();  //取消片选
    
74.     return byte;
    1 Z0 v1 k# |+ u% N
75. }
    
76. //写W25QXX状态寄存器
    
77. //只有SPR,TB,BP2,BP1,BP0(bit 7,5,4,3,2)可以写!!!
    
78. void W25QXX_Write_SR(uint8_t sr)
    9 d0 p, r5 A4 ^& }- C
79. {
    . {8 q7 Z7 l2 l+ d& L6 T
80.     W25QXX_CS_L(); //使能器件
    " Y6 f/ l8 c# a9 j5 U; p* l
81.     W25QXX_SPI_ReadWriteByte(W25X_WriteStatusReg);                 //发送写取状态寄存器命令
    
82.     W25QXX_SPI_ReadWriteByte(sr);                       //写入一个字节
    
83.     W25QXX_CS_H();  //取消片选
    6 t% q( ~% Z5 V/ A/ q
84. }
    
85. //W25QXX写使能
    ( M$ `: q7 r: k1 j* t8 F. U6 U
86. //将WEL置位
    / F& X7 W) D* T1 Y% B
87. void W25QXX_Write_Enable(void)
    
88. {
    5 [; E/ g( F! ~. P4 Z
89.     W25QXX_CS_L(); //使能器件
    $ P" G9 G  k! m# n% `, a0 [) `  z9 E
90.     W25QXX_SPI_ReadWriteByte(W25X_WriteEnable);         //发送写使能
    ) R4 G* {  u9 D- q+ E; b
91.     W25QXX_CS_H();  //取消片选
    9 {4 m$ r$ x4 g2 m+ `
92. }
    
93. //W25QXX写禁止
    / B4 O6 a% R4 i$ w7 O' I3 b8 u
94. //将WEL清零
    6 ~# m, ], E. Y* ]3 \& O' w
95. void W25QXX_Write_Disable(void)
    % `7 Z( i8 Q9 p
96. {
    ; C- [2 c( F+ g4 y) Q
97.     W25QXX_CS_L(); //使能器件
    0 Y- b. w9 p/ m, [% I
98.     W25QXX_SPI_ReadWriteByte(W25X_WriteDisable);  //发送写禁止指令
    ( Z- p8 u$ f* \; U
99.     W25QXX_CS_H();  //取消片选
    
100. }
     
101. //读取芯片ID
     / Y7 Q6 ^5 W1 |* w- N
102. //返回值如下:
     
103. //0XEF13,表示芯片型号为W25Q80
     
104. //0XEF14,表示芯片型号为W25Q16
     0 l% P7 z0 {0 V/ J% E: f
105. //0XEF15,表示芯片型号为W25Q32
     
106. //0XEF16,表示芯片型号为W25Q64
     
107. //0XEF17,表示芯片型号为W25Q128
       c; v' @0 a! ?/ H3 K" U, @$ V
108. uint16_t W25QXX_ReadID(void)
       I; p* q7 P3 e) V8 u" z
109. {
     
110.     uint16_t Temp = 0;
     , ]/ A/ n6 Q# c  n2 a5 Z8 j+ Q
111.     W25QXX_CS_L();
     ' b' u6 f3 z4 u) \# g
112.     W25QXX_SPI_ReadWriteByte(0x90);                            //发送读取ID命令
     ! o+ H* K/ H7 J/ k! v1 x" J6 Q
113.     W25QXX_SPI_ReadWriteByte(0x00);
     * z5 Q6 P, B+ y8 E% Y
114.     W25QXX_SPI_ReadWriteByte(0x00);
     
115.     W25QXX_SPI_ReadWriteByte(0x00);
     ; {5 s% u% Z0 b' o5 q" \
116.     Temp |= W25QXX_SPI_ReadWriteByte(0xFF) << 8;
     
117.     Temp |= W25QXX_SPI_ReadWriteByte(0xFF);
     ! ~" x7 e4 w/ U: t% @1 T9 V
118.     W25QXX_CS_H();
     3 o/ S& v# L" W; K
119.     return Temp;
     
120. }
     " m' i% _* ?3 c/ R2 e# ]" h/ ]
121. 
     # I" W) d4 E! _- `8 y
122. uint32_t W25QXX_ReadCapacity(void)
     
123. {
     ' [9 c& t) o0 q4 V
124.         int i = 0;
     / S6 p& W% J  F/ i. P$ g% C
125.         uint8_t arr[4] = {0,0,0,0};
     
126.     W25QXX_CS_L();
     
127.     W25QXX_SPI_ReadWriteByte(0x5A);
     2 l% |0 ~- C. ?
128.     W25QXX_SPI_ReadWriteByte(0x00);
     
129.     W25QXX_SPI_ReadWriteByte(0x00);
     - z# N3 ?$ E, o6 L8 g
130.     W25QXX_SPI_ReadWriteByte(0x84);
     
131.         W25QXX_SPI_ReadWriteByte(0x00);
     : f8 D: W; q3 Q( C0 C2 V
132.         for(i = 0; i < sizeof(arr); i++)
     
133.         {
     
134.                 arr<i> = W25QXX_SPI_ReadWriteByte(0xFF);
     % x2 ~; @! _. I& T# e
135.         }
       G, J& {: V  t+ l
136.     W25QXX_CS_H();
     
137.     return ((((*(uint32_t *)arr)) + 1) >> 3);
     
138. }
     : {* }2 M$ z% E$ f/ F$ }" i+ G( x
139. 
     
140. void W25QXX_ReadUniqueID(uint8_t UID[8])
     
141. {
     , y: D" ?4 u" t, Y  q6 [* y$ H
142.         int i = 0;
     8 d. h. E6 j+ I4 W6 T6 J' l
143.         W25QXX_CS_L();
     . D. i8 L! t$ J, l9 |+ G3 P& }
144.     W25QXX_SPI_ReadWriteByte(0x4B);
     
145.     W25QXX_SPI_ReadWriteByte(0x00);
     ) h: p, W% v# O9 y& Q0 \& B) h
146.     W25QXX_SPI_ReadWriteByte(0x00);
     
147.     W25QXX_SPI_ReadWriteByte(0x00);
     
148.         W25QXX_SPI_ReadWriteByte(0x00);
     ' \6 N4 M3 F4 O
149.     for(i = 0; i < 8; i++)
     
150.         {
     % i1 k8 T9 @! d+ S
151.                 UID<i> = W25QXX_SPI_ReadWriteByte(0xFF);
     9 B4 H/ `# v- a$ v, r
152.         }
     
153.         W25QXX_CS_H();
     3 U3 l5 b# W: C$ ?% Y
154. }
     
155. 
     7 P! Z' f0 S  v* Y
156. //读取SPI FLASH
     
157. //在指定地址开始读取指定长度的数据
     & ~( \; m) i& b
158. //pBuffer:数据存储区
     
159. //ReadAddr:开始读取的地址(24bit)
     ( D; l3 M( g8 u7 @' o" ~! ]
160. //NumByteToRead:要读取的字节数(最大65535)
     6 ~4 e& N* I+ b6 Y$ Z
161. void W25QXX_Read(uint8_t *pBuffer, uint32_t ReadAddr, uint16_t NumByteToRead)
     / \) h1 U7 O1 t7 g9 Q$ O/ ], [/ u
162. {
     
163.     uint16_t i;
     
164.     W25QXX_CS_L(); //使能器件
     
165.     W25QXX_SPI_ReadWriteByte(W25X_ReadData);                 //发送读取命令
     * w! i! K8 k5 T8 x5 s$ \
166.     W25QXX_SPI_ReadWriteByte((uint8_t)((ReadAddr) >> 16));          //发送24bit地址
     , p/ d: D5 }! G1 W2 ?" ^' n
167.     W25QXX_SPI_ReadWriteByte((uint8_t)((ReadAddr) >> 8));
     
168.     W25QXX_SPI_ReadWriteByte((uint8_t)ReadAddr);
     
169.     for (i = 0; i < NumByteToRead; i++)
     % y* l5 H; V5 w' T
170.     {
     # S0 N+ `) }  W# f
171.         pBuffer<i> = W25QXX_SPI_ReadWriteByte(0XFF);           //循环读数
     
172.     }
     
173.     W25QXX_CS_H();
     
174. }
     4 [; c! X' ^1 a8 a' {4 n
175. //SPI在一页(0~65535)内写入少于256个字节的数据
     
176. //在指定地址开始写入最大256字节的数据
     
177. //pBuffer:数据存储区
     5 R. g' d0 U1 ~7 k! f( B& d, \# Q
178. //WriteAddr:开始写入的地址(24bit)
       t3 h: f+ V3 b0 c* Z) i
179. //NumByteToWrite:要写入的字节数(最大256),该数不应该超过该页的剩余字节数!!!
     1 A$ l5 }$ M! G5 V" T
180. void W25QXX_Write_Page(uint8_t *pBuffer, uint32_t WriteAddr, uint16_t NumByteToWrite)
     
181. {
     9 r( P- r" ~1 s
182.     uint16_t i;
     
183.     W25QXX_Write_Enable();                          //SET WEL
     " j0 I$ z( G2 v. C
184.     W25QXX_CS_L(); //使能器件
     " f% J% I  C' _$ n$ ]) b  C+ H
185.     W25QXX_SPI_ReadWriteByte(W25X_PageProgram);              //发送写页命令
     
186.     W25QXX_SPI_ReadWriteByte((uint8_t)((WriteAddr) >> 16));         //发送24bit地址
     
187.     W25QXX_SPI_ReadWriteByte((uint8_t)((WriteAddr) >> 8));
     ! a) u5 U( x; s. q& H
188.     W25QXX_SPI_ReadWriteByte((uint8_t)WriteAddr);
     $ _  t1 c. y' K; e3 R. ^
189.     for (i = 0; i < NumByteToWrite; i++)
     
190.         W25QXX_SPI_ReadWriteByte(pBuffer<i>); //循环写数
     7 t1 h' I8 K% _# S1 [9 s' j
191.     W25QXX_CS_H();  //取消片选
     4 B) g! d" H6 G: Y; y% u) U
192.     W25QXX_Wait_Busy();                                                           //等待写入结束
     
193. }
     0 I1 O7 T4 j6 s2 _; t8 X( w; K7 a
194. //无检验写SPI FLASH
     + B* q7 F9 K0 p4 A3 o- f
195. //必须确保所写的地址范围内的数据全部为0XFF,否则在非0XFF处写入的数据将失败!
     
196. //具有自动换页功能
     : d% k5 I* p' d0 p9 @
197. //在指定地址开始写入指定长度的数据,但是要确保地址不越界!
     ! L! C0 X$ I# u2 n$ b4 k
198. //pBuffer:数据存储区
     ; e. H: @& [4 S0 V
199. //WriteAddr:开始写入的地址(24bit)
     + d5 b1 ^" `) e; U3 i3 R: a# W
200. //NumByteToWrite:要写入的字节数(最大65535)
     
201. //CHECK OK
     
202. void W25QXX_Write_NoCheck(uint8_t *pBuffer, uint32_t WriteAddr, uint16_t NumByteToWrite)
     # i7 x: }+ C/ z: e9 O% x& G
203. {
     ) g6 Y2 }8 E* ~; ~
204.     uint16_t pageremain;
     
205.     pageremain = 256 - WriteAddr % 256; //单页剩余的字节数
     ( g! j+ H7 V! c9 n
206.     if (NumByteToWrite <= pageremain)
     
207.         pageremain = NumByteToWrite; //不大于256个字节
     
208.     while (1)
     # t" B3 B+ N5 K) ^$ `7 }7 C
209.     {
     $ H3 c( T* W7 E9 a
210.         W25QXX_Write_Page(pBuffer, WriteAddr, pageremain);
     
211.         if (NumByteToWrite == pageremain)
     
212.             break; //写入结束了
     0 W% L, l6 O; S1 H' q: c& F
213.         else //NumByteToWrite>pageremain
     . d# K/ U+ [; J& j+ `1 j3 q8 G
214.         {
     
215.             pBuffer += pageremain;
     
216.             WriteAddr += pageremain;
     ' w1 x0 x- L9 |  a6 I
217. 
     
218.             NumByteToWrite -= pageremain;                          //减去已经写入了的字节数
     2 P6 R+ X1 ~2 {/ U
219.             if (NumByteToWrite > 256)
     
220.                 pageremain = 256; //一次可以写入256个字节
     
221.             else
     
222.                 pageremain = NumByteToWrite;           //不够256个字节了
     3 w& y8 T' T4 w
223.         }
     9 P, D9 S  q( |3 i5 U
224.     };
     0 `) V9 \. A# Z2 X/ f4 x+ z
225. }
     8 w5 \0 A# @( ^$ x7 r% i  Y2 ?' h: h
226. //写SPI FLASH
     + e5 W" `1 v" F3 w+ Z* W+ Y
227. //在指定地址开始写入指定长度的数据
     7 n2 [: c3 P- U# O! m1 Z+ I
228. //该函数带擦除操作!
     
229. //pBuffer:数据存储区
     
230. //WriteAddr:开始写入的地址(24bit)
     ( T8 b6 O2 b8 t/ X. B
231. //NumByteToWrite:要写入的字节数(最大65535)
     
232. uint8_t W25QXX_BUFFER[4096];
     0 j3 ]: I$ t2 ~3 K
233. void W25QXX_Write(uint8_t *pBuffer, uint32_t WriteAddr, uint16_t NumByteToWrite)
     ; K7 p! A* P$ r2 J: ~! f
234. {
     ' P2 Q& W0 Y' c; U/ M4 X
235.     uint32_t secpos;
     * u: h6 P6 M- m! g& G+ Z2 T
236.     uint16_t secoff;
     
237.     uint16_t secremain;
     - }4 z0 @( f8 P7 C6 N& A+ L
238.     uint16_t i;
     
239.     uint8_t *W25QXX_BUF;
     
240.     W25QXX_BUF = W25QXX_BUFFER;
     " Q3 k# Y) x3 s- o3 }) L  K
241.     secpos = WriteAddr / 4096;           //扇区地址
     ' i/ k2 }7 o/ `
242.     secoff = WriteAddr % 4096;           //在扇区内的偏移
     
243.     secremain = 4096 - secoff;           //扇区剩余空间大小
     ; u+ l- B. u/ J& c$ \7 B, [
244.     if (NumByteToWrite <= secremain)
     0 U: m$ h: p. v; {0 G% s- ~  [
245.         secremain = NumByteToWrite;           //不大于4096个字节
     7 P' M, K2 C( A' L$ X
246.     while (1)
     
247.     {
     * S+ ?% `/ ]6 L; Y. x8 T
248.         W25QXX_Read(W25QXX_BUF, secpos * 4096, 4096);           //读出整个扇区的内容
     1 D( Z  o' I, k: ^; Y8 X
249.         for (i = 0; i < secremain; i++) //校验数据
     
250.         {
     3 S/ t$ m. ?* G1 T  ^
251.             if (W25QXX_BUF[secoff + i] != 0XFF)
     
252.                 break; //需要擦除
     
253.         }
     4 I) c; J4 v/ H# J+ f7 _5 U8 h4 P
254.         if (i < secremain) //需要擦除
     
255.         {
     : }7 K3 h' i7 e' i0 D
256.             W25QXX_Erase_Sector(secpos);                //擦除这个扇区
     $ D" j& X$ d% k
257.             for (i = 0; i < secremain; i++)                           //复制
     7 p% O; s* f+ t5 m
258.             {
     1 M- [5 U1 c; o2 C0 \
259.                 W25QXX_BUF[i + secoff] = pBuffer<i>;
     5 C& e8 O2 s' M& T
260.             }
     # g3 y' V7 V3 z- o) ^# T+ a
261.             W25QXX_Write_NoCheck(W25QXX_BUF, secpos * 4096, 4096);                   //写入整个扇区
     
262. 
     
263.         }
     * G* S: F) P9 z: S$ x0 N% m, k% h
264.         else
     
265.             W25QXX_Write_NoCheck(pBuffer, WriteAddr, secremain); //写已经擦除了的,直接写入扇区剩余区间.
     $ w2 p# ^! W9 o+ m  E
266.         if (NumByteToWrite == secremain)
     
267.             break; //写入结束了
     
268.         else //写入未结束
     
269.         {
     
270.             secpos++; //扇区地址增1
     . B: b+ m7 K, l: g9 G% z9 J( V' M* }
271.             secoff = 0; //偏移位置为0
     . \# P& f" r4 ~) ?9 w
272. 
     
273.             pBuffer += secremain;                                  //指针偏移
     & k8 e& P  D$ u# L5 _$ D7 U
274.             WriteAddr += secremain;                                //写地址偏移
     
275.             NumByteToWrite -= secremain;                        //字节数递减
     
276.             if (NumByteToWrite > 4096)
     ' a. `: Q% H, i! E! ]$ m
277.                 secremain = 4096;                        //下一个扇区还是写不完
     ; g* t" M7 B4 Z4 [
278.             else
     - }1 J5 D( R" i* t
279.                 secremain = NumByteToWrite;                //下一个扇区可以写完了
     
280.         }
     
281.     };
     
282. }
     
283. 
     
284. //擦除整个芯片
     ' ]7 A; @  L! [0 W/ }& O& c  w
285. //等待时间超长...
     , V/ T! H' M$ D2 O! k" h2 a
286. void W25QXX_Erase_Chip(void)
     + Z2 |" t0 F/ s' W/ y! O% c
287. {
     - Z7 u, v, B: J; o( ^
288.     W25QXX_Write_Enable();                                  //SET WEL
     
289.     W25QXX_Wait_Busy();
     
290.     W25QXX_CS_L(); //使能器件
     + K) b0 e1 \1 A1 e6 z9 e
291.     W25QXX_SPI_ReadWriteByte(W25X_ChipErase);                //发送片擦除命令
     
292.     W25QXX_CS_H();  //取消片选
     
293.     W25QXX_Wait_Busy();                                                      //等待芯片擦除结束
     ! u" ?9 `& |' E0 I+ h0 k: D
294. }
     & P/ t6 W7 ]# E# K3 }, Z
295. //擦除一个扇区
     " @/ Q  e* c* L5 P
296. //Dst_Addr:扇区地址 根据实际容量设置
     : W1 c4 ]+ z- w5 K+ q
297. //擦除一个山区的最少时间:150ms
     6 w- n6 L1 O! j
298. void W25QXX_Erase_Sector(uint32_t Dst_Addr)
     
299. {
     3 [, Q" i1 u5 e9 j6 P/ y
300.     //监视falsh擦除情况,测试用
     
301.     Dst_Addr *= 4096;
     4 ?1 I3 |4 R1 G( H! O
302.     W25QXX_Write_Enable();                          //SET WEL
     , }( T; a* ?6 V; I; m! Z2 A' q
303.     W25QXX_Wait_Busy();
     ) A) U6 d  {$ h4 R! G1 u! y
304.     W25QXX_CS_L(); //使能器件
     8 F- ]6 B  x0 F+ z% O6 u
305.     W25QXX_SPI_ReadWriteByte(W25X_SectorErase);              //发送扇区擦除指令
     
306.     W25QXX_SPI_ReadWriteByte((uint8_t)((Dst_Addr) >> 16));          //发送24bit地址
     7 [' }7 }8 _2 ]; c: ?2 ]
307.     W25QXX_SPI_ReadWriteByte((uint8_t)((Dst_Addr) >> 8));
     
308.     W25QXX_SPI_ReadWriteByte((uint8_t)Dst_Addr);
     3 G3 Q7 o6 s3 B( `! G
309.     W25QXX_CS_H();  //取消片选
     
310.     W25QXX_Wait_Busy();                                                      //等待擦除完成
     
311. }
     
312. //等待空闲
     5 l# j, e+ c+ b) l$ X
313. void W25QXX_Wait_Busy(void)
     7 ]4 J6 @" r7 }+ G6 m# s
314. {
     : n. E8 [+ p. c% C
315.     while ((W25QXX_ReadSR() & 0x01) == 0x01);                  // 等待BUSY位清空
     : u+ y, |5 p0 E* z
316. }
     : W( z6 u6 {9 Z% S* n' Q
317. //进入掉电模式
     7 i6 N  j: P: w% C( `( ]: Z; K
318. void W25QXX_PowerDown(void)
     
319. {
     2 Q& C* ^1 i, e. y4 r" V
320.     W25QXX_CS_L(); //使能器件
     . {+ t/ K: f5 r2 `
321.     W25QXX_SPI_ReadWriteByte(W25X_PowerDown);        //发送掉电命令
     , f: E9 _" |  W- E
322.     W25QXX_CS_H();  //取消片选
     ) T8 N( ], e0 X+ d
323.     delay_us(3);                               //等待TPD
     
324. }
     - d  L2 a8 C+ g% q
325. //唤醒
     
326. void W25QXX_WAKEUP(void)
     
327. {
     6 f9 @) [% u! j1 a
328.     W25QXX_CS_L(); //使能器件
     ; P" q* I6 f2 g0 O% G( u0 Z
329.     W25QXX_SPI_ReadWriteByte(W25X_ReleasePowerDown); //  send W25X_PowerDown command 0xAB
     4 X0 W3 n. F4 o+ d6 o/ G( i8 T
330.     W25QXX_CS_H();  //取消片选
     1 P& ]( t& W  [3 h
331.     delay_us(3);                                    //等待TRES1
     5 j$ w, s! P2 F
332. }</i></i></i></i></i>

复制代码

* a. G0 Y3 }2 @$ p: b# n
头文件
6 \+ l2 U7 Y% j( x

1. #ifndef __W25QXX_H
   : B6 L0 G8 O9 l1 M( M$ Q1 r2 O8 O
2. #define __W25QXX_H
   
3. 
   ) [0 h" p  u3 m3 Y0 S
4. #include <main.h>
   
5. 
   
6. #define W25QXX_SPI_Handle (&hspi1)
   
7. 
   
8. //W25X系列/Q系列芯片列表
   . y, v7 [, Y, a3 @' ^' R' _( H0 ]" x
9. //W25Q80  ID  0XEF13
   
10. //W25Q16  ID  0XEF14
    
11. //W25Q32  ID  0XEF15
    
12. //W25Q64  ID  0XEF16
    
13. //W25Q128 ID  0XEF17
    7 ^, ^! \5 d# b+ h3 {* R  F
14. #define W25Q80         0XEF13
    9 K" O  k! ^; F+ ~% _
15. #define W25Q16         0XEF14
    
16. #define W25Q32         0XEF15
    ' z( _& P8 O' Y* ]( @8 W
17. #define W25Q64         0XEF16
    * p% h4 p8 R, f. `+ a5 h
18. #define W25Q128        0XEF17
    , A* o9 Y" |( p
19. 
    
20. 
    - a) C) l* o" |2 b% [" J9 t
21. #define W25QXX_CS_L()  HAL_GPIO_WritePin(W25QXX_CS_GPIO_Port, W25QXX_CS_Pin, GPIO_PIN_RESET)
    
22. #define W25QXX_CS_H()  HAL_GPIO_WritePin(W25QXX_CS_GPIO_Port, W25QXX_CS_Pin, GPIO_PIN_SET)
    9 ]1 g4 A, I6 W; z2 c( Y9 c- \5 b
23. 
    2 i% {, P' J9 J: }% K. ]0 G
24. 
    
25. extern uint16_t W25QXX_TYPE;
    
26. extern uint32_t W25QXX_SIZE;
    
27. extern uint8_t  W25QXX_UID[8];
    & b  W" z7 n- |: i
28. 
    5 |& r3 E6 ]( {" W/ R* p2 Y. V
29. 
    
30. //
    
31. //指令表
      n5 i3 K, U4 k7 Q
32. #define W25X_WriteEnable                0x06
    3 H- ~, I' ]- N& ^
33. #define W25X_WriteDisable                0x04
    & z$ I+ |6 j* f) e4 _
34. #define W25X_ReadStatusReg                0x05
    
35. #define W25X_WriteStatusReg                0x01
    
36. #define W25X_ReadData                        0x03
    
37. #define W25X_FastReadData                0x0B
    
38. #define W25X_FastReadDual                0x3B
    ! |/ v; b5 V7 j& O. e. ^
39. #define W25X_PageProgram                0x02
    - n5 P5 v- K0 E" \1 O
40. #define W25X_BlockErase                        0xD8
    
41. #define W25X_SectorErase                0x20
    % A4 U6 s" l' U' {8 C
42. #define W25X_ChipErase                        0xC7
    - G: \& b, F# ^1 x3 T
43. #define W25X_PowerDown                        0xB9
    7 u# X' N. |. @
44. #define W25X_ReleasePowerDown        0xAB
    
45. #define W25X_DeviceID                        0xAB
    
46. #define W25X_ManufactDeviceID        0x90
    
47. #define W25X_JedecDeviceID                0x9F
    
48. 
    # I; ~" I  g. i
49. int W25QXX_Init(void);
    
50. void W25QXX_ReadUniqueID(uint8_t UID[8]);
    9 a, U& l$ T+ H2 o4 u% m+ y
51. uint16_t  W25QXX_ReadID(void);                              //读取FLASH ID
    : I3 x/ @7 P* q2 I6 I0 v2 Y
52. uint8_t         W25QXX_ReadSR(void);                        //读取状态寄存器
    ; |- l+ z: C2 b5 x) |2 L+ Y4 B
53. void W25QXX_Write_SR(uint8_t sr);                          //写状态寄存器
    7 m4 m& o& b4 c: n$ u4 S
54. void W25QXX_Write_Enable(void);                  //写使能
    
55. void W25QXX_Write_Disable(void);                //写保护
    $ u) {$ K, f* r* g/ S
56. void W25QXX_Write_NoCheck(uint8_t* pBuffer,uint32_t WriteAddr,uint16_t NumByteToWrite);
    5 S/ i+ s) m0 S) e0 T! ?) X5 z
57. void W25QXX_Read(uint8_t* pBuffer,uint32_t ReadAddr,uint16_t NumByteToRead);   //读取flash
    1 V: P# ~6 j, k: F: o
58. void W25QXX_Write(uint8_t* pBuffer,uint32_t WriteAddr,uint16_t NumByteToWrite);//写入flash
    
59. void W25QXX_Erase_Chip(void);                      //整片擦除
    
60. void W25QXX_Erase_Sector(uint32_t Dst_Addr);        //扇区擦除
    
61. void W25QXX_Wait_Busy(void);                   //等待空闲
    + [5 M$ X, {8 O+ W! j$ J4 C- M3 i
62. void W25QXX_PowerDown(void);                //进入掉电模式
    2 V5 o% }& \' I! P* [/ @/ }$ X  N, D
63. void W25QXX_WAKEUP(void);                                //唤醒
      h6 e' w& w2 U" O- x
64. uint32_t W25QXX_ReadCapacity(void);
    
65. 
    
66. #endif
    1 O- x. Y# K8 Z2 A7 M# ?
67. 
    8 b! |, F+ l& ^  z  n, ?
68. 
    8 q$ `$ @" S% R7 X0 g" c+ I
69. 
    : N/ b$ M8 F6 R) h/ ]2 K$ ^: p1 q

复制代码