学习stm32已经很长时间了，但是一直没有过多的学习stm32的USB部分，因为实际工作还是用的比较少。说起USB那就有的说了，因为USB的功能很强大，这里主要重点记录一下STM32的USB部分，这个官方给的有专门USB库，笔者目前使用的是Cotex-M3内核的STM32F103系列，实验的芯片为STM32F103C8，这个是目前市场上性价比非常高的芯片，也是用的非常多的芯片。
( p$ R, U- D) |
$ |3 S- u8 R3 P% y$ X1 V0 {/ y, @USB基础知识
% u- x; W7 o: _$ Z+ v0 @USB按接口类型分
控制器/主机（controller/host）
& K+ `$ L! {& L$ M6 V+ p% J
6 W( T5 {" o& Q- `2 c设备（peripheral）
) ]2 s5 m$ x/ y: V- f; B3 r
OTG（on-the-go），通过id线确定作为主机还是作为设备
! p7 m. S5 L5 ?
' T, F  y3 ^! X3 g+ J8 X% J/ q按照USB速度分

低速（low speed）

; j0 j$ [% @5 H  o+ G全速（full speed）

高速（high speed）

USB接口一般是4根线，VCC GND DM(D-) DP(D+)
+ @3 ^* [3 M3 u
低速设备：在DM线上接入上拉
) l  G. \$ P* W( f' s' G; P9 m+ V
全速设备：在DP线上接入上拉

高速设备：在DP线上接入上拉，在主机对设备进行复位后进一步的确认
8 }2 }- m( D, h7 o% V( x
% G0 D$ T! ~  T9 I
关于描述符
; j' y2 Y% m6 s* v7 O设备描述符（device description）

5 N- ?; u4 D+ _+ z$ X, i/ l2 w9 m' ]配置描述符（config description）
- g( A8 @( a- S' [
接口描述符 （interface description）

端点描述符 （endpoint description）

$ p% ], t6 N9 C5 D& |. i( T

: K6 j3 p5 ?6 \  n+ g7 }. p! ~设备的“身份”信息存储在描述符中。每个USB设备中都有如下描述符。需要注意的是一个USB设备只能有一个设备描述符，一个设备描述符可以有多个配置描述符，一个配置描述符可以有多个接口描述符，一个接口描述符可以包含多个端点。
: O  P- e( a! o, `; F* k
9 f  n! G7 ~! `关于传输
. v$ |1 r6 I8 r* x1 {1.在USB的通讯中，有传输（transfer），事务（Transaction），包（packet）三级。包是最基础的传输单元，与TCP/IP协议中的MAC层协议作用相同。
- j; k, }' @# ?2.在一次传输中，由多次事务组成，每次的事务又由多个包组成
3.与众多协议相同，较高级别的协议的报文是基于/内嵌在低级协议的报文当中的，在USB中也不例外，例如，包中预留了DATA位，其目的就是填写报文
2 |$ Q' x2 e! vSTM32F103芯片自带了有USB模块，可以用来做从设备，不能用作主机HOST。这里使用USB的目的是讲USB作为一个大容量，这个可以基于官方USB Mass_Storage例程来移植。这里就不过多的介绍里面复杂的通信原理了，要彻彻底底搞明白并灵活运用取来还是有很大难度的，因为内容太多了。这里仅仅介绍下移植过程和描述符相关的重点内容。

" y  {2 B* B8 u! k. f0 H准备工作
' ~/ M1 S+ L+ j第一步
; p0 d+ g. }2 r) z3 k确保自己的KEIL开发环境已经完善。

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


3 q% C8 m/ W8 E) h
第三步
: F+ Y& G: x2 p/ Z9 e建立一个带有存储介质驱动的STM32基础工程，存储介质常见有SD卡、外部FLASH芯片、内部的FLASH空间。的我是基于一个外部flash的工程去实现的，芯片具体型号是W25Q64，64Mbit的空间，换成字节就是8MByte。驱动部分如下：

$ B( w, ]* B& d3 T& ^; TC文件

1. #include "fy_w25qxx.h"
   2 K0 e- L) K1 m7 \$ O& i: K# s
2. 
   7 M8 u' U, |) v- i, ^: R8 c- D
3. u16 W25QXX_TYPE=0;//W25Q64
   
4. 
   
5. //4Kbytes为一个Sector,16个扇区为1个Block,容量为16M字节,共有128个Block,4096个Sector
   
6. //初始化SPI FLASH的IO口
   
7. void W25QXX_Configuration(void)
   
8. {        
   4 G  A' d& H) g
9.         SPI2_SetSpeed(SPI_BaudRatePrescaler_2);//设置为18M时钟,高速模式
   % N+ E- L, h4 [# |5 y8 i# `( O
10.         W25QXX_TYPE=W25QXX_ReadID();//读取FLASH ID.  
    
11. }         
    
12. 
    + Y/ \) t* M; c$ e: _- u
13. //读取W25QXX的状态寄存器
    ; e- q; t3 w4 m. Z
14. //BIT7  6   5   4   3   2   1   0
    1 H8 s0 x1 V0 x+ j
15. //SPR   RV  TB BP2 BP1 BP0 WEL BUSY
    
16. //SPR:默认0,状态寄存器保护位,配合WP使用
    
17. //TB,BP2,BP1,BP0:FLASH区域写保护设置
    
18. //WEL:写使能锁定
    * x4 @. r- M; |0 V8 G7 u( `+ W
19. //BUSY:忙标记位(1,忙;0,空闲)
    # f( |& q2 p5 `( L
20. //默认:0x00
    & Q6 V4 |& x- C
21. u8 W25QXX_ReadSR(void)   
    ( d( {+ _2 x  W; l% e
22. {  
    
23.         u8 byte=0;   
    ; B0 C8 `, ^1 t% [  }; F7 T0 G' m
24.         W25QXX_CS_L();                            //使能器件   
    
25.         SPI2_ReadWriteByte(W25X_ReadStatusReg); //发送读取状态寄存器命令   
    , S( O, V) Q% |& N) _3 T1 Y
26.         byte=SPI2_ReadWriteByte(0Xff);          //读取一个字节  
    
27.         W25QXX_CS_H();                            //取消片选     
    - C- s9 }7 z. q; w3 N& c
28.         return byte;   
    
29. }
    
30. //写W25QXX状态寄存器
    2 A4 y8 ~  T' C  s
31. //只有SPR,TB,BP2,BP1,BP0(bit 7,5,4,3,2)可以写!!!
    ; |4 a. T3 F2 |9 W% J
32. void W25QXX_Write_SR(u8 sr)   
    
33. {   
    
34.         W25QXX_CS_L();                            //使能器件   
    
35.         SPI2_ReadWriteByte(W25X_WriteStatusReg);//发送写取状态寄存器命令   
    + c  ~* k' j; [+ Y/ y. }" w" d# a
36.         SPI2_ReadWriteByte(sr);                       //写入一个字节  
    1 Q5 H# J- F) n+ o5 C! Q/ g
37.         W25QXX_CS_H();                            //取消片选                  
    
38. }   
    
39. //W25QXX写使能        
    
40. //将WEL置位   
    % b  u" k& c& L, ?6 _
41. void W25QXX_Write_Enable(void)   
    : O1 W2 {6 @8 i( |) Z8 `! n! \
42. {
    
43.         W25QXX_CS_L();                                  //使能器件   
    
44.     SPI2_ReadWriteByte(W25X_WriteEnable);         //发送写使能  
    
45.         W25QXX_CS_H();                                   //取消片选                  
    
46. }
    ' l; r* |; I2 ]( u  ?
47. //W25QXX写禁止        
    + j( u0 m6 U. s1 X# F
48. //将WEL清零  
    
49. void W25QXX_Write_Disable(void)   
    ; S6 q, g" [1 }. D& T
50. {  
    
51.         W25QXX_CS_L();                            //使能器件   
    
52.     SPI2_ReadWriteByte(W25X_WriteDisable);  //发送写禁止指令   
    8 G; K, ]% D! w& c1 Z6 y0 p7 K
53.         W25QXX_CS_H();                            //取消片选                  
    
54. }                 
    
55. 
    
56. //读取芯片ID
    " T% X$ K4 B4 R  o
57. u16 W25QXX_ReadID(void)
    
58. {
    
59.         u16 Temp = 0;         
    8 a& D7 t7 E5 b& v' H
60.         W25QXX_CS_L();                                    
    
61.         SPI2_ReadWriteByte(0x90);//发送读取ID命令            
    7 j0 `& `$ _- {; u: e! V! c& n
62.         SPI2_ReadWriteByte(0x00);            
    
63.         SPI2_ReadWriteByte(0x00);            
    : [+ p0 r; }  j
64.         SPI2_ReadWriteByte(0x00);                                    
    - C6 n! D/ P- M& A7 X) f
65.         Temp|=SPI2_ReadWriteByte(0xFF)<<8;  
    
66.         Temp|=SPI2_ReadWriteByte(0xFF);         
    
67.         W25QXX_CS_H();                                    
    
68.         return Temp;
    
69. }                       
    7 D5 W" E) }# Q0 Q( F0 `  @
70. 
    , b' }$ N7 u* V0 r1 u9 h- y0 O
71. //在指定地址开始读取指定长度的数据
    
72. //pBuffer:数据存储区,ReadAddr:开始读取的地址(24bit),NumByteToRead:要读取的字节数(最大65535)
    
73. void W25QXX_Read(u8* pBuffer,u32 ReadAddr,u16 NumByteToRead)   
    / R1 n* x; Z% Q9 J6 ?! f
74. {
    2 _0 ^- `+ A) ~4 o8 T7 z) @
75.          u16 i;                                                                                       
    ) ~/ H4 S, ~& ?. T* T4 H( t
76.         W25QXX_CS_L();                                    //使能器件   
    
77.         SPI2_ReadWriteByte(W25X_ReadData);                 //发送读取命令   
    
78.         SPI2_ReadWriteByte((u8)((ReadAddr)>>16));          //发送24bit地址   
    
79.         SPI2_ReadWriteByte((u8)((ReadAddr)>>8));   
    " {8 i5 `4 A# [& d$ m) x7 U
80.         SPI2_ReadWriteByte((u8)ReadAddr);   
    ) Q; j5 n- ?: a4 f6 M+ x
81.         for(i=0;i<NumByteToRead;i++)
    
82.         {
    
83.         pBuffer=SPI2_ReadWriteByte(0XFF);           //循环读数  
    8 T7 }  L) J, ?2 T, F
84.   }
    4 [  U7 {0 y3 l) I: v# x) u  W; m) ?4 a
85.         W25QXX_CS_H();                                                   
    
86. }
    
87. 
      U# b. T, F" a/ k; k! p
88. //SPI在一页(0~65535)内写入少于256个字节的数据
    8 g+ {- F5 {2 s- k) B
89. //在指定地址开始写入最大256字节的数据
    7 y. E+ q3 r# Z8 I( o1 M7 I
90. //pBuffer:数据存储区,WriteAddr:开始写入的地址(24bit),NumByteToWrite:要写入的字节数(最大256),该数不应该超过该页的剩余字节数!!!         
    
91. void W25QXX_Write_Page(u8* pBuffer,u32 WriteAddr,u16 NumByteToWrite)
    . Z) X* l! x* @' G6 X; l
92. {
    0 \( ^/ x7 c! [0 h0 ?
93.          u16 i;  
    % F+ C6 }8 G% ^# f9 ]) y  N
94.         W25QXX_Write_Enable();                          //SET WEL
    # O2 k( j: |- K3 C# Y2 j5 x0 P
95.         W25QXX_CS_L();                                    //使能器件   
    
96.         SPI2_ReadWriteByte(W25X_PageProgram);              //发送写页命令   
    3 K9 U: A3 y# f% }
97.         SPI2_ReadWriteByte((u8)((WriteAddr)>>16));         //发送24bit地址   
    ) G- A2 ^7 A0 W: W! d
98.         SPI2_ReadWriteByte((u8)((WriteAddr)>>8));   
    " W! u' n2 ]1 c  Z8 }; b; G
99.         SPI2_ReadWriteByte((u8)WriteAddr);   
    
100.         for(i=0;i<NumByteToWrite;i++)SPI2_ReadWriteByte(pBuffer);//循环写数  
     " T( D% c9 @) }& c. b7 @
101.         W25QXX_CS_H();                                    //取消片选
     
102.         W25QXX_Wait_Busy();                                                           //等待写入结束
     ( `( C8 L3 g9 [; o$ k6 Y! A
103. }
     * ~. i4 g/ G2 i3 L' C8 T
104. //无检验写SPI FLASH
     
105. //必须确保所写的地址范围内的数据全部为0XFF,否则在非0XFF处写入的数据将失败!
     ) ~" w& Y  X, Q, t
106. //具有自动换页功能
     
107. //在指定地址开始写入指定长度的数据,但是要确保地址不越界!
     
108. //pBuffer:数据存储区
     4 z- N- p+ M* B5 ~, l7 [
109. //WriteAddr:开始写入的地址(24bit)
     ) V0 D0 A; C( g9 k0 G
110. //NumByteToWrite:要写入的字节数(最大65535)
     ' k$ r: ?% q' I9 w, m: S
111. //CHECK OK
     
112. void W25QXX_Write_NoCheck(u8* pBuffer,u32 WriteAddr,u16 NumByteToWrite)   
     
113. {                                          
     
114.         u16 pageremain;           
     $ G: m" E# ]  t  Y
115.         pageremain=256-WriteAddr%256; //单页剩余的字节数                             
     
116.         if(NumByteToWrite<=pageremain)pageremain=NumByteToWrite;//不大于256个字节
     
117.         while(1)
     
118.         {           
     . Q/ ^3 \& a8 Z% U% L
119.                 W25QXX_Write_Page(pBuffer,WriteAddr,pageremain);
     
120.                 if(NumByteToWrite==pageremain)break;//写入结束了
     8 }) G. L! A. V0 b6 B. ]
121.                  else //NumByteToWrite>pageremain
     
122.                 {
     * M9 o8 ?* T2 F/ I2 v2 \
123.                         pBuffer+=pageremain;
     
124.                         WriteAddr+=pageremain;        
     5 J. X/ I$ X* Y; c; M+ j2 ?/ f
125. 
     
126.                         NumByteToWrite-=pageremain;                          //减去已经写入了的字节数
     
127.                         if(NumByteToWrite>256)pageremain=256; //一次可以写入256个字节
     
128.                         else pageremain=NumByteToWrite;           //不够256个字节了
     ( s$ F. r6 E0 _+ T- {
129.                 }
     3 p5 x( I% ~) i9 c
130.         };            
     
131. }
     & W( f1 x0 h, ]$ v% C. S
132. //写SPI FLASH  
     9 I$ Q7 V" `' Z) G2 i: D' I" a0 w
133. //在指定地址开始写入指定长度的数据
     # s3 s4 l( Q# L  K( u
134. //该函数带擦除操作!
     : j6 q6 C( G" ?6 N$ y; ^
135. //pBuffer:数据存储区
     . ?  w: r* O: y& m
136. //WriteAddr:开始写入的地址(24bit)                                                
     
137. //NumByteToWrite:要写入的字节数(最大65535)   
     
138. u8 W25QXX_BUFFER[4096];                 
     
139. void W25QXX_Write(u8* pBuffer,u32 WriteAddr,u16 NumByteToWrite)   
     
140. {
     + R) j$ S8 y3 X" {9 x# \4 b/ j
141.         u32 secpos;
     
142.         u16 secoff;
     
143.         u16 secremain;           
     4 Y& e& x2 w0 ^1 w* ^/ x$ B# T* i
144.          u16 i;   
     : q: g6 R% S% }; |  m
145.         u8 *W25QXX_BUF;         
     1 a; P' U3 X- q* g5 c4 v0 `
146.         
     
147.            W25QXX_BUF=W25QXX_BUFFER;
     
148. //        
     , a1 f! L% n4 H6 O6 w1 w: p+ z- X* K
149. //    W25QXX_BUF = (u8 *)_mem.Alloc(4096);//申请一个扇区大小的内存
     
150. //    if(W25QXX_BUF==NULL)        return;
     % L+ X' K; M: h/ L
151.         
     / l6 ]# K) `9 J7 F6 u, l6 E
152.          secpos=WriteAddr/4096;//扇区地址  
     ) s" Y+ T: Q- m
153.         secoff=WriteAddr%4096;//在扇区内的偏移
     * u, C, P$ X8 @
154.         secremain=4096-secoff;//扇区剩余空间大小  
     
155. 
     
156.          //printf("ad:%X,nb:%X\r\n",WriteAddr,NumByteToWrite);//测试用
     
157.          if(NumByteToWrite<=secremain)secremain=NumByteToWrite;//不大于4096个字节
     
158.         while(1)
     1 U8 d/ ]; o# R; U5 O" o9 y" s
159.         {        
     # D9 I* q( X6 h3 @$ @! v6 v
160.                 W25QXX_Read(W25QXX_BUF,secpos*4096,4096);//读出整个扇区的内容
     : D1 Q6 H) d( G
161.                 for(i=0;i<secremain;i++)//校验数据
     
162.                 {
     $ ~9 @# H1 x- ^0 W+ n- b% i2 w
163.                         if(W25QXX_BUF[secoff+i]!=0XFF)break;//需要擦除            
     
164.                 }
     
165.                 if(i<secremain)//需要擦除
     ( ~: b3 r9 N3 }% h7 d7 U0 T: N
166.                 {
     
167.                         W25QXX_Erase_Sector(secpos);                //擦除这个扇区
     0 X- N: R/ J. S/ f
168.                         for(i=0;i<secremain;i++)                           //复制
     1 ~" c4 I& `6 D( F* F2 W
169.                         {
     
170.                                 W25QXX_BUF[i+secoff]=pBuffer;         
     . J4 X: {- u* y. o8 s, `
171.                         }
     
172.                         W25QXX_Write_NoCheck(W25QXX_BUF,secpos*4096,4096);//写入整个扇区  
     
173. 
     " I2 r* B& f9 f9 e7 X, ?, J
174.                 }else W25QXX_Write_NoCheck(pBuffer,WriteAddr,secremain);//写已经擦除了的,直接写入扇区剩余区间.                                    
     
175.                 if(NumByteToWrite==secremain)break;//写入结束了
     
176.                 else//写入未结束
     
177.                 {
     5 Z* ~& r$ ?' u( t" l
178.                         secpos++;//扇区地址增1
     
179.                         secoff=0;//偏移位置为0         
     
180. 
     5 q5 O, G6 U2 d$ V" ^; t
181.                            pBuffer+=secremain;                                  //指针偏移
     
182.                         WriteAddr+=secremain;                                //写地址偏移           
     # O2 ?' l4 F4 V
183.                            NumByteToWrite-=secremain;                        //字节数递减
     
184.                         if(NumByteToWrite>4096)secremain=4096;//下一个扇区还是写不完
     , ]/ j8 e" d3 O/ g2 l
185.                         else secremain=NumByteToWrite;                //下一个扇区可以写完了
     ; z5 _% X+ \! Y, X
186.                 }         
     
187.         }
     , s% M9 V* c; l; R6 N
188. //        _mem.Free(W25QXX_BUF);
     2 r+ y+ g. i( T; |7 Q, G' c8 ~
189. }
     
190. //擦除整个芯片                  
     " e& ^) R/ }) Q, B/ V8 v$ W
191. //等待时间超长...
     4 @) E3 K' f! a+ c" E# f! U& C
192. void W25QXX_Erase_Chip(void)   
     ; g* l+ T* k0 U
193. {                                   
     
194.     W25QXX_Write_Enable();                                  //SET WEL
     9 V, P+ a; N9 B0 n+ Y* L* [6 u
195.     W25QXX_Wait_Busy();   
     ; {* o- N% _2 J5 [$ K0 Z
196.           W25QXX_CS_L();                                    //使能器件   
     ! r" {3 U. T' X6 a7 J! A& F9 x
197.     SPI2_ReadWriteByte(W25X_ChipErase);                //发送片擦除命令  
     ) \! @5 R' ^) z9 X
198.         W25QXX_CS_H();                                    //取消片选                  
     + Q  `  b( c# `& a
199.         W25QXX_Wait_Busy();                                                      //等待芯片擦除结束
     
200. }   
     2 N# ^7 G! C# B$ \
201. //擦除一个扇区
     
202. //Dst_Addr:扇区地址 根据实际容量设置
     
203. //擦除一个山区的最少时间:150ms
     6 W) y* p' |# F0 @9 ~
204. void W25QXX_Erase_Sector(u32 Dst_Addr)   
     
205. {  
     
206.         //监视falsh擦除情况,测试用   
     
207. //         printf("fe:%x\r\n",Dst_Addr);         
     
208.          Dst_Addr*=4096;
     3 |  ^% d- b- `! m
209.     W25QXX_Write_Enable();                          //SET WEL         
     
210.     W25QXX_Wait_Busy();   
       N2 M+ E4 N0 E9 s1 i5 X0 Z
211.           W25QXX_CS_L();                                    //使能器件   
     ) T; a0 E# _) c) c7 Y
212.     SPI2_ReadWriteByte(W25X_SectorErase);              //发送扇区擦除指令
     7 g; `6 O6 g- L9 m( m
213.     SPI2_ReadWriteByte((u8)((Dst_Addr)>>16));          //发送24bit地址   
     * l; k/ E- [& I/ {  a# ]
214.     SPI2_ReadWriteByte((u8)((Dst_Addr)>>8));   
     
215.     SPI2_ReadWriteByte((u8)Dst_Addr);  
     
216.         W25QXX_CS_H();                                    //取消片选                  
     
217.     W25QXX_Wait_Busy();                                                      //等待擦除完成
     ; o( G' K7 _+ T' L3 ?9 g  g5 W' E
218. }  
     ; i1 [. l+ F6 w1 V
219. //等待空闲
     . E, y) j8 ^9 q3 [
220. void W25QXX_Wait_Busy(void)   
     
221. {   
     
222.         while((W25QXX_ReadSR()&0x01)==0x01);                  // 等待BUSY位清空
     , o3 c' D( T: I. F( |* s3 K% w4 a
223. }  
     
224. //进入掉电模式
     
225. void W25QXX_PowerDown(void)   
     
226. {
     $ k3 K0 C5 |. p  E: m" Y* t
227.           W25QXX_CS_L();                                            //使能器件   
     . Z7 E5 ]3 s+ k
228.     SPI2_ReadWriteByte(W25X_PowerDown);        //发送掉电命令  
     * I7 D) a: G% v
229.         W25QXX_CS_H();                                    //取消片选                  
     
230.     Delay_us(3);                               //等待TPD  
     
231. }   
     
232. //唤醒
     
233. void W25QXX_WAKEUP(void)   
     
234. {  
     : q; x* _! l0 y! ^: E. {
235.           W25QXX_CS_L();                                    //使能器件   
     & G4 `' K4 X0 \/ E1 U. [: V: W' K9 k
236.     SPI2_ReadWriteByte(W25X_ReleasePowerDown);        //  send W25X_PowerDown command 0xAB   
     3 T+ s1 D" P" T) b0 X; @
237.         W25QXX_CS_H();                                    //取消片选                  
     3 I! K; ~. r" g: O1 [) g
238.     Delay_us(3);                                    //等待TRES1
     
239. }   

复制代码

0 ?6 V4 |" ]+ R& |+ x  vH文件
! m$ O+ ]$ G+ x1 W7 q6 s
7 T0 Z0 _- O' N) |* y$ V

1. #ifndef __FY_W25QXX_H
   + W/ n4 q7 {4 u" F9 ]
2. #define __FY_W25QXX_H                           
   
3. 
   
4. #include "fy_includes.h"
   4 Q% x7 w; L' S4 u+ ~# O
5. 
   ' u+ i2 V/ {( t
6. //W25QXX对应唯一识别ID
   ; z( E! I" X! {# U" M$ @
7. #define W25Q80         0XEF13
   ; p2 M; o: \5 I1 `1 ]
8. #define W25Q16         0XEF14
   
9. #define W25Q32         0XEF15
   3 R, E6 u- R* H! Z9 @% P- ^* Q0 e
10. #define W25Q64         0XEF16
    2 q5 G. i" s  x- l6 X& i" {
11. #define W25Q128        0XEF17
    ! }3 T4 Y! B+ m
12. 
    " f4 [' ]8 H) O2 [2 a9 R% [
13. //指令表
    % a7 i; s* C# g( y0 Q. k4 A- R# B( P
14. #define W25X_WriteEnable                0x06
    5 F- ~' W  r- r* r
15. #define W25X_WriteDisable                0x04
    7 _0 n- Z  m9 r7 t
16. #define W25X_ReadStatusReg                0x05
      q0 Q! |3 N, Q3 n4 w' _
17. #define W25X_WriteStatusReg                0x01
    1 u, R: j3 O; c2 L1 ?7 Z# `1 Z
18. #define W25X_ReadData                        0x03
    
19. #define W25X_FastReadData                0x0B
    ) J/ v$ ?2 b; P  u# m6 u
20. #define W25X_FastReadDual                0x3B
    ; w2 X* O2 H9 D$ Q- ^
21. #define W25X_PageProgram                0x02
    
22. #define W25X_BlockErase                        0xD8
    ; ^! q, x" \/ Y, w+ j
23. #define W25X_SectorErase                0x20
    + v. d8 a# g; [) |% s! L
24. #define W25X_ChipErase                        0xC7
    5 E3 L  k! |% [) `! B8 C
25. #define W25X_PowerDown                        0xB9
    
26. #define W25X_ReleasePowerDown        0xAB
    ) S$ w) L2 c( Z: t
27. #define W25X_DeviceID                        0xAB
    2 k% w8 F. H9 A8 d) [
28. #define W25X_ManufactDeviceID        0x90
      m- T# N$ I/ i: m) M. W3 m5 A
29. #define W25X_JedecDeviceID                0x9F
    
30. 
    $ `8 y) _! a( [! g$ e6 L
31. void W25QXX_Configuration(void);
    
32. u16  W25QXX_ReadID(void);                              //读取FLASH ID
    - ]; ~7 J" Q6 u1 [7 ]$ y
33. u8         W25QXX_ReadSR(void);                        //读取状态寄存器
    
34. void W25QXX_Write_SR(u8 sr);                          //写状态寄存器
      p& I9 `4 C2 M2 }' j# F7 P3 Z
35. void W25QXX_Write_Enable(void);                  //写使能
    $ X2 g1 f0 [- Y, C- X
36. void W25QXX_Write_Disable(void);                //写保护
    
37. void W25QXX_Write_NoCheck(u8* pBuffer,u32 WriteAddr,u16 NumByteToWrite);
    . x* z6 N' N: l) X+ ]% j
38. void W25QXX_Read(u8* pBuffer,u32 ReadAddr,u16 NumByteToRead);   //读取flash
    - }* @5 {2 l/ G9 m! M
39. void W25QXX_Write(u8* pBuffer,u32 WriteAddr,u16 NumByteToWrite);//写入flash
    ( c: d9 R* |# {1 |& i  K, z& h9 Z0 i: g
40. void W25QXX_Erase_Chip(void);                      //整片擦除
    
41. void W25QXX_Erase_Sector(u32 Dst_Addr);        //扇区擦除
    
42. void W25QXX_Wait_Busy(void);                   //等待空闲
    6 P: a& {! C& z
43. void W25QXX_PowerDown(void);                //进入掉电模式
    
44. void W25QXX_WAKEUP(void);                                //唤醒
    
45. 
    
46. extern u16 W25QXX_TYPE;                                        //定义W25QXX芯片型号                  
    ' E8 d7 t/ L5 T  X# G
47. 
    
48. #endif

复制代码

基础工程如下：
) O  h, r+ y/ Z( ]& z
1 U0 Q4 x8 a, Q) P7 ~2 ?! k& e

; L  w- _# x$ J2 M1 u: A第四步：USB代码移植
拷贝USB底层库到工程根目录，新建一个目录命名成USB，拷贝Mass_Storage例程下的src和inc目录下的所以文件到USB。
  A: Z+ N4 j/ ~% u4 @0 A
& j. w+ u! x% t/ x. S  d, q4 @

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

+ A6 A& u% P3 l
9 h, M+ ~4 r" T, D
4.打开工程把分组和文件及包含路径添加进去，这里就不细说了，结果如下

" B5 d  s/ f! T8 a

打开usb下面的main和it 把重要的代码先拷贝出来
7 M) _; a. P4 K- z# c
: n% z$ k. h+ x

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


5 Y9 m4 M1 F4 }  |
' G$ z" P! |# C1 X3 i5 X然后编译下，这个时候会出现一堆报错，需要慢慢一步步搞定，编译前注意路径包含，

* o" r) G& t+ }# n5 u* F* K
3 s( f. L3 a8 g9 r: H5 ]
% |/ u8 F' S& g% O# K$ [0 X' ?定位到第一个错误进去


7 P' A- u! `6 E0 S, e* P8 _
这个定义的是官方的开发板 我们直接修改成自己的公共文件就可以，并且注释掉开发板定义
! j, P/ h7 i9 o+ w- W$ }


6 ~; I9 a: F) Y, [* X: F公共文件如下，并且添加usb部分的头文件


5 e/ I+ S( b) A( ~  K7 r8 ^, @
继续编译，定位第一个错误，这部分主要修改hw_config文件


3 y# d8 p; ~5 F" X: n9 f
删除Set_System函数



删除Led_Config函数
5 R1 K  Q( }. n$ s5 r. O
9 b7 ]2 T  r7 v) x

3 D8 V2 V. M+ ~) ?注释LED相关的内容
7 k* M& R4 M, D3 x# s& b6 _6 L


删除USB_Disconnect_Config

8 F/ [8 {6 o! e' c, s* j# m

接下来主要修改mass_mal部分，我这里是只有一个flash，所以我修改成如下：
: b! N* U2 i" c8 p$ V$ y

' G- _4 b9 [5 u6 G9 k
- n7 D5 L! S! n- a头文件
; g+ O& v' b) e# P3 g) O8 a
; O9 O( q* T! R6 G1 k  t/ A

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

* W2 p, a4 x8 q; Z3 ~; i3 l; F

/ q2 ^1 R5 W) U: ~- P2 i% z2 _" |6 Q( B接下来是usb_scsi部分的变量定义
# P# L0 R! \  G$ @) X


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

3 ]/ x$ u5 f$ W% [

1. /*******************************************************************************
   
2. * Function Name  : USB_Interrupts_Config
   
3. * Description    : Configures the USB interrupts
   
4. * Input          : None.
   
5. * Return         : None.
   
6. *******************************************************************************/
   
7. void USB_Interrupts_Config(void)
   0 N* k( {+ C& H
8. {
   
9.         
   4 e% u; y  i4 c* \
10.         NVIC_InitTypeDef NVIC_InitStructure;
    
11.         EXTI_InitTypeDef EXTI_InitStructure;
    ' {4 X5 i8 Q4 Y9 o5 Y  Q6 e
12. 
    
13. 
    : p  y4 r1 j. D1 x) W8 e& v2 C
14.         /* Configure the EXTI line 18 connected internally to the USB IP */
    
15.         EXTI_ClearITPendingBit(EXTI_Line18);
    + Q+ H  }) h% L5 z- k2 T
16.                                                                                           //  开启线18上的中断
    / z/ k( W5 K* R, o% Q# G9 g( B
17.         EXTI_InitStructure.EXTI_Line = EXTI_Line18; // USB resume from suspend mode
    
18.         EXTI_InitStructure.EXTI_Trigger = EXTI_Trigger_Rising;        //line 18上事件上升降沿触发
    % F) q6 y$ H9 ]5 |8 X5 A+ m, A
19.         EXTI_InitStructure.EXTI_LineCmd = ENABLE;
      E4 F2 r* x# V3 M6 @
20.         EXTI_Init(&EXTI_InitStructure);         
    0 {8 [9 J4 S% \4 d, l
21. 
    
22.         /* Enable the USB interrupt */
    2 i" d8 X9 T- [# m; T
23.         NVIC_InitStructure.NVIC_IRQChannel = USB_LP_CAN1_RX0_IRQn;        //组2，优先级次之
    
24.         NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 1;
    / n  }- P8 e. U& V( T' W
25.         NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0;
    
26.         NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
    9 M- s3 m( g7 p* S5 x7 Z3 |6 K
27.         NVIC_Init(&NVIC_InitStructure);
    $ K) H- U0 ^2 F8 P6 g
28.         
    
29.         /* Enable the USB Wake-up interrupt */
    
30.         NVIC_InitStructure.NVIC_IRQChannel = USBWakeUp_IRQn;   //组2，优先级最高        
    
31.         NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 0;
    ; |% v8 i0 @0 B9 T1 T$ x* u: l" {; u/ L1 S4 w
32.         NVIC_Init(&NVIC_InitStructure);  
    " a& t. `; n8 l% s/ F
33. 
    
34. 
    2 V$ d5 W- E% W2 O/ `" `; C
35. }

复制代码

- S" f( n/ h' ^( \再注释掉USB_Cable_Config的内容（DP上有1.5K上拉电阻）并修改中断函数
; J+ T5 _1 @7 ~6 z2 G3 |+ X

1. //USB唤醒中断服务函数
   1 O$ B/ j4 p$ @$ J) R) P- C. q
2. void USBWakeUp_IRQHandler(void)
   
3. {
   
4.         EXTI_ClearITPendingBit(EXTI_Line18);//清除USB唤醒中断挂起位
   
5. }

复制代码

! b4 l2 k9 |3 d修改pwr的Suspend内容：

3 ^1 F8 v  g" D5 f) M

1. void Suspend(void)
   ! j' P5 N  ^/ m3 ?) o2 [" Z8 L
2. {
   6 n2 w( z* _/ R" R2 y$ M- n
3.         uint32_t i =0;
   & ]5 j. |" F1 J% n$ d7 Y
4.         uint16_t wCNTR;
   
5.         __IO uint32_t savePWR_CR=0;
   
6.         /* suspend preparation */
   7 X  {7 F! K& @4 a# s* L) A
7.         /* ... */
   0 [6 F) o8 Q" Z: Q9 ]  h
8.         
   - W& r1 F( c# m& f
9.         /*Store CNTR value */
   
10.         wCNTR = _GetCNTR();  
    
11. 
    4 n- d1 J! h- @7 G* v
12.     /* This a sequence to apply a force RESET to handle a robustness case */
    ( e# {- E& z3 K6 a, W+ b
13. 
    
14.         /*Store endpoints registers status */
    0 ^6 R2 C  A- `3 @
15.     for (i=0;i<8;i++) EP = _GetENDPOINT(i);
    
16.         
    
17.         /* unmask RESET flag */
    6 u) _7 `; I2 o* ^
18.         wCNTR|=CNTR_RESETM;
    
19.         _SetCNTR(wCNTR);
    2 s' j( Q4 X' O6 `+ Z
20.         
    
21.         /*apply FRES */
    
22.         wCNTR|=CNTR_FRES;
    
23.         _SetCNTR(wCNTR);
    
24.         
    
25.         /*clear FRES*/
    
26.         wCNTR&=~CNTR_FRES;
    
27.         _SetCNTR(wCNTR);
    
28.         
    ; G+ P1 _2 h# D( h. z3 r5 \3 I
29.         /*poll for RESET flag in ISTR*/
    
30.         while((_GetISTR()&ISTR_RESET) == 0);
    
31.         
    $ Q! M) C8 h/ _4 i; `) {# {
32.         /* clear RESET flag in ISTR */
    4 ~1 L0 d! s3 f2 q7 k: B0 k
33.         _SetISTR((uint16_t)CLR_RESET);
    & m+ A" L# O! ?8 ]
34.         
    
35.         /*restore Enpoints*/
    # {; ?# w7 M( r2 n- |5 D2 e
36.         for (i=0;i<8;i++)
    
37.         _SetENDPOINT(i, EP);
    
38.         
    
39.         /* Now it is safe to enter macrocell in suspend mode */
    
40.         wCNTR |= CNTR_FSUSP;
    9 C( q- G# c8 }% U8 z$ d; b5 {) d+ e
41.         _SetCNTR(wCNTR);
    + Q1 q* }3 |  b4 M+ P
42.         
    
43.         /* force low-power mode in the macrocell */
    
44.         wCNTR = _GetCNTR();
    
45.         wCNTR |= CNTR_LPMODE;
    
46.         _SetCNTR(wCNTR);
    $ k1 [  L/ [7 `6 W/ T3 R( C* P
47.         
    & V. C) h4 q1 Y
48.         Enter_LowPowerMode();
    
49. }
    

复制代码

  K  f3 T8 p& u4 m* o3 {+ B把USB初始化部分不要的注释掉：

1. void USB_MSC_Configuration(void)
   
2. {
   + H4 i/ q% f7 M5 c. b
3. //  Set_System();
   ! a/ V( E/ ]& _0 ~
4.   Set_USBClock();
   # t- v9 c! P" n% L# ^4 X
5. //  Led_Config();
   
6.   USB_Interrupts_Config();
   
7.   USB_Init();
   + ~: u- _( r, r
8. //  while (bDeviceState != CONFIGURED);
   , {4 r9 a" m7 L! w
9. 
   / T: L: Y1 G& [+ H0 ^- I2 t
10. //  USB_Configured_LED();
    ( h. f- e" v& p' x9 f. x
11. 
    $ d" V2 ~( O6 x& \7 V2 c0 @: y6 R
12. //  while (1)
    
13. //  {}
    
14. }

复制代码

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

+ L/ W& q* u% U4 E' [5 {

1.     Mass_Memory_Size[0]=1024*1024*4;        //w25q64->8M 给4M做U盘
   ' S; W3 L  k! g7 L# r) r0 W+ }' F
2.     Mass_Block_Size[0] =512;                        //设置SPI FLASH的操作扇区大小为512
   1 p+ D0 V3 e1 C9 D6 R6 q
3.     Mass_Block_Count[0]=Mass_Memory_Size[0]/Mass_Block_Size[0];
   2 Y1 w! P" N4 I2 |
4. 
   # y' n, B+ [' j
5.         USB_MSC_Configuration();

复制代码

  z8 l+ i$ G( f; I: c5 K) j' i9 H

7 {+ m% Y6 s9 l- [编译下载后就可以正常运行了。
/ m1 y* m* w8 |+ a& I9 A

  G; ]8 p  l% F/ w: e
7 L# [5 _8 _( C2 I& x& f传输文件、新建文件夹都可以了，就是传输速度感人。

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

' g3 e# e8 r* k4 R, T9 f
+ n! r& @+ v: b) H* L8 M' a
# L* U# i- u( p6 K  N6 d/ j* X