STM32 SPI-DMA读写 SPI Flash （只需改动两个函数） +cube配置 多器件

已于 2024-02-19 18:39:13 修改
阅读量1.1w 收藏 92
点赞数 8
CC 4.0 BY-SA版权
分类专栏： # stm32cube 文章标签： 嵌入式
于 2020-02-20 23:49:35 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_33552551/article/details/104420324
本文介绍如何使用STM32 HAL库通过SPI DMA方式读写W25Q256闪存，包括CUBE配置、代码实现及速度测试。针对SPI上挂载多个设备的情况，优化读写速度，避免长时间占用总线。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

目录

最近在项目中遇到了 通过SPI DMA方式读写W25Q256；
网上许多例程都是直接读取flash，读写会占用比较长的时间 ，如果这个SPI上还挂载了其他SPI 器件，如SPI显示屏，就需要通过开启DMA来提升速度了。
在这里记录一下我的调试过程：

一、CUBE配置

详细CUBE 配置
1.基础设置，我用的是SPI6
oaramerter
2.DMA设置，并设置中断优先级在这里插入图片描述
3.SPI global interrupt不用开启
然后生成代码；

二、代码。

基础代码是正点原子的SPI flash 函数
基本读写函数没有开启DMA，因为只有单字节读写，所以不用开启DMA，后面两个就是DMA读写函数（hal库操作还是贼简单）


static inline void W25Q_SpiDmaStop()
{
    while(__HAL_DMA_GET_FLAG(&hdma_spi2_tx,DMA_FLAG_TCIF3_7)) { asm(""); }

   while (hspiflash.State != HAL_SPI_STATE_READY);
  // W25Q_SpiLcdCsDisable();
}

uint8_t W25Q_SpiReadWriteByte(uint8_t TxData)
{
    uint8_t Rxdata;

    HAL_SPI_TransmitReceive(&hspiflash,&TxData,&Rxdata,1, 1000);

    return Rxdata;                      //返回收到的数据
}
uint16_t W25Q_SpiWriteDMA(uint8_t *pTxData, uint16_t Size)
{
    W25Q_SpiDmaStop();
  //  uint16_t retval =  HAL_SPI_Transmit_DMA(&hspiflash,pTxData,Size);
    uint16_t retval = 	HAL_SPI_TransmitReceive_DMA(&hspiflash,pTxData,pTxData,Size);


    return retval;
}


/* 开始读数据，因为底层DMA缓冲区有限，必须分包读 */
uint16_t W25Q_SpiReadDMA( uint8_t *pRxData, uint32_t Size)
{
    uint16_t rem;
    uint32_t g_spiLen;
    uint8_t g_spiRxBuf[SPI_BUFFER_SIZE];
    uint8_t g_spiTxBuf[SPI_BUFFER_SIZE];
    uint8_t retval = 0;


   for (uint16_t i = 0; i <( Size / SPI_BUFFER_SIZE); i++)
       {
           g_spiLen = SPI_BUFFER_SIZE;

           HAL_SPI_TransmitReceive_DMA(&hspiflash,g_spiTxBuf,g_spiRxBuf,g_spiLen);

           memcpy(pRxData, g_spiRxBuf, SPI_BUFFER_SIZE);
           pRxData += SPI_BUFFER_SIZE;
       }

   rem = Size % SPI_BUFFER_SIZE;    /* 剩余字节 */
   if (rem > 0)
      {
          g_spiLen = rem;

          HAL_SPI_TransmitReceive_DMA(&hspiflash,g_spiTxBuf,g_spiRxBuf,g_spiLen);

          memcpy(pRxData, g_spiRxBuf, rem);
      }





   return retval;
}

基本读写函数写好了，就只需要去改flash的块读写操作函数即可，中间有一个很容易忽略的问题在后面提出

//读取SPI FLASH  
//在指定地址开始读取指定长度的数据
//pBuffer:数据存储区
//ReadAddr:开始读取的地址(24bit)
//NumByteToRead:要读取的字节数(最大65535)
void W25QXX_Read(u8* pBuffer,u32 ReadAddr,u32 NumByteToRead)   
{ 
 	u16 i;   										    
	W25QXX_CS=0;                            //使能器件   
    SPI6_ReadWriteByte(W25X_ReadData);      //发送读取命令
    if(W25QXX_TYPE==W25Q256)                //如果是W25Q256的话地址为4字节的，要发送最高8位
    {
        SPI6_ReadWriteByte((u8)((ReadAddr)>>24));
    }
    SPI6_ReadWriteByte((u8)((ReadAddr)>>16));   //发送24bit地址
    SPI6_ReadWriteByte((u8)((ReadAddr)>>8));
    SPI6_ReadWriteByte((u8)ReadAddr);
#ifdef SPI_USE_DMA
     W25Q_SpiReadDMA(pBuffer,NumByteToRead);
     W25Q_SpiCsDisable();
     W25Q_SpiDmaStop(); //等待写入完成
#else
    for(i=0;i<NumByteToRead;i++)
	{ 
        pBuffer[i]=SPI6_ReadWriteByte(0XFF);    //循环读数
    }
   W25Q_SpiCsDisable();
#endif

}  
//SPI在一页(0~65535)内写入少于256个字节的数据
//在指定地址开始写入最大256字节的数据
//pBuffer:数据存储区
//WriteAddr:开始写入的地址(24bit)
//NumByteToWrite:要写入的字节数(最大256),该数不应该超过该页的剩余字节数!!!	 
void W25QXX_Write_Page(u8* pBuffer,u32 WriteAddr,u16 NumByteToWrite)
{
 	u16 i;  
 	u8* rxBuffer;
    W25QXX_Write_Enable();                  //SET WEL 
	W25Q_SpiCsEnable();                            //使能器件
    SPI6_ReadWriteByte(W25X_PageProgram);   //发送写页命令
    if(W25QXX_TYPE==W25Q256)                //如果是W25Q256的话地址为4字节的，要发送最高8位
    {
        SPI6_ReadWriteByte((u8)((WriteAddr)>>24));
    }
    SPI6_ReadWriteByte((u8)((WriteAddr)>>16)); //发送24bit地址
    SPI6_ReadWriteByte((u8)((WriteAddr)>>8));
    SPI6_ReadWriteByte((u8)WriteAddr);
#ifdef SPI_USE_DMA
    W25Q_SpiWriteDMA(pBuffer,NumByteToWrite);
    W25Q_SpiDmaStop();
    W25Q_SpiCsDisable();                    //取消片选
#else
    for(i=0;i<NumByteToWrite;i++)SPI6_ReadWriteByte(pBuffer[i]);//循环写数
    W25Q_SpiCsDisable();                    //取消片选
#endif

	W25QXX_Wait_Busy();					   //等待写入结束
}

上面通过宏定义区分是否使用DMA，其中需要注意的就是W25Q64
的片选信号在DMA方式时不能马上取消片选；因为SPI6_WriteDMA函数实际只是打开了DMA,数据并没有发送完成。
当然在这里等待写入完成也是个坑，暂时没想到怎么填，如果SPI上只挂载了flash，就不用等了，可以去干其他的事。所以只能在回调函数中去取消片选。
W25QXX_Wait_Busy(); //等待写入结束 在这里插入图片描述

添加回调函数

void HAL_SPI_TxCpltCallback(SPI_HandleTypeDef *hspi)
{
   if(hspi== &hspi6)
   {
       W25QXX_CS=1;
   }

}

void HAL_SPI_RxCpltCallback(SPI_HandleTypeDef *hspi)
{

    if(hspi== &hspi6)
      {
          W25QXX_CS=1;
      }

}

到这里；DMA方式读写flash才算完成配置了。
总结如下：
1. 配置SPI 及对应Tx RX DMA;接收DMA要分包读取，一次性读取大量数据DMA缓存不够
2.改写flash块读写函数；
3.添加回调函数，取消片选； ->3.直接等待DMA传输完成就取消片选
速度测试：
写100K数据用时2s-3s，因为100K数据需要擦除32个扇区，
W25QXX_Erase_Sector扇区擦除命令就占了90ms,所以spi-flash最好不要实时存取数据，在开关机阶段操作存取保存的数据比较好

三、完整代码

w25qxx.c


u8 RX_TEXT_Buffer[24];

uint16_t Text_cpuBuff[24]={0};
void SpiFlash_LoadParam();
//#define SPI_USE_DMA
u16 W25QXX_TYPE=W25Q256;	//默认是W25Q256
#define SPI_BUFFER_SIZE  4096// 4*1024
//4Kbytes为一个Sector
//16个扇区为1个Block
//W25Q256
//容量为32M字节,共有512个Block,8192个Sector 
static void stmFlash_SaveParam();
static void stmFlash_LoadParam();

uint8_t W25Q_SpiReadWriteByte(uint8_t TxData)
{
    uint8_t Rxdata;

    HAL_SPI_TransmitReceive(&hspiflash,&TxData,&Rxdata,1, 1000);

    return Rxdata;                      //返回收到的数据
}
static void W25Q_SpiLcdCsEnable()
{
    UiLcdHy28_SpiLcdCsDisable();
    GPIO_ResetBits(W25Q_CS_PIO, W25Q_CS);
}

void W25Q_SpiLcdCsDisable()
{
    GPIO_SetBits(W25Q_CS_PIO, W25Q_CS);
}


static inline void W25Q_SpiDmaStop()
{
    while(__HAL_DMA_GET_FLAG(&hdma_spi2_tx,DMA_FLAG_TCIF3_7)) { asm(""); }

   while (hspiflash.State != HAL_SPI_STATE_READY);
  // W25Q_SpiLcdCsDisable();
}

uint16_t W25Q_SpiWriteDMA(uint8_t *pTxData, uint16_t Size)
{
    W25Q_SpiDmaStop();
  //  uint16_t retval =  HAL_SPI_Transmit_DMA(&hspiflash,pTxData,Size);
    uint16_t retval = HAL_SPI_TransmitReceive_DMA(&hspiflash,pTxData,pTxData,Size);


    return retval;
}
/* 开始读数据，因为底层DMA缓冲区有限，必须分包读 */
uint16_t W25Q_SpiReadDMA( uint8_t *pRxData, uint32_t Size)
{
    uint16_t rem;
    uint32_t g_spiLen;
    uint8_t g_spiRxBuf[SPI_BUFFER_SIZE];
    uint8_t g_spiTxBuf[SPI_BUFFER_SIZE];
    uint8_t retval = 0;


   for (uint16_t i = 0; i <( Size / SPI_BUFFER_SIZE); i++)
       {
           g_spiLen = SPI_BUFFER_SIZE;

           HAL_SPI_TransmitReceive_DMA(&hspiflash,g_spiTxBuf,g_spiRxBuf,g_spiLen);

           memcpy(pRxData, g_spiRxBuf, SPI_BUFFER_SIZE);
           pRxData += SPI_BUFFER_SIZE;
       }

   rem = Size % SPI_BUFFER_SIZE;    /* 剩余字节 */
   if (rem > 0)
      {
          g_spiLen = rem;

          HAL_SPI_TransmitReceive_DMA(&hspiflash,g_spiTxBuf,g_spiRxBuf,g_spiLen);

          memcpy(pRxData, g_spiRxBuf, rem);
      }





   return retval;
}



//初始化SPI FLASH的IO口
void W25QXX_Init(void)
{ 
#if    USE_CPU_FLASH
    ts.spiflash_present = true;
#else
    u8 temp;
    GPIO_InitTypeDef GPIO_Initure;

    __disable_irq();
    //PF6
    GPIO_Initure.Pin=GPIO_PIN_3;            //PF6
    GPIO_Initure.Mode=GPIO_MODE_OUTPUT_PP;  //推挽输出
    GPIO_Initure.Pull=GPIO_PULLUP;          //上拉
    GPIO_Initure.Speed=GPIO_SPEED_FREQ_HIGH;     //快速
    HAL_GPIO_Init(GPIOG,&GPIO_Initure);     //初始化
    for(uint8_t i=0;i<=3;i++)
    {
        W25Q_SpiLcdCsDisable();		                //SPI FLASH不选中
        W25QXX_TYPE=W25QXX_ReadID();	        //读取FLASH ID.
        if(W25QXX_TYPE==W25Q256)                //SPI FLASH为W25Q256
        {
            temp=W25QXX_ReadSR(3);              //读取状态寄存器3，判断地址模式
            if((temp&0X01)==0)			        //如果不是4字节地址模式,则进入4字节地址模式
            {
                W25Q_SpiLcdCsEnable(); 			        //选中
                W25Q_SpiReadWriteByte(W25X_Enable4ByteAddr);//发送进入4字节地址模式指令
                W25Q_SpiLcdCsDisable();       		        //取消片选
            }
    
            ts.spiflash_present = true;
            break;
        }
        else
        {

            ts.spiflash_present = false;

        }
    }


    __enable_irq();
#endif
}  








