furyhawk/xiaozhi-esp32
1
0
Fork 0
mirror of https://github.com/78/xiaozhi-esp32.git synced 2026-07-21 02:05:52 +00:00
Code Issues Packages Projects Releases Wiki Activity

Content: add esp32_s3_touch_lcd_7c

Browse Source
This commit is contained in:
CQ793
2026-07-03 14:17:43 +08:00
parent 7a7ac87640
commit 81b5e6bb15
7 changed files with 766 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files
main/CMakeLists.txt
+6
View File
@@ -376,6 +376,12 @@ elseif(CONFIG_BOARD_TYPE_WAVESHARE_ESP32_S3_TOUCH_LCD_4_3C)
set(BUILTIN_TEXT_FONT font_puhui_basic_30_4)
set(BUILTIN_ICON_FONT font_awesome_30_4)
set(DEFAULT_EMOJI_COLLECTION twemoji_64)
elseif(CONFIG_BOARD_TYPE_WAVESHARE_ESP32_S3_TOUCH_LCD_7C)
set(MANUFACTURER "waveshare")
set(BOARD_TYPE "esp32-s3-touch-lcd-7c")
set(BUILTIN_TEXT_FONT font_puhui_basic_30_4)
set(BUILTIN_ICON_FONT font_awesome_30_4)
set(DEFAULT_EMOJI_COLLECTION twemoji_64)
elseif(CONFIG_BOARD_TYPE_WAVESHARE_ESP32_S3_TOUCH_AMOLED_1_75)
set(MANUFACTURER "waveshare")
set(BOARD_TYPE "esp32-s3-touch-amoled-1.75")
main/Kconfig.projbuild
+3
View File
@@ -360,6 +360,9 @@ choice BOARD_TYPE
config BOARD_TYPE_WAVESHARE_ESP32_S3_TOUCH_LCD_4_3C
bool "Waveshare ESP32-S3-Touch-LCD-4.3C"
depends on IDF_TARGET_ESP32S3
config BOARD_TYPE_WAVESHARE_ESP32_S3_TOUCH_LCD_7C
bool "Waveshare ESP32-S3-Touch-LCD-7C"
depends on IDF_TARGET_ESP32S3
config BOARD_TYPE_WAVESHARE_ESP32_S3_TOUCH_LCD_1_85C
bool "Waveshare ESP32-S3-Touch-LCD-1.85C"
depends on IDF_TARGET_ESP32S3
main/boards/waveshare/esp32-s3-touch-lcd-7c/config.h
+91
View File
@@ -0,0 +1,91 @@
#ifndef _BOARD_CONFIG_H_
#define _BOARD_CONFIG_H_
#include <driver/gpio.h>
#include "custom_io_expander_ch32v003.h"
#define AUDIO_INPUT_SAMPLE_RATE 24000
#define AUDIO_OUTPUT_SAMPLE_RATE 24000
#define AUDIO_INPUT_REFERENCE true
#define BSP_USB_DP (GPIO_NUM_20)
#define BSP_I2S_SCLK (GPIO_NUM_44)
#define BSP_I2S_MCLK (GPIO_NUM_6)
#define BSP_I2S_LCLK (GPIO_NUM_16)
#define BSP_I2S_DOUT (GPIO_NUM_15) // To Codec ES8389
#define BSP_I2S_DSIN (GPIO_NUM_43) // From ADC ES7210
#define BSP_POWER_AMP_IO (IO_EXPANDER_PIN_NUM_3)
#define BSP_PA_PIN (GPIO_NUM_NC)
#define BSP_I2C_SCL (GPIO_NUM_48)
#define BSP_I2C_SDA (GPIO_NUM_47)
#define BSP_CODEC_ES8389_ADDR (0X20)
#define BSP_CODEC_ES7210_ADDR ES7210_CODEC_DEFAULT_ADDR
#define BSP_IO_EXPANDER_I2C_ADDRESS CUSTOM_IO_EXPANDER_I2C_CH32V003_ADDRESS
#define BOOT_BUTTON_GPIO GPIO_NUM_0
/* Display */
#define BSP_LCD_VSYNC (GPIO_NUM_3)
#define BSP_LCD_HSYNC (GPIO_NUM_46)
#define BSP_LCD_DE (GPIO_NUM_5)
#define BSP_LCD_PCLK (GPIO_NUM_7)
#define BSP_LCD_DISP (GPIO_NUM_NC)
// Blue data signals
#define BSP_LCD_DATA0 (GPIO_NUM_14) ///< B3
#define BSP_LCD_DATA1 (GPIO_NUM_38) ///< B4
#define BSP_LCD_DATA2 (GPIO_NUM_18) ///< B5
#define BSP_LCD_DATA3 (GPIO_NUM_17) ///< B6
#define BSP_LCD_DATA4 (GPIO_NUM_10) ///< B7
// Green data signals
#define BSP_LCD_DATA5 (GPIO_NUM_39) ///< G2
#define BSP_LCD_DATA6 (GPIO_NUM_0) ///< G3
#define BSP_LCD_DATA7 (GPIO_NUM_45) ///< G4
#define BSP_LCD_DATA8 (GPIO_NUM_9) ///< G5
#define BSP_LCD_DATA9 (GPIO_NUM_8) ///< G6
#define BSP_LCD_DATA10 (GPIO_NUM_21) ///< G7
// Red data signals
#define BSP_LCD_DATA11 (GPIO_NUM_1) ///< R3
#define BSP_LCD_DATA12 (GPIO_NUM_2) ///< R4
#define BSP_LCD_DATA13 (GPIO_NUM_42) ///< R5
#define BSP_LCD_DATA14 (GPIO_NUM_41) ///< R6
#define BSP_LCD_DATA15 (GPIO_NUM_40) ///< R7
#define BSP_LCD_BACKLIGHT (IO_EXPANDER_PIN_NUM_2)
#define BSP_LCD_RST (GPIO_NUM_NC)
#define BSP_LCD_TOUCH_RST (IO_EXPANDER_PIN_NUM_1)
#define BSP_LCD_TOUCH_INT (GPIO_NUM_4)
/* LCD display color format */
#define BSP_LCD_COLOR_FORMAT (ESP_LCD_COLOR_FORMAT_RGB565)
/* LCD display color bytes endianess */
#define BSP_LCD_BIGENDIAN (1)
/* LCD display color bits */
#define BSP_LCD_BITS_PER_PIXEL (16)
#define BSP_LCD_BIT_PER_PIXEL (18)
#define BSP_RGB_DATA_WIDTH (16)
/* LCD display definition */
#define BSP_LCD_H_RES (800)
#define BSP_LCD_V_RES (480)
#define DISPLAY_MIRROR_X false
#define DISPLAY_MIRROR_Y false
#define DISPLAY_SWAP_XY false
#define DISPLAY_OFFSET_X 0
#define DISPLAY_OFFSET_Y 0
#define DISPLAY_BACKLIGHT_PIN GPIO_NUM_NC
#define DISPLAY_BACKLIGHT_OUTPUT_INVERT true
#endif // _BOARD_CONFIG_H_
main/boards/waveshare/esp32-s3-touch-lcd-7c/config.json
+16
View File
@@ -0,0 +1,16 @@
{
"target": "esp32s3",
"builds": [
{
"name": "waveshare-s3-touch-lcd-7c",
"sdkconfig_append": [
"CONFIG_BOARD_TYPE_ESP32S3_Touch_LCD_7C=y",
"CONFIG_ESPTOOLPY_FLASHSIZE_32MB=y",
"CONFIG_PARTITION_TABLE_CUSTOM_FILENAME=\"partitions/v2/32m.csv\"",
"CONFIG_USE_DEVICE_AEC=y",
"CONFIG_SPIRAM_FETCH_INSTRUCTIONS=y",
"CONFIG_SPIRAM_RODATA=y"
]
}
]
}
main/boards/waveshare/esp32-s3-touch-lcd-7c/esp32_s3_touch_lcd_7c.cc
+315
View File
@@ -0,0 +1,315 @@
#include "wifi_board.h"
#include "display/lcd_display.h"
// #include "font_awesome_symbols.h"
#include "codecs/box_audio_codec.h"
#include "waveshare_audio_codec.h"
#include "application.h"
#include "button.h"
#include "led/single_led.h"
#include "mcp_server.h"
#include "config.h"
#include "power_save_timer.h"
#include <wifi_station.h>
#include <esp_log.h>
#include <esp_lcd_panel_vendor.h>
#include <esp_idf_version.h>
#include <driver/i2c_master.h>
#include "i2c_bus.h"
#include "bq27220.h"
#include "settings.h"
#include <esp_lcd_touch_gt911.h>
#include <esp_lvgl_port.h>
#include <lvgl.h>
#include <esp_lcd_panel_io.h>
#include <esp_lcd_panel_ops.h>
#include <esp_lcd_panel_rgb.h>
#define TAG "WaveshareEsp32s3TouchLCD7c"
class CustomBacklight : public Backlight {
public:
CustomBacklight(esp_io_expander_handle_t io_handle)
: Backlight(), io_handle_(io_handle) {}
protected:
esp_io_expander_handle_t io_handle_;
virtual void SetBrightnessImpl(uint8_t brightness) override {
if (brightness > 100) brightness = 100;
int flipped_brightness = brightness;
custom_io_expander_set_pwm(io_handle_, flipped_brightness * 255 / 100);
}
};
class WaveshareEsp32s3TouchLCD7c : public WifiBoard {
private:
i2c_bus_handle_t i2c_bus_handle_ = NULL;
i2c_master_bus_handle_t i2c_bus_;
LcdDisplay* display_;
esp_io_expander_handle_t io_expander = NULL;
PowerSaveTimer* power_save_timer_;
CustomBacklight *backlight_;
bq27220_handle_t bq27220_ = NULL;
void InitializePowerSaveTimer() {
power_save_timer_ = new PowerSaveTimer(-1, 60, 300);
power_save_timer_->OnEnterSleepMode([this]() {
GetDisplay()->SetPowerSaveMode(true);
GetBacklight()->SetBrightness(5); });
power_save_timer_->OnExitSleepMode([this]() {
GetDisplay()->SetPowerSaveMode(false);
GetBacklight()->RestoreBrightness();});
power_save_timer_->SetEnabled(true);
}
// void InitializeGpio() {
// // Zero-initialize the GPIO configuration structure
// gpio_config_t io_conf = {};
// io_conf.intr_type = GPIO_INTR_DISABLE; // Disable interrupts for this pin
// io_conf.pin_bit_mask = 1ULL << BSP_LCD_TOUCH_INT; // Select the GPIO pin using a bitmask
// io_conf.mode = GPIO_MODE_OUTPUT; // Set pin as output
// io_conf.pull_up_en = GPIO_PULLUP_DISABLE; // Disable pull-up
// gpio_config(&io_conf); // Apply the configuration
// }
void InitializeCodecI2c() {
i2c_config_t i2c_cfg = {};
i2c_cfg.mode = I2C_MODE_MASTER;
i2c_cfg.sda_io_num = BSP_I2C_SDA;
i2c_cfg.sda_pullup_en = GPIO_PULLUP_ENABLE;
i2c_cfg.scl_io_num = BSP_I2C_SCL;
i2c_cfg.scl_pullup_en = GPIO_PULLUP_ENABLE;
i2c_cfg.master.clk_speed = 100 * 1000;
i2c_bus_handle_ = i2c_bus_create(I2C_NUM_0, &i2c_cfg);
ESP_ERROR_CHECK(i2c_bus_handle_ == NULL ? ESP_FAIL : ESP_OK);
i2c_bus_ = i2c_bus_get_internal_bus_handle(i2c_bus_handle_);
ESP_ERROR_CHECK(i2c_bus_ == NULL ? ESP_FAIL : ESP_OK);
}
void InitializeBq27220() {
static parameter_cedv_t default_cedv = {
.full_charge_cap = 1000,
.design_cap = 1000,
.reserve_cap = 0,
.near_full = 100,
.self_discharge_rate = 10,
.EDV0 = 3200,
.EDV1 = 3300,
.EDV2 = 3400,
.EMF = 3670,
.C0 = 115,
.R0 = 968,
.T0 = 4547,
.R1 = 4764,
.TC = 11,
.C1 = 0,
.DOD0 = 4200,
.DOD10 = 4100,
.DOD20 = 4000,
.DOD30 = 3920,
.DOD40 = 3850,
.DOD50 = 3800,
.DOD60 = 3750,
.DOD70 = 3700,
.DOD80 = 3600,
.DOD90 = 3450,
.DOD100 = 3200,
};
static const gauging_config_t default_config = {
.CCT = 1,
.CSYNC = 0,
.EDV_CMP = 0,
.SC = 1,
.FIXED_EDV0 = 0,
.FCC_LIM = 1,
.FC_FOR_VDQ = 1,
.IGNORE_SD = 1,
.SME0 = 0,
};
bq27220_config_t bq27220_cfg = {
.i2c_bus = i2c_bus_handle_,
.cfg = &default_config,
.cedv = &default_cedv,
};
bq27220_ = bq27220_create(&bq27220_cfg);
if (bq27220_ == NULL) {
ESP_LOGW(TAG, "BQ27220 not detected, battery reporting disabled");
}
}
void InitializeCustomio(void) {
custom_io_expander_new_i2c_ch32v003(i2c_bus_, BSP_IO_EXPANDER_I2C_ADDRESS, &io_expander);
esp_io_expander_set_dir(io_expander, BSP_POWER_AMP_IO | BSP_LCD_BACKLIGHT | BSP_LCD_TOUCH_RST | IO_EXPANDER_PIN_NUM_6, IO_EXPANDER_OUTPUT);
esp_io_expander_set_level(io_expander, BSP_LCD_BACKLIGHT | BSP_LCD_TOUCH_RST | BSP_POWER_AMP_IO, 1);
esp_io_expander_set_level(io_expander, IO_EXPANDER_PIN_NUM_6, 1);
esp_io_expander_set_level(io_expander, BSP_LCD_TOUCH_RST, 0);
vTaskDelay(pdMS_TO_TICKS(200));
gpio_set_level(BSP_LCD_TOUCH_INT, 0);
vTaskDelay(pdMS_TO_TICKS(200));
esp_io_expander_set_level(io_expander, BSP_LCD_TOUCH_RST, 1);
vTaskDelay(pdMS_TO_TICKS(200));
}
void InitializeRGB() {
esp_lcd_panel_io_handle_t panel_io = nullptr;
esp_lcd_panel_handle_t panel_handle = nullptr;
esp_lcd_rgb_panel_config_t rgb_config = {
.clk_src = LCD_CLK_SRC_DEFAULT,
.timings = {
.pclk_hz = 16 * 1000 * 1000,
.h_res = BSP_LCD_H_RES,
.v_res = BSP_LCD_V_RES,
.hsync_pulse_width = 4,
.hsync_back_porch = 8,
.hsync_front_porch = 8,
.vsync_pulse_width = 4,
.vsync_back_porch = 8,
.vsync_front_porch = 8,
.flags = {
.pclk_active_neg = true
}
},
.data_width = 16,
.bits_per_pixel = 16,
.num_fbs = 2,
.bounce_buffer_size_px = BSP_LCD_H_RES * 10,
.psram_trans_align = 64,
.hsync_gpio_num = BSP_LCD_HSYNC,
.vsync_gpio_num = BSP_LCD_VSYNC,
.de_gpio_num = BSP_LCD_DE,
.pclk_gpio_num = BSP_LCD_PCLK,
.disp_gpio_num = BSP_LCD_DISP,
.data_gpio_nums = {
BSP_LCD_DATA0, BSP_LCD_DATA1, BSP_LCD_DATA2, BSP_LCD_DATA3,
BSP_LCD_DATA4, BSP_LCD_DATA5, BSP_LCD_DATA6, BSP_LCD_DATA7,
BSP_LCD_DATA8, BSP_LCD_DATA9, BSP_LCD_DATA10, BSP_LCD_DATA11,
BSP_LCD_DATA12, BSP_LCD_DATA13, BSP_LCD_DATA14, BSP_LCD_DATA15
},
.flags = {
.fb_in_psram = 1,
},
};
ESP_ERROR_CHECK(esp_lcd_new_rgb_panel(&rgb_config, &panel_handle));
ESP_ERROR_CHECK(esp_lcd_panel_init(panel_handle));
display_ = new RgbLcdDisplay(panel_io, panel_handle,
BSP_LCD_H_RES, BSP_LCD_V_RES, DISPLAY_OFFSET_X, DISPLAY_OFFSET_Y, DISPLAY_MIRROR_X,
DISPLAY_MIRROR_Y, DISPLAY_SWAP_XY);
backlight_ = new CustomBacklight(io_expander);
backlight_->RestoreBrightness();
}
void InitializeTouch() {
esp_lcd_touch_handle_t tp;
esp_lcd_touch_config_t tp_cfg = {
.x_max = BSP_LCD_H_RES - 1,
.y_max = BSP_LCD_V_RES - 1,
.rst_gpio_num = GPIO_NUM_NC,
.int_gpio_num = GPIO_NUM_NC,
.levels = {
.reset = 0,
.interrupt = 0,
},
.flags = {
.swap_xy = 0,
.mirror_x = 0,
.mirror_y = 0,
},
};
esp_lcd_panel_io_handle_t tp_io_handle = NULL;
esp_lcd_panel_io_i2c_config_t tp_io_config = {};
tp_io_config.scl_speed_hz = 400 * 1000;
tp_io_config.dev_addr = ESP_LCD_TOUCH_IO_I2C_GT911_ADDRESS;
tp_io_config.control_phase_bytes = 1;
tp_io_config.dc_bit_offset = 0;
tp_io_config.lcd_cmd_bits = 16;
tp_io_config.flags.disable_control_phase = 1;
esp_lcd_new_panel_io_i2c(i2c_bus_, &tp_io_config, &tp_io_handle);
ESP_LOGI(TAG, "Initialize touch controller");
ESP_ERROR_CHECK(esp_lcd_touch_new_i2c_gt911(tp_io_handle, &tp_cfg, &tp));
const lvgl_port_touch_cfg_t touch_cfg = {
.disp = lv_display_get_default(),
.handle = tp,
};
lvgl_port_add_touch(&touch_cfg);
ESP_LOGI(TAG, "Touch panel initialized successfully");
}
public:
WaveshareEsp32s3TouchLCD7c() {
InitializePowerSaveTimer();
// InitializeGpio();
InitializeCodecI2c();
InitializeBq27220();
InitializeCustomio();
InitializeRGB();
InitializeTouch();
GetBacklight()->SetBrightness(100);
}
virtual AudioCodec* GetAudioCodec() override {
static WaveshareAudioCodec audio_codec(
i2c_bus_,
AUDIO_INPUT_SAMPLE_RATE,
AUDIO_OUTPUT_SAMPLE_RATE,
BSP_I2S_MCLK,
BSP_I2S_SCLK,
BSP_I2S_LCLK,
BSP_I2S_DOUT,
BSP_I2S_DSIN,
BSP_PA_PIN,
BSP_CODEC_ES8389_ADDR,
BSP_CODEC_ES7210_ADDR,
AUDIO_INPUT_REFERENCE
);
return &audio_codec;
}
virtual Display* GetDisplay() override {
return display_;
}
virtual Backlight *GetBacklight() override {
return backlight_;
}
virtual bool GetBatteryLevel(int& level, bool& charging, bool& discharging) override {
static bool last_discharging = false;
charging = (bq27220_get_current(bq27220_) > 0);
discharging = !charging;
if (discharging != last_discharging) {
power_save_timer_->SetEnabled(discharging);
last_discharging = discharging;
}
level = bq27220_get_state_of_charge(bq27220_);
return true;
}
virtual void SetPowerSaveLevel(PowerSaveLevel level) override {
if (level != PowerSaveLevel::LOW_POWER) {
power_save_timer_->WakeUp();
}
WifiBoard::SetPowerSaveLevel(level);
}
};
DECLARE_BOARD(WaveshareEsp32s3TouchLCD7c);
main/boards/waveshare/esp32-s3-touch-lcd-7c/waveshare_audio_codec.cc
+293
View File
@@ -0,0 +1,293 @@
#include "waveshare_audio_codec.h"
#include <esp_log.h>
#include <driver/i2c_master.h>
#include <driver/i2s_tdm.h>
#include <cstring>
static const char TAG[] = "WaveshareAudioCodec";
WaveshareAudioCodec::WaveshareAudioCodec(void* i2c_master_handle, int input_sample_rate, int output_sample_rate,
gpio_num_t mclk, gpio_num_t bclk, gpio_num_t ws, gpio_num_t dout, gpio_num_t din,
gpio_num_t pa_pin, uint8_t es8389_addr, uint8_t es7210_addr, bool input_reference) {
duplex_ = true; // 是否双工
pa_pin_ = pa_pin;
input_reference_ = input_reference; // 是否使用参考输入，实现回声消除
input_channels_ = input_reference_ ? 2 : 1; // 输入通道数
input_sample_rate_ = input_sample_rate;
output_sample_rate_ = output_sample_rate;
CreateDuplexChannels(mclk, bclk, ws, dout, din);
// Do initialize of related interface: data_if, ctrl_if and gpio_if
audio_codec_i2s_cfg_t i2s_cfg = {
.port = I2S_NUM_0,
.rx_handle = rx_handle_,
.tx_handle = tx_handle_,
};
data_if_ = audio_codec_new_i2s_data(&i2s_cfg);
assert(data_if_ != NULL);
// Output
audio_codec_i2c_cfg_t i2c_cfg = {
.port = (i2c_port_t)0,
.addr = es8389_addr,
.bus_handle = i2c_master_handle,
};
out_ctrl_if_ = audio_codec_new_i2c_ctrl(&i2c_cfg);
assert(out_ctrl_if_ != NULL);
gpio_if_ = audio_codec_new_gpio();
assert(gpio_if_ != NULL);
es8389_codec_cfg_t es8389_cfg = {};
es8389_cfg.ctrl_if = out_ctrl_if_;
es8389_cfg.gpio_if = gpio_if_;
es8389_cfg.codec_mode = ESP_CODEC_DEV_WORK_MODE_DAC;
es8389_cfg.pa_pin = pa_pin;
es8389_cfg.pa_reverted = false;
es8389_cfg.use_mclk = mclk >= 0;
es8389_cfg.hw_gain.pa_voltage = 5.0;
es8389_cfg.hw_gain.codec_dac_voltage = 3.3;
out_codec_if_ = es8389_codec_new(&es8389_cfg);
assert(out_codec_if_ != NULL);
esp_codec_dev_cfg_t dev_cfg = {
.dev_type = ESP_CODEC_DEV_TYPE_OUT,
.codec_if = out_codec_if_,
.data_if = data_if_,
};
output_dev_ = esp_codec_dev_new(&dev_cfg);
assert(output_dev_ != NULL);
// Input
i2c_cfg.addr = es7210_addr;
in_ctrl_if_ = audio_codec_new_i2c_ctrl(&i2c_cfg);
assert(in_ctrl_if_ != NULL);
es7210_codec_cfg_t es7210_cfg = {};
es7210_cfg.ctrl_if = in_ctrl_if_;
es7210_cfg.mic_selected = ES7210_SEL_MIC1 | ES7210_SEL_MIC2 | ES7210_SEL_MIC3 | ES7210_SEL_MIC4;
in_codec_if_ = es7210_codec_new(&es7210_cfg);
assert(in_codec_if_ != NULL);
dev_cfg.dev_type = ESP_CODEC_DEV_TYPE_IN;
dev_cfg.codec_if = in_codec_if_;
input_dev_ = esp_codec_dev_new(&dev_cfg);
assert(input_dev_ != NULL);
esp_codec_set_disable_when_closed(output_dev_, false);
esp_codec_set_disable_when_closed(input_dev_, false);
ESP_LOGI(TAG, "WaveshareAudioDevice initialized");
}
WaveshareAudioCodec::~WaveshareAudioCodec() {
ESP_ERROR_CHECK(esp_codec_dev_close(output_dev_));
esp_codec_dev_delete(output_dev_);
ESP_ERROR_CHECK(esp_codec_dev_close(input_dev_));
esp_codec_dev_delete(input_dev_);
audio_codec_delete_codec_if(in_codec_if_);
audio_codec_delete_ctrl_if(in_ctrl_if_);
audio_codec_delete_codec_if(out_codec_if_);
audio_codec_delete_ctrl_if(out_ctrl_if_);
audio_codec_delete_gpio_if(gpio_if_);
audio_codec_delete_data_if(data_if_);
}
void WaveshareAudioCodec::CreateDuplexChannels(gpio_num_t mclk, gpio_num_t bclk, gpio_num_t ws, gpio_num_t dout, gpio_num_t din) {
assert(input_sample_rate_ == output_sample_rate_);
i2s_chan_config_t chan_cfg = {
.id = I2S_NUM_0,
.role = I2S_ROLE_MASTER,
.dma_desc_num = AUDIO_CODEC_DMA_DESC_NUM,
.dma_frame_num = AUDIO_CODEC_DMA_FRAME_NUM,
.auto_clear_after_cb = true,
.auto_clear_before_cb = false,
.intr_priority = 0,
};
ESP_ERROR_CHECK(i2s_new_channel(&chan_cfg, &tx_handle_, &rx_handle_));
i2s_std_config_t std_cfg = {
.clk_cfg = {
.sample_rate_hz = (uint32_t)output_sample_rate_,
.clk_src = I2S_CLK_SRC_DEFAULT,
.ext_clk_freq_hz = 0,
.mclk_multiple = I2S_MCLK_MULTIPLE_256
},
.slot_cfg = {
.data_bit_width = I2S_DATA_BIT_WIDTH_16BIT,
.slot_bit_width = I2S_SLOT_BIT_WIDTH_AUTO,
.slot_mode = I2S_SLOT_MODE_STEREO,
.slot_mask = I2S_STD_SLOT_BOTH,
.ws_width = I2S_DATA_BIT_WIDTH_16BIT,
.ws_pol = false,
.bit_shift = true,
.left_align = true,
.big_endian = false,
.bit_order_lsb = false
},
.gpio_cfg = {
.mclk = mclk,
.bclk = bclk,
.ws = ws,
.dout = dout,
.din = I2S_GPIO_UNUSED,
.invert_flags = {
.mclk_inv = false,
.bclk_inv = false,
.ws_inv = false
}
}
};
ESP_ERROR_CHECK(i2s_channel_init_std_mode(tx_handle_, &std_cfg));
i2s_tdm_config_t tdm_cfg = {
.clk_cfg = {
.sample_rate_hz = (uint32_t)input_sample_rate_,
.clk_src = I2S_CLK_SRC_DEFAULT,
.ext_clk_freq_hz = 0,
.mclk_multiple = I2S_MCLK_MULTIPLE_256,
.bclk_div = 8,
},
.slot_cfg = {
.data_bit_width = I2S_DATA_BIT_WIDTH_16BIT,
.slot_bit_width = I2S_SLOT_BIT_WIDTH_AUTO,
.slot_mode = I2S_SLOT_MODE_STEREO,
.slot_mask = i2s_tdm_slot_mask_t(I2S_TDM_SLOT0 | I2S_TDM_SLOT1 | I2S_TDM_SLOT2 | I2S_TDM_SLOT3),
.ws_width = I2S_TDM_AUTO_WS_WIDTH,
.ws_pol = false,
.bit_shift = true,
.left_align = false,
.big_endian = false,
.bit_order_lsb = false,
.skip_mask = false,
.total_slot = I2S_TDM_AUTO_SLOT_NUM
},
.gpio_cfg = {
.mclk = mclk,
.bclk = bclk,
.ws = ws,
.dout = I2S_GPIO_UNUSED,
.din = din,
.invert_flags = {
.mclk_inv = false,
.bclk_inv = false,
.ws_inv = false
}
}
};
ESP_ERROR_CHECK(i2s_channel_init_tdm_mode(rx_handle_, &tdm_cfg));
ESP_ERROR_CHECK(i2s_channel_enable(tx_handle_));
ESP_ERROR_CHECK(i2s_channel_enable(rx_handle_));
ESP_LOGI(TAG, "Duplex channels created");
}
void WaveshareAudioCodec::SetOutputVolume(int volume) {
ESP_ERROR_CHECK(esp_codec_dev_set_out_vol(output_dev_, volume));
AudioCodec::SetOutputVolume(volume);
}
void WaveshareAudioCodec::EnableInput(bool enable) {
std::lock_guard<std::mutex> lock(data_if_mutex_);
if (enable == input_enabled_) {
return;
}
if (enable) {
esp_codec_dev_sample_info_t fs = {
.bits_per_sample = 16,
.channel = 4,
.channel_mask = ESP_CODEC_DEV_MAKE_CHANNEL_MASK(0),//0是MIC1 1是MIC3 2是MIC2 3是MIC4 ,目前只有0有效，其他还无效
.sample_rate = (uint32_t)input_sample_rate_,
.mclk_multiple = 0,
};
if (input_channels_ == 2) {
fs.channel_mask |= ESP_CODEC_DEV_MAKE_CHANNEL_MASK(1);
}
ESP_ERROR_CHECK(esp_codec_dev_open(input_dev_, &fs));
ESP_ERROR_CHECK(esp_codec_dev_set_in_channel_gain(input_dev_, ESP_CODEC_DEV_MAKE_CHANNEL_MASK(0) , 37.5));
} else {
ESP_ERROR_CHECK(esp_codec_dev_close(input_dev_));
}
AudioCodec::EnableInput(enable);
}
void WaveshareAudioCodec::EnableOutput(bool enable) {
std::lock_guard<std::mutex> lock(data_if_mutex_);
if (enable == output_enabled_) {
return;
}
if (enable) {
// Play 32bit 2 channel
esp_codec_dev_sample_info_t fs = {
.bits_per_sample = I2S_DATA_BIT_WIDTH_16BIT,
.channel = 2,
.sample_rate = (uint32_t)(output_sample_rate_),
.mclk_multiple = 0,
};
printf("EnableOutput sample_rate=%ld\n", fs.sample_rate);
ESP_ERROR_CHECK(esp_codec_dev_open(output_dev_, &fs));
ESP_ERROR_CHECK(esp_codec_dev_set_out_vol(output_dev_, output_volume_));
if (pa_pin_ != GPIO_NUM_NC) {
gpio_set_level(pa_pin_, 1);
}
}
else {
ESP_ERROR_CHECK(esp_codec_dev_close(output_dev_));
if (pa_pin_ != GPIO_NUM_NC) {
gpio_set_level(pa_pin_, 0);
}
}
AudioCodec::EnableOutput(enable);
}
int WaveshareAudioCodec::Read(int16_t* dest, int samples) {
if (input_enabled_) {
int ret = esp_codec_dev_read(input_dev_, (void*)dest, samples * sizeof(int16_t));
if (ret != ESP_CODEC_DEV_OK) {
static uint32_t read_fail_count = 0;
read_fail_count++;
std::memset(dest, 0, samples * sizeof(int16_t));
if (read_fail_count <= 3 || read_fail_count % 30 == 0) {
ESP_LOGW(TAG, "Read failed %lu times: %s", (unsigned long)read_fail_count, esp_err_to_name(ret));
}
}
}
return samples;
}
int WaveshareAudioCodec::Write(const int16_t* data, int frames)
{
if (!output_enabled_ || frames <= 0) {
return frames;
}
// xiaozhi 上层通常是 mono，这里统一扩展成 stereo
stereo_buffer_.resize(frames * 2);
for (int i = 0; i < frames; i++) {
int16_t s = data[i];
stereo_buffer_[2 * i] = s; // L
stereo_buffer_[2 * i + 1] = s; // R
}
size_t bytes = frames * 2 * sizeof(int16_t);
esp_err_t ret = esp_codec_dev_write(
output_dev_,
stereo_buffer_.data(),
bytes
);
if (ret != ESP_OK) {
ESP_LOGW("AudioCodec", "write failed: %s", esp_err_to_name(ret));
}
return frames;
}
main/boards/waveshare/esp32-s3-touch-lcd-7c/waveshare_audio_codec.h
+42
View File
@@ -0,0 +1,42 @@
#ifndef _SENSECAP_AUDIO_CODEC_H
#define _SENSECAP_AUDIO_CODEC_H
#include "audio_codec.h"
#include <esp_codec_dev.h>
#include <esp_codec_dev_defaults.h>
#include <mutex>
class WaveshareAudioCodec : public AudioCodec {
private:
const audio_codec_data_if_t* data_if_ = nullptr;
const audio_codec_ctrl_if_t* out_ctrl_if_ = nullptr;
const audio_codec_if_t* out_codec_if_ = nullptr;
const audio_codec_ctrl_if_t* in_ctrl_if_ = nullptr;
const audio_codec_if_t* in_codec_if_ = nullptr;
const audio_codec_gpio_if_t* gpio_if_ = nullptr;
std::vector<int16_t> stereo_buffer_;
esp_codec_dev_handle_t output_dev_ = nullptr;
esp_codec_dev_handle_t input_dev_ = nullptr;
gpio_num_t pa_pin_ = GPIO_NUM_NC;
std::mutex data_if_mutex_;
void CreateDuplexChannels(gpio_num_t mclk, gpio_num_t bclk, gpio_num_t ws, gpio_num_t dout, gpio_num_t din);
virtual int Read(int16_t* dest, int samples) override;
virtual int Write(const int16_t* data, int samples) override;
public:
WaveshareAudioCodec(void* i2c_master_handle, int input_sample_rate, int output_sample_rate,
gpio_num_t mclk, gpio_num_t bclk, gpio_num_t ws, gpio_num_t dout, gpio_num_t din,
gpio_num_t pa_pin, uint8_t es8311_addr, uint8_t es7210_addr, bool input_reference);
virtual ~WaveshareAudioCodec();
virtual void SetOutputVolume(int volume) override;
virtual void EnableInput(bool enable) override;
virtual void EnableOutput(bool enable) override;
};
#endif // _SENSECAP_AUDIO_CODEC_H