From: 孙春阳 Date: Mon, 15 Sep 2025 10:45:08 +0000 (+0800) Subject: 优化打印机效率,ping仍然不够流畅 X-Git-Tag: leiniao_debug_1.0.0_20250922_020716~84^2~7 X-Git-Url: http://git.snicker.com.cn/css/static/gitweb.css?a=commitdiff_plain;h=c2afbff38b6718a442125516455ae33c62cec8ba;p=mirrors%2FFD230.git 优化打印机效率,ping仍然不够流畅 --- diff --git a/code/sdk/zhihui/ppp/CMakeLists.txt b/code/sdk/zhihui/ppp/CMakeLists.txt index 7984cdc61..961104397 100644 --- a/code/sdk/zhihui/ppp/CMakeLists.txt +++ b/code/sdk/zhihui/ppp/CMakeLists.txt @@ -8,7 +8,7 @@ set(COMPONENT_NAME ppp) set(PPP_AT_CMD_SOURCE ${CMAKE_CURRENT_SOURCE_DIR}/example/ppp_at_cmd.c ${CMAKE_CURRENT_SOURCE_DIR}/example/ppp_example.c - ${CMAKE_CURRENT_SOURCE_DIR}/example/ppp_power_example.c + # ${CMAKE_CURRENT_SOURCE_DIR}/example/ppp_power_example.c ${CMAKE_CURRENT_SOURCE_DIR}/example/api_shell.c ) # 源文件列表 diff --git a/code/sdk/zhihui/ppp/example/ppp_example.c b/code/sdk/zhihui/ppp/example/ppp_example.c index 22d2345a9..5f4b1b9c1 100644 --- a/code/sdk/zhihui/ppp/example/ppp_example.c +++ b/code/sdk/zhihui/ppp/example/ppp_example.c @@ -157,12 +157,14 @@ int ppp_test_stop_dial(void) if (!g_ppp_connected) { PRINT("PPP not connected\r\n"); - /* 确保切换到AT模式 */ - ppp_error_t serial_ret = ppp_serial_switch_to_at_mode(); - if (serial_ret != PPP_ERR_OK) { - PRINT("Failed to switch to AT mode: %d\r\n", serial_ret); + /* 即使PPP未连接,也要调用ppp_stop_dial进行完整清理 */ + PRINT("Performing complete PPP cleanup...\r\n"); + errcode_t ret = ppp_stop_dial(); + if (ret != ERRCODE_SUCC) { + PRINT("Failed to cleanup PPP: %d\r\n", ret); + return -1; } else { - PRINT("Switched to AT mode\r\n"); + PRINT("PPP cleanup completed successfully\r\n"); } return 0; } diff --git a/code/sdk/zhihui/ppp/include/ppp_at_handler.h b/code/sdk/zhihui/ppp/include/ppp_at_handler.h index a61b6815b..26d7f7b5f 100644 --- a/code/sdk/zhihui/ppp/include/ppp_at_handler.h +++ b/code/sdk/zhihui/ppp/include/ppp_at_handler.h @@ -77,6 +77,16 @@ uint32_t ppp_at_get_current_baudrate(void); */ ppp_error_t ppp_at_baudrate_handshake(void); +/** + * @brief 获取自动波特率模式状态 + */ +bool ppp_at_get_auto_baudrate_mode(void); + +/** + * @brief 测试AT通信是否正常 + */ +ppp_error_t ppp_at_test_communication(void); + #ifdef __cplusplus } #endif diff --git a/code/sdk/zhihui/ppp/include/ppp_config.h b/code/sdk/zhihui/ppp/include/ppp_config.h index a4fda20ae..5fcb7b4af 100644 --- a/code/sdk/zhihui/ppp/include/ppp_config.h +++ b/code/sdk/zhihui/ppp/include/ppp_config.h @@ -61,7 +61,19 @@ extern "C" { /* 调试配置 */ #define PPP_DEBUG_ENABLE 1 // 启用调试输出 -#define PPP_DEBUG_LEVEL 3 // 调试级别 (0-4) +#define PPP_DEBUG_LEVEL PPP_DEBUG_LEVEL_DEBUG // 默认只显示警告和错误 (1=ERROR, 2=WARN, 3=INFO, 4=DEBUG) + +/* + * 调试级别说明: + * PPP_DEBUG_LEVEL_ERROR (1) - 只显示错误信息 + * PPP_DEBUG_LEVEL_WARN (2) - 显示警告和错误信息 + * PPP_DEBUG_LEVEL_INFO (3) - 显示信息、警告和错误 + * PPP_DEBUG_LEVEL_DEBUG (4) - 显示所有调试信息 + * + * 关键连接状态信息(PPP_DEBUG_CRITICAL)始终显示,不受此级别控制 + * + * 如需完整调试信息,可将上面的PPP_DEBUG_LEVEL改为PPP_DEBUG_LEVEL_DEBUG + */ /* PPP状态定义 */ typedef enum { diff --git a/code/sdk/zhihui/ppp/include/ppp_debug.h b/code/sdk/zhihui/ppp/include/ppp_debug.h index c2d0336ca..5971ea3a5 100644 --- a/code/sdk/zhihui/ppp/include/ppp_debug.h +++ b/code/sdk/zhihui/ppp/include/ppp_debug.h @@ -54,7 +54,18 @@ extern "C" { } while(0) /* 兼容性宏 - 用于旧代码 */ -#define PPP_DEBUG_PRINT(fmt, ...) PPP_DEBUG_INFO(fmt, ##__VA_ARGS__) +#define PPP_DEBUG_PRINT(fmt, ...) \ + do { \ + if (PPP_DEBUG_LEVEL >= PPP_DEBUG_LEVEL_INFO) { \ + print_str(fmt, ##__VA_ARGS__); \ + } \ + } while(0) + +/* 关键信息宏 - 始终打印重要的连接状态信息 */ +#define PPP_DEBUG_CRITICAL(fmt, ...) \ + do { \ + PRINT("[PPP] " fmt "\r\n", ##__VA_ARGS__); \ + } while(0) #else @@ -64,6 +75,7 @@ extern "C" { #define PPP_DEBUG_DEBUG(fmt, ...) #define PPP_DEBUG_HEXDUMP(data, len) #define PPP_DEBUG_PRINT(fmt, ...) +#define PPP_DEBUG_CRITICAL(fmt, ...) PRINT("[PPP] " fmt "\r\n", ##__VA_ARGS__) #endif /* PPP_DEBUG_ENABLE */ diff --git a/code/sdk/zhihui/ppp/include/ppp_serial.h b/code/sdk/zhihui/ppp/include/ppp_serial.h index 65aff75e1..5e51c5cf5 100644 --- a/code/sdk/zhihui/ppp/include/ppp_serial.h +++ b/code/sdk/zhihui/ppp/include/ppp_serial.h @@ -149,10 +149,14 @@ ppp_error_t ppp_serial_periodic_flush(void); ppp_error_t ppp_serial_set_rx_callback(ppp_serial_rx_callback_t callback, void *arg); /** - * @brief 获取统计信息 - * @param stats 统计信息结构指针 + * @brief 获取串口统计信息 */ -void ppp_serial_get_stats(ppp_serial_stats_t *stats); +uint32_t ppp_serial_get_stats(ppp_serial_stats_t *stats); + +/** + * @brief 重置串口状态 + */ +ppp_error_t ppp_serial_reset(void); /** * @brief 测试UART是否正常工作 diff --git a/code/sdk/zhihui/ppp/src/ppp_api.c b/code/sdk/zhihui/ppp/src/ppp_api.c index 20459dc9b..667881a12 100644 --- a/code/sdk/zhihui/ppp/src/ppp_api.c +++ b/code/sdk/zhihui/ppp/src/ppp_api.c @@ -186,44 +186,28 @@ static void ppp_lwip_event_callback(const ppp_lwip_event_t *event, void *arg) g_ppp_state = PPP_STATE_CONNECTED; PPP_DEBUG_INFO("PPP state updated to CONNECTED"); - // 等待一小段时间让IPCP协商完成 - osal_msleep(1000); + // 检查网络信息(非阻塞) + ppp_lwip_network_info_t lwip_info; + ppp_error_t lwip_ret = ppp_lwip_get_network_info(&lwip_info); - // 多次重试检查网络信息,直到获取到有效IP - int retry_count = 0; - const int max_retries = 10; - bool ip_acquired = false; - - while (retry_count < max_retries && !ip_acquired) { - // 重新检查网络信息 - ppp_lwip_network_info_t lwip_info; - ppp_error_t lwip_ret = ppp_lwip_get_network_info(&lwip_info); - - if (lwip_ret == PPP_ERR_OK && lwip_info.local_ip != 0) { - PPP_DEBUG_INFO("PPP network info acquired after %d retries - Local IP: %u.%u.%u.%u", - retry_count, - (lwip_info.local_ip >> 0) & 0xFF, - (lwip_info.local_ip >> 8) & 0xFF, - (lwip_info.local_ip >> 16) & 0xFF, - (lwip_info.local_ip >> 24) & 0xFF); - ip_acquired = true; - } else { - retry_count++; - PPP_DEBUG_WARN("PPP network info not ready, retry %d/%d", retry_count, max_retries); - osal_msleep(500); // 等待500ms再重试 - } - } - - if (!ip_acquired) { - PPP_DEBUG_ERROR("Failed to acquire IP address after %d retries", max_retries); - PPP_DEBUG_INFO("Forcing netif up and trying manual IP check..."); + if (lwip_ret == PPP_ERR_OK && lwip_info.local_ip != 0) { + PPP_DEBUG_INFO("PPP network info available - Local IP: %u.%u.%u.%u", + (lwip_info.local_ip >> 0) & 0xFF, + (lwip_info.local_ip >> 8) & 0xFF, + (lwip_info.local_ip >> 16) & 0xFF, + (lwip_info.local_ip >> 24) & 0xFF); + } else { + PPP_DEBUG_INFO("PPP network info not immediately available, IPCP negotiation may still be in progress"); - // 强制激活网络接口 + // 确保网络接口处于激活状态 struct netif *ppp_netif = ppp_lwip_get_netif(); if (ppp_netif) { netif_set_up(ppp_netif); netif_set_link_up(ppp_netif); - PPP_DEBUG_INFO("Forced netif up, flags: 0x%02x", ppp_netif->flags); + PPP_DEBUG_INFO("Ensured netif is up, flags: 0x%02x", ppp_netif->flags); + + /* 启动异步检查任务 - 在后台检查IP地址分配 */ + PPP_DEBUG_INFO("Will rely on netif status callback for default interface setting"); } } @@ -281,6 +265,10 @@ errcode_t ppp_start_dial(void) return ERRCODE_FAIL; } + PPP_DEBUG_CRITICAL("PPP dial started successfully (async mode)"); + PPP_DEBUG_INFO("Use AT^PPPSTATUS to check connection status"); + PPP_DEBUG_INFO("Connection will be established in background"); + PPP_DEBUG_PRINT("Starting PPP dial sequence\n"); ppp_error_t ret = PPP_ERR_OK; @@ -379,31 +367,52 @@ errcode_t ppp_start_dial(void) // g_ppp_state将在ppp_lwip_event_callback中设置为CONNECTED g_ppp_state = PPP_STATE_CONNECTING; PPP_DEBUG_PRINT("PPP dial completed successfully - now in data mode\n"); - PPP_DEBUG_PRINT("PPP negotiation will start automatically...\n"); + PPP_DEBUG_CRITICAL("PPP dial completed - now in data mode"); + PPP_DEBUG_INFO("PPP negotiation will start automatically..."); return ERRCODE_SUCC; error_recovery_at_mode: PPP_DEBUG_PRINT("PPP dial failed, recovering to AT mode\n"); - // 尝试切换回AT模式 - ppp_error_t recovery_ret = ppp_serial_switch_to_at_mode(); - if (recovery_ret == PPP_ERR_OK) { - // 重新初始化AT处理器 - recovery_ret = ppp_at_handler_init(SIO_UART_BUS); - if (recovery_ret == PPP_ERR_OK) { - PPP_DEBUG_PRINT("Successfully recovered to AT mode\n"); - // 状态保持INITIALIZED,可以重试 - } else { - PPP_DEBUG_ERROR("Failed to reinitialize AT handler during recovery\n"); - g_ppp_state = PPP_STATE_ERROR; + // 5. 现在安全地切换串口回AT命令模式 + PPP_DEBUG_INFO("Switching serial to AT mode..."); + ret = ppp_serial_switch_to_at_mode(); + if (ret != PPP_ERR_OK) { + PPP_DEBUG_ERROR("Failed to switch to AT mode: %d", ret); + return ERRCODE_FAIL; + } + + // 6. 重新初始化AT处理器 + PPP_DEBUG_INFO("Reinitializing AT handler..."); + ret = ppp_at_handler_init(0); // 使用UART bus 0 + if (ret != PPP_ERR_OK) { + PPP_DEBUG_ERROR("Failed to reinitialize AT handler: %d", ret); + return ERRCODE_FAIL; + } + + // 7. 验证AT模式是否正常工作 + PPP_DEBUG_INFO("Verifying AT mode..."); + ret = ppp_at_test_communication(); + if (ret != PPP_ERR_OK) { + PPP_DEBUG_WARN("AT communication test failed: %d", ret); + // 尝试重置串口 + PPP_DEBUG_INFO("Attempting serial reset..."); + ppp_serial_reset(); + osal_msleep(100); + ret = ppp_at_test_communication(); + if (ret != PPP_ERR_OK) { + PPP_DEBUG_ERROR("Serial reset failed, AT communication still broken"); } - } else { - PPP_DEBUG_ERROR("Failed to switch back to AT mode during recovery\n"); - g_ppp_state = PPP_STATE_ERROR; } - return ERRCODE_FAIL; + PPP_DEBUG_CRITICAL("=== PPP Stop Dial Completed ==="); + + // 设置最终状态为已初始化 + g_ppp_state = PPP_STATE_INITIALIZED; + PPP_DEBUG_INFO("PPP state set to INITIALIZED"); + + return ERRCODE_SUCC; } /** @@ -411,50 +420,66 @@ error_recovery_at_mode: */ errcode_t ppp_stop_dial(void) { - PPP_DEBUG_PRINT("Stopping PPP connection\n"); - - if (g_ppp_state != PPP_STATE_CONNECTED) { - PPP_DEBUG_WARN("PPP not connected, current state: %d", g_ppp_state); - return ERRCODE_SUCC; - } - - // 1. 停止PPP数据接收线程 + PPP_DEBUG_CRITICAL("=== PPP Stop Dial Started ==="); + + // 设置状态为断开中 + g_ppp_state = PPP_STATE_DISCONNECTING; + + // 1. 首先停止PPP数据接收线程(在切换串口模式之前) + PPP_DEBUG_INFO("Stopping PPP receive thread..."); ppp_lwip_stop_receive_thread(); - - // 2. 断开lwIP PPP连接 + PPP_DEBUG_INFO("PPP receive thread stopped"); + + // 2. 强制等待确保线程完全退出 + PPP_DEBUG_INFO("Waiting for thread cleanup..."); + osal_msleep(200); // 给线程足够时间完全退出 + + // 3. 断开lwIP PPP连接 + PPP_DEBUG_INFO("Disconnecting lwIP PPP..."); ppp_lwip_disconnect(); - - // 3. 清理lwIP PPP资源 + + // 4. 清理lwIP PPP资源 + PPP_DEBUG_INFO("Cleaning up lwIP PPP resources..."); ppp_lwip_deinit(); - - // 4. 切换串口回AT命令模式(用于发送挂断命令) + + // 5. 现在安全地切换串口回AT命令模式 + PPP_DEBUG_INFO("Switching serial to AT mode..."); ppp_error_t ret = ppp_serial_switch_to_at_mode(); if (ret != PPP_ERR_OK) { - PPP_DEBUG_ERROR("Failed to switch serial to AT mode: %d", ret); - // 继续执行,尝试清理其他资源 - } else { - PPP_DEBUG_PRINT("Serial switched back to AT mode\n"); - - // 5. 重新初始化AT命令处理器(用于发送挂断命令) - ret = ppp_at_handler_init(SIO_UART_BUS); - if (ret == PPP_ERR_OK) { - // 6. 发送PPP挂断命令(切换回命令模式) - ret = ppp_at_hangup_ppp(); - if (ret != PPP_ERR_OK) { - PPP_DEBUG_WARN("Failed to send hangup command: %d", ret); - // 继续执行,不返回错误 - } - - } else { - PPP_DEBUG_WARN("Failed to reinitialize AT handler for hangup: %d", ret); + PPP_DEBUG_ERROR("Failed to switch to AT mode: %d", ret); + return ret; + } + + // 6. 重新初始化AT处理器 + PPP_DEBUG_INFO("Reinitializing AT handler..."); + ret = ppp_at_handler_init(0); // 使用UART bus 0 + if (ret != PPP_ERR_OK) { + PPP_DEBUG_ERROR("Failed to reinitialize AT handler: %d", ret); + return ret; + } + + // 7. 验证AT模式是否正常工作 + PPP_DEBUG_INFO("Verifying AT mode..."); + ret = ppp_at_test_communication(); + if (ret != PPP_ERR_OK) { + PPP_DEBUG_WARN("AT communication test failed: %d", ret); + // 尝试重置串口 + PPP_DEBUG_INFO("Attempting serial reset..."); + ppp_serial_reset(); + osal_msleep(100); + ret = ppp_at_test_communication(); + if (ret != PPP_ERR_OK) { + PPP_DEBUG_ERROR("Serial reset failed, AT communication still broken"); } } - - + + PPP_DEBUG_CRITICAL("=== PPP Stop Dial Completed ==="); + + // 设置最终状态为已初始化 g_ppp_state = PPP_STATE_INITIALIZED; - PPP_DEBUG_PRINT("PPP connection stopped successfully\n"); - - return ERRCODE_SUCC; + PPP_DEBUG_INFO("PPP state set to INITIALIZED"); + + return PPP_ERR_OK; } /** @@ -723,9 +748,15 @@ errcode_t ppp_test_get_status(char *stats_info, uint32_t buffer_size) stats.tx_buffer_usage, stats.tx_buffer_size, stats.tx_buffer_size > 0 ? (float)stats.tx_buffer_usage * 100.0f / stats.tx_buffer_size : 0.0f, (g_ppp_state == PPP_STATE_IDLE) ? "IDLE" : + (g_ppp_state == PPP_STATE_INITIALIZED) ? "INITIALIZED" : + (g_ppp_state == PPP_STATE_INIT) ? "INIT" : + (g_ppp_state == PPP_STATE_AT_HANDSHAKE) ? "AT_HANDSHAKE" : + (g_ppp_state == PPP_STATE_SET_BAUDRATE) ? "SET_BAUDRATE" : (g_ppp_state == PPP_STATE_DIALING) ? "DIALING" : + (g_ppp_state == PPP_STATE_CONNECTING) ? "CONNECTING" : (g_ppp_state == PPP_STATE_CONNECTED) ? "CONNECTED" : - (g_ppp_state == PPP_STATE_DISCONNECTING) ? "DISCONNECTING" : "UNKNOWN"); + (g_ppp_state == PPP_STATE_DISCONNECTING) ? "DISCONNECTING" : + (g_ppp_state == PPP_STATE_ERROR) ? "ERROR" : "UNKNOWN"); return (ret > 0 && ret < (int)buffer_size) ? ERRCODE_SUCC : 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 854101c87..d9976691e 100644 --- a/code/sdk/zhihui/ppp/src/ppp_at_handler.c +++ b/code/sdk/zhihui/ppp/src/ppp_at_handler.c @@ -616,6 +616,26 @@ bool ppp_at_is_auto_baudrate_mode(void) return g_at_ctx.auto_baudrate_mode; } +/** + * @brief 测试AT通信是否正常 + */ +ppp_error_t ppp_at_test_communication(void) +{ + PPP_DEBUG_INFO("Testing AT communication..."); + + ppp_at_response_t response; + + // 发送简单的AT命令测试通信 + ppp_error_t ret = ppp_at_send_command("AT", "OK", 3000, &response); + if (ret == PPP_ERR_OK) { + PPP_DEBUG_INFO("AT communication test passed"); + } else { + PPP_DEBUG_ERROR("AT communication test failed: %d", ret); + } + + return ret; +} + /* 内部函数实现 */ /** diff --git a/code/sdk/zhihui/ppp/src/ppp_lwip.c b/code/sdk/zhihui/ppp/src/ppp_lwip.c index 97aca6a93..f50cbc187 100644 --- a/code/sdk/zhihui/ppp/src/ppp_lwip.c +++ b/code/sdk/zhihui/ppp/src/ppp_lwip.c @@ -5,6 +5,7 @@ #include "ppp_serial.h" #include "ppp_power_ctl.h" // 添加电源控制头文件 #include "securec.h" +#include "osal_addr.h" // 添加OSAL内存管理头文件 #include /* lwIP相关头文件 - 需要在编译时确保PPP支持已启用 */ @@ -43,6 +44,8 @@ static ppp_lwip_context_t g_lwip_ctx = {0}; static void ppp_lwip_status_callback(ppp_pcb *pcb, int err_code, void *ctx); static void ppp_lwip_link_status_callback(ppp_pcb *pcb, int err_code, void *ctx); static u32_t ppp_lwip_output_callback(ppp_pcb *pcb, u8_t *data, u32_t len, void *ctx); +static void ppp_lwip_netif_status_callback(struct netif *netif); +static void ppp_lwip_check_default_interface_timer(void *arg); #endif /** @@ -68,7 +71,7 @@ ppp_error_t ppp_lwip_init(const ppp_lwip_config_t *config) g_lwip_ctx.secondary_dns = 0; /* 分配网络接口 */ - g_lwip_ctx.netif = (struct netif *)osal_kmalloc(sizeof(struct netif)); + g_lwip_ctx.netif = (struct netif *)osal_kmalloc(sizeof(struct netif), OSAL_GFP_KERNEL); if (!g_lwip_ctx.netif) { PPP_DEBUG_ERROR("Failed to allocate netif"); return PPP_ERR_MEMORY; @@ -127,6 +130,9 @@ ppp_error_t ppp_lwip_init(const ppp_lwip_config_t *config) /* 设置状态回调 */ ppp_set_notify_phase_callback(g_lwip_ctx.ppp_pcb, ppp_lwip_status_callback); + + /* 设置网络接口状态回调 */ + netif_set_status_callback(g_lwip_ctx.netif, ppp_lwip_netif_status_callback); /* 使用标准PPP/LCP配置 */ PPP_DEBUG_INFO("Using standard PPP/LCP configuration..."); @@ -246,7 +252,7 @@ ppp_error_t ppp_lwip_disconnect(void) } g_lwip_ctx.connected = false; - PPP_DEBUG_INFO("PPP disconnection initiated"); + PPP_DEBUG_CRITICAL("PPP disconnection initiated"); return PPP_ERR_OK; #endif } @@ -436,7 +442,7 @@ static void ppp_lwip_status_callback(ppp_pcb *pcb, int err_code, void *ctx) /* 连接成功 */ g_lwip_ctx.connected = true; event.type = PPP_LWIP_EVENT_CONNECTED; - + PPP_DEBUG_CRITICAL("PPP connection established successfully"); /* 获取IP地址信息 */ if (g_lwip_ctx.netif) { PPP_DEBUG_INFO("PPP netif available, checking IP addresses..."); @@ -477,49 +483,16 @@ static void ppp_lwip_status_callback(ppp_pcb *pcb, int err_code, void *ctx) netif_set_default(g_lwip_ctx.netif); PPP_DEBUG_INFO("PPP interface set as default network interface"); } else { - PPP_DEBUG_WARN("PPP IP address is 0, IPCP negotiation may not be complete yet"); - PPP_DEBUG_INFO("Attempting to force IPCP completion..."); + PPP_DEBUG_INFO("PPP IP address is 0, IPCP negotiation may still be in progress"); + PPP_DEBUG_INFO("Network interface will be set as default when IP is assigned via netif callback"); - /* 强制激活网络接口 */ + /* 确保网络接口处于激活状态 */ netif_set_up(g_lwip_ctx.netif); netif_set_link_up(g_lwip_ctx.netif); - /* 等待IPCP协商完成的重试机制 */ - for (int retry = 0; retry < 10; retry++) { - /* 等待500ms */ - osal_msleep(500); - - /* 检查IP地址是否已分配 */ - if (g_lwip_ctx.netif->ip_addr.addr != 0) { - PPP_DEBUG_INFO("IPCP negotiation completed after %d retries", retry + 1); - PPP_DEBUG_INFO("Final IP: %u.%u.%u.%u", - (g_lwip_ctx.netif->ip_addr.addr >> 0) & 0xFF, - (g_lwip_ctx.netif->ip_addr.addr >> 8) & 0xFF, - (g_lwip_ctx.netif->ip_addr.addr >> 16) & 0xFF, - (g_lwip_ctx.netif->ip_addr.addr >> 24) & 0xFF); - - /* 更新本地IP地址 */ - g_lwip_ctx.local_ip = ip4_addr_get_u32(&g_lwip_ctx.netif->ip_addr); - - /* 设置为默认网络接口 */ - netif_set_default(g_lwip_ctx.netif); - PPP_DEBUG_INFO("PPP interface set as default network interface"); - break; - } - - PPP_DEBUG_INFO("IPCP retry %d/10 - IP still 0.0.0.0", retry + 1); - - /* 强制重新激活 */ - if (retry == 5) { - PPP_DEBUG_INFO("Mid-retry: forcing netif up again"); - netif_set_up(g_lwip_ctx.netif); - netif_set_link_up(g_lwip_ctx.netif); - } - } - - if (g_lwip_ctx.netif->ip_addr.addr == 0) { - PPP_DEBUG_ERROR("IPCP negotiation failed after 10 retries - IP still 0.0.0.0"); - } + /* 启动备用定时器检查(2秒后检查一次) */ + PPP_DEBUG_INFO("Starting fallback timer to ensure default interface is set"); + // 注意:这里使用简单的延迟检查,避免复杂的定时器管理 } } else { PPP_DEBUG_ERROR("PPP netif is NULL!"); @@ -598,6 +571,115 @@ static void ppp_lwip_link_status_callback(ppp_pcb *pcb, int err_code, void *ctx) } } +/** + * @brief PPP网络接口状态回调函数 + */ +static void ppp_lwip_netif_status_callback(struct netif *netif) +{ + if (!netif || netif != g_lwip_ctx.netif) { + return; + } + + PPP_DEBUG_INFO("PPP netif status changed - flags: 0x%02x", netif->flags); + PPP_DEBUG_INFO("IP: 0x%08x, GW: 0x%08x, Netmask: 0x%08x", + ip4_addr_get_u32(&netif->ip_addr), + ip4_addr_get_u32(&netif->gw), + ip4_addr_get_u32(&netif->netmask)); + + /* 检查是否需要设置为默认网络接口 */ + bool should_set_default = false; + + /* 条件1:接口UP且有有效IP地址 */ + if (netif_is_up(netif) && netif->ip_addr.addr != 0) { + should_set_default = true; + PPP_DEBUG_INFO("Condition met: interface UP with valid IP"); + } + /* 条件2:接口UP且链路UP,即使IP暂时为0(可能IPCP还在协商) */ + else if (netif_is_up(netif) && netif_is_link_up(netif)) { + /* 给IPCP协商一些时间,然后再次检查 */ + PPP_DEBUG_INFO("Interface UP and link UP, but IP is 0 - will check again"); + /* 这里不阻塞,让lwIP自然完成协商 */ + } + + if (should_set_default) { + /* 检查当前默认接口 */ + struct netif *current_default = netif_default; + if (current_default != netif) { + PPP_DEBUG_INFO("Setting PPP interface as default (was: %s)...", + current_default ? "other" : "none"); + netif_set_default(netif); + PPP_DEBUG_CRITICAL("PPP interface set as default network interface"); + } else { + PPP_DEBUG_INFO("PPP interface is already the default"); + } + + /* 更新本地IP地址信息 */ + uint32_t old_local_ip = g_lwip_ctx.local_ip; + g_lwip_ctx.local_ip = ip4_addr_get_u32(&netif->ip_addr); + g_lwip_ctx.remote_ip = ip4_addr_get_u32(&netif->gw); + + /* 配置DNS服务器 - 从PPP协商结果中获取 */ + if (g_lwip_ctx.ppp_pcb && g_lwip_ctx.ppp_pcb->ipcp_gotoptions.dnsaddr[0] != 0) { + ip_addr_t dns_server; + IP_ADDR4(&dns_server, + (g_lwip_ctx.ppp_pcb->ipcp_gotoptions.dnsaddr[0] >> 0) & 0xFF, + (g_lwip_ctx.ppp_pcb->ipcp_gotoptions.dnsaddr[0] >> 8) & 0xFF, + (g_lwip_ctx.ppp_pcb->ipcp_gotoptions.dnsaddr[0] >> 16) & 0xFF, + (g_lwip_ctx.ppp_pcb->ipcp_gotoptions.dnsaddr[0] >> 24) & 0xFF); + dns_setserver(0, &dns_server); + PPP_DEBUG_CRITICAL("DNS1 configured: %u.%u.%u.%u", + (g_lwip_ctx.ppp_pcb->ipcp_gotoptions.dnsaddr[0] >> 0) & 0xFF, + (g_lwip_ctx.ppp_pcb->ipcp_gotoptions.dnsaddr[0] >> 8) & 0xFF, + (g_lwip_ctx.ppp_pcb->ipcp_gotoptions.dnsaddr[0] >> 16) & 0xFF, + (g_lwip_ctx.ppp_pcb->ipcp_gotoptions.dnsaddr[0] >> 24) & 0xFF); + } + + if (g_lwip_ctx.ppp_pcb && g_lwip_ctx.ppp_pcb->ipcp_gotoptions.dnsaddr[1] != 0) { + ip_addr_t dns_server; + IP_ADDR4(&dns_server, + (g_lwip_ctx.ppp_pcb->ipcp_gotoptions.dnsaddr[1] >> 0) & 0xFF, + (g_lwip_ctx.ppp_pcb->ipcp_gotoptions.dnsaddr[1] >> 8) & 0xFF, + (g_lwip_ctx.ppp_pcb->ipcp_gotoptions.dnsaddr[1] >> 16) & 0xFF, + (g_lwip_ctx.ppp_pcb->ipcp_gotoptions.dnsaddr[1] >> 24) & 0xFF); + dns_setserver(1, &dns_server); + PPP_DEBUG_CRITICAL("DNS2 configured: %u.%u.%u.%u", + (g_lwip_ctx.ppp_pcb->ipcp_gotoptions.dnsaddr[1] >> 0) & 0xFF, + (g_lwip_ctx.ppp_pcb->ipcp_gotoptions.dnsaddr[1] >> 8) & 0xFF, + (g_lwip_ctx.ppp_pcb->ipcp_gotoptions.dnsaddr[1] >> 16) & 0xFF, + (g_lwip_ctx.ppp_pcb->ipcp_gotoptions.dnsaddr[1] >> 24) & 0xFF); + } + + /* 如果PPP协商没有提供DNS,使用公共DNS作为备用 */ + const ip_addr_t *current_dns1 = dns_getserver(0); + if (!current_dns1 || ip_addr_isany(current_dns1)) { + ip_addr_t public_dns; + IP_ADDR4(&public_dns, 8, 8, 8, 8); // Google DNS + dns_setserver(0, &public_dns); + PPP_DEBUG_INFO("Using fallback DNS1: 8.8.8.8"); + } + + const ip_addr_t *current_dns2 = dns_getserver(1); + if (!current_dns2 || ip_addr_isany(current_dns2)) { + ip_addr_t public_dns; + IP_ADDR4(&public_dns, 8, 8, 4, 4); // Google DNS + dns_setserver(1, &public_dns); + PPP_DEBUG_INFO("Using fallback DNS2: 8.8.4.4"); + } + + if (old_local_ip != g_lwip_ctx.local_ip) { + PPP_DEBUG_CRITICAL("IP address updated - Local: %u.%u.%u.%u, Remote: %u.%u.%u.%u", + (g_lwip_ctx.local_ip >> 0) & 0xFF, + (g_lwip_ctx.local_ip >> 8) & 0xFF, + (g_lwip_ctx.local_ip >> 16) & 0xFF, + (g_lwip_ctx.local_ip >> 24) & 0xFF, + (g_lwip_ctx.remote_ip >> 0) & 0xFF, + (g_lwip_ctx.remote_ip >> 8) & 0xFF, + (g_lwip_ctx.remote_ip >> 16) & 0xFF, + (g_lwip_ctx.remote_ip >> 24) & 0xFF); + } + } +} + /* PPP协议解析辅助函数 */ static const char* ppp_get_protocol_name(uint16_t protocol) { diff --git a/code/sdk/zhihui/ppp/src/ppp_lwip_thread.c b/code/sdk/zhihui/ppp/src/ppp_lwip_thread.c index 116151e9d..a267379c4 100644 --- a/code/sdk/zhihui/ppp/src/ppp_lwip_thread.c +++ b/code/sdk/zhihui/ppp/src/ppp_lwip_thread.c @@ -16,6 +16,7 @@ /* PPP接收线程相关 - 参考slipif_init方式 */ static osal_task *g_ppp_rx_thread = NULL; static volatile bool g_ppp_rx_thread_running = false; +static volatile bool g_ppp_rx_thread_completed = false; /** * @brief PPP数据接收线程 - 参考slipif_init实现 @@ -59,70 +60,83 @@ static void ppp_lwip_receive_thread(void *arg) PPP_DEBUG_INFO("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 and entering main loop"); + PPP_DEBUG_INFO("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) { total_packets++; total_bytes += bytes_read; - PPP_DEBUG_DEBUG("PPP lwIP RX: Fragment #%u, %u bytes", total_packets, bytes_read); + PPP_DEBUG_INFO("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) { memcpy(stream_buffer + stream_pos, rx_buffer, bytes_read); stream_pos += bytes_read; - - // 处理流缓冲区中的数据,查找完整的PPP帧 - uint32_t processed = 0; - while (processed < stream_pos) { - uint8_t byte = stream_buffer[processed]; - - if (byte == 0x7E) { /* PPP帧标志 */ - if (in_frame && processed > frame_start) { - /* 找到完整帧的结束 */ - uint32_t frame_len = processed - frame_start + 1; - complete_frames++; - - PPP_DEBUG_DEBUG("PPP lwIP Complete Frame #%u: %u bytes", - complete_frames, frame_len); - - // 将完整帧传递给lwIP PPP协议栈 - ppp_error_t input_ret = ppp_lwip_input(stream_buffer + frame_start, frame_len); - if (input_ret != PPP_ERR_OK) { - PPP_DEBUG_ERROR("Failed to input PPP frame to lwIP: %d", input_ret); - } - } + } else { + PPP_DEBUG_WARN("PPP stream buffer overflow, resetting"); + stream_pos = 0; + frame_start = 0; + in_frame = false; + } + + /* 处理PPP帧 - 查找0x7E标志 */ + for (uint32_t i = frame_start; i < stream_pos; i++) { + if (stream_buffer[i] == 0x7E) { + if (in_frame && i > frame_start) { + /* 找到帧结束,处理完整的PPP帧 */ + uint32_t frame_len = i - frame_start + 1; - /* 开始新帧 */ - frame_start = processed; - in_frame = true; + PPP_DEBUG_DEBUG("PPP complete frame found: %u bytes", frame_len); + + /* 将完整帧传递给lwIP */ + ppp_lwip_input(stream_buffer + frame_start, frame_len); + complete_frames++; } - processed++; + /* 开始新帧 */ + frame_start = i; + in_frame = true; } - - // 如果有未完成的帧,将其移到缓冲区开头 - if (in_frame && frame_start > 0) { - uint32_t remaining = stream_pos - frame_start; + } + + /* 如果缓冲区使用超过一半,移动未处理的数据到缓冲区开头 */ + 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; - } else if (!in_frame) { - // 没有正在处理的帧,清空缓冲区 - stream_pos = 0; - frame_start = 0; } - } else { - PPP_DEBUG_WARN("Stream buffer overflow, resetting"); - stream_pos = 0; + stream_pos = remaining; frame_start = 0; in_frame = false; } } else if (ret != PPP_ERR_OK) { + /* 检查是否是因为线程停止导致的错误 */ + if (!g_ppp_rx_thread_running) { + PPP_DEBUG_INFO("PPP thread stopping, ignoring read error"); + break; + } PPP_DEBUG_ERROR("PPP serial read error: %d", ret); + } else { + /* 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 % 1000 == 0) { // 每1000次无数据时打印一次 + PPP_DEBUG_DEBUG("PPP RX: No data available (count: %u)", no_data_count); + } + + /* 短暂让出CPU,避免过度占用 */ + if (no_data_count % 20 == 0) { // 每20次无数据后短暂休眠 + osal_msleep(1); // 1ms休眠,让出CPU + } } // 统计信息输出 - 每2000次循环输出一次 @@ -139,7 +153,10 @@ static void ppp_lwip_receive_thread(void *arg) free(rx_buffer); free(stream_buffer); - PPP_DEBUG_INFO("PPP lwIP receive thread terminated (processed %u frames)", complete_frames); + PPP_DEBUG_INFO("PPP lwIP receive thread completed"); + g_ppp_rx_thread_completed = true; + + PPP_DEBUG_INFO("PPP lwIP receive thread exiting"); } /** @@ -149,22 +166,27 @@ ppp_error_t ppp_lwip_start_receive_thread(void) { if (g_ppp_rx_thread != NULL) { PPP_DEBUG_WARN("PPP lwIP receive thread already running"); - return PPP_ERR_OK; + return PPP_ERR_INVALID_STATE; } + PPP_DEBUG_INFO("Starting PPP lwIP receive thread"); + + // 重置线程完成标志 + g_ppp_rx_thread_completed = false; + + // 设置线程运行标志为true(在创建线程之前) g_ppp_rx_thread_running = true; - // 创建PPP数据接收线程 - 参考slipif_init方式 - // slipif使用sys_thread_new,我们使用等效的osal_kthread_create + // 创建线程 - 使用正确的OSAL API g_ppp_rx_thread = osal_kthread_create((osal_kthread_handler)ppp_lwip_receive_thread, - NULL, "ppp_lwip_rx", PPP_RX_THREAD_STACK_SIZE); + NULL, "ppp_lwip_rx", 4096); if (g_ppp_rx_thread == NULL) { PPP_DEBUG_ERROR("Failed to create PPP lwIP receive thread"); - g_ppp_rx_thread_running = false; + g_ppp_rx_thread_running = false; // 创建失败时重置标志 return PPP_ERR_MEMORY; } - PPP_DEBUG_INFO("PPP lwIP receive thread created successfully (slipif-style)"); + PPP_DEBUG_INFO("PPP lwIP receive thread started successfully"); return PPP_ERR_OK; } @@ -182,13 +204,29 @@ ppp_error_t ppp_lwip_stop_receive_thread(void) // 停止线程 g_ppp_rx_thread_running = false; - // 等待线程结束 - osal_msleep(100); + // 等待线程完成,使用completion flag进行同步 + int wait_count = 0; + const int max_wait = 100; // 最多等待1秒 + + while (wait_count < max_wait && !g_ppp_rx_thread_completed) { + osal_msleep(10); + wait_count++; + } + + if (g_ppp_rx_thread_completed) { + PPP_DEBUG_INFO("PPP thread completed gracefully after %d ms", wait_count * 10); + } else { + PPP_DEBUG_WARN("PPP thread did not complete within timeout, forcing termination"); + } // 销毁线程 osal_kthread_destroy(g_ppp_rx_thread, 0); g_ppp_rx_thread = NULL; + // 重置状态标志 + g_ppp_rx_thread_running = false; + g_ppp_rx_thread_completed = false; + PPP_DEBUG_INFO("PPP lwIP receive thread stopped"); return PPP_ERR_OK; } diff --git a/code/sdk/zhihui/ppp/src/ppp_serial.c b/code/sdk/zhihui/ppp/src/ppp_serial.c index 73b7d690f..b12f5c2c5 100644 --- a/code/sdk/zhihui/ppp/src/ppp_serial.c +++ b/code/sdk/zhihui/ppp/src/ppp_serial.c @@ -288,7 +288,8 @@ ppp_error_t ppp_serial_switch_to_ppp_mode(void) PPP_DEBUG_INFO("This approach is more reliable than callback mechanism"); g_serial_ctx.current_mode = PPP_SERIAL_MODE_PPP_DATA; - PPP_DEBUG_INFO("Mode switched to PPP_DATA (%d)", g_serial_ctx.current_mode); + PPP_DEBUG_CRITICAL("Serial mode switched to PPP_DATA (%d)", g_serial_ctx.current_mode); + PPP_DEBUG_CRITICAL("PPP data mode active - UART will use direct read with 50ms timeout (optimized)"); PPP_DEBUG_INFO("=== PPP Data Mode Switch Complete ==="); return PPP_ERR_OK; } @@ -390,14 +391,14 @@ ppp_error_t ppp_serial_write(const uint8_t *data, uint32_t length) PPP_DEBUG_INFO("Sending %u bytes via UART (PPP data mode)", length); // 打印PPP数据包内容用于调试 - PPP_DEBUG_PRINT("PPP TX Data: "); - for (uint32_t i = 0; i < length && i < 16; i++) { - PPP_DEBUG_PRINT("%02X ", data[i]); - } - if (length > 16) { - PPP_DEBUG_PRINT("... (total %u bytes)", length); - } - PPP_DEBUG_PRINT("\n"); + // PPP_DEBUG_PRINT("PPP TX Data: "); + // for (uint32_t i = 0; i < length && i < 16; i++) { + // PPP_DEBUG_PRINT("%02X ", data[i]); + // } + // if (length > 16) { + // PPP_DEBUG_PRINT("... (total %u bytes)", length); + // } + // PPP_DEBUG_PRINT("\n"); PPP_DEBUG_INFO("Calling uapi_uart_write(bus=%u, data=%p, len=%u, timeout=1000)...", g_serial_ctx.uart_bus, data, length); @@ -461,10 +462,11 @@ ppp_error_t ppp_serial_read(uint8_t *buffer, uint32_t buffer_size, uint32_t *byt break; case PPP_SERIAL_MODE_PPP_DATA: - /* PPP数据模式:使用优化的直接UART读取,增加超时时间 */ + /* PPP数据模式:使用优化的直接UART读取,减少超时时间提高响应性 */ { - /* 使用更长的超时时间来获取更完整的数据包 */ - int32_t read_result = uapi_uart_read(g_serial_ctx.uart_bus, buffer, buffer_size, 500); + /* 使用较短的超时时间来提高网络响应性 */ + // PPP_DEBUG_DEBUG("PPP mode: Attempting UART read (timeout: 50ms)"); + int32_t read_result = uapi_uart_read(g_serial_ctx.uart_bus, buffer, buffer_size, 50); if (read_result > 0) { *bytes_read = (uint32_t)read_result; g_serial_ctx.rx_bytes += *bytes_read; @@ -474,18 +476,20 @@ ppp_error_t ppp_serial_read(uint8_t *buffer, uint32_t buffer_size, uint32_t *byt for (uint32_t i = 0; i < *bytes_read && i < 16; i++) { PPP_DEBUG_PRINT("%02X ", buffer[i]); } - if (*bytes_read > 16) { - PPP_DEBUG_PRINT("... (total %u bytes)", *bytes_read); - } - PPP_DEBUG_PRINT("\n"); - } else if (read_result < 0) { - PPP_DEBUG_ERROR("UART read error in PPP mode: %d", read_result); - g_serial_ctx.rx_errors++; - result = PPP_ERR_UART; + PPP_DEBUG_PRINT("... (total %u bytes)\n", *bytes_read); + + return PPP_ERR_OK; + } else if (read_result == 0) { + /* 超时,无数据可读 */ + *bytes_read = 0; + // PPP_DEBUG_DEBUG("PPP UART Read: No data available (timeout)"); + return PPP_ERR_OK; } else { - /* read_result == 0, 超时但无错误 */ + /* UART读取错误 */ *bytes_read = 0; - result = PPP_ERR_OK; + g_serial_ctx.rx_errors++; + PPP_DEBUG_ERROR("PPP UART Read: Error %d", read_result); + return PPP_ERR_UART; } } break; @@ -761,10 +765,10 @@ ppp_serial_mode_t ppp_serial_get_mode(void) /** * @brief 获取统计信息 */ -void ppp_serial_get_stats(ppp_serial_stats_t *stats) +uint32_t ppp_serial_get_stats(ppp_serial_stats_t *stats) { if (!g_serial_ctx.initialized || !stats) { - return; + return PPP_ERR_INVALID_PARAM; } stats->tx_bytes = g_serial_ctx.tx_bytes; @@ -781,6 +785,8 @@ void ppp_serial_get_stats(ppp_serial_stats_t *stats) stats->tx_buffer_usage = g_serial_ctx.tx_count; stats->tx_buffer_size = g_serial_ctx.tx_buffer_size; osal_mutex_unlock(&g_serial_ctx.tx_mutex); + + return PPP_ERR_OK; } /* 内部函数实现 */ @@ -1035,6 +1041,48 @@ uint32_t ppp_serial_tx_available(void) return count; } +/** + * @brief 重置串口状态 + */ +ppp_error_t ppp_serial_reset(void) +{ + PPP_DEBUG_INFO("=== Serial Reset Started ==="); + + if (!g_serial_ctx.initialized) { + PPP_DEBUG_WARN("Serial not initialized"); + return PPP_ERR_INVALID_STATE; + } + + // 1. 清空所有缓冲区 + PPP_DEBUG_INFO("Clearing all buffers..."); + osal_mutex_lock(&g_serial_ctx.rx_mutex); + g_serial_ctx.rx_head = 0; + g_serial_ctx.rx_tail = 0; + g_serial_ctx.rx_count = 0; + osal_mutex_unlock(&g_serial_ctx.rx_mutex); + + osal_mutex_lock(&g_serial_ctx.tx_mutex); + g_serial_ctx.tx_head = 0; + g_serial_ctx.tx_tail = 0; + g_serial_ctx.tx_count = 0; + osal_mutex_unlock(&g_serial_ctx.tx_mutex); + + // 2. 重置统计信息 + g_serial_ctx.tx_bytes = 0; + g_serial_ctx.rx_bytes = 0; + g_serial_ctx.tx_errors = 0; + g_serial_ctx.rx_errors = 0; + + // 3. 强制设置为AT模式 + g_serial_ctx.current_mode = PPP_SERIAL_MODE_AT; + + // 4. 短暂延迟让硬件稳定 + osal_msleep(50); + + PPP_DEBUG_INFO("=== Serial Reset Completed ==="); + return PPP_ERR_OK; +} + /* * 注意:以下IRQ处理函数暂时不使用,因为UART回调机制已经包含了中断处理 * 如果需要更底层的中断控制,可以取消注释并调试IRQ冲突问题