12

import os

    13

import re

    14

from types import TupleType

    15

    16

import wx

    17

import wx.grid

    18

import wx.gizmos

    19

import wx.lib.buttons

    20

    21

from plcopen.structures import IEC_KEYWORDS, TestIdentifier

    22

from controls import CustomGrid, CustomTable, FolderTree

    23

from editors.ConfTreeNodeEditor import ConfTreeNodeEditor, SCROLLBAR_UNIT

    24

from util.BitmapLibrary import GetBitmap

    25

from controls.CustomStyledTextCtrl import NAVIGATION_KEYS

    26

    27

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

    28

from EtherCATManagementEditor import EtherCATManagementTreebook, MasterStatePanelClass

    29

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

    30

    31

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

    32

    33

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

    34

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

    35

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

    36

    else:

    37

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

    38

    39

def GetVariablesTableColnames(position=False):

    40

    _ = lambda x : x

    41

    colname = ["#"]

    42

    if position:

    43

        colname.append(_("Position"))

    44

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

    45

    46

ACCESS_TYPES = {

    47

    'ro': 'R',

    48

    'wo': 'W',

    49

    'rw': 'R/W'}

    50

    51

def GetAccessValue(access, pdo_mapping):

    52

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

    53

    if pdo_mapping != "":

    54

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

    55

    return value

    56

    57

VARIABLES_FILTERS = [

    58

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

    59

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

    60

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

    61

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

    62

    63

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

    64

    65

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

    66

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

    67

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

    68

    69

class NodeVariablesSizer(wx.FlexGridSizer):

    70

    71

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

    72

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

    73

        self.AddGrowableCol(0)

    74

        self.AddGrowableRow(1)

    75

    76

        self.Controler = controler

    77

        self.PositionColumn = position_column

    78

    79

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

    80

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

    81

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

    82

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

    83

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

    84

    85

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

    86

                style=wx.TR_DEFAULT_STYLE |

    87

                      wx.TR_ROW_LINES |

    88

                      wx.TR_COLUMN_LINES |

    89

                      wx.TR_HIDE_ROOT |

    90

                      wx.TR_FULL_ROW_HIGHLIGHT)

    91

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

    92

            self.OnVariablesGridLeftClick)

    93

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

    94

    95

        self.Filters = []

    96

        for desc, value in VARIABLES_FILTERS:

    97

            self.VariablesFilter.Append(desc)

    98

            self.Filters.append(value)

    99

   100

        self.VariablesFilter.SetSelection(0)

   101

        self.CurrentFilter = self.Filters[0]

   102

        self.VariablesFilterFirstCharacter = True

   103

   104

        if position_column:

   105

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

   106

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

   107

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

   108

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

   109

                                                   wx.ALIGN_LEFT]):

   110

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

   111

            self.VariablesGrid.SetMainColumn(2)

   112

        else:

   113

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

   114

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

   115

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

   116

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

   117

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

   118

            self.VariablesGrid.SetMainColumn(1)

   119

   120

    def RefreshView(self):

   121

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

   122

        self.RefreshVariablesGrid(entries)

   123

   124

    def RefreshVariablesGrid(self, entries):

   125

        root = self.VariablesGrid.GetRootItem()

   126

        if not root.IsOk():

   127

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

   128

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

   129

        self.VariablesGrid.Expand(root)

   130

   131

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

   132

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

   133

   134

        no_more_items = not item.IsOk()

   135

        for entry in entries:

   136

            idx += 1

   137

            if no_more_items:

   138

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

   139

            for col, colname in enumerate(colnames):

   140

                if col == 0:

   141

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

   142

                else:

   143

                    value = entry.get(colname, "")

   144

                    if colname == "Access":

   145

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

   146

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

   147

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

   148

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

   149

            else:

   150

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

   151

            self.VariablesGrid.SetItemPyData(item, entry)

   152

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

   153

            if not no_more_items:

   154

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

   155

                no_more_items = not item.IsOk()

   156

   157

        if not no_more_items:

   158

            to_delete = []

   159

            while item.IsOk():

   160

                to_delete.append(item)

   161

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

   162

            for item in to_delete:

   163

                self.VariablesGrid.Delete(item)

   164

   165

        return idx

   166

   167

    def OnVariablesFilterChanged(self, event):

   168

        filter = self.VariablesFilter.GetSelection()

   169

        if filter != -1:

   170

            self.CurrentFilter = self.Filters[filter]

   171

            self.RefreshView()

   172

        else:

   173

            try:

   174

                value = self.VariablesFilter.GetValue()

   175

                if value == "":

   176

                    self.CurrentFilter = self.Filters[0]

   177

                    self.VariablesFilter.SetSelection(0)

   178

                else:

   179

                    result = ETHERCAT_INDEX_MODEL.match(value)

   180

                    if result is not None:

   181

                        value = result.group(1)

   182

                    index = int(value, 16)

   183

                    self.CurrentFilter = (index, index)

   184

                    self.VariablesFilter.SetValue(VARIABLE_INDEX_FILTER_FORMAT % index)

   185

                self.RefreshView()

   186

            except:

   187

                if self.CurrentFilter in self.Filters:

   188

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

   189

                else:

   190

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

   191

        self.VariablesFilterFirstCharacter = True

   192

        event.Skip()

   193

   194

    def OnVariablesFilterKeyDown(self, event):

   195

        if self.VariablesFilterFirstCharacter:

   196

            keycode = event.GetKeyCode()

   197

            if keycode not in [wx.WXK_RETURN, 

   198

                               wx.WXK_NUMPAD_ENTER]:

   199

                self.VariablesFilterFirstCharacter = False

   200

                if keycode not in NAVIGATION_KEYS:

   201

                    self.VariablesFilter.SetValue("")

   202

            if keycode not in [wx.WXK_DELETE, 

   203

                               wx.WXK_NUMPAD_DELETE, 

   204

                               wx.WXK_BACK]:

   205

                event.Skip()

   206

        else:

   207

            event.Skip()

   208

   209

    def OnVariablesGridLeftClick(self, event):

   210

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

   211

        if item.IsOk():

   212

            entry = self.VariablesGrid.GetItemPyData(item)

   213

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

   214

            data_size = self.Controler.GetSizeOfType(data_type)

   215

   216

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

   217

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

   218

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

   219

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

   220

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

   221

                location = self.Controler.GetCurrentLocation()

   222

                if self.PositionColumn:

   223

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

   224

                    location += (slave_pos,)

   225

                    node_name = self.Controler.GetSlaveName(slave_pos)

   226

                else:

   227

                    node_name = self.Controler.CTNName()

   228

   229

                if pdo_mapping != "":

   230

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

   231

                    if pdo_mapping == "T":

   232

                        dir = "%I"

   233

                    else:

   234

                        dir = "%Q"

   235

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

   236

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

   237

   238

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

   239

                    dragSource = wx.DropSource(self.VariablesGrid)

   240

                    dragSource.SetData(data)

   241

                    dragSource.DoDragDrop()

   242

                    return

   243

   244

                elif self.PositionColumn:

   245

                    location = self.Controler.GetCurrentLocation() +\

   246

                               (slave_pos, entry_index, entry_subindex)

   247

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

   248

                    dragSource = wx.DropSource(self.VariablesGrid)

   249

                    dragSource.SetData(data)

   250

                    dragSource.DoDragDrop()

   251

                    return

   252

   253

        event.Skip()

   254

   255

class NodeEditor(ConfTreeNodeEditor):

   256

   257

    CONFNODEEDITOR_TABS = [

   258

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

   259

        # Add Notebook Tab for EtherCAT Management Treebook

   260

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

   261

        ]

   262

   263

    def _create_EthercatNodeEditor(self, prnt):

   264

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

   265

   266

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

   267

        main_sizer.AddGrowableCol(0)

   268

        main_sizer.AddGrowableRow(1)

   269

   270

        variables_label = wx.StaticText(self.EthercatNodeEditor,

   271

              label=_('Variable entries:'))

   272

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

   273

   274

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

   275

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

   276

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

   277

   278

        self.EthercatNodeEditor.SetSizer(main_sizer)

   279

   280

        return self.EthercatNodeEditor

   281

   282

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

   283

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

   284

   285

        # add Contoler for use EthercatSlave.py Method

   286

        self.Controler = controler

   287

   288

    def GetBufferState(self):

   289

        return False, False

   290

   291

    def RefreshView(self):

   292

        ConfTreeNodeEditor.RefreshView(self)

   293

   294

        self.NodeVariables.RefreshView()

   295

   296

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

   297

    def _create_EtherCATManagementEditor(self, prnt):

   298

        self.EtherCATManagementEditor = wx.ScrolledWindow(prnt,

   299

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

   300

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

   301

   302

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

   303

        self.EtherCATManagermentEditor_Main_Sizer.AddGrowableCol(0)

   304

        self.EtherCATManagermentEditor_Main_Sizer.AddGrowableRow(0)

   305

   306

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

   307

   308

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

   309

   310

        self.EtherCATManagementEditor.SetSizer(self.EtherCATManagermentEditor_Main_Sizer)

   311

        return self.EtherCATManagementEditor

   312

   313

    def OnResize(self, event):

   314

        self.EtherCATManagementEditor.GetBestSize()

   315

        xstart, ystart = self.EtherCATManagementEditor.GetViewStart()

   316

        window_size = self.EtherCATManagementEditor.GetClientSize()

   317

        maxx, maxy = self.EtherCATManagementEditor.GetMinSize()

   318

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

   319

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

   320

        self.EtherCATManagementEditor.Scroll(posx, posy)

   321

        self.EtherCATManagementEditor.SetScrollbars(SCROLLBAR_UNIT, SCROLLBAR_UNIT, 

   322

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

   323

        event.Skip()

   324

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

   325

   326

CIA402NodeEditor = NodeEditor

   327

   328

   329

def GetProcessVariablesTableColnames():

   330

    _ = lambda x : x

   331

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

   332

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

   333

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

   334

            _("Description")]

   335

   336

class ProcessVariablesTable(CustomTable):

   337

   338

    def GetValue(self, row, col):

   339

        if row < self.GetNumberRows():

   340

            if col == 0:

   341

                return row + 1

   342

            colname = self.GetColLabelValue(col, False)

   343

            if colname.startswith("Read from"):

   344

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

   345

                if value == "":

   346

                    return value

   347

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

   348

            elif colname.startswith("Write to"):

   349

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

   350

                if value == "":

   351

                    return value

   352

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

   353

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

   354

   355

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

   356

        if col < len(self.colnames):

   357

            colname = self.GetColLabelValue(col, False)

   358

            if colname.startswith("Read from"):

   359

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

   360

            elif colname.startswith("Write to"):

   361

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

   362

            else:

   363

                self.data[row][colname] = value

   364

   365

    def _updateColAttrs(self, grid):

   366

        """

   367

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

   368

        appropriate renderer given the column name.

   369

   370

        Otherwise default to the default renderer.

   371

        """

   372

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

   373

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

   374

                editor = None

   375

                renderer = None

   376

                colname = self.GetColLabelValue(col, False)

   377

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

   378

                    editor = wx.grid.GridCellTextEditor()

   379

                    renderer = wx.grid.GridCellStringRenderer()

   380

                    grid.SetReadOnly(row, col, False)

   381

                else:

   382

                    grid.SetReadOnly(row, col, True)

   383

   384

                grid.SetCellEditor(row, col, editor)

   385

                grid.SetCellRenderer(row, col, renderer)

   386

   387

            self.ResizeRow(grid, row)

   388

   389

class ProcessVariableDropTarget(wx.TextDropTarget):

   390

   391

    def __init__(self, parent):

   392

        wx.TextDropTarget.__init__(self)

   393

        self.ParentWindow = parent

   394

   395

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

   396

        self.ParentWindow.Select()

   397

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

   398

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

   399

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

   400

        message = None

   401

        try:

   402

            values = eval(data)

   403

        except:

   404

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

   405

            values = None

   406

        if not isinstance(values, TupleType):

   407

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

   408

            values = None

   409

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

   410

            location = None

   411

            if values[1] == "location":

   412

                result = LOCATION_MODEL.match(values[0])

   413

                if result is not None:

   414

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

   415

                master_location = self.ParentWindow.GetMasterLocation()

   416

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

   417

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

   418

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

   419

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

   420

                    if col == 2:

   421

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

   422

                    else:

   423

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

   424

                    if other_values != "":

   425

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

   426

                    else:

   427

                        other_type = None

   428

                    if other_type is None or var_type == other_type:

   429

                        if col == 2:

   430

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

   431

                        else:

   432

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

   433

                        self.ParentWindow.SaveProcessVariables()

   434

                        self.ParentWindow.RefreshProcessVariables()

   435

                    else:

   436

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

   437

                else:

   438

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

   439

   440

        if message is not None:

   441

            wx.CallAfter(self.ShowMessage, message)

   442

   443

    def ShowMessage(self, message):

   444

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

   445

        message.ShowModal()

   446

        message.Destroy()

   447

   448

def GetStartupCommandsTableColnames():

   449

    _ = lambda x : x

   450

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

   451

   452

class StartupCommandDropTarget(wx.TextDropTarget):

   453

   454

    def __init__(self, parent):

   455

        wx.TextDropTarget.__init__(self)

   456

        self.ParentWindow = parent

   457

   458

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

   459

        self.ParentWindow.Select()

   460

        message = None

   461

        try:

   462

            values = eval(data)

   463

        except:

   464

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

   465

            values = None

   466

        if not isinstance(values, TupleType):

   467

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

   468

            values = None

   469

        if values is not None:

   470

            location = None

   471

            if values[1] == "location":

   472

                result = LOCATION_MODEL.match(values[0])

   473

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

   474

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

   475

                    access = values[5]

   476

            elif values[1] == "variable":

   477

                location = values[0]

   478

                access = values[2]

   479

            if location is not None:

   480

                master_location = self.ParentWindow.GetMasterLocation()

   481

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

   482

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

   483

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

   484

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

   485

                    else:

   486

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

   487

                else:

   488

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

   489

   490

        if message is not None: