一、SPI介绍
( O, h9 j. l. x% j/ r- ]( lSPI 是英语Serial Peripheral interface的缩写，顾名思义就是串行外围设备接口。是Motorola首先在其MC68HCXX系列处理器上定义的。SPI，是一种高速的，全双工，同步的通信总线，并且在芯片的管脚上只占用四根线，节约了芯片的管脚，同时为PCB的布局上节省空间，提供方便，主要应用在 EEPROM，FLASH，实时时钟，AD转换器，还有数字信号处理器和数字信号解码器之间。
' U! q8 N  O- N" Q0 \
6 ~0 A" z& _5 S0 w# p正是简单易用的特性，如NRF24L01、VS1053、SD卡等皆集成了这种通信协议
7 S& _. H& h4 {% X


& }% _( j& c  J; L7 r; k2 E4 I二、SPI接口框图

) e$ P: o) I/ Y1 I

三、SPI优缺点
4 u+ w6 ~: n. t6 Q5 R4 m  fSPI接口是在CPU和外围低速器件之间进行同步串行数据传输，在主器件的移位脉冲下，数据按位传输，低位在前，高位在后，为全双工通信，数据传输速度总体来说比I2C总线要快，速度可达到几Mbps。
0 I) E) F' x: M; _# K
( L6 ~# g( w/ H9 r信号线少，协议简单，相对数据速率高。

6 i* ~  d+ S( O$ b# a2 I缺点：没有指定的流控制，没有应答机制确认是否接收到数据

四、SPI工作原理总结
) R! r' }1 w; Y% F" W8 p6 r硬件上为4根线。
主机和从机都有一个串行移位寄存器，主机通过向它的SPI串行寄存器写入一个字节来发起一次传输。
- z& v% k& e; e8 Y+ P串行移位寄存器通过MOSI信号线将字节传送给从机，从机也将自己的串行移位寄存器中的内容通过MISO信号线返回给主机。这样，两个移位寄存器中的内容就被交换。
外设的写操作和读操作是同步完成的。如果只进行写操作，主机只需忽略接收到的字节；反之，若主机要读取从机的一个字节，就必须发送一个空字节来引发从机的传输。
多个设备使用SPI的应用举例



五、时序图
时序为 SPI_CR1 寄存器中的 LSBFIRST 位复位时的时序
) Z/ [0 ]( e7 U; @
9 d- C/ ?0 D6 |3 }; D. @, ISPI_CPHA的值将会影响SPI_CPOL的值
1 s: A5 E$ s( r5 W" x! A

4 j$ F8 s5 O0 Z
六、SPI程序编写过程
7 g0 S5 b1 C+ j9 N2 X+ d+ `

1. //①使能SPIx和IO口时钟
   8 o$ D0 `. J8 ~0 K( j
2. RCC_AHBxPeriphClockCmd() / RCC_APBxPeriphClockCmd();
   . f/ }- |: Q- T) z( M
3. 
   
4. //②初始化IO口为复用功能
   
5. void GPIO_Init(GPIO_TypeDef* GPIOx, GPIO_InitTypeDef* GPIO_InitStruct);
   / ?" ?7 g9 H" J/ x
6. 
   3 Z( O9 J( P4 ?8 X3 Y( ~8 z2 w
7. //③设置引脚复用映射：
   9 g" @  }) \2 {: j5 @2 j. b
8. GPIO_PinAFConfig();
   & q4 c4 k4 G/ ]( I# a# H6 ]7 o
9. 
   
10. //②初始化SPIx,设置SPIx工作模式
    0 N" P% {$ U, c- N
11. void SPI_Init(SPI_TypeDef* SPIx, SPI_InitTypeDef* SPI_InitStruct);
    4 K: E8 A( a" z# G
12. 
    3 O! r: ?; f8 o# l8 [! _* B
13. //③使能SPIx
    / t$ G; C: R% u( X. @
14. void SPI_Cmd(SPI_TypeDef* SPIx, FunctionalState NewState);
    , h2 c# g% C* A3 G
15. 
    
16. //④SPI传输数据
    ( h" _# i% G% G: q0 K, f
17. void SPI_I2S_SendData(SPI_TypeDef* SPIx, uint16_t Data);
    , A* r1 P! J9 ?( i8 T! B: U
18. uint16_t SPI_I2S_ReceiveData(SPI_TypeDef* SPIx) ;
      y* q6 d4 |  L( L
19. 
    
20. //⑦查看SPI传输状态
    
21. SPI_I2S_GetFlagStatus(SPI2, SPI_I2S_FLAG_RXNE);

复制代码

1. SPI.c:
   
2. #include "spi.h"
   
3. 
     ]" u* ~6 y5 {5 p, |
4. //以下是SPI模块的初始化代码，配置成主机模式                                                   
   
5. //SPI口初始化
   5 s: g7 T7 G3 C. I6 s- D
6. //这里针是对SPI1的初始化
   
7. void SPI1_Init(void)
   + p7 K  v+ h& P3 X/ {" C
8. {         
   
9.   GPIO_InitTypeDef  GPIO_InitStructure;
   
10.   SPI_InitTypeDef  SPI_InitStructure;
    
11.         
    ' s# ^& ]/ ^+ ?* z0 _9 e9 u$ o
12.   RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOB, ENABLE);//使能GPIOB时钟
    9 O, a/ g. ?! n5 X
13.   RCC_APB2PeriphClockCmd(RCC_APB2Periph_SPI1, ENABLE);//使能SPI1时钟
    7 w% Z& f9 s0 Y% H
14. 
      |" y) c) k) H3 ]
15.   //GPIOFB3,4,5初始化设置
    5 L% }6 Z9 I9 y: Q* N
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 f9 q! n. q$ Q! G5 c  [) ^- F
18.   GPIO_InitStructure.GPIO_OType = GPIO_OType_PP;//推挽输出
    
19.   GPIO_InitStructure.GPIO_Speed = GPIO_Speed_100MHz;//100MHz
    7 c6 F; \2 o3 W0 f8 t9 Y0 F2 x
20.   GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_UP;//上拉
    & |; Z8 \8 ~$ t# t! |4 L' a% T
21.   GPIO_Init(GPIOB, &GPIO_InitStructure);//初始化
    
22.         
    
23.         GPIO_PinAFConfig(GPIOB,GPIO_PinSource3,GPIO_AF_SPI1); //PB3复用为 SPI1
    " F9 R1 T/ o; g. I1 V+ E+ W
24.         GPIO_PinAFConfig(GPIOB,GPIO_PinSource4,GPIO_AF_SPI1); //PB4复用为 SPI1
    $ Y& {' Q+ x, m: j* K
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
    
30. 
    6 U) S) j! l  Y% l' l- j
31.         SPI_InitStructure.SPI_Direction = SPI_Direction_2Lines_FullDuplex;  //设置SPI单向或者双向的数据模式:SPI设置为双线双向全双工
    $ K$ @: D9 i! e4 I' a* G9 S0 ]$ A
32.         SPI_InitStructure.SPI_Mode = SPI_Mode_Master;                //设置SPI工作模式:设置为主SPI
    
33.         SPI_InitStructure.SPI_DataSize = SPI_DataSize_8b;                //设置SPI的数据大小:SPI发送接收8位帧结构
    ! o/ }! q! I, F1 b, t
34.         SPI_InitStructure.SPI_CPOL = SPI_CPOL_High;                //串行同步时钟的空闲状态为高电平
    
35.         SPI_InitStructure.SPI_CPHA = SPI_CPHA_2Edge;        //串行同步时钟的第二个跳变沿（上升或下降）数据被采样
    # a: M1 s9 p' X' B: R, V/ [% |+ P9 d. t
36.         SPI_InitStructure.SPI_NSS = SPI_NSS_Soft;                //NSS信号由硬件（NSS管脚）还是软件（使用SSI位）管理:内部NSS信号有SSI位控制
    
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值计算的多项式
    * l- u2 B7 e2 b: Z( f0 S! |# M
40.         SPI_Init(SPI1, &SPI_InitStructure);  //根据SPI_InitStruct中指定的参数初始化外设SPIx寄存器
    9 c! f* @  Q" Y
41. 
    4 z  |8 e4 O6 b7 C3 w
42.         SPI_Cmd(SPI1, ENABLE); //使能SPI外设
    
43. 
    1 l! \3 o% M/ d  _0 o
44.         SPI1_ReadWriteByte(0xff);//启动传输                 
    6 h. Z6 ~. ~- _3 i( o  G
45. }   
    
46. //SPI1速度设置函数
    0 i1 C, Y1 e, S0 s& x7 u: y8 h7 h
47. //SPI速度=fAPB2/分频系数
    & N  v5 U; V1 Q
48. //@ref SPI_BaudRate_Prescaler:SPI_BaudRatePrescaler_2~SPI_BaudRatePrescaler_256  
    
49. //fAPB2时钟一般为84Mhz：
    2 h8 g7 I* g4 c+ ~
50. void SPI1_SetSpeed(u8 SPI_BaudRatePrescaler)
    
51. {
    
52.   assert_param(IS_SPI_BAUDRATE_PRESCALER(SPI_BaudRatePrescaler));//判断有效性
    
53.         SPI1->CR1&=0XFFC7;//位3-5清零，用来设置波特率
    ( M  Q# Z& B2 ^/ A- g
54.         SPI1->CR1|=SPI_BaudRatePrescaler;        //设置SPI1速度
    
55.         SPI_Cmd(SPI1,ENABLE); //使能SPI1
    1 ?* y7 Z9 @- X+ T! m5 f
56. }
    ( ?3 C* @4 p% i! {$ s# f8 K% P
57. //SPI1 读写一个字节
    ( [4 S8 |0 i7 [& R
58. //TxData:要写入的字节
    " g5 d' E9 H0 p& P6 W9 k, B, r
59. //返回值:读取到的字节
    6 R, `# M& l0 c6 r$ s# L
60. u8 SPI1_ReadWriteByte(u8 TxData)
    
61. {                                          
    
62. 
    
63.   while (SPI_I2S_GetFlagStatus(SPI1, SPI_I2S_FLAG_TXE) == RESET){}//等待发送区空  
    0 \7 y# P# g  q' Q* ~* \
64.         
    , ~$ h2 T. z: z, \' Z# R, I7 N
65.         SPI_I2S_SendData(SPI1, TxData); //通过外设SPIx发送一个byte  数据
    1 e' q! V5 \. p+ G9 w' V
66.                
    : |$ x$ Q: a( V
67.   while (SPI_I2S_GetFlagStatus(SPI1, SPI_I2S_FLAG_RXNE) == RESET){} //等待接收完一个byte  
    
68. 
    
69.         return SPI_I2S_ReceiveData(SPI1); //返回通过SPIx最近接收的数据        
    
70.                      
    
71. }
    
72. 
    - t9 [4 H! B9 U' b3 {

复制代码

2 e! S, Y/ E$ }七、W25Q12xx的原理及应用
W25Q128将16M的容量分为256个块（Block),每个块大小为64K字节，每个块又分为16个扇区（Sector),每个扇区4K个字节。W25Q128的最小擦除单位为一个扇区，也就是每次必须擦除4K个字节。这样我们需要给W25Q128开辟一个至少4K的缓存区，这样对SRAM要求比较高，要求芯片必须有4K以上SRAM才能很好的操作。

W25Q128的擦写周期多达10W次，具有20年的数据保存期限，支持电压为2.7~3.6V,W25Q128支持标准的SPI,还支持双输出/四输出的SPI,最大SPI时钟可以到80Mhz(双输出时相当于160Mhz,四输出时相当于320M),更多的W25Q128的介绍，请参考W25Q128的DATASHEET。

  J# C3 |" L. D+ L
( |: W! W: C! {& [6 Y
+ X7 o5 a. q1 D$ CW25Q12xx可根据原理图查看，使用的是SPI总线通信协议
0 L3 p' v/ [  i  y7 n
* M0 e1 `+ }) x( O% b比如原子的原理图
0 j1 G# }' i: D- u
9 c7 V, @% ^- ^, w$ p

! g5 G* ]7 v9 z) O9 v7.1 分析W25Q128指令
可参考W25Qxx的数据手册，这里列出W25Q128部分指令：
2 S; M) U. E& O7 s1 J+ ~0 m
3 A% @1 X" ^3 c+ S; T9 P
# M# p5 d: S9 p. G
比如读取设备的ID的指令：0x90000000


3 p2 K% [$ e2 w1 {( A" |9 U/ a


1 c) [4 |3 U& \3 a# R# ~$ q
" w* D  s8 l3 e& c  e  y
7.2 擦除扇区：
, }3 [: [  N  w% n: q

& U% N' g0 ]1 B* G! V4 m) y5 {% _
7.3 部分常用设备读取指令：
% D. o# i% i# P

) C9 p  u) W! k7 J
每次操作前要使能写操作，且给一个低电平。结束时要给其为高电平，再失能写操作。也就是通过操作片选引脚来确定是否使能或失能。

1. W25Q12xx.c:
   
2. #include "w25qxx.h"
   
3. #include "spi.h"
   
4. #include "delay.h"           
   
5. #include "usart.h"        
   & v2 O& g. T1 |2 Y
6. 
   * H3 |. B/ h+ w% O8 Y2 [
7. u16 W25QXX_TYPE=W25Q128;        //默认是W25Q128
   1 [1 d, Z* y! V: T
8. 
   2 j' k5 h, x" _+ S2 ~) g' u
9. //4Kbytes为一个Sector
   
10. //16个扇区为1个Block
    
11. //W25Q128
    ' [: {8 i9 a- Y  j
12. //容量为16M字节,共有128个Block,4096个Sector
    
13.                                                                                                          
    
14. //初始化SPI FLASH的IO口
    
15. void W25QXX_Init(void)
    ; z. o- \& k% A7 D; Q
16. {
    
17.   GPIO_InitTypeDef  GPIO_InitStructure;
    
18. 
    + Z4 y5 o( P3 F5 V4 g8 g* b
19.   RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOB, ENABLE);//使能GPIOB时钟
    ; k# K; R4 @. F( k1 E2 t, f
20.   RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOG, ENABLE);//使能GPIOG时钟
    7 z- _+ ?/ f: t' w  ]9 \" Q% @
21. 
    # s0 y7 |4 q7 O) V2 A0 e! b2 u5 d
22.           //GPIOB14
    
23.   GPIO_InitStructure.GPIO_Pin = GPIO_Pin_14;//PB14
    
24.   GPIO_InitStructure.GPIO_Mode = GPIO_Mode_OUT;//输出
    
25.   GPIO_InitStructure.GPIO_OType = GPIO_OType_PP;//推挽输出
    ! C. Z( d/ p. l% ~
26.   GPIO_InitStructure.GPIO_Speed = GPIO_Speed_100MHz;//100MHz
    + @, q  j* |9 g$ v- v% y4 m$ a
27.   GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_UP;//上拉
    1 P6 z" w2 T# l$ b0 @
28.   GPIO_Init(GPIOB, &GPIO_InitStructure);//初始化
    
29. 
    : [8 g2 ~6 X: ]
30.         GPIO_InitStructure.GPIO_Pin = GPIO_Pin_7;//PG7
    ) H6 R5 y  x' X- _1 T0 e
31.   GPIO_Init(GPIOG, &GPIO_InitStructure);//初始化
    
32. 
      T$ V4 ~0 W2 z$ k6 s. v
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时钟,高速模式
    
37.         W25QXX_TYPE=W25QXX_ReadID();        //读取FLASH ID.
    
38. }  
    9 J* N4 R# e- |4 `- Z
39. 
    
40. //读取W25QXX的状态寄存器
    / B* h& V1 o# w
41. //BIT7  6   5   4   3   2   1   0
    
42. //SPR   RV  TB BP2 BP1 BP0 WEL BUSY
    
43. //SPR:默认0,状态寄存器保护位,配合WP使用
    1 f/ J# }- T+ a6 w  R# w( g
44. //TB,BP2,BP1,BP0:FLASH区域写保护设置
    + K9 s/ c2 R) m( W* W
45. //WEL:写使能锁定
    
46. //BUSY:忙标记位(1,忙;0,空闲)
    
47. //默认:0x00
    % L7 Z0 @2 F  y! g
48. u8 W25QXX_ReadSR(void)   
    
49. {  
    
50.         u8 byte=0;   
    8 b* ~; D  @9 |/ i/ Y" p6 V
51.         W25QXX_CS=0;                            //使能器件   
    ; P) r! p- ^% z# f5 Y
52.         SPI1_ReadWriteByte(W25X_ReadStatusReg);    //发送读取状态寄存器命令   
    
53.         byte=SPI1_ReadWriteByte(0Xff);             //读取一个字节  
    
54.         W25QXX_CS=1;                            //取消片选     
    
55.         return byte;   
    
56. }
    . y$ x+ d; H5 q. g! e
57. //写W25QXX状态寄存器
    
58. //只有SPR,TB,BP2,BP1,BP0(bit 7,5,4,3,2)可以写!!!
    
59. void W25QXX_Write_SR(u8 sr)   
    
60. {   
    
61.         W25QXX_CS=0;                            //使能器件   
    
62.         SPI1_ReadWriteByte(W25X_WriteStatusReg);   //发送写取状态寄存器命令   
    
63.         SPI1_ReadWriteByte(sr);               //写入一个字节  
    
64.         W25QXX_CS=1;                            //取消片选                  
    
65. }   
    
66. //W25QXX写使能        
    
67. //将WEL置位   
    + \) t3 x8 L7 Y/ l( g6 P! F
68. void W25QXX_Write_Enable(void)   
    
69. {
    
70.         W25QXX_CS=0;                            //使能器件   
    ; r  r3 E' Q  r* u
71.     SPI1_ReadWriteByte(W25X_WriteEnable);      //发送写使能  
    ; o% m4 x" F1 R! q
72.         W25QXX_CS=1;                            //取消片选                  
    ; {* d) e; N( H* x2 \# C9 }
73. }
    
74. //W25QXX写禁止        
    
75. //将WEL清零  
    ( ~" Q' A2 g; s) \1 I
76. void W25QXX_Write_Disable(void)   
    
77. {  
    ' v# {$ j7 B' V' X5 b& f3 r8 L6 Y+ {
78.         W25QXX_CS=0;                            //使能器件   
    
79.     SPI1_ReadWriteByte(W25X_WriteDisable);     //发送写禁止指令   
    
80.         W25QXX_CS=1;                            //取消片选                  
    
81. }                 
    . w: p3 B* q2 `- ^& x
82. //读取芯片ID
    7 k0 v5 X1 ?- x/ w% b$ ?8 w( A% G( ?0 E! O
83. //返回值如下:                                   
    ( I  U1 ], Y$ ~3 b$ ]+ Q
84. //0XEF13,表示芯片型号为W25Q80  
    
85. //0XEF14,表示芯片型号为W25Q16   
    
86. //0XEF15,表示芯片型号为W25Q32  
    , ]5 g  C8 s  j
87. //0XEF16,表示芯片型号为W25Q64
    
88. //0XEF17,表示芯片型号为W25Q128           
    
89. u16 W25QXX_ReadID(void)
    
90. {
    
91.         u16 Temp = 0;         
    % r; g2 t% n& ]/ f+ ]  h
92.         W25QXX_CS=0;                                    
    
93.         SPI1_ReadWriteByte(0x90);//发送读取ID命令            
    
94.         SPI1_ReadWriteByte(0x00);            
    
95.         SPI1_ReadWriteByte(0x00);            
    
96.         SPI1_ReadWriteByte(0x00);                                    
    , h$ U8 x- i& Q: Q( B3 d0 `! W
97.         Temp|=SPI1_ReadWriteByte(0xFF)<<8;  
    
98.         Temp|=SPI1_ReadWriteByte(0xFF);         
    " E7 G& C8 M/ x* M' F3 {
99.         W25QXX_CS=1;                                    
    9 l& S1 r% P6 {( Z8 j% n/ V3 ?# \
100.         return Temp;
     & ]2 u, _! G% ~4 C
101. }                       
     
102. //读取SPI FLASH  
     
103. //在指定地址开始读取指定长度的数据
     9 I1 W7 ~  h$ o4 B0 Q5 ]
104. //pBuffer:数据存储区
     
105. //ReadAddr:开始读取的地址(24bit)
     8 h  {+ y' a3 I8 [5 {
106. //NumByteToRead:要读取的字节数(最大65535)
     
107. void W25QXX_Read(u8* pBuffer,u32 ReadAddr,u16 NumByteToRead)   
     
108. {
     
109.          u16 i;                                                                                       
     % }$ @! r. e3 u( p4 n2 W$ m" h! I- X; a
110.         W25QXX_CS=0;                            //使能器件   
     
111.     SPI1_ReadWriteByte(W25X_ReadData);         //发送读取命令   
     
112.     SPI1_ReadWriteByte((u8)((ReadAddr)>>16));  //发送24bit地址   
     
113.     SPI1_ReadWriteByte((u8)((ReadAddr)>>8));   
     
114.     SPI1_ReadWriteByte((u8)ReadAddr);   
     
115.     for(i=0;i<NumByteToRead;i++)
     
116.         {
     
117.         pBuffer<i>=SPI1_ReadWriteByte(0XFF);   //循环读数  
     
118.     }
     / l% p2 p3 }; l1 b. M4 Y
119.         W25QXX_CS=1;                                                   
       h* i2 ?6 S* ]' E/ ^0 @
120. }  
     3 \0 E5 J4 y+ T+ h0 }! X( z
121. //SPI在一页(0~65535)内写入少于256个字节的数据
     
122. //在指定地址开始写入最大256字节的数据
     
123. //pBuffer:数据存储区
     9 ]0 L" I+ w; x9 S
124. //WriteAddr:开始写入的地址(24bit)
     
125. //NumByteToWrite:要写入的字节数(最大256),该数不应该超过该页的剩余字节数!!!         
     
126. void W25QXX_Write_Page(u8* pBuffer,u32 WriteAddr,u16 NumByteToWrite)
     
127. {
     8 L3 C! s9 N. _5 h0 y- ?$ o# i
128.          u16 i;  
     0 q* [4 x1 \" \( u0 n8 [
129.     W25QXX_Write_Enable();                  //SET WEL
     6 v$ ?3 l, N% j1 o+ C" S% @9 T
130.         W25QXX_CS=0;                            //使能器件   
     & v& ^8 U; p6 Z
131.     SPI1_ReadWriteByte(W25X_PageProgram);      //发送写页命令   
     
132.     SPI1_ReadWriteByte((u8)((WriteAddr)>>16)); //发送24bit地址   
     
133.     SPI1_ReadWriteByte((u8)((WriteAddr)>>8));   
     
134.     SPI1_ReadWriteByte((u8)WriteAddr);   
     ) k, n- a* F# A" S' l$ \' \
135.     for(i=0;i<NumByteToWrite;i++)SPI1_ReadWriteByte(pBuffer<i>);//循环写数  
     
136.         W25QXX_CS=1;                            //取消片选
     
137.         W25QXX_Wait_Busy();                                           //等待写入结束
     + P6 F& ~! A, P6 M' i2 n
138. }
     ' S1 w; L8 o' t# q
139. //无检验写SPI FLASH
     
140. //必须确保所写的地址范围内的数据全部为0XFF,否则在非0XFF处写入的数据将失败!
     
141. //具有自动换页功能
     8 _- W7 S  H1 t/ [1 Z' J
142. //在指定地址开始写入指定长度的数据,但是要确保地址不越界!
     2 f  W. ~- C9 `$ m
143. //pBuffer:数据存储区
     4 Y$ i5 h' h: I( a! P
144. //WriteAddr:开始写入的地址(24bit)
     
145. //NumByteToWrite:要写入的字节数(最大65535)
     
146. //CHECK OK
     1 R8 t% d" Z, C# u% z' D" D" r5 [
147. void W25QXX_Write_NoCheck(u8* pBuffer,u32 WriteAddr,u16 NumByteToWrite)   
     - t/ E& D$ E, l, K3 \) T
148. {                                          
     8 _7 Y, L  p- o2 e- R& B6 C
149.         u16 pageremain;           
     4 A6 ]. e& Y' n% @
150.         pageremain=256-WriteAddr%256; //单页剩余的字节数                             
     
151.         if(NumByteToWrite<=pageremain)pageremain=NumByteToWrite;//不大于256个字节
     4 G' i: d4 c5 L" W' L8 S
152.         while(1)
     
153.         {           
     
154.                 W25QXX_Write_Page(pBuffer,WriteAddr,pageremain);
     # \2 b" k! Z4 k! x. V; @+ p" H& f
155.                 if(NumByteToWrite==pageremain)break;//写入结束了
     
156.                  else //NumByteToWrite>pageremain
     " y' p4 v/ ]5 o  r/ ~& h2 _5 Y
157.                 {
     # T  a& F" d3 [( b7 l7 |
158.                         pBuffer+=pageremain;
     
159.                         WriteAddr+=pageremain;        
     9 L! C$ ~, P# |4 ?+ S- M" g7 K& O
160. 
     ' [8 m8 {- X; E$ z1 R! Q
161.                         NumByteToWrite-=pageremain;                          //减去已经写入了的字节数
     
162.                         if(NumByteToWrite>256)pageremain=256; //一次可以写入256个字节
     
163.                         else pageremain=NumByteToWrite;           //不够256个字节了
     
164.                 }
     : \3 d* g2 Y! q% R/ t3 X
165.         };            
     8 O4 y0 G$ j! n! {& z$ R
166. }
     
167. //写SPI FLASH  
     $ W1 F) g' }3 c& A# k
168. //在指定地址开始写入指定长度的数据
     
169. //该函数带擦除操作!
     # B7 p5 d! x) F+ m) ~8 l
170. //pBuffer:数据存储区
     
171. //WriteAddr:开始写入的地址(24bit)                                                
     
172. //NumByteToWrite:要写入的字节数(最大65535)   
     4 T* b) A/ o* ?
173. u8 W25QXX_BUFFER[4096];                 
     ( P- a8 Q, Z) w* r! s- {
174. void W25QXX_Write(u8* pBuffer,u32 WriteAddr,u16 NumByteToWrite)   
     
175. {
     7 e5 y& _. a! R: |, r( O
176.         u32 secpos;
     7 R- u# A4 `8 Y- k6 Y1 o& g, V
177.         u16 secoff;
     ) s6 {3 B6 Q& c/ g5 x
178.         u16 secremain;           
     % Q( U5 O+ o5 N
179.          u16 i;   
     4 h2 O( h' J* A' K" o$ a
180.         u8 * W25QXX_BUF;         
     
181.            W25QXX_BUF=W25QXX_BUFFER;            
     , B+ U% ~. ]( d
182.          secpos=WriteAddr/4096;//扇区地址  
     
183.         secoff=WriteAddr%4096;//在扇区内的偏移
     
184.         secremain=4096-secoff;//扇区剩余空间大小   
     
185.          //printf("ad:%X,nb:%X\r\n",WriteAddr,NumByteToWrite);//测试用
     
186.          if(NumByteToWrite<=secremain)secremain=NumByteToWrite;//不大于4096个字节
     ' N$ F$ j) N7 w$ O$ ?' S5 U* T4 q* s
187.         while(1)
     , v" A2 Z  ~$ D2 u# [9 D9 Z, F
188.         {        
     
189.                 W25QXX_Read(W25QXX_BUF,secpos*4096,4096);//读出整个扇区的内容
     0 h/ Y) r+ S6 N% ?% o; Q, \4 d
190.                 for(i=0;i<secremain;i++)//校验数据
     $ a- y; d* @/ j0 n
191.                 {
     4 q$ }/ V: N2 W  ?1 V
192.                         if(W25QXX_BUF[secoff+i]!=0XFF)break;//需要擦除            
     
193.                 }
     
194.                 if(i<secremain)//需要擦除
     
195.                 {
     
196.                         W25QXX_Erase_Sector(secpos);//擦除这个扇区
     
197.                         for(i=0;i<secremain;i++)           //复制
     $ u8 d4 z: k4 V2 o5 ~' r$ Z( {! k
198.                         {
     
199.                                 W25QXX_BUF[i+secoff]=pBuffer<i>;         
     " H5 O3 \& p/ J& A, p
200.                         }
     
201.                         W25QXX_Write_NoCheck(W25QXX_BUF,secpos*4096,4096);//写入整个扇区  
     8 S3 P2 L2 x# z
202. 
     
203.                 }else W25QXX_Write_NoCheck(pBuffer,WriteAddr,secremain);//写已经擦除了的,直接写入扇区剩余区间.                                    
     
204.                 if(NumByteToWrite==secremain)break;//写入结束了
     2 x; X3 q$ R2 j, U
205.                 else//写入未结束
     
206.                 {
     
207.                         secpos++;//扇区地址增1
     
208.                         secoff=0;//偏移位置为0         
     
209. 
     
210.                            pBuffer+=secremain;  //指针偏移
     / i8 `& N  R: M! m  s
211.                         WriteAddr+=secremain;//写地址偏移           
     $ |* X4 L) K) ]
212.                            NumByteToWrite-=secremain;                                //字节数递减
     - a+ `5 r8 e/ j1 i
213.                         if(NumByteToWrite>4096)secremain=4096;        //下一个扇区还是写不完
     
214.                         else secremain=NumByteToWrite;                        //下一个扇区可以写完了
     / Q. j2 v2 T- Z) {
215.                 }         
     
216.         };         
     , D. ]# z/ ^% D4 g0 |4 B9 W0 t
217. }
     
218. //擦除整个芯片                  
     
219. //等待时间超长...
     . t3 M- V9 w. p6 i8 h0 ]  Z
220. void W25QXX_Erase_Chip(void)   
     " k& S  y9 y4 o7 A% X
221. {                                   
     + P7 D) Y$ y2 m
222.     W25QXX_Write_Enable();                  //SET WEL
     0 G! l' h/ @0 I% e2 Q) v
223.     W25QXX_Wait_Busy();   
     
224.           W25QXX_CS=0;                            //使能器件   
     
225.     SPI1_ReadWriteByte(W25X_ChipErase);        //发送片擦除命令  
     2 f) ?' C  K6 l% m, k$ |! E
226.         W25QXX_CS=1;                            //取消片选                  
     
227.         W25QXX_Wait_Busy();                                      //等待芯片擦除结束
       q$ P4 }$ A% y; Z% s+ y$ r
228. }   
     
229. //擦除一个扇区
     
230. //Dst_Addr:扇区地址 根据实际容量设置
     # U% s2 s+ N0 E! C, r. z" B1 u
231. //擦除一个山区的最少时间:150ms
     
232. void W25QXX_Erase_Sector(u32 Dst_Addr)   
     & V! j$ a0 Q3 b' g
233. {  
     
234.         //监视falsh擦除情况,测试用   
     
235.          printf("fe:%x\r\n",Dst_Addr);         
     8 [& {- p6 c8 Q5 m1 K+ F* |
236.          Dst_Addr*=4096;
     
237.     W25QXX_Write_Enable();                  //SET WEL         
     
238.     W25QXX_Wait_Busy();   
     ; ^/ o) t$ K& B9 ~8 T/ w! w# ]
239.           W25QXX_CS=0;                            //使能器件   
     6 P  i6 T7 u$ I0 P
240.     SPI1_ReadWriteByte(W25X_SectorErase);      //发送扇区擦除指令
     2 @0 u: h8 [! R/ O0 V1 t
241.     SPI1_ReadWriteByte((u8)((Dst_Addr)>>16));  //发送24bit地址   
     + R* Z+ Y" v8 L! X3 H) R) u
242.     SPI1_ReadWriteByte((u8)((Dst_Addr)>>8));   
     ; h  W8 I3 W( x7 H- g# }4 J* |8 @
243.     SPI1_ReadWriteByte((u8)Dst_Addr);  
     
244.         W25QXX_CS=1;                            //取消片选                  
     
245.     W25QXX_Wait_Busy();                                      //等待擦除完成
     
246. }  
     6 T% @! o  V2 e$ \3 ?+ ^
247. //等待空闲
     & J4 L0 N3 t6 v
248. void W25QXX_Wait_Busy(void)   
     
249. {   
     - Q2 q5 y7 N. R$ I/ q) J
250.         while((W25QXX_ReadSR()&0x01)==0x01);   // 等待BUSY位清空
     
251. }  
     
252. //进入掉电模式
     6 n( B' U0 w' h7 V) c6 L+ u+ ]
253. void W25QXX_PowerDown(void)   
     
254. {
     
255.           W25QXX_CS=0;                            //使能器件   
     . k7 c, i' J; ^& `
256.     SPI1_ReadWriteByte(W25X_PowerDown);        //发送掉电命令  
     * K  L+ ~* \% l
257.         W25QXX_CS=1;                            //取消片选                  
     
258.     delay_us(3);                               //等待TPD  
     
259. }   
     " r" K/ i! F4 `( m6 S0 N+ V+ Z% u, [
260. //唤醒
     + T6 X( Z0 N* }; I  W; L  {8 L  `
261. void W25QXX_WAKEUP(void)   
     1 y8 j! H) @8 b2 }( v0 H3 T
262. {  
     
263.           W25QXX_CS=0;                            //使能器件   
     7 U1 p3 U) H5 X' V3 S5 r3 ^
264.     SPI1_ReadWriteByte(W25X_ReleasePowerDown);   //  send W25X_PowerDown command 0xAB   
     
265.         W25QXX_CS=1;                            //取消片选                  
     * y6 R7 b! _- J# E9 C. [
266.     delay_us(3);                               //等待TRES1
     
267. }   </i></i></i>

复制代码

1. 
   
2. W25Q12xx.h：
   
3. 
   8 C% u- F: N- x) m# ~- W
4. #ifndef __W25QXX_H
   
5. #define __W25QXX_H                           
   + @1 l9 i# c" O* F4 o
6. #include "sys.h"  
   , Z8 v$ a% p9 K
7. 
   5 k4 Q. H5 k1 ^* @
8. //W25X系列/Q系列芯片列表           
   
9. //W25Q80  ID  0XEF13
   6 S4 l7 q/ P4 u2 Y& t* X
10. //W25Q16  ID  0XEF14
    4 \; J/ a, W" e! x$ Q
11. //W25Q32  ID  0XEF15
    5 o% H; X9 Y6 N/ h: ]* U' i
12. //W25Q64  ID  0XEF16        
    
13. //W25Q128 ID  0XEF17        
    . o4 u# ^9 i" d0 ^
14. #define W25Q80         0XEF13         
    
15. #define W25Q16         0XEF14
    
16. #define W25Q32         0XEF15
      Z" ~' s9 P) n9 c  {: }
17. #define W25Q64         0XEF16
    
18. #define W25Q128        0XEF17
    
19. 
    
20. extern u16 W25QXX_TYPE;                                        //定义W25QXX芯片型号                  
    6 z0 V/ N3 X, @+ I5 U
21. 
    7 L2 y7 n. }5 c
22. #define        W25QXX_CS                 PBout(14)                  //W25QXX的片选信号
    # e+ h' Z; g6 o
23. //
    
24. //指令表
    
25. #define W25X_WriteEnable                0x06
    + e  U7 t5 [$ O) E% G- w
26. #define W25X_WriteDisable                0x04
    / K/ T) k6 `: o6 J0 Y
27. #define W25X_ReadStatusReg                0x05
    
28. #define W25X_WriteStatusReg                0x01
    
29. #define W25X_ReadData                        0x03
    
30. #define W25X_FastReadData                0x0B
    3 ^& z" I- H% z. ]* ^
31. #define W25X_FastReadDual                0x3B
    $ k! `: V0 z. l+ @3 ~
32. #define W25X_PageProgram                0x02
    ; ]. x( q6 d) s" z3 w$ S6 F
33. #define W25X_BlockErase                        0xD8
    0 l: s. r' K2 }# j
34. #define W25X_SectorErase                0x20
    . d" r. V4 v4 W8 v
35. #define W25X_ChipErase                        0xC7
    
36. #define W25X_PowerDown                        0xB9
    " P; E0 u. T( _: P
37. #define W25X_ReleasePowerDown        0xAB
    
38. #define W25X_DeviceID                        0xAB
    / R& e! Y; f3 s% N; }
39. #define W25X_ManufactDeviceID        0x90
    ' r, B" K" t" C5 ^7 ~
40. #define W25X_JedecDeviceID                0x9F
    " E# c! U7 h" g
41. 
    : J- h0 [( Z- }% X# G
42. void W25QXX_Init(void);
    
43. u16  W25QXX_ReadID(void);                              //读取FLASH ID
    
44. u8         W25QXX_ReadSR(void);                        //读取状态寄存器
    0 [# T( ~1 N) c* \# Q1 H6 G, g
45. void W25QXX_Write_SR(u8 sr);                          //写状态寄存器
    * s7 X; ~% N: E, P5 e
46. void W25QXX_Write_Enable(void);                  //写使能
    
47. void W25QXX_Write_Disable(void);                //写保护
    ( r' T3 h* l: u/ v% ~) `" J
48. void W25QXX_Write_NoCheck(u8* pBuffer,u32 WriteAddr,u16 NumByteToWrite);
    9 t$ J- M/ G9 G( n
49. void W25QXX_Read(u8* pBuffer,u32 ReadAddr,u16 NumByteToRead);   //读取flash
    
50. void W25QXX_Write(u8* pBuffer,u32 WriteAddr,u16 NumByteToWrite);//写入flash
    
51. void W25QXX_Erase_Chip(void);                      //整片擦除
    2 @3 w. n6 v, I! t9 i
52. void W25QXX_Erase_Sector(u32 Dst_Addr);        //扇区擦除
    6 ^- e3 t8 E& Q# W7 i0 d
53. void W25QXX_Wait_Busy(void);                   //等待空闲
    , C& K1 N/ a. l  d
54. void W25QXX_PowerDown(void);                //进入掉电模式
    9 |5 s; d' M: Z+ n
55. void W25QXX_WAKEUP(void);                                //唤醒
    
56. 
    ( v2 q8 _. G' M
57. #endif
    7 s. I/ j7 x  h$ G

复制代码

main.c:
$ A1 p, g& B( P  y, R( A

1. main.c:
   
2. #include "sys.h"
   
3. #include "delay.h"
   ) s" u: A* O& @# O' v
4. #include "usart.h"
   
5. #include "led.h"
   
6. #include "lcd.h"
   
7. #include "spi.h"
   & l( r6 Z* w4 p4 [) p7 p
8. #include "w25qxx.h"
   , P4 `) Z5 K4 e# L, r% {* q8 V
9. #include "key.h"   
   
10. 
    
11. //要写入到W25Q16的字符串数组
    . B/ V8 }) r% t, o# a3 l
12. const u8 TEXT_Buffer[]={"Explorer STM32F4 SPI TEST"};
    . V1 c- V3 u7 \' d" P5 n$ B* {! a
13. #define SIZE sizeof(TEXT_Buffer)         
    
14.         
    6 [  x( p# i) s: Q8 [9 a* ~% @3 Y8 t3 ]
15. int main(void)
    8 }4 _) Q" Q* R. T
16. {
    
17.         u8 key;
    
18.         u16 i=0;
    
19.         u8 datatemp[SIZE];        
    : E  q$ r4 h9 x. v
20.         NVIC_PriorityGroupConfig(NVIC_PriorityGroup_2);//设置系统中断优先级分组2
    
21.         delay_init(168);    //初始化延时函数
    
22.         uart_init(115200);        //初始化串口波特率为115200
    
23.         LED_Init();                                        //初始化LED
    % U7 U/ }6 o+ |  S7 j  X
24.         KEY_Init();                                 //按键初始化  
    
25.         W25QXX_Init();                        //W25QXX初始化
    
26.                         
    
27.          while(W25QXX_ReadID()!=W25Q128)        //检测不到W25Q128
      r( x9 a. B. w4 d. ~. r
28.         {
    
29.                 printf("W25Q128 Check Failed!");
    ' N" m3 i0 i, |  b
30.                 delay_ms(500);
    
31.                 printf("Please Check!      ");
    
32.                 delay_ms(500);
    6 U, o- D. H1 V  D
33.                 LED0=!LED0;                //DS0闪烁
    
34.         }
    
35.         
    
36.         while(1)
    
37.         {
    ; T8 O2 d! K2 O9 @+ r
38.                 key=KEY_Scan(0);
    
39.                 if(key==KEY1_PRES)//KEY1按下,写入24C02
    
40.                 {
    
41.                         printf("Start Write W25Q128....");
    5 W& s6 T4 p4 W  X# e4 h8 X: H
42.                         //从倒数第100个地址处开始,写入SIZE长度的数据  
    ) z. e* L( q3 x1 E$ `
43.                         W25QXX_Write((u8*)TEXT_Buffer,FLASH_SIZE-100,SIZE);
    4 J- E( n4 m" B: \1 J& @
44.                         printf("W25Q128 Write Finished!");  //提示传送完成
    
45.                 }
    
46.                 if(key==KEY0_PRES)//KEY0按下,读取字符串并显示
    
47.                 {
    , ?4 X9 D  x. \: D' H  A
48.                         printf("Start Read W25Q128.... ");
    
49.                         //从倒数第100个地址处开始,读出SIZE个字节
    
50.                         W25QXX_Read(datatemp,FLASH_SIZE-100,SIZE);                                       
    + D) C  Z1 I& f, j3 w1 j, e/ L
51.                         printf("The Data Readed Is: \r\n ");//提示传送完成
    % d5 v- A/ V2 a8 Z! h9 i3 d! \
52.                         printf("%s\r\n ",datatemp);
    
53.                 }           
    * W1 L" O. z1 X. j8 E8 V( p& R4 |" y
54.         }            
    
55. }
    
56. 
    

复制代码

5 A+ `7 G; p* ]
) V# J! I+ P! I0 L