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

from __future__ import absolute_import

    13

from __future__ import division

    14

import os

    15

import re

    16

from types import TupleType

    17

    18

import wx

    19

import wx.grid

    20

import wx.gizmos

    21

import wx.lib.buttons

    22

    23

from plcopen.structures import IEC_KEYWORDS, TestIdentifier

    24

from controls import CustomGrid, CustomTable, FolderTree

    25

from controls.CustomStyledTextCtrl import NAVIGATION_KEYS

    26

from editors.ConfTreeNodeEditor import ConfTreeNodeEditor, SCROLLBAR_UNIT

    27

from util.BitmapLibrary import GetBitmap

    28

from util.TranslationCatalogs import NoTranslate

    29

    30

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

    31

from etherlab.EtherCATManagementEditor import EtherCATManagementTreebook, MasterStatePanelClass

    32

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

    33

    34

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

    35

    36

    37

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

    38

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

    39

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

    40

    else:

    41

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

    42

    43

    44

def GetVariablesTableColnames(position=False):

    45

    _ = NoTranslate

    46

    colname = ["#"]

    47

    if position:

    48

        colname.append(_("Position"))

    49

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

    50

    51

    52

ACCESS_TYPES = {

    53

    'ro': 'R',

    54

    'wo': 'W',

    55

    'rw': 'R/W'}

    56

    57

    58

def GetAccessValue(access, pdo_mapping):

    59

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

    60

    if pdo_mapping != "":

    61

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

    62

    return value

    63

    64

    65

VARIABLES_FILTERS = [

    66

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

    67

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

    68

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

    69

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

    70

    71

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

    72

    73

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

    74

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

    75

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

    76

    77

    78

class NodeVariablesSizer(wx.FlexGridSizer):

    79

    80

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

    81

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

    82

        self.AddGrowableCol(0)

    83

        self.AddGrowableRow(1)

    84

    85

        self.Controler = controler

    86

        self.PositionColumn = position_column

    87

    88

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

    89

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

    90

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

    91

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

    92

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

    93

    94

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

    95

                                                    style=wx.TR_DEFAULT_STYLE |

    96

                                                    wx.TR_ROW_LINES |

    97

                                                    wx.TR_COLUMN_LINES |

    98

                                                    wx.TR_HIDE_ROOT |

    99

                                                    wx.TR_FULL_ROW_HIGHLIGHT)

   100

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

   101

                                                self.OnVariablesGridLeftClick)

   102

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

   103

   104

        self.Filters = []

   105

        for desc, value in VARIABLES_FILTERS:

   106

            self.VariablesFilter.Append(desc)

   107

            self.Filters.append(value)

   108

   109

        self.VariablesFilter.SetSelection(0)

   110

        self.CurrentFilter = self.Filters[0]

   111

        self.VariablesFilterFirstCharacter = True

   112

   113

        if position_column:

   114

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

   115

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

   116

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

   117

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

   118

                                                   wx.ALIGN_LEFT]):

   119

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

   120

            self.VariablesGrid.SetMainColumn(2)

   121

        else:

   122

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

   123

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

   124

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

   125

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

   126

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

   127

            self.VariablesGrid.SetMainColumn(1)

   128

   129

    def RefreshView(self):

   130

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

   131

        self.RefreshVariablesGrid(entries)

   132

   133

    def RefreshVariablesGrid(self, entries):

   134

        root = self.VariablesGrid.GetRootItem()

   135

        if not root.IsOk():

   136

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

   137

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

   138

        self.VariablesGrid.Expand(root)

   139

   140

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

   141

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

   142

   143

        no_more_items = not item.IsOk()

   144

        for entry in entries:

   145

            idx += 1

   146

            if no_more_items:

   147

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

   148

            for col, colname in enumerate(colnames):

   149

                if col == 0:

   150

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

   151

                else:

   152

                    value = entry.get(colname, "")

   153

                    if colname == "Access":

   154

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

   155

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

   156

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

   157

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

   158

            else:

   159

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

   160

            self.VariablesGrid.SetItemPyData(item, entry)

   161

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

   162

            if not no_more_items:

   163

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

   164

                no_more_items = not item.IsOk()

   165

   166

        if not no_more_items:

   167

            to_delete = []

   168

            while item.IsOk():

   169

                to_delete.append(item)

   170

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

   171

            for item in to_delete:

   172

                self.VariablesGrid.Delete(item)

   173

   174

        return idx

   175

   176

    def OnVariablesFilterChanged(self, event):

   177

        filter = self.VariablesFilter.GetSelection()

   178

        if filter != -1:

   179

            self.CurrentFilter = self.Filters[filter]

   180

            self.RefreshView()

   181

        else:

   182

            try:

   183

                value = self.VariablesFilter.GetValue()

   184

                if value == "":

   185

                    self.CurrentFilter = self.Filters[0]

   186

                    self.VariablesFilter.SetSelection(0)

   187

                else:

   188

                    result = ETHERCAT_INDEX_MODEL.match(value)

   189

                    if result is not None:

   190

                        value = result.group(1)

   191

                    index = int(value, 16)

   192

                    self.CurrentFilter = (index, index)

   193

                    self.VariablesFilter.SetValue(VARIABLE_INDEX_FILTER_FORMAT % index)

   194

                self.RefreshView()

   195

            except Exception:

   196

                if self.CurrentFilter in self.Filters:

   197

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

   198

                else:

   199

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

   200

        self.VariablesFilterFirstCharacter = True

   201

        event.Skip()

   202

   203

    def OnVariablesFilterKeyDown(self, event):

   204

        if self.VariablesFilterFirstCharacter:

   205

            keycode = event.GetKeyCode()

   206

            if keycode not in [wx.WXK_RETURN,

   207

                               wx.WXK_NUMPAD_ENTER]:

   208

                self.VariablesFilterFirstCharacter = False

   209

                if keycode not in NAVIGATION_KEYS:

   210

                    self.VariablesFilter.SetValue("")

   211

            if keycode not in [wx.WXK_DELETE,

   212

                               wx.WXK_NUMPAD_DELETE,

   213

                               wx.WXK_BACK]:

   214

                event.Skip()

   215

        else:

   216

            event.Skip()

   217

   218

    def OnVariablesGridLeftClick(self, event):

   219

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

   220

        if item.IsOk():

   221

            entry = self.VariablesGrid.GetItemPyData(item)

   222

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

   223

            data_size = self.Controler.GetSizeOfType(data_type)

   224

   225

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

   226

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

   227

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

   228

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

   229

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

   230

                location = self.Controler.GetCurrentLocation()

   231

                if self.PositionColumn:

   232

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

   233

                    location += (slave_pos,)

   234

                    node_name = self.Controler.GetSlaveName(slave_pos)

   235

                else:

   236

                    node_name = self.Controler.CTNName()

   237

   238

                if pdo_mapping != "":

   239

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

   240

                    if pdo_mapping == "T":

   241

                        dir = "%I"

   242

                    else:

   243

                        dir = "%Q"

   244

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

   245

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

   246

   247

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

   248

                    dragSource = wx.DropSource(self.VariablesGrid)

   249

                    dragSource.SetData(data)

   250

                    dragSource.DoDragDrop()

   251

                    return

   252

   253

                elif self.PositionColumn:

   254

                    location = self.Controler.GetCurrentLocation() +\

   255

                               (slave_pos, entry_index, entry_subindex)

   256

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

   257

                    dragSource = wx.DropSource(self.VariablesGrid)

   258

                    dragSource.SetData(data)

   259

                    dragSource.DoDragDrop()

   260

                    return

   261

   262

        event.Skip()

   263

   264

   265

