1 前言
* a0 f) P0 G% {本文将基于STM32F4 Discovery板,从零开始设计并实现一个USB Audio的例子。

2 设计构思
% O7 l2 j! r' O6 |' {  {8 y% }) n所谓的USB AUDIO就是制作一个盒子，这个盒子可以通过USB连接到PC，PC端将其识别为Audio设备，然后在PC端播放音乐的时候，声音可以通过盒子播放出来。
! j0 s& {8 U- g! K. g1 `- A: Y
2.1 从原理框图开始

5 }, Z; @8 K% x0 q! \3 u如上图所示,我们大概构思一下，为了实现USB AUDIO功能，我们使用一个MCU的USB外设连接PC端，整个流程是这样: PC端播放音乐时，代表音乐的数据流从PC端通过USB传输到MCU端，MCU端然后将其转发给一个外部Codec，最后通过Codec上连接的扬声器或耳机播放音乐。
9 c7 [# E: w: I8 _& |2 F3 ^8 V( s
' Q+ `) ~- B% Q/ {8 ^% U+ N  O2.2 硬件支撑
这里选择ST官方的STM32F4-DISCOVERY板来实现，之所以选择这块板子，就是因为其上有USB接口和Codec，正好符合我们设计的要求。
0 d% x5 z5 X' \# \( J1 n1 P6 `* q
2.2.1 USB接口
如下图为USB接口部分的电路：

" `! x' L/ P( C' T' C; @这个一个将USB作为OTG的电路设计，在本设计中，我们只是将USB作为device来使用，因此，上图我们关注下面部分就可以了。在本设计中，我们使用到全速USB，从上图可以看出D+与D-引脚分别为PA12，PA11。

2.2.2 Codec部分
  M/ j0 \3 t% k& R. B如下图所示:

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

1 ?4 ?. a9 K/ y2.3 软件设计
为了简化开发流程，这里使用CubeMx自动生成代码工具来生成初始化代码，首先基于Cube库架构以及USB协议栈的特点，我们得先设计一个合理的软件框架。
9 S! \3 b: d: A8 \' P1 u2 \3 X
; e6 M& T( R3 e- u0 ?1 e+ E
( W. s# }3 X* j6 }+ e( C如上图，蓝色表示的模块为标准模块，不需要我们去修改它，将由CubeMx自动生成，而绿色部分则可能涉及到需要修改，其中BSP部分是需要自己添加的代码，其他的都是由CubeMx生成。

各个模块的工作流程如下设计:
8 h7 Q8 N4 J: o8 F! f6 N* I
. J. j1 m6 l' ?( M8 O( O2 d3 R 初始化流程: 由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模块是一个数据接收到数据处理的一个中间对接模块。
9 m' U' Z1 j  AUSB音频数据处理过程: usb audio interface 模块将从USB stack底层传上来的音频数据转发给Codec组件，最终通过Codec组件连接的耳机播放出来。
' @- r2 P6 A4 I从以上的音频数据流程来看，最主要的就是usbaudio interface模块，它实现了从USB audio stack到codec驱动的对接。
5 g) c+ d, C  C
4 h' {7 |, \: n8 E5 p, t/ {接下来，我们来看看软件层面上的实现。

+ A0 g! W& b2 g  P$ w3 软件实现
7 K- Q0 [' [/ P+ I% F还是老办法，采用CubeMx这个工具来生成初始化代码，这样可以节省我们花费在基本外设上的调试初始参数时间。
3 _- F3 B* z7 d* M+ m" D1 W: D
3.1 创建CubeMx工程
由于我们使用到的硬件平台是STM32F4Discovery板，上面搭载的MCU型号是STM32F407VGT6，我们就以此型号创建一个名为Audio_Test的工程。

pinout:
: d- }% |1 q" r0 g: c
/ a! Q) u) B0 [" D外设有用到USB_OTG_FS(PA11,PA12device模式)，I2C1(PB6,PB9)，I2S3(PC12,PA4,PC10,PC7，半双工主模式),此外Codec的reset使用PD4管脚控制，使用外部8M HSE。其pinout如下图所示：
3 Z' ?8 b! T0 b( I

Clock configuration:
3 X9 \, h, `. a9 \! u; D
( y) g1 P6 ^0 o0 E, f( O& b: Z时钟树如上设置，主频使用168M，I2S时钟输出初始化为96M。
; }' X6 S, F9 x% V4 w8 i7 [
Configuration:

2 l/ e8 M% ^+ ?8 H! W" l: R$ m  HAL层：
Usb_FS：使用默认参数。
7 i6 J# r: O& D: Z+ G/ w% ?
& [7 J- p% r. `7 XI2C：100K速率，7位地址宽度，使用默认参数。
  W+ s3 ?1 V4 a  N
* K1 W  }3 H9 j' c, QI2S：主发模式，标准16位宽，默认音频为48K，如下图：

并为I2S发送添加DMA，半字位宽:
, P$ Z+ t( r9 Q5 o. D) f+ _' G

1 m" u" {+ Y: S   MiddleWares:
  ^, o  @2 p4 y/ p; a
USB选择Audiodevice class,其配置参数如下：
/ _) ^$ D' G* s  ]9 n$ t% ~

这里都是默认参数。

在描述符参数内得为usb audio class修改两个参数：
6 _# `! b9 B, L
, l- m8 d1 v7 P1 r; N0 OPID得修改为0x5730(否则windows驱动会加载出错)
序列号：序列号字符串内不能包含字母，只能是数据(否则windowsaudio驱动在枚举后也不会将音频数据传输下来)。
2 c5 K0 N0 \/ M最后修改工程设置，将堆大小设为4K，栈大小设为1K，如下图：

# w2 Z8 m3 f0 `/ h) w" `+ y如此就可以生成工程了，我们生成IAR工程。

: g# y7 y8 Z' N3.2 生成的IAR工程介绍

8 B# J7 z6 A! B( x/ g5 T如上图所示，生成的IAR工程，主要有User,Drivers,Middleware3个目录。

User目录下为用户源码文件，用户的主要修改也将集中在此目录下，在这里，我们的主要工作是集中在usbd_audio_if.c文件，它对应着之前软件框图中的usbaudio interface模块，主要是实现USB audio协议栈与Codec的对接。其他源文件都保持不变就可以了。
- q- q$ M2 i, d8 |Middlewares目录对应着usb audio stack模块，它由CubeMx自动生成，保持原样就可以，不需要任何修改。
% a5 c+ A/ n2 A0 V0 W% eDrivers目录对应着HAL层，它包含CMSIS，HAL驱动。

3.3 开发
3.3.1 初次编译测试
首先我们不做任何修改，先编译一下工程，发现能顺利编译通过，并烧录进STM32F4DISCOVERY板，运行后通过USB连接上电脑，发现在设备管理器中能正常识别到这个USB AUDIO设备，如下图所示：
& T1 D2 j. p7 X6 G0 X% D
这说明，USB与PC端的连接是OK的，但不知道具体有没有数据。我们使用USB分析仪TOTAL PHASE USB480这个设备对USB总线进行数据监控，能够正常采集USB枚举过程和播放音乐的通信数据，如下图所示：

" s- g" T# r) I! a% u5 u- l3 O8 _这表明，到目前为止，从PC端到USB端都是能正常工作的，从PC端发送过来的音频数据已经到达usb audio interface模块，目前只不过还没有对这些数据进行处理，显然，接下来的工作，我们就需要将这些音频数据通过codec驱动发送出去，最终到达外部组件CS32L22.
- w1 S; D3 B8 L* S
  t- c  q1 ]2 _( E+ [' S2 s6 O- O3.3.2 添加codec驱动和audio bsp模块
我们已经知道，我们需要为audio添加BSP模块，在这里，我们将BSP归属于drivers类，因此，在drivers目录下添加BSP目录，通过之前的软件架构图我们可以知道，BSP包含Codec驱动（CS43L22）和Audio bsp模块，因此，我们在BSP目录下有添加了Codec的驱动源码cs43l22.c与bsp_audio.c,如下图所示：
, P2 d! a2 ?! P9 k% `! P6 l! u
0 M! T3 W* d$ w* ?/ E其中cs43l22.c为codec cs32l22的驱动，我们可以从ST的组件驱动中找到它，并copy过来直接使用，不需要修改任何代码。而bsp_audio.c是我们自己写的，它的任务是为usbd_audio_if.c与cs43l22.c提供服务，让这两个模块胜利对接。

2 M8 B3 k5 a$ |4 y4 r3.3.2.1 Codec与HAL的对接
0 b  r4 \8 e: r. g3 i9 ^首先我们来看Codec驱动文件cs43l22.c源文件，这个文件需要使用这个外部需要提供的接口：
% f3 Q) b3 _- ^( N7 q

1. [cpp] view plain copy
   & [1 T" N3 p. k8 V" a, T$ D9 I7 E% k! [
2. AUDIO_IO_Init()  
   . _' c6 e' o7 V: @
3. AUDIO_IO_DeInit()  
   7 e! l$ K# p- _1 g6 y( j0 E& v
4. AUDIO_IO_Write()  
   + d( L% `% T) I) d4 O
5. AUDIO_IO_Read()  

复制代码

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

1. [cpp] view plain copy
   ! Y+ p5 O$ B+ k& q. q1 o: A% o5 l
2. //---------------------for c43l22 port--------------------------//  
   
3. static void I2Cx_Error(uint8_t Addr)  
   6 m/ a+ ]% I+ B- c8 a) h1 `/ z
4. {  
   
5.   /* De-initialize the IOE comunication BUS */  
   
6.   HAL_I2C_DeInit(&hi2c1);  
   
7.   
   + ]3 t. ]" h% G# F# u8 o
8.   /* Re-Initiaize the IOE comunication BUS */  
   
9.   //I2Cx_Init();  
   ) E( F/ H$ [# [% }5 d5 M0 ~
10.   //MX_I2C1_Init();  
    6 I  {7 U& j( V5 ]7 h
11. }  
    
12. static void CODEC_Reset(void)  
    ( l, f; X# G! ~9 P8 r
13. {  
    ) ?; Y# B; s" R) B  c9 V9 N
14.     HAL_GPIO_WritePin(AUDIO_RESET_GPIO_Port, AUDIO_RESET_Pin, GPIO_PIN_RESET);  
    7 T% v# t! ^2 d3 N+ ~& M0 z# T
15.     HAL_Delay(5);  
    
16.     HAL_GPIO_WritePin(AUDIO_RESET_GPIO_Port, AUDIO_RESET_Pin, GPIO_PIN_SET);  
    
17.     HAL_Delay(5);  
    + b0 j( N+ ~$ N# _
18. }  
    5 q/ V1 d5 E0 G% Q
19. void AUDIO_IO_Init(void)  
    / D! R' Z; W* w& ]' G
20. {  
    
21.   //I2Cx_Init();  
    
22. }  
    ) l7 k* |8 o7 P1 D( }  ]0 e
23. void AUDIO_IO_DeInit(void)  
    0 X/ d8 r# m8 z3 V" _$ T
24. {  
    4 C0 l( @  g# ]- _$ V4 }$ d
25.   
    5 w  {' x9 `8 L* r+ q
