STM32cubeide/STM32cubeMX USB链接W25QXX做U盘

已于 2022-04-22 10:12:32 修改
阅读量1.8k 收藏 14
点赞数 2
分类专栏： stm32 文章标签： stm32 USB U盘 MSC HAL SPI
于 2022-04-21 13:19:30 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_27620407/article/details/124317561
版权

1、STM32cube配置

RCC和SYS不再赘述

时钟配置

由于有USB，必须设置USB时钟48Mhz
在这里插入图片描述

SPI配置

在这里插入图片描述
由于USB时钟问题 ，Prescaler 没法设置为2
CPOL和CPHA W25QXX应该是 00 和11 都行，我只试了00，中断不开也行

USB设置

这一篇我主要是是为了记录USB的

在这里插入图片描述
选上FS Device 勾选中断 settings部分默认就行，也不会改
在这里插入图片描述

USB DEVICE设置

这一节USB保持512 只把 MSC改4096也可以

这里主要就是搞USB的4K 因为USB默认数据是512 而flash是4096的，把数据对齐
在这里插入图片描述
类型选择MSC
setting里他们都没管这个数，但是在这里改了的话就不用再在源码的usbd_conf.h里改了，不然的话需要把usbd_conf.h改成

/*---------- -----------*/
#define USBD_MAX_NUM_INTERFACES     2
/*---------- -----------*/
#define USBD_MAX_NUM_CONFIGURATION     2
/*---------- -----------*/
#define USBD_MAX_STR_DESC_SIZ     4096  //可以保持512
/*---------- -----------*/
#define USBD_DEBUG_LEVEL     3
/*---------- -----------*/
#define USBD_SELF_POWERED     1
/*---------- -----------*/
#define MSC_MEDIA_PACKET     4096

其他设置

在这里插入图片描述

这个改大

其他的就不用管了，最后是源码

源码

改变量

usbd_conf.h

要改的有两个h一个C 之前配置中已经提到 usbd_conf.h 也可以直接在配置中改

/*---------- -----------*/
#define USBD_MAX_NUM_INTERFACES     1
/*---------- -----------*/
#define USBD_MAX_NUM_CONFIGURATION     1
/*---------- -----------*/
#define USBD_MAX_STR_DESC_SIZ     4096//可以保持512
/*---------- -----------*/
#define USBD_DEBUG_LEVEL     0
/*---------- -----------*/
#define USBD_SELF_POWERED     1
/*---------- -----------*/
#define MSC_MEDIA_PACKET     4096

usb_msc.h

* MSC Class Config */
#ifndef MSC_MEDIA_PACKET
#define MSC_MEDIA_PACKET             4096//512U
#endif /* MSC_MEDIA_PACKET */

#define MSC_MAX_FS_PACKET            0x40U
#define MSC_MAX_HS_PACKET            4096//0x200U

#define BOT_GET_MAX_LUN              0xFE
#define BOT_RESET                    0xFF
#define USB_MSC_CONFIG_DESC_SIZ      32


#define MSC_EPIN_ADDR                0x81U
#define MSC_EPOUT_ADDR               0x01U

/**

usb_storage.c

这个文件两个变量，另外这里面还有关于硬件的接口函数
这里只看变量

#define STORAGE_LUN_NBR                  1
#define STORAGE_BLK_NBR                  0x2000//0x10000     这个是你用的flash的大小  0x2000是32M=1024*32=32768K   32768K/4K=0x2000
#define STORAGE_BLK_SIZ                  0x1000//0x200     //这个是你用的flash的扇区大小，0x1000是4K

避免每次更改设置后要重新设置变量

除去usbd_conf.h内变量可以在配置中设置 另外两个每次设置都会重新定义，这里利用 #undef取消宏定义再重新定义

usb_storage.c

/** @defgroup USBD_STORAGE_Private_Defines
  * @brief Private defines.
  * @{
  */

#define STORAGE_LUN_NBR                  1
#define STORAGE_BLK_NBR                  0x2000//0x10000
#define STORAGE_BLK_SIZ                  0x1000//0x200

/* USER CODE BEGIN PRIVATE_DEFINES */
#ifdef STORAGE_BLK_NBR
#undef STORAGE_BLK_NBR
#define STORAGE_BLK_NBR                  0x2000
#else
#define STORAGE_BLK_NBR                  0x2000
#endif

#ifdef STORAGE_BLK_SIZ
#undef STORAGE_BLK_SIZ
#define STORAGE_BLK_SIZ                  0x1000
#else
#define STORAGE_BLK_SIZ                  0x1000
#endif
/* USER CODE END PRIVATE_DEFINES */

usb_msc.h
这里要在main.c里处理，这个文件没有留自定义代码位置

/* Private user code ---------------------------------------------------------*/
/* USER CODE BEGIN 0 */
/* USER CODE BEGIN 0 */
#ifdef MSC_MEDIA_PACKET
#undef MSC_MEDIA_PACKET
#define MSC_MEDIA_PACKET                  4096U
#else
#define MSC_MEDIA_PACKET                  4096U
#endif

#ifdef MSC_MAX_HS_PACKET
#undef MSC_MAX_HS_PACKET
#define MSC_MAX_HS_PACKET                  0x1000U
#else
#define MSC_MAX_HS_PACKET                  0x1000U
#endif
/* USER CODE END 0 */

先说flash硬件接口接入USB的部分，也就是usb_storage.c

自定义驱动名称

/* USER CODE BEGIN INQUIRY_DATA_FS */
/** USB Mass storage Standard Inquiry Data. */
const int8_t STORAGE_Inquirydata_FS[] = {/* 36 */

  /* LUN 0 */
  0x00,
  0x80,
  0x02,
  0x02,
  (STANDARD_INQUIRY_DATA_LEN - 5),
  0x00,
  0x00,
  0x00,
  'S', 'T', 'M', ' ', ' ', ' ', ' ', ' ', /* Manufacturer : 8 bytes */
  'P', 'r', 'o', 'd', 'u', 'c', 't', ' ', /* Product      : 16 Bytes */
  ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ',
  '0', '.', '0' ,'1'                      /* Version      : 4 Bytes */
};

后续接口，这里我是参考
https://blog.csdn.net/Roomen0/article/details/122963305

/* Private functions ---------------------------------------------------------*/
/**
  * @brief  Initializes over USB FS IP
  * @param  lun:
  * @retval USBD_OK if all operations are OK else USBD_FAIL
  */
int8_t STORAGE_Init_FS(uint8_t lun)
{
  /* USER CODE BEGIN 2 */
	//存储介质初始化，如果正常，则返回 USBD_OK
	W25QXX_Init();
	if(((W25QXX_TYPE&0xFF00)>>8)==0xEF)
  return (USBD_OK);
	else
		return USBD_FAIL;
  /* USER CODE END 2 */
}

/**
  * @brief  .
  * @param  lun: .
  * @param  block_num: .
  * @param  block_size: .
  * @retval USBD_OK if all operations are OK else USBD_FAIL
  */
int8_t STORAGE_GetCapacity_FS(uint8_t lun, uint32_t *block_num, uint16_t *block_size)
{
  /* USER CODE BEGIN 3 */
	//获取存储介质的大小，函数已经填充好，我们可以不动
  *block_num  = STORAGE_BLK_NBR;
  *block_size = STORAGE_BLK_SIZ;
  return (USBD_OK);
  /* USER CODE END 3 */
}

/**
  * @brief  .
  * @param  lun: .
  * @retval USBD_OK if all operations are OK else USBD_FAIL
  */
int8_t STORAGE_IsReady_FS(uint8_t lun)
{
  /* USER CODE BEGIN 4 */
	//获取介质状态，我们要对存储介质的状态进行判断，这里我们要判断两点，一个是是否正在读写状态中，
	//另外一个就是存储介质是否是不可工作状态
  return W25QXX_ReadSR(1);
  /* USER CODE END 4 */
}

/**
  * @brief  .
  * @param  lun: .
  * @retval USBD_OK if all operations are OK else USBD_FAIL
  */
int8_t STORAGE_IsWriteProtected_FS(uint8_t lun)
{
  /* USER CODE BEGIN 5 */
	//判断是否是写保护，我们可以直接返回USBD_OK
  return (USBD_OK);
  /* USER CODE END 5 */
}

/**
  * @brief  .
  * @param  lun: .
  * @retval USBD_OK if all operations are OK else USBD_FAIL
  */
