2

import re

     3

from types import TupleType

    10

from plcopen.structures import IEC_KEYWORDS, TestIdentifier

    23

def GetVariablesTableColnames(position=False):

    25

    colname = ["#"]

    26

    if position:

    27

        colname.append(_("Position"))

    28

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

    36

    value = ACCESS_TYPES.get(access, "")

    41

VARIABLES_FILTERS = [

    42

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

    43

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

    44

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

    45

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

    46

    47

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

    48

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

    49

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

    50

    51

class NodeVariablesSizer(wx.FlexGridSizer):

    52

    53

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

    54

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

    55

        self.AddGrowableCol(0)

    56

        self.AddGrowableRow(1)

    57

    58

        self.Controler = controler

    59

        self.PositionColumn = position_column

    60

    61

        self.VariablesFilter = wx.ComboBox(parent)

    62

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

    63

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

    64

    65

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

    66

                style=wx.TR_DEFAULT_STYLE |

    67

                      wx.TR_ROW_LINES |

    68

                      wx.TR_COLUMN_LINES |

    69

                      wx.TR_HIDE_ROOT |

    70

                      wx.TR_FULL_ROW_HIGHLIGHT)

    71

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

    73

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

    74

    75

        self.Filters = []

    76

        for desc, value in VARIABLES_FILTERS:

    77

            self.VariablesFilter.Append(desc)

    78

            self.Filters.append(value)

    79

    80

        self.VariablesFilter.SetSelection(0)

    81

        self.CurrentFilter = self.Filters[0]

    82

    83

        if position_column:

    84

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

    85

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

    86

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

    87

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

    88

                                                   wx.ALIGN_LEFT]):

    89

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

    90

            self.VariablesGrid.SetMainColumn(2)

    91

        else:

    92

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

    93

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

    94

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

    95

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

    96

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

    97

            self.VariablesGrid.SetMainColumn(1)

    98

   100

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

   101

        self.RefreshVariablesGrid(entries)

   106

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

   107

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

   128

            else:

   129

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

   145

   146

    def OnVariablesFilterChanged(self, event):

   147

        filter = self.VariablesFilter.GetSelection()

   148

        if filter != -1:

   149

            self.CurrentFilter = self.Filters[filter]

   150

            self.RefreshView()

   151

        else:

   152

            try:

   153

                value = self.VariablesFilter.GetValue()

   154

                result = ETHERCAT_INDEX_MODEL.match(value)

   155

                if result is not None:

   156

                    value = result.group(1)

   157

                index = int(value)

   158

                self.CurrentFilter = (index, index)

   159

                self.RefreshView()

   160

            except:

   161

                pass

   162

        event.Skip()

   163

   169

            data_size = self.Controler.GetSizeOfType(data_type)

   171

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

   172

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

   173

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

   176

                if self.PositionColumn:

   177

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

   179

                    slave_pos = self.Controler.GetSlavePos()

   181

                if pdo_mapping != "":

   182

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

   183

                    if pdo_mapping == "R":

   184

                        dir = "%I"

   185

                    else:

   186

                        dir = "%Q"

   187

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

   188

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

   189

                                                             (slave_pos, entry_index, entry_subindex)))

   190

   191

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

   192

                    dragSource = wx.DropSource(self.VariablesGrid)

   193

                    dragSource.SetData(data)

   194

                    dragSource.DoDragDrop()

   195

                    return

   196

   197

                elif self.ColumnPosition:

   198

                    location = self.Controler.GetCurrentLocation() +\

   199

                               (slave_pos, entry_index, entry_subindex)

   200

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

   201

                    dragSource = wx.DropSource(self.VariablesGrid)

   202

                    dragSource.SetData(data)

   203

                    dragSource.DoDragDrop()

   204

                    return

   205

   206

        event.Skip()

   207

   208

class NodeEditor(ConfTreeNodeEditor):

   209

   210

    CONFNODEEDITOR_TABS = [

   211

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

   212

   213

    def _create_EthercatNodeEditor(self, prnt):

   214

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

   215

   216

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

   217

        main_sizer.AddGrowableCol(0)

   218

        main_sizer.AddGrowableRow(1)

   219

   220

        variables_label = wx.StaticText(self.EthercatNodeEditor,

   221

              label=_('Variable entries:'))

   222

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

   223

   224

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

   225

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

   226

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

   227

   228

        self.EthercatNodeEditor.SetSizer(main_sizer)

   229

   230

        return self.EthercatNodeEditor

   231

   232

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

   233

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

   234

   235

    def GetBufferState(self):

   236

        return False, False

   237

   238

    def RefreshView(self):

   239

        ConfTreeNodeEditor.RefreshView(self)

   240

   241

        self.NodeVariables.RefreshView()

   242

   243

CIA402NodeEditor = NodeEditor

   244

   245

def GetProcessVariablesTableColnames():

   246

    _ = lambda x : x

   247

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

   248

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

   249

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

   250

            _("Description")]

   251

   252

class ProcessVariablesTable(CustomTable):

   253

   254

    def GetValue(self, row, col):

   255

        if row < self.GetNumberRows():

   256

            if col == 0:

   257

                return row + 1

   258

            colname = self.GetColLabelValue(col, False)

   259

            if colname.startswith("Read from"):

   260

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

   261

                if value == "":

   262

                    return value

   263

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

   264

            elif colname.startswith("Write to"):

   265

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

   266

                if value == "":

   267

                    return value

   268

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

   269

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

   270

   271

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

   272

        if col < len(self.colnames):

   273

            colname = self.GetColLabelValue(col, False)

   274

            if colname.startswith("Read from"):

   275

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

   276

            elif colname.startswith("Write to"):

   277

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

   278

            else:

   279

                self.data[row][colname] = value

   280

   281

    def _updateColAttrs(self, grid):

   282

        """

   283

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

   284

        appropriate renderer given the column name.

   285

   286

        Otherwise default to the default renderer.

   287

        """

   288

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

   289

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

   290

                editor = None

   291

                renderer = None

   292

                colname = self.GetColLabelValue(col, False)

   293

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

   294

                    editor = wx.grid.GridCellTextEditor()

   295

                    renderer = wx.grid.GridCellStringRenderer()

   296

                    grid.SetReadOnly(row, col, False)

   297

                else:

   298

                    grid.SetReadOnly(row, col, True)

   299

   300

                grid.SetCellEditor(row, col, editor)

   301

                grid.SetCellRenderer(row, col, renderer)

   302

   303

            self.ResizeRow(grid, row)

   304

   305

class ProcessVariableDropTarget(wx.TextDropTarget):

   306

   307

    def __init__(self, parent):

   308

        wx.TextDropTarget.__init__(self)

   309

        self.ParentWindow = parent

   310

   311

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

   312

        self.ParentWindow.Select()

   313

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

   314

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

   315

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

   316

        message = None

   317

        try:

   318

            values = eval(data)

   319

        except:

   320

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

   321

            values = None

   322

        if not isinstance(values, TupleType):

   323

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

   324

            values = None

   325

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

   326

            location = None

   327

            if values[1] == "location":

   328

                result = LOCATION_MODEL.match(values[0])

   329

                if result is not None:

   330

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

   331

                master_location = self.ParentWindow.GetMasterLocation()

   332

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

   333

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

   334

                    if col == 2:

   335

                        self.ParentWindow.ProcessVariablesTable.SetValueByName(

   336

                            row, "ReadFrom", tuple(location[len(master_location):]))

   337

                    else:

   338

                        self.ParentWindow.ProcessVariablesTable.SetValueByName(

   339

                            row, "WriteTo", tuple(location[len(master_location):]))

   340

                    self.ParentWindow.SaveProcessVariables()

   341

                    self.ParentWindow.RefreshProcessVariables()

   342

                else:

   343

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

   344

   345

        if message is not None:

   346

            wx.CallAfter(self.ShowMessage, message)

   347

   348

    def ShowMessage(self, message):

   349

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

   350

        message.ShowModal()

   351

        message.Destroy()

   352

   353

def GetStartupCommandsTableColnames():

   354

    _ = lambda x : x

   355

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

   356

   357

class StartupCommandDropTarget(wx.TextDropTarget):

   358

   359

    def __init__(self, parent):

   360

        wx.TextDropTarget.__init__(self)

   361

        self.ParentWindow = parent

   362

   363

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

   364

        self.ParentWindow.Select()

   365

        message = None

   366

        try:

   367

            values = eval(data)

   368

        except:

   369

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

   370

            values = None

   371

        if not isinstance(values, TupleType):

   372

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

   373

            values = None

   374

        if values is not None:

   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

                    access = values[5]

   381

            elif values[1] == "variable":

   382

                location = values[0]

   383

                access = values[2]

   384

            if location is not None:

   385

                master_location = self.ParentWindow.GetMasterLocation()

   386

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

   387

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

   388

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

   389

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

   390

                    else:

   391

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

   392

                else:

   393

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

   394

   395

        if message is not None:

   396

            wx.CallAfter(self.ShowMessage, message)

   397

   398

    def ShowMessage(self, message):

   399

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

   400

        message.ShowModal()

   401

        message.Destroy()

   402

   403

class StartupCommandsTable(CustomTable):

   404

   405

    """

   406

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

   407

    """

   408

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

   409

        # The base class must be initialized *first*

   410

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

   411

        self.old_value = None

   412

   413

    def GetValue(self, row, col):

   414

        if row < self.GetNumberRows():

   415

            colname = self.GetColLabelValue(col, False)

   416

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

   417

            if colname == "Index":

   418

                return "#x%0.4x" % value

   419

            elif colname == "Subindex":

   420

                return "#x%0.2x" % value

   421

            return value

   422

   423

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

   424

        if col < len(self.colnames):

   425

            colname = self.GetColLabelValue(col, False)

   426

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

   427

                if colname == "Index":

   428

                    result = ETHERCAT_INDEX_MODEL.match(value)

   429

                else:

   430

                    result = ETHERCAT_SUBINDEX_MODEL.match(value)

   431

                if result is None:

   432

                    return

   433

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

   434

            elif colname == "Value":

   435

                value = int(value)

   436

            elif colname == "Position":

   437

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

   438

                value = int(value)

   439

            self.data[row][colname] = value

   440

   441

    def GetOldValue(self):

   442

        return self.old_value

   443

   444

    def _updateColAttrs(self, grid):

   445

        """

   446

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

   447

        appropriate renderer given the column name.

   448

   449

        Otherwise default to the default renderer.

   450

        """

   451

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

   452

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

   453

                editor = None

   454

                renderer = None

   455

                colname = self.GetColLabelValue(col, False)

   456

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

   457

                    editor = wx.grid.GridCellNumberEditor()

   458

                    renderer = wx.grid.GridCellNumberRenderer()

   459

                else:

   460

                    editor = wx.grid.GridCellTextEditor()

   461

                    renderer = wx.grid.GridCellStringRenderer()

   462

   463

                grid.SetCellEditor(row, col, editor)

   464

                grid.SetCellRenderer(row, col, renderer)

   465

                grid.SetReadOnly(row, col, False)

   466

   467

            self.ResizeRow(grid, row)

   468

   469

    def GetCommandIndex(self, position, command_idx):

   470

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

   471

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

   472

                return row

   473

        return None

   474

   475

class MasterNodesVariablesSizer(NodeVariablesSizer):

   476

   477

    def __init__(self, parent, controler):

   478

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

   479

   480

        self.CurrentNodesFilter = {}

   481

   482

    def SetCurrentNodesFilter(self, nodes_filter):

   483

        self.CurrentNodesFilter = nodes_filter

   484

   485

    def RefreshView(self):

   486

        if self.CurrentNodesFilter is not None:

   487

            args = self.CurrentNodesFilter.copy()

   488

            args["limits"] = self.CurrentFilter

   489

            entries = self.Controler.GetNodesVariables(**args)

   490

            self.RefreshVariablesGrid(entries)

   491

   492

class MasterEditor(ConfTreeNodeEditor):

   493

   494

    CONFNODEEDITOR_TABS = [