From: 孙春阳 <snickersun@163.com>
Date: Sun, 21 Sep 2025 03:31:43 +0000 (+0800)
Subject: 修正tcptest，并让其在slip和ppp都可以运行。
X-Git-Tag: leiniao_debug_1.0.0_20250922_020716~1^2~9
X-Git-Url: http://git.snicker.com.cn/css/static/gitweb.css?a=commitdiff_plain;h=0cdc54749fd55a43ff071ff18ddb1b306ee57ebc;p=mirrors%2FFD230.git

修正tcptest，并让其在slip和ppp都可以运行。
---

diff --git a/code/sdk/build/config/target_config/brandy/config.py b/code/sdk/build/config/target_config/brandy/config.py
index 3459924b8..3ecde5a3c 100644
--- a/code/sdk/build/config/target_config/brandy/config.py
+++ b/code/sdk/build/config/target_config/brandy/config.py
@@ -1026,6 +1026,8 @@ target = {
             "cat1Service",
             "cat1Test",
             "4gTestcpp",
+            #tcp 测试相关配置
+            "tcp_test",
             #websocket 相关配置
             "zhihui_websocket",
             #ai 相关配置
@@ -1303,6 +1305,8 @@ target = {
                         # "cat1Service",
                         # "cat1Test",
 
+                        #tcp 测试相关配置
+                        "tcp_test",
                         #websocket 相关配置
                         "zhihui_websocket",
                         #ai 相关配置
diff --git a/code/sdk/zhihui/4gTest/cat1_at_cmd.c b/code/sdk/zhihui/4gTest/cat1_at_cmd.c
index 97e800203..35d0c5ed2 100644
--- a/code/sdk/zhihui/4gTest/cat1_at_cmd.c
+++ b/code/sdk/zhihui/4gTest/cat1_at_cmd.c
@@ -30,6 +30,9 @@ extern "C" {
 #ifdef SUPPORT_ZHIHUI_WEBSOCKET
 #include "../websocket/include/ws_multi_test.h"
 #endif
+#ifdef SUPPORT_TCP_TEST
+#include "../tcptest/include/zhihui_tcp_test.h"
+#endif
 
 static int ConvertCmdToParam(uint8_t *para, uint32_t paraLen,
         uint8_t argv[CUSTOM_UTILS_MAX_ARGC][CUSTOM_UTILS_MAX_ARGV_LEN], uint32_t* argc)
@@ -657,6 +660,206 @@ static uint32_t at_ws_multi_test_status(uint8_t *para, uint32_t paraLen, char *s
     return ERRCODE_SUCC;
 }
 #endif
+/**
+ * @brief AT^PPPTCPPERF - TCP性能测试
+ * 格式: AT^PPPTCPPERF=<host>,<port>,<connections>,<time>
+ * 示例: AT^PPPTCPPERF=110.42.224.129,8910,5,30
+ */
+static errcode_t at_4g_tcp_performance_test(uint8_t *para, uint32_t paraLen)
+{
+    if (!para || paraLen == 0) {
+        PRINT("[4G_ERR]4G TCP PERF: Missing parameters\r\n");
+        PRINT("[4G_INFO]Usage: AT^PPPTCPPERF=<host>,<port>,<connections>,<time>\r\n");
+        PRINT("[4G_INFO]Example: AT^PPPTCPPERF=110.42.224.129,8910,5,30\r\n");
+        return ERRCODE_FAIL;
+    }
+    
+    uint8_t argv[CUSTOM_UTILS_MAX_ARGC][CUSTOM_UTILS_MAX_ARGV_LEN];
+    uint32_t argc;
+    
+    if (ConvertCmdToParam(para, paraLen, argv, &argc) != CUSTOM_UTILS_SUCCESS || argc != 4) {
+        PRINT("[4G_ERR]4G TCP PERF: Invalid parameters, need 4 parameters, got %d\r\n", argc);
+        PRINT("[4G_INFO]Usage: AT^PPPTCPPERF=<host>,<port>,<connections>,<time>\r\n");
+        return ERRCODE_FAIL;
+    }
+    
+    // 解析参数
+    char *server_host = (char*)argv[0];
+    int port = atoi((char*)argv[1]);
+    int connections = atoi((char*)argv[2]);
+    int test_time = atoi((char*)argv[3]);
+    
+    // 参数验证
+    if (port < 1 || port > 65535) {
+        PRINT("[4G_ERR]4G TCP PERF: Invalid port %d (must be 1-65535)\r\n", port);
+        return ERRCODE_FAIL;
+    }
+    
+#ifdef SUPPORT_TCP_TEST
+    if (connections < 1 || connections > TCP_TEST_MAX_CONNECTIONS) {
+        PRINT("[4G_ERR]4G TCP PERF: Invalid connections %d (must be 1-%d)\r\n", 
+              connections, TCP_TEST_MAX_CONNECTIONS);
+        return ERRCODE_FAIL;
+    }
+#else
+    if (connections < 1 || connections > 50) {
+        PRINT("[4G_ERR]4G TCP PERF: Invalid connections %d (must be 1-50)\r\n", connections);
+        return ERRCODE_FAIL;
+    }
+#endif
+    
+    if (test_time < 1 || test_time > 3600) {
+        PRINT("[4G_ERR]4G TCP PERF: Invalid test time %d (must be 1-3600 seconds)\r\n", test_time);
+        return ERRCODE_FAIL;
+    }
+    
+    PRINT("[4G_INFO]4G TCP PERF: Starting TCP performance test\r\n");
+    PRINT("[4G_INFO]Target: %s:%d\r\n", server_host, port);
+    PRINT("[4G_INFO]Connections: %d\r\n", connections);
+    PRINT("[4G_INFO]Duration: %d seconds\r\n", test_time);
+    
+#ifdef SUPPORT_TCP_TEST
+    // 初始化TCP测试配置
+    tcp_test_config_t config;
+    strncpy(config.server_host, server_host, sizeof(config.server_host) - 1);
+    config.server_host[sizeof(config.server_host) - 1] = '\0';
+    config.server_port = (uint16_t)port;
+    config.test_duration = (uint32_t)test_time;
+    config.connection_count = (uint16_t)connections;
+    config.verbose = false; // AT命令模式不使用详细输出
+    config.send_interval_ms = 10; // 10ms间隔，适合AT命令模式
+    config.data_min_size = 64;    // 较小的数据包
+    config.data_max_size = 1024;  // 适中的最大包
+    
+    // 初始化TCP测试
+    errcode_t ret = tcp_test_init();
+    if (ret != ERRCODE_SUCC) {
+        PRINT("[4G_ERR]4G TCP PERF: Failed to initialize TCP test: %d\r\n", ret);
+        return ERRCODE_FAIL;
+    }
+    
+    // 启动测试
+    ret = tcp_test_start(&config);
+    if (ret != ERRCODE_SUCC) {
+        PRINT("[4G_ERR]4G TCP PERF: Failed to start TCP test: %d\r\n", ret);
+        tcp_test_deinit();
+        return ERRCODE_FAIL;
+    }
+    
+    PRINT("[4G_INFO]4G TCP PERF: Test started successfully\r\n");
+    PRINT("[4G_INFO]4G TCP PERF: Use AT^PPPTCPSTOP to stop early\r\n");
+    PRINT("[4G_INFO]4G TCP PERF: Use AT^PPPTCPSTATS to check status\r\n");
+    
+    return ERRCODE_SUCC;
+    
+#else
+    PRINT("[4G_ERR]4G TCP PERF: TCP test not supported in this build\r\n");
+    PRINT("[4G_INFO]4G TCP PERF: Enable SUPPORT_TCP_TEST to use this feature\r\n");
+    return ERRCODE_FAIL;
+#endif
+}
+
+/**
+ * @brief AT^PPPTCPSTOP - 停止TCP性能测试
+ */
+static errcode_t at_4g_tcp_test_stop(uint8_t *para, uint32_t paraLen)
+{
+    (void)para;
+    (void)paraLen;
+    
+#ifdef SUPPORT_TCP_TEST
+    if (!tcp_test_is_running()) {
+        PRINT("[4G_INFO]4G TCP STOP: No TCP test is currently running\r\n");
+        return ERRCODE_SUCC;
+    }
+    
+    PRINT("[4G_INFO]4G TCP STOP: Stopping TCP performance test...\r\n");
+    
+    errcode_t ret = tcp_test_stop();
+    if (ret != ERRCODE_SUCC) {
+        PRINT("[4G_ERR]4G TCP STOP: Failed to stop TCP test: %d\r\n", ret);
+        return ERRCODE_FAIL;
+    }
+    
+    // 清理资源
+    tcp_test_deinit();
+    
+    PRINT("[4G_INFO]4G TCP STOP: TCP test stopped successfully\r\n");
+    return ERRCODE_SUCC;
+    
+#else
+    PRINT("[4G_ERR]4G TCP STOP: TCP test not supported in this build\r\n");
+    return ERRCODE_FAIL;
+#endif
+}
+
+/**
+ * @brief AT^PPPTCPSTATS - 获取TCP测试统计信息
+ */
+static errcode_t at_4g_tcp_test_stats(uint8_t *para, uint32_t paraLen)
+{
+    (void)para;
+    (void)paraLen;
+    
+#ifdef SUPPORT_TCP_TEST
+    if (!tcp_test_is_running()) {
+        PRINT("[4G_INFO]4G TCP STATS: No TCP test is currently running\r\n");
+        return ERRCODE_SUCC;
+    }
+    
+    // 获取全局统计信息
+    tcp_global_stats_t stats;
+    errcode_t ret = tcp_test_get_stats(&stats);
+    if (ret != ERRCODE_SUCC) {
+        PRINT("[4G_ERR]4G TCP STATS: Failed to get TCP test stats: %d\r\n", ret);
+        return ERRCODE_FAIL;
+    }
+    
+    // 计算运行时间
+    uint32_t current_time = tcp_test_get_time_ms();
+    uint32_t elapsed_ms = current_time - stats.start_time;
+    uint32_t elapsed_sec = elapsed_ms / 1000;
+    
+    // 显示统计信息
+    PRINT("[4G_INFO]=== TCP Performance Test Statistics ===\r\n");
+    PRINT("[4G_INFO]Test Status: %s\r\n", stats.test_running ? "RUNNING" : "STOPPED");
+    PRINT("[4G_INFO]Elapsed Time: %d seconds\r\n", elapsed_sec);
+    PRINT("[4G_INFO]Successful Connections: %d\r\n", stats.successful_connections);
+    PRINT("[4G_INFO]Failed Connections: %d\r\n", stats.failed_connections);
+    PRINT("[4G_INFO]Packets Sent: %llu\r\n", stats.total_packets_sent);
+    PRINT("[4G_INFO]Packets Received: %llu\r\n", stats.total_packets_received);
+    PRINT("[4G_INFO]Bytes Sent: %llu\r\n", stats.total_bytes_sent);
+    PRINT("[4G_INFO]Bytes Received: %llu\r\n", stats.total_bytes_received);
+    PRINT("[4G_INFO]Total Errors: %d\r\n", stats.total_errors);
+    PRINT("[4G_INFO]Data Verification Errors: %d\r\n", stats.data_verification_errors);
+    
+    // 计算传输速率
+    if (elapsed_ms > 0) {
+        uint64_t throughput_bps = (stats.total_bytes_sent * 1000) / elapsed_ms;
+        char bytes_buf[64];
+        PRINT("[4G_INFO]Average Throughput: %s/s\r\n", 
+              tcp_test_format_bytes(throughput_bps, bytes_buf, sizeof(bytes_buf)));
+        
+        float packet_rate = (float)stats.total_packets_sent * 1000 / elapsed_ms;
+        PRINT("[4G_INFO]Average Packet Rate: %.1f packets/s\r\n", packet_rate);
+    }
+    
+    // 计算成功率
+    if (stats.total_packets_sent > 0) {
+        float success_rate = (float)stats.total_packets_received / stats.total_packets_sent * 100;
+        PRINT("[4G_INFO]Packet Success Rate: %.1f%%\r\n", success_rate);
+    }
+    
+    PRINT("[4G_INFO]========================================\r\n");
+    
+    return ERRCODE_SUCC;
+    
+#else
+    PRINT("[4G_ERR]4G TCP STATS: TCP test not supported in this build\r\n");
+    return ERRCODE_FAIL;
+#endif
+}
+
 static const at_cmd_table_t g_cat1_cmd[] = {
     { (char *)"AT^CAT1POWER",       cat1_power, (char *)"1" },
     { (char *)"AT^CAT1DIAL",        at_cat1_dial, (char *)"1" },
@@ -682,6 +885,10 @@ static const at_cmd_table_t g_cat1_cmd[] = {
     { (char *)"AT^STOPWSMULTI",     at_ws_multi_test_stop, (char *)" " },
     { (char *)"AT^WSMULTISTATUS",   at_ws_multi_test_status, (char *)" " },
 #endif
+    /* TCP性能测试指令 */
+    { (char *)"AT^PPPTCPPERF",      at_4g_tcp_performance_test, (char *)"host,port,connections,time" },
+    { (char *)"AT^PPPTCPSTOP",      at_4g_tcp_test_stop, (char *)" " },
+    { (char *)"AT^PPPTCPSTATS",     at_4g_tcp_test_stats, (char *)" " },
 };
 
 at_cmd_table_t *get_cat1_cmd_table(uint32_t *cmd_count)
diff --git a/code/sdk/zhihui/CMakeLists.txt b/code/sdk/zhihui/CMakeLists.txt
index 39e2cc58c..e005bdebb 100644
--- a/code/sdk/zhihui/CMakeLists.txt
+++ b/code/sdk/zhihui/CMakeLists.txt
@@ -19,6 +19,7 @@ else()
     add_subdirectory_if_exist(4g)
 endif()
 add_subdirectory_if_exist(4gTest)
+add_subdirectory_if_exist(tcptest)
 add_subdirectory_if_exist(ai)
 add_subdirectory_if_exist(ai_old)
 add_subdirectory_if_exist(ai_stub)
diff --git a/code/sdk/zhihui/ppp/CMakeLists.txt b/code/sdk/zhihui/ppp/CMakeLists.txt
index c5c3d3c7e..ac9ec1be7 100644
--- a/code/sdk/zhihui/ppp/CMakeLists.txt
+++ b/code/sdk/zhihui/ppp/CMakeLists.txt
@@ -10,7 +10,6 @@ set(PPP_AT_CMD_SOURCE
     ${CMAKE_CURRENT_SOURCE_DIR}/example/ppp_example.c
     # ${CMAKE_CURRENT_SOURCE_DIR}/example/ppp_power_example.c
     ${CMAKE_CURRENT_SOURCE_DIR}/example/api_shell.c
-    ${CMAKE_CURRENT_SOURCE_DIR}/example/ppp_tcp_test.c
 )
 # 源文件列表
 set(SOURCES
@@ -82,7 +81,6 @@ set(PUBLIC_DEFINES
     # PPP_OPTIONS=1 
     SUPPORT_PPP_SERVICE
     SUPPORT_AT_PPP
-    SUPPORT_TCP_TEST
 )
 
 set(PRIVATE_DEFINES
diff --git a/code/sdk/zhihui/ppp/example/README_TCP_TEST.md b/code/sdk/zhihui/ppp/example/README_TCP_TEST.md
deleted file mode 100644
index 0519ecba6..000000000
--- a/code/sdk/zhihui/ppp/example/README_TCP_TEST.md
+++ /dev/null
@@ -1 +0,0 @@
- 
\ No newline at end of file
diff --git a/code/sdk/zhihui/ppp/example/ppp_at_cmd.c b/code/sdk/zhihui/ppp/example/ppp_at_cmd.c
index f2f92e24b..9e7fbf666 100644
--- a/code/sdk/zhihui/ppp/example/ppp_at_cmd.c
+++ b/code/sdk/zhihui/ppp/example/ppp_at_cmd.c
@@ -13,7 +13,7 @@
 #include "ppp_api.h"
 #include "ppp_at_handler.h"
 #include "ppp_debug_manager.h"
-#include "ppp_tcp_test.h"
+#include "zhihui_tcp_test.h"
 #include "ppp_example.h"
 
 
@@ -1781,15 +1781,15 @@ static errcode_t at_ppp_tcp_performance_test(uint8_t *para, uint32_t paraLen)
     config.data_max_size = 1024;  // 适中的最大包
     
     // 初始化TCP测试
-    ppp_error_t ret = tcp_test_init();
-    if (ret != PPP_ERR_OK) {
+    errcode_t ret = tcp_test_init();
+    if (ret != ERRCODE_SUCC) {
         PRINT("[PPP_ERR]PPP TCP PERF: Failed to initialize TCP test: %d\r\n", ret);
         return ERRCODE_FAIL;
     }
     
     // 启动测试
     ret = tcp_test_start(&config);
-    if (ret != PPP_ERR_OK) {
+    if (ret != ERRCODE_SUCC) {
         PRINT("[PPP_ERR]PPP TCP PERF: Failed to start TCP test: %d\r\n", ret);
         tcp_test_deinit();
         return ERRCODE_FAIL;
@@ -1824,8 +1824,8 @@ static errcode_t at_ppp_tcp_test_stop(uint8_t *para, uint32_t paraLen)
     
     PRINT("[PPP_INFO]PPP TCP STOP: Stopping TCP performance test...\r\n");
     
-    ppp_error_t ret = tcp_test_stop();
-    if (ret != PPP_ERR_OK) {
+    errcode_t ret = tcp_test_stop();
+    if (ret != ERRCODE_SUCC) {
         PRINT("[PPP_ERR]PPP TCP STOP: Failed to stop TCP test: %d\r\n", ret);
         return ERRCODE_FAIL;
     }
@@ -1858,8 +1858,8 @@ static errcode_t at_ppp_tcp_test_stats(uint8_t *para, uint32_t paraLen)
     
     // 获取全局统计信息
     tcp_global_stats_t stats;
-    ppp_error_t ret = tcp_test_get_stats(&stats);
-    if (ret != PPP_ERR_OK) {
+    errcode_t ret = tcp_test_get_stats(&stats);
+    if (ret != ERRCODE_SUCC) {
         PRINT("[PPP_ERR]PPP TCP STATS: Failed to get TCP test stats: %d\r\n", ret);
         return ERRCODE_FAIL;
     }
diff --git a/code/sdk/zhihui/ppp/src/ppp_api.c b/code/sdk/zhihui/ppp/src/ppp_api.c
index 5c2335ff5..d16ff1435 100644
--- a/code/sdk/zhihui/ppp/src/ppp_api.c
+++ b/code/sdk/zhihui/ppp/src/ppp_api.c
@@ -1188,7 +1188,7 @@ errcode_t ppp_api_update_imei(void)
     char imei_temp[32] = {0};
     
     // 使用现有的AT命令执行接口
-    errcode_t ret = ppp_test_execute_at_command("AT+CGSN", response, 512, &response_len, 5000);
+    errcode_t ret = ppp_test_execute_at_command("AT+CGSN", response, 512, &response_len, 1000);
     if (ret != ERRCODE_SUCC) {
         PPP_DEBUG_ERROR("Failed to send AT+CGSN command");
         free(response);
@@ -1226,7 +1226,7 @@ errcode_t ppp_api_update_signal(void)
     int signal = 99; // 默认无信号
     
     // 使用现有的AT命令执行接口
-    errcode_t ret = ppp_test_execute_at_command("AT+CSQ", response, 512, &response_len, 5000);
+    errcode_t ret = ppp_test_execute_at_command("AT+CSQ", response, 512, &response_len, 1000);
     if (ret != ERRCODE_SUCC) {
         PPP_DEBUG_ERROR("Failed to send AT+CSQ command");
         free(response);
@@ -1433,7 +1433,7 @@ errcode_t ppp_api_update_sim_status(void)
     uint32_t response_len;
     
     // 通过AT+CCID命令检查SIM卡状态
-    errcode_t ret = ppp_test_execute_at_command("AT+CCID", response, 512, &response_len, 5000);
+    errcode_t ret = ppp_test_execute_at_command("AT+CCID", response, 512, &response_len, 1000);
     if (ret != ERRCODE_SUCC) {
         // 如果CCID命令失败，说明SIM卡可能未插入或有问题
         cat1_api_runtime_set_cat1_simstat(0); // 0表示SIM卡异常
@@ -1476,18 +1476,25 @@ errcode_t ppp_api_update_all_runtime_status(void)
     }
     
     // 更新IMEI
+    PPP_DEBUG_CRITICAL("Step 1: Starting IMEI update...");
     if (ppp_api_update_imei() != ERRCODE_SUCC) {
         PPP_DEBUG_ERROR("Failed to update IMEI");
         ret = ERRCODE_FAIL;
+    } else {
+        PPP_DEBUG_CRITICAL("Step 1: IMEI update completed successfully");
     }
     
     // 更新信号强度
+    PPP_DEBUG_CRITICAL("Step 2: Starting signal strength update...");
     if (ppp_api_update_signal() != ERRCODE_SUCC) {
         PPP_DEBUG_ERROR("Failed to update signal");
         ret = ERRCODE_FAIL;
+    } else {
+        PPP_DEBUG_CRITICAL("Step 2: Signal strength update completed successfully");
     }
     
     // 更新运营商信息
+    PPP_DEBUG_CRITICAL("Step 3: Starting operator update...");
     if (ppp_api_update_operator() != ERRCODE_SUCC) {
         PPP_DEBUG_ERROR("Failed to update operator");
         ret = ERRCODE_FAIL;
diff --git a/code/sdk/zhihui/ppp/src/ppp_at_handler.c b/code/sdk/zhihui/ppp/src/ppp_at_handler.c
index e16d9b9e3..a87db52f9 100644
--- a/code/sdk/zhihui/ppp/src/ppp_at_handler.c
+++ b/code/sdk/zhihui/ppp/src/ppp_at_handler.c
@@ -5,7 +5,6 @@
 #include "uart.h"
 #include "lwip/opt.h"
 #include "schedule/osal_task.h"
-#include "time/osal_timer.h"
 #include "lock/osal_mutex.h"
 #include "soc_osal.h"
 #include "securec.h"
@@ -20,7 +19,6 @@ static struct {
     uint32_t current_baudrate;
     bool auto_baudrate_mode;
     ppp_at_response_t last_response;
-    osal_timer at_timer;
     osal_mutex at_mutex;  // 改为结构体，不是指针
 } g_at_ctx = {0};
 
@@ -28,10 +26,13 @@ static struct {
 static const uint32_t g_auto_baudrates[] = PPP_BAUDRATE_AUTO_LIST;
 static const uint32_t g_fixed_baudrates[] = PPP_BAUDRATE_FIXED_LIST;
 
+/* 全局AT响应缓存 - 1024字节动态分配 */
+static uint8_t *g_at_response_buffer = NULL;
+static uint32_t g_at_buffer_size = 1024;
+
 /* AT命令响应解析 */
 static bool ppp_at_parse_response(const char *response, const char *expected);
 static ppp_error_t ppp_at_wait_response(ppp_at_response_t *response, uint32_t timeout);
-static void ppp_at_timeout_handler(unsigned long data);
 
 /**
  * @brief 初始化AT命令处理模块
@@ -53,15 +54,12 @@ ppp_error_t ppp_at_handler_init(uint8_t uart_bus)
         return PPP_ERR_MEMORY;
     }
 
-    // 初始化定时器
-    g_at_ctx.at_timer.handler = ppp_at_timeout_handler;
-    g_at_ctx.at_timer.data = 0;
-    g_at_ctx.at_timer.interval = PPP_AT_DEFAULT_TIMEOUT;
-    
-    if (osal_timer_init(&g_at_ctx.at_timer) != OSAL_SUCCESS) {
-        PPP_DEBUG_PRINT("Failed to initialize AT timer\n");
-        g_at_ctx.initialized = false;
-        return PPP_ERR_AT_FAILED;
+    /* 分配全局AT响应缓存 */
+    g_at_response_buffer = (uint8_t *)malloc(g_at_buffer_size);
+    if (g_at_response_buffer == NULL) {
+        PPP_DEBUG_ERROR("Failed to allocate AT response buffer");
+        osal_mutex_destroy(&g_at_ctx.at_mutex);
+        return PPP_ERR_MEMORY;
     }
 
     g_at_ctx.initialized = true;
@@ -79,13 +77,14 @@ void ppp_at_handler_deinit(void)
         return;
     }
 
-    if (g_at_ctx.at_timer.handler) {
-        osal_timer_destroy(&g_at_ctx.at_timer);
-        g_at_ctx.at_timer.handler = NULL;
-    }
-
     osal_mutex_destroy(&g_at_ctx.at_mutex);
 
+    /* 释放全局AT响应缓存 */
+    if (g_at_response_buffer) {
+        free(g_at_response_buffer);
+        g_at_response_buffer = NULL;
+    }
+
     memset_s(&g_at_ctx, sizeof(g_at_ctx), 0, sizeof(g_at_ctx));
     PPP_DEBUG_INFO("AT handler deinitialized");
 }
@@ -250,11 +249,25 @@ ppp_error_t ppp_at_set_baudrate(uint32_t baudrate)
 ppp_error_t ppp_at_send_command(const char *command, const char *expected_response, 
                                 uint32_t timeout, ppp_at_response_t *response)
 {
+    uint32_t start_timestamp = (uint32_t)osal_get_jiffies();
+    
+    PPP_DEBUG_CRITICAL("=== AT COMMAND START ===");
+    PPP_DEBUG_CRITICAL("Timestamp: %u", start_timestamp);
+    PPP_DEBUG_CRITICAL("Command: [%s]", command ? command : "NULL");
+    PPP_DEBUG_CRITICAL("Expected: [%s]", expected_response ? expected_response : "NULL");
+    PPP_DEBUG_CRITICAL("Timeout: %u ms", timeout);
+    
     if (!g_at_ctx.initialized || !command || !response) {
+        PPP_DEBUG_ERROR("Invalid parameters: initialized=%d, command=%p, response=%p", 
+                       g_at_ctx.initialized, command, response);
         return PPP_ERR_INVALID_PARAM;
     }
 
+    PPP_DEBUG_CRITICAL("Step 1: Attempting to acquire AT mutex...");
+    uint32_t mutex_start = (uint32_t)osal_get_jiffies();
     osal_mutex_lock(&g_at_ctx.at_mutex);
+    uint32_t mutex_end = (uint32_t)osal_get_jiffies();
+    PPP_DEBUG_CRITICAL("Step 1: AT mutex acquired in %u ms", osal_jiffies_to_msecs(mutex_end - mutex_start));
 
     PPP_DEBUG_DEBUG("=== AT Command Send ===");
     PPP_DEBUG_DEBUG("Command: %s", command);
@@ -303,16 +316,30 @@ ppp_error_t ppp_at_send_command(const char *command, const char *expected_respon
     PPP_DEBUG_DEBUG("Send String: %s", printable_cmd);
     free(printable_cmd);
     
-    if (uapi_uart_write(g_at_ctx.uart_bus, (const uint8_t *)cmd_with_crlf, cmd_len, 0) != cmd_len) {
-        PPP_DEBUG_ERROR("Failed to send AT command");
+    PPP_DEBUG_CRITICAL("Step 2: Sending AT command via UART...");
+    uint32_t uart_write_start = (uint32_t)osal_get_jiffies();
+    
+    int32_t write_result = uapi_uart_write(g_at_ctx.uart_bus, (const uint8_t *)cmd_with_crlf, cmd_len, 0);
+    uint32_t uart_write_end = (uint32_t)osal_get_jiffies();
+    
+    PPP_DEBUG_CRITICAL("Step 2: UART write completed in %u ms, result: %d (expected: %u)", 
+                      osal_jiffies_to_msecs(uart_write_end - uart_write_start), write_result, cmd_len);
+    
+    if (write_result != cmd_len) {
+        PPP_DEBUG_ERROR("Failed to send AT command: wrote %d bytes, expected %u", write_result, cmd_len);
         osal_mutex_unlock(&g_at_ctx.at_mutex);
         return PPP_ERR_UART;
     }
     
-    PPP_DEBUG_DEBUG("AT command sent successfully bus(%d)",g_at_ctx.uart_bus);
+    PPP_DEBUG_CRITICAL("Step 2: AT command sent successfully on bus %d", g_at_ctx.uart_bus);
 
     /* 等待响应 */
+    PPP_DEBUG_CRITICAL("Step 3: Starting to wait for AT response...");
+    uint32_t response_wait_start = (uint32_t)osal_get_jiffies();
     ppp_error_t ret = ppp_at_wait_response(response, timeout);
+    uint32_t response_wait_end = (uint32_t)osal_get_jiffies();
+    PPP_DEBUG_CRITICAL("Step 3: AT response wait completed in %u ms, result: %d", 
+                      osal_jiffies_to_msecs(response_wait_end - response_wait_start), ret);
     
     /* 打印响应结果 */
     PPP_DEBUG_DEBUG("=== AT Command Response ===");
@@ -377,7 +404,15 @@ ppp_error_t ppp_at_send_command(const char *command, const char *expected_respon
     
     PPP_DEBUG_DEBUG("=== AT Command Complete (Result: %s) ===", ret == PPP_ERR_OK ? "SUCCESS" : "FAILED");
 
+    PPP_DEBUG_CRITICAL("Step 4: Releasing AT mutex...");
+    uint32_t mutex_unlock_start = (uint32_t)osal_get_jiffies();
     osal_mutex_unlock(&g_at_ctx.at_mutex);
+    uint32_t mutex_unlock_end = (uint32_t)osal_get_jiffies();
+    
+    uint32_t total_time = osal_jiffies_to_msecs(mutex_unlock_end - start_timestamp);
+    PPP_DEBUG_CRITICAL("Step 4: AT mutex released in %u ms", osal_jiffies_to_msecs(mutex_unlock_end - mutex_unlock_start));
+    PPP_DEBUG_CRITICAL("=== AT COMMAND END (Total: %u ms, Result: %d) ===", total_time, ret);
+    
     return ret;
 }
 
@@ -715,134 +750,182 @@ static bool ppp_at_parse_response(const char *response, const char *expected)
 }
 
 /**
- * @brief 等待AT命令响应
+ * @brief 等待AT命令响应 - 新的直接读取实现（取消timer检测）
  */
 static ppp_error_t ppp_at_wait_response(ppp_at_response_t *response, uint32_t timeout)
 {
-    if (!response) {
-        return PPP_ERR_INVALID_PARAM;
-    }
-
-    /* 设置并启动超时定时器 */
-    if (osal_timer_mod(&g_at_ctx.at_timer, timeout) != OSAL_SUCCESS) {
-        PPP_DEBUG_ERROR("Failed to set AT timer timeout");
-        return PPP_ERR_MEMORY;
-    }
+    PPP_DEBUG_CRITICAL(">>> WAIT_RESPONSE START <<<");
     
-    if (osal_timer_start(&g_at_ctx.at_timer) != OSAL_SUCCESS) {
-        PPP_DEBUG_ERROR("Failed to start AT timer");
-        return PPP_ERR_MEMORY;
+    if (!response || !g_at_response_buffer) {
+        PPP_DEBUG_ERROR("Invalid parameters: response=%p, buffer=%p", response, g_at_response_buffer);
+        return PPP_ERR_INVALID_PARAM;
     }
 
     uint32_t start_time = (uint32_t)osal_get_jiffies();
     uint32_t bytes_received = 0;
     bool response_complete = false;
+    bool has_data = false;
+    uint32_t read_attempts = 0;
     
-    /* 动态分配缓冲区以避免栈溢出 */
-    uint8_t *buffer = (uint8_t *)malloc(256);
-    char *printable_buf = (char *)malloc(512);
+    /* 清空全局缓存 */
+    memset(g_at_response_buffer, 0, g_at_buffer_size);
     
-    if (buffer == NULL || printable_buf == NULL) {
-        PPP_DEBUG_ERROR("Failed to allocate memory for AT response buffers");
-        if (buffer) free(buffer);
-        if (printable_buf) free(printable_buf);
-        return PPP_ERR_MEMORY;
-    }
+    PPP_DEBUG_CRITICAL("WAIT_RESPONSE: Starting direct UART read (timeout: %u ms, buffer_size: %u)", 
+                      timeout, g_at_buffer_size);
     
-    PPP_DEBUG_INFO("Waiting bus(%d) for AT response (timeout: %u ms)...", g_at_ctx.uart_bus,timeout);
-
-    while (!response_complete && (osal_get_jiffies() - start_time) < osal_msecs_to_jiffies(timeout)) {
-        uint32_t bytes_read = 0;
+    /* 循环读取直到找到响应结论或超时 */
+    while (!response_complete) {
+        read_attempts++;
+        uint32_t current_time = (uint32_t)osal_get_jiffies();
+        uint32_t elapsed = osal_jiffies_to_msecs(current_time - start_time);
+        
+        /* 每10次尝试打印一次状态 */
+        if (read_attempts % 10 == 1) {
+            PPP_DEBUG_CRITICAL("WAIT_RESPONSE: Attempt #%u, elapsed: %u ms, has_data: %d, bytes_received: %u", 
+                              read_attempts, elapsed, has_data, bytes_received);
+        }
+        
+        /* 检查超时条件：如果没有数据且达到超时时间，退出 */
+        if (!has_data && elapsed >= timeout) {
+            PPP_DEBUG_CRITICAL("WAIT_RESPONSE: TIMEOUT - no data received after %u ms (attempts: %u)", elapsed, read_attempts);
+            break;
+        }
+        
+        /* 读取串口数据，使用较短的读取超时 */
+        PPP_DEBUG_DEBUG("WAIT_RESPONSE: Attempting UART read #%u...", read_attempts);
+        uint32_t uart_read_start = (uint32_t)osal_get_jiffies();
+        
+        int32_t ret = uapi_uart_read(g_at_ctx.uart_bus, 
+                                    g_at_response_buffer + bytes_received, 
+                                    g_at_buffer_size - bytes_received - 1, 
+                                    50);  /* 50ms读取超时 */
         
-        /* 读取串口数据 */
-        int32_t ret = uapi_uart_read(g_at_ctx.uart_bus, buffer, 256 - 1, 100);
+        uint32_t uart_read_end = (uint32_t)osal_get_jiffies();
+        uint32_t uart_read_time = osal_jiffies_to_msecs(uart_read_end - uart_read_start);
+        
+        PPP_DEBUG_DEBUG("WAIT_RESPONSE: UART read #%u completed in %u ms, result: %d", 
+                       read_attempts, uart_read_time, ret);
         
         if (ret > 0) {
-            bytes_read = (uint32_t)ret;
-            buffer[bytes_read] = '\0';
+            has_data = true;
+            bytes_received += (uint32_t)ret;
+            g_at_response_buffer[bytes_received] = '\0';
+            
+            PPP_DEBUG_CRITICAL("WAIT_RESPONSE: Read %d bytes, total: %u bytes", ret, bytes_received);
+            PPP_DEBUG_CRITICAL("WAIT_RESPONSE: Current buffer content: [%s]", (char*)g_at_response_buffer);
             
-            /* 打印实时接收的数据 */
-            PPP_DEBUG_INFO("Received %u bytes:", bytes_read);
-            for (uint32_t i = 0; i < bytes_read; i++) {
-                PPP_DEBUG_PRINT("%02X ", buffer[i]);
+            /* 打印接收到的原始数据（十六进制） */
+            PPP_DEBUG_DEBUG("WAIT_RESPONSE: Raw data received:");
+            for (int i = bytes_received - ret; i < bytes_received; i++) {
+                PPP_DEBUG_PRINT("%02X ", g_at_response_buffer[i]);
             }
             PPP_DEBUG_PRINT("\n");
             
-            /* 打印可读字符 */
-            uint32_t j = 0;
-            for (uint32_t i = 0; i < bytes_read && j < 512 - 10; i++) {
-                if (buffer[i] == '\r') {
-                    printable_buf[j++] = '\\';
-                    printable_buf[j++] = 'r';
-                } else if (buffer[i] == '\n') {
-                    printable_buf[j++] = '\\';
-                    printable_buf[j++] = 'n';
-                } else if (buffer[i] >= 32 && buffer[i] <= 126) {
-                    printable_buf[j++] = buffer[i];
-                } else {
-                    j += snprintf_s(printable_buf + j, 512 - j, 512 - j - 1, "\\x%02X", buffer[i]);
+            /* 检查缓存中是否有需要检测的结论 */
+            PPP_DEBUG_DEBUG("WAIT_RESPONSE: Checking for terminators...");
+            bool found_terminator = false;
+            
+            /* 搜索OK终止符 */
+            PPP_DEBUG_DEBUG("WAIT_RESPONSE: Searching for OK terminator...");
+            for (uint32_t i = 0; i <= bytes_received - 2; i++) {
+                if (g_at_response_buffer[i] == 'O' && g_at_response_buffer[i+1] == 'K') {
+                    /* 检查OK前面是否有换行符（避免误匹配） */
+                    if (i == 0 || g_at_response_buffer[i-1] == '\n' || g_at_response_buffer[i-1] == '\r') {
+                        PPP_DEBUG_CRITICAL("WAIT_RESPONSE: Found OK terminator at position %u", i);
+                        found_terminator = true;
+                        response_complete = true;
+                        break;
+                    }
                 }
             }
-            printable_buf[j] = '\0';
-            PPP_DEBUG_INFO("Received String: %s", printable_buf);
-            PPP_DEBUG_INFO("Received Raw: %s", (char*)buffer);
             
-            /* 追加到响应缓冲区 */
-            if (bytes_received + bytes_read < PPP_AT_RESPONSE_MAX_LEN - 1) {
-                memcpy_s(response->response + bytes_received, 
-                        PPP_AT_RESPONSE_MAX_LEN - bytes_received,
-                        buffer, bytes_read);
-                bytes_received += bytes_read;
-                response->response[bytes_received] = '\0';
-                response->length = bytes_received;
-                
-                PPP_DEBUG_DEBUG("Total received so far: %u bytes", bytes_received);
-                
-                /* 检查是否收到完整响应 */
-                if (strstr(response->response, "OK") || 
-                    strstr(response->response, "ERROR") ||
-                    strstr(response->response, "CONNECT") ||
-                    strstr(response->response, "NO CARRIER") ||
-                    strstr(response->response, "BUSY") ||
-                    strstr(response->response, "NO DIALTONE")) {
-                    PPP_DEBUG_INFO("Complete response detected");
+            /* 搜索ERROR终止符 */
+            if (!found_terminator && bytes_received >= 5) {
+                PPP_DEBUG_DEBUG("WAIT_RESPONSE: Searching for ERROR terminator...");
+                for (uint32_t i = 0; i <= bytes_received - 5; i++) {
+                    if (strncmp((char*)&g_at_response_buffer[i], "ERROR", 5) == 0) {
+                        /* 检查ERROR前面是否有换行符 */
+                        if (i == 0 || g_at_response_buffer[i-1] == '\n' || g_at_response_buffer[i-1] == '\r') {
+                            PPP_DEBUG_CRITICAL("WAIT_RESPONSE: Found ERROR terminator at position %u", i);
+                            found_terminator = true;
+                            response_complete = true;
+                            break;
+                        }
+                    }
+                }
+            }
+            
+            /* 检查其他终止符 */
+            if (!found_terminator) {
+                PPP_DEBUG_DEBUG("WAIT_RESPONSE: Searching for other terminators...");
+                char *buffer_str = (char*)g_at_response_buffer;
+                if (strstr(buffer_str, "CONNECT") ||
+                    strstr(buffer_str, "NO CARRIER") ||
+                    strstr(buffer_str, "BUSY") ||
+                    strstr(buffer_str, "NO DIALTONE")) {
+                    PPP_DEBUG_CRITICAL("WAIT_RESPONSE: Found other terminator in response");
+                    found_terminator = true;
                     response_complete = true;
                 }
+            }
+            
+            /* 检查缓存是否已满 */
+            if (bytes_received >= g_at_buffer_size - 1) {
+                PPP_DEBUG_WARN("AT response buffer full, stopping read");
+                response_complete = true;
+            }
+            
+        } else if (ret == 0) {
+            /* 没有读到数据 */
+            if (has_data) {
+                /* 已经有数据了，继续尝试读取更多数据，但不受严格超时限制 */
+                PPP_DEBUG_DEBUG("No new data, but continuing due to existing data");
+                osal_msleep(10);  /* 短暂延时后继续 */
             } else {
-                PPP_DEBUG_WARN("AT response buffer overflow");
-                break;
+                /* 还没有任何数据，检查是否超时 */
+                if (elapsed >= timeout) {
+                    PPP_DEBUG_WARN("No data received within timeout");
+                    break;
+                }
+                osal_msleep(10);  /* 短暂延时后继续 */
             }
-        } else if (ret < 0) {
-            PPP_DEBUG_DEBUG("UART read error: %d", ret);
+        } else {
+            PPP_DEBUG_ERROR("UART read error: %d", ret);
+            break;
         }
-        
-        osal_msleep(10); // 短暂延时
     }
-
-    /* 停止定时器 */
-    osal_timer_stop(&g_at_ctx.at_timer);
-
-    /* 释放动态分配的内存 */
-    free(buffer);
-    free(printable_buf);
-
-    if (!response_complete) {
-        PPP_DEBUG_ERROR("AT command timeout");
+    
+    /* 将结果复制到响应结构体 */
+    if (bytes_received > 0) {
+        uint32_t copy_len = (bytes_received < PPP_AT_RESPONSE_MAX_LEN - 1) ? 
+                           bytes_received : PPP_AT_RESPONSE_MAX_LEN - 1;
+        
+        memcpy_s(response->response, PPP_AT_RESPONSE_MAX_LEN, 
+                g_at_response_buffer, copy_len);
+        response->response[copy_len] = '\0';
+        response->length = copy_len;
+        
+        uint32_t final_time = (uint32_t)osal_get_jiffies();
+        uint32_t total_elapsed = osal_jiffies_to_msecs(final_time - start_time);
+        
+        PPP_DEBUG_CRITICAL("WAIT_RESPONSE: SUCCESS - %u bytes in %u ms (attempts: %u)", 
+                          bytes_received, total_elapsed, read_attempts);
+        PPP_DEBUG_CRITICAL(">>> WAIT_RESPONSE END (SUCCESS) <<<");
+        return PPP_ERR_OK;
+    } else {
+        uint32_t final_time = (uint32_t)osal_get_jiffies();
+        uint32_t total_elapsed = osal_jiffies_to_msecs(final_time - start_time);
+        
+        PPP_DEBUG_CRITICAL("WAIT_RESPONSE: FAILED - No response after %u ms (attempts: %u)", 
+                          total_elapsed, read_attempts);
+        PPP_DEBUG_CRITICAL(">>> WAIT_RESPONSE END (FAILED) <<<");
+        response->length = 0;
+        response->response[0] = '\0';
         return PPP_ERR_TIMEOUT;
     }
-
-    PPP_DEBUG_DEBUG("AT response: %s", response->response);
-    return PPP_ERR_OK;
 }
 
-/**
- * @brief AT命令超时处理
- */
-static void ppp_at_timeout_handler(unsigned long data)
-{
-    (void)data;
-    PPP_DEBUG_WARN("AT command timeout");
-}
+
 
 /**
  * @brief 解析AT+CESQ响应
diff --git a/code/sdk/zhihui/ppp/src/ppp_lwip_thread.c b/code/sdk/zhihui/ppp/src/ppp_lwip_thread.c
index 1ebbe1a44..2007edab8 100644
--- a/code/sdk/zhihui/ppp/src/ppp_lwip_thread.c
+++ b/code/sdk/zhihui/ppp/src/ppp_lwip_thread.c
@@ -26,16 +26,13 @@ static volatile bool g_ppp_rx_thread_completed = false;
  * 2. 实现流数据处理和PPP帧重组
  * 3. 直接调用lwIP的输入函数
  */
-static uint32_t ppp_process_complete_frames(uint8_t *buffer, uint32_t *buffer_pos);
-
-/* 替换第29-215行的ppp_lwip_receive_thread函数 */
 static void ppp_lwip_receive_thread(void *arg)
 {
     (void)arg;
     
-    PPP_DEBUG_DEBUG("PPP lwIP receive thread started (optimized frame detection)");
+    PPP_DEBUG_DEBUG("PPP lwIP receive thread started (slipif-style)");
     
-    /* 动态分配接收缓冲区 */
+    /* 动态分配接收缓冲区以避免栈溢出 */
     uint8_t *rx_buffer = (uint8_t *)malloc(PPP_RX_BUFFER_SIZE);
     if (!rx_buffer) {
         PPP_DEBUG_ERROR("Failed to allocate RX buffer for PPP thread");
@@ -53,16 +50,22 @@ static void ppp_lwip_receive_thread(void *arg)
     uint32_t bytes_read;
     uint32_t total_packets = 0;
     uint32_t total_bytes = 0;
-    uint32_t complete_frames = 0;
     
     /* PPP流处理状态 */
     uint32_t stream_pos = 0;          /* 流缓冲区当前位置 */
+    bool in_frame = false;            /* 是否正在接收PPP帧 */
+    uint32_t frame_start = 0;         /* 当前帧开始位置 */
+    uint32_t complete_frames = 0;     /* 完整帧计数 */
+    
+    PPP_DEBUG_DEBUG("PPP lwIP thread: allocated %d bytes RX buffer + %d bytes stream buffer", 
+                   PPP_RX_BUFFER_SIZE, PPP_RX_BUFFER_SIZE * 2);
     
-    PPP_DEBUG_CRITICAL("PPP receive thread started with optimized frame detection");
+    PPP_DEBUG_CRITICAL("PPP receive thread started and entering main loop");
+    PPP_DEBUG_DEBUG("Thread will read from serial in PPP data mode");
     
-    /* 主接收循环 */
+    /* 主接收循环 - 参考slipif的实现方式 */
     while (g_ppp_rx_thread_running) {
-        // 从串口读取PPP数据
+        // 从串口读取PPP数据 - 使用较短的超时时间提高响应性
         ppp_error_t ret = ppp_serial_read(rx_buffer, PPP_RX_BUFFER_SIZE, &bytes_read);
         
         if (ret == PPP_ERR_OK && bytes_read > 0) {
@@ -72,118 +75,107 @@ static void ppp_lwip_receive_thread(void *arg)
             PPP_DEBUG_DEBUG("PPP RX: Got %u bytes (total: %u packets, %u bytes)", 
                           bytes_read, total_packets, total_bytes);
             
-            /* 检查缓冲区空间 */
-            if (stream_pos + bytes_read >= PPP_RX_BUFFER_SIZE * 2) {
-                PPP_DEBUG_WARN("PPP stream buffer full, processing existing frames first");
-                
-                /* 处理现有完整帧以释放空间 */
-                uint32_t processed = ppp_process_complete_frames(stream_buffer, &stream_pos);
-                PPP_DEBUG_INFO("Processed %u frames to free buffer space", processed);
-                
-                /* 如果还是不够空间，重置缓冲区 */
-                if (stream_pos + bytes_read >= PPP_RX_BUFFER_SIZE * 2) {
-                    PPP_DEBUG_WARN("Buffer still full after processing, resetting");
-                    stream_pos = 0;
-                }
+            /* 将接收到的数据添加到流缓冲区 - 加强边界检查 */
+            if (stream_pos + bytes_read < PPP_RX_BUFFER_SIZE * 2) {
+                memcpy(stream_buffer + stream_pos, rx_buffer, bytes_read);
+                stream_pos += bytes_read;
+            } else {
+                PPP_DEBUG_WARN("PPP stream buffer overflow, resetting");
+                stream_pos = 0;
+                frame_start = 0;
+                in_frame = false;
+                continue;  // 跳过本次处理，避免缓冲区溢出
             }
             
-            /* 将新数据追加到流缓冲区 */
-            memcpy(stream_buffer + stream_pos, rx_buffer, bytes_read);
-            stream_pos += bytes_read;
-            
-            /* 立即处理所有完整的PPP帧 */
-            uint32_t processed_frames = ppp_process_complete_frames(stream_buffer, &stream_pos);
-            complete_frames += processed_frames;
-            
-            if (processed_frames > 0) {
-                PPP_DEBUG_DEBUG("Processed %u complete PPP frames", processed_frames);
+            /* 处理PPP帧 - 查找0x7E标志并添加边界检查 */
+            for (uint32_t i = frame_start; i < stream_pos && i < PPP_RX_BUFFER_SIZE * 2; i++) {
+                if (stream_buffer[i] == 0x7E) {
+                    if (in_frame && i > frame_start) {
+                        /* 找到帧结束，处理完整的PPP帧 */
+                        uint32_t frame_len = i - frame_start + 1;
+                        
+                        /* 添加帧长度合理性检查 */
+                        if (frame_len > 0 && frame_len <= 1500) {  // PPP最大帧长度
+                            PPP_DEBUG_DEBUG("PPP complete frame found: %u bytes", frame_len);
+                            
+                            /* 确保指针和长度有效 */
+                            if (frame_start + frame_len <= PPP_RX_BUFFER_SIZE * 2 && 
+                                frame_start < PPP_RX_BUFFER_SIZE * 2) {
+                                /* 将完整帧传递给lwIP - 让lwIP自己验证帧的有效性 */
+                                ppp_lwip_input(stream_buffer + frame_start, frame_len);
+                                complete_frames++;
+                            } else {
+                                PPP_DEBUG_WARN("PPP frame pointer out of bounds: start=%u, len=%u", 
+                                              frame_start, frame_len);
+                            }
+                        } else {
+                            PPP_DEBUG_WARN("Invalid PPP frame length: %u (frame_start=%u, i=%u)", 
+                                          frame_len, frame_start, i);
+                        }
+                    }
+                    
+                    /* 开始新帧 */
+                    frame_start = i;
+                    in_frame = true;
+                }
             }
             
+            /* 如果缓冲区使用超过一半，移动未处理的数据到缓冲区开头 */
+            if (frame_start > PPP_RX_BUFFER_SIZE) {
+                uint32_t remaining = stream_pos - frame_start;
+                if (remaining > 0) {
+                    memmove(stream_buffer, stream_buffer + frame_start, remaining);
+                }
+                stream_pos = remaining;
+                frame_start = 0;
+                /* 保持in_frame状态，不要重置为false */
+                /* in_frame状态应该保持，因为我们可能正在处理一个跨缓冲区的帧 */
+            }
         } else if (ret != PPP_ERR_OK) {
+            /* 检查是否是因为线程停止导致的错误 */
             if (!g_ppp_rx_thread_running) {
                 PPP_DEBUG_DEBUG("PPP thread stopping, ignoring read error");
                 break;
             }
             PPP_DEBUG_ERROR("PPP serial read error: %d", ret);
         } else {
-            /* 无数据可读，短暂休眠 */
-            osal_msleep(5);
+            /* ret == PPP_ERR_OK but bytes_read == 0 - no data available */
+            static uint32_t no_data_count = 0;
+            no_data_count++;
+            
+            /* 减少无数据时的日志输出频率，避免日志开销 */
+            if (no_data_count % 5000 == 0) {  /* 每5000次无数据时打印一次 */
+                PPP_DEBUG_DEBUG("PPP RX: No data available (count: %u)", no_data_count);
+            }
+            
+            /* 适应性休眠策略，避免过度占用CPU */
+            if (no_data_count % 5 == 0) {  /* 每5次无数据后短暂休眠 */
+                osal_msleep(2);  /* 2ms休眠，让出CPU给tcpip_thread */
+            }
         }
         
-        /* 统计信息输出 */
-        if ((total_packets % 1000) == 0 && total_packets > 0) {
-            PPP_DEBUG_DEBUG("PPP RX Stats: %u packets, %u frames, %u total bytes", 
+        // 统计信息输出 - 每5000次循环输出一次，减少日志开销
+        if ((total_packets % 5000) == 0 && total_packets > 0) {
+            PPP_DEBUG_DEBUG("PPP lwIP RX: %u fragments, %u complete frames, %u total bytes", 
                           total_packets, complete_frames, total_bytes);
         }
+        
+        // 适应性休眠以避免CPU占用过高，给tcpip_thread更多时间
+        if (complete_frames > 0) {
+            osal_msleep(5);  /* 有数据时短休眠 */
+        } else {
+            osal_msleep(15); /* 无数据时长休眠 */
+        }
     }
     
-    PPP_DEBUG_INFO("PPP receive thread exiting. Stats: %u packets, %u frames, %u bytes",
-                  total_packets, complete_frames, total_bytes);
-    
+    /* 清理资源 */
     free(rx_buffer);
     free(stream_buffer);
-    g_ppp_rx_thread_completed = true;
-}
-
-/**
- * @brief 处理缓冲区中的所有完整PPP帧
- * @param buffer 数据缓冲区
- * @param buffer_pos 缓冲区当前位置指针（会被更新）
- * @return 处理的帧数量
- */
-static uint32_t ppp_process_complete_frames(uint8_t *buffer, uint32_t *buffer_pos)
-{
-    uint32_t processed_frames = 0;
-    uint32_t scan_pos = 0;
-    uint32_t frame_start = 0;
-    bool in_frame = false;
-    uint32_t new_buffer_pos = 0;
-    
-    /* 扫描整个缓冲区查找完整的PPP帧 */
-    while (scan_pos < *buffer_pos) {
-        if (buffer[scan_pos] == 0x7E) {  /* PPP帧标志 */
-            if (in_frame) {
-                /* 帧结束 - 处理完整帧 */
-                uint32_t frame_len = scan_pos - frame_start + 1;
-                
-                /* PPP帧长度检查：最小2字节（两个0x7E），最大1500字节 */
-                if (frame_len >= 2 && frame_len <= 1500) {
-                    PPP_DEBUG_DEBUG("Complete PPP frame: %u bytes (start=%u, end=%u)", 
-                                  frame_len, frame_start, scan_pos);
-                    
-                    /* 发送给lwIP处理 - 包括空帧（只有头尾0x7E的帧）*/
-                    ppp_lwip_input(buffer + frame_start, frame_len);
-                    processed_frames++;
-                    
-                    /* 更新缓冲区位置到已处理帧之后 */
-                    new_buffer_pos = scan_pos + 1;
-                } else {
-                    PPP_DEBUG_WARN("Invalid PPP frame length: %u bytes, skipping", frame_len);
-                }
-                
-                in_frame = false;
-            } else {
-                /* 帧开始 */
-                frame_start = scan_pos;
-                in_frame = true;
-            }
-        }
-        scan_pos++;
-    }
     
-    /* 移动未处理的数据到缓冲区开头 */
-    if (new_buffer_pos > 0 && new_buffer_pos < *buffer_pos) {
-        uint32_t remaining = *buffer_pos - new_buffer_pos;
-        memmove(buffer, buffer + new_buffer_pos, remaining);
-        *buffer_pos = remaining;
-        
-        PPP_DEBUG_DEBUG("Moved %u unprocessed bytes to buffer start", remaining);
-    } else if (new_buffer_pos >= *buffer_pos) {
-        /* 所有数据都已处理 */
-        *buffer_pos = 0;
-    }
+    PPP_DEBUG_INFO("PPP lwIP receive thread completed");
+    g_ppp_rx_thread_completed = true;
     
-    return processed_frames;
+    PPP_DEBUG_INFO("PPP lwIP receive thread exiting");
 }
 
 /**
diff --git a/code/sdk/zhihui/ppp/src/ppp_serial.c b/code/sdk/zhihui/ppp/src/ppp_serial.c
index 034a4045e..4caa55a26 100644
--- a/code/sdk/zhihui/ppp/src/ppp_serial.c
+++ b/code/sdk/zhihui/ppp/src/ppp_serial.c
@@ -13,8 +13,8 @@
 #include "arch_port.h"
 
 /* PPP性能优化配置 */
-#define PPP_OPTIMIZED_UART_WRITE_TIMEOUT    500    /* UART写超时优化: 1000ms -> 200ms */
-#define PPP_OPTIMIZED_UART_READ_TIMEOUT     300    /* UART读超时优化: 200ms -> 100ms */
+#define PPP_OPTIMIZED_UART_WRITE_TIMEOUT    200    /* UART写超时优化: 1000ms -> 200ms */
+#define PPP_OPTIMIZED_UART_READ_TIMEOUT     100    /* UART读超时优化: 200ms -> 100ms */
 
 /* 串口上下文结构 - 优化缓存机制 */
 typedef struct {
@@ -443,24 +443,7 @@ ppp_error_t ppp_serial_write(const uint8_t *data, uint32_t length)
 
     return result;
 }
-// 根据数据类型动态调整超时
-#define PPP_UART_READ_TIMEOUT_NORMAL    300    // 正常情况300ms
-#define PPP_UART_READ_TIMEOUT_BURST     500    // 连续数据时500ms
-
-// 在ppp_serial.c中实现自适应超时
-static uint32_t get_adaptive_read_timeout(void) {
-    static uint32_t consecutive_reads = 0;
-    static uint32_t last_read_time = 0;
-    uint32_t current_time = osal_get_jiffies();
-    
-    if (current_time - last_read_time < 100) {  // 100ms内的连续读取
-        consecutive_reads++;
-        return PPP_UART_READ_TIMEOUT_BURST;  // 使用更长超时
-    } else {
-        consecutive_reads = 0;
-        return PPP_UART_READ_TIMEOUT_NORMAL;
-    }
-}
+
 /**
  * @brief 读取数据 - AT模式直接从UART读取，PPP模式从软件缓冲区读取
  */
@@ -477,9 +460,7 @@ ppp_error_t ppp_serial_read(uint8_t *buffer, uint32_t buffer_size, uint32_t *byt
         case PPP_SERIAL_MODE_AT:
         /* AT命令模式：直接从UART读取 */
             {
-                int32_t timeout = get_adaptive_read_timeout();
-                PPP_DEBUG_DEBUG("AT mode: Attempting UART read (timeout: %dms)", timeout);
-                int32_t read_result = uapi_uart_read(g_serial_ctx.uart_bus, buffer, buffer_size, timeout);
+                int32_t read_result = uapi_uart_read(g_serial_ctx.uart_bus, buffer, buffer_size, 100);
                 if (read_result > 0) {
                     *bytes_read = (uint32_t)read_result;
                     g_serial_ctx.rx_bytes += *bytes_read;
@@ -498,9 +479,7 @@ ppp_error_t ppp_serial_read(uint8_t *buffer, uint32_t buffer_size, uint32_t *byt
                 /* 使用适中的超时时间来平衡响应性和帧完整性 */
                 // PPP_DEBUG_DEBUG("PPP mode: Attempting UART read (timeout: 200ms)");
                 /* 优化PPP数据模式读取超时：使用配置的优化值以提高协商响应速度 */
-                int32_t timeout = get_adaptive_read_timeout();
-                PPP_DEBUG_DEBUG("PPP mode: Attempting UART read (timeout: %dms)", timeout);
-                int32_t read_result = uapi_uart_read(g_serial_ctx.uart_bus, buffer, buffer_size, timeout);
+                int32_t read_result = uapi_uart_read(g_serial_ctx.uart_bus, buffer, buffer_size, PPP_OPTIMIZED_UART_READ_TIMEOUT);
                 if (read_result > 0) {
                     *bytes_read = (uint32_t)read_result;
                     g_serial_ctx.rx_bytes += *bytes_read;
diff --git a/code/sdk/zhihui/tcptest/CMakeLists.txt b/code/sdk/zhihui/tcptest/CMakeLists.txt
new file mode 100644
index 000000000..2ec1fae08
--- /dev/null
+++ b/code/sdk/zhihui/tcptest/CMakeLists.txt
@@ -0,0 +1,55 @@
+cmake_minimum_required(VERSION 3.16)
+
+# 设置模块名称
+set(COMPONENT_NAME "tcp_test")
+
+# 源文件列表
+set(SOURCES
+    ${CMAKE_CURRENT_SOURCE_DIR}/src/zhihui_tcp_test.c
+    # ${CMAKE_CURRENT_SOURCE_DIR}/src/zhihui_tcp_test_main.c
+)
+
+# 头文件目录
+set(PUBLIC_HEADER
+    ${CMAKE_CURRENT_SOURCE_DIR}/include
+)
+
+set(PRIVATE_HEADER
+    ${ROOT_DIR}/include/middleware/utils/at
+    ${ROOT_DIR}/include/middleware/utils/dfx
+    ${ROOT_DIR}/include/kernel/osal
+    ${ROOT_DIR}/include/drivers/uart
+    ${ROOT_DIR}/open_source/openharmony/third_party/lwip/lwip_v2.1.3/src/include
+    ${ROOT_DIR}/open_source/openharmony/third_party/lwip/lwip_adapter/liteos/src/include
+)
+
+set(PUBLIC_DEFINES    
+    SUPPORT_TCP_TEST
+)
+
+set(PRIVATE_DEFINES
+)
+
+set(COMPONENT_PUBLIC_CCFLAGS
+)
+
+# 编译选项
+set(COMPONENT_CCFLAGS
+    -Wall
+    -Wextra
+    -Werror
+    -O2
+)
+
+# 是否整体链接
+set(WHOLE_LINK
+    false
+)
+
+# 是否为主组件
+set(MAIN_COMPONENT
+    false
+)
+
+# 构建组件
+build_component() 
\ No newline at end of file
diff --git a/code/sdk/zhihui/tcptest/include/zhihui_tcp_debug.h b/code/sdk/zhihui/tcptest/include/zhihui_tcp_debug.h
new file mode 100644
index 000000000..b743b852c
--- /dev/null
+++ b/code/sdk/zhihui/tcptest/include/zhihui_tcp_debug.h
@@ -0,0 +1,83 @@
+#ifndef ZHIHUI_TCP_DEBUG_H
+#define ZHIHUI_TCP_DEBUG_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include <stdio.h>
+#include "debug_print.h"
+
+/* 调试级别定义 */
+#define ZHIHUI_TCP_LOG_LEVEL_NONE    0
+#define ZHIHUI_TCP_LOG_LEVEL_ERROR   1
+#define ZHIHUI_TCP_LOG_LEVEL_WARN    2
+#define ZHIHUI_TCP_LOG_LEVEL_INFO    3
+#define ZHIHUI_TCP_LOG_LEVEL_DEBUG   4
+
+#define DEFAULT_ZHIHUI_TCP_LOG_LEVEL ZHIHUI_TCP_LOG_LEVEL_INFO
+
+#if ZHIHUI_TCP_LOG_ENABLE
+
+/* 前向声明动态调试级别函数 */
+extern int zhihui_tcp_debug_get_level(void);
+
+#define ZHIHUI_TCP_LOG_ERROR(fmt, ...) \
+    do { \
+        if (zhihui_tcp_debug_get_level() >= ZHIHUI_TCP_LOG_LEVEL_ERROR) { \
+            PRINT("[ZH_TCP ERROR] " fmt "\r\n", ##__VA_ARGS__); \
+        } \
+    } while(0)
+
+#define ZHIHUI_TCP_LOG_WARN(fmt, ...) \
+    do { \
+        if (zhihui_tcp_debug_get_level() >= ZHIHUI_TCP_LOG_LEVEL_WARN) { \
+            PRINT("[ZH_TCP WARN] " fmt "\r\n", ##__VA_ARGS__); \
+        } \
+    } while(0)
+
+#define ZHIHUI_TCP_LOG_INFO(fmt, ...) \
+    do { \
+        if (zhihui_tcp_debug_get_level() >= ZHIHUI_TCP_LOG_LEVEL_INFO) { \
+            PRINT("[ZH_TCP INFO] " fmt "\r\n", ##__VA_ARGS__); \
+        } \
+    } while(0)
+
+#define ZHIHUI_TCP_LOG_DEBUG(fmt, ...) \
+    do { \
+        if (zhihui_tcp_debug_get_level() >= ZHIHUI_TCP_LOG_LEVEL_DEBUG) { \
+            PRINT("[ZH_TCP DEBUG] " fmt "\r\n", ##__VA_ARGS__); \
+        } \
+    } while(0)
+
+/* 兼容性宏 - 用于旧代码 */
+#define ZHIHUI_TCP_LOG_PRINT(fmt, ...) \
+    do { \
+    if (zhihui_tcp_debug_get_level() >= ZHIHUI_TCP_LOG_LEVEL_INFO) { \
+        print_str(fmt, ##__VA_ARGS__); \
+    } \
+    } while(0)  
+
+/* 关键信息宏 - 始终打印重要的连接状态信息 */
+#define ZHIHUI_TCP_LOG_CRITICAL(fmt, ...) \
+    do { \
+        PRINT("[zh_tcp] " fmt "\r\n", ##__VA_ARGS__); \
+    } while(0)
+
+#else
+
+#define ZHIHUI_TCP_LOG_ERROR(fmt, ...)
+#define ZHIHUI_TCP_LOG_WARN(fmt, ...)
+#define ZHIHUI_TCP_LOG_INFO(fmt, ...)
+#define ZHIHUI_TCP_LOG_DEBUG(fmt, ...)
+#define ZHIHUI_TCP_LOG_PRINT(fmt, ...)
+#define ZHIHUI_TCP_LOG_CRITICAL(fmt, ...) PRINT("[zh_tcp] " fmt "\r\n", ##__VA_ARGS__)
+
+#endif /* ZHIHUI_TCP_LOG_ENABLE */
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* ZHIHUI_TCP_LOG_H */ 
\ No newline at end of file
diff --git a/code/sdk/zhihui/ppp/include/ppp_tcp_test.h b/code/sdk/zhihui/tcptest/include/zhihui_tcp_test.h
similarity index 93%
rename from code/sdk/zhihui/ppp/include/ppp_tcp_test.h
rename to code/sdk/zhihui/tcptest/include/zhihui_tcp_test.h
index fe92f1bed..4ca765a03 100644
--- a/code/sdk/zhihui/ppp/include/ppp_tcp_test.h
+++ b/code/sdk/zhihui/tcptest/include/zhihui_tcp_test.h
@@ -1,6 +1,6 @@
 /**
- * @file ppp_tcp_test.h
- * @brief PPP TCP性能测试客户端头文件
+ * @file zhihui_tcp_test.h
+ * @brief ZHIHUI TCP性能测试客户端头文件
  * 
  * 功能：
  * - 支持参数配置：服务器地址、端口、测试时间、连接数
@@ -9,8 +9,8 @@
  * - 数据发送和接收验证
  */
 
-#ifndef PPP_TCP_TEST_H
-#define PPP_TCP_TEST_H
+#ifndef ZHIHUI_TCP_TEST_H
+#define ZHIHUI_TCP_TEST_H
 
 #ifdef __cplusplus
 extern "C" {
@@ -19,7 +19,8 @@ extern "C" {
 #include <stdint.h>
 #include <stdbool.h>
 #include <time.h>
-#include "ppp_types.h"
+#include "errcode.h"
+
 #define USE_LWIP_SOCKET 
 
 /* Socket接口兼容性宏定义 */
@@ -28,7 +29,9 @@ extern "C" {
     #include "lwip/sockets.h"
     #include "lwip/netdb.h"
     #include "lwip/sys.h"
+    #ifdef SUPPORT_PPP_SERVICE
     #include "ppp_tcp_lwip_compat.h"  /* 兼容性定义 */
+    #endif
     
     #define TCP_SOCKET(domain, type, protocol)  lwip_socket(domain, type, protocol)
     #define TCP_CONNECT(s, name, namelen)       lwip_connect(s, name, namelen)
@@ -182,26 +185,26 @@ typedef struct {
  * @brief 初始化TCP测试
  * @return PPP_ERR_OK-成功，其他-失败
  */
-ppp_error_t tcp_test_init(void);
+errcode_t tcp_test_init(void);
 
 /**
  * @brief 反初始化TCP测试
  * @return PPP_ERR_OK-成功，其他-失败
  */
-ppp_error_t tcp_test_deinit(void);
+errcode_t tcp_test_deinit(void);
 
 /**
  * @brief 启动TCP测试
  * @param config 测试配置
  * @return PPP_ERR_OK-成功，其他-失败
  */
-ppp_error_t tcp_test_start(const tcp_test_config_t *config);
+errcode_t tcp_test_start(const tcp_test_config_t *config);
 
 /**
  * @brief 停止TCP测试
  * @return PPP_ERR_OK-成功，其他-失败
  */
-ppp_error_t tcp_test_stop(void);
+errcode_t tcp_test_stop(void);
 
 /**
  * @brief 获取测试状态
@@ -214,7 +217,7 @@ bool tcp_test_is_running(void);
  * @param stats 统计信息输出
  * @return PPP_ERR_OK-成功，其他-失败
  */
-ppp_error_t tcp_test_get_stats(tcp_global_stats_t *stats);
+errcode_t tcp_test_get_stats(tcp_global_stats_t *stats);
 
 /**
  * @brief 获取连接统计信息
@@ -222,13 +225,13 @@ ppp_error_t tcp_test_get_stats(tcp_global_stats_t *stats);
  * @param stats 连接统计信息输出
  * @return PPP_ERR_OK-成功，其他-失败
  */
-ppp_error_t tcp_test_get_connection_stats(uint16_t conn_id, tcp_connection_stats_t *stats);
+errcode_t tcp_test_get_connection_stats(uint16_t conn_id, tcp_connection_stats_t *stats);
 
 /**
  * @brief 打印测试报告
  * @return PPP_ERR_OK-成功，其他-失败
  */
-ppp_error_t tcp_test_print_report(void);
+errcode_t tcp_test_print_report(void);
 
 /**
  * @brief 格式化字节数显示
@@ -252,7 +255,7 @@ uint32_t tcp_test_get_time_ms(void);
  * @param config 配置输出
  * @return PPP_ERR_OK-成功，其他-失败
  */
-ppp_error_t tcp_test_parse_args(int argc, char *argv[], tcp_test_config_t *config);
+errcode_t tcp_test_parse_args(int argc, char *argv[], tcp_test_config_t *config);
 
 /**
  * @brief 打印使用帮助
diff --git a/code/sdk/zhihui/ppp/example/ppp_tcp_test.c b/code/sdk/zhihui/tcptest/src/zhihui_tcp_test.c
similarity index 84%
rename from code/sdk/zhihui/ppp/example/ppp_tcp_test.c
rename to code/sdk/zhihui/tcptest/src/zhihui_tcp_test.c
index d214d94da..5e8c97770 100644
--- a/code/sdk/zhihui/ppp/example/ppp_tcp_test.c
+++ b/code/sdk/zhihui/tcptest/src/zhihui_tcp_test.c
@@ -1,20 +1,22 @@
 /**
- * @file ppp_tcp_test.c
- * @brief PPP TCP性能测试客户端实现
+ * @file zhihui_tcp_test.c
+ * @brief ZHIHUI TCP性能测试客户端实现
  * 
  * 基于Python版本tcp_test_client.py实现的C语言版本
  * 支持多连接并发测试、性能统计和数据验证
  * 使用lwIP socket接口兼容嵌入式环境
  */
-
-#include "ppp_tcp_test.h"
-#include "ppp_debug.h"
-#include "ppp_tcp_lwip_compat.h"  /* lwIP兼容性定义 */
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 #include <errno.h>
 #include <signal.h>
+#include "errcode.h"
+#include "zhihui_tcp_test.h"
+#include "zhihui_tcp_debug.h"
+
+
+
 
 /* 时间相关头文件 */
 #ifndef USE_LWIP_SOCKET
@@ -78,29 +80,35 @@ static tcp_mutex_t g_tcp_stats_mutex;
 static bool g_tcp_test_initialized = false;
 
 /* 内部函数声明 */
-static ppp_error_t tcp_test_create_connection_thread(uint16_t conn_id);
+static errcode_t tcp_test_create_connection_thread(uint16_t conn_id);
 static void* tcp_test_connection_worker(void *arg);
-static ppp_error_t tcp_test_generate_data(uint16_t conn_id, uint32_t packet_id, 
+static errcode_t tcp_test_generate_data(uint16_t conn_id, uint32_t packet_id, 
                                           uint8_t *buffer, uint32_t size);
 static uint32_t tcp_test_calculate_checksum(const uint8_t *data, uint32_t size);
 static bool tcp_test_verify_data(const uint8_t *sent_data, const uint8_t *recv_data, uint32_t size);
 static void tcp_test_stats_timer_callback(void *arg);
 static void tcp_test_signal_handler(int signum);
-static ppp_error_t tcp_test_connect_socket(int *sock_fd, const char *host, uint16_t port);
+static errcode_t tcp_test_connect_socket(int *sock_fd, const char *host, uint16_t port);
+
+static int zhihui_tcp_debug_level = DEFAULT_ZHIHUI_TCP_LOG_LEVEL;
+int zhihui_tcp_debug_get_level(void)
+{
+    return zhihui_tcp_debug_level;
+}
 
 /**
  * @brief 初始化TCP测试
  */
-ppp_error_t tcp_test_init(void)
+errcode_t tcp_test_init(void)
 {
     if (g_tcp_test_initialized) {
-        return PPP_ERR_OK;
+        return ERRCODE_SUCC;
     }
     
     // 初始化互斥锁
     if (TCP_MUTEX_INIT(g_tcp_stats_mutex) != 0) {
-        PPP_DEBUG_ERROR("Failed to initialize TCP test mutex");
-        return PPP_ERR_MEMORY;
+        ZHIHUI_TCP_LOG_ERROR("Failed to initialize TCP test mutex");
+        return ERRCODE_FAIL;
     }
     
     // 清零管理器
@@ -113,18 +121,18 @@ ppp_error_t tcp_test_init(void)
 #endif
     
     g_tcp_test_initialized = true;
-    PPP_DEBUG_INFO("TCP test initialized successfully");
+    ZHIHUI_TCP_LOG_INFO("TCP test initialized successfully");
     
-    return PPP_ERR_OK;
+    return ERRCODE_SUCC;
 }
 
 /**
  * @brief 反初始化TCP测试
  */
-ppp_error_t tcp_test_deinit(void)
+errcode_t tcp_test_deinit(void)
 {
     if (!g_tcp_test_initialized) {
-        return PPP_ERR_OK;
+        return ERRCODE_SUCC;
     }
     
     // 停止测试
@@ -134,29 +142,29 @@ ppp_error_t tcp_test_deinit(void)
     TCP_MUTEX_DESTROY(g_tcp_stats_mutex);
     
     g_tcp_test_initialized = false;
-    PPP_DEBUG_INFO("TCP test deinitialized");
+    ZHIHUI_TCP_LOG_INFO("TCP test deinitialized");
     
-    return PPP_ERR_OK;
+    return ERRCODE_SUCC;
 }
 
 /**
  * @brief 启动TCP测试
  */
-ppp_error_t tcp_test_start(const tcp_test_config_t *config)
+errcode_t tcp_test_start(const tcp_test_config_t *config)
 {
     if (!g_tcp_test_initialized) {
-        PPP_DEBUG_ERROR("TCP test not initialized");
-        return PPP_ERR_INVALID_STATE;
+        ZHIHUI_TCP_LOG_ERROR("TCP test not initialized");
+        return ERRCODE_FAIL;
     }
     
     if (!config) {
-        PPP_DEBUG_ERROR("Invalid config parameter");
-        return PPP_ERR_INVALID_PARAM;
+        ZHIHUI_TCP_LOG_ERROR("Invalid config parameter");
+        return ERRCODE_INVALID_PARAM;
     }
     
     if (g_tcp_test_manager.global_stats.test_running) {
-        PPP_DEBUG_ERROR("TCP test already running");
-        return PPP_ERR_INVALID_STATE;
+        ZHIHUI_TCP_LOG_ERROR("TCP test already running");
+        return ERRCODE_FAIL;
     }
     
     // 复制配置
@@ -190,9 +198,9 @@ ppp_error_t tcp_test_start(const tcp_test_config_t *config)
     
     // 创建连接线程
     for (int i = 0; i < config->connection_count; i++) {
-        ppp_error_t ret = tcp_test_create_connection_thread(i);
-        if (ret != PPP_ERR_OK) {
-            PPP_DEBUG_ERROR("Failed to create connection thread %d", i);
+        errcode_t ret = tcp_test_create_connection_thread(i);
+        if (ret != ERRCODE_SUCC) {
+            ZHIHUI_TCP_LOG_ERROR("Failed to create connection thread %d", i);
             tcp_test_stop();
             return ret;
         }
@@ -201,17 +209,17 @@ ppp_error_t tcp_test_start(const tcp_test_config_t *config)
         TCP_SLEEP_MS(100); // 100ms
     }
     
-    PPP_DEBUG_INFO("TCP test started with %d connections", config->connection_count);
-    return PPP_ERR_OK;
+    ZHIHUI_TCP_LOG_INFO("TCP test started with %d connections", config->connection_count);
+    return ERRCODE_SUCC;
 }
 
 /**
  * @brief 停止TCP测试
  */
-ppp_error_t tcp_test_stop(void)
+errcode_t tcp_test_stop(void)
 {
     if (!g_tcp_test_manager.global_stats.test_running) {
-        return PPP_ERR_OK;
+        return ERRCODE_SUCC;
     }
     
     printf("\n正在停止TCP测试...\n");
@@ -244,8 +252,8 @@ ppp_error_t tcp_test_stop(void)
     // 打印最终报告
     tcp_test_print_report();
     
-    PPP_DEBUG_INFO("TCP test stopped");
-    return PPP_ERR_OK;
+    ZHIHUI_TCP_LOG_INFO("TCP test stopped");
+    return ERRCODE_SUCC;
 }
 
 /**
@@ -259,34 +267,34 @@ bool tcp_test_is_running(void)
 /**
  * @brief 获取全局统计信息
  */
-ppp_error_t tcp_test_get_stats(tcp_global_stats_t *stats)
+errcode_t tcp_test_get_stats(tcp_global_stats_t *stats)
 {
     if (!stats) {
-        return PPP_ERR_INVALID_PARAM;
+        return ERRCODE_INVALID_PARAM;
     }
     
     TCP_MUTEX_LOCK(g_tcp_stats_mutex);
     memcpy(stats, &g_tcp_test_manager.global_stats, sizeof(tcp_global_stats_t));
     TCP_MUTEX_UNLOCK(g_tcp_stats_mutex);
     
-    return PPP_ERR_OK;
+    return ERRCODE_SUCC;
 }
 
 /**
  * @brief 创建连接线程
  */
-static ppp_error_t tcp_test_create_connection_thread(uint16_t conn_id)
+static errcode_t tcp_test_create_connection_thread(uint16_t conn_id)
 {
     uint16_t *arg = malloc(sizeof(uint16_t));
     if (!arg) {
-        return PPP_ERR_MEMORY;
+        return ERRCODE_FAIL; 
     }
     
     *arg = conn_id;
     
     TCP_TASK_CREATE(tcp_test_connection_worker, arg, "tcp_test_conn", 8192);
     
-    return PPP_ERR_OK;
+    return ERRCODE_SUCC;
 }
 
 /**
@@ -305,12 +313,12 @@ static void* tcp_test_connection_worker(void *arg)
     uint32_t connect_start = tcp_test_get_time_ms();
     
     // 建立连接
-    ppp_error_t ret = tcp_test_connect_socket(&conn->socket_fd, 
+    errcode_t ret = tcp_test_connect_socket(&conn->socket_fd, 
                                              config->server_host, 
                                              config->server_port);
     
-    if (ret != PPP_ERR_OK) {
-        PPP_DEBUG_ERROR("[连接 %03d] 连接失败", conn_id);
+    if (ret != ERRCODE_SUCC) {
+        ZHIHUI_TCP_LOG_ERROR("[连接 %03d] 连接失败", conn_id);
         TCP_MUTEX_LOCK(g_tcp_stats_mutex);
         g_tcp_test_manager.global_stats.failed_connections++;
         TCP_MUTEX_UNLOCK(g_tcp_stats_mutex);
@@ -329,8 +337,16 @@ static void* tcp_test_connection_worker(void *arg)
     
     // 数据传输循环
     uint32_t packet_counter = 0;
-    uint8_t send_buffer[TCP_TEST_MAX_DATA_SIZE];
-    uint8_t recv_buffer[TCP_TEST_MAX_DATA_SIZE];
+    uint8_t *send_buffer = malloc(TCP_TEST_MAX_DATA_SIZE);
+    uint8_t *recv_buffer = malloc(TCP_TEST_MAX_DATA_SIZE);
+    
+    if (!send_buffer || !recv_buffer) {
+        ZHIHUI_TCP_LOG_ERROR("[连接 %03d] 内存分配失败", conn_id);
+        if (send_buffer) free(send_buffer);
+        if (recv_buffer) free(recv_buffer);
+        conn->errors++;
+        goto thread_exit;
+    }
     
     uint32_t test_end_time = g_tcp_test_manager.global_stats.start_time + 
                             (config->test_duration * 1000);
@@ -344,7 +360,7 @@ static void* tcp_test_connection_worker(void *arg)
         
         // 生成测试数据
         ret = tcp_test_generate_data(conn_id, packet_counter, send_buffer, data_size);
-        if (ret != PPP_ERR_OK) {
+        if (ret != ERRCODE_SUCC) {
             conn->errors++;
             continue;
         }
@@ -353,11 +369,11 @@ static void* tcp_test_connection_worker(void *arg)
         ssize_t bytes_sent = TCP_SEND(conn->socket_fd, send_buffer, data_size, 0);
         if (bytes_sent != (ssize_t)data_size) {
             if (bytes_sent < 0) {
-                PPP_DEBUG_ERROR("[连接 %03d] 发送失败: %s", conn_id, TCP_STRERROR(TCP_GET_ERRNO()));
+                ZHIHUI_TCP_LOG_ERROR("[连接 %03d] 发送失败: %s", conn_id, TCP_STRERROR(TCP_GET_ERRNO()));
                 conn->errors++;
                 break;
             } else {
-                PPP_DEBUG_WARN("[连接 %03d] 发送不完整 (%ld/%d 字节)", 
+                ZHIHUI_TCP_LOG_WARN("[连接 %03d] 发送不完整 (%ld/%d 字节)", 
                               conn_id, bytes_sent, data_size);
             }
         }
@@ -380,12 +396,12 @@ static void* tcp_test_connection_worker(void *arg)
             if (bytes_recv > 0) {
                 total_received += bytes_recv;
             } else if (bytes_recv == 0) {
-                PPP_DEBUG_WARN("[连接 %03d] 连接关闭", conn_id);
+                ZHIHUI_TCP_LOG_WARN("[连接 %03d] 连接关闭", conn_id);
                 goto thread_exit;
             } else {
                 int err = TCP_GET_ERRNO();
                 if (err != TCP_EAGAIN && err != TCP_EWOULDBLOCK) {
-                    PPP_DEBUG_ERROR("[连接 %03d] 接收失败: %s", conn_id, TCP_STRERROR(err));
+                    ZHIHUI_TCP_LOG_ERROR("[连接 %03d] 接收失败: %s", conn_id, TCP_STRERROR(err));
                     conn->errors++;
                     goto thread_exit;
                 }
@@ -406,7 +422,7 @@ static void* tcp_test_connection_worker(void *arg)
                 TCP_MUTEX_UNLOCK(g_tcp_stats_mutex);
             }
         } else {
-            PPP_DEBUG_WARN("[连接 %03d] 接收数据不完整: %ld/%d 字节", 
+            ZHIHUI_TCP_LOG_WARN("[连接 %03d] 接收数据不完整: %ld/%d 字节", 
                           conn_id, total_received, data_size);
             conn->errors++;
         }
@@ -444,18 +460,21 @@ thread_exit:
     conn->connected = false;
     conn->thread_running = false;
     
+    if (send_buffer) free(send_buffer);
+    if (recv_buffer) free(recv_buffer);
+    
     return NULL;
 }
 
 /**
  * @brief 建立Socket连接
  */
-static ppp_error_t tcp_test_connect_socket(int *sock_fd, const char *host, uint16_t port)
+static errcode_t tcp_test_connect_socket(int *sock_fd, const char *host, uint16_t port)
 {
     int fd = TCP_SOCKET(TCP_AF_INET, TCP_SOCK_STREAM, 0);
     if (fd < 0) {
-        PPP_DEBUG_ERROR("Failed to create socket: %s", TCP_STRERROR(TCP_GET_ERRNO()));
-        return PPP_ERR_UNKNOWN;
+        ZHIHUI_TCP_LOG_ERROR("Failed to create socket: %s", TCP_STRERROR(TCP_GET_ERRNO()));
+        return ERRCODE_FAIL;
     }
     
 #ifndef USE_LWIP_SOCKET
@@ -466,7 +485,7 @@ static ppp_error_t tcp_test_connect_socket(int *sock_fd, const char *host, uint1
     
     if (TCP_SETSOCKOPT(fd, TCP_SOL_SOCKET, TCP_SO_RCVTIMEO, &timeout, sizeof(timeout)) < 0 ||
         TCP_SETSOCKOPT(fd, TCP_SOL_SOCKET, TCP_SO_SNDTIMEO, &timeout, sizeof(timeout)) < 0) {
-        PPP_DEBUG_WARN("Failed to set socket timeout");
+        ZHIHUI_TCP_LOG_WARN("Failed to set socket timeout");
     }
 #else
     // 在lwIP环境下设置超时 - 使用正确的数据类型和检查
@@ -476,14 +495,14 @@ static ppp_error_t tcp_test_connect_socket(int *sock_fd, const char *host, uint1
     timeout.tv_usec = 0;
     
     if (TCP_SETSOCKOPT(fd, TCP_SOL_SOCKET, TCP_SO_RCVTIMEO, &timeout, sizeof(timeout)) < 0) {
-        PPP_DEBUG_DEBUG("lwIP SO_RCVTIMEO not supported or failed");
+        ZHIHUI_TCP_LOG_DEBUG("lwIP SO_RCVTIMEO not supported or failed");
     }
     if (TCP_SETSOCKOPT(fd, TCP_SOL_SOCKET, TCP_SO_SNDTIMEO, &timeout, sizeof(timeout)) < 0) {
-        PPP_DEBUG_DEBUG("lwIP SO_SNDTIMEO not supported or failed");
+        ZHIHUI_TCP_LOG_DEBUG("lwIP SO_SNDTIMEO not supported or failed");
     }
     #else
     // lwIP可能不支持超时选项，使用非阻塞模式代替
-    PPP_DEBUG_INFO("lwIP socket timeout not supported, using default behavior");
+    ZHIHUI_TCP_LOG_INFO("lwIP socket timeout not supported, using default behavior");
     #endif
 #endif
     
@@ -493,29 +512,29 @@ static ppp_error_t tcp_test_connect_socket(int *sock_fd, const char *host, uint1
     server_addr.sin_port = TCP_HTONS(port);
     
     if (TCP_INET_PTON(TCP_AF_INET, host, &server_addr.sin_addr) <= 0) {
-        PPP_DEBUG_ERROR("Invalid server address: %s", host);
+        ZHIHUI_TCP_LOG_ERROR("Invalid server address: %s", host);
         TCP_CLOSE(fd);
-        return PPP_ERR_INVALID_PARAM;
+        return ERRCODE_INVALID_PARAM;
     }
     
     if (TCP_CONNECT(fd, (struct sockaddr*)&server_addr, sizeof(server_addr)) < 0) {
-        PPP_DEBUG_ERROR("Failed to connect to %s:%d: %s", host, port, TCP_STRERROR(TCP_GET_ERRNO()));
+        ZHIHUI_TCP_LOG_ERROR("Failed to connect to %s:%d: %s", host, port, TCP_STRERROR(TCP_GET_ERRNO()));
         TCP_CLOSE(fd);
-        return PPP_ERR_UNKNOWN;
+        return ERRCODE_FAIL;
     }
     
     *sock_fd = fd;
-    return PPP_ERR_OK;
+    return ERRCODE_SUCC;
 }
 
 /**
  * @brief 生成测试数据
  */
-static ppp_error_t tcp_test_generate_data(uint16_t conn_id, uint32_t packet_id, 
+static errcode_t tcp_test_generate_data(uint16_t conn_id, uint32_t packet_id, 
                                           uint8_t *buffer, uint32_t size)
 {
     if (!buffer || size < sizeof(tcp_test_packet_header_t)) {
-        return PPP_ERR_INVALID_PARAM;
+        return ERRCODE_INVALID_PARAM;
     }
     
     tcp_test_packet_header_t *header = (tcp_test_packet_header_t*)buffer;
@@ -532,7 +551,7 @@ static ppp_error_t tcp_test_generate_data(uint16_t conn_id, uint32_t packet_id,
     // 计算校验和
     header->checksum = TCP_HTONL(tcp_test_calculate_checksum(buffer, size - sizeof(uint32_t)));
     
-    return PPP_ERR_OK;
+    return ERRCODE_SUCC;
 }
 
 /**
@@ -672,7 +691,7 @@ const char* tcp_test_format_bytes(uint64_t bytes, char *buffer, size_t buffer_si
 /**
  * @brief 打印测试报告
  */
-ppp_error_t tcp_test_print_report(void)
+errcode_t tcp_test_print_report(void)
 {
     uint32_t total_duration = g_tcp_test_manager.global_stats.end_time - 
                              g_tcp_test_manager.global_stats.start_time;
@@ -743,5 +762,5 @@ ppp_error_t tcp_test_print_report(void)
     
     printf("========================================\n");
     
-    return PPP_ERR_OK;
+    return ERRCODE_SUCC;
 } 
\ No newline at end of file
diff --git a/code/sdk/zhihui/ppp/example/ppp_tcp_test_main.c b/code/sdk/zhihui/tcptest/src/zhihui_tcp_test_main.c
similarity index 99%
rename from code/sdk/zhihui/ppp/example/ppp_tcp_test_main.c
rename to code/sdk/zhihui/tcptest/src/zhihui_tcp_test_main.c
index bb45519ea..033e0d381 100644
--- a/code/sdk/zhihui/ppp/example/ppp_tcp_test_main.c
+++ b/code/sdk/zhihui/tcptest/src/zhihui_tcp_test_main.c
@@ -6,7 +6,7 @@
  * 支持与Python版本相同的参数格式
  */
 
-#include "ppp_tcp_test.h"
+#include "zhihui_tcp_test.h"
 #include "ppp_debug.h"
 #include <stdio.h>
 #include <stdlib.h>