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

6 D% e" [# h3 C1 U' _USB基础知识
USB按接口类型分
1 C0 Y2 c( V4 o  z# v. z/ v控制器/主机（controller/host）
$ W, u* o. O# y
设备（peripheral）
4 F1 f: W; ]6 u- K! L* X3 Q6 c
OTG（on-the-go），通过id线确定作为主机还是作为设备

  ~0 N$ p* P. w+ J! _1 K8 p按照USB速度分

低速（low speed）

& G" E9 |8 @6 t, q0 C( r全速（full speed）

高速（high speed）

3 {' `. y/ C8 |! a- ~% L: tUSB接口一般是4根线，VCC GND DM(D-) DP(D+)

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

全速设备：在DP线上接入上拉
3 U: V. ^& ]1 F
2 L/ v0 |9 j7 e3 O( U高速设备：在DP线上接入上拉，在主机对设备进行复位后进一步的确认

: R3 ^/ y, ]& [/ S
关于描述符
设备描述符（device description）

配置描述符（config description）

接口描述符 （interface description）
( M4 d6 Z7 k9 `! g( z9 E9 S
* n/ f  `1 c9 `% v. T; `7 L端点描述符 （endpoint description）
' _0 p9 Q+ ]( o

- r2 x% ^3 \4 @  t
7 W- _/ ?; q0 |! q设备的“身份”信息存储在描述符中。每个USB设备中都有如下描述符。需要注意的是一个USB设备只能有一个设备描述符，一个设备描述符可以有多个配置描述符，一个配置描述符可以有多个接口描述符，一个接口描述符可以包含多个端点。

) f( H! @" ~( H( r) g% a* f7 u8 F关于传输
" q" Y$ Q) H% ^, O* X" W4 _1.在USB的通讯中，有传输（transfer），事务（Transaction），包（packet）三级。包是最基础的传输单元，与TCP/IP协议中的MAC层协议作用相同。
2.在一次传输中，由多次事务组成，每次的事务又由多个包组成
3.与众多协议相同，较高级别的协议的报文是基于/内嵌在低级协议的报文当中的，在USB中也不例外，例如，包中预留了DATA位，其目的就是填写报文
STM32F103芯片自带了有USB模块，可以用来做从设备，不能用作主机HOST。这里使用USB的目的是讲USB作为一个大容量，这个可以基于官方USB Mass_Storage例程来移植。这里就不过多的介绍里面复杂的通信原理了，要彻彻底底搞明白并灵活运用取来还是有很大难度的，因为内容太多了。这里仅仅介绍下移植过程和描述符相关的重点内容。

准备工作
第一步
确保自己的KEIL开发环境已经完善。

+ ^0 W9 j; K% G+ H第二步
下载好了两份ST官方的库文件（我是基于标准库开发的），一个是标准外设库文件，一个是USB库文件。如下图：
! D5 C, S6 @8 l( i& a  n0 C5 M


. b  v7 C1 ?0 V4 v- J2 D& e) ?第三步
6 w" H/ A; S$ b' f: c+ C建立一个带有存储介质驱动的STM32基础工程，存储介质常见有SD卡、外部FLASH芯片、内部的FLASH空间。的我是基于一个外部flash的工程去实现的，芯片具体型号是W25Q64，64Mbit的空间，换成字节就是8MByte。驱动部分如下：
4 L' s5 K/ L1 A- U
C文件

1. #include "fy_w25qxx.h"
   
2. 
   
3. u16 W25QXX_TYPE=0;//W25Q64
   
4. 
   
5. //4Kbytes为一个Sector,16个扇区为1个Block,容量为16M字节,共有128个Block,4096个Sector
   + @/ j& m  M& o1 |' `
6. //初始化SPI FLASH的IO口
   : W9 s6 V7 B: H
7. void W25QXX_Configuration(void)
   
8. {        
   2 |4 Y5 n. o2 c6 E$ f) F& H) u/ H: k- h
9.         SPI2_SetSpeed(SPI_BaudRatePrescaler_2);//设置为18M时钟,高速模式
   0 R. H& E! J/ `2 ]  Q& M
10.         W25QXX_TYPE=W25QXX_ReadID();//读取FLASH ID.  
    
11. }         
    
12. 
    ) Y; K; k5 S+ W; G/ }5 A4 U
13. //读取W25QXX的状态寄存器
    
14. //BIT7  6   5   4   3   2   1   0
    ) c- x/ d: e2 j2 D
15. //SPR   RV  TB BP2 BP1 BP0 WEL BUSY
    
16. //SPR:默认0,状态寄存器保护位,配合WP使用
    
17. //TB,BP2,BP1,BP0:FLASH区域写保护设置
    8 f: |, r( _, I0 |* a9 ?
18. //WEL:写使能锁定
    
19. //BUSY:忙标记位(1,忙;0,空闲)
    ' y: {& f9 X, F4 A1 ~
20. //默认:0x00
    : j5 f& ?+ K) e# j% K/ P1 d
21. u8 W25QXX_ReadSR(void)   
    
22. {  
    8 p+ O* N, L5 i% d' ~9 [# O
23.         u8 byte=0;   
    ( ?9 e; ?5 l9 J% D* q" e
24.         W25QXX_CS_L();                            //使能器件   
    
25.         SPI2_ReadWriteByte(W25X_ReadStatusReg); //发送读取状态寄存器命令   
    5 ~) g# L; O8 K1 E7 T
26.         byte=SPI2_ReadWriteByte(0Xff);          //读取一个字节  
    
27.         W25QXX_CS_H();                            //取消片选     
    0 t5 a* {$ d2 {4 S5 r( h; a/ _
28.         return byte;   
    
29. }
    1 T- F5 A% W* _' @# @& J
30. //写W25QXX状态寄存器
    5 e6 f$ V" u9 e- a+ B
31. //只有SPR,TB,BP2,BP1,BP0(bit 7,5,4,3,2)可以写!!!
    3 V) f  V6 y- c. A7 B# q
32. void W25QXX_Write_SR(u8 sr)   
    * ]8 d* [1 y6 u/ T
33. {   
    
34.         W25QXX_CS_L();                            //使能器件   
    6 q$ x: l/ V4 D/ F, d& n
35.         SPI2_ReadWriteByte(W25X_WriteStatusReg);//发送写取状态寄存器命令   
    
36.         SPI2_ReadWriteByte(sr);                       //写入一个字节  
    / J' l( S8 U, g5 D; w8 D( ~$ z
37.         W25QXX_CS_H();                            //取消片选                  
    6 U/ [# r! T8 M( }$ ]* p: P
38. }   
    
39. //W25QXX写使能        
    
40. //将WEL置位   
    
41. void W25QXX_Write_Enable(void)   
    
42. {
    
43.         W25QXX_CS_L();                                  //使能器件   
    - ?* I  ]/ ^$ f) U$ O
44.     SPI2_ReadWriteByte(W25X_WriteEnable);         //发送写使能  
    
45.         W25QXX_CS_H();                                   //取消片选                  
    * t3 Y. }# a% Q' z9 c* Q' b" c- @
46. }
    
47. //W25QXX写禁止        
      m, u3 Q% d9 B
48. //将WEL清零  
    
49. void W25QXX_Write_Disable(void)   
    
50. {  
    ( T5 O! x1 J+ N% P* r0 ]
51.         W25QXX_CS_L();                            //使能器件   
    
52.     SPI2_ReadWriteByte(W25X_WriteDisable);  //发送写禁止指令   
    $ q% f7 O+ L8 N6 f: l# t4 t
53.         W25QXX_CS_H();                            //取消片选                  
    % S" X( O3 \+ m4 n
54. }                 
    
55. 
    # g) H9 e7 Z, n: A- |) E2 f
56. //读取芯片ID
    
57. u16 W25QXX_ReadID(void)
    + u# J+ V; c( E1 _7 S6 R
58. {
    ) o  ~* [+ x5 T& K: j- q' T
59.         u16 Temp = 0;         
    6 d' `8 I/ |  |# G4 g
60.         W25QXX_CS_L();                                    
    7 [# |: p8 E5 y7 ^6 X: T: T
61.         SPI2_ReadWriteByte(0x90);//发送读取ID命令            
    & f6 f! J8 _: H& d
62.         SPI2_ReadWriteByte(0x00);            
    $ \" z5 W8 x/ Y. D
63.         SPI2_ReadWriteByte(0x00);            
    ! I8 a8 T8 e) p& W
64.         SPI2_ReadWriteByte(0x00);                                    
    7 q+ K+ {( t) ?  H; t& a% q
65.         Temp|=SPI2_ReadWriteByte(0xFF)<<8;  
    
66.         Temp|=SPI2_ReadWriteByte(0xFF);         
    % `5 S4 X3 [- K; _
67.         W25QXX_CS_H();                                    
    & [$ W$ l! O% _+ N) }. I
68.         return Temp;
    % v& p. E* }# k- i1 Y7 a) k
69. }                       
    
70. 
    
71. //在指定地址开始读取指定长度的数据
    + R4 S$ Q; f% x. E# J7 ^- C/ G
72. //pBuffer:数据存储区,ReadAddr:开始读取的地址(24bit),NumByteToRead:要读取的字节数(最大65535)
    
73. void W25QXX_Read(u8* pBuffer,u32 ReadAddr,u16 NumByteToRead)   
    % M% x: i- K( o9 W6 @
74. {
    ; d7 \3 s/ ]! }% O4 [: m2 X5 t
75.          u16 i;                                                                                       
    8 V* S0 o, d1 u% ~, Z7 ?
76.         W25QXX_CS_L();                                    //使能器件   
    
77.         SPI2_ReadWriteByte(W25X_ReadData);                 //发送读取命令   
    " l( G9 J, Z. k/ j- i
78.         SPI2_ReadWriteByte((u8)((ReadAddr)>>16));          //发送24bit地址   
    
79.         SPI2_ReadWriteByte((u8)((ReadAddr)>>8));   
    
80.         SPI2_ReadWriteByte((u8)ReadAddr);   
    $ t+ q4 S; S  D7 |1 t" B
81.         for(i=0;i<NumByteToRead;i++)
    
82.         {
    
83.         pBuffer=SPI2_ReadWriteByte(0XFF);           //循环读数  
    , Z% W/ L. a; s. ]( O! m0 N6 z
84.   }
    ( C9 d* U" v9 h3 I% L+ L/ g7 N% W
85.         W25QXX_CS_H();                                                   
    , v6 J! B8 D; i, L* z; L
86. }
    
87. 
    
88. //SPI在一页(0~65535)内写入少于256个字节的数据
    
89. //在指定地址开始写入最大256字节的数据
    
90. //pBuffer:数据存储区,WriteAddr:开始写入的地址(24bit),NumByteToWrite:要写入的字节数(最大256),该数不应该超过该页的剩余字节数!!!         
    + p. B! C$ N7 W
91. void W25QXX_Write_Page(u8* pBuffer,u32 WriteAddr,u16 NumByteToWrite)
    
92. {
    + f& z* E% h6 M/ l% K. m; n& j" F5 Y* C' C
93.          u16 i;  
    " J0 N* Q  |- I' Z- i' P% [- q- t. c/ z
94.         W25QXX_Write_Enable();                          //SET WEL
    
95.         W25QXX_CS_L();                                    //使能器件   
    4 M: J2 j; u, x* U) O
96.         SPI2_ReadWriteByte(W25X_PageProgram);              //发送写页命令   
      Y) c* l9 b  }8 z' U4 h
97.         SPI2_ReadWriteByte((u8)((WriteAddr)>>16));         //发送24bit地址   
    
98.         SPI2_ReadWriteByte((u8)((WriteAddr)>>8));   
    : h0 U3 W; P- b+ `; Q3 S% V) K6 o
99.         SPI2_ReadWriteByte((u8)WriteAddr);   
    ; t& e; S2 ^3 I/ a' ?7 h3 [
100.         for(i=0;i<NumByteToWrite;i++)SPI2_ReadWriteByte(pBuffer);//循环写数  
     
101.         W25QXX_CS_H();                                    //取消片选
     
102.         W25QXX_Wait_Busy();                                                           //等待写入结束
     ! P8 `# e* C; a! [7 L# G- h' B
103. }
     
104. //无检验写SPI FLASH
     - \  O- X7 u; @8 m% V$ Z0 i+ L9 Q
105. //必须确保所写的地址范围内的数据全部为0XFF,否则在非0XFF处写入的数据将失败!
     & o$ j9 Z# l. r3 n& O) x. Y
106. //具有自动换页功能
     ; U. B+ X7 a! w! d" U! R" ~) B
107. //在指定地址开始写入指定长度的数据,但是要确保地址不越界!
     + Z* g8 K2 f* J' q
108. //pBuffer:数据存储区
     $ t% C; c/ v1 K; ]9 |
109. //WriteAddr:开始写入的地址(24bit)
     & k+ t# `2 Y' Z4 N5 B5 J7 @
110. //NumByteToWrite:要写入的字节数(最大65535)
     - u" N. A" s" N! w( `
111. //CHECK OK
     ! o5 w: X; ^; X# w: I( U; T
112. void W25QXX_Write_NoCheck(u8* pBuffer,u32 WriteAddr,u16 NumByteToWrite)   
     # ]7 }- s& i. a' R: l
113. {                                          
     
114.         u16 pageremain;           
     
115.         pageremain=256-WriteAddr%256; //单页剩余的字节数                             
     
116.         if(NumByteToWrite<=pageremain)pageremain=NumByteToWrite;//不大于256个字节
     
117.         while(1)
     
118.         {           
     
119.                 W25QXX_Write_Page(pBuffer,WriteAddr,pageremain);
     : |% y, A+ c2 b! r( c
120.                 if(NumByteToWrite==pageremain)break;//写入结束了
     ' V8 W' `7 G" X5 y5 m/ Z( W5 w
121.                  else //NumByteToWrite>pageremain
     
122.                 {
     . \$ G# w  S2 H4 t* i1 F
123.                         pBuffer+=pageremain;
     
124.                         WriteAddr+=pageremain;        
     ; R3 [* w+ P: ]2 w* v2 b
125. 
     6 @$ H$ T; s: `' z
126.                         NumByteToWrite-=pageremain;                          //减去已经写入了的字节数
     
127.                         if(NumByteToWrite>256)pageremain=256; //一次可以写入256个字节
     ; Z0 a/ U) `* A2 T% M/ T" p! \4 W
128.                         else pageremain=NumByteToWrite;           //不够256个字节了
     
129.                 }
     
130.         };            
     
131. }
       t! D; t+ x0 Z3 C0 m+ }, y
132. //写SPI FLASH  
     2 G- |  A9 L7 G3 f/ k5 H% M( ~8 E
133. //在指定地址开始写入指定长度的数据
     0 ?  c  @# z% I: x2 @
134. //该函数带擦除操作!
     7 x) M1 N8 z0 B5 Z: c6 L8 X* X
135. //pBuffer:数据存储区
     
136. //WriteAddr:开始写入的地址(24bit)                                                
     
137. //NumByteToWrite:要写入的字节数(最大65535)   
     
138. u8 W25QXX_BUFFER[4096];                 
     
139. void W25QXX_Write(u8* pBuffer,u32 WriteAddr,u16 NumByteToWrite)   
     
140. {
     , m3 z# d5 `8 {6 S4 p
141.         u32 secpos;
     3 v! d- F6 c, g+ Y6 O; E
142.         u16 secoff;
     
143.         u16 secremain;           
     5 c: j+ B, _$ q% o
144.          u16 i;   
     9 a* l' Y; X0 S
145.         u8 *W25QXX_BUF;         
     4 q( V+ ]+ b3 Z* k" s
146.         
     , u% O' A, q4 w
147.            W25QXX_BUF=W25QXX_BUFFER;
     $ m% g5 u( `# r
148. //        
     & h: J# q+ n8 a7 Q+ c) z
149. //    W25QXX_BUF = (u8 *)_mem.Alloc(4096);//申请一个扇区大小的内存
     
150. //    if(W25QXX_BUF==NULL)        return;
     ! C6 C% z' J9 n
151.         
     
152.          secpos=WriteAddr/4096;//扇区地址  
     1 ~# v7 }: ?/ t* }
153.         secoff=WriteAddr%4096;//在扇区内的偏移
     
154.         secremain=4096-secoff;//扇区剩余空间大小  
     , V0 A2 p+ k! U1 C
155. 
     
156.          //printf("ad:%X,nb:%X\r\n",WriteAddr,NumByteToWrite);//测试用
     . O# D3 R9 y# W1 i! P1 J
157.          if(NumByteToWrite<=secremain)secremain=NumByteToWrite;//不大于4096个字节
     
158.         while(1)
     0 a! H# T% ~! L9 G/ e9 \
159.         {        
     
160.                 W25QXX_Read(W25QXX_BUF,secpos*4096,4096);//读出整个扇区的内容
     
161.                 for(i=0;i<secremain;i++)//校验数据
     
162.                 {
     * Z  h& s, @8 g/ K" G- W7 M
163.                         if(W25QXX_BUF[secoff+i]!=0XFF)break;//需要擦除            
     & b% t& e: F7 t! Y2 t( H
164.                 }
     
165.                 if(i<secremain)//需要擦除
     
166.                 {
     
167.                         W25QXX_Erase_Sector(secpos);                //擦除这个扇区
     
168.                         for(i=0;i<secremain;i++)                           //复制
     . x6 d8 q- e7 [. Y( Q8 |6 F; H4 G
169.                         {
     
170.                                 W25QXX_BUF[i+secoff]=pBuffer;         
     $ |! x6 i3 F4 q
171.                         }
     8 J7 l* o  a+ z9 [! L
172.                         W25QXX_Write_NoCheck(W25QXX_BUF,secpos*4096,4096);//写入整个扇区  
     
173. 
     
174.                 }else W25QXX_Write_NoCheck(pBuffer,WriteAddr,secremain);//写已经擦除了的,直接写入扇区剩余区间.                                    
     
175.                 if(NumByteToWrite==secremain)break;//写入结束了
     ! G$ Q% G' |# ~% ~- ~- \
176.                 else//写入未结束
     
177.                 {
     / w0 n  O' L9 n/ M/ v6 m5 ]) s
178.                         secpos++;//扇区地址增1
     ! n7 C/ q' k0 F, O  P
179.                         secoff=0;//偏移位置为0         
     
180. 
     
181.                            pBuffer+=secremain;                                  //指针偏移
     # Y0 |! l/ Q, q- A3 r7 g
182.                         WriteAddr+=secremain;                                //写地址偏移           
     
183.                            NumByteToWrite-=secremain;                        //字节数递减
     - R7 X) v. @7 ~5 B6 d' G: R
184.                         if(NumByteToWrite>4096)secremain=4096;//下一个扇区还是写不完
     
185.                         else secremain=NumByteToWrite;                //下一个扇区可以写完了
     0 W  c  Y% z: S6 f0 r+ q
186.                 }         
     - ]1 b$ q3 c! Z: ]/ L
187.         }
     1 h- N9 F4 [( Z# a
188. //        _mem.Free(W25QXX_BUF);
     ' S6 G/ n; h" q) m
189. }
     5 ?' [/ i1 K7 y7 b
190. //擦除整个芯片                  
     
191. //等待时间超长...
     ; M. A7 ~# c/ p, Y+ B
192. void W25QXX_Erase_Chip(void)   
     
193. {                                   
     - }5 Y! r. L8 q( n% k9 [1 T
194.     W25QXX_Write_Enable();                                  //SET WEL
     
195.     W25QXX_Wait_Busy();   
     % `1 U/ k6 r: E% ?( P+ l
196.           W25QXX_CS_L();                                    //使能器件   
     " Q. p7 l: g0 G) v5 d
197.     SPI2_ReadWriteByte(W25X_ChipErase);                //发送片擦除命令  
     ; i4 \) `( T9 `, j0 |. d: C
198.         W25QXX_CS_H();                                    //取消片选                  
     4 n8 d1 ]6 E6 f( N2 o9 \
199.         W25QXX_Wait_Busy();                                                      //等待芯片擦除结束
     $ w5 l* T( Y* R5 ?  O/ J/ a+ E
200. }   
     
201. //擦除一个扇区
     + r% j# N. x1 V1 c5 J( A
202. //Dst_Addr:扇区地址 根据实际容量设置
     
203. //擦除一个山区的最少时间:150ms
     
204. void W25QXX_Erase_Sector(u32 Dst_Addr)   
     
205. {  
     
206.         //监视falsh擦除情况,测试用   
     
207. //         printf("fe:%x\r\n",Dst_Addr);         
     1 K+ L9 o, J4 [6 V/ h% Q- `9 S: |, X
208.          Dst_Addr*=4096;
     - J' b% F, ~6 x8 y/ N. h8 l1 E
209.     W25QXX_Write_Enable();                          //SET WEL         
     % b# F  ~( x5 h
210.     W25QXX_Wait_Busy();   
     
211.           W25QXX_CS_L();                                    //使能器件   
     
212.     SPI2_ReadWriteByte(W25X_SectorErase);              //发送扇区擦除指令
     1 [7 B  [/ H% z* l4 ?
213.     SPI2_ReadWriteByte((u8)((Dst_Addr)>>16));          //发送24bit地址   
     
214.     SPI2_ReadWriteByte((u8)((Dst_Addr)>>8));   
     
215.     SPI2_ReadWriteByte((u8)Dst_Addr);  
     
216.         W25QXX_CS_H();                                    //取消片选                  
     
217.     W25QXX_Wait_Busy();                                                      //等待擦除完成
     
218. }  
     4 g- N* w, ~) L6 b( u" r! A
219. //等待空闲
     
220. void W25QXX_Wait_Busy(void)   
     
221. {   
     , r  \3 |2 |7 z3 f
222.         while((W25QXX_ReadSR()&0x01)==0x01);                  // 等待BUSY位清空
     
223. }  
     6 R& N9 h# a" |- S! ~: M8 i
224. //进入掉电模式
     
225. void W25QXX_PowerDown(void)   
     5 K( l5 O; O/ \3 y
226. {
     + @9 d0 q9 E. N; e, _
227.           W25QXX_CS_L();                                            //使能器件   
     
228.     SPI2_ReadWriteByte(W25X_PowerDown);        //发送掉电命令  
     7 M1 x# C7 c) k
229.         W25QXX_CS_H();                                    //取消片选                  
     
230.     Delay_us(3);                               //等待TPD  
     
231. }   
     
232. //唤醒
     0 |1 W. r' }3 ~3 X
233. void W25QXX_WAKEUP(void)   
     , v! `) {; n0 |- X7 }
234. {  
     
235.           W25QXX_CS_L();                                    //使能器件   
     
236.     SPI2_ReadWriteByte(W25X_ReleasePowerDown);        //  send W25X_PowerDown command 0xAB   
     
237.         W25QXX_CS_H();                                    //取消片选                  
     ; p' @- n  f" P- ~/ Z* O6 j
238.     Delay_us(3);                                    //等待TRES1
     . f$ W+ l/ J# r# h) M
239. }   

复制代码

. W1 H. d! `( p6 tH文件
2 ?% t, C: ?0 J5 f# ]* g5 y
5 H4 _4 P% `0 u5 k

1. #ifndef __FY_W25QXX_H
   
2. #define __FY_W25QXX_H                           
   , M8 p' o: `; G3 a- ]
3. 
   
4. #include "fy_includes.h"
   
5. 
   0 j' D, A6 f5 O" |- o; t  G# P
6. //W25QXX对应唯一识别ID
   + W1 w: s3 c5 F
7. #define W25Q80         0XEF13
   
8. #define W25Q16         0XEF14
   
9. #define W25Q32         0XEF15
     W1 s% [8 s& Q$ ^2 Y5 ?- m
10. #define W25Q64         0XEF16
    
11. #define W25Q128        0XEF17
    
12. 
    
13. //指令表
    ' ^  S' x8 m  t7 r+ c2 n' `
14. #define W25X_WriteEnable                0x06
    $ Z/ U6 v4 Q% [
15. #define W25X_WriteDisable                0x04
      k$ _0 {! j3 ~( z6 c
16. #define W25X_ReadStatusReg                0x05
    
17. #define W25X_WriteStatusReg                0x01
    4 v& D2 ]- W# j0 X+ H7 s
18. #define W25X_ReadData                        0x03
    9 _- T# b* {, p- m( J) Q3 R
19. #define W25X_FastReadData                0x0B
    ! l# A: c2 ~! Q- L& e  C7 i
20. #define W25X_FastReadDual                0x3B
    8 R6 w( B, N8 U4 g# q# v
21. #define W25X_PageProgram                0x02
    
22. #define W25X_BlockErase                        0xD8
    - o* H2 h; L! H( `; d
23. #define W25X_SectorErase                0x20
    # d. R8 \6 d: l6 q1 a
24. #define W25X_ChipErase                        0xC7
    
25. #define W25X_PowerDown                        0xB9
    7 F$ ~3 G2 n: k
26. #define W25X_ReleasePowerDown        0xAB
    
27. #define W25X_DeviceID                        0xAB
    2 d$ P* d. p+ @& v
28. #define W25X_ManufactDeviceID        0x90
    6 }3 J& c; P& @1 L6 l" B. W* _
29. #define W25X_JedecDeviceID                0x9F
    
30. 
    
31. void W25QXX_Configuration(void);
    
32. u16  W25QXX_ReadID(void);                              //读取FLASH ID
    
33. u8         W25QXX_ReadSR(void);                        //读取状态寄存器
    9 p$ w+ U' s7 `( H5 y
34. void W25QXX_Write_SR(u8 sr);                          //写状态寄存器
    
35. void W25QXX_Write_Enable(void);                  //写使能
    
36. void W25QXX_Write_Disable(void);                //写保护
    + r4 \' u6 z% S4 W/ ~& T
37. void W25QXX_Write_NoCheck(u8* pBuffer,u32 WriteAddr,u16 NumByteToWrite);
    ; h" y5 _2 K4 n4 f( k7 F$ d
38. void W25QXX_Read(u8* pBuffer,u32 ReadAddr,u16 NumByteToRead);   //读取flash
    : l5 ?2 {; i- S) _2 a5 m
39. void W25QXX_Write(u8* pBuffer,u32 WriteAddr,u16 NumByteToWrite);//写入flash
    
40. void W25QXX_Erase_Chip(void);                      //整片擦除
    
41. void W25QXX_Erase_Sector(u32 Dst_Addr);        //扇区擦除
    4 O, X( ?; ]. d  e* U; i8 T
42. void W25QXX_Wait_Busy(void);                   //等待空闲
    
43. void W25QXX_PowerDown(void);                //进入掉电模式
    * I0 x9 h4 B+ }1 A7 }
44. void W25QXX_WAKEUP(void);                                //唤醒
    
45. 
    
46. extern u16 W25QXX_TYPE;                                        //定义W25QXX芯片型号                  
    3 a) F. O% W2 n- j3 K
47. 
    
48. #endif

复制代码

基础工程如下：
& s( N' f+ Y; x% e* M# [3 g% `, V
, U/ ]* |! ^- r6 ~

( t& O) g- a7 Y2 m第四步：USB代码移植
+ A& {: x) h& ~& g5 D; d/ u拷贝USB底层库到工程根目录，新建一个目录命名成USB，拷贝Mass_Storage例程下的src和inc目录下的所以文件到USB。
4 ^: E  [' V3 c# u3 j8 ^


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

- q- S3 l/ m3 q; |6 W" G% E
' s* b6 r) T8 B: c. w
4.打开工程把分组和文件及包含路径添加进去，这里就不细说了，结果如下

9 G5 Y# C" b, E- e. [, \
7 F/ F9 ~0 w8 R9 \( |4 J& d) L1 g
打开usb下面的main和it 把重要的代码先拷贝出来


; }, k3 d& l- ]/ q/ ~9 F" Z
# R" W* q" ?* n+ ?# H5 R: ^把main和stm32_it里面的内容拷贝到自己的main里面进行下封装去掉不要的保留剩下的，然后就删除it和main三个文件。

& B- i, s8 z" C+ w

然后编译下，这个时候会出现一堆报错，需要慢慢一步步搞定，编译前注意路径包含，
! i) U0 p/ x" J$ r. I: R; |
0 h! H! k. B: \: M

定位到第一个错误进去

) h6 S, e- m1 r) z

这个定义的是官方的开发板 我们直接修改成自己的公共文件就可以，并且注释掉开发板定义
- i* v. b0 F" [9 @7 C" ~8 }


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



$ V' i) T; i: T9 j  x7 u继续编译，定位第一个错误，这部分主要修改hw_config文件

: G" C( J8 [% O) x
! o) d: d, t1 ]% ]2 n& }
删除Set_System函数


6 Y  J# {; l3 r5 h1 `1 U
! g' e+ p2 q( b" Q3 |8 M9 i6 e删除Led_Config函数

$ @8 g( F8 [( U# T" \, F
) a& Z' v3 C; L- I* |8 e, ?# u
7 N8 Y  E# K# L6 J注释LED相关的内容
. |* F( d$ d. ^  B2 E+ B9 q3 n
! O( d; J% d# `, C+ s, O* @( z
- B5 |5 `  o( ^8 m
) g! W1 Y7 M, s/ ?$ i' a% p删除USB_Disconnect_Config
# H- m* u7 Q6 b# F; @
5 _' a% j' q4 F5 I

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


: k4 |6 n. I( f6 B
头文件
  B: A, k' e% L8 x) a4 z$ ]: o7 O
' m* d* F* L% Q1 H3 Z
3 B) j1 m1 l4 _4 b1 K- I" U# o+ i
下面修改memory文件，主要修改变量定义，C文件和H文件分别如下
$ q1 N2 H; `( d) }9 E) r: u. B* d( \( B' E

7 v/ E; c# D- i/ d! w- ]
接下来是usb_scsi部分的变量定义
6 }- k- c. m4 W' ]: H" ?6 s- j
# g# A! O/ m* H2 ]

这时候再次编译就发现没有错误了，但是这个地方USB中断部分还需要配置下，官方用的宏定义方式去实现不同的代码，这里一开始就去掉了宏，所以最终修改如下：
+ Y* q0 P( \) ^5 W
' ~; H, E( [, K) f3 [9 B  d' [& U; Z

1. /*******************************************************************************
   * Q% u: g# p4 _( {% p
2. * Function Name  : USB_Interrupts_Config
   ; |- n& }) |' R7 ~
3. * Description    : Configures the USB interrupts
   
4. * Input          : None.
   
5. * Return         : None.
   & I" E  v3 u% q- ?6 x9 A
6. *******************************************************************************/
   
7. void USB_Interrupts_Config(void)
   
8. {
     m! S( ~/ s* G* h  K* S
9.         
   ( \: ~9 o; @' u0 p% J3 n# X
10.         NVIC_InitTypeDef NVIC_InitStructure;
    
11.         EXTI_InitTypeDef EXTI_InitStructure;
    , e# S1 G% y" Q- t7 i* R
12. 
    
13. 
    
14.         /* Configure the EXTI line 18 connected internally to the USB IP */
    
15.         EXTI_ClearITPendingBit(EXTI_Line18);
    ( k" Q0 r9 c9 @, l0 R9 t& F
16.                                                                                           //  开启线18上的中断
    
17.         EXTI_InitStructure.EXTI_Line = EXTI_Line18; // USB resume from suspend mode
    3 w$ q. w% A6 M5 g
18.         EXTI_InitStructure.EXTI_Trigger = EXTI_Trigger_Rising;        //line 18上事件上升降沿触发
    
19.         EXTI_InitStructure.EXTI_LineCmd = ENABLE;
    , K2 e0 X  a9 v& j! F  a$ ?/ Y
20.         EXTI_Init(&EXTI_InitStructure);         
    2 r8 X$ X* d, V- n  S' Q
21. 
    
22.         /* Enable the USB interrupt */
    - V# N7 [$ k/ Y" ]- O) E; u' C
23.         NVIC_InitStructure.NVIC_IRQChannel = USB_LP_CAN1_RX0_IRQn;        //组2，优先级次之
    
24.         NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 1;
    
25.         NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0;
    
26.         NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
    ' A* N; s; z4 d8 E
27.         NVIC_Init(&NVIC_InitStructure);
    1 |# q+ n2 l8 r2 W( {
28.         
    
29.         /* Enable the USB Wake-up interrupt */
    
30.         NVIC_InitStructure.NVIC_IRQChannel = USBWakeUp_IRQn;   //组2，优先级最高        
    6 M5 i" I. Q5 a5 c6 h6 Z" L
31.         NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 0;
    ) p' I' l" D0 N$ i2 Z2 [
32.         NVIC_Init(&NVIC_InitStructure);  
    0 V" |  E+ n% ?+ O! d3 v$ p1 C
33. 
    
34. 
    
35. }

复制代码

3 X0 u# L4 |: c8 U/ Q再注释掉USB_Cable_Config的内容（DP上有1.5K上拉电阻）并修改中断函数
9 S. f0 v% D3 i% s' R9 I

1. //USB唤醒中断服务函数
   
2. void USBWakeUp_IRQHandler(void)
   
3. {
   * V' W  q* L0 s1 \$ _$ @
4.         EXTI_ClearITPendingBit(EXTI_Line18);//清除USB唤醒中断挂起位
   
5. }

复制代码

+ d3 e* U+ T& y1 b修改pwr的Suspend内容：
+ [/ I1 V( }" j8 \% {
2 ]% V( a  l8 \

1. void Suspend(void)
   2 L1 E3 {# D: t9 y$ w7 h
2. {
   $ R, e5 C# r+ C% ~6 X
3.         uint32_t i =0;
   
4.         uint16_t wCNTR;
   0 X2 M' U) b0 W
5.         __IO uint32_t savePWR_CR=0;
   , M$ x& U& k$ b8 w9 p! _* r
6.         /* suspend preparation */
   
7.         /* ... */
   
8.         
   ( m2 a) o( ^5 l; u% E; z, x
9.         /*Store CNTR value */
   
10.         wCNTR = _GetCNTR();  
    * H" l6 X9 A7 `3 u6 Z
11. 
    : c% h5 M+ J7 k& K, ~$ Z. O
12.     /* This a sequence to apply a force RESET to handle a robustness case */
    ; c) C  O4 b; W
13. 
    
14.         /*Store endpoints registers status */
    2 A  t$ I* [  w3 \# _
15.     for (i=0;i<8;i++) EP = _GetENDPOINT(i);
    
16.         
    
17.         /* unmask RESET flag */
    
18.         wCNTR|=CNTR_RESETM;
    & |9 O. k; g  W6 ]7 [
19.         _SetCNTR(wCNTR);
    
20.         
    , j8 f" l) F% b; h
21.         /*apply FRES */
    
22.         wCNTR|=CNTR_FRES;
    
23.         _SetCNTR(wCNTR);
    5 K  o. }% g5 `. @2 }
24.         
    
25.         /*clear FRES*/
    
26.         wCNTR&=~CNTR_FRES;
    
27.         _SetCNTR(wCNTR);
    3 [0 @4 N( x! A1 N, ?
28.         
    
29.         /*poll for RESET flag in ISTR*/
    
30.         while((_GetISTR()&ISTR_RESET) == 0);
    
31.         
    8 ^$ H9 ~" V: T1 j% d
32.         /* clear RESET flag in ISTR */
    
33.         _SetISTR((uint16_t)CLR_RESET);
    : a4 \( o/ [4 e- ?
34.         
    3 \  n3 _& y* x% N9 W6 Q
35.         /*restore Enpoints*/
    8 |+ v$ d! }/ s) W4 C# D
36.         for (i=0;i<8;i++)
    % D. I4 W+ c. [6 |0 ~" f
37.         _SetENDPOINT(i, EP);
    
38.         
    5 [6 [$ S% p- k: d
39.         /* Now it is safe to enter macrocell in suspend mode */
    - a; h0 U' h! T' H. D2 ]
40.         wCNTR |= CNTR_FSUSP;
    ' [$ y, f. ~9 ~% T
41.         _SetCNTR(wCNTR);
    
42.         
    
43.         /* force low-power mode in the macrocell */
    
44.         wCNTR = _GetCNTR();
    & f) b) `6 \' Z8 X) r+ q$ w
45.         wCNTR |= CNTR_LPMODE;
    ) Y" _3 {8 \9 S1 Q
46.         _SetCNTR(wCNTR);
    2 M) r. w$ c4 J# @6 c: U6 D
47.         
    ) T$ W/ s  j' U5 ^8 }# b
48.         Enter_LowPowerMode();
    " R2 d4 e& q% L2 f  K
49. }
    5 D) G6 X; c" H# j

复制代码

% E. q3 q/ W3 Y7 m" b# u6 b" b把USB初始化部分不要的注释掉：
% }, I0 g. `. B, Q
$ Q0 l5 }+ o  I

1. void USB_MSC_Configuration(void)
   
2. {
   
3. //  Set_System();
   
4.   Set_USBClock();
   # L* @* B5 s9 n. g' t2 {+ r
5. //  Led_Config();
   
6.   USB_Interrupts_Config();
   , u4 i# M  f4 ?6 S
7.   USB_Init();
   0 Z& ~/ d: U# j. |
8. //  while (bDeviceState != CONFIGURED);
   % X. H* l, {. ~
9. 
   
10. //  USB_Configured_LED();
    2 |  t- ?8 d8 m6 Y* W: z
11. 
    
12. //  while (1)
    
13. //  {}
    0 e: r* c/ v$ ~* n
14. }

复制代码

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

/ A- e# q5 h. _. v, ?8 i- S

1.     Mass_Memory_Size[0]=1024*1024*4;        //w25q64->8M 给4M做U盘
   6 O3 l: B$ J& z8 y+ E+ S+ Z
2.     Mass_Block_Size[0] =512;                        //设置SPI FLASH的操作扇区大小为512
   
3.     Mass_Block_Count[0]=Mass_Memory_Size[0]/Mass_Block_Size[0];
   
4. 
     T; e& H- r6 X+ c' U$ q
5.         USB_MSC_Configuration();

复制代码

! Z5 t! s. ~2 E4 x. C$ @
& I6 a; R: ?. A+ }' x$ }& P
4 I6 I9 ~4 Z$ {: i编译下载后就可以正常运行了。
/ f* o; ?5 o; k, n  s. z

1 I( Q0 \- M$ o# E9 h
传输文件、新建文件夹都可以了，就是传输速度感人。
8 [, ]' Y" ~' z: }; Y/ s4 {0 q4 L
以上就是USB虚拟U盘的所有内容了，内容太多而且复杂，所以如果真的想亲手试试，还是要点耐心的。虽然能学到的并不是很多，这里主要可以干茶mass_mal部分，可以学到不少东西，方便以后的熟练运用。我这里也是为以后更进一步的开发做铺垫。

/ z; K; H; b# L' N# Z