RT-Thread组件之Audio框架i2s驱动的编写

已于 2024-03-12 15:43:14 修改
阅读量1.2k 收藏 9
点赞数 37
分类专栏： STM32相关驱动 嵌入式学习 文章标签： stm32 单片机 音视频
于 2024-03-12 12:56:47 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44742767/article/details/136648088
版权

前言

  1. rt-thread本次使用的是标志版本为5.0。
  2. 本次实现的是音频播放部分的i2s驱动
  3. 使用的芯片为stm32f407zgt6
  4. 在网上搜了一下关于rt-thread 音频部分的内容，没有实质的提供i2s对接的硬件驱动。所以才有了此次的记录，做一下分享记录。
  5. 参考的git源码驱动，这个是用的sai接口，而f4并没有
  6. 本次注重实际代码部分，关于一些音频相关的理论知识自行查阅相关资料。
  7. 使用到的音频模块为wm8978,相关驱动参考之前的文章
  8. 音频文件保存到sd中，使用的是rt-thread 的虚拟文件系统组件

rt-thread的audio框架

在这里插入图片描述

配置阶段

在这里插入图片描述在这里插入图片描述

播放阶段

在这里插入图片描述在这里插入图片描述在这里插入图片描述在这里插入图片描述
底层驱动需要做的是，通知框架发送下一帧数据 ，不然会阻塞
在这里插入图片描述

录音阶段（本文暂未涉及）

  1. 过程跟播放是类似的

I2S 音频驱动(暂时只做了播放)

头文件

#ifndef F4_OS_DR_I2S_H
#define F4_OS_DR_I2S_H

#include <rtthread.h>
#include <rthw.h>
#include <rtdevice.h>
#include <drv_common.h>
#include <drv_dma.h>
#include <drv_config.h>

#define I2S_TX_DMA_FIFO_SIZE (4096)
#define I2S_SOUND_NAME "sound0"
#define CODEC_I2C_NAME  ("i2c1")
struct stm32_i2s_cnf {
    rt_uint32_t standard;
    rt_uint32_t mode;
    rt_uint32_t data_format;
    rt_uint32_t clk_cpl;
};

struct stm32_audio { 
    I2S_HandleTypeDef i2s;
    DMA_HandleTypeDef dma_tx;
    struct rt_audio_device audio;
    struct rt_audio_configure replay_config;
    struct stm32_i2s_cnf *i2s_conf;
    rt_int32_t replay_volume;
    rt_uint8_t *tx_fifo;
    rt_bool_t startup;
};

int rt_hw_audio_init(void);
#endif //F4_OS_DR_I2S_H

原文件

#include "board.h"
#include "drv_audio.h"
#include "audio_wm8978.h"

#define DBG_TAG              "drv.sound"
#ifdef  DRV_DEBUG
#define DBG_LVL              DBG_LOG
#else
#define DBG_LVL              DBG_LOG
#endif /* DRV_DEBUG */

#include <rtdbg.h>


struct stm32_audio _stm32_audio_play = {
        .i2s.Instance=SPI2
};

#define _i2s _stm32_audio_play.i2s
#define _dma_tx _stm32_audio_play.dma_tx
//采样率计算公式:Fs=I2SxCLK/[256*(2*I2SDIV+ODD)]
//I2SxCLK=(HSE/pllm)*PLLI2SN/PLLI2SR
//一般HSE=8Mhz
//pllm:在Sys_Clock_Set设置的时候确定，一般是8
//PLLI2SN:一般是192~432
//PLLI2SR:2~7
//I2SDIV:2~255
//ODD:0/1
//I2S分频系数表@pllm=8,HSE=8Mhz,即vco输入频率为1Mhz
//表格式:采样率/10,PLLI2SN,PLLI2SR,I2SDIV,ODD
const rt_uint16_t i2s_psc_tbl[][5] =
        {
                {800,   256, 5, 12, 1},        //8Khz采样率
                {1102,  429, 4, 19, 0},        //11.025Khz采样率
                {1600,  213, 2, 13, 0},        //16Khz采样率
                {2205,  429, 4, 9,  1},        //22.05Khz采样率
                {3200,  213, 2, 6,  1},        //32Khz采样率
                {4410,  271, 2, 6,  0},        //44.1Khz采样率
                {4800,  258, 3, 3,  1},        //48Khz采样率
                {8820,  316, 2, 3,  1},        //88.2Khz采样率
                {9600,  344, 2, 3,  1},    //96Khz采样率
                {17640, 361, 2, 2,  0},    //176.4Khz采样率
                {19200, 393, 2, 2,  0},    //192Khz采样率
        };
//设置SAIA的采样率(@MCKEN)
//samplerate:采样率,单位:Hz
//返回值:0,设置成功;1,无法设置.
rt_err_t I2S2_SampleRate_Set(rt_uint32_t samplerate) {

    rt_uint16_t i;
    volatile uint32_t tempreg = 0;
    RCC_PeriphCLKInitTypeDef RCCI2S2_ClkInitSture;
    //看看改采样率是否可以支持
    for (i = 0; i < (sizeof(i2s_psc_tbl) / 10); i++) {
        if ((samplerate / 10) == i2s_psc_tbl[i][0])break;
    }
    if (i == (sizeof(i2s_psc_tbl) / 10))return RT_ERROR;//搜遍了也找不到
    RCCI2S2_ClkInitSture.PeriphClockSelection = RCC_PERIPHCLK_I2S;            //外设时钟源选择
    RCCI2S2_ClkInitSture.PLLI2S.PLLI2SN = (uint32_t) i2s_psc_tbl[i][1];        //设置PLLI2SN
    RCCI2S2_ClkInitSture.PLLI2S.PLLI2SR = (uint32_t) i2s_psc_tbl[i][2];        //设置PLLI2SR
    HAL_RCCEx_PeriphCLKConfig(&RCCI2S2_ClkInitSture);                //设置时钟

    SET_BIT(RCC->CR, RCC_CR_PLLI2SON);       //开启I2S时钟
    while (READ_BIT(RCC->CR, RCC_CR_PLLI2SRDY) == 0);//等待I2S时钟开启成功.


    if (_i2s.Instance->I2SCFGR & SPI_I2SCFGR_I2SE) {
        __HAL_I2S_DISABLE(&_i2s); /*禁止i2s 配置以下寄存器 (手册上说明)*/
    }
    tempreg = i2s_psc_tbl[i][3] << 0;     //设置I2SDIV
    tempreg |= i2s_psc_tbl[i][4] << 8;    //设置ODD位
    tempreg |= 1 << 9;                    //使能MCKOE位,输出MCK
    WRITE_REG(_i2s.Instance->I2SPR, tempreg);//设置I2SPR寄存器
    if (!(_i2s.Instance->I2SCFGR & SPI_I2SCFGR_I2SE)) { /*如果i2s没有启动*/
        __HAL_I2S_ENABLE(&_i2s); /*启用i2s 配置以下寄存器 (手册上说明)*/
    }
    return RT_EOK;
}



//I2S2初始化
//I2S_Standard:I2S标准,可以设置：I2S_STANDARD_PHILIPS/I2S_STANDARD_MSB/
//				       I2S_STANDARD_LSB/I2S_STANDARD_PCM_SHORT/I2S_STANDARD_PCM_LONG
//I2S_Mode:I2S工作模式,可以设置：I2S_MODE_SLAVE_TX/I2S_MODE_SLAVE_RX/I2S_MODE_MASTER_TX/I2S_MODE_MASTER_RX
//I2S_Clock_Polarity:时钟电平，可以设置为:I2S_CPOL_LOW/I2S_CPOL_HIGH
//I2S_DataFormat:数据长度,可以设置：I2S_DATAFORMAT_16B/I2S_DATAFORMAT_16B_EXTENDED/I2S_DATAFORMAT_24B/I2S_DATAFORMAT_32B
static void
stm32_i2s_init(struct stm32_i2s_cnf *i2s_cnf) {


    _i2s.Init.Mode = i2s_cnf->mode;                    //IIS模式
    _i2s.Init.Standard = i2s_cnf->standard;            //IIS标准
    _i2s.Init.DataFormat = i2s_cnf->data_format;        //IIS数据长度
    _i2s.Init.MCLKOutput = I2S_MCLKOUTPUT_ENABLE;    //主时钟输出使能
    _i2s.Init.AudioFreq = I2S_AUDIOFREQ_DEFAULT;    //IIS频率设置
    _i2s.Init.CPOL = i2s_cnf->clk_cpl;          //空闲状态时钟电平
    _i2s.Init.ClockSource = I2S_CLOCK_PLL;        //IIS时钟源为PLL
    HAL_I2S_Init(&_i2s);
    SET_BIT(_i2s.Instance->CR2, SPI_CR2_TXDMAEN); //Tx Buffer DMA Enable
    __HAL_I2S_ENABLE(&_i2s);                    //使能I2S2
}

void audio_channel_set(rt_uint16_t channel) {
    // todo 不支持设置通道
    RT_UNUSED(channel);
}

void audio_samplerate_set(rt_uint32_t samplerate) {
    I2S2_SampleRate_Set(samplerate);
}