//读取W25QXX的状态寄存器，W25QXX一共有3个状态寄存器
//状态寄存器1：
//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
//状态寄存器2：
//BIT7  6   5   4   3   2   1   0
//SUS   CMP LB3 LB2 LB1 (R) QE  SRP1
//状态寄存器3：
//BIT7      6    5    4   3   2   1   0
//HOLD/RST  DRV1 DRV0 (R) (R) WPS ADP ADS
//regno:状态寄存器号，范:1~3
//返回值:状态寄存器值
u8 W25QXX_ReadSR(u8 regno)   
{  
	u8 byte=0,command=0; 
    switch(regno)
    {
        case 1:
            command=W25X_ReadStatusReg1;    //读状态寄存器1指令
            break;
        case 2:
            command=W25X_ReadStatusReg2;    //读状态寄存器2指令
            break;
        case 3:
            command=W25X_ReadStatusReg3;    //读状态寄存器3指令
            break;
        default:
            command=W25X_ReadStatusReg1;    
            break;
    }    
	W25Q_SpiLcdCsEnable();                            //使能器件
	W25Q_SpiReadWriteByte(command);            //发送读取状态寄存器命令
	byte=W25Q_SpiReadWriteByte(0Xff);          //读取一个字节
	W25Q_SpiLcdCsDisable();                            //取消片选
	return byte;   
} 
//写W25QXX状态寄存器
void W25QXX_Write_SR(u8 regno,u8 sr)   
{   
    u8 command=0;
    switch(regno)
    {
        case 1:
            command=W25X_WriteStatusReg1;    //写状态寄存器1指令
            break;
        case 2:
            command=W25X_WriteStatusReg2;    //写状态寄存器2指令
            break;
        case 3:
            command=W25X_WriteStatusReg3;    //写状态寄存器3指令
            break;
        default:
            command=W25X_WriteStatusReg1;    
            break;
    }   
	W25Q_SpiLcdCsEnable();                            //使能器件
	W25Q_SpiReadWriteByte(command);            //发送写取状态寄存器命令
	W25Q_SpiReadWriteByte(sr);                 //写入一个字节
	W25Q_SpiLcdCsDisable();                            //取消片选
}   
//W25QXX写使能	
//将WEL置位   
void W25QXX_Write_Enable(void)   
{
	W25Q_SpiLcdCsEnable();                            //使能器件
    W25Q_SpiReadWriteByte(W25X_WriteEnable);   //发送写使能
	W25Q_SpiLcdCsDisable();                            //取消片选
} 
//W25QXX写禁止	
//将WEL清零  
void W25QXX_Write_Disable(void)   
{  
	W25Q_SpiLcdCsEnable();                            //使能器件
    W25Q_SpiReadWriteByte(W25X_WriteDisable);  //发送写禁止指令
	W25Q_SpiLcdCsDisable();                            //取消片选
} 

//读取芯片ID
//返回值如下:				   
//0XEF13,表示芯片型号为W25Q80  
//0XEF14,表示芯片型号为W25Q16    
//0XEF15,表示芯片型号为W25Q32  
//0XEF16,表示芯片型号为W25Q64 
//0XEF17,表示芯片型号为W25Q128 	  
//0XEF18,表示芯片型号为W25Q256
u16 W25QXX_ReadID(void)
{
	u16 Temp = 0;	  
	W25Q_SpiLcdCsEnable();
	W25Q_SpiReadWriteByte(0x90);//发送读取ID命令
	W25Q_SpiReadWriteByte(0x00);
	W25Q_SpiReadWriteByte(0x00);
	W25Q_SpiReadWriteByte(0x00);
	Temp|=W25Q_SpiReadWriteByte(0xFF)<<8;
	Temp|=W25Q_SpiReadWriteByte(0xFF);
	W25Q_SpiLcdCsDisable();
	return Temp;
}   		    
//读取SPI FLASH  
//在指定地址开始读取指定长度的数据
//pBuffer:数据存储区
//ReadAddr:开始读取的地址(24bit)
//NumByteToRead:要读取的字节数(最大65535)
void W25QXX_Read(u8* pBuffer,u32 ReadAddr,u32 NumByteToRead)
{ 

 	if(NumByteToRead==0||(ReadAddr+NumByteToRead)>EXTERN_FLASH_SIZE)
 	{
 	    return;
 	}

	W25Q_SpiLcdCsEnable();                            //使能器件
    W25Q_SpiReadWriteByte(W25X_ReadData);      //发送读取命令
    if(W25QXX_TYPE==W25Q256)                //如果是W25Q256的话地址为4字节的，要发送最高8位
    {
        W25Q_SpiReadWriteByte((u8)((ReadAddr)>>24));
    }
    W25Q_SpiReadWriteByte((u8)((ReadAddr)>>16));   //发送24bit地址
    W25Q_SpiReadWriteByte((u8)((ReadAddr)>>8));
    W25Q_SpiReadWriteByte((u8)ReadAddr);
#if 0//SPI2_USE_DMA   //由于spi2的接收跟uart7的接收是同一个DMA数据流，所以暂时不能开接收DMA
    W25Q_SpiReadDMA(pBuffer,NumByteToRead);
    W25Q_SpiLcdCsDisable();
    W25Q_SpiDmaStop(); //等待写入完成
#else
    for(uint32_t i=0;i<NumByteToRead;i++)
	{ 
        pBuffer[i]=W25Q_SpiReadWriteByte(0XFF);    //循环读数
    }
    W25Q_SpiLcdCsDisable();
#endif

}  
//SPI在一页(0~65535)内写入少于256个字节的数据
//在指定地址开始写入最大256字节的数据
//pBuffer:数据存储区
//WriteAddr:开始写入的地址(24bit)
//NumByteToWrite:要写入的字节数(最大256),该数不应该超过该页的剩余字节数!!!	 
void W25QXX_Write_Page(u8* pBuffer,u32 WriteAddr,u16 NumByteToWrite)
{

// 	u8* rxBuffer;
    W25QXX_Write_Enable();                  //SET WEL 
	W25Q_SpiLcdCsEnable();                            //使能器件
	//!SPI2_USE_DMA//#ifdef SPI_USE_DMA  //spi写DMA还是能用的
#if USE_SAI_IQ  //由于更换H7后，用DMA写不起作用了 后面测试原因
    u16 i;
    W25Q_SpiReadWriteByte(W25X_PageProgram);   //发送写页命令

    if(W25QXX_TYPE==W25Q256)                //如果是W25Q256的话地址为4字节的，要发送最高8位
    {
        W25Q_SpiReadWriteByte((u8)((WriteAddr)>>24));
    }
    W25Q_SpiReadWriteByte((u8)((WriteAddr)>>16)); //发送24bit地址
    W25Q_SpiReadWriteByte((u8)((WriteAddr)>>8));
    W25Q_SpiReadWriteByte((u8)WriteAddr);

    for(i=0;i<NumByteToWrite;i++)
    {
        W25Q_SpiReadWriteByte(pBuffer[i]);//循环写数
    }
    W25Q_SpiLcdCsDisable();
#else
//    uint8_t buf[5]={0};
//    buf[0] = W25X_PageProgram;
//    if(W25QXX_TYPE==W25Q256)                //如果是W25Q256的话地址为4字节的，要发送最高8位
//     {
//
//         buf[1] = (u8)((WriteAddr)>>24);
//         buf[2] = (u8)((WriteAddr)>>16);
//         buf[3] = (u8)((WriteAddr)>>8);
//         buf[4] = (u8)WriteAddr;
//         W25Q_SpiWriteDMA(buf,5);
//     }
//    else
//    {
//           buf[1] = (u8)((WriteAddr)>>16);
//           buf[2] = (u8)((WriteAddr)>>8);
//           buf[3] = (u8)WriteAddr;
//           W25Q_SpiWriteDMA(buf,4);
//    }
     W25Q_SpiReadWriteByte(W25X_PageProgram);   //发送写页命令

    if(W25QXX_TYPE==W25Q256)                //如果是W25Q256的话地址为4字节的，要发送最高8位
    {
       W25Q_SpiReadWriteByte((u8)((WriteAddr)>>24));
    }
    W25Q_SpiReadWriteByte((u8)((WriteAddr)>>16)); //发送24bit地址
    W25Q_SpiReadWriteByte((u8)((WriteAddr)>>8));
    W25Q_SpiReadWriteByte((u8)WriteAddr);

    W25Q_SpiWriteDMA(pBuffer,NumByteToWrite);
    W25Q_SpiDmaStop();
    W25Q_SpiLcdCsDisable();                    //取消片选

#endif

	W25QXX_Wait_Busy();					   //等待写入结束
} 
u8 W25QXX_BUFFER[4096];
//无检验写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)   

void W25QXX_Write(u8* pBuffer,u32 WriteAddr,u32 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();   
  	W25Q_SpiLcdCsEnable();                            //使能器件
    W25Q_SpiReadWriteByte(W25X_ChipErase);        //发送片擦除命令
	W25Q_SpiLcdCsDisable();                            //取消片选
	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();   
  	W25Q_SpiLcdCsEnable();                            //使能器件
    W25Q_SpiReadWriteByte(W25X_SectorErase);   //发送扇区擦除指令
    if(W25QXX_TYPE==W25Q256)                //如果是W25Q256的话地址为4字节的，要发送最高8位
    {
        W25Q_SpiReadWriteByte((u8)((Dst_Addr)>>24));
    }
    W25Q_SpiReadWriteByte((u8)((Dst_Addr)>>16));  //发送24bit地址
    W25Q_SpiReadWriteByte((u8)((Dst_Addr)>>8));
    W25Q_SpiReadWriteByte((u8)Dst_Addr);
	W25Q_SpiLcdCsDisable();                            //取消片选
    W25QXX_Wait_Busy();   				    //等待擦除完成
}  
//等待空闲
void W25QXX_Wait_Busy(void)   
{   
	while((W25QXX_ReadSR(1)&0x01)==0x01);   // 等待BUSY位清空
}  
//进入掉电模式
void W25QXX_PowerDown(void)   
{ 
  	W25Q_SpiLcdCsEnable();                            //使能器件
    W25Q_SpiReadWriteByte(W25X_PowerDown);     //发送掉电命令
	W25Q_SpiLcdCsDisable();                            //取消片选
    delay_us(3);                            //等待TPD  
}   
//唤醒
void W25QXX_WAKEUP(void)   
{  
  	W25Q_SpiLcdCsEnable();                                //使能器件
    W25Q_SpiReadWriteByte(W25X_ReleasePowerDown);  //  send W25X_PowerDown command 0xAB
	W25Q_SpiLcdCsDisable();                                //取消片选
    delay_us(3);                                //等待TRES1
}

w25qxx.h

#ifndef __W25QXX_H
#define __W25QXX_H
#include "sys.h"
	
#define hspiflash hspi2
//W25X系列/Q系列芯片列表	   
//W25Q80  ID  0XEF13
//W25Q16  ID  0XEF14
//W25Q32  ID  0XEF15
//W25Q64  ID  0XEF16	
//W25Q128 ID  0XEF17	
//W25Q256 ID  0XEF18
#define W25Q80 	0XEF13 	
#define W25Q16 	0XEF14
#define W25Q32 	0XEF15
#define W25Q64 	0XEF16
#define W25Q128	0XEF17
#define W25Q256 0XEF18

extern u16 W25QXX_TYPE;					//定义W25QXX芯片型号		   
#define EXTERN_FLASH_SIZE (32*1024*1024)  //FLASH 大小为32M字节

//最后1M作为设置存储区
#define SPIFLASH_VAR_ADDR_START (31*1024*1024)


//#define SIZE 24

#define	W25QXX_CS 		PIout(2)  		//W25QXX的片选信号
extern u8 TEXT_Buffer[];


////////////////////////////////////////////////////////////////////////////////// 
//指令表
#define W25X_WriteEnable		0x06 
#define W25X_WriteDisable		0x04 
#define W25X_ReadStatusReg1		0x05 
#define W25X_ReadStatusReg2		0x35 
#define W25X_ReadStatusReg3		0x15 
#define W25X_WriteStatusReg1    0x01 
#define W25X_WriteStatusReg2    0x31 
#define W25X_WriteStatusReg3    0x11 
#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_Enable4ByteAddr    0xB7
#define W25X_Exit4ByteAddr      0xE9

void W25QXX_Init(void);
u16  W25QXX_ReadID(void);  	    		//读取FLASH ID
u8 W25QXX_ReadSR(u8 regno);             //读取状态寄存器 
void W25QXX_4ByteAddr_Enable(void);     //使能4字节地址模式
void W25QXX_Write_SR(u8 regno,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,u32 NumByteToRead);   //读取flash
void W25QXX_Write(u8* pBuffer,u32 WriteAddr,u32 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);				//唤醒

void w25q64_text(void);
void W25Q_SpiLcdCsDisable();
uint16_t SpiFlash_UpdateVariable(uint16_t addr, uint16_t value);
uint16_t SpiFlash_ReadVariable(uint16_t addr, uint16_t* value);

void SpiFlash_SaveParam();
void SpiFlash_LoadParam();
void SPIFlash_test(void);
#endif
STM32----SPI+DMA+获取读写外部flash
m0_47216457的博客
06-18 4502
以上就是SPI+DMA读取flash的内容。
STM32F4 SPI RX/TX DMA 读写FLASH数据
sevek82的博客
09-28 6389
STM32 使用DMA读写FLASH数据需要注意以下几点： 1.SPI全双工模式下，无论读写FLASH数据均需要同时使能RX/TX DMA。 2.写数据时回读数据应当丢弃，读数据时应当发送0xff来启动SPI读周期。 3.使用DMA时应当使能DMA Stream，然后再使能SPI DMA请求。   以下为测试代码，为省事，没启动串口提供打印信息，可在读出FLASH数据后通过断点查看数据。...
STM32 SPI DMA驱动外部FLASH，寄存器操作，单发，单收，速度快
03-24
STM32 SPI DMA驱动外部FLASH，寄存器操作，单发，单收，速度快。
【联盛德W806上手笔记】八、SPI及其DMA
乙酸氧铍的博客
01-27 3573
目录高速 SPI 设备控制器库函数函数参数宏应用示例初始化 Windows 10 20H2 HLK-W806-V1.0-KIT WM_SDK_W806_v0.6.0        摘自《W806 芯片设计指导书 V1.0》、《W806 MCU 芯片规格书 V2.0》、《WM_W800_寄存器手册 V2.1》 高速 SPI 设备控制器        兼容通用 SPI 物
STM32 SPI与DMA集成实践教程
最新发布
weixin_30415591的博客
06-25 1123
SPI（Serial Peripheral Interface）是一种常用的串行通信接口，它允许微控制器与其他外围设备进行高速通信。SPI接口的通信速度比传统的串行通信接口快，而且通信方式简单直接。SPI通常用于短距离通信，如传感器数据采集、显示驱动和闪存存储等场景。DMA（Direct Memory Access）是一种允许硬件设备直接读写系统内存的技术，无需CPU干预。它提供了一种高效的数据传输方式，可以大幅减少CPU负担，提升数据传输速度。
STM32上SPI+DMA实现大批量读取flash数据
duobaohongtu3的专栏
06-15 6478
最近做项目需要使用SPI+DMA，为了做实验感受DMA传输数据块，本人以SPI+DMA来读取flash中的数据。网上有很多例程是spi直接读取flash，无法提高性能。因为只是简单的实验SPI的DMA功能，所以在写数据时并没有考虑页写一些制约，只是简单的将1k大小的数据写入flash,然后用DMA读出这1K大小的数据，相信SPI和DMA的配置大家都很熟悉了，本人在此不在强调，只是说几点注意点的： （1）DMA关于SPI通道的选择，在stm32中，SPI1_RX读请求是DMA通道2，SPI1_TX发送请求是
stm32f4 SPI DMA FLASH 传输调试
热门推荐
zjzto的博客
02-27 1万+
来源：项目中需要用stm32对外部spi flash（m25p16 2MB）进行快速读取，主要是图像数据。平台：stm32f407---168MHz，FreeRTOS V7.3.0主要参考：http://blog.csdn.net/sinat_20598829/article/details/44408125貌似发现了其中的一个小问题，未使用中断！！！见图期间还参考帖子：http://blog...
STM32F407使用SPI的DMA来读取外部FLASH---W25Q16
dog345的博客
05-28 8357
STM32F407使用SPI的DMA来读取外部FLASH—W25Q16 SPI功能是常用的片内外设，以前调试经常使用的其正常的读写功能，即不用DMA。当进行读取或者写入大数据量的操作的时候，使用DMA会对读写速度进行一定提高。这次利用开发板上的板载外部FLASHW25Q16来进行SPI的DMA进行调试。记录一下调试过程。 采用的MCU为STM32F407VET6，FLASH的具体型号为W25Q16的内存大小为2M的外部FLASH。电路连接上，采用STM32F4的SPI1和FLASH进行通信，IO口为PB3
STM32 SPI读写FLASH
乱学一气
09-09 5153
SPI协议   Serial Peripheral Interface，串行外围设备接口。SPI 是串行同步全双工通信协议。一般用于控制器和控制器之间的数据传输。 物理层   每个从机都有四条线和主机相连，不同从机的 MISO MOSI SCK 连接的是主机统一个端口，SS 线，连接不同端口 SS ：（Slave Select）从机选择。当主机想和某个从机通讯时，就把从机的 SS 条线的电平拉低。 SCK ：（Serial Clock）时钟信号线。由主机产生，f103的SPI挂载在不同的总线上，最大频
Spi-dma-communication.zip_DMA SPI STM32_DMA STM32 SPI_SPI+DMA_s
07-15
stm32的两个spi外设之间通过dma方式通信
STM32的使用之SPI通信DMA模式
08-03
MCU:STM32F303VC，在SPI通信中，可以同时开启发送和接收DMA请求，自动数据的发送和接收，完成数据的交换。
stm32F407 SPI1/SPI2 DMA 方式读写 CH376S
01-03
内含SPI1/SPI2两个接口的读写版本，都是用的DMA方式，通信速度还不够快，好像几十KB吧，具体忘了多少了。下载者可以试着优化一下，速度还可以提高的。部分测试结果：https://blog.csdn.net/weixin_41565755/article/details/83115489
STM32F407 SPI FLASH DMA.zip
05-25
基于正点原子的STM32F407 SPI FLASH采用DMA方式读写数据，可直接运行在STM32F407探索者上。
STM32 Bootloader，基于3.5库使用SD卡+DMA在线刷写Flash
06-07
这个Bootloader Demo基于STM32F103平台可以通过SD卡基于文件系统(FatFs_R0.09b)使用DMA在线刷写程序，方便产品的程序在线升级
【STM32】标准库-SPI-DMA收发数据-读写Flash(W25Q256JV)-仿printf和scanf输入输出
06-29
用SPI5与Flash芯片通信(W25Q256JV)，使用了DMA进行收发数据，SPI是同步通信，同时收发数据(其实仅与发TX同步，作为主器件，Tx产生波特率时钟SCK信号) 利用可变参数宏实现printf与scanf 定义了Flash输入输出结构体，...
STM32f103+RGB-TFT_LCD(ST7735)+硬件SPI+DMA+CUBEMX配置
08-13
这个项目展示了如何利用STM32F103的强大功能，结合硬件SPI和DMA，实现高效地驱动ST7735 RGB TFT LCD。这样的配置不仅提高了系统性能，还能实现更复杂的图形显示功能。通过深入理解这些概念和技术，开发者可以为他们...
STM32 硬件SPI+DMA控制OLED屏幕
10-14
7. **代码示例**：使用STM32CubeMX生成初始的SPI和DMA配置，然后在用户代码中编写OLED屏幕的初始化和数据传输函数。例如，使用HAL_SPI_Transmit_DMA()启动一个DMA传输，并在中断服务程序中处理传输完成事件。 8. **...
STM32G0 硬件SPI+DMA+LL库，最高通讯速率32MBit/s
04-03
STM32G0的DMA控制器支持多个通道，每个通道可以独立配置为从SPI接口读取或写入数据。配置DMA时，我们需要指定源地址（SPI接口寄存器地址）、目标地址（内存地址）、传输长度和传输类型（单次传输或循环传输）。 ST...
评论 33
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值