ESP32-S3开发问题排查指南

# 错误信息示例
ERROR: Failed to install esp-idf
Could not install packages due to an OSError

# 1. 检查Python版本 (需要3.8+)
python --version

# 2. 清理已下载的组件
rm -rf ~/.espressif

# 3. 重新安装ESP-IDF
git clone -b v5.3.2 --recursive https://github.com/espressif/esp-idf.git
cd esp-idf
./install.sh esp32,esp32s3

# 4. 设置环境变量
. ./export.sh

# 错误信息
idf.py: command not found

# 1. 确认ESP-IDF环境已导入
echo $IDF_PATH
# 应该显示ESP-IDF安装路径

# 2. 重新导入环境变量
cd /path/to/esp-idf
. ./export.sh

# 3. 验证工具链
idf.py --version

# 错误信息
Permission denied: '/dev/ttyUSB0'

# 1. 添加用户到dialout组
sudo usermod -a -G dialout $USER

# 2. 重新登录或重启终端

# 3. 或者临时修改权限
sudo chmod 666 /dev/ttyUSB0

# 现象: 编译时间超过10分钟

# 1. 关闭杀毒软件实时防护
# 2. 使用并行编译
idf.py build -j8  # 8线程并行

# 3. 使用RAM盘 (Windows)
# 将项目放到RAM盘可显著提升编译速度

# 4. 清理build目录
rm -rf build
idf.py build

# 错误信息
UnicodeDecodeError: 'gbk' codec can't decode

# 1. 项目路径不要包含中文字符
# 错误: C:\用户\小智项目\xiaozhi-esp32
# 正确: C:\Users\xiaozhi\xiaozhi-esp32

# 2. 设置环境变量 (Windows)
set PYTHONIOENCODING=utf-8

# 3. 使用英文用户名和路径

# 错误信息
A fatal error occurred: Could not open port

# 1. 检查设备管理器中是否有未知设备
# Windows: 设备管理器 -> 端口(COM和LPT)
# Linux: ls /dev/ttyUSB* 或 ls /dev/ttyACM*
# macOS: ls /dev/cu.*

# 2. 安装USB转串口驱动
# CP210x: https://www.silabs.com/developers/usb-to-uart-bridge-vcp-drivers
# CH340: http://www.wch.cn/downloads/CH341SER_EXE.html

# 3. 检查USB线缆
# 确保使用数据线而非仅充电线

# 1. 安装正确驱动程序
# 2. 尝试不同USB端口
# 3. 检查开发板上的USB接口

# 4. 手动指定串口
idf.py -p COM3 flash  # Windows
idf.py -p /dev/ttyUSB0 flash  # Linux

# 错误信息
A fatal error occurred: Failed to connect to ESP32

# 1. 手动进入下载模式
# 按住Boot按钮 -> 按下Reset按钮 -> 松开Reset -> 松开Boot

# 2. 检查引脚连接
# 确保GPIO0在复位时为低电平

# 3. 使用工具协助
idf.py --chip esp32s3 --before default_reset --after hard_reset flash

# 4. 检查电源供电
# 确保开发板有足够的电源供应

# 现象: I2S读取数据全为0或噪音

# 1. 检查硬件连接
GPIO4  -> INMP441 WS
GPIO5  -> INMP441 SCK  
GPIO6  -> INMP441 SD
3.3V   -> INMP441 VDD
GND    -> INMP441 GND + L/R

# 2. 测试I2S数据读取
void test_i2s_microphone() {
    int32_t buffer[1024];
    size_t bytes_read;
    
    i2s_read(I2S_NUM_0, buffer, sizeof(buffer), &bytes_read, 1000);
    
    ESP_LOGI("I2S_TEST", "读取字节: %d", bytes_read);
    for(int i = 0; i < 10; i++) {
        ESP_LOGI("I2S_TEST", "采样%d: %d", i, buffer[i]);
    }
}

# 3. 检查INMP441方向
# 麦克风收音孔应该朝上，排针朝下

