Files
2026-06-21 17:13:18 +08:00

397 lines
17 KiB
Python
Executable File

# The `HttpClient` class is a Python class that handles HTTP requests, sends commands to a server,
# processes server responses, and calculates various results based on received data.
from PySide6.QtCore import QObject, Signal, Slot, QTimer
from datetime import datetime
import random
import gzip
from io import BytesIO
from Manager.history_manager import historyManager
import json
from config import *
import requests
import logging
# 配置日志记录
logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(name)s - %(levelname)s - %(message)s')
logger = logging.getLogger('HttpClient')
class HttpClient(QObject):
reciveData = Signal(dict)
def __init__(self, address, port, connection_name, psk=None):
super().__init__()
self.name = connection_name
self.init = 1
self.file_name = ""
self.device_name = ""
self.address = address
self.port = port
self.tempIndex = 0
self.base_url = f"http://{address}:{port}/api"
logger.info(f"HttpClient initialized with base URL: {self.base_url}")
# 定时器
self.debug_timer = QTimer(self)
self.debug_timer.setInterval(5000)
self.debug_timer.timeout.connect(self.debug_info)
if YSMODE:
self.debug_timer.start()
logger.info("Debug mode enabled")
def debug_info(self):
if self.tempIndex == 0:
self.device_name = "scanner1"
self.tempIndex = 1
elif self.tempIndex == 1:
self.device_name = "scanner2"
self.tempIndex = 0
self.reciveData.emit({
"device": self.device_name,
"WtOSC": [random.uniform(0.80,0.82), 0.799, 0.819, 0.837, 0.83, 0.815, 0.812, 0.81],
"WtINS": [random.uniform(10.498,10.520), 10.525, 10.512, 10.488, 10.485, 10.486, 10.471, 10.468],
"WtISC": [0.973, 0.965, 0.94, 0.924, 0.935, 0.957, 0.968, 0.97],
"WtALL": [12.271, 12.288, 12.271, 12.249, 12.25, 12.258, 12.25, 12.248],
"AngOSC": [0, 90, 346.656],
"AngINS": [270, 0, 253.233],
"AngISC": [90, 315, 144.457],
"AngALL": [270, 0, 226.029],
"DmCORE": [random.uniform(14,14.3), 14.2, 14.1],
"DmALL": [random.uniform(37,37.2), 37.1, 37.2],
"EccentricityINS": random.uniform(0.30, 0.60),
"EccentricityOSC": 4.540023894862595,
"EccentricityISC": 5.035971223021576,
"Volatility": [0.021, 0.021, 0.028],
"EllipticityDmALL": -0.0,
"EllipticityDmCORE": -0.0,
"AvgALL": 12.260625000000001,
"AvgISC": 0.954, "AvgOSC": 0.81525, "AvgINS": 10.491625, "MinALL": 12.248, "MinISC": 0.924, "MinOSC": 0.799, "MinINS": 10.468,
"ConcentricityALL": 99.83697424193022, "ConcentricityISC": 97.4169741697417, "ConcentricityOSC": 97.67726161369193, "ConcentricityINS": 99.72848092221216,
"EccentricALL": 0.020000000000000462, "EccentricISC": 0.024499999999999966, "EccentricOSC": 0.01899999999999996, "EccentricINS": 0.028500000000000192,
"EccentricityALL": 0.32552083333334086,"EdgesA": [41.53, 42.66, 54.93, 56.28, 75.88, 76.58, 86.97, 88.19], "EdgesB": [39.36, 40.58, 52.69, 53.92, 73.64, 74.23, 84.77, 86.01]})
# self.reciveData.emit({
# "device": self.device_name,
# "WtOSC": [0.83, 0.86, 0.84, 0.81, 0.88, 0.92, 0.87, 0.79],
# "WtISC": [0.72, 0.76, 1.03, 0.96, 1.05, 0.84, 0.77, 0.89],
# "WtINS": [5.96, 6.57, 11.33, 13.54, 11.27, 6.47, 5.88, 7.62],
# "WtALL": [7.50, 8.20, 13.20, 15.32, 13.21, 8.22, 7.52, 9.30],
# "AngOSC": [303.75, 225.00, 21.88],
# "AngINS": [202.50, 135.00, 274.23],
# "AngISC": [247.50, 78.75, 301.21],
# "AngALL": [247.50, 135.00, 286.10],
# "DmCORE": [16.69, 14.54, 18.85],
# "DmALL": [37.21, 39.16, 35.27],
# "DmCOREDeviation": 1,
# "DmALLDeviation": 2,
# "AvgINS": 8.82,
# "AvgOSC": 0.95,
# "AvgISC": 0.88,
# "AvgALL": 9.63,
# "MinISC": 0.95,
# "MinOSC": 0.81,
# "MinINS": 5.88,
# "MinALL": 7.50,
# "EccentricINS": 0.95,
# "EccentricOSC": 2.03,
# "EccentricISC": 3.22,
# "EccentricALL": 8.82,
# "EccentricityINS": 16.003,
# "EccentricityOSC": 21.126,
# "EccentricityISC": 43.283,
# "EccentricityALL": 43.283,
# "ConcentricityALL" : 21.25,
# "ConcentricityINS" : 21.25,
# "ConcentricityOSC" : 11.63,
# "ConcentricityISC" : 6.53,
# "ConcentricityDeviationALL": 21.25,
# "ConcentricityDeviationINS": 21.25,
# "ConcentricityDeviationOSC": 11.63,
# "ConcentricityDeviationISC": 6.53,
# "EllipticityDmCORE": 6.51,
# "EllipticityDmALL": 9.68,
# "Volatility": [0.290, 0.088, 0.314],
# "EdgesA": [41.53, 42.66, 54.93, 56.28, 75.88, 76.58, 86.97, 88.19],
# "EdgesB": [39.36, 40.58, 52.69, 53.92, 73.64, 74.23, 84.77, 86.01]
# })
def start_handshake(self):
# HTTP客户端不需要握手,可以直接发送请求
logger.info(f"{self.name}: HTTP client ready to send requests to {self.address}:{self.port}")
def check_server_status(self):
"""检查服务器状态"""
try:
url = f"{self.base_url}/status"
response = requests.get(url, timeout=5)
if response.status_code == 200:
return response.json()
else:
logger.error(f"Failed to get server status, status code: {response.status_code}")
return None
except Exception as e:
logger.error(f"Error checking server status: {e}")
return None
@Slot()
def handle_timeout(self):
# HTTP客户端不需要重连,重试请求即可
logger.info(f"{self.name}: HTTP request timeout, ready to retry")
@Slot()
def udp_socket_connected(self):
# 兼容原有接口,HTTP客户端不需要UDP连接
pass
@Slot()
def readyRead(self):
# 兼容原有接口,HTTP客户端不需要监听接收数据
pass
def send_command(self, command, params=None):
"""发送命令到服务器"""
try:
url = f"{self.base_url}/command"
data = {"command": command}
if params:
data.update(params)
response = requests.post(url, json=data, timeout=10)
if response.status_code == 200:
logger.info(f"Command '{command}' sent successfully")
return response.json()
else:
logger.error(f"Failed to send command '{command}', status code: {response.status_code}")
return None
except Exception as e:
logger.error(f"Error sending command '{command}': {e}")
return None
@Slot()
def handshake_timeout(self):
# HTTP客户端不需要处理握手超时
pass
@Slot(bytearray)
def write_data(self, data):
"""发送二进制数据到服务器"""
try:
url = f"{self.base_url}/data"
files = {'file': ('binary_data', data, 'application/octet-stream')}
response = requests.post(url, files=files, timeout=10)
if response.status_code == 200:
logger.info('Data sent successfully')
result = response.json()
if result:
self.reciveData.emit(self.calResult(json.dumps(result)))
return True
else:
logger.error(f"Failed to send data, status code: {response.status_code}")
return False
except Exception as e:
logger.error(f"Error sending data: {e}")
return False
def compress_file_with_params(self, file_content):
compressed_data = None
try:
# 使用BytesIO来创建一个可写的文件对象
compressed_file = BytesIO()
with gzip.GzipFile(fileobj=compressed_file, mode='wb') as gzf:
gzf.write(file_content)
# 读取压缩后的文件内容
compressed_data = compressed_file.getvalue()
return compressed_data
except Exception as e:
logger.error(f'Error compressing file: {e}')
return None
@Slot(int, bytearray,str, int)
def start_cal(self, motor_index, file_content, direction, row_count):
"""开始计算,通过HTTP发送文件数据"""
logger.info(f"Starting calculation with motor_index: {motor_index}, direction: {direction}")
if direction == "":
return
direction_value = 0
if direction == "UP":
direction_value = 1
elif direction == "DOWN":
direction_value = 2
current_time = datetime.now()
compress_file_content = self.compress_file_with_params(file_content)
if not compress_file_content:
logger.error("Failed to compress file content")
return
self.device_name = f"scanner{motor_index}"
self.file_name = f'{current_time.strftime("%Y-%m-%d_%H_%M_%S_%f")[:-3]}_direction_{direction_value}_device{motor_index}.csv'
try:
url = f"{self.base_url}/data"
# 准备表单数据
form_data = {
"init": str(self.init),
"device_id": str(motor_index),
"device_name": DEVICENAME,
"version": "2",
"offset": "0",
"scale": "1",
"file_type": "raw",
"compress": "gz",
"row_count": str(row_count),
"direction": direction
}
# 准备文件数据
files = {
'file': (f'{self.file_name}.gz', compress_file_content, 'application/gzip')
}
self.init = 0
logger.info(f"Sending file: {self.file_name}.gz with size: {len(compress_file_content)} bytes")
# 发送HTTP POST请求
response = requests.post(url, data=form_data, files=files, timeout=30)
if response.status_code == 200:
logger.info("Calculation request sent successfully")
try:
result = response.json()
if result:
# 添加设备名称到结果中
result['device'] = self.device_name
# 计算额外的结果数据
processed_result = self.calResult(json.dumps(result))
self.reciveData.emit(processed_result)
except json.JSONDecodeError:
logger.error("Failed to parse server response as JSON")
else:
logger.error(f"Failed to send calculation request, status code: {response.status_code}")
logger.error(f"Response content: {response.text}")
except Exception as e:
logger.error(f"Error sending calculation request: {e}")
@Slot()
def set_init(self):
self.init = 1
logger.info(f"=====set init==== {self.init}")
def calResult(self, r_str):
"""处理服务器返回的计算结果"""
try:
robj = json.loads(r_str)
# 安全地获取结果中的数据,如果不存在则使用默认空列表
DmALL = robj.get("DmALL", [])
DmCORE = robj.get("DmCORE", [])
WtOSC = robj.get("WtOSC", [])
WtINS = robj.get("WtINS", [])
WtISC = robj.get("WtISC", [])
WtALL = robj.get("WtALL", [])
# 设置设备名称
robj["device"] = self.device_name
# 计算椭圆度
if len(DmALL) >= 3:
robj["EllipticityDmALL"] = 2*abs(DmALL[1]-DmALL[2])/(DmALL[1] + DmALL[2]) if (DmALL[1] + DmALL[2]) != 0 else 0
else:
robj["EllipticityDmALL"] = 0
if len(DmCORE) >= 3:
robj["EllipticityDmCORE"] = 2*abs(DmCORE[1]-DmCORE[2])/(DmCORE[1] + DmCORE[2]) if (DmCORE[1] + DmCORE[2]) != 0 else 0
else:
robj["EllipticityDmCORE"] = 0
# 计算平均值
robj["AvgALL"] = self.avg(WtALL)
robj["AvgISC"] = self.avg(WtISC)
robj["AvgOSC"] = self.avg(WtOSC)
robj["AvgINS"] = self.avg(WtINS)
# 计算最小值
if WtALL:
robj["MinALL"] = min(WtALL)
robj["ConcentricityALL"] = 200*min(WtALL)/(min(WtALL)+max(WtALL)) if (min(WtALL)+max(WtALL)) != 0 else 0
robj["EccentricALL"] = (max(WtALL) - min(WtALL))/2
robj["EccentricityALL"] = (max(WtALL) - min(WtALL))*100/max(WtALL) if max(WtALL) != 0 else 0
else:
robj["MinALL"] = 0
robj["ConcentricityALL"] = 0
robj["EccentricALL"] = 0
robj["EccentricityALL"] = 0
if WtISC:
robj["MinISC"] = min(WtISC)
robj["ConcentricityISC"] = 200*min(WtISC)/(min(WtISC)+max(WtISC)) if (min(WtISC)+max(WtISC)) != 0 else 0
robj["EccentricISC"] = (max(WtISC) - min(WtISC))/2
robj["EccentricityISC"] = (max(WtISC) - min(WtISC))*100/max(WtISC) if max(WtISC) != 0 else 0
else:
robj["MinISC"] = 0
robj["ConcentricityISC"] = 0
robj["EccentricISC"] = 0
robj["EccentricityISC"] = 0
if WtOSC:
robj["MinOSC"] = min(WtOSC)
robj["ConcentricityOSC"] = 200*min(WtOSC)/(min(WtOSC)+max(WtOSC)) if (min(WtOSC)+max(WtOSC)) != 0 else 0
robj["EccentricOSC"] = (max(WtOSC) - min(WtOSC))/2
robj["EccentricityOSC"] = (max(WtOSC) - min(WtOSC))*100/max(WtOSC) if max(WtOSC) != 0 else 0
else:
robj["MinOSC"] = 0
robj["ConcentricityOSC"] = 0
robj["EccentricOSC"] = 0
robj["EccentricityOSC"] = 0
if WtINS:
robj["MinINS"] = min(WtINS)
robj["ConcentricityINS"] = 200*min(WtINS)/(min(WtINS)+max(WtINS)) if (min(WtINS)+max(WtINS)) != 0 else 0
robj["EccentricINS"] = (max(WtINS) - min(WtINS))/2
robj["EccentricityINS"] = (max(WtINS) - min(WtINS))*100/max(WtINS) if max(WtINS) != 0 else 0
else:
robj["MinINS"] = 0
robj["ConcentricityINS"] = 0
robj["EccentricINS"] = 0
robj["EccentricityINS"] = 0
# 保存到历史记录
try:
historyManager.create(robj)
except Exception as hist_error:
logger.error(f"Error saving to history: {hist_error}")
return robj
except Exception as e:
logger.error(f"Error processing calculation result: {e}")
return {}
def avg(self, data):
"""计算平均值"""
if len(data) == 0:
return 0
if len(data) == 1:
return data[0]
try:
mean_value = sum(data) / len(data)
return mean_value
except TypeError:
logger.error("Error calculating average: data contains non-numeric values")
return 0
@Slot(object)
def psk_required(self, auth):
# HTTP客户端不需要PSK认证
pass
# 为了保持向后兼容性,可以继续使用原类名
CalcHttpClient = HttpClient