ben/SmartSpeaker
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Initial sanitized SmartSpeaker snapshot

Browse Source
This commit is contained in:
ben
2026-07-13 21:13:19 -07:00
commit ac26dcc238
66 changed files with 11438 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files
main/hardeware_driver/bsp_board.c
+684
View File
@@ -0,0 +1,684 @@
#include "bsp_board.h"
#include <stdbool.h>
#include "esp_err.h"
#include "freertos/FreeRTOS.h"
#include "freertos/semphr.h"
#include "string.h"
#include "driver/gpio.h"
#include "esp_err.h"
#include "esp_log.h"
#include "esp_rom_sys.h"
#include "esp_check.h"
#include "esp_vfs_fat.h"
#include "sdmmc_cmd.h"
#include <sys/unistd.h>
#include <sys/stat.h>
#include "dirent.h"
#include "driver/sdmmc_host.h"
#include <errno.h>
#if ((SOC_SDMMC_HOST_SUPPORTED) && (FUNC_SDMMC_EN))
#include "driver/sdmmc_host.h"
#endif /* ((SOC_SDMMC_HOST_SUPPORTED) && (FUNC_SDMMC_EN)) */
#define ADC_I2S_CHANNEL 4
static sdmmc_card_t *card;
static const char *TAG = "board";
static int s_play_sample_rate = 16000;
static int s_play_channel_format = 1;
static int s_bits_per_chan = 16;
#if ESP_IDF_VERSION >= ESP_IDF_VERSION_VAL(5, 0, 0)
static i2s_chan_handle_t tx_handle = NULL; // I2S tx channel handler
static i2s_chan_handle_t rx_handle = NULL; // I2S rx channel handler
#endif
static audio_codec_data_if_t *record_data_if = NULL;
static audio_codec_ctrl_if_t *record_ctrl_if = NULL;
static audio_codec_if_t *record_codec_if = NULL;
static esp_codec_dev_handle_t record_dev = NULL;
static audio_codec_data_if_t *play_data_if = NULL;
static audio_codec_ctrl_if_t *play_ctrl_if = NULL;
static audio_codec_gpio_if_t *play_gpio_if = NULL;
static audio_codec_if_t *play_codec_if = NULL;
static esp_codec_dev_handle_t play_dev = NULL;
static i2c_master_bus_handle_t i2c_bus_handle = NULL;
static uint32_t SDCard_Size = 0;
esp_codec_dev_handle_t esp_ret_play_dev(void)
{
return play_dev;
}
i2c_master_bus_handle_t esp_ret_i2c_handle(void)
{
return i2c_bus_handle;
}
uint32_t Get_SD_Size(void)
{
return SDCard_Size;
}
static esp_err_t i2c_master_init(void)
{
const i2c_master_bus_config_t bus_config = {
.i2c_port = I2C_NUM,
.sda_io_num = GPIO_I2C_SDA,
.scl_io_num = GPIO_I2C_SCL,
.clk_source = I2C_CLK_SRC_DEFAULT,
};
esp_err_t ret = i2c_new_master_bus(&bus_config, &i2c_bus_handle);
if (ret != ESP_OK) {
ESP_LOGE(TAG, "Failed to initialize I2C bus: %s", esp_err_to_name(ret));
return ret;
}
ESP_LOGI(TAG, "I2C bus initialized successfully");
return ESP_OK; // 返回 ESP_OK 表示成功
}
esp_err_t bsp_codec_adc_init(int sample_rate)
{
esp_err_t ret_val = ESP_OK;
// Do initialize of related interface: data_if, ctrl_if and gpio_if
audio_codec_i2s_cfg_t i2s_cfg = {
.port = I2S_NUM_1,
#if ESP_IDF_VERSION >= ESP_IDF_VERSION_VAL(5, 0, 0)
.rx_handle = rx_handle,
.tx_handle = NULL,
#endif
};
record_data_if = audio_codec_new_i2s_data(&i2s_cfg);
audio_codec_i2c_cfg_t i2c_cfg = {.addr = ES7210_CODEC_DEFAULT_ADDR,.bus_handle = i2c_bus_handle};
record_ctrl_if = audio_codec_new_i2c_ctrl(&i2c_cfg);
// New input codec interface
es7210_codec_cfg_t es7210_cfg = {
.ctrl_if = record_ctrl_if,
.mic_selected = ES7210_SEL_MIC1 | ES7210_SEL_MIC2 | ES7210_SEL_MIC3 | ES7210_SEL_MIC4,
};
record_codec_if = es7210_codec_new(&es7210_cfg);
// New input codec device
esp_codec_dev_cfg_t dev_cfg = {
.codec_if = record_codec_if,
.data_if = record_data_if,
.dev_type = ESP_CODEC_DEV_TYPE_IN,
};
record_dev = esp_codec_dev_new(&dev_cfg);
esp_codec_dev_sample_info_t fs = {
.sample_rate = 16000,
.channel = 2,
.bits_per_sample = 32,
};
esp_codec_dev_open(record_dev, &fs);
// esp_codec_dev_set_in_gain(record_dev, RECORD_VOLUME);
esp_codec_dev_set_in_channel_gain(record_dev, ESP_CODEC_DEV_MAKE_CHANNEL_MASK(0), RECORD_VOLUME);
esp_codec_dev_set_in_channel_gain(record_dev, ESP_CODEC_DEV_MAKE_CHANNEL_MASK(1), RECORD_VOLUME);
esp_codec_dev_set_in_channel_gain(record_dev, ESP_CODEC_DEV_MAKE_CHANNEL_MASK(2), RECORD_VOLUME);
esp_codec_dev_set_in_channel_gain(record_dev, ESP_CODEC_DEV_MAKE_CHANNEL_MASK(3), RECORD_VOLUME);
return ret_val;
}
esp_err_t bsp_codec_dac_init(int sample_rate, int channel_format, int bits_per_chan)
{
esp_err_t ret_val = ESP_OK;
// Do initialize of related interface: data_if, ctrl_if and gpio_if
audio_codec_i2s_cfg_t i2s_cfg = {
.port = I2S_NUM_1,
#if ESP_IDF_VERSION >= ESP_IDF_VERSION_VAL(5, 0, 0)
.rx_handle = NULL,
.tx_handle = tx_handle,
#endif
};
play_data_if = audio_codec_new_i2s_data(&i2s_cfg);
audio_codec_i2c_cfg_t i2c_cfg = {.addr = ES8311_CODEC_DEFAULT_ADDR,.bus_handle = i2c_bus_handle};
play_ctrl_if = audio_codec_new_i2c_ctrl(&i2c_cfg);
play_gpio_if = audio_codec_new_gpio();
// New output codec interface
es8311_codec_cfg_t es8311_cfg = {
.codec_mode = ESP_CODEC_DEV_WORK_MODE_DAC,
.ctrl_if = play_ctrl_if,
.gpio_if = play_gpio_if,
.pa_pin = GPIO_PWR_CTRL,
.use_mclk = false,
};
play_codec_if = es8311_codec_new(&es8311_cfg);
// New output codec device
esp_codec_dev_cfg_t dev_cfg = {
.codec_if = play_codec_if,
.data_if = play_data_if,
.dev_type = ESP_CODEC_DEV_TYPE_OUT,
};
play_dev = esp_codec_dev_new(&dev_cfg);
esp_codec_dev_sample_info_t fs = {
.bits_per_sample = bits_per_chan,
.sample_rate = sample_rate,
.channel = channel_format,
};
esp_codec_dev_set_out_vol(play_dev, PLAYER_VOLUME);
esp_codec_dev_open(play_dev, &fs);
return ret_val;
}
static esp_err_t bsp_codec_adc_deinit()
{
esp_err_t ret_val = ESP_OK;
if (record_dev) {
esp_codec_dev_close(record_dev);
esp_codec_dev_delete(record_dev);
record_dev = NULL;
}
// Delete codec interface
if (record_codec_if) {
audio_codec_delete_codec_if(record_codec_if);
record_codec_if = NULL;
}
// Delete codec control interface
if (record_ctrl_if) {
audio_codec_delete_ctrl_if(record_ctrl_if);
record_ctrl_if = NULL;
}
// Delete codec data interface
if (record_data_if) {
audio_codec_delete_data_if(record_data_if);
record_data_if = NULL;
}
return ret_val;
}
static esp_err_t bsp_codec_dac_deinit()
{
esp_err_t ret_val = ESP_OK;
if (play_dev) {
esp_codec_dev_close(play_dev);
esp_codec_dev_delete(play_dev);
play_dev = NULL;
}
// Delete codec interface
if (play_codec_if) {
audio_codec_delete_codec_if(play_codec_if);
play_codec_if = NULL;
}
// Delete codec control interface
if (play_ctrl_if) {
audio_codec_delete_ctrl_if(play_ctrl_if);
play_ctrl_if = NULL;
}
if (play_gpio_if) {
audio_codec_delete_gpio_if(play_gpio_if);
play_gpio_if = NULL;
}
// Delete codec data interface
if (play_data_if) {
audio_codec_delete_data_if(play_data_if);
play_data_if = NULL;
}
return ret_val;
}
esp_err_t esp_audio_set_play_vol(int volume)
{
if (!play_dev) {
ESP_LOGE(TAG, "DAC codec init fail");
return ESP_FAIL;
}
esp_codec_dev_set_out_vol(play_dev, volume);
return ESP_OK;
}
esp_err_t esp_audio_get_play_vol(int *volume)
{
if (!play_dev) {
ESP_LOGE(TAG, "DAC codec init fail");
return ESP_FAIL;
}
esp_codec_dev_get_out_vol(play_dev, volume);
return ESP_OK;
}
// static esp_err_t bsp_i2s_init(i2s_port_t i2s_num, uint32_t sample_rate, i2s_channel_fmt_t channel_format, i2s_bits_per_chan_t bits_per_chan)
static esp_err_t bsp_i2s_init(int i2s_num, uint32_t sample_rate, int channel_format, int bits_per_chan)
{
esp_err_t ret_val = ESP_OK;
#if ESP_IDF_VERSION >= ESP_IDF_VERSION_VAL(5, 0, 0)
i2s_slot_mode_t channel_fmt = I2S_SLOT_MODE_STEREO;
if (channel_format == 1) {
channel_fmt = I2S_SLOT_MODE_MONO;
} else if (channel_format == 2) {
channel_fmt = I2S_SLOT_MODE_STEREO;
} else {
ESP_LOGE(TAG, "Unable to configure channel_format %d", channel_format);
channel_format = 1;
channel_fmt = I2S_SLOT_MODE_MONO;
}
if (bits_per_chan != 16 && bits_per_chan != 32) {
ESP_LOGE(TAG, "Unable to configure bits_per_chan %d", bits_per_chan);
bits_per_chan = 32;
}
i2s_chan_config_t chan_cfg = I2S_CHANNEL_DEFAULT_CONFIG(i2s_num, I2S_ROLE_MASTER);
ret_val |= i2s_new_channel(&chan_cfg, &tx_handle, &rx_handle);
i2s_std_config_t std_cfg = I2S_CONFIG_DEFAULT(sample_rate, channel_fmt, bits_per_chan);
ret_val |= i2s_channel_init_std_mode(tx_handle, &std_cfg);
ret_val |= i2s_channel_init_std_mode(rx_handle, &std_cfg);
ret_val |= i2s_channel_enable(tx_handle);
ret_val |= i2s_channel_enable(rx_handle);
#else
i2s_channel_fmt_t channel_fmt = I2S_CHANNEL_FMT_RIGHT_LEFT;
if (channel_format == 1) {
channel_fmt = I2S_CHANNEL_FMT_ONLY_LEFT;
} else if (channel_format == 2) {
channel_fmt = I2S_CHANNEL_FMT_RIGHT_LEFT;
} else {
ESP_LOGE(TAG, "Unable to configure channel_format %d", channel_format);
channel_format = 1;
channel_fmt = I2S_CHANNEL_FMT_ONLY_LEFT;
}
if (bits_per_chan != 16 && bits_per_chan != 32) {
ESP_LOGE(TAG, "Unable to configure bits_per_chan %d", bits_per_chan);
bits_per_chan = 16;
}
i2s_config_t i2s_config = I2S_CONFIG_DEFAULT(sample_rate, channel_fmt, bits_per_chan);
i2s_pin_config_t pin_config = {
.bck_io_num = GPIO_I2S_SCLK,
.ws_io_num = GPIO_I2S_LRCK,
.data_out_num = GPIO_I2S_DOUT,
.data_in_num = GPIO_I2S_SDIN,
.mck_io_num = GPIO_I2S_MCLK,
};
ret_val |= i2s_driver_install(i2s_num, &i2s_config, 0, NULL);
ret_val |= i2s_set_pin(i2s_num, &pin_config);
#endif
return ret_val;
}
static esp_err_t bsp_i2s_deinit(int i2s_num)
{
esp_err_t ret_val = ESP_OK;
#if ESP_IDF_VERSION >= ESP_IDF_VERSION_VAL(5, 0, 0)
if (i2s_num == I2S_NUM_1 && rx_handle) {
ret_val |= i2s_channel_disable(rx_handle);
ret_val |= i2s_del_channel(rx_handle);
rx_handle = NULL;
} else if (i2s_num == I2S_NUM_0 && tx_handle) {
ret_val |= i2s_channel_disable(tx_handle);
ret_val |= i2s_del_channel(tx_handle);
tx_handle = NULL;
}
#else
ret_val |= i2s_stop(i2s_num);
ret_val |= i2s_driver_uninstall(i2s_num);
#endif
return ret_val;
}
static esp_err_t bsp_codec_init(int adc_sample_rate, int dac_sample_rate, int dac_channel_format, int dac_bits_per_chan)
{
esp_err_t ret_val = ESP_OK;
ret_val |= bsp_codec_adc_init(adc_sample_rate);
ret_val |= bsp_codec_dac_init(dac_sample_rate, dac_channel_format, dac_bits_per_chan);
return ret_val;
}
static esp_err_t bsp_codec_deinit()
{
esp_err_t ret_val = ESP_OK;
ret_val |= bsp_codec_adc_deinit();
ret_val |= bsp_codec_dac_deinit();
return ret_val;
}
esp_err_t esp_audio_play(const int16_t* data, int length, uint32_t ticks_to_wait)
{
size_t bytes_write = 0;
esp_err_t ret = ESP_OK;
if (!play_dev) {
return ESP_FAIL;
}
int out_length= length;
int audio_time = 1;
audio_time *= (16000 / s_play_sample_rate);
audio_time *= (2 / s_play_channel_format);
int *data_out = NULL;
if (s_bits_per_chan != 32) {
out_length = length * 2;
data_out = malloc(out_length);
for (int i = 0; i < length / sizeof(int16_t); i++) {
int ret = data[i];
data_out[i] = ret << 16;
}
}
int *data_out_1 = NULL;
if (s_play_channel_format != 2 || s_play_sample_rate != 16000) {
out_length *= audio_time;
data_out_1 = malloc(out_length);
int *tmp_data = NULL;
if (data_out != NULL) {
tmp_data = data_out;
} else {
tmp_data = (int *)data;
}
for (int i = 0; i < out_length / (audio_time * sizeof(int)); i++) {
for (int j = 0; j < audio_time; j++) {
data_out_1[audio_time * i + j] = tmp_data[i];
}
}
if (data_out != NULL) {
free(data_out);
data_out = NULL;
}
}
if (data_out != NULL) {
ret = esp_codec_dev_write(play_dev, (void *)data_out, out_length);
free(data_out);
} else if (data_out_1 != NULL) {
ret = esp_codec_dev_write(play_dev, (void *)data_out_1, out_length);
free(data_out_1);
} else {
ret = esp_codec_dev_write(play_dev, (void *)data, length);
}
return ret;
}
esp_err_t esp_get_feed_data(bool is_get_raw_channel, int16_t *buffer, int buffer_len)
{
esp_err_t ret = ESP_OK;
size_t bytes_read;
int audio_chunksize = buffer_len / (sizeof(int16_t) * ADC_I2S_CHANNEL);
ret = esp_codec_dev_read(record_dev, (void *)buffer, buffer_len);
if (!is_get_raw_channel) {
for (int i = 0; i < audio_chunksize; i++) {
int16_t ref = buffer[4 * i + 0];
buffer[3 * i + 0] = buffer[4 * i + 1];
buffer[3 * i + 1] = buffer[4 * i + 3];
buffer[3 * i + 2] = ref;
}
}
return ret;
}
int esp_get_feed_channel(void)
{
return ADC_I2S_CHANNEL;
}
char* esp_get_input_format(void)
{
return "RMNM";
}
esp_err_t esp_board_init(uint32_t sample_rate, int channel_format, int bits_per_chan)
{
/*!< Initialize I2C bus, used for audio codec*/
i2c_master_init();
s_play_sample_rate = sample_rate;
if (channel_format != 2 && channel_format != 1) {
ESP_LOGE(TAG, "Unable to configure channel_format");
channel_format = 2;
}
s_play_channel_format = channel_format;
if (bits_per_chan != 32 && bits_per_chan != 16) {
ESP_LOGE(TAG, "Unable to configure bits_per_chan");
bits_per_chan = 32;
}
s_bits_per_chan = bits_per_chan;
bsp_i2s_init(I2S_NUM_1, 16000, 2, 32);
// Because record and play use the same i2s.
bsp_codec_init(16000, 16000, 2, 32);
/* Initialize PA */
/*gpio_config_t io_conf;
memset(&io_conf, 0, sizeof(io_conf));
io_conf.intr_type = GPIO_INTR_DISABLE;
io_conf.mode = GPIO_MODE_OUTPUT;
io_conf.pin_bit_mask = ((1ULL << GPIO_PWR_CTRL));
io_conf.pull_down_en = 0;
io_conf.pull_up_en = 0;
gpio_config(&io_conf);
gpio_set_level(GPIO_PWR_CTRL, 1);*/
return ESP_OK;
}
esp_err_t esp_sdcard_init(char *mount_point, size_t max_files)
{
if (NULL != card) {
return ESP_ERR_INVALID_STATE;
}
/* Check if SD crad is supported */
if (!FUNC_SDMMC_EN && !FUNC_SDSPI_EN) {
ESP_LOGE(TAG, "SDMMC and SDSPI not supported on this board!");
return ESP_ERR_NOT_SUPPORTED;
}
esp_err_t ret_val = ESP_OK;
/**
* @brief Options for mounting the filesystem.
* If format_if_mount_failed is set to true, SD card will be partitioned and
* formatted in case when mounting fails.
*
*/
esp_vfs_fat_sdmmc_mount_config_t mount_config = {
.format_if_mount_failed = false,
.max_files = max_files,
.allocation_unit_size = 16 * 1024
};
/**
* @brief Use settings defined above to initialize SD card and mount FAT filesystem.
* Note: esp_vfs_fat_sdmmc/sdspi_mount is all-in-one convenience functions.
* Please check its source code and implement error recovery when developing
* production applications.
*
*/
sdmmc_host_t host =
#if FUNC_SDMMC_EN
SDMMC_HOST_DEFAULT();
#else
SDSPI_HOST_DEFAULT();
spi_bus_config_t bus_cfg = {
.mosi_io_num = GPIO_SDSPI_MOSI,
.miso_io_num = GPIO_SDSPI_MISO,
.sclk_io_num = GPIO_SDSPI_SCLK,
.quadwp_io_num = GPIO_NUM_NC,
.quadhd_io_num = GPIO_NUM_NC,
.max_transfer_sz = 4000,
};
ret_val = spi_bus_initialize(host.slot, &bus_cfg, SPI_DMA_CH_AUTO);
if (ret_val != ESP_OK) {
ESP_LOGE(TAG, "Failed to initialize bus.");
return ret_val;
}
#endif
/**
* @brief This initializes the slot without card detect (CD) and write protect (WP) signals.
* Modify slot_config.gpio_cd and slot_config.gpio_wp if your board has these signals.
*
*/
#if FUNC_SDMMC_EN
sdmmc_slot_config_t slot_config = SDMMC_SLOT_CONFIG_DEFAULT();
#else
sdspi_device_config_t slot_config = SDSPI_DEVICE_CONFIG_DEFAULT();
#endif
#if FUNC_SDMMC_EN
/* Config SD data width. 0, 4 or 8. Currently for SD card, 8 bit is not supported. */
slot_config.width = SDMMC_BUS_WIDTH;
/**
* @brief On chips where the GPIOs used for SD card can be configured, set them in
* the slot_config structure.
*
*/
#if SOC_SDMMC_USE_GPIO_MATRIX
slot_config.clk = GPIO_SDMMC_CLK;
slot_config.cmd = GPIO_SDMMC_CMD;
slot_config.d0 = GPIO_SDMMC_D0;
slot_config.d1 = GPIO_SDMMC_D1;
slot_config.d2 = GPIO_SDMMC_D2;
slot_config.d3 = GPIO_SDMMC_D3;
#endif
slot_config.cd = GPIO_SDMMC_DET;
slot_config.flags |= SDMMC_SLOT_FLAG_INTERNAL_PULLUP;
#else
slot_config.gpio_cs = GPIO_SDSPI_CS;
slot_config.host_id = host.slot;
#endif
/**
* @brief Enable internal pullups on enabled pins. The internal pullups
* are insufficient however, please make sure 10k external pullups are
* connected on the bus. This is for debug / example purpose only.
*/
/* get FAT filesystem on SD card registered in VFS. */
ret_val =
#if FUNC_SDMMC_EN
esp_vfs_fat_sdmmc_mount(mount_point, &host, &slot_config, &mount_config, &card);
#else
esp_vfs_fat_sdspi_mount(mount_point, &host, &slot_config, &mount_config, &card);
#endif
/* Check for SDMMC mount result. */
if (ret_val != ESP_OK) {
if (ret_val == ESP_FAIL) {
ESP_LOGE(TAG, "Failed to mount filesystem. "
"If you want the card to be formatted, set the EXAMPLE_FORMAT_IF_MOUNT_FAILED menuconfig option.");
} 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_val));
}
return ret_val;
}
/* Card has been initialized, print its properties. */
sdmmc_card_print_info(stdout, card);
SDCard_Size = ((uint64_t) card->csd.capacity) * card->csd.sector_size / (1024 * 1024);
return ret_val;
}
esp_err_t esp_sdcard_deinit(char *mount_point)
{
if (NULL == mount_point) {
return ESP_ERR_INVALID_STATE;
}
/* Unmount an SD card from the FAT filesystem and release resources acquired */
esp_err_t ret_val = esp_vfs_fat_sdcard_unmount(mount_point, card);
/* Make SD/MMC card information structure pointer NULL */
card = NULL;
return ret_val;
}
#define MOUNT_POINT "/sdcard"
static const char *SD_TAG = "SD";
uint16_t Folder_retrieval(const char* directory, const char* fileExtension, char File_Name[][MAX_FILE_NAME_SIZE], uint16_t maxFiles)
{
DIR *dir = opendir(directory);
if (dir == NULL) {
ESP_LOGE(SD_TAG, "Path: <%s> does not exist", directory);
return 0;
}
uint16_t fileCount = 0;
struct dirent *entry;
while ((entry = readdir(dir)) != NULL && fileCount < maxFiles) {
if (strcmp(entry->d_name, ".") == 0 || strcmp(entry->d_name, "..") == 0) {
continue;
}
const char *dot = strrchr(entry->d_name, '.');
if (dot != NULL && dot != entry->d_name) {
if (strcasecmp(dot, fileExtension) == 0) {
strncpy(File_Name[fileCount], entry->d_name, MAX_FILE_NAME_SIZE - 1);
File_Name[fileCount][MAX_FILE_NAME_SIZE - 1] = '\0';
char filePath[MAX_PATH_SIZE];
snprintf(filePath, MAX_PATH_SIZE, "%s/%s", directory, entry->d_name);
printf("File found: %s\r\n", filePath);
fileCount++;
}
}
else{
// printf("No extension found for file: %s\r\n", entry->d_name);
}
}
closedir(dir);
if (fileCount > 0) {
ESP_LOGI(SD_TAG, "Retrieved %d files with extension '%s'", fileCount, fileExtension);
} else {
ESP_LOGW(SD_TAG, "No files with extension '%s' found in directory: %s", fileExtension, directory);
}
return fileCount;
}
main/hardeware_driver/bsp_board.h
+213
View File
@@ -0,0 +1,213 @@
#pragma once
#include "driver/gpio.h"
#include "driver/i2s_std.h"
#include "driver/i2s_tdm.h"
#include "driver/i2c_master.h"
#include "soc/soc_caps.h"
#include "esp_idf_version.h"
#include "esp_codec_dev.h"
#include "esp_codec_dev_defaults.h"
#include "esp_codec_dev_os.h"
#include "sdkconfig.h"
#include "device_config.h"
#ifdef __cplusplus
extern "C" {
#endif
#define MAX_FILE_NAME_SIZE 100 // Define maximum file name size
#define MAX_PATH_SIZE 512 // Define a larger size for the full path
/**
* @brief ESP32-S3-CAM-OVxxxx I2C GPIO defineation
*
*/
#define I2C_NUM (0)
#define GPIO_I2C_SCL (GPIO_NUM_10)
#define GPIO_I2C_SDA (GPIO_NUM_11)
/**
* @brief ESP32-S3-CAM-OVxxxx SDMMC GPIO defination
*
* @note Only avaliable when PMOD connected
*/
#define FUNC_SDMMC_EN (1)
#define SDMMC_BUS_WIDTH (1)
#define GPIO_SDMMC_CLK (GPIO_NUM_40)
#define GPIO_SDMMC_CMD (GPIO_NUM_42)
#define GPIO_SDMMC_D0 (GPIO_NUM_41)
#define GPIO_SDMMC_D1 (GPIO_NUM_NC)
#define GPIO_SDMMC_D2 (GPIO_NUM_NC)
#define GPIO_SDMMC_D3 (GPIO_NUM_NC)
#define GPIO_SDMMC_DET (GPIO_NUM_NC)
/**
* @brief ESP32-S3-CAM-OVxxxx SDSPI GPIO definationv
*
*/
#define FUNC_SDSPI_EN (0)
#define SDSPI_HOST (SPI2_HOST)
#define GPIO_SDSPI_CS (GPIO_NUM_NC)
#define GPIO_SDSPI_SCLK (GPIO_NUM_NC)
#define GPIO_SDSPI_MISO (GPIO_NUM_NC)
#define GPIO_SDSPI_MOSI (GPIO_NUM_NC)
/**
* @brief ESP32-S3-CAM-OVxxxx I2S GPIO defination
*
*/
#define FUNC_I2S_EN (1)
#define GPIO_I2S_LRCK (GPIO_NUM_14)
#define GPIO_I2S_MCLK (GPIO_NUM_12)
#define GPIO_I2S_SCLK (GPIO_NUM_13)
#ifdef MODEL_PROTO_1
#define GPIO_I2S_SDIN (GPIO_NUM_16) // Swapped for PROTO-1
#define GPIO_I2S_DOUT (GPIO_NUM_15) // Swapped for PROTO-1
#else
#define GPIO_I2S_SDIN (GPIO_NUM_15)
#define GPIO_I2S_DOUT (GPIO_NUM_16)
#endif
/**
* @brief ESP32-S3-CAM-OVxxxx I2S GPIO defination
*
*/
#define FUNC_I2S0_EN (0)
#define GPIO_I2S0_LRCK (GPIO_NUM_NC)
#define GPIO_I2S0_MCLK (GPIO_NUM_NC)
#define GPIO_I2S0_SCLK (GPIO_NUM_NC)
#define GPIO_I2S0_SDIN (GPIO_NUM_NC)
#define GPIO_I2S0_DOUT (GPIO_NUM_NC)
/**
* @brief record configurations
*
*/
#define RECORD_VOLUME (30.0)
/**
* @brief player configurations
*
*/
#define PLAYER_VOLUME (60)
/**
* @brief ESP32-S3-HMI-DevKit power control IO
*
* @note Some power control pins might not be listed yet
*
*/
//#define FUNC_PWR_CTRL (1)
#define GPIO_PWR_CTRL (-1)
#define GPIO_PWR_ON_LEVEL (1)
#if ESP_IDF_VERSION >= ESP_IDF_VERSION_VAL(5, 0, 0)
#define I2S_CONFIG_DEFAULT(sample_rate, channel_fmt, bits_per_chan) { \
.clk_cfg = I2S_STD_CLK_DEFAULT_CONFIG(16000), \
.slot_cfg = I2S_STD_PHILIPS_SLOT_DEFAULT_CONFIG(32, I2S_SLOT_MODE_STEREO), \
.gpio_cfg = { \
.mclk = GPIO_I2S_MCLK, \
.bclk = GPIO_I2S_SCLK, \
.ws = GPIO_I2S_LRCK, \
.dout = GPIO_I2S_DOUT, \
.din = GPIO_I2S_SDIN, \
}, \
}
#else
#define I2S_CONFIG_DEFAULT(sample_rate, channel_fmt, bits_per_chan) { \
.mode = I2S_MODE_MASTER | I2S_MODE_RX | I2S_MODE_TX, \
.sample_rate = 16000, \
.bits_per_sample = I2S_BITS_PER_SAMPLE_32BIT, \
.channel_format = I2S_CHANNEL_FMT_RIGHT_LEFT, \
.communication_format = I2S_COMM_FORMAT_STAND_I2S, \
.intr_alloc_flags = ESP_INTR_FLAG_LEVEL1, \
.dma_buf_count = 6, \
.dma_buf_len = 160, \
.use_apll = false, \
.tx_desc_auto_clear = true, \
.fixed_mclk = 0, \
.mclk_multiple = I2S_MCLK_MULTIPLE_DEFAULT, \
.bits_per_chan = I2S_BITS_PER_CHAN_32BIT, \
}
#endif
/* LCD settings */
#define EXAMPLE_LCD_SPI_NUM (SPI3_HOST)
#define EXAMPLE_LCD_PIXEL_CLK_HZ (80 * 1000 * 1000)
#define EXAMPLE_LCD_CMD_BITS (8)
#define EXAMPLE_LCD_PARAM_BITS (8)
#define EXAMPLE_LCD_BITS_PER_PIXEL (16)
#define EXAMPLE_LCD_DRAW_BUFF_DOUBLE (1)
#define EXAMPLE_LCD_DRAW_BUFF_HEIGHT (50)
#define EXAMPLE_LCD_BL_ON_LEVEL (1)
#define Backlight_MAX 100
#define DEFAULT_BACKLIGHT 80
/* LCD pins */
#define EXAMPLE_LCD_GPIO_SCLK (GPIO_NUM_5)
#define EXAMPLE_LCD_GPIO_MOSI (GPIO_NUM_1)
#define EXAMPLE_LCD_GPIO_RST (GPIO_NUM_NC)
#define EXAMPLE_LCD_GPIO_DC (GPIO_NUM_3)
#define EXAMPLE_LCD_GPIO_CS (GPIO_NUM_6)
#define EXAMPLE_LCD_GPIO_BL (GPIO_NUM_NC)
/* LCD touch pins */
#define EXAMPLE_TOUCH_GPIO_RST (GPIO_NUM_NC)
#ifdef CONFIG_WAVESHARE_1_47INCH_TOUCH_LCD
#define EXAMPLE_LCD_H_RES (172)
#define EXAMPLE_LCD_V_RES (320)
#define EXAMPLE_TOUCH_GPIO_INT (GPIO_NUM_9)
#elif defined(CONFIG_WAVESHARE_2INCH_TOUCH_LCD)
#define EXAMPLE_LCD_H_RES (240)
#define EXAMPLE_LCD_V_RES (320)
#define EXAMPLE_TOUCH_GPIO_INT (GPIO_NUM_9)
#elif defined(CONFIG_WAVESHARE_2_8INCH_TOUCH_LCD)
#define EXAMPLE_LCD_H_RES (240)
#define EXAMPLE_LCD_V_RES (320)
#define EXAMPLE_TOUCH_GPIO_INT (GPIO_NUM_NC)
#elif defined(CONFIG_WAVESHARE_3_5INCH_TOUCH_LCD)
#define EXAMPLE_LCD_H_RES (320)
#define EXAMPLE_LCD_V_RES (480)
#define EXAMPLE_TOUCH_GPIO_INT (GPIO_NUM_9)
#endif
// GPIO assignment
#ifdef MODEL_PROTO_1
#define LED_STRIP_GPIO_PIN 9
#else
#define LED_STRIP_GPIO_PIN 38
#endif
#define LED_STRIP_LED_COUNT 7
esp_err_t esp_board_init(uint32_t sample_rate, int channel_format, int bits_per_chan);
esp_err_t esp_sdcard_init(char *mount_point, size_t max_files);
esp_err_t esp_sdcard_deinit(char *mount_point);
esp_err_t esp_audio_play(const int16_t* data, int length, uint32_t ticks_to_wait);
esp_err_t esp_get_feed_data(bool is_get_raw_channel, int16_t *buffer, int buffer_len);
int esp_get_feed_channel(void);
char* esp_get_input_format(void);
esp_err_t esp_audio_set_play_vol(int volume);
esp_err_t esp_audio_get_play_vol(int *volume);
i2c_master_bus_handle_t esp_ret_i2c_handle(void);
esp_codec_dev_handle_t esp_ret_play_dev();
uint32_t Get_SD_Size(void);
uint16_t Folder_retrieval(const char* directory, const char* fileExtension, char File_Name[][MAX_FILE_NAME_SIZE], uint16_t maxFiles) ;
#ifdef __cplusplus
}
#endif