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

! Q2 r. @' }, U! YUSB基础知识
+ Y4 e! L$ y% p! j8 Q# EUSB按接口类型分
控制器/主机（controller/host）

设备（peripheral）

& t7 \$ T0 J+ o7 K( m* cOTG（on-the-go），通过id线确定作为主机还是作为设备
7 s8 x4 Q* B- `$ T. N
8 q. ~1 A2 \2 d) ]8 C8 T6 X2 ~按照USB速度分
: t+ G% p; j# A/ g6 c
3 N, u3 o& x- h低速（low speed）

$ L# W6 s, p) K0 Y& @$ a全速（full speed）
4 \: q" q6 M6 k! ]5 S( h; N
& W# u& ]) `1 }; Y! D& d; i7 x高速（high speed）

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

6 q# [' F/ I. p4 A* k低速设备：在DM线上接入上拉
  M5 k+ [8 S/ v& q
' f* X9 i" `5 _4 Z全速设备：在DP线上接入上拉

' X: A) \1 _) D9 {6 |高速设备：在DP线上接入上拉，在主机对设备进行复位后进一步的确认


关于描述符
设备描述符（device description）
! F. m1 |1 \6 ]3 M' W
1 F# R( Q) N3 `9 t+ z配置描述符（config description）
* ^; F3 N. q7 W, r! _( r" P
接口描述符 （interface description）
  `5 H1 T/ U1 I5 |
端点描述符 （endpoint description）


3 }1 N( O( v! a" ~4 E
" P7 f) ~; z% h" U) V; S设备的“身份”信息存储在描述符中。每个USB设备中都有如下描述符。需要注意的是一个USB设备只能有一个设备描述符，一个设备描述符可以有多个配置描述符，一个配置描述符可以有多个接口描述符，一个接口描述符可以包含多个端点。

- N8 C) R; t& n' ?关于传输
! }4 v6 W. M8 f4 q" H! y' P5 k1.在USB的通讯中，有传输（transfer），事务（Transaction），包（packet）三级。包是最基础的传输单元，与TCP/IP协议中的MAC层协议作用相同。
. Z0 K' o9 ?' [# s# s& d" ?. q2.在一次传输中，由多次事务组成，每次的事务又由多个包组成
3.与众多协议相同，较高级别的协议的报文是基于/内嵌在低级协议的报文当中的，在USB中也不例外，例如，包中预留了DATA位，其目的就是填写报文
STM32F103芯片自带了有USB模块，可以用来做从设备，不能用作主机HOST。这里使用USB的目的是讲USB作为一个大容量，这个可以基于官方USB Mass_Storage例程来移植。这里就不过多的介绍里面复杂的通信原理了，要彻彻底底搞明白并灵活运用取来还是有很大难度的，因为内容太多了。这里仅仅介绍下移植过程和描述符相关的重点内容。
! J' ]# J1 S+ u; Z7 M
+ x4 {" x9 y5 p" S, ?- ^准备工作
; R) J/ s1 w( Z6 X1 Z% B. s第一步
/ g- u' l' a5 {# U确保自己的KEIL开发环境已经完善。
. b9 w5 a- X3 l  y6 F
第二步
下载好了两份ST官方的库文件（我是基于标准库开发的），一个是标准外设库文件，一个是USB库文件。如下图：



第三步
建立一个带有存储介质驱动的STM32基础工程，存储介质常见有SD卡、外部FLASH芯片、内部的FLASH空间。的我是基于一个外部flash的工程去实现的，芯片具体型号是W25Q64，64Mbit的空间，换成字节就是8MByte。驱动部分如下：
$ Y: |0 _/ J, |
4 {5 J) E$ Y; L- }2 kC文件

1. #include "fy_w25qxx.h"
   
2. 
   % r6 u! ~& z7 x2 Z- m
3. u16 W25QXX_TYPE=0;//W25Q64
   
4. 
   1 t( Q; m" H, j) D1 n! y" R
5. //4Kbytes为一个Sector,16个扇区为1个Block,容量为16M字节,共有128个Block,4096个Sector
   # A8 E, T( A8 j+ G% N0 @1 I- Z
6. //初始化SPI FLASH的IO口
   
7. void W25QXX_Configuration(void)
     j  _  L+ a! S- A" l! j6 }7 [9 X
8. {        
   6 H% F9 E" q9 A8 _8 }* t( ?
9.         SPI2_SetSpeed(SPI_BaudRatePrescaler_2);//设置为18M时钟,高速模式
   
10.         W25QXX_TYPE=W25QXX_ReadID();//读取FLASH ID.  
    
11. }         
    , c* z7 C$ n, Z7 x- q
12. 
    " ~: L" [% t% p! A3 r7 d
13. //读取W25QXX的状态寄存器
    
14. //BIT7  6   5   4   3   2   1   0
    
15. //SPR   RV  TB BP2 BP1 BP0 WEL BUSY
    # R- W9 U" P$ q
16. //SPR:默认0,状态寄存器保护位,配合WP使用
    2 M2 [0 j" [, O4 X
17. //TB,BP2,BP1,BP0:FLASH区域写保护设置
    
18. //WEL:写使能锁定
    
19. //BUSY:忙标记位(1,忙;0,空闲)
    
20. //默认:0x00
    
21. u8 W25QXX_ReadSR(void)   
    
22. {  
    
23.         u8 byte=0;   
    
24.         W25QXX_CS_L();                            //使能器件   
    7 A# j/ S% ~% n
25.         SPI2_ReadWriteByte(W25X_ReadStatusReg); //发送读取状态寄存器命令   
    4 n2 M8 {: W' c. Z
26.         byte=SPI2_ReadWriteByte(0Xff);          //读取一个字节  
    6 n  C" d+ n1 x8 O
27.         W25QXX_CS_H();                            //取消片选     
    
28.         return byte;   
    
29. }
    
30. //写W25QXX状态寄存器
    3 s# O0 x  m$ F  Q/ M9 _
31. //只有SPR,TB,BP2,BP1,BP0(bit 7,5,4,3,2)可以写!!!
    
32. void W25QXX_Write_SR(u8 sr)   
    
33. {   
    $ i  [+ @! J3 t. @
34.         W25QXX_CS_L();                            //使能器件   
    ( [- z, M6 T" A+ s
35.         SPI2_ReadWriteByte(W25X_WriteStatusReg);//发送写取状态寄存器命令   
    
36.         SPI2_ReadWriteByte(sr);                       //写入一个字节  
    
37.         W25QXX_CS_H();                            //取消片选                  
    - n/ r, O0 E6 T' |3 c8 U- w3 f9 R$ a
38. }   
    4 O/ u+ F$ I2 a6 p  B5 W2 Q
39. //W25QXX写使能        
    
40. //将WEL置位   
    % ?8 b. c% ~# l) ?8 x
41. void W25QXX_Write_Enable(void)   
    ! |3 Q" e4 u8 D  y1 _# B2 S5 [
42. {
    
43.         W25QXX_CS_L();                                  //使能器件   
    * H! K2 e2 C! f8 p7 d. ]
44.     SPI2_ReadWriteByte(W25X_WriteEnable);         //发送写使能  
    9 r2 Z; Y9 F$ D9 t4 H# b) B1 K
45.         W25QXX_CS_H();                                   //取消片选                  
    8 E3 f, j7 n+ U! n) Y. c8 Y  H+ Z; I
46. }
    9 ?; p" Z) S2 q6 }  P8 ^' M
47. //W25QXX写禁止        
    
48. //将WEL清零  
    
49. void W25QXX_Write_Disable(void)   
    
50. {  
    
51.         W25QXX_CS_L();                            //使能器件   
    
52.     SPI2_ReadWriteByte(W25X_WriteDisable);  //发送写禁止指令   
    . {% J  `; J2 T* s0 v* S% B
53.         W25QXX_CS_H();                            //取消片选                  
    
54. }                 
    / T- p: Z3 C) X6 Z- B
55. 
    
56. //读取芯片ID
    
57. u16 W25QXX_ReadID(void)
    . g+ o/ U9 I$ j) o* S: n, E
58. {
    ) N% H* O  w: s1 o9 z
59.         u16 Temp = 0;         
    
60.         W25QXX_CS_L();                                    
    
61.         SPI2_ReadWriteByte(0x90);//发送读取ID命令            
    : e4 [" a8 c; Y8 g
62.         SPI2_ReadWriteByte(0x00);            
    
63.         SPI2_ReadWriteByte(0x00);            
    
64.         SPI2_ReadWriteByte(0x00);                                    
    ' x% @8 S. p) c3 l& V' z+ z
65.         Temp|=SPI2_ReadWriteByte(0xFF)<<8;  
    # E( L& [: {. B2 W
66.         Temp|=SPI2_ReadWriteByte(0xFF);         
    ! G" F, l: j" Q% P! f" @* l
67.         W25QXX_CS_H();                                    
    0 `& e7 z0 Y% ^
68.         return Temp;
    # p6 H3 \  j" |) {) `' g8 w
69. }                       
    
70. 
    
71. //在指定地址开始读取指定长度的数据
    - }; Z! f) A3 J# \$ o5 ^7 j
72. //pBuffer:数据存储区,ReadAddr:开始读取的地址(24bit),NumByteToRead:要读取的字节数(最大65535)
    % t$ A5 T1 w3 F" T$ _; }' E
73. void W25QXX_Read(u8* pBuffer,u32 ReadAddr,u16 NumByteToRead)   
    
74. {
    ; h0 l+ H; @" G9 V0 p6 o
75.          u16 i;                                                                                       
    / l! k- y' T; p
76.         W25QXX_CS_L();                                    //使能器件   
    & S" m. }2 V1 F; l+ G' u& r& y
77.         SPI2_ReadWriteByte(W25X_ReadData);                 //发送读取命令   
    
78.         SPI2_ReadWriteByte((u8)((ReadAddr)>>16));          //发送24bit地址   
    
79.         SPI2_ReadWriteByte((u8)((ReadAddr)>>8));   
    : R- J3 T6 R% e3 n
80.         SPI2_ReadWriteByte((u8)ReadAddr);   
    
81.         for(i=0;i<NumByteToRead;i++)
    
82.         {
    $ m8 n9 S+ K, h  ~: m; R8 \% d
83.         pBuffer=SPI2_ReadWriteByte(0XFF);           //循环读数  
    6 d* Y% G  t9 I5 W4 ^& g- y
84.   }
    
85.         W25QXX_CS_H();                                                   
    0 C1 c$ i4 M; Q5 W6 o
86. }
    * |6 z$ E$ g8 o# J- b+ V
87. 
    
88. //SPI在一页(0~65535)内写入少于256个字节的数据
    
89. //在指定地址开始写入最大256字节的数据
    
90. //pBuffer:数据存储区,WriteAddr:开始写入的地址(24bit),NumByteToWrite:要写入的字节数(最大256),该数不应该超过该页的剩余字节数!!!         
    
91. void W25QXX_Write_Page(u8* pBuffer,u32 WriteAddr,u16 NumByteToWrite)
    8 a1 @7 U* |6 O+ \  K
92. {
    ( r( ?  c4 Q, x0 W
93.          u16 i;  
    ; b# T4 G7 m* a) z, `6 Y. e* `
94.         W25QXX_Write_Enable();                          //SET WEL
    * o) v1 k- ]3 ^( \) `* i
95.         W25QXX_CS_L();                                    //使能器件   
    
96.         SPI2_ReadWriteByte(W25X_PageProgram);              //发送写页命令   
    : n& Q9 y$ u' s6 ^6 M$ x( H, n% y2 p
97.         SPI2_ReadWriteByte((u8)((WriteAddr)>>16));         //发送24bit地址   
    * c, I, H9 q% F' f- p# Y
98.         SPI2_ReadWriteByte((u8)((WriteAddr)>>8));   
    $ T7 d. G, ^! v5 ^4 _
99.         SPI2_ReadWriteByte((u8)WriteAddr);   
    
100.         for(i=0;i<NumByteToWrite;i++)SPI2_ReadWriteByte(pBuffer);//循环写数  
     
101.         W25QXX_CS_H();                                    //取消片选
     . m1 }) y8 _+ G
102.         W25QXX_Wait_Busy();                                                           //等待写入结束
     - V# `1 e- M/ H
103. }
     
104. //无检验写SPI FLASH
     
105. //必须确保所写的地址范围内的数据全部为0XFF,否则在非0XFF处写入的数据将失败!
     6 r' s1 m& F- M
106. //具有自动换页功能
     
107. //在指定地址开始写入指定长度的数据,但是要确保地址不越界!
     4 q' \2 v" Q5 v9 f# M* f# I
108. //pBuffer:数据存储区
     
109. //WriteAddr:开始写入的地址(24bit)
     ! Q) _/ q. B' b) B  a
110. //NumByteToWrite:要写入的字节数(最大65535)
     
111. //CHECK OK
     
112. void W25QXX_Write_NoCheck(u8* pBuffer,u32 WriteAddr,u16 NumByteToWrite)   
     
113. {                                          
     
114.         u16 pageremain;           
     6 F3 _3 ]$ o  ?  V/ r- ^
115.         pageremain=256-WriteAddr%256; //单页剩余的字节数                             
     8 G1 l, m+ m8 A5 c9 q4 M" P: Z
116.         if(NumByteToWrite<=pageremain)pageremain=NumByteToWrite;//不大于256个字节
     
117.         while(1)
     
118.         {           
     ) I9 W( p8 _) c1 U& v
119.                 W25QXX_Write_Page(pBuffer,WriteAddr,pageremain);
     
120.                 if(NumByteToWrite==pageremain)break;//写入结束了
     
121.                  else //NumByteToWrite>pageremain
     2 x- R: ?4 f# ^, W
122.                 {
     " p5 D5 n( r! j3 L( I8 q$ M
123.                         pBuffer+=pageremain;
     # _: z" I# R4 y' f  m
124.                         WriteAddr+=pageremain;        
     
125. 
     
126.                         NumByteToWrite-=pageremain;                          //减去已经写入了的字节数
     # M) z* J- x/ x9 f
127.                         if(NumByteToWrite>256)pageremain=256; //一次可以写入256个字节
     
128.                         else pageremain=NumByteToWrite;           //不够256个字节了
     6 i, @, A! ^- R# k2 v; C* |
129.                 }
     ! n4 |  ]6 I+ e8 v
130.         };            
     4 @8 i3 o, d) H+ P) f; Q, e7 W3 N
131. }
     
132. //写SPI FLASH  
     
133. //在指定地址开始写入指定长度的数据
     ' x& F  n  J! x4 m5 U, D' x. W
134. //该函数带擦除操作!
     2 s  X7 f$ ]+ r. Q; S9 @1 C
135. //pBuffer:数据存储区
     . f3 c, J$ w5 }/ C, ?6 l! |
136. //WriteAddr:开始写入的地址(24bit)                                                
     $ Y( Z$ w7 ?2 g! i8 a( P
137. //NumByteToWrite:要写入的字节数(最大65535)   
     
138. u8 W25QXX_BUFFER[4096];                 
     
139. void W25QXX_Write(u8* pBuffer,u32 WriteAddr,u16 NumByteToWrite)   
     
140. {
     * H! W' P' E6 V6 S! G: X
141.         u32 secpos;
     , |/ K( {$ J! h; q
142.         u16 secoff;
     4 K5 [8 U5 x% p2 h0 x7 d
143.         u16 secremain;           
     
144.          u16 i;   
     : D( W% Z) g: Y' N7 G, i3 d2 B
145.         u8 *W25QXX_BUF;         
     
146.         
     - Q8 w5 d( A- \$ \# w* u' q
147.            W25QXX_BUF=W25QXX_BUFFER;
     " q3 v) e$ Q' w3 o! L
148. //        
     3 Z6 N- o/ G' Y! M; C
149. //    W25QXX_BUF = (u8 *)_mem.Alloc(4096);//申请一个扇区大小的内存
     
150. //    if(W25QXX_BUF==NULL)        return;
     
151.         
     
152.          secpos=WriteAddr/4096;//扇区地址  
     , o$ g, k  Z+ ~9 Q! s; R
153.         secoff=WriteAddr%4096;//在扇区内的偏移
     
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)
     
159.         {        
     
160.                 W25QXX_Read(W25QXX_BUF,secpos*4096,4096);//读出整个扇区的内容
       d+ w$ ?) f, c
161.                 for(i=0;i<secremain;i++)//校验数据
     & q0 h3 M; f) Q* c" i: m  I2 s- q
162.                 {
     7 \9 h0 _% H9 G( ?1 L! U# z0 c2 q
163.                         if(W25QXX_BUF[secoff+i]!=0XFF)break;//需要擦除            
     # ?; x1 O8 {( ?, K
164.                 }
     " y  f, m8 T0 o, y' m4 m7 W- M, }0 E
165.                 if(i<secremain)//需要擦除
     
166.                 {
     $ w  C% h9 f( d* |0 m
167.                         W25QXX_Erase_Sector(secpos);                //擦除这个扇区
     
168.                         for(i=0;i<secremain;i++)                           //复制
     
169.                         {
     + S1 `! L" T, A2 k% R4 ?, a
170.                                 W25QXX_BUF[i+secoff]=pBuffer;         
     4 |8 s4 `7 E9 l5 ?, a
171.                         }
     
172.                         W25QXX_Write_NoCheck(W25QXX_BUF,secpos*4096,4096);//写入整个扇区  
     ' ?$ X5 F, c; u4 v) t; D& U
173. 
     
174.                 }else W25QXX_Write_NoCheck(pBuffer,WriteAddr,secremain);//写已经擦除了的,直接写入扇区剩余区间.                                    
     
175.                 if(NumByteToWrite==secremain)break;//写入结束了
     
176.                 else//写入未结束
     
177.                 {
     
178.                         secpos++;//扇区地址增1
     ( \! z! X+ P  c: o
179.                         secoff=0;//偏移位置为0         
     7 N" \/ O% j* D' ?  I0 n
180. 
     
181.                            pBuffer+=secremain;                                  //指针偏移
     
182.                         WriteAddr+=secremain;                                //写地址偏移           
       ^5 c% p* l$ x' j8 T) C
183.                            NumByteToWrite-=secremain;                        //字节数递减
     5 i; D6 V+ Q+ n4 T# y4 d8 W- z
184.                         if(NumByteToWrite>4096)secremain=4096;//下一个扇区还是写不完
     8 L: F( w9 x3 l
185.                         else secremain=NumByteToWrite;                //下一个扇区可以写完了
     
186.                 }         
     9 ^- J& z2 r/ o& w
187.         }
     6 v4 K& D8 C3 W2 l& Z
188. //        _mem.Free(W25QXX_BUF);
     
189. }
     
190. //擦除整个芯片                  
     8 t, _/ I, D9 e! Q& ?0 D
191. //等待时间超长...
     
192. void W25QXX_Erase_Chip(void)   
     # e: ]+ u% S/ Z0 a, I; F
193. {                                   
     ( x  a& X6 K. D, @" X+ s  H  ?
194.     W25QXX_Write_Enable();                                  //SET WEL
     
195.     W25QXX_Wait_Busy();   
     
196.           W25QXX_CS_L();                                    //使能器件   
     
197.     SPI2_ReadWriteByte(W25X_ChipErase);                //发送片擦除命令  
     
198.         W25QXX_CS_H();                                    //取消片选                  
     
199.         W25QXX_Wait_Busy();                                                      //等待芯片擦除结束
     . I2 o8 V2 Z5 g, ]$ O* d% ]8 d5 J
200. }   
     
201. //擦除一个扇区
     
202. //Dst_Addr:扇区地址 根据实际容量设置
     
203. //擦除一个山区的最少时间:150ms
     8 b& W- d8 `7 {
204. void W25QXX_Erase_Sector(u32 Dst_Addr)   
     
205. {  
     - N$ x9 k( h# D( O! W( h0 c
206.         //监视falsh擦除情况,测试用   
     " K1 D( F# C$ r  x, \2 d
207. //         printf("fe:%x\r\n",Dst_Addr);         
     
208.          Dst_Addr*=4096;
     3 \! e! n1 O9 \, u! f
209.     W25QXX_Write_Enable();                          //SET WEL         
     2 p  c. |  j$ Z/ Z$ g" t) }) v6 {
210.     W25QXX_Wait_Busy();   
     : z6 M, S  N+ e
211.           W25QXX_CS_L();                                    //使能器件   
     
212.     SPI2_ReadWriteByte(W25X_SectorErase);              //发送扇区擦除指令
     * a! O4 f1 D; a6 K2 c
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();                                    //取消片选                  
     & A5 E7 R$ [7 b' D+ M, U4 Q8 w
217.     W25QXX_Wait_Busy();                                                      //等待擦除完成
     6 J8 G% Q" I5 n% u8 V
218. }  
     - m0 a; P1 ?0 Y% m  p/ n
219. //等待空闲
       b# e4 I3 @+ d* [
220. void W25QXX_Wait_Busy(void)   
     
221. {   
     . X8 D0 P: i4 Q
222.         while((W25QXX_ReadSR()&0x01)==0x01);                  // 等待BUSY位清空
     
223. }  
     9 C# r/ M' T  Z# W* F) }3 o
224. //进入掉电模式
     7 n1 o0 J1 }- W6 q  i
225. void W25QXX_PowerDown(void)   
     
226. {
     
227.           W25QXX_CS_L();                                            //使能器件   
     
228.     SPI2_ReadWriteByte(W25X_PowerDown);        //发送掉电命令  
     
229.         W25QXX_CS_H();                                    //取消片选                  
     / e4 P1 o) L* V% f7 F  F; ~, ~: [
230.     Delay_us(3);                               //等待TPD  
     9 N" A) A* J! a: j
231. }   
     ' F: e) v1 p" u# S  L
232. //唤醒
     
233. void W25QXX_WAKEUP(void)   
     , S& |! _0 K8 F2 L
234. {  
     
235.           W25QXX_CS_L();                                    //使能器件   
     
236.     SPI2_ReadWriteByte(W25X_ReleasePowerDown);        //  send W25X_PowerDown command 0xAB   
     % w: J; E( H8 T+ p& e6 T
237.         W25QXX_CS_H();                                    //取消片选                  
     
238.     Delay_us(3);                                    //等待TRES1
     7 Q5 E/ H) }+ n. Q1 y3 M
239. }   

复制代码

H文件

1. #ifndef __FY_W25QXX_H
   # k% v  g7 V8 m
2. #define __FY_W25QXX_H                           
   
3. 
   
4. #include "fy_includes.h"
   
5. 
   
6. //W25QXX对应唯一识别ID
   
7. #define W25Q80         0XEF13
   
8. #define W25Q16         0XEF14
   ! V( I! _1 f4 `# d. h$ O' x$ c
9. #define W25Q32         0XEF15
   
10. #define W25Q64         0XEF16
    . {# O% L$ Q6 B- ^  `
11. #define W25Q128        0XEF17
    
12. 
    
13. //指令表
    9 r9 e& c7 h8 d, Q
14. #define W25X_WriteEnable                0x06
    
15. #define W25X_WriteDisable                0x04
    9 h% p8 G8 s( k9 v7 ?% Q: m
16. #define W25X_ReadStatusReg                0x05
    4 A8 _) k( y4 c) {" C- T7 z
17. #define W25X_WriteStatusReg                0x01
    9 U" Z/ m/ r" q" b
18. #define W25X_ReadData                        0x03
    
19. #define W25X_FastReadData                0x0B
    $ ]9 f6 W. l' Y* O
20. #define W25X_FastReadDual                0x3B
    9 N1 S! e- p" G" t& z
21. #define W25X_PageProgram                0x02
    
22. #define W25X_BlockErase                        0xD8
    
23. #define W25X_SectorErase                0x20
    ! E# l& F6 e9 [: c# }
24. #define W25X_ChipErase                        0xC7
    
25. #define W25X_PowerDown                        0xB9
    
26. #define W25X_ReleasePowerDown        0xAB
    
27. #define W25X_DeviceID                        0xAB
    : L! ^% P3 q; Z; _- s4 Z
28. #define W25X_ManufactDeviceID        0x90
    5 n* |2 v! `- d; R5 @8 n
29. #define W25X_JedecDeviceID                0x9F
    ) m# @$ O8 m0 V& _
30. 
    2 a' v! b! v/ I, ^
31. void W25QXX_Configuration(void);
    
32. u16  W25QXX_ReadID(void);                              //读取FLASH ID
    
33. u8         W25QXX_ReadSR(void);                        //读取状态寄存器
    
34. void W25QXX_Write_SR(u8 sr);                          //写状态寄存器
    
35. void W25QXX_Write_Enable(void);                  //写使能
    ) M4 R7 Y" \) p) v: z+ _
36. void W25QXX_Write_Disable(void);                //写保护
    # H: o. g4 b) M1 S3 N
37. void W25QXX_Write_NoCheck(u8* pBuffer,u32 WriteAddr,u16 NumByteToWrite);
    
38. void W25QXX_Read(u8* pBuffer,u32 ReadAddr,u16 NumByteToRead);   //读取flash
    4 |9 n4 F1 J+ q. p3 ]
39. void W25QXX_Write(u8* pBuffer,u32 WriteAddr,u16 NumByteToWrite);//写入flash
    3 }; N3 U# J  b% J1 G2 V
40. void W25QXX_Erase_Chip(void);                      //整片擦除
    
41. void W25QXX_Erase_Sector(u32 Dst_Addr);        //扇区擦除
    0 u  e% Z& Y, C; H
42. void W25QXX_Wait_Busy(void);                   //等待空闲
    / q1 ^+ Y1 d; A
43. void W25QXX_PowerDown(void);                //进入掉电模式
    
44. void W25QXX_WAKEUP(void);                                //唤醒
    
45. 
    0 R% D6 R2 g5 ?6 r, @
46. extern u16 W25QXX_TYPE;                                        //定义W25QXX芯片型号                  
    ; I+ L( B9 Q: T  i
47. 
    
48. #endif

复制代码

基础工程如下：
, u4 W4 Y. V; K  R5 n" Y! G


3 b2 f* i5 g' Y/ m+ T9 \第四步：USB代码移植
  s! O8 l7 V) q2 a拷贝USB底层库到工程根目录，新建一个目录命名成USB，拷贝Mass_Storage例程下的src和inc目录下的所以文件到USB。
% d- S" J' r8 V% b
' E3 T7 z9 [% b3 K
0 V! H! b, g1 Z
  [  M* f! l% o* b% M( w- o, O拷贝过来是有37个文件，这个时候需要删除一些不必要的文件，因为官方的例程里面有nand，这里的话先删除以下文件

3 c" F5 a( Q" M2 @# i9 Y7 m+ Z3 ~$ V

: E, W% K9 N, U4.打开工程把分组和文件及包含路径添加进去，这里就不细说了，结果如下
9 ~: ?  v; k" ^
. m9 ?3 f5 c+ p  y& h, ?( Q+ O

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

) \. i; w  ]. o9 K1 z$ N6 l, N
) i3 }  ~- m9 x5 p; d' e  L
把main和stm32_it里面的内容拷贝到自己的main里面进行下封装去掉不要的保留剩下的，然后就删除it和main三个文件。
, q5 o. j1 u; c; v8 J' V- l
9 x) R- A( N  f+ n
9 c" X* B' ~' w; H, W9 |2 a# o# R
然后编译下，这个时候会出现一堆报错，需要慢慢一步步搞定，编译前注意路径包含，
5 X1 p7 }7 i( F! V% W9 @4 P* |5 N


定位到第一个错误进去

) M% z; C' B) @* d. H

这个定义的是官方的开发板 我们直接修改成自己的公共文件就可以，并且注释掉开发板定义
: s( `# _+ X& P! C6 }7 M: @; S

9 Y, F5 @: B: `& ^6 ?6 m; h
0 L% q  q- ~6 m$ C* i公共文件如下，并且添加usb部分的头文件



5 g* l3 Z8 [+ K. \$ B* D/ b6 W继续编译，定位第一个错误，这部分主要修改hw_config文件


  H  v" P- {" w9 b! H
删除Set_System函数


+ r. J) t' d8 t. ?* W7 R) `
/ P2 |# \- E7 o# Y2 i" ]删除Led_Config函数

9 j! [1 X& B! V& V* b

注释LED相关的内容

9 m3 B7 s5 j% D
/ A" }% l8 _8 V  x5 [* v8 M4 G
删除USB_Disconnect_Config
7 q8 U. e: s- y

7 H- |. z( R% w) k0 ?# a) F0 Q
接下来主要修改mass_mal部分，我这里是只有一个flash，所以我修改成如下：
  F2 ^  W" q" v9 o5 _


头文件
% H! M" \* [! D& o( O

( l$ ]6 u4 A8 y% T' j8 F
下面修改memory文件，主要修改变量定义，C文件和H文件分别如下
# L% |1 g* a, p; B: k; S, z  o
, ^0 o+ d) X0 q& t, K+ f
6 y; P) i. ~, p2 Q9 i
" |( s+ t& s9 w* j8 D) w接下来是usb_scsi部分的变量定义
* x4 e5 _: k: u: Y


& ?0 K7 X4 f' J/ s& m7 A7 M这时候再次编译就发现没有错误了，但是这个地方USB中断部分还需要配置下，官方用的宏定义方式去实现不同的代码，这里一开始就去掉了宏，所以最终修改如下：
7 m5 F2 {7 x& V" B2 X) r# U
& N& ~0 i3 H5 _" V. @# p& p& }- }

1. /*******************************************************************************
   
2. * Function Name  : USB_Interrupts_Config
   " B, ~  q; g8 P4 `2 o# i- G+ k
3. * Description    : Configures the USB interrupts
   . c+ t  z% u$ G! x* J$ k3 f: R
4. * Input          : None.
   
5. * Return         : None.
   : b% O2 ]7 d0 e- c" Z# z  C
6. *******************************************************************************/
   8 e% L1 s7 g4 c% |, t
7. void USB_Interrupts_Config(void)
   - R7 ^% z0 s8 Y( j( u2 d" @
8. {
   
9.         
   
10.         NVIC_InitTypeDef NVIC_InitStructure;
    ' }5 z6 ?' t) B9 `8 _; z
11.         EXTI_InitTypeDef EXTI_InitStructure;
    
12. 
    
13. 
    2 `3 K1 k; Y; J. J+ t
14.         /* Configure the EXTI line 18 connected internally to the USB IP */
    0 S" ?& |) ?2 Z
15.         EXTI_ClearITPendingBit(EXTI_Line18);
    7 v# B/ s4 p6 f6 W1 j! ]
16.                                                                                           //  开启线18上的中断
    
17.         EXTI_InitStructure.EXTI_Line = EXTI_Line18; // USB resume from suspend mode
    
18.         EXTI_InitStructure.EXTI_Trigger = EXTI_Trigger_Rising;        //line 18上事件上升降沿触发
    ' s; ]. A9 ^& C' O: P% R$ h
19.         EXTI_InitStructure.EXTI_LineCmd = ENABLE;
    / d6 Y# `4 `/ G
20.         EXTI_Init(&EXTI_InitStructure);         
    5 J9 A$ [% B. }, e7 K# d2 \- k- g( J
21. 
    
22.         /* Enable the USB interrupt */
    
23.         NVIC_InitStructure.NVIC_IRQChannel = USB_LP_CAN1_RX0_IRQn;        //组2，优先级次之
    & Q/ B& d  p( F" l
24.         NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 1;
      m$ {; W6 D1 V0 o5 ~
25.         NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0;
    
26.         NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
    9 E/ G8 v+ T1 r: Y: r6 w$ F# Y6 z) R
27.         NVIC_Init(&NVIC_InitStructure);
    
28.         
    
29.         /* Enable the USB Wake-up interrupt */
    " `' N4 N( ^" f% Y* l
30.         NVIC_InitStructure.NVIC_IRQChannel = USBWakeUp_IRQn;   //组2，优先级最高        
    
31.         NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 0;
    + z: E( c) P- |* {7 ~, k" A* u
32.         NVIC_Init(&NVIC_InitStructure);  
    6 L- ?2 R7 P% |( t3 a; _
33. 
    ( U$ j0 A: s9 X( }, z, E
34. 
    3 M6 p; z% O& e5 {8 O+ ?9 D/ q
35. }

复制代码

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

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

复制代码

" g8 n' f- V1 C4 v3 A( W9 ^4 U! t修改pwr的Suspend内容：
( t9 b$ X# \/ y# N: k: v
( J- v6 {: F5 l: d6 @, _3 i

1. void Suspend(void)
   9 J) S; u: c2 R2 r1 C: V8 f9 A
2. {
   + e9 r: `& l, m$ q
3.         uint32_t i =0;
   2 E- j- F& U: T0 C! f/ ]' m% R$ [) s
4.         uint16_t wCNTR;
   % M& @8 J( _) e" Y# K
5.         __IO uint32_t savePWR_CR=0;
   
6.         /* suspend preparation */
   % W2 ]: q6 i6 w& N4 V# k
7.         /* ... */
   
8.         
   
9.         /*Store CNTR value */
   2 u! P% S  e! u- w3 x! @8 `8 P7 o
10.         wCNTR = _GetCNTR();  
    
11. 
    2 a9 y/ l$ ?: `3 [* o# V
12.     /* This a sequence to apply a force RESET to handle a robustness case */
    
13. 
    
14.         /*Store endpoints registers status */
    1 a# n) r3 B5 q* K2 d. Y& o
15.     for (i=0;i<8;i++) EP = _GetENDPOINT(i);
    $ y, B- i. p7 l! b# h* }. @; |' y
16.         
    
17.         /* unmask RESET flag */
    
18.         wCNTR|=CNTR_RESETM;
    
19.         _SetCNTR(wCNTR);
    
20.         
    
21.         /*apply FRES */
    , {6 r  O5 C( S- L( O/ }
22.         wCNTR|=CNTR_FRES;
    4 J5 N: E  _& c; ?
23.         _SetCNTR(wCNTR);
    * R- @" P. V, K  G" I5 V2 @
24.         
    
25.         /*clear FRES*/
    
26.         wCNTR&=~CNTR_FRES;
    
27.         _SetCNTR(wCNTR);
    
28.         
    
29.         /*poll for RESET flag in ISTR*/
    " S1 W2 P& m" H+ Z
30.         while((_GetISTR()&ISTR_RESET) == 0);
    . H; h6 j6 O1 U# _% D! ~8 G
31.         
    / L' G4 K( o; u2 `2 w, j
32.         /* clear RESET flag in ISTR */
    
33.         _SetISTR((uint16_t)CLR_RESET);
    9 z! X0 y0 K6 J: P
34.         
    / b) g8 j- i2 I1 D0 t+ S
35.         /*restore Enpoints*/
    
36.         for (i=0;i<8;i++)
    
37.         _SetENDPOINT(i, EP);
    
38.         
    8 R6 \  b$ ^. V& _
39.         /* Now it is safe to enter macrocell in suspend mode */
    
40.         wCNTR |= CNTR_FSUSP;
    * a$ ^% I# W7 ?7 s1 Z
41.         _SetCNTR(wCNTR);
    
42.         
    
43.         /* force low-power mode in the macrocell */
    
44.         wCNTR = _GetCNTR();
    
45.         wCNTR |= CNTR_LPMODE;
    ! x6 {6 K1 c* {  X$ _4 Y7 g& ~1 c
46.         _SetCNTR(wCNTR);
    
47.         
    & J* ?( l" G" a1 ~
48.         Enter_LowPowerMode();
    5 c9 y8 h4 _+ ^1 Y5 _
49. }
    8 h9 g+ p( a% A& U" b+ ~

复制代码

把USB初始化部分不要的注释掉：
- {: c6 C8 J, q2 e
" ]# h9 X) K' L$ |" T7 O

1. void USB_MSC_Configuration(void)
   * ^3 r5 _' g. s: g! J
2. {
   6 K' B, C+ K& W
3. //  Set_System();
   5 p1 ]# T2 Z, e* d1 O* q! T) D* |
4.   Set_USBClock();
   * p0 b) ~# @6 f) O' S+ o' `6 _( H
5. //  Led_Config();
   ( ]+ l& r  ]$ Q/ X9 _
6.   USB_Interrupts_Config();
   & ?5 P* D( o  n. x2 R7 S& v3 p
7.   USB_Init();
   
8. //  while (bDeviceState != CONFIGURED);
   0 e% f6 w( t0 Q% r1 a/ b
9. 
   1 q8 E/ k# C; n  N: Q, h$ u  l1 y
10. //  USB_Configured_LED();
    
11. 
    
12. //  while (1)
    
13. //  {}
    
14. }

复制代码

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

8 Q+ v/ I1 R$ C% f& z

1.     Mass_Memory_Size[0]=1024*1024*4;        //w25q64->8M 给4M做U盘
   
2.     Mass_Block_Size[0] =512;                        //设置SPI FLASH的操作扇区大小为512
   
3.     Mass_Block_Count[0]=Mass_Memory_Size[0]/Mass_Block_Size[0];
   
4. 
   ( L5 u0 H" O  L4 e. W  t. u
5.         USB_MSC_Configuration();

复制代码

" \- R/ I( {# c& Y

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



' {# o5 k+ q. j传输文件、新建文件夹都可以了，就是传输速度感人。
2 b8 [9 o0 `1 B2 {& `, K
: C3 [7 f5 e: x+ }" i以上就是USB虚拟U盘的所有内容了，内容太多而且复杂，所以如果真的想亲手试试，还是要点耐心的。虽然能学到的并不是很多，这里主要可以干茶mass_mal部分，可以学到不少东西，方便以后的熟练运用。我这里也是为以后更进一步的开发做铺垫。

; j9 b  C8 C! X) {; y

$ S) J( T. k5 N$ L+ o+ b* H