From 43758730836ec1cd51f80697e5c477a0ed643818 Mon Sep 17 00:00:00 2001 From: wandering1 <1624155937@qq.com> Date: Mon, 24 Aug 2026 16:16:18 +0800 Subject: [PATCH] =?UTF-8?q?CH395F=20=E7=A1=AC=E4=BB=B6=E6=B5=8B=E8=AF=95?= =?UTF-8?q?=E5=AE=8C=E6=AF=95?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- AGENTS.md | 3 +- App/sys_clock.c | 68 +- App/task/net_task.c | 70 +- App/task/net_task.h | 8 +- Drivers/BSP/CH395F/ch395f.c | 6 +- Drivers/BSP/NET/net_socket.c | 58 +- MDK-ARM/build_log.txt | 82 +- Src/freertos.c | 8 +- docs/CH395F_Test_Guide.md | 630 +++++-- docs/CH395F_Trap_Records.md | 36 + .../ch395f_socket_test.cpython-311.pyc | Bin 55380 -> 65855 bytes test/ch395f_socket_test.py | 425 +++-- test/ch395f_test.h | 74 +- test/ch395f_test_task.c | 1502 ++++++++++++----- 14 files changed, 2183 insertions(+), 787 deletions(-) diff --git a/AGENTS.md b/AGENTS.md index e43cac9..19553dd 100644 --- a/AGENTS.md +++ b/AGENTS.md @@ -18,7 +18,7 @@ | USART1 | 串口 | PA9 TX, PA10 RX (115200bps) | | 6x LED | GPIO | PC4, PC5, PB1, PB2, PF11, PF12（低电平点亮） | -MCU: STM32F407ZGTx @ 168MHz (HSE 25MHz → PLL 4/168/2) +MCU: STM32F407ZGTx @ 168MHz (HSE 8MHz → PLL M=4/N=168/P=2，见 `*.ioc`/`stm32f4xx_hal_conf.h`) ## 架构 @@ -79,5 +79,6 @@ Src/main.c → 外设初始化 → app_main_init → gd5f2gq5ue_init → tpafe51 - `Inc/` 和 `Src/` 中 CubeMX 生成的文件带有 `USER CODE BEGIN`/`END` 标记，自定义代码写在这些区域之间 - `Drivers/BSP/` 下的驱动文件为纯手工代码，不受 CubeMX 保护 - CH395F 每次 SPI 事务需用 `ch395f_spi_begin()` / `ch395f_spi_end()` 包裹 +- CH395F SPI PCB设计问题，现在分频系数必须为 8，速度相对较低 - FreeRTOS V10.3.1 via CMSIS-RTOS V2，HAL 时基用 TIM7（非 SysTick） - NVIC 优先级分组 4 位，外设中断优先级 ≥ 5（`configLIBRARY_MAX_SYSCALL_INTERRUPT_PRIORITY`） diff --git a/App/sys_clock.c b/App/sys_clock.c index bfd55f0..2de4ea3 100644 --- a/App/sys_clock.c +++ b/App/sys_clock.c @@ -16,6 +16,23 @@ #define DBG_TAG "[CLK]" #include "dbg_log.h" +/* ============================================================ + * RTC 校时（开发期一次性） + * 使能 RTC_DEFAULT_INIT_ENABLE 后： + * RTC_DEFAULT_INIT_FORCE=1：每次启动都写入默认时间（首次/覆盖校时用） + * RTC_DEFAULT_INIT_FORCE=0：仅当 RTC 时间无效（越界）时写入 + * 校时完成后建议将 FORCE 置 0（或注释 ENABLE），避免每次开机覆盖用户设的时间。 + * 修改日期/时间时同步更新下列宏。 + * ============================================================ */ +#define RTC_DEFAULT_INIT_ENABLE 1 +#define RTC_DEFAULT_INIT_FORCE 1 +#define RTC_DEFAULT_YEAR 2026 +#define RTC_DEFAULT_MONTH 8 +#define RTC_DEFAULT_DAY 24 +#define RTC_DEFAULT_HOUR 0 +#define RTC_DEFAULT_MINUTE 0 +#define RTC_DEFAULT_SECOND 0 + /* ============================================================ * 内部状态：系统墙钟 * ============================================================ */ @@ -27,6 +44,20 @@ static volatile uint32_t s_base_unix_secs = UINT32_MAX; * 内部辅助函数：Unix time ↔ sd2506_time_t 转换 * ============================================================ */ +/* 计算星期（Zeller 公式，0=Sunday），与下方 unix_to_sd2506 中算法一致 */ +static uint8_t rtc_calc_week(uint16_t y, uint8_t m, uint8_t d) +{ + uint32_t wy = y; + uint32_t wm = m; + + if (wm <= 2) { + wy--; + wm += 12u; + } + return (uint8_t)(((uint32_t)(wy % 100u + wy / 100u / 4u - wy / 100u / 15u) + + (uint32_t)((26u * (wm + 1u)) / 10u) + (uint32_t)(d % 100u)) % 7u); +} + static void unix_to_sd2506(uint32_t unix_secs, sd2506_time_t *p_sd_time) { uint32_t y, m, d; @@ -105,10 +136,43 @@ int sys_clock_init(void) int64_t unix_secs = 0; int i; - /* Step 1: 从 SD2506 RTC 读取初始时间 */ + /* Step 1: 从 SD2506 RTC 读取初始时间 + * 注意：sd2506_get_time() 返回的 year 已是完整年份（如 2026，驱动内 +2000）， + * 此处不得再加 2000，否则年份虚增 → unix 秒数超 uint32 被截断回绕。 */ sd2506_get_time(&sd_time); - year = (uint32_t)sd_time.year + 2000uL; + /* RTC 校时（可选）：时间无效时，或 FORCE=1 强制时，写入编译期默认时间 */ +#if defined(RTC_DEFAULT_INIT_ENABLE) + { + int rtc_invalid = (sd_time.year < 2000 || sd_time.year > 2099 || + sd_time.month < 1 || sd_time.month > 12 || + sd_time.day < 1 || sd_time.day > 31); +#if (RTC_DEFAULT_INIT_FORCE == 1) + rtc_invalid = 1; /* 强制每次启动校时 */ +#endif + if (rtc_invalid) { + sd2506_time_t init_t; + init_t.year = RTC_DEFAULT_YEAR; + init_t.month = RTC_DEFAULT_MONTH; + init_t.day = RTC_DEFAULT_DAY; + init_t.hour = RTC_DEFAULT_HOUR; + init_t.minute = RTC_DEFAULT_MINUTE; + init_t.second = RTC_DEFAULT_SECOND; + init_t.week = rtc_calc_week(init_t.year, init_t.month, init_t.day); + + if (sd2506_set_time(&init_t) == SD2506_OK) { + DBG_INFO("sys_clock_init: RTC set %04d-%02d-%02d %02d:%02d:%02d", + init_t.year, init_t.month, init_t.day, + init_t.hour, init_t.minute, init_t.second); + sd2506_get_time(&sd_time); /* 重新读取校准后的时间 */ + } else { + DBG_ERROR("sys_clock_init: RTC default write FAIL"); + } + } + } +#endif + + year = (uint32_t)sd_time.year; month = (uint32_t)sd_time.month; day = (uint32_t)sd_time.day; hour = (uint32_t)sd_time.hour; diff --git a/App/task/net_task.c b/App/task/net_task.c index d4a6101..35b2f2e 100644 --- a/App/task/net_task.c +++ b/App/task/net_task.c @@ -25,6 +25,43 @@ /* 网络初始化完成标志（供 ch395f_test_task 等外部任务等待） */ volatile uint8_t g_net_ready = 0; +/* + * 函数功能：CH395F 协议栈一次性初始化（两种构建模式共用） + * 入口参数：无 + * 返 回 值：0 - 成功，-1 - 失败 + * 函数说明：net_init → MAC 打印 → PHY 强制 100M 全双工 → 置 g_net_ready。 + * NET 层模式由 netTask 调用；硬件层模式（阶段 1~5）netTask 不创建， + * 由 ch395fTestTask 调用后独占 CH395F。 + */ +int net_stack_bring_up(void) +{ + DBG_INFO("=== Network Init ==="); + + if (net_init("192.168.1.100", "255.255.255.0", "192.168.1.1") != 0) { + DBG_ERROR("net init: FAIL"); + return -1; + } + DBG_INFO("net init: OK"); + + uint8_t mac[6]; + ch395f_get_mac_addr(mac); + DBG_INFO("MAC: %02X:%02X:%02X:%02X:%02X:%02X", + mac[0], mac[1], mac[2], mac[3], mac[4], mac[5]); + + ch395f_set_phy(CH395F_PHY_100M_FULL); + HAL_Delay(3000); + uint8_t phy = ch395f_get_phy_status(); + DBG_INFO("PHY: %s", + (phy == CH395F_PHY_100M_FULL) ? "100M FULL" : + (phy == CH395F_PHY_100M_HALF) ? "100M HALF" : + (phy == CH395F_PHY_10M_FULL) ? "10M FULL" : + (phy == CH395F_PHY_10M_HALF) ? "10M HALF" : + (phy == CH395F_PHY_DISCONN) ? "DISCONNECT" : "UNKNOWN"); + + g_net_ready = 1; + return 0; +} + /* * 函数功能：网络任务初始化 * 入口参数：无 @@ -42,8 +79,10 @@ int net_task_init(void) * 函数功能：网络任务主函数 * 入口参数：arg - FreeRTOS 传入参数（未使用） * 返 回 值：无 - * 函数说明：启动后先调用 net_init 初始化 CH395F 协议栈，创建 TCP 监听， - * 再进入轮询循环处理网络事件 + * 函数说明：启动后先调用 net_stack_bring_up() 初始化 CH395F 协议栈， + * 再进入轮询循环处理网络事件。 + * 仅 NET 层测试模式（阶段 6~10）会创建本任务； + * 硬件层模式下 netTask 不创建，CH395F 由 ch395fTestTask 独占。 */ void net_task_func(void const *arg) { @@ -51,29 +90,10 @@ void net_task_func(void const *arg) osDelay(2000); - /* ==================== CH395F 协议栈初始化 ==================== */ - DBG_INFO("=== Network Init ==="); - - if (net_init("192.168.1.100", "255.255.255.0", "192.168.1.1") == 0) { - DBG_INFO("net init: OK"); - - uint8_t mac[6]; - ch395f_get_mac_addr(mac); - DBG_INFO("MAC: %02X:%02X:%02X:%02X:%02X:%02X", - mac[0], mac[1], mac[2], mac[3], mac[4], mac[5]); - - ch395f_set_phy(CH395F_PHY_100M_FULL); - HAL_Delay(3000); - uint8_t phy = ch395f_get_phy_status(); - DBG_INFO("PHY: %s", - (phy == CH395F_PHY_100M_FULL) ? "100M FULL" : - (phy == CH395F_PHY_100M_HALF) ? "100M HALF" : - (phy == CH395F_PHY_10M_FULL) ? "10M FULL" : - (phy == CH395F_PHY_10M_HALF) ? "10M HALF" : - (phy == CH395F_PHY_DISCONN) ? "DISCONNECT" : "UNKNOWN"); - g_net_ready = 1; - } else { - DBG_ERROR("net init: FAIL"); + if (net_stack_bring_up() != 0) { + for (;;) { + osDelay(1000); + } } DBG_INFO("netTask: started (single-socket mode)"); diff --git a/App/task/net_task.h b/App/task/net_task.h index 34df293..da32062 100644 --- a/App/task/net_task.h +++ b/App/task/net_task.h @@ -1,11 +1,12 @@ /* * 模块名称：Network Application Task - * 模块功能：网络协议栈轮询、TCP/UDP 业务处理 + * 模块功能：网络协议栈初始化、轮询、TCP/UDP 业务处理 * 适用平台：STM32F407ZGTx + CH395F * 作者：王建锋 * 创建日期：2026-07-19 * 修改记录： * v1.0 2026-07-19 王建锋 创建初始版本 + * v1.1 2026-08-24 王建锋 提取 net_stack_bring_up() 供硬件层/NET 层两种测试模式共用 */ #ifndef __NET_TASK_H @@ -15,6 +16,11 @@ extern "C" { #endif +/* CH395F 协议栈一次性初始化（net_init + MAC 打印 + PHY 配置 + g_net_ready 置位）。 + * 返回 0 成功 / -1 失败。NET 层模式由 netTask 调用；硬件层模式（阶段 1~5） + * netTask 不创建，由 ch395fTestTask 调用后独占 CH395F。 */ +int net_stack_bring_up(void); + int net_task_init(void); void net_task_func(void const *arg); diff --git a/Drivers/BSP/CH395F/ch395f.c b/Drivers/BSP/CH395F/ch395f.c index 90f3e9f..112c4b5 100644 --- a/Drivers/BSP/CH395F/ch395f.c +++ b/Drivers/BSP/CH395F/ch395f.c @@ -1222,10 +1222,11 @@ uint16_t ch395f_get_recv_len(uint8_t sock) { } /* - * 函数功能：获取全局中断状态（2字节版，支持Socket 0~7） + * 函数功能：获取并清除全局中断状态（2字节版，支持Socket 0~7） * 返回值：中断状态 uint16_t（低字节 = Socket 0~3 + PHY/DHCP， * 高字节 = Socket 4~7 + DHCPv6） * 限定条件：芯片已初始化 + * 注意事项：读取后就自动清除全局中断状态了 */ uint16_t ch395f_get_glob_int_status_all(void) { uint16_t status; @@ -1240,9 +1241,10 @@ uint16_t ch395f_get_glob_int_status_all(void) { } /* - * 函数功能：获取Socket中断状态 + * 函数功能：获取并清除 Socket 中断状态 * 入口参数：sock - Socket索引 uint8_t 0 - 7 * 返回值：Socket中断状态字节 uint8_t + * 注意事项：读取后就自动清除 Socket 中断 * 限定条件：芯片已初始化 */ uint8_t ch395f_get_sock_int_status(uint8_t sock) { diff --git a/Drivers/BSP/NET/net_socket.c b/Drivers/BSP/NET/net_socket.c index 745c922..c0e8864 100644 --- a/Drivers/BSP/NET/net_socket.c +++ b/Drivers/BSP/NET/net_socket.c @@ -195,16 +195,16 @@ int net_poll(void) { /* 诊断：每 3 秒打印一次全局中断状态和 Socket 状态。 * 注意：使用已读取的 int_status，不要再读 GINT（读即清除）。 */ - static uint32_t s_last_diag = 0; - uint32_t now_diag = HAL_GetTick(); - if ((now_diag - s_last_diag >= 3000) || s_last_diag == 0) { - s_last_diag = now_diag; - DBG_INFO("GINT=0x%04X", int_status); - for (int di = 0; di < NET_MAX_SOCKETS; di++) { - DBG_INFO(" s%d: in_use=%d state=%d", - di, s_net_socks[di].in_use, s_net_socks[di].state); - } - } +// static uint32_t s_last_diag = 0; +// uint32_t now_diag = HAL_GetTick(); +// if ((now_diag - s_last_diag >= 3000) || s_last_diag == 0) { +// s_last_diag = now_diag; +// DBG_INFO("GINT=0x%04X", int_status); +// for (int di = 0; di < NET_MAX_SOCKETS; di++) { +// DBG_INFO(" s%d: in_use=%d state=%d", +// di, s_net_socks[di].in_use, s_net_socks[di].state); +// } +// } if (int_status & CH395F_GINT_STAT_PHY_CHANGE) { uint8_t phy = ch395f_get_phy_status(); @@ -225,7 +225,7 @@ int net_poll(void) { /* 读取 Socket 中断状�?*/ uint8_t sock_int = ch395f_get_sock_int_status(i); - DBG_INFO("s%d int=0x%02X", i, sock_int); + //DBG_INFO("s%d int=0x%02X", i, sock_int); /* 连接事件 */ if (sock_int & CH395F_SINT_STAT_CONNECT) { @@ -270,24 +270,24 @@ int net_poll(void) { * 因此每次 net_poll() 调用只处理一批中断，由主循环负责读取数据。 */ } while (0); - /* 2 秒打印一次诊断信息（调试用） */ - { - static uint32_t s_last_dbg = 0; - uint32_t now = HAL_GetTick(); - if (now - s_last_dbg >= 2000) { - s_last_dbg = now; - uint8_t int_level = (HAL_GPIO_ReadPin(CH395_INT_GPIO_Port, CH395_INT_Pin) == GPIO_PIN_RESET) ? 1 : 0; - DBG_DEBUG("INT#=%d", int_level); - for (i = 0; i < NET_MAX_SOCKETS; i++) { - if (s_net_socks[i].in_use) { - uint8_t st[2]; - ch395f_get_socket_status((uint8_t)i, st); - uint16_t rl = ch395f_get_recv_len((uint8_t)i); - DBG_DEBUG(" s%d:sw%d/tcp%d rl%d", i, st[0], st[1], rl); - } - } - } - } +// /* 2 秒打印一次诊断信息（调试用） */ +// { +// static uint32_t s_last_dbg = 0; +// uint32_t now = HAL_GetTick(); +// if (now - s_last_dbg >= 2000) { +// s_last_dbg = now; +// uint8_t int_level = (HAL_GPIO_ReadPin(CH395_INT_GPIO_Port, CH395_INT_Pin) == GPIO_PIN_RESET) ? 1 : 0; +// DBG_DEBUG("INT#=%d", int_level); +// for (i = 0; i < NET_MAX_SOCKETS; i++) { +// if (s_net_socks[i].in_use) { +// uint8_t st[2]; +// ch395f_get_socket_status((uint8_t)i, st); +// uint16_t rl = ch395f_get_recv_len((uint8_t)i); +// DBG_DEBUG(" s%d:sw%d/tcp%d rl%d", i, st[0], st[1], rl); +// } +// } +// } +// } return event_count; } diff --git a/MDK-ARM/build_log.txt b/MDK-ARM/build_log.txt index a9224ba..e1d847c 100644 --- a/MDK-ARM/build_log.txt +++ b/MDK-ARM/build_log.txt @@ -3,69 +3,69 @@ Rebuild target 'STM32F407-Demo' assembling startup_stm32f407xx.s... compiling crc.c... compiling ringbuf.c... -compiling i2c.c... -compiling stm32f4xx_hal_msp.c... -compiling dma.c... -compiling spi.c... -compiling stm32f4xx_hal_timebase_tim.c... compiling stm32f4xx_hal_flash_ramfunc.c... -compiling stm32f4xx_it.c... -compiling stm32f4xx_hal_flash_ex.c... -compiling gpio.c... -compiling stm32f4xx_hal_flash.c... -compiling sys_clock.c... compiling stm32f4xx_hal_gpio.c... +compiling i2c.c... +compiling stm32f4xx_hal_timebase_tim.c... +compiling stm32f4xx_it.c... compiling app_main.c... compiling usart.c... +compiling spi.c... +compiling sys_clock.c... +compiling stm32f4xx_hal_msp.c... +compiling stm32f4xx_hal_flash_ex.c... +compiling dma.c... +compiling gpio.c... compiling stm32f4xx_hal_rcc_ex.c... +compiling stm32f4xx_hal_dma_ex.c... compiling adc_task.c... compiling rs485_task.c... compiling stm32f4xx_hal_rcc.c... -compiling net_task.c... compiling freertos.c... -compiling stm32f4xx_hal_tim_ex.c... -compiling main.c... -compiling stm32f4xx_hal_tim.c... -compiling stm32f4xx_hal_pwr.c... -compiling stm32f4xx_hal_dma_ex.c... compiling stm32f4xx_hal_dma.c... -compiling stm32f4xx_hal_pwr_ex.c... +compiling stm32f4xx_hal_tim_ex.c... +compiling stm32f4xx_hal_flash.c... +compiling net_task.c... +compiling main.c... compiling lftpd_string.c... -compiling stm32f4xx_hal_cortex.c... +compiling stm32f4xx_hal_tim.c... compiling croutine.c... -compiling stm32f4xx_hal_i2c_ex.c... -compiling stm32f4xx_hal.c... compiling list.c... compiling event_groups.c... -compiling system_stm32f4xx.c... -compiling stm32f4xx_hal_exti.c... -compiling queue.c... -compiling sd2506.c... compiling stream_buffer.c... -compiling rs485.c... -compiling tpafe5160.c... +compiling queue.c... compiling timers.c... -compiling stm32f4xx_hal_spi.c... -compiling ch395f.c... -compiling gd5f2gq5ue.c... compiling tasks.c... -compiling nand_ftl.c... -compiling lftpd_io.c... -compiling stm32f4xx_hal_uart.c... compiling heap_4.c... -compiling net_select.c... -compiling lftpd_inet.c... -compiling lftpd.c... -compiling map.c... -compiling net_socket.c... compiling port.c... compiling journal.c... -compiling stm32f4xx_hal_i2c.c... +compiling map.c... compiling ff.c... -compiling ch395f_test_task.c... +compiling stm32f4xx_hal.c... +compiling system_stm32f4xx.c... +compiling stm32f4xx_hal_pwr_ex.c... +compiling stm32f4xx_hal_exti.c... +compiling stm32f4xx_hal_i2c_ex.c... +compiling stm32f4xx_hal_pwr.c... +compiling stm32f4xx_hal_cortex.c... compiling cmsis_os2.c... +compiling ch395f.c... +compiling tpafe5160.c... +compiling rs485.c... +compiling stm32f4xx_hal_spi.c... +compiling lftpd_io.c... +compiling gd5f2gq5ue.c... +compiling sd2506.c... +compiling lftpd_inet.c... +compiling nand_ftl.c... +compiling stm32f4xx_hal_uart.c... +compiling net_select.c... +compiling lftpd.c... +compiling net_socket.c... +compiling stm32f4xx_hal_i2c.c... +compiling ch395f_test_task.c... linking... -Program Size: Code=63268 RO-data=3840 RW-data=408 ZI-data=58552 +Program Size: Code=52688 RO-data=1804 RW-data=232 ZI-data=69768 FromELF: creating hex file... ".\STM32F407-Demo\STM32F407-Demo.axf" - 0 Error(s), 0 Warning(s). -Build Time Elapsed: 00:00:18 +Build Time Elapsed: 00:00:19 diff --git a/Src/freertos.c b/Src/freertos.c index 59c0f34..31b4054 100644 --- a/Src/freertos.c +++ b/Src/freertos.c @@ -35,6 +35,7 @@ #include "gd5f2gq5ue.h" #include "lftpd.h" #include "../test/ch395f_test_task.h" +#include "../test/ch395f_test.h" /* ENABLE_NET_LAYER_TESTS：netTask 条件创建 */ /* USER CODE END Includes */ /* Private typedef -----------------------------------------------------------*/ @@ -161,7 +162,7 @@ void MX_FREERTOS_Init(void) { defaultTaskHandle = osThreadNew(StartDefaultTask, NULL, &defaultTask_attributes); /* creation of netTask */ - netTaskHandle = osThreadNew(StartNetTask, NULL, &netTask_attributes); + //netTaskHandle = osThreadNew(StartNetTask, NULL, &netTask_attributes); /* creation of ftpTask */ //ftpTaskHandle = osThreadNew(StartFtpTask, NULL, &ftpTask_attributes); @@ -170,7 +171,10 @@ void MX_FREERTOS_Init(void) { ch395fTestTaskHandle = osThreadNew(StartCh395fTestTask, NULL, &ch395fTestTask_attributes); /* USER CODE BEGIN RTOS_THREADS */ - /* add threads, ... */ +#ifdef ENABLE_NET_LAYER_TESTS + /* NET 层测试模式（阶段 6~10）：完整网络栈，netTask 负责轮询与消息处理 */ + netTaskHandle = osThreadNew(StartNetTask, NULL, &netTask_attributes); +#endif /* USER CODE END RTOS_THREADS */ /* USER CODE BEGIN RTOS_EVENTS */ diff --git a/docs/CH395F_Test_Guide.md b/docs/CH395F_Test_Guide.md index 1866671..eb965ea 100644 --- a/docs/CH395F_Test_Guide.md +++ b/docs/CH395F_Test_Guide.md @@ -12,7 +12,6 @@ | DP-02 | 中断集中处理：所有 CH395F 中断在 `net_poll()` 中通过 `GET_GLOB_INT_STATUS` 统一读取并清除，ISR 及其他位置不处理 | TC-NET-101 | | DP-03 | 线程安全：所有 CH395F 操作通过 `netMsgQueue` 在 netTask 串行处理 | TC-NET-301~302 | | DP-04 | DMA 边界安全：`CH395F_SPI_DMA_BUF_SIZE=4100`，单次事务最大载荷 `4096B`，超限自动分块 | TC-NET-801~805 | -| DP-05 | PHY 链路恢复：PHY 断连/重连后 socket 自动恢复至 LISTEN | TC-NET-901~902 | ### CH395F 缓冲架构（关键参数） @@ -61,9 +60,38 @@ PC (192.168.1.2) ──── 交换机 ──── CH395F (192.168.1.100) MCU: STM32F407ZGTx @ 168MHz, Keil MDK-ARM v5 (ARMCC) ``` +### 构建模式与执行顺序 + +测试固件通过条件编译分为**两种互斥形态**（`test/ch395f_test.h` 中同时启用两层会触发 `#error`）： + +| 构建模式 | 启用宏 | 固件形态 | +|----------|--------|----------| +| **硬件层模式** | `ENABLE_PHASE1~5_TESTS` | **netTask 不创建**，CH395F 协议栈初始化由 ch395fTestTask 完成后独占芯片执行阶段 1~5（裸调 `ch395f_*` 命令） | +| **NET 层模式** | `ENABLE_PHASE6~10_TESTS` | 完整网络栈：netTask 运行 `net_poll()` 轮询，testTask 经 `net_socket` API 在 TCP 监听循环中执行阶段 6~10 | + +**执行顺序严格递增**：先烧录硬件层固件完成阶段 1→2→3→4→5（全部通过），再切换为 NET 层固件执行阶段 6→…→10。硬件层测试期间 netTask 轮询不存在，从根上排除中断偷取与 SPI 并发问题。 + +### 阶段编号对照（2026-08 重排） + +| 新阶段 | 内容 | 旧阶段 | 层 | +|--------|------|--------|-----| +| 阶段 1 | 寄存器/SPI 命令验证 | 阶段 1 | 硬件层 | +| 阶段 2 | TCP Client 收发/重连 | 阶段 2 | 硬件层 | +| 阶段 3 | UDP Server 回显 | 阶段 3 | 硬件层 | +| 阶段 4 | DHCP | 阶段 6 | 硬件层 | +| 阶段 5 | 大文件传输（硬件层） | 新增（替代原 PHY 测试） | 硬件层 | +| 阶段 6 | NET 层 TCP（Echo + Client 扩展） | 阶段 4 | NET 层 | +| 阶段 7 | 大文件传输 | 阶段 5 | NET 层 | +| 阶段 8 | Select/Poll | 阶段 7 | NET 层 | +| 阶段 9 | 边界条件 | 阶段 8 | NET 层 | +| 阶段 10 | KeepAlive | 阶段 10 | NET 层 | + +> TC 用例 ID（TC-NET-xxx）保持不变，仅阶段号/TM-PHY 重排；历史记录按上表追溯。 +> 原阶段 2 内嵌的 NET 层部分（TC-NET-204/205/206）已并入**阶段 6**「Client 模式扩展」——硬件层阶段（1~5）不再包含任何 BSD Socket API 用例。 + ### 启用测试 -编辑 `test/ch395f_test.h`，取消注释对应 `ENABLE_PHASEx_TESTS` 宏。 +编辑 `test/ch395f_test.h`，取消注释对应 `ENABLE_PHASEx_TESTS` 宏（同一模式内 Phase 6/7/8/9 可共存于 testTask 循环）。 --- @@ -95,7 +123,7 @@ MCU: STM32F407ZGTx @ 168MHz, Keil MDK-ARM v5 (ARMCC) | 3 | `ch395f_set_ip_addr(192.168.1.100)` → `ch395f_get_ip_inf()` 回读 IP | `ip_info[0..3] == 192.168.1.100` | 任意字节不匹配（写入/回读不一致） | | 4 | `ch395f_set_gwip_addr(192.168.1.1)` → `ch395f_get_ip_inf()` 回读 GW | `ip_info[4..7] == 192.168.1.1` | 任意字节不匹配 | | 5 | `ch395f_set_mask_addr(255.255.255.0)` → `ch395f_get_ip_inf()` 回读 MASK | `ip_info[8..11] == 255.255.255.0` | 任意字节不匹配 | -| 6 | `ch395f_get_glob_int_status_all()`（16 位） | 返回值 == `0x0000`（无待处理中断） | 返回值 ≠ `0x0000`（有残留中断未清除） | +| 6 | `ch395f_get_glob_int_status_all()`（16 位）
注：测试入口处已预读一次清除 `PHY_CHANGE` 残留（`net_stack_bring_up()` 强制 PHY 重协商 + 等待链路期间锁存，硬件层模式无 netTask 消费） | 返回值 == `0x0000`（无待处理中断） | 返回值 ≠ `0x0000`（有残留中断未清除） | | 7 | `ch395f_open_socket(0)` → `ch395f_close_socket(0)` → `ch395f_get_cmd_status()` | `CMD_STATUS == 0x00`（`CH395F_ERR_SUCCESS`） | `CMD_STATUS` 非 `0x00`（Socket 操作失败） | | 8 | `ch395f_set_arp(10, 5)` → `ch395f_get_cmd_status()` | `CMD_STATUS == 0x00` | `CMD_STATUS` 非 `0x00` | | 9 | `ch395f_set_ttl(0, 64)` → `ch395f_get_cmd_status()` | `CMD_STATUS == 0x00` | `CMD_STATUS` 非 `0x00` | @@ -115,101 +143,389 @@ MCU: STM32F407ZGTx @ 168MHz, Keil MDK-ARM v5 (ARMCC) | **入口** | `ch395fTestTask` 启动后自动运行 | | **出口** | 串口 "Phase 2 Tests Complete" 且 0 失败 | -### TC-NET-201: TCP Client 连接与数据交换 +**分层说明**：本阶段属于**硬件层模式**（netTask 不创建，CH395F 由 ch395fTestTask 独占），仅使用 `ch395f_*` 裸命令验证芯片 TCP Client 行为：TCP 状态机、`CH395F_SINT_STAT_CONNECT` / `CH395F_SINT_STAT_SOCK_TIMEOUT` 中断、发送/接收缓冲与 `CH395F_SOCKET_CLOSED` 状态流转。 + +--- + +### TC-NET-201（硬件层）: TCP Client 连接与数据交换 | 字段 | 值 | |------|-----| | **ID** | TC-NET-201 | | **优先级** | P0 | -| **类型** | 功能测试 | -| **标题** | CH395F TCP Client → PC TCP Server，64 字节收发 | -| **前置条件** | PC: `python ch395f_socket_test.py tcp_server --port 8081` | +| **类型** | 功能测试（硬件层） | +| **标题** | ch395f TCP Client → PC TCP Server，64 字节收发 | +| **前置条件** | PC: `python test/ch395f_socket_test.py tcp_server --port 8081`（PC 作 TCP 回显服务器，收到数据原样回显） | **测试步骤与判定标准**： | 步 | 操作 | 成功标准 | 失败标准 | |----|------|----------|----------| -| 1 | CH395F open Socket 0 → 配置 TCP 协议 | `ch395f_open_socket(0)` 返回 `CH395F_ERR_SUCCESS`（`0x00`） | 返回值非 `0x00`（Socket 硬件异常或 SPI 通信失败） | -| 2 | 设置目标 IP 为 PC 地址（`192.168.1.2`），端口 `8081` → 发起 TCP 连接 | `ch395f_tcp_connect(0)` 返回 `CH395F_ERR_SUCCESS`（`0x00`） | 返回值非 `0x00`（连接超时、目标不可达或协议配置错误） | -| 3 | 发送 64 字节递增模式数据（`0x00, 0x01, ..., 0x3F`） | `net_send()` 返回值 == `64`（全部发出） | 返回值 < `0`（发送失败）或返回值 ≠ `64`（未完全发出） | -| 4 | 阻塞等待接收回显，超时 5 秒 | `net_recv()` 返回值 == `64`（收到全部回显） | 返回值 < `0`（超时/断开）或返回值 ≠ `64`（数据不完整） | -| 5 | 逐字节比较收发数据 | 所有 64 字节完全一致 | 任意字节不一致（回显错误或数据错位） | +| 1 | `ch395f_set_proto_type(0, CH395F_PROTO_TYPE_TCP)` + 设置目标 IP `192.168.1.2`、端口 `8081`、本地端口 `50000` | 配置写入成功（CMD_STATUS == `0x00`） | 配置失败（SPI 异常或寄存器未更新） | +| 2 | `ch395f_open_socket(0)` 打开 Socket 0 | 返回 `CH395F_ERR_SUCCESS`（`0x00`） | 返回值非 `0x00`（Socket 硬件异常或 SPI 通信失败） | +| 3 | `ch395f_tcp_connect(0)` 发起 TCP 连接 | 返回 `CH395F_ERR_SUCCESS`（`0x00`） | 返回值非 `0x00`（连接命令下发失败） | +| 4 | 轮询 `GET_GLOB_INT_STATUS` 的 `(sock+4)` 位 + `SINT_STAT` 等待 `CH395F_SINT_STAT_CONNECT`，超时 10s | 检测到 CONNECT 中断（连接已建立，进入 ESTABLISHED） | 超时未建立连接（目标不可达 / 链路异常） | +| 5 | `ch395f_write_send_buf(0, buf, 64)` 发送 64 字节递增模式数据（`0x00..0x3F`） | 发送完成且产生 `SENDBUF_FREE` 中断 | 发送缓冲未释放 / 发送失败 | +| 6 | 轮询 `GET_RECV_LEN` > 0 读取 PC 回显，超时 10s（PC 端 tcp_server 收到数据后原样回显） | 收到 64 字节且与原数据逐字节一致 | 回显超时或任意字节不符 | +| 7 | `ch395f_close_socket(0)` 并轮询 `GET_SOCKET_STATUS` 等待 `CH395F_SOCKET_CLOSED` | Socket 回到 CLOSED（`0x00`）状态 | 5s 内未回到 CLOSED（状态机卡死） | -**通过标准**：5/5 通过，0 失败。任一失败 → 阶段标记 FAIL，后续阶段不执行 +**通过标准**：7/7 通过，0 失败。任一失败 → 阶段标记 FAIL，后续阶段不执行 -### TC-NET-202: TCP Client 关闭重连 ×3 轮 +**覆盖原则**：DP-01（open→connect→send→recv→close 主路径，硬件层） + +--- + +### TC-NET-202（硬件层）: TCP Client 关闭重连 ×3 轮 | 字段 | 值 | |------|-----| | **ID** | TC-NET-202 | | **优先级** | P0 | -| **类型** | 功能测试 / 恢复测试 | +| **类型** | 功能测试 / 恢复测试（硬件层） | | **标题** | 关闭→重连循环 3 轮，每轮含数据交换 | -| **测试步骤** | 每轮：关 Socket 0 → 重开 → 重连 → 发 64B → 验证回显 | -| **通过标准** | 3/3 轮通过 | -| **覆盖原则** | DP-01（open→connect→close→re-open→reconnect） | +| **前置条件** | 1. PC 运行 `python ch395f_socket_test.py tcp_server --port 8081`（TCP 回显服务器）
2. TC-NET-201 通过（Socket 0 硬件正常） | -### TC-NET-203: TCP Client 连接超时 +**测试步骤与判定标准**（每轮 i = 0,1,2，本地端口取 `50000 + i` 规避 TIME_WAIT）： + +| 步 | 操作 | 成功标准 | 失败标准 | +|----|------|----------|----------| +| 1 | `ch395f_open_socket(0)` 打开 Socket 0 | 返回 `CH395F_ERR_SUCCESS`（`0x00`） | 返回值非 `0x00`（Socket 硬件异常或 SPI 通信失败） | +| 2 | `ch395f_tcp_connect(0)` 发起 TCP 连接 | 返回 `CH395F_ERR_SUCCESS`（`0x00`） | 返回值非 `0x00`（连接命令下发失败） | +| 3 | 轮询 `GET_GLOB_INT_STATUS` 的 `(sock+4)` 位，并读取 `SINT_STAT` 等待 `CH395F_SINT_STAT_CONNECT`，超时 10s | 检测到 CONNECT 中断（连接已建立） | 超时未建立连接（对端/链路异常） | +| 4 | `ch395f_write_send_buf(0, buf, 64)` 发送 64 字节递增模式数据（`0x00..0x3F`） | 发送完成且产生 `SENDBUF_FREE` 中断 | 发送缓冲未释放 / 发送失败 | +| 5 | 轮询 `GET_RECV_LEN` > 0 读取 PC 回显，超时 10s（PC 端 tcp_server 收到数据后原样回显） | 收到 64 字节且与原数据逐字节一致 | 回显超时或任意字节不符 | +| 6 | `ch395f_close_socket(0)` 并轮询 `GET_SOCKET_STATUS` 等待 `CH395F_SOCKET_CLOSED` | Socket 回到 CLOSED（`0x00`）状态 | 5s 内未回到 CLOSED（状态机卡死） | + +**通过标准**：3/3 轮全部 6 步通过，0 失败。任一失败 → 阶段标记 FAIL，后续不执行 + +**覆盖原则**：DP-01（open→connect→close→re-open→reconnect，硬件层） + +--- + +### TC-NET-203（硬件层）: TCP Client 连接超时 | 字段 | 值 | |------|-----| | **ID** | TC-NET-203 | | **优先级** | P1 | -| **类型** | 负向测试 | +| **类型** | 负向测试（硬件层） | | **标题** | 目标端口无服务时连接超时 | -| **前置条件** | PC 未运行 TCP Server | -| **测试步骤** | 1. 开 Socket 0 → 尝试连接 192.168.1.2:8081
2. 等待 TIMEOUT
3. 关 Socket 0 | -| **通过标准** | TIMEOUT 检测到，无崩溃 | -| **覆盖原则** | DP-01 | +| **前置条件** | 1. PC **未**运行 TCP Server（`192.168.1.2:8081` 无监听）
2. TC-NET-201 通过 | + +**测试步骤与判定标准**： + +| 步 | 操作 | 成功标准 | 失败标准 | +|----|------|----------|----------| +| 1 | `ch395f_set_proto_type(0, CH395F_PROTO_TYPE_TCP)` + 设置目标 IP `192.168.1.2`、端口 `8081` | 配置写入成功（CMD_STATUS == `0x00`） | 配置失败（SPI 异常或寄存器未更新） | +| 2 | `ch395f_open_socket(0)` → `ch395f_tcp_connect(0)` | OPEN / CONNECT 均返回 `CH395F_ERR_SUCCESS`（`0x00`），命令异步下发不立即报错 | 命令返回值非 `0x00`（Socket 硬件异常） | +| 3 | 轮询 `GET_GLOB_INT_STATUS` 的 `(sock+4)` 位，等待负向结果，超时窗 30s；同时扫全局 `UNREACH` 位作备注 | 收到 `SOCK_TIMEOUT` 或 `DISCONNECT`，且期间未收到 `CH395F_SINT_STAT_CONNECT`。按耗时细分：
**<3s** = RST 快速拒绝（端口关闭，实测主路径——芯片毫秒级上报 SOCK_TIMEOUT）
**≥3s** = 真无应答（离线/防火墙丢包）。全局 `UNREACH`（ARP 失败）仅备注不影响判定 | 误收到 `CONNECT`（PC 服务未关闭，环境错误——串口给出明确指引）或 30s 内无任何中断（状态机挂死） | +| 4 | `ch395f_close_socket(0)` 并轮询 `GET_SOCKET_STATUS` 等待 `CH395F_SOCKET_CLOSED` | Socket 正常关闭、系统无崩溃 / 死锁 | 关闭异常或任务挂死 | + +**通过标准**：检测到 `SOCK_TIMEOUT` / `DISCONNECT` 且系统稳定，0 崩溃。任一异常 → 阶段标记 FAIL + +**覆盖原则**：DP-01（异常路径的 connect 失败处理，硬件层） --- -## 4. 阶段 3：UDP Server 回显 +## 4. 阶段 3：UDP Server Echo（CH395F 作为 UDP Server） | 阶段 ID | TM-PHY-03 | |---------|-----------| | **类型** | 需 PC 配合 | -| **耗时** | ~30 秒 | -| **入口** | `ch395fTestTask` 启动后自动运行 | +| **耗时** | ~60 秒 | +| **入口** | `ENABLE_PHASE3_TESTS`，ch395fTestTask 启动后自动运行 | | **出口** | 串口 "Phase 3 Tests Complete" 且 0 失败 | -### TC-NET-301: UDP 回显 — HELLO + PING + 大包 ×30 +**分层说明**：本阶段属于**硬件层模式**（netTask 不创建），仅用 `ch395f_*` 裸命令验证芯片 UDP 能力：UDP Socket 打开、数据报接收、**包头源地址解析**与按源地址动态回显。 + +> CH395F UDP 接收帧格式（`ch395f_read_recv_buf` 返回）：[0-1] 保留｜[2-3] 源端口（大端）｜[4-7] 源 IP｜[8+] 载荷。回显前须以此源地址重设目标，且每次发送后等 `SENDBUF_FREE` 确认（Trap 04）。 + +--- + +### TC-NET-301（硬件层）: UDP 基础回显 | 字段 | 值 | |------|-----| | **ID** | TC-NET-301 | | **优先级** | P0 | -| **类型** | 功能测试 | -| **标题** | UDP Server 接收并回显 30 轮（含 HELLO、PING、1024B 大包） | -| **前置条件** | PC: `python ch395f_socket_test.py udp_client --ip 192.168.1.100 --port 60000` | -| **测试步骤** | 1. PC 发 HELLO → MCU 回显
2. PC 发 5×PING → MCU 回显
3. PC 发 10×1024B → MCU 回显
4. PC 发 14×混合大小 → MCU 回显 | -| **通过标准** | 30/30 回显匹配 100% | -| **覆盖原则** | DP-03 | +| **类型** | 功能测试（硬件层） | +| **标题** | 30 轮 64B UDP 数据报回显 | +| **前置条件** | PC: `python test/ch395f_socket_test.py udp_client --ip 192.168.1.100 --port 60000` | -### TC-NET-302: SENDBUF_FREE 等待合规 +> **会话结构**（固件单会话，与 udp_client 脚本约定）：累计 **60 个有效数据包**后关闭 Socket——第 1~30 轮对应本用例（PC 发 64B），第 31~60 轮对应 TC-302（变长）；脚本 `"HELLO"` 就绪探针只回显、**不计数**，不占用用例预算。 + +**测试步骤与判定标准**： + +| 步 | 操作 | 成功标准 | 失败标准 | +|----|------|----------|----------| +| 1 | 配置 Socket 0：proto=UDP、`sour_port=60000`、des=广播 `255.255.255.255:0`，后 `open_socket(0)` | OPEN 返回 `0x00` | 返回非 `0x00`（Socket/SPI 异常） | +| 2 | 轮询 `GET_RECV_LEN`，`rlen > 8` 时读收并解析包头源端口/源 IP，单轮超时 30s | 收到 PC 数据报且解析合法 | 30s 无数据（链路/环境异常） | +| 3 | 以源地址重设目标 → `write_send_buf` 回显载荷 → 等 `SENBUF_FREE`（超时 2s） | 发送缓冲释放，进入下一轮 | 发送缓冲超时 | +| 4 | 重复至第 30 个有效包后 `close_socket(0)`（串口按 `UDP echo #N` 连续递增） | 前 30 轮全部 PASS | 任意轮回显超时/解析错误（提前终止） | + +**通过标准**：30/30 轮回显成功，0 失败。任一失败 → 阶段标记 FAIL + +**覆盖原则**：DP-03（UDP 收发路径，包头源地址解析） + +--- + +### TC-NET-302（硬件层）: UDP 合规测试（变长载荷） | 字段 | 值 | |------|-----| | **ID** | TC-NET-302 | | **优先级** | P1 | -| **类型** | 合规测试 | -| **标题** | 每次 `write_send_buf` 后等待 `SENDBUF_FREE` | -| **前置条件** | TC-NET-301 运行中 | -| **测试步骤** | PC 连续发小包（<100ms 间隔） | -| **通过标准** | 30/30 成功，无丢包 | -| **覆盖原则** | DP-03 | +| **类型** | 合规测试（硬件层） | +| **标题** | 变长载荷（1B / 64B / 200B）各 10 轮回显，验证 `rlen-8` 解析与载荷完整性 | +| **前置条件** | 同 TC-NET-301（同一固件会话的第 31~60 轮）；载荷上限受 `rx_buf[300]` 约束（≤292B） | + +**测试步骤**：同 TC-NET-301 流程；PC 端 udp_client Phase C 按 1B→64B→200B 各 `--count` 轮（默认 10）循环发送，MCU 回显后由 PC 逐字节比对一致性。 + +**通过标准**：30/30 轮回显成功且 PC 端比对无误，0 失败。任一失败 → 阶段标记 FAIL + +**覆盖原则**：DP-03（变长载荷边界） --- -## 5. 阶段 4：NET 层 TCP Echo（单连接基础） +## 5. 阶段 4：DHCP 动态获取 IP | 阶段 ID | TM-PHY-04 | |---------|-----------| +| **类型** | PC 配合（脚本绑定 UDP/67，Windows 需**管理员权限**） | +| **耗时** | ~10s（上限 30s DISCOVER 轮询 + 30s HELLO 等待） | +| **入口** | `ENABLE_PHASE4_TESTS`，ch395fTestTask 启动后自动运行 | +| **出口** | 串口 "Phase 4: N/N PASSED (failed=0)" | +| **注意** | **改变 CH395F IP 配置**，必须独立运行（勿与其他阶段连跑） | + +### 机制与会话结构 + +**DHCP 报文流**（PC = DHCP Server，CH395F = Client）： + +``` +CH395F PC (dhcp_server) + | DISCOVER (xid, chaddr) ---------> | data[242]==1 + | <-------- OFFER (yiaddr=分配IP) | xid/chaddr 原样回填，双广播发送 + | REQUEST (server_id 校验) ------> | data[242]==3 + | <-------- ACK (掩码/网关/租约) | data[242]==5 + 应用 IP -> Socket6 广播宣告 -> HELLO 回显 +``` + +**关键实现约束**： + +- **xid/chaddr 回填**：OFFER/ACK 必须原样回传 DISCOVER 的 `xid([4:8])` 与 `chaddr([28:34])`（Trap 03：早期 xid 偏移错误导致芯片丢弃响应） +- **option53 位置**：报文类型在 `data[242]`（236B 固定头 + magic `63825363` + option 偏移），`len<=250` 视为无效包 +- **双广播发送**：OFFER/ACK 同时发 `255.255.255.255` 与 `192.168.1.255`（规避 Windows 定向广播路由限制） +- **REQUEST 重试**：PC 最多等 8×5s；期间收到重复 DISCOVER 则重发 OFFER + +**固件会话结构**（phase4_run）： + +| 序 | 操作 | 参数 | +|----|------|------| +| 1 | `ch395f_set_dhcp(1)` 启动协商 | - | +| 2 | 轮询 `GET_DHCP_STATUS == 0x00` | 超时 30s，间隔 500ms（循环中同步读清 GINT_ALL） | +| 3 | `GET_IP_INF` 轮询至连续 3 次一致（间隔 300ms，上限 8s）后打印 | 连续一致且非 `0.0.0.0`（见风险 #4） | +| 4 | Socket 6（UDP，本地 :60000，send/recv buf 各 512B）向 `255.255.255.255:60001` 广播 4B 本机 IP 宣告 | SENBUF_FREE 等待 2s | +| 5 | 同 Socket 收 PC `"HELLO"`(5B)，按包头源地址回显一次后关闭 | 窗口 30s（`PHASE4_HELLO_WAIT_MS`） | + +--- + +### TC-NET-601（硬件层）: DHCP 完整握手 + +| 字段 | 值 | +|------|-----| +| **ID** | TC-NET-601 | +| **优先级** | P0 | +| **类型** | 功能测试（硬件层） | +| **标题** | DISCOVER → OFFER → REQUEST → ACK 全流程获取 IP | +| **前置条件** | 管理员 PowerShell: `python test/ch395f_socket_test.py dhcp_server --ip 192.168.1.77 --dhcp-iface 192.168.1.2`（`--ip` 建议 ≠ 静态 IP，以证明确为动态获取） | + +**测试步骤与判定标准**： + +| 步 | 操作 | 成功标准 | 失败标准 | +|----|------|----------|----------| +| 1 | PC 先启动 dhcp_server；复位 MCU（ENABLE_PHASE4_TESTS） | PC 打印 "等待 CH395F DISCOVER" | 60s 无 DISCOVER（链路/SPI 异常） | +| 2 | CH395F 发 DISCOVER → PC 回 OFFER | PC: "收到 DISCOVER (xid=..)" + "发送 OFFER" | msg_type ≠ 1 或 len ≤ 250 | +| 3 | CH395F 发 REQUEST → PC 回 ACK | PC: "收到 REQUEST" + "发送 ACK → {offer_ip}" | 8×5s 内无 REQUEST（仅重发 OFFER） | +| 4 | 芯片应用配置，串口回读 IP | "DHCP completed within 30s" PASS 且 IP == {offer_ip} | 状态轮询超时或 IP = 0.0.0.0 | + +**通过标准**：步 2~4 全部满足，串口 IP 与 PC 分配一致。任一失败 → 阶段标记 FAIL + +**覆盖原则**：DP-03（DHCP 自动配置路径） + +--- + +### TC-NET-602（硬件层）: DHCP 后连通性验证（宣告 + HELLO 回显） + +| 字段 | 值 | +|------|-----| +| **ID** | TC-NET-602 | +| **优先级** | P1 | +| **类型** | 功能测试（硬件层） | +| **标题** | 获取 IP 后广播宣告 + 按 UDP 包头源地址回显 HELLO | +| **前置条件** | TC-NET-601 通过；同一脚本会话内自动衔接 | + +**测试步骤与判定标准**： + +| 步 | 操作 | 成功标准 | 失败标准 | +|----|------|----------|----------| +| 1 | Socket 6 广播 4B IP 宣告 → :60001 | 串口 "DHCP announcement sent"；PC 打印 "收到 IP 宣告: {offer_ip}" | OPEN 失败 / SENBUF_FREE 2s 超时 | +| 2 | PC 发 `"HELLO"` → {offer_ip}:60000（最多 5 次，每次等 2s） | 串口 "HELLO echo OK" | 30s 窗口内无有效 HELLO | +| 3 | 芯片按包头源地址回显 HELLO，关闭 Socket 6 | PC: "连通性验证通过" | PC 5 轮 retry 全超时 | + +**通过标准**：步 1~3 全部满足（HELLO 至少 1 次完整往返；固件设计为单次回显后关闭）。任一失败 → 阶段标记 FAIL + +**覆盖原则**：DP-03（动态 IP 下的端到端 UDP 通路） + +--- + +## 6. 阶段 5：大文件传输（硬件层） + +| 阶段 ID | TM-PHY-05 | +|---------|-----------| +| **类型** | PC 配合（`tcp_bulk`：先收 256KB 不回声 → 再按 LCG 回放 256KB） | +| **耗时** | ~20 秒（256KB 顺序双向：TX 256KB + RX 256KB，视链路/SPI 吞吐） | +| **入口** | `ENABLE_PHASE5_TESTS`，ch395fTestTask 启动后自动运行 | +| **出口** | 串口 "Phase 5: N/N PASSED (failed=0)" + 吞吐统计 | +| **注意** | 与 NET 层阶段 7 同主题不同层：本阶段用 `ch395f_*` 裸命令直驱芯片，不经 net_socket/netTask | + +> 编号说明：TC-NET-**511/512** 取 5xx"文件传输族"顺延（501/502 已属 NET 层阶段 7）；原阶段 5 的 TC-NET-901/902 因板载拓扑不可测已整体删除（见风险表 #1）。 + +### 为什么 4KB 接收缓冲不会丢数据（TCP 流控原理） + +PC 一次回放 256KB，而 CH395F socket 接收缓冲默认仅 4KB——不丢数据的保证**不靠缓冲够大，靠 TCP 流控（通告窗口）**。 + +数据不是全部驻留芯片，而是在一串缓冲区里"接力"： + +``` +PC OS 发送缓冲(64~256KB) → 网络在途 → CH395F 接收缓冲(4KB) → MCU 读取 +``` + +CH395F 是完整 TCP 栈 offload 芯片，内部实现 TCP 状态机，按**接收缓冲剩余空间**向 PC 通告接收窗口（advertised window）： + +1. PC 发数据，芯片收进自己的 4KB 接收环形缓冲； +2. 缓冲快满 → 通告窗口收缩直至 **窗口=0** → PC 的 `sendall` **阻塞**（TCP 背压），剩余数据停在 PC 自身 OS 发送缓冲，不再发出； +3. MCU `GET_RECV_LEN` → `READ_RECV_BUF` 读走 → 缓冲腾空 → 芯片重新通告窗口 → PC 恢复发送。 + +因此是**背压联动、自节流**：数据永不因芯片缓冲溢出被丢弃，只会"堵一会儿"。MCU 平均读取速率 ≥ PC 发送速率即可持续吞吐（本测试每 2ms 轮询、每次读 4KB，平均速率远高于发送速率，缓冲常年接近空）。 + +"先查长度再读"（`GET_RECV_LEN` → `READ_RECV_BUF`）安全的原因：查询返回"当前未读字节数"，流控保证其必然 ≤ 缓冲容量；查询与读取之间新到的数据进入环形缓冲尾部，由芯片读写指针管理，**不会覆盖未读数据**，留待下一次迭代读取。 + +会真正丢数据的只有两种情况：**MCU 复位 / TCP 连接断开**（连接级丢失，属预期失败）、**软件 bug**（读错长度/越界导致错位）。正常流控下接收缓冲本身不会溢出。 + +--- + +### 机制与会话结构 + +**顺序双测向协议**（TX 与 RX 单向隔离，独立测吞吐/完整性）： + +``` +MCU (TCP Client, ch395f_* 裸命令) PC (tcp_bulk --port 8081) + | open/connect -> CONNECT accept + |== 步2A: 连续发送 256KB (单向, 不等回显) ===| + | 写 4KB -> 等 SENBUF_FREE(2s) -> 下一块 | + |------------------------------------------>| recv 收满 256KB (不回声, LCG 校验) + |== 步2B: 连续接收 256KB ===================| + |<------------------------------------------| sendall 按 LCG 回放 256KB + | get_recv_len -> 滚动校验 (exp[] 按块生成) | + |===========================================| + close -> PC 侧 "阶段A 收满...校验一致" + "阶段B 回放完成" +``` + +**要点**： + +- **为什么顺序双测向**：单向隔离，分别测得**纯 TX / 纯 RX** 吞吐与完整性——不被"回声耦合"掩盖各自链路的真实能力 +- **TX 节奏**：写 4096B → 等 `SENBUF_FREE`（芯片把 socket 缓冲数据搬入内部协议栈/MAC 缓冲后触发）→ 写下一块，全程不等回显；单向发送阶段 PC 只收不回声，故无回读死锁问题 +- **RX 校验**：PC 按相同 LCG 模式回放，MCU 期望流按块生成 `exp[]` 字节对位 + `sum_rx` 累加，天然处理 TCP 分包/粘包 +- 单块 4096B = socket 默认发送缓冲上限，同时命中 DP-04 的 DMA 单次读边界 +- 双重完整性：逐字节比对 + 全量 32 位累加和 `SUM(TX)==SUM(RX)`（双向同源 LCG，相等即双向一致） +- 双向独立吞吐打印（TX/RX 各自 KB/s），作为 SPI 时钟/驱动调整的回归基线 + +**固件会话结构**（phase5_run）： + +| 序 | 操作 | 参数/超时 | +|----|------|----------| +| 1 | close 清残留 → proto/des_ip/des_port/sour_port 配置 → open+connect | 两级中断等 CONNECT，15s | +| 2A | 连续发送 64×4KB = 256KB（PC 只收） | SENBUF_FREE 单块 2s | +| 2B | 连续接收 256KB（PC 按 LCG 回放）滚动校验 | RX 停滞 5s 判 FAIL | +| 3 | close，打印双向吞吐与校验结论 | blk_tx/blk_rx==64 且 SUM(TX)==SUM(RX) | + +--- + +### TC-NET-511（硬件层）: 256KB 顺序双向（纯 TX + 纯 RX）完整性 + +| 字段 | 值 | +|------|-----| +| **ID** | TC-NET-511 | +| **优先级** | P0 | +| **类型** | 功能测试（硬件层） | +| **标题** | 先连续发送 256KB（PC 只收），再连续接收 256KB（PC 回放），逐字节校验 + 总账一致 | +| **前置条件** | PC: `python test/ch395f_socket_test.py tcp_bulk --port 8081 --bulk 262144 --chunk 4096`（先启动等待连接） | + +**测试步骤与判定标准**： + +| 步 | 操作 | 成功标准 | 失败标准 | +|----|------|----------|----------| +| 1 | 复位 MCU → 裸命令 connect 到 :8081 | "connected within 15000ms" | 连接超时 / cmd_status 非 0x00 | +| 2A | 连续发送 64×4KB，每 64KB 打印 TX 进度 | "TX 64/64 blocks (262144 bytes)"；PC "阶段A 收满 262144 字节，LCG 校验一致" | SENBUF_FREE 2s 超时 / PC 端校验不一致 | +| 2B | 连续接收 256KB 并滚动校验，每 64KB 打印 RX 进度 | "RX 262144/262144 bytes (64 blocks)"；PC "阶段B 回放 262144 字节完成" | RX 停滞 5s / 字节不匹配 | +| 3 | close 并输出结论 | "TX phase: 64/64 blocks" + "RX phase: ..." + "checksum TX==RX" | bad_chunks>0 / 累加和不一致 | + +**通过标准**：步 1~3 全部满足。任一失败 → 阶段标记 FAIL +**覆盖原则**：DP-02（两级中断轮询）、DP-04（4KB DMA 读边界） + +--- + +### TC-NET-512（硬件层）: 变总量与跨包分块合规 + +| 字段 | 值 | +|------|-----| +| **ID** | TC-NET-512 | +| **优先级** | P1 | +| **类型** | 合规测试（硬件层） | +| **标题** | 三档总量（64KB/256KB/1MB）+ 非整除块边界（4093B）回归 | +| **前置条件** | 同 TC-NET-511；每档修改 `PHASE5_TOTAL_BYTES` / `PHASE5_CHUNK_SIZE` 宏后重编译，且 PC `--bulk` 取 `chunks×PHASE5_CHUNK_SIZE`、`--chunk` 与 `PHASE5_CHUNK_SIZE` 一致 | + +**测试步骤与判定标准**： + +| 步 | 操作 | 成功标准 | 失败标准 | +|----|------|----------|----------| +| 1 | `PHASE5_TOTAL_BYTES=64*1024` 重编译，PC `--bulk 65536` 跑一遍 | 全绿 | 同 TC-511 | +| 2 | `PHASE5_TOTAL_BYTES=1024*1024` 重编译，PC `--bulk 1048576` 跑一遍 | 全绿且吞吐无劣化趋势 | 同上 | +| 3 | `PHASE5_CHUNK_SIZE=4093`（非 4 对齐，制造跨包边界），PC `--chunk 4093 --bulk 261952` 跑一遍 | 全绿（4093 档实际回传 `64×4093=261952B`，不足一块的尾数不上送，完成判定按实际上送字节） | 尾块校验失败 | + +**通过标准**：三组配置均全绿。任一失败 → 阶段标记 FAIL +**覆盖原则**：DP-04（跨包/非对齐边界） + +> **记录（2026-08-24 实测）**：三档全部 **6/6 PASSED**，checksum 逐档相等 —— +> 64KB（4096B 块）: TX 420 / RX 364 KB/s；1MB（4096B 块）: TX 449 / RX 391 KB/s； +> 4093B 块（261952B）: TX 448 / RX 368 KB/s。吞吐随总量/块大小基本恒定， +> 双方向均约 370~450 KB/s，疑似 SPI 总线（SPI2 DMA）为瓶颈。 + +--- + +### 已知风险与待实施项 + +| # | 事项 | 影响 | 状态 | +|---|------|------|------| +| 1 | 原 PHY 测试（TC-NET-901/902）删除：CH395F 直连板载 RTL8305NBI 交换机，PHY 恒 link up，拔插外线上联无法在芯片 PHY 产生变化事件（2026-08-24 实测 0/1 FAIL 后决议） | 编号 901/902 弃用 | ✅ 已移除 | +| 2 | DP-05（PHY 链路恢复）失去覆盖对象 | 设计原则表缩减 | ✅ 已同步删除 | +| 3 | 吞吐基线（2026-08-24 实测）：TX 420~449 KB/s、RX 364~391 KB/s，随总量/块大小基本恒定，疑似 SPI 总线为瓶颈 | 后续 SPI 时钟/驱动优化以该基线为参照 | ✅ 已记录 | + +--- + +## 7. 阶段 6：NET 层 TCP（Server 回显 + Client 主动连接） + +| 阶段 ID | TM-PHY-06 | +|---------|-----------| | **类型** | PC 配合，netTask 运行 | | **耗时** | 持续运行 | -| **入口** | `ENABLE_PHASE4_TESTS`，`ch395fTestTask` TCP 回显循环中运行 | +| **入口** | `ENABLE_PHASE6_TESTS`，`ch395fTestTask` TCP 回显循环中运行 | | **出口** | 用户终止 | +两部分组成： +- **Server 模式（TC-NET-401~406）**：MCU 监听 8080，PC 主动连接，验证回显通路 —— 已实现 🟡 +- **Client 模式扩展（TC-NET-204/205/206）**：MCU 经 BSD Socket API 主动连接 PC Server，补全 `net_connect()` 路径 —— 待实现 🟠（ID 沿用历史编号，原属阶段 2 的 NET 层部分） + ### TC-NET-401: Socket 0 单连接生命周期 | 字段 | 值 | @@ -284,14 +600,91 @@ MCU: STM32F407ZGTx @ 168MHz, Keil MDK-ARM v5 (ARMCC) --- -## 6. 阶段 5：大文件传输（20KB+） +### Client 模式扩展：主动连接 PC（TC-NET-204 / 205 / 206，🟠 待实现） -| 阶段 ID | TM-PHY-05 | +> 与硬件层阶段 2 的 TC-NET-201/202/203 一一对应（芯片行为 → API 封装），验证 `net_socket` / `net_connect` / `net_send` / `net_recv` / `net_close` 对 TCP Client 主路径及异常路径的正确封装。 +> 用例 ID 沿用历史编号（原阶段 2 的 NET 层部分），保证测试记录可追溯；实现于 `ENABLE_PHASE6_TESTS` 固件中。 + +#### TC-NET-204（NET 层）: TCP Client 连接与数据交换 + +| 字段 | 值 | +|------|-----| +| **ID** | TC-NET-204 | +| **优先级** | P0 | +| **类型** | 功能测试（NET 层） | +| **标题** | net_socket TCP Client → PC TCP Server，64 字节收发 | +| **前置条件** | 1. PC: `python ch395f_socket_test.py tcp_server --port 8081`（TCP 回显服务器）
2. `net_init()` 已完成（`g_net_ready == 1`，netTask 周期 `net_poll()` 运行中）
3. 建议：硬件层固件中 TC-NET-201/202/203 已通过（跨构建前置，见「构建模式与执行顺序」） | + +**测试步骤与判定标准**： + +| 步 | 操作 | 成功标准 | 失败标准 | +|----|------|----------|----------| +| 1 | `net_socket(NET_AF_INET, NET_SOCK_STREAM, 0)` 创建 TCP socket | 返回 sockfd（`0~7`），非 `-1` | 返回 `-1`（无空闲 Socket 或 net 层未初始化） | +| 2 | 构造 `struct net_sockaddr_in`（sin_family=`NET_AF_INET`，sin_port=`net_htons(8081)`，sin_addr=`net_inet_addr("192.168.1.2")`）后 `net_connect(sockfd, &addr, len)` | 返回 `0`（连接命令已异步下发） | 返回 `-1`（地址非法或协议栈异常） | +| 3 | 在 netTask 周期 `net_poll()` 推进下，调用 `net_select(sockfd+1, NULL, &wfds, NULL, &tv)` 等待可写事件，超时 10s | 返回正数且 `NET_FD_ISSET(sockfd)` 指示连接建立（ESTABLISHED） | 超时未连接，`net_errno == NET_ERR_WOULDBLOCK` 持续 | +| 4 | `net_send(sockfd, buf, 64, 0)` 发送 64 字节递增模式数据（`0x00..0x3F`） | 返回值 == `64`（全部发出） | 返回值 `< 0`（发送失败）或 `≠ 64`（未完全发出） | +| 5 | `net_recv(sockfd, buf, 64, 0)` 阻塞接收回显，超时 10s | 返回值 == `64` 且与原数据逐字节一致 | 返回值 `< 0`（超时/断开）或 `≠ 64`（数据不完整）或任意字节不符 | +| 6 | `net_close(sockfd)` 关闭 socket（TCP 先断开连接，释放控制块） | 返回 `0` | 返回 `-1`（关闭失败） | + +**通过标准**：6/6 通过，0 失败。任一失败 → 标记 FAIL + +**覆盖原则**：DP-01（net_socket→net_connect→net_send→net_recv→net_close 主路径，NET 层） + +#### TC-NET-205（NET 层）: TCP Client 关闭重连 ×3 轮 + +| 字段 | 值 | +|------|-----| +| **ID** | TC-NET-205 | +| **优先级** | P0 | +| **类型** | 功能测试 / 恢复测试（NET 层） | +| **标题** | close→重连循环 3 轮，每轮含数据交换 | +| **前置条件** | 同 TC-NET-204 | + +**测试步骤与判定标准**（每轮 i = 0,1,2）： + +| 步 | 操作 | 成功标准 | 失败标准 | +|----|------|----------|----------| +| 1 | `net_socket(NET_AF_INET, NET_SOCK_STREAM, 0)` 创建 socket | 返回 sockfd 非 `-1` | 返回 `-1`（无空闲 Socket） | +| 2 | 构造地址 + `net_connect(sockfd, &addr, len)`，再 `net_select` 等待可写确认 ESTABLISHED | 连接建立成功 | 连接失败或超时未建立 | +| 3 | `net_send(sockfd, buf, 64, 0)` → `net_recv(sockfd, buf, 64, 0)` | 收发各 `64` 字节且逐字节一致 | 收发失败或数据不符 | +| 4 | `net_close(sockfd)` 关闭并释放控制块 | 返回 `0` | 返回 `-1` | + +**通过标准**：3/3 轮全部通过，0 失败。任一失败 → 标记 FAIL + +**覆盖原则**：DP-01（net 层 open→connect→close→re-open→reconnect） + +#### TC-NET-206（NET 层）: TCP Client 连接超时 + +| 字段 | 值 | +|------|-----| +| **ID** | TC-NET-206 | +| **优先级** | P1 | +| **类型** | 负向测试（NET 层） | +| **标题** | 目标端口无服务时 net_connect 超时 | +| **前置条件** | 1. PC **未**运行 TCP Server（`192.168.1.2:8081` 无监听）
2. TC-NET-204 通过 | + +**测试步骤与判定标准**： + +| 步 | 操作 | 成功标准 | 失败标准 | +|----|------|----------|----------| +| 1 | `net_socket(...)` + `net_connect(sockfd, &addr, len)`（目标不可达） | `net_connect` 返回 `0`（异步下发） | 返回 `-1`（地址非法） | +| 2 | `net_select(sockfd+1, NULL, &wfds, NULL, &tv)` 等待可写，超时窗 30s | 返回 `0`（超时，连接未建立），`net_errno` 指示超时/不可达 | 误报告可写（异常响应）或 30s 内无结果（挂死） | +| 3 | `net_close(sockfd)` 释放 socket | 返回 `0` | 返回 `-1` | + +**通过标准**：`net_select` 超时且资源正确释放，0 崩溃。任一异常 → 标记 FAIL + +**覆盖原则**：DP-01（NET 层异常路径 connect 失败处理） + +--- + +## 8. 阶段 7：大文件传输（20KB+） + +| 阶段 ID | TM-PHY-07 | |---------|-----------| | **类型** | PC 配合，netTask 运行 | | **耗时** | 取决于文件大小和速率 | -| **入口** | `ENABLE_PHASE5_TESTS` | -| **配置** | `PHASE5_FILE_SIZE`（默认 20480）| +| **入口** | `ENABLE_PHASE7_TESTS` | +| **配置** | `PHASE7_FILE_SIZE`（默认 20480）| ### TC-NET-501: 20KB 分块传输 @@ -321,7 +714,7 @@ MCU: STM32F407ZGTx @ 168MHz, Keil MDK-ARM v5 (ARMCC) ### 实现说明 -`phase5_run()` 状态机（`ch395fTestTask` 内）： +`phase7_run()` 状态机（`ch395fTestTask` 内）： ``` IDLE → (连接建立) → SENDING(分块发) → RECVING(分块收+验证) → DONE → IDLE @@ -333,49 +726,13 @@ IDLE → (连接建立) → SENDING(分块发) → RECVING(分块收+验证) → --- -## 7. 阶段 6：DHCP +## 9. 阶段 8：Select/Poll I/O 多路复用（单连接） -| 阶段 ID | TM-PHY-06 | -|---------|-----------| -| **类型** | PC 配合（Windows 需管理员权限） | -| **耗时** | ~15 秒 | -| **入口** | `ENABLE_PHASE6_TESTS` | -| **注意** | **改变 CH395F IP**，必须独立运行 | - -### TC-NET-601: DHCP 完整握手 - -| 字段 | 值 | -|------|-----| -| **ID** | TC-NET-601 | -| **优先级** | P0 | -| **类型** | 功能测试 | -| **标题** | DISCOVER → OFFER → REQUEST → ACK | -| **前置条件** | PC: `python ch395f_socket_test.py dhcp_server ...`（管理员权限）| -| **测试步骤** | 1. CH395F 发 DISCOVER → PC 回 OFFER → CH395F 发 REQUEST → PC 回 ACK
2. CH395F 应用 IP 配置 | -| **通过标准** | DHCP SUCCESS，IP != 0.0.0.0 | -| **覆盖原则** | DP-03 | - -### TC-NET-602: DHCP 后连通性验证 - -| 字段 | 值 | -|------|-----| -| **ID** | TC-NET-602 | -| **优先级** | P1 | -| **类型** | 功能测试 | -| **标题** | DHCP 分配 IP 后广播宣告 + HELLO 回显 | -| **前置条件** | TC-NET-601 通过 | -| **测试步骤** | 1. CH395F 广播 HELLO（含 IP）
2. PC 收 HELLO
3. PC 发 3×HELLO 回显请求
4. CH395F 回显 | -| **通过标准** | 3/3 HELLO 回显 100% | - ---- - -## 8. 阶段 7：Select/Poll I/O 多路复用（单连接） - -| 阶段 ID | TM-PHY-07 | +| 阶段 ID | TM-PHY-08 | |---------|-----------| | **类型** | PC 配合，netTask 运行 | | **耗时** | 持续运行 | -| **入口** | `ENABLE_PHASE7_TESTS` | +| **入口** | `ENABLE_PHASE8_TESTS` | ### TC-NET-701: net_select() 单 socket 就绪检测 @@ -404,13 +761,13 @@ IDLE → (连接建立) → SENDING(分块发) → RECVING(分块收+验证) → --- -## 9. 阶段 8：边界条件测试 +## 10. 阶段 9：边界条件测试 -| 阶段 ID | TM-PHY-08 | +| 阶段 ID | TM-PHY-09 | |---------|-----------| | **类型** | PC 配合，netTask 运行 | | **耗时** | 按需 | -| **入口** | `ENABLE_PHASE8_TESTS` | +| **入口** | `ENABLE_PHASE9_TESTS` | ### TC-NET-801: DMA 边界 −1（4095 字节） @@ -457,7 +814,7 @@ IDLE → (连接建立) → SENDING(分块发) → RECVING(分块收+验证) → | **优先级** | P1 | | **类型** | 负向测试 | | **标题** | `net_send_sock(sk, buf, 0)` 返回 −1 | -| **测试步骤** | `net_send_sock(sk, s_phase8_tx, 0)` | +| **测试步骤** | `net_send_sock(sk, s_phase9_tx, 0)` | | **通过标准** | 返回 < 0，无崩溃 | ### TC-NET-805: 连续快速发送 20 小包 @@ -484,41 +841,6 @@ IDLE → (连接建立) → SENDING(分块发) → RECVING(分块收+验证) → --- -## 10. 阶段 9：PHY 链路恢复 - -| 阶段 ID | TM-PHY-09 | -|---------|-----------| -| **类型** | 需物理拔插网线 | -| **耗时** | ~45 秒 | -| **入口** | `ENABLE_PHASE9_TESTS` | - -### TC-NET-901: PHY 断开检测 - -| 字段 | 值 | -|------|-----| -| **ID** | TC-NET-901 | -| **优先级** | P1 | -| **类型** | 恢复测试 | -| **标题** | 拔网线后 `net_poll` 检测到 PHY_CHANGE + DISCONN | -| **测试步骤** | 拔网线 → 等 `net_poll` 检测 `CH395F_GINT_STAT_PHY_CHANGE` → 读 PHY = DISCONN | -| **通过标准** | 15 秒内串口 "PHY disconnect detected" | -| **覆盖原则** | DP-02, DP-05 | - -### TC-NET-902: PHY 重连 + Socket 恢复 - -| 字段 | 值 | -|------|-----| -| **ID** | TC-NET-902 | -| **优先级** | P1 | -| **类型** | 恢复测试 | -| **标题** | 插回网线后 Socket 0 自动监听，新连接正常 | -| **前置条件** | TC-NET-901 通过（已拔线） | -| **测试步骤** | 1. 插网线 → 等 PHY_CHANGE → 链路恢复
2. s0 re-OPEN → LISTEN
3. PC 连接 → 64B 回显 | -| **通过标准** | 30 秒内回显成功，无需手动复位 | -| **覆盖原则** | DP-01, DP-05 | - ---- - ## 11. 阶段 10：KeepAlive 超时断开 | 阶段 ID | TM-PHY-10 | @@ -546,13 +868,13 @@ IDLE → (连接建立) → SENDING(分块发) → RECVING(分块收+验证) → | 命令 | 模式 | 说明 | |------|------|------| -| `tcp_server --port 8081` | PC 作 TCP Server | 测试 TCP Client（阶段 2） | -| `tcp_client --ip ... --port 8080` | PC 作 TCP Client | 测试 TCP Echo（阶段 4/7/8） | -| `tcp_file --ip ... --port 8080 --size 20480` | PC 作文件接收 | 测试大文件传输（阶段 5） | +| `tcp_server --port 8081` | PC 作 TCP 回显服务器（多连接循环） | 测试 TCP Client（阶段 2 硬件层；阶段 6 Client 扩展 204/205/206） | +| `tcp_client --ip ... --port 8080` | PC 作 TCP Client | 测试 TCP Echo（阶段 6/8/9） | +| `tcp_file --ip ... --port 8080 --size 20480` | PC 作文件接收 | 测试大文件传输（阶段 7） | | `udp_client --ip ... --port 60000` | PC 作 UDP Client | 测试 UDP Echo（阶段 3） | | `udp_server --port 8082` | PC 作 UDP Server | 接收 CH395F UDP 数据 | | `stress --ip ... --port 8080 --count 10` | 压力测试 | 7 并发 × 10 轮 | -| `dhcp_server ...` | DHCP Server | 内置 DHCP（阶段 6，需管理员权限） | +| `dhcp_server ...` | DHCP Server | 内置 DHCP（阶段 4，需管理员权限） | ### 通用参数 @@ -598,26 +920,29 @@ IDLE → (连接建立) → SENDING(分块发) → RECVING(分块收+验证) → | TM-PHY-02 | TC-NET-203 | P1 | 负向测试 | ✅ | | TM-PHY-03 | TC-NET-301 | P0 | 功能测试 | ✅ | | TM-PHY-03 | TC-NET-302 | P1 | 合规测试 | ✅ | -| TM-PHY-04 | TC-NET-401 | P0 | 功能测试 | 🟡 | -| TM-PHY-04 | TC-NET-402 | P0 | 功能测试 | 🟡 | -| TM-PHY-04 | TC-NET-403 | P0 | 边界测试 | 🟡 | -| TM-PHY-04 | TC-NET-404 | P0 | 边界测试 | 🟡 | -| TM-PHY-04 | TC-NET-405 | P0 | 恢复测试 | 🟡 | -| TM-PHY-04 | TC-NET-406 | P1 | 恢复测试 | 🟡 | -| TM-PHY-05 | TC-NET-501 | P0 | 功能测试 | 🟡 | -| TM-PHY-05 | TC-NET-502 | P1 | 边界测试 | 🟡 | -| TM-PHY-06 | TC-NET-601 | P0 | 功能测试 | ✅ | -| TM-PHY-06 | TC-NET-602 | P1 | 功能测试 | ✅ | -| TM-PHY-07 | TC-NET-701 | P0 | 功能测试 | 🟡 | -| TM-PHY-07 | TC-NET-702 | P1 | 负向测试 | 🟡 | -| TM-PHY-08 | TC-NET-801 | P0 | 边界测试 | 🟡 | -| TM-PHY-08 | TC-NET-802 | P0 | 边界测试 | 🟡 | -| TM-PHY-08 | TC-NET-803 | P0 | 边界测试 | 🟡 | -| TM-PHY-08 | TC-NET-804 | P1 | 负向测试 | 🟡 | -| TM-PHY-08 | TC-NET-805 | P1 | 压力测试 | 🟡 | -| TM-PHY-08 | TC-NET-806 | P1 | 稳定性测试 | 🟡 | -| TM-PHY-09 | TC-NET-901 | P1 | 恢复测试 | ✅ | -| TM-PHY-09 | TC-NET-902 | P1 | 恢复测试 | ✅ | +| TM-PHY-04 | TC-NET-601 | P0 | 功能测试 | ✅ | +| TM-PHY-04 | TC-NET-602 | P1 | 功能测试 | ✅ | +| TM-PHY-05 | TC-NET-511 | P0 | 功能测试 | 🟡 | +| TM-PHY-05 | TC-NET-512 | P1 | 合规测试 | ✅ | +| TM-PHY-06 | TC-NET-204 | P0 | 功能测试 | 🟠 | +| TM-PHY-06 | TC-NET-205 | P0 | 恢复测试 | 🟠 | +| TM-PHY-06 | TC-NET-206 | P1 | 负向测试 | 🟠 | +| TM-PHY-06 | TC-NET-401 | P0 | 功能测试 | 🟡 | +| TM-PHY-06 | TC-NET-402 | P0 | 功能测试 | 🟡 | +| TM-PHY-06 | TC-NET-403 | P0 | 边界测试 | 🟡 | +| TM-PHY-06 | TC-NET-404 | P0 | 边界测试 | 🟡 | +| TM-PHY-06 | TC-NET-405 | P0 | 恢复测试 | 🟡 | +| TM-PHY-06 | TC-NET-406 | P1 | 恢复测试 | 🟡 | +| TM-PHY-07 | TC-NET-501 | P0 | 功能测试 | 🟡 | +| TM-PHY-07 | TC-NET-502 | P1 | 边界测试 | 🟡 | +| TM-PHY-08 | TC-NET-701 | P0 | 功能测试 | 🟡 | +| TM-PHY-08 | TC-NET-702 | P1 | 负向测试 | 🟡 | +| TM-PHY-09 | TC-NET-801 | P0 | 边界测试 | 🟡 | +| TM-PHY-09 | TC-NET-802 | P0 | 边界测试 | 🟡 | +| TM-PHY-09 | TC-NET-803 | P0 | 边界测试 | 🟡 | +| TM-PHY-09 | TC-NET-804 | P1 | 负向测试 | 🟡 | +| TM-PHY-09 | TC-NET-805 | P1 | 压力测试 | 🟡 | +| TM-PHY-09 | TC-NET-806 | P1 | 稳定性测试 | 🟡 | | TM-PHY-10 | TC-NET-1001 | P1 | 功能测试 | 🟡 | ✅ = 已实现并验证 | 🟡 = 已实现待验证 | 🟠 = 待实现 @@ -627,10 +952,9 @@ IDLE → (连接建立) → SENDING(分块发) → RECVING(分块收+验证) → | 原则 | 覆盖用例 | |------|----------| | DP-01：单 socket 生命周期 | TC-NET-202, 203, 401, 405, 406, 806, 902 | -| DP-02：中断集中处理 | TC-NET-101, 102, 701, 901 | +| DP-02：中断即读即清 | TC-NET-101, 102, 511, 512, 701 | | DP-03：消息队列线程安全 | TC-NET-301, 302, 601 | -| DP-04：DMA 边界安全 | TC-NET-403, 404, 501, 502, 801, 802, 803, 804, 805 | -| DP-05：PHY 链路恢复 | TC-NET-901, 902 | +| DP-04：DMA 边界安全 | TC-NET-403, 404, 501, 502, 511, 512, 801, 802, 803, 804, 805 | ## 附录 C：CH395F 边界条件速查 diff --git a/docs/CH395F_Trap_Records.md b/docs/CH395F_Trap_Records.md index a0a4576..9666519 100644 --- a/docs/CH395F_Trap_Records.md +++ b/docs/CH395F_Trap_Records.md @@ -395,3 +395,39 @@ MobaXterm 上传文件时 CH395F 收到数据（`s1 int=0x04` RECV_OK 持续触 ### 注意事项 - CH395F 接收缓冲区默认 socket 0: 4096B, socket 1: 4096B。读空后客户端继续发数据，recv_len 重新递增——正常 - 清理中断状态后 `handle_timeout_event` 中的 `ch395f_close_socket` 必须显式调用，确保下次 `open_socket` 成功 + +--- + +## Trap 14：close 后 DISCONNECT 滞后锁存，污染下次会话首次中断读取 + +### 现象 +`close_socket` → 轮询 `GET_SOCKET_STATUS` 已确认 CLOSED 后，紧接的下一会话（重新 open + connect）在第一次读 `GET_INT_STATUS_SN` 时读到**上一会话遗留的 DISCONNECT 事件**（0ms 即命中），导致负向判定/状态机误判。实测：TC-202 三轮重连后立即跑 TC-203，PC 端握手实际成功（连接被接受），固件却因陈旧 DISCONNECT 抢先判"未连接"。 + +### 根因 +- `wait-CLOSED` 轮询用的 `GET_SOCKET_STATUS` 是**纯查询，不清中断**； +- TCP 拆除过程中断（DISCONNECT）可能在与 CLOSED 状态达成几乎同时、甚至之后才锁存； +- 该事件无人消费，跨会话存活到下一次 `open_socket` 之后。 + +### 解决 +1. **预清**：新会话 OPEN 前读一次 `GET_GLOB_INT_STATUS_ALL` + `GET_INT_STATUS_SN` 丢弃陈旧事件； +2. **反核实**：依据中断做结论前，用 `GET_SOCKET_STATUS` 验证实际状态一致（如"负向事件 vs ESTABLISHED"矛盾时以状态为准）。 + +### 参考 +`test/ch395f_test_task.c: phase2_tc203()`（双保险实现）；同类思路见 Phase 1 入口的 PHY_CHANGE 预清。 + +--- + +## Trap 15：DHCP 成功后 IP 寄存器提交滞后 + +### 现象 +`GET_DHCP_STATUS` 已置 0x00 后立即 `GET_IP_INF`，回读到的仍是**旧静态配置**（如 192.168.1.100），而芯片实际已按新租约（192.168.1.77）正常收发——串口打印与 Socket6 广播宣告均带出过期 IP。2026-08-24 上板实测：固件各检查全 PASS（6/6），但 PC 侧 HELLO 发往租约地址才得到应答，三方数据矛盾构成假阳性。 + +### 根因 +DHCP 状态位仅代表协商流程完成；IP/MASK/GW 寄存器的提交与状态置位是异步的，存在数百毫秒级窗口（实测 ~1s 内完成翻转）。 + +### 解决 +1. **稳定轮询**：连续 3 次读 `GET_IP_INF`（间隔 300ms，上限 8s）结果一致且非零才采信； +2. **交叉比对**：PC 端将收到的宣告 IP 与所分配租约比对，不一致即报错兜底。 + +### 参考 +`test/ch395f_test_task.c: phase4_run()`；`docs/CH395F_Test_Guide.md` 阶段 4 风险表 #4。 diff --git a/test/__pycache__/ch395f_socket_test.cpython-311.pyc b/test/__pycache__/ch395f_socket_test.cpython-311.pyc index fac3bacd8f658cdd38e4ef3a6798a8a5c4f49883..75c05f75312c74b866f64f64ce60e978792f7fb0 100644 GIT binary patch delta 28145 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 aEyOCqU^Bgfrs2JafRAv6quIoQ<^KiUY;#)x delta 18498 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 diff --git a/test/ch395f_socket_test.py b/test/ch395f_socket_test.py index f384b3b..6575974 100644 --- a/test/ch395f_socket_test.py +++ b/test/ch395f_socket_test.py @@ -8,19 +8,22 @@ CH395F BSD Socket API 测试程序 python ch395f_socket_test.py [模式] [选项] 模式: - tcp_server - 作为 TCP 服务器（测试 CH395F TCP Client） + tcp_server - TCP 回显服务器，多连接循环（测试 CH395F TCP Client） tcp_client - 作为 TCP 客户端（测试 CH395F TCP Server） udp_server - 作为 UDP 服务器（测试 CH395F UDP Client） udp_client - 作为 UDP 客户端（测试 CH395F UDP Server） - tcp_echo - TCP 回显服务器（测试双向通信） + tcp_echo - TCP 回显服务器（单连接，测试双向通信） udp_echo - UDP 回显服务器（测试双向通信） stress - 压力测试（多连接并发测试） + tcp_bulk - 双向大块：先收满 bulk 字节（不回声，校验 LCG），再回放（阶段 5） 选项: --ip 目标 IP 地址（默认: 192.168.1.100） --port 端口号（默认: 8080） --count 测试次数（默认: 10） --size 数据包大小（默认: 1024） + --bulk tcp_bulk 模式双向字节数（默认: 262144） + --chunk tcp_bulk 模式块大小，须与固件 PHASE5_CHUNK_SIZE 一致（默认: 4096） 示例: # 测试 CH395F TCP Server @@ -37,10 +40,14 @@ CH395F BSD Socket API 测试程序 # 压力测试（多连接） python ch395f_socket_test.py stress --ip 192.168.1.100 --port 8080 --count 7 + + # 阶段 5 双向大块（先收 256KB 再回放 256KB） + python ch395f_socket_test.py tcp_bulk --port 8081 --bulk 262144 --chunk 4096 """ import socket import sys +import os import time import argparse import threading @@ -49,6 +56,10 @@ import random import string from datetime import datetime +# TCP 回显服务器（tcp_server 模式）参数 +INTER_ACCEPT_TIMEOUT = 60 # 首个连接后，等待下一个连接的超时秒数 +ECHO_IDLE_TIMEOUT = 30 # 连接内无数据的空闲超时秒数 + class Colors: """终端颜色""" @@ -69,19 +80,19 @@ def log_msg(msg, color=Colors.END): def log_success(msg): - log_msg(f"✓ {msg}", Colors.GREEN) + log_msg("[OK] %s" % msg, Colors.GREEN) def log_error(msg): - log_msg(f"✗ {msg}", Colors.RED) + log_msg("[ERR] %s" % msg, Colors.RED) def log_info(msg): - log_msg(f"ℹ {msg}", Colors.BLUE) + log_msg("[..] %s" % msg, Colors.BLUE) def log_warn(msg): - log_msg(f"⚠ {msg}", Colors.YELLOW) + log_msg("[!!] %s" % msg, Colors.YELLOW) def generate_data(size): @@ -99,89 +110,195 @@ def verify_data(data, expected_len): # ==================== TCP 测试函数 ==================== def tcp_server_test(args): - """TCP 服务器测试（测试 CH395F TCP Client）""" + """TCP 回显服务器测试（测试 CH395F TCP Client） + + 与固件 TC-NET-201/202 配套：MCU 连接后发送数据并等待原样回显， + 校验通过后主动关闭。本函数循环接受多个连接，每个连接内将收到的 + 数据逐字回显，直到对端关闭或空闲超时。 + + 首个连接等待 args.timeout 秒；之后每个连接间最多等待 + INTER_ACCEPT_TIMEOUT 秒，无新连接则结束并汇总。 + 返回 False 表示失败（无连接或回显出错），main 据此返回非 0 退出码。 + """ log_info("=" * 60) - log_info("TCP 服务器测试 - 测试 CH395F TCP Client 功能") + log_info("TCP 回显服务器 - 测试 CH395F TCP Client 功能") log_info("=" * 60) server_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM) server_socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1) - server_socket.settimeout(args.timeout) + + conn_total = 0 + echo_bytes = 0 + conn_errors = 0 try: server_socket.bind(('0.0.0.0', args.port)) - server_socket.listen(1) + server_socket.listen(4) log_success(f"服务器启动，监听端口 {args.port}") - for conn_idx in range(3): + conn_idx = 0 + while True: + wait = args.timeout if conn_idx == 0 else min(args.timeout, INTER_ACCEPT_TIMEOUT) + server_socket.settimeout(wait) try: - server_socket.settimeout(args.timeout) - log_info(f"等待第 {conn_idx+1} 个连接（超时 {args.timeout}s）...") + log_info(f"等待第 {conn_idx+1} 个连接（超时 {wait}s）...") client_socket, client_addr = server_socket.accept() - log_success(f"连接#{conn_idx+1} 来自: {client_addr[0]}:{client_addr[1]}") - client_socket.settimeout(5) - - # Test 1: 接收数据 - log_info("-" * 40) - log_info(f"[连接{conn_idx+1}] 测试 1: 接收数据") - try: - data = client_socket.recv(args.size) - if data: - log_success(f"收到数据 ({len(data)} bytes): {data[:50]}...") - except socket.timeout: - log_error("接收超时") - - # Test 2: PING echo - log_info(f"[连接{conn_idx+1}] 测试 2: 双向通信 (PING)") - ping_ok = 0 - for i in range(5): - try: - test_data = f"PING_{i}".encode() - client_socket.send(test_data) - data = client_socket.recv(args.size) - if data and data == test_data: - log_success(f"回显匹配: {test_data.decode()}") - ping_ok += 1 - elif data: - log_error(f"回显不匹配! 收到: {data[:20]}") - break - except socket.timeout: - log_error("通信超时") - break - except Exception as e: - log_error(f"通信错误: {e}") - break - log_info(f"PING 匹配: {ping_ok}/5") - - # Test 3: 大包发送 - log_info(f"[连接{conn_idx+1}] 测试 3: 大包发送") - for i in range(args.count): - try: - test_data = generate_data(min(100, args.size)) - client_socket.send(test_data) - time.sleep(0.1) - except Exception as e: - log_error(f"发送错误: {e}") - break - log_success(f"发送 {args.count} 包完成") - - client_socket.close() - log_success(f"连接#{conn_idx+1} 测试完成") - time.sleep(0.5) - except socket.timeout: - log_error(f"等待连接#{conn_idx+1} 超时") + if conn_idx == 0: + log_error("等待连接超时") + else: + log_info(f"{wait}s 内无新连接，服务器退出") break + + conn_idx += 1 + log_success(f"连接#{conn_idx} 来自: {client_addr[0]}:{client_addr[1]}") + + # 回显循环：收到什么回什么（sendall 保证发完），对端关闭或空闲超时结束 + client_socket.settimeout(ECHO_IDLE_TIMEOUT) + rx = 0 + try: + while True: + data = client_socket.recv(4096) + if not data: + log_info(f"[连接{conn_idx}] 对端已关闭") + break + client_socket.sendall(data) + rx += len(data) + except socket.timeout: + log_warn(f"[连接{conn_idx}] 空闲超时，关闭连接") except Exception as e: - log_error(f"连接#{conn_idx+1} 错误: {e}") - break + log_error(f"[连接{conn_idx}] 回显错误: {e}") + conn_errors += 1 + finally: + client_socket.close() - log_success("全部连接测试完成") + if rx > 0: + log_success(f"连接#{conn_idx} 完成: 回显 {rx} 字节") + else: + log_warn(f"连接#{conn_idx} 未收到任何数据") + conn_errors += 1 + echo_bytes += rx + conn_total += 1 + + log_info("-" * 40) + log_info(f"服务结束: 连接 {conn_total} 个, 回显 {echo_bytes} 字节, 异常 {conn_errors} 次") + if conn_total == 0: + log_error("无任何客户端连接") + return False + return conn_errors == 0 - except socket.timeout: - log_error("等待连接超时") except Exception as e: log_error(f"服务器错误: {e}") + return False + finally: + server_socket.close() + + +# ==================== 阶段 5：双向大块传输 ==================== + +BULK_IDLE_TIMEOUT = 10 # bulk 接收阶段单次 recv 等待超时（秒） + + +def _lcg_block(idx, size): + """生成与固件 phase5_gen_block 完全一致的 LCG 块数据（uint32 回绕）""" + seed = (0xC2D2E6F9 ^ (idx * 2654435761)) & 0xFFFFFFFF + out = bytearray(size) + for k in range(size): + seed = (seed * 1664525 + 1013904223) & 0xFFFFFFFF + out[k] = (seed >> 24) & 0xFF + return bytes(out) + + +def tcp_bulk_test(args): + """双向大块传输测试（配合固件阶段 5 硬件层） + + 协议：接受连接 → 收满 bulk 字节（不回声，校验 LCG 模式）→ + 按相同 LCG 模式回放 bulk 字节 → 关闭。 + MCU 侧先连续发送 256KB（本端只收），再连续接收 256KB（本端回放）， + 分别测得纯 TX / 纯 RX 吞吐。 + """ + chunk = args.chunk + bulk = (args.bulk // chunk) * chunk # 按整块取整 + blocks = bulk // chunk + log_info("=" * 60) + log_info("TCP Bulk 双向大块 - 配合 CH395F 阶段 5") + log_info(f"协议: 收满 {bulk} 字节(不回声) -> 回放 {bulk} 字节 (chunk={chunk}, blocks={blocks})") + log_info("=" * 60) + + server_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM) + server_socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1) + try: + server_socket.bind(('0.0.0.0', args.port)) + server_socket.listen(4) + log_success(f"服务器启动，监听端口 {args.port}") + + server_socket.settimeout(args.timeout) + try: + client_socket, client_addr = server_socket.accept() + except socket.timeout: + log_error("等待连接超时") + return False + log_success(f"连接来自: {client_addr[0]}:{client_addr[1]}") + client_socket.settimeout(BULK_IDLE_TIMEOUT) + + # 预生成期望/回放数据（LCG，与固件一致） + expected = bytearray(bulk) + for i in range(blocks): + expected[i * chunk:(i + 1) * chunk] = _lcg_block(i, chunk) + + # ---- 阶段 A：收满 bulk 字节（不回声），校验 LCG 模式 ---- + rx_buf = bytearray() + rx_t0 = time.time() + try: + while len(rx_buf) < bulk: + data = client_socket.recv(min(65536, bulk - len(rx_buf))) + if not data: + log_error(f"对端提前关闭，仅收到 {len(rx_buf)}/{bulk} 字节") + client_socket.close() + return False + rx_buf += data + except socket.timeout: + log_error(f"接收空闲超时，仅收到 {len(rx_buf)}/{bulk} 字节") + client_socket.close() + return False + rx_ms = int((time.time() - rx_t0) * 1000) + + ok = (bytes(rx_buf) == bytes(expected)) + if ok: + log_success(f"阶段A 收满 {len(rx_buf)} 字节，LCG 校验一致") + else: + bad = -1 + for i in range(min(len(rx_buf), len(expected))): + if rx_buf[i] != expected[i]: + bad = i + break + if bad >= 0: + log_error(f"阶段A 数据不一致 @第 {bad} 字节 (期望 0x{expected[bad]:02X}, " + f"实际 0x{rx_buf[bad]:02X})") + else: + log_error(f"阶段A 数据不一致（长度 {len(rx_buf)} vs {len(expected)}）") + log_info(f"阶段A 接收 {len(rx_buf)} 字节，耗时 {rx_ms} ms " + f"({len(rx_buf) * 1000 // max(rx_ms, 1)} B/s)") + + # ---- 阶段 B：按 LCG 模式回放 bulk 字节 ---- + tx_t0 = time.time() + try: + for off in range(0, bulk, chunk): + client_socket.sendall(expected[off:off + chunk]) + except Exception as e: + log_error(f"阶段B 回放错误: {e}") + ok = False + finally: + client_socket.close() + tx_ms = int((time.time() - tx_t0) * 1000) + if ok: + log_success(f"阶段B 回放 {bulk} 字节完成，耗时 {tx_ms} ms " + f"({bulk * 1000 // max(tx_ms, 1)} B/s)") + return ok + + except Exception as e: + log_error(f"服务器错误: {e}") + return False finally: server_socket.close() @@ -334,17 +451,24 @@ def udp_server_test(args): def udp_client_test(args): - """UDP Echo 测试（测试 CH395F UDP Server）""" + """UDP Echo 测试（测试 CH395F UDP Server，对应指南阶段 3） + + 会话结构与固件 phase3_run() 约定： + - "HELLO" 探针：回显即就绪，不计入固件轮次 + - TC-301：30 轮 64B 基础回显（--size 非默认值时覆盖单轮载荷大小） + - TC-302：1B/64B/200B 各 --count 轮变长合规（默认 10） + 任一轮 mismatch/timeout 立即终止；结束输出汇总，失败退出码 1。 + """ log_info("=" * 60) - log_info("UDP Echo 测试") + log_info("UDP Echo 测试（TC-301 基础回显 + TC-302 变长合规）") log_info("=" * 60) sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM) dest = (args.ip, args.port) try: - # Phase A: HELLO 探针等待 STM32 就绪 - log_info(f"Phase A: 等待 CH395F 就绪（超时 {args.timeout}s）") + # Phase A: HELLO 就绪探针（固件只回显不计数，不占用例预算） + log_info(f"Phase A: HELLO 就绪探针（超时 {args.timeout}s）") sock.settimeout(2) t0 = time.time() ready = False @@ -360,55 +484,70 @@ def udp_client_test(args): pass if not ready: log_error(f"未就绪（{args.timeout}s 超时）") - return + sys.exit(1) sock.settimeout(5) - # Phase B: PING Echo + # Phase B: TC-301 基础回显 30 轮 x 64B + size_b = 64 if args.size == 1024 else min(args.size, 200) + rounds_b = 30 log_info("-" * 40) - log_info("Phase B: PING Echo（5 轮）") - ok = 0 - for i in range(5): - msg = f"PING_{i}".encode() - try: - sock.sendto(msg, dest) - data, _ = sock.recvfrom(64) - if data == msg: - ok += 1 - log_success(f"PING_{i} OK") - else: - log_error(f"PING_{i} mismatch: {data[:20]}") - break - except socket.timeout: - log_error(f"PING_{i} timeout") - break - time.sleep(0.02) - log_info(f"PING: {ok}/5") - - # Phase C: 大包 Echo - log_info("-" * 40) - log_info(f"Phase C: 大包 Echo（{args.count} 轮）") - for i in range(args.count): - td = generate_data(min(100, args.size)) + log_info(f"Phase B: TC-301 基础回显（{rounds_b} 轮 x {size_b}B）") + ok_b = 0 + for i in range(rounds_b): + td = generate_data(size_b) try: sock.sendto(td, dest) - data, _ = sock.recvfrom(args.size) - if data == td: - log_success(f"#{i+1} OK ({len(data)}B)") - else: - log_error(f"#{i+1} mismatch") + data, _ = sock.recvfrom(size_b + 16) + if data != td: + log_error(f"[TC-301] #{i+1} mismatch: {len(data)}B != {len(td)}B") break - time.sleep(0.02) except socket.timeout: - log_warn(f"#{i+1} timeout") - except Exception as e: - log_error(f"#{i+1}: {e}") + log_error(f"[TC-301] #{i+1} echo timeout") break + ok_b += 1 + if ok_b % 10 == 0: + log_info(f"[TC-301] 进度 {ok_b}/{rounds_b}") + time.sleep(0.02) - log_success("Phase 3 完成") + # Phase C: TC-302 变长合规（仅 Phase B 全过后继续，否则后续必超时） + sizes_c = [1, 64, 200] + total_c = len(sizes_c) * args.count + ok_c = 0 + if ok_b == rounds_b: + log_info("-" * 40) + log_info(f"Phase C: TC-302 变长合规（{sizes_c}B 各 {args.count} 轮）") + for sz in sizes_c: + ok_sz = 0 + for i in range(args.count): + td = generate_data(sz) + try: + sock.sendto(td, dest) + data, _ = sock.recvfrom(sz + 16) + if data != td: + log_error(f"[TC-302] {sz}B #{i+1} mismatch: {len(data)}B != {sz}B") + break + except socket.timeout: + log_error(f"[TC-302] {sz}B #{i+1} echo timeout") + break + ok_sz += 1 + time.sleep(0.02) + log_info(f"[TC-302] {sz}B: {ok_sz}/{args.count}") + ok_c += ok_sz + if ok_sz < args.count: + break + + # 汇总与退出码 + log_info("=" * 60) + if ok_b == rounds_b and ok_c == total_c: + log_success(f"PASS: TC-301 {ok_b}/{rounds_b}, TC-302 {ok_c}/{total_c}") + else: + log_error(f"FAIL: TC-301 {ok_b}/{rounds_b}, TC-302 {ok_c}/{total_c}") + sys.exit(1) except Exception as e: log_error(f"错误: {e}") + sys.exit(1) finally: sock.close() @@ -647,6 +786,7 @@ DHCP_OFFER = 2 DHCP_REQUEST = 3 DHCP_ACK = 5 OPT_MESSAGE_TYPE = 53 +DHCP_ANNOUNCE_PORT = 60001 # MCU Socket6 广播宣告端口（固件 phase4_run） OPT_SERVER_ID = 54 OPT_SUBNET_MASK = 1 OPT_ROUTER = 3 @@ -675,6 +815,30 @@ def _build_dhcp_pkt(op, xid, client_mac, yiaddr, siaddr, options): return op_b + htype + hlen + hops + xid + secs + flags + ciaddr + yiaddr + siaddr + giaddr + chaddr + sname + file + magic + options +def _announce_listener(results): + """后台监听 MCU 的 4B IP 广播宣告（UDP :60001，TC-602 步1 的 PC 侧观测）""" + s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM) + s.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1) + try: + s.bind(('0.0.0.0', DHCP_ANNOUNCE_PORT)) + except OSError as e: + results['announce_err'] = f'绑定 {DHCP_ANNOUNCE_PORT} 失败: {e}' + return + s.settimeout(45) + try: + data, addr = s.recvfrom(16) + if len(data) == 4: + ip = '.'.join(str(b) for b in data) + log_success(f"收到 IP 宣告: {ip} (from {addr[0]}:{addr[1]})") + results['announce'] = ip + else: + results['announce_err'] = f'宣告长度异常 {len(data)}B（预期 4B）' + except socket.timeout: + results['announce_err'] = '45s 未收到宣告' + finally: + s.close() + + def dhcp_server_test(args): """DHCP Server 模式（DISCOVER → OFFER → REQUEST → ACK）""" log_info("=" * 60) @@ -700,9 +864,14 @@ def dhcp_server_test(args): sock.settimeout(60) log_info("DHCP 服务器已启动，等待 CH395F DISCOVER...") - log_info("（请确保 MCU 端已启用 ENABLE_PHASE6_TESTS 并复位）") + log_info("（请确保 MCU 端已启用 ENABLE_PHASE4_TESTS 并复位）") print() + # 宣告监听线程：MCU 在 ACK 后立即广播 4B IP 到 :60001 + results = {} + listener = threading.Thread(target=_announce_listener, args=(results,), daemon=True) + listener.start() + try: # Phase 1: DISCOVER → OFFER data, addr = sock.recvfrom(4096) @@ -799,6 +968,17 @@ def dhcp_server_test(args): print() + # 汇总宣告监听结果（TC-602 步 1 PC 侧观测；join 延迟由固件 30s HELLO 窗覆盖） + listener.join(timeout=10) + if results.get('announce'): + if results['announce'] != offer_ip: + log_error(f"IP 宣告 {results['announce']} != 租约 {offer_ip}！" + "芯片固件可能回读了未提交的旧 IP 配置") + elif 'announce_err' in results: + log_warn(f"IP 宣告未观测到：{results['announce_err']}") + + print() + # Phase 3: 连通性验证（MCU Phase 6 内置 HELLO 端口 = 60000） hello_port = args.port if args.port != 8080 else 60000 log_info(f"验证 {offer_ip} 连通性（UDP HELLO → port {hello_port}）") @@ -892,17 +1072,20 @@ def main(): %(prog)s tcp_server --port 8080 %(prog)s stress --ip 192.168.1.100 --port 8080 --count 5 %(prog)s dhcp_server --dhcp-iface 192.168.1.2 --ip 192.168.1.100 + %(prog)s tcp_bulk --port 8081 --bulk 262144 --chunk 4096 """ ) parser.add_argument('mode', choices=['tcp_server', 'tcp_client', 'udp_server', 'udp_client', 'tcp_echo', 'udp_echo', 'stress', 'packet_size', - 'dhcp_server'], + 'dhcp_server', 'tcp_bulk'], help='测试模式') parser.add_argument('--ip', default='192.168.1.100', help='目标 IP 地址 / DHCP 待分配 IP') parser.add_argument('--port', type=int, default=8080, help='端口号') parser.add_argument('--count', type=int, default=10, help='测试次数') parser.add_argument('--size', type=int, default=1024, help='数据包大小') + parser.add_argument('--bulk', type=int, default=262144, help='tcp_bulk 模式双向字节数') + parser.add_argument('--chunk', type=int, default=4096, help='tcp_bulk 模式块大小，须与固件 PHASE5_CHUNK_SIZE 一致') parser.add_argument('--timeout', type=int, default=180, help='接受连接超时（秒，默认180）') parser.add_argument('--dhcp-iface', default='192.168.1.2', help='DHCP 服务器网卡 IP') parser.add_argument('--dhcp-mask', default='255.255.255.0', help='DHCP 分配的子网掩码') @@ -910,15 +1093,24 @@ def main(): args = parser.parse_args() + # GBK 控制台容错：不可编码字符替换而非崩溃 + for stream in (sys.stdout, sys.stderr): + if stream is not None and hasattr(stream, 'reconfigure'): + stream.reconfigure(errors='replace') + + if sys.platform == 'win32': + os.system('') # 启用 Windows 控制台 VT 序列，避免 ANSI 颜色码乱码 + print() print(Colors.BOLD + "=" * 60 + Colors.END) print(Colors.BOLD + " CH395F BSD Socket API 测试程序" + Colors.END) print(Colors.BOLD + "=" * 60 + Colors.END) print() + ret = None try: if args.mode == 'tcp_server': - tcp_server_test(args) + ret = tcp_server_test(args) elif args.mode == 'tcp_client': tcp_client_test(args) elif args.mode == 'udp_server': @@ -933,14 +1125,21 @@ def main(): stress_test(args) elif args.mode == 'packet_size': packet_size_test(args) + elif args.mode == 'tcp_bulk': + ret = tcp_bulk_test(args) elif args.mode == 'dhcp_server': dhcp_server_test(args) except KeyboardInterrupt: log_warn("用户中断") + sys.exit(130) except Exception as e: log_error(f"未预期的错误: {e}") import traceback traceback.print_exc() + sys.exit(2) + + if ret is False: + sys.exit(1) if __name__ == '__main__': diff --git a/test/ch395f_test.h b/test/ch395f_test.h index c4a4ec8..47b999b 100644 --- a/test/ch395f_test.h +++ b/test/ch395f_test.h @@ -9,19 +9,19 @@ * 修改记录： * 2026-07-22 全面重构为单连接模式，增加大文件传输、边界条件等测试 * - * === 测试阶段一览 === - * Phase | 类型 | 描述 - * ---------|--------------|----------------------------------------------- - * Phase 1 | 独立运行 | 寄存器读写 + SPI 命令路径验证 - * Phase 2 | PC 配合 | TCP Client 收发 + 关闭重连 - * Phase 3 | PC 配合 | UDP Server Echo（HELLO + PING + 大包） - * Phase 4 | testTask | NET 层 TCP Echo（单连接模式，基础收发验证） - * Phase 5 | testTask | NET 层大文件传输（20KB+ 分块收发） - * Phase 6 | PC 配合 | DHCP 自动获取 IP - * Phase 7 | testTask | Select/Poll I/O 多路复用 - * Phase 8 | testTask | 边界条件测试（零长度、DMA 边界、缓冲溢出） - * Phase 9 | 需拔插网线 | PHY 链路恢复 - * Phase 10 | testTask | KeepAlive 超时断开测试 + * === 测试阶段一览（硬件层 1~5 → NET 层 6~10，严格顺序执行） === + * Phase | 层 | 描述 + * ---------|----------|----------------------------------------------- + * Phase 1 | 硬件层 | 独立运行：寄存器读写 + SPI 命令路径验证 + * Phase 2 | 硬件层 | PC 配合：TCP Client 收发 + 关闭重连 + * Phase 3 | 硬件层 | PC 配合：UDP Server Echo（60 轮动态源地址回显，HELLO 探针不计数） + * Phase 4 | 硬件层 | PC 配合：DHCP 自动获取 IP + * Phase 5 | 硬件层 | PC 配合：大文件分块回传（裸命令，tcp_server 配合） + * Phase 6 | NET 层 | testTask：TCP Echo（单连接模式，基础收发验证） + * Phase 7 | NET 层 | testTask：大文件传输（20KB+ 分块收发） + * Phase 8 | NET 层 | testTask：Select/Poll I/O 多路复用 + * Phase 9 | NET 层 | testTask：边界条件测试（零长度、DMA 边界、缓冲溢出） + * Phase 10 | NET 层 | testTask：KeepAlive 超时断开测试 */ #ifndef __CH395F_TEST_H @@ -35,19 +35,43 @@ extern "C" { /* * 阶段使能开关（取消注释即启用对应阶段） - * 注意：一次仅启用一个阶段（Phase 4/5/7/8 共享 testTask 循环，可同时启用） - * Phase 6 (DHCP) 会改变 IP，必须独立运行 + * + * 构建模式互斥（详见 docs/CH395F_Test_Guide.md「构建模式与执行顺序」）： + * 硬件层模式（阶段 1~5）：netTask 不创建，ch395fTestTask 独占 CH395F + * NET 层模式 （阶段 6~10）：完整网络栈，netTask 轮询 + ch395fTestTask 监听循环 + * + * 注意：同层内可多选（Phase 6~10 共享 testTask 循环）； + * Phase 4 (DHCP) 会改变 IP，必须独立运行； + * 两层同时启用会在下方触发 #error。 */ -#define ENABLE_PHASE1_TESTS /* 寄存器读写 + SPI 命令路径 */ -//#define ENABLE_PHASE2_TESTS /* TCP Client 收发 + 关闭重连 */ -//#define ENABLE_PHASE3_TESTS /* UDP Server Echo */ -//#define ENABLE_PHASE4_TESTS /* NET 层 TCP Echo（单连接基础收发） */ -//#define ENABLE_PHASE5_TESTS /* NET 层大文件传输（20KB+ 分块） */ -//#define ENABLE_PHASE6_TESTS /* DHCP 自动获取 IP（会改 IP！独立运行） */ -//#define ENABLE_PHASE7_TESTS /* Select/Poll I/O 多路复用 */ -//#define ENABLE_PHASE8_TESTS /* 边界条件测试 */ -//#define ENABLE_PHASE9_TESTS /* PHY 链路恢复测试 */ -//#define ENABLE_PHASE10_TESTS /* KeepAlive 超时断开测试 */ +/* ---- 硬件层（阶段 1~5）---- */ +//#define ENABLE_PHASE1_TESTS /* [硬] 寄存器读写 + SPI 命令路径 */ +//#define ENABLE_PHASE2_TESTS /* [硬] TCP Client 收发 + 关闭重连 */ +//#define ENABLE_PHASE3_TESTS /* [硬] UDP Server Echo */ +//#define ENABLE_PHASE4_TESTS /* [硬] DHCP 自动获取 IP（会改 IP！独立运行） */ +#define ENABLE_PHASE5_TESTS /* [硬] 大文件传输（硬件层，PC 配合） */ +/* ---- NET 层（阶段 6~10）---- */ +//#define ENABLE_PHASE6_TESTS /* [网] TCP Echo（单连接基础收发） */ +//#define ENABLE_PHASE7_TESTS /* [网] 大文件传输（20KB+ 分块） */ +//#define ENABLE_PHASE8_TESTS /* [网] Select/Poll I/O 多路复用 */ +//#define ENABLE_PHASE9_TESTS /* [网] 边界条件测试 */ +//#define ENABLE_PHASE10_TESTS /* [网] KeepAlive 超时断开测试 */ + +#if defined(ENABLE_PHASE1_TESTS) || defined(ENABLE_PHASE2_TESTS) || \ + defined(ENABLE_PHASE3_TESTS) || defined(ENABLE_PHASE4_TESTS) || \ + defined(ENABLE_PHASE5_TESTS) +#define ENABLE_HW_LAYER_TESTS 1 +#endif + +#if defined(ENABLE_PHASE6_TESTS) || defined(ENABLE_PHASE7_TESTS) || \ + defined(ENABLE_PHASE8_TESTS) || defined(ENABLE_PHASE9_TESTS) || \ + defined(ENABLE_PHASE10_TESTS) +#define ENABLE_NET_LAYER_TESTS 1 +#endif + +#if defined(ENABLE_HW_LAYER_TESTS) && defined(ENABLE_NET_LAYER_TESTS) +#error "硬件层(1~5)与NET层(6~10)测试互斥：请分两次构建，见 CH395F_Test_Guide 构建模式与执行顺序" +#endif /* 测试统计 */ typedef struct { diff --git a/test/ch395f_test_task.c b/test/ch395f_test_task.c index 0696b14..1836b1d 100644 --- a/test/ch395f_test_task.c +++ b/test/ch395f_test_task.c @@ -2,17 +2,17 @@ * 模块名称：CH395F Network Test Task * 模块功能：CH395F 全阶段测试入口，统一在独立 FreeRTOS 任务中运行。 * 测试分两组： - * Phase 1/2/3/6/9 — 阻塞式，TCP 监听前依次执行（各自有内部循环/等待） - * Phase 4/5/7/8/10 — 事件驱动，TCP 监听循环中运行（需 PC 客户端连接） + * Phase 1~5（硬件层）— 阻塞式独占执行（各自有内部循环/等待），netTask 未运行 + * Phase 4~10（NET 层）— 事件驱动，TCP 监听循环中运行（需 PC 客户端连接） * 所有测试结果通过 TEST_CHECK/TEST_REPORT 宏输出到串口。 * 作者：王建锋 * 创建日期：2026-07-22 ******************************************************************************/ #include -#include #include "ch395f_test_task.h" #include "cmsis_os.h" +#include "net_task.h" #include "net_socket.h" #include "ch395f_test.h" #include "ch395f.h" @@ -20,7 +20,8 @@ #define DBG_TAG "[TEST_TASK]" #include "dbg_log.h" -/* netTask 初始化完成标志（由 net_task.c 在 net_init 成功后置 1） */ +/* netTask 初始化完成标志（由 net_task.c 在 net_stack_bring_up 成功后置 1）。 + * 仅 NET 层模式使用 —— 硬件层模式下 netTask 不创建，由本任务自行初始化。 */ extern volatile uint8_t g_net_ready; /* @@ -32,16 +33,16 @@ test_stats_t g_test_stats; /* * 收发缓冲区 —— 全局静态，不在任务栈上。 - * s_tx_buf 仅在 Phase 5（大文件传输）和 Phase 8（边界条件）中使用， + * s_tx_buf 仅在 Phase 7（大文件传输）和 Phase 9（边界条件）中使用， * 其他 Phase 不需要发送固定模式数据，故条件编译节省 RAM。 */ #define TEST_BUF_SIZE 65536 -#if defined(ENABLE_PHASE4_TESTS) || defined(ENABLE_PHASE5_TESTS) || \ - defined(ENABLE_PHASE7_TESTS) || defined(ENABLE_PHASE8_TESTS) || \ +#if defined(ENABLE_PHASE6_TESTS) || defined(ENABLE_PHASE7_TESTS) || \ + defined(ENABLE_PHASE8_TESTS) || defined(ENABLE_PHASE9_TESTS) || \ defined(ENABLE_PHASE10_TESTS) static uint8_t s_rx_buf[TEST_BUF_SIZE]; #endif -#if defined(ENABLE_PHASE5_TESTS) || defined(ENABLE_PHASE8_TESTS) +#if defined(ENABLE_PHASE7_TESTS) || defined(ENABLE_PHASE9_TESTS) static uint8_t s_tx_buf[TEST_BUF_SIZE]; #endif @@ -54,10 +55,36 @@ static uint8_t s_tx_buf[TEST_BUF_SIZE]; * 共 9 项测试（P1-01 ~ P1-09），逐项执行，汇总报告。 * =================================================================== */ +/* 解析点分十进制 IP 字符串为数组（避免引入 sscanf 库） */ +static void test_parse_ip(const char *str, uint8_t *ip_arr) +{ + uint32_t val; + int i; + + for (i = 0; i < 4; i++) { + val = 0; + while (*str >= '0' && *str <= '9') { + val = val * 10 + (*str - '0'); + str++; + } + ip_arr[i] = (uint8_t)val; + if (*str == '.') { + str++; + } + } +} + #ifdef ENABLE_PHASE1_TESTS static void phase1_run(void) { uint8_t ip_info[20]; + /* ---- 前置清全局中断（读即清除） ---- + * net_stack_bring_up() 在 set_phy(100M_FULL) 强制重协商 + 等待链路建立 + * 期间，芯片会锁存 GINT_STAT_PHY_CHANGE（0x0004）标志；硬件层模式下无 + * netTask 轮询消费它，若不清除将导致 P1-06 的"原始状态 0x0000"检查误报。 + * 此处读取一次丢弃，保证 P1-06 反映的是测试期间的纯净状态。 */ + (void)ch395f_get_glob_int_status_all(); + DBG_INFO("=== CH395F Phase 1 Tests ==="); DBG_INFO("--- 9 test items (P1-01 ~ P1-09) ---"); @@ -230,7 +257,7 @@ static void phase1_run(void) { * 测试目的：验证 CH395F 作为 TCP Client 发起连接、发送数据、接收回显、 * 关闭连接、重连的完整生命周期。重复 3 轮以验证连接稳定性。 * - * 前置条件：PC 上运行 TCP Server（python ch395f_socket_test.py tcp_server --port 8081） + * 前置条件：PC 上运行 TCP 回显服务器（python test/ch395f_socket_test.py tcp_server --port 8081） * 通过：3/3 轮回显成功。 * 失败：任意轮连接失败、回显超时或数据不一致。 * =================================================================== */ @@ -251,122 +278,511 @@ static void phase1_run(void) { #ifndef PHASE2_TIMEOUT_MS #define PHASE2_TIMEOUT_MS 10000 #endif +#ifndef PHASE2_TC203_TIMEOUT_MS +#define PHASE2_TC203_TIMEOUT_MS 30000 /* TC-203 连接超时窗（指南规定 30s） */ +#endif -static void phase2_run(void) { +/* TCP Client 单次会话：对应 TC-NET-201 步 2~7 与 TC-NET-202 每轮 6 步。 + * 调用前须已设置协议类型 / 目标 IP / 目标端口（TC-NET-201 步 1）。 + * 每轮使用不同本地端口 local_port 规避 TIME_WAIT。 + * 返回 1 表示全流程通过，0 表示中途失败（已记录 TEST_CHECK）。 + */ +/* TC-NET-201（硬件层）：单次 TCP Client 连接与数据交换，步骤与文档 7 步严格对应 */ +static void phase2_tc201(void) +{ + uint8_t sock = 0; /* 本用例操作的 Socket 索引，固定 0（单连接模式） */ + uint8_t ip_arr[4]; /* 目标 IP 四字节数组，由 test_parse_ip() 解析 PHASE2_REMOTE_IP 填入 */ + uint8_t tx[64]; /* 发送缓冲：64 字节递增模式数据 0x00..0x3F */ + uint8_t rx[300]; /* 接收缓冲：存放 PC 回显数据，300 > 64 预留安全余量 */ + uint8_t r; /* ch395f_* 命令返回值（0x00 = CH395F_ERR_SUCCESS） */ + uint8_t ok; /* 当前步骤结果标志：1 = 成功跳出等待循环，0 = 超时失败 */ + uint16_t p; /* 逐字节比对循环索引（rx[p] vs tx[p]） */ + uint16_t n; /* 实际参与比对的字节数 = MIN(rl, 64) */ + uint16_t rl; /* 本次实际读取长度 = MIN(收到长度, sizeof(rx))，防缓冲区溢出 */ + uint32_t tick; /* HAL_GetTick() 快照；用无符号减法测超时窗口（回绕安全） */ + int16_t k; /* 通用循环索引（如构造 tx 递增模式） */ + int16_t match; /* 回显校验结果：1 = 全部字节一致，0 = 发现不符（提前 break） */ + + test_parse_ip(PHASE2_REMOTE_IP, ip_arr); + + /* 步1：配置协议类型 / 目标 IP / 目标端口 / 本地端口 */ + ch395f_set_proto_type(sock, CH395F_PROTO_TYPE_TCP); + ch395f_set_des_ip(sock, ip_arr); + ch395f_set_des_port(sock, PHASE2_REMOTE_PORT); + ch395f_set_sour_port(sock, (uint16_t)PHASE2_LOCAL_PORT); + TEST_CHECK(ch395f_get_cmd_status() == CH395F_ERR_SUCCESS, + "TC201 step1 cfg proto/ip/port"); + if (ch395f_get_cmd_status() != CH395F_ERR_SUCCESS) return; + + /* 构造 64 字节递增模式数据 0x00..0x3F */ + for (k = 0; k < 64; k++) { + tx[k] = (uint8_t)k; + } + + /* 步2：OPEN Socket 0 */ + r = ch395f_open_socket(sock); + TEST_CHECK(r == CH395F_ERR_SUCCESS, "TC201 step2 open"); + if (r != CH395F_ERR_SUCCESS) return; + + /* 步3：CONNECT */ + r = ch395f_tcp_connect(sock); + TEST_CHECK(r == CH395F_ERR_SUCCESS, "TC201 step3 connect"); + if (r != CH395F_ERR_SUCCESS) { ch395f_close_socket(sock); return; } + + /* 步4：等待 CONNECT 中断 + * + * CH395F 的中断上报是【两级】结构： + * + * 第 1 级 —— 全局中断状态 GET_GLOB_INT_STATUS_ALL（16 位，读即清除） + * 只回答"哪个 Socket 发生了事件"，不回答具体是什么事件。 + * 16 位布局（见 ch395f.h GINT_STAT 宏定义）： + * bit0 UNREACH (0x0001) 目标不可达 + * bit1 IP_CONFLI (0x0002) IP 冲突 + * bit2 PHY_CHANGE (0x0004) 链路状态变化 + * bit3 DHCP (0x0008) DHCP 事件 + * bit4~7 Socket0~3 (0x0010/0x20/0x40/0x80) + * bit8~11 Socket4~7 (0x0100~0x0800) + * bit15 DHCPV6 (0x8000) + * + * 第 2 级 —— Socket 中断状态 CMD_GET_INT_STATUS_SN（8 位，读即清除） + * 才包含具体事件类型：SENBUF_FREE / SEND_OK / RECV_OK / + * CONNECT / DISCONNECT / DISCARD / SOCK_TIMEOUT。 + * 必须在第 1 级提示"本 Socket 有事件"后再读，否则读了也是空。 + * + * 【掩码 (1U << (sock + 4)) 的由来】 + * 全局状态的 bit0~3 被 4 个全局事件占用，因此 Socket N 的事件标志 + * 固定从 bit4 开始排列 —— Socket N 对应第 (N + 4) 位： + * sock=0 → 1<<4 = 0x0010（CH395F_GINT_STAT_SOCK0） + * sock=1 → 1<<5 = 0x0020（CH395F_GINT_STAT_SOCK1） + * ... + * sock=7 → 1<<11 = 0x0800（CH395F_GINT_STAT_SOCK7） + * `int_st & (1U << (sock + 4))` 非 0 + * ⇔ 芯片报告"Socket [sock] 有待处理事件"， + * 此时才值得再花一次 SPI 事务去读第 2 级确认具体事件。 + */ + tick = HAL_GetTick(); + ok = 0; + while (HAL_GetTick() - tick < PHASE2_TIMEOUT_MS) { + /* 第 1 级：读全局状态。注意本次读取本身会清掉全部全局标志 + * 并拉高 INT#（读即清除），所以每轮循环都在重新采样。 */ + uint16_t int_st = ch395f_get_glob_int_status_all(); + + /* 本 Socket 在全局寄存器中有事件挂起？ */ + if (int_st & (1U << (sock + 4))) { + /* 第 2 级：读本 Socket 的具体事件类型（同样读即清除） */ + uint8_t si = ch395f_get_sock_int_status(sock); + if (si & CH395F_SINT_STAT_CONNECT) { + /* bit3 = 0x08：TCP 三次握手完成，进入 ESTABLISHED */ + ok = 1; + break; + } + /* 是别的事件（理论上此阶段不应出现），已被读清、直接忽略， + * 继续下一轮轮询等 CONNECT */ + } + HAL_Delay(10); /* 10ms 轮询周期，直至 CONNECT 或超时退出 */ + } + TEST_CHECK(ok, "TC201 step4 connected"); + if (!ok) { + ch395f_close_socket(sock); + return; + } + HAL_Delay(100); + + /* 步5：发送 64 字节，并等待 SENBUF_FREE 中断确认发送缓冲释放 */ + ch395f_write_send_buf(sock, tx, 64); + tick = HAL_GetTick(); + ok = 0; + while (HAL_GetTick() - tick < 2000) { + uint16_t int_st = ch395f_get_glob_int_status_all(); + if (int_st & (1U << (sock + 4))) { + uint8_t si = ch395f_get_sock_int_status(sock); + if (si & CH395F_SINT_STAT_SENBUF_FREE) { + ok = 1; + break; + } + } + HAL_Delay(10); + } + TEST_CHECK(ok, "TC201 step5 sendbuf_free"); + if (!ok) { + ch395f_close_socket(sock); + return; + } + + /* 步6：等待回显并逐字节验证（递增模式 0x00..0x3F） + * + * 背景：步 5 已把 tx[64] 发给 PC，PC 端 tcp_server 收到后原样回显。 + * 本步骤最多等 10 秒，每轮轮询做两件事： + * ① 查芯片接收缓冲有没有回显数据到达（优先处理）； + * ② 查有没有 DISCONNECT / TIMEOUT 事件（连接断了就别傻等了）。 + * + * 关键 API 语义区别： + * ch395f_get_recv_len() —— 只查询积压字节数，不取走数据（可反复调用） + * ch395f_read_recv_buf() —— 真正从芯片 RX FIFO 取出数据（取走即消耗） + */ + tick = HAL_GetTick(); + ok = 0; /* 尚未收到任何回显数据 */ + while (HAL_GetTick() - tick < 10000) { + + /* ---- ① 数据到达检查 ---- + * rlen：芯片 RX 缓冲区当前积压的字节数（纯查询、不消耗）。 + * rlen > 0 说明 PC 回显已到达，进入读取 + 校验流程。 */ + uint16_t rlen = ch395f_get_recv_len(sock); + if (rlen > 0) { + + /* 截断保护：一次最多读 sizeof(rx)=300 字节， + * 防止 rlen 异常偏大时 read_recv_buf 写越界 rx[] */ + rl = (rlen > (uint16_t)sizeof(rx)) ? (uint16_t)sizeof(rx) : rlen; + + /* 清零将要填充的区域（防御性写法，避免残留脏字节干扰比对） */ + memset(rx, 0, rl); + + /* 从芯片 RX FIFO 取出回显 —— 此刻起这些数据已被消费 */ + ch395f_read_recv_buf(sock, rx, rl); + + /* 参与比对的长度：预期回显 64 字节；若 TCP 分片导致本次 + * 只到了一部分（rl < 64），则只比对已到的部分 */ + n = (rl < 64) ? rl : 64; + + /* 判定初值：必须收满 64 字节才算通过。若 rl < 64（分片/短读）， + * match 直接为 0 → "echo verify" 判 FAIL */ + match = (rl >= 64); + + /* 与发送的递增模式逐字节比对：tx[k]=k，任一不符立即置 FAIL 退出 */ + for (p = 0; p < n; p++) { + if (rx[p] != tx[p]) { + match = 0; + break; + } + } + TEST_CHECK(match, "TC201 step6 echo verify"); + + ok = 1; /* 标记"收到过数据"，循环外的 echo rcvd 检查不再重复报错 */ + break; /* 校验结论已得出，无论 PASS/FAIL 都跳出 */ + } + + /* ---- ② 连接异常检查（还没等到数据才走到这里）---- + * 两级中断：全局状态确认本 Socket 有事件 → 再读具体事件类型。 + * 注意先查数据再查断开：断开事件可能和最后一批数据同时到达， + * 数据优先保证"临终回显"不被漏掉。 */ + uint16_t int_st = ch395f_get_glob_int_status_all(); + if (int_st & (1U << (sock + 4))) { + uint8_t si = ch395f_get_sock_int_status(sock); + if (si & (CH395F_SINT_STAT_DISCONNECT | CH395F_SINT_STAT_SOCK_TIMEOUT)) { + break; /* 对端断开 / 超时：继续等也不会有回显了。 + ok 保持 0，跳出后由下方统一判 FAIL */ + } + } + + /* 每 50ms 一轮。若本轮只读了部分数据（rlen > 300 的极端情况）， + * 剩余字节下一轮 get_recv_len 会继续报告，不会丢 */ + HAL_Delay(50); + } + /* 到这里只有两种情况： + * ok==1：收到过数据，结果已由循环内 "echo verify" 记录； + * ok==0：10s 内什么都没收到 / 中途断开 —— 在此补一条 FAIL。 */ + if (!ok) { + TEST_CHECK(0, "TC201 step6 echo rcvd"); + } + + /* 步7：关闭 Socket 并等待状态回到 CLOSED（CH395F_SOCKET_CLOSED = 0x00） */ + ch395f_close_socket(sock); + tick = HAL_GetTick(); + ok = 0; + while (HAL_GetTick() - tick < 5000) { + uint8_t st[2]; + ch395f_get_socket_status(sock, st); + if (st[0] == CH395F_SOCKET_CLOSED) { + ok = 1; + break; + } + HAL_Delay(50); + } + TEST_CHECK(ok, "TC201 step7 closed"); + HAL_Delay(200); +} + +/* TC-NET-202（硬件层）：关闭重连 x PHASE2_LOOP_COUNT 轮，每轮 6 步 */ +static void phase2_tc202_once(uint8_t sock, uint16_t local_port) +{ + uint8_t tx[64]; + uint8_t rx[300]; + uint8_t r; + uint8_t ok; + uint16_t p; + uint16_t n; + uint16_t rl; + uint32_t tick; + int k; + int match; + + for (k = 0; k < 64; k++) { + tx[k] = (uint8_t)k; + } + + /* 步1：设置本地端口并 OPEN Socket 0 */ + ch395f_set_sour_port(sock, local_port); + r = ch395f_open_socket(sock); + TEST_CHECK(r == CH395F_ERR_SUCCESS, "TC202 step1 open"); + if (r != CH395F_ERR_SUCCESS) return; + + /* 步2：CONNECT */ + r = ch395f_tcp_connect(sock); + TEST_CHECK(r == CH395F_ERR_SUCCESS, "TC202 step2 connect"); + if (r != CH395F_ERR_SUCCESS) { ch395f_close_socket(sock); return; } + + /* 步3：等待 CONNECT 中断 */ + tick = HAL_GetTick(); + ok = 0; + while (HAL_GetTick() - tick < PHASE2_TIMEOUT_MS) { + uint16_t int_st = ch395f_get_glob_int_status_all(); + if (int_st & (1U << (sock + 4))) { + uint8_t si = ch395f_get_sock_int_status(sock); + if (si & CH395F_SINT_STAT_CONNECT) { ok = 1; break; } + } + HAL_Delay(10); + } + TEST_CHECK(ok, "TC202 step3 connected"); + if (!ok) { ch395f_close_socket(sock); return; } + HAL_Delay(100); + + /* 步4：发送 64 字节 + SENBUF_FREE */ + ch395f_write_send_buf(sock, tx, 64); + tick = HAL_GetTick(); + ok = 0; + while (HAL_GetTick() - tick < 2000) { + uint16_t int_st = ch395f_get_glob_int_status_all(); + if (int_st & (1U << (sock + 4))) { + uint8_t si = ch395f_get_sock_int_status(sock); + if (si & CH395F_SINT_STAT_SENBUF_FREE) { ok = 1; break; } + } + HAL_Delay(10); + } + TEST_CHECK(ok, "TC202 step4 sendbuf_free"); + if (!ok) { ch395f_close_socket(sock); return; } + + /* 步5：等待回显并验证 */ + tick = HAL_GetTick(); + ok = 0; + while (HAL_GetTick() - tick < 10000) { + uint16_t rlen = ch395f_get_recv_len(sock); + if (rlen > 0) { + rl = (rlen > (uint16_t)sizeof(rx)) ? (uint16_t)sizeof(rx) : rlen; + memset(rx, 0, rl); + ch395f_read_recv_buf(sock, rx, rl); + n = (rl < 64) ? rl : 64; + match = (rl >= 64); + for (p = 0; p < n; p++) { + if (rx[p] != tx[p]) { match = 0; break; } + } + TEST_CHECK(match, "TC202 step5 echo verify"); + ok = 1; + break; + } + uint16_t int_st = ch395f_get_glob_int_status_all(); + if (int_st & (1U << (sock + 4))) { + uint8_t si = ch395f_get_sock_int_status(sock); + if (si & (CH395F_SINT_STAT_DISCONNECT | CH395F_SINT_STAT_SOCK_TIMEOUT)) break; + } + HAL_Delay(50); + } + if (!ok) TEST_CHECK(0, "TC202 step5 echo rcvd"); + + /* 步6：关闭 + 等待 CLOSED */ + ch395f_close_socket(sock); + tick = HAL_GetTick(); + ok = 0; + while (HAL_GetTick() - tick < 5000) { + uint8_t st[2]; + ch395f_get_socket_status(sock, st); + if (st[0] == CH395F_SOCKET_CLOSED) { ok = 1; break; } + HAL_Delay(50); + } + TEST_CHECK(ok, "TC202 step6 closed"); + HAL_Delay(200); +} + +static void phase2_tc202(void) +{ uint8_t sock = 0; - uint8_t rx_buf[300] = {0}; + uint8_t ip_arr[4]; int i; - DBG_INFO("=== CH395F Phase 2 Tests (TCP Client) ==="); + test_parse_ip(PHASE2_REMOTE_IP, ip_arr); - /* 解析远程 IP 字符串为字节数组 */ - uint8_t ip_arr[4]; - { - uint32_t a[4]; - sscanf(PHASE2_REMOTE_IP, "%lu.%lu.%lu.%lu", &a[0], &a[1], &a[2], &a[3]); - ip_arr[0] = (uint8_t)a[0]; - ip_arr[1] = (uint8_t)a[1]; - ip_arr[2] = (uint8_t)a[2]; - ip_arr[3] = (uint8_t)a[3]; - } - DBG_INFO("Target: %s:%d", PHASE2_REMOTE_IP, PHASE2_REMOTE_PORT); - - /* - * 配置 Socket 0 为 TCP Client 模式： - * - 协议类型 TCP - * - 目标 IP/端口：PC Server - * - 本地端口：循环内每次+1，避免 TIME_WAIT 冲突 - */ - sock = 0; + /* 协议 / 目标端口在重连间保持不变，仅每轮更换本地端口 */ ch395f_set_proto_type(sock, CH395F_PROTO_TYPE_TCP); ch395f_set_des_ip(sock, ip_arr); ch395f_set_des_port(sock, PHASE2_REMOTE_PORT); for (i = 0; i < PHASE2_LOOP_COUNT; i++) { - DBG_INFO("--- Iteration %d/%d ---", i + 1, PHASE2_LOOP_COUNT); + phase2_tc202_once(sock, (uint16_t)(PHASE2_LOCAL_PORT + i)); + } +} - /* - * 每轮使用不同本地端口（防止前一轮 TIME_WAIT 未完全释放导致绑定失败）。 - * 先 OPEN() 创建 Socket，再 CONNECT() 发 SYN。 - * OPEN() 和 CONNECT() 都是异步命令，需轮询中断状态确认连接完成。 - */ - ch395f_set_sour_port(sock, PHASE2_LOCAL_PORT + i); +/* TC-NET-203（硬件层）：TCP Client 连接超时（负向测试，P1） + * + * 前置环境：PC 未在 192.168.1.2:8081 提供服务（与 TC-201/202 互斥， + * 需先关闭 PC 端 tcp_server）。固件自行辨别环境错误： + * 若等待期间误收到 CONNECT，说明 PC 服务未关，判 FAIL 并给出指引。 + * + * 负向通过路径（本质都是"未建立连接"，按事件+耗时细分原因）： + * SOCK_TIMEOUT(快, <3s) —— 实测主路径：对端在线但端口关闭，RST 拒绝， + * 芯片毫秒级上报，并非等待重传耗尽 + * SOCK_TIMEOUT(慢, ≥3s) —— 对端无响应（掉电/防火墙丢包），重传耗尽后报超时 + * DISCONNECT —— 预留兼容路径（SYN_SENT 阶段实测基本不出现） + * UNREACH(全局位) —— ARP 失败、对端不在线（仅作备注，不影响判定） + * + * 已知陷阱（Trap 14）：上一会话 close 的 DISCONNECT 会滞后锁存在 + * SINT_SN（wait-CLOSED 的 STATUS 查询不清中断）。防御双保险： + * ① 步 2 前预清两级中断； + * ② 判负向后用 GET_SOCKET_STATUS 反核实，ESTABLISHED 即改判环境错误。 + */ +static void phase2_tc203(void) +{ + uint8_t sock = 0; /* 操作 Socket 0（单连接模式） */ + uint8_t ip_arr[4]; /* 目标 IP 四字节数组 */ + uint16_t sour_port = (uint16_t)(PHASE2_LOCAL_PORT + 16); /* 避开 201/202 用过的端口防 TIME_WAIT */ + uint32_t tick; + uint32_t elapsed; /* 步3 从 CONNECT 到收到负向事件的耗时（ms），用于细分原因 */ + uint8_t r; + uint8_t neg_si; /* 步3 命中的 socket 事件位（SOCK_TIMEOUT/DISCONNECT） */ + uint8_t ev; /* 步3 结果：0=无事件 1=收到负向事件(过) 2=误收到CONNECT(环境错误) */ - if (ch395f_open_socket(sock) != CH395F_ERR_SUCCESS) { TEST_CHECK(0, "open socket"); continue; } - if (ch395f_tcp_connect(sock) != CH395F_ERR_SUCCESS) { TEST_CHECK(0, "tcp connect"); ch395f_close_socket(sock); continue; } + DBG_INFO("--- TC-NET-203: connect timeout (PC 8081 MUST be OFF) ---"); - /* 等待 CONNECT 中断（最多 PHASE2_TIMEOUT_MS） */ - uint32_t tick = HAL_GetTick(); - uint8_t connected = 0; - while (HAL_GetTick() - tick < PHASE2_TIMEOUT_MS) { - uint16_t int_st = ch395f_get_glob_int_status_all(); - if (int_st & (1U << (sock + 4))) { - uint8_t si = ch395f_get_sock_int_status(sock); - if (si & CH395F_SINT_STAT_CONNECT) { connected = 1; break; } - } - HAL_Delay(10); - } - if (!connected) { TEST_CHECK(0, "connect timeout"); ch395f_close_socket(sock); continue; } + test_parse_ip(PHASE2_REMOTE_IP, ip_arr); - HAL_Delay(100); + /* 步1：配置协议/目标 IP/目标端口/本地端口，校验 CMD_STATUS */ + ch395f_set_proto_type(sock, CH395F_PROTO_TYPE_TCP); + ch395f_set_des_ip(sock, ip_arr); + ch395f_set_des_port(sock, (uint16_t)PHASE2_REMOTE_PORT); + ch395f_set_sour_port(sock, sour_port); + TEST_CHECK(ch395f_get_cmd_status() == CH395F_ERR_SUCCESS, + "TC203 step1 cfg proto/ip/port"); + if (ch395f_get_cmd_status() != CH395F_ERR_SUCCESS) return; - /* - * 发送 64 字节测试数据（前部为可读字符串，后部填充数字字符）。 - * 然后等待 PC Server 回显（将收到的数据原样发回）， - * 收到后立即把回显数据再次发送回去（实现双向验证）。 - */ - { - uint8_t test_buf[64] = {0}; - const char *msg = "HelloFromCH395F_TCP_Client! This is a 64-byte test message."; - int p, mlen = (int)strlen(msg); - memcpy(test_buf, msg, mlen); - for (p = mlen; p < 64; p++) test_buf[p] = (uint8_t)('0' + (p - mlen) % 10); - ch395f_write_send_buf(sock, test_buf, 64); + /* 预清陈旧事件（Trap 14）：上一会话 close 的 DISCONNECT 可能滞后锁存 + * 在 SINT_SN 中（wait-CLOSED 轮询的 STATUS 是纯查询、不清中断）， + * 若不清除，本用例首次读中断会误吃旧事件导致负向误判。 */ + (void)ch395f_get_glob_int_status_all(); + (void)ch395f_get_sock_int_status(sock); + + /* 步2：OPEN + CONNECT。命令为异步下发，此时均应立即返回成功， + * 真正的失败结果由步 3 的中断体现 */ + r = ch395f_open_socket(sock); + TEST_CHECK(r == CH395F_ERR_SUCCESS, "TC203 step2 open"); + if (r != CH395F_ERR_SUCCESS) return; + + r = ch395f_tcp_connect(sock); + TEST_CHECK(r == CH395F_ERR_SUCCESS, "TC203 step2 connect"); + if (r != CH395F_ERR_SUCCESS) { ch395f_close_socket(sock); return; } + + /* 步3：30s 两级中断轮询，等"连不上"的证据。 + * 先扫全局 UNREACH 位作备注，再查本 socket 位取具体事件。 + * + * 实测行为（2026-08 上板）：PC 端口关闭时 SYN 被 RST 拒绝， + * 芯片以【毫秒级 SOCK_TIMEOUT】上报，并非等待 30s 静默重传耗尽； + * DISCONNECT 仅在已建立连接断开时触发，SYN_SENT 阶段基本不会出现。 + * 因此同时记录耗时用于细分失败原因： + * <3s → 对端主动拒绝（RST，端口关闭） + * ≥3s → 真无应答（对端离线/防火墙丢包，重传耗尽） */ + tick = HAL_GetTick(); + ev = 0; + neg_si = 0; + while (HAL_GetTick() - tick < PHASE2_TC203_TIMEOUT_MS) { + uint16_t int_st = ch395f_get_glob_int_status_all(); + + if (int_st & CH395F_GINT_STAT_UNREACH) { + DBG_INFO(" global UNREACH: ARP fail (peer offline)"); } - /* 等待回显（最多 10 秒），收到后原样发回作为二次验证 */ - int got_echo = 0; - uint32_t wait = HAL_GetTick(); - while (HAL_GetTick() - wait < 10000) { - uint16_t rlen = ch395f_get_recv_len(sock); - if (rlen > 0) { - uint16_t read_len = (rlen > sizeof(rx_buf)) ? (uint16_t)sizeof(rx_buf) : rlen; - memset(rx_buf, 0, sizeof(rx_buf)); - ch395f_read_recv_buf(sock, rx_buf, read_len); - ch395f_write_send_buf(sock, rx_buf, read_len); - got_echo = 1; + if (int_st & (1U << (sock + 4))) { + uint8_t si = ch395f_get_sock_int_status(sock); + if (si & (CH395F_SINT_STAT_SOCK_TIMEOUT | CH395F_SINT_STAT_DISCONNECT)) { + neg_si = si; /* 记下事件位，跳出后再细分原因 */ + ev = 1; break; } - uint16_t int_st = ch395f_get_glob_int_status_all(); - if (int_st & (1U << (sock + 4))) { - uint8_t si = ch395f_get_sock_int_status(sock); - if (si & CH395F_SINT_STAT_DISCONNECT) break; - if (si & CH395F_SINT_STAT_SOCK_TIMEOUT) break; + if (si & CH395F_SINT_STAT_CONNECT) { + ev = 2; /* 连上了 = PC 服务没关，属环境错误而非芯片故障 */ + break; } - HAL_Delay(50); } - TEST_CHECK(got_echo, "Echo #%d", i + 1); - - /* - * 关闭 Socket（使用 close_socket 而非 disconnect，避免进入 FIN_WAIT_2）。 - * 等待状态机回到 CLOSED（CH395F_SOCKET_CLOSED = 0x05）。 - */ - ch395f_close_socket(sock); - { - uint8_t st[2]; - wait = HAL_GetTick(); - while (HAL_GetTick() - wait < 5000) { - ch395f_get_socket_status(sock, st); - if (st[0] == CH395F_SOCKET_CLOSED) break; - HAL_Delay(50); - } - DBG_INFO("closed: sock=0x%02X tcp=0x%02X", st[0], st[1]); - } - HAL_Delay(200); + HAL_Delay(10); } + elapsed = HAL_GetTick() - tick; + + /* 反核实（Trap 14 第二道防线）：负向事件与实际状态矛盾时以状态为准。 + * 若收到"负向事件"但 socket 实际已 ESTABLISHED，说明刚才读到的是 + * 上一会话遗留的陈旧 DISCONNECT，真实结果是连接成功 —— 环境错误。 */ + if (ev == 1) { + uint8_t st_chk[2]; + ch395f_get_socket_status(sock, st_chk); + if (st_chk[0] == CH395F_TCP_ESTABLISHED) { + DBG_ERROR(" negative event but socket ESTABLISHED -> stale DISCONNECT!"); + ev = 2; + } + } + + if (ev == 1) { + const char *why; + const char *short_tag; + + if (neg_si & CH395F_SINT_STAT_DISCONNECT) { + why = "DISCONNECT: peer sent RST (port closed)"; + short_tag = "DISC/RST"; + } else if (elapsed < 3000U) { + /* 毫秒级超时 = 收到了 RST 快速失败，而非静默无应答 */ + why = "SOCK_TIMEOUT fast: peer actively refused (RST, port closed)"; + short_tag = "T/O-fast(refused)"; + } else { + why = "SOCK_TIMEOUT slow: no response (offline / firewall drop)"; + short_tag = "T/O-slow(silence)"; + } + DBG_INFO(" negative event @%lums: %s", elapsed, why); + TEST_CHECK(1, "TC203 step3 no-connect OK (%lums %s)", elapsed, short_tag); + } else if (ev == 2) { + DBG_ERROR(" CONNECT received -> PC 8081 server is still running!"); + TEST_CHECK(0, "TC203 step3 connected?! stop PC server and retry"); + } else { + TEST_CHECK(0, "TC203 step3 no interrupt in %dms (state machine hang?)", + PHASE2_TC203_TIMEOUT_MS); + } + + /* 步4：无论步 3 结论如何都关闭 Socket，确认状态机可恢复到 CLOSED */ + ch395f_close_socket(sock); + tick = HAL_GetTick(); + ev = 0; + while (HAL_GetTick() - tick < 5000) { + uint8_t st[2]; + ch395f_get_socket_status(sock, st); + if (st[0] == CH395F_SOCKET_CLOSED) { ev = 1; break; } + HAL_Delay(50); + } + TEST_CHECK(ev == 1, "TC203 step4 closed"); + + HAL_Delay(200); +} + +static void phase2_run(void) +{ + DBG_INFO("=== CH395F Phase 2 Tests (TCP Client) ==="); + + DBG_INFO("--- TC-NET-201: connect & 64B exchange ---"); + phase2_tc201(); + + DBG_INFO("--- TC-NET-202: close/reconnect x%d ---", PHASE2_LOOP_COUNT); + phase2_tc202(); + + DBG_INFO("--- TC-NET-203: negative test, stop PC 8081 server first ---"); + phase2_tc203(); + TEST_REPORT("Phase 2"); } + + #endif /* =================================================================== @@ -379,16 +795,26 @@ static void phase2_run(void) { * 4. 向对应源地址回显数据 * 5. SENDBUF_FREE 中断等待（确保发送缓冲可用） * - * 前置条件：PC 发送 UDP 包到 192.168.1.100:60000 - * 通过：30/30 轮回显成功。 + * 前置条件：PC 运行 udp_client 发包到 192.168.1.100:60000 + * 会话结构：累计 PHASE3_TOTAL_ROUNDS(60) 个有效数据包后关闭 Socket + * 第 1~30 轮 = TC-301（PC 发 64B）；第 31~60 轮 = TC-302（1B/64B/200B） + * "HELLO"(5B) 为 PC 就绪探针：照常回显但不计入轮次 + * 通过：60/60 有效轮回显成功。 * 失败：任意轮回显超时或解析错误。 * =================================================================== */ #ifdef ENABLE_PHASE3_TESTS + +/* UDP 有效回显轮数：1~30 = TC-301（64B），31~60 = TC-302（变长）。 + * "HELLO" 探针只回显不计数，与 test/ch395f_socket_test.py udp_client 约定 */ +#ifndef PHASE3_TOTAL_ROUNDS +#define PHASE3_TOTAL_ROUNDS 60 +#endif + static void phase3_run(void) { uint8_t sock = 0; uint8_t rx_buf[300] = {0}; - int i; + int counted; DBG_INFO("=== CH395F Phase 3 Tests (UDP) ==="); @@ -413,7 +839,7 @@ static void phase3_run(void) { HAL_Delay(200); /* - * 循环接收并回显，最多 30 轮。 + * 计数式回显循环：累计 PHASE3_TOTAL_ROUNDS 个有效数据包。 * CH395F UDP 接收数据格式（read_recv_buf 返回）： * [0-1] 保留 * [2-3] 源端口（大端） @@ -422,10 +848,15 @@ static void phase3_run(void) { * 回显前需根据源 IP/Port 设置目标地址，写回载荷数据。 * 每次 write_send_buf 后需等待 SENDBUF_FREE 中断，确保数据已 * 从 MCU 传输到 CH395F 内部发送缓冲，避免后续接收覆盖。 + * + * "HELLO"(5B) 为 PC 就绪探针：照常回显但不计入轮次， + * 使脚本探针阶段不占用用例预算（与 udp_client 脚本约定）。 */ - for (i = 0; i < 30; i++) { + counted = 0; + while (counted < PHASE3_TOTAL_ROUNDS) { uint32_t tick = HAL_GetTick(); int echo_ok = 0; + int is_probe = 0; while (HAL_GetTick() - tick < 30000) { uint16_t rlen = ch395f_get_recv_len(sock); if (rlen > 8) { @@ -437,6 +868,9 @@ static void phase3_run(void) { uint8_t *src_ip = &rx_buf[4]; uint8_t *payload = &rx_buf[8]; + is_probe = (payload_len == 5 && + memcmp(payload, "HELLO", 5) == 0); + ch395f_set_des_ip(sock, src_ip); ch395f_set_des_port(sock, src_port); ch395f_write_send_buf(sock, payload, payload_len); @@ -455,8 +889,15 @@ static void phase3_run(void) { } HAL_Delay(50); } - TEST_CHECK(echo_ok, "UDP echo #%d", i + 1); - if (!echo_ok) break; + + if (!echo_ok) { + TEST_CHECK(0, "UDP echo #%d timeout", counted + 1); + break; + } + if (!is_probe) { + counted++; + TEST_CHECK(1, "UDP echo #%d", counted); + } } ch395f_close_socket(sock); @@ -466,121 +907,7 @@ static void phase3_run(void) { #endif /* =================================================================== - * Phase 4 — NET 层 TCP Echo（基础收发） - * - * 测试目的：验证 BSD Socket API（net_socket）的单连接 TCP Echo 通路。 - * Socket 0 复用监听和数据通道。PC 发任意数据，MCU 原样返回。 - * 这是 Phase 5/7/8/10 的基础。 - * - * 入口条件：Socket 0 处于 ESTABLISHED（TCP 连接已建立）。 - * 通过：数据收发一致。 - * 失败：send/recv 数量不匹配。 - * =================================================================== */ - -#ifdef ENABLE_PHASE4_TESTS -static uint32_t s_phase4_count = 0; - -static void phase4_run(int sockfd) { - /* - * 使用 NET_MSG_DONTWAIT 非阻塞接收 —— 没有数据时立即返回， - * 不阻塞任务循环（Phase 5/7/8/10 也共享同一个循环）。 - * 收到数据后立即原样发送回显。 - */ - int n = net_recv(sockfd, s_rx_buf, TEST_BUF_SIZE, NET_MSG_DONTWAIT); - if (n > 0) { - int sent = net_send(sockfd, s_rx_buf, n, 0); - if (sent != n) { - DBG_ERROR("echo: send %d != recv %d", sent, n); - return; - } - s_phase4_count++; - if (s_phase4_count <= 10 || (s_phase4_count % 100 == 0)) { - DBG_INFO("Phase4: echo #%lu (%d bytes)", s_phase4_count, n); - } - } -} -#endif - -/* =================================================================== - * Phase 5 — 大文件传输（超过 CH395F 硬件缓冲 4KB） - * - * 测试目的：验证超过 Socket 0 接收缓冲（4KB）的数据在 net_send/ - * net_recv 层的正确处理。net_send_locked 自动将大数据 - * 拆分为 ≤4096B 的块，每块通过一次 DMA 事务写入 CH395F。 - * 接收端同样分多次调用 ch395f_read_recv_buf 读空硬件缓冲。 - * - * 数据模式：递增字节（s_tx_buf[i] = i & 0xFF），接收端按 offset 逐字节比对。 - * 通过：全部 20480 字节逐字节匹配。 - * 失败：任意字节不一致或收发过程中断。 - * =================================================================== */ - -#ifdef ENABLE_PHASE5_TESTS -#define PHASE5_FILE_SIZE 20480 - -static void phase5_fill(uint8_t *buf, uint32_t size) { - for (uint32_t i = 0; i < size; i++) { - buf[i] = (uint8_t)(i & 0xFF); - } -} - -static int phase5_verify(uint8_t *buf, uint32_t size, uint32_t offset) { - for (uint32_t i = 0; i < size; i++) { - if (buf[i] != (uint8_t)((offset + i) & 0xFF)) { - DBG_ERROR("Phase5: mismatch at %lu (expect 0x%02X, got 0x%02X)", - offset + i, (uint8_t)((offset + i) & 0xFF), buf[i]); - return 0; - } - } - return 1; -} - -static void phase5_run(int sockfd) { - DBG_INFO("Phase5: starting %d-byte file transfer", PHASE5_FILE_SIZE); - - phase5_fill(s_tx_buf, PHASE5_FILE_SIZE); - - /* - * 发送阶段：分块发送，每块最多 4096B。 - * net_send 内部通过消息队列转发到 netTask，由 net_send_locked - * 按 CH395F_SPI_DMA_MAX_PAYLOAD（4096）自动拆分 DMA 事务。 - * 等待 PC 端回显（echod）全部数据。 - */ - uint32_t sent = 0; - while (sent < PHASE5_FILE_SIZE) { - int chunk = (PHASE5_FILE_SIZE - sent) > 4096 ? 4096 : (PHASE5_FILE_SIZE - sent); - int n = net_send(sockfd, s_tx_buf + sent, chunk, 0); - if (n <= 0) { - DBG_ERROR("Phase5: send fail at %lu (ret=%d)", sent, n); - return; - } - sent += (uint32_t)n; - DBG_INFO("Phase5: sent %lu/%d", sent, PHASE5_FILE_SIZE); - } - - /* - * 接收阶段：分块接收，逐块验证。 - * PC 回显数据需与发送数据逐字节一致（递增模式）。 - * 验证失败立即返回，不继续接收剩余数据。 - */ - uint32_t recvd = 0; - while (recvd < PHASE5_FILE_SIZE) { - int n = net_recv(sockfd, s_rx_buf, TEST_BUF_SIZE, 0); - if (n <= 0) { - DBG_ERROR("Phase5: recv fail at %lu (ret=%d)", recvd, n); - return; - } - int ok = phase5_verify(s_rx_buf, (uint32_t)n, recvd); - TEST_CHECK(ok, "Phase5: verify at %lu (%d bytes)", recvd, n); - if (!ok) return; - recvd += (uint32_t)n; - } - - TEST_CHECK(1, "Phase5: %d-byte file transfer complete", PHASE5_FILE_SIZE); -} -#endif - -/* =================================================================== - * Phase 6 — DHCP 自动获取 IP + * Phase 4 — DHCP 自动获取 IP * * 测试目的：验证 CH395F DHCP 客户端功能，包括： * 1. DHCP DISCOVER → OFFER → REQUEST → ACK 完整握手 @@ -594,18 +921,23 @@ static void phase5_run(int sockfd) { * 失败：DHCP 超时或 HELLO 无响应。 * =================================================================== */ -#ifdef ENABLE_PHASE6_TESTS -#ifndef PHASE6_ANNOUNCE_PORT -#define PHASE6_ANNOUNCE_PORT 60001 +#ifdef ENABLE_PHASE4_TESTS +#ifndef PHASE4_ANNOUNCE_PORT +#define PHASE4_ANNOUNCE_PORT 60001 #endif -#ifndef PHASE6_ANNOUNCE_SOCK -#define PHASE6_ANNOUNCE_SOCK 6 +#ifndef PHASE4_ANNOUNCE_SOCK +#define PHASE4_ANNOUNCE_SOCK 6 +#endif +#ifndef PHASE4_HELLO_WAIT_MS +#define PHASE4_HELLO_WAIT_MS 30000 /* HELLO 回显窗：PC 在 ACK 后固定 sleep(3)s， + * 窗口须覆盖 PC 侧启动延迟（旧值 5s 重叠仅 ~2s） */ #endif -static void phase6_run(void) { +static void phase4_run(void) { uint8_t ip_info[20] = {0}; + int same = 0; - DBG_INFO("=== CH395F Phase 6 Tests (DHCP) ==="); + DBG_INFO("=== CH395F Phase 4 Tests (DHCP) ==="); /* * 启用 DHCP：ch395f_set_dhcp(1) 使 CH395F 进入 DHCP 自动协商。 @@ -624,9 +956,37 @@ static void phase6_run(void) { HAL_Delay(500); } TEST_CHECK(dhcp_ok, "DHCP completed within 30s"); - if (!dhcp_ok) goto phase6_end; + if (!dhcp_ok) goto phase4_end; + + /* + * IP 寄存器提交滞后（2026-08-24 上板实测）：DHCP 状态已置成功、 + * 芯片已按新租约通信，但此刻 get_ip_inf 仍回读旧静态配置—— + * 串口打印与宣告广播会带出过期 IP。 + * 对策：轮询直至连续 3 次（间隔 300ms）读到相同非零值才采信。 + */ + { + uint8_t last[20] = {0}; + tick = HAL_GetTick(); + while (HAL_GetTick() - tick < 8000) { + memset(ip_info, 0, sizeof(ip_info)); + ch395f_get_ip_inf(ip_info); + if ((ip_info[0] || ip_info[1] || ip_info[2] || ip_info[3]) && + memcmp(last, ip_info, sizeof(ip_info)) == 0) { + if (++same >= 3) break; + } else { + same = 0; + } + if (memcmp(last, ip_info, sizeof(ip_info)) != 0) { + DBG_INFO(" DHCP IP report: %d.%d.%d.%d", + ip_info[0], ip_info[1], ip_info[2], ip_info[3]); + memcpy(last, ip_info, sizeof(ip_info)); + } + HAL_Delay(300); + } + memcpy(ip_info, last, sizeof(ip_info)); + } + TEST_CHECK(same >= 3, "IP registers settled (3 consecutive reads)"); - ch395f_get_ip_inf(ip_info); DBG_INFO(" IP: %d.%d.%d.%d", ip_info[0], ip_info[1], ip_info[2], ip_info[3]); TEST_CHECK(ip_info[0]!=0||ip_info[1]!=0||ip_info[2]!=0||ip_info[3]!=0, "IP non-zero"); @@ -637,7 +997,7 @@ static void phase6_run(void) { * 然后等待 PC 回复 HELLO（5 字节），收到后原样回显。 */ { - uint8_t anno_sock = PHASE6_ANNOUNCE_SOCK; + uint8_t anno_sock = PHASE4_ANNOUNCE_SOCK; uint8_t bcast[4] = {0xFF,0xFF,0xFF,0xFF}; uint8_t rx_buf[64] = {0}; @@ -650,7 +1010,7 @@ static void phase6_run(void) { if (ch395f_open_socket(anno_sock) == CH395F_ERR_SUCCESS) { ch395f_set_des_ip(anno_sock, bcast); - ch395f_set_des_port(anno_sock, PHASE6_ANNOUNCE_PORT); + ch395f_set_des_port(anno_sock, PHASE4_ANNOUNCE_PORT); ch395f_write_send_buf(anno_sock, ip_info, 4); uint32_t sw = HAL_GetTick(); while (HAL_GetTick() - sw < 2000) { @@ -667,7 +1027,7 @@ static void phase6_run(void) { int hello_ok = 0; uint32_t wait = HAL_GetTick(); - while (HAL_GetTick() - wait < 5000) { + while (HAL_GetTick() - wait < PHASE4_HELLO_WAIT_MS) { ch395f_get_glob_int_status_all(); uint16_t rlen = ch395f_get_recv_len(anno_sock); if (rlen > 8) { @@ -688,18 +1048,425 @@ static void phase6_run(void) { } HAL_Delay(50); } - TEST_CHECK(hello_ok, "HELLO echo within 5s"); + TEST_CHECK(hello_ok, "HELLO echo within %dms", PHASE4_HELLO_WAIT_MS); ch395f_close_socket(anno_sock); } } -phase6_end: - TEST_REPORT("Phase 6"); +phase4_end: + TEST_REPORT("Phase 4"); } #endif /* =================================================================== - * Phase 7 — Select/Poll I/O 多路复用 + * Phase 5 — 大文件传输（硬件层裸命令） + * + * 测试目的：不依赖 net_socket/netTask，直接用 ch395f_* 命令验证 + * TCP 批量数据搬运能力： + * 1. 裸命令建立 TCP Client 连接（open/connect/等 CONNECT） + * 2. 顺序双测向：先连续发送 256KB（PC 只收不回声，SENBUF_FREE 流控）， + * 再连续接收 256KB（PC 按相同 LCG 模式回放，滚动校验），内存 O(CHUNK) + * 3. 全量累加和 TX/RX 对总账 + 双向独立吞吐基线 + * + * PC 配合：python test/ch395f_socket_test.py tcp_bulk --port 8081 --bulk 262144 --chunk 4096 + * （先收满 256KB 不回声，再按 LCG 模式回放 256KB） + * 通过：全部块校验一致，且 SUM(TX)==SUM(RX)。 + * 失败：连接超时 / SENBUF_FREE 超时 / RX 停滞 / 数据不一致。 + * =================================================================== */ + +#ifdef ENABLE_PHASE5_TESTS + +/* 回传参数（TC-NET-512 合规测试时按档位修改重编译） */ +#ifndef PHASE5_REMOTE_IP +#define PHASE5_REMOTE_IP "192.168.1.2" +#endif +#ifndef PHASE5_REMOTE_PORT +#define PHASE5_REMOTE_PORT 8081 /* PC tcp_server 监听端口 */ +#endif +#ifndef PHASE5_LOCAL_PORT +#define PHASE5_LOCAL_PORT 50010 +#endif +#ifndef PHASE5_TOTAL_BYTES +#define PHASE5_TOTAL_BYTES (256*1024) /* 回传总量 */ +#endif +#ifndef PHASE5_CHUNK_SIZE +#define PHASE5_CHUNK_SIZE 4093 /* 单块 = socket 默认发送缓冲，DP-04 边界 */ +#endif +#ifndef PHASE5_CONN_TIMEOUT_MS +#define PHASE5_CONN_TIMEOUT_MS 15000 +#endif +#define PHASE5_TX_TIMEOUT_MS 2000 /* 单块 SENBUF_FREE 等待上限 */ +#define PHASE5_RX_STALL_TIMEOUT_MS 5000 /* 发送完成后 RX 无进展上限 */ + +/* 32 位累加和：足以发现丢字节/错位，比 CRC32 便宜 */ +static uint32_t phase5_sum32(const uint8_t *p, uint32_t n) { + uint32_t s = 0; + while (n--) s += *p++; + return s; +} + +/* 按块索引确定性生成模式数据（LCG）：发送与回读两侧可独立复现，逐字节比对 */ +static void phase5_gen_block(uint8_t *buf, uint32_t idx) { + uint32_t seed = 0xC2D2E6F9u ^ (idx * 2654435761u); + uint32_t k; + + for (k = 0; k < PHASE5_CHUNK_SIZE; k++) { + seed = seed * 1664525u + 1013904223u; + buf[k] = (uint8_t)(seed >> 24); + } +} + +static void phase5_run(void) { + static uint8_t tx[PHASE5_CHUNK_SIZE]; + static uint8_t rx[PHASE5_CHUNK_SIZE]; + static uint8_t exp[PHASE5_CHUNK_SIZE]; + uint8_t sock = 0; + uint8_t ip_arr[4]; + int chunks; + int bad = 0; + int conn_ok = 0; + int blk_tx = 0; + int blk_rx = 0; + int can_write = 1; + int progress_64k = -1; + uint32_t send_bytes; + uint32_t sum_tx = 0; + uint32_t sum_rx = 0; + uint32_t rx_total = 0; + uint32_t exp_off = 0; + uint32_t rx_stall = 0; + uint32_t tx_sw = 0; + uint32_t t0; + + DBG_INFO("=== CH395F Phase 5 Tests (HW Bulk Transfer) ==="); + DBG_INFO(" target %s:%d, %d bytes x %d B/chunk", + PHASE5_REMOTE_IP, PHASE5_REMOTE_PORT, + PHASE5_TOTAL_BYTES, PHASE5_CHUNK_SIZE); + + /* + * 步1：裸命令建立 TCP 连接。 + * 先 close 清理上轮残留（结果不关心），再配置并 connect。 + */ + (void)ch395f_close_socket(sock); + HAL_Delay(50); + ch395f_set_proto_type(sock, CH395F_PROTO_TYPE_TCP); + test_parse_ip(PHASE5_REMOTE_IP, ip_arr); + ch395f_set_des_ip(sock, ip_arr); + ch395f_set_des_port(sock, PHASE5_REMOTE_PORT); + ch395f_set_sour_port(sock, PHASE5_LOCAL_PORT); + TEST_CHECK(ch395f_open_socket(sock) == CH395F_ERR_SUCCESS && + ch395f_tcp_connect(sock) == CH395F_ERR_SUCCESS, + "step1 open+connect issued"); + if (ch395f_get_cmd_status() != CH395F_ERR_SUCCESS) { + TEST_REPORT("Phase 5"); + return; + } + + t0 = HAL_GetTick(); + while (HAL_GetTick() - t0 < PHASE5_CONN_TIMEOUT_MS) { + uint16_t gs = ch395f_get_glob_int_status_all(); + if ((gs & (1U << (sock + 4))) && + (ch395f_get_sock_int_status(sock) & CH395F_SINT_STAT_CONNECT)) { + conn_ok = 1; + break; + } + HAL_Delay(10); + } + TEST_CHECK(conn_ok, "connected within %dms", PHASE5_CONN_TIMEOUT_MS); + if (!conn_ok) { + (void)ch395f_close_socket(sock); + TEST_REPORT("Phase 5"); + return; + } + + /* + * 步2A：连续发送 256KB（单向，PC 只收不回声）。 + * 节奏：写 4096B → 等 SENBUF_FREE（芯片搬走数据后触发）→ 写下一块， + * 全程不等回显，测得纯 TX 吞吐。 + * 步2B：连续接收 256KB（PC 收到 256KB 后按相同 LCG 模式回放）， + * 对字节流做滚动校验（期望流按块生成 exp[]，字节对位 + sum_rx 累加）， + * 天然处理 TCP 分包/粘包，测得纯 RX 吞吐。 + */ + chunks = PHASE5_TOTAL_BYTES / PHASE5_CHUNK_SIZE; + send_bytes = (uint32_t)chunks * PHASE5_CHUNK_SIZE; /* 实际上送字节（4093 档 < TOTAL，余尾不送） */ + + /* ---- 步2A：连续发送 ---- + * 目标：把 chunks×PHASE5_CHUNK_SIZE 字节按 LCG 模式数据一次性连续交出， + * 全程不等回显，测得纯 TX 吞吐。 + * + * 发送状态机（can_write 标志）： + * can_write == 1 : 发送缓冲空闲，可写入下一块 + * can_write == 0 : 上一块已写入，等待芯片把数据搬出 socket 发送缓冲 + * （首次进入 can_write 初始为 1，因为连接建立后发送缓冲为空） + * + * 芯片写节奏约束（CH395 手册 / Trap 记录）： + * 每次 WRITE_SEND_BUF 后必须收到 SINT_STAT_SENBUF_FREE 才能再次写入， + * 否则下次写入会被芯片静默丢弃。SENBUF_FREE 表示芯片已把本次写入的数据 + * 从 socket 发送缓冲搬到内部协议栈/MAC 缓冲（腾出空间），故每写一块 + * 就转 can_write=0 等待该事件——这正是"连续发送"的天然流控节拍， + * 不会因超过发送缓冲（默认 4096B）而溢出。 + */ + { + uint32_t tx_t0 = HAL_GetTick(); /* 发送阶段起点：用于计算 TX 吞吐 */ + blk_tx = 0; /* 已交出的块计数 */ + can_write = 1; /* 初始：连接后发送缓冲为空，可直接写 */ + while (blk_tx < chunks && !bad) { + if (can_write) { + /* ---- 发送缓冲空闲：生成并写入一块 ---- */ + phase5_gen_block(tx, (uint32_t)blk_tx); /* 确定性生成第 blk_tx 块模式（TX/RX 可复现） */ + sum_tx += phase5_sum32(tx, PHASE5_CHUNK_SIZE); /* 先累加发送侧总账（与 RX 侧对账用） */ + ch395f_write_send_buf(sock, tx, PHASE5_CHUNK_SIZE); /* 4096B 单次写入（= 发送缓冲上限，DP-04 边界） */ + blk_tx++; /* 该块已交出 */ + can_write = 0; /* 进入等待 SENBUF_FREE 状态 */ + tx_sw = HAL_GetTick(); /* 记录等待起点（供超时判定） */ + } else { + /* ---- 等待上一次写入被芯片搬走（SENBUF_FREE） ---- + * 两级中断轮询（DP-02）：先读全局中断状态确认本 socket 有事件， + * 再读该 socket 的中断状态确认具体为 SENBUF_FREE。 + * 读全局中断状态即清除中断标志（读即清）。 + */ + uint16_t gs = ch395f_get_glob_int_status_all(); + if ((gs & (1U << (sock + 4))) && /* socket 中断位（socket 0 → bit 4） */ + (ch395f_get_sock_int_status(sock) & CH395F_SINT_STAT_SENBUF_FREE)) { + can_write = 1; /* 缓冲已腾空，下一轮写入下一块 */ + } else if (HAL_GetTick() - tx_sw >= PHASE5_TX_TIMEOUT_MS) { + /* 超时：芯片迟迟未腾出缓冲 —— 对端未收/链路异常/芯片堵死 */ + bad++; + DBG_ERROR("TX SENBUF_FREE stall @chunk %d", blk_tx); + break; + } + } + /* ---- 进度打印（每交出 64KB 打一行） ---- */ + if ((int)(((uint32_t)blk_tx * PHASE5_CHUNK_SIZE) / (64 * 1024)) != progress_64k) { + progress_64k = (int)(((uint32_t)blk_tx * PHASE5_CHUNK_SIZE) / (64 * 1024)); + DBG_INFO(" TX %d/%d blocks (%lu bytes)", blk_tx, chunks, + (uint32_t)blk_tx * PHASE5_CHUNK_SIZE); + } + } + /* 全部块已写入发送缓冲即视为发送完成：最后一块已交给芯片， + * 无需再等其 SENBUF_FREE，数据会随 TCP 正常发往对端。 */ + TEST_CHECK(bad == 0, "TX phase: %d/%d blocks (%lu bytes)", + blk_tx, chunks, (uint32_t)blk_tx * PHASE5_CHUNK_SIZE); + { + uint32_t ms = HAL_GetTick() - tx_t0; + DBG_INFO(" TX throughput: %lu bytes in %lums (%lu KB/s)", + (uint32_t)blk_tx * PHASE5_CHUNK_SIZE, ms, + ms > 0 ? (uint32_t)(((uint32_t)blk_tx * PHASE5_CHUNK_SIZE) / ms) : 0u); + } + } + + /* ---- 步2B：连续接收 ---- + * 目标：PC 收到 256KB 后按相同 LCG 模式回放，MCU 连续排空接收缓冲并对 + * 字节流做滚动校验，测得纯 RX 吞吐。 + * + * 滚动校验原理： + * 期望流按块确定性生成，同一时刻只保留当前块的 exp[]（内存 O(CHUNK)）。 + * exp_off 指向当前期望块内的偏移；回显流可能分包/粘包，故按"字节流"消费： + * 每次读到 rlen 字节 → 切成若干段（take，每段不超过当前期望块剩余）逐字节 + * 与 exp[exp_off+k] 比对，同时累加 sum_rx；当前块消费完（exp_off==CHUNK） + * 则回绕并生成下一块期望 —— 与 TCP 的分包/粘包边界完全解耦。 + * + * 停滞检测（rx_stall）： + * 记录"最后收到数据"的时刻，>PHASE5_RX_STALL_TIMEOUT_MS 无新数据即失败。 + * 用最后进度而非阶段起点，是为了兼容 PC 端回放开始的延迟与块间间隙。 + */ + if (!bad) { + uint32_t rx_t0 = HAL_GetTick(); /* 接收阶段起点：用于计算 RX 吞吐 */ + exp_off = 0; /* 当前期望块内的消费偏移 */ + blk_rx = 0; /* 已完整校验的块数 */ + rx_total = 0; /* 已接收字节总数 */ + rx_stall = rx_t0; /* 最后收到数据的时刻（停滞检测基准） */ + progress_64k = -1; /* 重置进度打印基准（TX 阶段已推进过） */ + phase5_gen_block(exp, 0); /* 预生成第 0 块期望数据 */ + while (!bad && rx_total < send_bytes) { + /* ---- 排空接收缓冲：一次可能读出多包数据，全部消费完再进入下一步 ---- */ + for (;;) { + uint16_t rlen = ch395f_get_recv_len(sock); /* 查询当前可读字节数 */ + if (rlen == 0) { + break; /* 缓冲空，跳出排空循环 */ + } + if (rlen > PHASE5_CHUNK_SIZE) { + rlen = PHASE5_CHUNK_SIZE; /* 单次读取上限 = 块大小（DP-04 4KB DMA 边界） */ + } + ch395f_read_recv_buf(sock, rx, rlen); /* 一次 SPI 事务读走 rlen 字节 */ + { + uint32_t off = 0; /* 本次读取数据内的消费偏移 */ + while (off < rlen) { + uint32_t take = PHASE5_CHUNK_SIZE - exp_off; /* 当前期望块剩余 */ + uint32_t k; + if (take > (uint32_t)(rlen - off)) { + take = rlen - off; /* 截断：本次读取只消费到块边界为止 */ + } + for (k = 0; k < take; k++) { + uint8_t b = rx[off + k]; + if (b != exp[exp_off + k]) { + bad++; /* 逐字节比对失败（定位精确偏移） */ + DBG_ERROR("rx mismatch @%lu", rx_total + off + k); + } + sum_rx += b; /* 同时累加接收侧总账 */ + } + off += take; + exp_off += take; + rx_total += take; + if (exp_off == PHASE5_CHUNK_SIZE) { + exp_off = 0; /* 当前块消费完：回绕并预生成下一块期望 */ + blk_rx++; + if (blk_rx < chunks) { + phase5_gen_block(exp, blk_rx); + } + } + } + } + rx_stall = HAL_GetTick(); /* 有数据到达：推进停滞检测基准 */ + } + if (bad) { + break; + } + /* ---- 停滞保护：发送方已回放完或链路异常，迟迟无新数据 ---- */ + if (HAL_GetTick() - rx_stall >= PHASE5_RX_STALL_TIMEOUT_MS) { + bad++; + DBG_ERROR("RX stall @%lu/%lu", rx_total, send_bytes); + break; + } + /* ---- 进度打印（每收到 64KB 打一行） ---- */ + if ((int)(rx_total / (64 * 1024)) != progress_64k) { + progress_64k = (int)(rx_total / (64 * 1024)); + DBG_INFO(" RX %lu/%lu bytes (%d blocks)", rx_total, send_bytes, blk_rx); + } + HAL_Delay(2); /* 轮询间隔：让出总线/降低 SPI 事务频率 */ + } + TEST_CHECK(bad == 0, "RX phase: %lu/%lu bytes (%d blocks)", rx_total, send_bytes, blk_rx); + { + uint32_t ms = HAL_GetTick() - rx_t0; + DBG_INFO(" RX throughput: %lu bytes in %lums (%lu KB/s)", + rx_total, ms, + ms > 0 ? (uint32_t)(rx_total / ms) : 0u); + } + } + TEST_CHECK(sum_tx == sum_rx, "checksum TX==RX (%08x/%08x)", sum_tx, sum_rx); + + /* 步3：关闭，PC 侧应统计到收满 256KB（校验一致）并回放完成 */ + ch395f_close_socket(sock); + TEST_CHECK(1, "socket closed"); + TEST_REPORT("Phase 5"); +} +#endif +/* =================================================================== + * Phase 6 — NET 层 TCP Echo（基础收发） + * + * 测试目的：验证 BSD Socket API（net_socket）的单连接 TCP Echo 通路。 + * Socket 0 复用监听和数据通道。PC 发任意数据，MCU 原样返回。 + * 这是 Phase 7/8/9/10 的基础。 + * + * 入口条件：Socket 0 处于 ESTABLISHED（TCP 连接已建立）。 + * 通过：数据收发一致。 + * 失败：send/recv 数量不匹配。 + * =================================================================== */ + +#ifdef ENABLE_PHASE6_TESTS +static uint32_t s_phase6_count = 0; + +static void phase6_run(int sockfd) { + /* + * 使用 NET_MSG_DONTWAIT 非阻塞接收 —— 没有数据时立即返回， + * 不阻塞任务循环（Phase 7/8/9/10 也共享同一个循环）。 + * 收到数据后立即原样发送回显。 + */ + int n = net_recv(sockfd, s_rx_buf, TEST_BUF_SIZE, NET_MSG_DONTWAIT); + if (n > 0) { + int sent = net_send(sockfd, s_rx_buf, n, 0); + if (sent != n) { + DBG_ERROR("echo: send %d != recv %d", sent, n); + return; + } + s_phase6_count++; + if (s_phase6_count <= 10 || (s_phase6_count % 100 == 0)) { + DBG_INFO("Phase6: echo #%lu (%d bytes)", s_phase6_count, n); + } + } +} +#endif + +/* =================================================================== + * Phase 7 — 大文件传输（超过 CH395F 硬件缓冲 4KB） + * + * 测试目的：验证超过 Socket 0 接收缓冲（4KB）的数据在 net_send/ + * net_recv 层的正确处理。net_send_locked 自动将大数据 + * 拆分为 ≤4096B 的块，每块通过一次 DMA 事务写入 CH395F。 + * 接收端同样分多次调用 ch395f_read_recv_buf 读空硬件缓冲。 + * + * 数据模式：递增字节（s_tx_buf[i] = i & 0xFF），接收端按 offset 逐字节比对。 + * 通过：全部 20480 字节逐字节匹配。 + * 失败：任意字节不一致或收发过程中断。 + * =================================================================== */ + +#ifdef ENABLE_PHASE7_TESTS +#define PHASE7_FILE_SIZE 20480 + +static void phase7_fill(uint8_t *buf, uint32_t size) { + for (uint32_t i = 0; i < size; i++) { + buf[i] = (uint8_t)(i & 0xFF); + } +} + +static int phase7_verify(uint8_t *buf, uint32_t size, uint32_t offset) { + for (uint32_t i = 0; i < size; i++) { + if (buf[i] != (uint8_t)((offset + i) & 0xFF)) { + DBG_ERROR("Phase7: mismatch at %lu (expect 0x%02X, got 0x%02X)", + offset + i, (uint8_t)((offset + i) & 0xFF), buf[i]); + return 0; + } + } + return 1; +} + +static void phase7_run(int sockfd) { + DBG_INFO("Phase7: starting %d-byte file transfer", PHASE7_FILE_SIZE); + + phase7_fill(s_tx_buf, PHASE7_FILE_SIZE); + + /* + * 发送阶段：分块发送，每块最多 4096B。 + * net_send 内部通过消息队列转发到 netTask，由 net_send_locked + * 按 CH395F_SPI_DMA_MAX_PAYLOAD（4096）自动拆分 DMA 事务。 + * 等待 PC 端回显（echod）全部数据。 + */ + uint32_t sent = 0; + while (sent < PHASE7_FILE_SIZE) { + int chunk = (PHASE7_FILE_SIZE - sent) > 4096 ? 4096 : (PHASE7_FILE_SIZE - sent); + int n = net_send(sockfd, s_tx_buf + sent, chunk, 0); + if (n <= 0) { + DBG_ERROR("Phase7: send fail at %lu (ret=%d)", sent, n); + return; + } + sent += (uint32_t)n; + DBG_INFO("Phase7: sent %lu/%d", sent, PHASE7_FILE_SIZE); + } + + /* + * 接收阶段：分块接收，逐块验证。 + * PC 回显数据需与发送数据逐字节一致（递增模式）。 + * 验证失败立即返回，不继续接收剩余数据。 + */ + uint32_t recvd = 0; + while (recvd < PHASE7_FILE_SIZE) { + int n = net_recv(sockfd, s_rx_buf, TEST_BUF_SIZE, 0); + if (n <= 0) { + DBG_ERROR("Phase7: recv fail at %lu (ret=%d)", recvd, n); + return; + } + int ok = phase7_verify(s_rx_buf, (uint32_t)n, recvd); + TEST_CHECK(ok, "Phase7: verify at %lu (%d bytes)", recvd, n); + if (!ok) return; + recvd += (uint32_t)n; + } + + TEST_CHECK(1, "Phase7: %d-byte file transfer complete", PHASE7_FILE_SIZE); +} +#endif + +/* =================================================================== + * Phase 8 — Select/Poll I/O 多路复用 * * 测试目的：验证 net_select() API 在单 Socket 模式下正确工作： * 1. Socket 0 有数据到达时 select 返回正数 @@ -711,11 +1478,11 @@ phase6_end: * 失败：select 未检测到数据或回显失败。 * =================================================================== */ -#ifdef ENABLE_PHASE7_TESTS +#ifdef ENABLE_PHASE8_TESTS #include "net_select.h" -static uint32_t s_phase7_count = 0; +static uint32_t s_phase8_count = 0; -static void phase7_run(int sockfd) { +static void phase8_run(int sockfd) { net_fd_set readfds; net_timeval tv; @@ -738,8 +1505,8 @@ static void phase7_run(int sockfd) { if (n > 0) { int sent = net_send(sockfd, s_rx_buf, n, 0); if (sent == n) { - s_phase7_count++; - TEST_CHECK(1, "Phase7: select echo #%lu (%d bytes)", s_phase7_count, n); + s_phase8_count++; + TEST_CHECK(1, "Phase8: select echo #%lu (%d bytes)", s_phase8_count, n); } } } @@ -747,7 +1514,7 @@ static void phase7_run(int sockfd) { #endif /* =================================================================== - * Phase 8 — 边界条件测试 + * Phase 9 — 边界条件测试 * * 测试目的：验证以下 DMA 和协议栈边界情况： * 1. TC-NET-801: 4095B（SPI 最大载荷 -1，单次 DMA 容纳） @@ -756,7 +1523,7 @@ static void phase7_run(int sockfd) { * 4. TC-NET-804: 零长度发送（返回 -1） * 5. TC-NET-805: 20 × 100B 连续快速发送 * - * 各用例通过状态机（s_phase8_stage）串行执行，每次 phase8_run 推进一个 + * 各用例通过状态机（s_phase9_stage）串行执行，每次 phase9_run 推进一个 * 步骤（发送→等待→接收→验证→下一阶段）。发送数据为递增模式字节 * （buf[i] = seed + i），接收端按相同模式验证。 * @@ -764,128 +1531,128 @@ static void phase7_run(int sockfd) { * 通过：各用例自身判定。 * =================================================================== */ -#ifdef ENABLE_PHASE8_TESTS -static int s_phase8_stage = 0; -static uint32_t s_phase8_recv = 0; +#ifdef ENABLE_PHASE9_TESTS +static int s_phase9_stage = 0; +static uint32_t s_phase9_recv = 0; -static void phase8_fill(uint8_t *buf, uint32_t size, uint8_t seed) { +static void phase9_fill(uint8_t *buf, uint32_t size, uint8_t seed) { for (uint32_t i = 0; i < size; i++) { buf[i] = (uint8_t)(seed + i); } } -static int phase8_verify(uint8_t *buf, uint32_t size, uint8_t seed) { +static int phase9_verify(uint8_t *buf, uint32_t size, uint8_t seed) { for (uint32_t i = 0; i < size; i++) { if (buf[i] != (uint8_t)(seed + i)) return 0; } return 1; } -static void phase8_run(int sockfd) { +static void phase9_run(int sockfd) { /* 阶段 0 → 1：发送 4095B */ - if (s_phase8_stage == 0) { - DBG_INFO("Phase8: 4095B (DMA-1)"); - phase8_fill(s_tx_buf, 4095, 0x10); + if (s_phase9_stage == 0) { + DBG_INFO("Phase9: 4095B (DMA-1)"); + phase9_fill(s_tx_buf, 4095, 0x10); int sent = net_send(sockfd, s_tx_buf, 4095, 0); - TEST_CHECK(sent == 4095, "Phase8: send 4095B (sent=%d)", sent); - s_phase8_recv = 0; - s_phase8_stage = 1; + TEST_CHECK(sent == 4095, "Phase9: send 4095B (sent=%d)", sent); + s_phase9_recv = 0; + s_phase9_stage = 1; return; } /* 阶段 1：接收并验证 4095B 回显 */ - if (s_phase8_stage == 1) { - int n = net_recv(sockfd, s_rx_buf + s_phase8_recv, (int)(4095 - s_phase8_recv), 0); + if (s_phase9_stage == 1) { + int n = net_recv(sockfd, s_rx_buf + s_phase9_recv, (int)(4095 - s_phase9_recv), 0); if (n > 0) { - s_phase8_recv += (uint32_t)n; - if (s_phase8_recv >= 4095) { - TEST_CHECK(phase8_verify(s_rx_buf, 4095, 0x10), "Phase8: verify 4095B"); - s_phase8_stage = 2; + s_phase9_recv += (uint32_t)n; + if (s_phase9_recv >= 4095) { + TEST_CHECK(phase9_verify(s_rx_buf, 4095, 0x10), "Phase9: verify 4095B"); + s_phase9_stage = 2; } } return; } /* 阶段 2 → 3：发送 4096B（DMA 边界精确值） */ - if (s_phase8_stage == 2) { - DBG_INFO("Phase8: 4096B (DMA exact)"); - phase8_fill(s_tx_buf, 4096, 0x20); + if (s_phase9_stage == 2) { + DBG_INFO("Phase9: 4096B (DMA exact)"); + phase9_fill(s_tx_buf, 4096, 0x20); int sent = net_send(sockfd, s_tx_buf, 4096, 0); - TEST_CHECK(sent == 4096, "Phase8: send 4096B (sent=%d)", sent); - s_phase8_recv = 0; - s_phase8_stage = 3; + TEST_CHECK(sent == 4096, "Phase9: send 4096B (sent=%d)", sent); + s_phase9_recv = 0; + s_phase9_stage = 3; return; } /* 阶段 3：接收并验证 4096B 回显 */ - if (s_phase8_stage == 3) { - int n = net_recv(sockfd, s_rx_buf + s_phase8_recv, (int)(4096 - s_phase8_recv), 0); + if (s_phase9_stage == 3) { + int n = net_recv(sockfd, s_rx_buf + s_phase9_recv, (int)(4096 - s_phase9_recv), 0); if (n > 0) { - s_phase8_recv += (uint32_t)n; - if (s_phase8_recv >= 4096) { - TEST_CHECK(phase8_verify(s_rx_buf, 4096, 0x20), "Phase8: verify 4096B"); - s_phase8_stage = 4; + s_phase9_recv += (uint32_t)n; + if (s_phase9_recv >= 4096) { + TEST_CHECK(phase9_verify(s_rx_buf, 4096, 0x20), "Phase9: verify 4096B"); + s_phase9_stage = 4; } } return; } /* 阶段 4 → 5：发送 4097B（超过 DMA 上限，自动拆 4096+1） */ - if (s_phase8_stage == 4) { - DBG_INFO("Phase8: 4097B (DMA+1, 2 SPI xacts)"); - phase8_fill(s_tx_buf, 4097, 0x30); + if (s_phase9_stage == 4) { + DBG_INFO("Phase9: 4097B (DMA+1, 2 SPI xacts)"); + phase9_fill(s_tx_buf, 4097, 0x30); int sent = net_send(sockfd, s_tx_buf, 4097, 0); - TEST_CHECK(sent == 4097, "Phase8: send 4097B (sent=%d)", sent); - s_phase8_recv = 0; - s_phase8_stage = 5; + TEST_CHECK(sent == 4097, "Phase9: send 4097B (sent=%d)", sent); + s_phase9_recv = 0; + s_phase9_stage = 5; return; } /* 阶段 5：接收并验证 4097B 回显 */ - if (s_phase8_stage == 5) { - int n = net_recv(sockfd, s_rx_buf + s_phase8_recv, (int)(4097 - s_phase8_recv), 0); + if (s_phase9_stage == 5) { + int n = net_recv(sockfd, s_rx_buf + s_phase9_recv, (int)(4097 - s_phase9_recv), 0); if (n > 0) { - s_phase8_recv += (uint32_t)n; - if (s_phase8_recv >= 4097) { - TEST_CHECK(phase8_verify(s_rx_buf, 4097, 0x30), "Phase8: verify 4097B"); - s_phase8_stage = 6; + s_phase9_recv += (uint32_t)n; + if (s_phase9_recv >= 4097) { + TEST_CHECK(phase9_verify(s_rx_buf, 4097, 0x30), "Phase9: verify 4097B"); + s_phase9_stage = 6; } } return; } /* 阶段 6：零长度发送 —— 期望 net_send 返回 -1（NET_ERR_INVAL） */ - if (s_phase8_stage == 6) { - DBG_INFO("Phase8: zero-length send"); + if (s_phase9_stage == 6) { + DBG_INFO("Phase9: zero-length send"); int sent = net_send(sockfd, s_tx_buf, 0, 0); - TEST_CHECK(sent < 0, "Phase8: send 0B returns %d (expect <0)", sent); - s_phase8_stage = 7; + TEST_CHECK(sent < 0, "Phase9: send 0B returns %d (expect <0)", sent); + s_phase9_stage = 7; return; } /* 阶段 7：20 × 100B 快速发送 */ - if (s_phase8_stage == 7) { - DBG_INFO("Phase8: 20x rapid sends (100B each)"); - phase8_fill(s_tx_buf, 100, 0x40); + if (s_phase9_stage == 7) { + DBG_INFO("Phase9: 20x rapid sends (100B each)"); + phase9_fill(s_tx_buf, 100, 0x40); int all_ok = 1; for (int i = 0; i < 20; i++) { if (net_send(sockfd, s_tx_buf, 100, 0) != 100) { - TEST_CHECK(0, "Phase8: rapid #%d fail", i + 1); + TEST_CHECK(0, "Phase9: rapid #%d fail", i + 1); all_ok = 0; break; } osDelay(1); } if (all_ok) { - TEST_CHECK(1, "Phase8: 20x rapid sends OK"); - s_phase8_recv = 0; - s_phase8_stage = 8; + TEST_CHECK(1, "Phase9: 20x rapid sends OK"); + s_phase9_recv = 0; + s_phase9_stage = 8; } else { - s_phase8_stage = 0; + s_phase9_stage = 0; } return; } /* 阶段 8：接收 2000B 回显总和并验证 */ - if (s_phase8_stage == 8) { - int n = net_recv(sockfd, s_rx_buf + s_phase8_recv, (int)(2000 - s_phase8_recv), 0); + if (s_phase9_stage == 8) { + int n = net_recv(sockfd, s_rx_buf + s_phase9_recv, (int)(2000 - s_phase9_recv), 0); if (n > 0) { - s_phase8_recv += (uint32_t)n; - if (s_phase8_recv >= 2000) { - TEST_CHECK(1, "Phase8: all echo received"); - TEST_REPORT("Phase 8"); - s_phase8_stage = 0; + s_phase9_recv += (uint32_t)n; + if (s_phase9_recv >= 2000) { + TEST_CHECK(1, "Phase9: all echo received"); + TEST_REPORT("Phase 9"); + s_phase9_stage = 0; } } return; @@ -893,72 +1660,6 @@ static void phase8_run(int sockfd) { } #endif -/* =================================================================== - * Phase 9 — PHY 链路恢复 - * - * 测试目的：验证 CH395F 的 PHY 状态监测功能： - * 1. 拔网线后 net_poll 检测到 PHY_CHANGE 中断并识别 DISCONN - * 2. 插回网线后 PHY 自动恢复连接 - * - * 需物理操作（拔插网线），测试会等待最多 15s 检测断开、30s 检测重连。 - * 通过：断开和重连均被检测到。 - * 失败：任意步骤超时。 - * =================================================================== */ - -#ifdef ENABLE_PHASE9_TESTS -static void phase9_run(void) { - DBG_INFO("=== CH395F Phase 9 Tests (PHY Recovery) ==="); - - /* - * 第一步：等待 PHY 断开（需拔网线）。 - * 轮询 GINT 状态寄存器中的 PHY_CHANGE 位， - * 然后读取 PHY 状态确认是否为 DISCONN。 - * 超时 15 秒 —— 若超时未检测到，提示拔网线。 - */ - uint8_t phy_disconnected = 0; - uint32_t wait = HAL_GetTick(); - while (HAL_GetTick() - wait < 15000) { - if (ch395f_get_glob_int_status_all() & CH395F_GINT_STAT_PHY_CHANGE) { - if (ch395f_get_phy_status() == CH395F_PHY_DISCONN) { - TEST_CHECK(1, "PHY disconnect detected"); - phy_disconnected = 1; - break; - } - } - HAL_Delay(100); - } - if (!phy_disconnected) { - TEST_CHECK(0, "PHY disconnect NOT detected (unplug cable?)"); - goto phase9_end; - } - - /* - * 第二步：等待 PHY 重连（需插回网线）。 - * 同样检测 PHY_CHANGE 中断，然后读取 PHY 状态确认不是 DISCONN。 - * 超时 30 秒。 - */ - uint8_t phy_reconnected = 0; - wait = HAL_GetTick(); - while (HAL_GetTick() - wait < 30000) { - if (ch395f_get_glob_int_status_all() & CH395F_GINT_STAT_PHY_CHANGE) { - uint8_t phy = ch395f_get_phy_status(); - if (phy != CH395F_PHY_DISCONN) { - TEST_CHECK(1, "PHY reconnected (0x%02X)", phy); - phy_reconnected = 1; - break; - } - } - HAL_Delay(100); - } - if (!phy_reconnected) { - TEST_CHECK(0, "PHY reconnect NOT detected (re-plug cable?)"); - } - -phase9_end: - TEST_REPORT("Phase 9"); -} -#endif - /* =================================================================== * Phase 10 — TCP KeepAlive 超时断开 * @@ -1003,11 +1704,13 @@ static void phase10_run(int sockfd) { /* =================================================================== * 任务入口：StartCh395fTestTask * - * 执行顺序： + * 执行顺序（按构建模式二选一，见 docs/CH395F_Test_Guide.md「构建模式与执行顺序」）： + * 硬件层模式（阶段 1~5）：netTask 不创建，本任务调用 + * net_stack_bring_up() 完成协议栈初始化后独占 CH395F 阻塞执行。 + * NET 层模式（阶段 6~10）： * 1. 等待 g_net_ready（netTask 初始化完成标志） - * 2. 阻塞执行 Phase 1/2/3/6/9（各 Phase 内部有独立循环和等待） - * 3. 创建 TCP 监听 Socket（单连接模式，端口 8080） - * 4. 进入事件驱动循环，等待 PC 连接并执行 Phase 4/5/7/8/10 + * 2. 创建 TCP 监听 Socket（单连接模式，端口 8080） + * 3. 进入事件驱动循环，等待 PC 连接并执行 NET 层测试 * * 单连接模式说明： * Socket 0 复用监听和数据通道。accept 返回的 fd 与监听 fd 相同。 @@ -1019,22 +1722,33 @@ void StartCh395fTestTask(void *argument) { (void)argument; +#if defined(ENABLE_NET_LAYER_TESTS) int sockfd = -1; int phase_active = 0; uint32_t accept_retry = 0; struct net_sockaddr_in client_addr; int addrlen = sizeof(client_addr); +#endif - DBG_INFO("Test task started, waiting for netTask..."); + DBG_INFO("Test task started"); - /* 等待 netTask 完成 net_init() 及 CH395F 初始化 */ +#if defined(ENABLE_HW_LAYER_TESTS) + /* 硬件层模式（阶段 1~5）：netTask 未创建，由本任务完成一次性协议栈 + * 初始化并独占 CH395F —— 无 net_poll() 并发读取中断，无 SPI 并发事务 */ + if (net_stack_bring_up() != 0) { + DBG_ERROR("net stack bring-up FAIL"); + goto task_end; + } +#else + /* NET 层模式（阶段 6~10）：等待 netTask 完成 net_init() 及 CH395F 初始化 */ while (!g_net_ready) { osDelay(100); } DBG_INFO("netTask ready"); +#endif /* ==================== 阻塞阶段 ==================== - * Phase 1/2/3/6/9 在 TCP 监听之前执行，不依赖外部连接。 + * Phase 1~5（硬件层）在 TCP 监听之前执行，不依赖外部连接。 * 各 Phase 有各自的测试逻辑，完成后继续下一 Phase。 */ #ifdef ENABLE_PHASE1_TESTS @@ -1046,14 +1760,15 @@ void StartCh395fTestTask(void *argument) #ifdef ENABLE_PHASE3_TESTS phase3_run(); #endif -#ifdef ENABLE_PHASE6_TESTS - phase6_run(); +#ifdef ENABLE_PHASE4_TESTS + phase4_run(); #endif -#ifdef ENABLE_PHASE9_TESTS - phase9_run(); +#ifdef ENABLE_PHASE5_TESTS + phase5_run(); #endif - /* ==================== 创建 TCP 监听 ==================== */ +#ifdef ENABLE_NET_LAYER_TESTS + /* ==================== 创建 TCP 监听（NET 层模式） ==================== */ DBG_INFO("Creating test socket..."); sockfd = net_socket(NET_AF_INET, NET_SOCK_STREAM, 0); @@ -1082,7 +1797,7 @@ void StartCh395fTestTask(void *argument) DBG_INFO("Test task: listening on 8080 (single-socket mode)"); /* ==================== 事件驱动阶段 ==================== - * Phase 4/5/7/8/10 在 TCP 监听循环中运行，需要 PC 客户端连接。 + * Phase 6~10（NET 层）在 TCP 监听循环中运行，需要 PC 客户端连接。 * 没有连接时循环等待；连接建立后执行对应 Phase。 * 断开后自动重新 listen。 */ @@ -1102,8 +1817,8 @@ void StartCh395fTestTask(void *argument) DBG_INFO("Test task: client accepted (fd=%d)", acc); /* 连接建立，重置各 Phase 内部状态 */ -#ifdef ENABLE_PHASE8_TESTS - s_phase8_stage = 0; +#ifdef ENABLE_PHASE9_TESTS + s_phase9_stage = 0; #endif #ifdef ENABLE_PHASE10_TESTS s_phase10_armed = 0; @@ -1111,19 +1826,19 @@ void StartCh395fTestTask(void *argument) } /* 每 10ms 依次执行各已启用 Phase */ -#ifdef ENABLE_PHASE4_TESTS - phase4_run(sockfd); -#endif -#ifdef ENABLE_PHASE5_TESTS - phase5_run(sockfd); - phase_active = 0; /* Phase 5 一次性完成，发完即止 */ +#ifdef ENABLE_PHASE6_TESTS + phase6_run(sockfd); #endif #ifdef ENABLE_PHASE7_TESTS phase7_run(sockfd); + phase_active = 0; /* Phase 7 一次性完成，发完即止 */ #endif #ifdef ENABLE_PHASE8_TESTS phase8_run(sockfd); #endif +#ifdef ENABLE_PHASE9_TESTS + phase9_run(sockfd); +#endif #ifdef ENABLE_PHASE10_TESTS phase10_run(sockfd); #endif @@ -1146,6 +1861,7 @@ void StartCh395fTestTask(void *argument) osDelay(10); } +#endif /* ENABLE_NET_LAYER_TESTS */ task_end: for (;;) {