3.1   初学者重要提示
1、  本章使用的ST专门为STM32H7提供的软件包
& g5 V& A  n# V6 p/ d$ E
2、  本章配套例子使用SD卡模拟一个U盘，使用的MicroUSB接口。

3.2   USBX移植步骤
8 B' p( ?4 J( I# n0 m; S4 SThreadX USBX的移植步骤如下：

3.2.1      第1步，了解整体设计框架
4 E7 L; C+ o2 X( w( i. N4 X为了方便大家移植，需要大家先对移植好的工程有个整体认识：
3 S% Q# g0 d/ G

* e) v  b" f: ?3 _. }

3.2.2      第2步，添加USBX和USB驱动到工程
( K9 ?8 c1 N, T8 h( E/ A4 P这里我们在FileX教程做的模板例子基础上添加USBX文件和USB驱动文件，大家可以直接从本章教程提供的例子里面复制。
5 F0 ]8 f: E) F# `9 J
3 @/ [- \) D8 [6 m. m  模拟U盘驱动文件ux_device_msc.c/.h和ux_device_descriptors.c/.h添加到自己的工程里面，路径不限。
配套例子是放在\User\usb文件。

. F( q& Q4 q0 G: s/ T  USB驱动文件stm32h7xx_hal_hcd.c，stm32h7xx_hal_pcd.c，stm32h7xx_hal_pcd_ex.c和stm32h7xx_ll_usb.c。
! u# `; n. a4 ~  k这个是STM32H7的HAL库自带的。
: P8 d: O# P  u' c
0 Y' ]7 t0 [0 P$ H- y  USBX相关源文件。
& t( J/ a& r4 V" w大家可以将所有相关文件都复制到自己的工程里面，配套例子是放在\USBX。

' z' e" H8 W! T% q2 T; m3.2.3      第3步，添加工程路径
大家根据自己添加的源文件位置，添加相关路径即可：

# m( ^* [& F5 {* p- Q! f- ^! V

. G" Y' h, g* u


6 n. F- i7 J. {3.2.4      第4步，禁止掉添加进来一些文件
# A4 t8 C$ `- z6 O/ C8 R之所以要禁止掉是因为这些文件要用到NetXDUO网络协议栈，或者大家不添加进来都是可以的。添加进来后再禁止的优势是添加时候可以全选添加。

1 |4 R* U2 C. q
( ~: Q; _! R3 S2 a7 O& ]* a

) b* S- A; c4 _$ c9 ^禁止的方法是右击此文件去掉如下对钩即可：

1 ^# y+ l9 D# O

4 C& T0 G7 `1 T! S, ]& B5 I
2 ]% b" u' Y( ~7 N8 I5 }* k% _3 }6 C! w
" ?1 W1 k% U6 q/ |% |" m& ?3.2.5      第4步，配置GPIO和时钟
; r& m" Q6 S* n  l2 u1 QUSB时钟配置在bsp.c文件的函数SystemClock_Config里面：
: S: D$ K) t3 ]9 G: `
' l' ^/ B1 p  w' e; G4 q4 X

1. {
   
2.                 /*
   
3.                 USB工作需要48MHz的时钟，可以由PLL1Q，PLL3Q和HSI48提供
   
4.                         PLL1Q用于给SDMMC提供时钟
   : T' |/ Z. w' {' \
5.                     PLL3Q给LTDC提供时钟，也可以跟USB共用，不过得更USB设置相同的频率才可一起用。
   ! U: i7 o; ], E4 ]) h2 @$ ~) k
6.                     HSI48可以供USB独享，就是精度不是很高。
   2 O! M0 X$ B/ ~; W$ k1 s. [6 \4 `: x! X' D  ?
7.                 */
   
8.                 RCC_PeriphCLKInitTypeDef PeriphClkInitStruct = {0};
   + h' K$ O" [, b; v1 i4 W
9. #if 0
   
10.                 /* PLL3-Q for USB Clock = 48M */
    + ~& Y% a( a2 c0 i0 b8 M
11.                 PeriphClkInitStruct.PeriphClockSelection = RCC_PERIPHCLK_USB;
    
12.                 PeriphClkInitStruct.PLL3.PLL3M = 5;
    
13.                 PeriphClkInitStruct.PLL3.PLL3N = 48;
    + g- l% h4 G! z9 G1 V! _' l# n
14.                 PeriphClkInitStruct.PLL3.PLL3P = 2;
    , h: o0 N8 M" A  J( _. p4 o
15.                 PeriphClkInitStruct.PLL3.PLL3Q = 5;
    8 D0 N8 |1 a; T9 e5 t, v) n% H
16.                 PeriphClkInitStruct.PLL3.PLL3R = 2;
    + I8 ]7 h' c& ]/ J( E7 t5 w3 `
17.                 PeriphClkInitStruct.PLL3.PLL3RGE = RCC_PLL3VCIRANGE_2;
    
18.                 PeriphClkInitStruct.PLL3.PLL3VCOSEL = RCC_PLL3VCOWIDE;
    6 P# M# n* h3 C# ^
19.                 PeriphClkInitStruct.PLL3.PLL3FRACN = 0;
    7 A; E$ @. Q% F+ U# v
20.                 PeriphClkInitStruct.UsbClockSelection = RCC_USBCLKSOURCE_PLL3;
    5 n: I; Q6 _/ \* l: P& k6 M+ `. j
21.                 if (HAL_RCCEx_PeriphCLKConfig(&PeriphClkInitStruct)!= HAL_OK)
    5 V) A1 W5 b& Z+ l" l& c+ q, k! B$ U' z
22.                 {
    4 ~, `- `+ s. j6 v
23.                         Error_Handler(__FILE__, __LINE__);
    
24.                 }        
    # t4 n/ m+ u* t) ^  f
25. #else
    
26.                 PeriphClkInitStruct.PeriphClockSelection = RCC_PERIPHCLK_USB;
    7 J3 y: t; M1 O7 W! ~
27.                 PeriphClkInitStruct.UsbClockSelection = RCC_USBCLKSOURCE_HSI48;
    
28.                 if (HAL_RCCEx_PeriphCLKConfig(&PeriphClkInitStruct) != HAL_OK)
    ! U$ B( d6 J5 v; s
29.                 {
    8 h7 }. O, {  N
30.                         Error_Handler(__FILE__, __LINE__);
    $ i- \& d/ b2 p4 |
31.                 }
    
32.               HAL_PWREx_EnableUSBVoltageDetector();
    & t, b2 @# p% e+ ^4 I& W
33. #endif
    * v7 \3 W# k: Q. U  M& X
34.         }        

复制代码

USB的GPIO，NVIC初始化在demo_sd_usbx.c：
' n7 q0 ~0 [- n5 g" E& u* M% m/ O) _
; `" R* ?/ E% D

1. /* 配置USB GPIO, NVIC */
   7 y9 g' E0 D/ V& S0 A/ L3 L' y
2.     {
   2 S$ t6 w. P  d) u( ~
3.         GPIO_InitTypeDef  GPIO_InitStruct = {0};
   7 f9 `# v. d9 Z
4. 
   0 i! x. \$ t5 v: D
5.         __HAL_RCC_GPIOA_CLK_ENABLE();
   ) {/ V8 W& a1 ^' M
6. 
   ( ]# i& N5 `8 V" k; u% C, c
7.         GPIO_InitStruct.Pin = (GPIO_PIN_11 | GPIO_PIN_12);
   , `/ E0 X, \2 e% R' p; I7 N
8.         GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
   
9.         GPIO_InitStruct.Pull = GPIO_NOPULL;
   ( S( ^1 ]" }/ y# h
10.         GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_HIGH;
    # e$ w: e* b: \6 M- w# [" @
11.         GPIO_InitStruct.Alternate = GPIO_AF10_OTG1_FS;
    : E* @% N9 ]4 i5 |/ Z" B# g
12.         HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);
    7 K# `. q. i1 ~# h8 ~, L
13. 
    
14.         /* 使能USB FS时钟 */
    2 `( d- R+ g. ?# i( C
15.         __HAL_RCC_USB2_OTG_FS_CLK_ENABLE();
    & z$ i* E6 K" p* Y9 L
16. 
    
17.         /* 在睡眠模式下禁用USB时钟 */
    * Y. x( f( G5 h9 r$ Y4 ?" n; z
18.         __HAL_RCC_USB2_OTG_FS_ULPI_CLK_SLEEP_DISABLE();
    
19. 
    ' f6 X; \( D& g( f* B
20.         /* 配置USB FS中断 */
    
21.         HAL_NVIC_SetPriority(OTG_FS_IRQn, 0x2, 0);
    
22.         HAL_NVIC_EnableIRQ(OTG_FS_IRQn);
    
23.     }
    
24. 
    2 J# w) l; \; m( L7 r
25.     /* 初始化USB */
    $ B  p' k) L( V( L
26.     {
    
27.         HAL_PWREx_EnableUSBVoltageDetector();
    # i2 |4 o( W( Y
28. 
    * X2 I) W5 E2 ~. U% y5 O/ b' Z  ]
29.         memset(&hpcd_USB_OTG_FS, 0x0, sizeof(PCD_HandleTypeDef));
    
30.         hpcd_USB_OTG_FS.Instance = USB2_OTG_FS;
    
31.         hpcd_USB_OTG_FS.Init.dev_endpoints = 8;
    
32.         hpcd_USB_OTG_FS.Init.use_dedicated_ep1 = 0;
    
33.         hpcd_USB_OTG_FS.Init.ep0_mps = 0x40;
    % |5 o6 X% F$ ]/ s5 s
34.         hpcd_USB_OTG_FS.Init.low_power_enable = 0;
    
35.         hpcd_USB_OTG_FS.Init.phy_itface = PCD_PHY_EMBEDDED;
    
36.         hpcd_USB_OTG_FS.Init.Sof_enable = 0;
    8 e& Z- e# Q2 y5 {  A- I
37.         hpcd_USB_OTG_FS.Init.speed = PCD_SPEED_FULL;
    
38.         hpcd_USB_OTG_FS.Init.vbus_sensing_enable = 0;
    
39.         hpcd_USB_OTG_FS.Init.lpm_enable = 0;
    4 A9 q2 z+ Z' j6 l. q) L. D, l+ k
40. 
    0 w1 R; R$ S% N& ^: v0 f
41.         /* 初始化USB  */
    + e: S9 {( H3 g
42.         HAL_PCD_Init(&hpcd_USB_OTG_FS);
    
43. 
    7 D- [9 X; o4 p* [/ w! K( S
44.         /* 设置TX FIFO和RX FIFO */
    
45.         HAL_PCDEx_SetRxFiFo(&hpcd_USB_OTG_FS, 1024);
    
46.         HAL_PCDEx_SetTxFiFo(&hpcd_USB_OTG_FS, 0, 64);
    $ c5 U6 o6 |; j3 M8 f2 L
47.         HAL_PCDEx_SetTxFiFo(&hpcd_USB_OTG_FS, 1, 1024);
    
48. 
    
49.         /* 注册STM32到USBX协议栈并初始化 */
    
50.         status =  ux_dcd_stm32_initialize((ULONG)USB2_OTG_FS, (ULONG)&hpcd_USB_OTG_FS);
    ( M) L+ C5 H0 h/ n6 P0 r  O; q9 H
51. 
    
52.         if (status != FX_SUCCESS)
    , G& W4 n3 i9 `& P! T
53.         {
    
54.             return;
    : P4 d2 v) H& y
55.         }
    
56. 
    
57.     }

复制代码

3.2.6      第5步，MPU配置
$ |" ^! E3 i5 o  X+ @$ U) z( M# e为了方便大家移植测试，我们这里直接关闭AXI SRAM的读Cache和写Cache（这样就跟使用STM32F1或者STM32F4系列里面的SRAM一样）。此配置是在bsp.c文件的MPU_Config函数里面实现：

1. /*
     O; L/ x* _! r/ a
2. *********************************************************************************************************
   
3. *        函 数 名: MPU_Config
   
4. *        功能说明: 配置MPU
   
5. *        形    参: 无
   " v( t% L) x5 X  V: |, {$ F
6. *        返 回 值: 无
   ' a9 m1 v5 h0 u! Z  \( r; A
7. *********************************************************************************************************
     \. W' A1 a' L1 T7 p
8. */
   6 A* F8 Y/ F: O) o  m) Y8 R( L
9. static void MPU_Config( void )
   
10. {
    
11.         MPU_Region_InitTypeDef MPU_InitStruct;
    1 T7 ~9 J9 }7 ~1 a, [
12. 
    
13.         /* 禁止 MPU */
    - N+ e: y, R) e2 F
14.         HAL_MPU_Disable();
    " Z8 w& [$ c# K0 o4 h
15. 
    , M4 f8 k, j$ c) s( D- S: N
16. #if 0
    
17.            /* 配置AXI SRAM的MPU属性为Write back, Read allocate，Write allocate */
    
18.         MPU_InitStruct.Enable           = MPU_REGION_ENABLE;
    ! y5 J# b4 D6 T: D
19.         MPU_InitStruct.BaseAddress      = 0x24000000;
    : X3 N% U0 }3 C. [
20.         MPU_InitStruct.Size             = MPU_REGION_SIZE_512KB;
    
21.         MPU_InitStruct.AccessPermission = MPU_REGION_FULL_ACCESS;
    
22.         MPU_InitStruct.IsBufferable     = MPU_ACCESS_BUFFERABLE;
    9 v& }9 r6 y% g
23.         MPU_InitStruct.IsCacheable      = MPU_ACCESS_CACHEABLE;
    
24.         MPU_InitStruct.IsShareable      = MPU_ACCESS_NOT_SHAREABLE;
    ) J/ o5 ^' i6 g. Q
25.         MPU_InitStruct.Number           = MPU_REGION_NUMBER0;
    & O2 }) c' T8 N: U) F; b1 u
26.         MPU_InitStruct.TypeExtField     = MPU_TEX_LEVEL1;
    
27.         MPU_InitStruct.SubRegionDisable = 0x00;
    % e% G, @+ p9 D# A0 |0 Z6 x
28.         MPU_InitStruct.DisableExec      = MPU_INSTRUCTION_ACCESS_ENABLE;
    
29. 
    + I$ _. b2 n3 X) \$ m8 `2 a
30.         HAL_MPU_ConfigRegion(&MPU_InitStruct);
    
31. 
    . _0 Z# Q5 G4 U! [9 y$ B" a1 k1 T4 g
32. #else
    ! Y) D$ q$ q; c0 @3 |
33.      /* 当前是采用下面的配置 */
    
34.         /* 配置AXI SRAM的MPU属性为NORMAL, NO Read allocate，NO Write allocate */
    + ~3 u3 V  u/ d2 |( w; R1 I
35.         MPU_InitStruct.Enable           = MPU_REGION_ENABLE;
    
36.         MPU_InitStruct.BaseAddress      = 0x24000000;
    
37.         MPU_InitStruct.Size             = MPU_REGION_SIZE_512KB;
    
38.         MPU_InitStruct.AccessPermission = MPU_REGION_FULL_ACCESS;
    
39.         MPU_InitStruct.IsBufferable     = MPU_ACCESS_NOT_BUFFERABLE;
    
40.         MPU_InitStruct.IsCacheable      = MPU_ACCESS_NOT_CACHEABLE;
    
41.         MPU_InitStruct.IsShareable      = MPU_ACCESS_NOT_SHAREABLE;
    
42.         MPU_InitStruct.Number           = MPU_REGION_NUMBER0;
    
43.         MPU_InitStruct.TypeExtField     = MPU_TEX_LEVEL1;
    
44.         MPU_InitStruct.SubRegionDisable = 0x00;
    
45.         MPU_InitStruct.DisableExec      = MPU_INSTRUCTION_ACCESS_ENABLE;
    
46. 
    7 {' w( {5 E. R; |% g& }# f5 U
47.         HAL_MPU_ConfigRegion(&MPU_InitStruct);
    2 w& r3 p9 T5 b4 c
48. #endif
    
49.         /* 配置FMC扩展IO的MPU属性为Device或者Strongly Ordered */
    / t; i( x, c; U+ E8 y
50.         MPU_InitStruct.Enable           = MPU_REGION_ENABLE;
    
51.         MPU_InitStruct.BaseAddress      = 0x60000000;
    " X0 m9 q! X: i. d' u& W
52.         MPU_InitStruct.Size             = ARM_MPU_REGION_SIZE_64KB;        
    
53.         MPU_InitStruct.AccessPermission = MPU_REGION_FULL_ACCESS;
    
54.         MPU_InitStruct.IsBufferable     = MPU_ACCESS_BUFFERABLE;
    
55.         MPU_InitStruct.IsCacheable      = MPU_ACCESS_NOT_CACHEABLE;
    7 R$ ?$ q6 a: t. D/ |0 d( k0 r
56.         MPU_InitStruct.IsShareable      = MPU_ACCESS_NOT_SHAREABLE;
    
57.         MPU_InitStruct.Number           = MPU_REGION_NUMBER1;
    
58.         MPU_InitStruct.TypeExtField     = MPU_TEX_LEVEL0;
    " t. _, K0 e6 p( z2 [" ^
59.         MPU_InitStruct.SubRegionDisable = 0x00;
      z3 i% i2 w! M% q/ G
60.         MPU_InitStruct.DisableExec      = MPU_INSTRUCTION_ACCESS_ENABLE;
    9 Y+ Q) H6 c8 q6 P% v
61.         
    , U  s" l- I' ~+ N( F% `8 v: ]
