I2S WM8978 DMA没中断问题，参考SAI驱动改写

发布于 2020-07-08 16:33:02 浏览：2442 订阅该版

1. STM32F4XX 参考音频SAI驱动 写I2S驱动，发现I2S的DMA不进入中断，代码如下，欢迎各位测试 查看问题出在哪里了。

2. 修改了一下初始化，和使用默认的I2S的DMA传输函数，现在DMA中断只产生一次，修改后的在1楼回复里面。

3. I2S的DMA双缓存传输有问题，不能直接使用HAL的传输，必须自己定义半传输和完整传输函数，修改如下方式，可以全部进入传输数据传输中断了。

4. 发现传输数据出现I2S_DMAError  进入到这个里面，正看问题

还没测试能不能播放出声音，默认的SAI里面的WM8978好像是耳机输出，还没配置为喇叭输出，已经可以进入数据传输中断了，

5. wm8978播放还没声音，需要看下为啥没声音，

6.可以播放，录音部分也写了，但是录音有杂音，标准库没杂音，HAL库有，暂时不知道为啥

I2S通过CubeMX的DMA配置如下  暂时只是播放的配置

```c
void HAL_I2S_MspInit(I2S_HandleTypeDef* hi2s)
{
  GPIO_InitTypeDef GPIO_InitStruct = {0};
  if(hi2s->Instance==SPI2)
  {
  /* USER CODE BEGIN SPI2_MspInit 0 */

/* USER CODE END SPI2_MspInit 0 */
    /* Peripheral clock enable */
    __HAL_RCC_SPI2_CLK_ENABLE();
  
    __HAL_RCC_GPIOA_CLK_ENABLE();
    __HAL_RCC_GPIOB_CLK_ENABLE();
    /**I2S2 GPIO Configuration    
    PA6     ------> I2S2_MCK
    PB12     ------> I2S2_WS
    PB13     ------> I2S2_CK
    PB14     ------> I2S2_ext_SD
    PB15     ------> I2S2_SD 
    */
    GPIO_InitStruct.Pin = GPIO_PIN_6;
    GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
    GPIO_InitStruct.Pull = GPIO_NOPULL;
    GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW;
    GPIO_InitStruct.Alternate = GPIO_AF6_SPI2;
    HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);

GPIO_InitStruct.Pin = GPIO_PIN_12|GPIO_PIN_13|GPIO_PIN_15;
    GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
    GPIO_InitStruct.Pull = GPIO_NOPULL;
    GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW;
    GPIO_InitStruct.Alternate = GPIO_AF5_SPI2;
    HAL_GPIO_Init(GPIOB, &GPIO_InitStruct);

GPIO_InitStruct.Pin = GPIO_PIN_14;
    GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
    GPIO_InitStruct.Pull = GPIO_NOPULL;
    GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW;
    GPIO_InitStruct.Alternate = GPIO_AF6_SPI2;
    HAL_GPIO_Init(GPIOB, &GPIO_InitStruct);

/* I2S2 DMA Init */
    /* SPI2_TX Init */
    hdma_spi2_tx.Instance = DMA1_Stream4;
    hdma_spi2_tx.Init.Channel = DMA_CHANNEL_0;
    hdma_spi2_tx.Init.Direction = DMA_MEMORY_TO_PERIPH;
    hdma_spi2_tx.Init.PeriphInc = DMA_PINC_DISABLE;
    hdma_spi2_tx.Init.MemInc = DMA_MINC_ENABLE;
    hdma_spi2_tx.Init.PeriphDataAlignment = DMA_PDATAALIGN_HALFWORD;
    hdma_spi2_tx.Init.MemDataAlignment = DMA_MDATAALIGN_HALFWORD;
    hdma_spi2_tx.Init.Mode = DMA_CIRCULAR;
    hdma_spi2_tx.Init.Priority = DMA_PRIORITY_LOW;
    hdma_spi2_tx.Init.FIFOMode = DMA_FIFOMODE_DISABLE;
    if (HAL_DMA_Init(&hdma_spi2_tx) != HAL_OK)
    {
      //Error_Handler();
    }

__HAL_LINKDMA(hi2s,hdmatx,hdma_spi2_tx);

/* USER CODE BEGIN SPI2_MspInit 1 */

/* USER CODE END SPI2_MspInit 1 */
  }

}

```

```
/*
 * Copyright (c) 2006-2018, RT-Thread Development Team
 *
 * SPDX-License-Identifier: Apache-2.0
 *
 * Change Logs:
 * Date           Author         Notes
 * 2019-07-28     Ernest         the first version
 */

#include "board.h"
#include "drv_wm8978.h"
#include "drv_sound.h"

#define DBG_TAG              "drv.sound"
#define DBG_LVL              DBG_INFO
#include <rtdbg.h>

#define	CODEC_I2C_NAME  ("i2c1")

#define TX_DMA_FIFO_SIZE (2048)

I2S_HandleTypeDef hi2s2;
DMA_HandleTypeDef hdma_spi2_tx;

struct stm32_audio
{
    struct rt_i2c_bus_device *i2c_bus;
    struct rt_audio_device audio;
    struct rt_audio_configure replay_config;
    int replay_volume;
    rt_uint8_t *tx_fifo;
    rt_bool_t startup;
};
struct stm32_audio _stm32_audio_play = {0};

void i2s_samplerate_set(rt_uint32_t freq)
{
    if(freq == I2S_AUDIOFREQ_8K  || freq == I2S_AUDIOFREQ_11K ||
            freq == I2S_AUDIOFREQ_16K || freq == I2S_AUDIOFREQ_22K ||
            freq == I2S_AUDIOFREQ_32K || freq == I2S_AUDIOFREQ_44K ||
            freq == I2S_AUDIOFREQ_48K || freq == I2S_AUDIOFREQ_96K)
    {
        hi2s2.Init.AudioFreq = freq;
    }
    else
    {
        return;
    }

__HAL_I2S_DISABLE(&hi2s2);
    HAL_I2S_Init(&hi2s2);
    __HAL_I2S_ENABLE(&hi2s2);

}

void i2s_channels_set(rt_uint16_t channels)
{
}

void i2s_samplebits_set(rt_uint16_t samplebits)
{
    switch (samplebits)
    {
        case 16:
            hi2s2.Init.DataFormat = I2S_DATAFORMAT_16B;
            break;

case 24:
            hi2s2.Init.DataFormat = I2S_DATAFORMAT_24B;
            break;

case 32:
            hi2s2.Init.DataFormat = I2S_DATAFORMAT_32B;
            break;

default:
            hi2s2.Init.DataFormat = I2S_DATAFORMAT_16B;
            break;
    }

__HAL_I2S_DISABLE(&hi2s2);
    HAL_I2S_Init(&hi2s2);
    __HAL_I2S_ENABLE(&hi2s2);
}

void i2s_config_set(struct rt_audio_configure config)
{
    i2s_channels_set(config.channels);
    i2s_samplerate_set(config.samplerate);
    i2s_samplebits_set(config.samplebits);
}

rt_err_t I2S_config_init(void)
{
    hi2s2.Instance = SPI2;
    hi2s2.Init.Mode = I2S_MODE_MASTER_TX;
    hi2s2.Init.Standard = I2S_STANDARD_PHILIPS;
    hi2s2.Init.DataFormat = I2S_DATAFORMAT_16B;
    hi2s2.Init.MCLKOutput = I2S_MCLKOUTPUT_ENABLE;
    hi2s2.Init.AudioFreq = I2S_AUDIOFREQ_8K;
    hi2s2.Init.CPOL = I2S_CPOL_LOW;
    hi2s2.Init.ClockSource = I2S_CLOCK_PLL;
    hi2s2.Init.FullDuplexMode = I2S_FULLDUPLEXMODE_ENABLE;

if (HAL_I2S_Init(&hi2s2) != HAL_OK)
	{
		rt_kprintf("HAL_I2S_Init error\n");
	}
}

void I2S_DMAConvCplt(DMA_HandleTypeDef *hdma)
{
    rt_audio_tx_complete(&_stm32_audio_play.audio);
}
void I2S_DMAError(DMA_HandleTypeDef *hdma)
{
    rt_kprintf("DMAError\n");
}
void DMA1_Stream4_IRQHandler(void)
{
    rt_interrupt_enter();
	HAL_DMA_IRQHandler(&hdma_spi2_tx);
    rt_interrupt_leave();
}

void HAL_I2S_TxHalfCpltCallback(I2S_HandleTypeDef *hi2s)
{
	rt_kprintf("HAL_I2S_TxHalfCpltCallback pk 1\n");
    rt_audio_tx_complete(&_stm32_audio_play.audio);
}

void HAL_I2S_TxCpltCallback(I2S_HandleTypeDef *hi2s)
{
	rt_kprintf("HAL_I2S_TxCpltCallback pk 2\n");
    rt_audio_tx_complete(&_stm32_audio_play.audio);
}

rt_err_t I2S_tx_dma(void)
{

HAL_DMA_DeInit(&hdma_spi2_tx);
	HAL_DMA_Init(&hdma_spi2_tx);
	__HAL_DMA_DISABLE(&hdma_spi2_tx);
	
	__HAL_DMA_ENABLE_IT(&hdma_spi2_tx,DMA_IT_TC);//开启DMA传输完成中断
	__HAL_DMA_ENABLE_IT(&hdma_spi2_tx, DMA_IT_HT); //开启DMA半传输传输完成中断
	__HAL_DMA_CLEAR_FLAG(&hdma_spi2_tx, DMA_FLAG_TCIF0_4);

__HAL_RCC_DMA1_CLK_ENABLE();  //DMA1时钟使能

//注册回调函数,读取数据等操作在这里面处理
    hdma_spi2_tx.XferCpltCallback = I2S_DMAConvCplt;
    hdma_spi2_tx.XferM1CpltCallback = I2S_DMAConvCplt;
    hdma_spi2_tx.XferErrorCallback = I2S_DMAError;

HAL_NVIC_SetPriority(DMA1_Stream4_IRQn, 0, 0);
    HAL_NVIC_EnableIRQ(DMA1_Stream4_IRQn);
    return RT_EOK;
}

rt_err_t i2s_tx_init()
{
    /* set I2S_TX DMA */
	I2S_config_init();
	I2S_tx_dma();
	
    return RT_EOK;
}
static rt_err_t stm32_player_getcaps(struct rt_audio_device *audio, struct rt_audio_caps *caps)
{
    rt_err_t result = RT_EOK;
    struct stm32_audio *st_audio = (struct stm32_audio *)audio->parent.user_data;

LOG_D("%s:main_type: %d, sub_type: %d", __FUNCTION__, caps->main_type, caps->sub_type);

switch (caps->main_type)
    {
        case AUDIO_TYPE_QUERY: /* query the types of hw_codec device */
        {
            switch (caps->sub_type)
            {
                case AUDIO_TYPE_QUERY:
                    caps->udata.mask = AUDIO_TYPE_OUTPUT | AUDIO_TYPE_MIXER;
                    break;

default:
                    result = -RT_ERROR;
                    break;
            }

break;
        }

case AUDIO_TYPE_OUTPUT: /* Provide capabilities of OUTPUT unit */
        {
            switch (caps->sub_type)
            {
                case AUDIO_DSP_PARAM:
                    caps->udata.config.channels     = st_audio->replay_config.channels;
                    caps->udata.config.samplebits   = st_audio->replay_config.samplebits;
                    caps->udata.config.samplerate   = st_audio->replay_config.samplerate;
                    break;

case AUDIO_DSP_SAMPLERATE:
                    caps->udata.config.samplerate   = st_audio->replay_config.samplerate;
                    break;

case AUDIO_DSP_CHANNELS:
                    caps->udata.config.channels     = st_audio->replay_config.channels;
                    break;

case AUDIO_DSP_SAMPLEBITS:
                    caps->udata.config.samplebits     = st_audio->replay_config.samplebits;
                    break;

default:
                    result = -RT_ERROR;
                    break;
            }

break;
        }

case AUDIO_TYPE_MIXER: /* report the Mixer Units */
        {
            switch (caps->sub_type)
            {
                case AUDIO_MIXER_QUERY:
                    caps->udata.mask = AUDIO_MIXER_VOLUME | AUDIO_MIXER_LINE;
                    break;

case AUDIO_MIXER_VOLUME:
                    caps->udata.value = st_audio->replay_volume;
                    break;

case AUDIO_MIXER_LINE:
                    break;

default:
                    result = -RT_ERROR;
                    break;
            }

break;
        }

default:
            result = -RT_ERROR;
            break;
    }

return result;
}

static rt_err_t  stm32_player_configure(struct rt_audio_device *audio, struct rt_audio_caps *caps)
{
    rt_err_t result = RT_EOK;
    struct stm32_audio *st_audio = (struct stm32_audio *)audio->parent.user_data;

LOG_D("%s:main_type: %d, sub_type: %d", __FUNCTION__, caps->main_type, caps->sub_type);

switch (caps->main_type)
    {
        case AUDIO_TYPE_MIXER:
        {
            switch (caps->sub_type)
            {
                case AUDIO_MIXER_MUTE:
                {
                    /* set mute mode */
                    wm8978_mute_enabled(_stm32_audio_play.i2c_bus, RT_FALSE);
                    break;
                }

case AUDIO_MIXER_VOLUME:
                {
                    int volume = caps->udata.value;

st_audio->replay_volume = volume;
                    /* set mixer volume */
                    wm8978_set_volume(_stm32_audio_play.i2c_bus, volume);

break;
                }

default:
                    result = -RT_ERROR;
                    break;
            }

break;
        }

case AUDIO_TYPE_OUTPUT:
        {
            switch (caps->sub_type)
            {
                case AUDIO_DSP_PARAM:
                {
                    struct rt_audio_configure config = caps->udata.config;

st_audio->replay_config.samplerate = config.samplerate;
                    st_audio->replay_config.samplebits = config.samplebits;
                    st_audio->replay_config.channels = config.channels;

i2s_config_set(config);
                    break;
                }

case AUDIO_DSP_SAMPLERATE:
                {
                    st_audio->replay_config.samplerate = caps->udata.config.samplerate;
                    i2s_samplerate_set(caps->udata.config.samplerate);
                    break;
                }

case AUDIO_DSP_CHANNELS:
                {
                    st_audio->replay_config.channels = caps->udata.config.channels;
                    i2s_channels_set(caps->udata.config.channels);
                    break;
                }

case AUDIO_DSP_SAMPLEBITS:
                {
                    st_audio->replay_config.samplebits = caps->udata.config.samplebits;
                    i2s_samplebits_set(caps->udata.config.samplebits);
                    break;
                }

default:
                    result = -RT_ERROR;
                    break;
            }

break;
        }

default:
            break;
    }

return result;
}

static rt_err_t stm32_player_init(struct rt_audio_device *audio)
{
    /* initialize wm8978 */
    _stm32_audio_play.i2c_bus = (struct rt_i2c_bus_device *)rt_device_find(CODEC_I2C_NAME);

i2s_tx_init();
    wm8978_init(_stm32_audio_play.i2c_bus);
    return RT_EOK;
}
void I2S_Play_Start(void)
{
   hi2s2.Instance->CR2 |= SPI_CR2_TXDMAEN;
}

static rt_err_t stm32_player_start(struct rt_audio_device *audio, int stream)
{
    if (stream == AUDIO_STREAM_REPLAY)
    {
		rt_kprintf("HAL_I2S_Transmit_DMA start\n");
		HAL_DMAEx_MultiBufferStart_IT(&hdma_spi2_tx, (uint32_t)_stm32_audio_play.tx_fifo, (uint32_t) & (SPI2->DR), (uint32_t)(_stm32_audio_play.tx_fifo + TX_DMA_FIFO_SIZE / 2), TX_DMA_FIFO_SIZE / 4);

I2S_Play_Start();
		wm8978_player_start(_stm32_audio_play.i2c_bus);
    }

return RT_EOK;
}

static rt_err_t stm32_player_stop(struct rt_audio_device *audio, int stream)
{
    if (stream == AUDIO_STREAM_REPLAY)
    {
        HAL_I2S_DMAStop(&hi2s2);
    }

return RT_EOK;
}

static void stm32_player_buffer_info(struct rt_audio_device *audio, struct rt_audio_buf_info *info)
{
    /**
     *               TX_FIFO
     * +----------------+----------------+
     * |     block1     |     block2     |
     * +----------------+----------------+
     *  \  block_size  /
     */
    info->buffer = _stm32_audio_play.tx_fifo;
    info->total_size = TX_DMA_FIFO_SIZE;
    info->block_size = TX_DMA_FIFO_SIZE / 2;
    info->block_count = 2;
}
static struct rt_audio_ops _p_audio_ops =
{
    .getcaps     = stm32_player_getcaps,
    .configure   = stm32_player_configure,
    .init        = stm32_player_init,
    .start       = stm32_player_start,
    .stop        = stm32_player_stop,
    .transmit    = NULL,
    .buffer_info = stm32_player_buffer_info,
};

int rt_hw_sound_init(void)
{
    rt_uint8_t *tx_fifo;

/* player */
    tx_fifo = rt_malloc(TX_DMA_FIFO_SIZE);

if (tx_fifo == RT_NULL)
    {
        return -RT_ENOMEM;
    }

rt_memset(tx_fifo, 0, TX_DMA_FIFO_SIZE);
    _stm32_audio_play.tx_fifo = tx_fifo;

_stm32_audio_play.tx_fifo = tx_fifo;

/* init default configuration */
    {
        _stm32_audio_play.replay_config.samplerate = 44100;
        _stm32_audio_play.replay_config.channels   = 2;
        _stm32_audio_play.replay_config.samplebits = 16;
        _stm32_audio_play.replay_volume            = 30;
    }
	
    /* register sound device */
    _stm32_audio_play.audio.ops = &_p_audio_ops;
    rt_audio_register(&_stm32_audio_play.audio, "sound0", RT_DEVICE_FLAG_WRONLY, &_stm32_audio_play);

return RT_EOK;
}

INIT_DEVICE_EXPORT(rt_hw_sound_init);

```

