STM32开发日记011：SPI讲解及W25Q64应用（flash存储）

已于 2023-12-07 00:09:28 修改
阅读量367 收藏 4
点赞数 2
分类专栏： # 固件库开发 文章标签： 性能优化
于 2023-12-07 00:08:10 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/aaaaannnnnn_/article/details/134843966
版权

1.SPI通信

在这里插入图片描述
SPI–硬件通信接口–硬件部分
能够驱使接口通信的协议–软件部分

相关概念：

EEPROM:
EEPROM (Electrically Erasable Programmable read only memory)是指带电可擦可编程只读存储器。是一种掉电后数据不丢失的存储芯片。 EEPROM 可以在电脑上或专用设备上擦除已有信息，重新编程。一般用在即插即用。
RAM和ROM的区别：
在这里插入图片描述
闪存：
在这里插入图片描述

SPI硬件组成:

时钟线：串行时钟线SCK
主机输入从机输出：数据线MISO
主机输出从机输入：数据线MOSI 
片选：从机选择线SSEL（选择从设备）

2.SPI的工作原理：

SPI 是一个环形总线结构，由 ss(cs SSEL)、 sck、 sdi(MISO)、 sdo(MOSI) 构成，其时序其实很简单，主要是在 sck 的控制下，两个双向移位寄存器进行数据交换。
在这里插入图片描述
数据传输过程：
在这里插入图片描述
时钟极性(CPOL):时钟的起始状态
时钟相位(CPHA):配置用于选择两种不同的传输协议之一进行数据传输–决定了哪一个跳变沿开始通信

CPOL=0:串行同步时钟的空闲状态为低电平
CPOL=1:串行同步时钟的空闲状态为高电平
CPHA=0：在串行同步时钟的第一个跳变沿(上升或下降)数据被采样
CPHA=1：在串行同步时钟的第二个跳变沿(上升或下降)数据被采样

SPI的工作方式（4种）：

SPI0:CPOL=0;CPHA=0;
空闲状态：低电平 第一个跳变（由低到高）--上升沿--采样  下降沿--输出
SPI1:CPOL=0;CPHA=1;
空闲状态：低电平 第二个跳变（由高到低）--下降沿--采样  上升沿--输出
SPI2:CPOL=1;CPHA=0;
空闲状态：高电平 第一个跳变（由高到低）--下降沿--采样  上升沿--输出
SPI3:CPOL=1;CPHA=1;
空闲状态：高电平 第二个跳变（由低到高）--上升沿--采样  下降沿--输出

SPI0和SPI3的传输数据的时序是一样的，可以通用
SPI1和SPI2的传输数据的时序是一样的，可以通用

SPI时序

在这里插入图片描述

必须可以分析出四种SPI的通信流程
我们来关注 SCK 的第一个时钟周期，在时钟的前沿采样数据（上升沿，第一个时钟沿），在时钟的后沿输出数据（下降沿，第二个时钟沿）。首先来看主器件，主器件的输出口（MOSI）输出的数据 bit1，在时钟的前沿被从器件采样，那主器件是在何时刻输出 bit1 的呢？ bit1 的输出时刻实际上在 SCK 信号有效以前，比 SCK 的上升沿还要早半个时钟周期。 bit1 的输出时刻与 SSEL 信号没有关系。再来看从器件，主器件的输入口 MISO 同样是在时钟的前沿采样从器件输出的 bit1 的，那从器件又是在何时刻输出 bit1 的呢。从器件是在 SSEL信号有效后，立即输出 bit1，尽管此时 SCK 信号还没有起效。

STM32F103中的SPI应用
在这里插入图片描述在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
主模式中的传输：
在这里插入图片描述

配置SPI为主模式
在这里插入图片描述

我们的单片机是作为主机使用的，因为目前在我们使用的场景中，只有单片机有SPI控制器
在这里插入图片描述

SPI的数据发送和接受请参考串口代码（格式基本一样）：
在这里插入图片描述在这里插入图片描述

USART和SPI的区别：
硬件方面：电器特性不一样 工作频率 数据传输速率
软件方面：传输数据格式，通信的方式
在这里插入图片描述

CRC校验作用（我们目前没有使用）：
在这里插入图片描述

3.硬件原理图部分

在这里插入图片描述
在这里插入图片描述

W25Q16是一款FLASH存储芯片
在这里插入图片描述

PB12（cs）--通用推挽输出
PB13(CLK)--复用推挽
PB14(MISO)--浮空输入
PB15(MOSI)--复用推挽
SPI的工作模式：主模式   数据发送的顺序  数据宽度   波特率  。。。。。

MCU中的SPI2用来驱动flash存储芯片，所以想要使用SPI还需要去搞明白FLASH存储芯片如何工作的（flash的代码，大家不用写）

4.W25Q16存储芯片特性

供电：2.7--3.6V   电流--4mA
页内：256字节
扇区：16个页--4KB
块：16扇区-- 64kB   
w25Q16大小：16M(bit)--2MByte
W25Q16总共有32个块
速率：
– 80MHz clock operation
– 160MHz equivalent Dual SPI
在我们使用FLASH存储芯片的时候，必须先擦除指定的位置：一般都是按照扇区进行擦除
擦出的最小单位---扇区
统一扇区擦除（4K字节）
–块擦除（32K和64K字节）
写操作一般是按照页的大小进行
–编程1到256字节
–超过100000个擦除/写入周期

引脚描述：
在这里插入图片描述
在这里插入图片描述

片选和输入输出：
在这里插入图片描述

写保护：低电平有效
在这里插入图片描述

