网络主要内容测试完成

test/ch395f_socket_test.py

@@ -16,6 +16,7 @@ CH395F BSD Socket API 测试程序
     udp_echo     - UDP 回显服务器（测试双向通信）
     stress       - 压力测试（多连接并发测试）
     tcp_bulk     - 双向大块：先收满 bulk 字节（不回声，校验 LCG），再回放（阶段 5）
+    tcp_file     - 文件收发：PC 作 Client 连 MCU:8080（阶段 8），--op send/recv 收发 100KB 文件（含 CRC32）
 
 选项:
     --ip         目标 IP 地址（默认: 192.168.1.100）
@@ -41,8 +42,13 @@ CH395F BSD Socket API 测试程序
     # 压力测试（多连接）
     python ch395f_socket_test.py stress --ip 192.168.1.100 --port 8080 --count 7
 
-    # 阶段 5 双向大块（先收 256KB 再回放 256KB）
-    python ch395f_socket_test.py tcp_bulk --port 8081 --bulk 262144 --chunk 4096
+     # 阶段 5 双向大块（先收 256KB 再回放 256KB）
+     python ch395f_socket_test.py tcp_bulk --port 8081 --bulk 262144 --chunk 4096
+
+     # 阶段 8 文件收发（PC 连 MCU:8080）
+     python ch395f_socket_test.py tcp_file --ip 192.168.1.100 --port 8080 --op recv --file rx_100k.bin --size 102400
+     python ch395f_socket_test.py tcp_file --ip 192.168.1.100 --port 8080 --op send --file tx_100k.bin
+     python ch395f_socket_test.py tcp_file --ip 192.168.1.100 --port 8080 --op echo   # TC-NET-803 回显（MCU 为 server）
 """
 
 import socket
@@ -54,6 +60,7 @@ import threading
 import struct
 import random
 import string
+import zlib
 from datetime import datetime
 
 # TCP 回显服务器（tcp_server 模式）参数
@@ -100,6 +107,11 @@ def generate_data(size):
     return ''.join(random.choices(string.ascii_letters + string.digits, k=size)).encode()
 
 
+def gen_pattern(size, offset=0):
+    """生成递增模式数据 (i+offset)&0xFF，与固件 §7 自检回显期望字节流一致"""
+    return bytes(((offset + i) & 0xFF) for i in range(size))
+
+
 def verify_data(data, expected_len):
     """验证数据"""
     if len(data) != expected_len:
@@ -109,35 +121,71 @@ def verify_data(data, expected_len):
 
 # ==================== TCP 测试函数 ====================
 
+def _echo_conn_handler(conn_idx, client_socket, counters, lock):
+    """每个连接一个线程：收到什么回什么，直到对端关闭或空闲超时。
+
+    线程安全：通过 lock 更新共享计数器 counters（dict: total/bytes/errors）。
+    """
+    rx = 0
+    client_socket.settimeout(ECHO_IDLE_TIMEOUT)
+    try:
+        while True:
+            data = client_socket.recv(4096)
+            if not data:
+                log_info(f"[连接{conn_idx}] 对端已关闭")
+                break
+            client_socket.sendall(data)
+            rx += len(data)
+    except socket.timeout:
+        log_warn(f"[连接{conn_idx}] 空闲超时，关闭连接")
+    except Exception as e:
+        log_error(f"[连接{conn_idx}] 回显错误: {e}")
+        with lock:
+            counters['errors'] += 1
+    finally:
+        client_socket.close()
+        with lock:
+            counters['active'] = max(0, counters['active'] - 1)
+            counters['total'] += 1
+            counters['bytes'] += rx
+            if rx == 0:
+                counters['errors'] += 1
+                log_warn(f"连接#{conn_idx} 未收到任何数据")
+            else:
+                log_success(f"连接#{conn_idx} 完成: 回显 {rx} 字节")
+
+
 def tcp_server_test(args):
     """TCP 回显服务器测试（测试 CH395F TCP Client）
 
-    与固件 TC-NET-201/202 配套：MCU 连接后发送数据并等待原样回显，
-    校验通过后主动关闭。本函数循环接受多个连接，每个连接内将收到的
-    数据逐字回显，直到对端关闭或空闲超时。
+    与固件 TC701/702/704 配套：MCU 连接后发送数据并等待原样回显。
+    每个连接由独立线程处理，支持多 Socket 并发（TC704 一次打开 8 个）。
 
-    首个连接等待 args.timeout 秒；之后每个连接间最多等待
-    INTER_ACCEPT_TIMEOUT 秒，无新连接则结束并汇总。
-    返回 False 表示失败（无连接或回显出错），main 据此返回非 0 退出码。
+    首个连接等待 args.timeout 秒；之后每个连接间最多等待 INTER_ACCEPT_TIMEOUT 秒；
+    若指定 --max-conn（>0），达到连接数上限后停止接受并等待全部线程结束。
+    无新连接则结束并汇总。返回 False 表示失败（无连接或回显出错）。
     """
     log_info("=" * 60)
-    log_info("TCP 回显服务器 - 测试 CH395F TCP Client 功能")
+    log_info("TCP 回显服务器 - 测试 CH395F TCP Client 功能（并发）")
     log_info("=" * 60)
 
     server_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
     server_socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
 
-    conn_total = 0
-    echo_bytes = 0
-    conn_errors = 0
+    counters = {'total': 0, 'bytes': 0, 'errors': 0, 'active': 0}
+    lock = threading.Lock()
+    threads = []
 
     try:
         server_socket.bind(('0.0.0.0', args.port))
-        server_socket.listen(4)
-        log_success(f"服务器启动，监听端口 {args.port}")
+        server_socket.listen(16)
+        log_success(f"服务器启动，监听端口 {args.port}（并发回显，backlog=16）")
 
         conn_idx = 0
         while True:
+            if args.max_conn and args.max_conn > 0 and counters['active'] >= args.max_conn:
+                log_info(f"已达 --max-conn {args.max_conn}（并发），停止接受新连接")
+                break
             wait = args.timeout if conn_idx == 0 else min(args.timeout, INTER_ACCEPT_TIMEOUT)
             server_socket.settimeout(wait)
             try:
@@ -151,41 +199,25 @@ def tcp_server_test(args):
                 break
 
             conn_idx += 1
+            with lock:
+                counters['active'] += 1
             log_success(f"连接#{conn_idx} 来自: {client_addr[0]}:{client_addr[1]}")
+            t = threading.Thread(target=_echo_conn_handler,
+                                 args=(conn_idx, client_socket, counters, lock),
+                                 daemon=True)
+            t.start()
+            threads.append(t)
 
-            # 回显循环：收到什么回什么（sendall 保证发完），对端关闭或空闲超时结束
-            client_socket.settimeout(ECHO_IDLE_TIMEOUT)
-            rx = 0
-            try:
-                while True:
-                    data = client_socket.recv(4096)
-                    if not data:
-                        log_info(f"[连接{conn_idx}] 对端已关闭")
-                        break
-                    client_socket.sendall(data)
-                    rx += len(data)
-            except socket.timeout:
-                log_warn(f"[连接{conn_idx}] 空闲超时，关闭连接")
-            except Exception as e:
-                log_error(f"[连接{conn_idx}] 回显错误: {e}")
-                conn_errors += 1
-            finally:
-                client_socket.close()
-
-            if rx > 0:
-                log_success(f"连接#{conn_idx} 完成: 回显 {rx} 字节")
-            else:
-                log_warn(f"连接#{conn_idx} 未收到任何数据")
-                conn_errors += 1
-            echo_bytes += rx
-            conn_total += 1
+        # 等待所有连接线程结束（对端关闭或空闲超时）
+        for t in threads:
+            t.join()
 
         log_info("-" * 40)
-        log_info(f"服务结束: 连接 {conn_total} 个, 回显 {echo_bytes} 字节, 异常 {conn_errors} 次")
-        if conn_total == 0:
+        log_info(f"服务结束: 连接 {counters['total']} 个, 回显 {counters['bytes']} 字节, 异常 {counters['errors']} 次")
+        if counters['total'] == 0:
             log_error("无任何客户端连接")
             return False
-        return conn_errors == 0
+        return counters['errors'] == 0
 
     except Exception as e:
         log_error(f"服务器错误: {e}")
@@ -318,18 +350,20 @@ def tcp_client_test(args):
         client_socket.connect((args.ip, args.port))
         log_success("连接成功!")
 
-        # 测试发送数据
+        # 测试发送数据（TC-NET-602: 64B 小包回显 ×args.count 轮）
         log_info("-" * 40)
-        log_info("测试 1: 发送数据")
+        log_info("测试 1: 64B 小包回显 (TC-NET-602)")
+        pkt_offset = 0  # 单连接内期望字节流连续累计，与固件 s_phase6_off 同步
         for i in range(args.count):
             try:
-                test_data = generate_data(min(100, args.size))
+                test_data = gen_pattern(64, pkt_offset)
+                pkt_offset += 64
                 client_socket.send(test_data)
                 log_success(f"发送数据 ({len(test_data)} bytes)")
                 log_info(f"发送 hex: {' '.join(f'{b:02X}' for b in test_data[:16])}")
 
                 # 等待回显
-                data = client_socket.recv(args.size)
+                data = client_socket.recv(64)
                 if data:
                     log_info(f"接收 hex: {' '.join(f'{b:02X}' for b in data[:16])}")
                     log_info(f"接收长度: {len(data)}, 期望长度: {len(test_data)}")
@@ -337,7 +371,6 @@ def tcp_client_test(args):
                         log_success("回显数据匹配!")
                     else:
                         log_error("回显数据不匹配!")
-                        # 找出第一个不同的字节
                         for j in range(min(len(data), len(test_data))):
                             if data[j] != test_data[j]:
                                 log_error(f"首个差异: 位置 {j}, 发送={test_data[j]:02X}, 接收={data[j]:02X}")
@@ -351,49 +384,74 @@ def tcp_client_test(args):
                 log_error(f"发送/接收错误: {e}")
                 break
 
-        # 测试大数据量
+        # 测试 1460B MSS 回显（TC-NET-603）
         log_info("-" * 40)
-        log_info("测试 2: 大数据量传输")
+        log_info("测试 2: 1460B MSS 回显 (TC-NET-603)")
         try:
-            large_data = generate_data(min(1024, args.size))
-            client_socket.send(large_data)
-            log_success(f"发送大数据 ({len(large_data)} bytes)")
+            test_data = gen_pattern(1460, pkt_offset)
+            pkt_offset += 1460
+            client_socket.send(test_data)
+            log_success(f"发送 1460B ({len(test_data)} bytes)")
 
             received = b""
-            while len(received) < len(large_data):
-                chunk = client_socket.recv(min(1024, len(large_data) - len(received)))
+            while len(received) < len(test_data):
+                chunk = client_socket.recv(min(1460, len(test_data) - len(received)))
                 if not chunk:
                     break
                 received += chunk
 
-            if received == large_data:
-                log_success("大数据传输完整!")
+            if received == test_data:
+                log_success("1460B 完全匹配!")
             else:
-                log_error(f"大数据传输不完整: 发送 {len(large_data)}, 接收 {len(received)}")
+                log_error(f"1460B 传输不完整: 发送 {len(test_data)}, 接收 {len(received)}")
         except Exception as e:
-            log_error(f"大数据传输错误: {e}")
+            log_error(f"1460B 传输错误: {e}")
 
-        # 测试快速收发
+        # 测试 4096B 缓冲满回显（TC-NET-604）
         log_info("-" * 40)
-        log_info("测试 3: 快速收发")
-        success_count = 0
-        fail_count = 0
-        start_time = time.time()
+        log_info("测试 3: 4096B 缓冲满回显 (TC-NET-604)")
+        try:
+            # 单 Socket 接收缓冲按 1KB block 配置为 2KB（set_recv_buf(sock,30,2)），
+            # 4096B 单包会分两次 net_recv 取空，验证分次取数 + 回显 + 字节累计校验正确。
+            test_data = gen_pattern(4096, pkt_offset)
+            pkt_offset += 4096
+            client_socket.send(test_data)
+            log_success(f"发送 4096B ({len(test_data)} bytes)")
 
-        for i in range(args.count):
-            try:
-                test_data = f"FAST_{i:04d}".encode()
-                client_socket.send(test_data)
-                data = client_socket.recv(100)
-                if data and data == test_data:
-                    success_count += 1
-                else:
-                    fail_count += 1
-            except Exception as e:
-                fail_count += 1
+            received = b""
+            while len(received) < len(test_data):
+                chunk = client_socket.recv(min(4096, len(test_data) - len(received)))
+                if not chunk:
+                    break
+                received += chunk
 
-        elapsed = time.time() - start_time
-        log_info(f"快速收发结果: 成功 {success_count}, 失败 {fail_count}, 耗时 {elapsed:.2f}s")
+            if received == test_data:
+                log_success("4096B 完全匹配!")
+            else:
+                log_error(f"4096B 传输不完整: 发送 {len(test_data)}, 接收 {len(received)}")
+        except Exception as e:
+            log_error(f"4096B 传输错误: {e}")
+
+        # 测试断开重连（TC-NET-605）
+        log_info("-" * 40)
+        log_info("测试 4: 断开重连 (TC-NET-605)")
+        try:
+            client_socket.close()
+            client_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+            client_socket.settimeout(10)
+            client_socket.connect((args.ip, args.port))
+            log_success("重连成功!")
+
+            # 新连接：固件复位 s_phase6_off=0，PC 期望字节流从偏移 0 重新比对
+            test_data = gen_pattern(64, 0)
+            client_socket.send(test_data)
+            data = client_socket.recv(64)
+            if data == test_data:
+                log_success("重连回显匹配!")
+            else:
+                log_error("重连回显不匹配!")
+        except Exception as e:
+            log_error(f"重连错误: {e}")
 
         client_socket.close()
         log_success("测试完成，连接已关闭")
@@ -1060,6 +1118,125 @@ def packet_size_test(args):
         client_socket.close()
 
 
+# ==================== 文件收发测试（配合固件阶段 8 / PHASE8_DIRECTION） ====================
+
+def tcp_file_test(args):
+    """文件收发测试：PC 作 TCP Client 连接 MCU:8080（net_test_task 监听）
+
+    协议：
+      --op send : 读取 --file（或生成 --size 字节递增模式）发往 MCU，
+                  末尾附 4 字节 CRC32（小端，zlib.crc32），供 MCU 整包校验。
+      --op recv : 从 MCU 接收 --size 字节写 --file，逐字节比对递增模式并报告 CRC32。
+      --op echo : PC 作 Client 连 MCU:8080，把 MCU 发来的数据原样回显，直到对端关闭。
+
+    对应固件 PHASE8_DIRECTION：
+      SEND(1)  -> PC 用 --op recv 收 MCU 发来的文件
+      RECV(2)  -> PC 用 --op send 发文件（+CRC32 尾）给 MCU
+      ECHO(0)  -> PC 用 --op echo 连 MCU:8080 回显（MCU 为 server，先发后收）
+    """
+    op = args.op
+    size = args.size
+    ip, port = args.ip, args.port
+
+    if op not in ('send', 'recv', 'echo'):
+        log_error("tcp_file: --op 必须为 send / recv / echo")
+        return False
+
+    client_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+    client_socket.settimeout(args.timeout)
+    try:
+        log_info(f"正在连接 MCU TCP Server: {ip}:{port}")
+        client_socket.connect((ip, port))
+        log_success(f"已连接 {ip}:{port}")
+    except Exception as e:
+        log_error(f"连接失败: {e}")
+        return False
+
+    try:
+        if op == 'send':
+            # ---- 准备数据 ----
+            if args.file and os.path.exists(args.file):
+                with open(args.file, 'rb') as f:
+                    data = f.read()
+                if len(data) != size:
+                    log_warn(f"文件大小 {len(data)} != --size {size}，以实际文件大小 {len(data)} 发送")
+                size = len(data)
+            else:
+                log_info(f"无 --file，生成 {size} 字节递增模式数据")
+                data = bytes((i & 0xFF) for i in range(size))
+            crc = zlib.crc32(data) & 0xFFFFFFFF
+            footer = struct.pack('<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: