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 from scipy.ndimage import gaussian_filter1d import numpy as np # 配置日志 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 daq_data_packet_ack(self, ip, pid): try: # 构建命令数据包 # 命令格式: AA CC 01 XX XX XX XX # 其中XX XX XX XX为采集时长,小端格式 command = bytearray([0xAA, 0xCC, 0x03]) # 将时长转换为4字节小端格式 command.extend(struct.pack(' 100: #gause filter channelA_filtered = gaussian_filter1d(channelA, 0.5) channelA = np.array(channelA_filtered).tolist() channelB_filtered = gaussian_filter1d(channelB, 0.5) channelB = np.array(channelB_filtered).tolist() #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)) channelA_average = np.mean(channelA) channelB_average = np.mean(channelB) if COREECTMODE and channelA_average > 5000 and channelB_average > 5000: try: _channelA,_channelB,corrected = self.correct_data(filename) if corrected: file_content = corrected channelA = _channelA channelB = _channelB except Exception as e: print(f"Error correcting data: {e}") channelA_json = json.dumps(channelA) channelB_json = json.dumps(channelB) # print("================channelA_json",channelA_json) # print("================channelB_json",channelB_json) 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" if channelA_average < 5000 or channelB_average < 5000: print("xray low idensity") else: 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" if channelA_average < 5000 or channelB_average < 5000: print("xray low idensity") else: 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() # 确保在对象销毁时停止服务器