一、实验前期准备
本次实验的 MCU 是 STM32F103C8T6 芯片，通过 SPI 通信实现 W25Q128 的读写操作。
1 D+ e' O* p- K, P. n9 j
3 }. `" Q; b4 P5 @$ _+ \6 R7 y1. 原理图

" Q  r+ c! }1 h
) {* b% n' S  ]8 c2 U, D4 Q
2. 引脚连接
; e$ S: e9 B3 g
& ?0 }: S- m' p1 p2 u
: ?! P- m7 e* J- n( K8 c
二、SPI 底层驱动
SPI.c

1. #include "SPI.h"
   # L7 m  d" R" I% i& A7 q
2. 
   $ G3 O; q* |. s; j9 v
3. /*
   # K% O3 q$ P+ \
4.         SPI引脚初始化配置
   ( p' \+ H0 f& E' _# }6 l
5.         **PA4------CS
   
6.         **PA5------SCLK
   ) Q+ H2 G' o0 Q& K* V
7.         **PA6------MISO
   / n) C, R+ i2 L& P( B0 i9 R3 y6 p- y; r
8.         **PA7------MOSI
   
9. */
   ) l" Y: _4 s  M1 A# ?* Q
10. 
    ) T. U4 g  Y) c' A. i$ M
11. static void SPI1_GPIO_Config(void)        
    
12. {
    , W- @  R7 ]$ z2 l0 Q- V
13.         GPIO_InitTypeDef GPIO_InitStructure;
    & `8 H* y3 C+ o. T
14.         
    4 H% S" D. T! g0 _5 E8 U0 L$ Y8 f, b
15.         RCC_APB2PeriphClockCmd(        RCC_APB2Periph_GPIOA, ENABLE );//PORTA时钟使能
    . ^1 `6 f* P2 s
16. 
    ( G7 q& x7 a! d! n' L, n2 v
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;
    , G6 r- F; I- R- `6 i
20.         GPIO_Init(GPIOA, &GPIO_InitStructure);                                                //初始化GPIOA
    
21.         
    
22.         GPIO_InitStructure.GPIO_Pin = GPIO_Pin_4;
    0 c; w; E" n( X% x
23.         GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;  //PA4推挽输出
    
24.         GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
    ) r7 h2 q' t' d# J0 {4 _
25.         GPIO_Init(GPIOA, &GPIO_InitStructure);                                                //初始化GPIOA
    $ q5 W7 r) g1 _$ B% B& [1 i
26. 
    
27.         GPIO_SetBits(GPIOA,GPIO_Pin_4|GPIO_Pin_5|GPIO_Pin_6|GPIO_Pin_7); //初始上拉输出
    
28. 
    
29. }
    - }! \1 S+ w7 O% ~; x) \
30. 
    
31. //SPI1初始化函数
    
32. void SPI1_Init(void)
    4 q" b$ f9 G: C( ^/ y! R
33. {
    
34.         SPI1_GPIO_Config();//SPI引脚初始化配置        
    , c3 e0 I  J: E9 t1 C$ I/ {
35. 
    6 _) u6 p% E8 x
36.         SPI_InitTypeDef  SPI_InitStructure;
    
37.         
    & Q0 x# o  Z: n
38.         RCC_APB2PeriphClockCmd(        RCC_APB2Periph_SPI1,  ENABLE );//SPI1时钟使能         
    ; d1 {; Z7 I8 e* r& N+ K
39.         
    0 `3 _* [  Z" g. N( s& Y8 ?& t' ^
40.         SPI_InitStructure.SPI_Direction = SPI_Direction_2Lines_FullDuplex;          //设置SPI单向或者双向的数据模式:SPI设置为双线双向全双工
    
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;                                                                                                                //串行同步时钟的空闲状态为高电平
    ( ?# v) g7 u) f4 u
44.         SPI_InitStructure.SPI_CPHA = SPI_CPHA_2Edge;                                                                                                        //串行同步时钟的第二个跳变沿（上升或下降）数据被采样
    . ~" c2 F6 Q) ]" l4 Q" _
45.         SPI_InitStructure.SPI_NSS = SPI_NSS_Soft;                                                                                                                        //NSS信号由硬件（NSS管脚）还是软件（使用SSI位）管理:内部NSS信号有SSI位控制
    / ~5 g3 p5 u) i1 X2 D: b
46.         SPI_InitStructure.SPI_BaudRatePrescaler = SPI_BaudRatePrescaler_256;        //定义波特率预分频的值:波特率预分频值为256
    . v. I1 H$ F2 \  p; k. ~
47.         SPI_InitStructure.SPI_FirstBit = SPI_FirstBit_MSB;                                                                                //指定数据传输从MSB位还是LSB位开始:数据传输从MSB位开始
    0 K6 W" `  t+ t; Z3 p3 Y; ], @
48.   SPI_InitStructure.SPI_CRCPolynomial = 7;        //CRC值计算的多项式
    
49.         SPI_Init(SPI1, &SPI_InitStructure);                          //根据SPI_InitStruct中指定的参数初始化外设SPIx寄存器
    
50.         
    * b$ E+ U& h4 N7 O& i
51.         SPI_Cmd(SPI1, ENABLE); //使能SPI外设
    
52.         SPI1_ReadWriteByte(0xFF);//启动传输
    , ^! _$ M. q5 m* @8 S0 K- s" y
53. }
    
54. 
    
55. /*
    " A" W" A% @" w& P/ t& R
56.         SPI的读写操作
    ) k& P3 |1 M: Y2 H
57.         **TxData:要写入的字节
    7 ^% @6 c8 s2 M# w$ F/ x, ^
58.         **返回值:读取到的字节
    7 Z" ^7 i+ E9 q' T. r3 P& ?. U- Z
59. */
    ' s6 u! A1 a* M$ c2 {: c
60. uint8_t SPI1_ReadWriteByte(uint8_t TxData)
    1 n) Y) U* [, y1 k& Z- Z7 u: _; G
61. {                                 
    
62.         while (SPI_I2S_GetFlagStatus(SPI1, SPI_I2S_FLAG_TXE) == RESET) //检查指定的SPI标志位设置与否:发送缓存空标志位
    
63.         {
    
64.                 //等待发送完成
    
65.         }                          
    : E& r/ @1 |+ x( b, Q
66.         SPI_I2S_SendData(SPI1, TxData); //通过外设SPIx发送一个数据
    4 ]6 }. g7 Z) L" W- n9 K
67.         while (SPI_I2S_GetFlagStatus(SPI1, SPI_I2S_FLAG_RXNE) == RESET) //检查指定的SPI标志位设置与否:接受缓存非空标志位
    
68.         {
    3 J' r. t3 H3 k9 W  h' f' N- u& a
69.                 //等待接收完成
    
70.         }                                                              
    
71.         return SPI_I2S_ReceiveData(SPI1); //返回通过SPIx最近接收的数据                                            
    , z* {2 ]) ^, ]$ G8 P6 V  _- e
72. }

复制代码

SPI.h

1. #ifndef __SPI_H
   
2. #define        __SPI_H
   
3. 
   
4. #include "stm32f10x.h"
   : t1 f9 L3 R# b* \1 O' h
5. 
   
