beremiz: comparison opc_ua/opcua_client

equal deleted inserted replaced

-:4582f0fcf4c4
+:46f3ca3f0157
 import csv
+import asyncio
-from opcua import Client
+import functools
-from opcua import ua
+from threading import Thread
+from asyncua import Client
+from asyncua import ua
 import wx
 import wx.lib.gizmos as gizmos  # Formerly wx.gizmos in Classic
 import wx.dataview as dv
 # Have to find OPC-UA client extension panel from here
 # in order to avoid keeping reference (otherwise __del__ isn't called)
 #             splitter.        panel.      splitter
 ClientPanel = self.GetParent().GetParent().GetParent()
 nodes = ClientPanel.GetSelectedNodes()
-for node in nodes:
+for node, properties in nodes:
-cname = node.get_node_class().name
+if properties.cname != "Variable":
-dname = node.get_display_name().Text
+self.log("Node {} ignored (not a variable)".format(properties.dname))
-if cname != "Variable":
-self.log("Node {} ignored (not a variable)".format(dname))
 continue
-tname = node.get_data_type_as_variant_type().name
+tname = properties.variant_type
 if tname not in UA_IEC_types:
-self.log("Node {} ignored (unsupported type)".format(dname))
+self.log("Node {} ignored (unsupported type)".format(properties.dname))
 continue
-access = node.get_access_level()
 if {"input":ua.AccessLevel.CurrentRead,
-"output":ua.AccessLevel.CurrentWrite}[self.direction] not in access:
+"output":ua.AccessLevel.CurrentWrite}[self.direction] not in properties.access:
-self.log("Node {} ignored because of insuficient access rights".format(dname))
+self.log("Node {} ignored because of insuficient access rights".format(properties.dname))
 continue
-nsid = node.nodeid.NamespaceIndex
+nid_type =  type(properties.nid).__name__
-nid =  node.nodeid.Identifier
+iecid = properties.nid
-nid_type =  type(nid).__name__
-iecid = nid
+value = [properties.dname,
+properties.nsid,
-value = [dname,
-nsid,
 nid_type,
-nid,
+properties.nid,
 tname,
 iecid]
 self.model.AddRow(value)
 fldropenidx = il.Add(wx.ArtProvider.GetBitmap(wx.ART_FILE_OPEN,   wx.ART_OTHER, isz))
 fileidx     = il.Add(wx.ArtProvider.GetBitmap(wx.ART_NORMAL_FILE, wx.ART_OTHER, isz))
 smileidx    = il.Add(wx.ArtProvider.GetBitmap(wx.ART_ADD_BOOKMARK, wx.ART_OTHER, isz))
+AsyncUAClientLoop = None
+def AsyncUAClientLoopProc():
+asyncio.set_event_loop(AsyncUAClientLoop)
+AsyncUAClientLoop.run_forever()
+def ExecuteSychronously(func, timeout=1):
+def AsyncSychronizer(*args, **kwargs):
+global AsyncUAClientLoop
+# create asyncio loop
+if AsyncUAClientLoop is None:
+AsyncUAClientLoop = asyncio.new_event_loop()
+Thread(target=AsyncUAClientLoopProc, daemon=True).start()
+# schedule work in this loop
+future = asyncio.run_coroutine_threadsafe(func(*args, **kwargs), AsyncUAClientLoop)
+# wait max 5sec until connection completed
+return future.result(timeout)
+return AsyncSychronizer
+def ExecuteSychronouslyWithTimeout(timeout):
+return functools.partial(ExecuteSychronously,timeout=timeout)
 class OPCUAClientPanel(wx.SplitterWindow):
 def __init__(self, parent, modeldata, log, config_getter):
 self.log = log
 wx.SplitterWindow.__init__(self, parent, -1)
-self.ordered_nodes = []
+self.ordered_nps = []
 self.inout_panel = wx.Panel(self)
 self.inout_sizer = wx.FlexGridSizer(cols=1, hgap=0, rows=2, vgap=0)
 self.inout_sizer.AddGrowableCol(0)
 self.inout_sizer.AddGrowableRow(1)
+self.clientloop = None
 self.client = None
 self.config_getter = config_getter
 self.connect_button = wx.ToggleButton(self.inout_panel, -1, "Browse Server")
 self.Bind(wx.EVT_TOGGLEBUTTON, self.OnConnectButton, self.connect_button)
 def OnClose(self):
 if self.client is not None:
-self.client.disconnect()
+asyncio.run(self.client.disconnect())
 self.client = None
 def __del__(self):
 self.OnClose()
+async def GetAsyncUANodeProperties(self, node):
+properties = type("UANodeProperties",(),dict(
+nsid = node.nodeid.NamespaceIndex,
+nid =  node.nodeid.Identifier,
+dname = (await node.read_display_name()).Text,
+cname = (await node.read_node_class()).name,
+))
+if properties.cname == "Variable":
+properties.access = await node.get_access_level()
+properties.variant_type = (await node.read_data_type_as_variant_type()).name
+return properties
+@ExecuteSychronouslyWithTimeout(5)
+async def ConnectAsyncUAClient(self, config):
+client = Client(config["URI"])
+AuthType = config["AuthType"]
+if AuthType=="UserPasword":
+await client.set_user(config["User"])
+await client.set_password(config["Password"])
+elif AuthType=="x509":
+await client.set_security_string(
+"{Policy},{Mode},{Certificate},{PrivateKey}".format(**config))
+await client.connect()
+self.client = client
+# load definition of server specific structures/extension objects
+await self.client.load_type_definitions()
+# returns root node object and its properties
+rootnode = self.client.get_root_node()
+return rootnode, await self.GetAsyncUANodeProperties(rootnode)
+@ExecuteSychronously
+async def DisconnectAsyncUAClient(self):
+if self.client is not None:
+await self.client.disconnect()
+self.client = None
+@ExecuteSychronously
+async def GetAsyncUANodeChildren(self, node):
+children = await node.get_children()
+return [ (child, await self.GetAsyncUANodeProperties(child)) for child in children]
 def OnConnectButton(self, event):
 if self.connect_button.GetValue():
 config = self.config_getter()
-self.client = Client(config["URI"])
 self.log("OPCUA browser: connecting to {}\n".format(config["URI"]))
-AuthType = config["AuthType"]
-if AuthType=="UserPasword":
-self.client.set_user(config["User"])
-self.client.set_password(config["Password"])
-elif AuthType=="x509":
-self.client.set_security_string(
-"{Policy},{Mode},{Certificate},{PrivateKey}".format(**config))
 try :
-self.client.connect()
+rootnode, rootnodeproperties = self.ConnectAsyncUAClient(config)
 except Exception as e:
-self.log("OPCUA browser: "+str(e)+"\n")
+self.log("Exception in OPCUA browser: "+repr(e)+"\n")
 self.client = None
 self.connect_button.SetValue(False)
 return
 self.tree_panel = wx.Panel(self)
 self.tree.AddColumn(colname)
 self.tree.SetColumnWidth(idx, width)
 self.tree.SetMainColumn(0)
-self.client.load_type_definitions()  # load definition of server specific structures/extension objects
+rootitem = self.AddNodeItem(self.tree.AddRoot, rootnode, rootnodeproperties)
-rootnode = self.client.get_root_node()
-rootitem = self.AddNodeItem(self.tree.AddRoot, rootnode)
 # Populate first level so that root can be expanded
 self.CreateSubItems(rootitem)
 self.tree.Bind(wx.EVT_TREE_ITEM_EXPANDED, self.OnExpand)
 self.tree.Bind(wx.EVT_TREE_SEL_CHANGED, self.OnTreeNodeSelection)
 self.tree.Bind(wx.EVT_TREE_BEGIN_DRAG, self.OnTreeBeginDrag)
 self.tree.Expand(rootitem)
-hint = wx.StaticText(self, label = "Drag'n'drop desired variables from tree to Input or Output list")
+hint = wx.StaticText(self.tree_panel, label = "Drag'n'drop desired variables from tree to Input or Output list")
 self.tree_sizer.Add(self.tree, flag=wx.GROW)
 self.tree_sizer.Add(hint, flag=wx.GROW)
 self.tree_sizer.Layout()
 self.tree_panel.SetAutoLayout(True)
 self.tree_panel.SetSizer(self.tree_sizer)
 self.SplitVertically(self.tree_panel, self.inout_panel, 500)
 else:
-self.client.disconnect()
+self.DisconnectAsyncUAClient()
-self.client = None
 self.Unsplit(self.tree_panel)
 self.tree_panel.Destroy()
 def CreateSubItems(self, item):
-node, browsed = self.tree.GetPyData(item)
+node, properties, browsed = self.tree.GetPyData(item)
 if not browsed:
-for subnode in node.get_children():
+children = self.GetAsyncUANodeChildren(node)
-self.AddNodeItem(lambda n: self.tree.AppendItem(item, n), subnode)
+for subnode, subproperties in children:
-self.tree.SetPyData(item,(node, True))
+self.AddNodeItem(lambda n: self.tree.AppendItem(item, n), subnode, subproperties)
+self.tree.SetPyData(item,(node, properties, True))
-def AddNodeItem(self, item_creation_func, node):
-nsid = node.nodeid.NamespaceIndex
+def AddNodeItem(self, item_creation_func, node, properties):
-nid =  node.nodeid.Identifier
+item = item_creation_func(properties.dname)
-dname = node.get_display_name().Text
-cname = node.get_node_class().name
+if properties.cname == "Variable":
+access = properties.access
-item = item_creation_func(dname)
-if cname == "Variable":
-access = node.get_access_level()
 normalidx = fileidx
 r = ua.AccessLevel.CurrentRead in access
 w = ua.AccessLevel.CurrentWrite in access
 if r and w:
 ext = "RW"
 ext = "RO"
 elif w:
 ext = "WO"  # not sure this one exist
 else:
 ext = "no access"  # not sure this one exist
-cname = "Var "+node.get_data_type_as_variant_type().name+" (" + ext + ")"
+cname = "Var "+properties.variant_type+" (" + ext + ")"
 else:
 normalidx = fldridx
-self.tree.SetPyData(item,(node, False))
+self.tree.SetPyData(item,(node, properties, False))
-self.tree.SetItemText(item, cname, 1)
+self.tree.SetItemText(item, properties.cname, 1)
-self.tree.SetItemText(item, str(nsid), 2)
+self.tree.SetItemText(item, str(properties.nsid), 2)
-self.tree.SetItemText(item, type(nid).__name__+": "+str(nid), 3)
+self.tree.SetItemText(item, type(properties.nid).__name__+": "+str(properties.nid), 3)
 self.tree.SetItemImage(item, normalidx, which = wx.TreeItemIcon_Normal)
 self.tree.SetItemImage(item, fldropenidx, which = wx.TreeItemIcon_Expanded)
 return item
 def OnTreeNodeSelection(self, event):
 items = self.tree.GetSelections()
 items_pydata = [self.tree.GetPyData(item) for item in items]
-nodes = [node for node, _unused in items_pydata]
+nps = [(node,properties) for node, properties, unused in items_pydata]
 # append new nodes to ordered list
-for node in nodes:
+for np in nps:
-if node not in self.ordered_nodes:
+if np not in self.ordered_nps:
-self.ordered_nodes.append(node)
+self.ordered_nps.append(np)
 # filter out vanished items
-self.ordered_nodes = [
+self.ordered_nps = [
-node
+np
-for node in self.ordered_nodes
+for np in self.ordered_nps
-if node in nodes]
+if np in nps]
 def GetSelectedNodes(self):
-return self.ordered_nodes
+return self.ordered_nps
 def OnTreeBeginDrag(self, event):
 """
 Called when a drag is started in tree
 @param event: wx.TreeEvent
 """
-if self.ordered_nodes:
+if self.ordered_nps:
 # Just send a recognizable mime-type, drop destination
 # will get python data from parent
 data = wx.CustomDataObject(OPCUAClientDndMagicWord)
 dragSource = wx.DropSource(self)
 dragSource.SetData(data)
 super(OPCUAClientModel, self).__init__()
 for direction in directions:
 self[direction] = OPCUAClientList(log, change_callback)
 def LoadCSV(self,path):
-with open(path, 'rb') as csvfile:
+with open(path, 'r') as csvfile:
 reader = csv.reader(csvfile, delimiter=',', quotechar='"')
 buf = {direction:[] for direction, _model in self.items()}
 for direction, model in self.items():
 self[direction][:] = []
 for row in reader:
 direction = row[0]
 # avoids calling change callback whe loading CSV
 list.append(self[direction],row[1:])
 def SaveCSV(self,path):
-with open(path, 'wb') as csvfile:
+with open(path, 'w') as csvfile:
 for direction, data in self.items():
 writer = csv.writer(csvfile, delimiter=',',
 quotechar='"', quoting=csv.QUOTE_MINIMAL)
 for row in data:
 writer.writerow([direction] + row)
 return EXIT_SUCCESS;
 }
 """
-with open(path, 'wb') as Cfile:
+with open(path, 'w') as Cfile:
 Cfile.write(Ccode)
 dlg.Destroy()

changeset 3820	46f3ca3f0157
parent 3750	f62625418bff