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

                    # add jblee

   145

                    if value is None:

   146

                        value = ""

   147

                    if colname == "Access":

   148

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

   149

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

   150

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

   151

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

   152

            else:

   153

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

   154

            self.VariablesGrid.SetItemPyData(item, entry)

   155

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

   156

            if not no_more_items:

   157

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

   158

                no_more_items = not item.IsOk()

   159

   160

        if not no_more_items:

   161

            to_delete = []

   162

            while item.IsOk():

   163

                to_delete.append(item)

   164

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

   165

            for item in to_delete:

   166

                self.VariablesGrid.Delete(item)

   167

   168

        return idx

   169

   170

    def OnVariablesFilterChanged(self, event):

   171

        filter = self.VariablesFilter.GetSelection()

   172

        if filter != -1:

   173

            self.CurrentFilter = self.Filters[filter]

   174

            self.RefreshView()

   175

        else:

   176

            try:

   177

                value = self.VariablesFilter.GetValue()

   178

                if value == "":

   179

                    self.CurrentFilter = self.Filters[0]

   180

                    self.VariablesFilter.SetSelection(0)

   181

                else:

   182

                    result = ETHERCAT_INDEX_MODEL.match(value)

   183

                    if result is not None:

   184

                        value = result.group(1)

   185

                    index = int(value, 16)

   186

                    self.CurrentFilter = (index, index)

   187

                    self.VariablesFilter.SetValue(VARIABLE_INDEX_FILTER_FORMAT % index)

   188

                self.RefreshView()

   189

            except:

   190

                if self.CurrentFilter in self.Filters:

   191

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

   192

                else:

   193

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

   194

        self.VariablesFilterFirstCharacter = True

   195

        event.Skip()

   196

   197

    def OnVariablesFilterKeyDown(self, event):

   198

        if self.VariablesFilterFirstCharacter:

   199

            keycode = event.GetKeyCode()

   200

            if keycode not in [wx.WXK_RETURN, 

   201

                               wx.WXK_NUMPAD_ENTER]:

   202

                self.VariablesFilterFirstCharacter = False

   203

                if keycode not in NAVIGATION_KEYS:

   204

                    self.VariablesFilter.SetValue("")

   205

            if keycode not in [wx.WXK_DELETE, 

   206

                               wx.WXK_NUMPAD_DELETE, 

   207

                               wx.WXK_BACK]:

   208

                event.Skip()

   209

        else:

   210

            event.Skip()

   211

   212

    def OnVariablesGridLeftClick(self, event):

   213

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

   214

        if item.IsOk():

   215

            entry = self.VariablesGrid.GetItemPyData(item)

   216

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

   217

            data_size = self.Controler.GetSizeOfType(data_type)

   218

   219

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

   220

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

   221

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

   222

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

   223

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

   224

                location = self.Controler.GetCurrentLocation()

   225

                if self.PositionColumn:

   226

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

   227

                    location += (slave_pos,)

   228

                    node_name = self.Controler.GetSlaveName(slave_pos)

   229

                else:

   230

                    node_name = self.Controler.CTNName()

   231

   232

                if pdo_mapping != "":

   233

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

   234

                    if pdo_mapping == "T":

   235

                        dir = "%I"

   236

                    else:

   237

                        dir = "%Q"

   238

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

   239

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

   240

   241

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

   242

                    dragSource = wx.DropSource(self.VariablesGrid)

   243

                    dragSource.SetData(data)

   244

                    dragSource.DoDragDrop()

   245

                    return

   246

   247

                elif self.PositionColumn:

   248

                    location = self.Controler.GetCurrentLocation() +\

   249

                               (slave_pos, entry_index, entry_subindex)

   250

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

   251

                    dragSource = wx.DropSource(self.VariablesGrid)

   252

                    dragSource.SetData(data)

   253

                    dragSource.DoDragDrop()

   254

                    return

   255

   256

        event.Skip()

   257

   258

