一、SPI介绍
  v2 w6 V, G' t; n& R/ SSPI 是英语Serial Peripheral interface的缩写，顾名思义就是串行外围设备接口。是Motorola首先在其MC68HCXX系列处理器上定义的。SPI，是一种高速的，全双工，同步的通信总线，并且在芯片的管脚上只占用四根线，节约了芯片的管脚，同时为PCB的布局上节省空间，提供方便，主要应用在 EEPROM，FLASH，实时时钟，AD转换器，还有数字信号处理器和数字信号解码器之间。
+ \3 A$ Y, A$ S/ R, @$ q5 g
正是简单易用的特性，如NRF24L01、VS1053、SD卡等皆集成了这种通信协议
1 I8 u: c( ^' t3 S
$ N9 y& C) j# K* u' w
+ s: k/ T$ z. t+ O
二、SPI接口框图
( W  B5 H- _3 \9 p& z( \/ H0 s* ?

7 C' Y* E% S7 H# n
三、SPI优缺点
SPI接口是在CPU和外围低速器件之间进行同步串行数据传输，在主器件的移位脉冲下，数据按位传输，低位在前，高位在后，为全双工通信，数据传输速度总体来说比I2C总线要快，速度可达到几Mbps。

5 C# w3 f7 W0 J, D信号线少，协议简单，相对数据速率高。
5 H+ x4 {, i/ `2 u/ J
7 ^8 V; o! H! q缺点：没有指定的流控制，没有应答机制确认是否接收到数据
& O2 `: p6 r; v3 }$ B
四、SPI工作原理总结
硬件上为4根线。
主机和从机都有一个串行移位寄存器，主机通过向它的SPI串行寄存器写入一个字节来发起一次传输。
串行移位寄存器通过MOSI信号线将字节传送给从机，从机也将自己的串行移位寄存器中的内容通过MISO信号线返回给主机。这样，两个移位寄存器中的内容就被交换。
外设的写操作和读操作是同步完成的。如果只进行写操作，主机只需忽略接收到的字节；反之，若主机要读取从机的一个字节，就必须发送一个空字节来引发从机的传输。
多个设备使用SPI的应用举例

0 U& }- p. Q3 Y* D
/ A, p% U, y/ o. Y1 L
五、时序图
5 j5 n3 R4 `+ h6 U时序为 SPI_CR1 寄存器中的 LSBFIRST 位复位时的时序
( z: j& F  q5 y$ P6 G0 ?
SPI_CPHA的值将会影响SPI_CPOL的值
2 c" y) S) {3 K3 f. w8 a2 R
6 x3 B, `0 r1 ~+ p5 J9 w

+ [$ O( x, w' m- p) D. r. a六、SPI程序编写过程

1. //①使能SPIx和IO口时钟
   
2. RCC_AHBxPeriphClockCmd() / RCC_APBxPeriphClockCmd();
   
3. 
   
4. //②初始化IO口为复用功能
   
5. void GPIO_Init(GPIO_TypeDef* GPIOx, GPIO_InitTypeDef* GPIO_InitStruct);
   ( r) t' c: g6 S! r" Q
6. 
   
7. //③设置引脚复用映射：
   
8. GPIO_PinAFConfig();
   
9. 
   & ~( J3 s4 p  c; g  q& ]
10. //②初始化SPIx,设置SPIx工作模式
    ' ^% |( O& Y1 Z% A; x
11. void SPI_Init(SPI_TypeDef* SPIx, SPI_InitTypeDef* SPI_InitStruct);
    
12. 
    
13. //③使能SPIx
    
14. void SPI_Cmd(SPI_TypeDef* SPIx, FunctionalState NewState);
    
15. 
    
16. //④SPI传输数据
    0 V/ x3 R  R3 a
17. void SPI_I2S_SendData(SPI_TypeDef* SPIx, uint16_t Data);
      e0 |* @% q7 b
18. uint16_t SPI_I2S_ReceiveData(SPI_TypeDef* SPIx) ;
    1 F; u3 i% F5 ?; Y: B# P" g
19. 
    
20. //⑦查看SPI传输状态
    
21. SPI_I2S_GetFlagStatus(SPI2, SPI_I2S_FLAG_RXNE);

复制代码

1. SPI.c:
   5 s# \4 B" I; U6 a
2. #include "spi.h"
   6 ~/ I1 Z/ {. ^, P( S
3. 
   
4. //以下是SPI模块的初始化代码，配置成主机模式                                                   
   
5. //SPI口初始化
   
6. //这里针是对SPI1的初始化
   6 f! c' _7 Q  B* r. d% A
7. void SPI1_Init(void)
   / l' S' w; n; [$ O
8. {         
   
9.   GPIO_InitTypeDef  GPIO_InitStructure;
   , e6 [0 c- f6 J  l1 f
10.   SPI_InitTypeDef  SPI_InitStructure;
    2 U0 g0 G7 [1 s+ p9 g) d6 b0 A
11.         
    
12.   RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOB, ENABLE);//使能GPIOB时钟
    
13.   RCC_APB2PeriphClockCmd(RCC_APB2Periph_SPI1, ENABLE);//使能SPI1时钟
    
14. 
    
15.   //GPIOFB3,4,5初始化设置
    + G- g+ A# |+ T2 ~3 g; x6 z7 P( Q7 b/ B
16.   GPIO_InitStructure.GPIO_Pin = GPIO_Pin_3|GPIO_Pin_4|GPIO_Pin_5;//PB3~5复用功能输出        
    ' d8 N% \0 u3 U$ M- l) b) o' S! V
17.   GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF;//复用功能
    3 c( n* O- O, C* g: f, a5 _
18.   GPIO_InitStructure.GPIO_OType = GPIO_OType_PP;//推挽输出
    # n- D  x( b" o) }
19.   GPIO_InitStructure.GPIO_Speed = GPIO_Speed_100MHz;//100MHz
    
20.   GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_UP;//上拉
    
21.   GPIO_Init(GPIOB, &GPIO_InitStructure);//初始化
    " Z& q0 Y8 M; z: {- o3 V* f2 C
22.         
      j. J6 A) H( o) R  h  i
23.         GPIO_PinAFConfig(GPIOB,GPIO_PinSource3,GPIO_AF_SPI1); //PB3复用为 SPI1
    
24.         GPIO_PinAFConfig(GPIOB,GPIO_PinSource4,GPIO_AF_SPI1); //PB4复用为 SPI1
    " Q; P6 _. ~) [* l
25.         GPIO_PinAFConfig(GPIOB,GPIO_PinSource5,GPIO_AF_SPI1); //PB5复用为 SPI1
    ) V7 x; I2 c" R& E+ v8 |' @
26. 
    
27.         //这里只针对SPI口初始化
    4 n8 }" d1 a' j3 d( z; i5 a
28.         RCC_APB2PeriphResetCmd(RCC_APB2Periph_SPI1,ENABLE);//复位SPI1
    3 K1 c. a! \+ A9 m
29.         RCC_APB2PeriphResetCmd(RCC_APB2Periph_SPI1,DISABLE);//停止复位SPI1
    ; L  Q5 _) x, F" `8 L
30. 
    6 W" I6 T0 o4 ^0 P1 v
31.         SPI_InitStructure.SPI_Direction = SPI_Direction_2Lines_FullDuplex;  //设置SPI单向或者双向的数据模式:SPI设置为双线双向全双工
      b( \8 J# J5 }" E& C
32.         SPI_InitStructure.SPI_Mode = SPI_Mode_Master;                //设置SPI工作模式:设置为主SPI
    
33.         SPI_InitStructure.SPI_DataSize = SPI_DataSize_8b;                //设置SPI的数据大小:SPI发送接收8位帧结构
    
34.         SPI_InitStructure.SPI_CPOL = SPI_CPOL_High;                //串行同步时钟的空闲状态为高电平
    : N: y) |8 z1 y7 K* V$ z, k. e+ E
35.         SPI_InitStructure.SPI_CPHA = SPI_CPHA_2Edge;        //串行同步时钟的第二个跳变沿（上升或下降）数据被采样
    
36.         SPI_InitStructure.SPI_NSS = SPI_NSS_Soft;                //NSS信号由硬件（NSS管脚）还是软件（使用SSI位）管理:内部NSS信号有SSI位控制
    % _+ o6 P  _6 z/ i
37.         SPI_InitStructure.SPI_BaudRatePrescaler = SPI_BaudRatePrescaler_256;                //定义波特率预分频的值:波特率预分频值为256
    6 `, F, i( M/ Q5 B
38.         SPI_InitStructure.SPI_FirstBit = SPI_FirstBit_MSB;        //指定数据传输从MSB位还是LSB位开始:数据传输从MSB位开始
    
39.         SPI_InitStructure.SPI_CRCPolynomial = 7;        //CRC值计算的多项式
    
40.         SPI_Init(SPI1, &SPI_InitStructure);  //根据SPI_InitStruct中指定的参数初始化外设SPIx寄存器
    / ?% W% V: W3 U3 d* F$ R" B
41. 
    8 W* H9 a5 k+ z  e4 U
42.         SPI_Cmd(SPI1, ENABLE); //使能SPI外设
    
43. 
    : ~! {- H- o5 o, ~" p, p) o
44.         SPI1_ReadWriteByte(0xff);//启动传输                 
    + y, h5 s" S' c5 M! t
45. }   
    6 t/ g# @, w* E3 e9 s# y, X4 |" A( _
46. //SPI1速度设置函数
    
47. //SPI速度=fAPB2/分频系数
    3 L, }3 Q7 q' A6 u5 u6 h" c
48. //@ref SPI_BaudRate_Prescaler:SPI_BaudRatePrescaler_2~SPI_BaudRatePrescaler_256  
    
49. //fAPB2时钟一般为84Mhz：
    
50. void SPI1_SetSpeed(u8 SPI_BaudRatePrescaler)
    . y" ~& B; _5 A$ B/ W. d8 f
51. {
    
52.   assert_param(IS_SPI_BAUDRATE_PRESCALER(SPI_BaudRatePrescaler));//判断有效性
    2 q- O# G) D& e" o1 f/ S
53.         SPI1->CR1&=0XFFC7;//位3-5清零，用来设置波特率
    
54.         SPI1->CR1|=SPI_BaudRatePrescaler;        //设置SPI1速度
    
55.         SPI_Cmd(SPI1,ENABLE); //使能SPI1
    7 T2 J* D# J+ H! i# r, n
56. }
    ( O7 o& i% H+ I4 f! M
57. //SPI1 读写一个字节
    
58. //TxData:要写入的字节
    
59. //返回值:读取到的字节
    
60. u8 SPI1_ReadWriteByte(u8 TxData)
    
61. {                                          
    
62. 
    
63.   while (SPI_I2S_GetFlagStatus(SPI1, SPI_I2S_FLAG_TXE) == RESET){}//等待发送区空  
    
64.         
    1 E( z9 I) v) h
65.         SPI_I2S_SendData(SPI1, TxData); //通过外设SPIx发送一个byte  数据
    . S" K% v9 T" @+ t; N. w* t( h3 e
66.                
    - i7 _( j, _- P$ I
67.   while (SPI_I2S_GetFlagStatus(SPI1, SPI_I2S_FLAG_RXNE) == RESET){} //等待接收完一个byte  
    
68. 
    
69.         return SPI_I2S_ReceiveData(SPI1); //返回通过SPIx最近接收的数据        
    
70.                      
    
71. }
    
72. 
    8 b) {) b" Q6 s0 x& L

复制代码

2 e: v: q! b4 v, P七、W25Q12xx的原理及应用
W25Q128将16M的容量分为256个块（Block),每个块大小为64K字节，每个块又分为16个扇区（Sector),每个扇区4K个字节。W25Q128的最小擦除单位为一个扇区，也就是每次必须擦除4K个字节。这样我们需要给W25Q128开辟一个至少4K的缓存区，这样对SRAM要求比较高，要求芯片必须有4K以上SRAM才能很好的操作。
- @" ~# C( C  u3 c  J
. b! F0 t' S8 {W25Q128的擦写周期多达10W次，具有20年的数据保存期限，支持电压为2.7~3.6V,W25Q128支持标准的SPI,还支持双输出/四输出的SPI,最大SPI时钟可以到80Mhz(双输出时相当于160Mhz,四输出时相当于320M),更多的W25Q128的介绍，请参考W25Q128的DATASHEET。
  Z+ g* t3 R. O* U/ u! S* ^
4 v; {/ }. L! f4 ^( B& ], P
# H/ S  w  J7 ^( z  E  r3 Y- D
. z% f. {3 K+ M$ S% v% s+ n  FW25Q12xx可根据原理图查看，使用的是SPI总线通信协议
. O( L' h# s# @7 m( H
比如原子的原理图

. k( ^5 M4 z- J! K

7.1 分析W25Q128指令
可参考W25Qxx的数据手册，这里列出W25Q128部分指令：

! F* \% ], z8 i- Q8 [" ~- y

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

7 ?. ]% C3 T" o3 {7 R/ ?
7 w1 k+ T9 [& K
8 C- ^$ W1 w  W% @7 \# O& h& V
9 x4 i. {! G* E. U: \" l. ?5 Z) s
/ `3 L" Z0 P: L7 R4 M

7.2 擦除扇区：
* F5 r$ V) V5 ?1 `; I4 t, {

, R/ k5 [3 b9 [: V! h" u& [" z
7.3 部分常用设备读取指令：

. o; q2 U. G  D) C9 M! \: }& i/ v

) N+ }! {* y3 o% h+ }% p每次操作前要使能写操作，且给一个低电平。结束时要给其为高电平，再失能写操作。也就是通过操作片选引脚来确定是否使能或失能。



. q" {! Q9 B& [5 o/ [

1. W25Q12xx.c:
   7 B: W2 J& n( a* ]. i, c# B& w9 a, }- A
2. #include "w25qxx.h"
     M  S* W" H( a% g1 Y
3. #include "spi.h"
   
4. #include "delay.h"           
   
5. #include "usart.h"        
   
6. 
   
7. u16 W25QXX_TYPE=W25Q128;        //默认是W25Q128
   
8. 
   
9. //4Kbytes为一个Sector
   
10. //16个扇区为1个Block
    ! K' e8 I3 x* F! }- M+ T
11. //W25Q128
    
12. //容量为16M字节,共有128个Block,4096个Sector
    # ~9 s  I  j- o
13.                                                                                                          
    
14. //初始化SPI FLASH的IO口
    , b' Q0 y' f* T2 L9 Q8 o8 a# s
15. void W25QXX_Init(void)
    6 ]& T0 [  Q2 W' e1 _6 h$ j3 e
16. {
    
17.   GPIO_InitTypeDef  GPIO_InitStructure;
    
18. 
    & J' {: g# D$ o" l  d* Q
19.   RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOB, ENABLE);//使能GPIOB时钟
    
20.   RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOG, ENABLE);//使能GPIOG时钟
    
21. 
    / A3 ?! c; R. ?# o
22.           //GPIOB14
    
23.   GPIO_InitStructure.GPIO_Pin = GPIO_Pin_14;//PB14
    : L! ?: j2 ?; n# h( F& Y5 r! [( L
24.   GPIO_InitStructure.GPIO_Mode = GPIO_Mode_OUT;//输出
    3 U  H& Q8 A* s9 V" N$ {0 t0 ^
25.   GPIO_InitStructure.GPIO_OType = GPIO_OType_PP;//推挽输出
    ( I8 V" X; I9 d! S
26.   GPIO_InitStructure.GPIO_Speed = GPIO_Speed_100MHz;//100MHz
    
27.   GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_UP;//上拉
    5 W3 k: \% o, @  H. ^5 @
28.   GPIO_Init(GPIOB, &GPIO_InitStructure);//初始化
    : i4 H1 f5 I5 ^  U/ ~8 D
29. 
    ) D6 v: u& W1 ]5 @+ s
30.         GPIO_InitStructure.GPIO_Pin = GPIO_Pin_7;//PG7
    $ ?- P4 {: U& ?
31.   GPIO_Init(GPIOG, &GPIO_InitStructure);//初始化
    & U5 C7 i" g! b( O- p2 K
32. 
    
33.         GPIO_SetBits(GPIOG,GPIO_Pin_7);//PG7输出1,防止NRF干扰SPI FLASH的通信
    
34.         W25QXX_CS=1;                        //SPI FLASH不选中
    
35.         SPI1_Init();                                           //初始化SPI
    
36.         SPI1_SetSpeed(SPI_BaudRatePrescaler_2);                //设置为42M时钟,高速模式
    ) h' ~9 q1 D- K6 K9 o$ g5 g# U
37.         W25QXX_TYPE=W25QXX_ReadID();        //读取FLASH ID.
    ! F+ ]: h/ @) X: F) I3 N: ]7 e1 c
38. }  
    
39. 
    9 T% i; D5 [1 X
40. //读取W25QXX的状态寄存器
    
41. //BIT7  6   5   4   3   2   1   0
    % J  \8 ~1 ]8 Y" p9 G: R% m9 }$ a
42. //SPR   RV  TB BP2 BP1 BP0 WEL BUSY
    5 m( i& B. N$ i6 ^6 S/ ]
43. //SPR:默认0,状态寄存器保护位,配合WP使用
    
44. //TB,BP2,BP1,BP0:FLASH区域写保护设置
    3 F# H1 }' K6 C- \, m( W
45. //WEL:写使能锁定
    
46. //BUSY:忙标记位(1,忙;0,空闲)
    
47. //默认:0x00
    
48. u8 W25QXX_ReadSR(void)   
    , P3 S: S1 [* B& f! ~2 Y
49. {  
    - L& Z( w* |& M. V8 F: H
50.         u8 byte=0;   
    
51.         W25QXX_CS=0;                            //使能器件   
    ) B0 O4 p: L4 h3 `  u5 {
52.         SPI1_ReadWriteByte(W25X_ReadStatusReg);    //发送读取状态寄存器命令   
    1 y# c" F& r) E  M  C
53.         byte=SPI1_ReadWriteByte(0Xff);             //读取一个字节  
    , O8 }* c4 z7 G" F
54.         W25QXX_CS=1;                            //取消片选     
    
55.         return byte;   
    ( o- b- G! Q/ a$ ]. I1 T$ @7 _
56. }
    
57. //写W25QXX状态寄存器
    
58. //只有SPR,TB,BP2,BP1,BP0(bit 7,5,4,3,2)可以写!!!
    . r3 E9 I0 w3 i( C6 `. ^
59. void W25QXX_Write_SR(u8 sr)   
    
60. {   
    
61.         W25QXX_CS=0;                            //使能器件   
    . [8 m! p- L  I) g7 v/ ?
62.         SPI1_ReadWriteByte(W25X_WriteStatusReg);   //发送写取状态寄存器命令   
    / x( E. L: R3 \0 n5 {
63.         SPI1_ReadWriteByte(sr);               //写入一个字节  
    
64.         W25QXX_CS=1;                            //取消片选                  
    
65. }   
    
66. //W25QXX写使能        
    7 c: ?$ e7 t3 l) J3 y
67. //将WEL置位   
    
68. void W25QXX_Write_Enable(void)   
    
69. {
    4 |7 c$ p- I7 J( Y0 q, P7 x9 }
70.         W25QXX_CS=0;                            //使能器件   
      f% P6 T5 `, u' F
71.     SPI1_ReadWriteByte(W25X_WriteEnable);      //发送写使能  
    
72.         W25QXX_CS=1;                            //取消片选                  
    9 d4 _% X. B$ K2 {* E3 `) V5 T: ^
73. }
    - t- K1 Y3 s4 [0 |3 p
74. //W25QXX写禁止        
    
75. //将WEL清零  
    
76. void W25QXX_Write_Disable(void)   
    
77. {  
    
78.         W25QXX_CS=0;                            //使能器件   
    ; h3 ^- I, w2 n  O" V/ {( Z! _
79.     SPI1_ReadWriteByte(W25X_WriteDisable);     //发送写禁止指令   
    ' j) ]) z7 g. G- a. ~* v' M$ K
80.         W25QXX_CS=1;                            //取消片选                  
    
81. }                 
    
82. //读取芯片ID
    
83. //返回值如下:                                   
    1 }: q% l# N# s4 a
84. //0XEF13,表示芯片型号为W25Q80  
    
85. //0XEF14,表示芯片型号为W25Q16   
    
86. //0XEF15,表示芯片型号为W25Q32  
    
87. //0XEF16,表示芯片型号为W25Q64
    
88. //0XEF17,表示芯片型号为W25Q128           
    
89. u16 W25QXX_ReadID(void)
    9 P/ F" a5 Q& e: P
90. {
    3 F8 h8 W9 ?- d! k/ _6 j
91.         u16 Temp = 0;         
    ) q& D# {% h- }0 ^' u
92.         W25QXX_CS=0;                                    
    
93.         SPI1_ReadWriteByte(0x90);//发送读取ID命令            
    
94.         SPI1_ReadWriteByte(0x00);            
      c) \% C: L& n4 E
95.         SPI1_ReadWriteByte(0x00);            
    
96.         SPI1_ReadWriteByte(0x00);                                    
    
97.         Temp|=SPI1_ReadWriteByte(0xFF)<<8;  
    
98.         Temp|=SPI1_ReadWriteByte(0xFF);         
    / L0 \1 F7 H3 g
99.         W25QXX_CS=1;                                    
    0 t% P4 Z. J# @# H9 d: p- s+ q
100.         return Temp;
     % F) Y* Z8 i" a8 Y, z; ]
101. }                       
     
102. //读取SPI FLASH  
     
103. //在指定地址开始读取指定长度的数据
     
104. //pBuffer:数据存储区
     
105. //ReadAddr:开始读取的地址(24bit)
     $ R' u- E  K  o( I+ p
106. //NumByteToRead:要读取的字节数(最大65535)
     
107. void W25QXX_Read(u8* pBuffer,u32 ReadAddr,u16 NumByteToRead)   
     
108. {
     
109.          u16 i;                                                                                       
     : s" x4 Z3 u' t+ U% x
110.         W25QXX_CS=0;                            //使能器件   
     
111.     SPI1_ReadWriteByte(W25X_ReadData);         //发送读取命令   
     9 T9 j. i5 Y0 c- h5 ~4 H% d- |
112.     SPI1_ReadWriteByte((u8)((ReadAddr)>>16));  //发送24bit地址   
     
113.     SPI1_ReadWriteByte((u8)((ReadAddr)>>8));   
     " |( h* O- H3 Q$ l; d% a
114.     SPI1_ReadWriteByte((u8)ReadAddr);   
     ( Y. B0 M5 I9 n' J# s4 k- Q* R
115.     for(i=0;i<NumByteToRead;i++)
     
116.         {
     
117.         pBuffer<i>=SPI1_ReadWriteByte(0XFF);   //循环读数  
     
118.     }
     2 L8 O6 h! {( ]' n3 o- a' B
119.         W25QXX_CS=1;                                                   
     2 ]( v& h" E7 L: V' T0 |) w
120. }  
     
121. //SPI在一页(0~65535)内写入少于256个字节的数据
     
122. //在指定地址开始写入最大256字节的数据
     
123. //pBuffer:数据存储区
     1 w" W8 j, n* r; j. q( `; g0 G
124. //WriteAddr:开始写入的地址(24bit)
     
125. //NumByteToWrite:要写入的字节数(最大256),该数不应该超过该页的剩余字节数!!!         
     6 F4 g" @8 q6 P0 Y) E2 [% E
126. void W25QXX_Write_Page(u8* pBuffer,u32 WriteAddr,u16 NumByteToWrite)
     / S% R# s# `, N* i+ s
127. {
     
128.          u16 i;  
     6 ?3 Q* n# J- W- C6 @
129.     W25QXX_Write_Enable();                  //SET WEL
     3 w! F9 S: S$ ]) }6 S- C
130.         W25QXX_CS=0;                            //使能器件   
     
131.     SPI1_ReadWriteByte(W25X_PageProgram);      //发送写页命令   
     ' c" s& O2 e7 k6 l0 V1 a9 p+ _
132.     SPI1_ReadWriteByte((u8)((WriteAddr)>>16)); //发送24bit地址   
     
133.     SPI1_ReadWriteByte((u8)((WriteAddr)>>8));   
     % t7 g/ P) Q: w! ~8 ?; U6 X. h
134.     SPI1_ReadWriteByte((u8)WriteAddr);   
     ) {' [7 N$ h5 t# Z' c
135.     for(i=0;i<NumByteToWrite;i++)SPI1_ReadWriteByte(pBuffer<i>);//循环写数  
     ; I' g! Z& h% F
136.         W25QXX_CS=1;                            //取消片选
     , z$ }" N+ ^$ Y: _& a
137.         W25QXX_Wait_Busy();                                           //等待写入结束
     
138. }
     
139. //无检验写SPI FLASH
     
140. //必须确保所写的地址范围内的数据全部为0XFF,否则在非0XFF处写入的数据将失败!
     
141. //具有自动换页功能
     8 C, `4 r' A/ f/ s
142. //在指定地址开始写入指定长度的数据,但是要确保地址不越界!
     $ i( s9 F4 G- u) z# c! ^
143. //pBuffer:数据存储区
     
144. //WriteAddr:开始写入的地址(24bit)
     
145. //NumByteToWrite:要写入的字节数(最大65535)
     
146. //CHECK OK
     9 {* Y; C, H% e5 L6 S' ^; V
147. void W25QXX_Write_NoCheck(u8* pBuffer,u32 WriteAddr,u16 NumByteToWrite)   
     
148. {                                          
     ( G2 C7 ?9 d  k) I* V
149.         u16 pageremain;           
     
150.         pageremain=256-WriteAddr%256; //单页剩余的字节数                             
     
151.         if(NumByteToWrite<=pageremain)pageremain=NumByteToWrite;//不大于256个字节
     
152.         while(1)
     . Y" v' M+ z4 j5 y) ?! c: Y) h( e
153.         {           
     ( ^" U" y, B* K+ \  f, B. v
154.                 W25QXX_Write_Page(pBuffer,WriteAddr,pageremain);
     ( w5 m9 w( Z& F9 e5 s* Y1 o
155.                 if(NumByteToWrite==pageremain)break;//写入结束了
     4 @) }" D8 M+ n! \/ _0 u
156.                  else //NumByteToWrite>pageremain
     
157.                 {
     % K/ C9 Z0 M" \4 V+ `& u2 l9 N1 y
158.                         pBuffer+=pageremain;
     8 s2 ^; ~) y2 ^  J0 N6 S0 n4 z- [
159.                         WriteAddr+=pageremain;        
     9 I- O# P, v: w4 F  Q$ A! U/ O
160. 
     ; U; u7 t9 [9 X. k" |1 k
161.                         NumByteToWrite-=pageremain;                          //减去已经写入了的字节数
     . D5 F! k4 u6 P6 R0 p2 [
162.                         if(NumByteToWrite>256)pageremain=256; //一次可以写入256个字节
     
163.                         else pageremain=NumByteToWrite;           //不够256个字节了
     6 F+ a  n( v' K  r' x4 Z) I  Z* C' y
164.                 }
     
165.         };            
     & L5 H% z1 z4 |% g/ j0 M3 Z4 T/ t8 i# E
166. }
     # X4 ~; P9 i4 Q0 b+ {
167. //写SPI FLASH  
     * U. \1 t4 X9 D
168. //在指定地址开始写入指定长度的数据
     4 ~% |: F% Y% ?  E% G5 B2 @. e- b
169. //该函数带擦除操作!
     ( W4 n9 V3 C5 v( m
170. //pBuffer:数据存储区
       v1 L4 T5 U1 D0 Q( e6 F0 ~6 J
171. //WriteAddr:开始写入的地址(24bit)                                                
     " K% v& e9 L  n! [
172. //NumByteToWrite:要写入的字节数(最大65535)   
     
173. u8 W25QXX_BUFFER[4096];                 
     
174. void W25QXX_Write(u8* pBuffer,u32 WriteAddr,u16 NumByteToWrite)   
     , f1 N6 H# R; P, ?8 r$ H
175. {
     4 s( R' G) X  ~+ x/ }
176.         u32 secpos;
     
177.         u16 secoff;
     
178.         u16 secremain;           
     
179.          u16 i;   
     
180.         u8 * W25QXX_BUF;         
     3 z7 P) k3 I, p% Q
181.            W25QXX_BUF=W25QXX_BUFFER;            
     ! y) F  W" I% E/ V; G( r
182.          secpos=WriteAddr/4096;//扇区地址  
     
183.         secoff=WriteAddr%4096;//在扇区内的偏移
     : k1 H; \* v0 D; O- r6 T* m
184.         secremain=4096-secoff;//扇区剩余空间大小   
     
185.          //printf("ad:%X,nb:%X\r\n",WriteAddr,NumByteToWrite);//测试用
     
186.          if(NumByteToWrite<=secremain)secremain=NumByteToWrite;//不大于4096个字节
     
187.         while(1)
     
188.         {        
     6 _* X7 Z+ n: Z/ b- Q6 w9 ?" l
189.                 W25QXX_Read(W25QXX_BUF,secpos*4096,4096);//读出整个扇区的内容
     3 N' M' Z" y, G9 D0 }
190.                 for(i=0;i<secremain;i++)//校验数据
     
191.                 {
     
192.                         if(W25QXX_BUF[secoff+i]!=0XFF)break;//需要擦除            
     
193.                 }
     9 j# ]6 c4 t4 w+ n& Z
194.                 if(i<secremain)//需要擦除
     7 T0 G/ E1 Z; x0 _" q& y
195.                 {
     # l6 Y; V# X, y# g" _
196.                         W25QXX_Erase_Sector(secpos);//擦除这个扇区
     1 F- R8 T; N5 k. ?% J$ V
197.                         for(i=0;i<secremain;i++)           //复制
     ; @  F" i6 J3 w* L) `# y5 I
198.                         {
     - n/ |$ f' T9 X* m$ K
199.                                 W25QXX_BUF[i+secoff]=pBuffer<i>;         
     
200.                         }
     
201.                         W25QXX_Write_NoCheck(W25QXX_BUF,secpos*4096,4096);//写入整个扇区  
     # l; P7 R& S0 \6 ^! x5 o& \
202. 
     2 X$ P3 j# t" ]* j/ V3 h
203.                 }else W25QXX_Write_NoCheck(pBuffer,WriteAddr,secremain);//写已经擦除了的,直接写入扇区剩余区间.                                    
     
204.                 if(NumByteToWrite==secremain)break;//写入结束了
     
205.                 else//写入未结束
     ; U6 F4 ~! o; |+ }: [
206.                 {
     
207.                         secpos++;//扇区地址增1
     ; `/ g: {6 p8 b: |' W/ d1 l7 _
208.                         secoff=0;//偏移位置为0         
     
209. 
     
210.                            pBuffer+=secremain;  //指针偏移
     , Z) O& f5 e& A; ^. P1 p: C$ p
211.                         WriteAddr+=secremain;//写地址偏移           
     : j& `( O/ p" i
212.                            NumByteToWrite-=secremain;                                //字节数递减
     
213.                         if(NumByteToWrite>4096)secremain=4096;        //下一个扇区还是写不完
     % D( j+ K/ {% |: D; ]
214.                         else secremain=NumByteToWrite;                        //下一个扇区可以写完了
     
215.                 }         
     
216.         };         
     3 G  n, c- s2 f* y- T+ ^1 [
217. }
     " @1 P- L/ `7 ^- u6 k2 x5 x
218. //擦除整个芯片                  
     
219. //等待时间超长...
     
220. void W25QXX_Erase_Chip(void)   
     
221. {                                   
     
222.     W25QXX_Write_Enable();                  //SET WEL
     
223.     W25QXX_Wait_Busy();   
     # V* Q( V* T  w8 w2 g9 d& U
224.           W25QXX_CS=0;                            //使能器件   
     
225.     SPI1_ReadWriteByte(W25X_ChipErase);        //发送片擦除命令  
     1 z. P, f& \4 _; f
226.         W25QXX_CS=1;                            //取消片选                  
     2 {; J6 M1 ?5 p
227.         W25QXX_Wait_Busy();                                      //等待芯片擦除结束
     
228. }   
     + |6 V2 o& R4 z& ]
229. //擦除一个扇区
     
230. //Dst_Addr:扇区地址 根据实际容量设置
     
231. //擦除一个山区的最少时间:150ms
     $ m( E+ p+ j/ f5 b0 L# T: K
232. void W25QXX_Erase_Sector(u32 Dst_Addr)   
     1 i; v+ ]$ w& Y+ _- T: l
233. {  
     
234.         //监视falsh擦除情况,测试用   
     4 C9 _  u1 i3 b9 h3 B0 r
235.          printf("fe:%x\r\n",Dst_Addr);         
     
236.          Dst_Addr*=4096;
     . I; ?8 C  x. i' k5 P% E
237.     W25QXX_Write_Enable();                  //SET WEL         
     
238.     W25QXX_Wait_Busy();   
     * _6 z( I) @$ r: B7 N
239.           W25QXX_CS=0;                            //使能器件   
     
240.     SPI1_ReadWriteByte(W25X_SectorErase);      //发送扇区擦除指令
     6 b, x6 e, ?3 P9 t
241.     SPI1_ReadWriteByte((u8)((Dst_Addr)>>16));  //发送24bit地址   
     
242.     SPI1_ReadWriteByte((u8)((Dst_Addr)>>8));   
     
243.     SPI1_ReadWriteByte((u8)Dst_Addr);  
     , j4 r$ M1 W9 W: A+ F# T4 R  ~! Y
244.         W25QXX_CS=1;                            //取消片选                  
     ) Z* g) @0 z2 |9 q6 r* f) R
245.     W25QXX_Wait_Busy();                                      //等待擦除完成
     
246. }  
     
247. //等待空闲
     
248. void W25QXX_Wait_Busy(void)   
     1 M* D4 O, e% E$ h# v0 ~
249. {   
       Y' K  q3 T; @  \2 Z4 ^
250.         while((W25QXX_ReadSR()&0x01)==0x01);   // 等待BUSY位清空
     $ f/ I& E* S$ }
251. }  
     
252. //进入掉电模式
     
253. void W25QXX_PowerDown(void)   
     
254. {
     
255.           W25QXX_CS=0;                            //使能器件   
     2 N# n$ b! T5 H( C0 s" o
256.     SPI1_ReadWriteByte(W25X_PowerDown);        //发送掉电命令  
     ) M) F* e4 j2 @! q7 W; u
257.         W25QXX_CS=1;                            //取消片选                  
     
258.     delay_us(3);                               //等待TPD  
     8 U7 B( n( }' m4 N* \! x/ u) L: ~
259. }   
     2 J  e% g$ n1 j
260. //唤醒
     : W& G5 i* k% D
261. void W25QXX_WAKEUP(void)   
     8 h* {4 Q0 }) b$ n# n2 ?4 E% `# R
262. {  
     3 b, L; J" }* m3 ?, j5 P9 \
263.           W25QXX_CS=0;                            //使能器件   
     
264.     SPI1_ReadWriteByte(W25X_ReleasePowerDown);   //  send W25X_PowerDown command 0xAB   
     8 [; ?+ [* k( _, k3 z7 F
265.         W25QXX_CS=1;                            //取消片选                  
     
266.     delay_us(3);                               //等待TRES1
     ( r* w9 U( R# J1 {+ `8 F! A$ o
267. }   </i></i></i>

复制代码

1. 
   
2. W25Q12xx.h：
   
3. 
   3 O) }: Z) v" ~& @) @' M. c3 k5 b
4. #ifndef __W25QXX_H
   - B! e, F4 c6 d/ X, m
5. #define __W25QXX_H                           
   ; W  a) \5 l0 Z* e* g. m3 T
6. #include "sys.h"  
   
7. 
   / w( N! l; S7 T; y* {: Y- ]
8. //W25X系列/Q系列芯片列表           
   
9. //W25Q80  ID  0XEF13
   6 I4 v) C; t) `; y
10. //W25Q16  ID  0XEF14
    + _4 D' g; p- Q: H6 s) ?  P9 i# B
11. //W25Q32  ID  0XEF15
    
12. //W25Q64  ID  0XEF16        
    9 v2 {  F/ G/ w( Y0 [
13. //W25Q128 ID  0XEF17        
    6 y, R) [: E$ Y: j6 p6 {
14. #define W25Q80         0XEF13         
    $ a" s8 p# l% V% q. k' x4 S
15. #define W25Q16         0XEF14
    . w4 b, u6 k2 Y) I( R0 q
16. #define W25Q32         0XEF15
    0 Y. W) e1 P2 b2 R7 \/ `
