def uasubscribe(): parser = argparse.ArgumentParser(description="Subscribe to a node and print results") add_common_args(parser) parser.add_argument("-t", "--eventtype", dest="eventtype", default="datachange", choices=['datachange', 'event'], help="Event type to subscribe to") args = parse_args(parser, requirenodeid=False) if args.eventtype == "datachange": _require_nodeid(parser, args) else: # FIXME: this is broken, someone may have written i=84 on purpose if args.nodeid == "i=84" and args.path == "": args.nodeid = "i=2253" client = Client(args.url, timeout=args.timeout) client.set_security_string(args.security) client.connect() try: node = get_node(client, args) handler = SubHandler() sub = client.create_subscription(500, handler) if args.eventtype == "datachange": sub.subscribe_data_change(node) else: sub.subscribe_events(node) embed() finally: client.disconnect() sys.exit(0) print(args)
class Plant(threading.Thread): def __init__(self, ip): super().__init__() self.client = Client(ip) self.objects = self.assign_object() self.heights = {'h1': 0, 'h2': 0, 'h3': 0, 'h4': 0} self.voltages = {'u1': 0, 'u2': 0} self._u = [0, 0] self.sample_time = 0.001 self.daemon = True ## Que termine de medir cuando termine el programa (debug) self.event_measure = threading.Event() def assign_object(self): self.client.connect() return self.client.get_objects_node() def get_valve_value(self): for i in range(1, 3): node = self.objects.get_child(['2:Proceso_Tanques', '2:Valvulas', f'2:Valvula{i}', '2:u']) self.voltages[f'u{i}'] = node.get_value() #NoneType object does not support item assig def get_heights(self): for i in range(1, 5): node = self.objects.get_child(['2:Proceso_Tanques', '2:Tanques', f'2:Tanque{i}', '2:h']) self.heights[f'h{i}'] = node.get_value() #NoneType object does not support item assig def suscribe_alarm(self): alarm = self.objects.get_child(['2:Proceso_Tanques', '2:Alarmas', f'2:Alarma_nivel']) handler = SubHandler() sub = self.client.create_subscription(500, handler) handle = sub.subscribe_events(alarm) time.sleep(0.1) def assign_valve_value(self): u1 = self.objects.get_child(['2:Proceso_Tanques', '2:Valvulas', f'2:Valvula1', '2:u']) u2 = self.objects.get_child(['2:Proceso_Tanques', '2:Valvulas', f'2:Valvula2', '2:u']) u1.set_value(self.u[0]) u2.set_value(self.u[1]) @property def u(self): return self._u @u.setter def u(self, value): if not None in value: self._u = list(value) else: self._u = self._u def run(self): self.suscribe_alarm() while True: if sum(self.u) > 0: self.assign_valve_value() self.u = [0, 0] self.event_measure.set() ## Revisar esto porque no se esta cumpliendo self.get_heights() time.sleep(self.sample_time)
def uasubscribe(): parser = argparse.ArgumentParser(description="Subscribe to a node and print results") add_common_args(parser) parser.add_argument("-t", "--eventtype", dest="eventtype", default="datachange", choices=['datachange', 'event'], help="Event type to subscribe to") args = parser.parse_args() if args.nodeid == "i=84" and args.path == "": parser.print_usage() print("uaread: error: The NodeId or BrowsePath of a variable is required") sys.exit(1) logging.basicConfig(format="%(levelname)s: %(message)s", level=getattr(logging, args.loglevel)) client = Client(args.url, timeout=args.timeout) client.connect() try: node = client.get_node(args.nodeid) if args.path: node = node.get_child(args.path.split(",")) handler = SubHandler() sub = client.create_subscription(500, handler) if args.eventtype == "datachange": sub.subscribe_data_change(node) else: sub.subscribe_events(node) embed() finally: client.disconnect() sys.exit(0) print(args)
def uasubscribe(): parser = argparse.ArgumentParser( description="Subscribe to a node and print results") add_common_args(parser) parser.add_argument("-t", "--eventtype", dest="eventtype", default="datachange", choices=['datachange', 'event'], help="Event type to subscribe to") args = parse_args(parser, requirenodeid=False) if args.eventtype == "datachange": _require_nodeid(parser, args) else: # FIXME: this is broken, someone may have written i=84 on purpose if args.nodeid == "i=84" and args.path == "": args.nodeid = "i=2253" client = Client(args.url, timeout=args.timeout) client.set_security_string(args.security) client.connect() try: node = get_node(client, args) handler = SubHandler() sub = client.create_subscription(500, handler) if args.eventtype == "datachange": sub.subscribe_data_change(node) else: sub.subscribe_events(node) embed() finally: client.disconnect() sys.exit(0) print(args)
def uasubscribe(): parser = argparse.ArgumentParser(description="Subscribe to a node and print results") add_common_args(parser) parser.add_argument("-t", "--eventtype", dest="eventtype", default="datachange", choices=['datachange', 'event'], help="Event type to subscribe to") args = parse_args(parser, requirenodeid=True) client = Client(args.url, timeout=args.timeout) client.connect() try: node = get_node(client, args) handler = SubHandler() sub = client.create_subscription(500, handler) if args.eventtype == "datachange": sub.subscribe_data_change(node) else: sub.subscribe_events(node) embed() finally: client.disconnect() sys.exit(0) print(args)
def main(): client = Client("opc.tcp://localhost:4840/freeopcua/server/") try: client.connect() # Client has a few methods to get proxy to UA nodes that should always be in address space such as Root or Objects root = client.get_root_node() print("Objects node is: ", root) print("Children of root are: ", root.get_children()) msclt = SubHandler() sub = client.create_subscription(100, msclt) ## subscribe to events myevent = root.get_child( ["0:Types", "0:EventTypes", "0:BaseEventType", "2:ThresholdEvent"]) print("MyFirstEventType is: ", myevent) handle = sub.subscribe_events(obj, myevent) myevent2 = root.get_child( ["0:Types", "0:EventTypes", "0:BaseEventType"]) print("MyFirstEventType is: ", myevent2) handle = sub.subscribe_events(obj, myevent2) while True: sleep(0.1) sub.unsubscribe(handle) sub.delete() finally: client.disconnect()
class OPCUAClient: """ 定义opcuaclient """ def __init__(self, url, username='', password=''): try: self.client = Client(url) # 初始化OPCUA客户端 if username != '' and password != '': # 初始化时如果提供用户名密码则配置 self.client.activate_session("username", "password") # 配置用户名密码 self.client.connect() except Exception as e: print("OPCUAClient INIT ERROR", e) def subscribeTag(self, stringNodeID): """ 通过StringNodeID订阅Tag """ tag = self.client.get_node(stringNodeID) # 获取需要读取的节点tag值 print('tag节点值:', tag) handler = SubHandler() subobj = self.client.create_subscription( 100, handler) # 返回一个订阅对象第一个参数为发布间隔(毫秒) handle = subobj.subscribe_data_change(tag) # 返回可用于退订的句柄 return subobj, handle, stringNodeID # 返回的三个参数可用于取消订阅 def unsubscribeTag(self, subobj, handle): """ 取消订阅 """ subobj.unsubscribe(handle) def getNodeValue(self, stringNodeID, type=1): """ 通过StringNodeID读取节点tag值 type = 1 获取值 type = 2 获取DataValue object """ tag = self.client.get_node(stringNodeID) return tag.get_value() def setNodeValue(self, stringNodeID, value): """ 通过StringNodeID设置节点tag值 """ tag = self.client.get_node(stringNodeID) tag.set_value(value) # 使用隐含变量类型设置节点值 def disconnect(self, client): """ 断开连接 """ return client.disconnect()
def plugin_start(handle): global loop, t _LOGGER.info("opcua_py plugin_start called") url = handle['url']['value'] userName = handle['userName']['value'] password = handle['password']['value'] _LOGGER.info('opcua_py: Attempting to connect to %s', url) client = Client(url=url) if userName: _LOGGER.info('opcua_py: Attempting to connect to OPC UA server with username and password.') client.set_user(userName) client.set_password(password) else: _LOGGER.info('opcua_py: Attempting to connect anonymously to OPC UA server.') client.connect() #Need to add some error checking on the connection subs = json.loads(handle['subscriptions']['value']) subs = subs["subscriptions"] _LOGGER.info('opcua_py: Attempting to subscribe to %s', subs) nodes = [] for sub in subs: nodes.append(client.get_node(sub)) handler = SubscriptionHandler() # We create a Client Subscription. subscription = client.create_subscription(500, handler) # We subscribe to data changes for our nodes (variables). subscription.subscribe_data_change(nodes) def run(): global loop loop.run_forever() t = Thread(target=run) t.start()
class UaClient(object): def __init__(self, server_ip): self.server_ip = server_ip self.client = Client(self.server_ip) print('Try to connect', self.server_ip) self.client.connect() print('Connected!') self.root = self.client.get_root_node() self.device = self.root.get_child(['0:Objects', '2:device']) self.device_obj = Device(self.device) self.device_id = self.device.get_child(['2:device_id']).get_value() self.location_x = self.device.get_child(['2:location_x']) self.location_y = self.device.get_child(['2:location_y']) self.direction = self.device.get_child(['2:direction']) self.status = self.device.get_child(['2:status']) self.network_condition = self.device.get_child(['2:network_condition']) handler = SubHandler(self) sub = self.client.create_subscription(500, handler) sub.subscribe_data_change(self.location_x) sub.subscribe_data_change(self.location_y) sub.subscribe_data_change(self.direction) sub.subscribe_data_change(self.network_condition) sub.subscribe_data_change(self.status) def go_front(self): self.device.call_method('2:go_front') def go_back(self): self.device.call_method('2:go_back') def turn_left(self): self.device.call_method('2:turn_left') def turn_right(self): self.device.call_method('2:turn_right') def go_to(self, target_x, target_y): self.device.call_method('2:go_to', target_x, target_y) def get_status(self): return Device(self.device).get_status() def disconnect(self): self.client.disconnect()
def main(): logging.basicConfig(level=logging.WARN) client = Client("opc.tcp://WIN-B3JSS0UOON2:49320") try: client.connect() tag1 = client.get_node("ns=2;s=Channel1.Device1.Tag1") tag2 = client.get_node("ns=2;s=Simulation Examples.Functions.Ramp3") tag3 = client.get_node("ns=2;s=Simulation Examples.Functions.Sine1") tags = [tag1, tag2, tag3] handler = SubHandler(tags) sub = client.create_subscription(500, handler) handles = [ sub.subscribe_data_change(tag1), sub.subscribe_data_change(tag2), sub.subscribe_data_change(tag3) ] sleep(0.1) embed() print("") print("Tag1 is: ", handler.storage[0]) print("") print("Tag2 is: ", handler.storage[1]) print("") print("Tag3 is: ", handler.storage[2]) print("") algorithm = SubHandler.extreme_value_analysis flags = list(map(lambda i: algorithm(np.array(i)), handler.storage)) for i in range(len(handles)): if flags[i] == True: sub.unsubscribe(handles[i]) print(tags[i], "is broken!") else: print(tags[i], "is OK!") sub.delete() finally: client.disconnect()
def subscribe(self): global dic if __name__ == "__main__": logging.basicConfig(level=logging.WARN) client = Client("opc.tcp://" + self.host + ":" + self.port) try: client.connect() for i, j in dic.items(): for k, l in j.items(): ss = client.get_node("ns=2;s=S7-300." + i + "." + k) self.taglist.append(ss) print("订阅变量总数为:", len(self.taglist)) except: pass handler = SubHandler() sub = client.create_subscription(5000, handler) handle1 = sub.subscribe_data_change(self.taglist)
class OpcuaBase(object): def __init__(self, address="opc.tcp://192.168.42.20:4840"): # self.client = Client("opc.tcp://100.102.7.5:4840") self.address = address self.client = Client(self.address) self.nodes = {} def get_node(self, nodeId): if not nodeId in self.nodes: self.nodes[nodeId] = self.client.get_node(ua.NodeId(nodeId, 2)) return self.nodes[nodeId] def readValue_polling(self, nodeId, namespace): var = self.client.get_node(ua.NodeId(nodeId, namespace)) return var.get_value() def writeBooleanValue(self, nodeId, namespace, value): self.get_node(nodeId).set_value( ua.Variant(value, ua.VariantType.Boolean)) def writeFloatValue(self, nodeId, namespace, value): var = self.client.get_node(ua.NodeId(nodeId, namespace)) var.set_value(ua.Variant(value, ua.VariantType.Float)) def disconnect(self): self.client.disconnect() def add_subscription(self, AxisNo, AxisType, MeasurementType): # AxisNo [1...4], AxisType ["Trans","Rot"], MeasurementType ["Vel","Pos"] if AxisType == "Rot": atype = 0 if AxisType == "Trans": atype = 1 if MeasurementType == "Pos": mtype = 2 if MeasurementType == "Trans": mtype = 3 nodeId = Axis[AxisNo - 1][atype][mtype][0] namespace = Axis[AxisNo - 1][atype][mtype][1] var = self.client.get_node(ua.NodeId(nodeId, namespace)) handler = SubScriptionHandler() sub = self.client.create_subscription(50, handler) sub.subscribe_data_change(var)
def main(): srv_url = "opc.tcp://127.0.0.1:XXXX/FearFactory/supervision_unit/" client = Client(srv_url) client.connect() root = client.get_root_node() objs = client.get_objects_node() # Subscribe to the main board event_obj = root.get_child("2:MainBoard") handler = SubscriptionHandler() subscription = client.create_subscription(500, handler) event_type = root.get_child( ["0:Types", "0:EventTypes", "0:BaseEventType", "2:MainBoardNotif"]) hilt = subscription.subscribe_events(event_obj, event_type) #subscription.unsubscribe(hilt) #subscription.delete() # Uncomment if you want to interact with server using IPython embed()
def lambda_handler(event, context): """ Handler for the AWS Lambda function. :param event: AWS Lambda uses this parameter to pass in event data to the handler. This parameter is usually of the Python dict type. It can also be list, str, int, float, or NoneType type. :param context: The AWS Lambda event context. To learn more about what is included in the context, see https://docs.aws.amazon.com/lambda/latest/dg/python-context-object.html. """ logger.debug('Handling event: %s', json.dumps(event)) client = Client(SERVER_URL) try: client.connect() root = client.get_root_node() logger.debug("Root node is: %s", root) objects = client.get_objects_node() logger.debug("Objects node is: %s", objects) # Node objects have methods to read and write node attributes as well as browse or populate address space logger.debug("Children of root are: %s", root.get_children()) logger.debug('Creating subscription...') subscription_handler = SubscriptionHandler() subscription = client.create_subscription(500, subscription_handler) logger.info('Finished creating subscription to %s', SERVER_URL) logger.debug('Subscribing to data changes...') variable = root.get_child(["0:Objects", "2:MyObject", "2:MyVariable"]) handle = subscription.subscribe_data_change(variable) logger.info('Subscribed to %s', handle) while True: time.sleep(1) finally: client.disconnect()
class OpcuaSubClient(): def __init__(self, sub_handler=SubHandler): self.server_uri = "opc.tcp://localhost:4840" self.client = Client(self.server_uri) self.is_connect = False self.sub = None self.root = None self.sub_handler = sub_handler() self.handle = None self.connect() def connect(self): try: self.client.connect() self.is_connect = True self.root = self.client.get_root_node() self.sub = self.client.create_subscription(1000, self.sub_handler) except Exception as e: self.is_connect = False raise e def dis_connect(self): if self.is_connect: self.client.disconnect() self.is_connect = False self.root = None self.sub = None def subscribe(self, qualified_list): val_node = self.root.get_child(qualified_list) if val_node: self.handle = self.sub.subscribe_data_change(val_node) def unsubscribe(self): if self.handle: self.sub.unsubscribe(self.handle)
class UaClient(object): """ OPC-Ua client specialized for the need of GUI client return exactly whant GUI needs, no customization possible """ def __init__(self): self.client = None self._connected = False self._datachange_sub = None self._event_sub = None self._subs_dc = {} self._subs_ev = {} def connect(self, uri): self.disconnect() print("Connecting to ", uri) self.client = Client(uri) self.client.connect() self._connected = True def disconnect(self): if self._connected: print("Disconnecting from server") self._subs_dc = {} self._subs_ev = {} self._connected = False self._subscription = None self.client.disconnect() self.client = None def subscribe_datachange(self, node, handler): if not self._datachange_sub: self._datachange_sub = self.client.create_subscription(500, handler) handle = self._datachange_sub.subscribe_data_change(node) self._subs_dc[node.nodeid] = handle return handle def unsubscribe_datachange(self, node): self._datachange_sub.unsubscribe(self._subs_dc[node.nodeid]) def subscribe_events(self, node, handler): if not self._event_sub: print("subscirbing with handler: ", handler, dir(handler)) self._event_sub = self.client.create_subscription(500, handler) handle = self._event_sub.subscribe_events(node) self._subs_ev[node.nodeid] = handle return handle def unsubscribe_events(self, node): self._event_sub.unsubscribe(self._subs_ev[node.nodeid]) def get_root_node_and_desc(self): node = self.client.get_root_node() attrs = node.get_attributes([ua.AttributeIds.DisplayName, ua.AttributeIds.BrowseName, ua.AttributeIds.NodeId, ua.AttributeIds.NodeClass]) desc = ua.ReferenceDescription() desc.DisplayName = attrs[0].Value.Value desc.BrowseName = attrs[1].Value.Value desc.NodeId = attrs[2].Value.Value desc.NodeClass = attrs[3].Value.Value desc.TypeDefinition = ua.TwoByteNodeId(ua.ObjectIds.FolderType) return node, desc def get_node_attrs(self, node): if not isinstance(node, Node): node = self.client.get_node(node) attrs = node.get_attributes([ua.AttributeIds.DisplayName, ua.AttributeIds.BrowseName, ua.AttributeIds.NodeId]) return node, [attr.Value.Value.to_string() for attr in attrs] def get_children(self, node): descs = node.get_children_descriptions() children = [] for desc in descs: children.append((self.client.get_node(desc.NodeId), desc)) return children def get_all_attrs(self, node): names = [] vals = [] for name, val in ua.AttributeIds.__dict__.items(): if not name.startswith("_"): names.append(name) vals.append(val) attrs = node.get_attributes(vals) res = [] for idx, name in enumerate(names): if attrs[idx].StatusCode.is_good(): res.append((name, attrs[idx])) res.sort() return res def get_all_refs(self, node): return node.get_children_descriptions(refs=ua.ObjectIds.References)
class OpcUaConnector(Thread, Connector): def __init__(self, gateway, config, connector_type): self._connector_type = connector_type self.statistics = {'MessagesReceived': 0, 'MessagesSent': 0} super().__init__() self.__gateway = gateway self.__server_conf = config.get("server") self.__interest_nodes = [] self.__available_object_resources = {} self.__show_map = self.__server_conf.get("showMap", False) self.__previous_scan_time = 0 for mapping in self.__server_conf["mapping"]: if mapping.get("deviceNodePattern") is not None: self.__interest_nodes.append( {mapping["deviceNodePattern"]: mapping}) else: log.error( "deviceNodePattern in mapping: %s - not found, add property deviceNodePattern to processing this mapping", dumps(mapping)) if "opc.tcp" not in self.__server_conf.get("url"): self.__opcua_url = "opc.tcp://" + self.__server_conf.get("url") else: self.__opcua_url = self.__server_conf.get("url") self.client = Client( self.__opcua_url, timeout=self.__server_conf.get("timeoutInMillis", 4000) / 1000) if self.__server_conf["identity"].get("type") == "cert.PEM": try: ca_cert = self.__server_conf["identity"].get("caCert") private_key = self.__server_conf["identity"].get("privateKey") cert = self.__server_conf["identity"].get("cert") security_mode = self.__server_conf["identity"].get( "mode", "SignAndEncrypt") policy = self.__server_conf["security"] if cert is None or private_key is None: log.exception( "Error in ssl configuration - cert or privateKey parameter not found" ) raise RuntimeError( "Error in ssl configuration - cert or privateKey parameter not found" ) security_string = policy + ',' + security_mode + ',' + cert + ',' + private_key if ca_cert is not None: security_string = security_string + ',' + ca_cert self.client.set_security_string(security_string) except Exception as e: log.exception(e) if self.__server_conf["identity"].get("username"): self.client.set_user( self.__server_conf["identity"].get("username")) if self.__server_conf["identity"].get("password"): self.client.set_password( self.__server_conf["identity"].get("password")) self.setName( self.__server_conf.get( "name", 'OPC-UA ' + ''.join(choice(ascii_lowercase) for _ in range(5))) + " Connector") self.__opcua_nodes = {} self._subscribed = {} self.__sub = None self.__sub_handler = SubHandler(self) self.data_to_send = [] self.__stopped = False self.__connected = False self.daemon = True def is_connected(self): return self.__connected def open(self): self.__stopped = False self.start() log.info("Starting OPC-UA Connector") def run(self): while not self.__connected: try: self.client.connect() try: self.client.load_type_definitions() except Exception as e: log.debug(e) log.debug("Error on loading type definitions.") log.debug(self.client.get_namespace_array()[-1]) log.debug( self.client.get_namespace_index( self.client.get_namespace_array()[-1])) except ConnectionRefusedError: log.error( "Connection refused on connection to OPC-UA server with url %s", self.__server_conf.get("url")) time.sleep(10) except OSError: log.error( "Connection refused on connection to OPC-UA server with url %s", self.__server_conf.get("url")) time.sleep(10) except Exception as e: log.debug("error on connection to OPC-UA server.") log.error(e) time.sleep(10) else: self.__connected = True log.info("OPC-UA connector %s connected to server %s", self.get_name(), self.__server_conf.get("url")) self.__initialize_client() while not self.__stopped: try: time.sleep(.1) self.__check_connection() if not self.__connected and not self.__stopped: self.client.connect() self.__initialize_client() log.info("Reconnected to the OPC-UA server - %s", self.__server_conf.get("url")) elif not self.__stopped: if self.__server_conf.get( "disableSubscriptions", False ) and time.time( ) * 1000 - self.__previous_scan_time > self.__server_conf.get( "scanPeriodInMillis", 60000): self.scan_nodes_from_config() self.__previous_scan_time = time.time() * 1000 # giusguerrini, 2020-09-24: Fix: flush event set and send all data to platform, # so data_to_send doesn't grow indefinitely in case of more than one value change # per cycle, and platform doesn't lose events. # NOTE: possible performance improvement: use a map to store only one event per # variable to reduce frequency of messages to platform. while self.data_to_send: self.__gateway.send_to_storage(self.get_name(), self.data_to_send.pop()) if self.__stopped: self.close() break except (KeyboardInterrupt, SystemExit): self.close() raise except FuturesTimeoutError: self.__check_connection() except Exception as e: log.error( "Connection failed on connection to OPC-UA server with url %s", self.__server_conf.get("url")) log.exception(e) self.client = Client( self.__opcua_url, timeout=self.__server_conf.get("timeoutInMillis", 4000) / 1000) self._subscribed = {} self.__available_object_resources = {} time.sleep(10) def __check_connection(self): try: node = self.client.get_root_node() node.get_children() if not self.__server_conf.get("disableSubscriptions", False) and ( not self.__connected or not self.subscribed): self.__sub = self.client.create_subscription( self.__server_conf.get("subCheckPeriodInMillis", 500), self.__sub_handler) self.__connected = True except ConnectionRefusedError: self.__connected = False self._subscribed = {} self.__available_object_resources = {} self.__sub = None except OSError: self.__connected = False self._subscribed = {} self.__available_object_resources = {} self.__sub = None except FuturesTimeoutError: self.__connected = False self._subscribed = {} self.__available_object_resources = {} self.__sub = None except AttributeError: self.__connected = False self._subscribed = {} self.__available_object_resources = {} self.__sub = None except Exception as e: self.__connected = False self._subscribed = {} self.__available_object_resources = {} self.__sub = None log.exception(e) def close(self): self.__stopped = True if self.__connected: self.client.disconnect() self.__connected = False log.info('%s has been stopped.', self.get_name()) def get_name(self): return self.name def on_attributes_update(self, content): log.debug(content) try: for server_variables in self.__available_object_resources[ content["device"]]['variables']: for attribute in content["data"]: for variable in server_variables: if attribute == variable: try: server_variables[variable].set_value( content["data"][variable]) except Exception: server_variables[variable].set_attribute( ua.AttributeIds.Value, ua.DataValue(content["data"][variable])) except Exception as e: log.exception(e) def server_side_rpc_handler(self, content): try: rpc_method = content["data"].get("method") for method in self.__available_object_resources[ content["device"]]['methods']: if rpc_method is not None and method.get( rpc_method) is not None: arguments_from_config = method["arguments"] arguments = content["data"].get( "params") if content["data"].get( "params") is not None else arguments_from_config try: if isinstance(arguments, list): result = method["node"].call_method( method[rpc_method], *arguments) elif arguments is not None: try: result = method["node"].call_method( method[rpc_method], arguments) except ua.UaStatusCodeError as e: if "BadTypeMismatch" in str(e) and isinstance( arguments, int): result = method["node"].call_method( method[rpc_method], float(arguments)) else: result = method["node"].call_method( method[rpc_method]) self.__gateway.send_rpc_reply( content["device"], content["data"]["id"], { content["data"]["method"]: result, "code": 200 }) log.debug("method %s result is: %s", method[rpc_method], result) except Exception as e: log.exception(e) self.__gateway.send_rpc_reply(content["device"], content["data"]["id"], { "error": str(e), "code": 500 }) else: log.error("Method %s not found for device %s", rpc_method, content["device"]) self.__gateway.send_rpc_reply( content["device"], content["data"]["id"], { "error": "%s - Method not found" % (rpc_method), "code": 404 }) except Exception as e: log.exception(e) def __initialize_client(self): self.__opcua_nodes["root"] = self.client.get_objects_node() self.__opcua_nodes["objects"] = self.client.get_objects_node() self.scan_nodes_from_config() self.__previous_scan_time = time.time() * 1000 log.debug('Subscriptions: %s', self.subscribed) log.debug("Available methods: %s", self.__available_object_resources) def scan_nodes_from_config(self): try: if self.__interest_nodes: for device_object in self.__interest_nodes: for current_device in device_object: try: device_configuration = device_object[ current_device] devices_info_array = self.__search_general_info( device_configuration) for device_info in devices_info_array: if device_info is not None and device_info.get( "deviceNode") is not None: self.__search_nodes_and_subscribe( device_info) self.__save_methods(device_info) self.__search_attribute_update_variables( device_info) else: log.error( "Device node is None, please check your configuration." ) log.debug( "Current device node is: %s", str( device_configuration.get( "deviceNodePattern"))) break except BrokenPipeError: log.debug("Broken Pipe. Connection lost.") except OSError: log.debug("Stop on scanning.") except FuturesTimeoutError: self.__check_connection() except Exception as e: log.exception(e) log.debug(self.__interest_nodes) except Exception as e: log.exception(e) def __search_nodes_and_subscribe(self, device_info): sub_nodes = [] information_types = { "attributes": "attributes", "timeseries": "telemetry" } for information_type in information_types: for information in device_info["configuration"][information_type]: information_key = information["key"] config_path = TBUtility.get_value(information["path"], get_tag=True) information_path = self._check_path(config_path, device_info["deviceNode"]) information["path"] = '${%s}' % information_path information_nodes = [] self.__search_node(device_info["deviceNode"], information_path, result=information_nodes) for information_node in information_nodes: if information_node is not None: try: information_value = information_node.get_value() except: log.error("Err get_value: %s", str(information_node)) continue log.debug( "Node for %s \"%s\" with path: %s - FOUND! Current values is: %s", information_type, information_key, information_path, str(information_value)) if device_info.get("uplink_converter") is None: configuration = { **device_info["configuration"], "deviceName": device_info["deviceName"], "deviceType": device_info["deviceType"] } if device_info["configuration"].get( 'converter') is None: converter = OpcUaUplinkConverter(configuration) else: converter = TBModuleLoader.import_module( self._connector_type, configuration) device_info["uplink_converter"] = converter else: converter = device_info["uplink_converter"] self.subscribed[information_node] = { "converter": converter, "path": information_path, "config_path": config_path } if not device_info.get( information_types[information_type]): device_info[ information_types[information_type]] = [] converted_data = converter.convert( (config_path, information_path), information_value) self.statistics['MessagesReceived'] = self.statistics[ 'MessagesReceived'] + 1 self.data_to_send.append(converted_data) self.statistics['MessagesSent'] = self.statistics[ 'MessagesSent'] + 1 log.debug("Data to ThingsBoard: %s", converted_data) if not self.__server_conf.get("disableSubscriptions", False): sub_nodes.append(information_node) else: log.error( "Node for %s \"%s\" with path %s - NOT FOUND!", information_type, information_key, information_path) if not self.__server_conf.get("disableSubscriptions", False): if self.__sub is None: self.__sub = self.client.create_subscription( self.__server_conf.get("subCheckPeriodInMillis", 500), self.__sub_handler) if sub_nodes: self.__sub.subscribe_data_change(sub_nodes) log.debug("Added subscription to nodes: %s", str(sub_nodes)) def __save_methods(self, device_info): try: if self.__available_object_resources.get( device_info["deviceName"]) is None: self.__available_object_resources[ device_info["deviceName"]] = {} if self.__available_object_resources[ device_info["deviceName"]].get("methods") is None: self.__available_object_resources[ device_info["deviceName"]]["methods"] = [] if device_info["configuration"].get("rpc_methods", []): node = device_info["deviceNode"] for method_object in device_info["configuration"][ "rpc_methods"]: method_node_path = self._check_path( method_object["method"], node) methods = [] self.__search_node(node, method_node_path, True, result=methods) for method in methods: if method is not None: node_method_name = method.get_display_name().Text self.__available_object_resources[ device_info["deviceName"]]["methods"].append({ node_method_name: method, "node": node, "arguments": method_object.get("arguments") }) else: log.error( "Node for method with path %s - NOT FOUND!", method_node_path) except Exception as e: log.exception(e) def __search_attribute_update_variables(self, device_info): try: if device_info["configuration"].get("attributes_updates", []): node = device_info["deviceNode"] device_name = device_info["deviceName"] if self.__available_object_resources.get(device_name) is None: self.__available_object_resources[device_name] = {} if self.__available_object_resources[device_name].get( "variables") is None: self.__available_object_resources[device_name][ "variables"] = [] for attribute_update in device_info["configuration"][ "attributes_updates"]: attribute_path = self._check_path( attribute_update["attributeOnDevice"], node) attribute_nodes = [] self.__search_node(node, attribute_path, result=attribute_nodes) for attribute_node in attribute_nodes: if attribute_node is not None: self.__available_object_resources[device_name][ "variables"].append({ attribute_update["attributeOnThingsBoard"]: attribute_node }) else: log.error( "Attribute update node with path \"%s\" - NOT FOUND!", attribute_path) except Exception as e: log.exception(e) def __search_general_info(self, device): result = [] match_devices = [] self.__search_node(self.__opcua_nodes["root"], TBUtility.get_value(device["deviceNodePattern"], get_tag=True), result=match_devices) for device_node in match_devices: if device_node is not None: result_device_dict = { "deviceName": None, "deviceType": None, "deviceNode": device_node, "configuration": deepcopy(device) } name_pattern_config = device["deviceNamePattern"] name_expression = TBUtility.get_value(name_pattern_config, get_tag=True) if "${" in name_pattern_config and "}" in name_pattern_config: log.debug("Looking for device name") device_name_from_node = "" if name_expression == "$DisplayName": device_name_from_node = device_node.get_display_name( ).Text elif name_expression == "$BrowseName": device_name_from_node = device_node.get_browse_name( ).Name elif name_expression == "$NodeId.Identifier": device_name_from_node = str( device_node.nodeid.Identifier) else: name_path = self._check_path(name_expression, device_node) device_name_node = [] self.__search_node(device_node, name_path, result=device_name_node) device_name_node = device_name_node[0] if device_name_node is not None: device_name_from_node = device_name_node.get_value( ) if device_name_from_node == "": log.error( "Device name node not found with expression: %s", name_expression) return None full_device_name = name_pattern_config.replace( "${" + name_expression + "}", str(device_name_from_node)).replace( name_expression, str(device_name_from_node)) else: full_device_name = name_expression result_device_dict["deviceName"] = full_device_name log.debug("Device name: %s", full_device_name) if device.get("deviceTypePattern"): device_type_expression = TBUtility.get_value( device["deviceTypePattern"], get_tag=True) if "${" in device_type_expression and "}" in device_type_expression: type_path = self._check_path(device_type_expression, device_node) device_type_node = [] self.__search_node(device_node, type_path, result=device_type_node) device_type_node = device_type_node[0] if device_type_node is not None: device_type = device_type_node.get_value() full_device_type = device_type_expression.replace( "${" + device_type_expression + "}", device_type).replace(device_type_expression, device_type) else: log.error( "Device type node not found with expression: %s", device_type_expression) full_device_type = "default" else: full_device_type = device_type_expression result_device_dict["deviceType"] = full_device_type log.debug("Device type: %s", full_device_type) else: result_device_dict["deviceType"] = "default" result.append(result_device_dict) else: log.error( "Device node not found with expression: %s", TBUtility.get_value(device["deviceNodePattern"], get_tag=True)) return result # # get fullpath of node as string # # this is verry slow # path = '\\.'.join(char.split(":")[1] for char in node.get_path(200000, True)) # i think we don't need \\. # def get_node_path(self, node): ID = node.nodeid.Identifier if ID == 85: return 'Root.Objects' # this is Root if type(ID) == int: ID = node.get_browse_name( ).Name # for int Identifer we take browsename return 'Root.Objects.' + ID def __search_node(self, current_node, fullpath, search_method=False, result=None): if result is None: result = [] try: if regex.match(r"ns=\d*;[isgb]=.*", fullpath, regex.IGNORECASE): if self.__show_map: log.debug("Looking for node with config") node = self.client.get_node(fullpath) if node is None: log.warning("NODE NOT FOUND - using configuration %s", fullpath) else: log.debug("Found in %s", node) result.append(node) else: fullpath_pattern = regex.compile(fullpath) full1 = fullpath.replace('\\\\.', '.') #current_node_path = '\\.'.join(char.split(":")[1] for char in current_node.get_path(200000, True)) current_node_path = self.get_node_path(current_node) # we are allways the parent child_node_parent_class = current_node.get_node_class() new_parent = current_node for child_node in current_node.get_children(): new_node_class = child_node.get_node_class() # this will not change you can do it outside th loop # basis Description of node.get_parent() function, sometime child_node.get_parent() return None #new_parent = child_node.get_parent() #if (new_parent is None): # child_node_parent_class = current_node.get_node_class() #else: # child_node_parent_class = child_node.get_parent().get_node_class() #current_node_path = '\\.'.join(char.split(":")[1] for char in current_node.get_path(200000, True)) #new_node_path = '\\\\.'.join(char.split(":")[1] for char in child_node.get_path(200000, True)) new_node_path = self.get_node_path(child_node) if child_node_parent_class == ua.NodeClass.View and new_parent is not None: parent_path = self.get_node_path(new_parent) #parent_path = '\\.'.join(char.split(":")[1] for char in new_parent.get_path(200000, True)) fullpath = fullpath.replace(current_node_path, parent_path) nnp1 = new_node_path.replace('\\\\.', '.') nnp2 = new_node_path.replace('\\\\', '\\') if self.__show_map: log.debug("SHOW MAP: Current node path: %s", new_node_path) regex_fullmatch = regex.fullmatch(fullpath_pattern, nnp1) or \ nnp2 == full1 or \ nnp2 == fullpath or \ nnp1 == full1 if regex_fullmatch: if self.__show_map: log.debug( "SHOW MAP: Current node path: %s - NODE FOUND", nnp2) result.append(child_node) else: regex_search = fullpath_pattern.fullmatch(nnp1, partial=True) or \ nnp2 in full1 or \ nnp1 in full1 if regex_search: if self.__show_map: log.debug( "SHOW MAP: Current node path: %s - NODE FOUND", new_node_path) if new_node_class == ua.NodeClass.Object: if self.__show_map: log.debug("SHOW MAP: Search in %s", new_node_path) self.__search_node(child_node, fullpath, result=result) elif new_node_class == ua.NodeClass.Variable: log.debug("Found in %s", new_node_path) result.append(child_node) elif new_node_class == ua.NodeClass.Method and search_method: log.debug("Found in %s", new_node_path) result.append(child_node) except CancelledError: log.error( "Request during search has been canceled by the OPC-UA server." ) except BrokenPipeError: log.error("Broken Pipe. Connection lost.") except OSError: log.debug("Stop on scanning.") except Exception as e: log.exception(e) def _check_path(self, config_path, node): if regex.match(r"ns=\d*;[isgb]=.*", config_path, regex.IGNORECASE): return config_path if re.search(r"^root", config_path.lower()) is None: node_path = self.get_node_path(node) #node_path = '\\\\.'.join(char.split(":")[1] for char in node.get_path(200000, True)) if config_path[-3:] != '\\.': information_path = node_path + '\\\\.' + config_path.replace( '\\', '\\\\') else: information_path = node_path + config_path.replace( '\\', '\\\\') else: information_path = config_path result = information_path[:] return result @property def subscribed(self): return self._subscribed
class UaClient(object): """ OPC-Ua client specialized for the need of GUI client return exactly what GUI needs, no customization possible """ def __init__(self): self.settings = QSettings() self.client = None self._connected = False self._datachange_sub = None self._event_sub = None self._subs_dc = {} self._subs_ev = {} self.security_mode = None self.security_policy = None self.certificate_path = None self.private_key_path = None @staticmethod def get_endpoints(uri): client = Client(uri, timeout=2) client.connect_and_get_server_endpoints() edps = client.connect_and_get_server_endpoints() for i, ep in enumerate(edps, start=1): logger.info('Endpoint %s:', i) for (n, v) in endpoint_to_strings(ep): logger.info(' %s: %s', n, v) logger.info('') return edps def load_security_settings(self, uri): self.security_mode = None self.security_policy = None self.certificate_path = None self.private_key_path = None mysettings = self.settings.value("security_settings", None) if mysettings is None: return if uri in mysettings: mode, policy, cert, key = mysettings[uri] self.security_mode = mode self.security_policy = policy self.certificate_path = cert self.private_key_path = key def save_security_settings(self, uri): mysettings = self.settings.value("security_settings", None) if mysettings is None: mysettings = {} mysettings[uri] = [ self.security_mode, self.security_policy, self.certificate_path, self.private_key_path ] self.settings.setValue("security_settings", mysettings) def get_node(self, nodeid): return self.client.get_node(nodeid) def connect(self, uri): self.disconnect() logger.info("Connecting to %s with parameters %s, %s, %s, %s", uri, self.security_mode, self.security_policy, self.certificate_path, self.private_key_path) self.client = Client(uri) if self.security_mode is not None and self.security_policy is not None: self.client.set_security(getattr( crypto.security_policies, 'SecurityPolicy' + self.security_policy), self.certificate_path, self.private_key_path, mode=getattr(ua.MessageSecurityMode, self.security_mode)) self.client.connect() self._connected = True self.save_security_settings(uri) def disconnect(self): if self._connected: print("Disconnecting from server") self._subs_dc = {} self._subs_ev = {} self._connected = False self.client.disconnect() self.client = None def subscribe_datachange(self, node, handler): if not self._datachange_sub: self._datachange_sub = self.client.create_subscription( 500, handler) handle = self._datachange_sub.subscribe_data_change(node) self._subs_dc[node.nodeid] = handle return handle def unsubscribe_datachange(self, node): self._datachange_sub.unsubscribe(self._subs_dc[node.nodeid]) def subscribe_events(self, node, handler): if not self._event_sub: print("subscirbing with handler: ", handler, dir(handler)) self._event_sub = self.client.create_subscription(500, handler) handle = self._event_sub.subscribe_events(node) self._subs_ev[node.nodeid] = handle return handle def unsubscribe_events(self, node): self._event_sub.unsubscribe(self._subs_ev[node.nodeid]) def get_node_attrs(self, node): if not isinstance(node, Node): node = self.client.get_node(node) attrs = node.get_attributes([ ua.AttributeIds.DisplayName, ua.AttributeIds.BrowseName, ua.AttributeIds.NodeId ]) return node, [attr.Value.Value.to_string() for attr in attrs] @staticmethod def get_children(node): descs = node.get_children_descriptions() descs.sort(key=lambda x: x.BrowseName) return descs
password=password) listdb = client_db.get_list_database() client_db.create_database(mydb) client_db.switch_database(mydb) client_ua = Client(url) try: client_ua.set_user(ua_username) client_ua.set_password(ua_password) client_ua.connect() print('Client Connected') for i in nodes: myvar.append(client_ua.get_node(i)) handler = SubHandler() sub = client_ua.create_subscription(ua_period, handler) handle = sub.subscribe_data_change(myvar) print('Subscribe data_change with period {} ms'.format(ua_period)) # time.sleep(5) input("Press Enter to continue...") for i in handle: sub.unsubscribe(i) print('Unsubscribe handle: ', i) print('Start deleting Sub') sub.delete() finally: try: client_db.close() client_ua.disconnect() except concurrent.futures._base.TimeoutError:
print("New event notification", event) # To print only the notification message #print("Write whatever you want here", event.Message.Text) if __name__ == "__main__": client = Client("opc.tcp://localhost:4840/freeopcua/server/") try: client.connect() root = client.get_root_node() print("Objects node is: ", root) # Now getting a variable node using its browse path obj = root.get_child(["0:Objects", "2:MyObject"]) print("MyObject is: ", obj) # Get the custom event type myevent = root.get_child(["0:Types", "0:EventTypes", "0:BaseEventType", "2:MyFirstEvent"]) print("MyFirstEventType is: ", myevent) msclt = SubHandler() sub = client.create_subscription(100, msclt) handle = sub.subscribe_events(obj, myevent) #embed() #sub.unsubscribe(handle) #sub.delete() finally: client.disconnect()
def run(): logger.info("Modular Input mi_opcua_subscription command: %s" % sys.argv) if len(sys.argv) > 1: try: if sys.argv[1] == "--scheme": do_scheme() elif sys.argv[1] == "--validate-arguments": validate_arguments() elif sys.argv[1] == "--test": test() else: usage() except Exception as ex: logger.critical(ex) else: logger.info("Modular Input mi_opcua_subscription Starts data collection.") configs = get_config() stanza = configs["name"] # server_uri = configs["server_uri"] # sessionKey = configs["session_key"] # userName = "******" # make this modular input as application context only. patterns = configs["measures"].split(":") tout = configs["connection_timeout"].strip() timeout = 1 if len(tout) <= 0 else int(tout) ct = configs["collect_duration"].strip() duration = 1000 if len(ct) <=0 else int(ct) conn = configs["connection"] ## "opc.tcp://ec2-54-190-162-94.us-west-2.compute.amazonaws.com:49320" if configs.has_key("username"): username = configs["username"].strip() if len(username)>0: password = configs["password"].strip() conn = "%s?username=%s&password=%s" % (conn, username, password) client = Client(conn, timeout=timeout) try: client.connect() measures = [] root = client.get_root_node() node.collect_measures(measures, patterns, root) subscribers = [] for m in measures: try: subscribers.append(m[len(m)-1]) except: logger.warn("The node of %s is invalid to subscribe." % m) handler = SubHandler(stanza) sub = client.create_subscription(duration, handler) dchandle = sub.subscribe_data_change(subscribers) def signal_handler(signal, frame): logger.info('Press Ctrl+C') if signal in [signal.SIGABRT, signal.SIGINT, signal.SIGQUIT, signal.SIGTERM]: sub.unsubscribe(dchandle) sub.delete() client.disconnect() signal.signal(signal.SIGINT, signal_handler) signal.signal(signal.SIGABRT, signal_handler) signal.signal(signal.SIGTERM, signal_handler) signal.signal(signal.SIGQUIT, signal_handler) signal.pause() except Exception as ex: logger.critical(ex) finally: sub.unsubscribe(dchandle) sub.delete() client.disconnect() logger.info("---- end of sub opc ua ----")
class UaClient(object): """ OPC-Ua client specialized for the need of GUI client return exactly what GUI needs, no customization possible """ def __init__(self): self.settings = QSettings() self.client = None self._connected = False self._datachange_sub = None self._event_sub = None self._subs_dc = {} self._subs_ev = {} self.security_mode = None self.security_policy = None self.certificate_path = None self.private_key_path = None def _reset(self): self.client = None self._connected = False self._datachange_sub = None self._event_sub = None self._subs_dc = {} self._subs_ev = {} @staticmethod def get_endpoints(uri): client = Client(uri, timeout=2) client.connect_and_get_server_endpoints() edps = client.connect_and_get_server_endpoints() for i, ep in enumerate(edps, start=1): logger.info('Endpoint %s:', i) for (n, v) in endpoint_to_strings(ep): logger.info(' %s: %s', n, v) logger.info('') return edps def load_security_settings(self, uri): self.security_mode = None self.security_policy = None self.certificate_path = None self.private_key_path = None mysettings = self.settings.value("security_settings", None) if mysettings is None: return if uri in mysettings: mode, policy, cert, key = mysettings[uri] self.security_mode = mode self.security_policy = policy self.certificate_path = cert self.private_key_path = key def save_security_settings(self, uri): mysettings = self.settings.value("security_settings", None) if mysettings is None: mysettings = {} mysettings[uri] = [self.security_mode, self.security_policy, self.certificate_path, self.private_key_path] self.settings.setValue("security_settings", mysettings) def get_node(self, nodeid): return self.client.get_node(nodeid) def connect(self, uri): self.disconnect() logger.info("Connecting to %s with parameters %s, %s, %s, %s", uri, self.security_mode, self.security_policy, self.certificate_path, self.private_key_path) self.client = Client(uri) if self.security_mode is not None and self.security_policy is not None: self.client.set_security( getattr(crypto.security_policies, 'SecurityPolicy' + self.security_policy), self.certificate_path, self.private_key_path, mode=getattr(ua.MessageSecurityMode, self.security_mode) ) self.client.connect() self._connected = True self.save_security_settings(uri) def disconnect(self): if self._connected: print("Disconnecting from server") self._connected = False try: self.client.disconnect() finally: self._reset() def subscribe_datachange(self, node, handler): if not self._datachange_sub: self._datachange_sub = self.client.create_subscription(500, handler) handle = self._datachange_sub.subscribe_data_change(node) self._subs_dc[node.nodeid] = handle return handle def unsubscribe_datachange(self, node): self._datachange_sub.unsubscribe(self._subs_dc[node.nodeid]) def subscribe_events(self, node, handler): if not self._event_sub: print("subscirbing with handler: ", handler, dir(handler)) self._event_sub = self.client.create_subscription(500, handler) handle = self._event_sub.subscribe_events(node) self._subs_ev[node.nodeid] = handle return handle def unsubscribe_events(self, node): self._event_sub.unsubscribe(self._subs_ev[node.nodeid]) def get_node_attrs(self, node): if not isinstance(node, Node): node = self.client.get_node(node) attrs = node.get_attributes([ua.AttributeIds.DisplayName, ua.AttributeIds.BrowseName, ua.AttributeIds.NodeId]) return node, [attr.Value.Value.to_string() for attr in attrs] @staticmethod def get_children(node): descs = node.get_children_descriptions() descs.sort(key=lambda x: x.BrowseName) return descs
class UaClient(object): """ OPC-Ua client specialized for the need of GUI client return exactly whant GUI needs, no customization possible """ def __init__(self): self.client = None self._connected = False self._subscription = None def connect(self, uri): self.disconnect() print("Connecting to ", uri) self.client = Client(uri) self.client.connect() self._connected = True print("Connected, root is: ", self.client.get_root_node()) print(self.get_root_attrs()) def disconnect(self): if self._connected: print("Disconnecting from server") self._connected = False self._subscription = None self.client.disconnect() self.client = None def subscribe(self, node, handler): if not self._subscription: self._subscription = self.client.create_subscription(500, handler) self._subscription.subscribe_data_change(node) def get_root_attrs(self): return self.get_node_attrs(self.client.get_root_node()) def get_node_attrs(self, node): if not type(node) is Node: node = self.client.get_node(node) attrs = node.get_attributes([AttributeIds.DisplayName, AttributeIds.BrowseName, AttributeIds.NodeId]) return [node] + [attr.Value.Value.to_string() for attr in attrs] def get_children(self, node): descs = node.get_children_descriptions() children = [] for desc in descs: children.append([self.client.get_node(desc.NodeId), desc.DisplayName.to_string(), desc.BrowseName.to_string(), desc.NodeId.to_string()]) return children def get_all_attrs(self, node): names = [] vals = [] for name, val in ua.AttributeIds.__dict__.items(): if not name.startswith("_"): names.append(name) vals.append(val) attrs = node.get_attributes(vals) res = {} for idx, name in enumerate(names): if attrs[idx].StatusCode.is_good(): res[name] = attrs[idx].Value.Value return res def get_all_refs(self, node): return node.get_children_descriptions(refs=ObjectIds.References)
# gettting our namespace idx #uri = "http://examples.freeopcua.github.io" #idx = client.get_namespace_index(uri) # Now getting a variable node using its browse path myvar = root.get_child([ "0:Objects", "{}:MyObject".format(idx), "{}:MyVariable".format(idx) ]) obj = root.get_child(["0:Objects", "{}:MyObject".format(idx)]) print("myvar is: ", myvar) # subscribing to a variable node handler = SubHandler() sub = client.create_subscription(500, handler) handle = sub.subscribe_data_change(myvar) time.sleep(0.1) # we can also subscribe to events from server sub.subscribe_events() # sub.unsubscribe(handle) # sub.delete() # calling a method on server res = obj.call_method("{}:multiply".format(idx), 3, "klk") print("method result is: ", res) embed() finally: client.disconnect()
class OpcClient(): """A simplified OpClient. This is a opc client that can be leveraged to subscribe to the OPC data change notifications. You should interact with the client using * add_notification_handler * subscribe_variable * unsubscribe_variable So typically: ``` # setup client cl = OpcClient(...) # define handler def handler(update): # data update : {'node': <node>, 'timestamp': <datetime>, 'value': <value>, 'data': <data>} # do something with update here # add handler cl.add_notification_handler(handler) # subscribe to variable cl.subscribe_variable(cl.get_node("ns=3;i=2002")) time.sleep(100) cl.disconnect() ``` *Note* Make sure to call disconnect before shutting down in order to ensure a clean close. See: https://github.com/FreeOpcUa/python-opcua Attributes ---------- _address : str The connection string address _address_obfuscated : str The connection string address obfuscating a potnetial password _client : OPCLibClient The opc lib client _subscription : ua.Subscription The ua subscription handle that can be used to create new subscritions or unsubscribe _sub_handles : dict A dictionary mapping ua.Node variables to subscription handles to be able to unsubscribe from them again _handlers : list A list of handler functions """ def __init__(self, host, port, path='/', username=None, password=None): """Create a new OpClient. This will create a new opc client that can be leveraged to subscribe to the OPC data change notifications. Parameters ---------- host : str The host name of the opc server. port : int The port of the opc server. path : str The path to add to the server as base username : str|None A username to use for authorization. password : str|None A password to use for authorization. """ self._client = None self._subscription = None self._sub_handles = {} self._handlers = [] # setup authorization auth = '' if username is not None: auth = '{}:{}@'.format(username, password) # define address self._address = self._address_obfuscated = "opc.tcp://{}{}:{}{}".format( auth, host, port, path) if username is not None and password is not None: self._address_obfuscated = self._address.replace(password, '***') Logger.trace('Created OpcClient', fields={'address': self._address_obfuscated}) # setup client self.init_client() # setup subscriptions self.init_subscriptions() def init_client(self): """Initialize the client. This will connect to the client using the address. This is required to be called before anything else interacting with the opc server is done. """ try: self._client = OPCLibClient(self._address) self._client.connect() self._client.load_type_definitions() self.namespace = self._client.get_namespace_array() Logger.trace('Connection established') except Exception as e: Logger.error('Failed connecting to address "{}"'.format( self._address_obfuscated)) Logger.error('{}'.format(e)) raise e def log_info(self): root = self._client.get_root_node() objects = self._client.get_objects_node() children = root.get_children() # print '{}:{}'.format(namespace[children[1].nodeid.NamespaceIndex], children[1].nodeid.Identifier) # print self._client.get_node("ns=0;i=86") Logger.debug("Retrieved Client Info", fields={ 'root': root, 'objects': objects, 'children': children, 'namespace': self.namespace }) def full_uri(self, node): """Resolve the full uri of a ua.Node. Parameters ---------- node : ua.Node A node from the OPC interface. Returns ------- str : The namespace prefixed full uri of the entity. """ return '{}:{}'.format(self.namespace[node.nodeid.NamespaceIndex], node.nodeid.Identifier) def get_by_uri(self, uri): """Resolve the full uri to a ua.Node. Parameters ---------- uri : str The uri to the ua.Node. Returns ------- ua.Node : The resolved node. """ ns_match = None for ns in self.namespace: if '{}:'.format(ns) in uri: ns_match = ns break if ns_match is None: raise RuntimeError('Namespace of "{}" not available'.format(uri)) ns_idx = self._client.get_namespace_index(ns_match) identifier = uri.replace('{}:'.format(ns_match), '') try: int(identifier) is_int = True except: is_int = False substituted = 'ns={};{}={}'.format(ns_idx, 'i' if is_int else 's', identifier) return self._client.get_node(substituted) def init_subscriptions(self): """Initialize the subscriptions. This will initialize a subscription handler and afterwards will be ready to subscribe to specific variables. """ if self._client is None: raise RuntimeError('Client not initialized yet.') self._subscription = self._client.create_subscription(500, self) Logger.trace('Base Subscription established') def subscribe_variable(self, variable): """Subscribe to a OPC variable. This will subscribe the client to the given variable and any data change notification will be published. Parameters ---------- variable : ua.Node The ua node, e.g. client.get_node(ua.NodeId(1002, 2)) or client.get_node("ns=3;i=2002") """ if self._subscription is None: raise RuntimeError('Subscriptions not initialized yet.') if variable in self._sub_handles.keys(): Logger.info('Already subscribed to "{}"'.format(variable)) return self._sub_handles[variable] = self._subscription.subscribe_data_change( variable) def unsubscribe_variable(self, variable): """Unsubscribe from a OPC variable. This will unsubscribe the client from the given variable. Parameters ---------- variable : ua.Node The ua node, e.g. client.get_node(ua.NodeId(1002, 2)) or client.get_node("ns=3;i=2002") """ if self._subscription is None: raise RuntimeError('Subscriptions not initialized yet.') if variable not in self._sub_handles.keys(): Logger.info('Not subscribed to "{}"'.format(variable)) return self._subscription.unsubscribe(self._sub_handles[variable]) del self._sub_handles[variable] def disconnect(self): """Disconnect the client. """ if self._client is None: return try: self._client.disconnect() except Exception: pass def datachange_notification(self, node, value, data): """Receiver from the OPC client. This gets called by OPC client on subscription notification. Parameter --------- node : ua.Node The node from which we received the data. value : any The value notification data : any The data of the notification """ timestamp = datetime.now() if hasattr(data, 'MonitoredItemNotification') and \ hasattr(data.MonitoredItemNotification, 'SourceTimestamp'): timestamp = data.MonitoredItemNotification.SourceTimestamp Logger.debug('OpcClient: Received data change notification', fields={ 'node': node, 'value': value, 'data': data, 'timestamp': timestamp.isoformat() }) # send update to handlers update = { 'node': node, 'value': value, 'data': data, 'timestamp': timestamp } for hdl in self._handlers: hdl(update) def add_notification_handler(self, handler): """Add a handler function. This handler `def handler(update)` will be called upon reception of a notification from the OPC Client. The update will have the following data: ```{ 'node': <node>, 'value': <value>, 'data': <data>, 'timestamp': <timestamp> }``` """ self._handlers.append(handler)
class ServerConnect(): # WRONG_INPUT_STATE = 0 # SEND_ERRORS = False # whether to send error to OPC server or just show them in console # USE_ACTIVE_STATE = False # STRIP_ACCENTS = True # whether to remove accents before comparing recognized text and possible choices # ALLOW_INTERRUPTIONS = False # whether the user can interupt TTS playback # # MICROPHONE_WAIT_TIMEOUT = 5 # time to wait for any non-zero audio from mic # LISTENING_START_TIMEOUT = 5 # time to start speaking after recognition is ran # PHRASE_TIMEOUT = 4 # maximum length of phrase before listening is cut off # CALIBRATION_TIME = 1 # time to spend calibrating the microphone bgr energy levels def __init__(self, serverAdress, gain: int = 1.0): # instantiate client object; make sure address and port are correct self.client = Client(serverAdress) # self.shouldProcessInput = True # self.LANG = 'cs' # self.recognizer = sr.Recognizer() # self.fast_recognizer = sr.Recognizer() # self.fast_recognizer.non_speaking_duration = 0.05 # self.fast_recognizer.pause_threshold = 0.15 # self.recText = RawNLParser() # self.lastRecognitionFailed = False # self.repeatChoices = False def connect(self): self.client.connect() # connect to server root = self.client.nodes.root # get the root entity print("Connected to server and successfully retrieved the root.") # Retreive some objects and variables dataObj = root.get_child(["0:Objects", "4:DATA"]) # a horse horse = dataObj.get_child("4:horse") # mic_active is the "You can now try recognizing speech" variable self.mic_active = horse.get_child("4:request") # the string where responses (errors and such) should be sent self.response_string = horse.get_child("4:response") # the state change request variable self.request = horse.get_child(["4:next_state_choice", "4:request"]) # self.request.set_value(True) # the number of the state to be changed to self.request_state_num = horse.get_child( ["4:next_state_choice", "4:state_num"]) # the variable with next state choices self.next_state_possibilities = horse.get_child( "4:next_state_possibilities") # self.client.load_type_definitions() # the variable with the current state self.actual_state_number = horse.get_child( ["4:actual_state", "4:number"]) self.sub = self.client.create_subscription(100, self) # create subscription self.handle = self.sub.subscribe_data_change(self.mic_active) def send_state(self, state_num): """ Changes state to the specified number and sets "request" to True. """ dt = ua.DataValue(ua.Variant(state_num, ua.VariantType.Int16)) self.request_state_num.set_value(dt) self.request.set_value(True) # def __extract_directive(self, string): # result = self.hint_directive_re.split(string) # if len(result) > 1: # return result[0], result[1] # else: # return result[0], "" def disconnect(self): try: self.sub.unsubscribe(self.handle) # cancel subscription self.sub.delete() except AttributeError: pass # not subscribed, yet except Exception: print("Error trying to unsubscribe from the mic_active variable!") self.client.disconnect()
def run(): logger.debug("Modular Input mi_opcua_event command: %s" % sys.argv) if len(sys.argv) > 1: try: if sys.argv[1] == "--scheme": do_scheme() elif sys.argv[1] == "--validate-arguments": validate_arguments() elif sys.argv[1] == "--test": test() else: usage() except Exception as ex: logger.critical(ex) else: logger.debug("Modular Input mi_opcua_event Starts data collection.") configs = get_config() logger.debug("Configuration: %s" % configs) stanza = configs["name"] # server_uri = configs["server_uri"] # sessionKey = configs["session_key"] # userName = "******" # make this modular input as application context only. """ wevts = configs["events"].strip() if len(wevts) <= 0: wevts = ["Objects", "Server"] else: wevts = wevts.split(":") patterns = configs["event_types"].strip() if len(patterns) <= 0: patterns = ["*"] else: patterns = patterns.split(":") """ tout = configs["connection_timeout"].strip() timeout = 1 if len(tout) <= 0 else int(tout) cdur = configs["collect_duration"].strip() duration = 1000 if len(cdur) <= 0 else int(cdur) conn = configs["connection"] ## "opc.tcp://ec2-54-190-162-94.us-west-2.compute.amazonaws.com:49320" if configs.has_key("username"): username = configs["username"].strip() if len(username)>0: password = configs["password"].strip() conn = "%s?username=%s&password=%s" % (conn, username, password) client = Client(conn, timeout=timeout) try: client.connect() #root = client.get_root_node() #m = node.get_child(root, wevts) #measures = [] #node.collect_measures(measures, wevts, root) handler = SubHandler(stanza) sub = client.create_subscription(duration, handler) h = sub.subscribe_events() """ handles = [] for evt in measures: try: h = sub.subscribe_events(evt[len(evt)-1]) handles.append(h) except Exception as ex: logger.warn(ex) """ def signal_handler(signal, frame): logger.info('Press Ctrl+C') if signal in [signal.SIGABRT, signal.SIGINT, signal.SIGQUIT, signal.SIGTERM]: #[sub.unsubscribe(h) for h in handles] sub.unsubscribe(h) sub.delete() client.disconnect() signal.signal(signal.SIGINT, signal_handler) signal.signal(signal.SIGABRT, signal_handler) signal.signal(signal.SIGTERM, signal_handler) # signal.signal(signal.SIGQUIT, signal_handler) # signal.pause() except Exception as ex: logger.critical(ex) finally: logger.info("---- end of sub opc ua event ----")
class OpcUaConnector(Thread, Connector): def __init__(self, gateway, config, connector_type): self.__connector_type = connector_type self.statistics = {'MessagesReceived': 0, 'MessagesSent': 0} super().__init__() self.__gateway = gateway self.__server_conf = config.get("server") self.__interest_nodes = [] self.__available_object_resources = {} for mapping in self.__server_conf["mapping"]: if mapping.get("deviceNodePattern") is not None: self.__interest_nodes.append( {mapping["deviceNodePattern"]: mapping}) else: log.error( "deviceNodePattern in mapping: %s - not found, add property deviceNodePattern to processing this mapping", dumps(mapping)) if "opc.tcp" not in self.__server_conf.get("url"): opcua_url = "opc.tcp://" + self.__server_conf.get("url") else: opcua_url = self.__server_conf.get("url") self.client = Client( opcua_url, timeout=self.__server_conf.get("timeoutInMillis", 4000) / 1000) if self.__server_conf["identity"]["type"] == "cert.PEM": try: ca_cert = self.__server_conf["identity"].get("caCert") private_key = self.__server_conf["identity"].get("privateKey") cert = self.__server_conf["identity"].get("cert") security_mode = self.__server_conf["identity"].get( "mode", "SignAndEncrypt") policy = self.__server_conf["security"] if cert is None or private_key is None: log.exception( "Error in ssl configuration - cert or privateKey parameter not found" ) raise security_string = policy + ',' + security_mode + ',' + cert + ',' + private_key if ca_cert is not None: security_string = security_string + ',' + ca_cert self.client.set_security_string(security_string) except Exception as e: log.exception(e) if self.__server_conf["identity"].get("username"): self.client.set_user( self.__server_conf["identity"].get("username")) if self.__server_conf["identity"].get("password"): self.client.set_password( self.__server_conf["identity"].get("password")) self.setName( self.__server_conf.get( "name", 'OPC-UA Default ' + ''.join(choice(ascii_lowercase) for _ in range(5))) + " Connector") self.__opcua_nodes = {} self._subscribed = {} self.data_to_send = [] self.__sub_handler = SubHandler(self) self.__stopped = False self.__connected = False self.daemon = True def is_connected(self): return self.__connected def open(self): self.__stopped = False self.start() log.info("Starting OPC-UA Connector") def run(self): while not self.__connected: try: self.__connected = self.client.connect() self.client.load_type_definitions() log.debug(self.client.get_namespace_array()[-1]) log.debug( self.client.get_namespace_index( self.client.get_namespace_array()[-1])) except ConnectionRefusedError: log.error( "Connection refused on connection to OPC-UA server with url %s", self.__server_conf.get("url")) time.sleep(10) except Exception as e: log.debug("error on connection to OPC-UA server.") log.error(e) time.sleep(10) else: self.__connected = True log.info("OPC-UA connector %s connected to server %s", self.get_name(), self.__server_conf.get("url")) self.__opcua_nodes["root"] = self.client.get_root_node() self.__opcua_nodes["objects"] = self.client.get_objects_node() sub = self.client.create_subscription( self.__server_conf.get("scanPeriodInMillis", 500), self.__sub_handler) self.__search_name(self.__opcua_nodes["objects"], 2) self.__search_tags(self.__opcua_nodes["objects"], 2, sub) log.debug('Subscriptions: %s', self.subscribed) log.debug("Available methods: %s", self.__available_object_resources) while True: try: time.sleep(1) if self.data_to_send: self.__gateway.send_to_storage(self.get_name(), self.data_to_send.pop()) if self.__stopped: break except (KeyboardInterrupt, SystemExit): self.close() raise except Exception as e: self.close() log.exception(e) def close(self): self.__stopped = True self.client.disconnect() self.__connected = False log.info('%s has been stopped.', self.get_name()) def get_name(self): return self.name def on_attributes_update(self, content): log.debug(content) try: for server_variables in self.__available_object_resources[ content["device"]]['variables']: for attribute in content["data"]: for variable in server_variables: if attribute == variable: server_variables[variable].set_value( content["data"][variable]) except Exception as e: log.exception(e) def server_side_rpc_handler(self, content): try: for method in self.__available_object_resources[ content["device"]]['methods']: rpc_method = content["data"].get("method") if rpc_method is not None and method.get( rpc_method) is not None: arguments = content["data"].get("params") if type(arguments) is list: result = method["node"].call_method( method[rpc_method], *arguments) elif arguments is not None: result = method["node"].call_method( method[rpc_method], arguments) else: result = method["node"].call_method(method[rpc_method]) self.__gateway.send_rpc_reply( content["device"], content["data"]["id"], {content["data"]["method"]: result}) log.debug("method %s result is: %s", method[rpc_method], result) except Exception as e: log.exception(e) def __search_name(self, node, recursion_level): try: for childId in node.get_children(): ch = self.client.get_node(childId) current_var_path = '.'.join( x.split(":")[1] for x in ch.get_path(20000, True)) if self.__interest_nodes: if ch.get_node_class() == ua.NodeClass.Object: for interest_node in self.__interest_nodes: for int_node in interest_node: subrecursion_level = recursion_level if subrecursion_level != recursion_level + len( interest_node[int_node] ["deviceNamePattern"].split("\\.")): if ch.get_display_name().Text in TBUtility.get_value(interest_node[int_node]["deviceNamePattern"], get_tag=True).split('.') or \ re.search(TBUtility.get_value(interest_node[int_node]["deviceNodePattern"], get_tag=True), ch.get_display_name().Text): self.__search_name( ch, subrecursion_level + 1) else: return elif ch.get_node_class() == ua.NodeClass.Variable: try: for interest_node in self.__interest_nodes: for int_node in interest_node: if interest_node[int_node].get( "deviceName") is None: try: name_pattern = TBUtility.get_value( interest_node[int_node] ["deviceNamePattern"], get_tag=True) log.debug(current_var_path) device_name_node = re.search( name_pattern.split('\\.')[-1], current_var_path) if device_name_node is not None: device_name = ch.get_value() if "${" + name_pattern + "}" in interest_node[ int_node][ "deviceNamePattern"]: full_device_name = interest_node[ int_node][ "deviceNamePattern"].replace( "${" + name_pattern + "}", device_name) elif device_name in interest_node[ int_node][ "deviceNamePattern"]: full_device_name = interest_node[ int_node][ "deviceNamePattern"].replace( name_pattern, device_name) else: log.error( "Name pattern not found." ) break interest_node[int_node][ "deviceName"] = full_device_name if self.__available_object_resources.get( full_device_name ) is None: self.__available_object_resources[ full_device_name] = { 'methods': [], 'variables': [] } if not self.__gateway.get_devices( ).get(full_device_name): self.__gateway.add_device( full_device_name, {"connector": None}) self.__gateway.update_device( full_device_name, "connector", self) else: try: if re.search( int_node.split( '\\.') [recursion_level - 2], ch. get_display_name( ).Text): self.__search_name( ch, recursion_level + 1) except IndexError: if re.search( int_node.split( '\\.')[-1], ch. get_display_name( ).Text): self.__search_name( ch, recursion_level + 1) except Exception as e: log.exception(e) else: break except BadWaitingForInitialData: pass elif not self.__interest_nodes: log.error( "Nodes in mapping not found, check your settings.") except Exception as e: log.exception(e) def __search_tags(self, node, recursion_level, sub=None): try: for childId in node.get_children(): ch = self.client.get_node(childId) current_var_path = '.'.join( x.split(":")[1] for x in ch.get_path(20000, True)) if self.__interest_nodes: if ch.get_node_class() == ua.NodeClass.Object: for interest_node in self.__interest_nodes: for int_node in interest_node: try: name_to_check = int_node.split('\\.')[ recursion_level - 1] if '\\.' in int_node else int_node name_to_check = int_node.split( '.' )[recursion_level - 1] if '.' in int_node else name_to_check except IndexError: name_to_check = int_node.split( '\\.' )[-1] if '\\.' in int_node else int_node name_to_check = int_node.split( '.' )[-1] if '.' in int_node else name_to_check if re.search(name_to_check, ch.get_display_name().Text): try: methods = ch.get_methods() for method in methods: self.__available_object_resources[ interest_node[int_node] ["deviceName"]][ "methods"].append({ method.get_display_name( ).Text: method, "node": ch }) except Exception as e: log.exception(e) for tag in interest_node[int_node][ "timeseries"] + interest_node[ int_node]["attributes"]: subrecursion_level = recursion_level if subrecursion_level != recursion_level + len( tag["path"].split("\\.")): self.__search_tags( ch, subrecursion_level + 1, sub) else: return self.__search_tags(ch, recursion_level + 1, sub) elif ch.get_node_class() == ua.NodeClass.Variable: try: for interest_node in self.__interest_nodes: for int_node in interest_node: if interest_node[int_node].get( "attributes_updates"): try: for attribute_update in interest_node[ int_node][ "attributes_updates"]: if attribute_update[ "attributeOnDevice"] == ch.get_display_name( ).Text: self.__available_object_resources[ interest_node[int_node] ["deviceName"]][ 'variables'].append({ attribute_update["attributeOnThingsBoard"]: ch, }) except Exception as e: log.exception(e) name_to_check = int_node.split( '\\.' )[-1] if '\\.' in int_node else int_node name_to_check = int_node.split( '.' )[-1] if '.' in int_node else name_to_check if re.search( name_to_check.replace('$', ''), current_var_path): tags = [] if interest_node[int_node].get( "attributes"): tags.extend(interest_node[int_node] ["attributes"]) if interest_node[int_node].get( "timeseries"): tags.extend(interest_node[int_node] ["timeseries"]) for tag in tags: target = TBUtility.get_value( tag["path"], get_tag=True) try: tag_name_for_check = target.split( '\\.' )[recursion_level - 1] if '\\.' in target else target tag_name_for_check = target.split( '.' )[recursion_level - 1] if '.' in target else tag_name_for_check except IndexError: tag_name_for_check = target.split( '\\.' )[-1] if '\\.' in target else target tag_name_for_check = target.split( '.' )[-1] if '.' in target else tag_name_for_check current_node_name = ch.get_display_name( ).Text if current_node_name == tag_name_for_check: sub.subscribe_data_change(ch) if interest_node[int_node].get( "uplink_converter" ) is None: if interest_node[ int_node].get( 'converter' ) is None: converter = OpcUaUplinkConverter( interest_node[ int_node]) else: converter = TBUtility.check_and_import( self. __connector_type, interest_node[ int_node] ['converter']) interest_node[int_node][ "uplink_converter"] = converter else: converter = interest_node[ int_node][ "uplink_converter"] self.subscribed[ch] = { "converter": converter, "path": current_var_path } else: return except BadWaitingForInitialData: pass elif not self.__interest_nodes: log.error( "Nodes in mapping not found, check your settings.") except Exception as e: log.exception(e) @property def subscribed(self): return self._subscribed
class UaClient(object): """ OPC-Ua client specialized for the need of GUI client return exactly whant GUI needs, no customization possible """ def __init__(self): self.client = None self._connected = False self._subscription = None def connect(self, uri): self.disconnect() print("Connecting to ", uri) self.client = Client(uri) self.client.connect() self._connected = True print("Connected, root is: ", self.client.get_root_node()) print(self.get_root_attrs()) def disconnect(self): if self._connected: print("Disconnecting from server") self._connected = False self._subscription = None self.client.disconnect() self.client = None def subscribe(self, node, handler): if not self._subscription: self._subscription = self.client.create_subscription(500, handler) self._subscription.subscribe_data_change(node) def get_root_attrs(self): return self.get_node_attrs(self.client.get_root_node()) def get_node_attrs(self, node): if not type(node) is Node: node = self.client.get_node(node) attrs = node.get_attributes([ AttributeIds.DisplayName, AttributeIds.BrowseName, AttributeIds.NodeId ]) return [node] + [attr.Value.Value.to_string() for attr in attrs] def get_children(self, node): descs = node.get_children_descriptions() children = [] for desc in descs: children.append([ self.client.get_node(desc.NodeId), desc.DisplayName.to_string(), desc.BrowseName.to_string(), desc.NodeId.to_string() ]) return children def get_all_attrs(self, node): names = [] vals = [] for name, val in ua.AttributeIds.__dict__.items(): if not name.startswith("_"): names.append(name) vals.append(val) attrs = node.get_attributes(vals) res = {} for idx, name in enumerate(names): if attrs[idx].StatusCode.is_good(): res[name] = attrs[idx].Value.Value return res def get_all_refs(self, node): return node.get_children_descriptions(refs=ObjectIds.References)
class Client_opc(): def __init__(self, cert_path, server_path, policy, mode, AggrObject, handle_dict): self.cert_path = cert_path #certificates path self.server_path = server_path self.policy = policy self.mode = mode self.AggrObject = AggrObject self.handle_dict = handle_dict #istantiating Client calling "Client" constructor into stack opcua, set name and calling set_security_string method in the stack def client_instantiate(self): self.client = Client(self.server_path) #instaniate client self.client.name = "AggregationClient" if ((self.policy != "None") and (self.mode != "None")): #this method take a string as input that contains policy, mode, client certificate path and private key path. The endpoint that satisfies this characteristichs is choosed self.client.set_security_string(self.policy+","+self.mode+","+self.cert_path+"client_certificate.der,"+self.cert_path+"client_private_key.pem") #SecurityPolicy, Mode, Certificate path, Private key path #This method call the "connect" method in the stack. This method creates secure channel, create the session and activate it def secure_channel_and_session_activation(self): #params requested from the client. Server can set another value based on its requirements self.client.secure_channel_timeout = 10000 self.client.session_timeout = 10000 try: self.client.connect() #create secure channel and session; activate session print("Client instantiated; secure channel and session created; session activated ") except: #if exception occures, disconnect the client self.client.disconnect() #This method disconnect the client from the server, closing session and secure channel def disconnect(self): self.client.disconnect() #This method is called when we want only to read Data def readData(self,node_id, polling_dict): #Get node node = self.client.get_node(node_id) #Client.py stack function #Get values value = node.get_data_value() #Node.py stack function print(f"Polling Service readed value : {value} ") #Set readed values in the local variables AggrVar = self.AggrObject.get_variables() for var in AggrVar: for key in polling_dict: remote_node = self.client.get_node(polling_dict[key]) if(remote_node == node and str(var.nodeid) == key): var.set_value(value) '''This method is our stack method revisitation to set our parameter values''' #This method is used in the "subscribe" method to create the filter for making the monitored item request def set_datachange_filter(self, deadband_val, deadbandtype=1): deadband_filter = ua.DataChangeFilter() deadband_filter.Trigger = ua.DataChangeTrigger(1) # send notification when status or value change deadband_filter.DeadbandType = deadbandtype #type = 0 -> notification every change; type = 1 -> absolute deadband_val is considered; type = 2 -> percent deadband_val is considered deadband_filter.DeadbandValue = deadband_val return deadband_filter '''This method is our stack method revisitation to set our parameter values''' #This method is called in the "subscribe" method for creating the monitored items for the nodes passed. def create_monitored_item(self, subscription, nodes , sampling_interval, client_handle, filter=None, queuesize = 0, discard_oldest = True, attr=ua.AttributeIds.Value): is_list = True if isinstance(nodes, Iterable): nodes = list(nodes) else: nodes = [nodes] is_list = False mirs = [] for node in nodes: mir = self.make_monitored_item_request(subscription, node, attr, sampling_interval, client_handle, filter, queuesize, discard_oldest) #making monitored item request mirs.append(mir) mids = subscription.create_monitored_items(mirs) if is_list: return mids if type(mids[0]) == ua.StatusCode: mids[0].check() return mids[0] #return a list of handles (monitored item ids) '''This method is our stack method revisitation to set our parameter values''' #This method sets our params obtained from the conf file and make the monitored item request def make_monitored_item_request(self, subscription, node, attr, sampling_interval, client_handle, filter, queuesize, discard_oldest): rv = ua.ReadValueId() rv.NodeId = node.nodeid rv.AttributeId = attr mparams = ua.MonitoringParameters() with subscription._lock: subscription._client_handle = client_handle mparams.ClientHandle = subscription._client_handle mparams.SamplingInterval = sampling_interval mparams.QueueSize = queuesize mparams.DiscardOldest = discard_oldest if filter: mparams.Filter = filter mir = ua.MonitoredItemCreateRequest() #stack request mir.ItemToMonitor = rv mir.MonitoringMode = ua.MonitoringMode.Reporting mir.RequestedParameters = mparams return mir #This method is called when we want only to subscribe to Data. It takes as input sub infos and mon_item infos from conf file def subscribe(self, monitored_nodes, sub_infos): #Create the handlers handler = [] for i in range(len(sub_infos)): handler.append(SubHandler(self.AggrObject, self.handle_dict)) #Creating a subscription for ech 'sub_infos' element in the config file (different types of subscriptions -> different parameters) sub = [] sub_index_list = [] for i in range(len(monitored_nodes)): sub_index_list.append(monitored_nodes[i]["subIndex"]) for i in range(len(sub_infos)): if(i in sub_index_list): #Set sub parameters params = ua.CreateSubscriptionParameters() params.RequestedPublishingInterval = sub_infos[i]['requested_publish_interval'] params.RequestedLifetimeCount = sub_infos[i]['requested_lifetime_count'] params.RequestedMaxKeepAliveCount = sub_infos[i]['requested_max_keepalive_timer'] params.MaxNotificationsPerPublish = sub_infos[i]['max_notif_per_publish'] params.PublishingEnabled = sub_infos[i]['publishing_enabled'] params.Priority = sub_infos[i]['priority'] #Create the subscription sub.append(self.client.create_subscription(params, handler[i])) #handle will contains mon_item_ids handle = [] Aggr_key = [] for key in self.handle_dict: Aggr_key.append(key) for i in range(len(monitored_nodes)): filter = self.set_datachange_filter(monitored_nodes[i]['deadbandval'], monitored_nodes[i]['deadbandtype']) #Set filter from config parameters setted in the config file handle.append(self.create_monitored_item(sub[monitored_nodes[i]['subIndex']], self.client.get_node(monitored_nodes[i]['nodeTomonitor']), monitored_nodes[i]['sampling_interval'] ,self.handle_dict[Aggr_key[i]], filter, monitored_nodes[i]['queue_size'], monitored_nodes[i]['discard_oldest'])) #handle = list of monitored items ids #handler.datachange_notification is called when a value of the monitored nodes has changed return sub, handle #This method take as input the subscription list and handle list of monitored items that we want to delete def delete_monit_items(self, sub, handle): for i in range(len(sub)): for mid in handle: try: #stack function called on the subscription sub[i].unsubscribe(mid) #unsubscribe to data_change/events of the selected monitored items (handle -> list of monitored items ids) except ua.uaerrors._auto.BadMonitoredItemIdInvalid: #This except is added because we call the unsubscribe stack method (delete monitored_item) for every subscription, but the monitored item is present only in one of them #So, in the other subscriptions, the BadMonitoredItemInvalid is raised, but we want to ignore this error pass #This method takes as input the subscriptions list and delete them def delete_sub(self, sub): try: for i in range(len(sub)): sub[i].delete() #Stack method call on the subscription(this method delete every monitored item in the subscription and delete the subscription) except Exception: print("An Error was occured in client.delete function!")
args=(node, val)) # Se realiza la descarga por un thread thread_handler.start() def event_notification(self, event): global evento_alarma evento_alarma = event #print(event) eventos = rootNode.get_child( ["0:Types", "0:EventTypes", "0:BaseEventType", "2:Alarma_nivel"]) # TIPO DE EVENTO obj_evento = objectsNode.get_child( ['2:Proceso_Tanques', '2:Alarmas', '2:Alarma_nivel']) # OBJETO EVENTO handler_event = SubHandler() sub_event = client.create_subscription(100, handler_event) #Subscripción al evento handle_event = sub_event.subscribe_events(obj_evento, eventos) ######################################################################### def funcion_guardado(mem_pd, T_init, T_now): global extension nombre = f"{T_init} - {T_now}{extension}" if extension == '.csv': mem_pd.to_csv(nombre) elif extension == '.txt': mem_npy = mem_pd.to_numpy() np.savetxt(nombre, mem_npy, fmt='%s') elif extension == '.npy': mem_npy = mem_pd.to_numpy()
class Cliente(): def __init__(self, direccion, suscribir_eventos, SubHandler): self.direccion = direccion self.client = Client(direccion) self.alturas = {'H1': 0, 'H2': 0, 'H3':0, 'H4':0} self.temperaturas = {'T1': 0, 'T2': 0, 'T3':0, 'T4':0} self.valvulas = {'valvula1':0, 'valvula2':0} self.razones = {'razon1':0, 'razon2': 0} self.subscribir_eventos = suscribir_eventos self.periodo = 100 # cantidad de milisegundos para revisar las variables subscritas self.SubHandlerClass = SubHandler def Instanciacion(self): self.root = self.client.get_root_node() self.objects = self.client.get_objects_node() self.Tanques = self.objects.get_child(['2:Proceso_Tanques','2:Tanques']) self.Valvulas = self.objects.get_child(['2:Proceso_Tanques', '2:Valvulas']) self.Razones = self.objects.get_child(['2:Proceso_Tanques', '2:Razones']) # Obtención de las alturas self.alturas['H1'] = self.Tanques.get_child(['2:Tanque1', '2:h']) self.alturas['H2'] = self.Tanques.get_child(['2:Tanque2', '2:h']) self.alturas['H3'] = self.Tanques.get_child(['2:Tanque3', '2:h']) self.alturas['H4'] = self.Tanques.get_child(['2:Tanque4', '2:h']) # Obtención de temperaturas self.temperaturas['T1'] = self.Tanques.get_child(['2:Tanque1', '2:T']) self.temperaturas['T2'] = self.Tanques.get_child(['2:Tanque2', '2:T']) self.temperaturas['T3'] = self.Tanques.get_child(['2:Tanque3', '2:T']) self.temperaturas['T4'] = self.Tanques.get_child(['2:Tanque4', '2:T']) # Obtención de los pumps self.valvulas['valvula1'] = self.Valvulas.get_child(['2:Valvula1', '2:u']) self.valvulas['valvula2'] = self.Valvulas.get_child(['2:Valvula2', '2:u']) # Obtención de los switches self.razones['razon1'] = self.Razones.get_child(['2:Razon1', '2:gamma']) self.razones['razon2'] = self.Razones.get_child(['2:Razon2', '2:gamma']) # Evento (alarma en este caso) if self.subscribir_eventos: self.myevent = self.root.get_child(["0:Types", "0:EventTypes", "0:BaseEventType", "2:Alarma_nivel"])#Tipo de evento self.obj_event = self.objects.get_child(['2:Proceso_Tanques', '2:Alarmas', '2:Alarma_nivel'])#Objeto Evento self.handler_event = self.SubHandlerClass() self.sub_event = self.client.create_subscription(self.periodo, self.handler_event)#Subscripción al evento self.handle_event = self.sub_event.subscribe_events(self.obj_event, self.myevent) def subscribir_cv(self): # Subscripción a las variables controladas self.handler_cv = self.SubHandlerClass() self.sub_cv = self.client.create_subscription(self.periodo, self.handler_cv) for key, var in self.alturas.items(): self.sub_cv.subscribe_data_change(var) for key, var in self.temperaturas.items(): self.sub_cv.subscribe_data_change(var) def subscribir_mv(self): # Subscripación a las variables manipuladas self.handler_mv = self.SubHandlerClass() self.sub_mv = self.client.create_subscription(self.periodo, self.handler_mv) for key, var in self.valvulas.items(): self.sub_mv.subscribe_data_change(var) for key, var in self.razones.items(): self.sub_mv.subscribe_data_change(var) def conectar(self): self.client.connect() self.objects = self.client.get_objects_node() print('Cliente OPCUA se ha conectado') self.Instanciacion() #self.client.disconnect() #print('Cliente no se ha podido conectar') #cliente = Cliente("opc.tcp://localhost:4840/freeopcua/server/", suscribir_eventos=True, SubHandlerClass=SubHandler) #cliente.conectar() #cliente.subscribir_mv() # Se subscribe a las variables manipuladas
class Plant(threading.Thread): def __init__(self, ip): super().__init__() self.client = Client(ip) self.objects = self.assign_object() self.heights = {'h1': 0, 'h2': 0, 'h3': 0, 'h4': 0} self._u = [0, 0] self.sample_time = 0.001 self.daemon = True ## Que termine de medir cuando termine el programa (debug) self.event_measure = threading.Event() def assign_object(self): """Conecta el cliente y retorna el objeto donde se encuentra la planta en el servidor""" self.client.connect() return self.client.get_objects_node() def get_heights(self): """Obtiene las alturas y las almacena en un diccionario con indices h1, h2, h3, h4""" for i in range(1, 5): node = self.objects.get_child([ '2:Parametros', f'2:Altura {i}' ]) ## '2:Proceso_Tanques', '2:Tanques', f'2:Tanque{i}', '2:h' self.heights[f'h{i}'] = node.get_value( ) #NoneType object does not support item assig def get_show_heights(self): return [x for x in self.heights.values()] def suscribe_alarm(self): """Suscribe la alarma que esta overwrited en la clase SubHandler""" alarm = self.objects.get_child( ['2:Proceso_Tanques', '2:Alarmas', f'2:Alarma_nivel']) handler = SubHandler() sub = self.client.create_subscription(500, handler) handle = sub.subscribe_events(alarm) time.sleep(0.1) def assign_valve_value(self): """Constantemente, asigna las variablaes almacenadas en el atributo self.u, a la planta""" u1 = self.objects.get_child([ '2:Parametros', '2: Válvula 1' ]) ## '2:Proceso_Tanques', '2:Valvulas', f'2:Valvula1', '2:u' u2 = self.objects.get_child([ '2:Parametros', '2: Válvula 2' ]) ## '2:Proceso_Tanques', '2:Valvulas', f'2:Valvula2', '2:u' u1.set_value(self.u[0]) u2.set_value(self.u[1]) @property def u(self): return self._u @u.setter def u(self, value): if not None in value: self._u = list(value) else: self._u = self._u def run(self): # self.suscribe_alarm() // no hay alarma en simulacion while True: if sum(self.u) > 0: self.assign_valve_value() self.u = [0, 0] self.event_measure.set( ) ## Revisar esto porque no se esta cumpliendo self.get_heights() time.sleep(self.sample_time)
print("New event recived: ", event) if __name__ == "__main__": client = Client("opc.tcp://*****:*****@localhost:4840/freeopcua/server/") #connect using a user try: client.connect() # Client has a few methods to get proxy to UA nodes that should always be in address space such as Root or Objects root = client.get_root_node() print("Objects node is: ", root) # Now getting a variable node using its browse path obj = root.get_child(["0:Objects", "2:MyObject"]) print("MyObject is: ", obj) myevent = root.get_child(["0:Types", "0:EventTypes", "0:BaseEventType", "2:MyFirstEvent"]) print("MyFirstEventType is: ", myevent) msclt = SubHandler() sub = client.create_subscription(100, msclt) handle = sub.subscribe_events(obj, myevent) embed() sub.unsubscribe(handle) sub.delete() finally: client.disconnect()
class OpcProtocol(): ''' OPC Protocol settings ''' def string_to_node_type(self, type='string'): if type == 'string': return ua.NodeIdType.String elif type == 'numeric': return ua.NodeIdType.Numeric else: return ua.NodeIdType.ByteString def __del__(self): self.Disconnect() def __init__(self, server_name): self.server_name = server_name namespaces = VAR.OPC_SERVERS[server_name]["namespaces"] # Get OPC UA node type for namespace in namespaces.keys(): nodes = VAR.OPC_SERVERS[server_name]["namespaces"][namespace]["nodes"] for node in nodes: type = nodes[node]["opc_type"] nodes[node]["opc_type"] = self.string_to_node_type(type) self.Connect() def Connect(self): ''' For creating connection to OPC UA Server ''' server = VAR.OPC_SERVERS[self.server_name]["opc_server"] namespaces = VAR.OPC_SERVERS[self.server_name]["namespaces"] self.client = Client(server) try: self.client.connect() for namespace in namespaces.keys(): VAR.OPC_SERVERS[self.server_name]["namespaces"][namespace]["index"] = self.client.get_namespace_index(namespace) except Exception as e: print('Connect error:', e) finally: self.firstrun() def remove_subscribe(self): namespaces = VAR.OPC_SERVERS[self.server_name]["namespaces"] for namespace in namespaces.keys(): nodes = VAR.OPC_SERVERS[self.server_name]['namespaces'][namespace]["nodes"] for node in nodes.keys(): VAR.OPC_SERVERS[self.server_name]['namespaces'][namespace]["nodes"][node]["subscribe"].unsubscribe( VAR.OPC_SERVERS[self.server_name]['namespaces'][namespace]["nodes"][node]["handler"] ) VAR.OPC_SERVERS[self.server_name]['namespaces'][namespace]["nodes"][node]["subscribe"].delete() return True def Disconnect(self): ''' Disconnect from OPC UA Server ''' try: self.remove_subscribe() self.client.disconnect() except Exception as e: print('Disconnect error:', e) return "disconnect done" def create_node(self, node, namespace, type): return ua.NodeId(identifier=node, namespaceidx=namespace, nodeidtype=type) def firstrun(self): ''' When OPC UA Server connection has been established, do this once ''' try: if VAR.FIRST_RUN: namespaces = VAR.OPC_SERVERS[self.server_name]["namespaces"] for namespace in namespaces.keys(): index = VAR.OPC_SERVERS[self.server_name]["namespaces"][namespace]["index"] nodes = VAR.OPC_SERVERS[self.server_name]["namespaces"][namespace]["nodes"] for node in nodes.keys(): type = VAR.OPC_SERVERS[self.server_name]["namespaces"][namespace]["nodes"][node]["opc_type"] nodeid = self.create_node(node, index, type) VAR.OPC_SERVERS[self.server_name]["namespaces"][namespace]["nodes"][node]["opc_nodeid"] = nodeid this_node = self.client.get_node(nodeid) VAR.OPC_SERVERS[self.server_name]["namespaces"][namespace]["nodes"][node]["opc_variable"] = this_node value = this_node.get_value() VAR.OPC_SERVERS[self.server_name]["namespaces"][namespace]["nodes"][node]["value"] = value VAR.OPC_SERVERS[self.server_name]["namespaces"][namespace]["nodes"][node]["timestamp"] = str(datetime.datetime.utcnow()) VAR.OPC_SERVERS[self.server_name]["namespaces"][namespace]["nodes"][node]["handler"] = NodeHandler(self.server_name, namespace) VAR.OPC_SERVERS[self.server_name]["namespaces"][namespace]["nodes"][node]["subscribe"] = self.client.create_subscription( 100, VAR.OPC_SERVERS[self.server_name]["namespaces"][namespace]["nodes"][node]["handler"] ) VAR.OPC_SERVERS[self.server_name]["namespaces"][namespace]["nodes"][node]["subscribe"].subscribe_data_change(this_node) except Exception as e: print('firstRun error:', e) finally: VAR.FIRST_RUN = False def reset(self): self.remove_subscribe() VAR.FIRST_RUN = True self.firstrun()
class OpcUaConnector(Thread, Connector): def __init__(self, gateway, config, connector_type): self._connector_type = connector_type self.statistics = {'MessagesReceived': 0, 'MessagesSent': 0} super().__init__() self.__gateway = gateway self.__server_conf = config.get("server") self.__interest_nodes = [] self.__available_object_resources = {} self.__show_map = self.__server_conf.get("showMap", False) self.__previous_scan_time = 0 for mapping in self.__server_conf["mapping"]: if mapping.get("deviceNodePattern") is not None: self.__interest_nodes.append( {mapping["deviceNodePattern"]: mapping}) else: log.error( "deviceNodePattern in mapping: %s - not found, add property deviceNodePattern to processing this mapping", dumps(mapping)) if "opc.tcp" not in self.__server_conf.get("url"): opcua_url = "opc.tcp://" + self.__server_conf.get("url") else: opcua_url = self.__server_conf.get("url") self.client = Client( opcua_url, timeout=self.__server_conf.get("timeoutInMillis", 4000) / 1000) if self.__server_conf["identity"]["type"] == "cert.PEM": try: ca_cert = self.__server_conf["identity"].get("caCert") private_key = self.__server_conf["identity"].get("privateKey") cert = self.__server_conf["identity"].get("cert") security_mode = self.__server_conf["identity"].get( "mode", "SignAndEncrypt") policy = self.__server_conf["security"] if cert is None or private_key is None: log.exception( "Error in ssl configuration - cert or privateKey parameter not found" ) raise security_string = policy + ',' + security_mode + ',' + cert + ',' + private_key if ca_cert is not None: security_string = security_string + ',' + ca_cert self.client.set_security_string(security_string) except Exception as e: log.exception(e) if self.__server_conf["identity"].get("username"): self.client.set_user( self.__server_conf["identity"].get("username")) if self.__server_conf["identity"].get("password"): self.client.set_password( self.__server_conf["identity"].get("password")) self.setName( self.__server_conf.get( "name", 'OPC-UA ' + ''.join(choice(ascii_lowercase) for _ in range(5))) + " Connector") self.__opcua_nodes = {} self._subscribed = {} self.data_to_send = [] self.__sub_handler = SubHandler(self) self.__stopped = False self.__connected = False self.daemon = True def is_connected(self): return self.__connected def open(self): self.__stopped = False self.start() log.info("Starting OPC-UA Connector") def run(self): while not self.__connected: try: self.__connected = self.client.connect() try: self.client.load_type_definitions() except Exception as e: log.debug(e) log.debug("Error on loading type definitions.") log.debug(self.client.get_namespace_array()[-1]) log.debug( self.client.get_namespace_index( self.client.get_namespace_array()[-1])) except ConnectionRefusedError: log.error( "Connection refused on connection to OPC-UA server with url %s", self.__server_conf.get("url")) time.sleep(10) except OSError: log.error( "Connection refused on connection to OPC-UA server with url %s", self.__server_conf.get("url")) time.sleep(10) except Exception as e: log.debug("error on connection to OPC-UA server.") log.error(e) time.sleep(10) else: self.__connected = True log.info("OPC-UA connector %s connected to server %s", self.get_name(), self.__server_conf.get("url")) self.__opcua_nodes["root"] = self.client.get_objects_node() self.__opcua_nodes["objects"] = self.client.get_objects_node() if not self.__server_conf.get("disableSubscriptions", False): self.__sub = self.client.create_subscription( self.__server_conf.get("subCheckPeriodInMillis", 500), self.__sub_handler) else: self.__sub = False self.__scan_nodes_from_config() self.__previous_scan_time = time.time() * 1000 log.debug('Subscriptions: %s', self.subscribed) log.debug("Available methods: %s", self.__available_object_resources) while not self.__stopped: try: time.sleep(.1) self.__check_connection() if not self.__connected and not self.__stopped: self.client.connect() elif not self.__stopped: if self.__server_conf.get( "disableSubscriptions", False ) and time.time( ) * 1000 - self.__previous_scan_time > self.__server_conf.get( "scanPeriodInMillis", 60000): self.__scan_nodes_from_config() self.__previous_scan_time = time.time() * 1000 if self.data_to_send: self.__gateway.send_to_storage(self.get_name(), self.data_to_send.pop()) if self.__stopped: self.close() break except (KeyboardInterrupt, SystemExit): self.close() raise except ConnectionRefusedError: log.error( "Connection refused on connection to OPC-UA server with url %s", self.__server_conf.get("url")) time.sleep(10) except Exception as e: self.close() log.exception(e) def __check_connection(self): try: node = self.client.get_root_node() node.get_children() self.__connected = True except ConnectionRefusedError: self.__connected = False self._subscribed = {} self.__sub = None except OSError: self.__connected = False self._subscribed = {} self.__sub = None except TimeoutError: self.__connected = False self._subscribed = {} self.__sub = None except AttributeError: self.__connected = False self._subscribed = {} self.__sub = None except Exception as e: self.__connected = False self._subscribed = {} self.__sub = None log.exception(e) def close(self): self.__stopped = True if self.__connected: self.client.disconnect() self.__connected = False log.info('%s has been stopped.', self.get_name()) def get_name(self): return self.name def on_attributes_update(self, content): log.debug(content) try: for server_variables in self.__available_object_resources[ content["device"]]['variables']: for attribute in content["data"]: for variable in server_variables: if attribute == variable: server_variables[variable].set_value( content["data"][variable]) except Exception as e: log.exception(e) def server_side_rpc_handler(self, content): try: for method in self.__available_object_resources[ content["device"]]['methods']: rpc_method = content["data"].get("method") if rpc_method is not None and method.get( rpc_method) is not None: arguments_from_config = method["arguments"] arguments = content["data"].get( "params") if content["data"].get( "params") is not None else arguments_from_config try: if type(arguments) is list: result = method["node"].call_method( method[rpc_method], *arguments) elif arguments is not None: result = method["node"].call_method( method[rpc_method], arguments) else: result = method["node"].call_method( method[rpc_method]) self.__gateway.send_rpc_reply( content["device"], content["data"]["id"], { content["data"]["method"]: result, "code": 200 }) log.debug("method %s result is: %s", method[rpc_method], result) except Exception as e: log.exception(e) self.__gateway.send_rpc_reply(content["device"], content["data"]["id"], { "error": str(e), "code": 500 }) else: log.error("Method %s not found for device %s", rpc_method, content["device"]) self.__gateway.send_rpc_reply( content["device"], content["data"]["id"], { "error": "%s - Method not found" % (rpc_method), "code": 404 }) except Exception as e: log.exception(e) def __scan_nodes_from_config(self): try: if self.__interest_nodes: for device_object in self.__interest_nodes: for current_device in device_object: try: device_configuration = device_object[ current_device] devices_info_array = self.__search_general_info( device_configuration) for device_info in devices_info_array: if device_info is not None and device_info.get( "deviceNode") is not None: self.__search_nodes_and_subscribe( device_info) self.__save_methods(device_info) self.__search_attribute_update_variables( device_info) else: log.error( "Device node is None, please check your configuration." ) log.debug( "Current device node is: %s", str( device_configuration.get( "deviceNodePattern"))) break except Exception as e: log.exception(e) log.debug(self.__interest_nodes) except Exception as e: log.exception(e) def __search_nodes_and_subscribe(self, device_info): information_types = { "attributes": "attributes", "timeseries": "telemetry" } for information_type in information_types: for information in device_info["configuration"][information_type]: information_key = information["key"] config_path = TBUtility.get_value(information["path"], get_tag=True) information_path = self._check_path(config_path, device_info["deviceNode"]) information["path"] = '${%s}' % information_path information_nodes = [] self.__search_node(device_info["deviceNode"], information_path, result=information_nodes) for information_node in information_nodes: if information_node is not None: information_value = information_node.get_value() log.debug( "Node for %s \"%s\" with path: %s - FOUND! Current values is: %s", information_type, information_key, information_path, str(information_value)) if device_info.get("uplink_converter") is None: configuration = { **device_info["configuration"], "deviceName": device_info["deviceName"], "deviceType": device_info["deviceType"] } if device_info["configuration"].get( 'converter') is None: converter = OpcUaUplinkConverter(configuration) else: converter = TBUtility.check_and_import( self._connector_type, configuration) device_info["uplink_converter"] = converter else: converter = device_info["uplink_converter"] self.subscribed[information_node] = { "converter": converter, "path": information_path, "config_path": config_path } if not device_info.get( information_types[information_type]): device_info[ information_types[information_type]] = [] converted_data = converter.convert( (config_path, information_path), information_value) self.statistics['MessagesReceived'] += 1 self.data_to_send.append(converted_data) self.statistics['MessagesSent'] += 1 if self.__sub is None: self.__sub = self.client.create_subscription( self.__server_conf.get( "subCheckPeriodInMillis", 500), self.__sub_handler) if self.__sub: self.__sub.subscribe_data_change(information_node) log.debug("Added subscription to node: %s", str(information_node)) log.debug("Data to ThingsBoard: %s", converted_data) else: log.error( "Node for %s \"%s\" with path %s - NOT FOUND!", information_type, information_key, information_path) def __save_methods(self, device_info): try: if self.__available_object_resources.get( device_info["deviceName"]) is None: self.__available_object_resources[ device_info["deviceName"]] = {} if self.__available_object_resources[ device_info["deviceName"]].get("methods") is None: self.__available_object_resources[ device_info["deviceName"]]["methods"] = [] if device_info["configuration"].get("rpc_methods"): node = device_info["deviceNode"] for method_object in device_info["configuration"][ "rpc_methods"]: method_node_path = self._check_path( method_object["method"], node) methods = [] self.__search_node(node, method_node_path, True, result=methods) for method in methods: if method is not None: node_method_name = method.get_display_name().Text self.__available_object_resources[ device_info["deviceName"]]["methods"].append({ node_method_name: method, "node": node, "arguments": method_object.get("arguments") }) else: log.error( "Node for method with path %s - NOT FOUND!", method_node_path) except Exception as e: log.exception(e) def __search_attribute_update_variables(self, device_info): try: if device_info["configuration"].get("attributes_updates"): node = device_info["deviceNode"] device_name = device_info["deviceName"] if self.__available_object_resources.get(device_name) is None: self.__available_object_resources[device_name] = {} if self.__available_object_resources[device_name].get( "variables") is None: self.__available_object_resources[device_name][ "variables"] = [] for attribute_update in device_info["configuration"][ "attributes_updates"]: attribute_path = self._check_path( attribute_update["attributeOnDevice"], node) attribute_nodes = [] self.__search_node(node, attribute_path, result=attribute_nodes) for attribute_node in attribute_nodes: if attribute_node is not None: self.__available_object_resources[device_name][ "variables"].append({ attribute_update["attributeOnThingsBoard"]: attribute_node }) else: log.error( "Attribute update node with path \"%s\" - NOT FOUND!", attribute_path) except Exception as e: log.exception(e) def __search_general_info(self, device): result = [] match_devices = [] self.__search_node(self.__opcua_nodes["root"], TBUtility.get_value(device["deviceNodePattern"], get_tag=True), result=match_devices) for device_node in match_devices: if device_node is not None: result_device_dict = { "deviceName": None, "deviceType": None, "deviceNode": device_node, "configuration": deepcopy(device) } name_pattern_config = device["deviceNamePattern"] name_expression = TBUtility.get_value(name_pattern_config, get_tag=True) if "${" in name_pattern_config and "}" in name_pattern_config: log.debug("Looking for device name") name_path = self._check_path(name_expression, device_node) device_name_node = [] self.__search_node(device_node, name_path, result=device_name_node) device_name_node = device_name_node[0] if device_name_node is not None: device_name_from_node = device_name_node.get_value() full_device_name = name_pattern_config.replace( "${" + name_expression + "}", str(device_name_from_node)).replace( name_expression, str(device_name_from_node)) else: log.error( "Device name node not found with expression: %s", name_expression) return else: full_device_name = name_expression result_device_dict["deviceName"] = full_device_name log.debug("Device name: %s", full_device_name) if device.get("deviceTypePattern"): device_type_expression = TBUtility.get_value( device["deviceTypePattern"], get_tag=True) if "${" in device_type_expression and "}" in device_type_expression: type_path = self._check_path(device_type_expression, device_node) device_type_node = [] self.__search_node(device_node, type_path, result=device_type_node) device_type_node = device_type_node[0] if device_type_node is not None: device_type = device_type_node.get_value() full_device_type = device_type_expression.replace( "${" + device_type_expression + "}", device_type).replace(device_type_expression, device_type) else: log.error( "Device type node not found with expression: %s", device_type_expression) full_device_type = "default" else: full_device_type = device_type_expression result_device_dict["deviceType"] = full_device_type log.debug("Device type: %s", full_device_type) else: result_device_dict["deviceType"] = "default" result.append(result_device_dict) else: log.error( "Device node not found with expression: %s", TBUtility.get_value(device["deviceNodePattern"], get_tag=True)) return result def __search_node(self, current_node, fullpath, search_method=False, result=[]): fullpath_pattern = regex.compile(fullpath) try: for child_node in current_node.get_children(): new_node = self.client.get_node(child_node) new_node_path = '\\\\.'.join( char.split(":")[1] for char in new_node.get_path(200000, True)) if self.__show_map: log.debug("SHOW MAP: Current node path: %s", new_node_path) new_node_class = new_node.get_node_class() # regex_fullmatch = re.fullmatch(fullpath, new_node_path.replace('\\\\.', '.')) or new_node_path.replace('\\\\', '\\') == fullpath regex_fullmatch = regex.fullmatch(fullpath_pattern, new_node_path.replace('\\\\.', '.')) or \ new_node_path.replace('\\\\', '\\') == fullpath.replace('\\\\', '\\') or \ new_node_path.replace('\\\\', '\\') == fullpath regex_search = fullpath_pattern.fullmatch(new_node_path.replace('\\\\.', '.'), partial=True) or \ new_node_path.replace('\\\\', '\\') in fullpath.replace('\\\\', '\\') # regex_search = re.search(new_node_path, fullpath.replace('\\\\', '\\')) if regex_fullmatch: if self.__show_map: log.debug( "SHOW MAP: Current node path: %s - NODE FOUND", new_node_path.replace('\\\\', '\\')) result.append(new_node) elif regex_search: if self.__show_map: log.debug( "SHOW MAP: Current node path: %s - NODE FOUND", new_node_path) if new_node_class == ua.NodeClass.Object: if self.__show_map: log.debug("SHOW MAP: Search in %s", new_node_path) self.__search_node(new_node, fullpath, result=result) elif new_node_class == ua.NodeClass.Variable: log.debug("Found in %s", new_node_path) result.append(new_node) elif new_node_class == ua.NodeClass.Method and search_method: log.debug("Found in %s", new_node_path) result.append(new_node) except Exception as e: log.exception(e) def _check_path(self, config_path, node): if re.search("^root", config_path.lower()) is None: node_path = '\\\\.'.join( char.split(":")[1] for char in node.get_path(200000, True)) if config_path[-3:] != '\\.': information_path = node_path + '\\\\.' + config_path.replace( '\\', '\\\\') else: information_path = node_path + config_path.replace( '\\', '\\\\') else: information_path = config_path return information_path[:] @property def subscribed(self): return self._subscribed
def main(): client = Client("opc.tcp://localhost:4840/freeopcua/server/") try: client.connect() # Client has a few methods to get proxy to UA nodes that should always be in address space such as Root or Objects root = client.get_root_node() print("Objects node is: ", root) print("Children of root are: ", root.get_children()) server_namespace = "http://examples.freeopcua.github.io" idx = client.get_namespace_index(server_namespace) # Now getting a variable node using its browse path obj = root.get_child(["0:Objects", "2:MyObject"]) print("My Object object is: ", obj) ## simply read variables, properties, and arrays myvar = root.get_child( ["0:Objects", "2:MyObject", "2:MyFirstVariable"]) print("myvar is: ", myvar.get_value()) myvar.set_value(3.9) # if the var on the server is writable print("myvar is: ", myvar.get_value()) myprop = root.get_child( ["0:Objects", "2:MyObject", "2:MyFirstVariable"]) print("myprop is: ", myprop.get_value()) myprop.set_value(3.9) # if the var on the server is writable print("myprop is: ", myprop.get_value()) ## subscribe to variables change subscribed_variables_dict = dict() subscribed_variables = list() for var in VARS_NAMES: myvar = root.get_child( ["0:Objects", "2:ChargeController", "2:" + str(var)]) subscribed_variables.append(myvar) subscribed_variables_dict[str(myvar)] = str( myvar.get_browse_name().to_string()) msclt = SubHandler() sub = client.create_subscription(100, msclt) for var in subscribed_variables: handle = sub.subscribe_data_change(var) ## subscribe to events myevent = root.get_child([ "0:Types", "0:EventTypes", "0:BaseEventType", "2:LowBatteryEvent" ]) print("MyFirstEventType is: ", myevent) handle = sub.subscribe_events(obj, myevent) ## methods while True: sleep(1) sub.unsubscribe(handle) sub.delete() finally: client.disconnect()
class MyPlc: area = {'I': 0x81, 'Q': 0x82, 'M': 0x83, 'D': 0x84} szs = {'x': 1, 'X': 1, 'b': 1, 'B': 1, 'w': 2, 'W': 2, 'd': 4, 'D': 4} def __init__(self, ip='192.168.0.1'): self.ip = ip self.INByteArray = bytearray([0, 0]) self.MKByteArray = bytearray([0, 0]) self.threadStatus = False self.varsdict = {} self.threads = {} self.plc = PlcClient() self.subNodes = [] self.subNodesD = {} self.keysDict = {} self.inNodes = {} def get_db(self, server_id): self.db_server = Server.query.get(server_id) self.connections() def connections(self): self.opc_ns_uri = self.db_server.server_namespace self.ep_url = 'opc.tcp://' + self.db_server.server_endpoint_url self.opclient = Client(self.ep_url) try: self.plc.connect(self.ip, 0, 1) # pass except Exception: self.conn_stat = "Could not connect to PLC" else: self.conn_stat = "PLC Connected Successfully" self.opclient.connect() self.root = self.opclient.get_root_node() self.idx = self.opclient.get_namespace_index( self.db_server.server_namespace) self.set_tags(self.db_server.server_objects) for key, val in self.varsdict.items(): if re.search("^(M|m)([\d]+).[\d]*$", key) is not None: self.subNodes.append(val['obj']) self.subNodesD[key] = val else: self.inNodes[key] = val self.run_threads() handler = SubHandler(self) sub = self.opclient.create_subscription(200, handler) handle = sub.subscribe_data_change(self.subNodes) time.sleep(0.1) def set_tags(self, objs): for obj in objs: try: self.make_tag_dict(obj, obj.object_variables) except Exception: self.make_tags_dict(obj.object_variables) finally: for var in obj.object_variables: self.keysDict[var.variable_name] = var.variable_address def make_tag_dict(self, obj, allvars): for var in allvars: self.varsdict[var.variable_address] = { 'obj': self.root.get_child([ "0:Objects", "{}:{}".format(self.idx, obj.object_name), "{}:{}".format(self.idx, var.variable_name) ]), 'type': var.variable_type } def kill_threads(self): self.threadStatus = False def run_threads(self): self.threadStatus = True self.threads['update_server'] = threading.Thread( target=self.updateInputs) self.threads['update_server'].start() def getInputs(self): while self.threadStatus: self.INByteArray = self.plc.read_area(areas['PE'], 0, 0, 2) # self.INByteArray = bytearray([ randint(0,7), randint(0,7) ]) time.sleep(.1) # def get_bool(_bytearray, byte_index, bool_index): def updateInputs(self): while self.threadStatus: for key, val in self.inNodes.items(): self.update_server_vars(key) time.sleep(.01) def writetoPLC(self, value, node): key = self.keysDict[node.get_browse_name().to_string().split(':')[1]] self.write_to_plc(key, value) ''' Get Data from the PLC and Update OPC Server variables ''' def update_server_vars(self, addr_key): addr = addr_key.split('.') # Works with Boolean values from a Data Block if len(addr) == 3 and addr[0][0] == 'D': DBn = int(addr[0][2:]) DBt = addr[1][2] byt = int(addr[1][3:]) bit = int(addr[2]) reading = self.plc.read_area(MyPlc.area['D'], DBn, byt, szs[DBt]) if DBt == 'X' or DBt == 'x': self.varsdict[addr_key]['obj'].set_value( get_bool(reading, 0, bit)) # return get_bool( reading, 0, bit ) else: self.varsdict[addr_key]['obj'].set_value(reading) # return reading # Works with other data types from a Data Block elif len(addr) == 2 and addr[0][0] == 'D': DBn = int(addr[0][2:]) DBt = addr[1][2] byt = int(addr[1][3:]) reading = self.plc.read_area(MyPlc.area['D'], DBn, byt, szs[DBt]) if DBt == 'W' or DBt == 'w': self.varsdict[addr_key]['obj'].set_value(get_int(reading, 0)) # return get_int(reading,0) elif DBt == 'D' or DBt == 'd': self.varsdict[addr_key]['obj'].set_value(get_real(reading, 0)) # return get_real(reading,0) else: self.varsdict[addr_key]['obj'].set_value(reading) # Works with boolean values from Inputs,Merkels and Outputs elif len(addr) == 2: byt = int(addr[0][1:]) bit = int(addr[1]) reading = self.plc.read_area(MyPlc.area[addr[0][0]], 0, byt, 1) self.varsdict[addr_key]['obj'].set_value(get_bool(reading, 0, bit)) # return get_bool(reading,0,bit) # Works with other data types from Inputs,Merkels ot Outputs eg MW2 elif len(addr) == 1: byt = int(addr[0][2:]) typ = addr[0][1] reading = self.plc.read_area(MyPlc.area[addr[0][0]], 0, byt, 2) if typ == 'w' or typ == 'W': self.varsdict[addr_key]['obj'].set_value(get_int(reading, 0)) # return get_int(reading, 0) elif typ == 'd' or typ == 'D': self.varsdict[addr_key]['obj'].set_value(get_real(reading, 0)) # return get_real(reading, 0) else: self.varsdict[addr_key]['obj'].set_value(reading) # return reading ''' WRITE DATA TO PLC FROM SERVER ''' def write_to_plc(self, addr_key, value): addr = addr_key.split('.') print("New data change on {} : {}".format(addr_key, value)) # Works with Boolean values from a Data Block if len(addr) == 3 and addr[0][0] == 'D': DBn = int(addr[0][2:]) DBt = addr[1][2] byt = int(addr[1][3:]) bit = int(addr[2]) reading = self.plc.read_area(MyPlc.area['D'], DBn, byt, MyPlc.szs[DBt]) if DBt == 'X' or DBt == 'x': set_bool(reading, 0, bit, value) self.plc.write_area(MyPlc.area['D'], DBn, byt, reading) # Works with other data types from a Data Block elif len(addr) == 2 and addr[0][0] == 'D': DBn = int(addr[0][2:]) DBt = addr[1][2] byt = int(addr[1][3:]) reading = self.plc.read_area(MyPlc.area['D'], DBn, byt, MyPlc.szs[DBt]) if DBt == 'W' or DBt == 'w': set_int(reading, 0, value) elif DBt == 'D' or DBt == 'd': set_real(reading, 0, value) self.plc.write_area(MyPlc.area['D'], DBn, byt, reading) # Works with boolean values from Inputs,Merkels ot Outputs elif len(addr) == 2: byt = int(addr[0][1:]) bit = int(addr[1]) reading = self.plc.read_area(MyPlc.area[addr[0][0]], 0, byt, 1) set_bool(reading, 0, bit, value) self.plc.write_area(MyPlc.area[addr[0][0]], 0, byt, reading) # Works with other data types from Inputs,Merkels ot Outputs eg MW2 elif len(addr) == 1: byt = int(addr[0][2:]) typ = addr[0][1] reading = self.plc.read_area(MyPlc.area[addr[0][0]], 0, byt, 2) if typ == 'w' or typ == 'W': set_int(reading, 0, value) elif typ == 'd' or typ == 'D': set_real(reading, 0, value) else: set_data(value) self.plc.write_area(MyPlc.area[addr[0][0]], 0, byt, reading)
class UaClient(object): """ OPC-Ua client specialized for the need of GUI client return exactly whant GUI needs, no customization possible """ def __init__(self): self.client = None self._connected = False self._datachange_sub = None self._event_sub = None self._subs_dc = {} self._subs_ev = {} def get_node(self, nodeid): return self.client.get_node(nodeid) def connect(self, uri): self.disconnect() print("Connecting to ", uri) self.client = Client(uri) self.client.connect() self._connected = True def disconnect(self): if self._connected: print("Disconnecting from server") self._subs_dc = {} self._subs_ev = {} self._connected = False self._subscription = None self.client.disconnect() self.client = None def subscribe_datachange(self, node, handler): if not self._datachange_sub: self._datachange_sub = self.client.create_subscription(500, handler) handle = self._datachange_sub.subscribe_data_change(node) self._subs_dc[node.nodeid] = handle return handle def unsubscribe_datachange(self, node): self._datachange_sub.unsubscribe(self._subs_dc[node.nodeid]) def subscribe_events(self, node, handler): if not self._event_sub: print("subscirbing with handler: ", handler, dir(handler)) self._event_sub = self.client.create_subscription(500, handler) handle = self._event_sub.subscribe_events(node) self._subs_ev[node.nodeid] = handle return handle def unsubscribe_events(self, node): self._event_sub.unsubscribe(self._subs_ev[node.nodeid]) def get_node_attrs(self, node): if not isinstance(node, Node): node = self.client.get_node(node) attrs = node.get_attributes([ua.AttributeIds.DisplayName, ua.AttributeIds.BrowseName, ua.AttributeIds.NodeId]) return node, [attr.Value.Value.to_string() for attr in attrs] def get_children(self, node): descs = node.get_children_descriptions() descs.sort(key=lambda x: x.BrowseName) return descs
myfloat = client.get_node("ns=4;s=Float") mydouble = client.get_node("ns=4;s=Double") myint64 = client.get_node("ns=4;s=Int64") myuint64 = client.get_node("ns=4;s=UInt64") myint32 = client.get_node("ns=4;s=Int32") myuint32 = client.get_node("ns=4;s=UInt32") var = client.get_node(ua.NodeId("Random1", 5)) print("var is: ", var) print("value of var is: ", var.get_value()) var.set_value(ua.Variant([23], ua.VariantType.Double)) print("setting float value") myfloat.set_value(ua.Variant(1.234, ua.VariantType.Float)) print("reading float value: ", myfloat.get_value()) handler = SubHandler() sub = client.create_subscription(500, handler) handle = sub.subscribe_data_change(var) device = objects.get_child(["2:MyObjects", "2:MyDevice"]) method = device.get_child("2:MyMethod") result = device.call_method(method, ua.Variant("sin"), ua.Variant(180, ua.VariantType.Double)) print("Mehtod result is: ", result) #embed() sub.unsubscribe(handle) sub.delete() #client.close_session() finally: client.disconnect()
class OPCPLC(PLC): """PLC con comunicación OPC UA. Args:: address (str): Dirección IP (o nombre) del controlador. port (int): Puerto de conexión. interval (float): Intervalo de actualización en segundos. Attributes: subscription: Grupo al que se suscriben las variables. handler: Manejador de las actualizaciones de los valores. objects: Nodo de objetos. tagbynodeid (Tag{}): Diccionario de variables por identificador de nodo. client: Cliente OPC UA. opctype (VariantType{}): Principales tipos de datos OPC. """ opctype={ 1:ua.VariantType.Boolean, 2:ua.VariantType.SByte, 3:ua.VariantType.Byte, 4:ua.VariantType.Int16, 5:ua.VariantType.UInt16, 6:ua.VariantType.Int32, 7:ua.VariantType.UInt32, 8:ua.VariantType.Int64, 9:ua.VariantType.UInt64, 10:ua.VariantType.Float, 11:ua.VariantType.Double, 12:ua.VariantType.String, 13:ua.VariantType.DateTime} class Memory(PLC.Memory): ''' Representacióne un área de memoria. No usada en OPC. Args: plc (PLC): Controlador al que pertenece. Attributes: tag (tag{}): Diccionario de variables ordenadas por nombre. tagbyaddress (tag{}): Diccionario de variables ordenadas por dirección. ''' class Tag(PLC.Memory.Tag): ''' Variable Args: memory (Memory): Memoria a la que pertenece (no usada en OPC). key (str): Nombre. description (str): Descripción. address: Dirección. Se pasa la ruta hasta el nodo con el carácter '\' como separación. Los nodos vienen precedidos del tipo en forma de entero, separados por dos puntos. Por ejemplo, una dirección podria ser "2:Data\2:Static\2:Scalar\2:Variable". Para más información de una estructura en particular, una vez conectado llamar al método print_tree(). Attributes: node: Nodo OPC asociado. type: Tipo de dato. value: Valor. subscriptor (Subcriptor[]): Objetos suscritos a los cambios. ''' def __init__(self, memory:PLC.Memory, key:str, description:str="", address=None): self.node=None self.type=None super().__init__(memory,key,description,address) def opcsubscribe(self): ''' Suscripción al nodo OPC. ''' plc=self.memory.plc address=self.address.split("\\") self.node=plc.objects.get_child(address) self.type=int(self.node.get_data_type().Identifier) plc.tagbynodeid[self.node.nodeid.Identifier]=self plc.subscription.subscribe_data_change(self.node) self.node.get_value() def set(self,value): ''' Modifica o asigna el valor de una variable. Args: value: Nuevo valor de la variable. ''' try: if self.type==1: self.node.set_value(ua.Variant(bool(value),OPCPLC.opctype[self.type])) if self.type>=2 and self.type<=9: self.node.set_value(ua.Variant(int(value),OPCPLC.opctype[self.type])) if self.type>=10 and self.type<=11: self.node.set_value(ua.Variant(float(value),OPCPLC.opctype[self.type])) if self.type==12: self.node.set_value(ua.Variant(str(value),OPCPLC.opctype[self.type])) if self.type==13: self.node.set_value(ua.Variant(datetime.strptime(value,"%Y-%m-%d %H:%M:%S"),OPCPLC.opctype[self.type])) self.__update(value) except Exception as e: printexception(e,"Error in assignment. Tag="+self.key+", Value="+value) def __init__(self, address:str, port:int=502, interval:float=3): super().__init__() self.address=address self.port=port self.interval=interval self.handler=OPCPLC.Handler(self) self.subscription=None self.objects=None self.tagbynodeid={} self.client = Client("opc.tcp://"+self.address+":"+str(self.port)+"/") self.create("") def connect(self): ''' Conexión con el controlador ''' try: self.client.connect() self.objects=self.client.get_objects_node() self.subscription=self.client.create_subscription(self.interval, self.handler) for key_memory in self.memory: memory=self.get(key_memory) for key_tag in memory: memory.get(key_tag).opcsubscribe() self.connected=True except Exception as e: printexception(e,"Error connecting to OPC server") def __tree(self, root, level:int=0): ''' Recursión para imprimir el árbol de nodos. Args: root: nodo raíz en la recursión. level (int): Nivel de recursión. ''' nodes=root.get_children() for node in nodes: node2=self.client.get_node(node.nodeid) name=node2.get_browse_name().to_string() print((' '*level)+name) self.tree(node, level+1) def print_tree(self): ''' Imprime la estructura de nodos. ''' self.__tree(self.client.get_objects_node()) class Handler(object): ''' Manejador de los cambios en los valores de los nodos. Args: plc (PLC): Controlador. ''' def __init__(self,plc): self.plc=plc def datachange_notification(self, node, val, data): ''' Método llamado cuando cambia el valor de un nodo. Args: node: Nodo. val: Valor. data: Datos. ''' self.plc.tagbynodeid[node.nodeid.Identifier].update(val)