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

                    # add jblee

   153

                    if value is None:

   154

                        value = ""

   155

                    if colname == "Access":

   156

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

   157

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

   158

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

   159

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

   160

            else:

   161

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

   162

            self.VariablesGrid.SetItemPyData(item, entry)

   163

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

   164

            if not no_more_items:

   165

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

   166

                no_more_items = not item.IsOk()

   167

   168

        if not no_more_items:

   169

            to_delete = []

   170

            while item.IsOk():

   171

                to_delete.append(item)

   172

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

   173

            for item in to_delete:

   174

                self.VariablesGrid.Delete(item)

   175

   176

        return idx

   177

   178

    def OnVariablesFilterChanged(self, event):

   179

        filter = self.VariablesFilter.GetSelection()

   180

        if filter != -1:

   181

            self.CurrentFilter = self.Filters[filter]

   182

            self.RefreshView()

   183

        else:

   184

            try:

   185

                value = self.VariablesFilter.GetValue()

   186

                if value == "":

   187

                    self.CurrentFilter = self.Filters[0]

   188

                    self.VariablesFilter.SetSelection(0)

   189

                else:

   190

                    result = ETHERCAT_INDEX_MODEL.match(value)

   191

                    if result is not None:

   192

                        value = result.group(1)

   193

                    index = int(value, 16)

   194

                    self.CurrentFilter = (index, index)

   195

                    self.VariablesFilter.SetValue(VARIABLE_INDEX_FILTER_FORMAT % index)

   196

                self.RefreshView()

   197

            except Exception:

   198

                if self.CurrentFilter in self.Filters:

   199

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

   200

                else:

   201

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

   202

        self.VariablesFilterFirstCharacter = True

   203

        event.Skip()

   204

   205

    def OnVariablesFilterKeyDown(self, event):

   206

        if self.VariablesFilterFirstCharacter:

   207

            keycode = event.GetKeyCode()

   208

            if keycode not in [wx.WXK_RETURN,

   209

                               wx.WXK_NUMPAD_ENTER]:

   210

                self.VariablesFilterFirstCharacter = False

   211

                if keycode not in NAVIGATION_KEYS:

   212

                    self.VariablesFilter.SetValue("")

   213

            if keycode not in [wx.WXK_DELETE,

   214

                               wx.WXK_NUMPAD_DELETE,

   215

                               wx.WXK_BACK]:

   216

                event.Skip()

   217

        else:

   218

            event.Skip()

   219

   220

    def OnVariablesGridLeftClick(self, event):

   221

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

   222

        if item.IsOk():

   223

            entry = self.VariablesGrid.GetItemPyData(item)

   224

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

   225

            data_size = self.Controler.GetSizeOfType(data_type)

   226

   227

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

   228

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

   229

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

   230

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

   231

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

   232

                location = self.Controler.GetCurrentLocation()

   233

                if self.PositionColumn:

   234

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

   235

                    location += (slave_pos,)

   236

                    node_name = self.Controler.GetSlaveName(slave_pos)

   237

                else:

   238

                    node_name = self.Controler.CTNName()

   239

   240

                if pdo_mapping != "":

   241

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

   242

                    if pdo_mapping == "T":

   243

                        dir = "%I"

   244

                    else:

   245

                        dir = "%Q"

   246

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

   247

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

   248

   249

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

   250

                    dragSource = wx.DropSource(self.VariablesGrid)

   251

                    dragSource.SetData(data)

   252

                    dragSource.DoDragDrop()

   253

                    return

   254

   255

                elif self.PositionColumn:

   256

                    location = self.Controler.GetCurrentLocation() +\

   257

                               (slave_pos, entry_index, entry_subindex)

   258

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

   259

                    dragSource = wx.DropSource(self.VariablesGrid)

   260

                    dragSource.SetData(data)

   261

                    dragSource.DoDragDrop()

   262

                    return

   263

   264

        event.Skip()

   265

   266

   267

class NodeEditor(ConfTreeNodeEditor):

   268

   269

    CONFNODEEDITOR_TABS = [

   270

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

   271

        # Add Notebook Tab for EtherCAT Management Treebook

   272

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

   273

        ]

   274

   275

    def _create_EthercatNodeEditor(self, prnt):

   276

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

   277

   278

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

   279

        main_sizer.AddGrowableCol(0)

   280

        main_sizer.AddGrowableRow(1)

   281

   282

        variables_label = wx.StaticText(self.EthercatNodeEditor,

   283

                                        label=_('Variable entries:'))

   284

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

   285

   286

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

   287

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

   288

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

   289

   290

        self.EthercatNodeEditor.SetSizer(main_sizer)

   291

   292

        return self.EthercatNodeEditor

   293

   294

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

   295

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

   296

   297

        # add Contoler for use EthercatSlave.py Method

   298

        self.Controler = controler

   299

   300

    def GetBufferState(self):

   301

        return False, False

   302

   303

    def RefreshView(self):

   304

        ConfTreeNodeEditor.RefreshView(self)

   305

   306

        self.NodeVariables.RefreshView()

   307

   308

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

   309

    def _create_EtherCATManagementEditor(self, prnt):

   310

        self.EtherCATManagementEditor = wx.ScrolledWindow(prnt,

   311

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

   312

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

   313

   314

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

   315

        self.EtherCATManagermentEditor_Main_Sizer.AddGrowableCol(0)

   316

        self.EtherCATManagermentEditor_Main_Sizer.AddGrowableRow(0)

   317

   318

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

   319

   320

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

   321

   322

        self.EtherCATManagementEditor.SetSizer(self.EtherCATManagermentEditor_Main_Sizer)

   323

        return self.EtherCATManagementEditor

   324

   325

    def OnResize(self, event):

   326

        self.EtherCATManagementEditor.GetBestSize()

   327

        xstart, ystart = self.EtherCATManagementEditor.GetViewStart()

   328

        window_size = self.EtherCATManagementEditor.GetClientSize()

   329

        maxx, maxy = self.EtherCATManagementEditor.GetMinSize()

   330

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

   331

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

   332

        self.EtherCATManagementEditor.Scroll(posx, posy)

   333

        self.EtherCATManagementEditor.SetScrollbars(SCROLLBAR_UNIT, SCROLLBAR_UNIT,

   334

                                                    maxx // SCROLLBAR_UNIT,

   335

                                                    maxy // SCROLLBAR_UNIT,

   336

                                                    posx, posy)

   337

        event.Skip()

   338

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

   339

   340

   341

CIA402NodeEditor = NodeEditor

   342

   343

   344

def GetProcessVariablesTableColnames():

   345

    _ = NoTranslate

   346

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

   347

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

   348

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

   349

            _("Description")]

   350

   351

   352

class ProcessVariablesTable(CustomTable):

   353

   354

    def GetValue(self, row, col):

   355

        if row < self.GetNumberRows():

   356

            if col == 0:

   357

                return row + 1

   358

            colname = self.GetColLabelValue(col, False)

   359

            if colname.startswith("Read from"):

   360

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

   361

                if value == "":

   362

                    return value

   363

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

   364

            elif colname.startswith("Write to"):

   365

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

   366

                if value == "":

   367

                    return value

   368

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

   369

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

   370

   371

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

   372

        if col < len(self.colnames):

   373

            colname = self.GetColLabelValue(col, False)

   374

            if colname.startswith("Read from"):

   375

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

   376

            elif colname.startswith("Write to"):

   377

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

   378

            else:

   379

                self.data[row][colname] = value

   380

   381

    def _updateColAttrs(self, grid):

   382

        """

   383

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

   384

        appropriate renderer given the column name.

   385

   386

        Otherwise default to the default renderer.

   387

        """

   388

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

   389

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

   390

                editor = None

   391

                renderer = None

   392

                colname = self.GetColLabelValue(col, False)

   393

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

   394

                    editor = wx.grid.GridCellTextEditor()

   395

                    renderer = wx.grid.GridCellStringRenderer()

   396

                    grid.SetReadOnly(row, col, False)

   397

                else:

   398

                    grid.SetReadOnly(row, col, True)

   399

   400

                grid.SetCellEditor(row, col, editor)

   401

                grid.SetCellRenderer(row, col, renderer)

   402

   403

            self.ResizeRow(grid, row)

   404

   405

   406

class ProcessVariableDropTarget(wx.TextDropTarget):

   407

   408

    def __init__(self, parent):

   409

        wx.TextDropTarget.__init__(self)

   410

        self.ParentWindow = parent

   411

   412

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

   413

        self.ParentWindow.Select()

   414

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

   415

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

   416

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

   417

        message = None

   418

        try:

   419

            values = eval(data)

   420

        except Exception:

   421

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

   422

            values = None

   423

        if not isinstance(values, tuple):

   424

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

   425

            values = None

   426

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

   427

            location = None

   428

            if values[1] == "location":

   429

                result = LOCATION_MODEL.match(values[0])

   430

                if result is not None:

   431

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

   432

                master_location = self.ParentWindow.GetMasterLocation()

   433

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

   434

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

   435

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

   436

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

   437

                    if col == 2:

   438

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

   439

                    else:

   440

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

   441

                    if other_values != "":

   442

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

   443

                    else:

   444

                        other_type = None

   445

                    if other_type is None or var_type == other_type:

   446

                        if col == 2:

   447

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

   448

                        else:

   449

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

   450

                        self.ParentWindow.SaveProcessVariables()

   451

                        self.ParentWindow.RefreshProcessVariables()

   452

                    else:

   453

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

   454

                else:

   455

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

   456

   457

        if message is not None:

   458

            wx.CallAfter(self.ShowMessage, message)

   459

   460

    def ShowMessage(self, message):

   461

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

   462

        message.ShowModal()

   463

        message.Destroy()

   464

   465

   466

def GetStartupCommandsTableColnames():

   467

    _ = NoTranslate

   468

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

   469

   470

   471

class StartupCommandDropTarget(wx.TextDropTarget):

   472

   473

    def __init__(self, parent):

   474

        wx.TextDropTarget.__init__(self)

   475

        self.ParentWindow = parent

   476

   477

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

   478

        self.ParentWindow.Select()

   479

        message = None

   480

        try:

   481

            values = eval(data)

   482