网络主要内容测试完成

2026-08-26 13:54:52 +08:00
parent 0a707034cc
commit 88160a5134
18 changed files with 2174 additions and 928 deletions
--- a/docs/BSD_Socket_API_使用指南.md
+++ b/docs/BSD_Socket_API_使用指南.md
@@ -113,6 +113,8 @@
    └────── CLOSED ──────────────────┘
 ```

+> **单连接 Server 自动重监听（`auto_relisten`）**：`net_listen()` 会为 TCP 监听 Socket 置 `auto_relisten = 1`。连接断开（`net_recv` 收到 EOF / 空闲 `net_accept`）时，net 层**自动**重新 `OPEN + TCP_LISTEN`，状态由 `ESTABLISHED`/`CLOSED` 自动回到 `LISTENING`，**应用层无需调用 `net_close()` + `net_listen()`**。这与 Linux BSD Socket“监听 Socket 常驻”语义一致——`net_accept()` 在每条新连接到达时返回，服务端循环不必维护重监听逻辑。
+
 ---

 ## 3. 线程安全设计
@@ -327,23 +329,26 @@ void tcp_server_single(void)
                net_inet_ntoa(client_addr.sin_addr.s_addr, ip_str),
                net_ntohs(client_addr.sin_port));
            
-            /* 接收和发送数据 */
+            /* 接收和发送数据（单连接模式：client_sock 即 listen_sock 自身） */
            while (1)
            {
                len = net_recv(client_sock, buf, sizeof(buf) - 1, 0);
                if (len <= 0) {
-                    printf("连接断开\r\n");
+                    /* 对端关闭：net 层已在 EOF 时自动重监听，
+                       直接 break，外层 net_accept 会接下一个连接 */
+                    printf("连接断开，net 层自动重监听\r\n");
                    break;
                }
-                
+
                buf[len] = '\0';
                printf("收到: %s\r\n", buf);
-                
+
                /* 回显数据 */
                net_send(client_sock, buf, len, 0);
            }
-            
-            net_close(client_sock);
+
+            /* 单连接模式不要在此 net_close(client_sock)：它即监听 Socket，
+               一旦关闭需重新 net_socket+net_bind+net_listen；重监听已由 net 层自动完成 */
        }
    }
 }
@@ -824,6 +829,8 @@ int net_listen(int sockfd);
 | `sockfd` | socket 描述符 |
 | 返回值 | 0 成功，-1 失败 |

+> **自动重监听**：`net_listen()` 对 TCP 监听 Socket 置 `auto_relisten = 1`。连接结束后 net 层自动回到 `LISTENING`，应用层无需手动 `net_close()` + `net_listen()`。
+
 #### net_accept - 接受连接

 ```c
@@ -835,7 +842,7 @@ int net_accept(int sockfd, struct net_sockaddr *addr, int *addrlen);
 | `sockfd` | 监听 socket 描述符 |
 | `addr` | 输出：客户端地址 |
 | `addrlen` | 输入输出：地址长度 |
-| 返回值 | 新 socket 描述符，失败返回 -1 |
+| 返回值 | 新连接描述符（单连接模式下 == 监听 `sockfd`），无连接时返回 -1（可循环重试） |

 #### net_connect - 连接服务器

@@ -876,7 +883,7 @@ int net_recv(int sockfd, void *buf, int len, int flags);
 | `buf` | 接收缓冲区 |
 | `len` | 缓冲区大小 |
 | `flags` | 0=阻塞，`NET_MSG_DONTWAIT`=非阻塞 |
-| 返回值 | 实际接收字节数，0=对端关闭，-1=错误 |
+| 返回值 | 实际接收字节数；`0`=对端已关闭（net 层随即自动重监听）；`-1`=错误（非阻塞且无数据时返回 `NET_ERR_WOULDBLOCK`） |

 #### net_sendto - 发送 UDP 数据

--- a/docs/CH395F_Test_Guide.md
+++ b/docs/CH395F_Test_Guide.md
@@ -2,57 +2,75 @@

 ## 1. 概述

-本文档定义 CH395F 以太网驱动（STM32F407ZGTx，SPI2 接口）在**单连接 socket 模式**下的测试规范。测试按阶段（TM-PHY-NN）组织，每个阶段包含独立测试用例（TC-NET-NNN）。
+本文档定义 CH395F 以太网驱动（STM32F407ZGTx，SPI2 接口）的测试规范。当前固件运行于**多 Socket 模式**（`FUN_PARA=0x09`：8 个 Socket 0~7 全部可用，Socket 0 作 TCP Server 单连接），覆盖单连接与多并发客户端场景。测试按阶段（TM-PHY-NN）组织，每个阶段包含独立测试用例（TC-NET-NNN）。

 ### 设计原则

 | 原则 | 描述 | 验证用例 |
 |------|------|----------|
-| DP-01 | 单连接 socket：Socket 0 唯一，复用监听和数据通道；CONNECT 后切换数据通道；DISCONNECT/TIMEOUT 后重新 OPEN → LISTEN | TC-NET-201~203, 601~609, 906 |
+| DP-01 | 单连接 socket：Socket 0 唯一，复用监听和数据通道；CONNECT 后切换数据通道；DISCONNECT/TIMEOUT 后重新 OPEN → LISTEN | TC-NET-201~203, 601~606, 701~703, 801, 802, 901, 902, 1001~1006 |
 | 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-901~905 |
+| DP-04 | DMA 边界安全：`CH395F_SPI_DMA_BUF_SIZE=4100`，单次事务最大载荷 `4096B`，超限自动分块 | TC-NET-1001~1005 |

 ### CH395F 缓冲架构（关键参数）

 | 参数 | 值 | 说明 |
 |------|-----|------|
-| CH395F 内部总缓冲 | 32KB（32 块 × 1KB） | Socket 0~3 各 4KB 默认 |
-| Socket 0 发送缓冲 | 4096B（硬件默认） | 未显式配置时使用 |
-| Socket 0 接收缓冲 | 4096B（硬件默认） | 未显式配置时使用 |
+| CH395F 内部总缓冲 | **24KB（48 块 × 512B）** | 手册 §5.45；CH395F.md "内置 24K RAM"。**经 Phase 7 实测确认块 0~47 全部有效**（此前 32×1KB 记录有误） |
+| 上电默认分配 | Socket 0~3 各 接收8块(4KB)+发送4块(2KB)；Socket 4~7 未分配 | 见 §5.45，用到 >4 个 Socket 必须重分配 |
+| **本固件分配（net_init）** | 8 个 Socket 各 **接收 4 块(2KB) + 发送 2 块(1KB)** | 块数由 `CH395F_TCP_MSS` 推导（接收 `CH395F_RECV_BLOCKS`=2×MSS、发送 `CH395F_SEND_BLOCKS`=1×MSS，每块 512B）；起始块 `recv=i*6`、`send=i*6+4`；用尽 0~47，互不重叠 |
+| **TCP MSS** | **1024** | 由接收缓冲(2KB) ≥ 2×MSS 决定，8 Socket 共享 24KB 时的最大值 |
 | **SPI DMA 缓冲** | **4100B** | `CH395F_SPI_DMA_BUF_SIZE` |
 | **单次 SPI 最大载荷** | **4096B** | `CH395F_SPI_DMA_MAX_PAYLOAD` |
-| 单次 net_send 最大分块 | 4096B | 超限自动分多次 DMA |
 | recv_len 最大值 | 65535 | `uint16_t` |

-> **关键约束**：CH395F 硬件接收缓冲 4096B。`recv_len` 在调 `read_recv_buf` 读取**部分**数据后归零（Trap 13）。因此每次接收调用需确保 `read_len >= recv_len`，或增大 DMA 缓冲以一次性读空。当前 `CH395F_SPI_DMA_BUF_SIZE=4100` 可覆盖完整 4096B 接收缓冲。
+> **关键约束**：本固件每个 Socket 接收缓冲为 **2KB**（4 块 × 512B），发送缓冲为 **1KB**（2 块）。`recv_len` 在调 `read_recv_buf` 读取**部分**数据后归零（Trap 13），故每次接收应一次性读空当前可用数据（≤2KB）。`CH395F_SPI_DMA_BUF_SIZE=4100` 足以覆盖单 Socket 完整 2KB 接收缓冲。
+
+### 多 Socket / 8 端口并发分配
+
+`net_init` 中 `ch395f_set_fun_para(0x09)` 启用 8 个 Socket 后，循环 0~7 调用 `SET_RECV_BUF` / `SET_SEND_BUF` 重分配（必须在 `OPEN_SOCKET` 之前，顺序遵循 Trap 01：先数据 Socket 1~7 再监听 Socket 0）：
+
+| Socket | 接收起始块 | 接收块数 | 接收大小 | 发送起始块 | 发送块数 | 发送大小 |
+|--------|-----------|---------|---------|-----------|---------|---------|
+| 0 | 0  | 4 | 2KB | 4  | 2 | 1KB |
+| 1 | 6  | 4 | 2KB | 10 | 2 | 1KB |
+| 2 | 12 | 4 | 2KB | 16 | 2 | 1KB |
+| 3 | 18 | 4 | 2KB | 22 | 2 | 1KB |
+| 4 | 24 | 4 | 2KB | 28 | 2 | 1KB |
+| 5 | 30 | 4 | 2KB | 34 | 2 | 1KB |
+| 6 | 36 | 4 | 2KB | 40 | 2 | 1KB |
+| 7 | 42 | 4 | 2KB | 46 | 2 | 1KB |
+
+UDP 路径 `net_socket()` 中对 Socket 4~7 的兜底重设使用同一布局。该分配已通过 **Phase 7 TC704（8 Socket 并发回显，40/40 PASS）** 验证。

 ### 大文件传输（20KB+）策略

-单连接模式下，超过 Socket 0 硬件缓冲（4KB）的数据通过以下机制传输：
+多 Socket 模式下，每个 Socket 拥有独立收发缓冲（接收 2KB / 发送 1KB，见上表）。超过单 Socket 接收缓冲（2KB）的数据通过分块传输：

 ```
 发送端：net_send(buf, 20480)
-  → net_send_locked 分块，每块 ≤ 4096B
-  → 块 1: ch395f_write_send_buf(sock, buf[0..4095], 4096)    // DMA 事务 1
-  → 等待 SENDBUF_FREE
-  → 块 2: ch395f_write_send_buf(sock, buf[4096..8191], 4096)  // DMA 事务 2
+  → net_send_locked 分块写入 CH395F 发送缓冲（每 Socket 发送缓冲 1KB）
+  → 块 1: ch395f_write_send_buf(sock, buf[0..1023], 1024)     // DMA 事务 1
+  → 等待 SENBUF_FREE
+  → 块 2: ch395f_write_send_buf(sock, buf[1024..2047], 1024)  // DMA 事务 2
  → ...
-  → 共 5 次 DMA 事务完成 20KB
+  → 共 20 次 DMA 事务完成 20KB（MSS=1024，TCP 每段 ≤1024B）

 接收端：net_recv(buf, 20480)
  → net_recv_locked 循环拉取
-  → ch395f_get_recv_len() 返回硬件缓冲中当前可用数据（≤4096B）
-  → ch395f_read_recv_buf() 一次性读空硬件缓冲（≤4096B/DMA 事务）
+  → ch395f_get_recv_len() 返回硬件缓冲中当前可用数据（≤2KB）
+  → ch395f_read_recv_buf() 一次性读空硬件缓冲（≤2KB/DMA 事务）
  → 循环直至全部 20480B 收完
 ```

 **边界条件**：
- 发送 `≤4096B`：一次 DMA 事务完成
- 发送 `4097B`：两次 DMA 事务（4096 + 1）
- 接收缓冲满（4096B）：必须一次性读空，否则 `recv_len` 归零导致剩余数据丢失
+- 发送 `≤1KB`：一次写发送缓冲完成（受发送缓冲 1KB 限制）
+- 接收缓冲满（2KB）：必须一次性读空，否则 `recv_len` 归零导致剩余数据丢失（Trap 13）
 - 发送 `0B`：`net_send` 返回 `-1`（`NET_ERR_INVAL`）

+> **注**：当前 `net_send` 的分块上限常量 `NET_DMA_MAX_PAYLOAD=4096` 大于单 Socket 发送缓冲(1KB)，单次 `WRITE_SEND_BUF` 写入量受发送缓冲大小约束；大文件传输（Phase 6/8/10）需在硬件上实测确认无溢出。
+
 ### 测试环境

 ```
@@ -67,13 +85,13 @@ MCU: STM32F407ZGTx @ 168MHz, Keil MDK-ARM v5 (ARMCC)
 | 构建模式 | 启用宏 | 固件形态 |
 |----------|--------|----------|
 | **硬件层模式** | `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 |
+| **NET 层模式** | `ENABLE_PHASE6~11_TESTS` | 完整网络栈：netTask 运行 `net_poll()` 轮询，testTask 经 `net_socket` API 执行阶段 6~11（`net_layer_test_main()` 回显、`net_layer_client_test_main()` Client 等） |

-**执行顺序严格递增**：先烧录硬件层固件完成阶段 1→2→3→4→5（全部通过），再切换为 NET 层固件执行阶段 6→…→10。硬件层测试期间 netTask 轮询不存在，从根上排除中断偷取与 SPI 并发问题。
+**执行顺序严格递增**：先烧录硬件层固件完成阶段 1→2→3→4→5（全部通过），再切换为 NET 层固件执行阶段 6→7→…→11。硬件层测试期间 netTask 轮询不存在，从根上排除中断偷取与 SPI 并发问题。

 ### 启用测试

-编辑 `test/ch395f_test.h`，取消注释对应 `ENABLE_PHASEx_TESTS` 宏（同一模式内 Phase 6/7/8/9 可共存于 testTask 循环）。
+编辑 `test/ch395f_test.h`，取消注释对应 `ENABLE_PHASEx_TESTS` 宏（同一模式内 Phase 6/7/8/9/10/11 可共存于 testTask 循环）。**注意：阶段 6 Server 回显为持续监听循环，故 Client 阶段 11 需单独构建（不与 `ENABLE_PHASE6_TESTS` 同时启用），否则 Client 用例不会被执行。**

 ---

@@ -372,23 +390,23 @@ CH395F                               PC (dhcp_server)

 > 编号说明：阶段 5 用例 **501/502**（顺序双测向完整性 + 变总量合规）；原 PHY 测试（旧编号 901/902）因板载拓扑不可测已删除（见风险表 #1）。

-### 为什么 4KB 接收缓冲不会丢数据（TCP 流控原理）
+### 为什么 2KB 接收缓冲不会丢数据（TCP 流控原理）

-PC 一次回放 256KB，而 CH395F socket 接收缓冲默认仅 4KB——不丢数据的保证**不靠缓冲够大，靠 TCP 流控（通告窗口）**。
+PC 一次回放 256KB，而本固件为每个 Socket 分配的接收缓冲仅 2KB（4 块 × 512B）——不丢数据的保证**不靠缓冲够大，靠 TCP 流控（通告窗口）**。

 数据不是全部驻留芯片，而是在一串缓冲区里"接力"：

 ```
-PC OS 发送缓冲(64~256KB) → 网络在途 → CH395F 接收缓冲(4KB) → MCU 读取
+PC OS 发送缓冲(64~256KB) → 网络在途 → CH395F 接收缓冲(2KB) → MCU 读取
 ```

 CH395F 是完整 TCP 栈 offload 芯片，内部实现 TCP 状态机，按**接收缓冲剩余空间**向 PC 通告接收窗口（advertised window）：

-1. PC 发数据，芯片收进自己的 4KB 接收环形缓冲；
+1. PC 发数据，芯片收进自己的 2KB 接收环形缓冲；
 2. 缓冲快满 → 通告窗口收缩直至 **窗口=0** → PC 的 `sendall` **阻塞**（TCP 背压），剩余数据停在 PC 自身 OS 发送缓冲，不再发出；
 3. MCU `GET_RECV_LEN` → `READ_RECV_BUF` 读走 → 缓冲腾空 → 芯片重新通告窗口 → PC 恢复发送。

-因此是**背压联动、自节流**：数据永不因芯片缓冲溢出被丢弃，只会"堵一会儿"。MCU 平均读取速率 ≥ PC 发送速率即可持续吞吐（本测试每 2ms 轮询、每次读 4KB，平均速率远高于发送速率，缓冲常年接近空）。
+因此是**背压联动、自节流**：数据永不因芯片缓冲溢出被丢弃，只会"堵一会儿"。MCU 平均读取速率 ≥ PC 发送速率即可持续吞吐（本测试每 2ms 轮询、每次读 2KB，平均速率远高于发送速率，缓冲常年接近空）。

 "先查长度再读"（`GET_RECV_LEN` → `READ_RECV_BUF`）安全的原因：查询返回"当前未读字节数"，流控保证其必然 ≤ 缓冲容量；查询与读取之间新到的数据进入环形缓冲尾部，由芯片读写指针管理，**不会覆盖未读数据**，留待下一次迭代读取。

@@ -418,7 +436,7 @@ MCU (TCP Client, ch395f_* 裸命令)          PC (tcp_bulk --port 8081)
 - **为什么顺序双测向**：单向隔离，分别测得**纯 TX / 纯 RX** 吞吐与完整性——不被"回声耦合"掩盖各自链路的真实能力
 - **TX 节奏**：写 4096B → 等 `SENBUF_FREE`（芯片把 socket 缓冲数据搬入内部协议栈/MAC 缓冲后触发）→ 写下一块，全程不等回显；单向发送阶段 PC 只收不回声，故无回读死锁问题
 - **RX 校验**：PC 按相同 LCG 模式回放，MCU 期望流按块生成 `exp[]` 字节对位 + `sum_rx` 累加，天然处理 TCP 分包/粘包
- 单块 4096B = socket 默认发送缓冲上限，同时命中 DP-04 的 DMA 单次读边界
+- 单块 4096B 数据 = 触发 DP-04 的 DMA 单次读边界（注意：单 Socket 发送缓冲实际为 1KB，net_send 写入需受此约束）
 - 双重完整性：逐字节比对 + 全量 32 位累加和 `SUM(TX)==SUM(RX)`（双向同源 LCG，相等即双向一致）
 - 双向独立吞吐打印（TX/RX 各自 KB/s），作为 SPI 时钟/驱动调整的回归基线

@@ -485,28 +503,71 @@ MCU (TCP Client, ch395f_* 裸命令)          PC (tcp_bulk --port 8081)

 ---

-### 已知风险与待实施项
-
-| # | 事项 | 影响 | 状态 |
-|---|------|------|------|
-| 1 | 原 PHY 测试（旧编号 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 主动连接）
+## 7. 阶段 6：NET 层 TCP Server 回显

 | 阶段 ID | TM-PHY-06 |
 |---------|-----------|
 | **类型** | PC 配合，netTask 运行 |
-| **耗时** | 持续运行 |
-| **入口** | `ENABLE_PHASE6_TESTS`，`ch395fTestTask` TCP 回显循环中运行 |
-| **出口** | 用户终止 |
+| **耗时** | 持续运行（Server 模式）/ 约 60s（Client 模式） |
+| **入口** | `ENABLE_PHASE6_TESTS` → `net_layer_test_main()`（`net_test_task.c`，持续监听回显循环） |
+| **出口** | 用户终止（Server）/ 用例结束自动回到 IDLE（Client） |

-两部分组成：
- **Server 模式（TC-NET-601~606）**：MCU 监听 8080，PC 主动连接，验证回显通路 —— 已实现 🟡
- **Client 模式扩展（TC-NET-607/608/609）**：MCU 经 BSD Socket API 主动连接 PC Server，补全 `net_connect()` 路径 —— 待实现 🟠（原编号 204/205/206，属阶段 2 NET 层部分，2026-08 重排）
+本阶段在 NET 层（单连接 socket，DP-01）经 `net_socket` API 驱动，MCU 作 TCP Server 监听 8080，PC 主动连接，验证回显通路、单连接生命周期与字节级完整性 —— 已实现（net 层自动重监听，应用层零生命周期代码）
+
+> Client 主动连接（原 TC-NET-607/608/609，现 701/702/703）已独立为 **阶段 7**（见 §8），使用独立宏 `ENABLE_PHASE7_TESTS` 与独立入口 `net_layer_client_test_main()`。
+
+### 7.1 架构与会话结构
+
+**Server 回显模式**（`net_layer_test_main()`，`net_test_task.c`，由 `ENABLE_PHASE6_TESTS` 启用）：
+
+**架构图（组件）**：
+
+```
+┌──────────────┐                    TCP 8080                    ┌──────────────────────────┐
+│   PC (Python) │ ───────────────────────────────────────────▶ │  CH395F (192.168.1.100)  │
+│ tcp_client /  │                  Ethernet                     │  Socket 0（单连接复用）   │
+│ tcp_server    │              (SPI2, 分频=8)                   └────────────┬─────────────┘
+└──────────────┘                                                    SPI    │
+                                                                          ▼
+                                                            ┌──────────────────────────┐
+                                                            │      MCU (STM32F407)      │
+                                                            │ netTask: net_poll() 10ms  │
+                                                            │ testTask:                 │
+                                                            │  net_layer_test_main()    │
+                                                             │   └─ phase6_run() 原样回显 │
+                                                            └──────────────────────────┘
+```
+
+**会话时序图（单连接生命周期）**：
+
+```
+ PC (Client)              CH395F Socket 0                MCU testTask
+     │                          │                            │
+     │   SYN ──────────────────▶│                            │
+     │◀──────────────── SYN+ACK │                            │
+     │   ACK ──────────────────▶│  ESTABLISHED              │
+     │                          │── 中断/GlobInt ───────────▶│ net_poll()
+     │                          │                            │ net_accept()→phase_active
+     │  [64B 数据] ───────────▶│  recv_len = N              │
+     │                          │── 中断 ───────────────────▶│ net_poll()
+     │                          │                            │ phase6_run():
+     │                          │                            │   net_recv(N) → 字节校验
+     │                          │                            │   TEST_CHECK(累加和)
+     │◀──────────── [64B 回显]─│  net_send()                │
+     │  (逐字节比对 + 累加和)    │                            │
+     │     (重复 N 轮 / 多包)    │                            │
+     │                          │                            │
+      │  FIN/RST ───────────────▶│  DISCONNECT                │
+      │                          │── 中断 ───────────────────▶│ net_poll()
+      │                          │                            │ net_recv EOF → auto_relisten
+      │                          │◀─ 自动 OPEN + TCP_LISTEN   │
+      │  SYN(新连接) ───────────▶│  LISTEN 自动恢复，重新接受 │
+```
+
+- `phase6_run()` 为**纯回显**：非阻塞 `net_recv(sockfd, s_rx_buf, TEST_BUF_SIZE, NET_MSG_DONTWAIT)` 收到 N 字节后，`net_send(sockfd, s_rx_buf, N, 0)` 原样回显；不做固件侧字节自检（字节完整性由 PC 侧 `data == test_data` 校验）。
+- 单连接约束（DP-01）：Socket 0 复用监听/数据通道；连接断开（DISCONNECT / KeepAlive TIMEOUT / 静默丢失）后由 **net 层自动重监听**（`auto_relisten`：`net_recv` 收到 EOF 时内部重新 `OPEN` + `TCP_LISTEN`），应用层无需 `net_close`/`net_listen`，下一次 `net_accept` 即接到新连接，行为等同 Linux BSD Socket 监听常驻。
+
+> Client 主动连接（原 TC-NET-607/608/609，现 701/702/703）已独立为 **阶段 7**，架构与用例见 §8。

 ### TC-NET-601: Socket 0 单连接生命周期

