一、实验前期准备
本次实验的 MCU 是 STM32F103C8T6 芯片，通过 SPI 通信实现 W25Q128 的读写操作。

. W4 V6 ]* F+ ~1. 原理图
9 i. j( Z; V9 x8 v7 ^1 A# ?. b' P


2. 引脚连接
4 s  l* s% P% V

+ P" l7 G. M" z/ }) F
二、SPI 底层驱动
SPI.c

1. #include "SPI.h"
   . e. l$ P/ [* J0 G3 k- D
2. 
   
3. /*
   " F0 V8 ], E# X+ Z% [
4.         SPI引脚初始化配置
     N" w; P% P/ x) Z5 N6 m
5.         **PA4------CS
   
6.         **PA5------SCLK
   , k- G$ U/ H- t0 c) c) N4 s( v4 D
7.         **PA6------MISO
   
8.         **PA7------MOSI
   ( O) m+ G; q& z. r& Y
9. */
   , r6 {2 d7 ~9 E* a# _
10. 
    
11. static void SPI1_GPIO_Config(void)        
    
12. {
    ( {% g9 ~* N3 x" s: p# ~
13.         GPIO_InitTypeDef GPIO_InitStructure;
    
14.         
    ' z3 D4 J& S+ A
15.         RCC_APB2PeriphClockCmd(        RCC_APB2Periph_GPIOA, ENABLE );//PORTA时钟使能
    
16. 
    $ L  _( C" P1 Y& @' s1 Z
17.         GPIO_InitStructure.GPIO_Pin = GPIO_Pin_5| GPIO_Pin_6|GPIO_Pin_7;
    
18.         GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;  //PA5/6/7复用推挽输出
    
19.         GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
    
20.         GPIO_Init(GPIOA, &GPIO_InitStructure);                                                //初始化GPIOA
      F0 h; ]- ?) \+ u
21.         
    
22.         GPIO_InitStructure.GPIO_Pin = GPIO_Pin_4;
    6 M' b( g9 m! `1 b
23.         GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;  //PA4推挽输出
    7 L* t& [' ~# S2 v% K2 e7 }6 ~: Q9 S! c
24.         GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
    
25.         GPIO_Init(GPIOA, &GPIO_InitStructure);                                                //初始化GPIOA
    
26. 
    7 z$ S, E% `- w5 k
27.         GPIO_SetBits(GPIOA,GPIO_Pin_4|GPIO_Pin_5|GPIO_Pin_6|GPIO_Pin_7); //初始上拉输出
    ( b' S! ~. o) S; i- G5 W& X
28. 
    ( A( F8 ~5 R5 }, [9 ^, T
29. }
    
30. 
    
31. //SPI1初始化函数
    # T( u( n" H$ s4 \  f7 ~
32. void SPI1_Init(void)
    
33. {
    : c: B9 D7 L- n( Q. L
34.         SPI1_GPIO_Config();//SPI引脚初始化配置        
    
35. 
    
36.         SPI_InitTypeDef  SPI_InitStructure;
    5 T$ A" y7 O: e$ k4 s( x7 X
37.         
    ; A9 y) M! |! L
38.         RCC_APB2PeriphClockCmd(        RCC_APB2Periph_SPI1,  ENABLE );//SPI1时钟使能         
    0 r! d  H& W% r1 A6 D3 }9 q" x
39.         
    
40.         SPI_InitStructure.SPI_Direction = SPI_Direction_2Lines_FullDuplex;          //设置SPI单向或者双向的数据模式:SPI设置为双线双向全双工
    . Y# Y! |( S/ G; B- S) f+ p3 [
41.         SPI_InitStructure.SPI_Mode = SPI_Mode_Master;                                                                                                        //设置SPI工作模式:设置为主SPI
    
42.         SPI_InitStructure.SPI_DataSize = SPI_DataSize_8b;                                                                                        //设置SPI的数据大小:SPI发送接收8位帧结构
    
43.         SPI_InitStructure.SPI_CPOL = SPI_CPOL_High;                                                                                                                //串行同步时钟的空闲状态为高电平
    
44.         SPI_InitStructure.SPI_CPHA = SPI_CPHA_2Edge;                                                                                                        //串行同步时钟的第二个跳变沿（上升或下降）数据被采样
    : I6 S* A6 g/ @: }9 s  @5 x
45.         SPI_InitStructure.SPI_NSS = SPI_NSS_Soft;                                                                                                                        //NSS信号由硬件（NSS管脚）还是软件（使用SSI位）管理:内部NSS信号有SSI位控制
    
46.         SPI_InitStructure.SPI_BaudRatePrescaler = SPI_BaudRatePrescaler_256;        //定义波特率预分频的值:波特率预分频值为256
    
47.         SPI_InitStructure.SPI_FirstBit = SPI_FirstBit_MSB;                                                                                //指定数据传输从MSB位还是LSB位开始:数据传输从MSB位开始
    9 P+ }, |  {$ D# q/ P% f3 B0 J! A
48.   SPI_InitStructure.SPI_CRCPolynomial = 7;        //CRC值计算的多项式
    
49.         SPI_Init(SPI1, &SPI_InitStructure);                          //根据SPI_InitStruct中指定的参数初始化外设SPIx寄存器
    0 q& w: Z0 A+ l, _
50.         
    ' N/ f: z& Z$ f* @
51.         SPI_Cmd(SPI1, ENABLE); //使能SPI外设
    % u! U3 r! l/ ?# J! T7 T  z9 [
52.         SPI1_ReadWriteByte(0xFF);//启动传输
    
53. }
    % a- x6 z( v  P/ J% U
54. 
    ( [% [. ~, {2 W' |. i
55. /*
    3 ~) e6 G& a& ~  T0 \& j! V4 D
56.         SPI的读写操作
    
57.         **TxData:要写入的字节
    
58.         **返回值:读取到的字节
    ) s$ R. J) B, j# o
59. */
    7 Z, s3 N" S6 s0 i2 B1 I
60. uint8_t SPI1_ReadWriteByte(uint8_t TxData)
    
61. {                                 
    9 C, R9 C2 @, g' n
62.         while (SPI_I2S_GetFlagStatus(SPI1, SPI_I2S_FLAG_TXE) == RESET) //检查指定的SPI标志位设置与否:发送缓存空标志位
    
63.         {
    ( p% i( T' a& E
64.                 //等待发送完成
    
65.         }                          
    
66.         SPI_I2S_SendData(SPI1, TxData); //通过外设SPIx发送一个数据
    7 P: f. s. Q. G
67.         while (SPI_I2S_GetFlagStatus(SPI1, SPI_I2S_FLAG_RXNE) == RESET) //检查指定的SPI标志位设置与否:接受缓存非空标志位
    * f) C! C* z" a
68.         {
    
69.                 //等待接收完成
    4 v3 p; @' f  r0 A; N5 ]- M! B
70.         }                                                              
    
71.         return SPI_I2S_ReceiveData(SPI1); //返回通过SPIx最近接收的数据                                            
    ! q0 C6 Y+ g# n& M3 p
72. }

复制代码

: t0 h# C( O& ?SPI.h
0 z% M6 e" ?. U

1. #ifndef __SPI_H
   
2. #define        __SPI_H
   
3. 
   
4. #include "stm32f10x.h"
   
5. 
   
6. #define SPI_CS(a)                if (a)        \
   
7.                                                 GPIO_SetBits(GPIOA,GPIO_Pin_4);\
   
8.                                                 else                \
   
9.                                             GPIO_ResetBits(GPIOA,GPIO_Pin_4)
   
10. 
    ( s" w; Q) S9 V; ^1 J5 w
11. void SPI1_Init(void);//SPI1初始化函数
    
12. uint8_t SPI1_ReadWriteByte(uint8_t TxData);//SPI1读写函数
    , E9 H+ T& G" X
13. 
    
14. #endif

复制代码

三、读取 W25Q128 设备 ID
本次实验是：读取 W25Q128 设备 ID，然后通过串口1打印出来。
通过简单的实验来调试，有利于发现问题。
- U6 C' c, W7 q$ q5 e' V- y通过W25Q128的数据手册可知其设备ID如下图所示：
9 S: i1 p8 @% |9 l% ]( F. i- _7 l

5 I! y' a) o! @
W25Q128.c

1. #include "W25Q128.h"
   
2. #include "SPI.h"
   5 ]8 e0 M" H- B1 ]9 I. G& {
3. 
   ; f7 t* x0 r4 C$ T4 \" `2 g
4. 
   
5. uint8_t W25Q128_ReadWriteByte(uint8_t TxData)//函数包装一下
   
6. {     
   % i0 Z: D) ~) A* O* x* R8 G7 z
7.            return SPI1_ReadWriteByte(TxData);                 
   
8. }
   
9. 
   
10. uint16_t W25Q128_ReadID(void)//读取芯片ID
    ; w& s3 \+ q; y4 D% k6 E
11. {
    
12.         uint16_t Temp = 0;         
    + b1 z. ?1 a- I6 ~6 @$ h
13.         W25Q128_CS(0);                                    
    , w7 [8 p( A) f' T- t) ?
14.         W25Q128_ReadWriteByte(W25X_ManufactDeviceID);//发送读取ID命令            
    9 N- |/ d5 ?! p
15.         W25Q128_ReadWriteByte(0x00);            
    
16.         W25Q128_ReadWriteByte(0x00);            
    7 S2 D8 B7 k' l5 z. [/ S$ ?; j
17.         W25Q128_ReadWriteByte(0x00);                                    
    + }) C4 B/ h6 A8 W! W$ T- O
18.         Temp|=W25Q128_ReadWriteByte(0xFF)<<8;  
    
19.         Temp|=W25Q128_ReadWriteByte(0xFF);         
    
20.         W25Q128_CS(1);                                    
    & P, e# _! d0 D/ p
21.         return Temp;
    
22. }

复制代码

W25Q128.h
4 x. Y& B2 j4 b  j$ z$ O5 S# \

1. #ifndef __W25Q128_H
   1 K% B( r# R, _) v9 R9 v1 V
2. #define        __W25Q128_H
   
3. 
   
4. #include "stm32f10x.h"
   
5. 
   5 e! y2 e( b: _) w$ u( e
6. //操作指令表
   / P0 I" j; y( p4 w% z
7. #define W25X_ManufactDeviceID         0x90       //制造商+设备ID
   ; U# Q$ @; g5 n5 t  [
8. 
   * }  ]% `# ~$ f: {/ T
9. #define W25Q128_CS(a) SPI_CS(a)        
   0 q2 s; g5 j5 P3 F8 K8 W! |0 {7 R
10. 
    
11. uint8_t W25Q128_ReadWriteByte(uint8_t TxData);//函数包装一下
    
12. uint16_t W25Q128_ReadID(void);//读取芯片ID
    " V# h9 C" J* V) Y( o
13. 
    
14. #endif

复制代码

main.c
# c$ C' ?8 ?0 L) p; R

1. #include <stdio.h>
   - [) R7 o2 T9 t8 u
2. #include "Uart1.h"
   # Y7 s; j- L& ]0 w* P* J' Y
3. #include "delay.h"
   , }4 m- G; y4 }. r: J5 G# k* D5 d
4. #include "SPI.h"
   
5. #include "W25Q128.h"
   
6. 
   
7. uint16_t W25Q128_ID=0;
   2 P$ e) Y, H& C% X1 d+ ?8 K$ |; R/ z
8. 
   
9. int main (void)
   
10. {
    
11.         Uart1_init();
    0 p2 j, Q, f8 A9 U' {5 g6 x
12.         SPI1_Init();
    9 D) p4 _7 D' s  D: N6 M6 I
13.         
    
14.         W25Q128_ID = W25Q128_ReadID();
    9 q" }  b; D& j6 y* y- f! S5 R8 ?/ F, G
15.         while(1)
    3 i! i: Z: w( `' w
16.         {
    + A6 {2 F4 }! P; R# Y
17.                 printf("\nW25Q128_ID=0x%X\n",W25Q128_ID);
    5 h: z9 W$ O+ q4 @+ Y/ ~
18.                 delay_ms(500);
    
19.         }
    ! q' k' P' e! Y2 {. f
20. }

复制代码

实验结果

  U8 N9 q$ I6 ?' k1 g
! r) Z" e& l2 @' b% H6 ^4 Z接收到 W25Q128 设备ID 为0xEF17

四、读写 W25Q128 外部 Flash
1 M# T! p# a$ p2 v  l% g( BW25Q128.c

1. #include "W25Q128.h"
   , l- R4 x$ C- s0 J% M- a2 x
2. #include "SPI.h"
   5 ^/ q  ~) t% b6 M  B
3. 
   
4. 
     `+ l- o& |6 `$ A5 C2 s( q  g
5. uint8_t W25Q128_ReadWriteByte(uint8_t TxData)//函数包装一下
   
6. {     
   0 Y! J( {7 u( _  \
7.          return SPI1_ReadWriteByte(TxData);                 
   2 P* M' [# G! }% D) S) T
8. }
   
9. 
   
10. 
    : D5 U: K' S3 B' Q* d
11. uint16_t W25Q128_ReadID(void)//读取芯片ID
    
12. {
      J' G* c, I2 m4 g, c
13.         uint16_t Temp = 0;         
    * A( |2 y, W/ H2 `2 g+ n7 v
14.         W25Q128_CS(0);                                    
    
15.         W25Q128_ReadWriteByte(W25X_ManufactDeviceID);//发送读取ID命令            
    - \8 Z9 l/ R* G) w) b5 [# L
16.         W25Q128_ReadWriteByte(0x00);            
    3 y5 |8 ^2 V3 ]9 x3 p
17.         W25Q128_ReadWriteByte(0x00);            
    
18.         W25Q128_ReadWriteByte(0x00);                                    
    ( [6 s; i* K/ |" r# I5 z
19.         Temp|=W25Q128_ReadWriteByte(0xFF)<<8;  
      G( M7 Z/ K# ?% `2 g
20.         Temp|=W25Q128_ReadWriteByte(0xFF);         
    
21.         W25Q128_CS(1);                                    
    
22.         return Temp;
    ; h5 w6 q& z5 t$ r1 |5 Q
23. }
    , H# X2 P: `/ E2 Z* t; |. |! D
24. 
    
25. //读取W25Q128的状态寄存器
    # t& N3 l0 \$ _9 e6 Y2 j1 R
26. //BIT7  6   5   4   3   2   1   0
    
27. //SPR   RV  TB BP2 BP1 BP0 WEL BUSY
    
28. //SPR:默认0,状态寄存器保护位,配合WP使用
    
29. //TB,BP2,BP1,BP0:FLASH区域写保护设置
    4 b& |8 K- B' g7 I/ Y8 u' J. W! ^( ]  h
30. //WEL:写使能锁定
    1 U$ q7 M2 O' q4 t" }" S
31. //BUSY:忙标记位(1,忙;0,空闲)
    
32. //默认:0x00
    
33. uint8_t W25Q128_ReadSR(void)//读取状态寄存器
    
34. {
    
35.     uint8_t byte=0;
    
36.     W25Q128_CS(0);                               //使能器件
    
37.     W25Q128_ReadWriteByte(W25X_ReadStatusReg1);  //发送读取状态寄存器命令
    
38.     byte=W25Q128_ReadWriteByte(0Xff);            //读取一个字节
    
39.     W25Q128_CS(1);                               //取消片选
    
40.     return byte;
    - G$ e3 x1 A# p2 k* {, c2 K
41. }
    
42. 
    
43. //写W25Q128状态寄存器
    1 z3 \; O* @" D! z4 _
44. //只有SPR,TB,BP2,BP1,BP0(bit 7,5,4,3,2)可以写!!!
    
45. void W25Q128_WriteSR(uint8_t sr)//写状态寄存器
    
46. {
    
47.     W25Q128_CS(0);                                           //使能器件
    
48.     W25Q128_ReadWriteByte(W25X_WriteStatusReg1);        //发送写取状态寄存器命令
    5 D$ Y- V5 H# S9 ?$ r, G$ T
49.     W25Q128_ReadWriteByte(sr);                               //写入一个字节
    * p/ W% U2 R; w! ]& B! B
50.     W25Q128_CS(1);                                            //取消片选
    2 {( C" m, a3 {+ c" r  C
51. }
    . x- @' l4 O  ~. r
52. 
    
53. void W25Q128_Write_Enable(void) //写使能
    
54. {
    
55.            W25Q128_CS(0);        
    6 [2 x5 K4 b) S2 `5 n3 u0 R
56.         W25Q128_ReadWriteByte(W25X_WriteEnable);
    ) y/ j0 P" \4 @% \6 H+ g
57.         W25Q128_CS(1);        
    
58. }
    ( `5 E' H4 h# G4 I  d/ x- A; ]
59. 
    
60. void W25Q128_Write_Disable(void) //禁止写入        
    3 N" p' |- W: q+ T; O( X7 F7 \
61. {
    
62.            W25Q128_CS(0);        
    
63.         W25Q128_ReadWriteByte(W25X_WriteDisable);
    
64.         W25Q128_CS(1);        
    
65. }
    1 M0 m3 ]: C% P
66. 
    . C1 L  `3 G9 S* O) m6 V4 g
67. void W25Q128_Read(uint8_t* pBuffer,uint32_t ReadAddr,uint16_t NumByteToRead)   
    
68. {                                                     
    
69.         W25Q128_CS(0);                                  //使能器件   
    
70.     W25Q128_ReadWriteByte(W25X_ReadData);      //发送读取命令  
    
71.     W25Q128_ReadWriteByte((uint8_t)((ReadAddr)>>16));   //发送24bit地址   
    , y3 Z, ]! R0 O$ P4 E' Y, g
72.     W25Q128_ReadWriteByte((uint8_t)((ReadAddr)>>8));   
    
73.     W25Q128_ReadWriteByte((uint8_t)ReadAddr);   
    / c5 ^# s( _4 w( r: ?4 I' H0 n
74.     for(uint16_t i=0;i<NumByteToRead;i++)
    
75.         {
    
76.        pBuffer<i>=W25Q128_ReadWriteByte(0XFF);    //循环读数  
    
77.     }
    
78.         W25Q128_CS(1);                                                  
    - ~& E/ Q# q2 I6 ~; b4 S* P
79. }  
    & |% X8 t$ s" w
80. 
    ; P/ N) [& H2 C( j/ w& I
81. 
    
82. void W25Q128_Write_Page(uint8_t* pBuffer,uint32_t WriteAddr,uint16_t NumByteToWrite)
    4 h6 M# D( s' o# G8 J9 m! a. T3 J0 w" [) y
83. {
    ; W" Y% l5 S/ w/ X
84. 
    
85.     W25Q128_Write_Enable();                  //SET WEL
    
86.         W25Q128_CS(0);                            //使能器件   
    
87.     W25Q128_ReadWriteByte(W25X_PageProgram);   //发送写页命令   
    
88. 
    1 D/ r: ?* f: ^" F" r0 |% M
89.     W25Q128_ReadWriteByte((uint8_t)((WriteAddr)>>16)); //发送24bit地址   
    6 O. A7 K3 V$ w7 h
90.     W25Q128_ReadWriteByte((uint8_t)((WriteAddr)>>8));   
    ) W" f) K8 Q8 x% I6 l
91.     W25Q128_ReadWriteByte((uint8_t)WriteAddr);   
    
92.     for(uint16_t i=0;i<NumByteToWrite;i++)
    1 E4 e3 L) L- \1 g  W/ M+ Q
93.         {
    
94.                 W25Q128_ReadWriteByte(pBuffer<i>);//循环写数  
    " L: o" w# J( z  G+ X
95.         }
    
96.         W25Q128_CS(1);                            //取消片选
    
97.         W25Q128_Wait_Busy();                                           //等待写入结束
    
98. }
    # e; Z. u! B/ d+ I* o" C3 J& h
99. 
    
100. //无检验写SPI FLASH
     
101. //必须确保所写的地址范围内的数据全部为0XFF,否则在非0XFF处写入的数据将失败!
     2 J8 H' T5 o& j* E7 o) }4 S, e
102. //具有自动换页功能
     
103. void W25Q128_Write_NoCheck(uint8_t* pBuffer,uint32_t WriteAddr,uint16_t NumByteToWrite)   
     
104. {                                          
     0 z4 i! l2 d! H- X- D( }
105.         uint16_t pageremain=256-WriteAddr%256; //单页剩余的字节数                             
     7 t, h8 p6 y" j* {
106.         if(NumByteToWrite<=pageremain)pageremain=NumByteToWrite;//不大于256个字节
       d3 R4 o% J4 x2 [( ?% i( t' G5 s
107.         while(1)
     
108.         {           
     : z1 e  X5 q+ n8 Z- B, N! w
109.                 W25Q128_Write_Page(pBuffer,WriteAddr,pageremain);
     ! F3 `8 K; z  x% v8 U
110.                 if(NumByteToWrite==pageremain)        break;//写入结束了
     
111.                  else
     - B5 k0 A) ~4 o+ H: S3 {; g/ t$ c5 r
112.                 {
     
113.                         pBuffer+=pageremain;
       N/ E0 Y2 }8 o+ |* {" }
114.                         WriteAddr+=pageremain;        
     
115.                         NumByteToWrite-=pageremain;                          //减去已经写入了的字节数
     7 ]  u/ H2 I# [: {4 ]6 ~0 m
116.                         if(NumByteToWrite>256)pageremain=256; //一次可以写入256个字节
     
117.                         else pageremain=NumByteToWrite;           //不够256个字节了
     
118.                 }
     
119.         }            
     
120. }
     
121. 
     
122. //写SPI FLASH  
     
123. //在指定地址开始写入指定长度的数据
     
124. //该函数带擦除操作!
     
125. //pBuffer:数据存储区
     
126. //WriteAddr:开始写入的地址(24bit)                                                
     2 F' |& }: M/ i$ }
127. //NumByteToWrite:要写入的字节数(最大65535)   
       G4 P) p. S/ u  r. V/ \8 R
128. uint8_t W25Q128_BUFFER[4096];                 
     
129. void W25Q128_Write(uint8_t* pBuffer,uint32_t WriteAddr,uint16_t NumByteToWrite)   
     ( D$ {7 d* D5 V7 M
130. {
     
131.          uint16_t i;   
     
132.         uint8_t * W25Q128_BUF;         
     
133.     W25Q128_BUF=W25Q128_BUFFER;            
     / q; Q0 m& p& ]$ _
134.          uint32_t secpos = WriteAddr/4096;//扇区地址  
     
135.         uint16_t secoff = WriteAddr%4096;//在扇区内的偏移
     
136.         uint16_t secremain = 4096-secoff;//扇区剩余空间大小   
       x$ }$ [4 V, I% ?7 h& k
137. 
     - g; a9 D( v9 ~; z) s1 Z. j; c
138.          if(NumByteToWrite<=secremain)                secremain=NumByteToWrite;//不大于4096个字节
     
139.         while(1)
     ( w8 \& V8 D8 h& S5 t
140.         {        
     ) Z- L9 g& c7 c, V
141.                 W25Q128_Read(W25Q128_BUF,secpos*4096,4096);//读出整个扇区的内容
     
142.                 for(i=0;i<secremain;i++)//校验数据
     & c. z/ s: @0 t5 ?
143.                 {
     2 _5 W  J/ C- G. Y9 `  L! J
144.                         if(W25Q128_BUF[secoff+i]!=0XFF)        break;//需要擦除            
     , h$ {) d# }. X; \, j
145.                 }
     
146.                 if(i<secremain)//需要擦除
     
147.                 {
     
148.                         W25Q128_Erase_Sector(secpos*4096);//擦除这个扇区
     
149.                         for(i=0;i<secremain;i++)           //复制
     4 d9 Y" W& H2 O
150.                         {
     
151.                                 W25Q128_BUF[i+secoff]=pBuffer<i>;         
     ( f. x& K+ c  m" O+ `0 K
152.                         }
     
153.                         W25Q128_Write_NoCheck(W25Q128_BUF,secpos*4096,4096);//写入整个扇区  
     
154. 
     
155.                 }else W25Q128_Write_NoCheck(pBuffer,WriteAddr,secremain);//写已经擦除了的,直接写入扇区剩余区间.                                    
     ! x* X' `  y1 X# G4 J( X
156.                 if(NumByteToWrite==secremain)        break;//写入结束了
     
157.                 else//写入未结束
     1 w- y, v: j/ k% _% f/ t2 `9 g6 Q
158.                 {
     
159.                         secpos++;//扇区地址增1
     
160.                         secoff=0;//偏移位置为0         
     
161. 
     
162.                     pBuffer+=secremain;  //指针偏移
     
163.                         WriteAddr+=secremain;//写地址偏移           
     
164.                     NumByteToWrite-=secremain;                                //字节数递减
     - I" G2 S/ Z% z; u: W/ A
165.                         if(NumByteToWrite>4096)        secremain=4096;        //下一个扇区还是写不完
     
166.                         else         secremain=NumByteToWrite;                //下一个扇区可以写完了
     : A! `; L: r3 B0 N& e+ h1 g" V
167.                 }         
     0 k& f0 ^+ a0 _! n, ?1 b1 t
168.         }         
     5 T1 \8 l1 o6 {, w
169. }
     . C) X( y4 W% O* B7 Q
170. 
     9 }0 Y( T+ F; G9 N
171. //擦除一个扇区
     ! W% M0 {/ j7 J+ @, d( u
172. //Dst_Addr:扇区地址 根据实际容量设置
     
173. //擦除一个扇区的最少时间:150ms
     
174. 
     ! C" v6 G1 L: R
175. void W25Q128_Erase_Sector(uint32_t Dst_Addr)   
     
176. {  
     # t$ {! h; P* V, d; J. @  `
177.     W25Q128_Write_Enable();                  //SET WEL         
     
178.     W25Q128_Wait_Busy();   
     & ~' m4 A  V- J- r& `, M7 o4 a3 Y
179.           W25Q128_CS(0);                            //使能器件   
     
180.     W25Q128_ReadWriteByte(W25X_SectorErase);   //发送扇区擦除指令
     - ?" f8 k, `' c8 }4 g9 g
181.     W25Q128_ReadWriteByte((uint8_t)((Dst_Addr)>>16));  //发送24bit地址   
     
182.     W25Q128_ReadWriteByte((uint8_t)((Dst_Addr)>>8));   
     
183.     W25Q128_ReadWriteByte((uint8_t)Dst_Addr);  
     $ I, {* n) u. ~* X
184.         W25Q128_CS(1);                                    //取消片选                  
     9 C0 v- Y; x7 G
185.     W25Q128_Wait_Busy();                                               //等待擦除完成
     
186. }  
     
187. 
     9 m, @7 j0 ^0 k( @% @8 s
188. //擦除整个芯片                  
     % x8 I( j9 T8 `6 d/ A' I# ?# g( O
189. //等待时间超长...
     / F! s$ A5 D) O# T' Y
190. void W25Q128_Erase_Chip(void)   
     : s( q3 Z; X2 E' g$ Q9 P
191. {                                   
     # w: o  \+ B3 N9 f& ?- s% W0 F. Y
192.     W25Q128_Write_Enable();                  //SET WEL
     ) {2 l) f7 n, G% f' O" d# w8 R- S
193.     W25Q128_Wait_Busy();   
     ( E: j1 |- K9 x( b" j
194.           W25Q128_CS(0);                           //使能器件   
     
195.     W25Q128_ReadWriteByte(W25X_ChipErase);   //发送片擦除命令  
     
196.         W25Q128_CS(1);                           //取消片选                  
     
197.         W25Q128_Wait_Busy();                                              //等待芯片擦除结束
     + p" p( w9 Q; G+ h. @
198. }
     2 Z1 T. `7 ?/ W3 y* ~
199. 
     
200. 
     6 b9 K2 j$ l) i  v+ n  y
201. //等待空闲
     
202. void W25Q128_Wait_Busy(void)   
     5 u5 s, M* g* E" Y/ q1 a
203. {   
     
204.         while((W25Q128_ReadSR()&0x01)==0x01);   // 等待BUSY位清空
     ) v/ [' }+ `# L: l0 b  p
205. }  
     
206. 
     
207. //进入掉电模式
     # i+ |/ z( c5 C' K/ d6 J; ?
208. void W25Q128_PowerDown(void)   
     5 c  A: \" n. z' s8 S! V
209. {
     + r; w/ C) J- b9 M
210.           W25Q128_CS(0);                            //使能器件   
     / X( [0 s  u6 e" O- R3 ~
211.     W25Q128_ReadWriteByte(W25X_PowerDown);    //发送掉电命令  
     ( Z+ d3 K) V' p8 N# m  |
212.         W25Q128_CS(1);                            //取消片选                  
     : T; }) s9 S- [% o3 {
213. }   
     1 n6 P5 A9 C0 r$ _6 e4 X2 O7 {
214. //掉电唤醒
     
215. void W25Q128_WAKEUP(void)   
     3 _+ ?# ~( V  q  t. Z* [( C* R
216. {  
     
217.           W25Q128_CS(0);                                //使能器件   
     , E9 @+ Y# h8 j* T! L
218.     W25Q128_ReadWriteByte(W25X_ReleasePowerDown);   
     
219.         W25Q128_CS(1);                                //取消片选                  
     
220. }   </i></i></i>

复制代码

6 h1 I$ T- u! K8 aW25Q128.h
! y( W) b( ~( N5 g5 g#ifndef __W25Q128_H
#define        __W25Q128_H
0 ~' @! ~* d% i& W9 B' ^2 l7 `
$ @, M' j5 V2 l8 p#include "stm32f10x.h"
1 s+ \& _' B/ o1 Z. A- G. l: o
; H8 U. R$ N/ l4 W0 p( }//操作指令表
8 `: g/ y) W" ]) W( V' O1 ^5 f#define W25X_WriteEnable                           0x06         //写使能
#define W25X_WriteDisable                           0x04         //写禁止
#define W25X_ReadStatusReg1                         0x05         //读状态寄存器1
#define W25X_ReadStatusReg2                         0x35         //读状态寄存器2
/ l, [# x( A1 T) f! g#define W25X_ReadStatusReg3                         0x15         //读状态寄存器3
#define W25X_WriteStatusReg1                   0x01         //写状态寄存器1
#define W25X_WriteStatusReg2                   0x31         //写状态寄存器2
#define W25X_WriteStatusReg3                   0x11         //写状态寄存器3
3 h/ Z" @4 q* M+ `9 m" V4 {#define W25X_ReadData                                0x03         //读数据
4 F: {5 l" r3 z2 N* S' S7 q3 x3 n#define W25X_FastReadData                           0x0B         //快读
  G' w0 ]* p9 e- a" }# ?1 }* h2 o#define W25X_FastReadDual                           0x3B    //双输出快读
#define W25X_PageProgram                           0x02         //页编程
#define W25X_BlockErase                                   0xD8         //块擦除（64K）
2 ~4 o) k: K8 I' ], f#define W25X_SectorErase                           0x20    //扇区擦除（4K）
#define W25X_ChipErase                                   0xC7    //芯片擦除
+ A' d0 }% W, y9 k* @#define W25X_PowerDown                                   0xB9    //掉电
' a. \1 n9 ^+ T) m' h8 O" ^#define W25X_ReleasePowerDown                 0xAB    //释放掉电
#define W25X_DeviceID                            0xAB    //器件ID
#define W25X_ManufactDeviceID                 0x90    //制造商+设备ID
#define W25X_JedecDeviceID                         0x9F         //电子元件ID
) p, b/ {: D0 }2 l5 d2 j5 Z0 m8 {
- ]+ b* u5 O, |
2 P2 H1 ~# c' d3 V#define W25Q128_CS(a) SPI_CS(a)        
6 |+ @0 n( U* n0 C9 T6 E2 K) q
# f' s1 `2 f# k( ?6 z
" J) }; U1 T( A8 a5 T& Auint8_t W25Q128_ReadWriteByte(uint8_t TxData);//函数包装一下
0 s7 D8 }$ t. S3 s
: r3 \# ?1 ^& f! [# {uint16_t W25Q128_ReadID(void);//读取芯片ID
& J, ^% J9 A! G
3 O2 R4 D: d! R, u- `4 vuint8_t W25Q128_ReadSR(void);//读取状态寄存器
; R* z* \2 K0 ~0 b- Zvoid W25Q128_WriteSR(uint8_t sr);//写状态寄存器

% Y0 G3 N5 {4 t( jvoid W25Q128_Write_Enable(void);//写使能
5 Z# k+ w0 b4 ]6 P3 \$ \' N% |void W25Q128_Write_Disable(void);//禁止写入        

; t( n* x  W& u) [2 Ovoid W25Q128_Read(uint8_t* pBuffer,uint32_t ReadAddr,uint16_t NumByteToRead); //读取数据
. G4 C/ L3 p0 k* A7 I$ Jvoid W25Q128_Write_Page(uint8_t* pBuffer,uint32_t WriteAddr,uint16_t NumByteToWrite);//页写
void W25Q128_Write_NoCheck(uint8_t* pBuffer,uint32_t WriteAddr,uint16_t NumByteToWrite);//无检验写数据，可自动翻页
! \' S6 ?7 ?! K+ h! B5 ?void W25Q128_Write(uint8_t* pBuffer,uint32_t WriteAddr,uint16_t NumByteToWrite);//写入数据，带擦写功能

5 l8 g3 d6 z1 n/ Yvoid W25Q128_Erase_Sector(uint32_t Dst_Addr);//擦除扇区
% |' t8 Y7 S2 Svoid W25Q128_Erase_Chip(void);//擦除整个芯片        

' f6 t% I* X% D" Zvoid W25Q128_Wait_Busy(void);//等待空闲
void W25Q128_PowerDown(void); //进入掉电模式
void W25Q128_WAKEUP(void);//掉电唤醒
( [' t  o3 r, X2 x
#endif

1
, R' O8 z' s  Y- F" T' l2
3
4
0 b6 v: S/ D" }+ F4 I* w' n5
' G$ V$ u7 k' V" b9 _  q6 `! M* x& _$ U6
1 f' k! `6 R' I0 }. L7
; E# o$ Y/ M. `- o! h# ^* ]' @# H8
9
* Y3 p, p* h- ?7 q5 f10
11
12
13
14
1 Y- \. \/ I9 K. u; m, P, I2 R15
7 y# }( Z4 k3 m$ p. n( I16
7 S" O. I3 r- j: A+ ]: |. \, u17
3 w4 d2 G$ _' }; ?0 M  ~18
19
8 H3 I! B! `3 l) k20
) B( b, _4 P' {' [21
, F3 u1 E9 h3 _4 k3 T* B4 p5 \22
23
24
) u; L% _: p! _% c- A8 j' |25
26
27
5 O% b* [$ S% k# p+ s28
29
30
31
9 D: v  k- X% l32
9 W: C1 `+ o- P& }" X33
& X+ o0 m& _6 @$ h34
35
36
37
38
2 U( s' H4 h7 i% z# h) K39
( @8 s1 a- ]! q5 \40
41
42
* u7 y% x: [' H" Z4 Y) P" r  t) g43
44
45
& t2 _& ^- T4 S, D! p3 W" B46
47
48
49
6 C# V, P- \$ m) `5 E50
5 H8 a9 T' Q/ u) O$ B& c51
52
8 _) z! n( S- O53
3 Z1 M6 m- r  w4 _; b( r, {54
1 m8 i9 [6 ~7 P: xmain.c
# e& r3 O2 e- r- V' ]4 e#include <stdio.h>
#include "Uart1.h"
#include "delay.h"
#include "SPI.h"
) `& e2 |/ {& N, d% C: B  u$ ?#include "W25Q128.h"
7 y2 P' f; I' m* @1 x. M
uint16_t W25Q128_ID=0;
* E, W% n0 J- Y& b4 huint8_t Write_data[20]={1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20};
uint8_t Read_data[100];
/ b# {/ b- b2 k( e7 j& Y, K
. {$ \* z  t6 W: o( D0 ^( Pint main (void)
/ _* Q( ^0 y# o  S) p{
  r/ l" k$ U+ \0 v% s6 J        Uart1_init();
        SPI1_Init();
% f6 N  r  X. k+ A9 O        
        W25Q128_ID=W25Q128_ReadID();
        W25Q128_Write_Page(Write_data,0x01,20);
3 H& U4 K0 O* M! t( Y& S        
        while(1)
: x' S3 M6 ]# E  B0 H. [" R        {
" L" n: P5 t+ p: |' G                W25Q128_Read(Read_data,0x00,100);
1 ?0 W3 f/ S) g8 {% u                for(int i=0;i<100;i++)
                {
8 O% a) K! h  W: A                        printf(" 0x%X ",Read_data);
  L+ ]  J8 r- ~# o' y                }
. r3 I$ n4 L9 s: g. i                printf("\nW25Q128_ID=0x%X\n",W25Q128_ID);
: C- l( H( o( L( ?1 E* \5 z                delay_ms(500);
        }
}

1
2
3
" J  ~" B: a) M4
1 u' g8 L, \* J1 t1 a: B5
+ o# m, M* ], l4 \: j8 F6
7
3 I3 K! E: m  Z, c! g# ~5 Z8
9
10
! k3 e2 u) H# c) A; ?11
8 [7 O/ ^& M8 m) U6 C12
5 W6 K7 j- g6 ^3 K' L4 V5 I13
  p) s/ C- C+ o) Q14
, i: W5 m8 ?1 b7 `15
; I* v1 N! f. w0 m$ j16
! q. g( u, R/ Q3 x17
18
19
20
21
" \% g- J" j! a( E22
: ], D2 q( Y6 ?3 ?23
3 s9 |- v" z* }24
- c3 l# t) t& i( K5 v25
1 @( r# C' D$ m: w/ Y$ {26
( H- e: {, p, n0 I/ F# ^3 I0 D27
8 B- z/ M1 E1 g1 {5 l% k9 Y- M28
- Q  i  n" e4 \/ v* `- ~29
4 J' `& W: ^' l$ \5 Z& ?实验结果

% `* I) i/ U, Z! w) S————————————————
版权声明：根号五
0 m& N  i% Z" Y8 p; o% ]4 }* w
* Y+ M" G4 @6 @; t% s
( y; i) Q1 d8 a7 M- t+ v