6 U3 V3 j% [0 g9 V- @1 前言
本文将基于STM32F4 Discovery板,从零开始设计并实现一个USB Audio的例子。
) `6 A$ o; g# L
) n! l- v8 a& |, O7 n' O& u2 设计构思
0 }/ d' S9 P2 e2 F所谓的USB AUDIO就是制作一个盒子，这个盒子可以通过USB连接到PC，PC端将其识别为Audio设备，然后在PC端播放音乐的时候，声音可以通过盒子播放出来。
; ?# ]2 r" l" k- R
2.1 从原理框图开始
& |% p' v  f, Y$ Z: C
如上图所示,我们大概构思一下，为了实现USB AUDIO功能，我们使用一个MCU的USB外设连接PC端，整个流程是这样: PC端播放音乐时，代表音乐的数据流从PC端通过USB传输到MCU端，MCU端然后将其转发给一个外部Codec，最后通过Codec上连接的扬声器或耳机播放音乐。
$ c; I# s- s) r/ Y
2.2 硬件支撑
  X5 E; V% T7 G. X* R8 f3 J+ i, D! p这里选择ST官方的STM32F4-DISCOVERY板来实现，之所以选择这块板子，就是因为其上有USB接口和Codec，正好符合我们设计的要求。

# o, a! {! y8 R, P2.2.1 USB接口
/ u. E8 d& }& r$ c: k! o如下图为USB接口部分的电路：
  s2 }" n8 C% q
这个一个将USB作为OTG的电路设计，在本设计中，我们只是将USB作为device来使用，因此，上图我们关注下面部分就可以了。在本设计中，我们使用到全速USB，从上图可以看出D+与D-引脚分别为PA12，PA11。
! g/ P- N6 F3 i  _  J! U0 x
2.2.2 Codec部分
8 B# Y9 H: c0 \% O如下图所示:
; n# c2 |; T" i4 V  ]& O
- Q4 C( ^6 X* T9 Q8 j/ R如上图所示，这里的Codec为具体型号为CS43L22，MCU通过I2C接口(PB9,PB6)连接Codec，作为其控制接口，使用I2S(PC7,PC10,PC12,PA4)作为数据通道，此外，MCU使用PD4这个IO管脚控制Codec的reset。CS43L22的14,15脚连接到外面的耳机插孔，也就是说，我们可以通过插入耳机线的方式来收听PC端播放的声音。
  H; P. w8 q. z7 \  m9 }: y
$ [/ ?; Z$ Z9 o" e/ K( @3 L2.3 软件设计
为了简化开发流程，这里使用CubeMx自动生成代码工具来生成初始化代码，首先基于Cube库架构以及USB协议栈的特点，我们得先设计一个合理的软件框架。
- |7 A8 ^" }8 {3 q
' R2 T1 w+ k/ _! S  u4 |2 I# `! Y
如上图，蓝色表示的模块为标准模块，不需要我们去修改它，将由CubeMx自动生成，而绿色部分则可能涉及到需要修改，其中BSP部分是需要自己添加的代码，其他的都是由CubeMx生成。
9 ~8 l; T4 z! F) f" ]+ F1 m
, y" S0 d1 O3 s8 F. n& i各个模块的工作流程如下设计:
0 q- ^$ W- Q  C0 F: f8 O: }  j
# ]. j/ J% `) f- s. D9 q# B- R 初始化流程: 由main开始，它首先对将使用到的外设I2C，I2S初始化，这最终将调到HAL MSP底层部分实现对具体IO管脚和外设的初始化。同时main使用usb description的数据通过调用USB栈初始化接口来完成对USB接口的初始化，这一步还涉及到USB的枚举过程。
* A( o8 _: E; o% m& k1 l+ @2 QUSB数据传输过程：PC端软件在播放音乐后，通过USB通道向MCU传输音频数据，音频数据到达MCU时，首先触发USB中断，然后进入到HAL driver层，在回调到 usb conf模块，接着进入到usb core，usb core再转给usb audio class，最后音频数据到达usb audio interface模块，到达这里，就只剩下对音频数据进行处理了。Usb audio interface模块是一个数据接收到数据处理的一个中间对接模块。
USB音频数据处理过程: usb audio interface 模块将从USB stack底层传上来的音频数据转发给Codec组件，最终通过Codec组件连接的耳机播放出来。
. F2 [$ j  S$ W( ?: s从以上的音频数据流程来看，最主要的就是usbaudio interface模块，它实现了从USB audio stack到codec驱动的对接。
, n% D) s7 L; @# D' `0 z
- E: X% H  o! q* a接下来，我们来看看软件层面上的实现。
9 R: a7 b# ~* |8 e$ x
3 软件实现
还是老办法，采用CubeMx这个工具来生成初始化代码，这样可以节省我们花费在基本外设上的调试初始参数时间。

3.1 创建CubeMx工程
5 @  V; g7 t/ E2 U由于我们使用到的硬件平台是STM32F4Discovery板，上面搭载的MCU型号是STM32F407VGT6，我们就以此型号创建一个名为Audio_Test的工程。

pinout:
- [, q% ~+ [/ k" g& X' r
外设有用到USB_OTG_FS(PA11,PA12device模式)，I2C1(PB6,PB9)，I2S3(PC12,PA4,PC10,PC7，半双工主模式),此外Codec的reset使用PD4管脚控制，使用外部8M HSE。其pinout如下图所示：
  }3 ]& Q+ g! p4 z5 ]1 N7 B

3 c; Z' ^! ^$ g* t/ s/ \& ?+ X; OClock configuration:
7 e9 ^; M$ f# |
时钟树如上设置，主频使用168M，I2S时钟输出初始化为96M。

Configuration:
4 g( s- M  S: B
  HAL层：
! V- {2 n: K: r2 t% vUsb_FS：使用默认参数。

3 I6 p; V6 j6 |# u  M0 TI2C：100K速率，7位地址宽度，使用默认参数。

% g( j. N2 n5 A) ?I2S：主发模式，标准16位宽，默认音频为48K，如下图：
6 H6 D" y3 P4 u4 \4 O, m, X
并为I2S发送添加DMA，半字位宽:


  y4 U. ~. j3 Y0 A2 U   MiddleWares:

! R' k2 ~9 y8 U: i7 N3 S, B3 S$ [4 wUSB选择Audiodevice class,其配置参数如下：
  }- _8 X2 T3 X# W( Y: ^, I

- u+ ?& o/ D! L& Q: n' ~& V) v这里都是默认参数。

5 z' P& Z$ V2 o; D在描述符参数内得为usb audio class修改两个参数：
& O" D' F+ A; L% v0 c! w% E" i2 m$ N+ O. m
PID得修改为0x5730(否则windows驱动会加载出错)
序列号：序列号字符串内不能包含字母，只能是数据(否则windowsaudio驱动在枚举后也不会将音频数据传输下来)。
4 M4 E' w) L: J( K" q2 y- ^最后修改工程设置，将堆大小设为4K，栈大小设为1K，如下图：

如此就可以生成工程了，我们生成IAR工程。
0 [1 b$ z, Q2 K4 J5 t
3 P0 x1 x! x! s, p+ V* F9 ?6 B3.2 生成的IAR工程介绍
0 d' h( \" B, G# B2 Z
% E8 l0 r" ]6 L  q如上图所示，生成的IAR工程，主要有User,Drivers,Middleware3个目录。

/ K: @2 `+ w: [' Z+ ^& VUser目录下为用户源码文件，用户的主要修改也将集中在此目录下，在这里，我们的主要工作是集中在usbd_audio_if.c文件，它对应着之前软件框图中的usbaudio interface模块，主要是实现USB audio协议栈与Codec的对接。其他源文件都保持不变就可以了。
Middlewares目录对应着usb audio stack模块，它由CubeMx自动生成，保持原样就可以，不需要任何修改。
Drivers目录对应着HAL层，它包含CMSIS，HAL驱动。

3.3 开发
  I- [, X$ f2 d7 d1 A! Y3.3.1 初次编译测试
4 d7 Q; _/ U% t; Z$ j首先我们不做任何修改，先编译一下工程，发现能顺利编译通过，并烧录进STM32F4DISCOVERY板，运行后通过USB连接上电脑，发现在设备管理器中能正常识别到这个USB AUDIO设备，如下图所示：

; O9 |" d. M5 e7 y5 Z% X- e9 U这说明，USB与PC端的连接是OK的，但不知道具体有没有数据。我们使用USB分析仪TOTAL PHASE USB480这个设备对USB总线进行数据监控，能够正常采集USB枚举过程和播放音乐的通信数据，如下图所示：

这表明，到目前为止，从PC端到USB端都是能正常工作的，从PC端发送过来的音频数据已经到达usb audio interface模块，目前只不过还没有对这些数据进行处理，显然，接下来的工作，我们就需要将这些音频数据通过codec驱动发送出去，最终到达外部组件CS32L22.

' ^, \2 |( @7 `* o! Z3.3.2 添加codec驱动和audio bsp模块
+ ?  ~% A0 c3 V# z: R6 y5 k; q我们已经知道，我们需要为audio添加BSP模块，在这里，我们将BSP归属于drivers类，因此，在drivers目录下添加BSP目录，通过之前的软件架构图我们可以知道，BSP包含Codec驱动（CS43L22）和Audio bsp模块，因此，我们在BSP目录下有添加了Codec的驱动源码cs43l22.c与bsp_audio.c,如下图所示：
) [9 [* i1 O- K- B; j+ j- D# \
其中cs43l22.c为codec cs32l22的驱动，我们可以从ST的组件驱动中找到它，并copy过来直接使用，不需要修改任何代码。而bsp_audio.c是我们自己写的，它的任务是为usbd_audio_if.c与cs43l22.c提供服务，让这两个模块胜利对接。

4 r% m: \! Y( l( H, P3.3.2.1 Codec与HAL的对接
首先我们来看Codec驱动文件cs43l22.c源文件，这个文件需要使用这个外部需要提供的接口：
! r3 q+ I4 a* f0 z

1. [cpp] view plain copy
   
2. AUDIO_IO_Init()  
   
3. AUDIO_IO_DeInit()  
   0 n+ O! r' s( Y0 j, O
4. AUDIO_IO_Write()  
   
5. AUDIO_IO_Read()  

复制代码

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

1. [cpp] view plain copy
   ! D! g; o& V4 u+ X; x( I
2. //---------------------for c43l22 port--------------------------//  
   
3. static void I2Cx_Error(uint8_t Addr)  
   2 j' g. l0 i3 y* r) d# [7 x
4. {  
   
5.   /* De-initialize the IOE comunication BUS */  
   
6.   HAL_I2C_DeInit(&hi2c1);  
   9 V) u" @; \+ x7 E) l" x3 I
7.   
   / Q6 z$ H3 J/ o) Z6 w% l3 |7 q
8.   /* Re-Initiaize the IOE comunication BUS */  
   
9.   //I2Cx_Init();  
   
10.   //MX_I2C1_Init();  
    , {2 O, _; Z3 n+ X. G' Y
11. }  
    
12. static void CODEC_Reset(void)  
    + r+ B9 z; @3 j5 D% e( s
13. {  
    , A$ N2 ~1 D( a7 u4 r
14.     HAL_GPIO_WritePin(AUDIO_RESET_GPIO_Port, AUDIO_RESET_Pin, GPIO_PIN_RESET);  
    . q% R. _( \+ U; q* s8 K
15.     HAL_Delay(5);  
    : w1 C! D, j6 v. X
16.     HAL_GPIO_WritePin(AUDIO_RESET_GPIO_Port, AUDIO_RESET_Pin, GPIO_PIN_SET);  
    
17.     HAL_Delay(5);  
    
18. }  
    ! b% z2 F- v9 j% u- x. x# h
19. void AUDIO_IO_Init(void)  
    
20. {  
    2 `; ~6 c  a- ?/ J, u
21.   //I2Cx_Init();  
    
22. }  
    # Y/ G4 s) g! w; t
23. void AUDIO_IO_DeInit(void)  
    
24. {  
    ) p3 n# G. V3 D
25.   
    & j' J- [4 j/ S0 [2 P  R
26. }  
    
27. /**
    
28.   * @brief  Writes a single data.
    ) v$ N6 e" m1 N9 s, L) }
29.   * @param  Addr: I2C address
    
30.   * @param  Reg: Reg address
    ) J# O0 U1 h1 D9 t+ g  _
31.   * @param  Value: Data to be written
    6 c1 j6 K: }% B9 g
32.   */  
    
33. static void I2Cx_Write(uint8_t Addr, uint8_t Reg, uint8_t Value)  
    
34. {  
    ( a0 _/ @* D6 d, f7 q
35.   HAL_StatusTypeDef status = HAL_OK;  
    
36.   
    / Q1 U' Z. ^2 m, C" I
37.   status = HAL_I2C_Mem_Write(&hi2c1, Addr, (uint16_t)Reg, I2C_MEMADD_SIZE_8BIT, &Value, 1, I2C_TIMEOUT);  
    ) y) Y' n; |& k2 M3 K
38.   
    7 k! Z9 U$ b8 i
39.   /* Check the communication status */  
    1 q) |  o* ?/ t1 q) E* ]3 P5 W
40.   if(status != HAL_OK)  
    , v, ~! H. U7 \1 w
41.   {  
    , y/ _' Q4 c1 G' S1 p6 \8 E
42.     /* I2C error occured */  
    2 \: }0 i9 t. ^$ y+ }' G
43.     I2Cx_Error(Addr);  
    8 k3 q0 e$ H1 I4 C. M
44.   }  
    " S3 d2 p' j2 E4 E& C# o7 I4 m3 l
45. }  
    
46. void AUDIO_IO_Write(uint8_t Addr, uint8_t Reg, uint8_t Value)  
    $ q; H4 x* j3 b: j: r: ], L( k
47. {  
    
48.   I2Cx_Write(Addr, Reg, Value);  
    
49. }  
    
50.   
    
51. /**
    7 B! Z- r' S( \& H$ [' d6 {$ X5 a0 e% z
52.   * @brief  Reads a single data.
    & X8 J8 k6 m  @6 _- r* C
53.   * @param  Addr: I2C address
    9 o, [7 N. P, |: G1 g+ Z
54.   * @param  Reg: Reg address
    
55.   * @retval Data to be read
    8 w3 o/ i* ?. X0 S( ^' K
56.   */  
    
57. static uint8_t I2Cx_Read(uint8_t Addr, uint8_t Reg)  
    1 A5 X: K2 A- f
58. {  
    8 K& j: V: W* d6 I( P& m) G
59.   HAL_StatusTypeDef status = HAL_OK;  
    ( z/ k) b9 `% t/ Z
60.   uint8_t Value = 0;  
    3 v; _6 z- f( f/ q' s
61.   
    
62.   status = HAL_I2C_Mem_Read(&hi2c1, Addr, Reg, I2C_MEMADD_SIZE_8BIT, &Value, 1, I2C_TIMEOUT);  
    
63.   
    : b1 V' I0 d5 D/ }6 R+ ]1 S; P. s
64.   /* Check the communication status */  
    
65.   if(status != HAL_OK)  
    ! s. a8 }' c+ m6 L* u
66.   {  
    
67.     /* Execute user timeout callback */  
    2 M7 {) ]1 A4 m$ L: |6 O+ X
68.     I2Cx_Error(Addr);  
    7 M& \$ |) N1 _' y) r. t
69.   }  
    6 T, y; R+ J: Q( s3 S7 a6 W
70.   
    5 T" p- }5 }! K: R
71.   return Value;  
    
72. }  
    $ Q" {1 N- _! r
73. uint8_t AUDIO_IO_Read(uint8_t Addr, uint8_t Reg)  
    
74. {  
    
75.   return I2Cx_Read(Addr, Reg);  
    
76. }  

复制代码

由于在main函数中已经对I2C初始化过了，因此，在AUDIO_IO_Init函数中不需要再次初始化。
. p5 ?: i; ?% k+ Z6 T7 b' \5 l/ f
& O( }0 ~8 f- P6 r! [' s就这样，就完成了Codec驱动与与HAL的对接。

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

9 \8 ~; j7 i- y2 M/ y" E按照这一清晰思路，我们首先找到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)  
   
3. {   
   
4.   /* USER CODE BEGIN 0 */  
   
5.   return (USBD_OK);  
   
6.   /* USER CODE END 0 */  
   
7. }  

复制代码

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

1. [cpp] view plain copy
   " |- @$ m6 I8 a/ a3 U3 `
2. static void I2Sx_Init(uint32_t AudioFreq)  
   , x& L. W/ ~& \- ^" E8 K1 ?. O( B  P
3. {  
   
4.   /* Initialize the haudio_i2s Instance parameter */  
   . u, P# A+ u) v
5.   hi2s3.Instance = SPI3;  
   
6.   
   & l: {: e7 ~! l* {8 E8 {& g
7. /* Disable I2S block */  
   ) G4 i* U8 q* J3 Q0 r
8.   __HAL_I2S_DISABLE(&hi2s3);  
   
9.   
   
10.   hi2s3.Init.Mode = I2S_MODE_MASTER_TX;  
    
11.   hi2s3.Init.Standard = I2S_STANDARD;  
    / v& D3 |2 f; s3 d0 g& v. v
12.   hi2s3.Init.DataFormat = I2S_DATAFORMAT_16B;  
    
13.   hi2s3.Init.AudioFreq = AudioFreq;  
    - p! e2 s8 e8 W4 e$ V& X5 B
14.   hi2s3.Init.CPOL = I2S_CPOL_LOW;  
    % E5 S( L# ^7 o0 {+ ]! Y- ?$ ]1 w
15.   hi2s3.Init.MCLKOutput = I2S_MCLKOUTPUT_ENABLE;  
    $ R$ d  l: A) t( r4 M  Y4 ?
16.   
    
17.   if(HAL_I2S_GetState(&hi2s3) == HAL_I2S_STATE_RESET)  
    
18.   {  
    6 u% a( u4 Y+ H4 E
19.     HAL_I2S_MspInit(&hi2s3);  
    
20.   }  
    8 x2 J% ~* g, M
21.   /* Init the I2S */  
    
22.   HAL_I2S_Init(&hi2s3);  
    
23. }  
    
24. const uint32_t I2SFreq[8] = {8000, 11025, 16000, 22050, 32000, 44100, 48000, 96000};  
    + l. q% [1 N& Y6 w: P
25. const uint32_t I2SPLLN[8] = {256, 429, 213, 429, 426, 271, 258, 344};  
    ! y' {0 X; ^6 d/ d
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. {  
    - t5 c# z1 t/ x' W. W
29.     uint32_t deviceid = 0x00;  
    6 s/ X) r  |3 p" W  V7 l
30.     uint8_t ret = AUDIO_ERROR;  
    
31.     uint8_t index = 0, freqindex = 0xFF;  
    
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.     {  
    
37.         if(I2SFreq[index] == AudioFreq)  
    
38.         {  
    1 t2 I- w3 Z! q$ ]
39.             freqindex = index;  
    
40.         }  
    % Q8 R; X3 [. S1 q% O& i/ H- ?
41.     }  
    
42.     HAL_RCCEx_GetPeriphCLKConfig(&RCC_ExCLKInitStruct);  
    
43.     if(freqindex != 0xFF)  
    9 s9 a' L1 z) J) m# i9 u* ?
44.     {  
    ' I! ?+ c9 S, u  L5 b% V) \
45.         RCC_ExCLKInitStruct.PeriphClockSelection = RCC_PERIPHCLK_I2S;  
    2 v3 C1 c. `9 F1 T8 u
46.             RCC_ExCLKInitStruct.PLLI2S.PLLI2SN = I2SPLLN[freqindex];  
    * z9 C* n( F) w% O! j' M
47.             RCC_ExCLKInitStruct.PLLI2S.PLLI2SR = I2SPLLR[freqindex];  
    ( s/ q# _4 C7 ?9 G8 |5 j
48.             HAL_RCCEx_PeriphCLKConfig(&RCC_ExCLKInitStruct);  
    
49.     }  
    3 \4 A3 k$ t; K
50.     else  
    1 J$ s7 Z+ h3 x4 t' @- q. i9 l) [
51.     {  
    
52.         RCC_ExCLKInitStruct.PeriphClockSelection = RCC_PERIPHCLK_I2S;  
    / ^1 l& G4 Y/ P5 `
53.             RCC_ExCLKInitStruct.PLLI2S.PLLI2SN = 258;  
    
54.             RCC_ExCLKInitStruct.PLLI2S.PLLI2SR = 3;  
    
55.             HAL_RCCEx_PeriphCLKConfig(&RCC_ExCLKInitStruct);  
    7 O) ]+ _  E- D8 D9 s0 `
56.     }  
    
57.   
    + u$ Y' n! ]6 _: ]' P+ q
58.     //reset the Codec register  
    
59.     CODEC_Reset();  
    
60.     deviceid = cs43l22_drv.ReadID(AUDIO_I2C_ADDRESS);  
    % k; w, Q7 I% [: ~9 V  A$ L
61.     if((deviceid & CS43L22_ID_MASK) == CS43L22_ID)  
    
62.       {  
    
63.         /* Initialize the audio driver structure */  
    $ x  o9 v, ~1 D  E
64.         audio_drv = &cs43l22_drv;  
    
65.         ret = AUDIO_OK;  
    9 y) @1 _& }1 a
66.       }  
    % w7 b& r# V0 G
67.       else  
    
68.       {  
    
69.         ret = AUDIO_ERROR;  
    4 N: @( F9 D/ I) X
70.       }  
    $ @3 ?( h5 m/ ^8 T
71.   
    2 V* n  C4 D* U) c4 Z
72.      if(ret == AUDIO_OK)  
    
73.       {  
    
74.         audio_drv->Init(AUDIO_I2C_ADDRESS, OutputDevice, Volume, AudioFreq);  
    6 B3 [% m- s2 C  f0 J, k( _
75.         /* I2S data transfer preparation:
    
76.         Prepare the Media to be used for the audio transfer from memory to I2S peripheral */  
    
77.         /* Configure the I2S peripheral */  
    * N) a8 h/ ~5 S/ o, m7 x
78.         I2Sx_Init(AudioFreq);  
    6 y$ L% t3 @' J; N1 u
79.       }  
    $ f' U+ c5 M* K; Q2 g9 i  \+ I
80.     return AUDIO_OK;  
    : z$ \6 y- k0 ~; Q2 |- k
81. }  

复制代码

在BSP_AUDIO_OUT_Init()这个函数内，根据所传入的采样率，程序在预定义的数组内选择出MCU内部时钟树对I2S时钟的一个合理的分频值，并设置进时钟树配置内，然后再对codec进行初始化，最后对I2S外设初始化。

" M5 W5 V' V. l  W这个选择I2S时钟合理分频值的过程是根据STM32F407的参考手册中的建议来做的，如下参考手册中的28.4.4中表126：
0 d, V7 H) e! T+ U7 R8 }' f4 E
" A3 m2 U/ K( Q# O8 V, f# }2 V, Z
在48K采样率下，假设时钟树下的PLLM VCO=1MHz情况下，且MCK使能，为了尽可能输出靠近期望的时钟，此时应该将时钟树内的PLL2SN设为258，且PLL2SR设为3，I2S内部的预分频因子I2SDIV设为3，以及零散因子I2SODD设为1。这个计算公式为:
, U- O' \( R1 U) P0 d9 W' U6 U! N
也就是(1M*258/3)/[(16*2)*((2*3)+1)]=47991.07142857143,差不多48K。

0 T  U; H0 O3 pPLL2SN，与PLL2SR的设置在上述代码中都有所体现，但是，预分频因子I2SDIV和零散因子I2SODD又是在哪里设置的呢？答案是在代码调用HAL_I2S_Init()时，在这个HAL接口内部会根据I2S的Audio Frequency(CubeMx中的I2S的Configuration中配置的参数)，以及I2S的输入时钟频率和MCK是否使能这些前提条件来自动计算出预分频因子I2SDIV和零散因子I2SODD的值，以此来尽可能匹配输出想要的位时钟，也对应着采样率48K。
$ S( {: R# i& S$ y1 P
5 r; w7 }( m7 `, G7 R/ z! y/ I搞懂了这些之后，我们马上将其代码进行对接：
: T" f/ V! k5 H- l- }# J

1. [cpp] view plain copy
   
2. static int8_t AUDIO_Init_FS(uint32_t  AudioFreq, uint32_t Volume, uint32_t options)  
   ) h6 Z% h6 ]4 Q8 P' ~
3. {   
   
4.   /* USER CODE BEGIN 0 */  
   5 o& ^8 |: }0 e! R+ {4 \" h! w# ?
5.   BSP_AUDIO_OUT_Init(OUTPUT_DEVICE_AUTO, Volume, AudioFreq);  
   : V8 x4 A& z/ \' b6 i- `
6.   return (USBD_OK);  
   " l' S' t: X6 v6 l8 L- f
7.   /* USER CODE END 0 */  
   
8. }  

复制代码

接下来下一个需要对接的接口：

1. [cpp] view plain copy
   
2. static int8_t AUDIO_DeInit_FS(uint32_t options)  
   " P8 S4 p( H$ A
3. {  
   3 o8 w; J$ Q' {
4.   /* USER CODE BEGIN 1 */   
   
5.   BSP_AUDIO_OUT_Stop(CODEC_PDWN_SW);  
   
6.   return (USBD_OK);  
   " F. `: {5 |7 h4 l9 A( D8 V
7.   /* USER CODE END 1 */  
   
8. }  
   2 q+ P" V2 _- K  {9 ?# x: N( l
9. 很明显，这个个反初始化的接口，它的具体实现如下：
   
10. 
    
11. [cpp] view plain copy
    
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)  
    ! a1 x8 M: |1 |* |0 {# n
19.   {  
    
20.     return AUDIO_ERROR;  
    7 R# ]$ ]" ]- v7 C  k- Y" d& I
21.   }  
    
22.   else  
    
23.   {  
    ( t6 ?$ k3 m$ B8 r: W4 W* `% X
24.     if(Option == CODEC_PDWN_HW)  
    
25.     {  
    
26.       /* Wait at least 1ms */  
    ; e' u- M: e1 y3 I  W5 l
27.       HAL_Delay(1);  
    ' P6 q3 J5 n' M
28.   
    6 h7 f: q6 D6 ]* w( I( Q& o; Q' Q
29.       /* Reset the pin */  
    
30.       //BSP_IO_WritePin(AUDIO_RESET_PIN, RESET);  
    
31.       HAL_GPIO_WritePin(AUDIO_RESET_GPIO_Port, AUDIO_RESET_Pin, GPIO_PIN_RESET);  
    
32.     }  
    
33.   
    3 k' }$ H6 F+ z% n# T
34.     /* Return AUDIO_OK when all operations are correctly done */  
    
35.     return AUDIO_OK;  
    
36.   }  
    
37. }  

复制代码

先关闭I2S的DMA，在调用Codec的停止接口。
OK，下一个：

1. [cpp] view plain copy
   7 @, J5 v! [- P1 X5 \6 k0 S0 i
2. static int8_t AUDIO_AudioCmd_FS (uint8_t* pbuf, uint32_t size, uint8_t cmd)  
   ! r9 Q, ]3 J8 c9 x0 M/ W
3. {  
   ) j% ]2 K& X# W; y, m5 Y
4.   /* USER CODE BEGIN 2 */  
   
5.   switch(cmd)  
   
6.   {  
   . R: \3 Q% t) }
7.     case AUDIO_CMD_START:  
   2 E9 }  C, z% I6 g5 M
8.         BSP_AUDIO_OUT_Play((uint16_t *)pbuf, size);  
   0 e/ _" j: P5 M3 A; B/ E# t
9.     break;  
   $ d9 P3 p+ o/ L+ d: J) W
10.   
    
11.     case AUDIO_CMD_PLAY:  
    
12.         BSP_AUDIO_OUT_ChangeBuffer((uint16_t *)pbuf, size);  
    
13.     break;  
    6 ~9 m$ A) {$ C+ y' \7 V5 ]
14.   }  
    4 h! x6 y+ m, g. N9 x
15.   return (USBD_OK);  
    3 _& |% w" ], ~6 J) r$ M
16.   /* USER CODE END 2 */  
    . {# o' |. s) \  ~1 I% M( ]
17.    
    
18. }  

复制代码

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

1. [cpp] view plain copy
   5 _0 U0 u. m; X6 ]) T& j
2. uint8_t BSP_AUDIO_OUT_Play(uint16_t* pBuffer, uint32_t Size)  
   , k+ M" L) C6 Q+ S( [' Q8 }1 }1 b
3. {  
   
4.   /* Call the audio Codec Play function */  
   / F) M) G: s( Q( F/ w% X* o- r
5.   if(audio_drv->Play(AUDIO_I2C_ADDRESS, pBuffer, Size) != 0)  
   
6.   {  
   
7.     return AUDIO_ERROR;  
   & p1 A0 f# ?8 w4 H+ F
8.   }  
   * h, c( Z+ `# n/ a" A5 u4 Y
9.   else  
   
10.   {  
    
11.     /* Update the Media layer and enable it for play */  
    " U- B  |3 [3 c2 o
12.     HAL_I2S_Transmit_DMA(&hi2s3, pBuffer, DMA_MAX(Size/AUDIODATA_SIZE));  
    - b+ }. l% }- T5 ]( w) f/ |  @
13.     return AUDIO_OK;  
    . l& P) B/ N9 v
14.   }  
    
15. }  

复制代码

很明显，它是调用Codec驱动处理数据，也就是通过I2S的DMA方式发送给Codec。
% A  k/ N& C. ^* H: V
2 L! u: F9 y$ ^/ p; T0 \然后I2S的DMA会产生传输完成中断和半传输完成中断，在这两个中断处理上，会回调到AUDIO_AudioCmd_FS()接口，并且此时传入的参数变为AUDIO_CMD_PLAY,此时，音频数据的处理函数为:

1. [cpp] view plain copy
   3 h% l8 F: f8 @1 d' x6 k4 k
2. void BSP_AUDIO_OUT_ChangeBuffer(uint16_t *pData, uint16_t Size)  
   
3. {  
   
4.   HAL_I2S_Transmit_DMA(&hi2s3, pData, Size);  
   
5. }  

复制代码

也是通过I2S的DMA将数据传输给外部Codec。

上述过程涉及到另外两个usbd_audio_if接口函数，即I2S的DMA半传输完成和传输完成中断回调,如下所示:

1. [cpp] view plain copy
   
2. void TransferComplete_CallBack_FS(void)  
   
3. {  
   
4.   /* USER CODE BEGIN 7 */   
   
5.   USBD_AUDIO_Sync(&hUsbDeviceFS, AUDIO_OFFSET_FULL);  
   
6.   /* USER CODE END 7 */  
   
7. }  
   
8. void HalfTransfer_CallBack_FS(void)  
   
9. {   
   
10.   /* USER CODE BEGIN 8 */   
    ; k1 S3 _: M. F+ y1 X0 D7 B
11.   USBD_AUDIO_Sync(&hUsbDeviceFS, AUDIO_OFFSET_HALF);  
    " e" h1 S- K' Q$ M7 ~, P4 s' e1 l
12.   /* USER CODE END 8 */  
    
13. }  

复制代码

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

8 d  V: F" _$ Y* d此外，在USB设备端，后续接收到的音频数据会紧接着之前的数据进行存放，这里实现了一个数据环形缓冲区，来实现了USB接收端与I2S输出端数据有效的缓存。
8 o0 C; c+ S+ ~: s
1 I, m& K! x* r接下来看下一个usbd_audio_if接口函数对接：
' D. E0 V7 Z. z' `& k

1. [cpp] view plain copy
   ' f" u: ^  P2 l1 P5 s' ^
2. static int8_t AUDIO_VolumeCtl_FS (uint8_t vol)  
   5 Z# x. B# Q; z8 Y$ s
3. {  
   - ^0 a' Y' H8 o# N2 |+ q8 }
4.   /* USER CODE BEGIN 3 */   
   5 c# j8 Y/ n5 _5 D8 [
5.   BSP_AUDIO_OUT_SetVolume(vol);  
   
6.   return (USBD_OK);  
   
7.   /* USER CODE END 3 */  
   9 S  f# a6 r4 [- K: S. v7 `
8. }  

复制代码

很明显，这个是音量控制接口，也对接下:

1. [cpp] view plain copy
   
2. uint8_t BSP_AUDIO_OUT_SetVolume(uint8_t Volume)  
   
3. {  
   1 h3 M& _1 x3 z" n/ N9 m0 v1 Q
4.   /* Call the codec volume control function with converted volume value */  
   
5.   if(audio_drv->SetVolume(AUDIO_I2C_ADDRESS, Volume) != 0)  
     m# x5 F/ A6 t- X
6.   {  
   
7.     return AUDIO_ERROR;  
   1 V. n" x0 E, i3 N- b9 `, y
8.   }  
   & k& E% X5 z4 x
9.   else  
   
10.   {  
    
11.     /* Return AUDIO_OK when all operations are correctly done */  
    
12.     return AUDIO_OK;  
      o9 @5 p7 j$ V2 u5 {% K
13.   }  
    5 S' L2 D4 p1 y+ _: w, c- A+ k  W
14. }  

复制代码

直接调用Codec启动的相应接口。需要注意地是，实际上，在PC端进行音量的调节，并不会向USB端发送相应的音量调节指令，这里只是象征性的对接下，实际上在USB AUDIO中代码并不会允许到这里，音量的放大和变小直接体现在音频数据本身内。
9 p: Q! H2 W& y: _! ^1 l/ y+ M2 K! `
下一个:
, f  `5 k$ f; M' [& A& d

1. [cpp] view plain copy
   
2. static int8_t AUDIO_MuteCtl_FS (uint8_t cmd)  
   
3. {  
   
4.   /* USER CODE BEGIN 4 */   
   / t: W0 y4 l  j' [5 k7 Q
5.   BSP_AUDIO_OUT_SetMute(cmd);  
   ( D1 C& ]4 ^. Z+ D% e5 `
6.   return (USBD_OK);  
   9 U1 |: h# {5 @$ f
7.   /* USER CODE END 4 */  
   4 J$ V4 C3 r3 G5 X# L# a: ]' F5 ]
8. }  

复制代码

静音控制，其实现为：

1. [cpp] view plain copy
   . e* w9 G; N1 u! r4 [
2. uint8_t BSP_AUDIO_OUT_SetMute(uint32_t Cmd)  
   4 H) k4 M" m4 k3 G- _
3. {  
   ) h; W6 n- Y4 Y: |" P( W  y
4.   /* Call the Codec Mute function */  
   
5.   if(audio_drv->SetMute(AUDIO_I2C_ADDRESS, Cmd) != 0)  
   
6.   {  
   1 [+ Y4 I3 b9 z! U* ]
7.     return AUDIO_ERROR;  
   2 x. N! v4 o! U! U' G* g+ w2 _9 Q
8.   }  
   
9.   else  
   ; W1 u- D8 P1 J8 _7 v' W- M( n( h
10.   {  
      @& ]; d$ C( e' L: c
11.     /* Return AUDIO_OK when all operations are correctly done */  
    + s5 _3 {: Q  I1 k7 T$ v
12.     return AUDIO_OK;  
    
13.   }  
    
14. }  
    ; I( b2 D" P( _: f- H- @

复制代码

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

( G. }5 K% C: B! j" ^OK，就这样，usbd_audio_if模块的接口基本上对接到这样就可以了。
3 C% k* d& Z$ {) b6 D" O- _- z
8 E; ]0 t) Y6 q' v4    测试验证
将代码编译后烧录进STM32F4DISCVOERY板进行验证。
  M* r6 S# X* Q1 j& F+ g
4 {, g# [8 G0 |8 {; F" s最终验证是OK的，可以从耳机上听到PC端播放的音乐。

5    结束语
在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生成的默认的最简单的算法，我们不做深入讨论，只是让大家有这么一个概念即可。

# w8 g# u, U  R  K4 H6 ~4 O
. b* K0 c) V) ^& I" b3 u
* w. v; p; @- }; U6 ]& P, M
: N5 \" w: G# A- O9 L& J% L

楼主问下，你这个会有杂音吗？我这边测试了下，会有杂音的，如果根据接受AUDIO_TOTAL_BUF_SIZE大小去传输，usb中断影响HAL_I2S_Transmit_DMA(&hi2s1, (uint16_t *)pbuf, (size))传输结果，显示为hal_busy,忙等待，传输数据这块你有做特殊处理吗？
" S* t& f, |( ^- vstatic uint8_t  USBD_AUDIO_DataOut (USBD_HandleTypeDef *pdev,
                              uint8_t epnum)
{
  USBD_AUDIO_HandleTypeDef   *haudio;
  haudio = (USBD_AUDIO_HandleTypeDef*) pdev->pClassData;
! u, r, s" F; a' g$ `
$ `7 D$ M6 L6 S5 D/ R8 u  if (epnum == AUDIO_OUT_EP)
4 G! ~3 C1 d: y2 \  {
3 W2 G% M) m( `, t% w    /* Increment the Buffer pointer or roll it back when all buffers are full */
, u. w% X' l" n' J. u9 Y' {5 t
    haudio->wr_ptr += AUDIO_OUT_PACKET;

    if (haudio->wr_ptr == AUDIO_TOTAL_BUF_SIZE)
    {
      /* All buffers are full: roll back */
      haudio->wr_ptr = 0U;
$ P: X9 a0 K( G    ((USBD_AUDIO_ItfTypeDef *)pdev->pUserData)->AudioCmd(&haudio->buffer[0],
                                                 AUDIO_TOTAL_BUF_SIZE / 2U,
+ i( E$ r( |, \% P1 v! p                                                 AUDIO_CMD_PLAY);
, m' I8 L/ a  o% o#if 0
      if(haudio->offset == AUDIO_OFFSET_UNKNOWN)
' k/ \4 K' x8 K0 C      {
3 V8 @2 a& O8 T4 M% y! K) ^        ((USBD_AUDIO_ItfTypeDef *)pdev->pUserData)->AudioCmd(&haudio->buffer[0],
# R$ u% O! L/ D2 g: A" R6 n                                                             AUDIO_TOTAL_BUF_SIZE / 2U,
0 G$ f% Y7 N! s* `" v# a" y5 W# p1 y                                                             AUDIO_CMD_START);
          haudio->offset = AUDIO_OFFSET_NONE;
+ n% I1 X7 y( C  X! z2 `) y      }
! A$ e) O2 C( H3 ]#endif
. P5 Y3 t, e8 N4 m  q/ ]7 s    }

    if(haudio->rd_enable == 0U)
2 B- ~- c9 E; S) C; y) f& e3 A    {
      if (haudio->wr_ptr == (AUDIO_TOTAL_BUF_SIZE / 2U))
      {
: L- ^$ Q. Y$ y0 u# a/ h) q9 n/ V        haudio->rd_enable = 1U;
5 H6 d1 K* m' |" q  d      }
( s4 w1 m' ]; @. r$ L; |4 l    }

. b# [1 @/ Z5 |  ?    /* Prepare Out endpoint to receive next audio packet */
& t8 w1 a9 g  [    USBD_LL_PrepareReceive(pdev, AUDIO_OUT_EP, &haudio->buffer[haudio->wr_ptr],
5 T# ?$ o8 o+ b, O# K' ~                           AUDIO_OUT_PACKET);
  }

楼主还在吗？
# h4 w* d/ Q: J' O6 d我参考了您的这篇文章，在 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" 设备，
5 D/ ~% O! y+ I5 ]但是只要 AUDIO_Init_FS 里面调了 BSP_AUDIO_OUT_Init 就会枚举失败，显示“未知 USB 设备”，跟踪 BSP_AUDIO_OUT_Init 的执行过程没发现问题，
而且这个函数返回值也是OK，但是紧接着 AUDIO_DeInit_FS 就被调了，也跟踪了 USB 中断和 DMA 中断都有，查了好几天查不出原因，时钟配置好像也没问题，楼主您能指点一下吗？多谢！

梦中的飞鸿 发表于 2019-9-11 09:20
这个问题您解决了吗，我这也遇到了这个问题，有个小感叹号，然后提示
1 \  Q6 y& Z1 D  L; e- e
该设备无法启动。 (代码 10)

' _) n% G9 q+ r7 F出现这种情况要保证描述符是不是正确的，如果描述符正确在看看内存是否溢出，如果都正确，那就要一步步找问题了，就是把个单片机外设相关的代码想注释掉，基本上就找到原因了。

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

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

- {# P9 W6 S& z5 Q. E- p7 i希望能有帮助

anny 发表于 2018-5-23 14:45
0 j- V9 W; L% a" g7 l1 r, C非常好的帖子，谢谢分享！！！

希望能有帮助

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

666，好贴，顶起来~

收藏

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

好贴！

楼主，我想问下，stm32 Audio Class的PC端不需要驱动吗？我的提示能够正确识别设备，但是安装驱动失败！
: N* P  R2 X2 k8 w* _. z
% O7 W% K+ E/ K# O! {3 U

delei 发表于 2019-8-12 11:18
+ U) i) P1 ?# s  n* q; I( i: P楼主，我想问下，stm32 Audio Class的PC端不需要驱动吗？我的提示能够正确识别设备，但是安装驱动失败！
: Q8 q' S" L4 K. N: X
) Y* P' y$ I5 J4 a- p! T ...

3 I& w9 L: |0 F7 _2 {7 M这个问题您解决了吗，我这也遇到了这个问题，有个小感叹号，然后提示

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

% f1 j( _0 B2 q# M: _( R" P1 l" p1 ]I/O 请求已取消。

梦中的飞鸿 发表于 2019-9-11 09:20
+ n2 h5 q, l# m% L这个问题您解决了吗，我这也遇到了这个问题，有个小感叹号，然后提示
1 e6 J8 n/ H' [4 F2 F
该设备无法启动。 (代码 10)

. G, p, S' f2 ^0 z8 f经测，不要用最新的库版本，用1.21.0的测试直接生成，正常识别！