修复提前启动websocket导致线程无法退出问题

diff --git a/code/sdk/drivers/peripheral/slip/cat1Service/cat1_ai_server.cpp b/code/sdk/drivers/peripheral/slip/cat1Service/cat1_ai_server.cpp
index b2328d0..017c92c 100644 (file)
--- a/code/sdk/drivers/peripheral/slip/cat1Service/cat1_ai_server.cpp
+++ b/code/sdk/drivers/peripheral/slip/cat1Service/cat1_ai_server.cpp
@@ -35,6 +35,8 @@
 #include <sys/time.h>
 #include <time.h>
 
+#include "cmsis_os2.h"
+
 #include "bletest.h"
 #include "custom_utils.h"
 #include "custom_runtime.h"
@@ -53,6 +55,19 @@
 #include "dev_authentication.h"
 #include "bk_websocket.h"
 
+#ifdef __cplusplus
+extern "C" {
+#endif /* __cplusplus */
+
+#include "cmsis_os2.h"
+#include "bk_websocket.h"
+
+#include <stdint.h>
+#include <stdint.h>
+#include <asm/delay.h>
+#include "bts_br_gap.h"
+
+
 // 内存管理和错误处理优化
 #define AI_SAFE_MALLOC(size) ({ \
     void* ptr = malloc(size); \
@@ -71,7 +86,7 @@
 
 // 超时和重试配置
 #define AI_CONNECT_TIMEOUT_MS    30000  // 30秒连接超时
-#define AI_RECEIVE_TIMEOUT_MS    60000  // 10秒接收超时
+#define AI_RECEIVE_TIMEOUT_MS    10000  // 10秒接收超时
 #define AI_MAX_RETRY_COUNT       3      // 最大重试次数
 #define AI_QUEUE_CHECK_INTERVAL  1000   // 队列检查间隔(ms)
 
@@ -99,6 +114,117 @@ static inline void ai_update_memory_usage(int32_t delta) {
     }
 }
 
+/**
+ * @brief 处理WebSocket连接失败的统一函数
+ * @param client_type 客户端类型字符串
+ * @param retry_count 当前重试次数
+ * @param max_retries 最大重试次数
+ * @return true 如果应该继续重试，false 如果应该停止重试
+ */
+static bool handle_websocket_connection_failure(const char* client_type, uint8_t retry_count, uint8_t max_retries) {
+    WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "%s WebSocket connection failed, retries left: %d", client_type, max_retries - retry_count);
+    
+    if (retry_count >= max_retries) {
+        WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "%s WebSocket connection failed after %d retries, giving up", client_type, max_retries);
+        return false; // 停止重试
+    }
+    
+    // 等待一段时间后重试
+    msleep(1000);
+    return true; // 继续重试
+}
+
+/**
+ * @brief 检查WebSocket客户端连接状态
+ * @param client WebSocket客户端指针
+ * @param client_type 客户端类型字符串
+ * @return true 如果连接正常，false 如果连接失败
+ */
+static bool check_websocket_client_status(WebSocketClient* client, const char* client_type) {
+    if (client == NULL) {
+        WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "%s WebSocket client is NULL", client_type);
+        return false;
+    }
+    
+    if (client->tcp_handle == NULL) {
+        WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "%s WebSocket TCP handle is NULL", client_type);
+        return false;
+    }
+    
+    if (client->parser == NULL) {
+        WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "%s WebSocket parser is NULL", client_type);
+        return false;
+    }
+    
+    return true;
+}
+
+/**
+ * @brief 将TCP连接状态转换为字符串
+ * @param state TCP连接状态
+ * @return 状态字符串
+ */
+static const char* tcp_state_to_string(tcp_connection_state_t state) {
+    switch (state) {
+        case TCP_STATE_DISCONNECTED: return "DISCONNECTED";
+        case TCP_STATE_CONNECTING: return "CONNECTING";
+        case TCP_STATE_CONNECTED: return "CONNECTED";
+        case TCP_STATE_CLOSING: return "CLOSING";
+        case TCP_STATE_ERROR: return "ERROR";
+        default: return "UNKNOWN";
+    }
+}
+
+/**
+ * @brief 等待TCP连接建立确认
+ * @param client WebSocket客户端指针
+ * @param client_type 客户端类型字符串
+ * @param timeout_ms 超时时间(毫秒)
+ * @return true 如果连接成功，false 如果连接失败或超时
+ */
+static bool wait_for_tcp_connection(WebSocketClient* client, const char* client_type, uint32_t timeout_ms) {
+    if (!client || !client->tcp_handle) {
+        WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "%s WebSocket client or TCP handle is NULL", client_type);
+        return false;
+    }
+    
+    uint32_t start_time = (uint32_t)osKernelGetTickCount();
+    uint32_t check_interval = 100; // 每100ms检查一次
+    
+    WEARABLE_LOGI(WEARABLE_LOG_MODULE_APP, "%s 等待TCP连接建立确认...", client_type);
+    
+    while ((uint32_t)osKernelGetTickCount() - start_time < timeout_ms) {
+        // 检查TCP连接状态
+        tcp_connection_state_t state = tcp_get_connection_state(client->tcp_handle);
+        
+        if (state == TCP_STATE_CONNECTED) {
+            WEARABLE_LOGI(WEARABLE_LOG_MODULE_APP, "%s TCP连接已建立", client_type);
+            return true;
+        }
+        
+        if (state == TCP_STATE_ERROR || state == TCP_STATE_DISCONNECTED) {
+            WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "%s TCP连接失败或已断开，状态: %s", client_type, tcp_state_to_string(state));
+            return false;
+        }
+        
+        // 如果还在连接中，继续等待
+        if (state == TCP_STATE_CONNECTING) {
+            msleep(check_interval);
+            WEARABLE_LOGI(WEARABLE_LOG_MODULE_APP, "%s 等待TCP连接... (%d ms)", 
+                          client_type, (uint32_t)osKernelGetTickCount() - start_time);
+            continue;
+        }
+        
+        // 其他状态也继续等待
+        msleep(check_interval);
+        WEARABLE_LOGI(WEARABLE_LOG_MODULE_APP, "%s TCP状态: %s, 等待中... (%d ms)", 
+                      client_type, tcp_state_to_string(state), (uint32_t)osKernelGetTickCount() - start_time);
+    }
+    
+    WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "%s TCP连接确认超时 (%d ms)", client_type, timeout_ms);
+    return false;
+}
+
 // 线程安全保护
 #define AI_LOCK() do { \
     if (g_ai_mutex) { \
@@ -112,17 +238,7 @@ static inline void ai_update_memory_usage(int32_t delta) {
     } \
 } while(0)
 
-#ifdef __cplusplus
-extern "C" {
-#endif /* __cplusplus */
-
-#include "cmsis_os2.h"
-#include "bk_websocket.h"
 
-#include <stdint.h>
-#include <stdint.h>
-#include <asm/delay.h>
-#include "bts_br_gap.h"
 
 #define AI_RESULT_STR_LEN  512
 
@@ -767,6 +883,7 @@ void chat_on_ws_packet_callback(uint8_t* data, size_t datalen, WebSocketMessageT
 static int receive_websocket_message_from_queue(ws_message_queue_t* queue, uint8_t* buffer, uint16_t buffer_size, WebSocketMessageType* type, uint32_t timeout_ms)
 {
     if (!queue || !buffer || !type) {
+        WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "!queue || !buffer || !type");
         return -1;
     }
     
@@ -814,13 +931,17 @@ void bk_websocket_demo(void *data) {
             
             if (is_raisound_url) {
                 chat_client = init_websocket_client(url_buf, NULL, 1);
-                chat_client->msg_queue = &chat_msg_queue;   
-                chat_client->packet_callback = chat_on_ws_packet_callback;
+                if (chat_client != NULL) {
+                    chat_client->msg_queue = &chat_msg_queue;   
+                    chat_client->packet_callback = chat_on_ws_packet_callback;
+                }
             } else {
                 #ifdef SUPPORT_CHINA_MOBILE_AI_REGULATION
                     chat_client = init_websocket_client(url_buf, NULL, 0);
-                    chat_client->msg_queue = &chat_msg_queue;   
-                    chat_client->packet_callback = chat_on_ws_packet_callback;
+                    if (chat_client != NULL) {
+                        chat_client->msg_queue = &chat_msg_queue;   
+                        chat_client->packet_callback = chat_on_ws_packet_callback;
+                    }
                 #else
                     const char* base_url = "ws://118.145.158.207:22080/chat/ws";
                     char full_url[512] = {0};
@@ -846,15 +967,17 @@ void bk_websocket_demo(void *data) {
                             break;
                     }
                     chat_client = init_websocket_client(full_url, NULL, 0);
-                    chat_client->msg_queue = &chat_msg_queue;   
-                    chat_client->packet_callback = chat_on_ws_packet_callback;
+                    if (chat_client != NULL) {
+                        chat_client->msg_queue = &chat_msg_queue;   
+                        chat_client->packet_callback = chat_on_ws_packet_callback;
+                    }
                 #endif
             }
 
             if (chat_client == NULL) {
                 client_count--;
                 WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "WebSocket connection failed, retries left: %d", client_count);
-                
+                                    
                 // 检查超时
                 if ((uint32_t)osKernelGetTickCount() - connect_start > AI_CONNECT_TIMEOUT_MS) {
                     WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "Connection timeout");
@@ -864,7 +987,7 @@ void bk_websocket_demo(void *data) {
                 msleep(1000);
                 continue;
             } else {
-                WEARABLE_LOGI(WEARABLE_LOG_MODULE_APP, "WebSocket connection established");
+                                WEARABLE_LOGI(WEARABLE_LOG_MODULE_APP, "WebSocket connection established");
                 break;
             }
         }
@@ -874,11 +997,42 @@ void bk_websocket_demo(void *data) {
             goto cleanup_and_exit;
         }
         
-        while (chat_client->handshake==0 )
-        {
+        // 在握手前先确认TCP连接状态
+        WEARABLE_LOGI(WEARABLE_LOG_MODULE_APP, "Chat WebSocket: 开始TCP连接确认...");
+        
+        // 先检查当前连接状态
+        tcp_connection_state_t current_state = tcp_get_connection_state(chat_client->tcp_handle);
+        WEARABLE_LOGI(WEARABLE_LOG_MODULE_APP, "Chat WebSocket: 当前TCP连接状态: %s", tcp_state_to_string(current_state));
+        
+        if (!wait_for_tcp_connection(chat_client, "Chat", 15000)) { // 15秒TCP连接确认超时
+            WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "Chat WebSocket: TCP连接确认失败，退出线程");
+            lwip_close_websocket_client(chat_client);
+            chat_client = NULL;
+            goto cleanup_and_exit;
+        }
+        WEARABLE_LOGI(WEARABLE_LOG_MODULE_APP, "Chat WebSocket: TCP连接确认成功，开始握手等待");
+        
+        // 等待WebSocket握手完成，增加超时机制
+        uint32_t handshake_start_time = (uint32_t)osKernelGetTickCount();
+        const uint32_t handshake_timeout_ms = 10000; // 30秒超时
+        
+        while (chat_client->handshake == 0) {
+            // 检查是否超时
+            if ((uint32_t)osKernelGetTickCount() - handshake_start_time > handshake_timeout_ms) {
+                WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "WebSocket握手超时 (%d ms)，重新连接", handshake_timeout_ms);
+                lwip_close_websocket_client(chat_client);
+                chat_client = NULL;
+                goto cleanup_and_exit;
+            }
+            
             msleep(1000);
+            WEARABLE_LOGI(WEARABLE_LOG_MODULE_APP, "等待WebSocket握手完成... (%d ms)", 
+                          (uint32_t)osKernelGetTickCount() - handshake_start_time);
         }
 
+        WEARABLE_LOGI(WEARABLE_LOG_MODULE_APP, "WebSocket握手完成，耗时 %d ms", 
+                      (uint32_t)osKernelGetTickCount() - handshake_start_time);
+
         // 设置socket超时
         // struct timeval timeout;
         // timeout.tv_sec = AI_RECEIVE_TIMEOUT_MS / 1000;
@@ -1301,38 +1455,46 @@ void bk_websocket_asr(void *data) {
             
             if (g_test_server_index == 1) {
                 asr_client = init_websocket_client("ws://118.145.158.207:22080/asr/ws", NULL, 0);
-                asr_client->msg_queue = &asr_msg_queue;
-                asr_client->packet_callback = asr_on_ws_packet_callback;
+                if (asr_client != NULL) {
+                    asr_client->msg_queue = &asr_msg_queue;
+                    asr_client->packet_callback = asr_on_ws_packet_callback;
+                }
             } else if (g_test_server_index == 2) {
                 asr_client = init_websocket_client("ws://110.42.224.129:8910/asr/ws", NULL, 0);
-                asr_client->msg_queue = &asr_msg_queue;
-                asr_client->packet_callback = asr_on_ws_packet_callback;
+                if (asr_client != NULL) {
+                    asr_client->msg_queue = &asr_msg_queue;
+                    asr_client->packet_callback = asr_on_ws_packet_callback;
+                }
             } else {
                 if (is_raisound_url) {
                     asr_client = init_websocket_client(url_buf, NULL, 1);
-                    asr_client->msg_queue = &asr_msg_queue;
-                    asr_client->packet_callback = asr_on_ws_packet_callback;
+                    if (asr_client != NULL) {
+                        asr_client->msg_queue = &asr_msg_queue;
+                        asr_client->packet_callback = asr_on_ws_packet_callback;
+                    }
                 } else {
                     asr_client = init_websocket_client("ws://118.145.158.207:22080/asr/ws", NULL, 0);
-                    asr_client->msg_queue = &asr_msg_queue;
-                    asr_client->packet_callback = asr_on_ws_packet_callback;
+                    if (asr_client != NULL) {
+                        asr_client->msg_queue = &asr_msg_queue;
+                        asr_client->packet_callback = asr_on_ws_packet_callback;
+                    }
                 }
             }
             
             if (asr_client == NULL) {
                 client_count--;
                 WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "ASR WebSocket connection failed, retries left: %d", client_count);
-                
+                                    
                 // 检查超时
                 if ((uint32_t)osKernelGetTickCount() - connect_start > AI_CONNECT_TIMEOUT_MS) {
                     WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "ASR connection timeout");
                     break;
                 }
                 
-                msleep(1000);
+msleep(1000);
                 continue;
             } else {
-                WEARABLE_LOGI(WEARABLE_LOG_MODULE_APP, "ASR WebSocket connection established");
+                                WEARABLE_LOGI(WEARABLE_LOG_MODULE_APP, "ASR WebSocket connection established");
                 break;
             }
         }
@@ -1345,11 +1507,42 @@ void bk_websocket_asr(void *data) {
             goto asr_cleanup_and_exit;
         }
 
-        while (asr_client->handshake==0)
-        {
+        // 在握手前先确认TCP连接状态
+        WEARABLE_LOGI(WEARABLE_LOG_MODULE_APP, "ASR WebSocket: 开始TCP连接确认...");
+        
+        // 先检查当前连接状态
+        tcp_connection_state_t current_state = tcp_get_connection_state(asr_client->tcp_handle);
+        WEARABLE_LOGI(WEARABLE_LOG_MODULE_APP, "ASR WebSocket: 当前TCP连接状态: %s", tcp_state_to_string(current_state));
+        
+        if (!wait_for_tcp_connection(asr_client, "ASR", 15000)) { // 15秒TCP连接确认超时
+            WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "ASR WebSocket: TCP连接确认失败，退出线程");
+            lwip_close_websocket_client(asr_client);
+            asr_client = NULL;
+            goto asr_cleanup_and_exit;
+        }
+        WEARABLE_LOGI(WEARABLE_LOG_MODULE_APP, "ASR WebSocket: TCP连接确认成功，开始握手等待");
+        
+        // 等待ASR WebSocket握手完成，增加超时机制
+        uint32_t asr_handshake_start_time = (uint32_t)osKernelGetTickCount();
+        const uint32_t asr_handshake_timeout_ms = 10000; // 30秒超时
+        
+        while (asr_client->handshake == 0) {
+            // 检查是否超时
+            if ((uint32_t)osKernelGetTickCount() - asr_handshake_start_time > asr_handshake_timeout_ms) {
+                WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "ASR WebSocket握手超时 (%d ms)，重新连接", asr_handshake_timeout_ms);
+                lwip_close_websocket_client(asr_client);
+                asr_client = NULL;
+                goto asr_cleanup_and_exit;
+            }
+            
             msleep(1000);
