1

     2

     3

     4

import csv

     5

import asyncio

     6

import functools

     7

from threading import Thread

     8

     9

from asyncua import Client

    10

from asyncua import ua

    11

    12

import wx

    13

import wx.lib.gizmos as gizmos  # Formerly wx.gizmos in Classic

    14

import wx.dataview as dv

    15

    16

    17

UA_IEC_types = dict(

    18

#   pyopcua | IEC61131|  C  type  | sz |  open62541  enum  | open62541

    19

    Boolean = ("BOOL" , "uint8_t" , "X", "UA_TYPES_BOOLEAN", "UA_Boolean"),

    20

    SByte   = ("SINT" , "int8_t"  , "B", "UA_TYPES_SBYTE"  , "UA_SByte"  ),

    21

    Byte    = ("USINT", "uint8_t" , "B", "UA_TYPES_BYTE"   , "UA_Byte"   ),

    22

    Int16   = ("INT"  , "int16_t" , "W", "UA_TYPES_INT16"  , "UA_Int16"  ),

    23

    UInt16  = ("UINT" , "uint16_t", "W", "UA_TYPES_UINT16" , "UA_UInt16" ),

    24

    Int32   = ("DINT" , "uint32_t", "D", "UA_TYPES_INT32"  , "UA_Int32"  ),

    25

    UInt32  = ("UDINT", "int32_t" , "D", "UA_TYPES_UINT32" , "UA_UInt32" ),

    26

    Int64   = ("LINT" , "int64_t" , "L", "UA_TYPES_INT64"  , "UA_Int64"  ),

    27

    UInt64  = ("ULINT", "uint64_t", "L", "UA_TYPES_UINT64" , "UA_UInt64" ),

    28

    Float   = ("REAL" , "float"   , "D", "UA_TYPES_FLOAT"  , "UA_Float"  ),

    29

    Double  = ("LREAL", "double"  , "L", "UA_TYPES_DOUBLE" , "UA_Double" ),

    30

)

    31

    32

UA_NODE_ID_types = {

    33

    "int"   : ("UA_NODEID_NUMERIC", "{}"  ),

    34

    "str"   : ("UA_NODEID_STRING" , '"{}"'),

    35

    "UUID"  : ("UA_NODEID_UUID"   , '"{}"'),

    36

}

    37

    38

lstcolnames  = [  "Name", "NSIdx", "IdType", "Id", "Type", "IEC"]

    39

lstcolwidths = [     100,      50,      100,  100,    100,    50]

    40

lstcoltypess = [     str,     int,      str,  str,    str,   int]

    41

    42

directions = ["input", "output"]

    43

    44

authParams = {

    45

    "x509":[

    46

        ("Certificate", "certificate.der"),

    47

        ("PrivateKey", "private_key.pem"),

    48

        ("Policy", "Basic256Sha256"),

    49

        ("Mode", "SignAndEncrypt")],

    50

    "UserPassword":[

    51

        ("User", None),

    52

        ("Password", None)]}

    53

    54

class OPCUASubListModel(dv.DataViewIndexListModel):

    55

    def __init__(self, data, log):

    56

        dv.DataViewIndexListModel.__init__(self, len(data))

    57

        self.data = data

    58

        self.log = log

    59

    60

    def GetColumnType(self, col):

    61

        return "string"

    62

    63

    def GetValueByRow(self, row, col):

    64

        return str(self.data[row][col])

    65

    66

    # This method is called when the user edits a data item in the view.

    67

    def SetValueByRow(self, value, row, col):

    68

        expectedtype = lstcoltypess[col]

    69

    70

        try:

    71

            v = expectedtype(value)

    72

        except ValueError: 

    73

            self.log("String {} is invalid for type {}\n".format(value,expectedtype.__name__))

    74

            return False

    75

    76

        if col == lstcolnames.index("IdType") and v not in UA_NODE_ID_types:

    77

            self.log("{} is invalid for IdType\n".format(value))

    78

            return False

    79

    80

        self.data[row][col] = v

    81

        return True

    82

    83

    # Report how many columns this model provides data for.

    84

    def GetColumnCount(self):

    85

        return len(lstcolnames)

    86

    87

    # Report the number of rows in the model

    88

    def GetCount(self):

    89

        #self.log.write('GetCount')

    90

        return len(self.data)

    91

    92

    # Called to check if non-standard attributes should be used in the

    93

    # cell at (row, col)

    94

    def GetAttrByRow(self, row, col, attr):

    95

        if col == 5:

    96

            attr.SetColour('blue')

    97

            attr.SetBold(True)

    98

            return True

    99

        return False

   100

   101

   102

    def DeleteRows(self, rows):

   103

        # make a copy since we'll be sorting(mutating) the list

   104

        # use reverse order so the indexes don't change as we remove items

   105

        rows = sorted(rows, reverse=True)

   106

   107

        for row in rows:

   108

            # remove it from our data structure

   109

            del self.data[row]

   110

            # notify the view(s) using this model that it has been removed

   111

            self.RowDeleted(row)

   112

   113

   114

    def AddRow(self, value):

   115

        if self.data.append(value):

   116

            # notify views

   117

            self.RowAppended()

   118

   119

    def ResetData(self):

   120

        self.Reset(len(self.data))

   121

   122

OPCUAClientDndMagicWord = "text/beremiz-opcuaclient"

   123

   124

class NodeDropTarget(wx.DropTarget):

   125

   126

    def __init__(self, parent):

   127

        data = wx.CustomDataObject(OPCUAClientDndMagicWord)

   128

        wx.DropTarget.__init__(self, data)

   129

        self.ParentWindow = parent

   130

   131

    def OnDrop(self, x, y):

   132

        self.ParentWindow.OnNodeDnD()

   133

        return True

   134

   135

class OPCUASubListPanel(wx.Panel):

   136

    def __init__(self, parent, log, model, direction):

   137

        self.log = log

   138

        wx.Panel.__init__(self, parent, -1)

   139

   140

        self.dvc = dv.DataViewCtrl(self,

   141

                                   style=wx.BORDER_THEME

   142

                                   | dv.DV_ROW_LINES

   143

                                   | dv.DV_HORIZ_RULES

   144

                                   | dv.DV_VERT_RULES

   145

                                   | dv.DV_MULTIPLE

   146

                                   )

   147

   148

        self.model = model

   149

   150

        self.dvc.AssociateModel(self.model)

   151

   152

        for idx,(colname,width) in enumerate(zip(lstcolnames,lstcolwidths)):

   153

            self.dvc.AppendTextColumn(colname,  idx, width=width, mode=dv.DATAVIEW_CELL_EDITABLE)

   154

   155

        DropTarget = NodeDropTarget(self)

   156

        self.SetDropTarget(DropTarget)

   157

   158

        self.Sizer = wx.BoxSizer(wx.VERTICAL)

   159

   160

        self.direction =  direction

   161

        titlestr = direction + " variables"

   162

   163

        title = wx.StaticText(self, label = titlestr)

   164

   165

        delbt = wx.Button(self, label="Delete Row(s)")

   166

        self.Bind(wx.EVT_BUTTON, self.OnDeleteRows, delbt)

   167

   168

        topsizer = wx.BoxSizer(wx.HORIZONTAL)

   169

        topsizer.Add(title, 1, wx.ALIGN_CENTER_VERTICAL|wx.LEFT|wx.RIGHT, 5)

   170

        topsizer.Add(delbt, 0, wx.LEFT|wx.RIGHT, 5)

   171

        self.Sizer.Add(topsizer, 0, wx.EXPAND|wx.TOP|wx.BOTTOM, 5)

   172

        self.Sizer.Add(self.dvc, 1, wx.EXPAND)

   173

   174

   175

   176

    def OnDeleteRows(self, evt):

   177

        items = self.dvc.GetSelections()

   178

        rows = [self.model.GetRow(item) for item in items]

   179

        self.model.DeleteRows(rows)

   180

   181

   182

    def OnNodeDnD(self):

   183

        # Have to find OPC-UA client extension panel from here 

   184

        # in order to avoid keeping reference (otherwise __del__ isn't called)

   185

        #             splitter.        panel.      splitter

   186

        ClientPanel = self.GetParent().GetParent().GetParent()

   187

        nodes = ClientPanel.GetSelectedNodes()

   188

        for node, properties in nodes:

   189

            if properties.cname != "Variable":

   190

                self.log("Node {} ignored (not a variable)".format(properties.dname))

   191

                continue

   192

   193

            tname = properties.variant_type

   194

            if tname not in UA_IEC_types:

   195

                self.log("Node {} ignored (unsupported type)".format(properties.dname))

   196

                continue

   197

   198

            if {"input":ua.AccessLevel.CurrentRead,

   199

                "output":ua.AccessLevel.CurrentWrite}[self.direction] not in properties.access:

   200

                self.log("Node {} ignored because of insuficient access rights".format(properties.dname))

   201

                continue

   202

   203

            nid_type =  type(properties.nid).__name__

   204

            iecid = properties.nid

   205

   206

            value = [properties.dname,

   207

                     properties.nsid,

   208

                     nid_type,

   209

                     properties.nid,

   210

                     tname,

   211

                     iecid]

   212

            self.model.AddRow(value)

   213

   214

   215

   216

il = None

   217

fldridx = None    

   218

fldropenidx = None

   219

fileidx = None

   220

smileidx = None

   221

isz = (16,16)

   222

   223

treecolnames  = [  "Name", "Class", "NSIdx", "Id"]

   224

treecolwidths = [     250,     100,      50,  200]

   225

   226

   227

def prepare_image_list():

   228

    global il, fldridx, fldropenidx, fileidx, smileidx    

   229

   230

    if il is not None: 

   231

        return

   232

   233

    il = wx.ImageList(isz[0], isz[1])

   234

    fldridx     = il.Add(wx.ArtProvider.GetBitmap(wx.ART_FOLDER,      wx.ART_OTHER, isz))

   235

    fldropenidx = il.Add(wx.ArtProvider.GetBitmap(wx.ART_FILE_OPEN,   wx.ART_OTHER, isz))

   236

    fileidx     = il.Add(wx.ArtProvider.GetBitmap(wx.ART_NORMAL_FILE, wx.ART_OTHER, isz))

   237

    smileidx    = il.Add(wx.ArtProvider.GetBitmap(wx.ART_ADD_BOOKMARK, wx.ART_OTHER, isz))

   238

   239

   240

AsyncUAClientLoop = None

   241

def AsyncUAClientLoopProc():

   242

    asyncio.set_event_loop(AsyncUAClientLoop)

   243

    AsyncUAClientLoop.run_forever()

   244

   245

def ExecuteSychronously(func, timeout=1):

   246

    def AsyncSychronizer(*args, **kwargs):

   247

        global AsyncUAClientLoop

   248

        # create asyncio loop

   249

        if AsyncUAClientLoop is None:

   250

            AsyncUAClientLoop = asyncio.new_event_loop()

   251

            Thread(target=AsyncUAClientLoopProc, daemon=True).start()

   252

        # schedule work in this loop

   253

        future = asyncio.run_coroutine_threadsafe(func(*args, **kwargs), AsyncUAClientLoop)

   254

        # wait max 5sec until connection completed

   255

        return future.result(timeout)

   256

    return AsyncSychronizer

   257

   258

def ExecuteSychronouslyWithTimeout(timeout):

   259

    return functools.partial(ExecuteSychronously,timeout=timeout)

   260

   261

   262

class OPCUAClientPanel(wx.SplitterWindow):

   263

    def __init__(self, parent, modeldata, log, config_getter):

   264

        self.log = log

   265

        wx.SplitterWindow.__init__(self, parent, -1)

   266

   267

        self.ordered_nps = []

   268

   269

        self.inout_panel = wx.Panel(self)

   270

        self.inout_sizer = wx.FlexGridSizer(cols=1, hgap=0, rows=2, vgap=0)

   271

        self.inout_sizer.AddGrowableCol(0)

   272

        self.inout_sizer.AddGrowableRow(1)

   273

   274

        self.clientloop = None

   275

        self.client = None

   276

        self.config_getter = config_getter

   277

   278

        self.connect_button = wx.ToggleButton(self.inout_panel, -1, "Browse Server")

   279

   280

        self.selected_splitter = wx.SplitterWindow(self.inout_panel, style=wx.SUNKEN_BORDER | wx.SP_3D)

   281

   282

        self.selected_datas = modeldata

   283

        self.selected_models = { direction:OPCUASubListModel(self.selected_datas[direction], log) for direction in directions }

   284

        self.selected_lists = { direction:OPCUASubListPanel(

   285

                self.selected_splitter, log, 

   286

                self.selected_models[direction], direction) 

   287

            for direction in directions }

   288

   289

        self.selected_splitter.SplitHorizontally(*[self.selected_lists[direction] for direction in directions]+[300])

   290

   291

        self.inout_sizer.Add(self.connect_button, flag=wx.GROW)

   292

        self.inout_sizer.Add(self.selected_splitter, flag=wx.GROW)

   293

        self.inout_sizer.Layout()

   294

        self.inout_panel.SetAutoLayout(True)

   295

        self.inout_panel.SetSizer(self.inout_sizer)

   296

   297

        self.Initialize(self.inout_panel)

   298

   299

        self.Bind(wx.EVT_TOGGLEBUTTON, self.OnConnectButton, self.connect_button)

   300

   301

    def OnClose(self):

   302

        if self.client is not None:

   303

            asyncio.run(self.client.disconnect())

   304

            self.client = None

   305

   306

    def __del__(self):

   307

        self.OnClose()

   308

   309

    async def GetAsyncUANodeProperties(self, node):

   310

        properties = type("UANodeProperties",(),dict(

   311

                nsid = node.nodeid.NamespaceIndex,

   312

                nid =  node.nodeid.Identifier,

   313

                dname = (await node.read_display_name()).Text,

   314

                cname = (await node.read_node_class()).name,

   315

            ))

   316

        if properties.cname == "Variable":

   317

            properties.access = await node.get_access_level()

   318

            properties.variant_type = (await node.read_data_type_as_variant_type()).name

   319

        return properties

   320

   321

    @ExecuteSychronouslyWithTimeout(5)

   322

    async def ConnectAsyncUAClient(self, config):

   323

        client = Client(config["URI"])

   324

   325

        AuthType = config["AuthType"]

   326

        if AuthType=="UserPasword":

   327

            await client.set_user(config["User"])

   328

            await client.set_password(config["Password"])

   329

        elif AuthType=="x509":

   330

            await client.set_security_string(

   331

                "{Policy},{Mode},{Certificate},{PrivateKey}".format(**config))

   332

   333

        await client.connect()

   334

        self.client = client

   335

   336

        # load definition of server specific structures/extension objects

   337

        await self.client.load_type_definitions()

   338

   339

        # returns root node object and its properties

   340

        rootnode = self.client.get_root_node()

   341

        return rootnode, await self.GetAsyncUANodeProperties(rootnode)

   342

   343

    @ExecuteSychronously

   344

    async def DisconnectAsyncUAClient(self):

   345

        if self.client is not None:

   346

            await self.client.disconnect()

   347

            self.client = None

   348

   349

    @ExecuteSychronously

   350

    async def GetAsyncUANodeChildren(self, node):

   351

        children = await node.get_children()

   352

        return [ (child, await self.GetAsyncUANodeProperties(child)) for child in children]

   353

   354

    def OnConnectButton(self, event):

   355

        if self.connect_button.GetValue():

   356

   357

            config = self.config_getter()

   358

            self.log("OPCUA browser: connecting to {}\n".format(config["URI"]))

   359

   360

            try :

   361

                rootnode, rootnodeproperties = self.ConnectAsyncUAClient(config)

   362

            except Exception as e:

   363

                self.log("Exception in OPCUA browser: "+repr(e)+"\n")

   364

                self.client = None

   365

                self.connect_button.SetValue(False)

   366

                return

   367

   368

            self.tree_panel = wx.Panel(self)

   369

            self.tree_sizer = wx.FlexGridSizer(cols=1, hgap=0, rows=2, vgap=0)

   370

            self.tree_sizer.AddGrowableCol(0)

   371

            self.tree_sizer.AddGrowableRow(0)

   372

   373

            self.tree = gizmos.TreeListCtrl(self.tree_panel, -1, style=0, agwStyle=

   374

                                            gizmos.TR_DEFAULT_STYLE

   375

                                            | gizmos.TR_MULTIPLE

   376

                                            | gizmos.TR_FULL_ROW_HIGHLIGHT

   377

                                       )

   378

   379

            prepare_image_list()

   380

            self.tree.SetImageList(il)

   381

   382

            for idx,(colname, width) in enumerate(zip(treecolnames, treecolwidths)):

   383

                self.tree.AddColumn(colname)

   384

                self.tree.SetColumnWidth(idx, width)

   385

   386

            self.tree.SetMainColumn(0)

   387

   388

            rootitem = self.AddNodeItem(self.tree.AddRoot, rootnode, rootnodeproperties)

   389

   390

            # Populate first level so that root can be expanded

   391

            self.CreateSubItems(rootitem)

   392

   393

            self.tree.Bind(wx.EVT_TREE_ITEM_EXPANDED, self.OnExpand)

   394

   395

            self.tree.Bind(wx.EVT_TREE_SEL_CHANGED, self.OnTreeNodeSelection)

   396

            self.tree.Bind(wx.EVT_TREE_BEGIN_DRAG, self.OnTreeBeginDrag)

   397

   398

            self.tree.Expand(rootitem)

   399

   400

            hint = wx.StaticText(self.tree_panel, label = "Drag'n'drop desired variables from tree to Input or Output list")

   401

   402

            self.tree_sizer.Add(self.tree, flag=wx.GROW)

   403

            self.tree_sizer.Add(hint, flag=wx.GROW)

   404

            self.tree_sizer.Layout()

   405

            self.tree_panel.SetAutoLayout(True)

   406

            self.tree_panel.SetSizer(self.tree_sizer)

   407

   408

            self.SplitVertically(self.tree_panel, self.inout_panel, 500)

   409

        else:

   410

            self.DisconnectAsyncUAClient()

   411

            self.Unsplit(self.tree_panel)

   412

            self.tree_panel.Destroy()

   413

   414

    def CreateSubItems(self, item):

   415

        node, properties, browsed = self.tree.GetPyData(item)

   416

        if not browsed:

   417

            children = self.GetAsyncUANodeChildren(node)

   418

            for subnode, subproperties in children:

   419

                self.AddNodeItem(lambda n: self.tree.AppendItem(item, n), subnode, subproperties)

   420

            self.tree.SetPyData(item,(node, properties, True))

   421

   422

    def AddNodeItem(self, item_creation_func, node, properties):

   423

        item = item_creation_func(properties.dname)

   424

   425

        if properties.cname == "Variable":

   426

            access = properties.access

   427

            normalidx = fileidx

   428

            r = ua.AccessLevel.CurrentRead in access

   429

            w = ua.AccessLevel.CurrentWrite in access

   430

            if r and w:

   431

                ext = "RW"

   432

            elif r:

   433

                ext = "RO"

   434

            elif w:

   435

                ext = "WO"  # not sure this one exist

   436

            else:

   437

                ext = "no access"  # not sure this one exist

   438

            cname = "Var "+properties.variant_type+" (" + ext + ")"

   439

        else:

   440

            normalidx = fldridx

   441

   442

        self.tree.SetPyData(item,(node, properties, False))

   443

        self.tree.SetItemText(item, properties.cname, 1)

   444

        self.tree.SetItemText(item, str(properties.nsid), 2)

   445

        self.tree.SetItemText(item, type(properties.nid).__name__+": "+str(properties.nid), 3)

   446

        self.tree.SetItemImage(item, normalidx, which = wx.TreeItemIcon_Normal)

   447

        self.tree.SetItemImage(item, fldropenidx, which = wx.TreeItemIcon_Expanded)

   448

   449

        return item

   450

   451

    def OnExpand(self, evt):

   452

        for item in evt.GetItem().GetChildren():

   453

            self.CreateSubItems(item)

   454

   455

    # def OnActivate(self, evt):

   456

    #     item = evt.GetItem()

   457

    #     node, browsed = self.tree.GetPyData(item)

   458

   459

    def OnTreeNodeSelection(self, event):

   460

        items = self.tree.GetSelections()

   461

        items_pydata = [self.tree.GetPyData(item) for item in items]

   462

   463

        nps = [(node,properties) for node, properties, unused in items_pydata]

   464

   465

        # append new nodes to ordered list

   466

        for np in nps:

   467

            if np not in self.ordered_nps:

   468

                self.ordered_nps.append(np)

   469

   470

        # filter out vanished items

   471

        self.ordered_nps = [

   472

            np 

   473

            for np in self.ordered_nps 

   474

            if np in nps]

   475

   476

    def GetSelectedNodes(self):

   477

        return self.ordered_nps 

   478

   479

    def OnTreeBeginDrag(self, event):

   480

        """

   481

        Called when a drag is started in tree

   482

        @param event: wx.TreeEvent

   483

        """

   484

        if self.ordered_nps:

   485

            # Just send a recognizable mime-type, drop destination

   486

            # will get python data from parent

   487

            data = wx.CustomDataObject(OPCUAClientDndMagicWord)

   488

            dragSource = wx.DropSource(self)

   489

            dragSource.SetData(data)

   490

            dragSource.DoDragDrop()

   491

   492

    def Reset(self):

   493

        for direction in directions:

   494

            self.selected_models[direction].ResetData() 

   495

   496

   497

class OPCUAClientList(list):

   498

    def __init__(self, log, change_callback):

   499

        super(OPCUAClientList, self).__init__(self)

   500

        self.log = log

   501

        self.change_callback = change_callback

   502

   503

    def append(self, value):

   504

        v = dict(list(zip(lstcolnames, value)))

   505

   506

        if type(v["IEC"]) != int:

   507

            if len(self) == 0:

   508

                v["IEC"] = 0

   509

            else:

   510

                iecnums = set(zip(*self)[lstcolnames.index("IEC")])

   511

                greatest = max(iecnums)