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.adv

    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 GetVariablesTableColnames(position=False):

    37

    _ = NoTranslate

    38

    colname = ["#"]

    39

    if position:

    40

        colname.append(_("Position"))

    41

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

    42

    43

    44

ACCESS_TYPES = {

    45

    'ro': 'R',

    46

    'wo': 'W',

    47

    'rw': 'R/W'}

    48

    49

    50

def GetAccessValue(access, pdo_mapping):

    51

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

    52

    if pdo_mapping != "":

    53

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

    54

    return value

    55

    56

    57

VARIABLES_FILTERS = [

    58

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

    59

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

    60

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

    61

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

    62

    63

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

    64

    65

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

    66

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

    67

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

    68

    69

    70

class NodeVariablesSizer(wx.FlexGridSizer):

    71

    72

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

    73

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

    74

        self.AddGrowableCol(0)

    75

        self.AddGrowableRow(1)

    76

    77

        self.Controler = controler

    78

        self.PositionColumn = position_column

    79

    80

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

    81

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

    82

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

    83

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

    84

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

    85

    86

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

    87

                                                    style=wx.TR_DEFAULT_STYLE |

    88

                                                    wx.TR_ROW_LINES |

    89

                                                    wx.TR_COLUMN_LINES |

    90

                                                    wx.TR_HIDE_ROOT |

    91

                                                    wx.TR_FULL_ROW_HIGHLIGHT)

    92

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

    93

                                                self.OnVariablesGridLeftClick)

    94

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

    95

    96

        self.Filters = []

    97

        for desc, value in VARIABLES_FILTERS:

    98

            self.VariablesFilter.Append(desc)

    99

            self.Filters.append(value)

   100

   101

        self.VariablesFilter.SetSelection(0)

   102

        self.CurrentFilter = self.Filters[0]

   103

        self.VariablesFilterFirstCharacter = True

   104

   105

        if position_column:

   106

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

   107

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

   108

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

   109

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

   110

                                                   wx.ALIGN_LEFT]):

   111

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

   112

            self.VariablesGrid.SetMainColumn(2)

   113

        else:

   114

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

   115

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

   116

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

   117

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

   118

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

   119

            self.VariablesGrid.SetMainColumn(1)

   120

   121

    def RefreshView(self):

   122

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

   123

        self.RefreshVariablesGrid(entries)

   124

   125

    def RefreshVariablesGrid(self, entries):

   126

        root = self.VariablesGrid.GetRootItem()

   127

        if not root.IsOk():

   128

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

   129

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

   130

        self.VariablesGrid.Expand(root)

   131

   132

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

   133

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

   134

   135

        no_more_items = not item.IsOk()

   136

        for entry in entries:

   137

            idx += 1

   138

            if no_more_items:

   139

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

   140

            for col, colname in enumerate(colnames):

   141

                if col == 0:

   142

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

   143

                else:

   144

                    value = entry.get(colname, "")

   145

                    # add jblee

   146

                    if value is None:

   147

                        value = ""

   148

                    if colname == "Access":

   149

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

   150

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

   151

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

   152

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

   153

            else:

   154

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

   155

            self.VariablesGrid.SetItemPyData(item, entry)

   156

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

   157

            if not no_more_items:

   158

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

   159

                no_more_items = not item.IsOk()

   160

   161

        if not no_more_items:

   162

            to_delete = []

   163

            while item.IsOk():

   164

                to_delete.append(item)

   165

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

   166

            for item in to_delete:

   167

                self.VariablesGrid.Delete(item)

   168

   169

        return idx

   170

   171

    def OnVariablesFilterChanged(self, event):

   172

        filter = self.VariablesFilter.GetSelection()

   173

        if filter != -1:

   174

            self.CurrentFilter = self.Filters[filter]

   175

            self.RefreshView()

   176

        else:

   177

            try:

   178

                value = self.VariablesFilter.GetValue()

   179

                if value == "":

   180

                    self.CurrentFilter = self.Filters[0]

   181

                    self.VariablesFilter.SetSelection(0)

   182

                else:

   183

                    result = ETHERCAT_INDEX_MODEL.match(value)

   184

                    if result is not None:

   185

                        value = result.group(1)

   186

                    index = int(value, 16)

   187

                    self.CurrentFilter = (index, index)

   188

                    self.VariablesFilter.SetValue(VARIABLE_INDEX_FILTER_FORMAT % index)

   189

                self.RefreshView()

   190

            except Exception:

   191

                if self.CurrentFilter in self.Filters:

   192

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

   193

                else:

   194

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

   195

        self.VariablesFilterFirstCharacter = True

   196

        event.Skip()

   197

   198

    def OnVariablesFilterKeyDown(self, event):

   199

        if self.VariablesFilterFirstCharacter:

   200

            keycode = event.GetKeyCode()

   201

            if keycode not in [wx.WXK_RETURN,

   202

                               wx.WXK_NUMPAD_ENTER]:

   203

                self.VariablesFilterFirstCharacter = False

   204

                if keycode not in NAVIGATION_KEYS:

   205

                    self.VariablesFilter.SetValue("")

   206

            if keycode not in [wx.WXK_DELETE,

   207

                               wx.WXK_NUMPAD_DELETE,

   208

                               wx.WXK_BACK]:

   209

                event.Skip()

   210

        else:

   211

            event.Skip()

   212

   213

    def OnVariablesGridLeftClick(self, event):

   214

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

   215

        if item.IsOk():

   216

            entry = self.VariablesGrid.GetItemPyData(item)

   217

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

   218

            data_size = self.Controler.GetSizeOfType(data_type)

   219

   220

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

   221

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

   222

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

   223

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

   224

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

   225

                location = self.Controler.GetCurrentLocation()

   226

                if self.PositionColumn:

   227

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

   228

                    location += (slave_pos,)

   229

                    node_name = self.Controler.GetSlaveName(slave_pos)

   230

                else:

   231

                    node_name = self.Controler.CTNName()

   232

   233

                if pdo_mapping != "":

   234

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

   235

                    if pdo_mapping == "T":

   236

                        dir = "%I"

   237

                    else:

   238

                        dir = "%Q"

   239

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

   240

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

   241

   242

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

   243

                    dragSource = wx.DropSource(self.VariablesGrid)

   244

                    dragSource.SetData(data)

   245

                    dragSource.DoDragDrop()

   246

                    return

   247

   248

                elif self.PositionColumn:

   249

                    location = self.Controler.GetCurrentLocation() +\

   250

                               (slave_pos, entry_index, entry_subindex)

   251

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

   252

                    dragSource = wx.DropSource(self.VariablesGrid)

   253

                    dragSource.SetData(data)

   254

                    dragSource.DoDragDrop()

   255

                    return

   256

   257

        event.Skip()

   258

   259

   260

class NodeEditor(ConfTreeNodeEditor):

   261

   262

    CONFNODEEDITOR_TABS = [

   263

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

   264

        # Add Notebook Tab for EtherCAT Management Treebook

   265

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

   266

        ]

   267

   268

    def _create_EthercatNodeEditor(self, prnt):

   269

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

   270

   271

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

   272

        main_sizer.AddGrowableCol(0)

   273

        main_sizer.AddGrowableRow(1)

   274

   275

        variables_label = wx.StaticText(self.EthercatNodeEditor,

   276

                                        label=_('Variable entries:'))

   277

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

   278

   279

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

   280

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

   281

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

   282

   283

        self.EthercatNodeEditor.SetSizer(main_sizer)

   284

   285

        return self.EthercatNodeEditor

   286

   287

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

   288

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

   289

   290

        # add Contoler for use EthercatSlave.py Method

   291

        self.Controler = controler

   292

   293

    def GetBufferState(self):

   294

        return False, False

   295

   296

    def RefreshView(self):

   297

        ConfTreeNodeEditor.RefreshView(self)

   298

   299

        self.NodeVariables.RefreshView()

   300

   301

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

   302

    def _create_EtherCATManagementEditor(self, prnt):

   303

        self.EtherCATManagementEditor = wx.ScrolledWindow(prnt,

   304

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

   305

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

   306

   307

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

   308

        self.EtherCATManagermentEditor_Main_Sizer.AddGrowableCol(0)

   309

        self.EtherCATManagermentEditor_Main_Sizer.AddGrowableRow(0)

   310

   311

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

   312

   313

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

   314

   315

        self.EtherCATManagementEditor.SetSizer(self.EtherCATManagermentEditor_Main_Sizer)

   316

        return self.EtherCATManagementEditor

   317

   318

    def OnResize(self, event):

   319

        self.EtherCATManagementEditor.GetBestSize()

   320

        xstart, ystart = self.EtherCATManagementEditor.GetViewStart()

   321

        window_size = self.EtherCATManagementEditor.GetClientSize()

   322

        maxx, maxy = self.EtherCATManagementEditor.GetMinSize()

   323

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

   324

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

   325

        self.EtherCATManagementEditor.Scroll(posx, posy)

   326

        self.EtherCATManagementEditor.SetScrollbars(SCROLLBAR_UNIT, SCROLLBAR_UNIT,

   327

                                                    maxx // SCROLLBAR_UNIT,

   328

                                                    maxy // SCROLLBAR_UNIT,

   329

                                                    posx, posy)

   330

        event.Skip()

   331

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

   332

   333

   334

CIA402NodeEditor = NodeEditor

   335

   336

   337

def GetProcessVariablesTableColnames():

   338

    _ = NoTranslate

   339

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

   340

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

   341

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

   342

            _("Description")]

   343

   344

   345

class ProcessVariablesTable(CustomTable):

   346

   347

    def GetValue(self, row, col):

   348

        if row < self.GetNumberRows():

   349

            if col == 0:

   350

                return row + 1

   351

            colname = self.GetColLabelValue(col, False)

   352

            if colname.startswith("Read from"):

   353

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

   354

                if value == "":

   355

                    return value

   356

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

   357

            elif colname.startswith("Write to"):

   358

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

   359

                if value == "":

   360

                    return value

   361

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

   362

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

   363

   364

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

   365

        if col < len(self.colnames):

   366

            colname = self.GetColLabelValue(col, False)

   367

            if colname.startswith("Read from"):

   368

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

   369

            elif colname.startswith("Write to"):

   370

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

   371

            else:

   372

                self.data[row][colname] = value

   373

   374

    def _updateColAttrs(self, grid):

   375

        """

   376

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

   377

        appropriate renderer given the column name.

   378

   379

        Otherwise default to the default renderer.

   380

        """

   381

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

   382

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

   383

                editor = None

   384

                renderer = None

   385

                colname = self.GetColLabelValue(col, False)

   386

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

   387

                    editor = wx.grid.GridCellTextEditor()

   388

                    renderer = wx.grid.GridCellStringRenderer()

   389

                    grid.SetReadOnly(row, col, False)

   390

                else:

   391

                    grid.SetReadOnly(row, col, True)

   392

   393

                grid.SetCellEditor(row, col, editor)

   394

                grid.SetCellRenderer(row, col, renderer)

   395

   396

            self.ResizeRow(grid, row)

   397

   398

   399

class ProcessVariableDropTarget(wx.TextDropTarget):

   400

   401

    def __init__(self, parent):

   402

        wx.TextDropTarget.__init__(self)

   403

        self.ParentWindow = parent

   404

   405

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

   406

        self.ParentWindow.Select()

   407

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

   408

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

   409

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

   410

        message = None

   411

        try:

   412

            values = eval(data)

   413

        except Exception:

   414

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

   415

            values = None

   416

        if not isinstance(values, tuple):

   417

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

   418

            values = None

   419

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

   420

            location = None

   421

            if values[1] == "location":

   422

                result = LOCATION_MODEL.match(values[0])

   423

                if result is not None:

   424

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

   425

                master_location = self.ParentWindow.GetMasterLocation()

   426

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

   427

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

   428

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

   429

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

   430

                    if col == 2:

   431

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

   432

                    else:

   433

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

   434

                    if other_values != "":

   435

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

   436

                    else:

   437

                        other_type = None

   438

                    if other_type is None or var_type == other_type:

   439

                        if col == 2:

   440

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

   441

                        else:

   442

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

   443

                        self.ParentWindow.SaveProcessVariables()

   444

                        self.ParentWindow.RefreshProcessVariables()

   445

                    else:

   446

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

   447

                else:

   448

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

   449

   450

        if message is not None:

   451

            wx.CallAfter(self.ShowMessage, message)

   452

            return False

   453

        return True

   454

   455

    def ShowMessage(self, message):

   456

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

   457

        message.ShowModal()

   458

        message.Destroy()

   459

   460

   461

def GetStartupCommandsTableColnames():

   462

    _ = NoTranslate

   463

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

   464

   465

   466

class StartupCommandDropTarget(wx.TextDropTarget):

   467

   468

    def __init__(self, parent):

   469

        wx.TextDropTarget.__init__(self)

   470

        self.ParentWindow = parent

   471

   472

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

   473

        self.ParentWindow.Select()

   474

        message = None

   475

        try:

   476

            values = eval(data)

   477

        except Exception:

   478

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

   479

            values = None

   480

        if not isinstance(values, tuple):

   481

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