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

import os

    13

import re

    14

from types import TupleType

    15

    16

import wx

    17

import wx.grid

    18

import wx.gizmos

    19

import wx.lib.buttons

    20

    21

from plcopen.structures import IEC_KEYWORDS, TestIdentifier

    22

from controls import CustomGrid, CustomTable, FolderTree

    23

from editors.ConfTreeNodeEditor import ConfTreeNodeEditor, SCROLLBAR_UNIT

    24

from util.BitmapLibrary import GetBitmap

    25

from controls.CustomStyledTextCtrl import NAVIGATION_KEYS

    26

    27

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

    28

from EtherCATManagementEditor import EtherCATManagementTreebook, MasterStatePanelClass

    29

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

    30

    31

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

    32

    33

    34

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

    35

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

    36

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

    37

    else:

    38

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

    39

    40

    41

def GetVariablesTableColnames(position=False):

    42

    _ = lambda x : x

    43

    colname = ["#"]

    44

    if position:

    45

        colname.append(_("Position"))

    46

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

    47

    48

    49

ACCESS_TYPES = {

    50

    'ro': 'R',

    51

    'wo': 'W',

    52

    'rw': 'R/W'}

    53

    54

    55

def GetAccessValue(access, pdo_mapping):

    56

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

    57

    if pdo_mapping != "":

    58

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

    59

    return value

    60

    61

    62

VARIABLES_FILTERS = [

    63

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

    64

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

    65

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

    66

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

    67

    68

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

    69

    70

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

    71

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

    72

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

    73

    74

    75

class NodeVariablesSizer(wx.FlexGridSizer):

    76

    77

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

    78

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

    79

        self.AddGrowableCol(0)

    80

        self.AddGrowableRow(1)

    81

    82

        self.Controler = controler

    83

        self.PositionColumn = position_column

    84

    85

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

    86

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

    87

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

    88

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

    89

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

    90

    91

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

    92

                style=wx.TR_DEFAULT_STYLE |

    93

                      wx.TR_ROW_LINES |

    94

                      wx.TR_COLUMN_LINES |

    95

                      wx.TR_HIDE_ROOT |

    96

                      wx.TR_FULL_ROW_HIGHLIGHT)

    97

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

    98

            self.OnVariablesGridLeftClick)

    99

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

   100

   101

        self.Filters = []

   102

        for desc, value in VARIABLES_FILTERS:

   103

            self.VariablesFilter.Append(desc)

   104

            self.Filters.append(value)

   105

   106

        self.VariablesFilter.SetSelection(0)

   107

        self.CurrentFilter = self.Filters[0]

   108

        self.VariablesFilterFirstCharacter = True

   109

   110

        if position_column:

   111

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

   112

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

   113

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

   114

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

   115

                                                   wx.ALIGN_LEFT]):

   116

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

   117

            self.VariablesGrid.SetMainColumn(2)

   118

        else:

   119

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

   120

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

   121

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

   122

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

   123

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

   124

            self.VariablesGrid.SetMainColumn(1)

   125

   126

    def RefreshView(self):

   127

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

   128

        self.RefreshVariablesGrid(entries)

   129

   130

    def RefreshVariablesGrid(self, entries):

   131

        root = self.VariablesGrid.GetRootItem()

   132

        if not root.IsOk():

   133

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

   134

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

   135

        self.VariablesGrid.Expand(root)

   136

   137

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

   138

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

   139

   140

        no_more_items = not item.IsOk()

   141

        for entry in entries:

   142

            idx += 1

   143

            if no_more_items:

   144

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

   145

            for col, colname in enumerate(colnames):

   146

                if col == 0:

   147

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

   148

                else:

   149

                    value = entry.get(colname, "")

   150

                    if colname == "Access":

   151

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

   152

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

   153

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

   154

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

   155

            else:

   156

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

   157

            self.VariablesGrid.SetItemPyData(item, entry)

   158

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

   159

            if not no_more_items:

   160

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

   161

                no_more_items = not item.IsOk()

   162

   163

        if not no_more_items:

   164

            to_delete = []

   165

            while item.IsOk():

   166

                to_delete.append(item)

   167

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

   168

            for item in to_delete:

   169

                self.VariablesGrid.Delete(item)

   170

   171

        return idx

   172

   173

    def OnVariablesFilterChanged(self, event):

   174

        filter = self.VariablesFilter.GetSelection()

   175

        if filter != -1:

   176

            self.CurrentFilter = self.Filters[filter]

   177

            self.RefreshView()

   178

        else:

   179

            try:

   180

                value = self.VariablesFilter.GetValue()

   181

                if value == "":

   182

                    self.CurrentFilter = self.Filters[0]

   183

                    self.VariablesFilter.SetSelection(0)

   184

                else:

   185

                    result = ETHERCAT_INDEX_MODEL.match(value)

   186

                    if result is not None:

   187

                        value = result.group(1)

   188

                    index = int(value, 16)

   189

                    self.CurrentFilter = (index, index)

   190

                    self.VariablesFilter.SetValue(VARIABLE_INDEX_FILTER_FORMAT % index)

   191

                self.RefreshView()

   192

            except Exception:

   193

                if self.CurrentFilter in self.Filters:

   194

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

   195

                else:

   196

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

   197

        self.VariablesFilterFirstCharacter = True

   198

        event.Skip()

   199

   200

    def OnVariablesFilterKeyDown(self, event):

   201

        if self.VariablesFilterFirstCharacter:

   202

            keycode = event.GetKeyCode()

   203

            if keycode not in [wx.WXK_RETURN,

   204

                               wx.WXK_NUMPAD_ENTER]:

   205

                self.VariablesFilterFirstCharacter = False

   206

                if keycode not in NAVIGATION_KEYS:

   207

                    self.VariablesFilter.SetValue("")

   208

            if keycode not in [wx.WXK_DELETE,

   209

                               wx.WXK_NUMPAD_DELETE,

   210

                               wx.WXK_BACK]:

   211

                event.Skip()

   212

        else:

   213

            event.Skip()

   214

   215

    def OnVariablesGridLeftClick(self, event):

   216

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

   217

        if item.IsOk():

   218

            entry = self.VariablesGrid.GetItemPyData(item)

   219

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

   220

            data_size = self.Controler.GetSizeOfType(data_type)

   221

   222

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

   223

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

   224

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

   225

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

   226

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

   227

                location = self.Controler.GetCurrentLocation()

   228

                if self.PositionColumn:

   229

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

   230

                    location += (slave_pos,)

   231

                    node_name = self.Controler.GetSlaveName(slave_pos)

   232

                else:

   233

                    node_name = self.Controler.CTNName()

   234

   235

                if pdo_mapping != "":

   236

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

   237

                    if pdo_mapping == "T":

   238

                        dir = "%I"

   239

                    else:

   240

                        dir = "%Q"

   241

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

   242

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

   243

   244

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

   245

                    dragSource = wx.DropSource(self.VariablesGrid)

   246

                    dragSource.SetData(data)

   247

                    dragSource.DoDragDrop()

   248

                    return

   249

   250

                elif self.PositionColumn:

   251

                    location = self.Controler.GetCurrentLocation() +\

   252

                               (slave_pos, entry_index, entry_subindex)

   253

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

   254

                    dragSource = wx.DropSource(self.VariablesGrid)

   255

                    dragSource.SetData(data)

   256

                    dragSource.DoDragDrop()

   257

                    return

   258

   259

        event.Skip()

   260

   261

   262

