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

6 J# H# Y) r; R8 ~# v7 iUSB基础知识
USB按接口类型分
控制器/主机（controller/host）
, ?8 i1 t1 ~' v* M
设备（peripheral）

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

按照USB速度分

. L4 N+ I3 g8 Y) \) d低速（low speed）
7 C0 r2 A5 t# f& [
; ?) M) N7 V1 B2 K  {4 K全速（full speed）

高速（high speed）
: M2 Q1 g. W; U% H0 w/ A7 w; [! l8 ]0 U
6 @" t4 G! B# oUSB接口一般是4根线，VCC GND DM(D-) DP(D+)
; _% T) l, J. F: C( |* q
低速设备：在DM线上接入上拉
  ]) j( `9 S! W; k; l% _
全速设备：在DP线上接入上拉

高速设备：在DP线上接入上拉，在主机对设备进行复位后进一步的确认
# R! \9 b0 B/ L2 q- f
% b" e& Z( N& q  o
关于描述符
设备描述符（device description）

  I3 e2 ^3 d0 a& @5 _8 ]$ _配置描述符（config description）
9 D+ c) A* I$ H3 n! R) Z
, M+ C7 E5 W! e% Q9 z接口描述符 （interface description）
* F' z6 i1 s# i
# A" C5 V2 X* N& c* n9 G端点描述符 （endpoint description）
9 a2 q  g, l% m! p' P/ U

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

关于传输
1.在USB的通讯中，有传输（transfer），事务（Transaction），包（packet）三级。包是最基础的传输单元，与TCP/IP协议中的MAC层协议作用相同。
2.在一次传输中，由多次事务组成，每次的事务又由多个包组成
$ O% p3 }4 M+ D: \' b2 L3.与众多协议相同，较高级别的协议的报文是基于/内嵌在低级协议的报文当中的，在USB中也不例外，例如，包中预留了DATA位，其目的就是填写报文
5 x( |6 ]0 y5 w! v  ?2 H7 hSTM32F103芯片自带了有USB模块，可以用来做从设备，不能用作主机HOST。这里使用USB的目的是讲USB作为一个大容量，这个可以基于官方USB Mass_Storage例程来移植。这里就不过多的介绍里面复杂的通信原理了，要彻彻底底搞明白并灵活运用取来还是有很大难度的，因为内容太多了。这里仅仅介绍下移植过程和描述符相关的重点内容。

; w1 k/ a" l" N1 ^, B) Q6 ^6 C4 l准备工作
* Z8 P. p; }0 e4 H第一步
确保自己的KEIL开发环境已经完善。
! p3 c8 @/ }  f8 T6 G
$ M. t3 h* y; T# Q7 t; r第二步
下载好了两份ST官方的库文件（我是基于标准库开发的），一个是标准外设库文件，一个是USB库文件。如下图：



2 Z% M9 F& G; S- s8 o第三步
8 x; g4 i2 w% C9 B. o建立一个带有存储介质驱动的STM32基础工程，存储介质常见有SD卡、外部FLASH芯片、内部的FLASH空间。的我是基于一个外部flash的工程去实现的，芯片具体型号是W25Q64，64Mbit的空间，换成字节就是8MByte。驱动部分如下：

7 f' P2 P& S0 a$ B1 ]C文件
) x  }$ C" g0 N8 P9 d8 b  i

1. #include "fy_w25qxx.h"
   
2. 
   
3. u16 W25QXX_TYPE=0;//W25Q64
   ; [2 s" ^4 n: B$ q
4. 
   1 W- w$ c5 ^* F: [
5. //4Kbytes为一个Sector,16个扇区为1个Block,容量为16M字节,共有128个Block,4096个Sector
   7 z3 Y% p* v9 B9 J
6. //初始化SPI FLASH的IO口
   0 A; n: Q3 q( G2 f% O2 V
7. void W25QXX_Configuration(void)
   
8. {        
   
9.         SPI2_SetSpeed(SPI_BaudRatePrescaler_2);//设置为18M时钟,高速模式
   * K6 _$ h( E! y3 C/ _! w
10.         W25QXX_TYPE=W25QXX_ReadID();//读取FLASH ID.  
    
11. }         
    
12. 
    5 S1 O' Y' P# r( D8 n/ q6 `
13. //读取W25QXX的状态寄存器
    
14. //BIT7  6   5   4   3   2   1   0
    
15. //SPR   RV  TB BP2 BP1 BP0 WEL BUSY
    
16. //SPR:默认0,状态寄存器保护位,配合WP使用
    6 l! k- m, k, F2 _
17. //TB,BP2,BP1,BP0:FLASH区域写保护设置
    
18. //WEL:写使能锁定
    ( I1 s/ ~" ?$ I6 S) {; \* \* x8 l
19. //BUSY:忙标记位(1,忙;0,空闲)
    1 u( S: Z2 Y: Q2 h9 A7 p
20. //默认:0x00
    
21. u8 W25QXX_ReadSR(void)   
    : J' n. ^1 H$ o9 G+ J
22. {  
    ' A# H3 ]1 _$ U) Z
23.         u8 byte=0;   
    : B1 o; P! k4 \  w
24.         W25QXX_CS_L();                            //使能器件   
    
25.         SPI2_ReadWriteByte(W25X_ReadStatusReg); //发送读取状态寄存器命令   
    " e  {% K4 `& i* Z% u
26.         byte=SPI2_ReadWriteByte(0Xff);          //读取一个字节  
    
27.         W25QXX_CS_H();                            //取消片选     
    ( U( n+ b% d) y/ N9 o3 |
28.         return byte;   
    
29. }
    
30. //写W25QXX状态寄存器
    
31. //只有SPR,TB,BP2,BP1,BP0(bit 7,5,4,3,2)可以写!!!
    
32. void W25QXX_Write_SR(u8 sr)   
    
33. {   
    
34.         W25QXX_CS_L();                            //使能器件   
    ' y8 F  Q' L, }$ S' `8 L
35.         SPI2_ReadWriteByte(W25X_WriteStatusReg);//发送写取状态寄存器命令   
    : e1 |7 B! ]6 ?8 V4 b* [4 ^4 ~; A# _
36.         SPI2_ReadWriteByte(sr);                       //写入一个字节  
    
37.         W25QXX_CS_H();                            //取消片选                  
    
38. }   
    
39. //W25QXX写使能        
    / M5 r1 g% c" O/ x2 e9 C2 `: x
40. //将WEL置位   
    
41. void W25QXX_Write_Enable(void)   
    3 T  V: c% e: k$ l  t0 Q; X
42. {
    
43.         W25QXX_CS_L();                                  //使能器件   
    - m; P: M3 J1 a4 E% ^
44.     SPI2_ReadWriteByte(W25X_WriteEnable);         //发送写使能  
    
45.         W25QXX_CS_H();                                   //取消片选                  
    
46. }
    & O2 i1 d- s; X3 [
47. //W25QXX写禁止        
    / U( R8 B9 C' Q% g! ?6 T- J6 M  Y
48. //将WEL清零  
    
49. void W25QXX_Write_Disable(void)   
    
50. {  
    
51.         W25QXX_CS_L();                            //使能器件   
    5 l2 l# n$ C% Q- Z' @8 B) d
52.     SPI2_ReadWriteByte(W25X_WriteDisable);  //发送写禁止指令   
    # I4 ]. D7 i2 Q$ s
53.         W25QXX_CS_H();                            //取消片选                  
    % q. h* ^% g- \* H3 d$ S3 _
54. }                 
    - ~! X- W! R7 L  j
55. 
    
56. //读取芯片ID
    6 ~: e2 h) S) N, [1 J
57. u16 W25QXX_ReadID(void)
    
58. {
    
59.         u16 Temp = 0;         
    
60.         W25QXX_CS_L();                                    
    
61.         SPI2_ReadWriteByte(0x90);//发送读取ID命令            
    
62.         SPI2_ReadWriteByte(0x00);            
    
63.         SPI2_ReadWriteByte(0x00);            
    1 y$ E# s; c5 R! G) I* I
64.         SPI2_ReadWriteByte(0x00);                                    
    
65.         Temp|=SPI2_ReadWriteByte(0xFF)<<8;  
    6 ?6 `& I# K6 ~! r# N- G
66.         Temp|=SPI2_ReadWriteByte(0xFF);         
    
67.         W25QXX_CS_H();                                    
    4 B5 Q3 m! a2 u/ s5 y! T; {
68.         return Temp;
    6 ~, k  D' u/ X5 Q$ O
69. }                       
    ) v; i) o/ V; E& y& P9 N( y
70. 
    " O$ |/ Q# O, Y  P9 a
71. //在指定地址开始读取指定长度的数据
    
72. //pBuffer:数据存储区,ReadAddr:开始读取的地址(24bit),NumByteToRead:要读取的字节数(最大65535)
    3 h$ w7 y# g$ `6 w- m6 S
73. void W25QXX_Read(u8* pBuffer,u32 ReadAddr,u16 NumByteToRead)   
    3 j. `9 f9 b- m8 l2 t$ _. e
74. {
    . @5 w0 v! U5 e, Y1 \' C8 V0 d
75.          u16 i;                                                                                       
    ( K( k# P& b% p1 F5 Y4 \2 a! b$ [8 W/ p
76.         W25QXX_CS_L();                                    //使能器件   
    7 Z1 y! q: p' |# _  K
77.         SPI2_ReadWriteByte(W25X_ReadData);                 //发送读取命令   
    + A( [- I( M/ j( \
78.         SPI2_ReadWriteByte((u8)((ReadAddr)>>16));          //发送24bit地址   
    
79.         SPI2_ReadWriteByte((u8)((ReadAddr)>>8));   
    + t( g5 Y, S" [$ R
80.         SPI2_ReadWriteByte((u8)ReadAddr);   
    
81.         for(i=0;i<NumByteToRead;i++)
    
82.         {
    
83.         pBuffer=SPI2_ReadWriteByte(0XFF);           //循环读数  
    4 _1 \6 Y6 }; o% c
84.   }
    0 S8 G3 J, C! l
85.         W25QXX_CS_H();                                                   
    
86. }
    ( D, }2 q8 F. p* E6 E' j
87. 
    5 ]5 I3 K# x, E% D7 @
88. //SPI在一页(0~65535)内写入少于256个字节的数据
    
89. //在指定地址开始写入最大256字节的数据
    
90. //pBuffer:数据存储区,WriteAddr:开始写入的地址(24bit),NumByteToWrite:要写入的字节数(最大256),该数不应该超过该页的剩余字节数!!!         
    8 K9 ?, X4 |" Z* i6 f/ Z
91. void W25QXX_Write_Page(u8* pBuffer,u32 WriteAddr,u16 NumByteToWrite)
    3 r: E% L  r' i, K3 e* O: M
92. {
    ' S3 q: [, d7 I( R& W0 {* X
93.          u16 i;  
    
94.         W25QXX_Write_Enable();                          //SET WEL
    
95.         W25QXX_CS_L();                                    //使能器件   
    % Y  n& d4 R# y+ t6 U( U
96.         SPI2_ReadWriteByte(W25X_PageProgram);              //发送写页命令   
    ' M# ~$ d% s! ^" q5 ]
97.         SPI2_ReadWriteByte((u8)((WriteAddr)>>16));         //发送24bit地址   
    & X4 p5 b" O3 u
98.         SPI2_ReadWriteByte((u8)((WriteAddr)>>8));   
    , x2 t4 S+ s0 r4 v
99.         SPI2_ReadWriteByte((u8)WriteAddr);   
    
100.         for(i=0;i<NumByteToWrite;i++)SPI2_ReadWriteByte(pBuffer);//循环写数  
     
101.         W25QXX_CS_H();                                    //取消片选
     
102.         W25QXX_Wait_Busy();                                                           //等待写入结束
     
103. }
     
104. //无检验写SPI FLASH
     - N9 R- Q/ \1 _: \, ?
105. //必须确保所写的地址范围内的数据全部为0XFF,否则在非0XFF处写入的数据将失败!
     
106. //具有自动换页功能
     ) G  @( F# H' {1 [2 ^+ x  o% z
107. //在指定地址开始写入指定长度的数据,但是要确保地址不越界!
     
108. //pBuffer:数据存储区
     
109. //WriteAddr:开始写入的地址(24bit)
     
110. //NumByteToWrite:要写入的字节数(最大65535)
     
111. //CHECK OK
     , a/ P- V/ i6 D$ P
112. void W25QXX_Write_NoCheck(u8* pBuffer,u32 WriteAddr,u16 NumByteToWrite)   
     . G' c/ x! ?- z2 u; c. C3 M
113. {                                          
     
114.         u16 pageremain;           
     5 m! T6 {( W' [7 [" M7 }
115.         pageremain=256-WriteAddr%256; //单页剩余的字节数                             
     3 j3 [: Z& ]/ V% l
116.         if(NumByteToWrite<=pageremain)pageremain=NumByteToWrite;//不大于256个字节
     & e9 I; `. d. @; b+ D2 D4 _
117.         while(1)
     
118.         {           
     # \% k- ?  q& U' p% l8 f: f
119.                 W25QXX_Write_Page(pBuffer,WriteAddr,pageremain);
     + F5 X! F; K% a
120.                 if(NumByteToWrite==pageremain)break;//写入结束了
     5 R0 z, ?2 V  y9 G
121.                  else //NumByteToWrite>pageremain
     
122.                 {
     & ]  l' Q& H1 Z" `/ u/ u
123.                         pBuffer+=pageremain;
     + k/ G. s7 C: Q/ A0 I* B4 x
124.                         WriteAddr+=pageremain;        
     
125. 
     
126.                         NumByteToWrite-=pageremain;                          //减去已经写入了的字节数
     % ]  ?0 X! ]2 G( D: P: V
127.                         if(NumByteToWrite>256)pageremain=256; //一次可以写入256个字节
     8 I+ d# l# i& c! V' l; ?2 |6 r
128.                         else pageremain=NumByteToWrite;           //不够256个字节了
     
129.                 }
     
130.         };            
     
131. }
     ' e- [. x  t  }$ L+ ?
132. //写SPI FLASH  
     4 C$ ^2 C: k# ~* I. c" Y2 t. z
133. //在指定地址开始写入指定长度的数据
     
134. //该函数带擦除操作!
     
135. //pBuffer:数据存储区
     9 o) K( ]. a5 @3 a3 C
136. //WriteAddr:开始写入的地址(24bit)                                                
     
137. //NumByteToWrite:要写入的字节数(最大65535)   
     ; z. e. ]/ Y2 G/ B2 w" L) s' D% A
