Files
CPY_AuxiliaryControlBoard/Drivers/User/UDP/test_sender.py
T
2026-08-24 15:49:57 +08:00

206 lines
6.9 KiB
Python

#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
UDP大数据包发送端测试程序
用于测试接收端的功能
"""
import socket
import struct
import random
import time
import threading
from typing import List
# 包头结构定义 (与C端保持一致)
class UDPPacketHeader:
"""UDP包头结构"""
MAGIC = 0xAA55
HEADER_SIZE = 16
def __init__(self, magic: int, total_size: int, big_packet_id: int,
packet_id: int, total_packets: int, payload_len: int):
self.magic = magic
self.total_size = total_size
self.big_packet_id = big_packet_id
self.packet_id = packet_id
self.total_packets = total_packets
self.payload_len = payload_len
def to_bytes(self) -> bytes:
"""转换为字节数据"""
return struct.pack('<HHIHHH',
self.magic, self.total_size, self.big_packet_id,
self.packet_id, self.total_packets, self.payload_len)
class UDPSender:
"""UDP发送端"""
def __init__(self, target_host: str, target_port: int):
self.target_host = target_host
self.target_port = target_port
self.socket = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
def send_big_packet(self, data: bytes, delay: float = 0.0) -> int:
"""
发送大数据包
"""
if len(data) > 60 * 1024: # 60KB限制
raise ValueError("数据太大,超过60KB限制")
# 生成随机大包ID
big_packet_id = random.randint(1, 0xFFFFFFFF)
# 计算包数量
max_payload_size = 1024
total_packets = (len(data) + max_payload_size - 1) // max_payload_size
print(f"发送大包: ID={big_packet_id}, 大小={len(data)} 字节, 包数={total_packets}")
# 发送所有包
for packet_id in range(total_packets):
# 计算当前包的载荷
start_offset = packet_id * max_payload_size
end_offset = min(start_offset + max_payload_size, len(data))
payload = data[start_offset:end_offset]
payload_len = len(payload)
# 创建包头
header = UDPPacketHeader(
magic=UDPPacketHeader.MAGIC,
total_size=len(data),
big_packet_id=big_packet_id,
packet_id=packet_id,
total_packets=total_packets,
payload_len=payload_len
)
# 组装完整包
packet = header.to_bytes() + payload
# 发送包
self.socket.sendto(packet, (self.target_host, self.target_port))
print(f" 发送包 {packet_id + 1}/{total_packets}, 载荷大小: {payload_len}")
# 延迟(模拟网络延迟)
if delay > 0:
time.sleep(delay)
return big_packet_id
def close(self):
"""关闭socket"""
self.socket.close()
def generate_test_data(size: int) -> bytes:
"""生成测试数据"""
return bytes([random.randint(0, 255) for _ in range(size)])
def test_single_sender():
"""测试单个发送端"""
sender = UDPSender('127.0.0.1', 8080)
try:
# 发送不同大小的数据包
test_sizes = [100, 1000, 5000, 10000, 30000]
for size in test_sizes:
print(f"\n=== 测试发送 {size} 字节数据 ===")
data = generate_test_data(size)
big_packet_id = sender.send_big_packet(data, delay=0.01)
print(f"大包 {big_packet_id} 发送完成")
time.sleep(0.5) # 等待接收端处理
finally:
sender.close()
def test_multiple_senders():
"""测试多个发送端同时发送"""
def sender_thread(sender_id: int, data_size: int):
sender = UDPSender('127.0.0.1', 8080)
try:
data = generate_test_data(data_size)
big_packet_id = sender.send_big_packet(data, delay=0.02)
print(f"发送端 {sender_id}: 大包 {big_packet_id} 发送完成")
finally:
sender.close()
# 创建多个发送线程
threads = []
for i in range(3):
data_size = random.randint(1000, 10000)
thread = threading.Thread(target=sender_thread, args=(i, data_size))
threads.append(thread)
thread.start()
# 等待所有线程完成
for thread in threads:
thread.join()
print("所有发送端完成")
def test_timeout_scenario():
"""测试超时场景(故意延迟发送)"""
sender = UDPSender('127.0.0.1', 8080)
try:
print("=== 测试超时场景 ===")
data = generate_test_data(5000)
# 只发送前几个包,然后等待超时
big_packet_id = random.randint(1, 0xFFFFFFFF)
total_packets = (len(data) + 1024 - 1) // 1024
for packet_id in range(min(3, total_packets)): # 只发送前3个包
start_offset = packet_id * 1024
end_offset = min(start_offset + 1024, len(data))
payload = data[start_offset:end_offset]
header = UDPPacketHeader(
magic=UDPPacketHeader.MAGIC,
total_size=len(data),
big_packet_id=big_packet_id,
packet_id=packet_id,
total_packets=total_packets,
payload_len=len(payload)
)
packet = header.to_bytes() + payload
sender.socket.sendto(packet, (sender.target_host, sender.target_port))
print(f"发送包 {packet_id + 1}/{total_packets} (故意不发送完整)")
print("等待超时...")
time.sleep(2) # 等待超时
finally:
sender.close()
def main():
"""主函数"""
import argparse
parser = argparse.ArgumentParser(description='UDP大数据包发送端测试程序')
parser.add_argument('--host', default='127.0.0.1', help='目标主机 (默认: 127.0.0.1)')
parser.add_argument('--port', type=int, default=8080, help='目标端口 (默认: 8080)')
parser.add_argument('--test', choices=['single', 'multiple', 'timeout'],
default='single', help='测试类型 (默认: single)')
args = parser.parse_args()
print(f"UDP发送端测试程序")
print(f"目标: {args.host}:{args.port}")
print(f"测试类型: {args.test}")
if args.test == 'single':
test_single_sender()
elif args.test == 'multiple':
test_multiple_senders()
elif args.test == 'timeout':
test_timeout_scenario()
print("测试完成")
if __name__ == '__main__':
main()