1

#!/usr/bin/env python

     2

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

     3

     4

# This file is part of Beremiz

     5

#

     6

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

     7

#

     8

# See COPYING file for copyrights details.

     9

    10

from __future__ import absolute_import

    11

from __future__ import division

    12

import os

    13

import string

    14

from xml.dom import minidom

    15

    16

import wx

    17

import wx.grid

    18

import wx.adv

    19

import wx.lib.buttons

    20

    21

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

    22

from controls import CustomGrid, CustomTable

    23

from runtime import PlcStatus

    24

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

    25

    26

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

    27

    28

from util.TranslationCatalogs import NoTranslate

    29

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

    30

    31

    32

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

    33

def GetSyncManagersTableColnames():

    34

    """

    35

    Returns column names of SyncManager Table in Slave state panel.

    36

    """

    37

    _ = NoTranslate

    38

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

    39

    40

    41

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

    42

#                    Sync Managers Table

    43

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

    44

class SyncManagersTable(CustomTable):

    45

    def GetValue(self, row, col):

    46

        if row < self.GetNumberRows():

    47

            if col == 0:

    48

                return row

    49

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

    50

    51

    52

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

    53

#                    EtherCAT Management Treebook

    54

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

    55

class EtherCATManagementTreebook(wx.Treebook):

    56

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

    57

        """

    58

        Constructor

    59

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

    60

        @param controler: _EthercatSlaveCTN class in EthercatSlave.py

    61

        @param node_editor: Reference to Beremiz frame

    62

        """

    63

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

    64

        self.parent = parent

    65

        self.Controler = controler

    66

        self.NodeEditor = node_editor

    67

    68

        self.EtherCATManagementClassObject = {}

    69

    70

        # fill EtherCAT Management Treebook

    71

        panels = [

    72

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

    73

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

    74

            ("PDO Mapping",     PDOPanelClass, [

    75

                    ("Rx PDO", RxPDOPanelClass),

    76

                    ("Tx PDO", TxPDOPanelClass)]),

    77

            ("MDP Setting",		MDPPanel, []),

    78

            ("ESC Management",     EEPROMAccessPanel, [

    79

                    ("Smart View",  SlaveSiiSmartView),

    80

                    ("Hex View",    HexView)]),

    81

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

    82

            ("DC Configuration",    DCConfigPanel, [])

    83

        ]

    84

        for pname, pclass, subs in panels:

    85

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

    86

            for spname, spclass in subs:

    87

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

    88

    89

    90

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

    91

#                    For SlaveState Panel

    92

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

    93

class SlaveStatePanelClass(wx.Panel):

    94

    def __init__(self, parent, controler):

    95

        """

    96

        Constructor

    97

        @param parent: Reference to the parent EtherCATManagementTreebook class

    98

        @param controler: _EthercatSlaveCTN class in EthercatSlave.py

    99

        """

   100

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

   101

        self.Controler = controler

   102

        self.parent = parent

   103

   104

        # initialize SlaveStatePanel UI dictionaries

   105

        self.StaticBoxDic = {}

   106

        self.StaticTextDic = {}

   107

        self.TextCtrlDic = {}

   108

        self.ButtonDic = {}

   109

   110

        # iniitalize BoxSizer and FlexGridSizer

   111

        self.SizerDic = {

   112

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

   113

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

   114

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

   115

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

   116

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

   117

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

   118

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

   119

   120

        # initialize StaticBox and StaticBoxSizer

   121

        for box_name, box_label in [

   122

                ("SlaveInfosDetailsBox", "Slave Informations"),

   123

                ("SyncManagerBox", "Sync Manager"),

   124

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

   125

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

   126

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

   127

   128

        for statictext_name, statictext_label, textctrl_name in [

   129

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

   130

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

   131

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

   132

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

   133

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

   134

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

   135

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

   136

                                                                  self.TextCtrlDic[textctrl_name]])

   137

   138

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

   139

   140

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

   141

   142

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

   143

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

   144

   145

        buttons = [

   146

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

   147

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

   148

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

   149

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

   150

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

   151

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

   152

        ]

   153

        for button_name, button_id, button_label, button_tooltipstring, event_method, sub_item in buttons:

   154

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

   155

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

   156

            self.ButtonDic[button_name].SetToolTip(button_tooltipstring)

   157

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

   158

            for statictext_name, statictext_label, textctrl_name in sub_item:

   159

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

   160

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

   161

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

   162

                                                              self.TextCtrlDic[textctrl_name]])

   163

   164

        for button_name, button_label, button_tooltipstring, event_method in [

   165

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

   166

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

   167

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

   168

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

   169

            self.ButtonDic[button_name].SetToolTip(button_tooltipstring)

   170

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

   171

   172

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

   173

                                                   self.SizerDic["SlaveState_down_sizer"]])

   174

   175

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

   176

   177

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

   178

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

   179

            self.SizerDic["SlaveStateBox"]])

   180

   181

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

   182

   183

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

   184

   185

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

   186

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

   187

   188

        self.CreateSyncManagerTable()

   189

   190

        self.Centre()

   191

   192

    def CreateSyncManagerTable(self):

   193

        """

   194

        Create grid for "SyncManager"

   195

        """

   196

        # declare Table object

   197

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

   198

        self.SyncManagersGrid.SetTable(self.SyncManagersTable)

   199

        # set grid alignment attr. (CENTER)

   200

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

   201

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

   202

        # set grid size

   203

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

   204

        self.SyncManagersGrid.SetRowLabelSize(0)

   205

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

   206

            attr = wx.grid.GridCellAttr()

   207

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

   208

            self.SyncManagersGrid.SetColAttr(col, attr)

   209

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

   210

            self.SyncManagersGrid.AutoSizeColumn(col, False)

   211

   212

        self.RefreshSlaveInfos()

   213

   214

    def RefreshSlaveInfos(self):

   215

        """

   216

        Fill data in "Slave Information" and "SyncManager"

   217

        """

   218

        slave_infos = self.Controler.GetSlaveInfos()

   219

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

   220

        if slave_infos is not None:

   221

            # this method is same as "TextCtrl.SetValue"

   222

            for textctrl_name in sync_manager_section:

   223

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

   224

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

   225

            self.SyncManagersTable.ResetView(self.SyncManagersGrid)

   226

        else:

   227

            for textctrl_name in sync_manager_section:

   228

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

   229

            self.SyncManagersTable.SetData([])

   230

            self.SyncManagersTable.ResetView(self.SyncManagersGrid)

   231

   232

    def OnButtonClick(self, event):

   233

        """

   234

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

   235

        @param event : wx.EVT_BUTTON object

   236

        """

   237

        # Check whether beremiz connected or not.

   238

        # If this method is called cyclically, set the cyclic flag true

   239

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

   240

        if check_connect_flag:

   241

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

   242

   243

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

   244

            if event.GetId() < 3:

   245

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

   246

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

   247

   248

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

   249

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

   250

            #  (2) Otherwise, show error message and return

   251

            else:

   252

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

   253

                if status == PlcStatus.Started:

   254

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

   255

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

   256

                else:

   257

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

   258

   259

    def GetCurrentState(self, event):

   260

        """

   261

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

   262

        @param event : wx.TIMER object

   263

        """

   264

        if self.IsShownOnScreen() is False:

   265

            return

   266

   267

        # Check whether beremiz connected or not.

   268

        # If this method is called cyclically, set the cyclic flag true

   269

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

   270

        if check_connect_flag:

   271

            returnVal = self.Controler.CommonMethod.GetSlaveStateFromSlave()

   272

            line = returnVal.split("\n")

   273

            try:

   274

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

   275

            except Exception:

   276

                pass

   277

   278

    def SetCurrentState(self, line):

   279

        """

   280

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

   281

        @param line : result of "ethercat slaves" command

   282

        """

   283

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

   284

        try:

   285

            # parse the execution result of  "ethercat slaves" command

   286

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

   287

            token = line.split("  ")

   288

            if token[2] in state_array:

   289

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

   290

        except Exception:

   291

            pass

   292

   293

    def StartTimer(self, event):

   294

        """

   295

        Event handler for "Start State Monitoring" button.

   296

          - start slave state monitoring thread

   297

        @param event : wx.EVT_BUTTON object

   298

        """

   299

        # Check whether beremiz connected or not.

   300

        # If this method is called cyclically, set the cyclic flag true

   301

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

   302

        if check_connect_flag:

   303

            self.SlaveStateThread = wx.Timer(self)

   304

            # set timer period (2000 ms)

   305

            self.SlaveStateThread.Start(2000)

   306

        else:

   307

            pass

   308

   309

    def CurrentStateThreadStop(self, event):

   310

        """

   311

        Event handler for "Stop State Monitoring" button.

   312

          - stop slave state monitoring thread

   313

        @param event : wx.EVT_BUTTON object

   314

        """

   315

        try:

   316

            self.SlaveStateThread.Stop()

   317

        except Exception:

   318

            pass

   319

   320

   321

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

   322

#                    For SDO Management Panel

   323

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

   324

class SDOPanelClass(wx.Panel):

   325

    def __init__(self, parent, controler):

   326

        """

   327

        Constructor

   328

        @param parent: Reference to the parent EtherCATManagementTreebook class

   329

        @param controler: _EthercatSlaveCTN class in EthercatSlave.py

   330

        """

   331

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

   332

   333

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

   334

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

   335

   336

        self.Controler = controler

   337

   338

        self.SDOMonitorEntries = {}

   339

        #----------------------------- SDO Monitor -------------------------------#

   340

        self.RBList = ["ON","OFF"]

   341

   342

        self.SDOMonitorRB = wx.RadioBox(self, label=_("monitoring"),

   343

                                        choices=self.RBList, majorDimension=2)

   344

   345

        self.SDOMonitorRB.SetSelection(1)

   346

        self.Bind(wx.EVT_RADIOBOX, self.OnRadioBox, self.SDOMonitorRB)

   347

   348

        self.SDOMonitorGrid = wx.grid.Grid(self,size=wx.Size(850,150),style=wx.EXPAND

   349

                                                        |wx.ALIGN_CENTER_HORIZONTAL

   350

                                                        |wx.ALIGN_CENTER_VERTICAL) 

   351

        self.SDOMonitorGrid.Bind(gridlib.EVT_GRID_CELL_LEFT_DCLICK, 

   352

                                                    self.onMonitorGridDoubleClick)

   353

   354

        #----------------------------- SDO Entries ----------------------------#

   355

        self.SDOUpdateBtn = wx.Button(self, label=_("update"))         

   356

        self.SDOUpdateBtn.Bind(wx.EVT_BUTTON, self.OnSDOUpdate)

   357

   358

        self.SDOTraceThread = None

   359

        self.SDOMonitoringFlag = False

   360

        self.SDOValuesList = []

   361

        # Default SDO Page Number

   362

        self.SDOPageNum = 2

   363

   364

        #----------------------------- Sizer --------------------------------------#

   365

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

   366

        self.SDOInfoBox = wx.StaticBox(self, label=_("SDO Entries"))

   367

        self.SDOMonitorBox = wx.StaticBox(self, label=_("SDO Monitor"))

   368

   369

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

   370

        self.SDOInfoBoxSizer = wx.StaticBoxSizer(self.SDOInfoBox, orient=wx.VERTICAL)

   371

        self.SDOMonitorBoxSizer = wx.StaticBoxSizer(self.SDOMonitorBox, 

   372

                                                                    orient=wx.VERTICAL)

   373

        self.SDOInfoBoxSizer.Add(self.SDOUpdateBtn)

   374

   375

        self.SDOInfoBoxSizer.Add(self.SDONoteBook, wx.ALL|wx.EXPAND)

   376

        self.SDOMonitorBoxSizer.Add(self.SDOMonitorRB)

   377

        self.SDOMonitorBoxSizer.Add(self.SDOMonitorGrid)

   378

        self.SDOManagementMainSizer.AddMany([self.SDOInfoBoxSizer, 

   379

                                             self.SDOMonitorBoxSizer])

   380

        self.SetSizer(self.SDOManagementMainSizer)

   381

   382

        #----------------------------- fill the contents --------------------------# 

   383

        #self.entries = self.Controler.CTNParent.CTNParent.GetEntriesList()

   384

   385

        slave = self.Controler.CTNParent.GetSlave(self.Controler.GetSlavePos())

   386

        type_infos = slave.getType()

   387

        device, alignment = self.Controler.CTNParent.GetModuleInfos(type_infos)

   388

        self.entries = device.GetEntriesList()

   389

   390

        self.Controler.CommonMethod.SDOVariables = []

   391

        self.Controler.CommonMethod.SDOSubEntryData = []

   392

        self.Controler.CommonMethod.ClearSDODataSet()

   393

        self.SDOParserXML(self.entries)

   394

        self.SDONoteBook.CreateNoteBook()      

   395

        self.CreateSDOMonitorGrid()

   396

        self.Refresh()

   397

   398

    def OnSDOUpdate(self, event):

   399

        SlavePos = self.Controler.GetSlavePos()

   400

        num = self.SDOPageNum - 1

   401

        if num < 0:

   402

            for i in range(len(self.Controler.CommonMethod.SDOVariables)):

   403

                data = self.Controler.GetCTRoot()._connector.GetSDOEntriesData(

   404

                           self.Controler.CommonMethod.SDOVariables[i], SlavePos)

   405

                self.Controler.CommonMethod.SDOVariables[i] = data

   406

        else :

   407

            SDOUploadEntries = self.Controler.CommonMethod.SDOVariables[num]        

   408

            data = self.Controler.GetCTRoot()._connector.GetSDOEntriesData(SDOUploadEntries, SlavePos)

   409

            self.Controler.CommonMethod.SDOVariables[num] = data

   410

   411

        self.SDONoteBook.CreateNoteBook()      

   412

        self.Refresh()

   413

   414

    def OnRadioBox(self, event):

   415

        """

   416

        There are two selections that are on and off.

   417

        If the on is selected, the monitor thread begins to run.

   418

        If the off is selected, the monitor thread gets off.

   419

        @param event: wx.EVT_RADIOBOX object 

   420

        """

   421

        on, off = range(2)

   422

   423

        if event.GetInt() == on:

   424

            CheckThreadFlag = self.SDOMonitoringThreadOn()

   425

            if not CheckThreadFlag:

   426

                self.SDOMonitorRB.SetSelection(off)

   427

        elif event.GetInt() == off:

   428

            self.SDOMonitoringThreadOff()

   429

   430

    def SDOMonitoringThreadOn(self):

   431

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

   432

        if check_connect_flag:

   433

            self.SetSDOTraceValues(self.SDOMonitorEntries)

   434

            self.Controler.GetCTRoot()._connector.GetSDOData()

   435

            self.SDOTraceThread = Thread(target=self.SDOMonitorThreadProc)

   436

            self.SDOMonitoringFlag = True

   437

            self.SDOTraceThread.start()

   438

        return check_connect_flag

   439

   440

    def SDOMonitoringThreadOff(self):

   441

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

   442

        if check_connect_flag:

   443

            self.SDOMonitoringFlag = False

   444

            if self.SDOTraceThread is not None:

   445

                self.SDOTraceThread.join()

   446

            self.SDOTraceThread = None

   447

            self.Controler.GetCTRoot()._connector.StopSDOThread()

   448

   449

    def SetSDOTraceValues(self, SDOMonitorEntries):

   450

        SlavePos = self.Controler.GetSlavePos()

   451

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

   452

        if check_connect_flag:

   453

            self.Controler.GetCTRoot()._connector.SetSDOTraceValues(SDOMonitorEntries, SlavePos)

   454

   455

    def SDOMonitorThreadProc(self):

   456

        while self.SDOMonitoringFlag and self.Controler.GetCTRoot()._connector.PLCStatus != "Started":

   457

            self.SDOValuesList = self.Controler.GetCTRoot()._connector.GetSDOData()

   458

            LocalData = self.SDOValuesList[0].items()

   459

            LocalData.sort()

   460

            if self.SDOValuesList[1] != self.Controler.GetSlavePos():

   461

                continue

   462

            row = 0

   463

            for (idx, subidx), data in LocalData:

   464

                self.SDOMonitorGrid.SetCellValue(row, 6, str(data["value"]))

   465

                row += 1

   466

            time.sleep(0.5)

   467

   468

    def CreateSDOMonitorGrid(self):

   469

        """

   470

        It creates SDO Monitor table and specifies cell size and labels.

   471

        """

   472

        self.SDOMonitorGrid.CreateGrid(0,7) 

   473

        SDOCellSize = [(0, 65), (1, 65), (2, 50), (3, 70), 

   474

                         (4, 40), (5, 450), (6, 85)]

   475

   476

        for (index, size) in SDOCellSize: