一、实验前期准备
. y7 ^2 j& X$ h, Y+ n本次实验的 MCU 是 STM32F103C8T6 芯片，通过 SPI 通信实现 W25Q128 的读写操作。
6 w/ y+ s0 J) w8 L9 `
, |9 h* Q) V6 ~' i) I1. 原理图



2. 引脚连接
3 w. F& T" p5 ]- l; @

0 r  ]: c5 ?- A! Z- p
  M3 S7 ^3 z6 u二、SPI 底层驱动
, S# [- j% i. M# D# x# s  JSPI.c
' L( _, t  s- Y

1. #include "SPI.h"
   + v3 N4 W2 q* Y' U; x3 S
2. 
   
3. /*
   
4.         SPI引脚初始化配置
   
5.         **PA4------CS
   
6.         **PA5------SCLK
   " W* [7 F/ c2 P( l! Z. S" ?: l
7.         **PA6------MISO
   
8.         **PA7------MOSI
   
9. */
   ! y/ m8 b/ O% S+ W" Q
10. 
    ) J$ [! {8 K! n) `$ r- A
11. static void SPI1_GPIO_Config(void)        
    & G' `& K1 T2 m) X
12. {
    
13.         GPIO_InitTypeDef GPIO_InitStructure;
    
14.         
    
15.         RCC_APB2PeriphClockCmd(        RCC_APB2Periph_GPIOA, ENABLE );//PORTA时钟使能
    
16. 
    
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
    5 P. ?6 O# R' i
21.         
    ' q; O5 l9 i9 X7 b( d
22.         GPIO_InitStructure.GPIO_Pin = GPIO_Pin_4;
    
23.         GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;  //PA4推挽输出
    
24.         GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
    
25.         GPIO_Init(GPIOA, &GPIO_InitStructure);                                                //初始化GPIOA
    
26. 
    # [; C  Z, ^, g. f. U
27.         GPIO_SetBits(GPIOA,GPIO_Pin_4|GPIO_Pin_5|GPIO_Pin_6|GPIO_Pin_7); //初始上拉输出
    
28. 
    : E! P/ s' F" Z+ X( |. i
29. }
    - u& C3 P- e- L9 M! c6 t, l
30. 
    
31. //SPI1初始化函数
    2 [4 q9 G4 P, _
32. void SPI1_Init(void)
    
33. {
    
34.         SPI1_GPIO_Config();//SPI引脚初始化配置        
    . O2 ?( I$ e$ q
35. 
    
36.         SPI_InitTypeDef  SPI_InitStructure;
    
37.         
    
38.         RCC_APB2PeriphClockCmd(        RCC_APB2Periph_SPI1,  ENABLE );//SPI1时钟使能         
    
39.         
    
40.         SPI_InitStructure.SPI_Direction = SPI_Direction_2Lines_FullDuplex;          //设置SPI单向或者双向的数据模式:SPI设置为双线双向全双工
    
41.         SPI_InitStructure.SPI_Mode = SPI_Mode_Master;                                                                                                        //设置SPI工作模式:设置为主SPI
    , M7 Y, O2 ]. \: S. B
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;                                                                                                        //串行同步时钟的第二个跳变沿（上升或下降）数据被采样
    
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位开始
    
48.   SPI_InitStructure.SPI_CRCPolynomial = 7;        //CRC值计算的多项式
    0 h: M# g1 q1 x0 }0 C
49.         SPI_Init(SPI1, &SPI_InitStructure);                          //根据SPI_InitStruct中指定的参数初始化外设SPIx寄存器
    
50.         
    7 X1 z2 i/ T( g, \( E6 d
51.         SPI_Cmd(SPI1, ENABLE); //使能SPI外设
    
52.         SPI1_ReadWriteByte(0xFF);//启动传输
    
53. }
    / B- B4 [9 r, E2 X( h! r" U' d
54. 
    " C+ g% s) H" a! h+ k; L
55. /*
    ' E9 c- I' U; C( _* f
56.         SPI的读写操作
    
57.         **TxData:要写入的字节
    
58.         **返回值:读取到的字节
    4 i& a' E3 F: S/ s! |  x, q! H
59. */
    4 W0 t! D, A- i& d+ f% i
60. uint8_t SPI1_ReadWriteByte(uint8_t TxData)
    9 B$ t/ g# a& T0 k( E) H& r
61. {                                 
    
62.         while (SPI_I2S_GetFlagStatus(SPI1, SPI_I2S_FLAG_TXE) == RESET) //检查指定的SPI标志位设置与否:发送缓存空标志位
    
63.         {
    
64.                 //等待发送完成
    # d+ E9 M; y/ P5 ?  e' L
65.         }                          
    : j" o. c+ @& U& k! G
66.         SPI_I2S_SendData(SPI1, TxData); //通过外设SPIx发送一个数据
    
67.         while (SPI_I2S_GetFlagStatus(SPI1, SPI_I2S_FLAG_RXNE) == RESET) //检查指定的SPI标志位设置与否:接受缓存非空标志位
    $ t/ [  e) q; V$ L5 `* Q2 T1 O
68.         {
    * c  c0 {( O) T6 R
69.                 //等待接收完成
    
70.         }                                                              
    . m2 b  ]+ @+ H0 `% ^) n: t
71.         return SPI_I2S_ReceiveData(SPI1); //返回通过SPIx最近接收的数据                                            
    " `: L6 I; X3 H$ |
72. }

复制代码

SPI.h

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);\
   / x( c3 _- S1 R" }  ~/ t5 V6 J: F
8.                                                 else                \
   7 m$ L$ T2 I0 ]2 T
9.                                             GPIO_ResetBits(GPIOA,GPIO_Pin_4)
   
10. 
    
11. void SPI1_Init(void);//SPI1初始化函数
    
12. uint8_t SPI1_ReadWriteByte(uint8_t TxData);//SPI1读写函数
    
13. 
    3 q9 y  J- T/ n* y" W
14. #endif

复制代码

; b8 N# H4 N2 z% m7 l三、读取 W25Q128 设备 ID
+ n2 f9 N/ v4 H+ |; z, C本次实验是：读取 W25Q128 设备 ID，然后通过串口1打印出来。
通过简单的实验来调试，有利于发现问题。
! _& @* }0 s0 _% C7 T. N1 r通过W25Q128的数据手册可知其设备ID如下图所示：

% T- {% ~& T& Y4 W1 \

W25Q128.c

1. #include "W25Q128.h"
   2 s# e' I9 C& p8 K& I; l( a
2. #include "SPI.h"
   $ V& C: C6 D  R
3. 
   
4. 
   
5. uint8_t W25Q128_ReadWriteByte(uint8_t TxData)//函数包装一下
   " W0 i1 L( k6 J) V! L
6. {     
   
7.            return SPI1_ReadWriteByte(TxData);                 
   6 [1 b, v" D) }9 v* w5 w( a
8. }
   
9. 
   
10. uint16_t W25Q128_ReadID(void)//读取芯片ID
    & y' C% w: }* q, M
11. {
    
12.         uint16_t Temp = 0;         
    ) v- c* ^1 K2 S; b& e
13.         W25Q128_CS(0);                                    
    
14.         W25Q128_ReadWriteByte(W25X_ManufactDeviceID);//发送读取ID命令            
    
15.         W25Q128_ReadWriteByte(0x00);            
    
16.         W25Q128_ReadWriteByte(0x00);            
    7 K9 Z/ M; O+ v# H: u
17.         W25Q128_ReadWriteByte(0x00);                                    
    
18.         Temp|=W25Q128_ReadWriteByte(0xFF)<<8;  
    & N! f1 m% L1 V  T( g
19.         Temp|=W25Q128_ReadWriteByte(0xFF);         
    - G, L' h' [1 u) e. i
20.         W25Q128_CS(1);                                    
    
21.         return Temp;
    
22. }

复制代码

W25Q128.h

1. #ifndef __W25Q128_H
   / ~# S+ D5 ~9 u# C* K4 e
2. #define        __W25Q128_H
   2 R$ V4 |4 |* N6 g
3. 
   * M1 C3 d- d$ }+ L# O
4. #include "stm32f10x.h"
   
5. 
   # O: Z6 o' u) K8 T  q  ^
6. //操作指令表
   6 w- l3 {. X& }+ e/ P$ y* Z) R
7. #define W25X_ManufactDeviceID         0x90       //制造商+设备ID
   
8. 
   - O2 ^1 r  d- g0 ~) P3 _4 y
9. #define W25Q128_CS(a) SPI_CS(a)        
   
10. 
    
11. uint8_t W25Q128_ReadWriteByte(uint8_t TxData);//函数包装一下
    
12. uint16_t W25Q128_ReadID(void);//读取芯片ID
    
13. 
    
14. #endif

复制代码

main.c
) E! O5 u# c- G$ {

1. #include <stdio.h>
   
2. #include "Uart1.h"
   % h! r" B( S2 l5 B3 f
3. #include "delay.h"
   
4. #include "SPI.h"
   
5. #include "W25Q128.h"
   2 ]8 H- i! e4 k) ^1 y5 A$ ?
6. 
   ( S% R. F) Z( O& U* H; s
7. uint16_t W25Q128_ID=0;
   9 V: V# \$ f. y, I# o+ ]
8. 
   
9. int main (void)
   
10. {
    0 U7 w; a$ G* C# \* u
11.         Uart1_init();
    
12.         SPI1_Init();
    ' q5 Q) Y5 y- o
13.         
    / j; n3 [+ D) m2 i
14.         W25Q128_ID = W25Q128_ReadID();
    ! k& |% T7 g4 K: r) g# T
15.         while(1)
    ; W+ W+ w" f% V  p. M! C6 O) C
16.         {
    4 F# k6 u- q; S* P1 ?4 {. F. _2 |
17.                 printf("\nW25Q128_ID=0x%X\n",W25Q128_ID);
    7 I/ U" C& r7 Z
18.                 delay_ms(500);
    7 `2 W4 e; Y# n( f) b8 O& [+ r& b' g
19.         }
    3 g7 F2 a% d& g. ]4 g; R
20. }

复制代码

7 J8 a2 n: S- D* f4 @5 U实验结果

9 Q; V& A2 _5 r, Y' v
* v' G3 E4 m, e4 \) b接收到 W25Q128 设备ID 为0xEF17
, i& a3 S0 O% X
# l  b5 x' r3 ]9 L/ M& C四、读写 W25Q128 外部 Flash
$ C( U  ~2 d( j3 [W25Q128.c
: \) j& W/ p1 J9 N5 R1 k3 ~

1. #include "W25Q128.h"
   + g/ a: `; X, N' B
2. #include "SPI.h"
   
3. 
   
4. 
   
5. uint8_t W25Q128_ReadWriteByte(uint8_t TxData)//函数包装一下
   + r2 M" v" ~6 K9 C% N3 W
6. {     
   
7.          return SPI1_ReadWriteByte(TxData);                 
   
8. }
   
9. 
   ; O6 ^9 m9 w. E: ~5 d% L
10. 
    ) q7 m# j  z6 ?" T# N/ M
11. uint16_t W25Q128_ReadID(void)//读取芯片ID
    
12. {
    
13.         uint16_t Temp = 0;         
    : n0 r2 g+ n* K4 G! Z8 ]7 o4 c
14.         W25Q128_CS(0);                                    
    & I4 u2 Q$ y: j& w- n( U
15.         W25Q128_ReadWriteByte(W25X_ManufactDeviceID);//发送读取ID命令            
    " o: A4 Z4 J8 l) k8 g9 A4 i# W
16.         W25Q128_ReadWriteByte(0x00);            
    
17.         W25Q128_ReadWriteByte(0x00);            
    
18.         W25Q128_ReadWriteByte(0x00);                                    
    ( ^! M& i$ h+ |0 t1 G
19.         Temp|=W25Q128_ReadWriteByte(0xFF)<<8;  
    
20.         Temp|=W25Q128_ReadWriteByte(0xFF);         
    # P( c( g# K) a. M; B) W
21.         W25Q128_CS(1);                                    
    ) \, a* _' A3 B' z: q
22.         return Temp;
    
23. }
    1 w; s5 m  B# D1 ?4 s1 g( _
24. 
    , Z7 q* W- J2 a- A0 R8 \
25. //读取W25Q128的状态寄存器
    $ H- d+ l3 b( N0 Q8 s: J6 t1 i
26. //BIT7  6   5   4   3   2   1   0
    
27. //SPR   RV  TB BP2 BP1 BP0 WEL BUSY
      B& b4 Q3 F: [. P
28. //SPR:默认0,状态寄存器保护位,配合WP使用
    
29. //TB,BP2,BP1,BP0:FLASH区域写保护设置
    2 P  l! z5 l" H$ m1 Y  f
30. //WEL:写使能锁定
    . K" r% Y7 e' v
31. //BUSY:忙标记位(1,忙;0,空闲)
    
32. //默认:0x00
    0 B; v! @3 F- i; I" K, {  F1 M* X. X
33. uint8_t W25Q128_ReadSR(void)//读取状态寄存器
      k$ ]/ Y* x. f$ G0 D1 A: M7 m
34. {
    
35.     uint8_t byte=0;
    
36.     W25Q128_CS(0);                               //使能器件
    
37.     W25Q128_ReadWriteByte(W25X_ReadStatusReg1);  //发送读取状态寄存器命令
    $ k  x2 u# ]/ |3 ]
38.     byte=W25Q128_ReadWriteByte(0Xff);            //读取一个字节
    : e* R) ~, x% N: k* g' [
39.     W25Q128_CS(1);                               //取消片选
    * L5 K2 e+ ~( ^5 P3 \* o
40.     return byte;
    ) W! c1 B: Q3 ]1 f
41. }
    
