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

# -----------------------------------------------------------------------

    17

from EtherCATManagementEditor import EtherCATManagementTreebook, MasterStatePanelClass

    18

# -----------------------------------------------------------------------

    19

    20

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

    21

    22

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

    23

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

    24

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

    25

    else:

    26

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

    27

    28

def GetVariablesTableColnames(position=False):

    29

    _ = lambda x : x

    30

    colname = ["#"]

    31

    if position:

    32

        colname.append(_("Position"))

    33

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

    34

    35

ACCESS_TYPES = {

    36

    'ro': 'R',

    37

    'wo': 'W',

    38

    'rw': 'R/W'}

    39

    40

def GetAccessValue(access, pdo_mapping):

    41

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

    42

    if pdo_mapping != "":

    43

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

    44

    return value

    45

    46

VARIABLES_FILTERS = [

    47

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

    48

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

    49

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

    50

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

    51

    52

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

    53

    54

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

    55

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

    56

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

    57

    58

class NodeVariablesSizer(wx.FlexGridSizer):

    59

    60

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

    61

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

    62

        self.AddGrowableCol(0)

    63

        self.AddGrowableRow(1)

    64

    65

        self.Controler = controler

    66

        self.PositionColumn = position_column

    67

    68

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

    69

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

    70

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

    71

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

    72

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

    73

    74

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

    75

                style=wx.TR_DEFAULT_STYLE |

    76

                      wx.TR_ROW_LINES |

    77

                      wx.TR_COLUMN_LINES |

    78

                      wx.TR_HIDE_ROOT |

    79

                      wx.TR_FULL_ROW_HIGHLIGHT)

    80

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

    81

            self.OnVariablesGridLeftClick)

    82

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

    83

    84

        self.Filters = []

    85

        for desc, value in VARIABLES_FILTERS:

    86

            self.VariablesFilter.Append(desc)

    87

            self.Filters.append(value)

    88

    89

        self.VariablesFilter.SetSelection(0)

    90

        self.CurrentFilter = self.Filters[0]

    91

        self.VariablesFilterFirstCharacter = True

    92

    93

        if position_column:

    94

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

    95

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

    96

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

    97

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

    98

                                                   wx.ALIGN_LEFT]):

    99

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

   100

            self.VariablesGrid.SetMainColumn(2)

   101

        else:

   102

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

   103

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

   104

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

   105

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

   106

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

   107

            self.VariablesGrid.SetMainColumn(1)

   108

   109

    def RefreshView(self):

   110

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

   111

        self.RefreshVariablesGrid(entries)

   112

   113

    def RefreshVariablesGrid(self, entries):

   114

        root = self.VariablesGrid.GetRootItem()

   115

        if not root.IsOk():

   116

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

   117

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

   118

        self.VariablesGrid.Expand(root)

   119

   120

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

   121

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

   122

   123

        no_more_items = not item.IsOk()

   124

        for entry in entries:

   125

            idx += 1

   126

            if no_more_items:

   127

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

   128

            for col, colname in enumerate(colnames):

   129

                if col == 0:

   130

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

   131

                else:

   132

                    value = entry.get(colname, "")

   133

                    if colname == "Access":

   134

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

   135

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

   136

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

   137

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

   138

            else:

   139

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

   140

            self.VariablesGrid.SetItemPyData(item, entry)

   141

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

   142

            if not no_more_items:

   143

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

   144

                no_more_items = not item.IsOk()

   145

   146

        if not no_more_items:

   147

            to_delete = []

   148

            while item.IsOk():

   149

                to_delete.append(item)

   150

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

   151

            for item in to_delete:

   152

                self.VariablesGrid.Delete(item)

   153

   154

        return idx

   155

   156

    def OnVariablesFilterChanged(self, event):

   157

        filter = self.VariablesFilter.GetSelection()

   158

        if filter != -1:

   159

            self.CurrentFilter = self.Filters[filter]

   160

            self.RefreshView()

   161

        else:

   162

            try:

   163

                value = self.VariablesFilter.GetValue()

   164

                if value == "":

   165

                    self.CurrentFilter = self.Filters[0]

   166

                    self.VariablesFilter.SetSelection(0)

   167

                else:

   168

                    result = ETHERCAT_INDEX_MODEL.match(value)

   169

                    if result is not None:

   170

                        value = result.group(1)

   171

                    index = int(value, 16)

   172

                    self.CurrentFilter = (index, index)

   173

                    self.VariablesFilter.SetValue(VARIABLE_INDEX_FILTER_FORMAT % index)

   174

                self.RefreshView()

   175

            except:

   176

                if self.CurrentFilter in self.Filters:

   177

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

   178

                else:

   179

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

   180

        self.VariablesFilterFirstCharacter = True

   181

        event.Skip()

   182

   183

    def OnVariablesFilterKeyDown(self, event):

   184

        if self.VariablesFilterFirstCharacter:

   185

            keycode = event.GetKeyCode()

   186

            if keycode not in [wx.WXK_RETURN, 

   187

                               wx.WXK_NUMPAD_ENTER]:

   188

                self.VariablesFilterFirstCharacter = False

   189

                if keycode not in NAVIGATION_KEYS:

   190

                    self.VariablesFilter.SetValue("")

   191

            if keycode not in [wx.WXK_DELETE, 

   192

                               wx.WXK_NUMPAD_DELETE, 

   193

                               wx.WXK_BACK]:

   194

                event.Skip()

   195

        else:

   196

            event.Skip()

   197

   198

    def OnVariablesGridLeftClick(self, event):

   199

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

   200

        if item.IsOk():

   201

            entry = self.VariablesGrid.GetItemPyData(item)

   202

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

   203

            data_size = self.Controler.GetSizeOfType(data_type)

   204

   205

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

   206

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

   207

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

   208

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

   209

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

   210

                location = self.Controler.GetCurrentLocation()

   211

                if self.PositionColumn:

   212

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

   213

                    location += (slave_pos,)

   214

                    node_name = self.Controler.GetSlaveName(slave_pos)

   215

                else:

   216

                    node_name = self.Controler.CTNName()

   217

   218

                if pdo_mapping != "":

   219

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

   220

                    if pdo_mapping == "T":

   221

                        dir = "%I"

   222

                    else:

   223

                        dir = "%Q"

   224

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

   225

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

   226

   227

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

   228

                    dragSource = wx.DropSource(self.VariablesGrid)

   229

                    dragSource.SetData(data)

   230

                    dragSource.DoDragDrop()

   231

                    return

   232

   233

                elif self.PositionColumn:

   234

                    location = self.Controler.GetCurrentLocation() +\

   235

                               (slave_pos, entry_index, entry_subindex)

   236

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

   237

                    dragSource = wx.DropSource(self.VariablesGrid)

   238

                    dragSource.SetData(data)

   239

                    dragSource.DoDragDrop()

   240

                    return

   241

   242

        event.Skip()

   243

   244

class NodeEditor(ConfTreeNodeEditor):

   245

   246

    CONFNODEEDITOR_TABS = [

   247

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

   248

        # Add Notebook Tab for EtherCAT Management Treebook

   249

        (_("EtherCAT Management"), "_create_EtherCATManagementEditor")

   250

        ]

   251

   252

    def _create_EthercatNodeEditor(self, prnt):

   253

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

   254

   255

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

   256

        main_sizer.AddGrowableCol(0)

   257

        main_sizer.AddGrowableRow(1)

   258

   259

        variables_label = wx.StaticText(self.EthercatNodeEditor,

   260

              label=_('Variable entries:'))

   261

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

   262

   263

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

   264

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

   265

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

   266

   267

        self.EthercatNodeEditor.SetSizer(main_sizer)

   268

   269

        return self.EthercatNodeEditor

   270

   271

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

   272

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

   273

   274

        # add Contoler for use EthercatSlave.py Method

   275

        self.Controler = controler

   276

   277

    def GetBufferState(self):

   278

        return False, False

   279

   280

    def RefreshView(self):

   281

        ConfTreeNodeEditor.RefreshView(self)

   282

   283

        self.NodeVariables.RefreshView()

   284

   285

    # -------------------For EtherCAT Management ----------------------------------------------    

   286

    def _create_EtherCATManagementEditor(self, prnt):

   287

        self.EtherCATManagementEditor = wx.ScrolledWindow(prnt,

   288

            style=wx.TAB_TRAVERSAL|wx.HSCROLL|wx.VSCROLL)

   289

        self.EtherCATManagementEditor.Bind(wx.EVT_SIZE, self.OnResize)

   290

   291

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

   292

        self.EtherCATManagermentEditor_Main_Sizer.AddGrowableCol(0)

   293

        self.EtherCATManagermentEditor_Main_Sizer.AddGrowableRow(0)

   294

   295

        self.EtherCATManagementTreebook = EtherCATManagementTreebook(self.EtherCATManagementEditor, self.Controler, self)

   296

   297

        self.EtherCATManagermentEditor_Main_Sizer.AddSizer(self.EtherCATManagementTreebook, border=10, flag=wx.GROW)

   298

   299

        self.EtherCATManagementEditor.SetSizer(self.EtherCATManagermentEditor_Main_Sizer)

   300

        return self.EtherCATManagementEditor

   301

   302

    def OnResize(self, event):

   303

        self.EtherCATManagementEditor.GetBestSize()

   304

        xstart, ystart = self.EtherCATManagementEditor.GetViewStart()

   305

        window_size = self.EtherCATManagementEditor.GetClientSize()

   306

        maxx, maxy = self.EtherCATManagementEditor.GetMinSize()

   307

        posx = max(0, min(xstart, (maxx - window_size[0]) / SCROLLBAR_UNIT))

   308

        posy = max(0, min(ystart, (maxy - window_size[1]) / SCROLLBAR_UNIT))

   309

        self.EtherCATManagementEditor.Scroll(posx, posy)

   310

        self.EtherCATManagementEditor.SetScrollbars(SCROLLBAR_UNIT, SCROLLBAR_UNIT, 

   311

                maxx / SCROLLBAR_UNIT, maxy / SCROLLBAR_UNIT, posx, posy)

   312

        event.Skip()

   313

    # -------------------------------------------------------------------------------------------------------

   314

   315

CIA402NodeEditor = NodeEditor

   316

   317

   318

def GetProcessVariablesTableColnames():

   319

    _ = lambda x : x

   320

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

   321

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

   322

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

   323

            _("Description")]

   324

   325

class ProcessVariablesTable(CustomTable):

   326

   327

    def GetValue(self, row, col):

   328

        if row < self.GetNumberRows():

   329

            if col == 0:

   330

                return row + 1

   331

            colname = self.GetColLabelValue(col, False)

   332

            if colname.startswith("Read from"):

   333

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

   334

                if value == "":

   335

                    return value

   336

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

   337

            elif colname.startswith("Write to"):

   338

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

   339

                if value == "":

   340

                    return value

   341

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

   342

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

   343

   344

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

   345

        if col < len(self.colnames):

   346

            colname = self.GetColLabelValue(col, False)

   347

            if colname.startswith("Read from"):

   348

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

   349

            elif colname.startswith("Write to"):

   350

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

   351

            else:

   352

                self.data[row][colname] = value

   353

   354

    def _updateColAttrs(self, grid):

   355

        """

   356

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

   357

        appropriate renderer given the column name.

   358

   359

        Otherwise default to the default renderer.

   360

        """

   361

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

   362

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

   363

                editor = None

   364

                renderer = None

   365

                colname = self.GetColLabelValue(col, False)

   366

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

   367

                    editor = wx.grid.GridCellTextEditor()

   368

                    renderer = wx.grid.GridCellStringRenderer()

   369

                    grid.SetReadOnly(row, col, False)

   370

                else:

   371

                    grid.SetReadOnly(row, col, True)

   372

   373

                grid.SetCellEditor(row, col, editor)

   374

                grid.SetCellRenderer(row, col, renderer)

   375

   376

            self.ResizeRow(grid, row)

   377

   378

class ProcessVariableDropTarget(wx.TextDropTarget):

   379

   380

    def __init__(self, parent):

   381

        wx.TextDropTarget.__init__(self)

   382

        self.ParentWindow = parent

   383

   384

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

   385

        self.ParentWindow.Select()

   386

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

   387

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

   388

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

   389

        message = None

   390

        try:

   391

            values = eval(data)

   392

        except:

   393

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

   394

            values = None

   395

        if not isinstance(values, TupleType):

   396

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

   397

            values = None

   398

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

   399

            location = None

   400

            if values[1] == "location":

   401

                result = LOCATION_MODEL.match(values[0])

   402

                if result is not None:

   403

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

   404

                master_location = self.ParentWindow.GetMasterLocation()

   405

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

   406

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

   407

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

   408

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

   409

                    if col == 2:

   410

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

   411

                    else:

   412

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

   413

                    if other_values != "":

   414

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

   415

                    else:

   416

                        other_type = None

   417

                    if other_type is None or var_type == other_type:

   418

                        if col == 2:

   419

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

   420

                        else:

   421

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

   422

                        self.ParentWindow.SaveProcessVariables()

   423

                        self.ParentWindow.RefreshProcessVariables()

   424

                    else:

   425

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

   426

                else:

   427

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

   428

   429

        if message is not None:

   430

            wx.CallAfter(self.ShowMessage, message)

   431

   432

    def ShowMessage(self, message):

   433

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

   434

        message.ShowModal()

   435

        message.Destroy()

   436

   437

def GetStartupCommandsTableColnames():

   438

    _ = lambda x : x

   439

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

   440

   441

class StartupCommandDropTarget(wx.TextDropTarget):

   442

   443

    def __init__(self, parent):

   444

        wx.TextDropTarget.__init__(self)

   445

        self.ParentWindow = parent

   446

   447

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

   448

        self.ParentWindow.Select()

   449

        message = None

   450

        try:

   451

            values = eval(data)

   452

        except:

   453

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

   454

            values = None

   455

        if not isinstance(values, TupleType):

   456

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

   457

            values = None

   458

        if values is not None:

   459

            location = None

   460

            if values[1] == "location":

   461

                result = LOCATION_MODEL.match(values[0])

   462

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

   463

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

   464

                    access = values[5]

   465

            elif values[1] == "variable":

   466

                location = values[0]

   467

                access = values[2]

   468

            if location is not None:

   469

                master_location = self.ParentWindow.GetMasterLocation()

   470

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

   471

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

   472

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

   473

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

   474

                    else:

   475

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

   476

                else:

   477

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

   478

   479

        if message is not None:

   480

            wx.CallAfter(self.ShowMessage, message)

   481

   482

    def ShowMessage(self, message):

   483

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

   484

        message.ShowModal()

   485

        message.Destroy()

   486

   487

class StartupCommandsTable(CustomTable):

   488

   489

    """

   490

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