From 897fd050e9f1523f49030280c101735e2b1782f1 Mon Sep 17 00:00:00 2001 From: Steven Dan Date: Mon, 26 Jan 2026 10:23:57 +0800 Subject: [PATCH] opt eq_design --- .../src/extensions/eq.c | 1095 ++++++++--------- .../src/extensions/eq_flash_storage.c | 90 +- .../src/extensions/user_uart.h | 30 + 3 files changed, 577 insertions(+), 638 deletions(-) diff --git a/sw_usb_audio/app_usb_aud_phaten_golden/src/extensions/eq.c b/sw_usb_audio/app_usb_aud_phaten_golden/src/extensions/eq.c index 5f92e18..4b6d3b0 100644 --- a/sw_usb_audio/app_usb_aud_phaten_golden/src/extensions/eq.c +++ b/sw_usb_audio/app_usb_aud_phaten_golden/src/extensions/eq.c @@ -16,6 +16,7 @@ #endif extern void device_reboot(void); +//extern void delay_milliseconds(unsigned int); // 常量定义 #define EQ_DISABLED_MODE 10 // 禁用EQ的模式编号 @@ -26,14 +27,26 @@ extern void device_reboot(void); #include #include #include "eq_params_44100.h" -#include "eq_params_48000.h" -#include "eq_params_88200.h" -#include "eq_params_96000.h" -#include "eq_params_176400.h" -#include "eq_params_192000.h" + +// 改动原因：进一步优化EQ参数存储策略，所有采样率共用44100Hz数组 +// 参数在所有采样率下是相同的，只有系数需要根据采样率动态计算 +// 切换采样率时，直接使用44100Hz数组的参数，重新计算系数即可 +/** + * @brief 获取指定采样率的EQ数组指针（统一使用44100Hz数组） + * @param sample_rate 采样率 + * @return EQ数组指针，始终返回44100Hz数组 + * + * 改动原因：所有采样率共用44100Hz数组，参数相同，系数根据采样率动态计算 + */ +static inline eq_mode_data_t (*get_eq_array_ptr_common(uint32_t sample_rate))[NUM_EQ_MODES][NUM_EQ_CHANS] { + // 所有采样率都使用44100Hz数组（参数源） + // 注意：切换采样率时需要重新计算系数 + return &sEQ_data_44100HZ; +} #include "eq_coefficient_calculator.h" #include "biquad_standalone.h" #include "eq_flash_storage.h" +#include "user_func.h" // 改动原因：包含check_sum函数声明，用于uart_checksum宏定义 static struct { bool is_read_device_params_request; // 设备参数读取请求标志 } device_params_request = {0}; @@ -452,72 +465,75 @@ static inline int32_t apply_gain(int32_t sample, int32_t gain_db) { return result; } -extern void delay_milliseconds(unsigned int); +/** + * @brief 设置采样率标记（所有采样率共用44100Hz数组） + * @param sample_rate 目标采样率 + * @param mode 模式号 + * @return 成功返回0，失败返回-1 + * + * 改动原因：所有采样率共用44100Hz数组，参数相同，只需要设置sample_rate标记 + * 系数会根据采样率动态计算，不需要复制参数 + */ +static int copy_params_from_44100(uint32_t sample_rate, uint8_t mode) { + if (mode >= NUM_EQ_MODES) { + debug_printf("Error: Invalid mode %d in copy_params_from_44100\n", mode); + return -1; + } + + // 改动原因：所有采样率共用44100Hz数组，只需要设置sample_rate标记 + // 参数已经存储在44100Hz数组中，不需要复制 + for (int ch = 0; ch < NUM_EQ_CHANS; ch++) { + sEQ_data_44100HZ[mode][ch].sample_rate = sample_rate; + // 重置total_bshift（将在计算系数时更新） + sEQ_data_44100HZ[mode][ch].total_bshift = 0; + } + + debug_printf("Set sample rate to %dHz for mode %d (using 44100Hz array)\n", sample_rate, mode); + return 0; +} /** * @brief 动态计算当前模式所有band的系数 * @param sample_rate 采样率 * @param mode EQ模式 (0-9) * @return 成功返回0，失败返回-1 - * + * * 根据process_send_params函数中0x8d命令的逻辑，实现当前模式所有band的系数计算 * 如果是bypass类型，直接赋值bypass系数，不计算bshift * 正确计算total_bshift作为所有非bypass滤波器bshift的累加 + * + * 改动原因：在计算系数前，先从44100Hz统一参数源复制参数到当前采样率 */ int calculate_current_mode_coefficients(uint32_t sample_rate, uint8_t mode) { debug_printf("calculate_current_mode_coefficients: sample_rate=%d, mode=%d\n", sample_rate, mode); - + + // 改动原因：在计算系数前，先从44100Hz统一参数源复制参数到当前采样率 + // 确保所有采样率的参数都从统一源同步 + if (copy_params_from_44100(sample_rate, mode) != 0) { + debug_printf("Warning: Failed to copy params from 44100Hz, continuing with existing params\n"); + } + if (mode >= NUM_EQ_MODES) { debug_printf("Error: Invalid mode %d (max: %d)\n", mode, NUM_EQ_MODES - 1); return -1; } - - // 获取对应采样率和模式的EQ数据指针 - eq_mode_data_t *eq_data = NULL; - eq_mode_data_t *eq_data_2 = NULL; - - switch (sample_rate) { - case 44100: - eq_data = &sEQ_data_44100HZ[mode][0]; - eq_data_2 = &sEQ_data_44100HZ[mode][1]; - break; - case 48000: - eq_data = &sEQ_data_48000HZ[mode][0]; - eq_data_2 = &sEQ_data_48000HZ[mode][1]; - break; - case 88200: - eq_data = &sEQ_data_88200HZ[mode][0]; - eq_data_2 = &sEQ_data_88200HZ[mode][1]; - break; - case 96000: - eq_data = &sEQ_data_96000HZ[mode][0]; - eq_data_2 = &sEQ_data_96000HZ[mode][1]; - break; - case 176400: - eq_data = &sEQ_data_176400HZ[mode][0]; - eq_data_2 = &sEQ_data_176400HZ[mode][1]; - break; - case 192000: - eq_data = &sEQ_data_192000HZ[mode][0]; - eq_data_2 = &sEQ_data_192000HZ[mode][1]; - break; - default: - debug_printf("Error: Unsupported sample rate %d\n", sample_rate); - return -1; - } - + + // 改动原因：所有采样率共用44100Hz数组 + eq_mode_data_t *eq_data = &sEQ_data_44100HZ[mode][0]; + eq_mode_data_t *eq_data_2 = &sEQ_data_44100HZ[mode][1]; + if (eq_data == NULL || eq_data_2 == NULL) { debug_printf("Error: eq_data pointer is NULL\n"); return -1; } - + // 重置total_bshift int total_bshift = 0; - + // 遍历所有band，计算系数 for (int band_index = 0; band_index < MAX_EQ_BANDS; band_index++) { filter_params_t *band = &eq_data->bands[band_index]; - + // 检查参数有效性 if (isnan(band->fc) || isnan(band->q) || isnan(band->bw) || isnan(band->gain)) { debug_printf("Warning: Invalid parameters for band %d, using bypass\n", band_index); @@ -527,10 +543,10 @@ int calculate_current_mode_coefficients(uint32_t sample_rate, uint8_t mode) { band->bw = 1.0f; band->gain = 0.0f; } - + q2_30 coeffs[5]; int calculated_bshift = 0; - + // 根据滤波器类型计算系数 if (band->type == FILTER_TYPE_BYPASS) { // bypass类型：直接设置bypass系数，不累加bshift @@ -540,7 +556,7 @@ int calculate_current_mode_coefficients(uint32_t sample_rate, uint8_t mode) { coeffs[3] = 0; // a1 = 0 coeffs[4] = 0; // a2 = 0 calculated_bshift = 0; - + debug_printf("Band %d: BYPASS - coeffs set to bypass values, bshift=0\n", band_index); } else { // 非bypass类型：调用系数计算函数 @@ -554,7 +570,7 @@ int calculate_current_mode_coefficients(uint32_t sample_rate, uint8_t mode) { coeffs[4] = 0; calculated_bshift = 0; } else { - debug_printf("Band %d: Type=%d, fc=%.2f, q=%.3f, gain=%.2f, bshift=%d\n", + debug_printf("Band %d: Type=%d, fc=%.2f, q=%.3f, gain=%.2f, bshift=%d\n", band_index, band->type, band->fc, band->q, band->gain, calculated_bshift); debug_printf("fc: "); print_float(band->fc, 6); @@ -565,11 +581,11 @@ int calculate_current_mode_coefficients(uint32_t sample_rate, uint8_t mode) { debug_printf("gain: "); print_float(band->gain, 6); } - + // 累加非bypass滤波器的bshift total_bshift += calculated_bshift; } - + // 存储计算出的系数到两个通道 for (int i = 0; i < 5; i++) { eq_data->filter.coef[i][band_index] = coeffs[i]; @@ -578,13 +594,13 @@ int calculate_current_mode_coefficients(uint32_t sample_rate, uint8_t mode) { // 同步band参数到第二个通道 memcpy(&eq_data_2->bands[band_index], band, sizeof(filter_params_t)); } - + // 更新total_bshift eq_data->total_bshift = total_bshift; eq_data_2->total_bshift = total_bshift; - + debug_printf("Mode %d coefficients calculated successfully, total_bshift=%d\n", mode, total_bshift); - + return 0; } @@ -592,31 +608,40 @@ int calculate_current_mode_coefficients(uint32_t sample_rate, uint8_t mode) { uint32_t init_eq_data(unsigned sample_freq) { g_eq_sample_rate = sample_freq; debug_printf("init_eq_data %d\n", g_eq_sample_rate); - + // 初始化模式信息 - + // 从Flash加载增益和模式名称 - + // 初始化单参数存储数据库 - + // Clear EQ status for all sample rates, modes, and channels for (int ch = 0; ch < NUM_EQ_CHANS; ch++) { // Clear status for various sample rates clear_eq_status(sample_freq, ch); } - - // 动态初始化所有模式的系数 - // 遍历所有EQ模式，为当前采样率计算系数 - debug_printf("Initializing coefficients for all EQ modes at %d Hz\n", sample_freq); - - if (calculate_current_mode_coefficients(sample_freq, g_current_eq_mode) == 0) { - debug_printf("Successfully initialized coefficients for mode %d\n", g_current_eq_mode); - } else { - debug_printf("Warning: Failed to initialize coefficients for mode %d\n", g_current_eq_mode); + + // 改动原因：优化EQ参数存储策略，从44100Hz统一参数源复制参数到当前采样率 + // 然后为所有模式计算系数，确保参数同步 + debug_printf("Initializing EQ parameters from 44100Hz source for sample rate %d Hz\n", sample_freq); + + // 为所有模式复制参数并计算系数 + for (int mode = 0; mode < NUM_EQ_MODES; mode++) { + // 从44100Hz复制参数到当前采样率 + if (copy_params_from_44100(sample_freq, mode) == 0) { + // 计算系数 + if (calculate_current_mode_coefficients(sample_freq, mode) == 0) { + debug_printf("Successfully initialized mode %d for sample rate %d Hz\n", mode, sample_freq); + } else { + debug_printf("Warning: Failed to calculate coefficients for mode %d\n", mode); + } + } else { + debug_printf("Warning: Failed to copy params for mode %d\n", mode); + } } - + debug_printf("EQ initialization completed for sample rate %d Hz\n", sample_freq); - + return 1; } @@ -628,20 +653,11 @@ void update_eq_post_gain(void) { debug_printf("Warning: mode %d gain %d clamped to %d in update_eq_post_gain\n", mode, g_mode_info.mode_gains[mode], gain); g_mode_info.mode_gains[mode] = gain; // 更新存储的值 } - + + // 改动原因：所有采样率共用44100Hz数组，直接更新即可 if (sEQ_data_44100HZ[mode][0].post_gain_db != gain) { sEQ_data_44100HZ[mode][0].post_gain_db = gain; sEQ_data_44100HZ[mode][1].post_gain_db = gain; - sEQ_data_48000HZ[mode][0].post_gain_db = gain; - sEQ_data_48000HZ[mode][1].post_gain_db = gain; - sEQ_data_88200HZ[mode][0].post_gain_db = gain; - sEQ_data_88200HZ[mode][1].post_gain_db = gain; - sEQ_data_96000HZ[mode][0].post_gain_db = gain; - sEQ_data_96000HZ[mode][1].post_gain_db = gain; - sEQ_data_176400HZ[mode][0].post_gain_db = gain; - sEQ_data_176400HZ[mode][1].post_gain_db = gain; - sEQ_data_192000HZ[mode][0].post_gain_db = gain; - sEQ_data_192000HZ[mode][1].post_gain_db = gain; } } } @@ -683,31 +699,8 @@ void clear_eq_status(unsigned sample_freq, unsigned ch_no) { return; } - eq_mode_data_t (*eq_data)[NUM_EQ_MODES][NUM_EQ_CHANS] = NULL; - - // Select EQ data based on sample rate - switch(sample_freq) { - case 44100: - eq_data = &sEQ_data_44100HZ; - break; - case 48000: - eq_data = &sEQ_data_48000HZ; - break; - case 88200: - eq_data = &sEQ_data_88200HZ; - break; - case 96000: - eq_data = &sEQ_data_96000HZ; - break; - case 176400: - eq_data = &sEQ_data_176400HZ; - break; - case 192000: - eq_data = &sEQ_data_192000HZ; - break; - default: - eq_data = &sEQ_data_48000HZ; // Use 48kHz data by default - } + // 改动原因：所有采样率共用44100Hz数组 + eq_mode_data_t (*eq_data)[NUM_EQ_MODES][NUM_EQ_CHANS] = &sEQ_data_44100HZ; // Clear status for the specified sample rate, mode, and channel for (n = 0; n < MAX_EQ_BANDS + 1; n++) { @@ -719,26 +712,26 @@ void clear_eq_status(unsigned sample_freq, unsigned ch_no) { // 复位EQ参数函数 uint8_t reset_eq_params(uint8_t mode) { debug_printf("Resetting EQ params for mode %d\n", mode); - + // 检查模式号有效性 if (mode != 0xFF && mode >= NUM_EQ_MODES) { debug_printf("Error: Invalid mode %d\n", mode); return 0x01; // 失败 } - + // 删除Flash中的EQ参数文件 delete_flash_eq_params(mode); - + // 删除Flash中的增益和模式名称文件（只删除相应模式的数据） // 改动原因：修改为按模式删除，只删除指定模式的增益和名称，而不是删除所有文件 delete_flash_gain_and_names(mode); - + // 恢复头文件预设参数 restore_default_eq_params(mode); // 恢复默认模式信息 init_mode_info(); - + debug_printf("EQ params reset successful for mode %d\n", mode); return 0x00; // 成功 } @@ -746,11 +739,11 @@ uint8_t reset_eq_params(uint8_t mode) { // 数据修复函数 - 修复损坏的EQ数据 static void repair_eq_data(eq_mode_data_t *eq_data) { if (eq_data == NULL) return; - + // 修复bands数组 for (int i = 0; i < MAX_EQ_BANDS; i++) { filter_params_t *band = &eq_data->bands[i]; - + // 检查并修复float字段 if (isnan(band->fc) || isinf(band->fc) || band->fc < 0 || band->fc > 100000) { band->fc = 1000.0f; @@ -764,19 +757,19 @@ static void repair_eq_data(eq_mode_data_t *eq_data) { if (isnan(band->gain) || isinf(band->gain) || band->gain < -100 || band->gain > 100) { band->gain = 0.0f; } - + // 修复索引和类型 band->index = i; if (band->type > FILTER_TYPE_HIGHSHELF) { band->type = FILTER_TYPE_BYPASS; } } - + // 修复其他字段 if (eq_data->sample_rate == 0 || eq_data->sample_rate > 200000) { eq_data->sample_rate = 48000; // 默认采样率 } - + // 修复total_bshift和post_gain_db if (eq_data->total_bshift < -32 || eq_data->total_bshift > 32) { eq_data->total_bshift = 0; @@ -797,13 +790,13 @@ void debug_print_eq_mode(eq_mode_data_t *eq_data) { DPRINTF("Filter Parameters:\n"); for (int i = 0; i < MAX_EQ_BANDS; i++) { filter_params_t *band = &eq_data->bands[i]; - + // 添加指针有效性检查 if (band == NULL) { DPRINTF(" Band %d: ERROR - band pointer is NULL\n", i); continue; } - + DPRINTF(" Band %d:\n", i); DPRINTF(" Index: %d\n", band->index); @@ -886,32 +879,10 @@ int32_t handler_eq_filter(unsigned sample_freq, uint32_t ch, int32_t new_sample) return temp_sample; } - if (ch < NUM_EQ_CHANS) { - eq_mode_data_t (*eq_data)[NUM_EQ_MODES][NUM_EQ_CHANS] = NULL; - // Select EQ data based on sample rate - switch(sample_freq) { - case 44100: - eq_data = &sEQ_data_44100HZ; - break; - case 48000: - eq_data = &sEQ_data_48000HZ; - break; - case 88200: - eq_data = &sEQ_data_88200HZ; - break; - case 96000: - eq_data = &sEQ_data_96000HZ; - break; - case 176400: - eq_data = &sEQ_data_176400HZ; - break; - case 192000: - eq_data = &sEQ_data_192000HZ; - break; - default: - eq_data = &sEQ_data_48000HZ; // Use 48kHz data by default - } + if (ch < NUM_EQ_CHANS) { + // 改动原因：所有采样率共用44100Hz数组 + eq_mode_data_t (*eq_data)[NUM_EQ_MODES][NUM_EQ_CHANS] = &sEQ_data_44100HZ; // 应用增益或衰减 (Q24格式) // 改动原因：修改post_gain_db范围检查为0到-50dB，确保只处理有效范围内的gain值 @@ -929,7 +900,7 @@ int32_t handler_eq_filter(unsigned sample_freq, uint32_t ch, int32_t new_sample) if (count % 100000 == 0) { debug_printf("post_gain: %d\n", post_gain); } - + temp_sample = temp_sample >> 1; //Q30 // 应用均衡器滤波 @@ -956,31 +927,12 @@ int32_t handler_eq_filter(unsigned sample_freq, uint32_t ch, int32_t new_sample) void debug_print_eq_params(unsigned sample_freq) { unsigned mode = g_current_eq_mode; - eq_mode_data_t (*eq_data)[NUM_EQ_MODES][NUM_EQ_CHANS] = NULL; + // 改动原因：使用公用数组，通过函数获取对应采样率的数组指针 + eq_mode_data_t (*eq_data)[NUM_EQ_MODES][NUM_EQ_CHANS] = get_eq_array_ptr_common(sample_freq); - // Select EQ data based on sample rate - switch(sample_freq) { - case 44100: - eq_data = &sEQ_data_44100HZ; - break; - case 48000: - eq_data = &sEQ_data_48000HZ; - break; - case 88200: - eq_data = &sEQ_data_88200HZ; - break; - case 96000: - eq_data = &sEQ_data_96000HZ; - break; - case 176400: - eq_data = &sEQ_data_176400HZ; - break; - case 192000: - eq_data = &sEQ_data_192000HZ; - break; - default: - debug_printf("Error: Unsupported sample rate %u\n", sample_freq); - return; + if (eq_data == NULL) { + debug_printf("Error: Unsupported sample rate %u\n", sample_freq); + return; } // 修复可能损坏的数据 @@ -999,18 +951,18 @@ void debug_print_eq_params(unsigned sample_freq) { DPRINTF("Filter Parameters:\n"); for (int i = 0; i < MAX_EQ_BANDS; i++) { filter_params_t *band = &(*eq_data)[mode][ch].bands[i]; - + // 添加指针有效性检查 if (band == NULL) { DPRINTF(" Band %d: ERROR - band pointer is NULL\n", i); continue; } - + // 检查指针是否在有效内存范围内 uintptr_t band_addr = (uintptr_t)band; uintptr_t eq_data_addr = (uintptr_t)eq_data; size_t eq_data_size = sizeof(eq_mode_data_t); - + DPRINTF(" Band %d:\n", i); DPRINTF(" Index: %d\n", band->index); @@ -1102,20 +1054,20 @@ void get_device_info(unsigned char *response) { // 产品ID (1字节，小端序，位置3-4) response[2] = (uint8_t)(XUA_Endpoint0_getProductId() & 0xFF); response[3] = (uint8_t)((XUA_Endpoint0_getProductId() >> 8) & 0xFF); - + // 厂商ID (1字节，小端序，位置5-6) response[4] = (uint8_t)(XUA_Endpoint0_getVendorId() & 0xFF); response[5] = (uint8_t)((XUA_Endpoint0_getVendorId() >> 8) & 0xFF); - + // 产品字符串 (15字节，UTF-8编码，位置7-22) memcpy(&response[6], XUA_Endpoint0_getProductStr(), 16); - + // 厂商字符串 (15字节，UTF-8编码，位置23-38) memcpy(&response[22], XUA_Endpoint0_getVendorStr(), 16); - + // 序列号字符串 (15字节，UTF-8编码，位置39-54) memcpy(&response[38], XUA_Endpoint0_getSerialStr(), 16); - + debug_printf("Device info - PID: -1x%04x, VID: 0x%04x, Product: '%s', Vendor: '%s', Serial: '%s'\n", XUA_Endpoint0_getProductId(), XUA_Endpoint0_getVendorId(), XUA_Endpoint0_getProductStr(), XUA_Endpoint0_getVendorStr(), XUA_Endpoint0_getSerialStr()); @@ -1175,7 +1127,7 @@ unsigned char process_send_params(uint8_t data[], uint16_t len) { // eq_enable是全局开关，与模式切换独立，可以在任何enable状态下切换模式 SET_SHARED_GLOBAL(g_request_eq_mode, data[2]); debug_printf("Received set mode command (0x8A), switching to mode %d (temporary, not saved to Flash)\n", data[2]); - debug_printf("EQ enable state: %d (independent of mode), saved startup mode: %d (set by 0x92)\n", + debug_printf("EQ enable state: %d (independent of mode), saved startup mode: %d (set by 0x92)\n", g_eq_enable, g_saved_eq_mode); return true; } @@ -1185,7 +1137,7 @@ unsigned char process_send_params(uint8_t data[], uint16_t len) { if (data[1] == 0x8b) { uint8_t mode = data[2]; debug_printf("Received read EQ mode command (GET_EQ_MODE), mode: 0x%02x\n", mode); - + // 验证mode参数：0xFF表示获取当前模式，0-9表示获取指定模式 if (mode == 0xFF) { // 获取当前模式信息 @@ -1208,7 +1160,7 @@ unsigned char process_send_params(uint8_t data[], uint16_t len) { eq_mode_data_t *eq_data = NULL; eq_mode_data_t *eq_data_2 = NULL; debug_printf("Received set EQ overall gain and name command (SET_MODE_GAIN_AND_NAME)\n"); - + // 获取模式值 uint8_t mode = data[2]; @@ -1217,35 +1169,35 @@ unsigned char process_send_params(uint8_t data[], uint16_t len) { } // 获取增益值 (4字节，范围0到-50dB) uint32_t gain = (uint32_t)data[3] | ((uint32_t)data[4] << 8) | ((uint32_t)data[5] << 16) | ((uint32_t)data[6] << 24); - + // 改动原因：限制gain范围到0到-50dB，防止超出范围的值导致异常 int32_t new_gain = clamp_post_gain((int32_t)gain); if (new_gain != (int32_t)gain) { debug_printf("Gain value %d clamped to %d (range: 0 to -50dB)\n", (int32_t)gain, new_gain); } - + // 获取模式名称 (16字节，UTF-8编码) char mode_name[17] = {0}; // 16字节 + 1个null终止符 memcpy(mode_name, &data[7], 16); mode_name[16] = '\0'; // 确保null终止 - + debug_printf("EQ overall gain: %d dB, mode name: '%s' for mode %d\n", new_gain, mode_name, mode); - + // 获取44100采样率下该模式的当前gain值，判断是否有变化 int32_t current_gain_44100 = sEQ_data_44100HZ[mode][0].post_gain_db; bool gain_changed = (current_gain_44100 != new_gain); - + if (gain_changed) { debug_printf("Gain changed from %d to %d, will mark dirty\n", current_gain_44100, new_gain); } else { debug_printf("Gain unchanged (%d), skip marking dirty\n", current_gain_44100); } - + // 获取当前模式名称，判断是否有变化 char current_name[16] = {0}; strncpy(current_name, g_mode_info.mode_names[mode], 15); current_name[15] = '\0'; - + // 检查新名称是否全空（全0或全空格） bool name_is_empty = true; if (mode_name[0] != '\0') { @@ -1258,10 +1210,10 @@ unsigned char process_send_params(uint8_t data[], uint16_t len) { } } // 如果第一个字符就是\0，name_is_empty保持为true - + // 比较名称是否有变化 bool name_changed = (strncmp(current_name, mode_name, 15) != 0); - + if (name_is_empty) { debug_printf("Mode name is empty, skip saving\n"); } else if (name_changed) { @@ -1269,66 +1221,31 @@ unsigned char process_send_params(uint8_t data[], uint16_t len) { } else { debug_printf("Name unchanged ('%s'), skip marking dirty\n", current_name); } - - + + if (!name_is_empty && name_changed) { set_mode_name(mode, mode_name); eq_mark_name_dirty(); // 只有变化且非空时才标记脏 debug_printf("Marked mode %d as dirty for Flash sync (name update)\n", mode); } - + if (gain_changed) { // 设置EQ整体增益到所有采样率的指定模式 uint32_t all_sample_rates[] = {44100, 48000, 88200, 96000, 176400, 192000}; int num_rates = sizeof(all_sample_rates) / sizeof(all_sample_rates[0]); - - for (int i = 0; i < num_rates; i++) { - uint32_t fs = all_sample_rates[i]; - // 查找当前采样率下相同mode的EQ数据 - switch (fs) { - case 44100: - eq_data = &sEQ_data_44100HZ[mode][0]; - eq_data_2 = &sEQ_data_44100HZ[mode][1]; - break; - case 48000: - eq_data = &sEQ_data_48000HZ[mode][0]; - eq_data_2 = &sEQ_data_48000HZ[mode][1]; - break; - case 88200: - eq_data = &sEQ_data_88200HZ[mode][0]; - eq_data_2 = &sEQ_data_88200HZ[mode][1]; - break; - case 96000: - eq_data = &sEQ_data_96000HZ[mode][0]; - eq_data_2 = &sEQ_data_96000HZ[mode][1]; - break; - case 176400: - eq_data = &sEQ_data_176400HZ[mode][0]; - eq_data_2 = &sEQ_data_176400HZ[mode][1]; - break; - case 192000: - eq_data = &sEQ_data_192000HZ[mode][0]; - eq_data_2 = &sEQ_data_192000HZ[mode][1]; - break; - default: - continue; - } - // 设置EQ整体增益到指定采样率和模式 - if (eq_data != NULL && eq_data_2 != NULL && mode < NUM_EQ_MODES) { - // 改动原因：使用限制后的gain值，确保所有post_gain_db都在0到-50dB范围内 - eq_data->post_gain_db = new_gain; - eq_data_2->post_gain_db = new_gain; - debug_printf("Set EQ overall gain to %d dB for mode %d, sample rate %d Hz\n", new_gain, mode, fs); - // 标记参数已修改，需要同步到Flash - } + // 改动原因：所有采样率共用44100Hz数组，直接更新即可 + if (mode < NUM_EQ_MODES) { + sEQ_data_44100HZ[mode][0].post_gain_db = new_gain; + sEQ_data_44100HZ[mode][1].post_gain_db = new_gain; + debug_printf("Set EQ overall gain to %d dB for mode %d (applied to all sample rates)\n", new_gain, mode); } - + set_mode_gain(mode, new_gain); eq_mark_gain_dirty(); // 只有变化时才标记脏 debug_printf("Marked mode %d as dirty for Flash sync (gain update)\n", mode); } - + return true; } @@ -1343,16 +1260,16 @@ unsigned char process_send_params(uint8_t data[], uint16_t len) { // 处理复位EQ参数命令 (0x90) - RESET_EQ_PARAMS if (data[1] == 0x90) { debug_printf("Received reset EQ params command (RESET_EQ_PARAMS)\n"); - + // 获取模式号 uint8_t mode = data[2]; debug_printf("Reset mode: %d (0xFF = all modes)\n", mode); - + // 立即执行复位操作并保存状态 // 改动原因：复位操作应该在收到命令时立即执行，而不是在读取响应时执行 // 这样可以避免在读取响应时重复执行耗时操作，提高响应效率 reset_eq_params(mode); - + // 设置读取请求标志，读取时只返回保存的状态 read_request.is_reset_eq_params_request = true; read_request.mode = mode; @@ -1375,30 +1292,30 @@ unsigned char process_send_params(uint8_t data[], uint16_t len) { if (data[1] == 0x92) { debug_printf("Received set and save EQ mode command (SET_AND_SAVE_EQ_MODE)\n"); read_request.is_set_and_save_mode_request = true; - + // 获取模式值 uint8_t mode = data[2]; - + // 验证模式值范围 if (mode > EQ_MODE_MAX ) { debug_printf("Error: Invalid mode %d (valid range: 0-9)\n", mode); read_request.mode = 0xFF; // 使用0xFF表示失败 return true; } - + debug_printf("Setting and saving EQ mode to %d\n", mode); - + // 设置当前模式 SET_SHARED_GLOBAL(g_request_eq_mode, mode); - + // 更新保存的模式（用于0x9D启用时恢复） g_saved_eq_mode = mode; - + // 保存到Flash（只保存模式，不影响使能状态） eq_flash_save_current_mode(mode); debug_printf("Successfully saved EQ mode %d to Flash (startup mode)\n", mode); read_request.mode = mode; - + return true; } @@ -1408,20 +1325,20 @@ unsigned char process_send_params(uint8_t data[], uint16_t len) { debug_printf("Received set volume command (SET_VOLUME)\n"); // 获取音量级别 uint8_t volume_level = data[2]; - + debug_printf("Setting volume level to %d\n", volume_level); - + // 参数验证 if (volume_level > 60) { debug_printf("Error: Invalid volume_level %d (must be 0-60)\n", volume_level); return false; } - + // 设置全局变量（直接赋值，因为在C文件中） extern unsigned g_volume_level; g_volume_level = volume_level; g_request_volume_set = 1; - + debug_printf("Volume level set successfully to %d\n", volume_level); return true; } @@ -1455,7 +1372,7 @@ unsigned char process_send_params(uint8_t data[], uint16_t len) { debug_printf("Received set LED switch command (SET_LED_SWITCH)\n"); uint8_t led_index = data[2]; uint8_t led_switch = data[3]; - + if (led_index > 7) { debug_printf("Error: Invalid LED index %d (must be 0-7)\n", led_index); return false; @@ -1464,14 +1381,14 @@ unsigned char process_send_params(uint8_t data[], uint16_t len) { debug_printf("Error: Invalid LED switch value %d (must be 0-1)\n", led_switch); return false; } - + // 设置LED开关全局变量 extern unsigned g_led_enable; g_led_enable = led_switch; SET_SHARED_GLOBAL(g_led_enable, led_switch); - + debug_printf("LED switch set to: %s (index: %d)\n", led_switch ? "ON" : "OFF", led_index); - + // 设置SET命令的响应标志 // 改动原因：SET_LED_SWITCH的响应格式与GET_LED_SWITCH不同，返回状态码 led_request.is_set_led_switch_request = true; @@ -1527,30 +1444,30 @@ unsigned char process_send_params(uint8_t data[], uint16_t len) { // 改动原因：添加UAC模式设置命令，支持切换到UAC1.0或UAC2.0 if (data[1] == 0x9B) { debug_printf("Received set UAC mode command (SET_UAC_MODE)\n"); - + // 获取UAC模式值 uint8_t uac_mode = data[2]; - + // 验证模式值范围 if (uac_mode > 1) { debug_printf("Error: Invalid UAC mode %d (must be 0-1, 0=UAC2.0, 1=UAC1.0)\n", uac_mode); return true; } - + debug_printf("Setting UAC mode to: %s\n", uac_mode == 0 ? "UAC2.0" : "UAC1.0"); - + // 读取当前UAC模式 extern unsigned g_uac_mode; unsigned current_uac_mode; GET_SHARED_GLOBAL(current_uac_mode, g_uac_mode); - + // 如果目标模式与当前模式相同，无需操作 if ((uac_mode == 0 && current_uac_mode == 2) || (uac_mode == 1 && current_uac_mode == 1)) { debug_printf("UAC mode is already %s, no action needed\n", uac_mode == 0 ? "UAC2.0" : "UAC1.0"); // 改动原因：SET_UAC_MODE命令不返回响应，直接返回true表示命令已接收 return true; } - + // 如果设置为UAC1.0，需要reboot到uac1.0 #if (UAC2 == 1) if (uac_mode == 1) { @@ -1571,7 +1488,7 @@ unsigned char process_send_params(uint8_t data[], uint16_t len) { return true; } #endif - + // 改动原因：SET_UAC_MODE命令不返回响应，直接返回true表示命令已接收 return true; } @@ -1589,24 +1506,24 @@ unsigned char process_send_params(uint8_t data[], uint16_t len) { if (data[1] == 0x9D) { uint8_t enable = data[2]; // 0=OFF禁用, 1=ON启用 debug_printf("Received set EQ enable command (SET_EQ_ENABLE), enable: %d\n", enable); - + if (enable > 1) { debug_printf("Error: Invalid EQ enable value %d (must be 0 or 1)\n", enable); return false; } - + // 改动原因：将eq_enable独立为全局开关，所有模式共用一个开关 // 在任何模式下调整enable，都会影响所有模式，不改变当前模式 g_eq_enable = enable; - + // 只保存EQ使能状态到Flash，不影响已保存的模式（0x92保存的模式） eq_flash_save_eq_enable(enable); - + unsigned int current_mode; GET_SHARED_GLOBAL(current_mode, g_request_eq_mode); - debug_printf("EQ enable set to %d (global switch, affects all modes), current mode: %d, saved startup mode: %d\n", + debug_printf("EQ enable set to %d (global switch, affects all modes), current mode: %d, saved startup mode: %d\n", enable, current_mode, g_saved_eq_mode); - + read_request.is_set_eq_enable_request = true; read_request.eq_enable_value = enable; return true; @@ -1633,17 +1550,17 @@ unsigned char process_send_params(uint8_t data[], uint16_t len) { if (data[1] == 0xA0) { debug_printf("Received set gain mode command (SET_GAIN_MODE)\n"); uint8_t gain_mode = data[2]; - + // 参数验证 if (gain_mode > 1) { debug_printf("Error: Invalid gain_mode %d (must be 0-1)\n", gain_mode); return false; } - + // 设置请求变量（使用SHARED_GLOBAL宏） extern unsigned g_request_gain_mode; SET_SHARED_GLOBAL(g_request_gain_mode, gain_mode); - + debug_printf("Gain mode set request: %d (0=低阻, 1=高阻)\n", gain_mode); return true; } @@ -1661,18 +1578,18 @@ unsigned char process_send_params(uint8_t data[], uint16_t len) { if (data[1] == 0xA2) { debug_printf("Received set filter mode command (SET_FILTER_MODE)\n"); uint8_t filter_mode = data[2]; - + // 参数验证 // 改动原因：支持8种滤波器模式（0-7），与g_filter_map[8]数组定义一致 if (filter_mode > 7) { debug_printf("Error: Invalid filter_mode %d (must be 0-7)\n", filter_mode); return false; } - + // 设置请求变量（使用SHARED_GLOBAL宏） extern unsigned g_request_filter_mode; SET_SHARED_GLOBAL(g_request_filter_mode, filter_mode); - + debug_printf("Filter mode set request: %d (0-7: 8种滤波器模式)\n", filter_mode); return true; } @@ -1690,19 +1607,19 @@ unsigned char process_send_params(uint8_t data[], uint16_t len) { if (data[1] == 0xA4) { debug_printf("Received set game mode command (SET_GAME_MODE)\n"); uint8_t game_mode = data[2]; - + // 参数验证 if (game_mode > 2) { debug_printf("Error: Invalid game_mode %d (must be 0-2)\n", game_mode); return false; } - + // 改动原因：在UAC1模式下，调用audiohw.xc中的request_game_mode_switch函数接口 // 该函数会判断是否需要重启，如果需要则设置重启标志，否则直接设置game_mode请求 extern unsigned g_uac_mode; unsigned uac_mode; GET_SHARED_GLOBAL(uac_mode, g_uac_mode); - + if (uac_mode == 1) { // 改动原因：UAC1模式下，使用request_game_mode_switch函数接口，仿照双键长按逻辑 extern void request_game_mode_switch(unsigned game_mode); @@ -1714,7 +1631,7 @@ unsigned char process_send_params(uint8_t data[], uint16_t len) { SET_SHARED_GLOBAL(g_request_game_mode, game_mode); debug_printf("Game mode set request: %d (0=无音效, 1=FPS, 2=虚拟7.1)\n", game_mode); } - + return true; } @@ -1740,10 +1657,10 @@ unsigned char process_send_params(uint8_t data[], uint16_t len) { debug_printf("Received set EX3D command (SET_EX3D_CMD)\n"); #if (USE_EX3D == 1) && (HID_CONTROLS == 1) // 提取EX3D命令码（4字节，小端序） - uint32_t ex3d_cmd = (uint32_t)data[2] | ((uint32_t)data[3] << 8) | + uint32_t ex3d_cmd = (uint32_t)data[2] | ((uint32_t)data[3] << 8) | ((uint32_t)data[4] << 16) | ((uint32_t)data[5] << 24); debug_printf("EX3D command code: 0x%08X\n", ex3d_cmd); - + // 提取参数（从data[6]开始，最多56字节） ex3d_request.ex3d_command_code = ex3d_cmd; ex3d_request.ex3d_params_len = (len > 62) ? 56 : (len - 6); @@ -1762,10 +1679,10 @@ unsigned char process_send_params(uint8_t data[], uint16_t len) { debug_printf("Received get EX3D command (GET_EX3D_CMD)\n"); #if (USE_EX3D == 1) && (HID_CONTROLS == 1) // 提取EX3D命令码（4字节，小端序） - uint32_t ex3d_cmd = (uint32_t)data[2] | ((uint32_t)data[3] << 8) | + uint32_t ex3d_cmd = (uint32_t)data[2] | ((uint32_t)data[3] << 8) | ((uint32_t)data[4] << 16) | ((uint32_t)data[5] << 24); debug_printf("EX3D command code: 0x%08X\n", ex3d_cmd); - + // 提取参数（从data[6]开始，最多56字节） ex3d_request.ex3d_command_code = ex3d_cmd; ex3d_request.ex3d_params_len = (len > 62) ? 56 : (len - 6); @@ -1781,7 +1698,7 @@ unsigned char process_send_params(uint8_t data[], uint16_t len) { if (data[1] == 0x8d) { debug_printf("Received set EQ filter parameters command (SET_EQ_PARAMS)\n"); - + // Get mode value (跳过report_id字节) uint8_t mode = data[2]; debug_printf("Received mode: %d\n", mode); @@ -1789,7 +1706,7 @@ unsigned char process_send_params(uint8_t data[], uint16_t len) { // 检查模式是否允许修改：只允许修改用户模式（6-8），不允许修改预设模式（0-5）和bypass模式（9） // 改动原因：保护预设参数不被修改，只允许用户修改用户自定义模式参数 if (mode < EQ_USER_MODE_MIN || mode > EQ_USER_MODE_MAX) { - debug_printf("Error: Cannot modify EQ parameters for mode %d. Only user modes (%d-%d) can be modified.\n", + debug_printf("Error: Cannot modify EQ parameters for mode %d. Only user modes (%d-%d) can be modified.\n", mode, EQ_USER_MODE_MIN, EQ_USER_MODE_MAX); return false; } @@ -1803,34 +1720,114 @@ unsigned char process_send_params(uint8_t data[], uint16_t len) { return false; } - // 更新所有采样率的对应模式参数 + // 改动原因：优化EQ参数存储策略，统一参数源为44100Hz + // 先更新44100Hz的参数（统一参数源），然后通过copy_params_from_44100同步到其他采样率 + // 解析新参数（只解析一次，避免重复解析） + filter_params_t new_params; + memset(&new_params, 0, sizeof(filter_params_t)); + new_params.index = band_index; + new_params.type = (filter_type_t)data[4]; + + // 解析浮点参数（小端序） + uint32_t fc_bytes = data[5] | (data[6] << 8) | (data[7] << 16) | (data[8] << 24); + memcpy(&new_params.fc, &fc_bytes, 4); + uint32_t q_bytes = data[9] | (data[10] << 8) | (data[11] << 16) | (data[12] << 24); + memcpy(&new_params.q, &q_bytes, 4); + uint32_t bw_bytes = data[13] | (data[14] << 8) | (data[15] << 16) | (data[16] << 24); + memcpy(&new_params.bw, &bw_bytes, 4); + uint32_t gain_bytes = data[17] | (data[18] << 8) | (data[19] << 16) | (data[20] << 24); + memcpy(&new_params.gain, &gain_bytes, 4); + + DPRINTF("Parsed new params: fc=%.2f, q=%.3f, bw=%.2f, gain=%.2f\n", + new_params.fc, new_params.q, new_params.bw, new_params.gain); + + // 检查参数有效性 + if ((isnan(new_params.fc) || isnan(new_params.q) || isnan(new_params.bw) || isnan(new_params.gain)) || new_params.fc == 0) { + debug_printf("Error: Invalid float values detected!\n"); + return false; + } + + // 只更新44100Hz统一参数源 + eq_mode_data_t *eq_data_44100 = &sEQ_data_44100HZ[mode][0]; + filter_params_t *band_44100 = &eq_data_44100->bands[band_index]; + + // 检查参数是否变化 + if (eq_single_params_different(band_44100, &new_params)) { + debug_printf("Parameter changed for mode %d, band %d, updating 44100Hz source\n", mode, band_index); + + // 更新44100Hz的参数（统一参数源） + band_44100->type = new_params.type; + band_44100->fc = new_params.fc; + band_44100->q = new_params.q; + band_44100->bw = new_params.bw; + band_44100->gain = new_params.gain; + + // 同步到第二个通道 + eq_mode_data_t *eq_data_44100_ch1 = &sEQ_data_44100HZ[mode][1]; + filter_params_t *band_44100_ch1 = &eq_data_44100_ch1->bands[band_index]; + memcpy(band_44100_ch1, band_44100, sizeof(filter_params_t)); + + // 改动原因：当EQ禁用时，不设置强制模式切换标志，避免实际切换模式 + if (g_eq_enable == 1) { + SET_SHARED_GLOBAL(g_force_request_eq_mode_change, 1); + } else { + debug_printf("EQ disabled: Parameter updated for saved mode %d (not switching current mode)\n", mode); + } + + // 同步参数到所有其他采样率 + uint32_t all_sample_rates[] = {48000, 88200, 96000, 176400, 192000}; + int num_rates = sizeof(all_sample_rates) / sizeof(all_sample_rates[0]); + + for (int rate_idx = 0; rate_idx < num_rates; rate_idx++) { + uint32_t fs = all_sample_rates[rate_idx]; + // 复制参数到目标采样率 + if (copy_params_from_44100(fs, mode) == 0) { + // 计算系数 + calculate_current_mode_coefficients(fs, mode); + debug_printf("Synced params and calculated coefficients for %dHz\n", fs); + } + } + + // 计算44100Hz的系数 + calculate_current_mode_coefficients(44100, mode); + + // 改动原因：标记参数已修改，需要同步到Flash + // 使用eq_process_single_param_change处理参数变化并标记为脏 + if (eq_process_single_param_change(44100, mode, 0, band_index, band_44100) == 0) { + debug_printf("Successfully processed parameter change for 44100Hz channel 0\n"); + } else { + debug_printf("Error processing parameter change for 44100Hz channel 0\n"); + } + + // 标记模式为脏，需要同步到Flash + eq_flash_mark_dirty(mode); + debug_printf("Marked mode %d as dirty for Flash sync\n", mode); + + debug_printf("Parameter update completed for mode %d, band %d\n", mode, band_index); + } else { + debug_printf("Parameter unchanged for mode %d, band %d\n", mode, band_index); + } + + return true; + } +#if 0 + // 旧代码已重构，以下代码不再使用 uint32_t all_sample_rates[] = {44100, 48000, 88200, 96000, 176400, 192000}; int num_rates = sizeof(all_sample_rates) / sizeof(all_sample_rates[0]); - + for (int rate_idx = 0; rate_idx < num_rates; rate_idx++) { uint32_t fs = all_sample_rates[rate_idx]; - + // 查找对应采样率和模式的eq参数数组 eq_mode_data_t *eq_data = NULL; eq_mode_data_t *eq_data_2 = NULL; if (fs == 44100) { eq_data = &sEQ_data_44100HZ[mode][0]; eq_data_2 = &sEQ_data_44100HZ[mode][1]; - } else if (fs == 48000) { - eq_data = &sEQ_data_48000HZ[mode][0]; - eq_data_2 = &sEQ_data_48000HZ[mode][1]; - } else if (fs == 88200) { - eq_data = &sEQ_data_88200HZ[mode][0]; - eq_data_2 = &sEQ_data_88200HZ[mode][1]; - } else if (fs == 96000) { - eq_data = &sEQ_data_96000HZ[mode][0]; - eq_data_2 = &sEQ_data_96000HZ[mode][1]; - } else if (fs == 176400) { - eq_data = &sEQ_data_176400HZ[mode][0]; - eq_data_2 = &sEQ_data_176400HZ[mode][1]; - } else if (fs == 192000) { - eq_data = &sEQ_data_192000HZ[mode][0]; - eq_data_2 = &sEQ_data_192000HZ[mode][1]; + } else { + // 改动原因：所有采样率共用44100Hz数组 + eq_data = &sEQ_data_44100HZ[mode][0]; + eq_data_2 = &sEQ_data_44100HZ[mode][1]; } // 检查指针有效性和mode范围 @@ -1842,14 +1839,14 @@ unsigned char process_send_params(uint8_t data[], uint16_t len) { memset(&new_params, 0, sizeof(filter_params_t)); new_params.index = band_index; new_params.type = (filter_type_t)data[4]; // 位置从8移到4 - + // 打印原始数据字节 DPRINTF(" Raw data bytes: "); for (int i = 0; i < 25; i++) { DPRINTF("%02x ", data[i]); } DPRINTF("\n"); - + // 手动组合字节解析小端序浮点数 // Python发送小端序: 44 16 00 00 (600.0) // C接收小端序: 00 00 16 44，需要按小端序解析 @@ -1859,19 +1856,19 @@ unsigned char process_send_params(uint8_t data[], uint16_t len) { DPRINTF("fc: "); print_float(new_params.fc, 6); - + // q: cd cc cc 3e -> 0x3ecccccd (小端序) uint32_t q_bytes = data[9] | (data[10] << 8) | (data[11] << 16) | (data[12] << 24); memcpy(&new_params.q, &q_bytes, 4); DPRINTF("q: "); print_float(new_params.q, 6); - + // bw: 00 00 80 3f -> 0x3f800000 uint32_t bw_bytes = data[13] | (data[14] << 8) | (data[15] << 16) | (data[16] << 24); memcpy(&new_params.bw, &bw_bytes, 4); DPRINTF("bw: "); print_float(new_params.bw, 6); - + // gain: 00 00 10 c1 -> 0xc1100000 uint32_t gain_bytes = data[17] | (data[18] << 8) | (data[19] << 16) | (data[20] << 24); memcpy(&new_params.gain, &gain_bytes, 4); @@ -1932,7 +1929,7 @@ unsigned char process_send_params(uint8_t data[], uint16_t len) { } else { debug_printf("Error processing 0x8d single parameter change for 44100Hz channel 0\n"); } - + // 标记参数已修改，需要同步到Flash eq_flash_mark_dirty(mode); debug_printf("Marked mode %d as dirty for Flash sync\n", mode); @@ -1944,7 +1941,9 @@ unsigned char process_send_params(uint8_t data[], uint16_t len) { debug_printf("Parameter processing completed for all sample rates\n"); } -#endif +#endif // #if 0 + +#endif // #if EQ_EN (for process_send_params EQ commands section starting at line 1228) return true; } @@ -1959,20 +1958,25 @@ unsigned char process_send_params(uint8_t data[], uint16_t len) { uint8_t process_uart_set_eq_mode(uint8_t mode) { debug_printf("UART SET_EQ_MODE: mode=%d\n", mode); - + // 验证模式值范围 if (mode > EQ_MODE_MAX ) { debug_printf("Invalid EQ mode: %d\n", mode); return 0x01; // 失败 } - + // 设置EQ模式 SET_SHARED_GLOBAL(g_request_eq_mode, mode); debug_printf("EQ mode set to: %d\n", mode); - + return 0x00; // 成功 } +/** + * @brief UART校验和计算函数，直接复用user_func.c的check_sum函数 + */ +#define uart_checksum(pbuf, len) check_sum((unsigned char *)(pbuf), (unsigned)(len)) + /** * @brief 处理串口获取EQ模式信息 (0x31) * @param response 响应数据缓冲区 @@ -1985,50 +1989,48 @@ uint8_t process_uart_get_eq_mode(uint8_t *response, uint8_t response_size) debug_printf("Response buffer too small\n"); return 0; } - + uint8_t current_mode; int32_t mode_gain = 0; char mode_name[16] = {0}; - + GET_SHARED_GLOBAL(current_mode, g_request_eq_mode); - + // 获取模式增益和名称 if (current_mode < NUM_EQ_MODES) { // 从44100Hz数据中获取模式增益 eq_mode_data_t (*eq_data)[NUM_EQ_MODES][NUM_EQ_CHANS] = &sEQ_data_44100HZ; mode_gain = (*eq_data)[current_mode][0].post_gain_db; - + // 从全局模式信息中获取模式名称 memcpy(mode_name, g_mode_info.mode_names[current_mode], 16); } - + debug_printf("UART GET_EQ_MODE: mode=%d, gain=%d, name=%s\n", current_mode, mode_gain, mode_name); - - // 构建响应数据 (串口格式: 55 AA 00 31 15 ...) + + // 构建响应数据 (串口格式: 55 AA 00 41 15 ...) + // 改动原因：使用枚举名称替代数字命令码，提高代码可读性和维护性 response[0] = 0x55; // 帧头1 response[1] = 0xAA; // 帧头2 response[2] = 0x00; // 版本 - response[3] = 0x31; // 命令码 + response[3] = GET_EQ_MODE; // 命令码 response[4] = 0x15; // 数据长度 (21字节) - + response[5] = current_mode; // 模式值 response[6] = (mode_gain >> 0) & 0xFF; // 增益值 (小端序) response[7] = (mode_gain >> 8) & 0xFF; response[8] = (mode_gain >> 16) & 0xFF; response[9] = (mode_gain >> 24) & 0xFF; - + // 复制模式名称 for (int i = 0; i < 16; i++) { response[10 + i] = mode_name[i]; } - + // 计算校验和 - uint16_t sum = 0; - for (int i = 0; i < 26; i++) { - sum += response[i]; - } - response[26] = sum % 256; - + uint8_t checksum_pos = 26; + response[checksum_pos] = uart_checksum(response, checksum_pos); + return 27; // 总长度 } @@ -2045,45 +2047,45 @@ uint8_t process_uart_set_mode_gain_and_name(uint8_t *data) bool name_is_empty = true; bool gain_changed = false; bool name_changed = false; - + // 复制模式名称 for (int i = 0; i < 16; i++) { mode_name[i] = data[10 + i]; } - + debug_printf("UART SET_MODE_GAIN_AND_NAME: mode=%d, gain=%d, name=%s\n", mode, gain, mode_name); - + // 验证模式值范围 if (mode > EQ_MODE_MAX ) { debug_printf("Invalid EQ mode: %d\n", mode); return 0x01; // 失败 } - + // 检查模式是否允许修改：只允许修改用户模式（6-8），不允许修改预设模式（0-5）和bypass模式（9） // 改动原因：保护预设参数不被修改，只允许用户修改用户自定义模式参数 if (mode < EQ_USER_MODE_MIN || mode > EQ_USER_MODE_MAX) { - debug_printf("Error: Cannot modify EQ gain/name for mode %d. Only user modes (%d-%d) can be modified.\n", + debug_printf("Error: Cannot modify EQ gain/name for mode %d. Only user modes (%d-%d) can be modified.\n", mode, EQ_USER_MODE_MIN, EQ_USER_MODE_MAX); return 0x01; // 失败 } - + // 设置模式增益和名称（只处理用户模式） if (mode < NUM_EQ_MODES) { // 获取44100采样率下该模式的当前gain值，判断是否有变化 int32_t current_gain_44100 = sEQ_data_44100HZ[mode][0].post_gain_db; bool gain_changed = (current_gain_44100 != gain); - + if (gain_changed) { debug_printf("UART: Gain changed from %d to %d, will mark dirty\n", current_gain_44100, gain); } else { debug_printf("UART: Gain unchanged (%d), skip marking dirty\n", current_gain_44100); } - + // 获取当前模式名称，判断是否有变化 char current_name[16] = {0}; strncpy(current_name, g_mode_info.mode_names[mode], 15); current_name[15] = '\0'; - + // 检查新名称是否全空（全0或全空格） if (mode_name[0] != '\0') { // 检查是否全是空格 @@ -2095,10 +2097,10 @@ uint8_t process_uart_set_mode_gain_and_name(uint8_t *data) } } // 如果第一个字符就是\0，name_is_empty保持为true - + // 比较名称是否有变化 name_changed = (strncmp(current_name, mode_name, 15) != 0); - + if (name_is_empty) { debug_printf("UART: Mode name is empty, skip saving\n"); } else if (name_changed) { @@ -2106,7 +2108,7 @@ uint8_t process_uart_set_mode_gain_and_name(uint8_t *data) } else { debug_printf("UART: Name unchanged ('%s'), skip marking dirty\n", current_name); } - + // 设置到所有采样率的EQ数据中 // 改动原因：限制gain范围到0到-50dB，确保所有post_gain_db都在有效范围内 int32_t clamped_gain = clamp_post_gain(gain); @@ -2114,29 +2116,16 @@ uint8_t process_uart_set_mode_gain_and_name(uint8_t *data) debug_printf("UART: Gain value %d clamped to %d (range: 0 to -50dB)\n", gain, clamped_gain); } uint32_t all_sample_rates[] = {44100, 48000, 88200, 96000, 176400, 192000}; - for (int i = 0; i < 6; i++) { - uint32_t fs = all_sample_rates[i]; - eq_mode_data_t (*eq_data)[NUM_EQ_MODES][NUM_EQ_CHANS] = NULL; - switch (fs) { - case 44100: eq_data = &sEQ_data_44100HZ; break; - case 48000: eq_data = &sEQ_data_48000HZ; break; - case 88200: eq_data = &sEQ_data_88200HZ; break; - case 96000: eq_data = &sEQ_data_96000HZ; break; - case 176400: eq_data = &sEQ_data_176400HZ; break; - case 192000: eq_data = &sEQ_data_192000HZ; break; - } - if (eq_data != NULL) { - (*eq_data)[mode][0].post_gain_db = clamped_gain; - (*eq_data)[mode][1].post_gain_db = clamped_gain; - } - } - + // 改动原因：所有采样率共用44100Hz数组，直接更新即可 + sEQ_data_44100HZ[mode][0].post_gain_db = clamped_gain; + sEQ_data_44100HZ[mode][1].post_gain_db = clamped_gain; + // 设置到全局模式信息中（根据判断结果决定是否标记脏标志） // 改动原因：使用限制后的gain值，确保存储的gain值在有效范围内 set_mode_gain(mode, clamped_gain); eq_mark_gain_dirty(); // 只有变化时才标记脏 } - + if (!name_is_empty && name_changed) { set_mode_name(mode, mode_name); eq_mark_name_dirty(); // 只有变化且非空时才标记脏 @@ -2156,11 +2145,11 @@ uint8_t process_uart_set_eq_params(uint8_t *data) uint8_t filter_type = data[7]; // 滤波器类型 float fc, q, bw, gain; uint8_t result = 0x00; - + // 检查模式是否允许修改：只允许修改用户模式（6-8），不允许修改预设模式（0-5）和bypass模式（9） // 改动原因：保护预设参数不被UART修改，只允许用户通过UART修改用户自定义模式参数 if (mode < EQ_USER_MODE_MIN || mode > EQ_USER_MODE_MAX) { - debug_printf("UART Error: Cannot modify EQ parameters for mode %d. Only user modes (%d-%d) can be modified.\n", + debug_printf("UART Error: Cannot modify EQ parameters for mode %d. Only user modes (%d-%d) can be modified.\n", mode, EQ_USER_MODE_MIN, EQ_USER_MODE_MAX); return 0x01; // 失败 } @@ -2169,7 +2158,7 @@ uint8_t process_uart_set_eq_params(uint8_t *data) q = *(float*)(&data[12]); bw = *(float*)(&data[16]); gain = *(float*)(&data[20]); - + DPRINTF("mode: %d, band_index: %d, filter_type: %d\n", mode, band_index, filter_type); DPRINTF("fc: "); print_float(fc, 6); @@ -2181,13 +2170,13 @@ uint8_t process_uart_set_eq_params(uint8_t *data) DPRINTF("gain: "); print_float(gain, 6); DPRINTF("\n"); - + // 验证参数范围（band_index检查） if ((mode > (EQ_MODE_MAX - 1)) || (band_index >= MAX_EQ_BANDS)) { debug_printf("Invalid parameters: mode=%d, band=%d\n", mode, band_index); return 0x01; // 失败 } - + // 使用现有的参数处理逻辑 // 构建临时数据包，调用现有的HID处理函数 uint8_t temp_data[60]; @@ -2196,18 +2185,18 @@ uint8_t process_uart_set_eq_params(uint8_t *data) temp_data[2] = mode; temp_data[3] = band_index; temp_data[4] = filter_type; - + // 复制浮点参数 memcpy(&temp_data[5], &fc, 4); memcpy(&temp_data[9], &q, 4); memcpy(&temp_data[13], &bw, 4); memcpy(&temp_data[17], &gain, 4); - + // 调用现有的HID处理函数 if (process_send_params(temp_data, 60) == false) { result = 0x01; // 失败 } - + return result; } @@ -2224,40 +2213,41 @@ uint8_t process_uart_get_eq_params(uint8_t *data, uint8_t *response, uint8_t res debug_printf("Response buffer too small\n"); return 0; } - + uint8_t mode = data[5]; // 模式值 uint8_t band_index = data[6]; // EQ索引 - + debug_printf("UART GET_EQ_PARAMS: mode=%d, band=%d\n", mode, band_index); - + // 验证参数范围 if (mode > (EQ_MODE_MAX - 1) || band_index > 7) { debug_printf("Invalid parameters: mode=%d, band=%d\n", mode, band_index); return 0; } - - // 构建响应数据 (串口格式: 55 AA 00 34 15 ...) + + // 构建响应数据 (串口格式: 55 AA 00 44 13 ...) + // 改动原因：使用枚举名称替代数字命令码，提高代码可读性和维护性 response[0] = 0x55; // 帧头1 response[1] = 0xAA; // 帧头2 response[2] = 0x00; // 版本 - response[3] = 0x34; // 命令码 - response[4] = 0x15; // 数据长度 (21字节) - + response[3] = GET_EQ_PARAMS; // 命令码 + response[4] = 0x13; // 数据长度 (19字节: 1字节模式 + 1字节索引 + 1字节类型 + 4个float参数共16字节) + response[5] = mode; response[6] = band_index; - + // 从EQ数据中读取参数 // 选择对应的EQ数据数组 (使用44100Hz，因为串口设置参数时主要存储到44100Hz) eq_mode_data_t (*eq_data)[NUM_EQ_MODES][NUM_EQ_CHANS] = NULL; // 优先使用44100Hz数据，因为串口设置参数时主要存储到44100Hz eq_data = &sEQ_data_44100HZ; debug_printf("Using 44100Hz data for UART read (g_eq_sample_rate=%d)\n", g_eq_sample_rate); - + if (eq_data != NULL && mode < NUM_EQ_MODES) { // 复制滤波器参数 filter_params_t *band = &(*eq_data)[mode][0].bands[band_index]; response[7] = band->type; - + // 复制浮点参数 memcpy(&response[8], &band->fc, 4); memcpy(&response[12], &band->q, 4); @@ -2273,7 +2263,7 @@ uint8_t process_uart_get_eq_params(uint8_t *data, uint8_t *response, uint8_t res DPRINTF("gain: "); print_float(band->gain, 6); DPRINTF("\n"); - + } else { // 返回默认值 response[7] = 0x00; // 滤波器类型 @@ -2286,15 +2276,13 @@ uint8_t process_uart_get_eq_params(uint8_t *data, uint8_t *response, uint8_t res memcpy(&response[16], &default_bw, 4); memcpy(&response[20], &default_gain, 4); } - + // 计算校验和 - uint16_t sum = 0; - for (int i = 0; i < 26; i++) { - sum += response[i]; - } - response[26] = sum % 256; - - return 27; // 总长度 + // 改动原因：数据长度是19字节(0x13)，所以校验和位置应该是5(头部) + 19(数据) = 24 + uint8_t checksum_pos = 24; + response[checksum_pos] = uart_checksum(response, checksum_pos); + + return 25; // 总长度：5(头部) + 19(数据) + 1(校验和) = 25 } /** @@ -2314,30 +2302,28 @@ uint8_t process_uart_get_eq_mode_count(uint8_t *response, uint8_t response_size) debug_printf("Response buffer too small\n"); return 0; } - + // 模式总数：预定义模式(0-5) + 用户模式(6-8) = 9，不包含禁用模式(10) uint8_t mode_count = 9; // 预定义模式数量：0-5共6个预设模式 uint8_t preset_mode_count = 6; // EQ_PRESET_MODE_MAX + 1 = 5 + 1 = 6 - + debug_printf("UART GET_EQ_MODE_COUNT: count=%d, preset_count=%d\n", mode_count, preset_mode_count); - - // 构建响应数据 (串口格式: 55 AA 00 36 02 ...) + + // 构建响应数据 (串口格式: 55 AA 00 47 02 ...) + // 改动原因：使用枚举名称替代数字命令码，提高代码可读性和维护性 response[0] = 0x55; // 帧头1 response[1] = 0xAA; // 帧头2 response[2] = 0x00; // 版本 - response[3] = 0x36; // 命令码 + response[3] = GET_EQ_MODE_COUNT; // 命令码 response[4] = 0x02; // 数据长度 (2字节) response[5] = mode_count; // 模式总数 response[6] = preset_mode_count; // 预定义模式数量 - + // 计算校验和 - uint16_t sum = 0; - for (int i = 0; i < 7; i++) { - sum += response[i]; - } - response[7] = sum % 256; - + uint8_t checksum_pos = 7; + response[checksum_pos] = uart_checksum(response, checksum_pos); + return 8; // 总长度 } @@ -2350,19 +2336,19 @@ uint8_t process_uart_set_and_save_eq_mode(uint8_t *data) { uint8_t mode = data[5]; // 模式值 uint8_t status = 0x00; // 成功 - + debug_printf("UART SET_AND_SAVE_EQ_MODE: mode=%d\n", mode); - + // 验证模式值范围 if (mode > EQ_MODE_MAX ) { debug_printf("Error: Invalid mode %d (valid range: 0-9)\n", mode); return 0x01; // 失败 } - + // 设置当前模式 g_request_eq_mode = mode; SET_SHARED_GLOBAL(g_request_eq_mode, mode); - + // 保存到Flash int result = eq_flash_save_current_mode(mode); if (result != 0) { @@ -2371,7 +2357,7 @@ uint8_t process_uart_set_and_save_eq_mode(uint8_t *data) } else { debug_printf("Successfully set and saved EQ mode %d to Flash\n", mode); } - + return status; } @@ -2384,9 +2370,9 @@ uint8_t process_uart_reset_eq_params(uint8_t *data) { uint8_t mode = data[5]; // 模式号 uint8_t status = 0x00; // 成功 - + debug_printf("UART RESET_EQ_PARAMS: mode=%d\n", mode); - + // 验证模式值范围 if (mode > (EQ_MODE_MAX - 1) && mode != 0xFF) { debug_printf("Invalid EQ mode: %d\n", mode); @@ -2398,7 +2384,7 @@ uint8_t process_uart_reset_eq_params(uint8_t *data) status = 0x01; // 失败 } } - + return status; } @@ -2412,18 +2398,18 @@ void set_mode_gain(uint8_t mode, int32_t gain) { debug_printf("Error: Invalid mode %d\n", mode); return; } - + // 改动原因：限制gain范围到0到-50dB，确保存储的gain值在有效范围内 int32_t clamped_gain = clamp_post_gain(gain); if (clamped_gain != gain) { debug_printf("Warning: gain %d clamped to %d (range: 0 to -50dB) for mode %d\n", gain, clamped_gain, mode); } - + // 设置模式增益 g_mode_info.mode_gains[mode] = clamped_gain; - + debug_printf("Set mode %d: gain=%d dB\n", mode, clamped_gain); - + // 注意：不在这里自动标记脏标志，由调用者根据实际情况决定是否标记 } @@ -2433,13 +2419,13 @@ void set_mode_name(uint8_t mode, const char* name) { debug_printf("Error: Invalid mode %d or null name\n", mode); return; } - + // 设置模式名称 strncpy(g_mode_info.mode_names[mode], name, 15); g_mode_info.mode_names[mode][15] = '\0'; // 确保null终止 - + debug_printf("Set mode %d: name='%s'\n", mode, name); - + // 注意：不在这里自动标记脏标志，由调用者根据实际情况决定是否标记 } @@ -2449,9 +2435,9 @@ void get_mode_gain(uint8_t mode, int32_t* gain) { debug_printf("Error: Invalid parameters for mode %d\n", mode); return; } - + *gain = g_mode_info.mode_gains[mode]; - + debug_printf("Get mode %d: gain=%d dB\n", mode, *gain); } @@ -2461,10 +2447,10 @@ void get_mode_name(uint8_t mode, char* name) { debug_printf("Error: Invalid parameters for mode %d\n", mode); return; } - + strncpy(name, g_mode_info.mode_names[mode], 15); name[15] = '\0'; // 确保null终止 - + debug_printf("Get mode %d: name='%s'\n", mode, name); } @@ -2475,14 +2461,14 @@ void init_mode_info(void) { "JAZZ", "POP", "ROCK", "CLASIC", "R&B", "3A Game", "FPS", "user 1", "user 2", "user3" }; - + // 初始化默认增益（0dB） for (int i = 0; i < NUM_EQ_MODES; i++) { g_mode_info.mode_gains[i] = 0; strncpy(g_mode_info.mode_names[i], default_names[i], 15); g_mode_info.mode_names[i][15] = '\0'; } - + debug_printf("Mode info initialized with %d modes\n", NUM_EQ_MODES); } @@ -2523,7 +2509,7 @@ unsigned char process_read_params(uint8_t response[]) { debug_printf("Building 0x8B response data:\n"); response[0] = 0x77; // Sync header 1 response[1] = 0x8B; // Sync header 2 - + // 确定要返回的模式值 uint8_t target_mode; if (read_request.read_mode_request_mode == 0xFF) { @@ -2537,10 +2523,10 @@ unsigned char process_read_params(uint8_t response[]) { target_mode = read_request.read_mode_request_mode; debug_printf("Mode=%d, returning specified mode info\n", target_mode); } - + // 模式值 response[2] = target_mode; - + // 改动原因：检查模式是否在有效范围内（0-9），如果是禁用模式（10）或超出范围，返回全0 if (target_mode >= EQ_DISABLED_MODE || target_mode > EQ_MODE_MAX) { debug_printf("Mode %d is disabled or invalid, returning all zeros\n", target_mode); @@ -2551,42 +2537,21 @@ unsigned char process_read_params(uint8_t response[]) { int32_t target_post_gain = 0; if (target_mode < NUM_EQ_MODES) { // 根据当前采样率选择对应的EQ数据数组 - eq_mode_data_t (*eq_data)[NUM_EQ_MODES][NUM_EQ_CHANS] = NULL; - switch(g_eq_sample_rate) { - case 44100: - eq_data = &sEQ_data_44100HZ; - break; - case 48000: - eq_data = &sEQ_data_48000HZ; - break; - case 88200: - eq_data = &sEQ_data_88200HZ; - break; - case 96000: - eq_data = &sEQ_data_96000HZ; - break; - case 176400: - eq_data = &sEQ_data_176400HZ; - break; - case 192000: - eq_data = &sEQ_data_192000HZ; - break; - default: - eq_data = &sEQ_data_48000HZ; // 默认使用48kHz数据 - } - + // 改动原因：使用公用数组，通过函数获取对应采样率的数组指针 + eq_mode_data_t (*eq_data)[NUM_EQ_MODES][NUM_EQ_CHANS] = get_eq_array_ptr_common(g_eq_sample_rate); + if (eq_data != NULL) { target_post_gain = (*eq_data)[target_mode][0].post_gain_db; debug_printf("Reading post_gain from mode %d: %d dB\n", target_mode, target_post_gain); } } - + // 整体增益 (4字节，位置3-6) - 根据简化协议修正位置 response[3] = (uint8_t)(target_post_gain & 0xFF); response[4] = (uint8_t)((target_post_gain >> 8) & 0xFF); response[5] = (uint8_t)((target_post_gain >> 16) & 0xFF); response[6] = (uint8_t)((target_post_gain >> 24) & 0xFF); - + // 模式名称 (16字节，UTF-8编码，位置7-22) if (target_mode < NUM_EQ_MODES) { memcpy(&response[7], g_mode_info.mode_names[target_mode], 16); @@ -2595,8 +2560,8 @@ unsigned char process_read_params(uint8_t response[]) { memset(&response[7], 0, 16); } } - - + + read_request.is_read_mode_request = false; // Clear read request flag read_request.read_mode_request_mode = 0; // Clear mode parameter return true; @@ -2607,7 +2572,7 @@ unsigned char process_read_params(uint8_t response[]) { debug_printf("Building 0x8F response data:\n"); response[0] = 0x77; // Sync header 1 response[1] = 0x8F; // Sync header 2 - + get_device_info(response); read_request.is_read_device_info_request = false; // Clear read request flag @@ -2619,7 +2584,7 @@ unsigned char process_read_params(uint8_t response[]) { debug_printf("Building 0x90 response data:\n"); response[0] = 0x77; // Sync header 1 response[1] = 0x90; // Sync header 2 - + // 只返回之前保存的状态，不再执行复位操作 // 改动原因：复位操作已在收到命令时执行并保存状态，这里只需返回保存的状态码 if (read_request.mode != 0xFF && read_request.mode >= EQ_PRESET_MODE_MIN && read_request.mode <= EQ_USER_MODE_MAX) { @@ -2627,7 +2592,7 @@ unsigned char process_read_params(uint8_t response[]) { } else { response[3] = 0x00; // 成功 } - + read_request.is_reset_eq_params_request = false; // Clear read request flag return true; } @@ -2637,19 +2602,19 @@ unsigned char process_read_params(uint8_t response[]) { debug_printf("Building 0x91 response data:\n"); response[0] = 0x77; // Sync header 1 response[1] = 0x91; // Sync header 2 - + // 模式总数：预定义模式(0-5) + 用户模式(6-8) = 9，不包含禁用模式(10) // 注意：NUM_EQ_MODES = 10，但实际可用模式是0-8共9个（不包含禁用模式10） uint8_t mode_count = NUM_EQ_MODES; // 固定返回10 response[2] = mode_count; - + // 预定义模式数量：0-6共7个预设模式 - uint8_t preset_mode_count = EQ_PRESET_MODE_MAX + 1; + uint8_t preset_mode_count = EQ_PRESET_MODE_MAX + 1; response[3] = preset_mode_count; - - debug_printf("EQ mode count: %d, preset mode count: %d (preset modes 0-5 + user modes 6-8, excluding disabled mode 10)\n", + + debug_printf("EQ mode count: %d, preset mode count: %d (preset modes 0-5 + user modes 6-8, excluding disabled mode 10)\n", mode_count, preset_mode_count); - + read_request.is_read_mode_count_request = false; // Clear read request flag return true; } @@ -2659,17 +2624,17 @@ unsigned char process_read_params(uint8_t response[]) { debug_printf("Building 0x92 response data:\n"); response[0] = 0x77; // Sync header 1 response[1] = 0x92; // Sync header 2 - + // 状态码：0x00=成功, 0x01=失败 uint8_t status = (read_request.mode == 0xFF) ? 0x01 : 0x00; response[2] = status; - + if (status == 0x00) { debug_printf("EQ mode %d set and saved successfully\n", read_request.mode); } else { debug_printf("Failed to set and save EQ mode\n"); } - + read_request.is_set_and_save_mode_request = false; // Clear read request flag return true; } @@ -2679,21 +2644,21 @@ unsigned char process_read_params(uint8_t response[]) { debug_printf("Building 0x94 response data (GET_VOLUME):\n"); response[0] = 0x77; // Sync header 1 response[1] = 0x94; // Sync header 2 - + // 读取全局变量（直接读取，因为在C文件中） extern unsigned g_volume_level; unsigned volume_level = g_volume_level; - + // 当前音量级别 (1字节，位置2) response[2] = (uint8_t)volume_level; - + debug_printf("Current volume level: %d\n", volume_level); - + // 其余字节填充为0 for (int i = 3; i < 63; i++) { response[i] = 0x00; } - + read_request.is_read_volume_request = false; // Clear read request flag return true; } @@ -2704,23 +2669,23 @@ unsigned char process_read_params(uint8_t response[]) { debug_printf("Building 0x95 response data (GET_LED_INFO):\n"); response[0] = 0x77; // Sync header 1 response[1] = 0x95; // Sync header 2 - + // LED索引 response[2] = led_request.led_index; - + // LED名称 (16字节，UTF-8编码) // 当前设备只有1个LED，索引为0，名称为"Main LED" const char* led_name = "Main LED"; memcpy(&response[3], led_name, strlen(led_name)); // 剩余字节填充为0 - + debug_printf("LED info - Index: %d, Name: %s\n", led_request.led_index, led_name); - + // 其余字节填充为0 for (int i = 3 + strlen(led_name); i < 63; i++) { response[i] = 0x00; } - + led_request.is_get_led_info_request = false; // Clear request flag return true; } @@ -2731,47 +2696,47 @@ unsigned char process_read_params(uint8_t response[]) { debug_printf("Building 0x97 response data (GET_LED_SWITCH):\n"); response[0] = 0x77; // Sync header 1 response[1] = 0x97; // Sync header 2 - + // LED索引 response[2] = led_request.led_index; - + // 读取LED开关全局变量 extern unsigned g_led_enable; unsigned led_enable = g_led_enable; GET_SHARED_GLOBAL(led_enable, g_led_enable); - + // LED开关状态 (0=OFF, 1=ON) response[3] = (uint8_t)led_enable; - + debug_printf("LED switch - Index: %d, Switch: %s\n", led_request.led_index, led_enable ? "ON" : "OFF"); - + // 其余字节填充为0 for (int i = 4; i < 63; i++) { response[i] = 0x00; } - + led_request.is_get_led_switch_request = false; // Clear request flag return true; } - + // 处理设置LED开关响应 (0x96) - SET_LED_SWITCH响应 // 改动原因：SET_LED_SWITCH命令需要返回状态码，使用独立的响应处理 if (led_request.is_set_led_switch_request == true) { debug_printf("Building 0x96 response data (SET_LED_SWITCH):\n"); response[0] = 0x77; // Sync header 1 response[1] = 0x96; // Sync header 2 - + // 状态码 (0x00=成功, 0x01=失败) // 由于SET命令已经在process_send_params中执行，这里直接返回成功 response[2] = 0x00; // 成功 - + debug_printf("LED switch set response - Status: Success\n"); - + // 其余字节填充为0 for (int i = 3; i < 63; i++) { response[i] = 0x00; } - + led_request.is_set_led_switch_request = false; // Clear request flag return true; } @@ -2782,18 +2747,18 @@ unsigned char process_read_params(uint8_t response[]) { debug_printf("Building 0x99 response data (GET_LED_COUNT):\n"); response[0] = 0x77; // Sync header 1 response[1] = 0x99; // Sync header 2 - + // LED总数（当前设备只有1个LED） uint8_t led_count = 1; response[2] = led_count; - + debug_printf("LED count: %d\n", led_count); - + // 其余字节填充为0 for (int i = 3; i < 63; i++) { response[i] = 0x00; } - + led_request.is_get_led_count_request = false; // Clear request flag return true; } @@ -2804,15 +2769,15 @@ unsigned char process_read_params(uint8_t response[]) { debug_printf("Building 0x98 response data (GET_LED_STATUS):\n"); response[0] = 0x77; // Sync header 1 response[1] = 0x98; // Sync header 2 - + // LED索引 response[2] = led_request.led_index; - + // 读取当前LED颜色 extern unsigned g_led_color; unsigned led_color; GET_SHARED_GLOBAL(led_color, g_led_color); - + // 转换LED颜色为RGB值 // 改动原因：修正RGB转换逻辑，LED颜色是低电平有效，应该检查bit位是否为0 // LED颜色定义：bit 1=0表示红色开启，bit 2=0表示绿色开启，bit 3=0表示蓝色开启 @@ -2825,7 +2790,7 @@ unsigned char process_read_params(uint8_t response[]) { response[3] = (uint8_t)r; // R颜色值 response[4] = (uint8_t)g; // G颜色值 response[5] = (uint8_t)b; // B颜色值 - + // 获取LED状态（需要在audiohw.xc中声明get_led_status函数） // 由于get_led_status在XC文件中，这里根据当前状态判断 extern unsigned g_playback_format, g_audio_type, g_gain_mode, g_uac_mode, g_game_mode; @@ -2835,11 +2800,11 @@ unsigned char process_read_params(uint8_t response[]) { GET_SHARED_GLOBAL(gain_mode, g_gain_mode); GET_SHARED_GLOBAL(uac_mode, g_uac_mode); GET_SHARED_GLOBAL(game_mode, g_game_mode); - + uint8_t led_status = 0; // LED_STATUS_OFF unsigned is_blinking = 0; unsigned is_fast_blinking = 0; - + if (uac_mode == 1) { // UAC 1.0 Game Mode if (gain_mode == 1) { // High impedance is_blinking = 1; @@ -2852,7 +2817,7 @@ unsigned char process_read_params(uint8_t response[]) { is_blinking = 1; } } - + if (led_color == 0x7F) { // LED_OFF led_status = 0; // LED_STATUS_OFF } else if (is_blinking) { @@ -2860,17 +2825,17 @@ unsigned char process_read_params(uint8_t response[]) { } else { led_status = 1; // LED_STATUS_SOLID } - + response[6] = led_status; // LED状态 - - debug_printf("LED status - Index: %d, RGB: (%d,%d,%d), Status: %d\n", + + debug_printf("LED status - Index: %d, RGB: (%d,%d,%d), Status: %d\n", led_request.led_index, r, g, b, led_status); - + // 其余字节填充为0 for (int i = 7; i < 63; i++) { response[i] = 0x00; } - + led_request.is_get_led_status_request = false; // Clear request flag return true; } @@ -2881,29 +2846,29 @@ unsigned char process_read_params(uint8_t response[]) { debug_printf("Building 0x9A response data (GET_UAC_MODE_INFO):\n"); response[0] = 0x77; // Sync header 1 response[1] = 0x9A; // Sync header 2 - + // UAC模式总数（当前为2：UAC2.0和UAC1.0） uint8_t uac_mode_count = 2; response[2] = uac_mode_count; - + // 模式0名称：UAC2.0 (8字节) const char* mode0_name = "UAC2.0"; memcpy(&response[3], mode0_name, strlen(mode0_name)); // 剩余字节填充为0 - + // 模式1名称：UAC1.0 (8字节) const char* mode1_name = "UAC1.0"; memcpy(&response[11], mode1_name, strlen(mode1_name)); // 剩余字节填充为0 - + // 其余字节填充为0 for (int i = 19; i < 63; i++) { response[i] = 0x00; } - - debug_printf("UAC mode info - Count: %d, Mode0: '%s', Mode1: '%s'\n", + + debug_printf("UAC mode info - Count: %d, Mode0: '%s', Mode1: '%s'\n", uac_mode_count, mode0_name, mode1_name); - + uac_request.is_get_uac_mode_info_request = false; // Clear request flag return true; } @@ -2916,30 +2881,30 @@ unsigned char process_read_params(uint8_t response[]) { debug_printf("Building 0x9C response data (GET_CURRENT_UAC_MODE):\n"); response[0] = 0x77; // Sync header 1 response[1] = 0x9C; // Sync header 2 - + // 读取当前UAC模式 extern unsigned g_uac_mode; unsigned current_uac_mode; GET_SHARED_GLOBAL(current_uac_mode, g_uac_mode); - + // 转换为协议格式：0=UAC2.0, 1=UAC1.0 // g_uac_mode: 2=UAC2.0, 1=UAC1.0 uint8_t uac_mode_value = (current_uac_mode == 1) ? 1 : 0; // 1=UAC1.0, 其他=UAC2.0(0) response[2] = uac_mode_value; - + // 当前UAC模式名称 (8字节) const char* current_mode_name = (uac_mode_value == 0) ? "UAC2.0" : "UAC1.0"; memcpy(&response[3], current_mode_name, strlen(current_mode_name)); // 剩余字节填充为0 - + // 其余字节填充为0 for (int i = 11; i < 63; i++) { response[i] = 0x00; } - - debug_printf("Current UAC mode - Value: %d (%s), Name: '%s'\n", + + debug_printf("Current UAC mode - Value: %d (%s), Name: '%s'\n", uac_mode_value, uac_mode_value == 0 ? "UAC2.0" : "UAC1.0", current_mode_name); - + uac_request.is_get_current_uac_mode_request = false; // Clear request flag return true; } @@ -2950,20 +2915,20 @@ unsigned char process_read_params(uint8_t response[]) { debug_printf("Building 0x9D response data (SET_EQ_ENABLE):\n"); response[0] = 0x77; // Sync header 1 response[1] = 0x9D; // Sync header 2 - + // 状态码：0x00=成功, 0x01=失败 response[2] = 0x00; // 成功 - + // 当前EQ使能状态（全局开关，所有模式共用） response[3] = g_eq_enable; - + // 其余字节填充为0 for (int i = 4; i < 63; i++) { response[i] = 0x00; } - + debug_printf("EQ enable set - Status: 0x00, Enable: %d (global switch)\n", g_eq_enable); - + read_request.is_set_eq_enable_request = false; // Clear request flag return true; } @@ -2974,17 +2939,17 @@ unsigned char process_read_params(uint8_t response[]) { debug_printf("Building 0x9E response data (GET_EQ_ENABLE):\n"); response[0] = 0x77; // Sync header 1 response[1] = 0x9E; // Sync header 2 - + // EQ使能开关状态（全局开关，所有模式共用） response[2] = g_eq_enable; - + // 其余字节填充为0 for (int i = 3; i < 63; i++) { response[i] = 0x00; } - + debug_printf("EQ enable status - Enable: %d (global switch)\n", g_eq_enable); - + read_request.is_get_eq_enable_request = false; // Clear request flag return true; } @@ -2995,30 +2960,30 @@ unsigned char process_read_params(uint8_t response[]) { debug_printf("Building 0x9F response data (GET_SAMPLE_FORMAT):\n"); response[0] = 0x77; // Sync header 1 response[1] = 0x9F; // Sync header 2 - + // 读取全局变量（使用SHARED_GLOBAL宏） extern unsigned g_samfreq, g_dsd_mode; unsigned samfreq, dsd_mode; GET_SHARED_GLOBAL(samfreq, g_samfreq); GET_SHARED_GLOBAL(dsd_mode, g_dsd_mode); - + // 采样率（32位，小端序，位置2-5） response[2] = (uint8_t)(samfreq & 0xFF); response[3] = (uint8_t)((samfreq >> 8) & 0xFF); response[4] = (uint8_t)((samfreq >> 16) & 0xFF); response[5] = (uint8_t)((samfreq >> 24) & 0xFF); - + // DSD模式（1字节，位置6） response[6] = (uint8_t)dsd_mode; - - debug_printf("Sample format - samFreq: %d, dsdMode: %d\n", + + debug_printf("Sample format - samFreq: %d, dsdMode: %d\n", samfreq, dsd_mode); - + // 其余字节填充为0 for (int i = 7; i < 63; i++) { response[i] = 0x00; } - + read_request.is_read_sample_format_request = false; // Clear request flag return true; } @@ -3029,22 +2994,22 @@ unsigned char process_read_params(uint8_t response[]) { debug_printf("Building 0xA1 response data (GET_GAIN_MODE):\n"); response[0] = 0x77; // Sync header 1 response[1] = 0xA1; // Sync header 2 - + // 读取全局变量（使用SHARED_GLOBAL宏） extern unsigned g_gain_mode; unsigned gain_mode; GET_SHARED_GLOBAL(gain_mode, g_gain_mode); - + // 当前增益模式 (1字节，位置2) response[2] = (uint8_t)gain_mode; - + debug_printf("Current gain mode: %d (0=低阻, 1=高阻)\n", gain_mode); - + // 其余字节填充为0 for (int i = 3; i < 63; i++) { response[i] = 0x00; } - + read_request.is_get_gain_mode_request = false; // Clear read request flag return true; } @@ -3055,22 +3020,22 @@ unsigned char process_read_params(uint8_t response[]) { debug_printf("Building 0xA3 response data (GET_FILTER_MODE):\n"); response[0] = 0x77; // Sync header 1 response[1] = 0xA3; // Sync header 2 - + // 读取全局变量（使用SHARED_GLOBAL宏） extern unsigned g_filter_mode; unsigned filter_mode; GET_SHARED_GLOBAL(filter_mode, g_filter_mode); - + // 当前滤波器模式 (1字节，位置2) response[2] = (uint8_t)filter_mode; - + debug_printf("Current filter mode: %d (0-6: 7种滤波器模式)\n", filter_mode); - + // 其余字节填充为0 for (int i = 3; i < 63; i++) { response[i] = 0x00; } - + read_request.is_get_filter_mode_request = false; // Clear read request flag return true; } @@ -3081,26 +3046,26 @@ unsigned char process_read_params(uint8_t response[]) { debug_printf("Building 0xA5 response data (GET_GAME_MODE):\n"); response[0] = 0x77; // Sync header 1 response[1] = 0xA5; // Sync header 2 - + // 读取全局变量（使用SHARED_GLOBAL宏） extern unsigned g_game_mode; unsigned game_mode; GET_SHARED_GLOBAL(game_mode, g_game_mode); - + // 当前游戏模式 (1字节，位置2) #if UAC2 == 1 response[2] = 0; #else response[2] = (uint8_t)game_mode; #endif - + debug_printf("Current game mode: %d (0=无音效, 1=FPS, 2=虚拟7.1)\n", game_mode); - + // 其余字节填充为0 for (int i = 3; i < 63; i++) { response[i] = 0x00; } - + read_request.is_get_game_mode_request = false; // Clear read request flag return true; } @@ -3111,7 +3076,7 @@ unsigned char process_read_params(uint8_t response[]) { debug_printf("Building 0xA6 response data (GET_FIRMWARE_VERSION):\n"); response[0] = 0x77; // Sync header 1 response[1] = 0xA6; // Sync header 2 - + // 读取固件版本号（BCD格式），参考user_uart.xc:414-418的实现 // BCD_DEVICE_J: 主版本号 // BCD_DEVICE_M: 次版本号 @@ -3119,16 +3084,16 @@ unsigned char process_read_params(uint8_t response[]) { response[2] = (uint8_t)BCD_DEVICE_J; // 主版本号 response[3] = (uint8_t)BCD_DEVICE_M; // 次版本号 response[4] = (uint8_t)BCD_DEVICE_N; // 修订版本号 - - debug_printf("Firmware version: %d.%d.%d (BCD format: 0x%02X 0x%02X 0x%02X)\n", + + debug_printf("Firmware version: %d.%d.%d (BCD format: 0x%02X 0x%02X 0x%02X)\n", BCD_DEVICE_J, BCD_DEVICE_M, BCD_DEVICE_N, BCD_DEVICE_J, BCD_DEVICE_M, BCD_DEVICE_N); - + // 其余字节填充为0 for (int i = 5; i < 63; i++) { response[i] = 0x00; } - + read_request.is_get_firmware_version_request = false; // Clear read request flag return true; } @@ -3139,19 +3104,19 @@ unsigned char process_read_params(uint8_t response[]) { debug_printf("Building 0xB0 response data (SET_EX3D_CMD):\n"); response[0] = 0x77; // Sync header 1 response[1] = 0xB0; // Sync header 2 - + #if (USE_EX3D == 1) && (HID_CONTROLS == 1) // 构建hid_receive_task_in_c需要的输入格式 // RcvData格式: [0-3: 保留] [4开始: 32位对齐的数据] unsigned char rcv_data[64] = {0}; unsigned send_data[16] = {0}; // hid_receive_task_in_c的输出缓冲区 - + // 设置Report ID（hid_receive_task_in_c期望从RcvData[4]开始） rcv_data[0] = 0x01; // Report ID // 从RcvData[4]开始放置数据（即pRcvBuf[0]） unsigned *pRcvBuf = (unsigned *)(rcv_data + 4); pRcvBuf[0] = ex3d_request.ex3d_command_code; // EX3D命令码 - + // 复制参数（最多14个uint32） for (int i = 0; i < ex3d_request.ex3d_params_len / 4 && i < 14; i++) { pRcvBuf[i + 1] = (uint32_t)ex3d_request.ex3d_params[i * 4] | @@ -3159,25 +3124,25 @@ unsigned char process_read_params(uint8_t response[]) { ((uint32_t)ex3d_request.ex3d_params[i * 4 + 2] << 16) | ((uint32_t)ex3d_request.ex3d_params[i * 4 + 3] << 24); } - + // 调用EX3D命令处理函数 hid_receive_task_in_c(rcv_data, send_data); - + // 状态码：检查send_data[1]是否有错误返回值（0xFFFFFFFF表示参数错误） uint8_t status = 0x00; // 默认成功 if (send_data[1] == 0xFFFFFFFF) { status = 0x01; // 失败 debug_printf("EX3D command returned error (0xFFFFFFFF)\n"); } - + response[2] = status; - + // 回显命令码（4字节） response[3] = (uint8_t)(ex3d_request.ex3d_command_code & 0xFF); response[4] = (uint8_t)((ex3d_request.ex3d_command_code >> 8) & 0xFF); response[5] = (uint8_t)((ex3d_request.ex3d_command_code >> 16) & 0xFF); response[6] = (uint8_t)((ex3d_request.ex3d_command_code >> 24) & 0xFF); - + // 返回send_data中的返回值（如果有） if (send_data[1] != 0xFFFFFFFF) { // 某些SET命令可能返回数据，将send_data[1]开始的数据复制到响应 @@ -3192,7 +3157,7 @@ unsigned char process_read_params(uint8_t response[]) { response[9] = 0xFF; response[10] = 0xFF; } - + // 其余字节填充为0 for (int i = 11; i < 63; i++) { response[i] = 0x00; @@ -3204,7 +3169,7 @@ unsigned char process_read_params(uint8_t response[]) { response[i] = 0x00; } #endif - + ex3d_request.is_set_ex3d_cmd_request = false; // Clear request flag return true; } @@ -3215,18 +3180,18 @@ unsigned char process_read_params(uint8_t response[]) { debug_printf("Building 0xB1 response data (GET_EX3D_CMD):\n"); response[0] = 0x77; // Sync header 1 response[1] = 0xB1; // Sync header 2 - + #if (USE_EX3D == 1) && (HID_CONTROLS == 1) // 构建hid_receive_task_in_c需要的输入格式 unsigned char rcv_data[64] = {0}; unsigned send_data[16] = {0}; // hid_receive_task_in_c的输出缓冲区 - + // 设置Report ID rcv_data[0] = 0x01; // Report ID // 从RcvData[4]开始放置数据（即pRcvBuf[0]） unsigned *pRcvBuf = (unsigned *)(rcv_data + 4); pRcvBuf[0] = ex3d_request.ex3d_command_code; // EX3D命令码 - + // 复制参数（最多14个uint32） for (int i = 0; i < ex3d_request.ex3d_params_len / 4 && i < 14; i++) { pRcvBuf[i + 1] = (uint32_t)ex3d_request.ex3d_params[i * 4] | @@ -3234,16 +3199,16 @@ unsigned char process_read_params(uint8_t response[]) { ((uint32_t)ex3d_request.ex3d_params[i * 4 + 2] << 16) | ((uint32_t)ex3d_request.ex3d_params[i * 4 + 3] << 24); } - + // 调用EX3D命令处理函数 hid_receive_task_in_c(rcv_data, send_data); - + // 回显命令码（4字节） response[2] = (uint8_t)(ex3d_request.ex3d_command_code & 0xFF); response[3] = (uint8_t)((ex3d_request.ex3d_command_code >> 8) & 0xFF); response[4] = (uint8_t)((ex3d_request.ex3d_command_code >> 16) & 0xFF); response[5] = (uint8_t)((ex3d_request.ex3d_command_code >> 24) & 0xFF); - + // 复制返回值（从send_data[1]开始，最多14个uint32值） int response_idx = 6; for (int i = 1; i < 16 && response_idx < 63; i++) { @@ -3254,7 +3219,7 @@ unsigned char process_read_params(uint8_t response[]) { response[response_idx++] = (uint8_t)((send_data[i] >> 24) & 0xFF); } } - + // 其余字节填充为0 while (response_idx < 63) { response[response_idx++] = 0x00; @@ -3270,7 +3235,7 @@ unsigned char process_read_params(uint8_t response[]) { response[i] = 0x00; } #endif - + ex3d_request.is_get_ex3d_cmd_request = false; // Clear request flag return true; } @@ -3349,4 +3314,4 @@ unsigned char process_read_params(uint8_t response[]) { } #endif return false; -} \ No newline at end of file +} diff --git a/sw_usb_audio/app_usb_aud_phaten_golden/src/extensions/eq_flash_storage.c b/sw_usb_audio/app_usb_aud_phaten_golden/src/extensions/eq_flash_storage.c index a1ecf24..ee3b910 100644 --- a/sw_usb_audio/app_usb_aud_phaten_golden/src/extensions/eq_flash_storage.c +++ b/sw_usb_audio/app_usb_aud_phaten_golden/src/extensions/eq_flash_storage.c @@ -41,12 +41,8 @@ char *g_eq_flash_enable_file = "eq_enable"; // EQ使能开关文件名（独立 char *g_eq_flash_name_prefix = "name_"; // 模式名称文件前缀 // 外部EQ数组声明 +// 改动原因：进一步优化EQ参数存储策略，所有采样率共用44100Hz数组 extern eq_mode_data_t sEQ_data_44100HZ[NUM_EQ_MODES][NUM_EQ_CHANS]; -extern eq_mode_data_t sEQ_data_48000HZ[NUM_EQ_MODES][NUM_EQ_CHANS]; -extern eq_mode_data_t sEQ_data_88200HZ[NUM_EQ_MODES][NUM_EQ_CHANS]; -extern eq_mode_data_t sEQ_data_96000HZ[NUM_EQ_MODES][NUM_EQ_CHANS]; -extern eq_mode_data_t sEQ_data_176400HZ[NUM_EQ_MODES][NUM_EQ_CHANS]; -extern eq_mode_data_t sEQ_data_192000HZ[NUM_EQ_MODES][NUM_EQ_CHANS]; extern void debug_print_eq_mode(eq_mode_data_t *eq_data); extern unsigned int g_eq_sample_rate; @@ -93,22 +89,8 @@ static int get_sample_rate_index(uint32_t sample_rate) { * @return EQ数组指针，NULL表示不支持的采样率 */ static eq_mode_data_t (*get_eq_array_ptr(uint32_t sample_rate))[NUM_EQ_MODES][NUM_EQ_CHANS] { - switch (sample_rate) { - case 44100: - return &sEQ_data_44100HZ; - case 48000: - return &sEQ_data_48000HZ; - case 88200: - return &sEQ_data_88200HZ; - case 96000: - return &sEQ_data_96000HZ; - case 176400: - return &sEQ_data_176400HZ; - case 192000: - return &sEQ_data_192000HZ; - default: - return NULL; - } + // 改动原因：所有采样率共用44100Hz数组 + return &sEQ_data_44100HZ; } /** @@ -689,13 +671,15 @@ int eq_save_single_param(uint32_t sample_rate, uint8_t mode, uint8_t channel, ui snprintf(file_path, sizeof(file_path), "%s/mode%d_band%d.bin", g_eq_flash_base_dir, mode, band_index); - // 获取参数数据 - eq_mode_data_t (*eq_array)[NUM_EQ_MODES][NUM_EQ_CHANS] = get_eq_array_ptr(sample_rate); + // 改动原因：优化EQ参数存储策略，统一参数源为44100Hz + // 保存参数时，总是从44100Hz读取参数，确保参数一致性 + eq_mode_data_t (*eq_array)[NUM_EQ_MODES][NUM_EQ_CHANS] = get_eq_array_ptr(44100); if (!eq_array) { - DPRINTF(" Error: Failed to get EQ array for sample rate %u\n", sample_rate); + DPRINTF(" Error: Failed to get EQ array for sample rate 44100 (unified source)\n"); return -1; } + // 从44100Hz统一参数源读取参数 filter_params_t *param = &(*eq_array)[mode][channel].bands[band_index]; // 创建文件头 @@ -718,19 +702,10 @@ int eq_save_single_param(uint32_t sample_rate, uint8_t mode, uint8_t channel, ui DPRINTF(" Successfully saved single parameter to %s\n", file_path); - // 为所有采样率计算并应用系数 - for (int i = 0; i < EQ_FLASH_MAX_SAMPLE_RATES; i++) { - uint32_t fs = supported_sample_rates[i]; - if (fs != sample_rate) { // 避免重复处理当前采样率 - eq_mode_data_t (*target_array)[NUM_EQ_MODES][NUM_EQ_CHANS] = get_eq_array_ptr(fs); - if (target_array) { - // 复制参数到目标采样率 - (*target_array)[mode][channel].bands[band_index] = *param; - // 这里可以添加系数计算逻辑 - //DPRINTF(" Applied parameter to sample rate %u\n", fs); - } - } - } + // 改动原因：优化EQ参数存储策略，参数保存后需要同步到44100Hz并更新所有采样率 + // 确保44100Hz作为统一参数源，然后通过copy_params_from_44100函数同步到其他采样率 + // 注意：这里只保存参数，系数会在切换采样率时动态计算 + // 参数已经保存到Flash，加载时会自动应用到所有采样率 return 0; } @@ -1797,30 +1772,8 @@ int delete_flash_gain_and_names(uint8_t mode) { void restore_mode_default_params(uint8_t mode, uint32_t sample_rate) { if (mode >= NUM_EQ_MODES) return; - // 选择对应的EQ数据数组 - eq_mode_data_t (*eq_array)[NUM_EQ_MODES][NUM_EQ_CHANS] = NULL; - switch (sample_rate) { - case 44100: - eq_array = &sEQ_data_44100HZ; - break; - case 48000: - eq_array = &sEQ_data_48000HZ; - break; - case 88200: - eq_array = &sEQ_data_88200HZ; - break; - case 96000: - eq_array = &sEQ_data_96000HZ; - break; - case 176400: - eq_array = &sEQ_data_176400HZ; - break; - case 192000: - eq_array = &sEQ_data_192000HZ; - break; - default: - return; - } + // 改动原因：所有采样率共用44100Hz数组 + eq_mode_data_t (*eq_array)[NUM_EQ_MODES][NUM_EQ_CHANS] = &sEQ_data_44100HZ; if (eq_array == NULL) return; @@ -1865,26 +1818,17 @@ void restore_mode_default_params(uint8_t mode, uint32_t sample_rate) { int restore_default_eq_params(uint8_t mode) { DPRINTF("Restoring default EQ params for mode %d\n", mode); - // 获取所有支持的采样率 - const uint32_t supported_sample_rates[] = {44100, 48000, 88200, 96000, 176400, 192000}; - int num_rates = sizeof(supported_sample_rates) / sizeof(supported_sample_rates[0]); - + // 改动原因：所有采样率共用44100Hz数组，只需要恢复44100Hz数组 if (mode == 0xFF) { // 恢复所有模式的默认参数 DPRINTF(" Restoring all modes to default parameters\n"); for (uint8_t m = 0; m < NUM_EQ_MODES; m++) { - for (int rate_idx = 0; rate_idx < num_rates; rate_idx++) { - uint32_t fs = supported_sample_rates[rate_idx]; - restore_mode_default_params(m, fs); - } + restore_mode_default_params(m, 44100); // 恢复44100Hz数组 } } else { // 恢复指定模式的默认参数 DPRINTF(" Restoring mode %d to default parameters\n", mode); - for (int rate_idx = 0; rate_idx < num_rates; rate_idx++) { - uint32_t fs = supported_sample_rates[rate_idx]; - restore_mode_default_params(mode, fs); - } + restore_mode_default_params(mode, 44100); // 恢复44100Hz数组 } DPRINTF(" Default parameters restored successfully\n"); diff --git a/sw_usb_audio/app_usb_aud_phaten_golden/src/extensions/user_uart.h b/sw_usb_audio/app_usb_aud_phaten_golden/src/extensions/user_uart.h index 5ba7208..ab5ae50 100644 --- a/sw_usb_audio/app_usb_aud_phaten_golden/src/extensions/user_uart.h +++ b/sw_usb_audio/app_usb_aud_phaten_golden/src/extensions/user_uart.h @@ -140,6 +140,36 @@ typedef enum { TEST_CMD = 0xF0, FW_VERSION = 0xF1, FLASH_ID = 0xF2, + // EQ命令定义 (0x40-0x5C) + SET_EQ_MODE = 0x40, // 切换EQ模式 + GET_EQ_MODE = 0x41, // 获取当前EQ模式信息 + SET_MODE_GAIN_AND_NAME = 0x42, // 设置模式整体增益和名称 + SET_EQ_PARAMS = 0x43, // 发送EQ参数 + GET_EQ_PARAMS = 0x44, // 读取EQ参数 + GET_DEVICE_INFO = 0x45, // 获取设备信息 + RESET_EQ_PARAMS = 0x46, // 复位EQ参数 + GET_EQ_MODE_COUNT = 0x47, // 获取EQ模式总数 + SET_AND_SAVE_EQ_MODE = 0x48, // 设置并保存EQ模式 + SET_VOLUME = 0x49, // 设置音量级别 + GET_VOLUME = 0x4A, // 获取音量级别 + GET_LED_INFO = 0x4B, // 获取LED信息 + SET_LED_SWITCH = 0x4C, // 设置LED开关 + GET_LED_SWITCH = 0x4D, // 获取LED开关 + GET_LED_STATUS = 0x4E, // 获取LED状态 + GET_LED_COUNT = 0x4F, // 获取LED总数 + GET_UAC_MODE_INFO = 0x50, // 获取UAC模式信息 + SET_UAC_MODE = 0x51, // 设置UAC模式 + GET_CURRENT_UAC_MODE = 0x52, // 获取当前UAC模式 + SET_EQ_ENABLE = 0x53, // 设置EQ使能开关 + GET_EQ_ENABLE = 0x54, // 获取EQ使能开关 + GET_SAMPLE_FORMAT = 0x55, // 获取采样率和格式 + SET_GAIN_MODE = 0x56, // 设置增益模式 + GET_GAIN_MODE = 0x57, // 获取增益模式 + SET_FILTER_MODE = 0x58, // 设置滤波器模式 + GET_FILTER_MODE = 0x59, // 获取滤波器模式 + SET_GAME_MODE = 0x5A, // 设置游戏模式 + GET_GAME_MODE = 0x5B, // 获取游戏模式 + GET_FIRMWARE_VERSION = 0x5C, // 获取固件版本 CMD_NONE = 0xFF } UartCmdType;