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

% K2 Z6 @$ n/ M; a, U1. 原理图

$ o1 O+ [, N; [3 C

$ Q3 I, g' L) W) Q4 k9 `0 i* K+ }6 a/ Z* s9 `2. 引脚连接



( M! J* |7 M* w3 I$ Z6 |# D7 ^- ^- @二、SPI 底层驱动
: z  s- b2 ?* @5 ~7 ^SPI.c
  k& p. V: p: w( ]- |" g

1. #include "SPI.h"
   
2. 
   % A; g* z+ J% n
3. /*
   # T3 ?, O$ b( U$ c6 k1 M
4.         SPI引脚初始化配置
   0 g9 b- r- w! e! w" L
5.         **PA4------CS
   0 p1 M+ W  O* N- w1 g7 G8 q2 ?
6.         **PA5------SCLK
   9 L2 Z) r- G7 g6 g0 W7 q& D2 d
7.         **PA6------MISO
     t# L! j* G/ _9 A9 f. ?
8.         **PA7------MOSI
   + X$ z# D' S8 T8 c# |  l
9. */
   0 z) |; O2 Z( Y7 x5 [& E, }9 L) n4 M
10. 
    / N6 C6 @! h1 p
11. static void SPI1_GPIO_Config(void)        
    / H; F5 @" s3 e. p1 L1 a% v
12. {
    ) H9 H- D" p/ Q+ i  L1 L( z6 Q
13.         GPIO_InitTypeDef GPIO_InitStructure;
    
14.         
    " `% ~8 `3 a1 R5 Q
15.         RCC_APB2PeriphClockCmd(        RCC_APB2Periph_GPIOA, ENABLE );//PORTA时钟使能
    
16. 
    
17.         GPIO_InitStructure.GPIO_Pin = GPIO_Pin_5| GPIO_Pin_6|GPIO_Pin_7;
    ' }$ ^1 w, j/ B7 o9 W# n
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
    ; g' G: z% `6 t6 [# s  q# J& ]
21.         
    
22.         GPIO_InitStructure.GPIO_Pin = GPIO_Pin_4;
    ' {5 Y" x3 u) _* _8 c  L+ N* G
23.         GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;  //PA4推挽输出
    ! A! n5 ^. k" V3 z
24.         GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
    5 H' D/ q* c: m5 [
25.         GPIO_Init(GPIOA, &GPIO_InitStructure);                                                //初始化GPIOA
    
26. 
    ! x6 [0 ~  w+ `6 n# X
27.         GPIO_SetBits(GPIOA,GPIO_Pin_4|GPIO_Pin_5|GPIO_Pin_6|GPIO_Pin_7); //初始上拉输出
    & o& Q1 l" b  w+ X3 s
28. 
    
29. }
    
30. 
    , \: c9 L/ N; `+ X. \% {
31. //SPI1初始化函数
    + t1 Z# S( E% D: L7 b" ?- z
32. void SPI1_Init(void)
    
33. {
    
34.         SPI1_GPIO_Config();//SPI引脚初始化配置        
    
35. 
    ( g, e9 H! e1 U7 p' x
36.         SPI_InitTypeDef  SPI_InitStructure;
    5 p$ L0 h- ?/ t% Z; E6 |  N
37.         
    2 i3 w# K+ n% k' g, y2 r, d
38.         RCC_APB2PeriphClockCmd(        RCC_APB2Periph_SPI1,  ENABLE );//SPI1时钟使能         
    4 x- ?; ~" g% _  u7 k3 c
39.         
    
40.         SPI_InitStructure.SPI_Direction = SPI_Direction_2Lines_FullDuplex;          //设置SPI单向或者双向的数据模式:SPI设置为双线双向全双工
    , P* c, A6 \1 y: P! m4 p
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;                                                                                                                //串行同步时钟的空闲状态为高电平
    ' [+ k; d! Z! h' z  |
44.         SPI_InitStructure.SPI_CPHA = SPI_CPHA_2Edge;                                                                                                        //串行同步时钟的第二个跳变沿（上升或下降）数据被采样
    
45.         SPI_InitStructure.SPI_NSS = SPI_NSS_Soft;                                                                                                                        //NSS信号由硬件（NSS管脚）还是软件（使用SSI位）管理:内部NSS信号有SSI位控制
      R! S% p$ p! a3 g9 e4 x* K
46.         SPI_InitStructure.SPI_BaudRatePrescaler = SPI_BaudRatePrescaler_256;        //定义波特率预分频的值:波特率预分频值为256
    4 u0 y; G% `' x8 O
47.         SPI_InitStructure.SPI_FirstBit = SPI_FirstBit_MSB;                                                                                //指定数据传输从MSB位还是LSB位开始:数据传输从MSB位开始
    
48.   SPI_InitStructure.SPI_CRCPolynomial = 7;        //CRC值计算的多项式
    0 O& V5 Z$ e& @- {0 v/ X
49.         SPI_Init(SPI1, &SPI_InitStructure);                          //根据SPI_InitStruct中指定的参数初始化外设SPIx寄存器
    2 a3 v3 w+ k! A+ o, C8 c
50.         
    
51.         SPI_Cmd(SPI1, ENABLE); //使能SPI外设
    
52.         SPI1_ReadWriteByte(0xFF);//启动传输
    9 Y$ k0 q# k5 a: z8 C
53. }
    
54. 
    
55. /*
    
56.         SPI的读写操作
    ) a0 _4 w5 v) W
57.         **TxData:要写入的字节
    
58.         **返回值:读取到的字节
    
59. */
    . G+ C: L/ a3 m/ k. r! G
60. uint8_t SPI1_ReadWriteByte(uint8_t TxData)
    
61. {                                 
    
62.         while (SPI_I2S_GetFlagStatus(SPI1, SPI_I2S_FLAG_TXE) == RESET) //检查指定的SPI标志位设置与否:发送缓存空标志位
    
63.         {
    
64.                 //等待发送完成
    
65.         }                          
    2 w6 d7 R5 O/ F( d/ A+ Z8 l- J' H- V
66.         SPI_I2S_SendData(SPI1, TxData); //通过外设SPIx发送一个数据
    * a' h& Z5 M1 x: L  x2 M
67.         while (SPI_I2S_GetFlagStatus(SPI1, SPI_I2S_FLAG_RXNE) == RESET) //检查指定的SPI标志位设置与否:接受缓存非空标志位
    , T5 G5 P& A' k6 M% a3 y  ~  H
68.         {
    
69.                 //等待接收完成
    
70.         }                                                              
    
71.         return SPI_I2S_ReceiveData(SPI1); //返回通过SPIx最近接收的数据                                            
    
72. }

复制代码

SPI.h
% o( K& P4 [9 c# Q2 c8 z9 C

1. #ifndef __SPI_H
   5 ~! N3 G' T- k9 r- K- W  |1 V8 t
2. #define        __SPI_H
   0 Y% X" w! K5 n- U* d
3. 
   ' o5 m& W: l, i( A* @, i" O
4. #include "stm32f10x.h"
   
5. 
   7 G1 s. w0 Z9 [, J) W; d. }
6. #define SPI_CS(a)                if (a)        \
   8 s! {- q6 K& |$ P$ u2 {  @
7.                                                 GPIO_SetBits(GPIOA,GPIO_Pin_4);\
   . p9 q  P9 v# A3 ~7 D  V
8.                                                 else                \
   
9.                                             GPIO_ResetBits(GPIOA,GPIO_Pin_4)
   $ N8 k) R% p3 F# B) ?4 _) A
10. 
    ( t' c4 P) q4 X! f
11. void SPI1_Init(void);//SPI1初始化函数
    . L; }* X0 d5 t
12. uint8_t SPI1_ReadWriteByte(uint8_t TxData);//SPI1读写函数
    
13. 
    
14. #endif

复制代码

三、读取 W25Q128 设备 ID
本次实验是：读取 W25Q128 设备 ID，然后通过串口1打印出来。
9 `: p9 R% a' b- n' M通过简单的实验来调试，有利于发现问题。
通过W25Q128的数据手册可知其设备ID如下图所示：



, W; s* k* X+ ]8 e: }4 tW25Q128.c

1. #include "W25Q128.h"
   
2. #include "SPI.h"
   5 c0 z. b! V- m) D( p6 P: R
3. 
   0 R/ Y4 _+ E8 b8 X( ]1 G. ~- P  R
4. 
   
5. uint8_t W25Q128_ReadWriteByte(uint8_t TxData)//函数包装一下
   . K+ n% `- _5 C$ d$ y8 l
6. {     
   
7.            return SPI1_ReadWriteByte(TxData);                 
   
8. }
   
9. 
   
10. uint16_t W25Q128_ReadID(void)//读取芯片ID
    1 |& N6 o* s( l' S
11. {
    , r, P8 S' ^) P8 V0 t, J' ^+ E
12.         uint16_t Temp = 0;         
    
13.         W25Q128_CS(0);                                    
    2 O1 @  J) a& C! o+ q2 S1 u
14.         W25Q128_ReadWriteByte(W25X_ManufactDeviceID);//发送读取ID命令            
    ; M) v/ K7 H2 Z- N. K, a! Q
15.         W25Q128_ReadWriteByte(0x00);            
    
16.         W25Q128_ReadWriteByte(0x00);            
    
17.         W25Q128_ReadWriteByte(0x00);                                    
    
18.         Temp|=W25Q128_ReadWriteByte(0xFF)<<8;  
    1 o& _0 B; I4 S
19.         Temp|=W25Q128_ReadWriteByte(0xFF);         
    
20.         W25Q128_CS(1);                                    
    ; W* {, W  T( w1 b8 z( P
21.         return Temp;
    
22. }

复制代码

9 s" ~8 X0 V! WW25Q128.h
1 M/ t7 f2 O  N* V& {) J, k3 O9 |

1. #ifndef __W25Q128_H
   6 B+ r/ A6 |6 H& x5 U
2. #define        __W25Q128_H
   " G6 M- x" o3 [: w3 g" R
3. 
   
4. #include "stm32f10x.h"
   
5. 
   
6. //操作指令表
   ( t& t4 q8 \2 B0 R% f
7. #define W25X_ManufactDeviceID         0x90       //制造商+设备ID
   ! ^/ C; e, o% o+ K  {6 [  F
8. 
   + C1 U2 n0 l7 `! E7 Q0 ?
9. #define W25Q128_CS(a) SPI_CS(a)        
   # ~7 ]; _0 B' W% d3 Q2 Z/ t) g; W
10. 
    : x& L8 ?0 S. W- ~( b" f
11. uint8_t W25Q128_ReadWriteByte(uint8_t TxData);//函数包装一下
    
12. uint16_t W25Q128_ReadID(void);//读取芯片ID
    
13. 
    
14. #endif

复制代码

# B: F+ k4 \0 k( `/ ^3 ]( @+ @5 E1 t4 @main.c

1. #include <stdio.h>
   
2. #include "Uart1.h"
   # X" ^6 [, u; ~1 W4 n
3. #include "delay.h"
   & n( \- o+ s3 D/ ~- _$ O# c
4. #include "SPI.h"
   0 K4 c% q" e3 u/ z
5. #include "W25Q128.h"
   8 d5 D# `$ _8 \( d8 s( j
6. 
   
7. uint16_t W25Q128_ID=0;
   
8. 
   
9. int main (void)
   
10. {
    
11.         Uart1_init();
    4 D' H, y5 _! I' K
12.         SPI1_Init();
    ) O* i" e. r6 F
13.         
    ' x: v* V7 F$ N6 @0 s( G
14.         W25Q128_ID = W25Q128_ReadID();
    
15.         while(1)
    
16.         {
    
17.                 printf("\nW25Q128_ID=0x%X\n",W25Q128_ID);
    ) _# p% Y: i: S$ T
18.                 delay_ms(500);
    
19.         }
    
20. }

复制代码

. v+ V+ D1 v4 G实验结果
4 j% @# u4 w8 ]/ h3 `! a2 K

1 m& J  S) x  H, C7 w接收到 W25Q128 设备ID 为0xEF17

四、读写 W25Q128 外部 Flash
2 m' B, E! Y; |2 S: C4 @W25Q128.c

1. #include "W25Q128.h"
   , V5 w0 i: F2 i
2. #include "SPI.h"
   
3. 
   4 m6 S' c; [! ?, ]: v
4. 
   . _, G+ Z7 c) R/ c1 o9 x( _
5. uint8_t W25Q128_ReadWriteByte(uint8_t TxData)//函数包装一下
   
6. {     
   
7.          return SPI1_ReadWriteByte(TxData);                 
   
8. }
   
9. 
   
10. 
    + M" ~, r/ _/ ~/ }' P2 C3 d+ v
11. uint16_t W25Q128_ReadID(void)//读取芯片ID
    ! _& U! [& i: q4 A! a) u) V+ l
12. {
    ) ~5 q( z% P" x3 A" H" b; _
13.         uint16_t Temp = 0;         
    $ I0 ^! D4 N/ I, a3 f
14.         W25Q128_CS(0);                                    
    
15.         W25Q128_ReadWriteByte(W25X_ManufactDeviceID);//发送读取ID命令            
    
16.         W25Q128_ReadWriteByte(0x00);            
    
17.         W25Q128_ReadWriteByte(0x00);            
    
18.         W25Q128_ReadWriteByte(0x00);                                    
    
19.         Temp|=W25Q128_ReadWriteByte(0xFF)<<8;  
    
20.         Temp|=W25Q128_ReadWriteByte(0xFF);         
    
21.         W25Q128_CS(1);                                    
    & S% w% r$ o5 l- o5 p
22.         return Temp;
    . J7 R7 k* k9 u( G' p1 N, a& t
23. }
    . |  J# a: t% F4 S7 i- C# c
24. 
    
25. //读取W25Q128的状态寄存器
    # E6 y  N' p& f( S/ a3 B
26. //BIT7  6   5   4   3   2   1   0
    ; K7 Q' T, ~. A9 E* i; p. W
27. //SPR   RV  TB BP2 BP1 BP0 WEL BUSY
    + P/ @% P, ^# V
28. //SPR:默认0,状态寄存器保护位,配合WP使用
    1 ^) {. }2 V  c  t2 F7 e
29. //TB,BP2,BP1,BP0:FLASH区域写保护设置
    4 s) C  v) \2 g0 }
30. //WEL:写使能锁定
    5 |$ `* c: j! n& h. c% W+ k
31. //BUSY:忙标记位(1,忙;0,空闲)
    0 q8 Q9 J" {- ?6 x/ J. j
32. //默认:0x00
    
33. uint8_t W25Q128_ReadSR(void)//读取状态寄存器
    : w! p* Z) w5 a" j. y
34. {
    4 w9 B. d4 M  c" m/ n
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;
    
41. }
    & o& _* }( q/ K" D. W! ^* ~
42. 
    ( X) D) {1 Z( W, a
43. //写W25Q128状态寄存器
    , P+ |# L- A- [: j: h8 K
44. //只有SPR,TB,BP2,BP1,BP0(bit 7,5,4,3,2)可以写!!!
    3 m. `, c( O7 f7 ]% t/ Z9 E- E
45. void W25Q128_WriteSR(uint8_t sr)//写状态寄存器
    
46. {
    : d- E9 z4 Z9 a' O0 ]6 S
47.     W25Q128_CS(0);                                           //使能器件
    , h% y% X$ o5 M3 B+ k- K
48.     W25Q128_ReadWriteByte(W25X_WriteStatusReg1);        //发送写取状态寄存器命令
    
49.     W25Q128_ReadWriteByte(sr);                               //写入一个字节
    $ n; N, N  }4 {+ O9 I# J
50.     W25Q128_CS(1);                                            //取消片选
    
51. }
    , m) W/ K% V4 c# k2 \& N
52. 
    
53. void W25Q128_Write_Enable(void) //写使能
    " h# i9 s# S8 w$ F2 M
54. {
    
55.            W25Q128_CS(0);        
    
56.         W25Q128_ReadWriteByte(W25X_WriteEnable);
    " _. ^- {& M) y( p0 r- A+ M' l
57.         W25Q128_CS(1);        
    . ^8 b$ v2 ?* `
58. }
    * [( H, v+ r1 [2 G8 v% k
59. 
    2 p7 N* t8 C4 t1 |
60. void W25Q128_Write_Disable(void) //禁止写入        
    
61. {
    
62.            W25Q128_CS(0);        
    
63.         W25Q128_ReadWriteByte(W25X_WriteDisable);
    5 N. y" f) @, d  A
64.         W25Q128_CS(1);        
    
65. }
    9 v/ y9 m* C$ i) w7 q: J
66. 
    ! `* i3 G$ s* Q7 _* d+ P& ~
67. void W25Q128_Read(uint8_t* pBuffer,uint32_t ReadAddr,uint16_t NumByteToRead)   
    % Q  _7 O$ \3 {
68. {                                                     
    
69.         W25Q128_CS(0);                                  //使能器件   
    
70.     W25Q128_ReadWriteByte(W25X_ReadData);      //发送读取命令  
    9 }; i# {7 W: t) B: H$ e: E* m/ @" a
71.     W25Q128_ReadWriteByte((uint8_t)((ReadAddr)>>16));   //发送24bit地址   
    / y+ D1 D) x2 K+ {1 l5 _( @. ^
72.     W25Q128_ReadWriteByte((uint8_t)((ReadAddr)>>8));   
    
73.     W25Q128_ReadWriteByte((uint8_t)ReadAddr);   
    
74.     for(uint16_t i=0;i<NumByteToRead;i++)
    0 m$ k/ ~, {; N$ I+ ?9 a! C! ^2 X
75.         {
    
76.        pBuffer<i>=W25Q128_ReadWriteByte(0XFF);    //循环读数  
    
77.     }
    2 @& A: Y* F" d# l) A) b
78.         W25Q128_CS(1);                                                  
    
79. }  
    7 a0 E! F$ @" D
80. 
    
81. 
    - G6 m7 F7 c9 R3 L; F
82. void W25Q128_Write_Page(uint8_t* pBuffer,uint32_t WriteAddr,uint16_t NumByteToWrite)
    8 Y9 L$ e- H% D3 X+ u
83. {
    
84. 
    
85.     W25Q128_Write_Enable();                  //SET WEL
    ; R8 g! V# x& Z; ]8 t% E4 I7 n
86.         W25Q128_CS(0);                            //使能器件   
    + x) ^+ ]: g( |$ ~' L/ f
87.     W25Q128_ReadWriteByte(W25X_PageProgram);   //发送写页命令   
    
88. 
    
89.     W25Q128_ReadWriteByte((uint8_t)((WriteAddr)>>16)); //发送24bit地址   
    
90.     W25Q128_ReadWriteByte((uint8_t)((WriteAddr)>>8));   
    2 M6 m% B9 {4 h  m+ `
91.     W25Q128_ReadWriteByte((uint8_t)WriteAddr);   
    2 I" c: x: {" h0 |$ v' p( c6 p+ h! }
92.     for(uint16_t i=0;i<NumByteToWrite;i++)
      ~, i+ H7 ?" s( p
93.         {
    4 T( X& J: N4 j2 \' @  F; U8 \
94.                 W25Q128_ReadWriteByte(pBuffer<i>);//循环写数  
    1 _* l; D2 g, u: E; @
95.         }
    
96.         W25Q128_CS(1);                            //取消片选
    9 c3 |7 A& o# P, b
97.         W25Q128_Wait_Busy();                                           //等待写入结束
    
98. }
    
99. 
    
100. //无检验写SPI FLASH
     & i/ T% w2 `" Z( w. g- Q
101. //必须确保所写的地址范围内的数据全部为0XFF,否则在非0XFF处写入的数据将失败!
     ' q3 p6 z6 |4 x( c) B3 n
102. //具有自动换页功能
     : O! b/ N9 z) E
103. void W25Q128_Write_NoCheck(uint8_t* pBuffer,uint32_t WriteAddr,uint16_t NumByteToWrite)   
     
104. {                                          
     
105.         uint16_t pageremain=256-WriteAddr%256; //单页剩余的字节数                             
     
106.         if(NumByteToWrite<=pageremain)pageremain=NumByteToWrite;//不大于256个字节
     1 L% W0 C' ]7 e! ]
107.         while(1)
     
108.         {           
     / a- `" ~, b# Q; l- ]2 ?
109.                 W25Q128_Write_Page(pBuffer,WriteAddr,pageremain);
     9 I) R' c6 P7 \- g& r
110.                 if(NumByteToWrite==pageremain)        break;//写入结束了
     0 R% k1 N/ u" t; a/ a& Z5 ]
111.                  else
     
112.                 {
     9 z% B0 Q4 s& V
113.                         pBuffer+=pageremain;
     8 y2 |* ]4 p: r1 U
114.                         WriteAddr+=pageremain;        
     ' d- M9 L! q, V. |' r2 P5 t+ [$ Q8 C
115.                         NumByteToWrite-=pageremain;                          //减去已经写入了的字节数
     
116.                         if(NumByteToWrite>256)pageremain=256; //一次可以写入256个字节
     
117.                         else pageremain=NumByteToWrite;           //不够256个字节了
     5 \& {1 S/ b/ I
118.                 }
     & F2 a0 B. V, N2 ?" I" p: _% F2 b
119.         }            
     ) K5 }. L, L7 a' U! L, i; P* B
120. }
     
121. 
     
122. //写SPI FLASH  
     
123. //在指定地址开始写入指定长度的数据
     
124. //该函数带擦除操作!
     
125. //pBuffer:数据存储区
     
126. //WriteAddr:开始写入的地址(24bit)                                                
       i" U4 V2 Q6 u5 {; y4 q) P" \
127. //NumByteToWrite:要写入的字节数(最大65535)   
     
128. uint8_t W25Q128_BUFFER[4096];                 
     
129. void W25Q128_Write(uint8_t* pBuffer,uint32_t WriteAddr,uint16_t NumByteToWrite)   
     . @) l1 i& p' Y( |: M
130. {
     
131.          uint16_t i;   
     
132.         uint8_t * W25Q128_BUF;         
     
133.     W25Q128_BUF=W25Q128_BUFFER;            
     
134.          uint32_t secpos = WriteAddr/4096;//扇区地址  
     % S9 h2 {+ m9 \
135.         uint16_t secoff = WriteAddr%4096;//在扇区内的偏移
     
136.         uint16_t secremain = 4096-secoff;//扇区剩余空间大小   
       t! O: d$ c. P  {- _4 S8 J
137. 
     4 h. U2 F. N4 }1 B$ j+ H, {- J
138.          if(NumByteToWrite<=secremain)                secremain=NumByteToWrite;//不大于4096个字节
     
139.         while(1)
     & c% j9 q# m' ?8 _* j
140.         {        
     
141.                 W25Q128_Read(W25Q128_BUF,secpos*4096,4096);//读出整个扇区的内容
     
142.                 for(i=0;i<secremain;i++)//校验数据
     % p6 ?* S! |/ O$ _" c7 E
143.                 {
     4 j1 @% M, p4 x$ Y# Y4 I* K
144.                         if(W25Q128_BUF[secoff+i]!=0XFF)        break;//需要擦除            
     
145.                 }
     - U$ S: M( y* M5 k6 P
146.                 if(i<secremain)//需要擦除
     1 v, a! Y- X8 L
147.                 {
     ' @1 [0 P! c9 }( u& D- r* Z
148.                         W25Q128_Erase_Sector(secpos*4096);//擦除这个扇区
     
149.                         for(i=0;i<secremain;i++)           //复制
     
150.                         {
     & n6 [1 l( [7 Z% a0 w
151.                                 W25Q128_BUF[i+secoff]=pBuffer<i>;         
     
152.                         }
     
153.                         W25Q128_Write_NoCheck(W25Q128_BUF,secpos*4096,4096);//写入整个扇区  
     ; m) G  X3 c# n/ ?
154. 
     
155.                 }else W25Q128_Write_NoCheck(pBuffer,WriteAddr,secremain);//写已经擦除了的,直接写入扇区剩余区间.                                    
     ' Z8 H0 x1 ^3 b
156.                 if(NumByteToWrite==secremain)        break;//写入结束了
     
157.                 else//写入未结束
     / F- }+ k& G; L6 F' H
158.                 {
     
159.                         secpos++;//扇区地址增1
     
160.                         secoff=0;//偏移位置为0         
     ; x$ j2 V( [: S) h. M7 R  b
161. 
     9 a+ A+ H3 O1 ^1 \: v
162.                     pBuffer+=secremain;  //指针偏移
     7 [  K" Y5 [+ c) S) N
163.                         WriteAddr+=secremain;//写地址偏移           
     
164.                     NumByteToWrite-=secremain;                                //字节数递减
     ! V. X9 x8 O: c
165.                         if(NumByteToWrite>4096)        secremain=4096;        //下一个扇区还是写不完
     ' k: K6 P! N2 F9 C/ K' R, ^+ X
166.                         else         secremain=NumByteToWrite;                //下一个扇区可以写完了
       P% n, g$ p# a5 Q) O! t
167.                 }         
     4 k( |% A9 W/ [' q
168.         }         
     
169. }
     " O- t1 C- O% _% Z2 Y
170. 
     
171. //擦除一个扇区
     
172. //Dst_Addr:扇区地址 根据实际容量设置
     
173. //擦除一个扇区的最少时间:150ms
     
174. 
     * d7 k/ @! g  E1 ?
175. void W25Q128_Erase_Sector(uint32_t Dst_Addr)   
     " P  C$ N1 L1 h& f( m: Q
176. {  
     6 V+ t/ h- ?; e; g" k) t
177.     W25Q128_Write_Enable();                  //SET WEL         
     & w" j# j' p3 n2 y  o  p7 R! w
178.     W25Q128_Wait_Busy();   
     9 H, \0 P9 G7 a: A6 _9 k% v0 b8 R' L) d
179.           W25Q128_CS(0);                            //使能器件   
     
180.     W25Q128_ReadWriteByte(W25X_SectorErase);   //发送扇区擦除指令
     
181.     W25Q128_ReadWriteByte((uint8_t)((Dst_Addr)>>16));  //发送24bit地址   
     
182.     W25Q128_ReadWriteByte((uint8_t)((Dst_Addr)>>8));   
     # P3 t" x. X$ w/ w! u
183.     W25Q128_ReadWriteByte((uint8_t)Dst_Addr);  
     + Z0 @1 a8 W7 _( F$ b
184.         W25Q128_CS(1);                                    //取消片选                  
     
185.     W25Q128_Wait_Busy();                                               //等待擦除完成
     
186. }  
     5 Y' \% N& |5 `. T
187. 
     
188. //擦除整个芯片                  
     
189. //等待时间超长...
     6 E1 m2 k' j& B" m) R
190. void W25Q128_Erase_Chip(void)   
     
191. {                                   
     ; }+ Q/ @; ^1 g$ X8 c8 O) Y
192.     W25Q128_Write_Enable();                  //SET WEL
     
193.     W25Q128_Wait_Busy();   
     . P$ s5 H8 G8 r: \' |7 J
194.           W25Q128_CS(0);                           //使能器件   
     9 }3 z, v7 D, s3 ]
195.     W25Q128_ReadWriteByte(W25X_ChipErase);   //发送片擦除命令  
     
196.         W25Q128_CS(1);                           //取消片选                  
     ( \" J) o! u# r, b
197.         W25Q128_Wait_Busy();                                              //等待芯片擦除结束
     
198. }
     3 o) @' V6 K1 V0 N
199. 
     
200. 
     
201. //等待空闲
     
202. void W25Q128_Wait_Busy(void)   
     5 u9 z, `5 p7 L! k: M
203. {   
     
204.         while((W25Q128_ReadSR()&0x01)==0x01);   // 等待BUSY位清空
     # Y# |7 C9 |5 F% y8 T- S! x* H
205. }  
     5 i, p1 S$ W; y/ V
206. 
     5 {/ z% l/ b$ i6 f$ C
207. //进入掉电模式
     , c5 _$ v/ v8 }& @" Q
208. void W25Q128_PowerDown(void)   
     : ]+ n4 K0 j5 {/ D9 K" o
209. {
     
210.           W25Q128_CS(0);                            //使能器件   
     
211.     W25Q128_ReadWriteByte(W25X_PowerDown);    //发送掉电命令  
     4 t* h8 y  w7 x+ X
212.         W25Q128_CS(1);                            //取消片选                  
     ; I3 {( ]3 |& r  H# B
213. }   
     
214. //掉电唤醒
     : B) P8 W2 m: x8 X6 C+ I
215. void W25Q128_WAKEUP(void)   
     
216. {  
     
217.           W25Q128_CS(0);                                //使能器件   
     : \- P/ ^0 ]& Q" E2 [" p
218.     W25Q128_ReadWriteByte(W25X_ReleasePowerDown);   
     
219.         W25Q128_CS(1);                                //取消片选                  
     
220. }   </i></i></i>

复制代码

$ b6 @7 H. y# V$ ?W25Q128.h
#ifndef __W25Q128_H
( m. F# t7 b2 D#define        __W25Q128_H

#include "stm32f10x.h"
2 m3 }/ ~9 a& _, t$ @  z# O
//操作指令表
#define W25X_WriteEnable                           0x06         //写使能
#define W25X_WriteDisable                           0x04         //写禁止
) p7 P+ V  F9 A9 b" P& Z#define W25X_ReadStatusReg1                         0x05         //读状态寄存器1
  w: F* N7 g6 @1 E8 f8 ]" o$ F#define W25X_ReadStatusReg2                         0x35         //读状态寄存器2
#define W25X_ReadStatusReg3                         0x15         //读状态寄存器3
. s0 J$ N7 O+ u- `4 ]& V#define W25X_WriteStatusReg1                   0x01         //写状态寄存器1
#define W25X_WriteStatusReg2                   0x31         //写状态寄存器2
#define W25X_WriteStatusReg3                   0x11         //写状态寄存器3
- x( N" Z( M- E( _#define W25X_ReadData                                0x03         //读数据
#define W25X_FastReadData                           0x0B         //快读
#define W25X_FastReadDual                           0x3B    //双输出快读
9 v1 N4 r2 P, P2 N# m( p#define W25X_PageProgram                           0x02         //页编程
) C9 W" F( u7 x#define W25X_BlockErase                                   0xD8         //块擦除（64K）
! u" Y6 S6 z' h( J: K! |#define W25X_SectorErase                           0x20    //扇区擦除（4K）
) T9 W2 n; S3 m! F$ J) ^# o#define W25X_ChipErase                                   0xC7    //芯片擦除
/ X# S5 _4 s8 y' j2 s#define W25X_PowerDown                                   0xB9    //掉电
#define W25X_ReleasePowerDown                 0xAB    //释放掉电
1 D9 i% u; z; C. g1 G/ ^#define W25X_DeviceID                            0xAB    //器件ID
#define W25X_ManufactDeviceID                 0x90    //制造商+设备ID
, w, e1 p0 {& c1 {#define W25X_JedecDeviceID                         0x9F         //电子元件ID
' e' q+ A' Y8 c2 Q% P
/ m+ u6 P7 n# P3 ?  d7 B
#define W25Q128_CS(a) SPI_CS(a)        
5 j1 _/ D4 s, Z; |

uint8_t W25Q128_ReadWriteByte(uint8_t TxData);//函数包装一下
% j2 D5 e6 z5 f$ K
uint16_t W25Q128_ReadID(void);//读取芯片ID
" @; m( D3 H' L
uint8_t W25Q128_ReadSR(void);//读取状态寄存器
void W25Q128_WriteSR(uint8_t sr);//写状态寄存器
  G% ?0 c" q6 A, p* _% B
void W25Q128_Write_Enable(void);//写使能
void W25Q128_Write_Disable(void);//禁止写入        

7 X# r! r/ x0 Xvoid W25Q128_Read(uint8_t* pBuffer,uint32_t ReadAddr,uint16_t NumByteToRead); //读取数据
3 Q( n" G6 V( T/ O3 h  Uvoid W25Q128_Write_Page(uint8_t* pBuffer,uint32_t WriteAddr,uint16_t NumByteToWrite);//页写
. P/ N4 k; b+ @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);//写入数据，带擦写功能

& c% M; q( I2 ^& Zvoid W25Q128_Erase_Sector(uint32_t Dst_Addr);//擦除扇区
+ V" }0 r* I: T. mvoid W25Q128_Erase_Chip(void);//擦除整个芯片        

! n" i3 [6 Q. ]0 r+ p5 n& u) m# y6 V% R( qvoid W25Q128_Wait_Busy(void);//等待空闲
8 w- J9 O9 h. e; X' u& {' A5 nvoid W25Q128_PowerDown(void); //进入掉电模式
7 y3 S  A9 o* ~6 k+ D) bvoid W25Q128_WAKEUP(void);//掉电唤醒
4 V( j" M) b' w; ?0 ~
2 w  B! O5 F3 H8 C6 W#endif

1
2
3
3 E/ W- X# V: E8 [  H# y3 m# l2 S, l! q4
5
6
7
8
. Q" W4 B3 N+ ~! _/ N9
3 ^2 }1 m5 ?: d. L8 w10
6 R8 q" p. j5 j/ Y5 g3 J/ a11
2 k. a( r3 X9 \6 Y$ R+ K  n- m6 ~12
/ [* d7 o) ?) `5 I" T4 C3 h7 B13
14
15
" c  c2 \: d7 g; A4 |16
9 T; l- x5 b8 X/ Z+ Y( p17
$ A2 Y( I7 h! N* p- V0 k- e18
" H! X1 a+ c+ w- P4 S19
20
4 d# y8 R2 L1 ]2 [# X4 W1 d* w21
* ~( n& N  D1 {+ M22
& X% k) G+ d! t# [" @1 ~5 t23
, V6 r* f- T* Y! f24
9 e' ^$ z% W& {3 T' h7 M0 k+ m) w25
26
27
28
( O& ^, s7 A: G5 ]( y" \/ J+ a29
. q7 x: e( C; ~. Y5 Z5 ?. L30
31
32
33
1 i: q6 s) N% ~2 i# w! e  F34
35
1 i4 u) S) p: o9 O/ W7 Z36
37
38
39
40
41
42
- y, [0 {+ Z% R8 L: e* i  G7 _43
44
6 p* v9 }: a& ~& K8 N' R( ?45
46
$ c2 g! y0 H+ A( L9 G/ ]47
48
49
& }7 b. m1 |$ N50
8 F# R: [, p5 O5 u51
1 j# n) U6 X& D9 V0 s3 ~  Z( p' t52
53
54
- C+ R  f* H0 {' s7 ~% amain.c
, V( a9 k2 k6 l! k6 p: B#include <stdio.h>
, Z0 ]( e9 M2 `8 w% b#include "Uart1.h"
+ B% }# @2 ^  Z. v9 V& H& }/ P3 Y  }% L( V#include "delay.h"
( F, k5 H4 ]& w+ `& B#include "SPI.h"
2 F+ C+ t& ?7 ?) g#include "W25Q128.h"

( n2 D, m; Z+ R0 R' ruint16_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};
uint8_t Read_data[100];

int main (void)
{
! T8 @; o8 }1 o- C- T/ Q! ^! P& s* g        Uart1_init();
+ `/ w2 s5 x% P! E5 Y* m/ T* q        SPI1_Init();
) O+ {* h% X5 y1 A8 C) U$ O8 \+ V        
2 q1 r( {3 k6 l2 Z* c: d        W25Q128_ID=W25Q128_ReadID();
        W25Q128_Write_Page(Write_data,0x01,20);
        
& [/ A  v2 @9 N: [& _8 \/ L        while(1)
0 f- C- d/ Z3 I* H1 E' y: o) E        {
' I) J8 t: O+ A  X; B3 A                W25Q128_Read(Read_data,0x00,100);
                for(int i=0;i<100;i++)
                {
! H$ i. \5 B" r                        printf(" 0x%X ",Read_data);
7 _: F' h: y) H! v# S                }
* X+ |/ q5 o/ v0 I+ y' W* t+ b                printf("\nW25Q128_ID=0x%X\n",W25Q128_ID);
- ~+ `! z9 t& n5 N* Z- k                delay_ms(500);
        }
1 b0 o9 g( b+ y7 W. W! F: n}
, A" q& @8 @7 ^( ?/ F. @9 @1 Z. h
1
5 ?: ^! I2 f# F( P8 v2
3
4
5
6
3 E9 v, B7 ^8 h8 h# e. Q' i7
8
9
10
. t. J1 \# W; N& j! b11
, m' E/ o9 Q) D: J! j12
3 e) ~  N) g. B8 w* _, t13
14
15
* p3 e9 y* k" V1 W; \16
17
18
1 _4 F  ]8 o$ o; `7 [, F19
! R3 ^' C; L( C, i20
21
, p" H6 l! t0 r; |  j& c  s: R8 Y22
% z/ k) `& S# g, u23
8 W' M# z, Y9 r' c# S$ {  u24
25
7 b& t6 K9 s( J7 S! t' ?26
27
28
" B3 n3 w0 g! W2 t) x29
% i0 R: ~1 }- s; y& P; e实验结果

————————————————
$ a3 F- r6 P4 B! J5 y! p版权声明：根号五
& v; K8 X2 Y8 A/ h6 O% y: F- Z
- l( u8 Q# K: }2 F8 G" d" X
3 |  X/ s* C0 n# y