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

    17

import wx

    18

import wx.grid

    19

import wx.gizmos

    20

import wx.lib.buttons

    21

    22

from plcopen.structures import IEC_KEYWORDS, TestIdentifier

    23

from controls import CustomGrid, CustomTable, FolderTree

    24

from controls.CustomStyledTextCtrl import NAVIGATION_KEYS

    25

from editors.ConfTreeNodeEditor import ConfTreeNodeEditor, SCROLLBAR_UNIT

    26

from util.BitmapLibrary import GetBitmap

    27

from util.TranslationCatalogs import NoTranslate

    28

    29

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

    30

from etherlab.EtherCATManagementEditor import EtherCATManagementTreebook, MasterStatePanelClass

    31

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

    32

    33

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

    34

    35

    36

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

    37

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

    38

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

    39

    else:

    40

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

    41

    42

    43

def GetVariablesTableColnames(position=False):

    44

    _ = NoTranslate

    45

    colname = ["#"]

    46

    if position:

    47

        colname.append(_("Position"))

    48

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

    49

    50

    51

ACCESS_TYPES = {

    52

    'ro': 'R',

    53

    'wo': 'W',

    54

    'rw': 'R/W'}

    55

    56

    57

def GetAccessValue(access, pdo_mapping):

    58

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

    59

    if pdo_mapping != "":

    60

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

    61

    return value

    62

    63

    64

VARIABLES_FILTERS = [

    65

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

    66

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

    67

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

    68

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

    69

    70

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

    71

    72

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

    73

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

    74

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

    75

    76

    77

class NodeVariablesSizer(wx.FlexGridSizer):

    78

    79

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

    80

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

    81

        self.AddGrowableCol(0)

    82

        self.AddGrowableRow(1)

    83

    84

        self.Controler = controler

    85

        self.PositionColumn = position_column

    86

    87

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

    88

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

    89

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

    90

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

    91

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

    92

    93

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

    94

                                                    style=wx.TR_DEFAULT_STYLE |

    95

                                                    wx.TR_ROW_LINES |

    96

                                                    wx.TR_COLUMN_LINES |

    97

                                                    wx.TR_HIDE_ROOT |

    98

                                                    wx.TR_FULL_ROW_HIGHLIGHT)

    99

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

   100

                                                self.OnVariablesGridLeftClick)

   101

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

   102

   103

        self.Filters = []

   104

        for desc, value in VARIABLES_FILTERS:

   105

            self.VariablesFilter.Append(desc)

   106

            self.Filters.append(value)

   107

   108

        self.VariablesFilter.SetSelection(0)

   109

        self.CurrentFilter = self.Filters[0]

   110

        self.VariablesFilterFirstCharacter = True

   111

   112

        if position_column:

   113

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

   114

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

   115

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

   116

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

   117

                                                   wx.ALIGN_LEFT]):

   118

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

   119

            self.VariablesGrid.SetMainColumn(2)

   120

        else:

   121

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

   122

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

   123

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

   124

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

   125

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

   126

            self.VariablesGrid.SetMainColumn(1)

   127

   128

    def RefreshView(self):

   129

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

   130

        self.RefreshVariablesGrid(entries)

   131

   132

    def RefreshVariablesGrid(self, entries):

   133

        root = self.VariablesGrid.GetRootItem()

   134

        if not root.IsOk():

   135

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

   136

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

   137

        self.VariablesGrid.Expand(root)

   138

   139

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

   140

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

   141

   142

        no_more_items = not item.IsOk()

   143

        for entry in entries:

   144

            idx += 1

   145

            if no_more_items:

   146

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

   147

            for col, colname in enumerate(colnames):

   148

                if col == 0:

   149

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

   150

                else:

   151

                    value = entry.get(colname, "")

   152

                    if colname == "Access":

   153

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

   154

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

   155

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

   156

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

   157

            else:

   158

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

   159

            self.VariablesGrid.SetItemPyData(item, entry)

   160

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

   161

            if not no_more_items:

   162

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

   163

                no_more_items = not item.IsOk()

   164

   165

        if not no_more_items:

   166

            to_delete = []

   167

            while item.IsOk():

   168

                to_delete.append(item)

   169

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

   170

            for item in to_delete:

   171

                self.VariablesGrid.Delete(item)

   172

   173

        return idx

   174

   175

    def OnVariablesFilterChanged(self, event):

   176

        filter = self.VariablesFilter.GetSelection()

   177

        if filter != -1:

   178

            self.CurrentFilter = self.Filters[filter]

   179

            self.RefreshView()

   180

        else:

   181

            try:

   182

                value = self.VariablesFilter.GetValue()

   183

                if value == "":

   184

                    self.CurrentFilter = self.Filters[0]

   185

                    self.VariablesFilter.SetSelection(0)

   186

                else:

   187

                    result = ETHERCAT_INDEX_MODEL.match(value)

   188

                    if result is not None:

   189

                        value = result.group(1)

   190

                    index = int(value, 16)

   191

                    self.CurrentFilter = (index, index)

   192

                    self.VariablesFilter.SetValue(VARIABLE_INDEX_FILTER_FORMAT % index)

   193

                self.RefreshView()

   194

            except Exception:

   195

                if self.CurrentFilter in self.Filters:

   196

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

   197

                else:

   198

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

   199

        self.VariablesFilterFirstCharacter = True

   200

        event.Skip()

   201

   202

    def OnVariablesFilterKeyDown(self, event):

   203

        if self.VariablesFilterFirstCharacter:

   204

            keycode = event.GetKeyCode()

   205

            if keycode not in [wx.WXK_RETURN,

   206

                               wx.WXK_NUMPAD_ENTER]:

   207

                self.VariablesFilterFirstCharacter = False

   208

                if keycode not in NAVIGATION_KEYS:

   209

                    self.VariablesFilter.SetValue("")

   210

            if keycode not in [wx.WXK_DELETE,

   211

                               wx.WXK_NUMPAD_DELETE,

   212

                               wx.WXK_BACK]:

   213

                event.Skip()

   214

        else:

   215

            event.Skip()

   216

   217

    def OnVariablesGridLeftClick(self, event):

   218

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

   219

        if item.IsOk():

   220

            entry = self.VariablesGrid.GetItemPyData(item)

   221

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

   222

            data_size = self.Controler.GetSizeOfType(data_type)

   223

   224

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

   225

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

   226

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

   227

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

   228

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

   229

                location = self.Controler.GetCurrentLocation()

   230

                if self.PositionColumn:

   231

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

   232

                    location += (slave_pos,)

   233

                    node_name = self.Controler.GetSlaveName(slave_pos)

   234

                else:

   235

                    node_name = self.Controler.CTNName()

   236

   237

                if pdo_mapping != "":

   238

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

   239

                    if pdo_mapping == "T":

   240

                        dir = "%I"

   241

                    else:

   242

                        dir = "%Q"

   243

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

   244

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

   245

   246

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

   247

                    dragSource = wx.DropSource(self.VariablesGrid)

   248

                    dragSource.SetData(data)

   249

                    dragSource.DoDragDrop()

   250

                    return

   251

   252

                elif self.PositionColumn:

   253

                    location = self.Controler.GetCurrentLocation() +\

   254

                               (slave_pos, entry_index, entry_subindex)

   255

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

   256

                    dragSource = wx.DropSource(self.VariablesGrid)

   257

                    dragSource.SetData(data)

   258

                    dragSource.DoDragDrop()

   259

                    return

   260

   261

        event.Skip()

   262

   263

   264

class NodeEditor(ConfTreeNodeEditor):

   265

   266

    CONFNODEEDITOR_TABS = [

   267

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

   268

        # Add Notebook Tab for EtherCAT Management Treebook

   269

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

   270

        ]

   271

   272

    def _create_EthercatNodeEditor(self, prnt):

   273

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

   274

   275

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

   276

        main_sizer.AddGrowableCol(0)

   277

        main_sizer.AddGrowableRow(1)

   278

   279

        variables_label = wx.StaticText(self.EthercatNodeEditor,

   280

                                        label=_('Variable entries:'))

   281

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

   282

   283

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

   284

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

   285

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

   286

   287

        self.EthercatNodeEditor.SetSizer(main_sizer)

   288

   289

        return self.EthercatNodeEditor

   290

   291

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

   292

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

   293

   294

        # add Contoler for use EthercatSlave.py Method

   295

        self.Controler = controler

   296

   297

    def GetBufferState(self):

   298

        return False, False

   299

   300

    def RefreshView(self):

   301

        ConfTreeNodeEditor.RefreshView(self)

   302

   303

        self.NodeVariables.RefreshView()

   304

   305

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

   306

    def _create_EtherCATManagementEditor(self, prnt):

   307

        self.EtherCATManagementEditor = wx.ScrolledWindow(prnt,

   308

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

   309

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

   310

   311

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

   312

        self.EtherCATManagermentEditor_Main_Sizer.AddGrowableCol(0)

   313

        self.EtherCATManagermentEditor_Main_Sizer.AddGrowableRow(0)

   314

   315

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

   316

   317

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

   318

   319

        self.EtherCATManagementEditor.SetSizer(self.EtherCATManagermentEditor_Main_Sizer)

   320

        return self.EtherCATManagementEditor

   321

   322

    def OnResize(self, event):

   323

        self.EtherCATManagementEditor.GetBestSize()

   324

        xstart, ystart = self.EtherCATManagementEditor.GetViewStart()

   325

        window_size = self.EtherCATManagementEditor.GetClientSize()

   326

        maxx, maxy = self.EtherCATManagementEditor.GetMinSize()

   327

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

   328

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

   329

        self.EtherCATManagementEditor.Scroll(posx, posy)

   330

        self.EtherCATManagementEditor.SetScrollbars(SCROLLBAR_UNIT, SCROLLBAR_UNIT,

   331

                                                    maxx // SCROLLBAR_UNIT,

   332

                                                    maxy // SCROLLBAR_UNIT,

   333

                                                    posx, posy)

   334

        event.Skip()

   335

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

   336

   337

   338

CIA402NodeEditor = NodeEditor

   339

   340

   341

def GetProcessVariablesTableColnames():

   342

    _ = NoTranslate

   343

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

   344

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

   345

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

   346

            _("Description")]

   347

   348

   349

class ProcessVariablesTable(CustomTable):

   350

   351

    def GetValue(self, row, col):

   352

        if row < self.GetNumberRows():

   353

            if col == 0:

   354

                return row + 1

   355

            colname = self.GetColLabelValue(col, False)

   356

            if colname.startswith("Read from"):

   357

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

   358

                if value == "":

   359

                    return value

   360

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

   361

            elif colname.startswith("Write to"):

   362

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

   363

                if value == "":

   364

                    return value

   365

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

   366

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

   367

   368

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

   369

        if col < len(self.colnames):

   370

            colname = self.GetColLabelValue(col, False)

   371

            if colname.startswith("Read from"):

   372

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

   373

            elif colname.startswith("Write to"):

   374

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

   375

            else:

   376

                self.data[row][colname] = value

   377

   378

    def _updateColAttrs(self, grid):

   379

        """

   380

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

   381

        appropriate renderer given the column name.

   382

   383

        Otherwise default to the default renderer.

   384

        """

   385

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

   386

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

   387

                editor = None

   388

                renderer = None

   389

                colname = self.GetColLabelValue(col, False)

   390

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

   391

                    editor = wx.grid.GridCellTextEditor()

   392

                    renderer = wx.grid.GridCellStringRenderer()

   393

                    grid.SetReadOnly(row, col, False)

   394

                else:

   395

                    grid.SetReadOnly(row, col, True)

   396

   397

                grid.SetCellEditor(row, col, editor)

   398

                grid.SetCellRenderer(row, col, renderer)

   399

   400

            self.ResizeRow(grid, row)

   401

   402

   403

class ProcessVariableDropTarget(wx.TextDropTarget):

   404

   405

    def __init__(self, parent):

   406

        wx.TextDropTarget.__init__(self)

   407

        self.ParentWindow = parent

   408

   409

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

   410

        self.ParentWindow.Select()

   411

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

   412

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

   413

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

   414

        message = None

   415

        try:

   416

            values = eval(data)

   417

        except Exception:

   418

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

   419

            values = None

   420

        if not isinstance(values, tuple):

   421

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

   422

            values = None

   423

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

   424

            location = None

   425

            if values[1] == "location":

   426

                result = LOCATION_MODEL.match(values[0])

   427

                if result is not None:

   428

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

   429

                master_location = self.ParentWindow.GetMasterLocation()

   430

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

   431

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

   432

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

   433

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

   434

                    if col == 2:

   435

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

   436

                    else:

   437

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

   438

                    if other_values != "":

   439

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

   440

                    else:

   441

                        other_type = None

   442

                    if other_type is None or var_type == other_type:

   443

                        if col == 2:

   444

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

   445

                        else:

   446

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

   447

                        self.ParentWindow.SaveProcessVariables()

   448

                        self.ParentWindow.RefreshProcessVariables()

   449

                    else:

   450

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

   451

                else:

   452

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

   453

   454

        if message is not None:

   455

            wx.CallAfter(self.ShowMessage, message)

   456

   457

    def ShowMessage(self, message):

   458

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

   459

        message.ShowModal()

   460

        message.Destroy()

   461

   462

   463

def GetStartupCommandsTableColnames():

   464

    _ = NoTranslate

   465

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

   466

   467

   468

class StartupCommandDropTarget(wx.TextDropTarget):

   469

   470

    def __init__(self, parent):

   471

        wx.TextDropTarget.__init__(self)

   472

        self.ParentWindow = parent

   473

   474

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

   475

        self.ParentWindow.Select()

   476

        message = None

   477

        try:

   478

            values = eval(data)

   479

        except Exception:

   480

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

   481

            values = None