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"))

   178

                if self.PositionColumn:

   179

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

   182

                else:

   184

   185

                if pdo_mapping != "":

   188

                        dir = "%I"

   189

                    else:

   190

                        dir = "%Q"

   191

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

   193

   194

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

   195

                    dragSource = wx.DropSource(self.VariablesGrid)

   196

                    dragSource.SetData(data)

   197

                    dragSource.DoDragDrop()

   198

                    return

   199

   201

                    location = self.Controler.GetCurrentLocation() +\

   202

                               (slave_pos, entry_index, entry_subindex)

   203

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

   204

                    dragSource = wx.DropSource(self.VariablesGrid)

   205

                    dragSource.SetData(data)

   206

                    dragSource.DoDragDrop()

   207

                    return

   208

   209

        event.Skip()

   210

   211

class NodeEditor(ConfTreeNodeEditor):

   212

   213

    CONFNODEEDITOR_TABS = [

   214

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

   215

   216

    def _create_EthercatNodeEditor(self, prnt):

   217

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

   218

   219

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

   220

        main_sizer.AddGrowableCol(0)

   221

        main_sizer.AddGrowableRow(1)

   222

   223

        variables_label = wx.StaticText(self.EthercatNodeEditor,

   224

              label=_('Variable entries:'))

   225

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

   226

   227

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

   228

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

   229

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

   230

   231

        self.EthercatNodeEditor.SetSizer(main_sizer)

   232

   233

        return self.EthercatNodeEditor

   234

   235

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

   236

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

   237

   238

    def GetBufferState(self):

   239

        return False, False

   240

   241

    def RefreshView(self):

   242

        ConfTreeNodeEditor.RefreshView(self)

   243

   244

        self.NodeVariables.RefreshView()

   245

   246

CIA402NodeEditor = NodeEditor

   247

   248

def GetProcessVariablesTableColnames():

   249

    _ = lambda x : x

   250

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

   251

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

   252

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

   253

            _("Description")]

   254

   255

class ProcessVariablesTable(CustomTable):

   256

   257

    def GetValue(self, row, col):

   258

        if row < self.GetNumberRows():

   259

            if col == 0:

   260

                return row + 1

   261

            colname = self.GetColLabelValue(col, False)

   262

            if colname.startswith("Read from"):

   263

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

   264

                if value == "":

   265

                    return value

   266

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

   267

            elif colname.startswith("Write to"):

   268

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

   269

                if value == "":

   270

                    return value

   271

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

   272

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

   273

   274

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

   275

        if col < len(self.colnames):

   276

            colname = self.GetColLabelValue(col, False)

   277

            if colname.startswith("Read from"):

   278

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

   279

            elif colname.startswith("Write to"):

   280

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

   281

            else:

   282

                self.data[row][colname] = value

   283

   284

    def _updateColAttrs(self, grid):

   285

        """

   286

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

   287

        appropriate renderer given the column name.

   288

   289

        Otherwise default to the default renderer.

   290

        """

   291

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

   292

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

   293

                editor = None

   294

                renderer = None

   295

                colname = self.GetColLabelValue(col, False)

   296

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

   297

                    editor = wx.grid.GridCellTextEditor()

   298

                    renderer = wx.grid.GridCellStringRenderer()

   299

                    grid.SetReadOnly(row, col, False)

   300

                else:

   301

                    grid.SetReadOnly(row, col, True)

   302

   303

                grid.SetCellEditor(row, col, editor)

   304

                grid.SetCellRenderer(row, col, renderer)

   305

   306

            self.ResizeRow(grid, row)

   307

   308

class ProcessVariableDropTarget(wx.TextDropTarget):

   309

   310

    def __init__(self, parent):

   311

        wx.TextDropTarget.__init__(self)

   312

        self.ParentWindow = parent

   313

   314

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

   315

        self.ParentWindow.Select()

   316

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

   317

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

   318

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

   319

        message = None

   320

        try:

   321

            values = eval(data)

   322

        except:

   323

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

   324

            values = None

   325

        if not isinstance(values, TupleType):

   326

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

   327

            values = None

   328

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

   329

            location = None

   330

            if values[1] == "location":

   331

                result = LOCATION_MODEL.match(values[0])

   332

                if result is not None:

   333

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

   334

                master_location = self.ParentWindow.GetMasterLocation()

   335

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

   336

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

   337

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

   338

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

   339

                    if col == 2:

   340

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

   341

                    else:

   342

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

   343

                    if other_values != "":

   344

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

   345

                    else:

   346

                        other_type = None

   347

                    if other_type is None or var_type == other_type:

   348

                        if col == 2:

   349

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

   350

                        else:

   351

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

   352

                        self.ParentWindow.SaveProcessVariables()

   353

                        self.ParentWindow.RefreshProcessVariables()

   354

                    else:

   355

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

   356

                else:

   357

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

   358

   359

        if message is not None:

   360

            wx.CallAfter(self.ShowMessage, message)

   361

   362

    def ShowMessage(self, message):

   363

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

   364

        message.ShowModal()

   365

        message.Destroy()

   366

   367

def GetStartupCommandsTableColnames():

   368

    _ = lambda x : x

   369

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

   370

   371

class StartupCommandDropTarget(wx.TextDropTarget):

   372

   373

    def __init__(self, parent):

   374

        wx.TextDropTarget.__init__(self)

   375

        self.ParentWindow = parent

   376

   377

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

   378

        self.ParentWindow.Select()

   379

        message = None

   380

        try:

   381

            values = eval(data)

   382

        except:

   383

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

   384

            values = None

   385

        if not isinstance(values, TupleType):

   386

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

   387

            values = None

   388

        if values is not None:

   389

            location = None

   390

            if values[1] == "location":

   391

                result = LOCATION_MODEL.match(values[0])

   392

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

   393

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

   394

                    access = values[5]

   395

            elif values[1] == "variable":

   396

                location = values[0]

   397

                access = values[2]

   398

            if location is not None:

   399

                master_location = self.ParentWindow.GetMasterLocation()

   400

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

   401

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

   402

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

   403

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

   404

                    else:

   405

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

   406

                else:

   407

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

   408

   409

        if message is not None:

   410

            wx.CallAfter(self.ShowMessage, message)

   411

   412

    def ShowMessage(self, message):

   413

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

   414

        message.ShowModal()

   415

        message.Destroy()

   416

   417

class StartupCommandsTable(CustomTable):

   418

   419

    """

   420

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

   421

    """

   422

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

   423

        # The base class must be initialized *first*

   424

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

   425

        self.old_value = None

   426

   427

    def GetValue(self, row, col):

   428

        if row < self.GetNumberRows():

   429

            colname = self.GetColLabelValue(col, False)

   430

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

   431

            if colname == "Index":

   432

                return "#x%0.4X" % value

   433

            elif colname == "Subindex":

   434

                return "#x%0.2X" % value

   435

            return value

   436

   437

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

   438

        if col < len(self.colnames):

   439

            colname = self.GetColLabelValue(col, False)

   440

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

   441

                if colname == "Index":

   442

                    result = ETHERCAT_INDEX_MODEL.match(value)

   443

                else:

   444

                    result = ETHERCAT_SUBINDEX_MODEL.match(value)

   445

                if result is None:

   446

                    return

   447

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

   448

            elif colname == "Value":

   449

                value = int(value)

   450

            elif colname == "Position":

   451

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

   452

                value = int(value)

   453

            self.data[row][colname] = value

   454

   455

    def GetOldValue(self):

   456

        return self.old_value

   457

   458

    def _updateColAttrs(self, grid):

   459

        """

   460

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

   461

        appropriate renderer given the column name.

   462

   463

        Otherwise default to the default renderer.

   464

        """

   465

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

   466

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

   467

                editor = None

   468

                renderer = None

   469

                colname = self.GetColLabelValue(col, False)

   470

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

   471

                    editor = wx.grid.GridCellNumberEditor()

   472

                    renderer = wx.grid.GridCellNumberRenderer()

   473

                else:

   474

                    editor = wx.grid.GridCellTextEditor()

   475

                    renderer = wx.grid.GridCellStringRenderer()

   476

   477

                grid.SetCellEditor(row, col, editor)

   478

                grid.SetCellRenderer(row, col, renderer)

   479

                grid.SetReadOnly(row, col, False)

   480

   481

            self.ResizeRow(grid, row)

   482

   483

    def GetCommandIndex(self, position, command_idx):

   484

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

   485

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

   486

                return row

   487

        return None

   488

   489

class MasterNodesVariablesSizer(NodeVariablesSizer):

   490

   491

    def __init__(self, parent, controler):

   492

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