42. 
    9 F1 S. s8 `. y1 m) \! b
43. //写W25Q128状态寄存器
    
44. //只有SPR,TB,BP2,BP1,BP0(bit 7,5,4,3,2)可以写!!!
    + m/ d. u; m9 ?. Y' N
45. void W25Q128_WriteSR(uint8_t sr)//写状态寄存器
    # o$ N- j: F  t( m. G
46. {
    % s5 L) ?6 X! l# J
47.     W25Q128_CS(0);                                           //使能器件
    ) L$ C( n' X% w
48.     W25Q128_ReadWriteByte(W25X_WriteStatusReg1);        //发送写取状态寄存器命令
    . c* j! i/ D$ b" o8 A9 m; w4 K
49.     W25Q128_ReadWriteByte(sr);                               //写入一个字节
    8 j2 ]5 t$ X7 ]! A7 q! L7 [/ K
50.     W25Q128_CS(1);                                            //取消片选
    ' k; j8 Y& Q* S2 q; B9 Z6 a* e+ c
51. }
    0 g0 z" l8 u! }
52. 
    
53. void W25Q128_Write_Enable(void) //写使能
    : W9 {3 H5 F: h/ H- P6 b6 Q
54. {
    ( e1 X+ m' p' X5 f- X
55.            W25Q128_CS(0);        
    
56.         W25Q128_ReadWriteByte(W25X_WriteEnable);
    
57.         W25Q128_CS(1);        
    ' E5 x8 l" ?0 ~- u8 b/ ^' p
58. }
    
59. 
    : T* S( f; n, y7 I% L. }
60. void W25Q128_Write_Disable(void) //禁止写入        
    
61. {
    % P1 _: Q$ {  A+ ^  B, K
62.            W25Q128_CS(0);        
    4 t- f$ _# f" z; J. ^
63.         W25Q128_ReadWriteByte(W25X_WriteDisable);
    8 g. s/ I* B/ ^3 Q/ b6 u& A( S
64.         W25Q128_CS(1);        
    % y4 G6 j! M4 K1 \
65. }
    
66. 
    
67. void W25Q128_Read(uint8_t* pBuffer,uint32_t ReadAddr,uint16_t NumByteToRead)   
    2 o3 M* S) r8 a' [
68. {                                                     
    
69.         W25Q128_CS(0);                                  //使能器件   
    ; v$ Y' B6 c7 q; K: Y" q; v
70.     W25Q128_ReadWriteByte(W25X_ReadData);      //发送读取命令  
    0 t1 v& ]/ M$ H" Y# N' n. p
71.     W25Q128_ReadWriteByte((uint8_t)((ReadAddr)>>16));   //发送24bit地址   
    5 g' t. c, _% x% k, q
72.     W25Q128_ReadWriteByte((uint8_t)((ReadAddr)>>8));   
    4 e/ y( }+ S# k: T
73.     W25Q128_ReadWriteByte((uint8_t)ReadAddr);   
    : k# x( }- @- q7 P& U
74.     for(uint16_t i=0;i<NumByteToRead;i++)
    
75.         {
    
76.        pBuffer<i>=W25Q128_ReadWriteByte(0XFF);    //循环读数  
    ( f: A. T6 M4 Y1 \1 O% J9 \( Z
77.     }
    
78.         W25Q128_CS(1);                                                  
    
79. }  
    9 {/ n1 f/ c  U1 G- Z- E( k+ W( W
80. 
    
81. 
    6 f$ t$ P) I; I/ p
82. void W25Q128_Write_Page(uint8_t* pBuffer,uint32_t WriteAddr,uint16_t NumByteToWrite)
    ' v9 {4 b  u( X5 G2 G$ m& C
83. {
    6 `) p) ]/ v; p
84. 
    
85.     W25Q128_Write_Enable();                  //SET WEL
    
