01. SPI简介
/ C; k, B5 D1 k- p- }SPI 是英语 Serial Peripheral interface 的缩写，顾名思义就是串行外围设备接口。是 Motorola首先在其 MC68HCXX 系列处理器上定义的。SPI 接口主要应用在 EEPROM，FLASH，实时时钟，AD 转换器，还有数字信号处理器和数字信号解码器之间。SPI，是一种高速的，全双工，同步的通信总线，并且在芯片的管脚上只占用四根线，节约了芯片的管脚，同时为 PCB 的布局上节省空间，提供方便，正是出于这种简单易用的特性，现在越来越多的芯片集成了这种通信协议，STM32F4 也有 SPI 接口。

3 H" e7 y  l) z. b; ?  B+ K- O% F' F+ k02. 功能描述
* x+ Y5 j" Y2 C( d; L1 e使用 STM32F4 自带的 SPI来实现对外部 FLASH（W25Q128）的读写，并将结果显示在 TFTLCD 模块上。
1 ~- y. o; z/ Y- s( [
5 [8 @: ?: D- Y; v5 S9 m$ E3 t6 D03. 硬件模块
开机的时候先检测 W25Q128 是否存在，然后在主循环里面检测两个按键，其中 1 个按键（KEY1）用来执行写入 W25Q128 的操作，另外一个按键（KEY0）用来执行读出操作，在 TFTLCD 模块上显示相关信息。同时用 DS0 提示程序正在运行。
) Z9 f7 d2 C3 u: T% p9 _; H所要用到的硬件资源如下：
1） 指示灯 DS0
2） KEY_UP 和 KEY1 按键
' ?1 |# T7 [- Z- ]3） TFTLCD 模块
% ]# D1 n2 X6 s! X6 ^, M1 k4） SPI
9 j6 |# ^1 j- O6 G, @5） W25Q128


# g( R! W, [" O: y8 m# f7 {
04. 软件设计
. ]8 T6 y, S: _5 rspi.h
2 j4 d* n( J* T  x
! h! X4 B* X8 _; S

1. #ifndef __SPI_H
   
2. #define __SPI_H
   
3. #include "sys.h"
   
4.                                                                                                                      
   
5. void SPI1_Init(void);                         //初始化SPI1口
   # |$ y3 m+ t) R, L5 @$ d
6. void SPI1_SetSpeed(u8 SpeedSet); //设置SPI1速度   
   
7. u8 SPI1_ReadWriteByte(u8 TxData);//SPI1总线读写一个字节
   ; W, A6 s* Z0 \) R4 c
8.                  
   
9. #endif

复制代码

! h5 x6 V+ ~7 C5 c  R- Y. S! pspi.c

; }- d, h/ r) m  _5 L+ H# ~

1. #include "spi.h"
   
2. 
   % h  a* ~$ E9 m( z# x4 p
3. 
   
4. //以下是SPI模块的初始化代码，配置成主机模式                                                   
   6 j# l/ j" s/ y1 y
5. //SPI口初始化
   
6. //这里针是对SPI1的初始化
   / q! D& X6 M& ?: L" `. v
7. void SPI1_Init(void)
   
8. {         
   
9.   GPIO_InitTypeDef  GPIO_InitStructure;
   
10.   SPI_InitTypeDef  SPI_InitStructure;
    
11.         
    4 Q/ Z  U5 L# l5 m! e, ~7 s: i
12.   RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOB, ENABLE);//使能GPIOB时钟
    / o3 W( ^: p7 S
13.   RCC_APB2PeriphClockCmd(RCC_APB2Periph_SPI1, ENABLE);//使能SPI1时钟
    0 |9 \1 Y7 U+ X
14. 
    
15.   //GPIOFB3,4,5初始化设置
    $ A- {- S; t; q* {+ v3 Q
16.   GPIO_InitStructure.GPIO_Pin = GPIO_Pin_3|GPIO_Pin_4|GPIO_Pin_5;//PB3~5复用功能输出        
    ) {9 H7 L8 @) ?& t  N
17.   GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF;//复用功能
    - x1 I! W7 }# J* x+ W9 D
18.   GPIO_InitStructure.GPIO_OType = GPIO_OType_PP;//推挽输出
    : X4 b/ m; L. ~" l$ _
19.   GPIO_InitStructure.GPIO_Speed = GPIO_Speed_100MHz;//100MHz
    # O2 |; f) g' F- k+ J
20.   GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_UP;//上拉
    
21.   GPIO_Init(GPIOB, &GPIO_InitStructure);//初始化
    , i. u* o2 `/ Y8 b2 O$ B6 B; M
22.         
    
23.         GPIO_PinAFConfig(GPIOB,GPIO_PinSource3,GPIO_AF_SPI1); //PB3复用为 SPI1
    
24.         GPIO_PinAFConfig(GPIOB,GPIO_PinSource4,GPIO_AF_SPI1); //PB4复用为 SPI1
    ! i; a, w6 d2 E) o' A  K3 t8 u* a8 T
25.         GPIO_PinAFConfig(GPIOB,GPIO_PinSource5,GPIO_AF_SPI1); //PB5复用为 SPI1
    . K7 |% O, P6 J$ C- l7 h
26. 
    
27.         //这里只针对SPI口初始化
    
28.         RCC_APB2PeriphResetCmd(RCC_APB2Periph_SPI1,ENABLE);//复位SPI1
    ! J7 I0 r$ M) ~0 s2 G8 g1 ^
29.         RCC_APB2PeriphResetCmd(RCC_APB2Periph_SPI1,DISABLE);//停止复位SPI1
    
30. 
    + S# H" ]6 H$ o; }6 q- `. L
31.         SPI_InitStructure.SPI_Direction = SPI_Direction_2Lines_FullDuplex;  //设置SPI单向或者双向的数据模式:SPI设置为双线双向全双工
    5 \) e1 A$ e" q) @* n
32.         SPI_InitStructure.SPI_Mode = SPI_Mode_Master;                //设置SPI工作模式:设置为主SPI
    
33.         SPI_InitStructure.SPI_DataSize = SPI_DataSize_8b;                //设置SPI的数据大小:SPI发送接收8位帧结构
    ' f- F/ {: ?" p! K# ?! l5 k
34.         SPI_InitStructure.SPI_CPOL = SPI_CPOL_High;                //串行同步时钟的空闲状态为高电平
    ( `- f" O0 t7 b9 n9 G6 w" O2 K
35.         SPI_InitStructure.SPI_CPHA = SPI_CPHA_2Edge;        //串行同步时钟的第二个跳变沿（上升或下降）数据被采样
    
36.         SPI_InitStructure.SPI_NSS = SPI_NSS_Soft;                //NSS信号由硬件（NSS管脚）还是软件（使用SSI位）管理:内部NSS信号有SSI位控制
    . |0 C" v! t" n) V7 |
37.         SPI_InitStructure.SPI_BaudRatePrescaler = SPI_BaudRatePrescaler_256;                //定义波特率预分频的值:波特率预分频值为256
    
38.         SPI_InitStructure.SPI_FirstBit = SPI_FirstBit_MSB;        //指定数据传输从MSB位还是LSB位开始:数据传输从MSB位开始
    * P" ~, V: {8 D6 L( J/ L$ j; v/ c
39.         SPI_InitStructure.SPI_CRCPolynomial = 7;        //CRC值计算的多项式
    
40.         SPI_Init(SPI1, &SPI_InitStructure);  //根据SPI_InitStruct中指定的参数初始化外设SPIx寄存器
    ; f' J+ x* p( H( Y4 M/ @7 ]
41. 
    
42.         SPI_Cmd(SPI1, ENABLE); //使能SPI外设
    & W, ~8 B, j8 F
43. 
    , U: ^, k# O; m& x6 \+ U
44.         SPI1_ReadWriteByte(0xff);//启动传输                 
    
45. }   
    ) i# c% z: Y$ n. D: z
46. //SPI1速度设置函数
    
47. //SPI速度=fAPB2/分频系数
    
48. //@ref SPI_BaudRate_Prescaler:SPI_BaudRatePrescaler_2~SPI_BaudRatePrescaler_256  
    
49. //fAPB2时钟一般为84Mhz：
    ' U/ y8 a6 L, e4 [5 ]: [
50. void SPI1_SetSpeed(u8 SPI_BaudRatePrescaler)
    $ ~% q5 \  v8 y" Q+ Z
51. {
    ( D% m* o7 P! v& \7 V
52.   assert_param(IS_SPI_BAUDRATE_PRESCALER(SPI_BaudRatePrescaler));//判断有效性
    
53.         SPI1->CR1&=0XFFC7;//位3-5清零，用来设置波特率
    
54.         SPI1->CR1|=SPI_BaudRatePrescaler;        //设置SPI1速度
    
55.         SPI_Cmd(SPI1,ENABLE); //使能SPI1
    6 i' M" m7 h7 r
56. }
    9 u7 z. P  h2 ~% }* h( j) ?5 q
57. //SPI1 读写一个字节
    
58. //TxData:要写入的字节
    5 c2 \( _1 B4 e. H7 ]4 Y
59. //返回值:读取到的字节
    
60. u8 SPI1_ReadWriteByte(u8 TxData)
    9 k0 s8 M  p9 A3 T
61. {                                          
    + g# _! j9 c8 _0 t+ {( C  H
62. 
    # i7 W9 K: A4 h' r
63.   while (SPI_I2S_GetFlagStatus(SPI1, SPI_I2S_FLAG_TXE) == RESET){}//等待发送区空  
    ( e; ~8 R9 @" N. b7 t
64.         
    
65.         SPI_I2S_SendData(SPI1, TxData); //通过外设SPIx发送一个byte  数据
    6 t/ I9 @' {& |% ?
66.                
    8 C- @6 V1 |9 I- ^$ ?( M
67.   while (SPI_I2S_GetFlagStatus(SPI1, SPI_I2S_FLAG_RXNE) == RESET){} //等待接收完一个byte  
    
68. 
    
69.         return SPI_I2S_ReceiveData(SPI1); //返回通过SPIx最近接收的数据        
    
70.                      
    8 y7 _1 e% ?  ]/ J9 X
71. }

复制代码

w25qxx.h
8 G  u! @8 N8 ^# ~

1. #ifndef __W25QXX_H
   
2. #define __W25QXX_H                           
   
3. #include "sys.h"  
   + B4 L5 |. ^& w" E
4. 
   
5. //W25X系列/Q系列芯片列表           
   0 k6 ?8 @) U3 C) H7 M- w. ?- x
6. //W25Q80  ID  0XEF13
   
7. //W25Q16  ID  0XEF14
   6 X) Q- P* S0 F$ D! R0 N7 U& W
8. //W25Q32  ID  0XEF15
   
9. //W25Q64  ID  0XEF16        
   
10. //W25Q128 ID  0XEF17        
    
11. #define W25Q80         0XEF13         
    
12. #define W25Q16         0XEF14
    
13. #define W25Q32         0XEF15
    9 [% n, i1 M4 n
14. #define W25Q64         0XEF16
    
15. #define W25Q128        0XEF17
    ! N+ R, H, [! ^0 l
16. 
    & l9 o% o# L9 c( _
17. extern u16 W25QXX_TYPE;                                        //定义W25QXX芯片型号                  
    1 R' m9 f* e! D4 t. T0 j' y1 a
18. 
    
19. #define        W25QXX_CS                 PBout(14)                  //W25QXX的片选信号
    * }  w8 f/ f9 W: K5 A
20. 
    
21. //
    & u6 d0 `4 Y* W6 Q) l9 K
22. //指令表
    ( s  m0 a6 ]0 _
23. #define W25X_WriteEnable                0x06
    
24. #define W25X_WriteDisable                0x04
    
25. #define W25X_ReadStatusReg                0x05
    - X# h; g) l; j3 Y" ?3 v
26. #define W25X_WriteStatusReg                0x01
    
27. #define W25X_ReadData                        0x03
    
28. #define W25X_FastReadData                0x0B
    / m! K2 T9 N+ T1 |  b4 Z4 J" J1 N: r
29. #define W25X_FastReadDual                0x3B
    
30. #define W25X_PageProgram                0x02
    
31. #define W25X_BlockErase                        0xD8
    
32. #define W25X_SectorErase                0x20
    : F( F/ U7 d8 @1 b
33. #define W25X_ChipErase                        0xC7
      Z5 W5 R4 ~6 `9 ~
34. #define W25X_PowerDown                        0xB9
    1 q- X3 q' T0 B  ^% ^- g( Y& \/ J
35. #define W25X_ReleasePowerDown        0xAB
    
36. #define W25X_DeviceID                        0xAB
    
37. #define W25X_ManufactDeviceID        0x90
    
38. #define W25X_JedecDeviceID                0x9F
    
39. 
    
40. void W25QXX_Init(void);
    7 Z* Q# u, h  d; Y/ [& H
41. u16  W25QXX_ReadID(void);                              //读取FLASH ID
    # r6 R  o& D1 A; k
42. u8         W25QXX_ReadSR(void);                        //读取状态寄存器
    4 O& S% ]' I2 r; }% L/ B
43. void W25QXX_Write_SR(u8 sr);                          //写状态寄存器
    $ b8 q$ O  I7 m* V
44. void W25QXX_Write_Enable(void);                  //写使能
    
45. void W25QXX_Write_Disable(void);                //写保护
    
46. void W25QXX_Write_NoCheck(u8* pBuffer,u32 WriteAddr,u16 NumByteToWrite);
    
47. void W25QXX_Read(u8* pBuffer,u32 ReadAddr,u16 NumByteToRead);   //读取flash
    7 S+ J! J9 c2 J. _( y# F; U% N
48. void W25QXX_Write(u8* pBuffer,u32 WriteAddr,u16 NumByteToWrite);//写入flash
    
49. void W25QXX_Erase_Chip(void);                      //整片擦除
    
50. void W25QXX_Erase_Sector(u32 Dst_Addr);        //扇区擦除
    
51. void W25QXX_Wait_Busy(void);                   //等待空闲
    
52. void W25QXX_PowerDown(void);                //进入掉电模式
    6 a7 C! q) o/ J/ {8 H2 F4 n: ~  ^$ U
53. void W25QXX_WAKEUP(void);                                //唤醒
    
54. #endif

复制代码

w25qxx.c
! }! w7 |; f: ]- K4 O" g( n2 C

1. #include "w25qxx.h"
   + P; F0 Q5 O( {4 |. p
2. #include "spi.h"
   8 ~9 m; b# M3 I! n" D* L, f; L) t! y
3. #include "delay.h"           
   + H3 ~9 ^2 r/ X8 ?# \1 K. e( n' s
4. #include "usart.h"        
   
5. 
   ; _& z& O7 V; J  U7 u
6. 
   
7. u16 W25QXX_TYPE=W25Q128;        //默认是W25Q128
   ( v) p2 W* B9 }* u9 \, _5 F9 [
8. 
   8 b% B, }# H2 I4 ]; s4 P, A
9. //4Kbytes为一个Sector
   % u( Y+ }# ~+ D" h5 d
10. //16个扇区为1个Block
    
11. //W25Q128
    2 m% O6 Q* c+ h3 @0 R
12. //容量为16M字节,共有128个Block,4096个Sector
    / G1 M) I4 T6 l- _0 v, o1 N' P
13.                                                                                                          
    
14. //初始化SPI FLASH的IO口
    - K2 a% t9 `+ C+ e2 o/ Z
15. void W25QXX_Init(void)
    % X+ O8 v6 U7 z8 g
16. {
    1 Y0 \) P" c4 e9 m+ [; p5 R
17.   GPIO_InitTypeDef  GPIO_InitStructure;
    . R, x+ M9 }3 }6 o  G9 S7 M" G
