CH395F 硬件测试完毕

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`）

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;

App/task/net_task.c

@@ -26,35 +26,21 @@
 volatile uint8_t g_net_ready = 0;
 
 /*
- * 函数功能：网络任务初始化
+ * 函数功能：CH395F 协议栈一次性初始化（两种构建模式共用）
  * 入口参数：无
  * 返 回 值：0 - 成功，-1 - 失败
- * 限定条件：CH395F 协议栈已初始化
+ * 函数说明：net_init → MAC 打印 → PHY 强制 100M 全双工 → 置 g_net_ready。
- * 函数说明：创建 TCP Server 监听 Socket，注册回调等
+ *          NET 层模式由 netTask 调用；硬件层模式（阶段 1~5）netTask 不创建，
+ *          由 ch395fTestTask 调用后独占 CH395F。
  */
-int net_task_init(void)
+int net_stack_bring_up(void)
 {
-    DBG_INFO("net_task_init");
-    return 0;
-}
-
-/*
- * 函数功能：网络任务主函数
- * 入口参数：arg - FreeRTOS 传入参数（未使用）
- * 返 回 值：无
- * 函数说明：启动后先调用 net_init 初始化 CH395F 协议栈，创建 TCP 监听，
- *          再进入轮询循环处理网络事件
- */
-void net_task_func(void const *arg)
-{
-    (void)arg;
-
-    osDelay(2000);
-
-    /* ==================== CH395F 协议栈初始化 ==================== */
     DBG_INFO("=== Network Init ===");
 
-    if (net_init("192.168.1.100", "255.255.255.0", "192.168.1.1") == 0) {
+    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];
@@ -71,9 +57,43 @@ void net_task_func(void const *arg)
              (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 {
+    return 0;
-        DBG_ERROR("net init: FAIL");
+}
+
+/*
+ * 函数功能：网络任务初始化
+ * 入口参数：无
+ * 返 回 值：0 - 成功，-1 - 失败
+ * 限定条件：CH395F 协议栈已初始化
+ * 函数说明：创建 TCP Server 监听 Socket，注册回调等
+ */
+int net_task_init(void)
+{
+    DBG_INFO("net_task_init");
+    return 0;
+}
+
+/*
+ * 函数功能：网络任务主函数
+ * 入口参数：arg - FreeRTOS 传入参数（未使用）
+ * 返 回 值：无
+ * 函数说明：启动后先调用 net_stack_bring_up() 初始化 CH395F 协议栈，
+ *          再进入轮询循环处理网络事件。
+ *          仅 NET 层测试模式（阶段 6~10）会创建本任务；
+ *          硬件层模式下 netTask 不创建，CH395F 由 ch395fTestTask 独占。
+ */
+void net_task_func(void const *arg)
+{
+    (void)arg;
+
+    osDelay(2000);
+
+    if (net_stack_bring_up() != 0) {
+        for (;;) {
+            osDelay(1000);
+        }
     }
 
     DBG_INFO("netTask: started (single-socket mode)");

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);
 

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) {

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;
+//        static uint32_t s_last_diag = 0;
-        uint32_t now_diag = HAL_GetTick();
+//        uint32_t now_diag = HAL_GetTick();
-        if ((now_diag - s_last_diag >= 3000) || s_last_diag == 0) {
+//        if ((now_diag - s_last_diag >= 3000) || s_last_diag == 0) {
-            s_last_diag = now_diag;
+//            s_last_diag = now_diag;
-            DBG_INFO("GINT=0x%04X", int_status);
+//            DBG_INFO("GINT=0x%04X", int_status);
-            for (int di = 0; di < NET_MAX_SOCKETS; di++) {
+//            for (int di = 0; di < NET_MAX_SOCKETS; di++) {
-                DBG_INFO("  s%d: in_use=%d state=%d",
+//                DBG_INFO("  s%d: in_use=%d state=%d",
-                    di, s_net_socks[di].in_use, s_net_socks[di].state);
+//                    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 中断状<E696AD>?*/
             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 秒打印一次诊断信息（调试用） */
+//    /* 2 秒打印一次诊断信息（调试用） */
-    {
+//    {
-        static uint32_t s_last_dbg = 0;
+//        static uint32_t s_last_dbg = 0;
-        uint32_t now = HAL_GetTick();
+//        uint32_t now = HAL_GetTick();
-        if (now - s_last_dbg >= 2000) {
+//        if (now - s_last_dbg >= 2000) {
-            s_last_dbg = now;
+//            s_last_dbg = now;
-            uint8_t int_level = (HAL_GPIO_ReadPin(CH395_INT_GPIO_Port, CH395_INT_Pin) == GPIO_PIN_RESET) ? 1 : 0;
+//            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);
+//            DBG_DEBUG("INT#=%d", int_level);
-            for (i = 0; i < NET_MAX_SOCKETS; i++) {
+//            for (i = 0; i < NET_MAX_SOCKETS; i++) {
-                if (s_net_socks[i].in_use) {
+//                if (s_net_socks[i].in_use) {
-                    uint8_t st[2];
+//                    uint8_t st[2];
-                    ch395f_get_socket_status((uint8_t)i, st);
+//                    ch395f_get_socket_status((uint8_t)i, st);
-                    uint16_t rl = ch395f_get_recv_len((uint8_t)i);
+//                    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);
+//                    DBG_DEBUG(" s%d:sw%d/tcp%d rl%d", i, st[0], st[1], rl);
-                }
+//                }
-            }
+//            }
-        }
+//        }
-    }
+//    }
 
     return event_count;
 }

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 queue.c...
-compiling tpafe5160.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

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 */

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 位）<br>注：测试入口处已预读一次清除 `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 字节收发 |
+| **标题** | ch395f TCP Client → PC TCP Server，64 字节收发 |
-| **前置条件** | PC: `python ch395f_socket_test.py tcp_server --port 8081` |
+| **前置条件** | 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 通信失败） |
+| 1 | `ch395f_set_proto_type(0, CH395F_PROTO_TYPE_TCP)` + 设置目标 IP `192.168.1.2`、端口 `8081`、本地端口 `50000` | 配置写入成功（CMD_STATUS == `0x00`） | 配置失败（SPI 异常或寄存器未更新） |
-| 2 | 设置目标 IP 为 PC 地址（`192.168.1.2`），端口 `8081` → 发起 TCP 连接 | `ch395f_tcp_connect(0)` 返回 `CH395F_ERR_SUCCESS`（`0x00`） | 返回值非 `0x00`（连接超时、目标不可达或协议配置错误） |
+| 2 | `ch395f_open_socket(0)` 打开 Socket 0 | 返回 `CH395F_ERR_SUCCESS`（`0x00`） | 返回值非 `0x00`（Socket 硬件异常或 SPI 通信失败） |
-| 3 | 发送 64 字节递增模式数据（`0x00, 0x01, ..., 0x3F`） | `net_send()` 返回值 == `64`（全部发出） | 返回值 < `0`（发送失败）或返回值 ≠ `64`（未完全发出） |
+| 3 | `ch395f_tcp_connect(0)` 发起 TCP 连接 | 返回 `CH395F_ERR_SUCCESS`（`0x00`） | 返回值非 `0x00`（连接命令下发失败） |
-| 4 | 阻塞等待接收回显，超时 5 秒 | `net_recv()` 返回值 == `64`（收到全部回显） | 返回值 < `0`（超时/断开）或返回值 ≠ `64`（数据不完整） |
+| 4 | 轮询 `GET_GLOB_INT_STATUS` 的 `(sock+4)` 位 + `SINT_STAT` 等待 `CH395F_SINT_STAT_CONNECT`，超时 10s | 检测到 CONNECT 中断（连接已建立，进入 ESTABLISHED） | 超时未建立连接（目标不可达 / 链路异常） |
-| 5 | 逐字节比较收发数据 | 所有 64 字节完全一致 | 任意字节不一致（回显错误或数据错位） |
+| 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 → 验证回显 |
+| **前置条件** | 1. PC 运行 `python ch395f_socket_test.py tcp_server --port 8081`（TCP 回显服务器）<br>2. TC-NET-201 通过（Socket 0 硬件正常） |
-| **通过标准** | 3/3 轮通过 |
-| **覆盖原则** | DP-01（open→connect→close→re-open→reconnect） |
 
