STM32F405外部FLASH模拟U盘HAL CubeMx

最新推荐文章于 2024-09-06 22:37:59 发布
最新推荐文章于 2024-09-06 22:37:59 发布
阅读量608 收藏 14
点赞数 6
文章标签： stm32 嵌入式硬件 单片机
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_43289353/article/details/140163275
版权

硬件

单片机：STM32F405RGT6
外部Flash芯片：W25Q128

引脚说明

在这里插入图片描述
设置好RCC和SYS后接下来配置：

SPI设置
在这里插入图片描述
CS引脚配置
在这里插入图片描述

USB设置
在这里插入图片描述
USB驱动设置
在这里插入图片描述
这里是时钟配置
在这里插入图片描述
设置堆栈大小
在这里插入图片描述
然后生成代码

外部FLASH驱动文件

新建一个 W25qxx.h 头文件

// W25qxx.h 
#ifndef __SPI_FLASH_H
#define __SPI_FLASH_H

#include "stm32f4xx.h"
#include "stm32f4xx_hal_spi.h"
#include "stm32f4xx_hal.h"

/* ----------------------------------------------------------------*/

#define SPI_FLASH_REBUILD 0            // 
#define SPI_FLASH_SECTOR_SIZE 4096     // 
#define SPI_FLASH_START_SECTOR 256 * 4 // 
#define SPI_FLASH_SECTOR_COUNT 256     //

// 使用SPI3
#define FLASH_SPI_Handle hspi3

// W25Qxx系列芯片的ID
// 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

#define FLASH_ID W25Q128

// SPI字段
extern SPI_HandleTypeDef FLASH_SPI_Handle;
extern uint16_t W25qxx_TYPE;

// 设置CS引脚 高低电平 宏定义
#define W25QXX_CS_1 HAL_GPIO_WritePin(GPIOD, GPIO_PIN_2, GPIO_PIN_SET)
#define W25QXX_CS_0 HAL_GPIO_WritePin(GPIOD, GPIO_PIN_2, GPIO_PIN_RESET)

/* ----------------------------------------------------------------*/

//
#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);
void W25qxx_WAKEUP(void);
void SPI_FLASH_SectorErase(uint32_t SectorAddr);
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);
void SPI_FLASH_PageWrite(uint8_t *pBuffer, uint32_t WriteAddr, uint16_t NumByteToWrite);

#endif /* __SPI_FLASH_H */

新建一个 W25qxx.c 文件

#include "./W25qxx/W25qxx.h"
#include "stm32f4xx_hal_gpio.h"
#include "stdio.h"
// #include "board.h"
uint16_t W25qxx_TYPE = FLASH_ID;
extern SPI_HandleTypeDef FLASH_SPI_Handle;

uint8_t W25qxx_ReadSR(uint8_t regno);            //
void W25qxx_4ByteAddr_Enable(void);              //
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);    //
void W25qxx_Write(uint8_t *pBuffer, uint32_t WriteAddr, uint16_t NumByteToWrite); //
void W25qxx_Erase_Chip(void);                                                     //
void W25qxx_Erase_Sector(uint32_t Dst_Addr);                                      //
void W25qxx_Wait_Busy(void);                                                      //
void W25qxx_PowerDown(void);                                                      //

// SPI 读写字节
uint8_t SPI_ReadWriteByte(uint8_t TxData)
{
    uint8_t Rxdata;
    HAL_SPI_TransmitReceive(&FLASH_SPI_Handle, &TxData, &Rxdata, 1, 1000);
    return Rxdata;
}
// SPI设置速度
void SPI2_SetSpeed(uint8_t SPI_BaudRatePrescaler)
{
    assert_param(IS_SPI_BAUDRATE_PRESCALER(SPI_BaudRatePrescaler));
    __HAL_SPI_DISABLE(&FLASH_SPI_Handle);
    FLASH_SPI_Handle.Instance->CR1 &= 0xFFC7;
    FLASH_SPI_Handle.Instance->CR1 |= SPI_BaudRatePrescaler;
    __HAL_SPI_ENABLE(&FLASH_SPI_Handle);
}

// 初始化引脚
void W25qxx_Init(void)
{
    uint8_t temp;
    GPIO_InitTypeDef GPIO_Initure;

    __HAL_RCC_GPIOD_CLK_ENABLE(); //
    // PD2
    GPIO_Initure.Pin = GPIO_PIN_2;             // PD2
    GPIO_Initure.Mode = GPIO_MODE_OUTPUT_PP;   // 设置推挽
    GPIO_Initure.Pull = GPIO_PULLUP;           // 设置上拉
    GPIO_Initure.Speed = GPIO_SPEED_FREQ_HIGH; // 设置高速
    W25QXX_CS_1;                               // 默认高电平
    SPI2_SetSpeed(SPI_BAUDRATEPRESCALER_2);    //
    W25qxx_TYPE = W25qxx_ReadID();             // 读取FLASH芯片的ID
    if (W25qxx_TYPE == FLASH_ID)               //
    {
        temp = W25qxx_ReadSR(3);
        if ((temp & 0x01) == 0)
        {
            W25QXX_CS_0;
            SPI_ReadWriteByte(W25X_Enable4ByteAddr);
            W25QXX_CS_1;
        }
    }
}
//
uint8_t W25qxx_ReadSR(uint8_t regno)
{
    uint8_t byte = 0, command = 0;
    switch (regno)
    {
    case 1:
        command = W25X_ReadStatusReg1;
        break;
    case 2:
        command = W25X_ReadStatusReg2;
        break;
    case 3:
        command = W25X_ReadStatusReg3;
        break;
    default:
        command = W25X_ReadStatusReg1;
        break;
    }
    W25QXX_CS_0;                    //
    SPI_ReadWriteByte(command);     //
    byte = SPI_ReadWriteByte(0xff); //
    W25QXX_CS_1;                    //
    return byte;
}
//
void W25qxx_Write_SR(uint8_t regno, uint8_t sr)
{
    uint8_t command = 0;
    switch (regno)
    {
    case 1:
        command = W25X_WriteStatusReg1; //
        break;
    case 2:
        command = W25X_WriteStatusReg2; //
        break;
    case 3:
        command = W25X_WriteStatusReg3; //
        break;
    default:
        command = W25X_WriteStatusReg1;
        break;
    }
    W25QXX_CS_0;                //
    SPI_ReadWriteByte(command); //
    SPI_ReadWriteByte(sr);      //
    W25QXX_CS_1;                //
}
// W25QXX
void W25qxx_Write_Enable(void)
{
    W25QXX_CS_0;                         //
    SPI_ReadWriteByte(W25X_WriteEnable); //
    W25QXX_CS_1;                         //
}
// W25QXX
void W25qxx_Write_Disable(void)
{
    W25QXX_CS_0;                          //
    SPI_ReadWriteByte(W25X_WriteDisable); //
    W25QXX_CS_1;                          //
}

// 读取 W25Qxx系列芯片的ID
// W25Q80  ID  0xEF13
// W25Q16  ID  0xEF14
// W25Q32  ID  0xEF15
// W25Q64  ID  0xEF16
// W25Q128 ID  0xEF17
// W25Q256 ID  0xEF18
uint16_t W25qxx_ReadID(void)
{
    uint16_t Temp = 0;
    W25QXX_CS_0;
    SPI_ReadWriteByte(0x90);
    SPI_ReadWriteByte(0x00);
    SPI_ReadWriteByte(0x00);
    SPI_ReadWriteByte(0x00);
    Temp |= SPI_ReadWriteByte(0xFF) << 8;
    Temp |= SPI_ReadWriteByte(0xFF);
    W25QXX_CS_1;
    return Temp;
}
//
void W25qxx_Read(uint8_t *pBuffer, uint32_t ReadAddr, uint16_t NumByteToRead)
{
    uint16_t i;
    W25QXX_CS_0;                      //
    SPI_ReadWriteByte(W25X_ReadData); //
    //    if(W25qxx_TYPE==FLASH_ID)                //W25Q256ĻַΪ4ֽڵģҪ8λ
    //    {
    //        SPI_ReadWriteByte((uint8_t)((ReadAddr)>>24));
    //    }
    SPI_ReadWriteByte((uint8_t)((ReadAddr) >> 16)); // 24bitַ
    SPI_ReadWriteByte((uint8_t)((ReadAddr) >> 8));
    SPI_ReadWriteByte((uint8_t)ReadAddr);
    for (i = 0; i < NumByteToRead; i++)
    {
        pBuffer[i] = SPI_ReadWriteByte(0xFF); // ѭ
    }
    W25QXX_CS_1;
}
/**
 * @brief   FLASH
 * @param 	pBuffer洢ݵָ
 * @param   ReadAddrȡַ
 * @param   NumByteToReadȡݳ
 * @retval
 */
void SPI_FLASH_BufferRead(uint8_t *pBuffer, uint32_t ReadAddr, uint16_t NumByteToRead)
{
    W25QXX_CS_0;
    SPI_ReadWriteByte(W25X_ReadData);
    SPI_ReadWriteByte((ReadAddr & 0xFF0000) >> 16);
    SPI_ReadWriteByte((ReadAddr & 0xFF00) >> 8);
    SPI_ReadWriteByte(ReadAddr & 0xFF);
    while (NumByteToRead--)
    {
        *pBuffer = SPI_ReadWriteByte(0xFF);
        pBuffer++;
    }
    W25QXX_CS_1;
}

#define WIP_Flag 0x01

/**
 * @brief  ȴWIP(BUSY)־0ȴFLASHڲд
 * @param  none
 * @retval none
 */
void SPI_FLASH_WaitForWriteEnd(void)
{
    uint8_t FLASH_Status = 0;
    W25QXX_CS_0;
    SPI_ReadWriteByte(W25X_ReadStatusReg1);
    do
    {
        FLASH_Status = SPI_ReadWriteByte(0xFF);
    } while ((FLASH_Status & WIP_Flag) == SET);
    W25QXX_CS_1;
}

/**
 * @brief  FLASH
 * @param  SectorAddrҪַ
 * @retval
 */
void SPI_FLASH_SectorErase(uint32_t SectorAddr)
{
    W25qxx_Write_Enable();
    SPI_FLASH_WaitForWriteEnd();
    W25QXX_CS_0;
    SPI_ReadWriteByte(W25X_SectorErase);
    SPI_ReadWriteByte((uint8_t)((SectorAddr) >> 16)); // 24bitַ
    SPI_ReadWriteByte((uint8_t)((SectorAddr) >> 8));
    SPI_ReadWriteByte(SectorAddr & 0xFF);
    W25QXX_CS_1;
    SPI_FLASH_WaitForWriteEnd();
}

#define SPI_FLASH_PageSize 256
#define SPI_FLASH_PerWritePageSize 256
/**
 * @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)
{
    W25qxx_Write_Enable();
    W25QXX_CS_0;
    SPI_ReadWriteByte(W25X_PageProgram);
    SPI_ReadWriteByte((WriteAddr & 0xFF0000) >> 16);
    SPI_ReadWriteByte((WriteAddr & 0xFF00) >> 8);
    SPI_ReadWriteByte(WriteAddr & 0xFF);
    if (NumByteToWrite > SPI_FLASH_PageSize)
    {
        NumByteToWrite = SPI_FLASH_PerWritePageSize;
    }
    while (NumByteToWrite--)
    {
        SPI_ReadWriteByte(*pBuffer);
        pBuffer++;
    }
    W25QXX_CS_1;
    SPI_FLASH_WaitForWriteEnd();
}

//
void W25qxx_Write_Page(uint8_t *pBuffer, uint32_t WriteAddr, uint16_t NumByteToWrite)
{
    uint16_t i;
    W25qxx_Write_Enable();
    W25QXX_CS_0;
    SPI_ReadWriteByte(W25X_PageProgram);
    //    if(W25qxx_TYPE==FLASH_ID)
    //    {
    //        SPI_ReadWriteByte((uint8_t)((WriteAddr)>>24));
    //    }
    SPI_ReadWriteByte((uint8_t)((WriteAddr) >> 16)); // 24bitַ
    SPI_ReadWriteByte((uint8_t)((WriteAddr) >> 8));
    SPI_ReadWriteByte((uint8_t)WriteAddr);
    for (i = 0; i < NumByteToWrite; i++)
        SPI_ReadWriteByte(pBuffer[i]); //
    W25QXX_CS_1;                       //
    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;
    Addr = WriteAddr % SPI_FLASH_PageSize;
    count = SPI_FLASH_PageSize - Addr;
    NumOfPage = NumByteToWrite / SPI_FLASH_PageSize;
    NumOfSingle = NumByteToWrite % SPI_FLASH_PageSize;
    if (Addr == 0)
    {
        if (NumOfPage == 0)
        {
            SPI_FLASH_PageWrite(pBuffer, WriteAddr, NumByteToWrite);
        }
        else
        {
            while (NumOfPage--)
            {
                SPI_FLASH_PageWrite(pBuffer, WriteAddr, SPI_FLASH_PageSize);
                WriteAddr += SPI_FLASH_PageSize;
                pBuffer += SPI_FLASH_PageSize;
            }
            SPI_FLASH_PageWrite(pBuffer, WriteAddr, NumOfSingle);
        }
    }
    else
    {
        if (NumOfPage == 0)
        {
            if (NumOfSingle > count)
            {
                temp = NumOfSingle - count;
                SPI_FLASH_PageWrite(pBuffer, WriteAddr, count);
                WriteAddr += count;
                pBuffer += count;
                SPI_FLASH_PageWrite(pBuffer, WriteAddr, temp);
            }
            else
            {
                SPI_FLASH_PageWrite(pBuffer, WriteAddr, NumByteToWrite);
            }
        }
        else
        {
            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);
            }
        }
    }
}

//
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
        {
            pBuffer += pageremain;
            WriteAddr += pageremain;

            NumByteToWrite -= pageremain;
            if (NumByteToWrite > 256)
                pageremain = 256;
            else
                pageremain = NumByteToWrite;
        }
    };
}
//
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; //
    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++;   //
            secoff = 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;                       //
    SPI_ReadWriteByte(W25X_ChipErase); //
    W25QXX_CS_1;                       //
    W25qxx_Wait_Busy();                //
}
//
void W25qxx_Erase_Sector(uint32_t Dst_Addr)
{
    Dst_Addr *= 4096;
    W25qxx_Write_Enable(); // SET WEL
    W25qxx_Wait_Busy();
    W25QXX_CS_0;                         //
    SPI_ReadWriteByte(W25X_SectorErase); //
    if (W25qxx_TYPE == FLASH_ID)         //
    {
        SPI_ReadWriteByte((uint8_t)((Dst_Addr) >> 24));
    }
    SPI_ReadWriteByte((uint8_t)((Dst_Addr) >> 16)); // 24bitַ
    SPI_ReadWriteByte((uint8_t)((Dst_Addr) >> 8));
    SPI_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;                       //
    SPI_ReadWriteByte(W25X_PowerDown); //
    W25QXX_CS_1;                       //
    // delay_us(3);                            //
}
//
void W25qxx_WAKEUP(void)
{
    W25QXX_CS_0;                              //
    SPI_ReadWriteByte(W25X_ReleasePowerDown); //
    W25QXX_CS_1;                              //
    // delay_us(3);                            //
}

将以上俩文件都放在一个文件里(W25qxx)
在这里插入图片描述
然后引入到项目中
在这里插入图片描述
打开 usbd_storage_if.c 文件
在这里插入图片描述
引入外部FLASH驱动头文件

#include "./W25qxx/W25qxx.h"

修改这里的宏定义（每次使用CubeMx生成代码后，这里都需要再重新设置一次）

#define STORAGE_LUN_NBR                  1
#define STORAGE_BLK_NBR                  4096  // 256*16扇区=16MByte   更改FLASH大小更改这里就可以
#define STORAGE_BLK_SIZ                  4096  // 每个扇区4096Byte

修改以下函数内的内容

int8_t STORAGE_Init_FS(uint8_t lun)
{
    /* USER CODE BEGIN 2 */
    // UNUSED(lun);
    W25qxx_Init();
    return (USBD_OK);
    /* USER CODE END 2 */
}

int8_t STORAGE_GetCapacity_FS(uint8_t lun, uint32_t *block_num, uint16_t *block_size)
{
    /* USER CODE BEGIN 3 */
    UNUSED(lun);
    *block_num = STORAGE_BLK_NBR;
    *block_size = STORAGE_BLK_SIZ;
    return (USBD_OK);
    /* USER CODE END 3 */
}

int8_t STORAGE_Read_FS(uint8_t lun, uint8_t *buf, uint32_t blk_addr, uint16_t blk_len)
{
    /* USER CODE BEGIN 6 */
    // UNUSED(lun);
    // UNUSED(buf);
    // UNUSED(blk_addr);
    // UNUSED(blk_len);
    blk_addr += SPI_FLASH_START_SECTOR;
    SPI_FLASH_BufferRead(buf, blk_addr * SPI_FLASH_SECTOR_SIZE, blk_len * SPI_FLASH_SECTOR_SIZE);
    return (USBD_OK);
    /* USER CODE END 6 */
}

int8_t STORAGE_Write_FS(uint8_t lun, uint8_t *buf, uint32_t blk_addr, uint16_t blk_len)
{
    /* USER CODE BEGIN 7 */
    // UNUSED(lun);
    // UNUSED(buf);
    // UNUSED(blk_addr);
    // UNUSED(blk_len);
    uint32_t write_addr;
    blk_addr += SPI_FLASH_START_SECTOR;
    write_addr = blk_addr * SPI_FLASH_SECTOR_SIZE;
    SPI_FLASH_SectorErase(write_addr);
    SPI_FLASH_BufferWrite((uint8_t *)buf, write_addr, blk_len * SPI_FLASH_SECTOR_SIZE);
    return (USBD_OK);
    /* USER CODE END 7 */
}

修改后完整的代码(usbd_storage_if.c)


/* USER CODE BEGIN Header */
/**
 ******************************************************************************
 * @file           : usbd_storage_if.c
 * @version        : v1.0_Cube
 * @brief          : Memory management layer.
 ******************************************************************************
 * @attention
 *
 * Copyright (c) 2024 STMicroelectronics.
 * All rights reserved.
 *
 * This software is licensed under terms that can be found in the LICENSE file
 * in the root directory of this software component.
 * If no LICENSE file comes with this software, it is provided AS-IS.
 *
 ******************************************************************************
 */
/* USER CODE END Header */

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

/* USER CODE BEGIN INCLUDE */
#include "./W25qxx/W25qxx.h"
/* USER CODE END INCLUDE */

/* Private typedef -----------------------------------------------------------*/
/* Private define ------------------------------------------------------------*/
/* Private macro -------------------------------------------------------------*/

/* USER CODE BEGIN PV */
/* Private variables ---------------------------------------------------------*/

/* USER CODE END PV */

/** @addtogroup STM32_USB_OTG_DEVICE_LIBRARY
 * @brief Usb device.
 * @{
 */

/** @defgroup USBD_STORAGE
 * @brief Usb mass storage device module
 * @{
 */

/** @defgroup USBD_STORAGE_Private_TypesDefinitions
 * @brief Private types.
 * @{
 */

/* USER CODE BEGIN PRIVATE_TYPES */

/* USER CODE END PRIVATE_TYPES */

/**
 * @}
 */

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

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

/* USER CODE BEGIN PRIVATE_DEFINES */
#define STORAGE_LUN_NBR 1
#define STORAGE_BLK_NBR 4096
#define STORAGE_BLK_SIZ 4096
/* USER CODE END PRIVATE_DEFINES */

/**
 * @}
 */

/** @defgroup USBD_STORAGE_Private_Macros
 * @brief Private macros.
 * @{
 */

/* USER CODE BEGIN PRIVATE_MACRO */

/* USER CODE END PRIVATE_MACRO */

/**
 * @}
 */

/** @defgroup USBD_STORAGE_Private_Variables
 * @brief Private variables.
 * @{
 */

/* 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 */
};
/* USER CODE END INQUIRY_DATA_FS */

/* USER CODE BEGIN PRIVATE_VARIABLES */

/* USER CODE END PRIVATE_VARIABLES */

/**
 * @}
 */

/** @defgroup USBD_STORAGE_Exported_Variables
 * @brief Public variables.
 * @{
 */

extern USBD_HandleTypeDef hUsbDeviceFS;

/* USER CODE BEGIN EXPORTED_VARIABLES */

/* USER CODE END EXPORTED_VARIABLES */

/**
 * @}
 */

/** @defgroup USBD_STORAGE_Private_FunctionPrototypes
 * @brief Private functions declaration.
 * @{
 */

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);

/* USER CODE BEGIN PRIVATE_FUNCTIONS_DECLARATION */

/* USER CODE END PRIVATE_FUNCTIONS_DECLARATION */

/**
 * @}
 */

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 the storage unit (medium) over USB FS IP
 * @param  lun: Logical unit number.
 * @retval USBD_OK if all operations are OK else USBD_FAIL
 */
int8_t STORAGE_Init_FS(uint8_t lun)
{
    /* USER CODE BEGIN 2 */
    // UNUSED(lun);

    W25qxx_Init();

    return (USBD_OK);
    /* USER CODE END 2 */
}

/**
 * @brief  Returns the medium capacity.
 * @param  lun: Logical unit number.
 * @param  block_num: Number of total block number.
 * @param  block_size: 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 */
    UNUSED(lun);
    *block_num = STORAGE_BLK_NBR;
    *block_size = STORAGE_BLK_SIZ;
    return (USBD_OK);
    /* USER CODE END 3 */
}

/**
 * @brief   Checks whether the medium is ready.
 * @param  lun:  Logical unit number.
 * @retval USBD_OK if all operations are OK else USBD_FAIL
 */
int8_t STORAGE_IsReady_FS(uint8_t lun)
{
    /* USER CODE BEGIN 4 */
    // uint16_t flash_ID;
    // flash_ID = W25QXX_ReadID();

    return (USBD_OK);
    /* USER CODE END 4 */
}

/**
 * @brief  Checks whether the medium is write protected.
 * @param  lun: Logical unit number.
 * @retval USBD_OK if all operations are OK else USBD_FAIL
 */
int8_t STORAGE_IsWriteProtected_FS(uint8_t lun)
{
    /* USER CODE BEGIN 5 */
    UNUSED(lun);

    return (USBD_OK);
    /* USER CODE END 5 */
}

/**
 * @brief  Reads data from the medium.
 * @param  lun: Logical unit number.
 * @param  buf: data buffer.
 * @param  blk_addr: Logical block address.
 * @param  blk_len: Blocks number.
 * @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 */
    // UNUSED(lun);
    // UNUSED(buf);
    // UNUSED(blk_addr);
    // UNUSED(blk_len);
    blk_addr += SPI_FLASH_START_SECTOR;
    SPI_FLASH_BufferRead(buf, blk_addr * SPI_FLASH_SECTOR_SIZE, blk_len * SPI_FLASH_SECTOR_SIZE);
    return (USBD_OK);
    /* USER CODE END 6 */
}

/**
 * @brief  Writes data into the medium.
 * @param  lun: Logical unit number.
 * @param  buf: data buffer.
 * @param  blk_addr: Logical block address.
 * @param  blk_len: Blocks number.
 * @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 */
    // UNUSED(lun);
    // UNUSED(buf);
    // UNUSED(blk_addr);
    // UNUSED(blk_len);
    uint32_t write_addr;
    blk_addr += SPI_FLASH_START_SECTOR;
    write_addr = blk_addr * SPI_FLASH_SECTOR_SIZE;
    SPI_FLASH_SectorErase(write_addr);
    SPI_FLASH_BufferWrite((uint8_t *)buf, write_addr, blk_len * SPI_FLASH_SECTOR_SIZE);
    return (USBD_OK);
    /* USER CODE END 7 */
}

