STM32移植USB-HOST，MSC（读U盘）
下载官方例程后移植以下文件，.h全部放进文件夹

其中主要修改usbh_usr.c 文件，其他的根据编译提示进行调整。

添加连个定义

直接返回OK
然后自己代码写在USBH_USR_MSC_Application函数里

int USBH_USR_MSC_Application(void)
{
  FRESULT res;
  static BOOL fgUsbInputFirst=TRUE;
  switch(USBH_USR_ApplicationState)
  {
	case USH_USR_FS_INIT: //初始化文件系统
	res = f_mount(&fslogic[2], "2:", 0); //挂载文件系统
    /* Initialises the File System*/
    if(res != FR_OK ) 
    {
      /* efs initialisation fails*/
		return(-1);
    }else{
	}
    if(USBH_MSC_Param.MSWriteProtect == DISK_WRITE_PROTECTED)
    {
    }
    fgUsbInputFirst=TRUE;
    USBH_USR_ApplicationState = USH_USR_FS_READLIST;
    break;
    
  case USH_USR_FS_READLIST:  //继续往下走
	   USBH_USR_ApplicationState = USH_USR_FS_WRITEFILE;
		break;   
  case USH_USR_FS_WRITEFILE:
		if(USBH_MSC_Param.MSWriteProtect == DISK_WRITE_PROTECTED) //如果写保护
		{
			break;
		}
		if(fgUsbInputFirst==TRUE)
			{
			}
		fgUsbInputFirst=FALSE;
		//状态机
		USBH_USR_ApplicationState = USH_USR_FS_INIT; 
		if(aabb==0)
		{
			USB_Write();		  
		}
		aabb=1;
		break;
    
  case USH_USR_FS_DRAW:	
		while(HCD_IsDeviceConnected(&USB_OTG_Core))
		{
			if( f_mount(&fslogic[1], "1:", 0) != FR_OK ) 
			{
				/* fat_fs initialisation fails*/
				return(-1);
			}
			return Image_Browser("1:/Media");
		}
		break;
  default: break;
  }
  return(0);
}

把中断函数也放在这里

#ifdef USE_USB_OTG_FS  
void OTG_FS_IRQHandler(void)
#else
void OTG_HS_IRQHandler(void)
#endif
{
  USBH_OTG_ISR_Handler(&USB_OTG_Core);
}

然后把USB读写驱动加到diskio.c里

/*-----------------------------------------------------------------------*/
/* Low level disk I/O module SKELETON for FatFs     (C)ChaN, 2019        */
/*-----------------------------------------------------------------------*/
/* If a working storage control module is available, it should be        */
/* attached to the FatFs via a glue function rather than modifying it.   */
/* This is an example of glue functions to attach various exsisting      */
/* storage control modules to the FatFs module with a defined API.       */
/*-----------------------------------------------------------------------*/

#include "ff.h"			/* Obtains integer types */
#include "diskio.h"		/* Declarations of disk functions */
#include "AppLib.h"


#include "usbh_conf.h"
#include "usbh_msc_core.h"
#include "usbh_msc_core.h"

static volatile DSTATUS Stat = STA_NOINIT;	/* Disk status */
extern USB_OTG_CORE_HANDLE          USB_OTG_Core;
extern USBH_HOST                     USB_Host;
/* Definitions of physical drive number for each drive */
//#define DEV_RAM		0	/* Example: Map Ramdisk to physical drive 0 */
//#define DEV_MMC		1	/* Example: Map MMC/SD card to physical drive 1 */
//#define DEV_USB		2	/* Example: Map USB MSD to physical drive 2 */

#define SD_CARD 	0
#define SD_CARD_SPI	1
#define USB_DEVICE	2

#define SECTOR_SIZE 512U  //扇区大小

u8 buff_read2[2048];  // 注:与 SD_READ_BUFFER_MAX	(2048)	大小一致

/*-----------------------------------------------------------------------*/
/* Get Drive Status                                                      */
/*-----------------------------------------------------------------------*/

DSTATUS disk_status (
	BYTE pdrv		/* Physical drive nmuber to identify the drive */
)
{
	DSTATUS stat;
	//int result;
	switch (pdrv) {
	case SD_CARD :
		stat = 0;
		return stat;
	case USB_DEVICE :
		stat = 0;
		return stat;
	case SD_CARD_SPI:
		stat = 0;
		return stat;
	}
	return 0;
}



/*-----------------------------------------------------------------------*/
/* Inidialize a Drive                                                    */
/*-----------------------------------------------------------------------*/

DSTATUS disk_initialize (
	BYTE pdrv				/* Physical drive nmuber to identify the drive */
)
{
	switch(pdrv)
	{
		case SD_CARD:
			//SD_Init();
			break;
		case USB_DEVICE:
			if(HCD_IsDeviceConnected(&USB_OTG_Core))
			{  
				Stat &= ~STA_NOINIT;
			}
			break;
		case SD_CARD_SPI:
			break;
	}
	return 0;
}



/*-----------------------------------------------------------------------*/
/* Read Sector(s)                                                        */
/*-----------------------------------------------------------------------*/

DRESULT disk_read (
	BYTE pdrv,		/* Physical drive nmuber to identify the drive */
	BYTE *buff,		/* Data buffer to store read data */
	DWORD sector,	/* Start sector in LBA */
	UINT count		/* Number of sectors to read */
)
{
	DRESULT res = RES_OK;	
	BYTE USBstatus = USBH_MSC_OK;

	switch (pdrv) 
	{
		case SD_CARD :

		if(count==1)
		{
			SD_ReadBlock(buff_read2, sector<< 9 ,SECTOR_SIZE);
			SD_WaitReadOperation();
			memcpy(buff,buff_read2,SECTOR_SIZE);

		}
		else
		{
			SD_ReadMultiBlocks(buff_read2,sector<< 9,SECTOR_SIZE,count);
			SD_WaitReadOperation();
			memcpy(buff,buff_read2,SECTOR_SIZE * count);

		}	
		return res;
	case SD_CARD_SPI :
	  
		if(count==1)
		{
			SD_ReadBlock_SPI(buff_read2, sector<< 9 ,SECTOR_SIZE);
			memcpy(buff,buff_read2,SECTOR_SIZE);
		}
		else
		{
			SD_ReadMultiBlocks_SPI(buff_read2,sector<< 9,SECTOR_SIZE,count);
			memcpy(buff,buff_read2,SECTOR_SIZE * count);
		}
		return RES_OK;
		
	case USB_DEVICE :
	  
		if (!pdrv || !count) return RES_PARERR;
		if (Stat & STA_NOINIT) return RES_NOTRDY;
		if(HCD_IsDeviceConnected(&USB_OTG_Core))
		{  
			do
			{
				USBstatus = USBH_MSC_Read10(&USB_OTG_Core, buff,sector,512 * count);
				USBH_MSC_HandleBOTXfer(&USB_OTG_Core ,&USB_Host);

				if(!HCD_IsDeviceConnected(&USB_OTG_Core))
				{ 
					return RES_ERROR;
				}      
			}while(USBstatus == USBH_MSC_BUSY );
		}

		if(USBstatus == USBH_MSC_OK)
		return RES_OK;
	return res;

	}
		return RES_OK;	
}



/*-----------------------------------------------------------------------*/
/* Write Sector(s)                                                       */
/*-----------------------------------------------------------------------*/

#if FF_FS_READONLY == 0

DRESULT disk_write (
	BYTE pdrv,			/* Physical drive nmuber to identify the drive */
	const BYTE *buff,	/* Data to be written */
	DWORD sector,		/* Start sector in LBA */
	UINT count			/* Number of sectors to write */
)
{
	DRESULT res = RES_OK;
		BYTE USBstatus = USBH_MSC_OK;
	switch (pdrv) 
	{
		case SD_CARD :

		if(count==1)
		{
			memcpy(buff_read2,buff,SECTOR_SIZE);
			SD_WriteBlock((uint8_t*)buff_read2, sector << 9 ,SECTOR_SIZE);
			SD_WaitWriteOperation(); 
		}
		else
		{
			memcpy(buff_read2,buff,SECTOR_SIZE * count);
			SD_WriteMultiBlocks((uint8_t*)buff_read2, sector << 9 ,SECTOR_SIZE,count);	
			SD_WaitWriteOperation(); 
		}	
		return res;
	case SD_CARD_SPI :
		if(count==1)
		{
			memcpy(buff_read2,buff,SECTOR_SIZE);
			SD_WriteBlock_SPI((uint8_t*)buff_read2, sector << 9 ,SECTOR_SIZE);
		}
		else
		{
			memcpy(buff_read2,buff,SECTOR_SIZE * count);
			SD_WriteMultiBlocks_SPI((uint8_t*)buff_read2, sector << 9 ,SECTOR_SIZE,count);	

		}

	return res;
	case USB_DEVICE :
		if (!pdrv || !count) return RES_PARERR;
		if (Stat & STA_NOINIT) return RES_NOTRDY;
		if (Stat & STA_PROTECT) return RES_WRPRT;

		if(HCD_IsDeviceConnected(&USB_OTG_Core))
		{  
			do
			{
				USBstatus = USBH_MSC_Write10(&USB_OTG_Core,(BYTE*)buff,sector,512 * count);
				USBH_MSC_HandleBOTXfer(&USB_OTG_Core, &USB_Host);

				if(!HCD_IsDeviceConnected(&USB_OTG_Core))
				{ 
					return RES_ERROR;
				}
			}while(USBstatus == USBH_MSC_BUSY );

		}
		if(USBstatus == USBH_MSC_OK)
		return RES_OK;	
	}
	return RES_OK;	
}

#endif


/*-----------------------------------------------------------------------*/
/* Miscellaneous Functions                                               */
/*-----------------------------------------------------------------------*/

DRESULT disk_ioctl (
	BYTE pdrv,		/* Physical drive nmuber (0..) */
	BYTE cmd,		/* Control code */
	void *buff		/* Buffer to send/receive control data */
)
{
		return RES_OK;
}

DWORD get_fattime(void){
	return 0;
}