一、实验前期准备
本次实验的 MCU 是 STM32F103C8T6 芯片，通过 SPI 通信实现 W25Q128 的读写操作。
7 ?: G: g2 s! M$ }5 J
1. 原理图



2. 引脚连接

6 @2 D4 }) _/ p/ O8 c" D/ t! l

9 e; m* p# z4 x# J二、SPI 底层驱动
SPI.c
) k. r* Z* m" D) I7 f& L6 z

1. #include "SPI.h"
   7 ?6 S; V; I# s
2. 
   
3. /*
   # s* E8 [% z% e% E  Z, f
4.         SPI引脚初始化配置
   
5.         **PA4------CS
   8 Q3 T' i3 T' J) E( i# S& |
6.         **PA5------SCLK
   4 B1 @! ?" P, U
7.         **PA6------MISO
   
8.         **PA7------MOSI
   
9. */
   
10. 
    & }6 R! x- |' E. d
11. static void SPI1_GPIO_Config(void)        
    
12. {
    1 C3 f3 w; \2 A( P! v
13.         GPIO_InitTypeDef GPIO_InitStructure;
    
14.         
    * \3 p6 a' b8 t; y
15.         RCC_APB2PeriphClockCmd(        RCC_APB2Periph_GPIOA, ENABLE );//PORTA时钟使能
    0 p1 C/ g- X( w( W6 _( Q, X
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复用推挽输出
    $ c# ?% d) h* O& h- w9 U, {; w! X8 c8 ?
19.         GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
    
20.         GPIO_Init(GPIOA, &GPIO_InitStructure);                                                //初始化GPIOA
    
21.         
    0 z" Q) G/ G( U
22.         GPIO_InitStructure.GPIO_Pin = GPIO_Pin_4;
    5 v& e3 d* I9 q* N8 B6 B! T# [( t
23.         GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;  //PA4推挽输出
    5 x4 _" E" S7 x9 ]: \: Q' N& ]& X) I
24.         GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
    + U# ]1 B0 h6 U3 d
25.         GPIO_Init(GPIOA, &GPIO_InitStructure);                                                //初始化GPIOA
    
26. 
    
27.         GPIO_SetBits(GPIOA,GPIO_Pin_4|GPIO_Pin_5|GPIO_Pin_6|GPIO_Pin_7); //初始上拉输出
    
28. 
    
29. }
    
30. 
    % G' c5 F( @3 @, S
31. //SPI1初始化函数
    8 H( \3 C6 Q$ U8 x3 J) I- d
32. void SPI1_Init(void)
    ' K$ v3 q/ Q1 k: u- a' u
33. {
    $ P( ?$ E* J# r3 I4 {6 y' N
34.         SPI1_GPIO_Config();//SPI引脚初始化配置        
    
35. 
    - A5 e' n0 \9 g9 S% e
36.         SPI_InitTypeDef  SPI_InitStructure;
    & Z" q7 g# l" D0 |. s
37.         
    
38.         RCC_APB2PeriphClockCmd(        RCC_APB2Periph_SPI1,  ENABLE );//SPI1时钟使能         
    
39.         
    1 D5 [) q( k. C. m9 P4 _6 a  C! h
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;                                                                                                                //串行同步时钟的空闲状态为高电平
    
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
    - U/ T1 b" e% m* w4 n; y
47.         SPI_InitStructure.SPI_FirstBit = SPI_FirstBit_MSB;                                                                                //指定数据传输从MSB位还是LSB位开始:数据传输从MSB位开始
    
48.   SPI_InitStructure.SPI_CRCPolynomial = 7;        //CRC值计算的多项式
    
49.         SPI_Init(SPI1, &SPI_InitStructure);                          //根据SPI_InitStruct中指定的参数初始化外设SPIx寄存器
    ' q( A1 _+ Z8 b' ~4 h
50.         
    - _" z) n/ l, I" t' g7 P
51.         SPI_Cmd(SPI1, ENABLE); //使能SPI外设
    
52.         SPI1_ReadWriteByte(0xFF);//启动传输
    7 ^2 N( O% u, p, [6 W
53. }
    
54. 
    
55. /*
    
56.         SPI的读写操作
    
57.         **TxData:要写入的字节
    
58.         **返回值:读取到的字节
    
59. */
    2 k  G' k9 T+ U, e! ^
60. uint8_t SPI1_ReadWriteByte(uint8_t TxData)
    9 H9 y, {7 H+ F, `  Y
61. {                                 
    ; }! T( p! D) A2 x; l, l
62.         while (SPI_I2S_GetFlagStatus(SPI1, SPI_I2S_FLAG_TXE) == RESET) //检查指定的SPI标志位设置与否:发送缓存空标志位
    
63.         {
    
64.                 //等待发送完成
    8 W) O& O9 l& e; ]* ~
65.         }                          
    
66.         SPI_I2S_SendData(SPI1, TxData); //通过外设SPIx发送一个数据
    # C+ U. L# J: f6 M
67.         while (SPI_I2S_GetFlagStatus(SPI1, SPI_I2S_FLAG_RXNE) == RESET) //检查指定的SPI标志位设置与否:接受缓存非空标志位
    
68.         {
    
69.                 //等待接收完成
    ( p. l9 `9 n3 E9 g: v. T
70.         }                                                              
    & i$ P. H0 Y* F) }3 E1 C7 p
71.         return SPI_I2S_ReceiveData(SPI1); //返回通过SPIx最近接收的数据                                            
    
72. }

复制代码

) f7 A9 x/ I/ uSPI.h

1. #ifndef __SPI_H
   
2. #define        __SPI_H
   
3. 
   
4. #include "stm32f10x.h"
   6 e8 M( J( E3 c; D9 ^2 h. F
5. 
   6 _* O! N3 c! w! J
6. #define SPI_CS(a)                if (a)        \
   
7.                                                 GPIO_SetBits(GPIOA,GPIO_Pin_4);\
   0 h& e6 o9 g; e7 T& G
8.                                                 else                \
   : m- [& e; U* s) b7 N2 m9 e
9.                                             GPIO_ResetBits(GPIOA,GPIO_Pin_4)
   
10. 
    ! ^% O. m* T" [% A
11. void SPI1_Init(void);//SPI1初始化函数
    $ a/ j5 R( X$ [9 X( b6 n
12. uint8_t SPI1_ReadWriteByte(uint8_t TxData);//SPI1读写函数
    
13. 
    . T7 ]) _$ U2 [+ K  `2 ?( d
14. #endif

复制代码

三、读取 W25Q128 设备 ID
6 Y2 p5 q3 }3 x2 D$ C! ~8 C本次实验是：读取 W25Q128 设备 ID，然后通过串口1打印出来。
0 }; y) D4 [$ u% ~4 o- G: R通过简单的实验来调试，有利于发现问题。
通过W25Q128的数据手册可知其设备ID如下图所示：

: Z# \( C5 w9 e1 ?) e! l3 s

W25Q128.c
' q+ d. \. Z3 V  Y$ z

1. #include "W25Q128.h"
   + w3 C" R. i8 A) L
2. #include "SPI.h"
   * v5 ?  X* }3 n" I: o  }6 }* f$ P, Z* b
3. 
   
4. 
   ; z: Z5 K3 {4 s& g
5. uint8_t W25Q128_ReadWriteByte(uint8_t TxData)//函数包装一下
   3 M# @4 f$ C# `/ K
6. {     
   " P, i& [! p4 F+ G: o0 Z
7.            return SPI1_ReadWriteByte(TxData);                 
   + t: t1 m6 K/ y
8. }
   5 O$ L, o! [7 n7 [! F
9. 
   
10. uint16_t W25Q128_ReadID(void)//读取芯片ID
    : G6 N' p% K( x; w
11. {
    / j( I& W) L( Q! A; a6 G: H
12.         uint16_t Temp = 0;         
    
13.         W25Q128_CS(0);                                    
    # D* v3 ]% l* c1 Z; H( N( ?  q" c
14.         W25Q128_ReadWriteByte(W25X_ManufactDeviceID);//发送读取ID命令            
    
15.         W25Q128_ReadWriteByte(0x00);            
    
16.         W25Q128_ReadWriteByte(0x00);            
    
17.         W25Q128_ReadWriteByte(0x00);                                    
    $ x0 ~  v4 |, ^9 c' k. r2 y  }
18.         Temp|=W25Q128_ReadWriteByte(0xFF)<<8;  
    
19.         Temp|=W25Q128_ReadWriteByte(0xFF);         
    9 h- {2 q% k# Y, t
20.         W25Q128_CS(1);                                    
    
21.         return Temp;
    : }+ Z' H0 T$ E* G1 Y4 B" |* A
22. }

复制代码

W25Q128.h
( R) H% m7 N- ?5 g& \

1. #ifndef __W25Q128_H
   , |; {: H* k! }+ h
2. #define        __W25Q128_H
   * Z! O3 W6 @" F0 h5 a
3. 
   
4. #include "stm32f10x.h"
   
5. 
   ( j+ i1 ^3 z2 D# ?7 u
6. //操作指令表
   ! Z9 m6 I! B4 A6 Z6 {
7. #define W25X_ManufactDeviceID         0x90       //制造商+设备ID
     `% O3 D  g1 P  ]: h
8. 
   
9. #define W25Q128_CS(a) SPI_CS(a)        
   
10. 
    6 B+ m5 ^' n# z  s
11. uint8_t W25Q128_ReadWriteByte(uint8_t TxData);//函数包装一下
    & F+ ?2 k+ Q0 r: a0 W6 c/ S# n
12. uint16_t W25Q128_ReadID(void);//读取芯片ID
    - D' Q+ }. o$ G5 F
13. 
    ! k8 C, P- o2 A' X6 [
14. #endif

复制代码

% z5 ?$ W4 o& z3 Z: E2 Wmain.c
6 n: @9 ~& Z+ T- U4 V

1. #include <stdio.h>
   & W/ f2 |  v: K
2. #include "Uart1.h"
   & ^$ x3 N1 i0 D) E
3. #include "delay.h"
   
4. #include "SPI.h"
   ( l: u4 ?$ r& U  l2 }8 q! o% `
5. #include "W25Q128.h"
   " {3 q9 e  f5 q6 S$ R( a  M
6. 
   
7. uint16_t W25Q128_ID=0;
   
8. 
   
9. int main (void)
   
10. {
    
11.         Uart1_init();
    
12.         SPI1_Init();
    
13.         
    ; E! M: P5 F$ M1 z- r
14.         W25Q128_ID = W25Q128_ReadID();
    
15.         while(1)
    
16.         {
    " ]( Z  n, u' z7 K+ e
17.                 printf("\nW25Q128_ID=0x%X\n",W25Q128_ID);
    
18.                 delay_ms(500);
    
19.         }
    * d& h. J* h+ }* ~" y# ^$ k
20. }

复制代码

实验结果
; Z6 A$ q) }8 V. l
: I- f2 n$ Y5 _% z: j
接收到 W25Q128 设备ID 为0xEF17
, n/ u: m2 B3 |" j  r; k* B
% t8 }/ E8 J2 n4 g2 S  [! r% B四、读写 W25Q128 外部 Flash
4 F7 W% M8 [6 u7 [W25Q128.c

1. #include "W25Q128.h"
   * s! `7 J" Q9 Z8 |0 o
2. #include "SPI.h"
   
3. 
   
4. 
   ! O, `4 S- |" Z2 a6 ?4 ]
5. uint8_t W25Q128_ReadWriteByte(uint8_t TxData)//函数包装一下
   9 L0 f& f% K; e; h9 F/ \, ?! P
6. {     
   
7.          return SPI1_ReadWriteByte(TxData);                 
   
8. }
   
9. 
   4 s/ G" A# z+ t
10. 
    
11. uint16_t W25Q128_ReadID(void)//读取芯片ID
    5 N7 y9 k3 q9 r5 x2 M9 Y. O
12. {
    
13.         uint16_t Temp = 0;         
    . j6 O, C. k% U7 p6 c
14.         W25Q128_CS(0);                                    
    
15.         W25Q128_ReadWriteByte(W25X_ManufactDeviceID);//发送读取ID命令            
    
16.         W25Q128_ReadWriteByte(0x00);            
    
17.         W25Q128_ReadWriteByte(0x00);            
    4 l- d; ^  F* }( Q
18.         W25Q128_ReadWriteByte(0x00);                                    
    9 y4 k( M* ~6 C, b6 _" G7 y# L
19.         Temp|=W25Q128_ReadWriteByte(0xFF)<<8;  
    5 ^+ U, Y9 e$ s
20.         Temp|=W25Q128_ReadWriteByte(0xFF);         
    / ^7 S" U) M# _6 U
21.         W25Q128_CS(1);                                    
    / a6 N5 F# B' F. C) F4 R
22.         return Temp;
    ! G6 Z- e5 h2 r1 O4 t
23. }
    & }2 n1 O) R5 J. b- Q, j
24. 
    % `4 o* D0 H+ N9 d& [
25. //读取W25Q128的状态寄存器
    : R1 K! Z/ c: d7 u0 ]( M5 R- _
26. //BIT7  6   5   4   3   2   1   0
    
27. //SPR   RV  TB BP2 BP1 BP0 WEL BUSY
    $ K8 [+ {2 h: a. Z+ L# P1 ~
28. //SPR:默认0,状态寄存器保护位,配合WP使用
    
29. //TB,BP2,BP1,BP0:FLASH区域写保护设置
    
30. //WEL:写使能锁定
    
31. //BUSY:忙标记位(1,忙;0,空闲)
    0 H8 ]- ~( B( t6 Y( v) e1 S* G
32. //默认:0x00
    . d4 Y+ D$ N8 ~/ b( i' E% U
33. uint8_t W25Q128_ReadSR(void)//读取状态寄存器
    
34. {
    
35.     uint8_t byte=0;
    + @, W: F0 t9 s$ g2 e# `
36.     W25Q128_CS(0);                               //使能器件
    $ r: N. t) j/ ?
37.     W25Q128_ReadWriteByte(W25X_ReadStatusReg1);  //发送读取状态寄存器命令
    
38.     byte=W25Q128_ReadWriteByte(0Xff);            //读取一个字节
    
39.     W25Q128_CS(1);                               //取消片选
    9 v& p5 F0 f( s
40.     return byte;
    
41. }
    
42. 
    
43. //写W25Q128状态寄存器
      g# }) Y" E4 ?4 f* u8 l5 o0 H
44. //只有SPR,TB,BP2,BP1,BP0(bit 7,5,4,3,2)可以写!!!
    
45. void W25Q128_WriteSR(uint8_t sr)//写状态寄存器
    ( G5 X4 g' O3 d# S4 X
46. {
    : u6 T- r" {2 V3 I1 m+ F
47.     W25Q128_CS(0);                                           //使能器件
    , ~( q% W/ h5 ?2 \
48.     W25Q128_ReadWriteByte(W25X_WriteStatusReg1);        //发送写取状态寄存器命令
    7 c4 ~, I7 G+ x5 Y1 r, c
49.     W25Q128_ReadWriteByte(sr);                               //写入一个字节
    5 j) h$ S( e2 q% {' u0 z$ T
50.     W25Q128_CS(1);                                            //取消片选
    ' z. C' J/ X0 J% q7 ]1 Z2 c* d2 a
51. }
    
52. 
    , u; G+ D' F8 U; h- F3 _* j
53. void W25Q128_Write_Enable(void) //写使能
    2 U6 b  V; q# B
54. {
    ! U/ }4 k& P5 e5 _; S2 o
55.            W25Q128_CS(0);        
    ) h0 m0 N% {7 D! P- k+ p' @( z1 t, n; r
56.         W25Q128_ReadWriteByte(W25X_WriteEnable);
    
57.         W25Q128_CS(1);        
    
58. }
    ' X, ?5 B& {  s* I
59. 
    7 q( ^/ H) V6 q+ }% b
60. void W25Q128_Write_Disable(void) //禁止写入        
    % C' K1 A( u% ^8 X2 d- p: i1 Y
61. {
    
62.            W25Q128_CS(0);        
    " s7 e9 [& L$ Y4 r# ~) o4 A2 C
63.         W25Q128_ReadWriteByte(W25X_WriteDisable);
    . Y1 B$ u) E- ]
64.         W25Q128_CS(1);        
    
65. }
    
66. 
    
67. void W25Q128_Read(uint8_t* pBuffer,uint32_t ReadAddr,uint16_t NumByteToRead)   
    ! E3 B- J) n+ q- w) V
68. {                                                     
    
69.         W25Q128_CS(0);                                  //使能器件   
    7 c, r  p- \+ J2 j) R6 }  D
70.     W25Q128_ReadWriteByte(W25X_ReadData);      //发送读取命令  
    
71.     W25Q128_ReadWriteByte((uint8_t)((ReadAddr)>>16));   //发送24bit地址   
      o& Y2 R0 T4 z% l$ o) W2 z! m
72.     W25Q128_ReadWriteByte((uint8_t)((ReadAddr)>>8));   
    
73.     W25Q128_ReadWriteByte((uint8_t)ReadAddr);   
    
74.     for(uint16_t i=0;i<NumByteToRead;i++)
    % f6 S  I3 d& d4 X5 U
75.         {
    , H6 j  C9 L" P
76.        pBuffer<i>=W25Q128_ReadWriteByte(0XFF);    //循环读数  
    4 X6 v: z5 X0 Q4 q
77.     }
    
78.         W25Q128_CS(1);                                                  
    . J/ m" m& C% K7 _3 g3 \
79. }  
    
80. 
    - {0 \( M6 ]& b, T( ?" }+ U
81. 
    
82. void W25Q128_Write_Page(uint8_t* pBuffer,uint32_t WriteAddr,uint16_t NumByteToWrite)
    6 `2 l- {& q% U# h+ {
83. {
    8 J4 k* l2 p8 j9 e+ C' D) |1 N* r0 Y
84. 
    
85.     W25Q128_Write_Enable();                  //SET WEL
    
86.         W25Q128_CS(0);                            //使能器件   
    5 T( j$ |* o+ y. q
87.     W25Q128_ReadWriteByte(W25X_PageProgram);   //发送写页命令   
    
88. 
    . e1 J$ r) g7 o
89.     W25Q128_ReadWriteByte((uint8_t)((WriteAddr)>>16)); //发送24bit地址   
    . v3 }. |" Y( T* i; G, k$ M
90.     W25Q128_ReadWriteByte((uint8_t)((WriteAddr)>>8));   
    - u4 W* {6 a0 K7 b3 M4 e) N
91.     W25Q128_ReadWriteByte((uint8_t)WriteAddr);   
    # y5 m( n( G1 K( a
92.     for(uint16_t i=0;i<NumByteToWrite;i++)
    * E  Z% z7 [9 `
93.         {
    
94.                 W25Q128_ReadWriteByte(pBuffer<i>);//循环写数  
    ! S6 d+ [, O' ~) E* e5 I; ^/ N
95.         }
      N- S& Y4 _8 s. U  j
96.         W25Q128_CS(1);                            //取消片选
    
97.         W25Q128_Wait_Busy();                                           //等待写入结束
    
98. }
    
99. 
    
100. //无检验写SPI FLASH
     
101. //必须确保所写的地址范围内的数据全部为0XFF,否则在非0XFF处写入的数据将失败!
     : u; ]4 \/ C# p+ F
102. //具有自动换页功能
     / Q  C% M# z9 {" x( r( y
103. void W25Q128_Write_NoCheck(uint8_t* pBuffer,uint32_t WriteAddr,uint16_t NumByteToWrite)   
     
104. {                                          
     
105.         uint16_t pageremain=256-WriteAddr%256; //单页剩余的字节数                             
     
106.         if(NumByteToWrite<=pageremain)pageremain=NumByteToWrite;//不大于256个字节
     
107.         while(1)
     ( `6 {* Y: [- H/ [2 d9 A) l
108.         {           
     
109.                 W25Q128_Write_Page(pBuffer,WriteAddr,pageremain);
       k6 H/ U# ?7 C! K# C
110.                 if(NumByteToWrite==pageremain)        break;//写入结束了
     , Q  w% d1 ?& r8 }+ j
111.                  else
     $ g) ?: L" d" y" W; ]
112.                 {
     
113.                         pBuffer+=pageremain;
     * e% P' X* h. d* }7 D# z  j) p. Z
114.                         WriteAddr+=pageremain;        
     ( {  \, e! J. L9 `% E4 U
115.                         NumByteToWrite-=pageremain;                          //减去已经写入了的字节数
     
116.                         if(NumByteToWrite>256)pageremain=256; //一次可以写入256个字节
     % A# d6 |" W7 r7 f! U
117.                         else pageremain=NumByteToWrite;           //不够256个字节了
     
118.                 }
     
119.         }            
     
120. }
     
121. 
     
122. //写SPI FLASH  
     + q' S, t( {1 v. k
123. //在指定地址开始写入指定长度的数据
     " M( o# m" O' o1 Z( s
124. //该函数带擦除操作!
     
125. //pBuffer:数据存储区
     / t9 S0 h! H7 N- n' V. r! k
126. //WriteAddr:开始写入的地址(24bit)                                                
     
127. //NumByteToWrite:要写入的字节数(最大65535)   
     # f; v% z& R7 w9 s/ K0 Y3 W0 ^
128. uint8_t W25Q128_BUFFER[4096];                 
     . @1 k. |5 S5 [3 }! g* p
129. void W25Q128_Write(uint8_t* pBuffer,uint32_t WriteAddr,uint16_t NumByteToWrite)   
     " Y, o& z6 L& [" a1 R) Q
130. {
     
131.          uint16_t i;   
     
132.         uint8_t * W25Q128_BUF;         
     
133.     W25Q128_BUF=W25Q128_BUFFER;            
     
134.          uint32_t secpos = WriteAddr/4096;//扇区地址  
     
135.         uint16_t secoff = WriteAddr%4096;//在扇区内的偏移
     
136.         uint16_t secremain = 4096-secoff;//扇区剩余空间大小   
       V; x" K/ c5 Y) o; C- t. o
137. 
     
138.          if(NumByteToWrite<=secremain)                secremain=NumByteToWrite;//不大于4096个字节
     ( ~4 u9 J" Q3 Z  |! c( Y6 e
139.         while(1)
     
140.         {        
     
141.                 W25Q128_Read(W25Q128_BUF,secpos*4096,4096);//读出整个扇区的内容
     
142.                 for(i=0;i<secremain;i++)//校验数据
       m: u, I( ?6 K. M
143.                 {
     
144.                         if(W25Q128_BUF[secoff+i]!=0XFF)        break;//需要擦除            
     - C4 F  m. x; l( G7 R
145.                 }
     0 C2 ~) z; T0 O( x! r0 }! q9 H
146.                 if(i<secremain)//需要擦除
     + t; C! a2 o/ k4 P5 U
147.                 {
     
148.                         W25Q128_Erase_Sector(secpos*4096);//擦除这个扇区
     9 G0 a+ |8 @0 u7 L
149.                         for(i=0;i<secremain;i++)           //复制
     
150.                         {
     
151.                                 W25Q128_BUF[i+secoff]=pBuffer<i>;         
     7 }, U6 X, n% W6 J# l/ u% Y
152.                         }
     
153.                         W25Q128_Write_NoCheck(W25Q128_BUF,secpos*4096,4096);//写入整个扇区  
     
154. 
     " R8 c/ [$ w  n
155.                 }else W25Q128_Write_NoCheck(pBuffer,WriteAddr,secremain);//写已经擦除了的,直接写入扇区剩余区间.                                    
     
156.                 if(NumByteToWrite==secremain)        break;//写入结束了
     
157.                 else//写入未结束
     ( Z- ]+ M8 D$ \" I3 x) d+ E
158.                 {
     4 a8 S- ~2 H# ]/ M
159.                         secpos++;//扇区地址增1
     
160.                         secoff=0;//偏移位置为0         
     - [8 Y9 e. b( F. ]; l$ ^9 h6 i
161. 
     
162.                     pBuffer+=secremain;  //指针偏移
     
163.                         WriteAddr+=secremain;//写地址偏移           
     
164.                     NumByteToWrite-=secremain;                                //字节数递减
     + G; U: Y- Z2 ]( N
165.                         if(NumByteToWrite>4096)        secremain=4096;        //下一个扇区还是写不完
     5 I, G' s; M) j  A0 Z, m
166.                         else         secremain=NumByteToWrite;                //下一个扇区可以写完了
     
167.                 }         
     
168.         }         
     
169. }
     
170. 
     
171. //擦除一个扇区
     
172. //Dst_Addr:扇区地址 根据实际容量设置
     
173. //擦除一个扇区的最少时间:150ms
     
174. 
     
175. void W25Q128_Erase_Sector(uint32_t Dst_Addr)   
     5 H: s- Z; |: \0 a; A
176. {  
     
177.     W25Q128_Write_Enable();                  //SET WEL         
     
178.     W25Q128_Wait_Busy();   
     * a/ g# D1 o! U3 y; q& l
179.           W25Q128_CS(0);                            //使能器件   
     , ~3 E8 T/ e( a- e6 a2 {
180.     W25Q128_ReadWriteByte(W25X_SectorErase);   //发送扇区擦除指令
     / [" o" r+ L  P" S
181.     W25Q128_ReadWriteByte((uint8_t)((Dst_Addr)>>16));  //发送24bit地址   
     
182.     W25Q128_ReadWriteByte((uint8_t)((Dst_Addr)>>8));   
     - Y# l9 o! j) o
183.     W25Q128_ReadWriteByte((uint8_t)Dst_Addr);  
     
184.         W25Q128_CS(1);                                    //取消片选                  
     ' v5 x/ Y8 M  i
185.     W25Q128_Wait_Busy();                                               //等待擦除完成
     
186. }  
     
187. 
       V7 q  @: k! [
188. //擦除整个芯片                  
     % X5 j' _& i/ Z/ J9 m1 v! k
189. //等待时间超长...
     ) N7 Z$ T7 d& |+ e' t3 i6 D
190. void W25Q128_Erase_Chip(void)   
     0 D$ q2 z0 q7 a
191. {                                   
     6 `* P, |4 W/ h' |
192.     W25Q128_Write_Enable();                  //SET WEL
     
193.     W25Q128_Wait_Busy();   
     
194.           W25Q128_CS(0);                           //使能器件   
     
195.     W25Q128_ReadWriteByte(W25X_ChipErase);   //发送片擦除命令  
     
196.         W25Q128_CS(1);                           //取消片选                  
     3 w& h5 l, u( w5 @1 k, t
197.         W25Q128_Wait_Busy();                                              //等待芯片擦除结束
     
198. }
     
199. 
     5 {( o5 w3 x3 b4 ^( D2 n
200. 
     % }' M  W. E3 ~$ h# x+ Q
201. //等待空闲
     
202. void W25Q128_Wait_Busy(void)   
     
203. {   
     % S7 q" L2 f1 [' b+ J, x) j
204.         while((W25Q128_ReadSR()&0x01)==0x01);   // 等待BUSY位清空
     
205. }  
     
206. 
     
207. //进入掉电模式
     
208. void W25Q128_PowerDown(void)   
     
209. {
     
210.           W25Q128_CS(0);                            //使能器件   
     
211.     W25Q128_ReadWriteByte(W25X_PowerDown);    //发送掉电命令  
     
212.         W25Q128_CS(1);                            //取消片选                  
     4 M9 `* x3 A/ c
213. }   
     : a3 x3 s: m& ^' r: O" U+ {! g
214. //掉电唤醒
     
215. void W25Q128_WAKEUP(void)   
     
216. {  
     2 {- M6 U( |  Z
217.           W25Q128_CS(0);                                //使能器件   
     % a- J; H& a% u
218.     W25Q128_ReadWriteByte(W25X_ReleasePowerDown);   
     
219.         W25Q128_CS(1);                                //取消片选                  
     * a" D8 ~' W1 Y  d. A4 V! r/ l
220. }   </i></i></i>

复制代码

" A+ l/ d- A  O' I: SW25Q128.h
; ]$ T* S1 Q9 R. K. }  S+ Z#ifndef __W25Q128_H
5 V# k9 b7 c7 s#define        __W25Q128_H

' S0 F0 F7 ~! }, l#include "stm32f10x.h"
$ ~7 f- l/ E$ c9 X3 X7 @$ Y, U
2 {+ _) i3 j% x$ }//操作指令表
, [  S# A- G. F. Q' s' D, @, M#define W25X_WriteEnable                           0x06         //写使能
) G4 F; r1 Z3 J, E. J' n#define W25X_WriteDisable                           0x04         //写禁止
" }2 S  c. M8 E* S( L" v#define W25X_ReadStatusReg1                         0x05         //读状态寄存器1
#define W25X_ReadStatusReg2                         0x35         //读状态寄存器2
0 p. n, l! s% T3 o( _, P#define W25X_ReadStatusReg3                         0x15         //读状态寄存器3
% o. a  f. ]! W' c. v! N9 z#define W25X_WriteStatusReg1                   0x01         //写状态寄存器1
' e; f9 f5 G4 T! i- D#define W25X_WriteStatusReg2                   0x31         //写状态寄存器2
#define W25X_WriteStatusReg3                   0x11         //写状态寄存器3
#define W25X_ReadData                                0x03         //读数据
#define W25X_FastReadData                           0x0B         //快读
5 L0 a# r; O. I; C#define W25X_FastReadDual                           0x3B    //双输出快读
% K* R1 \# _# r#define W25X_PageProgram                           0x02         //页编程
9 o- V3 f  n, |; l, }#define W25X_BlockErase                                   0xD8         //块擦除（64K）
+ d' ~7 |2 @" V' G, B#define W25X_SectorErase                           0x20    //扇区擦除（4K）
6 n1 m* Y( M1 ^, K0 K$ m! d#define W25X_ChipErase                                   0xC7    //芯片擦除
#define W25X_PowerDown                                   0xB9    //掉电
#define W25X_ReleasePowerDown                 0xAB    //释放掉电
- q! @6 z+ T0 `/ ^& Y#define W25X_DeviceID                            0xAB    //器件ID
#define W25X_ManufactDeviceID                 0x90    //制造商+设备ID
1 H5 _5 G' K+ S! b( q0 H$ |% B#define W25X_JedecDeviceID                         0x9F         //电子元件ID


#define W25Q128_CS(a) SPI_CS(a)        

( W, F' U8 H' \8 c, h
uint8_t W25Q128_ReadWriteByte(uint8_t TxData);//函数包装一下
8 p( G' h; K% A$ N. H1 y7 B
, g3 a+ ^. b8 ?& N3 ?uint16_t W25Q128_ReadID(void);//读取芯片ID
, A5 Z6 @- _  ^( b
uint8_t W25Q128_ReadSR(void);//读取状态寄存器
void W25Q128_WriteSR(uint8_t sr);//写状态寄存器
; R- p. i2 L4 ]+ O9 O6 i+ G
void W25Q128_Write_Enable(void);//写使能
void W25Q128_Write_Disable(void);//禁止写入        

void W25Q128_Read(uint8_t* pBuffer,uint32_t ReadAddr,uint16_t NumByteToRead); //读取数据
8 L2 o" V/ U0 {9 K7 B, `void W25Q128_Write_Page(uint8_t* pBuffer,uint32_t WriteAddr,uint16_t NumByteToWrite);//页写
+ ?0 ]2 x. B  y* V8 dvoid W25Q128_Write_NoCheck(uint8_t* pBuffer,uint32_t WriteAddr,uint16_t NumByteToWrite);//无检验写数据，可自动翻页
) K1 \( ?  C, F* R- Lvoid W25Q128_Write(uint8_t* pBuffer,uint32_t WriteAddr,uint16_t NumByteToWrite);//写入数据，带擦写功能
* S5 z7 P; N! k. A
void W25Q128_Erase_Sector(uint32_t Dst_Addr);//擦除扇区
; v5 P0 m/ |7 ]3 lvoid W25Q128_Erase_Chip(void);//擦除整个芯片        

void W25Q128_Wait_Busy(void);//等待空闲
void W25Q128_PowerDown(void); //进入掉电模式
void W25Q128_WAKEUP(void);//掉电唤醒

' |' z8 E; |8 s$ A& r#endif
- r' R9 Z' f6 X" V
1 J* @. c. t& t9 z2 m3 j2 B( Q1
( W' f& y- G  O$ h% R2
3
  h3 L  q4 b% C4
, a! x: A, ~/ _& E5
7 U: V4 H. B! d* m/ _' O6
' I; S, E; X- j1 j7 S, J$ ]- v9 j7
( h8 t* ~" b- s0 }  x( I* \8
9
10
& D5 _+ V2 G8 ]3 b/ h1 F11
12
/ H5 @* T* \- p4 X; t13
14
  Q7 `: G% c: Y5 N7 h15
! H+ G* y$ `: z7 ]' m3 v7 m* \16
! J( ?2 x2 b3 R! T+ t17
18
2 B. T7 E. F5 b/ N% v3 l19
5 o/ e" k( K* l/ `20
6 g4 O! P' z# L0 t21
22
- F+ r) `4 c" T/ v+ J" g23
3 I1 l& N% u) w24
8 ^9 Z& \0 e) u, N% ^# O% p  n! L25
26
' `- P4 a7 ]4 H- S4 _1 [27
& p8 T8 l' a- j8 g28
6 O* v8 g/ |7 O  I" i7 y29
$ Z8 Z5 T' `0 n) O2 O30
# R9 @2 M* ]3 }' S* M5 M. C( S( `% d31
& w2 ?" U4 T( @# ]32
33
$ F2 U, m5 j- T: a% n34
5 r- `: _, E; n3 H* p$ e35
8 U4 ]) d8 K5 A& N36
37
, q' j! C3 X% c! h$ p38
39
40
41
42
43
" q4 v+ n7 o; i+ T, ]' K% b44
  j% ?( Q3 K! Q$ w: ~( a' _  X45
46
$ U7 g" d' I; A47
6 @, D$ Q) O% v2 Z9 r/ i7 K! H4 i48
49
50
51
52
: V% |+ g% c5 Q5 `& h5 b53
0 o5 e  @; y2 u" q9 }54
main.c
#include <stdio.h>
#include "Uart1.h"
#include "delay.h"
. N1 _: O. f# X: Q- @#include "SPI.h"
#include "W25Q128.h"

% a/ @$ M9 |8 S6 `/ o( P! ]8 puint16_t W25Q128_ID=0;
uint8_t Write_data[20]={1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20};
uint8_t Read_data[100];
6 k) P) U; ^7 {0 @2 C6 _
6 Z0 f+ }/ L$ sint main (void)
{
+ p1 {8 e0 T' p: J. q/ N6 H7 B        Uart1_init();
        SPI1_Init();
        
        W25Q128_ID=W25Q128_ReadID();
% a# B: Q) V3 w. F0 c( `" I" ^5 l3 Z( N) e        W25Q128_Write_Page(Write_data,0x01,20);
        
; K& f9 Q5 b! l        while(1)
% X( n- o& ]9 C: H# s; Z  _! s; {        {
                W25Q128_Read(Read_data,0x00,100);
                for(int i=0;i<100;i++)
: v! x3 R5 n0 c                {
/ q2 z4 C/ h7 w3 i7 a                        printf(" 0x%X ",Read_data);
/ q  X' P; G6 @0 v) z* x                }
; u& I; ^7 e! e4 ^: {0 x                printf("\nW25Q128_ID=0x%X\n",W25Q128_ID);
" y# Z4 ?4 e4 \7 c+ y, I                delay_ms(500);
        }
0 s! r& H8 F! U}
) d7 O  Z$ y1 y5 Q, U6 Q
) L, {8 N& t  M1
2
: T, i- K0 `6 x8 B" ~3
4 F+ `* H+ ~# i5 y" T4
5
6
7
8
# O' n) t9 E1 C4 u7 q9
10
7 ^# l& d( I, d5 ]' a( j, C11
12
13
14
15
1 [+ i3 H, B9 g" l( B! e) ~: u16
17
18
# K$ H* t! `; C; r% o- X2 Y19
+ X8 d2 ~. f3 V: ^' r20
21
8 W+ s8 b$ p6 u! k& k6 b22
! R- F  d. R: ~) I( e# Q2 N7 o& {23
24
1 C2 n! y2 q7 A( ^+ b; x. a25
26
+ Z- T/ o8 k, L3 G, f$ D27
28
29
2 U+ A- E7 M, P: ]' z; \$ _实验结果
% _) {& P; S. k% [
. K. J: i# Y. n0 S6 j* ^8 }————————————————
版权声明：根号五
( u2 \! |) e0 ~8 P: c
/ t  U, O7 r' I  o9 \* c