1

import os

     2

import re

     3

from types import TupleType

     4

     5

import wx

     6

import wx.grid

     7

import wx.gizmos

     8

import wx.lib.buttons

     9

    10

from plcopen.structures import IEC_KEYWORDS, TestIdentifier

    11

from controls import CustomGrid, CustomTable, FolderTree

    12

from editors.ConfTreeNodeEditor import ConfTreeNodeEditor, SCROLLBAR_UNIT

    13

from util.BitmapLibrary import GetBitmap

    14

    15

[ETHERCAT_VENDOR, ETHERCAT_GROUP, ETHERCAT_DEVICE] = range(3)

    16

    17

def AppendMenu(parent, help, id, kind, text):

    18

    if wx.VERSION >= (2, 6, 0):

    19

        parent.Append(help=help, id=id, kind=kind, text=text)

    20

    else:

    21

        parent.Append(helpString=help, id=id, kind=kind, item=text)

    22

    23

def GetVariablesTableColnames(position=False):

    24

    _ = lambda x : x

    25

    colname = ["#"]

    26

    if position:

    27

        colname.append(_("Position"))

    28

    return colname + [_("Name"), _("Index"), _("SubIndex"), _("Type"), _("Access")]

    29

    30

ACCESS_TYPES = {

    31

    'ro': 'R',

    32

    'wo': 'W',

    33

    'rw': 'R/W'}

    34

    35

def GetAccessValue(access, pdo_mapping):

    36

    value = ACCESS_TYPES.get(access, "")

    37

    if pdo_mapping != "":

    38

        value += "/P"

    39

    return value

    40

    41

VARIABLES_FILTERS = [

    42

    (_("All"), (0x0000, 0xffff)),

    43

    (_("Communication Parameters"), (0x1000, 0x1fff)),

    44

    (_("Manufacturer Specific"), (0x2000, 0x5fff)),

    45

    (_("Standardized Device Profile"), (0x6000, 0x9fff))]

    46

    47

ETHERCAT_INDEX_MODEL = re.compile("#x([0-9a-fA-F]{0,4})$")

    48

ETHERCAT_SUBINDEX_MODEL = re.compile("#x([0-9a-fA-F]{0,2})$")

    49

LOCATION_MODEL = re.compile("(?:%[IQM](?:[XBWLD]?([0-9]+(?:\.[0-9]+)*)))$")

    50

    51

class NodeVariablesSizer(wx.FlexGridSizer):

    52

    53

    def __init__(self, parent, controler, position_column=False):

    54

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

    55

        self.AddGrowableCol(0)

    56

        self.AddGrowableRow(1)

    57

    58

        self.Controler = controler

    59

        self.PositionColumn = position_column

    60

    61

        self.VariablesFilter = wx.ComboBox(parent)

    62

        self.VariablesFilter.Bind(wx.EVT_COMBOBOX, self.OnVariablesFilterChanged)

    63

        self.AddWindow(self.VariablesFilter, flag=wx.GROW)

    64

    65

        self.VariablesGrid = wx.gizmos.TreeListCtrl(parent, 

    66

                style=wx.TR_DEFAULT_STYLE |

    67

                      wx.TR_ROW_LINES |

    68

                      wx.TR_COLUMN_LINES |

    69

                      wx.TR_HIDE_ROOT |

    70

                      wx.TR_FULL_ROW_HIGHLIGHT)

    71

        self.VariablesGrid.GetMainWindow().Bind(wx.EVT_LEFT_DOWN,

    72

            self.OnVariablesGridLeftClick)

    73

        self.AddWindow(self.VariablesGrid, flag=wx.GROW)

    74

    75

        self.Filters = []

    76

        for desc, value in VARIABLES_FILTERS:

    77

            self.VariablesFilter.Append(desc)

    78

            self.Filters.append(value)

    79

    80

        self.VariablesFilter.SetSelection(0)

    81

        self.CurrentFilter = self.Filters[0]

    82

    83

        if position_column:

    84

            for colname, colsize, colalign in zip(GetVariablesTableColnames(position_column),

    85

                                                  [40, 80, 350, 80, 100, 80, 80],

    86

                                                  [wx.ALIGN_RIGHT, wx.ALIGN_RIGHT, wx.ALIGN_LEFT, 

    87

                                                   wx.ALIGN_RIGHT, wx.ALIGN_RIGHT, wx.ALIGN_LEFT, 

    88

                                                   wx.ALIGN_LEFT]):

    89

                self.VariablesGrid.AddColumn(_(colname), colsize, colalign)

    90

            self.VariablesGrid.SetMainColumn(2)

    91

        else:

    92

            for colname, colsize, colalign in zip(GetVariablesTableColnames(),

    93

                                                  [40, 350, 80, 100, 80, 80],

    94

                                                  [wx.ALIGN_RIGHT, wx.ALIGN_LEFT, wx.ALIGN_RIGHT, 

    95

                                                   wx.ALIGN_RIGHT, wx.ALIGN_LEFT, wx.ALIGN_LEFT]):

    96

                self.VariablesGrid.AddColumn(_(colname), colsize, colalign)

    97

            self.VariablesGrid.SetMainColumn(1)

    98

    99

    def RefreshView(self):

   100

        entries = self.Controler.GetSlaveVariables(self.CurrentFilter)

   101

        self.RefreshVariablesGrid(entries)

   102

   103

    def RefreshVariablesGrid(self, entries):

   104

        root = self.VariablesGrid.GetRootItem()

   105

        if not root.IsOk():

   106

            root = self.VariablesGrid.AddRoot(_("Slave entries"))

   107

        self.GenerateVariablesGridBranch(root, entries, GetVariablesTableColnames(self.PositionColumn))

   108

        self.VariablesGrid.Expand(root)

   109

   110

    def GenerateVariablesGridBranch(self, root, entries, colnames, idx=0):

   111

        item, root_cookie = self.VariablesGrid.GetFirstChild(root)

   112

   113

        no_more_items = not item.IsOk()

   114

        for entry in entries:

   115

            idx += 1

   116

            if no_more_items:

   117

                item = self.VariablesGrid.AppendItem(root, "")

   118

            for col, colname in enumerate(colnames):

   119

                if col == 0:

   120

                    self.VariablesGrid.SetItemText(item, str(idx), 0)

   121

                else:

   122

                    value = entry.get(colname, "")

   123

                    if colname == "Access":

   124

                        value = GetAccessValue(value, entry.get("PDOMapping", ""))

   125

                    self.VariablesGrid.SetItemText(item, value, col)

   126

            if entry["PDOMapping"] == "":

   127

                self.VariablesGrid.SetItemBackgroundColour(item, wx.LIGHT_GREY)

   128

            else:

   129

                self.VariablesGrid.SetItemBackgroundColour(item, wx.WHITE)

   130

            self.VariablesGrid.SetItemPyData(item, entry)

   131

            idx = self.GenerateVariablesGridBranch(item, entry["children"], colnames, idx)

   132

            if not no_more_items:

   133

                item, root_cookie = self.VariablesGrid.GetNextChild(root, root_cookie)

   134

                no_more_items = not item.IsOk()

   135

   136

        if not no_more_items:

   137

            to_delete = []

   138

            while item.IsOk():

   139

                to_delete.append(item)

   140

                item, root_cookie = self.VariablesGrid.GetNextChild(root, root_cookie)

   141

            for item in to_delete:

   142

                self.VariablesGrid.Delete(item)

   143

   144

        return idx

   145

   146

    def OnVariablesFilterChanged(self, event):

   147

        filter = self.VariablesFilter.GetSelection()

   148

        if filter != -1:

   149

            self.CurrentFilter = self.Filters[filter]

   150

            self.RefreshView()

   151

        else:

   152

            try:

   153

                value = self.VariablesFilter.GetValue()

   154

                result = ETHERCAT_INDEX_MODEL.match(value)

   155

                if result is not None:

   156

                    value = result.group(1)

   157

                index = int(value)

   158

                self.CurrentFilter = (index, index)

   159

                self.RefreshView()

   160

            except:

   161

                pass

   162

        event.Skip()

   163

   164

    def OnVariablesGridLeftClick(self, event):

   165

        item, flags, col = self.VariablesGrid.HitTest(event.GetPosition())

   166

        if item.IsOk():

   167

            entry = self.VariablesGrid.GetItemPyData(item)

   168

            data_type = entry.get("Type", "")

   169

            data_size = self.Controler.GetSizeOfType(data_type)

   170

   171

            if col == -1 and data_size is not None:

   172

                pdo_mapping = entry.get("PDOMapping", "")

   173

                access = entry.get("Access", "")

   174

                entry_index = self.Controler.ExtractHexDecValue(entry.get("Index", "0"))

   175

                entry_subindex = self.Controler.ExtractHexDecValue(entry.get("SubIndex", "0"))

   176

                if self.PositionColumn:

   177

                    slave_pos = self.Controler.ExtractHexDecValue(entry.get("Position", "0"))

   178

                else:

   179

                    slave_pos = self.Controler.GetSlavePos()

   180

   181

                if pdo_mapping != "":

   182

                    var_name = "%s_%4.4x_%2.2x" % (self.Controler.CTNName(), entry_index, entry_subindex)

   183

                    if pdo_mapping == "R":

   184

                        dir = "%I"

   185

                    else:

   186

                        dir = "%Q"

   187

                    location = "%s%s" % (dir, data_size) + \

   188

                               ".".join(map(lambda x:str(x), self.Controler.GetCurrentLocation() + 

   189

                                                             (slave_pos, entry_index, entry_subindex)))

   190

   191

                    data = wx.TextDataObject(str((location, "location", data_type, var_name, "", access)))

   192

                    dragSource = wx.DropSource(self.VariablesGrid)

   193

                    dragSource.SetData(data)

   194

                    dragSource.DoDragDrop()

   195

                    return

   196

   197

                elif self.ColumnPosition:

   198

                    location = self.Controler.GetCurrentLocation() +\

   199

                               (slave_pos, entry_index, entry_subindex)

   200

                    data = wx.TextDataObject(str((location, "variable", access)))

   201

                    dragSource = wx.DropSource(self.VariablesGrid)

   202

                    dragSource.SetData(data)

   203

                    dragSource.DoDragDrop()

   204

                    return

   205

   206

        event.Skip()

   207

   208

