stm32cubemx usb开发

学习stm32已经很长时间了，但是一直没有过多的学习stm32的USB部分，因为实际工作还是用的比较少。说起USB那就有的说了，因为USB的功能很强大，这里主要重点记录一下STM32的USB部分，这个官方给的有专门USB库，笔者目前使用的是Cotex-M3内核的STM32F103系列，实验的芯片为STM32F103C8，这个是目前市场上性价比非常高的芯片，也是用的非常多的芯片。

USB基础知识

USB按接口类型分

控制器/主机（controller/host）

设备（peripheral）

OTG（on-the-go），通过id线确定作为主机还是作为设备

按照USB速度分

低速（low speed）

全速（full speed）

高速（high speed）

USB接口一般是4根线，VCC GND DM(D-) DP(D+)

低速设备：在DM线上接入上拉

全速设备：在DP线上接入上拉

高速设备：在DP线上接入上拉，在主机对设备进行复位后进一步的确认

 

关于描述符

设备描述符（device description）

配置描述符（config description）

接口描述符 （interface description）

端点描述符 （endpoint description）

设备的“身份”信息存储在描述符中。每个USB设备中都有如下描述符。需要注意的是一个USB设备只能有一个设备描述符，一个设备描述符可以有多个配置描述符，一个配置描述符可以有多个接口描述符，一个接口描述符可以包含多个端点。

关于传输

1. 在USB的通讯中，有传输（transfer），事务（Transaction），包（packet）三级。包是最基础的传输单元，与TCP/IP协议中的MAC层协议作用相同。
2. 在一次传输中，由多次事务组成，每次的事务又由多个包组成
3. 与众多协议相同，较高级别的协议的报文是基于/内嵌在低级协议的报文当中的，在USB中也不例外，例如，包中预留了DATA位，其目的就是填写报文

STM32F103芯片自带了有USB模块，可以用来做从设备，不能用作主机HOST。这里使用USB的目的是讲USB作为一个大容量，这个可以基于官方USB Mass_Storage例程来移植。这里就不过多的介绍里面复杂的通信原理了，要彻彻底底搞明白并灵活运用取来还是有很大难度的，因为内容太多了。这里仅仅介绍下移植过程和描述符相关的重点内容。

准备工作

第一步

确保自己的KEIL开发环境已经完善。

第二步

下载好了两份ST官方的库文件（我是基于标准库开发的），一个是标准外设库文件，一个是USB库文件。如下图：

 

没有的可以自行下载

标准外设库：https://www.stmcu.org.cn/document/detail/index/id-213160

USB外设库：https://www.stmcu.org.cn/document/detail/index/id-200293

第三步

建立一个带有存储介质驱动的STM32基础工程，存储介质常见有SD卡、外部FLASH芯片、内部的FLASH空间。的我是基于一个外部flash的工程去实现的，芯片具体型号是W25Q64，64Mbit的空间，换成字节就是8MByte。驱动部分如下：

C文件

#include "fy_w25qxx.h" 

u16 W25QXX_TYPE=0;//W25Q64

//4Kbytes为一个Sector,16个扇区为1个Block,容量为16M字节,共有128个Block,4096个Sector 
//初始化SPI FLASH的IO口
void W25QXX_Configuration(void)
{	
	SPI2_SetSpeed(SPI_BaudRatePrescaler_2);//设置为18M时钟,高速模式
	W25QXX_TYPE=W25QXX_ReadID();//读取FLASH ID.  
}  	

//读取W25QXX的状态寄存器
//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
u8 W25QXX_ReadSR(void)   
{  
	u8 byte=0;   
	W25QXX_CS_L();                            //使能器件   
	SPI2_ReadWriteByte(W25X_ReadStatusReg); //发送读取状态寄存器命令    
	byte=SPI2_ReadWriteByte(0Xff);          //读取一个字节  
	W25QXX_CS_H();                            //取消片选     
	return byte;   
} 
//写W25QXX状态寄存器
//只有SPR,TB,BP2,BP1,BP0(bit 7,5,4,3,2)可以写!!!
void W25QXX_Write_SR(u8 sr)   
{   
	W25QXX_CS_L();                            //使能器件   
	SPI2_ReadWriteByte(W25X_WriteStatusReg);//发送写取状态寄存器命令    
	SPI2_ReadWriteByte(sr);               	//写入一个字节  
	W25QXX_CS_H();                            //取消片选     	      
}   
//W25QXX写使能	
//将WEL置位   
void W25QXX_Write_Enable(void)   
{
	W25QXX_CS_L();                          	//使能器件   
    SPI2_ReadWriteByte(W25X_WriteEnable); 	//发送写使能  
	W25QXX_CS_H();                           	//取消片选     	      
} 
//W25QXX写禁止	
//将WEL清零  
void W25QXX_Write_Disable(void)   
{  
	W25QXX_CS_L();                            //使能器件   
    SPI2_ReadWriteByte(W25X_WriteDisable);  //发送写禁止指令    
	W25QXX_CS_H();                            //取消片选     	      
} 		

//读取芯片ID 
u16 W25QXX_ReadID(void)
{
	u16 Temp = 0;	  
	W25QXX_CS_L();				    
	SPI2_ReadWriteByte(0x90);//发送读取ID命令	    
	SPI2_ReadWriteByte(0x00); 	    
	SPI2_ReadWriteByte(0x00); 	    
	SPI2_ReadWriteByte(0x00); 	 			   
	Temp|=SPI2_ReadWriteByte(0xFF)<<8;  
	Temp|=SPI2_ReadWriteByte(0xFF);	 
	W25QXX_CS_H();				    
	return Temp;
}   		    

//在指定地址开始读取指定长度的数据
//pBuffer:数据存储区,ReadAddr:开始读取的地址(24bit),NumByteToRead:要读取的字节数(最大65535)
void W25QXX_Read(u8* pBuffer,u32 ReadAddr,u16 NumByteToRead)   
{ 
 	u16 i;   										    
	W25QXX_CS_L();                            	//使能器件   
	SPI2_ReadWriteByte(W25X_ReadData);         	//发送读取命令   
	SPI2_ReadWriteByte((u8)((ReadAddr)>>16));  	//发送24bit地址    
	SPI2_ReadWriteByte((u8)((ReadAddr)>>8));   
	SPI2_ReadWriteByte((u8)ReadAddr);   
	for(i=0;i<NumByteToRead;i++)
	{ 
        pBuffer[i]=SPI2_ReadWriteByte(0XFF);   	//循环读数  
  }
	W25QXX_CS_H();  				    	      
}

//SPI在一页(0~65535)内写入少于256个字节的数据
//在指定地址开始写入最大256字节的数据
//pBuffer:数据存储区,WriteAddr:开始写入的地址(24bit),NumByteToWrite:要写入的字节数(最大256),该数不应该超过该页的剩余字节数!!!	 
void W25QXX_Write_Page(u8* pBuffer,u32 WriteAddr,u16 NumByteToWrite)
{
 	u16 i;  
	W25QXX_Write_Enable();                  	//SET WEL 
	W25QXX_CS_L();                            	//使能器件   
	SPI2_ReadWriteByte(W25X_PageProgram);      	//发送写页命令   
	SPI2_ReadWriteByte((u8)((WriteAddr)>>16)); 	//发送24bit地址    
	SPI2_ReadWriteByte((u8)((WriteAddr)>>8));   
	SPI2_ReadWriteByte((u8)WriteAddr);   
	for(i=0;i<NumByteToWrite;i++)SPI2_ReadWriteByte(pBuffer[i]);//循环写数  
	W25QXX_CS_H();                            	//取消片选 
	W25QXX_Wait_Busy();					   		//等待写入结束
} 
//无检验写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)   
u8 W25QXX_BUFFER[4096];		 
void W25QXX_Write(u8* pBuffer,u32 WriteAddr,u16 NumByteToWrite)   
{ 
	u32 secpos;
	u16 secoff;
	u16 secremain;	   
 	u16 i;    
	u8 *W25QXX_BUF;	  
	
   	W25QXX_BUF=W25QXX_BUFFER;
//	
//    W25QXX_BUF = (u8 *)_mem.Alloc(4096);//申请一个扇区大小的内存
//    if(W25QXX_BUF==NULL)	return;
	
 	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;		//下一个扇区可以写完了
		}	 
	}