86.         W25Q128_CS(0);                            //使能器件   
    % {4 K" O4 r, H
87.     W25Q128_ReadWriteByte(W25X_PageProgram);   //发送写页命令   
    
88. 
    ; s* d# S; X0 f* |
89.     W25Q128_ReadWriteByte((uint8_t)((WriteAddr)>>16)); //发送24bit地址   
    
90.     W25Q128_ReadWriteByte((uint8_t)((WriteAddr)>>8));   
      S3 l$ Y/ k& [4 q* K+ e# v; |
91.     W25Q128_ReadWriteByte((uint8_t)WriteAddr);   
    8 D* d+ O6 |, Q. I" P+ p* f
92.     for(uint16_t i=0;i<NumByteToWrite;i++)
    
93.         {
    , u. G3 Z* R9 |2 ^
94.                 W25Q128_ReadWriteByte(pBuffer<i>);//循环写数  
    
95.         }
    - J+ n% z5 p7 L1 `
96.         W25Q128_CS(1);                            //取消片选
    
97.         W25Q128_Wait_Busy();                                           //等待写入结束
    
98. }
    
99. 
    ' u! f) S4 [) ]& g
100. //无检验写SPI FLASH
     3 s+ J) ?8 }& a+ M1 \1 ]+ [! Q
101. //必须确保所写的地址范围内的数据全部为0XFF,否则在非0XFF处写入的数据将失败!
     
102. //具有自动换页功能
     " G3 {" j* m) d  x& Y, d
103. void W25Q128_Write_NoCheck(uint8_t* pBuffer,uint32_t WriteAddr,uint16_t NumByteToWrite)   
     
104. {                                          
     ( E" z3 r* A& @  o  G$ I3 C
105.         uint16_t pageremain=256-WriteAddr%256; //单页剩余的字节数                             
     ; B& L) m' q6 J
106.         if(NumByteToWrite<=pageremain)pageremain=NumByteToWrite;//不大于256个字节
     
107.         while(1)
     7 h8 r- ]% c; T/ c# S8 v
108.         {           
     
109.                 W25Q128_Write_Page(pBuffer,WriteAddr,pageremain);
     6 `4 H% c0 O) {
110.                 if(NumByteToWrite==pageremain)        break;//写入结束了
     
111.                  else
     
112.                 {
     5 {. Q6 g: z2 p& L! t& z" @+ @. v
113.                         pBuffer+=pageremain;
     
114.                         WriteAddr+=pageremain;        
     
115.                         NumByteToWrite-=pageremain;                          //减去已经写入了的字节数
     
116.                         if(NumByteToWrite>256)pageremain=256; //一次可以写入256个字节
     
117.                         else pageremain=NumByteToWrite;           //不够256个字节了
     9 B7 h8 S$ |5 A( [# r+ u
118.                 }
     $ v; g- k9 k  z% `! ^1 K
119.         }            
     
120. }
     - D' \2 ]: `3 s' c
121. 
     1 A1 s9 I6 C' b- v5 Q
122. //写SPI FLASH  
     
123. //在指定地址开始写入指定长度的数据
     # c1 ~" t! p7 f+ A1 G0 P) N5 r8 o
124. //该函数带擦除操作!
     % K' M; T% p# x. N- u
125. //pBuffer:数据存储区
     , V% C/ `+ ?+ q% F& |" \* h0 v
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)   
     8 b; Q/ j- f9 \" s
130. {
     
131.          uint16_t i;   
     
132.         uint8_t * W25Q128_BUF;         
     : l& w, y% W& x
133.     W25Q128_BUF=W25Q128_BUFFER;            
     
134.          uint32_t secpos = WriteAddr/4096;//扇区地址  
     
135.         uint16_t secoff = WriteAddr%4096;//在扇区内的偏移
     
136.         uint16_t secremain = 4096-secoff;//扇区剩余空间大小   
       W0 ]' h  u, l: m0 z
137. 
     3 w1 b2 X; o4 }# i  j* b, L
138.          if(NumByteToWrite<=secremain)                secremain=NumByteToWrite;//不大于4096个字节
     0 c; i3 D- P0 b  g0 W
139.         while(1)
     
140.         {        
     + H9 V8 B# ]- U( `1 O& B
141.                 W25Q128_Read(W25Q128_BUF,secpos*4096,4096);//读出整个扇区的内容
       U6 _$ y$ r3 M! l3 {
142.                 for(i=0;i<secremain;i++)//校验数据
     * a3 ]6 C7 G5 X" t6 g
143.                 {
     , [. i3 G3 r  \' b; z
144.                         if(W25Q128_BUF[secoff+i]!=0XFF)        break;//需要擦除            
     
145.                 }
     
146.                 if(i<secremain)//需要擦除
     + h# ?' i& R" m
147.                 {
     ) X; N0 ?2 |0 K2 Z0 N9 B
148.                         W25Q128_Erase_Sector(secpos*4096);//擦除这个扇区
     
149.                         for(i=0;i<secremain;i++)           //复制
     
150.                         {
     / F/ `# I* k! v  {( _( r4 m
151.                                 W25Q128_BUF[i+secoff]=pBuffer<i>;         
     
152.                         }
     
153.                         W25Q128_Write_NoCheck(W25Q128_BUF,secpos*4096,4096);//写入整个扇区  
     
154. 
     
155.                 }else W25Q128_Write_NoCheck(pBuffer,WriteAddr,secremain);//写已经擦除了的,直接写入扇区剩余区间.                                    
     
156.                 if(NumByteToWrite==secremain)        break;//写入结束了
     
157.                 else//写入未结束
     ( D5 W! _8 H: s1 x
158.                 {
     
159.                         secpos++;//扇区地址增1
     4 _. W  C5 Q8 E1 X9 @
160.                         secoff=0;//偏移位置为0         
     
161. 
     
162.                     pBuffer+=secremain;  //指针偏移
     
163.                         WriteAddr+=secremain;//写地址偏移           
     ( M4 [* t$ |  ~
164.                     NumByteToWrite-=secremain;                                //字节数递减
     
165.                         if(NumByteToWrite>4096)        secremain=4096;        //下一个扇区还是写不完
     
166.                         else         secremain=NumByteToWrite;                //下一个扇区可以写完了
     5 N; f1 t% c: A$ b: l! W
167.                 }         
     + y* I6 x( B  W8 H' T' K: C$ O
168.         }         
     5 n( {/ R' V1 D3 u' Y
169. }
     
170. 
     0 N$ t% u4 ]2 i+ r2 A7 b
171. //擦除一个扇区
     
172. //Dst_Addr:扇区地址 根据实际容量设置
     ( N9 A# `4 {! N( |8 \5 w& ?& y& M
173. //擦除一个扇区的最少时间:150ms
     
174. 
     ! J; U& g8 H1 P6 V
175. void W25Q128_Erase_Sector(uint32_t Dst_Addr)   
     4 t/ P* V# I! {# z9 l
176. {  
     ( k$ K) V* l7 Q& q5 C. y+ o, A% g
177.     W25Q128_Write_Enable();                  //SET WEL         
       W! ~2 L( x$ q. }2 `2 v+ ]- B/ b% T
178.     W25Q128_Wait_Busy();   
     ( T+ a1 @! Y5 Y9 P
179.           W25Q128_CS(0);                            //使能器件   
     7 K& p8 u: A  n# t7 J
180.     W25Q128_ReadWriteByte(W25X_SectorErase);   //发送扇区擦除指令
     & N* f5 x: B, K; O
181.     W25Q128_ReadWriteByte((uint8_t)((Dst_Addr)>>16));  //发送24bit地址   
     
182.     W25Q128_ReadWriteByte((uint8_t)((Dst_Addr)>>8));   
     
183.     W25Q128_ReadWriteByte((uint8_t)Dst_Addr);  
     * L- _& }, i7 O! T( w6 g2 g( W# H
184.         W25Q128_CS(1);                                    //取消片选                  
     : Z+ m: z5 s1 Q# I% |; h. |* V
185.     W25Q128_Wait_Busy();                                               //等待擦除完成
     . A4 j8 Q$ m6 W2 A% Y
186. }  
       p8 }  Q. w' W8 O& l  @
187. 
     
188. //擦除整个芯片                  
     ( p0 B8 X% h8 W& Q
189. //等待时间超长...
     
190. void W25Q128_Erase_Chip(void)   
     ( G& f9 P" r, u
191. {                                   
     
192.     W25Q128_Write_Enable();                  //SET WEL
     " q, M& p8 A, x. |8 ~
193.     W25Q128_Wait_Busy();   
     0 `9 w# Q0 O; f* x9 s" W
194.           W25Q128_CS(0);                           //使能器件   
     
195.     W25Q128_ReadWriteByte(W25X_ChipErase);   //发送片擦除命令  
     / v2 Y! e0 T9 \9 }  ~
196.         W25Q128_CS(1);                           //取消片选                  
     ) t2 h$ v2 ~" D( s
197.         W25Q128_Wait_Busy();                                              //等待芯片擦除结束
     
198. }
     
199. 
     0 w$ f+ G# t4 [& t
200. 
     . \! H2 v; u: G7 O' e. @  l+ u
201. //等待空闲
     * }) ?. t& ?' @
202. void W25Q128_Wait_Busy(void)   
     
203. {   
     
204.         while((W25Q128_ReadSR()&0x01)==0x01);   // 等待BUSY位清空
     
205. }  
     5 Y, G( V4 |' ]* t, q1 P
206. 
     ' `5 K1 m- d* K& C( Y: |
207. //进入掉电模式
     
208. void W25Q128_PowerDown(void)   
     
209. {
     8 w" I7 ?% b7 }  C; ^; v" p
210.           W25Q128_CS(0);                            //使能器件   
     
211.     W25Q128_ReadWriteByte(W25X_PowerDown);    //发送掉电命令  
     0 v! M2 e3 {/ J; ?; |
212.         W25Q128_CS(1);                            //取消片选                  
     ! E  l: \# m& _+ s
213. }   
     ; g6 ]+ H% ~# m, t) q4 t& C5 S
214. //掉电唤醒
     
215. void W25Q128_WAKEUP(void)   
     0 c, S! {1 y+ g/ d& I
216. {  
     
217.           W25Q128_CS(0);                                //使能器件   
     ( C0 H( K7 e- U7 X$ f
218.     W25Q128_ReadWriteByte(W25X_ReleasePowerDown);   
     
219.         W25Q128_CS(1);                                //取消片选                  
     9 o# \! R: \: t, s; ]
220. }   </i></i></i>

复制代码

1 {: l# e: ?$ i9 ?5 eW25Q128.h
& h, R8 Y$ P9 Z1 t2 n% [#ifndef __W25Q128_H
#define        __W25Q128_H
  E8 H: i9 D' Y
#include "stm32f10x.h"
- n& |0 R' h& P5 I# L/ U4 Q. q, T
//操作指令表
#define W25X_WriteEnable                           0x06         //写使能
% \. p+ m5 p( R6 C. |& d#define W25X_WriteDisable                           0x04         //写禁止
#define W25X_ReadStatusReg1                         0x05         //读状态寄存器1
#define W25X_ReadStatusReg2                         0x35         //读状态寄存器2
% Y+ p# ?6 Y. B4 O/ L#define W25X_ReadStatusReg3                         0x15         //读状态寄存器3
#define W25X_WriteStatusReg1                   0x01         //写状态寄存器1
#define W25X_WriteStatusReg2                   0x31         //写状态寄存器2
#define W25X_WriteStatusReg3                   0x11         //写状态寄存器3
1 l" E% }9 z& C#define W25X_ReadData                                0x03         //读数据
( d( V  o; k8 U1 _#define W25X_FastReadData                           0x0B         //快读
9 R* t; `  k) n! w: n8 P) n2 J" ?#define W25X_FastReadDual                           0x3B    //双输出快读
#define W25X_PageProgram                           0x02         //页编程
, G  j5 M# w+ k3 a: U8 z$ n) a#define W25X_BlockErase                                   0xD8         //块擦除（64K）
" k% X! n( Q0 h+ S#define W25X_SectorErase                           0x20    //扇区擦除（4K）
+ i$ o8 Y9 X4 e+ S" w2 D' ^" F#define W25X_ChipErase                                   0xC7    //芯片擦除
#define W25X_PowerDown                                   0xB9    //掉电
8 ]$ q1 i) |& G" @#define W25X_ReleasePowerDown                 0xAB    //释放掉电
4 J' N% J8 O8 q& H5 j7 F+ j#define W25X_DeviceID                            0xAB    //器件ID
#define W25X_ManufactDeviceID                 0x90    //制造商+设备ID
#define W25X_JedecDeviceID                         0x9F         //电子元件ID
1 r0 n# n( M/ R: K
0 Q1 |6 Z( G. g1 c
) j! j, }7 F4 m) O6 S1 _% u) f- K6 G#define W25Q128_CS(a) SPI_CS(a)        
; |! s; C' T+ g* B8 \

uint8_t W25Q128_ReadWriteByte(uint8_t TxData);//函数包装一下
% R) g+ B/ a. B( t! W# H5 X
uint16_t W25Q128_ReadID(void);//读取芯片ID

uint8_t W25Q128_ReadSR(void);//读取状态寄存器
void W25Q128_WriteSR(uint8_t sr);//写状态寄存器

4 Y) l5 m1 w4 {( a. K7 {void W25Q128_Write_Enable(void);//写使能
/ @- g' J# k$ [; O7 O) Zvoid W25Q128_Write_Disable(void);//禁止写入        

' Z3 i* M6 l" W; I  t! P. cvoid W25Q128_Read(uint8_t* pBuffer,uint32_t ReadAddr,uint16_t NumByteToRead); //读取数据
+ r' Z/ r% k& J) u+ W% o; h3 X+ Zvoid 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);//写入数据，带擦写功能
" K+ h9 U6 e, g
, s/ O# L, X$ J) ^4 Y3 C: Tvoid W25Q128_Erase_Sector(uint32_t Dst_Addr);//擦除扇区
void W25Q128_Erase_Chip(void);//擦除整个芯片        
' b# M+ o8 y$ a
void W25Q128_Wait_Busy(void);//等待空闲
void W25Q128_PowerDown(void); //进入掉电模式
* S2 x9 F8 B6 r7 cvoid W25Q128_WAKEUP(void);//掉电唤醒
: v+ i  ]0 x1 w$ `9 e5 K1 ^
; R% M  n6 h7 W9 C' z1 m5 M9 `# [#endif

+ y; H% v" M. k2 b4 r  |1
2
# J* {. {6 V3 G* S: r3
2 N5 L" K3 v! @' c; e, [# W6 b4
5
6
* g! Y7 Y8 k/ B& j2 D7
8
9
: Z* L3 H# I% N% L) M. s2 N1 B2 m10
11
+ S* d# K7 X" J7 ~( o12
  U9 j6 L; P0 {8 i+ G# m13
14
$ Q' k* m7 W6 @) G- S/ n* |15
16
" Y/ C/ p9 L( n- m( @1 u! m17
18
. j$ S5 d' T2 D# B& w% i19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
" g% @, ?* ~& ]$ M- R$ C34
35
9 `$ w( E9 z( C3 |  Z' }! U36
3 H+ D- s/ u$ H1 S% H/ X* {37
38
39
40
41
42
( R: a2 i& a) j% E5 M3 H43
( e- G( W: \' ^# R5 j3 j5 O- u  k: C44
% P6 |" Z( X: |% v45
46
47
  U! _% p0 \: |6 ?48
" x: {9 L" ]; ?49
50
51
# _, y& g1 Z+ o# |52
$ _! M" F' p. B53
54
- B6 X; T) j+ i  R! o$ z, ~main.c
. B( W- s. w3 ?/ m- q* w8 |/ \#include <stdio.h>
#include "Uart1.h"
$ r, Q1 X8 A) f: ]#include "delay.h"
% Q7 P  l8 Z5 j: K#include "SPI.h"
#include "W25Q128.h"
( f9 z$ R& h) a2 K( I  v
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};
7 B) |+ b& U  E! \uint8_t Read_data[100];
2 w8 I( S1 a+ \
int main (void)
$ j9 s" |; j1 |4 n7 p  L{
& e! i) E( s7 s* L        Uart1_init();
        SPI1_Init();
5 }  r( Z& _4 j4 E& r2 f        
        W25Q128_ID=W25Q128_ReadID();
        W25Q128_Write_Page(Write_data,0x01,20);
6 e  `$ c+ B5 H! ]' r) J        
        while(1)
5 ]% S) f& S$ @$ h        {
                W25Q128_Read(Read_data,0x00,100);
                for(int i=0;i<100;i++)
% I% L6 e3 l: B) u' ~                {
: j  ^3 Z$ j6 f0 x                        printf(" 0x%X ",Read_data);
                }
4 v; h% @3 a4 m; M                printf("\nW25Q128_ID=0x%X\n",W25Q128_ID);
                delay_ms(500);
5 o2 y: R. e- d1 b. ]        }
2 u7 Y% W6 R5 m9 E* `}

1
8 W8 N) v) V/ J2
0 U0 m4 K1 X- V5 k& \3
! Z# v! R0 Q' Q' E4
$ G2 O5 D0 s- w9 |- D( A# J5
) w0 o+ y8 S/ N; Z6 h; V% `2 x! n6
4 E& }1 E4 l! U* ~! Y7
8
% L* t) }" ]8 n* Q& J9
! |' I. b) V/ y# n10
11
+ b: J$ Y8 c: ~3 q$ ?12
) R! j2 S3 C( ~! K# D: {13
/ ~( a% W7 c* p5 z9 _14
15
+ `7 g5 W- d& b7 h1 R; w/ h16
17
3 \# A  X) j* ~, {18
19
8 l5 ]6 P& ?0 R  R+ d1 j1 E  `20
& C4 @7 j, j9 u2 a1 e$ }" U+ N% J21
7 w5 E8 A. W+ W/ H* [' `' v; u9 s. H22
% y' J& r! |' F23
7 m* T* h: K+ S& w2 [24
; A/ t$ D1 S; w25
$ M# ?3 }8 C; n0 X3 I4 c2 z26
% z- R  H7 V2 }6 m/ q: f27
5 w  G: Y; I) x: W+ u8 Y28
) a+ o1 Z6 W% \$ t. w* Y" n) w29
实验结果
  a$ S9 z3 ]" l6 ?9 V" |6 H6 K$ j
————————————————
版权声明：根号五