// 1. 确认I2S配置正确
i2s_config_t i2s_config = {
    .mode = I2S_MODE_MASTER | I2S_MODE_RX,
    .sample_rate = 16000,
    .bits_per_sample = I2S_BITS_PER_SAMPLE_32BIT,  // INMP441需要32位
    .channel_format = I2S_CHANNEL_FMT_ONLY_LEFT,   // 单声道
    .communication_format = I2S_COMM_FORMAT_STAND_I2S,
    .intr_alloc_flags = ESP_INTR_FLAG_LEVEL2,
    .dma_buf_count = 8,
    .dma_buf_len = 1024,
};

// 2. 检查引脚配置
i2s_pin_config_t pin_config = {
    .ws_io_num = GPIO_NUM_4,      // WS引脚
    .ck_io_num = GPIO_NUM_5,      // SCK引脚  
    .data_in_num = GPIO_NUM_6,    // SD引脚
    .data_out_num = I2S_PIN_NO_CHANGE
};

# 现象: MAX98357A无声音输出或声音异常

# 1. 检查MAX98357A连接
GPIO7  -> MAX98357A DIN
GPIO15 -> MAX98357A BCLK
GPIO16 -> MAX98357A LRC
3.3V   -> MAX98357A VIN + SD
GND    -> MAX98357A GND + GAIN

# 2. 检查喇叭连接
# 音频+ -> 喇叭正极 (红线)
# 音频- -> 喇叭负极 (黑线)

# 3. 测试音频输出
void test_i2s_speaker() {
    int16_t sine_wave[480];  // 30ms@16kHz
    
    // 生成1kHz正弦波
    for(int i = 0; i < 480; i++) {
        sine_wave[i] = 16000 * sin(2 * M_PI * 1000 * i / 16000);
    }
    
    size_t bytes_written;
    i2s_write(I2S_NUM_1, sine_wave, sizeof(sine_wave), &bytes_written, 1000);
}

// 1. 确认I2S输出配置
i2s_config_t speaker_config = {
    .mode = I2S_MODE_MASTER | I2S_MODE_TX,
    .sample_rate = 16000,
    .bits_per_sample = I2S_BITS_PER_SAMPLE_16BIT,
    .channel_format = I2S_CHANNEL_FMT_RIGHT_LEFT,  // 立体声
    .communication_format = I2S_COMM_FORMAT_STAND_I2S,
    .intr_alloc_flags = ESP_INTR_FLAG_LEVEL2,
    .dma_buf_count = 8,
    .dma_buf_len = 1024,
};

// 2. 检查SD引脚连接
// SD必须连接到3.3V或悬空，不能接地

# 现象: SSD1306显示屏黑屏或花屏

# 1. 检查I2C连接
GPIO41 -> SSD1306 SDA
GPIO42 -> SSD1306 SCL
3.3V   -> SSD1306 VCC
GND    -> SSD1306 GND

# 2. 扫描I2C设备地址
void i2c_scanner() {
    for (uint8_t addr = 1; addr < 127; addr++) {
        i2c_cmd_handle_t cmd = i2c_cmd_link_create();
        i2c_master_start(cmd);
        i2c_master_write_byte(cmd, (addr << 1) | I2C_MASTER_WRITE, true);
        i2c_master_stop(cmd);
        
        esp_err_t ret = i2c_master_cmd_begin(I2C_NUM_0, cmd, 100);
        i2c_cmd_link_delete(cmd);
        
        if (ret == ESP_OK) {
            ESP_LOGI("I2C", "找到设备地址: 0x%02X", addr);
        }
    }
}

// 1. 检查OLED显示屏型号和地址
#define SSD1306_ADDR_1  0x3C  // 常见地址1
#define SSD1306_ADDR_2  0x3D  // 常见地址2

// 2. 确认引脚顺序 (新版OLED为GND开头)
// 新版: GND VCC SCL SDA
// 旧版: VCC GND SCL SDA

