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

import os

    11

    12

import wx

    13

import wx.grid

    14

import wx.gizmos

    15

import wx.lib.buttons

    16

    17

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

    18

from controls import CustomGrid, CustomTable

    19

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

    20

    21

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

    22

import string

    23

import wx.grid as gridlib

    24

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

    25

    27

from xml.dom import minidom

    28

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

    29

    30

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

    31

def GetSyncManagersTableColnames():

    32

    """

    33

    Returns column names of SyncManager Table in Slave state panel.

    34

    """

    35

    _ = lambda x : x

    36

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

    37

    38

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

    39

#                    Sync Managers Table

    40

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

    41

class SyncManagersTable(CustomTable):

    43

        if row < self.GetNumberRows():

    44

            if col == 0:

    45

                return row

    46

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

    47

    48

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

    49

#                    EtherCAT Management Treebook

    50

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

    51

class EtherCATManagementTreebook(wx.Treebook):

    52

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

    53

        """

    54

        Constructor

    55

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

    56

        @param controler: _EthercatSlaveCTN class in EthercatSlave.py

    57

        @param node_editor: Reference to Beremiz frame

    58

        """

    59

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

    60

        self.parent = parent

    61

        self.Controler = controler

    62

        self.NodeEditor = node_editor

    64

        self.EtherCATManagementClassObject = {}

    66

        # fill EtherCAT Management Treebook

    67

        for pname, pclass, subs in [

    68

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

    69

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

    70

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

    72

                    ("Smart View", SlaveSiiSmartView),

    73

                    ("Hex View", HexView)]),

    74

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

    75

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

    76

                for spname, spclass in subs:

    77

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

    78

    79

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

    80

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

    82

    def OnPageChanged(self, event):

    83

        old = event.GetOldSelection()

    84

        new = event.GetSelection()

    85

        sel = event.GetSelection()

    86

        event.Skip()

    88

    def OnPageChanging(self, event):

    89

        old = event.GetOldSelection()

    90

        new = event.GetSelection()

    91

        sel = event.GetSelection()

    94

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

    95

#                    For SlaveState Panel

    97

class SlaveStatePanelClass(wx.Panel):

    98

    def __init__(self, parent, controler):

    99

        """

   100

        Constructor

   101

        @param parent: Reference to the parent EtherCATManagementTreebook class

   102

        @param controler: _EthercatSlaveCTN class in EthercatSlave.py

   103

        """

   104

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

   105

        self.Controler = controler

   106

        self.parent = parent

   108

        # initialize SlaveStatePanel UI dictionaries

   109

        self.StaticBoxDic = {}

   110

        self.StaticTextDic = {}

   111

        self.TextCtrlDic = {}

   112

        self.ButtonDic = {}

   114

        # iniitalize BoxSizer and FlexGridSizer

   115

        self.SizerDic = {

   116

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

   117

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

   118

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

   119

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

   120

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

   121

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

   122

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

   124

        # initialize StaticBox and StaticBoxSizer

   125

        for box_name, box_label in [

   126

                ("SlaveInfosDetailsBox", "Slave Informations"),

   127

                ("SyncManagerBox", "Sync Manager"),

   128

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

   129

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

   132

        for statictext_name, statictext_label, textctrl_name in [

   133

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

   134

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

   135

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

   136

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

   137

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

   138

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

   142

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

   147

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

   149

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

   150

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

   151

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

   152

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

   153

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

   154

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

   155

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

   156

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

   157

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

   158

            self.ButtonDic[button_name].SetToolTipString(button_tooltipstring)

   159

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

   160

            for statictext_name, statictext_label, textctrl_name in sub_item :

   161

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

   162

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

   164

                                                               self.TextCtrlDic[textctrl_name]])

   166

        for button_name, button_label, button_tooltipstring, event_method in [

   167

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

   168

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

   169

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

   170

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

   171

            self.ButtonDic[button_name].SetToolTipString(button_tooltipstring)

   175

            self.SizerDic["SlaveState_down_sizer"]])

   177

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

   179

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

   180

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

   181

            self.SizerDic["SlaveStateBox"]])

   183

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

   185

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

   187

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

   188

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

   190

        self.CreateSyncManagerTable()

   192

        self.Centre()

   194

    def CreateSyncManagerTable(self):

   195

        """

   196

        Create grid for "SyncManager"

   197

        """

   199

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

   200

        self.SyncManagersGrid.SetTable(self.SyncManagersTable)

   201

        # set grid alignment attr. (CENTER)

   203

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

   204

        # set grid size

   205

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

   206

        self.SyncManagersGrid.SetRowLabelSize(0)

   207

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

   208

            attr = wx.grid.GridCellAttr()

   209

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

   210

            self.SyncManagersGrid.SetColAttr(col, attr)

   211

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

   214

        self.RefreshSlaveInfos()

   216

    def RefreshSlaveInfos(self):

   217

        """

   218

        Fill data in "Slave Information" and "SyncManager"

   219

        """

   220

        slave_infos = self.Controler.GetSlaveInfos()

   221

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

   222

        if slave_infos is not None:

   224

            for textctrl_name in sync_manager_section:

   225

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

   226

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

   227

            self.SyncManagersTable.ResetView(self.SyncManagersGrid)

   228

        else:

   229

            for textctrl_name in sync_manager_section:

   230

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

   231

            self.SyncManagersTable.SetData([])

   232

            self.SyncManagersTable.ResetView(self.SyncManagersGrid)

   234

    def OnButtonClick(self, event):

   235

        """

   236

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

   237

        @param event : wx.EVT_BUTTON object

   238

        """

   239

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

   240

        if check_connect_flag :

   241

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

   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, count = self.Controler.GetCTRoot()._connector.GetPLCstatus()

   253

                if status == "Started" :

   254

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

   255

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

   256

                else :

   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

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

   265

        if check_connect_flag:

   266

            returnVal = self.Controler.CommonMethod.GetSlaveStateFromSlave()

   267

            line = returnVal.split("\n")

   268

            try :

   269

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

   270

            except Exception:

   273

    def SetCurrentState(self, line):

   274

        """

   275

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

   276

        @param line : result of "ethercat slaves" command

   277

        """

   278

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

   279

        try :

   280

            # parse the execution result of  "ethercat slaves" command

   281

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

   282

            token = line.split("  ")

   283

            if token[2] in state_array:

   285

        except Exception:

   288

    def StartTimer(self, event):

   289

        """

   290

        Event handler for "Start State Monitoring" button.

   291

          - start slave state monitoring thread

   292

        @param event : wx.EVT_BUTTON object

   293

        """

   294

        self.SlaveStateThread = wx.Timer(self)

   295

        # set timer period (1000 ms)

   296

        self.SlaveStateThread.Start(1000)

   298

    def CurrentStateThreadStop(self, event):

   299

        """

   300

        Event handler for "Stop State Monitoring" button.

   301

          - stop slave state monitoring thread

   302

        @param event : wx.EVT_BUTTON object

   303

        """

   304

        try:

   305

            self.SlaveStateThread.Stop()

   306

        except Exception:

   307

            pass

   309

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

   310

#                    For SDO Management Panel

   312

class SDOPanelClass(wx.Panel):

   313

    def __init__(self, parent, controler):

   314

        """

   315

        Constructor

   316

        @param parent: Reference to the parent EtherCATManagementTreebook class

   317

        @param controler: _EthercatSlaveCTN class in EthercatSlave.py

   318

        """

   319

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

   321

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

   322

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

   324

        self.Controler = controler

   326

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

   327

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

   330

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

   332

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

   333

        self.SDOManagementInnerMainSizer.Add(self.SDOUpdate)

   335

   336

        self.SDOManagementMainSizer.Add(self.SDOManagementInnerMainSizer)

   338

        self.SetSizer(self.SDOManagementMainSizer)

   340

    def SDOInfoUpdate(self, event):

   341

        """

   342

        Evenet handler for SDO "update" button.

   344

        @param event : wx.EVT_BUTTON object

   346

        self.Controler.CommonMethod.SaveSDOData = []

   347

        self.Controler.CommonMethod.ClearSDODataSet()

   348

        self.SDOFlag = False

   350

        # Check whether beremiz connected or not.

   351

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

   352

        if check_connect_flag:

   353

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

   354

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

   356

   357

            if self.SDOFlag :

   359

                self.Refresh()

   362

        """

   363

        Parse SDO data set that obtain "SDOInfoUpdate" Method

   366

   367

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

   368

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

   373

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

   374

        keep_going = True

   375

        count = 0

   378

        # SDO 0x1000, "Device type"

   379

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

   380

        for details_line in self.SDOs.splitlines():

   381

            count += 1

   382

            line_token = details_line.split("\"")

   383

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

   384

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

   385

                title_name = line_token[1]

   386

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

   387

            else :

   388

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

   389

                token_head, name, token_tail = line_token

   391

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

   392

                token_head = token_head.split(",")

   393

                ful_idx, access, type, size, empty = token_head

   394

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

   395

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

   397

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

   398

                token_tail = token_tail.split(",")

   399

                try :

   400

                    empty, hex_val, dec_val = token_tail

   402

                # SDO data is not return "dec value"

   405

                except Exception:

   406

                    empty, hex_val = token_tail

   408

                name_after_check = self.StringTest(name)

   410

                # convert hex type

   411

                sub_idx = "0x" + sub_idx

   412

   413

                if type == "octet_string":

   414

                    hex_val = ' ---- '

   416

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

   419

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

   421

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

   422

   423

                for count in range(len(category_divide_value)) :

   424

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

   425

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

   426

                        break

   428

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

   430

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

   431

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

   432

            else:

   433

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

   436

            if (keep_going == False):

   437

                break

   441

   442

    def StringTest(self, check_string):

   443

        """

   446

        @return result : output data after check

   448

        # string.printable is print this result

   449

        #'0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ

   450

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

   451

        allow_range = string.printable

   452

        result = check_string

   453

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

   454

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

   455

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

   456

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

   457

                break

   458

        return result

   461

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

   462

#                    For SDO Notebook (divide category)

   464

class SDONoteBook(wx.Notebook):

   465

    def __init__(self, parent, controler):

   466

        """

   467

        Constructor

   468

        @param parent: Reference to the parent SDOPanelClass class

   469

        @param controler: _EthercatSlaveCTN class in EthercatSlave.py

   470

        """

   472

        self.Controler = controler

   473

        self.parent = parent

   475

        self.CreateNoteBook()

   477

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

   478

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

   481

        """

   482

        Create each NoteBook page, divided SDO index

   483

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

   485

        self.Data = []

   486

        count = 1