一、实验前期准备
本次实验的 MCU 是 STM32F103C8T6 芯片，通过 SPI 通信实现 W25Q128 的读写操作。
  L8 g: ~3 G- H+ B7 N2 m( R* H
! C% U; G/ a2 i) g0 b1. 原理图


8 c6 K" ^2 K' a' p( D* L
& D4 i5 B3 A1 u, }2. 引脚连接
" z) t' U% b) I8 ]% @  \% x/ A0 M

7 _. f& h6 S0 u
二、SPI 底层驱动
" T4 E" D) d, T& pSPI.c
. j5 ?' G, b1 ^, g6 t

1. #include "SPI.h"
   
2. 
     |, s' x: C$ Y0 ~5 p0 ?
3. /*
   * a  O; _# K; P/ e/ D: p+ M! Z( p; ^
4.         SPI引脚初始化配置
   
5.         **PA4------CS
   * R; a2 }" {$ U) X2 R8 S; w
6.         **PA5------SCLK
   
7.         **PA6------MISO
   ' ?: |( ^; P/ G- _, U6 {% M
8.         **PA7------MOSI
   
9. */
   
10. 
    
11. static void SPI1_GPIO_Config(void)        
    
12. {
    
13.         GPIO_InitTypeDef GPIO_InitStructure;
    
14.         
    
15.         RCC_APB2PeriphClockCmd(        RCC_APB2Periph_GPIOA, ENABLE );//PORTA时钟使能
    * W, w6 [0 O% X: }& E) G
16. 
    ' c! B% d7 t% F
17.         GPIO_InitStructure.GPIO_Pin = GPIO_Pin_5| GPIO_Pin_6|GPIO_Pin_7;
    , W/ I7 V7 }5 }+ j
18.         GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;  //PA5/6/7复用推挽输出
    , Z' V# G) Y2 I
19.         GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
    ) Q* \4 c/ h% z1 H7 ?9 k4 R1 u
20.         GPIO_Init(GPIOA, &GPIO_InitStructure);                                                //初始化GPIOA
    
21.         
    
22.         GPIO_InitStructure.GPIO_Pin = GPIO_Pin_4;
    
23.         GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;  //PA4推挽输出
    ) X3 M( u$ X, e/ u
24.         GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
    
25.         GPIO_Init(GPIOA, &GPIO_InitStructure);                                                //初始化GPIOA
    
26. 
    / o- ?+ `  [# M7 W2 m2 R
27.         GPIO_SetBits(GPIOA,GPIO_Pin_4|GPIO_Pin_5|GPIO_Pin_6|GPIO_Pin_7); //初始上拉输出
    
28. 
    ' n3 z/ ^+ A( M/ h$ ?' D
29. }
    
30. 
    
31. //SPI1初始化函数
    4 k3 `$ _: ]) @
32. void SPI1_Init(void)
    
33. {
    
34.         SPI1_GPIO_Config();//SPI引脚初始化配置        
    " _) t4 q% `6 Z, G1 }: \* H" Q
35. 
    
36.         SPI_InitTypeDef  SPI_InitStructure;
    # X, f1 B$ p6 Q, a
37.         
    
38.         RCC_APB2PeriphClockCmd(        RCC_APB2Periph_SPI1,  ENABLE );//SPI1时钟使能         
    
39.         
    
40.         SPI_InitStructure.SPI_Direction = SPI_Direction_2Lines_FullDuplex;          //设置SPI单向或者双向的数据模式:SPI设置为双线双向全双工
    8 F$ {7 C6 c- Z8 O' ?  D( k
41.         SPI_InitStructure.SPI_Mode = SPI_Mode_Master;                                                                                                        //设置SPI工作模式:设置为主SPI
    0 D* s9 ^; r( `
42.         SPI_InitStructure.SPI_DataSize = SPI_DataSize_8b;                                                                                        //设置SPI的数据大小:SPI发送接收8位帧结构
    
43.         SPI_InitStructure.SPI_CPOL = SPI_CPOL_High;                                                                                                                //串行同步时钟的空闲状态为高电平
    + |  [5 [: e3 x+ s% u- {
44.         SPI_InitStructure.SPI_CPHA = SPI_CPHA_2Edge;                                                                                                        //串行同步时钟的第二个跳变沿（上升或下降）数据被采样
    
45.         SPI_InitStructure.SPI_NSS = SPI_NSS_Soft;                                                                                                                        //NSS信号由硬件（NSS管脚）还是软件（使用SSI位）管理:内部NSS信号有SSI位控制
    # K3 n% \, b+ J! Q0 o5 X
46.         SPI_InitStructure.SPI_BaudRatePrescaler = SPI_BaudRatePrescaler_256;        //定义波特率预分频的值:波特率预分频值为256
    
47.         SPI_InitStructure.SPI_FirstBit = SPI_FirstBit_MSB;                                                                                //指定数据传输从MSB位还是LSB位开始:数据传输从MSB位开始
    ' w0 G5 o# J# n! J5 ^( H
48.   SPI_InitStructure.SPI_CRCPolynomial = 7;        //CRC值计算的多项式
    
49.         SPI_Init(SPI1, &SPI_InitStructure);                          //根据SPI_InitStruct中指定的参数初始化外设SPIx寄存器
    9 m6 I' j5 ^- r/ C3 f# z' X
50.         
    ( p/ h  z" v1 Z, h
51.         SPI_Cmd(SPI1, ENABLE); //使能SPI外设
    
52.         SPI1_ReadWriteByte(0xFF);//启动传输
    
53. }
    
54. 
    
55. /*
    
56.         SPI的读写操作
    8 P/ a$ a/ i3 e5 w5 |
57.         **TxData:要写入的字节
    
58.         **返回值:读取到的字节
    ) B% }# z) J) ~: c! L3 Z- O
59. */
    $ q; @  D- J7 k: q. {5 g
60. uint8_t SPI1_ReadWriteByte(uint8_t TxData)
    # i* l* {; o4 T/ {! s
61. {                                 
    / P/ g' I* K# g! {8 r
62.         while (SPI_I2S_GetFlagStatus(SPI1, SPI_I2S_FLAG_TXE) == RESET) //检查指定的SPI标志位设置与否:发送缓存空标志位
    
63.         {
    
64.                 //等待发送完成
    
65.         }                          
    ; ?( O5 ?0 g+ N8 s2 ^$ V4 w
66.         SPI_I2S_SendData(SPI1, TxData); //通过外设SPIx发送一个数据
    1 }) t4 P0 g9 _; ^: J* H- |
67.         while (SPI_I2S_GetFlagStatus(SPI1, SPI_I2S_FLAG_RXNE) == RESET) //检查指定的SPI标志位设置与否:接受缓存非空标志位
    
68.         {
    9 @, I: {' @0 b/ x( L# T9 B
69.                 //等待接收完成
    
70.         }                                                              
    
71.         return SPI_I2S_ReceiveData(SPI1); //返回通过SPIx最近接收的数据                                            
      l# b9 \7 T2 W8 _
72. }

复制代码

SPI.h
8 S- p! U: [# O9 o

1. #ifndef __SPI_H
   
2. #define        __SPI_H
   & A" ^2 W! S2 T7 K* G& g/ X
3. 
   $ D9 e0 ~1 Z  n0 |% r$ L
4. #include "stm32f10x.h"
   
5. 
   6 o8 e0 i+ N, I& T
6. #define SPI_CS(a)                if (a)        \
   
7.                                                 GPIO_SetBits(GPIOA,GPIO_Pin_4);\
   
8.                                                 else                \
   
9.                                             GPIO_ResetBits(GPIOA,GPIO_Pin_4)
   ( L1 h2 `3 x' Z6 _. V8 p
10. 
    
11. void SPI1_Init(void);//SPI1初始化函数
    ! N0 p( h& {3 y/ q! I5 y
12. uint8_t SPI1_ReadWriteByte(uint8_t TxData);//SPI1读写函数
    
13. 
    , ^* c# x: V" G* ~. b
14. #endif

复制代码

4 j$ \" A# s4 \. w0 b) E) y: z三、读取 W25Q128 设备 ID
本次实验是：读取 W25Q128 设备 ID，然后通过串口1打印出来。
1 `% y5 D7 W0 q; ]4 F% _5 [: U通过简单的实验来调试，有利于发现问题。
$ f  i0 G! _5 d7 `# C, f通过W25Q128的数据手册可知其设备ID如下图所示：
9 M1 X9 j$ [+ }1 V# b
# p' E/ w! R% S8 v1 g2 [' e
' C) Y, I& F. l7 I
& n$ z$ c: n8 \5 u5 n$ F  cW25Q128.c

1. #include "W25Q128.h"
   4 f/ p& f$ G$ z6 o5 H  k
2. #include "SPI.h"
   
3. 
   
4. 
   
5. uint8_t W25Q128_ReadWriteByte(uint8_t TxData)//函数包装一下
   ' D: Z4 m+ y" D
6. {     
   ) g+ i5 U+ |$ @; Z7 y! e
7.            return SPI1_ReadWriteByte(TxData);                 
   
8. }
   + p' t# w) v- n0 o* m+ P" j
9. 
   / O% z* M8 M8 H4 G: [6 Y. m
10. uint16_t W25Q128_ReadID(void)//读取芯片ID
    # s2 x' Q8 d, [/ s) k$ j* R) [
11. {
    
12.         uint16_t Temp = 0;         
    , F# p) h. S* Y" N- p( ~0 ?" D& p! H
13.         W25Q128_CS(0);                                    
    
14.         W25Q128_ReadWriteByte(W25X_ManufactDeviceID);//发送读取ID命令            
    2 x: @- S/ T$ _
15.         W25Q128_ReadWriteByte(0x00);            
    
16.         W25Q128_ReadWriteByte(0x00);            
    
17.         W25Q128_ReadWriteByte(0x00);                                    
    ! c. `6 S! ~3 ^% j: F
18.         Temp|=W25Q128_ReadWriteByte(0xFF)<<8;  
    
19.         Temp|=W25Q128_ReadWriteByte(0xFF);         
      n; A/ e) Z; i; R- p
20.         W25Q128_CS(1);                                    
    5 Y9 s2 @& T4 ^& i7 t0 Y
21.         return Temp;
    
22. }

复制代码

W25Q128.h

1. #ifndef __W25Q128_H
   ) r! O8 c6 X5 k* ^$ _0 i
2. #define        __W25Q128_H
   
3. 
   0 D0 O' t: L7 V
4. #include "stm32f10x.h"
   
5. 
   ! W: M, a! C$ E! E& i
6. //操作指令表
   
7. #define W25X_ManufactDeviceID         0x90       //制造商+设备ID
   7 H% `) c6 a/ E5 S% O. ~
8. 
     ]: z: k/ D$ G- F% z0 U
9. #define W25Q128_CS(a) SPI_CS(a)        
   9 B2 l2 t  w% O( K
10. 
    
11. uint8_t W25Q128_ReadWriteByte(uint8_t TxData);//函数包装一下
    
12. uint16_t W25Q128_ReadID(void);//读取芯片ID
    / e  ]$ R" R! C" D" d) r
13. 
    
14. #endif

复制代码

main.c
0 P( L# q& |0 v% e. I

1. #include <stdio.h>
   
2. #include "Uart1.h"
   
3. #include "delay.h"
   3 S( ^  k4 }' _0 [" x! D" d5 B/ {8 b
4. #include "SPI.h"
   7 U9 r7 M6 p7 H( _& k6 \$ t3 j: _2 E
5. #include "W25Q128.h"
   . l' n7 ^$ M; H+ R
6. 
   
7. uint16_t W25Q128_ID=0;
   
8. 
   
9. int main (void)
   / s! Q7 s7 k0 f6 [6 H7 o
10. {
    
11.         Uart1_init();
    
12.         SPI1_Init();
    + w8 |2 ]. |- A3 Q
13.         
    ! c. }" r/ \0 p% S) w9 {! T8 S" I# ]
14.         W25Q128_ID = W25Q128_ReadID();
    ) c- ^+ u! s6 \, |( {
15.         while(1)
    
16.         {
    
17.                 printf("\nW25Q128_ID=0x%X\n",W25Q128_ID);
    9 {+ O* @0 X' P9 g! W0 L$ e& H$ z; c
18.                 delay_ms(500);
    
19.         }
    
20. }

复制代码

2 r$ p4 d  U6 y! P$ l5 F. k/ t实验结果
& q  x# ], T9 ]& W4 n5 Y3 X

接收到 W25Q128 设备ID 为0xEF17
4 _* I+ c, I0 o+ h  m
四、读写 W25Q128 外部 Flash
1 \3 w1 r5 X+ _4 y/ J- uW25Q128.c

1. #include "W25Q128.h"
   " x1 u- k  t1 w, D
2. #include "SPI.h"
   
3. 
   
4. 
   7 f1 V. l7 w" H9 p: r
5. uint8_t W25Q128_ReadWriteByte(uint8_t TxData)//函数包装一下
   
6. {     
   - P2 Y! }1 E' ^, ^1 f
7.          return SPI1_ReadWriteByte(TxData);                 
   6 G. E1 d. P( C9 h
8. }
   - Y5 J7 Y3 e2 j5 E
9. 
   
10. 
    6 C6 J0 o. H+ D8 y% F6 }
11. uint16_t W25Q128_ReadID(void)//读取芯片ID
    
12. {
    
13.         uint16_t Temp = 0;         
    
14.         W25Q128_CS(0);                                    
    1 p, o+ _' m4 W* K1 Z
15.         W25Q128_ReadWriteByte(W25X_ManufactDeviceID);//发送读取ID命令            
    
16.         W25Q128_ReadWriteByte(0x00);            
    
17.         W25Q128_ReadWriteByte(0x00);            
    
18.         W25Q128_ReadWriteByte(0x00);                                    
    % [9 c3 b! k+ ^5 T, X- }
19.         Temp|=W25Q128_ReadWriteByte(0xFF)<<8;  
    , x3 d4 g8 H/ [0 h: y8 F+ D
20.         Temp|=W25Q128_ReadWriteByte(0xFF);         
    - N+ k# J8 P: P9 f
21.         W25Q128_CS(1);                                    
    
22.         return Temp;
    
23. }
    $ T1 z( h, U; u) H
24. 
    
25. //读取W25Q128的状态寄存器
    ( @" b8 k4 d2 S0 N
26. //BIT7  6   5   4   3   2   1   0
    / r, }8 L0 W1 V! x5 z: h! v1 t
27. //SPR   RV  TB BP2 BP1 BP0 WEL BUSY
    
28. //SPR:默认0,状态寄存器保护位,配合WP使用
    # l, s- e  z) ~& ~! c% K4 f
29. //TB,BP2,BP1,BP0:FLASH区域写保护设置
    
30. //WEL:写使能锁定
    + U# L1 B' _0 P/ U) R4 N7 Z3 O2 \
31. //BUSY:忙标记位(1,忙;0,空闲)
    
32. //默认:0x00
    " L! b2 f1 j! U: l
33. uint8_t W25Q128_ReadSR(void)//读取状态寄存器
    
34. {
    
35.     uint8_t byte=0;
    
36.     W25Q128_CS(0);                               //使能器件
    ! M& J0 v  a6 }# X
37.     W25Q128_ReadWriteByte(W25X_ReadStatusReg1);  //发送读取状态寄存器命令
    ; K* x; W; b& y' p* D
38.     byte=W25Q128_ReadWriteByte(0Xff);            //读取一个字节
    
39.     W25Q128_CS(1);                               //取消片选
    
40.     return byte;
    
41. }
    
42. 
    
43. //写W25Q128状态寄存器
    
44. //只有SPR,TB,BP2,BP1,BP0(bit 7,5,4,3,2)可以写!!!
    
45. void W25Q128_WriteSR(uint8_t sr)//写状态寄存器
    
46. {
    
47.     W25Q128_CS(0);                                           //使能器件
    ) @% o& ~( a8 P+ {( j9 Y$ q
48.     W25Q128_ReadWriteByte(W25X_WriteStatusReg1);        //发送写取状态寄存器命令
    
49.     W25Q128_ReadWriteByte(sr);                               //写入一个字节
    ! S6 ]. D% |1 i' [
50.     W25Q128_CS(1);                                            //取消片选
    
51. }
    
52. 
    
53. void W25Q128_Write_Enable(void) //写使能
    
54. {
    
55.            W25Q128_CS(0);        
    
56.         W25Q128_ReadWriteByte(W25X_WriteEnable);
    
57.         W25Q128_CS(1);        
    . W5 T- h* g% o& ~  P1 X
58. }
    . O3 x# D* \9 F4 S  t
59. 
    
60. void W25Q128_Write_Disable(void) //禁止写入        
    
61. {
    ; M1 I2 s9 w- L8 B3 u# x; V1 c7 S' B' a
62.            W25Q128_CS(0);        
    , J. d; [) f" D" b' V
63.         W25Q128_ReadWriteByte(W25X_WriteDisable);
    / T0 ^7 x0 r& }/ q% S
64.         W25Q128_CS(1);        
    
65. }
    ( C/ f/ z9 V; U
66. 
    
67. void W25Q128_Read(uint8_t* pBuffer,uint32_t ReadAddr,uint16_t NumByteToRead)   
    
68. {                                                     
    5 L9 u: D1 n0 w! S# w, T8 g
69.         W25Q128_CS(0);                                  //使能器件   
    , G) [' h( ~; y- m. p9 u
70.     W25Q128_ReadWriteByte(W25X_ReadData);      //发送读取命令  
    
71.     W25Q128_ReadWriteByte((uint8_t)((ReadAddr)>>16));   //发送24bit地址   
    / Q3 u  U0 k, {
72.     W25Q128_ReadWriteByte((uint8_t)((ReadAddr)>>8));   
    
73.     W25Q128_ReadWriteByte((uint8_t)ReadAddr);   
    ( H8 B  Z( K8 G; _; n9 y4 }
74.     for(uint16_t i=0;i<NumByteToRead;i++)
    
75.         {
    
76.        pBuffer<i>=W25Q128_ReadWriteByte(0XFF);    //循环读数  
    
77.     }
    
78.         W25Q128_CS(1);                                                  
    
79. }  
    & y  p8 W; ?  i5 d+ G; T
80. 
    
81. 
    6 k% N% }1 I4 Z) L; \- h
82. void W25Q128_Write_Page(uint8_t* pBuffer,uint32_t WriteAddr,uint16_t NumByteToWrite)
    
83. {
    * R9 s' z( u  W- V. b6 j2 c- D
84. 
    
85.     W25Q128_Write_Enable();                  //SET WEL
    
86.         W25Q128_CS(0);                            //使能器件   
    ( ^* ~* @/ [7 s' Q! G
87.     W25Q128_ReadWriteByte(W25X_PageProgram);   //发送写页命令   
    * M/ V, t0 C* ]/ t! d: V8 [
88. 
    3 a! P7 ]- B% z/ R. \7 Z7 T9 q
89.     W25Q128_ReadWriteByte((uint8_t)((WriteAddr)>>16)); //发送24bit地址   
    
90.     W25Q128_ReadWriteByte((uint8_t)((WriteAddr)>>8));   
    
91.     W25Q128_ReadWriteByte((uint8_t)WriteAddr);   
    : W) e$ [& y  M
92.     for(uint16_t i=0;i<NumByteToWrite;i++)
    
93.         {
    ) C9 e8 Z9 H  M6 e$ c+ J
94.                 W25Q128_ReadWriteByte(pBuffer<i>);//循环写数  
    
95.         }
    
96.         W25Q128_CS(1);                            //取消片选
    
97.         W25Q128_Wait_Busy();                                           //等待写入结束
    . m( O, O& Y7 S6 R& ?$ ^, J
98. }
    
99. 
    ; E+ |7 P" }* M$ _; t: V/ J1 c+ ~+ o
100. //无检验写SPI FLASH
     9 X& E2 b5 m3 t: Y! ~) I9 p
101. //必须确保所写的地址范围内的数据全部为0XFF,否则在非0XFF处写入的数据将失败!
     3 P" |5 e" ?. V5 F
102. //具有自动换页功能
     1 r4 I% H% A! ^- B2 W
103. void W25Q128_Write_NoCheck(uint8_t* pBuffer,uint32_t WriteAddr,uint16_t NumByteToWrite)   
     
104. {                                          
     
105.         uint16_t pageremain=256-WriteAddr%256; //单页剩余的字节数                             
     9 g6 d9 I6 a* P2 n" x
106.         if(NumByteToWrite<=pageremain)pageremain=NumByteToWrite;//不大于256个字节
     
107.         while(1)
     5 n" b( q; [  u3 n+ F) r
108.         {           
     
109.                 W25Q128_Write_Page(pBuffer,WriteAddr,pageremain);
     * S9 h1 C8 }9 v3 ]) h
110.                 if(NumByteToWrite==pageremain)        break;//写入结束了
     
111.                  else
     ' q! O) D; q$ B
112.                 {
     : l- g) |* Z8 ^# H# D; l
113.                         pBuffer+=pageremain;
     3 y1 \. F6 V) V: A; O' G5 w( D
114.                         WriteAddr+=pageremain;        
     , T5 }! m  @" @" Z5 |( S1 G& t# x
115.                         NumByteToWrite-=pageremain;                          //减去已经写入了的字节数
     , r8 n) d8 j6 w1 ~% ~0 A* |/ |0 J/ f
116.                         if(NumByteToWrite>256)pageremain=256; //一次可以写入256个字节
     - ]. ?2 L% p' v$ P, r9 r8 m
117.                         else pageremain=NumByteToWrite;           //不够256个字节了
       c& o2 |, L* x& {# Z
118.                 }
     
119.         }            
     
120. }
     + m- s7 \* p% u8 z7 G! @) l8 Y* P
121. 
     
122. //写SPI FLASH  
     7 C7 G3 K, M1 G* I# t* R4 @
123. //在指定地址开始写入指定长度的数据
     4 b3 ]  g$ d+ X% J: L9 T
124. //该函数带擦除操作!
     & R5 L8 Y! q6 g; ?
125. //pBuffer:数据存储区
     
126. //WriteAddr:开始写入的地址(24bit)                                                
     # d  H6 }1 V( n! W! Z4 u
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;   
     6 \& o# V# R1 U9 w6 U: t- C  V
132.         uint8_t * W25Q128_BUF;         
     
133.     W25Q128_BUF=W25Q128_BUFFER;            
     
134.          uint32_t secpos = WriteAddr/4096;//扇区地址  
     * x* v% V" [6 d. K$ z! s
135.         uint16_t secoff = WriteAddr%4096;//在扇区内的偏移
     - @7 I3 w7 b; A2 o& j
136.         uint16_t secremain = 4096-secoff;//扇区剩余空间大小   
     4 J, g6 L  l, d* E$ u* E
137. 
     - |) A& a: K' V) \) f8 L
138.          if(NumByteToWrite<=secremain)                secremain=NumByteToWrite;//不大于4096个字节
     
139.         while(1)
     
140.         {        
     . T- c% d' I# f4 E4 X' ]
