526 lines
20 KiB
Plaintext
526 lines
20 KiB
Plaintext
# The `CpyMqttClient` class is a Python class that handles MQTT 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, QUrl, QIODevice
|
|
|
|
import os
|
|
import gzip
|
|
from io import BytesIO
|
|
from Manager.history_manager import historyManager
|
|
import json
|
|
from config import *
|
|
import logging
|
|
import struct
|
|
import base64
|
|
import threading
|
|
import uuid
|
|
import copy
|
|
import time
|
|
import socket
|
|
|
|
import paho.mqtt.client as mqtt
|
|
import ssl
|
|
|
|
import pandas as pd
|
|
|
|
# 配置日志记录
|
|
logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(name)s - %(levelname)s - %(message)s')
|
|
logger = logging.getLogger('CpyMqttClient')
|
|
|
|
class CpyMqttClient(QObject):
|
|
reciveData = Signal(dict)
|
|
|
|
def __init__(self, address, port, dev_id, psk=None):
|
|
super().__init__()
|
|
self.dev_id = dev_id
|
|
self.init = 1
|
|
self.file_name = ""
|
|
self.scanner_name = ""
|
|
self.address = address
|
|
self.port = port
|
|
self.tempIndex = 0
|
|
|
|
self.last_server_ack_time = 0
|
|
|
|
self.cal_queue = {}
|
|
|
|
# 初始化MQTT客户端,通过SSL连接
|
|
# 使用V2.0 API版本
|
|
self.client = mqtt.Client(client_id=dev_id, callback_api_version=mqtt.CallbackAPIVersion.VERSION2)
|
|
# 设置连接回调
|
|
self.client.on_connect = self.on_connect
|
|
self.client.on_message = self.on_message
|
|
self.client.on_disconnect = self.on_disconnect
|
|
# 设置用户名密码
|
|
self.client.username_pw_set('cpy_tgx-08_controller', 'tgzz2026.')
|
|
# 配置SSL
|
|
logger.info("Configuring SSL for MQTT connection...")
|
|
# 使用默认系统CA证书
|
|
self.client.tls_set(cert_reqs=ssl.CERT_NONE)
|
|
# 禁用证书验证,解决自签名证书问题
|
|
self.client.tls_insecure_set(True)
|
|
# 开始循环
|
|
logger.info("Starting MQTT client loop...")
|
|
# self.client.loop_start()
|
|
|
|
self.check_timer = QTimer(self)
|
|
self.check_timer.timeout.connect(self.check_mqtt_server)
|
|
self.check_timer.start(1000)
|
|
|
|
thread = threading.Thread(target=self.main_loop)
|
|
thread.start()
|
|
|
|
|
|
|
|
def cal_queue_lock(self):
|
|
if not hasattr(self, "_cal_queue_lock"):
|
|
self._cal_queue_lock = threading.Lock()
|
|
self._cal_queue_lock.acquire()
|
|
|
|
def cal_queue_unlock(self):
|
|
try:
|
|
self._cal_queue_lock.release()
|
|
except:
|
|
pass
|
|
|
|
def check_cal_queue(self):
|
|
"""检查计算队列"""
|
|
if len(self.cal_queue) == 0:
|
|
return
|
|
logger.info(f"check cal queue: {len(self.cal_queue)} items in queue")
|
|
self.cal_queue_lock()
|
|
# 使用列表复制进行遍历,避免字典大小变化导致的错误
|
|
for uid, data in list(self.cal_queue.items()):
|
|
if time.time() - data.get("time", 0) > 5:
|
|
logger.error(f"calculate response timeout: {uid}")
|
|
del self.cal_queue[uid]
|
|
self.cal_queue_unlock()
|
|
|
|
def check_network_ready(self, host="cpycal.tgoim.com", port=8883):
|
|
try:
|
|
ip = socket.gethostbyname(host)
|
|
|
|
sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
|
|
sock.settimeout(0.5)
|
|
result = sock.connect_ex((ip, port))
|
|
sock.close()
|
|
print(result)
|
|
if result == 0:
|
|
return ip
|
|
return False
|
|
except Exception as e:
|
|
print(e)
|
|
return False
|
|
|
|
def check_mqtt_server(self):
|
|
if self.status == "init":
|
|
ip = self.check_network_ready()
|
|
if ip:
|
|
logger.info("Connecting to MQTT broker at cpycal.tgoim.com:8883...")
|
|
self.client.connect(ip, 8883, 10)
|
|
self.check_timer.stop()
|
|
|
|
def main_loop(self):
|
|
"""主循环"""
|
|
self.status = "init"
|
|
|
|
|
|
|
|
while True: print(self.status) self.check_cal_queue()
|
|
|
|
time.sleep(1)
|
|
if self.status == "init__":
|
|
if self.check_network_ready():
|
|
# 连接到MQTT服务器
|
|
logger.info("Connecting to MQTT broker at cpycal.tgoim.com:8883...")
|
|
self.client.connect('cpycal.tgoim.com', 8883, 10)
|
|
time.sleep(2)
|
|
else:
|
|
logger.info('network not ready...')
|
|
if self.status == "connected":
|
|
self.status = "checking"
|
|
self.check_server_status()
|
|
elif self.status == "available":
|
|
self.status = "registering"
|
|
self.register()
|
|
elif self.status == "checking":
|
|
if time.time() > self.check_server_status_time + 5:
|
|
self.status = "checking"
|
|
self.check_server_status()
|
|
elif self.status == "unavailable":
|
|
self.status = "checking"
|
|
self.check_server_status()
|
|
elif self.status == "registering":
|
|
if time.time() > self.register_time + 5:
|
|
self.status = "checking"
|
|
self.check_server_status()
|
|
elif self.status == "registered":
|
|
if time.time() > self.last_server_ack_time + 10:
|
|
self.status = "checking"
|
|
self.check_server_status()
|
|
|
|
def on_disconnect(self, client, userdata, flags, rc, properties=None):
|
|
"""断开连接回调 (V2.0 风格)"""
|
|
self.status = "disconnected"
|
|
logger.info(f"Disconnected from MQTT broker, return code: {rc}")
|
|
|
|
def on_connect(self, client, userdata, flags, rc, properties=None):
|
|
"""连接成功回调 (V2.0 风格)"""
|
|
if rc == 0:
|
|
logger.info("Connected to MQTT broker successfully")
|
|
self.status = "connected"
|
|
self.client.subscribe(f"v1/cpy/{self.dev_id}", qos=1)
|
|
else:
|
|
logger.error(f"Failed to connect to MQTT broker, return code: {rc}")
|
|
|
|
def handle_calculate_response(self, result, uid):
|
|
"""处理计算响应"""
|
|
if not result:
|
|
logger.error(f"Received calculate response with empty result: {result}")
|
|
return
|
|
try:
|
|
if not uid:
|
|
logger.error(f"Received calculate response with no 'uuid' field: {uid}")
|
|
return
|
|
self.cal_queue_lock()
|
|
_data = self.cal_queue.get(uid, None)
|
|
self.cal_queue_unlock()
|
|
if not _data:
|
|
logger.error(f"Received calculate response with no 'uuid' field: {uid}")
|
|
return
|
|
cal_data = copy.deepcopy(_data) #使用深拷贝
|
|
self.cal_queue_lock()
|
|
del self.cal_queue[uid] #删除队列中的数据
|
|
self.cal_queue_unlock()
|
|
|
|
if cal_data.get("time", None):
|
|
logger.info(f"calculation costs time: {time.time() - cal_data.get('time', None)}")
|
|
|
|
data_path = cal_data.get("data_path", None)
|
|
if not data_path:
|
|
logger.error(f"Received calculate response with no 'data_path' field: {data_path}")
|
|
return
|
|
info = cal_data.get("info", None)
|
|
if not info:
|
|
logger.error(f"Received calculate response with no 'info' field: {result}")
|
|
return
|
|
|
|
# 保存设备名称和文件名
|
|
scanner_id = info.get("scanner_id", None)
|
|
if not scanner_id:
|
|
logger.error(f"Received calculate response with no 'scanner_id' field: {result}")
|
|
return
|
|
|
|
result['device'] = f"scanner{scanner_id}"
|
|
|
|
# 计算额外的结果数据
|
|
processed_result = self.calResult(json.dumps(result))
|
|
# 保存结果到文件
|
|
self.save_result(data_path, processed_result)
|
|
|
|
# 发射结果信号
|
|
self.emit_recive_data(processed_result)
|
|
except json.JSONDecodeError:
|
|
logger.error("Failed to parse server response as JSON")
|
|
|
|
def handle_server_response(self, payload):
|
|
"""处理服务器响应"""
|
|
cmd = payload.get("ack", None)
|
|
error = payload.get("error", None)
|
|
result = payload.get("result", None)
|
|
if not cmd or error is None or result is None:
|
|
logger.error(f"Received message with no 'ack' field: {payload}")
|
|
return
|
|
|
|
if cmd == "status":
|
|
logger.info(f"Server status: {result}")
|
|
if error == 200:
|
|
self.status = "available"
|
|
else:
|
|
self.status = "unavailable"
|
|
elif cmd == 'register':
|
|
if error == 200:
|
|
self.status = "registered"
|
|
self.last_server_ack_time = time.time()
|
|
else:
|
|
self.status = "unavailable"
|
|
logger.info(f"Register status: {'success' if self.status == 'registered' else 'failed'}")
|
|
elif cmd == 'calculate':
|
|
if error == 200:
|
|
self.last_server_ack_time = time.time()
|
|
self.handle_calculate_response(result, payload.get("uuid", None))
|
|
else:
|
|
logger.error(f"Received calculate response with error: {error}")
|
|
|
|
def on_message(self, client, userdata, msg):
|
|
"""接收消息回调 (V2.0 风格)"""
|
|
try:
|
|
payload = json.loads(msg.payload.decode())
|
|
logger.info(f"Received message on topic {msg.topic}: {payload}")
|
|
self.handle_server_response(payload)
|
|
except json.JSONDecodeError:
|
|
logger.error(f"Failed to decode JSON from message on topic {msg.topic}")
|
|
|
|
def send_command(self, payload):
|
|
"""发送MQTT命令"""
|
|
topic = f"v1/cpy/server/3"
|
|
self.client.publish(topic, json.dumps(payload), qos=0)
|
|
|
|
def register(self):
|
|
"""注册设备到服务器"""
|
|
self.register_time = time.time()
|
|
payload = {
|
|
"cmd":"register",
|
|
"ver":1,
|
|
"dev_id": self.dev_id
|
|
}
|
|
self.send_command(payload)
|
|
|
|
def check_server_status(self):
|
|
"""检查服务器状态"""
|
|
self.check_server_status_time = time.time()
|
|
try:
|
|
payload = {
|
|
"cmd":"status",
|
|
"ver":1,
|
|
"dev_id": self.dev_id
|
|
}
|
|
self.send_command(payload)
|
|
logger.info(f"Sent status check command: {payload}")
|
|
except Exception as e:
|
|
logger.error(f"Error checking server status: {e}")
|
|
return None
|
|
|
|
def calculate_data(self, info, data, data_path):
|
|
"""计算数据"""
|
|
try:
|
|
info['uuid'] = str(uuid.uuid4())
|
|
info['cmd'] = 'calculate'
|
|
info['ver'] = 1
|
|
info['data'] = base64.b64encode(data).decode('utf-8')
|
|
self.cal_queue_lock()
|
|
self.cal_queue[info['uuid']] = {
|
|
"data_path" : data_path,
|
|
"info" : info,
|
|
"time" : time.time(),
|
|
}
|
|
self.cal_queue_unlock()
|
|
self.send_command(info)
|
|
except Exception as e:
|
|
logger.error(f"Error in calculate_data: {e}")
|
|
|
|
def compress_file_with_name(self, csv_path: str):
|
|
compressed_data = None
|
|
try:
|
|
#使用pandas读取csv文件
|
|
df = pd.read_csv(csv_path)
|
|
file_content = bytearray()
|
|
|
|
# 遍历DataFrame中的每一行
|
|
for index, row in df.iterrows():
|
|
channel_A = row['CH1']
|
|
channel_B = row['CH2']
|
|
file_content.extend(struct.pack('<ff', channel_A, channel_B))
|
|
|
|
# 使用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
|
|
|
|
def compress_file_with_params(self, file_content: bytes):
|
|
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(dict)
|
|
def emit_recive_data(self, data):
|
|
"""在主线程中发射信号"""
|
|
self.reciveData.emit(data)
|
|
|
|
def save_result(self, data_path: str, result: dict):
|
|
"""保存计算结果到文件"""
|
|
try:
|
|
result_path = data_path.replace('.csv', '_result.json')
|
|
if '_corrected' in result_path:
|
|
# 修正后的结果文件名
|
|
result_path = result_path.replace('_corrected', '')
|
|
# 保存结果到文件
|
|
with open(result_path, 'w') as f:
|
|
json.dump(result, f, indent=4)
|
|
|
|
logger.info(f"Result saved to {result_path}")
|
|
|
|
os.remove(data_path)
|
|
except Exception as e:
|
|
logger.error(f"Error saving result: {e}")
|
|
|
|
@Slot(int, str, str, int)
|
|
def start_cal(self, motor_index, data_path, direction, row_count):
|
|
"""开始计算,通过HTTP发送文件数据(异步实现)"""
|
|
|
|
if not self.status == "registered":
|
|
return
|
|
|
|
logger.info(f"Starting calculation with motor_index: {motor_index}, direction: {direction}")
|
|
if direction == "":
|
|
return
|
|
|
|
if not os.path.exists(data_path):
|
|
logger.error(f"File not found: {data_path}")
|
|
return
|
|
|
|
compress_file_content = self.compress_file_with_name(data_path)
|
|
if not compress_file_content:
|
|
logger.error("Failed to compress file content")
|
|
return
|
|
|
|
# 准备表单数据
|
|
info = {
|
|
"init": str(self.init),
|
|
"scanner_id": str(motor_index),
|
|
"dev_id": self.dev_id,
|
|
"version": "2",
|
|
"offset": "0",
|
|
"scale": "1",
|
|
"file_type": "raw",
|
|
"file_name": os.path.basename(data_path),
|
|
"compress": "gz",
|
|
"row_count": str(row_count),
|
|
"direction": direction
|
|
}
|
|
|
|
# 重置init标志
|
|
self.init = 0
|
|
|
|
self.calculate_data(info, compress_file_content, data_path)
|
|
|
|
@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", [])
|
|
|
|
|
|
# 计算椭圆度
|
|
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
|
|
|
|
|
|
|
|
|