From d6bc3f6253dc7c4b7b1517c183b698dcbd0feead Mon Sep 17 00:00:00 2001
From: wandering1 <1624155937@qq.com>
Date: Tue, 25 Aug 2026 11:49:31 +0800
Subject: [PATCH] =?UTF-8?q?=E4=BF=AE=E6=94=B9=E4=B8=80=E4=BA=9B=E6=B3=A8?=
 =?UTF-8?q?=E9=87=8A?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 Drivers/BSP/CH395F/ch395f.c  |   4 +-
 Drivers/BSP/NET/net_select.c | 157 ++++++++------
 Drivers/BSP/NET/net_socket.c | 400 +++++++++++++++++++++++------------
 MDK-ARM/build_log.txt        |  76 +++----
 docs/CH395F_Test_Guide.md    | 194 ++++++++---------
 test/ch395f_test_task.c      |  12 +-
 6 files changed, 496 insertions(+), 347 deletions(-)

diff --git a/Drivers/BSP/CH395F/ch395f.c b/Drivers/BSP/CH395F/ch395f.c
index 112c4b5..f753824 100644
--- a/Drivers/BSP/CH395F/ch395f.c
+++ b/Drivers/BSP/CH395F/ch395f.c
@@ -332,9 +332,9 @@ void ch395f_set_fun_para(uint32_t para) {
 }
 
 /*
- * 函数功能：设置TCP最大分段大小（MSS）
+ * 函数功能：设置 TCP 最大分段大小（MSS）
  * 入口参数：mss - MSS值  uint16_t  60 - 1460
- * 限定条件：必须在ch395f_init()之前调用
+ * 限定条件：必须在 ch395f_init() 之前调用
  */
 void ch395f_set_tcp_mss(uint16_t mss) {
     /* 启动SPI事务 */
diff --git a/Drivers/BSP/NET/net_select.c b/Drivers/BSP/NET/net_select.c
index c10ce26..f6ebc3f 100644
--- a/Drivers/BSP/NET/net_select.c
+++ b/Drivers/BSP/NET/net_select.c
@@ -34,17 +34,18 @@ static int check_socket_error(int sockfd);
 
 /*
  * 函数功能：I/O 多路复用（select 模式），等待多个 Socket 的读写事件就绪
- * 入口参数：nfds     - 最大文件描述符数 +1                                                          int > 0
- *           readfds  - 读事件集合指针                                                              net_fd_set *（可为 NULL）
- *           writefds - 写事件集合指针                                                              net_fd_set *（可为 NULL）
- *           exceptfds- 异常事件集合指针                                                            net_fd_set *（可为 NULL）
- *           timeout  - 超时时间结构体指针                                                          net_timeval *（NULL=无限等待）
- * 返回值：就绪的 Socket 数量                                                                      int >= 0 || -1
- *         -1          - 参数无效                                                                int
+ * 入口参数：nfds     - 最大文件描述符数 +1                                       int    > 0
+ *           readfds  - 读事件集合指针                                           net_fd_set *（可为 NULL）
+ *           writefds - 写事件集合指针                                           net_fd_set *（可为 NULL）
+ *           exceptfds- 异常事件集合指针                                         net_fd_set *（可为 NULL）
+ *           timeout  - 超时时间结构体指针                                       net_timeval *（NULL=无限等待）
+ * 出口参数：readfds/writefds/exceptfds - 仅保留就绪的 Socket 位                  net_fd_set *
+ * 返回值：就绪的 Socket 数量（>= 0）；-1 表示参数无效                           int
  * 限定条件：net_init() + MX_FREERTOS_Init() 已执行；必须在 netTask 上下文中调用
- * 函数说明：轮询所有 Socket，检查读/写/异常事件是否就绪。阻塞等待直到有事件或超时
+ * 函数说明：1. 轮询所有 Socket，检查读/写/异常事件是否就绪
+ *           2. 阻塞等待直到有事件就绪或超时
+ *           3. 通过 osDelay(1) 让出 CPU，平衡实时性与 CPU 利用率
  */
-
 int net_select(int nfds, net_fd_set *readfds, net_fd_set *writefds,
                net_fd_set *exceptfds, net_timeval *timeout) {
     uint32_t start_tick;
@@ -55,8 +56,13 @@ int net_select(int nfds, net_fd_set *readfds, net_fd_set *writefds,
     int ready_count = 0;
     int i;
 
-    /* 计算超时时间 */
-    if (timeout != NULL) {
+    /* 检查输入参数合法性 */
+    if ((0 >= nfds) || (NET_MAX_SOCKETS < nfds)) {
+        return -1;
+    }
+
+    /* 计算超时时间（毫秒） */
+    if (NULL != timeout) {
         timeout_ms = (uint32_t)(timeout->tv_sec * 1000) +
                      (uint32_t)(timeout->tv_usec / 1000);
     }
@@ -64,37 +70,37 @@ int net_select(int nfds, net_fd_set *readfds, net_fd_set *writefds,
     start_tick = HAL_GetTick();
 
     while (1) {
-        /* 轮询所�?Socket */
+        /* 轮询所有 Socket */
         net_poll();
 
         ready_count = 0;
 
-        /* 检查哪�?Socket 有事�?*/
+        /* 检查哪个 Socket 有事件 */
         for (i = 0; i < nfds && i < NET_MAX_SOCKETS; i++) {
             net_sock_t *p_sock = net_get_sock(i);
 
-            if (p_sock == NULL) {
+            if (NULL == p_sock) {
                 continue;
             }
 
-            /* 检查可读事�?*/
-            if (readfds != NULL && NET_FD_ISSET(i, readfds)) {
+            /* 检查可读事件 */
+            if ((NULL != readfds) && NET_FD_ISSET(i, readfds)) {
                 if (check_socket_readable(i)) {
                     NET_FD_SET(i, &result_read);
                     ready_count++;
                 }
             }
 
-            /* 检查可写事�?*/
-            if (writefds != NULL && NET_FD_ISSET(i, writefds)) {
+            /* 检查可写事件 */
+            if ((NULL != writefds) && NET_FD_ISSET(i, writefds)) {
                 if (check_socket_writable(i)) {
                     NET_FD_SET(i, &result_write);
                     ready_count++;
                 }
             }
 
-            /* 检查异常事�?*/
-            if (exceptfds != NULL && NET_FD_ISSET(i, exceptfds)) {
+            /* 检查异常事件 */
+            if ((NULL != exceptfds) && NET_FD_ISSET(i, exceptfds)) {
                 if (check_socket_error(i)) {
                     NET_FD_SET(i, &result_except);
                     ready_count++;
@@ -103,14 +109,14 @@ int net_select(int nfds, net_fd_set *readfds, net_fd_set *writefds,
         }
 
         /* 有事件就绪，返回 */
-        if (ready_count > 0) {
+        if (0 < ready_count) {
             break;
         }
 
-        /* 超时检�?*/
-        if (timeout != NULL) {
-            if (timeout_ms > 0 &&
-                (HAL_GetTick() - start_tick) >= timeout_ms) {
+        /* 超时检测 */
+        if (NULL != timeout) {
+            if ((0 < timeout_ms) &&
+                ((HAL_GetTick() - start_tick) >= timeout_ms)) {
                 break;  /* 超时返回 0 */
             }
         }
@@ -119,14 +125,14 @@ int net_select(int nfds, net_fd_set *readfds, net_fd_set *writefds,
         osDelay(1);  /* 1ms 周期轮询，平衡实时性和 CPU 利用率 */
     }
 
-    /* 复制结果 */
-    if (readfds != NULL) {
+    /* 复制结果集合 */
+    if (NULL != readfds) {
         readfds->fd_bits = result_read.fd_bits;
     }
-    if (writefds != NULL) {
+    if (NULL != writefds) {
         writefds->fd_bits = result_write.fd_bits;
     }
-    if (exceptfds != NULL) {
+    if (NULL != exceptfds) {
         exceptfds->fd_bits = result_except.fd_bits;
     }
 
@@ -135,20 +141,22 @@ int net_select(int nfds, net_fd_set *readfds, net_fd_set *writefds,
 
 /*
  * 函数功能：I/O 多路复用（poll 模式），等待多个 Socket 的读写事件就绪
- * 入口参数：fds     - pollfd 数组指针                                                              net_pollfd *
- *           nfds    - 数组元素数量                                                                int > 0
- *           timeout - 超时时间（毫秒）                                                            int >= 0
- * 返回值：就绪的 fd 数量                                                                          int >= 0 || -1
- *         -1          - 参数无效                                                                int
+ * 入口参数：fds     - pollfd 数组指针                                          net_pollfd *
+ *           nfds    - 数组元素数量                                              int    > 0
+ *           timeout - 超时时间（毫秒）                                          int    >= 0（-1=无限等待，但本实现按 >=0 处理）
+ * 出口参数：fds[i].revents - 填充实际发生的事件掩码                            short
+ * 返回值：就绪的 fd 数量（>= 0）；-1 表示参数无效                              int
  * 限定条件：net_init() + MX_FREERTOS_Init() 已执行；必须在 netTask 上下文中调用
- * 函数说明：轮询所有 Socket，检查读/写/错误/挂起事件是否就绪。阻塞等待直到有事件或超时
+ * 函数说明：1. 轮询所有 Socket，检查读/写/错误/挂起事件是否就绪
+ *           2. 阻塞等待直到有事件就绪或超时
+ *           3. 通过 osDelay(1) 让出 CPU，平衡实时性与 CPU 利用率
  */
 int net_poll_events(net_pollfd *fds, int nfds, int timeout) {
     uint32_t start_tick;
     int ready = 0;
     int i;
 
-    if (fds == NULL || nfds <= 0) {
+    if ((NULL == fds) || (0 >= nfds)) {
         return -1;
     }
 
@@ -163,8 +171,8 @@ int net_poll_events(net_pollfd *fds, int nfds, int timeout) {
         for (i = 0; i < nfds; i++) {
             fds[i].revents = 0;
 
-            /* 检�?fd 有效�?*/
-            if (fds[i].fd < 0 || fds[i].fd >= NET_MAX_SOCKETS) {
+            /* 检查 fd 有效性 */
+            if ((0 > fds[i].fd) || (NET_MAX_SOCKETS <= fds[i].fd)) {
                 fds[i].revents |= NET_POLLNVAL;
                 ready++;
                 continue;
@@ -172,13 +180,13 @@ int net_poll_events(net_pollfd *fds, int nfds, int timeout) {
 
             net_sock_t *p_sock = net_get_sock(fds[i].fd);
 
-            if (p_sock == NULL) {
+            if (NULL == p_sock) {
                 fds[i].revents |= NET_POLLNVAL;
                 ready++;
                 continue;
             }
 
-            /* 检查可�?*/
+            /* 检查可读 */
             if (fds[i].events & NET_POLLIN) {
                 if (check_socket_readable(fds[i].fd)) {
                     fds[i].revents |= NET_POLLIN;
@@ -186,7 +194,7 @@ int net_poll_events(net_pollfd *fds, int nfds, int timeout) {
                 }
             }
 
-            /* 检查可�?*/
+            /* 检查可写 */
             if (fds[i].events & NET_POLLOUT) {
                 if (check_socket_writable(fds[i].fd)) {
                     fds[i].revents |= NET_POLLOUT;
@@ -194,26 +202,26 @@ int net_poll_events(net_pollfd *fds, int nfds, int timeout) {
                 }
             }
 
-            /* 检查错�?*/
+            /* 检查错误 */
             if (check_socket_error(fds[i].fd)) {
                 fds[i].revents |= NET_POLLERR;
                 ready++;
             }
 
-            /* 检查挂起（连接断开�?*/
-            if (p_sock->state == NET_SOCK_STATE_TCP_ACCEPT ||
-                p_sock->state == NET_SOCK_STATE_CLOSED) {
+            /* 检查挂起（连接断开） */
+            if ((NET_SOCK_STATE_TCP_ACCEPT == p_sock->state) ||
+                (NET_SOCK_STATE_CLOSED == p_sock->state)) {
                 fds[i].revents |= NET_POLLHUP;
                 ready++;
             }
         }
 
-        if (ready > 0) {
+        if (0 < ready) {
             break;
         }
 
-        /* 超时检�?*/
-        if (timeout >= 0) {
+        /* 超时检测 */
+        if (0 <= timeout) {
             if ((HAL_GetTick() - start_tick) >= (uint32_t)timeout) {
                 break;
             }
@@ -227,29 +235,36 @@ int net_poll_events(net_pollfd *fds, int nfds, int timeout) {
 }
 
 /*
- * 私有函数实现�? */
+ * 私有函数实现区
+ */
 
 /*
- * 函数功能：检�?Socket 是否可读
- * 返回值：1 可读�? 不可�? */
+ * 函数功能：检查指定 Socket 当前是否可读
+ * 入口参数：sockfd - 待检查的 Socket 描述符                                int    0 - NET_MAX_SOCKETS-1
+ * 出口参数：无
+ * 返回值：1 - 可读（监听态有新连接，或已连接态接收缓冲非空）；0 - 不可读或描述符无效  int
+ * 限定条件：net_init() 已调用
+ * 函数说明：1. 监听态 Socket 视为可读（存在可 accept 的新连接）
+ *           2. 已建立连接且接收缓冲区长度大于 0 时视为可读
+ */
 static int check_socket_readable(int sockfd) {
     net_sock_t *p_sock;
     uint16_t recv_len;
 
     p_sock = net_get_sock(sockfd);
-    if (p_sock == NULL) {
+    if (NULL == p_sock) {
         return 0;
     }
 
-    /* 监听 Socket 有新连接时可�?*/
-    if (p_sock->state == NET_SOCK_STATE_LISTENING) {
+    /* 监听 Socket 有新连接时可读 */
+    if (NET_SOCK_STATE_LISTENING == p_sock->state) {
         return 1;
     }
 
-    /* 已建立连接的 Socket 有数据可�?*/
-    if (p_sock->state == NET_SOCK_STATE_ESTABLISHED) {
+    /* 已建立连接的 Socket 有数据可读 */
+    if (NET_SOCK_STATE_ESTABLISHED == p_sock->state) {
         recv_len = ch395f_get_recv_len(sockfd);
-        if (recv_len > 0) {
+        if (0 < recv_len) {
             return 1;
         }
     }
@@ -258,18 +273,23 @@ static int check_socket_readable(int sockfd) {
 }
 
 /*
- * 函数功能：检�?Socket 是否可写
- * 返回值：1 可写�? 不可�? */
+ * 函数功能：检查指定 Socket 当前是否可写
+ * 入口参数：sockfd - 待检查的 Socket 描述符                                int    0 - NET_MAX_SOCKETS-1
+ * 出口参数：无
+ * 返回值：1 - 可写（已连接且发送缓冲空闲）；0 - 不可写或描述符无效        int
+ * 限定条件：net_init() 已调用
+ * 函数说明：1. 仅已建立连接且 send_ready 标志置位的 Socket 视为可写
+ */
 static int check_socket_writable(int sockfd) {
     net_sock_t *p_sock;
 
     p_sock = net_get_sock(sockfd);
-    if (p_sock == NULL) {
+    if (NULL == p_sock) {
         return 0;
     }
 
-    /* 已建立连接的 Socket 发送缓冲区空闲时可�?*/
-    if (p_sock->state == NET_SOCK_STATE_ESTABLISHED) {
+    /* 已建立连接的 Socket 发送缓冲区空闲时可写 */
+    if (NET_SOCK_STATE_ESTABLISHED == p_sock->state) {
         if (p_sock->send_ready) {
             return 1;
         }
@@ -279,17 +299,24 @@ static int check_socket_writable(int sockfd) {
 }
 
 /*
- * 函数功能：检�?Socket 是否有错�? * 返回值：1 有错误，0 无错�? */
+ * 函数功能：检查指定 Socket 是否存在错误状态
+ * 入口参数：sockfd - 待检查的 Socket 描述符                                int    0 - NET_MAX_SOCKETS-1
+ * 出口参数：无
+ * 返回值：1 - 有错误（含描述符越界或 Socket 未分配）；0 - 无错误          int
+ * 限定条件：无
+ * 函数说明：1. 描述符越界视为错误
+ *           2. 未分配（net_get_sock 返回 NULL）的 Socket 视为错误
+ */
 static int check_socket_error(int sockfd) {
     net_sock_t *p_sock;
 
     /* 无效 fd 视为错误 */
-    if (sockfd < 0 || sockfd >= NET_MAX_SOCKETS) {
+    if ((0 > sockfd) || (NET_MAX_SOCKETS <= sockfd)) {
         return 1;
     }
 
     p_sock = net_get_sock(sockfd);
-    if (p_sock == NULL) {
+    if (NULL == p_sock) {
         return 1;  /* 未使用的 Socket 视为错误 */
     }
 
diff --git a/Drivers/BSP/NET/net_socket.c b/Drivers/BSP/NET/net_socket.c
index c0e8864..31c7506 100644
--- a/Drivers/BSP/NET/net_socket.c
+++ b/Drivers/BSP/NET/net_socket.c
@@ -34,7 +34,7 @@
 /*
  * 全局变量定义区 - 尽量避免使用全局变量
  */
-static net_sock_t s_net_socks[NET_MAX_SOCKETS];  /* Socket 控制块数组 */
+static net_sock_t s_net_socks[NET_MAX_SOCKETS];   /* Socket 控制块数组 */
 static int s_net_errno = 0;                       /* 最后错误码 */
 static uint8_t s_net_initialized = 0;             /* 初始化标志 */
 static uint8_t s_local_ip[4];                     /* 本机 IP 缓存（网络序，net_getsockname 用） */
@@ -50,9 +50,6 @@ extern osMessageQueueId_t netMsgQueueHandle;         /* CubeMX 生成的消息
 
 
 
-
-
-
 /*
  * 私有函数声明区
  */
@@ -115,17 +112,17 @@ int net_init(const char *ip, const char *mask, const char *gateway) {
     /* 设置 TCP MSS */
     ch395f_set_tcp_mss(1460);
 
-    /* 设置 TCP 重传参数（必须在 INIT_CH395 之前�?*/
-    ch395f_set_retrans_count(8);        /* 重传 8 �?*/
+    /* 设置 TCP 重传参数（必须在 INIT_CH395 之前调用*/
+    ch395f_set_retrans_count(8);        /* 重传 8 次*/
     ch395f_set_retrans_period(500);     /* 每次间隔 500ms，总计 4s 重传窗口 */
 
-    /* 设置 TCP KeepAlive 参数（必须在 INIT_CH395 之前，单�?ms，必须为 500 的倍数，IDLE > INTVL�?*/
-    ch395f_set_keepalive_idle(60000);    /* 空闲 60 秒后开始探�?*/
-    ch395f_set_keepalive_intvl(5000);    /* �?5 秒探测一�?*/
-    ch395f_set_keepalive_cnt(3);         /* 最多探�?3 �?*/
+    /* 设置 TCP KeepAlive 参数（必须在 INIT_CH395 之前，单位 ms，必须为 500 的倍数，IDLE > INTVL�?*/
+    ch395f_set_keepalive_idle(60000);    /* 空闲 60 秒后开始探测*/
+    ch395f_set_keepalive_intvl(5000);    /* 5 秒探测一次*/
+    ch395f_set_keepalive_cnt(3);         /* 最多探 3 次*/
 
-    /* 设置网络参数（必须在 INIT_CH395 之前�?*/
-    if (ip != NULL) {
+    /* 设置网络参数（必须在 INIT_CH395 之前调用 */
+    if (NULL != ip) {
         uint8_t ip_arr[4];
         uint8_t mask_arr[4];
         uint8_t gw_arr[4];
@@ -144,7 +141,7 @@ int net_init(const char *ip, const char *mask, const char *gateway) {
         ch395f_set_dhcp(1);
     }
 
-    /* 初始�?CH395F 协议栈（先不配置 buffer，测试默认值是否工作） */
+    /* 初始化 CH395F 协议栈（先不配置 buffer，测试默认值是否工作） */
     ret = ch395f_init();
     if (ret != CH395F_STATUS_OK) {
         s_net_errno = NET_ERR;
@@ -169,94 +166,86 @@ int net_init(const char *ip, const char *mask, const char *gateway) {
  *           4. RECV 中断为电平触发，每次 net_poll() 只处理一批中断，避免主循环饿死
  */
 int net_poll(void) {
+    /* 本次轮询累计发生的事件数（连接/断开/接收/发送/超时各计 1） */
     int event_count = 0;
-    int i;
+    /* 全局中断状态寄存器值（CH395F GET_GLOB_INT_STATUS_ALL 为 16 位） */
     uint16_t int_status;
 
+    /* 防御性检查：尚未初始化则不处理任何中断，直接返回 */
     if (!s_net_initialized) {
         return 0;
     }
 
     /*
-     * GPIO 轮询模式：仅当 INT# 有效（低电平）时读取中断状态。
-     * 读取 GET_GLOB_INT_STATUS_ALL，CH395F 拉高 INT#；若仍有中断则再次拉低。
+     * 采用 do-while(0) 实现“单次批处理”：
+     * 本函数每被调用一次只读取并处理一批中断，处理完立即返回，不循环等待，
+     * 避免 RECV 电平中断导致主循环（如 echo）饿死。
+     * 循环体内部用 break 提前退出（INT# 无效或无中断时）。
      */
     do
     {
+        /*
+         * GPIO 轮询 INT# 引脚：低电平有效（有中断待处理）。
+         * 采用 GPIO 轮询而非 EXTI 边沿中断，仅当 INT# 为低电平时才读取状态，减少不必要 SPI 事务。
+         * 若 INT# 为高（无效），直接退出本次轮询。
+         */
         if (HAL_GPIO_ReadPin(CH395_INT_GPIO_Port, CH395_INT_Pin) == GPIO_PIN_SET) {
             break;
         }
 
+        /* 读取全局中断状态（2 字节）：读操作本身会清除 CH395F 中断并使其拉高 INT#，
+         * 若此后仍有新中断，CH395F 会再次拉低 INT#，由下一次 net_poll() 处理 */
         int_status = ch395f_get_glob_int_status_all();
 
+        /* 无有效中断（读到的状态为 0），提前退出 */
         if (int_status == 0) {
             break;
         }
 
-        /* 诊断：每 3 秒打印一次全局中断状态和 Socket 状态。
-         * 注意：使用已读取的 int_status，不要再读 GINT（读即清除）。 */
-//        static uint32_t s_last_diag = 0;
-//        uint32_t now_diag = HAL_GetTick();
-//        if ((now_diag - s_last_diag >= 3000) || s_last_diag == 0) {
-//            s_last_diag = now_diag;
-//            DBG_INFO("GINT=0x%04X", int_status);
-//            for (int di = 0; di < NET_MAX_SOCKETS; di++) {
-//                DBG_INFO("  s%d: in_use=%d state=%d",
-//                    di, s_net_socks[di].in_use, s_net_socks[di].state);
-//            }
-//        }
-
-        if (int_status & CH395F_GINT_STAT_PHY_CHANGE) {
-            uint8_t phy = ch395f_get_phy_status();
-            DBG_INFO("PHY_CHANGE: 0x%02X", phy);
-            if (phy == CH395F_PHY_DISCONN) {
-                DBG_ERROR("PHY disconnected, sockets may need recovery");
-            }
-        }
-
-        /* 处理每个 Socket */
-        for (i = 0; i < NET_MAX_SOCKETS; i++) {
+        /* 遍历所有 Socket，处理各自的中断 */
+        for (int i = 0; i < NET_MAX_SOCKETS; i++) {
+            /* 取本 Socket 控制块（直接用数组下标，无需 net_get_sock 的越界判断） */
             net_sock_t *p_sock = &s_net_socks[i];
 
-            /* 检查该 Socket 是否有中断（全局中断状�?bit4~bit11 对应 socket0~7�?*/
+            /* 全局中断状态 bit4~bit11 分别对应 socket0~socket7 的中断标志，
+             * 对应位为 0 说明该 Socket 无中断，跳过以节省时间 */
             if (!(int_status & (1U << (i + 4)))) {
                 continue;
             }
 
-            /* 读取 Socket 中断状�?*/
+            /* 读取该 Socket 的中断状态寄存器（SINT） */
             uint8_t sock_int = ch395f_get_sock_int_status(i);
-            //DBG_INFO("s%d int=0x%02X", i, sock_int);
 
-            /* 连接事件 */
+            /* 连接建立事件：交给状态机处理（监听态/客户端/数据 Socket 分别处理） */
             if (sock_int & CH395F_SINT_STAT_CONNECT) {
                 handle_connect_event(p_sock);
                 event_count++;
             }
 
-            /* 断开事件 */
+            /* 连接断开事件：更新状态机并触发断开回调 */
             if (sock_int & CH395F_SINT_STAT_DISCONNECT) {
                 handle_disconnect_event(p_sock);
                 event_count++;
             }
 
-            /* 数据接收事件 */
+            /* 接收数据就绪事件：仅通知上层，实际数据由 net_recv_locked 读出（避免重复读 recv_len） */
             if (sock_int & CH395F_SINT_STAT_RECV_OK) {
                 handle_recv_event(p_sock);
                 event_count++;
             }
 
-            /* 发送完成事�?*/
+            /* 发送完成事件：通知上层发送缓冲已空，可继续发送 */
             if (sock_int & CH395F_SINT_STAT_SEND_OK) {
                 handle_send_event(p_sock);
                 event_count++;
             }
 
-            /* 发送缓冲区空闲 */
+            /* 发送缓冲区空闲：置 send_ready 标志，唤醒等待发送的逻辑 */
             if (sock_int & CH395F_SINT_STAT_SENBUF_FREE) {
                 p_sock->send_ready = 1;
             }
 
-            /* 超时事件 */
+            /* 超时事件：连接超时或收发超时，更新状态机 */
             if (sock_int & CH395F_SINT_STAT_SOCK_TIMEOUT) {
                 handle_timeout_event(p_sock);
                 event_count++;
@@ -264,31 +253,14 @@ int net_poll(void) {
         }
 
         /*
-         * 处理完毕后检查 INT# 是否仍为低电平。如果是，说明在处理期间有新中断产生，需要再次读取。
-         * 注意：CH395F 的 RECV 中断是电平触发的（只要接收缓冲区有数据就保持低电平）。
-         * 如果不跳出循环，net_poll() 会无限循环处理 RECV 中断，导致主循环中的应用代码（如 echo）永远无法执行。
-         * 因此每次 net_poll() 调用只处理一批中断，由主循环负责读取数据。 */
+         * 处理完本批中断后退出 do-while(0)：
+         * CH395F 的 RECV 中断为电平触发，只要接收缓冲区仍有数据就保持 INT# 低电平，
+         * 若此处继续循环会反复处理 RECV 中断，导致主循环中的应用代码（如 echo 回显）得不到执行。
+         * 因此每次 net_poll() 只处理“一批”，剩余数据由主循环/recv 逻辑在后续轮询中读取。
+         */
     } while (0);
 
-//    /* 2 秒打印一次诊断信息（调试用） */
-//    {
-//        static uint32_t s_last_dbg = 0;
-//        uint32_t now = HAL_GetTick();
-//        if (now - s_last_dbg >= 2000) {
-//            s_last_dbg = now;
-//            uint8_t int_level = (HAL_GPIO_ReadPin(CH395_INT_GPIO_Port, CH395_INT_Pin) == GPIO_PIN_RESET) ? 1 : 0;
-//            DBG_DEBUG("INT#=%d", int_level);
-//            for (i = 0; i < NET_MAX_SOCKETS; i++) {
-//                if (s_net_socks[i].in_use) {
-//                    uint8_t st[2];
-//                    ch395f_get_socket_status((uint8_t)i, st);
-//                    uint16_t rl = ch395f_get_recv_len((uint8_t)i);
-//                    DBG_DEBUG(" s%d:sw%d/tcp%d rl%d", i, st[0], st[1], rl);
-//                }
-//            }
-//        }
-//    }
-
+    /* 返回本次累计发生的事件数量（0 表示无事件） */
     return event_count;
 }
 
@@ -301,7 +273,7 @@ int net_poll(void) {
 void net_process_messages(void) {
     net_msg_t msg;
 
-    if (netMsgQueueHandle == NULL) {
+    if (NULL == netMsgQueueHandle) {
         return;
     }
 
@@ -309,7 +281,7 @@ void net_process_messages(void) {
         switch (msg.type) {
         case NET_MSG_SEND: {
             net_sock_t *p_sock = net_get_sock(msg.sockfd);
-            if (p_sock == NULL || p_sock->state != NET_SOCK_STATE_ESTABLISHED) {
+            if (NULL == p_sock || p_sock->state != NET_SOCK_STATE_ESTABLISHED) {
                 msg.result = -1;
             } else {
                 msg.result = net_send_locked(p_sock, msg.buf, msg.len);
@@ -318,7 +290,7 @@ void net_process_messages(void) {
         }
         case NET_MSG_RECV: {
             net_sock_t *p_sock = net_get_sock(msg.sockfd);
-            if (p_sock == NULL) {
+            if (NULL == p_sock) {
                 msg.result = -1;
             } else {
                 msg.result = net_recv_locked(p_sock, msg.buf, msg.len, msg.flags);
@@ -327,7 +299,7 @@ void net_process_messages(void) {
         }
         case NET_MSG_CLOSE: {
             net_sock_t *p_sock = net_get_sock(msg.sockfd);
-            if (p_sock == NULL) {
+            if (NULL == p_sock) {
                 msg.result = -1;
             } else {
                 msg.result = net_close_locked(p_sock);
@@ -347,7 +319,7 @@ void net_process_messages(void) {
         case NET_MSG_ACCEPT: {
             struct net_sockaddr *p_addr = (struct net_sockaddr *)msg.buf;
             int addrlen = msg.len;
-            int *p_addrlen = (p_addr != NULL && addrlen > 0) ? &addrlen : NULL;
+            int *p_addrlen = (NULL != p_addr && addrlen > 0) ? &addrlen : NULL;
             msg.result = net_accept_locked(msg.sockfd, p_addr, p_addrlen);
             break;
         }
@@ -424,7 +396,7 @@ int net_bind(int sockfd, const struct net_sockaddr *addr, int addrlen) {
         return -1;
     }
 
-    if (addr == NULL || addrlen < (int)sizeof(struct net_sockaddr_in)) {
+    if (NULL == addr || addrlen < (int)sizeof(struct net_sockaddr_in)) {
         s_net_errno = NET_ERR_INVAL;
         return -1;
     }
@@ -456,7 +428,7 @@ int net_bind(int sockfd, const struct net_sockaddr *addr, int addrlen) {
         ch395f_set_proto_type((uint8_t)sockfd, CH395F_PROTO_TYPE_UDP);
         ch395f_set_sour_port((uint8_t)sockfd, p_sock->local_port);
 
-        /* DesIP=0xFFFFFFFF �?UDP Server 模式（接受任意来源） */
+        /* DesIP=0xFFFFFFFF  UDP Server 模式（接受任意来源） */
         {
             uint8_t broadcast[4] = {0xFF, 0xFF, 0xFF, 0xFF};
             ch395f_set_des_ip((uint8_t)sockfd, broadcast);
@@ -480,77 +452,102 @@ int net_bind(int sockfd, const struct net_sockaddr *addr, int addrlen) {
 
 /*
  * 函数功能：启动 TCP Server 监听（内部版本，必须在 netTask 上下文调用）
- * 入口参数：sockfd   - Socket 描述符 (0~7)                                        int
- *           backlog  - 数据 Socket 数量（0=单连接模式）                            int
- * 返回值：0 - 成功，-1 - 失败                                                    int
+ * 入口参数：sockfd   - Socket 描述符 (0~7)                 int
+ *           backlog  - 数据 Socket 数量（0=单连接模式）    int
+ * 返回值：0 - 成功，-1 - 失败                              int
  * 限定条件：sockfd 已绑定且为 TCP；netTask 上下文
  */
 int net_listen_locked(int sockfd, int backlog) {
+    /* 取监听 Socket 控制块（直接下标访问，sockfd 已在上层 net_listen 校验过范围） */
     net_sock_t *p_sock = &s_net_socks[sockfd];
+    /* CH395F 打开 Socket 的返回状态 */
     uint8_t status;
 
+    /* 合法性检查：Socket 必须已创建且为 TCP 流类型 */
     if (!p_sock->in_use || p_sock->type != NET_SOCK_STREAM) {
         s_net_errno = NET_ERR_INVAL;
         return -1;
     }
 
+    /* 状态检查：仅允许在 BOUND（已 bind）或 CREATED（未 bind 直接用随机端口）状态下启动监听 */
     if (p_sock->state != NET_SOCK_STATE_BOUND &&
         p_sock->state != NET_SOCK_STATE_CREATED) {
         s_net_errno = NET_ERR_INVAL;
         return -1;
     }
 
-    /* 多连接模式：按 backlog 分配数据 Socket */
+    /* 多连接模式（backlog > 0）：为数据 Socket 分配并初始化 CH395F 资源 */
     if (backlog > 0) {
+        /* 数据 Socket 编号范围：[NET_TCP_SERVER_DATA_SOCK_START, max_ds) */
         int max_ds = NET_TCP_SERVER_DATA_SOCK_START + backlog;
+        /* 越界保护：不超过 Socket 总数 */
         if (max_ds > NET_MAX_SOCKETS) {
             max_ds = NET_MAX_SOCKETS;
         }
+        /* 逐个配置数据 Socket，供后续 accept 时承接新连接 */
         for (int ds = NET_TCP_SERVER_DATA_SOCK_START; ds < max_ds; ds++) {
+            /* 以 4 块为单位划出该 Socket 的发送/接收缓冲（发送占前 2 块，接收占后 2 块） */
             uint8_t base = (uint8_t)(ds * 4);
             ch395f_set_send_buf((uint8_t)ds, base, 2);
             ch395f_set_recv_buf((uint8_t)ds, base + 2, 2);
+            /* 数据 Socket 监听同一本地端口，协议类型为 TCP */
             ch395f_set_sour_port((uint8_t)ds, p_sock->local_port);
             ch395f_set_proto_type((uint8_t)ds, CH395F_PROTO_TYPE_TCP);
+            /* 登记数据 Socket 控制块：标记已用、等待连接态、流类型、绑定硬件 Socket 号 */
             s_net_socks[ds].in_use = 1;
             s_net_socks[ds].state = NET_SOCK_STATE_TCP_ACCEPT;
             s_net_socks[ds].type = NET_SOCK_STREAM;
             s_net_socks[ds].ch395_sock = (uint8_t)ds;
             s_net_socks[ds].send_ready = 1;
 
+            /* 记录到监听 Socket 的数据 Socket 列表，供 net_accept_locked 查表 */
             p_sock->data_socks[p_sock->data_sock_count++] = ds;
         }
     }
 
-    /* 配置监听 Socket：单连接模式使用 CH395F 默认缓冲区（socket 0-3 已互不重叠），
-     * 多连接模式显式分配（socket 4-7 默认无缓冲区）*/
+    /*
+     * 配置监听 Socket 自身的缓冲：
+     * - 单连接模式（backlog==0，通常用 Socket 0~3）：CH395F 默认缓冲已互不重叠，无需重设；
+     * - 多连接模式（Socket 4~7 默认无收发缓冲）：显式按 4 块划分发送/接收缓冲。
+     */
     if (backlog > 0) {
         uint8_t base = (uint8_t)(sockfd * 4);
         ch395f_set_send_buf((uint8_t)sockfd, base, 2);
         ch395f_set_recv_buf((uint8_t)sockfd, base + 2, 2);
     }
+    /* 监听 Socket 协议类型为 TCP，并绑定本地端口 */
     ch395f_set_proto_type(sockfd, CH395F_PROTO_TYPE_TCP);
     ch395f_set_sour_port(sockfd, p_sock->local_port);
 
-    /* CH395F 关 socket 后需要时间才能重新打开，重试 3 次（Trap 09） */
+    /* CH395F 关闭 Socket 后需延时才能重新打开（Trap 09），故失败重试最多 3 次 */
     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);
+        if (status == CH395F_ERR_SUCCESS) {
+            break;  /* 打开成功，退出重试 */
+        }
+        ch395f_close_socket(sockfd);  /* 打开失败先关闭，再延时后重试 */
         HAL_Delay(500);
     }
+    /* 3 次仍失败，返回错误 */
     if (status != CH395F_ERR_SUCCESS) {
         s_net_errno = NET_ERR_BUSY;
         return -1;
     }
 
+    /* 下发 TCP LISTEN 命令，进入监听状态 */
     ch395f_tcp_listen(sockfd);
 
+    /* 监听 Socket 进入 LISTENING 态 */
     p_sock->state = NET_SOCK_STATE_LISTENING;
+    /* 单连接模式标记为 standalone_accept：CONNECT 中断直接作用于本 Socket 自身 */
     if (backlog == 0) {
         p_sock->standalone_accept = 1;
     }
 
+    /*
+     * 启动监听前清空各 Socket 及全局中断状态寄存器（读即清除），
+     * 避免历史残留/伪中断在监听刚开始时误触发连接或断开事件。
+     */
     for (int j = 0; j < NET_MAX_SOCKETS; j++) {
         (void)ch395f_get_sock_int_status((uint8_t)j);
     }
@@ -575,7 +572,7 @@ int net_listen(int sockfd, int backlog) {
         return -1;
     }
 
-    if (netMsgQueueHandle == NULL) {
+    if (NULL == netMsgQueueHandle) {
         s_net_errno = NET_ERR;
         return -1;
     }
@@ -635,7 +632,7 @@ static int net_accept_locked(int sockfd, struct net_sockaddr *addr, int *addrlen
         net_sock_t *p_data_cb = &s_net_socks[data_sock];
 
         if (p_data_cb->state == NET_SOCK_STATE_ESTABLISHED) {
-            if (addr != NULL && addrlen != NULL) {
+            if (NULL != addr &&NULL != addrlen) {
                 struct net_sockaddr_in *p_addr_in = (struct net_sockaddr_in *)addr;
                 p_addr_in->sin_family = NET_AF_INET;
                 p_addr_in->sin_port = net_htons(p_data_cb->remote_port);
@@ -649,7 +646,7 @@ static int net_accept_locked(int sockfd, struct net_sockaddr *addr, int *addrlen
     /* 单连接模式（PASV）：查 standalone 监听者是否已 ESTABLISHED */
     if (p_listen_sock->standalone_accept &&
         p_listen_sock->state == NET_SOCK_STATE_ESTABLISHED) {
-        if (addr != NULL && addrlen != NULL) {
+        if (NULL != addr &&NULL != addrlen) {
             struct net_sockaddr_in *p_addr_in = (struct net_sockaddr_in *)addr;
             p_addr_in->sin_family = NET_AF_INET;
             p_addr_in->sin_port = net_htons(p_listen_sock->remote_port);
@@ -680,7 +677,7 @@ int net_accept(int sockfd, struct net_sockaddr *addr, int *addrlen) {
         return -1;
     }
 
-    if (netMsgQueueHandle == NULL) {
+    if (NULL == netMsgQueueHandle) {
         s_net_errno = NET_ERR;
         return -1;
     }
@@ -688,7 +685,7 @@ int net_accept(int sockfd, struct net_sockaddr *addr, int *addrlen) {
     msg.type = NET_MSG_ACCEPT;
     msg.sockfd = sockfd;
     msg.buf = (void *)addr;
-    msg.len = (addrlen != NULL) ? *addrlen : 0;
+    msg.len = (NULL != addrlen) ? *addrlen : 0;
     msg.caller = xTaskGetCurrentTaskHandle();
     msg.result = -1;
 
@@ -703,7 +700,7 @@ int net_accept(int sockfd, struct net_sockaddr *addr, int *addrlen) {
         msg.result = (int)s_notified;
     }
 
-    if (addrlen != NULL && addr != NULL) {
+    if (NULL != addrlen &&NULL != addr) {
         *addrlen = sizeof(struct net_sockaddr_in);
     }
 
@@ -741,7 +738,7 @@ int net_connect(int sockfd, const struct net_sockaddr *addr, int addrlen) {
         return -1;
     }
 
-    if (addr == NULL || addrlen < (int)sizeof(struct net_sockaddr_in)) {
+    if (NULL == addr || addrlen < (int)sizeof(struct net_sockaddr_in)) {
         s_net_errno = NET_ERR_INVAL;
         return -1;
     }
@@ -785,12 +782,24 @@ int net_connect(int sockfd, const struct net_sockaddr *addr, int addrlen) {
 /*
  * 函数功能：发送数据（内部锁定版本，必须在 netTask 上下文调用）
  */
+/*
+ * 函数功能：发送数据（内部锁定版本，必须在 netTask 上下文调用）
+ * 入口参数：p_sock - Socket 控制块指针                                  net_sock_t *
+ *           buf    - 待发送数据缓冲区指针                               const void *
+ *           len    - 数据长度                                           int    > 0
+ * 出口参数：无
+ * 返回值：实际发送字节数（>= 0）；-1 表示参数无效或 Socket 未连接      int
+ * 限定条件：p_sock 非空；Socket 处于 ESTABLISHED 状态；netTask 上下文
+ * 函数说明：1. 按 NET_DMA_MAX_PAYLOAD 分块写入 CH395F 发送缓冲区
+ *           2. 发送前等待 send_ready 置位，超时返回已发送字节数
+ *           3. 每写完一块等待 SEND_OK 中断（send_ready 清零后重新置位）
+ */
 static int net_send_locked(net_sock_t *p_sock, const void *buf, int len) {
     int sent = 0;
     uint32_t tick_start;
     int sockfd = (int)(p_sock - s_net_socks);
 
-    if (buf == NULL || len <= 0) {
+    if (NULL == buf || len <= 0) {
         s_net_errno = NET_ERR_INVAL;
         return -1;
     }
@@ -839,12 +848,25 @@ static int net_send_locked(net_sock_t *p_sock, const void *buf, int len) {
 /*
  * 函数功能：接收数据（内部锁定版本，必须在 netTask 上下文调用）
  */
+/*
+ * 函数功能：接收数据（内部锁定版本，必须在 netTask 上下文调用）
+ * 入口参数：p_sock - Socket 控制块指针                                  net_sock_t *
+ *           buf    - 接收缓冲区指针                                      void *
+ *           len    - 缓冲区大小                                          int    > 0
+ *           flags  - 标志位，NET_MSG_DONTWAIT 表示非阻塞                 int
+ * 出口参数：buf    - 填充接收到的数据
+ * 返回值：实际接收字节数（> 0）；0 表示对端关闭；-1 表示出错/超时/非阻塞无数据  int
+ * 限定条件：p_sock 非空；netTask 上下文
+ * 函数说明：1. 循环调用 net_poll() 检查接收长度，有数据即读出
+ *           2. 非阻塞模式下无数据立即返回 -1（NET_ERR_WOULDBLOCK）
+ *           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;
     uint32_t tick_start;
     int sockfd = (int)(p_sock - s_net_socks);
 
-    if (buf == NULL || len <= 0) {
+    if (NULL == buf || len <= 0) {
         s_net_errno = NET_ERR_INVAL;
         return -1;
     }
@@ -895,6 +917,15 @@ static int net_recv_locked(net_sock_t *p_sock, void *buf, int len, int flags) {
 /*
  * 函数功能：关闭 socket（内部锁定版本，必须在 netTask 上下文调用）
  */
+/*
+ * 函数功能：关闭 Socket（内部锁定版本，必须在 netTask 上下文调用）
+ * 入口参数：p_sock - Socket 控制块指针                                  net_sock_t *
+ * 出口参数：无
+ * 返回值：0 - 关闭成功                                                  int
+ * 限定条件：p_sock 非空；netTask 上下文
+ * 函数说明：1. 调用 ch395f_close_socket 关闭 CH395F 硬件 Socket
+ *           2. 清空整个控制块（memset 0），释放该 Socket 资源
+ */
 static int net_close_locked(net_sock_t *p_sock) {
     int sockfd = (int)(p_sock - s_net_socks);
 
@@ -924,7 +955,7 @@ int net_send(int sockfd, const void *buf, int len, int flags) {
         return -1;
     }
 
-    if (netMsgQueueHandle == NULL) {
+    if (NULL == netMsgQueueHandle) {
         s_net_errno = NET_ERR;
         return -1;
     }
@@ -974,7 +1005,7 @@ int net_recv(int sockfd, void *buf, int len, int flags) {
         return -1;
     }
 
-    if (netMsgQueueHandle == NULL) {
+    if (NULL == netMsgQueueHandle) {
         s_net_errno = NET_ERR;
         return -1;
     }
@@ -1021,7 +1052,7 @@ int net_close(int sockfd) {
         return -1;
     }
 
-    if (netMsgQueueHandle == NULL) {
+    if (NULL == netMsgQueueHandle) {
         s_net_errno = NET_ERR;
         return -1;
     }
@@ -1079,13 +1110,13 @@ int net_sendto(int sockfd, const void *buf, int len, int flags,
         return -1;
     }
 
-    if (buf == NULL || len <= 0) {
+    if (NULL == buf || len <= 0) {
         s_net_errno = NET_ERR_INVAL;
         return -1;
     }
 
     /* UDP 模式：设置目标地址 */
-    if (dest_addr != NULL && addrlen >= (int)sizeof(struct net_sockaddr_in)) {
+    if (NULL != dest_addr && addrlen >= (int)sizeof(struct net_sockaddr_in)) {
         p_addr_in = (const struct net_sockaddr_in *)dest_addr;
 
         /* 转换 IP 为数组格�?*/
@@ -1168,7 +1199,7 @@ int net_recvfrom(int sockfd, void *buf, int len, int flags,
         return -1;
     }
 
-    if (buf == NULL || len <= 0) {
+    if (NULL == buf || len <= 0) {
         s_net_errno = NET_ERR_INVAL;
         return -1;
     }
@@ -1187,7 +1218,7 @@ int net_recvfrom(int sockfd, void *buf, int len, int flags,
                 recv_len -= 8;
 
                 /* 填充来源地址 */
-                if (src_addr != NULL && addrlen != NULL &&
+                if (NULL != src_addr &&NULL != addrlen &&
                     *addrlen >= (int)sizeof(struct net_sockaddr_in)) {
                     struct net_sockaddr_in *p_addr_in = (struct net_sockaddr_in *)src_addr;
                     p_addr_in->sin_family = NET_AF_INET;
@@ -1228,8 +1259,18 @@ int net_recvfrom(int sockfd, void *buf, int len, int flags,
 /*
  * 函数功能：发送数据（内部版本，绕过消息队列，供 netTask 直接使用）
  */
+/*
+ * 函数功能：发送数据（内部版本，绕过消息队列，供 netTask 直接使用）
+ * 入口参数：p_sock - Socket 控制块指针                                  net_sock_t *
+ *           buf    - 待发送数据缓冲区指针                               const void *
+ *           len    - 数据长度                                           int    > 0
+ * 出口参数：无
+ * 返回值：实际发送字节数（>= 0）；-1 表示参数无效                      int
+ * 限定条件：p_sock 非空；netTask 上下文（避免向自身发送消息造成死锁）
+ * 函数说明：直接调用 net_send_locked 完成发送
+ */
 int net_send_sock(net_sock_t *p_sock, const void *buf, int len) {
-    if (p_sock == NULL) {
+    if (NULL == p_sock) {
         s_net_errno = NET_ERR_BADF;
         return -1;
     }
@@ -1248,7 +1289,7 @@ int net_send_sock(net_sock_t *p_sock, const void *buf, int len) {
  * 函数说明：直接操作 Socket 控制块，不经过消息队列。避免 netTask 向自身发送消息造成死锁
  */
 int net_recv_sock(net_sock_t *p_sock, void *buf, int len, int flags) {
-    if (p_sock == NULL) {
+    if (NULL == p_sock) {
         s_net_errno = NET_ERR_BADF;
         return -1;
     }
@@ -1263,7 +1304,7 @@ int net_recv_sock(net_sock_t *p_sock, void *buf, int len, int flags) {
  * 函数说明：直接操作 Socket 控制块，不经过消息队列。TCP Socket 先断开连接再释放控制块
  */
 int net_close_sock(net_sock_t *p_sock) {
-    if (p_sock == NULL) {
+    if (NULL == p_sock) {
         s_net_errno = NET_ERR_BADF;
         return -1;
     }
@@ -1311,14 +1352,20 @@ int net_get_errno(void) {
 }
 
 /*
- * 函数功能：将 IP 地址字符串转为网络字节序
+ * 函数功能：将点分十进制 IP 地址字符串转换为网络字节序的 32 位地址
+ * 入口参数：cp - 点分十进制 IP 字符串（如 "192.168.1.100"）            const char *
+ * 出口参数：无
+ * 返回值：网络字节序的 32 位 IP 地址（0 表示参数无效）                uint32_t
+ * 限定条件：无
+ * 函数说明：1. 逐段解析十进制数与并小端组装为 32 位值
+ *           2. 转换结果经 NET_htonl 转为网络字节序
  */
 uint32_t net_inet_addr(const char *cp) {
     uint32_t addr = 0;
     uint32_t val;
     int i;
 
-    if (cp == NULL) {
+    if (NULL == cp) {
         return 0;
     }
 
@@ -1338,11 +1385,18 @@ uint32_t net_inet_addr(const char *cp) {
 }
 
 /*
- * 函数功能：将网络字节�?IP 转为字符�? */
+ * 函数功能：将网络字节序的 32 位地址转换为点分十进制字符串
+ * 入口参数：addr - 网络字节序的 32 位 IP 地址                         uint32_t
+ *           buf  - 输出缓冲区（至少 16 字节）                          char *
+ * 出口参数：buf  - 填充点分十进制字符串
+ * 返回值：成功返回 buf 指针；buf 为 NULL 时返回 NULL                  char *
+ * 限定条件：buf 非空且长度足够（>= 16 字节）
+ * 函数说明：1. 先经 NET_ntohl 转为主机字节序再格式化输出
+ */
 char *net_inet_ntoa(uint32_t addr, char *buf) {
     uint32_t naddr = NET_ntohl(addr);
 
-    if (buf == NULL) {
+    if (NULL == buf) {
         return NULL;
     }
 
@@ -1355,40 +1409,64 @@ char *net_inet_ntoa(uint32_t addr, char *buf) {
     return buf;
 }
 
+
 /*
  * 函数功能：端口字节序转换（主机序 -> 网络序）
+ * 入口参数：hostshort - 主机字节序的 16 位端口                        uint16_t
+ * 出口参数：无
+ * 返回值：网络字节序的 16 位端口                                      uint16_t
+ * 限定条件：无
+ * 函数说明：直接调用 NET_htons 完成转换
  */
 uint16_t net_htons(uint16_t hostshort) {
     return NET_htons(hostshort);
 }
 
+
 /*
  * 函数功能：端口字节序转换（网络序 -> 主机序）
+ * 入口参数：netshort - 网络字节序的 16 位端口                         uint16_t
+ * 出口参数：无
+ * 返回值：主机字节序的 16 位端口                                      uint16_t
+ * 限定条件：无
+ * 函数说明：直接调用 NET_ntohs 完成转换
  */
 uint16_t net_ntohs(uint16_t netshort) {
     return NET_ntohs(netshort);
 }
 
 /*
- * 函数功能：IP 地址字节序转换（主机�?-> 网络序）
+ * 函数功能：IP 地址字节序转换（主机序 -> 网络序）
+ * 入口参数：hostlong - 主机字节序的 32 位 IP 地址                     uint32_t
+ * 出口参数：无
+ * 返回值：网络字节序的 32 位 IP 地址                                  uint32_t
+ * 限定条件：无
+ * 函数说明：直接调用 NET_htonl 完成转换
  */
 uint32_t net_htonl(uint32_t hostlong) {
     return NET_htonl(hostlong);
 }
 
 /*
- * 函数功能：IP 地址字节序转换（网络�?-> 主机序）
+ * 函数功能：IP 地址字节序转换（网络序 -> 主机序）
+ * 入口参数：netlong - 网络字节序的 32 位 IP 地址                      uint32_t
+ * 出口参数：无
+ * 返回值：主机字节序的 32 位 IP 地址                                  uint32_t
+ * 限定条件：无
+ * 函数说明：直接调用 NET_ntohl 完成转换
  */
 uint32_t net_ntohl(uint32_t netlong) {
     return NET_ntohl(netlong);
 }
 
 /*
- * 私有函数实现�? */
-
-/*
- * 函数功能：分配空�?Socket
- * 返回值：Socket 索引，失败返�?-1
+ * 函数功能：分配一个空闲的 Socket 控制块
+ * 入口参数：无
+ * 出口参数：无
+ * 返回值：空闲 Socket 索引（0~NET_MAX_SOCKETS-1）；-1 表示无空闲 Socket    int
+ * 限定条件：s_net_socks 已定义
+ * 函数说明：1. 线性扫描 s_net_socks，返回首个 in_use == 0 的控制块索引
+ *           2. 调用方负责初始化该控制块
  */
 static int alloc_socket(void) {
     int i;
@@ -1403,7 +1481,17 @@ static int alloc_socket(void) {
 }
 
 /*
- * 函数功能：处理连接事�? */
+ * 入口参数：p_sock - 发生连接事件的 Socket 控制块指针                    net_sock_t *
+ * 出口参数：无
+ * 返回值：无
+ * 限定条件：net_poll() 检测到 CONNECT 中断后调用；netTask 上下文
+ * 函数说明：1. 独立监听模式（standalone_accept）：自身转 ESTABLISHED 并读取对端地址
+ *           2. 多连接监听模式：Socket 0 保持 LISTENING，由数据 Socket 承接连接
+ *           3. 多连接模式自动打开的数据 Socket：首次 CONNECT 时初始化并置 ESTABLISHED
+ *           4. TCP Client（CONNECTING）：连接成功，读取对端地址并置 ESTABLISHED
+ *           5. 数据 Socket（TCP_ACCEPT）：被分配连接，置 ESTABLISHED
+ *           6. 连接成功后使能 KeepAlive 并触发 NET_EVENT_CONNECTED 回调
+ */
 static void handle_connect_event(net_sock_t *p_sock) {
     if (p_sock->state == NET_SOCK_STATE_LISTENING) {
         if (p_sock->standalone_accept) {
@@ -1488,9 +1576,16 @@ static void handle_connect_event(net_sock_t *p_sock) {
 }
 
 /*
- * 函数功能：处理断开事件
- * 函数说明：CH395F �?DISCONNECT 中断后自动关�?Socket（默�?FUN_PARA_FLAG_SOCKET_CLOSE=0），
- *          必须重新 OPEN_SOCKET + TCP_LISTEN 才能接受新连�? */
+ * 函数功能：处理 Socket 断开（DISCONNECT）事件，更新 Socket 状态机
+ * 入口参数：p_sock - 发生断开事件的 Socket 控制块指针                    net_sock_t *
+ * 出口参数：无
+ * 返回值：无
+ * 限定条件：net_poll() 检测到 DISCONNECT 中断后调用；netTask 上下文
+ * 函数说明：1. CH395F 在 DISCONNECT 后自动关闭 Socket（FUN_PARA 默认），需重新 OPEN + LISTEN
+ *           2. 独立监听模式：置 CLOSED，交由 net_recv_locked 排空剩余数据后再关
+ *           3. 多连接数据 Socket：回到 TCP_ACCEPT 状态等待新连接
+ *           4. 触发 NET_EVENT_DISCONNECTED 回调
+ */
 static void handle_disconnect_event(net_sock_t *p_sock) {
     if (p_sock->state == NET_SOCK_STATE_LISTENING) {
         DBG_ERROR("WARNING: listen sock%d got disconnect", p_sock->ch395_sock);
@@ -1524,7 +1619,15 @@ static void handle_disconnect_event(net_sock_t *p_sock) {
 }
 
 /*
- * 函数功能：处理数据接收事�? */
+ * 函数功能：处理数据接收事件
+ * 函数功能：处理 Socket 数据接收（RECV_OK）事件
+ * 入口参数：p_sock - 发生接收事件的 Socket 控制块指针                    net_sock_t *
+ * 出口参数：无
+ * 返回值：无
+ * 限定条件：net_poll() 检测到 RECV_OK 中断后调用；netTask 上下文
+ * 函数说明：1. 仅触发 NET_EVENT_DATA_RECEIVED 回调通知上层
+ *           2. 不在此读取 recv_len，避免与 net_recv_locked 中的读取冲突（Trap 13）
+ */
 static void handle_recv_event(net_sock_t *p_sock) {
     /* RECV_OK 中断已触发，直接通知上层。不在此读 recv_len，
      * 避免和 net_recv_locked 里面的 ch395f_get_recv_len 冲突（Trap 13） */
@@ -1532,13 +1635,28 @@ static void handle_recv_event(net_sock_t *p_sock) {
 }
 
 /*
- * 函数功能：处理发送完成事�? */
+ * 函数功能：处理 Socket 发送完成（SEND_OK）事件
+ * 入口参数：p_sock - 发生发送完成事件的 Socket 控制块指针              net_sock_t *
+ * 出口参数：无
+ * 返回值：无
+ * 限定条件：net_poll() 检测到 SEND_OK 中断后调用；netTask 上下文
+ * 函数说明：触发 NET_EVENT_SEND_COMPLETE 回调通知上层
+ */
 static void handle_send_event(net_sock_t *p_sock) {
     fire_event(p_sock, NET_EVENT_SEND_COMPLETE);
 }
 
 /*
- * 函数功能：处理超时事�? * 函数说明：CH395F �?TIMEOUT 中断后同样自动关�?Socket�? *          需要重新打开并恢复监�? */
+ * 函数功能：处理 Socket 超时（SOCK_TIMEOUT）事件，更新 Socket 状态机
+ * 入口参数：p_sock - 发生超时事件的 Socket 控制块指针                    net_sock_t *
+ * 出口参数：无
+ * 返回值：无
+ * 限定条件：net_poll() 检测到 SOCK_TIMEOUT 中断后调用；netTask 上下文
+ * 函数说明：1. TCP Client（CONNECTING）：连接超时，回到 CREATED 状态
+ *           2. 已建立连接：回到 CLOSED（独立模式）或 TCP_ACCEPT（多连接模式）
+ *           3. 监听态：异常超时，记录错误日志
+ *           4. 触发 NET_EVENT_TIMEOUT 回调
+ */
 static void handle_timeout_event(net_sock_t *p_sock) {
     if (p_sock->state == NET_SOCK_STATE_CONNECTING) {
         /* TCP Client 连接超时 */
@@ -1558,21 +1676,36 @@ static void handle_timeout_event(net_sock_t *p_sock) {
 }
 
 /*
- * 函数功能：触发事件回�? */
+ * 函数功能：触发 Socket 事件回调（若已注册）
+ * 入口参数：p_sock - 触发事件的 Socket 控制块指针                      net_sock_t *
+ *           event  - 事件类型                                          net_event_t
+ * 出口参数：无
+ * 返回值：无
+ * 限定条件：net_init() 已调用
+ * 函数说明：1. 仅当 p_sock->event_cb 非空时调用回调
+ *           2. 回调参数为 ch395_sock、event、event_arg
+ */
 static void fire_event(net_sock_t *p_sock, net_event_t event) {
-    if (p_sock->event_cb != NULL) {
+    if (NULL != p_sock->event_cb) {
         p_sock->event_cb(p_sock->ch395_sock, event, p_sock->event_arg);
     }
 }
 
 /*
- * 函数功能：解�?IP 地址字符串为数组
+ * 函数功能：将点分十进制 IP 地址字符串解析为 4 字节数组
+ * 入口参数：str    - 点分十进制 IP 字符串（如 "192.168.1.100"）       const char *
+ *           ip_arr - 输出：4 字节 IP 数组（网络序，低字节在前）        uint8_t *
+ * 出口参数：ip_arr - 填充解析后的 IP 地址
+ * 返回值：无
+ * 限定条件：str 与 ip_arr 均非空
+ * 函数说明：1. 逐段解析十进制数写入 ip_arr[0..3]
+ *           2. 参数非法（NULL）时直接返回，不做解析
  */
 static void parse_ip_string(const char *str, uint8_t *ip_arr) {
     uint32_t val;
     int i;
 
-    if (str == NULL || ip_arr == NULL) {
+    if (NULL == str ||NULL == ip_arr) {
         return;
     }
 
@@ -1590,7 +1723,14 @@ static void parse_ip_string(const char *str, uint8_t *ip_arr) {
 }
 
 /*
- * 函数功能：获�?Socket 控制块指针（内部使用�? */
+ * 函数功能：根据描述符获取 Socket 控制块指针（内部使用）
+ * 入口参数：sockfd - Socket 描述符                                     int    0 - NET_MAX_SOCKETS-1
+ * 出口参数：无
+ * 返回值：Socket 控制块指针；描述符越界或未分配时返回 NULL             net_sock_t *
+ * 限定条件：无
+ * 函数说明：1. 描述符越界（<0 或 >= NET_MAX_SOCKETS）返回 NULL
+ *           2. 未使用（in_use == 0）的 Socket 返回 NULL
+ */
 net_sock_t *net_get_sock(int sockfd) {
     if (sockfd < 0 || sockfd >= NET_MAX_SOCKETS) {
         return NULL;
@@ -1624,7 +1764,7 @@ int net_getsockname(int sockfd, struct net_sockaddr *addr, int *addrlen) {
         return -1;
     }
 
-    if (addr == NULL || addrlen == NULL || *addrlen < (int)sizeof(struct net_sockaddr_in)) {
+    if (NULL == addr ||NULL == addrlen || *addrlen < (int)sizeof(struct net_sockaddr_in)) {
         s_net_errno = NET_ERR_INVAL;
         return -1;
     }
diff --git a/MDK-ARM/build_log.txt b/MDK-ARM/build_log.txt
index e1d847c..5cd71f6 100644
--- a/MDK-ARM/build_log.txt
+++ b/MDK-ARM/build_log.txt
@@ -5,67 +5,67 @@ compiling crc.c...
 compiling ringbuf.c...
 compiling stm32f4xx_hal_flash_ramfunc.c...
 compiling stm32f4xx_hal_gpio.c...
-compiling i2c.c...
-compiling stm32f4xx_hal_timebase_tim.c...
-compiling stm32f4xx_it.c...
-compiling app_main.c...
-compiling usart.c...
-compiling spi.c...
-compiling sys_clock.c...
-compiling stm32f4xx_hal_msp.c...
 compiling stm32f4xx_hal_flash_ex.c...
-compiling dma.c...
+compiling i2c.c...
+compiling usart.c...
 compiling gpio.c...
-compiling stm32f4xx_hal_rcc_ex.c...
-compiling stm32f4xx_hal_dma_ex.c...
-compiling adc_task.c...
-compiling rs485_task.c...
-compiling stm32f4xx_hal_rcc.c...
-compiling freertos.c...
-compiling stm32f4xx_hal_dma.c...
-compiling stm32f4xx_hal_tim_ex.c...
+compiling app_main.c...
+compiling stm32f4xx_hal_timebase_tim.c...
+compiling spi.c...
+compiling stm32f4xx_it.c...
+compiling stm32f4xx_hal_msp.c...
+compiling dma.c...
 compiling stm32f4xx_hal_flash.c...
+compiling sys_clock.c...
+compiling stm32f4xx_hal_dma_ex.c...
+compiling stm32f4xx_hal_rcc_ex.c...
+compiling stm32f4xx_hal_dma.c...
+compiling rs485_task.c...
+compiling adc_task.c...
+compiling stm32f4xx_hal_tim_ex.c...
 compiling net_task.c...
+compiling stm32f4xx_hal_rcc.c...
 compiling main.c...
+compiling freertos.c...
 compiling lftpd_string.c...
 compiling stm32f4xx_hal_tim.c...
 compiling croutine.c...
-compiling list.c...
 compiling event_groups.c...
+compiling list.c...
+compiling stm32f4xx_hal_pwr.c...
 compiling stream_buffer.c...
 compiling queue.c...
-compiling timers.c...
 compiling tasks.c...
-compiling heap_4.c...
-compiling port.c...
-compiling journal.c...
-compiling map.c...
-compiling ff.c...
-compiling stm32f4xx_hal.c...
-compiling system_stm32f4xx.c...
 compiling stm32f4xx_hal_pwr_ex.c...
-compiling stm32f4xx_hal_exti.c...
-compiling stm32f4xx_hal_i2c_ex.c...
-compiling stm32f4xx_hal_pwr.c...
+compiling timers.c...
+compiling heap_4.c...
+compiling journal.c...
+compiling port.c...
+compiling map.c...
 compiling stm32f4xx_hal_cortex.c...
-compiling cmsis_os2.c...
-compiling ch395f.c...
-compiling tpafe5160.c...
+compiling ff.c...
+compiling stm32f4xx_hal_i2c_ex.c...
+compiling stm32f4xx_hal.c...
+compiling stm32f4xx_hal_exti.c...
+compiling system_stm32f4xx.c...
 compiling rs485.c...
 compiling stm32f4xx_hal_spi.c...
+compiling sd2506.c...
+compiling ch395f.c...
+compiling nand_ftl.c...
 compiling lftpd_io.c...
 compiling gd5f2gq5ue.c...
-compiling sd2506.c...
+compiling tpafe5160.c...
 compiling lftpd_inet.c...
-compiling nand_ftl.c...
-compiling stm32f4xx_hal_uart.c...
 compiling net_select.c...
+compiling stm32f4xx_hal_uart.c...
 compiling lftpd.c...
-compiling net_socket.c...
+compiling cmsis_os2.c...
 compiling stm32f4xx_hal_i2c.c...
+compiling net_socket.c...
 compiling ch395f_test_task.c...
 linking...
-Program Size: Code=52688 RO-data=1804 RW-data=232 ZI-data=69768  
+Program Size: Code=49060 RO-data=1760 RW-data=228 ZI-data=69764  
 FromELF: creating hex file...
 ".\STM32F407-Demo\STM32F407-Demo.axf" - 0 Error(s), 0 Warning(s).
-Build Time Elapsed:  00:00:19
+Build Time Elapsed:  00:00:14
diff --git a/docs/CH395F_Test_Guide.md b/docs/CH395F_Test_Guide.md
index eb965ea..40d2ffe 100644
--- a/docs/CH395F_Test_Guide.md
+++ b/docs/CH395F_Test_Guide.md
@@ -8,10 +8,10 @@
 
 | 原则 | 描述 | 验证用例 |
 |------|------|----------|
-| DP-01 | 单连接 socket：Socket 0 唯一，复用监听和数据通道；CONNECT 后切换数据通道；DISCONNECT/TIMEOUT 后重新 OPEN → LISTEN | TC-NET-201~406 |
+| DP-01 | 单连接 socket：Socket 0 唯一，复用监听和数据通道；CONNECT 后切换数据通道；DISCONNECT/TIMEOUT 后重新 OPEN → LISTEN | TC-NET-201~203, 601~609, 906 |
 | DP-02 | 中断集中处理：所有 CH395F 中断在 `net_poll()` 中通过 `GET_GLOB_INT_STATUS` 统一读取并清除，ISR 及其他位置不处理 | TC-NET-101 |
 | DP-03 | 线程安全：所有 CH395F 操作通过 `netMsgQueue` 在 netTask 串行处理 | TC-NET-301~302 |
-| DP-04 | DMA 边界安全：`CH395F_SPI_DMA_BUF_SIZE=4100`，单次事务最大载荷 `4096B`，超限自动分块 | TC-NET-801~805 |
+| DP-04 | DMA 边界安全：`CH395F_SPI_DMA_BUF_SIZE=4100`，单次事务最大载荷 `4096B`，超限自动分块 | TC-NET-901~905 |
 
 ### CH395F 缓冲架构（关键参数）
 
@@ -71,24 +71,6 @@ MCU: STM32F407ZGTx @ 168MHz, Keil MDK-ARM v5 (ARMCC)
 
 **执行顺序严格递增**：先烧录硬件层固件完成阶段 1→2→3→4→5（全部通过），再切换为 NET 层固件执行阶段 6→…→10。硬件层测试期间 netTask 轮询不存在，从根上排除中断偷取与 SPI 并发问题。
 
-### 阶段编号对照（2026-08 重排）
-
-| 新阶段 | 内容 | 旧阶段 | 层 |
-|--------|------|--------|-----|
-| 阶段 1 | 寄存器/SPI 命令验证 | 阶段 1 | 硬件层 |
-| 阶段 2 | TCP Client 收发/重连 | 阶段 2 | 硬件层 |
-| 阶段 3 | UDP Server 回显 | 阶段 3 | 硬件层 |
-| 阶段 4 | DHCP | 阶段 6 | 硬件层 |
-| 阶段 5 | 大文件传输（硬件层） | 新增（替代原 PHY 测试） | 硬件层 |
-| 阶段 6 | NET 层 TCP（Echo + Client 扩展） | 阶段 4 | NET 层 |
-| 阶段 7 | 大文件传输 | 阶段 5 | NET 层 |
-| 阶段 8 | Select/Poll | 阶段 7 | NET 层 |
-| 阶段 9 | 边界条件 | 阶段 8 | NET 层 |
-| 阶段 10 | KeepAlive | 阶段 10 | NET 层 |
-
-> TC 用例 ID（TC-NET-xxx）保持不变，仅阶段号/TM-PHY 重排；历史记录按上表追溯。
-> 原阶段 2 内嵌的 NET 层部分（TC-NET-204/205/206）已并入**阶段 6**「Client 模式扩展」——硬件层阶段（1~5）不再包含任何 BSD Socket API 用例。
-
 ### 启用测试
 
 编辑 `test/ch395f_test.h`，取消注释对应 `ENABLE_PHASEx_TESTS` 宏（同一模式内 Phase 6/7/8/9 可共存于 testTask 循环）。
@@ -329,11 +311,11 @@ CH395F                               PC (dhcp_server)
 
 ---
 
-### TC-NET-601（硬件层）: DHCP 完整握手
+### TC-NET-401（硬件层）: DHCP 完整握手
 
 | 字段 | 值 |
 |------|-----|
-| **ID** | TC-NET-601 |
+| **ID** | TC-NET-401 |
 | **优先级** | P0 |
 | **类型** | 功能测试（硬件层） |
 | **标题** | DISCOVER → OFFER → REQUEST → ACK 全流程获取 IP |
@@ -354,15 +336,15 @@ CH395F                               PC (dhcp_server)
 
 ---
 
-### TC-NET-602（硬件层）: DHCP 后连通性验证（宣告 + HELLO 回显）
+### TC-NET-402（硬件层）: DHCP 后连通性验证（宣告 + HELLO 回显）
 
 | 字段 | 值 |
 |------|-----|
-| **ID** | TC-NET-602 |
+| **ID** | TC-NET-402 |
 | **优先级** | P1 |
 | **类型** | 功能测试（硬件层） |
 | **标题** | 获取 IP 后广播宣告 + 按 UDP 包头源地址回显 HELLO |
-| **前置条件** | TC-NET-601 通过；同一脚本会话内自动衔接 |
+| **前置条件** | TC-NET-401 通过；同一脚本会话内自动衔接 |
 
 **测试步骤与判定标准**：
 
@@ -388,7 +370,7 @@ CH395F                               PC (dhcp_server)
 | **出口** | 串口 "Phase 5: N/N PASSED (failed=0)" + 吞吐统计 |
 | **注意** | 与 NET 层阶段 7 同主题不同层：本阶段用 `ch395f_*` 裸命令直驱芯片，不经 net_socket/netTask |
 
-> 编号说明：TC-NET-**511/512** 取 5xx"文件传输族"顺延（501/502 已属 NET 层阶段 7）；原阶段 5 的 TC-NET-901/902 因板载拓扑不可测已整体删除（见风险表 #1）。
+> 编号说明：阶段 5 用例 **501/502**（顺序双测向完整性 + 变总量合规）；原 PHY 测试（旧编号 901/902）因板载拓扑不可测已删除（见风险表 #1）。
 
 ### 为什么 4KB 接收缓冲不会丢数据（TCP 流控原理）
 
@@ -451,11 +433,11 @@ MCU (TCP Client, ch395f_* 裸命令)          PC (tcp_bulk --port 8081)
 
 ---
 
-### TC-NET-511（硬件层）: 256KB 顺序双向（纯 TX + 纯 RX）完整性
+### TC-NET-501（硬件层）: 256KB 顺序双向（纯 TX + 纯 RX）完整性
 
 | 字段 | 值 |
 |------|-----|
-| **ID** | TC-NET-511 |
+| **ID** | TC-NET-501 |
 | **优先级** | P0 |
 | **类型** | 功能测试（硬件层） |
 | **标题** | 先连续发送 256KB（PC 只收），再连续接收 256KB（PC 回放），逐字节校验 + 总账一致 |
@@ -475,21 +457,21 @@ MCU (TCP Client, ch395f_* 裸命令)          PC (tcp_bulk --port 8081)
 
 ---
 
-### TC-NET-512（硬件层）: 变总量与跨包分块合规
+### TC-NET-502（硬件层）: 变总量与跨包分块合规
 
 | 字段 | 值 |
 |------|-----|
-| **ID** | TC-NET-512 |
+| **ID** | TC-NET-502 |
 | **优先级** | P1 |
 | **类型** | 合规测试（硬件层） |
 | **标题** | 三档总量（64KB/256KB/1MB）+ 非整除块边界（4093B）回归 |
-| **前置条件** | 同 TC-NET-511；每档修改 `PHASE5_TOTAL_BYTES` / `PHASE5_CHUNK_SIZE` 宏后重编译，且 PC `--bulk` 取 `chunks×PHASE5_CHUNK_SIZE`、`--chunk` 与 `PHASE5_CHUNK_SIZE` 一致 |
+| **前置条件** | 同 TC-NET-501；每档修改 `PHASE5_TOTAL_BYTES` / `PHASE5_CHUNK_SIZE` 宏后重编译，且 PC `--bulk` 取 `chunks×PHASE5_CHUNK_SIZE`、`--chunk` 与 `PHASE5_CHUNK_SIZE` 一致 |
 
 **测试步骤与判定标准**：
 
 | 步 | 操作 | 成功标准 | 失败标准 |
 |----|------|----------|----------|
-| 1 | `PHASE5_TOTAL_BYTES=64*1024` 重编译，PC `--bulk 65536` 跑一遍 | 全绿 | 同 TC-511 |
+| 1 | `PHASE5_TOTAL_BYTES=64*1024` 重编译，PC `--bulk 65536` 跑一遍 | 全绿 | 同 TC-501 |
 | 2 | `PHASE5_TOTAL_BYTES=1024*1024` 重编译，PC `--bulk 1048576` 跑一遍 | 全绿且吞吐无劣化趋势 | 同上 |
 | 3 | `PHASE5_CHUNK_SIZE=4093`（非 4 对齐，制造跨包边界），PC `--chunk 4093 --bulk 261952` 跑一遍 | 全绿（4093 档实际回传 `64×4093=261952B`，不足一块的尾数不上送，完成判定按实际上送字节） | 尾块校验失败 |
 
@@ -507,7 +489,7 @@ MCU (TCP Client, ch395f_* 裸命令)          PC (tcp_bulk --port 8081)
 
 | # | 事项 | 影响 | 状态 |
 |---|------|------|------|
-| 1 | 原 PHY 测试（TC-NET-901/902）删除：CH395F 直连板载 RTL8305NBI 交换机，PHY 恒 link up，拔插外线上联无法在芯片 PHY 产生变化事件（2026-08-24 实测 0/1 FAIL 后决议） | 编号 901/902 弃用 | ✅ 已移除 |
+| 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 时钟/驱动优化以该基线为参照 | ✅ 已记录 |
 
@@ -523,14 +505,14 @@ MCU (TCP Client, ch395f_* 裸命令)          PC (tcp_bulk --port 8081)
 | **出口** | 用户终止 |
 
 两部分组成：
-- **Server 模式（TC-NET-401~406）**：MCU 监听 8080，PC 主动连接，验证回显通路 —— 已实现 🟡
-- **Client 模式扩展（TC-NET-204/205/206）**：MCU 经 BSD Socket API 主动连接 PC Server，补全 `net_connect()` 路径 —— 待实现 🟠（ID 沿用历史编号，原属阶段 2 的 NET 层部分）
+- **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 重排）
 
-### TC-NET-401: Socket 0 单连接生命周期
+### TC-NET-601: Socket 0 单连接生命周期
 
 | 字段 | 值 |
 |------|-----|
-| **ID** | TC-NET-401 |
+| **ID** | TC-NET-601 |
 | **优先级** | P0 |
 | **类型** | 功能测试 |
 | **标题** | Socket 0: OPEN → TCP_LISTEN → ESTABLISHED（单连接） |
@@ -539,33 +521,33 @@ MCU (TCP Client, ch395f_* 裸命令)          PC (tcp_bulk --port 8081)
 | **通过标准** | 仅 s0 状态变化；串口 `s0:int=0x08` → ESTABLISHED |
 | **覆盖原则** | DP-01 |
 
-### TC-NET-402: 64 字节小包回显
+### TC-NET-602: 64 字节小包回显
 
 | 字段 | 值 |
 |------|-----|
-| **ID** | TC-NET-402 |
+| **ID** | TC-NET-602 |
 | **优先级** | P0 |
 | **类型** | 功能测试 |
 | **标题** | 10 轮 64B TCP 回显 |
 | **测试步骤** | PC 发 10×64B，MCU 回显 |
 | **通过标准** | 10/10 匹配 |
 
-### TC-NET-403: 1460 字节 MSS 回显
+### TC-NET-603: 1460 字节 MSS 回显
 
 | 字段 | 值 |
 |------|-----|
-| **ID** | TC-NET-403 |
+| **ID** | TC-NET-603 |
 | **优先级** | P0 |
 | **类型** | 边界测试 |
 | **标题** | MSS 大小（1460B）TCP 回显 |
 | **测试步骤** | PC 发 1460B，MCU 回显 |
 | **通过标准** | 1460B 完全匹配，无截断 |
 
-### TC-NET-404: 4096 字节缓冲满回显
+### TC-NET-604: 4096 字节缓冲满回显
 
 | 字段 | 值 |
 |------|-----|
-| **ID** | TC-NET-404 |
+| **ID** | TC-NET-604 |
 | **优先级** | P0 |
 | **类型** | 边界测试 |
 | **标题** | 填满 Socket 0 接收缓冲（4096B）回显 |
@@ -574,11 +556,11 @@ MCU (TCP Client, ch395f_* 裸命令)          PC (tcp_bulk --port 8081)
 | **通过标准** | 4096B 完全匹配 |
 | **覆盖原则** | DP-04 |
 
-### TC-NET-405: 断开重连
+### TC-NET-605: 断开重连
 
 | 字段 | 值 |
 |------|-----|
-| **ID** | TC-NET-405 |
+| **ID** | TC-NET-605 |
 | **优先级** | P0 |
 | **类型** | 恢复测试 |
 | **标题** | PC 断开后 Socket 0 自动重新监听并接受新连接 |
@@ -586,11 +568,11 @@ MCU (TCP Client, ch395f_* 裸命令)          PC (tcp_bulk --port 8081)
 | **通过标准** | 重连成功，回显正常 |
 | **覆盖原则** | DP-01 |
 
-### TC-NET-406: 超时恢复
+### TC-NET-606: 超时恢复
 
 | 字段 | 值 |
 |------|-----|
-| **ID** | TC-NET-406 |
+| **ID** | TC-NET-606 |
 | **优先级** | P1 |
 | **类型** | 恢复测试 |
 | **标题** | KeepAlive 超时后 Socket 0 自动重新监听 |
@@ -600,16 +582,16 @@ MCU (TCP Client, ch395f_* 裸命令)          PC (tcp_bulk --port 8081)
 
 ---
 
-### Client 模式扩展：主动连接 PC（TC-NET-204 / 205 / 206，🟠 待实现）
+### Client 模式扩展：主动连接 PC（TC-NET-607 / 608 / 609，🟠 待实现）
 
 > 与硬件层阶段 2 的 TC-NET-201/202/203 一一对应（芯片行为 → API 封装），验证 `net_socket` / `net_connect` / `net_send` / `net_recv` / `net_close` 对 TCP Client 主路径及异常路径的正确封装。
-> 用例 ID 沿用历史编号（原阶段 2 的 NET 层部分），保证测试记录可追溯；实现于 `ENABLE_PHASE6_TESTS` 固件中。
+> 本组用例原编号 204/205/206（原阶段 2 的 NET 层部分），2026-08 重排后为 607/608/609；实现于 `ENABLE_PHASE6_TESTS` 固件中。
 
-#### TC-NET-204（NET 层）: TCP Client 连接与数据交换
+#### TC-NET-607（NET 层）: TCP Client 连接与数据交换
 
 | 字段 | 值 |
 |------|-----|
-| **ID** | TC-NET-204 |
+| **ID** | TC-NET-607 |
 | **优先级** | P0 |
 | **类型** | 功能测试（NET 层） |
 | **标题** | net_socket TCP Client → PC TCP Server，64 字节收发 |
@@ -630,15 +612,15 @@ MCU (TCP Client, ch395f_* 裸命令)          PC (tcp_bulk --port 8081)
 
 **覆盖原则**：DP-01（net_socket→net_connect→net_send→net_recv→net_close 主路径，NET 层）
 
-#### TC-NET-205（NET 层）: TCP Client 关闭重连 ×3 轮
+#### TC-NET-608（NET 层）: TCP Client 关闭重连 ×3 轮
 
 | 字段 | 值 |
 |------|-----|
-| **ID** | TC-NET-205 |
+| **ID** | TC-NET-608 |
 | **优先级** | P0 |
 | **类型** | 功能测试 / 恢复测试（NET 层） |
 | **标题** | close→重连循环 3 轮，每轮含数据交换 |
-| **前置条件** | 同 TC-NET-204 |
+| **前置条件** | 同 TC-NET-607 |
 
 **测试步骤与判定标准**（每轮 i = 0,1,2）：
 
@@ -653,15 +635,15 @@ MCU (TCP Client, ch395f_* 裸命令)          PC (tcp_bulk --port 8081)
 
 **覆盖原则**：DP-01（net 层 open→connect→close→re-open→reconnect）
 
-#### TC-NET-206（NET 层）: TCP Client 连接超时
+#### TC-NET-609（NET 层）: TCP Client 连接超时
 
 | 字段 | 值 |
 |------|-----|
-| **ID** | TC-NET-206 |
+| **ID** | TC-NET-609 |
 | **优先级** | P1 |
 | **类型** | 负向测试（NET 层） |
 | **标题** | 目标端口无服务时 net_connect 超时 |
-| **前置条件** | 1. PC **未**运行 TCP Server（`192.168.1.2:8081` 无监听）<br>2. TC-NET-204 通过 |
+| **前置条件** | 1. PC **未**运行 TCP Server（`192.168.1.2:8081` 无监听）<br>2. TC-NET-607 通过 |
 
 **测试步骤与判定标准**：
 
@@ -686,11 +668,11 @@ MCU (TCP Client, ch395f_* 裸命令)          PC (tcp_bulk --port 8081)
 | **入口** | `ENABLE_PHASE7_TESTS` |
 | **配置** | `PHASE7_FILE_SIZE`（默认 20480）|
 
-### TC-NET-501: 20KB 分块传输
+### TC-NET-701: 20KB 分块传输
 
 | 字段 | 值 |
 |------|-----|
-| **ID** | TC-NET-501 |
+| **ID** | TC-NET-701 |
 | **优先级** | P0 |
 | **类型** | 功能测试 |
 | **标题** | 20480 字节 TCP 分块收发（>Socket 0 硬件缓冲 4KB） |
@@ -699,15 +681,15 @@ MCU (TCP Client, ch395f_* 裸命令)          PC (tcp_bulk --port 8081)
 | **通过标准** | 20KB 完全匹配，每字节验证通过 |
 | **覆盖原则** | DP-04 |
 
-### TC-NET-502: 64KB 传输（recv_len 上限）
+### TC-NET-702: 64KB 传输（recv_len 上限）
 
 | 字段 | 值 |
 |------|-----|
-| **ID** | TC-NET-502 |
+| **ID** | TC-NET-702 |
 | **优先级** | P1 |
 | **类型** | 边界测试 |
 | **标题** | 65535 字节传输（`recv_len` uint16 上限） |
-| **前置条件** | TC-NET-501 通过 |
+| **前置条件** | TC-NET-701 通过 |
 | **测试步骤** | 同 501，文件大小 65535 |
 | **通过标准** | 65535B 完全匹配 |
 | **覆盖原则** | DP-04 |
@@ -734,11 +716,11 @@ IDLE → (连接建立) → SENDING(分块发) → RECVING(分块收+验证) →
 | **耗时** | 持续运行 |
 | **入口** | `ENABLE_PHASE8_TESTS` |
 
-### TC-NET-701: net_select() 单 socket 就绪检测
+### TC-NET-801: net_select() 单 socket 就绪检测
 
 | 字段 | 值 |
 |------|-----|
-| **ID** | TC-NET-701 |
+| **ID** | TC-NET-801 |
 | **优先级** | P0 |
 | **类型** | 功能测试 |
 | **标题** | `net_select()` 在 Socket 0 数据到达时正确返回 |
@@ -747,11 +729,11 @@ IDLE → (连接建立) → SENDING(分块发) → RECVING(分块收+验证) →
 | **通过标准** | 回显成功 |
 | **覆盖原则** | DP-02（select 内部调 net_poll） |
 
-### TC-NET-702: net_select() 超时
+### TC-NET-802: net_select() 超时
 
 | 字段 | 值 |
 |------|-----|
-| **ID** | TC-NET-702 |
+| **ID** | TC-NET-802 |
 | **优先级** | P1 |
 | **类型** | 负向测试 |
 | **标题** | 100ms 超时内无数据则返回 0 |
@@ -769,11 +751,11 @@ IDLE → (连接建立) → SENDING(分块发) → RECVING(分块收+验证) →
 | **耗时** | 按需 |
 | **入口** | `ENABLE_PHASE9_TESTS` |
 
-### TC-NET-801: DMA 边界 −1（4095 字节）
+### TC-NET-901: DMA 边界 −1（4095 字节）
 
 | 字段 | 值 |
 |------|-----|
-| **ID** | TC-NET-801 |
+| **ID** | TC-NET-901 |
 | **优先级** | P0 |
 | **类型** | 边界测试 |
 | **标题** | 发送 4095 字节（SPI 最大载荷 −1，单次 DMA 可容纳） |
@@ -782,11 +764,11 @@ IDLE → (连接建立) → SENDING(分块发) → RECVING(分块收+验证) →
 | **通过标准** | 4095B 完全匹配 |
 | **覆盖原则** | DP-04 |
 
-### TC-NET-802: DMA 边界（4096 字节）
+### TC-NET-902: DMA 边界（4096 字节）
 
 | 字段 | 值 |
 |------|-----|
-| **ID** | TC-NET-802 |
+| **ID** | TC-NET-902 |
 | **优先级** | P0 |
 | **类型** | 边界测试 |
 | **标题** | 发送 4096 字节（等于 SPI 最大载荷，填满单次 DMA） |
@@ -794,11 +776,11 @@ IDLE → (连接建立) → SENDING(分块发) → RECVING(分块收+验证) →
 | **通过标准** | 4096B 完全匹配 |
 | **覆盖原则** | DP-04 |
 
-### TC-NET-803: DMA 边界 +1（4097 字节）
+### TC-NET-903: DMA 边界 +1（4097 字节）
 
 | 字段 | 值 |
 |------|-----|
-| **ID** | TC-NET-803 |
+| **ID** | TC-NET-903 |
 | **优先级** | P0 |
 | **类型** | 边界测试 |
 | **标题** | 发送 4097 字节（超过 SPI 最大载荷，自动拆两次 DMA：4096+1） |
@@ -806,33 +788,33 @@ IDLE → (连接建立) → SENDING(分块发) → RECVING(分块收+验证) →
 | **通过标准** | 4097B 完全匹配，两次 DMA 无缝衔接 |
 | **覆盖原则** | DP-04 |
 
-### TC-NET-804: 零长度收发
+### TC-NET-904: 零长度收发
 
 | 字段 | 值 |
 |------|-----|
-| **ID** | TC-NET-804 |
+| **ID** | TC-NET-904 |
 | **优先级** | P1 |
 | **类型** | 负向测试 |
 | **标题** | `net_send_sock(sk, buf, 0)` 返回 −1 |
 | **测试步骤** | `net_send_sock(sk, s_phase9_tx, 0)` |
 | **通过标准** | 返回 < 0，无崩溃 |
 
-### TC-NET-805: 连续快速发送 20 小包
+### TC-NET-905: 连续快速发送 20 小包
 
 | 字段 | 值 |
 |------|-----|
-| **ID** | TC-NET-805 |
+| **ID** | TC-NET-905 |
 | **优先级** | P1 |
 | **类型** | 压力测试 |
 | **标题** | 20 × 100 字节连续快速发送（验证 SENDBUF_FREE 等待机制） |
 | **测试步骤** | 循环 20 次：`net_send_sock(sk, buf, 100)`，间隔 1ms |
 | **通过标准** | 20/20 成功，回显 2000B 完全匹配 |
 
-### TC-NET-806: 快速连接-断开 ×20 轮
+### TC-NET-906: 快速连接-断开 ×20 轮
 
 | 字段 | 值 |
 |------|-----|
-| **ID** | TC-NET-806 |
+| **ID** | TC-NET-906 |
 | **优先级** | P1 |
 | **类型** | 稳定性测试 |
 | **标题** | 20 次快速连接-断开循环 |
@@ -868,7 +850,7 @@ IDLE → (连接建立) → SENDING(分块发) → RECVING(分块收+验证) →
 
 | 命令 | 模式 | 说明 |
 |------|------|------|
-| `tcp_server --port 8081` | PC 作 TCP 回显服务器（多连接循环） | 测试 TCP Client（阶段 2 硬件层；阶段 6 Client 扩展 204/205/206） |
+| `tcp_server --port 8081` | PC 作 TCP 回显服务器（多连接循环） | 测试 TCP Client（阶段 2 硬件层；阶段 6 Client 扩展 607/608/609） |
 | `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） |
@@ -920,29 +902,29 @@ IDLE → (连接建立) → SENDING(分块发) → RECVING(分块收+验证) →
 | TM-PHY-02 | TC-NET-203 | P1 | 负向测试 | ✅ |
 | TM-PHY-03 | TC-NET-301 | P0 | 功能测试 | ✅ |
 | TM-PHY-03 | TC-NET-302 | P1 | 合规测试 | ✅ |
-| TM-PHY-04 | TC-NET-601 | P0 | 功能测试 | ✅ |
-| TM-PHY-04 | TC-NET-602 | P1 | 功能测试 | ✅ |
-| TM-PHY-05 | TC-NET-511 | P0 | 功能测试 | 🟡 |
-| TM-PHY-05 | TC-NET-512 | P1 | 合规测试 | ✅ |
-| TM-PHY-06 | TC-NET-204 | P0 | 功能测试 | 🟠 |
-| TM-PHY-06 | TC-NET-205 | P0 | 恢复测试 | 🟠 |
-| TM-PHY-06 | TC-NET-206 | P1 | 负向测试 | 🟠 |
-| TM-PHY-06 | TC-NET-401 | P0 | 功能测试 | 🟡 |
-| TM-PHY-06 | TC-NET-402 | P0 | 功能测试 | 🟡 |
-| TM-PHY-06 | TC-NET-403 | P0 | 边界测试 | 🟡 |
-| TM-PHY-06 | TC-NET-404 | P0 | 边界测试 | 🟡 |
-| TM-PHY-06 | TC-NET-405 | P0 | 恢复测试 | 🟡 |
-| TM-PHY-06 | TC-NET-406 | P1 | 恢复测试 | 🟡 |
-| TM-PHY-07 | TC-NET-501 | P0 | 功能测试 | 🟡 |
-| TM-PHY-07 | TC-NET-502 | P1 | 边界测试 | 🟡 |
-| TM-PHY-08 | TC-NET-701 | P0 | 功能测试 | 🟡 |
-| TM-PHY-08 | TC-NET-702 | P1 | 负向测试 | 🟡 |
-| TM-PHY-09 | TC-NET-801 | P0 | 边界测试 | 🟡 |
-| TM-PHY-09 | TC-NET-802 | P0 | 边界测试 | 🟡 |
-| TM-PHY-09 | TC-NET-803 | P0 | 边界测试 | 🟡 |
-| TM-PHY-09 | TC-NET-804 | P1 | 负向测试 | 🟡 |
-| TM-PHY-09 | TC-NET-805 | P1 | 压力测试 | 🟡 |
-| TM-PHY-09 | TC-NET-806 | P1 | 稳定性测试 | 🟡 |
+| TM-PHY-04 | TC-NET-401 | P0 | 功能测试 | ✅ |
+| TM-PHY-04 | TC-NET-402 | P1 | 功能测试 | ✅ |
+| TM-PHY-05 | TC-NET-501 | P0 | 功能测试 | ✅ |
+| TM-PHY-05 | TC-NET-502 | P1 | 合规测试 | ✅ |
+| TM-PHY-06 | TC-NET-601 | P0 | 功能测试 | 🟡 |
+| TM-PHY-06 | TC-NET-602 | P0 | 功能测试 | 🟡 |
+| TM-PHY-06 | TC-NET-603 | P0 | 边界测试 | 🟡 |
+| TM-PHY-06 | TC-NET-604 | P0 | 边界测试 | 🟡 |
+| TM-PHY-06 | TC-NET-605 | P0 | 恢复测试 | 🟡 |
+| TM-PHY-06 | TC-NET-606 | P1 | 恢复测试 | 🟡 |
+| TM-PHY-06 | TC-NET-607 | P0 | 功能测试 | 🟠 |
+| TM-PHY-06 | TC-NET-608 | P0 | 恢复测试 | 🟠 |
+| TM-PHY-06 | TC-NET-609 | P1 | 负向测试 | 🟠 |
+| TM-PHY-07 | TC-NET-701 | P0 | 功能测试 | 🟡 |
+| TM-PHY-07 | TC-NET-702 | P1 | 边界测试 | 🟡 |
+| TM-PHY-08 | TC-NET-801 | P0 | 功能测试 | 🟡 |
+| TM-PHY-08 | TC-NET-802 | P1 | 负向测试 | 🟡 |
+| TM-PHY-09 | TC-NET-901 | P0 | 边界测试 | 🟡 |
+| TM-PHY-09 | TC-NET-902 | P0 | 边界测试 | 🟡 |
+| TM-PHY-09 | TC-NET-903 | P0 | 边界测试 | 🟡 |
+| TM-PHY-09 | TC-NET-904 | P1 | 负向测试 | 🟡 |
+| TM-PHY-09 | TC-NET-905 | P1 | 压力测试 | 🟡 |
+| TM-PHY-09 | TC-NET-906 | P1 | 稳定性测试 | 🟡 |
 | TM-PHY-10 | TC-NET-1001 | P1 | 功能测试 | 🟡 |
 
 ✅ = 已实现并验证 | 🟡 = 已实现待验证 | 🟠 = 待实现
@@ -951,10 +933,10 @@ IDLE → (连接建立) → SENDING(分块发) → RECVING(分块收+验证) →
 
 | 原则 | 覆盖用例 |
 |------|----------|
-| DP-01：单 socket 生命周期 | TC-NET-202, 203, 401, 405, 406, 806, 902 |
-| DP-02：中断即读即清 | TC-NET-101, 102, 511, 512, 701 |
-| DP-03：消息队列线程安全 | TC-NET-301, 302, 601 |
-| DP-04：DMA 边界安全 | TC-NET-403, 404, 501, 502, 511, 512, 801, 802, 803, 804, 805 |
+| DP-01：单 socket 生命周期 | TC-NET-202, 203, 601, 605, 606, 906 |
+| DP-02：中断即读即清 | TC-NET-101, 102, 501, 502, 801 |
+| DP-03：消息队列线程安全 | TC-NET-301, 302, 401 |
+| DP-04：DMA 边界安全 | TC-NET-501, 502, 603, 604, 701, 702, 901, 902, 903, 904, 905 |
 
 ## 附录 C：CH395F 边界条件速查
 
diff --git a/test/ch395f_test_task.c b/test/ch395f_test_task.c
index 1836b1d..3c9d04b 100644
--- a/test/ch395f_test_task.c
+++ b/test/ch395f_test_task.c
@@ -1076,7 +1076,7 @@ phase4_end:
 
 #ifdef ENABLE_PHASE5_TESTS
 
-/* 回传参数（TC-NET-512 合规测试时按档位修改重编译） */
+/* 回传参数（TC-NET-502 合规测试时按档位修改重编译） */
 #ifndef PHASE5_REMOTE_IP
 #define PHASE5_REMOTE_IP        "192.168.1.2"
 #endif
@@ -1517,11 +1517,11 @@ static void phase8_run(int sockfd) {
  * Phase 9 — 边界条件测试
  *
  * 测试目的：验证以下 DMA 和协议栈边界情况：
- *          1. TC-NET-801: 4095B（SPI 最大载荷 -1，单次 DMA 容纳）
- *          2. TC-NET-802: 4096B（= SPI 最大载荷，填满单次 DMA）
- *          3. TC-NET-803: 4097B（超过 SPI 最大载荷，拆 2 次 DMA）
- *          4. TC-NET-804: 零长度发送（返回 -1）
- *          5. TC-NET-805: 20 × 100B 连续快速发送
+ *          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 推进一个
  * 步骤（发送→等待→接收→验证→下一阶段）。发送数据为递增模式字节