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 = "SDO: %s" % ACCESS_TYPES.get(access, "")

    37

    if pdo_mapping != "":

    38

        value += ", PDO: %s" % pdo_mapping

    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

VARIABLE_INDEX_FILTER_FORMAT = _("Variable Index: #x%4.4X")

    48

    49

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

    50

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

    51

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

    52

    53

NAVIGATION_KEYS = [

    54

    wx.WXK_END,

    55

    wx.WXK_HOME,

    56

    wx.WXK_LEFT,

    57

    wx.WXK_UP,

    58

    wx.WXK_RIGHT,

    59

    wx.WXK_DOWN,

    60

    wx.WXK_PAGEUP,

    61

    wx.WXK_PAGEDOWN,

    62

    wx.WXK_NUMPAD_HOME,

    63

    wx.WXK_NUMPAD_LEFT,

    64

    wx.WXK_NUMPAD_UP,

    65

    wx.WXK_NUMPAD_RIGHT,

    66

    wx.WXK_NUMPAD_DOWN,

    67

    wx.WXK_NUMPAD_PAGEUP,

    68

    wx.WXK_NUMPAD_PAGEDOWN,

    69

    wx.WXK_NUMPAD_END]

    70

    71

class NodeVariablesSizer(wx.FlexGridSizer):

    72

    73

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

    74

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

    75

        self.AddGrowableCol(0)

    76

        self.AddGrowableRow(1)

    77

    78

        self.Controler = controler

    79

        self.PositionColumn = position_column

    80

    81

        self.VariablesFilter = wx.ComboBox(parent, style=wx.TE_PROCESS_ENTER)

    82

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

    83

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

    84

        self.VariablesFilter.Bind(wx.EVT_CHAR, self.OnVariablesFilterKeyDown)

    85

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

    86

    87

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

    88

                style=wx.TR_DEFAULT_STYLE |

    89

                      wx.TR_ROW_LINES |

    90

                      wx.TR_COLUMN_LINES |

    91

                      wx.TR_HIDE_ROOT |

    92

                      wx.TR_FULL_ROW_HIGHLIGHT)

    93

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

    94

            self.OnVariablesGridLeftClick)

    95

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

    96

    97

        self.Filters = []

    98

        for desc, value in VARIABLES_FILTERS:

    99

            self.VariablesFilter.Append(desc)

   100

            self.Filters.append(value)

   101

   102

        self.VariablesFilter.SetSelection(0)

   103

        self.CurrentFilter = self.Filters[0]

   104

        self.VariablesFilterFirstCharacter = True

   105

   106

        if position_column:

   107

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

   108

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

   109

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

   110

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

   111

                                                   wx.ALIGN_LEFT]):

   112

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

   113

            self.VariablesGrid.SetMainColumn(2)

   114

        else:

   115

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

   116

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

   117

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

   118

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

   119

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

   120

            self.VariablesGrid.SetMainColumn(1)

   121

   122

    def RefreshView(self):

   123

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

   124

        self.RefreshVariablesGrid(entries)

   125

   126

    def RefreshVariablesGrid(self, entries):

   127

        root = self.VariablesGrid.GetRootItem()

   128

        if not root.IsOk():

   129

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

   130

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

   131

        self.VariablesGrid.Expand(root)

   132

   133

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

   134

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

   135

   136

        no_more_items = not item.IsOk()

   137

        for entry in entries:

   138

            idx += 1

   139

            if no_more_items:

   140

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

   141

            for col, colname in enumerate(colnames):

   142

                if col == 0:

   143

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

   144

                else:

   145

                    value = entry.get(colname, "")

   146

                    if colname == "Access":

   147

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

   148

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

   149

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

   150

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

   151

            else:

   152

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

   153

            self.VariablesGrid.SetItemPyData(item, entry)

   154

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

   155

            if not no_more_items:

   156

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

   157

                no_more_items = not item.IsOk()

   158

   159

        if not no_more_items:

   160

            to_delete = []

   161

            while item.IsOk():

   162

                to_delete.append(item)

   163

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

   164

            for item in to_delete:

   165

                self.VariablesGrid.Delete(item)

   166

   167

        return idx

   168

   169

    def OnVariablesFilterChanged(self, event):

   170

        filter = self.VariablesFilter.GetSelection()

   171

        if filter != -1:

   172

            self.CurrentFilter = self.Filters[filter]

   173

            self.RefreshView()

   174

        else:

   175

            try:

   176

                value = self.VariablesFilter.GetValue()

   177

                if value == "":

   178

                    self.CurrentFilter = self.Filters[0]

   179

                    self.VariablesFilter.SetSelection(0)

   180

                else:

   181

                    result = ETHERCAT_INDEX_MODEL.match(value)

   182

                    if result is not None:

   183

                        value = result.group(1)

   184

                    index = int(value, 16)

   185

                    self.CurrentFilter = (index, index)

   186

                    self.VariablesFilter.SetValue(VARIABLE_INDEX_FILTER_FORMAT % index)

   187

                self.RefreshView()

   188

            except:

   189

                if self.CurrentFilter in self.Filters:

   190

                    self.VariablesFilter.SetSelection(self.Filters.index(self.CurrentFilter))

   191

                else:

   192

                    self.VariablesFilter.SetValue(VARIABLE_INDEX_FILTER_FORMAT % self.CurrentFilter[0])

   193

        self.VariablesFilterFirstCharacter = True

   194

        event.Skip()

   195

   196

    def OnVariablesFilterKeyDown(self, event):

   197

        if self.VariablesFilterFirstCharacter:

   198

            keycode = event.GetKeyCode()

   199

            if keycode not in [wx.WXK_RETURN, 

   200

                               wx.WXK_NUMPAD_ENTER]:

   201

                self.VariablesFilterFirstCharacter = False

   202

                if keycode not in NAVIGATION_KEYS:

   203

                    self.VariablesFilter.SetValue("")

   204

            if keycode not in [wx.WXK_DELETE, 

   205

                               wx.WXK_NUMPAD_DELETE, 

   206

                               wx.WXK_BACK]:

   207

                event.Skip()

   208

        else:

   209

            event.Skip()

   210

   211

    def OnVariablesGridLeftClick(self, event):

   212

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

   213

        if item.IsOk():

   214

            entry = self.VariablesGrid.GetItemPyData(item)

   215

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

   216

            data_size = self.Controler.GetSizeOfType(data_type)

   217

   218

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

   219

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

   220

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

   221

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

   222

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

   223

                location = self.Controler.GetCurrentLocation()

   224

                if self.PositionColumn:

   225

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

   226

                    location += (slave_pos,)

   227

                    node_name = self.Controler.GetSlaveName(slave_pos)

   228

                else:

   229

                    node_name = self.Controler.CTNName()

   230

   231

                if pdo_mapping != "":

   232

                    var_name = "%s_%4.4x_%2.2x" % (node_name, entry_index, entry_subindex)

   233

                    if pdo_mapping == "T":

   234

                        dir = "%I"

   235

                    else:

   236

                        dir = "%Q"

   237

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

   238

                               ".".join(map(lambda x:str(x), location + (entry_index, entry_subindex)))

   239

   240

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

   241

                    dragSource = wx.DropSource(self.VariablesGrid)

   242

                    dragSource.SetData(data)

   243

                    dragSource.DoDragDrop()

   244

                    return

   245

   246

                elif self.PositionColumn:

   247

                    location = self.Controler.GetCurrentLocation() +\

   248

                               (slave_pos, entry_index, entry_subindex)

   249

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

   250

                    dragSource = wx.DropSource(self.VariablesGrid)

   251

                    dragSource.SetData(data)

   252

                    dragSource.DoDragDrop()

   253

                    return

   254

   255

        event.Skip()

   256

   257

class NodeEditor(ConfTreeNodeEditor):

   258

   259

    CONFNODEEDITOR_TABS = [

   260

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

   261

   262

    def _create_EthercatNodeEditor(self, prnt):

   263

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

   264

   265

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

   266

        main_sizer.AddGrowableCol(0)

   267

        main_sizer.AddGrowableRow(1)

   268

   269

        variables_label = wx.StaticText(self.EthercatNodeEditor,

   270

              label=_('Variable entries:'))

   271

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

   272

   273

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

   274

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

   275

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

   276

   277

        self.EthercatNodeEditor.SetSizer(main_sizer)

   278

   279

        return self.EthercatNodeEditor

   280

   281

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

   282

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

   283

   284

    def GetBufferState(self):

   285

        return False, False

   286

   287

    def RefreshView(self):

   288

        ConfTreeNodeEditor.RefreshView(self)

   289

   290

        self.NodeVariables.RefreshView()

   291

   292

CIA402NodeEditor = NodeEditor

   293

   294

def GetProcessVariablesTableColnames():

   295

    _ = lambda x : x

   296

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

   297

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

   298

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

   299

            _("Description")]

   300

   301

class ProcessVariablesTable(CustomTable):

   302

   303

    def GetValue(self, row, col):

   304

        if row < self.GetNumberRows():

   305

            if col == 0:

   306

                return row + 1

   307

            colname = self.GetColLabelValue(col, False)

   308

            if colname.startswith("Read from"):

   309

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

   310

                if value == "":

   311

                    return value

   312

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

   313

            elif colname.startswith("Write to"):

   314

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

   315

                if value == "":

   316

                    return value

   317

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

   318

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

   319

   320

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

   321

        if col < len(self.colnames):

   322

            colname = self.GetColLabelValue(col, False)

   323

            if colname.startswith("Read from"):

   324

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

   325

            elif colname.startswith("Write to"):

   326

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

   327

            else:

   328

                self.data[row][colname] = value

   329

   330

    def _updateColAttrs(self, grid):

   331

        """

   332

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

   333

        appropriate renderer given the column name.

   334

   335

        Otherwise default to the default renderer.

   336

        """

   337

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

   338

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

   339

                editor = None

   340

                renderer = None

   341

                colname = self.GetColLabelValue(col, False)

   342

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

   343

                    editor = wx.grid.GridCellTextEditor()

   344

                    renderer = wx.grid.GridCellStringRenderer()

   345

                    grid.SetReadOnly(row, col, False)

   346

                else:

   347

                    grid.SetReadOnly(row, col, True)

   348

   349

                grid.SetCellEditor(row, col, editor)

   350

                grid.SetCellRenderer(row, col, renderer)

   351

   352

            self.ResizeRow(grid, row)

   353

   354

class ProcessVariableDropTarget(wx.TextDropTarget):

   355

   356

    def __init__(self, parent):

   357

        wx.TextDropTarget.__init__(self)

   358

        self.ParentWindow = parent

   359

   360

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

   361

        self.ParentWindow.Select()

   362

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

   363

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

   364

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

   365

        message = None

   366

        try:

   367

            values = eval(data)

   368

        except:

   369

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

   370

            values = None

   371

        if not isinstance(values, TupleType):

   372

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

   373

            values = None

   374

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

   375

            location = None

   376

            if values[1] == "location":

   377

                result = LOCATION_MODEL.match(values[0])

   378

                if result is not None:

   379

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

   380

                master_location = self.ParentWindow.GetMasterLocation()

   381

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

   382

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

   383

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

   384

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

   385

                    if col == 2:

   386

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

   387

                    else:

   388

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

   389

                    if other_values != "":

   390

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

   391

                    else:

   392

                        other_type = None

   393

                    if other_type is None or var_type == other_type:

   394

                        if col == 2:

   395

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

   396

                        else:

   397

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

   398

                        self.ParentWindow.SaveProcessVariables()

   399

                        self.ParentWindow.RefreshProcessVariables()

   400

                    else:

   401

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

   402

                else:

   403

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

   404

   405

        if message is not None:

   406

            wx.CallAfter(self.ShowMessage, message)

   407

   408

    def ShowMessage(self, message):

   409

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

   410

        message.ShowModal()

   411

        message.Destroy()

   412

   413

def GetStartupCommandsTableColnames():

   414

    _ = lambda x : x

   415

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

   416

   417

class StartupCommandDropTarget(wx.TextDropTarget):

   418

   419

    def __init__(self, parent):

   420

        wx.TextDropTarget.__init__(self)

   421

        self.ParentWindow = parent

   422

   423

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

   424

        self.ParentWindow.Select()

   425

        message = None

   426

        try:

   427

            values = eval(data)

   428

        except:

   429

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

   430

            values = None

   431

        if not isinstance(values, TupleType):

   432

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

   433

            values = None

   434

        if values is not None:

   435

            location = None

   436

            if values[1] == "location":

   437

                result = LOCATION_MODEL.match(values[0])

   438

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

   439

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

   440

                    access = values[5]

   441

            elif values[1] == "variable":

   442

                location = values[0]

   443

                access = values[2]

   444

            if location is not None:

   445

                master_location = self.ParentWindow.GetMasterLocation()

   446

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

   447

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

   448

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

   449

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

   450

                    else:

   451

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

   452

                else:

   453

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

   454

   455

        if message is not None:

   456

            wx.CallAfter(self.ShowMessage, message)

   457

   458

    def ShowMessage(self, message):

   459

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

   460

        message.ShowModal()

   461

        message.Destroy()

   462

   463

class StartupCommandsTable(CustomTable):

   464

   465

    """

   466

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

   467

    """

   468

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

   469

        # The base class must be initialized *first*

   470

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

   471

        self.old_value = None

   472

   473

    def GetValue(self, row, col):

   474

        if row < self.GetNumberRows():

   475

            colname = self.GetColLabelValue(col, False)

   476

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

   477

            if colname == "Index":

   478

                return "#x%0.4X" % value

   479

            elif colname == "Subindex":

   480

                return "#x%0.2X" % value

   481

            return value

   482

   483

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

   484

        if col < len(self.colnames):

   485

            colname = self.GetColLabelValue(col, False)

   486

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

   487

                if colname == "Index":

   488

                    result = ETHERCAT_INDEX_MODEL.match(value)

   489

                else:

   490

                    result = ETHERCAT_SUBINDEX_MODEL.match(value)

   491

                if result is None: