stm32USB之模拟U盘

最新推荐文章于 2024-09-12 08:52:17 发布
最新推荐文章于 2024-09-12 08:52:17 发布
阅读量7.7k 收藏 45
点赞数 6
文章标签： 嵌入式 单片机 flash
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_38420206/article/details/110572003
版权

STMF0+W25Q32模拟U盘

1.第一次写博客，如有错误，请及时指正，如有表达不通顺的地方，敬请谅解。
2.本篇文章主要描述如何使用STM32cube配置USB，使用的主控为STM32F072，Flash为W25Q32，使用的主控RAM只有16K，所以不使用太多外设，也没有使用文件系统。
3.此段说明制作U盘的目的，不感兴趣可以忽略。由于主控ROM只有128K（项目需要，不可更换），需要将图片、字库等内容存储在W25Q32中，仅有一个串口，还被WiFi模块占用。因此上网查询资料，查询到了很多关于U盘制作的资料。有的使用原子的编程方式（看不懂）；有的使用标准库（我需要使用的是HAL库）；有的是STMF1+文件系统+Flash（F1不合适，并且整个工程太大，16KRAM不够用）。综上，选择自己造轮子，别人家法拉利的轮子太奢华，不能装在自家的拖拉机上。不管别人家的轮子多么好看，不适合自己就是不适合自己。但是很感谢这些造轮子的人，让我有了造拖拉机轮子的思路，文末将会贴上他们文章的链接，多看多写多想。

步骤如下

  1. 打开cube软件，芯片选择STM32F072CBT6。

  2. 使用内部8M晶振，所以不进行配置RCC。不进行调试，USART也不配置

  3. 配置USB在这里插入图片描述

  4. 配置USB_DEVICE在这里插入图片描述

  5. 时钟树设置未进行配置
    在这里插入图片描述

  6. 生成文件在这里插入图片描述

加入SPI控制程序

没有进行spi配置，毕竟还要加入flash扇区擦除、缓冲区写入等函数。spi控制程序选择野火的，在此感谢野火。在这里插入图片描述
野火的程序都可以在淘宝下载，还有很多资料，有很大的参考价值。

最重要的是在usb文件中加入读写函数

修改部分程序

STORAGE_BLK_SIZ 扇区大小为4096
STORAGE_BLK_NBR 总共有1024个扇区
在这里插入图片描述

加入读取、擦除、写入函数

每次写入数据前，需将对应的扇区进行擦除
在这里插入图片描述

关键代码

main.c

int main(void)
{
  SystemClock_Config();
  MX_GPIO_Init();               //usb引脚使用了PA口
  FLASH_GPIO_Init();            
  SPI_FLASH_Init();
  MX_USB_DEVICE_Init();
  while(1)
  {
  }
}




void SystemClock_Config(void)
{
  RCC_OscInitTypeDef RCC_OscInitStruct = {0};
  RCC_ClkInitTypeDef RCC_ClkInitStruct = {0};
  RCC_PeriphCLKInitTypeDef PeriphClkInit = {0};

  /** Initializes the CPU, AHB and APB busses clocks 
  */
  RCC_OscInitStruct.OscillatorType = RCC_OSCILLATORTYPE_HSI|RCC_OSCILLATORTYPE_HSI48;
  RCC_OscInitStruct.HSIState = RCC_HSI_ON;
  RCC_OscInitStruct.HSI48State = RCC_HSI48_ON;
  RCC_OscInitStruct.HSICalibrationValue = RCC_HSICALIBRATION_DEFAULT;
  RCC_OscInitStruct.PLL.PLLState = RCC_PLL_ON;
  RCC_OscInitStruct.PLL.PLLSource = RCC_PLLSOURCE_HSI;
  RCC_OscInitStruct.PLL.PLLMUL = RCC_PLL_MUL12;
  RCC_OscInitStruct.PLL.PREDIV = RCC_PREDIV_DIV2;
  if (HAL_RCC_OscConfig(&RCC_OscInitStruct) != HAL_OK)
  {
    Error_Handler();
  }
  /** Initializes the CPU, AHB and APB busses clocks 
  */
  RCC_ClkInitStruct.ClockType = RCC_CLOCKTYPE_HCLK|RCC_CLOCKTYPE_SYSCLK
                              |RCC_CLOCKTYPE_PCLK1;
  RCC_ClkInitStruct.SYSCLKSource = RCC_SYSCLKSOURCE_PLLCLK;
  RCC_ClkInitStruct.AHBCLKDivider = RCC_SYSCLK_DIV2;
  RCC_ClkInitStruct.APB1CLKDivider = RCC_HCLK_DIV1;

  if (HAL_RCC_ClockConfig(&RCC_ClkInitStruct, FLASH_LATENCY_1) != HAL_OK)
  {
    Error_Handler();
  }
  PeriphClkInit.PeriphClockSelection = RCC_PERIPHCLK_USB;
  PeriphClkInit.UsbClockSelection = RCC_USBCLKSOURCE_HSI48;

  if (HAL_RCCEx_PeriphCLKConfig(&PeriphClkInit) != HAL_OK)
  {
    Error_Handler();
  }
}

stm32f0xx_it.h

/* External variables --------------------------------------------------------*/
extern PCD_HandleTypeDef hpcd_USB_FS;

/**
  * @brief This function handles USB global interrupt / USB wake-up interrupt through EXTI line 18.
  */
void USB_IRQHandler(void)
{
  /* USER CODE BEGIN USB_IRQn 0 */

  /* USER CODE END USB_IRQn 0 */
  HAL_PCD_IRQHandler(&hpcd_USB_FS);
  /* USER CODE BEGIN USB_IRQn 1 */

  /* USER CODE END USB_IRQn 1 */
}

/* Includes ------------------------------------------------------------------*/
#include "usbd_storage_if.h"

#include "bsp_spi_flash.h"

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

#define STORAGE_LUN_NBR                  1
#define STORAGE_BLK_NBR                  1024
#define STORAGE_BLK_SIZ                  4096

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 */
}; 

extern USBD_HandleTypeDef hUsbDeviceFS;


static int8_t STORAGE_Init_FS(uint8_t lun);
static int8_t STORAGE_GetCapacity_FS(uint8_t lun, uint32_t *block_num, uint16_t *block_size);
static int8_t STORAGE_IsReady_FS(uint8_t lun);
static int8_t STORAGE_IsWriteProtected_FS(uint8_t lun);
static int8_t STORAGE_Read_FS(uint8_t lun, uint8_t *buf, uint32_t blk_addr, uint16_t blk_len);
static int8_t STORAGE_Write_FS(uint8_t lun, uint8_t *buf, uint32_t blk_addr, uint16_t blk_len);
static int8_t STORAGE_GetMaxLun_FS(void);

/**
  * @}
  */
USBD_StorageTypeDef USBD_Storage_Interface_fops_FS =
{
  STORAGE_Init_FS,
  STORAGE_GetCapacity_FS,
  STORAGE_IsReady_FS,
  STORAGE_IsWriteProtected_FS,
  STORAGE_Read_FS,
  STORAGE_Write_FS,
  STORAGE_GetMaxLun_FS,
  (int8_t *)STORAGE_Inquirydata_FS
};

/* 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 */
	
  return (USBD_OK);
  /* 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 */
//  if(SPI_FLASH_ReadID() == sFLASH_ID)
    return (USBD_OK);
//	else
//		return -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 */
  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 */
	SPI_FLASH_BufferRead(buf, blk_addr*STORAGE_BLK_SIZ, blk_len*STORAGE_BLK_SIZ);
  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 */
	SPI_FLASH_SectorErase(blk_addr*STORAGE_BLK_SIZ);
  SPI_FLASH_BufferWrite(buf, blk_addr*STORAGE_BLK_SIZ,blk_len*STORAGE_BLK_SIZ);
  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 */
}

缩减篇幅，删除了一些cube生成的无关注释

SPI程序也添上吧

spi.c

#include "bsp_spi_flash.h"

SPI_HandleTypeDef SpiHandle;
static __IO uint32_t  SPITimeout = SPIT_LONG_TIMEOUT;   

static uint16_t SPI_TIMEOUT_UserCallback(uint8_t errorCode);

/**
  * @brief SPI MSP Initialization 
  *        This function configures the hardware resources used in this example: 
  *           - Peripheral's clock enable
  *           - Peripheral's GPIO Configuration  
  * @param hspi: SPI handle pointer
  * @retval None
  */
void FLASH_GPIO_Init(void)
{
  GPIO_InitTypeDef  GPIO_InitStruct;
  
  /*##-1- Enable peripherals and GPIO Clocks #################################*/
  /* Enable GPIO TX/RX clock */
  SPIx_SCK_GPIO_CLK_ENABLE();
  SPIx_MISO_GPIO_CLK_ENABLE();
  SPIx_MOSI_GPIO_CLK_ENABLE();
  SPIx_CS_GPIO_CLK_ENABLE();
  /* Enable SPI clock */
  SPIx_CLK_ENABLE(); 
  
  /*##-2- Configure peripheral GPIO ##########################################*/  
  /* SPI SCK GPIO pin configuration  */
  GPIO_InitStruct.Pin       = SPIx_SCK_PIN;
  GPIO_InitStruct.Mode      = GPIO_MODE_AF_PP;
  GPIO_InitStruct.Pull      = GPIO_PULLUP;
  GPIO_InitStruct.Speed     = GPIO_SPEED_FREQ_HIGH;

  
  HAL_GPIO_Init(SPIx_SCK_GPIO_PORT, &GPIO_InitStruct);
    
  /* SPI MISO GPIO pin configuration  */
  GPIO_InitStruct.Pin = SPIx_MISO_PIN;  
  HAL_GPIO_Init(SPIx_MISO_GPIO_PORT, &GPIO_InitStruct);
  
  /* SPI MOSI GPIO pin configuration  */
  GPIO_InitStruct.Pin = SPIx_MOSI_PIN; 
  HAL_GPIO_Init(SPIx_MOSI_GPIO_PORT, &GPIO_InitStruct);   

  GPIO_InitStruct.Pin = FLASH_CS_PIN ;
  GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP;
  HAL_GPIO_Init(FLASH_CS_GPIO_PORT, &GPIO_InitStruct); 
	
	
	SPI_FLASH_CS_HIGH();
}


void SPI_FLASH_Init(void)
{
  SpiHandle.Instance               = SPIx;
  SpiHandle.Init.BaudRatePrescaler = SPI_BAUDRATEPRESCALER_2;
  SpiHandle.Init.Direction         = SPI_DIRECTION_2LINES;
  SpiHandle.Init.CLKPhase          = SPI_PHASE_2EDGE;
  SpiHandle.Init.CLKPolarity       = SPI_POLARITY_HIGH;
  SpiHandle.Init.CRCCalculation    = SPI_CRCCALCULATION_DISABLE;
  SpiHandle.Init.CRCPolynomial     = 7;
  SpiHandle.Init.DataSize          = SPI_DATASIZE_8BIT;
  SpiHandle.Init.FirstBit          = SPI_FIRSTBIT_MSB;
  SpiHandle.Init.NSS               = SPI_NSS_SOFT;
  SpiHandle.Init.TIMode            = SPI_TIMODE_DISABLE;
  
  SpiHandle.Init.Mode = SPI_MODE_MASTER;

  HAL_SPI_Init(&SpiHandle); 
  
  __HAL_SPI_ENABLE(&SpiHandle);     
}


 /**
  * @brief  擦除FLASH扇区
  * @param  SectorAddr：要擦除的扇区地址
  * @retval 无
  */
void SPI_FLASH_SectorErase(uint32_t SectorAddr)
{
  /* 发送FLASH写使能命令 */
  SPI_FLASH_WriteEnable();
  SPI_FLASH_WaitForWriteEnd();
  /* 擦除扇区 */
  /* 选择FLASH: CS低电平 */
  SPI_FLASH_CS_LOW();
  /* 发送扇区擦除指令*/
  SPI_FLASH_SendByte(W25X_SectorErase);
  /*发送擦除扇区地址的高位*/
  SPI_FLASH_SendByte((SectorAddr & 0xFF0000) >> 16);
  /* 发送擦除扇区地址的中位 */
  SPI_FLASH_SendByte((SectorAddr & 0xFF00) >> 8);
  /* 发送擦除扇区地址的低位 */
  SPI_FLASH_SendByte(SectorAddr & 0xFF);
  /* 停止信号 FLASH: CS 高电平 */
  SPI_FLASH_CS_HIGH();
  /* 等待擦除完毕*/
  SPI_FLASH_WaitForWriteEnd();
}

 /**
  * @brief  擦除FLASH扇区，整片擦除
  * @brief  页为编程单位，可以一次性编程1个到256个字节
  * @brief  超过256个字节要分次写入
  * @brief  写入数据之前，必须对对应的区域进行擦除操作
  * @brief  擦除的最小单位是“扇区”
  * @param  无
  * @retval 无
  */
void SPI_FLASH_BulkErase(void)
{
  /* 发送FLASH写使能命令 */
  SPI_FLASH_WriteEnable();

  /* 整块 Erase */
  /* 选择FLASH: CS低电平 */
  SPI_FLASH_CS_LOW();
  /* 发送整块擦除指令*/
  SPI_FLASH_SendByte(W25X_ChipErase);
  /* 停止信号 FLASH: CS 高电平 */
  SPI_FLASH_CS_HIGH();

  /* 等待擦除完毕*/
  SPI_FLASH_WaitForWriteEnd();
}

 /**
  * @brief  对FLASH按页写入数据，调用本函数写入数据前需要先擦除扇区
  * @param	pBuffer，要写入数据的指针
  * @param WriteAddr，写入地址
  * @param  NumByteToWrite，写入数据长度，必须小于等于SPI_FLASH_PerWritePageSize
  * @retval 无
  */
void SPI_FLASH_PageWrite(uint8_t* pBuffer, uint32_t WriteAddr, uint16_t NumByteToWrite)
{
  /* 发送FLASH写使能命令 */
  SPI_FLASH_WriteEnable();

  /* 选择FLASH: CS低电平 */
  SPI_FLASH_CS_LOW();
  /* 写页写指令*/
  SPI_FLASH_SendByte(W25X_PageProgram);
  /*发送写地址的高位*/
  SPI_FLASH_SendByte((WriteAddr & 0xFF0000) >> 16);
  /*发送写地址的中位*/
  SPI_FLASH_SendByte((WriteAddr & 0xFF00) >> 8);
  /*发送写地址的低位*/
  SPI_FLASH_SendByte(WriteAddr & 0xFF);

  if(NumByteToWrite > SPI_FLASH_PerWritePageSize)
  {
     NumByteToWrite = SPI_FLASH_PerWritePageSize;
//     FLASH_ERROR("SPI_FLASH_PageWrite too large!");
  }

  /* 写入数据*/
  while (NumByteToWrite--)
  {
    /* 发送当前要写入的字节数据 */
    SPI_FLASH_SendByte(*pBuffer);
    /* 指向下一字节数据 */
    pBuffer++;
  }

  /* 停止信号 FLASH: CS 高电平 */
  SPI_FLASH_CS_HIGH();

  /* 等待写入完毕*/
  SPI_FLASH_WaitForWriteEnd();
}


 /**
  * @brief  对FLASH写入数据，调用本函数写入数据前需要先擦除扇区
  * @param	pBuffer，要写入数据的指针
  * @param  WriteAddr，写入地址
  * @param  NumByteToWrite，写入数据长度
  * @retval 无
  */
void SPI_FLASH_BufferWrite(uint8_t* pBuffer, uint32_t WriteAddr, uint16_t NumByteToWrite)
{
  uint8_t NumOfPage = 0, NumOfSingle = 0, Addr = 0, count = 0, temp = 0;
	
	/*mod运算求余，若writeAddr是SPI_FLASH_PageSize整数倍，运算结果Addr值为0*/
  Addr = WriteAddr % SPI_FLASH_PageSize;
	
	/*差count个数据值，刚好可以对齐到页地址*/
  count = SPI_FLASH_PageSize - Addr;	
	/*计算出要写多少整数页*/
  NumOfPage =  NumByteToWrite / SPI_FLASH_PageSize;
	/*mod运算求余，计算出剩余不满一页的字节数*/
  NumOfSingle = NumByteToWrite % SPI_FLASH_PageSize;

	 /* Addr=0,则WriteAddr 刚好按页对齐 aligned  */
  if (Addr == 0) 
  {
		/* NumByteToWrite < SPI_FLASH_PageSize */
    if (NumOfPage == 0) 
    {
      SPI_FLASH_PageWrite(pBuffer, WriteAddr, NumByteToWrite);
    }
    else /* NumByteToWrite > SPI_FLASH_PageSize */
    {
			/*先把整数页都写了*/
      while (NumOfPage--)
      {
        SPI_FLASH_PageWrite(pBuffer, WriteAddr, SPI_FLASH_PageSize);
        WriteAddr +=  SPI_FLASH_PageSize;
        pBuffer += SPI_FLASH_PageSize;
      }
			
			/*若有多余的不满一页的数据，把它写完*/
      SPI_FLASH_PageWrite(pBuffer, WriteAddr, NumOfSingle);
    }
  }
	/* 若地址与 SPI_FLASH_PageSize 不对齐  */
  else 
  {
		/* NumByteToWrite < SPI_FLASH_PageSize */
    if (NumOfPage == 0) 
    {
			/*当前页剩余的count个位置比NumOfSingle小，写不完*/
      if (NumOfSingle > count) 
      {
        temp = NumOfSingle - count;
				
				/*先写满当前页*/
        SPI_FLASH_PageWrite(pBuffer, WriteAddr, count);
        WriteAddr +=  count;
        pBuffer += count;
				
				/*再写剩余的数据*/
        SPI_FLASH_PageWrite(pBuffer, WriteAddr, temp);
      }
      else /*当前页剩余的count个位置能写完NumOfSingle个数据*/
      {				
        SPI_FLASH_PageWrite(pBuffer, WriteAddr, NumByteToWrite);
      }
    }
    else /* NumByteToWrite > SPI_FLASH_PageSize */
    {
			/*地址不对齐多出的count分开处理，不加入这个运算*/
      NumByteToWrite -= count;
      NumOfPage =  NumByteToWrite / SPI_FLASH_PageSize;
      NumOfSingle = NumByteToWrite % SPI_FLASH_PageSize;

      SPI_FLASH_PageWrite(pBuffer, WriteAddr, count);
      WriteAddr +=  count;
      pBuffer += count;
			
			/*把整数页都写了*/
      while (NumOfPage--)
      {
        SPI_FLASH_PageWrite(pBuffer, WriteAddr, SPI_FLASH_PageSize);
        WriteAddr +=  SPI_FLASH_PageSize;
        pBuffer += SPI_FLASH_PageSize;
      }
			/*若有多余的不满一页的数据，把它写完*/
      if (NumOfSingle != 0)
      {
        SPI_FLASH_PageWrite(pBuffer, WriteAddr, NumOfSingle);
      }
    }
  }
}

 /**
  * @brief  读取FLASH数据
  * @param 	pBuffer，存储读出数据的指针
  * @param   ReadAddr，读取地址
  * @param   NumByteToRead，读取数据长度
  * @retval 无
  */
void SPI_FLASH_BufferRead(uint8_t* pBuffer, uint32_t ReadAddr, uint16_t NumByteToRead)
{
  /* 选择FLASH: CS低电平 */
  SPI_FLASH_CS_LOW();

  /* 发送 读 指令 */
  SPI_FLASH_SendByte(W25X_ReadData);

  /* 发送 读 地址高位 */
  SPI_FLASH_SendByte((ReadAddr & 0xFF0000) >> 16);
  /* 发送 读 地址中位 */
  SPI_FLASH_SendByte((ReadAddr& 0xFF00) >> 8);
  /* 发送 读 地址低位 */
  SPI_FLASH_SendByte(ReadAddr & 0xFF);
  
	/* 读取数据 */
  while (NumByteToRead--)
  {
    *pBuffer = SPI_FLASH_ReadByte();
    /* 指向下一个字节缓冲区 */
    pBuffer++;
  }

  /* 停止信号 FLASH: CS 高电平 */
  SPI_FLASH_CS_HIGH();
}

 /**
  * @brief  读取FLASH ID
  * @param 	无
  * @retval FLASH ID
  */
uint32_t SPI_FLASH_ReadID(void)
{
  uint32_t Temp = 0, Temp0 = 0, Temp1 = 0, Temp2 = 0;

  /* 开始通讯：CS低电平 */
  SPI_FLASH_CS_LOW();

	/* 发送JEDEC指令，读取ID */
  SPI_FLASH_SendByte(W25X_JedecDeviceID);
	
	/* 读取一个字节数据 */
	Temp0 = SPI_FLASH_ReadByte();
	
	/* 读取一个字节数据 */
  Temp1 = SPI_FLASH_ReadByte();
	
	/* 读取一个字节数据 */
  Temp2 = SPI_FLASH_ReadByte();

  /* 停止通讯：CS高电平 */
  SPI_FLASH_CS_HIGH();

	/*把数据组合起来，作为函数的返回值*/
  Temp = (Temp0 << 16) | (Temp1 << 8) | Temp2;

  return Temp;
}


 /**
  * @brief  读取FLASH Device ID
  * @param 	无
  * @retval FLASH Device ID
  */
uint32_t SPI_FLASH_ReadDeviceID(void)
{
  uint32_t Temp = 0;

  /* Select the FLASH: Chip Select low */
  SPI_FLASH_CS_LOW();

  /* Send "RDID " instruction */
	SPI_FLASH_SendByte(W25X_DeviceID);
  SPI_FLASH_SendByte(Dummy_Byte);
  SPI_FLASH_SendByte(Dummy_Byte);
  SPI_FLASH_SendByte(Dummy_Byte);
  
  /* Read a byte from the FLASH */
  Temp = SPI_FLASH_ReadByte();
	
  /* Deselect the FLASH: Chip Select high */
  SPI_FLASH_CS_HIGH();

  return Temp;
}
/*******************************************************************************
* Function Name  : SPI_FLASH_StartReadSequence
* Description    : Initiates a read data byte (READ) sequence from the Flash.
*                  This is done by driving the /CS line low to select the device,
*                  then the READ instruction is transmitted followed by 3 bytes
*                  address. This function exit and keep the /CS line low, so the
*                  Flash still being selected. With this technique the whole
*                  content of the Flash is read with a single READ instruction.
* Input          : - ReadAddr : FLASH's internal address to read from.
* Output         : None
* Return         : None
*******************************************************************************/
void SPI_FLASH_StartReadSequence(uint32_t ReadAddr)
{
  /* Select the FLASH: Chip Select low */
  SPI_FLASH_CS_LOW();

  /* Send "Read from Memory " instruction */
  SPI_FLASH_SendByte(W25X_ReadData);

  /* Send the 24-bit address of the address to read from -----------------------*/
  /* Send ReadAddr high nibble address byte */
  SPI_FLASH_SendByte((ReadAddr & 0xFF0000) >> 16);
  /* Send ReadAddr medium nibble address byte */
  SPI_FLASH_SendByte((ReadAddr& 0xFF00) >> 8);
  /* Send ReadAddr low nibble address byte */
  SPI_FLASH_SendByte(ReadAddr & 0xFF);
}



 /**
  * @brief  使用SPI读取一个字节的数据
  * @param  无
  * @retval 返回接收到的数据
  */
uint8_t SPI_FLASH_ReadByte(void)
{
	uint8_t data = 0xFF;	 
	 
//  SPITimeout = SPIT_FLAG_TIMEOUT;

//  /* 等待接收缓冲区非空，RXNE事件 */
//  while (__HAL_SPI_GET_FLAG( &SpiHandle, SPI_FLAG_RXNE ) == RESET)
//   {
//    if((SPITimeout--) == 0) return SPI_TIMEOUT_UserCallback(1);
//   }

  /* 读取数据寄存器，获取接收缓冲区数据 */
	HAL_SPI_Receive(&SpiHandle,&data,1,0xFFFF);
  return data;
}


 /**
  * @brief  使用SPI发送一个字节的数据
  * @param  byte：要发送的数据
  * @retval 返回接收到的数据
  */
uint8_t SPI_FLASH_SendByte(uint8_t byte)
{
//  SPITimeout = SPIT_FLAG_TIMEOUT;

//  /* 等待发送缓冲区为空，TXE事件 */
//  while (__HAL_SPI_GET_FLAG( &SpiHandle, SPI_FLAG_TXE ) == RESET)
//   {
//    if((SPITimeout--) == 0) return SPI_TIMEOUT_UserCallback(0);
//   }

  /* 写入数据寄存器，把要写入的数据写入发送缓冲区 */
	HAL_SPI_Transmit(&SpiHandle,&byte,1,0xFFFF);
	return NULL;
}


/*******************************************************************************
* Function Name  : SPI_FLASH_SendHalfWord
* Description    : Sends a Half Word through the SPI interface and return the
*                  Half Word received from the SPI bus.
* Input          : Half Word : Half Word to send.
* Output         : None
* Return         : The value of the received Half Word.
*******************************************************************************/
//uint16_t SPI_FLASH_SendHalfWord(uint16_t HalfWord)
//{
//  
//  SPITimeout = SPIT_FLAG_TIMEOUT;

//  /* Loop while DR register in not emplty */
//  while (__HAL_SPI_GET_FLAG( &SpiHandle,  SPI_FLAG_TXE ) == RESET)
//  {
//    if((SPITimeout--) == 0) return SPI_TIMEOUT_UserCallback(2);
//   }

//  /* Send Half Word through the SPIx peripheral */
//  WRITE_REG(SpiHandle.Instance->DR, HalfWord);

//  SPITimeout = SPIT_FLAG_TIMEOUT;

//  /* Wait to receive a Half Word */
//  while (__HAL_SPI_GET_FLAG( &SpiHandle, SPI_FLAG_RXNE ) == RESET)
//   {
//    if((SPITimeout--) == 0) return SPI_TIMEOUT_UserCallback(3);
//   }
//  /* Return the Half Word read from the SPI bus */
//  return READ_REG(SpiHandle.Instance->DR);
//}


 /**
  * @brief  向FLASH发送 写使能 命令
  * @param  none
  * @retval none
  */
void SPI_FLASH_WriteEnable(void)
{
  /* 通讯开始：CS低 */
  SPI_FLASH_CS_LOW();

  /* 发送写使能命令*/
  SPI_FLASH_SendByte(W25X_WriteEnable);

  /*通讯结束：CS高 */
  SPI_FLASH_CS_HIGH();
}

 /**
  * @brief  等待WIP(BUSY)标志被置0，即等待到FLASH内部数据写入完毕
  * @param  none
  * @retval none
  */
void SPI_FLASH_WaitForWriteEnd(void)
{
  uint8_t FLASH_Status = 0;

  /* 选择 FLASH: CS 低 */
  SPI_FLASH_CS_LOW();

  /* 发送 读状态寄存器 命令 */
  SPI_FLASH_SendByte(W25X_ReadStatusReg);

  SPITimeout = SPIT_FLAG_TIMEOUT;
  /* 若FLASH忙碌，则等待 */
  do
  {
    /* 读取FLASH芯片的状态寄存器 */ 
		FLASH_Status = SPI_FLASH_ReadByte();

    {
      if((SPITimeout--) == 0) 
      {
        SPI_TIMEOUT_UserCallback(4);
        return;
      }
    } 
  }
  while ((FLASH_Status & WIP_Flag) == SET); /* 正在写入标志 */

  /* 停止信号  FLASH: CS 高 */
  SPI_FLASH_CS_HIGH();
}


//进入掉电模式
void SPI_Flash_PowerDown(void)   
{ 
  /* 选择 FLASH: CS 低 */
  SPI_FLASH_CS_LOW();

  /* 发送 掉电 命令 */
  SPI_FLASH_SendByte(W25X_PowerDown);

  /* 停止信号  FLASH: CS 高 */
  SPI_FLASH_CS_HIGH();
}   

//唤醒
void SPI_Flash_WAKEUP(void)   
{
  /*选择 FLASH: CS 低 */
  SPI_FLASH_CS_LOW();

  /* 发上 上电 命令 */
  SPI_FLASH_SendByte(W25X_ReleasePowerDown);

  /* 停止信号 FLASH: CS 高 */
  SPI_FLASH_CS_HIGH();                   //等待TRES1
}   


/**
  * @brief  等待超时回调函数
  * @param  None.
  * @retval None.
  */
static  uint16_t SPI_TIMEOUT_UserCallback(uint8_t errorCode)
{
  /* 等待超时后的处理,输出错误信息 */
//	FLASH_ERROR("SPI 等待超时!errorCode = %d",errorCode);
  return 0;
}
   
/************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/

spi.h

#ifndef __SPI_FLASH_H
#define __SPI_FLASH_H

#include "stm32f0xx.h"
#include "main.h"
#include <stdio.h>

/* Private typedef -----------------------------------------------------------*/
//#define  sFLASH_ID                       0xEF3015     //W25X16
//#define  sFLASH_ID                       0xEF4015	    //W25Q16
#define  sFLASH_ID                        0XEF4016      //W25Q32
//#define  sFLASH_ID                       0XEF4017     //W25Q64
//#define  sFLASH_ID                       0XEF4018     //W25Q128


//#define SPI_FLASH_PageSize            4096
#define SPI_FLASH_PageSize              256
#define SPI_FLASH_PerWritePageSize      256

/* Private define ------------------------------------------------------------*/
/*命令定义-开头*******************************/
#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 WIP_Flag                  0x01  /* Write In Progress (WIP) flag */
#define Dummy_Byte                0xFF
/*命令定义-结尾*******************************/


#define SPIx                             SPI2
#define SPIx_CLK_ENABLE()                __HAL_RCC_SPI2_CLK_ENABLE()
#define SPIx_SCK_GPIO_CLK_ENABLE()       __HAL_RCC_GPIOA_CLK_ENABLE()
#define SPIx_MISO_GPIO_CLK_ENABLE()      __HAL_RCC_GPIOA_CLK_ENABLE() 
#define SPIx_MOSI_GPIO_CLK_ENABLE()      __HAL_RCC_GPIOA_CLK_ENABLE() 
#define SPIx_CS_GPIO_CLK_ENABLE()        __HAL_RCC_GPIOA_CLK_ENABLE() 

#define SPIx_FORCE_RESET()               __HAL_RCC_SPI2_FORCE_RESET()
#define SPIx_RELEASE_RESET()             __HAL_RCC_SPI2_RELEASE_RESET()

/* Definition for SPIx Pins */
#define SPIx_SCK_PIN                     GPIO_PIN_13
#define SPIx_SCK_GPIO_PORT               GPIOB

#define SPIx_MISO_PIN                    GPIO_PIN_14
#define SPIx_MISO_GPIO_PORT              GPIOB

#define SPIx_MOSI_PIN                    GPIO_PIN_15
#define SPIx_MOSI_GPIO_PORT              GPIOB

#define FLASH_CS_PIN                     GPIO_PIN_12               
#define FLASH_CS_GPIO_PORT               GPIOB                  


#define	digitalHi(p,i)			    {p->BSRR=i;}			  //设置为高电平		
#define digitalLo(p,i)			    {p->BSRR=(uint32_t)i << 16;}	//输出低电平
#define SPI_FLASH_CS_LOW()      digitalLo(FLASH_CS_GPIO_PORT,FLASH_CS_PIN )
#define SPI_FLASH_CS_HIGH()     digitalHi(FLASH_CS_GPIO_PORT,FLASH_CS_PIN )
/*SPI接口定义-结尾****************************/

/*等待超时时间*/
#define SPIT_FLAG_TIMEOUT         ((uint32_t)0x1000)
#define SPIT_LONG_TIMEOUT         ((uint32_t)(10 * SPIT_FLAG_TIMEOUT))

/*信息输出*/
#define FLASH_DEBUG_ON         1

//#define FLASH_INFO(fmt,arg...)           printf("<<-FLASH-INFO->> "fmt"\n",##arg)
//#define FLASH_ERROR(fmt,arg...)          printf("<<-FLASH-ERROR->> "fmt"\n",##arg)
//#define FLASH_DEBUG(fmt,arg...)          do{\
//                                          if(FLASH_DEBUG_ON)\
//                                          printf("<<-FLASH-DEBUG->> [%d]"fmt"\n",__LINE__, ##arg);\
//                                          }while(0)


void FLASH_GPIO_Init(void);
void SPI_FLASH_Init(void);
void SPI_FLASH_SectorErase(uint32_t SectorAddr);
void SPI_FLASH_BulkErase(void);
void SPI_FLASH_PageWrite(uint8_t* pBuffer, uint32_t WriteAddr, uint16_t NumByteToWrite);
void SPI_FLASH_BufferWrite(uint8_t* pBuffer, uint32_t WriteAddr, uint16_t NumByteToWrite);
void SPI_FLASH_BufferRead(uint8_t* pBuffer, uint32_t ReadAddr, uint16_t NumByteToRead);
uint32_t SPI_FLASH_ReadID(void);
uint32_t SPI_FLASH_ReadDeviceID(void);
void SPI_FLASH_StartReadSequence(uint32_t ReadAddr);
void SPI_Flash_PowerDown(void);
void SPI_Flash_WAKEUP(void);


uint8_t SPI_FLASH_ReadByte(void);
uint8_t SPI_FLASH_SendByte(uint8_t byte);
uint16_t SPI_FLASH_SendHalfWord(uint16_t HalfWord);
void SPI_FLASH_WriteEnable(void);
void SPI_FLASH_WaitForWriteEnd(void);

uint32_t HAL_W25QXX_ReadID(void);
#endif /* __SPI_FLASH_H */

/************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/

关于堆栈大小

很多文章介绍的是需要修改堆栈大小在这里插入图片描述
我也进行了修改，因为cube配置的工程比较难移植到其他程序中。当我测试完毕后，就将usb所需要的文件进行整理，移植到自己建立的工程当中。此时忘记修改堆栈大小，而U盘还能进行读取，未出现错误，这些问题还将继续探索。

实现效果

据其他博主介绍，没有文件系统，需先将U盘格式化，当时电脑的确提示格式化U盘。
在这里插入图片描述
W25Q32只有4MBYTE、32Mbit大小。
在这里插入图片描述
经测试，断电可保存数据

贴上其他文章

链接: https://blog.csdn.net/a3748622/article/details/80347730.
链接: http://news.eeworld.com.cn/mcu/2018/ic-news070140139.html.
其实还有很多优质文章的，一下子找不着了，之后看下能不能补上。
后续也将多写博客，记录自己的学习过程、疑问。

有些屌丝总是嫉妒我
在这里插入图片描述

今天心是冰冰的
关注
基于STM32 USB 模拟U盘 调试成功
08-06
基于STM32 USB 模拟U盘 调试成功 可通过 电脑 操作板载 NANDFLASH SD 是很好的资料
stm32用内存模拟U盘
10-08
用stm32f103模拟U盘，用的是内存，32k
stm32 USB升级：模拟U盘实现固件更新，功能介绍与资料包，使用STM32 USB接口模拟U盘实现固件升级功能
AOWyLsIqMkk的博客
06-10 1577
在实施过程中，需要注意保证固件文件的完整性和正确性，以确保固件升级的成功和设备的正常工作。在嵌入式领域中，有许多方法可以实现固件的升级，而今天我们就将来讨论一种基于STM32芯片的USB升级方案，它利用了STM32的USB接口来模拟一个U盘，从而实现固件的升级。开发Boot程序：根据STM32F103芯片的相关文档，我们可以开发一个Boot程序，通过引脚的状态判断来选择进入Boot模式或正常模式。固件更新：一旦U盘内的固件文件被更新，芯片会自动校验文件的正确性，并将固件更新到内部存储器中。
stm32 W25Q数据存储
最新发布
qq_59953808的博客
09-12 1207
W25Q128 容量为128位 128/8 = 16 也就是16M擦除之前必须写使能写数据的存储单元必须是被擦除过的也就是必须是0XFF，不过不是则写入无效。此图来源于提示：这里对文章进行总结：例如：以上就是今天要讲的内容，本文仅仅简单介绍了pandas的使用，而pandas提供了大量能使我们快速便捷地处理数据的函数和方法。
基于stm32的USB虚拟U盘+FATFS+W25Q64
weixin_44317448的博客
05-05 3313
本文主要结合自己的编程经验有了这篇文章，能够实现简单的USB模拟U盘的实验。在本次实验中，将使用STM32作为从设备使用USB的MSC类，在W25Q64存储ic上移植FATFS。
STM32的USB模拟U盘
热门推荐
qq_43527819的博客
06-28 1万+
使用STM32F103C8T6的USB模拟U盘（亲测GD32F103C8T6也行） 1.打开我的STM32CubeMX，选外部时钟，选SWD调试接口，勾上SPI1外设（使用PB3，PB4，PB5），这些比较简单我就不上图了。 2.勾上我的全速USB设备，其他默认即可，如下图。 3.全速USB选择大容量存取设备，最后一个由512字节改成4096字节（如果是SD卡则使用默认的512字节），其他默认即可，如下图。 4.堆栈改大一点，如下图。 5.在usbd_storage_if.c中把原来的参数屏蔽掉，使用
stm32模拟一个小u盘
02-12
stm32f103，野火的板子模拟一个小u盘，参考借鉴用
USB—SD卡模拟U盘.rar_STM32 U盘_STM32 模拟U盘_stm32 SD 野火_stm32 usb_模拟U盘
07-15
stm32 USB-SD卡模拟U盘，为野火例程
USB.zip_USB—外部FLASH模拟U盘_U盘_stm32_usb 模拟u盘_模拟U盘
07-15
STM32 SPI-FLASH USB MASS STORAGE 实验(模拟U盘)
USB—外部FLASH模拟U盘.zip_STM32 W25Q32_U盘读写_combine8me_stm32 u盘 w25_模
07-15
3. **Class驱动**：为了模拟U盘，固件需要实现Mass Storage Class驱动，遵循Bulk-Only Transport协议，这是U盘常用的传输协议。 4. **SPI通信**：固件通过SPI接口与W25Q32交互，完成数据的读写操作。 5. **文件...
STM32 USB模拟一个串口和U盘存储器复合设备
11-25
STM32 USB模拟一个串口和U盘存储器复合设备是一项高级嵌入式技术，它允许STM32微控制器（MCU）同时扮演串行通信接口（如虚拟COM口）和USB存储设备的角色。这样的功能使得STM32能够与PC或其他支持USB的设备进行数据...
用STM32CubeMX快速生成一个U盘模拟程序
10-10
基于MDK V5和STM32CubeMX，图文并茂；。。完成后，就可以双击打开这个“U盘”了，这是一个可以进行读写的U盘。 将这个U盘弹出，然后断开USB链接线，然后再重新连接，就可以被360 U盘助手发现了。 实际可用空间为81920字节。
零死角玩转stm32-高级篇-UsbDevice（模拟U盘）
06-15
零死角玩转stm32-高级篇-UsbDevice（模拟U盘），简单易懂的教程，免费开源的资料，免费下载
STM32 USB HS接口外部SD卡模拟成U盘
10-11
修改野火的源码资料，将外部Flash模拟成U盘的例程改为将外部SD卡模拟成U盘。
STM32 实现U盘功能 USB-Mass_Storage
04-23
该程序是STM32实现U盘功能可以直接跑，只需更改FLASH的端口，flash使用W25X16,可以以此做为STM32学习USB功能的易懂程序
stm32f103 虚拟U盘，调试成功的
12-12
stm32f103 虚拟U盘，自己调试成功的，U盘大小约5kb，可以正常使用的
STM32系列MCU模拟双盘符U盘的应用_STM32系列MCU模拟双盘符U盘的应用_
10-04
4. **硬件设计**：STM32需要有足够的存储空间来模拟U盘的存储空间。这可能需要连接外部Flash存储器，如SPI或I2C接口的NAND或Nor Flash。同时，确保MCU的GPIO引脚能够配置为USB接口所需的信号线。 5. **固件开发**：...
STM32CubeMX学习笔记（48）——USB接口使用（MSC基于外部Flash模拟U盘）
Leung的博客
11-23 7859
USB大容量存储设备类（The USB mass storage device class）是一种计算机和移动设备之间的传输协议，它允许一个通用串行总线（USB）设备来访问主机的计算设备，使两者之间进行文件传输。通过这个标准的计算机连接到的设备包括：移动硬盘、移动光驱、U盘、SD、TF等储存卡读卡器、数码相机、各种数字音频播放器和便携式媒体播放器、智能卡阅读器、掌上电脑和手机。
STM32外挂FLASH模拟U盘（基于HAL库）
Mi_Story的博客
04-17 8351
STM32外挂FLASH模拟U盘（基于HAL库）1、背景1.1这篇文章能给你带来什么1.2根据你要解决的问题，精确快速跳转到相应位置1.3我在做完这个后还有不明白的地方，希望能有大触解答困惑2、相关的知识储备2.1、FLASH芯片的相关知识Point1--FLASH的块儿、扇区、页、字节之间的关系2.2、SPI通信2.3、STM32模拟U盘原理3、外挂FLASH有什么作用4、制作模拟U盘的流程和难点分析4.1制作模拟U盘的流程4.2难点1：全程懵逼，不知道如何下手4.3难点2：不知道该如何写W25QXX驱动
stm32 usb模拟u盘
05-25
实现 STM32 USB 模拟 U 盘的方法如下： 1. 首先，在 STM32 中配置 USB 设备模式，使其成为 USB 主机。 2. 然后，将 STM32 的存储器映射到 USB 设备上，作为 U 盘的存储器。 3. 接下来，实现 USB 设备的文件系统，在其中创建文件和文件夹，以模拟 U 盘的文件系统。 4. 最后，通过 USB 接口与计算机连接，在计算机上识别 STM32 为 U 盘，并读写其中的文件。 需要注意的是，实现 USB 模拟 U 盘需要掌握一定的 USB 协议知识和 STM32 的 USB 库的使用方法。同时，还需要对文件系统有一定的了解。
评论 6
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值