1

#!/usr/bin/env python

     2

# -*- coding: utf-8 -*-

     3

     4

# This file is part of Beremiz

     5

#

     6

# Copyright (C) 2011-2014: Laurent BESSARD, Edouard TISSERANT

     7

#                          RTES Lab : CRKim, JBLee, youcu

     8

#                          Higen Motor : Donggu Kang

     9

#

    10

# See COPYING file for copyrights details.

    11

    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

    30

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

    31

    32

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

    33

    34

    35

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

    36

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

    37

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

    38

    else:

    39

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

    40

    41

    42

def GetVariablesTableColnames(position=False):

    44

    colname = ["#"]

    45

    if position:

    46

        colname.append(_("Position"))

    47

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

    48

    49

    50

ACCESS_TYPES = {

    51

    'ro': 'R',

    52

    'wo': 'W',

    53

    'rw': 'R/W'}

    54

    55

    56

def GetAccessValue(access, pdo_mapping):

    57

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

    58

    if pdo_mapping != "":

    59

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

    60

    return value

    61

    62

    63

VARIABLES_FILTERS = [

    64

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

    65

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

    66

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

    67

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

    68

    69

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

    70

    71

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

    72

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

    73

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

    74

    75

    76

class NodeVariablesSizer(wx.FlexGridSizer):

    77

    78

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

    79

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

    80

        self.AddGrowableCol(0)

    81

        self.AddGrowableRow(1)

    82

    83

        self.Controler = controler

    84

        self.PositionColumn = position_column

    85

    86

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

    87

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

    88

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

    89

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

    90

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

    91

    92

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

    93

                style=wx.TR_DEFAULT_STYLE |

    94

                      wx.TR_ROW_LINES |

    95

                      wx.TR_COLUMN_LINES |

    96

                      wx.TR_HIDE_ROOT |

    97

                      wx.TR_FULL_ROW_HIGHLIGHT)

    98

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

    99

            self.OnVariablesGridLeftClick)

   100

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

   101

   102

        self.Filters = []

   103

        for desc, value in VARIABLES_FILTERS:

   104

            self.VariablesFilter.Append(desc)

   105

            self.Filters.append(value)

   106

   107

        self.VariablesFilter.SetSelection(0)

   108

        self.CurrentFilter = self.Filters[0]

   109

        self.VariablesFilterFirstCharacter = True

   110

   111

        if position_column:

   112

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

   113

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

   114

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

   115

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

   116

                                                   wx.ALIGN_LEFT]):

   117

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

   118

            self.VariablesGrid.SetMainColumn(2)

   119

        else:

   120

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

   121

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

   122

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

   123

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

   124

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

   125

            self.VariablesGrid.SetMainColumn(1)

   126

   127

    def RefreshView(self):

   128

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

   129

        self.RefreshVariablesGrid(entries)

   130

   131

    def RefreshVariablesGrid(self, entries):

   132

        root = self.VariablesGrid.GetRootItem()

   133

        if not root.IsOk():

   134

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

   135

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

   136

        self.VariablesGrid.Expand(root)

   137

   138

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

   139

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

   140

   141

        no_more_items = not item.IsOk()

   142

        for entry in entries:

   143

            idx += 1

   144

            if no_more_items:

   145

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

   146

            for col, colname in enumerate(colnames):

   147

                if col == 0:

   148

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

   149

                else:

   150

                    value = entry.get(colname, "")

   151

                    if colname == "Access":

   152

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

   153

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

   154

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

   155

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

   156

            else:

   157

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

   158

            self.VariablesGrid.SetItemPyData(item, entry)

   159

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

   160

            if not no_more_items:

   161

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

   162

                no_more_items = not item.IsOk()

   163

   164

        if not no_more_items:

   165

            to_delete = []

   166

            while item.IsOk():

   167

                to_delete.append(item)

   168

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

   169

            for item in to_delete:

   170

                self.VariablesGrid.Delete(item)

   171

   172

        return idx

   173

   174

    def OnVariablesFilterChanged(self, event):

   175

        filter = self.VariablesFilter.GetSelection()

   176

        if filter != -1:

   177

            self.CurrentFilter = self.Filters[filter]

   178

            self.RefreshView()

   179

        else:

   180

            try:

   181

                value = self.VariablesFilter.GetValue()

   182

                if value == "":

   183

                    self.CurrentFilter = self.Filters[0]

   184

                    self.VariablesFilter.SetSelection(0)

   185

                else:

   186

                    result = ETHERCAT_INDEX_MODEL.match(value)

   187

                    if result is not None:

   188

                        value = result.group(1)

   189

                    index = int(value, 16)

   190

                    self.CurrentFilter = (index, index)

   191

                    self.VariablesFilter.SetValue(VARIABLE_INDEX_FILTER_FORMAT % index)

   192

                self.RefreshView()

   193

            except Exception:

   194

                if self.CurrentFilter in self.Filters:

   195

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

   196

                else:

   197

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

   198

        self.VariablesFilterFirstCharacter = True

   199

        event.Skip()

   200

   201

    def OnVariablesFilterKeyDown(self, event):

   202

        if self.VariablesFilterFirstCharacter:

   203

            keycode = event.GetKeyCode()

   204

            if keycode not in [wx.WXK_RETURN,

   205

                               wx.WXK_NUMPAD_ENTER]:

   206

                self.VariablesFilterFirstCharacter = False

   207

                if keycode not in NAVIGATION_KEYS:

   208

                    self.VariablesFilter.SetValue("")

   209

            if keycode not in [wx.WXK_DELETE,

   210

                               wx.WXK_NUMPAD_DELETE,

   211

                               wx.WXK_BACK]:

   212

                event.Skip()

   213

        else:

   214

            event.Skip()

   215

   216

    def OnVariablesGridLeftClick(self, event):

   217

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

   218

        if item.IsOk():

   219

            entry = self.VariablesGrid.GetItemPyData(item)

   220

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

   221

            data_size = self.Controler.GetSizeOfType(data_type)

   222

   223

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

   224

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

   225

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

   226

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

   227

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

   228

                location = self.Controler.GetCurrentLocation()

   229

                if self.PositionColumn:

   230

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

   231

                    location += (slave_pos,)

   232

                    node_name = self.Controler.GetSlaveName(slave_pos)

   233

                else:

   234

                    node_name = self.Controler.CTNName()

   235

   236

                if pdo_mapping != "":

   237

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

   238

                    if pdo_mapping == "T":

   239

                        dir = "%I"

   240

                    else:

   241

                        dir = "%Q"

   242

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

   243

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

   244

   245

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

   246

                    dragSource = wx.DropSource(self.VariablesGrid)

   247

                    dragSource.SetData(data)

   248

                    dragSource.DoDragDrop()

   249

                    return

   250

   251

                elif self.PositionColumn:

   252

                    location = self.Controler.GetCurrentLocation() +\

   253

                               (slave_pos, entry_index, entry_subindex)

   254

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

   255

                    dragSource = wx.DropSource(self.VariablesGrid)

   256

                    dragSource.SetData(data)

   257

                    dragSource.DoDragDrop()

   258

                    return

   259

   260

        event.Skip()

   261

   262

   263

class NodeEditor(ConfTreeNodeEditor):

   264

   265

    CONFNODEEDITOR_TABS = [

   266

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

   267

        # Add Notebook Tab for EtherCAT Management Treebook

   268

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

   269

        ]

   270

   271

    def _create_EthercatNodeEditor(self, prnt):

   272

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

   273

   274

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

   275

        main_sizer.AddGrowableCol(0)

   276

        main_sizer.AddGrowableRow(1)

   277

   278

        variables_label = wx.StaticText(self.EthercatNodeEditor,

   279

              label=_('Variable entries:'))

   280

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

   281

   282

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

   283

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

   284

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

   285

   286

        self.EthercatNodeEditor.SetSizer(main_sizer)

   287

   288

        return self.EthercatNodeEditor

   289

   290

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

   291

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

   292

   293

        # add Contoler for use EthercatSlave.py Method

   294

        self.Controler = controler

   295

   296

    def GetBufferState(self):

   297

        return False, False

   298

   299

    def RefreshView(self):

   300

        ConfTreeNodeEditor.RefreshView(self)

   301

   302

        self.NodeVariables.RefreshView()

   303

   304

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

   305

    def _create_EtherCATManagementEditor(self, prnt):

   306

        self.EtherCATManagementEditor = wx.ScrolledWindow(prnt,

   307

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

   308

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

   309

   310

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

   311

        self.EtherCATManagermentEditor_Main_Sizer.AddGrowableCol(0)

   312

        self.EtherCATManagermentEditor_Main_Sizer.AddGrowableRow(0)

   313

   314

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

   315

   316

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

   317

   318

        self.EtherCATManagementEditor.SetSizer(self.EtherCATManagermentEditor_Main_Sizer)

   319

        return self.EtherCATManagementEditor

   320

   321

    def OnResize(self, event):

   322

        self.EtherCATManagementEditor.GetBestSize()

   323

        xstart, ystart = self.EtherCATManagementEditor.GetViewStart()

   324

        window_size = self.EtherCATManagementEditor.GetClientSize()

   325

        maxx, maxy = self.EtherCATManagementEditor.GetMinSize()

   326

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

   327

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

   328

        self.EtherCATManagementEditor.Scroll(posx, posy)

   329

        self.EtherCATManagementEditor.SetScrollbars(SCROLLBAR_UNIT, SCROLLBAR_UNIT,

   330

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

   331

        event.Skip()

   332

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

   333

   334

   335

CIA402NodeEditor = NodeEditor

   336

   337

   338

def GetProcessVariablesTableColnames():

   340

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

   341

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

   342

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

   343

            _("Description")]

   344

   345

   346

class ProcessVariablesTable(CustomTable):

   347

   348

    def GetValue(self, row, col):

   349

        if row < self.GetNumberRows():

   350

            if col == 0:

   351

                return row + 1

   352

            colname = self.GetColLabelValue(col, False)

   353

            if colname.startswith("Read from"):

   354

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

   355

                if value == "":

   356

                    return value

   357

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

   358

            elif colname.startswith("Write to"):

   359

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

   360

                if value == "":

   361

                    return value

   362

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

   363

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

   364

   365

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

   366

        if col < len(self.colnames):

   367

            colname = self.GetColLabelValue(col, False)

   368

            if colname.startswith("Read from"):

   369

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

   370

            elif colname.startswith("Write to"):

   371

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

   372

            else:

   373

                self.data[row][colname] = value

   374

   375

    def _updateColAttrs(self, grid):

   376

        """

   377

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

   378

        appropriate renderer given the column name.

   379

   380

        Otherwise default to the default renderer.

   381

        """

   382

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

   383

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

   384

                editor = None

   385

                renderer = None

   386

                colname = self.GetColLabelValue(col, False)

   387

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

   388

                    editor = wx.grid.GridCellTextEditor()

   389

                    renderer = wx.grid.GridCellStringRenderer()

   390

                    grid.SetReadOnly(row, col, False)

   391

                else:

   392

                    grid.SetReadOnly(row, col, True)

   393

   394

                grid.SetCellEditor(row, col, editor)

   395

                grid.SetCellRenderer(row, col, renderer)

   396

   397

            self.ResizeRow(grid, row)

   398

   399

   400

class ProcessVariableDropTarget(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

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

   409

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

   410

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

   411

        message = None

   412

        try:

   413

            values = eval(data)

   414

        except Exception:

   415

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

   416

            values = None

   417

        if not isinstance(values, TupleType):

   418

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

   419

            values = None

   420

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

   421

            location = None

   422

            if values[1] == "location":

   423

                result = LOCATION_MODEL.match(values[0])

   424

                if result is not None:

   425

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

   426

                master_location = self.ParentWindow.GetMasterLocation()

   427

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

   428

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

   429

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

   430

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

   431

                    if col == 2:

   432

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

   433

                    else:

   434

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

   435

                    if other_values != "":

   436

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

   437

                    else:

   438

                        other_type = None

   439

                    if other_type is None or var_type == other_type:

   440

                        if col == 2:

   441

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

   442

                        else:

   443

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

   444

                        self.ParentWindow.SaveProcessVariables()

   445

                        self.ParentWindow.RefreshProcessVariables()

   446

                    else:

   447

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

   448

                else:

   449

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

   450

   451

        if message is not None:

   452

            wx.CallAfter(self.ShowMessage, message)

   453

   454

    def ShowMessage(self, message):

   455

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

   456

        message.ShowModal()

   457

        message.Destroy()

   458

   459

   460

def GetStartupCommandsTableColnames():

   462

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

   463

   464

   465

class StartupCommandDropTarget(wx.TextDropTarget):

   466

   467

    def __init__(self, parent):

   468

        wx.TextDropTarget.__init__(self)

   469

        self.ParentWindow = parent

   470

   471

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

   472

        self.ParentWindow.Select()

   473

        message = None

   474

        try:

   475

            values = eval(data)

   476

        except Exception:

   477

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

   478

            values = None

   479

        if not isinstance(values, TupleType):

   480

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

   481

            values = None

   482

        if values is not None: