import socket import base64 import json import time import psutil import struct import csv import threading from collections import defaultdict from typing import Dict, List, Tuple, Optional import logging from config import * from x_ray_data_processor import processor from PySide6.QtCore import QObject, Signal, Slot, QThread, QTimer # 配置日志 logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s') logger = logging.getLogger(__name__) # 定义adcDataUnitDef结构体 class adcDataUnitDef: def __init__(self): self.ucCmd = 0 self.ucAddr = 0 self.usData = 0 # 新增:UDP包头结构定义 (与C端保持一致) class UDPPacketHeader: """UDP包头结构""" MAGIC = 0xAA55 HEADER_SIZE = 16 # 包头大小 def __init__(self, data: bytes): """ 从字节数据解析包头 """ if len(data) < self.HEADER_SIZE: raise ValueError("数据长度不足,无法解析包头") # 解析包头字段 (小端序) (self.magic, self.total_size, self.big_packet_id, self.packet_id, self.total_packets, self.payload_len) = struct.unpack(' bool: """ 添加一个包到重组器 返回True如果包是新接收的,False如果包已存在 """ if packet_id in self.packets: return False # 包已存在 self.packets[packet_id] = payload self.received_count += 1 # 检查是否所有包都已接收 if self.received_count == self.total_packets: self._reassemble() return True return True def _reassemble(self): """重组完整数据""" try: # 按包序号排序 sorted_packets = sorted(self.packets.items()) # 重组数据 reassembled_data = b'' for packet_id, payload in sorted_packets: reassembled_data += payload # 截取到指定长度 self.data = reassembled_data[:self.total_size] self.completed = True logger.info(f"大包 {self.big_packet_id} 重组完成,大小: {len(self.data)} 字节") except Exception as e: logger.error(f"重组大包 {self.big_packet_id} 时出错: {e}") def is_timeout(self) -> bool: """检查是否超时""" return time.time() - self.start_time > self.timeout def is_completed(self) -> bool: """检查是否完成重组""" return self.completed def get_data(self) -> Optional[bytes]: """获取重组后的数据""" return self.data if self.completed else None class UdpServerEnhanced(QThread): start_cal = Signal(int, bytearray, str, int) # 信号:接收到消息,包含数据、发送者地址和端口 send_collect_data = Signal(dict) # update_acquisition_info = Signal(int, dict) def __init__(self, ip="0.0.0.0", port=50009, parent=None): super(UdpServerEnhanced, self).__init__(parent) self.kill_udp_port(port) self.ip = ip self.port = port self.server_socket = None self.running = True self.motor1_direction = "" self.motor2_direction = "" # 新增:分包重组相关属性 self.reassemblers: Dict[Tuple[Tuple[str, int], int], PacketReassembler] = {} self.reassembler_lock = threading.Lock() self.cleanup_thread = None self.timeout = 1.0 # 1秒超时 self.collect_object1 = { "method" : "scanner1", "channelA_data" :"base64", "channelB_data" :"base64", "intensityA" : 98, "intensityB" : 98 } self.collect_object2 = { "method" : "scanner2", "channelA_data" :"base64", "channelB_data" :"base64", "intensityA" : 98, "intensityB" : 98 } self.debug_timer = QTimer(self) self.debug_timer.timeout.connect(self.update_debug_timer) if YSMODE: self.debug_timer.start(1000) def update_debug_timer(self): import random channelA = [random.randint(1, 1000) for _ in range(3000)] channelB = [random.randint(1, 1000) for _ in range(3000)] self.collect_object1['channelA_data'] = base64.b64encode(json.dumps(channelA).encode()).decode() self.collect_object1['channelB_data'] = base64.b64encode(json.dumps(channelB).encode()).decode() self.collect_object2['channelA_data'] = base64.b64encode(json.dumps(channelA).encode()).decode() self.collect_object2['channelB_data'] = base64.b64encode(json.dumps(channelB).encode()).decode() self.send_collect_data.emit(self.collect_object1) self.send_collect_data.emit(self.collect_object2) def kill_udp_port(self, port): for proc in psutil.process_iter(): try: for conn in proc.connections(kind='udp'): if conn.laddr.port == port: print(f" PID={proc.pid}, procname={proc.name()}") proc.kill() except psutil.AccessDenied: continue def packet_crc(self, data): usSum = 0 for byte in data: usSum += byte return usSum & 0xFFFF # 确保返回值为16位 def handle_sample_data(self, data): # 确保数据长度是4的倍数 if len(data) % 4 != 0: raise ValueError("Data length must be a multiple of 4") # 使用列表推导式来简化代码 unpacked_data = [struct.unpack_from(' len(binary_data): print("offset:", offset, "data_len:", len(data_points)) break channel_A.append(struct.unpack(' bool: """检查数据包是否以UDP_PACKET_MAGIC开头""" if len(data) < 2: return False magic = struct.unpack(' Optional[PacketReassembler]: """获取或创建包重组器""" key = (addr, header.big_packet_id) with self.reassembler_lock: # 检查是否已存在 if key in self.reassemblers: reassembler = self.reassemblers[key] # 检查是否超时 if reassembler.is_timeout(): logger.warning(f"大包 {header.big_packet_id} 超时,丢弃") del self.reassemblers[key] return None return reassembler # 创建新的重组器 reassembler = PacketReassembler( header.big_packet_id, header.total_size, header.total_packets, addr, self.timeout ) self.reassemblers[key] = reassembler logger.info(f"创建新的大包重组器: ID={header.big_packet_id}, " f"大小={header.total_size}, 包数={header.total_packets}, 来源={addr}") return reassembler # 新增:处理完成重组的数据包 def _handle_completed_packet(self, reassembler: PacketReassembler): """处理完成重组的数据包""" data = reassembler.get_data() if data: logger.info(f"收到完整数据包: 大小={len(data)} 字节, " f"来源={reassembler.sender_addr}, ID={reassembler.big_packet_id}") # 调用现有的数据处理方法 try: # 尝试解析为JSON格式 msg = json.loads(data.decode().strip('\0')) msg_type = msg.get('type') if msg_type == "dev_discovery": self.handle_dev_discovery(msg, reassembler.sender_addr[0]) elif msg_type == "data_points": self.handle_data_point(msg, reassembler.sender_addr[0]) else: logger.warning(f"未知的消息类型: {msg_type}") except json.JSONDecodeError: logger.warning(f"重组后的数据不是有效的JSON格式") except Exception as e: logger.error(f"处理重组数据时出错: {e}") # 从重组器列表中移除 with self.reassembler_lock: key = (reassembler.sender_addr, reassembler.big_packet_id) if key in self.reassemblers: del self.reassemblers[key] # 新增:清理超时的包 def _cleanup_timeout_packets(self): """清理超时的包(在后台线程中运行)""" while self.running: time.sleep(0.5) # 每0.5秒检查一次 with self.reassembler_lock: timeout_keys = [] for key, reassembler in self.reassemblers.items(): if reassembler.is_timeout(): timeout_keys.append(key) # 移除超时的包 for key in timeout_keys: reassembler = self.reassemblers[key] logger.warning(f"清理超时的大包: ID={reassembler.big_packet_id}, " f"来源={reassembler.sender_addr}, " f"已接收={reassembler.received_count}/{reassembler.total_packets}") del self.reassemblers[key] def run(self): """启动 UDP 服务器""" self.server_socket = socket.socket(socket.AF_INET, socket.SOCK_DGRAM) self.server_socket.bind((self.ip, self.port)) # 增加接收缓冲区大小 self.server_socket.setsockopt(socket.SOL_SOCKET, socket.SO_RCVBUF, 65536) # 设置为 64KB print(f"UDP server is running on {self.ip}:{self.port}") # 启动清理线程 self.cleanup_thread = threading.Thread(target=self._cleanup_timeout_packets, daemon=True) self.cleanup_thread.start() while self.running: try: while True: # 循环接收数据 try: data, addr = self.server_socket.recvfrom(65536) # 接收最多 64KB 数据 # 检查是否为分包数据 if self.is_fragmented_packet(data): # 处理分包数据 self.handle_fragmented_packet(data, addr) else: # 使用现有的处理方法 try: msg = json.loads(data.decode().strip('\0')) msg_type = msg.get('type') if msg_type == "dev_discovery": self.handle_dev_discovery(msg, addr[0]) if msg_type == "data_points": self.handle_data_point(msg, addr[0]) except json.JSONDecodeError: print(f"Error decoding JSON data: {data.decode()}") except Exception as e: print(f"Error processing data: {e}") except OSError as e: print(f"Error receiving data: {e}") # 记录错误信息 def correct_data(self, filename): # 加载数据 processor.load_data(filename) filename = filename[0:-4] +"_corrected.csv" # 自动选择圆弧区间 if processor.auto_select_arcs(): # 拟合数据 if processor.fit_data(): # 校正数据 corrected = processor.correct_data() # 保存校正后的数据,去掉头尾各200个点 channel_A,channel_B,corrected = processor.save_corrected_data( corrected, filename, trim_edges=True, trim_amount=0 ) return channel_A,channel_B,corrected return None,None,None def handle_dev_discovery(self, msg, ip_address): if msg.get("name") == "daq": status = msg.get("status") if status: # temp = status.get("temp", 0) / 10 # speed = status.get("speed", 0) if ip_address == "192.168.100.236": self.update_acquisition_info.emit(1, status) elif ip_address == "192.168.100.237": self.update_acquisition_info.emit(2, status) def handle_data_point(self, msg, ip_address): try: print("handle data from", ip_address) direction = "" if msg.get("direction") == "up": direction = "UP" elif msg.get("direction") == "down": direction = "DOWN" if msg.get("name") == "daq": channelA, channelB,file_content, row_count =self.parse_packet(msg.get("data","") ) index_col = [i for i in range(row_count)] #save data to csv file filename = f'/home/admin/PythonPro/TGX_PYSERVER/datas/data{time.strftime("%Y%m%d%H%M%S")}.csv' with open(filename, 'w', newline='') as f: writer = csv.writer(f) writer.writerow(['INDEX', 'CH1', 'CH2']) writer.writerows(zip(index_col, channelA, channelB)) if COREECTMODE: channelA,channelB,corrected = self.correct_data(filename) if corrected: file_content = corrected channelA_json = json.dumps(channelA) channelB_json = json.dumps(channelB) channelA_bytes = channelA_json.encode('utf-8') channelB_bytes = channelB_json.encode('utf-8') if ip_address == "192.168.100.236": self.collect_object1["method"] = "scanner1" self.start_cal.emit(1, file_content, direction, row_count) print("====emit direction[1]:", direction) self.collect_object1['channelA_data'] = base64.b64encode(channelA_bytes).decode('utf-8') self.collect_object1['channelB_data'] = base64.b64encode(channelB_bytes).decode('utf-8') self.send_collect_data.emit(self.collect_object1) elif ip_address == "192.168.100.237": self.collect_object2["method"] = "scanner2" self.start_cal.emit(2, file_content, direction, row_count) print("====emit direction[2]:", direction) self.collect_object2['channelA_data'] = base64.b64encode(channelA_bytes).decode('utf-8') self.collect_object2['channelB_data'] = base64.b64encode(channelB_bytes).decode('utf-8') self.send_collect_data.emit(self.collect_object2) except OSError as e: print(f"Error handle_data_point: {e}") # 记录错误信息 def stop(self): """停止 UDP 服务器""" self.running = False if self.server_socket: self.server_socket.close() self.wait() # 等待线程结束 def send_message(self, message, ip, port): """发送消息到指定的 IP 和端口""" if self.server_socket: self.server_socket.sendto(message.encode(), (ip, port)) def __del__(self): self.stop() # 确保在对象销毁时停止服务器