Compare commits
7 Commits
| Author | SHA1 | Date | |
|---|---|---|---|
| 66d318774a | |||
| 60df0fe196 | |||
| 2c4329fd84 | |||
| 9637e09aef | |||
| b92e6e1b07 | |||
| 33ee598c21 | |||
| 37343ac0fe |
1
.gitignore
vendored
1
.gitignore
vendored
@ -19,3 +19,4 @@ main/mmap_generate_emoji.h
|
||||
*.bin
|
||||
mmap_generate_*.h
|
||||
.clangd
|
||||
background_frames/
|
||||
|
||||
@ -1,25 +1,24 @@
|
||||
#include "application.h"
|
||||
#include "assets.h"
|
||||
#include "assets/lang_config.h"
|
||||
#include "audio_codec.h"
|
||||
#include "board.h"
|
||||
#include "display.h"
|
||||
#include "system_info.h"
|
||||
#include "audio_codec.h"
|
||||
#include "mqtt_protocol.h"
|
||||
#include "websocket_protocol.h"
|
||||
#include "assets/lang_config.h"
|
||||
#include "mcp_server.h"
|
||||
#include "assets.h"
|
||||
#include "mqtt_protocol.h"
|
||||
#include "settings.h"
|
||||
#include "system_info.h"
|
||||
#include "websocket_protocol.h"
|
||||
|
||||
#include <cstring>
|
||||
#include <esp_log.h>
|
||||
#include <cJSON.h>
|
||||
#include <driver/gpio.h>
|
||||
#include <esp_log.h>
|
||||
#include <arpa/inet.h>
|
||||
#include <cJSON.h>
|
||||
#include <font_awesome.h>
|
||||
#include <cstring>
|
||||
|
||||
#define TAG "Application"
|
||||
|
||||
|
||||
Application::Application() {
|
||||
event_group_ = xEventGroupCreate();
|
||||
|
||||
@ -33,16 +32,16 @@ Application::Application() {
|
||||
aec_mode_ = kAecOff;
|
||||
#endif
|
||||
|
||||
esp_timer_create_args_t clock_timer_args = {
|
||||
.callback = [](void* arg) {
|
||||
Application* app = (Application*)arg;
|
||||
xEventGroupSetBits(app->event_group_, MAIN_EVENT_CLOCK_TICK);
|
||||
},
|
||||
.arg = this,
|
||||
.dispatch_method = ESP_TIMER_TASK,
|
||||
.name = "clock_timer",
|
||||
.skip_unhandled_events = true
|
||||
};
|
||||
esp_timer_create_args_t clock_timer_args = {.callback =
|
||||
[](void* arg) {
|
||||
Application* app = (Application*)arg;
|
||||
xEventGroupSetBits(app->event_group_,
|
||||
MAIN_EVENT_CLOCK_TICK);
|
||||
},
|
||||
.arg = this,
|
||||
.dispatch_method = ESP_TIMER_TASK,
|
||||
.name = "clock_timer",
|
||||
.skip_unhandled_events = true};
|
||||
esp_timer_create(&clock_timer_args, &clock_timer_handle_);
|
||||
}
|
||||
|
||||
@ -54,9 +53,7 @@ Application::~Application() {
|
||||
vEventGroupDelete(event_group_);
|
||||
}
|
||||
|
||||
bool Application::SetDeviceState(DeviceState state) {
|
||||
return state_machine_.TransitionTo(state);
|
||||
}
|
||||
bool Application::SetDeviceState(DeviceState state) { return state_machine_.TransitionTo(state); }
|
||||
|
||||
void Application::Initialize() {
|
||||
auto& board = Board::GetInstance();
|
||||
@ -81,6 +78,7 @@ void Application::Initialize() {
|
||||
xEventGroupSetBits(event_group_, MAIN_EVENT_WAKE_WORD_DETECTED);
|
||||
};
|
||||
callbacks.on_vad_change = [this](bool speaking) {
|
||||
vad_speaking_.store(speaking);
|
||||
xEventGroupSetBits(event_group_, MAIN_EVENT_VAD_CHANGE);
|
||||
};
|
||||
audio_service_.SetCallbacks(callbacks);
|
||||
@ -101,7 +99,7 @@ void Application::Initialize() {
|
||||
// Set network event callback for UI updates and network state handling
|
||||
board.SetNetworkEventCallback([this](NetworkEvent event, const std::string& data) {
|
||||
auto display = Board::GetInstance().GetDisplay();
|
||||
|
||||
|
||||
switch (event) {
|
||||
case NetworkEvent::Scanning:
|
||||
display->ShowNotification(Lang::Strings::SCANNING_WIFI, 30000);
|
||||
@ -141,13 +139,16 @@ void Application::Initialize() {
|
||||
display->SetStatus(Lang::Strings::DETECTING_MODULE);
|
||||
break;
|
||||
case NetworkEvent::ModemErrorNoSim:
|
||||
Alert(Lang::Strings::ERROR, Lang::Strings::PIN_ERROR, "triangle_exclamation", Lang::Sounds::OGG_ERR_PIN);
|
||||
Alert(Lang::Strings::ERROR, Lang::Strings::PIN_ERROR, "triangle_exclamation",
|
||||
Lang::Sounds::OGG_ERR_PIN);
|
||||
break;
|
||||
case NetworkEvent::ModemErrorRegDenied:
|
||||
Alert(Lang::Strings::ERROR, Lang::Strings::REG_ERROR, "triangle_exclamation", Lang::Sounds::OGG_ERR_REG);
|
||||
Alert(Lang::Strings::ERROR, Lang::Strings::REG_ERROR, "triangle_exclamation",
|
||||
Lang::Sounds::OGG_ERR_REG);
|
||||
break;
|
||||
case NetworkEvent::ModemErrorInitFailed:
|
||||
Alert(Lang::Strings::ERROR, Lang::Strings::MODEM_INIT_ERROR, "triangle_exclamation", Lang::Sounds::OGG_EXCLAMATION);
|
||||
Alert(Lang::Strings::ERROR, Lang::Strings::MODEM_INIT_ERROR, "triangle_exclamation",
|
||||
Lang::Sounds::OGG_EXCLAMATION);
|
||||
break;
|
||||
case NetworkEvent::ModemErrorTimeout:
|
||||
display->SetStatus(Lang::Strings::REGISTERING_NETWORK);
|
||||
@ -166,19 +167,11 @@ void Application::Run() {
|
||||
// Set the priority of the main task to 10
|
||||
vTaskPrioritySet(nullptr, 10);
|
||||
|
||||
const EventBits_t ALL_EVENTS =
|
||||
MAIN_EVENT_SCHEDULE |
|
||||
MAIN_EVENT_SEND_AUDIO |
|
||||
MAIN_EVENT_WAKE_WORD_DETECTED |
|
||||
MAIN_EVENT_VAD_CHANGE |
|
||||
MAIN_EVENT_CLOCK_TICK |
|
||||
MAIN_EVENT_ERROR |
|
||||
MAIN_EVENT_NETWORK_CONNECTED |
|
||||
MAIN_EVENT_NETWORK_DISCONNECTED |
|
||||
MAIN_EVENT_TOGGLE_CHAT |
|
||||
MAIN_EVENT_START_LISTENING |
|
||||
MAIN_EVENT_STOP_LISTENING |
|
||||
MAIN_EVENT_ACTIVATION_DONE |
|
||||
const EventBits_t ALL_EVENTS =
|
||||
MAIN_EVENT_SCHEDULE | MAIN_EVENT_SEND_AUDIO | MAIN_EVENT_WAKE_WORD_DETECTED |
|
||||
MAIN_EVENT_VAD_CHANGE | MAIN_EVENT_CLOCK_TICK | MAIN_EVENT_ERROR |
|
||||
MAIN_EVENT_NETWORK_CONNECTED | MAIN_EVENT_NETWORK_DISCONNECTED | MAIN_EVENT_TOGGLE_CHAT |
|
||||
MAIN_EVENT_START_LISTENING | MAIN_EVENT_STOP_LISTENING | MAIN_EVENT_ACTIVATION_DONE |
|
||||
MAIN_EVENT_STATE_CHANGED;
|
||||
|
||||
while (true) {
|
||||
@ -186,7 +179,8 @@ void Application::Run() {
|
||||
|
||||
if (bits & MAIN_EVENT_ERROR) {
|
||||
SetDeviceState(kDeviceStateIdle);
|
||||
Alert(Lang::Strings::ERROR, last_error_message_.c_str(), "circle_xmark", Lang::Sounds::OGG_EXCLAMATION);
|
||||
Alert(Lang::Strings::ERROR, last_error_message_.c_str(), "circle_xmark",
|
||||
Lang::Sounds::OGG_EXCLAMATION);
|
||||
}
|
||||
|
||||
if (bits & MAIN_EVENT_NETWORK_CONNECTED) {
|
||||
@ -233,6 +227,13 @@ void Application::Run() {
|
||||
if (GetDeviceState() == kDeviceStateListening) {
|
||||
auto led = Board::GetInstance().GetLed();
|
||||
led->OnStateChanged();
|
||||
|
||||
if (vad_speaking_.load() && vision_text_mode_enabled_.load() &&
|
||||
!vision_frame_sent_for_current_listen_.exchange(true)) {
|
||||
if (!SendCurrentVisionFrame()) {
|
||||
vision_frame_sent_for_current_listen_.store(false);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@ -249,7 +250,7 @@ void Application::Run() {
|
||||
clock_ticks_++;
|
||||
auto display = Board::GetInstance().GetDisplay();
|
||||
display->UpdateStatusBar();
|
||||
|
||||
|
||||
// Print debug info every 10 seconds
|
||||
if (clock_ticks_ % 10 == 0) {
|
||||
SystemInfo::PrintHeapStats();
|
||||
@ -270,12 +271,14 @@ void Application::HandleNetworkConnectedEvent() {
|
||||
return;
|
||||
}
|
||||
|
||||
xTaskCreate([](void* arg) {
|
||||
Application* app = static_cast<Application*>(arg);
|
||||
app->ActivationTask();
|
||||
app->activation_task_handle_ = nullptr;
|
||||
vTaskDelete(NULL);
|
||||
}, "activation", 4096 * 2, this, 2, &activation_task_handle_);
|
||||
xTaskCreate(
|
||||
[](void* arg) {
|
||||
Application* app = static_cast<Application*>(arg);
|
||||
app->ActivationTask();
|
||||
app->activation_task_handle_ = nullptr;
|
||||
vTaskDelete(NULL);
|
||||
},
|
||||
"activation", 4096 * 2, this, 2, &activation_task_handle_);
|
||||
}
|
||||
|
||||
// Update the status bar immediately to show the network state
|
||||
@ -286,7 +289,8 @@ void Application::HandleNetworkConnectedEvent() {
|
||||
void Application::HandleNetworkDisconnectedEvent() {
|
||||
// Close current conversation when network disconnected
|
||||
auto state = GetDeviceState();
|
||||
if (state == kDeviceStateConnecting || state == kDeviceStateListening || state == kDeviceStateSpeaking) {
|
||||
if (state == kDeviceStateConnecting || state == kDeviceStateListening ||
|
||||
state == kDeviceStateThinking || state == kDeviceStateSpeaking) {
|
||||
ESP_LOGI(TAG, "Closing audio channel due to network disconnection");
|
||||
protocol_->CloseAudioChannel();
|
||||
}
|
||||
@ -361,7 +365,7 @@ void Application::CheckAssetsVersion() {
|
||||
ESP_LOGW(TAG, "Assets partition is disabled for board %s", BOARD_NAME);
|
||||
return;
|
||||
}
|
||||
|
||||
|
||||
Settings settings("assets", true);
|
||||
// Check if there is a new assets need to be downloaded
|
||||
std::string download_url = settings.GetString("download_url");
|
||||
@ -371,27 +375,30 @@ void Application::CheckAssetsVersion() {
|
||||
|
||||
char message[256];
|
||||
snprintf(message, sizeof(message), Lang::Strings::FOUND_NEW_ASSETS, download_url.c_str());
|
||||
Alert(Lang::Strings::LOADING_ASSETS, message, "cloud_arrow_down", Lang::Sounds::OGG_UPGRADE);
|
||||
|
||||
Alert(Lang::Strings::LOADING_ASSETS, message, "cloud_arrow_down",
|
||||
Lang::Sounds::OGG_UPGRADE);
|
||||
|
||||
// Wait for the audio service to be idle for 3 seconds
|
||||
vTaskDelay(pdMS_TO_TICKS(3000));
|
||||
SetDeviceState(kDeviceStateUpgrading);
|
||||
board.SetPowerSaveLevel(PowerSaveLevel::PERFORMANCE);
|
||||
display->SetChatMessage("system", Lang::Strings::PLEASE_WAIT);
|
||||
|
||||
bool success = assets.Download(download_url, [this, display](int progress, size_t speed) -> void {
|
||||
char buffer[32];
|
||||
snprintf(buffer, sizeof(buffer), "%d%% %uKB/s", progress, speed / 1024);
|
||||
Schedule([display, message = std::string(buffer)]() {
|
||||
display->SetChatMessage("system", message.c_str());
|
||||
bool success =
|
||||
assets.Download(download_url, [this, display](int progress, size_t speed) -> void {
|
||||
char buffer[32];
|
||||
snprintf(buffer, sizeof(buffer), "%d%% %uKB/s", progress, speed / 1024);
|
||||
Schedule([display, message = std::string(buffer)]() {
|
||||
display->SetChatMessage("system", message.c_str());
|
||||
});
|
||||
});
|
||||
});
|
||||
|
||||
board.SetPowerSaveLevel(PowerSaveLevel::LOW_POWER);
|
||||
vTaskDelay(pdMS_TO_TICKS(1000));
|
||||
|
||||
if (!success) {
|
||||
Alert(Lang::Strings::ERROR, Lang::Strings::DOWNLOAD_ASSETS_FAILED, "circle_xmark", Lang::Sounds::OGG_EXCLAMATION);
|
||||
Alert(Lang::Strings::ERROR, Lang::Strings::DOWNLOAD_ASSETS_FAILED, "circle_xmark",
|
||||
Lang::Sounds::OGG_EXCLAMATION);
|
||||
vTaskDelay(pdMS_TO_TICKS(2000));
|
||||
SetDeviceState(kDeviceStateActivating);
|
||||
return;
|
||||
@ -407,7 +414,7 @@ void Application::CheckAssetsVersion() {
|
||||
void Application::CheckNewVersion() {
|
||||
const int MAX_RETRY = 10;
|
||||
int retry_count = 0;
|
||||
int retry_delay = 10; // Initial retry delay in seconds
|
||||
int retry_delay = 10; // Initial retry delay in seconds
|
||||
|
||||
auto& board = Board::GetInstance();
|
||||
while (true) {
|
||||
@ -423,27 +430,30 @@ void Application::CheckNewVersion() {
|
||||
}
|
||||
|
||||
char error_message[128];
|
||||
snprintf(error_message, sizeof(error_message), "code=%d, url=%s", err, ota_->GetCheckVersionUrl().c_str());
|
||||
snprintf(error_message, sizeof(error_message), "code=%d, url=%s", err,
|
||||
ota_->GetCheckVersionUrl().c_str());
|
||||
char buffer[256];
|
||||
snprintf(buffer, sizeof(buffer), Lang::Strings::CHECK_NEW_VERSION_FAILED, retry_delay, error_message);
|
||||
snprintf(buffer, sizeof(buffer), Lang::Strings::CHECK_NEW_VERSION_FAILED, retry_delay,
|
||||
error_message);
|
||||
Alert(Lang::Strings::ERROR, buffer, "cloud_slash", Lang::Sounds::OGG_EXCLAMATION);
|
||||
|
||||
ESP_LOGW(TAG, "Check new version failed, retry in %d seconds (%d/%d)", retry_delay, retry_count, MAX_RETRY);
|
||||
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++) {
|
||||
vTaskDelay(pdMS_TO_TICKS(1000));
|
||||
if (GetDeviceState() == kDeviceStateIdle) {
|
||||
break;
|
||||
}
|
||||
}
|
||||
retry_delay *= 2; // Double the retry delay
|
||||
retry_delay *= 2; // Double the retry delay
|
||||
continue;
|
||||
}
|
||||
retry_count = 0;
|
||||
retry_delay = 10; // Reset retry delay
|
||||
retry_delay = 10; // Reset retry delay
|
||||
|
||||
if (ota_->HasNewVersion()) {
|
||||
if (UpgradeFirmware(ota_->GetFirmwareUrl(), ota_->GetFirmwareVersion())) {
|
||||
return; // This line will never be reached after reboot
|
||||
return; // This line will never be reached after reboot
|
||||
}
|
||||
// If upgrade failed, continue to normal operation
|
||||
}
|
||||
@ -499,51 +509,61 @@ void Application::InitializeProtocol() {
|
||||
}
|
||||
#endif
|
||||
|
||||
protocol_->OnConnected([this]() {
|
||||
DismissAlert();
|
||||
});
|
||||
protocol_->OnConnected([this]() { DismissAlert(); });
|
||||
|
||||
protocol_->OnNetworkError([this](const std::string& message) {
|
||||
last_error_message_ = message;
|
||||
xEventGroupSetBits(event_group_, MAIN_EVENT_ERROR);
|
||||
});
|
||||
|
||||
|
||||
protocol_->OnIncomingAudio([this](std::unique_ptr<AudioStreamPacket> packet) {
|
||||
if (GetDeviceState() == kDeviceStateSpeaking) {
|
||||
if (accepting_tts_audio_.load() || GetDeviceState() == kDeviceStateSpeaking) {
|
||||
audio_service_.PushPacketToDecodeQueue(std::move(packet));
|
||||
}
|
||||
});
|
||||
|
||||
|
||||
protocol_->OnAudioChannelOpened([this, codec, &board]() {
|
||||
board.SetPowerSaveLevel(PowerSaveLevel::PERFORMANCE);
|
||||
if (protocol_->server_sample_rate() != codec->output_sample_rate()) {
|
||||
ESP_LOGW(TAG, "Server sample rate %d does not match device output sample rate %d, resampling may cause distortion",
|
||||
protocol_->server_sample_rate(), codec->output_sample_rate());
|
||||
ESP_LOGW(TAG,
|
||||
"Server sample rate %d does not match device output sample rate %d, "
|
||||
"resampling may cause distortion",
|
||||
protocol_->server_sample_rate(), codec->output_sample_rate());
|
||||
}
|
||||
});
|
||||
|
||||
|
||||
protocol_->OnAudioChannelClosed([this, &board]() {
|
||||
board.SetPowerSaveLevel(PowerSaveLevel::LOW_POWER);
|
||||
accepting_tts_audio_.store(false);
|
||||
Schedule([this]() {
|
||||
if (GetDeviceState() == kDeviceStateConnecting) {
|
||||
return;
|
||||
}
|
||||
auto display = Board::GetInstance().GetDisplay();
|
||||
display->SetChatMessage("system", "");
|
||||
SetDeviceState(kDeviceStateIdle);
|
||||
});
|
||||
});
|
||||
|
||||
|
||||
protocol_->OnIncomingJson([this, display](const cJSON* root) {
|
||||
// Parse JSON data
|
||||
auto type = cJSON_GetObjectItem(root, "type");
|
||||
if (strcmp(type->valuestring, "tts") == 0) {
|
||||
auto state = cJSON_GetObjectItem(root, "state");
|
||||
if (strcmp(state->valuestring, "start") == 0) {
|
||||
if (strcmp(state->valuestring, "thinking") == 0) {
|
||||
Schedule([this]() { SetDeviceState(kDeviceStateThinking); });
|
||||
} else if (strcmp(state->valuestring, "start") == 0) {
|
||||
audio_service_.ResetDecoder();
|
||||
accepting_tts_audio_.store(true);
|
||||
Schedule([this]() {
|
||||
aborted_ = false;
|
||||
SetDeviceState(kDeviceStateSpeaking);
|
||||
});
|
||||
} else if (strcmp(state->valuestring, "stop") == 0) {
|
||||
accepting_tts_audio_.store(false);
|
||||
Schedule([this]() {
|
||||
if (GetDeviceState() == kDeviceStateSpeaking) {
|
||||
auto state = GetDeviceState();
|
||||
if (state == kDeviceStateSpeaking || state == kDeviceStateThinking) {
|
||||
if (listening_mode_ == kListeningModeManualStop) {
|
||||
SetDeviceState(kDeviceStateIdle);
|
||||
} else {
|
||||
@ -586,9 +606,7 @@ void Application::InitializeProtocol() {
|
||||
ESP_LOGI(TAG, "System command: %s", command->valuestring);
|
||||
if (strcmp(command->valuestring, "reboot") == 0) {
|
||||
// Do a reboot if user requests a OTA update
|
||||
Schedule([this]() {
|
||||
Reboot();
|
||||
});
|
||||
Schedule([this]() { Reboot(); });
|
||||
} else {
|
||||
ESP_LOGW(TAG, "Unknown system command: %s", command->valuestring);
|
||||
}
|
||||
@ -598,7 +616,8 @@ void Application::InitializeProtocol() {
|
||||
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::OGG_VIBRATION);
|
||||
Alert(status->valuestring, message->valuestring, emotion->valuestring,
|
||||
Lang::Sounds::OGG_VIBRATION);
|
||||
} else {
|
||||
ESP_LOGW(TAG, "Alert command requires status, message and emotion");
|
||||
}
|
||||
@ -607,9 +626,10 @@ void Application::InitializeProtocol() {
|
||||
auto payload = cJSON_GetObjectItem(root, "payload");
|
||||
ESP_LOGI(TAG, "Received custom message: %s", cJSON_PrintUnformatted(root));
|
||||
if (cJSON_IsObject(payload)) {
|
||||
Schedule([this, display, payload_str = std::string(cJSON_PrintUnformatted(payload))]() {
|
||||
display->SetChatMessage("system", payload_str.c_str());
|
||||
});
|
||||
Schedule(
|
||||
[this, display, payload_str = std::string(cJSON_PrintUnformatted(payload))]() {
|
||||
display->SetChatMessage("system", payload_str.c_str());
|
||||
});
|
||||
} else {
|
||||
ESP_LOGW(TAG, "Invalid custom message format: missing payload");
|
||||
}
|
||||
@ -618,7 +638,7 @@ void Application::InitializeProtocol() {
|
||||
ESP_LOGW(TAG, "Unknown message type: %s", type->valuestring);
|
||||
}
|
||||
});
|
||||
|
||||
|
||||
protocol_->Start();
|
||||
}
|
||||
|
||||
@ -627,32 +647,27 @@ void Application::ShowActivationCode(const std::string& code, const std::string&
|
||||
char digit;
|
||||
const std::string_view& sound;
|
||||
};
|
||||
static const std::array<digit_sound, 10> digit_sounds{{
|
||||
digit_sound{'0', Lang::Sounds::OGG_0},
|
||||
digit_sound{'1', Lang::Sounds::OGG_1},
|
||||
digit_sound{'2', Lang::Sounds::OGG_2},
|
||||
digit_sound{'3', Lang::Sounds::OGG_3},
|
||||
digit_sound{'4', Lang::Sounds::OGG_4},
|
||||
digit_sound{'5', Lang::Sounds::OGG_5},
|
||||
digit_sound{'6', Lang::Sounds::OGG_6},
|
||||
digit_sound{'7', Lang::Sounds::OGG_7},
|
||||
digit_sound{'8', Lang::Sounds::OGG_8},
|
||||
digit_sound{'9', Lang::Sounds::OGG_9}
|
||||
}};
|
||||
static const std::array<digit_sound, 10> digit_sounds{
|
||||
{digit_sound{'0', Lang::Sounds::OGG_0}, digit_sound{'1', Lang::Sounds::OGG_1},
|
||||
digit_sound{'2', Lang::Sounds::OGG_2}, digit_sound{'3', Lang::Sounds::OGG_3},
|
||||
digit_sound{'4', Lang::Sounds::OGG_4}, digit_sound{'5', Lang::Sounds::OGG_5},
|
||||
digit_sound{'6', Lang::Sounds::OGG_6}, digit_sound{'7', Lang::Sounds::OGG_7},
|
||||
digit_sound{'8', Lang::Sounds::OGG_8}, digit_sound{'9', Lang::Sounds::OGG_9}}};
|
||||
|
||||
// This sentence uses 9KB of SRAM, so we need to wait for it to finish
|
||||
Alert(Lang::Strings::ACTIVATION, message.c_str(), "link", Lang::Sounds::OGG_ACTIVATION);
|
||||
|
||||
for (const auto& digit : code) {
|
||||
auto it = std::find_if(digit_sounds.begin(), digit_sounds.end(),
|
||||
[digit](const digit_sound& ds) { return ds.digit == digit; });
|
||||
[digit](const digit_sound& ds) { return ds.digit == digit; });
|
||||
if (it != digit_sounds.end()) {
|
||||
audio_service_.PlaySound(it->sound);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
void Application::Alert(const char* status, const char* message, const char* emotion, const std::string_view& sound) {
|
||||
void Application::Alert(const char* status, const char* message, const char* emotion,
|
||||
const std::string_view& sound) {
|
||||
ESP_LOGW(TAG, "Alert [%s] %s: %s", emotion, status, message);
|
||||
auto display = Board::GetInstance().GetDisplay();
|
||||
display->SetStatus(status);
|
||||
@ -672,30 +687,43 @@ void Application::DismissAlert() {
|
||||
}
|
||||
}
|
||||
|
||||
void Application::ToggleChatState() {
|
||||
vision_text_mode_enabled_.store(false);
|
||||
void Application::ToggleChatState() { ToggleChatStateForMode(kChatAgentModeNormal, false); }
|
||||
|
||||
void Application::ToggleChatStateWithVision() {
|
||||
ToggleChatStateForMode(kChatAgentModeNormal, true);
|
||||
}
|
||||
|
||||
void Application::ToggleChatStateForMode(ChatAgentMode agent_mode, bool vision_enabled) {
|
||||
chat_agent_mode_.store(agent_mode);
|
||||
vision_text_mode_enabled_.store(vision_enabled);
|
||||
vision_frame_sent_for_current_listen_.store(false);
|
||||
xEventGroupSetBits(event_group_, MAIN_EVENT_TOGGLE_CHAT);
|
||||
}
|
||||
|
||||
void Application::ToggleChatStateWithVision() {
|
||||
vision_text_mode_enabled_.store(true);
|
||||
xEventGroupSetBits(event_group_, MAIN_EVENT_TOGGLE_CHAT);
|
||||
bool Application::IsVisionTextModeEnabled() const { return vision_text_mode_enabled_.load(); }
|
||||
|
||||
const char* Application::GetChatAgentModeName() const {
|
||||
return chat_agent_mode_.load() == kChatAgentModeBeaver ? "beaver" : "normal";
|
||||
}
|
||||
|
||||
const char* Application::GetChatModeName() const {
|
||||
bool vision_enabled = vision_text_mode_enabled_.load();
|
||||
if (chat_agent_mode_.load() == kChatAgentModeBeaver) {
|
||||
return vision_enabled ? "vision-beaver" : "beaver";
|
||||
}
|
||||
return vision_enabled ? "vision-normal" : "normal";
|
||||
}
|
||||
|
||||
void Application::StartListening() {
|
||||
vision_text_mode_enabled_.store(false);
|
||||
vision_frame_sent_for_current_listen_.store(false);
|
||||
xEventGroupSetBits(event_group_, MAIN_EVENT_START_LISTENING);
|
||||
}
|
||||
|
||||
void Application::StopListening() {
|
||||
xEventGroupSetBits(event_group_, MAIN_EVENT_STOP_LISTENING);
|
||||
}
|
||||
void Application::StopListening() { xEventGroupSetBits(event_group_, MAIN_EVENT_STOP_LISTENING); }
|
||||
|
||||
void Application::HandleToggleChatEvent() {
|
||||
auto state = GetDeviceState();
|
||||
if (state != kDeviceStateIdle) {
|
||||
vision_text_mode_enabled_.store(false);
|
||||
}
|
||||
|
||||
if (state == kDeviceStateActivating) {
|
||||
SetDeviceState(kDeviceStateIdle);
|
||||
@ -717,17 +745,22 @@ void Application::HandleToggleChatEvent() {
|
||||
|
||||
if (state == kDeviceStateIdle) {
|
||||
ListeningMode mode = GetDefaultListeningMode();
|
||||
if (!protocol_->IsAudioChannelOpened()) {
|
||||
bool agent_mode_changed = chat_agent_mode_.load() != active_chat_agent_mode_.load();
|
||||
bool vision_mode_changed =
|
||||
vision_text_mode_enabled_.load() != active_vision_text_mode_enabled_.load();
|
||||
if (!protocol_->IsAudioChannelOpened() || agent_mode_changed || vision_mode_changed) {
|
||||
if (protocol_->IsAudioChannelOpened()) {
|
||||
protocol_->CloseAudioChannel();
|
||||
}
|
||||
SetDeviceState(kDeviceStateConnecting);
|
||||
// Schedule to let the state change be processed first (UI update)
|
||||
Schedule([this, mode]() {
|
||||
ContinueOpenAudioChannel(mode);
|
||||
});
|
||||
Schedule([this, mode]() { ContinueOpenAudioChannel(mode); });
|
||||
return;
|
||||
}
|
||||
SetListeningMode(mode);
|
||||
} else if (state == kDeviceStateSpeaking) {
|
||||
} else if (state == kDeviceStateSpeaking || state == kDeviceStateThinking) {
|
||||
AbortSpeaking(kAbortReasonNone);
|
||||
SetListeningMode(GetDefaultListeningMode());
|
||||
} else if (state == kDeviceStateListening) {
|
||||
protocol_->CloseAudioChannel();
|
||||
}
|
||||
@ -749,12 +782,14 @@ void Application::ContinueOpenAudioChannel(ListeningMode mode) {
|
||||
}
|
||||
}
|
||||
|
||||
active_chat_agent_mode_.store(chat_agent_mode_.load());
|
||||
active_vision_text_mode_enabled_.store(vision_text_mode_enabled_.load());
|
||||
SetListeningMode(mode);
|
||||
}
|
||||
|
||||
void Application::HandleStartListeningEvent() {
|
||||
auto state = GetDeviceState();
|
||||
|
||||
|
||||
if (state == kDeviceStateActivating) {
|
||||
SetDeviceState(kDeviceStateIdle);
|
||||
return;
|
||||
@ -768,18 +803,16 @@ void Application::HandleStartListeningEvent() {
|
||||
ESP_LOGE(TAG, "Protocol not initialized");
|
||||
return;
|
||||
}
|
||||
|
||||
|
||||
if (state == kDeviceStateIdle) {
|
||||
if (!protocol_->IsAudioChannelOpened()) {
|
||||
SetDeviceState(kDeviceStateConnecting);
|
||||
// Schedule to let the state change be processed first (UI update)
|
||||
Schedule([this]() {
|
||||
ContinueOpenAudioChannel(kListeningModeManualStop);
|
||||
});
|
||||
Schedule([this]() { ContinueOpenAudioChannel(kListeningModeManualStop); });
|
||||
return;
|
||||
}
|
||||
SetListeningMode(kListeningModeManualStop);
|
||||
} else if (state == kDeviceStateSpeaking) {
|
||||
} else if (state == kDeviceStateSpeaking || state == kDeviceStateThinking) {
|
||||
AbortSpeaking(kAbortReasonNone);
|
||||
SetListeningMode(kListeningModeManualStop);
|
||||
}
|
||||
@ -787,7 +820,7 @@ void Application::HandleStartListeningEvent() {
|
||||
|
||||
void Application::HandleStopListeningEvent() {
|
||||
auto state = GetDeviceState();
|
||||
|
||||
|
||||
if (state == kDeviceStateAudioTesting) {
|
||||
audio_service_.EnableAudioTesting(false);
|
||||
SetDeviceState(kDeviceStateWifiConfiguring);
|
||||
@ -817,17 +850,14 @@ void Application::HandleWakeWordDetectedEvent() {
|
||||
SetDeviceState(kDeviceStateConnecting);
|
||||
// Schedule to let the state change be processed first (UI update),
|
||||
// then continue with OpenAudioChannel which may block for ~1 second
|
||||
Schedule([this, wake_word]() {
|
||||
ContinueWakeWordInvoke(wake_word);
|
||||
});
|
||||
Schedule([this, wake_word]() { ContinueWakeWordInvoke(wake_word); });
|
||||
return;
|
||||
}
|
||||
// Channel already opened, continue directly
|
||||
ContinueWakeWordInvoke(wake_word);
|
||||
} else if (state == kDeviceStateSpeaking || state == kDeviceStateListening) {
|
||||
} else if (state == kDeviceStateSpeaking || state == kDeviceStateThinking ||
|
||||
state == kDeviceStateListening) {
|
||||
AbortSpeaking(kAbortReasonWakeWordDetected);
|
||||
// Clear send queue to avoid sending residues to server
|
||||
while (audio_service_.PopPacketFromSendQueue());
|
||||
|
||||
if (state == kDeviceStateListening) {
|
||||
protocol_->SendStartListening(GetDefaultListeningMode());
|
||||
@ -888,13 +918,14 @@ void Application::HandleStateChangedEvent() {
|
||||
auto display = board.GetDisplay();
|
||||
auto led = board.GetLed();
|
||||
led->OnStateChanged();
|
||||
|
||||
|
||||
switch (new_state) {
|
||||
case kDeviceStateUnknown:
|
||||
case kDeviceStateIdle:
|
||||
vision_frame_sent_for_current_listen_.store(false);
|
||||
display->SetStatus(Lang::Strings::STANDBY);
|
||||
display->ClearChatMessages(); // Clear messages first
|
||||
display->SetEmotion("neutral"); // Then set emotion (wechat mode checks child count)
|
||||
display->ClearChatMessages(); // Clear messages first
|
||||
display->SetEmotion("neutral"); // Then set emotion (wechat mode checks child count)
|
||||
audio_service_.EnableVoiceProcessing(false);
|
||||
audio_service_.EnableWakeWordDetection(true);
|
||||
break;
|
||||
@ -904,24 +935,19 @@ void Application::HandleStateChangedEvent() {
|
||||
display->SetChatMessage("system", "");
|
||||
break;
|
||||
case kDeviceStateListening:
|
||||
vad_speaking_.store(false);
|
||||
vision_frame_sent_for_current_listen_.store(false);
|
||||
display->SetStatus(Lang::Strings::LISTENING);
|
||||
display->SetEmotion("neutral");
|
||||
|
||||
// Make sure the audio processor is running
|
||||
if (play_popup_on_listening_ || !audio_service_.IsAudioProcessorRunning()) {
|
||||
// For auto mode, wait for playback queue to be empty before enabling voice processing
|
||||
// This prevents audio truncation when STOP arrives late due to network jitter
|
||||
if (listening_mode_ == kListeningModeAutoStop) {
|
||||
audio_service_.WaitForPlaybackQueueEmpty();
|
||||
}
|
||||
|
||||
if (vision_text_mode_enabled_.load()) {
|
||||
SendCurrentVisionFrame();
|
||||
}
|
||||
// Send the start listening command
|
||||
protocol_->SendStartListening(listening_mode_);
|
||||
audio_service_.EnableVoiceProcessing(true);
|
||||
// Re-entering listening after an interrupt must restart the capture path even if the
|
||||
// processor task is still marked running, otherwise realtime mode can show Listening
|
||||
// while no fresh mic frames are sent.
|
||||
if (listening_mode_ == kListeningModeAutoStop) {
|
||||
audio_service_.WaitForPlaybackQueueEmpty();
|
||||
}
|
||||
protocol_->SendStartListening(listening_mode_);
|
||||
audio_service_.EnableVoiceProcessing(true);
|
||||
|
||||
#ifdef CONFIG_WAKE_WORD_DETECTION_IN_LISTENING
|
||||
// Enable wake word detection in listening mode (configured via Kconfig)
|
||||
@ -930,13 +956,23 @@ void Application::HandleStateChangedEvent() {
|
||||
// Disable wake word detection in listening mode
|
||||
audio_service_.EnableWakeWordDetection(false);
|
||||
#endif
|
||||
|
||||
|
||||
// Play popup sound after ResetDecoder (in EnableVoiceProcessing) has been called
|
||||
if (play_popup_on_listening_) {
|
||||
play_popup_on_listening_ = false;
|
||||
audio_service_.PlaySound(Lang::Sounds::OGG_POPUP);
|
||||
}
|
||||
break;
|
||||
case kDeviceStateThinking:
|
||||
vad_speaking_.store(false);
|
||||
display->SetStatus(Lang::Strings::THINKING);
|
||||
display->SetEmotion("thinking");
|
||||
|
||||
if (listening_mode_ != kListeningModeRealtime) {
|
||||
audio_service_.EnableVoiceProcessing(false);
|
||||
audio_service_.EnableWakeWordDetection(audio_service_.IsAfeWakeWord());
|
||||
}
|
||||
break;
|
||||
case kDeviceStateSpeaking:
|
||||
display->SetStatus(Lang::Strings::SPEAKING);
|
||||
|
||||
@ -945,7 +981,9 @@ void Application::HandleStateChangedEvent() {
|
||||
// Only AFE wake word can be detected in speaking mode
|
||||
audio_service_.EnableWakeWordDetection(audio_service_.IsAfeWakeWord());
|
||||
}
|
||||
audio_service_.ResetDecoder();
|
||||
if (!accepting_tts_audio_.load()) {
|
||||
audio_service_.ResetDecoder();
|
||||
}
|
||||
break;
|
||||
case kDeviceStateWifiConfiguring:
|
||||
audio_service_.EnableVoiceProcessing(false);
|
||||
@ -957,24 +995,25 @@ void Application::HandleStateChangedEvent() {
|
||||
}
|
||||
}
|
||||
|
||||
void Application::SendCurrentVisionFrame() {
|
||||
bool Application::SendCurrentVisionFrame() {
|
||||
if (!protocol_ || !protocol_->IsAudioChannelOpened()) {
|
||||
return;
|
||||
return false;
|
||||
}
|
||||
|
||||
auto camera = Board::GetInstance().GetCamera();
|
||||
if (camera == nullptr) {
|
||||
return;
|
||||
return false;
|
||||
}
|
||||
|
||||
std::string jpeg_data;
|
||||
if (!camera->CaptureToJpeg(jpeg_data, false)) {
|
||||
if (!camera->CaptureToJpeg(jpeg_data, true)) {
|
||||
ESP_LOGW(TAG, "Failed to capture vision frame");
|
||||
return;
|
||||
return false;
|
||||
}
|
||||
|
||||
protocol_->SendVisionFrame(jpeg_data);
|
||||
ESP_LOGI(TAG, "Sent vision frame, size=%u bytes", static_cast<unsigned>(jpeg_data.size()));
|
||||
return true;
|
||||
}
|
||||
|
||||
void Application::Schedule(std::function<void()>&& callback) {
|
||||
@ -988,6 +1027,8 @@ void Application::Schedule(std::function<void()>&& callback) {
|
||||
void Application::AbortSpeaking(AbortReason reason) {
|
||||
ESP_LOGI(TAG, "Abort speaking");
|
||||
aborted_ = true;
|
||||
accepting_tts_audio_.store(false);
|
||||
audio_service_.ResetDecoder();
|
||||
if (protocol_) {
|
||||
protocol_->SendAbortSpeaking(reason);
|
||||
}
|
||||
@ -995,6 +1036,8 @@ void Application::AbortSpeaking(AbortReason reason) {
|
||||
|
||||
void Application::SetListeningMode(ListeningMode mode) {
|
||||
listening_mode_ = mode;
|
||||
vad_speaking_.store(false);
|
||||
vision_frame_sent_for_current_listen_.store(false);
|
||||
SetDeviceState(kDeviceStateListening);
|
||||
}
|
||||
|
||||
@ -1029,7 +1072,8 @@ bool Application::UpgradeFirmware(const std::string& url, const std::string& ver
|
||||
}
|
||||
ESP_LOGI(TAG, "Starting firmware upgrade from URL: %s", upgrade_url.c_str());
|
||||
|
||||
Alert(Lang::Strings::OTA_UPGRADE, Lang::Strings::UPGRADING, "download", Lang::Sounds::OGG_UPGRADE);
|
||||
Alert(Lang::Strings::OTA_UPGRADE, Lang::Strings::UPGRADING, "download",
|
||||
Lang::Sounds::OGG_UPGRADE);
|
||||
vTaskDelay(pdMS_TO_TICKS(3000));
|
||||
|
||||
SetDeviceState(kDeviceStateUpgrading);
|
||||
@ -1051,17 +1095,19 @@ bool Application::UpgradeFirmware(const std::string& url, const std::string& ver
|
||||
|
||||
if (!upgrade_success) {
|
||||
// Upgrade failed, restart audio service and continue running
|
||||
ESP_LOGE(TAG, "Firmware upgrade failed, restarting audio service and continuing operation...");
|
||||
audio_service_.Start(); // Restart audio service
|
||||
board.SetPowerSaveLevel(PowerSaveLevel::LOW_POWER); // Restore power save level
|
||||
Alert(Lang::Strings::ERROR, Lang::Strings::UPGRADE_FAILED, "circle_xmark", Lang::Sounds::OGG_EXCLAMATION);
|
||||
ESP_LOGE(TAG,
|
||||
"Firmware upgrade failed, restarting audio service and continuing operation...");
|
||||
audio_service_.Start(); // Restart audio service
|
||||
board.SetPowerSaveLevel(PowerSaveLevel::LOW_POWER); // Restore power save level
|
||||
Alert(Lang::Strings::ERROR, Lang::Strings::UPGRADE_FAILED, "circle_xmark",
|
||||
Lang::Sounds::OGG_EXCLAMATION);
|
||||
vTaskDelay(pdMS_TO_TICKS(3000));
|
||||
return false;
|
||||
} else {
|
||||
// Upgrade success, reboot immediately
|
||||
ESP_LOGI(TAG, "Firmware upgrade successful, rebooting...");
|
||||
display->SetChatMessage("system", "Upgrade successful, rebooting...");
|
||||
vTaskDelay(pdMS_TO_TICKS(1000)); // Brief pause to show message
|
||||
vTaskDelay(pdMS_TO_TICKS(1000)); // Brief pause to show message
|
||||
Reboot();
|
||||
return true;
|
||||
}
|
||||
@ -1073,25 +1119,21 @@ void Application::WakeWordInvoke(const std::string& wake_word) {
|
||||
}
|
||||
|
||||
auto state = GetDeviceState();
|
||||
|
||||
|
||||
if (state == kDeviceStateIdle) {
|
||||
audio_service_.EncodeWakeWord();
|
||||
|
||||
if (!protocol_->IsAudioChannelOpened()) {
|
||||
SetDeviceState(kDeviceStateConnecting);
|
||||
// Schedule to let the state change be processed first (UI update)
|
||||
Schedule([this, wake_word]() {
|
||||
ContinueWakeWordInvoke(wake_word);
|
||||
});
|
||||
Schedule([this, wake_word]() { ContinueWakeWordInvoke(wake_word); });
|
||||
return;
|
||||
}
|
||||
// Channel already opened, continue directly
|
||||
ContinueWakeWordInvoke(wake_word);
|
||||
} else if (state == kDeviceStateSpeaking) {
|
||||
Schedule([this]() {
|
||||
AbortSpeaking(kAbortReasonNone);
|
||||
});
|
||||
} else if (state == kDeviceStateListening) {
|
||||
} else if (state == kDeviceStateSpeaking || state == kDeviceStateThinking) {
|
||||
Schedule([this]() { AbortSpeaking(kAbortReasonNone); });
|
||||
} else if (state == kDeviceStateListening) {
|
||||
Schedule([this]() {
|
||||
if (protocol_) {
|
||||
protocol_->CloseAudioChannel();
|
||||
@ -1123,7 +1165,7 @@ void Application::RegisterMcpBroadcastCallback(std::function<void(const std::str
|
||||
|
||||
void Application::SendMcpMessage(const std::string& payload) {
|
||||
// Always schedule to run in main task for thread safety
|
||||
Schedule([this, payload](){
|
||||
Schedule([this, payload]() {
|
||||
if (protocol_) {
|
||||
protocol_->SendMcpMessage(payload);
|
||||
}
|
||||
@ -1139,18 +1181,18 @@ void Application::SetAecMode(AecMode mode) {
|
||||
auto& board = Board::GetInstance();
|
||||
auto display = board.GetDisplay();
|
||||
switch (aec_mode_) {
|
||||
case kAecOff:
|
||||
audio_service_.EnableDeviceAec(false);
|
||||
display->ShowNotification(Lang::Strings::RTC_MODE_OFF);
|
||||
break;
|
||||
case kAecOnServerSide:
|
||||
audio_service_.EnableDeviceAec(false);
|
||||
display->ShowNotification(Lang::Strings::RTC_MODE_ON);
|
||||
break;
|
||||
case kAecOnDeviceSide:
|
||||
audio_service_.EnableDeviceAec(true);
|
||||
display->ShowNotification(Lang::Strings::RTC_MODE_ON);
|
||||
break;
|
||||
case kAecOff:
|
||||
audio_service_.EnableDeviceAec(false);
|
||||
display->ShowNotification(Lang::Strings::RTC_MODE_OFF);
|
||||
break;
|
||||
case kAecOnServerSide:
|
||||
audio_service_.EnableDeviceAec(false);
|
||||
display->ShowNotification(Lang::Strings::RTC_MODE_ON);
|
||||
break;
|
||||
case kAecOnDeviceSide:
|
||||
audio_service_.EnableDeviceAec(true);
|
||||
display->ShowNotification(Lang::Strings::RTC_MODE_ON);
|
||||
break;
|
||||
}
|
||||
|
||||
// If the AEC mode is changed, close the audio channel
|
||||
@ -1160,9 +1202,7 @@ void Application::SetAecMode(AecMode mode) {
|
||||
});
|
||||
}
|
||||
|
||||
void Application::PlaySound(const std::string_view& sound) {
|
||||
audio_service_.PlaySound(sound);
|
||||
}
|
||||
void Application::PlaySound(const std::string_view& sound) { audio_service_.PlaySound(sound); }
|
||||
|
||||
void Application::ResetProtocol() {
|
||||
Schedule([this]() {
|
||||
|
||||
@ -41,6 +41,11 @@ enum AecMode {
|
||||
kAecOnServerSide,
|
||||
};
|
||||
|
||||
enum ChatAgentMode {
|
||||
kChatAgentModeNormal,
|
||||
kChatAgentModeBeaver,
|
||||
};
|
||||
|
||||
class Application {
|
||||
public:
|
||||
static Application& GetInstance() {
|
||||
@ -93,6 +98,11 @@ public:
|
||||
*/
|
||||
void ToggleChatState();
|
||||
void ToggleChatStateWithVision();
|
||||
void ToggleChatStateForMode(ChatAgentMode agent_mode, bool vision_enabled);
|
||||
bool IsVisionTextModeEnabled() const;
|
||||
ChatAgentMode GetChatAgentMode() const { return chat_agent_mode_.load(); }
|
||||
const char* GetChatAgentModeName() const;
|
||||
const char* GetChatModeName() const;
|
||||
|
||||
/**
|
||||
* Start listening (event-based, thread-safe)
|
||||
@ -146,7 +156,13 @@ private:
|
||||
bool aborted_ = false;
|
||||
bool assets_version_checked_ = false;
|
||||
bool play_popup_on_listening_ = false; // Flag to play popup sound after state changes to listening
|
||||
std::atomic<ChatAgentMode> chat_agent_mode_ = kChatAgentModeNormal;
|
||||
std::atomic<ChatAgentMode> active_chat_agent_mode_ = kChatAgentModeNormal;
|
||||
std::atomic<bool> vision_text_mode_enabled_ = false;
|
||||
std::atomic<bool> active_vision_text_mode_enabled_ = false;
|
||||
std::atomic<bool> vad_speaking_ = false;
|
||||
std::atomic<bool> vision_frame_sent_for_current_listen_ = false;
|
||||
std::atomic<bool> accepting_tts_audio_ = false;
|
||||
int clock_ticks_ = 0;
|
||||
TaskHandle_t activation_task_handle_ = nullptr;
|
||||
|
||||
@ -162,7 +178,7 @@ private:
|
||||
void HandleWakeWordDetectedEvent();
|
||||
void ContinueOpenAudioChannel(ListeningMode mode);
|
||||
void ContinueWakeWordInvoke(const std::string& wake_word);
|
||||
void SendCurrentVisionFrame();
|
||||
bool SendCurrentVisionFrame();
|
||||
|
||||
// Activation task (runs in background)
|
||||
void ActivationTask();
|
||||
|
||||
@ -26,6 +26,7 @@
|
||||
"CONNECTION_SUCCESSFUL": "Connection Successful",
|
||||
"CONNECTED_TO": "Connected to ",
|
||||
"LISTENING": "Listening...",
|
||||
"THINKING": "Thinking...",
|
||||
"SPEAKING": "Speaking...",
|
||||
"SERVER_NOT_FOUND": "Looking for available service",
|
||||
"SERVER_NOT_CONNECTED": "Unable to connect to service, please try again later",
|
||||
@ -56,4 +57,4 @@
|
||||
"LOADING_ASSETS": "Loading assets...",
|
||||
"HELLO_MY_FRIEND": "Hello, my friend!"
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@ -23,6 +23,7 @@
|
||||
"CONNECTING": "连接中...",
|
||||
"CONNECTED_TO": "已连接 ",
|
||||
"LISTENING": "聆听中...",
|
||||
"THINKING": "思考中...",
|
||||
"SPEAKING": "说话中...",
|
||||
"SERVER_NOT_FOUND": "正在寻找可用服务",
|
||||
"SERVER_NOT_CONNECTED": "无法连接服务，请稍后再试",
|
||||
@ -56,4 +57,4 @@
|
||||
"FLIGHT_MODE_OFF": "飞行模式已关闭",
|
||||
"FLIGHT_MODE_ON": "飞行模式已开启"
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@ -579,6 +579,7 @@ void AudioService::EnableWakeWordDetection(bool enable) {
|
||||
void AudioService::EnableVoiceProcessing(bool enable) {
|
||||
ESP_LOGD(TAG, "%s voice processing", enable ? "Enabling" : "Disabling");
|
||||
if (enable) {
|
||||
bool was_running = IsAudioProcessorRunning();
|
||||
if (!audio_processor_initialized_) {
|
||||
audio_processor_->Initialize(codec_, OPUS_FRAME_DURATION_MS, models_list_);
|
||||
audio_processor_initialized_ = true;
|
||||
@ -586,7 +587,7 @@ void AudioService::EnableVoiceProcessing(bool enable) {
|
||||
|
||||
/* We should make sure no audio is playing */
|
||||
ResetDecoder();
|
||||
audio_input_need_warmup_ = true;
|
||||
audio_input_need_warmup_ = !was_running;
|
||||
// Reset input resampler to clear cached data from previous mode (e.g. WakeWord)
|
||||
// This prevents buffer overflow when switching between different feed sizes
|
||||
{
|
||||
|
||||
177
main/background_capture_service.cc
Normal file
177
main/background_capture_service.cc
Normal file
@ -0,0 +1,177 @@
|
||||
#include "background_capture_service.h"
|
||||
|
||||
#include "board.h"
|
||||
#include "camera.h"
|
||||
|
||||
#include <algorithm>
|
||||
#include <esp_heap_caps.h>
|
||||
#include <esp_log.h>
|
||||
|
||||
#define TAG "BgCapture"
|
||||
|
||||
BackgroundCaptureService::BackgroundCaptureService() = default;
|
||||
|
||||
BackgroundCaptureService::~BackgroundCaptureService() {
|
||||
Stop();
|
||||
}
|
||||
|
||||
void BackgroundCaptureService::Start() {
|
||||
#if CONFIG_BACKGROUND_CAPTURE_ENABLE
|
||||
if (running_.exchange(true)) {
|
||||
return;
|
||||
}
|
||||
|
||||
auto result = xTaskCreate(
|
||||
&BackgroundCaptureService::TaskEntry,
|
||||
"bg_capture",
|
||||
CONFIG_BACKGROUND_CAPTURE_TASK_STACK_SIZE,
|
||||
this,
|
||||
CONFIG_BACKGROUND_CAPTURE_TASK_PRIORITY,
|
||||
&task_handle_);
|
||||
if (result != pdPASS) {
|
||||
running_.store(false);
|
||||
task_handle_ = nullptr;
|
||||
ESP_LOGE(TAG, "Failed to create background capture task");
|
||||
}
|
||||
#endif
|
||||
}
|
||||
|
||||
void BackgroundCaptureService::Stop() {
|
||||
#if CONFIG_BACKGROUND_CAPTURE_ENABLE
|
||||
if (!running_.exchange(false)) {
|
||||
return;
|
||||
}
|
||||
|
||||
while (task_handle_ != nullptr) {
|
||||
vTaskDelay(pdMS_TO_TICKS(20));
|
||||
}
|
||||
#endif
|
||||
}
|
||||
|
||||
void BackgroundCaptureService::TaskEntry(void* arg) {
|
||||
#if CONFIG_BACKGROUND_CAPTURE_ENABLE
|
||||
auto* service = static_cast<BackgroundCaptureService*>(arg);
|
||||
service->Run();
|
||||
service->task_handle_ = nullptr;
|
||||
#else
|
||||
(void)arg;
|
||||
#endif
|
||||
vTaskDelete(nullptr);
|
||||
}
|
||||
|
||||
void BackgroundCaptureService::Run() {
|
||||
#if CONFIG_BACKGROUND_CAPTURE_ENABLE
|
||||
ESP_LOGI(TAG, "Background capture task started");
|
||||
|
||||
while (running_.load()) {
|
||||
if (!CaptureAndSendFrame()) {
|
||||
consecutive_failures_++;
|
||||
auto delay_ms = GetFailureDelayMs();
|
||||
ESP_LOGW(TAG, "Background capture retry in %u ms, failures=%u",
|
||||
delay_ms, consecutive_failures_);
|
||||
vTaskDelay(pdMS_TO_TICKS(delay_ms));
|
||||
continue;
|
||||
}
|
||||
|
||||
consecutive_failures_ = 0;
|
||||
vTaskDelay(pdMS_TO_TICKS(CONFIG_BACKGROUND_CAPTURE_FRAME_INTERVAL_MS));
|
||||
}
|
||||
|
||||
ESP_LOGI(TAG, "Background capture task stopped");
|
||||
#endif
|
||||
}
|
||||
|
||||
bool BackgroundCaptureService::CaptureAndSendFrame() {
|
||||
#if CONFIG_BACKGROUND_CAPTURE_ENABLE
|
||||
const size_t free_internal_heap = heap_caps_get_free_size(MALLOC_CAP_INTERNAL);
|
||||
if (free_internal_heap < CONFIG_BACKGROUND_CAPTURE_MIN_FREE_INTERNAL_HEAP) {
|
||||
ESP_LOGW(TAG, "Skip background capture, low internal heap: free=%u threshold=%u",
|
||||
static_cast<unsigned>(free_internal_heap),
|
||||
static_cast<unsigned>(CONFIG_BACKGROUND_CAPTURE_MIN_FREE_INTERNAL_HEAP));
|
||||
return false;
|
||||
}
|
||||
|
||||
auto camera = Board::GetInstance().GetCamera();
|
||||
if (camera == nullptr) {
|
||||
ESP_LOGW(TAG, "No camera available for background capture");
|
||||
return false;
|
||||
}
|
||||
|
||||
std::string jpeg_data;
|
||||
if (!camera->CaptureToJpeg(jpeg_data, false)) {
|
||||
ESP_LOGW(TAG, "Failed to capture background frame");
|
||||
return false;
|
||||
}
|
||||
|
||||
if (jpeg_data.empty()) {
|
||||
ESP_LOGW(TAG, "Captured empty background frame");
|
||||
return false;
|
||||
}
|
||||
|
||||
return UploadJpegFrame(jpeg_data);
|
||||
#else
|
||||
return false;
|
||||
#endif
|
||||
}
|
||||
|
||||
uint32_t BackgroundCaptureService::GetFailureDelayMs() const {
|
||||
#if CONFIG_BACKGROUND_CAPTURE_ENABLE
|
||||
const uint32_t base_delay_ms = CONFIG_BACKGROUND_CAPTURE_RETRY_INTERVAL_MS;
|
||||
const uint32_t max_delay_ms = CONFIG_BACKGROUND_CAPTURE_MAX_BACKOFF_MS;
|
||||
const uint32_t shift = std::min<uint32_t>(consecutive_failures_ - 1, 4);
|
||||
return std::min<uint32_t>(base_delay_ms << shift, max_delay_ms);
|
||||
#else
|
||||
return 0;
|
||||
#endif
|
||||
}
|
||||
|
||||
bool BackgroundCaptureService::UploadJpegFrame(const std::string& jpeg_data) {
|
||||
#if CONFIG_BACKGROUND_CAPTURE_ENABLE
|
||||
const std::string url = CONFIG_BACKGROUND_CAPTURE_UPLOAD_URL;
|
||||
if (url.empty()) {
|
||||
ESP_LOGI(TAG, "Captured background frame: %u bytes", static_cast<unsigned>(jpeg_data.size()));
|
||||
return true;
|
||||
}
|
||||
|
||||
auto network = Board::GetInstance().GetNetwork();
|
||||
if (network == nullptr) {
|
||||
ESP_LOGW(TAG, "No network available for background upload");
|
||||
return false;
|
||||
}
|
||||
|
||||
const std::string boundary = "----XIAOZHI_BACKGROUND_CAPTURE_BOUNDARY";
|
||||
auto http = network->CreateHttp(3);
|
||||
http->SetHeader("Content-Type", "multipart/form-data; boundary=" + boundary);
|
||||
|
||||
if (!http->Open("POST", url)) {
|
||||
ESP_LOGW(TAG, "Failed to open background upload URL: %s", url.c_str());
|
||||
return false;
|
||||
}
|
||||
|
||||
std::string file_header;
|
||||
file_header += "--" + boundary + "\r\n";
|
||||
file_header += "Content-Disposition: form-data; name=\"file\"; filename=\"frame.jpg\"\r\n";
|
||||
file_header += "Content-Type: image/jpeg\r\n\r\n";
|
||||
http->Write(file_header.c_str(), file_header.size());
|
||||
http->Write(jpeg_data.data(), jpeg_data.size());
|
||||
|
||||
std::string footer;
|
||||
footer += "\r\n--" + boundary + "--\r\n";
|
||||
http->Write(footer.c_str(), footer.size());
|
||||
http->Write("", 0);
|
||||
|
||||
const int status_code = http->GetStatusCode();
|
||||
http->Close();
|
||||
|
||||
if (status_code < 200 || status_code >= 300) {
|
||||
ESP_LOGW(TAG, "Background upload failed, status=%d", status_code);
|
||||
return false;
|
||||
}
|
||||
|
||||
ESP_LOGI(TAG, "Uploaded background frame: %u bytes", static_cast<unsigned>(jpeg_data.size()));
|
||||
return true;
|
||||
#else
|
||||
(void)jpeg_data;
|
||||
return false;
|
||||
#endif
|
||||
}
|
||||
32
main/background_capture_service.h
Normal file
32
main/background_capture_service.h
Normal file
@ -0,0 +1,32 @@
|
||||
#ifndef BACKGROUND_CAPTURE_SERVICE_H
|
||||
#define BACKGROUND_CAPTURE_SERVICE_H
|
||||
|
||||
#include <freertos/FreeRTOS.h>
|
||||
#include <freertos/task.h>
|
||||
|
||||
#include <atomic>
|
||||
#include <cstdint>
|
||||
#include <string>
|
||||
|
||||
class BackgroundCaptureService {
|
||||
public:
|
||||
BackgroundCaptureService();
|
||||
~BackgroundCaptureService();
|
||||
|
||||
void Start();
|
||||
void Stop();
|
||||
bool IsRunning() const { return running_.load(); }
|
||||
|
||||
private:
|
||||
TaskHandle_t task_handle_ = nullptr;
|
||||
std::atomic<bool> running_ = false;
|
||||
uint32_t consecutive_failures_ = 0;
|
||||
|
||||
static void TaskEntry(void* arg);
|
||||
void Run();
|
||||
bool CaptureAndSendFrame();
|
||||
bool UploadJpegFrame(const std::string& jpeg_data);
|
||||
uint32_t GetFailureDelayMs() const;
|
||||
};
|
||||
|
||||
#endif // BACKGROUND_CAPTURE_SERVICE_H
|
||||
@ -214,6 +214,9 @@ public:
|
||||
case kDeviceStateSpeaking:
|
||||
ctrl_->SetStatusColor(64, 0, 0); // red
|
||||
break;
|
||||
case kDeviceStateThinking:
|
||||
ctrl_->SetStatusColor(0, 0, 64); // blue
|
||||
break;
|
||||
default:
|
||||
ctrl_->SetStatusColor(0, 0, 64); // blue
|
||||
break;
|
||||
|
||||
@ -203,7 +203,10 @@ void WifiBoard::EnterWifiConfigMode() {
|
||||
auto& app = Application::GetInstance();
|
||||
auto state = app.GetDeviceState();
|
||||
|
||||
if (state == kDeviceStateSpeaking || state == kDeviceStateListening || state == kDeviceStateIdle) {
|
||||
if (state == kDeviceStateSpeaking ||
|
||||
state == kDeviceStateThinking ||
|
||||
state == kDeviceStateListening ||
|
||||
state == kDeviceStateIdle) {
|
||||
// Reset protocol (close audio channel, reset protocol)
|
||||
Application::GetInstance().ResetProtocol();
|
||||
|
||||
|
||||
@ -85,6 +85,13 @@ void ElectronEmojiDisplay::SetStatus(const char* status) {
|
||||
lv_obj_add_flag(network_label_, LV_OBJ_FLAG_HIDDEN);
|
||||
lv_obj_add_flag(battery_label_, LV_OBJ_FLAG_HIDDEN);
|
||||
return;
|
||||
} else if (strcmp(status, Lang::Strings::THINKING) == 0) {
|
||||
lv_obj_set_style_text_font(status_label_, text_font, 0);
|
||||
lv_label_set_text(status_label_, status);
|
||||
lv_obj_clear_flag(status_label_, LV_OBJ_FLAG_HIDDEN);
|
||||
lv_obj_add_flag(network_label_, LV_OBJ_FLAG_HIDDEN);
|
||||
lv_obj_add_flag(battery_label_, LV_OBJ_FLAG_HIDDEN);
|
||||
return;
|
||||
} else if (strcmp(status, Lang::Strings::CONNECTING) == 0) {
|
||||
lv_obj_set_style_text_font(status_label_, &OTTO_ICON_FONT, 0);
|
||||
lv_label_set_text(status_label_, "\xEF\x83\x81"); // U+F0c1 连接图标
|
||||
@ -102,4 +109,4 @@ void ElectronEmojiDisplay::SetStatus(const char* status) {
|
||||
lv_obj_clear_flag(status_label_, LV_OBJ_FLAG_HIDDEN);
|
||||
lv_obj_clear_flag(network_label_, LV_OBJ_FLAG_HIDDEN);
|
||||
lv_obj_clear_flag(battery_label_, LV_OBJ_FLAG_HIDDEN);
|
||||
}
|
||||
}
|
||||
|
||||
@ -155,6 +155,8 @@ void EmojiWidget::SetStatus(const char* status)
|
||||
if (player_) {
|
||||
if (strcmp(status, Lang::Strings::LISTENING) == 0) {
|
||||
player_->StartPlayer("asking", true, 15);
|
||||
} else if (strcmp(status, Lang::Strings::THINKING) == 0) {
|
||||
player_->StartPlayer("thinking", true, 15);
|
||||
} else if (strcmp(status, Lang::Strings::STANDBY) == 0) {
|
||||
player_->StartPlayer("wake", true, 15);
|
||||
}
|
||||
|
||||
@ -231,9 +231,9 @@ private:
|
||||
// 如果当前是聆听状态，切换到待命状态
|
||||
ESP_LOGI(TAG, "从聆听状态切换到待命状态");
|
||||
app.ToggleChatState(); // 切换到待命状态
|
||||
} else if (current_state == kDeviceStateSpeaking) {
|
||||
// 如果当前是说话状态，终止说话并切换到待命状态
|
||||
ESP_LOGI(TAG, "从说话状态切换到待命状态");
|
||||
} else if (current_state == kDeviceStateSpeaking || current_state == kDeviceStateThinking) {
|
||||
// 如果当前是说话或思考状态，终止并切换到待命状态
|
||||
ESP_LOGI(TAG, "从说话/思考状态切换到待命状态");
|
||||
app.ToggleChatState(); // 终止说话
|
||||
} else {
|
||||
// 其他状态下只唤醒设备
|
||||
|
||||
@ -192,6 +192,7 @@ private:
|
||||
void PollTouchpad() {
|
||||
static bool was_touched = false;
|
||||
static int64_t touch_start_time = 0;
|
||||
static int touch_start_x = -1;
|
||||
const int64_t TOUCH_THRESHOLD_MS = 500; // 触摸时长阈值，超过500ms视为长按
|
||||
|
||||
ft6336_->UpdateTouchPoint();
|
||||
@ -201,11 +202,14 @@ private:
|
||||
if (touch_point.num > 0 && !was_touched) {
|
||||
was_touched = true;
|
||||
touch_start_time = esp_timer_get_time() / 1000; // 转换为毫秒
|
||||
touch_start_x = touch_point.x;
|
||||
}
|
||||
// 检测触摸释放
|
||||
else if (touch_point.num == 0 && was_touched) {
|
||||
was_touched = false;
|
||||
int64_t touch_duration = (esp_timer_get_time() / 1000) - touch_start_time;
|
||||
bool beaver_mode = touch_start_x >= DISPLAY_WIDTH / 2;
|
||||
auto agent_mode = beaver_mode ? kChatAgentModeBeaver : kChatAgentModeNormal;
|
||||
|
||||
if (touch_duration < TOUCH_THRESHOLD_MS) {
|
||||
auto& app = Application::GetInstance();
|
||||
@ -213,12 +217,12 @@ private:
|
||||
EnterWifiConfigMode();
|
||||
return;
|
||||
}
|
||||
ESP_LOGI(TAG, "Touch short: text-only mode");
|
||||
app.ToggleChatState();
|
||||
ESP_LOGI(TAG, "Touch short: %s text-only mode", beaver_mode ? "beaver" : "normal");
|
||||
app.ToggleChatStateForMode(agent_mode, false);
|
||||
} else {
|
||||
auto& app = Application::GetInstance();
|
||||
ESP_LOGI(TAG, "Touch long: vision+text mode");
|
||||
app.ToggleChatStateWithVision();
|
||||
ESP_LOGI(TAG, "Touch long: %s vision+text mode", beaver_mode ? "beaver" : "normal");
|
||||
app.ToggleChatStateForMode(agent_mode, true);
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -344,18 +348,23 @@ private:
|
||||
vTaskDelay(pdMS_TO_TICKS(BACKGROUND_VISION_INITIAL_DELAY_MS));
|
||||
|
||||
while (true) {
|
||||
if (!Application::GetInstance().IsVisionTextModeEnabled()) {
|
||||
vTaskDelay(pdMS_TO_TICKS(BACKGROUND_VISION_SAMPLE_INTERVAL_MS));
|
||||
continue;
|
||||
}
|
||||
|
||||
if (board->camera_ == nullptr) {
|
||||
vTaskDelay(pdMS_TO_TICKS(BACKGROUND_VISION_SAMPLE_INTERVAL_MS));
|
||||
continue;
|
||||
}
|
||||
|
||||
if (board->camera_->CaptureBackground()) {
|
||||
if (board->camera_->Capture()) {
|
||||
if (!has_logged_success) {
|
||||
ESP_LOGI(TAG, "Background vision sampler started");
|
||||
ESP_LOGI(TAG, "Vision preview sampler started");
|
||||
has_logged_success = true;
|
||||
}
|
||||
} else if (!has_logged_failure) {
|
||||
ESP_LOGW(TAG, "Background vision sampler is waiting for camera");
|
||||
ESP_LOGW(TAG, "Vision preview sampler is waiting for camera");
|
||||
has_logged_failure = true;
|
||||
}
|
||||
|
||||
|
||||
@ -77,6 +77,13 @@ void OttoEmojiDisplay::SetStatus(const char* status) {
|
||||
lv_obj_add_flag(network_label_, LV_OBJ_FLAG_HIDDEN);
|
||||
lv_obj_add_flag(battery_label_, LV_OBJ_FLAG_HIDDEN);
|
||||
return;
|
||||
} else if (strcmp(status, Lang::Strings::THINKING) == 0) {
|
||||
lv_obj_set_style_text_font(status_label_, text_font, 0);
|
||||
lv_label_set_text(status_label_, status);
|
||||
lv_obj_clear_flag(status_label_, LV_OBJ_FLAG_HIDDEN);
|
||||
lv_obj_add_flag(network_label_, LV_OBJ_FLAG_HIDDEN);
|
||||
lv_obj_add_flag(battery_label_, LV_OBJ_FLAG_HIDDEN);
|
||||
return;
|
||||
} else if (strcmp(status, Lang::Strings::CONNECTING) == 0) {
|
||||
lv_obj_set_style_text_font(status_label_, &OTTO_ICON_FONT, 0);
|
||||
lv_label_set_text(status_label_, "\xEF\x83\x81"); // U+F0c1 连接图标
|
||||
@ -131,4 +138,4 @@ void OttoEmojiDisplay::SetPreviewImage(std::unique_ptr<LvglImage> image) {
|
||||
lv_obj_remove_flag(preview_image_, LV_OBJ_FLAG_HIDDEN);
|
||||
esp_timer_stop(preview_timer_);
|
||||
ESP_ERROR_CHECK(esp_timer_start_once(preview_timer_, PREVIEW_IMAGE_DURATION_MS * 1000));
|
||||
}
|
||||
}
|
||||
|
||||
File diff suppressed because it is too large
Load Diff
@ -8,6 +8,7 @@ enum DeviceState {
|
||||
kDeviceStateIdle,
|
||||
kDeviceStateConnecting,
|
||||
kDeviceStateListening,
|
||||
kDeviceStateThinking,
|
||||
kDeviceStateSpeaking,
|
||||
kDeviceStateUpgrading,
|
||||
kDeviceStateActivating,
|
||||
@ -15,4 +16,4 @@ enum DeviceState {
|
||||
kDeviceStateFatalError
|
||||
};
|
||||
|
||||
#endif // _DEVICE_STATE_H_
|
||||
#endif // _DEVICE_STATE_H_
|
||||
|
||||
@ -13,6 +13,7 @@ static const char* const STATE_STRINGS[] = {
|
||||
"idle",
|
||||
"connecting",
|
||||
"listening",
|
||||
"thinking",
|
||||
"speaking",
|
||||
"upgrading",
|
||||
"activating",
|
||||
@ -69,9 +70,10 @@ bool DeviceStateMachine::IsValidTransition(DeviceState from, DeviceState to) con
|
||||
to == kDeviceStateActivating;
|
||||
|
||||
case kDeviceStateIdle:
|
||||
// Can go to connecting, listening (manual mode), speaking, activating, upgrading, or wifi configuring
|
||||
// Can go to connecting, listening (manual mode), thinking, speaking, activating, upgrading, or wifi configuring
|
||||
return to == kDeviceStateConnecting ||
|
||||
to == kDeviceStateListening ||
|
||||
to == kDeviceStateThinking ||
|
||||
to == kDeviceStateSpeaking ||
|
||||
to == kDeviceStateActivating ||
|
||||
to == kDeviceStateUpgrading ||
|
||||
@ -83,8 +85,15 @@ bool DeviceStateMachine::IsValidTransition(DeviceState from, DeviceState to) con
|
||||
to == kDeviceStateListening;
|
||||
|
||||
case kDeviceStateListening:
|
||||
// Can go to speaking or idle
|
||||
// Can go to thinking, speaking, or idle
|
||||
return to == kDeviceStateThinking ||
|
||||
to == kDeviceStateSpeaking ||
|
||||
to == kDeviceStateIdle;
|
||||
|
||||
case kDeviceStateThinking:
|
||||
// Can go to speaking, listening, or idle
|
||||
return to == kDeviceStateSpeaking ||
|
||||
to == kDeviceStateListening ||
|
||||
to == kDeviceStateIdle;
|
||||
|
||||
case kDeviceStateSpeaking:
|
||||
|
||||
@ -167,6 +167,8 @@ void EmoteDisplay::SetStatus(const char* const status)
|
||||
emote_set_event_msg(emote_handle_, EMOTE_MGR_EVT_LISTEN, NULL);
|
||||
} else if (std::strcmp(status, Lang::Strings::STANDBY) == 0) {
|
||||
emote_set_event_msg(emote_handle_, EMOTE_MGR_EVT_IDLE, NULL);
|
||||
} else if (std::strcmp(status, Lang::Strings::THINKING) == 0) {
|
||||
emote_set_event_msg(emote_handle_, EMOTE_MGR_EVT_LISTEN, NULL);
|
||||
} else if (std::strcmp(status, Lang::Strings::SPEAKING) == 0) {
|
||||
emote_set_event_msg(emote_handle_, EMOTE_MGR_EVT_SPEAK, NULL);
|
||||
} else if (std::strcmp(status, Lang::Strings::ERROR) == 0) {
|
||||
@ -247,4 +249,4 @@ void EmoteDisplay::RefreshAll()
|
||||
}
|
||||
}
|
||||
|
||||
} // namespace emote
|
||||
} // namespace emote
|
||||
|
||||
@ -203,6 +203,7 @@ void LvglDisplay::UpdateStatusBar(bool update_all) {
|
||||
kDeviceStateStarting,
|
||||
kDeviceStateWifiConfiguring,
|
||||
kDeviceStateListening,
|
||||
kDeviceStateThinking,
|
||||
kDeviceStateActivating,
|
||||
};
|
||||
if (std::find(allowed_states.begin(), allowed_states.end(), device_state) != allowed_states.end()) {
|
||||
|
||||
@ -228,6 +228,11 @@ void CircularStrip::OnStateChanged() {
|
||||
SetAllColor(color);
|
||||
break;
|
||||
}
|
||||
case kDeviceStateThinking: {
|
||||
StripColor color = { low_brightness_, low_brightness_, default_brightness_ };
|
||||
Blink(color, 300);
|
||||
break;
|
||||
}
|
||||
case kDeviceStateUpgrading: {
|
||||
StripColor color = { low_brightness_, default_brightness_, low_brightness_ };
|
||||
Blink(color, 100);
|
||||
|
||||
@ -235,6 +235,10 @@ void GpioLed::OnStateChanged() {
|
||||
// TurnOn();
|
||||
StartFadeTask();
|
||||
break;
|
||||
case kDeviceStateThinking:
|
||||
SetBrightness(DEFAULT_BRIGHTNESS);
|
||||
StartContinuousBlink(300);
|
||||
break;
|
||||
case kDeviceStateSpeaking:
|
||||
SetBrightness(SPEAKING_BRIGHTNESS);
|
||||
TurnOn();
|
||||
@ -260,4 +264,4 @@ void GpioLed::EventTask(void* arg) {
|
||||
ulTaskNotifyTake(pdTRUE, portMAX_DELAY);
|
||||
led->OnFadeEnd();
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@ -152,6 +152,10 @@ void SingleLed::OnStateChanged() {
|
||||
SetColor(0, DEFAULT_BRIGHTNESS, 0);
|
||||
TurnOn();
|
||||
break;
|
||||
case kDeviceStateThinking:
|
||||
SetColor(0, 0, DEFAULT_BRIGHTNESS);
|
||||
StartContinuousBlink(300);
|
||||
break;
|
||||
case kDeviceStateUpgrading:
|
||||
SetColor(0, DEFAULT_BRIGHTNESS, 0);
|
||||
StartContinuousBlink(100);
|
||||
|
||||
@ -119,6 +119,8 @@ bool WebsocketProtocol::OpenAudioChannel() {
|
||||
websocket_->SetHeader("Protocol-Version", std::to_string(version_).c_str());
|
||||
websocket_->SetHeader("Device-Id", SystemInfo::GetMacAddress().c_str());
|
||||
websocket_->SetHeader("Client-Id", Board::GetInstance().GetUuid().c_str());
|
||||
websocket_->SetHeader("Agent-Mode", Application::GetInstance().GetChatAgentModeName());
|
||||
websocket_->SetHeader("Chat-Mode", Application::GetInstance().GetChatModeName());
|
||||
|
||||
websocket_->OnData([this](const char* data, size_t len, bool binary) {
|
||||
if (binary) {
|
||||
|
||||
Reference in New Issue
Block a user