ESP32原生开发——小智AI解析2（application.cc）
#include "application.h" // 应用程序主入口，定义系统初始化和主循环逻辑 #include "board.h" // 开发板硬件配置（引脚定义、外设初始化） #include "display.h" // 显示屏驱动和UI渲染 #include "system_info.h" // 系统信息获取（版本、内存、运行状态）
通信协议与安全传输
#include "ml307_ssl_transport.h" // 基于ML307模块的SSL/TLS通信（安全传输层） #include "mqtt_protocol.h" // MQTT协议实现（物联网消息队列） #include "websocket_protocol.h" // WebSocket协议实现（双向通信） #include "mcp_server.h" // 自定义服务器协议（可能是项目内部协议）
音频处理
#include "audio_codec.h" // 音频编解码驱动（录音/播放） #ifdef CONFIG_USE_AUDIO_PROCESSOR #include "afe_audio_processor.h" // 高级音频处理（降噪、回声消除） #else #include "dummy_audio_processor.h" // 虚拟音频处理（测试或低功耗模式） #endif
辅助功能
#include "font_awesome_symbols.h" // Font Awesome图标集（用于UI显示） #include "assets/lang_config.h" // 多语言配置（字符串国际化） #include "iot/thing_manager.h" // IoT设备管理框架（设备注册、属性同步）
业务依赖
#include <cstring> // C标准字符串库 #include <esp_log.h> // ESP-IDF日志系统 #include <cJSON.h> // JSON解析库 #include <driver/gpio.h> // GPIO驱动 #include <arpa/inet.h> // 网络地址转换（IP格式处理）
LOG TAG
#define TAG "Application"
这是一个很好的状态机实践
STATE STRING
static const char* const STATE_STRINGS[] = { "unknown", "starting", "configuring", "idle", "connecting", "listening", "speaking", "upgrading", "activating", "fatal_error", "invalid_state" };
这段代码定义了一个静态常量数组 STATE_STRINGS，用于将 DeviceState 枚举值映射为可读的字符串。
数组索引与 DeviceState 枚举值一一对应
对应关系：数组索引与 DeviceState 枚举值一一对应（需注意枚举定义顺序）。
enum DeviceState { kDeviceStateUnknown = 0, // STATE_STRINGS[0] = "unknown" kDeviceStateStarting = 1, // STATE_STRINGS[1] = "starting" // ... 其他枚举值依此类推 };
2. 边界处理
DeviceState state = (DeviceState)100; // 非法值 const char* str = (state < sizeof(STATE_STRINGS)/sizeof(STATE_STRINGS[0])) ? STATE_STRINGS[state] : STATE_STRINGS[sizeof(STATE_STRINGS)/sizeof(STATE_STRINGS[0])-1];
良好的使用方式
static_assert( sizeof(STATE_STRINGS)/sizeof(STATE_STRINGS[0]) == static_cast<int>(kDeviceStateFatalError) + 2, // +2 包含 invalid_state "STATE_STRINGS length must match DeviceState enum values" );
Application构造
Application::Application() { event_group_ = xEventGroupCreate(); //用于任务间的同步或事件通信，允许一个或多个任务等待多个事件的组合（逻辑与 / 或） background_task_ = new BackgroundTask(4096 * 7); //手动创建 BackgroundTask 实例，传入栈大小为 4096 * 7 字节（约 28KB）。 #if CONFIG_USE_AUDIO_PROCESSOR //音频处理器初始化（条件编译） audio_processor_ = std::make_unique<AfeAudioProcessor>(); #else audio_processor_ = std::make_unique<DummyAudioProcessor>(); #endif //定时器参数结构体 esp_timer_create_args_t clock_timer_args = { .callback = [](void* arg) { Application* app = (Application*)arg; app->OnClockTimer(); }, .arg = this, .dispatch_method = ESP_TIMER_TASK, .name = "clock_timer", .skip_unhandled_events = true }; //创建timer esp_timer_create(&clock_timer_args, &clock_timer_handle_); //timer start esp_timer_start_periodic(clock_timer_handle_, 1000000); }
timer结构体
esp_timer_create_args_t 是一个结构体 typedef struct { esp_timer_cb_t callback; //定时器在周期内调用的函数。 void* arg; //一个指针类型，将参数传递给回调函数。 注：一般设置为NULL,即不携带参数 esp_timer_dispatch_t dispatch_method; //从task或ISR调用回调。 const char* name; //定时器名称，用于ESPTIMER转储功能。 bool skip_unhandled_events; //跳过周期计时器的未处理事件。 } esp_timer_create_args_t;
创建timer
esp_err_t esp_timer_create(const esp_timer_create_args_t* create_args, esp_timer_handle_t* out_handle); 入参 create_args //指向arg外设结构体的指针 esp_tim_handle //指定使能的中断 例程： esp_timer_handle_t esp_tim_handle; /* 定时器回调函数句柄 */ /* 定义一个定时器结构体 */ esp_timer_create_args_t tim_periodic_arg = { .callback = &esptim_callback, /* 设置回调函数 */ .arg = NULL, /* 不携带参数 */ }; esp_timer_create(&tim_periodic_arg, &esp_tim_handle); /* 创建一个事件 */ /** * @brief 定时器回调函数 * @param arg: 不携带参数 * @retval 无 */ void esptim_callback(void *arg) { //用户程序 }
周期触发定时器
esp_err_t IRAM_ATTR esp_timer_start_periodic(esp_timer_handle_t timer, uint64_t period_us); 入参 timer //使用esp_timer_create创建的定时器句柄 period_us //计时器周期，以微秒为单位 例程： uint32_t tps = 1000000; esp_timer_start_periodic(esp_tim_handle, tps); /* 每周期内触发一次 */ /** * @brief 初始化高精度定时器（ESP_TIMER） * @param tps: 定时器周期，以微妙为单位（μs），以一秒为定时器周期来执行一次定时器中断， * 那此处tps = 1s = 1000000μs * @retval 无 */
timer创建返回一个到timer的句柄，然后把这个句柄启动周期性定时器
Application析构函数
Application::~Application() { // 停止并删除定时器 if (clock_timer_handle_ != nullptr) { esp_timer_stop(clock_timer_handle_); esp_timer_delete(clock_timer_handle_); clock_timer_handle_ = nullptr; // 防止重复删除 } // 如果background_task_是智能指针管理的，则不需要这行代码 // 如果是原始指针，则需要保留这行 if (background_task_ != nullptr) { delete background_task_; background_task_ = nullptr; } // 删除事件组前检查是否为nullptr if (event_group_ != nullptr) { vEventGroupDelete(event_group_); event_group_ = nullptr; } }
void Application::CheckNewVersion() { const int MAX_RETRY = 10; //最大RETRY，10次 int retry_count = 0; int retry_delay = 10; // 初始重试延迟为10秒 while (true) { SetDeviceState(kDeviceStateActivating); auto display = Board::GetInstance().GetDisplay(); display->SetStatus(Lang::Strings::CHECKING_NEW_VERSION); //采用指数退避算法进行重试（初始 10 秒，每次翻倍） //最多重试 10 次，防止无限循环 if (!ota_.CheckVersion()) { retry_count++; if (retry_count >= MAX_RETRY) { ESP_LOGE(TAG, "Too many retries, exit version check"); return; } char buffer[128]; //snprintf 是 C 语言标准库中的一个函数，用于将格式化的数据写入字符串。 //它是 sprintf 的安全版本，通过指定缓冲区大小来避免缓冲区溢出的风险。 snprintf(buffer, sizeof(buffer), Lang::Strings::CHECK_NEW_VERSION_FAILED, retry_delay, ota_.GetCheckVersionUrl().c_str()); Alert(Lang::Strings::ERROR, buffer, "sad", Lang::Sounds::P3_EXCLAMATION); //LOG这里使用了TAG ESP_LOGW(TAG, "Check new version failed, retry in %d seconds (%d/%d)", retry_delay, retry_count, MAX_RETRY); for (int i = 0; i < retry_delay; i++) { //pdMS_TO_TICKS()：这是 FreeRTOS 提供的标准宏，用于将毫秒转换为时钟节拍数。，精确延迟一秒 vTaskDelay(pdMS_TO_TICKS(1000)); if (device_state_ == kDeviceStateIdle) { break; } } retry_delay *= 2; // 每次重试后延迟时间翻倍，退避算法在这里 continue; } retry_count = 0; retry_delay = 10; // 重置重试延迟时间 //如果有新版本，用于检测并设置设备升级状态 //先设置DeviceState，然后设置显示ICON，再输出屏幕message // // // if (ota_.HasNewVersion()) { Alert(Lang::Strings::OTA_UPGRADE, Lang::Strings::UPGRADING, "happy", Lang::Sounds::P3_UPGRADE); vTaskDelay(pdMS_TO_TICKS(3000)); //设置设备状态 SetDeviceState(kDeviceStateUpgrading); //设置屏显状态 display->SetIcon(FONT_AWESOME_DOWNLOAD); std::string message = std::string(Lang::Strings::NEW_VERSION) + ota_.GetFirmwareVersion(); display->SetChatMessage("system", message.c_str()); // 准备升级环境，boadinstance我要看一下 auto& board = Board::GetInstance(); //关闭省电模式和语音监听，避免中途断电变砖 board.SetPowerSaveMode(false); #if CONFIG_USE_WAKE_WORD_DETECT wake_word_detect_.StopDetection(); #endif // 预先关闭音频输出，避免升级过程有音频操作 auto codec = board.GetAudioCodec(); codec->EnableInput(false); codec->EnableOutput(false); // 清空音频解码队列 { std::lock_guard<std::mutex> lock(mutex_); audio_decode_queue_.clear(); } // 等待后台任务完成并释放资源 background_task_->WaitForCompletion(); delete background_task_; background_task_ = nullptr; vTaskDelay(pdMS_TO_TICKS(1000)); // 执行升级，显示进度，这里居然是个lambda写法 要看一下这个ota_了 ota_.StartUpgrade([display](int progress, size_t speed) { char buffer[64]; snprintf(buffer, sizeof(buffer), "%d%% %zuKB/s", progress, speed / 1024); display->SetChatMessage("system", buffer); }); //成功以后升级设备 // If upgrade success, the device will reboot and never reach here display->SetStatus(Lang::Strings::UPGRADE_FAILED); ESP_LOGI(TAG, "Firmware upgrade failed..."); vTaskDelay(pdMS_TO_TICKS(3000)); Reboot(); return; } //没有新版本标记当前版本为valid ota_.MarkCurrentVersionValid(); if (!ota_.HasActivationCode() && !ota_.HasActivationChallenge()) {、 // xEventGroupSetBits(event_group_, CHECK_NEW_VERSION_DONE_EVENT); //推出循环如果检测到新版本 break; } display->SetStatus(Lang::Strings::ACTIVATION); // Activation code is shown to the user and waiting for the user to input // 激活码处理，对用户显示激活码，并且等待用户输入 if (ota_.HasActivationCode()) { ShowActivationCode(); } // This will block the loop until the activation is done or timeout // 设备激活逻辑 for (int i = 0; i < 10; ++i) { ESP_LOGI(TAG, "Activating... %d/%d", i + 1, 10); esp_err_t err = ota_.Activate(); if (err == ESP_OK) { xEventGroupSetBits(event_group_, CHECK_NEW_VERSION_DONE_EVENT); break; } else if (err == ESP_ERR_TIMEOUT) { vTaskDelay(pdMS_TO_TICKS(3000)); } else { vTaskDelay(pdMS_TO_TICKS(10000)); } if (device_state_ == kDeviceStateIdle) { break; } } } }
触发事件任务
EventBits_t xEventGroupSetBits( EventGroupHandle_t xEventGroup, const EventBits_t uxBitsToSet ); 参数： xEventGroup：要操作的事件标志组的句柄。 uxBitsToClear：指定要置 1 的事件位，比如要将 bit3 值 1 的话就设置为 0X08。可以同时将多个 bit 置 1，如设置为 0X09 的话就是同时将 bit3 和 bit0 置 1。 返回值： 任何值：在将指定事件位置 1 后的事件组值。
这是一个激活码语音播报功能
void Application::ShowActivationCode() { auto& message = ota_.GetActivationMessage(); auto& code = ota_.GetActivationCode(); //digit_sounds 数组使用了 std::string_view 引用，但存储的是 Lang::Sounds::P3_X 这些静态字符串。直接存储字符串字面量会更高效 struct digit_sound { char digit; const std::string_view& sound; }; static const std::array<digit_sound, 10> digit_sounds{{ digit_sound{'0', Lang::Sounds::P3_0}, digit_sound{'1', Lang::Sounds::P3_1}, digit_sound{'2', Lang::Sounds::P3_2}, digit_sound{'3', Lang::Sounds::P3_3}, digit_sound{'4', Lang::Sounds::P3_4}, digit_sound{'5', Lang::Sounds::P3_5}, digit_sound{'6', Lang::Sounds::P3_6}, digit_sound{'7', Lang::Sounds::P3_7}, digit_sound{'8', Lang::Sounds::P3_8}, digit_sound{'9', Lang::Sounds::P3_9} }}; // This sentence uses 9KB of SRAM, so we need to wait for it to finish Alert(Lang::Strings::ACTIVATION, message.c_str(), "happy", Lang::Sounds::P3_ACTIVATION); for (const auto& digit : code) { //find_if功能，再加一个lambda auto it = std::find_if(digit_sounds.begin(), digit_sounds.end(), [digit](const digit_sound& ds) { return ds.digit == digit; }); if (it != digit_sounds.end()) { PlaySound(it->sound); } } }
大量的std标准库算法，很有意思
里面包含一个PlaySound()这么一个function
Alert功能
void Application::Alert(const char* status, const char* message, const char* emotion, const std::string_view& sound) { ESP_LOGW(TAG, "Alert %s: %s [%s]", status, message, emotion); //这个getinstance不知道哪里来的 似乎是个全局变量 //获取display，然后设置display，并且playsound auto display = Board::GetInstance().GetDisplay(); display->SetStatus(status); display->SetEmotion(emotion); display->SetChatMessage("system", message); if (!sound.empty()) { ResetDecoder(); PlaySound(sound); } }
要看一下这个GetInstance哪里来的
在设备处于空闲状态时关闭警报的功能。
void Application::DismissAlert() { if (device_state_ == kDeviceStateIdle) { auto display = Board::GetInstance().GetDisplay(); display->SetStatus(Lang::Strings::STANDBY); display->SetEmotion("neutral"); display->SetChatMessage("system", ""); } }
这段代码实现了播放声音的功能，主要逻辑是将二进制协议 mp3 格式的音频数据解析并加入解码队列
void Application::PlaySound(const std::string_view& sound) { // 等待之前的声音播放完成 { std::unique_lock<std::mutex> lock(mutex_); //大量使用lambda audio_decode_cv_.wait(lock, [this]() { return audio_decode_queue_.empty(); }); } background_task_->WaitForCompletion(); // The assets are encoded at 16000Hz, 60ms frame duration //资产被编码为16K 60ms的frame停止，设置解码方式 SetDecodeSampleRate(16000, 60); const char* data = sound.data(); size_t size = sound.size(); //循环加载数据包 for (const char* p = data; p < data + size; ) { auto p3 = (BinaryProtocol3*)p; p += sizeof(BinaryProtocol3); //ntohs 是一个计算机网络编程中的函数，全称为 "Network To Host Short"， //用于将 16 位无符号整数从网络字节序（大端序）转换为主机字节序（可能是大端序或小端序，取决于主机系统） auto payload_size = ntohs(p3->payload_size); //音频流数据包 AudioStreamPacket packet; packet.payload.resize(payload_size); //将MP3文件拷贝至音频流帧包内 memcpy(packet.payload.data(), p3->payload, payload_size); p += payload_size; //线程安全的数据队列操作 //自动管理互斥锁（mutex_）的生命周期，实现线程同步 std::lock_guard<std::mutex> lock(mutex_); //存储待解码的音频数据包，是多线程间共享的 “工作队列” //emplace_back：直接在队列尾部构造元素，避免额外拷贝。 //std::move：将 packet 的资源所有权转移给队列，避免深拷贝，提高性能。 audio_decode_queue_.emplace_back(std::move(packet)); } }
单纯的业务逻辑
void Application::ToggleChatState() { if (device_state_ == kDeviceStateActivating) { SetDeviceState(kDeviceStateIdle); return; } if (!protocol_) { ESP_LOGE(TAG, "Protocol not initialized"); return; } if (device_state_ == kDeviceStateIdle) { Schedule([this]() { SetDeviceState(kDeviceStateConnecting); if (!protocol_->OpenAudioChannel()) { return; } SetListeningMode(realtime_chat_enabled_ ? kListeningModeRealtime : kListeningModeAutoStop); }); } else if (device_state_ == kDeviceStateSpeaking) { Schedule([this]() { AbortSpeaking(kAbortReasonNone); }); } else if (device_state_ == kDeviceStateListening) { Schedule([this]() { protocol_->CloseAudioChannel(); }); } }
Schedule和protocol应该是自己实现的 需要自己看一下
也是纯业务逻辑
void Application::StartListening() { //如果是正在激活，直接返回 if (device_state_ == kDeviceStateActivating) { SetDeviceState(kDeviceStateIdle); return; } if (!protocol_) { ESP_LOGE(TAG, "Protocol not initialized"); return; } //如果是闲置，检查audiochannel状态 if (device_state_ == kDeviceStateIdle) { Schedule([this]() { if (!protocol_->IsAudioChannelOpened()) { SetDeviceState(kDeviceStateConnecting); if (!protocol_->OpenAudioChannel()) { return; } } SetListeningMode(kListeningModeManualStop); }); //如果是讲话中，停止讲话 } else if (device_state_ == kDeviceStateSpeaking) { Schedule([this]() { AbortSpeaking(kAbortReasonNone); SetListeningMode(kListeningModeManualStop); }); } }
停止监听，业务逻辑
void Application::StopListening() { //有效的状态列表 const std::array<int, 3> valid_states = { kDeviceStateListening, kDeviceStateSpeaking, kDeviceStateIdle, }; // If not valid, do nothing //如果不是有效的状态列表就什么都不做 if (std::find(valid_states.begin(), valid_states.end(), device_state_) == valid_states.end()) { return; } //scheduling 主要是protocol_的操作 Schedule([this]() { if (device_state_ == kDeviceStateListening) { protocol_->SendStopListening(); SetDeviceState(kDeviceStateIdle); } }); }
/** * 应用程序启动函数，初始化系统组件并启动主要功能 */ void Application::Start() { // 获取开发板实例并设置设备状态为启动中 auto& board = Board::GetInstance(); SetDeviceState(kDeviceStateStarting); /* 设置显示屏 */ auto display = board.GetDisplay(); /* 设置音频编解码器 */ auto codec = board.GetAudioCodec(); // 创建Opus解码器和编码器实例，设置采样率和通道数 //@@@这一段写得很精妙有趣 有待学习，这个包装器是从哪里来的？！！！！！！ opus_decoder_ = std::make_unique<OpusDecoderWrapper>(codec->output_sample_rate(), 1, OPUS_FRAME_DURATION_MS); opus_encoder_ = std::make_unique<OpusEncoderWrapper>(16000, 1, OPUS_FRAME_DURATION_MS); // 根据不同的条件设置Opus编码器复杂度 if (realtime_chat_enabled_) { ESP_LOGI(TAG, "实时聊天已启用，将Opus编码器复杂度设为0"); opus_encoder_->SetComplexity(0); } else if (board.GetBoardType() == "ml307") { ESP_LOGI(TAG, "检测到ML307开发板，将Opus编码器复杂度设为5"); opus_encoder_->SetComplexity(5); } else { ESP_LOGI(TAG, "检测到WiFi开发板，将Opus编码器复杂度设为3"); opus_encoder_->SetComplexity(3); } // 如果编解码器输入采样率不是16000Hz，则配置重采样器 if (codec->input_sample_rate() != 16000) { input_resampler_.Configure(codec->input_sample_rate(), 16000); reference_resampler_.Configure(codec->input_sample_rate(), 16000); } // 启动音频编解码器 codec->Start(); // 创建音频处理任务，根据配置决定是否固定到特定CPU核心 #if CONFIG_USE_AUDIO_PROCESSOR //@@@在特定核心上启动task xTaskCreatePinnedToCore([](void* arg) { Application* app = (Application*)arg; app->AudioLoop(); // 音频处理主循环 vTaskDelete(NULL); }, "audio_loop", 4096 * 2, this, 8, &audio_loop_task_handle_, 1); #else xTaskCreate([](void* arg) { Application* app = (Application*)arg; app->AudioLoop(); // 音频处理主循环 vTaskDelete(NULL); }, "audio_loop", 4096 * 2, this, 8, &audio_loop_task_handle_); #endif //@@@@@@@@@@@@@网络部分 /* 等待网络准备就绪 */ board.StartNetwork(); // 检查新版本固件或获取MQTT代理地址 CheckNewVersion(); // 初始化通信协议，根据配置选择MQTT或WebSocket display->SetStatus(Lang::Strings::LOADING_PROTOCOL); if (ota_.HasMqttConfig()) { protocol_ = std::make_unique<MqttProtocol>(); } else if (ota_.HasWebsocketConfig()) { protocol_ = std::make_unique<WebsocketProtocol>(); } else { ESP_LOGW(TAG, "OTA配置中未指定协议，使用MQTT"); protocol_ = std::make_unique<MqttProtocol>(); } // 设置协议事件回调函数 // 网络错误回调 protocol_->OnNetworkError([this](const std::string& message) { SetDeviceState(kDeviceStateIdle); Alert(Lang::Strings::ERROR, message.c_str(), "sad", Lang::Sounds::P3_EXCLAMATION); }); // 音频数据接收回调 protocol_->OnIncomingAudio([this](AudioStreamPacket&& packet) { const int max_packets_in_queue = 600 / OPUS_FRAME_DURATION_MS; std::lock_guard<std::mutex> lock(mutex_); // 限制解码队列大小，防止内存溢出 if (audio_decode_queue_.size() < max_packets_in_queue) { audio_decode_queue_.emplace_back(std::move(packet)); } }); // 音频通道打开回调 protocol_->OnAudioChannelOpened([this, codec, &board]() { board.SetPowerSaveMode(false); // 关闭节能模式 // 检查服务器采样率与设备输出采样率是否匹配 if (protocol_->server_sample_rate() != codec->output_sample_rate()) { ESP_LOGW(TAG, "服务器采样率 %d 与设备输出采样率 %d 不匹配，重采样可能导致失真", protocol_->server_sample_rate(), codec->output_sample_rate()); } SetDecodeSampleRate(protocol_->server_sample_rate(), protocol_->server_frame_duration()); // 如果启用了小智协议，发送设备描述符和状态 #if CONFIG_IOT_PROTOCOL_XIAOZHI auto& thing_manager = iot::ThingManager::GetInstance(); protocol_->SendIotDescriptors(thing_manager.GetDescriptorsJson()); std::string states; if (thing_manager.GetStatesJson(states, false)) { protocol_->SendIotStates(states); } #endif }); // 音频通道关闭回调 protocol_->OnAudioChannelClosed([this, &board]() { board.SetPowerSaveMode(true); // 开启节能模式 Schedule([this]() { auto display = Board::GetInstance().GetDisplay(); display->SetChatMessage("system", ""); // 清空聊天消息 SetDeviceState(kDeviceStateIdle); // 设置设备状态为空闲 }); }); // JSON消息接收回调，处理各种类型的消息 protocol_->OnIncomingJson([this, display](const cJSON* root) { // 解析JSON数据 auto type = cJSON_GetObjectItem(root, "type"); // 处理TTS(文本转语音)消息 if (strcmp(type->valuestring, "tts") == 0) { auto state = cJSON_GetObjectItem(root, "state"); if (strcmp(state->valuestring, "start") == 0) { Schedule([this]() { aborted_ = false; if (device_state_ == kDeviceStateIdle || device_state_ == kDeviceStateListening) { SetDeviceState(kDeviceStateSpeaking); // 设置设备状态为"说话中" } }); } else if (strcmp(state->valuestring, "stop") == 0) { Schedule([this]() { background_task_->WaitForCompletion(); if (device_state_ == kDeviceStateSpeaking) { // 根据监听模式设置下一个状态 if (listening_mode_ == kListeningModeManualStop) { SetDeviceState(kDeviceStateIdle); } else { SetDeviceState(kDeviceStateListening); } } }); } else if (strcmp(state->valuestring, "sentence_start") == 0) { auto text = cJSON_GetObjectItem(root, "text"); if (cJSON_IsString(text)) { ESP_LOGI(TAG, "<< %s", text->valuestring); Schedule([this, display, message = std::string(text->valuestring)]() { display->SetChatMessage("assistant", message.c_str()); // 在显示屏上显示回答 }); } } } // 处理STT(语音转文本)消息 else if (strcmp(type->valuestring, "stt") == 0) { auto text = cJSON_GetObjectItem(root, "text"); if (cJSON_IsString(text)) { ESP_LOGI(TAG, ">> %s", text->valuestring); Schedule([this, display, message = std::string(text->valuestring)]() { display->SetChatMessage("user", message.c_str()); // 在显示屏上显示用户输入 }); } } // 处理LLM(大语言模型)消息 else if (strcmp(type->valuestring, "llm") == 0) { auto emotion = cJSON_GetObjectItem(root, "emotion"); if (cJSON_IsString(emotion)) { Schedule([this, display, emotion_str = std::string(emotion->valuestring)]() { display->SetEmotion(emotion_str.c_str()); // 设置表情 }); } } // 处理MCP协议消息(如果启用) #if CONFIG_IOT_PROTOCOL_MCP else if (strcmp(type->valuestring, "mcp") == 0) { auto payload = cJSON_GetObjectItem(root, "payload"); if (cJSON_IsObject(payload)) { McpServer::GetInstance().ParseMessage(payload); // 解析MCP消息 } #endif // 处理IoT协议消息(如果启用) #if CONFIG_IOT_PROTOCOL_XIAOZHI else if (strcmp(type->valuestring, "iot") == 0) { auto commands = cJSON_GetObjectItem(root, "commands"); if (cJSON_IsArray(commands)) { auto& thing_manager = iot::ThingManager::GetInstance(); // 执行所有IoT命令 for (int i = 0; i < cJSON_GetArraySize(commands); ++i) { auto command = cJSON_GetArrayItem(commands, i); thing_manager.Invoke(command); } } #endif // 处理系统命令 else if (strcmp(type->valuestring, "system") == 0) { auto command = cJSON_GetObjectItem(root, "command"); if (cJSON_IsString(command)) { ESP_LOGI(TAG, "系统命令: %s", command->valuestring); if (strcmp(command->valuestring, "reboot") == 0) { // 如果用户请求OTA更新，则重启设备 Schedule([this]() { Reboot(); }); } else { ESP_LOGW(TAG, "未知系统命令: %s", command->valuestring); } } } // 处理警告消息 //@@@@@@@CJSON这个库也要看看，在根级别上获取object else if (strcmp(type->valuestring, "alert") == 0) { auto status = cJSON_GetObjectItem(root, "status"); auto message = cJSON_GetObjectItem(root, "message"); auto emotion = cJSON_GetObjectItem(root, "emotion"); if (cJSON_IsString(status) && cJSON_IsString(message) && cJSON_IsString(emotion)) { Alert(status->valuestring, message->valuestring, emotion->valuestring, Lang::Sounds::P3_VIBRATION); } else { ESP_LOGW(TAG, "警告命令需要status、message和emotion字段"); } } }); // 启动通信协议 bool protocol_started = protocol_->Start(); // 初始化音频处理器，设置音频输出和VAD(语音活动检测)回调 audio_processor_->Initialize(codec); audio_processor_->OnOutput([this](std::vector<int16_t>&& data) { background_task_->Schedule([this, data = std::move(data)]() mutable { if (protocol_->IsAudioChannelBusy()) { return; } // 编码音频数据并发送 opus_encoder_->Encode(std::move(data), [this](std::vector<uint8_t>&& opus) { AudioStreamPacket packet; packet.payload = std::move(opus); #ifdef CONFIG_USE_SERVER_AEC { std::lock_guard<std::mutex> lock(timestamp_mutex_); // 处理时间戳队列，用于回声消除 if (!timestamp_queue_.empty()) { packet.timestamp = timestamp_queue_.front(); timestamp_queue_.pop_front(); } else { packet.timestamp = 0; } if (timestamp_queue_.size() > 3) { // 限制队列长度3 timestamp_queue_.pop_front(); // 该包发送前先出队保持队列长度 return; } } #endif //这个stdmove有点意思 Schedule([this, packet = std::move(packet)]() { protocol_->SendAudio(packet); // 发送音频包 }); }); }); }); // VAD状态变化回调，更新LED状态 audio_processor_->OnVadStateChange([this](bool speaking) { if (device_state_ == kDeviceStateListening) { Schedule([this, speaking]() { voice_detected_ = speaking; // 更新语音检测状态 auto led = Board::GetInstance().GetLed(); led->OnStateChanged(); // 更新LED状态 }); } }); // 如果启用唤醒词检测，初始化并启动检测 #if CONFIG_USE_WAKE_WORD_DETECT wake_word_detect_.Initialize(codec); wake_word_detect_.OnWakeWordDetected([this](const std::string& wake_word) { Schedule([this, &wake_word]() { if (device_state_ == kDeviceStateIdle) { SetDeviceState(kDeviceStateConnecting); wake_word_detect_.EncodeWakeWordData(); // 打开音频通道并发送唤醒词数据 if (!protocol_ || !protocol_->OpenAudioChannel()) { wake_word_detect_.StartDetection(); return; } AudioStreamPacket packet; // 编码并发送唤醒词数据到服务器 while (wake_word_detect_.GetWakeWordOpus(packet.payload)) { protocol_->SendAudio(packet); } // 通知服务器唤醒词已检测到 protocol_->SendWakeWordDetected(wake_word); ESP_LOGI(TAG, "检测到唤醒词: %s", wake_word.c_str()); // 设置监听模式 SetListeningMode(realtime_chat_enabled_ ? kListeningModeRealtime : kListeningModeAutoStop); } else if (device_state_ == kDeviceStateSpeaking) { AbortSpeaking(kAbortReasonWakeWordDetected); // 中断当前语音播放 } else if (device_state_ == kDeviceStateActivating) { SetDeviceState(kDeviceStateIdle); // 设置设备状态为空闲 } }); }); wake_word_detect_.StartDetection(); // 开始唤醒词检测 #endif // 等待新版本检查完成 //@@@要注意这个groupwaitbits！！！ xEventGroupWaitBits(event_group_, CHECK_NEW_VERSION_DONE_EVENT, pdTRUE, pdFALSE, portMAX_DELAY); SetDeviceState(kDeviceStateIdle); // 设置设备状态为空闲 // 如果协议启动成功，显示版本信息并播放成功提示音 if (protocol_started) { std::string message = std::string(Lang::Strings::VERSION) + ota_.GetCurrentVersion(); display->ShowNotification(message.c_str()); display->SetChatMessage("system", ""); // 重置解码器并播放成功提示音 ResetDecoder(); PlaySound(Lang::Sounds::P3_SUCCESS); } // 进入主事件循环 MainEventLoop(); }
该函数不可在中断中调用 // 返回值 EventBits_t xEventGroupWaitBits(const EventGroupHandle_t xEventGroup,//事件组句柄 const EventBits_t uxBitsToWaitFor,//设置需要检查哪些二进制位，此处输入十六进制 const BaseType_t xClearOnExit,//如果设为pdTRUE，退出时清零对应位 const BaseType_t xWaitForAllBits,//设置等待事件组中的位同时(AND)满足或任意一位(OR)满足 TickType_t xTicksToWait);//设置阻塞等待时间 可以看到运行时当task2将0或者4置为1时，任务1才会解除阻塞 ------------- task1 begin to wait ------------- task2 begin set bit0 ------------- In task1, BIT_0 or BIT_4 is set ------------- task1 begin to wait ------------- task2 begin set bit0 ------------- In task1, BIT_0 or BIT_4 is set ------------- task1 begin to wait ------------- task2 begin set bit0 -------------
xEventGroupWaitBits()，通过这个函数， 任务可以知道事件标志组中的哪些位，有什么事件发生了， 然后通过 “逻辑与”、“逻辑或”等操作对感兴趣的事件进行获取，并且这个函数实现了等待超时机制， 当且仅当任务等待的事件发生时，任务才能获取到事件信息。在这段时间中，如果事件一直没发生，该任务将保持阻塞状态以等待事件发生。当其它任务或中断服务程序往其等待的事件设置对应的标志位，该任务将自动由阻塞态转为就绪态。当任务等待的时间超过了指定的阻塞时间，即使事件还未发生，任务也会自动从阻塞态转移为就绪态。这样子很有效的体现了操作系统的实时性，如果事件正确获取（等待到） 则返回对应的事件标志位，由用户判断再做处理， 因为在事件超时的时候也会返回一个不能确定的事件值，所以需要判断任务所等待的事件是否真的发生。
EventGroupWaitBits()用于获取事件组中的一个或多个事件发生标志， 当要读取的事件标 志 位 没 有 被 置 位 时 任 务 将 进 入 阻 塞 等 待 状 态 。
看完了其它实现这里还要再返回来看看
void Application::OnClockTimer() { clock_ticks_++; // 1. 时钟滴答计数器自增 // Print the debug info every 10 seconds //// 2. 条件判断：每 3 个滴答周期执行一次（需结合定时器周期计算实际时间间隔） if (clock_ticks_ % 3 == 0) { // char buffer[500]; // vTaskList(buffer); // ESP_LOGI(TAG, "Task list: \n%s", buffer); // SystemInfo::PrintRealTimeStats(pdMS_TO_TICKS(1000)); //用于定时监控内存情况，避免内存泄露或者碎片化 //heap_caps_get_free_size：返回当前指定类型内存的剩余字节数。 要返回仔细研读一下文档 int free_sram = heap_caps_get_free_size(MALLOC_CAP_INTERNAL); //返回自上次调用 heap_caps_reset_minimum_free_size 以来的最小剩余字节数 int min_free_sram = heap_caps_get_minimum_free_size(MALLOC_CAP_INTERNAL); ESP_LOGI(TAG, "Free internal: %u minimal internal: %u", free_sram, min_free_sram); // If we have synchronized server time, set the status to clock "HH:MM" if the device is idle // if (ota_.HasServerTime()) { // 6. 检查是否已同步服务器时间（通过 OTA 模块） if (device_state_ == kDeviceStateIdle) { // 7. 检查设备状态是否为空闲 Schedule([this]() { // 8. 异步调度 Lambda 函数更新显示屏（避免阻塞定时器回调） // Set status to clock "HH:MM" time_t now = time(NULL); // 9. 获取当前系统时间（从服务器同步而来） char time_str[64]; // 10. 格式化时间字符串为 "HH:MM "（末尾空格可能用于填充显示区域） strftime(time_str, sizeof(time_str), "%H:%M ", localtime(&now)); // 11. 更新显示屏状态 Board::GetInstance().GetDisplay()->SetStatus(time_str); }); } } } }
1 ESP32的SDK对于heap部分管理的源码位于路径\esp-idf-v3.0-rc1\components\heap下，可以简单的认为分为两层：heap_caps_init.c与heap_caps.c构成一层函数接口封装；multi_heap.c等文件内是具体函数接口的实现。主要接口： 3 Heap初始化: voidheap_caps_init(void) 5 Heap分配: void *heap_caps_malloc( size_t size,uint32_t caps ) 7 Heap释放: void heap_caps_free(void *ptr) 9 ESP32 SDK中的malloc/calloc/free等系统调用，最终都是调用以上函数执行(参见syscall_stub_table)。
1. 函数功能 核心作用：返回具有指定内存属性（caps）的所有内存区域的总空闲字节数。 参数说明： uint32_t caps：内存属性标志，用于指定要查询的内存类型（例如内部 RAM、外部 PSRAM 或特定对齐要求）。 常用标志包括 MALLOC_CAP_INTERNAL（内部 RAM）、MALLOC_CAP_SPIRAM（外部 SPI RAM）、MALLOC_CAP_8BIT（8 位对齐内存）等 2. 典型应用场景 内存监控：在初始化模块（如 Wi-Fi、蓝牙）前后调用该函数，对比内存变化以分析模块内存占用10。 优化分配策略：结合 heap_caps_get_largest_free_block()，评估内存碎片情况，决定是否调整分配策略。 多类型内存管理：区分内部与外部 RAM 使用情况，例如当外部 RAM 启用时，可通过 MALLOC_CAP_SPIRAM 单独查询其空闲容量 3. 相关函数对比 esp_get_free_heap_size()：返回默认堆（通常是内部 RAM）的空闲内存，等同于 heap_caps_get_free_size(MALLOC_CAP_DEFAULT)710。 esp_get_minimum_free_heap_size()：返回系统启动以来内部堆的最小空闲值，用于监控内存泄漏710。 heap_caps_print_heap_info()：打印详细内存分布信息，帮助定位碎片或特定内存区域的占用210。
1. 函数功能 核心作用：返回指定内存类型（由 caps 参数定义）自系统启动以来的最小空闲内存值。该值反映了内存使用的“最低点”，可用于评估内存泄漏或长期内存占用趋势1。 参数说明： uint32_t caps：内存属性标志，例如 MALLOC_CAP_INTERNAL（内部 RAM）、MALLOC_CAP_SPIRAM（外部 SPI RAM）等。支持组合多个标志位以筛选特定内存类型1。 2. 典型应用场景 内存泄漏检测 通过周期性调用该函数，对比最小值的变化。若最小值持续下降，可能表明存在内存泄漏。例如，在初始化模块后记录初始值，长期运行后检查是否显著减少1。 系统内存压力评估 结合 heap_caps_get_free_size()（当前空闲内存）和 heap_caps_get_largest_free_block()（最大连续空闲块），分析内存碎片化情况。若当前空闲内存充足但最小值较低，可能提示历史内存压力较大13。 多类型内存监控 区分内部 RAM 和外部 SPI RAM 的使用情况。例如，启用外部 RAM 后，可通过 MALLOC_CAP_SPIRAM 监控其最小空闲值，确保大容量数据处理时内存充足28。 3. 相关函数对比 函数名称 功能描述 适用场景 heap_caps_get_free_size() 返回当前指定内存类型的空闲内存总量 实时内存状态监控 heap_caps_get_minimum_free_size() 返回历史最小空闲内存值 长期内存泄漏检测 esp_get_minimum_free_heap_size() 默认堆（通常为内部 RAM）的历史最小值，等同于 heap_caps_get_minimum_free_size(MALLOC_CAP_DEFAULT) 快速获取默认堆的“低水位线” heap_caps_get_info() 返回包含详细堆信息的 multi_heap_info_t 结构体（如分配次数、空闲块数等） 深度分析堆状态与碎片化情况
该函数用于异步调度任务到主循环（MainLoop）中执行，实现线程间的任务传递。具体流程为：
这个函数大量调用，非常重要！！！
void Application::Schedule(std::function<void()> callback) { { std::lock_guard<std::mutex> lock(mutex_); // 1. 加锁保护任务队列 main_tasks_.push_back(std::move(callback)); // 2. 将回调函数移动到任务队列尾部 } // 3. 锁在此处释放（离开作用域） xEventGroupSetBits(event_group_, SCHEDULE_EVENT); // 4. 设置事件组标志位，触发主循环处理任务
非常重要的第二个部分！！！
void Application::MainEventLoop() { while (true) { // 1. 等待 SCHEDULE_EVENT 事件，永久阻塞直到事件触发 auto bits = xEventGroupWaitBits(event_group_, SCHEDULE_EVENT, pdTRUE, pdFALSE, portMAX_DELAY); if (bits & SCHEDULE_EVENT) { // 2. 确认事件类型（实际可省略，因仅等待 SCHEDULE_EVENT） // 3. 加锁并转移任务队列所有权（减少锁持有时间） std::unique_lock<std::mutex> lock(mutex_); std::list<std::function<void()>> tasks = std::move(main_tasks_); lock.unlock(); // 4. 执行所有转移的任务（在锁外执行，避免阻塞其他线程添加新任务） for (auto& task : tasks) { task(); } } } }
音频事件循环，但是不知道是如何调度的
void Application::AudioLoop() { auto codec = Board::GetInstance().GetAudioCodec(); // 1. 获取音频编解码器实例 while (true) { OnAudioInput(); // 2. 处理音频输入（如麦克风采集） if (codec->output_enabled()) { // 3. 检查音频输出是否启用 OnAudioOutput(); // 4. 处理音频输出（如扬声器播放） } } }
void Application::OnAudioOutput() { if (busy_decoding_audio_) { // 1. 避免并发解码 return; } auto now = std::chrono::steady_clock::now(); auto codec = Board::GetInstance().GetAudioCodec(); const int max_silence_seconds = 10; std::unique_lock<std::mutex> lock(mutex_); if (audio_decode_queue_.empty()) { // 2. 处理队列空的情况 if (device_state_ == kDeviceStateIdle && now - last_output_time_ > std::chrono::seconds(max_silence_seconds)) { codec->EnableOutput(false); // 长时间静音则禁用输出 } return; } if (device_state_ == kDeviceStateListening) { // 3. 监听状态下清空队列 audio_decode_queue_.clear(); audio_decode_cv_.notify_all(); return; } // 4. 取出待解码的数据包 auto packet = std::move(audio_decode_queue_.front()); audio_decode_queue_.pop_front();
//不知道这个锁是哪里来的 lock.unlock(); audio_decode_cv_.notify_all(); // 5. 异步调度解码任务 busy_decoding_audio_ = true; background_task_->Schedule([this, codec, packet = std::move(packet)]() mutable { busy_decoding_audio_ = false; if (aborted_) return; // 6. 解码 OPUS 数据 std::vector<int16_t> pcm; if (!opus_decoder_->Decode(std::move(packet.payload), pcm)) { return; } // 7. 采样率转换（如果需要） if (opus_decoder_->sample_rate() != codec->output_sample_rate()) { pcm = output_resampler_.Process(pcm); } // 8. 输出音频数据 codec->OutputData(pcm); // 9. 记录时间戳（用于回声消除） #ifdef CONFIG_USE_SERVER_AEC std::lock_guard<std::mutex> lock(timestamp_mutex_); timestamp_queue_.push_back(packet.timestamp); last_output_timestamp_ = packet.timestamp; #endif last_output_time_ = std::chrono::steady_clock::now(); }); }
audio_decode_cv_
这些都是来自自由的codec库，不知道哪里来的
所以回来再看看audio_processing/wake_word_detect，这个是基于 esp32 官方的esp-sr实现的唤醒词检测功能，不过坑爹的是，乐鑫只提供了固定的 20 多个唤醒词，如果需要自定义的话，要找乐鑫的销售付费才行。
-
audio_codec/audio_codec，音频解码器的基类，负责与 i2s 设备通信 -
on_sent，调用 on_output_ready
-
on_recv, 调用 on_input_ready
-
audio_codec/no_audio_codec一个空类 -
audio_codec/*这几个都是调用了esp_codec_dev 库，太多了，回头再看。
audioinput，处理audio输入的
这个函数可以看作是音频处理的“主心跳”或“事件入口”。每当系统需要处理新的音频输入时，这个函数就会被调用。它的核心职责是决定当前接收到的音频数据应该被送往何处进行处理。
代码功能详解
此函数建立了一个清晰的优先级处理流程：优先处理唤醒词检测，其次再进行常规的音频处理。
常规音频处理逻辑
空闲等待
// 音频输入事件处理函数。它就像一个音频数据分发中心。 void Application::OnAudioInput() { // 这是一个编译时开关。只有在配置中启用了“使用唤醒词检测”功能时，下面的代码才会被编译进去。 #if CONFIG_USE_WAKE_WORD_DETECT // 首先，检查唤醒词检测引擎是否正在运行。 if (wake_word_detect_.IsDetectionRunning()) { // 创建一个 vector 用于存放音频数据 std::vector<int16_t> data; // 获取唤醒词引擎当前需要处理的音频样本数量。 int samples = wake_word_detect_.GetFeedSize(); // 如果需要的数据量大于0 if (samples > 0) { // 调用我们之前分析过的 ReadAudio 函数，读取指定数量的样本，并确保其采样率为 16000Hz。 ReadAudio(data, 16000, samples); // 将读取到的音频数据“喂”给唤醒词引擎进行分析。 wake_word_detect_.Feed(data); // 处理完唤醒词就直接返回，本轮不再执行后续的常规音频处理，以确保逻辑的唯一性。 return; } } #endif // 结束编译时开关 // 如果唤醒词逻辑没有执行（或被禁用），则检查常规音频处理器是否正在运行。 if (audio_processor_->IsRunning()) { std::vector<int16_t> data; // 获取常规音频处理器需要的数据量。 int samples = audio_processor_->GetFeedSize(); if (samples > 0) { // 同样，读取 16000Hz 采样率的音频数据。 ReadAudio(data, 16000, samples); // 将数据“喂”给常规音频处理器（例如，用于识别语音指令）。 audio_processor_->Feed(data); // 处理完后直接返回。 return; } } // 如果上述两个处理器（唤醒词和常规音频）都未请求数据，则任务暂停30毫秒。 // pdMS_TO_TICKS() 是 FreeRTOS 的一个宏，用于将毫秒转换为操作系统的“时间片刻度(ticks)”。 // 这样做是为了防止CPU在没有任务时空转，可以节省功耗，并让操作系统调度其他任务。 vTaskDelay(pdMS_TO_TICKS(30)); }
好的，这段 C++ 代码 Application::ReadAudio 的主要功能是从音频编解码器（Audio Codec）读取音频数据，并确保最终输出的音频数据符合指定的采样率（sample rate）。
如果硬件本身提供的采样率与要求的不同，这段代码会自动执行采样率转换（Resampling）。
// 定义 Application 类中的 ReadAudio 方法 // - data: 一个 vector 引用，用于存放最终的音频数据 (16位整数) // - sample_rate: 应用程序期望得到的音频采样率 (例如 16000 Hz) // - samples: 应用程序期望读取的样本数量 void Application::ReadAudio(std::vector<int16_t>& data, int sample_rate, int samples) { // 从单例 Board 对象中获取音频编解码器 (Codec) 的实例 auto codec = Board::GetInstance().GetAudioCodec(); // 检查硬件 Codec 的原始输入采样率是否与我们要求的 sample_rate 不同 if (codec->input_sample_rate() != sample_rate) { // --- 如果采样率不同，就需要进行重采样 (Resampling) --- // 根据目标样本数和采样率的比例，计算需要从原始 Codec 读取多少样本 // 例如：目标要 160 个 16kHz 的样本，而源是 48kHz，则需读取 160 * 48000 / 16000 = 480 个样本 data.resize(samples * codec->input_sample_rate() / sample_rate); // 从 Codec 读取原始音频数据到 data 中 if (!codec->InputData(data)) { return; // 如果读取失败，直接返回 } // 检查原始音频的声道数是否为 2 (立体声) if (codec->input_channels() == 2) { // --- 处理立体声音频的重采样 --- // 创建两个新的 vector 来分别存放分离出来的左声道(麦克风)和右声道(参考) auto mic_channel = std::vector<int16_t>(data.size() / 2); auto reference_channel = std::vector<int16_t>(data.size() / 2); // 遍历原始的交错式(interleaved)立体声数据，将其分离 (de-interleave) // 交错式数据通常是 [左1, 右1, 左2, 右2, ...] for (size_t i = 0, j = 0; i < mic_channel.size(); ++i, j += 2) { mic_channel[i] = data[j]; // 偶数索引是麦克风声道 reference_channel[i] = data[j + 1]; // 奇数索引是参考声道 } // 准备存放重采样后数据的 vector auto resampled_mic = std::vector<int16_t>(input_resampler_.GetOutputSamples(mic_channel.size())); auto resampled_reference = std::vector<int16_t>(reference_resampler_.GetOutputSamples(reference_channel.size())); // 分别对两个声道执行重采样 input_resampler_.Process(mic_channel.data(), mic_channel.size(), resampled_mic.data()); reference_resampler_.Process(reference_channel.data(), reference_channel.size(), resampled_reference.data()); // 重新调整 data 的大小，以容纳重采样后合并的立体声数据 data.resize(resampled_mic.size() + resampled_reference.size()); // 将重采样后的两个声道重新交错合并回 data vector for (size_t i = 0, j = 0; i < resampled_mic.size(); ++i, j += 2) { data[j] = resampled_mic[i]; data[j + 1] = resampled_reference[i]; } } else { // --- 处理单声道 (Mono) 音频的重采样 --- // 准备一个 vector 来存放重采样后的数据 auto resampled = std::vector<int16_t>(input_resampler_.GetOutputSamples(data.size())); // 执行重采样 input_resampler_.Process(data.data(), data.size(), resampled.data()); // 使用 std::move 高效率地将重采样后的结果赋值给 data，避免不必要的复制 data = std::move(resampled); } } else { // --- 如果采样率相同，则无需重采样 --- // 直接将 data 的大小设置为所需的样本数 data.resize(samples); // 从 Codec 直接读取指定数量的音频样本 if (!codec->InputData(data)) { return; // 如果读取失败，直接返回 } } }
void Application::AbortSpeaking(AbortReason reason) { // 使用 ESP-IDF 的日志宏记录一条信息，表示正在中止语音播放。 // TAG 是一个通常用于标识日志来源的字符串（例如："Application"）。 ESP_LOGI(TAG, "Abort speaking"); // 将成员变量 aborted_ 设为 true，表示语音播放已被中止。 // 这个标志可能用于在其他地方检查当前是否有语音播放被中止。 aborted_ = true; // 通过 protocol_ 对象发送一个中止语音播放的命令。 // protocol_ 可能是一个指向通信协议类实例的指针，用于与外部设备或服务交互， // 告知它们停止当前的语音输出。 // reason 参数提供了中止语音播放的具体原因（例如：用户中断、新的命令）。 protocol_->SendAbortSpeaking(reason); } void Application::SetListeningMode(ListeningMode mode) { // 将成员变量 listening_mode_ 设置为传入的 mode 参数。 // ListeningMode 可能是一个枚举类型，定义了不同的监听模式（例如： // 持续监听、单次监听、禁用监听等）。 listening_mode_ = mode; // 调用 SetDeviceState 方法，将设备状态设置为 kDeviceStateListening。 // 这表明设备现在处于监听状态。 // kDeviceStateListening 可能是一个常量或枚举值，代表设备的特定状态。 // 这个方法可能负责更新设备的整体状态显示或行为。 SetDeviceState(kDeviceStateListening); }
这是纯粹业务逻辑了
最后一个重要功能
切换状态功能
void Application::SetDeviceState(DeviceState state) { // 如果当前设备状态与要设置的新状态相同，则直接返回，避免不必要的重复操作。 if (device_state_ == state) { return; } // 重置时钟计数器，这可能用于计时或状态持续时间计算。 clock_ticks_ = 0; // 保存当前设备状态，以便在状态切换时进行比较或执行特定逻辑。 auto previous_state = device_state_; // 更新设备状态为新传入的状态。 device_state_ = state; // 使用 ESP-IDF 的日志宏记录新的设备状态。 // STATE_STRINGS 应该是一个字符串数组或映射，用于将 DeviceState 枚举值转换为可读的字符串。 ESP_LOGI(TAG, "STATE: %s", STATE_STRINGS[device_state_]); // 状态已改变，等待所有后台任务完成，确保状态切换的原子性和避免竞态条件。 background_task_->WaitForCompletion(); // 获取 Board 单例的引用，Board 类可能提供了访问硬件组件的接口。 auto& board = Board::GetInstance(); // 获取显示屏接口。 auto display = board.GetDisplay(); // 获取 LED 灯接口。 auto led = board.GetLed(); // 通知 LED 灯状态已改变，可能触发 LED 灯效的变化。 led->OnStateChanged(); // 根据新的设备状态执行不同的操作。 switch (state) { // 未知状态或空闲状态。 case kDeviceStateUnknown: case kDeviceStateIdle: // 设置显示屏状态为“待机”。 display->SetStatus(Lang::Strings::STANDBY); // 设置显示屏情绪为“中性”。 display->SetEmotion("neutral"); // 停止音频处理器，可能意味着停止音频输入或输出流。 audio_processor_->Stop(); #if CONFIG_USE_WAKE_WORD_DETECT // 如果配置了使用唤醒词检测 // 启动唤醒词检测。 wake_word_detect_.StartDetection(); #endif break; // 连接状态。 case kDeviceStateConnecting: // 设置显示屏状态为“正在连接”。 display->SetStatus(Lang::Strings::CONNECTING); // 设置显示屏情绪为“中性”。 display->SetEmotion("neutral"); // 清空聊天消息显示。 display->SetChatMessage("system", ""); // 清空时间戳队列。 timestamp_queue_.clear(); // 重置上次输出时间戳。 last_output_timestamp_ = 0; break; // 监听状态（等待用户语音输入）。 case kDeviceStateListening: // 设置显示屏状态为“正在聆听”。 display->SetStatus(Lang::Strings::LISTENING); // 设置显示屏情绪为“中性”。 display->SetEmotion("neutral"); // 在发送开始监听命令之前更新 IoT 状态。 #if CONFIG_IOT_PROTOCOL_XIAOZHI // 如果配置了小米智联 IoT 协议 UpdateIotStates(); #endif // 确保音频处理器正在运行。 if (!audio_processor_->IsRunning()) { // 发送开始监听命令。 protocol_->SendStartListening(listening_mode_); // 如果是自动停止监听模式，并且之前处于语音播放状态，则等待扬声器缓冲区清空。 // FIXME: 这是一个待解决的问题，表示可能需要更精确的同步机制。 if (listening_mode_ == kListeningModeAutoStop && previous_state == kDeviceStateSpeaking) { vTaskDelay(pdMS_TO_TICKS(120)); // 延迟 120 毫秒。 } // 重置 Opus 编码器状态，准备新的音频编码。 opus_encoder_->ResetState(); #if CONFIG_USE_WAKE_WORD_DETECT // 如果配置了使用唤醒词检测 // 停止唤醒词检测。 wake_word_detect_.StopDetection(); #endif // 启动音频处理器。 audio_processor_->Start(); } break; // 语音播放状态。 case kDeviceStateSpeaking: // 设置显示屏状态为“正在说话”。 display->SetStatus(Lang::Strings::SPEAKING); // 如果监听模式不是实时模式。 if (listening_mode_ != kListeningModeRealtime) { // 停止音频处理器。 audio_processor_->Stop(); #if CONFIG_USE_WAKE_WORD_DETECT // 如果配置了使用唤醒词检测 // 启动唤醒词检测。 wake_word_detect_.StartDetection(); #endif } // 重置解码器状态，准备新的音频解码。 ResetDecoder(); break; // 默认情况，不执行任何操作。 default: // Do nothing break; } }
void Application::ResetDecoder() { // 创建一个互斥锁的 RAII (Resource Acquisition Is Initialization) 封装， // 在进入作用域时自动锁定 `mutex_`，在退出作用域时自动解锁。 // 这确保了对共享资源的线程安全访问，防止多个线程同时修改解码器状态。 std::lock_guard<std::mutex> lock(mutex_); // 重置 Opus 解码器的内部状态。 // 这会清除任何残留的解码上下文或缓冲区，确保解码器准备好处理新的音频帧。 opus_decoder_->ResetState(); // 清空音频解码队列。 // audio_decode_queue_ 可能存储着等待解码的音频数据。清空它会丢弃所有待处理的数据。 audio_decode_queue_.clear(); // 通知所有等待在 audio_decode_cv_ 条件变量上的线程。 // 这通常用于唤醒那些可能正在等待新数据加入队列的消费者线程， // 告知它们队列已被清空或状态已重置。 audio_decode_cv_.notify_all(); // 更新 last_output_time_ 为当前时间。 // 这可能用于同步音频播放、计算延迟或管理音频输出时间戳。 last_output_time_ = std::chrono::steady_clock::now(); // 获取 Board 单例的引用，Board 类可能提供了访问硬件组件（如音频编解码器）的接口。 auto codec = Board::GetInstance().GetAudioCodec(); // 启用音频编解码器的输出。 // 这确保了在解码器重置后，音频硬件能够正常播放解码后的音频。 codec->EnableOutput(true); }
void Application::SetDecodeSampleRate(int sample_rate, int frame_duration) { // 检查当前的 Opus 解码器采样率和帧持续时间是否与请求的值相同。 // 如果相同，则无需更改，直接返回，避免不必要的资源重新分配和配置。 if (opus_decoder_->sample_rate() == sample_rate && opus_decoder_->duration_ms() == frame_duration) { return; } // 重置（销毁）当前的 Opus 解码器对象。 // opus_decoder_ 是一个 std::unique_ptr，调用 reset() 会释放其管理的内存。 opus_decoder_.reset(); // 创建一个新的 Opus 解码器实例。 // 使用 std::make_unique 确保异常安全和正确的内存管理。 // 参数含义：sample_rate (采样率), 1 (声道数，这里是单声道), frame_duration (帧持续时间，毫秒)。 opus_decoder_ = std::make_unique<OpusDecoderWrapper>(sample_rate, 1, frame_duration); // 获取 Board 单例的引用，Board 类通常用于访问硬件组件（如音频编解码器）。 auto codec = Board::GetInstance().GetAudioCodec(); // 检查 Opus 解码器的采样率是否与音频编解码器的输出采样率不一致。 if (opus_decoder_->sample_rate() != codec->output_sample_rate()) { // 如果不一致，记录一条日志，表示将进行音频重采样。 ESP_LOGI(TAG, "Resampling audio from %d to %d", opus_decoder_->sample_rate(), codec->output_sample_rate()); // 配置输出重采样器。 // output_resampler_ 对象将负责将解码器输出的音频从其采样率转换为编解码器所需的输出采样率。 output_resampler_.Configure(opus_decoder_->sample_rate(), codec->output_sample_rate()); } }
void Application::UpdateIotStates() { #if CONFIG_IOT_PROTOCOL_XIAOZHI // 这是一个预处理指令，表示只有当 CONFIG_IOT_PROTOCOL_XIAOZHI 宏被定义时，下面的代码才会被编译。 // 这意味着这段代码是针对特定的“小智”物联网协议而设计的。 // 获取 iot::ThingManager 的单例实例。 // ThingManager 负责管理设备的各种物联网属性和状态。 auto& thing_manager = iot::ThingManager::GetInstance(); // 声明一个字符串变量来存储获取到的设备状态的 JSON 格式数据。 std::string states; // 调用 thing_manager 的 GetStatesJson 方法来获取设备的当前状态。 // 第一个参数 states 是一个输出参数，用于接收状态的 JSON 字符串。 // 第二个参数 true 可能表示只获取可报告的状态，或者以某种特定的格式。 // 如果成功获取到状态（返回 true），则执行内部的代码块。 if (thing_manager.GetStatesJson(states, true)) { // 通过 protocol_ 对象发送获取到的 IoT 状态。 // protocol_ 可能是一个指向通信协议类实例的指针，用于将状态数据发送到云端或其他服务。 protocol_->SendIotStates(states); } #endif // 结束条件编译块。 }
void Application::Reboot() { ESP_LOGI(TAG, "Rebooting..."); esp_restart(); }
这没什么好说的
void Application::WakeWordInvoke(const std::string& wake_word) { // 检查设备当前是否处于空闲状态。 if (device_state_ == kDeviceStateIdle) { // 如果处于空闲状态，则切换聊天状态。 // 这可能意味着从一个非交互状态进入一个准备接受用户命令的状态。 ToggleChatState(); // 调度一个任务在后台执行。 // [this, wake_word]() 是一个 Lambda 表达式，捕获当前对象的指针 (this) 和唤醒词 (wake_word)。 Schedule([this, wake_word]() { // 如果 protocol_ 对象有效（非空）。 if (protocol_) { // 通过协议发送“唤醒词已检测到”的命令，并附带检测到的唤醒词。 // 这可能用于通知后端服务设备已被唤醒。 protocol_->SendWakeWordDetected(wake_word); } }); } // 如果设备当前处于语音播放状态。 else if (device_state_ == kDeviceStateSpeaking) { // 调度一个任务在后台执行。 Schedule([this]() { // 中止当前的语音播放。 // kAbortReasonNone 可能表示没有特定的中止原因，只是单纯地停止。 AbortSpeaking(kAbortReasonNone); }); } // 如果设备当前处于监听状态。 else if (device_state_ == kDeviceStateListening) { // 调度一个任务在后台执行。 Schedule([this]() { // 如果 protocol_ 对象有效。 if (protocol_) { // 关闭音频通道。 // 这可能用于在监听过程中检测到唤醒词后，关闭当前的音频输入流， // 准备开始新的交互或者切换到其他状态。 protocol_->CloseAudioChannel(); } }); } }
bool Application::CanEnterSleepMode() { // 检查设备当前状态是否为“空闲”。 // 如果设备不处于空闲状态（例如，正在连接、监听、说话等），则不能进入睡眠模式。 if (device_state_ != kDeviceStateIdle) { return false; } // 检查是否存在协议对象（protocol_）并且其音频通道是否处于打开状态。 // 如果协议存在且音频通道打开（意味着可能正在进行通信或处理音频流）， // 则此时不应进入睡眠模式，以避免中断通信。 if (protocol_ && protocol_->IsAudioChannelOpened()) { return false; } // 如果通过了以上所有检查，则表示当前可以安全地进入睡眠模式。 return true; }
bool Application::CanEnterSleepMode() { // 检查设备的当前状态是否为“空闲” (kDeviceStateIdle)。 // 如果设备当前不是空闲状态（例如，它可能正在连接、监听语音、或者正在说话）， // 那么就不能进入睡眠模式，直接返回 false。 if (device_state_ != kDeviceStateIdle) { return false; } // 检查是否存在一个有效的通信协议对象 (protocol_)， // 并且该协议的音频通道 (Audio Channel) 是否处于打开状态 (IsAudioChannelOpened())。 // 如果音频通道是打开的，这通常意味着设备正在进行语音输入/输出或与其他服务进行实时音频通信， // 此时进入睡眠模式会中断这些通信，因此返回 false。 if (protocol_ && protocol_->IsAudioChannelOpened()) { return false; } // 如果通过了以上所有检查，表示设备当前既不处于忙碌状态，也没有打开的音频通道， // 那么现在可以安全地进入睡眠模式。 return true; }
void Application::SendMcpMessage(const std::string& payload) { // 将一个任务调度到后台执行（即异步操作）。 // [this, payload]() 是 C++ 的 Lambda 表达式。 // - `this` 被捕获（按值捕获），确保 Lambda 表达式内部可以访问当前 Application 对象的成员。 // - `payload` 也被捕获（按值捕获），这意味着当 Lambda 表达式最终执行时，它会拥有 `payload` 字符串的一个副本。 // 这样做的好处是，即使原始的 `payload` 变量在 `SendMcpMessage` 函数返回后超出了作用域， // 被调度的任务也能安全地使用这份 `payload` 数据。 Schedule([this, payload]() { // 检查 `protocol_` 指针是否有效（即不为空）。 // `protocol_` 很可能是一个指向通信协议类实例的指针，负责实际的网络通信或设备间通信。 if (protocol_) { // 如果 `protocol_` 对象存在，就调用它的 `SendMcpMessage` 方法， // 并将 `payload` 作为参数传递。这里是实际发送消息的地方。 protocol_->SendMcpMessage(payload); } }); }
这段作用域的描述很有意思
// - `this` 被捕获（按值捕获），确保 Lambda 表达式内部可以访问当前 Application 对象的成员。
// - `payload` 也被捕获（按值捕获），这意味着当 Lambda 表达式最终执行时，它会拥有 `payload` 字符串的一个副本。
// 这样做的好处是，即使原始的 `payload` 变量在 `SendMcpMessage` 函数返回后超出了作用域，
// 被调度的任务也能安全地使用这份 `payload` 数据。
浙公网安备 33010602011771号