-### 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. PC **未**运行 TCP Server（`192.168.1.2:8081` 无监听）<br>2. TC-NET-201 通过 |
-| **测试步骤** | 1. 开 Socket 0 → 尝试连接 192.168.1.2:8081<br>2. 等待 TIMEOUT<br>3. 关 Socket 0 |
+
-| **通过标准** | TIMEOUT 检测到，无崩溃 |
+**测试步骤与判定标准**：
-| **覆盖原则** | DP-01 |
+
+| 步 | 操作 | 成功标准 | 失败标准 |
+|----|------|----------|----------|
+| 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`。按耗时细分：<br>**<3s** = RST 快速拒绝（端口关闭，实测主路径——芯片毫秒级上报 SOCK_TIMEOUT）<br>**≥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 秒 |
+| **耗时** | ~60 秒 |
-| **入口** | `ch395fTestTask` 启动后自动运行 |
+| **入口** | `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 大包） |
+| **标题** | 30 轮 64B UDP 数据报回显 |
-| **前置条件** | PC: `python ch395f_socket_test.py udp_client --ip 192.168.1.100 --port 60000` |
+| **前置条件** | PC: `python test/ch395f_socket_test.py udp_client --ip 192.168.1.100 --port 60000` |
-| **测试步骤** | 1. PC 发 HELLO → MCU 回显<br>2. PC 发 5×PING → MCU 回显<br>3. PC 发 10×1024B → MCU 回显<br>4. PC 发 14×混合大小 → MCU 回显 |
-| **通过标准** | 30/30 回显匹配 100% |
-| **覆盖原则** | DP-03 |
 
-### 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` |
+| **标题** | 变长载荷（1B / 64B / 200B）各 10 轮回显，验证 `rlen-8` 解析与载荷完整性 |
-| **前置条件** | TC-NET-301 运行中 |
+| **前置条件** | 同 TC-NET-301（同一固件会话的第 31~60 轮）；载荷上限受 `rx_buf[300]` 约束（≤292B） |
-| **测试步骤** | PC 连续发小包（<100ms 间隔） |
+
-| **通过标准** | 30/30 成功，无丢包 |
+**测试步骤**：同 TC-NET-301 流程；PC 端 udp_client Phase C 按 1B→64B→200B 各 `--count` 轮（默认 10）循环发送，MCU 回显后由 PC 逐字节比对一致性。
-| **覆盖原则** | DP-03 |
+
+**通过标准**：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 回显服务器）<br>2. `net_init()` 已完成（`g_net_ready == 1`，netTask 周期 `net_poll()` 运行中）<br>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` 无监听）<br>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` |
+| **入口** | `ENABLE_PHASE7_TESTS` |
-| **配置** | `PHASE5_FILE_SIZE`（默认 20480）|
+| **配置** | `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 |
+| 阶段 ID | TM-PHY-08 |
-|---------|-----------|
-| **类型** | 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<br>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）<br>2. PC 收 HELLO<br>3. PC 发 3×HELLO 回显请求<br>4. CH395F 回显 |
-| **通过标准** | 3/3 HELLO 回显 100% |
-
----
-
-## 8. 阶段 7：Select/Poll I/O 多路复用（单连接）
-
-| 阶段 ID | TM-PHY-07 |
 |---------|-----------|
 | **类型** | 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 → 链路恢复<br>2. s0 re-OPEN → LISTEN<br>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_server --port 8081` | PC 作 TCP 回显服务器（多连接循环） | 测试 TCP Client（阶段 2 硬件层；阶段 6 Client 扩展 204/205/206） |