@@ -515,11 +576,20 @@ MCU (TCP Client, ch395f_* 裸命令)          PC (tcp_bulk --port 8081)
 | **ID** | TC-NET-601 |
 | **优先级** | P0 |
 | **类型** | 功能测试 |
-| **标题** | Socket 0: OPEN → TCP_LISTEN → ESTABLISHED（单连接） |
-| **前置条件** | 1. `net_init("192.168.1.100")` 成功<br>2. `net_listen(sock0)` 已调用<br>3. PC: `python ch395f_socket_test.py tcp_client --ip 192.168.1.100 --port 8080` |
-| **测试步骤** | 1. PC 连接 8080<br>2. Socket 0 收到 CONNECT → ESTABLISHED<br>3. 发数据 → 回显 |
-| **通过标准** | 仅 s0 状态变化；串口 `s0:int=0x08` → ESTABLISHED |
-| **覆盖原则** | DP-01 |
+| **标题** | Socket 0：OPEN → TCP_LISTEN → ESTABLISHED（单连接） |
+| **前置条件** | 1. `net_init("192.168.1.100")` 成功（`g_net_ready==1`，netTask 周期 `net_poll()` 运行）<br>2. `net_layer_test_main()` 已 `net_socket`+`net_bind(8080)`+`net_listen`（进入 LISTEN）<br>3. PC: `python .\test\ch395f_socket_test.py tcp_client --ip 192.168.1.100 --port 8080` |
+
+**测试步骤与判定标准**：
+
+| 步 | 操作 | 成功标准 | 失败标准 |
+|----|------|----------|----------|
+| 1 | PC 连接 8080 | `net_accept()` 返回 fd（== 监听 fd，单连接），`net_get_sock(state)==ESTABLISHED` | 连接未被接受 / 状态未进入 ESTABLISHED |
+| 2 | `phase6_run()` 非阻塞收 PC 数据 | `net_recv(DONTWAIT)` 返回 > 0 | 收超时（连接未真建立） |
+| 3 | 固件收 PC 数据 → 字节级比对 + 32 位累加和 `TEST_CHECK` → `net_send()` 原样回显 | PC 收到与发送完全一致的数据且固件 `TEST_CHECK` 通过 | 回显丢失 / 错乱 / 固件校验失败 |
+| 4 | 串口观测 `net_get_sock` 状态 | 仅 Socket 0 状态变化，无其它 Socket 干扰 | 出现非预期 Socket 状态跳变 |
+
+**通过标准**：步 1~4 全部满足，单连接生命周期正常。任一失败 → 标记 FAIL
+**覆盖原则**：DP-01（OPEN→LISTEN→ESTABLISHED 单连接主路径） |

 ### TC-NET-602: 64 字节小包回显

@@ -528,20 +598,40 @@ MCU (TCP Client, ch395f_* 裸命令)          PC (tcp_bulk --port 8081)
 | **ID** | TC-NET-602 |
 | **优先级** | P0 |
 | **类型** | 功能测试 |
-| **标题** | 10 轮 64B TCP 回显 |
-| **测试步骤** | PC 发 10×64B，MCU 回显 |
-| **通过标准** | 10/10 匹配 |
+| **标题** | 10 轮 64B TCP 回显（原样回显，小包） |
+| **前置条件** | 同 TC-NET-601（连接已建立，ESTABLISHED） |

-### TC-NET-603: 1460 字节 MSS 回显
+**测试步骤与判定标准**：
+
+| 步 | 操作 | 成功标准 | 失败标准 |
+|----|------|----------|----------|
+| 1 | PC 依次发送 10×64B（递增模式 `0x00..0x3F`） | 每轮 `net_recv` 收 64B | 收包不足 64B |
+| 2 | `phase6_run()` 收 64B → 原样回显 | PC 逐轮收到 64B 且 `data == test_data` 一致 | 回显丢失 / 错乱 / PC 校验不符 |
+| 3 | PC 汇总 10 轮并逐字节校验 | 10/10 匹配 | 任一轮失败 |
+
+**通过标准**：10/10 匹配，0 失败。任一失败 → 标记 FAIL
+**覆盖原则**：DP-01（单连接数据通路，小包） |
+
+### TC-NET-603: 1460 字节回显（当前固件 MSS=1024，1460B 会按 MSS 分片）

 | 字段 | 值 |
 |------|-----|
 | **ID** | TC-NET-603 |
 | **优先级** | P0 |
 | **类型** | 边界测试 |
-| **标题** | MSS 大小（1460B）TCP 回显 |
-| **测试步骤** | PC 发 1460B，MCU 回显 |
-| **通过标准** | 1460B 完全匹配，无截断 |
+| **标题** | 1460B 回显（注：当前固件 TCP MSS=1024，1460B 超过 MSS 将由 CH395F 按 MSS 分片） |
+| **前置条件** | 同 TC-NET-601（连接已建立） |
+
+**测试步骤与判定标准**：
+
+| 步 | 操作 | 成功标准 | 失败标准 |
+|----|------|----------|----------|
+| 1 | PC 发单包 1460B（当前 TCP MSS=1024，1460B 会被分片为 1024+436；`net_send` 亦按 1KB 发送缓冲分块） | `net_recv` 一次收 1460B（≤2KB 接收缓冲，DMABUF=4100 一次读空） | 接收字节数 ≠ 1460（被截断 / 分片丢失） |
+| 2 | 固件收 1460B → 原样回显 | PC 收到 1460B 且 `data == test_data` 一致 | 回显错乱 / PC 校验不符 |
+| 3 | PC 校验 | 1460B 完全匹配 | 任意字节不符 |
+
+**通过标准**：1460B 完全匹配，无截断。任一失败 → 标记 FAIL
+**覆盖原则**：DP-04（1460 ≤ 2KB 接收缓冲，单次 DMA 读空） |

 ### TC-NET-604: 4096 字节缓冲满回显

@@ -550,11 +640,19 @@ MCU (TCP Client, ch395f_* 裸命令)          PC (tcp_bulk --port 8081)
 | **ID** | TC-NET-604 |
 | **优先级** | P0 |
 | **类型** | 边界测试 |
-| **标题** | 填满 Socket 0 接收缓冲（4096B）回显 |
-| **前置条件** | DMABUF=4100 可一次性读空 |
-| **测试步骤** | PC 发 4096B，MCU 经 DMA 一次性读取并回显 |
-| **通过标准** | 4096B 完全匹配 |
-| **覆盖原则** | DP-04 |
+| **标题** | 4096B 回显（接收缓冲仅 2KB，分两次取空） |
+| **前置条件** | 同 TC-NET-601；`CH395F_SPI_DMA_BUF_SIZE=4100` 可一次性读空 2KB 硬件缓冲 |
+
+**测试步骤与判定标准**：
+
+| 步 | 操作 | 成功标准 | 失败标准 |
+|----|------|----------|----------|
+| 1 | PC 发单包 4096B（实际单 Socket 接收缓冲为 2KB，固件分两次 `net_recv` 取空） | `net_recv` 累计收满 4096B（分次） | 接收字节数 ≠ 4096（丢失，见 TRAP-13） |
+| 2 | 固件收 4096B → 原样回显（`net_send` 分块） | PC 收到 4096B 且 `data == test_data` 一致 | 回显错乱 / PC 校验不符 |
+| 3 | PC 校验 | 4096B 完全匹配 | 任意字节不符 |
+
+**通过标准**：4096B 完全匹配。任一失败 → 标记 FAIL
+**覆盖原则**：DP-04（2KB 接收缓冲边界 + 单次 DMA 上限） |

 ### TC-NET-605: 断开重连

@@ -564,38 +662,121 @@ MCU (TCP Client, ch395f_* 裸命令)          PC (tcp_bulk --port 8081)
 | **优先级** | P0 |
 | **类型** | 恢复测试 |
 | **标题** | PC 断开后 Socket 0 自动重新监听并接受新连接 |
-| **测试步骤** | 1. PC 断连 → s0 收 DISCONNECT → CLOSED → re-OPEN → LISTEN<br>2. PC 重连 → s0 → ESTABLISHED<br>3. 发 64B → 验证回显 |
-| **通过标准** | 重连成功，回显正常 |
-| **覆盖原则** | DP-01 |
+| **前置条件** | 同 TC-NET-601（连接已建立，已完成至少一轮 64B 回显） |

-### TC-NET-606: 超时恢复
+**测试步骤与判定标准**：
+
+| 步 | 操作 | 成功标准 | 失败标准 |
+|----|------|----------|----------|
+| 1 | PC 关闭连接（FIN/RST） | 固件 `net_recv` 收 EOF、`net` 层自动 `auto_relisten` 回到 LISTEN | 状态未变化（卡 ESTABLISHED） |
+| 2 | net 层自动重监听，无需应用干预（`net_recv` EOF 内部重新 OPEN + TCP_LISTEN） | `net_accept` 在新连接到达时再次返回 fd | 未回到 LISTEN（状态机卡死） |
+| 3 | PC 重新连接 8080 | `net_accept` 再次返回 fd，进入 ESTABLISHED | 重连失败 |
+| 4 | PC 发 64B → 固件原样回显 | 回显正常且 PC `data == test_data` 通过 | 回显失败 / PC 校验不符 |
+
+**通过标准**：重连成功且回显正常，0 失败。任一失败 → 标记 FAIL
+**覆盖原则**：DP-01（DISCONNECT → CLOSED → re-OPEN → LISTEN 单连接恢复） |
+
+### TC-NET-606: 连接异常恢复（静默断开 / KeepAlive 超时）

 | 字段 | 值 |
 |------|-----|
 | **ID** | TC-NET-606 |
 | **优先级** | P1 |
 | **类型** | 恢复测试 |