+WEARABLE_LOGI(WEARABLE_LOG_MODULE_APP, "等待ASR WebSocket握手完成... (%d ms)", 
+                          (uint32_t)osKernelGetTickCount() - asr_handshake_start_time);
         }
 
+        WEARABLE_LOGI(WEARABLE_LOG_MODULE_APP, "ASR WebSocket握手完成，耗时 %d ms", 
+                      (uint32_t)osKernelGetTickCount() - asr_handshake_start_time);
+
         uapi_cat1_keep_wakeup(1);
 
         server_state = 0x01 ^ server_state;
@@ -1734,28 +1927,31 @@ void bk_websocket_tts(void *data) {
             
             if (is_raisound_url == 1) {
                 tts_client = init_websocket_client(url_buf, NULL, 1);
-                tts_client->msg_queue = &tts_msg_queue; 
-                tts_client->packet_callback = tts_on_ws_packet_callback;
+                if (tts_client != NULL) {
+                    tts_client->msg_queue = &tts_msg_queue; 
+                    tts_client->packet_callback = tts_on_ws_packet_callback;
+                }
             } else {
-                tts_client = init_websocket_client("ws://118.145.158.207:22080/tts/stream?audio_buffer_size=1024", NULL, 0);
-                tts_client->msg_queue = &tts_msg_queue;
-                tts_client->packet_callback = tts_on_ws_packet_callback;
+                tts_client = init_websocket_client("ws://118.145.158.207:22080/tts/stream?audio_buffer_size=512", NULL, 0);
+                if (tts_client != NULL) {
+                    tts_client->msg_queue = &tts_msg_queue;
+                    tts_client->packet_callback = tts_on_ws_packet_callback;
+                }
             }
 
             if (tts_client == NULL) {
                 client_count--;
                 WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "TTS WebSocket connection failed, retries left: %d", client_count);
-                
+                                    
                 // 检查超时
                 if ((uint32_t)osKernelGetTickCount() - connect_start > AI_CONNECT_TIMEOUT_MS) {
                     WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "TTS connection timeout");
                     break;
                 }
                 
-                msleep(1000);
                 continue;
             } else {
-                WEARABLE_LOGI(WEARABLE_LOG_MODULE_APP, "TTS WebSocket connection established");
+                                WEARABLE_LOGI(WEARABLE_LOG_MODULE_APP, "TTS WebSocket connection established");
                 break;
             }
         }
@@ -1764,11 +1960,42 @@ void bk_websocket_tts(void *data) {
             goto tts_cleanup_and_exit;
         }
 
-        while (tts_client->handshake==0)
-        {
+        // 在握手前先确认TCP连接状态
+        WEARABLE_LOGI(WEARABLE_LOG_MODULE_APP, "TTS WebSocket: 开始TCP连接确认...");
+        
+        // 先检查当前连接状态
+        tcp_connection_state_t current_state = tcp_get_connection_state(tts_client->tcp_handle);
+        WEARABLE_LOGI(WEARABLE_LOG_MODULE_APP, "TTS WebSocket: 当前TCP连接状态: %s", tcp_state_to_string(current_state));
+        
+        if (!wait_for_tcp_connection(tts_client, "TTS", 15000)) { // 15秒TCP连接确认超时
+            WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "TTS WebSocket: TCP连接确认失败，退出线程");
+            lwip_close_websocket_client(tts_client);
+            tts_client = NULL;
+            goto tts_cleanup_and_exit;
+        }
+        WEARABLE_LOGI(WEARABLE_LOG_MODULE_APP, "TTS WebSocket: TCP连接确认成功，开始握手等待");
+        
+        // 等待TTS WebSocket握手完成，增加超时机制
+        uint32_t tts_handshake_start_time = (uint32_t)osKernelGetTickCount();
+        const uint32_t tts_handshake_timeout_ms = 10; // 30秒超时
+        
+        while (tts_client->handshake == 0) {
+            // 检查是否超时
+            if ((uint32_t)osKernelGetTickCount() - tts_handshake_start_time > tts_handshake_timeout_ms) {
+                WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "TTS WebSocket握手超时 (%d ms)，重新连接", tts_handshake_timeout_ms);
+                lwip_close_websocket_client(tts_client);
+                tts_client = NULL;
+                goto tts_cleanup_and_exit;
+            }
+            
             msleep(1000);
+            WEARABLE_LOGI(WEARABLE_LOG_MODULE_APP, "等待TTS WebSocket握手完成... (%d ms)", 
+                          (uint32_t)osKernelGetTickCount() - tts_handshake_start_time);
         }
 
+        WEARABLE_LOGI(WEARABLE_LOG_MODULE_APP, "TTS WebSocket握手完成，耗时 %d ms", 
+                      (uint32_t)osKernelGetTickCount() - tts_handshake_start_time);
+
         server_state = 0x04 ^ server_state;
         
         tts_break = 0;
