开启辅助访问

amobbs.com 阿莫电子技术论坛

登录 注册 找回密码
搜索
amobbs.com 阿莫电子技术论坛»论坛首页 › 商业论坛 › 正点原子 › 《DNK210使用指南 -SDK版 V1.0》第二十三章 音频播放实 ...
bottom↓
返回列表 发新帖
回复: 0

《DNK210使用指南 -SDK版 V1.0》第二十三章 音频播放实验

[复制链接]
正点原子

出0入234汤圆
发表于 3 小时前 | 显示全部楼层 |阅读模式
2.jpg
1）实验平台：正点原子DNK210开发板
2）购买链接：https://detail.tmall.com/item.htm?id=782801398750
3）全套实验源码+手册+视频下载地址：http://openedv.com/thread-348335-1-1.html
4）正点原子官方B站：https://space.bilibili.com/394620890
5）正点原子手把手教你学DNK210快速入门视频教程：https://www.bilibili.com/video/BV1kD421G7fu
6）正点原子FPGA交流群：132780729 1.png
3.png

第二十三章 音频播放实验


       本章将介绍如何使用Kendryte K210的I2S功能，并将SD卡的音频数据通过I2S传输到扬声器实现音频的播放。通过学习本章内容，读者将掌握利用SDK编程技术实现wav音频解码并播放的方法。
       本章分为如下几个小节：
       23.1 WAV和I2S简介
       23.2 硬件设计
       23.3 程序设计
       23.4 运行验证

       23.1 WAV和I2S简介

       23.1.1 WAV简介
       WAV即WAVE文件，WAV是计算机领域最常用的数字化声音文件格式之一，它是微软专门为Windows系统定义的波形文件格式（Waveform Audio），由于其扩展名为"*.wav"。它符合RIFF(Resource Interchange File Format)文件规范，用于保存Windows平台的音频信息资源，被Windows平台及其应用程序所广泛支持，该格式也支持MSADPCM，CCITT A LAW 等多种压缩运算法，支持多种音频数字，取样频率和声道，标准格式化的WAV文件和CD格式一样，也是44.1K的取样频率，16 位量化数字，因此在声音文件质量和CD相差无几！
       WAV一般采用线性PCM（脉冲编码调制）编码，本章，我们也主要讨论PCM的播放，因为这个最简单。
       WAV 文件是由若干个Chunk组成的。按照在文件中的出现位置包括：RIFF WAVE Chunk、Format Chunk、 Fact Chunk(可选)和Data Chunk。每个Chunk由块标识符、数据大小和数据三部分组成，如图 23.1.1.1 所示：

第二十三章 音频播放实验673.png
图23.1.1.1 Chunk组成结构

       对于一个基本的WAVE文件而言，以下三种Chunk是必不可少的：文件中第一个Chunk是RIFF Chunk，然后是FMT Chunk，最后是Data Chunk。对于其他的Chunk，顺序没有严格的限制。使用WAVE文件的应用程序必须具有读取以上三种chunk信息的能力，如果程序想要复制WAVE文件，必须拷贝文件中所有的chunk。本章，我们主要讨论PCM，因为这个最简单，它只包含3个Chunk，我们看一下它的文件构成，如图23.1.2。

第二十三章 音频播放实验918.png
图23.1.2 PCM格式的wav文件构成

       可以看到，不同的Chunk有不同的长度，编码文件时，按照Chunk的字节和位序排列好之后写入文件头，加上wav的后缀，就可以生成一个能被正确解析的wav文件了，对于PCM结构，我们只需要把获取到的音频数据填充到Data Chunk中即可。我们将利用VS1053实现16位，8Khz采样率的单声道WAV录音(PCM格式)。
       首先，我们来看看RIFF块（RIFF WAVE Chunk），该块以“RIFF”作为标示，紧跟wav文件大小（该大小是wav文件的总大小-8），然后数据段为“WAVE”，表示是wav文件。RIFF块的Chunk结构如下：
  1. typedef __PACKED_STRUCT
  2. {
  3.     uint32_t ChunkID;                /* chunk id;这里固定为"RIFF",即0X46464952 */
  4.     uint32_t ChunkSize ;           /* 集合大小;文件总大小-8 */
  5.     uint32_t Format;               /* 格式;WAVE,即0X45564157 */
  6. }ChunkRIFF;     /* RIFF块 */
复制代码
       接着，我们看看Format块（Format Chunk），该块以“fmt”作为标示（注意有个空格！），一般情况下，该段的大小为16个字节，但是有些软件生成的wav格式，该部分可能有18个字节，含有2个字节的附加信息。Format块的Chunk结构如下：
  1. typedef __PACKED_STRUCT
  2. {
  3.     uint32_t ChunkID;                 /* chunk id;这里固定为"fmt ",即0X20746D66 */
  4.     uint32_t ChunkSize ;              /* 子集合大小(不包括ID和Size);这里为:20. */
  5.     uint16_t AudioFormat;              /* 音频格式;0X01,表示线性PCM;0X11表示IMA ADPCM */
  6.     uint16_t NumOfChannels;           /* 通道数量;1,表示单声道;2,表示双声道; */
  7.     uint32_t SampleRate;               /* 采样率;0X1F40,表示8Khz */
  8.     uint32_t ByteRate;                 /* /字节速率; */
  9.     uint16_t BlockAlign;               /* 块对齐(字节); */
  10.     uint16_t BitsPerSample;            /* 单个采样数据大小;4位ADPCM,设置为4 */
  11. //  uint16_t ByteExtraData;            /* 附加的数据字节;2个; 线性PCM,没有这个参数 */
  12. }ChunkFMT;    /* fmt块 */
复制代码
       接下来，我们再看看Fact块（Fact Chunk），该块为可选块，以“fact”作为标示，不是每个WAV文件都有，在非PCM格式的文件中，一般会在Format结构后面加入一个Fact块，该块Chunk结构如下：
  1. typedef __PACKED_STRUCT
  2. {
  3.     uint32_t ChunkID;                   /* chunk id;这里固定为"fact",即0X74636166; */
  4.     uint32_t ChunkSize;                /* 子集合大小(不包括ID和Size);这里为:4. */
  5.     uint32_t NumOfSamples;              /* 采样的数量; */
  6. }ChunkFACT;    /* fact块 */
复制代码
       DataFactSize是这个Chunk中最重要的数据，如果这是某种压缩格式的声音文件，那么从这里就可以知道他解压缩后的大小。对于解压时的计算会有很大的好处！不过本章我们使用的是PCM格式，所以不存在这个块。
       最后，我们来看看数据块（Data Chunk），该块是真正保存wav数据的地方，以“data”作为该Chunk的标示，然后是数据的大小。数据块的Chunk结构如下：
  1. typedef __PACKED_STRUCT
  2. {
  3.     uint32_t ChunkID;                 /* chunk id;这里固定为"data",即0X5453494C */
  4.     uint32_t ChunkSize ;              /* 子集合大小(不包括ID和Size) */
  5. }ChunkDATA;     /* data块 */
复制代码
       ChunkSize后紧接着就是wav数据。根据Format Chunk中的声道数以及采样bit数，wav数据的bit位置可以分成如表23.1.1.1所示的几种形式：

1.png
表23.1.1.1 WAVE文件数据采样格式

       本章，我们播放的音频支持：16位和24位，立体声，所以每个取样为4/6个字节，低字节在前，高字节在后。在得到这些wav数据以后，通过I2S丢给ES8388，就可以欣赏音乐了。

       23.1.2 I2S简介
       I2S(Inter IC Sound)总线, 又称集成电路内置音频总线，是飞利浦公司为数字音频设备之间的音频数据传输而制定的一种总线标准，该总线专责于音频设备之间的数据传输，广泛应用于各种多媒体系统。它采用了沿独立的导线传输时钟与数据信号的设计，通过将数据和时钟信号分离，避免了因时差诱发的失真，为用户节省了购买抵抗音频抖动的专业设备的费用。
       Kendryte K210的I2S功能非常强大，集成电路内置音频总线共有3个(I2S0、I2S1、I2S2)，都是MASTER模式。其中I2S0支持可配置连接语音处理模块，实现语音增强和声源定向的功能。下面是一些共有的特性：
       1. 总线宽度可配置为8，16，和32位
       2. 每个接口最多支持4个立体声通道
       3. 由于发送器和接收器的独立性，所以支持全双工通讯
       4. APB总线和I2S SCLK的异步时钟
       5. 音频数据分辨率为12,16,20,24 和 32 位
       6. I2S0发送FIFO深度为64字节,接收为8字节，I2S1和I2S2的发送和接收FIFO深度都为8字节
       7. 支持DMA传输
       6. 可编程FIFO阈值
       Kendryte K210官方SDK提供了多个操作I2S接口的函数，这里我们只讲述本实验用到的函数，这些函数介绍如下：

       1，i2s_init函数
       该函数主要用于I2S的配置初始化，该函数原型及参数描述如下代码所示：
  1. void i2s_init(i2s_device_number_t device_num, i2s_transmit_t rxtx_mode, uint32_t channel_mask);
  2. /* I2S配总线号配置参数 */
  3. typedef enum _i2s_device_number
  4. {
  5.     I2S_DEVICE_0 = 0,
  6.     I2S_DEVICE_1 = 1,
  7.     I2S_DEVICE_2 = 2,
  8.     I2S_DEVICE_MAX
  9. } i2s_device_number_t;

  11. /* I2S工作模式配置参数 */
  12. typedef enum _i2s_transmit
  13. {
  14.     I2S_TRANSMITTER = 0,
  15.     I2S_RECEIVER = 1
  16. } i2s_transmit_t;
复制代码
       该函数共有三个配置参数，第一个为配置I2S总线号，Kendryte K210共有三个I2S总线，第二个为I2S工作模式，可配置为接收或发送模式，第三个是配置I2S通道掩码，通常配置：通道0:0x03,通道1：0x0C,通道2：0x30,通道3:0xC0。

       2，i2s_rx_channel_config函数
       该函数用于设置I2S接收通道参数，该函数原型及参数描述如下代码所示：
  1. void i2s_rx_channel_config(i2s_device_number_t device_num,
  2.                            i2s_channel_num_t channel_num,
  3.                            i2s_word_length_t word_length,
  4.                            i2s_word_select_cycles_t word_select_size,
  5.                            i2s_fifo_threshold_t trigger_level,
  6.                            i2s_work_mode_t word_mode);
  7. /* I2S通道号配置参数 */
  8. typedef enum _i2s_channel_num
  9. {
  10.     I2S_CHANNEL_0 = 0,
  11.     I2S_CHANNEL_1 = 1,
  12.     I2S_CHANNEL_2 = 2,
  13.     I2S_CHANNEL_3 = 3
  14. } i2s_channel_num_t;

  16. /* I2S接收数据位数配置参数 */
  17. typedef enum _word_length
  18. {
  19.     /* Ignore the word length */
  20.     IGNORE_WORD_LENGTH = 0x0,
  21.     /* 12-bit data resolution of the receiver */
  22.     RESOLUTION_12_BIT = 0x1,
  23.     /* 16-bit data resolution of the receiver */
  24.     RESOLUTION_16_BIT = 0x2,
  25.     /* 20-bit data resolution of the receiver */
  26.     RESOLUTION_20_BIT = 0x3,
  27.     /* 24-bit data resolution of the receiver */
  28.     RESOLUTION_24_BIT = 0x4,
  29.     /* 32-bit data resolution of the receiver */
  30.     RESOLUTION_32_BIT = 0x5
  31. } i2s_word_length_t;

  33. /* I2S单个数据时钟数配置参数 */
  34. typedef enum _word_select_cycles
  35. {
  36.     /* 16 sclk cycles */
  37.     SCLK_CYCLES_16 = 0x0,
  38.     /* 24 sclk cycles */
  39.     SCLK_CYCLES_24 = 0x1,
  40.     /* 32 sclk cycles */
  41.     SCLK_CYCLES_32 = 0x2
  42. } i2s_word_select_cycles_t;

  44. /*DMA触发时FIFO深度配置参数 */
  45. typedef enum _fifo_threshold
  46. {
  47.     /* Interrupt trigger when FIFO level is 1 */
  48.     TRIGGER_LEVEL_1 = 0x0,
  49.     /* Interrupt trigger when FIFO level is 2 */
  50.     TRIGGER_LEVEL_2 = 0x1,
  51.     /* Interrupt trigger when FIFO level is 3 */
  52.     TRIGGER_LEVEL_3 = 0x2,
  53.     /* Interrupt trigger when FIFO level is 4 */
  54.     TRIGGER_LEVEL_4 = 0x3,
  55.     /* Interrupt trigger when FIFO level is 5 */
  56.     TRIGGER_LEVEL_5 = 0x4,
  57.     /* Interrupt trigger when FIFO level is 6 */
  58.     TRIGGER_LEVEL_6 = 0x5,
  59.     /* Interrupt trigger when FIFO level is 7 */
  60.     TRIGGER_LEVEL_7 = 0x6,
  61.     /* Interrupt trigger when FIFO level is 8 */
  62.     TRIGGER_LEVEL_8 = 0x7,
  63.     /* Interrupt trigger when FIFO level is 9 */
  64.     TRIGGER_LEVEL_9 = 0x8,
  65.     /* Interrupt trigger when FIFO level is 10 */
  66.     TRIGGER_LEVEL_10 = 0x9,
  67.     /* Interrupt trigger when FIFO level is 11 */
  68.     TRIGGER_LEVEL_11 = 0xa,
  69.     /* Interrupt trigger when FIFO level is 12 */
  70.     TRIGGER_LEVEL_12 = 0xb,
  71.     /* Interrupt trigger when FIFO level is 13 */
  72.     TRIGGER_LEVEL_13 = 0xc,
  73.     /* Interrupt trigger when FIFO level is 14 */
  74.     TRIGGER_LEVEL_14 = 0xd,
  75.     /* Interrupt trigger when FIFO level is 15 */
  76.     TRIGGER_LEVEL_15 = 0xe,
  77.     /* Interrupt trigger when FIFO level is 16 */
  78.     TRIGGER_LEVEL_16 = 0xf
  79. } i2s_fifo_threshold_t;

  81. /* I2S工作模式配置参数 */
  82. typedef enum _i2s_work_mode
  83. {
  84.     STANDARD_MODE = 1,
  85.     RIGHT_JUSTIFYING_MODE = 2,
  86.     LEFT_JUSTIFYING_MODE = 4
  87. } i2s_work_mode_t;

复制代码
       该函数涉及6个参数，参数可配置选项上面结构体中已列出，大家根据自己需要配置即可，这里不再详细介绍。

       3，i2s_tx_channel_config函数
       该函数用于设置I2S发送通道参数，该函数原型及参数描述如下代码所示：
  1. void i2s_tx_channel_config(i2s_device_number_t device_num,
  2.                            i2s_channel_num_t channel_num,
  3.                            i2s_word_length_t word_length,
  4.                            i2s_word_select_cycles_t word_select_size,
  5.                            i2s_fifo_threshold_t trigger_level,
  6.                            i2s_work_mode_t word_mode);
复制代码
       该函数可配置6个参数，参数可配置选项和接收通道相同，大家根据自己需要配置即可。

       4，i2s_play函数
       该函数用来发送PCM数据，比如音乐播放，该函数原型及参数描述如下所示：
  1. void i2s_play(i2s_device_number_t device_num, dmac_channel_number_t channel_num,
  2.               const uint8_t *buf, size_t buf_len, size_t frame, size_t bits_per_sample, uint8_t track_num);

  4. /* 发送PCM数据的DMA通道配置参数 */
  5. typedef enum _dmac_channel_number
  6. {
  7.     DMAC_CHANNEL0 = 0,
  8.     DMAC_CHANNEL1 = 1,
  9.     DMAC_CHANNEL2 = 2,
  10.     DMAC_CHANNEL3 = 3,
  11.     DMAC_CHANNEL4 = 4,
  12.     DMAC_CHANNEL5 = 5,
  13.     DMAC_CHANNEL_MAX
  14. } dmac_channel_number_t;
复制代码
       函数共有7个参数，分别配置I2S总线号、DMA通道号、PCM数据、PCM数据长度、单次发送数量，单次采样位宽和声道数。

       6，i2s_receive_data_dma函数
       该函数的功能是从DMA读取PCM数据，函数原型如下所示：
  1. void i2s_receive_data_dma(i2s_device_number_t device_num, uint32_t *buf, size_t buf_len, dmac_channel_number_t channel_num);
复制代码
       函数共有四个参数，第一个参数是选择总线号，第二个参数是接收数据的地址，第三个参数是接收数据的长度，第四个参数是DMA通道号。

       7，i2s_send_data_dma函数
       该函数的功能是通过DMA发送PCM数据，并等待DMA完成，函数原型如下所示：
  1. void i2s_send_data_dma(i2s_device_number_t device_num, const void *buf, size_t buf_len, dmac_channel_number_t channel_num);
复制代码
       函数共有四个参数，第一个参数是选择总线号，第二个参数是要发送的数据地址，第三个参数是发送数据的长度，第四个参数是DMA通道号。

       23.2 硬件设计

       23.2.1 例程功能

       1.开发板开机上电后自动播放SD卡目录MUSIC文件夹的play.wav音频文件（提前将音频文件拷贝到SD卡根目录的MUSIC文件夹中）， LCD模块显示播放总时间和当前播放时间，播放完成后程序退出。

       23.2.2 硬件资源

       1. 扬声器与功放连接
              扬声器正极 - VoP
              扬声器负极 - VoN

       2. 数字功放NS4168
              SPK_CTRL - IO21
              IIS_SDOUT - IO31
              IIS_BCK - IO32
              IIS_LRCK - IO33

       3. LCD
              LCD_RD - IO34
              LCD_BL - IO35
              LCD_CS - IO36
              LCD_RST - IO37
              LCD_RS - IO38
              LCD_WR - IO39
              LCD_D0~LCD_D7 - SPI0_D0~SPI0_D7

       23.2.3 原理图
       本章实验内容，需要解析文件系统中的WAV文件，然后将音频数据通过I2S接口发送到数字功放NS4168，随后NS4168便可根据配置，控制板载的扬声器发声。
       DNK210开发板上的数字功放NS4168的连接原理图，如下图所示：

第二十三章 音频播放实验9640.png
图23.2.3.1 数字功放NS4168连接原理图

       关于数字功放NS4168的使用方法，可参考NS4168的数据手册，NS4168的数据手册可通过网站获取，网址为：http://www.nsiway.com.cn/product/18.html。
       这里简单对NS4168的CTRL引脚进行说明，当CTRL引脚上的电压为0V~0.4V时，NS4168处于低功耗关断状态，当CTRL引脚上的电压为0.9V~1.15V时，NS4168控制扬声器播放I2S接口接收到音频数据中的左声道数据，当CTRL引脚上的电压为1.5V~VDD时，NS4168控制扬声器播放I2S接口接收到的音频数据中的右声道数据。

       23.3 程序设计

       23.3.1 speaker驱动代码
       本实验是通过I2S将数据输入到数字功放实现音频的播放，数字功放也需要相应的驱动代码进行配置，驱动源码包括两个文件：speaker.c和speaker.h，我们先介绍speaker.h文件的内容。
  1. /*****************************HARDWARE-PIN*********************************/
  2. /* 硬件IO口，与原理图对应 */
  3. #define PIN_SPK_CTRL           (21)

  5. #define PIN_SPK_WS             (33)
  6. #define PIN_SPK_DATA           (31)
  7. #define PIN_SPK_BCK            (32)

  9. /*****************************SOFTWARE-GPIO********************************/
  10. /* 软件GPIO口，与程序对应 */
  11. #define SPK_CTRL_GPIONUM       (0)

  13. /*****************************FUNC-GPIO************************************/
  14. /* GPIO口的功能，绑定到硬件IO口 */
  15. #define FUNC_SPK_CTRL          (FUNC_GPIO0 + SPK_CTRL_GPIONUM)

  17. #define FUNC_SPK_WS            FUNC_I2S0_WS
  18. #define FUNC_SPK_DATA          FUNC_I2S0_OUT_D0
  19. #define FUNC_SPK_BCK           FUNC_I2S0_SCLK
复制代码
       这个是驱动引脚功能的绑定，根据原理图可知，IO21为控制数字功放的引脚，用普通GPIO功能即可，其他三个为I2S功能引脚，I2S数据引脚配置为输出即可。
       下面看speaker.c文件代码。
  1. void speaker_i2s_hardware_init(void)
  2. {
  3.     /* I2S 初始化 */
  4.     gpio_init();    /* 使能GPIO的时钟 */
  5.     fpioa_set_function(PIN_SPK_CTRL, FUNC_SPK_CTRL);
  6.     fpioa_set_function(PIN_SPK_WS, FUNC_SPK_WS);
  7.     fpioa_set_function(PIN_SPK_DATA, FUNC_SPK_DATA);
  8.     fpioa_set_function(PIN_SPK_BCK, FUNC_SPK_BCK);

  10.     gpio_set_drive_mode(SPK_CTRL_GPIONUM, GPIO_DM_OUTPUT);  /*输出模式*/
  11.     gpio_set_pin(SPK_CTRL_GPIONUM, GPIO_PV_HIGH);  /*输出为高，使能扬声器输出*/
  12. }
复制代码
       可以看到，普通GPIO功能使用前需要进行GPIO使能，然后绑定引脚功能，最后将控制引脚拉高，使能数字功放输出。

       23.3.2 wavplay代码
       wavpaly主要用于wav格式的音频文件解码，接下来看看wavplay.c里面的几个函数，代码如下：
  1. /**
  2. * @brief       WAV解析初始化
  3. * @param       fname : 文件路径+文件名
  4. * @param       wavx  : 信息存放结构体指针
  5. * @retval      0,打开文件成功
  6. *              1,打开文件失败
  7. *              2,非WAV文件
  8. *              3,DATA区域未找到
  9. */
  10. uint8_t wav_decode_init(uint8_t* fname, __wavctrl* wavx)
  11. {
  12.     FIL *ftemp;
  13.     uint8_t *buf;
  14.     uint32_t br = 0;
  15.     uint8_t res = 0;

  17.     ChunkRIFF *riff;
  18.     ChunkFMT *fmt;
  19.     ChunkFACT *fact;
  20.     ChunkDATA *data;
  21.    
  22.     ftemp = (FIL*)iomem_malloc(sizeof(FIL));
  23.     buf = iomem_malloc(512);

  25.     if (ftemp && buf)    /* 内存申请成功 */
  26.     {
  27.         res = f_open(ftemp, (TCHAR*)fname, FA_READ);    /* 打开文件 */
  28.         if (res==FR_OK)
  29.         {
  30.             f_read(ftemp, buf, 512, &br);               /* 读取512字节在数据 */
  31.             riff = (ChunkRIFF *)buf;                    /* 获取RIFF块 */
  32.             if (riff->Format == 0X45564157)             /* 是WAV文件 */
  33.             {
  34.                 fmt = (ChunkFMT *)(buf + 12);           /* 获取FMT块 */
  35.                 fact = (ChunkFACT *)(buf + 12 + 8 + fmt->ChunkSize);

  37.                 if (fact->ChunkID == 0X74636166 || fact->ChunkID == 0X5453494C)
  38.                 {
  39.                     wavx->datastart = 12 + 8 + fmt->ChunkSize + 8 + fact->
  40. ChunkSize;    /* 具有fact/LIST块的时候(未测试) */
  41.                 }
  42.                 else
  43.                 {
  44.                     wavx->datastart = 12 + 8 + fmt->ChunkSize;
  45.                 }

  47.                 data = (ChunkDATA *)(buf + wavx->datastart);    /* 读取DATA块 */

  49.                 if (data->ChunkID == 0X61746164)                /* 解析成功! */
  50.                 {
  51.                     wavx->audioformat = fmt->AudioFormat;       /* 音频格式 */
  52.                     wavx->nchannels = fmt->NumOfChannels;       /* 通道数 */
  53.                     wavx->samplerate = fmt->SampleRate;         /* 采样率 */
  54.                     wavx->bitrate = fmt->ByteRate * 8;          /* 得到位速 */
  55.                     wavx->blockalign = fmt->BlockAlign;         /* 块对齐 */
  56.                     wavx->bps = fmt->BitsPerSample;         /* 位数,16/24/32位 */
  57.                     
  58.                     wavx->datasize = data->ChunkSize;           /* 数据块大小 */
  59.                     wavx->datastart = wavx->datastart + 8;   /* 数据流开始的地方 */
  60.                      
  61.                     printf("wavx->audioformat:%d\r\n", wavx->audioformat);
  62.                     printf("wavx->nchannels:%d\r\n", wavx->nchannels);
  63.                     printf("wavx->samplerate:%d\r\n", wavx->samplerate);
  64.                     printf("wavx->bitrate:%d\r\n", wavx->bitrate);
  65.                     printf("wavx->blockalign:%d\r\n", wavx->blockalign);
  66.                     printf("wavx->bps:%d\r\n", wavx->bps);
  67.                     printf("wavx->datasize:%d\r\n", wavx->datasize);
  68.                     printf("wavx->datastart:%d\r\n", wavx->datastart);  
  69.                 }
  70.                 else
  71.                 {
  72.                     res = 3;    /* data区域未找到. */
  73.                 }
  74.             }
  75.             else
  76.             {
  77.                 res = 2;        /* 非wav文件 */
  78.             }
  79.         }
  80.         else
  81.         {
  82.             res = 1;            /* 打开文件错误 */
  83.         }
  84.     }

  86.     f_close(ftemp);             /* 关闭文件 */
  87.     printf("f_clase\n");
  88.     iomem_free(ftemp);          /* 释放内存 */
  89.     iomem_free(buf);

  91.     return 0;
  92. }

  94. /**
  95. * @brief       填充buf
  96. * @param       buf  : 填充区
  97. * @param       size : 填充数据量
  98. * @param       bits : 位数(16)
  99. * @retval      读取到的数据长度
  100. */
  101. uint32_t wav_buffill(uint8_t *buf, uint16_t size, uint8_t bits)
  102. {
  103.     uint32_t bread;
  104.     uint16_t i;

  106.     if (bits == 16)  
  107.     {
  108.         f_read(g_audiodev.file, buf, size, (UINT*)&bread);
  109.         if (bread < size)           /* 不够数据了,补充0 */
  110.         {
  111.             for(i = bread; i < size - bread; i++)
  112.             {
  113.                 buf = 0;
  114.             }
  115.         }
  116.     }

  118.     // else if (bits == 24)                 /* 24bit音频,需要处理一下 */
  119.     // }
  120.    
  121.     return bread;
  122. }

  124. /**
  125. * @brief       音频播放的buf填充
  126. * @param       无
  127. * @retval      无
  128. */
  129. void wav_play_buffill(void)
  130. {   
  131.     if(wavbuf1f1nish == 0 && wavplay == 1)
  132.     {  
  133.         fillnum = wav_buffill(g_audiodev.i2sbuf1, WAV_I2S_TX_DMA_BUFSIZE,
  134. wavctrl.bps);   /* 填充buf1 */
  135.         wavbuf1f1nish = 1;
  136.     }
  137.     else if (wavbuf2f1nish == 0 && wavplay == 0)
  138.     {
  139.         fillnum = wav_buffill(g_audiodev.i2sbuf2, WAV_I2S_TX_DMA_BUFSIZE,
  140. wavctrl.bps);   /* 填充buf1 */
  141.         wavbuf2f1nish = 1;
  142.     }
  143. }

  145. /**
  146. * @brief       I2S音频文件传输
  147. * @param       device_num : I2S总线号
  148. * @param       channel_num : DM通道号
  149. * @param       buf : PCM数据
  150. * @param       buf_len : 发送德数据长度
  151. * @param       frame : 单次发送的声音数据量
  152. * @param       bits_per_sample : 位宽
  153. * @param       track_num : 声道数
  154. * @retval      无
  155. */
  156. void i2s_pcm_play(i2s_device_number_t device_num, dmac_channel_number_t channel_num,
  157.               const uint8_t *buf, size_t buf_len, size_t frame, size_t bits_per_sample, uint8_t track_num)
  158. {
  159.     const uint8_t *trans_buf;
  160.     uint32_t i;
  161.     size_t sample_cnt = buf_len / (bits_per_sample / 8) / track_num;
  162.     size_t frame_cnt = sample_cnt / frame;
  163.     size_t frame_remain = sample_cnt % frame;
  164.     i2s_set_dma_divide_16(device_num, 0);

  166.     if(bits_per_sample == 16 && track_num == 2)
  167.     {
  168.         i2s_set_dma_divide_16(device_num, 1);
  169.         for(i = 0; i < frame_cnt; i++)
  170.         {
  171.             trans_buf = buf + i * frame * (bits_per_sample / 8) * track_num;  
  172. /* 按声音数量发送，一个声音大小和位数，声道相关 */
  173.             i2s_send_data_dma(device_num, trans_buf, frame, channel_num);
  174.             wav_play_buffill();
  175.         }
  176.         if(frame_remain)
  177.         {
  178.             trans_buf = buf + frame_cnt * frame * (bits_per_sample / 8) * track_num;
  179.             i2s_send_data_dma(device_num, trans_buf, frame_remain, channel_num);
  180.             wav_play_buffill();
  181.         }
  182.     }
  183. }

  185. /**
  186. * @brief       获取当前播放时间
  187. * @param       fname : 文件指针
  188. * @param       wavx  : wavx播放控制器
  189. * @retval      无
  190. */
  191. void wav_get_curtime(FIL *fx, __wavctrl *wavx)
  192. {
  193.     long long fpos;

  195.     wavx->totsec = wavx->datasize / (wavx->bitrate / 8);  /* 歌曲总长度(单位:秒) */
  196.     fpos = fx->fptr-wavx->datastart;                  /* 得到当前文件播放到的地方 */
  197.     wavx->cursec = fpos*wavx->totsec / wavx->datasize;   /* 当前播放到第多少秒了? */
  198. }

  200. /**
  201. * @brief       显示播放时间,比特率 信息
  202. * @param       totsec : 音频文件总时间长度
  203. * @param       cursec : 当前播放时间
  204. * @retval      无
  205. */
  206. void audio_msg_show(uint32_t totsec, uint32_t cursec)
  207. {
  208.     char datashow[35];
  209.     static uint16_t playtime = 0XFFFF;  /* 放时间标记 */
  210.    
  211.     if (playtime != cursec)             /* 需要更新显示时间 */
  212.     {
  213.         playtime = cursec;
  214.         
  215.         /* 显示播放时间 */
  216.         sprintf((char *)datashow, "Play time:%02d:%02d/%02d:%02d", playtime / 60, playtime % 60, totsec / 60, totsec % 60);
  217.         // lcd_draw_fill_rectangle(10 + 8 * 11, 30, 10 + 8 * 15, 30 + 16, WHITE);
  218.         // lcd_draw_string(10, 30, (char *)datashow, BLUE);    /* 显示SD卡容量 */
  219.         /* 显示字符的形式实在太慢了，会导致播放卡顿，所以用画图的形式显示 */
  220.         for (size_t i = 0; i < 320 * 16; i++)
  221.         {
  222. <span style="font-style: italic;"><span style="font-style: normal;">            lcd_gram = 0xFFFF;
  223.         }
  224.         draw_string_rgb565_image(lcd_gram, 320, 240, 10, 0, datashow, BLUE);
  225.         lcd_draw_picture(0, 30, 320, 16, (uint16_t *)lcd_gram);   
  226.     }
  227. }

  229. /**
  230. * @brief       播放某个wav文件
  231. * @param       fname : 文件路径+文件名
  232. * @retval      KEY0_PRES,错误
  233. *              KEY1_PRES,打开文件失败
  234. *              其他,非WAV文件
  235. */
  236. uint8_t wav_play_song(uint8_t* fname)
  237. {
  238.     uint8_t res;  
  239.    
  240.     g_audiodev.file = (FIL*)iomem_malloc(sizeof(FIL));
  241.     g_audiodev.i2sbuf1 = iomem_malloc(WAV_I2S_TX_DMA_BUFSIZE);
  242.     g_audiodev.i2sbuf2 = iomem_malloc(WAV_I2S_TX_DMA_BUFSIZE);
  243.     g_audiodev.tbuf = iomem_malloc(WAV_I2S_TX_DMA_BUFSIZE);
  244.    
  245.     if (g_audiodev.file && g_audiodev.i2sbuf1 && g_audiodev.i2sbuf2 && g_audiodev.tbuf)
  246.     {
  247.         res = wav_decode_init(fname, &wavctrl); /* 得到文件的信息 */
  248.         if (res == 0)   /* 解析文件成功 */
  249.         {
  250. /*初始化I2S，第三个参数为设置通道掩码，通道0:0x03,通道1：0x0C,通道2：0x30,通道3:0xC0*/
  251.             i2s_init(I2S_DEVICE_0, I2S_TRANSMITTER, 0x03);
  252.             if (wavctrl.bps == 16)
  253.             {
  254.                 /* 设置I2S发送数据的通道参数 */
  255.                 i2s_tx_channel_config(
  256.                     I2S_DEVICE_0, /* I2S设备号*/
  257.                     I2S_CHANNEL_0, /* I2S通道 */
  258.                     RESOLUTION_16_BIT, /* 接收数据位数 */
  259.                     SCLK_CYCLES_32, /* 单个数据时钟数 */
  260.                     TRIGGER_LEVEL_4, /* DMA触发时FIFO深度 */
  261.                     STANDARD_MODE); /* 工作模式 */
  262.             }
  263.             // else if (wavctrl.bps == 24) /* 暂不支持 */
  264.             // {

  266.             // }

  268.             res = f_open(g_audiodev.file, (TCHAR*)fname, FA_READ);  /* 打开文件 */
  269.             if (res == 0)
  270.             {
  271.                 f_lseek(g_audiodev.file, wavctrl.datastart);     /* 跳过文件头 */
  272.                 fillnum = wav_buffill(g_audiodev.i2sbuf1, WAV_I2S_TX_DMA_BUFSIZE, wavctrl.bps);
  273.                 // fillnum = wav_buffill(g_audiodev.i2sbuf2, WAV_I2S_TX_DMA_BUFSIZE, wavctrl.bps);
  274.                 wavbuf1f1nish = 1;
  275.                 wavbuf2f1nish = 0;
  276.                 wavplay = 0;
  277.                 while (1)
  278.                 {
  279.                     if (wavplay)
  280.                     {
  281.                         i2s_pcm_play(
  282.                         I2S_DEVICE_0, /* I2S设备号 */
  283.                         DMAC_CHANNEL1, /* DMA通道号 */
  284.                         (uint8_t *)g_audiodev.i2sbuf2, /* 播放的PCM数据 */
  285.                         WAV_I2S_TX_DMA_BUFSIZE, /* PCM数据的长度 */
  286.                         1024, /* 单次发送数量 */
  287.                         16, /* 单次采样位宽 */
  288.                         2); /* 声道数 */
  289.                         wavbuf2f1nish = 0;
  290.                         wavplay = 0;
  291.                     }
  292.                     else
  293.                     {
  294.                         i2s_pcm_play(
  295.                         I2S_DEVICE_0, /* I2S设备号 */
  296.                         DMAC_CHANNEL1, /* DMA通道号 */
  297.                         (uint8_t *)g_audiodev.i2sbuf1, /* 播放的PCM数据 */
  298.                         WAV_I2S_TX_DMA_BUFSIZE, /* PCM数据的长度 */
  299.                         1024, /* 单次发送数量 */
  300.                         16, /* 单次采样位宽 */
  301.                         2); /* 声道数 */
  302.                         wavbuf1f1nish = 0;
  303.                         wavplay = 1;
  304.                     }
  305.                     if (fillnum != WAV_I2S_TX_DMA_BUFSIZE)/*文件剩余不足，播放完束*/
  306.                     {
  307.                         dmac_wait_done(DMAC_CHANNEL0);
  308.                         printf("play end\n");
  309.                         break;
  310.                     }
  311.                     wav_get_curtime(g_audiodev.file, &wavctrl);   
  312. /* 得到总时间和当前播放的时间 */
  313.                     audio_msg_show(wavctrl.totsec, wavctrl.cursec);
  314.                 }
  315.             }
  316.             else
  317.             {
  318.                 res = 0XFF;
  319.             }
  320.         }
  321.         else
  322.         {
  323.             res = 0XFF;
  324.         }
  325.     }
  326.     else
  327.     {
  328.         res = 0XFF;
  329.     }
  330.     iomem_free(g_audiodev.tbuf);      /* 释放内存 */
  331.     iomem_free(g_audiodev.i2sbuf1);   /* 释放内存 */
  332.     iomem_free(g_audiodev.i2sbuf2);   /* 释放内存 */
  333.     iomem_free(g_audiodev.file);      /* 释放内存 */
  334.    
  335.     return res;
  336. }</span></span>