//	_mem.Free(W25QXX_BUF);
}
//擦除整个芯片		  
//等待时间超长...
void W25QXX_Erase_Chip(void)   
{                                   
    W25QXX_Write_Enable();                 	 	//SET WEL 
    W25QXX_Wait_Busy();   
  	W25QXX_CS_L();                            	//使能器件   
    SPI2_ReadWriteByte(W25X_ChipErase);        	//发送片擦除命令  
	W25QXX_CS_H();                            	//取消片选     	      
	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();   
  	W25QXX_CS_L();                            	//使能器件   
    SPI2_ReadWriteByte(W25X_SectorErase);      	//发送扇区擦除指令 
    SPI2_ReadWriteByte((u8)((Dst_Addr)>>16));  	//发送24bit地址    
    SPI2_ReadWriteByte((u8)((Dst_Addr)>>8));   
    SPI2_ReadWriteByte((u8)Dst_Addr);  
	W25QXX_CS_H();                            	//取消片选     	      
    W25QXX_Wait_Busy();   				   		//等待擦除完成
}  
//等待空闲
void W25QXX_Wait_Busy(void)   
{   
	while((W25QXX_ReadSR()&0x01)==0x01);  		// 等待BUSY位清空
}  
//进入掉电模式
void W25QXX_PowerDown(void)   
{ 
  	W25QXX_CS_L();                           	 	//使能器件   
    SPI2_ReadWriteByte(W25X_PowerDown);        //发送掉电命令  
	W25QXX_CS_H();                            	//取消片选     	      
    Delay_us(3);                               //等待TPD  
}   
//唤醒
void W25QXX_WAKEUP(void)   
{  
  	W25QXX_CS_L();                            	//使能器件   
    SPI2_ReadWriteByte(W25X_ReleasePowerDown);	//  send W25X_PowerDown command 0xAB    
	W25QXX_CS_H();                            	//取消片选     	      
    Delay_us(3);                            	//等待TRES1
}

H文件

#ifndef __FY_W25QXX_H
#define __FY_W25QXX_H			    

#include "fy_includes.h" 

//W25QXX对应唯一识别ID
#define W25Q80 	0XEF13
#define W25Q16 	0XEF14
#define W25Q32 	0XEF15
#define W25Q64 	0XEF16
#define W25Q128	0XEF17

//指令表
#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 

void W25QXX_Configuration(void);
u16  W25QXX_ReadID(void);  	    		//读取FLASH ID
u8	 W25QXX_ReadSR(void);        		//读取状态寄存器 
void W25QXX_Write_SR(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,u16 NumByteToRead);   //读取flash
void W25QXX_Write(u8* pBuffer,u32 WriteAddr,u16 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);				//唤醒

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

#endif

基础工程如下：

第四步：USB代码移植

拷贝USB底层库到工程根目录，新建一个目录命名成USB，拷贝Mass_Storage例程下的src和inc目录下的所以文件到USB。

拷贝过来是有37个文件，这个时候需要删除一些不必要的文件，因为官方的例程里面有nand，这里的话先删除以下文件

4.打开工程把分组和文件及包含路径添加进去，这里就不细说了，结果如下

打开usb下面的main和it 把重要的代码先拷贝出来

把main和stm32_it里面的内容拷贝到自己的main里面进行下封装去掉不要的保留剩下的，然后就删除it和main三个文件。

然后编译下，这个时候会出现一堆报错，需要慢慢一步步搞定，编译前注意路径包含，

定位到第一个错误进去

这个定义的是官方的开发板 我们直接修改成自己的公共文件就可以，并且注释掉开发板定义

公共文件如下，并且添加usb部分的头文件

继续编译，定位第一个错误，这部分主要修改hw_config文件

删除Set_System函数

删除Led_Config函数

 

注释LED相关的内容

删除USB_Disconnect_Config

接下来主要修改mass_mal部分，我这里是只有一个flash，所以我修改成如下：

头文件

 

下面修改memory文件，主要修改变量定义，C文件和H文件分别如下

接下来是usb_scsi部分的变量定义

这时候再次编译就发现没有错误了，但是这个地方USB中断部分还需要配置下，官方用的宏定义方式去实现不同的代码，这里一开始就去掉了宏，所以最终修改如下：

/*******************************************************************************
* Function Name  : USB_Interrupts_Config
* Description    : Configures the USB interrupts
* Input          : None.
* Return         : None.
*******************************************************************************/
void USB_Interrupts_Config(void)
{
	
	NVIC_InitTypeDef NVIC_InitStructure;
	EXTI_InitTypeDef EXTI_InitStructure;

 
	/* Configure the EXTI line 18 connected internally to the USB IP */
	EXTI_ClearITPendingBit(EXTI_Line18);
											  //  开启线18上的中断
	EXTI_InitStructure.EXTI_Line = EXTI_Line18; // USB resume from suspend mode
	EXTI_InitStructure.EXTI_Trigger = EXTI_Trigger_Rising;	//line 18上事件上升降沿触发
	EXTI_InitStructure.EXTI_LineCmd = ENABLE;
	EXTI_Init(&EXTI_InitStructure); 	 

	/* Enable the USB interrupt */
	NVIC_InitStructure.NVIC_IRQChannel = USB_LP_CAN1_RX0_IRQn;	//组2，优先级次之 
	NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 1;
	NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0;
	NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
	NVIC_Init(&NVIC_InitStructure);
	
	/* Enable the USB Wake-up interrupt */
	NVIC_InitStructure.NVIC_IRQChannel = USBWakeUp_IRQn;   //组2，优先级最高	
	NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 0;
	NVIC_Init(&NVIC_InitStructure);  

 
}

 

 

 

再注释掉USB_Cable_Config的内容（DP上有1.5K上拉电阻）并修改中断函数

//USB唤醒中断服务函数
void USBWakeUp_IRQHandler(void) 
{
	EXTI_ClearITPendingBit(EXTI_Line18);//清除USB唤醒中断挂起位
}

修改pwr的Suspend内容：

void Suspend(void)
{
	uint32_t i =0;
	uint16_t wCNTR;
	__IO uint32_t savePWR_CR=0;
	/* suspend preparation */
	/* ... */
	
	/*Store CNTR value */
	wCNTR = _GetCNTR();  

    /* This a sequence to apply a force RESET to handle a robustness case */
    
	/*Store endpoints registers status */
    for (i=0;i<8;i++) EP[i] = _GetENDPOINT(i);
	
	/* unmask RESET flag */
	wCNTR|=CNTR_RESETM;
	_SetCNTR(wCNTR);
	
	/*apply FRES */
	wCNTR|=CNTR_FRES;
	_SetCNTR(wCNTR);
	
	/*clear FRES*/
	wCNTR&=~CNTR_FRES;
	_SetCNTR(wCNTR);
	
	/*poll for RESET flag in ISTR*/
	while((_GetISTR()&ISTR_RESET) == 0);
	
	/* clear RESET flag in ISTR */
	_SetISTR((uint16_t)CLR_RESET);
	
	/*restore Enpoints*/
	for (i=0;i<8;i++)
	_SetENDPOINT(i, EP[i]);
	
	/* Now it is safe to enter macrocell in suspend mode */
	wCNTR |= CNTR_FSUSP;
	_SetCNTR(wCNTR);
	
	/* force low-power mode in the macrocell */
	wCNTR = _GetCNTR();
	wCNTR |= CNTR_LPMODE;
	_SetCNTR(wCNTR);
	
	Enter_LowPowerMode();
}

把USB初始化部分不要的注释掉：

void USB_MSC_Configuration(void)
{
//  Set_System();
  Set_USBClock();
//  Led_Config();
  USB_Interrupts_Config();
  USB_Init();
//  while (bDeviceState != CONFIGURED);

//  USB_Configured_LED();

//  while (1)
//  {}
}

最后在USB初始化之前给U盘定义的数组赋值，不然就只有个盘符

Mass_Memory_Size[0]=1024*1024*4;	//w25q64->8M 给4M做U盘
    Mass_Block_Size[0] =512;			//设置SPI FLASH的操作扇区大小为512
    Mass_Block_Count[0]=Mass_Memory_Size[0]/Mass_Block_Size[0];

	USB_MSC_Configuration();

编译下载后就可以正常运行了。

 

传输文件、新建文件夹都可以了，就是传输速度感人。

以上就是USB虚拟U盘的所有内容了，内容太多而且复杂，所以如果真的想亲手试试，还是要点耐心的。虽然能学到的并不是很多，这里主要可以干茶mass_mal部分，可以学到不少东西，方便以后的熟练运用。我这里也是为以后更进一步的开发做铺垫。

By Urien 2019年10月27日 03:19:23