6. #define SPI_CS(a)                if (a)        \
   ( @, X. {. ]$ y( `3 s3 s4 x
7.                                                 GPIO_SetBits(GPIOA,GPIO_Pin_4);\
   + e$ h4 [! L! _2 e
8.                                                 else                \
   3 e& W  z2 z/ o/ Z9 R
9.                                             GPIO_ResetBits(GPIOA,GPIO_Pin_4)
   7 ~" Z% C. V# U& v3 k$ F
10. 
    
11. void SPI1_Init(void);//SPI1初始化函数
    
12. uint8_t SPI1_ReadWriteByte(uint8_t TxData);//SPI1读写函数
    
13. 
    ! V/ A2 m$ O+ D; Y4 |! O& e5 _
14. #endif

复制代码

; ~* P( x  f  E/ ?, H三、读取 W25Q128 设备 ID
本次实验是：读取 W25Q128 设备 ID，然后通过串口1打印出来。
通过简单的实验来调试，有利于发现问题。
通过W25Q128的数据手册可知其设备ID如下图所示：
8 E( L; l3 ~+ I3 m


( w+ r0 x4 c- oW25Q128.c
3 W1 ^3 Q$ W. o9 f

1. #include "W25Q128.h"
   ( S/ j  l5 F% z7 }) o* C
2. #include "SPI.h"
   
3. 
   
4. 
   6 _" Q8 d4 w6 m) `# E. L
5. uint8_t W25Q128_ReadWriteByte(uint8_t TxData)//函数包装一下
   
6. {     
   
7.            return SPI1_ReadWriteByte(TxData);                 
   
8. }
   
9. 
   
10. uint16_t W25Q128_ReadID(void)//读取芯片ID
    
11. {
    
12.         uint16_t Temp = 0;         
    
13.         W25Q128_CS(0);                                    
    " m: a! T. r3 ^1 R0 l8 @$ a* d9 c
14.         W25Q128_ReadWriteByte(W25X_ManufactDeviceID);//发送读取ID命令            
    
15.         W25Q128_ReadWriteByte(0x00);            
    - [% m, j3 u, d" r" _; }0 l
16.         W25Q128_ReadWriteByte(0x00);            
    , ~& l! {9 [; P2 _* I! R, |4 f
17.         W25Q128_ReadWriteByte(0x00);                                    
    
18.         Temp|=W25Q128_ReadWriteByte(0xFF)<<8;  
    9 o2 X: R; S0 o+ L% i
19.         Temp|=W25Q128_ReadWriteByte(0xFF);         
    
20.         W25Q128_CS(1);                                    
    
21.         return Temp;
    * `3 [: t& O% s+ m# u4 D* y9 q
22. }

复制代码

$ a# A, I) m3 d' i. lW25Q128.h
2 D# o1 V5 @! L+ |0 y* C9 }

1. #ifndef __W25Q128_H
   2 z2 u. s% \& R  P$ U
2. #define        __W25Q128_H
   9 ?2 H! V* d' P5 N
3. 
   + Y2 b1 R9 \: W; ?$ ?9 N
4. #include "stm32f10x.h"
   
5. 
   - G& k6 h/ o1 C4 Y% |3 p+ O
6. //操作指令表
   9 e& a& u" T; O* Q. T
7. #define W25X_ManufactDeviceID         0x90       //制造商+设备ID
   
8. 
   ! J4 |8 m8 E5 L
9. #define W25Q128_CS(a) SPI_CS(a)        
   
10. 
    & V; W& R) _) ?! e* y
11. uint8_t W25Q128_ReadWriteByte(uint8_t TxData);//函数包装一下
    ' _- O  p. Q! g) g* O$ L
12. uint16_t W25Q128_ReadID(void);//读取芯片ID
    ! [" ~( m! J9 Q2 O( j
13. 
    7 Q* E. Q) C1 X2 b' @9 n
14. #endif

复制代码

; k2 {5 E# k5 D% D/ }  ?/ i4 e3 smain.c
) v% L. c8 e: |* ]/ r! N, Z8 `4 S) Z

1. #include <stdio.h>
   2 f* U* N% P  s: T, b
2. #include "Uart1.h"
   
3. #include "delay.h"
   
4. #include "SPI.h"
   
5. #include "W25Q128.h"
   0 \4 ^2 f5 [$ }5 r- j6 C! a  z1 j
6. 
   $ V- l" [  i1 r5 p4 r( f+ F
7. uint16_t W25Q128_ID=0;
   : Q" J2 V% k% L7 x5 [4 N7 V
8. 
   7 g& z' d8 P$ j. }! ?& m
9. int main (void)
   % p" R! L; X6 g. D) S0 G9 [
10. {
    . \! m3 d+ G9 R+ b. S& u
11.         Uart1_init();
    - O: D& j5 }% B, q
12.         SPI1_Init();
    
13.         
    / d0 B  a  W9 s7 c; ^, u  E2 k
14.         W25Q128_ID = W25Q128_ReadID();
    
15.         while(1)
    
16.         {
    1 J' Y" }& t7 H1 C: _7 O
17.                 printf("\nW25Q128_ID=0x%X\n",W25Q128_ID);
    
18.                 delay_ms(500);
    . u1 \# E- _$ f8 Q6 \
19.         }
    
20. }

复制代码

实验结果


! i3 m& h4 ?+ L# p) M接收到 W25Q128 设备ID 为0xEF17
3 e4 m: x+ h4 P) V; z
" y; b* k) W/ y+ r四、读写 W25Q128 外部 Flash
7 r3 z# S" }) P1 p6 V2 KW25Q128.c
$ Y) w. d# U" u2 ]9 v; r5 m

1. #include "W25Q128.h"
   
2. #include "SPI.h"
   
3. 
   % |9 M3 R: e) e% A. {- |
4. 
   6 q& ^4 o. f% ?- M+ I
5. uint8_t W25Q128_ReadWriteByte(uint8_t TxData)//函数包装一下
   ; B% w( C, R% @4 S) e
6. {     
   ; Y( u5 }1 Q9 y3 Q5 K8 ?  ^! G
7.          return SPI1_ReadWriteByte(TxData);                 
   
8. }
   % }  d9 w& {6 f
9. 
   
10. 
    
11. uint16_t W25Q128_ReadID(void)//读取芯片ID
    
12. {
    5 Q# F& {" w1 p' h. Z
13.         uint16_t Temp = 0;         
    & J& J- p* D1 j4 l! z/ F
14.         W25Q128_CS(0);                                    
    ; X. z. `2 W0 a! ~7 w; G! _
15.         W25Q128_ReadWriteByte(W25X_ManufactDeviceID);//发送读取ID命令            
    4 U. N' [, X" O' J5 a
16.         W25Q128_ReadWriteByte(0x00);            
    
17.         W25Q128_ReadWriteByte(0x00);            
    
18.         W25Q128_ReadWriteByte(0x00);                                    
    
19.         Temp|=W25Q128_ReadWriteByte(0xFF)<<8;  
    9 t# k, o  L, H: j- e
20.         Temp|=W25Q128_ReadWriteByte(0xFF);         
    1 B( f  z+ T3 k8 O
21.         W25Q128_CS(1);                                    
    * w. g- q+ T' R# D6 [5 @0 S
22.         return Temp;
    . |* _% }- |3 }1 S0 d
23. }
    
24. 
    
25. //读取W25Q128的状态寄存器
    
26. //BIT7  6   5   4   3   2   1   0
    + k7 |3 s4 U2 h( u  I9 X6 [2 p2 Y, ?
27. //SPR   RV  TB BP2 BP1 BP0 WEL BUSY
    4 H% h7 z+ w3 h0 o3 X, G. Y- w0 R
28. //SPR:默认0,状态寄存器保护位,配合WP使用
    
29. //TB,BP2,BP1,BP0:FLASH区域写保护设置
    " D/ C( Y) z. h! R) `$ {' I" M* h  `
30. //WEL:写使能锁定
    # N: D$ O6 i3 x* v8 A& F5 ]
31. //BUSY:忙标记位(1,忙;0,空闲)
    
32. //默认:0x00
    
33. uint8_t W25Q128_ReadSR(void)//读取状态寄存器
    % t/ A# C7 s) q: x* C$ T( }
34. {
    4 h/ J2 B+ `0 {7 I
35.     uint8_t byte=0;
    ! B, s- u9 O4 [5 u# W- _
36.     W25Q128_CS(0);                               //使能器件
    + k# |' F- _4 ~8 E2 D% H7 |5 U
37.     W25Q128_ReadWriteByte(W25X_ReadStatusReg1);  //发送读取状态寄存器命令
    . H! Y' @+ ~* F0 r7 Z
38.     byte=W25Q128_ReadWriteByte(0Xff);            //读取一个字节
    3 x# y6 k, Y5 D1 t) X
39.     W25Q128_CS(1);                               //取消片选
    
40.     return byte;
    
41. }
    
42. 
    # c' T: ^" H0 ]4 H
43. //写W25Q128状态寄存器
    
44. //只有SPR,TB,BP2,BP1,BP0(bit 7,5,4,3,2)可以写!!!
    
45. void W25Q128_WriteSR(uint8_t sr)//写状态寄存器
    
46. {
    4 T. j5 J$ a/ K1 A5 ]& z* V
47.     W25Q128_CS(0);                                           //使能器件
    
48.     W25Q128_ReadWriteByte(W25X_WriteStatusReg1);        //发送写取状态寄存器命令
    3 `; o' ?  u: J: F7 b9 V
49.     W25Q128_ReadWriteByte(sr);                               //写入一个字节
    ( O; J$ M1 w. r, G6 M. a) i
50.     W25Q128_CS(1);                                            //取消片选
    9 Z; I) c. y( u0 I
51. }
    
52. 
    7 @+ S0 P& a, P
53. void W25Q128_Write_Enable(void) //写使能
    4 e% g, J5 k* f; M% p
54. {
      v, M) Y, t5 B" C& G- ^: R
55.            W25Q128_CS(0);        
    
56.         W25Q128_ReadWriteByte(W25X_WriteEnable);
    $ ?5 k" e9 c" M
57.         W25Q128_CS(1);        
    0 p% c! I  g; E; U7 Y
58. }
    
59. 
    
60. void W25Q128_Write_Disable(void) //禁止写入        
    ; Y1 |- `$ y2 D: e' X. i9 K% m
61. {
    % \& _2 U" A4 _( J6 l8 a' i  a
62.            W25Q128_CS(0);        
    
63.         W25Q128_ReadWriteByte(W25X_WriteDisable);
    # }1 `. A* E( v* X8 t6 v, Q6 w
64.         W25Q128_CS(1);        
    4 W# D5 m/ R6 Y2 a( J
65. }
    
66. 
    / Y+ F/ D7 e- E& ?/ o5 `/ D
67. void W25Q128_Read(uint8_t* pBuffer,uint32_t ReadAddr,uint16_t NumByteToRead)   
    
68. {                                                     
      [7 B5 u: l. c5 I
69.         W25Q128_CS(0);                                  //使能器件   
    
70.     W25Q128_ReadWriteByte(W25X_ReadData);      //发送读取命令  
    % b; _+ v# T; {1 A, F' u0 [4 K' w
71.     W25Q128_ReadWriteByte((uint8_t)((ReadAddr)>>16));   //发送24bit地址   
    8 C6 l/ y! m$ `" a
72.     W25Q128_ReadWriteByte((uint8_t)((ReadAddr)>>8));   
    : ~- h9 e+ D9 _/ L6 E
73.     W25Q128_ReadWriteByte((uint8_t)ReadAddr);   
    & \; I  y: e0 m, t' @6 [
74.     for(uint16_t i=0;i<NumByteToRead;i++)
    
75.         {
    : |' l, e) B! y: G% R5 O' ]' E- p# }
76.        pBuffer<i>=W25Q128_ReadWriteByte(0XFF);    //循环读数  
    6 s9 i8 L+ d5 i
77.     }
    
78.         W25Q128_CS(1);                                                  
    * w8 i; n6 b5 o. Z
79. }  
    