62.         HAL_MPU_ConfigRegion(&MPU_InitStruct);
    
63. 
    
64.         /*使能 MPU */
    
65.         HAL_MPU_Enable(MPU_PRIVILEGED_DEFAULT);
    3 q4 t5 h- R' q' A+ {' ?* k
66. }

复制代码

3.2.7      第7步，添加应用代码（USB中断，打开U盘和关闭U盘）
0 i6 p- X$ O0 v% XUSB操作专门整理到了文件demo_sd_usbx.c。主要三部分，打开U盘，关闭U盘和USB中断服务程序。这三个函数基本是通用的，大家直接复制粘贴使用即可

5 I: D8 i- i6 v( Z. c3 t特别注意USB中断服务程序别忘了添加。
3 x$ N0 ^/ W% n
2 g/ M  }# d. E7 M2 r. V; i3.3   USBX的模拟U盘移植接口文件ux_device_msc.c说明
: x4 B$ g# d- r4 q0 }这里将USBX的底层接口文件ux_device_msc.c的实现为大家简单做个说明。

0 k2 ^  C9 D  p5 `& B: _3.3.1  状态函数app_usb_device_thread_media_status
代码如下：
2 c" u1 U, b* L& B/ Z
1 ^) f- U3 \" u: N: A

1. UINT  app_usb_device_thread_media_status(VOID *storage, ULONG lun, ULONG media_id, ULONG *media_status)
   5 L& f, t- Q8 m5 V
2. {
   5 t  J6 `6 O9 f4 `- ^
3. 
   : Q& v' z- f' C! E& j
4.   /* The ATA drive never fails. This is just for app_usb_device only !!!! */
   9 w: Z/ |! ^: O7 \  n( P) \4 A
5.   return (UX_SUCCESS);
   
6. }

复制代码

此函数主要用于获取SD卡模拟U盘的状态。

3.3.2  读取函数app_usb_device_thread_media_read
; S" i+ @: r9 R! `% T, T代码如下：
  c% O, [1 E% B6 H9 L  C% o9 M6 H
, x% p; D* \3 T+ \7 \

1. /**
   
2.   * @brief  Function implementing app_usb_device_thread_media_read.
     D- {0 Q8 `% a
3.   * @param  storage : Not used
   
4.   * @param  lun: Logical unit number
   - ^; G  J, S% x, d/ }5 `
5.   * @param  lba: Logical block address
   % Q/ m+ @$ z- e
6.   * @param  number_blocks: Blocks number
   
7.   * @param  data_pointer: Data
   & x; ]% q& B0 Y% X& x2 q7 M; b8 i
8.   * @param  media_status: Not used
   
9.   * @retval Status (0 : OK / -1 : Error)
   ( q( K- A" o+ G5 {$ c- q3 g
10.   */
    9 `2 V% K8 w7 k- U! z7 o
11. UINT  app_usb_device_thread_media_read(VOID *storage, ULONG lun,
    5 `! s. L( c5 E* q5 v' h
12.                                        UCHAR *data_pointer,
    
13.                                        ULONG number_blocks,
    : W; C: \8 Y0 ]
14.                                        ULONG lba, ULONG *media_status)
    1 V8 v/ X5 K% L- }& u2 e
15. {
    : q& T( L3 L: ]3 Y; t; N6 s- y3 K0 D
16.     UINT status = 0U;
    
17. 
    
18.     BSP_SD_ReadBlocks((uint32_t *) data_pointer, lba, number_blocks, 500);                                                                        
    
19.     //while(BSP_SD_GetCardState() != SD_TRANSFER_OK);
    / B: _0 E6 ^  v& \6 u4 x& H
20.     status = check_sd_status(0);   
    , D# n, e5 n- r3 i8 ?* y% Z  N2 R
21.     return (status);
    
22. }

复制代码

用于实现SD模拟U盘的读取功能。
7 d1 T8 ~8 L- ?* w: r1 p
% B( C1 R: p- X( D; I8 c- a3.3.3  写入函数app_usb_device_thread_media_write
& G, e1 c+ C1 p- B/ ~6 ~代码如下：
) Z- ]7 |, H" x# X3 u  W

1. /**
   
2.   * @brief  Function implementing app_usb_device_thread_media_write.
   
3.   * @param  storage : Not used
   & _4 ]+ v: E0 S% d" e) X% U
4.   * @param  lun: Logical unit number
   
5.   * @param  lba: Logical block address
   
6.   * @param  number_blocks: Blocks number
   1 y1 I( t" t4 d; P$ S. m3 y) w/ Y
7.   * @param  data_pointer: Data
   6 ?" F+ l6 y% O  k- R' x. i5 y  E
8.   * @param  media_status: Not used
   
9.   * @retval Status (0 : OK / -1 : Error)
   
10.   */
    ' o5 z- D! r$ G
11. UINT  app_usb_device_thread_media_write(VOID *storage, ULONG lun,
      V' H8 ~9 s0 k7 G% f9 W
12.                                         UCHAR *data_pointer,
    
13.                                         ULONG number_blocks,
    % ~4 y- q6 C; U, W3 E
14.                                         ULONG lba, ULONG *media_status)
    
15. {
    
16.     UINT status = 0U;
    
17. 
    ; x( |% Q; V3 V+ a3 I$ R7 S2 w
18.     BSP_SD_WriteBlocks((uint32_t *) data_pointer, lba, number_blocks, 500);
    
19.     //while(BSP_SD_GetCardState() != SD_TRANSFER_OK);
    $ Z" }: Q" E- B- H& ~3 b& z
20.     status = check_sd_status(0);
    : g6 r4 M( ~2 B* x- M0 L$ w3 C/ n
21. 
    3 N8 @+ f& r# ~# E5 a/ F% _
22.     return (status);
    
23. }

复制代码

用于实现SD模拟U盘的写入功能。
9 j% x& |  e+ b. o' n
3.3.4  接口函数注册
接口函数的注册是在文件demo_sd_usbx.c里面：
+ A7 ~' V# y/ j' }! J

1. storage_parameter.ux_slave_class_storage_parameter_lun[0].ux_slave_class_storage_media_read  =  app_usb_device_thread_media_read;
   
2. 
   6 w/ Z+ ~' ]" N9 e
3. storage_parameter.ux_slave_class_storage_parameter_lun[0].ux_slave_class_storage_media_write  =  app_usb_device_thread_media_write;
   
4. 
   
5. storage_parameter.ux_slave_class_storage_parameter_lun[0].ux_slave_class_storage_media_status =  app_usb_device_thread_media_status;

复制代码

0 ?" x: s/ k8 P( L  J1 d8 [3.4   使用的MicroUSB接口并注意跳线帽设置
本周教程移植的例子使用内部RAM模拟了一个U盘，效果如下：
; L/ E* c# s# n/ ^- N

! B8 t: N  \; m5 C8 e- ~! m
注意使用的是MicroUSB接口：
  D9 Y- f/ x9 n. [0 j3 J1 Q5 T, o7 r

, p) ?* H+ V$ M- Y4 O1 O
, }7 t+ F4 s. G2 M. r9 k$ N0 ^注意板子左下角跳线帽的设置：
; U7 o& s% V6 P5 m/ @' d
7 b. a: [' j- n4 ~

: s- u2 z8 c% F: N& ]5 v8 N
1 J$ H- m: i! P6 [3 k+ ?( J' ]这里是用于选择CAN1 TX使用PB9或者PA12引脚，CAN1 RX使用PB8或者PA11引脚。大家这里可以什么都不接，或者CAN1 TX通过跳线帽短接PA12，CAN1 RX通过跳线帽短接PA11。切记不可以短接到PA12和PA11引脚上，USB要使用这两个引脚。

. K& x6 i! t9 N. f# b3.5   实验例程
1 l0 l/ i% h7 K3 n配套例子：

) A5 g& b/ @' X, `  oV7-2401_ThreadX USBX Template
% L9 n* ?8 T. K; A
实验目的：

学习USBX模板，通过SD来模拟U盘。
实验内容：

# V# x0 m% w( V* X1、共创建了如下几个任务，通过按下按键K1可以通过串口或者RTT打印任务堆栈使用情况                                 
  ^: o8 g3 b8 d! m' Q# M1 v2 n
  ========================================================
  Z) j* F& `) C3 r% g
         CPU利用率 =  0.89%
% R* I0 N( E% M, L7 G
         任务执行时间 = 0.586484645s
( J& F: h4 ~3 @- o  M; V
         空闲执行时间 = 85.504470575s
! `9 Y' B/ W, ~3 \
1 ~  m. ~; @+ G- K         中断执行时间 = 0.173225395s
; u0 W$ B% m- p4 ?4 {0 c
         系统总执行时间 = 86.264180615s              

2 _, c1 j+ B5 ]2 `# h/ v=======================================================
: y9 A! f3 R! ^1 i  Q
% `4 {( N, k) g2 c7 i        任务优先级 任务栈大小 当前使用栈  最大栈使用   任务名

7 x6 T+ `2 V: l, w          Prio     StackSize   CurStack    MaxStack   Taskname

. S" m2 T% a# `: b' m2 H          2         4092        303         459      App Task Start
0 T: m& r; t. g/ `0 j
; l/ `. j" R  G+ e          5         4092        167         167      App Msp Pro
' w$ N1 E- i4 d
* s% Y4 L0 g+ D- N9 i. [  |          4         4092        167         167      App Task UserIF

* G' E1 ]% d6 [- O  T           5         4092        167         167      App Task COM

$ ?% u6 z# Z: K* b  ~           0         1020        191         191      System Timer Thread           

串口软件可以使用SecureCRT或者H7-TOOL RTT查看打印信息。

1 S, u% [6 x& U9 X2 d- U( t1 o% dApp Task Start任务  ：启动任务，这里用作BSP驱动包处理。
7 @' r* e7 ~4 r
App Task MspPro任务 ：消息处理。
  z* K1 Q+ `$ v: B) a  ]' e; r/ n
% d  U5 k1 X0 _' _- v. b7 [App Task UserIF任务 ：按键消息处理。

; K6 c. T9 H9 O. lApp Task COM任务   ：这里用作LED闪烁。
+ _, R$ e7 P9 V2 y, k
7 m+ _+ L6 [" X! [* ISystem Timer Thread任务：系统定时器任务
% D4 ^( i+ M. L" h+ H4 i8 E
, f2 R& Y9 _. \2、(1) 凡是用到printf函数的全部通过函数App_Printf实现。
3 p, S4 }8 z4 l" S1 S
7 S- d) V; V' X7 Y3 P; b      (2) App_Printf函数做了信号量的互斥操作，解决资源共享问题。
- D) r4 n7 r5 y) B
3、默认上电是通过串口打印信息，如果使用RTT打印信息
- i: A; X# _" V
(1)   MDK AC5，MDK AC6或IAR通过使能bsp.h文件中的宏定义为1即可

  k  Y0 C6 P0 e6 Y#define Enable_RTTViewer  1

2 g5 S" ?  D% h" t- s+ x+ v7 b9 e+ X(2)   Embedded Studio继续使用此宏定义为0, 因为Embedded Studio仅制作了调试状态RTT方式查看。
+ ^: [: U  V2 d, c3 t
7 l' ]0 ~' h) V, t! i& p; [实验操作：

测试前务必将SD卡插入到开发板左上角的卡座中。
% x1 Z# |0 i2 I5 C0 `0 A/ ^支持以下6个功能，用户通过电脑端串口软件发送数字1-6给开发板即可
printf("1 - 显示根目录下的文件列表\r\n");
  D3 I0 a. W. |& j1 O( c* y' T: sprintf("2 - 创建一个新文件armfly.txt\r\n");
8 V  F2 M1 L" s% E. e# K8 }printf("3 - 读armfly.txt文件的内容\r\n");
! ~" L# T1 K' x3 w9 L2 Vprintf("4 - 创建目录\r\n");
printf("5 - 删除文件和目录\r\n");
* A" ^, Z8 o7 r" c% g2 o% Mprintf("6 - 读写文件速度测试\r\n");
1 T0 n: |3 j+ f! y" P% p0 Zprintf("a - 打开SD卡模拟U盘\r\n");
; }! t& }, T- R6 _; wprintf("b - 关闭SD卡模拟U盘\r\n");
串口打印的信息：
, W% n6 \& D) C  v' j
波特率 115200，数据位 8，奇偶校验位无，停止位 1
/ W& N- @. Q! _7 i6 A, q

% n8 V* p. a0 U  j% S" j
/ {1 U: v2 N2 U/ D$ s8 L) ?9 y. [
$ k" t2 i/ v- Q" m$ J* n1 T, W
RTT打印：
0 C$ _) C5 X2 `3 s

+ C1 Q" X4 N9 Q, v
, A4 ]0 N+ G$ f" [3.6   总结
本章节就为大家讲解这么多，后面章节再为大家详细讲解USBX的玩法。

5 m* o$ s, M3 H! g: y1 E- h& O
1 T+ _- Q. C; v