/**
 * @brief  Returns the Max Supported LUNs.
 * @param  None
 * @retval Lun(s) number.
 */
int8_t STORAGE_GetMaxLun_FS(void)
{
    /* USER CODE BEGIN 8 */
    return (STORAGE_LUN_NBR - 1);
    /* USER CODE END 8 */
}

/* USER CODE BEGIN PRIVATE_FUNCTIONS_IMPLEMENTATION */

/* USER CODE END PRIVATE_FUNCTIONS_IMPLEMENTATION */

/**
 * @}
 */

/**
 * @}
 */

最后编译烧录

测试

第一次插入电脑会提示格式化，格式化以后就会变成U盘了，往里边丢文件测试完成
在这里插入图片描述

摸鱼的码农族
关注
USB—外部flash && SD卡模拟U盘_stm32_USB-外部flash、模拟U盘_
10-02
基于STM32的Usb-外部 flash驱动代码 Usb U盘
USB.zip_USB—外部FLASH模拟U盘_U盘_stm32_usb 模拟u盘_模拟U盘
07-15
STM32 SPI-FLASH USB MASS STORAGE 实验(模拟U盘)
USB-SPI Flash模拟U盘
gitblog_09742的博客
09-06 375
USB-SPI Flash模拟U盘 USB-SPIFlash模拟U盘.zip项目地址:https://gitcode.com/open-source-toolkit/791fb 项目简介 本项目提供了一个基于STM32的外部SPI Flash模拟U盘的例程。通过该例程，您可以实现将外部Flash中的程序通过USB接口模拟成U盘，从而方便地进行程序更新。 功能描述 USB模拟U盘：将STM32的...
STM32外挂FLASH模拟U盘（基于HAL库）
Mi_Story的博客
04-17 8225
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基于HAL库驱动外部SPI flash制作虚拟U盘
perseverance51博客
08-25 2861
stm32基于HAL库驱动外部SPI flash制作虚拟U盘
USB—外部FLASH模拟U盘.zip_STM32 W25Q32_U盘读写_combine8me_stm32 u盘 w25_模
07-15
此代码为stm32将外部flash如w25q32模拟成U盘，对内部数据进行读写操作，此工程已经验证通过，希望对大家用一定的帮助
USB—外部FLASH模拟U盘 W25Q128.zip
12-31
使用STM32F4的外部FLASH(W25Q128)作为U盘，代码清楚，逻辑清晰，可以快速完成开发，FLASH本身有16M空间，该文档配置了FLASH的6-16M空间作为U盘使用，U盘大小为10M。
STMFLASH_STM32F405内部FLASH_
09-29
STM32F405是意法半导体（STMicroelectronics）推出的一款基于ARM Cortex-M4内核的微控制器，其内部集成了丰富的外设，包括一个高性能的内部Flash存储器。在嵌入式开发中，理解和高效利用STM32F405的内部Flash对于...
HAL库+CubeMX+Stm32F405实现串口DMA不定长收发
07-25
STM32F405系列微控制器是基于ARM ...总的来说，通过HAL库和CubeMX，我们可以方便地在STM32F405上配置串口DMA，实现高效、灵活的不定长数据收发。这种技术在实时性要求高的应用中尤其有用，如工业通信、数据采集等。
HAL库+CubeMX+Stm32F405 实现串口定长收发、printf函数使用、自定义打印函数
07-23
HAL库+CubeMX+Stm32F405 实现串口定长收发、printf函数使用、自定义打印函数 详情请看：https://lindoglog.blog.csdn.net/article/details/107463926
STM32F405工程模板_STM32F405工程模板_stm32f405_
09-30
STM32F405是一款基于ARM Cortex-M4内核的微控制器，由意法半导体（STMicroelectronics）生产。...在使用前，建议先熟悉STM32F405的数据手册和HAL库的文档，以便更好地理解和利用模板中的各项资源。
USB—外部FLASH模拟U盘_模拟外置U盘_USB外部FLASH模拟U盘_proteus_
10-04
这是 USB—外部FLASH模拟U盘 可用Proteus 进行仿真
STM32 USB 使用内部flash模拟U盘
02-26
使用芯片STM32F103，系统ucosii,通过USB插入电脑，电脑识别芯片内部flash为U盘
stm32模拟一个小u盘
02-12
stm32f103，野火的板子模拟一个小u盘，参考借鉴用
USB—外部FLASH模拟U盘.zip_FLASH 模拟U盘_USB flash stm32_stm32 mass_mal.c
07-15
利用stm32单片机，对外部flash作为模拟优盘
stm32用内存模拟U盘
10-08
用stm32f103模拟U盘，用的是内存，32k
使用STM32cube生成STM32F405RGTx的CAN2通信测试程序
03-10
总结，本文详细介绍了如何使用STM32CubeMX配置和生成STM32F405RGTx的CAN2通信测试程序，涉及了CAN2接口配置、HAL库使用、中断编程以及通过CAN转USB实现收发数据的流程。通过这样的实践，开发者可以更好地理解和掌握...
20230412-使用STM32实现内部flash模拟U盘
湮雨塵飛的博客
04-13 2557
​ 工程师干了几年后，基本会有小外包的生活，算是赚外快吧，搞小钱改善伙食，嘻嘻。。。。​ 最近有个客户找到我，说是否通过ST的单片机搞个U盘功能，有些文件通过U盘拖拽放入的方式比较方便。当时就有点懵了，这从来没这么用过，后来查查资料，还真网上有这么玩的，所以就记录下自己的实现过程​ 既然要搞，一般过程都是网上找个demo，看懂了然后自己改改，我也是这么干的。。。。
【电子技术】【2014.11】基于STM32F405的USB通信
weixin_42825609的博客
11-17 1229
本文为瑞典布莱金厄理工学院（作者：DONATAS KATEIVA）的学士论文，共22页。 本文的目标是测试定制板与PC机之间的高速USB 2.0通信。波罗的海工程公司开发了一个基于ST微电子公司微控制器的硬件平台。单片机STM32F405具有多种外围功能，其中之一是高速USB2.0 OTG单元。波罗的海工程公司正计划在未来的项目中使用此功能，但目前他们还没有为这种通信链路实现软件代码的经验。工作重点是编程并建立PC机与微控制器之间的连接。介绍了如何使用CooCox-CoIDE建立开发环境，以及如何借助li.
STM32F405VGTx flash
最新发布
09-12
STM32F405VGTx是ST公司生产的一款高性能的ARM Cortex-M4微控制器，它属于STM32F4系列。这款微控制器拥有广泛的存储容量选项，其中"VGTx"是产品型号的一部分，它指明了设备的具体配置，包括内存大小。STM32F405VGTx通常拥有较大的闪存（flash）存储空间，这对于存储程序代码和数据非常重要。 STM32F405VGTx微控制器的闪存大小为1024 KB，这意味着它可以存储多达1024千字节的数据。在编程和应用开发中，这个闪存区域通常用于存储固件或应用程序代码。由于STM32F405VGTx具有较大的闪存容量，它能够支持较为复杂的应用程序，甚至可以在不需要外部存储器的情况下，执行存储密集型任务。 闪存在微控制器中的作用非常关键，因为它是非易失性存储器，即在断电后仍能保持信息不丢失。这对于存储程序代码非常有用，因为每次设备重启时，可以从闪存中读取并执行代码。此外，STM32F405VGTx还具有灵活的内存管理特性，支持多种不同的闪存读取保护级别和编程功能。 在使用STM32F405VGTx时，开发者需要通过适当的开发环境（如Keil uVision、IAR Embedded Workbench等）进行编程。这些环境提供了必要的工具链，包括编译器、调试器和闪存编程器，用于将编译好的程序代码烧写到微控制器的闪存中。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值