dale_yxc/dtm-py-all
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
872b1817037e8a65832edc1568ad8b4097a920f8
dtm-py-all/dtmgtApp.py

998 lines
40 KiB
Python
Raw Normal View History

这是使用PyQT5作为UI的首次提交,将后端和UI合并到1个工程中，统一使用了Python，没有使用JS和HTML
2025-12-14 12:13:19 +08:00
import argparse
import asyncio
import queue
import multiprocessing
import signal
import time
import keyboard
import requests
import serial.tools.list_ports
import sqlite3, datetime
import eel
import tkinter as tk
import threading, os, sys, platform
import serial
import logging
# from flask_socketio import SocketIO, emit # 改为sockets 来实现websocket
from flask import Flask, request, jsonify, g, Response, send_from_directory, json
from flask_cors import CORS, cross_origin
import websockets
import uuid
# sudo systemctl restart nginx #centos 下重启nginx
# gunicorn -b 0.0.0.0:5050 -w 3 -error-log ./dtmgt.log dtmgtApp:app
# gunicorn -b 0.0.0.0:5050 -w 3 --error-log ./dtmgt.log --preload dtmgtApp:app
# 在linux 下不使用gunicorn启动此程序，nohup python(39) dtmgtApp.py --modbusServer=xxxxx --modbusServerPort=xxxxx
# 本地运行 python dtmgtApp.py --startModbusServer
# pyinstaller --add-data "src;dst" xxxx.py
# 打包成1个可执行文件 exe
# pyinstaller --onefile --add-data "web;web" dtmgtApp.py
# pyinstaller dtmgtApp.spec # 包含pyQT5的打包 20251208 更新
from pymodbus.client import ModbusSerialClient as ModbusClient
# import dtMachineService as machineService # 延迟到 main() 函数中导入，以便先设置 MOCK_MODE
from modbus_server import ModbusServer
from multiprocessing import Process, Event
from api_route import app, access_table_data, dutDirectionMode, set_machine_service
from utils import print_with_timestamp
initialized = False
dbServer_aloned = False
dtm_machines = {}
dtMachineService = None
machineService = None # 将在 main() 函数中导入
webview_thread = None
modbus_server_obj = None
webSocket_server = None
websocket_connected_clients = set() # 定义全局对象
ws_message_send_queue = queue.Queue() # 全局线程安全的消息队列
ws_dispatcher_thread = None
flask_server_thread = None
keyboard_input_thread = None
main_exit_flag = False
flask_stop_event = None
socketio_thread = None
insert_result_thread = None
# 设置 Werkzeug 日志记录器（Flask 默认的开发服务器）等级为 ERROR
logging.getLogger('werkzeug').setLevel(logging.ERROR)
# 连接SQLite数据库
try:
dbConn = sqlite3.connect('db\dtmgtDb.db')
dbCursor = dbConn.cursor()
# 创建表
dbCursor.execute('''CREATE TABLE IF NOT EXISTS TEST
(ID INT PRIMARY KEY NOT NULL,
NAME TEXT NOT NULL,
RESULT TEXT NOT NULL);''')
except sqlite3.Error as e:
print(f"Database error: {e}")
# 或者你可以选择抛出异常，让程序停止运行
# raise e
# socket IO
name_space = "/ws"
"""
# 改为sockets 来实现websocket
@socketio.on('connect', namespace=name_space) # 处理前端定时或者主动来查询试验机器数据和状态的请求
@cross_origin()
def ws_connect(auth ={}):
print('socket client connected', auth)
return None
@socketio.on('disconnect', namespace=name_space) # 处理前端定时或者主动来查询试验机器数据和状态的请求
@cross_origin()
def ws_disconnect():
print('socket client disconnected')
"""
def handle_get_machines_value(param):
# print('socket io received message: ' + param)
try:
param = json.loads(param)
except:
pass
if 'machines' in param:
if dtMachineService:
current_time = datetime.datetime.now().strftime('%H:%M:%S.%f')[:-3]
# print(f'{current_time} :getMachinesValue begin', param['machines'])
result = dtMachineService.get_machines_value(param['machines'])
# emit('get_machines_data', {"status": "success", "data": result})
current_time = datetime.datetime.now().strftime('%H:%M:%S.%f')[:-3]
# print(f'{current_time} :getMachinesValue end', param['machines'])
return {"status": "success", "data": result}
else:
return {"status": "error", "msg": "machine service is not available"}
# emit('get_machines_data', {"status": "error", "msg": "machine service is not available"})
else:
# emit('get_machines_data', {"status": "error", "msg": "machines in param is invalid"})
return {"status": "error", "msg": "machines in param is invalid"}
"""
{
"requestId": "f876asd98g7fds987da",
"module": "dz_drop",
"sfcNo":"Fxxxxxxxxx+7+350",
"buckSn":"CJJ412435132B1078",
"time": "2024-03-27 12:20:53",
"deviceCode": "SUN-LAB1-xxx-xxx",
"deviceCode": "微跌落设备",
"operatorId": "2309120078",
"data": "{"example_field1":"2024-03-27 12:20:53","example_field2":[0.232,0.231,0.43,0.545,0.643]}"
}
"""
"""
下列参数data 示例：
{'SN': '543009860', 'description': '常规跌落操作，样品需放正',
'dropCycles': 12, 'dropDirection': 0, 'dropHeight': 8900, 'dropItem': '正面',
'dtMachine': 'DTM-STA-00002', 'dutSN': '543009860', 'endTime': '2024-07-16 10:11:28',
'id': 111, 'key': 'DTM-TR-00001', 'name': '二型电池组件', 'phase': 'PRJ-PHASE-01',
'project': 'GV9206', 'startTime': '2024-06-14 23:15:46', 'station': '01',
'stationAssigned': '{"dtMachine":"DTM-STA-00002","station":"01"}', 'status': 'cancel', 'tester': '234'}
"""
"""
buckSn:样品编码
project:项目代号
phase:样品阶段
deviceCode:设备编码
channel:工作位(通道)
operatorId:操作员
cyclesTotal:样品总测试次数
orientation:跌落方向
direction:跌落方向编号
cycles:跌落次数
height:跌落高度
config:样品描述
startTime:测试开始时间
endTime:测试结束时间
"""
def generate_request_id():
return uuid.uuid4().hex
def remove_item_from_send_queque(key, value):
# 从队列中获取元素，直到队列为空
global ws_message_send_queue
to_be_emerge = []
while not ws_message_send_queue.empty():
try:
item = ws_message_send_queue.get_nowait()
# 检查 machine_sn 是否匹配
if item.get(key) != value:
# 如果不匹配，将元素放回队列
ws_message_send_queue.put(item)
except queue.Empty:
# 队列为空，跳出循环
break
def post_data_to_lmis(station, data):
if data is None:
return
headers = {'content-type': 'application/json'}
post_json = {"requestId": generate_request_id(), "module": "dz_drop", "buckSn": data.get("SN"),
"deviceCode": data.get("dtMachine"), "operatorId": data.get("tester"),
"time": datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S"),
"deviceName": data.get("deviceName"), "deviceStatus": data.get("deviceStatus")}
item_json = {"project": data.get("project"), "phase": data.get("phase"),
"channel": data.get("station"),
"startTime": data.get("startTime"), "endTime": data.get("endTime"),
"orientation": data.get("dropItem"), "direction": data.get("dropDirection"),
"cycles": data.get("dropCycles"), "cyclesTotal": data.get("cyclesTotal"),
"height": data.get("dropHeight"),
"config": data.get("description")}
post_json['data'] = json.dumps(item_json);
print("post data to lmis--", data, post_json)
retry_count = 0
url = "http://lims.sunwoda.com/gateway/api/rel/upload/commonUploadData"
# url = "http://106.52.71.204:3005/RkUpdate/OtaUpdater/dropItem"
while retry_count < 5:
try:
response = requests.post(url, data=json.dumps(post_json), headers=headers)
# 检查响应状态码
"""
上传失败异常处理
若上传失败，如网络异常、接口调用不同、未知错误等原因，最终导致数据上传失败，则使用同一个 requestId 进行重传，最多重试5次，每次间隔1分钟。
若重试过程中，收到 1501 状态码，则表示数据已上传成功，停止重传，结束请求。
"""
if response.status_code == 200:
# 解析 JSON 响应内容
response_json = response.json()
# 获取 code 和 message
code = response_json.get('code')
message = response_json.get('message')
print("resp", response.status_code, 'code=', code, 'message=', message) # cyx
if code == 200:
print((f"{post_json.get('deviceCode')} {item_json.get('channel')} 上传 "
f"{post_json.get('buckSn')} {item_json.get('cycles')} finished 操作成功"), message)
if code == 1501:
print("数据上传成功", message)
if code == 200 or code == 1501:
break # 成功后跳出循环，结束线程
else:
retry_count += 1
time.sleep(60) # 间隔1分钟
else:
# raise Exception("接口响应状态码错误")
retry_count += 1
time.sleep(60) # 间隔1分钟
except Exception as e:
print(f"上传失败，原因:{e}，开始第{retry_count + 1}次重试")
retry_count += 1
time.sleep(60) # 间隔1分钟
else:
print("重试上传5次后仍失败，结束请求")
# ----------------------------------------------------------------
# 处理LMIS 数据上传
from concurrent.futures import ThreadPoolExecutor
# 全局配置
UPLOAD_MAX_RETRIES = 5
UPLOAD_RETRY_INTERVAL = 60 # 秒
UPLOAD_THREAD_POOL_SIZE = 20 # 根据网络延迟调整
UPLOAD_LIMS_URL = "http://lims.sunwoda.com/gateway/api/rel/upload/commonUploadData"
class LMISUploadSystem:
def __init__(self):
self.retry_queue = queue.PriorityQueue() # (重试时间, data, retry_count)
self.executor = ThreadPoolExecutor(max_workers=UPLOAD_THREAD_POOL_SIZE)
self._start_retry_monitor()
self.session = requests.Session() # 复用HTTP连接
def _start_retry_monitor(self):
"""启动重试监控线程"""
def monitor():
while True:
now = time.time()
try:
# 检查是否有需要重试的任务
if not self.retry_queue.empty() and self.retry_queue.queue[0][0] <= now:
next_time, data, retry_count = self.retry_queue.get()
self.executor.submit(self._upload_data, data, retry_count)
time.sleep(0.5) # 降低CPU占用
except Exception as e:
print(f"重试监控异常: {e}")
threading.Thread(target=monitor, daemon=True).start()
def post_data(self, data):
"""提交数据到上传系统"""
self.executor.submit(self._upload_data, data, 0)
def _upload_data(self, data, retry_count):
"""执行实际的上传操作"""
try:
if data is None:
return
# 构建请求数据
item_json = {
"project": data.get("dutProject", ""), # 使用表字段名
"phase": data.get("dutPhase", ""), # 使用表字段名
"channel": data.get("station_no", ""), # 使用表字段名
"startTime": data.get("startTime", ""),
"endTime": data.get("endTime", ""),
"orientation": data.get("dropItem", ""),
"direction": data.get("dropDirection", 0),
"cycles": data.get("dropCycles", 0),
"cyclesTotal": data.get("stationDropCycles", 0), # 使用表字段名
"height": data.get("dropHeight_int", 0), # 使用表字段名
"config": data.get("description", "")
}
post_json = {
"requestId": str(uuid.uuid4()),
"module": "dz_drop",
"buckSn": data.get("SN", ""),
"deviceCode": data.get("machine_sn", ""), # 使用表字段名
"operatorId": data.get("tester", ""),
"time": datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S"),
"deviceName": data.get("deviceName", ""),
"deviceStatus": data.get("status", ""), # 使用表字段名
"data": json.dumps(item_json)
}
headers = {'content-type': 'application/json'}
print(f"上传数据到LMIS: {data['SN']} (尝试 {retry_count + 1})")
# 使用连接池发送请求
response = self.session.post(
UPLOAD_LIMS_URL,
data=json.dumps(post_json),
headers=headers,
timeout=10
)
# 处理响应
if response.status_code == 200:
response_json = response.json()
code = response_json.get('code')
message = response_json.get('message')
if code in (200, 1501):
print(f"上传成功: {data['SN']} | 代码: {code}, 消息: {message}")
return # 成功结束
# 处理失败情况
raise Exception(f"上传失败: 状态码={response.status_code}, 响应码={code}, 消息={message}")
except Exception as e:
print(f"上传异常: {e}")
if retry_count < UPLOAD_MAX_RETRIES:
next_retry = time.time() + UPLOAD_RETRY_INTERVAL
self.retry_queue.put((next_retry, data, retry_count + 1))
else:
print(f"放弃上传: {data.get('SN')} | 已重试{UPLOAD_MAX_RETRIES}次")
# 初始化上传系统
lmis_upload_system = LMISUploadSystem()
# 定义一个线程安全的队列
result_to_localDB_queue = queue.Queue()
"""
SN TEXT, -- 测试样品序列号
status TEXT, -- 状态
startTime TEXT, -- 跌落开始时间
endTime TEXT, -- 跌落结束时间
tester TEXT, -- 测试员
description TEXT, -- 说明
id INTEGER PRIMARY KEY AUTOINCREMENT,
dropDirection INTEGER, -- 跌落面（方向）
dropHeight_int INTEGER, -- 跌落高度(mm)
dropSpeed INTEGER, -- 跌落速度
stationDropCycles INTEGER, -- 工位跌落次数
dropCycles INTEGER, -- 样品累计已完成跌落次数
itemCurrentCycles INTEGER, -- 样品此方向跌落次数
machine_sn TEXT, -- 设备编码
station_no TEXT, -- 设备工位（通道）
dutProject TEXT, -- 样品项目
dutPhase TEXT, -- 样品阶段
dutProjectType TEXT, -- 样品项目类型
dutWeeks INTEGER, -- 测试周数
dutWorkOrder TEXT -- 测试工单
"""
def run_insert_result():
while True:
try:
insert_records = []
while not ws_message_send_queue.empty():
# 尝试从队列中获取元素，如果队列为空，则阻塞等待
result_row = result_to_localDB_queue.get()
insert_records.append(result_row)
if len(insert_records) > 0:
# print(f"insert req results {insert_records}")
print(f"insert req results {len(insert_records)}")
# 执行插入数据库的操作
if dtMachineService:
dtMachineService.insertTableRecords('TestReq', insert_records)
# 标记任务完成
except queue.Empty:
# 如果队列在超时时间内为空，则继续循环
continue
time.sleep(2)
def cb_insert_result(test_req_result):
"""回调函数 - 处理测试结果"""
# 1. 放入结果队列供本地数据库写入
result_to_localDB_queue.put_nowait(test_req_result)
# 2. 提交到LMIS上传系统
lmis_upload_system.post_data(test_req_result)
def cb_station_result_change(station, data):
if data is None:
return
json_data = {"status": "success", "command": "station_result_change", "data": data}
data["command"] = "station_result_change"
global ws_message_send_queue
if ws_message_send_queue is not None:
ws_message_send_queue.put(json_data)
else:
print("Message queue is not initialized yet!")
def cb_machine_data_change(machine_sn_list, data): # 通知和station 无关的machine data，目前重点是connectState
if data is None:
return
json_data = {"status": "success", "command": "machine_data_change", "data": data}
data["command"] = "machine_data_change"
if len(machine_sn_list) == 1: # 更新单台机器的数据
remove_item_from_send_queque('machine_sn', machine_sn_list[0])
json_data['machine_sn'] = machine_sn_list[0]
global ws_message_send_queue
if ws_message_send_queue is not None:
ws_message_send_queue.put(json_data)
else:
print("Message queue is not initialized yet!")
def run_flask_server(flask_stop_event=None):
app.run(host='0.0.0.0', port=5050, threaded=True, use_reloader=False)
# WebSocket 消息分发器：从队列中取出消息并发送给所有客户端
async def ws_message_send_dispatcher():
while True:
# 创建一个字典来存储以 SN 为键的最新记录
latest_machines = {}
# 从队列中取出所有元素
while not ws_message_send_queue.empty():
item = ws_message_send_queue.get()
if item.get('command') == 'machine_data_change':
# 假设每个元素都有一个 'data' 键，且 'data' 是一个字典，其中包含 'machines' 键
machines = item.get('data', {}).get('machines', [])
for machine in machines:
# 使用 SN 作为键来存储最新的记录
sn = machine.get('SN')
# 更新字典中的记录，始终保留最新的记录
latest_machines[sn] = machine
else:
ws_message_send_queue.put(item)
# 将字典中的值转换成一个列表
combined_machines = list(latest_machines.values())
if len(combined_machines) > 0:
combine_json_data = {"status": "success", "command": "machine_data_change", "data":
{'status': 'success', 'machines': combined_machines}}
ws_message_send_queue.put(combine_json_data)
# 如果队列中有消息，则获取消息
if not ws_message_send_queue.empty():
message = ws_message_send_queue.get()
# 将消息发送给所有已连接的客户端
disconnected_clients = []
# print("ws send",len(websocket_connected_clients)) # cyx
for ws in websocket_connected_clients:
try:
await ws.send(json.dumps(message))
except websockets.exceptions.ConnectionClosed:
disconnected_clients.append(ws)
# 移除断开的客户端
if disconnected_clients:
for ws in disconnected_clients:
try:
websocket_connected_clients.discard(ws)
print(f"websocket client disconnected {len(websocket_connected_clients)}")
finally:
pass
if dtMachineService:
all_machines_sn = dtMachineService.get_all_machine_sn()
all_machines_data = dtMachineService.get_machines_value(all_machines_sn)
await asyncio.sleep(0.1) # 防止占用过高 CPU
async def websocket_server_handle(ws, path):
print(f"websocket client connected {path} ")
try:
websocket_connected_clients.add(ws)
finally:
pass
async for message in ws:
# print("ws", message)
try:
msg_json = json.loads(message)
if msg_json:
# print("ws",msg_json)
if "command" in msg_json and msg_json["command"] == "get_machines_data" and \
"data" in msg_json:
result = handle_get_machines_value(msg_json['data'])
result['command'] = 'get_machines_data'
# print(result)
# 将字典转换为 JSON 字符串
await ws.send(json.dumps(result))
except websockets.exceptions.ConnectionClosed:
# 连接关闭时从集合中移除
try:
websocket_connected_clients.remove(ws)
finally:
pass
# print(f'Unexpected error: {e}')
# await websocket.send(json.dumps({"message": "Received your message: " + data['message']}))
def run_websockets():
global webSocket_server
loop = asyncio.new_event_loop()
asyncio.set_event_loop(loop)
webSocket_server = websockets.serve(websocket_server_handle, 'localhost', 5080)
loop.run_until_complete(webSocket_server)
# 在事件循环中启动消息分发器
loop.create_task(ws_message_send_dispatcher())
try:
loop.run_forever()
except KeyboardInterrupt:
print("Caught keyboard interrupt. stop web sockets server")
webSocket_server.close()
loop.run_until_complete(webSocket_server.wait_closed())
def stop_flask_server():
requests.post('http://127.0.0.1:5050/shutdown') # 将端口号改为你的 Flask 服务器的端口号
@eel.expose
def close_window():
print("Eel window closed via JavaScript.")
exit_program() # This will shut down the servers and exit the program
def on_webveiw_closed():
print("webview window closed via JavaScript.")
exit_program() # This will shut down the servers and exit the program
def run_eel():
eel.init('web') # 告诉 Eel 查找 'web' 文件夹
eel.start('dtm_entry.html', size=(3000, 2000), position=(0, 0),
suppress_error=True)
class H5Api:
# def close_window(self):
# print("Eel window closed via JavaScript.")
# exit_program() # This will shut down the servers and exit the program
pass
# 定义 Flask-SocketIO 运行函数
def run_flask_socketio():
# socketio.run(app, host='0.0.0.0', port=5080)
pass
def exit_program(sig=None, frame=None):
global main_exit_flag, flask_stop_event, modbus_server_obj, webview_thread, socketio_thread, flask_server_thread
global webSocket_server, insert_result_thread, dtMachineService
# 显示关闭提示窗口（在开始清理资源之前）
closing_window = None
try:
ui_path = os.path.join(os.path.dirname(os.path.abspath(__file__)), 'UI')
if ui_path not in sys.path:
sys.path.insert(0, ui_path)
from ui_utils.splash_window import ClosingWindow
closing_window = ClosingWindow(title="系统关闭中", message="跌落试验管理系统正在关闭，请稍候...")
closing_window.show()
except Exception as e:
print(f"显示关闭提示窗口失败: {e}")
print("="*60)
print("Received SIGINT or window close, exiting...")
print("="*60)
main_exit_flag = True
try:
# 0. 停止 dtMachineService 中的 PLC 设备轮询线程
print("0. 停止 PLC 设备轮询线程...")
if dtMachineService and hasattr(dtMachineService, 'dtMachineStationData'):
# 停止所有机器中的 PLC 设备轮询线程
for machine in dtMachineService.dtMachineStationData:
virt_plc_device = machine.get('virt_plc_device')
if virt_plc_device:
# 如果 PLC 设备有 plc_client 属性，则调用其 stop_polling
if hasattr(virt_plc_device, 'plc_client') and virt_plc_device.plc_client:
if hasattr(virt_plc_device.plc_client, 'stop_polling'):
try:
virt_plc_device.plc_client.stop_polling()
print(f" 已停止 PLC 设备 {machine.get('SN', 'unknown')} 的轮询线程")
except Exception as e:
print(f" 停止 PLC 设备 {machine.get('SN', 'unknown')} 轮询失败: {e}")
print(" PLC 设备轮询线程已停止")
# 等待一下确保线程完全停止
time.sleep(2)
print(" 等待 PLC 线程完全停止...")
except Exception as error:
print(f" 停止 PLC 设备轮询失败: {error}")
try:
# 1. 停止 Flask 服务器
print("1. 停止 Flask 服务器...")
stop_flask_server()
if flask_server_thread and flask_server_thread.is_alive():
flask_server_thread.join(timeout=2)
print(" Flask 服务器已停止")
except Exception as error:
print(f" 停止 Flask 服务器失败: {error}")
try:
# 2. 停止 WebSocket 服务器
print("2. 停止 WebSocket 服务器...")
if webSocket_server:
try:
# websockets.serve 返回的是一个 Server 对象，使用 close() 方法
if hasattr(webSocket_server, 'close'):
webSocket_server.close()
elif hasattr(webSocket_server, 'ws_server'):
# 如果是包装器对象
webSocket_server.ws_server.close()
except Exception as e:
# WebSocket 服务器可能已经关闭，忽略错误
print(f" WebSocket 关闭日志: {e}")
if socketio_thread and socketio_thread.is_alive():
socketio_thread.join(timeout=2)
print(" WebSocket 服务器已停止")
except Exception as error:
print(f" 停止 WebSocket 服务器失败: {error}")
try:
# 3. 停止 Modbus 服务器及其 PLC 设备
print("3. 停止 Modbus 服务器...")
if modbus_server_obj:
# 停止 Modbus 服务器中的 PLC 设备轮询
if hasattr(modbus_server_obj, 'plc_devices'):
for device_info in modbus_server_obj.plc_devices:
device = device_info.get('device')
if device and hasattr(device, 'stop_polling'):
try:
device.stop_polling()
print(f" 已停止 Modbus Server PLC 设备 {device_info.get('com', 'unknown')} 的轮询")
except Exception as e:
print(f" 停止 Modbus Server PLC 设备轮询失败: {e}")
# 终止 Modbus 服务器进程
modbus_server_obj.terminate()
modbus_server_obj.join(timeout=3)
print(" Modbus 服务器已停止")
except Exception as error:
print(f" 停止 Modbus 服务器失败: {error}")
try:
# 4. 停止数据插入线程
print("4. 停止数据插入线程...")
if insert_result_thread and insert_result_thread.is_alive():
insert_result_thread.join(timeout=2)
print(" 数据插入线程已停止")
except Exception as error:
print(f" 停止数据插入线程失败: {error}")
try:
# 5. 清理 dtMachineService
print("5. 清理 dtMachineService...")
if dtMachineService:
# 如果有清理方法，调用它
if hasattr(dtMachineService, 'cleanup'):
dtMachineService.cleanup()
print(" dtMachineService 已清理")
except Exception as error:
print(f" 清理 dtMachineService 失败: {error}")
print("="*60)
print("所有服务已停止，程序退出")
print("="*60)
# 关闭提示窗口
if closing_window:
try:
closing_window.close()
except Exception as e:
print(f"关闭提示窗口失败: {e}")
# 强制退出
os._exit(0)
def modbus_client_test():
# 创建 Modbus 客户端实例
client = ModbusTcpClient('127.0.0.1', port=5020)
# 连接到 Modbus 服务器
connection = client.connect()
if connection:
print("Modbus client connected successfully")
# 在这里执行你的 Modbus 请求
# 例如，读取线圈状态
response = client.read_coils(13, 5)
if response.isError():
print("Modbus request failed:", response)
else:
print("Coil states:", response.bits)
response = client.read_holding_registers(185, 2, 1)
if response.isError():
print("Modbus request failed:", response)
else:
print("Holding Registers is :", response.registers)
response = client.write_registers(78, [81, 88, 89, 100])
if response.isError():
print("Modbus request failed:", response)
else:
print("write Registers is :", response.isError())
else:
print("Modbus client connection failed")
# 关闭 Modbus 客户端连接
client.close()
"""
post_json = {"requestId": generate_request_id(), "module": "dz_drop", "buckSn": data.get("SN"),
"deviceCode": data.get("dtMachine"), "operatorId": data.get("tester"),
"time": datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S")}
item_json = {"project": data.get("project"), "phase": data.get("phase"),
"channel": data.get("station"),
"startTime": data.get("startTime"), "endTime": data.get("endTime"),
"orientation": data.get("dropItem"), "direction": data.get("dropDirection"),
"cycles": data.get("dropCycles"), "cyclesTotal": data.get("cyclesTotal"),
"height": data.get("dropHeight"),
"config": data.get("description")}
"""
def create_lims_mock():
lims_mock = {}
lims_mock['SN'] = "202407229087"
lims_mock['dtMachine'] = "DTM-STA-00003"
lims_mock['tester'] = "65432"
lims_mock['project'] = "DTM-PRJ-00006"
lims_mock['station'] = "01"
lims_mock['phase'] = "D Sample TEST"
lims_mock['startTime'] = "2024-06-14 23:15:46"
lims_mock['endTime'] = "2024-07-13 15:55:45"
lims_mock['dropItem'] = "正面"
lims_mock['dropDirection'] = 0
lims_mock['dropCycles'] = 800
lims_mock['cyclesTotal'] = 2356
lims_mock['dropHeight'] = 5673
lims_mock['dropDirection'] = ""
return lims_mock
def main(args):
global initialized, modbus_server_obj, webview_thread, socketio_thread, flask_server_thread, main_exit_flag
global flask_stop_event, dtMachineService, insert_result_thread
# 先显示启动提示窗口（如果需要UI）
splash = None
if not args.no_ui:
# 立即显示启动提示窗口
ui_path = os.path.join(os.path.dirname(os.path.abspath(__file__)), 'UI')
if ui_path not in sys.path:
sys.path.insert(0, ui_path)
from ui_utils.splash_window import SplashWindow
splash = SplashWindow(title="系统启动中", message="跌落试验管理系统正在加载，请稍候...")
splash.show()
print_with_timestamp("启动提示窗口已显示")
# 设置 MOCK_MODE（必须在导入 dtMachineService 之前）
if hasattr(args, 'mock') and args.mock:
import modbus_plc
modbus_plc.MOCK_MODE = True
print_with_timestamp("启用 PLC 模拟模式", color='yellow')
else:
print_with_timestamp("使用真实 PLC 设备", color='green')
# 在设置 MOCK_MODE 之后导入 dtMachineService
global machineService
import dtMachineService as machineService
comm_config = {
"baudrate": 9600,
"stopbits": serial.STOPBITS_ONE,
"parity": serial.PARITY_EVEN,
"bytesize": serial.SEVENBITS
}
drop_register = {
'01': {"height": 'D0160', "cycles": "D0200", "cyclesFinished": "D0202", "start": 'M0016', "stop": "M0008"},
'02': {"height": 'D0162', "cycles": "D0204", "cyclesFinished": "D0206", "start": 'M0017', "stop": "M0018"}
}
signal.signal(signal.SIGINT, exit_program) # 设置SIGINT（Ctrl + C）信号处理器
print_with_timestamp("init dtMachineService")
dtMachineService = machineService.DtmMachineService(args.modbusServer, args.modbusServerPort, access_table_data,
app, dutDirectionMode, cb_station_result_change,
cb_machine_data_change, cb_insert_result)
initialized = True
set_machine_service(dtMachineService)
if args.startModbusServer:
# 创建并启动Modbus Server的线程
machines_config = dtMachineService.get_machine_com_config()
print_with_timestamp(f"main start modbus server ") # cyx
# 创建 ModbusServer 实例
# 创建同步事件
modbus_ready_event = Event()
modbus_server_obj = ModbusServer(host=args.modbusServer, port=args.modbusServerPort,
machines_config=machines_config, mock_mode=args.mock)
# 启动 ModbusServer 进程
modbus_server_obj.start()
# 等待 ModbusServer 完全启动
wait_result = modbus_ready_event.wait(timeout=4)
print_with_timestamp(f"Modbus server started in a separate process. {wait_result}")
initialized = True
print_with_timestamp("modbus client connect to server") # cyx
dtMachineService.dtm_virt_machine_client_connect()
# if not wait_result: print_with_timestamp(f"等待MODBUS SERVER 启动超时", color= 'red')
# 创建并启动Flask的线程
print_with_timestamp("begin init flask server")
flask_stop_event = threading.Event()
flask_server_thread = threading.Thread(target=run_flask_server, args=(flask_stop_event,))
flask_server_thread.daemon = True
flask_server_thread.start()
print_with_timestamp("init flask server over")
# 创建线程并启动
socketio_thread = threading.Thread(target=run_websockets)
socketio_thread.daemon = True
socketio_thread.start()
# 启动写入从PLC得到测试结果的thread
insert_result_thread = threading.Thread(target=run_insert_result)
insert_result_thread.daemon = True
insert_result_thread.start()
# 启动PyQt5前端界面
if not args.no_ui:
print_with_timestamp("开始启动PyQt5 UI...")
print_with_timestamp("正在启动界面，请稍候......")
# 设置API地址（在导入UI模块之前）
ui_path = os.path.join(os.path.dirname(os.path.abspath(__file__)), 'UI')
if ui_path not in sys.path:
sys.path.insert(0, ui_path)
import config as ui_config
ui_config.HTTP_API_BASE_URL = f"http://127.0.0.1:{args.port or 5050}"
ui_config.WEBSOCKET_URL = f"ws://127.0.0.1:5080"
# 导入 UI 模块
from dtmgtUI import main as ui_main, set_on_exit_callback
# 关闭启动提示窗口（在主界面启动前关闭）
if splash:
splash.close()
print_with_timestamp("启动提示窗口已关闭")
# 等待tkinter窗口完全关闭
time.sleep(0.3)
# 设置退出回调函数（保持原有逻辑）
def on_ui_exit():
print_with_timestamp("UI 窗口关闭，开始退出程序...")
# 直接调用 exit_program，不使用额外的线程或提示窗口
exit_program()
set_on_exit_callback(on_ui_exit)
# 启动 UI（这会阻塞直到窗口关闭）
print_with_timestamp("UI 启动中...")
exit_code = ui_main()
print_with_timestamp(f"UI 退出，退出码: {exit_code}")
# 检查退出码
if exit_code == -1:
# 用户取消登录或登录失败，exit_program 已经在 on_ui_exit 中被调用
print_with_timestamp("用户取消登录，程序已退出")
else:
# 正常关闭 UI 窗口，退出程序
exit_program()
else:
# 如果不启动UI，则保持后台运行
while not main_exit_flag:
if flask_server_thread:
flask_server_thread.join(1)
elif socketio_thread:
socketio_thread.join(1)
else:
pass
class startArgs:
def __init__(self, startModbusServer=False, modbusServer="127.0.0.1", modbusServerPort=5020):
self.startModbusServer = startModbusServer
self.modbusServer = modbusServer
self.modbusServerPort = modbusServerPort
def check_simulator_api_availability():
"""
检测FastAPI API服务是否可用
"""
url = "http://127.0.0.1:8088/gateway/api/rel/upload/getconnect"
try:
# 发送GET请求
response = requests.get(url, timeout=5)
# 检查响应状态码
if response.status_code == 200:
# 检查响应内容
data = response.json()
if data.get("status") == "ok" and "LMIS 模拟接收数据服务已运行" in data.get("message", ""):
print("✅ API服务正常运行")
print(f"响应内容: {data}")
return True
else:
print("⚠️ API服务响应内容不符合预期")
print(f"响应内容: {data}")
return False
else:
print(f"❌ API服务返回异常状态码: {response.status_code}")
return False
except requests.exceptions.ConnectionError:
print("❌ 无法连接到API服务 - 连接被拒绝")
print("请检查服务是否已启动，以及端口号是否正确")
return False
except requests.exceptions.Timeout:
print("❌ 连接API服务超时")
return False
except requests.exceptions.RequestException as e:
print(f"❌ 请求异常: {e}")
return False
if __name__ == "__main__":
multiprocessing.freeze_support() # 添加 freeze_support 以支持 Windows 的多进程
# 解析参数（需要先解析以获取 --debug-console 参数）
parser = argparse.ArgumentParser(description="DTM 跌落试验管理系统")
parser.add_argument('--startModbusServer', default=True, help="启动 Modbus Server", action='store_true')
parser.add_argument('--modbusServer', default="127.0.0.1", help="Modbus Server 地址")
parser.add_argument('--modbusServerPort', default=5020, help="Modbus Server 端口")
parser.add_argument('--no-ui', action='store_true', help="不启动PyQt5前端界面")
parser.add_argument('--port', type=int, default=5050, help="HTTP服务端口")
parser.add_argument('--mock', action='store_true', help="启用 PLC 模拟模式")
parser.add_argument('--check-simulator', action='store_true', help="检查 LMIS 模拟器 API 可用性")
parser.add_argument('--debug-console', action='store_true', help="打包后仍然显示控制台窗口（调试用）")
args = parser.parse_args()
# 检测是否是打包后的可执行文件（没有console窗口）
# 如果是PyInstaller打包的程序，且没有 --debug-console 参数，则重定向stdout/stderr到日志文件
if getattr(sys, 'frozen', False) and not args.debug_console:
# 运行在打包后的可执行文件中，且未指定 debug-console
log_dir = os.path.join(os.path.dirname(sys.executable), 'logs')
if not os.path.exists(log_dir):
os.makedirs(log_dir)
log_file = os.path.join(log_dir, f'dtmgt_{datetime.datetime.now().strftime("%Y%m%d_%H%M%S")}.log')
# 重定向stdout和stderr到日志文件
sys.stdout = open(log_file, 'w', encoding='utf-8', buffering=1)
sys.stderr = sys.stdout
print(f"=== DTM试验管理系统启动 (日志文件: {log_file}) ===")
else:
# 开发模式或调试模式，直接输出到控制台
if getattr(sys, 'frozen', False):
print("=== DTM试验管理系统启动 (调试模式 - 控制台输出) ===")
else:
print("=== DTM试验管理系统启动 (开发模式) ===")
# 检查是否是 multiprocessing 子进程
# 检查模拟器 API 可用性（仅在指定 --check-simulator 时）
if hasattr(args, 'check_simulator') and args.check_simulator and check_simulator_api_availability():
UPLOAD_LIMS_URL = "http://127.0.0.1:8088/gateway/api/rel/upload/commonUploadData"
if any(arg.startswith("--multiprocessing-fork") for arg in sys.argv):
# 如果是子进程，直接调用主逻辑，跳过 argparse
pass
else:
# 如果是主进程，正常调用主逻辑
main(args)
Reference in New Issue Copy Permalink