ICode9
精准搜索请尝试： 精确搜索
首页
编程语言>
数据库
系统相关
互联网
其他分享
Python
Java
JavaScript
android
PHP
首页 > 其他分享> 文章详细

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

2021-12-24 19:03:48  阅读：366  来源： 互联网

标签：DMA u8 16 BUFFER W25QXX SPI InitStructure 源代码


系列文章目录

文章目录

前言

框架：自己新建库文件夹 取名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

七、输出结果

在这里插入图片描述

标签：DMA,u8,16,BUFFER,W25QXX,SPI,InitStructure,源代码
来源： https://blog.csdn.net/weixin_51218153/article/details/122127625

本站声明： 1. iCode9 技术分享网（下文简称本站）提供的所有内容，仅供技术学习、探讨和分享；
2. 关于本站的所有留言、评论、转载及引用，纯属内容发起人的个人观点，与本站观点和立场无关；
3. 关于本站的所有言论和文字，纯属内容发起人的个人观点，与本站观点和立场无关；
4. 本站文章均是网友提供，不完全保证技术分享内容的完整性、准确性、时效性、风险性和版权归属；如您发现该文章侵犯了您的权益，可联系我们第一时间进行删除；
5. 本站为非盈利性的个人网站，所有内容不会用来进行牟利，也不会利用任何形式的广告来间接获益，纯粹是为了广大技术爱好者提供技术内容和技术思想的分享性交流网站。

关于我们 | 联系我们 | 留言反馈

专注分享技术，共同学习，共同进步。侵权联系[81616952@qq.com]

Copyright (C)ICode9.com, All Rights Reserved.

ICode9版权所有