8 |9 L& ]4 B* f
$ Y# _- E5 @8 f- B2 `4 ~1 前言
本文将基于STM32F4 Discovery板,从零开始设计并实现一个USB Audio的例子。

3 N; l# e( @* X1 ^1 J1 A& q! Z2 {2 设计构思
6 t  K0 z  D1 I; G所谓的USB AUDIO就是制作一个盒子，这个盒子可以通过USB连接到PC，PC端将其识别为Audio设备，然后在PC端播放音乐的时候，声音可以通过盒子播放出来。

7 _' c6 U9 H1 P/ E6 d2.1 从原理框图开始

6 p! k$ x& z7 x如上图所示,我们大概构思一下，为了实现USB AUDIO功能，我们使用一个MCU的USB外设连接PC端，整个流程是这样: PC端播放音乐时，代表音乐的数据流从PC端通过USB传输到MCU端，MCU端然后将其转发给一个外部Codec，最后通过Codec上连接的扬声器或耳机播放音乐。

2.2 硬件支撑
# q4 c* ~% R4 R/ K! l- \- H这里选择ST官方的STM32F4-DISCOVERY板来实现，之所以选择这块板子，就是因为其上有USB接口和Codec，正好符合我们设计的要求。
; }; h0 s2 G9 f4 Z. g; G9 g
2.2.1 USB接口
1 X$ R$ D+ k% W. f3 M( U9 @如下图为USB接口部分的电路：
+ P# X4 i  o3 P3 L5 s: B
这个一个将USB作为OTG的电路设计，在本设计中，我们只是将USB作为device来使用，因此，上图我们关注下面部分就可以了。在本设计中，我们使用到全速USB，从上图可以看出D+与D-引脚分别为PA12，PA11。
  d+ c6 G# a0 s3 H3 N
2.2.2 Codec部分
如下图所示:
; E' h  h3 \; B5 D% R2 q3 R" S( P
如上图所示，这里的Codec为具体型号为CS43L22，MCU通过I2C接口(PB9,PB6)连接Codec，作为其控制接口，使用I2S(PC7,PC10,PC12,PA4)作为数据通道，此外，MCU使用PD4这个IO管脚控制Codec的reset。CS43L22的14,15脚连接到外面的耳机插孔，也就是说，我们可以通过插入耳机线的方式来收听PC端播放的声音。
( Y% h. n% X1 z$ T, g
7 v3 i+ b& y% h2 A2.3 软件设计
为了简化开发流程，这里使用CubeMx自动生成代码工具来生成初始化代码，首先基于Cube库架构以及USB协议栈的特点，我们得先设计一个合理的软件框架。


如上图，蓝色表示的模块为标准模块，不需要我们去修改它，将由CubeMx自动生成，而绿色部分则可能涉及到需要修改，其中BSP部分是需要自己添加的代码，其他的都是由CubeMx生成。
% o+ M; z: [/ z+ R) _" n
各个模块的工作流程如下设计:
7 R# ]) n( E8 \% C- w+ x4 E
初始化流程: 由main开始，它首先对将使用到的外设I2C，I2S初始化，这最终将调到HAL MSP底层部分实现对具体IO管脚和外设的初始化。同时main使用usb description的数据通过调用USB栈初始化接口来完成对USB接口的初始化，这一步还涉及到USB的枚举过程。
# i7 n8 d  p7 V; {USB数据传输过程：PC端软件在播放音乐后，通过USB通道向MCU传输音频数据，音频数据到达MCU时，首先触发USB中断，然后进入到HAL driver层，在回调到 usb conf模块，接着进入到usb core，usb core再转给usb audio class，最后音频数据到达usb audio interface模块，到达这里，就只剩下对音频数据进行处理了。Usb audio interface模块是一个数据接收到数据处理的一个中间对接模块。
) [  K' E  h7 k6 C  ^1 bUSB音频数据处理过程: usb audio interface 模块将从USB stack底层传上来的音频数据转发给Codec组件，最终通过Codec组件连接的耳机播放出来。
. _7 M: k  X4 ?# Q# f, ?从以上的音频数据流程来看，最主要的就是usbaudio interface模块，它实现了从USB audio stack到codec驱动的对接。
' F% A6 S1 V9 U, d
接下来，我们来看看软件层面上的实现。

3 软件实现
8 I; q# z3 v# _% j7 }还是老办法，采用CubeMx这个工具来生成初始化代码，这样可以节省我们花费在基本外设上的调试初始参数时间。

4 r" N" D' Q: p3 B1 r! X7 H' l3.1 创建CubeMx工程
" u) ?, ^- l# q, J1 Q! j由于我们使用到的硬件平台是STM32F4Discovery板，上面搭载的MCU型号是STM32F407VGT6，我们就以此型号创建一个名为Audio_Test的工程。
: a6 N  D. }( \: _& E" @( P
3 O$ Z! R$ j1 o8 u; t( p  {pinout:
" H& i# Q! G7 t$ I
% }. r6 Z  Y; F. M5 W) ]; g6 z外设有用到USB_OTG_FS(PA11,PA12device模式)，I2C1(PB6,PB9)，I2S3(PC12,PA4,PC10,PC7，半双工主模式),此外Codec的reset使用PD4管脚控制，使用外部8M HSE。其pinout如下图所示：


Clock configuration:
: z  W8 e9 |9 ?8 j
时钟树如上设置，主频使用168M，I2S时钟输出初始化为96M。

+ m0 F( O( \1 c  I. UConfiguration:
0 |+ w% j. \6 @( h4 d1 t
, v+ @+ Q; \6 a  HAL层：
Usb_FS：使用默认参数。

I2C：100K速率，7位地址宽度，使用默认参数。

I2S：主发模式，标准16位宽，默认音频为48K，如下图：
  F' A) K, R( p. H, Q2 C/ H3 {
9 u8 U+ i( f3 B4 M) \8 T并为I2S发送添加DMA，半字位宽:
. P$ w7 S; k" U. O9 O

   MiddleWares:
( q* B6 i% o, B' y, x' ]% y; ]9 V
  b4 d4 j$ @1 `6 G: K7 N9 S2 @& jUSB选择Audiodevice class,其配置参数如下：


+ Z( T! p( x. w0 ~) g) V这里都是默认参数。

: Z9 e' A( f+ C/ a4 n在描述符参数内得为usb audio class修改两个参数：

PID得修改为0x5730(否则windows驱动会加载出错)
6 ]" }' p$ q$ k  z0 W 序列号：序列号字符串内不能包含字母，只能是数据(否则windowsaudio驱动在枚举后也不会将音频数据传输下来)。
3 R. X2 C! n+ Q* ^+ x6 }最后修改工程设置，将堆大小设为4K，栈大小设为1K，如下图：
1 a+ [2 {0 X: `# r& S3 t
如此就可以生成工程了，我们生成IAR工程。
) B7 F0 e6 A6 f+ w5 M# t. |
0 c  f) y/ E. ~# `( M+ F+ y! i3.2 生成的IAR工程介绍
" W0 j& d2 S: s0 P  X+ G3 x4 F8 o. n8 J
如上图所示，生成的IAR工程，主要有User,Drivers,Middleware3个目录。

% V* I2 d* g; \) m9 }User目录下为用户源码文件，用户的主要修改也将集中在此目录下，在这里，我们的主要工作是集中在usbd_audio_if.c文件，它对应着之前软件框图中的usbaudio interface模块，主要是实现USB audio协议栈与Codec的对接。其他源文件都保持不变就可以了。
Middlewares目录对应着usb audio stack模块，它由CubeMx自动生成，保持原样就可以，不需要任何修改。
Drivers目录对应着HAL层，它包含CMSIS，HAL驱动。

( r; x$ M6 S4 K$ ^3.3 开发
3.3.1 初次编译测试
首先我们不做任何修改，先编译一下工程，发现能顺利编译通过，并烧录进STM32F4DISCOVERY板，运行后通过USB连接上电脑，发现在设备管理器中能正常识别到这个USB AUDIO设备，如下图所示：
& M! W2 R1 j& v2 F1 m
5 P, `6 q) v9 v9 T) B. M4 D这说明，USB与PC端的连接是OK的，但不知道具体有没有数据。我们使用USB分析仪TOTAL PHASE USB480这个设备对USB总线进行数据监控，能够正常采集USB枚举过程和播放音乐的通信数据，如下图所示：
  r+ T& e  V- N$ r' p% ?
这表明，到目前为止，从PC端到USB端都是能正常工作的，从PC端发送过来的音频数据已经到达usb audio interface模块，目前只不过还没有对这些数据进行处理，显然，接下来的工作，我们就需要将这些音频数据通过codec驱动发送出去，最终到达外部组件CS32L22.
" ?; Z+ I( A$ a1 G
$ g3 D- J) ?9 y" X6 F* J$ a8 r3.3.2 添加codec驱动和audio bsp模块
1 Y$ }( o% P% H+ I5 p& Y) `- x我们已经知道，我们需要为audio添加BSP模块，在这里，我们将BSP归属于drivers类，因此，在drivers目录下添加BSP目录，通过之前的软件架构图我们可以知道，BSP包含Codec驱动（CS43L22）和Audio bsp模块，因此，我们在BSP目录下有添加了Codec的驱动源码cs43l22.c与bsp_audio.c,如下图所示：

其中cs43l22.c为codec cs32l22的驱动，我们可以从ST的组件驱动中找到它，并copy过来直接使用，不需要修改任何代码。而bsp_audio.c是我们自己写的，它的任务是为usbd_audio_if.c与cs43l22.c提供服务，让这两个模块胜利对接。
  W+ h2 N# p$ r! k+ j
3.3.2.1 Codec与HAL的对接
( u6 l* D, H4 X/ q6 L$ w; w- x( c# M首先我们来看Codec驱动文件cs43l22.c源文件，这个文件需要使用这个外部需要提供的接口：

1. [cpp] view plain copy
   " c: q: Q1 ]5 Z! @: `
2. AUDIO_IO_Init()  
   0 D' i2 s. P, b% c0 l
3. AUDIO_IO_DeInit()  
   
4. AUDIO_IO_Write()  
   ; d/ y" W5 K* Q/ y
5. AUDIO_IO_Read()  

复制代码

这个都是Codec的基本控制接口，是通过I2C来控制的。都是需要用户在驱动外部来提供这些接口给到驱动，于是，我们在bsp_audio.c文件中来提供这个接口的实现：

1. [cpp] view plain copy
   . \1 H1 W# r1 r, }) f* k
2. //---------------------for c43l22 port--------------------------//  
   ( B4 {. N* m# W2 a' }
3. static void I2Cx_Error(uint8_t Addr)  
   ' S$ ]/ B4 E2 e' L' C+ D/ A+ j9 \
4. {  
   
5.   /* De-initialize the IOE comunication BUS */  
   3 C; I/ B( A6 n( A5 |' R
6.   HAL_I2C_DeInit(&hi2c1);  
   
7.   
   ) S) _  r# H1 r3 O+ Z, K6 }8 E; v2 {
8.   /* Re-Initiaize the IOE comunication BUS */  
   
9.   //I2Cx_Init();  
   1 L* V. U! B; |: h
10.   //MX_I2C1_Init();  
    
11. }  
    
12. static void CODEC_Reset(void)  
    3 C; }0 A; B. E, Q  ^+ v( z" i- S
13. {  
    
14.     HAL_GPIO_WritePin(AUDIO_RESET_GPIO_Port, AUDIO_RESET_Pin, GPIO_PIN_RESET);  
    + E7 g% Q( Y0 c" W  [: z4 D/ D
15.     HAL_Delay(5);  
    
16.     HAL_GPIO_WritePin(AUDIO_RESET_GPIO_Port, AUDIO_RESET_Pin, GPIO_PIN_SET);  
      Q: W& G& F, C& K9 z0 K% S. j: {
17.     HAL_Delay(5);  
    
18. }  
    
19. void AUDIO_IO_Init(void)  
    + o& r' s' m# Q5 J
20. {  
    : c0 x3 d( O! T* t% Q
21.   //I2Cx_Init();  
    . }' o. ~; k& X. G$ B. v% V/ E: p
22. }  
    & ]8 }, H! p$ u
23. void AUDIO_IO_DeInit(void)  
    0 Z) I" b/ x6 p8 p* |  C2 E, C
24. {  
    
25.   
    
26. }  
    
27. /**
    1 W/ z7 A1 A2 r# O" c3 B0 B
28.   * @brief  Writes a single data.
    
29.   * @param  Addr: I2C address
    , ~/ c! k4 r' z
30.   * @param  Reg: Reg address
    ! ?% Q) \  h2 ?) ^0 Y* N) ^4 P
31.   * @param  Value: Data to be written
    
32.   */  
    ! M1 X8 p5 B% s2 `- i; P5 {! a
33. static void I2Cx_Write(uint8_t Addr, uint8_t Reg, uint8_t Value)  
      |; e! m3 R: |5 l2 F- E5 e+ [. a
34. {  
    & X/ J+ @- k; c7 {
35.   HAL_StatusTypeDef status = HAL_OK;  
    
36.   
    ! B: v' D5 G/ g1 `7 a
37.   status = HAL_I2C_Mem_Write(&hi2c1, Addr, (uint16_t)Reg, I2C_MEMADD_SIZE_8BIT, &Value, 1, I2C_TIMEOUT);  
    7 Y% u" B& i. |& z0 N$ u( d
38.   
    - Q& _4 A: u) ?( {( Z& i  G2 |
39.   /* Check the communication status */  
    
40.   if(status != HAL_OK)  
    
41.   {  
    / \1 S  o8 t6 O" F  ?& s+ q
42.     /* I2C error occured */  
    / N2 r# [# ?0 u8 b" w3 S* X; A
43.     I2Cx_Error(Addr);  
    
44.   }  
    
45. }  
    
46. void AUDIO_IO_Write(uint8_t Addr, uint8_t Reg, uint8_t Value)  
    
47. {  
      \# a9 s4 ?; @1 t
48.   I2Cx_Write(Addr, Reg, Value);  
    
49. }  
      O: l8 @! A" \0 B* j5 ]3 N
50.   
    
51. /**
    . \5 w# z! k6 x
52.   * @brief  Reads a single data.
    
53.   * @param  Addr: I2C address
    
54.   * @param  Reg: Reg address
    
55.   * @retval Data to be read
    
56.   */  
    
57. static uint8_t I2Cx_Read(uint8_t Addr, uint8_t Reg)  
    ' M+ {4 U! x+ G/ x
58. {  
    $ I9 N# B: G1 |- M8 e/ T& V+ e
59.   HAL_StatusTypeDef status = HAL_OK;  
    $ m/ i6 p' k# p7 N) H. e
60.   uint8_t Value = 0;  
    2 s5 _9 _/ K: U3 n/ q7 i5 l
61.   
    
62.   status = HAL_I2C_Mem_Read(&hi2c1, Addr, Reg, I2C_MEMADD_SIZE_8BIT, &Value, 1, I2C_TIMEOUT);  
    $ N3 r; {; a* V: M, Q! H
63.   
    2 n5 L- t, U2 y
64.   /* Check the communication status */  
    / `. ]; Q* e( d/ R
65.   if(status != HAL_OK)  
    
66.   {  
    
67.     /* Execute user timeout callback */  
    
68.     I2Cx_Error(Addr);  
    
69.   }  
    
70.   
    
71.   return Value;  
    
72. }  
    
73. uint8_t AUDIO_IO_Read(uint8_t Addr, uint8_t Reg)  
    
74. {  
    1 h7 u& I' [' ?- Z- g9 ]$ t# W
75.   return I2Cx_Read(Addr, Reg);  
    / c2 E1 Q8 q" c; J& d
76. }  

复制代码

由于在main函数中已经对I2C初始化过了，因此，在AUDIO_IO_Init函数中不需要再次初始化。

就这样，就完成了Codec驱动与与HAL的对接。

$ W, E7 j# M+ W$ ]' h+ m2 A3.3.2.2 usb audiointerface与codec的对接
我们打开usb audio interface源码文件usbd_audio.if.c文件，此文件由CubeMx自动生成，已经自动给出了一些关于usb audio class的函数，且这些函数体内容都是空白的，毫无疑问，接下来的工作，我们就是要完成这个空白的内容，就好比做填空题一样，当然，在做这些”填空题”的过程中，我们将使用到Codec驱动提供的接口，这一过程，就是usb audiointerface与codec的对接过程。

) m( @+ ~9 q/ h- p按照这一清晰思路，我们首先找到usbd_audio_if.c的一个接口：

1. [cpp] view plain copy
   
2. static int8_t AUDIO_Init_FS(uint32_t  AudioFreq, uint32_t Volume, uint32_t options)  
     P# o! M' N, E& k- O. M7 G
3. {   
   ! q6 f6 u4 p8 p) h
4.   /* USER CODE BEGIN 0 */  
   
5.   return (USBD_OK);  
   1 M, B: ]: G: w( B- w( H# B: o
6.   /* USER CODE END 0 */  
   ! N; ^1 ^! }% \0 Z8 I# b; M! z* c
7. }  

复制代码

这是个空白函数，它是在USB枚举结束并收到set_configuration消息时会被调用到，我们利用他来实现对codec的初始化。在bsp_audio.c文件中，我们添加一个函数，如下：

1. [cpp] view plain copy
   / j! _) T, P$ f0 r
2. static void I2Sx_Init(uint32_t AudioFreq)  
   - ]. a  |/ V( Y9 \' |5 Y* z
3. {  
   
4.   /* Initialize the haudio_i2s Instance parameter */  
   
5.   hi2s3.Instance = SPI3;  
   1 w) I$ a/ i# m. {+ x" d
6.   
   ' a) r  J; J! [- X/ X3 U: ]' m
7. /* Disable I2S block */  
   
8.   __HAL_I2S_DISABLE(&hi2s3);  
   ) C  t) ]: I3 c) s5 H2 U# W
9.   
   
10.   hi2s3.Init.Mode = I2S_MODE_MASTER_TX;  
    + l3 p$ W# p- J8 O; |" A7 W' l: T# h) h
11.   hi2s3.Init.Standard = I2S_STANDARD;  
    7 V& O" L/ c. H: I  e
12.   hi2s3.Init.DataFormat = I2S_DATAFORMAT_16B;  
    7 g* a/ i5 j4 q. S
13.   hi2s3.Init.AudioFreq = AudioFreq;  
    
14.   hi2s3.Init.CPOL = I2S_CPOL_LOW;  
    
15.   hi2s3.Init.MCLKOutput = I2S_MCLKOUTPUT_ENABLE;  
    
16.   
    
17.   if(HAL_I2S_GetState(&hi2s3) == HAL_I2S_STATE_RESET)  
    
18.   {  
    ( C/ b/ o  \0 v5 ^
19.     HAL_I2S_MspInit(&hi2s3);  
    
20.   }  
    
21.   /* Init the I2S */  
    0 m; U! s* `% Z  |% {0 K
22.   HAL_I2S_Init(&hi2s3);  
    ! k" j6 N7 |# X; H& ?  A( I
23. }  
    
24. const uint32_t I2SFreq[8] = {8000, 11025, 16000, 22050, 32000, 44100, 48000, 96000};  
    3 L* B$ ?% \3 B6 l- C# `# B
25. const uint32_t I2SPLLN[8] = {256, 429, 213, 429, 426, 271, 258, 344};  
    
26. const uint32_t I2SPLLR[8] = {5, 4, 4, 4, 4, 6, 3, 1};  
    
27. uint8_t BSP_AUDIO_OUT_Init(uint16_t OutputDevice, uint8_t Volume, uint32_t AudioFreq)  
    
28. {  
    
29.     uint32_t deviceid = 0x00;  
    0 l$ O' r, U" z, A" K* n
30.     uint8_t ret = AUDIO_ERROR;  
    4 F$ e3 z- {, g% p% L" B
31.     uint8_t index = 0, freqindex = 0xFF;  
    5 p& `. {9 F9 ^% H; u  G
32.     RCC_PeriphCLKInitTypeDef RCC_ExCLKInitStruct;  
    
33.   
    
34.     //get the according P,N value and set into config,this is for audio clock provide  
    
35.     for(index = 0; index < 8; index++)  
    
36.     {  
    2 n  L: w  j0 a% b) {- q
37.         if(I2SFreq[index] == AudioFreq)  
    & a! |7 J4 Q' M$ M2 p7 V; z& n4 g
38.         {  
    + U# r0 E* y8 H
39.             freqindex = index;  
    
40.         }  
    . A6 c5 N& S1 H) e7 s0 y
41.     }  
    % X3 ^- T& V6 ~. L/ a! |4 }) W
42.     HAL_RCCEx_GetPeriphCLKConfig(&RCC_ExCLKInitStruct);  
    - X# x3 O( f0 [  V0 N
43.     if(freqindex != 0xFF)  
    - y" p$ V+ ^, X) Q8 y6 i
44.     {  
    " Q6 F* y' ]( H
45.         RCC_ExCLKInitStruct.PeriphClockSelection = RCC_PERIPHCLK_I2S;  
    0 k9 c. }4 E0 b( {8 T
46.             RCC_ExCLKInitStruct.PLLI2S.PLLI2SN = I2SPLLN[freqindex];  
    
47.             RCC_ExCLKInitStruct.PLLI2S.PLLI2SR = I2SPLLR[freqindex];  
    
48.             HAL_RCCEx_PeriphCLKConfig(&RCC_ExCLKInitStruct);  
    * b7 e! U  L: j
49.     }  
    
50.     else  
    & ]" i" l) L6 o7 F7 S
51.     {  
    
52.         RCC_ExCLKInitStruct.PeriphClockSelection = RCC_PERIPHCLK_I2S;  
    
53.             RCC_ExCLKInitStruct.PLLI2S.PLLI2SN = 258;  
    & ~# }# Y8 U1 J
54.             RCC_ExCLKInitStruct.PLLI2S.PLLI2SR = 3;  
    7 q6 K. \4 g1 I( p
55.             HAL_RCCEx_PeriphCLKConfig(&RCC_ExCLKInitStruct);  
    
56.     }  
    
57.   
    
58.     //reset the Codec register  
    
59.     CODEC_Reset();  
    3 E9 R+ U( S  Y# Y+ _
60.     deviceid = cs43l22_drv.ReadID(AUDIO_I2C_ADDRESS);  
    
61.     if((deviceid & CS43L22_ID_MASK) == CS43L22_ID)  
    
62.       {  
    # t/ {) C7 x$ n1 P: Q+ q5 R: J4 h
63.         /* Initialize the audio driver structure */  
    
64.         audio_drv = &cs43l22_drv;  
    ; k. ~9 j. S% Q! u( c% F% g
65.         ret = AUDIO_OK;  
    ( h4 i; C) p6 {' D  w* x  ~
66.       }  
    7 B% _$ |  e# L9 @
67.       else  
    
68.       {  
    
69.         ret = AUDIO_ERROR;  
    
70.       }  
    ( r1 |* O0 ^( c3 Q; N- w
71.   
    + N( m+ q: X: s4 k) ?; C+ F$ e& H
72.      if(ret == AUDIO_OK)  
    * D9 c" @+ e  N/ t. V
73.       {  
    
74.         audio_drv->Init(AUDIO_I2C_ADDRESS, OutputDevice, Volume, AudioFreq);  
    $ r5 O' x) ?* ~
75.         /* I2S data transfer preparation:
    5 A! i6 V! ^$ ?6 I3 F5 |) q: t
76.         Prepare the Media to be used for the audio transfer from memory to I2S peripheral */  
    4 j6 C9 O' e6 }+ r
77.         /* Configure the I2S peripheral */  
    / G5 j/ W1 k$ h
78.         I2Sx_Init(AudioFreq);  
    ' Y0 w0 E/ ^- G0 E% d5 v) `
79.       }  
    % U4 `# A, R6 g$ p8 B9 v# {
80.     return AUDIO_OK;  
    
81. }  

复制代码

在BSP_AUDIO_OUT_Init()这个函数内，根据所传入的采样率，程序在预定义的数组内选择出MCU内部时钟树对I2S时钟的一个合理的分频值，并设置进时钟树配置内，然后再对codec进行初始化，最后对I2S外设初始化。
. }: \- R( `8 }& @- w3 E
+ X2 H' e3 U8 ?" G  V) O  q这个选择I2S时钟合理分频值的过程是根据STM32F407的参考手册中的建议来做的，如下参考手册中的28.4.4中表126：

5 K; f+ a, `- d; K5 A5 k- @* [% R
4 m  g% l) g6 \) D9 ?- c5 V. S在48K采样率下，假设时钟树下的PLLM VCO=1MHz情况下，且MCK使能，为了尽可能输出靠近期望的时钟，此时应该将时钟树内的PLL2SN设为258，且PLL2SR设为3，I2S内部的预分频因子I2SDIV设为3，以及零散因子I2SODD设为1。这个计算公式为:
2 F0 ?" h: u! a4 ?8 Z$ o
8 y6 Q5 T5 B3 n2 V9 V2 E: d也就是(1M*258/3)/[(16*2)*((2*3)+1)]=47991.07142857143,差不多48K。

PLL2SN，与PLL2SR的设置在上述代码中都有所体现，但是，预分频因子I2SDIV和零散因子I2SODD又是在哪里设置的呢？答案是在代码调用HAL_I2S_Init()时，在这个HAL接口内部会根据I2S的Audio Frequency(CubeMx中的I2S的Configuration中配置的参数)，以及I2S的输入时钟频率和MCK是否使能这些前提条件来自动计算出预分频因子I2SDIV和零散因子I2SODD的值，以此来尽可能匹配输出想要的位时钟，也对应着采样率48K。

搞懂了这些之后，我们马上将其代码进行对接：
! \7 U1 Z) G' W

1. [cpp] view plain copy
   0 q4 O& R1 t. ^. t' w. k4 r; `1 L
2. static int8_t AUDIO_Init_FS(uint32_t  AudioFreq, uint32_t Volume, uint32_t options)  
   
3. {   
   5 N5 [3 @/ ]9 r. K- t8 G
4.   /* USER CODE BEGIN 0 */  
   
5.   BSP_AUDIO_OUT_Init(OUTPUT_DEVICE_AUTO, Volume, AudioFreq);  
   . H) `& c7 P8 M1 K" K9 y
6.   return (USBD_OK);  
   
7.   /* USER CODE END 0 */  
   " g; ~9 |% r( T
8. }  

复制代码

接下来下一个需要对接的接口：
2 }8 V+ [9 r6 F# x  J

1. [cpp] view plain copy
   
2. static int8_t AUDIO_DeInit_FS(uint32_t options)  
   
3. {  
   
4.   /* USER CODE BEGIN 1 */   
   3 s) E; H. R) Y' O4 D, H& I9 i1 G% o
5.   BSP_AUDIO_OUT_Stop(CODEC_PDWN_SW);  
   
6.   return (USBD_OK);  
   5 f9 [/ l5 K( `% j' D
7.   /* USER CODE END 1 */  
   8 [* \! G+ A; Q' y3 P9 ]: E
8. }  
   
9. 很明显，这个个反初始化的接口，它的具体实现如下：
   
10. 
    
11. [cpp] view plain copy
    + `8 H1 `1 s  G% b
12. uint8_t BSP_AUDIO_OUT_Stop(uint32_t Option)  
    
13. {  
    
14.   /* Call the Media layer stop function */  
    
15.   HAL_I2S_DMAStop(&hi2s3);  
    
16.   
    
17.   /* Call Audio Codec Stop function */  
    
18.   if(audio_drv->Stop(AUDIO_I2C_ADDRESS, Option) != 0)  
    
19.   {  
    ( a* S8 c* S/ O/ |$ Q- z! ?( O
20.     return AUDIO_ERROR;  
    
21.   }  
    
22.   else  
    
23.   {  
    
24.     if(Option == CODEC_PDWN_HW)  
    $ K: B$ E, l1 z- }! q1 _( A
25.     {  
    ) ?+ V. e; J5 K9 ~6 V
26.       /* Wait at least 1ms */  
    . T3 u, N: g* A7 @2 u/ j9 @
27.       HAL_Delay(1);  
    ' A3 x5 ]; S; h1 W, x2 t
28.   
    
29.       /* Reset the pin */  
    
30.       //BSP_IO_WritePin(AUDIO_RESET_PIN, RESET);  
    , f, c, j6 |3 _/ A4 j$ }, B
31.       HAL_GPIO_WritePin(AUDIO_RESET_GPIO_Port, AUDIO_RESET_Pin, GPIO_PIN_RESET);  
    0 n. T5 u  |2 S/ o0 I& {& @
32.     }  
    5 C' w1 W8 t7 i
33.   
    
34.     /* Return AUDIO_OK when all operations are correctly done */  
    
35.     return AUDIO_OK;  
    
36.   }  
    
37. }  

复制代码

先关闭I2S的DMA，在调用Codec的停止接口。
7 B1 ]. L5 J. O2 ~+ M& j) BOK，下一个：

1. [cpp] view plain copy
   
2. static int8_t AUDIO_AudioCmd_FS (uint8_t* pbuf, uint32_t size, uint8_t cmd)  
   
3. {  
   
4.   /* USER CODE BEGIN 2 */  
   
5.   switch(cmd)  
   ) X  l$ R5 i8 `0 L' u+ x
6.   {  
   
7.     case AUDIO_CMD_START:  
   ! t8 n6 k. [. p7 _
8.         BSP_AUDIO_OUT_Play((uint16_t *)pbuf, size);  
   * b# U5 s: f. ~7 h
9.     break;  
   % P  Q: Q5 U* Y6 K
10.   
    % @, v' {, c* g7 \" }5 w! b
11.     case AUDIO_CMD_PLAY:  
    
12.         BSP_AUDIO_OUT_ChangeBuffer((uint16_t *)pbuf, size);  
    3 i- H1 K. _; U
13.     break;  
    5 d9 w- F" ^/ B; [0 E
14.   }  
    . B/ x+ q5 x; U% h! d( f" G
15.   return (USBD_OK);  
    
16.   /* USER CODE END 2 */  
    ! F/ P; ?0 r3 ~- W( D& s) t; @$ }
17.    
    # b  g4 N+ c9 W, q( b( _! h
18. }  

复制代码

第一次USB audio stack接收到USB OUT数据时会回调这个接口并传入AUDIO_CMD_START参数，这里的处理代码是：

1. [cpp] view plain copy
   
2. uint8_t BSP_AUDIO_OUT_Play(uint16_t* pBuffer, uint32_t Size)  
   
3. {  
   
4.   /* Call the audio Codec Play function */  
   1 i6 l8 @$ I# d2 [4 k! g0 L( H
5.   if(audio_drv->Play(AUDIO_I2C_ADDRESS, pBuffer, Size) != 0)  
   
6.   {  
   
7.     return AUDIO_ERROR;  
     D. w, o: B" V+ V; P
8.   }  
   * l% C0 U& b- o' Y4 ]; F7 v  x
9.   else  
   & r# A6 A  o0 i$ H9 z8 I
10.   {  
    7 \6 z& K8 v" n
11.     /* Update the Media layer and enable it for play */  
    5 F# J. v& _$ k6 N$ G* Q5 u
12.     HAL_I2S_Transmit_DMA(&hi2s3, pBuffer, DMA_MAX(Size/AUDIODATA_SIZE));  
    - h0 u8 L; W5 t$ }! ~( V; L
13.     return AUDIO_OK;  
    7 ]/ t- t& J$ ]3 L. z1 U1 y6 N
14.   }  
    
15. }  

复制代码

很明显，它是调用Codec驱动处理数据，也就是通过I2S的DMA方式发送给Codec。

8 {9 Y8 _6 O. r4 m; x" t+ Q. M然后I2S的DMA会产生传输完成中断和半传输完成中断，在这两个中断处理上，会回调到AUDIO_AudioCmd_FS()接口，并且此时传入的参数变为AUDIO_CMD_PLAY,此时，音频数据的处理函数为:

1. [cpp] view plain copy
   4 x+ z2 {0 W6 b: M3 c" z
2. void BSP_AUDIO_OUT_ChangeBuffer(uint16_t *pData, uint16_t Size)  
   + ^6 w& K6 {, j3 W" }
3. {  
   
4.   HAL_I2S_Transmit_DMA(&hi2s3, pData, Size);  
   
5. }  

复制代码

也是通过I2S的DMA将数据传输给外部Codec。
4 j* }% t+ @7 Q
上述过程涉及到另外两个usbd_audio_if接口函数，即I2S的DMA半传输完成和传输完成中断回调,如下所示:
; D9 z# _, ?( ^' R  M

1. [cpp] view plain copy
   
2. void TransferComplete_CallBack_FS(void)  
   3 [; N0 g1 t* b$ {0 D1 f0 H" C
3. {  
   / x1 ]+ e$ h4 q$ B" j
4.   /* USER CODE BEGIN 7 */   
   " {* o" @9 A" s
5.   USBD_AUDIO_Sync(&hUsbDeviceFS, AUDIO_OFFSET_FULL);  
   
6.   /* USER CODE END 7 */  
   6 b# X: P" G% J& r% B" o* q
7. }  
   4 d# A# s2 L9 V  ]/ a
8. void HalfTransfer_CallBack_FS(void)  
   $ i) p; p# }+ u$ c$ s3 j+ g  P4 O6 [
9. {   
   
10.   /* USER CODE BEGIN 8 */   
    : k" z  P3 ^  u- g" d3 F
11.   USBD_AUDIO_Sync(&hUsbDeviceFS, AUDIO_OFFSET_HALF);  
    
12.   /* USER CODE END 8 */  
    
13. }  

复制代码

此代码为CubeMx自动生成，且在自动生成的代码中就已经调用了usb audio class函数USBD_AUDIO_Sync()，在这里，对于这个，我们是不需要添加任何额外代码的。之前我们说过，在USBD_AUDIO_Sync()函数内部，会实现对AUDIO_AudioCmd_FS()的回调，目的是，需要及时将数据缓冲中另一半准备好的数据也通过I2S的DMA传输给外部Codec，这个不间断的传输，才能实现音频播放的连贯性。

此外，在USB设备端，后续接收到的音频数据会紧接着之前的数据进行存放，这里实现了一个数据环形缓冲区，来实现了USB接收端与I2S输出端数据有效的缓存。
( n' q2 g* W' n* `
接下来看下一个usbd_audio_if接口函数对接：

1. [cpp] view plain copy
   
2. static int8_t AUDIO_VolumeCtl_FS (uint8_t vol)  
   
3. {  
   
4.   /* USER CODE BEGIN 3 */   
   - C& x# O( Y: G
5.   BSP_AUDIO_OUT_SetVolume(vol);  
   9 Z7 _2 l8 M" w. ~
6.   return (USBD_OK);  
   ; c6 j& X9 y" _; A+ P4 w
7.   /* USER CODE END 3 */  
   ' R, b, e- Y# w2 @+ {% I* e
8. }  

复制代码

很明显，这个是音量控制接口，也对接下:
2 ^( z3 M6 @9 v' Z3 B

1. [cpp] view plain copy
   . v- _* m5 Q- @0 d
2. uint8_t BSP_AUDIO_OUT_SetVolume(uint8_t Volume)  
   4 Y7 I2 y. Y  j3 }+ S8 L
3. {  
   
4.   /* Call the codec volume control function with converted volume value */  
   0 d4 g8 C0 O; `' O1 @8 e
5.   if(audio_drv->SetVolume(AUDIO_I2C_ADDRESS, Volume) != 0)  
   ! e2 s- U$ R2 H
6.   {  
   2 M0 F; L3 @! y
7.     return AUDIO_ERROR;  
   
8.   }  
   9 ?6 p/ U, u, ~0 Q7 R8 M- R
9.   else  
   
10.   {  
    8 e7 H. H; d- K( K/ _+ b* _7 y
11.     /* Return AUDIO_OK when all operations are correctly done */  
    
12.     return AUDIO_OK;  
    
13.   }  
    
14. }  

复制代码

直接调用Codec启动的相应接口。需要注意地是，实际上，在PC端进行音量的调节，并不会向USB端发送相应的音量调节指令，这里只是象征性的对接下，实际上在USB AUDIO中代码并不会允许到这里，音量的放大和变小直接体现在音频数据本身内。
- p2 L# A1 _) Z+ \" l
下一个:

1. [cpp] view plain copy
   
2. static int8_t AUDIO_MuteCtl_FS (uint8_t cmd)  
   
3. {  
   4 w6 _! q' ?3 n& ?( H, a& c
4.   /* USER CODE BEGIN 4 */   
   6 S$ q# _5 H( O$ {
5.   BSP_AUDIO_OUT_SetMute(cmd);  
   
6.   return (USBD_OK);  
   
7.   /* USER CODE END 4 */  
   1 k, O7 p4 i. W; F
8. }  

复制代码

静音控制，其实现为：

1. [cpp] view plain copy
   " b& l; r" m: p
2. uint8_t BSP_AUDIO_OUT_SetMute(uint32_t Cmd)  
   
3. {  
   % C* p4 s2 D1 S' g8 m
4.   /* Call the Codec Mute function */  
   
5.   if(audio_drv->SetMute(AUDIO_I2C_ADDRESS, Cmd) != 0)  
   
6.   {  
   + j  ^9 g3 v. u& U# y- X0 l  U
7.     return AUDIO_ERROR;  
   
8.   }  
   6 R1 o$ S# n& c- b% c
9.   else  
   
10.   {  
    
11.     /* Return AUDIO_OK when all operations are correctly done */  
    
12.     return AUDIO_OK;  
    + \3 L/ n% b# g, e; H# U4 y
13.   }  
      V: F) v) T2 D: g, m
14. }  
    

复制代码

很简单，直接调用codec驱动的静音接口。静音接口与音量控制不同，在PC端进行静音操作会发送相应的mute指令，进而运行到这里。

. g- O6 d2 F& i' Y+ TOK，就这样，usbd_audio_if模块的接口基本上对接到这样就可以了。
1 ^, Z( C  Z8 c8 L2 a7 u
' _2 L. c) \3 k! x5 y4    测试验证
将代码编译后烧录进STM32F4DISCVOERY板进行验证。
( b+ ~' \  C4 ~
最终验证是OK的，可以从耳机上听到PC端播放的音乐。
: H7 ~0 t' D5 ~) W
; ?/ w: n+ b  g( O7 H  N5    结束语
0 p  F, C, e6 p6 E在CubeMx上对中间件USB配置时，将USB audio class的音频采样率设置为48K,那个这个参数会再USB枚举期间会传递给windows的audio驱动，在枚举通过后，后续通过USB传输的音频数据都将是固定以48K采样率来的，也就是192bytes/ms，也就是说，不管PC端播放什么音乐，windows的audio驱动都会固定以48K采样率向USB端口进行传输。这种特性是由windows的audio驱动决定的。

I2S外设向codec传输的时钟是可以改变的，在本应用中是用不着改变，这个是因为USB端固定以48K采样率接收数据，那么I2S也可以固定以48K采样率所对应的速度向Codec传输速度，这个特点，正式因为USB audio的固定传输特性所决定的。若换成播放本地U盘音频文件或连接iPhone并播放iPhone的音乐时，则I2S外设的时钟是根据每次播放的具体音乐所对应的采样率来配置I2S的时钟的，这种机制稍微有所不同，这里只需注意下，理解了就可以了。

在本例中，从I2S传输数据的速率是48K的采样率，但实际精度却是47991.07142857143。这个与标准的48K还是有所偏差的，实际上，无论USB端和I2S端的传输速度在理论上有多匹配，在实际上，多少都会存在些偏差，这也就意味着，在USB与I2S这两个”入口”与”出口”之间的缓存，在随着时间流逝，如不进行任何处理，这个缓存理论上一定会爆掉或掏空。那么这里就需要针对这个缓存这种现象的一种处理，或者叫做算法，算法的好坏在一定程度上决定了音质的好坏。而本例中，我们使用的是CubeMx生成的默认的最简单的算法，我们不做深入讨论，只是让大家有这么一个概念即可。


6 G. s/ l7 i; s5 b

楼主问下，你这个会有杂音吗？我这边测试了下，会有杂音的，如果根据接受AUDIO_TOTAL_BUF_SIZE大小去传输，usb中断影响HAL_I2S_Transmit_DMA(&hi2s1, (uint16_t *)pbuf, (size))传输结果，显示为hal_busy,忙等待，传输数据这块你有做特殊处理吗？
static uint8_t  USBD_AUDIO_DataOut (USBD_HandleTypeDef *pdev,
+ E' J! l4 K0 s+ B% f3 F; [                              uint8_t epnum)
7 l$ o- @" v3 z% g. q1 p5 Z$ ]4 d{
# @- }+ H0 V* O' u# X. N1 E  USBD_AUDIO_HandleTypeDef   *haudio;
) {( _8 B) |+ Y0 z7 n8 f  haudio = (USBD_AUDIO_HandleTypeDef*) pdev->pClassData;
+ h' l2 u2 }5 T
  if (epnum == AUDIO_OUT_EP)
  {
    /* Increment the Buffer pointer or roll it back when all buffers are full */
/ H9 P! x$ [4 E0 O8 j
    haudio->wr_ptr += AUDIO_OUT_PACKET;

/ T$ p0 j6 B; h; c    if (haudio->wr_ptr == AUDIO_TOTAL_BUF_SIZE)
    {
( Z2 L9 Y8 b  `: ^  B. o' B* Z# ^      /* All buffers are full: roll back */
/ k( @- p# E% b5 V8 \3 i      haudio->wr_ptr = 0U;
    ((USBD_AUDIO_ItfTypeDef *)pdev->pUserData)->AudioCmd(&haudio->buffer[0],
( c0 x* t- b2 B) c0 ^2 s                                                 AUDIO_TOTAL_BUF_SIZE / 2U,
                                                 AUDIO_CMD_PLAY);
8 o; ~! H1 B  o% z% O. H- h  {4 |#if 0
      if(haudio->offset == AUDIO_OFFSET_UNKNOWN)
. R. Z5 g2 l' a- o      {
4 y: V/ y: l) d( U        ((USBD_AUDIO_ItfTypeDef *)pdev->pUserData)->AudioCmd(&haudio->buffer[0],
: k& R7 }+ w  G) z& g( i  g$ P                                                             AUDIO_TOTAL_BUF_SIZE / 2U,
3 o! E; [' F; x6 k                                                             AUDIO_CMD_START);
          haudio->offset = AUDIO_OFFSET_NONE;
% f& |) O7 ?4 S: ^. w      }
2 f8 l  x1 V+ u6 N#endif
; ?3 @& M  B7 N% t* ]3 @( q5 C    }

    if(haudio->rd_enable == 0U)
% b+ u$ H. z; v  c: N    {
      if (haudio->wr_ptr == (AUDIO_TOTAL_BUF_SIZE / 2U))
      {
        haudio->rd_enable = 1U;
+ f0 k8 Q" T9 ]3 k3 k0 g      }
7 L6 ^$ P. q6 c: z$ `! k8 [    }

( C" i9 Q& c+ ?1 V    /* Prepare Out endpoint to receive next audio packet */
    USBD_LL_PrepareReceive(pdev, AUDIO_OUT_EP, &haudio->buffer[haudio->wr_ptr],
                           AUDIO_OUT_PACKET);
3 x! ?- M/ s6 q2 g; a$ I% ~! a( L  }

楼主还在吗？
我参考了您的这篇文章，在 STM32F413 discovery 板子上试验 USB Audio，
我先用 STM32CubeMX 5.2.1 生成代码框架，然后再把 STM32CubeF4 V1.24.1 里面的 stm32f413h_discovery.c, stm32f413h_discovery_audio.c, wm8994.c 这几个源文件添加到工程里，用的 toolchain 是 IAR 8.30。
现在的问题是，如果在 usbd_audio_if.c 里面函数 AUDIO_Init_FS 里面什么都不调那么能成功地枚举出 "STM32 Audio Class" 设备，
但是只要 AUDIO_Init_FS 里面调了 BSP_AUDIO_OUT_Init 就会枚举失败，显示“未知 USB 设备”，跟踪 BSP_AUDIO_OUT_Init 的执行过程没发现问题，
而且这个函数返回值也是OK，但是紧接着 AUDIO_DeInit_FS 就被调了，也跟踪了 USB 中断和 DMA 中断都有，查了好几天查不出原因，时钟配置好像也没问题，楼主您能指点一下吗？多谢！

梦中的飞鸿 发表于 2019-9-11 09:20
这个问题您解决了吗，我这也遇到了这个问题，有个小感叹号，然后提示
$ A( h( b) d: F
! k3 Z! v8 l$ m7 f2 r! a1 s4 g7 B该设备无法启动。 (代码 10)

7 @7 R' ~# m2 z. h$ G4 ?6 O4 s* N出现这种情况要保证描述符是不是正确的，如果描述符正确在看看内存是否溢出，如果都正确，那就要一步步找问题了，就是把个单片机外设相关的代码想注释掉，基本上就找到原因了。

非常好的帖子，谢谢分享！！！

anny 发表于 2018-5-23 14:45
非常好的帖子，谢谢分享！！！

9 P% O; i7 ~1 G3 `: Z+ J希望能有帮助

anny 发表于 2018-5-23 14:45
非常好的帖子，谢谢分享！！！

希望能有帮助

非常好的帖子，楼主可以发一份工程的代码吗？非常感谢，18056453597@qq.com

666，好贴，顶起来~

收藏

" F0 z1 O" e" O2 I/ {非常好的帖子，谢谢分享！！！

好贴！

楼主，我想问下，stm32 Audio Class的PC端不需要驱动吗？我的提示能够正确识别设备，但是安装驱动失败！
* A0 Y* b! N1 ?* y8 h% o2 ?+ a  N
2 C& v* w: i0 Z. W6 E8 ]- q, q$ m

delei 发表于 2019-8-12 11:18
. k4 _" P- n) u% ^8 p楼主，我想问下，stm32 Audio Class的PC端不需要驱动吗？我的提示能够正确识别设备，但是安装驱动失败！

...

这个问题您解决了吗，我这也遇到了这个问题，有个小感叹号，然后提示

该设备无法启动。 (代码 10)

I/O 请求已取消。
5 }' _* z/ H1 z3 N

梦中的飞鸿 发表于 2019-9-11 09:20
; F  R! `: J: Z; z: U* t这个问题您解决了吗，我这也遇到了这个问题，有个小感叹号，然后提示

该设备无法启动。 (代码 10)

& ]( {  _; e" u经测，不要用最新的库版本，用1.21.0的测试直接生成，正常识别！