add(更新opcua客户端、振捣频率按钮、管片任务数据刷新)

service/opcua_ui_client.py

@@ -1,185 +1,266 @@
 #!/usr/bin/env python3
-from PySide6.QtCore import QObject, Signal
+from PySide6.QtCore import QObject, Signal, QThread
 from opcua import Client, ua
 import time
 from datetime import datetime
+import configparser
 
 class OpcuaUiSignal(QObject):
-    # 定义值变化信号：参数为(node_id, var_name, new_value)
     value_changed = Signal(str, str, object)
+    opc_disconnected = Signal(str)    # OPC服务断开信号，参数：断开原因
+    opc_reconnected = Signal()        # OPC重连成功信号
+    opc_log = Signal(str)             # OPC运行日志信号，参数：日志信息
 
 # Opcua回调处理器
 class SubscriptionHandler:
     def __init__(self, opc_signal:OpcuaUiSignal):
-        # 初始化nodeid→变量名映射表
         self.node_id_to_name = {}
         self.opc_signal = opc_signal
 
     def datachange_notification(self, node, val, data):
-        """
-        python-opcua标准的回调函数
-        :param node: 变化的节点对象
-        :param val: 节点新值
-        :param data: 附加数据（包含时间戳等）
-        """
         try:
-            # 1. 解析时间戳
-            # time_str = datetime.now().strftime('%Y-%m-%d %H:%M:%S')
-            # try:
-            #     utc_time = data.monitored_item.Value.SourceTimestamp
-            #     beijing_time = utc_time + datetime.timedelta(hours=8)
-            #     time_str = beijing_time.strftime('%Y-%m-%d %H:%M:%S')
-            # except:
-            #     pass
-
-            # 2. 获取nodeid并解析变量名
             node_id = node.nodeid.to_string()
-            # 从映射表获取可读变量名
             var_name = self.node_id_to_name.get(node_id)
-
-            # 3. 打印变化通知
-            # print(f"\n 节点值发生变化！")
-            # print(f"   节点ID: {node_id}")
-            # print(f"   变量名称: {var_name}")
-            # print(f"   时间: {time_str}")
-            # print(f"   新值: {val}")
-
             self.opc_signal.value_changed.emit(node_id, var_name, val)
-           
         except Exception as e:
-            print(f"解析值变化事件失败: {e}")
-            import traceback
-            traceback.print_exc()
+            err_msg = f"opcua解析值变化事件失败: {e}"
+            self.opc_signal.opc_log.emit(err_msg)
 
-class OpcuaUiClient:
-    def __init__(self, server_url="opc.tcp://localhost:4840/zjsh_feed/server/"):
-        """初始化 OPC UA 客户端"""
-        self.client = Client(server_url)
+class OpcuaUiClient(QThread):
+    def __init__(self, parent=None):
+        super().__init__(parent)
+        self.server_url = ""
+        self.client = None
 
         self.connected = False
         self.subscription = None
         self.monitored_items = []
+        self.is_running = True  # 线程运行标志位
+        self.node_id_mapping = {} # node_id 和 可读变量名的映射表
+        self.is_reconnect_tip_sent = False  # 重连失败提示是否已发送
 
-        # 创建Qt信号对象（用于跨线程传递数据）
         self.opc_signal = OpcuaUiSignal()
-        self.handler = SubscriptionHandler(self.opc_signal)  # 回调处理器
-        # 定义需要监控的变量路径（object_name + var_name）
-        # 格式：(变量可读名称, [object路径, 变量路径])
-        self.target_var_paths = [
-            ("upper_weight", ["2:upper", "2:upper_weight"]),
-            ("lower_weight", ["2:lower", "2:lower_weight"])
-        ]
-        self.node_id_mapping = {}  # 存储nodeid→变量名的映射表
+        self.handler = SubscriptionHandler(self.opc_signal)
+        
+        self.target_var_paths = []
+        
+        # 参数
+        self.heartbeat_interval = None  # 心跳检测间隔 
+        self.reconnect_interval = None  # 首次/掉线重连间隔 
+        self.sub_interval = None        # 订阅间隔 (单位:ms)
+
+
+    def stop_run(self):
+        """停止线程+断开连接"""
+        self.is_running = False
+        self.disconnect()
+        self.wait()
+        print("opcua客户端线程已退出")
 
     def connect(self):
-        """连接到服务器"""
+        """连接到OPC服务器"""
         try:
             self.client.connect()
             self.connected = True
-            print(f"成功连接到 OPC UA 服务器: {self.client.server_url}")
+            msg = f"成功连接到OPCUA服务器: {self.server_url}"
+            print(msg)
+            self.opc_signal.opc_log.emit(msg)
+            self.is_reconnect_tip_sent = False
             return True
         except Exception as e:
-            print(f"连接服务器失败: {e}")
+            self.connected = False
+            err_msg = f"连接OPCUA服务器失败: {e}"
+            print(err_msg)
+            if not self.is_reconnect_tip_sent:
+                self.opc_signal.opc_log.emit(err_msg)
+                # 标记为已发送，后续不重复在UI上显示
+                self.is_reconnect_tip_sent = True 
             return False
 
     def disconnect(self):
-        """断开连接（包含取消订阅）"""
-        if self.subscription:
-            try:
-                self.subscription.delete()
-                print("已取消节点订阅")
-            except:
-                pass
-        if self.connected:
-            self.client.disconnect()
-            self.connected = False
-            print("已断开与 OPC UA 服务器的连接")
+        """断开连接"""
+        self.connected = False
+        try:  
+            if self.monitored_items:
+                for item in self.monitored_items:
+                    try:
+                        self.subscription.unsubscribe(item)
+                    except Exception: 
+                        pass
+                self.monitored_items.clear()
+            if self.subscription:
+                try:
+                    self.subscription.delete()
+                except Exception:
+                    pass
+                self.subscription = None
+            if self.client:
+                try:
+                    self.client.disconnect()
+                except Exception:
+                    pass
+            self.node_id_mapping.clear()
+            if hasattr(self, 'handler') and self.handler: 
+                self.handler.node_id_to_name = {}
+        except Exception as e:
+            print(f"opcua断开连接异常: {e}")
 
     def build_node_id_mapping(self):
-        """
-        根据object_name+var_name路径获取nodeid,建立映射表
-        """
+        """根据object_name+var_name路径获取nodeid,建立映射表"""
         if not self.connected:
-            print("请先连接到服务器")
             return False
-        
         try:
-            print("\n 开始构建nodeid映射表...")
-            objects_node = self.client.get_objects_node()  # 获取根Objects节点
-
-            for var_name, path_list in self.target_var_paths:
-                # 根据层级路径找到目标节点
-                target_node = objects_node.get_child(path_list)
-                # 提取nodeid字符串
-                node_id = target_node.nodeid.to_string()
-                # 存入映射表
-                self.node_id_mapping[node_id] = var_name
-                print(f"映射成功: {node_id} → {var_name}")
-            
-            # 将映射表传给回调处理器
+            # self.opc_signal.opc_log.emit("开始构建nodeid映射表...")
+            objects_node = self.client.get_objects_node()
             self.handler.node_id_to_name = self.node_id_mapping
+            for var_name, path_list in self.target_var_paths:
+                target_node = objects_node.get_child(path_list)
+                node_id = target_node.nodeid.to_string()
+                self.node_id_mapping[node_id] = var_name
+            # self.opc_signal.opc_log.emit("nodeid映射表构建成功")
             return True
         except Exception as e:
-            print(f"构建映射表失败: {e}")
-            import traceback
-            traceback.print_exc()
+            err_msg = f"构建{var_name}映射表失败: {e}"
+            print(err_msg)
+            self.opc_signal.opc_log.emit(err_msg)
             return False
 