class NodeEditor(ConfTreeNodeEditor):

   266

   267

    CONFNODEEDITOR_TABS = [

   268

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

   269

        # Add Notebook Tab for EtherCAT Management Treebook

   270

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

   271

        ]

   272

   273

    def _create_EthercatNodeEditor(self, prnt):

   274

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

   275

   276

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

   277

        main_sizer.AddGrowableCol(0)

   278

        main_sizer.AddGrowableRow(1)

   279

   280

        variables_label = wx.StaticText(self.EthercatNodeEditor,

   281

                                        label=_('Variable entries:'))

   282

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

   283

   284

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

   285

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

   286

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

   287

   288

        self.EthercatNodeEditor.SetSizer(main_sizer)

   289

   290

        return self.EthercatNodeEditor

   291

   292

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

   293

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

   294

   295

        # add Contoler for use EthercatSlave.py Method

   296

        self.Controler = controler

   297

   298

    def GetBufferState(self):

   299

        return False, False

   300

   301

    def RefreshView(self):

   302

        ConfTreeNodeEditor.RefreshView(self)

   303

   304

        self.NodeVariables.RefreshView()

   305

   306

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

   307

    def _create_EtherCATManagementEditor(self, prnt):

   308

        self.EtherCATManagementEditor = wx.ScrolledWindow(prnt,

   309

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

   310

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

   311

   312

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

   313

        self.EtherCATManagermentEditor_Main_Sizer.AddGrowableCol(0)

   314

        self.EtherCATManagermentEditor_Main_Sizer.AddGrowableRow(0)

   315

   316

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

   317

   318

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

   319

   320

        self.EtherCATManagementEditor.SetSizer(self.EtherCATManagermentEditor_Main_Sizer)

   321

        return self.EtherCATManagementEditor

   322

   323

    def OnResize(self, event):

   324

        self.EtherCATManagementEditor.GetBestSize()

   325

        xstart, ystart = self.EtherCATManagementEditor.GetViewStart()

   326

        window_size = self.EtherCATManagementEditor.GetClientSize()

   327

        maxx, maxy = self.EtherCATManagementEditor.GetMinSize()

   328

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

   329

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

   330

        self.EtherCATManagementEditor.Scroll(posx, posy)

   331

        self.EtherCATManagementEditor.SetScrollbars(SCROLLBAR_UNIT, SCROLLBAR_UNIT,

   332

                                                    maxx // SCROLLBAR_UNIT,

   333

                                                    maxy // SCROLLBAR_UNIT,

   334

                                                    posx, posy)

   335

        event.Skip()

   336

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

   337

   338

   339

CIA402NodeEditor = NodeEditor

   340

   341

   342

def GetProcessVariablesTableColnames():

   343

    _ = NoTranslate

   344

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

   345

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

   346

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

   347

            _("Description")]

   348

   349

   350

class ProcessVariablesTable(CustomTable):

   351

   352

    def GetValue(self, row, col):

   353

        if row < self.GetNumberRows():

   354

            if col == 0:

   355

                return row + 1

   356

            colname = self.GetColLabelValue(col, False)

   357

            if colname.startswith("Read from"):

   358

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

   359

                if value == "":

   360

                    return value

   361

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

   362

            elif colname.startswith("Write to"):

   363

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

   364

                if value == "":

   365

                    return value

   366

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

   367

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

   368

   369

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

   370

        if col < len(self.colnames):

   371

            colname = self.GetColLabelValue(col, False)

   372

            if colname.startswith("Read from"):

   373

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

   374

            elif colname.startswith("Write to"):

   375

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

   376

            else:

   377

                self.data[row][colname] = value

   378

   379

    def _updateColAttrs(self, grid):

   380

        """

   381

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

   382

        appropriate renderer given the column name.

   383

   384

        Otherwise default to the default renderer.

   385

        """

   386

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

   387

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

   388

                editor = None

   389

                renderer = None

   390

                colname = self.GetColLabelValue(col, False)

   391

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

   392

                    editor = wx.grid.GridCellTextEditor()

   393

                    renderer = wx.grid.GridCellStringRenderer()

   394

                    grid.SetReadOnly(row, col, False)

   395

                else:

   396

                    grid.SetReadOnly(row, col, True)

   397

   398

                grid.SetCellEditor(row, col, editor)

   399

                grid.SetCellRenderer(row, col, renderer)

   400

   401

            self.ResizeRow(grid, row)

   402

   403

   404

class ProcessVariableDropTarget(wx.TextDropTarget):

   405

   406

    def __init__(self, parent):

   407

        wx.TextDropTarget.__init__(self)

   408

        self.ParentWindow = parent

   409

   410

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

   411

        self.ParentWindow.Select()

   412

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

   413

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

   414

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

   415

        message = None

   416

        try:

   417

            values = eval(data)

   418

        except Exception:

   419

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

   420

            values = None

   421

        if not isinstance(values, TupleType):

   422

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

   423

            values = None

   424

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

   425

            location = None

   426

            if values[1] == "location":

   427

                result = LOCATION_MODEL.match(values[0])

   428

                if result is not None:

   429

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

   430

                master_location = self.ParentWindow.GetMasterLocation()

   431

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

   432

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

   433

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

   434

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

   435

                    if col == 2:

   436

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

   437

                    else:

   438

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

   439

                    if other_values != "":

   440

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

   441

                    else:

   442

                        other_type = None

   443

                    if other_type is None or var_type == other_type:

   444

                        if col == 2:

   445

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

   446

                        else:

   447

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

   448

                        self.ParentWindow.SaveProcessVariables()

   449

                        self.ParentWindow.RefreshProcessVariables()

   450

                    else:

   451

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

   452

                else:

   453

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

   454

   455

        if message is not None:

   456

            wx.CallAfter(self.ShowMessage, message)

   457

   458

    def ShowMessage(self, message):

   459

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

   460

        message.ShowModal()

   461

        message.Destroy()

   462

   463

   464

def GetStartupCommandsTableColnames():

   465

    _ = NoTranslate

   466

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

   467

   468

   469

class StartupCommandDropTarget(wx.TextDropTarget):

   470

   471

    def __init__(self, parent):

   472

        wx.TextDropTarget.__init__(self)

   473

        self.ParentWindow = parent

   474

   475

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

   476

        self.ParentWindow.Select()

   477

        message = None

   478

        try:

   479

            values = eval(data)

   480

        except Exception:

   481

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

   482