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 fac3bac..75c05f7 100644
Binary files a/test/__pycache__/ch395f_socket_test.cpython-311.pyc and b/test/__pycache__/ch395f_socket_test.cpython-311.pyc differ
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 (;;) {