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

import os

    12

import string

    13

from xml.dom import minidom

    14

    15

import wx

    16

import wx.grid

    17

import wx.gizmos

    18

import wx.lib.buttons

    19

    20

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

    21

from controls import CustomGrid, CustomTable

    22

from runtime import PlcStatus

    23

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

    24

    25

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

    26

    27

from util.TranslationCatalogs import NoTranslate

    28

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

    29

    30

    31

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

    32

def GetSyncManagersTableColnames():

    33

    """

    34

    Returns column names of SyncManager Table in Slave state panel.

    35

    """

    36

    _ = NoTranslate

    37

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

    38

    39

    40

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

    41

#                    Sync Managers Table

    42

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

    43

class SyncManagersTable(CustomTable):

    44

    def GetValue(self, row, col):

    45

        if row < self.GetNumberRows():

    46

            if col == 0:

    47

                return row

    48

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

    49

    50

    51

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

    52

#                    EtherCAT Management Treebook

    53

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

    54

class EtherCATManagementTreebook(wx.Treebook):

    55

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

    56

        """

    57

        Constructor

    58

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

    59

        @param controler: _EthercatSlaveCTN class in EthercatSlave.py

    60

        @param node_editor: Reference to Beremiz frame

    61

        """

    62

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

    63

        self.parent = parent

    64

        self.Controler = controler

    65

        self.NodeEditor = node_editor

    66

    67

        self.EtherCATManagementClassObject = {}

    68

    69

        # fill EtherCAT Management Treebook

    70

        panels = [

    71

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

    72

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

    73

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

    74

            ("ESC Management",     EEPROMAccessPanel, [

    75

                ("Smart View", SlaveSiiSmartView),

    76

                ("Hex View", HexView)]),

    77

            ("Register Access",     RegisterAccessPanel, [])

    78

        ]

    79

        for pname, pclass, subs in panels:

    80

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

    81

            for spname, spclass in subs:

    82

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

    83

    84

    85

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

    86

#                    For SlaveState Panel

    87

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

    88

class SlaveStatePanelClass(wx.Panel):

    89

    def __init__(self, parent, controler):

    90

        """

    91

        Constructor

    92

        @param parent: Reference to the parent EtherCATManagementTreebook class

    93

        @param controler: _EthercatSlaveCTN class in EthercatSlave.py

    94

        """

    95

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

    96

        self.Controler = controler

    97

        self.parent = parent

    98

    99

        # initialize SlaveStatePanel UI dictionaries

   100

        self.StaticBoxDic = {}

   101

        self.StaticTextDic = {}

   102

        self.TextCtrlDic = {}

   103

        self.ButtonDic = {}

   104

   105

        # iniitalize BoxSizer and FlexGridSizer

   106

        self.SizerDic = {

   107

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

   108

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

   109

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

   110

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

   111

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

   112

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

   113

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

   114

   115

        # initialize StaticBox and StaticBoxSizer

   116

        for box_name, box_label in [

   117

                ("SlaveInfosDetailsBox", "Slave Informations"),

   118

                ("SyncManagerBox", "Sync Manager"),

   119

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

   120

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

   121

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

   122

   123

        for statictext_name, statictext_label, textctrl_name in [

   124

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

   125

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

   126

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

   127

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

   128

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

   129

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

   130

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

   131

                                                                  self.TextCtrlDic[textctrl_name]])

   132

   133

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

   134

   135

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

   136

   137

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

   138

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

   139

   140

        buttons = [

   141

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

   142

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

   143

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

   144

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

   145

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

   146

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

   147

        ]

   148

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

   149

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

   150

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

   151

            self.ButtonDic[button_name].SetToolTipString(button_tooltipstring)

   152

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

   153

            for statictext_name, statictext_label, textctrl_name in sub_item:

   154

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

   155

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

   156

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

   157

                                                              self.TextCtrlDic[textctrl_name]])

   158

   159

        for button_name, button_label, button_tooltipstring, event_method in [

   160

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

   161

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

   162

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

   163

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

   164

            self.ButtonDic[button_name].SetToolTipString(button_tooltipstring)

   165

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

   166

   167

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

   168

                                                   self.SizerDic["SlaveState_down_sizer"]])

   169

   170

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

   171

   172

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

   173

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

   174

            self.SizerDic["SlaveStateBox"]])

   175

   176

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

   177

   178

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

   179

   180

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

   181

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

   182

   183

        self.CreateSyncManagerTable()

   184

   185

        self.Centre()

   186

   187

    def CreateSyncManagerTable(self):

   188

        """

   189

        Create grid for "SyncManager"

   190

        """

   191

        # declare Table object

   192

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

   193

        self.SyncManagersGrid.SetTable(self.SyncManagersTable)

   194

        # set grid alignment attr. (CENTER)

   195

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

   196

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

   197

        # set grid size

   198

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

   199

        self.SyncManagersGrid.SetRowLabelSize(0)

   200

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

   201

            attr = wx.grid.GridCellAttr()

   202

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

   203

            self.SyncManagersGrid.SetColAttr(col, attr)

   204

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

   205

            self.SyncManagersGrid.AutoSizeColumn(col, False)

   206

   207

        self.RefreshSlaveInfos()

   208

   209

    def RefreshSlaveInfos(self):

   210

        """

   211

        Fill data in "Slave Information" and "SyncManager"

   212

        """

   213

        slave_infos = self.Controler.GetSlaveInfos()

   214

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

   215

        if slave_infos is not None:

   216

            # this method is same as "TextCtrl.SetValue"

   217

            for textctrl_name in sync_manager_section:

   218

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

   219

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

   220

            self.SyncManagersTable.ResetView(self.SyncManagersGrid)

   221

        else:

   222

            for textctrl_name in sync_manager_section:

   223

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

   224

            self.SyncManagersTable.SetData([])

   225

            self.SyncManagersTable.ResetView(self.SyncManagersGrid)

   226

   227

    def OnButtonClick(self, event):

   228

        """

   229

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

   230

        @param event : wx.EVT_BUTTON object

   231

        """

   232

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

   233

        if check_connect_flag:

   234

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

   235

   236

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

   237

            if event.GetId() < 3:

   238

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

   239

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

   240

   241

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

   242

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

   243

            #  (2) Otherwise, show error message and return

   244

            else:

   245

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

   246

                if status == PlcStatus.Started:

   247

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

   248

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

   249

                else:

   250

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

   251

   252

    def GetCurrentState(self, event):

   253

        """

   254

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

   255

        @param event : wx.TIMER object

   256

        """

   257

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

   258

        if check_connect_flag:

   259

            returnVal = self.Controler.CommonMethod.GetSlaveStateFromSlave()

   260

            line = returnVal.split("\n")

   261

            try:

   262

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

   263

            except Exception:

   264

                pass

   265

   266

    def SetCurrentState(self, line):

   267

        """

   268

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

   269

        @param line : result of "ethercat slaves" command

   270

        """

   271

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

   272

        try:

   273

            # parse the execution result of  "ethercat slaves" command

   274

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

   275

            token = line.split("  ")

   276

            if token[2] in state_array:

   277

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

   278

        except Exception:

   279

            pass

   280

   281

    def StartTimer(self, event):

   282

        """

   283

        Event handler for "Start State Monitoring" button.

   284

          - start slave state monitoring thread

   285

        @param event : wx.EVT_BUTTON object

   286

        """

   287

        self.SlaveStateThread = wx.Timer(self)

   288

        # set timer period (1000 ms)

   289

        self.SlaveStateThread.Start(1000)

   290

   291

    def CurrentStateThreadStop(self, event):

   292

        """

   293

        Event handler for "Stop State Monitoring" button.

   294

          - stop slave state monitoring thread

   295

        @param event : wx.EVT_BUTTON object

   296

        """

   297

        try:

   298

            self.SlaveStateThread.Stop()

   299

        except Exception:

   300

            pass

   301

   302

   303

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

   304

#                    For SDO Management Panel

   305

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

   306

class SDOPanelClass(wx.Panel):

   307

    def __init__(self, parent, controler):

   308

        """

   309

        Constructor

   310

        @param parent: Reference to the parent EtherCATManagementTreebook class

   311

        @param controler: _EthercatSlaveCTN class in EthercatSlave.py

   312

        """

   313

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

   314

   315

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

   316

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

   317

   318

        self.Controler = controler

   319

   320

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

   321

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

   322

   323

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

   324

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

   325

   326

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

   327

        self.SDOManagementInnerMainSizer.Add(self.SDOUpdate)

   328

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

   329

   330

        self.SDOManagementMainSizer.Add(self.SDOManagementInnerMainSizer)

   331

   332

        self.SetSizer(self.SDOManagementMainSizer)

   333

   334

    def SDOInfoUpdate(self, event):

   335

        """

   336

        Evenet handler for SDO "update" button.

   337

          - Load SDO data from current slave

   338

        @param event : wx.EVT_BUTTON object

   339

        """

   340

        self.Controler.CommonMethod.SaveSDOData = []

   341

        self.Controler.CommonMethod.ClearSDODataSet()

   342

        self.SDOFlag = False

   343

   344

        # Check whether beremiz connected or not.

   345

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

   346

        if check_connect_flag:

   347

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

   348

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

   349

            self.SDOFlag = self.SDOParser()

   350

   351

            if self.SDOFlag:

   352

                self.CallSDONoteBook.CreateNoteBook()

   353

                self.Refresh()

   354

   355

    def SDOParser(self):

   356

        """

   357

        Parse SDO data set that obtain "SDOInfoUpdate" Method

   358

        @return True or False

   359

        """

   360

   361

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

   362

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

   363

                                              parent=self,

   364

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

   365

                                              wx.PD_ESTIMATED_TIME | wx.PD_REMAINING_TIME |

   366

                                              wx.PD_AUTO_HIDE | wx.PD_SMOOTH)

   367

   368

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

   369

        keep_going = True

   370

        count = 0

   371

   372

        # SDO data example

   373

        # SDO 0x1000, "Device type"

   374

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

   375

        for details_line in self.SDOs.splitlines():

   376

            count += 1

   377

            line_token = details_line.split("\"")

   378

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

   379

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

   380

                title_name = line_token[1]

   381

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

   382

            else:

   383

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

   384

                token_head, name, token_tail = line_token

   385

   386

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

   387

                token_head = token_head.split(",")

   388

                ful_idx, access, type, size, _empty = token_head

   389

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

   390

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

   391

   392

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

   393

                token_tail = token_tail.split(",")

   394

                try:

   395

                    _empty, hex_val, _dec_val = token_tail

   396

   397

                # SDO data is not return "dec value"

   398

                # line example :

   399

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

   400

                except Exception:

   401

                    _empty, hex_val = token_tail

   402

   403

                name_after_check = self.StringTest(name)

   404

   405

                # convert hex type

   406

                sub_idx = "0x" + sub_idx

   407

   408

                if type == "octet_string":

   409

                    hex_val = ' ---- '

   410

   411

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

   412

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

   413

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

   414

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

   415

   416

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

   417

   418

                for count in range(len(category_divide_value)):

   419

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

   420

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

   421

                        break

   422

   423

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

   424

   425

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

   426

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

   427

            else:

   428

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

   429

   430

            # If user click "Cancel" loop suspend immediately

   431

            if not keep_going:

   432

                break

   433

   434

        slaveSDO_progress.Destroy()

   435

        return keep_going

   436

   437

    def StringTest(self, check_string):

   438

        """

   439

        Test value 'name' is alphanumeric

   440

        @param check_string : input data for check

   441

        @return result : output data after check

   442

        """

   443

        # string.printable is print this result

   444

        # '0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ

   445

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

   446

        allow_range = string.printable

   447

        result = check_string

   448

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

   449

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

   450

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

   451

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

   452

                break

   453

        return result

   454

   455

   456

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

   457

#                    For SDO Notebook (divide category)

   458

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

   459

class SDONoteBook(wx.Notebook):

   460

    def __init__(self, parent, controler):

   461

        """

   462

        Constructor

   463

        @param parent: Reference to the parent SDOPanelClass class

   464

        @param controler: _EthercatSlaveCTN class in EthercatSlave.py

   465

        """

   466

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

   467

        self.Controler = controler

   468

        self.parent = parent

   469

   470

        self.CreateNoteBook()

   471

   472

    def CreateNoteBook(self):

   473

        """

   474

        Create each NoteBook page, divided SDO index

   475

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

   476

        """

   477

        self.Data = []

   478

        count = 1

   479

   480

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

   481

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

   482

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