一、SPI介绍
SPI 是英语Serial Peripheral interface的缩写，顾名思义就是串行外围设备接口。是Motorola首先在其MC68HCXX系列处理器上定义的。SPI，是一种高速的，全双工，同步的通信总线，并且在芯片的管脚上只占用四根线，节约了芯片的管脚，同时为PCB的布局上节省空间，提供方便，主要应用在 EEPROM，FLASH，实时时钟，AD转换器，还有数字信号处理器和数字信号解码器之间。

& ?- d& ], l0 d2 Q7 S7 r正是简单易用的特性，如NRF24L01、VS1053、SD卡等皆集成了这种通信协议
; _% x& z: ^7 \. p


二、SPI接口框图

2 @% L# b/ |. L, \
: _$ A. M0 e3 L" G8 F  J0 W
; B. G' l1 ~) x' k# P三、SPI优缺点
SPI接口是在CPU和外围低速器件之间进行同步串行数据传输，在主器件的移位脉冲下，数据按位传输，低位在前，高位在后，为全双工通信，数据传输速度总体来说比I2C总线要快，速度可达到几Mbps。

' q( R" s& l) F5 w信号线少，协议简单，相对数据速率高。
  u0 R/ T" ?" v& s$ F$ H4 P
缺点：没有指定的流控制，没有应答机制确认是否接收到数据
* D9 q% E3 \4 X1 _
8 ]/ D7 B% U/ e( n4 x0 i, S8 a四、SPI工作原理总结
+ W" G! X3 c! v7 U硬件上为4根线。
主机和从机都有一个串行移位寄存器，主机通过向它的SPI串行寄存器写入一个字节来发起一次传输。
- C) \, t5 e" I5 {串行移位寄存器通过MOSI信号线将字节传送给从机，从机也将自己的串行移位寄存器中的内容通过MISO信号线返回给主机。这样，两个移位寄存器中的内容就被交换。
外设的写操作和读操作是同步完成的。如果只进行写操作，主机只需忽略接收到的字节；反之，若主机要读取从机的一个字节，就必须发送一个空字节来引发从机的传输。
$ P3 t* H2 z# Q; {) k6 ]/ X多个设备使用SPI的应用举例


7 P) b$ o/ X# k; K8 f
5 e1 R. Y- Z/ |: s6 d# U五、时序图
时序为 SPI_CR1 寄存器中的 LSBFIRST 位复位时的时序
) a, w0 w( o$ _1 O, V% b( ]$ ^6 X) t1 B* }
3 V% I0 G' O2 y# C/ D% DSPI_CPHA的值将会影响SPI_CPOL的值
. F4 f  k& }5 y/ J5 I* R, R
- T* k2 {: y$ M5 m  L9 A
  g* ]  t% J( N! N2 S
六、SPI程序编写过程

1. //①使能SPIx和IO口时钟
   
2. RCC_AHBxPeriphClockCmd() / RCC_APBxPeriphClockCmd();
   * [# p. g1 p: q% X
3. 
   6 ?8 L  s4 v- x5 g; W( x2 B5 \
4. //②初始化IO口为复用功能
   
5. void GPIO_Init(GPIO_TypeDef* GPIOx, GPIO_InitTypeDef* GPIO_InitStruct);
   4 J0 |8 }. \; F5 m7 [. p; E
6. 
   
7. //③设置引脚复用映射：
   
8. GPIO_PinAFConfig();
   
9. 
   
10. //②初始化SPIx,设置SPIx工作模式
    * F: ?: @2 Q9 N( ~: Z; y. t
11. void SPI_Init(SPI_TypeDef* SPIx, SPI_InitTypeDef* SPI_InitStruct);
    
12. 
    
13. //③使能SPIx
    6 }7 ]. ]7 N) Y
14. void SPI_Cmd(SPI_TypeDef* SPIx, FunctionalState NewState);
    
15. 
    9 I4 C. f3 S( O! M/ d- k& B+ d
16. //④SPI传输数据
    
17. void SPI_I2S_SendData(SPI_TypeDef* SPIx, uint16_t Data);
    
18. uint16_t SPI_I2S_ReceiveData(SPI_TypeDef* SPIx) ;
    
19. 
    
20. //⑦查看SPI传输状态
    
21. SPI_I2S_GetFlagStatus(SPI2, SPI_I2S_FLAG_RXNE);

复制代码

1. SPI.c:
   
2. #include "spi.h"
   ' l, B0 Y1 X2 @% g& r
3. 
   
4. //以下是SPI模块的初始化代码，配置成主机模式                                                   
   
5. //SPI口初始化
   
6. //这里针是对SPI1的初始化
   
7. void SPI1_Init(void)
   
8. {         
   + q! R/ f1 x, i2 ~
9.   GPIO_InitTypeDef  GPIO_InitStructure;
   
10.   SPI_InitTypeDef  SPI_InitStructure;
    % E" I3 t% A- r- u# u- }5 Q
11.         
    $ ^* O' ]+ S: w9 j9 [
12.   RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOB, ENABLE);//使能GPIOB时钟
    ( W" U$ O# G; `) l
13.   RCC_APB2PeriphClockCmd(RCC_APB2Periph_SPI1, ENABLE);//使能SPI1时钟
    % r  c) v0 v( W
14. 
    3 y8 S. [2 I+ S. a0 n
15.   //GPIOFB3,4,5初始化设置
    # ?/ w! _! C- y0 J& t2 A
16.   GPIO_InitStructure.GPIO_Pin = GPIO_Pin_3|GPIO_Pin_4|GPIO_Pin_5;//PB3~5复用功能输出        
    
17.   GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF;//复用功能
      |8 k3 h8 S( y, X5 y
18.   GPIO_InitStructure.GPIO_OType = GPIO_OType_PP;//推挽输出
    - b1 l, Z- v5 F1 `: p
19.   GPIO_InitStructure.GPIO_Speed = GPIO_Speed_100MHz;//100MHz
    5 ~* d. @) u1 V' Q" \8 c; [1 y  K
20.   GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_UP;//上拉
    
21.   GPIO_Init(GPIOB, &GPIO_InitStructure);//初始化
    9 ^6 t0 e; C8 l0 G- `/ h! e1 s
22.         
    7 I, @3 B3 p1 ^: ~& r. f
23.         GPIO_PinAFConfig(GPIOB,GPIO_PinSource3,GPIO_AF_SPI1); //PB3复用为 SPI1
    ( P+ |+ y/ t4 ~4 q
24.         GPIO_PinAFConfig(GPIOB,GPIO_PinSource4,GPIO_AF_SPI1); //PB4复用为 SPI1
    
25.         GPIO_PinAFConfig(GPIOB,GPIO_PinSource5,GPIO_AF_SPI1); //PB5复用为 SPI1
    
26. 
    
27.         //这里只针对SPI口初始化
    
28.         RCC_APB2PeriphResetCmd(RCC_APB2Periph_SPI1,ENABLE);//复位SPI1
    
29.         RCC_APB2PeriphResetCmd(RCC_APB2Periph_SPI1,DISABLE);//停止复位SPI1
    ' `1 E* N' q  A* J* _. B. l4 r
30. 
    
31.         SPI_InitStructure.SPI_Direction = SPI_Direction_2Lines_FullDuplex;  //设置SPI单向或者双向的数据模式:SPI设置为双线双向全双工
    3 x/ \# x% s9 q
32.         SPI_InitStructure.SPI_Mode = SPI_Mode_Master;                //设置SPI工作模式:设置为主SPI
    , F; I) \6 L9 ?1 y
33.         SPI_InitStructure.SPI_DataSize = SPI_DataSize_8b;                //设置SPI的数据大小:SPI发送接收8位帧结构
    
34.         SPI_InitStructure.SPI_CPOL = SPI_CPOL_High;                //串行同步时钟的空闲状态为高电平
    , w! P* o) L- }7 Q, L
35.         SPI_InitStructure.SPI_CPHA = SPI_CPHA_2Edge;        //串行同步时钟的第二个跳变沿（上升或下降）数据被采样
    $ g1 D; i  c, k! C# w
36.         SPI_InitStructure.SPI_NSS = SPI_NSS_Soft;                //NSS信号由硬件（NSS管脚）还是软件（使用SSI位）管理:内部NSS信号有SSI位控制
    7 D' C: m  h  w" J. K) P+ s
37.         SPI_InitStructure.SPI_BaudRatePrescaler = SPI_BaudRatePrescaler_256;                //定义波特率预分频的值:波特率预分频值为256
    
38.         SPI_InitStructure.SPI_FirstBit = SPI_FirstBit_MSB;        //指定数据传输从MSB位还是LSB位开始:数据传输从MSB位开始
    
39.         SPI_InitStructure.SPI_CRCPolynomial = 7;        //CRC值计算的多项式
    & v7 P( S+ F4 A' d) C1 H& F
40.         SPI_Init(SPI1, &SPI_InitStructure);  //根据SPI_InitStruct中指定的参数初始化外设SPIx寄存器
    
41. 
    ; ^( f: ~4 L4 C" k# V0 v! o! n
42.         SPI_Cmd(SPI1, ENABLE); //使能SPI外设
    3 c8 H4 j' u; P7 F. v
43. 
    % C+ y" k& O. Y3 ~! f- Z& a6 ~( b7 K) p
44.         SPI1_ReadWriteByte(0xff);//启动传输                 
    
45. }   
    - q) W/ ?- [0 p# F- Q( @
46. //SPI1速度设置函数
    
47. //SPI速度=fAPB2/分频系数
    . Y( Z' C" }7 G' N& c8 E* J
48. //@ref SPI_BaudRate_Prescaler:SPI_BaudRatePrescaler_2~SPI_BaudRatePrescaler_256  
    2 D  _5 ~0 v+ W3 e( M6 z
49. //fAPB2时钟一般为84Mhz：
    
50. void SPI1_SetSpeed(u8 SPI_BaudRatePrescaler)
    ) \9 l" }1 l8 S: k5 p
51. {
    : P6 y9 r7 {3 P! v3 G
52.   assert_param(IS_SPI_BAUDRATE_PRESCALER(SPI_BaudRatePrescaler));//判断有效性
    9 U9 S+ s0 @& `- t, T6 X
53.         SPI1->CR1&=0XFFC7;//位3-5清零，用来设置波特率
    & T. j6 o- ~2 a3 Z% R6 U
54.         SPI1->CR1|=SPI_BaudRatePrescaler;        //设置SPI1速度
    % w% b2 H2 H* }; W6 Z2 M
55.         SPI_Cmd(SPI1,ENABLE); //使能SPI1
    * z' M3 Q: }6 ?$ D
56. }
    
57. //SPI1 读写一个字节
    
58. //TxData:要写入的字节
    : v; V: ~% k6 N) s
59. //返回值:读取到的字节
    ' s2 @) v+ H- Y. r- u: M- d5 ^
60. u8 SPI1_ReadWriteByte(u8 TxData)
    $ }* C. q  F$ y2 O$ u
61. {                                          
    
62. 
    
63.   while (SPI_I2S_GetFlagStatus(SPI1, SPI_I2S_FLAG_TXE) == RESET){}//等待发送区空  
    
64.         
    : E+ I0 S, r! T% v+ t; w
65.         SPI_I2S_SendData(SPI1, TxData); //通过外设SPIx发送一个byte  数据
    
66.                
    
67.   while (SPI_I2S_GetFlagStatus(SPI1, SPI_I2S_FLAG_RXNE) == RESET){} //等待接收完一个byte  
    8 f$ w3 B# M; I, _, I9 Q
68. 
    4 s1 j3 j9 ~4 a5 t
69.         return SPI_I2S_ReceiveData(SPI1); //返回通过SPIx最近接收的数据        
    
70.                      
    % y3 W4 I% ^$ H+ [
71. }
    / D9 E* u; Q8 v* j) ]
72. 
    

复制代码

七、W25Q12xx的原理及应用
W25Q128将16M的容量分为256个块（Block),每个块大小为64K字节，每个块又分为16个扇区（Sector),每个扇区4K个字节。W25Q128的最小擦除单位为一个扇区，也就是每次必须擦除4K个字节。这样我们需要给W25Q128开辟一个至少4K的缓存区，这样对SRAM要求比较高，要求芯片必须有4K以上SRAM才能很好的操作。
2 e0 H; m, ~( d! ~) U2 p7 E/ h
W25Q128的擦写周期多达10W次，具有20年的数据保存期限，支持电压为2.7~3.6V,W25Q128支持标准的SPI,还支持双输出/四输出的SPI,最大SPI时钟可以到80Mhz(双输出时相当于160Mhz,四输出时相当于320M),更多的W25Q128的介绍，请参考W25Q128的DATASHEET。
/ L2 }, N  T3 S" v" D* R% M$ V* t

* y% t- W$ I8 x1 d5 S3 ?3 g/ o
5 V* D3 Y1 |2 |4 w2 r% ~! e0 s4 }W25Q12xx可根据原理图查看，使用的是SPI总线通信协议

  W5 {( O1 _, x: i9 g* `比如原子的原理图


( C2 A4 C8 T; b7 C
. P) _3 N3 C& i3 N4 r7.1 分析W25Q128指令
0 y- c/ N; L( h/ g& Y$ ?& d8 P2 L可参考W25Qxx的数据手册，这里列出W25Q128部分指令：

. ^7 K' E, G3 C( X3 Q/ W% j

比如读取设备的ID的指令：0x90000000

8 X# T; V* F  v6 S# R
2 B% N9 k  I" u$ J% ?' A/ Y
! B1 @+ m; w( D2 K! e( E; N
/ y; b0 y+ |; _! U1 \4 i7 K) e# |2 @
; g. |' i% H5 D0 ~- q' k9 N! ~+ i0 z, L
" D/ s7 v: }9 |
5 g, }  v; M! H- K7.2 擦除扇区：
5 r1 N! Z9 Z/ k5 E! p9 V

9 x2 O5 i" m& @9 b* r  }
+ y' |  `" k% p6 F, i7.3 部分常用设备读取指令：


3 y& x8 X4 M7 @, E8 u
' t3 g, N. M$ L5 s每次操作前要使能写操作，且给一个低电平。结束时要给其为高电平，再失能写操作。也就是通过操作片选引脚来确定是否使能或失能。
' l3 ~# _6 n0 g
" k1 ^; l0 G! {
3 v, D, g& B( t! L3 A$ N
3 k/ X6 @0 ]; x  l( O

1. W25Q12xx.c:
   
2. #include "w25qxx.h"
   1 }8 n% {3 n. x3 m4 p9 b
3. #include "spi.h"
   
4. #include "delay.h"           
   , U# C4 d/ r/ U% E' ~/ p! Q0 H. U
5. #include "usart.h"        
   4 k$ k4 F- C  x: I. Z1 ?8 |. A. F
6. 
   
7. u16 W25QXX_TYPE=W25Q128;        //默认是W25Q128
   # }! [1 Z8 G9 L$ F& u0 E
8. 
   
9. //4Kbytes为一个Sector
   ; g% l8 f: I& v
10. //16个扇区为1个Block
    ' c3 y( o* Q' J1 q; \- T
11. //W25Q128
    . a2 q) E1 u+ B2 l9 g6 W
12. //容量为16M字节,共有128个Block,4096个Sector
    
13.                                                                                                          
    ! {; y, o% ^1 V/ i  C
14. //初始化SPI FLASH的IO口
    
15. void W25QXX_Init(void)
    - u9 x5 l6 }# z6 ~: y) ~
16. {
    ( [8 L6 s  H. d. `  m% E* q. F
17.   GPIO_InitTypeDef  GPIO_InitStructure;
    4 A  E* f' t% r  Q6 \
18. 
    & a9 A$ s7 [  B
19.   RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOB, ENABLE);//使能GPIOB时钟
    
20.   RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOG, ENABLE);//使能GPIOG时钟
    1 J, x# G" b9 r0 d4 R6 ?( [
21. 
    % b5 t' n6 C/ h6 m
22.           //GPIOB14
    $ \( M/ _2 I1 B( P" \; I& P- X
23.   GPIO_InitStructure.GPIO_Pin = GPIO_Pin_14;//PB14
    " u. j4 k& W: p( z5 e& S
24.   GPIO_InitStructure.GPIO_Mode = GPIO_Mode_OUT;//输出
    
25.   GPIO_InitStructure.GPIO_OType = GPIO_OType_PP;//推挽输出
    
26.   GPIO_InitStructure.GPIO_Speed = GPIO_Speed_100MHz;//100MHz
    & I3 A! }: [6 |  y0 K
27.   GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_UP;//上拉
    
28.   GPIO_Init(GPIOB, &GPIO_InitStructure);//初始化
    % N7 z. S; m' q/ D. J* q3 M
29. 
    
30.         GPIO_InitStructure.GPIO_Pin = GPIO_Pin_7;//PG7
    
31.   GPIO_Init(GPIOG, &GPIO_InitStructure);//初始化
    
32. 
    
33.         GPIO_SetBits(GPIOG,GPIO_Pin_7);//PG7输出1,防止NRF干扰SPI FLASH的通信
    
34.         W25QXX_CS=1;                        //SPI FLASH不选中
    + ~) S! j: N1 V+ }2 `
35.         SPI1_Init();                                           //初始化SPI
    1 C# Y' x8 K2 S9 u3 V
36.         SPI1_SetSpeed(SPI_BaudRatePrescaler_2);                //设置为42M时钟,高速模式
    
37.         W25QXX_TYPE=W25QXX_ReadID();        //读取FLASH ID.
    
38. }  
    
39. 
    
40. //读取W25QXX的状态寄存器
    , {, n+ c- ]! {) ~8 e% O
41. //BIT7  6   5   4   3   2   1   0
    0 J( j" ?- O7 A# `' ?
42. //SPR   RV  TB BP2 BP1 BP0 WEL BUSY
    
43. //SPR:默认0,状态寄存器保护位,配合WP使用
    
44. //TB,BP2,BP1,BP0:FLASH区域写保护设置
    
45. //WEL:写使能锁定
    - R- H- |  B9 E5 ^, [) b2 @" z6 E
46. //BUSY:忙标记位(1,忙;0,空闲)
    
47. //默认:0x00
    ) ]  h$ |1 ?) O$ \
48. u8 W25QXX_ReadSR(void)   
    5 w! q) q! d3 n8 T2 h
49. {  
    . }2 I9 m" u8 |6 S
50.         u8 byte=0;   
    
51.         W25QXX_CS=0;                            //使能器件   
    
52.         SPI1_ReadWriteByte(W25X_ReadStatusReg);    //发送读取状态寄存器命令   
    
53.         byte=SPI1_ReadWriteByte(0Xff);             //读取一个字节  
    4 _$ g; g+ j; l2 c4 r9 w
54.         W25QXX_CS=1;                            //取消片选     
    
55.         return byte;   
    ; z! z" I$ l5 h
56. }
    # g  v0 F0 w+ g0 [8 ~6 {
57. //写W25QXX状态寄存器
    / }% W0 C+ ]+ D/ i
58. //只有SPR,TB,BP2,BP1,BP0(bit 7,5,4,3,2)可以写!!!
    ( {! O3 o- W. \8 h
59. void W25QXX_Write_SR(u8 sr)   
    
60. {   
    
61.         W25QXX_CS=0;                            //使能器件   
    
62.         SPI1_ReadWriteByte(W25X_WriteStatusReg);   //发送写取状态寄存器命令   
    
63.         SPI1_ReadWriteByte(sr);               //写入一个字节  
    * @3 a) d" _. u7 L  {# n" N! E  ~
64.         W25QXX_CS=1;                            //取消片选                  
    
65. }   
    9 \6 q! r6 D/ w% T: t" W4 k
66. //W25QXX写使能        
    0 a/ R7 P  M8 u+ B: F# T5 i8 ^, I
67. //将WEL置位   
    
68. void W25QXX_Write_Enable(void)   
    0 }4 Z% w" m: w; F0 }2 d6 K
69. {
      h8 v0 P7 n1 p
70.         W25QXX_CS=0;                            //使能器件   
    2 v7 B1 U5 G' |9 m5 d2 T- l
71.     SPI1_ReadWriteByte(W25X_WriteEnable);      //发送写使能  
    1 c2 `, U: M% O  g
72.         W25QXX_CS=1;                            //取消片选                  
    
73. }
    
74. //W25QXX写禁止        
    
75. //将WEL清零  
    5 F8 G1 t; M6 g# {) f' b
76. void W25QXX_Write_Disable(void)   
    6 M; r9 ^0 O8 ~* l: ~2 S
77. {  
    * w$ M4 H- V0 y0 i: g9 |0 Q
78.         W25QXX_CS=0;                            //使能器件   
    # L4 J' Q2 [. |: A' ^# E9 W2 a" A% ?
79.     SPI1_ReadWriteByte(W25X_WriteDisable);     //发送写禁止指令   
    9 n- }: `$ y, h/ v* n! y* Z
80.         W25QXX_CS=1;                            //取消片选                  
    
81. }                 
    
82. //读取芯片ID
    
83. //返回值如下:                                   
    1 y- b( b$ b2 m) H7 g9 q
84. //0XEF13,表示芯片型号为W25Q80  
    + J  K& k3 X+ L2 B
85. //0XEF14,表示芯片型号为W25Q16   
    
86. //0XEF15,表示芯片型号为W25Q32  
    1 R* H  M1 U% N) ^) f& c: Q
87. //0XEF16,表示芯片型号为W25Q64
    
88. //0XEF17,表示芯片型号为W25Q128           
    
89. u16 W25QXX_ReadID(void)
    
90. {
    9 E0 E# f9 R4 g7 `& _: ?9 S/ e
91.         u16 Temp = 0;         
    , K/ c5 o6 h7 h1 ~
92.         W25QXX_CS=0;                                    
    
93.         SPI1_ReadWriteByte(0x90);//发送读取ID命令            
    
94.         SPI1_ReadWriteByte(0x00);            
    
95.         SPI1_ReadWriteByte(0x00);            
    ! t( Z2 |; ]& a* d
96.         SPI1_ReadWriteByte(0x00);                                    
    . f7 f8 R3 O. l4 R% g( ]
97.         Temp|=SPI1_ReadWriteByte(0xFF)<<8;  
    ) n9 l/ W# e" ^( O0 ?
98.         Temp|=SPI1_ReadWriteByte(0xFF);         
    / o) u& V7 K, \5 F# X2 E4 |  Z