int8_t STORAGE_Read_FS(uint8_t lun, uint8_t *buf, uint32_t blk_addr, uint16_t blk_len)
{
  /* USER CODE BEGIN 6 */
	//读取一个扇区，我们将准备好的读取一个扇区的代码填充进来就好
	//W25QXX_Read(uint8_t* pBuffer,uint32_t ReadAddr,uint16_t NumByteToRead);   //读取flash
	W25QXX_Read(buf,blk_addr*W25Q64_SECTOR_SIZE,blk_len*W25Q64_SECTOR_SIZE);   //读取flash
  return (USBD_OK);
  /* USER CODE END 6 */
}

/**
  * @brief  .
  * @param  lun: .
  * @retval USBD_OK if all operations are OK else USBD_FAIL
  */
int8_t STORAGE_Write_FS(uint8_t lun, uint8_t *buf, uint32_t blk_addr, uint16_t blk_len)
{
  /* USER CODE BEGIN 7 */
	//写入一个扇区，我们将准备好的读取一个扇区的代码填充进来就好
	//W25QXX_Write(uint8_t* pBuffer,uint32_t WriteAddr,uint16_t NumByteToWrite);//写入flash
	W25QXX_Write(buf,blk_addr*W25Q64_SECTOR_SIZE,blk_len*W25Q64_SECTOR_SIZE);//写入flash
  return (USBD_OK);
  /* USER CODE END 7 */
}

/**
  * @brief  .
  * @param  None
  * @retval .
  */
int8_t STORAGE_GetMaxLun_FS(void)
{
  /* USER CODE BEGIN 8 */
	//读取磁盘介质的个数，一般我们只虚拟出一个来，不用管就行
  return (STORAGE_LUN_NBR - 1);
  /* USER CODE END 8 */
}

最后是根据原子例程改写的WQ驱动函数
H文件

#ifndef W25XX_H_
#define W25XX_H_

#include "main.h"

#define W25Q80 	0XEF13 	
#define W25Q16 	0XEF14
#define W25Q32 	0XEF15
#define W25Q64 	0XEF16
#define W25Q128	0XEF17
#define W25Q256 0XEF18

#define	W25Q64_SECTOR_NBR             0x2000//改为flash介质的sector 数量
#define	W25Q64_SECTOR_SIZE            0x1000//改为flash介质的sector 大小


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


#define	 W25QXX_CS 		PAout(4)  		//W25QXX的片选信号

void SPI1_Init(void);
void SPI1_SetSpeed(uint8_t SPI_BaudRatePrescaler);
uint8_t SPI1_ReadWriteByte(uint8_t TxData);


//指令表
#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);
uint16_t  W25QXX_ReadID(void);  	    		//读取FLASH ID
uint8_t W25QXX_ReadSR(uint8_t regno);             //读取状态寄存器 
void W25QXX_4ByteAddr_Enable(void);     //使能4字节地址模式
void W25QXX_Write_SR(uint8_t regno,uint8_t sr);   //写状态寄存器
void W25QXX_Write_Enable(void);  		//写使能 
void W25QXX_Write_Disable(void);		//写保护
void W25QXX_Write_NoCheck(uint8_t* pBuffer,uint32_t WriteAddr,uint16_t NumByteToWrite);
void W25QXX_Read(uint8_t* pBuffer,uint32_t ReadAddr,uint16_t NumByteToRead);   //读取flash
void W25QXX_Write(uint8_t* pBuffer,uint32_t WriteAddr,uint16_t NumByteToWrite);//写入flash
void W25QXX_Erase_Chip(void);    	  	//整片擦除
void W25QXX_Erase_Sector(uint32_t Dst_Addr);	//扇区擦除
void W25QXX_Wait_Busy(void);           	//等待空闲
void W25QXX_PowerDown(void);        	//进入掉电模式
void W25QXX_WAKEUP(void);				//唤醒
#endif /* W25XX_H_ */

C文件

#include "W25XX.h"
extern SPI_HandleTypeDef hspi1;
uint16_t W25QXX_TYPE;					//定义W25QXX芯片型号