class NodeEditor(ConfTreeNodeEditor):

   259

   260

    CONFNODEEDITOR_TABS = [

   261

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

   262

        # Add Notebook Tab for EtherCAT Management Treebook

   263

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

   264

        ]

   265

   266

    def _create_EthercatNodeEditor(self, prnt):

   267

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

   268

   269

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

   270

        main_sizer.AddGrowableCol(0)

   271

        main_sizer.AddGrowableRow(1)

   272

   273

        variables_label = wx.StaticText(self.EthercatNodeEditor,

   274

              label=_('Variable entries:'))

   275

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

   276

   277

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

   278

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

   279

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

   280

   281

        self.EthercatNodeEditor.SetSizer(main_sizer)

   282

   283

        return self.EthercatNodeEditor

   284

   285

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

   286

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

   287

   288

        # add Contoler for use EthercatSlave.py Method

   289

        self.Controler = controler

   290

   291

    def GetBufferState(self):

   292

        return False, False

   293

   294

    def RefreshView(self):

   295

        ConfTreeNodeEditor.RefreshView(self)

   296

   297

        self.NodeVariables.RefreshView()

   298

   299

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

   300

    def _create_EtherCATManagementEditor(self, prnt):

   301

        self.EtherCATManagementEditor = wx.ScrolledWindow(prnt,

   302

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

   303

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

   304

   305

        #self.Bind(wx.EVT_NOTEBOOK_PAGE_CHANGED, self.OnPageChanged)

   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

        #except:

   313

        #try:

   314

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

   315

        #except:

   316

        #    self.EtherCATManagementTreebook = wx.Treebook(self.EtherCATManagementEditor, -1)

   317

        #    self.Controler.CommonMethod.CreateErrorDialog(\

   318

        #        "failed to open EtherCAT Management.\nplease remove the slave and try it again.")

   319

   320

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

   321

   322

        self.EtherCATManagementEditor.SetSizer(self.EtherCATManagermentEditor_Main_Sizer)

   323

        return self.EtherCATManagementEditor

   324

   325

    """

   326

    def OnPageChanged(self, event):

   327

        try:

   328

            print "OnPageChanged"

   329

            self.EtherCATManagementTreebook.SDOPanel.SDOMonitorThread.Stop();

   330

        except:

   331

            pass

   332

    """

   333

   334

    def OnResize(self, event):

   335

        self.EtherCATManagementEditor.GetBestSize()

   336

        xstart, ystart = self.EtherCATManagementEditor.GetViewStart()

   337

        window_size = self.EtherCATManagementEditor.GetClientSize()

   338

        maxx, maxy = self.EtherCATManagementEditor.GetMinSize()

   339

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

   340

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

   341

        self.EtherCATManagementEditor.Scroll(posx, posy)

   342

        self.EtherCATManagementEditor.SetScrollbars(SCROLLBAR_UNIT, SCROLLBAR_UNIT, 

   343

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

   344

        event.Skip()

   345

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

   346

   347

CIA402NodeEditor = NodeEditor

   348

   349

   350

def GetProcessVariablesTableColnames():

   351

    _ = lambda x : x

   352

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

   353

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

   354

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

   355

            _("Description")]

   356

   357

class ProcessVariablesTable(CustomTable):

   358

   359

    def GetValue(self, row, col):

   360

        if row < self.GetNumberRows():

   361

            if col == 0:

   362

                return row + 1

   363

            colname = self.GetColLabelValue(col, False)

   364

            if colname.startswith("Read from"):

   365

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

   366

                if value == "":

   367

                    return value

   368

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

   369

            elif colname.startswith("Write to"):

   370

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

   371

                if value == "":

   372

                    return value

   373

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

   374

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

   375

   376

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

   377

        if col < len(self.colnames):

   378

            colname = self.GetColLabelValue(col, False)

   379

            if colname.startswith("Read from"):

   380

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

   381

            elif colname.startswith("Write to"):

   382

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

   383

            else:

   384

                self.data[row][colname] = value

   385

   386

    def _updateColAttrs(self, grid):

   387

        """

   388

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

   389

        appropriate renderer given the column name.

   390

   391

        Otherwise default to the default renderer.

   392

        """

   393

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

   394

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

   395

                editor = None

   396

                renderer = None

   397

                colname = self.GetColLabelValue(col, False)

   398

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

   399

                    editor = wx.grid.GridCellTextEditor()

   400

                    renderer = wx.grid.GridCellStringRenderer()

   401

                    grid.SetReadOnly(row, col, False)

   402

                else:

   403

                    grid.SetReadOnly(row, col, True)

   404

   405

                grid.SetCellEditor(row, col, editor)

   406

                grid.SetCellRenderer(row, col, renderer)

   407

   408

            self.ResizeRow(grid, row)

   409

   410

class ProcessVariableDropTarget(wx.TextDropTarget):

   411

   412

    def __init__(self, parent):

   413

        wx.TextDropTarget.__init__(self)

   414

        self.ParentWindow = parent

   415

   416

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

   417

        self.ParentWindow.Select()

   418

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

   419

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

   420

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

   421

        message = None

   422

        try:

   423

            values = eval(data)

   424

        except:

   425

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

   426

            values = None

   427

        if not isinstance(values, TupleType):

   428

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

   429

            values = None

   430

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

   431

            location = None

   432

            if values[1] == "location":

   433

                result = LOCATION_MODEL.match(values[0])

   434

                if result is not None:

   435

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

   436

                master_location = self.ParentWindow.GetMasterLocation()

   437

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

   438

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

   439

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

   440

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

   441

                    if col == 2:

   442

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

   443

                    else:

   444

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

   445

                    if other_values != "":

   446

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

   447

                    else:

   448

                        other_type = None

   449

                    if other_type is None or var_type == other_type:

   450

                        if col == 2:

   451

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

   452

                        else:

   453

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

   454

                        self.ParentWindow.SaveProcessVariables()

   455

                        self.ParentWindow.RefreshProcessVariables()

   456

                    else:

   457

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

   458

                else:

   459

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

   460

   461

        if message is not None:

   462

            wx.CallAfter(self.ShowMessage, message)

   463

   464

    def ShowMessage(self, message):

   465

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

   466

        message.ShowModal()

   467

        message.Destroy()

   468

   469

def GetStartupCommandsTableColnames():

   470

    _ = lambda x : x

   471

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

   472

   473

class StartupCommandDropTarget(wx.TextDropTarget):

   474

   475

    def __init__(self, parent):

   476

        wx.TextDropTarget.__init__(self)

   477

        self.ParentWindow = parent

   478

   479

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

   480

        self.ParentWindow.Select()

   481

        message = None

   482

        try:

   483

            values = eval(data)

   484

        except:

   485

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

   486

            values = None

   487

        if not isinstance(values, TupleType):

   488

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

   489

            values = None

   490