devbox
AllinToyou
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

STM32入门开发: 介绍SPI总线、读写W25Q64(FLASH)(硬件+模拟时序)_stm32模拟spi最大速度

作者：AllinToyou | 2024-03-06 15:35:57

赞

踩

stm32模拟spi最大速度

一、环境介绍

编程软件: keil5

操作系统: win10

MCU型号: STM32F103ZET6

STM32编程方式: 寄存器开发 (方便程序移植到其他单片机)

SPI总线:  STM32本身支持SPI硬件时序，本文示例代码里同时采用模拟时序和硬件时序两种方式读写W25Q64。

模拟时序更加方便移植到其他单片机，更加方便学习理解SPI时序，通用性更高，不分MCU；

硬件时序效率更高，每个MCU配置方法不同，依赖MCU硬件本身支持。

存储器件： 采用华邦W25Q64  flash存储芯片。 

W25Q64这类似的Flash存储芯片在单片机里、嵌入式系统里还是比较常见，可以用来存储图片数据、字库数据、音频数据、保存设备运行日志文件等。

完整工程代码下载：https://download.csdn.net/download/xiaolong1126626497/19425042

二、华邦W25Q64介绍(FLASH存储类型)

2.1 W25Q64芯片功能介绍

W25Q64是为系统提供一个最小空间、最少引脚，最低功耗的串行Flash存储器，25Q系列比普通的串行Flash存储器更灵活，性能更优越。

W25Q64支持双倍/四倍的SPI，可以储存包括声音、文本、图片和其他数据；芯片支持的工作电压 2.7V 到 3.6V，正常工作时电流小于5mA，掉电时低于1uA，所有芯片提供标准的封装。 

W25Q64的内存空间结构:  一页256字节，4K(4096 字节)为一个扇区，16个扇区为1块，容量为8M字节，共有128个块，2048 个扇区。  

W25Q64每页大小由256字节组成，每页的256字节用一次页编程指令即可完成。

擦除指令分别支持: 16页（1个扇区）、128页、256页、全片擦除。 

W25Q64支持标准串行外围接口（SPI），和高速的双倍/四倍输出，双倍/四倍用的引脚：串行时钟、片选端、串行数据 I/O0(DI)、I/O1(DO)、I/O2(WP)和 I/O3(HOLD)。
SPI 最高支持 80MHz，当用快读双倍/四倍指令时，相当于双倍输出时最高速率160MHz，四倍输出时最高速率 320MHz。这个传输速率比得上8位和16位的并行Flash存储器。
 
W25Q64支持 JEDEC 标准，具有唯一的 64 位识别序列号，方便区别芯片型号。

 2.2 W25Q64芯片特性详细介绍

●SPI串行存储器系列    
-W25Q64:64M 位/8M 字节    
-W25Q16:16M 位/2M 字节    
-W25Q32:32M 位/4M 字节    
-每 256 字节可编程页    

    
●灵活的4KB扇区结构     
-统一的扇区擦除（4K 字节）     
-块擦除（32K 和 64K 字节） 
-一次编程 256 字节 
-至少 100,000 写/擦除周期 
-数据保存 20 年 
    
●标准、双倍和四倍SPI 
-标准 SPI:CLK、CS、DI、DO、WP、HOLD         
-双倍 SPI:CLK、CS、IO0、IO1、WP、HOLD         
-四倍 SPI:CLK、CS、IO0、IO1、IO2、IO3 

●高级的安全特点 
-软件和硬件写保护 
-选择扇区和块保护 
-一次性编程保护(1) 
-每个设备具有唯一的64位ID(1) 

●高性能串行Flash存储器     
-比普通串行Flash性能高6倍          
-80MHz时钟频率          
-双倍SPI相当于160MHz         
-四倍SPI相当于320MHz         
-40MB/S连续传输数据     
-30MB/S随机存取（每32字节）     
-比得上16位并行存储器
         
●低功耗、宽温度范围 
-单电源 2.7V-3.6V 
-工作电流 4mA，掉电<1μA（典型值）
-40℃～+85℃工作 

2.3  引脚介绍

下面只介绍W25Q64标准SPI接口，因为目前开发板上的封装使用的就是标准SPI接口。

 

引脚编号

引脚名称

I/O

功能

1

/CS

I

片选端输入

2

DO(IO1)

I/O

数据输出（数据输入输出 1）*1 

3

/WP(IO2)

I/O

写保护输入（数据输入输出 2）*2 

4

GND

 

地

5

DI(IO0)

I/O

数据输入（数据输入输出 0）*1 

6

CLK

I

串行时钟输入

7

/HOLD(IO3)

I/O

保持端输入（数据输入输出 3）*2 

8

VCC

 

电源

  2.2.1 SPI片选（/CS）引脚用于使能和禁止芯片操作

CS引脚是W25Q64的片选引脚，用于选中芯片；当CS为高电平时，芯片未被选择，串行数据输出（DO、IO0、IO1、IO2 和 IO3）引脚为高阻态。未被选择时，芯片处于待机状态下的低功耗，除非芯片内部在擦除、编程。当/CS 变成低电平，芯片功耗将增长到正常工作，能够从芯片读写数据。上电后， 在接收新的指令前，/CS 必须由高变为低电平。上电后，/CS 必须上升到 VCC，在/CS 接上拉电阻可以完成这个操作。 

2.2.2 串行数据输入、输出和 IOs（DI、DO 和 IO0、IO1、IO2、IO3）

W25Q64、W25Q16 和 W25Q32 支持标准 SPI、双倍 SPI 和四倍 SPI。

标准的 SPI 传输用单向的 DI（输入）引脚连续的写命令、地址或者数据在串行时钟（CLK）的上升沿时写入到芯片内。

标准的SPI 用单向的 DO（输出）在 CLK 的下降沿从芯片内读出数据或状态。 

2.2.3 写保护（/WP）

写保护引脚（/WP）用来保护状态寄存器。和状态寄存器的块保护位（SEC、TB、BP2、BP1 和BP0）和状态寄存器保护位（SRP）对存储器进行一部分或者全部的硬件保护。/WP 引脚低电平有效。当状态寄存器 2 的 QE 位被置位了，/WP 引脚（硬件写保护）的功能不可用。

2.2.4  保持端（/HOLD）

当/HOLD 引脚是有效时，允许芯片暂停工作。在/CS 为低电平时，当/HOLD 变为低电平，DO 引脚将变为高阻态，在 DI 和 CLK 引脚上的信号将无效。当/HOLD 变为高电平，芯片恢复工作。/HOLD 功能用在当有多个设备共享同一 SPI 总线时。/HOLD 引脚低电平有效。当状态寄存器 2 的 QE 位被置位了，/ HOLD 引脚的功能不可用。

2.2.5 串行时钟（CLK）

串行时钟输入引脚为串行输入和输出操作提供时序。（见 SPI 操作）。

设备数据传输是从高位开始，数据传输的格式为 8bit,数据采样从第二个时间边沿开始，空闲状态时，时钟线 clk 为高电平。 

2.3 内部结构框架图

2.4 W25Q64的标准SPI操作流程

W25Q64标准SPI总线接口包含四个信号: 串行时钟（CLK）、片选端（/CS）、串行数据输入（DI）和串行数据输出（DO）。

DI输入引脚在CLK的上升沿连续写命令、地址或数据到芯片内。

DO输出引脚在CLK的下降沿从芯片内读出数据或状态。

W25Q64分别支持SPI总线工作模式0和工作模式3。模式0和模式3的主要区别在于常态时的CLK信号不同；对于模式0来说，当SPI主机已准备好数据还没传输到串行Flash中时，CLK信号常态为低；

设备数据传输是从高位开始，数据传输的格式为8bit，数据采样从第二个时间边沿开始，空闲状态时，时钟线clk为高电平。

 

2.5 部分控制和状态寄存器介绍

2.5.1 W25Q64的指令表

 

指令名称

字节 1

（代码）

 

字节 2

 

字节 3

 

字节 4

 

字节 5

 

字节 6

写使能

06h

write_enabled 

禁止写

04h

 

读状态寄存器 1

05h

(S7-S0)（2） 

 

读状态寄存器 2

35h

(S15-S8)（2） 

 

写状态寄存器

01h

(S7-S0)

(S15-S8)

 

页编程

02h

A23-A16

A15-A8

A7-A0

(D7-D0)

 

四倍页编程

32h

A23-A16

A15-A8

A7-A0

(D7-D0,…)(3) 

 

块擦除(64KB)

D8h

A23-A16

A15-A8

A7-A0

 

块擦除(32KB)

52h

A23-A16

A15-A8

A7-A0

 

扇区擦除(4KB)

20h

A23-A16

A15-A8

A7-A0

 

全片擦除

C7h/60h

 

暂停擦除

75h

 

恢复擦除

7Ah

 

掉电模式

B9h

 

高性能模式

A3h

 

 

 

 

 

2.5.2 读状态寄存器1

状态寄存器1的内部结构如下：

状态寄存器1的S0位是当前W25Q64的忙状态；为1的时候表示设备正在执行程序(可能是在擦除芯片)或写状态寄存器指令，这个时候设备将忽略传来的指令， 除了读状态寄存器和擦除暂停指令外，其他写指令或写状态指令都无效,  当 S0 为 0 状态时指示设备已经执行完毕，可以进行下一步操作。 

读状态寄存器1的时序如下：

读取状态寄存器的指令是 8 位的指令。发送指令之前，先将/CS 拉低，再发送指令码“05 h” 或者“35h”。设备收到读取状态寄存器的指令后，将状态信息(高位)依次移位发送出去，读出的状态信息，最低位为 1 代表忙，最低位为 0 代表可以操作，状态信息读取完毕，将片选线拉高。 

读状态寄存器指令可以使用在任何时候，即使程序在擦除的过程中或者写状态寄存器周期正在进行中。这可以检测忙碌状态来确定周期是否完成，以确定设备是否可以接受另一个指令。
 

2.5.3 读制造商ID和芯片ID

 时序图如下：

读取制造商/设备 ID 指令可以读取制造商 ID 和特定的设备 ID。读取之前，拉低 CS 片选信号，接着发送指令代码“90h” ，紧随其后的是一个 24 位地址(A23-A0)000000h。 设备收到指令之后，会发出华邦电子制造商 ID(EFh) 和设备ID(w25q64 为 16h)。如果 24 位地址设置为 000001h ，设备 ID 会先发出，然后跟着制造商 ID。制造商和设备ID可以连续读取。完成指令后，片选信号/ CS 拉高。

2.5.4 全片擦除（C7h/60h）

全芯片擦除指令，可以将整个芯片的所有内存数据擦除，恢复到 0XFF 状态。写入全芯片擦除指令之前必须执行设备写使能(发送设备写使能指令 0x06)，并判断状态寄存器(状态寄存器位最低位必须等于 0 才能操作)。发送全芯片擦除指令前，先拉低/ CS，接着发送擦除指令码”C7h”或者是”60h”， 指令码发送完毕后，拉高片选线 CS/,，并判断状态位，等待擦除结束。全片擦除指令尽量少用，擦除会缩短设备的寿命。

2.5.5 读数据（03h）

读取数据指令允许按顺序读取一个字节的内存数据。当片选 CS/拉低之后，紧随其后是一个 24 位的地址(A23-A0)(需要发送 3 次，每次 8 个字节，先发高位)。芯片收到地址后，将要读的数据按字节大小转移出去，数据是先转移高位，对于单片机，时钟下降沿发送数据，上升沿接收数据。读数据时，地址会自动增加，允许连续的读取数据。这意味着读取整个内存的数据,只要用一个指令就可以读完。数据读取完成之后，片选信号/ CS 拉高。

读取数据的指令序列,如上图所示。如果一个读数据指令而发出的时候，设备正在擦除扇区,或者(忙= 1)，该读指令将被忽略,也不会对当前周期有什么影响。

三、SPI时序介绍

SPI是串行外设接口（Serial Peripheral Interface）的缩写，是一种高速的，全双工，同步的通信总线，并且在芯片的管脚上只占用四根线，节约了芯片的管脚，同时为PCB的布局上节省空间。

SPI是一种高速、高效率的串行接口技术，一共有4根线。通常由一个主模块和一个或多个从模块组成，主模块选择一个从模块进行同步通信，从而完成数据的交换。SPI是一个环形结构，通信时需要至少4根线（在单向传输时3根线也可以）。分别是MISO（主设备数据输入）、MOSI（主设备数据输出）、SCLK（时钟）、CS（片选）。
（1）MISO– Master Input Slave Output,主设备数据输入，从设备数据输出；
（2）MOSI– Master Output Slave Input，主设备数据输出，从设备数据输入；
（3）SCLK – Serial Clock，时钟信号，由主设备产生；
（4）CS – Chip Select，从设备使能信号，由主设备控制。

其中，CS是从芯片是否被主芯片选中的控制信号，也就是说只有片选信号为预先规定的使能信号时（高电位或低电位），主芯片对此从芯片的操作才有效。这就使在同一条总线上连接多个SPI设备成为可能。接下来就负责通讯的3根线了。通讯是通过数据交换完成的，这里先要知道SPI是串行通讯协议，也就是说数据是一位一位的传输的。这就是SCLK时钟线存在的原因，由SCLK提供时钟脉冲，SDI，SDO则基于此脉冲完成数据传输。数据输出通过 SDO线，数据在时钟上升沿或下降沿时改变，在紧接着的下降沿或上升沿被读取。完成一位数据传输，输入也使用同样原理。因此，至少需要8次时钟信号的改变（上沿和下沿为一次），才能完成8位数据的传输。
时钟信号线SCLK只能由主设备控制，从设备不能控制。这样的传输方式有一个优点，在数据位的传输过程中可以暂停，也就是时钟的周期可以为不等宽，因为时钟线由主设备控制，当没有时钟跳变时，从设备不采集或传送数据。SPI还是一个数据交换协议：因为SPI的数据输入和输出线独立，所以允许同时完成数据的输入和输出。芯片集成的SPI串行同步时钟极性和相位可以通过寄存器配置，IO模拟的SPI串行同步时钟需要根据从设备支持的时钟极性和相位来通讯。SPI通信原理比I2C要简单，IIC有应答机制，可以确保数据都全部发送成。SPI接口没有指定的流控制，没有应答机制确认是否接收到数据，速度上更加快。

SPI总线通过时钟极性和相位可以配置成4种时序：

STM32F103参考手册，SPI章节介绍的时序图：

