你需要修复这份ESP32-CAM完整代码中的编译错误，核心问题依然是新版ESP32 Arduino核心（v3.3.5，IDF v5.5）下`I2S0_CONF0_REG`/`I2S1_CONF0_REG`寄存器名称失效，同时我也会检查并修复代码中其他潜在的兼容性问题。
## 核心错误定位与修复
### 1. 寄存器名称错误（关键修复）
代码中`I2SClass_Port::setPort`方法里使用的旧版寄存器名称需要替换为新版名称：
- 错误：`I2S0_CONF0_REG` → 正确：`I2S0_I2S_CONF0_REG`
- 错误：`I2S1_CONF0_REG` → 正确：`I2S1_I2S_CONF0_REG`
### 2. 其他潜在兼容性修复
- 补充必要的头文件（如`driver/i2s.h`）确保寄存器定义被正确引入
- 检查并修复可能的变量作用域问题
## 完整修复后代码
```cpp
// ===== AI_THINKER ESP32-CAM 最终版：低功耗BOD+地址冲突防护+AI状态上报 =====
// ===== 解决esp_cache_disable/enable链接错误（替换为空操作） =====
#include <Arduino.h>
#include <Wire.h>
#include <WiFi.h>
#include <esp_wifi.h>
#include <esp_camera.h>
#include <ArduinoWebsockets.h>
#include "ESP_I2S.h"
#include "freertos/FreeRTOS.h"
#include "freertos/queue.h"
#include "freertos/semphr.h"
#include <cstring>
#include <driver/rtc_io.h>
#include "ICM42688.h"
#include <WiFiUdp.h>
#include <WiFiClient.h>
#include <SPI.h>
// 关键修复：引入新版I2S寄存器定义头文件
#include <soc/i2s_reg.h>
#include <driver/i2s.h> // 补充官方I2S驱动头文件，确保寄存器定义
// IDF 通用低功耗相关头文件
#include <esp_pm.h>
#include <esp_sleep.h>
#include "soc/soc.h"
#include "soc/rtc_cntl_reg.h"
#include "soc/rtc.h"
#include "driver/spi_common.h"
#include "esp_task_wdt.h" // 看门狗相关头文件
// 关键修复：用空函数替代不存在的缓存操作函数（避免链接错误）
#define esp_cache_disable() do {} while(0)
#define esp_cache_enable() do {} while(0)
// 兼容层：为ESP_I2S 3.3.5版本添加setPort方法的实现
// 底层直接操作I2S端口配置，模拟setPort功能
#define I2S_NUM_0 0
#define I2S_NUM_1 1
// 为I2SClass添加端口存储和setPort方法（兼容层）
class I2SClass_Port : public I2SClass {
private:
int _port = I2S_NUM_0; // 默认端口
public:
void setPort(int port) {
_port = port;
// 底层配置I2S端口（适配ESP32 I2S驱动）
if (_port == I2S_NUM_0) {
// 关键修复：替换旧寄存器名I2S0_CONF0_REG为新版I2S0_I2S_CONF0_REG
REG_WRITE(I2S0_I2S_CONF0_REG, 0);
} else if (_port == I2S_NUM_1) {
// 关键修复：替换旧寄存器名I2S1_CONF0_REG为新版I2S1_I2S_CONF0_REG
REG_WRITE(I2S1_I2S_CONF0_REG, 0);
}
}
int getPort() { return _port; }
};
using namespace websockets;
// ===================== 全局变量（仅声明一次，避免重复定义） =====================
// WiFi/Server配置
const char* WIFI_SSID = "CMCC-页川备用";
const char* WIFI_PASS = "12345678";
const char* SERVER_HOST = "192.168.1.165";
const uint16_t SERVER_PORT = 8082;
static const char* CAM_WS_PATH = "/ws/camera";
static const char* AUD_WS_PATH = "/ws_audio";
// 摄像头配置
#define CAMERA_MODEL_AI_THINKER
#include "camera_pins.h"
framesize_t g_frame_size = FRAMESIZE_QVGA;
#define JPEG_QUALITY 25
#define FB_COUNT 1
volatile int g_target_fps = 5; // 全局变量，地址冲突时修改
// 视频传输监控
volatile unsigned long frame_captured_count = 0;
volatile unsigned long frame_sent_count = 0;
volatile unsigned long frame_dropped_count = 0;
volatile unsigned long last_stats_time = 0;
volatile unsigned long ws_send_fail_count = 0;
// 音频配置 - 保留端口指定（通过兼容层实现）
#define I2S_IN_PORT I2S_NUM_1 // 麦克风用I2S1
#define I2S_OUT_PORT I2S_NUM_0 // 扬声器用I2S0（无冲突）
#define I2S_MIC_CLOCK_PIN 12
#define I2S_MIC_DATA_PIN 13
const int SAMPLE_RATE = 8000;
const int CHUNK_MS = 30;
const int BYTES_PER_CHUNK = SAMPLE_RATE * CHUNK_MS / 1000 * 2;
const int AUDIO_QUEUE_DEPTH = 3;
// 扬声器配置
#define I2S_SPK_BCLK 14
#define I2S_SPK_LRCK 15
#define I2S_SPK_DIN 16
const int TTS_RATE = 8000;
// IMU配置
#define IMU_SPI_SCK 1
#define IMU_SPI_MOSI 2
#define IMU_SPI_MISO 3
#define IMU_SPI_CS 4
const char* UDP_HOST = "192.168.1.165";
const int UDP_PORT = 8888;
// 核心状态变量（全局唯一，避免重复定义）
volatile bool low_power_mode = false; // 低功耗模式标记
volatile bool is_low_power_sleep = false; // 低功耗睡眠标记
volatile bool addr_conflict_detected = false; // 地址冲突检测标记
volatile bool run_audio_stream = false; // 音频流运行标记
volatile bool cam_ws_ready = false;
volatile bool aud_ws_ready = false;
volatile bool snapshot_in_progress = false;
SemaphoreHandle_t state_mutex; // 状态变量互斥锁
// 全局对象 - 使用带端口支持的I2SClass_Port（兼容层）
WiFiUDP udp;
WebsocketsClient wsCam;
WebsocketsClient wsAud;
I2SClass_Port i2sIn; // 替换为带setPort的兼容类
I2SClass_Port i2sOut; // 替换为带setPort的兼容类
// 队列定义
typedef camera_fb_t* fb_ptr_t;
QueueHandle_t qFrames;
typedef struct {
size_t n;
uint8_t data[BYTES_PER_CHUNK];
} AudioChunk;
QueueHandle_t qAudio;
#define TTS_QUEUE_DEPTH 16
typedef struct { uint16_t n; uint8_t data[2048]; } TTSChunk;
QueueHandle_t qTTS;
volatile bool tts_playing = false;
// HTTP播放相关
static TaskHandle_t taskHttpPlayHandle = nullptr;
static volatile bool http_play_running = false;
// ===================== 提前声明WavFmt结构体（解决未声明错误） =====================
struct WavFmt {
uint16_t audioFormat;
uint16_t numChannels;
uint32_t sampleRate;
uint32_t byteRate;
uint16_t blockAlign;
uint16_t bitsPerSample;
};
// ===================== 低功耗安全BOD配置（缓存操作替换为空，保留核心逻辑） =====================
void bod_config_low_power_safe() {
// 1. 低功耗安全的BOD配置（RTC域专用API，无地址冲突）
REG_CLR_BIT(RTC_CNTL_BROWN_OUT_REG, RTC_CNTL_BROWN_OUT_ENA);
REG_CLR_BIT(RTC_CNTL_INT_ENA_REG, RTC_CNTL_BROWN_OUT_INT_ENA);
// 2. 关闭外设减少资源占用
if (is_low_power_sleep) {
spi_bus_free(SPI2_HOST); // 释放SPI2总线（PSRAM使用）
esp_camera_deinit(); // 关闭摄像头
WiFi.disconnect(true); // 断开WiFi
i2sIn.end(); // 关闭麦克风I2S
i2sOut.end(); // 关闭扬声器I2S
esp_cache_disable(); // 空操作，无实际执行
}
Serial.println("[BOD] 低功耗安全配置完成，地址冲突防护已启用");
}
// ===================== 低功耗唤醒后恢复（缓存操作替换为空，保留核心逻辑） =====================
void bod_restore_after_wakeup() {
xSemaphoreTake(state_mutex, portMAX_DELAY);
is_low_power_sleep = false;
addr_conflict_detected = false;
xSemaphoreGive(state_mutex);
// 1. 恢复缓存和SPI总线（缓存操作为空，SPI恢复保留）
esp_cache_enable(); // 空操作，无实际执行
delay(10);
SPI.begin(IMU_SPI_SCK, IMU_SPI_MISO, IMU_SPI_MOSI, IMU_SPI_CS); // 恢复SPI总线
delay(10);
// 2. 恢复外设
init_camera(); // 重启摄像头
init_i2s_in(); // 重启麦克风I2S
init_i2s_out(); // 重启扬声器I2S
// 3. 重连WiFi
WiFi.begin(WIFI_SSID, WIFI_PASS);
while (WiFi.status() != WL_CONNECTED) { delay(300); }
// 4. 恢复BOD基础配置
REG_SET_BIT(RTC_CNTL_BROWN_OUT_REG, RTC_CNTL_BROWN_OUT_ENA);
Serial.println("[BOD] 唤醒后地址空间恢复完成，外设重新初始化");
}
// ===================== AI状态上报（修复sendText和变量未声明） =====================
void report_state_to_ai(const char* state, bool conflict = false) {
if (!wsCam.available() && !wsAud.available()) {
Serial.println("[AI] 无WS连接，跳过状态上报");
return;
}
// 构造AI能识别的状态信息
char ai_report[512];
snprintf(ai_report, sizeof(ai_report),
"{\"device_state\":\"%s\",\"is_low_power\":%d,\"addr_conflict\":%d,"
"\"bod_config\":\"low_power_safe\",\"timestamp\":%lu}",
state, is_low_power_sleep, addr_conflict_detected, millis());
// 修复：WebsocketsClient无sendText，改用send
if (wsCam.available()) {
wsCam.send(String("[AI_REPORT]") + ai_report);
Serial.printf("[AI] 上报状态：%s\n", ai_report);
}
}
// ===================== 低功耗睡眠触发（核心入口） =====================
void enter_low_power_sleep(uint32_t sleep_ms) {
// 1. 上报低功耗准备状态给AI
report_state_to_ai("enter_low_power", false);
// 2. 安全配置BOD，避免地址冲突
bod_config_low_power_safe();
// 3. 配置唤醒源（定时器唤醒，适配底板）
esp_sleep_enable_timer_wakeup(sleep_ms * 1000); // 毫秒转微秒
// 可选：底板引脚唤醒
// rtc_gpio_pullup_en(GPIO_NUM_0);
// esp_sleep_enable_ext0_wakeup(GPIO_NUM_0, 1);
// 4. 进入深度睡眠（替代轻睡眠，降低功耗）
xSemaphoreTake(state_mutex, portMAX_DELAY);
is_low_power_sleep = true;
xSemaphoreGive(state_mutex);
Serial.printf("[LOW POWER] 进入睡眠%dms，地址冲突防护已启用\n", sleep_ms);
esp_deep_sleep_start(); // 改用深度睡眠，彻底释放资源
// 注意：深度睡眠后设备会重启，以下代码不会执行
// 唤醒后会重新执行setup()，无需手动恢复
}
// ===================== 地址冲突检测（修复逻辑错误） =====================
void check_addr_conflict() {
// 修复：正确的PSRAM地址范围检测（ESP32 PSRAM地址：0x3F800000 ~ 0x3FFFFFFF）
void* psram_ptr = ps_malloc(1024);
if (psram_ptr == NULL) {
Serial.println("[ERROR] PSRAM分配失败，疑似地址冲突！");
xSemaphoreTake(state_mutex, portMAX_DELAY);
addr_conflict_detected = true;
xSemaphoreGive(state_mutex);
report_state_to_ai("addr_conflict_detected", true);
// 紧急降负载
g_target_fps = 2;
low_power_mode = true;
return;
}
uint32_t psram_addr = (uint32_t)psram_ptr;
// 修复：正确的RTC内存地址范围（0x3FF80000 ~ 0x3FFBFFFF）
if ((psram_addr >= 0x3FF80000 && psram_addr <= 0x3FFBFFFF)) { // RTC内存范围
xSemaphoreTake(state_mutex, portMAX_DELAY);
addr_conflict_detected = true;
xSemaphoreGive(state_mutex);
Serial.println("[ERROR] 检测到PSRAM与RTC地址冲突！");
report_state_to_ai("addr_conflict_detected", true);
// 紧急降负载
g_target_fps = 2;
low_power_mode = true;
} else {
xSemaphoreTake(state_mutex, portMAX_DELAY);
addr_conflict_detected = false;
xSemaphoreGive(state_mutex);
}
free(psram_ptr);
}
// ===================== 原有功能函数（保留核心，修复变量引用） =====================
bool apply_framesize(framesize_t fs) {
if (fs != FRAMESIZE_QVGA) {
Serial.println("[CAM] 禁止切换高分辨率（防止欠压）");
return false;
}
sensor_t* s = esp_camera_sensor_get();
if (!s) return false;
int r = s->set_framesize(s, fs);
if (r == 0) { g_frame_size = fs; return true; }
return false;
}
bool init_camera() {
camera_config_t config;
config.ledc_channel = LEDC_CHANNEL_0;
config.ledc_timer = LEDC_TIMER_0;
config.pin_d0 = Y2_GPIO_NUM; config.pin_d1 = Y3_GPIO_NUM;
config.pin_d2 = Y4_GPIO_NUM; config.pin_d3 = Y5_GPIO_NUM;
config.pin_d4 = Y6_GPIO_NUM; config.pin_d5 = Y7_GPIO_NUM;
config.pin_d6 = Y8_GPIO_NUM; config.pin_d7 = Y9_GPIO_NUM;
config.pin_xclk = XCLK_GPIO_NUM; config.pin_pclk = PCLK_GPIO_NUM;
config.pin_vsync = VSYNC_GPIO_NUM; config.pin_href = HREF_GPIO_NUM;
config.pin_sscb_sda = SIOD_GPIO_NUM; config.pin_sscb_scl = SIOC_GPIO_NUM;
config.pin_pwdn = PWDN_GPIO_NUM; config.pin_reset = RESET_GPIO_NUM;
config.xclk_freq_hz = 8000000;
config.pixel_format = PIXFORMAT_JPEG;
config.frame_size = g_frame_size;
config.jpeg_quality = JPEG_QUALITY;
config.fb_count = FB_COUNT;
config.fb_location = CAMERA_FB_IN_PSRAM;
config.grab_mode = CAMERA_GRAB_LATEST;
esp_err_t err = esp_camera_init(&config);
if (err != ESP_OK) { Serial.printf("[CAM] init failed: 0x%x\n", err); return false; }
sensor_t * s = esp_camera_sensor_get();
if (s) {
s->set_hmirror(s, 1);
s->set_vflip(s, 0);
s->set_brightness(s, 0);
s->set_contrast(s, 0);
s->set_saturation(s, 0);
s->set_gain_ctrl(s, 0);
s->set_exposure_ctrl(s, 1);
s->set_whitebal(s, 1);
s->set_awb_gain(s, 0);
s->set_aec2(s, 0);
s->set_aec_value(s, 80);
s->set_special_effect(s, 0);
s->set_wb_mode(s, 2);
}
return true;
}
inline void enqueue_frame(camera_fb_t* fb) {
if (!fb) return;
xSemaphoreTake(state_mutex, portMAX_DELAY);
bool lpm = low_power_mode;
xSemaphoreGive(state_mutex);
if (lpm) {
esp_camera_fb_return(fb);
frame_dropped_count++;
return;
}
if (xQueueSend(qFrames, &fb, 0) != pdPASS) {
fb_ptr_t drop = nullptr;
if (xQueueReceive(qFrames, &drop, 0) == pdPASS) {
if (drop) {
esp_camera_fb_return(drop);
frame_dropped_count++;
}
}
xQueueSend(qFrames, &fb, 0);
}
}
void taskCamCapture(void* param) {
// 任务喂狗
esp_task_wdt_add(NULL);
unsigned long last_log = 0;
unsigned long capture_fail_count = 0;
for(;;){
esp_task_wdt_reset(); // 喂狗
if (snapshot_in_progress) { vTaskDelay(pdMS_TO_TICKS(5)); continue; }
xSemaphoreTake(state_mutex, portMAX_DELAY);
bool cam_ready = cam_ws_ready;
bool lpm = low_power_mode;
xSemaphoreGive(state_mutex);
if (cam_ready) {
if (lpm) {
vTaskDelay(pdMS_TO_TICKS(200));
continue;
}
camera_fb_t* fb = esp_camera_fb_get();
if (fb) {
frame_captured_count++;
if (fb->format != PIXFORMAT_JPEG) {
esp_camera_fb_return(fb);
capture_fail_count++;
}
else {
enqueue_frame(fb);
}
} else {
capture_fail_count++;
vTaskDelay(pdMS_TO_TICKS(2));
}
unsigned long now = millis();
if (now - last_log > 5000) {
int queue_waiting = uxQueueMessagesWaiting(qFrames);
Serial.printf("[CAM-CAP] captured=%lu, queue=%d, fail=%lu, low_power=%d\n",
frame_captured_count, queue_waiting, capture_fail_count, lpm);
last_log = now;
capture_fail_count = 0;
}
} else {
vTaskDelay(pdMS_TO_TICKS(20));
}
}
}
void taskCamSend(void* param) {
// 任务喂狗
esp_task_wdt_add(NULL);
static TickType_t lastTick = 0;
unsigned long last_log = 0;
unsigned long send_timeout_count = 0;
unsigned long last_sent_time = 0;
for(;;){
esp_task_wdt_reset(); // 喂狗
fb_ptr_t fb = nullptr;
if (xQueueReceive(qFrames, &fb, pdMS_TO_TICKS(100)) == pdPASS) {
xSemaphoreTake(state_mutex, portMAX_DELAY);
bool cam_ready = cam_ws_ready;
xSemaphoreGive(state_mutex);
if (fb && cam_ready) {
const int period_ms = 200;
TickType_t tick_now = xTaskGetTickCount();
int elapsed = (tick_now - lastTick) * portTICK_PERIOD_MS;
if (elapsed < period_ms) vTaskDelay(pdMS_TO_TICKS(period_ms - elapsed));
lastTick = tick_now;
const size_t CHUNK_SIZE = 2048;
size_t sent = 0;
bool send_ok = true;
while (sent < fb->len && send_ok) {
size_t chunk_len = min(CHUNK_SIZE, fb->len - sent);
send_ok = wsCam.sendBinary((const char*)fb->buf + sent, chunk_len);
sent += chunk_len;
if (!send_ok) break;
vTaskDelay(pdMS_TO_TICKS(2));
}
if (send_ok) {
frame_sent_count++;
last_sent_time = millis();
} else {
ws_send_fail_count++;
Serial.println("[CAM-SEND] 发送失败，进入低功耗模式");
xSemaphoreTake(state_mutex, portMAX_DELAY);
low_power_mode = true;
xSemaphoreGive(state_mutex);
esp_camera_fb_return(fb);
wsCam.close();
cam_ws_ready = false;
continue;
}
esp_camera_fb_return(fb);
unsigned long log_now = millis();
if (log_now - last_log > 5000) {
unsigned long gap = log_now - last_sent_time;
Serial.printf("[CAM-SEND] sent=%lu, dropped=%lu, ws_fail=%lu, last_gap=%lu ms\n",
frame_sent_count, frame_dropped_count, ws_send_fail_count, gap);
last_log = log_now;
}
} else if (fb) {
esp_camera_fb_return(fb);
}
} else {
unsigned long now = millis();
xSemaphoreTake(state_mutex, portMAX_DELAY);
bool cam_ready = cam_ws_ready;
xSemaphoreGive(state_mutex);
if (cam_ready && last_sent_time > 0 && (now - last_sent_time) > 3000) {
Serial.printf("[CAM-SEND] 无帧发送，退出低功耗模式\n");
xSemaphoreTake(state_mutex, portMAX_DELAY);
low_power_mode = false;
xSemaphoreGive(state_mutex);
send_timeout_count++;
}
}
}
}
// 保留端口指定逻辑（通过兼容层的setPort实现）
bool init_i2s_in(){
// 第一步：指定I2S端口（兼容层实现）
i2sIn.setPort(I2S_IN_PORT);
// 第二步：配置麦克风引脚
i2sIn.setPinsPdmRx(I2S_MIC_CLOCK_PIN, I2S_MIC_DATA_PIN);
// 第三步：初始化I2S
if (!i2sIn.begin(I2S_MODE_PDM_RX, SAMPLE_RATE, I2S_DATA_BIT_WIDTH_16BIT, I2S_SLOT_MODE_MONO)) {
Serial.println("[I2S IN] init failed");
return false;
}
Serial.println("[I2S IN] PDM RX @8kHz 16bit MONO ready (I2S1)");
return true;
}
void taskMicCapture(void* param) {
esp_task_wdt_add(NULL); // 喂狗
const int samples_per_chunk = BYTES_PER_CHUNK / 2;
for(;;){
esp_task_wdt_reset(); // 喂狗
xSemaphoreTake(state_mutex, portMAX_DELAY);
bool run_audio = run_audio_stream;
bool aud_ready = aud_ws_ready;
bool lpm = low_power_mode;
xSemaphoreGive(state_mutex);
if (run_audio && aud_ready && !lpm) {
AudioChunk ch; ch.n = BYTES_PER_CHUNK;
int16_t* out = reinterpret_cast<int16_t*>(ch.data);
int i = 0;
while (i < samples_per_chunk){
int v = i2sIn.read();
if (v == -1) { delay(1); continue; }
out[i++] = (int16_t)v;
}
if (xQueueSend(qAudio, &ch, 0) != pdPASS){
AudioChunk dump;
xQueueReceive(qAudio, &dump, 0);
xQueueSend(qAudio, &ch, 0);
}
} else {
vTaskDelay(pdMS_TO_TICKS(10));
}
}
}
void taskMicUpload(void* param) {
esp_task_wdt_add(NULL); // 喂狗
for(;;){
esp_task_wdt_reset(); // 喂狗
xSemaphoreTake(state_mutex, portMAX_DELAY);
bool run_audio = run_audio_stream;
bool aud_ready = aud_ws_ready;
bool lpm = low_power_mode;
xSemaphoreGive(state_mutex);
if (run_audio && aud_ready && !lpm){
AudioChunk ch;
if (xQueueReceive(qAudio, &ch, pdMS_TO_TICKS(100)) == pdPASS){
wsAud.sendBinary((const char*)ch.data, ch.n);
vTaskDelay(pdMS_TO_TICKS(2));
}
} else {
vTaskDelay(pdMS_TO_TICKS(20));
}
}
}
// 保留端口指定逻辑（通过兼容层的setPort实现）
bool init_i2s_out(){
// 第一步：指定I2S端口（兼容层实现）
i2sOut.setPort(I2S_OUT_PORT);
// 第二步：配置扬声器引脚
i2sOut.setPins(I2S_SPK_BCLK, I2S_SPK_LRCK, I2S_SPK_DIN);
// 第三步：初始化I2S
if (!i2sOut.begin(I2S_MODE_STD, TTS_RATE, I2S_DATA_BIT_WIDTH_16BIT, I2S_SLOT_MODE_STEREO)) {
Serial.println("[I2S OUT] init failed");
return false;
}
Serial.println("[I2S OUT] STD TX @8kHz 16bit STEREO ready (I2S0)");
return true;
}
static inline void mono16_to_stereo32_msb(const int16_t* in, size_t nSamp, int32_t* outLR, float gain = 0.3f) {
for (size_t i = 0; i < nSamp; ++i) {
int32_t s = (int32_t)((float)in[i] * gain);
int32_t v32 = s << 16;
outLR[i*2 + 0] = v32;
outLR[i*2 + 1] = v32;
}
}
static bool read_line(WiFiClient& cli, String& line, uint32_t timeout_ms=3000){
line = "";
uint32_t t0 = millis();
while (millis() - t0 < timeout_ms){
while (cli.available()){
char ch = (char)cli.read();
if (ch == '\n'){
if (line.endsWith("\r")) line.remove(line.length()-1);
return true;
}
line += ch;
}
delay(1);
}
return false;
}
static bool readN_http_body(WiFiClient& cli, uint8_t* buf, size_t n, bool chunked, size_t& chunk_left, uint32_t timeout_ms=3000){
size_t got = 0;
uint32_t t0 = millis();
while (got < n){
if (!cli.connected()) return false;
if (!chunked){
int avail = cli.available();
if (avail > 0){
int toread = (int)min((size_t)avail, n - got);
int r = cli.read(buf + got, toread);
if (r > 0) got += r;
} else {
if (millis() - t0 > timeout_ms) return false;
delay(1);
}
} else {
if (chunk_left == 0){
String szline;
if (!read_line(cli, szline, timeout_ms)) return false;
int sc = szline.indexOf(';');
if (sc >= 0) szline = szline.substring(0, sc);
szline.trim();
unsigned long sz = strtoul(szline.c_str(), nullptr, 16);
if (sz == 0){
String dummy;
read_line(cli, dummy, 500);
return false;
}
chunk_left = (size_t)sz;
}
int avail = cli.available();
if (avail > 0){
size_t want = min(n - got, chunk_left);
int toread = (int)min((size_t)avail, want);
int r = cli.read(buf + got, toread);
if (r > 0){
got += r;
chunk_left -= (size_t)r;
if (chunk_left == 0){
while (cli.available() < 2) { if (millis() - t0 > timeout_ms) return false; delay(1); }
cli.read(); cli.read();
}
}
} else {
if (millis() - t0 > timeout_ms) return false;
delay(1);
}
}
}
return true;
}
// 修复：补全parse_wav_header函数的闭合大括号
static bool parse_wav_header(WiFiClient& cli, WavFmt& fmt, uint32_t& dataRemaining, bool chunked, size_t& chunk_left){
uint8_t hdr12[12];
if (!readN_http_body(cli, hdr12, 12, chunked, chunk_left)) return false;
if (memcmp(hdr12, "RIFF", 4) != 0 || memcmp(hdr12 + 8, "WAVE", 4) != 0) return false;
bool gotFmt = false;
dataRemaining = 0;
while (true) {
uint8_t chdr[8];
if (!readN_http_body(cli, chdr, 8, chunked, chunk_left)) return false;
uint32_t sz = (uint32_t)chdr[4] | ((uint32_t)chdr[5] << 8) | ((uint32_t)chdr[6] << 16) | ((uint32_t)chdr[7] << 24);
if (memcmp(chdr, "fmt ", 4) == 0) {
if (sz < 16) return false;
uint8_t fmtbuf[32];
size_t toread = min(sz, (uint32_t)sizeof(fmtbuf));
if (!readN_http_body(cli, fmtbuf, toread, chunked, chunk_left)) return false;
uint32_t left = sz - (uint32_t)toread;
while (left){
uint8_t dump[64];
size_t d = min((uint32_t)sizeof(dump), left);
if (!readN_http_body(cli, dump, d, chunked, chunk_left)) return false;
left -= d;
}
fmt.audioFormat = (uint16_t) (fmtbuf[0] | (fmtbuf[1] << 8));
fmt.numChannels = (uint16_t) (fmtbuf[2] | (fmtbuf[3] << 8));
fmt.sampleRate = (uint32_t) (fmtbuf[4] | (fmtbuf[5] << 8) | (fmtbuf[6] << 16) | (fmtbuf[7] << 24));
fmt.byteRate = (uint32_t) (fmtbuf[8] | (fmtbuf[9] << 8) | (fmtbuf[10] << 16) | (fmtbuf[11] << 24));
fmt.blockAlign = (uint16_t) (fmtbuf[12] | (fmtbuf[13] << 8));
fmt.bitsPerSample = (uint16_t) (fmtbuf[14] | (fmtbuf[15] << 8));
gotFmt = true;
}
else if (memcmp(chdr, "data", 4) == 0) {
if (!gotFmt) return false;
dataRemaining = sz;
return true;
}
else {
uint32_t left = sz;
while (left){
uint8_t dump[128];
size_t d = min((uint32_t)sizeof(dump), left);
if (!readN_http_body(cli, dump, d, chunked, chunk_left)) return false;
left -= d;
}
}
}
} // 关键修复：补全这个函数的闭合大括号
void taskHttpPlay(void* param) {
esp_task_wdt_add(NULL); // 喂狗
http_play_running = true;
WiFiClient cli;
auto readLine = [&](String& out, uint32_t timeout_ms)->bool {
out = "";
uint32_t t0 = millis();
while (millis() - t0 < timeout_ms) {
while (cli.available()) {
char c = (char)cli.read();
if (c == '\r') continue;
if (c == '\n') return true;
out += c;
if (out.length() > 1024) return false;
}
delay(1);
}
return false;
};
auto readNRaw = [&](uint8_t* dst, size_t n, uint32_t timeout_ms)->bool {
size_t got = 0;
uint32_t t0 = millis();
while (got < n) {
if (!cli.connected()) return false;
int avail = cli.available();
if (avail > 0) {
int take = (int)min((size_t)avail, n - got);
int r = cli.read(dst + got, take);
if (r > 0) { got += r; continue; }
}
if (millis() - t0 > timeout_ms) return false;
delay(1);
}
return true;
};
auto makeBodyReader = [&](bool& is_chunked, uint32_t& chunk_left){
return [&](uint8_t* dst, size_t n, uint32_t timeout_ms)->bool {
size_t filled = 0;
uint32_t t0 = millis();
while (filled < n) {
esp_task_wdt_reset(); // 喂狗
if (!cli.connected()) return false;
if (is_chunked) {
if (chunk_left == 0) {
String szLine;
if (!readLine(szLine, timeout_ms)) return false;
int sc = szLine.indexOf(';');
if (sc >= 0) szLine = szLine.substring(0, sc);
szLine.trim();
uint32_t sz = 0;
if (sscanf(szLine.c_str(), "%x", &sz) != 1) return false;
if (sz == 0) { String dummy; readLine(dummy, 200); return false; }
chunk_left = sz;
}
size_t need = (size_t)min<uint32_t>(chunk_left, (uint32_t)(n - filled));
while (cli.available() < (int)need) {
if (millis() - t0 > timeout_ms) return false;
if (!cli.connected()) return false;
delay(1);
}
int r = cli.read(dst + filled, need);
if (r <= 0) {
if (millis() - t0 > timeout_ms) return false;
delay(1); continue;
}
filled += r;
chunk_left -= r;
if (chunk_left == 0) {
char crlf[2];
if (!readNRaw((uint8_t*)crlf, 2, 200)) return false;
}
} else {
if (!readNRaw(dst + filled, n - filled, timeout_ms)) return false;
filled = n;
}
}
return true;
};
};
static int32_t outLR[256 * 2];
const uint32_t BODY_TIMEOUT_MS = 1500;
while (http_play_running) {
esp_task_wdt_reset(); // 喂狗
xSemaphoreTake(state_mutex, portMAX_DELAY);
bool lpm = low_power_mode;
xSemaphoreGive(state_mutex);
if (lpm) {
vTaskDelay(pdMS_TO_TICKS(100));
continue;
}
if (!cli.connected()) {
Serial.println("[AUDIO] HTTP connect...");
if (!cli.connect(SERVER_HOST, SERVER_PORT)) { delay(500); continue; }
String req =
String("GET /stream.wav HTTP/1.1\r\n") +
"Host: " + SERVER_HOST + ":" + String(SERVER_PORT) + "\r\n" +
"Connection: keep-alive\r\n\r\n";
cli.print(req);
}
bool header_ok = false;
bool is_chunked = false;
uint32_t content_len = 0;
{
String line; uint32_t t0 = millis();
while (millis() - t0 < 3000) {
if (!readLine(line, 1000)) { if (!cli.connected()) break; continue; }
String u = line; u.toLowerCase();
if (u.startsWith("transfer-encoding:")) { if (u.indexOf("chunked") >= 0) is_chunked = true; }
else if (u.startsWith("content-length:")) { content_len = (uint32_t) strtoul(u.substring(strlen("content-length:")).c_str(), nullptr, 10); }
if (line.length() == 0) { header_ok = true; break; }
}
}
if (!header_ok) { cli.stop(); delay(300); continue; }
uint32_t chunk_left = 0;
auto readBody = makeBodyReader(is_chunked, chunk_left);
uint8_t hdr12[12];
if (!readBody(hdr12, 12, 1000)) { cli.stop(); delay(300); continue; }
if (memcmp(hdr12, "RIFF", 4) != 0 || memcmp(hdr12 + 8, "WAVE", 4) != 0) { cli.stop(); delay(300); continue; }
bool gotFmt = false, gotData = false;
uint8_t chdr[8];
uint16_t audioFormat=0, numChannels=0, bitsPerSample=0;
uint32_t sampleRate=0;
while (!gotData) {
if (!readBody(chdr, 8, 1000)) { cli.stop(); delay(300); goto reconnect; }
uint32_t sz = (uint32_t)chdr[4] | ((uint32_t)chdr[5]<<8) | ((uint32_t)chdr[6]<<16) | ((uint32_t)chdr[7]<<24);
if (memcmp(chdr, "fmt ", 4) == 0) {
if (sz < 16) { cli.stop(); delay(300); goto reconnect; }
uint8_t fmtbuf[32];
size_t toread = min(sz, (uint32_t)sizeof(fmtbuf));
if (!readBody(fmtbuf, toread, 1000)) { cli.stop(); delay(300); goto reconnect; }
if (sz > toread) {
size_t left = sz - toread;
while (left) { uint8_t dump[128]; size_t d = min(left, sizeof(dump));
if (!readBody(dump, d, 1000)) { cli.stop(); delay(300); goto reconnect; }
left -= d;
}
}
audioFormat = (uint16_t)(fmtbuf[0] | (fmtbuf[1] << 8));
numChannels = (uint16_t)(fmtbuf[2] | (fmtbuf[3] << 8));
sampleRate = (uint32_t)(fmtbuf[4] | (fmtbuf[5] << 8) | (fmtbuf[6] << 16) | (fmtbuf[7] << 24));
bitsPerSample = (uint16_t)(fmtbuf[14] | (fmtbuf[15] << 8));
gotFmt = true;
}
else if (memcmp(chdr, "data", 4) == 0) {
if (!gotFmt) { cli.stop(); delay(300); goto reconnect; }
gotData = true;
}
else {
size_t left = sz;
while (left) { uint8_t dump[128]; size_t d = min(left, sizeof(dump));
if (!readBody(dump, d, 1000)) { cli.stop(); delay(300); goto reconnect; }
left -= d;
}
}
}
if (!(audioFormat==1 && numChannels==1 && bitsPerSample==16 && (sampleRate==8000 || sampleRate==12000 || sampleRate==16000))) {
Serial.printf("[AUDIO] unsupported fmt: ch=%u bits=%u sr=%u af=%u\n",
numChannels, bitsPerSample, sampleRate, audioFormat);
cli.stop(); delay(300); continue;
}
Serial.printf("[AUDIO] WAV ok: %u/16bit/mono (chunked=%d)\n", sampleRate, is_chunked ? 1 : 0);
static uint32_t current_out_rate = 0;
if (current_out_rate != sampleRate) {
// 重新初始化I2S输出，适配新的采样率（保留端口指定）
i2sOut.end();
i2sOut.setPort(I2S_OUT_PORT); // 重新指定端口（兼容层）
i2sOut.setPins(I2S_SPK_BCLK, I2S_SPK_LRCK, I2S_SPK_DIN);
i2sOut.begin(I2S_MODE_STD, (int)sampleRate, I2S_DATA_BIT_WIDTH_16BIT, I2S_SLOT_MODE_STEREO);
current_out_rate = sampleRate;
Serial.printf("[I2S OUT] reconfig to %u Hz\n", sampleRate);
}
while (http_play_running) {
esp_task_wdt_reset(); // 喂狗
xSemaphoreTake(state_mutex, portMAX_DELAY);
bool lpm = low_power_mode;
xSemaphoreGive(state_mutex);
if (lpm) break;
uint8_t inbuf[512];
size_t filled = 0;
uint32_t bytes20 = (sampleRate * 2 * 20) / 1000;
if (bytes20 < 2) bytes20 = 2;
if (!readBody(inbuf, bytes20, BODY_TIMEOUT_MS)) { break; }
filled = bytes20;
while (filled + bytes20 <= sizeof(inbuf)) {
if (!readBody(inbuf + filled, bytes20, 2)) { break; }
filled += bytes20;
}
if (filled & 1) filled -= 1;
if (filled == 0) { vTaskDelay(pdMS_TO_TICKS(1)); continue; }
size_t samp = filled / 2;
mono16_to_stereo32_msb((const int16_t*)inbuf, samp, outLR, 0.3f);
size_t bytes = samp * 2 * sizeof(int32_t);
size_t off = 0;
while (off < bytes && http_play_running) {
size_t wrote = i2sOut.write((uint8_t*)outLR + off, bytes - off);
if (wrote == 0) vTaskDelay(pdMS_TO_TICKS(1));
else off += wrote;
}
}
reconnect:
cli.stop();
delay(200);
}
cli.stop();
vTaskDelete(nullptr);
}
void startStreamWav(){
if (taskHttpPlayHandle) return;
// 关键修复：增大任务栈大小
xTaskCreatePinnedToCore(taskHttpPlay, "http_wav", 8192, nullptr, 1, &taskHttpPlayHandle, 0); // 栈大小从4096→8192
Serial.println("[AUDIO] http_wav task started");
}
void stopStreamWav(){
if (!taskHttpPlayHandle) return;
http_play_running = false;
vTaskDelay(pdMS_TO_TICKS(50));
taskHttpPlayHandle = nullptr;
Serial.println("[AUDIO] http_wav task stopped");
}
void taskTTSPlay(void* param) {
esp_task_wdt_add(NULL); // 喂狗
static int32_t stereo32Buf[256*2];
for(;;){
esp_task_wdt_reset(); // 喂狗
xSemaphoreTake(state_mutex, portMAX_DELAY);
bool tts_play = tts_playing;
bool lpm = low_power_mode;
xSemaphoreGive(state_mutex);
if (!tts_play || lpm){
vTaskDelay(pdMS_TO_TICKS(10)); continue;
}
TTSChunk ch;
if (xQueueReceive(qTTS, &ch, pdMS_TO_TICKS(50)) == pdPASS){
size_t inSamp = ch.n / 2;
int16_t* inPtr = (int16_t*)ch.data;
size_t outPairs = 0;
for (size_t i = 0; i < inSamp; ++i){
int32_t s = (int32_t)inPtr[i];
s = (s * 19660) / 32768;
int32_t v32 = s << 16;
stereo32Buf[outPairs*2 + 0] = v32;
stereo32Buf[outPairs*2 + 1] = v32;
outPairs++;
if (outPairs >= 256){
size_t bytes = outPairs * 2 * sizeof(int32_t);
size_t off = 0;
while (off < bytes){
size_t wrote = i2sOut.write((uint8_t*)stereo32Buf + off, bytes - off);
if (wrote == 0) vTaskDelay(pdMS_TO_TICKS(1)); else off += wrote;
}
outPairs = 0;
}
}
if (outPairs){
size_t bytes = outPairs * 2 * sizeof(int32_t);
size_t off = 0;
while (off < bytes){
size_t wrote = i2sOut.write((uint8_t*)stereo32Buf + off, bytes - off);
if (wrote == 0) vTaskDelay(pdMS_TO_TICKS(1)); else off += wrote;
}
}
}
}
}
inline void tts_reset_queue(){ if (qTTS) xQueueReset(qTTS); }
// IMU相关函数
#define REG_WHO_AM_I 0x75
#define REG_BANK_SEL 0x76
#define REG_PWR_MGMT0 0x4E
#define REG_TEMP_H 0x1D
#define BURST_FIRST REG_TEMP_H
#define BURST_COUNT 14
static const float ACC_LSB_PER_G = 2048.0f;
static const float GYR_LSB_PER_DPS = 16.4f;
static const float G = 9.80665f;
static const float TEMP_SENS = 132.48f;
static const float TEMP_OFFSET = 25.0f;
static inline void imu_cs_low() { digitalWrite(IMU_SPI_CS, LOW); }
static inline void imu_cs_high() { digitalWrite(IMU_SPI_CS, HIGH); }
uint8_t imu_read8(uint8_t reg){
imu_cs_low();
SPI.transfer(reg | 0x80);
uint8_t v = SPI.transfer(0x00);
imu_cs_high();
return v;
}
void imu_write8(uint8_t reg, uint8_t val){
imu_cs_low();
SPI.transfer(reg & 0x7F);
SPI.transfer(val);
imu_cs_high();
}
void imu_readn(uint8_t start_reg, uint8_t* dst, size_t n){
imu_cs_low();
SPI.transfer(start_reg | 0x80);
for (size_t i=0;i<n;i++) dst[i] = SPI.transfer(0x00);
imu_cs_high();
}
bool imu_init_spi(){
SPI.begin(IMU_SPI_SCK, IMU_SPI_MISO, IMU_SPI_MOSI, IMU_SPI_CS);
SPI.setClockDivider(SPI_CLOCK_DIV16);
pinMode(IMU_SPI_CS, OUTPUT);
imu_cs_high();
delay(5);
uint8_t who = imu_read8(REG_WHO_AM_I);
Serial.printf("[IMU] WHO_AM_I=0x%02X (expect 0x47)\n", who);
if (who != 0x47) return false;
imu_write8(REG_PWR_MGMT0, 0x03);
delay(10);
return true;
}
bool imu_read_once(float& tempC, float& ax, float& ay, float& az, float& gx, float& gy, float& gz){
uint8_t raw[BURST_COUNT];
imu_readn(BURST_FIRST, raw, sizeof(raw));
auto s16 = [&](int idx)->int16_t {
return (int16_t)((raw[idx] << 8) | raw[idx+1]);
};
int16_t tr = s16(0);
int16_t axr = s16(2);
int16_t ayr = s16(4);
int16_t azr = s16(6);
int16_t gxr = s16(8);
int16_t gyr = s16(10);
int16_t gzr = s16(12);
tempC = (float)tr / TEMP_SENS + TEMP_OFFSET;
ax = ((float)axr / ACC_LSB_PER_G) * G;
ay = ((float)ayr / ACC_LSB_PER_G) * G;
az = ((float)azr / ACC_LSB_PER_G) * G;
gx = 0;
gy = 0;
gz = 0;
return true;
}
static const float EMA_ALPHA = 0.20f;
bool ema_inited = false;
float ax_f=0, ay_f=0, az_f=0;
void taskImuLoop(void* param) {
esp_task_wdt_add(NULL); // 喂狗
for(;;){
esp_task_wdt_reset(); // 喂狗
static bool inited = false;
if (!inited){
inited = imu_init_spi();
if (!inited){ vTaskDelay(pdMS_TO_TICKS(500)); continue; }
Serial.println("[IMU] init OK (SPI)");
}
xSemaphoreTake(state_mutex, portMAX_DELAY);
bool lpm = low_power_mode;
xSemaphoreGive(state_mutex);
if (lpm) {
vTaskDelay(pdMS_TO_TICKS(200));
continue;
}
float tempC, ax, ay, az, gx, gy, gz;
if (!imu_read_once(tempC, ax, ay, az, gx, gy, gz)){
inited = false; vTaskDelay(pdMS_TO_TICKS(50)); continue;
}
if (!ema_inited){ ax_f=ax; ay_f=ay; az_f=az; ema_inited=true; }
else {
ax_f = EMA_ALPHA*ax + (1-EMA_ALPHA)*ax_f;
ay_f = EMA_ALPHA*ay + (1-EMA_ALPHA)*ay_f;
az_f = EMA_ALPHA*az + (1-EMA_ALPHA)*az_f;
}
char buf[256];
unsigned long ts = millis();
int n = snprintf(buf, sizeof(buf),
"{\"ts\":%lu,\"temp_c\":%.2f,"
"\"accel\":{\"x\":%.3f,\"y\":%.3f,\"z\":%.3f},"
"\"gyro\":{\"x\":%.3f,\"y\":%.3f,\"z\":%.3f}}",
ts, tempC, ax_f, ay_f, az_f, gx, gy, gz);
if (n > 0) {
udp.beginPacket(UDP_HOST, UDP_PORT);
udp.write((const uint8_t*)buf, n);
udp.endPacket();
}
vTaskDelay(pdMS_TO_TICKS(100));
}
}
// ===================== Setup和Loop（修复变量重定义） =====================
void setup() {
// 1. 初始化互斥锁
state_mutex = xSemaphoreCreateMutex();
// 2. 初始化看门狗（适配IDF v5.5新API）
esp_task_wdt_config_t wdt_config = {
.timeout_ms = 10000, // 超时10秒
.trigger_panic = true // 超时触发panic（重启）
};
esp_task_wdt_init(&wdt_config);
// 3. BOD禁用（核心欠压保护）
WRITE_PERI_REG(RTC_CNTL_BROWN_OUT_REG, 0);
CLEAR_PERI_REG_MASK(RTC_CNTL_BROWN_OUT_REG, RTC_CNTL_BROWN_OUT_ENA);
// 4. 电源管理优化
setCpuFrequencyMhz(160);
Serial.begin(115200);
delay(1000);
// 5. PSRAM初始化
bool psram_ok = psramInit();
if (psram_ok) {
Serial.println("✅ PSRAM 初始化成功！");
} else {
Serial.println("❌ PSRAM 初始化失败！");
return;
}
Serial.print("
我要赚赏金打赏帖
STM32
MCU
通讯及无线技术
物联网技术
电子DIY
板卡试用
基础知识
软件与操作系统
我爱生活
小e食堂
