Feeding_control_system/opc/opcua_client_feed.py

#!/usr/bin/env python3
from opcua import Client, ua
import time
from datetime import datetime
import configparser
from threading import Thread,RLock
import logging
import queue
 
logging.getLogger("opcua").setLevel(logging.WARNING)
logging.getLogger("opcua.client.ua_client").setLevel(logging.WARNING)
logging.getLogger("opcua.uaprotocol").setLevel(logging.WARNING)
#控制程序opcua 需要需要在opc_config中配置_f结尾的key才会收到通知 
# Opcua回调处理器
class SubscriptionHandler:
    def __init__(self,parent):
        self.node_id_to_name = {}
        #设置派单模式(1自动派单 2手动派单0未知)
        # self.pd_set_mode=0
        # #设置方量{ID:派单表ID，Volumn:修改后方量}
        # self.pd_set_volumn=''
        # #派单通知数据{ErpID:ID:派单表ID,Flag:状态，ErrorMsg:失败异常信息	}
        # self.pd_notify=''
        # 添加队列和锁
        self.notification_queue = queue.Queue()
        self.processing_thread = Thread(target=self._process_notifications, daemon=True,name="opcua_recv_thread")
        self.lock = RLock()  # 可重入锁
        self.parent=parent
        self.notify_callback=self.parent.notify_callback

    def start_accept(self):
        self.processing_thread.start()

    def datachange_notification(self, node, val, data):
        try:
            node_id = node.nodeid.to_string()
            var_name = self.node_id_to_name.get(node_id)
            print(f"node_id: {node_id}, var_name: {var_name}, val: {val}")
            self.notification_queue.put_nowait((var_name, val))
            # setattr(self, var_name, val)
            # if self.notify_callback:
            #     self.notify_callback(var_name,val)
        except Exception as e:
            err_msg = f"opcua解析值变化事件失败: {e}"
            print(err_msg)

    def _process_notifications(self):
        """后台线程处理通知（串行执行）"""
        while self.parent.is_running:
            try:
                var_name, val = self.notification_queue.get(timeout=1)            
                # 使用锁保护共享资源
                with self.lock:
                     self.notify_callback(var_name,val)              
                self.notification_queue.task_done()
            except queue.Empty:
                continue
            except Exception as e:
                print(f"处理通知失败: {e}")
     

class OpcuaClientFeed(Thread):
    def __init__(self,notify_callback=None, parent=None):
        super().__init__(parent)
        
        self.name="opcua_feed_client"
        self.target_var_paths = []
           #订阅配置文件中的参数
        self.subscription_name=["pd_notify","pd_notify_finish","pd_set_mode","pd_set_volume"]
        # self.server_url = ""
        self.read_opc_config() # 读取配置文件

        self.client = Client(self.server_url) # 初始化opc客户端
        self.notify_callback=notify_callback
        
        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  # 重连失败提示是否已发送
        self.handler = SubscriptionHandler(self)

    def start_accept(self):
        self.handler.start_accept()

    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
            msg = f"成功连接到OPCUA服务器: {self.server_url}"
            print(msg)
            self.is_reconnect_tip_sent = False
            return True
        except Exception as e:
            self.connected = False
            err_msg = f"连接OPCUA服务器失败: {e}"
            print(err_msg)
            if not self.is_reconnect_tip_sent:
                print(err_msg)
                # 标记为已发送，后续不重复在UI上显示
                self.is_reconnect_tip_sent = True 
            return False

    def disconnect(self):
        """断开连接"""
        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,建立映射表"""
        if not self.connected:
            return False
        try:
            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
            print("nodeid映射表构建成功")
            return True
        except Exception as e:
            err_msg = f"构建{var_name}映射表失败: {e}"
            print(err_msg)
            return False

    def create_multi_subscription(self, interval=None):
        """订阅多个变量(基于映射表的nodeid)"""
        if not self.connected:
            return
        if not self.node_id_mapping:
            return
        try:
            interval = int(interval) if interval else self.sub_interval
            self.subscription = self.client.create_subscription(interval, self.handler)
            for node_id, var_name in self.node_id_mapping.items():     
                if var_name  in self.subscription_name:             
                    var_node = self.client.get_node(node_id)
                    monitored_item = self.subscription.subscribe_data_change(var_node)
                    self.monitored_items.append(monitored_item)
                    print(f"已订阅变量: {var_name} (nodeid: {node_id})")
        except Exception as e:
            err_msg = f"创建批量订阅失败: {e}"
            print(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.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")
        :param value: 要写入的值
        """
        max_wait = 30  # 最大等待30秒
        wait_count = 0
        while (not self.node_id_mapping and wait_count < max_wait):
            time.sleep(0.5)
            wait_count += 1
            if wait_count % 2 == 0:  # 每2秒打印一次
                print(f"等待OPC连接中...({wait_count/2}秒)")
        
        if not self.connected:
            print(f"{var_readable_name}写入失败: OPC服务未连接")
            return

        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:
            return
        try:
            target_node = self.client.get_node(target_node_id)
            target_node.set_value(value)
        except Exception as e:
            err_msg = f"opcua写入值失败: {e}"
            print(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)
            return False

    # ===== 掉线重连函数 =====
    def _auto_reconnect(self):
        """掉线后自动重连+重建映射+恢复订阅"""
        print("OPC服务掉线, 开始自动重连...")
        try:
            self.disconnect()
        except Exception as e:
            print(f"_auto_reconnect: 断开旧连接时出现异常: {e}")
        while self.is_running:
            print(f"重试连接OPC服务器: {self.server_url}")
            if self.connect():
                self.build_node_id_mapping()
                self.create_multi_subscription()
                print("OPCUA服务器重连成功, 所有订阅已恢复正常")
                break
            time.sleep(self.reconnect_interval)

    def _init_connect_with_retry(self):
        """连接opc服务器"""
        print("OPC客户端初始化, 开始连接服务器...")
        while self.is_running:
            if self.connect():
                self.build_node_id_mapping()
                self.create_multi_subscription()
                break
            print(f"连接OPCUA服务器失败, {self.reconnect_interval}秒后重试...")
            time.sleep(self.reconnect_interval)

    def run(self) -> None:
        """opcua客户端线程主函数"""
        # 连接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)


if __name__ == "__main__":
    opcua_client = OpcuaClientFeed()
    opcua_client.start()
    opcua_client.write_value_by_name("pd_set_mode", 1)
   
    while True:
        time.sleep(1)