//初始化SPI FLASH的IO口
void W25QXX_Init(void)
{
	uint8_t temp;
	W25QXX_CS=1;			                //SPI FLASH不选中
	//SPI1_Init();		   			        //初始化SPI
	//SPI1_SetSpeed(SPI_BAUDRATEPRESCALER_2); //设置为45M时钟,高速模式
	W25QXX_TYPE=W25QXX_ReadID();	        //读取FLASH ID.
    if(W25QXX_TYPE==W25Q32)                //SPI FLASH为W25Q32
    {
        temp=W25QXX_ReadSR(3);              //读取状态寄存器3，判断地址模式
        printf("W25Q32  %X\r\n",temp);
        if((temp&0X01)==0)			        //如果不是4字节地址模式,则进入4字节地址模式
		{
			W25QXX_CS=0; 			        //选中
			SPI1_ReadWriteByte(W25X_Enable4ByteAddr);//发送进入4字节地址模式指令
			printf("4ByteAddr\r\n");
			W25QXX_CS=1;       		        //取消片选   
		}
    }
}

uint16_t W25QXX_ReadID(void)
{
	uint16_t Temp = 0;	  
	W25QXX_CS=0;				    
	SPI1_ReadWriteByte(0x90);//发送读取ID命令	    
	SPI1_ReadWriteByte(0x00); 	    
	SPI1_ReadWriteByte(0x00); 	    
	SPI1_ReadWriteByte(0x00); 	 			   
	Temp|=SPI1_ReadWriteByte(0xFF)<<8;  
	Temp|=SPI1_ReadWriteByte(0xFF);	 
	W25QXX_TYPE=Temp;
	W25QXX_CS=1;				    
	return Temp;
}  

//读取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
//返回值:状态寄存器值
uint8_t W25QXX_ReadSR(uint8_t regno)   
{  
	uint8_t 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;
    }    
	W25QXX_CS=0;                            //使能器件   
	SPI1_ReadWriteByte(command);            //发送读取状态寄存器命令    
	byte=SPI1_ReadWriteByte(0Xff);          //读取一个字节  
	W25QXX_CS=1;                            //取消片选     
	return byte;   
} 
//写W25QXX状态寄存器
void W25QXX_Write_SR(uint8_t regno,uint8_t sr)   
{   
    uint8_t 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;
    }   
	W25QXX_CS=0;                            //使能器件   
	SPI1_ReadWriteByte(command);            //发送写取状态寄存器命令    
	SPI1_ReadWriteByte(sr);                 //写入一个字节  
	W25QXX_CS=1;                            //取消片选     	      
}   
//W25QXX写使能	
//将WEL置位   
void W25QXX_Write_Enable(void)   
{
	W25QXX_CS=0;                            //使能器件   
    SPI1_ReadWriteByte(W25X_WriteEnable);   //发送写使能  
	W25QXX_CS=1;                            //取消片选     	      
} 
//W25QXX写禁止	
//将WEL清零  
void W25QXX_Write_Disable(void)   
{  
	W25QXX_CS=0;                            //使能器件   
    SPI1_ReadWriteByte(W25X_WriteDisable);  //发送写禁止指令    
	W25QXX_CS=1;                            //取消片选     	      
} 

		    
//读取SPI FLASH  
//在指定地址开始读取指定长度的数据
//pBuffer:数据存储区
//ReadAddr:开始读取的地址(24bit)
//NumByteToRead:要读取的字节数(最大65535)
void W25QXX_Read(uint8_t* pBuffer,uint32_t ReadAddr,uint16_t NumByteToRead)   
{ 
 	uint16_t i;   										    
	W25QXX_CS=0;                            //使能器件   
    SPI1_ReadWriteByte(W25X_ReadData);      //发送读取命令  
    if(W25QXX_TYPE==W25Q256)                //如果是W25Q256的话地址为4字节的，要发送最高8位
    {
        SPI1_ReadWriteByte((uint8_t)((ReadAddr)>>24));    
    }
    SPI1_ReadWriteByte((uint8_t)((ReadAddr)>>16));   //发送24bit地址    
    SPI1_ReadWriteByte((uint8_t)((ReadAddr)>>8));   
    SPI1_ReadWriteByte((uint8_t)ReadAddr);   
    for(i=0;i<NumByteToRead;i++)
	{ 
        pBuffer[i]=SPI1_ReadWriteByte(0XFF);    //循环读数  
    }
	W25QXX_CS=1;  				    	      
}  
//SPI在一页(0~65535)内写入少于256个字节的数据
//在指定地址开始写入最大256字节的数据
//pBuffer:数据存储区
//WriteAddr:开始写入的地址(24bit)
//NumByteToWrite:要写入的字节数(最大256),该数不应该超过该页的剩余字节数!!!	 
void W25QXX_Write_Page(uint8_t* pBuffer,uint32_t WriteAddr,uint16_t NumByteToWrite)
{
 	uint16_t i;  
    W25QXX_Write_Enable();                  //SET WEL 
	W25QXX_CS=0;                            //使能器件   
    SPI1_ReadWriteByte(W25X_PageProgram);   //发送写页命令   
    if(W25QXX_TYPE==W25Q256)                //如果是W25Q256的话地址为4字节的，要发送最高8位
    {
        SPI1_ReadWriteByte((uint8_t)((WriteAddr)>>24)); 
    }
    SPI1_ReadWriteByte((uint8_t)((WriteAddr)>>16)); //发送24bit地址    
    SPI1_ReadWriteByte((uint8_t)((WriteAddr)>>8));   
    SPI1_ReadWriteByte((uint8_t)WriteAddr);   
    for(i=0;i<NumByteToWrite;i++)SPI1_ReadWriteByte(pBuffer[i]);//循环写数  
	W25QXX_CS=1;                            //取消片选 
	W25QXX_Wait_Busy();					   //等待写入结束
} 
//无检验写SPI FLASH 
//必须确保所写的地址范围内的数据全部为0XFF,否则在非0XFF处写入的数据将失败!
//具有自动换页功能 
//在指定地址开始写入指定长度的数据,但是要确保地址不越界!
//pBuffer:数据存储区
//WriteAddr:开始写入的地址(24bit)
//NumByteToWrite:要写入的字节数(最大65535)
//CHECK OK
void W25QXX_Write_NoCheck(uint8_t* pBuffer,uint32_t WriteAddr,uint16_t NumByteToWrite)   
{ 			 		 
	uint16_t 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)   