// 3. 初始化序列
void ssd1306_init() {
    ssd1306_write_command(0xAE);  // Display OFF
    ssd1306_write_command(0x20);  // Set Memory Addressing Mode
    ssd1306_write_command(0x00);  // Horizontal Addressing Mode
    ssd1306_write_command(0xB0);  // Set Page Start Address
    ssd1306_write_command(0xC8);  // Set COM Output Scan Direction
    ssd1306_write_command(0x00);  // Set Low Column Start Address
    ssd1306_write_command(0x10);  // Set High Column Start Address
    ssd1306_write_command(0x40);  // Set Display Start Line
    ssd1306_write_command(0x81);  // Set Contrast Control
    ssd1306_write_command(0xFF);  // Maximum contrast
    ssd1306_write_command(0xA1);  // Set Segment Re-map
    ssd1306_write_command(0xA6);  // Set Normal Display
    ssd1306_write_command(0xA8);  // Set Multiplex Ratio
    ssd1306_write_command(0x3F);  // 1/64 duty
    ssd1306_write_command(0xA4);  // Resume to RAM content display
    ssd1306_write_command(0xD3);  // Set Display Offset
    ssd1306_write_command(0x00);  // No offset
    ssd1306_write_command(0xD5);  // Set Display Clock Divide Ratio
    ssd1306_write_command(0xF0);  // Suggest ratio 0xF0
    ssd1306_write_command(0xD9);  // Set Pre-charge Period
    ssd1306_write_command(0x22);  // 
    ssd1306_write_command(0xDA);  // Set COM Pins Configuration
    ssd1306_write_command(0x12);  // 
    ssd1306_write_command(0xDB);  // Set VCOMH Deselect Level
    ssd1306_write_command(0x20);  // 0.77*Vcc
    ssd1306_write_command(0x8D);  // Charge Pump Setting
    ssd1306_write_command(0x14);  // Enable charge pump
    ssd1306_write_command(0xAF);  // Display ON
}

# 错误信息
***ERROR*** A stack overflow in task AudioTask has been detected.

// 1. 增加任务栈大小
xTaskCreatePinnedToCore(
    audio_task,
    "AudioTask", 
    8192,        // 增加栈大小 (字节)
    NULL,
    5,
    NULL,
    1
);

// 2. 检查局部变量大小
void problematic_function() {
    // 问题：大数组分配在栈上
    // int16_t audio_buffer[16384];  // 32KB！
    
    // 解决：使用动态分配
    int16_t* audio_buffer = (int16_t*)malloc(16384 * sizeof(int16_t));
    if (audio_buffer) {
        // 使用buffer...
        free(audio_buffer);
    }
}

// 3. 监控栈使用情况
void monitor_stack_usage() {
    UBaseType_t high_water_mark = uxTaskGetStackHighWaterMark(NULL);
    ESP_LOGI("STACK", "剩余栈空间: %d bytes", high_water_mark * 4);
}

# 现象: 可用内存持续减少

// 1. 监控内存使用
void monitor_memory() {
    size_t free_heap = esp_get_free_heap_size();
    size_t min_free = esp_get_minimum_free_heap_size();
    
    ESP_LOGI("MEMORY", "当前空闲: %d bytes, 最低: %d bytes", free_heap, min_free);
}

// 2. 检查动态内存分配
void* safe_malloc(size_t size) {
    void* ptr = malloc(size);
    if (ptr) {
        ESP_LOGD("MALLOC", "分配 %d bytes at %p", size, ptr);
    } else {
        ESP_LOGE("MALLOC", "分配 %d bytes 失败", size);
    }
    return ptr;
}

void safe_free(void* ptr) {
    if (ptr) {
        ESP_LOGD("MALLOC", "释放内存 %p", ptr);
        free(ptr);
    }
}

// 3. 使用内存检查工具
#ifdef CONFIG_HEAP_TRACING
    heap_trace_init_standalone(trace_records, NUM_RECORDS);
    heap_trace_start(HEAP_TRACE_LEAKS);
    
    // 运行一段时间后
    heap_trace_stop();
    heap_trace_dump();
#endif

# 错误信息
I (2345) wifi:AP's beacon interval = 102400 us, DTIM period = 1
E (12345) wifi: sta connect failed

// 1. 检查Wi-Fi配置
void wifi_debug_info() {
    wifi_ap_record_t ap_info;
    esp_wifi_sta_get_ap_info(&ap_info);
    
    ESP_LOGI("WIFI", "连接AP: %s", ap_info.ssid);
    ESP_LOGI("WIFI", "信号强度: %d dBm", ap_info.rssi);
    ESP_LOGI("WIFI", "频道: %d", ap_info.primary);
    ESP_LOGI("WIFI", "加密类型: %d", ap_info.authmode);
}

// 2. 增加连接重试
static int wifi_retry_count = 0;
#define MAX_WIFI_RETRY 10

static void wifi_event_handler(void* arg, esp_event_base_t event_base,
                              int32_t event_id, void* event_data) {
    if (event_base == WIFI_EVENT && event_id == WIFI_EVENT_STA_DISCONNECTED) {
        if (wifi_retry_count < MAX_WIFI_RETRY) {
            esp_wifi_connect();
            wifi_retry_count++;
            ESP_LOGI("WIFI", "重试连接 %d/%d", wifi_retry_count, MAX_WIFI_RETRY);
        } else {
            ESP_LOGE("WIFI", "Wi-Fi连接失败");
        }
    }
}

// 3. 检查密码和加密方式
wifi_config_t wifi_config = {
    .sta = {
        .ssid = "Your_SSID",
        .password = "Your_Password",
        .threshold.authmode = WIFI_AUTH_WPA2_PSK,  // 指定加密方式
    },
};

# 现象: WebSocket频繁断线重连

// 1. 实现心跳机制
void websocket_keepalive_task(void* parameter) {
    while(1) {
        if (websocket_connected) {
            esp_websocket_client_send_text(client, "{\"type\":\"ping\"}", 
                                          16, portMAX_DELAY);
        }
        vTaskDelay(pdMS_TO_TICKS(30000));  // 30秒心跳
    }
}

// 2. 处理网络错误
static void websocket_event_handler(void *handler_args, esp_event_base_t base,
                                   int32_t event_id, void *event_data) {
    switch (event_id) {
        case WEBSOCKET_EVENT_ERROR:
            ESP_LOGE("WS", "WebSocket错误，尝试重连...");
            // 延迟重连
            vTaskDelay(pdMS_TO_TICKS(5000));
            esp_websocket_client_start(client);
            break;
            
        case WEBSOCKET_EVENT_DISCONNECTED:
            ESP_LOGW("WS", "WebSocket断开连接");
            websocket_connected = false;
            break;
    }
}

// 3. 检查网络稳定性
void network_quality_monitor() {
    // 检查Wi-Fi信号强度
    wifi_ap_record_t ap_info;
    if (esp_wifi_sta_get_ap_info(&ap_info) == ESP_OK) {
        if (ap_info.rssi < -70) {
            ESP_LOGW("NETWORK", "Wi-Fi信号弱: %d dBm", ap_info.rssi);
        }
    }
    
    // 检查可用内存
    size_t free_heap = esp_get_free_heap_size();
    if (free_heap < 50000) {  // 50KB
        ESP_LOGW("NETWORK", "内存不足: %d bytes", free_heap);
    }
}

# 现象: 识别出很多乱码或者错误的语言

// 1. 检查音频质量
void analyze_audio_quality(int16_t* audio_data, size_t samples) {
    // 计算音频能量
    float energy = 0;
    for (size_t i = 0; i < samples; i++) {
        energy += audio_data[i] * audio_data[i];
    }
    energy = sqrt(energy / samples);
    
    ESP_LOGI("AUDIO", "音频能量: %.2f", energy);
    
    // 检查是否有有效语音
    if (energy < 100) {
        ESP_LOGW("AUDIO", "音频能量过低，可能为环境噪音");
    } else if (energy > 10000) {
        ESP_LOGW("AUDIO", "音频能量过高，可能有削波失真");
    }
}

// 2. 音频预处理
void preprocess_audio(int16_t* audio_data, size_t samples) {
    // 去除直流分量
    float dc_offset = 0;
    for (size_t i = 0; i < samples; i++) {
        dc_offset += audio_data[i];
    }
    dc_offset /= samples;
    
    for (size_t i = 0; i < samples; i++) {
        audio_data[i] -= (int16_t)dc_offset;
    }
    
    // 简单的噪音门
    const int16_t noise_gate = 200;
    for (size_t i = 0; i < samples; i++) {
        if (abs(audio_data[i]) < noise_gate) {
            audio_data[i] = 0;
        }
    }
}

// 3. 检查采样率设置
void verify_sample_rate() {
    i2s_config_t config;
    ESP_ERROR_CHECK(i2s_get_clk(I2S_NUM_0, &config));
    
    ESP_LOGI("AUDIO", "当前采样率: %d Hz", config.sample_rate);
    
    // 确保与语音识别服务要求一致(通常16kHz)
    if (config.sample_rate != 16000) {
        ESP_LOGW("AUDIO", "采样率不匹配，建议使用16kHz");
    }
}

# 现象: 说唤醒词多次才能唤醒，或者完全不响应

// 1. 调整唤醒灵敏度
void configure_wake_word_sensitivity() {
    // 通过menuconfig配置
    // Component config -> ESP Speech Recognition -> Wake Word Engine
    // 调整 Detection Threshold (0.0-1.0，越小越敏感)
    
    ESP_LOGI("WAKE", "当前唤醒阈值: %.2f", CONFIG_SR_WN_WakeNet_THRESHOLD);
}

// 2. 检查麦克风摆放
void microphone_placement_tips() {
    ESP_LOGI("TIPS", "麦克风使用建议:");
    ESP_LOGI("TIPS", "1. 确保收音孔朝上，远离扬声器");
    ESP_LOGI("TIPS", "2. 避免遮挡麦克风");
    ESP_LOGI("TIPS", "3. 在安静环境下训练唤醒词");
    ESP_LOGI("TIPS", "4. 说话音量适中，距离20-50cm");
}

// 3. 音频增益调整
void adjust_microphone_gain(float gain) {
    // gain: 0.1 - 5.0
    static float current_gain = 1.0;
    current_gain = gain;
    
    ESP_LOGI("AUDIO", "麦克风增益调整为: %.1fx", gain);
}

void apply_gain_to_audio(int16_t* audio_data, size_t samples, float gain) {
    for (size_t i = 0; i < samples; i++) {
        int32_t amplified = (int32_t)(audio_data[i] * gain);
        
        // 防止溢出
        if (amplified > 32767) amplified = 32767;
        if (amplified < -32768) amplified = -32768;
        
        audio_data[i] = (int16_t)amplified;
    }
}

# 现象: 从说话到回复需要5秒以上

// 1. 音频缓冲优化
#define AUDIO_BUFFER_SIZE 1024  // 减小缓冲区提高实时性
#define DMA_BUFFER_COUNT  4     // 减少DMA缓冲区数量

// 2. 并行处理
typedef struct {
    int16_t* audio_data;
    size_t samples;
    uint32_t timestamp;
} audio_frame_t;

QueueHandle_t audio_queue;

void audio_capture_task(void* parameter) {
    audio_frame_t frame;
    
    while(1) {
        frame.audio_data = malloc(AUDIO_BUFFER_SIZE * sizeof(int16_t));
        frame.samples = read_microphone_data(frame.audio_data, AUDIO_BUFFER_SIZE);
        frame.timestamp = esp_timer_get_time();
        
        // 非阻塞发送到处理队列
        if (xQueueSend(audio_queue, &frame, 0) != pdTRUE) {
            ESP_LOGW("AUDIO", "音频队列满，丢弃帧");
            free(frame.audio_data);
        }
    }
}

void audio_process_task(void* parameter) {
    audio_frame_t frame;
    
    while(1) {
        if (xQueueReceive(audio_queue, &frame, portMAX_DELAY)) {
            uint32_t process_start = esp_timer_get_time();
            
            // 语音处理
            process_audio_frame(&frame);
            
            uint32_t process_time = esp_timer_get_time() - process_start;
            ESP_LOGI("PERF", "音频处理耗时: %d ms", process_time / 1000);
            
            free(frame.audio_data);
        }
    }
}

// 3. 网络请求优化
esp_err_t http_post_with_timeout(const char* url, const char* data, 
                                char* response, size_t response_size, 
                                int timeout_ms) {
    esp_http_client_config_t config = {
        .url = url,
        .method = HTTP_METHOD_POST,
        .timeout_ms = timeout_ms,  // 设置超时时间
        .disable_auto_redirect = true,
    };
    
    esp_http_client_handle_t client = esp_http_client_init(&config);
    
    // 设置Keep-Alive
    esp_http_client_set_header(client, "Connection", "keep-alive");
    
    esp_err_t err = esp_http_client_perform(client);
    esp_http_client_cleanup(client);
    
    return err;
}

# 现象: 可用内存低于50KB

// 1. 音频缓冲区池化
#define AUDIO_POOL_SIZE 8
static int16_t* audio_buffer_pool[AUDIO_POOL_SIZE];
static bool buffer_in_use[AUDIO_POOL_SIZE];
static SemaphoreHandle_t pool_mutex;

void init_audio_buffer_pool() {
    pool_mutex = xSemaphoreCreateMutex();
    
    for (int i = 0; i < AUDIO_POOL_SIZE; i++) {
        audio_buffer_pool[i] = malloc(AUDIO_BUFFER_SIZE * sizeof(int16_t));
        buffer_in_use[i] = false;
    }
}

int16_t* get_audio_buffer() {
    xSemaphoreTake(pool_mutex, portMAX_DELAY);
    
    for (int i = 0; i < AUDIO_POOL_SIZE; i++) {
        if (!buffer_in_use[i]) {
            buffer_in_use[i] = true;
            xSemaphoreGive(pool_mutex);
            return audio_buffer_pool[i];
        }
    }
    
    xSemaphoreGive(pool_mutex);
    ESP_LOGW("POOL", "音频缓冲区池已满");
    return NULL;
}

void return_audio_buffer(int16_t* buffer) {
    xSemaphoreTake(pool_mutex, portMAX_DELAY);
    
    for (int i = 0; i < AUDIO_POOL_SIZE; i++) {
        if (audio_buffer_pool[i] == buffer) {
            buffer_in_use[i] = false;
            break;
        }
    }
    
    xSemaphoreGive(pool_mutex);
}

// 2. 配置优化
void optimize_memory_config() {
    // 通过menuconfig优化内存分配
    ESP_LOGI("CONFIG", "PSRAM支持: %s", 
            CONFIG_SPIRAM_SUPPORT ? "启用" : "禁用");
    ESP_LOGI("CONFIG", "WiFi动态缓冲区: %d", 
            CONFIG_ESP32_WIFI_DYNAMIC_RX_BUFFER_NUM);
    ESP_LOGI("CONFIG", "蓝牙内存模式: %s",
            CONFIG_BTDM_CTRL_MODE_BTDM ? "BT+BLE" : "仅BLE");
}

// 3. 垃圾回收
void manual_garbage_collection() {
    // 强制释放TCP/IP栈缓冲区
    esp_netif_dhcpc_stop(esp_netif_get_handle_from_ifkey("WIFI_STA_DEF"));
    vTaskDelay(pdMS_TO_TICKS(100));
    esp_netif_dhcpc_start(esp_netif_get_handle_from_ifkey("WIFI_STA_DEF"));
    
    // 强制WiFi垃圾回收
    esp_wifi_clear_ap_list();
    
    ESP_LOGI("GC", "垃圾回收完成");
}

// 1. 分级日志系统
typedef enum {
    LOG_LEVEL_ERROR = 0,
    LOG_LEVEL_WARN,
    LOG_LEVEL_INFO,
    LOG_LEVEL_DEBUG,
    LOG_LEVEL_VERBOSE
} log_level_t;

void set_component_log_level(const char* component, log_level_t level) {
    esp_log_level_t esp_level;
    
    switch(level) {
        case LOG_LEVEL_ERROR:   esp_level = ESP_LOG_ERROR; break;
        case LOG_LEVEL_WARN:    esp_level = ESP_LOG_WARN; break;
        case LOG_LEVEL_INFO:    esp_level = ESP_LOG_INFO; break;
        case LOG_LEVEL_DEBUG:   esp_level = ESP_LOG_DEBUG; break;
        case LOG_LEVEL_VERBOSE: esp_level = ESP_LOG_VERBOSE; break;
        default: esp_level = ESP_LOG_INFO;
    }
    
    esp_log_level_set(component, esp_level);
}

// 2. 性能分析日志
#define PERF_LOG_START(tag) \
    uint64_t _perf_start_##tag = esp_timer_get_time()

#define PERF_LOG_END(tag, description) \
    do { \
        uint64_t _perf_time = esp_timer_get_time() - _perf_start_##tag; \
        ESP_LOGI("PERF", "%s: %lld μs", description, _perf_time); \
    } while(0)

// 使用示例
void example_function() {
    PERF_LOG_START(audio_process);
    
    // 音频处理代码
    process_audio();
    
    PERF_LOG_END(audio_process, "音频处理");
}

// 3. 内存使用跟踪
void log_memory_status(const char* location) {
    size_t free_heap = esp_get_free_heap_size();
    size_t free_internal = heap_caps_get_free_size(MALLOC_CAP_INTERNAL);
    size_t free_psram = heap_caps_get_free_size(MALLOC_CAP_SPIRAM);
    
    ESP_LOGI("MEMORY", "[%s] 堆内存: %d, 内部: %d, PSRAM: %d", 
            location, free_heap, free_internal, free_psram);
}

// 1. GPIO状态检测
void debug_gpio_states() {
    ESP_LOGI("GPIO", "关键引脚状态:");
    ESP_LOGI("GPIO", "GPIO4(MIC_WS): %d", gpio_get_level(GPIO_NUM_4));
    ESP_LOGI("GPIO", "GPIO5(MIC_SCK): %d", gpio_get_level(GPIO_NUM_5));
    ESP_LOGI("GPIO", "GPIO6(MIC_SD): %d", gpio_get_level(GPIO_NUM_6));
    ESP_LOGI("GPIO", "GPIO7(SPK_DIN): %d", gpio_get_level(GPIO_NUM_7));
    ESP_LOGI("GPIO", "GPIO0(BOOT): %d", gpio_get_level(GPIO_NUM_0));
}

// 2. I2S状态检测
void debug_i2s_status() {
    // 检查I2S时钟
    uint32_t sample_rate;
    i2s_get_clk(I2S_NUM_0, &sample_rate);
    ESP_LOGI("I2S", "麦克风采样率: %d Hz", sample_rate);
    
    i2s_get_clk(I2S_NUM_1, &sample_rate);
    ESP_LOGI("I2S", "扬声器采样率: %d Hz", sample_rate);
}

// 3. 电源监测
void monitor_power_supply() {
    // 读取内部电压参考
    adc1_config_width(ADC_WIDTH_BIT_12);
    adc1_config_channel_atten(ADC1_CHANNEL_0, ADC_ATTEN_DB_11);
    
    int raw_value = adc1_get_raw(ADC1_CHANNEL_0);
    float voltage = (raw_value * 3.3) / 4095.0;
    
    ESP_LOGI("POWER", "电源电压: %.2fV (ADC: %d)", voltage, raw_value);
    
    if (voltage < 3.0) {
        ESP_LOGW("POWER", "电源电压偏低，可能影响稳定性");
    }
}