SPI时序比较简单，CPU如果没有硬件支持，可以直接写代码采用IO口模拟，下面是模拟时序的示例的代码：

  1. SPI的模式1:
  2. u8 SPI_ReadWriteOneByte(u8 tx_data)
  3. {
  4. 	u8 i,rx_data=0;
  5. 	SCK=0; //空闲电平(默认初始化情况)
  6. 	for(i=0;i<8;i++)
  7. 	{
  8. 		/*1. 主机发送一位数据*/
  9. 		SCK=0;//告诉从机,主机将要发送数据
  10. 		if(tx_data&0x80)MOSI=1; //发送数据
  11. 		else MOSI=0;
  12. 		SCK=1; //告诉从机，主机数据发送完毕
  13. 		tx_data<<=1; //继续发送下一位
  14. 		
  15. 		/*2. 主机接收一位数据*/
  16. 		rx_data<<=1; //默认认为接收到0
  17. 		if(MISO)rx_data|=0x01;
  18. 	}
  19. 	SCK=0; //恢复空闲电平
  20. 	return rx_data;
  21. }
  22.  
  23. SPI的模式2:
  24. u8 SPI_ReadWriteOneByte(u8 tx_data)
  25. {
  26. 	u8 i,rx_data=0;
  27. 	SCK=0; //空闲电平(默认初始化情况)
  28. 	for(i=0;i<8;i++)
  29. 	{
  30. 		/*1. 主机发送一位数据*/
  31. 		SCK=1;//告诉从机,主机将要发送数据
  32. 		if(tx_data&0x80)MOSI=1; //发送数据
  33. 		else MOSI=0;
  34. 		SCK=0; //告诉从机，主机数据发送完毕
  35. 		tx_data<<=1; //继续发送下一位
  36. 		
  37. 		/*2. 主机接收一位数据*/
  38. 		rx_data<<=1; //默认认为接收到0
  39. 		if(MISO)rx_data|=0x01;
  40. 	}
  41. 	SCK=0; //恢复空闲电平
  42. 	return rx_data;
  43. }
  44.  
  45.  
  46. SPI的模式3:
  47. u8 SPI_ReadWriteOneByte(u8 tx_data)
  48. {
  49. 	u8 i,rx_data=0;
  50. 	SCK=1; //空闲电平(默认初始化情况)
  51. 	for(i=0;i<8;i++)
  52. 	{
  53. 		/*1. 主机发送一位数据*/
  54. 		SCK=1;//告诉从机,主机将要发送数据
  55. 		if(tx_data&0x80)MOSI=1; //发送数据
  56. 		else MOSI=0;
  57. 		SCK=0; //告诉从机，主机数据发送完毕
  58. 		tx_data<<=1; //继续发送下一位
  59. 		
  60. 		/*2. 主机接收一位数据*/
  61. 		rx_data<<=1; //默认认为接收到0
  62. 		if(MISO)rx_data|=0x01;
  63. 	}
  64. 	SCK=1; //恢复空闲电平
  65. 	return rx_data;
  66. }
  67.  
  68. SPI的模式4:
  69. u8 SPI_ReadWriteOneByte(u8 tx_data)
  70. {
  71. 	u8 i,rx_data=0;
  72. 	SCK=1; //空闲电平(默认初始化情况)
  73. 	for(i=0;i<8;i++)
  74. 	{
  75. 		/*1. 主机发送一位数据*/
  76. 		SCK=0;//告诉从机,主机将要发送数据
  77. 		if(tx_data&0x80)MOSI=1; //发送数据
  78. 		else MOSI=0;
  79. 		SCK=1; //告诉从机，主机数据发送完毕
  80. 		tx_data<<=1; //继续发送下一位
  81. 		
  82. 		/*2. 主机接收一位数据*/
  83. 		rx_data<<=1; //默认认为接收到0
  84. 		if(MISO)rx_data|=0x01;
  85. 	}
  86. 	SCK=1; //恢复空闲电平
  87. 	return rx_data;
  88. }

四、W25Q64的示例代码

4.1 STM32采用硬件SPI读写W25Q64示例代码

  1. /*
  2. 函数功能：SPI初始化(模拟SPI)
  3. 硬件连接：
  4. MISO--->PB14
  5. MOSI--->PB15
  6. SCLK--->PB13
  7. */
  8. void SPI_Init(void)
  9. {
  10. 	/*开启时钟*/
  11. 	RCC->APB1ENR|=1<<14;   //开启SPI2时钟
  12. 	RCC->APB2ENR|=1<<3;    //PB
  13. 	GPIOB->CRH&=0X000FFFFF; //清除寄存器
  14. 	GPIOB->CRH|=0XB8B00000;
  15. 	GPIOB->ODR|=0X7<<13;    	//PB13/14/15上拉--输出高电平
  16. 	/*SPI2基本配置*/
  17. 	SPI2->CR1=0X0; 		//清空寄存器
  18. 	SPI2->CR1|=0<<15; //选择“双线双向”模式
  19. 	SPI2->CR1|=0<<11; //使用8位数据帧格式进行发送/接收；
  20. 	SPI2->CR1|=0<<10; //全双工(发送和接收)；
  21. 	SPI2->CR1|=1<<9;  //启用软件从设备管理
  22. 	SPI2->CR1|=1<<8;  //NSS
  23. 	SPI2->CR1|=0<<7;  //帧格式，先发送高位
  24. 	SPI2->CR1|=0x0<<3;//当总线频率为36MHZ时，SPI速度为18MHZ，高速。
  25. 	SPI2->CR1|=1<<2;  //配置为主设备
  26. 	SPI2->CR1|=1<<1;  //空闲状态时， SCK保持高电平。
  27. 	SPI2->CR1|=1<<0;  //数据采样从第二个时钟边沿开始。
  28. 	SPI2->CR1|=1<<6;  //开启SPI设备。
  29. }
  30.  
  31.  
  32. /*
  33. 函数功能：SPI读写一个字节
  34. */
  35. u8 SPI_ReadWriteOneByte(u8 data_tx)
  36. {
  37.     u16 cnt=0;				 
  38.     while((SPI2->SR&1<<1)==0)		 //等待发送区空--等待发送缓冲为空	
  39.     {
  40.       cnt++;
  41.       if(cnt>=65530)return 0; 	  //超时退出  u16=2个字节
  42.     }	
  43.     SPI2->DR=data_tx;	 	  		      //发送一个byte 
  44.     cnt=0;
  45.     while((SPI2->SR&1<<0)==0) 		//等待接收完一个byte   
  46.     {
  47.       cnt++;
  48.       if(cnt>=65530)return 0;	   //超时退出
  49.     }	  						    
  50.     return SPI2->DR;          		//返回收到的数据	
  51. }
  52.  
  53.  
  54. /*
  55. 函数功能：W25Q64初始化
  56. 硬件连接：
  57. MOSI--->PB15
  58. MISO--->PB14
  59. SCLK--->PB13
  60. CS----->PB12
  61. */
  62. void W25Q64_Init(void)
  63. {
  64. 	/*1. 开时钟*/
  65. 	RCC->APB2ENR|=1<<3; //PB
  66. 	
  67. 	/*2. 配置GPIO口模式*/
  68. 	GPIOB->CRH&=0xFFF0FFFF;
  69. 	GPIOB->CRH|=0x00030000;
  70. 	
  71. 	W25Q64_CS=1; //未选中芯片
  72. 	SPI_Init();   //SPI初始化
  73. }
  74.  
  75.  
  76. /*
  77. 函数功能：读取芯片的ID号
  78. */
  79. u16 W25Q64_ReadID(void)
  80. {
  81. 	u16 id;
  82. 	/*1. 拉低片选*/
  83. 	W25Q64_CS=0;
  84. 	
  85. 	/*2. 发送读取ID的指令*/
  86. 	SPI_ReadWriteOneByte(0x90);
  87. 	
  88. 	/*3. 发送24位的地址-0*/
  89. 	SPI_ReadWriteOneByte(0);
  90. 	SPI_ReadWriteOneByte(0);
  91. 	SPI_ReadWriteOneByte(0);
  92. 	
  93. 	/*4. 读取芯片的ID*/
  94. 	id=SPI_ReadWriteOneByte(0xFF)<<8;
  95. 	id|=SPI_ReadWriteOneByte(0xFF);
  96.  
  97. 	/*5. 拉高片选*/
  98. 	W25Q64_CS=1;
  99. 	return id;
  100. }
  101.  
  102. /*
  103. 函数功能：检测W25Q64状态
  104. */
  105. void W25Q64_CheckStat(void)
  106. {
  107. 	u8 stat=1;
  108. 	while(stat&1<<0)
  109. 	{
  110. 		W25Q64_CS=0; //选中芯片
  111. 		SPI_ReadWriteOneByte(0x05);      //发送读状态寄存器1指令
  112. 		stat=SPI_ReadWriteOneByte(0xFF); //读取状态
  113. 		W25Q64_CS=1; //取消选中芯片
  114. 	}
  115. }
  116.  
  117.  
  118. /*
  119. 函数功能：页编程
  120. 说    明：一页最多写256个字节。 写数据之前，必须保证空间是0xFF
  121. 函数参数：
  122. u32 addr:页编程起始地址
  123. u8 *buff:写入的数据缓冲区
  124. u16 len :写入的字节长度
  125. */
  126. void W25Q64_PageWrite(u32 addr,u8 *buff,u16 len)
  127. {
  128. 	u16 i;
  129. 	W25Q64_Enabled();  						//写使能
  130. 	W25Q64_CS=0; //选中芯片
  131. 	SPI_ReadWriteOneByte(0x02); //页编程指令
  132. 	SPI_ReadWriteOneByte(addr>>16); //24~16地址
  133. 	SPI_ReadWriteOneByte(addr>>8);  //16~8地址
  134. 	SPI_ReadWriteOneByte(addr);     //8~0地址
  135.  
  136. 	for(i=0;i<len;i++)
  137. 	{
  138. 		SPI_ReadWriteOneByte(buff[i]);     //8~0地址	
  139. 	}
  140. 	W25Q64_CS=1; //取消选中芯片
  141. 	W25Q64_CheckStat();  //检测芯片忙状态
  142. }
  143.  
  144.  
  145. /*
  146. 函数功能：连续读数据
  147. 函数参数：
  148. u32 addr:读取数据的起始地址
  149. u8 *buff:读取数据存放的缓冲区
  150. u32 len :读取字节的长度
  151. */
  152. void W25Q64_ReadByteData(u32 addr,u8 *buff,u32 len)
  153. {
  154. 	u32 i;
  155. 	W25Q64_CS=0; //选中芯片
  156. 	SPI_ReadWriteOneByte(0x03);     //读数据指令
  157. 	SPI_ReadWriteOneByte(addr>>16); //24~16地址
  158. 	SPI_ReadWriteOneByte(addr>>8);  //16~8地址
  159. 	SPI_ReadWriteOneByte(addr);     //8~0地址
  160. 	for(i=0;i<len;i++)buff[i]=SPI_ReadWriteOneByte(0xFF);
  161. 	W25Q64_CS=1; //取消选中芯片
  162. }
  163.  
  164.  
  165. /*
  166. 函数功能：擦除一个扇区
  167. 函数参数：
  168. u32 addr:擦除扇区的地址范围
  169. */
  170. void W25Q64_ClearSector(u32 addr)
  171. {
  172. 	W25Q64_Enabled();  						//写使能
  173. 	W25Q64_CS=0; //选中芯片
  174. 	SPI_ReadWriteOneByte(0x20);     //扇区擦除指令
  175. 	SPI_ReadWriteOneByte(addr>>16); //24~16地址
  176. 	SPI_ReadWriteOneByte(addr>>8);  //16~8地址
  177. 	SPI_ReadWriteOneByte(addr);     //8~0地址
  178. 	W25Q64_CS=1; 				//取消选中芯片
  179. 	W25Q64_CheckStat();  //检测芯片忙状态
  180. }
  181.  
  182. /*
  183. 函数功能：写使能
  184. */
  185. void W25Q64_Enabled(void)
  186. {
  187. 	W25Q64_CS=0; //选中芯片
  188. 	SPI_ReadWriteOneByte(0x06);     //写使能
  189. 	W25Q64_CS=1; //取消选中芯片
  190. }
  191.  
  192.  
  193. /*
  194. 函数功能：指定位置写入指定个数的数据，不考虑擦除问题
  195. 注意事项：W25Q64只能将1写为，不能将0写为1。
  196. 函数参数：
  197. u32 addr---写入数据的起始地址
  198. u8 *buff---写入的数据
  199. u32 len---长度
  200. */
  201. void W25Q64_WriteByteDataNoCheck(u32 addr,u8 *buff,u32 len)
  202. {
  203. 	u32 page_remain=256-addr%256; //计算当前页还可以写下多少数据
  204. 	if(len<=page_remain) //如果当前写入的字节长度小于剩余的长度
  205. 	{
  206. 		page_remain=len;
  207. 	}
  208. 	while(1)
  209. 	{
  210. 		W25Q64_PageWrite(addr,buff,page_remain);
  211. 		if(page_remain==len)break; //表明数据已经写入完毕
  212. 		buff+=page_remain; //buff向后偏移地址
  213. 		addr+=page_remain; //起始地址向后偏移
  214. 		len-=page_remain;  //减去已经写入的字节数
  215. 		if(len>256)page_remain=256;  //如果大于一页，每次就直接写256字节
  216. 		else page_remain=len;
  217. 	}
  218. }
  219.  
  220.  
  221. /*
  222. 函数功能：指定位置写入指定个数的数据，考虑擦除问题，完善代码
  223. 函数参数：
  224. u32 addr---写入数据的起始地址
  225. u8 *buff---写入的数据
  226. u32 len---长度
  227. 说明：擦除的最小单位扇区，4096字节
  228. */
  229. static u8 W25Q64_READ_WRITE_CHECK_BUFF[4096];
  230. void W25Q64_WriteByteData(u32 addr,u8 *buff,u32 len)
  231. {
  232.     u32 i;
  233.     u32 len_w;
  234.     u32 sector_addr; //存放扇区的地址
  235.     u32 sector_move; //扇区向后偏移的地址
  236.     u32 sector_size; //扇区大小。（剩余的空间大小）
  237.     u8 *p=W25Q64_READ_WRITE_CHECK_BUFF;//存放指针
  238.     sector_addr=addr/4096; //传入的地址是处于第几个扇区
  239.     sector_move=addr%4096; //计算传入的地址存于当前的扇区的偏移量位置
  240.     sector_size=4096-sector_move; //得到当前扇区剩余的空间
  241.  
  242.     if(len<=sector_size)
  243.     {
  244.             sector_size=len; //判断第一种可能性、一次可以写完
  245.     }
  246.     
  247.     while(1)
  248.     {
  249.         W25Q64_ReadByteData(addr,p,sector_size);	 //读取剩余扇区里的数据
  250.         for(i=0;i<sector_size;i++)
  251.         {
  252.             if(p[i]!=0xFF)break;
  253.         }
  254.         if(i!=sector_size)  //判断是否需要擦除
  255.         {
  256.              W25Q64_ClearSector(sector_addr*4096);
  257.         }
  258. //        for(i=0;i<len;i++)
  259. //        {
  260. //             W25Q64_READ_WRITE_CHECK_BUFF[i]=buff[len_w++]; 
  261.         }
  262. //        W25Q64_WriteByteDataNoCheck(addr,W25Q64_READ_WRITE_CHECK_BUFF,sector_size);
  263.         W25Q64_WriteByteDataNoCheck(addr,buff,sector_size);
  264.         if(sector_size==len)break;
  265.  
  266.         addr+=sector_size; //向后偏移地址
  267.         buff+=sector_size ;//向后偏移
  268.         len-=sector_size;  //减去已经写入的数据
  269.         sector_addr++;     //校验第下个扇区
  270.         if(len>4096)       //表明还可以写一个扇区
  271.         {
  272.                 sector_size=4096;//继续写一个扇区
  273.         }
  274.         else
  275.         {
  276.                 sector_size=len; //剩余的空间可以写完
  277.         }
  278.     }
  279. }

4.2 STM32采用硬件SPI读写W25Q64示例代码

  1. #include "spi.h"
  2.  
  3.  
  4. /*
  5. 函数功能：SPI初始化(模拟SPI)
  6. 硬件连接：
  7. MISO--->PB14
  8. MOSI--->PB15
  9. SCLK--->PB13
  10. */
  11. void SPI_Init(void)
  12. {
  13. 	/*1. 开时钟*/
  14. 	RCC->APB2ENR|=1<<3; //PB
  15.  
  16. 	/*2. 配置GPIO口模式*/
  17. 	GPIOB->CRH&=0x000FFFFF;
  18. 	GPIOB->CRH|=0x38300000;
  19.  
  20. 	/*3. 上拉*/
  21. 	SPI_MOSI=1;
  22. 	SPI_MISO=1;
  23. 	SPI_SCLK=1;
  24. }
  25.  
  26. /*
  27. 函数功能：SPI读写一个字节
  28. */
  29. u8 SPI_ReadWriteOneByte(u8 data_tx)
  30. {
  31. 	u8 data_rx=0; //存放读取的数据
  32. 	u8 i;
  33. 	for(i=0;i<8;i++)
  34. 	{
  35. 		SPI_SCLK=0; //准备发送数据
  36. 		if(data_tx&0x80)SPI_MOSI=1;
  37. 		else SPI_MOSI=0;
  38. 		data_tx<<=1; //依次发送最高位
  39. 		SPI_SCLK=1;  //表示主机数据发送完成，表示从机发送完毕
  40. 		
  41. 		data_rx<<=1; //表示默认接收的是0
  42. 		if(SPI_MISO)data_rx|=0x01;
  43. 	}
  44. 	return data_rx;
  45. }
  46.  
  47. #include "W25Q64.h"
  48.  
  49. /*
  50. 函数功能：W25Q64初始化
  51. 硬件连接：
  52. MOSI--->PB15
  53. MISO--->PB14
  54. SCLK--->PB13
  55. CS----->PB12
  56. */
  57. void W25Q64_Init(void)
  58. {
  59. 	/*1. 开时钟*/
  60. 	RCC->APB2ENR|=1<<3; //PB
  61. 	
  62. 	/*2. 配置GPIO口模式*/
  63. 	GPIOB->CRH&=0xFFF0FFFF;
  64. 	GPIOB->CRH|=0x00030000;
  65. 	
  66. 	W25Q64_CS=1; //未选中芯片
  67. 	SPI_Init();   //SPI初始化
  68. }
  69.  
  70.  
  71. /*
  72. 函数功能：读取芯片的ID号
  73. */
  74. u16 W25Q64_ReadID(void)
  75. {
  76. 	u16 id;
  77. 	/*1. 拉低片选*/
  78. 	W25Q64_CS=0;
  79.  
  80. 	/*2. 发送读取ID的指令*/
  81. 	SPI_ReadWriteOneByte(0x90);
  82.  
  83. 	/*3. 发送24位的地址-0*/
  84. 	SPI_ReadWriteOneByte(0);
  85. 	SPI_ReadWriteOneByte(0);
  86. 	SPI_ReadWriteOneByte(0);
  87.  
  88. 	/*4. 读取芯片的ID*/
  89. 	id=SPI_ReadWriteOneByte(0xFF)<<8;
  90. 	id|=SPI_ReadWriteOneByte(0xFF);
  91.  
  92. 	/*5. 拉高片选*/
  93. 	W25Q64_CS=1;
  94. 	return id;
  95. }
  96.  
  97. /*
  98. 函数功能：检测W25Q64状态
  99. */
  100. void W25Q64_CheckStat(void)
  101. {
  102. 	u8 stat=1;
  103. 	while(stat&1<<0)
  104. 	{
  105. 		W25Q64_CS=0; //选中芯片
  106. 		SPI_ReadWriteOneByte(0x05);      //发送读状态寄存器1指令
  107. 		stat=SPI_ReadWriteOneByte(0xFF); //读取状态
  108. 		W25Q64_CS=1; //取消选中芯片
  109. 	}
  110. }
  111.  
  112.  
  113. /*
  114. 函数功能：页编程
  115. 说    明：一页最多写256个字节。 写数据之前，必须保证空间是0xFF
  116. 函数参数：
  117. u32 addr:页编程起始地址
  118. u8 *buff:写入的数据缓冲区
  119. u16 len :写入的字节长度
  120. */
  121. void W25Q64_PageWrite(u32 addr,u8 *buff,u16 len)
  122. {
  123. 	u16 i;
  124. 	W25Q64_Enabled();  						//写使能
  125. 	W25Q64_CS=0; //选中芯片
  126. 	SPI_ReadWriteOneByte(0x02); //页编程指令
  127. 	SPI_ReadWriteOneByte(addr>>16); //24~16地址
  128. 	SPI_ReadWriteOneByte(addr>>8);  //16~8地址
  129. 	SPI_ReadWriteOneByte(addr);     //8~0地址
  130.  
  131. 	for(i=0;i<len;i++)
  132. 	{
  133. 		SPI_ReadWriteOneByte(buff[i]);     //8~0地址	
  134. 	}
  135. 	W25Q64_CS=1; //取消选中芯片
  136. 	W25Q64_CheckStat();  //检测芯片忙状态
  137. }
  138.  
  139.  
  140. /*
  141. 函数功能：连续读数据
  142. 函数参数：
  143. u32 addr:读取数据的起始地址
  144. u8 *buff:读取数据存放的缓冲区
  145. u32 len :读取字节的长度
  146. */
  147. void W25Q64_ReadByteData(u32 addr,u8 *buff,u32 len)
  148. {
  149. 	u32 i;
  150. 	W25Q64_CS=0; //选中芯片
  151. 	SPI_ReadWriteOneByte(0x03);     //读数据指令
  152. 	SPI_ReadWriteOneByte(addr>>16); //24~16地址
  153. 	SPI_ReadWriteOneByte(addr>>8);  //16~8地址
  154. 	SPI_ReadWriteOneByte(addr);     //8~0地址
  155. 	for(i=0;i<len;i++)buff[i]=SPI_ReadWriteOneByte(0xFF);
  156. 	W25Q64_CS=1; //取消选中芯片
  157. }
  158.  
  159.  
  160. /*
  161. 函数功能：擦除一个扇区
  162. 函数参数：
  163. 				u32 addr:擦除扇区的地址范围
  164. */
  165. void W25Q64_ClearSector(u32 addr)
  166. {
  167. 	W25Q64_Enabled();  						//写使能
  168. 	W25Q64_CS=0; //选中芯片
  169. 	SPI_ReadWriteOneByte(0x20);     //扇区擦除指令
  170. 	SPI_ReadWriteOneByte(addr>>16); //24~16地址
  171. 	SPI_ReadWriteOneByte(addr>>8);  //16~8地址
  172. 	SPI_ReadWriteOneByte(addr);     //8~0地址
  173. 	W25Q64_CS=1; 				//取消选中芯片
  174. 	W25Q64_CheckStat();  //检测芯片忙状态
  175. }
  176.  
  177. /*
  178. 函数功能：写使能
  179. */
  180. void W25Q64_Enabled(void)
  181. {
  182. 	W25Q64_CS=0; //选中芯片
  183. 	SPI_ReadWriteOneByte(0x06);     //写使能
  184. 	W25Q64_CS=1; //取消选中芯片
  185. }
  186.  
  187.  
  188. /*
  189. 函数功能：指定位置写入指定个数的数据，不考虑擦除问题
  190. 注意事项：W25Q64只能将1写为，不能将0写为1。
  191. 函数参数：
  192. u32 addr---写入数据的起始地址
  193. u8 *buff---写入的数据
  194. u32 len---长度
  195. */
  196. void W25Q64_WriteByteDataNoCheck(u32 addr,u8 *buff,u32 len)
  197. {
  198. 	u32 page_remain=256-addr%256; //计算当前页还可以写下多少数据
  199. 	if(len<=page_remain) //如果当前写入的字节长度小于剩余的长度
  200. 	{
  201. 		page_remain=len;
  202. 	}
  203. 	while(1)
  204. 	{
  205. 		W25Q64_PageWrite(addr,buff,page_remain);
  206. 		if(page_remain==len)break; //表明数据已经写入完毕
  207. 		buff+=page_remain; //buff向后偏移地址
  208. 		addr+=page_remain; //起始地址向后偏移
  209. 		len-=page_remain;  //减去已经写入的字节数
  210. 		if(len>256)page_remain=256;  //如果大于一页，每次就直接写256字节
  211. 		else page_remain=len;
  212. 	}
  213. }
  214.  
  215.  
  216. /*
  217. 函数功能：指定位置写入指定个数的数据，考虑擦除问题，完善代码
  218. 函数参数：
  219. u32 addr---写入数据的起始地址
  220. u8 *buff---写入的数据
  221. u32 len---长度
  222. 说明：擦除的最小单位扇区，4096字节
  223. */
  224. static u8 W25Q64_READ_WRITE_CHECK_BUFF[4096];
  225. void W25Q64_WriteByteData(u32 addr,u8 *buff,u32 len)
  226. {
  227. 	u32 i;
  228. 	u32 sector_addr; //存放扇区的地址
  229. 	u32 sector_move; //扇区向后偏移的地址
  230. 	u32 sector_size; //扇区大小。（剩余的空间大小）
  231. 	u8 *p=W25Q64_READ_WRITE_CHECK_BUFF;//存放指针
  232. 	sector_addr=addr/4096; //传入的地址是处于第几个扇区
  233. 	sector_move=addr%4096; //计算传入的地址存于当前的扇区的偏移量位置
  234. 	sector_size=4096-sector_move; //得到当前扇区剩余的空间
  235.  
  236. 	if(len<=sector_size)
  237. 	{
  238. 		sector_size=len; //判断第一种可能性、一次可以写完
  239. 	}
  240.  
  241. 	while(1)
  242. 	{
  243. 		W25Q64_ReadByteData(addr,p,sector_size);	 //读取剩余扇区里的数据
  244. 		for(i=0;i<sector_size;i++)
  245. 		{
  246. 			if(p[i]!=0xFF)break;
  247. 		}
  248. 		if(i!=sector_size)  //判断是否需要擦除
  249. 		{
  250. 			W25Q64_ClearSector(sector_addr*4096);
  251. 		}
  252. 		W25Q64_WriteByteDataNoCheck(addr,buff,sector_size);
  253. 		if(sector_size==len)break;
  254.  
  255. 		addr+=sector_size; //向后偏移地址
  256. 		buff+=sector_size ;//向后偏移
  257. 		len-=sector_size;  //减去已经写入的数据
  258. 		sector_addr++;     //校验第下个扇区
  259. 		if(len>4096)       //表明还可以写一个扇区
  260. 		{
  261. 			sector_size=4096;//继续写一个扇区
  262. 		}
  263. 		else
  264. 		{
  265. 			sector_size=len; //剩余的空间可以写完
  266. 		}
  267. 	}
  268. }

 

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/AllinToyou/article/detail/199883
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号