uint8_t W25QXX_BUFFER[4096];		 
void W25QXX_Write(uint8_t* pBuffer,uint32_t WriteAddr,uint16_t NumByteToWrite)   
{ 
	uint32_t secpos;
	uint16_t secoff;
	uint16_t secremain;	   
 	uint16_t i;    
	uint8_t * 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;                            //使能器件   
    SPI1_ReadWriteByte(W25X_ChipErase);        //发送片擦除命令  
	W25QXX_CS=1;                            //取消片选     	      
	W25QXX_Wait_Busy();   				   //等待芯片擦除结束
}   
//擦除一个扇区
//Dst_Addr:扇区地址 根据实际容量设置
//擦除一个扇区的最少时间:150ms
void W25QXX_Erase_Sector(uint32_t Dst_Addr)   
{  
	//监视falsh擦除情况,测试用   
 	//printf("fe:%x\r\n",Dst_Addr);	  
 	Dst_Addr*=4096;
    W25QXX_Write_Enable();                  //SET WEL 	 
    W25QXX_Wait_Busy();   
  	W25QXX_CS=0;                            //使能器件   
    SPI1_ReadWriteByte(W25X_SectorErase);   //发送扇区擦除指令 
    if(W25QXX_TYPE==W25Q256)                //如果是W25Q256的话地址为4字节的，要发送最高8位
    {
        SPI1_ReadWriteByte((uint8_t)((Dst_Addr)>>24)); 
    }
    SPI1_ReadWriteByte((uint8_t)((Dst_Addr)>>16));  //发送24bit地址    
    SPI1_ReadWriteByte((uint8_t)((Dst_Addr)>>8));   
    SPI1_ReadWriteByte((uint8_t)Dst_Addr);  
	W25QXX_CS=1;                            //取消片选     	      
    W25QXX_Wait_Busy();   				    //等待擦除完成
}  
//等待空闲
void W25QXX_Wait_Busy(void)   
{   
	while((W25QXX_ReadSR(1)&0x01)==0x01);   // 等待BUSY位清空
}  
//进入掉电模式
void W25QXX_PowerDown(void)   
{ 
  	W25QXX_CS=0;                            //使能器件   
    SPI1_ReadWriteByte(W25X_PowerDown);     //发送掉电命令  
	W25QXX_CS=1;                            //取消片选     	      
    delay_us(3);                            //等待TPD  
}   
//唤醒
void W25QXX_WAKEUP(void)   
{  
  	W25QXX_CS=0;                                //使能器件   
    SPI1_ReadWriteByte(W25X_ReleasePowerDown);  //  send W25X_PowerDown command 0xAB    
	W25QXX_CS=1;                                //取消片选     	      
    delay_us(3);                                //等待TRES1
}   