class NodeEditor(ConfTreeNodeEditor):

   209

   210

    CONFNODEEDITOR_TABS = [

   211

        (_("Ethercat node"), "_create_EthercatNodeEditor")]

   212

   213

    def _create_EthercatNodeEditor(self, prnt):

   214

        self.EthercatNodeEditor = wx.Panel(prnt, style=wx.TAB_TRAVERSAL)

   215

   216

        main_sizer = wx.FlexGridSizer(cols=1, hgap=0, rows=2, vgap=5)

   217

        main_sizer.AddGrowableCol(0)

   218

        main_sizer.AddGrowableRow(1)

   219

   220

        variables_label = wx.StaticText(self.EthercatNodeEditor,

   221

              label=_('Variable entries:'))

   222

        main_sizer.AddWindow(variables_label, border=10, flag=wx.TOP|wx.LEFT|wx.RIGHT)

   223

   224

        self.NodeVariables = NodeVariablesSizer(self.EthercatNodeEditor, self.Controler)

   225

        main_sizer.AddSizer(self.NodeVariables, border=10, 

   226

            flag=wx.GROW|wx.BOTTOM|wx.LEFT|wx.RIGHT)

   227

   228

        self.EthercatNodeEditor.SetSizer(main_sizer)

   229

   230

        return self.EthercatNodeEditor

   231

   232

    def __init__(self, parent, controler, window):

   233

        ConfTreeNodeEditor.__init__(self, parent, controler, window)

   234

   235

    def GetBufferState(self):

   236

        return False, False

   237

   238

    def RefreshView(self):

   239

        ConfTreeNodeEditor.RefreshView(self)

   240

   241

        self.NodeVariables.RefreshView()

   242

   243

CIA402NodeEditor = NodeEditor

   244

   245

def GetProcessVariablesTableColnames():

   246

    _ = lambda x : x

   247

    return ["#", _("Name"), 

   248

            _("Read from (nodeid, index, subindex)"), 

   249

            _("Write to (nodeid, index, subindex)"),

   250

            _("Description")]

   251

   252

class ProcessVariablesTable(CustomTable):

   253

   254

    def GetValue(self, row, col):

   255

        if row < self.GetNumberRows():

   256

            if col == 0:

   257

                return row + 1

   258

            colname = self.GetColLabelValue(col, False)

   259

            if colname.startswith("Read from"):

   260

                value = self.data[row].get("ReadFrom", "")

   261

                if value == "":

   262

                    return value

   263

                return "%d, #x%0.4X, #x%0.2X" % value

   264

            elif colname.startswith("Write to"):

   265

                value = self.data[row].get("WriteTo", "")

   266

                if value == "":

   267

                    return value

   268

                return "%d, #x%0.4X, #x%0.2X" % value

   269

            return self.data[row].get(colname, "")

   270

   271

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

   272

        if col < len(self.colnames):

   273

            colname = self.GetColLabelValue(col, False)

   274

            if colname.startswith("Read from"):

   275

                self.data[row]["ReadFrom"] = value

   276

            elif colname.startswith("Write to"):

   277

                self.data[row]["WriteTo"] = value

   278

            else:

   279

                self.data[row][colname] = value

   280

   281

    def _updateColAttrs(self, grid):

   282

        """

   283

        wx.grid.Grid -> update the column attributes to add the

   284

        appropriate renderer given the column name.

   285

   286

        Otherwise default to the default renderer.

   287

        """

   288

        for row in range(self.GetNumberRows()):

   289

            for col in range(self.GetNumberCols()):

   290

                editor = None

   291

                renderer = None

   292

                colname = self.GetColLabelValue(col, False)

   293

                if colname in ["Name", "Description"]:

   294

                    editor = wx.grid.GridCellTextEditor()

   295

                    renderer = wx.grid.GridCellStringRenderer()

   296

                    grid.SetReadOnly(row, col, False)

   297

                else:

   298

                    grid.SetReadOnly(row, col, True)

   299

   300

                grid.SetCellEditor(row, col, editor)

   301

                grid.SetCellRenderer(row, col, renderer)

   302

   303

            self.ResizeRow(grid, row)

   304

   305

class ProcessVariableDropTarget(wx.TextDropTarget):

   306

   307

    def __init__(self, parent):

   308

        wx.TextDropTarget.__init__(self)

   309

        self.ParentWindow = parent

   310

   311

    def OnDropText(self, x, y, data):

   312

        self.ParentWindow.Select()

   313

        x, y = self.ParentWindow.ProcessVariablesGrid.CalcUnscrolledPosition(x, y)

   314

        col = self.ParentWindow.ProcessVariablesGrid.XToCol(x)

   315

        row = self.ParentWindow.ProcessVariablesGrid.YToRow(y - self.ParentWindow.ProcessVariablesGrid.GetColLabelSize())

   316

        message = None

   317

        try:

   318

            values = eval(data)

   319

        except:

   320

            message = _("Invalid value \"%s\" for process variable")%data

   321

            values = None

   322

        if not isinstance(values, TupleType):

   323

            message = _("Invalid value \"%s\" for process variable")%data

   324

            values = None

   325

        if values is not None and 2 <= col <= 3:

   326

            location = None

   327

            if values[1] == "location":

   328

                result = LOCATION_MODEL.match(values[0])

   329

                if result is not None:

   330

                    location = map(int, result.group(1).split('.'))

   331

                master_location = self.ParentWindow.GetMasterLocation()

   332

                if (master_location == tuple(location[:len(master_location)]) and 

   333

                    len(location) - len(master_location) == 3):

   334

                    values = tuple(location[len(master_location):])

   335

                    var_type = self.ParentWindow.Controler.GetSlaveVariableDataType(*values)

   336

                    if col == 2:

   337

                        other_values = self.ParentWindow.ProcessVariablesTable.GetValueByName(row, "WriteTo")

   338

                    else:

   339

                        other_values = self.ParentWindow.ProcessVariablesTable.GetValueByName(row, "ReadFrom")

   340

                    if other_values != "":

   341

                        other_type = self.ParentWindow.Controler.GetSlaveVariableDataType(*other_values)

   342

                    else:

   343

                        other_type = None

   344

                    if other_type is None or var_type == other_type:

   345

                        if col == 2:

   346

                            self.ParentWindow.ProcessVariablesTable.SetValueByName(row, "ReadFrom", values)

   347

                        else:

   348

                            self.ParentWindow.ProcessVariablesTable.SetValueByName(row, "WriteTo", values)

   349

                        self.ParentWindow.SaveProcessVariables()

   350

                        self.ParentWindow.RefreshProcessVariables()

   351

                    else:

   352

                        message = _("'Read from' and 'Write to' variables types are not compatible")

   353

                else:

   354

                    message = _("Invalid value \"%s\" for process variable")%data

   355

   356

        if message is not None:

   357

            wx.CallAfter(self.ShowMessage, message)

   358

   359

    def ShowMessage(self, message):

   360

        message = wx.MessageDialog(self.ParentWindow, message, _("Error"), wx.OK|wx.ICON_ERROR)

   361

        message.ShowModal()

   362

        message.Destroy()

   363

   364

def GetStartupCommandsTableColnames():

   365

    _ = lambda x : x

   366

    return [_("Position"), _("Index"), _("Subindex"), _("Value"), _("Description")]

   367

   368

class StartupCommandDropTarget(wx.TextDropTarget):

   369

   370

    def __init__(self, parent):

   371

        wx.TextDropTarget.__init__(self)

   372

        self.ParentWindow = parent

   373

   374

    def OnDropText(self, x, y, data):

   375

        self.ParentWindow.Select()

   376

        message = None

   377

        try:

   378

            values = eval(data)

   379

        except:

   380

            message = _("Invalid value \"%s\" for startup command")%data

   381

            values = None

   382

        if not isinstance(values, TupleType):

   383

            message = _("Invalid value \"%s\" for startup command")%data

   384

            values = None

   385

        if values is not None:

   386

            location = None

   387

            if values[1] == "location":

   388

                result = LOCATION_MODEL.match(values[0])

   389

                if result is not None and len(values) > 5:

   390

                    location = map(int, result.group(1).split('.'))

   391

                    access = values[5]

   392

            elif values[1] == "variable":

   393

                location = values[0]

   394

                access = values[2]

   395

            if location is not None:

   396

                master_location = self.ParentWindow.GetMasterLocation()

   397

                if (master_location == tuple(location[:len(master_location)]) and 

   398

                    len(location) - len(master_location) == 3):

   399

                    if access in ["wo", "rw"]:

   400

                        self.ParentWindow.AddStartupCommand(*location[len(master_location):])

   401

                    else:

   402

                        message = _("Entry can't be write through SDO")

   403

                else:

   404

                    message = _("Invalid value \"%s\" for startup command")%data

   405

   406

        if message is not None:

   407

            wx.CallAfter(self.ShowMessage, message)

   408

   409

    def ShowMessage(self, message):

   410

        message = wx.MessageDialog(self.ParentWindow, message, _("Error"), wx.OK|wx.ICON_ERROR)

   411

        message.ShowModal()

   412

        message.Destroy()

   413

   414

class StartupCommandsTable(CustomTable):

   415

   416

    """

   417

    A custom wx.grid.Grid Table using user supplied data

   418

    """

   419

    def __init__(self, parent, data, colnames):

   420

        # The base class must be initialized *first*

   421

        CustomTable.__init__(self, parent, data, colnames)

   422

        self.old_value = None

   423

   424

    def GetValue(self, row, col):

   425

        if row < self.GetNumberRows():

   426

            colname = self.GetColLabelValue(col, False)

   427

            value = self.data[row].get(colname, "")

   428

            if colname == "Index":

   429

                return "#x%0.4X" % value

   430

            elif colname == "Subindex":

   431

                return "#x%0.2X" % value

   432

            return value

   433

   434

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

   435

        if col < len(self.colnames):

   436

            colname = self.GetColLabelValue(col, False)

   437

            if colname in ["Index", "Subindex"]:

   438

                if colname == "Index":

   439

                    result = ETHERCAT_INDEX_MODEL.match(value)

   440

                else:

   441

                    result = ETHERCAT_SUBINDEX_MODEL.match(value)

   442

                if result is None:

   443

                    return

   444

                value = int(result.group(1), 16)

   445

            elif colname == "Value":

   446

                value = int(value)

   447

            elif colname == "Position":

   448

                self.old_value = self.data[row][colname]

   449

                value = int(value)

   450

            self.data[row][colname] = value

   451

   452

    def GetOldValue(self):

   453

        return self.old_value

   454

   455

    def _updateColAttrs(self, grid):

   456

        """

   457

        wx.grid.Grid -> update the column attributes to add the

   458

        appropriate renderer given the column name.

   459

   460

        Otherwise default to the default renderer.

   461

        """

   462

        for row in range(self.GetNumberRows()):

   463

            for col in range(self.GetNumberCols()):

   464

                editor = None

   465

                renderer = None

   466

                colname = self.GetColLabelValue(col, False)

   467

                if colname in ["Position", "Value"]:

   468

                    editor = wx.grid.GridCellNumberEditor()

   469

                    renderer = wx.grid.GridCellNumberRenderer()

   470

                else:

   471

                    editor = wx.grid.GridCellTextEditor()

   472

                    renderer = wx.grid.GridCellStringRenderer()

   473

   474

                grid.SetCellEditor(row, col, editor)

   475

                grid.SetCellRenderer(row, col, renderer)

   476

                grid.SetReadOnly(row, col, False)

   477

   478

            self.ResizeRow(grid, row)

   479

   480

    def GetCommandIndex(self, position, command_idx):

   481

        for row, command in enumerate(self.data):

   482

            if command["Position"] == position and command["command_idx"] == command_idx:

   483

                return row

   484

        return None

   485

   486

class MasterNodesVariablesSizer(NodeVariablesSizer):

   487

   488

    def __init__(self, parent, controler):

   489

        NodeVariablesSizer.__init__(self, parent, controler, True)

   490

   491

        self.CurrentNodesFilter = {}

   492

   493

    def SetCurrentNodesFilter(self, nodes_filter):