4 个回答

aozima 2020-07-08

调网络不抓包，调I2C等时序不上逻辑分析仪，就像电工不用万用表！多用整理的好的文字，比截图更省流量，还能在整理过程中思考。

肉肉肉肉肉肉多 2020-07-08

这家伙很懒，什么也没写！

请登录后再发布评论，点击登录

追加回复

肉肉肉肉肉肉多 2020-07-08

这家伙很懒，什么也没写！

aozima 2020-07-08

调网络不抓包，调I2C等时序不上逻辑分析仪，就像电工不用万用表！多用整理的好的文字，比截图更省流量，还能在整理过程中思考。

肉肉肉肉肉肉多 2020-07-08

这家伙很懒，什么也没写！

@aozima 我刚修改了一下DMA的初始化和传输，直接用HAL默认的DMA库函数，发信DMA1_Stream4_IRQHandler 只执行了一次，修改后的代码如下 
`static rt_err_t stm32_player_start(struct rt_audio_device *audio, int stream)
{
    if (stream == AUDIO_STREAM_REPLAY)
    {
		rt_kprintf("HAL_I2S_Transmit_DMA start\n");
		//PrintBuffer((uint16_t *)_stm32_audio_play.tx_fifo,TX_DMA_FIFO_SIZE/2);
		HAL_I2S_Transmit_DMA(&hi2s2,(uint16_t *)_stm32_audio_play.tx_fifo,TX_DMA_FIFO_SIZE/2);
		
		wm8978_player_start(_stm32_audio_play.i2c_bus);
    }

return RT_EOK;
}`

```
rt_err_t I2S_tx_dma(void)
{

HAL_DMA_DeInit(&hdma_spi2_tx);
	HAL_DMA_Init(&hdma_spi2_tx);
	__HAL_DMA_DISABLE(&hdma_spi2_tx);
	
	__HAL_DMA_ENABLE_IT(&hdma_spi2_tx,DMA_IT_TC);//开启DMA传输完成中断
	__HAL_DMA_ENABLE_IT(&hdma_spi2_tx, DMA_IT_HT); //开启DMA半传输传输完成中断
	__HAL_DMA_CLEAR_FLAG(&hdma_spi2_tx, DMA_FLAG_TCIF0_4);

//清空DMA1_Stream4上所有中断标志
//	DMA_HandleTypeDef  DMA_InitStructure;
	__HAL_RCC_DMA1_CLK_ENABLE();  //DMA1时钟使能
  //  __HAL_DMA_CLEAR_FLAG(&DMA_InitStructure, DMA_FLAG_FEIF0_4 | DMA_FLAG_DMEIF0_4 | DMA_FLAG_TEIF0_4 | DMA_FLAG_HTIF0_4 | DMA_FLAG_TCIF0_4);

//注册回调函数,读取数据等操作在这里面处理
  //  hdma_spi2_tx.XferCpltCallback = I2S_DMAConvCplt;
  //  hdma_spi2_tx.XferM1CpltCallback = I2S_DMAConvCplt;
   // hdma_spi2_tx.XferErrorCallback = I2S_DMAError;
	
 //   HAL_DMAEx_MultiBufferStart_IT(&hdma_spi2_tx, (uint32_t)buffer0, (uint32_t) & (WM8978_I2Sx_SPI->DR), (uint32_t)buffer1, num);

HAL_NVIC_SetPriority(DMA1_Stream4_IRQn, 0, 0);
    HAL_NVIC_EnableIRQ(DMA1_Stream4_IRQn);
    return RT_EOK;
}

串口打印如下
```
msh />wavplay -s 1.wav
[65201] D/audio: open audio replay device, oflag = 2