-| `tcp_client --ip ... --port 8080` | PC 作 TCP Client | 测试 TCP Echo（阶段 4/7/8） |
+| `tcp_client --ip ... --port 8080` | PC 作 TCP Client | 测试 TCP Echo（阶段 6/8/9） |
-| `tcp_file --ip ... --port 8080 --size 20480` | PC 作文件接收 | 测试大文件传输（阶段 5） |
+| `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-601 | P0 | 功能测试 | ✅ |
-| TM-PHY-04 | TC-NET-402 | P0 | 功能测试 | 🟡 |
+| TM-PHY-04 | TC-NET-602 | P1 | 功能测试 | ✅ |
-| TM-PHY-04 | TC-NET-403 | P0 | 边界测试 | 🟡 |
+| TM-PHY-05 | TC-NET-511 | P0 | 功能测试 | 🟡 |
-| TM-PHY-04 | TC-NET-404 | P0 | 边界测试 | 🟡 |
+| TM-PHY-05 | TC-NET-512 | P1 | 合规测试 | ✅ |
-| TM-PHY-04 | TC-NET-405 | P0 | 恢复测试 | 🟡 |
+| TM-PHY-06 | TC-NET-204 | P0 | 功能测试 | 🟠 |
-| TM-PHY-04 | TC-NET-406 | P1 | 恢复测试 | 🟡 |
+| TM-PHY-06 | TC-NET-205 | P0 | 恢复测试 | 🟠 |
-| TM-PHY-05 | TC-NET-501 | P0 | 功能测试 | 🟡 |
+| TM-PHY-06 | TC-NET-206 | P1 | 负向测试 | 🟠 |
-| TM-PHY-05 | TC-NET-502 | P1 | 边界测试 | 🟡 |
+| TM-PHY-06 | TC-NET-401 | P0 | 功能测试 | 🟡 |
-| TM-PHY-06 | TC-NET-601 | P0 | 功能测试 | ✅ |
+| TM-PHY-06 | TC-NET-402 | P0 | 功能测试 | 🟡 |
-| TM-PHY-06 | TC-NET-602 | P1 | 功能测试 | ✅ |
+| TM-PHY-06 | TC-NET-403 | P0 | 边界测试 | 🟡 |
-| TM-PHY-07 | TC-NET-701 | P0 | 功能测试 | 🟡 |
+| TM-PHY-06 | TC-NET-404 | P0 | 边界测试 | 🟡 |
-| TM-PHY-07 | TC-NET-702 | P1 | 负向测试 | 🟡 |
+| TM-PHY-06 | TC-NET-405 | P0 | 恢复测试 | 🟡 |
-| TM-PHY-08 | TC-NET-801 | P0 | 边界测试 | 🟡 |
+| TM-PHY-06 | TC-NET-406 | P1 | 恢复测试 | 🟡 |
-| TM-PHY-08 | TC-NET-802 | P0 | 边界测试 | 🟡 |
+| TM-PHY-07 | TC-NET-501 | P0 | 功能测试 | 🟡 |
-| TM-PHY-08 | TC-NET-803 | P0 | 边界测试 | 🟡 |
+| TM-PHY-07 | TC-NET-502 | P1 | 边界测试 | 🟡 |
-| TM-PHY-08 | TC-NET-804 | P1 | 负向测试 | 🟡 |
+| TM-PHY-08 | TC-NET-701 | P0 | 功能测试 | 🟡 |
-| TM-PHY-08 | TC-NET-805 | P1 | 压力测试 | 🟡 |
+| TM-PHY-08 | TC-NET-702 | P1 | 负向测试 | 🟡 |
-| TM-PHY-08 | TC-NET-806 | P1 | 稳定性测试 | 🟡 |
+| TM-PHY-09 | TC-NET-801 | P0 | 边界测试 | 🟡 |
-| TM-PHY-09 | TC-NET-901 | P1 | 恢复测试 | ✅ |
+| TM-PHY-09 | TC-NET-802 | P0 | 边界测试 | 🟡 |
-| TM-PHY-09 | TC-NET-902 | P1 | 恢复测试 | ✅ |
+| 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-04：DMA 边界安全 | TC-NET-403, 404, 501, 502, 511, 512, 801, 802, 803, 804, 805 |
-| DP-05：PHY 链路恢复 | TC-NET-901, 902 |
 
 ## 附录 C：CH395F 边界条件速查
 

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。

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} 个连接（超时 {wait}s）...")
-                log_info(f"等待第 {conn_idx+1} 个连接（超时 {args.timeout}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} 超时")
-                break
-            except Exception as e:
-                log_error(f"连接#{conn_idx+1} 错误: {e}")
-                break
-
-        log_success("全部连接测试完成")
-
             except socket.timeout:
+                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}] 回显错误: {e}")
+                conn_errors += 1
+            finally:
+                client_socket.close()
+
+            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 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 就绪
+        # Phase A: HELLO 就绪探针（固件只回显不计数，不占用例预算）
-        log_info(f"Phase A: 等待 CH395F 就绪（超时 {args.timeout}s）")
+        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 轮）")
+        log_info(f"Phase B: TC-301 基础回显（{rounds_b} 轮 x {size_b}B）")
-        ok = 0
+        ok_b = 0
-        for i in range(5):
+        for i in range(rounds_b):
-            msg = f"PING_{i}".encode()
+            td = generate_data(size_b)
-            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))
             try:
                 sock.sendto(td, dest)
-                data, _ = sock.recvfrom(args.size)
+                data, _ = sock.recvfrom(size_b + 16)
-                if data == td:
+                if data != td:
-                    log_success(f"#{i+1} OK ({len(data)}B)")
+                    log_error(f"[TC-301] #{i+1} mismatch: {len(data)}B != {len(td)}B")
-                else:
-                    log_error(f"#{i+1} mismatch")
                     break
-                time.sleep(0.02)
             except socket.timeout:
-                log_warn(f"#{i+1} timeout")
+                log_error(f"[TC-301] #{i+1} echo timeout")
-            except Exception as e:
+                break
-                log_error(f"#{i+1}: {e}")
+            ok_b += 1
+            if ok_b % 10 == 0:
+                log_info(f"[TC-301] 进度 {ok_b}/{rounds_b}")
+            time.sleep(0.02)
+
+        # 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_success("Phase 3 完成")
+        # 汇总与退出码
+        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__':

test/ch395f_test.h

@@ -9,19 +9,19 @@
  * 修改记录：
  *     2026-07-22  全面重构为单连接模式，增加大文件传输、边界条件等测试
  *
- * === 测试阶段一览 ===
+ * === 测试阶段一览（硬件层 1~5 → NET 层 6~10，严格顺序执行） ===
- * Phase    | 类型         | 描述
+ * Phase    | 层       | 描述
- * ---------|--------------|-----------------------------------------------
+ * ---------|----------|-----------------------------------------------
- * Phase 1  | 独立运行      | 寄存器读写 + SPI 命令路径验证
+ * Phase 1  | 硬件层   | 独立运行：寄存器读写 + SPI 命令路径验证
- * Phase 2  | PC 配合      | TCP Client 收发 + 关闭重连
+ * Phase 2  | 硬件层   | PC 配合：TCP Client 收发 + 关闭重连
- * Phase 3  | PC 配合      | UDP Server Echo（HELLO + PING + 大包）
+ * Phase 3  | 硬件层   | PC 配合：UDP Server Echo（60 轮动态源地址回显，HELLO 探针不计数）
- * Phase 4  | testTask     | NET 层 TCP Echo（单连接模式，基础收发验证）
+ * Phase 4  | 硬件层   | PC 配合：DHCP 自动获取 IP
- * Phase 5  | testTask     | NET 层大文件传输（20KB+ 分块收发）
+ * Phase 5  | 硬件层   | PC 配合：大文件分块回传（裸命令，tcp_server 配合）
- * Phase 6  | PC 配合      | DHCP 自动获取 IP
+ * Phase 6  | NET 层   | testTask：TCP Echo（单连接模式，基础收发验证）
- * Phase 7  | testTask     | Select/Poll I/O 多路复用
+ * Phase 7  | NET 层   | testTask：大文件传输（20KB+ 分块收发）
- * Phase 8  | testTask     | 边界条件测试（零长度、DMA 边界、缓冲溢出）
+ * Phase 8  | NET 层   | testTask：Select/Poll I/O 多路复用
- * Phase 9  | 需拔插网线   | PHY 链路恢复
+ * Phase 9  | NET 层   | testTask：边界条件测试（零长度、DMA 边界、缓冲溢出）
- * Phase 10 | testTask     | KeepAlive 超时断开测试
+ * 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 命令路径 */
+/* ---- 硬件层（阶段 1~5）---- */
-//#define ENABLE_PHASE2_TESTS     /* TCP Client 收发 + 关闭重连 */
+//#define ENABLE_PHASE1_TESTS     /* [硬] 寄存器读写 + SPI 命令路径 */
-//#define ENABLE_PHASE3_TESTS     /* UDP Server Echo */
+//#define ENABLE_PHASE2_TESTS     /* [硬] TCP Client 收发 + 关闭重连 */
-//#define ENABLE_PHASE4_TESTS     /* NET 层 TCP Echo（单连接基础收发） */
+//#define ENABLE_PHASE3_TESTS     /* [硬] UDP Server Echo */
-//#define ENABLE_PHASE5_TESTS     /* NET 层大文件传输（20KB+ 分块） */
+//#define ENABLE_PHASE4_TESTS     /* [硬] DHCP 自动获取 IP（会改 IP！独立运行） */
-//#define ENABLE_PHASE6_TESTS     /* DHCP 自动获取 IP（会改 IP！独立运行） */
+#define ENABLE_PHASE5_TESTS     /* [硬] 大文件传输（硬件层，PC 配合） */
-//#define ENABLE_PHASE7_TESTS     /* Select/Poll I/O 多路复用 */
+/* ---- NET 层（阶段 6~10）---- */
-//#define ENABLE_PHASE8_TESTS     /* 边界条件测试 */
+//#define ENABLE_PHASE6_TESTS     /* [网] TCP Echo（单连接基础收发） */
-//#define ENABLE_PHASE9_TESTS     /* PHY 链路恢复测试 */
+//#define ENABLE_PHASE7_TESTS     /* [网] 大文件传输（20KB+ 分块） */
-//#define ENABLE_PHASE10_TESTS    /* KeepAlive 超时断开测试 */
+//#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 {