SPI协议：是由摩托罗拉公司提出的通讯协议(Serial Peripheral Interface)，即串行外围设备接口，是一种高速全双工的通信总线。它被广泛地使用在ADC、LCD 等设备与MCU 间，要求通讯速率较高的场合。

物理层：

S S  ( Slave Select)：从设备选择信号线，常称为片选信号线，也称为NSS、CS，以下用NSS 表示。当有多个SPI 从设备与SPI 主机相连时，设备的其它信号线SCK、MOSI及MISO 同时并联到相同的SPI 总线上，即无论有多少个从设备，都共同只使用这3 条总线；而每个从设备都有独立的这一条NSS 信号线，本信号线独占主机的一个引脚，即有多少个从设备，就有多少条片选信号线。I2C  协议中通过设备地址来寻址、选中总线上的某个设备并与其进行通讯；而SPI 协议中没有设备地址，它使用NSS 信号线来寻址，当主机要选择从设备时，把该从设备的NSS 信号线设置为低电平，该从设备即被选中，即片选有效，接着主机开始与被选中的从设备进行SPI通讯。所以SPI通讯以NSS 线置低电平为开始信号，以NSS 线被拉高作为结束信号。

SCK (Serial Clock)：时钟信号线，用于通讯数据同步。它由通讯主机产生，决定了通讯的速率，不同的设备支持的最高时钟频率不一样，如STM32 的SPI 时钟频率最大为fpclk/2，两个设备之间通讯时，通讯速率受限于低速设备。

MOSI (Master Output，Slave Input)：主设备输出/从设备输入引脚。主机的数据从这条信号线输出，从机由这条信号线读入主机发送的数据，即这条线上数据的方向为主机到从机。

. b# N% `1 O9 R% h+ w; i

MISO(Master Input,，Slave Output)：主设备输入/从设备输出引脚。主机从这条信号线读入数据，从机的数据由这条信号线输出到主机，即在这条线上数据的方向为从机到主机，只有这条线的信号由从机产生。

SPI设备之间的常用连线方式如下：

$ l: W. o, C- _' O

协议层：

SPI 一共有四种通讯模式，它们的主要区别是总线空闲时SCK 的时钟状态以及数据采样时刻。为方便说明，在此引入“时钟极性CPOL”和“时钟相位CPHA”的概念。时钟极性CPOL 是指SPI 通讯设备处于空闲状态时，SCK 信号线的电平信号(即SPI 通讯开始前、NSS 线为高电平时SCK 的状态)。CPOL=0 时，SCK 在空闲状态时为低电平，CPOL=1 时，则相反。时钟相位CPHA 是指数据的采样的时刻，当CPHA=0 时，MOSI 或MISO 数据线上的信号将会在SCK 时钟线的“奇数边沿”被采样。当CPHA=1 时，数据线在SCK 的“偶数边沿”采样。

7 _6 t% ?# `  u  @+ Z2 Q

bsp_spi_flash.h文件：

1. #ifndef __SPI_FLASH_H
   
2. #define __SPI_FLASH_H
   
3. 
   " ^" C# S! z- s7 f- h
4. #include "stm32f10x.h"
   ( j- p6 Y0 ?7 Q0 C
5. #include <stdio.h>
   / u- A; n' b/ W% A
6. #define  sFLASH_ID    0XEF4017
   
7. #define  SPI_FLASH_PageSize   256
   
8. #define  SPI_FLASH_PerWritePageSize 256
   
9. //Flash命令定义
   
10. #define W25X_WriteEnable              0x06
    
11. #define W25X_WriteDisable              0x04
    
12. #define W25X_ReadStatusReg            0x05
    
13. #define W25X_WriteStatusReg            0x01
    : Y: \$ f/ \) \2 w2 c- h
14. #define W25X_ReadData                    0x03
    ( Q! X6 }4 z$ f$ ^
15. #define W25X_FastReadData              0x0B
    % `$ |9 }# Q4 {1 ~; |
16. #define W25X_FastReadDual              0x3B
    
17. #define W25X_PageProgram              0x02
    6 J$ p, t( T  D) k  M5 M
18. #define W25X_BlockErase                  0xD8
    + i6 H: v0 s. R1 T# ]2 r
19. #define W25X_SectorErase              0x20
    * F' S; _- f; a; ]. \) X7 a
20. #define W25X_ChipErase                  0xC7
    ) O8 {" I# ?  U6 f& S$ E5 P
21. #define W25X_PowerDown                  0xB9
    5 B/ b/ K  b8 @: S. S7 R
22. #define W25X_ReleasePowerDown        0xAB
    
23. #define W25X_DeviceID                    0xAB
    ; `1 A* h/ T8 s# Z' D7 [" B
24. #define W25X_ManufactDeviceID       0x90
    
25. #define W25X_JedecDeviceID            0x9F
    # o( q( _/ C# A% [- {. z$ I  f
26. //WIP（busy) 标志，Flash内部正在写入
    
27. #define WIP_flag   0x01
    
28. #define Dummy_Byte 0xFF
    / @( `  Z4 R- O8 J  y6 M* |% {
29. //SPI接口定义
    
30. #define FLASH_SPIx   SPI1
    
31. #define FLASH_SPI_CLK   RCC_APB2Periph_SPI1
    
32. //片选引脚
    " J2 {7 E% F/ e3 T+ Y
33. #define FLASH_SPI_CS_CLK   RCC_APB2Periph_GPIOC
    $ U5 @( C( U5 N# D1 t, a
34. #define FLASH_SPI_CS_PORT  GPIOC
    
35. #define FLASH_SPI_CS_PIN   GPIO_Pin_0
    
36. //SCK引脚
    2 J6 R0 }1 s1 l" {, Z% B/ Z
37. #define FLASH_SPI_SCK_CLK  RCC_APB2Periph_GPIOA
    # K! ]; x% A/ |4 y9 a4 M
38. #define FLASH_SPI_SCK_PORT GPIOA
    ' H3 U: Y. F; k  U; @2 L
39. #define FLASH_SPI_SCK_PIN  GPIO_Pin_5
    
40. //MISO引脚
    , d+ m6 U6 P( L# @
41. #define FLASH_SPI_MISO_CLK  RCC_APB2Periph_GPIOA
    # s! s7 m  h- ^2 o% j8 @
42. #define FLASH_SPI_MISO_PORT GPIOA
    6 ]6 Y2 Z/ r$ P9 ]9 ^- P
43. #define FLASH_SPI_MISO_PIN  GPIO_Pin_6
    
44. //MOSI引脚
    . P2 |( }) ~3 ]8 B' I: [: K
45. #define FLASH_SPI_MOSI_CLK  RCC_APB2Periph_GPIOA
    
46. #define FLASH_SPI_MOSI_PORT GPIOA
    
47. #define FLASH_SPI_MOSI_PIN  GPIO_Pin_7
      u2 h1 i. |' R$ {
48. 
    
49. #define SPI_FLASH_CS_LOW()   GPIO_ResetBits(FLASH_SPI_CS_PORT, FLASH_SPI_CS_PIN)
    
50. #define SPI_FLASH_CS_HIGH()  GPIO_SetBits( FLASH_SPI_CS_PORT, FLASH_SPI_CS_PIN )
    : ?& j4 H4 w( w
51. 
    
52. #define SPIT_FLAG_TIMEOUT         ((uint32_t)0x1000)
    9 J1 A$ n* C& x; W) P6 G& R5 Y* ]
53. #define SPIT_LONG_TIMEOUT         ((uint32_t)(10 * SPIT_FLAG_TIMEOUT))
    
54. 
    
55. #define FLASH_DEBUG_ON         1
    , s. k4 a: k+ p0 M" J
56. 
    ; n0 r  K( {9 h, m( C; ?0 F' I1 T
57. #define FLASH_INFO(fmt,arg...)           printf("<<-FLASH-INFO->> "fmt"\n",##arg)
    % `3 c9 V( Y  N0 U! j5 [
58. #define FLASH_ERROR(fmt,arg...)          printf("<<-FLASH-ERROR->> "fmt"\n",##arg)
    
59. #define FLASH_DEBUG(fmt,arg...)          do{\
    ; _/ ~+ S3 d. S0 h: K
60.                                           if(FLASH_DEBUG_ON)\
    $ k1 x. ?/ a. v
61.                                           printf("<<-FLASH-DEBUG->> [%d]"fmt"\n",__LINE__, ##arg);\
    
62.                                           }while(0)
    
63. 
    / f  M8 W+ e: \) N
64. void SPI_FLASH_Init(void);
    ! w/ E) ?7 [& N& {+ `4 ]2 x) s
65. void SPI_FLASH_SectorErase(u32 SectorAddr);
      Y* ]$ W# j$ P
66. void SPI_FLASH_BulkErase(void);
    
67. void SPI_FLASH_PageWrite(u8* pBuffer, u32 WriteAddr, u16 NumByteToWrite);
      @& V' [1 X- m. m$ P: o
68. void SPI_FLASH_BufferWrite(u8* pBuffer, u32 WriteAddr, u16 NumByteToWrite);
    
69. void SPI_FLASH_BufferRead(u8* pBuffer, u32 ReadAddr, u16 NumByteToRead);
    
70. u32 SPI_FLASH_ReadID(void);
    - G: }  l% d2 J% p, Y5 p" P" p
71. u32 SPI_FLASH_ReadDeviceID(void);
    . R+ A! L# T8 F
72. void SPI_FLASH_StartReadSequence(up32 ReadAddr);
    : f% k! f+ O& Z
73. void SPI_Flash_PowerDown(void);
    6 l* K! k4 \7 v1 t* V9 n+ K
74. void SPI_Flash_WAKEUP(void);
    : }% B6 |5 O- c( e+ q9 }: C8 v: \
75. 
    
76. 
    
77. u8 SPI_FLASH_ReadByte(void);
    6 I. G. M7 N9 N( S; d
78. u8 SPI_FLASH_SendByte(u8 byte);
    
79. u16 SPI_FLASH_SendHalfWord(u16 HalfWord);
    * H! }' I/ O5 X1 i5 @  u) N( r
80. void SPI_FLASH_WriteEnable(void);
    ) T! n5 [, v4 ]  T! a1 f+ S- O
81. void SPI_FLASH_WaitForWriteEnd(void);
    
82. #endif

复制代码

bsp_spi_flash.c文件：

1. #include "bsp_spi_flash.h"
   
2. 
   - H  {- D* d, e; {/ l( z% h  t2 u! R
3. static __IO uint32_t  SPITimeout = SPIT_LONG_TIMEOUT;   
   
4. static uint16_t SPI_TIMEOUT_UserCallback(uint8_t errorCode);
   # I, B+ y: L: n$ T; J5 ^7 a+ a" R9 z9 P
5. 
   
6. void SPI_FLASH_Init(void)
   
7. {
   
8.   SPI_InitTypeDef  SPI_InitStructure;
   7 K6 B4 c4 D5 N
9.   GPIO_InitTypeDef GPIO_InitStructure;
   
10.     RCC_APB2PeriphClockCmd(FLASH_SPI_CLK, ENABLE );
    
11.      RCC_APB2PeriphClockCmd(FLASH_SPI_CS_CLK|FLASH_SPI_SCK_CLK|
    
12.         FLASH_SPI_MISO_PIN|FLASH_SPI_MOSI_PIN, ENABLE );
    & L5 \9 }& e* v  ~
13.   GPIO_InitStructure.GPIO_Pin = FLASH_SPI_CS_PIN;
    
14.   //配置片选
    5 C! J& \" o2 h( M! K3 b: A) I
15.     GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
    
16.   GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;
    
17.   GPIO_Init(FLASH_SPI_CS_PORT, &GPIO_InitStructure);
    " C5 f0 D+ r8 v2 r; L2 s
18.   GPIO_InitStructure.GPIO_Pin = FLASH_SPI_SCK_PIN;
    , W( ?$ ]& d5 Z6 t
19.   //配置SCK
    
20.   GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;
    
21.   GPIO_Init(FLASH_SPI_SCK_PORT, &GPIO_InitStructure);
    
22.   //配置MISO
    
23.   GPIO_InitStructure.GPIO_Pin = FLASH_SPI_MISO_PIN;
    
24.   GPIO_Init(FLASH_SPI_MISO_PORT, &GPIO_InitStructure);
    
25.   //配置MOSI
    . B( K0 d6 q! z# B- @$ N# a$ C% T( Y
26.   GPIO_InitStructure.GPIO_Pin = FLASH_SPI_MOSI_PIN;
    ) P) W: S# ~; x: v2 |" T/ b+ Z
27.   GPIO_Init(FLASH_SPI_MOSI_PORT, &GPIO_InitStructure);
    
28.   //cs高电平，通讯停止
    
29.   SPI_FLASH_CS_HIGH();
    ; ~$ J" x/ `' |8 a9 L/ M: A+ B
30.   //SPI模式配置
    8 }; h; }. z6 _( |5 @! w' |+ }- @5 b
31.   SPI_InitStructure.SPI_Direction = SPI_Direction_2Lines_FullDuplex;
    
32.   SPI_InitStructure.SPI_Mode = SPI_Mode_Master;
    0 p8 i- E- @7 }# K/ {+ ]2 W  h7 D
33.   SPI_InitStructure.SPI_DataSize = SPI_DataSize_8b;
    ! u" O$ d$ y2 R  O' ?6 W1 C
34.   SPI_InitStructure.SPI_CPOL = SPI_CPOL_High;
    % r6 z# h1 _) C. ^, n  n4 d
35.   SPI_InitStructure.SPI_CPHA = SPI_CPHA_2Edge;
    & \, H: F& t3 o4 Y) O5 Y* G- E  H
36.   SPI_InitStructure.SPI_NSS = SPI_NSS_Soft;
      s& j" M& L( ]# w" n
37.   SPI_InitStructure.SPI_BaudRatePrescaler = SPI_BaudRatePrescaler_4;
    . a. n: a& b  r% D5 }
38.   SPI_InitStructure.SPI_FirstBit = SPI_FirstBit_MSB;
    
39.   SPI_InitStructure.SPI_CRCPolynomial = 7;
    
40.   SPI_Init(FLASH_SPIx , &SPI_InitStructure);
    
41.   SPI_Cmd(FLASH_SPIx , ENABLE);
    & S/ ]+ R+ \% f# l
42.    
    ( \) [  x- M5 {
43. }
    6 g; g. c+ a0 f5 x7 U! V
44. //擦除FLASH
    % k. i4 P$ G; t
45. void SPI_FLASH_SectorErase(u32 SectorAddr)
    ) O6 {8 V/ ?3 M7 {# l
46. {
    
47.   SPI_FLASH_WriteEnable();
    
48.   SPI_FLASH_WaitForWriteEnd();
    
49.   SPI_FLASH_CS_LOW();
    ) u7 Z7 D8 y; {4 j; s, m1 ~* J
50.   SPI_FLASH_SendByte(W25X_SectorErase);
    
51.   SPI_FLASH_SendByte((SectorAddr & 0xFF0000) >> 16);
    . |% d7 o. r: Z6 {
52.   SPI_FLASH_SendByte((SectorAddr & 0xFF00) >> 8);
    
53.   SPI_FLASH_SendByte(SectorAddr & 0xFF);
    
54.   SPI_FLASH_CS_HIGH();
    
55.   SPI_FLASH_WaitForWriteEnd();
    
56. }
    5 ^& E6 _. Q# w9 p  g8 P) U
57. //擦除FLASH扇区
    
58. void SPI_FLASH_BulkErase(void)
    
59. {
    + g+ s( a% u! t
60.   SPI_FLASH_WriteEnable();
    ; g1 Z# w) x" J5 n) n
61.   SPI_FLASH_CS_LOW();
    * _% d7 z, ?! @1 u4 F# f: A
62.   SPI_FLASH_SendByte(W25X_ChipErase);
    
63.   SPI_FLASH_CS_HIGH();
    
64.   SPI_FLASH_WaitForWriteEnd();
    1 I6 h  T  j5 f( a- a( M2 b
65. }
    
66. 
    ; M, }8 r1 q/ f; I) ~
67. //按页写入数据
    
68. void SPI_FLASH_PageWrite(u8* pBuffer, u32 WriteAddr, u16 NumByteToWrite)
    
69. {
    
70.   SPI_FLASH_WriteEnable();
    
71.   SPI_FLASH_CS_LOW();
    9 F  w) j6 j8 x- Z+ w' [
72.   SPI_FLASH_SendByte(W25X_PageProgram);
    3 s% F0 C5 _; @; T6 L
73.   SPI_FLASH_SendByte((WriteAddr & 0xFF0000) >> 16);
    
74.   SPI_FLASH_SendByte((WriteAddr & 0xFF00) >> 8);
    ! d6 V, m* f7 b/ P8 ^/ D. I" c" [
75.   SPI_FLASH_SendByte(WriteAddr & 0xFF);
    $ b) t) o. T" e
76.   if(NumByteToWrite > SPI_FLASH_PerWritePageSize)
    
77.   {
    
78.      NumByteToWrite = SPI_FLASH_PerWritePageSize;
    
79.      FLASH_ERROR("SPI_FLASH_PageWrite too large!");
    
80.   }
    
81.   while (NumByteToWrite--)
    
82.   {
    . A* k3 h* y: m) e( {
83.     SPI_FLASH_SendByte(*pBuffer);
    2 y5 @3 A; o3 _' D! q, W! J' R
84.     pBuffer++;
    $ i5 x$ |. {0 y  `
85.   }
    2 q! w0 [' h1 O, u8 d0 y
86.   SPI_FLASH_CS_HIGH();
    
87.   SPI_FLASH_WaitForWriteEnd();
    $ y) N- z# T2 x) d6 E; V! V
88. }
    + w- U% c' }0 {$ U: G) V
89. //写数据
    " h2 {8 y/ a3 r; {! O
90. void SPI_FLASH_BufferWrite(u8* pBuffer, u32 WriteAddr, u16 NumByteToWrite)
    7 ?7 h# O) ~3 ]/ }9 X# l
91. {
    
92.   u8 NumOfPage = 0, NumOfSingle = 0, Addr = 0, count = 0, temp = 0;
    " K! m* }8 p' M6 l2 V9 r/ |/ u
93.   Addr = WriteAddr % SPI_FLASH_PageSize;
    
94.   count = SPI_FLASH_PageSize - Addr;
    
95.   NumOfPage =  NumByteToWrite / SPI_FLASH_PageSize;
      L) Z, j! i) @2 D
96.   NumOfSingle = NumByteToWrite % SPI_FLASH_PageSize;
    & ?$ U8 G0 m- t( f
97.   if (Addr == 0)
    
98.   {
    , A3 Y2 u4 g& s5 B: |
99.     if (NumOfPage == 0)
    & C. m2 V3 U( i* R. ?. z6 u8 B
100.     {
     
101.       SPI_FLASH_PageWrite(pBuffer, WriteAddr, NumByteToWrite);
     ; e' O$ X4 @; ^; m
102.     }
     ! Z% B) [7 Y1 `8 M# U& X, z  I
103.     else
     
104.     {
     2 [& c8 S- u: y3 h2 y
105.       while (NumOfPage--)
     
106.       {
     ( m5 G5 y$ @9 `; M4 i( q: P; l: Y
107.         SPI_FLASH_PageWrite(pBuffer, WriteAddr, SPI_FLASH_PageSize);
     : B) D$ B/ G+ |! m8 k* A
108.         WriteAddr +=  SPI_FLASH_PageSize;
     
109.         pBuffer += SPI_FLASH_PageSize;
     
110.       }
     , m' r' R5 T; b  _
111.       SPI_FLASH_PageWrite(pBuffer, WriteAddr, NumOfSingle);
     
112.     }
     
113.   }
     
114.   else
     7 J. v) X! A. w' e. e" e4 e
115.   {
     
116.     if (NumOfPage == 0)
     
117.     {
     
118.       if (NumOfSingle > count)
     / b6 n9 s0 J4 i5 z% C' g/ L7 F- s
119.       {
     9 D! k* W9 t, `: Q+ R
120.         temp = NumOfSingle - count;
     0 d8 f: B. X% V3 B' C  p! f
121.         SPI_FLASH_PageWrite(pBuffer, WriteAddr, count);
     ' j' z. t- X+ b# Y1 a
122.                
     ' h" ^( O/ G- M- ~9 m# U
123.         WriteAddr +=  count;
     ; ^1 x. ~* Z) E$ C  Z3 S
124.         pBuffer += count;
     
125.         SPI_FLASH_PageWrite(pBuffer, WriteAddr, temp);
     2 b: w+ g( Q, l2 S- I% ^" ?
126.       }
     7 l" R: Y  ~/ \7 z3 }( B( {3 z
127.       else
     
128.       {
     0 U) Y# D  }' m9 X! n
129.         SPI_FLASH_PageWrite(pBuffer, WriteAddr, NumByteToWrite);
     9 ?7 N6 R' W0 P( ^4 N% `  O( Y
130.       }
     , G, k1 X# X/ f- q% y" a+ P- S
131.     }
     + N0 Z: B$ [) S: I- _
132.     else
     
133.     {
     
134.       NumByteToWrite -= count;
     $ K3 H" F2 {" q4 r
135.       NumOfPage =  NumByteToWrite / SPI_FLASH_PageSize;
     ; i5 t. e: K# }! B% o' \. G
136.       NumOfSingle = NumByteToWrite % SPI_FLASH_PageSize;
     + H; C$ M% b( R6 ]
137.       SPI_FLASH_PageWrite(pBuffer, WriteAddr, count);
     
138.       WriteAddr +=  count;
     
139.       pBuffer += count;
     1 `7 o6 X; D4 b2 R% Z
140.       while (NumOfPage--)
     % F, P% `/ z4 B% m# ^3 s1 D
141.       {
     
142.         SPI_FLASH_PageWrite(pBuffer, WriteAddr, SPI_FLASH_PageSize);
     9 V. O5 ]. R2 c5 Q# B
143.         WriteAddr +=  SPI_FLASH_PageSize;
     
144.         pBuffer += SPI_FLASH_PageSize;
     
145.       }
     
146.       if (NumOfSingle != 0)
     
147.       {
     
148.         SPI_FLASH_PageWrite(pBuffer, WriteAddr, NumOfSingle);
     # p( a. h. B& [" L, \4 K  K
149.       }
     
150.     }
     
151.   }
     1 t7 m1 P0 e: ~( D2 K
152. }
     9 N3 k4 D) G6 ~8 G, X" p* z
153. 
     7 r+ j5 P9 t4 ^
154. //读数据
     
155. void SPI_FLASH_BufferRead(u8* pBuffer, u32 ReadAddr, u16 NumByteToRead)
     9 D  }% ]( i( n& m: H3 `
156. {
     
157.   SPI_FLASH_CS_LOW();
     
158.   SPI_FLASH_SendByte(W25X_ReadData);
     
159.   SPI_FLASH_SendByte((ReadAddr & 0xFF0000) >> 16);
     % |) f- O  L' F2 p: Z" l6 O! f
160.   SPI_FLASH_SendByte((ReadAddr& 0xFF00) >> 8);
     
161.   SPI_FLASH_SendByte(ReadAddr & 0xFF);
     ( i9 M" M0 {6 F( K: n; |
162.   while (NumByteToRead--)
     9 A* ~! y* w) f! E2 X' o9 G# J
163.   {
     
164.     *pBuffer = SPI_FLASH_SendByte(Dummy_Byte);
     " p2 j# k* u% C: Q$ x* E+ U
165.     pBuffer++;
     0 M; v, i0 w, o7 R) g9 l4 V
166.   }
     # m8 {$ p( b, _) u) C
167.   SPI_FLASH_CS_HIGH();
     
168. }
     
169. //读取ID
     ' |+ Y: A- T. i2 {4 a
170. u32 SPI_FLASH_ReadID(void)
     
171. {
     6 H  N7 f- l# h' n& K0 @. w
172.   u32 Temp = 0, Temp0 = 0, Temp1 = 0, Temp2 = 0;
     
173.   SPI_FLASH_CS_LOW();
     " ~" C0 k+ f* V0 t
174.   SPI_FLASH_SendByte(W25X_JedecDeviceID);
     
175.   Temp0 = SPI_FLASH_SendByte(Dummy_Byte);
     7 x& @$ I* O& P
176.   Temp1 = SPI_FLASH_SendByte(Dummy_Byte);
     + J3 w0 s6 Z8 ~
177.   Temp2 = SPI_FLASH_SendByte(Dummy_Byte);
     
178.   SPI_FLASH_CS_HIGH();
     
179.     Temp = (Temp0 << 16) | (Temp1 << 8) | Temp2;
     
180. 
     & P& H( A; @- D
181.   return Temp;
     
182. }
     6 g" R2 h/ t  J0 H$ F/ P
183. //读取DeviceID
     & p9 x+ A1 |9 F; K7 @$ O
184. u32 SPI_FLASH_ReadDeviceID(void)
     
185. {
     
186.   u32 Temp = 0;
     
187.   SPI_FLASH_CS_LOW();
     5 l: W! x; E: D% ~- g" Y; E
188.   SPI_FLASH_SendByte(W25X_DeviceID);
     
189.   SPI_FLASH_SendByte(Dummy_Byte);
     
190.   SPI_FLASH_SendByte(Dummy_Byte);
     5 i7 z& ]$ r! {5 d
191.   SPI_FLASH_SendByte(Dummy_Byte);
     
192.   Temp = SPI_FLASH_SendByte(Dummy_Byte);
     2 B$ P% }/ P/ H9 |2 M
193.   SPI_FLASH_CS_HIGH();
     
194. 
     3 q; t/ S# f. g9 R0 J
195.   return Temp;
     9 m3 ^8 H$ }& {, D% _% s: P4 F+ `
196. }
     # s; f1 \9 v& d8 l
197. 
     
198. void SPI_FLASH_StartReadSequence(u32 ReadAddr)
     ; Q+ K; Q$ g3 Y3 N6 j3 S
199. {
     : B2 J5 M5 U3 P5 {! _2 ]$ }
200.   SPI_FLASH_CS_LOW();
     7 t: f' [, K* F
201.   SPI_FLASH_SendByte(W25X_ReadData);
     
202.   SPI_FLASH_SendByte((ReadAddr & 0xFF0000) >> 16);
     
203.   SPI_FLASH_SendByte((ReadAddr& 0xFF00) >> 8);
     1 G3 Q, B5 ]! ]' o
204.   SPI_FLASH_SendByte(ReadAddr & 0xFF);
     + B% m* z# t7 ]$ a  I$ ?# \
205. }
     8 a5 u. A: Y8 u' l$ j6 R