17. #define W25Q64         0XEF16
    7 {- z  W8 G1 o0 w! ?* a8 f8 M
18. #define W25Q128        0XEF17
    
19. 
    
20. extern u16 W25QXX_TYPE;                                        //定义W25QXX芯片型号                  
    - _; n9 |) o$ Z1 o% c
21. 
    
22. #define        W25QXX_CS                 PBout(14)                  //W25QXX的片选信号
    3 V+ A, Y! ~6 i
23. //
    
24. //指令表
    ( X: y2 {1 `7 e, _( |
25. #define W25X_WriteEnable                0x06
    3 O- c4 r8 N7 ]0 U; a
26. #define W25X_WriteDisable                0x04
    % I( p( w# W' |% A
27. #define W25X_ReadStatusReg                0x05
    
28. #define W25X_WriteStatusReg                0x01
    9 ?3 h1 u6 d8 F$ B' y4 B1 B
29. #define W25X_ReadData                        0x03
    2 ~# n/ |7 t( ]: ?: {/ G
30. #define W25X_FastReadData                0x0B
    
31. #define W25X_FastReadDual                0x3B
    6 L8 y" w$ H) x) R2 G9 i
32. #define W25X_PageProgram                0x02
    ( Z& `( a" Y+ Q4 S7 s  C
33. #define W25X_BlockErase                        0xD8
    3 r* z3 q4 ]  n5 D" q2 E
34. #define W25X_SectorErase                0x20
    
35. #define W25X_ChipErase                        0xC7
    , G/ B; B7 m2 Q. w2 h  F) ?8 ]7 \8 A
36. #define W25X_PowerDown                        0xB9
    6 c8 m" y# ^& C; m( }- L8 e4 W& G
37. #define W25X_ReleasePowerDown        0xAB
    ; J7 Q& Z. }) n) P
38. #define W25X_DeviceID                        0xAB
    1 ^1 z, M: [" y2 z: s& X1 o
39. #define W25X_ManufactDeviceID        0x90
    / d- N& u) m# l' A$ D9 |
40. #define W25X_JedecDeviceID                0x9F
    
41. 
    
42. void W25QXX_Init(void);
    3 [  l! j! K( l7 H! t$ O# n1 T5 g
43. u16  W25QXX_ReadID(void);                              //读取FLASH ID
    * J1 [$ ~$ `5 Q" [
44. u8         W25QXX_ReadSR(void);                        //读取状态寄存器
    
45. void W25QXX_Write_SR(u8 sr);                          //写状态寄存器
    
46. void W25QXX_Write_Enable(void);                  //写使能
    
47. void W25QXX_Write_Disable(void);                //写保护
    ( `" e5 e2 @  I! D
48. void W25QXX_Write_NoCheck(u8* pBuffer,u32 WriteAddr,u16 NumByteToWrite);
    + P/ k. J' n( {* z5 R; [
49. void W25QXX_Read(u8* pBuffer,u32 ReadAddr,u16 NumByteToRead);   //读取flash
      ]2 w2 ?3 ~/ o. M' ^' r. M6 ]6 U
50. void W25QXX_Write(u8* pBuffer,u32 WriteAddr,u16 NumByteToWrite);//写入flash
    4 \7 {" N$ R/ V
51. void W25QXX_Erase_Chip(void);                      //整片擦除
    
52. void W25QXX_Erase_Sector(u32 Dst_Addr);        //扇区擦除
    $ I' p! J* q. d. t# r' u, [' C
53. void W25QXX_Wait_Busy(void);                   //等待空闲
    : F' Z, t6 S4 U( F  o
54. void W25QXX_PowerDown(void);                //进入掉电模式
      l* {. v3 p9 c5 Y" Y7 r* |: z6 Q
55. void W25QXX_WAKEUP(void);                                //唤醒
    
56. 
    % _& u7 w( b5 ~/ V) p$ o
57. #endif
    7 R/ `* O3 y$ C" |- a* S

复制代码

. @/ r% v% s4 }' ~main.c:

9 ~, F+ L9 J2 w' B

1. main.c:
   
2. #include "sys.h"
     w/ m1 V# {. B: w4 M0 R
3. #include "delay.h"
   
4. #include "usart.h"
   * @& |. g# d/ w& D' _
5. #include "led.h"
   / e9 ^0 f! n1 [- l
6. #include "lcd.h"
   # g* I8 U6 U  O) I
7. #include "spi.h"
   ; i3 s& t7 E. K$ E2 c/ i4 y. B  T0 p
8. #include "w25qxx.h"
   
9. #include "key.h"   
   
10. 
    
11. //要写入到W25Q16的字符串数组
    
12. const u8 TEXT_Buffer[]={"Explorer STM32F4 SPI TEST"};
    
13. #define SIZE sizeof(TEXT_Buffer)         
    
14.         
    
15. int main(void)
    
16. {
    6 Z; y6 d0 V" h0 }0 c
17.         u8 key;
    ) C; M! i9 _" f
18.         u16 i=0;
    
19.         u8 datatemp[SIZE];        
    7 J5 h. p$ y9 U
20.         NVIC_PriorityGroupConfig(NVIC_PriorityGroup_2);//设置系统中断优先级分组2
    3 t& i/ A# |. G( S
21.         delay_init(168);    //初始化延时函数
    . P4 p; W& P7 z% f, V; p- f1 l
22.         uart_init(115200);        //初始化串口波特率为115200
    6 W' s* t: W: g$ h
23.         LED_Init();                                        //初始化LED
    
24.         KEY_Init();                                 //按键初始化  
    
25.         W25QXX_Init();                        //W25QXX初始化
    3 {! t! T: l' s- p: s5 P
26.                         
    
27.          while(W25QXX_ReadID()!=W25Q128)        //检测不到W25Q128
    - s9 _0 n- M# `( v2 L
28.         {
    
29.                 printf("W25Q128 Check Failed!");
    0 l1 ~# P6 J$ Q. \& l3 u6 }
30.                 delay_ms(500);
    
31.                 printf("Please Check!      ");
    
32.                 delay_ms(500);
    
33.                 LED0=!LED0;                //DS0闪烁
    9 E/ S! T8 @* y9 h# }
34.         }
    ! l. ?, N2 f' ?4 X. [3 q
35.         
    
36.         while(1)
    
37.         {
    # g. C9 E* v, r# I# ^: O
38.                 key=KEY_Scan(0);
    
39.                 if(key==KEY1_PRES)//KEY1按下,写入24C02
    
40.                 {
    % [" u+ }, b0 I2 f+ m  c) j8 k
41.                         printf("Start Write W25Q128....");
    
42.                         //从倒数第100个地址处开始,写入SIZE长度的数据  
    
43.                         W25QXX_Write((u8*)TEXT_Buffer,FLASH_SIZE-100,SIZE);
    
44.                         printf("W25Q128 Write Finished!");  //提示传送完成
    4 G, L* r2 i" j3 Y
45.                 }
    & z0 x$ ^( z- |1 B
46.                 if(key==KEY0_PRES)//KEY0按下,读取字符串并显示
    3 |' c- Y& d; j) G3 Y/ A- t
47.                 {
    & Y2 A8 ^( q5 _7 p" i; u, I/ a
48.                         printf("Start Read W25Q128.... ");
    / V- b+ u6 X$ q+ y
49.                         //从倒数第100个地址处开始,读出SIZE个字节
      G) V' E! w# r8 d" w2 [7 ^" u
50.                         W25QXX_Read(datatemp,FLASH_SIZE-100,SIZE);                                       
    & g; l3 ~6 M4 Y) H( Y
51.                         printf("The Data Readed Is: \r\n ");//提示传送完成
    
52.                         printf("%s\r\n ",datatemp);
    6 K% B- V' f/ _7 [" c9 K
53.                 }           
    
54.         }            
    
55. }
    , N& D# z- L6 t+ V6 ~! E& y
56. 
    , N& y& l9 k) w% b

复制代码

( `1 \) S4 Z' j  U5 q' e" f7 f# }
% h9 K* Z' q3 k2 k1 x