@@ -2509,15 +2736,24 @@ void voice_chat_websocket(void *data) {
             
             if (is_raisound_url == 1) {
                 voice_chat_client = init_websocket_client(url_buf, NULL, 1);
-                // voice_chat_client->msg_queue = &voice_msg_queue;
+                if (voice_chat_client != NULL) {
+                    // voice_chat_client->msg_queue = &voice_msg_queue;
+                }
             } else {
                 voice_chat_client = init_websocket_client("ws://118.145.158.207:22080/voice-chat/v2/ws?platform=huoshan", NULL, 0);
-                // voice_chat_client->msg_queue = &voice_msg_queue;
+                if (voice_chat_client != NULL) {
+                    // voice_chat_client->msg_queue = &voice_msg_queue;
+                }
             }
 
             if (voice_chat_client == NULL) {
                 client_count--;
-                WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "Voice chat WebSocket connection failed, retries left: %d", client_count);
+                
+                // 使用统一的错误处理函数
+                if (!handle_websocket_connection_failure("Voice chat", AI_MAX_RETRY_COUNT - client_count, AI_MAX_RETRY_COUNT)) {
+                    WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "Voice chat WebSocket connection failed after all retries");
+                    break;
+                }
                 
                 // 检查超时
                 if ((uint32_t)osKernelGetTickCount() - connect_start > AI_CONNECT_TIMEOUT_MS) {
@@ -2525,7 +2761,6 @@ void voice_chat_websocket(void *data) {
                     break;
                 }
                 
-                msleep(1000);
                 continue;
             } else {
                 WEARABLE_LOGI(WEARABLE_LOG_MODULE_APP, "Voice chat WebSocket connection established");

diff --git a/code/sdk/drivers/peripheral/slip/cat1Service/cat1_ws.cpp b/code/sdk/drivers/peripheral/slip/cat1Service/cat1_ws.cpp
index aafc19b..0c72124 100644 (file)
--- a/code/sdk/drivers/peripheral/slip/cat1Service/cat1_ws.cpp
+++ b/code/sdk/drivers/peripheral/slip/cat1Service/cat1_ws.cpp
@@ -598,6 +598,11 @@ WebSocketClient *init_websocket_client(const char *url, const char *headers,uint
     int opt = 1;
     err_t ret = 0;
 
+    if (!url) {
+        printf("init_websocket_client Error: URL is NULL\n");
+        return NULL;
+    }
+
     parsed_url = parse_url(url);//解析url
 
     if (parsed_url.error) {
@@ -610,22 +615,25 @@ WebSocketClient *init_websocket_client(const char *url, const char *headers,uint
         printf("Path: %s\n", parsed_url.path);
         printf("Query: %s\n", parsed_url.query);
     }
+    
     client = (WebSocketClient *)aic_zalloc(sizeof(WebSocketClient)) ;
     memset_s(client,sizeof(WebSocketClient),0,sizeof(WebSocketClient));
     if(!client)
     {
-        printf("init_websocket_client alloc error");
+        printf("init_websocket_client alloc error: Failed to allocate memory for WebSocketClient\n");
         goto client_ERROR;
     }
+    
     //移植建议： 此处调用 tcp_open_url 进行连接, 不必使用 lwip_connect，异常及数据接收，都放到callback中处理
     client->tcp_handle = tcp_open_url(parsed_url.host, parsed_url.port, _tcp_on_connect_cb, _tcp_on_disconnect_cb, _tcp_on_data_received_cb);
 
     if(client->tcp_handle == NULL)
     {
-        printf("socket creation failed\r\n");
+        printf("init_websocket_client Error: TCP connection failed for %s:%d\n", parsed_url.host, parsed_url.port);
         goto client_ERROR;
     }
-    printf("socket creation success\r\n");
+    printf("socket creation success\n");
+    
     strcpy(client->host, parsed_url.host);
     strcpy(client->path, parsed_url.path);
     strcpy(client->query, parsed_url.query);
@@ -634,15 +642,13 @@ WebSocketClient *init_websocket_client(const char *url, const char *headers,uint
     /* 初始化WebSocket解析器 */
     client->parser = ws_parser_init();
     if (!client->parser) {
-        printf("Failed to initialize WebSocket parser\n");
+        printf("init_websocket_client Error: Failed to initialize WebSocket parser\n");
         goto client_ERROR;
     }
     
     /* 握手将在连接成功回调中发送，这里不再立即发送 */
     printf("WebSocket客户端初始化完成，等待TCP连接建立\r\n");
     
-  
-
     // if(strstr(buffer,"HTTP/1.1 101") == NULL)
     // {
         
@@ -655,6 +661,7 @@ WebSocketClient *init_websocket_client(const char *url, const char *headers,uint
      printf("init_websocket_client end 2");
     return client;
 client_ERROR:
+    printf("init_websocket_client Error: Initialization failed, cleaning up...\n");
     if(client){
         free(client);
         client = NULL;
@@ -737,8 +744,8 @@ int ws_process_received_data(WebSocketClient *client, const uint8_t *data, size_
             const uint8_t* payload = ws_get_payload(parser);
             size_t payload_len = ws_get_payload_length(parser);
             
-            printf("ws_process_received_data: frame complete, total bytes: %d, payload bytes: %zu\n", 
-                   result, payload_len);
+            printf("ws_process_received_data: frame complete, total bytes: %d, payload bytes: %zu %s\n", 
+                   result, payload_len,client->path);
             
             if (header && payload) {
                 printf("WebSocket frame received: opcode=0x%02X, fin=%d, payload_len=%llu\n", 
@@ -782,6 +789,7 @@ int ws_process_received_data(WebSocketClient *client, const uint8_t *data, size_
                                                           (header->opcode == WS_BINARY) ? (WebSocketMessageType)WS_BINARY : (WebSocketMessageType)WS_CONT;
                             client->packet_callback((uint8_t*)payload, payload_len, ws_type);
                         }
+                      
                         break;
                         
                     default: