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

from controls.CustomStyledTextCtrl import NAVIGATION_KEYS

    15

    16

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

    17

    18

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

    19

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

    20

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

    21

    else:

    22

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

    23

    24

def GetVariablesTableColnames(position=False):

    25

    _ = lambda x : x

    26

    colname = ["#"]

    27

    if position:

    28

        colname.append(_("Position"))

    29

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

    30

    31

ACCESS_TYPES = {

    32

    'ro': 'R',

    33

    'wo': 'W',

    34

    'rw': 'R/W'}

    35

    36

def GetAccessValue(access, pdo_mapping):

    37

    value = "SDO: %s" % ACCESS_TYPES.get(access, "")

    38

    if pdo_mapping != "":

    39

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

    40

    return value

    41

    42

VARIABLES_FILTERS = [

    43

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

    44

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

    45

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

    46

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

    47

    48

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

    49

    50

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

    51

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

    52

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

    53

    54

class NodeVariablesSizer(wx.FlexGridSizer):

    55

    56

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

    57

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

    58

        self.AddGrowableCol(0)

    59

        self.AddGrowableRow(1)

    60

    61

        self.Controler = controler

    62

        self.PositionColumn = position_column

    63

    64

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

    65

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

    66

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

    67

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

    68

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

    69

    70

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

    71

                style=wx.TR_DEFAULT_STYLE |

    72

                      wx.TR_ROW_LINES |

    73

                      wx.TR_COLUMN_LINES |

    74

                      wx.TR_HIDE_ROOT |

    75

                      wx.TR_FULL_ROW_HIGHLIGHT)

    76

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

    77

            self.OnVariablesGridLeftClick)

    78

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

    79

    80

        self.Filters = []

    81

        for desc, value in VARIABLES_FILTERS:

    82

            self.VariablesFilter.Append(desc)

    83

            self.Filters.append(value)

    84

    85

        self.VariablesFilter.SetSelection(0)

    86

        self.CurrentFilter = self.Filters[0]

    87

        self.VariablesFilterFirstCharacter = True

    88

    89

        if position_column:

    90

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

    91

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

    92

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

    93

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

    94

                                                   wx.ALIGN_LEFT]):

    95

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

    96

            self.VariablesGrid.SetMainColumn(2)

    97

        else:

    98

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

    99

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

   100

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

   101

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

   102

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

   103

            self.VariablesGrid.SetMainColumn(1)

   104

   105

    def RefreshView(self):

   106

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

   107

        self.RefreshVariablesGrid(entries)

   108

   109

    def RefreshVariablesGrid(self, entries):

   110

        root = self.VariablesGrid.GetRootItem()

   111

        if not root.IsOk():

   112

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

   113

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

   114

        self.VariablesGrid.Expand(root)

   115

   116

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

   117

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

   118

   119

        no_more_items = not item.IsOk()

   120

        for entry in entries:

   121

            idx += 1

   122

            if no_more_items:

   123

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

   124

            for col, colname in enumerate(colnames):

   125

                if col == 0:

   126

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

   127

                else:

   128

                    value = entry.get(colname, "")

   129

                    if colname == "Access":

   130

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

   131

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

   132

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

   133

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

   134

            else:

   135

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

   136

            self.VariablesGrid.SetItemPyData(item, entry)

   137

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

   138

            if not no_more_items:

   139

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

   140

                no_more_items = not item.IsOk()

   141

   142

        if not no_more_items:

   143

            to_delete = []

   144

            while item.IsOk():

   145

                to_delete.append(item)

   146

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

   147

            for item in to_delete:

   148

                self.VariablesGrid.Delete(item)

   149

   150

        return idx

   151

   152

    def OnVariablesFilterChanged(self, event):

   153

        filter = self.VariablesFilter.GetSelection()

   154

        if filter != -1:

   155

            self.CurrentFilter = self.Filters[filter]

   156

            self.RefreshView()

   157

        else:

   158

            try:

   159

                value = self.VariablesFilter.GetValue()

   160

                if value == "":

   161

                    self.CurrentFilter = self.Filters[0]

   162

                    self.VariablesFilter.SetSelection(0)

   163

                else:

   164

                    result = ETHERCAT_INDEX_MODEL.match(value)

   165

                    if result is not None:

   166

                        value = result.group(1)

   167

                    index = int(value, 16)

   168

                    self.CurrentFilter = (index, index)

   169

                    self.VariablesFilter.SetValue(VARIABLE_INDEX_FILTER_FORMAT % index)

   170

                self.RefreshView()

   171

            except:

   172

                if self.CurrentFilter in self.Filters:

   173

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

   174

                else:

   175

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

   176

        self.VariablesFilterFirstCharacter = True

   177

        event.Skip()

   178

   179

    def OnVariablesFilterKeyDown(self, event):

   180

        if self.VariablesFilterFirstCharacter:

   181

            keycode = event.GetKeyCode()

   182

            if keycode not in [wx.WXK_RETURN, 

   183

                               wx.WXK_NUMPAD_ENTER]:

   184

                self.VariablesFilterFirstCharacter = False

   185

                if keycode not in NAVIGATION_KEYS:

   186

                    self.VariablesFilter.SetValue("")

   187

            if keycode not in [wx.WXK_DELETE, 

   188

                               wx.WXK_NUMPAD_DELETE, 

   189

                               wx.WXK_BACK]:

   190

                event.Skip()

   191

        else:

   192

            event.Skip()

   193

   194

    def OnVariablesGridLeftClick(self, event):

   195

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

   196

        if item.IsOk():

   197

            entry = self.VariablesGrid.GetItemPyData(item)

   198

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

   199

            data_size = self.Controler.GetSizeOfType(data_type)

   200

   201

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

   202

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

   203

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

   204

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

   205

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

   206

                location = self.Controler.GetCurrentLocation()

   207

                if self.PositionColumn:

   208

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

   209

                    location += (slave_pos,)

   210

                    node_name = self.Controler.GetSlaveName(slave_pos)

   211

                else:

   212

                    node_name = self.Controler.CTNName()

   213

   214

                if pdo_mapping != "":

   215

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

   216

                    if pdo_mapping == "T":

   217

                        dir = "%I"

   218

                    else:

   219

                        dir = "%Q"

   220

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

   221

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

   222

   223

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

   224

                    dragSource = wx.DropSource(self.VariablesGrid)

   225

                    dragSource.SetData(data)

   226

                    dragSource.DoDragDrop()

   227

                    return

   228

   229

                elif self.PositionColumn:

   230

                    location = self.Controler.GetCurrentLocation() +\

   231

                               (slave_pos, entry_index, entry_subindex)

   232

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

   233

                    dragSource = wx.DropSource(self.VariablesGrid)

   234

                    dragSource.SetData(data)

   235

                    dragSource.DoDragDrop()

   236

                    return

   237

   238

        event.Skip()

   239

   240

class NodeEditor(ConfTreeNodeEditor):

   241

   242

    CONFNODEEDITOR_TABS = [

   243

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

   244

   245

    def _create_EthercatNodeEditor(self, prnt):

   246

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

   247

   248

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

   249

        main_sizer.AddGrowableCol(0)

   250

        main_sizer.AddGrowableRow(1)

   251

   252

        variables_label = wx.StaticText(self.EthercatNodeEditor,

   253

              label=_('Variable entries:'))

   254

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

   255

   256

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

   257

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

   258

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

   259

   260

        self.EthercatNodeEditor.SetSizer(main_sizer)

   261

   262

        return self.EthercatNodeEditor

   263

   264

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

   265

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

   266

   267

    def GetBufferState(self):

   268

        return False, False

   269

   270

    def RefreshView(self):

   271

        ConfTreeNodeEditor.RefreshView(self)

   272

   273

        self.NodeVariables.RefreshView()

   274

   275

CIA402NodeEditor = NodeEditor

   276

   277

def GetProcessVariablesTableColnames():

   278

    _ = lambda x : x

   279

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

   280

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

   281

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

   282

            _("Description")]

   283

   284

class ProcessVariablesTable(CustomTable):

   285

   286

    def GetValue(self, row, col):

   287

        if row < self.GetNumberRows():

   288

            if col == 0:

   289

                return row + 1

   290

            colname = self.GetColLabelValue(col, False)

   291

            if colname.startswith("Read from"):

   292

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

   293

                if value == "":

   294

                    return value

   295

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

   296

            elif colname.startswith("Write to"):

   297

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

   298

                if value == "":

   299

                    return value

   300

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

   301

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

   302

   303

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

   304

        if col < len(self.colnames):

   305

            colname = self.GetColLabelValue(col, False)

   306

            if colname.startswith("Read from"):

   307

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

   308

            elif colname.startswith("Write to"):

   309

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

   310

            else:

   311

                self.data[row][colname] = value

   312

   313

    def _updateColAttrs(self, grid):

   314

        """

   315

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

   316

        appropriate renderer given the column name.

   317

   318

        Otherwise default to the default renderer.

   319

        """

   320

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

   321

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

   322

                editor = None

   323

                renderer = None

   324

                colname = self.GetColLabelValue(col, False)

   325

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

   326

                    editor = wx.grid.GridCellTextEditor()

   327

                    renderer = wx.grid.GridCellStringRenderer()

   328

                    grid.SetReadOnly(row, col, False)

   329

                else:

   330

                    grid.SetReadOnly(row, col, True)

   331

   332

                grid.SetCellEditor(row, col, editor)

   333

                grid.SetCellRenderer(row, col, renderer)

   334

   335

            self.ResizeRow(grid, row)

   336

   337

class ProcessVariableDropTarget(wx.TextDropTarget):

   338

   339

    def __init__(self, parent):

   340

        wx.TextDropTarget.__init__(self)

   341

        self.ParentWindow = parent

   342

   343

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

   344

        self.ParentWindow.Select()

   345

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

   346

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

   347

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

   348

        message = None

   349

        try:

   350

            values = eval(data)

   351

        except:

   352

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

   353

            values = None

   354

        if not isinstance(values, TupleType):

   355

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

   356

            values = None

   357

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

   358

            location = None

   359

            if values[1] == "location":

   360

                result = LOCATION_MODEL.match(values[0])

   361

                if result is not None:

   362

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

   363

                master_location = self.ParentWindow.GetMasterLocation()

   364

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

   365

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

   366

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

   367

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

   368

                    if col == 2:

   369

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

   370

                    else:

   371

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

   372

                    if other_values != "":

   373

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

   374

                    else:

   375

                        other_type = None

   376

                    if other_type is None or var_type == other_type:

   377

                        if col == 2:

   378

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

   379

                        else:

   380

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

   381

                        self.ParentWindow.SaveProcessVariables()

   382

                        self.ParentWindow.RefreshProcessVariables()

   383

                    else:

   384

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

   385

                else:

   386

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

   387

   388

        if message is not None:

   389

            wx.CallAfter(self.ShowMessage, message)

   390

   391

    def ShowMessage(self, message):

   392

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

   393

        message.ShowModal()

   394

        message.Destroy()

   395

   396

def GetStartupCommandsTableColnames():

   397

    _ = lambda x : x

   398

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

   399

   400

class StartupCommandDropTarget(wx.TextDropTarget):

   401

   402

    def __init__(self, parent):

   403

        wx.TextDropTarget.__init__(self)

   404

        self.ParentWindow = parent

   405

   406

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

   407

        self.ParentWindow.Select()

   408

        message = None

   409

        try:

   410

            values = eval(data)

   411

        except:

   412

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

   413

            values = None

   414

        if not isinstance(values, TupleType):

   415

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

   416

            values = None

   417

        if values is not None:

   418

            location = None

   419

            if values[1] == "location":

   420

                result = LOCATION_MODEL.match(values[0])

   421

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

   422

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

   423

                    access = values[5]

   424

            elif values[1] == "variable":

   425

                location = values[0]

   426

                access = values[2]

   427

            if location is not None:

   428

                master_location = self.ParentWindow.GetMasterLocation()

   429

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

   430

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

   431

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

   432

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

   433

                    else:

   434

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

   435

                else:

   436

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

   437

   438

        if message is not None:

   439

            wx.CallAfter(self.ShowMessage, message)

   440

   441

    def ShowMessage(self, message):

   442

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

   443

        message.ShowModal()

   444

        message.Destroy()

   445

   446

class StartupCommandsTable(CustomTable):

   447

   448

    """

   449

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

   450

    """

   451

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

   452

        # The base class must be initialized *first*

   453

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

   454

        self.old_value = None

   455

   456

    def GetValue(self, row, col):

   457

        if row < self.GetNumberRows():

   458

            colname = self.GetColLabelValue(col, False)

   459

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

   460

            if colname == "Index":

   461

                return "#x%0.4X" % value

   462

            elif colname == "Subindex":

   463

                return "#x%0.2X" % value

   464

            return value

   465

   466

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

   467

        if col < len(self.colnames):

   468

            colname = self.GetColLabelValue(col, False)

   469

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

   470

                if colname == "Index":

   471

                    result = ETHERCAT_INDEX_MODEL.match(value)

   472

                else:

   473

                    result = ETHERCAT_SUBINDEX_MODEL.match(value)

   474

                if result is None:

   475

                    return

   476

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

   477

            elif colname == "Value":

   478

                value = int(value)

   479

            elif colname == "Position":

   480

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

   481

                value = int(value)

   482

            self.data[row][colname] = value

   483

   484

    def GetOldValue(self):

   485

        return self.old_value

   486

   487

    def _updateColAttrs(self, grid):

   488

        """

   489

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

   490

        appropriate renderer given the column name.

   491