Bairan.Zhang/AI_Printer
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

语音对话

Browse Source
This commit is contained in:
admin
2026-02-25 11:16:30 +08:00
parent e9ac05592c
commit 9d060f9f40
5 changed files with 612 additions and 58 deletions
Download Patch File Download Diff File Expand all files Collapse all files

390
main/domain/src/voice_interaction.c
View File

@@ -13,12 +13,14 @@
#include "esp_log.h"
#include "esp_mac.h"
#include "esp_random.h"
#include "esp_heap_caps.h"
#include "esp_system.h"
#include "esp_timer.h"
#include "esp_websocket_client.h"
#include "esp_opus_dec.h"
#include "esp_opus_enc.h"
#include "freertos/FreeRTOS.h"
#include "freertos/idf_additions.h"
#include "freertos/semphr.h"
#include "freertos/task.h"
#include "voice_audio.h"
@@ -32,7 +34,8 @@
#define VOICE_SAMPLE_BYTES 2
#define VOICE_STATUS_LOCK_TIMEOUT_MS 1000
#define VOICE_WS_SEND_TIMEOUT_MS 1000
#define VOICE_UPLINK_TASK_STACK 8192
#define VOICE_WS_TASK_STACK 24576
#define VOICE_UPLINK_TASK_STACK 32768
#define VOICE_HEARTBEAT_TASK_STACK 4096
#define VOICE_START_CONNECT_TIMEOUT_MS 8000
#define VOICE_AUDIO_IO_TIMEOUT_MS 1200
@@ -45,6 +48,8 @@ typedef struct {
TaskHandle_t uplink_task;
TaskHandle_t heartbeat_task;
bool uplink_task_with_caps;
bool heartbeat_task_with_caps;
void *opus_enc;
void *opus_dec;
@@ -69,6 +74,7 @@ typedef struct {
bool started;
bool tap_active;
bool stop_requested;
bool ws_low_stack_warned;
voice_dialog_state_t dialog_state;
@@ -112,6 +118,143 @@ static void voice_unlock(void) {
}
}
static void voice_log_status_snapshot(const char *stage) {
if (!voice_lock(VOICE_STATUS_LOCK_TIMEOUT_MS)) {
ESP_LOGW(TAG, "[stage] %s: status snapshot lock timeout", stage);
return;
}
ESP_LOGI(TAG,
"[stage] %s: active=%d ws=%d started=%d tap=%d state=%s up=%" PRIu32 " down=%" PRIu32 " err=%s",
stage,
s_voice.session_active,
s_voice.ws_connected,
s_voice.started,
s_voice.tap_active,
voice_interaction_dialog_state_str(s_voice.dialog_state),
s_voice.upstream_packets,
s_voice.downstream_packets,
s_voice.last_error[0] != '\0' ? s_voice.last_error : "-");
voice_unlock();
}
static void voice_log_heap_snapshot(const char *stage) {
size_t free_8bit = heap_caps_get_free_size(MALLOC_CAP_8BIT);
size_t free_internal = heap_caps_get_free_size(MALLOC_CAP_INTERNAL | MALLOC_CAP_8BIT);
size_t free_spiram = heap_caps_get_free_size(MALLOC_CAP_SPIRAM | MALLOC_CAP_8BIT);
size_t largest_8bit = heap_caps_get_largest_free_block(MALLOC_CAP_8BIT);
size_t largest_internal = heap_caps_get_largest_free_block(MALLOC_CAP_INTERNAL | MALLOC_CAP_8BIT);
size_t largest_spiram = heap_caps_get_largest_free_block(MALLOC_CAP_SPIRAM | MALLOC_CAP_8BIT);
ESP_LOGI(TAG,
"[stage] %s heap: free8=%u free_internal=%u free_spiram=%u largest8=%u largest_internal=%u largest_spiram=%u",
stage,
(unsigned)free_8bit,
(unsigned)free_internal,
(unsigned)free_spiram,
(unsigned)largest_8bit,
(unsigned)largest_internal,
(unsigned)largest_spiram);
}
static void *voice_malloc_prefer_psram(size_t size) {
void *ptr = heap_caps_malloc(size, MALLOC_CAP_SPIRAM | MALLOC_CAP_8BIT);
if (ptr == NULL) {
ptr = malloc(size);
}
return ptr;
}
static void *voice_calloc_prefer_psram(size_t n, size_t size) {
void *ptr = heap_caps_calloc(n, size, MALLOC_CAP_SPIRAM | MALLOC_CAP_8BIT);
if (ptr == NULL) {
ptr = calloc(n, size);
}
return ptr;
}
static void *voice_realloc_prefer_psram(void *ptr, size_t size) {
void *new_ptr = heap_caps_realloc(ptr, size, MALLOC_CAP_SPIRAM | MALLOC_CAP_8BIT);
if (new_ptr == NULL) {
new_ptr = realloc(ptr, size);
}
return new_ptr;
}
static BaseType_t voice_create_task_prefer_psram(TaskFunction_t task_fn,
const char *name,
uint32_t stack_size,
UBaseType_t priority,
TaskHandle_t *out_task,
bool *out_with_caps) {
if (out_with_caps != NULL) {
*out_with_caps = false;
}
BaseType_t rc = pdFAIL;
#if defined(CONFIG_SPIRAM_ALLOW_STACK_EXTERNAL_MEMORY) && \
defined(CONFIG_FREERTOS_TASK_CREATE_ALLOW_EXT_MEM) && \
(configSUPPORT_STATIC_ALLOCATION == 1)
rc = xTaskCreatePinnedToCoreWithCaps(task_fn,
name,
(configSTACK_DEPTH_TYPE)stack_size,
NULL,
priority,
out_task,
tskNO_AFFINITY,
MALLOC_CAP_SPIRAM | MALLOC_CAP_8BIT);
if (rc == pdPASS) {
if (out_with_caps != NULL) {
*out_with_caps = true;
}
ESP_LOGI(TAG, "[stage] task_create_psram_ok: name=%s stack=%u", name, (unsigned)stack_size);
return pdPASS;
}
ESP_LOGW(TAG, "[stage] task_create_psram_failed: name=%s stack=%u", name, (unsigned)stack_size);
#endif
rc = xTaskCreate(task_fn,
name,
(configSTACK_DEPTH_TYPE)stack_size,
NULL,
priority,
out_task);
if (rc == pdPASS) {
ESP_LOGI(TAG, "[stage] task_create_internal_ok: name=%s stack=%u", name, (unsigned)stack_size);
} else {
ESP_LOGE(TAG, "[stage] task_create_internal_failed: name=%s stack=%u", name, (unsigned)stack_size);
}
return rc;
}
static void voice_delete_task(TaskHandle_t task, bool with_caps) {
if (task == NULL) {
return;
}
#if (configSUPPORT_STATIC_ALLOCATION == 1)
if (with_caps) {
vTaskDeleteWithCaps(task);
return;
}
#else
(void)with_caps;
#endif
vTaskDelete(task);
}
static void voice_delete_self_task(bool with_caps) {
#if (configSUPPORT_STATIC_ALLOCATION == 1)
if (with_caps) {
vTaskDeleteWithCaps(NULL);
return;
}
#else
(void)with_caps;
#endif
vTaskDelete(NULL);
}
static void voice_make_uuid(char out[40]) {
uint8_t raw[16];
esp_fill_random(raw, sizeof(raw));
@@ -317,6 +460,7 @@ static esp_err_t voice_send_text(const char *text, int len) {
voice_unlock();
if (ws == NULL || !connected) {
ESP_LOGW(TAG, "[stage] ws_send_text skipped: ws=%p connected=%d len=%d", (void *)ws, connected, len);
return ESP_ERR_INVALID_STATE;
}
@@ -325,8 +469,10 @@ static esp_err_t voice_send_text(const char *text, int len) {
len,
pdMS_TO_TICKS(VOICE_WS_SEND_TIMEOUT_MS));
if (ret < 0) {
ESP_LOGW(TAG, "[stage] ws_send_text failed: len=%d", len);
return ESP_FAIL;
}
ESP_LOGI(TAG, "[stage] ws_send_text ok: len=%d", len);
return ESP_OK;
}
@@ -345,6 +491,12 @@ static esp_err_t voice_send_directive(const char *action,
}
esp_err_t err = voice_send_text(text, (int)strlen(text));
ESP_LOGI(TAG,
"[stage] directive: action=%s directive=%s with_dialog_id=%d result=%s",
action,
directive,
with_dialog_id,
esp_err_to_name(err));
cJSON_free(text);
return err;
}
@@ -385,7 +537,7 @@ static void voice_handle_downstream_packet(const uint8_t *data, size_t len) {
esp_audio_err_t ret = esp_opus_dec_decode(opus_dec, &raw, &out, &dec_info);
if (ret == ESP_AUDIO_ERR_BUFF_NOT_ENOUGH) {
if (out.needed_size > pcm_buf_size) {
uint8_t *new_buf = (uint8_t *)realloc(pcm_buf, out.needed_size);
uint8_t *new_buf = (uint8_t *)voice_realloc_prefer_psram(pcm_buf, out.needed_size);
if (new_buf == NULL) {
ESP_LOGE(TAG, "No memory to extend pcm rx buffer to %u", out.needed_size);
break;
@@ -441,6 +593,33 @@ static const char *voice_get_json_str(cJSON *obj, const char *name) {
return NULL;
}
static bool voice_get_json_bool(cJSON *obj, const char *name, bool *out_value) {
if (obj == NULL || name == NULL || out_value == NULL) {
return false;
}
cJSON *item = cJSON_GetObjectItemCaseSensitive(obj, name);
if (!cJSON_IsBool(item)) {
return false;
}
*out_value = cJSON_IsTrue(item);
return true;
}
static void voice_log_final_text(const char *stage, const char *text) {
if (stage == NULL || text == NULL || text[0] == '\0') {
return;
}
size_t len = strlen(text);
const int preview = 240;
ESP_LOGI(TAG,
"[stage] %s: len=%u text=%.*s%s",
stage,
(unsigned)len,
preview,
text,
(len > (size_t)preview) ? "..." : "");
}
static void voice_handle_output_event(cJSON *output) {
const char *event_name = voice_get_json_str(output, "event");
if (event_name == NULL) {
@@ -448,6 +627,29 @@ static void voice_handle_output_event(cJSON *output) {
}
const char *dialog_id = voice_get_json_str(output, "dialog_id");
const char *state = NULL;
if (strcmp(event_name, "DialogStateChanged") == 0) {
state = voice_get_json_str(output, "state");
}
ESP_LOGI(TAG,
"[stage] ws_event_output: event=%s dialog_id=%s state=%s",
event_name,
dialog_id != NULL ? dialog_id : "-",
state != NULL ? state : "-");
bool finished = false;
bool has_finished = voice_get_json_bool(output, "finished", &finished);
if (has_finished && finished) {
if (strcmp(event_name, "SpeechContent") == 0) {
voice_log_final_text("asr_final_text", voice_get_json_str(output, "text"));
} else if (strcmp(event_name, "RespondingContent") == 0) {
const char *final_text = voice_get_json_str(output, "text");
if (final_text == NULL || final_text[0] == '\0') {
final_text = voice_get_json_str(output, "spoken");
}
voice_log_final_text("response_final_text", final_text);
}
}
if (voice_lock(VOICE_STATUS_LOCK_TIMEOUT_MS)) {
if (dialog_id != NULL) {
@@ -458,8 +660,8 @@ static void voice_handle_output_event(cJSON *output) {
if (strcmp(event_name, "Started") == 0) {
s_voice.started = true;
s_voice.dialog_state = VOICE_DIALOG_STATE_IDLE;
ESP_LOGI(TAG, "[stage] session_started: dialog_id=%s", s_voice.dialog_id);
} else if (strcmp(event_name, "DialogStateChanged") == 0) {
const char *state = voice_get_json_str(output, "state");
if (state != NULL) {
if (strcmp(state, "Listening") == 0) {
s_voice.dialog_state = VOICE_DIALOG_STATE_LISTENING;
@@ -469,16 +671,22 @@ static void voice_handle_output_event(cJSON *output) {
s_voice.dialog_state = VOICE_DIALOG_STATE_RESPONDING;
}
}
ESP_LOGI(TAG,
"[stage] dialog_state_changed: state=%s current=%s",
state != NULL ? state : "-",
voice_interaction_dialog_state_str(s_voice.dialog_state));
} else if (strcmp(event_name, "SpeechEnded") == 0) {
s_voice.tap_active = false;
ESP_LOGI(TAG, "[stage] speech_ended: keep tap_active=%d for continuous rounds", s_voice.tap_active);
} else if (strcmp(event_name, "Stopped") == 0) {
s_voice.started = false;
s_voice.tap_active = false;
s_voice.dialog_state = VOICE_DIALOG_STATE_IDLE;
ESP_LOGI(TAG, "[stage] session_stopped_by_server");
} else if (strcmp(event_name, "Error") == 0) {
const char *error_msg = voice_get_json_str(output, "error_message");
if (error_msg != NULL) {
voice_set_last_error_locked(error_msg);
ESP_LOGW(TAG, "[stage] server_error: %s", error_msg);
}
s_voice.tap_active = false;
}
@@ -512,6 +720,10 @@ static void voice_handle_text_message(const char *text, size_t len) {
cJSON *status_code = cJSON_GetObjectItemCaseSensitive(header, "status_code");
cJSON *status_msg = cJSON_GetObjectItemCaseSensitive(header, "status_message");
if (cJSON_IsNumber(status_code) && status_code->valueint >= 400) {
ESP_LOGW(TAG,
"[stage] ws_header_error: status_code=%d status_message=%s",
status_code->valueint,
(cJSON_IsString(status_msg) && status_msg->valuestring != NULL) ? status_msg->valuestring : "-");
if (voice_lock(VOICE_STATUS_LOCK_TIMEOUT_MS)) {
if (cJSON_IsString(status_msg) && status_msg->valuestring != NULL) {
voice_set_last_error_locked(status_msg->valuestring);
@@ -527,6 +739,7 @@ static void voice_handle_text_message(const char *text, size_t len) {
voice_handle_output_event(output);
} else if (header_event != NULL && strcmp(header_event, "task-failed") == 0) {
const char *error_msg = voice_get_json_str(header, "error_message");
ESP_LOGW(TAG, "[stage] ws_task_failed: %s", error_msg != NULL ? error_msg : "task failed");
if (voice_lock(VOICE_STATUS_LOCK_TIMEOUT_MS)) {
voice_set_last_error_locked(error_msg != NULL ? error_msg : "task failed");
voice_unlock();
@@ -546,8 +759,9 @@ static void voice_handle_text_chunk(esp_websocket_event_data_t *data) {
return;
}
s_voice.text_agg = (uint8_t *)calloc(1, (size_t)data->payload_len + 1);
s_voice.text_agg = (uint8_t *)voice_calloc_prefer_psram(1, (size_t)data->payload_len + 1);
if (s_voice.text_agg == NULL) {
ESP_LOGW(TAG, "[stage] text_agg_alloc_failed: len=%d", data->payload_len);
return;
}
s_voice.text_agg_size = (size_t)data->payload_len;
@@ -588,8 +802,9 @@ static void voice_handle_binary_chunk(esp_websocket_event_data_t *data) {
return;
}
s_voice.bin_agg = (uint8_t *)malloc((size_t)data->payload_len);
s_voice.bin_agg = (uint8_t *)voice_malloc_prefer_psram((size_t)data->payload_len);
if (s_voice.bin_agg == NULL) {
ESP_LOGW(TAG, "[stage] bin_agg_alloc_failed: len=%d", data->payload_len);
return;
}
s_voice.bin_agg_size = (size_t)data->payload_len;
@@ -627,10 +842,16 @@ static void voice_websocket_event_handler(void *handler_args,
(void)handler_args;
(void)base;
UBaseType_t ws_hwm = uxTaskGetStackHighWaterMark(NULL);
if (!s_voice.ws_low_stack_warned && ws_hwm < 256) {
s_voice.ws_low_stack_warned = true;
ESP_LOGW(TAG, "[stage] ws_task_low_stack: hwm_words=%u", (unsigned)ws_hwm);
}
esp_websocket_event_data_t *data = (esp_websocket_event_data_t *)event_data;
switch ((esp_websocket_event_id_t)event_id) {
case WEBSOCKET_EVENT_CONNECTED: {
ESP_LOGI(TAG, "websocket connected");
ESP_LOGI(TAG, "[stage] ws_connected");
if (voice_lock(VOICE_STATUS_LOCK_TIMEOUT_MS)) {
s_voice.ws_connected = true;
s_voice.last_event_ms = voice_now_ms();
@@ -643,13 +864,16 @@ static void voice_websocket_event_handler(void *handler_args,
voice_unlock();
}
if (start_msg != NULL) {
(void)voice_send_text(start_msg, (int)strlen(start_msg));
esp_err_t send_err = voice_send_text(start_msg, (int)strlen(start_msg));
ESP_LOGI(TAG, "[stage] start_message_sent: result=%s", esp_err_to_name(send_err));
cJSON_free(start_msg);
} else {
ESP_LOGE(TAG, "[stage] start_message_build_failed");
}
break;
}
case WEBSOCKET_EVENT_DISCONNECTED:
ESP_LOGW(TAG, "websocket disconnected");
ESP_LOGW(TAG, "[stage] ws_disconnected");
if (voice_lock(VOICE_STATUS_LOCK_TIMEOUT_MS)) {
s_voice.ws_connected = false;
s_voice.started = false;
@@ -670,6 +894,7 @@ static void voice_websocket_event_handler(void *handler_args,
}
break;
case WEBSOCKET_EVENT_ERROR:
ESP_LOGW(TAG, "[stage] ws_error");
if (voice_lock(VOICE_STATUS_LOCK_TIMEOUT_MS)) {
voice_set_last_error_locked("websocket error");
s_voice.last_event_ms = voice_now_ms();
@@ -685,8 +910,19 @@ static void voice_uplink_task(void *arg) {
(void)arg;
const int frame_ms = CONFIG_TQ_VOICE_OPUS_FRAME_MS;
bool low_stack_warned = false;
UBaseType_t start_hwm = uxTaskGetStackHighWaterMark(NULL);
ESP_LOGI(TAG, "[stage] uplink_task_started: stack_hwm_words=%u", (unsigned)start_hwm);
while (true) {
if (!low_stack_warned) {
UBaseType_t hwm = uxTaskGetStackHighWaterMark(NULL);
if (hwm < 256) {
low_stack_warned = true;
ESP_LOGW(TAG, "[stage] uplink_task_low_stack: hwm_words=%u", (unsigned)hwm);
}
}
bool active = false;
bool connected = false;
bool started = false;
@@ -762,11 +998,14 @@ static void voice_uplink_task(void *arg) {
}
}
bool delete_with_caps = false;
if (voice_lock(VOICE_STATUS_LOCK_TIMEOUT_MS)) {
delete_with_caps = s_voice.uplink_task_with_caps;
s_voice.uplink_task = NULL;
s_voice.uplink_task_with_caps = false;
voice_unlock();
}
vTaskDelete(NULL);
voice_delete_self_task(delete_with_caps);
}
static void voice_heartbeat_task(void *arg) {
@@ -789,17 +1028,21 @@ static void voice_heartbeat_task(void *arg) {
}
if (connected && started) {
ESP_LOGI(TAG, "[stage] heartbeat_send");
(void)voice_send_directive("continue-task", "HeartBeat", true);
}
vTaskDelay(pdMS_TO_TICKS(CONFIG_TQ_VOICE_HEARTBEAT_SEC * 1000));
}
bool delete_with_caps = false;
if (voice_lock(VOICE_STATUS_LOCK_TIMEOUT_MS)) {
delete_with_caps = s_voice.heartbeat_task_with_caps;
s_voice.heartbeat_task = NULL;
s_voice.heartbeat_task_with_caps = false;
voice_unlock();
}
vTaskDelete(NULL);
voice_delete_self_task(delete_with_caps);
}
static esp_err_t voice_setup_opus(char *err, size_t err_len) {
@@ -841,8 +1084,8 @@ static esp_err_t voice_setup_opus(char *err, size_t err_len) {
return ESP_FAIL;
}
s_voice.pcm_tx_buf = (int16_t *)malloc((size_t)s_voice.opus_enc_in_size);
s_voice.opus_tx_buf = (uint8_t *)malloc((size_t)s_voice.opus_enc_out_size);
s_voice.pcm_tx_buf = (int16_t *)voice_malloc_prefer_psram((size_t)s_voice.opus_enc_in_size);
s_voice.opus_tx_buf = (uint8_t *)voice_malloc_prefer_psram((size_t)s_voice.opus_enc_out_size);
if (s_voice.pcm_tx_buf == NULL || s_voice.opus_tx_buf == NULL) {
voice_fill_err(err, err_len, "no memory for opus tx buffers");
return ESP_ERR_NO_MEM;
@@ -870,7 +1113,7 @@ static esp_err_t voice_setup_opus(char *err, size_t err_len) {
rx_pcm_size = 2048;
}
s_voice.pcm_rx_buf = (uint8_t *)malloc(rx_pcm_size);
s_voice.pcm_rx_buf = (uint8_t *)voice_malloc_prefer_psram(rx_pcm_size);
if (s_voice.pcm_rx_buf == NULL) {
voice_fill_err(err, err_len, "no memory for opus rx buffer");
return ESP_ERR_NO_MEM;
@@ -931,8 +1174,10 @@ esp_err_t voice_interaction_init(void) {
}
esp_err_t voice_interaction_start(char *err, size_t err_len) {
ESP_LOGI(TAG, "[stage] session_start_enter");
if (!s_voice.ready) {
voice_fill_err(err, err_len, "voice interaction not initialized");
ESP_LOGW(TAG, "[stage] session_start_abort: not initialized");
return ESP_ERR_INVALID_STATE;
}
@@ -940,17 +1185,28 @@ esp_err_t voice_interaction_start(char *err, size_t err_len) {
strlen(CONFIG_TQ_VOICE_WORKSPACE_ID) == 0 ||
strlen(CONFIG_TQ_VOICE_APP_ID) == 0) {
voice_fill_err(err, err_len, "voice API key/workspace/app_id is missing");
ESP_LOGW(TAG, "[stage] session_start_abort: config missing");
return ESP_ERR_INVALID_STATE;
}
ESP_LOGI(TAG,
"[stage] session_config_ok: ws_uri=%s sample_rate=%d frame_ms=%d bitrate_kbps=%d ws_stack=%d",
CONFIG_TQ_VOICE_WS_URI,
CONFIG_TQ_VOICE_SAMPLE_RATE,
CONFIG_TQ_VOICE_OPUS_FRAME_MS,
CONFIG_TQ_VOICE_OPUS_BITRATE_KBPS,
VOICE_WS_TASK_STACK);
if (!voice_lock(VOICE_STATUS_LOCK_TIMEOUT_MS)) {
voice_fill_err(err, err_len, "voice lock timeout");
ESP_LOGW(TAG, "[stage] session_start_abort: lock timeout");
return ESP_ERR_TIMEOUT;
}
bool already_active = s_voice.session_active;
voice_unlock();
if (already_active) {
ESP_LOGI(TAG, "[stage] session_start_skip: already active");
voice_log_status_snapshot("already_active");
return ESP_OK;
}
@@ -962,12 +1218,16 @@ esp_err_t voice_interaction_start(char *err, size_t err_len) {
.input_gain_db = (float)CONFIG_TQ_VOICE_CODEC_MIC_GAIN_DB,
};
ESP_LOGI(TAG, "[stage] audio_open_begin");
ESP_RETURN_ON_ERROR(voice_audio_open(&audio_cfg, err, err_len), TAG, "voice audio open failed");
ESP_LOGI(TAG, "[stage] audio_open_ok");
ESP_LOGI(TAG, "[stage] opus_setup_begin");
esp_err_t opus_setup_err = voice_setup_opus(err, err_len);
if (opus_setup_err != ESP_OK) {
ESP_LOGE(TAG, "voice opus setup failed: %s", esp_err_to_name(opus_setup_err));
goto exit_err;
}
ESP_LOGI(TAG, "[stage] opus_setup_ok");
if (voice_lock(VOICE_STATUS_LOCK_TIMEOUT_MS)) {
voice_make_uuid(s_voice.task_id);
@@ -979,7 +1239,14 @@ esp_err_t voice_interaction_start(char *err, size_t err_len) {
s_voice.dialog_state = VOICE_DIALOG_STATE_IDLE;
s_voice.stop_requested = false;
s_voice.tap_active = false;
s_voice.ws_low_stack_warned = false;
s_voice.uplink_task_with_caps = false;
s_voice.heartbeat_task_with_caps = false;
s_voice.last_event_ms = voice_now_ms();
ESP_LOGI(TAG,
"[stage] session_context_prepared: task_id=%s device_uuid=%s",
s_voice.task_id,
s_voice.device_uuid);
voice_unlock();
}
@@ -987,7 +1254,7 @@ esp_err_t voice_interaction_start(char *err, size_t err_len) {
.uri = CONFIG_TQ_VOICE_WS_URI,
.task_name = "voice_ws",
.task_prio = 5,
.task_stack = 8192,
.task_stack = VOICE_WS_TASK_STACK,
.buffer_size = 2048,
.network_timeout_ms = 10000,
.reconnect_timeout_ms = 3000,
@@ -999,42 +1266,54 @@ esp_err_t voice_interaction_start(char *err, size_t err_len) {
#endif
};
ESP_LOGI(TAG, "[stage] ws_init_begin");
esp_websocket_client_handle_t ws = esp_websocket_client_init(&ws_cfg);
if (ws == NULL) {
voice_fill_err(err, err_len, "websocket init failed");
ESP_LOGE(TAG, "[stage] ws_init_failed");
goto exit_err;
}
ESP_LOGI(TAG, "[stage] ws_init_ok");
size_t auth_len = strlen(CONFIG_TQ_VOICE_API_KEY) + 8;
char *auth_value = (char *)malloc(auth_len);
if (auth_value == NULL) {
voice_fill_err(err, err_len, "no memory for auth header");
ESP_LOGE(TAG, "[stage] ws_auth_header_alloc_failed");
esp_websocket_client_destroy(ws);
goto exit_err;
}
snprintf(auth_value, auth_len, "Bearer %s", CONFIG_TQ_VOICE_API_KEY);
esp_websocket_client_append_header(ws, "Authorization", auth_value);
free(auth_value);
ESP_LOGI(TAG, "[stage] ws_auth_header_set");
ESP_LOGI(TAG, "[stage] ws_register_events_begin");
esp_err_t reg_err = esp_websocket_register_events(ws,
WEBSOCKET_EVENT_ANY,
voice_websocket_event_handler,
NULL);
if (reg_err != ESP_OK) {
voice_fill_err(err, err_len, "websocket register events failed");
ESP_LOGE(TAG, "[stage] ws_register_events_failed: %s", esp_err_to_name(reg_err));
esp_websocket_client_destroy(ws);
goto exit_err;
}
ESP_LOGI(TAG, "[stage] ws_register_events_ok");
ESP_LOGI(TAG, "[stage] ws_start_begin");
esp_err_t ws_start_err = esp_websocket_client_start(ws);
if (ws_start_err != ESP_OK) {
voice_fill_err(err, err_len, "websocket start failed");
ESP_LOGE(TAG, "[stage] ws_start_failed: %s", esp_err_to_name(ws_start_err));
esp_websocket_client_destroy(ws);
goto exit_err;
}
ESP_LOGI(TAG, "[stage] ws_start_ok");
if (!voice_lock(VOICE_STATUS_LOCK_TIMEOUT_MS)) {
voice_fill_err(err, err_len, "voice lock timeout");
ESP_LOGE(TAG, "[stage] session_start_abort: lock timeout after ws_start");
esp_websocket_client_stop(ws);
esp_websocket_client_destroy(ws);
goto exit_err;
@@ -1044,31 +1323,44 @@ esp_err_t voice_interaction_start(char *err, size_t err_len) {
s_voice.ws_connected = false;
s_voice.started = false;
voice_unlock();
voice_log_status_snapshot("session_marked_active");
voice_log_heap_snapshot("before_create_uplink");
BaseType_t ok = xTaskCreate(voice_uplink_task,
"voice_uplink",
VOICE_UPLINK_TASK_STACK,
NULL,
5,
&s_voice.uplink_task);
ESP_LOGI(TAG, "[stage] uplink_task_create_begin");
BaseType_t ok = voice_create_task_prefer_psram(voice_uplink_task,
"voice_uplink",
VOICE_UPLINK_TASK_STACK,
5,
&s_voice.uplink_task,
&s_voice.uplink_task_with_caps);
if (ok != pdPASS) {
voice_fill_err(err, err_len, "create uplink task failed");
ESP_LOGE(TAG, "[stage] uplink_task_create_failed");
voice_log_heap_snapshot("uplink_create_failed");
(void)voice_interaction_stop(NULL, 0);
return ESP_ERR_NO_MEM;
}
ESP_LOGI(TAG, "[stage] uplink_task_create_ok");
voice_log_heap_snapshot("after_create_uplink");
ok = xTaskCreate(voice_heartbeat_task,
"voice_hb",
VOICE_HEARTBEAT_TASK_STACK,
NULL,
4,
&s_voice.heartbeat_task);
ESP_LOGI(TAG, "[stage] heartbeat_task_create_begin");
ok = voice_create_task_prefer_psram(voice_heartbeat_task,
"voice_hb",
VOICE_HEARTBEAT_TASK_STACK,
4,
&s_voice.heartbeat_task,
&s_voice.heartbeat_task_with_caps);
if (ok != pdPASS) {
voice_fill_err(err, err_len, "create heartbeat task failed");
ESP_LOGE(TAG, "[stage] heartbeat_task_create_failed");
voice_log_heap_snapshot("heartbeat_create_failed");
(void)voice_interaction_stop(NULL, 0);
return ESP_ERR_NO_MEM;
}
ESP_LOGI(TAG, "[stage] heartbeat_task_create_ok");
voice_log_heap_snapshot("after_create_heartbeat");
ESP_LOGI(TAG, "[stage] wait_ws_connected_begin: timeout_ms=%d", VOICE_START_CONNECT_TIMEOUT_MS);
int64_t deadline = voice_now_ms() + VOICE_START_CONNECT_TIMEOUT_MS;
while (voice_now_ms() < deadline) {
bool connected = false;
@@ -1084,6 +1376,7 @@ esp_err_t voice_interaction_start(char *err, size_t err_len) {
if (!voice_lock(VOICE_STATUS_LOCK_TIMEOUT_MS)) {
voice_fill_err(err, err_len, "voice lock timeout");
ESP_LOGE(TAG, "[stage] wait_ws_connected_abort: lock timeout");
(void)voice_interaction_stop(NULL, 0);
return ESP_ERR_TIMEOUT;
}
@@ -1091,13 +1384,18 @@ esp_err_t voice_interaction_start(char *err, size_t err_len) {
voice_unlock();
if (!connected) {
voice_fill_err(err, err_len, "websocket connect timeout");
ESP_LOGE(TAG, "[stage] wait_ws_connected_timeout");
voice_log_status_snapshot("wait_ws_connected_timeout");
(void)voice_interaction_stop(NULL, 0);
return ESP_ERR_TIMEOUT;
}
ESP_LOGI(TAG, "[stage] wait_ws_connected_ok");
voice_log_status_snapshot("session_start_exit_ok");
return ESP_OK;
exit_err:
ESP_LOGE(TAG, "[stage] session_start_exit_err: %s", (err != NULL && err[0] != '\0') ? err : "unknown");
voice_release_runtime_resources();
voice_audio_close();
return ESP_FAIL;
@@ -1106,17 +1404,21 @@ exit_err:
esp_err_t voice_interaction_stop(char *err, size_t err_len) {
(void)err;
(void)err_len;
ESP_LOGI(TAG, "[stage] session_stop_enter");
if (!s_voice.ready) {
ESP_LOGW(TAG, "[stage] session_stop_abort: not initialized");
return ESP_ERR_INVALID_STATE;
}
if (!voice_lock(VOICE_STATUS_LOCK_TIMEOUT_MS)) {
ESP_LOGW(TAG, "[stage] session_stop_abort: lock timeout");
return ESP_ERR_TIMEOUT;
}
if (!s_voice.session_active) {
voice_unlock();
ESP_LOGI(TAG, "[stage] session_stop_skip: not active");
return ESP_OK;
}
@@ -1124,34 +1426,37 @@ esp_err_t voice_interaction_stop(char *err, size_t err_len) {
bool ws_connected = s_voice.ws_connected;
TaskHandle_t uplink_task = s_voice.uplink_task;
TaskHandle_t heartbeat_task = s_voice.heartbeat_task;
bool uplink_task_with_caps = s_voice.uplink_task_with_caps;
bool heartbeat_task_with_caps = s_voice.heartbeat_task_with_caps;
esp_websocket_client_handle_t ws = s_voice.ws;
s_voice.tap_active = false;
voice_unlock();
voice_log_status_snapshot("session_stop_requested");
if (ws_connected) {
(void)voice_send_directive("finish-task", "Stop", true);
}
if (uplink_task != NULL) {
vTaskDelete(uplink_task);
}
if (heartbeat_task != NULL) {
vTaskDelete(heartbeat_task);
}
voice_delete_task(uplink_task, uplink_task_with_caps);
voice_delete_task(heartbeat_task, heartbeat_task_with_caps);
if (ws != NULL) {
ESP_LOGI(TAG, "[stage] ws_stop_destroy_begin");
esp_websocket_unregister_events(ws,
WEBSOCKET_EVENT_ANY,
voice_websocket_event_handler);
esp_websocket_client_stop(ws);
esp_websocket_client_destroy(ws);
ESP_LOGI(TAG, "[stage] ws_stop_destroy_ok");
}
if (voice_lock(VOICE_STATUS_LOCK_TIMEOUT_MS)) {
s_voice.ws = NULL;
s_voice.uplink_task = NULL;
s_voice.heartbeat_task = NULL;
s_voice.uplink_task_with_caps = false;
s_voice.heartbeat_task_with_caps = false;
s_voice.ws_connected = false;
s_voice.started = false;
s_voice.session_active = false;
@@ -1160,19 +1465,28 @@ esp_err_t voice_interaction_stop(char *err, size_t err_len) {
s_voice.dialog_id[0] = '\0';
voice_unlock();
}
voice_log_status_snapshot("session_stop_cleared");
voice_release_runtime_resources();
voice_audio_close();
ESP_LOGI(TAG, "[stage] session_stop_exit_ok");
return ESP_OK;
}
esp_err_t voice_interaction_tap_start(char *err, size_t err_len) {
ESP_LOGI(TAG, "[stage] tap_start_enter");
if (!voice_lock(VOICE_STATUS_LOCK_TIMEOUT_MS)) {
voice_fill_err(err, err_len, "voice lock timeout");
ESP_LOGW(TAG, "[stage] tap_start_abort: lock timeout");
return ESP_ERR_TIMEOUT;
}
if (!s_voice.session_active || !s_voice.ws_connected || !s_voice.started) {
ESP_LOGW(TAG,
"[stage] tap_start_abort: session_active=%d ws_connected=%d started=%d",
s_voice.session_active,
s_voice.ws_connected,
s_voice.started);
voice_unlock();
voice_fill_err(err, err_len, "voice session not ready");
return ESP_ERR_INVALID_STATE;
@@ -1181,21 +1495,30 @@ esp_err_t voice_interaction_tap_start(char *err, size_t err_len) {
bool listening = (s_voice.dialog_state == VOICE_DIALOG_STATE_LISTENING);
s_voice.tap_active = true;
voice_unlock();
ESP_LOGI(TAG, "[stage] tap_start_marked_active: listening=%d", listening);
if (!listening) {
(void)voice_send_directive("continue-task", "RequestToSpeak", true);
}
voice_log_status_snapshot("tap_start_exit_ok");
return ESP_OK;
}
esp_err_t voice_interaction_tap_cancel(char *err, size_t err_len) {
ESP_LOGI(TAG, "[stage] tap_cancel_enter");
if (!voice_lock(VOICE_STATUS_LOCK_TIMEOUT_MS)) {
voice_fill_err(err, err_len, "voice lock timeout");
ESP_LOGW(TAG, "[stage] tap_cancel_abort: lock timeout");
return ESP_ERR_TIMEOUT;
}
if (!s_voice.session_active || !s_voice.ws_connected || !s_voice.started) {
ESP_LOGW(TAG,
"[stage] tap_cancel_abort: session_active=%d ws_connected=%d started=%d",
s_voice.session_active,
s_voice.ws_connected,
s_voice.started);
voice_unlock();
voice_fill_err(err, err_len, "voice session not ready");
return ESP_ERR_INVALID_STATE;
@@ -1203,6 +1526,7 @@ esp_err_t voice_interaction_tap_cancel(char *err, size_t err_len) {
s_voice.tap_active = false;
voice_unlock();
voice_log_status_snapshot("tap_cancel_marked_inactive");
return voice_send_directive("continue-task", "CancelSpeech", true);
}