1

#!/usr/bin/env python

     2

# -*- coding: utf-8 -*-

     3

     4

#This file is part of Beremiz, a Integrated Development Environment for

     5

#programming IEC 61131-3 automates supporting EtherCAT. 

     6

#

     7

#Copyright (C) 2013: Real-Time & Embedded Systems (RTES) Lab., University of Seoul

     8

#

     9

#See COPYING file for copyrights details.

    10

#

    11

#This library is free software; you can redistribute it and/or

    12

#modify it under the terms of the GNU General Public

    13

#License as published by the Free Software Foundation; either

    14

#version 2.1 of the License, or (at your option) any later version.

    15

#

    16

#This library is distributed in the hope that it will be useful,

    17

#but WITHOUT ANY WARRANTY; without even the implied warranty of

    18

#MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU

    19

#General Public License for more details.

    20

#

    21

#You should have received a copy of the GNU General Public

    22

#License along with this library; if not, write to the Free Software

    23

#Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

    24

    25

    26

import os

    27

    28

import wx

    29

import wx.grid

    30

import wx.gizmos

    31

import wx.lib.buttons

    32

    33

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

    34

from controls import CustomGrid, CustomTable

    35

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

    36

    37

# ------------ for SDO Management --------------------

    38

import string

    39

import wx.grid as gridlib

    40

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

    41

    42

# ------------ for register management --------------- 

    43

from xml.dom import minidom

    44

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

    45

    46

# ----------------------------- For Sync Manager Table -----------------------------------

    47

def GetSyncManagersTableColnames():

    48

    """

    49

    Returns column names of SyncManager Table in Slave state panel.

    50

    """

    51

    _ = lambda x : x

    52

    return ["#", _("Name"), _("Start Address"), _("Default Size"), _("Control Byte"), _("Enable")]

    53

    54

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

    55

#                    Sync Managers Table

    56

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

    57

class SyncManagersTable(CustomTable):

    58

    def GetValue(self, row, col): 

    59

        if row < self.GetNumberRows():

    60

            if col == 0:

    61

                return row

    62

            return self.data[row].get(self.GetColLabelValue(col, False), "")

    63

    64

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

    65

#                    EtherCAT Management Treebook

    66

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

    67

class EtherCATManagementTreebook(wx.Treebook):

    68

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

    69

        """

    70

        Constructor

    71

        @param parent: Reference to the parent wx.ScrolledWindow object

    72

        @param controler: _EthercatSlaveCTN class in EthercatSlave.py

    73

        @param node_editor: Reference to Beremiz frame

    74

        """

    75

        wx.Treebook.__init__(self, parent, -1, size=wx.DefaultSize, style=wx.BK_DEFAULT)

    76

        self.parent = parent

    77

        self.Controler = controler

    78

        self.NodeEditor = node_editor

    79

    80

        self.EtherCATManagementClassObject = {}

    81

    82

        # fill EtherCAT Management Treebook

    83

        for pname, pclass, subs in [

    84

            ("Slave State",        SlaveStatePanelClass, []),

    85

            ("SDO Management",     SDOPanelClass, []),

    86

            ("PDO Monitoring",     PDOPanelClass, []),

    87

            ("ESC Management",     EEPROMAccessPanel, [        

    88

                    ("Smart View", SlaveSiiSmartView),

    89

                    ("Hex View", HexView)]),

    90

            ("Register Access",     RegisterAccessPanel, [])]:

    91

                self.AddPage(pclass(self, self.Controler), pname)

    92

                for spname, spclass in subs:

    93

                    self.AddSubPage(spclass(self, self.Controler), spname)

    94

    95

        self.Bind(wx.EVT_TREEBOOK_PAGE_CHANGED, self.OnPageChanged)

    96

        self.Bind(wx.EVT_TREEBOOK_PAGE_CHANGING, self.OnPageChanging)

    97

    98

    def OnPageChanged(self, event):

    99

        old = event.GetOldSelection()

   100

        new = event.GetSelection()

   101

        sel = event.GetSelection()

   102

        event.Skip()

   103

   104

    def OnPageChanging(self, event):

   105

        old = event.GetOldSelection()

   106

        new = event.GetSelection()

   107

        sel = event.GetSelection()

   108

        event.Skip()    

   109

   110

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

   111

#                    For SlaveState Panel

   112

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

   113

class SlaveStatePanelClass(wx.Panel):

   114

    def __init__(self, parent, controler):

   115

        """

   116

        Constructor

   117

        @param parent: Reference to the parent EtherCATManagementTreebook class

   118

        @param controler: _EthercatSlaveCTN class in EthercatSlave.py

   119

        """

   120

        wx.Panel.__init__(self, parent, -1, (0, 0), size=wx.DefaultSize, style = wx.SUNKEN_BORDER)

   121

        self.Controler = controler

   122

        self.parent = parent

   123

   124

        # initialize SlaveStatePanel UI dictionaries

   125

        self.StaticBoxDic = {}

   126

        self.StaticTextDic = {}

   127

        self.TextCtrlDic = {}

   128

        self.ButtonDic = {}

   129

   130

        # iniitalize BoxSizer and FlexGridSizer

   131

        self.SizerDic = {

   132

            "SlaveState_main_sizer" : wx.BoxSizer(wx.VERTICAL),

   133

            "SlaveState_inner_main_sizer" : wx.FlexGridSizer(cols=1, hgap=50, rows=3, vgap=10),

   134

            "SlaveInfosDetailsInnerSizer" : wx.FlexGridSizer(cols=4, hgap=10, rows=2, vgap=10),

   135

            "SyncManagerInnerSizer" : wx.FlexGridSizer(cols=1, hgap=5, rows=1, vgap=5),

   136

            "SlaveState_sizer" : wx.FlexGridSizer(cols=1, hgap=10, rows=2, vgap=10),

   137

            "SlaveState_up_sizer" : wx.FlexGridSizer(cols=4, hgap=10, rows=2, vgap=10),

   138

            "SlaveState_down_sizer" : wx.FlexGridSizer(cols=2, hgap=10, rows=1, vgap=10)}

   139

   140

        # initialize StaticBox and StaticBoxSizer

   141

        for box_name, box_label in [

   142

                ("SlaveInfosDetailsBox", "Slave Informations"),

   143

                ("SyncManagerBox", "Sync Manager"),

   144

                ("SlaveStateBox", "Slave State Transition && Monitoring")]:

   145

            self.StaticBoxDic[box_name] = wx.StaticBox(self, label=_(box_label))

   146

            self.SizerDic[box_name] = wx.StaticBoxSizer(self.StaticBoxDic[box_name])  

   147

   148

        for statictext_name, statictext_label, textctrl_name in [

   149

                ("VendorLabel", "Vendor:", "vendor"),

   150

                ("ProductcodeLabel", "Product code:", "product_code"),

   151

                ("RevisionnumberLabel", "Slave Count:", "revision_number"),

   152

                ("PhysicsLabel", "Physics:", "physics")]:

   153

            self.StaticTextDic[statictext_name] = wx.StaticText(self, label=_(statictext_label))

   154

            self.TextCtrlDic[textctrl_name] = wx.TextCtrl(self, size=wx.Size(130, 24), style=wx.TE_READONLY)

   155

            self.SizerDic["SlaveInfosDetailsInnerSizer"].AddMany([self.StaticTextDic[statictext_name], 

   156

                                                               self.TextCtrlDic[textctrl_name]])    

   157

   158

        self.SizerDic["SlaveInfosDetailsBox"].AddSizer(self.SizerDic["SlaveInfosDetailsInnerSizer"])

   159

   160

        self.SyncManagersGrid = CustomGrid(self, size=wx.Size(605,155), style=wx.VSCROLL)      

   161

   162

        self.SizerDic["SyncManagerInnerSizer"].Add(self.SyncManagersGrid)    

   163

        self.SizerDic["SyncManagerBox"].Add(self.SizerDic["SyncManagerInnerSizer"])

   164

   165

        for button_name, button_id, button_label, button_tooltipstring, event_method, sub_item in [

   166

                ("InitButton",   0, "INIT", "State Transition to \"Init\" State",     self.OnButtonClick, []),

   167

                ("PreOPButton",  1, "PREOP", "State Transition to \"PreOP\" State",   self.OnButtonClick, [

   168

                        ("TargetStateLabel", "Target State:" , "TargetState")]),

   169

                ("SafeOPButton", 2, "SAFEOP", "State Transition to \"SafeOP\" State", self.OnButtonClick, []),

   170

                ("OPButton",     3, "OP",  "State Transition to \"OP\" State",        self.OnButtonClick, [

   171

                        ("CurrentStateLabel", "Current State:", "CurrentState")])]:

   172

            self.ButtonDic[button_name] = wx.Button(self, id=button_id ,label=_(button_label))

   173

            self.ButtonDic[button_name].Bind(wx.EVT_BUTTON, event_method)

   174

            self.ButtonDic[button_name].SetToolTipString(button_tooltipstring)

   175

            self.SizerDic["SlaveState_up_sizer"].Add(self.ButtonDic[button_name])

   176

            for statictext_name, statictext_label, textctrl_name in sub_item :

   177

                self.StaticTextDic[statictext_name] = wx.StaticText(self, label=_(statictext_label))

   178

                self.TextCtrlDic[textctrl_name] = wx.TextCtrl(self, size=wx.DefaultSize, style=wx.TE_READONLY)

   179

                self.SizerDic["SlaveState_up_sizer"].AddMany([self.StaticTextDic[statictext_name], 

   180

                                                               self.TextCtrlDic[textctrl_name]])

   181

   182

        for button_name, button_label, button_tooltipstring, event_method in [

   183

                ("StartTimerButton", "Start State Monitoring", "Slave State Update Restart", self.StartTimer),

   184

                ("StopTimerButton", "Stop State Monitoring", "Slave State Update Stop", self.CurrentStateThreadStop)]:

   185

            self.ButtonDic[button_name] = wx.Button(self, label=_(button_label))

   186

            self.ButtonDic[button_name].Bind(wx.EVT_BUTTON, event_method)

   187

            self.ButtonDic[button_name].SetToolTipString(button_tooltipstring)

   188

            self.SizerDic["SlaveState_down_sizer"].Add(self.ButtonDic[button_name])   

   189

   190

        self.SizerDic["SlaveState_sizer"].AddMany([self.SizerDic["SlaveState_up_sizer"], 

   191

            self.SizerDic["SlaveState_down_sizer"]])

   192

   193

        self.SizerDic["SlaveStateBox"].Add(self.SizerDic["SlaveState_sizer"])

   194

   195

        self.SizerDic["SlaveState_inner_main_sizer"].AddMany([

   196

            self.SizerDic["SlaveInfosDetailsBox"], self.SizerDic["SyncManagerBox"],

   197

            self.SizerDic["SlaveStateBox"]])

   198

   199

        self.SizerDic["SlaveState_main_sizer"].Add(self.SizerDic["SlaveState_inner_main_sizer"])

   200

   201

        self.SetSizer(self.SizerDic["SlaveState_main_sizer"])

   202

   203

        # register a timer for periodic exectuion of slave state update (period: 1000 ms)

   204

        self.Bind(wx.EVT_TIMER, self.GetCurrentState)

   205

   206

        self.CreateSyncManagerTable()

   207

   208

        self.Centre()

   209

   210

    def CreateSyncManagerTable(self):

   211

        """

   212

        Create grid for "SyncManager"

   213

        """

   214

        # declare Table object 

   215

        self.SyncManagersTable = SyncManagersTable(self, [], GetSyncManagersTableColnames())

   216

        self.SyncManagersGrid.SetTable(self.SyncManagersTable)

   217

        # set grid alignment attr. (CENTER)

   218

        self.SyncManagersGridColAlignements = [wx.ALIGN_CENTRE, wx.ALIGN_CENTRE, wx.ALIGN_CENTRE, 

   219

                                               wx.ALIGN_CENTRE, wx.ALIGN_CENTRE, wx.ALIGN_CENTRE]

   220

        # set grid size

   221

        self.SyncManagersGridColSizes = [40, 150, 100, 100, 100, 100]

   222

        self.SyncManagersGrid.SetRowLabelSize(0)

   223

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

   224

            attr = wx.grid.GridCellAttr()

   225

            attr.SetAlignment(self.SyncManagersGridColAlignements[col], wx.ALIGN_CENTRE)

   226

            self.SyncManagersGrid.SetColAttr(col, attr)

   227

            self.SyncManagersGrid.SetColMinimalWidth(col, self.SyncManagersGridColSizes[col])

   228

            self.SyncManagersGrid.AutoSizeColumn(col, False) 

   229

   230

        self.RefreshSlaveInfos()

   231

   232

    def RefreshSlaveInfos(self):

   233

        """

   234

        Fill data in "Slave Information" and "SyncManager"

   235

        """

   236

        slave_infos = self.Controler.GetSlaveInfos()

   237

        sync_manager_section = ["vendor", "product_code", "revision_number", "physics"]

   238

        if slave_infos is not None:

   239

            # this method is same as "TextCtrl.SetValue" 

   240

            for textctrl_name in sync_manager_section:

   241

                self.TextCtrlDic[textctrl_name].SetValue(slave_infos[textctrl_name])

   242

            self.SyncManagersTable.SetData(slave_infos["sync_managers"])

   243

            self.SyncManagersTable.ResetView(self.SyncManagersGrid)

   244

        else:

   245

            for textctrl_name in sync_manager_section:

   246

                self.TextCtrlDic[textctrl_name].SetValue("")

   247

            self.SyncManagersTable.SetData([])

   248

            self.SyncManagersTable.ResetView(self.SyncManagersGrid)

   249

   250

    def OnButtonClick(self, event):

   251

        """

   252

        Event handler for slave state transition button click (Init, PreOP, SafeOP, OP button)

   253

        @param event : wx.EVT_BUTTON object

   254

        """

   255

        check_connect_flag = self.Controler.CommonMethod.CheckConnect(False)

   256

        if check_connect_flag :

   257

            state_dic = ["INIT", "PREOP", "SAFEOP", "OP"]

   258

   259

            # If target state is one of {INIT, PREOP, SAFEOP}, request slave state transition immediately.

   260

            if event.GetId() < 3 :

   261

                self.Controler.CommonMethod.RequestSlaveState(state_dic[event.GetId()])

   262

                self.TextCtrlDic["TargetState"].SetValue(state_dic[event.GetId()])

   263

   264

            # If target state is OP, first check "PLC status".

   265

            #  (1) If current PLC status is "Started", then request slave state transition

   266

            #  (2) Otherwise, show error message and return

   267

            else :

   268

                status, count = self.Controler.GetCTRoot()._connector.GetPLCstatus()

   269

                if status == "Started" :

   270

                    self.Controler.CommonMethod.RequestSlaveState("OP")

   271

                    self.TextCtrlDic["TargetState"].SetValue("OP")

   272

                else :

   273

                    self.Controler.CommonMethod.CreateErrorDialog("PLC is Not Started")  

   274

   275

    def GetCurrentState(self, event):

   276

        """

   277

        Timer event handler for periodic slave state monitoring (Default period: 1 sec = 1000 msec).

   278

        @param event : wx.TIMER object

   279

        """

   280

        check_connect_flag = self.Controler.CommonMethod.CheckConnect(True)

   281

        if check_connect_flag:

   282

            returnVal = self.Controler.CommonMethod.GetSlaveStateFromSlave()

   283

            line = returnVal.split("\n")

   284

            try :

   285

                self.SetCurrentState(line[self.Controler.GetSlavePos()])

   286

            except :

   287

                pass  

   288

   289

    def SetCurrentState(self, line):

   290

        """

   291

        Show current slave state using the executiob result of "ethercat slaves" command.

   292

        @param line : result of "ethercat slaves" command

   293

        """

   294

        state_array = ["INIT", "PREOP", "SAFEOP", "OP"]

   295

        try :

   296

            # parse the execution result of  "ethercat slaves" command

   297

            # Result example : 0  0:0  PREOP  +  EL9800 (V4.30) (PIC24, SPI, ET1100)

   298

            token = line.split("  ")

   299

            if token[2] in state_array:

   300

                self.TextCtrlDic["CurrentState"].SetValue(token[2])           

   301

        except :

   302

            pass     

   303

   304

    def StartTimer(self, event):

   305

        """

   306

        Event handler for "Start State Monitoring" button.

   307

          - start slave state monitoring thread

   308

        @param event : wx.EVT_BUTTON object

   309

        """

   310

        self.SlaveStateThread = wx.Timer(self)

   311

        # set timer period (1000 ms)

   312

        self.SlaveStateThread.Start(1000)

   313

   314

    def CurrentStateThreadStop(self, event):

   315

        """

   316

        Event handler for "Stop State Monitoring" button.

   317

          - stop slave state monitoring thread

   318

        @param event : wx.EVT_BUTTON object

   319

        """

   320

        try:

   321

            self.SlaveStateThread.Stop()

   322

        except:

   323

            pass

   324

   325

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

   326

#                    For SDO Management Panel

   327

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

   328

class SDOPanelClass(wx.Panel):

   329

    def __init__(self, parent, controler):

   330

        """

   331

        Constructor

   332

        @param parent: Reference to the parent EtherCATManagementTreebook class

   333

        @param controler: _EthercatSlaveCTN class in EthercatSlave.py

   334

        """

   335

        wx.Panel.__init__(self, parent, -1)

   336

   337

        self.DatatypeDescription, self.CommunicationObject, self.ManufacturerSpecific, \

   338

        self.ProfileSpecific, self.Reserved, self.AllSDOData = range(6)

   339

   340

        self.Controler = controler

   341

   342

        self.SDOManagementMainSizer = wx.BoxSizer(wx.VERTICAL)

   343

        self.SDOManagementInnerMainSizer = wx.FlexGridSizer(cols=1, hgap=10, rows=2, vgap=10)

   344

   345

        self.SDOUpdate = wx.Button(self, label=_('update'))          

   346

        self.SDOUpdate.Bind(wx.EVT_BUTTON, self.SDOInfoUpdate)

   347

   348

        self.CallSDONoteBook = SDONoteBook(self, controler=self.Controler)

   349

        self.SDOManagementInnerMainSizer.Add(self.SDOUpdate)

   350

        self.SDOManagementInnerMainSizer.Add(self.CallSDONoteBook, wx.ALL | wx.EXPAND)           

   351

   352

        self.SDOManagementMainSizer.Add(self.SDOManagementInnerMainSizer)

   353

   354

        self.SetSizer(self.SDOManagementMainSizer)

   355

   356

    def SDOInfoUpdate(self, event):

   357

        """

   358

        Evenet handler for SDO "update" button.

   359

          - Load SDO data from current slave 

   360

        @param event : wx.EVT_BUTTON object

   361

        """     

   362

        self.Controler.CommonMethod.SaveSDOData = []

   363

        self.Controler.CommonMethod.ClearSDODataSet()

   364

        self.SDOFlag = False

   365

   366

        # Check whether beremiz connected or not.

   367

        check_connect_flag = self.Controler.CommonMethod.CheckConnect(False)

   368

        if check_connect_flag:

   369

            self.SDOs = self.Controler.CommonMethod.GetSlaveSDOFromSlave()

   370

            # SDOFlag is "False", user click "Cancel" button

   371

            self.SDOFlag = self.SDOParser() 

   372

   373

            if self.SDOFlag :

   374

                self.CallSDONoteBook.CreateNoteBook()      

   375

                self.Refresh()

   376

   377

    def SDOParser(self):  

   378

        """

   379

        Parse SDO data set that obtain "SDOInfoUpdate" Method

   380

        @return True or False 

   381

        """       

   382

   383

        slaveSDO_progress = wx.ProgressDialog("Slave SDO Monitoring", "Now Uploading...",

   384

                               maximum = len(self.SDOs.splitlines()), parent=self,

   385

                               style = wx.PD_CAN_ABORT | wx.PD_APP_MODAL | wx.PD_ELAPSED_TIME | 

   386

                                       wx.PD_ESTIMATED_TIME | wx.PD_REMAINING_TIME | 

   387

                                       wx.PD_AUTO_HIDE | wx.PD_SMOOTH)        

   388

   389

        # If keep_going flag is False, SDOParser method is stop and return "False".

   390

        keep_going = True

   391

        count = 0

   392

   393

        # SDO data example 

   394

        # SDO 0x1000, "Device type"

   395

        # 0x1000:00,r-r-r-,uint32,32 bit,"Device type",0x00020192, 131474

   396

        for details_line in self.SDOs.splitlines():

   397

            count += 1

   398

            line_token = details_line.split("\"")

   399

            # len(line_token[2]) case : SDO 0x1000, "Device type"

   400

            if len(line_token[2]) == 0:

   401

                title_name = line_token[1]

   402

            # else case : 0x1000:00,r-r-r-,uint32,32 bit,"Device type",0x00020192, 131474

   403

            else :

   404

                # line_token = ['0x1000:00,r-r-r-,uint32,32 bit,', 'Device type', ',0x00020192, 131474']

   405

                token_head, name, token_tail = line_token

   406

   407

                # token_head = ['0x1000:00', 'r-r-r-', 'uint32', '32 bit', '']

   408

                token_head = token_head.split(",")

   409

                ful_idx, access, type, size, empty = token_head

   410

                # ful_idx.split(":") = ['0x1000', '00']

   411

                idx, sub_idx = ful_idx.split(":")

   412

   413

                # token_tail = ['', '0x00020192', '131474']

   414

                token_tail = token_tail.split(",")

   415

                try :

   416

                    empty, hex_val, dec_val = token_tail

   417

   418

                # SDO data is not return "dec value"

   419

                # line example : 

   420

                # 0x1702:01,rwr-r-,uint32,32 bit," 1st mapping", ---- 

   421

                except :

   422

                    empty, hex_val = token_tail

   423

   424

                name_after_check = self.StringTest(name)

   425

   426

                # convert hex type

   427

                sub_idx = "0x" + sub_idx

   428

   429

                if type == "octet_string":

   430

                    hex_val = ' ---- '

   431

   432

                # SResult of SlaveSDO data parsing. (data type : dictionary)

   433

                self.Data = {'idx':idx.strip(), 'subIdx':sub_idx.strip(), 'access':access.strip(), 

   434

                             'type':type.strip(), 'size':size.strip(),  'name':name_after_check.strip("\""), 

   435

                             'value':hex_val.strip(), "category":title_name.strip("\"")}

   436

   437

                category_divide_value = [0x1000, 0x2000, 0x6000, 0xa000, 0xffff]

   438

   439

                for count in range(len(category_divide_value)) :

   440

                    if int(idx, 0) < category_divide_value[count]:

   441

                        self.Controler.CommonMethod.SaveSDOData[count].append(self.Data)

   442

                        break

   443

   444

                self.Controler.CommonMethod.SaveSDOData[self.AllSDOData].append(self.Data)

   445

   446

            if count >= len(self.SDOs.splitlines()) / 2:

   447

                (keep_going, skip) = slaveSDO_progress.Update(count, "Please waiting a moment!!")

   448

            else:

   449

                (keep_going, skip) = slaveSDO_progress.Update(count)

   450

   451

            # If user click "Cancel" loop suspend immediately 

   452

            if (keep_going == False):

   453

                break

   454

   455

        slaveSDO_progress.Destroy()      

   456

        return keep_going  

   457

   458

    def StringTest(self, check_string):

   459

        """

   460

        Test value 'name' is alphanumeric  

   461

        @param check_string : input data for check 

   462

        @return result : output data after check

   463

        """  

   464

        # string.printable is print this result

   465

        #'0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ

   466

        #!"#$%&\'()*+,-./:;<=>?@[\\]^_`{|}~ \t\n\r\x0b\x0c

   467

        allow_range = string.printable

   468

        result = check_string

   469

        for i in range(0, len(check_string)):

   470

            # string.isalnum() is check whether string is alphanumeric or not

   471

            if check_string[len(check_string)-1-i:len(check_string)-i] in allow_range :

   472

                result = check_string[:len(check_string) - i]

   473

                break

   474

        return result

   475

   476

   477

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

   478

#                    For SDO Notebook (divide category)

   479

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

   480

class SDONoteBook(wx.Notebook):

   481

    def __init__(self, parent, controler):

   482

        """

   483

        Constructor

   484

        @param parent: Reference to the parent SDOPanelClass class

   485

        @param controler: _EthercatSlaveCTN class in EthercatSlave.py

   486

        """

   487

        wx.Notebook.__init__(self, parent, id = -1, size=(850,500))      

   488

        self.Controler = controler

   489

        self.parent = parent

   490

   491

        self.CreateNoteBook()

   492

   493

        self.Bind(wx.EVT_CHOICEBOOK_PAGE_CHANGED, self.OnPageChanged)

   494

        self.Bind(wx.EVT_CHOICEBOOK_PAGE_CHANGING, self.OnPageChanging)

   495

   496

    def CreateNoteBook(self): 

   497

        """

   498

        Create each NoteBook page, divided SDO index

   499

        According to EtherCAT Communication(03/2011), 158p

   500

        """   

   501

        self.Data = []

   502

        count = 1

   503

   504

        page_texts = [("all", self.parent.AllSDOData),

   505

                     ("0x0000 - 0x0ff", self.parent.DatatypeDescription),

   506

                     ("0x1000 - 0x1fff", self.parent.CommunicationObject),

   507

                     ("0x2000 - 0x5fff", self.parent.ManufacturerSpecific),

   508

                     ("0x6000 - 0x9fff", self.parent.ProfileSpecific),

   509

                     ("0xa000 - 0xffff", self.parent.Reserved)]

   510

   511

        page_tooltip_string = ["SDO Index 0x0000 - 0x0fff : Data Type Description",

   512

                               "SDO Index 0x1000 - 0x1fff : Communication object",

   513

                               "SDO Index 0x2000 - 0x5fff : Manufacturer specific",

   514

                               "SDO Index 0x6000 - 0x9fff : Profile specific",

   515

                               "SDO Index 0xa000 - 0xffff : Reserved",

   516

                               "All SDO Object"]

   517

   518

        self.DeleteAllPages()

   519

   520

        for txt, count in page_texts:

   521

            self.Data = self.Controler.CommonMethod.SaveSDOData[count]

   522

            self.Win = SlaveSDOTable(self, self.Data) 

   523

            self.AddPage(self.Win, txt)

   524

   525

    def OnPageChanged(self, event):

   526

        old = event.GetOldSelection()

   527

        new = event.GetSelection()

   528

        sel = self.GetSelection()

   529

        event.Skip()

   530