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

    13

    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] = list(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 = list(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