//以下是SPI模块的初始化代码，配置成主机模式 						  
//SPI口初始化
//这里针是对SPI5的初始化
void SPI1_Init(void)
{
	hspi1.Instance=SPI1;                         //SP5
	hspi1.Init.Mode=SPI_MODE_MASTER;             //设置SPI工作模式，设置为主模式
	hspi1.Init.Direction=SPI_DIRECTION_2LINES;   //设置SPI单向或者双向的数据模式:SPI设置为双线模式
	hspi1.Init.DataSize=SPI_DATASIZE_8BIT;       //设置SPI的数据大小:SPI发送接收8位帧结构
	hspi1.Init.CLKPolarity=SPI_POLARITY_HIGH;    //串行同步时钟的空闲状态为高电平
	hspi1.Init.CLKPhase=SPI_PHASE_2EDGE;         //串行同步时钟的第二个跳变沿（上升或下降）数据被采样
	hspi1.Init.NSS=SPI_NSS_SOFT;                 //NSS信号由硬件（NSS管脚）还是软件（使用SSI位）管理:内部NSS信号有SSI位控制
	hspi1.Init.BaudRatePrescaler=SPI_BAUDRATEPRESCALER_256;//定义波特率预分频的值:波特率预分频值为256
	hspi1.Init.FirstBit=SPI_FIRSTBIT_MSB;        //指定数据传输从MSB位还是LSB位开始:数据传输从MSB位开始
	hspi1.Init.TIMode=SPI_TIMODE_DISABLE;        //关闭TI模式
	hspi1.Init.CRCCalculation=SPI_CRCCALCULATION_DISABLE;//关闭硬件CRC校验
	hspi1.Init.CRCPolynomial=7;                  //CRC值计算的多项式
    HAL_SPI_Init(&hspi1);//初始化
    
    __HAL_SPI_ENABLE(&hspi1);                    //使能SPI5
	
    SPI1_ReadWriteByte(0Xff);                           //启动传输
}

//SPI1底层驱动，时钟使能，引脚配置
//此函数会被HAL_SPI_Init()调用
//hspi:SPI句柄
//void HAL_SPI_MspInit(SPI_HandleTypeDef *hspi)
//{
//    GPIO_InitTypeDef GPIO_Initure;
//    
//    __HAL_RCC_GPIOA_CLK_ENABLE();       //使能GPIOAF时钟
//    __HAL_RCC_SPI1_CLK_ENABLE();        //使能SPI1时钟
//    
//    //PA567
//    GPIO_Initure.Pin=GPIO_PIN_5|GPIO_PIN_6|GPIO_PIN_7;
//    GPIO_Initure.Mode=GPIO_MODE_AF_PP;              //复用推挽输出
//    GPIO_Initure.Pull=GPIO_PULLUP;                  //上拉
//    GPIO_Initure.Speed=GPIO_SPEED_FREQ_HIGH;             //快速            
//    HAL_GPIO_Init(GPIOA,&GPIO_Initure);
//    
//    
//}

//SPI速度设置函数
//SPI速度=fAPB1/分频系数
//@ref SPI_BaudRate_Prescaler:SPI_BAUDRATEPRESCALER_2~SPI_BAUDRATEPRESCALER_2 256
//fAPB1时钟一般为45Mhz：
void SPI1_SetSpeed(uint8_t SPI_BaudRatePrescaler)
{
    assert_param(IS_SPI_BAUDRATE_PRESCALER(SPI_BaudRatePrescaler));//判断有效性
    __HAL_SPI_DISABLE(&hspi1);            //关闭SPI
    hspi1.Instance->CR1&=0XFFC7;          //位3-5清零，用来设置波特率
    hspi1.Instance->CR1|=SPI_BaudRatePrescaler;//设置SPI速度
    __HAL_SPI_ENABLE(&hspi1);             //使能SPI
    
}

//SPI5 读写一个字节
//TxData:要写入的字节
//返回值:读取到的字节
uint8_t SPI1_ReadWriteByte(uint8_t TxData)
{
	uint8_t Rxdata;
    HAL_SPI_TransmitReceive(&hspi1,&TxData,&Rxdata,1, 1000);       
 	return Rxdata;          		    //返回收到的数据		
}

注意 W25QXX_Init中W25QXX_ReadID之后对比的flash型号对应自己的大小

完成的例程参考
https://download.csdn.net/download/qq_27620407/85193715

物极必反1024
关注
  • 2
    点赞
  • 踩
  • 14
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
使用STM32cubeMX/STM32cube ide 生成FatFS代码,操作SPI FLASH
04-19
在本文中，我们将深入探讨如何使用STM32CubeMX/STM32CubeIDE来生成FatFS代码，并操作SPI Flash（以w25Qxx为例），这在嵌入式硬件开发中是一个常见且重要的任务。STM32CubeMX是STMicroelectronics提供的一个配置工具...
STM32CubeMX学习笔记（48）——USB接口使用（MSC基于外部Flash模拟U盘）
Leung的博客
11-23 5319
USB大容量存储设备类（The USB mass storage device class）是一种计算机和移动设备之间的传输协议，它允许一个通用串行总线（USB）设备来访问主机的计算设备，使两者之间进行文件传输。通过这个标准的计算机连接到的设备包括：移动硬盘、移动光驱、U盘、SD、TF等储存卡读卡器、数码相机、各种数字音频播放器和便携式媒体播放器、智能卡阅读器、掌上电脑和手机。
【STM32CubeIDE进阶】（一）USB设备之鼠标
涛涛子的博客
10-24 1694
由于 USB 协议过于复杂，这里不展开详细讲解，不过我上传了，文中用到的工具皆出自这里，并且其中包括的《圈圈教你玩USB》是一本非常好的入门书籍，想要深入可以看看。
STM32存储左右互搏 USB接口FATS文件读写U盘
最新发布
Pegasus的软件博客
05-13 1094
常见的USB接口电路部分相似而有不同的连接器应用，连接器有USB-A, USB-MINI, USB-MICRO, USB-TYPEC等。除了USB-A可以直接插入U盘,其它连接器可以通过转接板和转接线和U盘连接。如果用USB-TYPEC公头的U盘，则可以直接插入USB-TYPEC母座的主机。常见USB-TYPEC接口电路如下：去繁化简，主要是5V电源输入，接地，差分信号+ （DP）， 差分信号- （DN）4个有效连接。对于STM32, DP连接到了PA12管脚， DN连接到了PA11管脚.
STM32CubeIDE 简单配置USB虚拟串口 并实现printf
热门推荐
zateper的博客
02-18 1万+
一、MX配置 （支持OTG的32需要在USB_OTG_FS中 选择DeviceOnly模式） 中间件Middleware配置选择虚拟串口，参数默认即可 时钟配置需要将USB的频率设置为48MHz 修改堆空间，避免电脑识别异常 二、生成的代码 代码文件分布结构 在main.c中已自动加入以下相关代码 #include "usb_device.h"...
STM32Cube的USB_device软件库说明
qq_37391577的博客
08-03 1972
USB 设备库基于通用 USB 底层驱动开发，可在全速和高速模式中工作。它实现了USB 2.0版本定义的USB设备库状态机。此模块功能由USB设备库固件包中"Core" 目录下的文件提供。USB 类模块为类层，与协议规范兼容。
使用stm32cubeide的usb-host-cdc库驱动EC20模块
gyzw_mx的博客
04-12 6024
使用stm32cubeide的usb-host-cdc库驱动EC20模块写在前面开发环境：开始一、使用 cubeide 创建 STM32 Project二、修改代码三、仿真最后 写在前面 之前已经发布过一篇 “使用stm32cubemx的usb-host-cdc库驱动EC20模块”，但是近期有很多小伙伴私信询问相关问题。今天抽空重新浏览了一下上一篇博客，因为自己想表述的东西太多，写的有点乱。决定重新建立一个空工程，使用最新的 1.26.1 HAL库，按照原文配置方式，删除掉干扰代码，重写一篇博客，希望可以减
基于STM32F407的SDCard读写操作及USB挂载（HAL库）
a390478024的博客
09-09 5803
基于STM32F407的SDCard读写操作及USB挂载（HAL库版本）
STM32cubeMX配置F103的硬件SPI读写W25QXX的FLASH
02-29
STM32CubeMX是一款强大的STM32微控制器配置工具，由意法半导体（STMicroelectronics）提供，用于初始化和配置STM32系列芯片的各种外设。在这个特定的场景中，我们要探讨如何使用STM32CubeMX来配置STM32F103微控制器...
STM32驱动W25Q64,W25Q128,W25QXX驱动
03-20
STM32驱动W25Q64、W25Q128以及W25QXX系列的SPI接口闪存芯片是一项常见的任务，在嵌入式系统开发中扮演着重要角色。这些芯片通常用于存储程序代码、配置数据或者用户数据。在本教程中，我们将深入探讨如何使用STM32的...
用STM32CubeMX快速生成一个U盘模拟程序
10-10
基于MDK V5和STM32CubeMX，图文并茂；。。完成后，就可以双击打开这个“U盘”了，这是一个可以进行读写的U盘。 将这个U盘弹出，然后断开USB链接线，然后再重新连接，就可以被360 U盘助手发现了。 实际可用空间为81920字节。
STM32L051+W25Qxx实现数据读写
04-29
在STM32L051与W25Qxx的集成应用中，我们需要实现以下主要知识点： 1. **SPI通信协议**：STM32L051通过SPI接口与W25Qxx进行通信。SPI是一种同步串行通信协议，由主设备（Master）控制时钟和数据传输方向。在STM32中...
STM32CubeMX F4驱动SDIO USB Fatfs文件系统
lin辰傍风的博客
03-19 1322
SDIO TF卡 USB Fatfs STM32
FLASH 写数据函数
wuhuiskt的博客
07-23 1268
#define W25Q64_PAGE_SIZE          FLASH_PAGE_SIZE                        // 一个page 256 (Byte)  #define W25Q64_SECTOR_SIZE      (W25Q64_PAGE_SIZE*16)    // 16个page组成一个sector: PAGE * 16 = 4K (Byte) //擦除...
STM32Cube MX USB虚拟U盘+FATFS+W25Q128
m0_52169267的博客
12-05 6923
第一次写CSDN，把这两天做的一个小实验记个笔记。写的不好请见谅，有错误欢迎指正，欢迎讨论。在做之前也参考其他博主的一些文章。 USB基本概念不做介绍，不懂的可以先去了解，主要说明实现过程。
使用STM32Cube库开发USB虚拟串口设备
weixin_66608063的博客
01-16 1203
然后在主循环中，利用USB_TransferData函数进行数据传输，这里的CDC_Transmit_FS是USB CDC库函数，用于向主机传输数据。通过USB虚拟串口设备，我们可以简化外部设备与计算机之间的通信，实现便捷的数据传输。在使用STM32Cube库开发USB虚拟串口设备时，我们可以利用STM32CubeMX工具进行初始化配置和生成代码，然后在Keil、IAR等集成开发环境下进行进一步的开发和调试。通过合理的配置和开发，我们可以实现与计算机的串口通信，为嵌入式系统的通信提供了一种便捷的解决方案。
STM32CubeMX学习笔记（46）——USB接口使用（HID自定义设备）
Leung的博客
11-04 6249
USB HID类是USB设备的一个标准设备类，包括的设备非常多。HID类设备定义它属于人机交互操作的设备，用于控制计算机操作的一些方面，如USB鼠标、USB键盘、USB游戏操纵杆等。但HID设备类不一定要有人机接口，只要符合HID类别规范的设备都是HID设备。USB HID设备的一个好处就是操作系统自带了HID类的驱动程序，而用户无需去开发驱动程序，只要使用API系统调用即可完成通信。
STM32cubeMX配置FreeRTOS-51、USB-U盘读写
fanzhipeng7000的博客
11-15 339
2-USB_HOST，Mass Storage Host Class配置为大容量存储设备，调试为3，512个words,即2K字节。3-FATFS，勾选USB Disk，CODE_PAGE设置Latin1改S-C-(DBCS),LFN为----STACK.插上U盘后新建了tast文件内容hello word。5-在main.c文件中 代码0中增加代码。1-选USB-FS，Host_Only。6-在main.c代码3中中增加。4-工程堆栈全为1000。
stm32cube spi w25q32
07-27
STM32Cube是STMicroelectronics针对其STM32微控制器系列提供的综合软件开发平台。SPI是一种串行外设接口，用于在微控制器和外部设备之间传输数据。而W25Q32是一种串行闪存芯片，用于存储程序和数据。 STM32Cube提供...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值