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

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

    34

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

    35

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

    36

    else:

    37

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

    38

    39

def GetVariablesTableColnames(position=False):

    40

    _ = lambda x : x

    41

    colname = ["#"]

    42

    if position:

    43

        colname.append(_("Position"))

    44

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

    45

    46

ACCESS_TYPES = {

    47

    'ro': 'R',

    48

    'wo': 'W',

    49

    'rw': 'R/W'}

    50

    51

def GetAccessValue(access, pdo_mapping):

    52

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

    53

    if pdo_mapping != "":

    54

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

    55

    return value

    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("(?:%[IQM](?:[XBWLD]?([0-9]+(?:\.[0-9]+)*)))$")

    68

    69

class NodeVariablesSizer(wx.FlexGridSizer):

    70

    71

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

    72

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

    73

        self.AddGrowableCol(0)

    74

        self.AddGrowableRow(1)

    75

    76

        self.Controler = controler

    77

        self.PositionColumn = position_column

    78

    79

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

    80

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

    81

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

    82

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

    83

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

    84

    85

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

    86

                style=wx.TR_DEFAULT_STYLE |

    87

                      wx.TR_ROW_LINES |

    88

                      wx.TR_COLUMN_LINES |

    89

                      wx.TR_HIDE_ROOT |

    90

                      wx.TR_FULL_ROW_HIGHLIGHT)

    91

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

    92

            self.OnVariablesGridLeftClick)

    93

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

    94

    95

        self.Filters = []

    96

        for desc, value in VARIABLES_FILTERS:

    97

            self.VariablesFilter.Append(desc)

    98

            self.Filters.append(value)

    99

   100

        self.VariablesFilter.SetSelection(0)

   101

        self.CurrentFilter = self.Filters[0]

   102

        self.VariablesFilterFirstCharacter = True

   103

   104

        if position_column:

   105

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

   106

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

   107

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

   108

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

   109

                                                   wx.ALIGN_LEFT]):

   110

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

   111

            self.VariablesGrid.SetMainColumn(2)

   112

        else:

   113

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

   114

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

   115

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

   116

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

   117

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

   118

            self.VariablesGrid.SetMainColumn(1)

   119

   120

    def RefreshView(self):

   121

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

   122

        self.RefreshVariablesGrid(entries)

   123

   124

    def RefreshVariablesGrid(self, entries):

   125

        root = self.VariablesGrid.GetRootItem()

   126

        if not root.IsOk():

   127

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

   128

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

   129

        self.VariablesGrid.Expand(root)

   130

   131

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

   132

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

   133

   134

        no_more_items = not item.IsOk()

   135

        for entry in entries:

   136

            idx += 1

   137

            if no_more_items:

   138

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

   139

            for col, colname in enumerate(colnames):

   140

                if col == 0:

   141

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

   142

                else:

   143

                    value = entry.get(colname, "")

   144

                    if colname == "Access":

   145

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

   146

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

   147

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

   148

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

   149

            else:

   150

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

   151

            self.VariablesGrid.SetItemPyData(item, entry)

   152

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

   153

            if not no_more_items:

   154

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

   155

                no_more_items = not item.IsOk()

   156

   157

        if not no_more_items:

   158

            to_delete = []

   159

            while item.IsOk():

   160

                to_delete.append(item)

   161

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

   162

            for item in to_delete:

   163

                self.VariablesGrid.Delete(item)

   164

   165

        return idx

   166

   167

    def OnVariablesFilterChanged(self, event):

   168

        filter = self.VariablesFilter.GetSelection()

   169

        if filter != -1:

   170

            self.CurrentFilter = self.Filters[filter]

   171

            self.RefreshView()

   172

        else:

   173

            try:

   174

                value = self.VariablesFilter.GetValue()

   175

                if value == "":

   176

                    self.CurrentFilter = self.Filters[0]

   177

                    self.VariablesFilter.SetSelection(0)

   178

                else:

   179

                    result = ETHERCAT_INDEX_MODEL.match(value)

   180

                    if result is not None:

   181

                        value = result.group(1)

   182

                    index = int(value, 16)

   183

                    self.CurrentFilter = (index, index)

   184

                    self.VariablesFilter.SetValue(VARIABLE_INDEX_FILTER_FORMAT % index)

   185

                self.RefreshView()

   186

            except:

   187

                if self.CurrentFilter in self.Filters:

   188

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

   189

                else:

   190

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

   191

        self.VariablesFilterFirstCharacter = True

   192

        event.Skip()

   193

   194

    def OnVariablesFilterKeyDown(self, event):

   195

        if self.VariablesFilterFirstCharacter:

   196

            keycode = event.GetKeyCode()

   197

            if keycode not in [wx.WXK_RETURN, 

   198

                               wx.WXK_NUMPAD_ENTER]:

   199

                self.VariablesFilterFirstCharacter = False

   200

                if keycode not in NAVIGATION_KEYS:

   201

                    self.VariablesFilter.SetValue("")

   202

            if keycode not in [wx.WXK_DELETE, 

   203

                               wx.WXK_NUMPAD_DELETE, 

   204

                               wx.WXK_BACK]:

   205

                event.Skip()

   206

        else:

   207

            event.Skip()

   208

   209

    def OnVariablesGridLeftClick(self, event):

   210

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

   211

        if item.IsOk():

   212

            entry = self.VariablesGrid.GetItemPyData(item)

   213

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

   214

            data_size = self.Controler.GetSizeOfType(data_type)

   215

   216

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

   217

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

   218

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

   219

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

   220

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

   221

                location = self.Controler.GetCurrentLocation()

   222

                if self.PositionColumn:

   223

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

   224

                    location += (slave_pos,)

   225

                    node_name = self.Controler.GetSlaveName(slave_pos)

   226

                else:

   227

                    node_name = self.Controler.CTNName()

   228

   229

                if pdo_mapping != "":

   230

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

   231

                    if pdo_mapping == "T":

   232

                        dir = "%I"

   233

                    else:

   234

                        dir = "%Q"

   235

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

   236

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

   237

   238

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

   239

                    dragSource = wx.DropSource(self.VariablesGrid)

   240

                    dragSource.SetData(data)

   241

                    dragSource.DoDragDrop()

   242

                    return

   243

   244

                elif self.PositionColumn:

   245

                    location = self.Controler.GetCurrentLocation() +\

   246

                               (slave_pos, entry_index, entry_subindex)

   247

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

   248

                    dragSource = wx.DropSource(self.VariablesGrid)

   249

                    dragSource.SetData(data)

   250

                    dragSource.DoDragDrop()

   251

                    return

   252

   253

        event.Skip()

   254

   255

class NodeEditor(ConfTreeNodeEditor):

   256

   257

    CONFNODEEDITOR_TABS = [

   258

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

   259

        # Add Notebook Tab for EtherCAT Management Treebook

   260

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

   261

        ]

   262

   263

    def _create_EthercatNodeEditor(self, prnt):

   264

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

   265

   266

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

   267

        main_sizer.AddGrowableCol(0)

   268

        main_sizer.AddGrowableRow(1)

   269

   270

        variables_label = wx.StaticText(self.EthercatNodeEditor,

   271

              label=_('Variable entries:'))

   272

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

   273

   274

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

   275

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

   276

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

   277

   278

        self.EthercatNodeEditor.SetSizer(main_sizer)

   279

   280

        return self.EthercatNodeEditor

   281

   282

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

   283

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

   284

   285

        # add Contoler for use EthercatSlave.py Method

   286

        self.Controler = controler

   287

   288

    def GetBufferState(self):

   289

        return False, False

   290

   291

    def RefreshView(self):

   292

        ConfTreeNodeEditor.RefreshView(self)

   293

   294

        self.NodeVariables.RefreshView()

   295

   296

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

   297

    def _create_EtherCATManagementEditor(self, prnt):

   298

        self.EtherCATManagementEditor = wx.ScrolledWindow(prnt,

   299

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

   300

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

   301

   302

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

   303

        self.EtherCATManagermentEditor_Main_Sizer.AddGrowableCol(0)

   304

        self.EtherCATManagermentEditor_Main_Sizer.AddGrowableRow(0)

   305

   306

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

   307

   308

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

   309

   310

        self.EtherCATManagementEditor.SetSizer(self.EtherCATManagermentEditor_Main_Sizer)

   311

        return self.EtherCATManagementEditor

   312

   313

    def OnResize(self, event):

   314

        self.EtherCATManagementEditor.GetBestSize()

   315

        xstart, ystart = self.EtherCATManagementEditor.GetViewStart()

   316

        window_size = self.EtherCATManagementEditor.GetClientSize()

   317

        maxx, maxy = self.EtherCATManagementEditor.GetMinSize()

   318

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

   319

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

   320

        self.EtherCATManagementEditor.Scroll(posx, posy)

   321

        self.EtherCATManagementEditor.SetScrollbars(SCROLLBAR_UNIT, SCROLLBAR_UNIT, 

   322

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

   323

        event.Skip()

   324

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

   325

   326

CIA402NodeEditor = NodeEditor

   327

   328

   329

def GetProcessVariablesTableColnames():

   330

    _ = lambda x : x

   331

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

   332

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

   333

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

   334

            _("Description")]

   335

   336

class ProcessVariablesTable(CustomTable):

   337

   338

    def GetValue(self, row, col):

   339

        if row < self.GetNumberRows():

   340

            if col == 0:

   341

                return row + 1

   342

            colname = self.GetColLabelValue(col, False)

   343

            if colname.startswith("Read from"):

   344

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

   345

                if value == "":

   346

                    return value

   347

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

   348

            elif colname.startswith("Write to"):

   349

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

   350

                if value == "":

   351

                    return value

   352

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

   353

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

   354

   355

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

   356

        if col < len(self.colnames):

   357

            colname = self.GetColLabelValue(col, False)

   358

            if colname.startswith("Read from"):

   359

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

   360

            elif colname.startswith("Write to"):

   361

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

   362

            else:

   363

                self.data[row][colname] = value

   364

   365

    def _updateColAttrs(self, grid):

   366

        """

   367

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

   368

        appropriate renderer given the column name.

   369

   370

        Otherwise default to the default renderer.

   371

        """

   372

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

   373

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

   374

                editor = None

   375

                renderer = None

   376

                colname = self.GetColLabelValue(col, False)

   377

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

   378

                    editor = wx.grid.GridCellTextEditor()

   379

                    renderer = wx.grid.GridCellStringRenderer()

   380

                    grid.SetReadOnly(row, col, False)

   381

                else:

   382

                    grid.SetReadOnly(row, col, True)

   383

   384

                grid.SetCellEditor(row, col, editor)

   385

                grid.SetCellRenderer(row, col, renderer)

   386

   387

            self.ResizeRow(grid, row)

   388

   389

class ProcessVariableDropTarget(wx.TextDropTarget):

   390

   391

    def __init__(self, parent):

   392

        wx.TextDropTarget.__init__(self)

   393

        self.ParentWindow = parent

   394

   395

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

   396

        self.ParentWindow.Select()

   397

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

   398

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

   399

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

   400

        message = None

   401

        try:

   402

            values = eval(data)

   403

        except:

   404

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

   405

            values = None

   406

        if not isinstance(values, TupleType):

   407

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

   408

            values = None

   409

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

   410

            location = None

   411

            if values[1] == "location":

   412

                result = LOCATION_MODEL.match(values[0])

   413

                if result is not None:

   414

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

   415

                master_location = self.ParentWindow.GetMasterLocation()

   416

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

   417

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

   418

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

   419

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

   420

                    if col == 2:

   421

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

   422

                    else:

   423

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

   424

                    if other_values != "":

   425

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

   426

                    else:

   427

                        other_type = None

   428

                    if other_type is None or var_type == other_type:

   429

                        if col == 2:

   430

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

   431

                        else:

   432

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

   433

                        self.ParentWindow.SaveProcessVariables()

   434

                        self.ParentWindow.RefreshProcessVariables()

   435

                    else:

   436

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

   437

                else:

   438

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

   439

   440

        if message is not None:

   441

            wx.CallAfter(self.ShowMessage, message)

   442

   443

    def ShowMessage(self, message):

   444

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

   445

        message.ShowModal()

   446

        message.Destroy()

   447

   448

def GetStartupCommandsTableColnames():

   449

    _ = lambda x : x

   450

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

   451

   452

class StartupCommandDropTarget(wx.TextDropTarget):

   453

   454

    def __init__(self, parent):

   455

        wx.TextDropTarget.__init__(self)

   456

        self.ParentWindow = parent

   457

   458

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

   459

        self.ParentWindow.Select()

   460

        message = None

   461

        try:

   462

            values = eval(data)

   463

        except:

   464

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

   465

            values = None

   466

        if not isinstance(values, TupleType):

   467

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

   468

            values = None

   469

        if values is not None:

   470

            location = None

   471

            if values[1] == "location":

   472

                result = LOCATION_MODEL.match(values[0])

   473

                if result is not None and len(values) > 5:

   474

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

   475

                    access = values[5]

   476

            elif values[1] == "variable":

   477

                location = values[0]

   478

                access = values[2]

   479

            if location is not None:

   480

                master_location = self.ParentWindow.GetMasterLocation()

   481

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

   482

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

   483

                    if access in ["wo", "rw"]:

   484

                        self.ParentWindow.AddStartupCommand(*location[len(master_location):])

   485

                    else:

   486

                        message = _("Entry can't be write through SDO")

   487

                else:

   488

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

   489

   490