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

/ x7 T+ p$ m7 z. ]1. 原理图



& e. l' i, O/ @+ Y, ~2. 引脚连接



二、SPI 底层驱动
SPI.c
) t% G0 L+ p+ X( u) f0 s7 b! I

1. #include "SPI.h"
   
2. 
   + G* X$ l% t. H
3. /*
   
4.         SPI引脚初始化配置
   5 ~  M$ H; n6 z0 n
5.         **PA4------CS
   & B5 ?6 \2 o- A& d" _
6.         **PA5------SCLK
   + |- ?' u1 c- ^
7.         **PA6------MISO
   
8.         **PA7------MOSI
   
9. */
   
10. 
      ~/ s+ Z# i$ s# L6 E
11. static void SPI1_GPIO_Config(void)        
    
12. {
    ' v' x  \$ N8 U+ t" r; ~( B/ M
13.         GPIO_InitTypeDef GPIO_InitStructure;
    
14.         
    
15.         RCC_APB2PeriphClockCmd(        RCC_APB2Periph_GPIOA, ENABLE );//PORTA时钟使能
    
16. 
    0 _; K, ]4 _/ ?* {  f) G
17.         GPIO_InitStructure.GPIO_Pin = GPIO_Pin_5| GPIO_Pin_6|GPIO_Pin_7;
    ; W  \# V, [' s( Q0 V, v! g: V
18.         GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;  //PA5/6/7复用推挽输出
    3 H; t1 M7 l5 c9 K" ]
19.         GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
    
20.         GPIO_Init(GPIOA, &GPIO_InitStructure);                                                //初始化GPIOA
    ' _! Y7 Z; r; h" V" j0 r
21.         
    5 M  J4 k- H8 k6 p" s  E
22.         GPIO_InitStructure.GPIO_Pin = GPIO_Pin_4;
    3 Y. U( V$ ~% L3 b8 G8 t4 D( V9 W
23.         GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;  //PA4推挽输出
    
24.         GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
      H3 I! a. I+ j2 I' O. I
25.         GPIO_Init(GPIOA, &GPIO_InitStructure);                                                //初始化GPIOA
    
26. 
    
27.         GPIO_SetBits(GPIOA,GPIO_Pin_4|GPIO_Pin_5|GPIO_Pin_6|GPIO_Pin_7); //初始上拉输出
    , E/ M) ?; x) Q, a5 u& X7 |! r
28. 
    
29. }
    
30. 
    - M7 w  _+ o+ p$ C/ P+ |
31. //SPI1初始化函数
    & r1 ~9 P; s" I7 H1 E
32. void SPI1_Init(void)
    ' B- d6 N4 w* G
33. {
    
34.         SPI1_GPIO_Config();//SPI引脚初始化配置        
    
35. 
    0 ?: m( q2 ^: e3 Q
36.         SPI_InitTypeDef  SPI_InitStructure;
    
37.         
    5 v4 P; n$ V" v9 Q
38.         RCC_APB2PeriphClockCmd(        RCC_APB2Periph_SPI1,  ENABLE );//SPI1时钟使能         
    6 x& c  K. g( D1 G3 f4 N$ F
39.         
    
40.         SPI_InitStructure.SPI_Direction = SPI_Direction_2Lines_FullDuplex;          //设置SPI单向或者双向的数据模式:SPI设置为双线双向全双工
    
41.         SPI_InitStructure.SPI_Mode = SPI_Mode_Master;                                                                                                        //设置SPI工作模式:设置为主SPI
      ?2 g- ^, r# E3 ?" m9 m* u  }  [" G
42.         SPI_InitStructure.SPI_DataSize = SPI_DataSize_8b;                                                                                        //设置SPI的数据大小:SPI发送接收8位帧结构
    
43.         SPI_InitStructure.SPI_CPOL = SPI_CPOL_High;                                                                                                                //串行同步时钟的空闲状态为高电平
    & \/ R1 N( V  m5 L. B$ J$ O5 j
44.         SPI_InitStructure.SPI_CPHA = SPI_CPHA_2Edge;                                                                                                        //串行同步时钟的第二个跳变沿（上升或下降）数据被采样
    6 C  L, V/ r8 O& e
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位开始
    * x3 J( z2 W% ~8 }3 C1 i! h
48.   SPI_InitStructure.SPI_CRCPolynomial = 7;        //CRC值计算的多项式
    
49.         SPI_Init(SPI1, &SPI_InitStructure);                          //根据SPI_InitStruct中指定的参数初始化外设SPIx寄存器
    
50.         
    
51.         SPI_Cmd(SPI1, ENABLE); //使能SPI外设
    4 w. {7 k5 K9 s0 M
52.         SPI1_ReadWriteByte(0xFF);//启动传输
    
53. }
    
54. 
    - }$ d* J! ?9 `4 @. ?% u
55. /*
    , D- M7 s/ d# a) X/ S2 g
56.         SPI的读写操作
    ( Q3 a' u3 ^/ c9 r/ R1 i5 _7 Y
57.         **TxData:要写入的字节
    - G0 R" {5 w5 c% t/ e( i
58.         **返回值:读取到的字节
    
59. */
    
60. uint8_t SPI1_ReadWriteByte(uint8_t TxData)
    0 }; i2 c6 Z% p# ^- k8 e7 E$ W
61. {                                 
    2 z( C6 v; p# Y( l" z
62.         while (SPI_I2S_GetFlagStatus(SPI1, SPI_I2S_FLAG_TXE) == RESET) //检查指定的SPI标志位设置与否:发送缓存空标志位
    $ q: [! s+ X0 M4 N3 L
63.         {
    
64.                 //等待发送完成
    % ^1 v1 P) N1 @) S( f4 j+ ^1 Y" F
65.         }                          
    
66.         SPI_I2S_SendData(SPI1, TxData); //通过外设SPIx发送一个数据
    
67.         while (SPI_I2S_GetFlagStatus(SPI1, SPI_I2S_FLAG_RXNE) == RESET) //检查指定的SPI标志位设置与否:接受缓存非空标志位
    
68.         {
    
69.                 //等待接收完成
    0 I) V5 J. D1 v/ C* v
70.         }                                                              
    
71.         return SPI_I2S_ReceiveData(SPI1); //返回通过SPIx最近接收的数据                                            
    
72. }

复制代码

SPI.h

1. #ifndef __SPI_H
   
2. #define        __SPI_H
   
3. 
   ( H. Q* y$ U( O: r8 [
4. #include "stm32f10x.h"
   * H% W  J0 [8 |% a" {
5. 
   
6. #define SPI_CS(a)                if (a)        \
   ( D# E! w, _4 v9 p
7.                                                 GPIO_SetBits(GPIOA,GPIO_Pin_4);\
   ! }' J" }7 @1 n! K
8.                                                 else                \
   ( t+ E3 l, M$ v* ]5 K3 s6 K
9.                                             GPIO_ResetBits(GPIOA,GPIO_Pin_4)
   7 t/ |+ T, o2 F$ y" g
10. 
    
11. void SPI1_Init(void);//SPI1初始化函数
    3 I! S0 M( S: U1 z9 u9 ]/ v
12. uint8_t SPI1_ReadWriteByte(uint8_t TxData);//SPI1读写函数
    
13. 
    
14. #endif

复制代码

# I7 |- k* a7 d* J( S) L三、读取 W25Q128 设备 ID
本次实验是：读取 W25Q128 设备 ID，然后通过串口1打印出来。
通过简单的实验来调试，有利于发现问题。
通过W25Q128的数据手册可知其设备ID如下图所示：

1 A* g9 Z" S' a! ?: s9 c6 N2 W
* |% F6 \# Z4 B0 a- O
W25Q128.c

1. #include "W25Q128.h"
   . q2 p! U4 ~' [6 ?" C
2. #include "SPI.h"
   $ \3 Y5 s/ q1 U+ v: E; L
3. 
   4 a  r; p8 d5 [2 d7 u# J
4. 
   
5. uint8_t W25Q128_ReadWriteByte(uint8_t TxData)//函数包装一下
   
6. {     
   
7.            return SPI1_ReadWriteByte(TxData);                 
   ) v# z$ D" B9 s" X
8. }
   
9. 
   
10. uint16_t W25Q128_ReadID(void)//读取芯片ID
    
11. {
    8 R1 A- j2 \0 y' V; I7 s7 S
12.         uint16_t Temp = 0;         
    
13.         W25Q128_CS(0);                                    
    
14.         W25Q128_ReadWriteByte(W25X_ManufactDeviceID);//发送读取ID命令            
    
15.         W25Q128_ReadWriteByte(0x00);            
    
16.         W25Q128_ReadWriteByte(0x00);            
    0 `/ _9 o8 J0 k. r
17.         W25Q128_ReadWriteByte(0x00);                                    
    
18.         Temp|=W25Q128_ReadWriteByte(0xFF)<<8;  
    & E! Z/ S: G: R  c
19.         Temp|=W25Q128_ReadWriteByte(0xFF);         
    
20.         W25Q128_CS(1);                                    
    * i  L* E2 Y2 F- b4 ^& j
21.         return Temp;
    : J1 s8 @% P! G' A+ p1 L, g7 y! w
22. }

复制代码

W25Q128.h
/ ^' I: a; f2 ?

1. #ifndef __W25Q128_H
   
2. #define        __W25Q128_H
   
3. 
     r2 v+ _3 k5 E4 }; O, b& S; C
4. #include "stm32f10x.h"
   - o( i/ D9 A: E2 _  Q$ A5 k! J
5. 
   $ v% K; Y1 ?4 v. v9 @' @$ }# G$ m/ r
6. //操作指令表
   ! C- o. k  ^' F2 N
7. #define W25X_ManufactDeviceID         0x90       //制造商+设备ID
   
8. 
   6 H3 S4 i: L8 r& N  ^+ Q6 O
9. #define W25Q128_CS(a) SPI_CS(a)        
     o8 [2 u, L# I8 `6 d# J
10. 
    # O1 C) L3 U: A6 E$ j7 f
11. uint8_t W25Q128_ReadWriteByte(uint8_t TxData);//函数包装一下
    
12. uint16_t W25Q128_ReadID(void);//读取芯片ID
    
13. 
    
14. #endif

复制代码

main.c
" ]% D; g9 E7 I, ~

1. #include <stdio.h>
   
2. #include "Uart1.h"
   8 c8 `& B5 A  g  A
3. #include "delay.h"
   
4. #include "SPI.h"
   0 }5 C8 g5 U5 m  P: I1 ?
5. #include "W25Q128.h"
   
6. 
   
7. uint16_t W25Q128_ID=0;
   1 _  k6 Y! a! S* ^4 M
8. 
   . G7 A( S& E0 a
9. int main (void)
   ' h1 v( ~' Q/ @( h( T: k& P) ~
10. {
    : v, X* L/ t; ]
11.         Uart1_init();
    ! ]) o3 P- {% N3 u
12.         SPI1_Init();
    * U6 R" A4 R) v
13.         
    3 o7 u0 J: h8 o, n+ y/ B. ]
14.         W25Q128_ID = W25Q128_ReadID();
    " w/ U; \: D4 v0 d, u- M
15.         while(1)
    
16.         {
    
17.                 printf("\nW25Q128_ID=0x%X\n",W25Q128_ID);
      }3 A, a7 R( J
18.                 delay_ms(500);
    
19.         }
    
20. }

复制代码

3 s- h2 T! w0 p" X/ Y) Q: Q实验结果


接收到 W25Q128 设备ID 为0xEF17

四、读写 W25Q128 外部 Flash
- A5 l) X& o% a3 [W25Q128.c

1. #include "W25Q128.h"
   
2. #include "SPI.h"
   5 I3 ~0 I; p( @. W! P3 q. e
3. 
   . }1 {7 Q% v( T( [: M$ y
4. 
   7 o& H- [  N$ ^: y- o6 }
5. uint8_t W25Q128_ReadWriteByte(uint8_t TxData)//函数包装一下
   
6. {     
   
7.          return SPI1_ReadWriteByte(TxData);                 
   
8. }
   
9. 
   , R! P  I3 N/ C/ k: [& P
10. 
    
11. uint16_t W25Q128_ReadID(void)//读取芯片ID
    ) J$ i7 r8 i" f6 b  B" }
12. {
      R# ]1 \5 ?+ |9 P" w1 K, q. z' S
13.         uint16_t Temp = 0;         
    8 y1 m2 i3 ?$ G/ n# q
14.         W25Q128_CS(0);                                    
    / P( W# c9 ^3 d. T: Z- O
15.         W25Q128_ReadWriteByte(W25X_ManufactDeviceID);//发送读取ID命令            
    
16.         W25Q128_ReadWriteByte(0x00);            
    
17.         W25Q128_ReadWriteByte(0x00);            
    2 i3 u& b+ C+ V  C% X0 \
18.         W25Q128_ReadWriteByte(0x00);                                    
    2 Q! ?5 M' z- s; w1 ~( T- v
19.         Temp|=W25Q128_ReadWriteByte(0xFF)<<8;  
    
20.         Temp|=W25Q128_ReadWriteByte(0xFF);         
    . ~9 R! z8 u# R
21.         W25Q128_CS(1);                                    
      P, }* A6 A( n/ L% L5 x
22.         return Temp;
    
23. }
    
24. 
    7 x6 h% R/ T7 V( w" E
25. //读取W25Q128的状态寄存器
    : ?$ r5 r% ?7 S8 c- v0 _( l, g' f6 E
26. //BIT7  6   5   4   3   2   1   0
    ' y: N! e7 b, ]' a' t, U
27. //SPR   RV  TB BP2 BP1 BP0 WEL BUSY
    . y& r$ R( s! a/ f; y3 a
28. //SPR:默认0,状态寄存器保护位,配合WP使用
    
29. //TB,BP2,BP1,BP0:FLASH区域写保护设置
    1 }) z& ]# ^- F% t+ `- O* m# k
30. //WEL:写使能锁定
    
31. //BUSY:忙标记位(1,忙;0,空闲)
    2 c% ~& W0 D/ ~0 w/ y4 X+ t- Q
32. //默认:0x00
    
33. uint8_t W25Q128_ReadSR(void)//读取状态寄存器
    ; D; ?- Z1 \$ R6 c
34. {
    - S$ U  S5 @0 m1 o  e" _/ ~" j' G
35.     uint8_t byte=0;
    
36.     W25Q128_CS(0);                               //使能器件
    
37.     W25Q128_ReadWriteByte(W25X_ReadStatusReg1);  //发送读取状态寄存器命令
    
38.     byte=W25Q128_ReadWriteByte(0Xff);            //读取一个字节
    % f. E3 D4 V1 m3 B
39.     W25Q128_CS(1);                               //取消片选
    
40.     return byte;
    
41. }
    
42. 
    
43. //写W25Q128状态寄存器
    
44. //只有SPR,TB,BP2,BP1,BP0(bit 7,5,4,3,2)可以写!!!
    ( G/ Z& |8 o2 n" O8 a3 B8 Y
45. void W25Q128_WriteSR(uint8_t sr)//写状态寄存器
    
46. {
    ! l* z4 f+ i/ i* y4 O7 J: ~% ^
47.     W25Q128_CS(0);                                           //使能器件
    . J& b: m% I7 p: u) o1 y3 M
48.     W25Q128_ReadWriteByte(W25X_WriteStatusReg1);        //发送写取状态寄存器命令
    
49.     W25Q128_ReadWriteByte(sr);                               //写入一个字节
    0 e3 t, N! s$ G6 m3 p
50.     W25Q128_CS(1);                                            //取消片选
    ) K0 u4 }, x5 r: u! h' b3 y* |7 I
51. }
    # V  R- h2 ?; n* m
52. 
    
53. void W25Q128_Write_Enable(void) //写使能
    & @. |; c  ]1 C; i1 W
54. {
    2 @6 q* M$ E' f, r
55.            W25Q128_CS(0);        
    ) x. D# Q9 {' U: q6 M( L
56.         W25Q128_ReadWriteByte(W25X_WriteEnable);
    ) F. d0 q. q, U
57.         W25Q128_CS(1);        
    
58. }
    6 j5 M1 @$ p2 s$ ~' J% [+ j3 e
59. 
    
60. void W25Q128_Write_Disable(void) //禁止写入        
    1 O1 W5 |0 n& r& G
61. {
    
62.            W25Q128_CS(0);        
    9 C! Y/ f! U; O/ H5 d% F2 E9 D
63.         W25Q128_ReadWriteByte(W25X_WriteDisable);
    - F  U5 u3 w. `8 T' P* V* n
64.         W25Q128_CS(1);        
    
65. }
    
66. 
    
67. void W25Q128_Read(uint8_t* pBuffer,uint32_t ReadAddr,uint16_t NumByteToRead)   
    
68. {                                                     
    
69.         W25Q128_CS(0);                                  //使能器件   
    
70.     W25Q128_ReadWriteByte(W25X_ReadData);      //发送读取命令  
    2 h5 u0 u& W% t2 T1 [
71.     W25Q128_ReadWriteByte((uint8_t)((ReadAddr)>>16));   //发送24bit地址   
    
72.     W25Q128_ReadWriteByte((uint8_t)((ReadAddr)>>8));   
    0 e& s' ~4 B4 M$ n( c9 H# Y9 a
73.     W25Q128_ReadWriteByte((uint8_t)ReadAddr);   
    
74.     for(uint16_t i=0;i<NumByteToRead;i++)
    
75.         {
    & O+ u6 ]5 L; K  k2 Z
76.        pBuffer<i>=W25Q128_ReadWriteByte(0XFF);    //循环读数  
    
77.     }
    + n) \" z/ M3 I1 \1 \; P
78.         W25Q128_CS(1);                                                  
    1 r& R- q5 v8 B: a( W5 G) f
79. }  
    
80. 
    
81. 
    
82. void W25Q128_Write_Page(uint8_t* pBuffer,uint32_t WriteAddr,uint16_t NumByteToWrite)
    
83. {
    + K! q* t$ M" M2 |6 ]) \
84. 
    
85.     W25Q128_Write_Enable();                  //SET WEL
    : A6 m8 o; ~1 t: C
86.         W25Q128_CS(0);                            //使能器件   
    
87.     W25Q128_ReadWriteByte(W25X_PageProgram);   //发送写页命令   
    & P! i, A- U9 g, j" O
88. 
    
89.     W25Q128_ReadWriteByte((uint8_t)((WriteAddr)>>16)); //发送24bit地址   
    
90.     W25Q128_ReadWriteByte((uint8_t)((WriteAddr)>>8));   
    2 N  ^2 H5 I5 B& f  d- a, w
91.     W25Q128_ReadWriteByte((uint8_t)WriteAddr);   
    # z8 a$ W" m! y: F  l& Y
92.     for(uint16_t i=0;i<NumByteToWrite;i++)
    
93.         {
    $ ^, L( K. R7 T. Q+ R" N6 O
94.                 W25Q128_ReadWriteByte(pBuffer<i>);//循环写数  
    
95.         }
    & o& _0 v- ~  n+ s
96.         W25Q128_CS(1);                            //取消片选
    , b7 J% c5 R4 F" l8 F2 n* J
97.         W25Q128_Wait_Busy();                                           //等待写入结束
    / U5 W& x0 W" ?+ c4 H% v
98. }
    
99. 
    2 g" s' w; R# G( i0 _
100. //无检验写SPI FLASH
     . F+ s! J# s- H- L! P- `" W
101. //必须确保所写的地址范围内的数据全部为0XFF,否则在非0XFF处写入的数据将失败!
     
102. //具有自动换页功能
     : c7 e& F; j- S! ?
103. void W25Q128_Write_NoCheck(uint8_t* pBuffer,uint32_t WriteAddr,uint16_t NumByteToWrite)   
     / }& z1 i9 b; w* _
104. {                                          
     6 x2 D8 b, v: i3 e/ ?
105.         uint16_t pageremain=256-WriteAddr%256; //单页剩余的字节数                             
     
106.         if(NumByteToWrite<=pageremain)pageremain=NumByteToWrite;//不大于256个字节
     
107.         while(1)
     9 Q$ s# o8 M0 O: U
108.         {           
     " Q; n) ~4 ?7 ^' g% e; b" i
109.                 W25Q128_Write_Page(pBuffer,WriteAddr,pageremain);
     
110.                 if(NumByteToWrite==pageremain)        break;//写入结束了
       a+ o2 O( R6 @* O  U
111.                  else
     1 x5 `1 ~$ J$ d" X* Z; X- d% ?) \
112.                 {
     # U3 v; ]5 s: ]
113.                         pBuffer+=pageremain;
     
114.                         WriteAddr+=pageremain;        
     
115.                         NumByteToWrite-=pageremain;                          //减去已经写入了的字节数
     
116.                         if(NumByteToWrite>256)pageremain=256; //一次可以写入256个字节
     7 K+ u6 {- {% T! ~2 o& T
117.                         else pageremain=NumByteToWrite;           //不够256个字节了
     ) R% f0 Z; C" H. q# ^7 I
118.                 }
     
119.         }            
     - M! a: c, C7 `
120. }
     " _, `# ]% ~; B1 }% E
121. 
     
122. //写SPI FLASH  
     " ?7 j( r, d; m
123. //在指定地址开始写入指定长度的数据
     
124. //该函数带擦除操作!
     1 w+ V- T/ \' V" z! O
125. //pBuffer:数据存储区
     
126. //WriteAddr:开始写入的地址(24bit)                                                
     7 f, \' j0 j( V% ^: H
127. //NumByteToWrite:要写入的字节数(最大65535)   
     
128. uint8_t W25Q128_BUFFER[4096];                 
     9 w- L1 n3 V! O1 c+ u1 V
129. void W25Q128_Write(uint8_t* pBuffer,uint32_t WriteAddr,uint16_t NumByteToWrite)   
     / }. V2 h2 r: ~+ V) t4 L
130. {
     ' w, b# J% L+ N+ o/ k; O( h
131.          uint16_t i;   
     1 P' h! k/ q: R
132.         uint8_t * W25Q128_BUF;         
     $ b- e. e+ ^5 Q. \8 I  ]! f
133.     W25Q128_BUF=W25Q128_BUFFER;            
     2 B) r8 c1 `7 d6 t- O' H
134.          uint32_t secpos = WriteAddr/4096;//扇区地址  
     
135.         uint16_t secoff = WriteAddr%4096;//在扇区内的偏移
     
136.         uint16_t secremain = 4096-secoff;//扇区剩余空间大小   
     6 ~! O% _) q! X% L
137. 
     & V: f& I1 o# D2 K( K- O
138.          if(NumByteToWrite<=secremain)                secremain=NumByteToWrite;//不大于4096个字节
     0 e; s: y) E: [9 \; n3 `, o& w
139.         while(1)
     
140.         {        
     
141.                 W25Q128_Read(W25Q128_BUF,secpos*4096,4096);//读出整个扇区的内容
     + s* g+ D. P- u
142.                 for(i=0;i<secremain;i++)//校验数据
     ) O" N6 ]' N- B8 {% c# U1 _' Z) A' g2 g
143.                 {
     
144.                         if(W25Q128_BUF[secoff+i]!=0XFF)        break;//需要擦除            
     
145.                 }
     6 I5 n& A- t5 J) j4 d
146.                 if(i<secremain)//需要擦除
     ! v) e1 b0 v& @2 g
147.                 {
     * }8 u* ]+ R7 q  ]! k
148.                         W25Q128_Erase_Sector(secpos*4096);//擦除这个扇区
     " w; Z$ W) @2 u. ?# y
149.                         for(i=0;i<secremain;i++)           //复制
     - A' u# w; ^# P: z
150.                         {
     * P+ c- W5 }& D# i+ a1 D1 f3 j
151.                                 W25Q128_BUF[i+secoff]=pBuffer<i>;         
     
152.                         }
     
153.                         W25Q128_Write_NoCheck(W25Q128_BUF,secpos*4096,4096);//写入整个扇区  
     8 c) }7 ~# a% ^0 Q. v! \
154. 
     / h( F% I2 ^+ h, A( _7 }# N$ Z% @. ]
155.                 }else W25Q128_Write_NoCheck(pBuffer,WriteAddr,secremain);//写已经擦除了的,直接写入扇区剩余区间.                                    
     
156.                 if(NumByteToWrite==secremain)        break;//写入结束了
     
157.                 else//写入未结束
     
158.                 {
     
159.                         secpos++;//扇区地址增1
     8 l' F. {$ h: \2 T# H
160.                         secoff=0;//偏移位置为0         
     
161. 
     
162.                     pBuffer+=secremain;  //指针偏移
     4 Y) V1 `) ?; K
163.                         WriteAddr+=secremain;//写地址偏移           
     . w. N: o- e. \! z' M, f
164.                     NumByteToWrite-=secremain;                                //字节数递减
     
165.                         if(NumByteToWrite>4096)        secremain=4096;        //下一个扇区还是写不完
     ! D% q8 [" v) Y4 M9 }. F
166.                         else         secremain=NumByteToWrite;                //下一个扇区可以写完了
     
167.                 }         
     
168.         }         
     
169. }
     7 X( v$ S5 D9 k" L
170. 
     2 ~- l5 O3 b7 Z2 {4 D9 r4 U- }
171. //擦除一个扇区
     
172. //Dst_Addr:扇区地址 根据实际容量设置
     4 G# @, y1 j9 v8 z, M$ `
173. //擦除一个扇区的最少时间:150ms
     
174. 
     0 g' H! l5 f& {  S& J
175. void W25Q128_Erase_Sector(uint32_t Dst_Addr)   
     : J% c! B! h; I3 u" C. ?2 G  s* j
176. {  
     & ]4 m1 ^" \( |2 \3 C
177.     W25Q128_Write_Enable();                  //SET WEL         
     " P9 ^: W0 G0 v
178.     W25Q128_Wait_Busy();   
     : A2 G; k7 e1 L2 Q* X3 k0 l
179.           W25Q128_CS(0);                            //使能器件   
     
180.     W25Q128_ReadWriteByte(W25X_SectorErase);   //发送扇区擦除指令
     
181.     W25Q128_ReadWriteByte((uint8_t)((Dst_Addr)>>16));  //发送24bit地址   
     * I& a' I3 L" o0 n$ r" j
182.     W25Q128_ReadWriteByte((uint8_t)((Dst_Addr)>>8));   
     8 `; J! `& q3 \2 o% m
183.     W25Q128_ReadWriteByte((uint8_t)Dst_Addr);  
     - _4 f, z1 F" z. ?3 J" P
184.         W25Q128_CS(1);                                    //取消片选                  
     4 U3 ^, d: a$ H
185.     W25Q128_Wait_Busy();                                               //等待擦除完成
     7 P4 A4 ~) F$ E9 L& r. E/ s
186. }  
     / l6 a# s# D# c" {/ i) u
187. 
     
188. //擦除整个芯片                  
     
189. //等待时间超长...
     ! A/ ~  \2 F" d
190. void W25Q128_Erase_Chip(void)   
     
191. {                                   
     $ \' D" H# E( X# Q& B
192.     W25Q128_Write_Enable();                  //SET WEL
     
193.     W25Q128_Wait_Busy();   
     1 p  j6 E& B" y$ e2 |
194.           W25Q128_CS(0);                           //使能器件   
     - |7 |2 a' `$ V; K- Q, R8 e
195.     W25Q128_ReadWriteByte(W25X_ChipErase);   //发送片擦除命令  
     ! I" z, l/ }- B9 t8 Q1 \: v
196.         W25Q128_CS(1);                           //取消片选                  
     0 J1 a5 j) [) O" O* |3 V; s
197.         W25Q128_Wait_Busy();                                              //等待芯片擦除结束
     
198. }
     
199. 
     / b# F+ q' k+ R7 M5 x2 d! L7 `" d
200. 
     
201. //等待空闲
     7 l8 o- }6 N5 f$ J
202. void W25Q128_Wait_Busy(void)   
     - u# m/ z% {& n1 W
203. {   
     
204.         while((W25Q128_ReadSR()&0x01)==0x01);   // 等待BUSY位清空
     
205. }  
     ' R; g5 a  t2 B& e, }  `& l5 {
206. 
     
207. //进入掉电模式
     ' D) e* u7 w& _# M. A
208. void W25Q128_PowerDown(void)   
     
209. {
     " S' \! c# n+ [
210.           W25Q128_CS(0);                            //使能器件   
     
211.     W25Q128_ReadWriteByte(W25X_PowerDown);    //发送掉电命令  
     
212.         W25Q128_CS(1);                            //取消片选                  
     . ^+ k7 z1 e' V) H
213. }   
     
214. //掉电唤醒
     
215. void W25Q128_WAKEUP(void)   
     
216. {  
     
217.           W25Q128_CS(0);                                //使能器件   
     0 [7 ^* v+ d% S0 q5 h& f
218.     W25Q128_ReadWriteByte(W25X_ReleasePowerDown);   
     ; Q; V, l! W8 b) O4 H
219.         W25Q128_CS(1);                                //取消片选                  
     2 _, F+ Z4 y3 ?9 P. }, o
220. }   </i></i></i>

复制代码

W25Q128.h
0 b6 e7 Q- P& \$ I: Z#ifndef __W25Q128_H
#define        __W25Q128_H
0 [% b' {& |# m! K5 W. Y" H
#include "stm32f10x.h"

//操作指令表
#define W25X_WriteEnable                           0x06         //写使能
#define W25X_WriteDisable                           0x04         //写禁止
. Q% F4 k; d& p5 N#define W25X_ReadStatusReg1                         0x05         //读状态寄存器1
#define W25X_ReadStatusReg2                         0x35         //读状态寄存器2
0 ~) Y0 a! e2 F#define W25X_ReadStatusReg3                         0x15         //读状态寄存器3
#define W25X_WriteStatusReg1                   0x01         //写状态寄存器1
  X5 h. G5 H- v8 g# q#define W25X_WriteStatusReg2                   0x31         //写状态寄存器2
8 ~$ o' q0 O7 _8 ~% P9 Y#define W25X_WriteStatusReg3                   0x11         //写状态寄存器3
#define W25X_ReadData                                0x03         //读数据
+ w2 W6 `7 }, {) C' K  z#define W25X_FastReadData                           0x0B         //快读
. K, |: S, S( g6 r; ^, ~% u#define W25X_FastReadDual                           0x3B    //双输出快读
#define W25X_PageProgram                           0x02         //页编程
4 a* t/ }; j  r* M, T* k- C#define W25X_BlockErase                                   0xD8         //块擦除（64K）
#define W25X_SectorErase                           0x20    //扇区擦除（4K）
#define W25X_ChipErase                                   0xC7    //芯片擦除
& ^5 I2 Z! N, c9 K#define W25X_PowerDown                                   0xB9    //掉电
* e3 ~% P# @. W1 i* i* ]#define W25X_ReleasePowerDown                 0xAB    //释放掉电
#define W25X_DeviceID                            0xAB    //器件ID
#define W25X_ManufactDeviceID                 0x90    //制造商+设备ID
#define W25X_JedecDeviceID                         0x9F         //电子元件ID
5 q, z( p$ Y" a. Y, r& I8 e) f( }
5 ]# |" T# U0 x+ u0 ?3 O# a
#define W25Q128_CS(a) SPI_CS(a)        

) f, @4 r  A' S- g! I" K
uint8_t W25Q128_ReadWriteByte(uint8_t TxData);//函数包装一下
: s& z8 _5 i/ g4 J6 Q
uint16_t W25Q128_ReadID(void);//读取芯片ID
# E/ n3 d' w/ A: g8 X, v8 b$ e4 o
8 A) C0 L2 {# [* a; @. Zuint8_t W25Q128_ReadSR(void);//读取状态寄存器
+ _1 B+ ~6 C5 w$ v/ c6 Tvoid W25Q128_WriteSR(uint8_t sr);//写状态寄存器
" Y0 V, ^& }& G2 g; o3 B( v; {
void W25Q128_Write_Enable(void);//写使能
void W25Q128_Write_Disable(void);//禁止写入        

void W25Q128_Read(uint8_t* pBuffer,uint32_t ReadAddr,uint16_t NumByteToRead); //读取数据
# b9 b' i; W4 J* ^) Ovoid 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);//无检验写数据，可自动翻页
void W25Q128_Write(uint8_t* pBuffer,uint32_t WriteAddr,uint16_t NumByteToWrite);//写入数据，带擦写功能
: @; T  k6 V! N' j
void W25Q128_Erase_Sector(uint32_t Dst_Addr);//擦除扇区
( }% ^. Y  f- }void W25Q128_Erase_Chip(void);//擦除整个芯片        
! M) |( q; r; n7 a" e: L  c7 ^
' H0 G( [' ~# H+ C7 N9 J# Tvoid W25Q128_Wait_Busy(void);//等待空闲
% g! q) P) g+ [* {0 F; E+ P& p& Svoid W25Q128_PowerDown(void); //进入掉电模式
void W25Q128_WAKEUP(void);//掉电唤醒
5 L2 Y% b4 J7 H+ L* H
& C- e6 h. [" B; M" T$ D% H. i: s#endif
& z) M+ N( |7 t4 S$ u, n$ q
1
  `8 R7 ^) R- W( t8 V2
  H+ c+ _: r: u! d! o3
4
2 R+ l; B$ Y0 ?$ F& a/ h/ b5
& ~: {$ b2 `' N* ~1 s9 {% ~6
7
8
6 X9 X3 I8 c0 {. Z4 q7 D8 c9
2 t3 z  R6 \3 d10
! N& ]  z& Y* o( p% E11
% Q2 k' s/ C# _+ l& t8 N12
13
14
15
; j6 u7 K- N, q2 G% R: y; f$ p16
% J, m# p) Q* ]" w) n( ^. H17
18
- F3 ^$ J: z8 u8 n; K19
20
21
22
( z. i8 |& U7 H' l23
9 b$ r, Z; a: I  f: l, O24
# J" T% b' M& X' m" s# a25
" _; ?0 x* B- N& w9 e26
9 {+ v+ q' k! l( Y27
28
9 d2 I; o8 @- v29
30
31
32
( C" J/ B1 `6 n/ }& b. `33
34
35
$ v( e7 t" x1 \36
37
38
. Q9 ^' r( F3 G# M) A39
/ O. G1 x* x( ~4 G40
41
. g1 H; u6 f$ ~42
8 m* M1 ?- R+ z2 Q; ~43
44
+ _/ E. P5 n  F: z& M45
46
47
# v. m5 X. }- M48
, A+ |% t7 C. d$ U! f49
. _2 R- a# [6 y4 ]0 @& v  z50
51
52
# C( F  s  u% j& w$ G* j53
54
5 U1 @1 i! k$ \  }3 T% smain.c
8 }7 [" V) s' }: \: j3 I8 J#include <stdio.h>
* F' j* r, N8 Z0 R#include "Uart1.h"
#include "delay.h"
#include "SPI.h"
#include "W25Q128.h"

uint16_t W25Q128_ID=0;
uint8_t Write_data[20]={1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20};
& c8 F- K$ |9 }1 \uint8_t Read_data[100];

int main (void)
{
        Uart1_init();
        SPI1_Init();
        
        W25Q128_ID=W25Q128_ReadID();
        W25Q128_Write_Page(Write_data,0x01,20);
# {! v& B: }" ]" v        
8 @) [4 S1 s" `. r: ]        while(1)
! ?: Z# q& v" H7 O* P- @        {
                W25Q128_Read(Read_data,0x00,100);
% x0 C/ J+ ]* g" ?4 m9 y7 Q                for(int i=0;i<100;i++)
                {
4 \+ |% Q, k( @: i- S9 W                        printf(" 0x%X ",Read_data);
0 x) Y5 n  ~8 o9 }$ }: L" B# p                }
; D7 G9 S- m" `* Y2 u9 ?: Q& l  K, m                printf("\nW25Q128_ID=0x%X\n",W25Q128_ID);
                delay_ms(500);
        }
( {# g3 |4 R5 c$ D, r! a0 d* X}
1 n: Z' n' r: r, _) S
1
- b( D) I% w3 o& `% U% Z( c2
+ T' ~6 ~1 e# Z, ?) T3 i* y3 i0 N' _3
# F0 L' U) s$ {) O# T4
4 v1 H: F1 q& S) S: L- P* d5
6
7
9 A& V; e7 {& g# w. Z! g) Q( E8
& l1 L, W" c9 w% l/ t' f9
10
. S1 }7 T# U6 B1 ]" k! d5 o, B11
- [2 s2 A8 m. v12
13
14
15
16
17
. u7 J  k. {" w8 e, j" L. i18
( `* z4 R' Y  v7 X/ k% u- d: D19
20
21
5 A, @/ L3 J0 m' T22
. I: I- E5 L& l; m4 u+ A23
24
25
26
27
4 N! m+ `5 y( H28
29
+ j# Q1 |! Q- I" E实验结果
$ {. |/ v; N1 b$ x! a* c
————————————————
8 ?& i  o* ?. F6 Z. T, y版权声明：根号五
$ }$ L1 a! O( h/ [& s# R6 c

5 f0 P9 Z8 r4 @' p% U+ q! v6 E