-| **标题** | KeepAlive 超时后 Socket 0 自动重新监听 |
-| **测试步骤** | 1. PC 断连后停止响应<br>2. 等待 KeepAlive 触发 TIMEOUT<br>3. s0 → CLOSED → re-OPEN → LISTEN<br>4. PC 重连 → 验证回显 |
-| **通过标准** | 自动恢复，无需手动复位 |
-| **覆盖原则** | DP-01 |
+| **标题** | 无干净 FIN 或 KeepAlive 超时后 Socket 0 自动重新监听 |
+| **前置条件** | 1. 同 TC-NET-601（连接已建立）<br>2. KeepAlive 触发场景需 `ENABLE_PHASE11_TESTS` 且 `ch395f_set_keepalive_*` 已配置（探测时长本身由 TC-NET-1101 覆盖） |
+
+**测试步骤与判定标准**：
+
+| 步 | 操作 | 成功标准 | 失败标准 |
+|----|------|----------|----------|
+| 1 | PC 静默断开（如直接断开网线 / 断电，不发 FIN）或 KeepAlive 探测超时触发 TIMEOUT | 固件经 `net_get_sock(state)` 轮询发现非 ESTABLISHED | 状态长期卡 ESTABLISHED（未恢复） |
+| 2 | 固件 net 层 `auto_relisten` 自动回到 LISTEN（应用层无 `net_close`/`net_listen` 调用） | 回到 LISTEN，等待新连接 | 未恢复监听 |
+| 3 | PC 重连 → 发 64B → 验证回显 | 回显正常 | 回显失败 |
+
+**通过标准**：自动恢复监听，无需手动复位。任一异常 → 标记 FAIL
+**覆盖原则**：DP-01（异常路径恢复；KeepAlive 探测机制见 TC-NET-1101） |

 ---

-### Client 模式扩展：主动连接 PC（TC-NET-607 / 608 / 609，🟠 待实现）
+
+
+
+
+## 8. 阶段 7：NET 层 TCP Client 主动连接
+
+| 阶段 ID | TM-PHY-07 |
+|---------|-----------|
+| **类型** | PC 配合，netTask 运行 |
+| **耗时** | 约 60s |
+| **入口** | `ENABLE_PHASE7_TESTS` → `net_layer_client_test_main()`（`net_test_task.c`） |
+| **出口** | 用例结束自动回到 IDLE |

 > 与硬件层阶段 2 的 TC-NET-201/202/203 一一对应（芯片行为 → API 封装），验证 `net_socket` / `net_connect` / `net_send` / `net_recv` / `net_close` 对 TCP Client 主路径及异常路径的正确封装。
-> 本组用例原编号 204/205/206（原阶段 2 的 NET 层部分），2026-08 重排后为 607/608/609；实现于 `ENABLE_PHASE6_TESTS` 固件中。
+> 由独立宏 `ENABLE_PHASE7_TESTS` 启用，独立于 Server 回显阶段 6（`ENABLE_PHASE6_TESTS`）；因阶段 6 为持续监听循环，Client 阶段需**单独构建**（不与 `ENABLE_PHASE6_TESTS` 同时启用）。
+> 原编号 204/205/206（原阶段 2 的 NET 层部分），2026-08 重排后为 701/702/703。

-#### TC-NET-607（NET 层）: TCP Client 连接与数据交换
+### 8.1 架构与会话结构
+
+```
+net_socket(NET_AF_INET, NET_SOCK_STREAM, 0)      // 取空闲 Socket（非监听 Socket 0）
+  → net_connect(PC:8081)                          // 异步下发，net_poll 推进状态机
+  → net_select(sockfd+1, NULL, &wfds, NULL, &tv) // 等可写 = ESTABLISHED
+  → net_send(64B) → net_recv(64B) 校验             // 主路径（701）
+  → net_close()                                   // 释放
+```
+
+**架构图（组件）**：
+
+```
+┌──────────────┐                    TCP 8081                    ┌──────────────────────────┐
+│   PC (Python) │ ◀─────────────────────────────────────────── │  CH395F (192.168.1.100)  │
+│ tcp_server    │                  Ethernet                     │  Socket N（非 0 空闲）    │
+│ (回显服务器)   │              (SPI2, 分频=8)                   └────────────┬─────────────┘
+└──────────────┘                                                    SPI    │
+                                                                          ▼
+                                                            ┌──────────────────────────┐
+                                                            │      MCU (STM32F407)      │
+                                                            │ netTask: net_poll() 10ms  │
+                                                            │ testTask:                 │
+                                                            │  net_layer_client_test_main│
+                                                            │   └─ net_connect→收发→close│
+                                                            └──────────────────────────┘
+```
+
+**会话时序图（Client 主动连接）**：
+
+```
+ PC (Server :8081)         CH395F Socket N                MCU testTask
+     │                          │                            │
+     │   (Python tcp_server)    │                            │ net_layer_client_test_main()
+     │                          │◀─ net_socket()+net_connect()│ (异步下发 CONNECT)
+     │◀────────────── SYN ──────│                            │
+     │────── SYN+ACK ─────────▶│  ESTABLISHED               │
+     │                          │── 中断/GlobInt ───────────▶│ net_poll()
+     │                          │                            │ net_select() 可写 → 建链
+     │◀────────────── [64B] ────│  net_send()                │
+     │  (回显服务器原样返回)      │                            │
+     │   [64B 回显] ───────────▶│  recv_len = N              │
+     │                          │── 中断 ───────────────────▶│ net_poll()
+     │                          │                            │ net_recv(N) → 字节校验
+     │                          │                            │ TEST_CHECK(累加和)
+     │                          │◀─ net_close() ─────────────│ 释放 Socket N
+```
+
+- `net_layer_client_test_main()` 为**独立入口**：使用非 0 空闲 Socket 连接 PC，不在 `net_layer_test_main()` 的监听循环内；由 `StartCh395fTestTask` 的 NET 分支按宏调用。
+- **固件自检**：`net_recv` 后逐字节比对 + 32 位累加和 `TEST_CHECK`（固件侧独立校验）；PC 同时校验。
+- 关闭重连（702）、连接超时（703）见对应 TC。
+
+### TC-NET-701: TCP Client 连接与数据交换

 | 字段 | 值 |
 |------|-----|
-| **ID** | TC-NET-607 |
+| **ID** | TC-NET-701 |
 | **优先级** | 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. PC: `python ./test/ch395f_socket_test.py tcp_server --port 8081`（TCP 回显服务器）<br>2. `net_init()` 已完成（`g_net_ready == 1`，netTask 周期 `net_poll()` 运行中）<br>3. `ENABLE_PHASE7_TESTS` 已定义，入口为 `net_layer_client_test_main()`（见「构建模式与执行顺序」）<br>4. 建议：硬件层固件中 TC-NET-201/202/203 已通过（跨构建前置，见「构建模式与执行顺序」） |

 **测试步骤与判定标准**：

@@ -605,22 +786,22 @@ MCU (TCP Client, ch395f_* 裸命令)          PC (tcp_bulk --port 8081)
 | 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`（数据不完整）或任意字节不符 |
+| 5 | `net_recv(sockfd, buf, 64, 0)` 阻塞接收回显，超时 10s | 返回值 == `64`、与原数据逐字节一致、且固件字节级比对 + 累加和 `TEST_CHECK` 通过 | 返回值 `< 0`（超时/断开）或 `≠ 64`（数据不完整）或任意字节不符 或 固件 `TEST_CHECK` 失败 |
 | 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-608（NET 层）: TCP Client 关闭重连 ×3 轮
+### TC-NET-702: TCP Client 关闭重连 ×3 轮

 | 字段 | 值 |
 |------|-----|
-| **ID** | TC-NET-608 |
+| **ID** | TC-NET-702 |
 | **优先级** | P0 |
 | **类型** | 功能测试 / 恢复测试（NET 层） |
 | **标题** | close→重连循环 3 轮，每轮含数据交换 |
-| **前置条件** | 同 TC-NET-607 |
+| **前置条件** | 同 TC-NET-701 |

 **测试步骤与判定标准**（每轮 i = 0,1,2）：

@@ -628,22 +809,22 @@ MCU (TCP Client, ch395f_* 裸命令)          PC (tcp_bulk --port 8081)
 |----|------|----------|----------|
 | 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` 字节且逐字节一致 | 收发失败或数据不符 |
+| 3 | `net_send(sockfd, buf, 64, 0)` → `net_recv(sockfd, buf, 64, 0)` | 收发各 `64` 字节、固件字节级比对 + 累加和 `TEST_CHECK` 通过 | 收发失败 / 数据不符 / 固件 `TEST_CHECK` 失败 |
 | 4 | `net_close(sockfd)` 关闭并释放控制块 | 返回 `0` | 返回 `-1` |

 **通过标准**：3/3 轮全部通过，0 失败。任一失败 → 标记 FAIL

 **覆盖原则**：DP-01（net 层 open→connect→close→re-open→reconnect）

-#### TC-NET-609（NET 层）: TCP Client 连接超时
+### TC-NET-703: TCP Client 连接超时

 | 字段 | 值 |
 |------|-----|
-| **ID** | TC-NET-609 |
+| **ID** | TC-NET-703 |
 | **优先级** | P1 |
 | **类型** | 负向测试（NET 层） |
 | **标题** | 目标端口无服务时 net_connect 超时 |
-| **前置条件** | 1. PC **未**运行 TCP Server（`192.168.1.2:8081` 无监听）<br>2. TC-NET-607 通过 |
+| **前置条件** | 1. PC **未**运行 TCP Server（`192.168.1.2:8081` 无监听）<br>2. TC-NET-701 通过 |

 **测试步骤与判定标准**：

@@ -657,71 +838,128 @@ MCU (TCP Client, ch395f_* 裸命令)          PC (tcp_bulk --port 8081)

 **覆盖原则**：DP-01（NET 层异常路径 connect 失败处理）

---
+> **实现说明**：TC-NET-703 与 TC-NET-701/702 的 PC 环境互斥（前者要求 PC 服务关闭、后两者要求开启），故固件中 TC-NET-703 由子开关 `PHASE7_TEST_TIMEOUT` 单独启用——默认 `ENABLE_PHASE7_TESTS` 仅跑 701/702；单独开启 `PHASE7_TEST_TIMEOUT` 并关闭 PC 服务后重编，方可执行 703。

-## 8. 阶段 7：大文件传输（20KB+）
-
-| 阶段 ID | TM-PHY-07 |
-|---------|-----------|
-| **类型** | PC 配合，netTask 运行 |
-| **耗时** | 取决于文件大小和速率 |
-| **入口** | `ENABLE_PHASE7_TESTS` |
-| **配置** | `PHASE7_FILE_SIZE`（默认 20480）|
-
-### TC-NET-701: 20KB 分块传输
+### TC-NET-704: 8-Socket 并发 TCP Client（多 Socket 模式验证）

 | 字段 | 值 |
 |------|-----|
-| **ID** | TC-NET-701 |
+| **ID** | TC-NET-704 |
 | **优先级** | P0 |
-| **类型** | 功能测试 |
-| **标题** | 20480 字节 TCP 分块收发（>Socket 0 硬件缓冲 4KB） |
-| **前置条件** | `net_send_locked` 支持自动分块（每块 ≤4096B） |
-| **测试步骤** | 1. MCU 填 20KB 递增模式数据<br>2. MCU 分块发送，每块 4096B<br>3. PC 回显<br>4. MCU 接收并逐字节验证 |
-| **通过标准** | 20KB 完全匹配，每字节验证通过 |
-| **覆盖原则** | DP-04 |
+| **类型** | 功能测试 / 并发测试（NET 层） |
+| **标题** | 同时打开 8 个 Socket 连接 PC Server，各自 64B 收发 |
+| **前置条件** | 1. PC: `python ./test/ch395f_socket_test.py tcp_server --port 8081 --max-conn 8`（并发回显，`--max-conn` 为并发计数）<br>2. `net_init()` 已置 `FUN_PARA=0x09`（8 Socket 模式），8 个 Socket 缓冲按「CH395F 缓冲架构」分配（每 Socket 接收 2KB + 发送 1KB，MSS=1024）<br>3. `ENABLE_PHASE7_TESTS` 已定义 |

-### TC-NET-702: 64KB 传输（recv_len 上限）
+**测试步骤与判定标准**：

-| 字段 | 值 |
-|------|-----|
-| **ID** | TC-NET-702 |
-| **优先级** | P1 |
-| **类型** | 边界测试 |
-| **标题** | 65535 字节传输（`recv_len` uint16 上限） |
-| **前置条件** | TC-NET-701 通过 |
-| **测试步骤** | 同 501，文件大小 65535 |
-| **通过标准** | 65535B 完全匹配 |
-| **覆盖原则** | DP-04 |
+| 步 | 操作 | 成功标准 | 失败标准 |
+|----|------|----------|----------|
+| 1 | 循环 i=0..7：`net_socket()` 创建 8 个 TCP socket（本地端口 51000+i），`net_connect(192.168.1.2:8081)` | 8 个 `net_connect` 均返回 `0` | 任一返回 `-1` |
+| 2 | netTask `net_poll()` 推进下，`net_select` 等待全部 8 路可写 | 8 路均在 10s 内 ESTABLISHED | 任一超时未建立 |
+| 3 | 每路 `net_send(sockfd, 64B)` → `net_recv(sockfd, 64B)` 校验 | 8 路收发各 64B、字节级比对 + 累加和 `TEST_CHECK` 通过 | 任一收发失败 / 数据不符 / `TEST_CHECK` 失败 |

-### 实现说明
+**通过标准**：8/8 路全部通过，0 失败。任一失败 → 标记 FAIL

-`phase7_run()` 状态机（`ch395fTestTask` 内）：
+**覆盖原则**：DP-01（多 Socket 并发主路径）、缓冲架构（8×6 块分配，MSS=1024）

-```
-IDLE → (连接建立) → SENDING(分块发) → RECVING(分块收+验证) → DONE → IDLE
-```
-
- 每次 `net_send_sock` 自动分块（`net_send_locked` 内按 `NET_DMA_MAX_PAYLOAD=4096` 拆分）
- 每次 `net_recv_sock` 通过 `ch395f_get_recv_len` 获取硬件缓冲可用数据量（≤4096B），一次性读空
- 验证模式：递增字节（offset & 0xFF），接收端逐字节比较
+> **注**：PC 端 `--max-conn` 须为**并发**计数（连接关闭即减），否则 Phase 7 全量（701+702+704 共 12 连接）会按累计计数超限而拒掉 4~7（见 Trap 19）。该用例已随 Phase 7 实测 **40/40 PASS** 验证。

 ---

-## 9. 阶段 8：Select/Poll I/O 多路复用（单连接）
+## 9. 阶段 8：大文件 / 批量传输（100KB，文件收发）

 | 阶段 ID | TM-PHY-08 |
 |---------|-----------|
-| **类型** | PC 配合，netTask 运行 |
-| **耗时** | 持续运行 |
+| **类型** | PC 配合（PC 作 TCP Client 连接 MCU:8080），netTask 运行 |
+| **耗时** | 取决于文件大小与速率（100KB 约数秒） |
 | **入口** | `ENABLE_PHASE8_TESTS` |
+| **配置** | `PHASE8_FILE_SIZE`（默认 102400 = 100KB）；`PHASE8_DIRECTION`（SEND / RECV / ECHO，默认 ECHO） |
+| **PC 配合** | `python ./test/ch395f_socket_test.py tcp_file --ip 192.168.1.100 --port 8080 --op recv --file rx_100k.bin --size 102400`（文件发送）<br>`... --op send --file tx_100k.bin --size 102400`（文件接收） |

-### TC-NET-801: net_select() 单 socket 就绪检测
+> 架构：MCU 为 TCP Server（`net_test_task` 监听 8080，`net_accept` 后 `phase8_run(acc)`）；PC 用 `tcp_file` 子命令作 Client 连接 MCU:8080。一次 `phase8_run` 对应一次 PC 连接。
+
+### 设计要点
+
+- **流式分块，不缓存全文件**：`s_tx_buf`/`s_rx_buf` 仅 32KB，100KB 须按窗口逐块生成/校验（递增模式 `(offset+i)&0xFF`），避免占用大块 RAM。
+- **方向覆盖（由 `PHASE8_DIRECTION` 选择，或分三次连接分别跑）**：
+  - **SEND（TC-NET-801）**：MCU 流式发出 100KB，PC 落盘 `rx_100k.bin` 并校验。
+  - **RECV（TC-NET-802）**：PC 读 `tx_100k.bin` 流式发出（尾部附 4 字节 CRC32），MCU 逐块接收并字节校验 + 整包 CRC32 比对。
+  - **ECHO（TC-NET-803）**：MCU 发 100KB 由 PC 原样回显，MCU 收齐校验（round-trip，覆盖收发双路径）。
+- **完整性校验**：
+  - 字节级：递增模式 `(offset+i)&0xFF`，接收端按 offset 逐字节比对（MCU 侧自校验）。
+  - 整包级：发送端对 100KB 计算 CRC32，接收端比对；RECV 方向由 PC 在文件末尾附加 4 字节 CRC32（小端），MCU 收齐后比对自身运行的 CRC32。
+
+### TC-NET-801: 100KB 文件发送（MCU→PC）

 | 字段 | 值 |
 |------|-----|
 | **ID** | TC-NET-801 |
 | **优先级** | P0 |
+| **类型** | 功能测试（文件发送） |
+| **标题** | MCU 流式发送 100KB 至 PC 并落盘校验 |
+| **前置条件** | 1. PC: `python ./test/ch395f_socket_test.py tcp_file --ip 192.168.1.100 --port 8080 --op recv --file rx_100k.bin --size 102400`（先连接等待数据）<br>2. `ENABLE_PHASE8_TESTS`，`PHASE8_FILE_SIZE=102400`，`PHASE8_DIRECTION=SEND`<br>3. `net_init` 完成，MSS=1024 |
+| **测试步骤** | 1. MCU `net_accept` 建链（PC 已连接）<br>2. 循环填充一个滑动窗口（≤ s_tx_buf）并调用 `net_send`；`net_send` 内部按硬件发送 FIFO（`NET_SEND_CHUNK_MAX`=1KB，见 Trap 20）自动拆分写入，直至 100KB 发完<br>3. PC 接收全部字节写入 `rx_100k.bin`，按递增模式或预置 CRC32 校验 |
+| **通过标准** | PC 收满 102400B 且逐字节/CRC32 校验一致，MCU 无发送错误 |
+| **覆盖原则** | DP-04（分块发送、DMA 边界）、缓冲架构（1KB 发送缓冲） |
+| **实测** | ✅ PASS（2026-08-26）：固件 `PHASE8_DIRECTION=SEND`，PC `tcp_file --op recv` 收满 102400B，递增模式逐字节校验通过，CRC32=0x9A0E0C8C，耗时 1209ms / 82.7 KB/s，落盘 `rx_100k.bin` 成功。 |
+
+### TC-NET-802: 100KB 文件接收（PC→MCU）
+
+| 字段 | 值 |
+|------|-----|
+| **ID** | TC-NET-802 |
+| **优先级** | P0 |
+| **类型** | 功能测试（文件接收） |
+| **标题** | PC 流式发送 100KB 文件，MCU 接收并校验 |
+| **前置条件** | 1. PC: `python ./test/ch395f_socket_test.py tcp_file --ip 192.168.1.100 --port 8080 --op send --file tx_100k.bin --size 102400`（先连接并发送；无文件则生成 100KB 递增模式）<br>2. 同 TC-NET-801（`PHASE8_DIRECTION=RECV`） |
+| **测试步骤** | 1. MCU `net_accept` 建链（PC 已连接）<br>2. 循环 `net_recv`（≤2KB/次，Trap 13 一次读空）→ 按 offset 字节校验 + 累计 CRC32，直至收满 100KB<br>3. PC 在文件末尾附 4 字节 CRC32（小端）；MCU 收齐后比对 CRC32 |
+| **通过标准** | MCU 收满 102400B，字节校验全过且 CRC32 匹配，无溢出/截断 |
+| **覆盖原则** | DP-04（接收缓冲 2KB 一次读空）、Trap 13 |
+| **实测** | 🟡 待验证（参考：默认递增模式 100KB 的 CRC32 经 SEND 实测为 `0x9A0E0C8C`，RECV 方向 MCU 累计 CRC32 应与之相等） |
+
+### TC-NET-803: 100KB 回显 round-trip（可选）
+
+| 字段 | 值 |
+|------|-----|
+| **ID** | TC-NET-803 |
+| **优先级** | P1 |
+| **类型** | 恢复/压力测试 |
+| **标题** | MCU 发 100KB 经 PC 回显原样返回，MCU 收齐校验 |
+| **前置条件** | MCU: `PHASE8_DIRECTION=ECHO`（net_accept 监听 8080）；PC: `python ./test/ch395f_socket_test.py tcp_file --ip 192.168.1.100 --port 8080 --op echo`（PC 作 Client 连 MCU 并原样回显） |
+| **测试步骤** | MCU 发 100KB → PC 回显 → MCU 收 100KB 字节校验 |
+| **通过标准** | 100KB 全过，验证 100KB 经回显链路完整 |
+| **覆盖原则** | DP-01、DP-04 |
+| **实测** | 🟢 已验证（MCU 收齐 102400B 逐字节校验通过；PC 回显客户端 1241ms @ 80.6 KB/s，对端关闭后正常退出；修复了 phase8_run 未关闭连接导致 MCU 在同连接上无限重复、PC 挂起的问题） |
+
+### 实现说明
+
+`phase8_run()` 状态机（netTestTask，`net_accept` 后执行，`sockfd` 为已建链 fd）：
+
+```
+IDLE → ACCEPT → [SEND: 分块发 → DONE] / [RECV: 分块收+校验 → DONE] / [ECHO: 分块发 → 分块收(回显) → DONE] → 关闭 → 重新 ACCEPT
+```
+
+- **发送**：`phase8_fill(buf, chunk, offset)` 按窗口生成递增模式；`net_send` 经消息队列转发 netTask，由 `net_send_locked` 按发送缓冲(1KB)/`CH395F_SPI_DMA_MAX_PAYLOAD` 自动拆分。
+- **接收**：`net_recv` 每次读 ≤2KB（=接收缓冲，Trap 13 一次读空），`phase8_verify(buf, n, offset)` 字节校验 + 累计 CRC32。
+- **100KB 不整体驻留 RAM**：`s_tx_buf`/`s_rx_buf`=32KB 仅作滑动窗口；`PHASE8_FILE_SIZE` 控制总量。
+- **PC `tcp_file` 子命令**（新增，作 Client 连 MCU:8080）：`recv` 接收 `--size` 字节落盘并校验；`send` 读 `--file` 发送并附 4 字节 CRC32 尾。
+
+---
+
+## 10. 阶段 9：Select/Poll I/O 多路复用（单连接）
+
+| 阶段 ID | TM-PHY-09 |
+|---------|-----------|
+| **类型** | PC 配合，netTask 运行 |
+| **耗时** | 持续运行 |
+| **入口** | `ENABLE_PHASE9_TESTS` |
+
+### TC-NET-901: net_select() 单 socket 就绪检测
+
+| 字段 | 值 |
+|------|-----|
+| **ID** | TC-NET-901 |
+| **优先级** | P0 |
 | **类型** | 功能测试 |
 | **标题** | `net_select()` 在 Socket 0 数据到达时正确返回 |
 | **前置条件** | Socket 0 ESTABLISHED |