138. u8 W25QXX_BUFFER[4096];                 
     
139. void W25QXX_Write(u8* pBuffer,u32 WriteAddr,u16 NumByteToWrite)   
     
140. {
     
141.         u32 secpos;
     
142.         u16 secoff;
       h. k$ f; v( ^9 h( t
143.         u16 secremain;           
     
144.          u16 i;   
     
145.         u8 *W25QXX_BUF;         
     ( ^2 i- U$ M: G1 {0 M
146.         
     
147.            W25QXX_BUF=W25QXX_BUFFER;
     ) j6 J6 F. r8 t
148. //        
     - q3 _& A3 s8 |
149. //    W25QXX_BUF = (u8 *)_mem.Alloc(4096);//申请一个扇区大小的内存
     ' k4 c5 i& V7 A0 E2 l6 U% C6 Y
150. //    if(W25QXX_BUF==NULL)        return;
     
151.         
     + r* J  ~$ h( Z( q* v6 L
152.          secpos=WriteAddr/4096;//扇区地址  
     
153.         secoff=WriteAddr%4096;//在扇区内的偏移
     . x1 k1 M2 I" M) v5 M9 u
154.         secremain=4096-secoff;//扇区剩余空间大小  
     / ^2 P8 C; h( J$ s0 v; c
155. 
     
156.          //printf("ad:%X,nb:%X\r\n",WriteAddr,NumByteToWrite);//测试用
     
157.          if(NumByteToWrite<=secremain)secremain=NumByteToWrite;//不大于4096个字节
     
158.         while(1)
     % W% Y3 s& F- ]& j7 m# Y( ]6 ~$ _* Q
159.         {        
     0 m, V# @6 ]7 k/ J- B4 b! z2 m
160.                 W25QXX_Read(W25QXX_BUF,secpos*4096,4096);//读出整个扇区的内容
     
161.                 for(i=0;i<secremain;i++)//校验数据
     3 }, O$ Z; A0 N; N# A
162.                 {
     
163.                         if(W25QXX_BUF[secoff+i]!=0XFF)break;//需要擦除            
     8 j% n/ }* j5 J1 P' F  m6 M4 y# v
164.                 }
     
165.                 if(i<secremain)//需要擦除
     
166.                 {
     : k: G3 {" e5 J) D
167.                         W25QXX_Erase_Sector(secpos);                //擦除这个扇区
     
168.                         for(i=0;i<secremain;i++)                           //复制
     . G# g  v: S- A% F" B; _2 d& j: a3 @
169.                         {
     ) @: }8 G7 T" q2 j# A
170.                                 W25QXX_BUF[i+secoff]=pBuffer;         
     
171.                         }
     8 X1 ]( K2 ]& i  d
172.                         W25QXX_Write_NoCheck(W25QXX_BUF,secpos*4096,4096);//写入整个扇区  
     9 D' b+ L' e+ I% t3 q
173. 
     ! R" O, a% @8 v
174.                 }else W25QXX_Write_NoCheck(pBuffer,WriteAddr,secremain);//写已经擦除了的,直接写入扇区剩余区间.                                    
     * g. v, }1 t! S5 w2 J
175.                 if(NumByteToWrite==secremain)break;//写入结束了
     
176.                 else//写入未结束
     
177.                 {
     " `2 H5 P' ^' Z, B. j/ \
178.                         secpos++;//扇区地址增1
     
179.                         secoff=0;//偏移位置为0         
     $ ?8 F( Y6 M: C% A
180. 
     ) {9 M2 @4 ]9 w6 b, t
181.                            pBuffer+=secremain;                                  //指针偏移
     
182.                         WriteAddr+=secremain;                                //写地址偏移           
     ! ?! N9 _2 S+ l- W
183.                            NumByteToWrite-=secremain;                        //字节数递减
     
184.                         if(NumByteToWrite>4096)secremain=4096;//下一个扇区还是写不完
     + C+ O1 E  x4 K
185.                         else secremain=NumByteToWrite;                //下一个扇区可以写完了
     
186.                 }         
     # x( O* Y6 J# O8 \
187.         }
     
188. //        _mem.Free(W25QXX_BUF);
     
189. }
     4 l& ?# T. b. A9 N: ~6 q
190. //擦除整个芯片                  
     : e( i) k- d# P0 C4 Y/ \
191. //等待时间超长...
     
192. void W25QXX_Erase_Chip(void)   
     
193. {                                   
     7 c# D! x8 J4 |& ?% H5 k
194.     W25QXX_Write_Enable();                                  //SET WEL
     5 E# @; r2 D# F$ b7 `
195.     W25QXX_Wait_Busy();   
     2 r0 J: P+ s. \: F/ s
196.           W25QXX_CS_L();                                    //使能器件   
     
197.     SPI2_ReadWriteByte(W25X_ChipErase);                //发送片擦除命令  
     
198.         W25QXX_CS_H();                                    //取消片选                  
     
199.         W25QXX_Wait_Busy();                                                      //等待芯片擦除结束
     
200. }   
     & _4 ], N9 v# |2 N+ S0 N
201. //擦除一个扇区
     
202. //Dst_Addr:扇区地址 根据实际容量设置
     
203. //擦除一个山区的最少时间:150ms
     ; [% z: D( k  n3 ]
204. void W25QXX_Erase_Sector(u32 Dst_Addr)   
     1 |; i# X0 M% U* i
205. {  
     
206.         //监视falsh擦除情况,测试用   
     
207. //         printf("fe:%x\r\n",Dst_Addr);         
     
208.          Dst_Addr*=4096;
     4 n8 Z$ J; Y4 S
209.     W25QXX_Write_Enable();                          //SET WEL         
     
210.     W25QXX_Wait_Busy();   
     * R9 s6 ~: R( X: o1 W4 c8 O$ C2 U
211.           W25QXX_CS_L();                                    //使能器件   
     
212.     SPI2_ReadWriteByte(W25X_SectorErase);              //发送扇区擦除指令
     9 s9 I' J( Z2 N) Z  E
213.     SPI2_ReadWriteByte((u8)((Dst_Addr)>>16));          //发送24bit地址   
     
214.     SPI2_ReadWriteByte((u8)((Dst_Addr)>>8));   
     
215.     SPI2_ReadWriteByte((u8)Dst_Addr);  
     ; w" P6 g8 Q: r1 r4 y+ s1 Q5 U
216.         W25QXX_CS_H();                                    //取消片选                  
     6 p: B8 p' T. A, t
217.     W25QXX_Wait_Busy();                                                      //等待擦除完成
     
218. }  
     2 O  @# r9 I6 c) S' L6 n5 k" @
219. //等待空闲
     & Q- Z  `3 V7 l( S( w
220. void W25QXX_Wait_Busy(void)   
     
221. {   
     & N4 T7 ]' x) f: u, V2 E, C
222.         while((W25QXX_ReadSR()&0x01)==0x01);                  // 等待BUSY位清空
     9 `7 v: \" Q' ]' `
223. }  
     0 h; I* q6 \1 H1 k! Y
224. //进入掉电模式
     
225. void W25QXX_PowerDown(void)   
     + B8 ?9 U6 q( W/ r0 h6 M
226. {
       X4 F, [1 C2 A$ I( o3 [
227.           W25QXX_CS_L();                                            //使能器件   
     
228.     SPI2_ReadWriteByte(W25X_PowerDown);        //发送掉电命令  
     
229.         W25QXX_CS_H();                                    //取消片选                  
     
230.     Delay_us(3);                               //等待TPD  
     
231. }   
     
232. //唤醒
     
233. void W25QXX_WAKEUP(void)   
     + p7 N" l- h3 h: e( q4 w
234. {  
     $ Y5 r  G7 z+ e, n- P/ B) O& |
235.           W25QXX_CS_L();                                    //使能器件   
     
236.     SPI2_ReadWriteByte(W25X_ReleasePowerDown);        //  send W25X_PowerDown command 0xAB   
     
237.         W25QXX_CS_H();                                    //取消片选                  
     
238.     Delay_us(3);                                    //等待TRES1
       ~3 S' P7 X2 J6 L' I& c. n$ v! |
239. }   

复制代码

- e5 }" Y& o/ o& _2 SH文件
* M( P) e3 V  \) X/ X
& c" Q. X/ |: B( K7 |

1. #ifndef __FY_W25QXX_H
   
2. #define __FY_W25QXX_H                           
   2 ]  U0 L$ N  d# ~7 U
3. 
   ; {6 e: B; u4 C& `" b& O( k/ U
4. #include "fy_includes.h"
   4 F4 a( u. j6 K2 y7 }1 a. g. b1 G
5. 
   4 K+ [" [% L" u7 D2 u; d
6. //W25QXX对应唯一识别ID
   
7. #define W25Q80         0XEF13
   
8. #define W25Q16         0XEF14
   " c5 p: }3 }4 c- m1 ~% v8 T
9. #define W25Q32         0XEF15
   
10. #define W25Q64         0XEF16
    
11. #define W25Q128        0XEF17
    & c4 Y7 x  J; o8 @: K) I( f- X
12. 
    1 L% u5 Q3 N+ x+ d
13. //指令表
      B0 B5 K1 w# X0 M9 ]# l9 G- M5 d
14. #define W25X_WriteEnable                0x06
    
15. #define W25X_WriteDisable                0x04
    
16. #define W25X_ReadStatusReg                0x05
    
17. #define W25X_WriteStatusReg                0x01
    
18. #define W25X_ReadData                        0x03
    $ X4 o0 A* B$ j: S5 W! {6 {
19. #define W25X_FastReadData                0x0B
    
20. #define W25X_FastReadDual                0x3B
    
21. #define W25X_PageProgram                0x02
    4 y- r- Q* _" o5 R5 D
22. #define W25X_BlockErase                        0xD8
    % j8 `, J8 S& E# D6 q( r9 Q
23. #define W25X_SectorErase                0x20
    
24. #define W25X_ChipErase                        0xC7
    
25. #define W25X_PowerDown                        0xB9
    
26. #define W25X_ReleasePowerDown        0xAB
    , H  V' ]+ j9 L; [2 f- n; f4 @
27. #define W25X_DeviceID                        0xAB
    7 x8 @$ c$ e# j4 Y  G% c( }
28. #define W25X_ManufactDeviceID        0x90
    
29. #define W25X_JedecDeviceID                0x9F
    3 Q( F& F6 ^) N. Q( j$ H: _8 {4 n
30. 
    
31. void W25QXX_Configuration(void);
    3 w& u0 G' L* S0 s" K
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);                  //写使能
    
36. void W25QXX_Write_Disable(void);                //写保护
    4 @: f& e& P5 Y0 G6 q4 ^0 F
37. void W25QXX_Write_NoCheck(u8* pBuffer,u32 WriteAddr,u16 NumByteToWrite);
    
38. void W25QXX_Read(u8* pBuffer,u32 ReadAddr,u16 NumByteToRead);   //读取flash
    # w( K: Z# D4 _- M4 P
39. void W25QXX_Write(u8* pBuffer,u32 WriteAddr,u16 NumByteToWrite);//写入flash
    , @* ^: @8 y! }: l$ n# T9 d- J
40. void W25QXX_Erase_Chip(void);                      //整片擦除
    
41. void W25QXX_Erase_Sector(u32 Dst_Addr);        //扇区擦除
    ) V9 W" `: r) _( s& ?$ n2 b( @7 p+ x4 v8 M
42. void W25QXX_Wait_Busy(void);                   //等待空闲
    
43. void W25QXX_PowerDown(void);                //进入掉电模式
      K1 `7 E' U! c/ C2 O
44. void W25QXX_WAKEUP(void);                                //唤醒
    * ~. p0 l5 `0 o7 O+ W( {
45. 
    . L8 K6 w3 n& m: S$ V3 }! G- I- _
46. extern u16 W25QXX_TYPE;                                        //定义W25QXX芯片型号                  
    ) g  n+ k7 x1 E+ V& F6 E
47. 
    
48. #endif

复制代码

1 T; N0 J5 M# b基础工程如下：
: f% W4 w  a( M" B: C' H
5 K4 c, e0 Y) O) T! E8 ~' {
" |3 |/ `4 r0 f$ k/ X2 L7 H5 T: {
: f% }  g8 l' L6 h第四步：USB代码移植
拷贝USB底层库到工程根目录，新建一个目录命名成USB，拷贝Mass_Storage例程下的src和inc目录下的所以文件到USB。
" h" t5 o; u8 O/ T; R1 l3 o8 i
& ^  Z- A; [3 {$ c3 [) {

+ I! |( r' w& O拷贝过来是有37个文件，这个时候需要删除一些不必要的文件，因为官方的例程里面有nand，这里的话先删除以下文件
  q( }2 V$ x; M0 c

7 p0 r4 t6 s- ]! i1 H
: ~* S- V  R) c4 F8 j: G4.打开工程把分组和文件及包含路径添加进去，这里就不细说了，结果如下


( j5 r; s6 g: x. p2 S
打开usb下面的main和it 把重要的代码先拷贝出来
3 R6 I$ _( ?$ j% p3 e, Y9 N
' m1 P0 O- e. ^* D
5 G# `* p4 v0 d
把main和stm32_it里面的内容拷贝到自己的main里面进行下封装去掉不要的保留剩下的，然后就删除it和main三个文件。
' x' h7 i0 f5 U' K' V

' a# {/ F4 e* \
然后编译下，这个时候会出现一堆报错，需要慢慢一步步搞定，编译前注意路径包含，
0 n8 P6 Z7 Z2 Z0 A7 F, D* E
  u# n  J% c+ i& S4 L

; |) ?8 o2 B: M$ a+ S( |. K! m定位到第一个错误进去



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


! K, n- a7 j" [
7 t0 W6 A* {- \% t- i, x. x公共文件如下，并且添加usb部分的头文件

) m  @5 Z) m1 J2 @7 W, l% p5 ?

+ d  k, J) m0 K1 Q, y$ a3 G3 `" |继续编译，定位第一个错误，这部分主要修改hw_config文件
  C! @' Q+ ^. V9 O+ O7 w; `


& P* s6 h9 x) g6 u. H删除Set_System函数

5 p, ~' g: a6 K; w

删除Led_Config函数
6 M" w- w* M$ `$ h3 Q


注释LED相关的内容

5 a* T3 {! ~- L" i6 _6 t# P/ M

- ^& ?3 V6 q) G; N2 T删除USB_Disconnect_Config
/ e- k" g" v; o4 m9 k. ~5 j( i: u
- U* O# N9 X! m! h2 [- U

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

! r& W, Y3 _% e0 m
% k1 U+ C, v- V
头文件
% i/ h) K- U' `0 }2 u' c$ i! d
$ N* Z) x+ H7 _& Y/ O! S; U' A( [
: a) C8 S8 _! H
下面修改memory文件，主要修改变量定义，C文件和H文件分别如下
- D, |$ f5 |9 h, z, y


; H" c- Y3 h. `0 h# L接下来是usb_scsi部分的变量定义


7 B. v$ o5 s9 F& w* z4 o7 z. @
这时候再次编译就发现没有错误了，但是这个地方USB中断部分还需要配置下，官方用的宏定义方式去实现不同的代码，这里一开始就去掉了宏，所以最终修改如下：

( J- l4 n, L, f2 A/ A8 _

1. /*******************************************************************************
   2 s& K- f& c8 y0 r: a. ~
2. * Function Name  : USB_Interrupts_Config
   
3. * Description    : Configures the USB interrupts
   
4. * Input          : None.
   % W) _6 h9 ^7 P) ]6 t
5. * Return         : None.
   
6. *******************************************************************************/
   
7. void USB_Interrupts_Config(void)
   
8. {
   ) E2 t1 J( s0 V
9.         
   
10.         NVIC_InitTypeDef NVIC_InitStructure;
    * k* m1 [1 R% W& O
11.         EXTI_InitTypeDef EXTI_InitStructure;
    # N4 e; x. `0 A. s+ d1 i) m- ?
12. 
    
13. 
    
14.         /* Configure the EXTI line 18 connected internally to the USB IP */
    
15.         EXTI_ClearITPendingBit(EXTI_Line18);
    / w1 V8 W* N" w8 o) w
16.                                                                                           //  开启线18上的中断
    5 N+ I( H2 h: t) z, g
17.         EXTI_InitStructure.EXTI_Line = EXTI_Line18; // USB resume from suspend mode
    4 ~  z) y" X7 x6 @* |7 G$ w8 W. f1 m
18.         EXTI_InitStructure.EXTI_Trigger = EXTI_Trigger_Rising;        //line 18上事件上升降沿触发
    7 P' \( c! }- l9 ?0 C3 N! F
19.         EXTI_InitStructure.EXTI_LineCmd = ENABLE;
    $ k$ ]# ^5 E: L. l8 m" R# j! S9 c2 Z  q
20.         EXTI_Init(&EXTI_InitStructure);         
    7 p1 X/ u) A) \, q# H1 {# h
21. 
    
22.         /* Enable the USB interrupt */
    , Q) n" C2 X. F# D! u8 k$ j4 h6 M& j+ G
23.         NVIC_InitStructure.NVIC_IRQChannel = USB_LP_CAN1_RX0_IRQn;        //组2，优先级次之
    ) e  j7 H4 |& w; v( q0 d( y5 H
24.         NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 1;
    $ A# ], m/ j  N5 ~5 c% o
25.         NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0;
    8 z, q6 m5 B3 t7 f0 @- m
26.         NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
    & d) }! P7 ]/ V7 I+ T
27.         NVIC_Init(&NVIC_InitStructure);
    
28.         
    
29.         /* Enable the USB Wake-up interrupt */
    # m2 l0 P! b" ?9 I% f
30.         NVIC_InitStructure.NVIC_IRQChannel = USBWakeUp_IRQn;   //组2，优先级最高        
    
31.         NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 0;
    
32.         NVIC_Init(&NVIC_InitStructure);  
    
33. 
    4 D# l4 w6 H$ j- Y- h$ J2 `( Q6 |
34. 
    / _6 D7 P* `* ~% i2 G+ F: h
35. }

复制代码

再注释掉USB_Cable_Config的内容（DP上有1.5K上拉电阻）并修改中断函数
8 T- \/ g* a3 |0 g' K- k7 T

1. //USB唤醒中断服务函数
   
2. void USBWakeUp_IRQHandler(void)
   : i& p* ^1 ]2 h, {7 `  g) l$ x2 Z
3. {
   8 K* R) z( f6 d" n
4.         EXTI_ClearITPendingBit(EXTI_Line18);//清除USB唤醒中断挂起位
   3 W2 B  X1 [) \, E# S' }* H
5. }

复制代码

修改pwr的Suspend内容：

1. void Suspend(void)
   
2. {
   
3.         uint32_t i =0;
   & \$ F1 c. l. v9 d7 J
4.         uint16_t wCNTR;
   ( W2 [% z( q1 v" K0 E% H$ ^
5.         __IO uint32_t savePWR_CR=0;
   
6.         /* suspend preparation */
   
7.         /* ... */
   
8.         
   
9.         /*Store CNTR value */
   8 J( A; y% z( W. d; S! d( G
10.         wCNTR = _GetCNTR();  
    
11. 
    * f8 B( y9 |  U9 `. q
12.     /* This a sequence to apply a force RESET to handle a robustness case */
      A+ ?5 _$ E: U  W4 v* _8 _0 ~
13. 
    5 A+ O6 N" L5 c6 Q' W5 d
14.         /*Store endpoints registers status */
      v& f8 a7 G- \3 r, S' i2 c
15.     for (i=0;i<8;i++) EP = _GetENDPOINT(i);
    
16.         
    
17.         /* unmask RESET flag */
    
18.         wCNTR|=CNTR_RESETM;
    
19.         _SetCNTR(wCNTR);
    
20.         
    , n; M% K7 F( ]" h. D! p* X
21.         /*apply FRES */
    
22.         wCNTR|=CNTR_FRES;
    
23.         _SetCNTR(wCNTR);
    
24.         
    
25.         /*clear FRES*/
    
26.         wCNTR&=~CNTR_FRES;
    
27.         _SetCNTR(wCNTR);
    & p' r, p# U4 S8 }1 ]+ Z
28.         
    / Y9 m- n' u6 s
29.         /*poll for RESET flag in ISTR*/
    
30.         while((_GetISTR()&ISTR_RESET) == 0);
    
31.         
    0 r4 |; \8 i6 Z
32.         /* clear RESET flag in ISTR */
    
33.         _SetISTR((uint16_t)CLR_RESET);
    
34.         
    
35.         /*restore Enpoints*/
    7 f1 s$ u: r) `* H
36.         for (i=0;i<8;i++)
    
37.         _SetENDPOINT(i, EP);
    
38.         
    / S! Q0 @+ {* P4 J
39.         /* Now it is safe to enter macrocell in suspend mode */
    
40.         wCNTR |= CNTR_FSUSP;
    / r* Y, s9 F" l$ t% ]4 I3 ?
41.         _SetCNTR(wCNTR);
    3 S% u8 q* x4 T/ {% D+ T  P
42.         
    
43.         /* force low-power mode in the macrocell */
    : f3 A7 c# w  p
44.         wCNTR = _GetCNTR();
    
45.         wCNTR |= CNTR_LPMODE;
    9 ~( m9 s# w% r, R5 y( I
46.         _SetCNTR(wCNTR);
    . b$ K6 W, U9 r) ^
47.         
    . B( L% L8 u4 e1 l
48.         Enter_LowPowerMode();
    7 z( P! ?, g! \3 h+ C$ h8 v
49. }
    

复制代码

" Z; y. l( t  V+ b, L, o把USB初始化部分不要的注释掉：
' k; L' ?  O6 M; A( P

1. void USB_MSC_Configuration(void)
   5 {* Q/ `6 j: l6 ~5 ^$ R) W
2. {
   
3. //  Set_System();
   # U9 m* N5 k) _5 C& R5 \
4.   Set_USBClock();
   
5. //  Led_Config();
   
6.   USB_Interrupts_Config();
   , r& Q# G6 H! u% W% {% g$ @
7.   USB_Init();
   
8. //  while (bDeviceState != CONFIGURED);
   * m1 r, h  T- |0 B. W/ p
9. 
   
10. //  USB_Configured_LED();
    . C% v: I! y! e; T7 f( X& v2 m
11. 
    ) O' i7 n; g+ q
12. //  while (1)
    7 Q) K: m* Z$ ^9 F( m
13. //  {}
    
14. }

复制代码

. [4 C. G- S& G/ l0 @最后在USB初始化之前给U盘定义的数组赋值，不然就只有个盘符
# ~' N1 V6 l5 T1 Z
6 ]1 N& F- S8 y

1.     Mass_Memory_Size[0]=1024*1024*4;        //w25q64->8M 给4M做U盘
   , d0 t! ]- ^* _; n9 P1 g
2.     Mass_Block_Size[0] =512;                        //设置SPI FLASH的操作扇区大小为512
   
3.     Mass_Block_Count[0]=Mass_Memory_Size[0]/Mass_Block_Size[0];
     j' K' _" U: P8 ^3 l0 l
4. 
   
5.         USB_MSC_Configuration();

复制代码

- i2 p( M3 m9 f, C; D6 F1 a

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



3 D$ d6 q' r* `" J& b  K传输文件、新建文件夹都可以了，就是传输速度感人。

以上就是USB虚拟U盘的所有内容了，内容太多而且复杂，所以如果真的想亲手试试，还是要点耐心的。虽然能学到的并不是很多，这里主要可以干茶mass_mal部分，可以学到不少东西，方便以后的熟练运用。我这里也是为以后更进一步的开发做铺垫。
1 }( D/ u6 O+ B
6 K; S+ P3 g8 R( P! s6 z
3 ]4 W7 d1 ?/ a6 x3 a6 @2 a& M2 O7 _
6 F* |4 K0 R6 \( I/ V3 I* E