wandering1/STM32F4-Base
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

网络主要内容测试完成

Browse Source
This commit is contained in:
wandering1
2026-08-26 13:54:52 +08:00
parent 0a707034cc
commit 88160a5134
18 changed files with 2174 additions and 928 deletions
Download Patch File Download Diff File Expand all files Collapse all files

BIN
test/__pycache__/ch395f_socket_test.cpython-311.pyc
View File

Binary file not shown.

341
test/ch395f_socket_test.py
View File

@@ -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:

30
test/ch395f_test.h
View File

@@ -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
/* 测试统计 */

544
test/ch395f_test_task.c
View File

@@ -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
View 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
View 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 */