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, style=wx.TE_PROCESS_ENTER)

    62

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

    63

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

    64

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

    65

    66

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

    67

                style=wx.TR_DEFAULT_STYLE |

    68

                      wx.TR_ROW_LINES |

    69

                      wx.TR_COLUMN_LINES |

    70

                      wx.TR_HIDE_ROOT |

    71

                      wx.TR_FULL_ROW_HIGHLIGHT)

    72

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

    73

            self.OnVariablesGridLeftClick)

    74

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

    75

    76

        self.Filters = []

    77

        for desc, value in VARIABLES_FILTERS:

    78

            self.VariablesFilter.Append(desc)

    79

            self.Filters.append(value)

    80

    81

        self.VariablesFilter.SetSelection(0)

    82

        self.CurrentFilter = self.Filters[0]

    83

    84

        if position_column:

    85

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

    86

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

    87

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

    88

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

    89

                                                   wx.ALIGN_LEFT]):

    90

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

    91

            self.VariablesGrid.SetMainColumn(2)

    92

        else:

    93

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

    94

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

    95

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

    96

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

    97

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

    98

            self.VariablesGrid.SetMainColumn(1)

    99

   100

    def RefreshView(self):

   101

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

   102

        self.RefreshVariablesGrid(entries)

   103

   104

    def RefreshVariablesGrid(self, entries):

   105

        root = self.VariablesGrid.GetRootItem()

   106

        if not root.IsOk():

   107

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

   108

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

   109

        self.VariablesGrid.Expand(root)

   110

   111

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

   112

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

   113

   114

        no_more_items = not item.IsOk()

   115

        for entry in entries:

   116

            idx += 1

   117

            if no_more_items:

   118

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

   119

            for col, colname in enumerate(colnames):

   120

                if col == 0:

   121

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

   122

                else:

   123

                    value = entry.get(colname, "")

   124

                    if colname == "Access":

   125

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

   126

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

   127

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

   128

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

   129

            else:

   130

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

   131

            self.VariablesGrid.SetItemPyData(item, entry)

   132

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

   133

            if not no_more_items:

   134

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

   135

                no_more_items = not item.IsOk()

   136

   137

        if not no_more_items:

   138

            to_delete = []

   139

            while item.IsOk():

   140

                to_delete.append(item)

   141

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

   142

            for item in to_delete:

   143

                self.VariablesGrid.Delete(item)

   144

   145

        return idx

   146

   147

    def OnVariablesFilterChanged(self, event):

   148

        filter = self.VariablesFilter.GetSelection()

   149

        if filter != -1:

   150

            self.CurrentFilter = self.Filters[filter]

   151

            self.RefreshView()

   152

        else:

   153

            try:

   154

                value = self.VariablesFilter.GetValue()

   155

                result = ETHERCAT_INDEX_MODEL.match(value)

   156

                if result is not None:

   157

                    value = result.group(1)

   158

                index = int(value, 16)

   159

                self.CurrentFilter = (index, index)

   160

                self.RefreshView()

   161

            except:

   162

                pass

   163

        event.Skip()

   164

   165

    def OnVariablesGridLeftClick(self, event):

   166

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

   167

        if item.IsOk():

   168

            entry = self.VariablesGrid.GetItemPyData(item)

   169

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

   170

            data_size = self.Controler.GetSizeOfType(data_type)

   171

   172

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

   173

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

   174

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

   175

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

   176

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

   177

                if self.PositionColumn:

   178

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

   179

                else:

   180

                    slave_pos = self.Controler.GetSlavePos()

   181

   182

                if pdo_mapping != "":

   183

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

   184

                    if pdo_mapping == "R":

   185

                        dir = "%I"

   186

                    else:

   187

                        dir = "%Q"

   188

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

   189

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

   190

                                                             (slave_pos, entry_index, entry_subindex)))

   191

   192

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

   193

                    dragSource = wx.DropSource(self.VariablesGrid)

   194

                    dragSource.SetData(data)

   195

                    dragSource.DoDragDrop()

   196

                    return

   197

   198

                elif self.ColumnPosition:

   199

                    location = self.Controler.GetCurrentLocation() +\

   200

                               (slave_pos, entry_index, entry_subindex)

   201

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

   202

                    dragSource = wx.DropSource(self.VariablesGrid)

   203

                    dragSource.SetData(data)

   204

                    dragSource.DoDragDrop()

   205

                    return

   206

   207

        event.Skip()

   208

   209

class NodeEditor(ConfTreeNodeEditor):

   210

   211

    CONFNODEEDITOR_TABS = [

   212

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

   213

   214

    def _create_EthercatNodeEditor(self, prnt):

   215

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

   216

   217

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

   218

        main_sizer.AddGrowableCol(0)

   219

        main_sizer.AddGrowableRow(1)

   220

   221

        variables_label = wx.StaticText(self.EthercatNodeEditor,

   222

              label=_('Variable entries:'))

   223

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

   224

   225

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

   226

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

   227

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

   228

   229

        self.EthercatNodeEditor.SetSizer(main_sizer)

   230

   231

        return self.EthercatNodeEditor

   232

   233

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

   234

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

   235

   236

    def GetBufferState(self):

   237

        return False, False

   238

   239

    def RefreshView(self):

   240

        ConfTreeNodeEditor.RefreshView(self)

   241

   242

        self.NodeVariables.RefreshView()

   243

   244

CIA402NodeEditor = NodeEditor

   245

   246

def GetProcessVariablesTableColnames():

   247

    _ = lambda x : x

   248

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

   249

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

   250

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

   251

            _("Description")]

   252

   253

class ProcessVariablesTable(CustomTable):

   254

   255

    def GetValue(self, row, col):

   256

        if row < self.GetNumberRows():

   257

            if col == 0:

   258

                return row + 1

   259

            colname = self.GetColLabelValue(col, False)

   260

            if colname.startswith("Read from"):

   261

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

   262

                if value == "":

   263

                    return value

   264

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

   265

            elif colname.startswith("Write to"):

   266

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

   267

                if value == "":

   268

                    return value

   269

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

   270

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

   271

   272

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

   273

        if col < len(self.colnames):

   274

            colname = self.GetColLabelValue(col, False)

   275

            if colname.startswith("Read from"):

   276

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

   277

            elif colname.startswith("Write to"):

   278

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

   279

            else:

   280

                self.data[row][colname] = value

   281

   282

    def _updateColAttrs(self, grid):

   283

        """

   284

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

   285

        appropriate renderer given the column name.

   286

   287

        Otherwise default to the default renderer.

   288

        """

   289

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

   290

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

   291

                editor = None

   292

                renderer = None

   293

                colname = self.GetColLabelValue(col, False)

   294

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

   295

                    editor = wx.grid.GridCellTextEditor()

   296

                    renderer = wx.grid.GridCellStringRenderer()

   297

                    grid.SetReadOnly(row, col, False)

   298

                else:

   299

                    grid.SetReadOnly(row, col, True)

   300

   301

                grid.SetCellEditor(row, col, editor)

   302

                grid.SetCellRenderer(row, col, renderer)

   303

   304

            self.ResizeRow(grid, row)

   305

   306

class ProcessVariableDropTarget(wx.TextDropTarget):

   307

   308

    def __init__(self, parent):

   309

        wx.TextDropTarget.__init__(self)

   310

        self.ParentWindow = parent

   311

   312

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

   313

        self.ParentWindow.Select()

   314

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

   315

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

   316

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

   317

        message = None

   318

        try:

   319

            values = eval(data)

   320

        except:

   321

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

   322

            values = None

   323

        if not isinstance(values, TupleType):

   324

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

   325

            values = None

   326

        if values is not None and col != wx.NOT_FOUND and row != wx.NOT_FOUND and 2 <= col <= 3:

   327

            location = None

   328

            if values[1] == "location":

   329

                result = LOCATION_MODEL.match(values[0])

   330

                if result is not None:

   331

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

   332

                master_location = self.ParentWindow.GetMasterLocation()

   333

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

   334

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

   335

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

   336

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

   337

                    if col == 2:

   338

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

   339

                    else:

   340

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

   341

                    if other_values != "":

   342

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

   343

                    else:

   344

                        other_type = None

   345

                    if other_type is None or var_type == other_type:

   346

                        if col == 2:

   347

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

   348

                        else:

   349

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

   350

                        self.ParentWindow.SaveProcessVariables()

   351

                        self.ParentWindow.RefreshProcessVariables()

   352

                    else:

   353

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

   354

                else:

   355

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

   356

   357

        if message is not None:

   358

            wx.CallAfter(self.ShowMessage, message)

   359

   360

    def ShowMessage(self, message):

   361

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

   362

        message.ShowModal()

   363

        message.Destroy()

   364

   365

def GetStartupCommandsTableColnames():

   366

    _ = lambda x : x

   367

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

   368

   369

class StartupCommandDropTarget(wx.TextDropTarget):

   370

   371

    def __init__(self, parent):

   372

        wx.TextDropTarget.__init__(self)

   373

        self.ParentWindow = parent

   374

   375

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

   376

        self.ParentWindow.Select()

   377

        message = None

   378

        try:

   379

            values = eval(data)

   380

        except:

   381

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

   382

            values = None

   383

        if not isinstance(values, TupleType):

   384

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

   385

            values = None

   386

        if values is not None:

   387

            location = None

   388

            if values[1] == "location":

   389

                result = LOCATION_MODEL.match(values[0])

   390

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

   391

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

   392

                    access = values[5]

   393

            elif values[1] == "variable":

   394

                location = values[0]

   395

                access = values[2]

   396

            if location is not None:

   397

                master_location = self.ParentWindow.GetMasterLocation()

   398

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

   399

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

   400

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

   401

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

   402

                    else:

   403

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

   404

                else:

   405

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

   406

   407

        if message is not None:

   408

            wx.CallAfter(self.ShowMessage, message)

   409

   410

    def ShowMessage(self, message):

   411

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

   412

        message.ShowModal()

   413

        message.Destroy()

   414

   415

class StartupCommandsTable(CustomTable):

   416

   417

    """

   418

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

   419

    """

   420

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

   421

        # The base class must be initialized *first*

   422

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

   423

        self.old_value = None

   424

   425

    def GetValue(self, row, col):

   426

        if row < self.GetNumberRows():

   427

            colname = self.GetColLabelValue(col, False)

   428

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

   429

            if colname == "Index":

   430

                return "#x%0.4X" % value

   431

            elif colname == "Subindex":

   432

                return "#x%0.2X" % value

   433

            return value

   434

   435

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

   436

        if col < len(self.colnames):

   437

            colname = self.GetColLabelValue(col, False)

   438

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

   439

                if colname == "Index":

   440

                    result = ETHERCAT_INDEX_MODEL.match(value)

   441

                else:

   442

                    result = ETHERCAT_SUBINDEX_MODEL.match(value)

   443

                if result is None:

   444

                    return

   445

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

   446

            elif colname == "Value":

   447

                value = int(value)

   448

            elif colname == "Position":

   449

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

   450

                value = int(value)

   451

            self.data[row][colname] = value

   452

   453

    def GetOldValue(self):

   454

        return self.old_value

   455

   456

    def _updateColAttrs(self, grid):

   457

        """

   458

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

   459

        appropriate renderer given the column name.

   460

   461

        Otherwise default to the default renderer.

   462

        """

   463

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

   464

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

   465

                editor = None

   466

                renderer = None

   467

                colname = self.GetColLabelValue(col, False)

   468

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

   469

                    editor = wx.grid.GridCellNumberEditor()

   470

                    renderer = wx.grid.GridCellNumberRenderer()

   471

                else:

   472

                    editor = wx.grid.GridCellTextEditor()

   473

                    renderer = wx.grid.GridCellStringRenderer()

   474

   475

                grid.SetCellEditor(row, col, editor)

   476

                grid.SetCellRenderer(row, col, renderer)

   477

                grid.SetReadOnly(row, col, False)

   478

   479

            self.ResizeRow(grid, row)

   480

   481

    def GetCommandIndex(self, position, command_idx):

   482

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

   483

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

   484

                return row

   485

        return None

   486

   487

class MasterNodesVariablesSizer(NodeVariablesSizer):

   488

   489

    def __init__(self, parent, controler):

   490

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

   491

   492

        self.CurrentNodesFilter = {}