复制代码
       以上代码中，wav_decode_init函数，用来对wav音频文件进行解析，得到wav的详细信息（音频采样率，位数，数据流起始位置等）；wav_buffill函数，通过f_read读取数据，然后将数据填充到buf里面；wav_play_buffill函数则是播放过程中提前对将要播放的数据buf进行填充，这里，用wavbuf1f1nish和wavbuf2f1nish两个变量判断buf是否填充完成，变量wavplay指示当前播放的buf，通过这几个变量，我们就能在音频播放前处理buf数据，i2s_pcm_play函数是我们参考官方API函数编写，用于播放PCM数据。
       最后，wav_play_song函数，是播放WAV最终执行的函数，该函数解析完WAV文件后，设置I2S的参数（采样率，位数等），调用i2s_pcm_play开始播放，然后不断填充数据，实现WAV播放，播放完成后函数提示播放结束并退出。

       23.3.3 main.c代码
       main.c中的代码如下所示：
  1. char *pname = {"0: MUSIC/play.wav"};  

  3. int main(void)
  4. {
  5.     FRESULT res;
  6.     FATFS fs;

  8.     sysctl_pll_set_freq(SYSCTL_PLL0, 800000000);
  9.     sysctl_pll_set_freq(SYSCTL_PLL1, 400000000);
  10.     sysctl_pll_set_freq(SYSCTL_PLL2, 45158400);
  11.     sysctl_set_power_mode(SYSCTL_POWER_BANK6, SYSCTL_POWER_V18);
  12.     sysctl_set_power_mode(SYSCTL_POWER_BANK7, SYSCTL_POWER_V18);
  13.     sysctl_set_spi0_dvp_data(1);

  15.     speaker_i2s_hardware_init(); /* 扬声器接口初始化 */
  16.     /* 初始化中断，使能全局中断，初始化dmac */
  17.     plic_init();
  18.     sysctl_enable_irq();
  19.     dmac_init();
  20.     lcd_init();                             /* 初始化LCD */
  21.     lcd_set_direction(DIR_YX_LRUD);

  23.     lcd_draw_string(10, 10, "MUSIC ", RED);
  24.     /* 初始化SD卡*/
  25.     while (sd_init() != 0)                        /* 检查字库 */
  26.     {      
  27.         lcd_draw_string(10, 30, "SD Error!", BLUE); /* 提示SD卡错误 */
  28.         msleep(200);
  29.         lcd_draw_fill_rectangle(10, 30, 319, 50, WHITE);        /* 清除显示 */
  30.         msleep(200);
  31.     }

  33.     printf("SD card initialization succeed!\n");

  35.     /* 挂载SD卡 */
  36.     res = f_mount(&fs, _T("0:"), 1);
  37.     if (res != FR_OK)
  38.     {
  39.         printf("SD card mount failed! Error code: %d\n", res);
  40.         while (1);
  41.     }
  42.     printf("SD card mount succeed!\n");

  44.     wav_play_song((uint8_t *)pname);  /* 播放音频play.wav */
  45.     lcd_draw_string(10, 50, "End of play ", BLUE);
  46.     while (1)
  47.     {

  49.     }
  50. }
复制代码
       在main函数前面，我们定义了pname数组，用于存放音频文件的SD卡路径。main函数代码具体流程大致是：首先完成系统级和用户级初始化工作，挂载SD卡，挂载成功后播放SD卡根目录中文件名为pname中的wav文件，播放结束后LCD显示“End of play”。

       23.4 运行验证
       将DNK210开发板连接到电脑主机，通过VSCode将固件烧录到开发板中，程序启动后开始播放音频文件，可以看到LCD显示播放时间信息，LCD显示的内容如图23.4.1所示：

第二十三章 音频播放实验24325.png
图23.4.1音频播放中运行效果图

       等待音频播放结束，LCD提示播放结束信息，得到如图23.4.2所示：

第二十三章 音频播放实验24380.png
图23.4.2播放结束后的显示效果图
正点原子DNK210

阿莫论坛20周年了！感谢大家的支持与爱护！！

你熬了10碗粥，别人一桶水倒进去，淘走90碗，剩下10碗给你，你看似没亏，其实你那10碗已经没有之前的裹腹了，人家的一桶水换90碗，继续卖。说白了，通货膨胀就是，你的钱是挣来的，他的钱是印来的，掺和在一起，你的钱就贬值了。

相关帖子
回复

   举报本楼层   

返回列表 发新帖
回帖提示： 反政府言论将被立即封锁ID 。在按“提交”前，请自问一下：我这样表达会给举报吗，会给自己惹麻烦吗？ 另外：尽量不要使用Mark、顶等没有意义的回复。不得大量使用大字体和彩色字。【本论坛不允许直接上传手机拍摄图片，浪费大家下载带宽和论坛服务器空间，请压缩后（图片小于1兆）才上传。压缩方法可以在微信里面发给自己（不要勾选“原图），然后下载，就能得到压缩后的图片。注意：要连续压缩2次才能满足要求！！】。另外，手机版只能上传图片，要上传附件需要切换到电脑版（不需要使用电脑，手机上切换到电脑版就行，页面底部）。
高级模式
B Color Image Link Quote Code Smilies
您需要登录后才可以回帖 登录 | 注册

本版积分规则

手机版|Archiver|amobbs.com 阿莫电子技术论坛 ( 粤ICP备2022115958号, 版权所有：东莞阿莫电子贸易商行 创办于2004年 (公安交互式论坛备案：44190002001997 ) )

GMT+8, 2024-10-16 16:07

© Since 2004 www.amobbs.com, 原www.ourdev.cn, 原www.ouravr.com

快速回复 返回顶部 返回列表