概述
SPI是串行外设接口（Serial Peripheral Interface）的缩写，是一种高速的，全双工，同步的通信总线，并且在芯片的管脚上只占用四根线，节约了芯片的管脚，同时为PCB的布局上节省空间，提供方便，正是出于这种简单易用的特性，越来越多的芯片集成了这种通信协议，比如 EEPROM，FLASH，实时时钟，AD转换器。
) `0 D; Y  X0 @W25Q128 是一款SPI接口的Flash芯片，其存储空间为 128Mbit，相当于16M字节。W25Q128可以支持 SPI 的模式 0 和模式 3，也就是 CPOL=0/CPHA=0 和CPOL=1/CPHA=1 这两种模式。

6 G4 ^* x( V/ g2 Q硬件准备
% T& G$ r, u7 P& K6 h首先需要准备一个开发板，这里我准备的是NUCLEO-F030R8的开发板：
+ a* a  l. k* j, N$ m6 k
$ |% w0 S2 h$ B) k+ n

选择芯片型号
* p8 _, K) x4 D: [使用STM32CUBEMX选择芯片stm32f030r8，如下所示：
3 W3 R9 h6 A3 H5 t

+ s8 K# Q' j& ^; i
配置时钟源
HSE与LSE分别为外部高速时钟和低速时钟，在本文中使用内置的时钟源，故都选择Disable选项，如下所示：



配置时钟树
STM32F0的最高主频到48M，所以配置48即可：
: w7 c$ Z, ~  I8 ~) p/ q

# M2 n, \' K  }% e5 S
串口配置
7 \5 r; H% R, f+ G% A本次实验使用的串口1进行串口通信，波特率配置为115200。
  P2 I$ Z7 `' o4 r" r* e, b5 N

/ L: Q3 b$ E1 Q0 G. D& t
$ A/ b1 ^5 L3 c; r( r" L2 `开启DMA。
5 e! u5 j+ b. p$ k4 I
( r# n7 Z' g( h# q/ k
8 V; o1 A* L, }+ N: R' h, l. s8 j
中断。

9 l; D4 N: a4 s+ G0 g8 G& k
% u9 N2 _6 P8 R# T9 _

) j; V7 m. n% w. F/ ISPI配置
2 \: D# z. {& k( P2 a' S* j本次实验使用的SPI与Flash通信，配置如下。
) n; ~& W- ?, P- j" cSPI的通信原理很简单，它以主从方式工作，这种模式通常有一个主设备和一个或多个从设备，需要至少4根线，事实上3根也可以（单向传输时）。也是所有基于SPI的设备共有的，它们是MISO（主设备数据输入）、MOSI（主设备数据输出）、SCLK（时钟）、CS（片选）。
6 D5 P6 P5 ~3 z2 l（1）MISO– Master Input Slave Output,主设备数据输入，从设备数据输出；
（2）MOSI– Master Output Slave Input，主设备数据输出，从设备数据输入；
6 h8 I* w" S! {! S（3）SCLK – Serial Clock，时钟信号，由主设备产生；
（4）CS – Chip Select，从设备使能信号，由主设备控制。

接线方式
9 X: u3 U- Q- a* i) _
+ k, o1 z3 |3 r& |7 [
! L5 [2 ~) C: `8 ]4 t
( }6 ?6 K( R  _2 g& ~: v9 }负责通讯的3根线了。通讯是通过数据交换完成的，这里先要知道SPI是串行通讯协议，也就是说数据是一位一位的传输的。这就是SCLK时钟线存在的原因，由SCLK提供时钟脉冲，SDI，SDO则基于此脉冲完成数据传输。数据输出通过 SDO线，数据在时钟上升沿或下降沿时改变，在紧接着的下降沿或上升沿被读取。完成一位数据传输，输入也使用同样原理。因此，至少需要8次时钟信号的改变（上沿和下沿为一次），才能完成8位数据的传输。
时钟信号线SCLK只能由主设备控制，从设备不能控制。同样，在一个基于SPI的设备中，至少有一个主设备。这样的传输方式有一个优点，在数据位的传输过程中可以暂停，也就是时钟的周期可以为不等宽，因为时钟线由主设备控制，当没有时钟跳变时，从设备不采集或传送数据。SPI还是一个数据交换协议：因为SPI的数据输入和输出线独立，所以允许同时完成数据的输入和输出。芯片集成的SPI串行同步时钟极性和相位可以通过寄存器配置，IO模拟的SPI串行同步时钟需要根据从设备支持的时钟极性和相位来通讯。
& K5 n  n8 l0 u$ l5 r' H# ]$ W/ ^" Z最后，SPI接口的一个缺点：没有指定的流控制，没有应答机制确认是否接收到数据。
& d' ?' B8 d2 T/ ~+ E5 H
# R* N2 P7 P/ R" h7 [, G

其中，CS是从芯片是否被主芯片选中的控制信号，也就是说只有片选信号为预先规定的使能信号时（高电位或低电位），主芯片对此从芯片的操作才有效。这就使在同一条总线上连接多个SPI设备成为可能。
随便配置一个端口为CS片选，并且命名为CS。
  I& z* ]# w7 n- L8 J0 ~% `$ v! ?1 X& }0 l) O
, t& B0 u8 B% |# b

; \0 x- s: i) M生成工程设置
注意在生产工程设置中不能出现中文，不然会报错。



生成代码

( r  V) \4 c5 ]9 l- a$ P( N# Y

/ ]8 Y6 ~* d' A. M配置keil
3 S7 O( c$ @6 k. X: {: Y2 X3 `8 c


W25Q128的原理及应用
. |1 U1 @, y+ h' o5 SW25Q128将16M的容量分为256个块（Block),每个块大小为64K字节，每个块又分为16个扇区（Sector),每个扇区4K个字节。W25Q128的最小擦除单位为一个扇区，也就是每次必须擦除4K个字节。
芯片ID如下所示。
4 y" }$ m) V9 h& y
! e+ G) H0 x/ ~! Y! h/ `0XEF13,表示芯片型号为W25Q80
  }, C$ L0 x. o( O) F& x2 J2 i5 ]0XEF14,表示芯片型号为W25Q16
0XEF15,表示芯片型号为W25Q32
0XEF16,表示芯片型号为W25Q64
) d3 \6 H% M5 x5 Z; \& g/ x' W0XEF17,表示芯片型号为W25Q128

1 v; J% F% F4 _9 G+ }. U3 V驱动代码
W25Qx.c

1. /*********************************************************************************************************
   
2. *
   
3. * File                : ws_W25Qx.c
   . E% Z$ U. m! y! w' E. H. t
4. * Hardware Environment:
   
5. * Build Environment   : RealView MDK-ARM  Version: 4.20
   
6. * Version             : V1.0
   # H7 i' ]# l0 Y" V+ B
7. * By                  :
   
8. *
   " ]2 ~6 q. {5 r0 u' K
9. *                                  (c) Copyright 2005-2011, WaveShare
   
10. *                                       <a href="http://www.waveshare.net" target="_blank">http://www.waveshare.net</a>
    
11. *                                          All Rights Reserved
    
12. *
    
13. *********************************************************************************************************/
    3 d4 E  m; ]9 a' k1 G
14. 
    5 z0 u+ C! K: G$ o, f8 l* k- s
15. #include "W25Qx.h"
    & G9 ^2 G8 y- G& ^6 P8 C
16. 
    $ ~: K6 B6 A& p3 j
17. /**
    : B8 g  y: n% F) {
18.   * @brief  Initializes the W25Q128FV interface.
    
19.   * @retval None
    $ s; [6 J: O% ?) N+ {! Y2 I) C: K0 G
20.   */
    
21. uint8_t BSP_W25Qx_Init(void)
    + i/ U% r- c# v) {" \" g- w4 ~8 k
22. {
    2 q; M- O% ?7 r
23.         /* Reset W25Qxxx */
    
24.         BSP_W25Qx_Reset();
    
25.         
    1 h1 L- F' O; c# ]/ p
26.         return BSP_W25Qx_GetStatus();
    
27. }
    . r5 v' m2 ]0 e* I8 u
28. 
    ; B- x+ S5 Y' o( x: V
29. /**
    
30.   * @brief  This function reset the W25Qx.
    
31.   * @retval None
    ( I* D& V1 k5 W; k) L
32.   */
    
33. static void        BSP_W25Qx_Reset(void)
    
34. {
    ' N1 I! Q- `# l4 v( d6 U. @
35.         uint8_t cmd[2] = {RESET_ENABLE_CMD,RESET_MEMORY_CMD};
    
36.         
    ' m$ A' V% w3 g
37.         W25Qx_Enable();
    
38.         /* Send the reset command */
    & Y2 X5 I" C# u8 `2 `8 t1 c
39.         HAL_SPI_Transmit(&hspi1, cmd, 2, W25Qx_TIMEOUT_VALUE);        
    7 M7 Q7 U9 L$ C* E) k) Q- f9 q
40.         W25Qx_Disable();
    $ H+ l" ~$ g: o- S* m1 x
41. 
    " o: P4 ]7 b2 w2 ~$ C# v7 C
42. }
    % S$ Q$ a6 V) K
43. 
    
44. /**
    7 u. V, R* g) _* g7 a- @8 _
45.   * @brief  Reads current status of the W25Q128FV.
    / R9 i* F% H" d3 s6 o; i$ R7 H! F% `
46.   * @retval W25Q128FV memory status
    
47.   */
    ; u3 l/ P/ j+ I; g$ }
48. static uint8_t BSP_W25Qx_GetStatus(void)
    ! c/ H, j1 S6 R6 T* c
49. {
    
50.         uint8_t cmd[] = {READ_STATUS_REG1_CMD};
    
51.         uint8_t status;
    & V  [/ g/ ]. s) g8 f- f
52.         
    
53.         W25Qx_Enable();
    
54.         /* Send the read status command */
    
55.         HAL_SPI_Transmit(&hspi1, cmd, 1, W25Qx_TIMEOUT_VALUE);        
    
56.         /* Reception of the data */
    % F+ L* b, h, g' a: h$ z: L
57.         HAL_SPI_Receive(&hspi1,&status, 1, W25Qx_TIMEOUT_VALUE);
    
58.         W25Qx_Disable();
    
59.         
    
60.         /* Check the value of the register */
    
61.   if((status & W25Q128FV_FSR_BUSY) != 0)
    
62.   {
    , ]3 m0 T+ F8 ]7 K9 L$ J# }
63.     return W25Qx_BUSY;
    
64.   }
    
65.         else
    
66.         {
    
67.                 return W25Qx_OK;
    
68.         }               
    9 l- N7 D$ V, Q+ B, _$ p
69. }
    8 [$ X* W7 I5 O3 I& t2 r
70. 
    1 ^+ s! k0 w& t( ]# B8 U7 ^
71. /**
    - C3 D: r" m7 p
72.   * @brief  This function send a Write Enable and wait it is effective.
    ' P' r2 Z5 F: W1 D- X
73.   * @retval None
    
74.   */
    + J* U1 X% O5 N* k% g( ]0 I
75. uint8_t BSP_W25Qx_WriteEnable(void)
    
76. {
    2 P: O) |, h# q3 V/ d
77.         uint8_t cmd[] = {WRITE_ENABLE_CMD};
    * U* l& s9 B' v$ Z( T' S3 B! ?6 z
78.         uint32_t tickstart = HAL_GetTick();
    
79. 
    $ ~. c1 Z. m% S4 V* i
80.         /*Select the FLASH: Chip Select low */
    
81.         W25Qx_Enable();
    
82.         /* Send the read ID command */
    
83.         HAL_SPI_Transmit(&hspi1, cmd, 1, W25Qx_TIMEOUT_VALUE);        
    
84.         /*Deselect the FLASH: Chip Select high */
    & C, a9 y- [) _9 d# J
85.         W25Qx_Disable();
    
86.         
    2 f, d) [) {, J5 e
87.         /* Wait the end of Flash writing */
    
88.         while(BSP_W25Qx_GetStatus() == W25Qx_BUSY);
    ( M% v8 }2 @0 q: j# i
89.         {
    
90.                 /* Check for the Timeout */
    " _; z" `# t  e0 r# C) O
91.     if((HAL_GetTick() - tickstart) > W25Qx_TIMEOUT_VALUE)
    
92.     {        
    
93.                         return W25Qx_TIMEOUT;
    7 A4 D% q) [! c6 u) a
94.     }
    
95.         }
    4 n: V, M$ H& a+ l
96.         
    8 o) ?: I# ?) u5 p, P( v# T
97.         return W25Qx_OK;
    
98. }
    0 F3 j( Q' y* [& a
99. 
    7 H5 i/ ]% [. _. V
100. /**
     
101.   * @brief  Read Manufacture/Device ID.
     ( X4 Q- E; O' q' a0 f3 @. U/ O& a
102.         * @param  return value address
     ' s0 W. \5 s3 O* P+ |8 i0 G
103.   * @retval None
     
104.   */
     0 b7 S, C8 m, C" O6 Q( D
105. void BSP_W25Qx_Read_ID(uint8_t *ID)
     8 z" r) p6 u- f9 j9 ?; Z1 U
106. {
     9 p. N; M- |* G, t: I5 w& C/ e
107.         uint8_t cmd[4] = {READ_ID_CMD,0x00,0x00,0x00};
     * l$ Z% M: T# ]% ?9 z9 U+ [" }
108.         
     
109.         W25Qx_Enable();
     
110.         /* Send the read ID command */
     
111.         HAL_SPI_Transmit(&hspi1, cmd, 4, W25Qx_TIMEOUT_VALUE);        
     2 R8 w  ^$ I) Q3 `% C) h9 S7 M- x
112.         /* Reception of the data */
     
113.         HAL_SPI_Receive(&hspi1,ID, 2, W25Qx_TIMEOUT_VALUE);
     
114.         W25Qx_Disable();
     3 R( f( A8 }+ T$ s' P. N6 I
115.                
     
116. }
     0 s  R* [9 N( l" R; P
117. 
     # ]! [! O0 {8 s# {
118. /**
     , D0 F9 H0 v  K3 M7 c0 U
119.   * @brief  Reads an amount of data from the QSPI memory.
     
120.   * @param  pData: Pointer to data to be read
     
121.   * @param  ReadAddr: Read start address
     
122.   * @param  Size: Size of data to read   
     - d0 R, J3 [; V9 m5 @. g- P
123.   * @retval QSPI memory status
     + y( ]2 c5 E" ~0 X! `; ~! O
124.   */
     : }4 f7 l7 K( K" a% S
125. uint8_t BSP_W25Qx_Read(uint8_t* pData, uint32_t ReadAddr, uint32_t Size)
     - u% V) T2 G" }! I3 |5 f
126. {
     . b1 o  a+ x1 X
127.         uint8_t cmd[4];
     
128. 
     4 C4 ~; ~4 Y+ R7 g7 @
129.         /* Configure the command */
     
130.         cmd[0] = READ_CMD;
     9 v! R! b& `; i9 X  ~# K
131.         cmd[1] = (uint8_t)(ReadAddr >> 16);
     
132.         cmd[2] = (uint8_t)(ReadAddr >> 8);
     " T7 C1 c# v3 n, J' |& S/ B* ~) }
133.         cmd[3] = (uint8_t)(ReadAddr);
     
134.         
     
135.         W25Qx_Enable();
     / C% J9 H1 i. S  z
136.         /* Send the read ID command */
     
137.         HAL_SPI_Transmit(&hspi1, cmd, 4, W25Qx_TIMEOUT_VALUE);        
     
138.         /* Reception of the data */
     ; o+ r3 F- ~! Q& g5 F
139.         if (HAL_SPI_Receive(&hspi1, pData,Size,W25Qx_TIMEOUT_VALUE) != HAL_OK)
     
140.   {
     
141.     return W25Qx_ERROR;
     
142.   }
     
143.         W25Qx_Disable();
     6 E/ u: M5 D0 G3 h% F7 H; P6 h
144.         return W25Qx_OK;
     
145. }
     ! j7 `0 A  B8 Y
146. 
     6 ^5 Z* ^3 }4 }! b6 k: ]
147. /**
       n; o* m- i: K4 x( e
148.   * @brief  Writes an amount of data to the QSPI memory.
     $ t1 m  T+ ]8 I
149.   * @param  pData: Pointer to data to be written
     $ g1 M0 G) _8 _8 H. c# i
150.   * @param  WriteAddr: Write start address
     
151.   * @param  Size: Size of data to write,No more than 256byte.   
     
152.   * @retval QSPI memory status
     
153.   */
     ) m& j( `% |8 H% u7 s- U
154. uint8_t BSP_W25Qx_Write(uint8_t* pData, uint32_t WriteAddr, uint32_t Size)
     
155. {
     / K# F0 }$ W$ b8 H
156.         uint8_t cmd[4];
     / c7 T$ w. x) C$ f- w9 k" u
157.         uint32_t end_addr, current_size, current_addr;
     
158.         uint32_t tickstart = HAL_GetTick();
     
159.         
     
160.         /* Calculation of the size between the write address and the end of the page */
     
161.   current_addr = 0;
     % [* r4 m) W2 D: _9 ~3 E' H
162. 
     
163.   while (current_addr <= WriteAddr)
     
164.   {
     
165.     current_addr += W25Q128FV_PAGE_SIZE;
     
166.   }
     
167.   current_size = current_addr - WriteAddr;
     
168. 
     2 _' Z5 m5 k5 D( {0 {  j! b
169.   /* Check if the size of the data is less than the remaining place in the page */
     . |( x+ \8 z9 x) r  H
170.   if (current_size > Size)
     - d5 t# D# w1 J% |& Q+ s+ d
171.   {
     & E' G" L1 s/ j' p8 `: x: x
172.     current_size = Size;
     
173.   }
     
174. 
     
175.   /* Initialize the adress variables */
     . V8 _5 J5 G( s/ q* i
176.   current_addr = WriteAddr;
     / R7 j% I- f. F% ?, M
177.   end_addr = WriteAddr + Size;
     
178.         
     
179.   /* Perform the write page by page */
     1 Y: w; w. J: W+ O7 m8 T
180.   do
     
181.   {
     
182.                 /* Configure the command */
     1 Z9 w1 w6 }$ x: K/ a; ?
183.                 cmd[0] = PAGE_PROG_CMD;
     + J- [/ o, N4 F1 e8 A$ o
184.                 cmd[1] = (uint8_t)(current_addr >> 16);
     ; m5 W6 q0 T) Y  g& A6 C$ k9 m
185.                 cmd[2] = (uint8_t)(current_addr >> 8);
     ' R% c3 ~* l9 G8 O, z: T
186.                 cmd[3] = (uint8_t)(current_addr);
     
187. 
     
188.                 /* Enable write operations */
     
189.                 BSP_W25Qx_WriteEnable();
     3 s1 V; d. S4 U# q6 b4 h# c) i
190.         
     ; ~+ S* h2 R' ?; S+ b. z! L
191.                 W25Qx_Enable();
     
192.     /* Send the command */
     + J3 n! V+ a, e/ G) ~
193.     if (HAL_SPI_Transmit(&hspi1,cmd, 4, W25Qx_TIMEOUT_VALUE) != HAL_OK)
     - T8 s, g* |: a- o
194.     {
     
195.       return W25Qx_ERROR;
     7 r1 R# l; P1 z* d6 p9 Y
196.     }
     # e- `  K5 L) T
197. 
     2 d4 j5 m9 n& ^8 f# Z7 n
198.     /* Transmission of the data */
     
199.     if (HAL_SPI_Transmit(&hspi1, pData,current_size, W25Qx_TIMEOUT_VALUE) != HAL_OK)
     
200.     {
     
201.       return W25Qx_ERROR;
     # I$ o+ g0 C7 `" @
202.     }
     
203.                         W25Qx_Disable();
     - ?9 [  F( Z& }* E: q8 R  h6 Q
204.             /* Wait the end of Flash writing */
     
205.                 while(BSP_W25Qx_GetStatus() == W25Qx_BUSY);
       ~3 t& L' a' S7 K1 C) B
206.                 {
     " W3 q8 y# a4 _; N: L3 H0 N
207.                         /* Check for the Timeout */
     
208.                         if((HAL_GetTick() - tickstart) > W25Qx_TIMEOUT_VALUE)
     
209.                         {        
     9 ]9 a; M  {/ _
210.                                 return W25Qx_TIMEOUT;
     
211.                         }
     : e3 ^* k0 d+ U1 Q
212.                 }
     
213. 
     
214.     /* Update the address and size variables for next page programming */
     7 g+ m; U  B" }$ ~, @3 I) ]
215.     current_addr += current_size;
     % \' m8 e# u, U. z$ l$ @2 M
216.     pData += current_size;
     , _0 t& f0 E' w/ f& j; F! J. ]& y* N
217.     current_size = ((current_addr + W25Q128FV_PAGE_SIZE) > end_addr) ? (end_addr - current_addr) : W25Q128FV_PAGE_SIZE;
     
218.   } while (current_addr < end_addr);
     
219. 
     2 d& k9 K$ J/ M3 B( V6 M
220.         
     ! H+ }/ e+ A% J; N  w! O- D
221.         return W25Qx_OK;
     9 I& Z% Y! s6 A7 E) q* @# b% n
222. }
     2 o! I& J, @" l* @5 A
223. 
     8 j% j3 }; x1 |+ J- X
224. /**
     
225.   * @brief  Erases the specified block of the QSPI memory.
       k* Z/ N  Y9 a* @8 c$ G
226.   * @param  BlockAddress: Block address to erase  
     : M3 V4 C3 p) i3 T* O' X! ]
227.   * @retval QSPI memory status
     
228.   */
     
229. uint8_t BSP_W25Qx_Erase_Block(uint32_t Address)
     0 E& m7 z/ q1 S( C! `6 v0 Z' j. I! k& R
230. {
     . @$ P; f1 {: v9 {
231.         uint8_t cmd[4];
     
232.         uint32_t tickstart = HAL_GetTick();
     3 ?  K, p. s, l( K
233.         cmd[0] = SECTOR_ERASE_CMD;
     
234.         cmd[1] = (uint8_t)(Address >> 16);
     ; C& @5 Y* t: m5 @1 w& \2 x
235.         cmd[2] = (uint8_t)(Address >> 8);
     ' r8 T: K; G9 c8 k
236.         cmd[3] = (uint8_t)(Address);
     , f6 d* n9 S4 W+ d5 R
237.         
     ; g6 m. x' [6 C
238.         /* Enable write operations */
     4 q2 V6 G5 n0 S% {& g+ j
239.         BSP_W25Qx_WriteEnable();
     : V1 s. H% z2 L9 L
240.         
     0 e, P/ b0 \. m$ V9 ]
241.         /*Select the FLASH: Chip Select low */
     $ y; I7 ~- t$ X+ p7 z6 z0 |
242.         W25Qx_Enable();
     5 D5 j( d' V) I0 t6 Y3 i6 C. @
243.         /* Send the read ID command */
     : }. O; B+ r& Q% V7 ]# @
244.         HAL_SPI_Transmit(&hspi1, cmd, 4, W25Qx_TIMEOUT_VALUE);        
     
245.         /*Deselect the FLASH: Chip Select high */
     
246.         W25Qx_Disable();
     
247.         
     
248.         /* Wait the end of Flash writing */
     
249.         while(BSP_W25Qx_GetStatus() == W25Qx_BUSY);
     
250.         {
     + O( `5 E. M. v6 w
251.                 /* Check for the Timeout */
     0 y( [# y- t- K+ @- H$ s+ @( L' t& E
252.     if((HAL_GetTick() - tickstart) > W25Q128FV_SECTOR_ERASE_MAX_TIME)
     0 K) x. C& u' U' O
253.     {        
     3 y' y* O* x* a% O1 e7 V
254.                         return W25Qx_TIMEOUT;
     
255.     }
     - Y6 G/ O2 R& C- V
256.         }
     
257.         return W25Qx_OK;
     
258. }
     
259. 
     & H) g: Z# O; D1 |- {
260. /**
     
261.   * @brief  Erases the entire QSPI memory.This function will take a very long time.
     
262.   * @retval QSPI memory status
     4 o0 d, T. ?: K9 |& J7 X
263.   */
     ; R/ T/ x- E5 o) C, Y' U4 M- f; r
264. uint8_t BSP_W25Qx_Erase_Chip(void)
     ( e" T; x, e) \5 T/ d
265. {
     
266.         uint8_t cmd[4];
     
267.         uint32_t tickstart = HAL_GetTick();
     ' s. S3 N% f  J5 ]
268.         cmd[0] = SECTOR_ERASE_CMD;
     
269.         
     % {3 V& N6 ?2 H4 \& }% w& w/ Z6 s6 d
270.         /* Enable write operations */
     
271.         BSP_W25Qx_WriteEnable();
     - h$ C0 D+ [0 b+ j$ y1 u% F
272.         
     
273.         /*Select the FLASH: Chip Select low */
     4 I0 G1 Q! u  D) U. E. ], m; K
274.         W25Qx_Enable();
     7 T4 U% ~% s8 K( R2 q1 A' J, u! t9 l
275.         /* Send the read ID command */
     
276.         HAL_SPI_Transmit(&hspi1, cmd, 1, W25Qx_TIMEOUT_VALUE);        
     ' ]# K0 g$ d5 C( ?1 o
277.         /*Deselect the FLASH: Chip Select high */
     ( {7 l) d. W' }% p- p
278.         W25Qx_Disable();
     4 a6 Y( p; n* V$ N
279.         
     
280.         /* Wait the end of Flash writing */
     7 u& E+ g" K' S+ d
281.         while(BSP_W25Qx_GetStatus() != W25Qx_BUSY);
     ' v1 \1 l! b" r# B  N
282.         {
     : p& k3 U1 H" f
283.                 /* Check for the Timeout */
     9 y, t6 V$ t+ Q8 S$ ]
284.     if((HAL_GetTick() - tickstart) > W25Q128FV_BULK_ERASE_MAX_TIME)
     
285.     {        
     
286.                         return W25Qx_TIMEOUT;
     & k6 v$ {# K0 M2 M% o
287.     }
     / O  i9 J; B# w
288.         }
     . h5 t3 {5 ?# I
289.         return W25Qx_OK;
     + l  s) F0 b8 v! n7 v) S% m! r$ a+ h
290. }

复制代码

; U3 M3 ~. G6 \8 Z9 yW25Qx.h
- D1 `7 s* B; B7 N, W; Q" s

1. /*********************************************************************************************************
   
2. *
   
3. * File                : W25Qx.h
   : T( I3 V5 d! w+ Q  Q3 F* v9 K
4. * Hardware Environment:
   8 {$ t7 _* e/ p$ n8 s% M
5. * Build Environment   : RealView MDK-ARM  Version: 5.15
   1 g6 s  ^8 Y3 v4 J4 _0 c
6. * Version             : V1.0
   & t, }2 v" x9 N: ?) {
7. * By                  :
   
8. *
   ' b* c" F' v1 @' n( b. S
9. *                                  (c) Copyright 2005-2015, WaveShare
   
10. *                                       <a href="http://www.waveshare.net" target="_blank">http://www.waveshare.net</a>
    
11. *                                          All Rights Reserved
    
12. *
    " I) ?$ g6 _( ^% j" V
13. *********************************************************************************************************/
      u% X  o% M! i$ y: ^9 y) x
14. /* Define to prevent recursive inclusion -------------------------------------*/
    
15. #ifndef __W25Qx_H
    
16. #define __W25Qx_H
    ; ~6 C& p1 G- Z3 I  B
17. 
    
18. #ifdef __cplusplus
    . @% U  U9 F. G0 W# |& z, n  v8 j
19. extern "C" {
    $ u+ V2 W9 e3 F) M9 \) M
20. #endif
    . S0 T9 l' B/ D- s% z+ \4 w
21. 
    
22. /* Includes ------------------------------------------------------------------*/
    , ?) ]6 |' N+ Z; \. B
23. #include "stm32f0xx.h"
    
24. #include "spi.h"
    
25.          
    
26. /** @addtogroup BSP
    
27.   * @{
    
28.   */
    9 t3 |# W# _2 p" O& o6 J$ W
29. 
    " }- }# q5 u$ A; }1 S0 o
30. /** @addtogroup Components
    
31.   * @{
    
32.   */
    
33. 
    
34. /** @addtogroup W25Q128FV
    + N6 q  d) h5 _6 R! I( s1 q: a+ H
35.   * @{
    4 {% D- r. _7 W; s. l0 R* }* {1 k- B
36.   */
    " I, f# I& Y9 f
37. 
    + f$ x, w& O0 a( N* Q2 a
38. /** @defgroup W25Q128FV_Exported_Types
    
39.   * @{
    , L& _- G9 g, q# y1 S
40.   */
    1 c5 @; ]" E0 L9 V+ }
41. 
    % j9 |4 C% R2 _9 R9 ~" v6 S' F( [
42. /**
    
43.   * @}
    : b! ~- M* a9 _6 c' d$ F$ `
44.   */
    
45. 
    
46. /** @defgroup W25Q128FV_Exported_Constants
    + Q/ }+ y/ S+ g6 l3 z
47.   * @{
    
48.   */
    
49. 
    + L. v* ?4 ?  S1 U' X
50. /**
    7 W2 t0 S7 F+ ^# p
51.   * @brief  W25Q128FV Configuration  
    
52.   */  
    
53. #define W25Q128FV_FLASH_SIZE                  0x1000000 /* 128 MBits => 16MBytes */
    9 U, R4 r1 d- {  u
54. #define W25Q128FV_SECTOR_SIZE                 0x10000   /* 256 sectors of 64KBytes */
    6 M* N" ^/ I& Y, E. s/ e
55. #define W25Q128FV_SUBSECTOR_SIZE              0x1000    /* 4096 subsectors of 4kBytes */
    
56. #define W25Q128FV_PAGE_SIZE                   0x100     /* 65536 pages of 256 bytes */
    / ?. b1 g+ P1 U6 R" F0 i
57. 
    
58. #define W25Q128FV_DUMMY_CYCLES_READ           4
    
59. #define W25Q128FV_DUMMY_CYCLES_READ_QUAD      10
    
60. 
    
61. #define W25Q128FV_BULK_ERASE_MAX_TIME         250000
    
62. #define W25Q128FV_SECTOR_ERASE_MAX_TIME       3000
    3 ?6 @' q6 r; w! ^9 `* V: {1 ?
63. #define W25Q128FV_SUBSECTOR_ERASE_MAX_TIME    800
    
64. #define W25Qx_TIMEOUT_VALUE 1000
    9 y5 F* }2 x) t, Y5 h0 B3 J" W6 W5 G
65. 
    ! x, m, ?* |& `" }( t* Z- t
66. /**
    
67.   * @brief  W25Q128FV Commands  
    # N; P; V. ~( b- e2 R
68.   */  
    * k, X# ^) d+ V: o! |
69. /* Reset Operations */
    4 K% q& f4 M' J
70. #define RESET_ENABLE_CMD                     0x66
    : q$ x) H$ X9 m
71. #define RESET_MEMORY_CMD                     0x99
    
72. 
    
73. #define ENTER_QPI_MODE_CMD                   0x38
    8 i& P; U2 u# E0 c7 B* Y
74. #define EXIT_QPI_MODE_CMD                    0xFF
    . l8 E' l6 y# ]( y, ]- E/ c1 ^% M' s
75. 
    
76. /* Identification Operations */
    
77. #define READ_ID_CMD                          0x90
    
78. #define DUAL_READ_ID_CMD                     0x92
    
79. #define QUAD_READ_ID_CMD                     0x94
    , r# F% I" s& D/ ^
80. #define READ_JEDEC_ID_CMD                    0x9F
    6 R$ n' W& n3 I
81. 
    
82. /* Read Operations */
    4 n- s" @# i  e7 I7 v
83. #define READ_CMD                             0x03
    6 ^7 v  W7 K* G4 t
84. #define FAST_READ_CMD                        0x0B
    
85. #define DUAL_OUT_FAST_READ_CMD               0x3B
    + k% }7 t$ }4 ^+ ], f* }6 I2 n
86. #define DUAL_INOUT_FAST_READ_CMD             0xBB
    
87. #define QUAD_OUT_FAST_READ_CMD               0x6B
    & p3 _5 y2 K( I+ z+ u
88. #define QUAD_INOUT_FAST_READ_CMD             0xEB
    
89. 
    
90. /* Write Operations */
    
91. #define WRITE_ENABLE_CMD                     0x06
    8 B6 m- G! F: `' ]2 |& m0 B
92. #define WRITE_DISABLE_CMD                    0x04
    2 z0 I6 t$ H- Q4 J0 @. y
93. 
    
94. /* Register Operations */
    1 k  q! I  ^1 R6 n- Q% K4 H0 T
95. #define READ_STATUS_REG1_CMD                  0x05
    
96. #define READ_STATUS_REG2_CMD                  0x35
    
97. #define READ_STATUS_REG3_CMD                  0x15
    ! l- ~. s0 Q9 e1 `
98. 
    
99. #define WRITE_STATUS_REG1_CMD                 0x01
    # Q* u6 w0 F. y
100. #define WRITE_STATUS_REG2_CMD                 0x31
     2 y2 K$ m+ R4 X# {( [2 H" e2 H6 J7 A
101. #define WRITE_STATUS_REG3_CMD                 0x11
     , f/ T- U: F  n- e( m
102. 
     
103. 
     
104. /* Program Operations */
       t/ t1 v( ?$ O% R, A
105. #define PAGE_PROG_CMD                        0x02
     
106. #define QUAD_INPUT_PAGE_PROG_CMD             0x32
     . g5 {+ d& D) ^! a5 c0 Y+ c$ H
107. 
     
108. 
     
109. /* Erase Operations */
     
110. #define SECTOR_ERASE_CMD                     0x20
     1 U5 q* l+ [8 v( J- b" R- A
111. #define CHIP_ERASE_CMD                       0xC7
     # E/ i1 K* Y4 C5 e, M4 }- r- |: n
112. 
     " d) K4 r7 ^' ^- |- J, o7 R  N
113. #define PROG_ERASE_RESUME_CMD                0x7A
     - n0 `: j) J) e! h" t
114. #define PROG_ERASE_SUSPEND_CMD               0x75
     
115. 
     
116. 
     
117. /* Flag Status Register */
     
118. #define W25Q128FV_FSR_BUSY                    ((uint8_t)0x01)    /*!< busy */
     
119. #define W25Q128FV_FSR_WREN                    ((uint8_t)0x02)    /*!< write enable */
     
120. #define W25Q128FV_FSR_QE                      ((uint8_t)0x02)    /*!< quad enable */
     
121. 
     - O7 I- p* I# o6 H
122. 
     + B, G+ ~. D6 e4 |
123. #define W25Qx_Enable()                         HAL_GPIO_WritePin(CS_GPIO_Port, CS_Pin, GPIO_PIN_RESET)
     : B: R% f6 o. z( q- x
124. #define W25Qx_Disable()                 HAL_GPIO_WritePin(CS_GPIO_Port, CS_Pin, GPIO_PIN_SET)
     
125. 
     2 H  C5 U/ k5 R% A( j2 \4 P
126. #define W25Qx_OK            ((uint8_t)0x00)
     8 R3 D2 b6 `& Z  g
127. #define W25Qx_ERROR         ((uint8_t)0x01)
     ' K7 A- v& @- Y$ H% N
128. #define W25Qx_BUSY          ((uint8_t)0x02)
     0 g" _+ \# D2 [$ H+ U
129. #define W25Qx_TIMEOUT                                ((uint8_t)0x03)
     ( R8 R% _. M! @2 p
130. 
     ! ?& \  o* z: V+ R% N
131. 
     - o4 H! M2 M3 R+ |( m( r5 c6 R/ }) n
132. uint8_t BSP_W25Qx_Init(void);
     
133. static void        BSP_W25Qx_Reset(void);
     
134. static uint8_t BSP_W25Qx_GetStatus(void);
     
135. uint8_t BSP_W25Qx_WriteEnable(void);
     
136. void BSP_W25Qx_Read_ID(uint8_t *ID);
     4 Z' q& J( w+ E1 k# v
137. uint8_t BSP_W25Qx_Read(uint8_t* pData, uint32_t ReadAddr, uint32_t Size);
     
138. uint8_t BSP_W25Qx_Write(uint8_t* pData, uint32_t WriteAddr, uint32_t Size);
     
139. uint8_t BSP_W25Qx_Erase_Block(uint32_t Address);
     " u$ ?# L* r: Q$ f. ~( {! U/ N
140. uint8_t BSP_W25Qx_Erase_Chip(void);
     
141. 
     , O  Q, w+ m+ K3 G9 Z
142. /**
     
143.   * @}
     5 l) n8 d5 A  y7 e
144.   */
     6 P1 u# I) @/ j9 c
145. 
     
146. /** @defgroup W25Q128FV_Exported_Functions
     
147.   * @{
       N- M% p9 U$ h6 {: {% u
148.   */
     9 K; b, b# k2 {9 N" f. i0 E) [. T$ E; d
149. /**
     * ^3 ]; s! r  O) l' `0 [+ z
150.   * @}
     % L# W+ D& [5 _# F: t
151.   */
     1 z5 X: H+ n0 M5 _+ {) y- w% V
152. 
     3 i& u, D" {" a+ n
153. /**
     
154.   * @}
     
155.   */
     & a+ @4 O1 c9 a# A: ?
156. 
     4 k- c; q4 @- y: `2 W& H! w2 l' f
157. /**
     ' E1 N$ g# Z$ z/ Y1 y8 i
158.   * @}
     
159.   */
     6 S& G! C8 L' g& O5 v/ l/ y
160. 
     7 I+ g8 h8 N' K. g% ~7 i7 E# ]$ Q
161. /**
     4 O2 ~5 V( m7 `& w" M! A3 Y
162.   * @}
     * H  G" l. C& J' e
163.   */
     ! r" Y3 }- I4 J7 O4 S, k4 a
164. 
     
165. #ifdef __cplusplus
       J" k  o1 X7 [5 ~- Y) V. i* x1 h
166. }
     
167. #endif
     
168. 
     
169. #endif /* __W25Qx_H */

复制代码

* E8 r7 E# b3 P) B写好的W25Qx.c放入Src文件夹内，W25Qx.h放入Inc文件夹内，之后需要在keil中加入这2个文件。

) V% Y' \9 ^; F5 X; i: |
* i, {4 O! v2 Y- Y2 {) i$ d, T; c
# E  Y5 t% I# ~$ y- K/ r# y代码
$ W2 u  z& }% O2 N- K% D0 ?本例程向1，2，3扇区中写入数据，并且读取出来，例程代码如下。
8 v4 Q6 d; J$ h% n头文件定义。

1. /* USER CODE BEGIN Includes */
   
2. #include "stdio.h"
   - \# Q# y- h8 V6 ^1 d+ z1 w
3. 
   
4. #include <string.h>
   . B0 x4 m" l7 F- p
5. #include "W25Qx.h"
   7 ?: s9 N+ ]! C# d# Q/ b% B
6. /* USER CODE END Includes */

复制代码

8 L  l  U8 H; ?6 O串口接收和flash数组定义。
  a8 O& z0 q' g  h9 v

1. /* USER CODE BEGIN PV */
   " }0 x. b3 L9 ^
2. #define BUFFERSIZE 255           //可以接收的最大字符个数      
   
3. uint8_t ReceiveBuff[BUFFERSIZE]; //接收缓冲区
   
4. uint8_t recv_end_flag = 0,Rx_len;//接收完成中断标志，接收到字符长度
   5 u) y" ]7 k0 l2 e
5. 
   : g. \. N. @( H# ~& b6 L6 `
6. uint8_t wData1[0x200];
   1 l3 r( x/ U7 q/ l5 |+ M5 F* d
7. uint8_t wData2[0x200];
   
8. uint8_t wData3[0x200];
   
9. 
   ) g0 |% ?' ]: f
10. uint8_t rData1[0x200];
    
11. uint8_t rData2[0x200];
    
12. uint8_t rData3[0x200];
    2 x$ Q: z% P8 `6 E0 t+ A
13. uint8_t ID[4];
    $ D" q  X* v, k; H4 A7 f
14. uint32_t i;
    
15. 
    
16. uint8_t flag[1] ;
    
17. int i_flag = 0;
    0 @0 T: C+ I7 @; e
18. /* USER CODE END PV */

复制代码

" p- y/ L" _& C# {$ p串口重定向。

1. /* USER CODE BEGIN PFP */
   + o: k6 w/ {6 h+ t0 \
2. void uart1_data(void);                                        //接收函数
   * D" A$ W$ d7 w: t- h
3. #ifdef __GNUC__                                                                        //串口重定向
   5 O" d; U2 z6 O
4. #define PUTCHAR_PROTOTYPE int __io_putchar(int ch)
   " V$ D1 z( @7 C
5. #else
   
6. #define PUTCHAR_PROTOTYPE int fputc(int ch, FILE *f)
   3 `: n2 A! T1 a& L, G- ]
7. #endif
   
8. PUTCHAR_PROTOTYPE
   8 r4 z. |: w, o
9. {
   ( }" z; t. z5 P+ X1 L' I9 C6 z& L
10.     HAL_UART_Transmit(&huart1 , (uint8_t *)&ch, 1, 0xFFFF);
    
11.     return ch;
    8 L6 _% m' O6 q# ^: Q  v
12. }
    
13. 
    / ?' t; n2 A/ _, u
14. /* USER CODE END PFP */

复制代码

; m5 f3 z7 M* k7 m0 r#include "stm32f0xx_it.c"文件中断外部变量引用：
- R2 ^! u9 N9 p* _; G
5 I* K7 U# H; u% E

1. /* USER CODE BEGIN 0 */
   
2. #define BUFFERSIZE 255        //可接收的最大数据量
   
3. extern uint8_t recv_end_flag,Rx_len,bootfirst;
   
4. /* USER CODE END 0 */

复制代码

. N# v+ A* _, [/ o5 v+ U- J0 |串口1中断函数：
  k! G: ~+ u; r( M/ ^- y
0 }3 e  S% E9 }$ s- S

1. /**
   
2.   * @brief This function handles USART1 global interrupt.
   . r! ]. d4 ^, f2 @& I" k+ ]; X
3.   */
   
4. void USART1_IRQHandler(void)
   
5. {
   
6.   /* USER CODE BEGIN USART1_IRQn 0 */
   ( z) n! K) J& N# m/ P7 r2 m0 ^
7. 
   6 h+ h3 S  X; P4 ~: D+ u
8.   /* USER CODE END USART1_IRQn 0 */
   9 V; j: V9 @  p' J
9.   HAL_UART_IRQHandler(&huart1);
   
10.   /* USER CODE BEGIN USART1_IRQn 1 */
    
11.         uint32_t temp;
    
12.         if(USART1 == huart1.Instance)//判断是否为串口1中断
    
13. 
    
14.         {      
    
15.                 if(RESET != __HAL_UART_GET_FLAG(&huart1,UART_FLAG_IDLE))//如果为串口1
    $ Q: d" z( T- y& t, ?) W' K
16.                 {
    1 P- L( ]0 i6 o
17.                         __HAL_UART_CLEAR_IDLEFLAG(&huart1);//清除中断标志
    
18.       HAL_UART_DMAStop(&huart1);//停止DMA接收
    
19.                      temp  = __HAL_DMA_GET_COUNTER(&hdma_usart1_rx);//获取DMA当前还有多少未填充
    
20.                       Rx_len =  BUFFERSIZE - temp; //计算串口接收到的数据个数
    
21.                       recv_end_flag = 1;
    
22.              }
    8 q! Q$ N6 n( h+ J$ F. v# [! [4 s. g
23.         }        
    ( V# B, F1 F. U2 A; p
24.   /* USER CODE END USART1_IRQn 1 */
    ! `7 ?, U% l  ?1 s
25. }
    - U/ v& i7 z( O$ H# A" p: h9 h

复制代码

在main.c函数中，初始化串口和W25Q128。
' t, K5 k' m# [/ B. ]! U
  u3 p. }; c2 r* ~  N9 R! f4 b

1.   /* USER CODE BEGIN 2 */
   # B1 s7 m+ J$ @' U/ W- g/ l
2.         printf("串口1DMA例程\n");
   4 E* Q( z; _7 M% o
3.   __HAL_UART_ENABLE_IT(&huart1, UART_IT_IDLE);//使能串口1 IDLE中断
   
4.         
   # U# Z; |6 M5 \
5.         
   % z  m# T) [' ~! h. [4 g
6.         
   , t% T. r, ]2 M( L
7.         
   2 ]- u: v  y9 w
8.                 printf("\r\n SPI-W25Q128读写\n");
   + f  ?1 n7 }' u0 O) k& c
9. 
   3 O1 r7 T0 X: C
10.         /*##-1- Read the device ID  ########################*/
      l. S8 p# w5 Z$ U8 k! d8 h
11.         BSP_W25Qx_Init();//初始化W25Q128
    
12.         BSP_W25Qx_Read_ID(ID);//读取ID
    & t; F+ @# f4 J* ]
13. 
    
14.         if((ID[0] != 0xEF) | (ID[1] != 0x17))
    
15.         {
    * Z! r4 A$ c8 O0 w- e
16.                 Error_Handler();//如果 ID不对打印错误
    ' z  P5 [' H# l
17.         }
    1 e0 P$ P8 @7 t
18.         else//ID正确，打印ID
    1 q9 t% ~& g8 Z; N+ |/ k
19.         {
    
20.                 printf("W25Q128 ID : ");
    
21.                 for(i=0;i<2;i++)
    7 P* M  f6 B- U6 K: n. L. R/ t7 Z# a
22.                 {
    + ]  W$ ]5 O( |* D% C' F/ U
23.                         printf("0x%02X ",ID<i>);
    6 d/ ]4 l5 r! P; ^6 H$ i# b
24.                 }
    ! h! j# e/ ?: Q
25.                 printf("\r\n\r\n");
    
26.         }
    
27. 
    ) y# v) Z; }& D/ j
28. /**************************读取第1扇区数据**************************************************************/
    $ d0 {. w5 q9 X' G6 a; v7 Q
29. 
    
30.         /*##-3- Read the flash     ########################*/
    
31.         /*读取数据，rData读取数据的指针，起始地址0x00，读取数据长度0x200*/
    
32.         if(BSP_W25Qx_Read(rData1,0x0,0x200)== W25Qx_OK)
    
33.                 printf("读取原始的前1个扇区数据成功！\n");
    
34.         else
    " p! {# V3 e( R2 W4 I. z
35.                 Error_Handler();
    8 `, ~0 }& I5 p' l+ Z  m2 C5 S) `
36.         /*打印数据*/        
    * ?0 g3 Y6 `, U# x( l/ C
37.         printf("读取原始的前1个扇区数据为: \r\n");
    & p% [9 }4 `( w# m7 X: v$ P
38.         
    
39.         for(i =0;i<0x200;i++)
    
40.         {
    
41.                 if(i%20==0)
    
42.                         printf("\n1扇区第%d到%d的数据为：\r\n",i,i+19);
    
43.                                 printf("0x%02X  ",rData1<i>);
    
44.         }
    
45. 
    
46.         printf("\n");
    + T" D! V5 ?7 v* M7 ?; s
47. 
    + Y8 I8 y# y$ b, v. p
48.         
    
49. /**************************读取第2扇区数据**************************************************************/
    
50.         
    
51.         /*##-3- Read the flash     ########################*/
    5 a# [# U$ r0 D5 u+ g
52.         /*读取数据，rData读取数据的指针，起始地址0x1000，读取数据长度0x200*/
    8 m* p" X7 g7 e. O, x
53.         if(BSP_W25Qx_Read(rData2,0x1000,0x200)== W25Qx_OK)
    ! o. u5 o6 s' ^7 ~
54.                 printf("读取原始的前2个扇区数据成功！\n");
    5 q( \. j. j3 b5 y- j
55.         else
    
56.                 Error_Handler();
    
57.         /*打印数据*/        
    
58.         printf("读取原始的前2个扇区数据为:");
    
59.         
    
60.         for(i =0;i<0x200;i++)
    3 e0 g  M; b/ x8 S+ s
61.         {
    9 X: F, e# U7 S$ j
62.                 if(i%20==0)
    
63.                         printf("\n2扇区第%d到%d的数据为：\r\n",i,i+19);
    . l6 f4 W, j0 K& O. `& ^  E
64.                                 printf("0x%02X  ",rData2<i>);
    
65.         }
    
66. 
    
67.         printf("\n");        
      X3 u2 J$ w) j. _* C8 u9 i8 p
68.         
    # X0 u* _& V( J* [& b( o
69.         
    / `2 K9 Z$ h6 H% n# }& [6 x: W
70. /**************************读取第3扇区数据**************************************************************/
    
71.         
    6 C  I0 u: D' F5 f; l& I
72.         /*##-3- Read the flash     ########################*/
    
73.         /*读取数据，rData读取数据的指针，起始地址0x2000，读取数据长度0x200*/
    
74.         if(BSP_W25Qx_Read(rData3,0x2000,0x200)== W25Qx_OK)
    : w" a' j/ ~4 @5 h0 ^
75.                 printf("读取原始的前3个扇区数据成功！\n");
    0 I2 q( h7 _' n' n/ d" q4 ]) {
76.         else
    
77.                 Error_Handler();
    
78.         /*打印数据*/        
    9 X4 O8 O6 f# w- o. ?2 n+ h
79.         printf("读取原始的前3个扇区数据为: ");
    
80.         
    
81.         for(i =0;i<0x200;i++)
    + i2 c7 Y5 V( K  l7 x, S
82.         {
    
83.                 if(i%20==0)
    
84.                         printf("\n3扇区第%d到%d的数据为：\r\n",i,i+19);
    , H1 C7 N6 Q4 Z
85.                                 printf("0x%02X  ",rData3<i>);
    
86.         }
      ~- O5 q8 J' o. Z
87. 
    " d0 E1 b4 [% p" _  e) x
88.         printf("\n");        
    
89.         
    ) |, o# g+ h9 D- @: ~
90.         
    
91. 
    
92. /**************************清除第1扇区数据为0**************************************************************/
    
93. 
    ( u# I2 J  |( Q
94. 
    4 B  ~) B3 l8 Z* y& A) ^
95.         
    9 c  ~1 T& r9 e. O
96.         /*##-2- Erase Block ##################################*/
    4 }6 l1 n- ]! I/ Z( |
97.         if(BSP_W25Qx_Erase_Block(0) == W25Qx_OK)
    
98.                 printf(" QSPI Erase Block ok\r\n");
    0 Q9 y& R( o0 m/ `4 I! _3 {
99.         else
    
100.                 Error_Handler();
     
101.         
     3 m9 q0 z9 U, h; q
102.         /*##-2- Written to the flash ########################*/
     8 u, V& B/ d( T+ W4 [7 V1 {
103.         /* fill buffer */
     
104.         printf(" 初始化数据，清零第1扇区前0x200的数据！\r\n");
     2 L3 R% u: V* X0 C9 ~
105.         for(i =0;i<0x200;i ++)
     
106.         {
     7 c# S- k2 Q. `7 }) v* z
107.                         wData1<i> = 0;
     $ c* ^+ y9 N  o; Q& z5 T  C% L0 e
108.                   rData1<i> = 0;
     
109.         }
     
110.         /*写入数据，wData写入数据的指针，起始地址0x00，写入数据长度0x200*/
     
111.         if(BSP_W25Qx_Write(wData1,0x00,0x200)== W25Qx_OK)
     
112.                 printf("清零第1扇区前0x200的数据成功！\r\n");
     . i* V6 p6 C0 k# p, |: X0 t* |
113.         else
     7 Q! d. F0 R/ Z' |! f: b
114.                 Error_Handler();
     - `3 O" U! f& T* b" }
115. 
     - H( V7 G! N2 K" X) x& T* s  t
116.         
     ) r- ~* n6 ?+ B! B
117.         
     5 Y' H9 y& r% B. ?% k4 z; t
118.         
     
119.         /*##-3- Read the flash     ########################*/
     
120.         /*读取数据，rData读取数据的指针，起始地址0x00，读取数据长度0x200*/
     " n( m9 b! a) L3 l0 C, l
121.         if(BSP_W25Qx_Read(rData1,0x00,0x200)== W25Qx_OK)
     5 T( F: `' H# A2 c  H
122.                 printf("读取第1扇区前0x200数据成功！\r\n\r\n");
     9 R8 e4 N1 {/ F# S  M3 d( u+ |  Z
123.         else
     
124.                 Error_Handler();
     3 r. K# @, Y/ Q/ f9 w5 G
125.         /*打印数据*/        
     
126.         printf("读取第1扇区前0x200数据为: \r\n");
     
127.         
     
128.         for(i =0;i<0x200;i++)
     " `# f7 p  F) S% x) ?0 U
129.         {
     ; i2 `' P% @1 `4 I; Z6 Q
130.                 if(i%20==0)
     
131.                         printf("\n第%d到%d的数据为：\r\n",i,i+19);
     2 K) @$ D$ N$ Y5 Q* x% J
132.                                 printf("0x%02X  ",rData1<i>);
     7 ]1 X1 m5 ^. [* J& n  ~
133.         }
     8 L' Y: A, S/ l
134. 
     
135.         printf("\n");
     % I' T. \; s7 M! R) v/ ?
136. 
     
137. 
     
138. /**************************清除第2扇区数据为0**************************************************************/
     
139. 
     
140. 
     
141.         
     - H6 a0 n* r2 M' K: l- ]$ n
142.         /*##-2- Erase Block ##################################*/
     * I" s8 r: N3 u, @2 b6 v0 W
143.         if(BSP_W25Qx_Erase_Block(0x1000) == W25Qx_OK)
     ' x- M; U2 o5 _+ A4 Q7 u
144.                 printf(" QSPI Erase Block ok\r\n");
     
145.         else
     ) }# _/ y2 O, a; Q6 W" i
146.                 Error_Handler();
     + L; c; T# @$ [  U1 W
147.         
     ( P$ I# u: _' B) L* X! h
148.         /*##-2- Written to the flash ########################*/
     
149.         /* fill buffer */
     
150.         printf(" 初始化数据，清零第2扇区前0x200的数据！\r\n");
     / K4 b, D8 w2 s( ~& d  P9 I0 A# X
151.         for(i =0;i<0x200;i ++)
     
152.         {
     
153.                         wData2<i> = 0;
     0 Q2 ^5 k7 V6 j" e, [! \
154.                   rData2<i> = 0;
     ( H/ E; D; \3 P# e
155.         }
     
156.         /*写入数据，wData写入数据的指针，起始地址0x1000，写入数据长度0x200*/
     
157.         if(BSP_W25Qx_Write(wData2,0x1000,0x200)== W25Qx_OK)
     0 Y4 ^8 X0 i5 Y/ q- B. I' T
158.                 printf("清零第2扇区前0x200的数据成功！\r\n");
     
159.         else
     
160.                 Error_Handler();
     0 V* L5 W8 \$ |/ |6 I
161. 
     * i$ K/ d8 }4 x) G' P4 T
162.         
     / v0 [& W. y  U2 @0 `
163.         
     * v( D, J; H" z; t7 z7 T
164.         
     
165.         /*##-3- Read the flash     ########################*/
     7 c2 v' c8 j# a) B9 l3 F4 }
166.         /*读取数据，rData读取数据的指针，起始地址0x00，读取数据长度0x200*/
     ! t  P1 N# R& L" h# T5 q
167.         if(BSP_W25Qx_Read(rData2,0x1000,0x200)== W25Qx_OK)
     
168.                 printf("读取第2扇区前0x200数据成功！\r\n\r\n");
     
169.         else
     
170.                 Error_Handler();
     
171.         /*打印数据*/        
     / m* `8 b8 x4 C+ f  r( A  H4 w! E
172.         printf("读取第2扇区前0x200数据为: \r\n");
     
173.         
     ! F% j4 L$ z: l7 L0 U) H
174.         for(i =0;i<0x200;i++)
     " D" w1 P4 T9 e8 r
175.         {
     + U& H) O8 G; d
176.                 if(i%20==0)
     
177.                         printf("\n第%d到%d的数据为：\r\n",i,i+19);
     
178.                                 printf("0x%02X  ",rData2<i>);
     4 f( b9 j% Q0 h/ V1 n: F
179.         }
     , a$ C) X" v( k- d* D
180. 
     " V0 r. k! _- W6 ?1 l
181.         printf("\n");
     3 }# f4 N1 E& F6 n5 O$ V
182. 
     
183. 
     1 S, O* Y( C4 u6 k; [& _. O
184. /**************************清除第3扇区数据为0**************************************************************/
     
185. 
     ; k' H- m0 |" E, ~
186. 
     
187.         
     
188.         /*##-2- Erase Block ##################################*/
     
189.         if(BSP_W25Qx_Erase_Block(0x2000) == W25Qx_OK)
     8 z! A! r% S% R6 J, k7 ^
190.                 printf(" QSPI Erase Block ok\r\n");
     
191.         else
     
192.                 Error_Handler();
     2 q3 z) c: y) r; p3 \' E
193.         
     
194.         /*##-2- Written to the flash ########################*/
     
195.         /* fill buffer */
       x( A! ?% V, d; i
196.         printf(" 初始化数据，清零第3扇区前0x200的数据！\r\n");
     " i5 r& |1 N9 a# x% T* H
197.         for(i =0;i<0x200;i ++)
     / F: H, q( @! T5 ~- [
198.         {
     
199.                         wData3<i> = 0;
     
200.                   rData3<i> = 0;
     
201.         }
     " k, I" b8 Y7 }* j- G) G
202.         /*写入数据，wData写入数据的指针，起始地址0x2000，写入数据长度0x200*/
     
203.         if(BSP_W25Qx_Write(wData3,0x2000,0x200)== W25Qx_OK)
     $ v$ x7 z" ?. y' H. G3 W
204.                 printf("清零第3扇区前0x200的数据成功！\r\n");
     ( |& T/ z$ u+ d" Q8 m# ?. t
205.         else
     ; g/ W8 T# c' Z7 s2 A- _
206.                 Error_Handler();
     2 y: {) r3 B  p9 b6 G/ D4 y5 r
207. 
     
208.         
     1 n4 e/ f9 r. M" D2 ^0 r- i
209.         
     , j! {3 u! y* k7 s. c7 Y
210.         
     & |7 M9 d& c6 m3 z6 \* T5 }: Q9 l7 ^8 u
211.         /*##-3- Read the flash     ########################*/
     0 d& `* K+ ~& A4 K
212.         /*读取数据，rData读取数据的指针，起始地址0x00，读取数据长度0x200*/
     * s1 r: P7 A) ]# L0 B
213.         if(BSP_W25Qx_Read(rData3,0x2000,0x200)== W25Qx_OK)
     
214.                 printf("读取第3扇区前0x200数据成功！\r\n\r\n");
     
215.         else
     ; f5 [7 o( }; [; a+ q
216.                 Error_Handler();
     
217.         /*打印数据*/        
     
218.         printf("读取第3扇区前0x200数据为: \r\n");
     ! Y2 G6 Q: I- M9 C# q6 T
219.         
     
220.         for(i =0;i<0x200;i++)
     3 Q" V0 z$ C1 W0 {& P
221.         {
     + i+ l# n% V8 X# [
222.                 if(i%20==0)
     3 D; \; P8 x9 G, Y2 K' f
223.                         printf("\n第%d到%d的数据为：\r\n",i,i+19);
     ' \& ?. L) L4 A% L
224.                                 printf("0x%02X  ",rData3<i>);
     8 j) K0 x, W7 N
225.         }
     5 J# G$ z& l0 `; N3 r
226. 
     
227.         printf("\n");
     
228. 
     + A4 v5 i$ J9 n* N, M
229.         
     # M( l5 A( k# ?) t' j  w
230.   /* USER CODE END 2 */</i></i></i></i></i></i></i></i></i></i></i></i></i>

复制代码

7 v( x' _0 w+ m# _! N主程序。

. H9 ?+ Y- R6 F  E' w6 |

1.   /* USER CODE BEGIN WHILE */
   
2.   while (1)
   ) T. w/ y5 w  k- o" |
3.   {
     c9 J1 k, D% b2 N3 g. U
4.     /* USER CODE END WHILE */
   
5. 
   
6.     /* USER CODE BEGIN 3 */
   , D; J* p3 V# B! f# W
7. 
   8 {+ B9 l7 A9 c- U$ R3 R; G" m- q. b
8.                 uart1_data();//串口数据处理
   
9.                 HAL_GPIO_WritePin(GPIOA,GPIO_PIN_5,GPIO_PIN_SET);
   
10.     HAL_Delay(100);
    
11. 
    
12.                 HAL_GPIO_WritePin(GPIOA,GPIO_PIN_5,GPIO_PIN_RESET);
    
13.                 HAL_Delay(100);
    
14. 
    
15.   }
      u, o6 ?  z: \- v. Y+ x
16.   /* USER CODE END 3 */

复制代码

6 ?) C$ W0 I3 _$ Z$ x演示效果
5 [9 _4 |, n! m+ i* n4 J7 W+ qW25Q128芯片型号的ID为0XEF17，下方读取为0XEF17，所以读取成功。
开机会打印出1，2，3扇区的前0x200个数据，即打印2页的数据。


打印完原始数据之后将数据全部清零，清零完成如下图所示。

" L) a1 ]0 |8 N+ Q# ?( @4 O7 k1 [' E

串口定义了ReceiveBuff[0]的数据为写入什么扇区，ReceiveBuff[0]为1写入扇区1，ReceiveBuff[0]为2写入扇区2，ReceiveBuff[0]为3写入扇区3，若为其他数据，则打印输入错误；ReceiveBuff[1]则为写入的位置。
) x$ ?" p# _" {. t0 i' I输入：01 05 01 02 03 04
' h& Q# z8 P- S7 W# Q" @+ K向扇区1的的05号位置开始写入数据01 02 03 04。



( Q, y% D! S# X6 Y7 @: M2 f输入：01 28 11 12 13 14 15
$ q# @3 T. m$ R: {: R向扇区1的的40(28是十六进制)号位置开始写入数据11 12 13 14 15。
0 h( K' T5 B1 z! W3 y
6 o/ X& N9 N0 L! y6 @
+ M7 [% |7 p+ o" c' L- d, T
  G# a% J* J  p$ q9 ~. G; i. q3 \: c) ]输入：03 10 aa bb
向扇区3的的16(10是十六进制)号位置开始写入数据aa bb。


$ k  \) z" v' n; @* Z; K

. N. F4 j1 r& f9 }) M# s