80. 
    
81. 
    7 L2 H5 B& Q" {) x5 e: j. c% _
82. void W25Q128_Write_Page(uint8_t* pBuffer,uint32_t WriteAddr,uint16_t NumByteToWrite)
    9 B" c$ W. M, ~# N$ M; E
83. {
    : x: W7 X. w0 ?! z1 N
84. 
    
85.     W25Q128_Write_Enable();                  //SET WEL
    
86.         W25Q128_CS(0);                            //使能器件   
    2 E) _1 @  N7 v2 b; p
87.     W25Q128_ReadWriteByte(W25X_PageProgram);   //发送写页命令   
    
88. 
    4 y; n$ x/ L3 @
89.     W25Q128_ReadWriteByte((uint8_t)((WriteAddr)>>16)); //发送24bit地址   
    ! l" j- X7 W' n: j# A" G  C
90.     W25Q128_ReadWriteByte((uint8_t)((WriteAddr)>>8));   
    
91.     W25Q128_ReadWriteByte((uint8_t)WriteAddr);   
    6 p' [, ~( Q5 z0 B. b1 B
92.     for(uint16_t i=0;i<NumByteToWrite;i++)
    
93.         {
    
94.                 W25Q128_ReadWriteByte(pBuffer<i>);//循环写数  
    # J7 R$ }) o& C- i% _4 Y
95.         }
    + P, y  x, v$ ^+ F' ]
96.         W25Q128_CS(1);                            //取消片选
    : `; L% r: ]- S
97.         W25Q128_Wait_Busy();                                           //等待写入结束
    
98. }
    
99. 
    ; c: L( I% I  t* |
100. //无检验写SPI FLASH
     
101. //必须确保所写的地址范围内的数据全部为0XFF,否则在非0XFF处写入的数据将失败!
     ; w" \1 O5 t2 X1 y
102. //具有自动换页功能
     - i+ \  w. @. A# e: @
103. void W25Q128_Write_NoCheck(uint8_t* pBuffer,uint32_t WriteAddr,uint16_t NumByteToWrite)   
     
104. {                                          
       }  s7 j" [6 A; c8 _
105.         uint16_t pageremain=256-WriteAddr%256; //单页剩余的字节数                             
     9 N; w4 O3 y& Y) T
106.         if(NumByteToWrite<=pageremain)pageremain=NumByteToWrite;//不大于256个字节
     
107.         while(1)
     
108.         {           
     9 [0 Z/ U! x+ J. ]- \- x4 {
109.                 W25Q128_Write_Page(pBuffer,WriteAddr,pageremain);
     - Q1 N% f" z" X. f+ j' [
110.                 if(NumByteToWrite==pageremain)        break;//写入结束了
     
111.                  else
     
112.                 {
     
113.                         pBuffer+=pageremain;
     5 X  Y* T7 n% j, `: ]7 p4 r8 P! E
114.                         WriteAddr+=pageremain;        
     
115.                         NumByteToWrite-=pageremain;                          //减去已经写入了的字节数
     
116.                         if(NumByteToWrite>256)pageremain=256; //一次可以写入256个字节
     
117.                         else pageremain=NumByteToWrite;           //不够256个字节了
     
118.                 }
     
119.         }            
     
120. }
     
121. 
     
122. //写SPI FLASH  
     5 W6 b# s0 n9 s7 _4 U* c! T( K
123. //在指定地址开始写入指定长度的数据
     
124. //该函数带擦除操作!
     
125. //pBuffer:数据存储区
     
126. //WriteAddr:开始写入的地址(24bit)                                                
     
127. //NumByteToWrite:要写入的字节数(最大65535)   
     
128. uint8_t W25Q128_BUFFER[4096];                 
     
129. void W25Q128_Write(uint8_t* pBuffer,uint32_t WriteAddr,uint16_t NumByteToWrite)   
     
130. {
     
131.          uint16_t i;   
     
132.         uint8_t * W25Q128_BUF;         
     ! M- c! X9 b5 y9 g8 F
133.     W25Q128_BUF=W25Q128_BUFFER;            
     
134.          uint32_t secpos = WriteAddr/4096;//扇区地址  
     
135.         uint16_t secoff = WriteAddr%4096;//在扇区内的偏移
     
136.         uint16_t secremain = 4096-secoff;//扇区剩余空间大小   
     
137. 
     + l, p: t9 b" V3 ?* e
138.          if(NumByteToWrite<=secremain)                secremain=NumByteToWrite;//不大于4096个字节
     
139.         while(1)
     
140.         {        
     
141.                 W25Q128_Read(W25Q128_BUF,secpos*4096,4096);//读出整个扇区的内容
     
142.                 for(i=0;i<secremain;i++)//校验数据
     
143.                 {
     4 S* M: u$ Y7 {& E1 {1 l
144.                         if(W25Q128_BUF[secoff+i]!=0XFF)        break;//需要擦除            
     
145.                 }
     . m% v' ^" m: }! H% q8 V# H5 }' A. }
146.                 if(i<secremain)//需要擦除
       s5 t/ \) D% j" V/ y: m
147.                 {
     
148.                         W25Q128_Erase_Sector(secpos*4096);//擦除这个扇区
     3 X, {0 X5 o  ?& v6 J
149.                         for(i=0;i<secremain;i++)           //复制
     
150.                         {
     1 P" M. |! d# m! k( n" Q
151.                                 W25Q128_BUF[i+secoff]=pBuffer<i>;         
     . K4 a; c9 s0 F, i: p
152.                         }
     ) w% Y# F' `5 X- b9 q
153.                         W25Q128_Write_NoCheck(W25Q128_BUF,secpos*4096,4096);//写入整个扇区  
     9 ?; a6 F! U2 l7 r6 p/ \
154. 
     
155.                 }else W25Q128_Write_NoCheck(pBuffer,WriteAddr,secremain);//写已经擦除了的,直接写入扇区剩余区间.                                    
     
156.                 if(NumByteToWrite==secremain)        break;//写入结束了
     . `0 ?) \% y* o/ [2 X8 b
157.                 else//写入未结束
     % Q8 D% f( D; h0 Q% A
158.                 {
     ( x$ u: W; [  k+ b( P
159.                         secpos++;//扇区地址增1
     
160.                         secoff=0;//偏移位置为0         
     : Z0 N! z9 F, i# i% C) |7 F) }1 c
161. 
     
162.                     pBuffer+=secremain;  //指针偏移
     
163.                         WriteAddr+=secremain;//写地址偏移           
     
164.                     NumByteToWrite-=secremain;                                //字节数递减
     6 S6 I: b5 i# q' |9 D6 K
165.                         if(NumByteToWrite>4096)        secremain=4096;        //下一个扇区还是写不完
     
166.                         else         secremain=NumByteToWrite;                //下一个扇区可以写完了
     ! d# \% x- _' ?. m/ y
167.                 }         
     8 {( z9 ^. c: e5 q) N2 H
168.         }         
     9 T, ~. x- n2 u2 [+ v% k
169. }
     ) b" s$ K; [) c) h; l
170. 
     6 Q# T0 Z. e. B! g1 ~0 P# S8 w. {
171. //擦除一个扇区
     
172. //Dst_Addr:扇区地址 根据实际容量设置
     
173. //擦除一个扇区的最少时间:150ms
     2 Z4 V3 a* D5 Y# S' p5 W: G
174. 
     
175. void W25Q128_Erase_Sector(uint32_t Dst_Addr)   
     
176. {  
     : b3 \' a' R% r2 \% @/ ?! j
177.     W25Q128_Write_Enable();                  //SET WEL         
     ( k7 _" t3 H+ C: k' r+ r- x
178.     W25Q128_Wait_Busy();   
     
179.           W25Q128_CS(0);                            //使能器件   
     
180.     W25Q128_ReadWriteByte(W25X_SectorErase);   //发送扇区擦除指令
     7 W6 u% b5 y- s; G: N
181.     W25Q128_ReadWriteByte((uint8_t)((Dst_Addr)>>16));  //发送24bit地址   
     
182.     W25Q128_ReadWriteByte((uint8_t)((Dst_Addr)>>8));   
     
183.     W25Q128_ReadWriteByte((uint8_t)Dst_Addr);  
     0 [. l; V2 z9 {" R+ G9 |: k
184.         W25Q128_CS(1);                                    //取消片选                  
     0 V' ~& c) R% {' M
185.     W25Q128_Wait_Busy();                                               //等待擦除完成
     % X! \$ h6 V" Y
186. }  
     
187. 
     * o$ ^3 Z' ]! i5 m
188. //擦除整个芯片                  
     + C& ]. Z0 v0 v- x* m
189. //等待时间超长...
     
190. void W25Q128_Erase_Chip(void)   
     5 q' J% t4 u' J' `: I
191. {                                   
     
192.     W25Q128_Write_Enable();                  //SET WEL
     
193.     W25Q128_Wait_Busy();   
     & y* T5 n- i9 Y& H2 _
194.           W25Q128_CS(0);                           //使能器件   
     
195.     W25Q128_ReadWriteByte(W25X_ChipErase);   //发送片擦除命令  
     6 R# Q. m) e# e  N
196.         W25Q128_CS(1);                           //取消片选                  
     
197.         W25Q128_Wait_Busy();                                              //等待芯片擦除结束
     - Y0 B2 K+ F- l0 o" x
198. }
     $ O0 S5 F" X. d
199. 
     
200. 
     . K+ H: H5 e: L
201. //等待空闲
     
202. void W25Q128_Wait_Busy(void)   
     
203. {   
     
204.         while((W25Q128_ReadSR()&0x01)==0x01);   // 等待BUSY位清空
     0 l" U/ Z$ _8 h# r
205. }  
     
206. 
     
207. //进入掉电模式
     ' s2 r/ O# E0 E& F$ R) v
208. void W25Q128_PowerDown(void)   
     + `8 X4 ^6 e* G0 N
209. {
     4 [9 I" K/ s5 L7 V) |
210.           W25Q128_CS(0);                            //使能器件   
     
211.     W25Q128_ReadWriteByte(W25X_PowerDown);    //发送掉电命令  
     / n3 \8 x2 k( i0 j- s9 o
212.         W25Q128_CS(1);                            //取消片选                  
       e8 J; ~  d' _- P
213. }   
     * y- |. }# T& d8 q  r
214. //掉电唤醒
     
215. void W25Q128_WAKEUP(void)   
     
216. {  
     6 ~5 p* n# g. \( M/ T9 D/ }
217.           W25Q128_CS(0);                                //使能器件   
     
218.     W25Q128_ReadWriteByte(W25X_ReleasePowerDown);   
     ; ~% H( N+ U; x7 k7 R1 ~9 J
219.         W25Q128_CS(1);                                //取消片选                  
     
220. }   </i></i></i>

复制代码

W25Q128.h
#ifndef __W25Q128_H
. p0 \7 R( a$ U7 p  z#define        __W25Q128_H
8 G( m+ d3 p3 E/ w9 t0 q/ e
7 o/ y! {0 u* o& k#include "stm32f10x.h"

; d; z; a$ G% \0 a# ~0 G, k//操作指令表
' |$ @* K+ d+ Z8 P) K& Y4 O/ ^5 }( p#define W25X_WriteEnable                           0x06         //写使能
#define W25X_WriteDisable                           0x04         //写禁止
#define W25X_ReadStatusReg1                         0x05         //读状态寄存器1
, C0 z1 j) \0 C6 t, I1 @#define W25X_ReadStatusReg2                         0x35         //读状态寄存器2
# J9 n: l5 j6 Z% L3 j' J#define W25X_ReadStatusReg3                         0x15         //读状态寄存器3
# f5 M5 U$ W- o6 {! }4 a! y+ [4 r0 K" f#define W25X_WriteStatusReg1                   0x01         //写状态寄存器1
#define W25X_WriteStatusReg2                   0x31         //写状态寄存器2
#define W25X_WriteStatusReg3                   0x11         //写状态寄存器3
8 a% X5 U* D# g* N( Y$ e% l#define W25X_ReadData                                0x03         //读数据
#define W25X_FastReadData                           0x0B         //快读
6 p# T" _* i* U0 d#define W25X_FastReadDual                           0x3B    //双输出快读
& T; I+ I: n$ B/ w8 y8 R7 f; O+ w#define W25X_PageProgram                           0x02         //页编程
! |  \4 |% }9 |4 s. J7 X; R#define W25X_BlockErase                                   0xD8         //块擦除（64K）
#define W25X_SectorErase                           0x20    //扇区擦除（4K）
#define W25X_ChipErase                                   0xC7    //芯片擦除
* H* o2 a8 C6 e- C#define W25X_PowerDown                                   0xB9    //掉电
; g4 c8 }" C# B: Q2 N#define W25X_ReleasePowerDown                 0xAB    //释放掉电
#define W25X_DeviceID                            0xAB    //器件ID
#define W25X_ManufactDeviceID                 0x90    //制造商+设备ID
8 J$ E! {  L: m# g$ d#define W25X_JedecDeviceID                         0x9F         //电子元件ID
* F& c! Z( v& c  J
4 k/ t% J7 k; E5 }
#define W25Q128_CS(a) SPI_CS(a)        

6 _2 c% {8 [. G% F- r, W
. }& w: Z# h: O5 vuint8_t W25Q128_ReadWriteByte(uint8_t TxData);//函数包装一下
) N0 W; a- Q; y
uint16_t W25Q128_ReadID(void);//读取芯片ID

) U8 H1 Y# t6 [# t" g9 auint8_t W25Q128_ReadSR(void);//读取状态寄存器
/ f& V6 ^. V7 h! d% gvoid W25Q128_WriteSR(uint8_t sr);//写状态寄存器
! F, k! U+ p1 k' e. t' J: t
& u. ^0 P! v: l' ^+ qvoid W25Q128_Write_Enable(void);//写使能
void W25Q128_Write_Disable(void);//禁止写入        

void W25Q128_Read(uint8_t* pBuffer,uint32_t ReadAddr,uint16_t NumByteToRead); //读取数据
void 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);//写入数据，带擦写功能

void W25Q128_Erase_Sector(uint32_t Dst_Addr);//擦除扇区
void W25Q128_Erase_Chip(void);//擦除整个芯片        

+ N  B6 Q" Z- V: p, d) nvoid W25Q128_Wait_Busy(void);//等待空闲
void W25Q128_PowerDown(void); //进入掉电模式
void W25Q128_WAKEUP(void);//掉电唤醒
; B9 Y; U2 K0 [& b5 ^0 k: s
3 r8 O( P& y1 O" b#endif
2 Q, Z; t7 X% z% J" c
; [# n& P% ~# w; x, p3 @$ N1
( v+ j6 s% Z, u+ J* @2
7 F0 o9 [( ^8 K3
' m2 F# K# E3 b8 g4
6 e3 x' N/ S/ n. y; o+ m- Z2 o; _5
6
6 _, r* J6 |5 L& B7
/ H1 r2 B# ]3 s: r5 G8
5 `8 b/ C. }: S  B' x" o9
# z* A- n) T) w5 f  `' C10
  g) y. t6 V2 }+ O( e11
12
! f* i) X$ e1 J% d+ a- H13
14
15
% e3 k9 j) C# u5 M* ?1 f16
2 f. D+ K3 Y+ ~# |4 P% H0 g( u/ g- V17
18
19
20
9 p3 Q/ n" a- H# B' i21
% S1 h" k- G9 I) Q! |# g  l22
* C% e) b% X- t' ~$ k23
24
0 f; h5 ~2 }$ |% R7 H7 ]* |25
$ ~' o  P; ^) y( v9 c% A) A$ n26
27
3 T+ H1 \  ]& N28
29
# l! V& Y* N9 z" f30
31
- N) K. @9 ^# h4 z32
33
% t$ ?+ m/ c0 Z$ \& t6 q! g2 m34
35
36
3 Y, g! G. f$ i, o- V8 x. x37
2 Z5 W4 E( H# |: D* F" C38
1 k7 ~  w5 ?8 h; _! o! g39
$ A2 B: u# W" X8 A2 a40
& G5 H3 w" g2 Q8 {! m41
42
$ [3 O1 G, I% [43
0 x% O# |' w8 L$ k) `44
# |) Q$ N* ~2 [6 f! [% k5 a" ~45
1 Q+ `8 {% x& M( P7 R/ G46
3 ?& ~) A) }* o47
48
; A( `9 A6 k4 [49
50
9 @& {9 B% s! \$ `" o51
: l: V" L; K7 U4 g& ~% a52
53
' \! u* l/ m5 x& l/ y54
main.c
) U5 g2 x- t: }- B, R#include <stdio.h>
$ H3 S1 \% ^- G& \, y#include "Uart1.h"
7 S- _. N9 i6 Y& U9 X) W% C/ X#include "delay.h"
% r" A- t" \" i; @" w0 f#include "SPI.h"
' y; D6 p# F0 D#include "W25Q128.h"
' x) ^6 T, W+ Y, X' U
  m1 a# `/ O4 N$ T, N) Ruint16_t W25Q128_ID=0;
9 s$ C$ E' ?9 A, m5 kuint8_t Write_data[20]={1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20};
7 i; D6 Z" S# ?1 ^' Juint8_t Read_data[100];

4 F' S2 g; f0 G: f+ ^. ^int main (void)
) ]% V& Q9 C6 ?5 u{
1 g* o2 s* B# ^( o& I/ a        Uart1_init();
* a. b8 ~& \5 X; f: m1 v$ O' c        SPI1_Init();
+ N3 Y$ B- M5 w! i2 x        
        W25Q128_ID=W25Q128_ReadID();
, u, B5 B7 n( i& a        W25Q128_Write_Page(Write_data,0x01,20);
        
        while(1)
        {
4 w4 p" q3 ]. \  Q- b7 H# Z                W25Q128_Read(Read_data,0x00,100);
! @  R- ]! L( E& Q$ T9 e                for(int i=0;i<100;i++)
                {
                        printf(" 0x%X ",Read_data);
- y' Y0 W3 q: _4 t4 q                }
0 L: K$ b* O% ?5 O+ y  l                printf("\nW25Q128_ID=0x%X\n",W25Q128_ID);
3 U9 ^4 U+ \# i                delay_ms(500);
        }
4 l# s8 ?# t' }$ V}

! P9 J7 O6 T2 B) g; g' R1
2
2 _. L  u4 d6 s% o; W4 W4 Z3
4
' `, ]3 u" o. |3 @. f- Y' i, T5
6
* I( R9 t  P) o& X9 }0 s: J3 m7
2 H! R1 M  J2 u3 {8
: x- _( V. {, j! g* F2 ]: \9
10
4 V% P6 w7 Q! Q8 s1 [4 P! h+ y11
12
6 I* i3 f% U& w, g13
9 @' |' _: `  y$ W- C$ ~0 s" _' @* v14
15
( V2 o: o6 I% ^16
6 }, ]! f' A7 n% T17
* h* h  G1 H7 n! T: L5 U$ @( Q18
; [0 N! c/ H6 S/ K. M19
- {! d( q% O( B" Y2 v/ P8 H! e9 E20
21
+ t# [, F. B0 p# Y; Q7 ]8 D22
  a* b* N, @: V) Y& r7 Y2 z( H6 }23
24
25
  W. M- x" g$ Y  c2 k' h, ]* H26
27
- Y2 I$ O4 T" U# u* Z28
29
- [; U3 y6 N/ h实验结果
" g' ?) ~$ w- R) C- s  t
& I$ \: c+ `) x————————————————
版权声明：根号五


, \' t! B5 ?0 r9 A