程序员经验分享-hwhale

源代码：STM32 SPI “DMA”操作W25QXX(16/32/64/128)系列芯片代码详解

2023-11-09

系列文章目录

前言

框架：自己新建库文件夹 取名lib，并按顺序新建spi.c、w25q64.c(根据自己芯片型号)
使用开发板为正点原子mini板演示，开发板上芯片为W25Q64。

一、SPI.h

#ifndef _SPI_H
#define _SPI_H

#include "stm32f10x.h"
#include "system.h"

/*如果不使用SPI_DMA，屏蔽下面define*/
#define	SPI1_DMA

#ifdef	SPI1_DMA
extern u8 SPI_RX_BUFFER[4096];
extern u8 SPI_TX_BUFFER[4096];
#endif

void SPI1_Config(void);			 //初始化SPI1口
void SPI1_SetSpeed(u8 SpeedSet); //设置SPI1速度   
u8 SPI1_ReadWriteByte(u8 TxData);//SPI1总线读写一个字节
	
void SPI1_DMA_Config(void);
void SPI_transmission(u8 *rx_buf,u8 *tx_buf,u16 NumByte);
void SPI_DMA_Read(u8 *rx_buf,u8 *tx_data,u16 NumByte);
void SPI_DMA_Write(u8 *rx_data,u8 *tx_buf,u16 NumByte);
#endif

二、SPI.c

1.SPI配置

#include "SPI.h"
#include "stdio.h"

#define Rx_BFSize  (u8)20
#define Tx_BFSize  (u8)20
#define SPI1_DR_Addr ( (u32)0x4001300C )
u8 Rx_Addr[Rx_BFSize];
u8 Tx_Addr[Tx_BFSize];

/*长度一定要>=数据接收发送大小*/
u8 SPI_RX_BUFFER[4096];	
u8 SPI_TX_BUFFER[4096];

void SPI1_Config(void)
{	 
	u8 count=0;
	GPIO_InitTypeDef	GPIO_InitStructure;
	SPI_InitTypeDef		SPI_InitStructure;
	
	RCC_APB2PeriphClockCmd( RCC_APB2Periph_SPI1 , ENABLE);
	RCC_APB2PeriphClockCmd( RCC_APB2Periph_GPIOA , ENABLE);
	
	GPIO_InitStructure.GPIO_Pin = GPIO_Pin_5 | GPIO_Pin_7;	//SCK,MOSI
	GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;	//复用推挽输出
	GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
	GPIO_Init(GPIOA, &GPIO_InitStructure);	
	//GPIO_Mode_IN_FLOATING
	GPIO_InitStructure.GPIO_Pin = GPIO_Pin_6;	//MISO
	GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING;	
	GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
	GPIO_Init(GPIOA, &GPIO_InitStructure);	
	
	GPIO_InitStructure.GPIO_Pin = GPIO_Pin_4;	//NSS 由软件控制 设置为普通推挽输出
	GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;	
	GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
	GPIO_Init(GPIOA, &GPIO_InitStructure);		//初始化GPIOA
	
	GPIO_SetBits(GPIOA,GPIO_Pin_4|GPIO_Pin_5|GPIO_Pin_6|GPIO_Pin_7);

	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 = 7;	//CRC值计算的多项式				//NSS由	软件控制
	
	SPI_Init(SPI1, &SPI_InitStructure);					//初始化SPI1
#ifdef	SPI1_DMA
	SPI_I2S_DMACmd(SPI1,SPI_I2S_DMAReq_Tx,ENABLE);	//使能DMA Tx通道
	SPI_I2S_DMACmd(SPI1,SPI_I2S_DMAReq_Rx,ENABLE);	//使能DMA Rx通道
#endif
	SPI_Cmd(SPI1, ENABLE);							//使能SPI
	SPI_TX_BUFFER[count++]=0xFF;
	SPI_transmission(SPI_RX_BUFFER, SPI_TX_BUFFER, count);	
	
}   

//SPI1速度设置函数
//SPI速度=fAPB2/分频系数
//@ref SPI_BaudRate_Prescaler:SPI_BaudRatePrescaler_2~SPI_BaudRatePrescaler_256  
//fAPB2时钟一般为84Mhz：
void SPI1_SetSpeed(u8 SPI_BaudRatePrescaler)
{
  assert_param(IS_SPI_BAUDRATE_PRESCALER(SPI_BaudRatePrescaler));//判断有效性
	SPI1->CR1&=0XFFC7;//位3-5清零，用来设置波特率
	SPI1->CR1|=SPI_BaudRatePrescaler;	//设置SPI1速度 
	SPI_Cmd(SPI1,ENABLE); //使能SPI1
}

2.DMA配置

#ifdef SPI1_DMA
void SPI1_DMA_Config(void)
{	
	DMA_InitTypeDef DMA_InitStructure;
	
	RCC_AHBPeriphClockCmd(RCC_AHBPeriph_DMA1,ENABLE);
	
	/*********************  DMA_Rx  *********************/
	DMA_DeInit(DMA1_Channel2);	//DMA1 通道2 SPI1_RX 
	
	DMA_InitStructure.DMA_BufferSize=Rx_BFSize; //传输数据量的大小
	DMA_InitStructure.DMA_DIR=DMA_DIR_PeripheralSRC; 	//DMA传输方向，SRC 外设为数据源
	DMA_InitStructure.DMA_M2M=DMA_M2M_Disable;			//非存储器到存储器传输模式
	DMA_InitStructure.DMA_MemoryBaseAddr=(u32)Rx_Addr;	//数据缓冲区地址
	DMA_InitStructure.DMA_MemoryDataSize=DMA_MemoryDataSize_Byte; //内存数据宽度 数据宽度 8位
	DMA_InitStructure.DMA_MemoryInc=DMA_MemoryInc_Enable;  		//传输数据时候内存地址递增
	DMA_InitStructure.DMA_Mode=DMA_Mode_Normal; 		//内存不循环采集数据
	DMA_InitStructure.DMA_PeripheralBaseAddr=SPI1_DR_Addr;	//SPI1 外设基地址
	DMA_InitStructure.DMA_PeripheralDataSize=DMA_PeripheralDataSize_Byte;  //外设数据宽度 数据宽度 8位
	DMA_InitStructure.DMA_PeripheralInc=DMA_PeripheralInc_Disable; 	//传输地址固定不变  ENABLE时下次发送数据地址递增+1
	DMA_InitStructure.DMA_Priority=DMA_Priority_Medium;		//通道优先级
	
	DMA_Init(DMA1_Channel2,&DMA_InitStructure);		//DMA1 通道2 SPI1_RX 
	
	/*********************  DMA_Tx  *********************/
	DMA_DeInit(DMA1_Channel3);	//DMA1 通道3 SPI1_TX 
	
	DMA_InitStructure.DMA_BufferSize=Tx_BFSize; //传输数据量的大小
	DMA_InitStructure.DMA_DIR=DMA_DIR_PeripheralDST; 	//DMA传输方向，DST 内存作为数据源
	DMA_InitStructure.DMA_M2M=DMA_M2M_Disable;			//非存储器到存储器传输模式
	DMA_InitStructure.DMA_MemoryBaseAddr=(u32)Tx_Addr;	//数据缓冲区地址
	DMA_InitStructure.DMA_MemoryDataSize=DMA_MemoryDataSize_Byte; //内存数据宽度 数据宽度 8位
	DMA_InitStructure.DMA_MemoryInc=DMA_MemoryInc_Enable;  		//传输数据时候内存地址递增
	DMA_InitStructure.DMA_Mode=DMA_Mode_Normal; 		//内存不循环采集数据
	DMA_InitStructure.DMA_PeripheralBaseAddr=SPI1_DR_Addr;	//SPI1 外设基地址
	DMA_InitStructure.DMA_PeripheralDataSize=DMA_PeripheralDataSize_Byte;  //外设数据宽度 数据宽度 8位
	DMA_InitStructure.DMA_PeripheralInc=DMA_PeripheralInc_Disable; 	//传输地址固定不变  ENABLE时下次发送数据地址递增+1
	DMA_InitStructure.DMA_Priority=DMA_Priority_Medium;		//通道优先级
	
	DMA_Init(DMA1_Channel3,&DMA_InitStructure);		//DMA1 通道2 SPI1_RX 
}