206. 
     5 T2 R/ R' Q# w) H0 S. l' j
207. u8 SPI_FLASH_ReadByte(void)
     
208. {
     * v5 w8 W. b5 G  @) F
209.   return (SPI_FLASH_SendByte(Dummy_Byte));
     
210. }
     5 y. t( z4 u5 Z
211. 
     ; ?! _2 @0 Q5 q
212. u8 SPI_FLASH_SendByte(u8 byte)
       g, Q  v$ x  R: S/ u0 F
213. {
     
214.      SPITimeout = SPIT_FLAG_TIMEOUT;
     - L7 n- w' p3 c( K
215.   while (SPI_I2S_GetFlagStatus(FLASH_SPIx , SPI_I2S_FLAG_TXE) == RESET)
     0 O  W; o( }- _5 E/ z, M& i& X
216.     {
     / P# e1 C9 Y  g2 b8 F
217.     if((SPITimeout--) == 0) return SPI_TIMEOUT_UserCallback(0);
     6 l- C; G6 ~+ T, v# g  o$ [
218.    }
     7 k  U. u- j, U3 i8 A, U* f! _  i. u
219.   SPI_I2S_SendData(FLASH_SPIx , byte);
     
220. 
     
221.     SPITimeout = SPIT_FLAG_TIMEOUT;
     
222.   while (SPI_I2S_GetFlagStatus(FLASH_SPIx , SPI_I2S_FLAG_RXNE) == RESET)
     
223.   {
     0 S2 z+ U; Y5 y& @
224.     if((SPITimeout--) == 0) return SPI_TIMEOUT_UserCallback(1);
     $ a6 {3 _) |# S3 W2 z4 @% W& L
225.    }
     
226.   return SPI_I2S_ReceiveData(FLASH_SPIx );
     1 A9 U0 r/ c3 q8 U5 D
227. }
     
228. 
     
229. u16 SPI_FLASH_SendHalfWord(u16 HalfWord)
     ; O3 f# p. j  A
230. {
     
231.       SPITimeout = SPIT_FLAG_TIMEOUT;
     
232.   while (SPI_I2S_GetFlagStatus(FLASH_SPIx , SPI_I2S_FLAG_TXE) == RESET)
     ( M1 Y* A' Y' K, P0 k& H) i( z
233.     {
     
234.     if((SPITimeout--) == 0) return SPI_TIMEOUT_UserCallback(2);
     $ x9 U+ B6 c) \* ^$ @: M: b
235.    }
     
236.   SPI_I2S_SendData(FLASH_SPIx , HalfWord);
     
237. 
     
238.      SPITimeout = SPIT_FLAG_TIMEOUT;
     " d$ ~; ]" d" o9 Q7 g
239.   while (SPI_I2S_GetFlagStatus(FLASH_SPIx , SPI_I2S_FLAG_RXNE) == RESET)
     
240.      {
     
241.     if((SPITimeout--) == 0) return SPI_TIMEOUT_UserCallback(3);
     5 H0 K0 ~9 ^1 N
242.    }
     , L+ R5 h% }* Y$ B: V1 t
243.   return SPI_I2S_ReceiveData(FLASH_SPIx );
     
244. }
     
245. 
     
246. void SPI_FLASH_WriteEnable(void)
     
247. {
     7 i- O+ `2 h( s& ?
248.   SPI_FLASH_CS_LOW();
     
249.   SPI_FLASH_SendByte(W25X_WriteEnable);
     
250.   SPI_FLASH_CS_HIGH();
     
251. }
     
252. 
     
253. void SPI_FLASH_WaitForWriteEnd(void)
     & l, m! i6 C5 z- B6 e; f
254. {
     ( B. Y" n6 P0 `3 _& y5 N9 ~5 |
255.   u8 FLASH_Status = 0;
     
256.   SPI_FLASH_CS_LOW();
     - X. B+ N5 W9 {
257.   SPI_FLASH_SendByte(W25X_ReadStatusReg);
     9 D! {3 `% |0 ^( Z, r1 H
258.   do
     
259.   {
     0 t( |3 C8 c8 H6 W7 s' n
260.     FLASH_Status = SPI_FLASH_SendByte(Dummy_Byte);     
     0 |3 k$ w4 b, t' z0 L+ o' [
261.   }
     
262.   while ((FLASH_Status & WIP_flag ) == SET);  
     ' {, a4 z: B+ g1 Y
263.   SPI_FLASH_CS_HIGH();
     5 f) z9 Q) F$ L& T7 H0 [' V
264. }
     8 h; [, V' \1 z% d+ x* C
265. 
     # @2 u; U1 o' ?: W3 Z7 r( K3 ^
266. void SPI_Flash_PowerDown(void)   
     / x6 {% j& K. s2 n
267. {
     4 W+ C+ v* ]4 P7 V2 u
268.   SPI_FLASH_CS_LOW();
     
269.   SPI_FLASH_SendByte(W25X_PowerDown);
     
270.   SPI_FLASH_CS_HIGH();
     3 h( A+ Q8 e9 s& h1 Y9 b: R* `
271. }   
     2 A: b4 ~3 }/ j/ ~+ A! g
272. 
     : p1 m/ h) w! Z  q( w7 N
273. void SPI_Flash_WAKEUP(void)   
     0 e# u+ q- \  ?# e0 s2 W1 A2 p) ^
274. {
     
275.   SPI_FLASH_CS_LOW();
     3 P: N& M# I4 F; K6 m" e
276.   SPI_FLASH_SendByte(W25X_ReleasePowerDown);
     5 o) ?5 B4 z  Q3 S  `" M" I
277.   SPI_FLASH_CS_HIGH();
     
278. }   
     + y* W/ k# l# I4 D% f0 q
279.    
     8 J( l" e8 N" S# u/ A9 H# i  D
280. static  uint16_t SPI_TIMEOUT_UserCallback(uint8_t errorCode)
     
281. {
     ( J7 f& ^  x1 ?  |+ y
282.   FLASH_ERROR("SPI等待超时!errorCode = %d",errorCode);
     - ]3 H! M/ Q' g1 @5 a6 I( z  o1 [; S
283.   return 0;
       A6 u; j( N) @/ @  f
284. }

复制代码

; z9 w2 }5 q( U& h/ B

main.c文件：

1. #include "stm32f10x.h"
   
2. #include "bsp_usart.h"
   
3. #include "bsp_led.h"
   
4. #include "bsp_spi_flash.h"
   7 N9 D5 I1 r( e. J; s! E# b: t
5. 
   
6. 
   4 @" T, a" u2 _. [  Q& W
7. typedef enum { FAILED = 0, PASSED = !FAILED} TestStatus;
   
8. 
   1 b# S6 L3 x) ]0 b* k* h- I; J
9. #define TxBufferSize1   (countof(TxBuffer1) - 1)
   2 i( F. [/ r) S: [. r; M
10. #define RxBufferSize1   (countof(TxBuffer1) - 1)
    2 d! Y" V: d2 F4 k- p9 @
11. #define countof(a)      (sizeof(a) / sizeof(*(a)))
    , g- E3 T: e& I" {& m6 h
12. #define  BufferSize (countof(Tx_Buffer)-1)
    
13. 
    & L  V6 T7 `9 |+ P+ {
14. #define  FLASH_WriteAddress     0x00000
    , r! |0 }) p& a2 A( _( D6 [
15. #define  FLASH_ReadAddress      FLASH_WriteAddress
    
16. #define  FLASH_SectorToErase    FLASH_WriteAddress
    
17. 
    
18. uint8_t Tx_Buffer[] = "hello stm32!!!\r\n";
    
19. uint8_t Rx_Buffer[BufferSize];
    
20. 
    2 y5 A/ F6 R3 C2 L, {+ l
21. __IO uint32_t DeviceID = 0;
    ( \' t5 f2 D) q" b% ~' J3 D0 z
22. __IO uint32_t FlashID = 0;
    
23. __IO TestStatus TransferStatus1 = FAILED;
    5 U3 H( O, ^! x7 m: A' l- \
24. 
    2 J8 w. ^9 F3 C/ @" A! i
25. void Delay(__IO uint32_t nCount);
    2 V- k% e' d7 M
26. TestStatus Buffercmp(uint8_t* pBuffer1,uint8_t* pBuffer2, uint16_t BufferLength);
    $ B9 i$ x" R2 d- ^$ E
27. 
    
28. int main(void)
    0 L# _/ O; [0 C1 G" e) i- J/ u) F
29. {     
    " R3 e3 e; o' W, q; g) b( ]/ j
30.     LED_GPIO_Config();
    
31.     USART_Config();
    2 G# ~* y- ~/ i
32.     printf("\r\n 这是一个8M的串行flash W25Q64实验!\r\n");
    
33.     SPI_FLASH_Init();
    
34.     DeviceID = SPI_FLASH_ReadDeviceID();   
    ( u/ C4 v  V; k2 ~/ K" {) f
35.     Delay( 200 );
    
36.     FlashID = SPI_FLASH_ReadID();   
    + i) F/ r& D$ M1 T4 @
37.     printf("\r\n FlashID is 0x%X,\
    : k0 ]' P+ k8 {/ U
38.     Manufacturer Device ID is 0x%X\r\n", FlashID, DeviceID);
    
39.     if (FlashID == sFLASH_ID)
    
40.     {   
    
41.         printf("\r\n检测到串行flash W25Q64\r\n");
    
42.         SPI_FLASH_SectorErase(FLASH_SectorToErase);         
    
43.         SPI_FLASH_BufferWrite(Tx_Buffer, FLASH_WriteAddress, BufferSize);        
    
44.         printf("\r\n 写入的数据为：%s \r\t", Tx_Buffer);
    & n( x+ A, t" B! Q
45.         SPI_FLASH_BufferRead(Rx_Buffer, FLASH_ReadAddress, BufferSize);
    - c2 r2 q+ _4 R5 [2 f9 @1 Y, |. V
46.         printf("\r\n 读出的数据为\r\n", Rx_Buffer);
    
47.         TransferStatus1 = Buffercmp(Tx_Buffer, Rx_Buffer, BufferSize);
    # G+ c5 Y" F4 o* J, q5 J; ~# t$ f
48.         if( PASSED == TransferStatus1 )
    
49.         {
    
50.             green(ON);
    & t. ~; s1 B5 v( e0 x9 y" Y% f
51.             printf("\r\n 测试成功!\n\r");
    4 I. ]+ F$ ^+ `" k
52.         }
    - L+ M- B( z5 ~0 L6 a' ?- }" R2 Y
53.         else
    6 t5 ^8 ?8 }8 x" O; T
54.         {        
    
55.             red(ON);
    & v" C4 `  y" P0 _
56.             printf("\r\n 测试失败\n\r");
    7 \/ L. n( U6 g7 f0 u# Y
57.         }
    1 y6 b- D4 K3 w! W' t
58.     }// if (FlashID == sFLASH_ID)
    
59.     else// if (FlashID == sFLASH_ID)
    + T# _. S5 _! t9 ]; U9 O6 E( J
60.     {
    8 j4 }; \* J7 X4 o9 L
61.         red(ON);
    " t1 S( b0 O" ^
62.         printf("\r\n 获取不到W25Q64 ID!\n\r");
    
63.     }
    5 R( ?; ~* X( J' r1 b! A
64.    
    ' ~( N1 h7 [+ G1 W2 n4 U/ J
65.     while(1);  
    
66. }
    
67. //比较两个缓冲区的内容是否一样
      g8 [* G' P# v+ v7 K0 y3 b; A
68. TestStatus Buffercmp(uint8_t* pBuffer1, uint8_t* pBuffer2, uint16_t BufferLength)
    * t. B' n. t' R$ x  \
69. {
    7 M8 Q. Z" w  f% q) J
70.   while(BufferLength--)
    ! X: t1 z/ c% }  i
71.   {
    
72.     if(*pBuffer1 != *pBuffer2)
    " l0 R0 b$ z7 s# F- @' u- ~
73.     {
      n9 M$ u- @3 O2 q8 o" u. v' P1 w
74.       return FAILED;
    6 }; X( G: t) h, u
75.     }
    , E* g4 D0 b# V% x$ Y
76.     pBuffer1++;
    
77.     pBuffer2++;
    2 J& S* R$ m& q: [" }- \6 q
78.   }
    2 u2 D9 F/ r$ L! F
79.   return PASSED;
    / ]" m/ [1 H, f1 e5 @+ m
80. }
    
81. 
    / P( C) F' A' a" d( |
82. void Delay(__IO uint32_t nCount)
    ' b* n& k' G7 Z7 Z! k
83. {
    
84.   for(; nCount != 0; nCount--);
    ! \1 n* p  b, ~
85. }

复制代码

6 y/ v* X' K  ^  s5 B" N