网络主要内容测试完成
This commit is contained in:
@@ -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();
|
||||
|
||||
@@ -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) {
|
||||
|
||||
@@ -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)
|
||||
|
||||
/* 其他命令 */
|
||||
|
||||
@@ -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;
|
||||
|
||||
@@ -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;
|
||||
|
||||
/* 参数检<EFBFBD>?*/
|
||||
/* 参数检查 */
|
||||
if (sockfd < 0 || sockfd >= NET_MAX_SOCKETS) {
|
||||
s_net_errno = NET_ERR_BADF;
|
||||
return -1;
|
||||
@@ -690,24 +778,56 @@ int net_connect(int sockfd, const struct net_sockaddr *addr, int addrlen) {
|
||||
p_sock->remote_ip = p_addr_in->sin_addr.s_addr;
|
||||
p_sock->remote_port = net_ntohs(p_addr_in->sin_port);
|
||||
|
||||
/* 转换 IP 为数组格式（低字节在前） */
|
||||
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 为数组格<EFBFBD>?*/
|
||||
/* 转换 IP 为大端数组（同 TCP 客户端，set_des_ip 期望大端） */
|
||||
uint8_t ip_arr[4];
|
||||
uint32_t ip = p_addr_in->sin_addr.s_addr;
|
||||
ip_arr[0] = (uint8_t)(ip);
|
||||
ip_arr[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,
|
||||
/* 发送数<E98081>?*/
|
||||
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;
|
||||
|
||||
/* 参数检<E695B0>?*/
|
||||
@@ -1172,7 +1394,7 @@ int net_recvfrom(int sockfd, void *buf, int len, int flags,
|
||||
|
||||
/* 读取数据 */
|
||||
if (recv_len > 0) {
|
||||
int read_len = (recv_len > (uint16_t)len) ? len : (int)recv_len;
|
||||
int read_len = (recv_len > len) ? len : recv_len;
|
||||
ch395f_read_recv_buf(sockfd, (uint8_t *)buf, (uint16_t)read_len);
|
||||
p_sock->recv_bytes += (uint32_t)read_len;
|
||||
return read_len;
|
||||
@@ -1505,6 +1727,7 @@ static void handle_disconnect_event(net_sock_t *p_sock) {
|
||||
static void handle_recv_event(net_sock_t *p_sock) {
|
||||
/* RECV_OK 中断已触发，直接通知上层。不在此读 recv_len，
|
||||
* 避免和 net_recv_locked 里面的 ch395f_get_recv_len 冲突（Trap 13） */
|
||||
p_sock->readable = 1; /* 置可读标志，供 net_select 在无 SPI 访问下判读 */
|
||||
fire_event(p_sock, NET_EVENT_DATA_RECEIVED);
|
||||
}
|
||||
|
||||
|
||||
@@ -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; /* 累计发送字节数 */
|
||||
|
||||
@@ -2009,6 +2009,11 @@
|
||||
<FileType>1</FileType>
|
||||
<FilePath>..\test\ch395f_test_task.c</FilePath>
|
||||
</File>
|
||||
<File>
|
||||
<FileName>net_test_task.c</FileName>
|
||||
<FileType>1</FileType>
|
||||
<FilePath>..\test\net_test_task.c</FilePath>
|
||||
</File>
|
||||
</Files>
|
||||
</Group>
|
||||
<Group>
|
||||
|
||||
@@ -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
|
||||
|
||||
@@ -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 数据
|
||||
|
||||
|
||||
@@ -2,57 +2,75 @@
|
||||
|
||||
## 1. 概述
|
||||
|
||||
本文档定义 CH395F 以太网驱动（STM32F407ZGTx，SPI2 接口）在**单连接 socket 模式**下的测试规范。测试按阶段（TM-PHY-NN）组织，每个阶段包含独立测试用例（TC-NET-NNN）。
|
||||
本文档定义 CH395F 以太网驱动（STM32F407ZGTx，SPI2 接口）的测试规范。当前固件运行于**多 Socket 模式**（`FUN_PARA=0x09`：8 个 Socket 0~7 全部可用，Socket 0 作 TCP Server 单连接），覆盖单连接与多并发客户端场景。测试按阶段（TM-PHY-NN）组织，每个阶段包含独立测试用例（TC-NET-NNN）。
|
||||
|
||||
### 设计原则
|
||||
|
||||
| 原则 | 描述 | 验证用例 |
|
||||
|------|------|----------|
|
||||
| DP-01 | 单连接 socket：Socket 0 唯一，复用监听和数据通道；CONNECT 后切换数据通道；DISCONNECT/TIMEOUT 后重新 OPEN → LISTEN | TC-NET-201~203, 601~609, 906 |
|
||||
| DP-01 | 单连接 socket：Socket 0 唯一，复用监听和数据通道；CONNECT 后切换数据通道；DISCONNECT/TIMEOUT 后重新 OPEN → LISTEN | TC-NET-201~203, 601~606, 701~703, 801, 802, 901, 902, 1001~1006 |
|
||||
| DP-02 | 中断集中处理：所有 CH395F 中断在 `net_poll()` 中通过 `GET_GLOB_INT_STATUS` 统一读取并清除，ISR 及其他位置不处理 | TC-NET-101 |
|
||||
| DP-03 | 线程安全：所有 CH395F 操作通过 `netMsgQueue` 在 netTask 串行处理 | TC-NET-301~302 |
|
||||
| DP-04 | DMA 边界安全：`CH395F_SPI_DMA_BUF_SIZE=4100`，单次事务最大载荷 `4096B`，超限自动分块 | TC-NET-901~905 |
|
||||
| DP-04 | DMA 边界安全：`CH395F_SPI_DMA_BUF_SIZE=4100`，单次事务最大载荷 `4096B`，超限自动分块 | TC-NET-1001~1005 |
|
||||
|
||||
### CH395F 缓冲架构（关键参数）
|
||||
|
||||
| 参数 | 值 | 说明 |
|
||||
|------|-----|------|
|
||||
| CH395F 内部总缓冲 | 32KB（32 块 × 1KB） | Socket 0~3 各 4KB 默认 |
|
||||
| Socket 0 发送缓冲 | 4096B（硬件默认） | 未显式配置时使用 |
|
||||
| Socket 0 接收缓冲 | 4096B（硬件默认） | 未显式配置时使用 |
|
||||
| CH395F 内部总缓冲 | **24KB（48 块 × 512B）** | 手册 §5.45；CH395F.md "内置 24K RAM"。**经 Phase 7 实测确认块 0~47 全部有效**（此前 32×1KB 记录有误） |
|
||||
| 上电默认分配 | Socket 0~3 各 接收8块(4KB)+发送4块(2KB)；Socket 4~7 未分配 | 见 §5.45，用到 >4 个 Socket 必须重分配 |
|
||||
| **本固件分配（net_init）** | 8 个 Socket 各 **接收 4 块(2KB) + 发送 2 块(1KB)** | 块数由 `CH395F_TCP_MSS` 推导（接收 `CH395F_RECV_BLOCKS`=2×MSS、发送 `CH395F_SEND_BLOCKS`=1×MSS，每块 512B）；起始块 `recv=i*6`、`send=i*6+4`；用尽 0~47，互不重叠 |
|
||||
| **TCP MSS** | **1024** | 由接收缓冲(2KB) ≥ 2×MSS 决定，8 Socket 共享 24KB 时的最大值 |
|
||||
| **SPI DMA 缓冲** | **4100B** | `CH395F_SPI_DMA_BUF_SIZE` |
|
||||
| **单次 SPI 最大载荷** | **4096B** | `CH395F_SPI_DMA_MAX_PAYLOAD` |
|
||||
| 单次 net_send 最大分块 | 4096B | 超限自动分多次 DMA |
|
||||
| recv_len 最大值 | 65535 | `uint16_t` |
|
||||
|
||||
> **关键约束**：CH395F 硬件接收缓冲 4096B。`recv_len` 在调 `read_recv_buf` 读取**部分**数据后归零（Trap 13）。因此每次接收调用需确保 `read_len >= recv_len`，或增大 DMA 缓冲以一次性读空。当前 `CH395F_SPI_DMA_BUF_SIZE=4100` 可覆盖完整 4096B 接收缓冲。
|
||||
> **关键约束**：本固件每个 Socket 接收缓冲为 **2KB**（4 块 × 512B），发送缓冲为 **1KB**（2 块）。`recv_len` 在调 `read_recv_buf` 读取**部分**数据后归零（Trap 13），故每次接收应一次性读空当前可用数据（≤2KB）。`CH395F_SPI_DMA_BUF_SIZE=4100` 足以覆盖单 Socket 完整 2KB 接收缓冲。
|
||||
|
||||
### 多 Socket / 8 端口并发分配
|
||||
|
||||
`net_init` 中 `ch395f_set_fun_para(0x09)` 启用 8 个 Socket 后，循环 0~7 调用 `SET_RECV_BUF` / `SET_SEND_BUF` 重分配（必须在 `OPEN_SOCKET` 之前，顺序遵循 Trap 01：先数据 Socket 1~7 再监听 Socket 0）：
|
||||
|
||||
| Socket | 接收起始块 | 接收块数 | 接收大小 | 发送起始块 | 发送块数 | 发送大小 |
|
||||
|--------|-----------|---------|---------|-----------|---------|---------|
|
||||
| 0 | 0 | 4 | 2KB | 4 | 2 | 1KB |
|
||||
| 1 | 6 | 4 | 2KB | 10 | 2 | 1KB |
|
||||
| 2 | 12 | 4 | 2KB | 16 | 2 | 1KB |
|
||||
| 3 | 18 | 4 | 2KB | 22 | 2 | 1KB |
|
||||
| 4 | 24 | 4 | 2KB | 28 | 2 | 1KB |
|
||||
| 5 | 30 | 4 | 2KB | 34 | 2 | 1KB |
|
||||
| 6 | 36 | 4 | 2KB | 40 | 2 | 1KB |
|
||||
| 7 | 42 | 4 | 2KB | 46 | 2 | 1KB |
|
||||
|
||||
UDP 路径 `net_socket()` 中对 Socket 4~7 的兜底重设使用同一布局。该分配已通过 **Phase 7 TC704（8 Socket 并发回显，40/40 PASS）** 验证。
|
||||
|
||||
### 大文件传输（20KB+）策略
|
||||
|
||||
单连接模式下，超过 Socket 0 硬件缓冲（4KB）的数据通过以下机制传输：
|
||||
多 Socket 模式下，每个 Socket 拥有独立收发缓冲（接收 2KB / 发送 1KB，见上表）。超过单 Socket 接收缓冲（2KB）的数据通过分块传输：
|
||||
|
||||
```
|
||||
发送端：net_send(buf, 20480)
|
||||
→ net_send_locked 分块，每块 ≤ 4096B
|
||||
→ 块 1: ch395f_write_send_buf(sock, buf[0..4095], 4096) // DMA 事务 1
|
||||
→ 等待 SENDBUF_FREE
|
||||
→ 块 2: ch395f_write_send_buf(sock, buf[4096..8191], 4096) // DMA 事务 2
|
||||
→ net_send_locked 分块写入 CH395F 发送缓冲（每 Socket 发送缓冲 1KB）
|
||||
→ 块 1: ch395f_write_send_buf(sock, buf[0..1023], 1024) // DMA 事务 1
|
||||
→ 等待 SENBUF_FREE
|
||||
→ 块 2: ch395f_write_send_buf(sock, buf[1024..2047], 1024) // DMA 事务 2
|
||||
→ ...
|
||||
→ 共 5 次 DMA 事务完成 20KB
|
||||
→ 共 20 次 DMA 事务完成 20KB（MSS=1024，TCP 每段 ≤1024B）
|
||||
|
||||
接收端：net_recv(buf, 20480)
|
||||
→ net_recv_locked 循环拉取
|
||||
→ ch395f_get_recv_len() 返回硬件缓冲中当前可用数据（≤4096B）
|
||||
→ ch395f_read_recv_buf() 一次性读空硬件缓冲（≤4096B/DMA 事务）
|
||||
→ ch395f_get_recv_len() 返回硬件缓冲中当前可用数据（≤2KB）
|
||||
→ ch395f_read_recv_buf() 一次性读空硬件缓冲（≤2KB/DMA 事务）
|
||||
→ 循环直至全部 20480B 收完
|
||||
```
|
||||
|
||||
**边界条件**：
|
||||
- 发送 `≤4096B`：一次 DMA 事务完成
|
||||
- 发送 `4097B`：两次 DMA 事务（4096 + 1）
|
||||
- 接收缓冲满（4096B）：必须一次性读空，否则 `recv_len` 归零导致剩余数据丢失
|
||||
- 发送 `≤1KB`：一次写发送缓冲完成（受发送缓冲 1KB 限制）
|
||||
- 接收缓冲满（2KB）：必须一次性读空，否则 `recv_len` 归零导致剩余数据丢失（Trap 13）
|
||||
- 发送 `0B`：`net_send` 返回 `-1`（`NET_ERR_INVAL`）
|
||||
|
||||
> **注**：当前 `net_send` 的分块上限常量 `NET_DMA_MAX_PAYLOAD=4096` 大于单 Socket 发送缓冲(1KB)，单次 `WRITE_SEND_BUF` 写入量受发送缓冲大小约束；大文件传输（Phase 6/8/10）需在硬件上实测确认无溢出。
|
||||
|
||||
### 测试环境
|
||||
|
||||
```
|
||||
@@ -67,13 +85,13 @@ MCU: STM32F407ZGTx @ 168MHz, Keil MDK-ARM v5 (ARMCC)
|
||||
| 构建模式 | 启用宏 | 固件形态 |
|
||||
|----------|--------|----------|
|
||||
| **硬件层模式** | `ENABLE_PHASE1~5_TESTS` | **netTask 不创建**，CH395F 协议栈初始化由 ch395fTestTask 完成后独占芯片执行阶段 1~5（裸调 `ch395f_*` 命令） |
|
||||
| **NET 层模式** | `ENABLE_PHASE6~10_TESTS` | 完整网络栈：netTask 运行 `net_poll()` 轮询，testTask 经 `net_socket` API 在 TCP 监听循环中执行阶段 6~10 |
|
||||
| **NET 层模式** | `ENABLE_PHASE6~11_TESTS` | 完整网络栈：netTask 运行 `net_poll()` 轮询，testTask 经 `net_socket` API 执行阶段 6~11（`net_layer_test_main()` 回显、`net_layer_client_test_main()` Client 等） |
|
||||
|
||||
**执行顺序严格递增**：先烧录硬件层固件完成阶段 1→2→3→4→5（全部通过），再切换为 NET 层固件执行阶段 6→…→10。硬件层测试期间 netTask 轮询不存在，从根上排除中断偷取与 SPI 并发问题。
|
||||
**执行顺序严格递增**：先烧录硬件层固件完成阶段 1→2→3→4→5（全部通过），再切换为 NET 层固件执行阶段 6→7→…→11。硬件层测试期间 netTask 轮询不存在，从根上排除中断偷取与 SPI 并发问题。
|
||||
|
||||
### 启用测试
|
||||
|
||||
编辑 `test/ch395f_test.h`，取消注释对应 `ENABLE_PHASEx_TESTS` 宏（同一模式内 Phase 6/7/8/9 可共存于 testTask 循环）。
|
||||
编辑 `test/ch395f_test.h`，取消注释对应 `ENABLE_PHASEx_TESTS` 宏（同一模式内 Phase 6/7/8/9/10/11 可共存于 testTask 循环）。**注意：阶段 6 Server 回显为持续监听循环，故 Client 阶段 11 需单独构建（不与 `ENABLE_PHASE6_TESTS` 同时启用），否则 Client 用例不会被执行。**
|
||||
|
||||
---
|
||||
|
||||
@@ -372,23 +390,23 @@ CH395F PC (dhcp_server)
|
||||
|
||||
> 编号说明：阶段 5 用例 **501/502**（顺序双测向完整性 + 变总量合规）；原 PHY 测试（旧编号 901/902）因板载拓扑不可测已删除（见风险表 #1）。
|
||||
|
||||
### 为什么 4KB 接收缓冲不会丢数据（TCP 流控原理）
|
||||
### 为什么 2KB 接收缓冲不会丢数据（TCP 流控原理）
|
||||
|
||||
PC 一次回放 256KB，而 CH395F socket 接收缓冲默认仅 4KB——不丢数据的保证**不靠缓冲够大，靠 TCP 流控（通告窗口）**。
|
||||
PC 一次回放 256KB，而本固件为每个 Socket 分配的接收缓冲仅 2KB（4 块 × 512B）——不丢数据的保证**不靠缓冲够大，靠 TCP 流控（通告窗口）**。
|
||||
|
||||
数据不是全部驻留芯片，而是在一串缓冲区里"接力"：
|
||||
|
||||
```
|
||||
PC OS 发送缓冲(64~256KB) → 网络在途 → CH395F 接收缓冲(4KB) → MCU 读取
|
||||
PC OS 发送缓冲(64~256KB) → 网络在途 → CH395F 接收缓冲(2KB) → MCU 读取
|
||||
```
|
||||
|
||||
CH395F 是完整 TCP 栈 offload 芯片，内部实现 TCP 状态机，按**接收缓冲剩余空间**向 PC 通告接收窗口（advertised window）：
|
||||
|
||||
1. PC 发数据，芯片收进自己的 4KB 接收环形缓冲；
|
||||
1. PC 发数据，芯片收进自己的 2KB 接收环形缓冲；
|
||||
2. 缓冲快满 → 通告窗口收缩直至 **窗口=0** → PC 的 `sendall` **阻塞**（TCP 背压），剩余数据停在 PC 自身 OS 发送缓冲，不再发出；
|
||||
3. MCU `GET_RECV_LEN` → `READ_RECV_BUF` 读走 → 缓冲腾空 → 芯片重新通告窗口 → PC 恢复发送。
|
||||
|
||||
因此是**背压联动、自节流**：数据永不因芯片缓冲溢出被丢弃，只会"堵一会儿"。MCU 平均读取速率 ≥ PC 发送速率即可持续吞吐（本测试每 2ms 轮询、每次读 4KB，平均速率远高于发送速率，缓冲常年接近空）。
|
||||
因此是**背压联动、自节流**：数据永不因芯片缓冲溢出被丢弃，只会"堵一会儿"。MCU 平均读取速率 ≥ PC 发送速率即可持续吞吐（本测试每 2ms 轮询、每次读 2KB，平均速率远高于发送速率，缓冲常年接近空）。
|
||||
|
||||
"先查长度再读"（`GET_RECV_LEN` → `READ_RECV_BUF`）安全的原因：查询返回"当前未读字节数"，流控保证其必然 ≤ 缓冲容量；查询与读取之间新到的数据进入环形缓冲尾部，由芯片读写指针管理，**不会覆盖未读数据**，留待下一次迭代读取。
|
||||
|
||||
@@ -418,7 +436,7 @@ MCU (TCP Client, ch395f_* 裸命令) PC (tcp_bulk --port 8081)
|
||||
- **为什么顺序双测向**：单向隔离，分别测得**纯 TX / 纯 RX** 吞吐与完整性——不被"回声耦合"掩盖各自链路的真实能力
|
||||
- **TX 节奏**：写 4096B → 等 `SENBUF_FREE`（芯片把 socket 缓冲数据搬入内部协议栈/MAC 缓冲后触发）→ 写下一块，全程不等回显；单向发送阶段 PC 只收不回声，故无回读死锁问题
|
||||
- **RX 校验**：PC 按相同 LCG 模式回放，MCU 期望流按块生成 `exp[]` 字节对位 + `sum_rx` 累加，天然处理 TCP 分包/粘包
|
||||
- 单块 4096B = socket 默认发送缓冲上限，同时命中 DP-04 的 DMA 单次读边界
|
||||
- 单块 4096B 数据 = 触发 DP-04 的 DMA 单次读边界（注意：单 Socket 发送缓冲实际为 1KB，net_send 写入需受此约束）
|
||||
- 双重完整性：逐字节比对 + 全量 32 位累加和 `SUM(TX)==SUM(RX)`（双向同源 LCG，相等即双向一致）
|
||||
- 双向独立吞吐打印（TX/RX 各自 KB/s），作为 SPI 时钟/驱动调整的回归基线
|
||||
|
||||
@@ -485,28 +503,71 @@ MCU (TCP Client, ch395f_* 裸命令) PC (tcp_bulk --port 8081)
|
||||
|
||||
---
|
||||
|
||||
### 已知风险与待实施项
|
||||
|
||||
| # | 事项 | 影响 | 状态 |
|
||||
|---|------|------|------|
|
||||
| 1 | 原 PHY 测试（旧编号 901/902）删除：CH395F 直连板载 RTL8305NBI 交换机，PHY 恒 link up，拔插外线上联无法在芯片 PHY 产生变化事件（2026-08-24 实测 0/1 FAIL 后决议） | 编号 901/902 弃用 | ✅ 已移除 |
|
||||
| 2 | DP-05（PHY 链路恢复）失去覆盖对象 | 设计原则表缩减 | ✅ 已同步删除 |
|
||||
| 3 | 吞吐基线（2026-08-24 实测）：TX 420~449 KB/s、RX 364~391 KB/s，随总量/块大小基本恒定，疑似 SPI 总线为瓶颈 | 后续 SPI 时钟/驱动优化以该基线为参照 | ✅ 已记录 |
|
||||
|
||||
---
|
||||
|
||||
## 7. 阶段 6：NET 层 TCP（Server 回显 + Client 主动连接）
|
||||
## 7. 阶段 6：NET 层 TCP Server 回显
|
||||
|
||||
| 阶段 ID | TM-PHY-06 |
|
||||
|---------|-----------|
|
||||
| **类型** | PC 配合，netTask 运行 |
|
||||
| **耗时** | 持续运行 |
|
||||
| **入口** | `ENABLE_PHASE6_TESTS`，`ch395fTestTask` TCP 回显循环中运行 |
|
||||
| **出口** | 用户终止 |
|
||||
| **耗时** | 持续运行（Server 模式）/ 约 60s（Client 模式） |
|
||||
| **入口** | `ENABLE_PHASE6_TESTS` → `net_layer_test_main()`（`net_test_task.c`，持续监听回显循环） |
|
||||
| **出口** | 用户终止（Server）/ 用例结束自动回到 IDLE（Client） |
|
||||
|
||||
两部分组成：
|
||||
- **Server 模式（TC-NET-601~606）**：MCU 监听 8080，PC 主动连接，验证回显通路 —— 已实现 🟡
|
||||
- **Client 模式扩展（TC-NET-607/608/609）**：MCU 经 BSD Socket API 主动连接 PC Server，补全 `net_connect()` 路径 —— 待实现 🟠（原编号 204/205/206，属阶段 2 NET 层部分，2026-08 重排）
|
||||
本阶段在 NET 层（单连接 socket，DP-01）经 `net_socket` API 驱动，MCU 作 TCP Server 监听 8080，PC 主动连接，验证回显通路、单连接生命周期与字节级完整性 —— 已实现（net 层自动重监听，应用层零生命周期代码）
|
||||
|
||||
> Client 主动连接（原 TC-NET-607/608/609，现 701/702/703）已独立为 **阶段 7**（见 §8），使用独立宏 `ENABLE_PHASE7_TESTS` 与独立入口 `net_layer_client_test_main()`。
|
||||
|
||||
### 7.1 架构与会话结构
|
||||
|
||||
**Server 回显模式**（`net_layer_test_main()`，`net_test_task.c`，由 `ENABLE_PHASE6_TESTS` 启用）：
|
||||
|
||||
**架构图（组件）**：
|
||||
|
||||
```
|
||||
┌──────────────┐ TCP 8080 ┌──────────────────────────┐
|
||||
│ PC (Python) │ ───────────────────────────────────────────▶ │ CH395F (192.168.1.100) │
|
||||
│ tcp_client / │ Ethernet │ Socket 0（单连接复用） │
|
||||
│ tcp_server │ (SPI2, 分频=8) └────────────┬─────────────┘
|
||||
└──────────────┘ SPI │
|
||||
▼
|
||||
┌──────────────────────────┐
|
||||
│ MCU (STM32F407) │
|
||||
│ netTask: net_poll() 10ms │
|
||||
│ testTask: │
|
||||
│ net_layer_test_main() │
|
||||
│ └─ phase6_run() 原样回显 │
|
||||
└──────────────────────────┘
|
||||
```
|
||||
|
||||
**会话时序图（单连接生命周期）**：
|
||||
|
||||
```
|
||||
PC (Client) CH395F Socket 0 MCU testTask
|
||||
│ │ │
|
||||
│ SYN ──────────────────▶│ │
|
||||
│◀──────────────── SYN+ACK │ │
|
||||
│ ACK ──────────────────▶│ ESTABLISHED │
|
||||
│ │── 中断/GlobInt ───────────▶│ net_poll()
|
||||
│ │ │ net_accept()→phase_active
|
||||
│ [64B 数据] ───────────▶│ recv_len = N │
|
||||
│ │── 中断 ───────────────────▶│ net_poll()
|
||||
│ │ │ phase6_run():
|
||||
│ │ │ net_recv(N) → 字节校验
|
||||
│ │ │ TEST_CHECK(累加和)
|
||||
│◀──────────── [64B 回显]─│ net_send() │
|
||||
│ (逐字节比对 + 累加和) │ │
|
||||
│ (重复 N 轮 / 多包) │ │
|
||||
│ │ │
|
||||
│ FIN/RST ───────────────▶│ DISCONNECT │
|
||||
│ │── 中断 ───────────────────▶│ net_poll()
|
||||
│ │ │ net_recv EOF → auto_relisten
|
||||
│ │◀─ 自动 OPEN + TCP_LISTEN │
|
||||
│ SYN(新连接) ───────────▶│ LISTEN 自动恢复，重新接受 │
|
||||
```
|
||||
|
||||
- `phase6_run()` 为**纯回显**：非阻塞 `net_recv(sockfd, s_rx_buf, TEST_BUF_SIZE, NET_MSG_DONTWAIT)` 收到 N 字节后，`net_send(sockfd, s_rx_buf, N, 0)` 原样回显；不做固件侧字节自检（字节完整性由 PC 侧 `data == test_data` 校验）。
|
||||
- 单连接约束（DP-01）：Socket 0 复用监听/数据通道；连接断开（DISCONNECT / KeepAlive TIMEOUT / 静默丢失）后由 **net 层自动重监听**（`auto_relisten`：`net_recv` 收到 EOF 时内部重新 `OPEN` + `TCP_LISTEN`），应用层无需 `net_close`/`net_listen`，下一次 `net_accept` 即接到新连接，行为等同 Linux BSD Socket 监听常驻。
|
||||
|
||||
> Client 主动连接（原 TC-NET-607/608/609，现 701/702/703）已独立为 **阶段 7**，架构与用例见 §8。
|
||||
|
||||
### TC-NET-601: Socket 0 单连接生命周期
|
||||
|
||||
@@ -515,11 +576,20 @@ MCU (TCP Client, ch395f_* 裸命令) PC (tcp_bulk --port 8081)
|
||||
| **ID** | TC-NET-601 |
|
||||
| **优先级** | P0 |
|
||||
| **类型** | 功能测试 |
|
||||
| **标题** | Socket 0: OPEN → TCP_LISTEN → ESTABLISHED（单连接） |
|
||||
| **前置条件** | 1. `net_init("192.168.1.100")` 成功<br>2. `net_listen(sock0)` 已调用<br>3. PC: `python ch395f_socket_test.py tcp_client --ip 192.168.1.100 --port 8080` |
|
||||
| **测试步骤** | 1. PC 连接 8080<br>2. Socket 0 收到 CONNECT → ESTABLISHED<br>3. 发数据 → 回显 |
|
||||
| **通过标准** | 仅 s0 状态变化；串口 `s0:int=0x08` → ESTABLISHED |
|
||||
| **覆盖原则** | DP-01 |
|
||||
| **标题** | Socket 0：OPEN → TCP_LISTEN → ESTABLISHED（单连接） |
|
||||
| **前置条件** | 1. `net_init("192.168.1.100")` 成功（`g_net_ready==1`，netTask 周期 `net_poll()` 运行）<br>2. `net_layer_test_main()` 已 `net_socket`+`net_bind(8080)`+`net_listen`（进入 LISTEN）<br>3. PC: `python .\test\ch395f_socket_test.py tcp_client --ip 192.168.1.100 --port 8080` |
|
||||
|
||||
**测试步骤与判定标准**：
|
||||
|
||||
| 步 | 操作 | 成功标准 | 失败标准 |
|
||||
|----|------|----------|----------|
|
||||
| 1 | PC 连接 8080 | `net_accept()` 返回 fd（== 监听 fd，单连接），`net_get_sock(state)==ESTABLISHED` | 连接未被接受 / 状态未进入 ESTABLISHED |
|
||||
| 2 | `phase6_run()` 非阻塞收 PC 数据 | `net_recv(DONTWAIT)` 返回 > 0 | 收超时（连接未真建立） |
|
||||
| 3 | 固件收 PC 数据 → 字节级比对 + 32 位累加和 `TEST_CHECK` → `net_send()` 原样回显 | PC 收到与发送完全一致的数据且固件 `TEST_CHECK` 通过 | 回显丢失 / 错乱 / 固件校验失败 |
|
||||
| 4 | 串口观测 `net_get_sock` 状态 | 仅 Socket 0 状态变化，无其它 Socket 干扰 | 出现非预期 Socket 状态跳变 |
|
||||
|
||||
**通过标准**：步 1~4 全部满足，单连接生命周期正常。任一失败 → 标记 FAIL
|
||||
**覆盖原则**：DP-01（OPEN→LISTEN→ESTABLISHED 单连接主路径） |
|
||||
|
||||
### TC-NET-602: 64 字节小包回显
|
||||
|
||||
@@ -528,20 +598,40 @@ MCU (TCP Client, ch395f_* 裸命令) PC (tcp_bulk --port 8081)
|
||||
| **ID** | TC-NET-602 |
|
||||
| **优先级** | P0 |
|
||||
| **类型** | 功能测试 |
|
||||
| **标题** | 10 轮 64B TCP 回显 |
|
||||
| **测试步骤** | PC 发 10×64B，MCU 回显 |
|
||||
| **通过标准** | 10/10 匹配 |
|
||||
| **标题** | 10 轮 64B TCP 回显（原样回显，小包） |
|
||||
| **前置条件** | 同 TC-NET-601（连接已建立，ESTABLISHED） |
|
||||
|
||||
### TC-NET-603: 1460 字节 MSS 回显
|
||||
**测试步骤与判定标准**：
|
||||
|
||||
| 步 | 操作 | 成功标准 | 失败标准 |
|
||||
|----|------|----------|----------|
|
||||
| 1 | PC 依次发送 10×64B（递增模式 `0x00..0x3F`） | 每轮 `net_recv` 收 64B | 收包不足 64B |
|
||||
| 2 | `phase6_run()` 收 64B → 原样回显 | PC 逐轮收到 64B 且 `data == test_data` 一致 | 回显丢失 / 错乱 / PC 校验不符 |
|
||||
| 3 | PC 汇总 10 轮并逐字节校验 | 10/10 匹配 | 任一轮失败 |
|
||||
|
||||
**通过标准**：10/10 匹配，0 失败。任一失败 → 标记 FAIL
|
||||
**覆盖原则**：DP-01（单连接数据通路，小包） |
|
||||
|
||||
### TC-NET-603: 1460 字节回显（当前固件 MSS=1024，1460B 会按 MSS 分片）
|
||||
|
||||
| 字段 | 值 |
|
||||
|------|-----|
|
||||
| **ID** | TC-NET-603 |
|
||||
| **优先级** | P0 |
|
||||
| **类型** | 边界测试 |
|
||||
| **标题** | MSS 大小（1460B）TCP 回显 |
|
||||
| **测试步骤** | PC 发 1460B，MCU 回显 |
|
||||
| **通过标准** | 1460B 完全匹配，无截断 |
|
||||
| **标题** | 1460B 回显（注：当前固件 TCP MSS=1024，1460B 超过 MSS 将由 CH395F 按 MSS 分片） |
|
||||
| **前置条件** | 同 TC-NET-601（连接已建立） |
|
||||
|
||||
**测试步骤与判定标准**：
|
||||
|
||||
| 步 | 操作 | 成功标准 | 失败标准 |
|
||||
|----|------|----------|----------|
|
||||
| 1 | PC 发单包 1460B（当前 TCP MSS=1024，1460B 会被分片为 1024+436；`net_send` 亦按 1KB 发送缓冲分块） | `net_recv` 一次收 1460B（≤2KB 接收缓冲，DMABUF=4100 一次读空） | 接收字节数 ≠ 1460（被截断 / 分片丢失） |
|
||||
| 2 | 固件收 1460B → 原样回显 | PC 收到 1460B 且 `data == test_data` 一致 | 回显错乱 / PC 校验不符 |
|
||||
| 3 | PC 校验 | 1460B 完全匹配 | 任意字节不符 |
|
||||
|
||||
**通过标准**：1460B 完全匹配，无截断。任一失败 → 标记 FAIL
|
||||
**覆盖原则**：DP-04（1460 ≤ 2KB 接收缓冲，单次 DMA 读空） |
|
||||
|
||||
### TC-NET-604: 4096 字节缓冲满回显
|
||||
|
||||
@@ -550,11 +640,19 @@ MCU (TCP Client, ch395f_* 裸命令) PC (tcp_bulk --port 8081)
|
||||
| **ID** | TC-NET-604 |
|
||||
| **优先级** | P0 |
|
||||
| **类型** | 边界测试 |
|
||||
| **标题** | 填满 Socket 0 接收缓冲（4096B）回显 |
|
||||
| **前置条件** | DMABUF=4100 可一次性读空 |
|
||||
| **测试步骤** | PC 发 4096B，MCU 经 DMA 一次性读取并回显 |
|
||||
| **通过标准** | 4096B 完全匹配 |
|
||||
| **覆盖原则** | DP-04 |
|
||||
| **标题** | 4096B 回显（接收缓冲仅 2KB，分两次取空） |
|
||||
| **前置条件** | 同 TC-NET-601；`CH395F_SPI_DMA_BUF_SIZE=4100` 可一次性读空 2KB 硬件缓冲 |
|
||||
|
||||
**测试步骤与判定标准**：
|
||||
|
||||
| 步 | 操作 | 成功标准 | 失败标准 |
|
||||
|----|------|----------|----------|
|
||||
| 1 | PC 发单包 4096B（实际单 Socket 接收缓冲为 2KB，固件分两次 `net_recv` 取空） | `net_recv` 累计收满 4096B（分次） | 接收字节数 ≠ 4096（丢失，见 TRAP-13） |
|
||||
| 2 | 固件收 4096B → 原样回显（`net_send` 分块） | PC 收到 4096B 且 `data == test_data` 一致 | 回显错乱 / PC 校验不符 |
|
||||
| 3 | PC 校验 | 4096B 完全匹配 | 任意字节不符 |
|
||||
|
||||
**通过标准**：4096B 完全匹配。任一失败 → 标记 FAIL
|
||||
**覆盖原则**：DP-04（2KB 接收缓冲边界 + 单次 DMA 上限） |
|
||||
|
||||
### TC-NET-605: 断开重连
|
||||
|
||||
@@ -564,38 +662,121 @@ MCU (TCP Client, ch395f_* 裸命令) PC (tcp_bulk --port 8081)
|
||||
| **优先级** | P0 |
|
||||
| **类型** | 恢复测试 |
|
||||
| **标题** | PC 断开后 Socket 0 自动重新监听并接受新连接 |
|
||||
| **测试步骤** | 1. PC 断连 → s0 收 DISCONNECT → CLOSED → re-OPEN → LISTEN<br>2. PC 重连 → s0 → ESTABLISHED<br>3. 发 64B → 验证回显 |
|
||||
| **通过标准** | 重连成功，回显正常 |
|
||||
| **覆盖原则** | DP-01 |
|
||||
| **前置条件** | 同 TC-NET-601（连接已建立，已完成至少一轮 64B 回显） |
|
||||
|
||||
### TC-NET-606: 超时恢复
|
||||
**测试步骤与判定标准**：
|
||||
|
||||
| 步 | 操作 | 成功标准 | 失败标准 |
|
||||
|----|------|----------|----------|
|
||||
| 1 | PC 关闭连接（FIN/RST） | 固件 `net_recv` 收 EOF、`net` 层自动 `auto_relisten` 回到 LISTEN | 状态未变化（卡 ESTABLISHED） |
|
||||
| 2 | net 层自动重监听，无需应用干预（`net_recv` EOF 内部重新 OPEN + TCP_LISTEN） | `net_accept` 在新连接到达时再次返回 fd | 未回到 LISTEN（状态机卡死） |
|
||||
| 3 | PC 重新连接 8080 | `net_accept` 再次返回 fd，进入 ESTABLISHED | 重连失败 |
|
||||
| 4 | PC 发 64B → 固件原样回显 | 回显正常且 PC `data == test_data` 通过 | 回显失败 / PC 校验不符 |
|
||||
|
||||
**通过标准**：重连成功且回显正常，0 失败。任一失败 → 标记 FAIL
|
||||
**覆盖原则**：DP-01（DISCONNECT → CLOSED → re-OPEN → LISTEN 单连接恢复） |
|
||||
|
||||
### TC-NET-606: 连接异常恢复（静默断开 / KeepAlive 超时）
|
||||
|
||||
| 字段 | 值 |
|
||||
|------|-----|
|
||||
| **ID** | TC-NET-606 |
|
||||
| **优先级** | P1 |
|
||||
| **类型** | 恢复测试 |
|
||||
| **标题** | KeepAlive 超时后 Socket 0 自动重新监听 |
|
||||
| **测试步骤** | 1. PC 断连后停止响应<br>2. 等待 KeepAlive 触发 TIMEOUT<br>3. s0 → CLOSED → re-OPEN → LISTEN<br>4. PC 重连 → 验证回显 |
|
||||
| **通过标准** | 自动恢复，无需手动复位 |
|
||||
| **覆盖原则** | DP-01 |
|
||||
| **标题** | 无干净 FIN 或 KeepAlive 超时后 Socket 0 自动重新监听 |
|
||||
| **前置条件** | 1. 同 TC-NET-601（连接已建立）<br>2. KeepAlive 触发场景需 `ENABLE_PHASE11_TESTS` 且 `ch395f_set_keepalive_*` 已配置（探测时长本身由 TC-NET-1101 覆盖） |
|
||||
|
||||
**测试步骤与判定标准**：
|
||||
|
||||
| 步 | 操作 | 成功标准 | 失败标准 |
|
||||
|----|------|----------|----------|
|
||||
| 1 | PC 静默断开（如直接断开网线 / 断电，不发 FIN）或 KeepAlive 探测超时触发 TIMEOUT | 固件经 `net_get_sock(state)` 轮询发现非 ESTABLISHED | 状态长期卡 ESTABLISHED（未恢复） |
|
||||
| 2 | 固件 net 层 `auto_relisten` 自动回到 LISTEN（应用层无 `net_close`/`net_listen` 调用） | 回到 LISTEN，等待新连接 | 未恢复监听 |
|
||||
| 3 | PC 重连 → 发 64B → 验证回显 | 回显正常 | 回显失败 |
|
||||
|
||||
**通过标准**：自动恢复监听，无需手动复位。任一异常 → 标记 FAIL
|
||||
**覆盖原则**：DP-01（异常路径恢复；KeepAlive 探测机制见 TC-NET-1101） |
|
||||
|
||||
---
|
||||
|
||||
### Client 模式扩展：主动连接 PC（TC-NET-607 / 608 / 609，🟠 待实现）
|
||||
|
||||
|
||||
|
||||
|
||||
## 8. 阶段 7：NET 层 TCP Client 主动连接
|
||||
|
||||
| 阶段 ID | TM-PHY-07 |
|
||||
|---------|-----------|
|
||||
| **类型** | PC 配合，netTask 运行 |
|
||||
| **耗时** | 约 60s |
|
||||
| **入口** | `ENABLE_PHASE7_TESTS` → `net_layer_client_test_main()`（`net_test_task.c`） |
|
||||
| **出口** | 用例结束自动回到 IDLE |
|
||||
|
||||
> 与硬件层阶段 2 的 TC-NET-201/202/203 一一对应（芯片行为 → API 封装），验证 `net_socket` / `net_connect` / `net_send` / `net_recv` / `net_close` 对 TCP Client 主路径及异常路径的正确封装。
|
||||
> 本组用例原编号 204/205/206（原阶段 2 的 NET 层部分），2026-08 重排后为 607/608/609；实现于 `ENABLE_PHASE6_TESTS` 固件中。
|
||||
> 由独立宏 `ENABLE_PHASE7_TESTS` 启用，独立于 Server 回显阶段 6（`ENABLE_PHASE6_TESTS`）；因阶段 6 为持续监听循环，Client 阶段需**单独构建**（不与 `ENABLE_PHASE6_TESTS` 同时启用）。
|
||||
> 原编号 204/205/206（原阶段 2 的 NET 层部分），2026-08 重排后为 701/702/703。
|
||||
|
||||
#### TC-NET-607（NET 层）: TCP Client 连接与数据交换
|
||||
### 8.1 架构与会话结构
|
||||
|
||||
```
|
||||
net_socket(NET_AF_INET, NET_SOCK_STREAM, 0) // 取空闲 Socket（非监听 Socket 0）
|
||||
→ net_connect(PC:8081) // 异步下发，net_poll 推进状态机
|
||||
→ net_select(sockfd+1, NULL, &wfds, NULL, &tv) // 等可写 = ESTABLISHED
|
||||
→ net_send(64B) → net_recv(64B) 校验 // 主路径（701）
|
||||
→ net_close() // 释放
|
||||
```
|
||||
|
||||
**架构图（组件）**：
|
||||
|
||||
```
|
||||
┌──────────────┐ TCP 8081 ┌──────────────────────────┐
|
||||
│ PC (Python) │ ◀─────────────────────────────────────────── │ CH395F (192.168.1.100) │
|
||||
│ tcp_server │ Ethernet │ Socket N（非 0 空闲） │
|
||||
│ (回显服务器) │ (SPI2, 分频=8) └────────────┬─────────────┘
|
||||
└──────────────┘ SPI │
|
||||
▼
|
||||
┌──────────────────────────┐
|
||||
│ MCU (STM32F407) │
|
||||
│ netTask: net_poll() 10ms │
|
||||
│ testTask: │
|
||||
│ net_layer_client_test_main│
|
||||
│ └─ net_connect→收发→close│
|
||||
└──────────────────────────┘
|
||||
```
|
||||
|
||||
**会话时序图（Client 主动连接）**：
|
||||
|
||||
```
|
||||
PC (Server :8081) CH395F Socket N MCU testTask
|
||||
│ │ │
|
||||
│ (Python tcp_server) │ │ net_layer_client_test_main()
|
||||
│ │◀─ net_socket()+net_connect()│ (异步下发 CONNECT)
|
||||
│◀────────────── SYN ──────│ │
|
||||
│────── SYN+ACK ─────────▶│ ESTABLISHED │
|
||||
│ │── 中断/GlobInt ───────────▶│ net_poll()
|
||||
│ │ │ net_select() 可写 → 建链
|
||||
│◀────────────── [64B] ────│ net_send() │
|
||||
│ (回显服务器原样返回) │ │
|
||||
│ [64B 回显] ───────────▶│ recv_len = N │
|
||||
│ │── 中断 ───────────────────▶│ net_poll()
|
||||
│ │ │ net_recv(N) → 字节校验
|
||||
│ │ │ TEST_CHECK(累加和)
|
||||
│ │◀─ net_close() ─────────────│ 释放 Socket N
|
||||
```
|
||||
|
||||
- `net_layer_client_test_main()` 为**独立入口**：使用非 0 空闲 Socket 连接 PC，不在 `net_layer_test_main()` 的监听循环内；由 `StartCh395fTestTask` 的 NET 分支按宏调用。
|
||||
- **固件自检**：`net_recv` 后逐字节比对 + 32 位累加和 `TEST_CHECK`（固件侧独立校验）；PC 同时校验。
|
||||
- 关闭重连（702）、连接超时（703）见对应 TC。
|
||||
|
||||
### TC-NET-701: TCP Client 连接与数据交换
|
||||
|
||||
| 字段 | 值 |
|
||||
|------|-----|
|
||||
| **ID** | TC-NET-607 |
|
||||
| **ID** | TC-NET-701 |
|
||||
| **优先级** | P0 |
|
||||
| **类型** | 功能测试（NET 层） |
|
||||
| **标题** | net_socket TCP Client → PC TCP Server，64 字节收发 |
|
||||
| **前置条件** | 1. PC: `python ch395f_socket_test.py tcp_server --port 8081`（TCP 回显服务器）<br>2. `net_init()` 已完成（`g_net_ready == 1`，netTask 周期 `net_poll()` 运行中）<br>3. 建议：硬件层固件中 TC-NET-201/202/203 已通过（跨构建前置，见「构建模式与执行顺序」） |
|
||||
| **前置条件** | 1. PC: `python ./test/ch395f_socket_test.py tcp_server --port 8081`（TCP 回显服务器）<br>2. `net_init()` 已完成（`g_net_ready == 1`，netTask 周期 `net_poll()` 运行中）<br>3. `ENABLE_PHASE7_TESTS` 已定义，入口为 `net_layer_client_test_main()`（见「构建模式与执行顺序」）<br>4. 建议：硬件层固件中 TC-NET-201/202/203 已通过（跨构建前置，见「构建模式与执行顺序」） |
|
||||
|
||||
**测试步骤与判定标准**：
|
||||
|
||||
@@ -605,22 +786,22 @@ MCU (TCP Client, ch395f_* 裸命令) PC (tcp_bulk --port 8081)
|
||||
| 2 | 构造 `struct net_sockaddr_in`（sin_family=`NET_AF_INET`，sin_port=`net_htons(8081)`，sin_addr=`net_inet_addr("192.168.1.2")`）后 `net_connect(sockfd, &addr, len)` | 返回 `0`（连接命令已异步下发） | 返回 `-1`（地址非法或协议栈异常） |
|
||||
| 3 | 在 netTask 周期 `net_poll()` 推进下，调用 `net_select(sockfd+1, NULL, &wfds, NULL, &tv)` 等待可写事件，超时 10s | 返回正数且 `NET_FD_ISSET(sockfd)` 指示连接建立（ESTABLISHED） | 超时未连接，`net_errno == NET_ERR_WOULDBLOCK` 持续 |
|
||||
| 4 | `net_send(sockfd, buf, 64, 0)` 发送 64 字节递增模式数据（`0x00..0x3F`） | 返回值 == `64`（全部发出） | 返回值 `< 0`（发送失败）或 `≠ 64`（未完全发出） |
|
||||
| 5 | `net_recv(sockfd, buf, 64, 0)` 阻塞接收回显，超时 10s | 返回值 == `64` 且与原数据逐字节一致 | 返回值 `< 0`（超时/断开）或 `≠ 64`（数据不完整）或任意字节不符 |
|
||||
| 5 | `net_recv(sockfd, buf, 64, 0)` 阻塞接收回显，超时 10s | 返回值 == `64`、与原数据逐字节一致、且固件字节级比对 + 累加和 `TEST_CHECK` 通过 | 返回值 `< 0`（超时/断开）或 `≠ 64`（数据不完整）或任意字节不符 或 固件 `TEST_CHECK` 失败 |
|
||||
| 6 | `net_close(sockfd)` 关闭 socket（TCP 先断开连接，释放控制块） | 返回 `0` | 返回 `-1`（关闭失败） |
|
||||
|
||||
**通过标准**：6/6 通过，0 失败。任一失败 → 标记 FAIL
|
||||
|
||||
**覆盖原则**：DP-01（net_socket→net_connect→net_send→net_recv→net_close 主路径，NET 层）
|
||||
|
||||
#### TC-NET-608（NET 层）: TCP Client 关闭重连 ×3 轮
|
||||
### TC-NET-702: TCP Client 关闭重连 ×3 轮
|
||||
|
||||
| 字段 | 值 |
|
||||
|------|-----|
|
||||
| **ID** | TC-NET-608 |
|
||||
| **ID** | TC-NET-702 |
|
||||
| **优先级** | P0 |
|
||||
| **类型** | 功能测试 / 恢复测试（NET 层） |
|
||||
| **标题** | close→重连循环 3 轮，每轮含数据交换 |
|
||||
| **前置条件** | 同 TC-NET-607 |
|
||||
| **前置条件** | 同 TC-NET-701 |
|
||||
|
||||
**测试步骤与判定标准**（每轮 i = 0,1,2）：
|
||||
|
||||
@@ -628,22 +809,22 @@ MCU (TCP Client, ch395f_* 裸命令) PC (tcp_bulk --port 8081)
|
||||
|----|------|----------|----------|
|
||||
| 1 | `net_socket(NET_AF_INET, NET_SOCK_STREAM, 0)` 创建 socket | 返回 sockfd 非 `-1` | 返回 `-1`（无空闲 Socket） |
|
||||
| 2 | 构造地址 + `net_connect(sockfd, &addr, len)`，再 `net_select` 等待可写确认 ESTABLISHED | 连接建立成功 | 连接失败或超时未建立 |
|
||||
| 3 | `net_send(sockfd, buf, 64, 0)` → `net_recv(sockfd, buf, 64, 0)` | 收发各 `64` 字节且逐字节一致 | 收发失败或数据不符 |
|
||||
| 3 | `net_send(sockfd, buf, 64, 0)` → `net_recv(sockfd, buf, 64, 0)` | 收发各 `64` 字节、固件字节级比对 + 累加和 `TEST_CHECK` 通过 | 收发失败 / 数据不符 / 固件 `TEST_CHECK` 失败 |
|
||||
| 4 | `net_close(sockfd)` 关闭并释放控制块 | 返回 `0` | 返回 `-1` |
|
||||
|
||||
**通过标准**：3/3 轮全部通过，0 失败。任一失败 → 标记 FAIL
|
||||
|
||||
**覆盖原则**：DP-01（net 层 open→connect→close→re-open→reconnect）
|
||||
|
||||
#### TC-NET-609（NET 层）: TCP Client 连接超时
|
||||
### TC-NET-703: TCP Client 连接超时
|
||||
|
||||
| 字段 | 值 |
|
||||
|------|-----|
|
||||
| **ID** | TC-NET-609 |
|
||||
| **ID** | TC-NET-703 |
|
||||
| **优先级** | P1 |
|
||||
| **类型** | 负向测试（NET 层） |
|
||||
| **标题** | 目标端口无服务时 net_connect 超时 |
|
||||
| **前置条件** | 1. PC **未**运行 TCP Server（`192.168.1.2:8081` 无监听）<br>2. TC-NET-607 通过 |
|
||||
| **前置条件** | 1. PC **未**运行 TCP Server（`192.168.1.2:8081` 无监听）<br>2. TC-NET-701 通过 |
|
||||
|
||||
**测试步骤与判定标准**：
|
||||
|
||||
@@ -657,71 +838,128 @@ MCU (TCP Client, ch395f_* 裸命令) PC (tcp_bulk --port 8081)
|
||||
|
||||
**覆盖原则**：DP-01（NET 层异常路径 connect 失败处理）
|
||||
|
||||
---
|
||||
> **实现说明**：TC-NET-703 与 TC-NET-701/702 的 PC 环境互斥（前者要求 PC 服务关闭、后两者要求开启），故固件中 TC-NET-703 由子开关 `PHASE7_TEST_TIMEOUT` 单独启用——默认 `ENABLE_PHASE7_TESTS` 仅跑 701/702；单独开启 `PHASE7_TEST_TIMEOUT` 并关闭 PC 服务后重编，方可执行 703。
|
||||
|
||||
## 8. 阶段 7：大文件传输（20KB+）
|
||||
|
||||
| 阶段 ID | TM-PHY-07 |
|
||||
|---------|-----------|
|
||||
| **类型** | PC 配合，netTask 运行 |
|
||||
| **耗时** | 取决于文件大小和速率 |
|
||||
| **入口** | `ENABLE_PHASE7_TESTS` |
|
||||
| **配置** | `PHASE7_FILE_SIZE`（默认 20480）|
|
||||
|
||||
### TC-NET-701: 20KB 分块传输
|
||||
### TC-NET-704: 8-Socket 并发 TCP Client（多 Socket 模式验证）
|
||||
|
||||
| 字段 | 值 |
|
||||
|------|-----|
|
||||
| **ID** | TC-NET-701 |
|
||||
| **ID** | TC-NET-704 |
|
||||
| **优先级** | P0 |
|
||||
| **类型** | 功能测试 |
|
||||
| **标题** | 20480 字节 TCP 分块收发（>Socket 0 硬件缓冲 4KB） |
|
||||
| **前置条件** | `net_send_locked` 支持自动分块（每块 ≤4096B） |
|
||||
| **测试步骤** | 1. MCU 填 20KB 递增模式数据<br>2. MCU 分块发送，每块 4096B<br>3. PC 回显<br>4. MCU 接收并逐字节验证 |
|
||||
| **通过标准** | 20KB 完全匹配，每字节验证通过 |
|
||||
| **覆盖原则** | DP-04 |
|
||||
| **类型** | 功能测试 / 并发测试（NET 层） |
|
||||
| **标题** | 同时打开 8 个 Socket 连接 PC Server，各自 64B 收发 |
|
||||
| **前置条件** | 1. PC: `python ./test/ch395f_socket_test.py tcp_server --port 8081 --max-conn 8`（并发回显，`--max-conn` 为并发计数）<br>2. `net_init()` 已置 `FUN_PARA=0x09`（8 Socket 模式），8 个 Socket 缓冲按「CH395F 缓冲架构」分配（每 Socket 接收 2KB + 发送 1KB，MSS=1024）<br>3. `ENABLE_PHASE7_TESTS` 已定义 |
|
||||
|
||||
### TC-NET-702: 64KB 传输（recv_len 上限）
|
||||
**测试步骤与判定标准**：
|
||||
|
||||
| 字段 | 值 |
|
||||
|------|-----|
|
||||
| **ID** | TC-NET-702 |
|
||||
| **优先级** | P1 |
|
||||
| **类型** | 边界测试 |
|
||||
| **标题** | 65535 字节传输（`recv_len` uint16 上限） |
|
||||
| **前置条件** | TC-NET-701 通过 |
|
||||
| **测试步骤** | 同 501，文件大小 65535 |
|
||||
| **通过标准** | 65535B 完全匹配 |
|
||||
| **覆盖原则** | DP-04 |
|
||||
| 步 | 操作 | 成功标准 | 失败标准 |
|
||||
|----|------|----------|----------|
|
||||
| 1 | 循环 i=0..7：`net_socket()` 创建 8 个 TCP socket（本地端口 51000+i），`net_connect(192.168.1.2:8081)` | 8 个 `net_connect` 均返回 `0` | 任一返回 `-1` |
|
||||
| 2 | netTask `net_poll()` 推进下，`net_select` 等待全部 8 路可写 | 8 路均在 10s 内 ESTABLISHED | 任一超时未建立 |
|
||||
| 3 | 每路 `net_send(sockfd, 64B)` → `net_recv(sockfd, 64B)` 校验 | 8 路收发各 64B、字节级比对 + 累加和 `TEST_CHECK` 通过 | 任一收发失败 / 数据不符 / `TEST_CHECK` 失败 |
|
||||
|
||||
### 实现说明
|
||||
**通过标准**：8/8 路全部通过，0 失败。任一失败 → 标记 FAIL
|
||||
|
||||
`phase7_run()` 状态机（`ch395fTestTask` 内）：
|
||||
**覆盖原则**：DP-01（多 Socket 并发主路径）、缓冲架构（8×6 块分配，MSS=1024）
|
||||
|
||||
```
|
||||
IDLE → (连接建立) → SENDING(分块发) → RECVING(分块收+验证) → DONE → IDLE
|
||||
```
|
||||
|
||||
- 每次 `net_send_sock` 自动分块（`net_send_locked` 内按 `NET_DMA_MAX_PAYLOAD=4096` 拆分）
|
||||
- 每次 `net_recv_sock` 通过 `ch395f_get_recv_len` 获取硬件缓冲可用数据量（≤4096B），一次性读空
|
||||
- 验证模式：递增字节（offset & 0xFF），接收端逐字节比较
|
||||
> **注**：PC 端 `--max-conn` 须为**并发**计数（连接关闭即减），否则 Phase 7 全量（701+702+704 共 12 连接）会按累计计数超限而拒掉 4~7（见 Trap 19）。该用例已随 Phase 7 实测 **40/40 PASS** 验证。
|
||||
|
||||
---
|
||||
|
||||
## 9. 阶段 8：Select/Poll I/O 多路复用（单连接）
|
||||
## 9. 阶段 8：大文件 / 批量传输（100KB，文件收发）
|
||||
|
||||
| 阶段 ID | TM-PHY-08 |
|
||||
|---------|-----------|
|
||||
| **类型** | PC 配合，netTask 运行 |
|
||||
| **耗时** | 持续运行 |
|
||||
| **类型** | PC 配合（PC 作 TCP Client 连接 MCU:8080），netTask 运行 |
|
||||
| **耗时** | 取决于文件大小与速率（100KB 约数秒） |
|
||||
| **入口** | `ENABLE_PHASE8_TESTS` |
|
||||
| **配置** | `PHASE8_FILE_SIZE`（默认 102400 = 100KB）；`PHASE8_DIRECTION`（SEND / RECV / ECHO，默认 ECHO） |
|
||||
| **PC 配合** | `python ./test/ch395f_socket_test.py tcp_file --ip 192.168.1.100 --port 8080 --op recv --file rx_100k.bin --size 102400`（文件发送）<br>`... --op send --file tx_100k.bin --size 102400`（文件接收） |
|
||||
|
||||
### TC-NET-801: net_select() 单 socket 就绪检测
|
||||
> 架构：MCU 为 TCP Server（`net_test_task` 监听 8080，`net_accept` 后 `phase8_run(acc)`）；PC 用 `tcp_file` 子命令作 Client 连接 MCU:8080。一次 `phase8_run` 对应一次 PC 连接。
|
||||
|
||||
### 设计要点
|
||||
|
||||
- **流式分块，不缓存全文件**：`s_tx_buf`/`s_rx_buf` 仅 32KB，100KB 须按窗口逐块生成/校验（递增模式 `(offset+i)&0xFF`），避免占用大块 RAM。
|
||||
- **方向覆盖（由 `PHASE8_DIRECTION` 选择，或分三次连接分别跑）**：
|
||||
- **SEND（TC-NET-801）**：MCU 流式发出 100KB，PC 落盘 `rx_100k.bin` 并校验。
|
||||
- **RECV（TC-NET-802）**：PC 读 `tx_100k.bin` 流式发出（尾部附 4 字节 CRC32），MCU 逐块接收并字节校验 + 整包 CRC32 比对。
|
||||
- **ECHO（TC-NET-803）**：MCU 发 100KB 由 PC 原样回显，MCU 收齐校验（round-trip，覆盖收发双路径）。
|
||||
- **完整性校验**：
|
||||
- 字节级：递增模式 `(offset+i)&0xFF`，接收端按 offset 逐字节比对（MCU 侧自校验）。
|
||||
- 整包级：发送端对 100KB 计算 CRC32，接收端比对；RECV 方向由 PC 在文件末尾附加 4 字节 CRC32（小端），MCU 收齐后比对自身运行的 CRC32。
|
||||
|
||||
### TC-NET-801: 100KB 文件发送（MCU→PC）
|
||||
|
||||
| 字段 | 值 |
|
||||
|------|-----|
|
||||
| **ID** | TC-NET-801 |
|
||||
| **优先级** | P0 |
|
||||
| **类型** | 功能测试（文件发送） |
|
||||
| **标题** | MCU 流式发送 100KB 至 PC 并落盘校验 |
|
||||
| **前置条件** | 1. PC: `python ./test/ch395f_socket_test.py tcp_file --ip 192.168.1.100 --port 8080 --op recv --file rx_100k.bin --size 102400`（先连接等待数据）<br>2. `ENABLE_PHASE8_TESTS`，`PHASE8_FILE_SIZE=102400`，`PHASE8_DIRECTION=SEND`<br>3. `net_init` 完成，MSS=1024 |
|
||||
| **测试步骤** | 1. MCU `net_accept` 建链（PC 已连接）<br>2. 循环填充一个滑动窗口（≤ s_tx_buf）并调用 `net_send`；`net_send` 内部按硬件发送 FIFO（`NET_SEND_CHUNK_MAX`=1KB，见 Trap 20）自动拆分写入，直至 100KB 发完<br>3. PC 接收全部字节写入 `rx_100k.bin`，按递增模式或预置 CRC32 校验 |
|
||||
| **通过标准** | PC 收满 102400B 且逐字节/CRC32 校验一致，MCU 无发送错误 |
|
||||
| **覆盖原则** | DP-04（分块发送、DMA 边界）、缓冲架构（1KB 发送缓冲） |
|
||||
| **实测** | ✅ PASS（2026-08-26）：固件 `PHASE8_DIRECTION=SEND`，PC `tcp_file --op recv` 收满 102400B，递增模式逐字节校验通过，CRC32=0x9A0E0C8C，耗时 1209ms / 82.7 KB/s，落盘 `rx_100k.bin` 成功。 |
|
||||
|
||||
### TC-NET-802: 100KB 文件接收（PC→MCU）
|
||||
|
||||
| 字段 | 值 |
|
||||
|------|-----|
|
||||
| **ID** | TC-NET-802 |
|
||||
| **优先级** | P0 |
|
||||
| **类型** | 功能测试（文件接收） |
|
||||
| **标题** | PC 流式发送 100KB 文件，MCU 接收并校验 |
|
||||
| **前置条件** | 1. PC: `python ./test/ch395f_socket_test.py tcp_file --ip 192.168.1.100 --port 8080 --op send --file tx_100k.bin --size 102400`（先连接并发送；无文件则生成 100KB 递增模式）<br>2. 同 TC-NET-801（`PHASE8_DIRECTION=RECV`） |
|
||||
| **测试步骤** | 1. MCU `net_accept` 建链（PC 已连接）<br>2. 循环 `net_recv`（≤2KB/次，Trap 13 一次读空）→ 按 offset 字节校验 + 累计 CRC32，直至收满 100KB<br>3. PC 在文件末尾附 4 字节 CRC32（小端）；MCU 收齐后比对 CRC32 |
|
||||
| **通过标准** | MCU 收满 102400B，字节校验全过且 CRC32 匹配，无溢出/截断 |
|
||||
| **覆盖原则** | DP-04（接收缓冲 2KB 一次读空）、Trap 13 |
|
||||
| **实测** | 🟡 待验证（参考：默认递增模式 100KB 的 CRC32 经 SEND 实测为 `0x9A0E0C8C`，RECV 方向 MCU 累计 CRC32 应与之相等） |
|
||||
|
||||
### TC-NET-803: 100KB 回显 round-trip（可选）
|
||||
|
||||
| 字段 | 值 |
|
||||
|------|-----|
|
||||
| **ID** | TC-NET-803 |
|
||||
| **优先级** | P1 |
|
||||
| **类型** | 恢复/压力测试 |
|
||||
| **标题** | MCU 发 100KB 经 PC 回显原样返回，MCU 收齐校验 |
|
||||
| **前置条件** | MCU: `PHASE8_DIRECTION=ECHO`（net_accept 监听 8080）；PC: `python ./test/ch395f_socket_test.py tcp_file --ip 192.168.1.100 --port 8080 --op echo`（PC 作 Client 连 MCU 并原样回显） |
|
||||
| **测试步骤** | MCU 发 100KB → PC 回显 → MCU 收 100KB 字节校验 |
|
||||
| **通过标准** | 100KB 全过，验证 100KB 经回显链路完整 |
|
||||
| **覆盖原则** | DP-01、DP-04 |
|
||||
| **实测** | 🟢 已验证（MCU 收齐 102400B 逐字节校验通过；PC 回显客户端 1241ms @ 80.6 KB/s，对端关闭后正常退出；修复了 phase8_run 未关闭连接导致 MCU 在同连接上无限重复、PC 挂起的问题） |
|
||||
|
||||
### 实现说明
|
||||
|
||||
`phase8_run()` 状态机（netTestTask，`net_accept` 后执行，`sockfd` 为已建链 fd）：
|
||||
|
||||
```
|
||||
IDLE → ACCEPT → [SEND: 分块发 → DONE] / [RECV: 分块收+校验 → DONE] / [ECHO: 分块发 → 分块收(回显) → DONE] → 关闭 → 重新 ACCEPT
|
||||
```
|
||||
|
||||
- **发送**：`phase8_fill(buf, chunk, offset)` 按窗口生成递增模式；`net_send` 经消息队列转发 netTask，由 `net_send_locked` 按发送缓冲(1KB)/`CH395F_SPI_DMA_MAX_PAYLOAD` 自动拆分。
|
||||
- **接收**：`net_recv` 每次读 ≤2KB（=接收缓冲，Trap 13 一次读空），`phase8_verify(buf, n, offset)` 字节校验 + 累计 CRC32。
|
||||
- **100KB 不整体驻留 RAM**：`s_tx_buf`/`s_rx_buf`=32KB 仅作滑动窗口；`PHASE8_FILE_SIZE` 控制总量。
|
||||
- **PC `tcp_file` 子命令**（新增，作 Client 连 MCU:8080）：`recv` 接收 `--size` 字节落盘并校验；`send` 读 `--file` 发送并附 4 字节 CRC32 尾。
|
||||
|
||||
---
|
||||
|
||||
## 10. 阶段 9：Select/Poll I/O 多路复用（单连接）
|
||||
|
||||
| 阶段 ID | TM-PHY-09 |
|
||||
|---------|-----------|
|
||||
| **类型** | PC 配合，netTask 运行 |
|
||||
| **耗时** | 持续运行 |
|
||||
| **入口** | `ENABLE_PHASE9_TESTS` |
|
||||
|
||||
### TC-NET-901: net_select() 单 socket 就绪检测
|
||||
|
||||
| 字段 | 值 |
|
||||
|------|-----|
|
||||
| **ID** | TC-NET-901 |
|
||||
| **优先级** | P0 |
|
||||
| **类型** | 功能测试 |
|
||||
| **标题** | `net_select()` 在 Socket 0 数据到达时正确返回 |
|
||||
| **前置条件** | Socket 0 ESTABLISHED |
|
||||
@@ -729,11 +967,11 @@ IDLE → (连接建立) → SENDING(分块发) → RECVING(分块收+验证) →
|
||||
| **通过标准** | 回显成功 |
|
||||
| **覆盖原则** | DP-02（select 内部调 net_poll） |
|
||||
|
||||
### TC-NET-802: net_select() 超时
|
||||
### TC-NET-902: net_select() 超时
|
||||
|
||||
| 字段 | 值 |
|
||||
|------|-----|
|
||||
| **ID** | TC-NET-802 |
|
||||
| **ID** | TC-NET-902 |
|
||||
| **优先级** | P1 |
|
||||
| **类型** | 负向测试 |
|
||||
| **标题** | 100ms 超时内无数据则返回 0 |
|
||||
@@ -743,19 +981,19 @@ IDLE → (连接建立) → SENDING(分块发) → RECVING(分块收+验证) →
|
||||
|
||||
---
|
||||
|
||||
## 10. 阶段 9：边界条件测试
|
||||
## 11. 阶段 10：边界条件测试
|
||||
|
||||
| 阶段 ID | TM-PHY-09 |
|
||||
| 阶段 ID | TM-PHY-10 |
|
||||
|---------|-----------|
|
||||
| **类型** | PC 配合，netTask 运行 |
|
||||
| **耗时** | 按需 |
|
||||
| **入口** | `ENABLE_PHASE9_TESTS` |
|
||||
| **入口** | `ENABLE_PHASE10_TESTS` |
|
||||
|
||||
### TC-NET-901: DMA 边界 −1（4095 字节）
|
||||
### TC-NET-1001: DMA 边界 −1（4095 字节）
|
||||
|
||||
| 字段 | 值 |
|
||||
|------|-----|
|
||||
| **ID** | TC-NET-901 |
|
||||
| **ID** | TC-NET-1001 |
|
||||
| **优先级** | P0 |
|
||||
| **类型** | 边界测试 |
|
||||
| **标题** | 发送 4095 字节（SPI 最大载荷 −1，单次 DMA 可容纳） |
|
||||
@@ -764,11 +1002,11 @@ IDLE → (连接建立) → SENDING(分块发) → RECVING(分块收+验证) →
|
||||
| **通过标准** | 4095B 完全匹配 |
|
||||
| **覆盖原则** | DP-04 |
|
||||
|
||||
### TC-NET-902: DMA 边界（4096 字节）
|
||||
### TC-NET-1002: DMA 边界（4096 字节）
|
||||
|
||||
| 字段 | 值 |
|
||||
|------|-----|
|
||||
| **ID** | TC-NET-902 |
|
||||
| **ID** | TC-NET-1002 |
|
||||
| **优先级** | P0 |
|
||||
| **类型** | 边界测试 |
|
||||
| **标题** | 发送 4096 字节（等于 SPI 最大载荷，填满单次 DMA） |
|
||||
@@ -776,11 +1014,11 @@ IDLE → (连接建立) → SENDING(分块发) → RECVING(分块收+验证) →
|
||||
| **通过标准** | 4096B 完全匹配 |
|
||||
| **覆盖原则** | DP-04 |
|
||||
|
||||
### TC-NET-903: DMA 边界 +1（4097 字节）
|
||||
### TC-NET-1003: DMA 边界 +1（4097 字节）
|
||||
|
||||
| 字段 | 值 |
|
||||
|------|-----|
|
||||
| **ID** | TC-NET-903 |
|
||||
| **ID** | TC-NET-1003 |
|
||||
| **优先级** | P0 |
|
||||
| **类型** | 边界测试 |
|
||||
| **标题** | 发送 4097 字节（超过 SPI 最大载荷，自动拆两次 DMA：4096+1） |
|
||||
@@ -788,33 +1026,33 @@ IDLE → (连接建立) → SENDING(分块发) → RECVING(分块收+验证) →
|
||||
| **通过标准** | 4097B 完全匹配，两次 DMA 无缝衔接 |
|
||||
| **覆盖原则** | DP-04 |
|
||||
|
||||
### TC-NET-904: 零长度收发
|
||||
### TC-NET-1004: 零长度收发
|
||||
|
||||
| 字段 | 值 |
|
||||
|------|-----|
|
||||
| **ID** | TC-NET-904 |
|
||||
| **ID** | TC-NET-1004 |
|
||||
| **优先级** | P1 |
|
||||
| **类型** | 负向测试 |
|
||||
| **标题** | `net_send_sock(sk, buf, 0)` 返回 −1 |
|
||||
| **测试步骤** | `net_send_sock(sk, s_phase9_tx, 0)` |
|
||||
| **通过标准** | 返回 < 0，无崩溃 |
|
||||
|
||||
### TC-NET-905: 连续快速发送 20 小包
|
||||
### TC-NET-1005: 连续快速发送 20 小包
|
||||
|
||||
| 字段 | 值 |
|
||||
|------|-----|
|
||||
| **ID** | TC-NET-905 |
|
||||
| **ID** | TC-NET-1005 |
|
||||
| **优先级** | P1 |
|
||||
| **类型** | 压力测试 |
|
||||
| **标题** | 20 × 100 字节连续快速发送（验证 SENDBUF_FREE 等待机制） |
|
||||
| **测试步骤** | 循环 20 次：`net_send_sock(sk, buf, 100)`，间隔 1ms |
|
||||
| **通过标准** | 20/20 成功，回显 2000B 完全匹配 |
|
||||
|
||||
### TC-NET-906: 快速连接-断开 ×20 轮
|
||||
### TC-NET-1006: 快速连接-断开 ×20 轮
|
||||
|
||||
| 字段 | 值 |
|
||||
|------|-----|
|
||||
| **ID** | TC-NET-906 |
|
||||
| **ID** | TC-NET-1006 |
|
||||
| **优先级** | P1 |
|
||||
| **类型** | 稳定性测试 |
|
||||
| **标题** | 20 次快速连接-断开循环 |
|
||||
@@ -823,20 +1061,20 @@ IDLE → (连接建立) → SENDING(分块发) → RECVING(分块收+验证) →
|
||||
|
||||
---
|
||||
|
||||
## 11. 阶段 10：KeepAlive 超时断开
|
||||
## 12. 阶段 11：KeepAlive 超时断开
|
||||
|
||||
| 阶段 ID | TM-PHY-10 |
|
||||
| 阶段 ID | TM-PHY-11 |
|
||||
|---------|-----------|
|
||||
| **类型** | PC 配合，netTask 运行 |
|
||||
| **耗时** | ~65 秒（60s idle + 15s probes） |
|
||||
| **入口** | `ENABLE_PHASE10_TESTS` |
|
||||
| **入口** | `ENABLE_PHASE11_TESTS` |
|
||||
| **配置** | KeepAlive 空闲 60s，探测间隔 5s，3 次 |
|
||||
|
||||
### TC-NET-1001: KeepAlive 触发断开
|
||||
### TC-NET-1101: KeepAlive 触发断开
|
||||
|
||||
| 字段 | 值 |
|
||||
|------|-----|
|
||||
| **ID** | TC-NET-1001 |
|
||||
| **ID** | TC-NET-1101 |
|
||||
| **优先级** | P1 |
|
||||
| **类型** | 功能测试 |
|
||||
| **标题** | TCP 连接空闲超过 KeepAlive 阈值后自动断开 |
|
||||
@@ -846,16 +1084,17 @@ IDLE → (连接建立) → SENDING(分块发) → RECVING(分块收+验证) →
|
||||
|
||||
---
|
||||
|
||||
## 12. Python 测试脚本参考
|
||||
|
||||
|
||||
## 13. Python 测试脚本参考
|
||||
|
||||
| 命令 | 模式 | 说明 |
|
||||
|------|------|------|
|
||||
| `tcp_server --port 8081` | PC 作 TCP 回显服务器（多连接循环） | 测试 TCP Client（阶段 2 硬件层；阶段 6 Client 扩展 607/608/609） |
|
||||
| `tcp_server --port 8081` | PC 作 TCP 回显服务器（回显循环） | 测试 TCP Client（阶段 2 硬件层；阶段 7 Client 701/702/703） |
|
||||
| `tcp_client --ip ... --port 8080` | PC 作 TCP Client | 测试 TCP Echo（阶段 6/8/9） |
|
||||
| `tcp_file --ip ... --port 8080 --size 20480` | PC 作文件接收 | 测试大文件传输（阶段 7） |
|
||||
| `udp_client --ip ... --port 60000` | PC 作 UDP Client | 测试 UDP Echo（阶段 3） |
|
||||
| `udp_server --port 8082` | PC 作 UDP Server | 接收 CH395F UDP 数据 |
|
||||
| `stress --ip ... --port 8080 --count 10` | 压力测试 | 7 并发 × 10 轮 |
|
||||
| `dhcp_server ...` | DHCP Server | 内置 DHCP（阶段 4，需管理员权限） |
|
||||
|
||||
### 通用参数
|
||||
@@ -870,12 +1109,10 @@ IDLE → (连接建立) → SENDING(分块发) → RECVING(分块收+验证) →
|
||||
|
||||
---
|
||||
|
||||
## 13. 已知陷阱
|
||||
## 14. 已知陷阱
|
||||
|
||||
| ID | 陷阱 | 现象 | 修复 |
|
||||
|----|------|------|------|
|
||||
| TRAP-01 | ~~多连接初始化顺序~~ | 已废弃（单连接模式） | — |
|
||||
| TRAP-02 | ~~数据 socket 缓冲重叠~~ | 已废弃（单连接模式） | — |
|
||||
| TRAP-03 | DHCP xid 偏移错误 | DHCP 握手失败 | xid 在 `data[4:8]` |
|
||||
| TRAP-04 | UDP 无 SENDBUF_FREE 等待 | 后续接收挂起 | 每次 write 后等 SENDBUF_FREE |
|
||||
| TRAP-05 | PHY 不兼容 RTL8305NBI | 链路抖动 | `ch395f_set_phy(0x08)` 强制 100M_FULL |
|
||||
@@ -891,7 +1128,7 @@ IDLE → (连接建立) → SENDING(分块发) → RECVING(分块收+验证) →
|
||||
|
||||
---
|
||||
|
||||
## 附录 A：通过/失败汇总
|
||||
## 附录 B：通过/失败汇总
|
||||
|
||||
| 阶段 | TC ID | 优先级 | 类型 | 状态 |
|
||||
|------|-------|--------|------|------|
|
||||
@@ -906,45 +1143,47 @@ IDLE → (连接建立) → SENDING(分块发) → RECVING(分块收+验证) →
|
||||
| TM-PHY-04 | TC-NET-402 | P1 | 功能测试 | ✅ |
|
||||
| TM-PHY-05 | TC-NET-501 | P0 | 功能测试 | ✅ |
|
||||
| TM-PHY-05 | TC-NET-502 | P1 | 合规测试 | ✅ |
|
||||
| TM-PHY-06 | TC-NET-601 | P0 | 功能测试 | 🟡 |
|
||||
| TM-PHY-06 | TC-NET-602 | P0 | 功能测试 | 🟡 |
|
||||
| TM-PHY-06 | TC-NET-603 | P0 | 边界测试 | 🟡 |
|
||||
| TM-PHY-06 | TC-NET-604 | P0 | 边界测试 | 🟡 |
|
||||
| TM-PHY-06 | TC-NET-605 | P0 | 恢复测试 | 🟡 |
|
||||
| TM-PHY-06 | TC-NET-606 | P1 | 恢复测试 | 🟡 |
|
||||
| TM-PHY-06 | TC-NET-607 | P0 | 功能测试 | 🟠 |
|
||||
| TM-PHY-06 | TC-NET-608 | P0 | 恢复测试 | 🟠 |
|
||||
| TM-PHY-06 | TC-NET-609 | P1 | 负向测试 | 🟠 |
|
||||
| TM-PHY-07 | TC-NET-701 | P0 | 功能测试 | 🟡 |
|
||||
| TM-PHY-07 | TC-NET-702 | P1 | 边界测试 | 🟡 |
|
||||
| TM-PHY-08 | TC-NET-801 | P0 | 功能测试 | 🟡 |
|
||||
| TM-PHY-08 | TC-NET-802 | P1 | 负向测试 | 🟡 |
|
||||
| TM-PHY-09 | TC-NET-901 | P0 | 边界测试 | 🟡 |
|
||||
| TM-PHY-09 | TC-NET-902 | P0 | 边界测试 | 🟡 |
|
||||
| TM-PHY-09 | TC-NET-903 | P0 | 边界测试 | 🟡 |
|
||||
| TM-PHY-09 | TC-NET-904 | P1 | 负向测试 | 🟡 |
|
||||
| TM-PHY-09 | TC-NET-905 | P1 | 压力测试 | 🟡 |
|
||||
| TM-PHY-09 | TC-NET-906 | P1 | 稳定性测试 | 🟡 |
|
||||
| TM-PHY-10 | TC-NET-1001 | P1 | 功能测试 | 🟡 |
|
||||
| TM-PHY-06 | TC-NET-601 | P0 | 功能测试 | ✅ |
|
||||
| TM-PHY-06 | TC-NET-602 | P0 | 功能测试 | ✅ |
|
||||
| TM-PHY-06 | TC-NET-603 | P0 | 边界测试 | ✅ |
|
||||
| TM-PHY-06 | TC-NET-604 | P0 | 边界测试 | ✅ |
|
||||
| TM-PHY-06 | TC-NET-605 | P0 | 恢复测试 | ✅ |
|
||||
| TM-PHY-06 | TC-NET-606 | P1 | 恢复测试 | ✅ |
|
||||
| TM-PHY-07 | TC-NET-701 | P0 | 功能测试 | ✅ |
|
||||
| TM-PHY-07 | TC-NET-702 | P0 | 恢复测试 | ✅ |
|
||||
| TM-PHY-07 | TC-NET-703 | P1 | 负向测试 | ✅ |
|
||||
| TM-PHY-07 | TC-NET-704 | P0 | 并发测试 | ✅ |
|
||||
| TM-PHY-08 | TC-NET-801 | P0 | 文件发送 | ✅ |
|
||||
| TM-PHY-08 | TC-NET-802 | P0 | 文件接收 | 🟡 |
|
||||
| TM-PHY-08 | TC-NET-803 | P1 | 回显/压力 | 🟡 |
|
||||
| TM-PHY-09 | TC-NET-901 | P0 | 功能测试 | 🟡 |
|
||||
| TM-PHY-09 | TC-NET-902 | P1 | 负向测试 | 🟡 |
|
||||
| TM-PHY-10 | TC-NET-1001 | P0 | 边界测试 | 🟡 |
|
||||
| TM-PHY-10 | TC-NET-1002 | P0 | 边界测试 | 🟡 |
|
||||
| TM-PHY-10 | TC-NET-1003 | P0 | 边界测试 | 🟡 |
|
||||
| TM-PHY-10 | TC-NET-1004 | P1 | 负向测试 | 🟡 |
|
||||
| TM-PHY-10 | TC-NET-1005 | P1 | 压力测试 | 🟡 |
|
||||
| TM-PHY-10 | TC-NET-1006 | P1 | 稳定性测试 | 🟡 |
|
||||
| TM-PHY-11 | TC-NET-1101 | P1 | 功能测试 | 🟡 |
|
||||
|
||||
✅ = 已实现并验证 | 🟡 = 已实现待验证 | 🟠 = 待实现
|
||||
|
||||
## 附录 B：设计原则覆盖
|
||||
## 附录 C：设计原则覆盖
|
||||
|
||||
| 原则 | 覆盖用例 |
|
||||
|------|----------|
|
||||
| DP-01：单 socket 生命周期 | TC-NET-202, 203, 601, 605, 606, 906 |
|
||||
| DP-02：中断即读即清 | TC-NET-101, 102, 501, 502, 801 |
|
||||
| DP-01：单 socket 生命周期 | TC-NET-202, 203, 601, 605, 606, 701, 702, 703, 704, 801, 802, 901, 902, 1001~1006 |
|
||||
| DP-02：中断即读即清 | TC-NET-101, 102, 501, 502, 901 |
|
||||
| DP-03：消息队列线程安全 | TC-NET-301, 302, 401 |
|
||||
| DP-04：DMA 边界安全 | TC-NET-501, 502, 603, 604, 701, 702, 901, 902, 903, 904, 905 |
|
||||
| DP-04：DMA 边界安全 | TC-NET-501, 502, 603, 604, 801, 802, 1001~1005 |
|
||||
|
||||
## 附录 C：CH395F 边界条件速查
|
||||
## 附录 D：CH395F 边界条件速查
|
||||
|
||||
| 操作 | 大小 | 行为 |
|
||||
|------|------|------|
|
||||
| `net_send(buf, ≤1496)` | 1~1496B | 单次 DMA 事务（旧 DMABUF=1500 时完全容纳） |
|
||||
| `net_send(buf, 1497~4096)` | 1497~4096B | 旧代码**静默失败**；现 DMABUF=4100 **一次 DMA 容纳** |
|
||||
| `net_send(buf, 4097~65535)` | >4096B | `net_send_locked` **自动分块**，每块 4096B |
|
||||
| `net_send(buf, 4097~65535)` | >4096B | `net_send_locked` **自动分块**（受单 Socket 发送缓冲 1KB 约束；当前按 `NET_DMA_MAX_PAYLOAD=4096` 拆分，需实测） |
|
||||
| `net_send(buf, 0)` | 0 | 返回 `-1`（`NET_ERR_INVAL`） |
|
||||
| `ch395f_get_recv_len()` | 0~65535 | 返回 CH395F 硬件缓冲当前可用数据量 |
|
||||
| `ch395f_read_recv_buf(buf, 4096)` | 4096B | 一次性读空 Socket 0 整个接收缓冲 |
|
||||
|
||||
@@ -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。
|
||||
|
||||
BIN
rx_100k.bin
Normal file
BIN
rx_100k.bin
Normal file
Binary file not shown.
Binary file not shown.
@@ -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('<I', crc)
|
||||
|
||||
# ---- 发送数据 + CRC32 尾 ----
|
||||
t0 = time.time()
|
||||
sent = 0
|
||||
while sent < size:
|
||||
n = client_socket.send(data[sent:size])
|
||||
if n <= 0:
|
||||
log_error("发送中断")
|
||||
return False
|
||||
sent += n
|
||||
sent_f = 0
|
||||
while sent_f < 4:
|
||||
n = client_socket.send(footer[sent_f:4])
|
||||
if n <= 0:
|
||||
log_error("CRC 尾发送失败")
|
||||
return False
|
||||
sent_f += n
|
||||
ms = int((time.time() - t0) * 1000)
|
||||
rate = (size / 1024.0 / (ms / 1000.0)) if ms else 0.0
|
||||
log_success(f"已发送 {size} 字节 -> {args.file or '(pattern)'}，"
|
||||
f"CRC32=0x{crc:08X}，耗时 {ms}ms ({rate:.1f} KB/s)")
|
||||
return True
|
||||
|
||||
elif op == 'recv':
|
||||
rx = bytearray()
|
||||
t0 = time.time()
|
||||
while len(rx) < size:
|
||||
chunk = client_socket.recv(min(65536, size - len(rx)))
|
||||
if not chunk:
|
||||
log_error(f"对端提前关闭，仅收到 {len(rx)}/{size}")
|
||||
return False
|
||||
rx += chunk
|
||||
ms = int((time.time() - t0) * 1000)
|
||||
rate = (size / 1024.0 / (ms / 1000.0)) if ms else 0.0
|
||||
|
||||
ok = all(rx[i] == (i & 0xFF) for i in range(size))
|
||||
crc = zlib.crc32(bytes(rx)) & 0xFFFFFFFF
|
||||
if args.file:
|
||||
with open(args.file, 'wb') as f:
|
||||
f.write(rx)
|
||||
log_info(f"已写入文件 {args.file}")
|
||||
log_success(f"已接收 {size} 字节，耗时 {ms}ms ({rate:.1f} KB/s)，"
|
||||
f"递增模式校验={'通过' if ok else '失败'}，CRC32=0x{crc:08X}")
|
||||
return ok
|
||||
|
||||
elif op == 'echo':
|
||||
# MCU 为 server：先发 100KB，PC 原样回显，MCU 收齐后关闭连接
|
||||
log_info("回显模式：将把 MCU 发来的数据原样返回，直到对端关闭")
|
||||
t0 = time.time()
|
||||
echoed = 0
|
||||
while True:
|
||||
data = client_socket.recv(65536)
|
||||
if not data:
|
||||
break
|
||||
client_socket.sendall(data)
|
||||
echoed += len(data)
|
||||
ms = int((time.time() - t0) * 1000)
|
||||
rate = (echoed / 1024.0 / (ms / 1000.0)) if ms else 0.0
|
||||
log_success(f"回显完成，共 {echoed} 字节，耗时 {ms}ms ({rate:.1f} KB/s)")
|
||||
return True
|
||||
|
||||
except socket.timeout:
|
||||
log_error("传输超时")
|
||||
return False
|
||||
except Exception as e:
|
||||
log_error(f"错误: {e}")
|
||||
return False
|
||||
finally:
|
||||
client_socket.close()
|
||||
|
||||
|
||||
# ==================== 主程序 ====================
|
||||
|
||||
def main():
|
||||
@@ -1078,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:
|
||||
|
||||
@@ -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
|
||||
|
||||
/* 测试统计 */
|
||||
|
||||
@@ -3,7 +3,7 @@
|
||||
* 模块功能：CH395F 全阶段测试入口，统一在独立 FreeRTOS 任务中运行。
|
||||
* 测试分两组：
|
||||
* Phase 1~5（硬件层）— 阻塞式独占执行（各自有内部循环/等待），netTask 未运行
|
||||
* Phase 4~10（NET 层）— 事件驱动，TCP 监听循环中运行（需 PC 客户端连接）
|
||||
* Phase 4~11（NET 层）— 事件驱动，TCP 监听循环中运行（需 PC 客户端连接）
|
||||
* 所有测试结果通过 TEST_CHECK/TEST_REPORT 宏输出到串口。
|
||||
* 作者：王建锋
|
||||
* 创建日期：2026-07-22
|
||||
@@ -11,6 +11,7 @@
|
||||
|
||||
#include <string.h>
|
||||
#include "ch395f_test_task.h"
|
||||
#include "net_test_task.h"
|
||||
#include "cmsis_os.h"
|
||||
#include "net_task.h"
|
||||
#include "net_socket.h"
|
||||
@@ -31,20 +32,6 @@ extern volatile uint8_t g_net_ready;
|
||||
*/
|
||||
test_stats_t g_test_stats;
|
||||
|
||||
/*
|
||||
* 收发缓冲区 —— 全局静态，不在任务栈上。
|
||||
* s_tx_buf 仅在 Phase 7（大文件传输）和 Phase 9（边界条件）中使用，
|
||||
* 其他 Phase 不需要发送固定模式数据，故条件编译节省 RAM。
|
||||
*/
|
||||
#define TEST_BUF_SIZE 65536
|
||||
#if defined(ENABLE_PHASE6_TESTS) || defined(ENABLE_PHASE7_TESTS) || \
|
||||
defined(ENABLE_PHASE8_TESTS) || defined(ENABLE_PHASE9_TESTS) || \
|
||||
defined(ENABLE_PHASE10_TESTS)
|
||||
static uint8_t s_rx_buf[TEST_BUF_SIZE];
|
||||
#endif
|
||||
#if defined(ENABLE_PHASE7_TESTS) || defined(ENABLE_PHASE9_TESTS)
|
||||
static uint8_t s_tx_buf[TEST_BUF_SIZE];
|
||||
#endif
|
||||
|
||||
/* ===================================================================
|
||||
* Phase 1 — 寄存器与 SPI 命令路径验证
|
||||
@@ -55,7 +42,9 @@ static uint8_t s_tx_buf[TEST_BUF_SIZE];
|
||||
* 共 9 项测试（P1-01 ~ P1-09），逐项执行，汇总报告。
|
||||
* =================================================================== */
|
||||
|
||||
/* 解析点分十进制 IP 字符串为数组（避免引入 sscanf 库） */
|
||||
/* 解析点分十进制 IP 字符串为数组（避免引入 sscanf 库）。
|
||||
* 仅硬件层阶段（1~5）使用，NET 层无需此辅助。 */
|
||||
#if defined(ENABLE_HW_LAYER_TESTS)
|
||||
static void test_parse_ip(const char *str, uint8_t *ip_arr)
|
||||
{
|
||||
uint32_t val;
|
||||
@@ -73,6 +62,7 @@ static void test_parse_ip(const char *str, uint8_t *ip_arr)
|
||||
}
|
||||
}
|
||||
}
|
||||
#endif /* ENABLE_HW_LAYER_TESTS */
|
||||
|
||||
#ifdef ENABLE_PHASE1_TESTS
|
||||
static void phase1_run(void) {
|
||||
@@ -1351,385 +1341,10 @@ static void phase5_run(void) {
|
||||
TEST_REPORT("Phase 5");
|
||||
}
|
||||
#endif
|
||||
/* ===================================================================
|
||||
* Phase 6 — NET 层 TCP Echo（基础收发）
|
||||
*
|
||||
* 测试目的：验证 BSD Socket API（net_socket）的单连接 TCP Echo 通路。
|
||||
* Socket 0 复用监听和数据通道。PC 发任意数据，MCU 原样返回。
|
||||
* 这是 Phase 7/8/9/10 的基础。
|
||||
*
|
||||
* 入口条件：Socket 0 处于 ESTABLISHED（TCP 连接已建立）。
|
||||
* 通过：数据收发一致。
|
||||
* 失败：send/recv 数量不匹配。
|
||||
* =================================================================== */
|
||||
|
||||
#ifdef ENABLE_PHASE6_TESTS
|
||||
static uint32_t s_phase6_count = 0;
|
||||
|
||||
static void phase6_run(int sockfd) {
|
||||
/*
|
||||
* 使用 NET_MSG_DONTWAIT 非阻塞接收 —— 没有数据时立即返回，
|
||||
* 不阻塞任务循环（Phase 7/8/9/10 也共享同一个循环）。
|
||||
* 收到数据后立即原样发送回显。
|
||||
*/
|
||||
int n = net_recv(sockfd, s_rx_buf, TEST_BUF_SIZE, NET_MSG_DONTWAIT);
|
||||
if (n > 0) {
|
||||
int sent = net_send(sockfd, s_rx_buf, n, 0);
|
||||
if (sent != n) {
|
||||
DBG_ERROR("echo: send %d != recv %d", sent, n);
|
||||
return;
|
||||
}
|
||||
s_phase6_count++;
|
||||
if (s_phase6_count <= 10 || (s_phase6_count % 100 == 0)) {
|
||||
DBG_INFO("Phase6: echo #%lu (%d bytes)", s_phase6_count, n);
|
||||
}
|
||||
}
|
||||
}
|
||||
#endif
|
||||
|
||||
/* ===================================================================
|
||||
* Phase 7 — 大文件传输（超过 CH395F 硬件缓冲 4KB）
|
||||
*
|
||||
* 测试目的：验证超过 Socket 0 接收缓冲（4KB）的数据在 net_send/
|
||||
* net_recv 层的正确处理。net_send_locked 自动将大数据
|
||||
* 拆分为 ≤4096B 的块，每块通过一次 DMA 事务写入 CH395F。
|
||||
* 接收端同样分多次调用 ch395f_read_recv_buf 读空硬件缓冲。
|
||||
*
|
||||
* 数据模式：递增字节（s_tx_buf[i] = i & 0xFF），接收端按 offset 逐字节比对。
|
||||
* 通过：全部 20480 字节逐字节匹配。
|
||||
* 失败：任意字节不一致或收发过程中断。
|
||||
* =================================================================== */
|
||||
|
||||
#ifdef ENABLE_PHASE7_TESTS
|
||||
#define PHASE7_FILE_SIZE 20480
|
||||
|
||||
static void phase7_fill(uint8_t *buf, uint32_t size) {
|
||||
for (uint32_t i = 0; i < size; i++) {
|
||||
buf[i] = (uint8_t)(i & 0xFF);
|
||||
}
|
||||
}
|
||||
|
||||
static int phase7_verify(uint8_t *buf, uint32_t size, uint32_t offset) {
|
||||
for (uint32_t i = 0; i < size; i++) {
|
||||
if (buf[i] != (uint8_t)((offset + i) & 0xFF)) {
|
||||
DBG_ERROR("Phase7: mismatch at %lu (expect 0x%02X, got 0x%02X)",
|
||||
offset + i, (uint8_t)((offset + i) & 0xFF), buf[i]);
|
||||
return 0;
|
||||
}
|
||||
}
|
||||
return 1;
|
||||
}
|
||||
|
||||
static void phase7_run(int sockfd) {
|
||||
DBG_INFO("Phase7: starting %d-byte file transfer", PHASE7_FILE_SIZE);
|
||||
|
||||
phase7_fill(s_tx_buf, PHASE7_FILE_SIZE);
|
||||
|
||||
/*
|
||||
* 发送阶段：分块发送，每块最多 4096B。
|
||||
* net_send 内部通过消息队列转发到 netTask，由 net_send_locked
|
||||
* 按 CH395F_SPI_DMA_MAX_PAYLOAD（4096）自动拆分 DMA 事务。
|
||||
* 等待 PC 端回显（echod）全部数据。
|
||||
*/
|
||||
uint32_t sent = 0;
|
||||
while (sent < PHASE7_FILE_SIZE) {
|
||||
int chunk = (PHASE7_FILE_SIZE - sent) > 4096 ? 4096 : (PHASE7_FILE_SIZE - sent);
|
||||
int n = net_send(sockfd, s_tx_buf + sent, chunk, 0);
|
||||
if (n <= 0) {
|
||||
DBG_ERROR("Phase7: send fail at %lu (ret=%d)", sent, n);
|
||||
return;
|
||||
}
|
||||
sent += (uint32_t)n;
|
||||
DBG_INFO("Phase7: sent %lu/%d", sent, PHASE7_FILE_SIZE);
|
||||
}
|
||||
|
||||
/*
|
||||
* 接收阶段：分块接收，逐块验证。
|
||||
* PC 回显数据需与发送数据逐字节一致（递增模式）。
|
||||
* 验证失败立即返回，不继续接收剩余数据。
|
||||
*/
|
||||
uint32_t recvd = 0;
|
||||
while (recvd < PHASE7_FILE_SIZE) {
|
||||
int n = net_recv(sockfd, s_rx_buf, TEST_BUF_SIZE, 0);
|
||||
if (n <= 0) {
|
||||
DBG_ERROR("Phase7: recv fail at %lu (ret=%d)", recvd, n);
|
||||
return;
|
||||
}
|
||||
int ok = phase7_verify(s_rx_buf, (uint32_t)n, recvd);
|
||||
TEST_CHECK(ok, "Phase7: verify at %lu (%d bytes)", recvd, n);
|
||||
if (!ok) return;
|
||||
recvd += (uint32_t)n;
|
||||
}
|
||||
|
||||
TEST_CHECK(1, "Phase7: %d-byte file transfer complete", PHASE7_FILE_SIZE);
|
||||
}
|
||||
#endif
|
||||
|
||||
/* ===================================================================
|
||||
* Phase 8 — Select/Poll I/O 多路复用
|
||||
*
|
||||
* 测试目的：验证 net_select() API 在单 Socket 模式下正确工作：
|
||||
* 1. Socket 0 有数据到达时 select 返回正数
|
||||
* 2. NET_FD_ISSET 正确指示就绪的 Socket
|
||||
* 3. 超时（50ms 无数据）时返回 0
|
||||
*
|
||||
* 入口条件：Socket 0 处于 ESTABLISHED。
|
||||
* 通过：select 检测到数据并成功回显。
|
||||
* 失败：select 未检测到数据或回显失败。
|
||||
* =================================================================== */
|
||||
|
||||
#ifdef ENABLE_PHASE8_TESTS
|
||||
#include "net_select.h"
|
||||
static uint32_t s_phase8_count = 0;
|
||||
|
||||
static void phase8_run(int sockfd) {
|
||||
net_fd_set readfds;
|
||||
net_timeval tv;
|
||||
|
||||
/*
|
||||
* 配置 select：只监测 Socket 0 的可读状态，超时 50ms。
|
||||
* NET_FD_ZERO 清空集合，NET_FD_SET 添加 Socket 0。
|
||||
* 50ms 超时确保不阻塞任务循环太久。
|
||||
*/
|
||||
NET_FD_ZERO(&readfds);
|
||||
NET_FD_SET(sockfd, &readfds);
|
||||
tv.tv_sec = 0;
|
||||
tv.tv_usec = 50000;
|
||||
|
||||
int nfds = net_select(sockfd + 1, &readfds, NULL, NULL, &tv);
|
||||
if (nfds <= 0) return;
|
||||
|
||||
/* Socket 0 可读：非阻塞接收并回显 */
|
||||
if (NET_FD_ISSET(sockfd, &readfds)) {
|
||||
int n = net_recv(sockfd, s_rx_buf, TEST_BUF_SIZE, NET_MSG_DONTWAIT);
|
||||
if (n > 0) {
|
||||
int sent = net_send(sockfd, s_rx_buf, n, 0);
|
||||
if (sent == n) {
|
||||
s_phase8_count++;
|
||||
TEST_CHECK(1, "Phase8: select echo #%lu (%d bytes)", s_phase8_count, n);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
#endif
|
||||
|
||||
/* ===================================================================
|
||||
* Phase 9 — 边界条件测试
|
||||
*
|
||||
* 测试目的：验证以下 DMA 和协议栈边界情况：
|
||||
* 1. TC-NET-901: 4095B（SPI 最大载荷 -1，单次 DMA 容纳）
|
||||
* 2. TC-NET-902: 4096B（= SPI 最大载荷，填满单次 DMA）
|
||||
* 3. TC-NET-903: 4097B（超过 SPI 最大载荷，拆 2 次 DMA）
|
||||
* 4. TC-NET-904: 零长度发送（返回 -1）
|
||||
* 5. TC-NET-905: 20 × 100B 连续快速发送
|
||||
*
|
||||
* 各用例通过状态机（s_phase9_stage）串行执行，每次 phase9_run 推进一个
|
||||
* 步骤（发送→等待→接收→验证→下一阶段）。发送数据为递增模式字节
|
||||
* （buf[i] = seed + i），接收端按相同模式验证。
|
||||
*
|
||||
* 入口条件：Socket 0 处于 ESTABLISHED。
|
||||
* 通过：各用例自身判定。
|
||||
* =================================================================== */
|
||||
|
||||
#ifdef ENABLE_PHASE9_TESTS
|
||||
static int s_phase9_stage = 0;
|
||||
static uint32_t s_phase9_recv = 0;
|
||||
|
||||
static void phase9_fill(uint8_t *buf, uint32_t size, uint8_t seed) {
|
||||
for (uint32_t i = 0; i < size; i++) {
|
||||
buf[i] = (uint8_t)(seed + i);
|
||||
}
|
||||
}
|
||||
|
||||
static int phase9_verify(uint8_t *buf, uint32_t size, uint8_t seed) {
|
||||
for (uint32_t i = 0; i < size; i++) {
|
||||
if (buf[i] != (uint8_t)(seed + i)) return 0;
|
||||
}
|
||||
return 1;
|
||||
}
|
||||
|
||||
static void phase9_run(int sockfd) {
|
||||
/* 阶段 0 → 1：发送 4095B */
|
||||
if (s_phase9_stage == 0) {
|
||||
DBG_INFO("Phase9: 4095B (DMA-1)");
|
||||
phase9_fill(s_tx_buf, 4095, 0x10);
|
||||
int sent = net_send(sockfd, s_tx_buf, 4095, 0);
|
||||
TEST_CHECK(sent == 4095, "Phase9: send 4095B (sent=%d)", sent);
|
||||
s_phase9_recv = 0;
|
||||
s_phase9_stage = 1;
|
||||
return;
|
||||
}
|
||||
/* 阶段 1：接收并验证 4095B 回显 */
|
||||
if (s_phase9_stage == 1) {
|
||||
int n = net_recv(sockfd, s_rx_buf + s_phase9_recv, (int)(4095 - s_phase9_recv), 0);
|
||||
if (n > 0) {
|
||||
s_phase9_recv += (uint32_t)n;
|
||||
if (s_phase9_recv >= 4095) {
|
||||
TEST_CHECK(phase9_verify(s_rx_buf, 4095, 0x10), "Phase9: verify 4095B");
|
||||
s_phase9_stage = 2;
|
||||
}
|
||||
}
|
||||
return;
|
||||
}
|
||||
/* 阶段 2 → 3：发送 4096B（DMA 边界精确值） */
|
||||
if (s_phase9_stage == 2) {
|
||||
DBG_INFO("Phase9: 4096B (DMA exact)");
|
||||
phase9_fill(s_tx_buf, 4096, 0x20);
|
||||
int sent = net_send(sockfd, s_tx_buf, 4096, 0);
|
||||
TEST_CHECK(sent == 4096, "Phase9: send 4096B (sent=%d)", sent);
|
||||
s_phase9_recv = 0;
|
||||
s_phase9_stage = 3;
|
||||
return;
|
||||
}
|
||||
/* 阶段 3：接收并验证 4096B 回显 */
|
||||
if (s_phase9_stage == 3) {
|
||||
int n = net_recv(sockfd, s_rx_buf + s_phase9_recv, (int)(4096 - s_phase9_recv), 0);
|
||||
if (n > 0) {
|
||||
s_phase9_recv += (uint32_t)n;
|
||||
if (s_phase9_recv >= 4096) {
|
||||
TEST_CHECK(phase9_verify(s_rx_buf, 4096, 0x20), "Phase9: verify 4096B");
|
||||
s_phase9_stage = 4;
|
||||
}
|
||||
}
|
||||
return;
|
||||
}
|
||||
/* 阶段 4 → 5：发送 4097B（超过 DMA 上限，自动拆 4096+1） */
|
||||
if (s_phase9_stage == 4) {
|
||||
DBG_INFO("Phase9: 4097B (DMA+1, 2 SPI xacts)");
|
||||
phase9_fill(s_tx_buf, 4097, 0x30);
|
||||
int sent = net_send(sockfd, s_tx_buf, 4097, 0);
|
||||
TEST_CHECK(sent == 4097, "Phase9: send 4097B (sent=%d)", sent);
|
||||
s_phase9_recv = 0;
|
||||
s_phase9_stage = 5;
|
||||
return;
|
||||
}
|
||||
/* 阶段 5：接收并验证 4097B 回显 */
|
||||
if (s_phase9_stage == 5) {
|
||||
int n = net_recv(sockfd, s_rx_buf + s_phase9_recv, (int)(4097 - s_phase9_recv), 0);
|
||||
if (n > 0) {
|
||||
s_phase9_recv += (uint32_t)n;
|
||||
if (s_phase9_recv >= 4097) {
|
||||
TEST_CHECK(phase9_verify(s_rx_buf, 4097, 0x30), "Phase9: verify 4097B");
|
||||
s_phase9_stage = 6;
|
||||
}
|
||||
}
|
||||
return;
|
||||
}
|
||||
/* 阶段 6：零长度发送 —— 期望 net_send 返回 -1（NET_ERR_INVAL） */
|
||||
if (s_phase9_stage == 6) {
|
||||
DBG_INFO("Phase9: zero-length send");
|
||||
int sent = net_send(sockfd, s_tx_buf, 0, 0);
|
||||
TEST_CHECK(sent < 0, "Phase9: send 0B returns %d (expect <0)", sent);
|
||||
s_phase9_stage = 7;
|
||||
return;
|
||||
}
|
||||
/* 阶段 7：20 × 100B 快速发送 */
|
||||
if (s_phase9_stage == 7) {
|
||||
DBG_INFO("Phase9: 20x rapid sends (100B each)");
|
||||
phase9_fill(s_tx_buf, 100, 0x40);
|
||||
int all_ok = 1;
|
||||
for (int i = 0; i < 20; i++) {
|
||||
if (net_send(sockfd, s_tx_buf, 100, 0) != 100) {
|
||||
TEST_CHECK(0, "Phase9: rapid #%d fail", i + 1);
|
||||
all_ok = 0; break;
|
||||
}
|
||||
osDelay(1);
|
||||
}
|
||||
if (all_ok) {
|
||||
TEST_CHECK(1, "Phase9: 20x rapid sends OK");
|
||||
s_phase9_recv = 0;
|
||||
s_phase9_stage = 8;
|
||||
} else {
|
||||
s_phase9_stage = 0;
|
||||
}
|
||||
return;
|
||||
}
|
||||
/* 阶段 8：接收 2000B 回显总和并验证 */
|
||||
if (s_phase9_stage == 8) {
|
||||
int n = net_recv(sockfd, s_rx_buf + s_phase9_recv, (int)(2000 - s_phase9_recv), 0);
|
||||
if (n > 0) {
|
||||
s_phase9_recv += (uint32_t)n;
|
||||
if (s_phase9_recv >= 2000) {
|
||||
TEST_CHECK(1, "Phase9: all echo received");
|
||||
TEST_REPORT("Phase 9");
|
||||
s_phase9_stage = 0;
|
||||
}
|
||||
}
|
||||
return;
|
||||
}
|
||||
}
|
||||
#endif
|
||||
|
||||
/* ===================================================================
|
||||
* Phase 10 — TCP KeepAlive 超时断开
|
||||
*
|
||||
* 测试目的：验证 CH395F 的 TCP KeepAlive 机制：
|
||||
* 1. 连接空闲超过 idle 阈值（60s）后开始发送探测包
|
||||
* 2. 探测无响应（默认 3 次 × 5s = 15s）后触发 TIMEOUT
|
||||
* 3. Socket 自动关闭并回到 LISTEN
|
||||
*
|
||||
* 入口条件：Socket 0 处于 ESTABLISHED，PC 连接后静置（不发数据）。
|
||||
* 通过：KeepAlive 断开时间 ≥ 60s（从连接建立到 recv 返回 0 的间隔）。
|
||||
* 失败：不到 60s 就断开（可能是其他原因导致）或 75s 后仍未断开。
|
||||
* =================================================================== */
|
||||
|
||||
#ifdef ENABLE_PHASE10_TESTS
|
||||
static int s_phase10_armed = 0;
|
||||
static uint32_t s_phase10_start = 0;
|
||||
|
||||
static void phase10_run(int sockfd) {
|
||||
/*
|
||||
* 第一次调用：记录开始时间并 arm。
|
||||
* 后续调用：非阻塞 recv，若返回 0 表示连接已断开（KeepAlive 触发）。
|
||||
* 计算耗时与 60s idle 阈值比较。
|
||||
*/
|
||||
if (!s_phase10_armed) {
|
||||
s_phase10_armed = 1;
|
||||
s_phase10_start = HAL_GetTick();
|
||||
DBG_INFO("Phase10: idle wait for KeepAlive timeout (60s)");
|
||||
return;
|
||||
}
|
||||
|
||||
int n = net_recv(sockfd, s_rx_buf, 64, NET_MSG_DONTWAIT);
|
||||
if (n == 0) {
|
||||
uint32_t elapsed = HAL_GetTick() - s_phase10_start;
|
||||
TEST_CHECK(elapsed >= 60000,
|
||||
"Phase10: KeepAlive triggered after %lums (expect >=60000ms)", elapsed);
|
||||
TEST_REPORT("Phase 10");
|
||||
s_phase10_armed = 0;
|
||||
}
|
||||
}
|
||||
#endif
|
||||
|
||||
/* ===================================================================
|
||||
* 任务入口：StartCh395fTestTask
|
||||
*
|
||||
* 执行顺序（按构建模式二选一，见 docs/CH395F_Test_Guide.md「构建模式与执行顺序」）：
|
||||
* 硬件层模式（阶段 1~5）：netTask 不创建，本任务调用
|
||||
* net_stack_bring_up() 完成协议栈初始化后独占 CH395F 阻塞执行。
|
||||
* NET 层模式（阶段 6~10）：
|
||||
* 1. 等待 g_net_ready（netTask 初始化完成标志）
|
||||
* 2. 创建 TCP 监听 Socket（单连接模式，端口 8080）
|
||||
* 3. 进入事件驱动循环，等待 PC 连接并执行 NET 层测试
|
||||
*
|
||||
* 单连接模式说明：
|
||||
* Socket 0 复用监听和数据通道。accept 返回的 fd 与监听 fd 相同。
|
||||
* 连接断开后需重新 listen。连接恢复检测在循环末尾通过
|
||||
* net_get_sock() 检查状态并自动处理。
|
||||
* =================================================================== */
|
||||
|
||||
void StartCh395fTestTask(void *argument)
|
||||
{
|
||||
(void)argument;
|
||||
|
||||
#if defined(ENABLE_NET_LAYER_TESTS)
|
||||
int sockfd = -1;
|
||||
int phase_active = 0;
|
||||
uint32_t accept_retry = 0;
|
||||
struct net_sockaddr_in client_addr;
|
||||
int addrlen = sizeof(client_addr);
|
||||
#endif
|
||||
|
||||
DBG_INFO("Test task started");
|
||||
|
||||
#if defined(ENABLE_HW_LAYER_TESTS)
|
||||
@@ -1737,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);
|
||||
}
|
||||
|
||||
904
test/net_test_task.c
Normal file
904
test/net_test_task.c
Normal file
@@ -0,0 +1,904 @@
|
||||
/*****************************************************************************
|
||||
* 模块名称：CH395F NET 层测试（Phase 6~11）
|
||||
* 模块功能：基于 BSD Socket API（单连接模式）的 NET 层测试，由 ch395fTestTask
|
||||
* 任务内的 net_layer_test_main() / net_layer_client_test_main() 事件
|
||||
* 循环驱动，需 PC 配合。
|
||||
* 包含 Phase 6(TCP Echo) / 7(TCP Client) / 8(大文件) / 9(Select) /
|
||||
* 10(边界) / 11(KeepAlive) 及监听循环。
|
||||
* 作者：王建锋
|
||||
* 创建日期：2026-07-22
|
||||
******************************************************************************/
|
||||
|
||||
#include <string.h>
|
||||
#include "cmsis_os.h"
|
||||
#include "net_socket.h"
|
||||
#include "net_types.h"
|
||||
#include "ch395f_test.h"
|
||||
#include "ch395f_test_task.h"
|
||||
#include "net_test_task.h"
|
||||
|
||||
#define DBG_TAG "[NET_TEST]"
|
||||
#include "dbg_log.h"
|
||||
|
||||
/*
|
||||
* 收发缓冲区 —— 全局静态，不在任务栈上。
|
||||
* s_rx_buf 仅在 Phase 6(Echo)/8(大文件)/10(边界)/11(KeepAlive) 中使用。
|
||||
* s_tx_buf 仅在 Phase 8(大文件) 和 Phase 10(边界) 中使用。
|
||||
* Phase 7(TCP Client) 使用函数内局部小缓冲（64B 递增 + 回显）。
|
||||
*
|
||||
* 大小依据：
|
||||
* - CH395F 单 Socket 接收缓冲按 1KB block 配置（net_socket.c 中
|
||||
* set_recv_buf(sock, 30, 2) = 2KB），单次 net_recv 至多返回 ~2KB，
|
||||
* 故 s_rx_buf 实际只需 ≥ 2KB（此处 32KB 留足余量）。
|
||||
* - Phase 8(大文件) 现改为流式分块：每次仅填一个窗口（≤1024B）即发出，
|
||||
* 不再一次性填入整文件，故 s_tx_buf 只需 ≥ 单窗口大小（此处 32KB 留足余量）。
|
||||
* 取 32KB(32768) 同时满足两者并留余量，且为 2 的幂；相比原 64KB
|
||||
* 在 STM32F4（128KB RAM）上节省一半静态空间。
|
||||
*/
|
||||
#define TEST_BUF_SIZE 32768
|
||||
|
||||
|
||||
/* ===================================================================
|
||||
* Phase 6 — NET 层 TCP Echo（基础收发）
|
||||
*
|
||||
* 测试目的：验证 BSD Socket API（net_socket）的单连接 TCP Echo 通路。
|
||||
* Socket 0 复用监听和数据通道。PC 发任意数据，MCU 原样返回。
|
||||
* 这是 Phase 7/8/9/10 的基础。
|
||||
*
|
||||
* 入口条件：Socket 0 处于 ESTABLISHED（TCP 连接已建立）。
|
||||
* 通过：数据收发一致。
|
||||
* 失败：send/recv 数量不匹配。
|
||||
* =================================================================== */
|
||||
|
||||
#ifdef ENABLE_PHASE6_TESTS
|
||||
static void phase6_run(int sockfd) {
|
||||
/*
|
||||
* 单连接 TCP Echo：NET_MSG_DONTWAIT 非阻塞收，原样回显。
|
||||
* 连接断开由 net 层自动重监听（auto_relisten），应用层不维护生命周期；
|
||||
* 字节完整性由 PC 侧校验（data == test_data），固件不做每连接自检。
|
||||
*/
|
||||
int n = net_recv(sockfd, s_rx_buf, TEST_BUF_SIZE, NET_MSG_DONTWAIT);
|
||||
if (n > 0) {
|
||||
int sent = net_send(sockfd, s_rx_buf, n, 0);
|
||||
if (sent != n) {
|
||||
DBG_ERROR("echo: send %d != recv %d", sent, n);
|
||||
}
|
||||
}
|
||||
}
|
||||
#endif
|
||||
|
||||
/* ===================================================================
|
||||
* Phase 7 — NET 层 TCP Client（主动连接 PC 回显服务器）
|
||||
*
|
||||
* 测试目的：验证 BSD Socket API 的 TCP Client 路径（net_socket + net_bind
|
||||
* + net_connect + net_send + net_recv）：
|
||||
* 1. MCU 主动连接 PC 回显服务器（192.168.1.2:8080）
|
||||
* 2. 64B 递增数据回显后，固件侧逐字节比对 + 32 位累加和校验
|
||||
* 3. 关闭并重新连接（规避 TIME_WAIT：每轮换本地端口）
|
||||
* 4. 连接超时负向用例（PC 服务关闭时 connect 不应成功）
|
||||
*
|
||||
* 入口条件：PC 运行 `python test/ch395f_socket_test.py tcp_server --port 8081`
|
||||
* （TC 703 需先关闭该服务）。
|
||||
* TC 映射：TC 701（连接 + 回显）/ TC 702（关闭重连）/ TC 703（连接超时）。
|
||||
* 通过：回显逐字节一致且 32 位 checksum 匹配；重连全部成功；超时用例未建连。
|
||||
* 失败：连接失败 / 回显不一致 / 重连中断 / 超时用例误建连。
|
||||
* =================================================================== */
|
||||
|
||||
#ifdef ENABLE_PHASE7_TESTS
|
||||
#include "net_select.h"
|
||||
|
||||
#ifndef PHASE7_REMOTE_IP
|
||||
#define PHASE7_REMOTE_IP "192.168.1.2"
|
||||
#endif
|
||||
#ifndef PHASE7_REMOTE_PORT
|
||||
#define PHASE7_REMOTE_PORT 8081
|
||||
#endif
|
||||
#ifndef PHASE7_LOCAL_PORT
|
||||
#define PHASE7_LOCAL_PORT 50000
|
||||
#endif
|
||||
#ifndef PHASE7_LOOP_COUNT
|
||||
#define PHASE7_LOOP_COUNT 3
|
||||
#endif
|
||||
#ifndef PHASE7_EXCH_SIZE
|
||||
#define PHASE7_EXCH_SIZE 64
|
||||
#endif
|
||||
#ifndef PHASE7_CONN_TIMEOUT_MS
|
||||
#define PHASE7_CONN_TIMEOUT_MS 10000
|
||||
#endif
|
||||
#ifndef PHASE7_TIMEOUT_TEST_MS
|
||||
#define PHASE7_TIMEOUT_TEST_MS 30000 /* TC 703 连接超时窗（指南规定 30s） */
|
||||
#endif
|
||||
|
||||
/* 32 位累加和：足以发现丢字节/错位，比 CRC32 便宜 */
|
||||
static uint32_t phase7_cksum(const uint8_t *p, uint32_t n) {
|
||||
uint32_t s = 0;
|
||||
while (n--) s += *p++;
|
||||
return s;
|
||||
}
|
||||
|
||||
/* 单次 TCP Client 会话：对应 TC 701 主体 / TC 702 单轮。
|
||||
* 每轮使用不同本地端口 local_port 规避 TIME_WAIT。
|
||||
* 返回 1 表示全流程通过，0 表示中途失败（已记录 TEST_CHECK）。 */
|
||||
static int phase7_session(uint16_t local_port)
|
||||
{
|
||||
int sockfd = net_socket(NET_AF_INET, NET_SOCK_STREAM, 0);
|
||||
if (sockfd < 0) {
|
||||
TEST_CHECK(0, "TC701 socket create");
|
||||
return 0;
|
||||
}
|
||||
|
||||
/* 绑定本地端口（不同轮用不同端口规避 TIME_WAIT） */
|
||||
{
|
||||
struct net_sockaddr_in laddr;
|
||||
memset(&laddr, 0, sizeof(laddr));
|
||||
laddr.sin_family = NET_AF_INET;
|
||||
laddr.sin_port = net_htons(local_port);
|
||||
if (net_bind(sockfd, (struct net_sockaddr *)&laddr, sizeof(laddr)) < 0) {
|
||||
TEST_CHECK(0, "TC701 bind port %d", local_port);
|
||||
net_close(sockfd);
|
||||
return 0;
|
||||
}
|
||||
}
|
||||
|
||||
/* 目标地址 */
|
||||
struct net_sockaddr_in raddr;
|
||||
memset(&raddr, 0, sizeof(raddr));
|
||||
raddr.sin_family = NET_AF_INET;
|
||||
raddr.sin_port = net_htons((uint16_t)PHASE7_REMOTE_PORT);
|
||||
raddr.sin_addr.s_addr = net_inet_addr(PHASE7_REMOTE_IP);
|
||||
|
||||
DBG_INFO("TC701 connecting %s:%d (local port %d)",
|
||||
PHASE7_REMOTE_IP, PHASE7_REMOTE_PORT, local_port);
|
||||
int rc = net_connect(sockfd, (struct net_sockaddr *)&raddr, sizeof(raddr));
|
||||
TEST_CHECK(rc == 0, "TC701 connect issued (ret=%d)", rc);
|
||||
if (rc != 0) { net_close(sockfd); return 0; }
|
||||
|
||||
/* 等待连接建立：轮询 socket 状态（ESTABLISHED）。
|
||||
* 用 net_select 触发 net_poll 并作为 100ms 节拍，状态以 net_get_sock 为准。 */
|
||||
{
|
||||
int connected = 0;
|
||||
uint32_t tick = HAL_GetTick();
|
||||
while (HAL_GetTick() - tick < PHASE7_CONN_TIMEOUT_MS) {
|
||||
net_sock_t *sk = net_get_sock(sockfd);
|
||||
if (sk && sk->state == NET_SOCK_STATE_ESTABLISHED) {
|
||||
connected = 1; break;
|
||||
}
|
||||
if (sk && sk->state == NET_SOCK_STATE_CLOSED) {
|
||||
break; /* 连接失败 */
|
||||
}
|
||||
osDelay(100); /* 仅作等待/让出 CPU；连接状态由 netTask 的 net_poll 每 10ms 刷新 */
|
||||
}
|
||||
TEST_CHECK(connected, "TC701 connected within %dms", PHASE7_CONN_TIMEOUT_MS);
|
||||
if (!connected) { net_close(sockfd); return 0; }
|
||||
}
|
||||
|
||||
/* 数据交换：64B 递增模式 */
|
||||
uint8_t tx[PHASE7_EXCH_SIZE];
|
||||
uint8_t rx[PHASE7_EXCH_SIZE];
|
||||
for (int i = 0; i < PHASE7_EXCH_SIZE; i++) tx[i] = (uint8_t)i;
|
||||
|
||||
int sent = net_send(sockfd, tx, PHASE7_EXCH_SIZE, 0);
|
||||
TEST_CHECK(sent == PHASE7_EXCH_SIZE, "TC701 send %dB (sent=%d)", PHASE7_EXCH_SIZE, sent);
|
||||
if (sent != PHASE7_EXCH_SIZE) { net_close(sockfd); return 0; }
|
||||
|
||||
int recvd = 0;
|
||||
uint32_t tick = HAL_GetTick();
|
||||
while (recvd < PHASE7_EXCH_SIZE) {
|
||||
int n = net_recv(sockfd, rx + recvd, PHASE7_EXCH_SIZE - recvd, NET_MSG_DONTWAIT);
|
||||
if (n > 0) {
|
||||
recvd += n;
|
||||
} else if (n == 0) {
|
||||
break; /* 对端关闭 */
|
||||
} else if (n < 0 && net_get_errno() == NET_ERR_WOULDBLOCK) {
|
||||
if (HAL_GetTick() - tick > PHASE7_CONN_TIMEOUT_MS) break;
|
||||
osDelay(10);
|
||||
continue;
|
||||
} else {
|
||||
break; /* 其它错误 */
|
||||
}
|
||||
if (HAL_GetTick() - tick > PHASE7_CONN_TIMEOUT_MS) break;
|
||||
}
|
||||
|
||||
int ok = (recvd == PHASE7_EXCH_SIZE);
|
||||
if (ok) {
|
||||
int bad = 0;
|
||||
for (int i = 0; i < PHASE7_EXCH_SIZE; i++) {
|
||||
if (rx[i] != (uint8_t)i) { bad = 1; break; }
|
||||
}
|
||||
TEST_CHECK(!bad, "TC701 byte-compare %dB", PHASE7_EXCH_SIZE);
|
||||
TEST_CHECK(1, "TC701 recv %dB, cksum=0x%08X", recvd, phase7_cksum(rx, PHASE7_EXCH_SIZE));
|
||||
} else {
|
||||
TEST_CHECK(0, "TC701 recv %dB (expect %d)", recvd, PHASE7_EXCH_SIZE);
|
||||
}
|
||||
|
||||
net_close(sockfd);
|
||||
return ok;
|
||||
}
|
||||
|
||||
/* TC 703（负向）：连接超时。PC 未在 REMOTE_IP:REMOTE_PORT 提供服务时，
|
||||
* connect 不应成功建立。本用例需先关闭 PC 端 tcp_server（与 TC 701/702 互斥环境：
|
||||
* 701/702 要求服务端在线，703 要求服务端离线，故 703 应在独立的一轮中运行）。 */
|
||||
static void phase7_test_timeout(void)
|
||||
{
|
||||
int sockfd = net_socket(NET_AF_INET, NET_SOCK_STREAM, 0);
|
||||
if (sockfd < 0) { TEST_CHECK(0, "TC703 socket create"); return; }
|
||||
|
||||
struct net_sockaddr_in raddr;
|
||||
memset(&raddr, 0, sizeof(raddr));
|
||||
raddr.sin_family = NET_AF_INET;
|
||||
raddr.sin_port = net_htons((uint16_t)PHASE7_REMOTE_PORT);
|
||||
raddr.sin_addr.s_addr = net_inet_addr(PHASE7_REMOTE_IP);
|
||||
|
||||
DBG_INFO("TC703 connecting %s:%d (expect TIMEOUT, PC server must be OFF)",
|
||||
PHASE7_REMOTE_IP, PHASE7_REMOTE_PORT);
|
||||
int rc = net_connect(sockfd, (struct net_sockaddr *)&raddr, sizeof(raddr));
|
||||
TEST_CHECK(rc == 0, "TC703 connect issued (ret=%d)", rc);
|
||||
if (rc != 0) { net_close(sockfd); return; }
|
||||
|
||||
int established = 0;
|
||||
uint32_t tick = HAL_GetTick();
|
||||
while (HAL_GetTick() - tick < PHASE7_TIMEOUT_TEST_MS) {
|
||||
net_sock_t *sk = net_get_sock(sockfd);
|
||||
if (sk && sk->state == NET_SOCK_STATE_ESTABLISHED) { established = 1; break; }
|
||||
if (sk && sk->state == NET_SOCK_STATE_CLOSED) break;
|
||||
osDelay(100); /* 仅作等待/让出 CPU；连接状态由 netTask 的 net_poll 每 10ms 刷新 */
|
||||
}
|
||||
if (established) {
|
||||
TEST_CHECK(0, "TC703 connected?! stop PC server and retry");
|
||||
} else {
|
||||
TEST_CHECK(1, "TC703 no-connect within %dms (timeout as expected)", PHASE7_TIMEOUT_TEST_MS);
|
||||
}
|
||||
net_close(sockfd);
|
||||
}
|
||||
|
||||
/* TC 704：多 Socket 并发 TCP Client。
|
||||
* 多 Socket 模式下 Socket 1~7 才可用；本用例同时打开 Socket 0~7，
|
||||
* 各自连 PC echo server，每路独立收发 PHASE7_EXCH_SIZE 字节回显并比对，
|
||||
* 验证 8 个 Socket 均能独立工作。依赖 PC 端 tcp_server 支持并发连接。 */
|
||||
#ifndef PHASE7_MULTI_COUNT
|
||||
#define PHASE7_MULTI_COUNT 8
|
||||
#endif
|
||||
#ifndef PHASE7_MULTI_BASE_PORT
|
||||
#define PHASE7_MULTI_BASE_PORT 51000
|
||||
#endif
|
||||
|
||||
static int phase7_session_multi(void)
|
||||
{
|
||||
int sockfd[PHASE7_MULTI_COUNT];
|
||||
uint8_t tx[PHASE7_EXCH_SIZE];
|
||||
uint8_t rx[PHASE7_EXCH_SIZE];
|
||||
for (int i = 0; i < PHASE7_EXCH_SIZE; i++) tx[i] = (uint8_t)i;
|
||||
|
||||
/* 1) 打开并连接所有 Socket（各自绑定不同本地端口规避 TIME_WAIT） */
|
||||
for (int i = 0; i < PHASE7_MULTI_COUNT; i++) {
|
||||
sockfd[i] = net_socket(NET_AF_INET, NET_SOCK_STREAM, 0);
|
||||
if (sockfd[i] < 0) {
|
||||
TEST_CHECK(0, "TC704 socket create #%d", i);
|
||||
for (int j = 0; j < i; j++) net_close(sockfd[j]);
|
||||
return 0;
|
||||
}
|
||||
struct net_sockaddr_in laddr;
|
||||
memset(&laddr, 0, sizeof(laddr));
|
||||
laddr.sin_family = NET_AF_INET;
|
||||
laddr.sin_port = net_htons((uint16_t)(PHASE7_MULTI_BASE_PORT + i));
|
||||
if (net_bind(sockfd[i], (struct net_sockaddr *)&laddr, sizeof(laddr)) < 0) {
|
||||
TEST_CHECK(0, "TC704 bind #%d port %d", i, PHASE7_MULTI_BASE_PORT + i);
|
||||
net_close(sockfd[i]);
|
||||
for (int j = 0; j < i; j++) net_close(sockfd[j]);
|
||||
return 0;
|
||||
}
|
||||
struct net_sockaddr_in raddr;
|
||||
memset(&raddr, 0, sizeof(raddr));
|
||||
raddr.sin_family = NET_AF_INET;
|
||||
raddr.sin_port = net_htons((uint16_t)PHASE7_REMOTE_PORT);
|
||||
raddr.sin_addr.s_addr = net_inet_addr(PHASE7_REMOTE_IP);
|
||||
int rc = net_connect(sockfd[i], (struct net_sockaddr *)&raddr, sizeof(raddr));
|
||||
TEST_CHECK(rc == 0, "TC704 connect #%d issued (ret=%d)", i, rc);
|
||||
if (rc != 0) {
|
||||
net_close(sockfd[i]);
|
||||
for (int j = 0; j < i; j++) net_close(sockfd[j]);
|
||||
return 0;
|
||||
}
|
||||
}
|
||||
|
||||
/* 2) 等待所有连接建立（或超时） */
|
||||
{
|
||||
uint32_t tick = HAL_GetTick();
|
||||
int all_up = 0;
|
||||
while (HAL_GetTick() - tick < PHASE7_CONN_TIMEOUT_MS) {
|
||||
all_up = 1;
|
||||
for (int i = 0; i < PHASE7_MULTI_COUNT; i++) {
|
||||
net_sock_t *sk = net_get_sock(sockfd[i]);
|
||||
if (!sk || sk->state != NET_SOCK_STATE_ESTABLISHED) { all_up = 0; break; }
|
||||
}
|
||||
if (all_up) break;
|
||||
osDelay(100);
|
||||
}
|
||||
TEST_CHECK(all_up, "TC704 all %d sockets established within %dms", PHASE7_MULTI_COUNT, PHASE7_CONN_TIMEOUT_MS);
|
||||
if (!all_up) {
|
||||
for (int i = 0; i < PHASE7_MULTI_COUNT; i++) {
|
||||
net_sock_t *sk = net_get_sock(sockfd[i]);
|
||||
if (sk) DBG_ERROR("TC704 socket #%d state=%d", i, sk->state);
|
||||
net_close(sockfd[i]);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
}
|
||||
|
||||
/* 3) 每路独立收发回显 */
|
||||
int ok = 1;
|
||||
for (int i = 0; i < PHASE7_MULTI_COUNT; i++) {
|
||||
int sent = net_send(sockfd[i], tx, PHASE7_EXCH_SIZE, 0);
|
||||
if (sent != PHASE7_EXCH_SIZE) {
|
||||
TEST_CHECK(0, "TC704 socket #%d send %dB (sent=%d)", i, PHASE7_EXCH_SIZE, sent);
|
||||
ok = 0;
|
||||
continue;
|
||||
}
|
||||
int recvd = 0;
|
||||
uint32_t tick = HAL_GetTick();
|
||||
while (recvd < PHASE7_EXCH_SIZE) {
|
||||
int n = net_recv(sockfd[i], rx + recvd, PHASE7_EXCH_SIZE - recvd, NET_MSG_DONTWAIT);
|
||||
if (n > 0) recvd += n;
|
||||
else if (n == 0) break;
|
||||
else if (n < 0 && net_get_errno() == NET_ERR_WOULDBLOCK) {
|
||||
if (HAL_GetTick() - tick > PHASE7_CONN_TIMEOUT_MS) break;
|
||||
osDelay(10);
|
||||
continue;
|
||||
} else break;
|
||||
if (HAL_GetTick() - tick > PHASE7_CONN_TIMEOUT_MS) break;
|
||||
}
|
||||
int sock_ok = (recvd == PHASE7_EXCH_SIZE);
|
||||
if (sock_ok) {
|
||||
int bad = 0;
|
||||
for (int k = 0; k < PHASE7_EXCH_SIZE; k++) if (rx[k] != (uint8_t)k) { bad = 1; break; }
|
||||
TEST_CHECK(!bad, "TC704 socket #%d echo %dB OK", i, PHASE7_EXCH_SIZE);
|
||||
} else {
|
||||
TEST_CHECK(0, "TC704 socket #%d recv %dB (expect %d)", i, recvd, PHASE7_EXCH_SIZE);
|
||||
ok = 0;
|
||||
}
|
||||
}
|
||||
|
||||
/* 4) 关闭所有 */
|
||||
for (int i = 0; i < PHASE7_MULTI_COUNT; i++) net_close(sockfd[i]);
|
||||
|
||||
return ok;
|
||||
}
|
||||
|
||||
void net_layer_client_test_main(void)
|
||||
{
|
||||
DBG_INFO("=== CH395F Phase 7 Tests (NET TCP Client) ===");
|
||||
|
||||
DBG_INFO("--- TC 701: connect + %dB echo exchange ---", PHASE7_EXCH_SIZE);
|
||||
phase7_session((uint16_t)PHASE7_LOCAL_PORT);
|
||||
|
||||
DBG_INFO("--- TC 702: close/reconnect x%d ---", PHASE7_LOOP_COUNT);
|
||||
{
|
||||
int all_ok = 1;
|
||||
for (int i = 0; i < PHASE7_LOOP_COUNT; i++) {
|
||||
if (!phase7_session((uint16_t)(PHASE7_LOCAL_PORT + 1 + i))) all_ok = 0;
|
||||
}
|
||||
TEST_CHECK(all_ok, "TC702 reconnect x%d all passed", PHASE7_LOOP_COUNT);
|
||||
}
|
||||
|
||||
DBG_INFO("--- TC 704: %d-socket concurrent client (PC %s:%d MUST be ON) ---",
|
||||
PHASE7_MULTI_COUNT, PHASE7_REMOTE_IP, PHASE7_REMOTE_PORT);
|
||||
phase7_session_multi();
|
||||
|
||||
DBG_INFO("--- TC 703: connect timeout (PC %s:%d MUST be OFF) ---",
|
||||
PHASE7_REMOTE_IP, PHASE7_REMOTE_PORT);
|
||||
phase7_test_timeout();
|
||||
|
||||
TEST_REPORT("Phase 7");
|
||||
}
|
||||
#endif
|
||||
|
||||
/* ===================================================================
|
||||
* Phase 8 — 大文件 / 批量传输（默认 100KB，文件收发）
|
||||
*
|
||||
* 测试目的：验证超过 Socket 接收缓冲（2KB）的大块数据在 net_send /
|
||||
* net_recv 层经分块后的正确处理；并支持「文件发送(MCU→PC) /
|
||||
* 文件接收(PC→MCU) / 回显 round-trip」三种方向。
|
||||
*
|
||||
* 数据模式：递增字节，绝对位置 p 处字节 = (p & 0xFF)；发送端按窗口
|
||||
* (offset + i) 生成，接收端按 offset 逐字节比对（自校验）。
|
||||
* 整包另用 CRC32（与 PC zlib.crc32 一致）做整体校验。
|
||||
*
|
||||
* 缓冲策略：s_tx_buf / s_rx_buf 仅 32KB，100KB 须按窗口逐块生成/校验，
|
||||
* 不整体驻留 RAM（流式分块）。
|
||||
*
|
||||
* 方向选择（编译宏 PHASE8_DIRECTION）：
|
||||
* 0 = ECHO 发 100KB 经 PC 回显，MCU 收齐校验（默认）
|
||||
* 1 = SEND MCU 发 100KB，PC 落盘 rx_100k.bin 校验
|
||||
* 2 = RECV PC 发 100KB（+4B CRC32 尾），MCU 收齐字节+CRC 校验
|
||||
* =================================================================== */
|
||||
|
||||
/* Phase 8 方向配置：须早于下方缓冲声明，以按方向精确控制 s_tx_buf 等是否参与编译 */
|
||||
#ifdef ENABLE_PHASE8_TESTS
|
||||
#define PHASE8_DIR_ECHO 0
|
||||
#define PHASE8_DIR_SEND 1
|
||||
#define PHASE8_DIR_RECV 2
|
||||
#ifndef PHASE8_FILE_SIZE
|
||||
#define PHASE8_FILE_SIZE 102400 /* 100KB */
|
||||
#endif
|
||||
#ifndef PHASE8_DIRECTION
|
||||
#define PHASE8_DIRECTION PHASE8_DIR_ECHO
|
||||
#endif
|
||||
#endif
|
||||
|
||||
#if defined(ENABLE_PHASE6_TESTS) || \
|
||||
(defined(ENABLE_PHASE8_TESTS) && (PHASE8_DIRECTION != PHASE8_DIR_SEND)) || \
|
||||
defined(ENABLE_PHASE10_TESTS) || defined(ENABLE_PHASE11_TESTS)
|
||||
static uint8_t s_rx_buf[TEST_BUF_SIZE];
|
||||
#endif
|
||||
/* s_tx_buf 仅 SEND/ECHO（及 Phase 10）需要；RECV 不发送，避免未使用变量警告 */
|
||||
#if (defined(ENABLE_PHASE8_TESTS) && (PHASE8_DIRECTION != PHASE8_DIR_RECV)) || \
|
||||
defined(ENABLE_PHASE10_TESTS)
|
||||
static uint8_t s_tx_buf[TEST_BUF_SIZE];
|
||||
#endif
|
||||
|
||||
|
||||
#ifdef ENABLE_PHASE8_TESTS
|
||||
|
||||
/* CRC32（标准，与 Python zlib.crc32 一致；初始 0xFFFFFFFF，末异或 0xFFFFFFFF）
|
||||
* 仅 RECV 方向需要：MCU 收齐后比对 PC 附在文件末尾的 4 字节 CRC32。 */
|
||||
#if PHASE8_DIRECTION == PHASE8_DIR_RECV
|
||||
static uint32_t phase8_crc32_step(uint32_t crc, const uint8_t *data, uint32_t len) {
|
||||
for (uint32_t i = 0; i < len; i++) {
|
||||
crc ^= data[i];
|
||||
for (int k = 0; k < 8; k++) {
|
||||
crc = (crc & 1u) ? (crc >> 1) ^ 0xEDB88320u : (crc >> 1);
|
||||
}
|
||||
}
|
||||
return crc;
|
||||
}
|
||||
#endif
|
||||
|
||||
/* 仅 SEND/ECHO 方向需要：生成递增模式发送窗口 */
|
||||
#if PHASE8_DIRECTION != PHASE8_DIR_RECV
|
||||
static void phase8_fill(uint8_t *buf, uint32_t size, uint32_t offset) {
|
||||
for (uint32_t i = 0; i < size; i++) {
|
||||
buf[i] = (uint8_t)((offset + i) & 0xFF);
|
||||
}
|
||||
}
|
||||
#endif
|
||||
|
||||
/* 仅 ECHO/RECV 方向需要：逐字节校验接收数据 */
|
||||
#if PHASE8_DIRECTION != PHASE8_DIR_SEND
|
||||
static int phase8_verify(uint8_t *buf, uint32_t size, uint32_t offset) {
|
||||
for (uint32_t i = 0; i < size; i++) {
|
||||
if (buf[i] != (uint8_t)((offset + i) & 0xFF)) {
|
||||
DBG_ERROR("Phase8: mismatch at %lu (expect 0x%02X, got 0x%02X)",
|
||||
offset + i, (uint8_t)((offset + i) & 0xFF), buf[i]);
|
||||
return 0;
|
||||
}
|
||||
}
|
||||
return 1;
|
||||
}
|
||||
#endif
|
||||
|
||||
static void phase8_run(int sockfd) {
|
||||
#if PHASE8_DIRECTION == PHASE8_DIR_RECV
|
||||
/* PC 发送文件（尾附 4B CRC32），MCU 接收并逐字节 + CRC32 校验 */
|
||||
DBG_INFO("Phase8[RECV]: receiving %d-byte file", PHASE8_FILE_SIZE);
|
||||
|
||||
uint32_t recvd = 0;
|
||||
uint32_t crc = 0xFFFFFFFFu;
|
||||
while (recvd < PHASE8_FILE_SIZE) {
|
||||
int to_read = (PHASE8_FILE_SIZE - recvd) > (TEST_BUF_SIZE - 4)
|
||||
? (TEST_BUF_SIZE - 4) : (int)(PHASE8_FILE_SIZE - recvd);
|
||||
int n = net_recv(sockfd, s_rx_buf, to_read, 0);
|
||||
if (n <= 0) {
|
||||
DBG_ERROR("Phase8[RECV]: recv fail at %lu (ret=%d)", recvd, n);
|
||||
return;
|
||||
}
|
||||
int ok = phase8_verify(s_rx_buf, (uint32_t)n, recvd);
|
||||
TEST_CHECK(ok, "Phase8[RECV]: verify at %lu (%d bytes)", recvd, n);
|
||||
if (!ok) return;
|
||||
crc = phase8_crc32_step(crc, s_rx_buf, (uint32_t)n);
|
||||
recvd += (uint32_t)n;
|
||||
}
|
||||
|
||||
/* 读取 PC 附在文件末尾的 4 字节 CRC32（小端） */
|
||||
uint8_t foot[4];
|
||||
uint32_t got = 0;
|
||||
while (got < 4) {
|
||||
int n = net_recv(sockfd, foot + got, (int)(4 - got), 0);
|
||||
if (n <= 0) {
|
||||
DBG_ERROR("Phase8[RECV]: footer recv fail (ret=%d)", n);
|
||||
return;
|
||||
}
|
||||
got += (uint32_t)n;
|
||||
}
|
||||
uint32_t crc_exp = crc ^ 0xFFFFFFFFu;
|
||||
uint32_t crc_act = ((uint32_t)foot[0]) | ((uint32_t)foot[1] << 8)
|
||||
| ((uint32_t)foot[2] << 16) | ((uint32_t)foot[3] << 24);
|
||||
TEST_CHECK(crc_act == crc_exp,
|
||||
"Phase8[RECV]: CRC32 exp=0x%08X act=0x%08X", crc_exp, crc_act);
|
||||
DBG_INFO("Phase8[RECV]: done, CRC32=0x%08X", crc_exp);
|
||||
|
||||
#elif PHASE8_DIRECTION == PHASE8_DIR_SEND
|
||||
/* MCU 发送文件，PC 落盘校验（PC 侧自行比对字节/CRC32） */
|
||||
DBG_INFO("Phase8[SEND]: sending %d-byte file", PHASE8_FILE_SIZE);
|
||||
|
||||
uint32_t sent = 0;
|
||||
while (sent < PHASE8_FILE_SIZE) {
|
||||
/* 每次填充一个滑动窗口（≤ s_tx_buf 容量）；net_send 内部按硬件发送 FIFO
|
||||
* (NET_SEND_CHUNK_MAX=1KB，见 Trap 20) 自动拆分写入，无需此处逐 1KB 分块 */
|
||||
uint32_t chunk = (PHASE8_FILE_SIZE - sent) > (uint32_t)TEST_BUF_SIZE
|
||||
? (uint32_t)TEST_BUF_SIZE : (PHASE8_FILE_SIZE - sent);
|
||||
phase8_fill(s_tx_buf, chunk, sent);
|
||||
int n = net_send(sockfd, s_tx_buf, (int)chunk, 0);
|
||||
if (n <= 0) {
|
||||
DBG_ERROR("Phase8[SEND]: send fail at %lu (ret=%d)", sent, n);
|
||||
return;
|
||||
}
|
||||
sent += (uint32_t)n;
|
||||
}
|
||||
DBG_INFO("Phase8[SEND]: sent %d bytes", PHASE8_FILE_SIZE);
|
||||
TEST_CHECK(1, "Phase8[SEND]: %d-byte file sent", PHASE8_FILE_SIZE);
|
||||
|
||||
#else /* PHASE8_DIR_ECHO */
|
||||
/* 发 100KB 经 PC 回显（tcp_server --max-conn 1），MCU 收齐逐字节校验 */
|
||||
DBG_INFO("Phase8[ECHO]: transferring %d-byte file", PHASE8_FILE_SIZE);
|
||||
|
||||
uint32_t sent = 0;
|
||||
while (sent < PHASE8_FILE_SIZE) {
|
||||
/* 同 SEND：填充滑动窗口（≤ s_tx_buf），由 net_send 内部按硬件 FIFO 自动拆分 */
|
||||
uint32_t chunk = (PHASE8_FILE_SIZE - sent) > (uint32_t)TEST_BUF_SIZE
|
||||
? (uint32_t)TEST_BUF_SIZE : (PHASE8_FILE_SIZE - sent);
|
||||
phase8_fill(s_tx_buf, chunk, sent);
|
||||
int n = net_send(sockfd, s_tx_buf, (int)chunk, 0);
|
||||
if (n <= 0) {
|
||||
DBG_ERROR("Phase8[ECHO]: send fail at %lu (ret=%d)", sent, n);
|
||||
return;
|
||||
}
|
||||
sent += (uint32_t)n;
|
||||
}
|
||||
|
||||
uint32_t recvd = 0;
|
||||
while (recvd < PHASE8_FILE_SIZE) {
|
||||
int n = net_recv(sockfd, s_rx_buf, TEST_BUF_SIZE, 0);
|
||||
if (n <= 0) {
|
||||
DBG_ERROR("Phase8[ECHO]: recv fail at %lu (ret=%d)", recvd, n);
|
||||
return;
|
||||
}
|
||||
int ok = phase8_verify(s_rx_buf, (uint32_t)n, recvd);
|
||||
TEST_CHECK(ok, "Phase8[ECHO]: verify at %lu (%d bytes)", recvd, n);
|
||||
if (!ok) return;
|
||||
recvd += (uint32_t)n;
|
||||
}
|
||||
TEST_CHECK(1, "Phase8[ECHO]: %d-byte file transfer complete", PHASE8_FILE_SIZE);
|
||||
#endif
|
||||
|
||||
/* 一次性传输完成：主动关闭数据连接，触发 net 层自动重监听。
|
||||
* 否则 accept 循环会在“仍打开的同一条连接”上重复执行本 Phase——
|
||||
* SEND/RECV 由 PC 端先关闭尚可终止，ECHO 方向 PC 回显客户端不会主动
|
||||
* 关闭，会导致 MCU 无限重复、PC 端 tcp_file --op echo 一直挂起。 */
|
||||
net_close(sockfd);
|
||||
}
|
||||
#endif
|
||||
|
||||
/* ===================================================================
|
||||
* Phase 9 — Select/Poll I/O 多路复用
|
||||
*
|
||||
* 测试目的：验证 net_select() API 在单 Socket 模式下正确工作：
|
||||
* 1. Socket 0 有数据到达时 select 返回正数
|
||||
* 2. NET_FD_ISSET 正确指示就绪的 Socket
|
||||
* 3. 超时（50ms 无数据）时返回 0
|
||||
*
|
||||
* 入口条件：Socket 0 处于 ESTABLISHED。
|
||||
* 通过：select 检测到数据并成功回显。
|
||||
* 失败：select 未检测到数据或回显失败。
|
||||
* =================================================================== */
|
||||
|
||||
#ifdef ENABLE_PHASE9_TESTS
|
||||
#include "net_select.h"
|
||||
static uint32_t s_phase9_count = 0;
|
||||
|
||||
static void phase9_run(int sockfd) {
|
||||
net_fd_set readfds;
|
||||
net_timeval tv;
|
||||
|
||||
/*
|
||||
* 配置 select：只监测 Socket 0 的可读状态，超时 50ms。
|
||||
* NET_FD_ZERO 清空集合，NET_FD_SET 添加 Socket 0。
|
||||
* 50ms 超时确保不阻塞任务循环太久。
|
||||
*/
|
||||
NET_FD_ZERO(&readfds);
|
||||
NET_FD_SET(sockfd, &readfds);
|
||||
tv.tv_sec = 0;
|
||||
tv.tv_usec = 50000;
|
||||
|
||||
int nfds = net_select(sockfd + 1, &readfds, NULL, NULL, &tv);
|
||||
if (nfds <= 0) return;
|
||||
|
||||
/* Socket 0 可读：非阻塞接收并回显 */
|
||||
if (NET_FD_ISSET(sockfd, &readfds)) {
|
||||
int n = net_recv(sockfd, s_rx_buf, TEST_BUF_SIZE, NET_MSG_DONTWAIT);
|
||||
if (n > 0) {
|
||||
int sent = net_send(sockfd, s_rx_buf, n, 0);
|
||||
if (sent == n) {
|
||||
s_phase9_count++;
|
||||
TEST_CHECK(1, "Phase9: select echo #%lu (%d bytes)", s_phase9_count, n);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
#endif
|
||||
|
||||
/* ===================================================================
|
||||
* Phase 10 — 边界条件测试
|
||||
*
|
||||
* 测试目的：验证以下 DMA 和协议栈边界情况：
|
||||
* 1. TC-NET-1001: 4095B（SPI 最大载荷 -1，单次 DMA 容纳）
|
||||
* 2. TC-NET-1002: 4096B（= SPI 最大载荷，填满单次 DMA）
|
||||
* 3. TC-NET-1003: 4097B（超过 SPI 最大载荷，拆 2 次 DMA）
|
||||
* 4. TC-NET-1004: 零长度发送（返回 -1）
|
||||
* 5. TC-NET-1005: 20 × 100B 连续快速发送
|
||||
*
|
||||
* 各用例通过状态机（s_phase10_stage）串行执行，每次 phase10_run 推进一个
|
||||
* 步骤（发送→等待→接收→验证→下一阶段）。发送数据为递增模式字节
|
||||
* （buf[i] = seed + i），接收端按相同模式验证。
|
||||
*
|
||||
* 入口条件：Socket 0 处于 ESTABLISHED。
|
||||
* 通过：各用例自身判定。
|
||||
* =================================================================== */
|
||||
|
||||
#ifdef ENABLE_PHASE10_TESTS
|
||||
static int s_phase10_stage = 0;
|
||||
static uint32_t s_phase10_recv = 0;
|
||||
|
||||
static void phase10_fill(uint8_t *buf, uint32_t size, uint8_t seed) {
|
||||
for (uint32_t i = 0; i < size; i++) {
|
||||
buf[i] = (uint8_t)(seed + i);
|
||||
}
|
||||
}
|
||||
|
||||
static int phase10_verify(uint8_t *buf, uint32_t size, uint8_t seed) {
|
||||
for (uint32_t i = 0; i < size; i++) {
|
||||
if (buf[i] != (uint8_t)(seed + i)) return 0;
|
||||
}
|
||||
return 1;
|
||||
}
|
||||
|
||||
static void phase10_run(int sockfd) {
|
||||
/* 阶段 0 → 1：发送 4095B */
|
||||
if (s_phase10_stage == 0) {
|
||||
DBG_INFO("Phase10: 4095B (DMA-1)");
|
||||
phase10_fill(s_tx_buf, 4095, 0x10);
|
||||
int sent = net_send(sockfd, s_tx_buf, 4095, 0);
|
||||
TEST_CHECK(sent == 4095, "Phase10: send 4095B (sent=%d)", sent);
|
||||
s_phase10_recv = 0;
|
||||
s_phase10_stage = 1;
|
||||
return;
|
||||
}
|
||||
/* 阶段 1：接收并验证 4095B 回显 */
|
||||
if (s_phase10_stage == 1) {
|
||||
int n = net_recv(sockfd, s_rx_buf + s_phase10_recv, (int)(4095 - s_phase10_recv), 0);
|
||||
if (n > 0) {
|
||||
s_phase10_recv += (uint32_t)n;
|
||||
if (s_phase10_recv >= 4095) {
|
||||
TEST_CHECK(phase10_verify(s_rx_buf, 4095, 0x10), "Phase10: verify 4095B");
|
||||
s_phase10_stage = 2;
|
||||
}
|
||||
}
|
||||
return;
|
||||
}
|
||||
/* 阶段 2 → 3：发送 4096B（DMA 边界精确值） */
|
||||
if (s_phase10_stage == 2) {
|
||||
DBG_INFO("Phase10: 4096B (DMA exact)");
|
||||
phase10_fill(s_tx_buf, 4096, 0x20);
|
||||
int sent = net_send(sockfd, s_tx_buf, 4096, 0);
|
||||
TEST_CHECK(sent == 4096, "Phase10: send 4096B (sent=%d)", sent);
|
||||
s_phase10_recv = 0;
|
||||
s_phase10_stage = 3;
|
||||
return;
|
||||
}
|
||||
/* 阶段 3：接收并验证 4096B 回显 */
|
||||
if (s_phase10_stage == 3) {
|
||||
int n = net_recv(sockfd, s_rx_buf + s_phase10_recv, (int)(4096 - s_phase10_recv), 0);
|
||||
if (n > 0) {
|
||||
s_phase10_recv += (uint32_t)n;
|
||||
if (s_phase10_recv >= 4096) {
|
||||
TEST_CHECK(phase10_verify(s_rx_buf, 4096, 0x20), "Phase10: verify 4096B");
|
||||
s_phase10_stage = 4;
|
||||
}
|
||||
}
|
||||
return;
|
||||
}
|
||||
/* 阶段 4 → 5：发送 4097B（超过 DMA 上限，自动拆 4096+1） */
|
||||
if (s_phase10_stage == 4) {
|
||||
DBG_INFO("Phase10: 4097B (DMA+1, 2 SPI xacts)");
|
||||
phase10_fill(s_tx_buf, 4097, 0x30);
|
||||
int sent = net_send(sockfd, s_tx_buf, 4097, 0);
|
||||
TEST_CHECK(sent == 4097, "Phase10: send 4097B (sent=%d)", sent);
|
||||
s_phase10_recv = 0;
|
||||
s_phase10_stage = 5;
|
||||
return;
|
||||
}
|
||||
/* 阶段 5：接收并验证 4097B 回显 */
|
||||
if (s_phase10_stage == 5) {
|
||||
int n = net_recv(sockfd, s_rx_buf + s_phase10_recv, (int)(4097 - s_phase10_recv), 0);
|
||||
if (n > 0) {
|
||||
s_phase10_recv += (uint32_t)n;
|
||||
if (s_phase10_recv >= 4097) {
|
||||
TEST_CHECK(phase10_verify(s_rx_buf, 4097, 0x30), "Phase10: verify 4097B");
|
||||
s_phase10_stage = 6;
|
||||
}
|
||||
}
|
||||
return;
|
||||
}
|
||||
/* 阶段 6：零长度发送 —— 期望 net_send 返回 -1（NET_ERR_INVAL） */
|
||||
if (s_phase10_stage == 6) {
|
||||
DBG_INFO("Phase10: zero-length send");
|
||||
int sent = net_send(sockfd, s_tx_buf, 0, 0);
|
||||
TEST_CHECK(sent < 0, "Phase10: send 0B returns %d (expect <0)", sent);
|
||||
s_phase10_stage = 7;
|
||||
return;
|
||||
}
|
||||
/* 阶段 7：20 × 100B 快速发送 */
|
||||
if (s_phase10_stage == 7) {
|
||||
DBG_INFO("Phase10: 20x rapid sends (100B each)");
|
||||
phase10_fill(s_tx_buf, 100, 0x40);
|
||||
int all_ok = 1;
|
||||
for (int i = 0; i < 20; i++) {
|
||||
if (net_send(sockfd, s_tx_buf, 100, 0) != 100) {
|
||||
TEST_CHECK(0, "Phase10: rapid #%d fail", i + 1);
|
||||
all_ok = 0; break;
|
||||
}
|
||||
osDelay(1);
|
||||
}
|
||||
if (all_ok) {
|
||||
TEST_CHECK(1, "Phase10: 20x rapid sends OK");
|
||||
s_phase10_recv = 0;
|
||||
s_phase10_stage = 8;
|
||||
} else {
|
||||
s_phase10_stage = 0;
|
||||
}
|
||||
return;
|
||||
}
|
||||
/* 阶段 8：接收 2000B 回显总和并验证 */
|
||||
if (s_phase10_stage == 8) {
|
||||
int n = net_recv(sockfd, s_rx_buf + s_phase10_recv, (int)(2000 - s_phase10_recv), 0);
|
||||
if (n > 0) {
|
||||
s_phase10_recv += (uint32_t)n;
|
||||
if (s_phase10_recv >= 2000) {
|
||||
TEST_CHECK(1, "Phase10: all echo received");
|
||||
TEST_REPORT("Phase 10");
|
||||
s_phase10_stage = 0;
|
||||
}
|
||||
}
|
||||
return;
|
||||
}
|
||||
}
|
||||
#endif
|
||||
|
||||
/* ===================================================================
|
||||
* Phase 11 — TCP KeepAlive 超时断开
|
||||
*
|
||||
* 测试目的：验证 CH395F 的 TCP KeepAlive 机制：
|
||||
* 1. 连接空闲超过 idle 阈值（60s）后开始发送探测包
|
||||
* 2. 探测无响应（默认 3 次 × 5s = 15s）后触发 TIMEOUT
|
||||
* 3. Socket 自动关闭并回到 LISTEN
|
||||
*
|
||||
* 入口条件：Socket 0 处于 ESTABLISHED，PC 连接后静置（不发数据）。
|
||||
* 通过：KeepAlive 断开时间 ≥ 60s（从连接建立到 recv 返回 0 的间隔）。
|
||||
* 失败：不到 60s 就断开（可能是其他原因导致）或 75s 后仍未断开。
|
||||
* =================================================================== */
|
||||
|
||||
#ifdef ENABLE_PHASE11_TESTS
|
||||
static int s_phase11_armed = 0;
|
||||
static uint32_t s_phase11_start = 0;
|
||||
|
||||
static void phase11_run(int sockfd) {
|
||||
/*
|
||||
* 第一次调用：记录开始时间并 arm。
|
||||
* 后续调用：非阻塞 recv，若返回 0 表示连接已断开（KeepAlive 触发）。
|
||||
* 计算耗时与 60s idle 阈值比较。
|
||||
*/
|
||||
if (!s_phase11_armed) {
|
||||
s_phase11_armed = 1;
|
||||
s_phase11_start = HAL_GetTick();
|
||||
DBG_INFO("Phase11: idle wait for KeepAlive timeout (60s)");
|
||||
return;
|
||||
}
|
||||
|
||||
int n = net_recv(sockfd, s_rx_buf, 64, NET_MSG_DONTWAIT);
|
||||
if (n == 0) {
|
||||
uint32_t elapsed = HAL_GetTick() - s_phase11_start;
|
||||
TEST_CHECK(elapsed >= 60000,
|
||||
"Phase11: KeepAlive triggered after %lums (expect >=60000ms)", elapsed);
|
||||
TEST_REPORT("Phase 11");
|
||||
s_phase11_armed = 0;
|
||||
}
|
||||
}
|
||||
#endif
|
||||
|
||||
void net_layer_test_main(void)
|
||||
{
|
||||
int sockfd = -1;
|
||||
int phase_active = 0;
|
||||
uint32_t accept_retry = 0;
|
||||
struct net_sockaddr_in client_addr;
|
||||
int addrlen = sizeof(client_addr);
|
||||
|
||||
sockfd = net_socket(NET_AF_INET, NET_SOCK_STREAM, 0);
|
||||
if (sockfd < 0) {
|
||||
DBG_ERROR("Test task: net_socket failed");
|
||||
return;
|
||||
}
|
||||
DBG_INFO("Test task: socket %d created", sockfd);
|
||||
|
||||
{
|
||||
struct net_sockaddr_in addr;
|
||||
memset(&addr, 0, sizeof(addr));
|
||||
addr.sin_family = NET_AF_INET;
|
||||
addr.sin_port = net_htons(8080);
|
||||
if (net_bind(sockfd, (struct net_sockaddr *)&addr, sizeof(addr)) < 0) {
|
||||
DBG_ERROR("Test task: net_bind failed");
|
||||
return;
|
||||
}
|
||||
DBG_INFO("Test task: bound to port 8080");
|
||||
}
|
||||
|
||||
if (net_listen(sockfd) < 0) {
|
||||
DBG_ERROR("Test task: net_listen failed");
|
||||
return;
|
||||
}
|
||||
DBG_INFO("Test task: listening on 8080 (single-socket mode)");
|
||||
|
||||
/* ==================== 事件驱动阶段 ====================
|
||||
* Phase 6/8~11（NET 层）在 TCP 监听循环中运行，需要 PC 客户端连接。
|
||||
* （Phase 7 TCP Client 为独立入口 net_layer_client_test_main，不在本循环。）
|
||||
* 没有连接时循环等待；连接建立后执行对应 Phase。
|
||||
* 断开后自动重新 listen。
|
||||
*/
|
||||
for (;;) {
|
||||
if (!phase_active) {
|
||||
int acc = net_accept(sockfd, (struct net_sockaddr *)&client_addr, &addrlen);
|
||||
if (acc < 0) {
|
||||
if (accept_retry % 100 == 0) {
|
||||
DBG_INFO("Test task: waiting for connection...");
|
||||
}
|
||||
accept_retry++;
|
||||
osDelay(100);
|
||||
continue;
|
||||
}
|
||||
accept_retry = 0;
|
||||
phase_active = 1;
|
||||
DBG_INFO("Test task: client accepted (fd=%d)", acc);
|
||||
|
||||
/* 连接建立，重置各 Phase 内部状态 */
|
||||
#ifdef ENABLE_PHASE10_TESTS
|
||||
s_phase10_stage = 0;
|
||||
#endif
|
||||
#ifdef ENABLE_PHASE11_TESTS
|
||||
s_phase11_armed = 0;
|
||||
#endif
|
||||
}
|
||||
|
||||
/* 每 10ms 依次执行各已启用 Phase */
|
||||
#ifdef ENABLE_PHASE6_TESTS
|
||||
phase6_run(sockfd);
|
||||
#endif
|
||||
#ifdef ENABLE_PHASE8_TESTS
|
||||
phase8_run(sockfd);
|
||||
phase_active = 0; /* Phase 8 一次性完成，发完即止 */
|
||||
#endif
|
||||
#ifdef ENABLE_PHASE9_TESTS
|
||||
phase9_run(sockfd);
|
||||
#endif
|
||||
#ifdef ENABLE_PHASE10_TESTS
|
||||
phase10_run(sockfd);
|
||||
#endif
|
||||
#ifdef ENABLE_PHASE11_TESTS
|
||||
phase11_run(sockfd);
|
||||
#endif
|
||||
|
||||
/*
|
||||
* 单连接模式：连接断开由 net 层自动重监听（auto_relisten），
|
||||
* 应用层不巡检/不重监听，回显循环持续服务新连接。
|
||||
*/
|
||||
osDelay(10);
|
||||
}
|
||||
}
|
||||
22
test/net_test_task.h
Normal file
22
test/net_test_task.h
Normal file
@@ -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 */
|
||||
Reference in New Issue
Block a user