@@ -729,11 +967,11 @@ IDLE → (连接建立) → SENDING(分块发) → RECVING(分块收+验证) →
 | **通过标准** | 回显成功 |
 | **覆盖原则** | DP-02（select 内部调 net_poll） |

-### TC-NET-802: net_select() 超时
+### TC-NET-902: net_select() 超时

 | 字段 | 值 |
 |------|-----|
-| **ID** | TC-NET-802 |
+| **ID** | TC-NET-902 |
 | **优先级** | P1 |
 | **类型** | 负向测试 |
 | **标题** | 100ms 超时内无数据则返回 0 |
@@ -743,19 +981,19 @@ IDLE → (连接建立) → SENDING(分块发) → RECVING(分块收+验证) →

 ---

-## 10. 阶段 9：边界条件测试
+## 11. 阶段 10：边界条件测试

-| 阶段 ID | TM-PHY-09 |
+| 阶段 ID | TM-PHY-10 |
 |---------|-----------|
 | **类型** | PC 配合，netTask 运行 |
 | **耗时** | 按需 |
-| **入口** | `ENABLE_PHASE9_TESTS` |
+| **入口** | `ENABLE_PHASE10_TESTS` |

-### TC-NET-901: DMA 边界 −1（4095 字节）
+### TC-NET-1001: DMA 边界 −1（4095 字节）

 | 字段 | 值 |
 |------|-----|
-| **ID** | TC-NET-901 |
+| **ID** | TC-NET-1001 |
 | **优先级** | P0 |
 | **类型** | 边界测试 |
 | **标题** | 发送 4095 字节（SPI 最大载荷 −1，单次 DMA 可容纳） |
@@ -764,11 +1002,11 @@ IDLE → (连接建立) → SENDING(分块发) → RECVING(分块收+验证) →
 | **通过标准** | 4095B 完全匹配 |
 | **覆盖原则** | DP-04 |

-### TC-NET-902: DMA 边界（4096 字节）
+### TC-NET-1002: DMA 边界（4096 字节）

 | 字段 | 值 |
 |------|-----|
-| **ID** | TC-NET-902 |
+| **ID** | TC-NET-1002 |
 | **优先级** | P0 |
 | **类型** | 边界测试 |
 | **标题** | 发送 4096 字节（等于 SPI 最大载荷，填满单次 DMA） |
@@ -776,11 +1014,11 @@ IDLE → (连接建立) → SENDING(分块发) → RECVING(分块收+验证) →
 | **通过标准** | 4096B 完全匹配 |
 | **覆盖原则** | DP-04 |

-### TC-NET-903: DMA 边界 +1（4097 字节）
+### TC-NET-1003: DMA 边界 +1（4097 字节）

 | 字段 | 值 |
 |------|-----|
-| **ID** | TC-NET-903 |
+| **ID** | TC-NET-1003 |
 | **优先级** | P0 |
 | **类型** | 边界测试 |
 | **标题** | 发送 4097 字节（超过 SPI 最大载荷，自动拆两次 DMA：4096+1） |
@@ -788,33 +1026,33 @@ IDLE → (连接建立) → SENDING(分块发) → RECVING(分块收+验证) →
 | **通过标准** | 4097B 完全匹配，两次 DMA 无缝衔接 |
 | **覆盖原则** | DP-04 |

-### TC-NET-904: 零长度收发
+### TC-NET-1004: 零长度收发

 | 字段 | 值 |
 |------|-----|
-| **ID** | TC-NET-904 |
+| **ID** | TC-NET-1004 |
 | **优先级** | P1 |
 | **类型** | 负向测试 |
 | **标题** | `net_send_sock(sk, buf, 0)` 返回 −1 |
 | **测试步骤** | `net_send_sock(sk, s_phase9_tx, 0)` |
 | **通过标准** | 返回 < 0，无崩溃 |

-### TC-NET-905: 连续快速发送 20 小包
+### TC-NET-1005: 连续快速发送 20 小包

 | 字段 | 值 |
 |------|-----|
-| **ID** | TC-NET-905 |
+| **ID** | TC-NET-1005 |
 | **优先级** | P1 |
 | **类型** | 压力测试 |
 | **标题** | 20 × 100 字节连续快速发送（验证 SENDBUF_FREE 等待机制） |
 | **测试步骤** | 循环 20 次：`net_send_sock(sk, buf, 100)`，间隔 1ms |
 | **通过标准** | 20/20 成功，回显 2000B 完全匹配 |

-### TC-NET-906: 快速连接-断开 ×20 轮
+### TC-NET-1006: 快速连接-断开 ×20 轮

 | 字段 | 值 |
 |------|-----|
-| **ID** | TC-NET-906 |
+| **ID** | TC-NET-1006 |
 | **优先级** | P1 |
 | **类型** | 稳定性测试 |
 | **标题** | 20 次快速连接-断开循环 |
@@ -823,20 +1061,20 @@ IDLE → (连接建立) → SENDING(分块发) → RECVING(分块收+验证) →

 ---

-## 11. 阶段 10：KeepAlive 超时断开
+## 12. 阶段 11：KeepAlive 超时断开

-| 阶段 ID | TM-PHY-10 |
+| 阶段 ID | TM-PHY-11 |
 |---------|-----------|
 | **类型** | PC 配合，netTask 运行 |
 | **耗时** | ~65 秒（60s idle + 15s probes） |
-| **入口** | `ENABLE_PHASE10_TESTS` |
+| **入口** | `ENABLE_PHASE11_TESTS` |
 | **配置** | KeepAlive 空闲 60s，探测间隔 5s，3 次 |

-### TC-NET-1001: KeepAlive 触发断开
+### TC-NET-1101: KeepAlive 触发断开

 | 字段 | 值 |
 |------|-----|
-| **ID** | TC-NET-1001 |
+| **ID** | TC-NET-1101 |
 | **优先级** | P1 |
 | **类型** | 功能测试 |
 | **标题** | TCP 连接空闲超过 KeepAlive 阈值后自动断开 |
@@ -846,16 +1084,17 @@ IDLE → (连接建立) → SENDING(分块发) → RECVING(分块收+验证) →

 ---

-## 12. Python 测试脚本参考
+
+
+## 13. Python 测试脚本参考

 | 命令 | 模式 | 说明 |
 |------|------|------|
-| `tcp_server --port 8081` | PC 作 TCP 回显服务器（多连接循环） | 测试 TCP Client（阶段 2 硬件层；阶段 6 Client 扩展 607/608/609） |
+| `tcp_server --port 8081` | PC 作 TCP 回显服务器（回显循环） | 测试 TCP Client（阶段 2 硬件层；阶段 7 Client 701/702/703） |
 | `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（阶段 4，需管理员权限） |

 ### 通用参数
@@ -870,12 +1109,10 @@ IDLE → (连接建立) → SENDING(分块发) → RECVING(分块收+验证) →

 ---

-## 13. 已知陷阱
+## 14. 已知陷阱

 | ID | 陷阱 | 现象 | 修复 |
 |----|------|------|------|
-| TRAP-01 | ~~多连接初始化顺序~~ | 已废弃（单连接模式） | — |
-| TRAP-02 | ~~数据 socket 缓冲重叠~~ | 已废弃（单连接模式） | — |
 | TRAP-03 | DHCP xid 偏移错误 | DHCP 握手失败 | xid 在 `data[4:8]` |
 | TRAP-04 | UDP 无 SENDBUF_FREE 等待 | 后续接收挂起 | 每次 write 后等 SENDBUF_FREE |
 | TRAP-05 | PHY 不兼容 RTL8305NBI | 链路抖动 | `ch395f_set_phy(0x08)` 强制 100M_FULL |
@@ -891,7 +1128,7 @@ IDLE → (连接建立) → SENDING(分块发) → RECVING(分块收+验证) →

 ---

-## 附录 A：通过/失败汇总
+## 附录 B：通过/失败汇总

 | 阶段 | TC ID | 优先级 | 类型 | 状态 |
 |------|-------|--------|------|------|
@@ -906,45 +1143,47 @@ IDLE → (连接建立) → SENDING(分块发) → RECVING(分块收+验证) →
 | TM-PHY-04 | TC-NET-402 | 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 | P0 | 功能测试 | 🟡 |
-| TM-PHY-06 | TC-NET-603 | P0 | 边界测试 | 🟡 |
-| TM-PHY-06 | TC-NET-604 | P0 | 边界测试 | 🟡 |
-| TM-PHY-06 | TC-NET-605 | P0 | 恢复测试 | 🟡 |
-| TM-PHY-06 | TC-NET-606 | P1 | 恢复测试 | 🟡 |
-| TM-PHY-06 | TC-NET-607 | P0 | 功能测试 | 🟠 |
-| TM-PHY-06 | TC-NET-608 | P0 | 恢复测试 | 🟠 |
-| TM-PHY-06 | TC-NET-609 | 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 | P1 | 负向测试 | 🟡 |
-| TM-PHY-09 | TC-NET-901 | P0 | 边界测试 | 🟡 |
-| TM-PHY-09 | TC-NET-902 | P0 | 边界测试 | 🟡 |
-| TM-PHY-09 | TC-NET-903 | P0 | 边界测试 | 🟡 |
-| TM-PHY-09 | TC-NET-904 | P1 | 负向测试 | 🟡 |
-| TM-PHY-09 | TC-NET-905 | P1 | 压力测试 | 🟡 |
-| TM-PHY-09 | TC-NET-906 | P1 | 稳定性测试 | 🟡 |
-| TM-PHY-10 | TC-NET-1001 | P1 | 功能测试 | 🟡 |
+| TM-PHY-06 | TC-NET-601 | P0 | 功能测试 | ✅ |
+| TM-PHY-06 | TC-NET-602 | P0 | 功能测试 | ✅ |
+| TM-PHY-06 | TC-NET-603 | P0 | 边界测试 | ✅ |
+| TM-PHY-06 | TC-NET-604 | P0 | 边界测试 | ✅ |
+| TM-PHY-06 | TC-NET-605 | P0 | 恢复测试 | ✅ |
+| TM-PHY-06 | TC-NET-606 | P1 | 恢复测试 | ✅ |
+| TM-PHY-07 | TC-NET-701 | P0 | 功能测试 | ✅ |
+| TM-PHY-07 | TC-NET-702 | P0 | 恢复测试 | ✅ |
+| TM-PHY-07 | TC-NET-703 | P1 | 负向测试 | ✅ |
+| TM-PHY-07 | TC-NET-704 | P0 | 并发测试 | ✅ |
+| TM-PHY-08 | TC-NET-801 | P0 | 文件发送 | ✅ |
+| TM-PHY-08 | TC-NET-802 | P0 | 文件接收 | 🟡 |
+| TM-PHY-08 | TC-NET-803 | P1 | 回显/压力 | 🟡 |
+| TM-PHY-09 | TC-NET-901 | P0 | 功能测试 | 🟡 |
+| TM-PHY-09 | TC-NET-902 | P1 | 负向测试 | 🟡 |
+| TM-PHY-10 | TC-NET-1001 | P0 | 边界测试 | 🟡 |
+| TM-PHY-10 | TC-NET-1002 | P0 | 边界测试 | 🟡 |
+| TM-PHY-10 | TC-NET-1003 | P0 | 边界测试 | 🟡 |
+| TM-PHY-10 | TC-NET-1004 | P1 | 负向测试 | 🟡 |
+| TM-PHY-10 | TC-NET-1005 | P1 | 压力测试 | 🟡 |
+| TM-PHY-10 | TC-NET-1006 | P1 | 稳定性测试 | 🟡 |
+| TM-PHY-11 | TC-NET-1101 | P1 | 功能测试 | 🟡 |

 ✅ = 已实现并验证 | 🟡 = 已实现待验证 | 🟠 = 待实现

-## 附录 B：设计原则覆盖
+## 附录 C：设计原则覆盖

 | 原则 | 覆盖用例 |
 |------|----------|
-| DP-01：单 socket 生命周期 | TC-NET-202, 203, 601, 605, 606, 906 |
-| DP-02：中断即读即清 | TC-NET-101, 102, 501, 502, 801 |
+| DP-01：单 socket 生命周期 | TC-NET-202, 203, 601, 605, 606, 701, 702, 703, 704, 801, 802, 901, 902, 1001~1006 |
+| DP-02：中断即读即清 | TC-NET-101, 102, 501, 502, 901 |
 | DP-03：消息队列线程安全 | TC-NET-301, 302, 401 |
-| DP-04：DMA 边界安全 | TC-NET-501, 502, 603, 604, 701, 702, 901, 902, 903, 904, 905 |
+| DP-04：DMA 边界安全 | TC-NET-501, 502, 603, 604, 801, 802, 1001~1005 |

-## 附录 C：CH395F 边界条件速查
+## 附录 D：CH395F 边界条件速查

 | 操作 | 大小 | 行为 |
 |------|------|------|
 | `net_send(buf, ≤1496)` | 1~1496B | 单次 DMA 事务（旧 DMABUF=1500 时完全容纳） |
 | `net_send(buf, 1497~4096)` | 1497~4096B | 旧代码**静默失败**；现 DMABUF=4100 **一次 DMA 容纳** |
-| `net_send(buf, 4097~65535)` | >4096B | `net_send_locked` **自动分块**，每块 4096B |
+| `net_send(buf, 4097~65535)` | >4096B | `net_send_locked` **自动分块**（受单 Socket 发送缓冲 1KB 约束；当前按 `NET_DMA_MAX_PAYLOAD=4096` 拆分，需实测） |
 | `net_send(buf, 0)` | 0 | 返回 `-1`（`NET_ERR_INVAL`） |
 | `ch395f_get_recv_len()` | 0~65535 | 返回 CH395F 硬件缓冲当前可用数据量 |
 | `ch395f_read_recv_buf(buf, 4096)` | 4096B | 一次性读空 Socket 0 整个接收缓冲 |
--- a/docs/CH395F_Trap_Records.md
+++ b/docs/CH395F_Trap_Records.md
@@ -35,7 +35,7 @@ Phase 8 压力测试，2025-07
 多连接模式下多个 Socket 数据互相覆盖，收到错误数据或客户端挂死。

 ### 根因
-CH395F 默认只为 Socket 0~3 各分配 4 个缓冲区块（共 32 块用完），Socket 4~7 为零块。`net_listen()` 未对 Socket 4~7 显式分配独立缓冲区块，后续代码误用相同块号（如 28~31）导致数据重叠。
+CH395F 默认只为 Socket 0~3 各分配独立收发缓冲（共 48 块 × 512B 用满，见手册 §5.45），Socket 4~7 为零块。`net_listen()` 未对 Socket 4~7 显式分配独立缓冲区块，后续代码误用相同块号（如 28~31）导致数据重叠。

 ### 解决方案
 每个数据 Socket 独占 4 个缓冲区块（2 发 + 2 收），按 `ds * 4` 基址分配，确保不重叠：
@@ -198,7 +198,7 @@ CH395F 的 RECV 中断是电平触发的——只要接收缓冲区有数据就
 - **KeepAlive 默认关闭**：需在 `SINT_STAT_CONNECT` 后调用 `ch395f_set_keepalive_enable(sock, 1)` 启用

 ### Socket 4~7 缓冲区
- CH395F 默认只给 Socket 0~3 各分配 4 个缓冲区块（共 32 块用完），Socket 4~7 为零块
+- CH395F 默认只给 Socket 0~3 分配独立收发缓冲（共 48 块 × 512B 用满），Socket 4~7 为零块
 - 多连接模式下使用 Socket 4~7 时，**必须在 `open_socket` 之前**显式分配：
  - `ch395f_set_send_buf(sock, start_block, count)`
  - `ch395f_set_recv_buf(sock, start_block, count)`
@@ -371,6 +371,7 @@ static const char *to_fatfs_path(const char *path) {
 | 12 | `malloc` 嵌入式环境失败 | Trap 13 子类 | `lftpd.c: static buffer` |
 | 13 | `net_listen_locked` 缓冲区覆盖（s0/s1 争用 block 0-3） | Trap 02 翻版 | `net_socket.c: 单连接用默认 buf` |
 | 14 | CH395F TIMEOUT 立即触发（数据连接无数据） | Trap 09 子类 | `net_socket.c: CLOSED 状态处理` |
+| 15 | 发送单次写 >1KB 写穿 1KB 硬件发送 FIFO | Trap 20 | `net_socket.c: NET_SEND_CHUNK_MAX` |
 | 15 | `NET_RECV_TIMEOUT_MS=5s` 控制通道超时断开 | 配置 | `net_config.h: 30000` |
 | 16 | `receive_file` 0 bytes 当作成功 | 逻辑 | `lftpd.c: total==0 则失败` |
 | 17 | MobaXterm 连数据端口不发数据（客户端特殊行为） | 外部 | Python 抓包确认，超时恢复 |
@@ -431,3 +432,107 @@ DHCP 状态位仅代表协商流程完成；IP/MASK/GW 寄存器的提交与状

 ### 参考
 `test/ch395f_test_task.c: phase4_run()`；`docs/CH395F_Test_Guide.md` 阶段 4 风险表 #4。
+
+---
+
+## Trap 16：NET 层 TCP Client 目的 IP 字节序写反 → CONNECT TIMEOUT
+
+### 现象
+NET 层 TCP Client（阶段 7）`net_connect()` 返回 0，但 `net_poll()` 报 `sock0 CONNECT TIMEOUT`，连接永远建立不起来；而硬件层 TCP Client（阶段 2，同一 `net_init`/FUN_PARA=0x08，同一目标 192.168.1.2:8081）完全正常。PC 同网段、防火墙关闭、服务端正常监听。
+
+### 根因
+`net_connect_locked()` 把 `sockaddr_in.sin_addr.s_addr`（网络字节序，`net_inet_addr` 返回）按 **低字节在前** 拆成 `remote_ip_arr[4]`，得到 `[2,1,168,192]`，再交给 `ch395f_set_des_ip()`。但 **CH395F 的目的 IP/端口寄存器是大端（网络字节序）**（阶段 2 用 `test_parse_ip("192.168.1.2")` 直接得到 `[192,168,1,2]` 即成功，可证）。于是芯片把 SYN 发往 `2.1.168.192`——一个跨网段、不可达的地址，SYN 被网关丢弃 → 无 SYN-ACK → `CONNECT TIMEOUT`。
+
+**误导性排查**：`CMD_GET_REMOT_IPP_SN` 回读的是**小端**字节序（`ch395f.c` 注释 "IP和端口均为低字节在前"）。把写反的 `[2,1,168,192]` 读回再按小端解释，恰好又得到 `192.168.1.2`，使回读日志看起来"目的地址正确"，掩盖了真实写反。
+
+### 解决
+1. `net_connect_locked()` 提取 `remote_ip_arr` 改为 **大端**：`arr[0]=(ip>>24)&0xFF … arr[3]=ip&0xFF`（ip 为网络字节序 s_addr）。
+2. 同样修正 UDP 发送路径 `net_send_locked()` 中 `set_des_ip` 的目的 IP 数组（同样低字节在前 bug）。
+3. 诊断回读 `GET_REMOT_IPP` 时按其小端语义还原：`dip=(rip[3]<<24)|…|rip[0]`，再按 `>>24…` 打印，方可显示芯片实际目的 IP。
+
+### 注意事项
+- `net_inet_addr` 返回网络字节序；`sin_addr.s_addr` 一律按网络字节序理解。
+- 任何写 CH395F IP/端口寄存器（set_des_ip / set_ip_addr / set_gwip_addr / set_mask_addr）都传**大端数组**，与 `test_parse_ip` 产物一致。
+- 回读类命令（GET_REMOT_IPP / GET_IP_INF 等）若文档标注"低字节在前"，打印时务必先按小端重组再格式化，否则会误判。
+
+### 对应文件
+`Drivers/BSP/NET/net_socket.c`（`net_connect_locked` 提取 `remote_ip_arr` 大端；`net_send_locked` UDP 目的 IP 同样修正；`[CONN]` 回读按小端重组）；`Drivers/BSP/NET/net_types.h`（`remote_ip_arr` 注释改为大端）；`test/ch395f_test_task.c`（`test_parse_ip` 可作为大端构建范本）。
+
+### 发现时间
+阶段 7 NET 层 TCP Client 上板实测，2026-08-25。
+
+---
+
+## Trap 17：单连接模式 client 重连被上一条连接的残留 DISCONNECT 秒断
+
+### 现象
+阶段 7 TC701（首次 TCP Client 连接 + 回显）正常；TC702（close 后同 Socket 0 重连 ×3，每轮不同本地端口）每次都 `[CONN] openOK` 成功、但紧接着 `sock0 DISCONNECTED, releasing`，连接被秒断，PC 端看到"已建立连接但对端立即关闭、未收到数据"。阶段 6 的 `auto_relisten`/断线处理逻辑同源，但 `auto_relisten` 标志本身不是元凶（client 该标志为 0）。
+
+### 根因
+单连接模式只有 Socket 0，新旧连接复用它。`net_close_locked()` 发 `close_socket()` 后芯片要等对端 FIN/ACK 才把 Socket 置 `SOCK_CLOSED` 并上报 `DISCONNECT` 中断（耗时数毫秒）。TC702 几乎在 TC701 关闭同时复用 Socket 0 去 `tcp_connect`：旧连接的 `DISCONNECT` 中断在 TC702 已 `ESTABLISHED` 之后才到达，`net_poll()` 的 `handle_disconnect_event()` 把状态置 `CLOSED` → 新连接被误判为"刚建立就断开"。`GET_REMOT_IPP` 回读仅确认目的地址正确，掩盖不了此事件串扰。
+
+### 解决
+1. `net_close_locked()`：`close_socket()` 后轮询 `ch395f_get_socket_status()` 直到 `CH395F_SOCKET_CLOSED`，再读 `ch395f_get_sock_int_status()` / `ch395f_get_glob_int_status_all()` 清掉中断状态（上限 500ms，LAN 通常几毫秒），彻底排空上一条连接残留的 `DISCONNECT`。
+2. `net_connect_locked()`：`open_socket()` 成功后再次读空本 Socket 中断状态，作为双保险。
+
+### 注意事项
+- 任何"关闭→复用同一 Socket 0 重新建连"的场景都必须先排空旧连接的中断，否则旧 `DISCONNECT` 会串扰新连接。
+- 若关闭后阻塞等待影响实时性（多连接模式另有 Socket），应改为非阻塞的"代次/epoch"机制；单连接模式直接排空即可。
+- `net_close_locked` 内阻塞 `osDelay` 仅在 netTask 上下文，单连接模式无其它并发 Socket，安全。
+
+### 对应文件
+`Drivers/BSP/NET/net_socket.c`（`net_close_locked` 排空残留 DISCONNECT；`net_connect_locked` open 后清中断）。
+
+### 发现时间
+阶段 7 NET 层 TCP Client 上板实测，2026-08-25。
+
+## Trap 18：多 Socket 模式切换 + 8 个 Socket 缓冲分配
+
+### 现象
+阶段 7 仅测了 Socket 0（单连接模式只有 Socket 0 可用）。要验证 Socket 1~7 也能作为 client，必须把 `FUN_PARA` 从单 Socket 模式切到多 Socket 模式，否则 `open_socket(1~7)` 被芯片拒绝/无响应，1~7 完全不可用。
+
+### 根因
+`CMD_SET_FUN_PARA` 的 **bit0** 决定 Socket 数量模式：`0`=单 Socket 模式（仅 Socket 0，8KB 缓冲全归它）；`1`=多 Socket 模式（Socket 0~7 全部可用，缓冲需自行分配）。之前 `net_init` 用 `0x08`（bit0=0）即单 Socket 模式，故 1~7 不存在。注意 bit1（TCP Server 单/多连接）与 bit0 是两回事：本方案只翻 bit0（多 Socket），bit1 保持 0（TCP Server 单连接），即"8 个 Socket 可用，但 Socket 0 作服务端时只接 1 客户端"。
+
+### 解决
+1. `net_init`：`ch395f_set_fun_para(0x09)`（bit0=1, bit1=0, bit3=1）。
+2. `ch395f_init()` 之后，循环 0~7 用 `ch395f_set_send_buf(sock, i*6+4, 2)` / `ch395f_set_recv_buf(sock, i*6, 4)` 给每个 Socket 分配独立收发缓冲。按手册 §5.45（48 块 × 512B = 24KB）+ §9.2.8 最优分配：每 Socket 6 块 = 接收 4 块(2KB) + 发送 2 块(1KB)，`ch395f_set_tcp_mss(1024)`，恰好用尽 0~47 块、互不重叠。
+3. MSS 选取依据 §9.2.8：接收缓冲(2KB) ≥ 2×MSS(1024) 满足建议、≥ MSS 满足必须；发送缓冲(1KB) ≤ 8KB 满足必须。MSS 取 1024 为 8-Socket 共享 24KB 时的最大值。
+4. `net_init` 缓冲分配顺序遵循 Trap 01：先配数据 Socket，再配监听 Socket 0（本 Net 层 Socket 按需 open，故统一在 init 一次性配好）。UDP 路径 `net_socket()` 中对 Socket 4~7 的兜底重设也同步为同一布局。
+5. PC 端 `tcp_server` 改为每连接一线程的并发回显（`--max-conn` 为并发计数），否则 Phase 7 全量连接会触发累计计数上限而拒掉 4~7（Trap 19）。
+
+### 注意事项
+- 4~7 的缓冲必须显式分配，否则其 CONNECT/RECV 中断不触发（Trap 01/02）。
+- 上述布局**以手册 §5.45 的 48×512B 缓冲几何为准**，并已由 Phase 7 TC704（40/40 PASS）实测确认块 0~47 全部有效（此前文档中"32×1KB"记录有误）。Socket 4~7 分配与 8 路并发回显均验证通过。
+- 多 Socket 模式下 TCP Server 单连接语义不变：Socket 0 监听且连接停留在本 Socket，Sockets 1~7 由应用当作独立 client 使用。
+- `net_poll` 用 `GET_GLOB_INT_STATUS_ALL`（2 字节，支持 0~7）并遍历 0~7，Socket n 中断位即 `bit(n+4)`（Socket 0~3→bit4~7，Socket 4~7→bit8~11），原代码正确无需改动。
+
+### 对应文件
+`Drivers/BSP/NET/net_socket.c`（`net_init` FUN_PARA + 缓冲分配 + MSS）；`test/net_test_task.c`（新增 TC704 八 Socket 并发回显）；`test/ch395f_socket_test.py`（`tcp_server` 并发 + `--max-conn`）。
+
+### 发现时间
+阶段 7 扩展 8 Socket 测试，2026-08-25。
+
+## Trap 20：发送缓冲区单次写入超过硬件 FIFO 上限（写穿）
+
+### 现象
+大文件/批量发送（如阶段 8 的 100KB，或 FTP 上传）时，数据在中间某处错乱、连接被对端 RST、或在 `WRITE_SEND_BUF` 后芯片不再产生 `SEND_OK`，表现为发送卡死或后续字节丢失。该问题只在单次发送长度 > 1KB 时稳定复现。
+
+### 根因
+`net_send_locked`（TCP）与 `net_sendto`（UDP）在分块时以 **`NET_DMA_MAX_PAYLOAD`(2KB) / `NET_SEND_BUF_SIZE`(4KB)** 作为单次写长度上限，但 CH395F 每个 Socket 的**硬件发送 FIFO 只有 `CH395F_SEND_BLOCKS × CH395F_RAM_BLOCK_SIZE` = 2×512 = 1KB**（由 MSS=1024 推导，见 `ch395f.h`）。当某次调用 `net_send/sendto` 传入 >1KB 数据，驱动会在 `send_ready` 置位后一次性 `WRITE_SEND_BUF(2KB/4KB)`，直接**写穿 1KB 发送 FIFO**（超出部分覆盖/丢失或破坏 FIFO 指针），导致后续数据错位。原代码误把"SPI DMA 缓冲上限(2KB)"或"软件 API 缓冲(4KB)"当成硬件发送缓冲上限。
+
+### 解决
+1. `ch395f.h` 新增硬件缓冲字节宏：`CH395F_SEND_BUF_SIZE_BYTES = CH395F_SEND_BLOCKS × CH395F_RAM_BLOCK_SIZE`（=1KB），并补充 `CH395F_RECV_BUF_SIZE_BYTES`。
+2. `net_socket.c` 新增 `NET_SEND_CHUNK_MAX = min(NET_DMA_MAX_PAYLOAD, CH395F_SEND_BUF_SIZE_BYTES)`，即**以硬件发送 FIFO 为硬上限**（当前 1KB < 2KB DMA 载荷，故生效 1KB）。
+3. `net_send_locked` 与 `net_sendto` 的单次写长度上限均由原来的 `NET_DMA_MAX_PAYLOAD`/`NET_SEND_BUF_SIZE` 改为 `NET_SEND_CHUNK_MAX`。`send_ready` 门控保证只有 FIFO 空闲时才写入，故写入 ≤1KB 安全（写满后等 `SEND_OK` 再写下一块）。
+4. 接收方向不受影响：`net_recv_locked` 只读 `ch395f_get_recv_len`（≤ 接收 FIFO 2KB）并受调用方 `len` 截断，不会写穿。
+
+### 注意事项
+- 该上限由 `CH395F_TCP_MSS` 推导，若将来调大 MSS 使发送缓冲 >2KB，则 `NET_SEND_CHUNK_MAX` 自动跟随（仍取硬件缓冲与 DMA 载荷的较小者），无需改此处逻辑。
+- 调用方（阶段 8、FTP `lftpd`）仍可按任意长度调用 `net_send`，实际分块由驱动保证 ≤ 硬件 FIFO。
+
+### 对应文件
+`Drivers/BSP/CH395F/ch395f.h`（`CH395F_SEND_BUF_SIZE_BYTES` 等）；`Drivers/BSP/NET/net_socket.c`（`NET_SEND_CHUNK_MAX` + `net_send_locked`/`net_sendto` 分块上限）。
+
+### 发现时间
+阶段 8 大文件传输实现，2026-08-26。