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

1. 原理图
  x$ W' w, I5 s# X; i5 O

3 z0 M: S9 u  q' e$ D- `
; ?9 M, L+ W5 O0 K% |2. 引脚连接

2 G/ x' ]7 P5 s0 D

1 c0 c7 d) o/ c9 q/ u' u二、SPI 底层驱动
SPI.c
5 a' X. [& r# |, U0 v: Y

1. #include "SPI.h"
   . F  b( j5 F# C9 F, R$ z
2. 
   
3. /*
   
4.         SPI引脚初始化配置
   
5.         **PA4------CS
   
6.         **PA5------SCLK
   
7.         **PA6------MISO
   
8.         **PA7------MOSI
   
9. */
   
10. 
    
11. static void SPI1_GPIO_Config(void)        
    7 c' F$ s2 m8 q9 G' ?( I% q
12. {
    % ^9 V. }7 }/ p7 M; i: U% J. B" c* s
13.         GPIO_InitTypeDef GPIO_InitStructure;
    7 Q7 [3 F% x" r& ?( z$ T. g$ Y
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复用推挽输出
    + ?  f* ?" u8 N1 V' @
19.         GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
    
20.         GPIO_Init(GPIOA, &GPIO_InitStructure);                                                //初始化GPIOA
    5 @/ `+ [" Z5 s/ S7 J: D7 g- Y
21.         
    
22.         GPIO_InitStructure.GPIO_Pin = GPIO_Pin_4;
    ) X9 a5 G- d. u8 s# {8 u
23.         GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;  //PA4推挽输出
    5 m. d- u& T, `3 e7 }1 j4 k6 J
24.         GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
      z2 u8 G3 J. E8 f2 j0 U3 B: C
25.         GPIO_Init(GPIOA, &GPIO_InitStructure);                                                //初始化GPIOA
    
26. 
    
27.         GPIO_SetBits(GPIOA,GPIO_Pin_4|GPIO_Pin_5|GPIO_Pin_6|GPIO_Pin_7); //初始上拉输出
      h% R' I+ S  k
28. 
    ! }1 u+ B" u9 s: u8 \1 Y
29. }
    ! q( B# U4 S& _2 \
30. 
    
31. //SPI1初始化函数
    , V0 x8 p# m2 e! i
32. void SPI1_Init(void)
    ) D+ V- \+ K! {& i
33. {
    2 u3 E: X' D0 _# {( c
34.         SPI1_GPIO_Config();//SPI引脚初始化配置        
    
35. 
    
36.         SPI_InitTypeDef  SPI_InitStructure;
    1 `  n, g8 D3 p7 a
37.         
    
38.         RCC_APB2PeriphClockCmd(        RCC_APB2Periph_SPI1,  ENABLE );//SPI1时钟使能         
    . G) n! [% |2 a, T' f
39.         
    1 [  u0 W6 {+ C1 ]( Y4 U
40.         SPI_InitStructure.SPI_Direction = SPI_Direction_2Lines_FullDuplex;          //设置SPI单向或者双向的数据模式:SPI设置为双线双向全双工
      {/ ~# u' W5 X" `) ^8 R
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;                                                                                                                //串行同步时钟的空闲状态为高电平
    
44.         SPI_InitStructure.SPI_CPHA = SPI_CPHA_2Edge;                                                                                                        //串行同步时钟的第二个跳变沿（上升或下降）数据被采样
    
45.         SPI_InitStructure.SPI_NSS = SPI_NSS_Soft;                                                                                                                        //NSS信号由硬件（NSS管脚）还是软件（使用SSI位）管理:内部NSS信号有SSI位控制
    " [0 D  L. S5 o
46.         SPI_InitStructure.SPI_BaudRatePrescaler = SPI_BaudRatePrescaler_256;        //定义波特率预分频的值:波特率预分频值为256
    & O* _$ {! j  }. |( Q0 F8 d6 n0 B
47.         SPI_InitStructure.SPI_FirstBit = SPI_FirstBit_MSB;                                                                                //指定数据传输从MSB位还是LSB位开始:数据传输从MSB位开始
    , h3 m! S: v/ W( Z0 N
48.   SPI_InitStructure.SPI_CRCPolynomial = 7;        //CRC值计算的多项式
    
49.         SPI_Init(SPI1, &SPI_InitStructure);                          //根据SPI_InitStruct中指定的参数初始化外设SPIx寄存器
    0 U( w: ^1 L/ b4 B
50.         
    
51.         SPI_Cmd(SPI1, ENABLE); //使能SPI外设
    5 q9 S9 }3 ]9 ~; P" ~; A, d
52.         SPI1_ReadWriteByte(0xFF);//启动传输
    * p3 B' H7 j, d
53. }
    
54. 
    
55. /*
    
56.         SPI的读写操作
    
57.         **TxData:要写入的字节
    
58.         **返回值:读取到的字节
    
59. */
    / f8 p" Y+ S$ ?( `
60. uint8_t SPI1_ReadWriteByte(uint8_t TxData)
    
61. {                                 
    
62.         while (SPI_I2S_GetFlagStatus(SPI1, SPI_I2S_FLAG_TXE) == RESET) //检查指定的SPI标志位设置与否:发送缓存空标志位
    
63.         {
    
64.                 //等待发送完成
    9 Y: |; Z' W  t, {& d  p
65.         }                          
    
66.         SPI_I2S_SendData(SPI1, TxData); //通过外设SPIx发送一个数据
    
67.         while (SPI_I2S_GetFlagStatus(SPI1, SPI_I2S_FLAG_RXNE) == RESET) //检查指定的SPI标志位设置与否:接受缓存非空标志位
    % x. o6 }3 Q+ }6 B
68.         {
    ) u8 |/ O# U9 y) [. ^2 N4 z& S5 C0 g- e
69.                 //等待接收完成
    0 |+ p" T( L2 J' C( e
70.         }                                                              
    
71.         return SPI_I2S_ReceiveData(SPI1); //返回通过SPIx最近接收的数据                                            
    1 @4 B+ t! G: p# u
72. }

复制代码

2 T3 X! U5 z+ k0 F. _SPI.h

1. #ifndef __SPI_H
   
2. #define        __SPI_H
   
3. 
   $ ]) Y5 ]7 ]9 O3 ^+ `5 x, o
4. #include "stm32f10x.h"
   : L  y% Z+ f; u: _8 ^3 H
5. 
   ; S  s2 V% x- m* {5 B/ H
6. #define SPI_CS(a)                if (a)        \
   
7.                                                 GPIO_SetBits(GPIOA,GPIO_Pin_4);\
   
8.                                                 else                \
   
9.                                             GPIO_ResetBits(GPIOA,GPIO_Pin_4)
   
10. 
    * M+ l1 _4 G$ Z) m1 f( z- z( a
11. void SPI1_Init(void);//SPI1初始化函数
    
12. uint8_t SPI1_ReadWriteByte(uint8_t TxData);//SPI1读写函数
    5 `8 ~! j9 D9 z" R
13. 
    5 x! M( Q3 {+ Y8 |& G& ]
14. #endif

复制代码

三、读取 W25Q128 设备 ID
本次实验是：读取 W25Q128 设备 ID，然后通过串口1打印出来。
( z" T, Y" V6 P9 [( C. s7 v. B通过简单的实验来调试，有利于发现问题。
通过W25Q128的数据手册可知其设备ID如下图所示：
# ^7 g. _1 m2 n4 d7 e" a. M( C
& c3 |8 Z/ `. G. r
6 n' l* G! n8 c. k: e/ I4 }5 W0 g
' V; k; ]: c) x8 PW25Q128.c
0 j7 l9 c; X: S! ^  D

1. #include "W25Q128.h"
   8 n! e6 Y& @; o+ P
2. #include "SPI.h"
   
3. 
   
4. 
   
5. uint8_t W25Q128_ReadWriteByte(uint8_t TxData)//函数包装一下
   ) ~& B, B, `  U7 T. R' c
6. {     
   
7.            return SPI1_ReadWriteByte(TxData);                 
   4 p" x8 s* D6 o% b7 K6 x/ b
8. }
   5 r9 A- N" p  R5 \5 s
9. 
   
10. uint16_t W25Q128_ReadID(void)//读取芯片ID
    . N$ D2 v# D  Q' D6 f/ Z
11. {
    , g% X; d, S. Q; D4 Y
12.         uint16_t Temp = 0;         
    
13.         W25Q128_CS(0);                                    
    - L) F! S! Z; k3 \. q6 P  h
14.         W25Q128_ReadWriteByte(W25X_ManufactDeviceID);//发送读取ID命令            
    - \+ ~4 C" e% B6 q* e" D
15.         W25Q128_ReadWriteByte(0x00);            
    
16.         W25Q128_ReadWriteByte(0x00);            
    
17.         W25Q128_ReadWriteByte(0x00);                                    
    
18.         Temp|=W25Q128_ReadWriteByte(0xFF)<<8;  
    * G. ^8 _. L) a
19.         Temp|=W25Q128_ReadWriteByte(0xFF);         
    . E% ?3 v" Z# z- k" Z
20.         W25Q128_CS(1);                                    
    0 c+ y7 A- ]5 D" n9 C8 e! _+ |" x
21.         return Temp;
    7 c5 g2 K* \  s5 @) L0 ?5 p8 j
22. }

复制代码

W25Q128.h

1. #ifndef __W25Q128_H
   
2. #define        __W25Q128_H
   
3. 
   
4. #include "stm32f10x.h"
   8 e, s! z% n! L7 _" O5 y
5. 
   5 F9 N' r3 _' B! G. U
6. //操作指令表
   & `& K  C8 v8 x
7. #define W25X_ManufactDeviceID         0x90       //制造商+设备ID
   
8. 
   
9. #define W25Q128_CS(a) SPI_CS(a)        
   
10. 
    5 E/ Y2 ~0 Q  s7 i* `0 S
11. uint8_t W25Q128_ReadWriteByte(uint8_t TxData);//函数包装一下
    
12. uint16_t W25Q128_ReadID(void);//读取芯片ID
    
13. 
    
14. #endif

复制代码

main.c

1. #include <stdio.h>
   
2. #include "Uart1.h"
   . K+ c+ J/ ~7 R+ L; a, {
3. #include "delay.h"
   : i7 G( u' Y6 ?
4. #include "SPI.h"
   
5. #include "W25Q128.h"
   9 t% U( D' t6 O  t
6. 
   8 T# Y/ Z5 _: f* X! {5 P
7. uint16_t W25Q128_ID=0;
   / A8 j9 g8 g8 v  u" s9 a3 l8 T
8. 
   
9. int main (void)
   ' e/ j& Q/ ]/ j, x- k
10. {
    ( e& o6 t4 h: D) _
11.         Uart1_init();
    ( N' e, ^! U$ v4 `8 v
12.         SPI1_Init();
    
13.         
    
14.         W25Q128_ID = W25Q128_ReadID();
    * G# u; ]6 H/ U0 [1 I- F5 u
15.         while(1)
    + i4 Y" k8 Z% W4 K
16.         {
    ; B6 g% f/ k& A8 ~5 [- r
17.                 printf("\nW25Q128_ID=0x%X\n",W25Q128_ID);
    
18.                 delay_ms(500);
    ( P. f8 K. t; c* D$ U' @* Q
19.         }
    ( n' ~" S9 }. ]* Z3 I
20. }

复制代码

/ {% b, j* `% R( f; h实验结果

% t/ R' X! Z6 ?) G1 b- _! W: T
接收到 W25Q128 设备ID 为0xEF17

四、读写 W25Q128 外部 Flash
( |6 i" ^) M  u' _; m2 b; cW25Q128.c
0 M5 n9 j: n* [1 u* g  X

1. #include "W25Q128.h"
   & x/ M1 N  [  @- j' v; |: n4 S
2. #include "SPI.h"
   ( d9 C* i) S# e% n. x0 O! K
3. 
   ) y' ^1 ?, a( @5 a# x* ]* q
4. 
   
5. uint8_t W25Q128_ReadWriteByte(uint8_t TxData)//函数包装一下
   
6. {     
   
7.          return SPI1_ReadWriteByte(TxData);                 
   
8. }
   ! h8 F8 m0 h3 q
9. 
   * i. `3 X6 |( y" K9 k  P
10. 
    
11. uint16_t W25Q128_ReadID(void)//读取芯片ID
    . Q2 v& U, G; S+ f
12. {
    2 e! c- T( W: P' V4 n* l1 \
13.         uint16_t Temp = 0;         
    , ]7 V* u( M4 z: r
14.         W25Q128_CS(0);                                    
    ' d/ a5 l$ d2 r. ~+ b
15.         W25Q128_ReadWriteByte(W25X_ManufactDeviceID);//发送读取ID命令            
    $ _  f& F2 u2 |1 ]: b7 u: z
16.         W25Q128_ReadWriteByte(0x00);            
    
17.         W25Q128_ReadWriteByte(0x00);            
    
18.         W25Q128_ReadWriteByte(0x00);                                    
    . b0 F" a6 g/ _- `; ~
19.         Temp|=W25Q128_ReadWriteByte(0xFF)<<8;  
    ; _2 h; w2 {% g1 _8 d3 m: E3 a
20.         Temp|=W25Q128_ReadWriteByte(0xFF);         
    
21.         W25Q128_CS(1);                                    
    $ g0 C9 W8 P! b7 p
22.         return Temp;
    5 x$ e; j3 C& x
23. }
    
24. 
    % x) G' B8 U) e, C5 G) ?
25. //读取W25Q128的状态寄存器
    
26. //BIT7  6   5   4   3   2   1   0
    
27. //SPR   RV  TB BP2 BP1 BP0 WEL BUSY
    
28. //SPR:默认0,状态寄存器保护位,配合WP使用
    
29. //TB,BP2,BP1,BP0:FLASH区域写保护设置
    , H: `: V0 s4 D* a. Y
30. //WEL:写使能锁定
    5 {& T4 [2 {2 T- y! P/ y+ K
31. //BUSY:忙标记位(1,忙;0,空闲)
    
32. //默认:0x00
    # |( N  Y/ h! R% k, d0 g6 V/ B- W
33. uint8_t W25Q128_ReadSR(void)//读取状态寄存器
    5 }. d9 o! U3 w* M6 p5 X
34. {
    & f' W# Q- O4 ^; E  X) i. u
35.     uint8_t byte=0;
    
36.     W25Q128_CS(0);                               //使能器件
    
37.     W25Q128_ReadWriteByte(W25X_ReadStatusReg1);  //发送读取状态寄存器命令
    
38.     byte=W25Q128_ReadWriteByte(0Xff);            //读取一个字节
      u' e, M, h+ m6 e
39.     W25Q128_CS(1);                               //取消片选
    9 o3 E( C# e0 F' P
40.     return byte;
    7 @% V- ~( O- y# @/ b
41. }
    3 n9 `. t" u/ d7 g& k: j* S
42. 
      y: Z3 L1 y$ ~4 Y
43. //写W25Q128状态寄存器
    6 ]+ ?, }7 K7 z5 k$ X. y
44. //只有SPR,TB,BP2,BP1,BP0(bit 7,5,4,3,2)可以写!!!
    
45. void W25Q128_WriteSR(uint8_t sr)//写状态寄存器
    
46. {
    
47.     W25Q128_CS(0);                                           //使能器件
    
48.     W25Q128_ReadWriteByte(W25X_WriteStatusReg1);        //发送写取状态寄存器命令
    
49.     W25Q128_ReadWriteByte(sr);                               //写入一个字节
    
50.     W25Q128_CS(1);                                            //取消片选
    
51. }
    3 Q/ O. E+ Z! H9 h, J  ~
52. 
    
53. void W25Q128_Write_Enable(void) //写使能
    
54. {
    
55.            W25Q128_CS(0);        
    " y0 r& w& ^$ A$ m
56.         W25Q128_ReadWriteByte(W25X_WriteEnable);
    
57.         W25Q128_CS(1);        
    6 q3 b* E7 e6 m
58. }
    
59. 
    
60. void W25Q128_Write_Disable(void) //禁止写入        
    & P8 W) M7 H/ `0 _1 |5 Z+ Q+ {
61. {
    5 x# e# p! f4 @! i, K7 ], t
62.            W25Q128_CS(0);        
    
63.         W25Q128_ReadWriteByte(W25X_WriteDisable);
    & o) W0 D9 H) Q0 @3 I  r: ?
64.         W25Q128_CS(1);        
    
65. }
    : f! K9 w3 w. m" x8 c* U& H8 R
66. 
    - B" e- S! @6 i5 p3 [0 G- z
67. void W25Q128_Read(uint8_t* pBuffer,uint32_t ReadAddr,uint16_t NumByteToRead)   
    9 Z8 k8 Q- q' o& X; B
68. {                                                     
    
69.         W25Q128_CS(0);                                  //使能器件   
    % e. b& l/ S! K( l" H/ ~( N" b. B
70.     W25Q128_ReadWriteByte(W25X_ReadData);      //发送读取命令  
    ( l9 b6 O  }2 ^: H, P: @; X5 P
71.     W25Q128_ReadWriteByte((uint8_t)((ReadAddr)>>16));   //发送24bit地址   
    
72.     W25Q128_ReadWriteByte((uint8_t)((ReadAddr)>>8));   
    
73.     W25Q128_ReadWriteByte((uint8_t)ReadAddr);   
    9 T) p2 ~2 q2 ]" ^2 u
74.     for(uint16_t i=0;i<NumByteToRead;i++)
    
75.         {
    4 `, [& x' l2 N4 {  g1 X
76.        pBuffer<i>=W25Q128_ReadWriteByte(0XFF);    //循环读数  
    ! f- E# F, z  K: E' S" p' ~
77.     }
    
78.         W25Q128_CS(1);                                                  
    
79. }  
    
80. 
    
81. 
    
82. void W25Q128_Write_Page(uint8_t* pBuffer,uint32_t WriteAddr,uint16_t NumByteToWrite)
    
83. {
    / P* M: H; Y$ T# d
84. 
    
85.     W25Q128_Write_Enable();                  //SET WEL
    4 ~$ q; K4 e$ @, n9 p. ^
86.         W25Q128_CS(0);                            //使能器件   
    
87.     W25Q128_ReadWriteByte(W25X_PageProgram);   //发送写页命令   
    0 }0 a$ m) e* G! t& L( D
88. 
    . h  `/ ?8 o* S
89.     W25Q128_ReadWriteByte((uint8_t)((WriteAddr)>>16)); //发送24bit地址   
    $ o8 o9 J: V- {# k$ m0 ^$ x
90.     W25Q128_ReadWriteByte((uint8_t)((WriteAddr)>>8));   
    
91.     W25Q128_ReadWriteByte((uint8_t)WriteAddr);   
    # B8 l* b. T8 Z7 Y  M
92.     for(uint16_t i=0;i<NumByteToWrite;i++)
    ! B  x% C, M7 b8 b3 ~
93.         {
    
94.                 W25Q128_ReadWriteByte(pBuffer<i>);//循环写数  
    
95.         }
    5 F3 S! G; R: q' _9 g' o5 A( ~
96.         W25Q128_CS(1);                            //取消片选
    , L- z* _$ Y9 i, }
97.         W25Q128_Wait_Busy();                                           //等待写入结束
    
98. }
    " _+ b% v) f5 |( `4 C+ i4 }; v
99. 
    1 E5 W( I* q2 k  I- j. ~0 g8 K6 h
100. //无检验写SPI FLASH
     1 Y" }! e+ M7 `
101. //必须确保所写的地址范围内的数据全部为0XFF,否则在非0XFF处写入的数据将失败!
     
102. //具有自动换页功能
     
103. void W25Q128_Write_NoCheck(uint8_t* pBuffer,uint32_t WriteAddr,uint16_t NumByteToWrite)   
     
104. {                                          
     1 N  y2 j: k5 ?6 u3 A6 v
105.         uint16_t pageremain=256-WriteAddr%256; //单页剩余的字节数                             
     
106.         if(NumByteToWrite<=pageremain)pageremain=NumByteToWrite;//不大于256个字节
     
107.         while(1)
     
108.         {           
     
109.                 W25Q128_Write_Page(pBuffer,WriteAddr,pageremain);
     3 F" E+ A* L: ^% K/ @
110.                 if(NumByteToWrite==pageremain)        break;//写入结束了
     - l3 }& K& B. y4 X1 j# F* k5 L# W
111.                  else
     
112.                 {
     
113.                         pBuffer+=pageremain;
     : D4 G: |# D" V* C( d
114.                         WriteAddr+=pageremain;        
     ' h6 X* ^; q( Q0 @8 T8 P# K5 ?
115.                         NumByteToWrite-=pageremain;                          //减去已经写入了的字节数
     4 P( k* ^3 e+ B) T& W" c/ @) ]
116.                         if(NumByteToWrite>256)pageremain=256; //一次可以写入256个字节
     
117.                         else pageremain=NumByteToWrite;           //不够256个字节了
     8 P9 n' [: K) m7 S$ g
118.                 }
     
119.         }            
     
120. }
     
121. 
     
122. //写SPI FLASH  
     
123. //在指定地址开始写入指定长度的数据
       D0 \8 q& m& m: j! {" u9 Q  m
124. //该函数带擦除操作!
       b4 ?* Z4 q4 {+ C
125. //pBuffer:数据存储区
     + U8 D4 y) q# \3 Y( W9 `" c
126. //WriteAddr:开始写入的地址(24bit)                                                
     8 z" _* f' B+ p/ x) i
127. //NumByteToWrite:要写入的字节数(最大65535)   
     8 K3 K4 r, H! e7 [
128. uint8_t W25Q128_BUFFER[4096];                 
     9 B  `' h( p8 X" q
129. void W25Q128_Write(uint8_t* pBuffer,uint32_t WriteAddr,uint16_t NumByteToWrite)   
     
130. {
     
131.          uint16_t i;   
     . C4 f, a4 [2 `8 |' X
132.         uint8_t * W25Q128_BUF;         
     
133.     W25Q128_BUF=W25Q128_BUFFER;            
     5 K1 p- p6 a* j- X
134.          uint32_t secpos = WriteAddr/4096;//扇区地址  
     
135.         uint16_t secoff = WriteAddr%4096;//在扇区内的偏移
     
136.         uint16_t secremain = 4096-secoff;//扇区剩余空间大小   
     
137. 
     7 c+ G& \6 V+ Y8 a5 @
138.          if(NumByteToWrite<=secremain)                secremain=NumByteToWrite;//不大于4096个字节
     
139.         while(1)
     
140.         {        
     ) b4 o+ j1 o$ @, F2 R4 t4 T: k
141.                 W25Q128_Read(W25Q128_BUF,secpos*4096,4096);//读出整个扇区的内容
     + Z" ?' Q* o: V  d2 C
142.                 for(i=0;i<secremain;i++)//校验数据
     
143.                 {
     + d, J* A0 b. ?
144.                         if(W25Q128_BUF[secoff+i]!=0XFF)        break;//需要擦除            
     $ ~* I0 Z8 \* h- O% o
145.                 }
     7 }' Y5 z- K6 J3 Y4 u8 W* l
146.                 if(i<secremain)//需要擦除
     
147.                 {
     ; Q+ B& h: \0 Y) H( Q
148.                         W25Q128_Erase_Sector(secpos*4096);//擦除这个扇区
     
149.                         for(i=0;i<secremain;i++)           //复制
     4 ?& W- }& r# c$ ?$ L2 A1 A
150.                         {
     + R. g% s9 P* s% X6 r* D
151.                                 W25Q128_BUF[i+secoff]=pBuffer<i>;         
     
152.                         }
     
153.                         W25Q128_Write_NoCheck(W25Q128_BUF,secpos*4096,4096);//写入整个扇区  
       p! {8 h( [" h0 Y5 L- Q6 _
154. 
     
155.                 }else W25Q128_Write_NoCheck(pBuffer,WriteAddr,secremain);//写已经擦除了的,直接写入扇区剩余区间.                                    
     
156.                 if(NumByteToWrite==secremain)        break;//写入结束了
     
157.                 else//写入未结束
     
158.                 {
     
159.                         secpos++;//扇区地址增1
     ' j+ e8 f9 L. p' N4 C
160.                         secoff=0;//偏移位置为0         
     
161. 
     ( ]) M' Z6 O' O6 e7 j$ ?: T& N
162.                     pBuffer+=secremain;  //指针偏移
     
163.                         WriteAddr+=secremain;//写地址偏移           
     
164.                     NumByteToWrite-=secremain;                                //字节数递减
     
165.                         if(NumByteToWrite>4096)        secremain=4096;        //下一个扇区还是写不完
     
166.                         else         secremain=NumByteToWrite;                //下一个扇区可以写完了
     
167.                 }         
     
168.         }         
     
169. }
     
170. 
     ' ~* s5 H0 X- Z, ~( z( b
171. //擦除一个扇区
     ) ~8 f8 q5 D' x& x# N2 D
172. //Dst_Addr:扇区地址 根据实际容量设置
     
173. //擦除一个扇区的最少时间:150ms
     ! P# Y5 h. i3 c9 h$ l7 c# [, w5 f
174. 
     , v# v: ?" R- y( \6 Z5 d
175. void W25Q128_Erase_Sector(uint32_t Dst_Addr)   
     
176. {  
     
177.     W25Q128_Write_Enable();                  //SET WEL         
     
178.     W25Q128_Wait_Busy();   
     
179.           W25Q128_CS(0);                            //使能器件   
     2 _9 Z/ A, G. h$ r9 c
180.     W25Q128_ReadWriteByte(W25X_SectorErase);   //发送扇区擦除指令
     
181.     W25Q128_ReadWriteByte((uint8_t)((Dst_Addr)>>16));  //发送24bit地址   
     
182.     W25Q128_ReadWriteByte((uint8_t)((Dst_Addr)>>8));   
     " s9 Y2 O) Z& z1 y, ^) I
183.     W25Q128_ReadWriteByte((uint8_t)Dst_Addr);  
     6 B6 d( v% Q. T0 v
184.         W25Q128_CS(1);                                    //取消片选                  
     : k1 X8 j# c( Z# D8 h6 m4 U: B
185.     W25Q128_Wait_Busy();                                               //等待擦除完成
     4 P& x! W2 G- H5 Q1 V: F
186. }  
     
187. 
     : v) z3 H( j7 l" }8 U
188. //擦除整个芯片                  
     
189. //等待时间超长...
     
190. void W25Q128_Erase_Chip(void)   
     
191. {                                   
     
192.     W25Q128_Write_Enable();                  //SET WEL
     
193.     W25Q128_Wait_Busy();   
     
194.           W25Q128_CS(0);                           //使能器件   
     1 p: y0 y* P- s8 h
195.     W25Q128_ReadWriteByte(W25X_ChipErase);   //发送片擦除命令  
     
196.         W25Q128_CS(1);                           //取消片选                  
     
197.         W25Q128_Wait_Busy();                                              //等待芯片擦除结束
     9 A/ X8 u( ?! G9 H& @- D
198. }
     1 v+ R3 f3 c6 F* @( j5 T
199. 
     
200. 
     7 n& J6 n0 K, q
201. //等待空闲
     : ~) @8 s  `1 m, a( _$ ^9 l
202. void W25Q128_Wait_Busy(void)   
     
203. {   
     * l! E" m/ x- u: {4 P
204.         while((W25Q128_ReadSR()&0x01)==0x01);   // 等待BUSY位清空
     
205. }  
     6 x; C7 }, V- e' n' N
206. 
     0 D  O4 u. O. w) U* W; D
207. //进入掉电模式
     
208. void W25Q128_PowerDown(void)   
     . \* ?' j4 {+ Z" ^( v) B$ J+ T
209. {
     9 N! S. ?) Q" ]! V* X& |
210.           W25Q128_CS(0);                            //使能器件   
     
211.     W25Q128_ReadWriteByte(W25X_PowerDown);    //发送掉电命令  
     / d  z. t5 ?# i4 L! o
212.         W25Q128_CS(1);                            //取消片选                  
     0 |6 e2 ]+ a! Y. M8 _9 ?  B
213. }   
     
214. //掉电唤醒
     8 w+ }- Q6 T" a, y; o: Y& Z
215. void W25Q128_WAKEUP(void)   
     - \% R5 W  L! e2 W
216. {  
     
217.           W25Q128_CS(0);                                //使能器件   
     
218.     W25Q128_ReadWriteByte(W25X_ReleasePowerDown);   
     
219.         W25Q128_CS(1);                                //取消片选                  
     
220. }   </i></i></i>

复制代码

9 S: ^2 N. p: X1 A8 L7 H( LW25Q128.h
+ ]2 T0 Y, Z5 [#ifndef __W25Q128_H
8 n  L$ M  p3 p, ]! Y) a' y#define        __W25Q128_H
$ \$ A1 \8 }4 w; O1 H# H
$ H) D' ~( m, _; e#include "stm32f10x.h"
, B" M; F2 c2 E+ G6 U
//操作指令表
7 l: A, J: y- k. n: s2 |#define W25X_WriteEnable                           0x06         //写使能
#define W25X_WriteDisable                           0x04         //写禁止
1 E+ b" U" r8 F# `* L2 s#define W25X_ReadStatusReg1                         0x05         //读状态寄存器1
#define W25X_ReadStatusReg2                         0x35         //读状态寄存器2
#define W25X_ReadStatusReg3                         0x15         //读状态寄存器3
% g% `/ v/ \( p; F) Z0 Z' }#define W25X_WriteStatusReg1                   0x01         //写状态寄存器1
! u( y# S7 I0 X: O0 H' R5 ?/ t* c#define W25X_WriteStatusReg2                   0x31         //写状态寄存器2
' n+ \) Z& W" I; F  q; f#define W25X_WriteStatusReg3                   0x11         //写状态寄存器3
#define W25X_ReadData                                0x03         //读数据
#define W25X_FastReadData                           0x0B         //快读
#define W25X_FastReadDual                           0x3B    //双输出快读
#define W25X_PageProgram                           0x02         //页编程
# l9 N4 N( b) ~. _. N/ B#define W25X_BlockErase                                   0xD8         //块擦除（64K）
* e1 \2 ?7 n. G+ c/ g' X#define W25X_SectorErase                           0x20    //扇区擦除（4K）
3 p6 E4 d5 k8 F& @  @#define W25X_ChipErase                                   0xC7    //芯片擦除
+ G8 [* t" z. X5 M#define W25X_PowerDown                                   0xB9    //掉电
#define W25X_ReleasePowerDown                 0xAB    //释放掉电
#define W25X_DeviceID                            0xAB    //器件ID
6 ^+ h3 H8 _& _7 ~7 S! F% Q#define W25X_ManufactDeviceID                 0x90    //制造商+设备ID
#define W25X_JedecDeviceID                         0x9F         //电子元件ID
" F/ |! T/ M8 R- [/ o) J8 E

#define W25Q128_CS(a) SPI_CS(a)        

, C4 c" B8 e) a* ?1 o' I
uint8_t W25Q128_ReadWriteByte(uint8_t TxData);//函数包装一下
! W& [7 ]# ?  t) b# v3 H6 |
1 r6 F" i+ A9 u8 g. |uint16_t W25Q128_ReadID(void);//读取芯片ID

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

void W25Q128_Write_Enable(void);//写使能
5 `( {- w2 a9 Dvoid W25Q128_Write_Disable(void);//禁止写入        

void W25Q128_Read(uint8_t* pBuffer,uint32_t ReadAddr,uint16_t NumByteToRead); //读取数据
6 B( I& V: i5 q/ K  [/ Fvoid W25Q128_Write_Page(uint8_t* pBuffer,uint32_t WriteAddr,uint16_t NumByteToWrite);//页写
* m: P/ ?+ s4 }2 Z" Hvoid 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);//擦除整个芯片        

void W25Q128_Wait_Busy(void);//等待空闲
2 f6 X3 w* {0 }5 bvoid W25Q128_PowerDown(void); //进入掉电模式
; t, d+ q- U9 Q' B1 @$ X$ p! |8 ovoid W25Q128_WAKEUP(void);//掉电唤醒
9 a& W/ @6 D! h
#endif
0 f* R* w* p! c; Z, I1 b6 F6 Z# p, i
1
5 Z# ^- H9 J! X3 L& K7 c1 u" X8 h2
# J! R5 F) x8 @0 V3
$ p- N7 ?  l# y+ l4
! G5 c: g4 r7 l5
) Q$ y9 E- k) p6
7
8
9 R% T+ e1 g0 |6 I7 `& g& |9
! J2 a6 F  g+ |% P4 A$ N# D10
" ^( [& J1 T' m9 s" B4 \5 n2 c11
0 [( x9 X% s: b- w9 g+ r! t12
13
5 p: E1 l2 u8 \; }14
15
16
, r: V4 z4 v6 w6 D17
  N0 O" ~2 E4 r" b% t18
19
% R% y; i, c2 ?9 t; I/ {1 L20
  M/ D. m( U; ~( A8 j6 l+ D& ^21
22
23
+ p6 Y+ b$ G  q) [# f) e5 L24
25
26
+ A% h0 s% U; d27
5 t' N5 }$ z* m2 r/ f, P28
29
30
31
6 o5 q& v3 L, \' T/ W; F32
  z* @3 O( `  }6 V; ]33
3 y# a) t. H. y; w3 w# s- ?34
35
, T+ V4 r4 a: N2 e) D36
37
38
( S. S- ~( D3 `* R% [' j6 F39
( |0 J9 h7 Y# Z/ ^8 a! S4 A1 t40
41
, I% K2 v- p: n2 k4 T) `* Z5 k42
43
2 I7 g. W- ?) x, K8 j44
45
46
8 k" c$ T5 J* Y- F; }47
) N3 V$ [( G* D3 b9 C6 N48
49
50
. n0 z( a: \  Q" H1 t51
52
7 K# N0 Z1 S! s  K; _53
3 Z) Q# J' X) C6 m& z4 l7 H54
main.c
- N; q9 v% @, T6 a#include <stdio.h>
#include "Uart1.h"
#include "delay.h"
# P8 Q* C# m$ S4 u* Q#include "SPI.h"
# x" H: b& O  E, n9 m#include "W25Q128.h"
: n. N: K% n) x$ e
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};
5 o9 M, M0 l0 O3 {! A/ n+ huint8_t Read_data[100];
5 Z/ k' h  u$ p% p  q5 E
- |# `, D( O% f  S8 f; xint main (void)
{
& I. r7 B% u9 }& V        Uart1_init();
        SPI1_Init();
, ~8 ]5 X9 o) u1 B        
        W25Q128_ID=W25Q128_ReadID();
$ S+ I) l0 q7 q  z' J        W25Q128_Write_Page(Write_data,0x01,20);
        
' f! j) ^7 A: |6 i        while(1)
        {
                W25Q128_Read(Read_data,0x00,100);
                for(int i=0;i<100;i++)
/ x8 i+ D" w. S7 x# q                {
                        printf(" 0x%X ",Read_data);
                }
                printf("\nW25Q128_ID=0x%X\n",W25Q128_ID);
5 x( |) c+ j* i7 S. A  M) j; s* A                delay_ms(500);
        }
$ f- J8 J$ f" A& _}
( d8 u2 x8 z, A
1
+ X# y8 Z+ V1 W, C2 n+ \7 F2
: M: v' d/ _( U8 C- x  y3
4
( d" }. {  I& v$ c( j5 b4 P1 x% Z5
% ?( G3 k9 |! n6
: t& O; U) T; a7
8
9
10
11
- o8 g4 B. m1 m' p& U4 I  v12
13
14
  Q  D) R+ I& T  N4 F) k15
9 v& H$ p: ~- l9 }$ V1 G16
  o( p# w0 a# j4 `# ]0 Q9 \3 d( {17
18
3 Z' G( ~0 U  G$ y19
6 X0 \* T% p4 A1 R" U# ?, n20
' k8 T+ ?0 l" l( Q0 z$ B0 U21
9 R/ u7 t7 z& f22
1 v1 a3 J7 w9 N& Z0 e2 @! u, x23
24
25
9 y( @; h+ p( F$ e8 ]" t26
27
/ k5 ]2 e9 u- g+ p28
29
实验结果
5 x- X" r+ |7 U
————————————————
% w' G. T0 E4 O) Q版权声明：根号五

$ M+ E5 N( X) D/ H& C* H& L