18. 
    6 Q% z+ f% A, N' }
19.   RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOB, ENABLE);//使能GPIOB时钟
    
20.   RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOG, ENABLE);//使能GPIOG时钟
    6 _4 p! b4 I6 H9 E
21. 
    
22.           //GPIOB14
    & s' N4 f/ L! g. x
23.   GPIO_InitStructure.GPIO_Pin = GPIO_Pin_14;//PB14
    5 T, U$ k$ n% N$ t# O/ G
24.   GPIO_InitStructure.GPIO_Mode = GPIO_Mode_OUT;//输出
    ' ~/ @9 v; o6 M4 y7 ~
25.   GPIO_InitStructure.GPIO_OType = GPIO_OType_PP;//推挽输出
    % T+ q! g/ u' `+ K0 m
26.   GPIO_InitStructure.GPIO_Speed = GPIO_Speed_100MHz;//100MHz
    9 i0 y% Y4 ^7 D$ K6 u6 d
27.   GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_UP;//上拉
    
28.   GPIO_Init(GPIOB, &GPIO_InitStructure);//初始化
    
29. 
    
30.         GPIO_InitStructure.GPIO_Pin = GPIO_Pin_7;//PG7
    " l0 n4 _3 [  _5 R! ~& L+ m
31.   GPIO_Init(GPIOG, &GPIO_InitStructure);//初始化
    2 E) L1 _4 H* _6 z( y
32. 
    
33.         GPIO_SetBits(GPIOG,GPIO_Pin_7);//PG7输出1,防止NRF干扰SPI FLASH的通信
    8 t2 `% N& l, v7 W& r
34.         W25QXX_CS=1;                        //SPI FLASH不选中
    
35.         SPI1_Init();                                           //初始化SPI
    1 e) ^" o; B$ b$ s
36.         SPI1_SetSpeed(SPI_BaudRatePrescaler_4);                //设置为21M时钟,高速模式
    9 w  p5 R) M$ R  Z! F
37.         W25QXX_TYPE=W25QXX_ReadID();        //读取FLASH ID.
    
38. }  
    
39. 
    4 x$ o1 }7 s9 l+ x3 P- A0 ^
40. //读取W25QXX的状态寄存器
    4 t; w3 p* z  ^  z
41. //BIT7  6   5   4   3   2   1   0
    4 J, K, c& v0 n0 L; W: @  N  f% g
42. //SPR   RV  TB BP2 BP1 BP0 WEL BUSY
    5 ~; E+ n$ ^$ u5 Q' E
43. //SPR:默认0,状态寄存器保护位,配合WP使用
    
44. //TB,BP2,BP1,BP0:FLASH区域写保护设置
    ; _- Q& }9 R" S' h0 e
45. //WEL:写使能锁定
    6 a' _4 U. z7 _) x) w& l0 p' T
46. //BUSY:忙标记位(1,忙;0,空闲)
      ~1 Y2 t2 r$ D+ ^0 l" }
47. //默认:0x00
    6 I* m7 e9 O) N1 C
48. u8 W25QXX_ReadSR(void)   
    4 `4 l7 }5 [$ T" N. }8 f- R1 o
49. {  
    
50.         u8 byte=0;   
    
51.         W25QXX_CS=0;                            //使能器件   
    * ]* N# N+ c7 M% ]) i! N4 J1 g
52.         SPI1_ReadWriteByte(W25X_ReadStatusReg);    //发送读取状态寄存器命令   
    ) |& y( v$ `+ g3 Z4 {* y( h
53.         byte=SPI1_ReadWriteByte(0Xff);             //读取一个字节  
    2 z; p$ s. C% d3 }- B" d
54.         W25QXX_CS=1;                            //取消片选     
    
55.         return byte;   
    
56. }
    2 R; z0 V! b& y
57. //写W25QXX状态寄存器
    . H, e5 P4 t9 Q; Q4 N
58. //只有SPR,TB,BP2,BP1,BP0(bit 7,5,4,3,2)可以写!!!
    
59. void W25QXX_Write_SR(u8 sr)   
    
60. {   
    
61.         W25QXX_CS=0;                            //使能器件   
    0 d& L2 d% j" ]# c( q) `0 j
62.         SPI1_ReadWriteByte(W25X_WriteStatusReg);   //发送写取状态寄存器命令   
    8 b% C$ D! E- Y% v9 }$ ^
63.         SPI1_ReadWriteByte(sr);               //写入一个字节  
    & j7 T4 e3 \: z* d( i
64.         W25QXX_CS=1;                            //取消片选                  
    
65. }   
    & O6 t1 _8 m) |2 f. H: E/ g
66. //W25QXX写使能        
    
67. //将WEL置位   
    
68. void W25QXX_Write_Enable(void)   
    # E. u7 f9 q7 h0 |" Z! a3 e8 B
69. {
    
70.         W25QXX_CS=0;                            //使能器件   
    ) O6 A' b! X: m6 Q4 J
71.     SPI1_ReadWriteByte(W25X_WriteEnable);      //发送写使能  
    
72.         W25QXX_CS=1;                            //取消片选                  
    ! V" f5 y; ^6 R$ ]. O- e  p+ ^
73. }
    
74. //W25QXX写禁止        
    
75. //将WEL清零  
    
76. void W25QXX_Write_Disable(void)   
    & s. ]+ I* n  e' r+ u# V
77. {  
    + {. D' r5 k+ |6 N2 E4 \# x7 V
78.         W25QXX_CS=0;                            //使能器件   
    % z  S6 f; a6 x3 {
79.     SPI1_ReadWriteByte(W25X_WriteDisable);     //发送写禁止指令   
    ! S+ }  O- j, ]" Q$ y" D* O
80.         W25QXX_CS=1;                            //取消片选                  
    
81. }                 
    / y" p, J  r& D
82. //读取芯片ID
    6 x# ^* T' R3 H
83. //返回值如下:                                   
    
84. //0XEF13,表示芯片型号为W25Q80  
    
85. //0XEF14,表示芯片型号为W25Q16   
    ! x6 L2 F; j" U: i9 l9 P& ~# F; B
86. //0XEF15,表示芯片型号为W25Q32  
    * t3 X* X% I& x7 E2 _' W
87. //0XEF16,表示芯片型号为W25Q64
    3 e* n: r# N% J- Q
88. //0XEF17,表示芯片型号为W25Q128           
    
89. u16 W25QXX_ReadID(void)
    4 ]  N* j. s4 y: s3 P$ q8 r
90. {
    & j7 a/ U9 H$ K0 L" j* q5 b) u
91.         u16 Temp = 0;         
    6 p6 L9 h% e3 z: K
92.         W25QXX_CS=0;                                    
    6 B' g! p% H+ x- ]8 `+ c
93.         SPI1_ReadWriteByte(0x90);//发送读取ID命令            
    2 M1 ?" _* e' d
94.         SPI1_ReadWriteByte(0x00);            
    , r( m, N; Q* ^5 ]/ e  E
95.         SPI1_ReadWriteByte(0x00);            
    - a$ N, d' [! _4 b+ b  g* S
96.         SPI1_ReadWriteByte(0x00);                                    
    1 G1 W) H% w5 T& D$ b( G
97.         Temp|=SPI1_ReadWriteByte(0xFF)<<8;  
    
98.         Temp|=SPI1_ReadWriteByte(0xFF);         
    
99.         W25QXX_CS=1;                                    
    ; T8 |' |: K1 Y9 g2 q$ Z
100.         return Temp;
     
101. }                       
     5 x3 o- t# y. v( J
102. //读取SPI FLASH  
     
103. //在指定地址开始读取指定长度的数据
     
104. //pBuffer:数据存储区
     $ |* S4 Q1 D+ T' j" ?
105. //ReadAddr:开始读取的地址(24bit)
     - @: U* H& ?, c; _! g+ {
106. //NumByteToRead:要读取的字节数(最大65535)
     
107. void W25QXX_Read(u8* pBuffer,u32 ReadAddr,u16 NumByteToRead)   
     
108. {
     
109.          u16 i;                                                                                       
     
110.         W25QXX_CS=0;                            //使能器件   
     % z( T& g0 |$ r
111.     SPI1_ReadWriteByte(W25X_ReadData);         //发送读取命令   
     
112.     SPI1_ReadWriteByte((u8)((ReadAddr)>>16));  //发送24bit地址   
     
113.     SPI1_ReadWriteByte((u8)((ReadAddr)>>8));   
     1 D$ D3 Z) X' j: j3 h9 ~& _) F) ]2 Q
114.     SPI1_ReadWriteByte((u8)ReadAddr);   
     
115.     for(i=0;i<NumByteToRead;i++)
     1 m6 o2 u3 Z) x. w1 _1 T5 }2 i
116.         {
     
117.         pBuffer<i>=SPI1_ReadWriteByte(0XFF);   //循环读数  
     , I( Z* E; N: p. v
118.     }
     
119.         W25QXX_CS=1;                                                   
     6 S5 y) P9 U* t
120. }  
     
121. //SPI在一页(0~65535)内写入少于256个字节的数据
     
122. //在指定地址开始写入最大256字节的数据
     
123. //pBuffer:数据存储区
     
124. //WriteAddr:开始写入的地址(24bit)
     ! S, c2 p5 v# ^9 a2 K( s4 \0 s; s
125. //NumByteToWrite:要写入的字节数(最大256),该数不应该超过该页的剩余字节数!!!         
     
126. void W25QXX_Write_Page(u8* pBuffer,u32 WriteAddr,u16 NumByteToWrite)
     
127. {
     
128.          u16 i;  
     6 O; E; A4 d, M; ~! W: D
129.     W25QXX_Write_Enable();                  //SET WEL
     
130.         W25QXX_CS=0;                            //使能器件   
     
131.     SPI1_ReadWriteByte(W25X_PageProgram);      //发送写页命令   
     2 K  g' z6 p8 }0 R6 Z
132.     SPI1_ReadWriteByte((u8)((WriteAddr)>>16)); //发送24bit地址   
     $ x3 a) G) D4 X4 e
133.     SPI1_ReadWriteByte((u8)((WriteAddr)>>8));   
     
134.     SPI1_ReadWriteByte((u8)WriteAddr);   
     
135.     for(i=0;i<NumByteToWrite;i++)SPI1_ReadWriteByte(pBuffer<i>);//循环写数  
     
136.         W25QXX_CS=1;                            //取消片选
     2 X2 b9 Z2 _8 j4 g/ N4 q
137.         W25QXX_Wait_Busy();                                           //等待写入结束
     1 @5 D: M& Z/ k! h& `
138. }
     
139. //无检验写SPI FLASH
     0 Q7 I7 @; ]3 o1 D
140. //必须确保所写的地址范围内的数据全部为0XFF,否则在非0XFF处写入的数据将失败!
     ) C  t/ m9 K4 G
141. //具有自动换页功能
     
142. //在指定地址开始写入指定长度的数据,但是要确保地址不越界!
     2 j0 M9 P( _: Y# p! F& U5 g# D: o
143. //pBuffer:数据存储区
     
144. //WriteAddr:开始写入的地址(24bit)
     
145. //NumByteToWrite:要写入的字节数(最大65535)
     ) }6 O; q) V6 K, J* D3 K# Y
146. //CHECK OK
       W/ x( C3 [, t9 E8 B
147. void W25QXX_Write_NoCheck(u8* pBuffer,u32 WriteAddr,u16 NumByteToWrite)   
     # P3 n+ S! i) q, @+ u
148. {                                          
     1 x# _% F& E# j  ~8 K
149.         u16 pageremain;           
     
150.         pageremain=256-WriteAddr%256; //单页剩余的字节数                             
     3 O9 L  f) K: M! y
151.         if(NumByteToWrite<=pageremain)pageremain=NumByteToWrite;//不大于256个字节
     : z) L( H: a5 J, S
152.         while(1)
     & z0 M2 Y- Y) d, {7 k
153.         {           
     7 o! a# S& C& B; ?5 b; _' ?
154.                 W25QXX_Write_Page(pBuffer,WriteAddr,pageremain);
     9 r" y) Z* Y2 y/ u
155.                 if(NumByteToWrite==pageremain)break;//写入结束了
     ) v) n0 Q4 U/ j7 V3 g/ q
156.                  else //NumByteToWrite>pageremain
     ; e& X: c* l" B$ A+ N! a
157.                 {
     ( _8 B' G7 p: [5 B
158.                         pBuffer+=pageremain;
     
159.                         WriteAddr+=pageremain;        
     
160. 
     
161.                         NumByteToWrite-=pageremain;                          //减去已经写入了的字节数
     1 P) u! ~- \: z5 L, {; O
162.                         if(NumByteToWrite>256)pageremain=256; //一次可以写入256个字节
     $ k5 l* M6 j# Q7 I3 R
163.                         else pageremain=NumByteToWrite;           //不够256个字节了
     ! N. J& h2 N! K2 X8 \: N
164.                 }
     3 L2 t) j* I7 h8 I
165.         };            
     
166. }
     0 h% G. @( H" @0 J+ V  c5 v9 }
167. //写SPI FLASH  
     ! g0 n. @( |. W0 I
168. //在指定地址开始写入指定长度的数据
     
169. //该函数带擦除操作!
     3 i4 Q, [/ I6 f8 \
170. //pBuffer:数据存储区
     
171. //WriteAddr:开始写入的地址(24bit)                                                
     
172. //NumByteToWrite:要写入的字节数(最大65535)   
     
173. u8 W25QXX_BUFFER[4096];                 
     
174. void W25QXX_Write(u8* pBuffer,u32 WriteAddr,u16 NumByteToWrite)   
     
175. {
     
176.         u32 secpos;
     : x8 ^$ ]8 J1 i
177.         u16 secoff;
     5 V0 {+ G0 Z5 l5 L4 N
178.         u16 secremain;           
     
179.          u16 i;   
     ; p  }( U5 o8 P+ g! ?$ P) c' r
180.         u8 * W25QXX_BUF;         
     7 w8 ?6 h# {. W3 p% q' H
181.            W25QXX_BUF=W25QXX_BUFFER;            
     ! C% z' o0 t2 S" Q4 U; w* d
182.          secpos=WriteAddr/4096;//扇区地址  
     7 ?2 B1 Q4 a) P2 ~
183.         secoff=WriteAddr%4096;//在扇区内的偏移
     
184.         secremain=4096-secoff;//扇区剩余空间大小   
     % B6 a* J7 x! }8 c0 _
185.          //printf("ad:%X,nb:%X\r\n",WriteAddr,NumByteToWrite);//测试用
     $ W4 ?" k' o/ E
186.          if(NumByteToWrite<=secremain)secremain=NumByteToWrite;//不大于4096个字节
     - z( u( n! j1 n# ], `
187.         while(1)
     # j# ~+ c* ]6 Z1 v% [9 b
188.         {        
     ( j' Q2 |5 Z1 @* V5 g1 W' j
189.                 W25QXX_Read(W25QXX_BUF,secpos*4096,4096);//读出整个扇区的内容
     7 K: X. Q5 h1 C4 B9 h
190.                 for(i=0;i<secremain;i++)//校验数据
     
191.                 {
       v; @( s8 k2 l: T: ~' ~9 G" W
192.                         if(W25QXX_BUF[secoff+i]!=0XFF)break;//需要擦除            
     ' Q1 I/ q* C# x+ `6 n+ ~% W
193.                 }
     ) h" ?' L6 x+ x5 ]& i" C
194.                 if(i<secremain)//需要擦除
     # I. \0 Q0 }* X. u/ o+ R5 D
195.                 {
     0 u! h9 ?( F# W( f) t8 u$ j9 i& a1 ^
196.                         W25QXX_Erase_Sector(secpos);//擦除这个扇区
     
197.                         for(i=0;i<secremain;i++)           //复制
     
198.                         {
     
199.                                 W25QXX_BUF[i+secoff]=pBuffer<i>;         
     + K0 h. Z8 g! z. O4 J3 i
200.                         }
     
201.                         W25QXX_Write_NoCheck(W25QXX_BUF,secpos*4096,4096);//写入整个扇区  
     
202. 
     ' e# _2 X. C! B1 P  _
203.                 }else W25QXX_Write_NoCheck(pBuffer,WriteAddr,secremain);//写已经擦除了的,直接写入扇区剩余区间.                                    
     2 B4 Q9 R5 Q! q+ w$ Y( b
204.                 if(NumByteToWrite==secremain)break;//写入结束了
     $ D7 w! Z- v9 S' i4 n8 N4 M% I
205.                 else//写入未结束
     
206.                 {
     
207.                         secpos++;//扇区地址增1
     % C0 R* V6 s; f) i8 S6 D( u
208.                         secoff=0;//偏移位置为0         
     
209. 
     ; O" q/ C8 i. b: J
210.                            pBuffer+=secremain;  //指针偏移
     4 Q4 w5 L* U6 _% C# b; R/ G1 Q
211.                         WriteAddr+=secremain;//写地址偏移           
     
212.                            NumByteToWrite-=secremain;                                //字节数递减
     
213.                         if(NumByteToWrite>4096)secremain=4096;        //下一个扇区还是写不完
     
214.                         else secremain=NumByteToWrite;                        //下一个扇区可以写完了
     
215.                 }         
     2 _! V" H9 X, e% C
216.         };         
     
217. }
     ; Y* b/ Q* m: M3 U7 F( z0 ?
218. //擦除整个芯片                  
     6 m! o: e4 |: H& _
219. //等待时间超长...
     9 i+ r! Z! N3 z& @
220. void W25QXX_Erase_Chip(void)   
     3 E# c# B& }' Y# t3 x! l( G) x
221. {                                   
     2 X+ R3 O/ R1 L% r
222.     W25QXX_Write_Enable();                  //SET WEL
     " B( P. i8 M. {2 j" O2 A3 j" n' y
223.     W25QXX_Wait_Busy();   
     - I4 V. p/ ^' ^' T
224.           W25QXX_CS=0;                            //使能器件   
     
225.     SPI1_ReadWriteByte(W25X_ChipErase);        //发送片擦除命令  
     
226.         W25QXX_CS=1;                            //取消片选                  
     , u) r' F" O& O) ~. d8 p0 d0 j
227.         W25QXX_Wait_Busy();                                      //等待芯片擦除结束
     
228. }   
     
229. //擦除一个扇区
     , p' d0 s+ `' s+ V) y
230. //Dst_Addr:扇区地址 根据实际容量设置
     * X# D! I9 B  H: e5 O6 `) ^
231. //擦除一个山区的最少时间:150ms
     + j% B& j) U' @4 x" S. U
232. void W25QXX_Erase_Sector(u32 Dst_Addr)   
       p! l& o% c+ p
233. {  
     ( N+ B, M0 R7 p! B
234.         //监视falsh擦除情况,测试用   
     ; T, P8 ?% J" a
235.          printf("fe:%x\r\n",Dst_Addr);         
       d4 s0 i7 L" D  e  I
236.          Dst_Addr*=4096;
     : l/ J+ \# I5 ~- V7 v5 P. m
237.     W25QXX_Write_Enable();                  //SET WEL         
     / J* e% m7 L' k
238.     W25QXX_Wait_Busy();   
     
239.           W25QXX_CS=0;                            //使能器件   
     # h! c) z+ @5 E$ q5 q4 N3 Y
240.     SPI1_ReadWriteByte(W25X_SectorErase);      //发送扇区擦除指令
     
241.     SPI1_ReadWriteByte((u8)((Dst_Addr)>>16));  //发送24bit地址   
     
242.     SPI1_ReadWriteByte((u8)((Dst_Addr)>>8));   
     7 Q5 t( Y7 q3 w7 M% Z5 X4 p
243.     SPI1_ReadWriteByte((u8)Dst_Addr);  
     
244.         W25QXX_CS=1;                            //取消片选                  
     5 m% h' s+ K" W) Q
245.     W25QXX_Wait_Busy();                                      //等待擦除完成
     9 J; w# n; z' v! W+ b, R
246. }  
     
247. //等待空闲
     % E: x' q  M% T* D7 q6 L
248. void W25QXX_Wait_Busy(void)   
     
249. {   
     
250.         while((W25QXX_ReadSR()&0x01)==0x01);   // 等待BUSY位清空
     6 k+ M9 c4 O6 M* Y3 N5 U
251. }  
     5 u8 T7 S# Y% b& G: R% p
252. //进入掉电模式
     
253. void W25QXX_PowerDown(void)   
     ' c, ]; L- v$ {$ B% }
254. {
     + q4 s5 [, |) U: @
255.           W25QXX_CS=0;                            //使能器件   
     
256.     SPI1_ReadWriteByte(W25X_PowerDown);        //发送掉电命令  
     
257.         W25QXX_CS=1;                            //取消片选                  
       F) y3 T8 D0 J
258.     delay_us(3);                               //等待TPD  
     - i  J/ ~: y) T
259. }   
     5 w/ n" O: ]. T% p+ H; g' ~
260. //唤醒
     9 O1 V# V% L& K$ ~
261. void W25QXX_WAKEUP(void)   
     
262. {  
     
263.           W25QXX_CS=0;                            //使能器件   
     , {$ F; h& G2 i: i; X% p
264.     SPI1_ReadWriteByte(W25X_ReleasePowerDown);   //  send W25X_PowerDown command 0xAB   
     . U! r2 r# e$ Y: [9 t
265.         W25QXX_CS=1;                            //取消片选                  
     # ?4 T* c" b; D# [+ a% r7 v
266.     delay_us(3);                               //等待TRES1
     3 n) E6 d) ~5 u* I4 U  h" E
267. }   </i></i></i>

复制代码

3 a7 {  Q9 z' A% N* [4 qmain.c
. t: X4 y: {! z0 G' f- R* K
+ u) |; ?7 n6 z. x0 a  E( M$ C. R

1. #include "sys.h"
   $ m" l2 x. M* o
2. #include "delay.h"
   4 |. O6 r! w# G5 q, V: ?
3. #include "usart.h"
     q* V8 q$ W, F
4. #include "led.h"
   4 j! w% _' D) U( h
5. #include "lcd.h"
   
6. #include "spi.h"
   8 ]1 r4 D5 c8 h; D4 J( }
7. #include "w25qxx.h"
   
8. #include "key.h"  
   
9. 
   
10. 
    
11. //要写入到W25Q16的字符串数组
    # n- Q3 F3 x( L) @5 ^0 I: X
12. const u8 TEXT_Buffer[]={"Explorer STM32F4 SPI TEST"};
    
13. #define SIZE sizeof(TEXT_Buffer)         
    
14.         
    
15. int main(void)
    
16. {
    # P; N4 M" n3 h
17.         u8 key;
    + r: C' T/ [# I# i9 H; m
18.         u16 i=0;
    
19.         u8 datatemp[SIZE];
    
20.         u32 FLASH_SIZE;
    
21.         NVIC_PriorityGroupConfig(NVIC_PriorityGroup_2);//设置系统中断优先级分组2
    : O3 p' ]4 ^, A+ j$ Q
22.         delay_init(168);     //初始化延时函数
    
23.         uart_init(115200);        //初始化串口波特率为115200
    ' k$ _' u5 e6 q+ @9 j3 e) I
24.         LED_Init();                                        //初始化LED
    5 M/ X6 B, p1 B
25.          LCD_Init();                                        //LCD初始化
    ) y6 Q" m! M6 W" B' m
26.         KEY_Init();                                 //按键初始化  
    
27.         W25QXX_Init();                        //W25QXX初始化
    4 F* {6 h- r4 S4 T+ M" W
28.          POINT_COLOR=RED;
    
29.         LCD_ShowString(30,50,200,16,16,"Explorer STM32F4");        
    3 w$ M. |9 Q; i& U1 i5 A
30.         LCD_ShowString(30,70,200,16,16,"SPI TEST");        
    
31.         LCD_ShowString(30,90,200,16,16,"ATOM@ALIENTEK");
    
32.         LCD_ShowString(30,110,200,16,16,"2014/5/6");         
    ( r. d' Z4 l8 r& A/ n
33.         LCD_ShowString(30,130,200,16,16,"KEY1:Write  KEY0:Read");        //显示提示信息               
    $ l1 h1 L8 ?1 s$ b$ M+ T6 q! R
34.         while(W25QXX_ReadID()!=W25Q128)                                                                //检测不到W25Q128
    $ N* M2 L) f! Q- L
35.         {
    - E# i1 H5 J4 l6 E- K' k
36.                 LCD_ShowString(30,150,200,16,16,"W25Q128 Check Failed!");
    4 n' A! K  t8 Z
37.                 delay_ms(500);
    
38.                 LCD_ShowString(30,150,200,16,16,"Please Check!      ");
    
39.                 delay_ms(500);
    
40.                 LED1=!LED1;                //DS0闪烁
    
41.         }
    * N9 N+ b' u& w% C, ^2 V
42.         LCD_ShowString(30,150,200,16,16,"W25Q128 Ready!");
    6 C  [" b& Z: B
43.         FLASH_SIZE=16*1024*1024;        //FLASH 大小为16字节
    4 R6 z2 l& P9 E6 D; v4 z8 p, ?
44.           POINT_COLOR=BLUE;                        //设置字体为蓝色         
    
45.         while(1)
    7 ~1 o, c! K% ~$ Z" S  |
46.         {
    & f+ j2 W; b# Y' R+ Y! [
47.                 key=Key_Scan();
    3 |; ^2 T! o3 e
48.                 if(key==KEY1_PRESS)//KEY1按下,写入W25Q128
    
49.                 {
    : p8 b- u: g7 x
50.                         LCD_Fill(0,170,239,319,WHITE);//清除半屏   
    
51.                          LCD_ShowString(30,170,200,16,16,"Start Write W25Q128....");
    
52.                         W25QXX_Write((u8*)TEXT_Buffer,FLASH_SIZE-100,SIZE);                //从倒数第100个地址处开始,写入SIZE长度的数据
    
53.                         LCD_ShowString(30,170,200,16,16,"W25Q128 Write Finished!");        //提示传送完成
    ( o& y" t9 \: W* B/ s! T3 Q
54.                 }
    1 w! U7 J: l2 c2 g6 C
55.                 if(key==KEY0_PRESS)//KEY0按下,读取字符串并显示
    7 p" c' b: y, Z+ K4 g7 X; O
56.                 {
    
57.                          LCD_ShowString(30,170,200,16,16,"Start Read W25Q128.... ");
    
58.                         W25QXX_Read(datatemp,FLASH_SIZE-100,SIZE);                                        //从倒数第100个地址处开始,读出SIZE个字节
    
59.                         LCD_ShowString(30,170,200,16,16,"The Data Readed Is:   ");        //提示传送完成
    ( m7 J/ L$ u0 h  Q; z: c( e. t
60.                         LCD_ShowString(30,190,200,16,16,datatemp);                                        //显示读到的字符串
    
61.                 }
    * J4 h7 |  f. x
62.                 i++;
    
63.                 delay_ms(10);
    2 P! x6 h6 j' R& _/ \5 M* R
64.                 if(i==20)
    
65.                 {
    
66.                         LED1=!LED1;//提示系统正在运行        
    5 O$ o2 H, x  B& V
67.                         i=0;
    7 d( n  \9 A* B1 V* x
68.                 }                  
    
69.         }      
    7 f  c$ E/ C2 d
70. }

复制代码

8 B! w( N% Y. c4 ?) q$ d2 b05. 结果验证
按 KEY1 按键写入数据，然后按 KEY0 读取数据。DS0 的不停闪烁，提示程序在运行。
6 }- a: Y: |2 W1 X' F4 M& n4 j5 u