26. }  
    9 {* ^) k8 }2 i/ |
27. /**
    : W& \3 A! q* l* ]# H
28.   * @brief  Writes a single data.
    
29.   * @param  Addr: I2C address
    2 C) w( ~( p9 f9 M2 |8 u% u% s) k& O
30.   * @param  Reg: Reg address
    1 t: B, U9 M4 _) G
31.   * @param  Value: Data to be written
    
32.   */  
    
33. static void I2Cx_Write(uint8_t Addr, uint8_t Reg, uint8_t Value)  
    
34. {  
      y/ y( ~, J, a, F% ?/ L
35.   HAL_StatusTypeDef status = HAL_OK;  
    ' s1 n& r5 l) D/ X+ f$ q# t( ]
36.   
    5 M) V; S  t+ v( z) @1 \4 |
37.   status = HAL_I2C_Mem_Write(&hi2c1, Addr, (uint16_t)Reg, I2C_MEMADD_SIZE_8BIT, &Value, 1, I2C_TIMEOUT);  
    
38.   
    
39.   /* Check the communication status */  
    & q" E5 p% L% X+ D0 _
40.   if(status != HAL_OK)  
    2 l4 a- ]+ m/ I& j8 G
41.   {  
    3 t. d: [. x' m$ L1 o% {
42.     /* I2C error occured */  
    
43.     I2Cx_Error(Addr);  
    ) x$ K, V" g! c  \
44.   }  
    5 W2 J9 T( i5 _3 |) L# _
45. }  
    
46. void AUDIO_IO_Write(uint8_t Addr, uint8_t Reg, uint8_t Value)  
    
47. {  
    
48.   I2Cx_Write(Addr, Reg, Value);  
    
49. }  
    
50.   
    2 x: j- X/ x3 i. p/ d4 H4 Q! p
51. /**
    
52.   * @brief  Reads a single data.
    % w2 V( p0 I9 F! I+ E1 h  h0 ?. ?
53.   * @param  Addr: I2C address
    
54.   * @param  Reg: Reg address
    ! [; K1 ]: N6 Z; D
55.   * @retval Data to be read
      r! T+ @  V6 m# m$ \* D
56.   */  
    9 e' _& P. x; j- A
57. static uint8_t I2Cx_Read(uint8_t Addr, uint8_t Reg)  
    ; c  n8 b# B+ [# ~
58. {  
    7 P  f- A2 a' [0 s$ e
59.   HAL_StatusTypeDef status = HAL_OK;  
    
60.   uint8_t Value = 0;  
    
61.   
    
62.   status = HAL_I2C_Mem_Read(&hi2c1, Addr, Reg, I2C_MEMADD_SIZE_8BIT, &Value, 1, I2C_TIMEOUT);  
    
63.   
    4 u4 {: z! O9 T$ g2 o
64.   /* Check the communication status */  
    ( t. d* b( j5 U6 g
65.   if(status != HAL_OK)  
    
66.   {  
    
67.     /* Execute user timeout callback */  
    
68.     I2Cx_Error(Addr);  
    
69.   }  
    
70.   
    
71.   return Value;  
    ' F. z1 z3 Z) @5 V' O
72. }  
    
73. uint8_t AUDIO_IO_Read(uint8_t Addr, uint8_t Reg)  
    3 p& L) e' ~/ S0 B; \9 {
74. {  
    $ ]9 s* c( Q0 \( m; ]9 ?+ s6 q
75.   return I2Cx_Read(Addr, Reg);  
    6 N1 G2 j2 a) S% g4 r( m& l. l; j
76. }  

复制代码

由于在main函数中已经对I2C初始化过了，因此，在AUDIO_IO_Init函数中不需要再次初始化。
9 q, o3 _7 z( q( u) X
就这样，就完成了Codec驱动与与HAL的对接。
  ~$ x7 S" T; J$ x/ C$ {* R
9 [" Z+ @' ]0 A8 L3.3.2.2 usb audiointerface与codec的对接
我们打开usb audio interface源码文件usbd_audio.if.c文件，此文件由CubeMx自动生成，已经自动给出了一些关于usb audio class的函数，且这些函数体内容都是空白的，毫无疑问，接下来的工作，我们就是要完成这个空白的内容，就好比做填空题一样，当然，在做这些”填空题”的过程中，我们将使用到Codec驱动提供的接口，这一过程，就是usb audiointerface与codec的对接过程。

  U2 }! E/ \* F2 ~5 Q% z按照这一清晰思路，我们首先找到usbd_audio_if.c的一个接口：
" |: t: O, N" u! G7 n

1. [cpp] view plain copy
   / S' M6 [7 ~8 Q2 e3 ]
2. static int8_t AUDIO_Init_FS(uint32_t  AudioFreq, uint32_t Volume, uint32_t options)  
   
3. {   
   " K/ D6 M( y6 l% c9 S, {8 M& C
4.   /* USER CODE BEGIN 0 */  
   7 j, i: m# h: r& J! K- x( [4 m
5.   return (USBD_OK);  
   : o; A0 ]" u) r4 J
6.   /* USER CODE END 0 */  
   
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 */  
   
5.   hi2s3.Instance = SPI3;  
   
6.   
   ! {$ `3 O4 w- N
7. /* Disable I2S block */  
   
8.   __HAL_I2S_DISABLE(&hi2s3);  
   ! U) F4 i" S) z8 Y8 P2 n
9.   
   
10.   hi2s3.Init.Mode = I2S_MODE_MASTER_TX;  
    & r  y; @2 k: Q  k
11.   hi2s3.Init.Standard = I2S_STANDARD;  
    
12.   hi2s3.Init.DataFormat = I2S_DATAFORMAT_16B;  
    
13.   hi2s3.Init.AudioFreq = AudioFreq;  
    ) J5 l  C) F7 b& g8 D* h
14.   hi2s3.Init.CPOL = I2S_CPOL_LOW;  
    7 B) s9 q$ n1 N: h$ d7 |
15.   hi2s3.Init.MCLKOutput = I2S_MCLKOUTPUT_ENABLE;  
    / P& w7 s' {! u- ~* B0 Z
16.   
    * O, c% l9 a! {8 f% \5 r0 n
17.   if(HAL_I2S_GetState(&hi2s3) == HAL_I2S_STATE_RESET)  
    
18.   {  
    5 S# {" S! w/ u
19.     HAL_I2S_MspInit(&hi2s3);  
    3 A& F4 \6 [" T% D
20.   }  
    
21.   /* Init the I2S */  
    7 ^" f/ q2 \# ~, R" U) t
22.   HAL_I2S_Init(&hi2s3);  
    
23. }  
    
24. const uint32_t I2SFreq[8] = {8000, 11025, 16000, 22050, 32000, 44100, 48000, 96000};  
    $ N& Z$ G$ d8 m
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. {  
    % W: E* A+ |: U- l, Y) l
29.     uint32_t deviceid = 0x00;  
    & N  a5 e! R6 ?1 G  d
30.     uint8_t ret = AUDIO_ERROR;  
    1 f" l& m9 m7 Z$ Z; g( w
31.     uint8_t index = 0, freqindex = 0xFF;  
      u  k3 w# x/ l0 Z' C
32.     RCC_PeriphCLKInitTypeDef RCC_ExCLKInitStruct;  
    ) z/ X+ R! g4 f/ M, D9 M& R3 V
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)  
    4 O5 g4 O# h6 N5 ~
38.         {  
    / a! {) G% y" R- K
39.             freqindex = index;  
    + H$ M  ]) P' y$ C! ^
40.         }  
    
41.     }  
    
42.     HAL_RCCEx_GetPeriphCLKConfig(&RCC_ExCLKInitStruct);  
    , v* R- q+ I; G( S# D( h+ b* m
43.     if(freqindex != 0xFF)  
    & D2 ]. u& u4 z, |$ O4 `' _" n
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.     }  
    
50.     else  
    , @0 Y0 c* n# W; o0 \
51.     {  
    
52.         RCC_ExCLKInitStruct.PeriphClockSelection = RCC_PERIPHCLK_I2S;  
    
53.             RCC_ExCLKInitStruct.PLLI2S.PLLI2SN = 258;  
    
54.             RCC_ExCLKInitStruct.PLLI2S.PLLI2SR = 3;  
      |: a; @6 E' q2 ]
55.             HAL_RCCEx_PeriphCLKConfig(&RCC_ExCLKInitStruct);  
    ( m6 Q( u" \$ t4 @, O4 M  ^
56.     }  
    / k) z! s3 a. O" H1 T# Z
57.   
    
58.     //reset the Codec register  
    
59.     CODEC_Reset();  
    
60.     deviceid = cs43l22_drv.ReadID(AUDIO_I2C_ADDRESS);  
    % R6 |: j7 F2 _, s- l4 k# ~
61.     if((deviceid & CS43L22_ID_MASK) == CS43L22_ID)  
    3 Z  x' ?: \+ j- P: N; _$ q
62.       {  
    
63.         /* Initialize the audio driver structure */  
    
64.         audio_drv = &cs43l22_drv;  
    & l* c$ J/ `% g; ~: P
65.         ret = AUDIO_OK;  
    
66.       }  
    
67.       else  
    
68.       {  
    
69.         ret = AUDIO_ERROR;  
      A; k! u  U# p5 v
70.       }  
    - b7 e2 ?9 |6 ?+ W) G2 D
71.   
    & P2 m" b( o7 D
72.      if(ret == AUDIO_OK)  
    
73.       {  
    + `/ d# H+ F4 [( r, ~+ k
74.         audio_drv->Init(AUDIO_I2C_ADDRESS, OutputDevice, Volume, AudioFreq);  
    & ~0 i8 J: K5 A9 b- f
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 */  
    7 L+ h- }; ~- X& j% c
78.         I2Sx_Init(AudioFreq);  
      F) _! h9 r# F" L
79.       }  
    - M4 F2 q1 x# n" M* Z
80.     return AUDIO_OK;  
    ; C/ Q, z. f) z' g$ r' ?
81. }  

复制代码

在BSP_AUDIO_OUT_Init()这个函数内，根据所传入的采样率，程序在预定义的数组内选择出MCU内部时钟树对I2S时钟的一个合理的分频值，并设置进时钟树配置内，然后再对codec进行初始化，最后对I2S外设初始化。
' Q2 e, \9 ~: ?* n& Q/ f6 X
这个选择I2S时钟合理分频值的过程是根据STM32F407的参考手册中的建议来做的，如下参考手册中的28.4.4中表126：
  T* t. c: A7 V) N4 e; S

% y' o% g9 u, B: P在48K采样率下，假设时钟树下的PLLM VCO=1MHz情况下，且MCK使能，为了尽可能输出靠近期望的时钟，此时应该将时钟树内的PLL2SN设为258，且PLL2SR设为3，I2S内部的预分频因子I2SDIV设为3，以及零散因子I2SODD设为1。这个计算公式为:
% `8 _* Y$ G, F7 e! U0 W- J
0 m9 z4 g. o5 ~# V9 e. x, w也就是(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。

) f. w) j: e% V  t: O! a搞懂了这些之后，我们马上将其代码进行对接：

1. [cpp] view plain copy
   ( u8 Y, B" \* x6 L8 S6 ~5 T( A
2. static int8_t AUDIO_Init_FS(uint32_t  AudioFreq, uint32_t Volume, uint32_t options)  
   ! @7 V3 [7 g9 H/ z4 V
3. {   
   
4.   /* USER CODE BEGIN 0 */  
   
5.   BSP_AUDIO_OUT_Init(OUTPUT_DEVICE_AUTO, Volume, AudioFreq);  
   
6.   return (USBD_OK);  
   : b! R% g! c$ I5 h
7.   /* USER CODE END 0 */  
   ! Y) w) K3 S) A# y$ L6 t6 e
8. }  

复制代码

接下来下一个需要对接的接口：
: R6 A. _4 w4 V& {2 o  r# f, j& u+ W, s

1. [cpp] view plain copy
   
2. static int8_t AUDIO_DeInit_FS(uint32_t options)  
   
3. {  
   
4.   /* USER CODE BEGIN 1 */   
   2 l" Y3 H' |. ?
5.   BSP_AUDIO_OUT_Stop(CODEC_PDWN_SW);  
   8 T( n, _; o! j2 B! f- j
6.   return (USBD_OK);  
   " E4 Y( ^5 ~7 a9 [- D. n5 g8 V+ R7 n. d
7.   /* USER CODE END 1 */  
   
8. }  
   
9. 很明显，这个个反初始化的接口，它的具体实现如下：
   3 g' b: f, C) ]4 x( c& P; {8 r
10. 
    
11. [cpp] view plain copy
    
12. uint8_t BSP_AUDIO_OUT_Stop(uint32_t Option)  
    
13. {  
    6 b' L4 V$ a% Q' F. H8 r
14.   /* Call the Media layer stop function */  
    
15.   HAL_I2S_DMAStop(&hi2s3);  
    
16.   
    " I) @  a6 u% j! a8 |, K$ B
17.   /* Call Audio Codec Stop function */  
    5 ]& q1 m& q3 d: x9 }! q4 C" n9 b
18.   if(audio_drv->Stop(AUDIO_I2C_ADDRESS, Option) != 0)  
    
19.   {  
    
20.     return AUDIO_ERROR;  
    
21.   }  
    
22.   else  
    ) k$ w/ Y8 b; O" g- O
23.   {  
    , t* c0 ~5 G- W3 w$ R
24.     if(Option == CODEC_PDWN_HW)  
    
25.     {  
    
26.       /* Wait at least 1ms */  
    3 [: M: t+ A) o
27.       HAL_Delay(1);  
    
28.   
    & r% W6 X0 o1 ?' ^" g% l! Y. C+ W
29.       /* Reset the pin */  
    
30.       //BSP_IO_WritePin(AUDIO_RESET_PIN, RESET);  
    ' I: U( c& z7 j' U2 j
31.       HAL_GPIO_WritePin(AUDIO_RESET_GPIO_Port, AUDIO_RESET_Pin, GPIO_PIN_RESET);  
    
32.     }  
    
33.   
    ; m4 b5 A" V) w4 F! F. ?  M
34.     /* Return AUDIO_OK when all operations are correctly done */  
    
35.     return AUDIO_OK;  
    
36.   }  
    2 t( t) \) g# j8 T
37. }  

复制代码

先关闭I2S的DMA，在调用Codec的停止接口。
& |  _1 a4 n" r0 w/ I/ R0 TOK，下一个：
6 T1 {( G% `% h" `4 s6 s6 V

1. [cpp] view plain copy
     j7 G7 j$ E- m6 X* y# _3 f! j. m
2. static int8_t AUDIO_AudioCmd_FS (uint8_t* pbuf, uint32_t size, uint8_t cmd)  
   
3. {  
   4 L$ [4 b& s) Y% e1 p; T
4.   /* USER CODE BEGIN 2 */  
   # F7 W8 L* @) m9 |5 G
5.   switch(cmd)  
   7 j4 [; w9 ^) i( `3 e: P+ ^' u" w
6.   {  
   
7.     case AUDIO_CMD_START:  
   9 o$ m) T1 h" g& j$ U
8.         BSP_AUDIO_OUT_Play((uint16_t *)pbuf, size);  
   
9.     break;  
   ; W. V( H( [; f0 Y" V1 E6 R  M; l
10.   
    
11.     case AUDIO_CMD_PLAY:  
    
12.         BSP_AUDIO_OUT_ChangeBuffer((uint16_t *)pbuf, size);  
    / n6 ~. E' D% u% E/ ^
13.     break;  
    
14.   }  
    ) M  Q& [) C! p2 c  h
15.   return (USBD_OK);  
    
16.   /* USER CODE END 2 */  
    & j  [7 Y# w1 f! g; z
17.    
      C/ w& |0 y7 b
18. }  

复制代码

第一次USB audio stack接收到USB OUT数据时会回调这个接口并传入AUDIO_CMD_START参数，这里的处理代码是：
/ [7 _8 T4 D) S' Q- `( A! e

1. [cpp] view plain copy
   + z, @2 P: x# ?5 @- N
2. uint8_t BSP_AUDIO_OUT_Play(uint16_t* pBuffer, uint32_t Size)  
   3 H6 k  n2 Z5 u0 Z- T
3. {  
   
4.   /* Call the audio Codec Play function */  
   
5.   if(audio_drv->Play(AUDIO_I2C_ADDRESS, pBuffer, Size) != 0)  
   
6.   {  
   4 z& L* _9 X5 @; A  x; e
7.     return AUDIO_ERROR;  
   
8.   }  
   , V" I* N6 a( K+ \
9.   else  
   
10.   {  
    9 Z' X$ K" n3 B3 R! h
11.     /* Update the Media layer and enable it for play */  
    0 w" X9 E, e1 ]5 b. C
12.     HAL_I2S_Transmit_DMA(&hi2s3, pBuffer, DMA_MAX(Size/AUDIODATA_SIZE));  
    4 h+ \/ m9 L5 ^2 |; j, d
13.     return AUDIO_OK;  
    - h1 |8 ^, s& N7 H* H
14.   }  
    * ?! r$ q/ P; \& f, K1 k( F0 q  o/ ]
15. }  

复制代码

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

( b3 M- D# U7 v2 R, X5 S然后I2S的DMA会产生传输完成中断和半传输完成中断，在这两个中断处理上，会回调到AUDIO_AudioCmd_FS()接口，并且此时传入的参数变为AUDIO_CMD_PLAY,此时，音频数据的处理函数为:
4 Q" Q1 A' S) [6 Y& V% d

1. [cpp] view plain copy
   
2. void BSP_AUDIO_OUT_ChangeBuffer(uint16_t *pData, uint16_t Size)  
   
3. {  
   . t6 D+ j% P/ M4 A4 P4 K* D
4.   HAL_I2S_Transmit_DMA(&hi2s3, pData, Size);  
   
5. }  

复制代码

也是通过I2S的DMA将数据传输给外部Codec。
" j! A+ D, }; C
7 D3 C1 J: V* P7 c: T  x上述过程涉及到另外两个usbd_audio_if接口函数，即I2S的DMA半传输完成和传输完成中断回调,如下所示:

1. [cpp] view plain copy
   
2. void TransferComplete_CallBack_FS(void)  
   1 f: O& d" R, |7 V5 @( I6 c
3. {  
   
4.   /* USER CODE BEGIN 7 */   
   1 `& t  G$ H) \+ L" T
5.   USBD_AUDIO_Sync(&hUsbDeviceFS, AUDIO_OFFSET_FULL);  
   
6.   /* USER CODE END 7 */  
   
7. }  
   ! q% {; i. T: p/ G
8. void HalfTransfer_CallBack_FS(void)  
   
9. {   
   , w! b  b5 P3 o. f+ s' P* t
10.   /* USER CODE BEGIN 8 */   
    & ~" O5 o% q* p! ^* B
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，这个不间断的传输，才能实现音频播放的连贯性。

2 j3 O$ K6 M2 E8 {2 O此外，在USB设备端，后续接收到的音频数据会紧接着之前的数据进行存放，这里实现了一个数据环形缓冲区，来实现了USB接收端与I2S输出端数据有效的缓存。

接下来看下一个usbd_audio_if接口函数对接：
( {6 S' T& V$ j. F

1. [cpp] view plain copy
   2 T7 T% A3 o- v' l' D" T
2. static int8_t AUDIO_VolumeCtl_FS (uint8_t vol)  
   
3. {  
   
4.   /* USER CODE BEGIN 3 */   
   
5.   BSP_AUDIO_OUT_SetVolume(vol);  
   
6.   return (USBD_OK);  
   
7.   /* USER CODE END 3 */  
   
8. }  

复制代码

很明显，这个是音量控制接口，也对接下:
/ t! O; o/ z: x$ c1 J' ?/ X8 q

1. [cpp] view plain copy
   6 ~: E! d$ d( D: G& N
2. uint8_t BSP_AUDIO_OUT_SetVolume(uint8_t Volume)  
   , Y0 _, k: Y+ D1 k+ K4 G; x6 H$ d1 j# l* |
3. {  
   5 r) j9 X7 R+ e3 ]0 O
4.   /* Call the codec volume control function with converted volume value */  
   ! ]4 V$ g2 x7 B) u3 H- p0 r8 @
5.   if(audio_drv->SetVolume(AUDIO_I2C_ADDRESS, Volume) != 0)  
   $ O8 K. j! r0 a2 o
6.   {  
   6 W3 p+ K9 g/ j9 [3 g
7.     return AUDIO_ERROR;  
   ; T3 M% i1 J  N
8.   }  
   - n/ ^6 Q' ^9 G7 Q; s. |! ?
9.   else  
   % _, d: D. Z$ v* ~$ ]
10.   {  
    
11.     /* Return AUDIO_OK when all operations are correctly done */  
    # }2 e! l% S- n2 ^) {
12.     return AUDIO_OK;  
    
13.   }  
    
14. }  

复制代码

直接调用Codec启动的相应接口。需要注意地是，实际上，在PC端进行音量的调节，并不会向USB端发送相应的音量调节指令，这里只是象征性的对接下，实际上在USB AUDIO中代码并不会允许到这里，音量的放大和变小直接体现在音频数据本身内。
2 {& x9 z6 e5 i- \3 B
  n0 \6 _$ M3 |6 b8 E, }2 q8 b* F  R下一个:

1. [cpp] view plain copy
   
2. static int8_t AUDIO_MuteCtl_FS (uint8_t cmd)  
   - F& v) W: O# f% M& ^# C/ L
3. {  
   
4.   /* USER CODE BEGIN 4 */   
   ) R8 x6 n7 y& _& }1 e4 k8 J4 z
5.   BSP_AUDIO_OUT_SetMute(cmd);  
   
6.   return (USBD_OK);  
   2 |2 K( ^" a8 L& F- Y! |4 q) H
7.   /* USER CODE END 4 */  
   ! r0 W2 S; t( D4 s% S
8. }  

复制代码

静音控制，其实现为：
5 `3 c/ e' q( O

1. [cpp] view plain copy
   
2. uint8_t BSP_AUDIO_OUT_SetMute(uint32_t Cmd)  
   : `* n/ |7 y  u- A
3. {  
   
4.   /* Call the Codec Mute function */  
   0 c9 B% z7 p' z+ W5 H4 B; h8 U
5.   if(audio_drv->SetMute(AUDIO_I2C_ADDRESS, Cmd) != 0)  
   1 R8 T% L1 U2 ?( v
6.   {  
   2 w0 l/ L( l# ]9 ?" m/ o, r4 y: h
7.     return AUDIO_ERROR;  
   + F/ W0 e  {  {9 n7 ^3 h9 P
8.   }  
   
9.   else  
   
10.   {  
    4 ]9 K) C' n4 L+ n
11.     /* Return AUDIO_OK when all operations are correctly done */  
    
12.     return AUDIO_OK;  
    
13.   }  
    
14. }  
    

复制代码

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

OK，就这样，usbd_audio_if模块的接口基本上对接到这样就可以了。

4    测试验证
将代码编译后烧录进STM32F4DISCVOERY板进行验证。

最终验证是OK的，可以从耳机上听到PC端播放的音乐。
" h/ o$ J& N1 @
5    结束语
! ~) @5 Z- G* x1 P9 B在CubeMx上对中间件USB配置时，将USB audio class的音频采样率设置为48K,那个这个参数会再USB枚举期间会传递给windows的audio驱动，在枚举通过后，后续通过USB传输的音频数据都将是固定以48K采样率来的，也就是192bytes/ms，也就是说，不管PC端播放什么音乐，windows的audio驱动都会固定以48K采样率向USB端口进行传输。这种特性是由windows的audio驱动决定的。

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

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

楼主问下，你这个会有杂音吗？我这边测试了下，会有杂音的，如果根据接受AUDIO_TOTAL_BUF_SIZE大小去传输，usb中断影响HAL_I2S_Transmit_DMA(&hi2s1, (uint16_t *)pbuf, (size))传输结果，显示为hal_busy,忙等待，传输数据这块你有做特殊处理吗？
, P: c2 j% @3 Wstatic uint8_t  USBD_AUDIO_DataOut (USBD_HandleTypeDef *pdev,
* |9 T. P6 l1 |' a1 K                              uint8_t epnum)
{
  USBD_AUDIO_HandleTypeDef   *haudio;
  haudio = (USBD_AUDIO_HandleTypeDef*) pdev->pClassData;

4 a9 l! Z& q) K5 Y& Y: ~9 W% \  if (epnum == AUDIO_OUT_EP)
  {
1 x* i/ ]. z, o& J! x4 G    /* Increment the Buffer pointer or roll it back when all buffers are full */
/ C" ^7 f5 L' S& C
; q  ^/ \" X6 ^% C- d    haudio->wr_ptr += AUDIO_OUT_PACKET;
( s9 V! G% n8 i4 D
  d3 T# k  r7 R4 s0 L7 U0 ^+ ^    if (haudio->wr_ptr == AUDIO_TOTAL_BUF_SIZE)
    {
      /* All buffers are full: roll back */
# O! U+ }; p6 i6 P' l$ U7 m2 s      haudio->wr_ptr = 0U;
    ((USBD_AUDIO_ItfTypeDef *)pdev->pUserData)->AudioCmd(&haudio->buffer[0],
% A% m0 e0 G% o                                                 AUDIO_TOTAL_BUF_SIZE / 2U,
3 y% ^9 E  V8 w, ~                                                 AUDIO_CMD_PLAY);
#if 0
      if(haudio->offset == AUDIO_OFFSET_UNKNOWN)
      {
# H& O; e5 j5 L' `  g        ((USBD_AUDIO_ItfTypeDef *)pdev->pUserData)->AudioCmd(&haudio->buffer[0],
                                                             AUDIO_TOTAL_BUF_SIZE / 2U,
                                                             AUDIO_CMD_START);
          haudio->offset = AUDIO_OFFSET_NONE;
- r. n1 Z9 f3 }- I* W  K0 I, B) l6 I      }
#endif
7 F' z3 L8 S; V' h* f    }

. l' P2 ^8 G1 M  @: n- v: P3 K& V    if(haudio->rd_enable == 0U)
( s- O8 J3 B, t6 d# i$ @    {
) R/ C% y% x$ }2 Y      if (haudio->wr_ptr == (AUDIO_TOTAL_BUF_SIZE / 2U))
: v. i' ^  F- I. {9 ]! Q/ Z1 b      {
4 _* q- r/ \5 U5 o        haudio->rd_enable = 1U;
      }
    }

    /* Prepare Out endpoint to receive next audio packet */
8 X  G* q7 l1 N; r# g    USBD_LL_PrepareReceive(pdev, AUDIO_OUT_EP, &haudio->buffer[haudio->wr_ptr],
                           AUDIO_OUT_PACKET);
. u! q/ X% }( e  L6 V, a- j  }

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

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

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

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

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

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

4 S5 f& g  I# t; S9 b" S" }+ }希望能有帮助

anny 发表于 2018-5-23 14:45
  J# S- y' g! c8 x1 t( e1 ]9 A: `非常好的帖子，谢谢分享！！！

希望能有帮助

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

666，好贴，顶起来~

收藏

" L# B/ A$ g) q" m  f& _0 g非常好的帖子，谢谢分享！！！

好贴！

楼主，我想问下，stm32 Audio Class的PC端不需要驱动吗？我的提示能够正确识别设备，但是安装驱动失败！
  R# S5 Z  Z$ ~6 ~
. G- \% w# j1 m7 L

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

这个问题您解决了吗，我这也遇到了这个问题，有个小感叹号，然后提示
7 f2 c4 B- [4 {2 B
5 O( i" Y8 M  b4 ^6 V; M该设备无法启动。 (代码 10)

* _3 m" @  J- S2 p. NI/O 请求已取消。

梦中的飞鸿 发表于 2019-9-11 09:20
  N0 |4 d, I2 g' l这个问题您解决了吗，我这也遇到了这个问题，有个小感叹号，然后提示
) I% D4 o* D0 K7 ^) I; q: Q+ a8 ]- {
该设备无法启动。 (代码 10)

$ M) U6 J5 _! S# W8 a经测，不要用最新的库版本，用1.21.0的测试直接生成，正常识别！