时钟：
在这里插入图片描述

FLASH存储芯片的指令部分：
在这里插入图片描述
在这里插入图片描述

设备ID格式：
在这里插入图片描述

FLASH存储芯片–W25Q16的驱动
将一下代码复制：
在这里插入图片描述

粘贴替换一下位置内容：
在这里插入图片描述

打开工程：
在这里插入图片描述

我们需要参考的FLASH存储芯片的代码位置，在官方提供的工程如下：
可以将以下文件添加到工程中，然后进行修改，就可使用，主要修改的就是IO口；
在这里插入图片描述

我们使用直接修改过的：
在这里插入图片描述

驱动修改：
在这里插入图片描述

修改片选信号：
在这里插入图片描述

添加以下内容到delay.h

//位带操作,实现51类似的GPIO控制功能
//具体实现思想,参考<<CM3权威指南>>第五章(87页~92页).
//IO口操作宏定义
#define BITBAND(addr, bitnum) ((addr & 0xF0000000)+0x2000000+((addr &0xFFFFF)<<5)+(bitnum<<2)) 
#define MEM_ADDR(addr)  *((volatile unsigned long  *)(addr)) 
#define BIT_ADDR(addr, bitnum)   MEM_ADDR(BITBAND(addr, bitnum)) 
//IO口地址映射
#define GPIOA_ODR_Addr    (GPIOA_BASE+12) //0x4001080C 
#define GPIOB_ODR_Addr    (GPIOB_BASE+12) //0x40010C0C 
#define GPIOC_ODR_Addr    (GPIOC_BASE+12) //0x4001100C 
#define GPIOD_ODR_Addr    (GPIOD_BASE+12) //0x4001140C 
#define GPIOE_ODR_Addr    (GPIOE_BASE+12) //0x4001180C 
#define GPIOF_ODR_Addr    (GPIOF_BASE+12) //0x40011A0C    
#define GPIOG_ODR_Addr    (GPIOG_BASE+12) //0x40011E0C    

#define GPIOA_IDR_Addr    (GPIOA_BASE+8) //0x40010808 
#define GPIOB_IDR_Addr    (GPIOB_BASE+8) //0x40010C08 
#define GPIOC_IDR_Addr    (GPIOC_BASE+8) //0x40011008 
#define GPIOD_IDR_Addr    (GPIOD_BASE+8) //0x40011408 
#define GPIOE_IDR_Addr    (GPIOE_BASE+8) //0x40011808 
#define GPIOF_IDR_Addr    (GPIOF_BASE+8) //0x40011A08 
#define GPIOG_IDR_Addr    (GPIOG_BASE+8) //0x40011E08 
 
//IO口操作,只对单一的IO口!
//确保n的值小于16!
#define PAout(n)   BIT_ADDR(GPIOA_ODR_Addr,n)  //输出 
#define PAin(n)    BIT_ADDR(GPIOA_IDR_Addr,n)  //输入 

#define PBout(n)   BIT_ADDR(GPIOB_ODR_Addr,n)  //输出 
#define PBin(n)    BIT_ADDR(GPIOB_IDR_Addr,n)  //输入 

#define PCout(n)   BIT_ADDR(GPIOC_ODR_Addr,n)  //输出 
#define PCin(n)    BIT_ADDR(GPIOC_IDR_Addr,n)  //输入 

#define PDout(n)   BIT_ADDR(GPIOD_ODR_Addr,n)  //输出 
#define PDin(n)    BIT_ADDR(GPIOD_IDR_Addr,n)  //输入 

#define PEout(n)   BIT_ADDR(GPIOE_ODR_Addr,n)  //输出 
#define PEin(n)    BIT_ADDR(GPIOE_IDR_Addr,n)  //输入

#define PFout(n)   BIT_ADDR(GPIOF_ODR_Addr,n)  //输出 
#define PFin(n)    BIT_ADDR(GPIOF_IDR_Addr,n)  //输入

#define PGout(n)   BIT_ADDR(GPIOG_ODR_Addr,n)  //输出 
#define PGin(n)    BIT_ADDR(GPIOG_IDR_Addr,n)  //输入

修改读写函数的函数名字：
在这里插入图片描述

注释掉速度设置函数：
在这里插入图片描述

地址表示格式：flash地址大小总共是24位

0x031000
00--页内地址       256
0--页的个数
1--扇区个数
03--块个数
第三块第一个扇区第0页起始位置

W25Q16地址范围：
在这里插入图片描述

代码请参考相关工程
spi.c

#include "spi.h"
//	 
//STM32F1
//SPI驱动 代码	   
							  
//
 
//以下是SPI模块的初始化代码，配置成主机模式，访问SD Card/W25Q64/NRF24L01						  
//SPI口初始化
//这里针是对SPI2的初始化



void SPI2_Init(void)
{
 	GPIO_InitTypeDef GPIO_InitStructure;
  SPI_InitTypeDef  SPI_InitStructure;

	RCC_APB2PeriphClockCmd(	RCC_APB2Periph_GPIOB, ENABLE );//PORTB时钟使能 
	RCC_APB1PeriphClockCmd(	RCC_APB1Periph_SPI2,  ENABLE );//SPI2时钟使能 	
 
	GPIO_InitStructure.GPIO_Pin = GPIO_Pin_13 | GPIO_Pin_14 | GPIO_Pin_15;
	GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;  //PB13/14/15复用推挽输出 
	GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
	GPIO_Init(GPIOB, &GPIO_InitStructure);//初始化GPIOB

 	GPIO_SetBits(GPIOB,GPIO_Pin_13|GPIO_Pin_14|GPIO_Pin_15);  //PB13/14/15上拉

	SPI_InitStructure.SPI_Direction = SPI_Direction_2Lines_FullDuplex;  //设置SPI单向或者双向的数据模式:SPI设置为双线双向全双工
	SPI_InitStructure.SPI_Mode = SPI_Mode_Master;		//设置SPI工作模式:设置为主SPI
	SPI_InitStructure.SPI_DataSize = SPI_DataSize_8b;		//设置SPI的数据大小:SPI发送接收8位帧结构
	SPI_InitStructure.SPI_CPOL = SPI_CPOL_High;		//串行同步时钟的空闲状态为高电平
	SPI_InitStructure.SPI_CPHA = SPI_CPHA_2Edge;	//串行同步时钟的第二个跳变沿（上升或下降）数据被采样
	SPI_InitStructure.SPI_NSS = SPI_NSS_Soft;		//NSS信号由硬件（NSS管脚）还是软件（使用SSI位）管理:内部NSS信号有SSI位控制
	SPI_InitStructure.SPI_BaudRatePrescaler = SPI_BaudRatePrescaler_256;		//定义波特率预分频的值:波特率预分频值为256
	SPI_InitStructure.SPI_FirstBit = SPI_FirstBit_MSB;	//指定数据传输从MSB位还是LSB位开始:数据传输从MSB位开始
	SPI_InitStructure.SPI_CRCPolynomial = 5;	//CRC值计算的多项式
	SPI_Init(SPI2, &SPI_InitStructure);  //根据SPI_InitStruct中指定的参数初始化外设SPIx寄存器
 
	SPI_Cmd(SPI2, ENABLE); //使能SPI外设
	
	SPI2_ReadWriteByte(0xff);//启动传输		 
 

}   
//SPI 速度设置函数
//SpeedSet:
//SPI_BaudRatePrescaler_2   2分频   
//SPI_BaudRatePrescaler_8   8分频   
//SPI_BaudRatePrescaler_16  16分频  
//SPI_BaudRatePrescaler_256 256分频 
  //此函数不用
void SPI2_SetSpeed(u8 SPI_BaudRatePrescaler)
{
  assert_param(IS_SPI_BAUDRATE_PRESCALER(SPI_BaudRatePrescaler));
	SPI2->CR1&=0XFFC7;
	SPI2->CR1|=SPI_BaudRatePrescaler;	//设置SPI2速度 
	SPI_Cmd(SPI2,ENABLE); 

} 

//SPIx 读写一个字节
//TxData:要写入的字节
//返回值:读取到的字节
u8 SPI2_ReadWriteByte(u8 TxData)
{		
	u8 retry=0;				 	
	while (SPI_I2S_GetFlagStatus(SPI2, SPI_I2S_FLAG_TXE) == RESET) //检查指定的SPI标志位设置与否:发送缓存空标志位
		{
		retry++;
		if(retry>200)return 0;
		}			  
	SPI_I2S_SendData(SPI2, TxData); //通过外设SPIx发送一个数据
	retry=0;

	while (SPI_I2S_GetFlagStatus(SPI2, SPI_I2S_FLAG_RXNE) == RESET) //检查指定的SPI标志位设置与否:接受缓存非空标志位
		{
		retry++;
		if(retry>200)return 0;
		}	  						    
	return SPI_I2S_ReceiveData(SPI2); //返回通过SPIx最近接收的数据					    
}

spi.h

#ifndef __SPI_H
#define __SPI_H
#include "delay.h"
//	 
//STM32F1
//SPI驱动 代码	   
							  
//
			  	    													  
void SPI2_Init(void);			 //初始化SPI口
void SPI2_SetSpeed(u8 SpeedSet); //设置SPI速度   
u8 SPI2_ReadWriteByte(u8 TxData);//SPI总线读写一个字节
		 
#endif

w25qxx.c

#include "w25qxx.h" 
#include "spi.h"
#include "delay.h"
#include "usart1.h"
//	 
//STM32F1
//W25Q16 代码	   
							  
//


u16 W25QXX_TYPE=W25Q16;	//默认是W25Q16

//4Kbytes为一个Sector
//16个扇区为1个Block
//W25Q128
//容量为16M字节,共有128个Block,4096个Sector 
													 
//初始化SPI FLASH的IO口
void W25QXX_Init(void)
{	
  GPIO_InitTypeDef GPIO_InitStructure;
	RCC_APB2PeriphClockCmd(	RCC_APB2Periph_GPIOB, ENABLE );//PORTB时钟使能 

	GPIO_InitStructure.GPIO_Pin = GPIO_Pin_12;  // PB12 推挽 
 	GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;  //推挽输出
	GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
 	GPIO_Init(GPIOB, &GPIO_InitStructure);
 	GPIO_SetBits(GPIOB,GPIO_Pin_12);
 
        W25QXX_CS=1;				//SPI FLASH不选中
	SPI2_Init();		   	//初始化SPI
//	SPI2_SetSpeed(SPI_BaudRatePrescaler_2);//设置为18M时钟,高速模式
	W25QXX_TYPE=W25QXX_ReadID();//读取FLASH ID.  

}  

//读取W25QXX的状态寄存器
//BIT7  6   5   4   3   2   1   0
//SPR   RV  TB BP2 BP1 BP0 WEL BUSY
//SPR:默认0,状态寄存器保护位,配合WP使用
//TB,BP2,BP1,BP0:FLASH区域写保护设置
//WEL:写使能锁定
//BUSY:忙标记位(1,忙;0,空闲)
//默认:0x00
u8 W25QXX_ReadSR(void)   
{  
	u8 byte=0;   
	W25QXX_CS=0;                            //使能器件   
	SPI2_ReadWriteByte(W25X_ReadStatusReg); //发送读取状态寄存器命令    
	byte=SPI2_ReadWriteByte(0Xff);          //读取一个字节  
	W25QXX_CS=1;                            //取消片选     
	return byte;   
} 
//写W25QXX状态寄存器
//只有SPR,TB,BP2,BP1,BP0(bit 7,5,4,3,2)可以写!!!
void W25QXX_Write_SR(u8 sr)   
{   
	W25QXX_CS=0;                            //使能器件   
	SPI2_ReadWriteByte(W25X_WriteStatusReg);//发送写取状态寄存器命令    
	SPI2_ReadWriteByte(sr);               	//写入一个字节  
	W25QXX_CS=1;                            //取消片选     	      
}   
//W25QXX写使能	
//将WEL置位   
void W25QXX_Write_Enable(void)   
{
	W25QXX_CS=0;                          	//使能器件   
    SPI2_ReadWriteByte(W25X_WriteEnable); 	//发送写使能  
	W25QXX_CS=1;                           	//取消片选     	      
} 
//W25QXX写禁止	
//将WEL清零  
void W25QXX_Write_Disable(void)   
{  
	W25QXX_CS=0;                            //使能器件   
    SPI2_ReadWriteByte(W25X_WriteDisable);  //发送写禁止指令    
	W25QXX_CS=1;                            //取消片选     	      
} 		
//读取芯片ID
//返回值如下:				   
//0XEF13,表示芯片型号为W25Q80  
//0XEF14,表示芯片型号为W25Q16    
//0XEF15,表示芯片型号为W25Q32  
//0XEF16,表示芯片型号为W25Q64 
//0XEF17,表示芯片型号为W25Q128 	  
u16 W25QXX_ReadID(void)
{
	u16 Temp = 0;	  
	W25QXX_CS=0;				    
	SPI2_ReadWriteByte(0x90);//发送读取ID命令	    
	SPI2_ReadWriteByte(0x00); 	    
	SPI2_ReadWriteByte(0x00); 	    
	SPI2_ReadWriteByte(0x00); 	 			   
	Temp|=SPI2_ReadWriteByte(0xFF)<<8;  
	Temp|=SPI2_ReadWriteByte(0xFF);	 
	W25QXX_CS=1;				    
	return Temp;
}   		    
//读取SPI FLASH  
//在指定地址开始读取指定长度的数据
//pBuffer:数据存储区
//ReadAddr:开始读取的地址(24bit)
//NumByteToRead:要读取的字节数(最大65535)
void W25QXX_Read(u8* pBuffer,u32 ReadAddr,u16 NumByteToRead)   
{ 
 	u16 i;   										    
	W25QXX_CS=0;                            	//使能器件   
    SPI2_ReadWriteByte(W25X_ReadData);         	//发送读取命令   
    SPI2_ReadWriteByte((u8)((ReadAddr)>>16));  	//发送24bit地址    
    SPI2_ReadWriteByte((u8)((ReadAddr)>>8));   
    SPI2_ReadWriteByte((u8)ReadAddr);   
    for(i=0;i<NumByteToRead;i++)
	{ 
        pBuffer[i]=SPI2_ReadWriteByte(0XFF);   	//循环读数  
    }
	W25QXX_CS=1;  				    	      
}  
//SPI在一页(0~65535)内写入少于256个字节的数据
//在指定地址开始写入最大256字节的数据
//pBuffer:数据存储区
//WriteAddr:开始写入的地址(24bit)
//NumByteToWrite:要写入的字节数(最大256),该数不应该超过该页的剩余字节数!!!	 
void W25QXX_Write_Page(u8* pBuffer,u32 WriteAddr,u16 NumByteToWrite)
{
 	u16 i;  
    W25QXX_Write_Enable();                  	//SET WEL 
	W25QXX_CS=0;                            	//使能器件   
    SPI2_ReadWriteByte(W25X_PageProgram);      	//发送写页命令   
    SPI2_ReadWriteByte((u8)((WriteAddr)>>16)); 	//发送24bit地址    
    SPI2_ReadWriteByte((u8)((WriteAddr)>>8));   
    SPI2_ReadWriteByte((u8)WriteAddr);   
    for(i=0;i<NumByteToWrite;i++)SPI2_ReadWriteByte(pBuffer[i]);//循环写数  
	W25QXX_CS=1;                            	//取消片选 
	W25QXX_Wait_Busy();					   		//等待写入结束
} 
//无检验写SPI FLASH 
//必须确保所写的地址范围内的数据全部为0XFF,否则在非0XFF处写入的数据将失败!
//具有自动换页功能 
//在指定地址开始写入指定长度的数据,但是要确保地址不越界!
//pBuffer:数据存储区
//WriteAddr:开始写入的地址(24bit)
//NumByteToWrite:要写入的字节数(最大65535)
//CHECK OK
void W25QXX_Write_NoCheck(u8* pBuffer,u32 WriteAddr,u16 NumByteToWrite)   
{ 			 		 
	u16 pageremain;	   
	pageremain=256-WriteAddr%256; //单页剩余的字节数		 	    
	if(NumByteToWrite<=pageremain)pageremain=NumByteToWrite;//不大于256个字节
	while(1)
	{	   
		W25QXX_Write_Page(pBuffer,WriteAddr,pageremain);
		if(NumByteToWrite==pageremain)break;//写入结束了
	 	else //NumByteToWrite>pageremain
		{
			pBuffer+=pageremain;
			WriteAddr+=pageremain;	

			NumByteToWrite-=pageremain;			  //减去已经写入了的字节数
			if(NumByteToWrite>256)pageremain=256; //一次可以写入256个字节
			else pageremain=NumByteToWrite; 	  //不够256个字节了
		}
	};	    
} 
//写SPI FLASH  
//在指定地址开始写入指定长度的数据
//该函数带擦除操作!
//pBuffer:数据存储区
//WriteAddr:开始写入的地址(24bit)						
//NumByteToWrite:要写入的字节数(最大65535)   
u8 W25QXX_BUFFER[4096];		 
void W25QXX_Write(u8* pBuffer,u32 WriteAddr,u16 NumByteToWrite)   
{ 
	u32 secpos;
	u16 secoff;
	u16 secremain;	   
 	u16 i;    
	u8 * W25QXX_BUF;	  
   	W25QXX_BUF=W25QXX_BUFFER;	     
 	secpos=WriteAddr/4096;//扇区地址  
	secoff=WriteAddr%4096;//在扇区内的偏移
	secremain=4096-secoff;//扇区剩余空间大小   
 	//printf("ad:%X,nb:%X\r\n",WriteAddr,NumByteToWrite);//测试用
 	if(NumByteToWrite<=secremain)secremain=NumByteToWrite;//不大于4096个字节
	while(1) 
	{	
		W25QXX_Read(W25QXX_BUF,secpos*4096,4096);//读出整个扇区的内容
		for(i=0;i<secremain;i++)//校验数据
		{
			if(W25QXX_BUF[secoff+i]!=0XFF)break;//需要擦除  	  
		}
		if(i<secremain)//需要擦除
		{
			W25QXX_Erase_Sector(secpos);		//擦除这个扇区
			for(i=0;i<secremain;i++)	   		//复制
			{
				W25QXX_BUF[i+secoff]=pBuffer[i];	  
			}
			W25QXX_Write_NoCheck(W25QXX_BUF,secpos*4096,4096);//写入整个扇区  

		}else W25QXX_Write_NoCheck(pBuffer,WriteAddr,secremain);//写已经擦除了的,直接写入扇区剩余区间. 				   
		if(NumByteToWrite==secremain)break;//写入结束了
		else//写入未结束
		{
			secpos++;//扇区地址增1
			secoff=0;//偏移位置为0 	 

		   	pBuffer+=secremain;  				//指针偏移
			WriteAddr+=secremain;				//写地址偏移	   
		   	NumByteToWrite-=secremain;			//字节数递减
			if(NumByteToWrite>4096)secremain=4096;//下一个扇区还是写不完
			else secremain=NumByteToWrite;		//下一个扇区可以写完了
		}	 
	};	 
}
//擦除整个芯片		  
//等待时间超长...
void W25QXX_Erase_Chip(void)   
{                                   
    W25QXX_Write_Enable();                 	 	//SET WEL 
    W25QXX_Wait_Busy();   
  	W25QXX_CS=0;                            	//使能器件   
    SPI2_ReadWriteByte(W25X_ChipErase);        	//发送片擦除命令  
	W25QXX_CS=1;                            	//取消片选     	      
	W25QXX_Wait_Busy();   				   		//等待芯片擦除结束
}   
//擦除一个扇区
//Dst_Addr:扇区地址 根据实际容量设置
//擦除一个山区的最少时间:150ms
void W25QXX_Erase_Sector(u32 Dst_Addr)   
{  
	//监视falsh擦除情况,测试用   
 	printf("fe:%x\r\n",Dst_Addr);	  
 	Dst_Addr*=4096;
    W25QXX_Write_Enable();                  	//SET WEL 	 
    W25QXX_Wait_Busy();   
  	W25QXX_CS=0;                            	//使能器件   
    SPI2_ReadWriteByte(W25X_SectorErase);      	//发送扇区擦除指令 
    SPI2_ReadWriteByte((u8)((Dst_Addr)>>16));  	//发送24bit地址    
    SPI2_ReadWriteByte((u8)((Dst_Addr)>>8));   
    SPI2_ReadWriteByte((u8)Dst_Addr);  
	W25QXX_CS=1;                            	//取消片选     	      
    W25QXX_Wait_Busy();   				   		//等待擦除完成
}  
//等待空闲
void W25QXX_Wait_Busy(void)   
{   
	while((W25QXX_ReadSR()&0x01)==0x01);  		// 等待BUSY位清空
}  
//进入掉电模式
void W25QXX_PowerDown(void)   
{ 
  	W25QXX_CS=0;                           	 	//使能器件   
    SPI2_ReadWriteByte(W25X_PowerDown);        //发送掉电命令  
	W25QXX_CS=1;                            	//取消片选     	      
    delay_us(3);                               //等待TPD  
}   
//唤醒
void W25QXX_WAKEUP(void)   
{  
  	W25QXX_CS=0;                            	//使能器件   
    SPI2_ReadWriteByte(W25X_ReleasePowerDown);	//  send W25X_PowerDown command 0xAB    
	W25QXX_CS=1;                            	//取消片选     	      
    delay_us(3);                            	//等待TRES1
}

w25qxx.h

#ifndef __FLASH_H
#define __FLASH_H			    
#include "delay.h" 
//	 
//STM32F1
//W25Q16 代码	   
						  
//
	  
//W25X系列/Q系列芯片列表	   
//W25Q80  ID  0XEF13
//W25Q16  ID  0XEF14
//W25Q32  ID  0XEF15
//W25Q64  ID  0XEF16	
//W25Q128 ID  0XEF17	
#define W25Q80 	0XEF13 	
#define W25Q16 	0XEF14
#define W25Q32 	0XEF15
#define W25Q64 	0XEF16
#define W25Q128	0XEF17

extern u16 W25QXX_TYPE;					//定义W25QXX芯片型号		   

#define	W25QXX_CS 		PBout(12)  		//W25QXX的片选信号
				 

 
//指令表
#define W25X_WriteEnable		0x06 
#define W25X_WriteDisable		0x04 
#define W25X_ReadStatusReg		0x05 
#define W25X_WriteStatusReg		0x01 
#define W25X_ReadData			0x03 
#define W25X_FastReadData		0x0B 
#define W25X_FastReadDual		0x3B 
#define W25X_PageProgram		0x02 
#define W25X_BlockErase			0xD8 
#define W25X_SectorErase		0x20 
#define W25X_ChipErase			0xC7 
#define W25X_PowerDown			0xB9 
#define W25X_ReleasePowerDown	0xAB 
#define W25X_DeviceID			0xAB 
#define W25X_ManufactDeviceID	0x90 
#define W25X_JedecDeviceID		0x9F 

void W25QXX_Init(void);
u16  W25QXX_ReadID(void);  	    		//读取FLASH ID
u8	 W25QXX_ReadSR(void);        		//读取状态寄存器 
void W25QXX_Write_SR(u8 sr);  			//写状态寄存器
void W25QXX_Write_Enable(void);  		//写使能 
void W25QXX_Write_Disable(void);		//写保护
void W25QXX_Write_NoCheck(u8* pBuffer,u32 WriteAddr,u16 NumByteToWrite);
void W25QXX_Read(u8* pBuffer,u32 ReadAddr,u16 NumByteToRead);   //读取flash
void W25QXX_Write(u8* pBuffer,u32 WriteAddr,u16 NumByteToWrite);//写入flash
void W25QXX_Erase_Chip(void);    	  	//整片擦除
void W25QXX_Erase_Sector(u32 Dst_Addr);	//扇区擦除
void W25QXX_Wait_Busy(void);           	//等待空闲
void W25QXX_PowerDown(void);        	//进入掉电模式
void W25QXX_WAKEUP(void);				//唤醒
#endif

主函数测试：

W25QXX_Init();
printf("flash id %#x\r\n",W25QXX_ReadID());
W25QXX_Write("hello world",0x031000,strlen("hello world"));
W25QXX_Read(datatemp,0x031000,strlen("hello world"));
浅夏漫行
关注
  • 2
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
SPIFS:为w25qXX设计的文件系统，支持w25q32，w25q64，w25q128等
03-11
SPIFS 非常简单的文件系统，核心代码约500行，适用于256个字节/页，4096个字节/放置的存储设备；主要是spi flash器件，例如w25q32，w25q64，w25q128等。实现了基本的文件管理功能，例如创建，写入，追加，重新读取等，对于删除文件采用标记清除的回收方式，删除文件时仅进行进行标记，在后续的文件写入过程中若空间不足，再进行此项工作。本文件系统采用单个文件的布局，并不支持文件夹；使用8 + 4文件名（带有FAT的短文件名只是后缀由3字节变成4字节），文件名8字节与后缀名4字节可连在一起使用。 新的版本在这里 目录说明 src：文件系统实现源码，w25q32.c模拟了一个spi flash器件。 demo：codeblocks演示项目，在gcc-4.8.2 x64（posix）下验证通过。 api说明 使用文件名（文件名），和（扩展名）扩展名创建文件，此时可以重新写入
STM32_Flash字节读写
06-27
实现串口显示stm32，按字节读写Flash的功能，打开下载后，打开串口助手即可看到现象，你值得下载
STM32-SPI通信（W25Q64芯片简介，使用SPI读写W25Q64存储器芯片）
zhuxinmingde的博客
07-30 3095
​  SPI（Serial Peripheral Interface）是由Motorola公司开发的一种通用数据总线四根通信线：SCK（Serial Clock）、MOSI（Master Output Slave Input）、MISO（Master Input Slave Output）、SS（Slave Select）。同步，全双工；支持总线挂载多设备（SPI仅支持一主多从）；在不同情况下，通信线的名称可能有所变化：MOSI：DI（对从机而言）；MISO：DO（对从机而言）；
STM32G474_board_STM32G474开发板
05-16
板载资源 板载DAP下载器，无需连接外部下载器，单板可实现调试 SWD接口引出，可以断开板载DAP下载器，方便外置下载器下载程序 板载PD模块，参考ST官方的PD设计，适用于开发PD接口 QSPI-Flash模块，可以焊接W25Q64/128/80/32等型号Flash 一颗红色LED，一颗绿色LED，一颗用户按键 IO接口全部引出（QSPI、USB、SWD通过功能接口引出）
W25Q64模块以及STM32代码
最新发布
mltzhuo的博客
04-02 990
endif。
STM32开发（八）STM32F103 SPI 通信（W25Q64JVSSIQ ）代码
08-22
通过STM32F103 的SPI功能，实现对W25Q64JVSSIQ （Flash芯片）芯片擦除，读数据，写数据等操作。SPI 通信代码包括 通信时序、相关回调函数、Flash芯片的读写使用函数以及相关接口等。代码测试通过，结合 《stm32专栏》 中的知识点，更加深入了解 SPI 整个通信过程，以及 SPI 时序。
【STM32篇】SPI时序驱动W25Q64（硬件SPI和模拟SPI）
we_long的博客
07-19 5829
使用STM32硬件SPI和模拟SPI驱动W25Q64，实现读取ID，扇区擦除，读写数据等函数。
STM32-W25Q64
2201_75735537的博客
01-15 1511
参考数据手册；存储介质：Nor Flash和（双重SPI和四重SPI，MOSI用于发送,MISO用于与接收，MOSI和MISO同时兼具发送和接收的功能，一个时钟下同时发送俩位数据，四重SPI即一个时钟同时发送四位，WP和HOLD不需要时，可以充当数据传输引脚，四个数据同时收发，类似并行模式（串行为一位一位的发送）
stm32的通信协议SPI(二)：W25Q64模块简介
m0_52854915的博客
02-20 1114
右下角的256字节页缓存区是一个256字节的RAM存储器，数据的读写就是通过这个RAM缓存区来进行的，写入数据先放到缓存区里面，时序结束后芯片再将缓存区的数据复制到Flash里进行永久保存。简单说是因为SPI传输频率高，而Flash的写入需要掉电不丢失，它比较慢，所以弄这个页缓存区来缓存数据，缓存区是RAM，它的速度非常快，可以跟上SPI总线的速度。然后写入的字节不能超过256字节，不能跨页，跨页的地址会回到首地址，导致地址错乱。读取数据也通过页缓存区进行，看一下电路的状态即可，限制少，响应快。
（STM32）W25Q64存储模块
myz1016的博客
06-10 1171
HOLD：芯片正常读写数据时，突然产生中断，然后想用SPI通信线去操控其他器件，这时如果把CS置回高电平，那时序就终止了，但如果你又不想终止总线，又想操作其他器件，这就可以HOLD引脚置低电平，这样芯片就HOLD住了。芯片释放总线，但是芯片时序也不会终止，它会记住当前的状态，当你操作完其他器件时，可以回过来，HOLD置回高电平，然后继续HOLD之前的时序，相当于SPI总线进了一次中断，并且在中断里，还可以用SPI干别的事情。256字节的页缓存区。最小擦除单元，不是字节，是按照存储器的划分，最小是扇区。
stm32学习-8.spi读取W25Q64的ID信息
qq_45417579的博客
01-27 2062
SPI的数据通信其实是数据交换，两个输入输出线和主从设备的数据寄存器构成一个回路，每一次数据位移出和移入通过边缘触发（移入移出分开进行的，完成一位数据交换需要两个边沿1.寻址不是还是要ss发送完整地址信息吗主机有多个ss线，用哪个从设备就控制对应ss口置低位2.没有从机应答，那从机数据没准备好就开始读，不是就冲突了吗有个状态标志位，可以先读这个数据再判断是否进行数据交换3.读取w25q64设备id失败4.oled屏无法正常显示。
教程 14、stm32单片机之W25Q64存储器的读写
06-29
教程 14、stm32单片机之W25Q64存储器的读写教程 14、stm32单片机之W25Q64存储器的读写教程 14、stm32单片机之W25Q64存储器的读写教程 14、stm32单片机之W25Q64存储器的读写教程 14、stm32单片机之W25Q64存储器的读写教程 14、stm32单片机之W25Q64存储器的读写教程 14、stm32单片机之W25Q64存储器的读写教程 14、stm32单片机之W25Q64存储器的读写教程 14、stm32单片机之W25Q64存储器的读写教程 14、stm32单片机之W25Q64存储器的读写教程 14、stm32单片机之W25Q64存储器的读写教程 14、stm32单片机之W25Q64存储器的读写教程 14、stm32单片机之W25Q64存储器的读写教程 14、stm32单片机之W25Q64存储器的读写教程 14、stm32单片机之W25Q64存储器的读写教程 14、stm32单片机之W25Q64存储器的读写教程 14、stm32单片机之W25Q64存储器的读写教程 14、stm32单片机之W25Q64存储器的读写教程 14、stm32单片机
STM32F103标准库开发：W25Q128读写-程序源码
10-14
主MCU是STM32F103C8T6芯片，做SPI总线主控。 外部Flash是W25Q128，做SPI总线从控。 128M(bit)内存----16M字节，有512块。
STM32单片机（STM32F429BI）读写W25Q64串行Flash软件例程源码.zip
01-13
STM32单片机（STM32F429BI）读写W25Q64串行Flash软件例程源码，可以做为你的学习设计参考。 本例程实现串行Flash的读写操作，并测试读写速度。采用STM32内置的SPI硬件接口访问串行Flash。 程序执行结果通过串口1...
STM32 W25Q64驱动程序 W25Q128驱动程序 W25Q32驱动程序
07-21
用于驱动W25Q64，模拟SPI，更改移植方便，标准库
W25Q64Flash芯片STM32操作
08-01
该资源包含STM32F407的SPI寄存器配置及对W25Q64进行读写及擦除所需要的函数。
SPI _FLASH芯片W25Q16配置FATFS
“Struggle”的博客
08-02 8024
一、SPI FLASH芯片能干啥有哪些种类 存放数据。SPI FLASH普遍比EEPROM大得多。所以容量SPI FLASH占优势。但是价格，EEPROM占优势. 1、IIC EEPROM------容量小，采用的是IIC通信协议；用于在掉电时，存系统配置参数，比如屏幕亮度等。常用芯片型号有 AT24C02、FM24C02、CAT24C02等，其常见的封装多为DIP8，SOP8，TSSOP8等； 2、SPI NorFlash------容量略大，采用的是SPI 通信协议；用于存放程序和数据。程序和数据可存放
使用cubemx工具的STM32对外部flash(W25Q64)的简单编程
嵌入一下?的博客
04-24 8806
STM32实现flash超详细，手把手教你写代码
STM32-SPI读写falsh-W25Q64
jx5631833的博客
08-11 1351
W25Q64BV是64Mbit（即8MByte）的flash，通过SPI接口与STM32进行通信。
stm32f103c8t6 硬件spi驱动及w25q64读写
03-29
以下是基于STM32F103C8T6芯片的硬件SPI驱动及W25Q64读写的示例代码，供参考。 SPI驱动： ``` #include "stm32f10x.h" #define SPI_PORT GPIOA #define SPI_SCK GPIO_Pin_5 #define SPI_MOSI GPIO_Pin_7 #define SPI_MISO GPIO_Pin_6 void SPI_Init(void) { GPIO_InitTypeDef GPIO_InitStructure; SPI_InitTypeDef SPI_InitStructure; RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA | RCC_APB2Periph_SPI1, ENABLE); GPIO_InitStructure.GPIO_Pin = SPI_SCK | SPI_MOSI; GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz; GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP; GPIO_Init(SPI_PORT, &GPIO_InitStructure); GPIO_InitStructure.GPIO_Pin = SPI_MISO; GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING; GPIO_Init(SPI_PORT, &GPIO_InitStructure); SPI_InitStructure.SPI_Direction = SPI_Direction_2Lines_FullDuplex; SPI_InitStructure.SPI_Mode = SPI_Mode_Master; SPI_InitStructure.SPI_DataSize = SPI_DataSize_8b; SPI_InitStructure.SPI_CPOL = SPI_CPOL_High; SPI_InitStructure.SPI_CPHA = SPI_CPHA_2Edge; SPI_InitStructure.SPI_NSS = SPI_NSS_Soft; SPI_InitStructure.SPI_BaudRatePrescaler = SPI_BaudRatePrescaler_2; SPI_InitStructure.SPI_FirstBit = SPI_FirstBit_MSB; SPI_InitStructure.SPI_CRCPolynomial = 7; SPI_Init(SPI1, &SPI_InitStructure); SPI_Cmd(SPI1, ENABLE); } uint8_t SPI_SendByte(uint8_t byte) { while (SPI_I2S_GetFlagStatus(SPI1, SPI_I2S_FLAG_TXE) == RESET); SPI_I2S_SendData(SPI1, byte); while (SPI_I2S_GetFlagStatus(SPI1, SPI_I2S_FLAG_RXNE) == RESET); return SPI_I2S_ReceiveData(SPI1); } ``` W25Q64读写： ``` #include "stm32f10x.h" #define W25Q64_CS GPIO_Pin_4 void W25Q64_Init(void) { GPIO_InitTypeDef GPIO_InitStructure; RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA, ENABLE); GPIO_InitStructure.GPIO_Pin = W25Q64_CS; GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz; GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP; GPIO_Init(GPIOA, &GPIO_InitStructure); GPIO_SetBits(GPIOA, W25Q64_CS); } void W25Q64_WriteEnable(void) { GPIO_ResetBits(GPIOA, W25Q64_CS); SPI_SendByte(0x06); GPIO_SetBits(GPIOA, W25Q64_CS); } void W25Q64_ReadStatus(uint8_t *status) { GPIO_ResetBits(GPIOA, W25Q64_CS); SPI_SendByte(0x05); *status = SPI_SendByte(0xFF); GPIO_SetBits(GPIOA, W25Q64_CS); } void W25Q64_WriteStatus(uint8_t status) { GPIO_ResetBits(GPIOA, W25Q64_CS); SPI_SendByte(0x01); SPI_SendByte(status); GPIO_SetBits(GPIOA, W25Q64_CS); } void W25Q64_EraseChip(void) { W25Q64_WriteEnable(); GPIO_ResetBits(GPIOA, W25Q64_CS); SPI_SendByte(0xC7); GPIO_SetBits(GPIOA, W25Q64_CS); } void W25Q64_EraseSector(uint32_t address) { W25Q64_WriteEnable(); GPIO_ResetBits(GPIOA, W25Q64_CS); SPI_SendByte(0x20); SPI_SendByte((address >> 16) & 0xFF); SPI_SendByte((address >> 8) & 0xFF); SPI_SendByte(address & 0xFF); GPIO_SetBits(GPIOA, W25Q64_CS); } void W25Q64_WritePage(uint32_t address, uint8_t *data, uint32_t length) { uint32_t i; W25Q64_WriteEnable(); GPIO_ResetBits(GPIOA, W25Q64_CS); SPI_SendByte(0x02); SPI_SendByte((address >> 16) & 0xFF); SPI_SendByte((address >> 8) & 0xFF); SPI_SendByte(address & 0xFF); for (i = 0; i < length; i++) { SPI_SendByte(data[i]); } GPIO_SetBits(GPIOA, W25Q64_CS); } void W25Q64_ReadData(uint32_t address, uint8_t *data, uint32_t length) { uint32_t i; GPIO_ResetBits(GPIOA, W25Q64_CS); SPI_SendByte(0x03); SPI_SendByte((address >> 16) & 0xFF); SPI_SendByte((address >> 8) & 0xFF); SPI_SendByte(address & 0xFF); for (i = 0; i < length; i++) { data[i] = SPI_SendByte(0xFF); } GPIO_SetBits(GPIOA, W25Q64_CS); } ```

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值