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

" z* `8 m9 |8 E* c生成例程
使用STM32CUBEMX生成例程，这里使用NUCLEO-F103RB开发板
) W3 k$ K* F8 A8 Z2 l. s0 {


配置时钟树，配置时钟为64M。



查看原理图，PA2和PA3设置为开发板的串口。
, @0 g" n! o! @4 K  t


配置串口。
" e: A8 E$ H. W+ C% ], k


由于需要输入数据，开启DMA进行接收。
. i2 M( U* h% Q* }/ t
. L7 y' U$ R1 E. D0 G" o8 t9 }  ^
1 `3 _0 Q( w! O/ E7 M& y  M
中断。

. I: T2 p2 y$ c3 [

SPI配置
" ^+ A1 _& l* G* x) \在开发板中有arduino接口，配置这几个接口为spi。
" P) ~- \3 W5 j" x

% \* K. y6 v) u# B. a$ l4 {. a

6 J9 \$ [) d) b. ]5 f$ s2 R本次实验使用的SPI与Flash通信，配置如下。
( _3 r9 w+ b/ X8 b; ]0 p- S: I7 ySPI的通信原理很简单，它以主从方式工作，这种模式通常有一个主设备和一个或多个从设备，需要至少4根线，事实上3根也可以（单向传输时）。也是所有基于SPI的设备共有的，它们是MISO（主设备数据输入）、MOSI（主设备数据输出）、SCLK（时钟）、CS（片选）。
% W% H9 M9 R6 i6 {8 a（1）MISO– Master Input Slave Output,主设备数据输入，从设备数据输出；
（2）MOSI– Master Output Slave Input，主设备数据输出，从设备数据输入；
( Y/ S; |' O. V4 m2 O8 z（3）SCLK – Serial Clock，时钟信号，由主设备产生；
' f3 W* ~5 v6 |1 O& V; g（4）CS – Chip Select，从设备使能信号，由主设备控制。
0 ~/ T( v& l$ D2 S1 I
0 U. U5 x! C3 }8 V( v
; E; m9 n4 C$ r, Z2 |  n; m" D
9 k+ A7 }/ e: c7 m' k0 h. _% P负责通讯的3根线了。通讯是通过数据交换完成的，这里先要知道SPI是串行通讯协议，也就是说数据是一位一位的传输的。这就是SCLK时钟线存在的原因，由SCLK提供时钟脉冲，SDI，SDO则基于此脉冲完成数据传输。数据输出通过 SDO线，数据在时钟上升沿或下降沿时改变，在紧接着的下降沿或上升沿被读取。完成一位数据传输，输入也使用同样原理。因此，至少需要8次时钟信号的改变（上沿和下沿为一次），才能完成8位数据的传输。
8 J7 r3 Z& i8 {3 h2 ]时钟信号线SCLK只能由主设备控制，从设备不能控制。同样，在一个基于SPI的设备中，至少有一个主设备。这样的传输方式有一个优点，在数据位的传输过程中可以暂停，也就是时钟的周期可以为不等宽，因为时钟线由主设备控制，当没有时钟跳变时，从设备不采集或传送数据。SPI还是一个数据交换协议：因为SPI的数据输入和输出线独立，所以允许同时完成数据的输入和输出。芯片集成的SPI串行同步时钟极性和相位可以通过寄存器配置，IO模拟的SPI串行同步时钟需要根据从设备支持的时钟极性和相位来通讯。
* S  r7 ^# M( F/ X3 ]* @, n最后，SPI接口的一个缺点：没有指定的流控制，没有应答机制确认是否接收到数据。
) I2 T  }# M' l+ T4 }/ E+ k
) t7 r% E+ f' ~2 b
9 k+ [- h( A( \! `- ?' E+ `# h' x& @; d
7 F/ I* A! G. _4 o其中，CS是从芯片是否被主芯片选中的控制信号，也就是说只有片选信号为预先规定的使能信号时（高电位或低电位），主芯片对此从芯片的操作才有效。这就使在同一条总线上连接多个SPI设备成为可能。
" I7 D! h4 v% w* u0 Y1 p7 I& }随便配置一个端口为CS片选，并且命名为CS。


- L- F7 j/ r; Q' g& x4 h* x$ I
NOR Flash
NOR Flash是一种非易失闪存技术，是Intel在1988年创建。是市场上两种主要的非易失闪存技术之一。
以GD25Q64E为例，该 Flash为64M-bit大小，即8192K-Byte。
8 j% L) H5 p+ V9 y; A! h3 _
  |5 k; \3 K- V" w2 D3 X0 M( P
) ]. J$ A3 o; E5 W5 R' E0 Z

W25Q64将8M的容量分为127个块（Block),每个块大小为64K字节，每个块又分为16个扇区（Sector),每个扇区4K个字节。W25Q64的最小擦除单位为一个扇区，也就是每次必须擦除4K个字节。
即4K16128=8192K=8M
& [+ Y" X: u7 J' ]


W25Q64的原理及应用
复位初始化
对于复位，需要发送0x66和0x99

1 o. }8 ]  U; b

! R0 a1 @3 {$ U6 S7 i; {& l5 a1 ^; ^代码中的初始化。
1 F1 L/ {* |& l# Z& O- _9 F" |

1. /* Reset Operations */
   
2. #define RESET_ENABLE_CMD                     0x66
   
3. #define RESET_MEMORY_CMD                     0x99
   ) R& X4 A6 \" K1 s6 ^" l* f% \, l
4. /**
   
5.   * @brief  Initializes the W25Q128FV interface.
   
6.   * @retval None
   ; C! R  i4 r5 c: z9 T  V
7.   */
   
8. uint8_t BSP_W25Qx_Init(void)
   
9. {
   
10.         /* Reset W25Qxxx */
    
11.         BSP_W25Qx_Reset();
    
12.         
    . A# _- ]7 C! u' }. V2 ^
13.         return BSP_W25Qx_GetStatus();
    
14. }
    2 D1 s$ T, N. A- W+ K
15. 
    
16. /**
    - _  N* A! i0 @6 [. z0 I
17.   * @brief  This function reset the W25Qx.
    
18.   * @retval None
    
19.   */
    
20. static void        BSP_W25Qx_Reset(void)
    
21. {
      [) ]9 |4 O+ \7 Y; |+ H; {; A
22.         uint8_t cmd[2] = {RESET_ENABLE_CMD,RESET_MEMORY_CMD};
    7 j  [5 P# z* t8 m3 \; S
23.         
    
24.         W25Qx_Enable();
    
25.         /* Send the reset command */
    
26.         HAL_SPI_Transmit(&hspi1, cmd, 2, W25Qx_TIMEOUT_VALUE);        
    
27.         W25Qx_Disable();
    ' g7 ?4 l. w" D& w5 ]5 z. r
28. 
    5 G! H: c" i* u) Q
29. }

复制代码

* t/ E2 l- ]; Q- {5 eID
9 b) f" z/ s# w对于兆易创新W25Q64，主要有三种查询ID方式。


- o4 |8 z  q  _% Z* X; I, X
可以使用90H查询设备ID，以判断是否是W25Q64设备。
% C+ @  H, _/ w* {- R# j# P8 m
; C* B! j7 p) p$ [+ x; T

1. 
   
2. /* Identification Operations */
   
3. #define READ_ID_CMD                          0x9F
   
4. /**
   
5.   * @brief  Read Manufacture/Device ID.
   8 ?- I% i3 W( T6 M! L2 \' a7 a
6.         * @param  return value address
   
7.   * @retval None
   
8.   */
   
9. void BSP_W25Qx_Read_ID(uint8_t *ID)
   0 [  @6 z/ O0 _- n
10. {
      i, ?, d2 ^8 n) K) q
11.         uint8_t cmd[4] = {READ_ID_CMD,0x00,0x00,0x00};
    
12.         
    5 V# O6 Y3 Y' q4 l
13.         W25Qx_Enable();
    
14.         /* Send the read ID command */
    
15.         HAL_SPI_Transmit(&hspi1, cmd, 4, W25Qx_TIMEOUT_VALUE);        
    4 M: H/ p$ V/ G) F" W
16.         /* Reception of the data */
    
17.         HAL_SPI_Receive(&hspi1,ID, 2, W25Qx_TIMEOUT_VALUE);
    * U/ S+ \6 Z& a
18.         W25Qx_Disable();
    
19.                
    
20. }

复制代码

* p! z+ e+ _6 I+ }# E
6 p$ ?8 _( a/ U! s5 x

读取数据
/ `5 z! m$ ]2 A; w. f对于兆易创新W25Q64，读取数据使用0x03指令，后面添加需要读取的数据地址。
( n! ?+ Y! L4 r; g( L数据可以一直进行读取，当不需要读取数据时候将片选CS拉高，关闭时钟SCLK即可。
3 j$ i3 {# o2 @; ^2 B1 }

1. #define READ_CMD                             0x03
   
2. 
   
3. /**
   
4.   * @brief  Reads an amount of data from the QSPI memory.
   
5.   * @param  pData: Pointer to data to be read
   
6.   * @param  ReadAddr: Read start address
   " r7 T7 O! w! M
7.   * @param  Size: Size of data to read   
   
8.   * @retval QSPI memory status
   
9.   */
   
10. uint8_t BSP_W25Qx_Read(uint8_t* pData, uint32_t ReadAddr, uint32_t Size)
    
11. {
    6 M+ l1 v7 |5 G$ g! F
12.         uint8_t cmd[4];
    + Q/ E- p: w/ B! a' L% i
13. 
    
14.         /* Configure the command */
    
15.         cmd[0] = READ_CMD;
    , j6 k& m( b. V- h
16.         cmd[1] = (uint8_t)(ReadAddr >> 16);
    
17.         cmd[2] = (uint8_t)(ReadAddr >> 8);
    % d' u5 q4 j8 [0 [" t) W
18.         cmd[3] = (uint8_t)(ReadAddr);
    
19.         
    
20.         W25Qx_Enable();
    / o  A7 r/ ~1 p4 k6 `# ~7 }' ]
21.         /* Send the read ID command */
    
22.         HAL_SPI_Transmit(&hspi1, cmd, 4, W25Qx_TIMEOUT_VALUE);        
    
23.         /* Reception of the data */
    5 u" n; j/ e" j' r5 I/ H
24.         if (HAL_SPI_Receive(&hspi1, pData,Size,W25Qx_TIMEOUT_VALUE) != HAL_OK)
    " B1 K2 f/ I. `
25.   {
    
26.     return W25Qx_ERROR;
    / U( X( N* B! {- x$ U' d; a4 ~( }! M
27.   }
    
28.         W25Qx_Disable();
    2 a/ `7 z0 z  L8 \
29.         return W25Qx_OK;
    
30. }
    

复制代码

# r  g' Z- F% H9 e* h' D# w" B, y以读取10个数据为例子，波形如下所示。
0 w$ U1 p3 W) W: Y+ y! x7 S1 ~# c

1. BSP_W25Qx_Read(rData2,0x1000,0x00a);   

复制代码

   
/ J3 Q. Z' v! C8 i- X
; E$ s0 u& w# ^8 x0 s, V) V
擦除扇区
# \! R# z' j* ?+ C最小的擦除单位是扇区，擦除指令为0x20和3字节的地址。
! s2 L8 `+ V. p5 h5 ?1 b

  w6 K/ O$ y" M7 K) n, H
  B+ \8 _: o# J" Y: M

1. #define SECTOR_ERASE_CMD                     0x20
   
2. uint8_t BSP_W25Qx_Erase_Block(uint32_t Address)
   
3. {
   
4.         uint8_t cmd[4];
   
5.         uint32_t tickstart = HAL_GetTick();
   
6.         cmd[0] = SECTOR_ERASE_CMD;
   
7.         cmd[1] = (uint8_t)(Address >> 16);
   
8.         cmd[2] = (uint8_t)(Address >> 8);
   1 A/ ]9 W6 ~$ m. J
9.         cmd[3] = (uint8_t)(Address);
   
10.         
    6 W0 S; z2 V2 L: u7 n+ e
11.         /* Enable write operations */
    
12.         BSP_W25Qx_WriteEnable();
    / y- l: e4 s) y" @
13.         
    # w7 V. m" r' S: g2 @' t# r$ q$ w
14.         /*Select the FLASH: Chip Select low */
    9 R% T8 c4 D" v' a* _
15.         W25Qx_Enable();
    
16.         /* Send the read ID command */
    : M7 p5 Z9 p, G7 b. r
17.         HAL_SPI_Transmit(&hspi1, cmd, 4, W25Qx_TIMEOUT_VALUE);        
    
18.         /*Deselect the FLASH: Chip Select high */
    0 {# D% A, o0 \) b/ V# M
19.         W25Qx_Disable();
    - Q: ]* g& J8 ?7 p3 S  w/ `& O1 S
20.         
    
21.         /* Wait the end of Flash writing */
    
22.         while(BSP_W25Qx_GetStatus() == W25Qx_BUSY);
    
23.         {
    
24.                 /* Check for the Timeout */
    
25.     if((HAL_GetTick() - tickstart) > W25Q128FV_SECTOR_ERASE_MAX_TIME)
    
26.     {        
    
27.                         return W25Qx_TIMEOUT;
    
28.     }
    
29.         }
    
30.         return W25Qx_OK;
    
31. }

复制代码

* W( K1 j$ {+ O! J
1 {/ l1 ]! h& Z1 R& A

) h% t3 x' \* Z, I+ H: J写数据
对于写数据到flash中，使用0x02指令进行写数据，后面还需要指定24位地址，才能进行写数据。
8 K/ a3 _% ^4 C7 v; i# W' b

3 q& x; V* Y# a$ L/ l: R

1. #define PAGE_PROG_CMD                        0x02
   : f/ X4 Q$ I/ D, B: C' }
2. /**
   $ s  U/ J7 s7 o5 D, i  Y3 z2 E0 n, g
3.   * @brief  Writes an amount of data to the QSPI memory.
   
4.   * @param  pData: Pointer to data to be written
   
5.   * @param  WriteAddr: Write start address
   
6.   * @param  Size: Size of data to write,No more than 256byte.   
   5 P0 I+ d+ T3 H* g* |' J9 u) ]% a
7.   * @retval QSPI memory status
   6 q4 }% l( v! }, U
8.   */
   
9. uint8_t BSP_W25Qx_Write(uint8_t* pData, uint32_t WriteAddr, uint32_t Size)
   ) r2 q- N$ x, O0 G
10. {
    # r1 n3 f1 [2 l1 E
11.         uint8_t cmd[4];
    
12.         uint32_t end_addr, current_size, current_addr;
    & U! V# c! s4 {! ?
13.         uint32_t tickstart = HAL_GetTick();
    , ~7 d% A3 t6 d' {
14.         
    
15.         /* Calculation of the size between the write address and the end of the page */
    
16.   current_addr = 0;
    
17. 
    
18.   while (current_addr <= WriteAddr)//判断地址属于哪一扇区开始
    
19.   {
    
20.     current_addr += W25Q128FV_PAGE_SIZE;//0x100-> 256 bytes
    
21.   }
    
22.   current_size = current_addr - WriteAddr;
    % c' j$ G1 B) n' a8 X
23. 
    7 p' ~$ B* w+ T/ H! B
24.   /* Check if the size of the data is less than the remaining place in the page */
    
25.   if (current_size > Size)
    % A# K+ u5 X0 P+ m0 m
26.   {
    
27.     current_size = Size;
    1 s" i- T5 f  |: X1 ]' m/ @$ a) D* Q
28.   }
    
29. 
    ; Y- F, P5 j, I$ J) |
30.   /* Initialize the adress variables *///写入地址大小范围
    $ B3 i- U# V/ F
31.   current_addr = WriteAddr;
    
32.   end_addr = WriteAddr + Size;
    
33.         
    - X, L1 X4 d( [) Q8 m# c/ p
34.   /* Perform the write page by page */
    
35.   do
    
36.   {
    4 A, j1 Z" ^) _  E, J% E
37.                 /* Configure the command */
    + {# [& M6 M! i& w) R2 L% [
38.                 cmd[0] = PAGE_PROG_CMD;
    1 v" G3 ?! m4 _( o* r: z& r
39.                 cmd[1] = (uint8_t)(current_addr >> 16);
    
40.                 cmd[2] = (uint8_t)(current_addr >> 8);
    
41.                 cmd[3] = (uint8_t)(current_addr);
    # W' N) ^& P7 Y0 }1 d. F1 A+ I
42. 
    ) |7 E; A+ l6 S9 M
43.                 /* Enable write operations */
    2 F# O" U4 F& p* F2 g
44.                 BSP_W25Qx_WriteEnable();
    
45.         
    
46.                 W25Qx_Enable();
    
47.     /* Send the command */
    ' [% s) q+ R# g+ w/ U7 V
48.     if (HAL_SPI_Transmit(&hspi1,cmd, 4, W25Qx_TIMEOUT_VALUE) != HAL_OK)
    
49.     {
    
50.       return W25Qx_ERROR;
    ' a; F: t0 w5 I* c+ V# ~  y
51.     }
    
52. 
    + c$ T$ U" U+ s+ v! U/ T
53.     /* Transmission of the data */
    
54.     if (HAL_SPI_Transmit(&hspi1, pData,current_size, W25Qx_TIMEOUT_VALUE) != HAL_OK)
    5 ~0 l9 W. n3 g1 ^% Z+ y
55.     {
    4 r  y( S$ o) g! B& V
56.       return W25Qx_ERROR;
    
57.     }
    
58.                         W25Qx_Disable();
    4 V% o- ?# N& C1 {& b( C6 E
59.             /* Wait the end of Flash writing */
    
60.                 while(BSP_W25Qx_GetStatus() == W25Qx_BUSY);
    ( h8 v7 ~4 j# Q. U5 a* P' c2 q
61.                 {
    ) l  D1 V, F) [% ~2 h6 o; H
62.                         /* Check for the Timeout */
    8 ]* ?. R' |: H+ ]: R: e& e9 h
63.                         if((HAL_GetTick() - tickstart) > W25Qx_TIMEOUT_VALUE)
    8 W9 l6 e% a0 k& y" S  d. o8 u7 f
64.                         {        
    
65.                                 return W25Qx_TIMEOUT;
    
66.                         }
      |9 Z9 M/ q- Q+ T
67.                 }
    
68. 
    ' S6 S; I3 i! w: D
69.     /* Update the address and size variables for next page programming */
    
70.     current_addr += current_size;
    
71.     pData += current_size;
    5 {( B9 R8 F3 x, p; ^1 U' P0 r/ n
72.     current_size = ((current_addr + W25Q128FV_PAGE_SIZE) > end_addr) ? (end_addr - current_addr) : W25Q128FV_PAGE_SIZE;
    + h: u0 c: o! E$ _) T
73.   } while (current_addr < end_addr);
      m& V0 r" X" }
74. 
    
75.         
    . I4 n( U* e6 g
76.         return W25Qx_OK;
    
77. }

复制代码

对flash的0x1000地址进行写数据，指令如下。

' D/ d3 d( o) {7 {' v

1. BSP_W25Qx_Write(wData2,0x1000,0x000a);

复制代码

! A  D/ V$ G0 ~& A6 i" @波形如下所示。
% g+ z) w; ~/ z/ t


2 A& Y7 @. Q; x8 h5 \+ \W25Qx.c

1. /*********************************************************************************************************
   . m9 K. H, s& F: {
2. *
   . j( N" E  U4 B. n1 o
3. * File                : ws_W25Qx.c
   
4. * Hardware Environment:
   ; u" _4 t: u# c7 B- G/ g* `
5. * Build Environment   : RealView MDK-ARM  Version: 4.20
   
6. * Version             : V1.0
   # |  O8 [6 J9 o3 \
7. * By                  :
   6 f3 ^/ [. ?7 H( q5 |% m+ s
8. *
   
9. *                                  (c) Copyright 2005-2011, WaveShare
   ' |. }- q( [% m4 _
10. *                                       <a href="http://www.waveshare.net" target="_blank">http://www.waveshare.net</a>
    
11. *                                          All Rights Reserved
    
12. *
    
13. *********************************************************************************************************/
    
14. 
    
15. #include "W25Qx.h"
    
16. 
    - B# C; n3 @6 p$ Z' S' v* Q
17. /**
    
18.   * @brief  Initializes the W25Q128FV interface.
    & T! }9 u& b0 L" N+ W' J
19.   * @retval None
    / y$ D  X) ?; }/ L3 i5 ]/ `
20.   */
    
21. uint8_t BSP_W25Qx_Init(void)
    0 B; H. U  b7 c/ K: v) i
22. {
    7 x; J( [. s' c) I  g& W3 x
23.         /* Reset W25Qxxx */
    9 k- Z& i( b3 z- h( ^/ D
24.         BSP_W25Qx_Reset();
    7 x& c+ G4 P; ^
25.         
      E7 x4 O, ]' n0 J( F# ~
26.         return BSP_W25Qx_GetStatus();
    
27. }
    
28. 
    * p; k5 S; S9 C% f9 \
29. /**
    
30.   * @brief  This function reset the W25Qx.
    ) l1 z2 X, H' a( |5 M2 A  ^3 \
31.   * @retval None
    
32.   */
    4 g4 j1 x9 _9 g3 H
33. static void        BSP_W25Qx_Reset(void)
    3 T! j6 F, j1 M# f7 V" W! G
34. {
    
35.         uint8_t cmd[2] = {RESET_ENABLE_CMD,RESET_MEMORY_CMD};
    8 b; @) F2 d) u5 @
36.         
    
37.         W25Qx_Enable();
    % F; S8 @1 @( m. x2 s. ]
38.         /* Send the reset command */
    
39.         HAL_SPI_Transmit(&hspi1, cmd, 2, W25Qx_TIMEOUT_VALUE);        
    
40.         W25Qx_Disable();
    $ m7 }3 a& u; W, @1 {
41. 
    , Z" h" T' O5 u
42. }
    
43. 
    
44. /**
    1 K5 i' X, g) o1 a# W7 K8 D0 _  l
45.   * @brief  Reads current status of the W25Q128FV.
    
46.   * @retval W25Q128FV memory status
    
47.   */
    
48. static uint8_t BSP_W25Qx_GetStatus(void)
    
49. {
    
50.         uint8_t cmd[] = {READ_STATUS_REG1_CMD};
    " Y( q: _/ |3 U- B7 y# I2 [! y' [6 f
51.         uint8_t status;
    / r1 S6 C: x" U
52.         
    ; U* \3 D1 q2 o- g: |8 Z0 m
53.         W25Qx_Enable();
    
54.         /* Send the read status command */
    
55.         HAL_SPI_Transmit(&hspi1, cmd, 1, W25Qx_TIMEOUT_VALUE);        
    7 G% i* C$ j# f6 F) Q
56.         /* Reception of the data */
    
57.         HAL_SPI_Receive(&hspi1,&status, 1, W25Qx_TIMEOUT_VALUE);
    
58.         W25Qx_Disable();
    
59.         
    - o- ?  A- K# r( z% g
60.         /* Check the value of the register */
    ( N& ]/ h+ c) O
61.   if((status & W25Q128FV_FSR_BUSY) != 0)
    7 s- E; j3 a. ?7 B$ M
62.   {
    0 X/ \( L+ |2 a' s. l/ b7 C
63.     return W25Qx_BUSY;
    
64.   }
    
65.         else
    : W! i# R" p" m" L. |$ w9 P
66.         {
    
67.                 return W25Qx_OK;
    
68.         }               
    
69. }
    + {8 y* a% h6 H% ?6 V( ?
70. 
    
71. /**
    ; P, q1 ^; r% h( Y
72.   * @brief  This function send a Write Enable and wait it is effective.
    + b2 W( Q2 l8 e1 o' v
73.   * @retval None
    % y$ z$ z* A# V# q( [- ?
74.   */
    & Y. O) ^; X( n" z2 r9 K3 p( h
75. uint8_t BSP_W25Qx_WriteEnable(void)
    
76. {
    ( Y& C4 a- Z$ x5 i6 `* y
77.         uint8_t cmd[] = {WRITE_ENABLE_CMD};
    . F& W; O# ?6 [0 U7 B6 b( _/ X
78.         uint32_t tickstart = HAL_GetTick();
      X- i; p' [  a+ S& V. w! \
79. 
    
80.         /*Select the FLASH: Chip Select low */
    2 M3 S4 d1 D: B4 [7 N& Y
81.         W25Qx_Enable();
    2 u0 H. s# h; P4 x: M" ]2 k1 k
82.         /* Send the read ID command */
    " S1 z! H. W# I( @: k# H
83.         HAL_SPI_Transmit(&hspi1, cmd, 1, W25Qx_TIMEOUT_VALUE);        
    / L1 l# T3 G" x
84.         /*Deselect the FLASH: Chip Select high */
    
85.         W25Qx_Disable();
    
86.         
    
87.         /* Wait the end of Flash writing */
    
88.         while(BSP_W25Qx_GetStatus() == W25Qx_BUSY);
    ; ~  {+ f5 g9 z1 W  c
89.         {
    
90.                 /* Check for the Timeout */
    $ X& }% J2 i9 N3 X* i
91.     if((HAL_GetTick() - tickstart) > W25Qx_TIMEOUT_VALUE)
    
92.     {        
    
93.                         return W25Qx_TIMEOUT;
    
94.     }
    
95.         }
    
96.         
    
97.         return W25Qx_OK;
    ' j! Z6 r0 D: O5 \: `
98. }
    / T# M2 h" ^0 j8 E. j( l& z8 i/ c
99. 
    6 p+ t3 L8 {$ d
100. /**
     
101.   * @brief  Read Manufacture/Device ID.
     
102.         * @param  return value address
     8 P, J1 }" U; w6 V0 y4 r
103.   * @retval None
     2 j3 S6 P6 e' m" Z) G% D5 B
104.   */
     & k- C+ }4 W: d  {3 r+ c, S6 ^8 }
105. void BSP_W25Qx_Read_ID(uint8_t *ID)
       D- ?1 u( S* P' n4 E: v0 n
106. {
     2 h2 o, u7 ^. H! ^* m1 X! E
107.         uint8_t cmd[4] = {READ_ID_CMD,0x00,0x00,0x00};
     : o+ Q( }1 L$ G7 }# g% u; I# }
108.         
     1 C! A/ b: k6 ?& }
109.         W25Qx_Enable();
     
110.         /* Send the read ID command */
     ! S/ F- j7 x# o- ^! N% g! I
111.         HAL_SPI_Transmit(&hspi1, cmd, 4, W25Qx_TIMEOUT_VALUE);        
     ' U4 @1 Y" \- w, ^0 s  |& P2 c
112.         /* Reception of the data */
     
113.         HAL_SPI_Receive(&hspi1,ID, 2, W25Qx_TIMEOUT_VALUE);
     
114.         W25Qx_Disable();
     
115.                
     
116. }
     
117. 
     
118. /**
     
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
     - V7 B0 p$ d9 D! N: r2 ]
122.   * @param  Size: Size of data to read   
       u9 Z5 X- `5 u4 u, O
123.   * @retval QSPI memory status
     
124.   */
     ; e- V2 e! ?- F( L
125. uint8_t BSP_W25Qx_Read(uint8_t* pData, uint32_t ReadAddr, uint32_t Size)
     
126. {
     4 j4 {& @  N( |
127.         uint8_t cmd[4];
     
128. 
     
129.         /* Configure the command */
     , i& e, y: N9 t
130.         cmd[0] = READ_CMD;
     ! e& Q' R5 y! `3 Y; Q9 J- a
131.         cmd[1] = (uint8_t)(ReadAddr >> 16);
     $ ?! Y7 c  p2 r# h) r" Q3 G
132.         cmd[2] = (uint8_t)(ReadAddr >> 8);
     8 ?, Z! U* D' T! i
133.         cmd[3] = (uint8_t)(ReadAddr);
     
134.         
     5 W, q: _. v, s
135.         W25Qx_Enable();
     
136.         /* Send the read ID command */
     0 J* q) \7 o7 y' |8 {4 }! q
137.         HAL_SPI_Transmit(&hspi1, cmd, 4, W25Qx_TIMEOUT_VALUE);        
     6 @6 v, t; b5 t, V3 c. K
138.         /* Reception of the data */
     - Y7 Z/ M- Z, r! K* T# C; N0 O
139.         if (HAL_SPI_Receive(&hspi1, pData,Size,W25Qx_TIMEOUT_VALUE) != HAL_OK)
     
140.   {
     
141.     return W25Qx_ERROR;
     
142.   }
     
143.         W25Qx_Disable();
       y( z& o& M0 J0 G7 r0 t
144.         return W25Qx_OK;
     
145. }
     
146. 
     3 U2 G6 v2 x% Y* y% ~+ |( y
147. /**
     8 L  }" K+ {, Y# Y# O" m
148.   * @brief  Writes an amount of data to the QSPI memory.
     
149.   * @param  pData: Pointer to data to be written
     5 ~2 p& V/ v9 Z9 x1 e, \- e
150.   * @param  WriteAddr: Write start address
     1 V% b" E, V0 R8 e
151.   * @param  Size: Size of data to write,No more than 256byte.   
     ! ]- \3 _; L: ~$ t  g/ A
152.   * @retval QSPI memory status
     
153.   */
     $ n- [' ]6 C* b) v- v) |  U1 @- i$ Z
154. uint8_t BSP_W25Qx_Write(uint8_t* pData, uint32_t WriteAddr, uint32_t Size)
     ; n5 ]9 ~0 m7 C% d' _
155. {
     
156.         uint8_t cmd[4];
     ) r' X- i, ^: n
157.         uint32_t end_addr, current_size, current_addr;
     
158.         uint32_t tickstart = HAL_GetTick();
       z* P" D: T& [4 O' _
159.         
     
160.         /* Calculation of the size between the write address and the end of the page */
     + p5 R! q* N" a4 F, d' W1 F" O
161.   current_addr = 0;
     9 ?' W' I6 h( U5 z6 p, I! C4 N
162. 
     
163.   while (current_addr <= WriteAddr)//判断地址属于哪一扇区开始
     
164.   {
     7 o, X0 [) \4 J) }( N
165.     current_addr += W25Q128FV_PAGE_SIZE;//0x100-> 256 bytes
     
166.   }
     7 J. R: c/ I- x8 ]$ X
167.   current_size = current_addr - WriteAddr;
     
168. 
     & D$ \0 F) r- u
169.   /* Check if the size of the data is less than the remaining place in the page */
     $ x% k/ d( Y- {
170.   if (current_size > Size)
     
171.   {
       K8 z, H" M( q# Q$ L5 a  d- d. o' s
172.     current_size = Size;
     ; N3 X3 J$ M" m5 D
173.   }
     " w& L( W" U( L) ]& n
174. 
     
175.   /* Initialize the adress variables *///写入地址大小范围
     4 y. L1 q3 `: t1 i" d  _
176.   current_addr = WriteAddr;
     
177.   end_addr = WriteAddr + Size;
     ( Q5 o2 n  i2 }! Z
178.         
     * [, t0 Y, F5 \, M$ [' _
179.   /* Perform the write page by page */
     
180.   do
     
181.   {
     
182.                 /* Configure the command */
     9 O5 D  K' T! ?" I$ u( G  Z1 `5 x: M3 U
183.                 cmd[0] = PAGE_PROG_CMD;
     ) ~* E/ @9 |( ?  X! c7 k6 q
184.                 cmd[1] = (uint8_t)(current_addr >> 16);
     
185.                 cmd[2] = (uint8_t)(current_addr >> 8);
     0 ]& F& ]6 a* R/ ^9 x1 S4 M
186.                 cmd[3] = (uint8_t)(current_addr);
     8 _% O- D/ O3 a1 m2 Y/ [6 y
187. 
     
188.                 /* Enable write operations */
     ' Z% U+ u$ J# [3 x0 o
189.                 BSP_W25Qx_WriteEnable();
     
190.         
     1 D7 N; h$ L: P/ \
191.                 W25Qx_Enable();
     
192.     /* Send the command */
     
193.     if (HAL_SPI_Transmit(&hspi1,cmd, 4, W25Qx_TIMEOUT_VALUE) != HAL_OK)
     
194.     {
     ; A6 [& W- N# l; d
195.       return W25Qx_ERROR;
     1 [3 m4 H5 `* w, a
196.     }
     . Y; C/ Z7 P, F
197. 
     ' f: g) s: `2 j
198.     /* Transmission of the data */
     % Z7 B/ y6 d8 y. t) r+ t, G% N* z+ q: @
199.     if (HAL_SPI_Transmit(&hspi1, pData,current_size, W25Qx_TIMEOUT_VALUE) != HAL_OK)
     
200.     {
     0 O$ {: a( k' j; n- H1 T- \
201.       return W25Qx_ERROR;
     " H% X% m9 y/ X
202.     }
     
203.                         W25Qx_Disable();
     
204.             /* Wait the end of Flash writing */
     , v; h# K6 B; ]' @, r0 y. M/ M+ _' J* m
205.                 while(BSP_W25Qx_GetStatus() == W25Qx_BUSY);
     
206.                 {
     
207.                         /* Check for the Timeout */
     
208.                         if((HAL_GetTick() - tickstart) > W25Qx_TIMEOUT_VALUE)
     
209.                         {        
     8 x2 x8 w, H8 Q3 }  b
210.                                 return W25Qx_TIMEOUT;
     
211.                         }
     
212.                 }
     
213. 
     
214.     /* Update the address and size variables for next page programming */
     4 y* ^, \3 S5 b* j: l
215.     current_addr += current_size;
     ) w5 p4 o& M; S# k4 u4 B7 S
216.     pData += current_size;
     * I+ o6 ?1 ^  V6 O; T
217.     current_size = ((current_addr + W25Q128FV_PAGE_SIZE) > end_addr) ? (end_addr - current_addr) : W25Q128FV_PAGE_SIZE;
     & Z8 G& `/ b. O: p: _
218.   } while (current_addr < end_addr);
     * C; ~8 r3 y& `* X1 j
219. 
     
220.         
     * b9 O0 s+ V* l. T' ~6 e: J! ^
221.         return W25Qx_OK;
     
222. }
     
223. 
     ; d* @& K3 d* ]" F+ Z; `
224. /**
     " v2 {0 `6 W/ [4 M/ r
225.   * @brief  Erases the specified block of the QSPI memory.
     & v! O; b; e$ W1 _; r
226.   * @param  BlockAddress: Block address to erase  
     0 O: l* K; e1 ^* r! H. x
227.   * @retval QSPI memory status
     , T' ~% i2 c2 z8 T
228.   */
     & \/ E' Y/ S7 Z; n3 U% [
229. uint8_t BSP_W25Qx_Erase_Block(uint32_t Address)
     
230. {
     
231.         uint8_t cmd[4];
     
232.         uint32_t tickstart = HAL_GetTick();
     
233.         cmd[0] = SECTOR_ERASE_CMD;
     
234.         cmd[1] = (uint8_t)(Address >> 16);
     + O3 N! L8 ~; O+ p, C; I0 c
235.         cmd[2] = (uint8_t)(Address >> 8);
     : O3 i# u: l$ e- l
236.         cmd[3] = (uint8_t)(Address);
     
237.         
     
238.         /* Enable write operations */
     
239. //        BSP_W25Qx_WriteEnable();
     
240.         
     * s" A  _7 `' N0 j' c* Q
241.         /*Select the FLASH: Chip Select low */
     + g# o# Q' u! {7 T" g
242.         W25Qx_Enable();
     7 q3 S' m* o1 [; q- T! T! R& Z+ Q
243.         /* Send the read ID command */
     
244.         HAL_SPI_Transmit(&hspi1, cmd, 4, W25Qx_TIMEOUT_VALUE);        
     
245.         /*Deselect the FLASH: Chip Select high */
     ! q& S# a1 U7 C+ }9 l
246.         W25Qx_Disable();
     
247.         
     4 w6 t* U  s" p. }6 [/ B
248.         /* Wait the end of Flash writing */
     
249.         while(BSP_W25Qx_GetStatus() == W25Qx_BUSY);
     7 V0 ~! I3 c# v5 C1 s9 i4 A# }" f
250.         {
     ! ]) X8 Z* ^5 z# g+ X3 [: U! f
251.                 /* Check for the Timeout */
     " a: t) b9 L+ v% B9 V& I$ j, a
252.     if((HAL_GetTick() - tickstart) > W25Q128FV_SECTOR_ERASE_MAX_TIME)
     
253.     {        
     7 j2 S) n9 }- c- U; N! F  j& x
254.                         return W25Qx_TIMEOUT;
     
255.     }
     
256.         }
     
257.         return W25Qx_OK;
     
258. }
     
259. 
     
260. /**
     
261.   * @brief  Erases the entire QSPI memory.This function will take a very long time.
     5 ~% h$ @/ H! N3 ], ^( h
262.   * @retval QSPI memory status
     " P3 T) {: P, d0 a. g; {
263.   */
     
264. uint8_t BSP_W25Qx_Erase_Chip(void)
     . k7 S# a& Q( @1 F. V% {
265. {
     5 s4 Y. V4 ]' l- o. v3 @6 |" {
266.         uint8_t cmd[4];
     
267.         uint32_t tickstart = HAL_GetTick();
     ! W3 t( q" l' d' n1 B6 l& I
268.         cmd[0] = SECTOR_ERASE_CMD;
     , f% ~$ b1 q6 [3 G! f2 g, K
269.         
     ; R* V' q2 s- P2 M6 q8 A
270.         /* Enable write operations */
     7 [* a$ t% I6 G
271.         BSP_W25Qx_WriteEnable();
     
272.         
     ! H/ T0 {3 s- H$ K+ v
273.         /*Select the FLASH: Chip Select low */
     / j  S  U1 f$ D; M! i
274.         W25Qx_Enable();
     7 S. R  E: ?* t1 S5 O
275.         /* Send the read ID command */
     $ E$ A' ^0 R, h' {
276.         HAL_SPI_Transmit(&hspi1, cmd, 1, W25Qx_TIMEOUT_VALUE);        
     
277.         /*Deselect the FLASH: Chip Select high */
     ) j6 B( f! h' V7 F; N- {0 M
278.         W25Qx_Disable();
     ! j( y& P1 x$ n! f: S8 J* K
279.         
     + X, v3 M' y% ]! P* J# d2 c
280.         /* Wait the end of Flash writing */
     & u: h- F6 j' i! l# D# Q
281.         while(BSP_W25Qx_GetStatus() != W25Qx_BUSY);
     ; p& C  L( n3 b# Q
282.         {
     3 B$ X9 _, `  X5 V8 ~8 W  {
283.                 /* Check for the Timeout */
     
284.     if((HAL_GetTick() - tickstart) > W25Q128FV_BULK_ERASE_MAX_TIME)
     6 [* j) K3 ^5 ?; j0 W; k- @1 ?
285.     {        
     
286.                         return W25Qx_TIMEOUT;
     
287.     }
     ; E' b6 w7 {$ Y4 p: o
288.         }
     # L! c( B4 `! X5 Y2 i* `
289.         return W25Qx_OK;
     
290. }
     

复制代码

& P8 d' ^: ?  F8 uW25Qx.h
# E! J4 @. E$ X. R4 [" D

1. /*********************************************************************************************************
   ; F8 n' f7 x4 B% k0 X3 g0 }
2. *
   5 q9 W& X+ O  `: ?4 W
3. * File                : W25Qx.h
   
4. * Hardware Environment:
   : w! a; a6 h4 O% W/ l/ \
5. * Build Environment   : RealView MDK-ARM  Version: 5.15
   
6. * Version             : V1.0
   1 N' r  o/ \$ x7 o
7. * By                  :
   
8. *
   - v$ M( J4 |$ P3 ~, |% Y; ~  M
9. *                                  (c) Copyright 2005-2015, WaveShare
   . v6 E/ t7 U. {4 @
10. *                                       <a href="http://www.waveshare.net" target="_blank">http://www.waveshare.net</a>
    
11. *                                          All Rights Reserved
    1 U& J. H# C: N* P
12. *
    # L, T9 y- t$ D- `6 m- H, C& t
13. *********************************************************************************************************/
    
14. /* Define to prevent recursive inclusion -------------------------------------*/
    
15. #ifndef __W25Qx_H
    
16. #define __W25Qx_H
    # o; s& I2 d" e7 L
17. 
    9 a# {9 w2 m8 @7 _" j
18. #ifdef __cplusplus
    : |( F0 V6 J7 p" P; |2 h% k
19. extern "C" {
    " i+ A4 M0 t+ d, [) ]
20. #endif
    ) M, P& P3 x- h; W# N! Q' ^
21. 
    + t" H) C! J4 O) t+ W3 a. q
22. /* Includes ------------------------------------------------------------------*/
    
23. #include "stm32f0xx.h"
    . }6 B: ~" e  j8 G; t( D7 ?, q2 r
24. #include "spi.h"
    0 z. o4 s: e8 B( x
25.          
    
26. /** @addtogroup BSP
    3 z6 V) @8 [+ W& v
27.   * @{
    * n5 r  I- j( ~# c* z9 X# C
28.   */
    
29. 
    6 ~6 e9 _/ t* H1 _/ }$ ~; p/ e
30. /** @addtogroup Components
    
31.   * @{
    ; L! R  f! M' {$ ?2 d# s7 Q! m
32.   */
    
33. 
    
34. /** @addtogroup W25Q128FV
    
35.   * @{
    8 B+ T) ~4 m( y( X
36.   */
    
37. 
    
38. /** @defgroup W25Q128FV_Exported_Types
    . V/ u4 n  E, Z5 s& b) z: @. \
39.   * @{
    
40.   */
    
41. 
    
42. /**
    $ l0 t" Z; y( C% g6 Q- ^
43.   * @}
    
44.   */
    
45. 
    
46. /** @defgroup W25Q128FV_Exported_Constants
    
47.   * @{
    
48.   */
    2 D5 c" S8 M: Y, E6 f
49. 
    
50. /**
    
51.   * @brief  W25Q128FV Configuration  
    : {# T+ a! ?9 A( Z' r: J; L. S
52.   */  
    ' C. _* `& K  \
53. #define W25Q128FV_FLASH_SIZE                  0x1000000 /* 128 MBits => 16MBytes */
    
54. #define W25Q128FV_SECTOR_SIZE                 0x10000   /* 256 sectors of 64KBytes */
    $ F6 _- Y: _  d* L7 h- m
55. #define W25Q128FV_SUBSECTOR_SIZE              0x1000    /* 4096 subsectors of 4kBytes */
    : Z0 s& X" o9 p. I$ H) d8 `4 U7 u
56. #define W25Q128FV_PAGE_SIZE                   0x100     /* 65536 pages of 256 bytes */
    ' ?. E$ k  d6 ^8 ?0 f
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
    1 R8 d  x! m. B! F! M- R) O
62. #define W25Q128FV_SECTOR_ERASE_MAX_TIME       3000
    
63. #define W25Q128FV_SUBSECTOR_ERASE_MAX_TIME    800
    
64. #define W25Qx_TIMEOUT_VALUE 1000
    
65. 
    
66. /**
    
67.   * @brief  W25Q128FV Commands  
    3 c' ~# ^4 ]( _+ [
68.   */  
    
69. /* Reset Operations */
    
70. #define RESET_ENABLE_CMD                     0x66
    
71. #define RESET_MEMORY_CMD                     0x99
      i7 g- R$ D3 c3 Y+ b" W
72. 
    
73. #define ENTER_QPI_MODE_CMD                   0x38
    
74. #define EXIT_QPI_MODE_CMD                    0xFF
      S9 C8 }: N0 c+ U
75. 
    
76. /* Identification Operations */
    
77. #define READ_ID_CMD                          0x90
    6 n) a- S  J% `7 Z5 |4 ~( t
78. #define DUAL_READ_ID_CMD                     0x92
    
79. #define QUAD_READ_ID_CMD                     0x94
    
80. #define READ_JEDEC_ID_CMD                    0x9F
    
81. 
    
82. /* Read Operations */
    
83. #define READ_CMD                             0x03
    
84. #define FAST_READ_CMD                        0x0B
    
85. #define DUAL_OUT_FAST_READ_CMD               0x3B
    
86. #define DUAL_INOUT_FAST_READ_CMD             0xBB
    
87. #define QUAD_OUT_FAST_READ_CMD               0x6B
    ) Z# |# J7 H6 E) @/ s' s
88. #define QUAD_INOUT_FAST_READ_CMD             0xEB
    - [  Y, x/ F5 D1 F- n
89. 
    6 b7 I" Y5 P# ]! _/ r& @  S/ {
90. /* Write Operations */
    / u4 T5 s" Q% J- |! _% W
91. #define WRITE_ENABLE_CMD                     0x06
    
92. #define WRITE_DISABLE_CMD                    0x04
    1 g3 w% b0 `; e/ Y& `+ T6 ?' H# a
93. 
    
94. /* Register Operations */
    & Q! G9 O5 h6 e$ b! n7 R0 Y* b8 i
95. #define READ_STATUS_REG1_CMD                  0x05
    : B# E6 J0 g5 J4 V' ]" Y% L
96. #define READ_STATUS_REG2_CMD                  0x35
    
97. #define READ_STATUS_REG3_CMD                  0x15
    
98. 
    
99. #define WRITE_STATUS_REG1_CMD                 0x01
    
100. #define WRITE_STATUS_REG2_CMD                 0x31
     
101. #define WRITE_STATUS_REG3_CMD                 0x11
     2 K. P$ R) Q+ D! c* U  E
102. 
     
103. 
     
104. /* Program Operations */
     + f0 u/ M& X: j! f; @
105. #define PAGE_PROG_CMD                        0x02
     ; P4 U+ |, a; o- \) K. g
106. #define QUAD_INPUT_PAGE_PROG_CMD             0x32
     . G0 R! I. T+ @
107. 
     7 L/ ]( |! T! C
108. 
     
109. /* Erase Operations */
     7 C( g- Q9 W2 l" o) a+ V
110. #define SECTOR_ERASE_CMD                     0x20
     
111. #define CHIP_ERASE_CMD                       0xC7
     
112. 
     
113. #define PROG_ERASE_RESUME_CMD                0x7A
     
114. #define PROG_ERASE_SUSPEND_CMD               0x75
     ) q& A* ~% [; X) p- v) ~
115. 
     + L& i& e. D" d! D
116. 
     
117. /* Flag Status Register */
     1 x" |- W3 }( y5 i" K4 @3 V/ {
118. #define W25Q128FV_FSR_BUSY                    ((uint8_t)0x01)    /*!< busy */
     0 t* ^/ F4 K5 B" ^  y
119. #define W25Q128FV_FSR_WREN                    ((uint8_t)0x02)    /*!< write enable */
     
120. #define W25Q128FV_FSR_QE                      ((uint8_t)0x02)    /*!< quad enable */
     / `; w' }; l: k1 P
121. 
     . M, t/ z' X- v- ~! j) U
122. 
     
123. #define W25Qx_Enable()                         HAL_GPIO_WritePin(CS_GPIO_Port, CS_Pin, GPIO_PIN_RESET)
     ! i. C9 a5 v2 m8 c2 T; W
124. #define W25Qx_Disable()                 HAL_GPIO_WritePin(CS_GPIO_Port, CS_Pin, GPIO_PIN_SET)
     
125. 
     
126. #define W25Qx_OK            ((uint8_t)0x00)
     2 y1 P+ f3 ]  N3 Y, V6 Z0 B; w
127. #define W25Qx_ERROR         ((uint8_t)0x01)
     # L3 j0 e2 G, E1 \4 J9 B
128. #define W25Qx_BUSY          ((uint8_t)0x02)
     
129. #define W25Qx_TIMEOUT                                ((uint8_t)0x03)
     
130. 
     
131. 
     
132. uint8_t BSP_W25Qx_Init(void);
     3 w3 |' r* x( d& P" @1 J
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);
     0 ^. b: [6 w7 U1 ?& x) x% G" T  I
137. uint8_t BSP_W25Qx_Read(uint8_t* pData, uint32_t ReadAddr, uint32_t Size);
       `; l2 _; R) m
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);
     
140. uint8_t BSP_W25Qx_Erase_Chip(void);
     2 a% o, Z( q' w# w. u7 T/ i, ^7 G
141. 
     / C. D5 ?! |8 L, ~$ U3 w3 Y
142. /**
     ( h  c6 L' m; U+ z* B  M( W$ m
143.   * @}
     
144.   */
     
145. 
     ; r9 U/ m, g7 `) L9 E
146. /** @defgroup W25Q128FV_Exported_Functions
     
147.   * @{
     
148.   */
     / s$ g$ K. r2 w8 A
149. /**
     
150.   * @}
     , N9 o% o4 Z" ]: ^
151.   */
     0 Z9 f* Q7 @/ J
152. 
     
153. /**
     - p# e, w$ ~0 ~, N' e* t$ z* s+ Z
154.   * @}
     1 l8 ?- g+ }8 @1 {
155.   */
       g8 v& @+ E! ]$ J& `  y
156. 
     ! K  b- i4 k9 S- A- X! E% Y1 L
157. /**
     , U. F8 K5 |( m, x& _2 X1 D
158.   * @}
     " |( x1 C7 N& b7 c
159.   */
     
160. 
     
161. /**
     
162.   * @}
     
163.   */
     
164. 
     
165. #ifdef __cplusplus
     0 z  j% v5 ^$ l4 U: c6 D' s& ~* x. P
166. }
     7 |2 U0 }! E0 K5 @
167. #endif
     
168. 
     
169. #endif /* __W25Qx_H */

复制代码

案例
7 j* T1 G0 N1 _' `向0扇区（0块0扇区），17扇区（1块1扇区），34扇区（2块2扇区）分别写入0x200的数据。

头文件定义

1. /* USER CODE BEGIN Includes */
   
2. #include "stdio.h"
   3 r" k) O+ N+ F* K6 Q; u" F% B
3. 
   
4. #include "W25Qx.h"
   
5. /* USER CODE END Includes */

复制代码

串口接收和flash数组定义

1. /* USER CODE BEGIN PV */
   2 S0 J* k3 |+ |3 a# N9 ]8 L- [
2. #define BUFFERSIZE 255           //可以接收的最大字符个数      
   
3. uint8_t ReceiveBuff[BUFFERSIZE]; //接收缓冲区
   
4. uint8_t recv_end_flag = 0,Rx_len;//接收完成中断标志，接收到字符长度
   & |$ V1 d$ v( V% e
5. 
   
6. uint8_t wData1[0x200];
   
7. uint8_t wData2[0x200];
   
8. uint8_t wData3[0x200];
   0 o  m+ ~: U0 D- s- y8 e
9. 
   
10. uint8_t rData1[0x200];
    8 I7 @8 z$ ]3 X. ^! U0 W) v
11. uint8_t rData2[0x200];
    4 [0 |' H% @3 W9 y7 E9 T& S2 R+ T/ W
12. uint8_t rData3[0x200];
    # n4 O" H0 R. ?( a2 K
13. uint8_t ID[4];
    
14. uint32_t i;
    
15. 
    3 m) t$ m/ ?) ~& d
16. uint8_t flag[1] ;
    
17. int i_flag = 0;
    
18. /* USER CODE END PV */

复制代码

: ~2 r2 K: R8 @5 j/ J* K2 K6 W串口重定向

1. /* USER CODE BEGIN PFP */
   
2. void uart2_data(void);
   
3. #ifdef __GNUC__                                                                        //串口重定向
   . @# A1 l6 n3 o1 i9 R) E+ z
4. #define PUTCHAR_PROTOTYPE int __io_putchar(int ch)
   $ y% i* R) U, M3 m4 ~9 F' k
5. #else
   $ h2 M+ J" C0 y& S$ s' n' T9 Y9 N
6. #define PUTCHAR_PROTOTYPE int fputc(int ch, FILE *f)
   
7. #endif
   
8. PUTCHAR_PROTOTYPE
   
9. {
   
10.     HAL_UART_Transmit(&huart2 , (uint8_t *)&ch, 1, 0xFFFF);
    
11.     return ch;
    
12. }
    " ^$ F. i0 c7 x# o- ~4 }8 ~
13. /* USER CODE END PFP */

复制代码

串口中断设置
  g: P% P" i3 {6 \% |% K

1. #include "stm32f1xx_it.c"文件中断外部变量引用：
   ; ?$ ~+ h7 Z1 b( ~
2. 
   ) c! d/ L6 v: `. z
3. /* USER CODE BEGIN 0 */
   & E# g0 P6 \, [
4. #define BUFFERSIZE 255        //可接收的最大数据量
   
5. extern uint8_t recv_end_flag,Rx_len,bootfirst;
   + F) ]+ j5 [0 [
6. /* USER CODE END 0 */

复制代码

串口2中断函数：

& F' C9 X1 n: v1 t% ~

1. /**
   ( u! y% A7 j) N  E( z6 ?6 T
2.   * @brief This function handles USART2 global interrupt.
   ; p  u) a* P2 j+ r2 N4 h
3.   */
   $ w5 v5 M# F* W) g, V$ c
4. void USART2_IRQHandler(void)
   5 E6 A! m3 X3 n1 P& [9 [0 d
5. {
   6 D1 q3 m, {. X6 L' [
6.   /* USER CODE BEGIN USART2_IRQn 0 */
   # `2 j9 ]+ e& q8 z
7. 
   
8.   /* USER CODE END USART2_IRQn 0 */
   
9.   HAL_UART_IRQHandler(&huart2);
   7 E* s: K5 \& h# H* a& `
10.   /* USER CODE BEGIN USART2_IRQn 1 */
    ! j* B1 ~. W$ d. _' U" k
11.         uint32_t temp;
    ! a4 U' N0 t$ J( @2 V( D- z  y* }6 \
12.         if(USART2 == huart2.Instance)//判断是否为串口2中断
    
13. 
    
14.         {      
    # C# m# Q5 e; k  _; U# _7 K
15.                 if(RESET != __HAL_UART_GET_FLAG(&huart2,UART_FLAG_IDLE))//如果为串口2
    3 u  v' e3 w8 ?0 s: l
16.                 {
    + {6 {) ~) _3 w  k$ o4 \- n
17.                         __HAL_UART_CLEAR_IDLEFLAG(&huart2);//清除中断标志
    
18.       HAL_UART_DMAStop(&huart2);//停止DMA接收
    # y3 G0 ?9 [5 @. q7 N0 E
19.                      temp  = __HAL_DMA_GET_COUNTER(&hdma_usart2_rx);//获取DMA当前还有多少未填充
    # T8 ]1 H% g& d* |5 m
20.                       Rx_len =  BUFFERSIZE - temp; //计算串口接收到的数据个数
    
21.                       recv_end_flag = 1;
    
22.              }
    , S! ^" w+ K, v/ |5 U
23.         }
    ! X* d: S& y* _" f; C% s- T( A
24. 
    % @2 D& R' }7 U8 W+ {# C
25.   /* USER CODE END USART2_IRQn 1 */
    ' Y) k9 N  k" v. Q3 L0 [/ {5 w' A4 `
26. }
    

复制代码

  D* m. E) {; c主程序
读取ID和flash数据及擦除。

: f. d2 n) a) I

1.   /* USER CODE BEGIN 2 */
   - z. p4 Z! Z$ L) j
2.         printf("GD Nor Flash案例\n");
   
3.          __HAL_UART_ENABLE_IT(&huart2, UART_IT_IDLE);//使能串口1 IDLE中断
   5 w; O6 ]1 X  \  T+ P
4.         
   6 b5 ?0 o7 L* Q; }2 A8 e) |
5.         /*##-1- Read the device ID  ########################*/
   0 K( C; Y2 e# B2 |7 I0 ?2 V4 f
6.         BSP_W25Qx_Init();//初始化W25Q128
   ' i4 Z9 f: g; o% D. B7 e' A
7.         BSP_W25Qx_Read_ID(ID);//读取ID
   
8. 
   
9.         if((ID[0] != 0xC8) | (ID[1] != 0x16))
   
10.         {
    - E1 {1 N0 V; l+ p
11.                 Error_Handler();//如果 ID不对打印错误
    3 S! A0 x" K  r
12.         }
    
13.         else//ID正确，打印ID
    ) C3 `& N, ?$ H$ g: {0 L& h/ o
14.         {
    
15.                 printf("W25Q64 ID : ");
    
16.                 for(i=0;i<2;i++)
    
17.                 {
    
18.                         printf("0x%02X ",ID);
    
19.                 }
    
20.                 printf("\r\n\r\n");
    4 \" I, e$ c% X6 H! b
21.         }
    $ f& Q/ ]% l- I3 O: G) k/ o
22. 
    
23. 
    ' \  ^9 ^& I- m, }2 x' A
24. /**************************读取第0扇区数据**************************************************************/
    
25. 
    / k" A$ [" P. f& A+ J
26.         /*##-3- Read the flash     ########################*/
    
27.         /*读取数据，rData读取数据的指针，起始地址0x00，读取数据长度0x200*/
    0 Q; m% w5 i: y) z: b  d' o0 e+ e
28.         if(BSP_W25Qx_Read(rData1,0x0,0x200)== W25Qx_OK)
    
29.                 printf("读取原始的0个扇区数据成功！\n");
    & t4 B% R9 f- l% ^1 J
30.         else
    
31.                 Error_Handler();
    
32.         /*打印数据*/        
    , [. ?3 K5 x" `6 d# L
33.         printf("读取原始的0个扇区数据为: \r\n");
    
34.         
    ) _5 D1 R! d: B" R
35.         for(i =0;i<0x200;i++)
    * @, P% x* I4 u; [/ z
36.         {
    
37.                 if(i%20==0)
    2 h+ h, K- Z' Y9 H5 x! r
38.                         printf("\n0扇区第%d到%d的数据为：\r\n",i,i+19);
    
39.                                 printf("0x%02X  ",rData1);
    4 M' _  n+ [- m# `
40.         }
    
41. 
    " m0 N/ K- i7 z/ t" Y
42.         printf("\n");
    ) Z- R- g: u8 B1 K: B' O" g  h5 I  k' a
43. 
    
44.         
    
45. /**************************读取第17扇区数据**************************************************************/
    2 d5 X. Q# n; q1 p3 U
46.         
    - n/ M% |) `, X$ F7 Z( S" J
47.         /*##-3- Read the flash     ########################*/
    
48.         /*读取数据，rData读取数据的指针，起始地址0x1000，读取数据长度0x200*/
    4 X" E- v. h" r" n8 b, O: e
49.         if(BSP_W25Qx_Read(rData2,0x11000,0x200)== W25Qx_OK)
    
50.                 printf("读取原始的17个扇区数据成功！\n");
    ( j) z, k+ h* o' ^
51.         else
    
52.                 Error_Handler();
    
53.         /*打印数据*/        
    0 o: l0 q; ]/ B% M, s
54.         printf("读取原始的2个扇区数据为:");
    
55.         
    
56.         for(i =0;i<0x200;i++)
    " H9 Y% _( @' a0 P
57.         {
    
58.                 if(i%20==0)
    
59.                         printf("\n17扇区第%d到%d的数据为：\r\n",i,i+19);
    
60.                                 printf("0x%02X  ",rData2);
    
61.         }
    
62. 
    
63.         printf("\n");        
    
64.         
    
65.         
    : J3 ?) v4 v8 S, N; }! U
66. /**************************读取第34扇区数据**************************************************************/
    
67.         
    
68.         /*##-3- Read the flash     ########################*/
    & L( a3 ~( f2 u8 T* _7 S6 p- i
69.         /*读取数据，rData读取数据的指针，起始地址0x2000，读取数据长度0x200*/
    * s1 N5 C* F" W7 D) ]
70.         if(BSP_W25Qx_Read(rData3,0x22000,0x200)== W25Qx_OK)
    0 x* N" p* B  v& ^$ h* ~
71.                 printf("读取原始的34个扇区数据成功！\n");
    2 Y  g$ J# K2 {9 a: x
72.         else
    
73.                 Error_Handler();
    
74.         /*打印数据*/        
    
75.         printf("读取原始的34个扇区数据为: ");
    3 v! ~* n4 ]+ u7 g# w" N8 U
76.         
    
77.         for(i =0;i<0x200;i++)
    
78.         {
    0 Z& v9 ?: Q* d+ @
79.                 if(i%20==0)
    
80.                         printf("\n34扇区第%d到%d的数据为：\r\n",i,i+19);
    
81.                                 printf("0x%02X  ",rData3);
    ' P& Z; C1 _7 W8 W( y
82.         }
    
83. 
    ' l: n( u- t+ l% D) m6 n
84.         printf("\n");        
    
85.         
    + P1 h) r, j* {8 {& S0 ^2 |8 M
86.         
    & p2 t: ~/ f9 F4 P2 U# i
87. 
    
88. /**************************清除第0扇区数据为0**************************************************************/
    
89. 
    
90. 
    . \2 P% b% P3 E+ x9 v) K; y* \  N
91.         
    
92.         /*##-2- Erase Block ##################################*/
    " X( b$ e) \0 p8 W/ A
93.         if(BSP_W25Qx_Erase_Block(0) == W25Qx_OK)
    , }8 y3 Z# C* L# q: Q
94.                 printf(" QSPI Erase Block ok\r\n");
    
95.         else
    
96.                 Error_Handler();
    # j/ U( o( p  z9 q
97.         
    ! Y7 X( Y- [/ q+ Y  j$ U0 i8 E
98.         /*##-2- Written to the flash ########################*/
    3 t  l  K1 A" M6 d! |( K
99.         /* fill buffer */
    
100.         printf(" 初始化数据，清零第0扇区前0x200的数据！\r\n");
     : M( V' n% ~# [+ e* x# T0 v
101.         for(i =0;i<0x200;i ++)
     2 _- X4 C# T; i. w, N- |: I3 D5 G
102.         {
     - U& z( l2 z& H5 _
103.                         wData1 = 0;
     
104.                   rData1 = 0;
     
105.         }
     ( o+ x1 D% M, A$ Y$ ]8 H$ W% E
106.         /*写入数据，wData写入数据的指针，起始地址0x00，写入数据长度0x200*/
     , M! p. h6 F( H7 B; M3 P/ u3 _
107.         if(BSP_W25Qx_Write(wData1,0x00,0x200)== W25Qx_OK)
     
108.                 printf("清零第0扇区前0x200的数据成功！\r\n");
     " i$ p8 P; e- N
109.         else
     - C% I8 G, ~6 v; W8 Y  A
110.                 Error_Handler();
     : Q6 G, c4 G4 B$ w* o
111. 
     4 h2 _( v' L, [8 F" W
112.         
     
113.         
     ; n7 l- E' o- }' j# a/ }' l
114.         
     
115.         /*##-3- Read the flash     ########################*/
     ( x# V; K! I9 |# V) j/ I
116.         /*读取数据，rData读取数据的指针，起始地址0x00，读取数据长度0x200*/
     
117.         if(BSP_W25Qx_Read(rData1,0x00,0x200)== W25Qx_OK)
     
118.                 printf("读取第0扇区前0x200数据成功！\r\n\r\n");
     9 s. G5 p! t" }8 r4 o  t0 P% w
119.         else
     # ?" m0 y' c  W2 f1 e* O
120.                 Error_Handler();
     
121.         /*打印数据*/        
     
122.         printf("读取第0扇区前0x200数据为: \r\n");
     
123.         
     + y/ b/ D9 R6 B
124.         for(i =0;i<0x200;i++)
     
125.         {
     : l; W$ p, j, D1 R2 [
126.                 if(i%20==0)
     ) l6 V3 O" v* K( h
127.                         printf("\n第%d到%d的数据为：\r\n",i,i+19);
     8 p3 d& Z( ^6 U% t8 z% J
128.                                 printf("0x%02X  ",rData1);
     - F' U( A$ b# N9 f! G
129.         }
     
130. 
     9 n$ _) i( T: a' N  Y3 ]4 v
131.         printf("\n");
     - c% G$ k% u, \2 p7 ~* N* L
132. 
     
133. 
     
134. /**************************清除第17扇区数据为0**************************************************************/
     . i5 ?: ^, y; z" q# g
135. 
     
136. 
     
137.         
     $ E  U0 a, K; K8 k& I
138.         /*##-2- Erase Block ##################################*/
     1 @4 Q5 g( B2 \6 m2 r
139.         if(BSP_W25Qx_Erase_Block(0x11000) == W25Qx_OK)
     : ~, a* M! z% S- l" I) S
140.                 printf(" QSPI Erase Block ok\r\n");
     
141.         else
     0 R* l$ F* }7 n9 ~
142.                 Error_Handler();
     
143.         
     , X# ], Q# M$ ]" F" \
144.         /*##-2- Written to the flash ########################*/
     
145.         /* fill buffer */
     4 ]) W1 ]$ Z7 ~* C; ?
146.         printf(" 初始化数据，清零第17扇区前0x200的数据！\r\n");
     
147.         for(i =0;i<0x200;i ++)
     
148.         {
     ; g. u: N% [# {, z5 s, U
149.                         wData2 = 0;
     
150.                   rData2 = 0;
     
151.         }
     
152.         /*写入数据，wData写入数据的指针，起始地址0x1000，写入数据长度0x200*/
     
153.         if(BSP_W25Qx_Write(wData2,0x11000,0x200)== W25Qx_OK)
     ; n; ^: l! X  n
154.                 printf("清零第2扇区前0x200的数据成功！\r\n");
     $ H7 D. F4 |3 @# L' q* n2 l( Q) `4 _
155.         else
     % W9 X8 I* ?8 [- N$ u- f( \
156.                 Error_Handler();
     % [- r6 H  B1 s9 V
157. 
     
158.         
     
159.         
     : }% g6 r0 C. p6 n# C/ B7 z
160.         
     2 o% l, T' z. ~) j1 P  w
161.         /*##-3- Read the flash     ########################*/
     $ v: Q- ]; o; {5 ^- D1 k1 I9 V
162.         /*读取数据，rData读取数据的指针，起始地址0x00，读取数据长度0x200*/
     / ^: X) D! t% t3 p; X2 }
163.         if(BSP_W25Qx_Read(rData2,0x11000,0x200)== W25Qx_OK)
     1 U" |5 L: c. G. f* S  c
164.                 printf("读取第17扇区前0x200数据成功！\r\n\r\n");
     : l9 e5 }* |3 i2 V
165.         else
       W- A1 w3 f2 z9 m$ c# {' [* A7 h
166.                 Error_Handler();
     
167.         /*打印数据*/        
     6 c' _3 [6 Z' \# N; ^4 b- Y
168.         printf("读取第17扇区前0x200数据为: \r\n");
     & e8 u' Z8 y' H) |$ z9 p0 H
169.         
     
170.         for(i =0;i<0x200;i++)
     8 F4 m+ B( ?/ ?
171.         {
     
172.                 if(i%20==0)
     3 P. ^' w0 y) Y0 @3 M8 t( f# e2 ]
173.                         printf("\n第%d到%d的数据为：\r\n",i,i+19);
     
174.                                 printf("0x%02X  ",rData2);
     
175.         }
     
176. 
     # }6 o# H3 ?5 U% S, f: s6 U
177.         printf("\n");
     
178. 
     
179. 
     
180. /**************************清除第34扇区数据为0**************************************************************/
     6 Z5 \! M, G* ?& q) Z
181. 
     ' U, f: S6 n% k0 s
182. 
     % i( n8 g4 b  D2 O$ [
183.         
     8 s6 Q( c6 B7 T0 i5 I" V
184.         /*##-2- Erase Block ##################################*/
     
185.         if(BSP_W25Qx_Erase_Block(0x22000) == W25Qx_OK)
     
186.                 printf(" QSPI Erase Block ok\r\n");
     
187.         else
     : |0 w% Y) g! L; o- n* r$ g8 K1 b
188.                 Error_Handler();
     
189.         
     
190.         /*##-2- Written to the flash ########################*/
     8 r* A- O" Z" L7 @  k, v# c1 X
191.         /* fill buffer */
     
192.         printf(" 初始化数据，清零第34扇区前0x200的数据！\r\n");
     
193.         for(i =0;i<0x200;i ++)
     
194.         {
     3 m2 h- y7 K" q$ Z$ b
195.                         wData3 = 0;
     
196.                   rData3 = 0;
     ( J$ \0 S" w9 N7 g$ X, `
197.         }
     " M7 _& Z7 n6 W9 a2 D" F; [
198.         /*写入数据，wData写入数据的指针，起始地址0x22000，写入数据长度0x200*/
     
199.         if(BSP_W25Qx_Write(wData3,0x22000,0x200)== W25Qx_OK)
     ( b9 T: \! [, O/ w5 j" D' G, {
200.                 printf("清零第34扇区前0x200的数据成功！\r\n");
     0 S- M9 [% n$ c$ C9 M
201.         else
     
202.                 Error_Handler();
     
203. 
     8 y1 L- t, R$ c6 M
204.         
     
205.         
     
206.         
     
207.         /*##-3- Read the flash     ########################*/
     
208.         /*读取数据，rData读取数据的指针，起始地址0x00，读取数据长度0x200*/
     
209.         if(BSP_W25Qx_Read(rData3,0x22000,0x200)== W25Qx_OK)
     
210.                 printf("读取第34扇区前0x200数据成功！\r\n\r\n");
     # _( W0 [+ a8 \$ Y6 g
211.         else
     % @, X3 q* r% \
212.                 Error_Handler();
     5 L, Z) v  u1 E) i/ k3 d
213.         /*打印数据*/        
     
214.         printf("读取第34扇区前0x200数据为: \r\n");
     - f0 G3 q8 \: R1 \; I$ G
215.         
     
216.         for(i =0;i<0x200;i++)
     
217.         {
     
218.                 if(i%20==0)
     
219.                         printf("\n第%d到%d的数据为：\r\n",i,i+19);
     3 O0 K  W& c$ z: j& D0 d; e
220.                                 printf("0x%02X  ",rData3);
     
221.         }
     
222. 
     
223.         printf("\n");
     3 Q& h7 v& Y& E
224. 
     
225. 
     & H: G6 x" w: y/ w  ^
226.   /* USER CODE END 2 */

复制代码

) j, f0 r; J$ a主程序。

9 y/ w: B# U7 f+ H1 O; w" P, I! K

1.   /* Infinite loop */
   & [! M' e$ a5 p' h
2.   /* USER CODE BEGIN WHILE */
   
3.   while (1)
   
4.   {
   7 w# B% [2 }$ l# ]' U
5.     /* USER CODE END WHILE */
   0 k; ]5 M2 X1 U; p# i% t
6. 
   % S# S7 V) Z$ G
7.     /* USER CODE BEGIN 3 */
   4 ]) @( N0 _0 X  }" b8 ^
8.                 uart2_data();
   9 Q' V1 H3 ]3 ~) @* F
9.                 HAL_Delay(100);
   
10.                
    
11.   }
    
12.   /* USER CODE END 3 */

复制代码

, [/ ]8 ^" Y0 z数据处理
# ^8 C1 G5 }3 G% N: ]2 A- Z

1. /* USER CODE BEGIN 4 */
   5 c4 `  O5 ], W
2. void uart2_data(void)
   
3. {
   + g7 K8 |( r5 s
4.         if(recv_end_flag ==1)//接收完成标志
   
5.         {
   
6.         
   " T! M* R9 X7 k" P  p1 t
7. 
   
8. if(ReceiveBuff[0]==0x00)
   . o$ W4 W0 e. }! o9 e+ r" B
9.                 {
   1 q) A" N2 |. a
10.                         printf("写入数据长度：%d\n",Rx_len-2);
    1 h, V4 W( v; C
11.                         for(int i =0;i<Rx_len-2;i++)
    ' D4 F  Q7 ~; \2 h+ r
12.                         {
    7 z7 k' M5 Q) y1 X
13.                                 wData1[ (i+ReceiveBuff[1]) ] = ReceiveBuff[i+2];
    
14. 
    ) V. b7 X  U4 ~- @$ \) x, x! {7 t" r
15.                         }
    
16.                                 
    3 H1 Q, Z0 V1 x9 A/ q6 C7 _! f; E* Y
17. 
    
18.                 /*##-2- Erase Block ##################################*/
    
19.                 if(BSP_W25Qx_Erase_Block(0) == W25Qx_OK)
    . Z# B% r4 ~& l/ k+ T) R# l
20.                         printf(" QSPI Erase Block ok\r\n");
    
21.                 else
    " O: s# k4 p3 y, W# f8 B  L
22.                         Error_Handler();
    & c2 d6 D3 \" W& O+ U+ u' _
23. 
    6 t0 U1 y+ |! a( P8 w) N) l
24.                
    5 I% \' ]1 _5 n; G* @! Z6 b, i
25.                 /*写入数据，wData写入数据的指针，起始地址0x00，写入数据长度0x200*/
    2 {& t2 J/ M- b0 \( W; i' ^6 R2 Z
26.                 if(BSP_W25Qx_Write(wData1,0x00,0x200)== W25Qx_OK)
    
27.                         
    / R5 V, t' l- M
28.                         printf("扇区0数据成功~~~~~~~~~~~~~~~~~~~~~~~~~~！\r\n");
    
29.                 else
    * C3 G$ m' T. Q+ S1 ?
30.                         Error_Handler();
    ! {4 o8 ?0 I3 K- \6 |9 ^; n
31.                         
    # @9 Q0 d# p+ x1 K3 q; }
32.                 if(BSP_W25Qx_Read(rData1,0x00,0x200)== W25Qx_OK)
    
33.                         printf("读取扇区0前0x200数据成功！\r\n\r\n");
    
34.                 else
    
35.                         Error_Handler();
    ) O5 I+ M$ l. i$ t4 e0 e# w
36.                 /*打印数据*/        
    . j7 m" i& \* Q
37.                 printf("读取扇区0前0x200数据为: \r\n");
    
38.         
    
39.                 for(i =0;i<0x200;i++)
    " Y( u) D$ y  T: E7 P) T2 G
40.                 {
    
41.                         if(i%20==0)
    
42.                                 printf("\n第%d到%d的数据为：\r\n",i,i+19);
    
43.                                         printf("0x%02X  ",wData1);
    
44.                 }
    + F6 \5 ]' N# [7 j
45. 
    
46.                 printf("\n");
    5 F  s" j& a- A- B; j0 x6 k4 g
47.                
    & d6 N$ E# V7 ?- n
48.         }
    . j7 d* j8 U$ e9 J8 I- u4 D
49.                
    ) _/ V: O  l2 P+ D1 ^/ W
50.         
    
51.         
    % T+ e; C2 g" |" o) H
52.         else if(ReceiveBuff[0]==0x17)
    
53.         {
    
54.                         printf("写入数据长度：%d\n",Rx_len-2);
    
55.                         for(int i =0;i<Rx_len-2;i++)
    2 J. s) a5 A( b; ?$ X! {* ^: L
56.                         {
    
57. //                                Data=ReceiveBuff[i+2];
    9 d/ w1 o- m" k! ]9 N1 {& G
58.                                 wData2[ (i+ReceiveBuff[1]) ] = ReceiveBuff[i+2];
    4 B# l) p$ `- Q3 _& k
59.                         }
    , Z8 [9 q5 ~& q7 c0 r
60.                                 
    ( A# z; b( n3 V) [3 I: D% D0 K
61. 
    - T4 G$ a! R6 v% V* S
62.                 /*##-17- Erase Block ##################################*/
    
63.                 if(BSP_W25Qx_Erase_Block(0x11000) == W25Qx_OK)
    
64.                         printf(" QSPI Erase Block ok\r\n");
    
65.                 else
    
66.                         Error_Handler();
    
67. 
    
68.                
    " e/ W3 z/ a# t2 S; n8 R( m
69.                 /*写入数据，wData写入数据的指针，起始地址0x11000，写入数据长度0x200*/
    & x7 |7 I9 S7 y7 ~* l. i
70.                 if(BSP_W25Qx_Write(wData2,0x11000,0x200)== W25Qx_OK)
    
71.                         
    
72.                         printf("扇区17数据成功~~~~~~~~~~~~~~~~~~~~~~~~~~！\r\n");
    " h+ K7 M; A1 a: Y0 H
73.                 else
    
74.                         Error_Handler();
    
75.                         
    
76.                 if(BSP_W25Qx_Read(rData2,0x11000,0x200)== W25Qx_OK)
    8 e4 o) @7 t: Z
77.                         printf("读取扇区17前0x200数据成功！\r\n\r\n");
    
78.                 else
    
79.                         Error_Handler();
    1 ^$ ~/ B* b2 o  U" P4 e
80.                 /*打印数据*/        
    9 K& F9 w: v! I- p
81.                 printf("读取扇区17前0x200数据为: \r\n");
    
82.         
    
83.                 for(i =0;i<0x200;i++)
    0 n( j, _9 ^, q0 K) f3 j
84.                 {
    2 O. O9 X1 f# N- U
85.                         if(i%20==0)
    
86.                                 printf("\n第%d到%d的数据为：\r\n",i,i+19);
    
87.                                         printf("0x%02X  ",rData2);
    
88.                 }
    
89. 
    
90.                 printf("\n");
    3 n" R. A2 P  u; c! T1 |
91.                
    ! @2 P) _8 F0 c4 M! ^4 w% R8 i
92.         }               
    ) Y* ]5 S& c, y# i
93. 
    % f; D0 k+ F( J2 Z+ r2 p
94. 
    
95. 
    
96.         else if(ReceiveBuff[0]==0x34)
    
97.         {
      T& o: l/ C8 Q$ L& S( a& }
98.                         printf("写入数据长度：%d\n",Rx_len-2);
      G+ f. J0 |8 o% S9 f2 h# o7 g1 k6 N
99.                         for(int i =0;i<Rx_len-2;i++)
    
100.                         {
     
101. //                                Data=ReceiveBuff[i+2];
     
102.                                 wData3[ (i+ReceiveBuff[1]) ] = ReceiveBuff[i+2];
     3 s6 Y  q/ j* V
103.                         }
     5 ^% m& G% `- Y' V/ j
104.                                 
     
105. 
     ! a, I1 D5 C3 a2 ^
106.                 /*##-22- Erase Block ##################################*/
     ( G: F2 q% u0 X5 i4 o
107.                 if(BSP_W25Qx_Erase_Block(0x22000) == W25Qx_OK)
     
108.                         printf(" QSPI Erase Block ok\r\n");
     9 ^3 \: C+ \" ^8 |9 p( A2 P8 ^
109.                 else
     
110.                         Error_Handler();
     
111. 
     . v  E: e! w+ ~* R( Y, X% r5 w+ O& F) p
112.                
     : o8 j5 v6 ?6 F  a8 r0 _
113.                 /*写入数据，wData写入数据的指针，起始地址0x22000，写入数据长度0x200*/
     
114.                 if(BSP_W25Qx_Write(wData3,0x22000,0x200)== W25Qx_OK)
     
115.                         
     
116.                         printf("扇区34数据成功~~~~~~~~~~~~~~~~~~~~~~~~~~！\r\n");
     
117.                 else
     8 c! R. C: Y& `, `- I
118.                         Error_Handler();
     
119.                         
     
120.                 if(BSP_W25Qx_Read(rData3,0x22000,0x200)== W25Qx_OK)
     
121.                         printf("读取扇区34前0x200数据成功！\r\n\r\n");
     
122.                 else
     * Y( u" p7 ~, B1 e
123.                         Error_Handler();
     
124.                 /*打印数据*/        
     
125.                 printf("读取扇区34前0x200数据为: \r\n");
     - q# }$ J, W- \0 y
126.         
     - g: i! W& k$ Y9 r; J2 k, U" t
127.                 for(i =0;i<0x200;i++)
     ; g+ J/ Q+ a$ a
128.                 {
     
129.                         if(i%20==0)
     
130.                                 printf("\n第%d到%d的数据为：\r\n",i,i+19);
     
131.                                         printf("0x%02X  ",rData3);
     " _2 L) Z) g" ^  y3 N( L( Z! X
132.                 }
     8 m  |2 K0 c$ G) g% A" B- A5 L
133. 
     
134.                 printf("\n");
     
135.                
     $ k- j3 F+ P, ]: H; t8 ]0 h
136.         }        
     
137. 
     3 c4 b7 {/ q3 s/ Y. u* e$ u& Y- w
138. 
     " K3 q  M  M" [7 W
139. 
     
140.                
     7 s) |! h5 |, F) o. f$ X
141.                 else
     ! p, ~2 `! Z( ?$ k' f  e& Y9 k8 V
142.                         printf("输入错误！");
       z' `7 \2 f$ N, m7 P( r$ X3 {7 b
143. 
     # ?0 D. k3 d7 O4 ~
144.     for(int i = 0; i < Rx_len ; i++) //清空接收缓存区
     
145.     ReceiveBuff=0;//置0
     
146.     Rx_len=0;//接收数据长度清零
     
147.     recv_end_flag=0;//接收标志位清零
     
148.                 //开启下一次接收
     7 X. Q- ]& U* T+ a1 Z
149.     HAL_UART_Receive_DMA(&huart2,(uint8_t*)ReceiveBuff,BUFFERSIZE);
     2 Y  V2 O" z* O1 D1 {' S6 g1 s
150.     }
     
151. 
     ( T; M" y; H* H* D: d: i
152. }
     
153. 
     " w6 B3 \4 v) U; k
154. /* USER CODE END 4 */

复制代码

! E& s: H3 a) l* U0 S* N演示
- a1 u/ N3 z# v1 T2 n( `W25Q64芯片型号的ID为0XEF17，下方读取为0XC816，所以读取成功。
9 c5 \) C4 x) s0 j5 Z
* r- e2 h9 a  e- _5 d8 E/ {

开机会打印出0，17，34扇区的前0x200个数据。


( i2 A- Y5 Q4 V, E# L# l9 v# X4 k* [3 z
4 x% ]; r7 w3 u' X! F* L3 n打印完原始数据之后将数据全部清零，清零完成如下图所示。
6 X# g' ?3 t0 G

6 u: Z4 }  ?" K0 P0 Y
串口定义了ReceiveBuff[0]的数据为写入什么扇区，ReceiveBuff[0]为1写入扇区1，ReceiveBuff[0]为2写入扇区2，ReceiveBuff[0]为3写入扇区3，若为其他数据，则打印输入错误；ReceiveBuff[1]则为写入的位置。
6 [/ B+ `$ ?2 \2 r$ l/ \9 b# N  F% b2 F输入：00 05 01 02 03 04
7 z8 T  t  |/ ^5 L% \向扇区0的的05号位置开始写入数据01 02 03 04。

/ u  \5 U0 U( C- C4 g2 f
7 X! Y9 j* \! a* z, O
输入：00 28 11 12 13 14 15
9 I$ y) s* M% f- E向扇区0的的40(28是十六进制)号位置开始写入数据11 12 13 14 15。
' R; T% @7 g- @! q* _: ^" I' d5 j# k

2 ~2 L+ _& k$ m9 N
输入：17 10 aa bb
9 t( O2 K! ]: D7 n0 l9 e) s向扇区17的的16(10是十六进制)号位置开始写入数据aa bb。

7 u& \, k3 q# h: g" s6 W/ z
# c/ x! j, Q2 f: U7 W$ k
- W- U# Z1 z" x4 t————————————————
+ {* {) b) t6 [版权声明：记帖

) f3 h; n: n& i& i8 u1 u4 H
& b) z5 v% l& Y' n3 O1 l' `8 j/ s' ]6 G
' o2 ^9 |; f; A6 |$ _- @' D4 o5 z