diff --git a/App/task/net_task.c b/App/task/net_task.c
index 35b2f2e..f5208bf 100644
--- 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();
diff --git a/Drivers/BSP/CH395F/ch395f.c b/Drivers/BSP/CH395F/ch395f.c
index f753824..99633b7 100644
--- 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
- * 返回值：接收数据长度 uint16_t
+ * 入口参数：sock - Socket索引 uint8_t 0 - 7
+ * 返回值：接收数据长度 uint16_t，实际上 ch395F 接收缓冲区最大也就 8192
* 限定条件：Socket必须已打开
*/
uint16_t ch395f_get_recv_len(uint8_t sock) {
diff --git a/Drivers/BSP/CH395F/ch395f.h b/Drivers/BSP/CH395F/ch395f.h
index 36e71d0..c0526db 100644
--- 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)
/* 其他命令 */
diff --git a/Drivers/BSP/NET/net_select.c b/Drivers/BSP/NET/net_select.c
index 24b87ee..b0e21d6 100644
--- a/Drivers/BSP/NET/net_select.c
+++ b/Drivers/BSP/NET/net_select.c
@@ -41,13 +41,16 @@ 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 上下文中调用
- * 函数说明：1. 轮询所有 Socket，检查读/写/异常事件是否就绪
- * 2. 阻塞等待直到有事件就绪或超时
- * 3. 通过 osDelay(1) 让出 CPU，平衡实时性与 CPU 利用率
+ * 限定条件：net_init() + MX_FREERTOS_Init() 已执行；可在任意任务上下文调用
+ * 函数说明：1. 轮询 Socket 控制块（RAM）中的读/写/异常状态，判断事件是否就绪
+ * 2. 不在此直接访问 CH395F SPI——所有 ch395f 事务统一由 netTask 的 net_poll()
+ * 每 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) {
+ net_fd_set *exceptfds, net_timeval *timeout) {
uint32_t start_tick;
uint32_t timeout_ms = 0;
net_fd_set result_read = {0};
@@ -70,9 +73,7 @@ int net_select(int nfds, net_fd_set *readfds, net_fd_set *writefds,
start_tick = HAL_GetTick();
while (1) {
- /* 轮询所有 Socket */
- net_poll();
-
+ /* 仅读取 netTask 的 net_poll() 已刷新的控制块状态（无 CH395F SPI 访问） */
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 上下文中调用
- * 函数说明：1. 轮询所有 Socket，检查读/写/错误/挂起事件是否就绪
- * 2. 阻塞等待直到有事件就绪或超时
- * 3. 通过 osDelay(1) 让出 CPU，平衡实时性与 CPU 利用率
+ * 限定条件：net_init() + MX_FREERTOS_Init() 已执行；可在任意任务上下文调用
+ * 函数说明：1. 轮询 Socket 控制块（RAM）中的读/写/错误/挂起状态，判断事件是否就绪
+ * 2. 不在此直接访问 CH395F SPI——状态由 netTask 的 net_poll() 每 10ms 刷新
+ * 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) {
- /* 轮询 */
- net_poll();
-
+ /* 仅读取 netTask 的 net_poll() 已刷新的控制块状态（无 CH395F SPI 访问） */
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,12 +259,10 @@ static int check_socket_readable(int sockfd) {
return 1;
}
- /* 已建立连接的 Socket 有数据可读 */
- if (NET_SOCK_STATE_ESTABLISHED == p_sock->state) {
- recv_len = ch395f_get_recv_len(sockfd);
- if (0 < recv_len) {
- return 1;
- }
+ /* 已建立连接或 UDP 等有数据可读：readable 由 net_poll 在 RECV_OK 时置位、
+ * net_recv_locked 读空后清零。避免应用任务直接访问 CH395F SPI（见 Trap 16） */
+ if (p_sock->readable) {
+ return 1;
}
return 0;
diff --git a/Drivers/BSP/NET/net_socket.c b/Drivers/BSP/NET/net_socket.c
index 4645deb..ca388e7 100644
--- 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 */
- ch395f_set_tcp_mss(1460);
+ /* 设置 TCP MSS
+ * 手册(§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 的中断标志，
- * 对应位为 0 说明该 Socket 无中断，跳过以节省时间 */
- if (!(int_status & (1U << (i + 4)))) {
+ /* 全局中断状态（GET_GLOB_INT_STATUS_ALL 16 位）：Socket n 的中断位即 bit(n+4)。
+ * Socket 0~3 在低位字节 bit4~bit7；Socket 4~7 在高位字节的 bit0~3
+ * （即 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);
- ch395f_set_recv_buf((uint8_t)sockfd, 30, 2);
+ uint8_t blocks_per_socket = (uint8_t)(CH395F_RECV_BLOCKS + CH395F_SEND_BLOCKS);
+ 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 状态。连接建立需等待
- * net_poll() 检测到 CONNECT 事件并将状态更新为 ESTABLISHED
+ * 函数说明：将连接请求放入消息队列，阻塞等待 netTask 处理完毕。实际的 SPI 操作在 netTask
+ * 上下文中执行，避免与 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;
- /* 参数检�?*/
+ /* 参数检查 */
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 为数组格式（低字节在前） */
- p_sock->remote_ip_arr[0] = (uint8_t)(p_sock->remote_ip);
- p_sock->remote_ip_arr[1] = (uint8_t)(p_sock->remote_ip >> 8);
- p_sock->remote_ip_arr[2] = (uint8_t)(p_sock->remote_ip >> 16);
- p_sock->remote_ip_arr[3] = (uint8_t)(p_sock->remote_ip >> 24);
+ /* 转换 IP 为数组格式（大端/网络字节序，与 ch395f set_des_ip 期望一致，
+ * 同 Phase2 phase2_tc201 的 test_parse_ip 结果 [192,168,1,2]） */
+ p_sock->remote_ip_arr[0] = (uint8_t)(p_sock->remote_ip >> 24);
+ p_sock->remote_ip_arr[1] = (uint8_t)(p_sock->remote_ip >> 16);
+ 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_set_des_port(sockfd, p_sock->remote_port);
- status = ch395f_open_socket(sockfd);
+
+ /* 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); /* 打开失败先关闭，再延时后重试 */
+ 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) {
- chunk = NET_DMA_MAX_PAYLOAD;
+ if (chunk > NET_SEND_CHUNK_MAX) {
+ 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 *
- * len - 数据长度 int > 0
- * flags - 标志位，通常为 0 int
+ * buf - 待发送数据缓冲区指针（调用返回前须保持有效，本函数不拷贝数据） const void *
+ * len - 数据长度（字节），> 0 int
+ * flags - 标志位，当前实现忽略（保留 BSD send 接口兼容） int
* 返回值：实际发送字节数 int >= 0 || -1
- * -1 - 发送失败（参数无效、队列满等） int
- * 限定条件：Socket 处于 ESTABLISHED 状态；net_init() + MX_FREERTOS_Init() 已执行；非 netTask 上下文
- * 函数说明：将发送请求放入消息队列，阻塞等待 netTask 处理完毕并返回结果。netTask 内请使用 net_send_sock()
+ * -1 - 发送失败（参数非法 / 消息队列入队失败 / netTask 侧发送错误） int
+ * 限定条件：1. 必须在【非 netTask】上下文中调用（应用/测试任务）；若在 netTask 内调用会自己等自己
+ * （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;
- net_msg_t msg;
+ (void)flags; /* flags 当前未使用，显式 void 以消除未用参数告警 */
+ 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;
- msg.sockfd = sockfd;
- msg.buf = (void *)buf;
- msg.len = len;
- msg.flags = 0;
- msg.caller = xTaskGetCurrentTaskHandle();
- msg.result = -1;
+ /* ---- 3. 组装消息：把本次 send 的全部上下文填入 msg ---- */
+ msg.type = NET_MSG_SEND; /* 消息类型，netTask 据此分派到 net_send_locked */
+ msg.sockfd = sockfd; /* 目标 Socket */
+ msg.buf = (void *)buf; /* 数据缓冲（队列仅拷贝指针，buf 须有效至函数返回） */
+ msg.len = len; /* 待发送字节数 */
+ msg.flags = 0; /* 实际标志位（忽略入参 flags） */
+ 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);
- msg.result = (int)s_notified;
+ xTaskNotifyWait(0, 0, &s_notified, portMAX_DELAY); /* 一直阻塞直到被 netTask 通知 */
+ 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 为数组格�?*/
+ /* 转换 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[1] = (uint8_t)(ip >> 8);
- ip_arr[2] = (uint8_t)(ip >> 16);
- ip_arr[3] = (uint8_t)(ip >> 24);
+ ip_arr[0] = (uint8_t)(ip >> 24);
+ ip_arr[1] = (uint8_t)(ip >> 16);
+ ip_arr[2] = (uint8_t)(ip >> 8);
+ 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,
/* 发送数�?*/
while (sent < len) {
int chunk = len - sent;
- if (chunk > NET_SEND_BUF_SIZE) {
- chunk = NET_SEND_BUF_SIZE;
+ if (chunk > NET_SEND_CHUNK_MAX) {
+ 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;
/* 参数检�?*/
@@ -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);
}
diff --git a/Drivers/BSP/NET/net_types.h b/Drivers/BSP/NET/net_types.h
index f9eb41f..35992b2 100644
--- 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; /* 累计发送字节数 */
diff --git a/MDK-ARM/STM32F407-Demo.uvprojx b/MDK-ARM/STM32F407-Demo.uvprojx
index fa2f90d..7c442ff 100644
--- a/MDK-ARM/STM32F407-Demo.uvprojx
+++ b/MDK-ARM/STM32F407-Demo.uvprojx
@@ -2009,6 +2009,11 @@
1
..\test\ch395f_test_task.c
+
+ net_test_task.c
+ 1
+ ..\test\net_test_task.c
+
diff --git a/MDK-ARM/build_log.txt b/MDK-ARM/build_log.txt
index 1908fe1..01fdea8 100644
--- 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 adc_task.c...
+compiling stm32f4xx_hal_dma.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 cmsis_os2.c...
-compiling stm32f4xx_hal_i2c.c...
+compiling stm32f4xx_hal.c...
compiling tpafe5160.c...
-compiling gd5f2gq5ue.c...
-compiling net_select.c...
-compiling lftpd_inet.c...
+compiling rs485.c...
+compiling sd2506.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
diff --git a/docs/BSD_Socket_API_使用指南.md b/docs/BSD_Socket_API_使用指南.md
index d7f4526..ed891bb 100644
--- a/docs/BSD_Socket_API_使用指南.md
+++ b/docs/BSD_Socket_API_使用指南.md
@@ -113,6 +113,8 @@
└────── CLOSED ──────────────────┘
```
+> **单连接 Server 自动重监听（`auto_relisten`）**：`net_listen()` 会为 TCP 监听 Socket 置 `auto_relisten = 1`。连接断开（`net_recv` 收到 EOF / 空闲 `net_accept`）时，net 层**自动**重新 `OPEN + TCP_LISTEN`，状态由 `ESTABLISHED`/`CLOSED` 自动回到 `LISTENING`，**应用层无需调用 `net_close()` + `net_listen()`**。这与 Linux BSD Socket“监听 Socket 常驻”语义一致——`net_accept()` 在每条新连接到达时返回，服务端循环不必维护重监听逻辑。
+
---
## 3. 线程安全设计
@@ -327,23 +329,26 @@ void tcp_server_single(void)
net_inet_ntoa(client_addr.sin_addr.s_addr, ip_str),
net_ntohs(client_addr.sin_port));
- /* 接收和发送数据 */
+ /* 接收和发送数据（单连接模式：client_sock 即 listen_sock 自身） */
while (1)
{
len = net_recv(client_sock, buf, sizeof(buf) - 1, 0);
if (len <= 0) {
- printf("连接断开\r\n");
+ /* 对端关闭：net 层已在 EOF 时自动重监听，
+ 直接 break，外层 net_accept 会接下一个连接 */
+ printf("连接断开，net 层自动重监听\r\n");
break;
}
-
+
buf[len] = '\0';
printf("收到: %s\r\n", buf);
-
+
/* 回显数据 */
net_send(client_sock, buf, len, 0);
}
-
- net_close(client_sock);
+
+ /* 单连接模式不要在此 net_close(client_sock)：它即监听 Socket，
+ 一旦关闭需重新 net_socket+net_bind+net_listen；重监听已由 net 层自动完成 */
}
}
}
@@ -824,6 +829,8 @@ int net_listen(int sockfd);
| `sockfd` | socket 描述符 |
| 返回值 | 0 成功，-1 失败 |
+> **自动重监听**：`net_listen()` 对 TCP 监听 Socket 置 `auto_relisten = 1`。连接结束后 net 层自动回到 `LISTENING`，应用层无需手动 `net_close()` + `net_listen()`。
+
#### net_accept - 接受连接
```c
@@ -835,7 +842,7 @@ int net_accept(int sockfd, struct net_sockaddr *addr, int *addrlen);
| `sockfd` | 监听 socket 描述符 |
| `addr` | 输出：客户端地址 |
| `addrlen` | 输入输出：地址长度 |
-| 返回值 | 新 socket 描述符，失败返回 -1 |
+| 返回值 | 新连接描述符（单连接模式下 == 监听 `sockfd`），无连接时返回 -1（可循环重试） |
#### net_connect - 连接服务器
@@ -876,7 +883,7 @@ int net_recv(int sockfd, void *buf, int len, int flags);
| `buf` | 接收缓冲区 |
| `len` | 缓冲区大小 |
| `flags` | 0=阻塞，`NET_MSG_DONTWAIT`=非阻塞 |
-| 返回值 | 实际接收字节数，0=对端关闭，-1=错误 |
+| 返回值 | 实际接收字节数；`0`=对端已关闭（net 层随即自动重监听）；`-1`=错误（非阻塞且无数据时返回 `NET_ERR_WOULDBLOCK`） |
#### net_sendto - 发送 UDP 数据
diff --git a/docs/CH395F_Test_Guide.md b/docs/CH395F_Test_Guide.md
index 40d2ffe..57997b4 100644
--- a/docs/CH395F_Test_Guide.md
+++ b/docs/CH395F_Test_Guide.md
@@ -2,57 +2,75 @@
## 1. 概述
-本文档定义 CH395F 以太网驱动（STM32F407ZGTx，SPI2 接口）在**单连接 socket 模式**下的测试规范。测试按阶段（TM-PHY-NN）组织，每个阶段包含独立测试用例（TC-NET-NNN）。
+本文档定义 CH395F 以太网驱动（STM32F407ZGTx，SPI2 接口）的测试规范。当前固件运行于**多 Socket 模式**（`FUN_PARA=0x09`：8 个 Socket 0~7 全部可用，Socket 0 作 TCP Server 单连接），覆盖单连接与多并发客户端场景。测试按阶段（TM-PHY-NN）组织，每个阶段包含独立测试用例（TC-NET-NNN）。
### 设计原则
| 原则 | 描述 | 验证用例 |
|------|------|----------|
-| DP-01 | 单连接 socket：Socket 0 唯一，复用监听和数据通道；CONNECT 后切换数据通道；DISCONNECT/TIMEOUT 后重新 OPEN → LISTEN | TC-NET-201~203, 601~609, 906 |
+| DP-01 | 单连接 socket：Socket 0 唯一，复用监听和数据通道；CONNECT 后切换数据通道；DISCONNECT/TIMEOUT 后重新 OPEN → LISTEN | TC-NET-201~203, 601~606, 701~703, 801, 802, 901, 902, 1001~1006 |
| DP-02 | 中断集中处理：所有 CH395F 中断在 `net_poll()` 中通过 `GET_GLOB_INT_STATUS` 统一读取并清除，ISR 及其他位置不处理 | TC-NET-101 |
| DP-03 | 线程安全：所有 CH395F 操作通过 `netMsgQueue` 在 netTask 串行处理 | TC-NET-301~302 |
-| DP-04 | DMA 边界安全：`CH395F_SPI_DMA_BUF_SIZE=4100`，单次事务最大载荷 `4096B`，超限自动分块 | TC-NET-901~905 |
+| DP-04 | DMA 边界安全：`CH395F_SPI_DMA_BUF_SIZE=4100`，单次事务最大载荷 `4096B`，超限自动分块 | TC-NET-1001~1005 |
### CH395F 缓冲架构（关键参数）
| 参数 | 值 | 说明 |
|------|-----|------|
-| CH395F 内部总缓冲 | 32KB（32 块 × 1KB） | Socket 0~3 各 4KB 默认 |
-| Socket 0 发送缓冲 | 4096B（硬件默认） | 未显式配置时使用 |
-| Socket 0 接收缓冲 | 4096B（硬件默认） | 未显式配置时使用 |
+| CH395F 内部总缓冲 | **24KB（48 块 × 512B）** | 手册 §5.45；CH395F.md "内置 24K RAM"。**经 Phase 7 实测确认块 0~47 全部有效**（此前 32×1KB 记录有误） |
+| 上电默认分配 | Socket 0~3 各 接收8块(4KB)+发送4块(2KB)；Socket 4~7 未分配 | 见 §5.45，用到 >4 个 Socket 必须重分配 |
+| **本固件分配（net_init）** | 8 个 Socket 各 **接收 4 块(2KB) + 发送 2 块(1KB)** | 块数由 `CH395F_TCP_MSS` 推导（接收 `CH395F_RECV_BLOCKS`=2×MSS、发送 `CH395F_SEND_BLOCKS`=1×MSS，每块 512B）；起始块 `recv=i*6`、`send=i*6+4`；用尽 0~47，互不重叠 |
+| **TCP MSS** | **1024** | 由接收缓冲(2KB) ≥ 2×MSS 决定，8 Socket 共享 24KB 时的最大值 |
| **SPI DMA 缓冲** | **4100B** | `CH395F_SPI_DMA_BUF_SIZE` |
| **单次 SPI 最大载荷** | **4096B** | `CH395F_SPI_DMA_MAX_PAYLOAD` |
-| 单次 net_send 最大分块 | 4096B | 超限自动分多次 DMA |
| recv_len 最大值 | 65535 | `uint16_t` |
-> **关键约束**：CH395F 硬件接收缓冲 4096B。`recv_len` 在调 `read_recv_buf` 读取**部分**数据后归零（Trap 13）。因此每次接收调用需确保 `read_len >= recv_len`，或增大 DMA 缓冲以一次性读空。当前 `CH395F_SPI_DMA_BUF_SIZE=4100` 可覆盖完整 4096B 接收缓冲。
+> **关键约束**：本固件每个 Socket 接收缓冲为 **2KB**（4 块 × 512B），发送缓冲为 **1KB**（2 块）。`recv_len` 在调 `read_recv_buf` 读取**部分**数据后归零（Trap 13），故每次接收应一次性读空当前可用数据（≤2KB）。`CH395F_SPI_DMA_BUF_SIZE=4100` 足以覆盖单 Socket 完整 2KB 接收缓冲。
+
+### 多 Socket / 8 端口并发分配
+
+`net_init` 中 `ch395f_set_fun_para(0x09)` 启用 8 个 Socket 后，循环 0~7 调用 `SET_RECV_BUF` / `SET_SEND_BUF` 重分配（必须在 `OPEN_SOCKET` 之前，顺序遵循 Trap 01：先数据 Socket 1~7 再监听 Socket 0）：
+
+| Socket | 接收起始块 | 接收块数 | 接收大小 | 发送起始块 | 发送块数 | 发送大小 |
+|--------|-----------|---------|---------|-----------|---------|---------|
+| 0 | 0 | 4 | 2KB | 4 | 2 | 1KB |
+| 1 | 6 | 4 | 2KB | 10 | 2 | 1KB |
+| 2 | 12 | 4 | 2KB | 16 | 2 | 1KB |
+| 3 | 18 | 4 | 2KB | 22 | 2 | 1KB |
+| 4 | 24 | 4 | 2KB | 28 | 2 | 1KB |
+| 5 | 30 | 4 | 2KB | 34 | 2 | 1KB |
+| 6 | 36 | 4 | 2KB | 40 | 2 | 1KB |
+| 7 | 42 | 4 | 2KB | 46 | 2 | 1KB |
+
+UDP 路径 `net_socket()` 中对 Socket 4~7 的兜底重设使用同一布局。该分配已通过 **Phase 7 TC704（8 Socket 并发回显，40/40 PASS）** 验证。
### 大文件传输（20KB+）策略
-单连接模式下，超过 Socket 0 硬件缓冲（4KB）的数据通过以下机制传输：
+多 Socket 模式下，每个 Socket 拥有独立收发缓冲（接收 2KB / 发送 1KB，见上表）。超过单 Socket 接收缓冲（2KB）的数据通过分块传输：
```
发送端：net_send(buf, 20480)
- → net_send_locked 分块，每块 ≤ 4096B
- → 块 1: ch395f_write_send_buf(sock, buf[0..4095], 4096) // DMA 事务 1
- → 等待 SENDBUF_FREE
- → 块 2: ch395f_write_send_buf(sock, buf[4096..8191], 4096) // DMA 事务 2
+ → net_send_locked 分块写入 CH395F 发送缓冲（每 Socket 发送缓冲 1KB）
+ → 块 1: ch395f_write_send_buf(sock, buf[0..1023], 1024) // DMA 事务 1
+ → 等待 SENBUF_FREE
+ → 块 2: ch395f_write_send_buf(sock, buf[1024..2047], 1024) // DMA 事务 2
→ ...
- → 共 5 次 DMA 事务完成 20KB
+ → 共 20 次 DMA 事务完成 20KB（MSS=1024，TCP 每段 ≤1024B）
接收端：net_recv(buf, 20480)
→ net_recv_locked 循环拉取
- → ch395f_get_recv_len() 返回硬件缓冲中当前可用数据（≤4096B）
- → ch395f_read_recv_buf() 一次性读空硬件缓冲（≤4096B/DMA 事务）
+ → ch395f_get_recv_len() 返回硬件缓冲中当前可用数据（≤2KB）
+ → ch395f_read_recv_buf() 一次性读空硬件缓冲（≤2KB/DMA 事务）
→ 循环直至全部 20480B 收完
```
**边界条件**：
-- 发送 `≤4096B`：一次 DMA 事务完成
-- 发送 `4097B`：两次 DMA 事务（4096 + 1）
-- 接收缓冲满（4096B）：必须一次性读空，否则 `recv_len` 归零导致剩余数据丢失
+- 发送 `≤1KB`：一次写发送缓冲完成（受发送缓冲 1KB 限制）
+- 接收缓冲满（2KB）：必须一次性读空，否则 `recv_len` 归零导致剩余数据丢失（Trap 13）
- 发送 `0B`：`net_send` 返回 `-1`（`NET_ERR_INVAL`）
+> **注**：当前 `net_send` 的分块上限常量 `NET_DMA_MAX_PAYLOAD=4096` 大于单 Socket 发送缓冲(1KB)，单次 `WRITE_SEND_BUF` 写入量受发送缓冲大小约束；大文件传输（Phase 6/8/10）需在硬件上实测确认无溢出。
+
### 测试环境
```
@@ -67,13 +85,13 @@ MCU: STM32F407ZGTx @ 168MHz, Keil MDK-ARM v5 (ARMCC)
| 构建模式 | 启用宏 | 固件形态 |
|----------|--------|----------|
| **硬件层模式** | `ENABLE_PHASE1~5_TESTS` | **netTask 不创建**，CH395F 协议栈初始化由 ch395fTestTask 完成后独占芯片执行阶段 1~5（裸调 `ch395f_*` 命令） |
-| **NET 层模式** | `ENABLE_PHASE6~10_TESTS` | 完整网络栈：netTask 运行 `net_poll()` 轮询，testTask 经 `net_socket` API 在 TCP 监听循环中执行阶段 6~10 |
+| **NET 层模式** | `ENABLE_PHASE6~11_TESTS` | 完整网络栈：netTask 运行 `net_poll()` 轮询，testTask 经 `net_socket` API 执行阶段 6~11（`net_layer_test_main()` 回显、`net_layer_client_test_main()` Client 等） |
-**执行顺序严格递增**：先烧录硬件层固件完成阶段 1→2→3→4→5（全部通过），再切换为 NET 层固件执行阶段 6→…→10。硬件层测试期间 netTask 轮询不存在，从根上排除中断偷取与 SPI 并发问题。
+**执行顺序严格递增**：先烧录硬件层固件完成阶段 1→2→3→4→5（全部通过），再切换为 NET 层固件执行阶段 6→7→…→11。硬件层测试期间 netTask 轮询不存在，从根上排除中断偷取与 SPI 并发问题。
### 启用测试
-编辑 `test/ch395f_test.h`，取消注释对应 `ENABLE_PHASEx_TESTS` 宏（同一模式内 Phase 6/7/8/9 可共存于 testTask 循环）。
+编辑 `test/ch395f_test.h`，取消注释对应 `ENABLE_PHASEx_TESTS` 宏（同一模式内 Phase 6/7/8/9/10/11 可共存于 testTask 循环）。**注意：阶段 6 Server 回显为持续监听循环，故 Client 阶段 11 需单独构建（不与 `ENABLE_PHASE6_TESTS` 同时启用），否则 Client 用例不会被执行。**
---
@@ -372,23 +390,23 @@ CH395F PC (dhcp_server)
> 编号说明：阶段 5 用例 **501/502**（顺序双测向完整性 + 变总量合规）；原 PHY 测试（旧编号 901/902）因板载拓扑不可测已删除（见风险表 #1）。
-### 为什么 4KB 接收缓冲不会丢数据（TCP 流控原理）
+### 为什么 2KB 接收缓冲不会丢数据（TCP 流控原理）
-PC 一次回放 256KB，而 CH395F socket 接收缓冲默认仅 4KB——不丢数据的保证**不靠缓冲够大，靠 TCP 流控（通告窗口）**。
+PC 一次回放 256KB，而本固件为每个 Socket 分配的接收缓冲仅 2KB（4 块 × 512B）——不丢数据的保证**不靠缓冲够大，靠 TCP 流控（通告窗口）**。
数据不是全部驻留芯片，而是在一串缓冲区里"接力"：
```
-PC OS 发送缓冲(64~256KB) → 网络在途 → CH395F 接收缓冲(4KB) → MCU 读取
+PC OS 发送缓冲(64~256KB) → 网络在途 → CH395F 接收缓冲(2KB) → MCU 读取
```
CH395F 是完整 TCP 栈 offload 芯片，内部实现 TCP 状态机，按**接收缓冲剩余空间**向 PC 通告接收窗口（advertised window）：
-1. PC 发数据，芯片收进自己的 4KB 接收环形缓冲；
+1. PC 发数据，芯片收进自己的 2KB 接收环形缓冲；
2. 缓冲快满 → 通告窗口收缩直至 **窗口=0** → PC 的 `sendall` **阻塞**（TCP 背压），剩余数据停在 PC 自身 OS 发送缓冲，不再发出；
3. MCU `GET_RECV_LEN` → `READ_RECV_BUF` 读走 → 缓冲腾空 → 芯片重新通告窗口 → PC 恢复发送。
-因此是**背压联动、自节流**：数据永不因芯片缓冲溢出被丢弃，只会"堵一会儿"。MCU 平均读取速率 ≥ PC 发送速率即可持续吞吐（本测试每 2ms 轮询、每次读 4KB，平均速率远高于发送速率，缓冲常年接近空）。
+因此是**背压联动、自节流**：数据永不因芯片缓冲溢出被丢弃，只会"堵一会儿"。MCU 平均读取速率 ≥ PC 发送速率即可持续吞吐（本测试每 2ms 轮询、每次读 2KB，平均速率远高于发送速率，缓冲常年接近空）。
"先查长度再读"（`GET_RECV_LEN` → `READ_RECV_BUF`）安全的原因：查询返回"当前未读字节数"，流控保证其必然 ≤ 缓冲容量；查询与读取之间新到的数据进入环形缓冲尾部，由芯片读写指针管理，**不会覆盖未读数据**，留待下一次迭代读取。
@@ -418,7 +436,7 @@ MCU (TCP Client, ch395f_* 裸命令) PC (tcp_bulk --port 8081)
- **为什么顺序双测向**：单向隔离，分别测得**纯 TX / 纯 RX** 吞吐与完整性——不被"回声耦合"掩盖各自链路的真实能力
- **TX 节奏**：写 4096B → 等 `SENBUF_FREE`（芯片把 socket 缓冲数据搬入内部协议栈/MAC 缓冲后触发）→ 写下一块，全程不等回显；单向发送阶段 PC 只收不回声，故无回读死锁问题
- **RX 校验**：PC 按相同 LCG 模式回放，MCU 期望流按块生成 `exp[]` 字节对位 + `sum_rx` 累加，天然处理 TCP 分包/粘包
-- 单块 4096B = socket 默认发送缓冲上限，同时命中 DP-04 的 DMA 单次读边界
+- 单块 4096B 数据 = 触发 DP-04 的 DMA 单次读边界（注意：单 Socket 发送缓冲实际为 1KB，net_send 写入需受此约束）
- 双重完整性：逐字节比对 + 全量 32 位累加和 `SUM(TX)==SUM(RX)`（双向同源 LCG，相等即双向一致）
- 双向独立吞吐打印（TX/RX 各自 KB/s），作为 SPI 时钟/驱动调整的回归基线
@@ -485,28 +503,71 @@ MCU (TCP Client, ch395f_* 裸命令) PC (tcp_bulk --port 8081)
---
-### 已知风险与待实施项
-
-| # | 事项 | 影响 | 状态 |
-|---|------|------|------|
-| 1 | 原 PHY 测试（旧编号 901/902）删除：CH395F 直连板载 RTL8305NBI 交换机，PHY 恒 link up，拔插外线上联无法在芯片 PHY 产生变化事件（2026-08-24 实测 0/1 FAIL 后决议） | 编号 901/902 弃用 | ✅ 已移除 |
-| 2 | DP-05（PHY 链路恢复）失去覆盖对象 | 设计原则表缩减 | ✅ 已同步删除 |
-| 3 | 吞吐基线（2026-08-24 实测）：TX 420~449 KB/s、RX 364~391 KB/s，随总量/块大小基本恒定，疑似 SPI 总线为瓶颈 | 后续 SPI 时钟/驱动优化以该基线为参照 | ✅ 已记录 |
-
----
-
-## 7. 阶段 6：NET 层 TCP（Server 回显 + Client 主动连接）
+## 7. 阶段 6：NET 层 TCP Server 回显
| 阶段 ID | TM-PHY-06 |
|---------|-----------|
| **类型** | PC 配合，netTask 运行 |
-| **耗时** | 持续运行 |
-| **入口** | `ENABLE_PHASE6_TESTS`，`ch395fTestTask` TCP 回显循环中运行 |
-| **出口** | 用户终止 |
+| **耗时** | 持续运行（Server 模式）/ 约 60s（Client 模式） |
+| **入口** | `ENABLE_PHASE6_TESTS` → `net_layer_test_main()`（`net_test_task.c`，持续监听回显循环） |
+| **出口** | 用户终止（Server）/ 用例结束自动回到 IDLE（Client） |
-两部分组成：
-- **Server 模式（TC-NET-601~606）**：MCU 监听 8080，PC 主动连接，验证回显通路 —— 已实现 🟡
-- **Client 模式扩展（TC-NET-607/608/609）**：MCU 经 BSD Socket API 主动连接 PC Server，补全 `net_connect()` 路径 —— 待实现 🟠（原编号 204/205/206，属阶段 2 NET 层部分，2026-08 重排）
+本阶段在 NET 层（单连接 socket，DP-01）经 `net_socket` API 驱动，MCU 作 TCP Server 监听 8080，PC 主动连接，验证回显通路、单连接生命周期与字节级完整性 —— 已实现（net 层自动重监听，应用层零生命周期代码）
+
+> Client 主动连接（原 TC-NET-607/608/609，现 701/702/703）已独立为 **阶段 7**（见 §8），使用独立宏 `ENABLE_PHASE7_TESTS` 与独立入口 `net_layer_client_test_main()`。
+
+### 7.1 架构与会话结构
+
+**Server 回显模式**（`net_layer_test_main()`，`net_test_task.c`，由 `ENABLE_PHASE6_TESTS` 启用）：
+
+**架构图（组件）**：
+
+```
+┌──────────────┐ TCP 8080 ┌──────────────────────────┐
+│ PC (Python) │ ───────────────────────────────────────────▶ │ CH395F (192.168.1.100) │
+│ tcp_client / │ Ethernet │ Socket 0（单连接复用） │
+│ tcp_server │ (SPI2, 分频=8) └────────────┬─────────────┘
+└──────────────┘ SPI │
+ ▼
+ ┌──────────────────────────┐
+ │ MCU (STM32F407) │
+ │ netTask: net_poll() 10ms │
+ │ testTask: │
+ │ net_layer_test_main() │
+ │ └─ phase6_run() 原样回显 │
+ └──────────────────────────┘
+```
+
+**会话时序图（单连接生命周期）**：
+
+```
+ PC (Client) CH395F Socket 0 MCU testTask
+ │ │ │
+ │ SYN ──────────────────▶│ │
+ │◀──────────────── SYN+ACK │ │
+ │ ACK ──────────────────▶│ ESTABLISHED │
+ │ │── 中断/GlobInt ───────────▶│ net_poll()
+ │ │ │ net_accept()→phase_active
+ │ [64B 数据] ───────────▶│ recv_len = N │
+ │ │── 中断 ───────────────────▶│ net_poll()
+ │ │ │ phase6_run():
+ │ │ │ net_recv(N) → 字节校验
+ │ │ │ TEST_CHECK(累加和)
+ │◀──────────── [64B 回显]─│ net_send() │
+ │ (逐字节比对 + 累加和) │ │
+ │ (重复 N 轮 / 多包) │ │
+ │ │ │
+ │ FIN/RST ───────────────▶│ DISCONNECT │
+ │ │── 中断 ───────────────────▶│ net_poll()
+ │ │ │ net_recv EOF → auto_relisten
+ │ │◀─ 自动 OPEN + TCP_LISTEN │
+ │ SYN(新连接) ───────────▶│ LISTEN 自动恢复，重新接受 │
+```
+
+- `phase6_run()` 为**纯回显**：非阻塞 `net_recv(sockfd, s_rx_buf, TEST_BUF_SIZE, NET_MSG_DONTWAIT)` 收到 N 字节后，`net_send(sockfd, s_rx_buf, N, 0)` 原样回显；不做固件侧字节自检（字节完整性由 PC 侧 `data == test_data` 校验）。
+- 单连接约束（DP-01）：Socket 0 复用监听/数据通道；连接断开（DISCONNECT / KeepAlive TIMEOUT / 静默丢失）后由 **net 层自动重监听**（`auto_relisten`：`net_recv` 收到 EOF 时内部重新 `OPEN` + `TCP_LISTEN`），应用层无需 `net_close`/`net_listen`，下一次 `net_accept` 即接到新连接，行为等同 Linux BSD Socket 监听常驻。
+
+> Client 主动连接（原 TC-NET-607/608/609，现 701/702/703）已独立为 **阶段 7**，架构与用例见 §8。
### TC-NET-601: Socket 0 单连接生命周期
@@ -515,11 +576,20 @@ MCU (TCP Client, ch395f_* 裸命令) PC (tcp_bulk --port 8081)
| **ID** | TC-NET-601 |
| **优先级** | P0 |
| **类型** | 功能测试 |
-| **标题** | Socket 0: OPEN → TCP_LISTEN → ESTABLISHED（单连接） |
-| **前置条件** | 1. `net_init("192.168.1.100")` 成功
2. `net_listen(sock0)` 已调用
3. PC: `python ch395f_socket_test.py tcp_client --ip 192.168.1.100 --port 8080` |
-| **测试步骤** | 1. PC 连接 8080
2. Socket 0 收到 CONNECT → ESTABLISHED
3. 发数据 → 回显 |
-| **通过标准** | 仅 s0 状态变化；串口 `s0:int=0x08` → ESTABLISHED |
-| **覆盖原则** | DP-01 |
+| **标题** | Socket 0：OPEN → TCP_LISTEN → ESTABLISHED（单连接） |
+| **前置条件** | 1. `net_init("192.168.1.100")` 成功（`g_net_ready==1`，netTask 周期 `net_poll()` 运行）
2. `net_layer_test_main()` 已 `net_socket`+`net_bind(8080)`+`net_listen`（进入 LISTEN）
3. PC: `python .\test\ch395f_socket_test.py tcp_client --ip 192.168.1.100 --port 8080` |
+
+**测试步骤与判定标准**：
+
+| 步 | 操作 | 成功标准 | 失败标准 |
+|----|------|----------|----------|
+| 1 | PC 连接 8080 | `net_accept()` 返回 fd（== 监听 fd，单连接），`net_get_sock(state)==ESTABLISHED` | 连接未被接受 / 状态未进入 ESTABLISHED |
+| 2 | `phase6_run()` 非阻塞收 PC 数据 | `net_recv(DONTWAIT)` 返回 > 0 | 收超时（连接未真建立） |
+| 3 | 固件收 PC 数据 → 字节级比对 + 32 位累加和 `TEST_CHECK` → `net_send()` 原样回显 | PC 收到与发送完全一致的数据且固件 `TEST_CHECK` 通过 | 回显丢失 / 错乱 / 固件校验失败 |
+| 4 | 串口观测 `net_get_sock` 状态 | 仅 Socket 0 状态变化，无其它 Socket 干扰 | 出现非预期 Socket 状态跳变 |
+
+**通过标准**：步 1~4 全部满足，单连接生命周期正常。任一失败 → 标记 FAIL
+**覆盖原则**：DP-01（OPEN→LISTEN→ESTABLISHED 单连接主路径） |
### TC-NET-602: 64 字节小包回显
@@ -528,20 +598,40 @@ MCU (TCP Client, ch395f_* 裸命令) PC (tcp_bulk --port 8081)
| **ID** | TC-NET-602 |
| **优先级** | P0 |
| **类型** | 功能测试 |
-| **标题** | 10 轮 64B TCP 回显 |
-| **测试步骤** | PC 发 10×64B，MCU 回显 |
-| **通过标准** | 10/10 匹配 |
+| **标题** | 10 轮 64B TCP 回显（原样回显，小包） |
+| **前置条件** | 同 TC-NET-601（连接已建立，ESTABLISHED） |
-### TC-NET-603: 1460 字节 MSS 回显
+**测试步骤与判定标准**：
+
+| 步 | 操作 | 成功标准 | 失败标准 |
+|----|------|----------|----------|
+| 1 | PC 依次发送 10×64B（递增模式 `0x00..0x3F`） | 每轮 `net_recv` 收 64B | 收包不足 64B |
+| 2 | `phase6_run()` 收 64B → 原样回显 | PC 逐轮收到 64B 且 `data == test_data` 一致 | 回显丢失 / 错乱 / PC 校验不符 |
+| 3 | PC 汇总 10 轮并逐字节校验 | 10/10 匹配 | 任一轮失败 |
+
+**通过标准**：10/10 匹配，0 失败。任一失败 → 标记 FAIL
+**覆盖原则**：DP-01（单连接数据通路，小包） |
+
+### TC-NET-603: 1460 字节回显（当前固件 MSS=1024，1460B 会按 MSS 分片）
| 字段 | 值 |
|------|-----|
| **ID** | TC-NET-603 |
| **优先级** | P0 |
| **类型** | 边界测试 |
-| **标题** | MSS 大小（1460B）TCP 回显 |
-| **测试步骤** | PC 发 1460B，MCU 回显 |
-| **通过标准** | 1460B 完全匹配，无截断 |
+| **标题** | 1460B 回显（注：当前固件 TCP MSS=1024，1460B 超过 MSS 将由 CH395F 按 MSS 分片） |
+| **前置条件** | 同 TC-NET-601（连接已建立） |
+
+**测试步骤与判定标准**：
+
+| 步 | 操作 | 成功标准 | 失败标准 |
+|----|------|----------|----------|
+| 1 | PC 发单包 1460B（当前 TCP MSS=1024，1460B 会被分片为 1024+436；`net_send` 亦按 1KB 发送缓冲分块） | `net_recv` 一次收 1460B（≤2KB 接收缓冲，DMABUF=4100 一次读空） | 接收字节数 ≠ 1460（被截断 / 分片丢失） |
+| 2 | 固件收 1460B → 原样回显 | PC 收到 1460B 且 `data == test_data` 一致 | 回显错乱 / PC 校验不符 |
+| 3 | PC 校验 | 1460B 完全匹配 | 任意字节不符 |
+
+**通过标准**：1460B 完全匹配，无截断。任一失败 → 标记 FAIL
+**覆盖原则**：DP-04（1460 ≤ 2KB 接收缓冲，单次 DMA 读空） |
### TC-NET-604: 4096 字节缓冲满回显
@@ -550,11 +640,19 @@ MCU (TCP Client, ch395f_* 裸命令) PC (tcp_bulk --port 8081)
| **ID** | TC-NET-604 |
| **优先级** | P0 |
| **类型** | 边界测试 |
-| **标题** | 填满 Socket 0 接收缓冲（4096B）回显 |
-| **前置条件** | DMABUF=4100 可一次性读空 |
-| **测试步骤** | PC 发 4096B，MCU 经 DMA 一次性读取并回显 |
-| **通过标准** | 4096B 完全匹配 |
-| **覆盖原则** | DP-04 |
+| **标题** | 4096B 回显（接收缓冲仅 2KB，分两次取空） |
+| **前置条件** | 同 TC-NET-601；`CH395F_SPI_DMA_BUF_SIZE=4100` 可一次性读空 2KB 硬件缓冲 |
+
+**测试步骤与判定标准**：
+
+| 步 | 操作 | 成功标准 | 失败标准 |
+|----|------|----------|----------|
+| 1 | PC 发单包 4096B（实际单 Socket 接收缓冲为 2KB，固件分两次 `net_recv` 取空） | `net_recv` 累计收满 4096B（分次） | 接收字节数 ≠ 4096（丢失，见 TRAP-13） |
+| 2 | 固件收 4096B → 原样回显（`net_send` 分块） | PC 收到 4096B 且 `data == test_data` 一致 | 回显错乱 / PC 校验不符 |
+| 3 | PC 校验 | 4096B 完全匹配 | 任意字节不符 |
+
+**通过标准**：4096B 完全匹配。任一失败 → 标记 FAIL
+**覆盖原则**：DP-04（2KB 接收缓冲边界 + 单次 DMA 上限） |
### TC-NET-605: 断开重连
@@ -564,38 +662,121 @@ MCU (TCP Client, ch395f_* 裸命令) PC (tcp_bulk --port 8081)
| **优先级** | P0 |
| **类型** | 恢复测试 |
| **标题** | PC 断开后 Socket 0 自动重新监听并接受新连接 |
-| **测试步骤** | 1. PC 断连 → s0 收 DISCONNECT → CLOSED → re-OPEN → LISTEN
2. PC 重连 → s0 → ESTABLISHED
3. 发 64B → 验证回显 |
-| **通过标准** | 重连成功，回显正常 |
-| **覆盖原则** | DP-01 |
+| **前置条件** | 同 TC-NET-601（连接已建立，已完成至少一轮 64B 回显） |
-### TC-NET-606: 超时恢复
+**测试步骤与判定标准**：
+
+| 步 | 操作 | 成功标准 | 失败标准 |
+|----|------|----------|----------|
+| 1 | PC 关闭连接（FIN/RST） | 固件 `net_recv` 收 EOF、`net` 层自动 `auto_relisten` 回到 LISTEN | 状态未变化（卡 ESTABLISHED） |
+| 2 | net 层自动重监听，无需应用干预（`net_recv` EOF 内部重新 OPEN + TCP_LISTEN） | `net_accept` 在新连接到达时再次返回 fd | 未回到 LISTEN（状态机卡死） |
+| 3 | PC 重新连接 8080 | `net_accept` 再次返回 fd，进入 ESTABLISHED | 重连失败 |
+| 4 | PC 发 64B → 固件原样回显 | 回显正常且 PC `data == test_data` 通过 | 回显失败 / PC 校验不符 |
+
+**通过标准**：重连成功且回显正常，0 失败。任一失败 → 标记 FAIL
+**覆盖原则**：DP-01（DISCONNECT → CLOSED → re-OPEN → LISTEN 单连接恢复） |
+
+### TC-NET-606: 连接异常恢复（静默断开 / KeepAlive 超时）
| 字段 | 值 |
|------|-----|
| **ID** | TC-NET-606 |
| **优先级** | P1 |
| **类型** | 恢复测试 |
-| **标题** | KeepAlive 超时后 Socket 0 自动重新监听 |
-| **测试步骤** | 1. PC 断连后停止响应
2. 等待 KeepAlive 触发 TIMEOUT
3. s0 → CLOSED → re-OPEN → LISTEN
4. PC 重连 → 验证回显 |
-| **通过标准** | 自动恢复，无需手动复位 |
-| **覆盖原则** | DP-01 |
+| **标题** | 无干净 FIN 或 KeepAlive 超时后 Socket 0 自动重新监听 |
+| **前置条件** | 1. 同 TC-NET-601（连接已建立）
2. KeepAlive 触发场景需 `ENABLE_PHASE11_TESTS` 且 `ch395f_set_keepalive_*` 已配置（探测时长本身由 TC-NET-1101 覆盖） |
+
+**测试步骤与判定标准**：
+
+| 步 | 操作 | 成功标准 | 失败标准 |
+|----|------|----------|----------|
+| 1 | PC 静默断开（如直接断开网线 / 断电，不发 FIN）或 KeepAlive 探测超时触发 TIMEOUT | 固件经 `net_get_sock(state)` 轮询发现非 ESTABLISHED | 状态长期卡 ESTABLISHED（未恢复） |
+| 2 | 固件 net 层 `auto_relisten` 自动回到 LISTEN（应用层无 `net_close`/`net_listen` 调用） | 回到 LISTEN，等待新连接 | 未恢复监听 |
+| 3 | PC 重连 → 发 64B → 验证回显 | 回显正常 | 回显失败 |
+
+**通过标准**：自动恢复监听，无需手动复位。任一异常 → 标记 FAIL
+**覆盖原则**：DP-01（异常路径恢复；KeepAlive 探测机制见 TC-NET-1101） |
---
-### Client 模式扩展：主动连接 PC（TC-NET-607 / 608 / 609，🟠 待实现）
+
+
+
+
+## 8. 阶段 7：NET 层 TCP Client 主动连接
+
+| 阶段 ID | TM-PHY-07 |
+|---------|-----------|
+| **类型** | PC 配合，netTask 运行 |
+| **耗时** | 约 60s |
+| **入口** | `ENABLE_PHASE7_TESTS` → `net_layer_client_test_main()`（`net_test_task.c`） |
+| **出口** | 用例结束自动回到 IDLE |
> 与硬件层阶段 2 的 TC-NET-201/202/203 一一对应（芯片行为 → API 封装），验证 `net_socket` / `net_connect` / `net_send` / `net_recv` / `net_close` 对 TCP Client 主路径及异常路径的正确封装。
-> 本组用例原编号 204/205/206（原阶段 2 的 NET 层部分），2026-08 重排后为 607/608/609；实现于 `ENABLE_PHASE6_TESTS` 固件中。
+> 由独立宏 `ENABLE_PHASE7_TESTS` 启用，独立于 Server 回显阶段 6（`ENABLE_PHASE6_TESTS`）；因阶段 6 为持续监听循环，Client 阶段需**单独构建**（不与 `ENABLE_PHASE6_TESTS` 同时启用）。
+> 原编号 204/205/206（原阶段 2 的 NET 层部分），2026-08 重排后为 701/702/703。
-#### TC-NET-607（NET 层）: TCP Client 连接与数据交换
+### 8.1 架构与会话结构
+
+```
+net_socket(NET_AF_INET, NET_SOCK_STREAM, 0) // 取空闲 Socket（非监听 Socket 0）
+ → net_connect(PC:8081) // 异步下发，net_poll 推进状态机
+ → net_select(sockfd+1, NULL, &wfds, NULL, &tv) // 等可写 = ESTABLISHED
+ → net_send(64B) → net_recv(64B) 校验 // 主路径（701）
+ → net_close() // 释放
+```
+
+**架构图（组件）**：
+
+```
+┌──────────────┐ TCP 8081 ┌──────────────────────────┐
+│ PC (Python) │ ◀─────────────────────────────────────────── │ CH395F (192.168.1.100) │
+│ tcp_server │ Ethernet │ Socket N（非 0 空闲） │
+│ (回显服务器) │ (SPI2, 分频=8) └────────────┬─────────────┘
+└──────────────┘ SPI │
+ ▼
+ ┌──────────────────────────┐
+ │ MCU (STM32F407) │
+ │ netTask: net_poll() 10ms │
+ │ testTask: │
+ │ net_layer_client_test_main│
+ │ └─ net_connect→收发→close│
+ └──────────────────────────┘
+```
+
+**会话时序图（Client 主动连接）**：
+
+```
+ PC (Server :8081) CH395F Socket N MCU testTask
+ │ │ │
+ │ (Python tcp_server) │ │ net_layer_client_test_main()
+ │ │◀─ net_socket()+net_connect()│ (异步下发 CONNECT)
+ │◀────────────── SYN ──────│ │
+ │────── SYN+ACK ─────────▶│ ESTABLISHED │
+ │ │── 中断/GlobInt ───────────▶│ net_poll()
+ │ │ │ net_select() 可写 → 建链
+ │◀────────────── [64B] ────│ net_send() │
+ │ (回显服务器原样返回) │ │
+ │ [64B 回显] ───────────▶│ recv_len = N │
+ │ │── 中断 ───────────────────▶│ net_poll()
+ │ │ │ net_recv(N) → 字节校验
+ │ │ │ TEST_CHECK(累加和)
+ │ │◀─ net_close() ─────────────│ 释放 Socket N
+```
+
+- `net_layer_client_test_main()` 为**独立入口**：使用非 0 空闲 Socket 连接 PC，不在 `net_layer_test_main()` 的监听循环内；由 `StartCh395fTestTask` 的 NET 分支按宏调用。
+- **固件自检**：`net_recv` 后逐字节比对 + 32 位累加和 `TEST_CHECK`（固件侧独立校验）；PC 同时校验。
+- 关闭重连（702）、连接超时（703）见对应 TC。
+
+### TC-NET-701: TCP Client 连接与数据交换
| 字段 | 值 |
|------|-----|
-| **ID** | TC-NET-607 |
+| **ID** | TC-NET-701 |
| **优先级** | P0 |
| **类型** | 功能测试（NET 层） |
| **标题** | net_socket TCP Client → PC TCP Server，64 字节收发 |
-| **前置条件** | 1. PC: `python ch395f_socket_test.py tcp_server --port 8081`（TCP 回显服务器）
2. `net_init()` 已完成（`g_net_ready == 1`，netTask 周期 `net_poll()` 运行中）
3. 建议：硬件层固件中 TC-NET-201/202/203 已通过（跨构建前置，见「构建模式与执行顺序」） |
+| **前置条件** | 1. PC: `python ./test/ch395f_socket_test.py tcp_server --port 8081`（TCP 回显服务器）
2. `net_init()` 已完成（`g_net_ready == 1`，netTask 周期 `net_poll()` 运行中）
3. `ENABLE_PHASE7_TESTS` 已定义，入口为 `net_layer_client_test_main()`（见「构建模式与执行顺序」）
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` 无监听）
2. TC-NET-607 通过 |
+| **前置条件** | 1. PC **未**运行 TCP Server（`192.168.1.2:8081` 无监听）
2. TC-NET-701 通过 |
**测试步骤与判定标准**：
@@ -657,71 +838,128 @@ MCU (TCP Client, ch395f_* 裸命令) PC (tcp_bulk --port 8081)
**覆盖原则**：DP-01（NET 层异常路径 connect 失败处理）
----
+> **实现说明**：TC-NET-703 与 TC-NET-701/702 的 PC 环境互斥（前者要求 PC 服务关闭、后两者要求开启），故固件中 TC-NET-703 由子开关 `PHASE7_TEST_TIMEOUT` 单独启用——默认 `ENABLE_PHASE7_TESTS` 仅跑 701/702；单独开启 `PHASE7_TEST_TIMEOUT` 并关闭 PC 服务后重编，方可执行 703。
-## 8. 阶段 7：大文件传输（20KB+）
-
-| 阶段 ID | TM-PHY-07 |
-|---------|-----------|
-| **类型** | PC 配合，netTask 运行 |
-| **耗时** | 取决于文件大小和速率 |
-| **入口** | `ENABLE_PHASE7_TESTS` |
-| **配置** | `PHASE7_FILE_SIZE`（默认 20480）|
-
-### TC-NET-701: 20KB 分块传输
+### TC-NET-704: 8-Socket 并发 TCP Client（多 Socket 模式验证）
| 字段 | 值 |
|------|-----|
-| **ID** | TC-NET-701 |
+| **ID** | TC-NET-704 |
| **优先级** | P0 |
-| **类型** | 功能测试 |
-| **标题** | 20480 字节 TCP 分块收发（>Socket 0 硬件缓冲 4KB） |
-| **前置条件** | `net_send_locked` 支持自动分块（每块 ≤4096B） |
-| **测试步骤** | 1. MCU 填 20KB 递增模式数据
2. MCU 分块发送，每块 4096B
3. PC 回显
4. MCU 接收并逐字节验证 |
-| **通过标准** | 20KB 完全匹配，每字节验证通过 |
-| **覆盖原则** | DP-04 |
+| **类型** | 功能测试 / 并发测试（NET 层） |
+| **标题** | 同时打开 8 个 Socket 连接 PC Server，各自 64B 收发 |
+| **前置条件** | 1. PC: `python ./test/ch395f_socket_test.py tcp_server --port 8081 --max-conn 8`（并发回显，`--max-conn` 为并发计数）
2. `net_init()` 已置 `FUN_PARA=0x09`（8 Socket 模式），8 个 Socket 缓冲按「CH395F 缓冲架构」分配（每 Socket 接收 2KB + 发送 1KB，MSS=1024）
3. `ENABLE_PHASE7_TESTS` 已定义 |
-### TC-NET-702: 64KB 传输（recv_len 上限）
+**测试步骤与判定标准**：
-| 字段 | 值 |
-|------|-----|
-| **ID** | TC-NET-702 |
-| **优先级** | P1 |
-| **类型** | 边界测试 |
-| **标题** | 65535 字节传输（`recv_len` uint16 上限） |
-| **前置条件** | TC-NET-701 通过 |
-| **测试步骤** | 同 501，文件大小 65535 |
-| **通过标准** | 65535B 完全匹配 |
-| **覆盖原则** | DP-04 |
+| 步 | 操作 | 成功标准 | 失败标准 |
+|----|------|----------|----------|
+| 1 | 循环 i=0..7：`net_socket()` 创建 8 个 TCP socket（本地端口 51000+i），`net_connect(192.168.1.2:8081)` | 8 个 `net_connect` 均返回 `0` | 任一返回 `-1` |
+| 2 | netTask `net_poll()` 推进下，`net_select` 等待全部 8 路可写 | 8 路均在 10s 内 ESTABLISHED | 任一超时未建立 |
+| 3 | 每路 `net_send(sockfd, 64B)` → `net_recv(sockfd, 64B)` 校验 | 8 路收发各 64B、字节级比对 + 累加和 `TEST_CHECK` 通过 | 任一收发失败 / 数据不符 / `TEST_CHECK` 失败 |
-### 实现说明
+**通过标准**：8/8 路全部通过，0 失败。任一失败 → 标记 FAIL
-`phase7_run()` 状态机（`ch395fTestTask` 内）：
+**覆盖原则**：DP-01（多 Socket 并发主路径）、缓冲架构（8×6 块分配，MSS=1024）
-```
-IDLE → (连接建立) → SENDING(分块发) → RECVING(分块收+验证) → DONE → IDLE
-```
-
-- 每次 `net_send_sock` 自动分块（`net_send_locked` 内按 `NET_DMA_MAX_PAYLOAD=4096` 拆分）
-- 每次 `net_recv_sock` 通过 `ch395f_get_recv_len` 获取硬件缓冲可用数据量（≤4096B），一次性读空
-- 验证模式：递增字节（offset & 0xFF），接收端逐字节比较
+> **注**：PC 端 `--max-conn` 须为**并发**计数（连接关闭即减），否则 Phase 7 全量（701+702+704 共 12 连接）会按累计计数超限而拒掉 4~7（见 Trap 19）。该用例已随 Phase 7 实测 **40/40 PASS** 验证。
---
-## 9. 阶段 8：Select/Poll I/O 多路复用（单连接）
+## 9. 阶段 8：大文件 / 批量传输（100KB，文件收发）
| 阶段 ID | TM-PHY-08 |
|---------|-----------|
-| **类型** | PC 配合，netTask 运行 |
-| **耗时** | 持续运行 |
+| **类型** | PC 配合（PC 作 TCP Client 连接 MCU:8080），netTask 运行 |
+| **耗时** | 取决于文件大小与速率（100KB 约数秒） |
| **入口** | `ENABLE_PHASE8_TESTS` |
+| **配置** | `PHASE8_FILE_SIZE`（默认 102400 = 100KB）；`PHASE8_DIRECTION`（SEND / RECV / ECHO，默认 ECHO） |
+| **PC 配合** | `python ./test/ch395f_socket_test.py tcp_file --ip 192.168.1.100 --port 8080 --op recv --file rx_100k.bin --size 102400`（文件发送）
`... --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`（先连接等待数据）
2. `ENABLE_PHASE8_TESTS`，`PHASE8_FILE_SIZE=102400`，`PHASE8_DIRECTION=SEND`
3. `net_init` 完成，MSS=1024 |
+| **测试步骤** | 1. MCU `net_accept` 建链（PC 已连接）
2. 循环填充一个滑动窗口（≤ s_tx_buf）并调用 `net_send`；`net_send` 内部按硬件发送 FIFO（`NET_SEND_CHUNK_MAX`=1KB，见 Trap 20）自动拆分写入，直至 100KB 发完
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 递增模式）
2. 同 TC-NET-801（`PHASE8_DIRECTION=RECV`） |
+| **测试步骤** | 1. MCU `net_accept` 建链（PC 已连接）
2. 循环 `net_recv`（≤2KB/次，Trap 13 一次读空）→ 按 offset 字节校验 + 累计 CRC32，直至收满 100KB
3. PC 在文件末尾附 4 字节 CRC32（小端）；MCU 收齐后比对 CRC32 |
+| **通过标准** | MCU 收满 102400B，字节校验全过且 CRC32 匹配，无溢出/截断 |
+| **覆盖原则** | DP-04（接收缓冲 2KB 一次读空）、Trap 13 |
+| **实测** | 🟡 待验证（参考：默认递增模式 100KB 的 CRC32 经 SEND 实测为 `0x9A0E0C8C`，RECV 方向 MCU 累计 CRC32 应与之相等） |
+
+### TC-NET-803: 100KB 回显 round-trip（可选）
+
+| 字段 | 值 |
+|------|-----|
+| **ID** | TC-NET-803 |
+| **优先级** | P1 |
+| **类型** | 恢复/压力测试 |
+| **标题** | MCU 发 100KB 经 PC 回显原样返回，MCU 收齐校验 |
+| **前置条件** | MCU: `PHASE8_DIRECTION=ECHO`（net_accept 监听 8080）；PC: `python ./test/ch395f_socket_test.py tcp_file --ip 192.168.1.100 --port 8080 --op echo`（PC 作 Client 连 MCU 并原样回显） |
+| **测试步骤** | MCU 发 100KB → PC 回显 → MCU 收 100KB 字节校验 |
+| **通过标准** | 100KB 全过，验证 100KB 经回显链路完整 |
+| **覆盖原则** | DP-01、DP-04 |
+| **实测** | 🟢 已验证（MCU 收齐 102400B 逐字节校验通过；PC 回显客户端 1241ms @ 80.6 KB/s，对端关闭后正常退出；修复了 phase8_run 未关闭连接导致 MCU 在同连接上无限重复、PC 挂起的问题） |
+
+### 实现说明
+
+`phase8_run()` 状态机（netTestTask，`net_accept` 后执行，`sockfd` 为已建链 fd）：
+
+```
+IDLE → ACCEPT → [SEND: 分块发 → DONE] / [RECV: 分块收+校验 → DONE] / [ECHO: 分块发 → 分块收(回显) → DONE] → 关闭 → 重新 ACCEPT
+```
+
+- **发送**：`phase8_fill(buf, chunk, offset)` 按窗口生成递增模式；`net_send` 经消息队列转发 netTask，由 `net_send_locked` 按发送缓冲(1KB)/`CH395F_SPI_DMA_MAX_PAYLOAD` 自动拆分。
+- **接收**：`net_recv` 每次读 ≤2KB（=接收缓冲，Trap 13 一次读空），`phase8_verify(buf, n, offset)` 字节校验 + 累计 CRC32。
+- **100KB 不整体驻留 RAM**：`s_tx_buf`/`s_rx_buf`=32KB 仅作滑动窗口；`PHASE8_FILE_SIZE` 控制总量。
+- **PC `tcp_file` 子命令**（新增，作 Client 连 MCU:8080）：`recv` 接收 `--size` 字节落盘并校验；`send` 读 `--file` 发送并附 4 字节 CRC32 尾。
+
+---
+
+## 10. 阶段 9：Select/Poll I/O 多路复用（单连接）
+
+| 阶段 ID | TM-PHY-09 |
+|---------|-----------|
+| **类型** | PC 配合，netTask 运行 |
+| **耗时** | 持续运行 |
+| **入口** | `ENABLE_PHASE9_TESTS` |
+
+### TC-NET-901: net_select() 单 socket 就绪检测
+
+| 字段 | 值 |
+|------|-----|
+| **ID** | TC-NET-901 |
+| **优先级** | P0 |
| **类型** | 功能测试 |
| **标题** | `net_select()` 在 Socket 0 数据到达时正确返回 |
| **前置条件** | Socket 0 ESTABLISHED |
@@ -729,11 +967,11 @@ IDLE → (连接建立) → SENDING(分块发) → RECVING(分块收+验证) →
| **通过标准** | 回显成功 |
| **覆盖原则** | DP-02（select 内部调 net_poll） |
-### TC-NET-802: net_select() 超时
+### TC-NET-902: net_select() 超时
| 字段 | 值 |
|------|-----|
-| **ID** | TC-NET-802 |
+| **ID** | TC-NET-902 |
| **优先级** | P1 |
| **类型** | 负向测试 |
| **标题** | 100ms 超时内无数据则返回 0 |
@@ -743,19 +981,19 @@ IDLE → (连接建立) → SENDING(分块发) → RECVING(分块收+验证) →
---
-## 10. 阶段 9：边界条件测试
+## 11. 阶段 10：边界条件测试
-| 阶段 ID | TM-PHY-09 |
+| 阶段 ID | TM-PHY-10 |
|---------|-----------|
| **类型** | PC 配合，netTask 运行 |
| **耗时** | 按需 |
-| **入口** | `ENABLE_PHASE9_TESTS` |
+| **入口** | `ENABLE_PHASE10_TESTS` |
-### TC-NET-901: DMA 边界 −1（4095 字节）
+### TC-NET-1001: DMA 边界 −1（4095 字节）
| 字段 | 值 |
|------|-----|
-| **ID** | TC-NET-901 |
+| **ID** | TC-NET-1001 |
| **优先级** | P0 |
| **类型** | 边界测试 |
| **标题** | 发送 4095 字节（SPI 最大载荷 −1，单次 DMA 可容纳） |
@@ -764,11 +1002,11 @@ IDLE → (连接建立) → SENDING(分块发) → RECVING(分块收+验证) →
| **通过标准** | 4095B 完全匹配 |
| **覆盖原则** | DP-04 |
-### TC-NET-902: DMA 边界（4096 字节）
+### TC-NET-1002: DMA 边界（4096 字节）
| 字段 | 值 |
|------|-----|
-| **ID** | TC-NET-902 |
+| **ID** | TC-NET-1002 |
| **优先级** | P0 |
| **类型** | 边界测试 |
| **标题** | 发送 4096 字节（等于 SPI 最大载荷，填满单次 DMA） |
@@ -776,11 +1014,11 @@ IDLE → (连接建立) → SENDING(分块发) → RECVING(分块收+验证) →
| **通过标准** | 4096B 完全匹配 |
| **覆盖原则** | DP-04 |
-### TC-NET-903: DMA 边界 +1（4097 字节）
+### TC-NET-1003: DMA 边界 +1（4097 字节）
| 字段 | 值 |
|------|-----|
-| **ID** | TC-NET-903 |
+| **ID** | TC-NET-1003 |
| **优先级** | P0 |
| **类型** | 边界测试 |
| **标题** | 发送 4097 字节（超过 SPI 最大载荷，自动拆两次 DMA：4096+1） |
@@ -788,33 +1026,33 @@ IDLE → (连接建立) → SENDING(分块发) → RECVING(分块收+验证) →
| **通过标准** | 4097B 完全匹配，两次 DMA 无缝衔接 |
| **覆盖原则** | DP-04 |
-### TC-NET-904: 零长度收发
+### TC-NET-1004: 零长度收发
| 字段 | 值 |
|------|-----|
-| **ID** | TC-NET-904 |
+| **ID** | TC-NET-1004 |
| **优先级** | P1 |
| **类型** | 负向测试 |
| **标题** | `net_send_sock(sk, buf, 0)` 返回 −1 |
| **测试步骤** | `net_send_sock(sk, s_phase9_tx, 0)` |
| **通过标准** | 返回 < 0，无崩溃 |
-### TC-NET-905: 连续快速发送 20 小包
+### TC-NET-1005: 连续快速发送 20 小包
| 字段 | 值 |
|------|-----|
-| **ID** | TC-NET-905 |
+| **ID** | TC-NET-1005 |
| **优先级** | P1 |
| **类型** | 压力测试 |
| **标题** | 20 × 100 字节连续快速发送（验证 SENDBUF_FREE 等待机制） |
| **测试步骤** | 循环 20 次：`net_send_sock(sk, buf, 100)`，间隔 1ms |
| **通过标准** | 20/20 成功，回显 2000B 完全匹配 |
-### TC-NET-906: 快速连接-断开 ×20 轮
+### TC-NET-1006: 快速连接-断开 ×20 轮
| 字段 | 值 |
|------|-----|
-| **ID** | TC-NET-906 |
+| **ID** | TC-NET-1006 |
| **优先级** | P1 |
| **类型** | 稳定性测试 |
| **标题** | 20 次快速连接-断开循环 |
@@ -823,20 +1061,20 @@ IDLE → (连接建立) → SENDING(分块发) → RECVING(分块收+验证) →
---
-## 11. 阶段 10：KeepAlive 超时断开
+## 12. 阶段 11：KeepAlive 超时断开
-| 阶段 ID | TM-PHY-10 |
+| 阶段 ID | TM-PHY-11 |
|---------|-----------|
| **类型** | PC 配合，netTask 运行 |
| **耗时** | ~65 秒（60s idle + 15s probes） |
-| **入口** | `ENABLE_PHASE10_TESTS` |
+| **入口** | `ENABLE_PHASE11_TESTS` |
| **配置** | KeepAlive 空闲 60s，探测间隔 5s，3 次 |
-### TC-NET-1001: KeepAlive 触发断开
+### TC-NET-1101: KeepAlive 触发断开
| 字段 | 值 |
|------|-----|
-| **ID** | TC-NET-1001 |
+| **ID** | TC-NET-1101 |
| **优先级** | P1 |
| **类型** | 功能测试 |
| **标题** | TCP 连接空闲超过 KeepAlive 阈值后自动断开 |
@@ -846,16 +1084,17 @@ IDLE → (连接建立) → SENDING(分块发) → RECVING(分块收+验证) →
---
-## 12. Python 测试脚本参考
+
+
+## 13. Python 测试脚本参考
| 命令 | 模式 | 说明 |
|------|------|------|
-| `tcp_server --port 8081` | PC 作 TCP 回显服务器（多连接循环） | 测试 TCP Client（阶段 2 硬件层；阶段 6 Client 扩展 607/608/609） |
+| `tcp_server --port 8081` | PC 作 TCP 回显服务器（回显循环） | 测试 TCP Client（阶段 2 硬件层；阶段 7 Client 701/702/703） |
| `tcp_client --ip ... --port 8080` | PC 作 TCP Client | 测试 TCP Echo（阶段 6/8/9） |
| `tcp_file --ip ... --port 8080 --size 20480` | PC 作文件接收 | 测试大文件传输（阶段 7） |
| `udp_client --ip ... --port 60000` | PC 作 UDP Client | 测试 UDP Echo（阶段 3） |
| `udp_server --port 8082` | PC 作 UDP Server | 接收 CH395F UDP 数据 |
-| `stress --ip ... --port 8080 --count 10` | 压力测试 | 7 并发 × 10 轮 |
| `dhcp_server ...` | DHCP Server | 内置 DHCP（阶段 4，需管理员权限） |
### 通用参数
@@ -870,12 +1109,10 @@ IDLE → (连接建立) → SENDING(分块发) → RECVING(分块收+验证) →
---
-## 13. 已知陷阱
+## 14. 已知陷阱
| ID | 陷阱 | 现象 | 修复 |
|----|------|------|------|
-| TRAP-01 | ~~多连接初始化顺序~~ | 已废弃（单连接模式） | — |
-| TRAP-02 | ~~数据 socket 缓冲重叠~~ | 已废弃（单连接模式） | — |
| TRAP-03 | DHCP xid 偏移错误 | DHCP 握手失败 | xid 在 `data[4:8]` |
| TRAP-04 | UDP 无 SENDBUF_FREE 等待 | 后续接收挂起 | 每次 write 后等 SENDBUF_FREE |
| TRAP-05 | PHY 不兼容 RTL8305NBI | 链路抖动 | `ch395f_set_phy(0x08)` 强制 100M_FULL |
@@ -891,7 +1128,7 @@ IDLE → (连接建立) → SENDING(分块发) → RECVING(分块收+验证) →
---
-## 附录 A：通过/失败汇总
+## 附录 B：通过/失败汇总
| 阶段 | TC ID | 优先级 | 类型 | 状态 |
|------|-------|--------|------|------|
@@ -906,45 +1143,47 @@ IDLE → (连接建立) → SENDING(分块发) → RECVING(分块收+验证) →
| TM-PHY-04 | TC-NET-402 | P1 | 功能测试 | ✅ |
| TM-PHY-05 | TC-NET-501 | P0 | 功能测试 | ✅ |
| TM-PHY-05 | TC-NET-502 | P1 | 合规测试 | ✅ |
-| TM-PHY-06 | TC-NET-601 | P0 | 功能测试 | 🟡 |
-| TM-PHY-06 | TC-NET-602 | P0 | 功能测试 | 🟡 |
-| TM-PHY-06 | TC-NET-603 | P0 | 边界测试 | 🟡 |
-| TM-PHY-06 | TC-NET-604 | P0 | 边界测试 | 🟡 |
-| TM-PHY-06 | TC-NET-605 | P0 | 恢复测试 | 🟡 |
-| TM-PHY-06 | TC-NET-606 | P1 | 恢复测试 | 🟡 |
-| TM-PHY-06 | TC-NET-607 | P0 | 功能测试 | 🟠 |
-| TM-PHY-06 | TC-NET-608 | P0 | 恢复测试 | 🟠 |
-| TM-PHY-06 | TC-NET-609 | P1 | 负向测试 | 🟠 |
-| TM-PHY-07 | TC-NET-701 | P0 | 功能测试 | 🟡 |
-| TM-PHY-07 | TC-NET-702 | P1 | 边界测试 | 🟡 |
-| TM-PHY-08 | TC-NET-801 | P0 | 功能测试 | 🟡 |
-| TM-PHY-08 | TC-NET-802 | P1 | 负向测试 | 🟡 |
-| TM-PHY-09 | TC-NET-901 | P0 | 边界测试 | 🟡 |
-| TM-PHY-09 | TC-NET-902 | P0 | 边界测试 | 🟡 |
-| TM-PHY-09 | TC-NET-903 | P0 | 边界测试 | 🟡 |
-| TM-PHY-09 | TC-NET-904 | P1 | 负向测试 | 🟡 |
-| TM-PHY-09 | TC-NET-905 | P1 | 压力测试 | 🟡 |
-| TM-PHY-09 | TC-NET-906 | P1 | 稳定性测试 | 🟡 |
-| TM-PHY-10 | TC-NET-1001 | P1 | 功能测试 | 🟡 |
+| TM-PHY-06 | TC-NET-601 | P0 | 功能测试 | ✅ |
+| TM-PHY-06 | TC-NET-602 | P0 | 功能测试 | ✅ |
+| TM-PHY-06 | TC-NET-603 | P0 | 边界测试 | ✅ |
+| TM-PHY-06 | TC-NET-604 | P0 | 边界测试 | ✅ |
+| TM-PHY-06 | TC-NET-605 | P0 | 恢复测试 | ✅ |
+| TM-PHY-06 | TC-NET-606 | P1 | 恢复测试 | ✅ |
+| TM-PHY-07 | TC-NET-701 | P0 | 功能测试 | ✅ |
+| TM-PHY-07 | TC-NET-702 | P0 | 恢复测试 | ✅ |
+| TM-PHY-07 | TC-NET-703 | P1 | 负向测试 | ✅ |
+| TM-PHY-07 | TC-NET-704 | P0 | 并发测试 | ✅ |
+| TM-PHY-08 | TC-NET-801 | P0 | 文件发送 | ✅ |
+| TM-PHY-08 | TC-NET-802 | P0 | 文件接收 | 🟡 |
+| TM-PHY-08 | TC-NET-803 | P1 | 回显/压力 | 🟡 |
+| TM-PHY-09 | TC-NET-901 | P0 | 功能测试 | 🟡 |
+| TM-PHY-09 | TC-NET-902 | P1 | 负向测试 | 🟡 |
+| TM-PHY-10 | TC-NET-1001 | P0 | 边界测试 | 🟡 |
+| TM-PHY-10 | TC-NET-1002 | P0 | 边界测试 | 🟡 |
+| TM-PHY-10 | TC-NET-1003 | P0 | 边界测试 | 🟡 |
+| TM-PHY-10 | TC-NET-1004 | P1 | 负向测试 | 🟡 |
+| TM-PHY-10 | TC-NET-1005 | P1 | 压力测试 | 🟡 |
+| TM-PHY-10 | TC-NET-1006 | P1 | 稳定性测试 | 🟡 |
+| TM-PHY-11 | TC-NET-1101 | P1 | 功能测试 | 🟡 |
✅ = 已实现并验证 | 🟡 = 已实现待验证 | 🟠 = 待实现
-## 附录 B：设计原则覆盖
+## 附录 C：设计原则覆盖
| 原则 | 覆盖用例 |
|------|----------|
-| DP-01：单 socket 生命周期 | TC-NET-202, 203, 601, 605, 606, 906 |
-| DP-02：中断即读即清 | TC-NET-101, 102, 501, 502, 801 |
+| DP-01：单 socket 生命周期 | TC-NET-202, 203, 601, 605, 606, 701, 702, 703, 704, 801, 802, 901, 902, 1001~1006 |
+| DP-02：中断即读即清 | TC-NET-101, 102, 501, 502, 901 |
| DP-03：消息队列线程安全 | TC-NET-301, 302, 401 |
-| DP-04：DMA 边界安全 | TC-NET-501, 502, 603, 604, 701, 702, 901, 902, 903, 904, 905 |
+| DP-04：DMA 边界安全 | TC-NET-501, 502, 603, 604, 801, 802, 1001~1005 |
-## 附录 C：CH395F 边界条件速查
+## 附录 D：CH395F 边界条件速查
| 操作 | 大小 | 行为 |
|------|------|------|
| `net_send(buf, ≤1496)` | 1~1496B | 单次 DMA 事务（旧 DMABUF=1500 时完全容纳） |
| `net_send(buf, 1497~4096)` | 1497~4096B | 旧代码**静默失败**；现 DMABUF=4100 **一次 DMA 容纳** |
-| `net_send(buf, 4097~65535)` | >4096B | `net_send_locked` **自动分块**，每块 4096B |
+| `net_send(buf, 4097~65535)` | >4096B | `net_send_locked` **自动分块**（受单 Socket 发送缓冲 1KB 约束；当前按 `NET_DMA_MAX_PAYLOAD=4096` 拆分，需实测） |
| `net_send(buf, 0)` | 0 | 返回 `-1`（`NET_ERR_INVAL`） |
| `ch395f_get_recv_len()` | 0~65535 | 返回 CH395F 硬件缓冲当前可用数据量 |
| `ch395f_read_recv_buf(buf, 4096)` | 4096B | 一次性读空 Socket 0 整个接收缓冲 |
diff --git a/docs/CH395F_Trap_Records.md b/docs/CH395F_Trap_Records.md
index 9666519..8674c40 100644
--- 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。
diff --git a/rx_100k.bin b/rx_100k.bin
new file mode 100644
index 0000000..db15ba9
Binary files /dev/null and b/rx_100k.bin differ
diff --git a/test/__pycache__/ch395f_socket_test.cpython-311.pyc b/test/__pycache__/ch395f_socket_test.cpython-311.pyc
index 75c05f7..c9fd4a1 100644
Binary files a/test/__pycache__/ch395f_socket_test.cpython-311.pyc and b/test/__pycache__/ch395f_socket_test.cpython-311.pyc differ
diff --git a/test/ch395f_socket_test.py b/test/ch395f_socket_test.py
index 6575974..dcb6353 100644
--- 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）
@@ -41,8 +42,13 @@ CH395F BSD Socket API 测试程序
# 压力测试（多连接）
python ch395f_socket_test.py stress --ip 192.168.1.100 --port 8080 --count 7
- # 阶段 5 双向大块（先收 256KB 再回放 256KB）
- python ch395f_socket_test.py tcp_bulk --port 8081 --bulk 262144 --chunk 4096
+ # 阶段 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 秒；之后每个连接间最多等待
- INTER_ACCEPT_TIMEOUT 秒，无新连接则结束并汇总。
- 返回 False 表示失败（无连接或回显出错），main 据此返回非 0 退出码。
+ 首个连接等待 args.timeout 秒；之后每个连接间最多等待 INTER_ACCEPT_TIMEOUT 秒；
+ 若指定 --max-conn（>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
- echo_bytes = 0
- conn_errors = 0
+ counters = {'total': 0, 'bytes': 0, 'errors': 0, 'active': 0}
+ lock = threading.Lock()
+ threads = []
try:
server_socket.bind(('0.0.0.0', args.port))
- server_socket.listen(4)
- log_success(f"服务器启动，监听端口 {args.port}")
+ server_socket.listen(16)
+ 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)
- rx = 0
- try:
- while True:
- data = client_socket.recv(4096)
- if not data:
- log_info(f"[连接{conn_idx}] 对端已关闭")
- break
- client_socket.sendall(data)
- rx += len(data)
- except socket.timeout:
- log_warn(f"[连接{conn_idx}] 空闲超时，关闭连接")
- except Exception as e:
- log_error(f"[连接{conn_idx}] 回显错误: {e}")
- conn_errors += 1
- finally:
- client_socket.close()
-
- if rx > 0:
- log_success(f"连接#{conn_idx} 完成: 回显 {rx} 字节")
- else:
- log_warn(f"连接#{conn_idx} 未收到任何数据")
- conn_errors += 1
- echo_bytes += rx
- conn_total += 1
+ # 等待所有连接线程结束（对端关闭或空闲超时）
+ for t in threads:
+ t.join()
log_info("-" * 40)
- log_info(f"服务结束: 连接 {conn_total} 个, 回显 {echo_bytes} 字节, 异常 {conn_errors} 次")
- if conn_total == 0:
+ log_info(f"服务结束: 连接 {counters['total']} 个, 回显 {counters['bytes']} 字节, 异常 {counters['errors']} 次")
+ 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))
- client_socket.send(large_data)
- log_success(f"发送大数据 ({len(large_data)} bytes)")
+ test_data = gen_pattern(1460, pkt_offset)
+ pkt_offset += 1460
+ client_socket.send(test_data)
+ log_success(f"发送 1460B ({len(test_data)} bytes)")
received = b""
- while len(received) < len(large_data):
- chunk = client_socket.recv(min(1024, len(large_data) - len(received)))
+ while len(received) < len(test_data):
+ chunk = client_socket.recv(min(1460, len(test_data) - len(received)))
if not chunk:
break
received += chunk
- if received == large_data:
- log_success("大数据传输完整!")
+ if received == test_data:
+ 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: 快速收发")
- success_count = 0
- fail_count = 0
- start_time = time.time()
+ log_info("测试 3: 4096B 缓冲满回显 (TC-NET-604)")
+ try:
+ # 单 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)
+ log_success(f"发送 4096B ({len(test_data)} bytes)")
- for i in range(args.count):
- try:
- test_data = f"FAST_{i:04d}".encode()
- client_socket.send(test_data)
- data = client_socket.recv(100)
- if data and data == test_data:
- success_count += 1
- else:
- fail_count += 1
- except Exception as e:
- fail_count += 1
+ received = b""
+ while len(received) < len(test_data):
+ chunk = client_socket.recv(min(4096, len(test_data) - len(received)))
+ if not chunk:
+ break
+ received += chunk
- elapsed = time.time() - start_time
- log_info(f"快速收发结果: 成功 {success_count}, 失败 {fail_count}, 耗时 {elapsed:.2f}s")
+ 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(' {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,8 +1255,8 @@ 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'],
- help='测试模式')
+ '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='端口号')
parser.add_argument('--count', type=int, default=10, 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:
diff --git a/test/ch395f_test.h b/test/ch395f_test.h
index 47b999b..c579ae2 100644
--- 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 8 | NET 层 | testTask：Select/Poll I/O 多路复用
- * Phase 9 | NET 层 | testTask：边界条件测试（零长度、DMA 边界、缓冲溢出）
- * Phase 10 | NET 层 | testTask：KeepAlive 超时断开测试
+ * Phase 7 | NET 层 | testTask：TCP Client 主动连接（回显收发 + 关闭重连 + 连接超时）
+ * Phase 8 | NET 层 | testTask：大文件传输（20KB+ 分块收发）
+ * Phase 9 | NET 层 | testTask：Select/Poll I/O 多路复用
+ * 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 配合） */
-/* ---- NET 层（阶段 6~10）---- */
+//#define ENABLE_PHASE5_TESTS /* [硬] 大文件传输（硬件层，PC 配合） */
+/* ---- NET 层（阶段 6~11）---- */
//#define ENABLE_PHASE6_TESTS /* [网] TCP Echo（单连接基础收发） */
-//#define ENABLE_PHASE7_TESTS /* [网] 大文件传输（20KB+ 分块） */
-//#define ENABLE_PHASE8_TESTS /* [网] Select/Poll I/O 多路复用 */
-//#define ENABLE_PHASE9_TESTS /* [网] 边界条件测试 */
-//#define ENABLE_PHASE10_TESTS /* [网] KeepAlive 超时断开测试 */
+//#define ENABLE_PHASE7_TESTS /* [网] TCP Client 主动连接（回显收发 + 关闭重连 + 连接超时） */
+#define ENABLE_PHASE8_TESTS /* [网] 大文件传输（100KB 文件收发） */
+//#define ENABLE_PHASE9_TESTS /* [网] Select/Poll I/O 多路复用 */
+//#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
/* 测试统计 */
diff --git a/test/ch395f_test_task.c b/test/ch395f_test_task.c
index bc97ed4..bdde144 100644
--- 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
#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,133 +1352,42 @@ 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 {
+ /* ==================== 阻塞阶段 ====================
+ * Phase 1~5（硬件层）在 TCP 监听之前执行，不依赖外部连接。
+ * 各 Phase 有各自的测试逻辑，完成后继续下一 Phase。
+ */
+#ifdef ENABLE_PHASE1_TESTS
+ phase1_run();
+#endif
+#ifdef ENABLE_PHASE2_TESTS
+ phase2_run();
+#endif
+#ifdef ENABLE_PHASE3_TESTS
+ phase3_run();
+#endif
+#ifdef ENABLE_PHASE4_TESTS
+ phase4_run();
+#endif
+#ifdef ENABLE_PHASE5_TESTS
+ phase5_run();
+#endif
}
#else
- /* NET 层模式（阶段 6~10）：等待 netTask 完成 net_init() 及 CH395F 初始化 */
+ /* NET 层模式（阶段 6~11）：等待 netTask 完成 net_init() 及 CH395F 初始化。
+ * Phase 7（TCP Client）与阶段 6/8~11（TCP Server 监听循环）互斥，
+ * 二者共用单连接 Socket 0，故按宏选择入口。 */
while (!g_net_ready) {
osDelay(100);
}
DBG_INFO("netTask ready");
+#if defined(ENABLE_PHASE7_TESTS)
+ net_layer_client_test_main();
+#else
+ net_layer_test_main();
+#endif
#endif
- /* ==================== 阻塞阶段 ====================
- * Phase 1~5（硬件层）在 TCP 监听之前执行，不依赖外部连接。
- * 各 Phase 有各自的测试逻辑，完成后继续下一 Phase。
- */
-#ifdef ENABLE_PHASE1_TESTS
- phase1_run();
-#endif
-#ifdef ENABLE_PHASE2_TESTS
- phase2_run();
-#endif
-#ifdef ENABLE_PHASE3_TESTS
- phase3_run();
-#endif
-#ifdef ENABLE_PHASE4_TESTS
- phase4_run();
-#endif
-#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);
-
- {
- 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");
- 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;
- phase_active = 1;
- DBG_INFO("Test task: client accepted (fd=%d)", acc);
-
- /* 连接建立，重置各 Phase 内部状态 */
-#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);
}
diff --git a/test/net_test_task.c b/test/net_test_task.c
new file mode 100644
index 0000000..43dc844
--- /dev/null
+++ 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
+#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);
+ }
+}
diff --git a/test/net_test_task.h b/test/net_test_task.h
new file mode 100644
index 0000000..f5ed5c9
--- /dev/null
+++ 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 */