void audio_samplebits_set(rt_uint16_t samplebits) {
    if (_stm32_audio_play.i2s_conf) { /*如果用户自行配置的话就有用户的*/
        stm32_i2s_init(_stm32_audio_play.i2s_conf);
        return;
    }
    struct stm32_i2s_cnf i2s_cnf;
    switch (samplebits) {
        case 16:
            LOG_D("飞利浦标准,16位数据长度");
            wm8978_I2S_Cfg(2, 0);  // 飞利浦标准,主机发送,时钟低电平有效,16位帧长度
            i2s_cnf.mode = I2S_MODE_MASTER_TX;
            i2s_cnf.standard = I2S_STANDARD_PHILIPS;
            i2s_cnf.clk_cpl = I2S_CPOL_LOW;
            i2s_cnf.data_format = I2S_DATAFORMAT_16B_EXTENDED;
            break;
        case 24:
            LOG_D("飞利浦标准,24位数据长度");
            wm8978_I2S_Cfg(2, 2);     //飞利浦标准,主机发送,时钟低电平有效,24位扩展帧长度
            i2s_cnf.mode = I2S_MODE_MASTER_TX;
            i2s_cnf.standard = I2S_STANDARD_PHILIPS;
            i2s_cnf.clk_cpl = I2S_CPOL_LOW;
            i2s_cnf.data_format = I2S_DATAFORMAT_24B;
            break;
        case 32:
            wm8978_I2S_Cfg(2, 3);     //飞利浦标准,主机发送,时钟低电平有效,24位扩展帧长度
            i2s_cnf.mode = I2S_MODE_MASTER_TX;
            i2s_cnf.standard = I2S_STANDARD_PHILIPS;
            i2s_cnf.clk_cpl = I2S_CPOL_LOW;
            i2s_cnf.data_format = I2S_DATAFORMAT_32B;
            break;
        default:
            // todo
            return;
    }
    stm32_i2s_init(&i2s_cnf);
}


/* initial sai A */
rt_err_t audio_config_init() {
    rt_uint32_t temp;

    return RT_EOK;
}

static void i2s_transmit_complate(struct __DMA_HandleTypeDef *hdma);

rt_err_t audio_tx_dma(void) {
    __HAL_RCC_DMA1_CLK_ENABLE();                                //使能DMA1时钟
    __HAL_LINKDMA(&_i2s, hdmatx, _dma_tx);                      //将DMA与I2S联系起来
    _dma_tx.Instance = DMA1_Stream4;                            //DMA1数据流4
    _dma_tx.Init.Channel = DMA_CHANNEL_0;                       //通道0
    _dma_tx.Init.Direction = DMA_MEMORY_TO_PERIPH;              //存储器到外设模式
    _dma_tx.Init.PeriphInc = DMA_PINC_DISABLE;                  //外设非增量模式
    _dma_tx.Init.MemInc = DMA_MINC_ENABLE;                      //存储器增量模式
    /*todo 这里按照道理应该根据数据位宽来配置 ?*/
    _dma_tx.Init.PeriphDataAlignment = DMA_PDATAALIGN_HALFWORD; //外设数据长度:16位
    _dma_tx.Init.MemDataAlignment = DMA_MDATAALIGN_HALFWORD;    //存储器数据长度:16位
    _dma_tx.Init.Mode = DMA_CIRCULAR;                           //使用循环模式
    _dma_tx.Init.Priority = DMA_PRIORITY_VERY_HIGH;             //高优先级
    _dma_tx.Init.FIFOMode = DMA_FIFOMODE_DISABLE;               //不使用FIFO
    _dma_tx.Init.FIFOThreshold = DMA_FIFO_THRESHOLD_FULL;       // 使用FIFO阈值完全配置
    _dma_tx.Init.MemBurst = DMA_MBURST_SINGLE;                  //存储器单次突发传输
    _dma_tx.Init.PeriphBurst = DMA_MBURST_SINGLE;               //外设突发单次传输

    HAL_DMA_DeInit(&_dma_tx);                              //先清除以前的设置
    HAL_DMA_Init(&_dma_tx);                                //初始化DMA
    __HAL_DMA_DISABLE(&_dma_tx);                                 //先关闭DMA
    /*开启dma双缓冲模式*/
    /* Enable the double buffer mode */
    _dma_tx.Instance->CR |= (uint32_t) DMA_SxCR_DBM;
    /* Configure DMA Stream destination address */
    _dma_tx.Instance->M1AR = (uint32_t) (_stm32_audio_play.tx_fifo + I2S_TX_DMA_FIFO_SIZE);
    /* Configure DMA Stream data length */
    _dma_tx.Instance->NDTR = I2S_TX_DMA_FIFO_SIZE / 2;
    /* Configure DMA Stream destination address */
    _dma_tx.Instance->PAR = (uint32_t) &(_i2s.Instance->DR);
    /* Configure DMA Stream source address */
    _dma_tx.Instance->M0AR = (uint32_t) _stm32_audio_play.tx_fifo;
    /* Clear all flags */
    __HAL_DMA_CLEAR_FLAG (&_dma_tx, __HAL_DMA_GET_TC_FLAG_INDEX(&_dma_tx));
    __HAL_DMA_CLEAR_FLAG (&_dma_tx, __HAL_DMA_GET_HT_FLAG_INDEX(&_dma_tx));
    __HAL_DMA_CLEAR_FLAG (&_dma_tx, __HAL_DMA_GET_TE_FLAG_INDEX(&_dma_tx));
    __HAL_DMA_CLEAR_FLAG (&_dma_tx, __HAL_DMA_GET_DME_FLAG_INDEX(&_dma_tx));
    __HAL_DMA_CLEAR_FLAG (&_dma_tx, __HAL_DMA_GET_FE_FLAG_INDEX(&_dma_tx));

    /* Enable Common interrupts*/
    /* todo 这里是否需要开启 错误中断使能 ?*/
    //DMA_IT_TE: 传输错误中断使能 (Transfer error interrupt enable)
    //DMA_IT_DME: 直接模式错误中断使能 (Direct mode error interrupt enable)

    rt_thread_delay(20);
    //DMA_IT_TC: 传输完成中断使能 (Transfer complete interrupt enable)
    __HAL_DMA_ENABLE_IT(&_dma_tx, DMA_IT_TC);                    //开启传输完成中断
    __HAL_DMA_CLEAR_FLAG(&_dma_tx, DMA_FLAG_TCIF0_4);            //清除DMA传输完成中断标志位
    HAL_NVIC_SetPriority(DMA1_Stream4_IRQn, 1, 0);    //DMA中断优先级
    HAL_NVIC_EnableIRQ(DMA1_Stream4_IRQn);

    __HAL_DMA_ENABLE(&_dma_tx);                                //打开dma
    return RT_EOK;
}


static void i2s_dma_tx_set(void) {
    __HAL_RCC_DMA1_CLK_ENABLE(); // 使能DMA1时钟
    __HAL_LINKDMA(&_i2s, hdmatx, _dma_tx);//将DMA与I2S联系起来
    _dma_tx.Instance = DMA1_Stream4;                            //DMA1数据流4
    _dma_tx.Init.Channel = DMA_CHANNEL_0;                        //通道0
    _dma_tx.Init.Direction = DMA_MEMORY_TO_PERIPH;                //存储器到外设模式
    _dma_tx.Init.PeriphInc = DMA_PINC_DISABLE;                    //外设非增量模式
    _dma_tx.Init.MemInc = DMA_MINC_ENABLE;                        //存储器增量模式
    _dma_tx.Init.PeriphDataAlignment = DMA_PDATAALIGN_HALFWORD;    //外设数据长度:16位
    _dma_tx.Init.MemDataAlignment = DMA_MDATAALIGN_HALFWORD;        //存储器数据长度:16位
    _dma_tx.Init.Mode = DMA_CIRCULAR;                            //使用循环模式
    _dma_tx.Init.Priority = DMA_PRIORITY_VERY_HIGH;                    //高优先级
    _dma_tx.Init.FIFOMode = DMA_FIFOMODE_DISABLE;                //不使用FIFO
    _dma_tx.Init.MemBurst = DMA_MBURST_SINGLE;                    //存储器单次突发传输
    _dma_tx.Init.PeriphBurst = DMA_PBURST_SINGLE;                //外设突发单次传输
    _dma_tx.Init.FIFOThreshold = DMA_FIFO_THRESHOLD_FULL;
    HAL_DMA_DeInit(&_dma_tx);                                    //先清除以前的设置
    HAL_DMA_Init(&_dma_tx);                                        //初始化DMA

    HAL_DMAEx_MultiBufferStart(&_dma_tx,
                               (uint32_t) _stm32_audio_play.tx_fifo,
                               (uint32_t) &SPI2->DR,
                               (uint32_t) _stm32_audio_play.tx_fifo + I2S_TX_DMA_FIFO_SIZE,
                               I2S_TX_DMA_FIFO_SIZE / 2);///开启双缓冲
    rt_thread_delay(20);
    __HAL_DMA_ENABLE_IT(&_dma_tx, DMA_IT_TC);                                     //开启传输完成中断
    HAL_NVIC_SetPriority(DMA1_Stream4_IRQn, 1, 0);    //DMA中断优先级
    HAL_NVIC_EnableIRQ(DMA1_Stream4_IRQn);
}

void audio_config_set(struct rt_audio_configure config) {
    audio_channel_set(config.channels);
    audio_samplebits_set(config.samplebits);
    audio_samplerate_set(config.samplerate);

}

rt_err_t audio_init() {
    audio_tx_dma();
    audio_config_init();
    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: {
                    break;
                }
                case AUDIO_MIXER_VOLUME: {
                    int volume = caps->udata.value;
                    st_audio->replay_volume = volume;
                    /* set mixer volume */
                    wm8978_HPvol_Set(volume, 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;
                    audio_config_set(config);
                    break;
                }

                case AUDIO_DSP_SAMPLERATE: {
                    st_audio->replay_config.samplerate = caps->udata.config.samplerate; /*设置采样率*/
                    audio_samplerate_set(caps->udata.config.samplerate);
                    break;
                }

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

                case AUDIO_DSP_SAMPLEBITS: {
                    st_audio->replay_config.samplebits = caps->udata.config.samplebits;
                    audio_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 wm8988 */
    audio_init();
    wm8978_init(CODEC_I2C_NAME, WM8978_ADDR);
    wm8978_cnf_init();
    wm8978_HPvol_Set(30, 30);              //耳机音量设置
    wm8978_SPKvol_Set(50);                     //喇叭音量设置
    wm8978_ADDA_Cfg(1, 0);             //开启DAC
    wm8978_Input_Cfg(0, 0, 0);//关闭输入通道
    wm8978_Output_Cfg(1, 0);         //开启DAC输出
    return RT_EOK;
}

static rt_err_t stm32_player_start(struct rt_audio_device *audio, int stream) {
    if (stream == AUDIO_STREAM_REPLAY) {
        __HAL_DMA_ENABLE(&_dma_tx);
    }
    return RT_EOK;
}

static rt_err_t stm32_player_stop(struct rt_audio_device *audio, int stream) {
    if (stream == AUDIO_STREAM_REPLAY) {
        __HAL_DMA_DISABLE(&_dma_tx);
        /* Clear all flags */
        __HAL_DMA_CLEAR_FLAG (&_dma_tx, __HAL_DMA_GET_TC_FLAG_INDEX(&_dma_tx));
        __HAL_DMA_CLEAR_FLAG (&_dma_tx, __HAL_DMA_GET_HT_FLAG_INDEX(&_dma_tx));
        __HAL_DMA_CLEAR_FLAG (&_dma_tx, __HAL_DMA_GET_TE_FLAG_INDEX(&_dma_tx));
        __HAL_DMA_CLEAR_FLAG (&_dma_tx, __HAL_DMA_GET_DME_FLAG_INDEX(&_dma_tx));
        __HAL_DMA_CLEAR_FLAG (&_dma_tx, __HAL_DMA_GET_FE_FLAG_INDEX(&_dma_tx));
    }
    return RT_EOK;
}

rt_ssize_t stm32_player_transmit(struct rt_audio_device *audio, const void *writeBuf, void *readBuf, rt_size_t size) {

    return (rt_ssize_t) size;
}

static void stm32_player_buffer_info(struct rt_audio_device *audio, struct rt_audio_buf_info *info) {
    /**
     *               TX_FIFO
     * +----------------+----------------+
     * |     block1     |     block2     |
     * +----------------+----------------+
     *  \  block_size  / \  block_size  /
     */
    info->buffer = _stm32_audio_play.tx_fifo;
    info->total_size = I2S_TX_DMA_FIFO_SIZE * 2;
    info->block_size = I2S_TX_DMA_FIFO_SIZE;
    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    = stm32_player_transmit,
                .buffer_info = stm32_player_buffer_info,
        };

int rt_hw_audio_init(void) {
    rt_uint8_t *tx_fifo;
    tx_fifo = rt_malloc(I2S_TX_DMA_FIFO_SIZE * 2);
    if (tx_fifo == RT_NULL) {
        return -RT_ENOMEM;
    }
    rt_memset(tx_fifo, 0, I2S_TX_DMA_FIFO_SIZE);
    _stm32_audio_play.tx_fifo = tx_fifo;
    _stm32_audio_play.audio.ops = &_p_audio_ops;
    rt_audio_register(&_stm32_audio_play.audio, I2S_SOUND_NAME, RT_DEVICE_FLAG_WRONLY, &_stm32_audio_play);
    return RT_EOK;
}

INIT_DEVICE_EXPORT(rt_hw_audio_init);
void DMA1_Stream4_IRQHandler(void) {
    rt_interrupt_enter();
    if (__HAL_DMA_GET_FLAG(&_dma_tx, DMA_FLAG_TCIF0_4) != RESET) //DMA传输完成
    {
        __HAL_DMA_CLEAR_FLAG(&_dma_tx, DMA_FLAG_TCIF0_4); //清除DMA传输完成中断标志位
        rt_audio_tx_complete(&_stm32_audio_play.audio); /*通知发送下一帧数据*/
    }
    rt_interrupt_leave();
}

IO口初始化

//I2S底层驱动，时钟使能，引脚配置
//此函数会被HAL_I2S_Init()调用
//hi2s:I2S句柄
void HAL_I2S_MspInit(I2S_HandleTypeDef *hi2s) {
    if (hi2s->Instance == SPI2) {
        GPIO_InitTypeDef GPIO_InitStruct;
        /* Peripheral clock enable */
        __HAL_RCC_SPI2_CLK_ENABLE();
        __HAL_RCC_GPIOC_CLK_ENABLE();
        __HAL_RCC_GPIOB_CLK_ENABLE();
        /**I2S2 GPIO Configuration
        PC2     ------> I2S2_ext_SD
        PC3     ------> I2S2_SD
        PB12     ------> I2S2_WS
        PB13     ------> I2S2_CK
        PC6     ------> I2S2_MCK
        */
        GPIO_InitStruct.Pin = GPIO_PIN_2;
        GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
        GPIO_InitStruct.Pull = GPIO_NOPULL;
        GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW;
        GPIO_InitStruct.Alternate = GPIO_AF6_I2S2ext;
        HAL_GPIO_Init(GPIOC, &GPIO_InitStruct);
        GPIO_InitStruct.Pin = GPIO_PIN_3|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_AF5_SPI2;
        HAL_GPIO_Init(GPIOC, &GPIO_InitStruct);
        GPIO_InitStruct.Pin = GPIO_PIN_12|GPIO_PIN_13;
        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);
    }
}

I2S测试

测试文件(参考官方)

#include <rtthread.h>
#include <rtdevice.h>
#include <dfs_posix.h>

#define BUFSZ   1024
#define SOUND_DEVICE_NAME    "sound0"    /* Audio 设备名称 */
static rt_device_t snd_dev;              /* Audio 设备句柄 */

struct RIFF_HEADER_DEF
{
    char riff_id[4];     // 'R','I','F','F'
    uint32_t riff_size;
    char riff_format[4]; // 'W','A','V','E'
};

struct WAVE_FORMAT_DEF
{
    uint16_t FormatTag;
    uint16_t Channels;
    uint32_t SamplesPerSec;
    uint32_t AvgBytesPerSec;
    uint16_t BlockAlign;
    uint16_t BitsPerSample;
};

struct FMT_BLOCK_DEF
{
    char fmt_id[4];    // 'f','m','t',' '
    uint32_t fmt_size;
    struct WAVE_FORMAT_DEF wav_format;
};

struct DATA_BLOCK_DEF
{
    char data_id[4];     // 'R','I','F','F'
    uint32_t data_size;
};

struct wav_info
{
    struct RIFF_HEADER_DEF header;
    struct FMT_BLOCK_DEF   fmt_block;
    struct DATA_BLOCK_DEF  data_block;
};

int wavplay_sample(int argc, char **argv)
{
    int fd = -1;
    uint8_t *buffer = NULL;
    struct wav_info *info = NULL;
    struct rt_audio_caps caps = {0};
    if (argc != 2)
    {
        rt_kprintf("Usage:\n");
        rt_kprintf("wavplay_sample song.wav\n");
        return 0;
    }
    fd = open(argv[1], O_RDONLY);
    if (fd < 0)
    {
        rt_kprintf("open file failed!\n");
        goto __exit;
    }
    buffer = rt_malloc(BUFSZ);
    if (buffer == RT_NULL)
        goto __exit;
    info = (struct wav_info *) rt_malloc(sizeof * info);
    if (info == RT_NULL)
        goto __exit;
    if (read(fd, &(info->header), sizeof(struct RIFF_HEADER_DEF)) <= 0)
        goto __exit;
    if (read(fd, &(info->fmt_block),  sizeof(struct FMT_BLOCK_DEF)) <= 0)
        goto __exit;
    if (read(fd, &(info->data_block), sizeof(struct DATA_BLOCK_DEF)) <= 0)
        goto __exit;
    rt_kprintf("wav information:\n");
    rt_kprintf("samplerate %d\n", info->fmt_block.wav_format.SamplesPerSec);
    rt_kprintf("channel %d\n", info->fmt_block.wav_format.Channels);
    /* 根据设备名称查找 Audio 设备，获取设备句柄 */
    snd_dev = rt_device_find(SOUND_DEVICE_NAME);
    /* 以只写方式打开 Audio 播放设备 */
    rt_device_open(snd_dev, RT_DEVICE_OFLAG_WRONLY);
    /* 设置采样率、通道、采样位数等音频参数信息 */
    caps.main_type               = AUDIO_TYPE_OUTPUT;                           /* 输出类型（播放设备 ）*/
    caps.sub_type                = AUDIO_DSP_PARAM;                             /* 设置所有音频参数信息 */
    caps.udata.config.samplerate = info->fmt_block.wav_format.SamplesPerSec;    /* 采样率 */
    caps.udata.config.channels   = info->fmt_block.wav_format.Channels;         /* 采样通道 */
    caps.udata.config.samplebits = 16;                                          /* 采样位数 */
    rt_device_control(snd_dev, AUDIO_CTL_CONFIGURE, &caps);

    while (1)
    {
        int length;

        /* 从文件系统读取 wav 文件的音频数据 */
        length = read(fd, buffer, BUFSZ);

        if (length <= 0)
            break;

        /* 向 Audio 设备写入音频数据 */
        rt_device_write(snd_dev, 0, buffer, length);
    }

    /* 关闭 Audio 设备 */
    rt_device_close(snd_dev);

    __exit:

    if (fd >= 0)
        close(fd);

    if (buffer)
        rt_free(buffer);

    if (info)
        rt_free(info);

    return 0;
}

//MSH_CMD_EXPORT(wavplay_sample,  play wav file);

int main() {
    rt_thread_mdelay(1000); // 防止sd卡还未自动挂载
    char *par[2] = {
            "wavplay_sample",
            "/music/whans-maidt.wav"
    };
    wavplay_sample(2, par);
    while (1) {

        rt_thread_delay(1000);
    }
}

结尾

  1. 在stm32f407zgt6板子上测试没有问题
詩不诉卿
关注
  • 37
    点赞
  • 踩
  • 9
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
ESP32设备驱动-I2S播放音频（使用MAX98357A放大器）
视觉与物联智能
06-28 3508
本文将详细介绍如何使用ESP32的I2S接口通过MAX98357A进行音频播放。
linuxmini2440I2S驱动
10-09 1018
要写I2S驱动，对于硬件也要了解。I2S是一种常用的数字音频接口。总线值处理音频数据，像编码和控制这样的其他信号被转移分开。I2S接口传输或者接受声音数据来自于外部立体声音频编码器。用于传输和接受数据，包括两个32x16FIFO数据结构。 总线特征： 2通道I2S总线用于DM
armlinux学习笔记--IIS音频驱动程序详解
09-16
armlinux IIs音频驱动 UDA1341
音乐播放器之在RTT下AUDIO驱动实现(一)
lyf_9705的博客
11-26 1187
rtthread 驱动框架 Audio
stm32之hal库i2s驱动的封装记录
scl8295的博客
05-07 359
【代码】stm32之hal库i2s驱动的封装记录。
rt-thread组件之audio组件(结合mp3player包使用)
scl8295的博客
03-12 640
前言 继上一篇RT-Thread组件之Audio框架i2s驱动的编写的编写，应用层使用rt-thread软件包里面的wavplayer组件 以及 rt-thread组件之audio组件(结合wavplayer包使用)的文章 本篇使用的是 mp3player软件包，与wavplayer设计框架基本上是一样的，只有在处理数据上存在差异。 在和rt-thread的版本上也存在类似的兼容问题(处理方案，参照上一篇) mp3player软件包还依赖mp3的解码包 底层驱动一样用的是i2s驱动 mp3player软
WinCE基于I2S总线的单体音频驱动开发（UDA1341）
疯子之徒
04-09 3372
本文转载自网络，但作者不详，如作者看到，请通知本人，本人会马上注明详细出处，谢谢。  1 音频驱动程序模型    本音频驱动采用Wavedev2模式来实现，这是单层的驱动模式，平台相关的都在hwctxt.h和hwctxt.cpp中，此外还加入了midi支持、software mixer支持、S/PDIF接口、gain class接口、forcespeaker接口，等等，因此，开发Sma
I2S时序及音频驱动
qq_41882586的博客
08-15 2313
I2S、音频驱动
RT-thread+GD32F450+i2c
04-07
RT-thread提供了软件模拟的I2C驱动（soft I2C），这意味着即使硬件不直接支持I2C，我们也能通过GPIO引脚模拟出I2C通信协议。在RT-thread中，I2C驱动通常被封装为一个设备驱动模型，可以通过标准的设备操作接口进行...
rt-thread mcp2515驱动程序参考
11-01
RT-Thread MCP2515驱动程序是专为在嵌入式系统中实现SPI到CAN（Controller Area Network）转换而设计的。MCP2515是一款由Microchip Technology公司生产的CAN控制器，它通过SPI（Serial Peripheral Interface）接口与...
基于RT-Thread的ST7735S屏幕驱动设计源码
最新发布
05-28
本项目是基于RT-Thread的ST7735S屏幕驱动设计源码，包含2572个文件，其中包括1002个H头文件、977个C源文件、90个S源文件、56个MK文件、35个Markdown文档、34个Python源文件、29个TXT文本文件、14个C++源文件、9个...
AR9331 I2S驱动程序源码
02-27
AR9331 I2S Linux 驱动程序源码
I2S——MP3播放器
12-18
利用stm32f407和SD卡， 通过i2s协议做一个MP3播放器。
【RT-Thread】基于Sensor框架TMP1075温度传感器驱动软件包
01-06
  tmp1075 软件包是基于RT-Thread sensor框架实现的一个驱动包。基于该软件包，RT-Thread应用程序可以使用标准的sensor接口访问tmp1075，获取传感器数据。 1.1 目录结构 名称 说明 docs 文档目录 ...
正点原子4.8寸LCD—RT-thread驱动.rar
08-17
RT-Thread遵循统一的设备驱动框架，通过HAL（Hardware Abstraction Layer，硬件抽象层）与底层硬件进行交互，使得上层应用可以独立于具体的硬件平台。对于LCD驱动，我们主要关注LCD控制器的初始化、帧缓冲管理以及...
I2S 总线学习：I2S驱动WM8978
Open_The_World的博客
11-11 2298
背景 为了了解I2S总线所对应的硬件设计，下文转载了《STM32：I2S驱动WM8978》。 以加深对I2S总线的了解。 正文 最近项目中使用STM32F4驱动音频IC：WM8978。 由于STM32的I2S接口只有一个数据引脚，因此在设计引脚的时候，就需要确定是录音还是放音。 WM8978为DAC+ADC芯片，本身并不具备编解码的功能。 1）WM8978可通过I2S接口接收PCM数据，转为模拟信号输出，此为DAC过程，即放音； 2）WM8978可接收模拟信号转为数字信号，通过I2S接口传输给
STM32H743VIT6使用STM32CubeMX通过I2S驱动WM8978（4）
phmatthaus的专栏
04-13 744
STM32H743VIT6使用STM32CubeMX通过I2S驱动WM8978（4）
STM32H7使用CubeMX生成的I2S驱动存在BUG
weixin_42383961的博客
04-29 1767
V6.2.0版本的CubeMX在配置H7芯片的I2S通信引脚存在配置错误的BUG
Linux下的I2S驱动学习
格物致知的专栏 [音视频编解码 网络协议 计算机视觉 计算机图形学 图像理解 语音识别 机器学习 模拟电路 传感器]
02-26 1336
snd_soc_register_dais函数显示为每个snd_soc_dai实例分配内存，确定dai的名字，用snd_soc_dai_driver实例的字段对它进行必要初始化，最后把该dai链接到全局链表dai_list中。2.在对应的platform_driver中的probe回调中通过API：snd_soc_register_dai或者snd_soc_register_dais，注册snd_soc_dai实例；LRCK为“1”表示正在传输的是右声道的数据，为“0”则表示正在传输的是左声道的数据。
DW_apb_i2c rt-thread驱动源码
06-09
DW_apb_i2c在RT-Thread实时操作系统中也有对应的驱动程序。下面是DW_apb_i2c在RT-Thread中的驱动源码链接： https://github.com/RT-Thread/rt-thread/tree/master/drivers/i2c/dw_i2c 该驱动程序基于RT-Thread的I2C驱动框架进行实现，支持DW_apb_i2c IP核的读写操作。该驱动程序的实现比较简单，主要包括初始化、读写数据等功能，适用于嵌入式系统中的I2C通信应用。 需要注意的是，RT-Thread的DW_apb_i2c驱动程序可能会因RT-Thread版本、处理器架构或DW_apb_i2c IP核版本等因素而有所不同。因此，在使用该驱动程序时，需要根据具体的环境和需求进行适当的调整。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

詩不诉卿

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值