141.                 W25Q128_Read(W25Q128_BUF,secpos*4096,4096);//读出整个扇区的内容
     
142.                 for(i=0;i<secremain;i++)//校验数据
     # {/ {( r( v  ~, y
143.                 {
     
144.                         if(W25Q128_BUF[secoff+i]!=0XFF)        break;//需要擦除            
     
145.                 }
     
146.                 if(i<secremain)//需要擦除
     0 H- M! {( p( S) T4 [
147.                 {
     
148.                         W25Q128_Erase_Sector(secpos*4096);//擦除这个扇区
     
149.                         for(i=0;i<secremain;i++)           //复制
     1 L- {( `5 p. ?7 _
150.                         {
     
151.                                 W25Q128_BUF[i+secoff]=pBuffer<i>;         
     
152.                         }
     
153.                         W25Q128_Write_NoCheck(W25Q128_BUF,secpos*4096,4096);//写入整个扇区  
     
154. 
     # }- `1 I$ R5 g$ {- u
155.                 }else W25Q128_Write_NoCheck(pBuffer,WriteAddr,secremain);//写已经擦除了的,直接写入扇区剩余区间.                                    
     
156.                 if(NumByteToWrite==secremain)        break;//写入结束了
     1 J( u; m0 K6 W, b9 Z3 A4 ^( L
157.                 else//写入未结束
     
158.                 {
     
159.                         secpos++;//扇区地址增1
     - R2 {  ]( P: D" i; Y& Q
160.                         secoff=0;//偏移位置为0         
       x+ j0 I; ?* V
161. 
     - P; j. G& u4 L* g0 s+ k  R
162.                     pBuffer+=secremain;  //指针偏移
     3 K: r. P/ [+ `9 b
163.                         WriteAddr+=secremain;//写地址偏移           
     
164.                     NumByteToWrite-=secremain;                                //字节数递减
     
165.                         if(NumByteToWrite>4096)        secremain=4096;        //下一个扇区还是写不完
     5 |/ j6 F: B9 y  {# `
166.                         else         secremain=NumByteToWrite;                //下一个扇区可以写完了
     
167.                 }         
     
168.         }         
     
169. }
     
170. 
     # K7 s  n1 O8 K7 t8 q, ?
171. //擦除一个扇区
     
172. //Dst_Addr:扇区地址 根据实际容量设置
     . m5 ?2 W+ a/ u8 R' w/ L# r9 x2 M
173. //擦除一个扇区的最少时间:150ms
     
174. 
     
175. void W25Q128_Erase_Sector(uint32_t Dst_Addr)   
     
176. {  
     " f7 ^* h# N3 ^
177.     W25Q128_Write_Enable();                  //SET WEL         
     ( D3 z, d: z0 M4 u
178.     W25Q128_Wait_Busy();   
     
179.           W25Q128_CS(0);                            //使能器件   
     : f) }% n/ E  U& F$ l
180.     W25Q128_ReadWriteByte(W25X_SectorErase);   //发送扇区擦除指令
     9 N& x& m' x7 H; L5 c% s$ l4 u  a
181.     W25Q128_ReadWriteByte((uint8_t)((Dst_Addr)>>16));  //发送24bit地址   
     
182.     W25Q128_ReadWriteByte((uint8_t)((Dst_Addr)>>8));   
     . \3 r" [1 b4 F+ H( d/ t# Z
183.     W25Q128_ReadWriteByte((uint8_t)Dst_Addr);  
     - ]+ o0 V6 K3 Y2 p
184.         W25Q128_CS(1);                                    //取消片选                  
     & N! i: s! B9 w+ b; Z$ o6 Z
185.     W25Q128_Wait_Busy();                                               //等待擦除完成
     
186. }  
     & Y' h0 g1 {2 a) V9 [# \* g9 `
187. 
     7 Q! a% g" R- `% T! W
188. //擦除整个芯片                  
     
189. //等待时间超长...
     
190. void W25Q128_Erase_Chip(void)   
     
191. {                                   
     
192.     W25Q128_Write_Enable();                  //SET WEL
     7 A0 m4 p8 Z5 S& K# S/ y+ ^8 {! x
193.     W25Q128_Wait_Busy();   
     
194.           W25Q128_CS(0);                           //使能器件   
     * S6 j1 k+ V0 u6 y& i, C
195.     W25Q128_ReadWriteByte(W25X_ChipErase);   //发送片擦除命令  
     1 u/ ~( b3 r+ j
196.         W25Q128_CS(1);                           //取消片选                  
     
197.         W25Q128_Wait_Busy();                                              //等待芯片擦除结束
     7 y/ \2 o  c6 Q/ L; g+ _
198. }
     # O3 k" [9 Y, c/ |6 u& ?
199. 
     
200. 
     7 L" t, `3 E" C! U6 v7 ?3 {
201. //等待空闲
     
202. void W25Q128_Wait_Busy(void)   
     
203. {   
     
204.         while((W25Q128_ReadSR()&0x01)==0x01);   // 等待BUSY位清空
     
205. }  
     , q$ K' u' r: \) l8 \$ v9 N, }
206. 
     4 T) B/ I! L0 o$ N# n
207. //进入掉电模式
     
208. void W25Q128_PowerDown(void)   
     
209. {
     : c6 X, `7 G' J6 o0 A
210.           W25Q128_CS(0);                            //使能器件   
     
211.     W25Q128_ReadWriteByte(W25X_PowerDown);    //发送掉电命令  
     4 f; f$ K7 C- e8 e! p. a; ?% \; N. D) d
212.         W25Q128_CS(1);                            //取消片选                  
     + W/ [9 b$ k9 g+ H+ ^6 C# J0 @
213. }   
     
214. //掉电唤醒
     
215. void W25Q128_WAKEUP(void)   
     
216. {  
     
217.           W25Q128_CS(0);                                //使能器件   
     
218.     W25Q128_ReadWriteByte(W25X_ReleasePowerDown);   
     ' j1 Q, S9 Q. o+ `
219.         W25Q128_CS(1);                                //取消片选                  
     . N5 Z; ^. f; l! b) x" U
220. }   </i></i></i>

复制代码

W25Q128.h
#ifndef __W25Q128_H
% K3 @9 Q: l' ]% e#define        __W25Q128_H

#include "stm32f10x.h"
+ L9 W4 \9 _- e( i6 x' p  B
//操作指令表
#define W25X_WriteEnable                           0x06         //写使能
#define W25X_WriteDisable                           0x04         //写禁止
9 m0 M2 {: e" V* I2 }5 F: D#define W25X_ReadStatusReg1                         0x05         //读状态寄存器1
#define W25X_ReadStatusReg2                         0x35         //读状态寄存器2
3 L2 W1 n! t) b/ n% r#define W25X_ReadStatusReg3                         0x15         //读状态寄存器3
#define W25X_WriteStatusReg1                   0x01         //写状态寄存器1
#define W25X_WriteStatusReg2                   0x31         //写状态寄存器2
5 t1 U' k. T$ P#define W25X_WriteStatusReg3                   0x11         //写状态寄存器3
+ n6 i" Y4 f& q6 B9 X: h#define W25X_ReadData                                0x03         //读数据
' i8 V; Z; w  T* |#define W25X_FastReadData                           0x0B         //快读
4 O8 ?% z- i) |& Q, c% z& x; g- f#define W25X_FastReadDual                           0x3B    //双输出快读
#define W25X_PageProgram                           0x02         //页编程
7 q7 N5 ~! J0 g2 B2 N#define W25X_BlockErase                                   0xD8         //块擦除（64K）
#define W25X_SectorErase                           0x20    //扇区擦除（4K）
#define W25X_ChipErase                                   0xC7    //芯片擦除
#define W25X_PowerDown                                   0xB9    //掉电
/ E( k7 m1 D: M, h#define W25X_ReleasePowerDown                 0xAB    //释放掉电
#define W25X_DeviceID                            0xAB    //器件ID
7 e: E1 L2 O- T0 c# c- v#define W25X_ManufactDeviceID                 0x90    //制造商+设备ID
#define W25X_JedecDeviceID                         0x9F         //电子元件ID


$ K0 G2 r! @6 K8 J! X8 u6 a- w0 W#define W25Q128_CS(a) SPI_CS(a)        

7 [2 t% V2 N+ d( G2 M" N! D) y) q# d
% Y- X0 |$ \" g$ L" B8 Kuint8_t W25Q128_ReadWriteByte(uint8_t TxData);//函数包装一下

* V$ d9 y6 m' k: ?$ z2 e/ S) w9 a# tuint16_t W25Q128_ReadID(void);//读取芯片ID
2 o' U# {! A/ N4 }$ o+ K0 Z
1 e2 D2 m( f4 x( q/ Puint8_t W25Q128_ReadSR(void);//读取状态寄存器
void W25Q128_WriteSR(uint8_t sr);//写状态寄存器
1 j5 F3 |1 O( c+ X+ {* z
% ]- C1 e0 g. X5 i4 f2 Wvoid W25Q128_Write_Enable(void);//写使能
5 j/ r# v  u8 N, K  fvoid W25Q128_Write_Disable(void);//禁止写入        
6 Z: m2 w' M( u1 i1 R! v
! `! @- K1 T3 I) lvoid W25Q128_Read(uint8_t* pBuffer,uint32_t ReadAddr,uint16_t NumByteToRead); //读取数据
void W25Q128_Write_Page(uint8_t* pBuffer,uint32_t WriteAddr,uint16_t NumByteToWrite);//页写
8 `9 M' l: W' M2 U% x* H' Pvoid W25Q128_Write_NoCheck(uint8_t* pBuffer,uint32_t WriteAddr,uint16_t NumByteToWrite);//无检验写数据，可自动翻页
void W25Q128_Write(uint8_t* pBuffer,uint32_t WriteAddr,uint16_t NumByteToWrite);//写入数据，带擦写功能

4 \2 z. ?+ h/ T) Z  Svoid W25Q128_Erase_Sector(uint32_t Dst_Addr);//擦除扇区
  W$ x6 ~; }& p. D2 |void W25Q128_Erase_Chip(void);//擦除整个芯片        

void W25Q128_Wait_Busy(void);//等待空闲
void W25Q128_PowerDown(void); //进入掉电模式
& G: b; D4 n; o3 x$ rvoid W25Q128_WAKEUP(void);//掉电唤醒

#endif

1
2
8 F8 r# V" D! ^! E3
: {% [$ L: Q% Z/ E. S4
+ w0 R. Q& u. n$ M, }5
6
3 ?- d( F- y2 q4 P0 G7
; n9 O* n/ L( P$ o, e# q8
9
10
11
  |. T8 q. G! D& I12
13
1 U0 @- [2 O, E2 c. D8 {3 |6 O14
' |" X6 [; `2 M- E* M15
' N; I: T0 n2 n6 f' O16
17
+ G6 `& f. D9 Z  e8 }7 ]18
19
20
/ c/ \, [5 U/ g$ z21
8 f) A$ Y! ?" r$ b' z22
( S8 O5 _, U6 t7 j6 V$ Q23
& p7 b3 T8 T' S6 ?24
9 K5 e6 ^4 C9 K1 p25
& v) g# Q: d4 g9 t/ c26
4 X& g' R7 h) h7 d" {$ V+ `2 ~% o27
28
( H( I' m$ q& \5 |( I( l/ C7 ~; ]29
8 p- X5 q7 x6 V5 E& N$ K; w30
, I8 u7 S4 H& E" n  h7 C  f31
32
33
34
0 d2 Y% L) t7 v2 q5 s$ M35
36
9 x, o# V0 {4 L37
38
39
) P+ U) @6 F0 v' {40
4 N0 R* @& G0 Z  Z! ^9 M" N41
42
43
44
45
46
47
6 Z- p( N' f% l$ ~' h  F48
49
50
2 Y) u1 [& g0 |* r1 I4 M% r51
52
% b0 w9 g8 W7 [5 j& w53
54
main.c
% H+ f! N6 B% H6 v  u& M#include <stdio.h>
2 W! ~5 X6 o' s' P& e6 ~5 e. h" h#include "Uart1.h"
( J- z4 }* e8 a9 z& @#include "delay.h"
, O0 C: p7 a8 q0 I#include "SPI.h"
4 @  Z, [" M# L7 k- ?$ _- J5 s#include "W25Q128.h"
+ C* q4 O" D; ?  l' h
3 X- ]  p" r- ?9 G4 O: C/ Buint16_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};
* f+ L. D: q9 W: w3 w1 l) @0 Cuint8_t Read_data[100];
. [+ A& \7 N5 k6 k+ ~1 e) U8 B; c( V# e
int main (void)
( S8 F8 @* H  T. T5 A) y{
! Z' s% V3 y& o7 J$ m) X) I        Uart1_init();
        SPI1_Init();
6 T- F: l( K! |, R5 h        
# J0 X) `( l* H2 q3 n! e4 m        W25Q128_ID=W25Q128_ReadID();
        W25Q128_Write_Page(Write_data,0x01,20);
5 R. L# S0 q8 O# O! p        
        while(1)
        {
4 s$ [. N6 v- W# V# K                W25Q128_Read(Read_data,0x00,100);
                for(int i=0;i<100;i++)
5 O0 Y& X0 [' h5 {1 ~                {
                        printf(" 0x%X ",Read_data);
                }
( Z; I" s2 @! p! i# h                printf("\nW25Q128_ID=0x%X\n",W25Q128_ID);
                delay_ms(500);
" O# v* J4 B* K8 e* Z9 `1 ~6 @        }
}
9 ^3 G3 [  b- i
: V- Q) F- A( w% X6 \0 q; p( N1
2 L' c* Q( ^% A* |2
( d) _" D2 G* h7 A# B% j' V. q6 d9 Q3
; e  W: u6 x/ Z( |4
! q8 b2 A4 Q$ i# i9 Z5
6
9 z+ t, A8 ]. {( C6 E" c$ i- W7
8
  V  a& N. A, `5 V/ q9
$ W) F0 I5 b" T8 x10
% Q0 {# V  d; K* P$ N; g11
12
13
8 q8 ~0 A% q) b- @4 F( D14
. l: O( Z& t# G: I. m# q2 x15
- i" C; F, L$ I  T( B% Q7 ?1 T16
- Q3 v" _1 N+ ^5 n9 i  }3 F17
. T8 t) ], p' o18
! {: M% ]/ c4 J  `! ~- {19
8 w! K$ h7 S9 K5 h$ n/ Y20
' [9 G2 |2 T5 Y  N2 \$ W21
7 k+ ?1 e9 O3 ^" G/ b9 e$ W1 g22
9 t5 K6 ?: t5 Z  k23
24
25
; _8 t3 `5 c  J: }26
27
- T$ a( P; h# a, q" p28
9 x' Y' J3 d% w/ A7 c29
1 g4 x/ _8 _7 u# T实验结果

————————————————
版权声明：根号五
! r6 ~* ^1 L  J5 y
% N; G. ^: R) y9 e/ w2 [0 F