-    def create_multi_subscription(self, interval=500):
+    def create_multi_subscription(self, interval=None):
         """订阅多个变量(基于映射表的nodeid)"""
         if not self.connected:
-            print("请先连接到服务器")
             return
-        
-        # 先构建映射表，失败则直接返回
-        if not self.node_id_mapping:
-            if not self.build_node_id_mapping():
-                return
-        
+        if not self.node_id_mapping and not self.build_node_id_mapping():
+            return
         try:
-            interval = int(interval)
-            # 1. 创建订阅
+            interval = int(interval) if interval else self.sub_interval
             self.subscription = self.client.create_subscription(interval, self.handler)
-            print(f"\n订阅创建成功(间隔：{interval}ms)")
-
-            # 2. 遍历映射表，为每个nodeid创建监控项
+            self.opc_signal.opc_log.emit(f"opcua订阅创建成功(间隔：{interval}ms)")
             for node_id, var_name in self.node_id_mapping.items():
                 var_node = self.client.get_node(node_id)
                 monitored_item = self.subscription.subscribe_data_change(var_node)
                 self.monitored_items.append(monitored_item)
+                # self.opc_signal.opc_log.emit(f"已订阅变量: {var_name} (nodeid: {node_id})")
                 print(f"已订阅变量: {var_name} (nodeid: {node_id})")
-
         except Exception as e:
-            print(f"创建批量订阅失败: {e}")
-            import traceback
-            traceback.print_exc()
+            err_msg = f"创建批量订阅失败: {e}"
+            print(err_msg)
+            self.opc_signal.opc_log.emit(err_msg)
+
+    def read_opc_config(self, cfg_path = "config/opc_config.ini"):
+        """读取OPC配置文件, 初始化所有参数和节点列表"""
+        try:
+            cfg = configparser.ConfigParser()
+            cfg.read(cfg_path, encoding="utf-8")
+            # 1. 读取服务器基础配置
+            self.server_url = cfg.get("OPC_SERVER_CONFIG", "server_url")
+            self.heartbeat_interval = cfg.getint("OPC_SERVER_CONFIG", "heartbeat_interval")
+            self.reconnect_interval = cfg.getint("OPC_SERVER_CONFIG", "reconnect_interval")
+            self.sub_interval = cfg.getint("OPC_SERVER_CONFIG", "sub_interval")
+            
+            # 2. 读取OPC节点配置
+            node_section = cfg["OPC_NODE_LIST"]
+            for readable_name, node_path_str in node_section.items():
+                node_path_list = node_path_str.split(",")
+                self.target_var_paths.append( (readable_name, node_path_list) )
+            # print("target_var_paths", self.target_var_paths)
+        except Exception as e:
+            print(f"读取配置文件失败: {e}，使用默认配置启动！")
+            self.server_url = "opc.tcp://localhost:4840/zjsh_feed/server/"
+            self.heartbeat_interval = 4
+            self.reconnect_interval = 2
+            self.sub_interval = 500
+            self.target_var_paths = [
+                ("upper_weight", ["2:upper", "2:upper_weight"]),
+                ("lower_weight", ["2:lower", "2:lower_weight"])
+            ]
+        # 参数合法性检验
+        self.heartbeat_interval = self.heartbeat_interval if isinstance(self.heartbeat_interval, int) and self.heartbeat_interval >=1 else 4
+        self.reconnect_interval = self.reconnect_interval if isinstance(self.reconnect_interval, int) and self.reconnect_interval >=1 else 2
+        self.sub_interval = self.sub_interval if isinstance(self.sub_interval, int) and self.sub_interval >=100 else 500
 
     def write_value_by_name(self, var_readable_name, value):
-        """
-        根据变量可读名称写入值(主要用于修改方量， 类型为 Double类型)
-        :param var_readable_name: 变量可读名称（如"upper_weight"）
+        """ 
+        根据变量可读名称写入值(主要用于修改方量， 方量的类型为 Double类型)
+        :param var_readable_name: 变量可读名称（如"upper_weight")
         :param value: 要写入的值
         """
         if not self.connected:
-            print("请先连接到服务器")
+            self.opc_signal.opc_log.emit(f"{var_readable_name}写入失败: OPC服务未连接")
             return
-        
-        # 反向查找：通过变量名找nodeid
         target_node_id = None
         for node_id, name in self.node_id_mapping.items():
             if name == var_readable_name:
                 target_node_id = node_id
                 break
-        
         if not target_node_id:
-            print(f"未找到变量名 {var_readable_name} 对应的nodeid")
+            # self.opc_signal.opc_log.emit(f"写入失败：未找到变量名 {var_readable_name} 对应的nodeid")
             return
-        
         try:
             target_node = self.client.get_node(target_node_id)
-            # 明确指定值类型为Double，避免类型错误
-            variant = ua.Variant(float(value), ua.VariantType.Double)
-            target_node.set_value(variant)
+            # variant = ua.Variant(float(value), ua.VariantType.Double)
+            target_node.set_value(value)
+            # self.opc_signal.opc_log.emit(f"写入成功：{var_readable_name} = {value}")
         except Exception as e:
-            print(f"写入值失败: {e}")
+            err_msg = f"opcua写入值失败: {e}"
+            print(err_msg)
+            self.opc_signal.opc_log.emit(err_msg)
 
+    # ===== 心跳检测函数 =====
+    def _heartbeat_check(self):
+        """心跳检测: 判断opc服务是否存活"""
+        try:
+            self.client.get_node("i=2258").get_value()
+            return True
+        except Exception as e:
+            err_msg = f"心跳检测失败, OPCUA服务已断开 {e}"
+            print(err_msg)
+            self.opc_signal.opc_log.emit(err_msg)
+            return False
+
+    # ===== 掉线重连函数 =====
+    def _auto_reconnect(self):
+        """掉线后自动重连+重建映射+恢复订阅"""
+        self.opc_signal.opc_disconnected.emit("OPC服务掉线, 开始自动重连...")
+        try:
+            self.disconnect()
+        except Exception as e:
+            print(f"_auto_reconnect: 断开旧连接时出现异常: {e}")
+        while self.is_running:
+            # self.opc_signal.opc_log.emit(f"重试连接OPC服务器: {self.server_url}")
+            if self.connect():
+                self.build_node_id_mapping()
+                self.create_multi_subscription()
+                self.opc_signal.opc_reconnected.emit()
+                self.opc_signal.opc_log.emit("OPCUA服务器重连成功, 所有订阅已恢复正常")
+                print("OPCUA服务器重连成功, 所有订阅已恢复正常")
+                break
+            time.sleep(self.reconnect_interval)
+
+    def _init_connect_with_retry(self):
+        """连接opc服务器"""
+        # self.opc_signal.opc_log.emit("OPC客户端初始化, 开始连接服务器...")
+        print("OPC客户端初始化, 开始连接服务器...")
+        while self.is_running:
+            if self.connect():
+                self.build_node_id_mapping()
+                self.create_multi_subscription()
+                break
+            # self.opc_signal.opc_log.emit(f"连接OPCUA服务器失败, {self.reconnect_interval}秒后重试...")
+            time.sleep(self.reconnect_interval)
+
+    def run(self) -> None:
+        """opcua客户端线程主函数"""
+        self.read_opc_config() # 读取配置文件
+        self.client = Client(self.server_url) # 初始化opc客户端
+
+        # 连接opc服务器
+        self._init_connect_with_retry()
+        
+        while self.is_running:
+            if self.connected:
+                if not self._heartbeat_check():
+                    self.connected = False
+                    self._auto_reconnect()
+            else:
+                self._auto_reconnect()
+            time.sleep(self.heartbeat_interval)