class NodeEditor(ConfTreeNodeEditor):

   263

   264

    CONFNODEEDITOR_TABS = [

   265

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

   266

        # Add Notebook Tab for EtherCAT Management Treebook

   267

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

   268

        ]

   269

   270

    def _create_EthercatNodeEditor(self, prnt):

   271

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

   272

   273

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

   274

        main_sizer.AddGrowableCol(0)

   275

        main_sizer.AddGrowableRow(1)

   276

   277

        variables_label = wx.StaticText(self.EthercatNodeEditor,

   278

              label=_('Variable entries:'))

   279

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

   280

   281

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

   282

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

   283

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

   284

   285

        self.EthercatNodeEditor.SetSizer(main_sizer)

   286

   287

        return self.EthercatNodeEditor

   288

   289

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

   290

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

   291

   292

        # add Contoler for use EthercatSlave.py Method

   293

        self.Controler = controler

   294

   295

    def GetBufferState(self):

   296

        return False, False

   297

   298

    def RefreshView(self):

   299

        ConfTreeNodeEditor.RefreshView(self)

   300

   301

        self.NodeVariables.RefreshView()

   302

   303

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

   304

    def _create_EtherCATManagementEditor(self, prnt):

   305

        self.EtherCATManagementEditor = wx.ScrolledWindow(prnt,

   306

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

   307

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

   308

   309

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

   310

        self.EtherCATManagermentEditor_Main_Sizer.AddGrowableCol(0)

   311

        self.EtherCATManagermentEditor_Main_Sizer.AddGrowableRow(0)

   312

   313

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

   314

   315

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

   316

   317

        self.EtherCATManagementEditor.SetSizer(self.EtherCATManagermentEditor_Main_Sizer)

   318

        return self.EtherCATManagementEditor

   319

   320

    def OnResize(self, event):

   321

        self.EtherCATManagementEditor.GetBestSize()

   322

        xstart, ystart = self.EtherCATManagementEditor.GetViewStart()

   323

        window_size = self.EtherCATManagementEditor.GetClientSize()

   324

        maxx, maxy = self.EtherCATManagementEditor.GetMinSize()

   325

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

   326

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

   327

        self.EtherCATManagementEditor.Scroll(posx, posy)

   328

        self.EtherCATManagementEditor.SetScrollbars(SCROLLBAR_UNIT, SCROLLBAR_UNIT,

   329

                maxx / SCROLLBAR_UNIT, maxy / SCROLLBAR_UNIT, posx, posy)

   330

        event.Skip()

   331

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

   332

   333

   334

CIA402NodeEditor = NodeEditor

   335

   336

   337

def GetProcessVariablesTableColnames():

   338

    _ = lambda x : x

   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, TupleType):

   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

   453

    def ShowMessage(self, message):

   454

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

   455

        message.ShowModal()

   456

        message.Destroy()

   457

   458

   459

def GetStartupCommandsTableColnames():

   460

    _ = lambda x : x

   461

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

   462

   463

   464

class StartupCommandDropTarget(wx.TextDropTarget):

   465

   466

    def __init__(self, parent):

   467

        wx.TextDropTarget.__init__(self)

   468

        self.ParentWindow = parent

   469

   470

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

   471

        self.ParentWindow.Select()

   472

        message = None

   473

        try:

   474

            values = eval(data)

   475

        except Exception:

   476

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

   477

            values = None

   478

        if not isinstance(values, TupleType):

   479

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

   480

            values = None

   481

        if values is not None:

   482

            location = None

   483

            if values[1] == "location":