esp32笔记[5]-基于I2S协议实现音频播放

/*
 * @Descripttion :  通过串口点播数字音频
 * @version      :  
 * @Author       : Kevincoooool
 * @Date         : 2021-05-25 09:20:06
 * @LastEditors: qsbye
 * @LastEditTime: 2023-06-27 12:00:18
 * @FilePath: appmain.c
 */

/*
ESP32-KSDIY的扬声器测试
音频与数组对照:
- voice_ling:零:0
- voice_yi:一:1
- voice_er:二:2
- voice_san:三:3
- voice_si:四:4
- voice_wu:五:5
- voice_liu:六:6
- voice_qi:七:7
- voice_ba:八:8
- voice_jiu:九:9
- voice_shi:十:10
- voice_bai:百:11
- voice_qian:千:12
- voice_wan:万:13
- voice_jia:加:14
- voice_jian:减:15
- voice_cheng:乘:16
- voice_chu:除:17
- voice_fu:负:18
- voice_dian:点:19
- voice_dengyu:等于:20
- voice_fenzhi:分之:21
PCM格式信息:
- 声道:1
- 采样率:16000
- 每秒数据字节数:32000
- 每个采样率所需字节数:2
- 单个采样位深:16
- 小端字节序:little-endian
ESP32烧录方式:
- SPI Flash Speed:40MHz
- SPI Mode:QIO
- 速率:921600
- 地址:0x0000(完整bin)
- 理论上两个C口都能烧录
串口引脚:
- USART0_RX:44
- USART0_TX:43
- 开发板使用J1接口才有串口输出
*/
#include <stdio.h>
#include "string.h"

#include "freertos/FreeRTOS.h"
#include "freertos/task.h"
#include "freertos/queue.h"
#include "freertos/semphr.h"
#include "esp_freertos_hooks.h"

#include "lv_examples/src/lv_demo_widgets/lv_demo_widgets.h"
#include "lv_examples/src/lv_demo_music/lv_demo_music.h"
#include "lv_examples/src/lv_demo_benchmark/lv_demo_benchmark.h"
#include "lvgl_helpers.h"

#include "esp_vfs.h"
#include "esp_spiffs.h"

#include "driver/gpio.h"
#include "driver/uart.h"
#include "driver/rmt.h"

#include "nvs_flash.h"
#include "app_main.h"
#include "mp3_player.h"

#define TAG "ESP32S3"
#define USART1_TXD_PIN (GPIO_NUM_43) //IO43
#define USART1_RXD_PIN (GPIO_NUM_44) //IO44

#define DEBUG 1

#ifdef uint8_t 
#define uint8_t unsigned char
#endif

/*开始全局变量*/
uint8_t voice_num_isr=22;//volatile用于ISR,串口调用语音播放
uint8_t voice_num_string_isr;//缓存接收到的ascii,下一步就是转换为数字
uint8_t voice_num_rec_complete=0;//接收完成标识位
static const int USART0_RX_BUF_SIZE = 1000;//usart0串口接收缓存区大小
int usart0_rx_buf_index=0;//usart0缓存区索引
/*结束全局变量*/

/*开始函数原型*/
void i2s_play(uint8_t voice_num);//i2s播放音频
void usart0_interrupt_callback();//串口0中断回调
static void usart0_rx_task(void *arg);//串口0接收任务
/*结束函数原型*/

/*用定时器给LVGL提供时钟*/
static void lv_tick_task(void *arg)
{
	(void)arg;
	lv_tick_inc(10);
}

SemaphoreHandle_t xGuiSemaphore;

static void gui_task(void *arg)
{
	xGuiSemaphore = xSemaphoreCreateMutex();
	lv_init(); // lvgl内核初始化

	lvgl_driver_init(); // lvgl显示接口初始化
	//申请两个buffer来给lvgl刷屏用  
	/*外部PSRAM方式*/
	// lv_color_t *buf1 = (lv_color_t *)heap_caps_malloc(DISP_BUF_SIZE * 2, MALLOC_CAP_SPIRAM | MALLOC_CAP_8BIT);
	// lv_color_t *buf2 = (lv_color_t *)heap_caps_malloc(DISP_BUF_SIZE * 2, MALLOC_CAP_SPIRAM | MALLOC_CAP_8BIT);

	/*内部DMA方式*/
	lv_color_t *buf1 = heap_caps_malloc(DISP_BUF_SIZE * sizeof(lv_color_t), MALLOC_CAP_DMA);
	lv_color_t *buf2 = heap_caps_malloc(DISP_BUF_SIZE * sizeof(lv_color_t), MALLOC_CAP_DMA);

	/*静态数组方式*/
	// static lv_color_t buf1[DISP_BUF_SIZE];
	// static lv_color_t buf2[DISP_BUF_SIZE];
	static lv_disp_buf_t disp_buf;
	uint32_t size_in_px = DISP_BUF_SIZE;
	lv_disp_buf_init(&disp_buf, buf1, buf2, size_in_px);

	lv_disp_drv_t disp_drv;
	lv_disp_drv_init(&disp_drv);
	disp_drv.flush_cb = disp_driver_flush;
	disp_drv.buffer = &disp_buf;
	lv_disp_drv_register(&disp_drv);
	/*触摸屏输入接口配置*/
	lv_indev_drv_t indev_drv;
	lv_indev_drv_init(&indev_drv);
	indev_drv.read_cb = touch_driver_read;
	indev_drv.type = LV_INDEV_TYPE_POINTER;
	lv_indev_drv_register(&indev_drv);

	// esp_register_freertos_tick_hook(lv_tick_task);
	/* 创建一个定时器中断来进入 lv_tick_inc 给lvgl运行提供心跳 这里是10ms一次 主要是动画运行要用到 */
	const esp_timer_create_args_t periodic_timer_args = {
		.callback = &lv_tick_task,
		.name = "periodic_gui"};
	esp_timer_handle_t periodic_timer;
	ESP_ERROR_CHECK(esp_timer_create(&periodic_timer_args, &periodic_timer));
	ESP_ERROR_CHECK(esp_timer_start_periodic(periodic_timer, 10 * 1000));

	// lv_demo_widgets();
	// lv_demo_music();
	// lv_demo_benchmark();
	// avi_player_load();

	while (1)
	{
		/* Delay 1 tick (assumes FreeRTOS tick is 10ms */
		vTaskDelay(pdMS_TO_TICKS(10));

		/* Try to take the semaphore, call lvgl related function on success */
		if (pdTRUE == xSemaphoreTake(xGuiSemaphore, portMAX_DELAY))
		{

			lv_task_handler();
			xSemaphoreGive(xGuiSemaphore);
		}
	}
}
/*显示spiffs的所有文件名*/
static void SPIFFS_Directory(char *path)
{
	DIR *dir = opendir(path);
	assert(dir != NULL);
	while (true)
	{
		struct dirent *pe = readdir(dir);
		if (!pe)
			break;
		ESP_LOGI(__FUNCTION__, "d_name=%s d_ino=%d d_type=%x", pe->d_name, pe->d_ino, pe->d_type);
	}
	closedir(dir);
}
extern char *Font_buff;
void app_main(void)
{	
	/*初始化spiffs用于存放字体文件或者图片文件或者网页文件或者音频文件*/
	ESP_LOGI(TAG, "Initializing SPIFFS");
	esp_vfs_spiffs_conf_t conf = {
		.base_path = "/spiffs",
		.partition_label = "storage",
		.max_files = 20,
		.format_if_mount_failed = false};
	esp_err_t ret = esp_vfs_spiffs_register(&conf);
	if (ret != ESP_OK)
	{
		if (ret == ESP_FAIL)
			ESP_LOGE(TAG, "Failed to mount or format filesystem");
		else if (ret == ESP_ERR_NOT_FOUND)
			ESP_LOGE(TAG, "Failed to find SPIFFS partition");
		else
			ESP_LOGE(TAG, "Failed to initialize SPIFFS (%s)", esp_err_to_name(ret));
		return;
	}
	/*显示spiffs里的文件列表*/
	SPIFFS_Directory("/spiffs/");

	// 初始化nvs用于存放wifi或者其他需要掉电保存的东西
	ret = nvs_flash_init();
	if (ret == ESP_ERR_NVS_NO_FREE_PAGES)
	{
		ESP_ERROR_CHECK(nvs_flash_erase());
		ret = nvs_flash_init();
	}
	ESP_ERROR_CHECK(ret);
	play_i2s_init();//初始化I2S播放
	//audio_play(1);//播放第一个文件

	xTaskCreate(usart0_rx_task, "usart0_rx_task", 1024 * 5, NULL, configMAX_PRIORITIES, NULL);//创建串口监听任务

	#ifdef DEBUG
	//play_spiffs_name("all.wav");//播放all.wav
	for(int j=0;j<21;j++){
		i2s_play(j);
	}
	printf("playing all.wav!\n");
	#endif


	/*创建lvgl任务显示*/
	//xTaskCreatePinnedToCore(&gui_task, "lvgl task", 1024 * 5, NULL, 5, NULL, 1);
}

/*开始函数本体*/
/*
根据数字点播音频
*/
void i2s_play(uint8_t voice_num) {
  switch (voice_num) {
    case 0: {
      play_spiffs_name("ling.wav"); // 0
      break;
    }
    case 1: {
      play_spiffs_name("yi.wav"); // 1
      break;
    }
    case 2: {
      play_spiffs_name("er.wav"); // 2
      break;
    }
    case 3: {
      play_spiffs_name("san.wav"); // 3
      break;
    }
    case 4: {
      play_spiffs_name("si.wav"); // 4
      break;
    }
    case 5: {
      play_spiffs_name("wu.wav"); // 5
      break;
    }
    case 6: {
      play_spiffs_name("liu.wav"); // 6
      break;
    }
    case 7: {
      play_spiffs_name("qi.wav"); // 7
      break;
    }
    case 8: {
      play_spiffs_name("ba.wav"); // 8
      break;
    }
    case 9: {
      play_spiffs_name("jiu.wav"); // 9
      break;
    }
    case 10: {
      play_spiffs_name("shi.wav"); // 10
      break;
    }
    case 11: {
      play_spiffs_name("bai.wav"); // 11
      break;
    }
    case 12: {
      play_spiffs_name("qian.wav"); // 12
      break;
    }
    case 13: {
      play_spiffs_name("wan.wav"); // 13
      break;
    }
    case 14: {
      play_spiffs_name("jia.wav"); // 14
      break;
    }
    case 15: {
      play_spiffs_name("jian.wav"); // 15
      break;
    }
    case 16: {
      play_spiffs_name("cheng.wav"); // 16
      break;
    }
    case 17: {
      play_spiffs_name("chu.wav"); // 17
      break;
    }
    case 18: {
      play_spiffs_name("fu.wav"); // 18
      break;
    }
    case 19: {
      play_spiffs_name("dian.wav"); // 19
      break;
    }
    case 20: {
      play_spiffs_name("dengyu.wav"); // 20
      break;
    }
    case 21: {
      play_spiffs_name("fenzhi.wav"); // 21
      break;
    }
    default: {
      break;
    }
  }
}

/*
串口中断回调
*/
void usart0_interrupt_callback(){
	//pass
}