void SPI_transmission(u8 *rx_buf,u8 *tx_buf,u16 NumByte)
{
//	DMA_Cmd(DMA1_Channel2,DISABLE);		//关闭DMA
//	DMA_Cmd(DMA1_Channel3,DISABLE);
	
	DMA_SetCurrDataCounter(DMA1_Channel2,NumByte);		//设定通道内存宽度
	DMA_SetCurrDataCounter(DMA1_Channel3,NumByte);
	
	DMA1_Channel2->CCR |= (1<<7);			//打开地址自增
	DMA1_Channel3->CCR |= (1<<7);
	
	DMA1_Channel2->CMAR =(u32)rx_buf;
	DMA1_Channel3->CMAR =(u32)tx_buf;
	
	SPI1->DR;		//清空SPI DR寄存器
	
	while((SPI1->SR&1<<1)==0);	//等待清除
	
	DMA_Cmd(DMA1_Channel2,ENABLE);	//开启DMA
	DMA_Cmd(DMA1_Channel3,ENABLE);
	
	while( DMA_GetFlagStatus(DMA1_FLAG_TC3) == RESET);	//等待传输完成
	while( DMA_GetFlagStatus(DMA1_FLAG_TC2) == RESET);
	
	DMA_Cmd(DMA1_Channel2,DISABLE);		//关闭DMA
	DMA_Cmd(DMA1_Channel3,DISABLE);
	
	DMA_ClearFlag(DMA1_FLAG_TC3);		//清空传输完成flag
	DMA_ClearFlag(DMA1_FLAG_TC2);
}
	
void SPI_DMA_Read(u8 *rx_buf,u8 *tx_data,u16 NumByte)
{
//	DMA_Cmd(DMA1_Channel2,DISABLE);
//	DMA_Cmd(DMA1_Channel3,DISABLE);
	
	DMA_SetCurrDataCounter(DMA1_Channel2,NumByte);
	DMA_SetCurrDataCounter(DMA1_Channel3,NumByte);
		
	DMA1_Channel3->CCR &= ~(1<<7);
	
	DMA1_Channel2->CMAR =(u32)rx_buf;
	DMA1_Channel3->CMAR =(u32)tx_data;
	
	SPI1->DR;
	
	while((SPI1->SR&1<<1)==0);
	
	DMA_Cmd(DMA1_Channel2,ENABLE);
	DMA_Cmd(DMA1_Channel3,ENABLE);
	
	while( DMA_GetFlagStatus(DMA1_FLAG_TC3) == RESET);
	while( DMA_GetFlagStatus(DMA1_FLAG_TC2) == RESET);
	
	DMA_Cmd(DMA1_Channel2,DISABLE);
	DMA_Cmd(DMA1_Channel3,DISABLE);
	
	DMA_ClearFlag(DMA1_FLAG_TC3);
	DMA_ClearFlag(DMA1_FLAG_TC2);
}

void SPI_DMA_Write(u8 *rx_data,u8 *tx_buf,u16 NumByte)
{
//	DMA_Cmd(DMA1_Channel2,DISABLE);
//	DMA_Cmd(DMA1_Channel3,DISABLE);
	
	DMA_SetCurrDataCounter(DMA1_Channel2,NumByte);
	DMA_SetCurrDataCounter(DMA1_Channel3,NumByte);
	
	DMA1_Channel2->CCR &= ~(1<<7);	
	
	DMA1_Channel2->CMAR =(u32)rx_data;
	DMA1_Channel3->CMAR =(u32)tx_buf;
	
	SPI1->DR;
	
	while((SPI1->SR&1<<1)==0);
	
	DMA_Cmd(DMA1_Channel2,ENABLE);
	DMA_Cmd(DMA1_Channel3,ENABLE);
	
	while( DMA_GetFlagStatus(DMA1_FLAG_TC3) == RESET);
	while( DMA_GetFlagStatus(DMA1_FLAG_TC2) == RESET);
	
	DMA_Cmd(DMA1_Channel2,DISABLE);
	DMA_Cmd(DMA1_Channel3,DISABLE);
	
	DMA_ClearFlag(DMA1_FLAG_TC3);
	DMA_ClearFlag(DMA1_FLAG_TC2);
}
#else
	u8 SPI1_ReadWriteByte(u8 TxData)
	{
		while((SPI1->SR&1<<1)==0);
		
		SPI1->DR=TxData;
		
		while((SPI1->SR&1<<0)==0);
		
		return SPI1->DR;
	}
#endif

3.w25q64.c

#include "W25QXX.h"

void W25QXX_Config(void)
{ 	
	W25QXX_CS=1;			//SPI FLASH不选中
	SPI1_DMA_Config();
	SPI1_Config();		   			//初始化SPI
	SPI1_SetSpeed(SPI_BaudRatePrescaler_2);		//设置为42M时钟,高速模式 
#ifdef W25Q256	
	u8 count=0;
	
	W25QXX_CS=0; 
	SPI_TX_BUFFER[count++]=W25X_Entry4ByteMode;
	SPI_transmission(SPI_RX_BUFFER, SPI_TX_BUFFER, count);
    W25QXX_CS=1;
#endif
}  
	
u8 W25QXX_ReadSR(void)   
{  
	u8 byte=0;  
	u8 count=0;
	
	W25QXX_CS=0;                            //使能器件 
	SPI_TX_BUFFER[count++]=W25X_ReadStatusReg;
	SPI_TX_BUFFER[count++]=0xFF;
	SPI_DMA_Write(&byte,SPI_TX_BUFFER,count);	
	W25QXX_CS=1;	//取消片选  
	return byte;   
} 

u8 W25QXX_ReadSR_2(void)   
{  
	u8 byte=0;  
	u8 count=0;
	
	W25QXX_CS=0;                            //使能器件 
	SPI_TX_BUFFER[count++]=W25X_ReadStatusReg_2;
	SPI_TX_BUFFER[count++]=0xFF;
	SPI_DMA_Write(&byte,SPI_TX_BUFFER,count);	
	W25QXX_CS=1;	//取消片选  
	return byte;   
} 

u8 W25QXX_ReadSR_3(void)   
{  
	u8 byte=0;  
	u8 count=0;
	
	W25QXX_CS=0;                            //使能器件 
	SPI_TX_BUFFER[count++]=W25X_ReadStatusReg_3;
	SPI_TX_BUFFER[count++]=0xFF;
	SPI_DMA_Write(&byte,SPI_TX_BUFFER,count);	
	W25QXX_CS=1;	//取消片选  
	return byte;   
} 

//写W25QXX状态寄存器
//只有SPR,TB,BP2,BP1,BP0(bit 7,5,4,3,2)可以写!!!
void W25QXX_Write_SR(u8 sr)   
{   
	u8 count=0;
	
	W25QXX_CS=0;                            //使能器件   
	SPI_TX_BUFFER[count++]=W25X_WriteStatusReg;
	SPI_TX_BUFFER[count++]=sr;
	SPI_transmission(SPI_RX_BUFFER, SPI_TX_BUFFER, count); 
	W25QXX_CS=1;                            //取消片选     	      
}   

//W25QXX写使能	
//将WEL置位   
void W25QXX_Write_Enable(void)   
{
	u8 count=0;
	
	W25QXX_CS=0;                            //使能器件 
	SPI_TX_BUFFER[count++]=W25X_WriteEnable;
	SPI_transmission(SPI_RX_BUFFER, SPI_TX_BUFFER, count);
	W25QXX_CS=1;                            //取消片选     	      
} 
//W25QXX写禁止	
//将WEL清零  
void W25QXX_Write_Disable(void)   
{  
	u8 count=0;
	
	W25QXX_CS=0;                            //使能器件   
	SPI_TX_BUFFER[count++]=W25X_WriteDisable;
	SPI_transmission(SPI_RX_BUFFER, SPI_TX_BUFFER, count);   
	W25QXX_CS=1;                            //取消片选     	      
} 		
//读取芯片ID
//返回值如下:				   
//0XEF13,表示芯片型号为W25Q80  
//0XEF14,表示芯片型号为W25Q16    
//0XEF15,表示芯片型号为W25Q32  
//0XEF16,表示芯片型号为W25Q64 
//0XEF17,表示芯片型号为W25Q128 	  
u16 W25QXX_ReadID(void)
{
	u8 count = 0;
	u16 Temp = 0;
	
	W25QXX_CS=0;				    
	SPI_TX_BUFFER[count++]=W25X_ManufactDeviceID;
	SPI_TX_BUFFER[count++]=0x00;
	SPI_TX_BUFFER[count++]=0x00;
	SPI_TX_BUFFER[count++]=0x00;
	SPI_TX_BUFFER[count++]=0xFF;
	SPI_TX_BUFFER[count++]=0xFF;
	SPI_transmission(SPI_RX_BUFFER, SPI_TX_BUFFER, count);
	Temp = SPI_RX_BUFFER[4]<<8 | SPI_RX_BUFFER[5];  	 
	W25QXX_CS=1;				    
	return Temp;
} 

//读取SPI FLASH  
//在指定地址开始读取指定长度的数据
//pBuffer:数据存储区
//ReadAddr:开始读取的地址(24bit)
//NumByteToRead:要读取的字节数(最大65535)
void W25QXX_Read(u8* pBuffer,u32 ReadAddr,u16 NumByteToRead)   
{ 
	u8 count=0;
	u8 temp=0xFF; 
	
	W25QXX_CS=0;                            //使能器件 
	SPI_TX_BUFFER[count++]=W25X_ReadData;
#ifdef W25Q256
	SPI_TX_BUFFER[count++]=(u8)((ReadAddr)>>24);
#endif
	SPI_TX_BUFFER[count++]=(u8)((ReadAddr)>>16);
	SPI_TX_BUFFER[count++]=(u8)((ReadAddr)>>8);
	SPI_TX_BUFFER[count++]=(u8)ReadAddr;	  
	SPI_transmission(SPI_RX_BUFFER, SPI_TX_BUFFER, count);
	SPI_DMA_Read(pBuffer,&temp,NumByteToRead);
	W25QXX_CS=1;  				    	      
} 

//SPI在一页(0~65535)内写入少于256个字节的数据
//在指定地址开始写入最大256字节的数据
//pBuffer:数据存储区
//WriteAddr:开始写入的地址(24bit)
//NumByteToWrite:要写入的字节数(最大256),该数不应该超过该页的剩余字节数!!!	 
void W25QXX_Write_Page(u8* pBuffer,u32 WriteAddr,u16 NumByteToWrite)
{
 	u8 count=0;
	u8 temp=0; 
	
    W25QXX_Write_Enable();                  //SET WEL 
	W25QXX_CS=0;                            //使能器件 
	SPI_TX_BUFFER[count++]=W25X_PageProgram;
#ifdef W25Q256
	SPI_TX_BUFFER[count++]=(u8)((WriteAddr)>>24);
#endif
	SPI_TX_BUFFER[count++]=(u8)((WriteAddr)>>16);
	SPI_TX_BUFFER[count++]=(u8)((WriteAddr)>>8);
	SPI_TX_BUFFER[count++]=(u8)WriteAddr;
	SPI_transmission(SPI_RX_BUFFER, SPI_TX_BUFFER, count);
	SPI_DMA_Write(&temp,pBuffer,NumByteToWrite);	
	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;//扇区剩余空间大小   
 	if(NumByteToWrite<=secremain)secremain=NumByteToWrite;	//不大于剩余空间
	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)   
{          
	u8 count=0;
	u8 temp=0; 
	
    W25QXX_Write_Enable();                  //SET WEL 
    W25QXX_Wait_Busy();   
  	W25QXX_CS=0;	//使能器件   
	SPI_TX_BUFFER[count++]=W25X_ChipErase;
	SPI_DMA_Write(&temp,SPI_TX_BUFFER,count);
	W25QXX_CS=1;                            //取消片选     	      
	W25QXX_Wait_Busy();   				   //等待芯片擦除结束
}  

//擦除一个扇区
//Dst_Addr:扇区地址 根据实际容量设置
//擦除一个山区的最少时间:150ms
void W25QXX_Erase_Sector(u32 Dst_Addr)   
{  
	u8 count=0;
	u8 temp=0;
 	
 	Dst_Addr*=4096;
    W25QXX_Write_Enable();                  //SET WEL 	 
    W25QXX_Wait_Busy();   
  	W25QXX_CS=0; 	//使能器件  	
	SPI_TX_BUFFER[count++]=W25X_SectorErase;
#ifdef W25Q256
	SPI_TX_BUFFER[count++]=(u8)((Dst_Addr)>>24);
#endif
	SPI_TX_BUFFER[count++]=(u8)((Dst_Addr)>>16);
	SPI_TX_BUFFER[count++]=(u8)((Dst_Addr)>>8);
	SPI_TX_BUFFER[count++]=(u8)Dst_Addr;
	SPI_DMA_Write(&temp,SPI_TX_BUFFER,count);
	W25QXX_CS=1;                            //取消片选     	      
    W25QXX_Wait_Busy();   				   //等待擦除完成
} 

//等待空闲
void W25QXX_Wait_Busy(void)   
{   
	while((W25QXX_ReadSR()&0x01)==0x01);	// 等待BUSY位清空
}

//进入掉电模式
void W25QXX_PowerDown(void)   
{ 
	u8 count=0;
	u8 temp=0;
	
  	W25QXX_CS=0;                            //使能器件
	SPI_TX_BUFFER[count++]=W25X_PowerDown;
	SPI_DMA_Write(&temp,SPI_TX_BUFFER,count);  
	W25QXX_CS=1;                            //取消片选     	      
    delay_us(3);                               //等待TPD  
} 

唤醒
void W25QXX_WAKEUP(void)   
{  
	u8 count=0;
	u8 temp=0;
	
  	W25QXX_CS=0;                            //使能器件  
	SPI_TX_BUFFER[count++]=W25X_ReleasePowerDown;
	SPI_DMA_Write(&temp,SPI_TX_BUFFER,count); 
	W25QXX_CS=1;                            //取消片选     	      
    delay_us(3);                               //等待TRES1
}

4.w25q64.h

#include "system.h"
#include "SPI.h"
#include "USART.h"
#include "delay.h"


/*如果不是W25Q256，屏蔽下面define*/		
//#define W25Q256


#define W25QXX_CS GAout(4)

#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 
#define W25X_Entry4ByteMode 	0xB7
#define W25X_Exit4ByteMode 		0xE9
#define W25X_ReadStatusReg_2	0x35 
#define W25X_WriteStatusReg_2	0x31 
#define W25X_ReadStatusReg_3	0x15 
#define W25X_WriteStatusReg_3	0x11



void W25QXX_Config(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);				//唤醒
u8 W25QXX_ReadSR_2(void);
void W25QXX_Write_SR_2(u8 sr);
u8 W25QXX_ReadSR_3(void);

#endif

五.main.c

#include "main.h"


const u8 TEXT_Buffer[]={"abcdefg1234567!"};
//const u8 TEXT_Buffer[4096];
#define SIZE sizeof(TEXT_Buffer)
	
int main()
{ 
	
	u8 datatemp[SIZE];
	
	LED_Config();
	USART1_Config(115200);
	W25QXX_Config();
	
    printf("\r\nID:%x\r\n",W25QXX_ReadID());	
	
	printf("SR1:%x\r\n",W25QXX_ReadSR());
	
	printf("SR2:%x\r\n",W25QXX_ReadSR_2());
	
	printf("SR3:%x\r\n",W25QXX_ReadSR_3());
	
    W25QXX_Write((u8*)TEXT_Buffer,0,SIZE);
    delay_ms(200);
	W25QXX_Read(datatemp,0,SIZE);
    printf("fe:%s",datatemp);

	while(1)
	{		
		
	}
}

六.串口打印代码

#include "USART.h"

int fputc(int ch, FILE *f)
{     
	while((USART1->SR&0X40)==0);//循环发送,直到发送完毕   
    USART1->DR = (u8) ch;      
	return ch;
}


void USART1_Config(u32 Baud)
{
	GPIO_InitTypeDef 	GPIO_InitStructure;
	USART_InitTypeDef 	USART_InitStructure;
	NVIC_InitTypeDef 	NVIC_InitStructure;
	
	RCC_APB2PeriphClockCmd( RCC_APB2Periph_USART1 , ENABLE);
	RCC_APB2PeriphClockCmd( RCC_APB2Periph_GPIOA , ENABLE);
	
	GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;
	GPIO_InitStructure.GPIO_Pin = GPIO_Pin_9|GPIO_Pin_10;
	GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
	
	GPIO_Init(GPIOA, &GPIO_InitStructure);		//初始化GPIOA
	
	NVIC_InitStructure.NVIC_IRQChannel = USART1_IRQn;
	NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority=3 ;//抢占优先级3
	NVIC_InitStructure.NVIC_IRQChannelSubPriority = 3;		//子优先级3
	NVIC_InitStructure.NVIC_IRQChannelCmd = DISABLE;			//IRQ通道使能
	
	NVIC_Init(&NVIC_InitStructure);	//根据指定的参数初始化VIC寄存器
	
	USART_InitStructure.USART_BaudRate = Baud;
	USART_InitStructure.USART_HardwareFlowControl = USART_HardwareFlowControl_None;
	USART_InitStructure.USART_Mode = USART_Mode_Rx | USART_Mode_Tx;
	USART_InitStructure.USART_Parity  = USART_Parity_No;
	USART_InitStructure.USART_StopBits =  USART_StopBits_1;
	USART_InitStructure.USART_WordLength = USART_WordLength_8b;
	
	USART_Init(USART1,&USART_InitStructure);
	USART_ITConfig(USART1, USART_IT_RXNE, DISABLE);//开启串口接受中断
	USART_Cmd(USART1,ENABLE);             
	
}


#ifndef _USART_H
#define _USART_H

#include "stm32f10x.h"
#include "system.h"

typedef struct __FILE FILE;

int fputc(int ch, FILE *f);
void USART1_Config(u32 Baud);

#endif

七、输出结果

在这里插入图片描述

本文内容由网友自发贡献，版权归原作者所有，本站不承担相应法律责任。如您发现有涉嫌抄袭侵权的内容，请联系:hwhale#tublm.com(使用前将#替换为@)

STM32

嵌入式

单片机

嵌入式硬件

源代码：STM32 SPI “DMA”操作W25QXX(16/32/64/128)系列芯片代码详解 的相关文章

随机推荐

  • CMS V5.7 SP2漏洞复现（CVE-2018-20129）

    0x00 前置 1 CVE中对该漏洞的描述 在 DedeCMS V5 7 SP2 中发现了一个问题 uploads include dialog select images post php 允许远程攻击者通过双扩展名和修改的 php 子字

  • Nodejs学习之Path模块

    一 介绍 Node js path模块提供了一些用于处理文件路径的方法 引入Path模块 var path require path 二 函数介绍 2 1 path normalize 格式化路径 console log normaliza

  • 常见数据结构

    一 数据结构 1 线性 数组 按顺序存储在内存中 每一个节点都有下标 查询快 数组一般用来存储相同类型的数据 可通过数组名和下标进行数据的访问和更新 数组中元素的存储是按照先后顺序进行的 同时在内存中也是按照这个顺序进行连续存放 数组相邻元

  • rtabmap安装与使用

    参考 ubuntu18 04安装Rtabmap 具体详细步骤 教你手把手运行基于ZED的rtab map ZED入门 利用RTAB MAP做SLAM ubuntu16 04 ROS Kinetic rtabmap 源码 非ros版本 安装运

  • freeswitch四、局域网支持

    在局域网内进行的测试 需要进行ACL的配置 conf autoload configs acl conf xml 中 加入下面配置

  • 搭建属于自己的云测试平台

    最近老大给了一个资料让研究 需要搭建一个平台 把公司所有的测试机集中在一起管理 谁需要用的时候 直接在web页面使用 省去了到处找别人借手机等问题 下面先介绍以下这个平台 STF Smartphone Test Farm 是一个Web应用程

  • python爬虫案例（二）：大学排名

    小菜鸟从一个个案例来练习爬虫 心路是曲折的 555 在爬虫案例 一 中 是用urllib进行的 本案例中应用的是requests库 它会比urllib更加方便 requests是python实现的最简单易用的HTTP库 建议爬虫使用requ

  • JavaScript学习（四）认识DOM

    文章目录 DOM简介 通过ID获取元素 innerHTML 属性 改变 HTML 样式 display属性 DOM简介 DOM Document Object Model 文档对象模型 定义了访问和处理html文档的标准方法 DOM 将HT

  • 《信号与系统》示例1.单位阶跃信号的matlab实现

    1 已知单位阶跃函数 请用matlab实现单位阶跃信号 step1 打开matlab2014a 版本可以自选 step2 输入相应代码 t 1 0 01 5 ft t gt 0 plot t ft grid on plot函数是绘制二维图形

  • Vue项目运行报错：Module build failed (from ./node_modules/babel-loader/lib/index.js)

    报错分析 今天在npm run serve运行Vue项目时 突然报出了一个依赖构建错误 Module build failed from node modules babel loader lib index js 报错原因是babel的版

  • linux三剑客sed之模式空间与保持空间

    pattern space 模式空间 and hold space 保持空间 H h G g x 模式空间 sed处理文本内容行的一个临时缓冲区 模式空间中的内容会主动打印到标准输出 并自动清空模式空间 保持空间 sed处理文本内容行的另一

  • 【Hexo themes】【闪烁之狐 Matery】【简】

    文章目录 1 Down 2 修改Hexo配置文件 3 预览 4 部署更新 Summary Reference 个性化 PS 上午在 Hexo themes找了一些主题 有的太简单 可以配置的功能少 有些太复杂 以up现有能力要调一会才能开通

  • 从JAVA转.NET

    走路 难免要过河 生活 难免要磕碰 最近由于公司业务调整 把我所在的部门 整体搬迁到另外一个部门 业务自然是要从头开始了 这 我也就忍了 反正业务嘛 对大家都是公平的 而且搞软件开发哪能同一个业务做一辈子啊 除了盖茨啊 郁闷的是 技术也要换

  • 前端基础4——jQuery

    文章目录 一 基本了解 1 1 导入jQuery库 1 2 基本语法 1 3 选择器 二 操作HTML 2 1 隐藏和显示元素 2 2 获取与设置内容 2 3 获取 设置和删除属性 2 4 添加元素 2 5 删除元素 2 6 设置CSS样式

  • 在centos7上安装在线vscode

    最近在二开datahub 而datahub比较适合在linux中部署 就打算使用线上开发工具code server 安装方法比较简单 直接执行脚本进行安装 curl fsSL https code server dev install sh

  • C++模板函数-无法解析的外部符号

    在网上 看到有类似的问题 经常是写一个头文件 如test h 里面这样写 ifndef TEST H define TEST H include using namespace std 给指针data分配height width的内存 te

  • C#连接SQL数据库

    一 连接数据库服务器 1 连接SQL服务器 以下面为例 这里我使用的是SQL Server 身份验证 也可使用windows 身份验证 账户信息如下 登录名 sa 密码 mima 输入时自动隐藏 建立好数据库和表 服务器名 HG66 MSS

  • JavaScript应用——手把手教你做一个页面化猜数字游戏

    一听到猜数字游戏 想必大家都不太陌生吧 是的没错 很多人都用C语言或者Java写过猜数字游戏小程序 博主也不例外 之前写过C语言版本的猜数字游戏 感兴趣的同学可以看看C语言版本猜数字游戏 本篇博客主要介绍如何用JavaScript实现一个页

  • Django配置文件介绍

    本文主要讲一下django的settings文件中各个配置的代表的含义 from pathlib import Path 项目根路径 BASE DIR Path file resolve parent parent 密钥 自动生成的 很复杂

  • 源代码：STM32 SPI “DMA”操作W25QXX(16/32/64/128)系列芯片代码详解

    系列文章目录 文章目录 系列文章目录 前言 一 SPI h 二 SPI c 1 SPI配置 2 DMA配置 3 w25q64 c 4 w25q64 h 五 main c 六 串口打印代码 七 输出结果 前言 框架 自己新建库文件夹 取名li

热门标签