网络主要内容测试完成

2026-08-26 13:54:52 +08:00
parent 0a707034cc
commit 88160a5134
18 changed files with 2174 additions and 928 deletions
--- a/App/task/net_task.c
+++ b/App/task/net_task.c
@@ -48,6 +48,13 @@ int net_stack_bring_up(void)
    DBG_INFO("MAC: %02X:%02X:%02X:%02X:%02X:%02X",
             mac[0], mac[1], mac[2], mac[3], mac[4], mac[5]);
    uint8_t ipinf[20];
    ch395f_get_ip_inf(ipinf);
    DBG_INFO("IP_INF: IP=%d.%d.%d.%d GW=%d.%d.%d.%d MASK=%d.%d.%d.%d",
             ipinf[0], ipinf[1], ipinf[2], ipinf[3],
             ipinf[4], ipinf[5], ipinf[6], ipinf[7],
             ipinf[8], ipinf[9], ipinf[10], ipinf[11]);
    ch395f_set_phy(CH395F_PHY_100M_FULL);
    HAL_Delay(3000);
    uint8_t phy = ch395f_get_phy_status();
--- a/Drivers/BSP/CH395F/ch395f.c
+++ b/Drivers/BSP/CH395F/ch395f.c
@@ -925,7 +925,7 @@ uint8_t ch395f_get_dhcp_status(void) {
 /*
 * 函数功能：设置Socket协议类型
- * 入口参数：sock - Socket索引  uint8_t  0 - 3
+ * 入口参数：sock - Socket索引  uint8_t  0 - 7
 *           proto - 协议类型  uint8_t  CH395F_PROTO_TYPE_xxx
 * 限定条件：Socket必须处于关闭状态
 */
@@ -948,7 +948,7 @@ void ch395f_set_proto_type(uint8_t sock, uint8_t proto) {
 /*
 * 函数功能：设置Socket目标IP地址
- * 入口参数：sock - Socket索引  uint8_t  0 - 3
+ * 入口参数：sock - Socket索引  uint8_t  0 - 7
 *           p_ip - 4字节目标IP指针  uint8_t*
 * 限定条件：p_ip不可为NULL
 */
@@ -980,7 +980,7 @@ void ch395f_set_des_ip(uint8_t sock, uint8_t *p_ip) {
 /*
 * 函数功能：设置Socket目标端口（小端格式）
- * 入口参数：sock - Socket索引  uint8_t  0 - 3
+ * 入口参数：sock - Socket索引  uint8_t  0 - 7
 *           port - 目标端口号  uint16_t
 */
 void ch395f_set_des_port(uint8_t sock, uint16_t port) {
@@ -1005,7 +1005,7 @@ void ch395f_set_des_port(uint8_t sock, uint16_t port) {
 /*
 * 函数功能：设置Socket源端口（小端格式）
- * 入口参数：sock - Socket索引  uint8_t  0 - 3
+ * 入口参数：sock - Socket索引  uint8_t  0 - 7
 *           port - 源端口号  uint16_t
 */
 void ch395f_set_sour_port(uint8_t sock, uint16_t port) {
@@ -1105,7 +1105,7 @@ uint8_t ch395f_tcp_disconnect(uint8_t sock) {
 /*
 * 函数功能：向Socket发送缓冲区写入数据（DMA批量传输）
- * 入口参数：sock - Socket索引  uint8_t  0 - 3
+ * 入口参数：sock - Socket索引  uint8_t  0 - 7
 *           p_data - 数据指针  uint8_t*
 *           len - 数据长度  uint16_t
 * 限定条件：1. p_data不可为NULL
@@ -1149,7 +1149,7 @@ void ch395f_write_send_buf(uint8_t sock, uint8_t *p_data, uint16_t len) {
 /*
 * 函数功能：从Socket接收缓冲区读取数据（DMA批量传输）
- * 入口参数：sock - Socket索引  uint8_t  0 - 3
+ * 入口参数：sock - Socket索引  uint8_t  0 - 7
 *           p_data - 输出缓冲区指针  uint8_t*
 *           len - 待读取数据长度  uint16_t
 * 限定条件：1. p_data不可为NULL
@@ -1193,8 +1193,8 @@ void ch395f_read_recv_buf(uint8_t sock, uint8_t *p_data, uint16_t len) {
 /*
 * 函数功能：获取Socket接收缓冲区中数据长度
- * 入口参数：sock - Socket索引  uint8_t  0 - 3
+ * 入口参数：sock - Socket索引  uint8_t  0 - 7
- * 返回值：接收数据长度  uint16_t
+ * 返回值：接收数据长度  uint16_t，实际上 ch395F 接收缓冲区最大也就 8192
 * 限定条件：Socket必须已打开
 */
 uint16_t ch395f_get_recv_len(uint8_t sock) {
--- a/Drivers/BSP/CH395F/ch395f.h
+++ b/Drivers/BSP/CH395F/ch395f.h
@@ -110,12 +110,31 @@ extern "C" {
 /* 3 字节输入 + 数据输入（socket + 长度 + 数据） */
 #define CH395F_CMD_WRITE_SEND_BUF_SN     0x39U
 /*
 * TCP MSS（CH395F_CMD_SET_TCP_MSS 参数）
 * 由 net_init 经 ch395f_set_tcp_mss() 下发；此处作为单一真值源，
 * DMA 缓冲大小亦由此推导（见下）。当前选取依据：8 Socket 共享 24KB 缓冲时，
 * 各 Socket 接收缓冲 = 2×MSS，故 MSS 取 1024 为最大值（详见 net_socket.c 分配注释）。
 */
 #define CH395F_TCP_MSS                  1024U
 /* 内部缓冲 RAM 每块字节数（手册 §5.45：48 块 × 512B = 24KB） */
 #define CH395F_RAM_BLOCK_SIZE          512U
 /* 单 Socket 缓冲块数由 MSS 推导：接收 = 2×MSS（满足手册 §9.2.8 接收 ≥ 2×MSS），发送 = 1×MSS；向上取整 */
 #define CH395F_RECV_BLOCKS             ((2U * CH395F_TCP_MSS + CH395F_RAM_BLOCK_SIZE - 1U) / CH395F_RAM_BLOCK_SIZE)
 #define CH395F_SEND_BLOCKS             ((CH395F_TCP_MSS + CH395F_RAM_BLOCK_SIZE - 1U) / CH395F_RAM_BLOCK_SIZE)
 /* 单 Socket 硬件收发缓冲字节数（= 块数 × 块大小）。写入发送 FIFO 的单次长度严禁超过此值，
 * 否则会写穿有限的发送缓冲（见 Trap 20）。 */
 #define CH395F_SEND_BUF_SIZE_BYTES     (CH395F_SEND_BLOCKS * CH395F_RAM_BLOCK_SIZE)
 #define CH395F_RECV_BUF_SIZE_BYTES     (CH395F_RECV_BLOCKS * CH395F_RAM_BLOCK_SIZE)
 /*
 * SPI DMA 事务限制
 * CH395F_SPI_DMA_MAX_PAYLOAD: 单次 DMA 事务最大有效载荷（总缓冲 - 4 字节命令头）
- * 注意: CH395F 内部 socket 接收缓冲默认 4096B，DMA 缓冲需至少 4100 以一次性读空
+ * 接收方向需一次性读空整个 Socket 接收缓冲（= 2×MSS，避免 Trap 13 部分读导致数据不可见），
 * 故总缓冲 = 2×MSS + 4（4 为命令头开销），有效载荷 = 2×MSS。
 */
-#define CH395F_SPI_DMA_BUF_SIZE         4100U
+#define CH395F_SPI_DMA_BUF_SIZE         (CH395F_TCP_MSS * 2U + 4U)
 #define CH395F_SPI_DMA_MAX_PAYLOAD      (CH395F_SPI_DMA_BUF_SIZE - 4U)
 /* 其他命令 */
--- a/Drivers/BSP/NET/net_select.c
+++ b/Drivers/BSP/NET/net_select.c
@@ -41,10 +41,13 @@ static int check_socket_error(int sockfd);
 *           timeout  - 超时时间结构体指针                                       net_timeval *（NULL=无限等待）
 * 出口参数：readfds/writefds/exceptfds - 仅保留就绪的 Socket 位                  net_fd_set *
 * 返回值：就绪的 Socket 数量（>= 0）；-1 表示参数无效                           int
- * 限定条件：net_init() + MX_FREERTOS_Init() 已执行；必须在 netTask 上下文中调用
+ * 限定条件：net_init() + MX_FREERTOS_Init() 已执行；可在任意任务上下文调用
- * 函数说明：1. 轮询所有 Socket，检查读/写/异常事件是否就绪
+ * 函数说明：1. 轮询 Socket 控制块（RAM）中的读/写/异常状态，判断事件是否就绪
- *           2. 阻塞等待直到有事件就绪或超时
+ *           2. 不在此直接访问 CH395F SPI——所有 ch395f 事务统一由 netTask 的 net_poll()
- *           3. 通过 osDelay(1) 让出 CPU，平衡实时性与 CPU 利用率
+ *              每 10ms 串行执行并刷新控制块状态（send_ready / readable），本函数仅做
 *              RAM 读取，避免与应用任务发起的 SPI 访问竞争（见 Trap 16）
 *           3. 阻塞等待直到有事件就绪或超时
 *           4. 通过 osDelay(1) 让出 CPU，平衡实时性与 CPU 利用率（状态刷新延迟 <=10ms）
 */
 int net_select(int nfds, net_fd_set *readfds, net_fd_set *writefds,
                net_fd_set *exceptfds, net_timeval *timeout) {
@@ -70,9 +73,7 @@ int net_select(int nfds, net_fd_set *readfds, net_fd_set *writefds,
    start_tick = HAL_GetTick();
    while (1) {
-        /* 轮询所有 Socket */
+        /* 仅读取 netTask 的 net_poll() 已刷新的控制块状态（无 CH395F SPI 访问） */
        net_poll();
        ready_count = 0;
        /* 检查哪个 Socket 有事件 */
@@ -146,10 +147,11 @@ int net_select(int nfds, net_fd_set *readfds, net_fd_set *writefds,
 *           timeout - 超时时间（毫秒）                                          int    >= 0（-1=无限等待，但本实现按 >=0 处理）
 * 出口参数：fds[i].revents - 填充实际发生的事件掩码                            short
 * 返回值：就绪的 fd 数量（>= 0）；-1 表示参数无效                              int
- * 限定条件：net_init() + MX_FREERTOS_Init() 已执行；必须在 netTask 上下文中调用
+ * 限定条件：net_init() + MX_FREERTOS_Init() 已执行；可在任意任务上下文调用
- * 函数说明：1. 轮询所有 Socket，检查读/写/错误/挂起事件是否就绪
+ * 函数说明：1. 轮询 Socket 控制块（RAM）中的读/写/错误/挂起状态，判断事件是否就绪
- *           2. 阻塞等待直到有事件就绪或超时
+ *           2. 不在此直接访问 CH395F SPI——状态由 netTask 的 net_poll() 每 10ms 刷新
- *           3. 通过 osDelay(1) 让出 CPU，平衡实时性与 CPU 利用率
+ *           3. 阻塞等待直到有事件就绪或超时
 *           4. 通过 osDelay(1) 让出 CPU，平衡实时性与 CPU 利用率（状态刷新延迟 <=10ms）
 */
 int net_poll_events(net_pollfd *fds, int nfds, int timeout) {
    uint32_t start_tick;
@@ -163,9 +165,7 @@ int net_poll_events(net_pollfd *fds, int nfds, int timeout) {
    start_tick = HAL_GetTick();
    while (1) {
-        /* 轮询 */
+        /* 仅读取 netTask 的 net_poll() 已刷新的控制块状态（无 CH395F SPI 访问） */
        net_poll();
        ready = 0;
        for (i = 0; i < nfds; i++) {
@@ -248,7 +248,6 @@ int net_poll_events(net_pollfd *fds, int nfds, int timeout) {
 */
 static int check_socket_readable(int sockfd) {
    net_sock_t *p_sock;
    uint16_t recv_len;
    p_sock = net_get_sock(sockfd);
    if (NULL == p_sock) {
@@ -260,13 +259,11 @@ static int check_socket_readable(int sockfd) {
        return 1;
    }
-    /* 已建立连接的 Socket 有数据可读 */
+    /* 已建立连接或 UDP 等有数据可读：readable 由 net_poll 在 RECV_OK 时置位、
-    if (NET_SOCK_STATE_ESTABLISHED == p_sock->state) {
+     * net_recv_locked 读空后清零。避免应用任务直接访问 CH395F SPI（见 Trap 16） */
-        recv_len = ch395f_get_recv_len(sockfd);
+    if (p_sock->readable) {
        if (0 < recv_len) {
        return 1;
    }
    }
    return 0;
 }
--- a/Drivers/BSP/NET/net_socket.c
+++ b/Drivers/BSP/NET/net_socket.c
@@ -65,7 +65,9 @@ static void parse_ip_string(const char *str, uint8_t *ip_arr);
 static int net_send_locked(net_sock_t *p_sock, const void *buf, int len);
 static int net_recv_locked(net_sock_t *p_sock, void *buf, int len, int flags);
 static int net_close_locked(net_sock_t *p_sock);
 static int net_relisten_locked(net_sock_t *p_sock);
 static int net_accept_locked(int sockfd, struct net_sockaddr *addr, int *addrlen);
 static int net_connect_locked(int sockfd, const struct net_sockaddr *addr, int addrlen);
 /*
 * 函数功能：网络子系统初始化（配置 CH395F + 启用多连接模式）
@@ -104,13 +106,18 @@ int net_init(const char *ip, const char *mask, const char *gateway) {
    ch395f_reset();
    DBG_INFO("net_init: set_fun_para...");
-    /* 启用单连接模式 + 手动关闭 Socket（bit3=1, bit1=0）
+    /* 多 Socket 模式 + TCP Server 单连接 + 手动关闭 Socket（bit0=1, bit1=0, bit3=1）
     * bit0=1: 多 Socket 模式，启用 Socket 0~7（单 Socket 模式下 1~7 被禁用）
     * bit1=0: TCP Server 单连接，监听 Socket 0 仅接受 1 个客户端（连接停留在 Socket 0 本身）
     * bit3=1: DISCONNECT/TIMEOUT 时不自动清空缓冲区，由软件排空数据后手动关闭 */
-    ch395f_set_fun_para(0x08);
+    ch395f_set_fun_para(0x09);
    DBG_INFO("net_init: set_tcp_mss...");
-    /* 设置 TCP MSS */
+    /* 设置 TCP MSS
-    ch395f_set_tcp_mss(1460);
+     * 手册(§5.45)：CH395F 内部缓冲共 48 块 × 512B = 24KB。下方为 8 个 Socket 各分配 6 块
     * （接收 4 块=2KB + 发送 2 块=1KB），按手册 §9.2.8（接收 ≥ 2×MSS 建议）取 MSS=1024，用满 48 块。
     * MSS 真值源为 ch395f.h 的 CH395F_TCP_MSS，DMA 缓冲大小亦由其推导。 */
    ch395f_set_tcp_mss(CH395F_TCP_MSS);
    /* 设置 TCP 重传参数（必须在 INIT_CH395 之前调用*/
    ch395f_set_retrans_count(8);        /* 重传 8 次*/
@@ -141,13 +148,31 @@ int net_init(const char *ip, const char *mask, const char *gateway) {
        ch395f_set_dhcp(1);
    }
-    /* 初始化 CH395F 协议栈（先不配置 buffer，测试默认值是否工作） */
+    /* 初始化 CH395F 协议栈 */
    ret = ch395f_init();
    if (ret != CH395F_STATUS_OK) {
        s_net_errno = NET_ERR;
        return -1;
    }
    /* 多 Socket 模式：为 Socket 0~7 各分配独立收发缓冲（必须在 OPEN_SOCKET 之前）
     * 手册(§5.45)：CH395F 内部缓冲共 48 块 × 512B = 24KB；芯片上电默认仅给 Socket 0~3
     * 分配（每 Socket 接收 8 块/发送 4 块），Socket 4~7 为 NULL，故用到 8 个 Socket 必须重分配。
     * 单 Socket 块数由 MSS 推导（ch395f.h）：接收 CH395F_RECV_BLOCKS(=2×MSS/512=4 块=2KB)、
     * 发送 CH395F_SEND_BLOCKS(=1×MSS/512=2 块=1KB)，每 Socket 共 6 块，MSS=1024 用满 48 块：
     *   blocks_per_socket = CH395F_RECV_BLOCKS + CH395F_SEND_BLOCKS
     *   recv_start = i * blocks_per_socket，        send_start = recv_start + CH395F_RECV_BLOCKS
     *   Socket 7 占块 42~47，恰好用尽 0~47，互不重叠。
     * 注：此布局以手册 §5.45（48×512B）为准；若实际芯片为其它缓冲规格需重新核算。
     * Trap 01：先配数据 Socket 1~7，再配监听 Socket 0。 */
    uint8_t blocks_per_socket = (uint8_t)(CH395F_RECV_BLOCKS + CH395F_SEND_BLOCKS);
    for (int i = NET_MAX_SOCKETS - 1; i >= 0; i--) {
        uint8_t recv_start = (uint8_t)(i * blocks_per_socket);
        uint8_t send_start = (uint8_t)(recv_start + CH395F_RECV_BLOCKS);
        ch395f_set_send_buf((uint8_t)i, send_start, (uint8_t)CH395F_SEND_BLOCKS);
        ch395f_set_recv_buf((uint8_t)i, recv_start, (uint8_t)CH395F_RECV_BLOCKS);
    }
    /* 使能 PING 响应 */
    ch395f_ping_enable(1);
@@ -207,9 +232,10 @@ int net_poll(void) {
            /* 取本 Socket 控制块（直接用数组下标，无需 net_get_sock 的越界判断） */
            net_sock_t *p_sock = &s_net_socks[i];
-            /* 全局中断状态 bit4~bit11 分别对应 socket0~socket7 的中断标志，
+            /* 全局中断状态（GET_GLOB_INT_STATUS_ALL 16 位）：Socket n 的中断位即 bit(n+4)。
-             * 对应位为 0 说明该 Socket 无中断，跳过以节省时间 */
+             * Socket 0~3 在低位字节 bit4~bit7；Socket 4~7 在高位字节的 bit0~3
-            if (!(int_status & (1U << (i + 4)))) {
+             * （即 16 位值的 bit8~bit11）。对应位为 0 说明该 Socket 无中断，跳过以节省时间。 */
            if (!(int_status & (1U << (i + 4U)))) {
                continue;
            }
@@ -307,7 +333,7 @@ void net_process_messages(void) {
            break;
        }
        case NET_MSG_CONNECT: {
-            msg.result = net_connect(msg.sockfd,
+            msg.result = net_connect_locked(msg.sockfd,
                                     (const struct net_sockaddr *)&msg.addr,
                                     msg.addrlen);
            break;
@@ -364,6 +390,7 @@ int net_socket(int domain, int type, int protocol) {
    p_sock->state = NET_SOCK_STATE_CREATED;
    p_sock->in_use = 1;
    p_sock->send_ready = 1;
    p_sock->readable = 0;
    return sockfd;
 }
@@ -419,10 +446,14 @@ int net_bind(int sockfd, const struct net_sockaddr *addr, int addrlen) {
    if (p_sock->type == NET_SOCK_DGRAM) {
        uint8_t status;
-        /* Socket 4-7 默认无收发缓冲，需显式分配 */
+        /* net_init 已为全部 8 个 Socket 分配缓冲；此处仅对 Socket 4~7 兜底重设，
         * 使用与 net_init 相同的布局（由 MSS 推导，见 net_init） */
        if (sockfd >= 4) {
-            ch395f_set_send_buf((uint8_t)sockfd, 28, 2);
+            uint8_t blocks_per_socket = (uint8_t)(CH395F_RECV_BLOCKS + CH395F_SEND_BLOCKS);
-            ch395f_set_recv_buf((uint8_t)sockfd, 30, 2);
+            uint8_t recv_start = (uint8_t)(sockfd * blocks_per_socket);
            uint8_t send_start = (uint8_t)(recv_start + CH395F_RECV_BLOCKS);
            ch395f_set_send_buf((uint8_t)sockfd, send_start, (uint8_t)CH395F_SEND_BLOCKS);
            ch395f_set_recv_buf((uint8_t)sockfd, recv_start, (uint8_t)CH395F_RECV_BLOCKS);
        }
        ch395f_set_proto_type((uint8_t)sockfd, CH395F_PROTO_TYPE_UDP);
@@ -505,6 +536,8 @@ int net_listen_locked(int sockfd) {
    /* 监听 Socket 进入 LISTENING 态 */
    p_sock->state = NET_SOCK_STATE_LISTENING;
    /* 单连接模式：连接断开后由 net 层自动回到 LISTEN（模拟 BSD 监听常驻） */
    p_sock->auto_relisten = 1;
    /* 单连接：CONNECT 中断直接作用于本 Socket 自身 */
    /*
@@ -584,6 +617,11 @@ static int net_accept_locked(int sockfd, struct net_sockaddr *addr, int *addrlen
    /* 单连接：本 Socket 自身在 CONNECT 后已转为 ESTABLISHED，
     * 只有处于 ESTABLISHED 才表示有可接受的连接；否则尚无连接 */
    if (p_listen_sock->state != NET_SOCK_STATE_ESTABLISHED) {
        /* 连接已断开（CLOSED）且启用自动重监听：先把 Socket 重新置回 LISTEN，
         * 下一次 accept 即可等待新连接（BSD 风格监听常驻） */
        if (p_listen_sock->state == NET_SOCK_STATE_CLOSED && p_listen_sock->auto_relisten) {
            net_relisten_locked(p_listen_sock);
        }
        s_net_errno = NET_ERR_WOULDBLOCK;
        return -1;
    }
@@ -652,22 +690,72 @@ int net_accept(int sockfd, struct net_sockaddr *addr, int *addrlen) {
 }
 /*
- * 函数功能：TCP Client 发起与服务器的连接
+ * 函数功能：TCP Client 发起与服务器的连接（线程安全版本，通过消息队列委托给 netTask）
 * 入口参数：sockfd   - Socket 描述符 (0~7)，必须为已创建的 TCP Socket          int
 *           addr     - 服务器地址结构体指针                                    const struct net_sockaddr *
 *           addrlen  - 地址结构体长度                                          int >= sizeof(struct net_sockaddr_in)
 * 返回值：0 - 连接请求发送成功（异步，需等待 ESTABLISHED）                     int
 *         -1 - 连接失败（参数无效、状态错误等）                               int
 * 限定条件：Socket 已通过 net_socket() 创建且 type == NET_SOCK_STREAM；尚未连接
- * 函数说明：设置目标 IP 和端口后打开 CH395F Socket，进入 CONNECTING 状态。连接建立需等待
+ * 函数说明：将连接请求放入消息队列，阻塞等待 netTask 处理完毕。实际的 SPI 操作在 netTask
- *          net_poll() 检测到 CONNECT 事件并将状态更新为 ESTABLISHED
+ *          上下文中执行，避免与 net_poll() 的 SPI 访问产生竞争（否则会破坏 CH395F 寄存器）。
 *          连接建立需等待 net_poll() 检测到 CONNECT 事件并将状态更新为 ESTABLISHED
 */
 int net_connect(int sockfd, const struct net_sockaddr *addr, int addrlen) {
    net_msg_t msg;
    if (sockfd < 0 || sockfd >= NET_MAX_SOCKETS) {
        s_net_errno = NET_ERR_BADF;
        return -1;
    }
    if (NULL == netMsgQueueHandle) {
        s_net_errno = NET_ERR;
        return -1;
    }
    if (NULL == addr || addrlen < (int)sizeof(struct net_sockaddr_in)) {
        s_net_errno = NET_ERR_INVAL;
        return -1;
    }
    msg.type    = NET_MSG_CONNECT;
    msg.sockfd  = sockfd;
    msg.buf     = NULL;
    msg.len     = 0;
    msg.flags   = 0;
    memcpy(&msg.addr, addr, sizeof(struct net_sockaddr_in));
    msg.addrlen = addrlen;
    msg.caller  = xTaskGetCurrentTaskHandle();
    msg.result  = -1;
    if (osMessageQueuePut(netMsgQueueHandle, &msg, 0, osWaitForever) != osOK) {
        s_net_errno = NET_ERR_BUSY;
        return -1;
    }
    {
        uint32_t s_notified;
        xTaskNotifyWait(0, 0, &s_notified, portMAX_DELAY);
        msg.result = (int)s_notified;
    }
    if (msg.result < 0) {
        s_net_errno = NET_ERR;
    }
    return msg.result;
 }
 /*
 * 函数功能：TCP Client 发起连接（netTask 内部锁定版本，由消息队列委托执行）
 * 限定条件：net_init() 已调用；必须在 netTask 上下文中调用
 */
 static int net_connect_locked(int sockfd, const struct net_sockaddr *addr, int addrlen) {
    net_sock_t *p_sock;
    const struct net_sockaddr_in *p_addr_in;
    uint8_t status;
-    /* 参数检<EFBFBD>?*/
+    /* 参数检查 */
    if (sockfd < 0 || sockfd >= NET_MAX_SOCKETS) {
        s_net_errno = NET_ERR_BADF;
        return -1;
@@ -690,24 +778,56 @@ int net_connect(int sockfd, const struct net_sockaddr *addr, int addrlen) {
    p_sock->remote_ip = p_addr_in->sin_addr.s_addr;
    p_sock->remote_port = net_ntohs(p_addr_in->sin_port);
-    /* 转换 IP 为数组格式（低字节在前） */
+    /* 转换 IP 为数组格式（大端/网络字节序，与 ch395f set_des_ip 期望一致，
-    p_sock->remote_ip_arr[0] = (uint8_t)(p_sock->remote_ip);
+     * 同 Phase2 phase2_tc201 的 test_parse_ip 结果 [192,168,1,2]） */
-    p_sock->remote_ip_arr[1] = (uint8_t)(p_sock->remote_ip >> 8);
+    p_sock->remote_ip_arr[0] = (uint8_t)(p_sock->remote_ip >> 24);
-    p_sock->remote_ip_arr[2] = (uint8_t)(p_sock->remote_ip >> 16);
+    p_sock->remote_ip_arr[1] = (uint8_t)(p_sock->remote_ip >> 16);
-    p_sock->remote_ip_arr[3] = (uint8_t)(p_sock->remote_ip >> 24);
+    p_sock->remote_ip_arr[2] = (uint8_t)(p_sock->remote_ip >> 8);
    p_sock->remote_ip_arr[3] = (uint8_t)(p_sock->remote_ip);
-    /* 配置 CH395F Socket */
+    /* 配置 CH395F Socket：先 OPEN 再写源/目的端口（避免 open 复位寄存器） */
    ch395f_set_proto_type(sockfd, CH395F_PROTO_TYPE_TCP);
-    ch395f_set_sour_port(sockfd, p_sock->local_port);
+
-    ch395f_set_des_ip(sockfd, p_sock->remote_ip_arr);
+    /* CH395F 关闭 Socket 后需延时才能重新打开（Trap 09），故失败重试最多 3 次 */
-    ch395f_set_des_port(sockfd, p_sock->remote_port);
+    for (int open_try = 0; open_try < 3; open_try++) {
        status = ch395f_open_socket(sockfd);
        if (status == CH395F_ERR_SUCCESS) {
            break;  /* 打开成功，退出重试 */
        }
        ch395f_close_socket(sockfd);  /* 打开失败先关闭，再延时后重试 */
        HAL_Delay(500);
    }
    if (status != CH395F_ERR_SUCCESS) {
        s_net_errno = NET_ERR_BUSY;
        return -1;
    }
    /* 清掉本 Socket 可能残留的中断状态，丢弃上一条连接遗留的 DISCONNECT */
    (void)ch395f_get_sock_int_status((uint8_t)sockfd);
    (void)ch395f_get_glob_int_status_all();
    ch395f_set_sour_port(sockfd, p_sock->local_port);
    ch395f_set_des_ip(sockfd, p_sock->remote_ip_arr);
    ch395f_set_des_port(sockfd, p_sock->remote_port);
    /* 诊断：回读目的 IP/端口与 Socket 状态（GET_REMOT_IPP 为小端，故需按小端解析） */
    {
        uint8_t rip[6];
        uint8_t st = 0;
        uint32_t dip;
        uint16_t dp;
        ch395f_get_remot_ipp((uint8_t)sockfd, rip);
        ch395f_get_socket_status((uint8_t)sockfd, &st);
        dip = ((uint32_t)rip[3] << 24) | ((uint32_t)rip[2] << 16) |
              ((uint32_t)rip[1] << 8) | rip[0];
        dp = ((uint16_t)rip[5] << 8) | rip[4];
        DBG_INFO("[CONN] sock%d openOK dest=%d.%d.%d.%d:%d status=0x%02X",
                 sockfd,
                 (dip >> 24) & 0xFF, (dip >> 16) & 0xFF,
                 (dip >> 8) & 0xFF, dip & 0xFF, dp, st);
    }
    /* 发起 TCP 连接 */
    ch395f_tcp_connect(sockfd);
    p_sock->state = NET_SOCK_STATE_CONNECTING;
@@ -719,6 +839,11 @@ int net_connect(int sockfd, const struct net_sockaddr *addr, int addrlen) {
 * SPI DMA 单次事务最大有效载荷（取 CH395F 驱动公开常量）
 */
 #define NET_DMA_MAX_PAYLOAD           ((int)CH395F_SPI_DMA_MAX_PAYLOAD)
 /* 单次写入 CH395F 发送 FIFO 的最大字节数：受硬件发送缓冲(CH395F_SEND_BUF_SIZE_BYTES=1KB)
 * 与 SPI DMA 载荷(NET_DMA_MAX_PAYLOAD=2KB) 双重限制，以硬件发送缓冲为硬上限（见 Trap 20），
 * 否则单次写 2KB/4KB 会写穿 1KB 发送 FIFO。 */
 #define NET_SEND_CHUNK_MAX            ((int)CH395F_SEND_BUF_SIZE_BYTES < NET_DMA_MAX_PAYLOAD ? \
                                        (int)CH395F_SEND_BUF_SIZE_BYTES : NET_DMA_MAX_PAYLOAD)
 /*
 * 函数功能：发送数据（内部锁定版本，必须在 netTask 上下文调用）
@@ -731,7 +856,7 @@ int net_connect(int sockfd, const struct net_sockaddr *addr, int addrlen) {
 * 出口参数：无
 * 返回值：实际发送字节数（>= 0）；-1 表示参数无效或 Socket 未连接      int
 * 限定条件：p_sock 非空；Socket 处于 ESTABLISHED 状态；netTask 上下文
- * 函数说明：1. 按 NET_DMA_MAX_PAYLOAD 分块写入 CH395F 发送缓冲区
+ * 函数说明：1. 按 NET_SEND_CHUNK_MAX（硬件发送缓冲上限，见 Trap 20）分块写入 CH395F 发送 FIFO
 *           2. 发送前等待 send_ready 置位，超时返回已发送字节数
 *           3. 每写完一块等待 SEND_OK 中断（send_ready 清零后重新置位）
 */
@@ -754,8 +879,8 @@ static int net_send_locked(net_sock_t *p_sock, const void *buf, int len) {
    while (sent < len) {
        int chunk = len - sent;
-        if (chunk > NET_DMA_MAX_PAYLOAD) {
+        if (chunk > NET_SEND_CHUNK_MAX) {
-            chunk = NET_DMA_MAX_PAYLOAD;
+            chunk = NET_SEND_CHUNK_MAX;
        }
        if (!p_sock->send_ready) {
@@ -786,9 +911,6 @@ static int net_send_locked(net_sock_t *p_sock, const void *buf, int len) {
    return sent;
 }
 /*
 * 函数功能：接收数据（内部锁定版本，必须在 netTask 上下文调用）
 */
 /*
 * 函数功能：接收数据（内部锁定版本，必须在 netTask 上下文调用）
 * 入口参数：p_sock - Socket 控制块指针                                  net_sock_t *
@@ -803,7 +925,7 @@ static int net_send_locked(net_sock_t *p_sock, const void *buf, int len) {
 *           3. CLOSED 状态尝试排空接收缓冲区残余数据（Trap 13：FIN 可能先于数据到达）
 */
 static int net_recv_locked(net_sock_t *p_sock, void *buf, int len, int flags) {
-    uint16_t recv_len;
+    int recv_len;
    uint32_t tick_start;
    int sockfd = (int)(p_sock - s_net_socks);
@@ -819,15 +941,24 @@ static int net_recv_locked(net_sock_t *p_sock, void *buf, int len, int flags) {
        recv_len = ch395f_get_recv_len(sockfd);
        if (recv_len > 0) {
-            int read_len = (recv_len > (uint16_t)len) ? len : (int)recv_len;
+            int read_len = (recv_len > len) ? len : recv_len;
            DBG_INFO("recv sock%d len=%d", sockfd, recv_len);
            ch395f_read_recv_buf(sockfd, (uint8_t *)buf, (uint16_t)read_len);
            p_sock->recv_bytes += (uint32_t)read_len;
            p_sock->readable = 0;   /* 已消费数据（注：部分读受 Trap 13 限制，下一次 RECV_OK 会重新置位） */
            HAL_Delay(1);  /* 等待 CH395F 刷新 recv_len 寄存器 */
            return read_len;
        }
        if (flags & NET_MSG_DONTWAIT) {
            /* 非阻塞且当前无数据：若连接已断开则视为 EOF(0) 并自动重监听，
             * 否则返回 WOULDBLOCK(-1) 表示暂时无数据 */
            if (p_sock->state == NET_SOCK_STATE_CLOSED) {
                if (p_sock->auto_relisten) {
                    net_relisten_locked(p_sock);
                }
                return 0;
            }
            s_net_errno = NET_ERR_WOULDBLOCK;
            return -1;
        }
@@ -840,13 +971,18 @@ static int net_recv_locked(net_sock_t *p_sock, void *buf, int len, int flags) {
        if (p_sock->state == NET_SOCK_STATE_CLOSED) {
            /* 断开前尝试排空 CH395F 接收缓冲区（Trap 13：FIN 可能比数据先到） */
-            uint16_t rem = ch395f_get_recv_len(sockfd);
+            int rem = ch395f_get_recv_len(sockfd);
            if (rem > 0) {
-                int rd = (rem > (uint16_t)len) ? len : (int)rem;
+                int rd = (rem > len) ? len : rem;
                ch395f_read_recv_buf(sockfd, (uint8_t *)buf, (uint16_t)rd);
                p_sock->recv_bytes += (uint32_t)rd;
                p_sock->readable = 0;
                return rd;
            }
            /* EOF：单连接模式自动回到 LISTEN，应用下次 net_accept 即接到新连接 */
            if (p_sock->auto_relisten) {
                net_relisten_locked(p_sock);
            }
            return 0;
        }
    }
@@ -864,10 +1000,82 @@ static int net_recv_locked(net_sock_t *p_sock, void *buf, int len, int flags) {
 * 函数说明：1. 调用 ch395f_close_socket 关闭 CH395F 硬件 Socket
 *           2. 清空整个控制块（memset 0），释放该 Socket 资源
 */
-static int net_close_locked(net_sock_t *p_sock) {
+/*
 * 函数功能：单连接模式断连后自动重新进入 LISTEN（不清空控制块，保留 fd）
 * 入口参数：p_sock - 已断开（CLOSED）的 TCP 监听型 Socket 控制块          net_sock_t *
 * 返回值：0 - 成功，-1 - 失败
 * 限定条件：netTask 上下文；p_sock->in_use == 1；保留 local_port/auto_relisten
 * 函数说明：1. 复用原本地端口与协议，重新 OPEN + TCP_LISTEN（Trap 09 重试）
 *           2. 仅将 state 置回 LISTENING，不 memset（fd 与 auto_relisten 保持不变）
 *           3. 实现 BSD 风格"监听 Socket 常驻"，应用层无需手动重监听
 */
 static int net_relisten_locked(net_sock_t *p_sock) {
    uint8_t status;
    int sockfd = (int)(p_sock - s_net_socks);
    ch395f_set_proto_type((uint8_t)sockfd, CH395F_PROTO_TYPE_TCP);
    ch395f_set_sour_port((uint8_t)sockfd, p_sock->local_port);
    for (int open_try = 0; open_try < 3; open_try++) {
        status = ch395f_open_socket((uint8_t)sockfd);
        if (status == CH395F_ERR_SUCCESS) {
            break;
        }
        ch395f_close_socket((uint8_t)sockfd);  /* 打开失败先关闭，再延时后重试 */
        HAL_Delay(500);
    }
    if (status != CH395F_ERR_SUCCESS) {
        s_net_errno = NET_ERR_BUSY;
        return -1;
    }
    status = ch395f_tcp_listen((uint8_t)sockfd);
    if (status != CH395F_ERR_SUCCESS) {
        s_net_errno = NET_ERR_BUSY;
        return -1;
    }
    p_sock->state      = NET_SOCK_STATE_LISTENING;
    p_sock->remote_port = 0;
    p_sock->remote_ip   = 0;
    memset(p_sock->remote_ip_arr, 0, sizeof(p_sock->remote_ip_arr));
    p_sock->send_ready  = 0;
    p_sock->recv_bytes  = 0;
    /* auto_relisten 保持为 1，下次断连仍自动重监听 */
    for (int j = 0; j < NET_MAX_SOCKETS; j++) {
        (void)ch395f_get_sock_int_status((uint8_t)j);
    }
    (void)ch395f_get_glob_int_status_all();
    DBG_INFO("sock%d auto-relisten ok", sockfd);
    return 0;
 }
 static int net_close_locked(net_sock_t *p_sock) {
    int sockfd = (int)(p_sock - s_net_socks);
    uint32_t tick = HAL_GetTick();
    ch395f_close_socket(sockfd);
    /* 排空上一条连接残留的 DISCONNECT 中断（单连接模式仅有 Socket 0，
     * 复用同一 Socket 时，旧连接的 DISCONNECT 在 FIN/ACK 完成后才上报，
     * 若不清除会被下一连接误判为"刚建立就断开"）。等待芯片回到 CLOSED
     * 并清掉 Socket/全局中断状态，避免事件串扰。 
    */
    do {
        uint8_t st = 0;
        ch395f_get_socket_status((uint8_t)sockfd, &st);
        (void)ch395f_get_sock_int_status((uint8_t)sockfd);
        (void)ch395f_get_glob_int_status_all();
        if (st == CH395F_SOCKET_CLOSED) {
            break;
        }
        if (HAL_GetTick() - tick > 500) {
            break;
        }
        osDelay(5);
    } while (1);
    memset(p_sock, 0, sizeof(net_sock_t));
    return 0;
@@ -876,47 +1084,61 @@ static int net_close_locked(net_sock_t *p_sock) {
 /*
 * 函数功能：发送数据（线程安全版本，通过消息队列委托给 netTask）
 * 入口参数：sockfd - Socket 描述符                                                  int >= 0 && < NET_MAX_SOCKETS
- *           buf    - 待发送数据缓冲区指针                                            const void *
+ *           buf    - 待发送数据缓冲区指针（调用返回前须保持有效，本函数不拷贝数据）  const void *
- *           len    - 数据长度                                                        int > 0
+ *           len    - 数据长度（字节），> 0                                           int
- *           flags  - 标志位，通常为 0                                                int
+ *           flags  - 标志位，当前实现忽略（保留 BSD send 接口兼容）                  int
 * 返回值：实际发送字节数                                                            int >= 0 || -1
- *         -1       - 发送失败（参数无效、队列满等）                                int
+ *         -1       - 发送失败（参数非法 / 消息队列入队失败 / netTask 侧发送错误）    int
- * 限定条件：Socket 处于 ESTABLISHED 状态；net_init() + MX_FREERTOS_Init() 已执行；非 netTask 上下文
+ * 限定条件：1. 必须在【非 netTask】上下文中调用（应用/测试任务）；若在 netTask 内调用会自己等自己
- * 函数说明：将发送请求放入消息队列，阻塞等待 netTask 处理完毕并返回结果。netTask 内请使用 net_send_sock()
+ *              （netTask 阻塞在 xTaskNotifyWait 而无人处理消息）→ 死锁。netTask 内请直接用 net_send_locked()。
 *           2. Socket 须处于 ESTABLISHED 状态；net_init() + MX_FREERTOS_Init() 已执行；
 *              netMsgQueueHandle 已由 net_init 创建。
 * 函数说明：所有 CH395F SPI 访问只允许在 netTask 内串行执行（见 Trap 16）。本函数作为应用侧 API，
 *           自身不直接触碰 SPI，而是把发送请求打包成 net_msg_t 投递到 netMsgQueueHandle，由 netTask
 *           的 net_process_messages() 取出并在 netTask 上下文调用 net_send_locked() 真正写 CH395F。
 *           调用方通过 FreeRTOS TaskNotify 阻塞等待处理结果，从而对外呈现"同步发送"语义：
 *           函数返回即代表本次发送已被 netTask 处理完毕（成功或失败）。
 */
 int net_send(int sockfd, const void *buf, int len, int flags) {
-    (void)flags;
+    (void)flags;               /* flags 当前未使用，显式 void 以消除未用参数告警 */
-    net_msg_t msg;
+    net_msg_t msg;             /* 一次性消息结构体；入队后由 netTask 取出处理（注意只传指针不拷贝数据） */
    /* ---- 1. 参数合法性检查 ---- */
    if (sockfd < 0 || sockfd >= NET_MAX_SOCKETS) {
-        s_net_errno = NET_ERR_BADF;
+        s_net_errno = NET_ERR_BADF;   /* 描述符越界 */
        return -1;
    }
    /* ---- 2. 运行环境检查：消息队列须已创建（网络层已初始化） ---- */
    if (NULL == netMsgQueueHandle) {
-        s_net_errno = NET_ERR;
+        s_net_errno = NET_ERR;        /* 网络层未初始化 */
        return -1;
    }
-    msg.type = NET_MSG_SEND;
+    /* ---- 3. 组装消息：把本次 send 的全部上下文填入 msg ---- */
-    msg.sockfd = sockfd;
+    msg.type   = NET_MSG_SEND;                /* 消息类型，netTask 据此分派到 net_send_locked */
-    msg.buf = (void *)buf;
+    msg.sockfd = sockfd;                      /* 目标 Socket */
-    msg.len = len;
+    msg.buf    = (void *)buf;                 /* 数据缓冲（队列仅拷贝指针，buf 须有效至函数返回） */
-    msg.flags = 0;
+    msg.len    = len;                         /* 待发送字节数 */
-    msg.caller = xTaskGetCurrentTaskHandle();
+    msg.flags  = 0;                           /* 实际标志位（忽略入参 flags） */
-    msg.result = -1;
+    msg.caller = xTaskGetCurrentTaskHandle(); /* 记录调用任务句柄，供 netTask 回执时精准通知 */
    msg.result = -1;                         /* 预置失败；netTask 处理成功后会改写为实际发送字节数 */
    /* ---- 4. 入队：将消息投递给 netTask，osWaitForever 表示队列满时阻塞调用方 ---- */
    if (osMessageQueuePut(netMsgQueueHandle, &msg, 0, osWaitForever) != osOK) {
-        s_net_errno = NET_ERR_BUSY;
+        s_net_errno = NET_ERR_BUSY;   /* 入队失败（队列异常等极端情况） */
        return -1;
    }
    /* ---- 5. 阻塞等待 netTask 处理完毕：netTask 调 net_send_locked 后通过
     *        xTaskNotify() 唤醒本任务，并把结果（实际发送字节数或 -1）作为通知值传回 ---- */
    {
        uint32_t s_notified;
-        xTaskNotifyWait(0, 0, &s_notified, portMAX_DELAY);
+        xTaskNotifyWait(0, 0, &s_notified, portMAX_DELAY);  /* 一直阻塞直到被 netTask 通知 */
-        msg.result = (int)s_notified;
+        msg.result = (int)s_notified;                       /* 取回 netTask 写入的结果 */
    }
    /* ---- 6. 结果回传：负数视为错误并设置线程级错误码；否则返回实际发送字节数 ---- */
    if (msg.result < 0) {
        s_net_errno = NET_ERR;
    }
@@ -1057,13 +1279,13 @@ int net_sendto(int sockfd, const void *buf, int len, int flags,
    if (NULL != dest_addr && addrlen >= (int)sizeof(struct net_sockaddr_in)) {
        p_addr_in = (const struct net_sockaddr_in *)dest_addr;
-        /* 转换 IP 为数组格<EFBFBD>?*/
+        /* 转换 IP 为大端数组（同 TCP 客户端，set_des_ip 期望大端） */
        uint8_t ip_arr[4];
        uint32_t ip = p_addr_in->sin_addr.s_addr;
-        ip_arr[0] = (uint8_t)(ip);
+        ip_arr[0] = (uint8_t)(ip >> 24);
-        ip_arr[1] = (uint8_t)(ip >> 8);
+        ip_arr[1] = (uint8_t)(ip >> 16);
-        ip_arr[2] = (uint8_t)(ip >> 16);
+        ip_arr[2] = (uint8_t)(ip >> 8);
-        ip_arr[3] = (uint8_t)(ip >> 24);
+        ip_arr[3] = (uint8_t)(ip);
        ch395f_set_des_ip(sockfd, ip_arr);
        ch395f_set_des_port(sockfd, net_ntohs(p_addr_in->sin_port));
@@ -1074,8 +1296,8 @@ int net_sendto(int sockfd, const void *buf, int len, int flags,
    /* 发送数<E98081>?*/
    while (sent < len) {
        int chunk = len - sent;
-        if (chunk > NET_SEND_BUF_SIZE) {
+        if (chunk > NET_SEND_CHUNK_MAX) {
-            chunk = NET_SEND_BUF_SIZE;
+            chunk = NET_SEND_CHUNK_MAX;
        }
        /* 检查发送缓冲区 */
@@ -1122,7 +1344,7 @@ int net_sendto(int sockfd, const void *buf, int len, int flags,
 int net_recvfrom(int sockfd, void *buf, int len, int flags,
                 struct net_sockaddr *src_addr, int *addrlen) {
    net_sock_t *p_sock;
-    uint16_t recv_len;
+    int recv_len;
    uint32_t tick_start;
    /* 参数检<E695B0>?*/
@@ -1172,7 +1394,7 @@ int net_recvfrom(int sockfd, void *buf, int len, int flags,
            /* 读取数据 */
            if (recv_len > 0) {
-                int read_len = (recv_len > (uint16_t)len) ? len : (int)recv_len;
+                int read_len = (recv_len > len) ? len : recv_len;
            ch395f_read_recv_buf(sockfd, (uint8_t *)buf, (uint16_t)read_len);
            p_sock->recv_bytes += (uint32_t)read_len;
            return read_len;
@@ -1505,6 +1727,7 @@ static void handle_disconnect_event(net_sock_t *p_sock) {
 static void handle_recv_event(net_sock_t *p_sock) {
    /* RECV_OK 中断已触发，直接通知上层。不在此读 recv_len，
     * 避免和 net_recv_locked 里面的 ch395f_get_recv_len 冲突（Trap 13） */
    p_sock->readable = 1;   /* 置可读标志，供 net_select 在无 SPI 访问下判读 */
    fire_event(p_sock, NET_EVENT_DATA_RECEIVED);
 }
--- a/Drivers/BSP/NET/net_types.h
+++ b/Drivers/BSP/NET/net_types.h
@@ -149,7 +149,7 @@ typedef struct {
    uint16_t            local_port;             /* 本地端口（主机序） */
    uint16_t            remote_port;            /* 远端端口（主机序） */
    uint32_t            remote_ip;              /* 远端 IP（网络字节序） */
-    uint8_t             remote_ip_arr[4];       /* 远端 IP 数组（低字节在前） */
+    uint8_t             remote_ip_arr[4];       /* 远端 IP 数组（大端/网络字节序） */
    /* 事件回调（可选） */
    net_event_cb_t      event_cb;
@@ -158,6 +158,14 @@ typedef struct {
    /* 发送就绪标志 */
    uint8_t             send_ready;
    /* 接收可读标志：net_poll 检测到 RECV_OK 时置 1，net_recv_locked 读空后清零。
     * net_select 据此判断可读性，从而无需在应用/测试任务上下文直接访问 CH395F SPI
     * （所有 ch395f 事务统一由 netTask 串行执行，避免与 net_poll 竞争，见 Trap 16）。 */
    uint8_t             readable;
    /* 单连接模式自动重监听：连接断开后由 net 层自动回到 LISTEN（BSD 风格监听常驻） */
    uint8_t             auto_relisten;
    /* 统计信息 */
    uint32_t            recv_bytes;             /* 累计接收字节数 */
    uint32_t            send_bytes;             /* 累计发送字节数 */
--- a/MDK-ARM/STM32F407-Demo.uvprojx
+++ b/MDK-ARM/STM32F407-Demo.uvprojx
@@ -2009,6 +2009,11 @@
              <FileType>1</FileType>
              <FilePath>..\test\ch395f_test_task.c</FilePath>
            </File>
            <File>
              <FileName>net_test_task.c</FileName>
              <FileType>1</FileType>
              <FilePath>..\test\net_test_task.c</FilePath>
            </File>
          </Files>
        </Group>
        <Group>
--- a/MDK-ARM/build_log.txt
+++ b/MDK-ARM/build_log.txt
@@ -1,37 +1,37 @@
 *** Using Compiler 'V5.06 update 7 (build 960)', folder: 'C:\Keil_v5\ARM\ARMCC\Bin'
 Rebuild target 'STM32F407-Demo'
 assembling startup_stm32f407xx.s...
 compiling ringbuf.c...
 compiling crc.c...
 compiling ringbuf.c...
 compiling stm32f4xx_hal_flash_ramfunc.c...
 compiling stm32f4xx_hal_gpio.c...
 compiling i2c.c...
 compiling stm32f4xx_hal_dma_ex.c...
 compiling stm32f4xx_hal_dma.c...
 compiling stm32f4xx_hal_timebase_tim.c...
 compiling stm32f4xx_hal_msp.c...
 compiling stm32f4xx_it.c...
 compiling app_main.c...
 compiling spi.c...
 compiling usart.c...
 compiling dma.c...
 compiling sys_clock.c...
 compiling stm32f4xx_hal_rcc_ex.c...
 compiling stm32f4xx_hal_flash.c...
 compiling gpio.c...
 compiling stm32f4xx_hal_flash_ex.c...
-compiling rs485_task.c...
+compiling stm32f4xx_hal_dma.c...
-compiling adc_task.c...
+compiling gpio.c...
 compiling stm32f4xx_hal_dma_ex.c...
 compiling stm32f4xx_hal_timebase_tim.c...
 compiling stm32f4xx_it.c...
 compiling sys_clock.c...
 compiling stm32f4xx_hal_rcc.c...
 compiling app_main.c...
 compiling dma.c...
 compiling spi.c...
 compiling stm32f4xx_hal_flash.c...
 compiling stm32f4xx_hal_msp.c...
 compiling usart.c...
 compiling stm32f4xx_hal_rcc_ex.c...
 compiling i2c.c...
 compiling adc_task.c...
 compiling rs485_task.c...
 compiling main.c...
 compiling stm32f4xx_hal_tim_ex.c...
 compiling freertos.c...
 compiling net_task.c...
 compiling freertos.c...
 compiling lftpd_string.c...
 compiling croutine.c...
 compiling stm32f4xx_hal_tim.c...
-compiling event_groups.c...
+compiling croutine.c...
 compiling list.c...
 compiling event_groups.c...
 compiling stream_buffer.c...
 compiling queue.c...
 compiling timers.c...
@@ -39,33 +39,34 @@ compiling tasks.c...
 compiling heap_4.c...
 compiling port.c...
 compiling journal.c...
 compiling stm32f4xx_hal_pwr.c...
 compiling map.c...
 compiling ff.c...
 compiling stm32f4xx_hal_pwr_ex.c...
 compiling stm32f4xx_hal_exti.c...
 compiling cmsis_os2.c...
 compiling stm32f4xx_hal_pwr.c...
 compiling system_stm32f4xx.c...
 compiling stm32f4xx_hal_i2c_ex.c...
 compiling stm32f4xx_hal_cortex.c...
 compiling stm32f4xx_hal_pwr_ex.c...
 compiling stm32f4xx_hal_exti.c...
 compiling lftpd_io.c...
 compiling stm32f4xx_hal.c...
 compiling ff.c...
 compiling sd2506.c...
 compiling rs485.c...
 compiling stm32f4xx_hal_spi.c...
-compiling ch395f.c...
+compiling stm32f4xx_hal.c...
 compiling cmsis_os2.c...
 compiling stm32f4xx_hal_i2c.c...
 compiling tpafe5160.c...
-compiling gd5f2gq5ue.c...
+compiling rs485.c...
-compiling net_select.c...
+compiling sd2506.c...
 compiling lftpd_inet.c...
 compiling nand_ftl.c...
 compiling ch395f.c...
 compiling lftpd_io.c...
 compiling lftpd_inet.c...
 compiling gd5f2gq5ue.c...
 compiling stm32f4xx_hal_uart.c...
 compiling net_select.c...
 compiling stm32f4xx_hal_i2c.c...
 compiling lftpd.c...
 compiling net_socket.c...
 compiling net_test_task.c...
 compiling ch395f_test_task.c...
 linking...
-Program Size: Code=49060 RO-data=1760 RW-data=228 ZI-data=69508  
+Program Size: Code=52664 RO-data=1992 RW-data=232 ZI-data=118672  
 FromELF: creating hex file...
 ".\STM32F407-Demo\STM32F407-Demo.axf" - 0 Error(s), 0 Warning(s).
-Build Time Elapsed:  00:00:15
+Build Time Elapsed:  00:00:17
--- 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,12 +329,14 @@ 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;
                }
@@ -343,7 +347,8 @@ void tcp_server_single(void)
                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 默认 |
+| CH395F 内部总缓冲 | **24KB（48 块 × 512B）** | 手册 §5.45；CH395F.md "内置 24K RAM"。**经 Phase 7 实测确认块 0~47 全部有效**（此前 32×1KB 记录有误） |
-| Socket 0 发送缓冲 | 4096B（硬件默认） | 未显式配置时使用 |
+| 上电默认分配 | Socket 0~3 各 接收8块(4KB)+发送4块(2KB)；Socket 4~7 未分配 | 见 §5.45，用到 >4 个 Socket 必须重分配 |
-| Socket 0 接收缓冲 | 4096B（硬件默认） | 未显式配置时使用 |
+| **本固件分配（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
+  → net_send_locked 分块写入 CH395F 发送缓冲（每 Socket 发送缓冲 1KB）
-  → 块 1: ch395f_write_send_buf(sock, buf[0..4095], 4096)    // DMA 事务 1
+  → 块 1: ch395f_write_send_buf(sock, buf[0..1023], 1024)     // DMA 事务 1
-  → 等待 SENDBUF_FREE
+  → 等待 SENBUF_FREE
-  → 块 2: ch395f_write_send_buf(sock, buf[4096..8191], 4096)  // DMA 事务 2
+  → 块 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_get_recv_len() 返回硬件缓冲中当前可用数据（≤2KB）
-  → ch395f_read_recv_buf() 一次性读空硬件缓冲（≤4096B/DMA 事务）
+  → ch395f_read_recv_buf() 一次性读空硬件缓冲（≤2KB/DMA 事务）
  → 循环直至全部 20480B 收完
 ```
 **边界条件**：
- 发送 `≤4096B`：一次 DMA 事务完成
+- 发送 `≤1KB`：一次写发送缓冲完成（受发送缓冲 1KB 限制）
- 发送 `4097B`：两次 DMA 事务（4096 + 1）
+- 接收缓冲满（2KB）：必须一次性读空，否则 `recv_len` 归零导致剩余数据丢失（Trap 13）
 - 接收缓冲满（4096B）：必须一次性读空，否则 `recv_len` 归零导致剩余数据丢失
 - 发送 `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)
 ---
-### 已知风险与待实施项
+## 7. 阶段 6：NET 层 TCP Server 回显
 | # | 事项 | 影响 | 状态 |
 |---|------|------|------|
 | 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 主动连接）
 | 阶段 ID | TM-PHY-06 |
 |---------|-----------|
 | **类型** | PC 配合，netTask 运行 |
-| **耗时** | 持续运行 |
+| **耗时** | 持续运行（Server 模式）/ 约 60s（Client 模式） |
-| **入口** | `ENABLE_PHASE6_TESTS`，`ch395fTestTask` TCP 回显循环中运行 |
+| **入口** | `ENABLE_PHASE6_TESTS` → `net_layer_test_main()`（`net_test_task.c`，持续监听回显循环） |
-| **出口** | 用户终止 |
+| **出口** | 用户终止（Server）/ 用例结束自动回到 IDLE（Client） |
-两部分组成：
+本阶段在 NET 层（单连接 socket，DP-01）经 `net_socket` API 驱动，MCU 作 TCP Server 监听 8080，PC 主动连接，验证回显通路、单连接生命周期与字节级完整性 —— 已实现（net 层自动重监听，应用层零生命周期代码）
- **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 重排）
+> 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（单连接） |
+| **标题** | 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. `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<br>2. Socket 0 收到 CONNECT → ESTABLISHED<br>3. 发数据 → 回显 |
+
-| **通过标准** | 仅 s0 状态变化；串口 `s0:int=0x08` → ESTABLISHED |
+**测试步骤与判定标准**：
-| **覆盖原则** | DP-01 |
+
 | 步 | 操作 | 成功标准 | 失败标准 |
 |----|------|----------|----------|
 | 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 回显 |
+| **标题** | 10 轮 64B TCP 回显（原样回显，小包） |
-| **测试步骤** | PC 发 10×64B，MCU 回显 |
+| **前置条件** | 同 TC-NET-601（连接已建立，ESTABLISHED） |
 | **通过标准** | 10/10 匹配 |
-### 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 回显 |
+| **标题** | 1460B 回显（注：当前固件 TCP MSS=1024，1460B 超过 MSS 将由 CH395F 按 MSS 分片） |
-| **测试步骤** | PC 发 1460B，MCU 回显 |
+| **前置条件** | 同 TC-NET-601（连接已建立） |
-| **通过标准** | 1460B 完全匹配，无截断 |
+
 **测试步骤与判定标准**：
 | 步 | 操作 | 成功标准 | 失败标准 |
 |----|------|----------|----------|
 | 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）回显 |
+| **标题** | 4096B 回显（接收缓冲仅 2KB，分两次取空） |
-| **前置条件** | DMABUF=4100 可一次性读空 |
+| **前置条件** | 同 TC-NET-601；`CH395F_SPI_DMA_BUF_SIZE=4100` 可一次性读空 2KB 硬件缓冲 |
-| **测试步骤** | PC 发 4096B，MCU 经 DMA 一次性读取并回显 |
+
-| **通过标准** | 4096B 完全匹配 |
+**测试步骤与判定标准**：
-| **覆盖原则** | DP-04 |
+
 | 步 | 操作 | 成功标准 | 失败标准 |
 |----|------|----------|----------|
 | 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 → 验证回显 |
+| **前置条件** | 同 TC-NET-601（连接已建立，已完成至少一轮 64B 回显） |
 | **通过标准** | 重连成功，回显正常 |
 | **覆盖原则** | DP-01 |
-### 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 自动重新监听 |
+| **标题** | 无干净 FIN 或 KeepAlive 超时后 Socket 0 自动重新监听 |
-| **测试步骤** | 1. PC 断连后停止响应<br>2. 等待 KeepAlive 触发 TIMEOUT<br>3. s0 → CLOSED → re-OPEN → LISTEN<br>4. PC 重连 → 验证回显 |
+| **前置条件** | 1. 同 TC-NET-601（连接已建立）<br>2. KeepAlive 触发场景需 `ENABLE_PHASE11_TESTS` 且 `ch395f_set_keepalive_*` 已配置（探测时长本身由 TC-NET-1101 覆盖） |
-| **通过标准** | 自动恢复，无需手动复位 |
+
-| **覆盖原则** | DP-01 |
+**测试步骤与判定标准**：
 | 步 | 操作 | 成功标准 | 失败标准 |
 |----|------|----------|----------|
 | 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+）
+### TC-NET-704: 8-Socket 并发 TCP Client（多 Socket 模式验证）
 | 阶段 ID | TM-PHY-07 |
 |---------|-----------|
 | **类型** | PC 配合，netTask 运行 |
 | **耗时** | 取决于文件大小和速率 |
 | **入口** | `ENABLE_PHASE7_TESTS` |
 | **配置** | `PHASE7_FILE_SIZE`（默认 20480）|
 ### TC-NET-701: 20KB 分块传输
 | 字段 | 值 |
 |------|-----|
-| **ID** | TC-NET-701 |
+| **ID** | TC-NET-704 |
 | **优先级** | P0 |
-| **类型** | 功能测试 |
+| **类型** | 功能测试 / 并发测试（NET 层） |
-| **标题** | 20480 字节 TCP 分块收发（>Socket 0 硬件缓冲 4KB） |
+| **标题** | 同时打开 8 个 Socket 连接 PC Server，各自 64B 收发 |
-| **前置条件** | `net_send_locked` 支持自动分块（每块 ≤4096B） |
+| **前置条件** | 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` 已定义 |
 | **测试步骤** | 1. MCU 填 20KB 递增模式数据<br>2. MCU 分块发送，每块 4096B<br>3. PC 回显<br>4. MCU 接收并逐字节验证 |
 | **通过标准** | 20KB 完全匹配，每字节验证通过 |
 | **覆盖原则** | DP-04 |
-### TC-NET-702: 64KB 传输（recv_len 上限）
+**测试步骤与判定标准**：
-| 字段 | 值 |
+| 步 | 操作 | 成功标准 | 失败标准 |
-|------|-----|
+|----|------|----------|----------|
-| **ID** | TC-NET-702 |
+| 1 | 循环 i=0..7：`net_socket()` 创建 8 个 TCP socket（本地端口 51000+i），`net_connect(192.168.1.2:8081)` | 8 个 `net_connect` 均返回 `0` | 任一返回 `-1` |
-| **优先级** | P1 |
+| 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` 失败 |
 | **标题** | 65535 字节传输（`recv_len` uint16 上限） |
 | **前置条件** | TC-NET-701 通过 |
 | **测试步骤** | 同 501，文件大小 65535 |
 | **通过标准** | 65535B 完全匹配 |
 | **覆盖原则** | DP-04 |
-### 实现说明
+**通过标准**：8/8 路全部通过，0 失败。任一失败 → 标记 FAIL
-`phase7_run()` 状态机（`ch395fTestTask` 内）：
+**覆盖原则**：DP-01（多 Socket 并发主路径）、缓冲架构（8×6 块分配，MSS=1024）
-```
+> **注**：PC 端 `--max-conn` 须为**并发**计数（连接关闭即减），否则 Phase 7 全量（701+702+704 共 12 连接）会按累计计数超限而拒掉 4~7（见 Trap 19）。该用例已随 Phase 7 实测 **40/40 PASS** 验证。
 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），接收端逐字节比较
 ---
-## 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-601 | P0 | 功能测试 | ✅ |
-| TM-PHY-06 | TC-NET-602 | P0 | 功能测试 | 🟡 |
+| TM-PHY-06 | TC-NET-602 | P0 | 功能测试 | ✅ |
-| TM-PHY-06 | TC-NET-603 | P0 | 边界测试 | 🟡 |
+| TM-PHY-06 | TC-NET-603 | P0 | 边界测试 | ✅ |
-| TM-PHY-06 | TC-NET-604 | P0 | 边界测试 | 🟡 |
+| TM-PHY-06 | TC-NET-604 | P0 | 边界测试 | ✅ |
-| TM-PHY-06 | TC-NET-605 | P0 | 恢复测试 | 🟡 |
+| TM-PHY-06 | TC-NET-605 | P0 | 恢复测试 | ✅ |
-| TM-PHY-06 | TC-NET-606 | P1 | 恢复测试 | 🟡 |
+| TM-PHY-06 | TC-NET-606 | P1 | 恢复测试 | ✅ |
-| TM-PHY-06 | TC-NET-607 | P0 | 功能测试 | 🟠 |
+| TM-PHY-07 | TC-NET-701 | P0 | 功能测试 | ✅ |
-| TM-PHY-06 | TC-NET-608 | P0 | 恢复测试 | 🟠 |
+| TM-PHY-07 | TC-NET-702 | P0 | 恢复测试 | ✅ |
-| TM-PHY-06 | TC-NET-609 | P1 | 负向测试 | 🟠 |
+| TM-PHY-07 | TC-NET-703 | P1 | 负向测试 | ✅ |
-| TM-PHY-07 | TC-NET-701 | P0 | 功能测试 | 🟡 |
+| TM-PHY-07 | TC-NET-704 | P0 | 并发测试 | ✅ |
-| TM-PHY-07 | TC-NET-702 | P1 | 边界测试 | 🟡 |
+| TM-PHY-08 | TC-NET-801 | P0 | 文件发送 | ✅ |
-| TM-PHY-08 | TC-NET-801 | P0 | 功能测试 | 🟡 |
+| TM-PHY-08 | TC-NET-802 | P0 | 文件接收 | 🟡 |
-| TM-PHY-08 | TC-NET-802 | P1 | 负向测试 | 🟡 |
+| TM-PHY-08 | TC-NET-803 | P1 | 回显/压力 | 🟡 |
-| TM-PHY-09 | TC-NET-901 | P0 | 边界测试 | 🟡 |
+| TM-PHY-09 | TC-NET-901 | P0 | 功能测试 | 🟡 |
-| TM-PHY-09 | TC-NET-902 | P0 | 边界测试 | 🟡 |
+| TM-PHY-09 | TC-NET-902 | P1 | 负向测试 | 🟡 |
-| TM-PHY-09 | TC-NET-903 | P0 | 边界测试 | 🟡 |
+| TM-PHY-10 | TC-NET-1001 | P0 | 边界测试 | 🟡 |
-| TM-PHY-09 | TC-NET-904 | P1 | 负向测试 | 🟡 |
+| TM-PHY-10 | TC-NET-1002 | P0 | 边界测试 | 🟡 |
-| TM-PHY-09 | TC-NET-905 | P1 | 压力测试 | 🟡 |
+| TM-PHY-10 | TC-NET-1003 | P0 | 边界测试 | 🟡 |
-| TM-PHY-09 | TC-NET-906 | P1 | 稳定性测试 | 🟡 |
+| TM-PHY-10 | TC-NET-1004 | P1 | 负向测试 | 🟡 |
-| TM-PHY-10 | TC-NET-1001 | 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-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, 801 |
+| 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。
--- a/rx_100k.bin
+++ b/rx_100k.bin
--- a/test/pycache/ch395f_socket_test.cpython-311.pyc
+++ b/test/pycache/ch395f_socket_test.cpython-311.pyc
--- a/test/ch395f_socket_test.py
+++ b/test/ch395f_socket_test.py
@@ -16,6 +16,7 @@ CH395F BSD Socket API 测试程序
    udp_echo     - UDP 回显服务器（测试双向通信）
    stress       - 压力测试（多连接并发测试）
    tcp_bulk     - 双向大块：先收满 bulk 字节（不回声，校验 LCG），再回放（阶段 5）
    tcp_file     - 文件收发：PC 作 Client 连 MCU:8080（阶段 8），--op send/recv 收发 100KB 文件（含 CRC32）
 选项:
    --ip         目标 IP 地址（默认: 192.168.1.100）
@@ -43,6 +44,11 @@ CH395F BSD Socket API 测试程序
     # 阶段 5 双向大块（先收 256KB 再回放 256KB）
     python ch395f_socket_test.py tcp_bulk --port 8081 --bulk 262144 --chunk 4096
     # 阶段 8 文件收发（PC 连 MCU:8080）
     python ch395f_socket_test.py tcp_file --ip 192.168.1.100 --port 8080 --op recv --file rx_100k.bin --size 102400
     python ch395f_socket_test.py tcp_file --ip 192.168.1.100 --port 8080 --op send --file tx_100k.bin
     python ch395f_socket_test.py tcp_file --ip 192.168.1.100 --port 8080 --op echo   # TC-NET-803 回显（MCU 为 server）
 """
 import socket
@@ -54,6 +60,7 @@ import threading
 import struct
 import random
 import string
 import zlib
 from datetime import datetime
 # TCP 回显服务器（tcp_server 模式）参数
@@ -100,6 +107,11 @@ def generate_data(size):
    return ''.join(random.choices(string.ascii_letters + string.digits, k=size)).encode()
 def gen_pattern(size, offset=0):
    """生成递增模式数据 (i+offset)&0xFF，与固件 §7 自检回显期望字节流一致"""
    return bytes(((offset + i) & 0xFF) for i in range(size))
 def verify_data(data, expected_len):
    """验证数据"""
    if len(data) != expected_len:
@@ -109,35 +121,71 @@ def verify_data(data, expected_len):
 # ==================== TCP 测试函数 ====================
 def _echo_conn_handler(conn_idx, client_socket, counters, lock):
    """每个连接一个线程：收到什么回什么，直到对端关闭或空闲超时。
    线程安全：通过 lock 更新共享计数器 counters（dict: total/bytes/errors）。
    """
    rx = 0
    client_socket.settimeout(ECHO_IDLE_TIMEOUT)
    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}")
        with lock:
            counters['errors'] += 1
    finally:
        client_socket.close()
        with lock:
            counters['active'] = max(0, counters['active'] - 1)
            counters['total'] += 1
            counters['bytes'] += rx
            if rx == 0:
                counters['errors'] += 1
                log_warn(f"连接#{conn_idx} 未收到任何数据")
            else:
                log_success(f"连接#{conn_idx} 完成: 回显 {rx} 字节")
 def tcp_server_test(args):
    """TCP 回显服务器测试（测试 CH395F TCP Client）
-    与固件 TC-NET-201/202 配套：MCU 连接后发送数据并等待原样回显，
+    与固件 TC701/702/704 配套：MCU 连接后发送数据并等待原样回显。
-    校验通过后主动关闭。本函数循环接受多个连接，每个连接内将收到的
+    每个连接由独立线程处理，支持多 Socket 并发（TC704 一次打开 8 个）。
    数据逐字回显，直到对端关闭或空闲超时。
-    首个连接等待 args.timeout 秒；之后每个连接间最多等待
+    首个连接等待 args.timeout 秒；之后每个连接间最多等待 INTER_ACCEPT_TIMEOUT 秒；
-    INTER_ACCEPT_TIMEOUT 秒，无新连接则结束并汇总。
+    若指定 --max-conn（>0），达到连接数上限后停止接受并等待全部线程结束。
-    返回 False 表示失败（无连接或回显出错），main 据此返回非 0 退出码。
+    无新连接则结束并汇总。返回 False 表示失败（无连接或回显出错）。
    """
    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)
-    conn_total = 0
+    counters = {'total': 0, 'bytes': 0, 'errors': 0, 'active': 0}
-    echo_bytes = 0
+    lock = threading.Lock()
-    conn_errors = 0
+    threads = []
    try:
        server_socket.bind(('0.0.0.0', args.port))
-        server_socket.listen(4)
+        server_socket.listen(16)
-        log_success(f"服务器启动，监听端口 {args.port}")
+        log_success(f"服务器启动，监听端口 {args.port}（并发回显，backlog=16）")
        conn_idx = 0
        while True:
            if args.max_conn and args.max_conn > 0 and counters['active'] >= args.max_conn:
                log_info(f"已达 --max-conn {args.max_conn}（并发），停止接受新连接")
                break
            wait = args.timeout if conn_idx == 0 else min(args.timeout, INTER_ACCEPT_TIMEOUT)
            server_socket.settimeout(wait)
            try:
@@ -151,41 +199,25 @@ def tcp_server_test(args):
                break
            conn_idx += 1
            with lock:
                counters['active'] += 1
            log_success(f"连接#{conn_idx} 来自: {client_addr[0]}:{client_addr[1]}")
            t = threading.Thread(target=_echo_conn_handler,
                                 args=(conn_idx, client_socket, counters, lock),
                                 daemon=True)
            t.start()
            threads.append(t)
-            # 回显循环：收到什么回什么（sendall 保证发完），对端关闭或空闲超时结束
+        # 等待所有连接线程结束（对端关闭或空闲超时）
-            client_socket.settimeout(ECHO_IDLE_TIMEOUT)
+        for t in threads:
-            rx = 0
+            t.join()
            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} 次")
+        log_info(f"服务结束: 连接 {counters['total']} 个, 回显 {counters['bytes']} 字节, 异常 {counters['errors']} 次")
-        if conn_total == 0:
+        if counters['total'] == 0:
            log_error("无任何客户端连接")
            return False
-        return conn_errors == 0
+        return counters['errors'] == 0
    except Exception as e:
        log_error(f"服务器错误: {e}")
@@ -318,18 +350,20 @@ def tcp_client_test(args):
        client_socket.connect((args.ip, args.port))
        log_success("连接成功!")
-        # 测试发送数据
+        # 测试发送数据（TC-NET-602: 64B 小包回显 ×args.count 轮）
        log_info("-" * 40)
-        log_info("测试 1: 发送数据")
+        log_info("测试 1: 64B 小包回显 (TC-NET-602)")
        pkt_offset = 0  # 单连接内期望字节流连续累计，与固件 s_phase6_off 同步
        for i in range(args.count):
            try:
-                test_data = generate_data(min(100, args.size))
+                test_data = gen_pattern(64, pkt_offset)
                pkt_offset += 64
                client_socket.send(test_data)
                log_success(f"发送数据 ({len(test_data)} bytes)")
                log_info(f"发送 hex: {' '.join(f'{b:02X}' for b in test_data[:16])}")
                # 等待回显
-                data = client_socket.recv(args.size)
+                data = client_socket.recv(64)
                if data:
                    log_info(f"接收 hex: {' '.join(f'{b:02X}' for b in data[:16])}")
                    log_info(f"接收长度: {len(data)}, 期望长度: {len(test_data)}")
@@ -337,7 +371,6 @@ def tcp_client_test(args):
                        log_success("回显数据匹配!")
                    else:
                        log_error("回显数据不匹配!")
                        # 找出第一个不同的字节
                        for j in range(min(len(data), len(test_data))):
                            if data[j] != test_data[j]:
                                log_error(f"首个差异: 位置 {j}, 发送={test_data[j]:02X}, 接收={data[j]:02X}")
@@ -351,49 +384,74 @@ def tcp_client_test(args):
                log_error(f"发送/接收错误: {e}")
                break
-        # 测试大数据量
+        # 测试 1460B MSS 回显（TC-NET-603）
        log_info("-" * 40)
-        log_info("测试 2: 大数据量传输")
+        log_info("测试 2: 1460B MSS 回显 (TC-NET-603)")
        try:
-            large_data = generate_data(min(1024, args.size))
+            test_data = gen_pattern(1460, pkt_offset)
-            client_socket.send(large_data)
+            pkt_offset += 1460
-            log_success(f"发送大数据 ({len(large_data)} bytes)")
+            client_socket.send(test_data)
            log_success(f"发送 1460B ({len(test_data)} bytes)")
            received = b""
-            while len(received) < len(large_data):
+            while len(received) < len(test_data):
-                chunk = client_socket.recv(min(1024, len(large_data) - len(received)))
+                chunk = client_socket.recv(min(1460, len(test_data) - len(received)))
                if not chunk:
                    break
                received += chunk
-            if received == large_data:
+            if received == test_data:
-                log_success("大数据传输完整!")
+                log_success("1460B 完全匹配!")
            else:
-                log_error(f"大数据传输不完整: 发送 {len(large_data)}, 接收 {len(received)}")
+                log_error(f"1460B 传输不完整: 发送 {len(test_data)}, 接收 {len(received)}")
        except Exception as e:
-            log_error(f"大数据传输错误: {e}")
+            log_error(f"1460B 传输错误: {e}")
-        # 测试快速收发
+        # 测试 4096B 缓冲满回显（TC-NET-604）
        log_info("-" * 40)
-        log_info("测试 3: 快速收发")
+        log_info("测试 3: 4096B 缓冲满回显 (TC-NET-604)")
        success_count = 0
        fail_count = 0
        start_time = time.time()
        for i in range(args.count):
        try:
-                test_data = f"FAST_{i:04d}".encode()
+            # 单 Socket 接收缓冲按 1KB block 配置为 2KB（set_recv_buf(sock,30,2)），
            # 4096B 单包会分两次 net_recv 取空，验证分次取数 + 回显 + 字节累计校验正确。
            test_data = gen_pattern(4096, pkt_offset)
            pkt_offset += 4096
            client_socket.send(test_data)
-                data = client_socket.recv(100)
+            log_success(f"发送 4096B ({len(test_data)} bytes)")
                if data and data == test_data:
                    success_count += 1
                else:
                    fail_count += 1
            except Exception as e:
                fail_count += 1
-        elapsed = time.time() - start_time
+            received = b""
-        log_info(f"快速收发结果: 成功 {success_count}, 失败 {fail_count}, 耗时 {elapsed:.2f}s")
+            while len(received) < len(test_data):
                chunk = client_socket.recv(min(4096, len(test_data) - len(received)))
                if not chunk:
                    break
                received += chunk
            if received == test_data:
                log_success("4096B 完全匹配!")
            else:
                log_error(f"4096B 传输不完整: 发送 {len(test_data)}, 接收 {len(received)}")
        except Exception as e:
            log_error(f"4096B 传输错误: {e}")
        # 测试断开重连（TC-NET-605）
        log_info("-" * 40)
        log_info("测试 4: 断开重连 (TC-NET-605)")
        try:
            client_socket.close()
            client_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
            client_socket.settimeout(10)
            client_socket.connect((args.ip, args.port))
            log_success("重连成功!")
            # 新连接：固件复位 s_phase6_off=0，PC 期望字节流从偏移 0 重新比对
            test_data = gen_pattern(64, 0)
            client_socket.send(test_data)
            data = client_socket.recv(64)
            if data == test_data:
                log_success("重连回显匹配!")
            else:
                log_error("重连回显不匹配!")
        except Exception as e:
            log_error(f"重连错误: {e}")
        client_socket.close()
        log_success("测试完成，连接已关闭")
@@ -1060,6 +1118,125 @@ def packet_size_test(args):
        client_socket.close()
 # ==================== 文件收发测试（配合固件阶段 8 / PHASE8_DIRECTION） ====================
 def tcp_file_test(args):
    """文件收发测试：PC 作 TCP Client 连接 MCU:8080（net_test_task 监听）
    协议：
      --op send : 读取 --file（或生成 --size 字节递增模式）发往 MCU，
                  末尾附 4 字节 CRC32（小端，zlib.crc32），供 MCU 整包校验。
      --op recv : 从 MCU 接收 --size 字节写 --file，逐字节比对递增模式并报告 CRC32。
      --op echo : PC 作 Client 连 MCU:8080，把 MCU 发来的数据原样回显，直到对端关闭。
    对应固件 PHASE8_DIRECTION：
      SEND(1)  -> PC 用 --op recv 收 MCU 发来的文件
      RECV(2)  -> PC 用 --op send 发文件（+CRC32 尾）给 MCU
      ECHO(0)  -> PC 用 --op echo 连 MCU:8080 回显（MCU 为 server，先发后收）
    """
    op = args.op
    size = args.size
    ip, port = args.ip, args.port
    if op not in ('send', 'recv', 'echo'):
        log_error("tcp_file: --op 必须为 send / recv / echo")
        return False
    client_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    client_socket.settimeout(args.timeout)
    try:
        log_info(f"正在连接 MCU TCP Server: {ip}:{port}")
        client_socket.connect((ip, port))
        log_success(f"已连接 {ip}:{port}")
    except Exception as e:
        log_error(f"连接失败: {e}")
        return False
    try:
        if op == 'send':
            # ---- 准备数据 ----
            if args.file and os.path.exists(args.file):
                with open(args.file, 'rb') as f:
                    data = f.read()
                if len(data) != size:
                    log_warn(f"文件大小 {len(data)} != --size {size}，以实际文件大小 {len(data)} 发送")
                size = len(data)
            else:
                log_info(f"无 --file，生成 {size} 字节递增模式数据")
                data = bytes((i & 0xFF) for i in range(size))
            crc = zlib.crc32(data) & 0xFFFFFFFF
            footer = struct.pack('<I', crc)
            # ---- 发送数据 + CRC32 尾 ----
            t0 = time.time()
            sent = 0
            while sent < size:
                n = client_socket.send(data[sent:size])
                if n <= 0:
                    log_error("发送中断")
                    return False
                sent += n
            sent_f = 0
            while sent_f < 4:
                n = client_socket.send(footer[sent_f:4])
                if n <= 0:
                    log_error("CRC 尾发送失败")
                    return False
                sent_f += n
            ms = int((time.time() - t0) * 1000)
            rate = (size / 1024.0 / (ms / 1000.0)) if ms else 0.0
            log_success(f"已发送 {size} 字节 -> {args.file or '(pattern)'}，"
                        f"CRC32=0x{crc:08X}，耗时 {ms}ms ({rate:.1f} KB/s)")
            return True
        elif op == 'recv':
            rx = bytearray()
            t0 = time.time()
            while len(rx) < size:
                chunk = client_socket.recv(min(65536, size - len(rx)))
                if not chunk:
                    log_error(f"对端提前关闭，仅收到 {len(rx)}/{size}")
                    return False
                rx += chunk
            ms = int((time.time() - t0) * 1000)
            rate = (size / 1024.0 / (ms / 1000.0)) if ms else 0.0
            ok = all(rx[i] == (i & 0xFF) for i in range(size))
            crc = zlib.crc32(bytes(rx)) & 0xFFFFFFFF
            if args.file:
                with open(args.file, 'wb') as f:
                    f.write(rx)
                log_info(f"已写入文件 {args.file}")
            log_success(f"已接收 {size} 字节，耗时 {ms}ms ({rate:.1f} KB/s)，"
                        f"递增模式校验={'通过' if ok else '失败'}，CRC32=0x{crc:08X}")
            return ok
        elif op == 'echo':
            # MCU 为 server：先发 100KB，PC 原样回显，MCU 收齐后关闭连接
            log_info("回显模式：将把 MCU 发来的数据原样返回，直到对端关闭")
            t0 = time.time()
            echoed = 0
            while True:
                data = client_socket.recv(65536)
                if not data:
                    break
                client_socket.sendall(data)
                echoed += len(data)
            ms = int((time.time() - t0) * 1000)
            rate = (echoed / 1024.0 / (ms / 1000.0)) if ms else 0.0
            log_success(f"回显完成，共 {echoed} 字节，耗时 {ms}ms ({rate:.1f} KB/s)")
            return True
    except socket.timeout:
        log_error("传输超时")
        return False
    except Exception as e:
        log_error(f"错误: {e}")
        return False
    finally:
        client_socket.close()
 # ==================== 主程序 ====================
 def main():
@@ -1078,7 +1255,7 @@ def main():
    parser.add_argument('mode', choices=['tcp_server', 'tcp_client', 'udp_server', 'udp_client',
                                          'tcp_echo', 'udp_echo', 'stress', 'packet_size',
-                                          'dhcp_server', 'tcp_bulk'],
+                                          'dhcp_server', 'tcp_bulk', 'tcp_file'],
                         help='测试模式')
    parser.add_argument('--ip', default='192.168.1.100', help='目标 IP 地址 / DHCP 待分配 IP')
    parser.add_argument('--port', type=int, default=8080, help='端口号')
@@ -1087,6 +1264,10 @@ def main():
    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('--op', choices=['send', 'recv', 'echo'], default='recv',
                        help='tcp_file 方向: send=读文件发往 MCU, recv=从 MCU 收文件落盘, echo=连 MCU 回显')
    parser.add_argument('--file', default=None, help='tcp_file 文件路经（send: 读取; recv: 写入）')
    parser.add_argument('--max-conn', type=int, default=0, help='最大并发连接数（默认0=不限；按并发计数，非累计，TC704 并发测试用 8）')
    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 分配的子网掩码')
    parser.add_argument('--dhcp-gw', default='192.168.1.1', help='DHCP 分配的网关')
@@ -1127,6 +1308,8 @@ def main():
            packet_size_test(args)
        elif args.mode == 'tcp_bulk':
            ret = tcp_bulk_test(args)
        elif args.mode == 'tcp_file':
            ret = tcp_file_test(args)
        elif args.mode == 'dhcp_server':
            dhcp_server_test(args)
    except KeyboardInterrupt:
--- a/test/ch395f_test.h
+++ b/test/ch395f_test.h
@@ -9,7 +9,7 @@
 * 修改记录：
 *     2026-07-22  全面重构为单连接模式，增加大文件传输、边界条件等测试
 *
- * === 测试阶段一览（硬件层 1~5 → NET 层 6~10，严格顺序执行） ===
+ * === 测试阶段一览（硬件层 1~5 → NET 层 6~11，严格顺序执行） ===
 * Phase    | 层       | 描述
 * ---------|----------|-----------------------------------------------
 * Phase 1  | 硬件层   | 独立运行：寄存器读写 + SPI 命令路径验证
@@ -18,10 +18,11 @@
 * Phase 4  | 硬件层   | PC 配合：DHCP 自动获取 IP
 * Phase 5  | 硬件层   | PC 配合：大文件分块回传（裸命令，tcp_server 配合）
 * Phase 6  | NET 层   | testTask：TCP Echo（单连接模式，基础收发验证）
- * Phase 7  | NET 层   | testTask：大文件传输（20KB+ 分块收发）
+ * Phase 7  | NET 层   | testTask：TCP Client 主动连接（回显收发 + 关闭重连 + 连接超时）
- * Phase 8  | NET 层   | testTask：Select/Poll I/O 多路复用
+ * Phase 8  | NET 层   | testTask：大文件传输（20KB+ 分块收发）
- * Phase 9  | NET 层   | testTask：边界条件测试（零长度、DMA 边界、缓冲溢出）
+ * Phase 9  | NET 层   | testTask：Select/Poll I/O 多路复用
- * Phase 10 | NET 层   | testTask：KeepAlive 超时断开测试
+ * Phase 10 | NET 层   | testTask：边界条件测试（零长度、DMA 边界、缓冲溢出）
 * Phase 11 | NET 层   | testTask：KeepAlive 超时断开测试
 */
 #ifndef __CH395F_TEST_H
@@ -38,7 +39,7 @@ extern "C" {
 *
 * 构建模式互斥（详见 docs/CH395F_Test_Guide.md「构建模式与执行顺序」）：
 *   硬件层模式（阶段 1~5）：netTask 不创建，ch395fTestTask 独占 CH395F
- *   NET 层模式 （阶段 6~10）：完整网络栈，netTask 轮询 + ch395fTestTask 监听循环
+ *   NET 层模式 （阶段 6~11）：完整网络栈，netTask 轮询 + ch395fTestTask 监听循环
 *
 * 注意：同层内可多选（Phase 6~10 共享 testTask 循环）；
 *       Phase 4 (DHCP) 会改变 IP，必须独立运行；
@@ -49,13 +50,14 @@ extern "C" {
 //#define ENABLE_PHASE2_TESTS     /* [硬] TCP Client 收发 + 关闭重连 */
 //#define ENABLE_PHASE3_TESTS     /* [硬] UDP Server Echo */
 //#define ENABLE_PHASE4_TESTS     /* [硬] DHCP 自动获取 IP（会改 IP！独立运行） */
-#define ENABLE_PHASE5_TESTS     /* [硬] 大文件传输（硬件层，PC 配合） */
+//#define ENABLE_PHASE5_TESTS     /* [硬] 大文件传输（硬件层，PC 配合） */
-/* ---- NET 层（阶段 6~10）---- */
+/* ---- NET 层（阶段 6~11）---- */
 //#define ENABLE_PHASE6_TESTS     /* [网] TCP Echo（单连接基础收发） */
-//#define ENABLE_PHASE7_TESTS     /* [网] 大文件传输（20KB+ 分块） */
+//#define ENABLE_PHASE7_TESTS     /* [网] TCP Client 主动连接（回显收发 + 关闭重连 + 连接超时） */
-//#define ENABLE_PHASE8_TESTS     /* [网] Select/Poll I/O 多路复用 */
+#define ENABLE_PHASE8_TESTS     /* [网] 大文件传输（100KB 文件收发） */
-//#define ENABLE_PHASE9_TESTS     /* [网] 边界条件测试 */
+//#define ENABLE_PHASE9_TESTS     /* [网] Select/Poll I/O 多路复用 */
-//#define ENABLE_PHASE10_TESTS    /* [网] KeepAlive 超时断开测试 */
+//#define ENABLE_PHASE10_TESTS    /* [网] 边界条件测试 */
 //#define ENABLE_PHASE11_TESTS    /* [网] KeepAlive 超时断开测试 */
 #if defined(ENABLE_PHASE1_TESTS) || defined(ENABLE_PHASE2_TESTS) || \
    defined(ENABLE_PHASE3_TESTS) || defined(ENABLE_PHASE4_TESTS) || \
@@ -65,12 +67,12 @@ extern "C" {
 #if defined(ENABLE_PHASE6_TESTS) || defined(ENABLE_PHASE7_TESTS) || \
    defined(ENABLE_PHASE8_TESTS) || defined(ENABLE_PHASE9_TESTS) || \
-    defined(ENABLE_PHASE10_TESTS)
+    defined(ENABLE_PHASE10_TESTS) || defined(ENABLE_PHASE11_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 构建模式与执行顺序"
+#error "硬件层(1~5)与NET层(6~11)测试互斥：请分两次构建，见 CH395F_Test_Guide 构建模式与执行顺序"
 #endif
 /* 测试统计 */
--- a/test/ch395f_test_task.c
+++ b/test/ch395f_test_task.c
@@ -3,7 +3,7 @@
 * 模块功能：CH395F 全阶段测试入口，统一在独立 FreeRTOS 任务中运行。
 *          测试分两组：
 *            Phase 1~5（硬件层）— 阻塞式独占执行（各自有内部循环/等待），netTask 未运行
- *            Phase 4~10（NET 层）— 事件驱动，TCP 监听循环中运行（需 PC 客户端连接）
+ *            Phase 4~11（NET 层）— 事件驱动，TCP 监听循环中运行（需 PC 客户端连接）
 *          所有测试结果通过 TEST_CHECK/TEST_REPORT 宏输出到串口。
 * 作者：王建锋
 * 创建日期：2026-07-22
@@ -11,6 +11,7 @@
 #include <string.h>
 #include "ch395f_test_task.h"
 #include "net_test_task.h"
 #include "cmsis_os.h"
 #include "net_task.h"
 #include "net_socket.h"
@@ -31,20 +32,6 @@ extern volatile uint8_t g_net_ready;
 */
 test_stats_t g_test_stats;
 /*
 * 收发缓冲区 —— 全局静态，不在任务栈上。
 * s_tx_buf 仅在 Phase 7（大文件传输）和 Phase 9（边界条件）中使用，
 * 其他 Phase 不需要发送固定模式数据，故条件编译节省 RAM。
 */
 #define TEST_BUF_SIZE       65536
 #if defined(ENABLE_PHASE6_TESTS)  || defined(ENABLE_PHASE7_TESTS) || \
    defined(ENABLE_PHASE8_TESTS)  || defined(ENABLE_PHASE9_TESTS) || \
    defined(ENABLE_PHASE10_TESTS)
 static uint8_t s_rx_buf[TEST_BUF_SIZE];
 #endif
 #if defined(ENABLE_PHASE7_TESTS) || defined(ENABLE_PHASE9_TESTS)
 static uint8_t s_tx_buf[TEST_BUF_SIZE];
 #endif
 /* ===================================================================
 * Phase 1 — 寄存器与 SPI 命令路径验证
@@ -55,7 +42,9 @@ static uint8_t s_tx_buf[TEST_BUF_SIZE];
 * 共 9 项测试（P1-01 ~ P1-09），逐项执行，汇总报告。
 * =================================================================== */
-/* 解析点分十进制 IP 字符串为数组（避免引入 sscanf 库） */
+/* 解析点分十进制 IP 字符串为数组（避免引入 sscanf 库）。
 * 仅硬件层阶段（1~5）使用，NET 层无需此辅助。 */
 #if defined(ENABLE_HW_LAYER_TESTS)
 static void test_parse_ip(const char *str, uint8_t *ip_arr)
 {
    uint32_t val;
@@ -73,6 +62,7 @@ static void test_parse_ip(const char *str, uint8_t *ip_arr)
        }
    }
 }
 #endif /* ENABLE_HW_LAYER_TESTS */
 #ifdef ENABLE_PHASE1_TESTS
 static void phase1_run(void) {
@@ -1351,385 +1341,10 @@ static void phase5_run(void) {
    TEST_REPORT("Phase 5");
 }
 #endif
 /* ===================================================================
 * Phase 6 — NET 层 TCP Echo（基础收发）
 *
 * 测试目的：验证 BSD Socket API（net_socket）的单连接 TCP Echo 通路。
 *          Socket 0 复用监听和数据通道。PC 发任意数据，MCU 原样返回。
 *          这是 Phase 7/8/9/10 的基础。
 *
 * 入口条件：Socket 0 处于 ESTABLISHED（TCP 连接已建立）。
 * 通过：数据收发一致。
 * 失败：send/recv 数量不匹配。
 * =================================================================== */
 #ifdef ENABLE_PHASE6_TESTS
 static uint32_t s_phase6_count = 0;
 static void phase6_run(int sockfd) {
    /*
     * 使用 NET_MSG_DONTWAIT 非阻塞接收 —— 没有数据时立即返回，
      * 不阻塞任务循环（Phase 7/8/9/10 也共享同一个循环）。
     * 收到数据后立即原样发送回显。
     */
    int n = net_recv(sockfd, s_rx_buf, TEST_BUF_SIZE, NET_MSG_DONTWAIT);
    if (n > 0) {
        int sent = net_send(sockfd, s_rx_buf, n, 0);
        if (sent != n) {
            DBG_ERROR("echo: send %d != recv %d", sent, n);
            return;
        }
        s_phase6_count++;
        if (s_phase6_count <= 10 || (s_phase6_count % 100 == 0)) {
            DBG_INFO("Phase6: echo #%lu (%d bytes)", s_phase6_count, n);
        }
    }
 }
 #endif
 /* ===================================================================
 * Phase 7 — 大文件传输（超过 CH395F 硬件缓冲 4KB）
 *
 * 测试目的：验证超过 Socket 0 接收缓冲（4KB）的数据在 net_send/
 *          net_recv 层的正确处理。net_send_locked 自动将大数据
 *          拆分为 ≤4096B 的块，每块通过一次 DMA 事务写入 CH395F。
 *          接收端同样分多次调用 ch395f_read_recv_buf 读空硬件缓冲。
 *
 * 数据模式：递增字节（s_tx_buf[i] = i & 0xFF），接收端按 offset 逐字节比对。
 * 通过：全部 20480 字节逐字节匹配。
 * 失败：任意字节不一致或收发过程中断。
 * =================================================================== */
 #ifdef ENABLE_PHASE7_TESTS
 #define PHASE7_FILE_SIZE        20480
 static void phase7_fill(uint8_t *buf, uint32_t size) {
    for (uint32_t i = 0; i < size; i++) {
        buf[i] = (uint8_t)(i & 0xFF);
    }
 }
 static int phase7_verify(uint8_t *buf, uint32_t size, uint32_t offset) {
    for (uint32_t i = 0; i < size; i++) {
        if (buf[i] != (uint8_t)((offset + i) & 0xFF)) {
            DBG_ERROR("Phase7: mismatch at %lu (expect 0x%02X, got 0x%02X)",
                      offset + i, (uint8_t)((offset + i) & 0xFF), buf[i]);
            return 0;
        }
    }
    return 1;
 }
 static void phase7_run(int sockfd) {
    DBG_INFO("Phase7: starting %d-byte file transfer", PHASE7_FILE_SIZE);
    phase7_fill(s_tx_buf, PHASE7_FILE_SIZE);
    /*
     * 发送阶段：分块发送，每块最多 4096B。
     * net_send 内部通过消息队列转发到 netTask，由 net_send_locked
     * 按 CH395F_SPI_DMA_MAX_PAYLOAD（4096）自动拆分 DMA 事务。
     * 等待 PC 端回显（echod）全部数据。
     */
    uint32_t sent = 0;
    while (sent < PHASE7_FILE_SIZE) {
        int chunk = (PHASE7_FILE_SIZE - sent) > 4096 ? 4096 : (PHASE7_FILE_SIZE - sent);
        int n = net_send(sockfd, s_tx_buf + sent, chunk, 0);
        if (n <= 0) {
            DBG_ERROR("Phase7: send fail at %lu (ret=%d)", sent, n);
            return;
        }
        sent += (uint32_t)n;
        DBG_INFO("Phase7: sent %lu/%d", sent, PHASE7_FILE_SIZE);
    }
    /*
     * 接收阶段：分块接收，逐块验证。
     * PC 回显数据需与发送数据逐字节一致（递增模式）。
     * 验证失败立即返回，不继续接收剩余数据。
     */
    uint32_t recvd = 0;
    while (recvd < PHASE7_FILE_SIZE) {
        int n = net_recv(sockfd, s_rx_buf, TEST_BUF_SIZE, 0);
        if (n <= 0) {
            DBG_ERROR("Phase7: recv fail at %lu (ret=%d)", recvd, n);
            return;
        }
        int ok = phase7_verify(s_rx_buf, (uint32_t)n, recvd);
        TEST_CHECK(ok, "Phase7: verify at %lu (%d bytes)", recvd, n);
        if (!ok) return;
        recvd += (uint32_t)n;
    }
    TEST_CHECK(1, "Phase7: %d-byte file transfer complete", PHASE7_FILE_SIZE);
 }
 #endif
 /* ===================================================================
 * Phase 8 — Select/Poll I/O 多路复用
 *
 * 测试目的：验证 net_select() API 在单 Socket 模式下正确工作：
 *          1. Socket 0 有数据到达时 select 返回正数
 *          2. NET_FD_ISSET 正确指示就绪的 Socket
 *          3. 超时（50ms 无数据）时返回 0
 *
 * 入口条件：Socket 0 处于 ESTABLISHED。
 * 通过：select 检测到数据并成功回显。
 * 失败：select 未检测到数据或回显失败。
 * =================================================================== */
 #ifdef ENABLE_PHASE8_TESTS
 #include "net_select.h"
 static uint32_t s_phase8_count = 0;
 static void phase8_run(int sockfd) {
    net_fd_set readfds;
    net_timeval tv;
    /*
     * 配置 select：只监测 Socket 0 的可读状态，超时 50ms。
     * NET_FD_ZERO 清空集合，NET_FD_SET 添加 Socket 0。
     * 50ms 超时确保不阻塞任务循环太久。
     */
    NET_FD_ZERO(&readfds);
    NET_FD_SET(sockfd, &readfds);
    tv.tv_sec = 0;
    tv.tv_usec = 50000;
    int nfds = net_select(sockfd + 1, &readfds, NULL, NULL, &tv);
    if (nfds <= 0) return;
    /* Socket 0 可读：非阻塞接收并回显 */
    if (NET_FD_ISSET(sockfd, &readfds)) {
        int n = net_recv(sockfd, s_rx_buf, TEST_BUF_SIZE, NET_MSG_DONTWAIT);
        if (n > 0) {
            int sent = net_send(sockfd, s_rx_buf, n, 0);
            if (sent == n) {
                s_phase8_count++;
                TEST_CHECK(1, "Phase8: select echo #%lu (%d bytes)", s_phase8_count, n);
            }
        }
    }
 }
 #endif
 /* ===================================================================
 * Phase 9 — 边界条件测试
 *
 * 测试目的：验证以下 DMA 和协议栈边界情况：
 *          1. TC-NET-901: 4095B（SPI 最大载荷 -1，单次 DMA 容纳）
 *          2. TC-NET-902: 4096B（= SPI 最大载荷，填满单次 DMA）
 *          3. TC-NET-903: 4097B（超过 SPI 最大载荷，拆 2 次 DMA）
 *          4. TC-NET-904: 零长度发送（返回 -1）
 *          5. TC-NET-905: 20 × 100B 连续快速发送
 *
 * 各用例通过状态机（s_phase9_stage）串行执行，每次 phase9_run 推进一个
 * 步骤（发送→等待→接收→验证→下一阶段）。发送数据为递增模式字节
 * （buf[i] = seed + i），接收端按相同模式验证。
 *
 * 入口条件：Socket 0 处于 ESTABLISHED。
 * 通过：各用例自身判定。
 * =================================================================== */
 #ifdef ENABLE_PHASE9_TESTS
 static int s_phase9_stage = 0;
 static uint32_t s_phase9_recv = 0;
 static void phase9_fill(uint8_t *buf, uint32_t size, uint8_t seed) {
    for (uint32_t i = 0; i < size; i++) {
        buf[i] = (uint8_t)(seed + i);
    }
 }
 static int phase9_verify(uint8_t *buf, uint32_t size, uint8_t seed) {
    for (uint32_t i = 0; i < size; i++) {
        if (buf[i] != (uint8_t)(seed + i)) return 0;
    }
    return 1;
 }
 static void phase9_run(int sockfd) {
    /* 阶段 0 → 1：发送 4095B */
    if (s_phase9_stage == 0) {
        DBG_INFO("Phase9: 4095B (DMA-1)");
        phase9_fill(s_tx_buf, 4095, 0x10);
        int sent = net_send(sockfd, s_tx_buf, 4095, 0);
        TEST_CHECK(sent == 4095, "Phase9: send 4095B (sent=%d)", sent);
        s_phase9_recv = 0;
        s_phase9_stage = 1;
        return;
    }
    /* 阶段 1：接收并验证 4095B 回显 */
    if (s_phase9_stage == 1) {
        int n = net_recv(sockfd, s_rx_buf + s_phase9_recv, (int)(4095 - s_phase9_recv), 0);
        if (n > 0) {
            s_phase9_recv += (uint32_t)n;
            if (s_phase9_recv >= 4095) {
                TEST_CHECK(phase9_verify(s_rx_buf, 4095, 0x10), "Phase9: verify 4095B");
                s_phase9_stage = 2;
            }
        }
        return;
    }
    /* 阶段 2 → 3：发送 4096B（DMA 边界精确值） */
    if (s_phase9_stage == 2) {
        DBG_INFO("Phase9: 4096B (DMA exact)");
        phase9_fill(s_tx_buf, 4096, 0x20);
        int sent = net_send(sockfd, s_tx_buf, 4096, 0);
        TEST_CHECK(sent == 4096, "Phase9: send 4096B (sent=%d)", sent);
        s_phase9_recv = 0;
        s_phase9_stage = 3;
        return;
    }
    /* 阶段 3：接收并验证 4096B 回显 */
    if (s_phase9_stage == 3) {
        int n = net_recv(sockfd, s_rx_buf + s_phase9_recv, (int)(4096 - s_phase9_recv), 0);
        if (n > 0) {
            s_phase9_recv += (uint32_t)n;
            if (s_phase9_recv >= 4096) {
                TEST_CHECK(phase9_verify(s_rx_buf, 4096, 0x20), "Phase9: verify 4096B");
                s_phase9_stage = 4;
            }
        }
        return;
    }
    /* 阶段 4 → 5：发送 4097B（超过 DMA 上限，自动拆 4096+1） */
    if (s_phase9_stage == 4) {
        DBG_INFO("Phase9: 4097B (DMA+1, 2 SPI xacts)");
        phase9_fill(s_tx_buf, 4097, 0x30);
        int sent = net_send(sockfd, s_tx_buf, 4097, 0);
        TEST_CHECK(sent == 4097, "Phase9: send 4097B (sent=%d)", sent);
        s_phase9_recv = 0;
        s_phase9_stage = 5;
        return;
    }
    /* 阶段 5：接收并验证 4097B 回显 */
    if (s_phase9_stage == 5) {
        int n = net_recv(sockfd, s_rx_buf + s_phase9_recv, (int)(4097 - s_phase9_recv), 0);
        if (n > 0) {
            s_phase9_recv += (uint32_t)n;
            if (s_phase9_recv >= 4097) {
                TEST_CHECK(phase9_verify(s_rx_buf, 4097, 0x30), "Phase9: verify 4097B");
                s_phase9_stage = 6;
            }
        }
        return;
    }
    /* 阶段 6：零长度发送 —— 期望 net_send 返回 -1（NET_ERR_INVAL） */
    if (s_phase9_stage == 6) {
        DBG_INFO("Phase9: zero-length send");
        int sent = net_send(sockfd, s_tx_buf, 0, 0);
        TEST_CHECK(sent < 0, "Phase9: send 0B returns %d (expect <0)", sent);
        s_phase9_stage = 7;
        return;
    }
    /* 阶段 7：20 × 100B 快速发送 */
    if (s_phase9_stage == 7) {
        DBG_INFO("Phase9: 20x rapid sends (100B each)");
        phase9_fill(s_tx_buf, 100, 0x40);
        int all_ok = 1;
        for (int i = 0; i < 20; i++) {
            if (net_send(sockfd, s_tx_buf, 100, 0) != 100) {
                TEST_CHECK(0, "Phase9: rapid #%d fail", i + 1);
                all_ok = 0; break;
            }
            osDelay(1);
        }
        if (all_ok) {
            TEST_CHECK(1, "Phase9: 20x rapid sends OK");
            s_phase9_recv = 0;
            s_phase9_stage = 8;
        } else {
            s_phase9_stage = 0;
        }
        return;
    }
    /* 阶段 8：接收 2000B 回显总和并验证 */
    if (s_phase9_stage == 8) {
        int n = net_recv(sockfd, s_rx_buf + s_phase9_recv, (int)(2000 - s_phase9_recv), 0);
        if (n > 0) {
            s_phase9_recv += (uint32_t)n;
            if (s_phase9_recv >= 2000) {
                TEST_CHECK(1, "Phase9: all echo received");
                TEST_REPORT("Phase 9");
                s_phase9_stage = 0;
            }
        }
        return;
    }
 }
 #endif
 /* ===================================================================
 * Phase 10 — TCP KeepAlive 超时断开
 *
 * 测试目的：验证 CH395F 的 TCP KeepAlive 机制：
 *          1. 连接空闲超过 idle 阈值（60s）后开始发送探测包
 *          2. 探测无响应（默认 3 次 × 5s = 15s）后触发 TIMEOUT
 *          3. Socket 自动关闭并回到 LISTEN
 *
 * 入口条件：Socket 0 处于 ESTABLISHED，PC 连接后静置（不发数据）。
 * 通过：KeepAlive 断开时间 ≥ 60s（从连接建立到 recv 返回 0 的间隔）。
 * 失败：不到 60s 就断开（可能是其他原因导致）或 75s 后仍未断开。
 * =================================================================== */
 #ifdef ENABLE_PHASE10_TESTS
 static int      s_phase10_armed = 0;
 static uint32_t s_phase10_start = 0;
 static void phase10_run(int sockfd) {
    /*
     * 第一次调用：记录开始时间并 arm。
     * 后续调用：非阻塞 recv，若返回 0 表示连接已断开（KeepAlive 触发）。
     * 计算耗时与 60s idle 阈值比较。
     */
    if (!s_phase10_armed) {
        s_phase10_armed = 1;
        s_phase10_start = HAL_GetTick();
        DBG_INFO("Phase10: idle wait for KeepAlive timeout (60s)");
        return;
    }
    int n = net_recv(sockfd, s_rx_buf, 64, NET_MSG_DONTWAIT);
    if (n == 0) {
        uint32_t elapsed = HAL_GetTick() - s_phase10_start;
        TEST_CHECK(elapsed >= 60000,
                   "Phase10: KeepAlive triggered after %lums (expect >=60000ms)", elapsed);
        TEST_REPORT("Phase 10");
        s_phase10_armed = 0;
    }
 }
 #endif
 /* ===================================================================
 * 任务入口：StartCh395fTestTask
 *
 * 执行顺序（按构建模式二选一，见 docs/CH395F_Test_Guide.md「构建模式与执行顺序」）：
 *   硬件层模式（阶段 1~5）：netTask 不创建，本任务调用
 *     net_stack_bring_up() 完成协议栈初始化后独占 CH395F 阻塞执行。
 *   NET 层模式（阶段 6~10）：
 *   1. 等待 g_net_ready（netTask 初始化完成标志）
 *   2. 创建 TCP 监听 Socket（单连接模式，端口 8080）
 *   3. 进入事件驱动循环，等待 PC 连接并执行 NET 层测试
 *
 * 单连接模式说明：
 *   Socket 0 复用监听和数据通道。accept 返回的 fd 与监听 fd 相同。
 *   连接断开后需重新 listen。连接恢复检测在循环末尾通过
 *   net_get_sock() 检查状态并自动处理。
 * =================================================================== */
 void StartCh395fTestTask(void *argument)
 {
    (void)argument;
 #if defined(ENABLE_NET_LAYER_TESTS)
    int sockfd = -1;
    int phase_active = 0;
    uint32_t accept_retry = 0;
    struct net_sockaddr_in client_addr;
    int addrlen = sizeof(client_addr);
 #endif
    DBG_INFO("Test task started");
 #if defined(ENABLE_HW_LAYER_TESTS)
@@ -1737,16 +1352,7 @@ void StartCh395fTestTask(void *argument)
     * 初始化并独占 CH395F —— 无 net_poll() 并发读取中断，无 SPI 并发事务 */
    if (net_stack_bring_up() != 0) {
        DBG_ERROR("net stack bring-up FAIL");
-        goto task_end;
+    } else {
    }
 #else
    /* NET 层模式（阶段 6~10）：等待 netTask 完成 net_init() 及 CH395F 初始化 */
    while (!g_net_ready) {
        osDelay(100);
    }
    DBG_INFO("netTask ready");
 #endif
        /* ==================== 阻塞阶段 ====================
         * Phase 1~5（硬件层）在 TCP 监听之前执行，不依赖外部连接。
         * 各 Phase 有各自的测试逻辑，完成后继续下一 Phase。
@@ -1766,104 +1372,22 @@ void StartCh395fTestTask(void *argument)
 #ifdef ENABLE_PHASE5_TESTS
        phase5_run();
 #endif
 #ifdef ENABLE_NET_LAYER_TESTS
    /* ==================== 创建 TCP 监听（NET 层模式） ==================== */
    DBG_INFO("Creating test socket...");
    sockfd = net_socket(NET_AF_INET, NET_SOCK_STREAM, 0);
    if (sockfd < 0) {
        DBG_ERROR("Test task: net_socket failed");
        goto task_end;
    }
-    DBG_INFO("Test task: socket %d created", sockfd);
+#else
-
+    /* NET 层模式（阶段 6~11）：等待 netTask 完成 net_init() 及 CH395F 初始化。
-    {
+     * Phase 7（TCP Client）与阶段 6/8~11（TCP Server 监听循环）互斥，
-        struct net_sockaddr_in addr;
+     * 二者共用单连接 Socket 0，故按宏选择入口。 */
-        memset(&addr, 0, sizeof(addr));
+    while (!g_net_ready) {
        addr.sin_family = NET_AF_INET;
        addr.sin_port   = net_htons(8080);
        if (net_bind(sockfd, (struct net_sockaddr *)&addr, sizeof(addr)) < 0) {
            DBG_ERROR("Test task: net_bind failed");
            goto task_end;
        }
        DBG_INFO("Test task: bound to port 8080");
    }
    if (net_listen(sockfd) < 0) {
        DBG_ERROR("Test task: net_listen failed");
        goto task_end;
    }
    DBG_INFO("Test task: listening on 8080 (single-socket mode)");
    /* ==================== 事件驱动阶段 ====================
     * Phase 6~10（NET 层）在 TCP 监听循环中运行，需要 PC 客户端连接。
     * 没有连接时循环等待；连接建立后执行对应 Phase。
     * 断开后自动重新 listen。
     */
    for (;;) {
        if (!phase_active) {
            int acc = net_accept(sockfd, (struct net_sockaddr *)&client_addr, &addrlen);
            if (acc < 0) {
                if (accept_retry % 100 == 0) {
                    DBG_INFO("Test task: waiting for connection...");
                }
                accept_retry++;
        osDelay(100);
                continue;
    }
-            accept_retry = 0;
+    DBG_INFO("netTask ready");
-            phase_active = 1;
+#if defined(ENABLE_PHASE7_TESTS)
-            DBG_INFO("Test task: client accepted (fd=%d)", acc);
+    net_layer_client_test_main();
-
+#else
-            /* 连接建立，重置各 Phase 内部状态 */
+    net_layer_test_main();
 #ifdef ENABLE_PHASE9_TESTS
            s_phase9_stage = 0;
 #endif
 #ifdef ENABLE_PHASE10_TESTS
            s_phase10_armed = 0;
 #endif
        }
        /* 每 10ms 依次执行各已启用 Phase */
 #ifdef ENABLE_PHASE6_TESTS
        phase6_run(sockfd);
 #endif
 #ifdef ENABLE_PHASE7_TESTS
        phase7_run(sockfd);
        phase_active = 0;   /* Phase 7 一次性完成，发完即止 */
 #endif
 #ifdef ENABLE_PHASE8_TESTS
        phase8_run(sockfd);
 #endif
 #ifdef ENABLE_PHASE9_TESTS
        phase9_run(sockfd);
 #endif
 #ifdef ENABLE_PHASE10_TESTS
        phase10_run(sockfd);
 #endif
        /*
         * 连接状态检查：通过 net_get_sock 获取 Socket 控制块，
         * 如果连接已断开（state != ESTABLISHED），关闭并重新 listen。
         * 这是单连接模式的关键 —— Socket 0 必须始终处于 LISTEN 或 ESTABLISHED。
         */
        {
            net_sock_t *sk = net_get_sock(sockfd);
            if (sk == NULL || !sk->in_use || sk->state != NET_SOCK_STATE_ESTABLISHED) {
                DBG_INFO("Test task: connection closed, re-listen...");
                net_close(sockfd);
                osDelay(500);
                net_listen(sockfd);
                phase_active = 0;
            }
        }
        osDelay(10);
    }
 #endif /* ENABLE_NET_LAYER_TESTS */
 task_end:
    for (;;) {
        osDelay(1000);
    }
--- a/test/net_test_task.c
+++ b/test/net_test_task.c
@@ -0,0 +1,904 @@
 /*****************************************************************************
 * 模块名称：CH395F NET 层测试（Phase 6~11）
 * 模块功能：基于 BSD Socket API（单连接模式）的 NET 层测试，由 ch395fTestTask
 *          任务内的 net_layer_test_main() / net_layer_client_test_main() 事件
 *          循环驱动，需 PC 配合。
 *          包含 Phase 6(TCP Echo) / 7(TCP Client) / 8(大文件) / 9(Select) /
 *          10(边界) / 11(KeepAlive) 及监听循环。
 * 作者：王建锋
 * 创建日期：2026-07-22
 ******************************************************************************/
 #include <string.h>
 #include "cmsis_os.h"
 #include "net_socket.h"
 #include "net_types.h"
 #include "ch395f_test.h"
 #include "ch395f_test_task.h"
 #include "net_test_task.h"
 #define DBG_TAG "[NET_TEST]"
 #include "dbg_log.h"
 /*
 * 收发缓冲区 —— 全局静态，不在任务栈上。
 * s_rx_buf 仅在 Phase 6(Echo)/8(大文件)/10(边界)/11(KeepAlive) 中使用。
 * s_tx_buf 仅在 Phase 8(大文件) 和 Phase 10(边界) 中使用。
 * Phase 7(TCP Client) 使用函数内局部小缓冲（64B 递增 + 回显）。
 *
 * 大小依据：
 *   - CH395F 单 Socket 接收缓冲按 1KB block 配置（net_socket.c 中
 *     set_recv_buf(sock, 30, 2) = 2KB），单次 net_recv 至多返回 ~2KB，
 *     故 s_rx_buf 实际只需 ≥ 2KB（此处 32KB 留足余量）。
 *   - Phase 8(大文件) 现改为流式分块：每次仅填一个窗口（≤1024B）即发出，
 *     不再一次性填入整文件，故 s_tx_buf 只需 ≥ 单窗口大小（此处 32KB 留足余量）。
 *   取 32KB(32768) 同时满足两者并留余量，且为 2 的幂；相比原 64KB
 *   在 STM32F4（128KB RAM）上节省一半静态空间。
 */
 #define TEST_BUF_SIZE       32768
 /* ===================================================================
 * Phase 6 — NET 层 TCP Echo（基础收发）
 *
 * 测试目的：验证 BSD Socket API（net_socket）的单连接 TCP Echo 通路。
 *          Socket 0 复用监听和数据通道。PC 发任意数据，MCU 原样返回。
 *          这是 Phase 7/8/9/10 的基础。
 *
 * 入口条件：Socket 0 处于 ESTABLISHED（TCP 连接已建立）。
 * 通过：数据收发一致。
 * 失败：send/recv 数量不匹配。
 * =================================================================== */
 #ifdef ENABLE_PHASE6_TESTS
 static void phase6_run(int sockfd) {
    /*
     * 单连接 TCP Echo：NET_MSG_DONTWAIT 非阻塞收，原样回显。
     * 连接断开由 net 层自动重监听（auto_relisten），应用层不维护生命周期；
     * 字节完整性由 PC 侧校验（data == test_data），固件不做每连接自检。
     */
    int n = net_recv(sockfd, s_rx_buf, TEST_BUF_SIZE, NET_MSG_DONTWAIT);
    if (n > 0) {
        int sent = net_send(sockfd, s_rx_buf, n, 0);
        if (sent != n) {
            DBG_ERROR("echo: send %d != recv %d", sent, n);
        }
    }
 }
 #endif
 /* ===================================================================
 * Phase 7 — NET 层 TCP Client（主动连接 PC 回显服务器）
 *
 * 测试目的：验证 BSD Socket API 的 TCP Client 路径（net_socket + net_bind
 *          + net_connect + net_send + net_recv）：
 *          1. MCU 主动连接 PC 回显服务器（192.168.1.2:8080）
 *          2. 64B 递增数据回显后，固件侧逐字节比对 + 32 位累加和校验
 *          3. 关闭并重新连接（规避 TIME_WAIT：每轮换本地端口）
 *          4. 连接超时负向用例（PC 服务关闭时 connect 不应成功）
 *
 * 入口条件：PC 运行 `python test/ch395f_socket_test.py tcp_server --port 8081`
 *          （TC 703 需先关闭该服务）。
 * TC 映射：TC 701（连接 + 回显）/ TC 702（关闭重连）/ TC 703（连接超时）。
 * 通过：回显逐字节一致且 32 位 checksum 匹配；重连全部成功；超时用例未建连。
 * 失败：连接失败 / 回显不一致 / 重连中断 / 超时用例误建连。
 * =================================================================== */
 #ifdef ENABLE_PHASE7_TESTS
 #include "net_select.h"
 #ifndef PHASE7_REMOTE_IP
 #define PHASE7_REMOTE_IP        "192.168.1.2"
 #endif
 #ifndef PHASE7_REMOTE_PORT
 #define PHASE7_REMOTE_PORT      8081
 #endif
 #ifndef PHASE7_LOCAL_PORT
 #define PHASE7_LOCAL_PORT       50000
 #endif
 #ifndef PHASE7_LOOP_COUNT
 #define PHASE7_LOOP_COUNT       3
 #endif
 #ifndef PHASE7_EXCH_SIZE
 #define PHASE7_EXCH_SIZE        64
 #endif
 #ifndef PHASE7_CONN_TIMEOUT_MS
 #define PHASE7_CONN_TIMEOUT_MS  10000
 #endif
 #ifndef PHASE7_TIMEOUT_TEST_MS
 #define PHASE7_TIMEOUT_TEST_MS  30000   /* TC 703 连接超时窗（指南规定 30s） */
 #endif
 /* 32 位累加和：足以发现丢字节/错位，比 CRC32 便宜 */
 static uint32_t phase7_cksum(const uint8_t *p, uint32_t n) {
    uint32_t s = 0;
    while (n--) s += *p++;
    return s;
 }
 /* 单次 TCP Client 会话：对应 TC 701 主体 / TC 702 单轮。
 * 每轮使用不同本地端口 local_port 规避 TIME_WAIT。
 * 返回 1 表示全流程通过，0 表示中途失败（已记录 TEST_CHECK）。 */
 static int phase7_session(uint16_t local_port)
 {
    int sockfd = net_socket(NET_AF_INET, NET_SOCK_STREAM, 0);
    if (sockfd < 0) {
        TEST_CHECK(0, "TC701 socket create");
        return 0;
    }
    /* 绑定本地端口（不同轮用不同端口规避 TIME_WAIT） */
    {
        struct net_sockaddr_in laddr;
        memset(&laddr, 0, sizeof(laddr));
        laddr.sin_family = NET_AF_INET;
        laddr.sin_port   = net_htons(local_port);
        if (net_bind(sockfd, (struct net_sockaddr *)&laddr, sizeof(laddr)) < 0) {
            TEST_CHECK(0, "TC701 bind port %d", local_port);
            net_close(sockfd);
            return 0;
        }
    }
    /* 目标地址 */
    struct net_sockaddr_in raddr;
    memset(&raddr, 0, sizeof(raddr));
    raddr.sin_family      = NET_AF_INET;
    raddr.sin_port        = net_htons((uint16_t)PHASE7_REMOTE_PORT);
    raddr.sin_addr.s_addr = net_inet_addr(PHASE7_REMOTE_IP);
    DBG_INFO("TC701 connecting %s:%d (local port %d)",
             PHASE7_REMOTE_IP, PHASE7_REMOTE_PORT, local_port);
    int rc = net_connect(sockfd, (struct net_sockaddr *)&raddr, sizeof(raddr));
    TEST_CHECK(rc == 0, "TC701 connect issued (ret=%d)", rc);
    if (rc != 0) { net_close(sockfd); return 0; }
    /* 等待连接建立：轮询 socket 状态（ESTABLISHED）。
     * 用 net_select 触发 net_poll 并作为 100ms 节拍，状态以 net_get_sock 为准。 */
    {
        int connected = 0;
        uint32_t tick = HAL_GetTick();
        while (HAL_GetTick() - tick < PHASE7_CONN_TIMEOUT_MS) {
            net_sock_t *sk = net_get_sock(sockfd);
            if (sk && sk->state == NET_SOCK_STATE_ESTABLISHED) { 
                connected = 1; break; 
            }
            if (sk && sk->state == NET_SOCK_STATE_CLOSED) {
                break; /* 连接失败 */
            }
            osDelay(100);   /* 仅作等待/让出 CPU；连接状态由 netTask 的 net_poll 每 10ms 刷新 */
        }
        TEST_CHECK(connected, "TC701 connected within %dms", PHASE7_CONN_TIMEOUT_MS);
        if (!connected) { net_close(sockfd); return 0; }
    }
    /* 数据交换：64B 递增模式 */
    uint8_t tx[PHASE7_EXCH_SIZE];
    uint8_t rx[PHASE7_EXCH_SIZE];
    for (int i = 0; i < PHASE7_EXCH_SIZE; i++) tx[i] = (uint8_t)i;
    int sent = net_send(sockfd, tx, PHASE7_EXCH_SIZE, 0);
    TEST_CHECK(sent == PHASE7_EXCH_SIZE, "TC701 send %dB (sent=%d)", PHASE7_EXCH_SIZE, sent);
    if (sent != PHASE7_EXCH_SIZE) { net_close(sockfd); return 0; }
    int recvd = 0;
    uint32_t tick = HAL_GetTick();
    while (recvd < PHASE7_EXCH_SIZE) {
        int n = net_recv(sockfd, rx + recvd, PHASE7_EXCH_SIZE - recvd, NET_MSG_DONTWAIT);
        if (n > 0) {
            recvd += n;
        } else if (n == 0) {
            break;  /* 对端关闭 */
        } else if (n < 0 && net_get_errno() == NET_ERR_WOULDBLOCK) {
            if (HAL_GetTick() - tick > PHASE7_CONN_TIMEOUT_MS) break;
            osDelay(10);
            continue;
        } else {
            break;  /* 其它错误 */
        }
        if (HAL_GetTick() - tick > PHASE7_CONN_TIMEOUT_MS) break;
    }
    int ok = (recvd == PHASE7_EXCH_SIZE);
    if (ok) {
        int bad = 0;
        for (int i = 0; i < PHASE7_EXCH_SIZE; i++) {
            if (rx[i] != (uint8_t)i) { bad = 1; break; }
        }
        TEST_CHECK(!bad, "TC701 byte-compare %dB", PHASE7_EXCH_SIZE);
        TEST_CHECK(1, "TC701 recv %dB, cksum=0x%08X", recvd, phase7_cksum(rx, PHASE7_EXCH_SIZE));
    } else {
        TEST_CHECK(0, "TC701 recv %dB (expect %d)", recvd, PHASE7_EXCH_SIZE);
    }
    net_close(sockfd);
    return ok;
 }
 /* TC 703（负向）：连接超时。PC 未在 REMOTE_IP:REMOTE_PORT 提供服务时，
 * connect 不应成功建立。本用例需先关闭 PC 端 tcp_server（与 TC 701/702 互斥环境：
 * 701/702 要求服务端在线，703 要求服务端离线，故 703 应在独立的一轮中运行）。 */
 static void phase7_test_timeout(void)
 {
    int sockfd = net_socket(NET_AF_INET, NET_SOCK_STREAM, 0);
    if (sockfd < 0) { TEST_CHECK(0, "TC703 socket create"); return; }
    struct net_sockaddr_in raddr;
    memset(&raddr, 0, sizeof(raddr));
    raddr.sin_family      = NET_AF_INET;
    raddr.sin_port        = net_htons((uint16_t)PHASE7_REMOTE_PORT);
    raddr.sin_addr.s_addr = net_inet_addr(PHASE7_REMOTE_IP);
    DBG_INFO("TC703 connecting %s:%d (expect TIMEOUT, PC server must be OFF)",
             PHASE7_REMOTE_IP, PHASE7_REMOTE_PORT);
    int rc = net_connect(sockfd, (struct net_sockaddr *)&raddr, sizeof(raddr));
    TEST_CHECK(rc == 0, "TC703 connect issued (ret=%d)", rc);
    if (rc != 0) { net_close(sockfd); return; }
    int established = 0;
    uint32_t tick = HAL_GetTick();
    while (HAL_GetTick() - tick < PHASE7_TIMEOUT_TEST_MS) {
        net_sock_t *sk = net_get_sock(sockfd);
        if (sk && sk->state == NET_SOCK_STATE_ESTABLISHED) { established = 1; break; }
        if (sk && sk->state == NET_SOCK_STATE_CLOSED) break;
        osDelay(100);   /* 仅作等待/让出 CPU；连接状态由 netTask 的 net_poll 每 10ms 刷新 */
    }
    if (established) {
        TEST_CHECK(0, "TC703 connected?! stop PC server and retry");
    } else {
        TEST_CHECK(1, "TC703 no-connect within %dms (timeout as expected)", PHASE7_TIMEOUT_TEST_MS);
    }
    net_close(sockfd);
 }
 /* TC 704：多 Socket 并发 TCP Client。
 * 多 Socket 模式下 Socket 1~7 才可用；本用例同时打开 Socket 0~7，
 * 各自连 PC echo server，每路独立收发 PHASE7_EXCH_SIZE 字节回显并比对，
 * 验证 8 个 Socket 均能独立工作。依赖 PC 端 tcp_server 支持并发连接。 */
 #ifndef PHASE7_MULTI_COUNT
 #define PHASE7_MULTI_COUNT     8
 #endif
 #ifndef PHASE7_MULTI_BASE_PORT
 #define PHASE7_MULTI_BASE_PORT 51000
 #endif
 static int phase7_session_multi(void)
 {
    int sockfd[PHASE7_MULTI_COUNT];
    uint8_t tx[PHASE7_EXCH_SIZE];
    uint8_t rx[PHASE7_EXCH_SIZE];
    for (int i = 0; i < PHASE7_EXCH_SIZE; i++) tx[i] = (uint8_t)i;
    /* 1) 打开并连接所有 Socket（各自绑定不同本地端口规避 TIME_WAIT） */
    for (int i = 0; i < PHASE7_MULTI_COUNT; i++) {
        sockfd[i] = net_socket(NET_AF_INET, NET_SOCK_STREAM, 0);
        if (sockfd[i] < 0) {
            TEST_CHECK(0, "TC704 socket create #%d", i);
            for (int j = 0; j < i; j++) net_close(sockfd[j]);
            return 0;
        }
        struct net_sockaddr_in laddr;
        memset(&laddr, 0, sizeof(laddr));
        laddr.sin_family = NET_AF_INET;
        laddr.sin_port   = net_htons((uint16_t)(PHASE7_MULTI_BASE_PORT + i));
        if (net_bind(sockfd[i], (struct net_sockaddr *)&laddr, sizeof(laddr)) < 0) {
            TEST_CHECK(0, "TC704 bind #%d port %d", i, PHASE7_MULTI_BASE_PORT + i);
            net_close(sockfd[i]);
            for (int j = 0; j < i; j++) net_close(sockfd[j]);
            return 0;
        }
        struct net_sockaddr_in raddr;
        memset(&raddr, 0, sizeof(raddr));
        raddr.sin_family      = NET_AF_INET;
        raddr.sin_port        = net_htons((uint16_t)PHASE7_REMOTE_PORT);
        raddr.sin_addr.s_addr = net_inet_addr(PHASE7_REMOTE_IP);
        int rc = net_connect(sockfd[i], (struct net_sockaddr *)&raddr, sizeof(raddr));
        TEST_CHECK(rc == 0, "TC704 connect #%d issued (ret=%d)", i, rc);
        if (rc != 0) {
            net_close(sockfd[i]);
            for (int j = 0; j < i; j++) net_close(sockfd[j]);
            return 0;
        }
    }
    /* 2) 等待所有连接建立（或超时） */
    {
        uint32_t tick = HAL_GetTick();
        int all_up = 0;
        while (HAL_GetTick() - tick < PHASE7_CONN_TIMEOUT_MS) {
            all_up = 1;
            for (int i = 0; i < PHASE7_MULTI_COUNT; i++) {
                net_sock_t *sk = net_get_sock(sockfd[i]);
                if (!sk || sk->state != NET_SOCK_STATE_ESTABLISHED) { all_up = 0; break; }
            }
            if (all_up) break;
            osDelay(100);
        }
        TEST_CHECK(all_up, "TC704 all %d sockets established within %dms", PHASE7_MULTI_COUNT, PHASE7_CONN_TIMEOUT_MS);
        if (!all_up) {
            for (int i = 0; i < PHASE7_MULTI_COUNT; i++) {
                net_sock_t *sk = net_get_sock(sockfd[i]);
                if (sk) DBG_ERROR("TC704 socket #%d state=%d", i, sk->state);
                net_close(sockfd[i]);
            }
            return 0;
        }
    }
    /* 3) 每路独立收发回显 */
    int ok = 1;
    for (int i = 0; i < PHASE7_MULTI_COUNT; i++) {
        int sent = net_send(sockfd[i], tx, PHASE7_EXCH_SIZE, 0);
        if (sent != PHASE7_EXCH_SIZE) {
            TEST_CHECK(0, "TC704 socket #%d send %dB (sent=%d)", i, PHASE7_EXCH_SIZE, sent);
            ok = 0;
            continue;
        }
        int recvd = 0;
        uint32_t tick = HAL_GetTick();
        while (recvd < PHASE7_EXCH_SIZE) {
            int n = net_recv(sockfd[i], rx + recvd, PHASE7_EXCH_SIZE - recvd, NET_MSG_DONTWAIT);
            if (n > 0) recvd += n;
            else if (n == 0) break;
            else if (n < 0 && net_get_errno() == NET_ERR_WOULDBLOCK) {
                if (HAL_GetTick() - tick > PHASE7_CONN_TIMEOUT_MS) break;
                osDelay(10);
                continue;
            } else break;
            if (HAL_GetTick() - tick > PHASE7_CONN_TIMEOUT_MS) break;
        }
        int sock_ok = (recvd == PHASE7_EXCH_SIZE);
        if (sock_ok) {
            int bad = 0;
            for (int k = 0; k < PHASE7_EXCH_SIZE; k++) if (rx[k] != (uint8_t)k) { bad = 1; break; }
            TEST_CHECK(!bad, "TC704 socket #%d echo %dB OK", i, PHASE7_EXCH_SIZE);
        } else {
            TEST_CHECK(0, "TC704 socket #%d recv %dB (expect %d)", i, recvd, PHASE7_EXCH_SIZE);
            ok = 0;
        }
    }
    /* 4) 关闭所有 */
    for (int i = 0; i < PHASE7_MULTI_COUNT; i++) net_close(sockfd[i]);
    return ok;
 }
 void net_layer_client_test_main(void)
 {
    DBG_INFO("=== CH395F Phase 7 Tests (NET TCP Client) ===");
    DBG_INFO("--- TC 701: connect + %dB echo exchange ---", PHASE7_EXCH_SIZE);
    phase7_session((uint16_t)PHASE7_LOCAL_PORT);
    DBG_INFO("--- TC 702: close/reconnect x%d ---", PHASE7_LOOP_COUNT);
    {
        int all_ok = 1;
        for (int i = 0; i < PHASE7_LOOP_COUNT; i++) {
            if (!phase7_session((uint16_t)(PHASE7_LOCAL_PORT + 1 + i))) all_ok = 0;
        }
        TEST_CHECK(all_ok, "TC702 reconnect x%d all passed", PHASE7_LOOP_COUNT);
    }
    DBG_INFO("--- TC 704: %d-socket concurrent client (PC %s:%d MUST be ON) ---",
             PHASE7_MULTI_COUNT, PHASE7_REMOTE_IP, PHASE7_REMOTE_PORT);
    phase7_session_multi();
    DBG_INFO("--- TC 703: connect timeout (PC %s:%d MUST be OFF) ---",
             PHASE7_REMOTE_IP, PHASE7_REMOTE_PORT);
    phase7_test_timeout();
    TEST_REPORT("Phase 7");
 }
 #endif
 /* ===================================================================
 * Phase 8 — 大文件 / 批量传输（默认 100KB，文件收发）
 *
 * 测试目的：验证超过 Socket 接收缓冲（2KB）的大块数据在 net_send /
 *          net_recv 层经分块后的正确处理；并支持「文件发送(MCU→PC) /
 *          文件接收(PC→MCU) / 回显 round-trip」三种方向。
 *
 * 数据模式：递增字节，绝对位置 p 处字节 = (p & 0xFF)；发送端按窗口
 *          (offset + i) 生成，接收端按 offset 逐字节比对（自校验）。
 *          整包另用 CRC32（与 PC zlib.crc32 一致）做整体校验。
 *
 * 缓冲策略：s_tx_buf / s_rx_buf 仅 32KB，100KB 须按窗口逐块生成/校验，
 *          不整体驻留 RAM（流式分块）。
 *
 * 方向选择（编译宏 PHASE8_DIRECTION）：
 *   0 = ECHO  发 100KB 经 PC 回显，MCU 收齐校验（默认）
 *   1 = SEND  MCU 发 100KB，PC 落盘 rx_100k.bin 校验
 *   2 = RECV  PC 发 100KB（+4B CRC32 尾），MCU 收齐字节+CRC 校验
 * =================================================================== */
 /* Phase 8 方向配置：须早于下方缓冲声明，以按方向精确控制 s_tx_buf 等是否参与编译 */
 #ifdef ENABLE_PHASE8_TESTS
 #define PHASE8_DIR_ECHO         0
 #define PHASE8_DIR_SEND         1
 #define PHASE8_DIR_RECV         2
 #ifndef PHASE8_FILE_SIZE
 #define PHASE8_FILE_SIZE        102400      /* 100KB */
 #endif
 #ifndef PHASE8_DIRECTION
 #define PHASE8_DIRECTION        PHASE8_DIR_ECHO
 #endif
 #endif
 #if defined(ENABLE_PHASE6_TESTS)  || \
    (defined(ENABLE_PHASE8_TESTS) && (PHASE8_DIRECTION != PHASE8_DIR_SEND)) || \
    defined(ENABLE_PHASE10_TESTS) || defined(ENABLE_PHASE11_TESTS)
 static uint8_t s_rx_buf[TEST_BUF_SIZE];
 #endif
 /* s_tx_buf 仅 SEND/ECHO（及 Phase 10）需要；RECV 不发送，避免未使用变量警告 */
 #if (defined(ENABLE_PHASE8_TESTS) && (PHASE8_DIRECTION != PHASE8_DIR_RECV)) || \
    defined(ENABLE_PHASE10_TESTS)
 static uint8_t s_tx_buf[TEST_BUF_SIZE];
 #endif
 #ifdef ENABLE_PHASE8_TESTS
 /* CRC32（标准，与 Python zlib.crc32 一致；初始 0xFFFFFFFF，末异或 0xFFFFFFFF）
 *   仅 RECV 方向需要：MCU 收齐后比对 PC 附在文件末尾的 4 字节 CRC32。 */
 #if PHASE8_DIRECTION == PHASE8_DIR_RECV
 static uint32_t phase8_crc32_step(uint32_t crc, const uint8_t *data, uint32_t len) {
    for (uint32_t i = 0; i < len; i++) {
        crc ^= data[i];
        for (int k = 0; k < 8; k++) {
            crc = (crc & 1u) ? (crc >> 1) ^ 0xEDB88320u : (crc >> 1);
        }
    }
    return crc;
 }
 #endif
 /* 仅 SEND/ECHO 方向需要：生成递增模式发送窗口 */
 #if PHASE8_DIRECTION != PHASE8_DIR_RECV
 static void phase8_fill(uint8_t *buf, uint32_t size, uint32_t offset) {
    for (uint32_t i = 0; i < size; i++) {
        buf[i] = (uint8_t)((offset + i) & 0xFF);
    }
 }
 #endif
 /* 仅 ECHO/RECV 方向需要：逐字节校验接收数据 */
 #if PHASE8_DIRECTION != PHASE8_DIR_SEND
 static int phase8_verify(uint8_t *buf, uint32_t size, uint32_t offset) {
    for (uint32_t i = 0; i < size; i++) {
        if (buf[i] != (uint8_t)((offset + i) & 0xFF)) {
            DBG_ERROR("Phase8: mismatch at %lu (expect 0x%02X, got 0x%02X)",
                      offset + i, (uint8_t)((offset + i) & 0xFF), buf[i]);
            return 0;
        }
    }
    return 1;
 }
 #endif
 static void phase8_run(int sockfd) {
 #if PHASE8_DIRECTION == PHASE8_DIR_RECV
    /* PC 发送文件（尾附 4B CRC32），MCU 接收并逐字节 + CRC32 校验 */
    DBG_INFO("Phase8[RECV]: receiving %d-byte file", PHASE8_FILE_SIZE);
    uint32_t recvd = 0;
    uint32_t crc = 0xFFFFFFFFu;
    while (recvd < PHASE8_FILE_SIZE) {
        int to_read = (PHASE8_FILE_SIZE - recvd) > (TEST_BUF_SIZE - 4)
                        ? (TEST_BUF_SIZE - 4) : (int)(PHASE8_FILE_SIZE - recvd);
        int n = net_recv(sockfd, s_rx_buf, to_read, 0);
        if (n <= 0) {
            DBG_ERROR("Phase8[RECV]: recv fail at %lu (ret=%d)", recvd, n);
            return;
        }
        int ok = phase8_verify(s_rx_buf, (uint32_t)n, recvd);
        TEST_CHECK(ok, "Phase8[RECV]: verify at %lu (%d bytes)", recvd, n);
        if (!ok) return;
        crc = phase8_crc32_step(crc, s_rx_buf, (uint32_t)n);
        recvd += (uint32_t)n;
    }
    /* 读取 PC 附在文件末尾的 4 字节 CRC32（小端） */
    uint8_t foot[4];
    uint32_t got = 0;
    while (got < 4) {
        int n = net_recv(sockfd, foot + got, (int)(4 - got), 0);
        if (n <= 0) {
            DBG_ERROR("Phase8[RECV]: footer recv fail (ret=%d)", n);
            return;
        }
        got += (uint32_t)n;
    }
    uint32_t crc_exp = crc ^ 0xFFFFFFFFu;
    uint32_t crc_act = ((uint32_t)foot[0]) | ((uint32_t)foot[1] << 8)
                     | ((uint32_t)foot[2] << 16) | ((uint32_t)foot[3] << 24);
    TEST_CHECK(crc_act == crc_exp,
               "Phase8[RECV]: CRC32 exp=0x%08X act=0x%08X", crc_exp, crc_act);
    DBG_INFO("Phase8[RECV]: done, CRC32=0x%08X", crc_exp);
 #elif PHASE8_DIRECTION == PHASE8_DIR_SEND
    /* MCU 发送文件，PC 落盘校验（PC 侧自行比对字节/CRC32） */
    DBG_INFO("Phase8[SEND]: sending %d-byte file", PHASE8_FILE_SIZE);
    uint32_t sent = 0;
    while (sent < PHASE8_FILE_SIZE) {
        /* 每次填充一个滑动窗口（≤ s_tx_buf 容量）；net_send 内部按硬件发送 FIFO
         * (NET_SEND_CHUNK_MAX=1KB，见 Trap 20) 自动拆分写入，无需此处逐 1KB 分块 */
        uint32_t chunk = (PHASE8_FILE_SIZE - sent) > (uint32_t)TEST_BUF_SIZE
                            ? (uint32_t)TEST_BUF_SIZE : (PHASE8_FILE_SIZE - sent);
        phase8_fill(s_tx_buf, chunk, sent);
        int n = net_send(sockfd, s_tx_buf, (int)chunk, 0);
        if (n <= 0) {
            DBG_ERROR("Phase8[SEND]: send fail at %lu (ret=%d)", sent, n);
            return;
        }
        sent += (uint32_t)n;
    }
    DBG_INFO("Phase8[SEND]: sent %d bytes", PHASE8_FILE_SIZE);
    TEST_CHECK(1, "Phase8[SEND]: %d-byte file sent", PHASE8_FILE_SIZE);
 #else /* PHASE8_DIR_ECHO */
    /* 发 100KB 经 PC 回显（tcp_server --max-conn 1），MCU 收齐逐字节校验 */
    DBG_INFO("Phase8[ECHO]: transferring %d-byte file", PHASE8_FILE_SIZE);
    uint32_t sent = 0;
    while (sent < PHASE8_FILE_SIZE) {
        /* 同 SEND：填充滑动窗口（≤ s_tx_buf），由 net_send 内部按硬件 FIFO 自动拆分 */
        uint32_t chunk = (PHASE8_FILE_SIZE - sent) > (uint32_t)TEST_BUF_SIZE
                            ? (uint32_t)TEST_BUF_SIZE : (PHASE8_FILE_SIZE - sent);
        phase8_fill(s_tx_buf, chunk, sent);
        int n = net_send(sockfd, s_tx_buf, (int)chunk, 0);
        if (n <= 0) {
            DBG_ERROR("Phase8[ECHO]: send fail at %lu (ret=%d)", sent, n);
            return;
        }
        sent += (uint32_t)n;
    }
    uint32_t recvd = 0;
    while (recvd < PHASE8_FILE_SIZE) {
        int n = net_recv(sockfd, s_rx_buf, TEST_BUF_SIZE, 0);
        if (n <= 0) {
            DBG_ERROR("Phase8[ECHO]: recv fail at %lu (ret=%d)", recvd, n);
            return;
        }
        int ok = phase8_verify(s_rx_buf, (uint32_t)n, recvd);
        TEST_CHECK(ok, "Phase8[ECHO]: verify at %lu (%d bytes)", recvd, n);
        if (!ok) return;
        recvd += (uint32_t)n;
    }
    TEST_CHECK(1, "Phase8[ECHO]: %d-byte file transfer complete", PHASE8_FILE_SIZE);
 #endif
    /* 一次性传输完成：主动关闭数据连接，触发 net 层自动重监听。
     * 否则 accept 循环会在“仍打开的同一条连接”上重复执行本 Phase——
     * SEND/RECV 由 PC 端先关闭尚可终止，ECHO 方向 PC 回显客户端不会主动
     * 关闭，会导致 MCU 无限重复、PC 端 tcp_file --op echo 一直挂起。 */
    net_close(sockfd);
 }
 #endif
 /* ===================================================================
 * Phase 9 — Select/Poll I/O 多路复用
 *
 * 测试目的：验证 net_select() API 在单 Socket 模式下正确工作：
 *          1. Socket 0 有数据到达时 select 返回正数
 *          2. NET_FD_ISSET 正确指示就绪的 Socket
 *          3. 超时（50ms 无数据）时返回 0
 *
 * 入口条件：Socket 0 处于 ESTABLISHED。
 * 通过：select 检测到数据并成功回显。
 * 失败：select 未检测到数据或回显失败。
 * =================================================================== */
 #ifdef ENABLE_PHASE9_TESTS
 #include "net_select.h"
 static uint32_t s_phase9_count = 0;
 static void phase9_run(int sockfd) {
    net_fd_set readfds;
    net_timeval tv;
    /*
     * 配置 select：只监测 Socket 0 的可读状态，超时 50ms。
     * NET_FD_ZERO 清空集合，NET_FD_SET 添加 Socket 0。
     * 50ms 超时确保不阻塞任务循环太久。
     */
    NET_FD_ZERO(&readfds);
    NET_FD_SET(sockfd, &readfds);
    tv.tv_sec = 0;
    tv.tv_usec = 50000;
    int nfds = net_select(sockfd + 1, &readfds, NULL, NULL, &tv);
    if (nfds <= 0) return;
    /* Socket 0 可读：非阻塞接收并回显 */
    if (NET_FD_ISSET(sockfd, &readfds)) {
        int n = net_recv(sockfd, s_rx_buf, TEST_BUF_SIZE, NET_MSG_DONTWAIT);
        if (n > 0) {
            int sent = net_send(sockfd, s_rx_buf, n, 0);
            if (sent == n) {
                s_phase9_count++;
                TEST_CHECK(1, "Phase9: select echo #%lu (%d bytes)", s_phase9_count, n);
            }
        }
    }
 }
 #endif
 /* ===================================================================
 * Phase 10 — 边界条件测试
 *
 * 测试目的：验证以下 DMA 和协议栈边界情况：
 *          1. TC-NET-1001: 4095B（SPI 最大载荷 -1，单次 DMA 容纳）
 *          2. TC-NET-1002: 4096B（= SPI 最大载荷，填满单次 DMA）
 *          3. TC-NET-1003: 4097B（超过 SPI 最大载荷，拆 2 次 DMA）
 *          4. TC-NET-1004: 零长度发送（返回 -1）
 *          5. TC-NET-1005: 20 × 100B 连续快速发送
 *
 * 各用例通过状态机（s_phase10_stage）串行执行，每次 phase10_run 推进一个
 * 步骤（发送→等待→接收→验证→下一阶段）。发送数据为递增模式字节
 * （buf[i] = seed + i），接收端按相同模式验证。
 *
 * 入口条件：Socket 0 处于 ESTABLISHED。
 * 通过：各用例自身判定。
 * =================================================================== */
 #ifdef ENABLE_PHASE10_TESTS
 static int s_phase10_stage = 0;
 static uint32_t s_phase10_recv = 0;
 static void phase10_fill(uint8_t *buf, uint32_t size, uint8_t seed) {
    for (uint32_t i = 0; i < size; i++) {
        buf[i] = (uint8_t)(seed + i);
    }
 }
 static int phase10_verify(uint8_t *buf, uint32_t size, uint8_t seed) {
    for (uint32_t i = 0; i < size; i++) {
        if (buf[i] != (uint8_t)(seed + i)) return 0;
    }
    return 1;
 }
 static void phase10_run(int sockfd) {
    /* 阶段 0 → 1：发送 4095B */
    if (s_phase10_stage == 0) {
        DBG_INFO("Phase10: 4095B (DMA-1)");
        phase10_fill(s_tx_buf, 4095, 0x10);
        int sent = net_send(sockfd, s_tx_buf, 4095, 0);
        TEST_CHECK(sent == 4095, "Phase10: send 4095B (sent=%d)", sent);
        s_phase10_recv = 0;
        s_phase10_stage = 1;
        return;
    }
    /* 阶段 1：接收并验证 4095B 回显 */
    if (s_phase10_stage == 1) {
        int n = net_recv(sockfd, s_rx_buf + s_phase10_recv, (int)(4095 - s_phase10_recv), 0);
        if (n > 0) {
            s_phase10_recv += (uint32_t)n;
            if (s_phase10_recv >= 4095) {
                TEST_CHECK(phase10_verify(s_rx_buf, 4095, 0x10), "Phase10: verify 4095B");
                s_phase10_stage = 2;
            }
        }
        return;
    }
    /* 阶段 2 → 3：发送 4096B（DMA 边界精确值） */
    if (s_phase10_stage == 2) {
        DBG_INFO("Phase10: 4096B (DMA exact)");
        phase10_fill(s_tx_buf, 4096, 0x20);
        int sent = net_send(sockfd, s_tx_buf, 4096, 0);
        TEST_CHECK(sent == 4096, "Phase10: send 4096B (sent=%d)", sent);
        s_phase10_recv = 0;
        s_phase10_stage = 3;
        return;
    }
    /* 阶段 3：接收并验证 4096B 回显 */
    if (s_phase10_stage == 3) {
        int n = net_recv(sockfd, s_rx_buf + s_phase10_recv, (int)(4096 - s_phase10_recv), 0);
        if (n > 0) {
            s_phase10_recv += (uint32_t)n;
            if (s_phase10_recv >= 4096) {
                TEST_CHECK(phase10_verify(s_rx_buf, 4096, 0x20), "Phase10: verify 4096B");
                s_phase10_stage = 4;
            }
        }
        return;
    }
    /* 阶段 4 → 5：发送 4097B（超过 DMA 上限，自动拆 4096+1） */
    if (s_phase10_stage == 4) {
        DBG_INFO("Phase10: 4097B (DMA+1, 2 SPI xacts)");
        phase10_fill(s_tx_buf, 4097, 0x30);
        int sent = net_send(sockfd, s_tx_buf, 4097, 0);
        TEST_CHECK(sent == 4097, "Phase10: send 4097B (sent=%d)", sent);
        s_phase10_recv = 0;
        s_phase10_stage = 5;
        return;
    }
    /* 阶段 5：接收并验证 4097B 回显 */
    if (s_phase10_stage == 5) {
        int n = net_recv(sockfd, s_rx_buf + s_phase10_recv, (int)(4097 - s_phase10_recv), 0);
        if (n > 0) {
            s_phase10_recv += (uint32_t)n;
            if (s_phase10_recv >= 4097) {
                TEST_CHECK(phase10_verify(s_rx_buf, 4097, 0x30), "Phase10: verify 4097B");
                s_phase10_stage = 6;
            }
        }
        return;
    }
    /* 阶段 6：零长度发送 —— 期望 net_send 返回 -1（NET_ERR_INVAL） */
    if (s_phase10_stage == 6) {
        DBG_INFO("Phase10: zero-length send");
        int sent = net_send(sockfd, s_tx_buf, 0, 0);
        TEST_CHECK(sent < 0, "Phase10: send 0B returns %d (expect <0)", sent);
        s_phase10_stage = 7;
        return;
    }
    /* 阶段 7：20 × 100B 快速发送 */
    if (s_phase10_stage == 7) {
        DBG_INFO("Phase10: 20x rapid sends (100B each)");
        phase10_fill(s_tx_buf, 100, 0x40);
        int all_ok = 1;
        for (int i = 0; i < 20; i++) {
            if (net_send(sockfd, s_tx_buf, 100, 0) != 100) {
                TEST_CHECK(0, "Phase10: rapid #%d fail", i + 1);
                all_ok = 0; break;
            }
            osDelay(1);
        }
        if (all_ok) {
            TEST_CHECK(1, "Phase10: 20x rapid sends OK");
            s_phase10_recv = 0;
            s_phase10_stage = 8;
        } else {
            s_phase10_stage = 0;
        }
        return;
    }
    /* 阶段 8：接收 2000B 回显总和并验证 */
    if (s_phase10_stage == 8) {
        int n = net_recv(sockfd, s_rx_buf + s_phase10_recv, (int)(2000 - s_phase10_recv), 0);
        if (n > 0) {
            s_phase10_recv += (uint32_t)n;
            if (s_phase10_recv >= 2000) {
                TEST_CHECK(1, "Phase10: all echo received");
                TEST_REPORT("Phase 10");
                s_phase10_stage = 0;
            }
        }
        return;
    }
 }
 #endif
 /* ===================================================================
 * Phase 11 — TCP KeepAlive 超时断开
 *
 * 测试目的：验证 CH395F 的 TCP KeepAlive 机制：
 *          1. 连接空闲超过 idle 阈值（60s）后开始发送探测包
 *          2. 探测无响应（默认 3 次 × 5s = 15s）后触发 TIMEOUT
 *          3. Socket 自动关闭并回到 LISTEN
 *
 * 入口条件：Socket 0 处于 ESTABLISHED，PC 连接后静置（不发数据）。
 * 通过：KeepAlive 断开时间 ≥ 60s（从连接建立到 recv 返回 0 的间隔）。
 * 失败：不到 60s 就断开（可能是其他原因导致）或 75s 后仍未断开。
 * =================================================================== */
 #ifdef ENABLE_PHASE11_TESTS
 static int      s_phase11_armed = 0;
 static uint32_t s_phase11_start = 0;
 static void phase11_run(int sockfd) {
    /*
     * 第一次调用：记录开始时间并 arm。
     * 后续调用：非阻塞 recv，若返回 0 表示连接已断开（KeepAlive 触发）。
     * 计算耗时与 60s idle 阈值比较。
     */
    if (!s_phase11_armed) {
        s_phase11_armed = 1;
        s_phase11_start = HAL_GetTick();
        DBG_INFO("Phase11: idle wait for KeepAlive timeout (60s)");
        return;
    }
    int n = net_recv(sockfd, s_rx_buf, 64, NET_MSG_DONTWAIT);
    if (n == 0) {
        uint32_t elapsed = HAL_GetTick() - s_phase11_start;
        TEST_CHECK(elapsed >= 60000,
                   "Phase11: KeepAlive triggered after %lums (expect >=60000ms)", elapsed);
        TEST_REPORT("Phase 11");
        s_phase11_armed = 0;
    }
 }
 #endif
 void net_layer_test_main(void)
 {
    int sockfd = -1;
    int phase_active = 0;
    uint32_t accept_retry = 0;
    struct net_sockaddr_in client_addr;
    int addrlen = sizeof(client_addr);
    sockfd = net_socket(NET_AF_INET, NET_SOCK_STREAM, 0);
    if (sockfd < 0) {
        DBG_ERROR("Test task: net_socket failed");
        return;
    }
    DBG_INFO("Test task: socket %d created", sockfd);
    {
        struct net_sockaddr_in addr;
        memset(&addr, 0, sizeof(addr));
        addr.sin_family = NET_AF_INET;
        addr.sin_port   = net_htons(8080);
        if (net_bind(sockfd, (struct net_sockaddr *)&addr, sizeof(addr)) < 0) {
            DBG_ERROR("Test task: net_bind failed");
            return;
        }
        DBG_INFO("Test task: bound to port 8080");
    }
    if (net_listen(sockfd) < 0) {
        DBG_ERROR("Test task: net_listen failed");
        return;
    }
    DBG_INFO("Test task: listening on 8080 (single-socket mode)");
    /* ==================== 事件驱动阶段 ====================
     * Phase 6/8~11（NET 层）在 TCP 监听循环中运行，需要 PC 客户端连接。
     * （Phase 7 TCP Client 为独立入口 net_layer_client_test_main，不在本循环。）
     * 没有连接时循环等待；连接建立后执行对应 Phase。
     * 断开后自动重新 listen。
     */
    for (;;) {
        if (!phase_active) {
            int acc = net_accept(sockfd, (struct net_sockaddr *)&client_addr, &addrlen);
            if (acc < 0) {
                if (accept_retry % 100 == 0) {
                    DBG_INFO("Test task: waiting for connection...");
                }
                accept_retry++;
                osDelay(100);
                continue;
            }
            accept_retry = 0;
            phase_active = 1;
            DBG_INFO("Test task: client accepted (fd=%d)", acc);
            /* 连接建立，重置各 Phase 内部状态 */
 #ifdef ENABLE_PHASE10_TESTS
            s_phase10_stage = 0;
 #endif
 #ifdef ENABLE_PHASE11_TESTS
            s_phase11_armed = 0;
 #endif
        }
        /* 每 10ms 依次执行各已启用 Phase */
 #ifdef ENABLE_PHASE6_TESTS
        phase6_run(sockfd);
 #endif
 #ifdef ENABLE_PHASE8_TESTS
        phase8_run(sockfd);
        phase_active = 0;   /* Phase 8 一次性完成，发完即止 */
 #endif
 #ifdef ENABLE_PHASE9_TESTS
        phase9_run(sockfd);
 #endif
 #ifdef ENABLE_PHASE10_TESTS
        phase10_run(sockfd);
 #endif
 #ifdef ENABLE_PHASE11_TESTS
        phase11_run(sockfd);
 #endif
        /*
         * 单连接模式：连接断开由 net 层自动重监听（auto_relisten），
         * 应用层不巡检/不重监听，回显循环持续服务新连接。
         */
        osDelay(10);
    }
 }
--- a/test/net_test_task.h
+++ b/test/net_test_task.h
@@ -0,0 +1,22 @@
 #ifndef __NET_TEST_TASK_H
 #define __NET_TEST_TASK_H
 #ifdef __cplusplus
 extern "C" {
 #endif
 /* NET 层测试事件循环入口（定义于 net_test_task.c）。
 * 由 ch395fTestTask 在 NET 层构建模式下调用，内部创建单连接 TCP 监听
 * 并驱动 Phase 6/8~11 依次执行，连接断开后自动重新 listen。 */
 void net_layer_test_main(void);
 /* NET 层 TCP Client 测试入口（定义于 net_test_task.c）。
 * 由 ch395fTestTask 在 NET 层构建模式下（ENABLE_PHASE7_TESTS）调用，
 * MCU 作为 TCP Client 主动连接 PC 回显服务器，覆盖 TC 701/702/703。 */
 void net_layer_client_test_main(void);
 #ifdef __cplusplus
 }
 #endif
 #endif /* __NET_TEST_TASK_H */