/*
串口0接收任务
*/
static void usart0_rx_task(void *arg){
    static const char *RX_TASK_TAG = "RX_TASK";
    esp_log_level_set(RX_TASK_TAG, ESP_LOG_INFO);

	//配置串口
	const uart_config_t uart_config = {
	.baud_rate = 115200,
	.data_bits = UART_DATA_8_BITS,
	.parity = UART_PARITY_DISABLE,
	.stop_bits = UART_STOP_BITS_1,
	.flow_ctrl = UART_HW_FLOWCTRL_DISABLE,
	.source_clk = UART_SCLK_APB,
	};
    uart_driver_install(UART_NUM_0, USART0_RX_BUF_SIZE * 2, 0, 0, NULL, 0);
    uart_param_config(UART_NUM_0, &uart_config);
    uart_set_pin(UART_NUM_0, 43, 44, UART_PIN_NO_CHANGE, UART_PIN_NO_CHANGE);

    uint8_t *data = (uint8_t *)malloc(USART0_RX_BUF_SIZE + 1); // 申请一块内存空间 与free()成对出现
	printf("malloc USART0_RX_BUF_SIZE ok!\n");
    while (1){
        int rxBytes = uart_read_bytes(UART_NUM_0, data, USART0_RX_BUF_SIZE, 1000 / portTICK_RATE_MS); // important 重要函数 接收
		if(rxBytes >0){
			data[rxBytes]=0;
			//usart0_rx_buf_index += rxBytes;//其实每次只能接受一个字符,这里计算索引

        //if (usart0_rx_buf_index >= 1 && data[usart0_rx_buf_index]=='\n'){
            //data[rxBytes] = 0;//自动重置
            ESP_LOGI(RX_TASK_TAG, "Read %d bytes: '%s'", rxBytes, data);
            ESP_LOG_BUFFER_HEXDUMP(RX_TASK_TAG, data, rxBytes, ESP_LOG_INFO);

			//比较字符串
			if (strstr((char *)data, "0") != NULL){
                i2s_play(0);
				usart0_rx_buf_index=0;//重置
            }
			else if(strstr((char *)data, "1") != NULL){
				i2s_play(1);
				usart0_rx_buf_index=0;//重置
			}
            else if(strstr((char *)data, "2") != NULL){
				i2s_play(2);
				usart0_rx_buf_index=0;//重置
			}
            else if(strstr((char *)data, "3") != NULL){
				i2s_play(3);
				usart0_rx_buf_index=0;//重置
			}
            else if(strstr((char *)data, "4") != NULL){
				i2s_play(4);
				usart0_rx_buf_index=0;//重置
			}
            else if(strstr((char *)data, "5") != NULL){
				i2s_play(5);
				usart0_rx_buf_index=0;//重置
			}
            else if(strstr((char *)data, "6") != NULL){
				i2s_play(6);
				usart0_rx_buf_index=0;//重置
			}
            else if(strstr((char *)data, "7") != NULL){
				i2s_play(7);
				usart0_rx_buf_index=0;//重置
			}
            else if(strstr((char *)data, "8") != NULL){
				i2s_play(8);
				usart0_rx_buf_index=0;//重置
			}
            else if(strstr((char *)data, "9") != NULL){
				i2s_play(9);
				usart0_rx_buf_index=0;//重置
			}
            else if(strstr((char *)data, "10") != NULL) {
				i2s_play(10);
				usart0_rx_buf_index=0;//重置
			}
            else if(strstr((char *)data, "11") != NULL){
				i2s_play(11);
				usart0_rx_buf_index=0;//重置
			}
            else if(strstr((char *)data, "12") != NULL){
				i2s_play(12);
				usart0_rx_buf_index=0;//重置
			}
            else if(strstr((char *)data, "13") != NULL){
				i2s_play(13);
				usart0_rx_buf_index=0;//重置
			}
            else if(strstr((char *)data, "14") != NULL){
				i2s_play(14);
				usart0_rx_buf_index=0;//重置
			}
            else if(strstr((char *)data, "15") != NULL){
				i2s_play(15);
				usart0_rx_buf_index=0;//重置
			}
            else if(strstr((char *)data, "16") != NULL){
				i2s_play(16);
				usart0_rx_buf_index=0;//重置
			}
            else if(strstr((char *)data, "17") != NULL){
				i2s_play(17);
				usart0_rx_buf_index=0;//重置
			}
            else if(strstr((char *)data, "18") != NULL){
				i2s_play(18);
				usart0_rx_buf_index=0;//重置
			}
            else if(strstr((char *)data, "19") != NULL){
				i2s_play(19);
				usart0_rx_buf_index=0;//重置
			}
            else if(strstr((char *)data, "20") != NULL){
				i2s_play(20);
				usart0_rx_buf_index=0;//重置
			}
            else if(strstr((char *)data, "21") != NULL){
				i2s_play(21);
				usart0_rx_buf_index=0;//重置
			}
			else if(strstr((char *)data, "s") != NULL){//十
				i2s_play(10);
				usart0_rx_buf_index=0;//重置
			}
			else if(strstr((char *)data, "b") != NULL){//百
				i2s_play(11);
				usart0_rx_buf_index=0;//重置
			}
			else if(strstr((char *)data, "q") != NULL){//千
				i2s_play(12);
				usart0_rx_buf_index=0;//重置
			}
			else if(strstr((char *)data, "w") != NULL){//万
				i2s_play(13);
				usart0_rx_buf_index=0;//重置
			}
			else if(strstr((char *)data, "+") != NULL){//加
				i2s_play(14);
				usart0_rx_buf_index=0;//重置
			}
			else if(strstr((char *)data, "j") != NULL){//减
				i2s_play(15);
				usart0_rx_buf_index=0;//重置
			}
			else if(strstr((char *)data, "x") != NULL){//乘
				i2s_play(16);
				usart0_rx_buf_index=0;//重置
			}
			else if(strstr((char *)data, "c") != NULL){//除
				i2s_play(17);
				usart0_rx_buf_index=0;//重置
			}
			else if(strstr((char *)data, "-") != NULL){//负
				for(int k=0;k<10;k++){
				i2s_play(18);
				}
				usart0_rx_buf_index=0;//重置
			}
			else if(strstr((char *)data, ".") != NULL){//点
				i2s_play(19);
				usart0_rx_buf_index=0;//重置
			}
			else if(strstr((char *)data, "=") != NULL){//等于
				i2s_play(20);
				usart0_rx_buf_index=0;//重置
			}
			else if(strstr((char *)data, "/") != NULL){//分之
				i2s_play(21);
				usart0_rx_buf_index=0;//重置
			}
        //}end if rx_buf_index
      }//end if(rxBytes>0)
	}//end while(1)
    free(data);
}

#ifndef APP_MAIN_H
#define APP_MAIN_H

#include <stdint.h>

#define VERSION "0.9.0"

typedef enum
{
    WAIT_FOR_WAKEUP,
    WAIT_FOR_CONNECT,
    START_DETECT,
    START_RECOGNITION,
    START_ENROLL,
    START_DELETE,

} en_fsm_state;

extern en_fsm_state g_state;

extern int g_is_enrolling;
extern int g_is_deleting;

#endif

// Copyright 2015-2020 Espressif Systems (Shanghai) PTE LTD
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at

//     http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

#include <stdio.h>
#include <string.h>
#include <sys/unistd.h>
#include <dirent.h>
#include <sys/stat.h>
#include <ctype.h>
#include "esp_err.h"
#include "esp_log.h"
#include "esp_vfs_fat.h"
#include "driver/sdspi_host.h"
#include "driver/spi_common.h"
#include "sdmmc_cmd.h"
#include "file_manager.h"

#ifdef CONFIG_IDF_TARGET_ESP32
#include "driver/sdmmc_host.h"
#endif

static const char *TAG = "file manager";

static const char *partition_label = "audio";

#define FLN_MAX 512

// Pin mapping when using SPI mode.
// With this mapping, SD card can be used both in SPI and 1-line SD mode.
// Note that a pull-up on CS line is required in SD mode.
#define PIN_NUM_MISO 0
#define PIN_NUM_MOSI 4
#define PIN_NUM_CLK 3
#define PIN_NUM_CS 8

bool flag_mount = false;
static sdmmc_card_t *card;

void sd_unmount(void)
{
    if (flag_mount == true)
    {
        esp_vfs_fat_sdcard_unmount(MOUNT_POINT, card);
        ESP_LOGI(TAG, "Card unmounted");
    }
    spi_bus_free(SPI3_HOST);
}
esp_err_t fm_sdcard_init(void)
{
    esp_err_t ret;
    esp_vfs_fat_sdmmc_mount_config_t mount_config = {
        .format_if_mount_failed = false,
        .max_files = 5,
        .allocation_unit_size = 16 * 1024};
    ESP_LOGI(TAG, "Initializing SD card");
    ESP_LOGI(TAG, "Using SPI peripheral");
    sdmmc_host_t host = SDSPI_HOST_DEFAULT();
    spi_bus_config_t bus_cfg = {
        .mosi_io_num = PIN_NUM_MOSI,
        .miso_io_num = PIN_NUM_MISO,
        .sclk_io_num = PIN_NUM_CLK,
        .quadwp_io_num = -1,
        .quadhd_io_num = -1,
        .max_transfer_sz = 4000,
    };
    ret = spi_bus_initialize(SPI3_HOST, &bus_cfg, SPI_DMA_CH_AUTO);
    if (ret != ESP_OK)
    {
        ESP_LOGE(TAG, "Failed to initialize bus.");
        return ESP_FAIL;
    }
    sdspi_device_config_t slot_config = SDSPI_DEVICE_CONFIG_DEFAULT();
    slot_config.gpio_cs = 8;
    slot_config.host_id = SPI3_HOST;

    ret = esp_vfs_fat_sdspi_mount(MOUNT_POINT, &host, &slot_config, &mount_config, &card);

    if (ret != ESP_OK)
    {
        flag_mount = false;
        if (ret == ESP_FAIL)
        {
            ESP_LOGE(TAG, "Failed to mount filesystem. ");
        }
        else
        {
            ESP_LOGE(TAG, "Failed to initialize the card (%s). "
                          "Make sure SD card lines have pull-up resistors in place.",
                     esp_err_to_name(ret));
        }
        return ESP_FAIL;
    }
    ESP_LOGW(TAG, "Success to mount filesystem. ");
    flag_mount = true;
    return ESP_OK;
}

esp_err_t fm_spiffs_init(void)
{
    esp_err_t ret;
    ESP_LOGI(TAG, "Initializing SPIFFS");

    esp_vfs_spiffs_conf_t conf = {
        .base_path = MOUNT_POINT,
        .partition_label = partition_label,
        .max_files = 5, // This decides the maximum number of files that can be created on the storage
        .format_if_mount_failed = false};

    ret = esp_vfs_spiffs_register(&conf);

    if (ret != ESP_OK)
    {
        if (ret == ESP_FAIL)
        {
            ESP_LOGE(TAG, "Failed to mount or format filesystem");
        }
        else if (ret == ESP_ERR_NOT_FOUND)
        {
            ESP_LOGE(TAG, "Failed to find SPIFFS partition");
        }
        else
        {
            ESP_LOGE(TAG, "Failed to initialize SPIFFS (%s)", esp_err_to_name(ret));
        }
        return ESP_FAIL;
    }

    size_t total = 0, used = 0;
    ret = esp_spiffs_info(partition_label, &total, &used);

    if (ret != ESP_OK)
    {
        ESP_LOGE(TAG, "Failed to get SPIFFS partition information (%s)", esp_err_to_name(ret));
        return ESP_FAIL;
    }

    ESP_LOGI(TAG, "Partition size: total: %d, used: %d", total, used);

    return ESP_OK;
}

static void TraverseDir(char *direntName, int level, int indent)
{
    DIR *p_dir = NULL;
    struct dirent *p_dirent = NULL;

    p_dir = opendir(direntName);

    if (p_dir == NULL)
    {
        printf("opendir error\n");
        return;
    }

    while ((p_dirent = readdir(p_dir)) != NULL)
    {
        char *backupDirName = NULL;

        if (p_dirent->d_name[0] == '.')
        {
            continue;
        }

        int i;

        for (i = 0; i < indent; i++)
        {
            // printf("|");
            printf("     ");
        }

        printf("|--- %s", p_dirent->d_name);

        /* Itme is a file */
        if (p_dirent->d_type == DT_REG)
        {
            int curDirentNameLen = strlen(direntName) + strlen(p_dirent->d_name) + 2;

            //prepare next path
            backupDirName = (char *)malloc(curDirentNameLen);
            struct stat *st = NULL;
            st = malloc(sizeof(struct stat));

            if (NULL == backupDirName || NULL == st)
            {
                goto _err;
            }

            memset(backupDirName, 0, curDirentNameLen);
            memcpy(backupDirName, direntName, strlen(direntName));

            strcat(backupDirName, "/");
            strcat(backupDirName, p_dirent->d_name);

            int statok = stat(backupDirName, st);

            if (0 == statok)
            {
                printf("[%dB]\n", (int)st->st_size);
            }
            else
            {
                printf("\n");
            }

            free(backupDirName);
            backupDirName = NULL;
        }
        else
        {
            printf("\n");
        }

        /* Itme is a directory */
        if (p_dirent->d_type == DT_DIR)
        {
            int curDirentNameLen = strlen(direntName) + strlen(p_dirent->d_name) + 2;

            //prepare next path
            backupDirName = (char *)malloc(curDirentNameLen);

            if (NULL == backupDirName)
            {
                goto _err;
            }

            memset(backupDirName, 0, curDirentNameLen);
            memcpy(backupDirName, direntName, curDirentNameLen);

            strcat(backupDirName, "/");
            strcat(backupDirName, p_dirent->d_name);

            if (level > 0)
            {
                TraverseDir(backupDirName, level - 1, indent + 1);
            }

            free(backupDirName);
            backupDirName = NULL;
        }
    }

_err:
    closedir(p_dir);
}

void fm_print_dir(char *direntName, int level)
{
    printf("Traverse directory %s\n", direntName);
    TraverseDir(direntName, level, 0);
    printf("\r\n");
}

const char *fm_get_basepath(void)
{
    return MOUNT_POINT;
}

esp_err_t fm_file_table_create(char ***list_out, uint16_t *files_number, const char *filter_suffix)
{
    DIR *p_dir = NULL;
    struct dirent *p_dirent = NULL;

    p_dir = opendir(MOUNT_POINT);

    if (p_dir == NULL)
    {
        ESP_LOGE(TAG, "opendir error");
        return ESP_FAIL;
    }

    uint16_t f_num = 0;
    while ((p_dirent = readdir(p_dir)) != NULL)
    {
        if (p_dirent->d_type == DT_REG)
        {
            f_num++;
        }
    }

    rewinddir(p_dir);

    *list_out = calloc(f_num, sizeof(char *));
    if (NULL == (*list_out))
    {
        goto _err;
    }
    for (size_t i = 0; i < f_num; i++)
    {
        (*list_out)[i] = malloc(FLN_MAX);
        if (NULL == (*list_out)[i])
        {
            ESP_LOGE(TAG, "malloc failed at %d", i);
            fm_file_table_free(list_out, f_num);
            goto _err;
        }
    }

    uint16_t index = 0;
    while ((p_dirent = readdir(p_dir)) != NULL)
    {
        if (p_dirent->d_type == DT_REG)
        {
            if (NULL != filter_suffix)
            {
                if (strstr(p_dirent->d_name, filter_suffix))
                {
                    strncpy((*list_out)[index], p_dirent->d_name, FLN_MAX - 1);
                    (*list_out)[index][FLN_MAX - 1] = '\0';
                    index++;
                }
            }
            else
            {
                strncpy((*list_out)[index], p_dirent->d_name, FLN_MAX - 1);
                (*list_out)[index][FLN_MAX - 1] = '\0';
                index++;
            }
        }
    }
    (*files_number) = index;

    closedir(p_dir);
    return ESP_OK;
_err:
    closedir(p_dir);

    return ESP_FAIL;
}

esp_err_t fm_file_table_free(char ***list, uint16_t files_number)
{
    for (size_t i = 0; i < files_number; i++)
    {
        free((*list)[i]);
    }
    free((*list));
    return ESP_OK;
}

const char *fm_get_filename(const char *file)
{
    const char *p = file + strlen(file);
    while (p > file)
    {
        if ('/' == *p)
        {
            return (p + 1);
        }
        p--;
    }
    return file;
}

size_t fm_get_file_size(const char *filepath)
{
    struct stat siz = {0};
    stat(filepath, &siz);
    return siz.st_size;
}

#ifndef _IOT_FILE_MANAGER_H_
#define _IOT_FILE_MANAGER_H_

#include "esp_err.h"
#include "esp_spiffs.h"
#include "esp_vfs.h"

#ifdef __cplusplus
extern "C" {
#endif

#define MOUNT_POINT  "/sdcard"

esp_err_t fm_sdcard_init(void);
esp_err_t fm_spiffs_init(void);
void fm_print_dir(char *direntName, int level);
const char *fm_get_basepath(void);
const char *fm_get_filename(const char *file);
size_t fm_get_file_size(const char *filepath);
esp_err_t fm_file_table_create(char ***list_out, uint16_t *files_number, const char *filter_suffix);
esp_err_t fm_file_table_free(char ***list,uint16_t files_number);
void sd_unmount(void);
#ifdef __cplusplus
}
#endif
#endif

/*
 * @Descripttion :  通过串口点播数字音频
 * @version      :  
 * @Author       : Kevincoooool
 * @Date         : 2021-05-25 09:20:06
 * @LastEditors: qsbye
 * @LastEditTime: 2023-06-27 12:00:18
 * @FilePath: mp3_player.c
 */

#include "mp3_player.h"
#include "file_manager.h"
#include "driver/i2s.h"
#include "esp_log.h"
#include "esp_spiffs.h"
#include "mp3dec.h"
#define TAG "WAV_PLAYER"
#define I2S_NUM 0
/*
    录音I2S初始化
*/
void record_i2s_init(void)
{
    i2s_config_t i2s_config = {
        .mode = I2S_MODE_MASTER | I2S_MODE_RX,        // the mode must be set according to DSP configuration
        .sample_rate = 16000,                         // must be the same as DSP configuration
        .channel_format = I2S_CHANNEL_FMT_RIGHT_LEFT, // must be the same as DSP configuration
        .bits_per_sample = 32,                        // must be the same as DSP configuration
        .communication_format = I2S_COMM_FORMAT_STAND_I2S,
        .dma_buf_count = 2,
        .dma_buf_len = 300,
        .intr_alloc_flags = ESP_INTR_FLAG_LOWMED,
        .bits_per_chan = I2S_BITS_PER_SAMPLE_16BIT};
    i2s_pin_config_t pin_config = {
        .mck_io_num = -1,
        .bck_io_num = IIS_SCLK, // IIS_SCLK
        .ws_io_num = IIS_LCLK,  // IIS_LCLK
        .data_out_num = -1,     // IIS_DSIN
        .data_in_num = IIS_DOUT // IIS_DOUT
    };
    i2s_driver_install(I2S_NUM, &i2s_config, 0, NULL);
    i2s_set_pin(I2S_NUM, &pin_config);
    i2s_zero_dma_buffer(I2S_NUM);
}
/*
    播放I2S初始化
*/
void play_i2s_init(void)
{
    i2s_config_t i2s_config = {
        .mode = (i2s_mode_t)(I2S_MODE_MASTER | I2S_MODE_TX),
        .sample_rate = 36000,
        .bits_per_sample = I2S_BITS_PER_SAMPLE_16BIT,
        .channel_format = I2S_CHANNEL_FMT_ONLY_LEFT,
        .communication_format = I2S_COMM_FORMAT_STAND_I2S,
        .intr_alloc_flags = ESP_INTR_FLAG_LOWMED,
        .dma_buf_count = 2,
        .dma_buf_len = 300,
        .bits_per_chan = I2S_BITS_PER_SAMPLE_16BIT};
    i2s_pin_config_t pin_config = {
        .mck_io_num = -1,
        .bck_io_num = IIS_SCLK,   // IIS_SCLK
        .ws_io_num = IIS_LCLK,    // IIS_LCLK
        .data_out_num = IIS_DSIN, // IIS_DSIN
        .data_in_num = -1         // IIS_DOUT
    };
    i2s_driver_install(I2S_NUM, &i2s_config, 0, NULL);
    i2s_set_pin(I2S_NUM, &pin_config);
    i2s_zero_dma_buffer(I2S_NUM);
}
/*
    卸载I2S驱动
*/
void all_i2s_deinit(void)
{
    i2s_driver_uninstall(I2S_NUM);
    vTaskDelay(10);
}
char path_buf[256] = {0};
char **g_file_list = NULL;
uint16_t g_file_num = 0;
bool playing = false;
typedef struct
{
	// The "RIFF" chunk descriptor
	uint8_t ChunkID[4];
	int32_t ChunkSize;
	uint8_t Format[4];
	// The "fmt" sub-chunk
	uint8_t Subchunk1ID[4];
	int32_t Subchunk1Size;
	int16_t AudioFormat;
	int16_t NumChannels;
	int32_t SampleRate;
	int32_t ByteRate;
	int16_t BlockAlign;
	int16_t BitsPerSample;
	// The "data" sub-chunk
	uint8_t Subchunk2ID[4];
	int32_t Subchunk2Size;
} wav_header_t;

esp_err_t play_wav(const char *filepath)
{

	all_i2s_deinit();//先把i2s的驱动卸载掉 因为在这之前是把i2s初始化为录音了 现在要播放 公用的引脚就不能播放  需要卸载掉重新初始化为播放模式
	play_i2s_init();//初始化播放模式的i2s
	FILE *fd = NULL;
	struct stat file_stat;

	if (stat(filepath, &file_stat) == -1)//先找找这个文件是否存在
	{
		ESP_LOGE(TAG, "Failed to stat file : %s", filepath);
		//all_i2s_deinit();
		//record_i2s_init();
		return ESP_FAIL;//如果不存在就继续录音
	}

	ESP_LOGI(TAG, "file stat info: %s (%ld bytes)...", filepath, file_stat.st_size);
	fd = fopen(filepath, "r");

	if (NULL == fd)
	{
		ESP_LOGE(TAG, "Failed to read existing file : %s", filepath);
		//all_i2s_deinit();
		//record_i2s_init();
		return ESP_FAIL;
	}
	const size_t chunk_size = 4096;
	uint8_t *buffer = malloc(chunk_size);

	if (NULL == buffer)
	{
		ESP_LOGE(TAG, "audio data buffer malloc failed");
		//all_i2s_deinit();
		//record_i2s_init();
		fclose(fd);
		return ESP_FAIL;
	}

	/**
	 * read head of WAV file
	 */
	wav_header_t wav_head;
	int len = fread(&wav_head, 1, sizeof(wav_header_t), fd);//读取wav文件的文件头
	if (len <= 0)
	{
		ESP_LOGE(TAG, "Read wav header failed");
		//all_i2s_deinit();
		//record_i2s_init();
		fclose(fd);
		return ESP_FAIL;
	}
	if (NULL == strstr((char *)wav_head.Subchunk1ID, "fmt") &&
		NULL == strstr((char *)wav_head.Subchunk2ID, "data"))
	{
		ESP_LOGE(TAG, "Header of wav format error");
		//all_i2s_deinit();
		//record_i2s_init();
		fclose(fd);
		return ESP_FAIL;
	}

	ESP_LOGI(TAG, "frame_rate=%d, ch=%d, width=%d", wav_head.SampleRate, wav_head.NumChannels, wav_head.BitsPerSample);
	/**
	 * read wave data of WAV file
	 */
	size_t write_num = 0;
	size_t cnt;
	ESP_LOGI(TAG, "set clock");
    //I2S:1->0
	i2s_set_clk(0, wav_head.SampleRate, wav_head.BitsPerSample, 1);//根据该wav文件的各种参数来配置一下i2S的clk 采样率等等
	ESP_LOGI(TAG, "write data");
	do
	{
		/* Read file in chunks into the scratch buffer */
		len = fread(buffer, 1, chunk_size, fd);
		if (len <= 0)
		{
			break;
		}
        //I2S:1->0
		i2s_write(0, buffer, len, &cnt, 1000 / portTICK_PERIOD_MS);//输出数据到I2S  就实现了播放
		write_num += len;
	} while (1);
	fclose(fd);
	ESP_LOGI(TAG, "File reading complete, total: %d bytes", write_num);

	all_i2s_deinit();
	// record_i2s_init();

	return ESP_OK;
}
void play_sdfile_name(char *file_name)
{
	playing = true;

	fm_sdcard_init();
	fm_print_dir("/sdcard", 2);
	fm_file_table_create(&g_file_list, &g_file_num, ".WAV");
	for (size_t i = 0; i < g_file_num; i++)
	{
		ESP_LOGI(TAG, "have file [%d:%s]", i, g_file_list[i]);
	}
	if (0 == g_file_num)
	{
		ESP_LOGW(TAG, "Can't found any wav file in sdcard!");
		all_i2s_deinit();
		record_i2s_init();
		sd_unmount();
		playing = false;
		return;
	}
	sprintf(path_buf, "%s/%s", "/sdcard", file_name);
	play_wav(path_buf);
	sd_unmount();
	fm_file_table_free(&g_file_list, g_file_num);
    record_i2s_init();
    vTaskDelay(10);
	playing = false;
}
void play_spiffs_name(char *file_name)
{
	playing = true;

	sprintf(path_buf, "%s/%s", "/spiffs/voice", file_name);
	play_wav(path_buf);
	//record_i2s_init();
    vTaskDelay(10);
	playing = false;
	vTaskDelay(10);
}


#define SAMPLE_RATE (44100)
#define I2S_NUM (0)
#define WAVE_FREQ_HZ (100)
#define PI (3.14159265)

#define SAMPLE_PER_CYCLE (SAMPLE_RATE / WAVE_FREQ_HZ)

xQueueHandle play_queue = NULL;

/*!< aduio music list from spiffs*/
const char audio_list[2][64] = {
    "/spiffs/apple-tosk.mp3",
    "/spiffs/distance.mp3",
    // "/spiffs/longest_movie.mp3",
};

enum
{
    AUDIO_STOP = 0,
    AUDIO_PLAY,
    AUDIO_NEXT,
    AUDIO_LAST
};

int play_flag = AUDIO_STOP;
int audio_play_index = 0;

void aplay_mp3(const char *path)
{
    ESP_LOGI(TAG, "start to decode %s", path);
    HMP3Decoder hMP3Decoder;
    MP3FrameInfo mp3FrameInfo;
    unsigned char *readBuf = malloc(MAINBUF_SIZE);

    if (readBuf == NULL)
    {
        ESP_LOGE(TAG, "readBuf malloc failed");
        return;
    }

    short *output = malloc(1153 * 4);

    if (output == NULL)
    {
        free(readBuf);
        ESP_LOGE(TAG, "outBuf malloc failed");
    }

    hMP3Decoder = MP3InitDecoder();

    if (hMP3Decoder == 0)
    {
        free(readBuf);
        free(output);
        ESP_LOGE(TAG, "memory is not enough..");
    }

    int samplerate = 0;
    i2s_zero_dma_buffer(0);
    FILE *mp3File = fopen(path, "rb");

    if (mp3File == NULL)
    {
        MP3FreeDecoder(hMP3Decoder);
        free(readBuf);
        free(output);
        ESP_LOGE(TAG, "open file failed");
    }

    char tag[10];
    int tag_len = 0;
    int read_bytes = fread(tag, 1, 10, mp3File);

    if (read_bytes == 10)
    {
        if (memcmp(tag, "ID3", 3) == 0)
        {
            tag_len = ((tag[6] & 0x7F) << 21) | ((tag[7] & 0x7F) << 14) | ((tag[8] & 0x7F) << 7) | (tag[9] & 0x7F);
            // ESP_LOGI(TAG,"tag_len: %d %x %x %x %x", tag_len,tag[6],tag[7],tag[8],tag[9]);
            fseek(mp3File, tag_len - 10, SEEK_SET);
        }
        else
        {
            fseek(mp3File, 0, SEEK_SET);
        }
    }

    int bytesLeft = 0;
    unsigned char *readPtr = readBuf;
    play_flag = AUDIO_PLAY;

    while (1)
    {
        switch (play_flag)
        {
        case AUDIO_STOP:
        {
            while (!play_flag)
            {
                i2s_zero_dma_buffer(0);
                vTaskDelay(100 / portTICK_RATE_MS);
                goto stop;
            }
            break;
        }
        break;

        case AUDIO_PLAY:
        {
        }
        break;

        case AUDIO_NEXT:
        {
            if (audio_play_index < 3 - 1)
            {
                audio_play_index++;
            }
            else
            {
                audio_play_index = 0;
            }

            goto stop;
        }
        break;

        case AUDIO_LAST:
        {
            if (audio_play_index > 0)
            {
                audio_play_index--;
            }
            else
            {
                audio_play_index = 3 - 1;
            }

            goto stop;
        }
        break;
        }

        if (bytesLeft < MAINBUF_SIZE)
        {
            memmove(readBuf, readPtr, bytesLeft);
            int br = fread(readBuf + bytesLeft, 1, MAINBUF_SIZE - bytesLeft, mp3File);

            if ((br == 0) && (bytesLeft == 0))
            {
                break;
            }

            bytesLeft = bytesLeft + br;
            readPtr = readBuf;
        }

        int offset = MP3FindSyncWord(readPtr, bytesLeft);

        if (offset < 0)
        {
            ESP_LOGE(TAG, "MP3FindSyncWord not find");
            bytesLeft = 0;
            continue;
        }
        else
        {
            readPtr += offset;   /*!< data start point */
            bytesLeft -= offset; /*!< in buffer */
            int errs = MP3Decode(hMP3Decoder, &readPtr, &bytesLeft, output, 0);

            if (errs != 0)
            {
                ESP_LOGE(TAG, "MP3Decode failed ,code is %d ", errs);
                break;
            }

            MP3GetLastFrameInfo(hMP3Decoder, &mp3FrameInfo);

            if (samplerate != mp3FrameInfo.samprate)
            {
                samplerate = mp3FrameInfo.samprate;
                i2s_set_clk(0, samplerate, 16, mp3FrameInfo.nChans);
                ESP_LOGI(TAG, "mp3file info---bitrate=%d,layer=%d,nChans=%d,samprate=%d,outputSamps=%d", mp3FrameInfo.bitrate, mp3FrameInfo.layer, mp3FrameInfo.nChans, mp3FrameInfo.samprate, mp3FrameInfo.outputSamps);
            }

            size_t bytes_write = 0;
            i2s_write(0, (const char *)output, mp3FrameInfo.outputSamps * 2, &bytes_write, 100 / portTICK_RATE_MS);
            // rmt_write_items(0,(const char*)output,mp3FrameInfo.outputSamps*2, 1000 / portTICK_RATE_MS);
        }
    }

stop:
    i2s_zero_dma_buffer(0);
    MP3FreeDecoder(hMP3Decoder);
    free(readBuf);
    free(output);
    fclose(mp3File);

    ESP_LOGI(TAG, "end mp3 decode ..");
}

// static void audio_task(void *arg)
// {
//     /*!<  for 36Khz sample rates, we create 100Hz sine wave, every cycle need 36000/100 = 360 samples (4-bytes or 8-bytes each sample) */
//     /*!<  depend on bits_per_sample */
//     /*!<  using 6 buffers, we need 60-samples per buffer */
//     /*!<  if 2-channels, 16-bit each channel, total buffer is 360*4 = 1440 bytes */
//     /*!<  if 2-channels, 24/32-bit each channel, total buffer is 360*8 = 2880 bytes */
//     i2s_config_t i2s_config = {
//         .mode = I2S_MODE_MASTER | I2S_MODE_TX | I2S_MODE_RX, /*!<  Only TX */
//         .sample_rate = SAMPLE_RATE,
//         .bits_per_sample = 16,
//         .channel_format = I2S_CHANNEL_FMT_RIGHT_LEFT, /*!< 1-channels */
//         .communication_format = I2S_COMM_FORMAT_I2S,
//         .dma_buf_count = 6,
//         .dma_buf_len = 256,
//         .use_apll = true,
//         .tx_desc_auto_clear = true, /*!< I2S auto clear tx descriptor if there is underflow condition (helps in avoiding noise in case of data unavailability) */
//         .intr_alloc_flags = ESP_INTR_FLAG_LEVEL2 | ESP_INTR_FLAG_IRAM,
//     };
//     i2s_pin_config_t pin_config = {
//         .bck_io_num = I2S_SCLK,
//         .ws_io_num = I2S_LCLK,
//         .data_out_num = I2S_DOUT,
//         .data_in_num = I2S_DSIN /*!< Not used */
//     };

//     i2s_driver_install(I2S_NUM, &i2s_config, 0, NULL);
//     i2s_set_pin(I2S_NUM, &pin_config);

//     unsigned int mp3_index = 0;
//     while (1)
//     {
//         if (xQueueReceive(play_queue, &mp3_index, portTICK_RATE_MS))
//         {
//             printf("play_queue: mp3_index = %u\n", mp3_index);

//             if (mp3_index > (AUDIO_MAX_PLAY_LIST - 1))
//                 printf("mp3_index: error\n");
//             else
//             {
//                 aplay_mp3(audio_list[mp3_index]);
//                 vTaskDelay(1000 / portTICK_RATE_MS);
//             }
//         }
//     }
// }
void audio_play(uint8_t index)
{
	printf("play_queue: mp3_index = %d\n", index);
	aplay_mp3(audio_list[index]);
}
int audio_init(uint32_t vol)
{
    // es8311_init(SAMPLE_RATE);
    
    // if (vol > 100)
    //     vol = 100;

    ESP_LOGI(TAG, "设置音量(%d)", vol);
    // es8311_set_voice_volume(vol);
    // xTaskCreate(audio_task, "audio_task", 4096, NULL, 5, NULL);
    return 0;
}

// void audio_setting_vol(uint32_t vol)
// {
//     if (vol > 100)
//         vol = 100;

//     es8311_set_voice_volume(vol);
// }

#ifndef _wav_player_h_
#define _wav_player_h_
#include <stdio.h>
#include <string.h>
#include "freertos/FreeRTOS.h"
#include "freertos/task.h"
#include "freertos/queue.h"
#include "freertos/semphr.h"
#include "esp_err.h"
#include "esp_log.h"
#define IIS_SCLK 16
#define IIS_LCLK 7
#define IIS_DSIN 6
#define IIS_DOUT 15

extern bool playing;
esp_err_t play_wav(const char *filepath);
void play_sdfile_name(char *file_name);
void play_spiffs_name(char *file_name);
void play_i2s_init(void);
void audio_play(uint8_t index);
#ifdef __cplusplus
}
#endif