"cat1Service",
"cat1Test",
"4gTestcpp",
+ #tcp 测试相关配置
+ "tcp_test",
#websocket 相关配置
"zhihui_websocket",
#ai 相关配置
# "cat1Service",
# "cat1Test",
+ #tcp 测试相关配置
+ "tcp_test",
#websocket 相关配置
"zhihui_websocket",
#ai 相关配置
#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)
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" },
{ (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)
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)
${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
# PPP_OPTIONS=1
SUPPORT_PPP_SERVICE
SUPPORT_AT_PPP
- SUPPORT_TCP_TEST
)
set(PRIVATE_DEFINES
+++ /dev/null
-
\ No newline at end of file
#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"
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;
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;
}
// 获取全局统计信息
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;
}
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);
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);
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卡异常
}
// 更新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;
#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"
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};
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命令处理模块
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;
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");
}
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);
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 ===");
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;
}
}
/**
- * @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响应
* 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");
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) {
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");
}
/**
#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 {
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模式从软件缓冲区读取
*/
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;
/* 使用适中的超时时间来平衡响应性和帧完整性 */
// 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;
--- /dev/null
+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
--- /dev/null
+#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
/**
- * @file ppp_tcp_test.h
- * @brief PPP TCP性能测试客户端头文件
+ * @file zhihui_tcp_test.h
+ * @brief ZHIHUI TCP性能测试客户端头文件
*
* 功能：
* - 支持参数配置：服务器地址、端口、测试时间、连接数
* - 数据发送和接收验证
*/
-#ifndef PPP_TCP_TEST_H
-#define PPP_TCP_TEST_H
+#ifndef ZHIHUI_TCP_TEST_H
+#define ZHIHUI_TCP_TEST_H
#ifdef __cplusplus
extern "C" {
#include <stdint.h>
#include <stdbool.h>
#include <time.h>
-#include "ppp_types.h"
+#include "errcode.h"
+
#define USE_LWIP_SOCKET
/* Socket接口兼容性宏定义 */
#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)
* @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 获取测试状态
* @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 获取连接统计信息
* @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 格式化字节数显示
* @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 打印使用帮助
/**
- * @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
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;
}
// 清零管理器
#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;
}
// 停止测试
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;
}
// 复制配置
// 创建连接线程
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;
}
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");
// 打印最终报告
tcp_test_print_report();
- PPP_DEBUG_INFO("TCP test stopped");
- return PPP_ERR_OK;
+ ZHIHUI_TCP_LOG_INFO("TCP test stopped");
+ return ERRCODE_SUCC;
}
/**
/**
* @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;
}
/**
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);
// 数据传输循环
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);
// 生成测试数据
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;
}
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);
}
}
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;
}
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++;
}
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
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环境下设置超时 - 使用正确的数据类型和检查
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
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;
// 计算校验和
header->checksum = TCP_HTONL(tcp_test_calculate_checksum(buffer, size - sizeof(uint32_t)));
- return PPP_ERR_OK;
+ return ERRCODE_SUCC;
}
/**
/**
* @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;
printf("========================================\n");
- return PPP_ERR_OK;
+ return ERRCODE_SUCC;
}
\ No newline at end of file
* 支持与Python版本相同的参数格式
*/
-#include "ppp_tcp_test.h"
+#include "zhihui_tcp_test.h"
#include "ppp_debug.h"
#include <stdio.h>
#include <stdlib.h>
projects / mirrors / FD230.git / commitdiff