[65207] D/WAV_PLAYER: open wavplayer, device sound0
[65214] D/WAV_PLAYER: Information:
[65217] D/WAV_PLAYER: samplerate 44100
[65221] D/WAV_PLAYER: channels 2
[65225] D/WAV_PLAYER: sample bits width 16
[65229] D/audio: AUDIO_CTL_CONFIGURE: main_type = 2,sub_type = 0
[65236] D/audio: AUDIO_CTL_CONFIGURE: main_type = 4,sub_type = 2
[65242] I/WAV_PLAYER: play start, uri=1.wav
[65254] I/WAV_PLAYER: witte data to sound device WP_BUFFER_SIZE 2048
HAL_I2S_Transmit_DMA start
DMA1_Stream4_IRQHandler
HAL_I2S_TxHalfCpltCallback pk 1
HAL_I2S_TxCpltCallback pk 2
[65267] D/audio: start audio replay device
[65278] I/WAV_PLAYER: witte data to sound device WP_BUFFER_SIZE 2048
[65292] I/WAV_PLAYER: witte data to sound device WP_BUFFER_SIZE 2048
[65306] I/WAV_PLAYER: witte data to sound device WP_BUFFER_SIZE 2048
[65320] I/WAV_PLAYER: witte data to sound device WP_BUFFER_SIZE 2048

```

肉肉肉肉肉肉多 2020-07-08

这家伙很懒，什么也没写！

上面格式有点不正常  重新格式下，原来的回复没法修改啊。

```

rt_err_t I2S_tx_dma(void)
{

HAL_DMA_DeInit(&hdma_spi2_tx);
	HAL_DMA_Init(&hdma_spi2_tx);
	__HAL_DMA_DISABLE(&hdma_spi2_tx);
	
	__HAL_DMA_ENABLE_IT(&hdma_spi2_tx,DMA_IT_TC);//开启DMA传输完成中断
	__HAL_DMA_ENABLE_IT(&hdma_spi2_tx, DMA_IT_HT); //开启DMA半传输传输完成中断
	__HAL_DMA_CLEAR_FLAG(&hdma_spi2_tx, DMA_FLAG_TCIF0_4);

//清空DMA1_Stream4上所有中断标志
//	DMA_HandleTypeDef  DMA_InitStructure;
	__HAL_RCC_DMA1_CLK_ENABLE();  //DMA1时钟使能
  //  __HAL_DMA_CLEAR_FLAG(&DMA_InitStructure, DMA_FLAG_FEIF0_4 | DMA_FLAG_DMEIF0_4 | DMA_FLAG_TEIF0_4 | DMA_FLAG_HTIF0_4 | DMA_FLAG_TCIF0_4);

//注册回调函数,读取数据等操作在这里面处理
  //  hdma_spi2_tx.XferCpltCallback = I2S_DMAConvCplt;
  //  hdma_spi2_tx.XferM1CpltCallback = I2S_DMAConvCplt;
   // hdma_spi2_tx.XferErrorCallback = I2S_DMAError;
	
 //   HAL_DMAEx_MultiBufferStart_IT(&hdma_spi2_tx, (uint32_t)buffer0, (uint32_t) & (WM8978_I2Sx_SPI->DR), (uint32_t)buffer1, num);

HAL_NVIC_SetPriority(DMA1_Stream4_IRQn, 0, 0);
    HAL_NVIC_EnableIRQ(DMA1_Stream4_IRQn);
    return RT_EOK;
}
```

```
static rt_err_t stm32_player_start(struct rt_audio_device *audio, int stream)
{
    if (stream == AUDIO_STREAM_REPLAY)
    {
		rt_kprintf("HAL_I2S_Transmit_DMA start\n");
		//PrintBuffer((uint16_t *)_stm32_audio_play.tx_fifo,TX_DMA_FIFO_SIZE/2);
		HAL_I2S_Transmit_DMA(&hi2s2,(uint16_t *)_stm32_audio_play.tx_fifo,TX_DMA_FIFO_SIZE/2);

wm8978_player_start(_stm32_audio_play.i2c_bus);
    }

return RT_EOK;
}

```

```
msh />wavplay -s 1.wav
[65201] D/audio: open audio replay device, oflag = 2

[65207] D/WAV_PLAYER: open wavplayer, device sound0
[65214] D/WAV_PLAYER: Information:
[65217] D/WAV_PLAYER: samplerate 44100
[65221] D/WAV_PLAYER: channels 2
[65225] D/WAV_PLAYER: sample bits width 16
[65229] D/audio: AUDIO_CTL_CONFIGURE: main_type = 2,sub_type = 0
[65236] D/audio: AUDIO_CTL_CONFIGURE: main_type = 4,sub_type = 2
[65242] I/WAV_PLAYER: play start, uri=1.wav
[65254] I/WAV_PLAYER: witte data to sound device WP_BUFFER_SIZE 2048
HAL_I2S_Transmit_DMA start
DMA1_Stream4_IRQHandler
HAL_I2S_TxHalfCpltCallback pk 1
HAL_I2S_TxCpltCallback pk 2
[65267] D/audio: start audio replay device
[65278] I/WAV_PLAYER: witte data to sound device WP_BUFFER_SIZE 2048
[65292] I/WAV_PLAYER: witte data to sound device WP_BUFFER_SIZE 2048
[65306] I/WAV_PLAYER: witte data to sound device WP_BUFFER_SIZE 2048
[65320] I/WAV_PLAYER: witte data to sound device WP_BUFFER_SIZE 2048

```

肉肉肉肉肉肉多 2020-07-08

这家伙很懒，什么也没写！

肉肉肉肉肉肉多 2020-07-08

这家伙很懒，什么也没写！

@aozima 首先非常抱歉，对不起，群里不知道是您，对不起~

默认的HAL库的I2S传输应该有点问题，必须自己定义半传输中断，和完整传输中断，

I2S DMA配置如下

```c
rt_err_t I2S_tx_dma(void)
{

HAL_DMA_DeInit(&hdma_spi2_tx);
	HAL_DMA_Init(&hdma_spi2_tx);
	__HAL_DMA_DISABLE(&hdma_spi2_tx);
	
	__HAL_DMA_ENABLE_IT(&hdma_spi2_tx,DMA_IT_TC);//开启DMA传输完成中断
	__HAL_DMA_ENABLE_IT(&hdma_spi2_tx, DMA_IT_HT); //开启DMA半传输传输完成中断
	__HAL_DMA_CLEAR_FLAG(&hdma_spi2_tx, DMA_FLAG_TCIF0_4);

__HAL_RCC_DMA1_CLK_ENABLE();  //DMA1时钟使能

//注册回调函数,读取数据等操作在这里面处理
    hdma_spi2_tx.XferCpltCallback = I2S_DMAConvCplt;
    hdma_spi2_tx.XferM1CpltCallback = I2S_DMAConvCplt;
    hdma_spi2_tx.XferErrorCallback = I2S_DMAError;

HAL_NVIC_SetPriority(DMA1_Stream4_IRQn, 0, 0);
    HAL_NVIC_EnableIRQ(DMA1_Stream4_IRQn);
    return RT_EOK;
}
```

player 函数如下

```c
static rt_err_t stm32_player_start(struct rt_audio_device *audio, int stream)
{
    if (stream == AUDIO_STREAM_REPLAY)
    {
		rt_kprintf("HAL_I2S_Transmit_DMA start\n");

HAL_DMAEx_MultiBufferStart_IT(&hdma_spi2_tx, (uint32_t)_stm32_audio_play.tx_fifo, (uint32_t) & (SPI2->DR), (uint32_t)(_stm32_audio_play.tx_fifo + TX_DMA_FIFO_SIZE / 2), TX_DMA_FIFO_SIZE / 2);

I2S_Play_Start();
		wm8978_player_start(_stm32_audio_play.i2c_bus);
    }

return RT_EOK;
}
```

半中断和中断完成传输函数如下

```c
void I2S_DMAConvCplt(DMA_HandleTypeDef *hdma)
{
    rt_audio_tx_complete(&_stm32_audio_play.audio);
}
```

这样可以完整的进入中断了，查看了下HAL_DMA_Init 双缓存有点问题，使用HAL_DMAEx_MultiBufferStart_IT 启动双缓存传输，这样就可以了，