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.user_certificate_path, self.user_private_key_path) self.client = Client(uri) self.client.application_uri = self.application_uri self.client.description = "FreeOpcUa Client GUI" # Set user identity token if self.user_private_key_path: self.client.load_private_key(self.user_private_key_path) if self.user_certificate_path: self.client.load_client_certificate(self.user_certificate_path) # Set security mode and security policy 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.application_certificate_path, self.application_private_key_path, mode=getattr(ua.MessageSecurityMode, self.security_mode) ) self.client.connect() self._connected = True self.client.load_data_type_definitions() self.client.load_enums() self.client.load_type_definitions() self.save_security_settings(uri)
def get_endpoints(uri): client = Client(uri, timeout=2) 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 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.client.load_enums() self.client.load_type_definitions() self.client.load_data_type_definitions() self.save_security_settings(uri)
def start_server(self, endpoint): self._server = UAServer() self._server.endpoint = 48400 # enpoint not supported yet #self._server.endpoint = endpoint self._server.start() #self._server.set_server_name("OpcUa Modeler Server") time.sleep(0.2) self._client = Client(endpoint) self._client.connect() self.nodes = self._client.nodes self.get_node = self._client.get_node self.get_namespace_array = self._client.get_namespace_array # now remove freeopcua namespace, not necessary when modeling and # ensures correct idx for exported nodesets ns_node = self._client.get_node( ua.NodeId(ua.ObjectIds.Server_NamespaceArray)) nss = ns_node.read_value()
class ServerC(object): def __init__(self): self._server = None self._client = None self.nodes = None self.get_node = None self.get_namespace_array = None def get_server(self): return self._client def start_server(self, endpoint): self._server = UAServer() self._server.endpoint = 48400 # enpoint not supported yet #self._server.endpoint = endpoint self._server.start() #self._server.set_server_name("OpcUa Modeler Server") time.sleep(0.2) self._client = Client(endpoint) self._client.connect() self.nodes = self._client.nodes self.get_node = self._client.get_node self.get_namespace_array = self._client.get_namespace_array # now remove freeopcua namespace, not necessary when modeling and # ensures correct idx for exported nodesets ns_node = self._client.get_node( ua.NodeId(ua.ObjectIds.Server_NamespaceArray)) nss = ns_node.read_value() #ns_node.read_value(nss[1:]) def stop_server(self): if self._server is not None: self._client.disconnect() self._client = None self._server.stop() time.sleep(0.2) self._server = None self.get_node = None self.get_namespace_array = None def import_xml(self, path): return self._client.import_xml(path) def export_xml(self, nodes, uris, path): exp = XmlExporter(self._client) exp.build_etree(nodes, uris=uris) exp.write_xml(path)
def datachange_notification(self, node, val, data): print("Python: New data change event", node, val) def event_notification(self, event): print("Python: New event", event) if __name__ == "__main__": #from IPython import embed logging.basicConfig(level=logging.DEBUG) #client = Client("opc.tcp://*****:*****@localhost:53530/OPCUA/SimulationServer/") #client.set_security_string("Basic256Sha256,SignAndEncrypt,certificate-example.der,private-key-example.pem") try: start_thread_loop() client = Client("opc.tcp://localhost:53530/OPCUA/SimulationServer/") client.connect() root = client.nodes.root print("Root is", root) print("childs of root are: ", root.get_children()) print("name of root is", root.read_browse_name()) objects = client.nodes.objects print("childs og objects are: ", objects.get_children()) 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))
def client_no_tloop(server): with Client("opc.tcp://admin@localhost:8840/freeopcua/server") as c: yield c
def client(tloop, server): c = Client("opc.tcp://admin@localhost:8840/freeopcua/server", tloop=tloop) with c: yield c
from asyncua.sync import Client from asyncua import ua import asyncio import time # Get Temperature with Client("opc.tcp://169.254.1.70:4840/freeopcua/server/") as client: print( client.get_node( 'ns=4;s=MAIN.IOPT100.stat.arrAI[0].lrValueUser').get_value()) # Initialize the lamp with Client("opc.tcp://169.254.1.70:4840/freeopcua/server/") as client: print(client.get_node('ns=4;s=MAIN.Lamp001.stat.sState').get_value()) print(client.get_node('ns=4;s=MAIN.Lamp001.stat.sStatus').get_value()) print(client.get_node('ns=4;s=MAIN.Lamp001.stat.sSubstate').get_value()) parent = client.get_node('ns=4;s=MAIN.Lamp001') method = parent.get_child("4:RPC_Init") # Show the needed input arguments inputs = method.get_child("0:InputArguments").get_value() arguments = [] res = parent.call_method(method, *arguments) # Wait for 1 second time.sleep(1) # Show status print(client.get_node('ns=4;s=MAIN.Lamp001.stat.sState').get_value()) print(client.get_node('ns=4;s=MAIN.Lamp001.stat.sStatus').get_value()) print(client.get_node('ns=4;s=MAIN.Lamp001.stat.sSubstate').get_value()) # Enable the lamp with Client("opc.tcp://169.254.1.70:4840/freeopcua/server/") as client:
import sys sys.path.insert(0, "../..") from asyncua.sync import Client, start_thread_loop, stop_thread_loop if __name__ == "__main__": start_thread_loop() 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 # Node objects have methods to read and write node attributes as well as browse or populate address space print("Children of root are: ", client.nodes.root.get_children()) # get a specific node knowing its node id #var = client.get_node(ua.NodeId(1002, 2)) #var = client.get_node("ns=3;i=2002") #print(var) #var.get_data_value() # get value of node as a DataValue object #var.get_value() # get value of node as a python builtin #var.set_value(ua.Variant([23], ua.VariantType.Int64)) #set node value using explicit data type #var.set_value(3.9) # set node value using implicit data type # Now getting a variable node using its browse path myvar = client.nodes.root.get_child( ["0:Objects", "2:MyObject", "2:MyVariable"]) obj = client.nodes.root.get_child(["0:Objects", "2:MyObject"])
thread if you need to do such a thing """ def datachange_notification(self, node, val, data): print("Python: New data change event", node, val) def event_notification(self, event): print("Python: New event", event) if __name__ == "__main__": logging.basicConfig(level=logging.WARN) #logger = logging.getLogger("KeepAlive") #logger.setLevel(logging.DEBUG) with ThreadLoop() as tloop: with Client("opc.tcp://*****:*****@localhost:4840/freeopcua/server/") #connect using a user client.load_type_definitions( ) # load definition of server specific structures/extension objects # Client has a few methods to get proxy to UA nodes that should always be in address space such as Root or Objects print("Objects node is: ", client.nodes.objects) # Node objects have methods to read and write node attributes as well as browse or populate address space print("Children of root are: ", client.nodes.root.get_children()) # get a specific node knowing its node id #var = client.get_node(ua.NodeId(1002, 2)) #var = client.get_node("ns=3;i=2002") #print(var) #var.read_data_value() # get value of node as a DataValue object
def client(tloop, server): c = Client("opc.tcp://localhost:8840/freeopcua/server") c.connect() yield c c.disconnect()
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) 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.client.load_enums() self.client.load_type_definitions() self.client.load_data_type_definitions() 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, SyncNode): 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
thread if you need to do such a thing """ def datachange_notification(self, node, val, data): print("Python: New data change event", node, val) def event_notification(self, event): print("Python: New event", event) if __name__ == "__main__": logging.basicConfig(level=logging.WARN) #logger = logging.getLogger("KeepAlive") #logger.setLevel(logging.DEBUG) start_thread_loop() client = Client("opc.tcp://*****:*****@localhost:4840/freeopcua/server/") #connect using a user try: client.connect() client.load_type_definitions( ) # load definition of server specific structures/extension objects # Client has a few methods to get proxy to UA nodes that should always be in address space such as Root or Objects print("Objects node is: ", client.nodes.objects) # Node objects have methods to read and write node attributes as well as browse or populate address space print("Children of root are: ", client.nodes.root.get_children()) # get a specific node knowing its node id #var = client.get_node(ua.NodeId(1002, 2)) #var = client.get_node("ns=3;i=2002")
import logging from asyncua.sync import Client class SubHandler(object): """ Client to subscription. It will receive events from server """ def datachange_notification(self, node, val, data): print("Python: New data change event", node, val) def event_notification(self, event): print("Python: New event", event) if __name__ == "__main__": from IPython import embed logging.basicConfig(level=logging.DEBUG) #client = Client("opc.tcp://*****:*****@localhost:53530/OPCUA/SimulationServer/") #client.set_security_string("Basic256Sha256,SignAndEncrypt,certificate-example.der,private-key-example.pem") with Client("opc.tcp://localhost:53530/OPCUA/SimulationServer/") as client: root = client.nodes.root print("Root is", root) print("childs of root are: ", root.get_children()) print("name of root is", root.read_browse_name()) objects = client.nodes.objects print("childs og objects are: ", objects.get_children()) embed()