5 N8 P% {7 D$ _  y' b
  x% i6 `: t+ [, X8 H- \1 前言
* f5 W/ c( M# h3 J4 H- X- A本文将基于STM32F4 Discovery板,从零开始设计并实现一个USB Audio的例子。
! S) K/ U# n, f
6 i3 S9 Z* I6 ]& s* @7 h) n/ X2 设计构思
% |4 o' t+ m" C- ?  J7 [! m所谓的USB AUDIO就是制作一个盒子，这个盒子可以通过USB连接到PC，PC端将其识别为Audio设备，然后在PC端播放音乐的时候，声音可以通过盒子播放出来。
& {3 m/ x( @" e6 P8 K( c0 R; z
5 q% r" B$ R0 E: ?' b0 P2.1 从原理框图开始
$ c, ?6 v, l9 _  R  Q* U( z, Q' b
+ Z8 u: b7 q- C) x) l6 P如上图所示,我们大概构思一下，为了实现USB AUDIO功能，我们使用一个MCU的USB外设连接PC端，整个流程是这样: PC端播放音乐时，代表音乐的数据流从PC端通过USB传输到MCU端，MCU端然后将其转发给一个外部Codec，最后通过Codec上连接的扬声器或耳机播放音乐。
2 p; m% ?/ {4 Y% @# @0 u4 d2 m
2.2 硬件支撑
这里选择ST官方的STM32F4-DISCOVERY板来实现，之所以选择这块板子，就是因为其上有USB接口和Codec，正好符合我们设计的要求。
3 [" R- s% w8 n  X
) [% D" b7 `% C; `2.2.1 USB接口
如下图为USB接口部分的电路：

8 |6 w  G5 v2 _8 O2 ?  y% M这个一个将USB作为OTG的电路设计，在本设计中，我们只是将USB作为device来使用，因此，上图我们关注下面部分就可以了。在本设计中，我们使用到全速USB，从上图可以看出D+与D-引脚分别为PA12，PA11。

2.2.2 Codec部分
: G* K8 B' O: o. e( ~3 t  Y; {如下图所示:

如上图所示，这里的Codec为具体型号为CS43L22，MCU通过I2C接口(PB9,PB6)连接Codec，作为其控制接口，使用I2S(PC7,PC10,PC12,PA4)作为数据通道，此外，MCU使用PD4这个IO管脚控制Codec的reset。CS43L22的14,15脚连接到外面的耳机插孔，也就是说，我们可以通过插入耳机线的方式来收听PC端播放的声音。

2.3 软件设计
为了简化开发流程，这里使用CubeMx自动生成代码工具来生成初始化代码，首先基于Cube库架构以及USB协议栈的特点，我们得先设计一个合理的软件框架。
8 L( |6 ~! N# l: k8 v
7 _! e, Y5 S4 E( V8 O
# E. D1 |" t- E( b3 [2 g+ ]1 W如上图，蓝色表示的模块为标准模块，不需要我们去修改它，将由CubeMx自动生成，而绿色部分则可能涉及到需要修改，其中BSP部分是需要自己添加的代码，其他的都是由CubeMx生成。
$ Z$ w7 r( z% W3 x! Q
各个模块的工作流程如下设计:

% L  _2 X5 ~  Z6 W: I4 h! `/ a0 L5 m 初始化流程: 由main开始，它首先对将使用到的外设I2C，I2S初始化，这最终将调到HAL MSP底层部分实现对具体IO管脚和外设的初始化。同时main使用usb description的数据通过调用USB栈初始化接口来完成对USB接口的初始化，这一步还涉及到USB的枚举过程。
USB数据传输过程：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组件连接的耳机播放出来。
从以上的音频数据流程来看，最主要的就是usbaudio interface模块，它实现了从USB audio stack到codec驱动的对接。
/ p  {4 `* B9 J
! X& v4 {4 s- t4 C4 g, E接下来，我们来看看软件层面上的实现。

3 软件实现
还是老办法，采用CubeMx这个工具来生成初始化代码，这样可以节省我们花费在基本外设上的调试初始参数时间。
" q6 F! A, {; r+ i1 j! C1 E) |
; b: y- ?& W8 G& L# G4 j( K- k3.1 创建CubeMx工程
由于我们使用到的硬件平台是STM32F4Discovery板，上面搭载的MCU型号是STM32F407VGT6，我们就以此型号创建一个名为Audio_Test的工程。

3 Z- ~( P+ d0 u, q% F3 Y" K8 gpinout:
' b$ X9 ~+ g4 ]9 D) P
外设有用到USB_OTG_FS(PA11,PA12device模式)，I2C1(PB6,PB9)，I2S3(PC12,PA4,PC10,PC7，半双工主模式),此外Codec的reset使用PD4管脚控制，使用外部8M HSE。其pinout如下图所示：


Clock configuration:
( i( G9 m6 K+ Y! n, N
  M+ m. g5 S+ ]* s: Z* U时钟树如上设置，主频使用168M，I2S时钟输出初始化为96M。
$ M3 l+ d; P3 M0 q% y
Configuration:

% g% I) z; Z# k! Y# c! j! O  HAL层：
Usb_FS：使用默认参数。

8 t8 Z0 ?. N' f; }, r  C7 b( r0 ?. CI2C：100K速率，7位地址宽度，使用默认参数。
% o% e/ I0 L( b1 g
) ~9 n- L! }$ ?I2S：主发模式，标准16位宽，默认音频为48K，如下图：
# y2 V7 q- o( K
; Q% p1 Y2 u/ {, ^' Q9 }并为I2S发送添加DMA，半字位宽:
6 c3 e' W. u, {: F) d, J4 H4 u
* z* N& s) ^8 y/ h* E
   MiddleWares:

USB选择Audiodevice class,其配置参数如下：

- L) |3 O" I( w2 L
! X& w! w% q6 E2 V这里都是默认参数。

在描述符参数内得为usb audio class修改两个参数：

PID得修改为0x5730(否则windows驱动会加载出错)
序列号：序列号字符串内不能包含字母，只能是数据(否则windowsaudio驱动在枚举后也不会将音频数据传输下来)。
最后修改工程设置，将堆大小设为4K，栈大小设为1K，如下图：
. R+ m& W/ e( D7 V! S" U1 e
& ?( R$ d% d! L6 A$ u如此就可以生成工程了，我们生成IAR工程。

3.2 生成的IAR工程介绍

& ?5 Z0 @# l) k9 _- o/ q如上图所示，生成的IAR工程，主要有User,Drivers,Middleware3个目录。

User目录下为用户源码文件，用户的主要修改也将集中在此目录下，在这里，我们的主要工作是集中在usbd_audio_if.c文件，它对应着之前软件框图中的usbaudio interface模块，主要是实现USB audio协议栈与Codec的对接。其他源文件都保持不变就可以了。
Middlewares目录对应着usb audio stack模块，它由CubeMx自动生成，保持原样就可以，不需要任何修改。
9 F8 R. N6 w! Y: ]Drivers目录对应着HAL层，它包含CMSIS，HAL驱动。
8 e4 w. l$ l: u6 W6 ~
# }0 ?# `4 o6 z2 I. z3.3 开发
3.3.1 初次编译测试
( l0 i9 v  H" w% `- S" l首先我们不做任何修改，先编译一下工程，发现能顺利编译通过，并烧录进STM32F4DISCOVERY板，运行后通过USB连接上电脑，发现在设备管理器中能正常识别到这个USB AUDIO设备，如下图所示：
8 g6 o5 \, o  R, v0 i
这说明，USB与PC端的连接是OK的，但不知道具体有没有数据。我们使用USB分析仪TOTAL PHASE USB480这个设备对USB总线进行数据监控，能够正常采集USB枚举过程和播放音乐的通信数据，如下图所示：
9 z& r+ G' |" n: s0 d
这表明，到目前为止，从PC端到USB端都是能正常工作的，从PC端发送过来的音频数据已经到达usb audio interface模块，目前只不过还没有对这些数据进行处理，显然，接下来的工作，我们就需要将这些音频数据通过codec驱动发送出去，最终到达外部组件CS32L22.
, _- k9 L' Z+ K, K7 V( E0 T+ e
3.3.2 添加codec驱动和audio bsp模块
, `. P4 G" t  x' Q我们已经知道，我们需要为audio添加BSP模块，在这里，我们将BSP归属于drivers类，因此，在drivers目录下添加BSP目录，通过之前的软件架构图我们可以知道，BSP包含Codec驱动（CS43L22）和Audio bsp模块，因此，我们在BSP目录下有添加了Codec的驱动源码cs43l22.c与bsp_audio.c,如下图所示：
% r6 R& L  E! i: w/ J5 Z& N
) w" p% F" D7 u/ K* ?其中cs43l22.c为codec cs32l22的驱动，我们可以从ST的组件驱动中找到它，并copy过来直接使用，不需要修改任何代码。而bsp_audio.c是我们自己写的，它的任务是为usbd_audio_if.c与cs43l22.c提供服务，让这两个模块胜利对接。

3.3.2.1 Codec与HAL的对接
首先我们来看Codec驱动文件cs43l22.c源文件，这个文件需要使用这个外部需要提供的接口：
, f1 D* t6 b# U' z! a: I4 ?) j5 S* x- R, C

1. [cpp] view plain copy
   7 k# k" v: a/ y
2. AUDIO_IO_Init()  
   4 C  w( s* q. Y* V4 l, Z; }5 u, a0 V
3. AUDIO_IO_DeInit()  
   4 h( K6 Q) o- D1 w, g8 {
4. AUDIO_IO_Write()  
   
5. AUDIO_IO_Read()  

复制代码

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

1. [cpp] view plain copy
   , k) ^9 x/ B( R+ j/ h$ x
2. //---------------------for c43l22 port--------------------------//  
   & c6 q/ z0 v& [7 b. S9 ~1 @* n
3. static void I2Cx_Error(uint8_t Addr)  
   
4. {  
   
5.   /* De-initialize the IOE comunication BUS */  
   
6.   HAL_I2C_DeInit(&hi2c1);  
   $ K# |; B+ e% w* q* D' Q9 Z, S
7.   
   * o& r3 W. d! j1 i: }
8.   /* Re-Initiaize the IOE comunication BUS */  
   
9.   //I2Cx_Init();  
   3 F8 y& L; I2 U3 J! g/ O
10.   //MX_I2C1_Init();  
    
11. }  
    1 r( L8 B6 O! J' m) F) ~
12. static void CODEC_Reset(void)  
    + c' e; y1 i6 t! j
13. {  
    
14.     HAL_GPIO_WritePin(AUDIO_RESET_GPIO_Port, AUDIO_RESET_Pin, GPIO_PIN_RESET);  
    : U% a7 {4 x; o: c- L9 M
15.     HAL_Delay(5);  
    , H4 p0 t" `. h3 T! g2 O0 B
16.     HAL_GPIO_WritePin(AUDIO_RESET_GPIO_Port, AUDIO_RESET_Pin, GPIO_PIN_SET);  
    6 z* y1 L7 z4 K* l8 c6 E' @- i
17.     HAL_Delay(5);  
    
18. }  
    ; s% n3 k4 ^1 D5 ?% _' O
19. void AUDIO_IO_Init(void)  
    , z0 N7 F  `- o2 y
20. {  
    # i0 u  w  h% n8 q+ J
21.   //I2Cx_Init();  
    
22. }  
    " n4 K" p  p3 W5 ^
23. void AUDIO_IO_DeInit(void)  
    
24. {  
    6 L$ }/ M, {- i$ u- s5 J5 N6 Y
25.   
    ) k' P0 [3 T  u3 n# m3 h
26. }  
    
27. /**
    4 [, a, E2 p" u' ^& b1 z
28.   * @brief  Writes a single data.
    8 v$ n& N1 K: L2 D9 j$ ~( [$ U
29.   * @param  Addr: I2C address
    / J$ {7 U8 N) N  o$ D0 w: f
30.   * @param  Reg: Reg address
    " \3 ]4 R9 F. R& ]) J9 ?7 ~! F
31.   * @param  Value: Data to be written
    ! m/ ]) A2 U" Q5 Q5 D% u3 O
32.   */  
    
33. static void I2Cx_Write(uint8_t Addr, uint8_t Reg, uint8_t Value)  
    
34. {  
    + j1 u$ N7 ~# m2 Q" Y1 r2 Y) I' y* x
35.   HAL_StatusTypeDef status = HAL_OK;  
    
36.   
    
37.   status = HAL_I2C_Mem_Write(&hi2c1, Addr, (uint16_t)Reg, I2C_MEMADD_SIZE_8BIT, &Value, 1, I2C_TIMEOUT);  
    
38.   
    " Y5 q) R: k  l& e
39.   /* Check the communication status */  
    
40.   if(status != HAL_OK)  
    
41.   {  
    
42.     /* I2C error occured */  
    + [6 d" G# L7 G0 y
43.     I2Cx_Error(Addr);  
    
44.   }  
    % {5 g& C" w8 @6 ~4 `) `. T
45. }  
    
46. void AUDIO_IO_Write(uint8_t Addr, uint8_t Reg, uint8_t Value)  
    
47. {  
    
48.   I2Cx_Write(Addr, Reg, Value);  
    / W  e7 r+ Z+ v! ]
49. }  
    1 {+ L; }9 X( K" D9 z$ @
50.   
    0 f! o8 u" v$ l# c
51. /**
    ' t4 g; W- S0 b5 g
52.   * @brief  Reads a single data.
    
53.   * @param  Addr: I2C address
    1 X, o) g8 K: n  E+ W& b$ d$ f# J( e
54.   * @param  Reg: Reg address
    1 p: ]7 t3 H2 {
55.   * @retval Data to be read
    
56.   */  
    8 ~8 B8 D/ `1 T) r6 s9 d: b. ]% j. b