99.         W25QXX_CS=1;                                    
    
100.         return Temp;
     
101. }                       
     
102. //读取SPI FLASH  
     
103. //在指定地址开始读取指定长度的数据
       K& h/ O) D/ ~$ \# z+ h* D
104. //pBuffer:数据存储区
     * g: U: C4 j, V% m
105. //ReadAddr:开始读取的地址(24bit)
     , {4 f9 S. f' n/ C% Y. X* i: T% z
106. //NumByteToRead:要读取的字节数(最大65535)
       n! q8 \; C7 Q
107. void W25QXX_Read(u8* pBuffer,u32 ReadAddr,u16 NumByteToRead)   
     3 t. U) v$ \( d5 I( ?
108. {
     
109.          u16 i;                                                                                       
     
110.         W25QXX_CS=0;                            //使能器件   
     - F4 T! z. s7 U3 X% g& Y! D
111.     SPI1_ReadWriteByte(W25X_ReadData);         //发送读取命令   
     
112.     SPI1_ReadWriteByte((u8)((ReadAddr)>>16));  //发送24bit地址   
     
113.     SPI1_ReadWriteByte((u8)((ReadAddr)>>8));   
     2 ^. S. m: B$ L2 ]
114.     SPI1_ReadWriteByte((u8)ReadAddr);   
     7 j% e/ E, T0 F0 Y) i$ R/ U) K; q
115.     for(i=0;i<NumByteToRead;i++)
     7 C# e, `2 S4 d
116.         {
     
117.         pBuffer<i>=SPI1_ReadWriteByte(0XFF);   //循环读数  
     
118.     }
     
119.         W25QXX_CS=1;                                                   
     
120. }  
     7 N- H1 t; |  `
121. //SPI在一页(0~65535)内写入少于256个字节的数据
     
122. //在指定地址开始写入最大256字节的数据
     # k) W! Q  p( k: ]/ z2 q
123. //pBuffer:数据存储区
     - s" m9 M+ i6 `7 S/ [
124. //WriteAddr:开始写入的地址(24bit)
     : H* X+ G: |# e! U' S
125. //NumByteToWrite:要写入的字节数(最大256),该数不应该超过该页的剩余字节数!!!         
     + X6 d0 F6 [6 h  Y4 L) U
126. void W25QXX_Write_Page(u8* pBuffer,u32 WriteAddr,u16 NumByteToWrite)
     , x) V) W4 A( }7 d3 Q" q5 c+ g& ~
127. {
     
128.          u16 i;  
     3 C7 L6 j, n) l/ F, Z2 ~
129.     W25QXX_Write_Enable();                  //SET WEL
     
130.         W25QXX_CS=0;                            //使能器件   
     * w* @* K8 x: ]% z. d
131.     SPI1_ReadWriteByte(W25X_PageProgram);      //发送写页命令   
     
132.     SPI1_ReadWriteByte((u8)((WriteAddr)>>16)); //发送24bit地址   
     7 a$ O) l6 v5 R4 R! c
133.     SPI1_ReadWriteByte((u8)((WriteAddr)>>8));   
     : N$ X! M/ t: U" ~% J
134.     SPI1_ReadWriteByte((u8)WriteAddr);   
     
135.     for(i=0;i<NumByteToWrite;i++)SPI1_ReadWriteByte(pBuffer<i>);//循环写数  
     0 @( p" _, f8 Q
136.         W25QXX_CS=1;                            //取消片选
     
137.         W25QXX_Wait_Busy();                                           //等待写入结束
     
138. }
     
139. //无检验写SPI FLASH
     % e; i- q  G- ?9 Z1 I1 _: h
140. //必须确保所写的地址范围内的数据全部为0XFF,否则在非0XFF处写入的数据将失败!
     9 I% l% G5 ?% h% E
141. //具有自动换页功能
     
142. //在指定地址开始写入指定长度的数据,但是要确保地址不越界!
     
143. //pBuffer:数据存储区
     
144. //WriteAddr:开始写入的地址(24bit)
     
145. //NumByteToWrite:要写入的字节数(最大65535)
     
146. //CHECK OK
     / p0 Q" G( x+ {- V6 u
147. void W25QXX_Write_NoCheck(u8* pBuffer,u32 WriteAddr,u16 NumByteToWrite)   
     % i; u0 V, ~% ?7 P, W& [
148. {                                          
     * n6 ]# [; |% N3 X1 a
149.         u16 pageremain;           
     & M& k8 y( s! p6 y
150.         pageremain=256-WriteAddr%256; //单页剩余的字节数                             
     
151.         if(NumByteToWrite<=pageremain)pageremain=NumByteToWrite;//不大于256个字节
     
152.         while(1)
     
153.         {           
     # z- g9 h$ y) \
154.                 W25QXX_Write_Page(pBuffer,WriteAddr,pageremain);
     
155.                 if(NumByteToWrite==pageremain)break;//写入结束了
     ) [4 B7 e# W) q% M/ }0 W
156.                  else //NumByteToWrite>pageremain
     : j6 Y/ n2 T; G+ |  c
157.                 {
     
158.                         pBuffer+=pageremain;
     6 C; D) Z; h( p& A. T
159.                         WriteAddr+=pageremain;        
     # P$ T0 C+ H. b' z% d7 v' [
160. 
     
161.                         NumByteToWrite-=pageremain;                          //减去已经写入了的字节数
     8 G# a6 e8 x/ j% [" D
162.                         if(NumByteToWrite>256)pageremain=256; //一次可以写入256个字节
     5 r( F% J2 U2 Q" |( W
163.                         else pageremain=NumByteToWrite;           //不够256个字节了
     
164.                 }
       b1 [! V4 p; y$ c4 b- @3 p
165.         };            
     8 j3 M0 ?  V! _4 \
166. }
     
167. //写SPI FLASH  
     
168. //在指定地址开始写入指定长度的数据
     
169. //该函数带擦除操作!
     
170. //pBuffer:数据存储区
     6 z7 m- X  P3 C1 K1 j/ P
171. //WriteAddr:开始写入的地址(24bit)                                                
     ; l5 h5 X! F! I. L
172. //NumByteToWrite:要写入的字节数(最大65535)   
     
173. u8 W25QXX_BUFFER[4096];                 
     
174. void W25QXX_Write(u8* pBuffer,u32 WriteAddr,u16 NumByteToWrite)   
     ( |2 Y2 V1 G, G$ ?
175. {
     * A4 C7 k) M7 _* g  l3 Q
176.         u32 secpos;
     & Q9 H8 h0 v2 R# M
177.         u16 secoff;
     
178.         u16 secremain;           
     
179.          u16 i;   
     . Z3 A# Z" x( j$ q  C  M4 `
180.         u8 * W25QXX_BUF;         
     
181.            W25QXX_BUF=W25QXX_BUFFER;            
     
182.          secpos=WriteAddr/4096;//扇区地址  
     + b8 Q* I3 [+ D6 w
183.         secoff=WriteAddr%4096;//在扇区内的偏移
     ) l0 |9 p0 s( N+ E. w( |: I
184.         secremain=4096-secoff;//扇区剩余空间大小   
     0 t0 i: j+ a, Y+ \& b
185.          //printf("ad:%X,nb:%X\r\n",WriteAddr,NumByteToWrite);//测试用
     2 J: g5 y4 _2 Z7 J. H. v
186.          if(NumByteToWrite<=secremain)secremain=NumByteToWrite;//不大于4096个字节
     ( `0 D7 r- ]: g$ m6 w
187.         while(1)
     - }* ^4 {4 z0 y9 V1 y5 L! e: n
188.         {        
     & X! b$ l/ F  P" T" I" c, R: G
189.                 W25QXX_Read(W25QXX_BUF,secpos*4096,4096);//读出整个扇区的内容
     2 A, `* ?% h* Q7 j) {1 Y: f& G) {( a
190.                 for(i=0;i<secremain;i++)//校验数据
     $ v) d4 k! k* E
191.                 {
     
192.                         if(W25QXX_BUF[secoff+i]!=0XFF)break;//需要擦除            
     
193.                 }
     + n( k; Q% g8 U( O
194.                 if(i<secremain)//需要擦除
     
195.                 {
     
196.                         W25QXX_Erase_Sector(secpos);//擦除这个扇区
     ; X* a3 X6 Y- l% j: J9 Y- T3 |
197.                         for(i=0;i<secremain;i++)           //复制
     ) W; i8 ]! ~, z9 ^
198.                         {
     
199.                                 W25QXX_BUF[i+secoff]=pBuffer<i>;         
     
200.                         }
     $ \$ K! j7 x5 X: v* {$ w  `7 s
201.                         W25QXX_Write_NoCheck(W25QXX_BUF,secpos*4096,4096);//写入整个扇区  
     
202. 
     ' ~% h4 |/ E+ C+ i8 c
203.                 }else W25QXX_Write_NoCheck(pBuffer,WriteAddr,secremain);//写已经擦除了的,直接写入扇区剩余区间.                                    
     ) T: r3 w- j# i& `+ p4 M
204.                 if(NumByteToWrite==secremain)break;//写入结束了
     4 v# Y& |( o  \
205.                 else//写入未结束
     
206.                 {
     
207.                         secpos++;//扇区地址增1
     
208.                         secoff=0;//偏移位置为0         
     
209. 
     5 p9 d' a9 H7 M$ ]' a
210.                            pBuffer+=secremain;  //指针偏移
     / z- J% t) Z. T4 W4 O8 Z
211.                         WriteAddr+=secremain;//写地址偏移           
     ' U# o: a6 O# C9 L2 G9 E) k, p! j
212.                            NumByteToWrite-=secremain;                                //字节数递减
     
213.                         if(NumByteToWrite>4096)secremain=4096;        //下一个扇区还是写不完
     9 g* ?$ \% ]; T0 S/ J5 r
214.                         else secremain=NumByteToWrite;                        //下一个扇区可以写完了
     
215.                 }         
     
216.         };         
     8 e8 \1 s0 Q0 x! u+ G: q$ a0 p
217. }
     6 g7 E# g/ L! i4 E: }. p
218. //擦除整个芯片                  
     
219. //等待时间超长...
     " T+ s% b  J/ t3 |
220. void W25QXX_Erase_Chip(void)   
     
221. {                                   
     
222.     W25QXX_Write_Enable();                  //SET WEL
     
223.     W25QXX_Wait_Busy();   
     8 h4 t- \; {- c6 w- ~3 Z  _+ X% l
224.           W25QXX_CS=0;                            //使能器件   
     , ~2 O# q4 k4 m- A2 t) R  [9 j1 u
225.     SPI1_ReadWriteByte(W25X_ChipErase);        //发送片擦除命令  
     
226.         W25QXX_CS=1;                            //取消片选                  
     
227.         W25QXX_Wait_Busy();                                      //等待芯片擦除结束
     
228. }   
     
229. //擦除一个扇区
     5 [1 E) g2 D1 X1 d) G5 K
230. //Dst_Addr:扇区地址 根据实际容量设置
     , H: E% a( O( [9 k1 }8 a
231. //擦除一个山区的最少时间:150ms
     0 F! B0 d: v( ~' B, X
232. void W25QXX_Erase_Sector(u32 Dst_Addr)   
     - j/ ~5 O9 T9 ^: s" k9 k; J! d2 E
233. {  
     
234.         //监视falsh擦除情况,测试用   
     
235.          printf("fe:%x\r\n",Dst_Addr);         
     
236.          Dst_Addr*=4096;
     " z& H: d4 [6 I5 j! K+ {& a' B" Z
237.     W25QXX_Write_Enable();                  //SET WEL         
     6 ~/ Q' `% [: p) J$ e6 Y8 m' `
238.     W25QXX_Wait_Busy();   
     
239.           W25QXX_CS=0;                            //使能器件   
     
240.     SPI1_ReadWriteByte(W25X_SectorErase);      //发送扇区擦除指令
     / l# D" t* W2 }$ |. j( b7 K8 o
241.     SPI1_ReadWriteByte((u8)((Dst_Addr)>>16));  //发送24bit地址   
     
242.     SPI1_ReadWriteByte((u8)((Dst_Addr)>>8));   
     
243.     SPI1_ReadWriteByte((u8)Dst_Addr);  
     + x; }0 n) Q8 U- A  C
244.         W25QXX_CS=1;                            //取消片选                  
     
245.     W25QXX_Wait_Busy();                                      //等待擦除完成
     
246. }  
     
247. //等待空闲
     , L- q) V$ U* ~6 n
248. void W25QXX_Wait_Busy(void)   
     
249. {   
     ( d+ j6 O8 C- ~8 v6 Z
250.         while((W25QXX_ReadSR()&0x01)==0x01);   // 等待BUSY位清空
     " S( v7 F* A3 o& z# k; ]/ c
251. }  
     / r& {) }; w8 i9 Z1 R9 U6 c
252. //进入掉电模式
     ! L5 w- l$ ~& ]" g! A
253. void W25QXX_PowerDown(void)   
     " t/ I" ~$ D- \
254. {
     $ s+ }) v- W+ o/ _% P: R
255.           W25QXX_CS=0;                            //使能器件   
     & {" L/ i: h! v7 T( l
256.     SPI1_ReadWriteByte(W25X_PowerDown);        //发送掉电命令  
     
257.         W25QXX_CS=1;                            //取消片选                  
     ; ^$ k, l7 L5 w
258.     delay_us(3);                               //等待TPD  
     
259. }   
     
260. //唤醒
     
261. void W25QXX_WAKEUP(void)   
     
262. {  
     
263.           W25QXX_CS=0;                            //使能器件   
     8 u) X' W; i0 J0 I& B9 _& h
264.     SPI1_ReadWriteByte(W25X_ReleasePowerDown);   //  send W25X_PowerDown command 0xAB   
     ! C. }/ T. {, o; n: ~) ^% ?
265.         W25QXX_CS=1;                            //取消片选                  
     " x. l1 F) w2 `6 \4 u0 c& @
266.     delay_us(3);                               //等待TRES1
     & |; w0 ]$ {5 n  y# o& L. M
267. }   </i></i></i>

复制代码

1. 
   
2. W25Q12xx.h：
   
3. 
   0 k# \( g- g2 Y* [0 ~
4. #ifndef __W25QXX_H
   
5. #define __W25QXX_H                           
   
6. #include "sys.h"  
   
7. 
   
8. //W25X系列/Q系列芯片列表           
   ' W6 h: B; t; P) n3 {- u
9. //W25Q80  ID  0XEF13
   9 P. Q+ A* w7 S7 s( b" m
10. //W25Q16  ID  0XEF14
    # ~# M8 j& O3 I3 z2 Q* \4 W( n& J
11. //W25Q32  ID  0XEF15
    7 \+ s; G5 X6 @, f
12. //W25Q64  ID  0XEF16        
    
13. //W25Q128 ID  0XEF17        
    7 X2 B7 z$ J% O% v1 }; l
14. #define W25Q80         0XEF13         
    
15. #define W25Q16         0XEF14
    ) m2 L4 }' C4 ^+ \, }8 H. G
16. #define W25Q32         0XEF15
    - ]( K7 E' H/ ]. c: ]5 h
17. #define W25Q64         0XEF16
    
18. #define W25Q128        0XEF17
    1 h0 x, _: D* I% z9 v
19. 
    . B  k5 [5 N4 X1 F+ ~
20. extern u16 W25QXX_TYPE;                                        //定义W25QXX芯片型号                  
    ' q* r. `5 [. ]2 q: @' }
21. 
    $ o! v/ y5 Y: a& B4 [7 R, n
22. #define        W25QXX_CS                 PBout(14)                  //W25QXX的片选信号
    1 N, N; Z$ m2 \! o/ v) n
23. //
    # l( W' Z  ^* G* k  o  b- U
24. //指令表
    ; k1 \0 Q6 t5 {4 ^% X1 z) T
25. #define W25X_WriteEnable                0x06
    ; l, E- U: L9 R# m3 g
26. #define W25X_WriteDisable                0x04
    
27. #define W25X_ReadStatusReg                0x05
    ( \" v  h; M7 r! [( a3 X8 u3 S
28. #define W25X_WriteStatusReg                0x01
    
29. #define W25X_ReadData                        0x03
    , V9 ?3 p7 n% M- |) T- \
30. #define W25X_FastReadData                0x0B
    1 P$ R2 T3 [3 k& _7 z
31. #define W25X_FastReadDual                0x3B
    * K# V. B) m4 m# t* T5 t
32. #define W25X_PageProgram                0x02
    
33. #define W25X_BlockErase                        0xD8
    ' |' I2 g- S' P1 B$ Z% Y* j  w
34. #define W25X_SectorErase                0x20
    
35. #define W25X_ChipErase                        0xC7
    & u; Q: W  G2 ~
36. #define W25X_PowerDown                        0xB9
    
37. #define W25X_ReleasePowerDown        0xAB
    * L: R9 {; h; D6 _# R& ]+ B
38. #define W25X_DeviceID                        0xAB
    
39. #define W25X_ManufactDeviceID        0x90
    
40. #define W25X_JedecDeviceID                0x9F
    
41. 
    8 l, a( R9 Y; W& `" _. W1 A
42. void W25QXX_Init(void);
    
43. u16  W25QXX_ReadID(void);                              //读取FLASH ID
    9 R' k) N" R$ [+ P% v
44. u8         W25QXX_ReadSR(void);                        //读取状态寄存器
    / Z( r  d6 _* v: z$ L
45. void W25QXX_Write_SR(u8 sr);                          //写状态寄存器
      p4 T* ?: G# m6 Q
46. void W25QXX_Write_Enable(void);                  //写使能
      B( _3 ^& _% p0 U: @' Q. x
47. void W25QXX_Write_Disable(void);                //写保护
    
48. void W25QXX_Write_NoCheck(u8* pBuffer,u32 WriteAddr,u16 NumByteToWrite);
    
49. void W25QXX_Read(u8* pBuffer,u32 ReadAddr,u16 NumByteToRead);   //读取flash
    , X- n" m# [) j' T' J
50. void W25QXX_Write(u8* pBuffer,u32 WriteAddr,u16 NumByteToWrite);//写入flash
    
51. void W25QXX_Erase_Chip(void);                      //整片擦除
    
52. void W25QXX_Erase_Sector(u32 Dst_Addr);        //扇区擦除
    
53. void W25QXX_Wait_Busy(void);                   //等待空闲
    
54. void W25QXX_PowerDown(void);                //进入掉电模式
    
55. void W25QXX_WAKEUP(void);                                //唤醒
    
56. 
    
57. #endif
    

复制代码

main.c:
+ o3 v9 l9 F4 k  F$ d& f

1. main.c:
   6 J0 u  L" V9 Z" s4 z* j3 j
2. #include "sys.h"
   
3. #include "delay.h"
   
4. #include "usart.h"
   + B( M( Y1 H" Q/ s
5. #include "led.h"
   
6. #include "lcd.h"
   
7. #include "spi.h"
   
8. #include "w25qxx.h"
   
9. #include "key.h"   
   0 \' J& w( w; D) ?+ n. m/ n
10. 
    
11. //要写入到W25Q16的字符串数组
    
12. const u8 TEXT_Buffer[]={"Explorer STM32F4 SPI TEST"};
    
13. #define SIZE sizeof(TEXT_Buffer)         
    
14.         
    
15. int main(void)
    
16. {
    
17.         u8 key;
    ' m4 n8 @+ _! F- G9 O
18.         u16 i=0;
    
19.         u8 datatemp[SIZE];        
    
20.         NVIC_PriorityGroupConfig(NVIC_PriorityGroup_2);//设置系统中断优先级分组2
    ; k5 j, O7 g% i' ?/ ]
21.         delay_init(168);    //初始化延时函数
    
22.         uart_init(115200);        //初始化串口波特率为115200
    
23.         LED_Init();                                        //初始化LED
    ! g3 \' M: Z( G# P6 c# n( P
24.         KEY_Init();                                 //按键初始化  
    ! b7 ~# ]7 F  P6 z
25.         W25QXX_Init();                        //W25QXX初始化
    - A1 t( K6 h; S' v! c' R. n% q! a
26.                         
    , M0 f# E' @3 A
27.          while(W25QXX_ReadID()!=W25Q128)        //检测不到W25Q128
    3 C) r9 h) `) S. k! l
28.         {
    
29.                 printf("W25Q128 Check Failed!");
    4 d5 `, b5 V2 H
30.                 delay_ms(500);
    
31.                 printf("Please Check!      ");
    % E7 T& R* X$ i: D5 y
32.                 delay_ms(500);
    3 w7 g; H4 a0 x: ~' ~
33.                 LED0=!LED0;                //DS0闪烁
    ! E7 `% {7 g4 G! c1 E8 V5 A
34.         }
    
35.         
    , S* s/ R2 t" C' ]- l
36.         while(1)
    
37.         {
    $ R. X. l; x' J0 s0 b: W' M* e
38.                 key=KEY_Scan(0);
    6 ?6 F( s/ H/ ~8 P& N* x
39.                 if(key==KEY1_PRES)//KEY1按下,写入24C02
      V" E% V% a9 B/ s# Q9 u  ?* S
40.                 {
    
41.                         printf("Start Write W25Q128....");
    6 U$ A4 f5 [2 X5 m7 j$ ~
42.                         //从倒数第100个地址处开始,写入SIZE长度的数据  
    ! {+ G, e( y4 B
43.                         W25QXX_Write((u8*)TEXT_Buffer,FLASH_SIZE-100,SIZE);
    
44.                         printf("W25Q128 Write Finished!");  //提示传送完成
    0 u6 N1 s+ d% W$ ~. @" F
45.                 }
    
46.                 if(key==KEY0_PRES)//KEY0按下,读取字符串并显示
    " X$ e% w0 ?- I  X7 v, c9 z
47.                 {
    8 E# n' _& l; r: s6 u: k
48.                         printf("Start Read W25Q128.... ");
    0 M) n' g9 U4 k; m6 J
49.                         //从倒数第100个地址处开始,读出SIZE个字节
    
50.                         W25QXX_Read(datatemp,FLASH_SIZE-100,SIZE);                                       
    $ ~# F0 `+ _/ v" `% n
51.                         printf("The Data Readed Is: \r\n ");//提示传送完成
    & [( H/ A6 T1 w9 q" U
52.                         printf("%s\r\n ",datatemp);
    $ c2 P9 }- J/ u: B" p% U
53.                 }           
    0 e. ?' W9 e( k& O- ^1 ~0 b
54.         }            
    ; n0 `2 P9 L7 I5 O% s
55. }
    
56. 
    

复制代码