57. static uint8_t I2Cx_Read(uint8_t Addr, uint8_t Reg)  
    & c0 H- c/ @* h' l6 @7 D
58. {  
    
59.   HAL_StatusTypeDef status = HAL_OK;  
    - N/ M2 K) `. B, I
60.   uint8_t Value = 0;  
    6 t8 w9 [9 c, A7 G- Y( x! N
61.   
    7 Q2 M. \4 x; ~  w' N" m# w
62.   status = HAL_I2C_Mem_Read(&hi2c1, Addr, Reg, I2C_MEMADD_SIZE_8BIT, &Value, 1, I2C_TIMEOUT);  
    
63.   
    
64.   /* Check the communication status */  
    # ^/ G) Z6 I: t# C9 P2 S; v
65.   if(status != HAL_OK)  
    
66.   {  
    
67.     /* Execute user timeout callback */  
    
68.     I2Cx_Error(Addr);  
    
69.   }  
    1 b/ E# N9 b2 u9 e
70.   
    ( ]" z+ _* m7 f( m
71.   return Value;  
    
72. }  
    
73. uint8_t AUDIO_IO_Read(uint8_t Addr, uint8_t Reg)  
    
74. {  
    5 K2 k5 J0 ~+ P2 K' @8 C. I
75.   return I2Cx_Read(Addr, Reg);  
    * z6 I) h3 k9 Y; f' j; Z" U  J  L- G8 P
76. }  

复制代码

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

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

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

按照这一清晰思路，我们首先找到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)  
   $ [  S! a2 o7 \1 b
3. {   
   
4.   /* USER CODE BEGIN 0 */  
   
5.   return (USBD_OK);  
   " c/ j0 Q: M" j' \
6.   /* USER CODE END 0 */  
   $ j9 U* M% z( p8 N* S! u
7. }  

复制代码

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

1. [cpp] view plain copy
   
2. static void I2Sx_Init(uint32_t AudioFreq)  
   
3. {  
   
4.   /* Initialize the haudio_i2s Instance parameter */  
   - ]7 _# C+ c# j# x& f
5.   hi2s3.Instance = SPI3;  
   4 b2 G, v2 u' L% U; e6 c" m0 K& n
6.   
   # v( Z' j" `0 p) T4 R7 Z# U
7. /* Disable I2S block */  
   
8.   __HAL_I2S_DISABLE(&hi2s3);  
   
9.   
   9 X% C9 y2 F% {
10.   hi2s3.Init.Mode = I2S_MODE_MASTER_TX;  
    + q- q; e( f1 l4 E7 G  a
11.   hi2s3.Init.Standard = I2S_STANDARD;  
    ; x$ z% X) A: R% W8 g, p7 M
12.   hi2s3.Init.DataFormat = I2S_DATAFORMAT_16B;  
    7 ]/ j( x: |. q6 W/ t
13.   hi2s3.Init.AudioFreq = AudioFreq;  
    
14.   hi2s3.Init.CPOL = I2S_CPOL_LOW;  
    9 b/ ~3 }5 L7 e$ b" k, k
15.   hi2s3.Init.MCLKOutput = I2S_MCLKOUTPUT_ENABLE;  
    
16.   
    
17.   if(HAL_I2S_GetState(&hi2s3) == HAL_I2S_STATE_RESET)  
    : m! ]3 z# \2 a* U
18.   {  
    
19.     HAL_I2S_MspInit(&hi2s3);  
    * R( S- T: Q# A
20.   }  
    
21.   /* Init the I2S */  
    
22.   HAL_I2S_Init(&hi2s3);  
    1 z" A) \; p" m& q: F9 W
23. }  
    1 ^" Z# p" \' Q) y
24. const uint32_t I2SFreq[8] = {8000, 11025, 16000, 22050, 32000, 44100, 48000, 96000};  
    , U) F# \* I6 K$ z& r& G4 c; A
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;  
    + y. d; j5 |; L+ o
30.     uint8_t ret = AUDIO_ERROR;  
    3 u* `/ b4 {& V$ E1 I- v
31.     uint8_t index = 0, freqindex = 0xFF;  
    
32.     RCC_PeriphCLKInitTypeDef RCC_ExCLKInitStruct;  
    $ ^0 Z, q$ G/ F* ^" ^, \
33.   
    
34.     //get the according P,N value and set into config,this is for audio clock provide  
    * |. U2 N* Q- _
35.     for(index = 0; index < 8; index++)  
    
36.     {  
    ! V; X2 f! s/ ?! a9 X( H) z6 e; M
37.         if(I2SFreq[index] == AudioFreq)  
    
38.         {  
    
39.             freqindex = index;  
    
40.         }  
    2 G5 a  E4 L3 F; ~; u7 p- U: W
41.     }  
    
42.     HAL_RCCEx_GetPeriphCLKConfig(&RCC_ExCLKInitStruct);  
    $ h. p/ ?7 \- m! @$ h0 H' B
43.     if(freqindex != 0xFF)  
    
44.     {  
    
45.         RCC_ExCLKInitStruct.PeriphClockSelection = RCC_PERIPHCLK_I2S;  
    
46.             RCC_ExCLKInitStruct.PLLI2S.PLLI2SN = I2SPLLN[freqindex];  
    
47.             RCC_ExCLKInitStruct.PLLI2S.PLLI2SR = I2SPLLR[freqindex];  
    
48.             HAL_RCCEx_PeriphCLKConfig(&RCC_ExCLKInitStruct);  
    
49.     }  
      s& [" I$ ?" _$ E# C3 w
50.     else  
    
51.     {  
    : K3 }. n) o# S* H$ N6 F/ u
52.         RCC_ExCLKInitStruct.PeriphClockSelection = RCC_PERIPHCLK_I2S;  
    0 p. E5 `) G1 ]+ n- G
53.             RCC_ExCLKInitStruct.PLLI2S.PLLI2SN = 258;  
    0 f* B& P# i' F( G8 [% R+ O
54.             RCC_ExCLKInitStruct.PLLI2S.PLLI2SR = 3;  
    
55.             HAL_RCCEx_PeriphCLKConfig(&RCC_ExCLKInitStruct);  
    # A, b5 b1 [% [, Q9 K! _  [
56.     }  
    ( J8 R4 Y' ^  E3 V
57.   
    
58.     //reset the Codec register  
    
59.     CODEC_Reset();  
    
60.     deviceid = cs43l22_drv.ReadID(AUDIO_I2C_ADDRESS);  
    / i% w* k4 N5 n) C
61.     if((deviceid & CS43L22_ID_MASK) == CS43L22_ID)  
    
62.       {  
    
63.         /* Initialize the audio driver structure */  
    
64.         audio_drv = &cs43l22_drv;  
    
65.         ret = AUDIO_OK;  
    
66.       }  
    - Q& j& B+ ?0 [4 G9 z  z  P
67.       else  
    
68.       {  
    
69.         ret = AUDIO_ERROR;  
    + E+ I& {; b4 D
70.       }  
    2 ]2 B! G3 j! I0 K7 V  }  r# o
71.   
    # u# k' S- n+ U
72.      if(ret == AUDIO_OK)  
    + W. O: b0 A/ i2 W3 X
73.       {  
    
74.         audio_drv->Init(AUDIO_I2C_ADDRESS, OutputDevice, Volume, AudioFreq);  
    ( m* ~8 X0 W7 @- X: {- F: k+ |9 p
75.         /* I2S data transfer preparation:
    + g+ A# r9 q8 z
76.         Prepare the Media to be used for the audio transfer from memory to I2S peripheral */  
    . S9 U. ?% Q. @+ C; x1 I
77.         /* Configure the I2S peripheral */  
    
78.         I2Sx_Init(AudioFreq);  
    9 c/ p% I  E* q( F" ]$ S! D
79.       }  
    + ~3 B& G! `8 _! J! n: w
80.     return AUDIO_OK;  
    
81. }  

复制代码

在BSP_AUDIO_OUT_Init()这个函数内，根据所传入的采样率，程序在预定义的数组内选择出MCU内部时钟树对I2S时钟的一个合理的分频值，并设置进时钟树配置内，然后再对codec进行初始化，最后对I2S外设初始化。
+ N( V" b& K3 X" n& u
这个选择I2S时钟合理分频值的过程是根据STM32F407的参考手册中的建议来做的，如下参考手册中的28.4.4中表126：
) T! J+ w: m2 M3 F5 h/ E

在48K采样率下，假设时钟树下的PLLM VCO=1MHz情况下，且MCK使能，为了尽可能输出靠近期望的时钟，此时应该将时钟树内的PLL2SN设为258，且PLL2SR设为3，I2S内部的预分频因子I2SDIV设为3，以及零散因子I2SODD设为1。这个计算公式为:

( {  C6 P# S! d也就是(1M*258/3)/[(16*2)*((2*3)+1)]=47991.07142857143,差不多48K。

  }# g9 Y' ?' N" \/ ^$ o6 Z' a$ h( V" GPLL2SN，与PLL2SR的设置在上述代码中都有所体现，但是，预分频因子I2SDIV和零散因子I2SODD又是在哪里设置的呢？答案是在代码调用HAL_I2S_Init()时，在这个HAL接口内部会根据I2S的Audio Frequency(CubeMx中的I2S的Configuration中配置的参数)，以及I2S的输入时钟频率和MCK是否使能这些前提条件来自动计算出预分频因子I2SDIV和零散因子I2SODD的值，以此来尽可能匹配输出想要的位时钟，也对应着采样率48K。
& l/ W3 _4 q- s2 O2 W0 k
搞懂了这些之后，我们马上将其代码进行对接：

1. [cpp] view plain copy
   
2. static int8_t AUDIO_Init_FS(uint32_t  AudioFreq, uint32_t Volume, uint32_t options)  
   
3. {   
   / m: ]$ ~" e% ^4 H
4.   /* USER CODE BEGIN 0 */  
   
5.   BSP_AUDIO_OUT_Init(OUTPUT_DEVICE_AUTO, Volume, AudioFreq);  
   6 {8 q& D% Q2 \7 `+ c( G1 ?, E
6.   return (USBD_OK);  
     g9 n# Z5 r- L5 w6 Q
7.   /* USER CODE END 0 */  
   
8. }  

复制代码

接下来下一个需要对接的接口：
- x( M& D  U5 `% y& w( W2 C

1. [cpp] view plain copy
   
2. static int8_t AUDIO_DeInit_FS(uint32_t options)  
   
3. {  
   
4.   /* USER CODE BEGIN 1 */   
   
5.   BSP_AUDIO_OUT_Stop(CODEC_PDWN_SW);  
   3 p0 J7 I& N3 i* j, ^
6.   return (USBD_OK);  
   
7.   /* USER CODE END 1 */  
   
8. }  
   + |6 m8 m  m1 Z+ T; F+ }5 v
9. 很明显，这个个反初始化的接口，它的具体实现如下：
   % z4 |" i; A' T  E( O
10. 
    
11. [cpp] view plain copy
    1 y7 G7 B. `; ?" E
12. uint8_t BSP_AUDIO_OUT_Stop(uint32_t Option)  
    , ~" @# a) V$ s, o2 Y3 Q
13. {  
    2 O; Q# b5 z2 F- _& l
14.   /* Call the Media layer stop function */  
    
15.   HAL_I2S_DMAStop(&hi2s3);  
    - |/ E; v6 m; Z) W/ a+ s/ P
16.   
    
17.   /* Call Audio Codec Stop function */  
    ! h9 T3 u8 x  c  d1 I/ E
18.   if(audio_drv->Stop(AUDIO_I2C_ADDRESS, Option) != 0)  
    
19.   {  
    4 ?- Q: W4 b  u* F  E0 \
20.     return AUDIO_ERROR;  
    
21.   }  
    
22.   else  
    
23.   {  
    : e+ @4 W% k7 R% K9 \& G  m1 w6 t
24.     if(Option == CODEC_PDWN_HW)  
    
25.     {  
    
26.       /* Wait at least 1ms */  
    
27.       HAL_Delay(1);  
    0 }& U4 ]. I, \0 _0 g
28.   
    8 e, ]" n9 R; h& C
29.       /* Reset the pin */  
    / B& v3 U, T4 y5 w
30.       //BSP_IO_WritePin(AUDIO_RESET_PIN, RESET);  
    - e% L4 m& K% ]* q; L, D( r8 u
31.       HAL_GPIO_WritePin(AUDIO_RESET_GPIO_Port, AUDIO_RESET_Pin, GPIO_PIN_RESET);  
    
32.     }  
    
33.   
    2 n8 h7 e2 X# f) r/ P! ?1 ]
34.     /* Return AUDIO_OK when all operations are correctly done */  
    . ?$ p0 b& u9 _
35.     return AUDIO_OK;  
    / S4 Q6 r) S( \, g& _6 x$ H
36.   }  
    
37. }  

复制代码

先关闭I2S的DMA，在调用Codec的停止接口。
" G1 d# Q1 I4 `$ N# m6 b& O$ }OK，下一个：

1. [cpp] view plain copy
   6 I2 I/ s2 Z' t, Y
2. static int8_t AUDIO_AudioCmd_FS (uint8_t* pbuf, uint32_t size, uint8_t cmd)  
     V5 {  X1 f; x9 v) a) G
3. {  
   / y; T4 ~# O6 W$ u% ]
4.   /* USER CODE BEGIN 2 */  
     Z2 X5 j" `3 e! I; {7 o
5.   switch(cmd)  
   2 N* B+ B, Y  D) j3 l+ r
6.   {  
   
7.     case AUDIO_CMD_START:  
   + g, l2 A2 S+ }2 T( {' l
8.         BSP_AUDIO_OUT_Play((uint16_t *)pbuf, size);  
   5 J( P3 a* @) t0 ~" K7 f' ^9 q+ a
9.     break;  
   
10.   
    - X; D( Z8 s/ L8 V8 C1 @6 {: `
11.     case AUDIO_CMD_PLAY:  
    
12.         BSP_AUDIO_OUT_ChangeBuffer((uint16_t *)pbuf, size);  
    
13.     break;  
    ! e' A, w* R( H4 G" \4 v. P
14.   }  
    
15.   return (USBD_OK);  
    * E  J* o  [2 z) p, ^
16.   /* USER CODE END 2 */  
    
17.    
    9 r4 ~+ z! n) J9 U
18. }  

复制代码

第一次USB audio stack接收到USB OUT数据时会回调这个接口并传入AUDIO_CMD_START参数，这里的处理代码是：
3 ]0 o( E% |5 G, L2 x; u" H

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 */  
   8 Z3 c" F: g: X& u2 z- l
5.   if(audio_drv->Play(AUDIO_I2C_ADDRESS, pBuffer, Size) != 0)  
   
6.   {  
   
7.     return AUDIO_ERROR;  
   0 _+ z  V/ Q% E7 H; |
8.   }  
   " o6 g3 w; h" V: n
9.   else  
   
10.   {  
    3 d0 b6 K2 i' S/ f
11.     /* Update the Media layer and enable it for play */  
    : K0 i3 Z; _! |5 ~: f. I
12.     HAL_I2S_Transmit_DMA(&hi2s3, pBuffer, DMA_MAX(Size/AUDIODATA_SIZE));  
    3 M$ S% c, y# L4 [5 H1 h9 Y  k' ^
13.     return AUDIO_OK;  
    
14.   }  
    . m$ u/ D5 [3 e; h- G; ?+ `* n
15. }  

复制代码

很明显，它是调用Codec驱动处理数据，也就是通过I2S的DMA方式发送给Codec。
5 w/ q. s1 c7 H8 T. ^7 c
( n0 l9 p8 ~  P6 u: R然后I2S的DMA会产生传输完成中断和半传输完成中断，在这两个中断处理上，会回调到AUDIO_AudioCmd_FS()接口，并且此时传入的参数变为AUDIO_CMD_PLAY,此时，音频数据的处理函数为:
+ ?5 C7 @% ?' K+ f  V

1. [cpp] view plain copy
   
2. void BSP_AUDIO_OUT_ChangeBuffer(uint16_t *pData, uint16_t Size)  
   
3. {  
   " }! r+ ^. J# \
4.   HAL_I2S_Transmit_DMA(&hi2s3, pData, Size);  
   
5. }  

复制代码

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

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

1. [cpp] view plain copy
   ! @! v1 j- e2 e/ l5 w2 G' a
2. void TransferComplete_CallBack_FS(void)  
   
3. {  
   3 i2 K  C8 G7 c' Y! j3 k
4.   /* USER CODE BEGIN 7 */   
   / k9 A3 r  a+ K( l! `1 ?8 \: v% H! y) G
5.   USBD_AUDIO_Sync(&hUsbDeviceFS, AUDIO_OFFSET_FULL);  
   + {% h) ]  I2 ?& Y3 u# D' v
6.   /* USER CODE END 7 */  
   . G, n9 i! R3 _9 ]% U/ h8 R' ^
7. }  
   , _+ J4 j4 X- |
8. void HalfTransfer_CallBack_FS(void)  
   9 g( Z& N$ Q$ h1 i6 Z; ]0 L- i
9. {   
   2 c. b" O7 o  I! v% }1 H
10.   /* USER CODE BEGIN 8 */   
    8 s; d) [2 W' W, w* M
11.   USBD_AUDIO_Sync(&hUsbDeviceFS, AUDIO_OFFSET_HALF);  
    ; j: n( P/ d* P+ U* G
12.   /* USER CODE END 8 */  
    
13. }  

复制代码

此代码为CubeMx自动生成，且在自动生成的代码中就已经调用了usb audio class函数USBD_AUDIO_Sync()，在这里，对于这个，我们是不需要添加任何额外代码的。之前我们说过，在USBD_AUDIO_Sync()函数内部，会实现对AUDIO_AudioCmd_FS()的回调，目的是，需要及时将数据缓冲中另一半准备好的数据也通过I2S的DMA传输给外部Codec，这个不间断的传输，才能实现音频播放的连贯性。
3 H2 H/ V. ?2 f8 R) c) h
此外，在USB设备端，后续接收到的音频数据会紧接着之前的数据进行存放，这里实现了一个数据环形缓冲区，来实现了USB接收端与I2S输出端数据有效的缓存。

接下来看下一个usbd_audio_if接口函数对接：

1. [cpp] view plain copy
   
2. static int8_t AUDIO_VolumeCtl_FS (uint8_t vol)  
   1 I0 h" M; Y  X9 R
3. {  
   / j$ t7 a, K0 @8 O
4.   /* USER CODE BEGIN 3 */   
   6 Y" u4 J8 j/ L6 o+ T
5.   BSP_AUDIO_OUT_SetVolume(vol);  
   
6.   return (USBD_OK);  
   
7.   /* USER CODE END 3 */  
   
8. }  

复制代码

很明显，这个是音量控制接口，也对接下:
8 Z! }0 I  ]$ G

1. [cpp] view plain copy
   
2. uint8_t BSP_AUDIO_OUT_SetVolume(uint8_t Volume)  
   ) H4 h2 j; J/ b! @( K" D% G/ [
3. {  
   & N& r' b% @1 @) ]2 C2 ^# D% k8 u
4.   /* Call the codec volume control function with converted volume value */  
   
5.   if(audio_drv->SetVolume(AUDIO_I2C_ADDRESS, Volume) != 0)  
   
6.   {  
   
7.     return AUDIO_ERROR;  
   
8.   }  
   , o( ?6 c" F' P- \' B- U
9.   else  
   8 ]1 w" J$ l! w3 k! J. p
10.   {  
    
11.     /* Return AUDIO_OK when all operations are correctly done */  
    
12.     return AUDIO_OK;  
    
13.   }  
    
14. }  

复制代码

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

下一个:
+ _( ?6 ?, ?* x  K

1. [cpp] view plain copy
   ! d3 t/ U+ |" b; A1 M  w
2. static int8_t AUDIO_MuteCtl_FS (uint8_t cmd)  
   
3. {  
   
4.   /* USER CODE BEGIN 4 */   
   / P; }5 y0 E7 g- Z
5.   BSP_AUDIO_OUT_SetMute(cmd);  
   / O3 H% ^; d% v( o5 p* @
6.   return (USBD_OK);  
   
7.   /* USER CODE END 4 */  
   
8. }  

复制代码

静音控制，其实现为：

1. [cpp] view plain copy
   & J2 v# E! S- p: D0 l
2. uint8_t BSP_AUDIO_OUT_SetMute(uint32_t Cmd)  
   
3. {  
   
4.   /* Call the Codec Mute function */  
   
5.   if(audio_drv->SetMute(AUDIO_I2C_ADDRESS, Cmd) != 0)  
   
6.   {  
   . q& l) d/ ]* x3 [( y
7.     return AUDIO_ERROR;  
   
8.   }  
   
9.   else  
   ' i4 g; @& `9 l6 r2 J5 z9 Y, j
10.   {  
    % ?2 ], |7 \4 _2 i* t) R
11.     /* Return AUDIO_OK when all operations are correctly done */  
    
12.     return AUDIO_OK;  
    1 d' }; A" a  G& ?1 L3 t8 i
13.   }  
    
14. }  
    , h9 W5 [$ M1 z" N

复制代码

很简单，直接调用codec驱动的静音接口。静音接口与音量控制不同，在PC端进行静音操作会发送相应的mute指令，进而运行到这里。
5 e9 W# |! O1 K# _0 j  _
OK，就这样，usbd_audio_if模块的接口基本上对接到这样就可以了。

9 U# k6 ]0 q2 G5 `4    测试验证
将代码编译后烧录进STM32F4DISCVOERY板进行验证。

最终验证是OK的，可以从耳机上听到PC端播放的音乐。
3 U% E' c$ d) Y/ n7 u: S' i
% [% z2 Y( `$ w) O1 X5    结束语
在CubeMx上对中间件USB配置时，将USB audio class的音频采样率设置为48K,那个这个参数会再USB枚举期间会传递给windows的audio驱动，在枚举通过后，后续通过USB传输的音频数据都将是固定以48K采样率来的，也就是192bytes/ms，也就是说，不管PC端播放什么音乐，windows的audio驱动都会固定以48K采样率向USB端口进行传输。这种特性是由windows的audio驱动决定的。

; }+ ^  z$ H7 RI2S外设向codec传输的时钟是可以改变的，在本应用中是用不着改变，这个是因为USB端固定以48K采样率接收数据，那么I2S也可以固定以48K采样率所对应的速度向Codec传输速度，这个特点，正式因为USB audio的固定传输特性所决定的。若换成播放本地U盘音频文件或连接iPhone并播放iPhone的音乐时，则I2S外设的时钟是根据每次播放的具体音乐所对应的采样率来配置I2S的时钟的，这种机制稍微有所不同，这里只需注意下，理解了就可以了。
4 ^+ t/ X& Q' S. U4 T& G" \
! v- E+ p, k& Y" B8 ]在本例中，从I2S传输数据的速率是48K的采样率，但实际精度却是47991.07142857143。这个与标准的48K还是有所偏差的，实际上，无论USB端和I2S端的传输速度在理论上有多匹配，在实际上，多少都会存在些偏差，这也就意味着，在USB与I2S这两个”入口”与”出口”之间的缓存，在随着时间流逝，如不进行任何处理，这个缓存理论上一定会爆掉或掏空。那么这里就需要针对这个缓存这种现象的一种处理，或者叫做算法，算法的好坏在一定程度上决定了音质的好坏。而本例中，我们使用的是CubeMx生成的默认的最简单的算法，我们不做深入讨论，只是让大家有这么一个概念即可。

3 K# [, `) N; K
" b! r* q, L: K) |7 b, x! \9 u

楼主问下，你这个会有杂音吗？我这边测试了下，会有杂音的，如果根据接受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,
7 U6 \5 G( {: o2 D3 M0 q" n- Z                              uint8_t epnum)
6 x; d2 A/ g/ }( a7 f4 c{
  USBD_AUDIO_HandleTypeDef   *haudio;
2 ~* l: A: Q* i2 O  haudio = (USBD_AUDIO_HandleTypeDef*) pdev->pClassData;
- h: `$ ~( t5 h
  if (epnum == AUDIO_OUT_EP)
5 T1 a  C: k6 @3 \  {
    /* Increment the Buffer pointer or roll it back when all buffers are full */
0 j0 V0 j3 ?7 e; h! V$ v* R
1 M6 V. b. s. C4 x    haudio->wr_ptr += AUDIO_OUT_PACKET;
8 l1 `, A: T3 }/ v5 C( q
0 G$ b% I+ v" `, [    if (haudio->wr_ptr == AUDIO_TOTAL_BUF_SIZE)
    {
      /* All buffers are full: roll back */
      haudio->wr_ptr = 0U;
$ P0 l) `! @* X* s1 Z- P: v9 ]* |* T    ((USBD_AUDIO_ItfTypeDef *)pdev->pUserData)->AudioCmd(&haudio->buffer[0],
                                                 AUDIO_TOTAL_BUF_SIZE / 2U,
                                                 AUDIO_CMD_PLAY);
#if 0
      if(haudio->offset == AUDIO_OFFSET_UNKNOWN)
6 H6 i- @: C. e+ @  r      {
        ((USBD_AUDIO_ItfTypeDef *)pdev->pUserData)->AudioCmd(&haudio->buffer[0],
                                                             AUDIO_TOTAL_BUF_SIZE / 2U,
                                                             AUDIO_CMD_START);
) W! G6 R  V. S          haudio->offset = AUDIO_OFFSET_NONE;
      }
4 B/ b6 |6 `" d; D% o* v#endif
" _" a* K/ ]! p2 k& V    }
0 u3 s) ~; _; J" k/ J
    if(haudio->rd_enable == 0U)
! o8 i) l. \3 H% k6 w- T    {
      if (haudio->wr_ptr == (AUDIO_TOTAL_BUF_SIZE / 2U))
      {
/ p/ k  F: S3 {* ?$ r7 s0 f        haudio->rd_enable = 1U;
      }
    }
' k6 v5 G2 H% G7 ~
    /* Prepare Out endpoint to receive next audio packet */
3 ?* P! v: \4 U: k8 u5 w& O    USBD_LL_PrepareReceive(pdev, AUDIO_OUT_EP, &haudio->buffer[haudio->wr_ptr],
; h2 U! C. ]# \' N5 p                           AUDIO_OUT_PACKET);
1 h1 s( V2 O& ^7 P# d  }

楼主还在吗？
; y/ u. N* z5 e我参考了您的这篇文章，在 STM32F413 discovery 板子上试验 USB Audio，
1 M* w6 R3 h  ~我先用 STM32CubeMX 5.2.1 生成代码框架，然后再把 STM32CubeF4 V1.24.1 里面的 stm32f413h_discovery.c, stm32f413h_discovery_audio.c, wm8994.c 这几个源文件添加到工程里，用的 toolchain 是 IAR 8.30。
& {+ ]( V; \. W0 l4 T  g现在的问题是，如果在 usbd_audio_if.c 里面函数 AUDIO_Init_FS 里面什么都不调那么能成功地枚举出 "STM32 Audio Class" 设备，
, f5 s' z* w) F$ f8 ]2 g* V但是只要 AUDIO_Init_FS 里面调了 BSP_AUDIO_OUT_Init 就会枚举失败，显示“未知 USB 设备”，跟踪 BSP_AUDIO_OUT_Init 的执行过程没发现问题，
, v; L2 o! U0 k6 H而且这个函数返回值也是OK，但是紧接着 AUDIO_DeInit_FS 就被调了，也跟踪了 USB 中断和 DMA 中断都有，查了好几天查不出原因，时钟配置好像也没问题，楼主您能指点一下吗？多谢！

梦中的飞鸿 发表于 2019-9-11 09:20
这个问题您解决了吗，我这也遇到了这个问题，有个小感叹号，然后提示
3 \; C1 w- H9 a! i" U% K/ I4 w3 b
$ T7 h" v: i' c8 B该设备无法启动。 (代码 10)

2 w  b* b8 v  m. C0 C: Q% C  S0 [出现这种情况要保证描述符是不是正确的，如果描述符正确在看看内存是否溢出，如果都正确，那就要一步步找问题了，就是把个单片机外设相关的代码想注释掉，基本上就找到原因了。

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

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

希望能有帮助

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

希望能有帮助

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

666，好贴，顶起来~

收藏

- H2 Z1 w4 {) [! o! U! o非常好的帖子，谢谢分享！！！

好贴！

楼主，我想问下，stm32 Audio Class的PC端不需要驱动吗？我的提示能够正确识别设备，但是安装驱动失败！
2 l0 r; ?) v  e- f- w2 f

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

...

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

4 i7 M6 o! k2 j0 s4 ^该设备无法启动。 (代码 10)

I/O 请求已取消。
4 N6 Q( Q8 l# ^$ X

梦中的飞鸿 发表于 2019-9-11 09:20
这个问题您解决了吗，我这也遇到了这个问题，有个小感叹号，然后提示

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

) P1 u+ `# ?! e( C3 J$ {1 t' b经测，不要用最新的库版本，用1.21.0的测试直接生成，正常识别！