beremiz: comparison etherlab/EtherCATManagementEditor.py

equal deleted inserted replaced

-:bcf346f558bd
+:02a2b5dee5e3
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+# This file is part of Beremiz
+#
+# Copyright (C) 2013: Real-Time & Embedded Systems (RTES) Lab., University of Seoul
+#
+# See COPYING file for copyrights details.
+import os
+import wx
+import wx.grid
+import wx.gizmos
+import wx.lib.buttons
+# --------------------------------------------------------------------
+from controls import CustomGrid, CustomTable
+# --------------------------------------------------------------------
+# ------------ for SDO Management --------------------
+import string
+import wx.grid as gridlib
+#-------------------------------------------------------------
+# ------------ for register management ---------------
+from xml.dom import minidom
+#-------------------------------------------------------------
+# ----------------------------- For Sync Manager Table -----------------------------------
+def GetSyncManagersTableColnames():
+"""
+Returns column names of SyncManager Table in Slave state panel.
+"""
+_ = lambda x : x
+return ["#", _("Name"), _("Start Address"), _("Default Size"), _("Control Byte"), _("Enable")]
+#-------------------------------------------------------------------------------
+#                    Sync Managers Table
+#-------------------------------------------------------------------------------
+class SyncManagersTable(CustomTable):
+def GetValue(self, row, col):
+if row < self.GetNumberRows():
+if col == 0:
+return row
+return self.data[row].get(self.GetColLabelValue(col, False), "")
+#-------------------------------------------------------------------------------
+#                    EtherCAT Management Treebook
+#-------------------------------------------------------------------------------
+class EtherCATManagementTreebook(wx.Treebook):
+def __init__(self, parent, controler, node_editor):
+"""
+Constructor
+@param parent: Reference to the parent wx.ScrolledWindow object
+@param controler: _EthercatSlaveCTN class in EthercatSlave.py
+@param node_editor: Reference to Beremiz frame
+"""
+wx.Treebook.__init__(self, parent, -1, size=wx.DefaultSize, style=wx.BK_DEFAULT)
+self.parent = parent
+self.Controler = controler
+self.NodeEditor = node_editor
+self.EtherCATManagementClassObject = {}
+# fill EtherCAT Management Treebook
+for pname, pclass, subs in [
+("Slave State",        SlaveStatePanelClass, []),
+("SDO Management",     SDOPanelClass, []),
+("PDO Monitoring",     PDOPanelClass, []),
+("ESC Management",     EEPROMAccessPanel, [
+("Smart View", SlaveSiiSmartView),
+("Hex View", HexView)]),
+("Register Access",     RegisterAccessPanel, [])]:
+self.AddPage(pclass(self, self.Controler), pname)
+for spname, spclass in subs:
+self.AddSubPage(spclass(self, self.Controler), spname)
+self.Bind(wx.EVT_TREEBOOK_PAGE_CHANGED, self.OnPageChanged)
+self.Bind(wx.EVT_TREEBOOK_PAGE_CHANGING, self.OnPageChanging)
+def OnPageChanged(self, event):
+old = event.GetOldSelection()
+new = event.GetSelection()
+sel = event.GetSelection()
+event.Skip()
+def OnPageChanging(self, event):
+old = event.GetOldSelection()
+new = event.GetSelection()
+sel = event.GetSelection()
+event.Skip()
+#-------------------------------------------------------------------------------
+#                    For SlaveState Panel
+#-------------------------------------------------------------------------------
+class SlaveStatePanelClass(wx.Panel):
+def __init__(self, parent, controler):
+"""
+Constructor
+@param parent: Reference to the parent EtherCATManagementTreebook class
+@param controler: _EthercatSlaveCTN class in EthercatSlave.py
+"""
+wx.Panel.__init__(self, parent, -1, (0, 0), size=wx.DefaultSize, style = wx.SUNKEN_BORDER)
+self.Controler = controler
+self.parent = parent
+# initialize SlaveStatePanel UI dictionaries
+self.StaticBoxDic = {}
+self.StaticTextDic = {}
+self.TextCtrlDic = {}
+self.ButtonDic = {}
+# iniitalize BoxSizer and FlexGridSizer
+self.SizerDic = {
+"SlaveState_main_sizer" : wx.BoxSizer(wx.VERTICAL),
+"SlaveState_inner_main_sizer" : wx.FlexGridSizer(cols=1, hgap=50, rows=3, vgap=10),
+"SlaveInfosDetailsInnerSizer" : wx.FlexGridSizer(cols=4, hgap=10, rows=2, vgap=10),
+"SyncManagerInnerSizer" : wx.FlexGridSizer(cols=1, hgap=5, rows=1, vgap=5),
+"SlaveState_sizer" : wx.FlexGridSizer(cols=1, hgap=10, rows=2, vgap=10),
+"SlaveState_up_sizer" : wx.FlexGridSizer(cols=4, hgap=10, rows=2, vgap=10),
+"SlaveState_down_sizer" : wx.FlexGridSizer(cols=2, hgap=10, rows=1, vgap=10)}
+# initialize StaticBox and StaticBoxSizer
+for box_name, box_label in [
+("SlaveInfosDetailsBox", "Slave Informations"),
+("SyncManagerBox", "Sync Manager"),
+("SlaveStateBox", "Slave State Transition && Monitoring")]:
+self.StaticBoxDic[box_name] = wx.StaticBox(self, label=_(box_label))
+self.SizerDic[box_name] = wx.StaticBoxSizer(self.StaticBoxDic[box_name])
+for statictext_name, statictext_label, textctrl_name in [
+("VendorLabel", "Vendor:", "vendor"),
+("ProductcodeLabel", "Product code:", "product_code"),
+("RevisionnumberLabel", "Slave Count:", "revision_number"),
+("PhysicsLabel", "Physics:", "physics")]:
+self.StaticTextDic[statictext_name] = wx.StaticText(self, label=_(statictext_label))
+self.TextCtrlDic[textctrl_name] = wx.TextCtrl(self, size=wx.Size(130, 24), style=wx.TE_READONLY)
+self.SizerDic["SlaveInfosDetailsInnerSizer"].AddMany([self.StaticTextDic[statictext_name],
+self.TextCtrlDic[textctrl_name]])
+self.SizerDic["SlaveInfosDetailsBox"].AddSizer(self.SizerDic["SlaveInfosDetailsInnerSizer"])
+self.SyncManagersGrid = CustomGrid(self, size=wx.Size(605,155), style=wx.VSCROLL)
+self.SizerDic["SyncManagerInnerSizer"].Add(self.SyncManagersGrid)
+self.SizerDic["SyncManagerBox"].Add(self.SizerDic["SyncManagerInnerSizer"])
+for button_name, button_id, button_label, button_tooltipstring, event_method, sub_item in [
+("InitButton",   0, "INIT", "State Transition to \"Init\" State",     self.OnButtonClick, []),
+("PreOPButton",  1, "PREOP", "State Transition to \"PreOP\" State",   self.OnButtonClick, [
+("TargetStateLabel", "Target State:" , "TargetState")]),
+("SafeOPButton", 2, "SAFEOP", "State Transition to \"SafeOP\" State", self.OnButtonClick, []),
+("OPButton",     3, "OP",  "State Transition to \"OP\" State",        self.OnButtonClick, [
+("CurrentStateLabel", "Current State:", "CurrentState")])]:
+self.ButtonDic[button_name] = wx.Button(self, id=button_id ,label=_(button_label))
+self.ButtonDic[button_name].Bind(wx.EVT_BUTTON, event_method)
+self.ButtonDic[button_name].SetToolTipString(button_tooltipstring)
+self.SizerDic["SlaveState_up_sizer"].Add(self.ButtonDic[button_name])
+for statictext_name, statictext_label, textctrl_name in sub_item :
+self.StaticTextDic[statictext_name] = wx.StaticText(self, label=_(statictext_label))
+self.TextCtrlDic[textctrl_name] = wx.TextCtrl(self, size=wx.DefaultSize, style=wx.TE_READONLY)
+self.SizerDic["SlaveState_up_sizer"].AddMany([self.StaticTextDic[statictext_name],
+self.TextCtrlDic[textctrl_name]])
+for button_name, button_label, button_tooltipstring, event_method in [
+("StartTimerButton", "Start State Monitoring", "Slave State Update Restart", self.StartTimer),
+("StopTimerButton", "Stop State Monitoring", "Slave State Update Stop", self.CurrentStateThreadStop)]:
+self.ButtonDic[button_name] = wx.Button(self, label=_(button_label))
+self.ButtonDic[button_name].Bind(wx.EVT_BUTTON, event_method)
+self.ButtonDic[button_name].SetToolTipString(button_tooltipstring)
+self.SizerDic["SlaveState_down_sizer"].Add(self.ButtonDic[button_name])
+self.SizerDic["SlaveState_sizer"].AddMany([self.SizerDic["SlaveState_up_sizer"],
+self.SizerDic["SlaveState_down_sizer"]])
+self.SizerDic["SlaveStateBox"].Add(self.SizerDic["SlaveState_sizer"])
+self.SizerDic["SlaveState_inner_main_sizer"].AddMany([
+self.SizerDic["SlaveInfosDetailsBox"], self.SizerDic["SyncManagerBox"],
+self.SizerDic["SlaveStateBox"]])
+self.SizerDic["SlaveState_main_sizer"].Add(self.SizerDic["SlaveState_inner_main_sizer"])
+self.SetSizer(self.SizerDic["SlaveState_main_sizer"])
+# register a timer for periodic exectuion of slave state update (period: 1000 ms)
+self.Bind(wx.EVT_TIMER, self.GetCurrentState)
+self.CreateSyncManagerTable()
+self.Centre()
+def CreateSyncManagerTable(self):
+"""
+Create grid for "SyncManager"
+"""
+# declare Table object
+self.SyncManagersTable = SyncManagersTable(self, [], GetSyncManagersTableColnames())
+self.SyncManagersGrid.SetTable(self.SyncManagersTable)
+# set grid alignment attr. (CENTER)
+self.SyncManagersGridColAlignements = [wx.ALIGN_CENTRE, wx.ALIGN_CENTRE, wx.ALIGN_CENTRE,
+wx.ALIGN_CENTRE, wx.ALIGN_CENTRE, wx.ALIGN_CENTRE]
+# set grid size
+self.SyncManagersGridColSizes = [40, 150, 100, 100, 100, 100]
+self.SyncManagersGrid.SetRowLabelSize(0)
+for col in range(self.SyncManagersTable.GetNumberCols()):
+attr = wx.grid.GridCellAttr()
+attr.SetAlignment(self.SyncManagersGridColAlignements[col], wx.ALIGN_CENTRE)
+self.SyncManagersGrid.SetColAttr(col, attr)
+self.SyncManagersGrid.SetColMinimalWidth(col, self.SyncManagersGridColSizes[col])
+self.SyncManagersGrid.AutoSizeColumn(col, False)
+self.RefreshSlaveInfos()
+def RefreshSlaveInfos(self):
+"""
+Fill data in "Slave Information" and "SyncManager"
+"""
+slave_infos = self.Controler.GetSlaveInfos()
+sync_manager_section = ["vendor", "product_code", "revision_number", "physics"]
+if slave_infos is not None:
+# this method is same as "TextCtrl.SetValue"
+for textctrl_name in sync_manager_section:
+self.TextCtrlDic[textctrl_name].SetValue(slave_infos[textctrl_name])
+self.SyncManagersTable.SetData(slave_infos["sync_managers"])
+self.SyncManagersTable.ResetView(self.SyncManagersGrid)
+else:
+for textctrl_name in sync_manager_section:
+self.TextCtrlDic[textctrl_name].SetValue("")
+self.SyncManagersTable.SetData([])
+self.SyncManagersTable.ResetView(self.SyncManagersGrid)
+def OnButtonClick(self, event):
+"""
+Event handler for slave state transition button click (Init, PreOP, SafeOP, OP button)
+@param event : wx.EVT_BUTTON object
+"""
+check_connect_flag = self.Controler.CommonMethod.CheckConnect(False)
+if check_connect_flag :
+state_dic = ["INIT", "PREOP", "SAFEOP", "OP"]
+# If target state is one of {INIT, PREOP, SAFEOP}, request slave state transition immediately.
+if event.GetId() < 3 :
+self.Controler.CommonMethod.RequestSlaveState(state_dic[event.GetId()])
+self.TextCtrlDic["TargetState"].SetValue(state_dic[event.GetId()])
+# If target state is OP, first check "PLC status".
+#  (1) If current PLC status is "Started", then request slave state transition
+#  (2) Otherwise, show error message and return
+else :
+status, count = self.Controler.GetCTRoot()._connector.GetPLCstatus()
+if status == "Started" :
+self.Controler.CommonMethod.RequestSlaveState("OP")
+self.TextCtrlDic["TargetState"].SetValue("OP")
+else :
+self.Controler.CommonMethod.CreateErrorDialog("PLC is Not Started")
+def GetCurrentState(self, event):
+"""
+Timer event handler for periodic slave state monitoring (Default period: 1 sec = 1000 msec).
+@param event : wx.TIMER object
+"""
+check_connect_flag = self.Controler.CommonMethod.CheckConnect(True)
+if check_connect_flag:
+returnVal = self.Controler.CommonMethod.GetSlaveStateFromSlave()
+line = returnVal.split("\n")
+try :
+self.SetCurrentState(line[self.Controler.GetSlavePos()])
+except :
+pass
+def SetCurrentState(self, line):
+"""
+Show current slave state using the executiob result of "ethercat slaves" command.
+@param line : result of "ethercat slaves" command
+"""
+state_array = ["INIT", "PREOP", "SAFEOP", "OP"]
+try :
+# parse the execution result of  "ethercat slaves" command
+# Result example : 0  0:0  PREOP  +  EL9800 (V4.30) (PIC24, SPI, ET1100)
+token = line.split("  ")
+if token[2] in state_array:
+self.TextCtrlDic["CurrentState"].SetValue(token[2])
+except :
+pass
+def StartTimer(self, event):
+"""
+Event handler for "Start State Monitoring" button.
+- start slave state monitoring thread
+@param event : wx.EVT_BUTTON object
+"""
+self.SlaveStateThread = wx.Timer(self)
+# set timer period (1000 ms)
+self.SlaveStateThread.Start(1000)
+def CurrentStateThreadStop(self, event):
+"""
+Event handler for "Stop State Monitoring" button.
+- stop slave state monitoring thread
+@param event : wx.EVT_BUTTON object
+"""
+try:
+self.SlaveStateThread.Stop()
+except:
+pass
+#-------------------------------------------------------------------------------
+#                    For SDO Management Panel
+#-------------------------------------------------------------------------------
+class SDOPanelClass(wx.Panel):
+def __init__(self, parent, controler):
+"""
+Constructor
+@param parent: Reference to the parent EtherCATManagementTreebook class
+@param controler: _EthercatSlaveCTN class in EthercatSlave.py
+"""
+wx.Panel.__init__(self, parent, -1)
+self.DatatypeDescription, self.CommunicationObject, self.ManufacturerSpecific, \
+self.ProfileSpecific, self.Reserved, self.AllSDOData = range(6)
+self.Controler = controler
+self.SDOManagementMainSizer = wx.BoxSizer(wx.VERTICAL)
+self.SDOManagementInnerMainSizer = wx.FlexGridSizer(cols=1, hgap=10, rows=2, vgap=10)
+self.SDOUpdate = wx.Button(self, label=_('update'))
+self.SDOUpdate.Bind(wx.EVT_BUTTON, self.SDOInfoUpdate)
+self.CallSDONoteBook = SDONoteBook(self, controler=self.Controler)
+self.SDOManagementInnerMainSizer.Add(self.SDOUpdate)
+self.SDOManagementInnerMainSizer.Add(self.CallSDONoteBook, wx.ALL | wx.EXPAND)
+self.SDOManagementMainSizer.Add(self.SDOManagementInnerMainSizer)
+self.SetSizer(self.SDOManagementMainSizer)
+def SDOInfoUpdate(self, event):
+"""
+Evenet handler for SDO "update" button.
+- Load SDO data from current slave
+@param event : wx.EVT_BUTTON object
+"""
+self.Controler.CommonMethod.SaveSDOData = []
+self.Controler.CommonMethod.ClearSDODataSet()
+self.SDOFlag = False
+# Check whether beremiz connected or not.
+check_connect_flag = self.Controler.CommonMethod.CheckConnect(False)
+if check_connect_flag:
+self.SDOs = self.Controler.CommonMethod.GetSlaveSDOFromSlave()
+# SDOFlag is "False", user click "Cancel" button
+self.SDOFlag = self.SDOParser()
+if self.SDOFlag :
+self.CallSDONoteBook.CreateNoteBook()
+self.Refresh()
+def SDOParser(self):
+"""
+Parse SDO data set that obtain "SDOInfoUpdate" Method
+@return True or False
+"""
+slaveSDO_progress = wx.ProgressDialog("Slave SDO Monitoring", "Now Uploading...",
+maximum = len(self.SDOs.splitlines()), parent=self,
+style = wx.PD_CAN_ABORT | wx.PD_APP_MODAL | wx.PD_ELAPSED_TIME |
+wx.PD_ESTIMATED_TIME | wx.PD_REMAINING_TIME |
+wx.PD_AUTO_HIDE | wx.PD_SMOOTH)
+# If keep_going flag is False, SDOParser method is stop and return "False".
+keep_going = True
+count = 0
+# SDO data example
+# SDO 0x1000, "Device type"
+# 0x1000:00,r-r-r-,uint32,32 bit,"Device type",0x00020192, 131474
+for details_line in self.SDOs.splitlines():
+count += 1
+line_token = details_line.split("\"")
+# len(line_token[2]) case : SDO 0x1000, "Device type"
+if len(line_token[2]) == 0:
+title_name = line_token[1]
+# else case : 0x1000:00,r-r-r-,uint32,32 bit,"Device type",0x00020192, 131474
+else :
+# line_token = ['0x1000:00,r-r-r-,uint32,32 bit,', 'Device type', ',0x00020192, 131474']
+token_head, name, token_tail = line_token
+# token_head = ['0x1000:00', 'r-r-r-', 'uint32', '32 bit', '']
+token_head = token_head.split(",")
+ful_idx, access, type, size, empty = token_head
+# ful_idx.split(":") = ['0x1000', '00']
+idx, sub_idx = ful_idx.split(":")
+# token_tail = ['', '0x00020192', '131474']
+token_tail = token_tail.split(",")
+try :
+empty, hex_val, dec_val = token_tail
+# SDO data is not return "dec value"
+# line example :
+# 0x1702:01,rwr-r-,uint32,32 bit," 1st mapping", ----
+except :
+empty, hex_val = token_tail
+name_after_check = self.StringTest(name)
+# convert hex type
+sub_idx = "0x" + sub_idx
+if type == "octet_string":
+hex_val = ' ---- '
+# SResult of SlaveSDO data parsing. (data type : dictionary)
+self.Data = {'idx':idx.strip(), 'subIdx':sub_idx.strip(), 'access':access.strip(),
+'type':type.strip(), 'size':size.strip(),  'name':name_after_check.strip("\""),
+'value':hex_val.strip(), "category":title_name.strip("\"")}
+category_divide_value = [0x1000, 0x2000, 0x6000, 0xa000, 0xffff]
+for count in range(len(category_divide_value)) :
+if int(idx, 0) < category_divide_value[count]:
+self.Controler.CommonMethod.SaveSDOData[count].append(self.Data)
+break
+self.Controler.CommonMethod.SaveSDOData[self.AllSDOData].append(self.Data)
+if count >= len(self.SDOs.splitlines()) / 2:
+(keep_going, skip) = slaveSDO_progress.Update(count, "Please waiting a moment!!")
+else:
+(keep_going, skip) = slaveSDO_progress.Update(count)
+# If user click "Cancel" loop suspend immediately
+if (keep_going == False):
+break
+slaveSDO_progress.Destroy()
+return keep_going
+def StringTest(self, check_string):
+"""
+Test value 'name' is alphanumeric
+@param check_string : input data for check
+@return result : output data after check
+"""
+# string.printable is print this result
+#'0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ
+#!"#$%&\'()*+,-./:;<=>?@[\\]^_`{|}~ \t\n\r\x0b\x0c
+allow_range = string.printable
+result = check_string
+for i in range(0, len(check_string)):
+# string.isalnum() is check whether string is alphanumeric or not
+if check_string[len(check_string)-1-i:len(check_string)-i] in allow_range :
+result = check_string[:len(check_string) - i]
+break
+return result
+#-------------------------------------------------------------------------------
+#                    For SDO Notebook (divide category)
+#-------------------------------------------------------------------------------
+class SDONoteBook(wx.Notebook):
+def __init__(self, parent, controler):
+"""
+Constructor
+@param parent: Reference to the parent SDOPanelClass class
+@param controler: _EthercatSlaveCTN class in EthercatSlave.py
+"""
+wx.Notebook.__init__(self, parent, id = -1, size=(850,500))
+self.Controler = controler
+self.parent = parent
+self.CreateNoteBook()
+self.Bind(wx.EVT_CHOICEBOOK_PAGE_CHANGED, self.OnPageChanged)
+self.Bind(wx.EVT_CHOICEBOOK_PAGE_CHANGING, self.OnPageChanging)
+def CreateNoteBook(self):
+"""
+Create each NoteBook page, divided SDO index
+According to EtherCAT Communication(03/2011), 158p
+"""
+self.Data = []
+count = 1
+page_texts = [("all", self.parent.AllSDOData),
+("0x0000 - 0x0ff", self.parent.DatatypeDescription),
+("0x1000 - 0x1fff", self.parent.CommunicationObject),
+("0x2000 - 0x5fff", self.parent.ManufacturerSpecific),
+("0x6000 - 0x9fff", self.parent.ProfileSpecific),
+("0xa000 - 0xffff", self.parent.Reserved)]
+page_tooltip_string = ["SDO Index 0x0000 - 0x0fff : Data Type Description",
+"SDO Index 0x1000 - 0x1fff : Communication object",
+"SDO Index 0x2000 - 0x5fff : Manufacturer specific",
+"SDO Index 0x6000 - 0x9fff : Profile specific",
+"SDO Index 0xa000 - 0xffff : Reserved",
+"All SDO Object"]
+self.DeleteAllPages()
+for txt, count in page_texts:
+self.Data = self.Controler.CommonMethod.SaveSDOData[count]
+self.Win = SlaveSDOTable(self, self.Data)
+self.AddPage(self.Win, txt)
+def OnPageChanged(self, event):
+old = event.GetOldSelection()
+new = event.GetSelection()
+sel = self.GetSelection()
+event.Skip()
+def OnPageChanging(self, event):
+old = event.GetOldSelection()
+new = event.GetSelection()
+sel = self.GetSelection()
+event.Skip()
+#-------------------------------------------------------------------------------
+#                    For SDO Grid (fill index, subindex, etc...)
+#-------------------------------------------------------------------------------
+class SlaveSDOTable(wx.grid.Grid):
+def __init__(self, parent, data):
+"""
+Constructor
+@param parent: Reference to the parent SDOPanelClass class
+@param data: SDO data after parsing "SDOParser" method
+"""
+wx.grid.Grid.__init__(self, parent, -1, size=(830,490),
+style=wx.EXPAND|wx.ALIGN_CENTRE_HORIZONTAL|wx.ALIGN_CENTER_VERTICAL)
+self.Controler = parent.Controler
+self.parent = parent
+self.SDOFlag = True
+if data is None :
+self.SDOs = []
+else :
+self.SDOs = data
+self.CreateGrid(len(self.SDOs), 8)
+SDOCellSize = [(0, 65), (1, 65), (2, 50), (3, 55),
+(4, 40), (5, 200), (6, 250), (7, 85)]
+for (index, size) in SDOCellSize:
+self.SetColSize(index, size)
+self.SetRowLabelSize(0)
+SDOTableLabel = [(0, "Index"), (1, "Subindex"), (2, "Access"),
+(3, "Type"), (4, "Size"), (5, "Category"),
+(6, "Name"), (7, "Value")]
+for (index, label) in SDOTableLabel:
+self.SetColLabelValue(index, label)
+self.SetColLabelAlignment(index, wx.ALIGN_CENTRE)
+attr = wx.grid.GridCellAttr()
+# for SDO download
+self.Bind(gridlib.EVT_GRID_CELL_LEFT_DCLICK, self.SDOModifyDialog)
+for i in range(7):
+self.SetColAttr(i,attr)
+self.SetColLabelAlignment(wx.ALIGN_CENTER, wx.ALIGN_CENTER)
+self.SetTableValue()
+def SetTableValue(self):
+"""
+Cell is filled by new parsing data
+"""
+sdo_list = ['idx', 'subIdx', 'access', 'type', 'size', 'category', 'name', 'value']
+for row_idx in range(len(self.SDOs)):
+for col_idx in range(len(self.SDOs[row_idx])):
+self.SetCellValue(row_idx, col_idx, self.SDOs[row_idx][sdo_list[col_idx]])
+self.SetReadOnly(row_idx, col_idx, True)
+if col_idx < 5 :
+self.SetCellAlignment(row_idx, col_idx, wx.ALIGN_CENTRE, wx.ALIGN_CENTRE)
+def CheckSDODataAccess(self, row):
+"""
+CheckSDODataAccess method is checking that access data has "w"
+Access field consist 6 char, if mean
+rw      rw     rw
+(preop) (safeop) (op)
+Example Access field : rwrwrw, rwrw--
+@param row : Selected cell by user
+@return Write_flag : If data has "w", flag is true
+"""
+write_flag = False
+check = self.SDOs[row]['access']
+if check[1:2] == 'w' :
+self.Controler.CommonMethod.Check_PREOP = True
+write_flag = True
+if check[3:4] == 'w' :
+self.Controler.CommonMethod.Check_SAFEOP = True
+write_flag = True
+if check[5:] =='w' :
+self.Controler.CommonMethod.Check_OP = True
+write_flag = True
+return write_flag
+def DecideSDODownload(self, state):
+"""
+compare current state and "access" field,
+result notify SDOModifyDialog method
+@param state : current slave state
+@return True or False
+"""
+# Example of 'state' parameter : "0  0:0  PREOP  +  EL9800 (V4.30) (PIC24, SPI, ET1100)"
+state = state[self.Controler.GetSlavePos()].split("  ")[2]
+if state == "PREOP" and self.Controler.CommonMethod.Check_PREOP :
+return True
+elif state == "SAFEOP" and self.Controler.CommonMethod.Check_SAFEOP :
+return True
+elif state == "OP" and self.Controler.CommonMethod.Check_OP :
+return True
+return False
+def ClearStateFlag(self):
+"""
+Initialize StateFlag
+StateFlag is notice SDOData access each slave state
+"""
+self.Controler.CommonMethod.Check_PREOP = False
+self.Controler.CommonMethod.Check_SAFEOP = False
+self.Controler.CommonMethod.Check_OP = False
+def SDOModifyDialog (self, event):
+"""
+Create dialog for SDO value modify
+if user enter data, perform command "ethercat download"
+@param event : gridlib.EVT_GRID_CELL_LEFT_DCLICK object
+"""
+self.ClearStateFlag()
+# CheckSDODataAccess is checking that OD(Object Dictionary) has "w"
+if event.GetCol() == 7 and self.CheckSDODataAccess(event.GetRow()) :
+dlg = wx.TextEntryDialog (self, "Enter hex or dec value (if enter dec value, it automatically conversed hex value)",
+"SDOModifyDialog", style = wx.OK | wx.CANCEL)
+start_value = self.GetCellValue(event.GetRow(), event.GetCol())
+dlg.SetValue(start_value)
+if dlg.ShowModal() == wx.ID_OK:
+try :
+int(dlg.GetValue(), 0)
+# check "Access" field
+if self.DecideSDODownload(self.Controler.CommonMethod.SlaveState[self.Controler.GetSlavePos()]) :
+# Request "SDODownload"
+self.Controler.CommonMethod.SDODownload(self.SDOs[event.GetRow()]['type'], self.SDOs[event.GetRow()]['idx'],
+self.SDOs[event.GetRow()]['subIdx'], dlg.GetValue())
+self.SetCellValue(event.GetRow(), event.GetCol(), hex(int(dlg.GetValue(), 0)))
+else :
+self.Controler.CommonMethod.CreateErrorDialog('You cannot SDO download this state')
+# Error occured process of "int(variable)"
+# User input is not hex, dec value
+except ValueError:
+self.Controler.CommonMethod.CreateErrorDialog('You can input only hex, dec value')
+#-------------------------------------------------------------------------------
+#                 For PDO Monitoring Panel
+# PDO Class UI  : Panel -> Choicebook (RxPDO, TxPDO) ->
+#                 Notebook (PDO Index) -> Grid (PDO entry)
+#-------------------------------------------------------------------------------
+class PDOPanelClass(wx.Panel):
+def __init__(self, parent, controler):
+"""
+Constructor
+@param parent: Reference to the parent EtherCATManagementTreebook class
+@param controler: _EthercatSlaveCTN class in EthercatSlave.py
+"""
+wx.Panel.__init__(self, parent, -1)
+self.Controler = controler
+self.PDOMonitoringEditorMainSizer = wx.BoxSizer(wx.VERTICAL)
+self.PDOMonitoringEditorInnerMainSizer = wx.FlexGridSizer(cols=1, hgap=10, rows=2, vgap=10)
+self.CallPDOChoicebook = PDOChoicebook(self, controler=self.Controler)
+self.PDOMonitoringEditorInnerMainSizer.Add(self.CallPDOChoicebook, wx.ALL)
+self.PDOMonitoringEditorMainSizer.Add(self.PDOMonitoringEditorInnerMainSizer)
+self.SetSizer(self.PDOMonitoringEditorMainSizer)
+def PDOInfoUpdate(self):
+"""
+Call RequestPDOInfo method and create Choicebook
+"""
+self.Controler.CommonMethod.RequestPDOInfo()
+self.CallPDOChoicebook.Destroy()
+self.CallPDOChoicebook = PDOChoicebook(self, controler=self.Controler)
+self.Refresh()
+#-------------------------------------------------------------------------------
+#                    For PDO Choicebook (divide Tx, Rx PDO)
+#-------------------------------------------------------------------------------
+class PDOChoicebook(wx.Choicebook):
+def __init__(self, parent, controler):
+"""
+Constructor
+@param parent: Reference to the parent PDOPanelClass class
+@param controler: _EthercatSlaveCTN class in EthercatSlave.py
+"""
+wx.Choicebook.__init__(self, parent, id=-1, size=(500, 500), style=wx.CHB_DEFAULT)
+self.Controler = controler
+RxWin = PDONoteBook(self, controler=self.Controler, name="Rx")
+TxWin = PDONoteBook(self, controler=self.Controler, name="Tx")
+self.AddPage(RxWin, "RxPDO")
+self.AddPage(TxWin, "TxPDO")
+self.Bind(wx.EVT_CHOICEBOOK_PAGE_CHANGED, self.OnPageChanged)
+self.Bind(wx.EVT_CHOICEBOOK_PAGE_CHANGING, self.OnPageChanging)
+def OnPageChanged(self, event):
+old = event.GetOldSelection()
+new = event.GetSelection()
+sel = self.GetSelection()
+event.Skip()
+def OnPageChanging(self, event):
+old = event.GetOldSelection()
+new = event.GetSelection()
+sel = self.GetSelection()
+event.Skip()
+#-------------------------------------------------------------------------------
+#                    For PDO Notebook (divide PDO index)
+#-------------------------------------------------------------------------------
+class PDONoteBook(wx.Notebook):
+def __init__(self, parent, name, controler):
+"""
+Constructor
+@param parent: Reference to the parent PDOChoicebook class
+@param name: identifier whether RxPDO or TxPDO
+@param controler: _EthercatSlaveCTN class in EthercatSlave.py
+"""
+wx.Notebook.__init__(self, parent, id=-1, size=(640, 400))
+self.Controler = controler
+count = 0
+page_texts = []
+self.Controler.CommonMethod.RequestPDOInfo()
+if name == "Tx" :
+# obtain pdo_info and pdo_entry
+# pdo_info include (PDO index, name, number of entry)
+pdo_info =  self.Controler.CommonMethod.GetTxPDOCategory()
+pdo_entry = self.Controler.CommonMethod.GetTxPDOInfo()
+for tmp in pdo_info :
+title = str(hex(tmp['pdo_index']))
+page_texts.append(title)
+# RX PDO case
+else :
+pdo_info = self.Controler.CommonMethod.GetRxPDOCategory()
+pdo_entry = self.Controler.CommonMethod.GetRxPDOInfo()
+for tmp in pdo_info :
+title = str(hex(tmp['pdo_index']))
+page_texts.append(title)
+# Add page depending on the number of pdo_info
+for txt in page_texts:
+win = PDOEntryTable(self, pdo_info, pdo_entry, count)
+self.AddPage(win, txt)
+count += 1
+self.Bind(wx.EVT_CHOICEBOOK_PAGE_CHANGED, self.OnPageChanged)
+self.Bind(wx.EVT_CHOICEBOOK_PAGE_CHANGING, self.OnPageChanging)
+def OnPageChanged(self, event):
+old = event.GetOldSelection()
+new = event.GetSelection()
+sel = self.GetSelection()
+event.Skip()
+def OnPageChanging(self, event):
+old = event.GetOldSelection()
+new = event.GetSelection()
+sel = self.GetSelection()
+event.Skip()
+#-------------------------------------------------------------------------------
+#                    For PDO Grid (fill entry index, subindex etc...)
+#-------------------------------------------------------------------------------
+class PDOEntryTable(wx.grid.Grid):
+def __init__(self, parent, info, entry, count):
+"""
+Constructor
+@param parent: Reference to the parent PDONoteBook class
+@param info : data structure including entry index, sub index, name, length, type
+@param entry : data structure including index, name, entry number
+@param count : page number
+"""
+wx.grid.Grid.__init__(self, parent, -1, size=(500, 400), pos=wx.Point(0,0),
+style=wx.EXPAND|wx.ALIGN_CENTRE_HORIZONTAL|wx.ALIGN_CENTER_VERTICAL)
+self.Controler = parent.Controler
+self.PDOInfo = info
+self.PDOEntry = entry
+self.Count = count
+self.CreateGrid(self.PDOInfo[self.Count]['number_of_entry'], 5)
+self.SetColLabelSize(25)
+self.SetRowLabelSize(0)
+PDOTableLabel = [(0, "Index"), (1, "Subindex"), (2, "Length"),
+(3, "Type"), (4, "Name")]
+for (index, label) in PDOTableLabel:
+self.SetColLabelValue(index, label)
+PDOCellSize = [(0, 45), (1, 65), (2, 55), (3, 40), (4, 300)]
+for (index, size) in PDOCellSize:
+self.SetColSize(index, size)
+self.SetColLabelAlignment(index, wx.ALIGN_LEFT)
+attr = wx.grid.GridCellAttr()
+for i in range(5):
+self.SetColAttr(i, attr)
+self.SetTableValue()
+def SetTableValue(self):
+"""
+Cell is filled by new parsing data in XML
+"""
+list_index = 0
+# number of entry
+for i in range(self.Count + 1) :
+list_index += self.PDOInfo[i]['number_of_entry']
+start_value = list_index - self.PDOInfo[self.Count]['number_of_entry']
+pdo_list = ['entry_index', 'subindex', 'bitlen', 'type', 'name']
+for row_idx in range(self.PDOInfo[self.Count]['number_of_entry']):
+for col_idx in range(len(self.PDOEntry[row_idx])):
+# entry index is converted hex value.
+if col_idx == 0 :
+self.SetCellValue(row_idx, col_idx, hex(self.PDOEntry[start_value][pdo_list[col_idx]]))
+else :
+self.SetCellValue(row_idx, col_idx, str(self.PDOEntry[start_value][pdo_list[col_idx]]))
+if col_idx != 4 :
+self.SetCellAlignment(row_idx, col_idx, wx.ALIGN_CENTRE, wx.ALIGN_CENTRE)
+else :
+self.SetCellAlignment(row_idx, col_idx, wx.ALIGN_LEFT, wx.ALIGN_CENTRE)
+self.SetReadOnly(row_idx, col_idx, True)
+self.SetRowSize(row_idx, 25)
+start_value += 1
+#-------------------------------------------------------------------------------
+#                    For EEPROM Access Main Panel
+#                 (This class explain EEPROM Access)
+#-------------------------------------------------------------------------------
+class EEPROMAccessPanel(wx.Panel):
+def __init__(self, parent, controler):
+"""
+Constructor
+@param parent: Reference to the parent EtherCATManagementTreebook class
+@param controler: _EthercatSlaveCTN class in EthercatSlave.py
+"""
+wx.Panel.__init__(self, parent, -1)
+sizer = wx.FlexGridSizer(cols=1, hgap=20,rows=3, vgap=20)
+line = wx.StaticText(self, -1, "\n  EEPROM Access is composed to SmartView and HexView. \
+\n\n   - SmartView shows Config Data, Device Identity, Mailbox settings, etc. \
+\n\n   - HexView shows EEPROM's contents.")
+sizer.Add(line)
+self.SetSizer(sizer)
+#-------------------------------------------------------------------------------
+#                    For Smart View Panel
+#-------------------------------------------------------------------------------
+class SlaveSiiSmartView(wx.Panel):
+def __init__(self, parent, controler):
+"""
+Constructor
+@param parent: Reference to the parent EtherCATManagementTreebook class
+@param controler: _EthercatSlaveCTN class in EthercatSlave.py
+"""
+wx.Panel.__init__(self, parent, -1)
+self.parent = parent
+self.Controler = controler
+self.PDIType = {0  :['none', '00000000'],
+4  :['Digital I/O', '00000100'],
+5  :['SPI Slave', '00000101'],
+7  :['EtherCAT Bridge (port3)', '00000111'],
+8  :['uC async. 16bit', '00001000'],
+9  :['uC async. 8bit', '00001001'],
+10 :['uC sync. 16bit', '00001010'],
+11 :['uC sync. 8bit', '00001011'],
+16 :['32 Digtal Input and 0 Digital Output', '00010000'],
+17 :['24 Digtal Input and 8 Digital Output', '00010001'],
+18 :['16 Digtal Input and 16 Digital Output','00010010'],
+19 :['8 Digtal Input and 24 Digital Output', '00010011'],
+20 :['0 Digtal Input and 32 Digital Output', '00010100'],
+128:['On-chip bus', '11111111']
+}
+sizer = wx.FlexGridSizer(cols=1, hgap=5, rows=2, vgap=5)
+button_sizer = wx.FlexGridSizer(cols=2, hgap=5, rows=1, vgap=5)
+for button, mapping_method in [("Write EEPROM", self.WriteToEEPROM),
+("Read EEPROM", self.ReadFromEEPROM)]:
+btn = wx.Button(self, -1, button, size=(150, 40))
+button_sizer.Add(btn, border=10, flag=wx.ALL)
+btn.Bind(wx.EVT_BUTTON, mapping_method)
+self.TreeListCtrl = SmartViewTreeListCtrl(self, self.Controler)
+sizer.Add(button_sizer, border=10, flag=wx.ALL)
+sizer.Add(self.TreeListCtrl, border=10, flag=wx.ALL)
+self.SetSizer(sizer)
+self.Create_SmartView()
+def Create_SmartView(self):
+"""
+SmartView shows information based on XML as initial value.
+"""
+self.Controler.CommonMethod.SmartViewInfosFromXML = self.Controler.CommonMethod.GetSmartViewInfos()
+self.SetXMLData()
+def WriteToEEPROM(self, event):
+"""
+Open binary file (user select) and write the selected binary data to EEPROM
+@param event : wx.EVT_BUTTON object
+"""
+# Check whether beremiz connected or not, and whether status is "Started" or not.
+check_connect_flag = self.Controler.CommonMethod.CheckConnect(False)
+if check_connect_flag:
+status, count = self.Controler.GetCTRoot()._connector.GetPLCstatus()
+if status is not "Started":
+dialog = wx.FileDialog(self, _("Choose a binary file"), os.getcwd(), "",  _("bin files (*.bin)|*.bin"), wx.OPEN)
+if dialog.ShowModal() == wx.ID_OK:
+filepath = dialog.GetPath()
+try:
+binfile = open(filepath,"rb")
+self.SiiBinary = binfile.read()
+dialog.Destroy()
+self.Controler.CommonMethod.SiiWrite(self.SiiBinary)
+# refresh data structure kept by master
+self.Controler.CommonMethod.Rescan()
+# save binary data as inner global data of beremiz
+# for fast loading when slave plugin node is reopened.
+self.Controler.CommonMethod.SiiData = self.SiiBinary
+self.SetEEPROMData()
+except:
+self.Controler.CommonMethod.CreateErrorDialog('The file does not exist!')
+dialog.Destroy()
+def ReadFromEEPROM(self, event):
+"""
+Refresh displayed data based on slave EEPROM and save binary file through dialog
+@param event : wx.EVT_BUTTON object
+"""
+# Check whether beremiz connected or not.
+check_connect_flag = self.Controler.CommonMethod.CheckConnect(False)
+if check_connect_flag:
+self.SiiBinary = self.Controler.CommonMethod.LoadData()
+self.SetEEPROMData()
+dialog = wx.FileDialog(self, _("Save as..."), os.getcwd(),
+"slave0.bin",  _("bin files (*.bin)|*.bin|All files|*.*"),
+wx.SAVE|wx.OVERWRITE_PROMPT)
+if dialog.ShowModal() == wx.ID_OK:
+filepath = dialog.GetPath()
+binfile = open(filepath,"wb")
+binfile.write(self.SiiBinary)
+binfile.close()
+dialog.Destroy()
+def SetXMLData(self):
+"""
+Set data based on XML initially
+"""
+# Config Data: EEPROM Size, PDI Type, Device Emulation
+# Find PDI Type in pdiType dictionary
+cnt_pdi_type = self.Controler.CommonMethod.SmartViewInfosFromXML["pdi_type"]
+for i in self.PDIType.keys():
+if cnt_pdi_type == i:
+cnt_pdi_type = self.PDIType[i][0]
+break
+#  Set Config Data
+for treelist, data in [("EEPROM Size (Bytes)",
+str(self.Controler.CommonMethod.SmartViewInfosFromXML["eeprom_size"])),
+("PDI Type",
+cnt_pdi_type),
+("Device Emulation",
+self.Controler.CommonMethod.SmartViewInfosFromXML["device_emulation"])]:
+self.TreeListCtrl.Tree.SetItemText(self.TreeListCtrl.ConfigData[treelist], data, 1)
+# Device Identity: Vendor ID, Product Code, Revision No., Serial No.
+#  Set Device Identity
+for treelist, data in [("Vendor ID", self.Controler.CommonMethod.SmartViewInfosFromXML["vendor_id"]),
+("Product Code", self.Controler.CommonMethod.SmartViewInfosFromXML["product_code"]),
+("Revision No.", self.Controler.CommonMethod.SmartViewInfosFromXML["revision_no"]),
+("Serial No.", self.Controler.CommonMethod.SmartViewInfosFromXML["serial_no"])]:
+self.TreeListCtrl.Tree.SetItemText(self.TreeListCtrl.DeviceIdentity[treelist], data, 1)
+# Mailbox: Supported Mailbox, Bootstrap Configuration, Standard Configuration
+#  Set Mailbox
+for treelist, data in [("Supported Mailbox", self.Controler.CommonMethod.SmartViewInfosFromXML["supported_mailbox"]),
+("Bootstrap Configuration", ""),
+("Standard Configuration", "")]:
+self.TreeListCtrl.Tree.SetItemText(self.TreeListCtrl.Mailbox[treelist], data, 1)
+#  Set Bootstrap Configuration: Receive Offset, Receive Size, Send Offset, Send Size
+for treelist, data in [("Receive Offset", self.Controler.CommonMethod.SmartViewInfosFromXML["mailbox_bootstrapconf_outstart"]),
+("Receive Size", self.Controler.CommonMethod.SmartViewInfosFromXML["mailbox_bootstrapconf_outlength"]),
+("Send Offset", self.Controler.CommonMethod.SmartViewInfosFromXML["mailbox_bootstrapconf_instart"]),
+("Send Size", self.Controler.CommonMethod.SmartViewInfosFromXML["mailbox_bootstrapconf_inlength"])]:
+self.TreeListCtrl.Tree.SetItemText(self.TreeListCtrl.BootstrapConfig[treelist], data, 1)
+#  Set Standard Configuration: Receive Offset, Receive Size, Send Offset, Send Size
+for treelist, data in [("Receive Offset", self.Controler.CommonMethod.SmartViewInfosFromXML["mailbox_standardconf_outstart"]),
+("Receive Size", self.Controler.CommonMethod.SmartViewInfosFromXML["mailbox_standardconf_outlength"]),
+("Send Offset", self.Controler.CommonMethod.SmartViewInfosFromXML["mailbox_standardconf_instart"]),
+("Send Size", self.Controler.CommonMethod.SmartViewInfosFromXML["mailbox_standardconf_inlength"])]:
+self.TreeListCtrl.Tree.SetItemText(self.TreeListCtrl.StandardConfig[treelist], data, 1)
+def SetEEPROMData(self):
+"""
+Set data based on slave EEPROM.
+"""
+# sii_dict = { Parameter : (WordAddress, WordSize) }
+sii_dict= { 'PDIControl' :                          ( '0', 1),
+'PDIConfiguration' :                    ( '1', 1),
+'PulseLengthOfSYNCSignals' :            ( '2', 1),
+'ExtendedPDIConfiguration' :            ( '3', 1),
+'ConfiguredStationAlias' :              ( '4', 1),
+'Checksum' :                            ( '7', 1),
+'VendorID' :                            ( '8', 2),
+'ProductCode' :                         ( 'a', 2),
+'RevisionNumber' :                      ( 'c', 2),
+'SerialNumber' :                        ( 'e', 2),
+'Execution Delay' :                     ('10', 1),
+'Port0Delay' :                          ('11', 1),
+'Port1Delay' :                          ('12', 1),
+'BootstrapReceiveMailboxOffset' :       ('14', 1),
+'BootstrapReceiveMailboxSize' :         ('15', 1),
+'BootstrapSendMailboxOffset' :          ('16', 1),
+'BootstrapSendMailboxSize' :            ('17', 1),
+'StandardReceiveMailboxOffset' :        ('18', 1),
+'StandardReceiveMailboxSize' :          ('19', 1),
+'StandardSendMailboxOffset' :           ('1a', 1),
+'StandardSendMailboxSize' :             ('1b', 1),
+'MailboxProtocol' :                     ('1c', 1),
+'Size' :                                ('3e', 1),
+'Version' :                             ('3f', 1),
+'First Category Type/Vendor Specific' : ('40', 1),
+'Following Category Word Size' :        ('41', 1),
+'Category Data' :                       ('42', 1),
+}
+# Config Data: EEPROM Size, PDI Type, Device Emulation
+# EEPROM's data in address '0x003f' is Size of EEPROM in KBit-1
+eeprom_size = str((int(self.GetWordAddressData( sii_dict.get('Size'),10 ))+1)/8*1024)
+# Find PDI Type in pdiType dictionary
+cnt_pdi_type = int(self.GetWordAddressData( sii_dict.get('PDIControl'),16 ).split('x')[1][2:4], 16)
+for i in self.PDIType.keys():
+if cnt_pdi_type == i:
+cnt_pdi_type = self.PDIType[i][0]
+break
+#  Get Device Emulation
+device_emulation = str(bool(int("{:0>16b}".format(int(self.GetWordAddressData( sii_dict.get('PDIControl'),16 ), 16))[7])))
+#  Set Config Data
+for treelist, data in [("EEPROM Size (Bytes)", eeprom_size),
+("PDI Type", cnt_pdi_type),
+("Device Emulation", device_emulation)]:
+self.TreeListCtrl.Tree.SetItemText(self.TreeListCtrl.ConfigData[treelist], data, 1)
+# Device Identity: Vendor ID, Product Code, Revision No., Serial No.
+#  Set Device Identity
+for treelist, data in [("Vendor ID", self.GetWordAddressData( sii_dict.get('VendorID'),16 )),
+("Product Code", self.GetWordAddressData( sii_dict.get('ProductCode'),16 )),
+("Revision No.", self.GetWordAddressData( sii_dict.get('RevisionNumber'),16 )),
+("Serial No.", self.GetWordAddressData( sii_dict.get('SerialNumber'),16 ))]:
+self.TreeListCtrl.Tree.SetItemText(self.TreeListCtrl.DeviceIdentity[treelist], data, 1)
+# Mailbox
+# EEORPOM's word address '1c' indicates supported mailbox protocol.
+# each value of mailbox protocol :
+# VoE(0x0020), SoE(0x0010), FoE(0x0008), CoE(0x0004), EoE(0x0002), AoE(0x0001)
+supported_mailbox = ""
+mailbox_protocol=["VoE,  ", "SoE,  ", "FoE,  ", "CoE,  ", "EoE,  ", "AoE,  "]
+mailbox_data = "{:0>8b}".format(int(self.GetWordAddressData( sii_dict.get('MailboxProtocol'),16 ), 16))
+for protocol in range(6):
+if mailbox_data[protocol+2] == '1':
+supported_mailbox += mailbox_protocol[protocol]
+supported_mailbox = supported_mailbox.strip(",  ")
+#  Set Mailbox
+for treelist, data in [("Supported Mailbox", supported_mailbox),
+("Bootstrap Configuration", ""),
+("Standard Configuration", "")]:
+self.TreeListCtrl.Tree.SetItemText(self.TreeListCtrl.Mailbox[treelist], data, 1)
+#  Set Bootstrap Configuration: Receive Offset, Receive Size, Send Offset, Send Size
+for treelist, data in [("Receive Offset", self.GetWordAddressData( sii_dict.get('BootstrapReceiveMailboxOffset'),10 )),
+("Receive Size", self.GetWordAddressData( sii_dict.get('BootstrapReceiveMailboxSize'),10 )),
+("Send Offset", self.GetWordAddressData( sii_dict.get('BootstrapSendMailboxOffset'),10 )),
+("Send Size", self.GetWordAddressData( sii_dict.get('BootstrapSendMailboxSize'),10 ))]:
+self.TreeListCtrl.Tree.SetItemText(self.TreeListCtrl.BootstrapConfig[treelist], data, 1)
+#  Set Standard Configuration: Receive Offset, Receive Size, Send Offset, Send Size
+for treelist, data in [("Receive Offset", self.GetWordAddressData( sii_dict.get('StandardReceiveMailboxOffset'),10 )),
+("Receive Size", self.GetWordAddressData( sii_dict.get('StandardReceiveMailboxSize'),10 )),
+("Send Offset", self.GetWordAddressData( sii_dict.get('StandardSendMailboxOffset'),10 )),
+("Send Size", self.GetWordAddressData( sii_dict.get('StandardSendMailboxSize'),10 ))]:
+self.TreeListCtrl.Tree.SetItemText(self.TreeListCtrl.StandardConfig[treelist], data, 1)
+def MakeStaticBoxSizer(self, boxlabel):
+"""
+Make StaticBoxSizer
+@param boxlabel : label of box sizer
+@return sizer : the StaticBoxSizer labeled 'boxlabel'
+"""
+box = wx.StaticBox(self, -1, boxlabel)
+sizer = wx.StaticBoxSizer(box, wx.VERTICAL)
+return sizer
+def GetWordAddressData(self, dict_tuple, format):
+"""
+This method converts word address data from EEPROM binary.
+@param dict_tuple : element of 'sii_dict' dictionary in SetEEPROMData()
+@param format : format of data. It can be 16(hex), 10(decimal) and 2(binary).
+@return formatted value
+"""
+offset = int(str(dict_tuple[0]), 16) * 2
+length = int(str(dict_tuple[1]), 16) * 2
+list = []
+data = ''
+for index in range(length):
+hexdata = hex(ord(self.SiiBinary[offset + index]))[2:]
+list.append(hexdata.zfill(2))
+list.reverse()
+data = list[0:length]
+if format == 16:
+return '0x' + ''.join(data)
+elif format == 10:
+return str(int(str(''.join(data)), 16))
+elif format == 2:
+''.join(data)
+#-------------------------------------------------------------------------------
+#                    For Smart View TreeListCtrl
+#-------------------------------------------------------------------------------
+class SmartViewTreeListCtrl(wx.Panel):
+def __init__(self, parent, Controler):
+"""
+Constructor
+@param parent: Reference to the parent SlaveSiiSmartView class
+@param controler: _EthercatSlaveCTN class in EthercatSlave.py
+"""
+wx.Panel.__init__(self, parent, -1, size=(350, 500))
+self.Tree = wx.gizmos.TreeListCtrl(self, -1, size=(350, 500),
+style=wx.TR_DEFAULT_STYLE
+|wx.TR_FULL_ROW_HIGHLIGHT
+|wx.TR_HIDE_ROOT
+|wx.TR_COLUMN_LINES
+|wx.TR_ROW_LINES)
+self.Tree.AddColumn("Description", width=200)
+self.Tree.AddColumn("Value", width=140)
+self.Tree.SetMainColumn(0)
+self.Root = self.Tree.AddRoot("")
+# Add item
+#  Level 1 nodes
+self.Level1Nodes = {}
+for lv1 in ["Config Data", "Device Identity", "Mailbox"]:
+self.Level1Nodes[lv1] = self.Tree.AppendItem(self.Root, lv1)
+#  Level 2 nodes
+#   Config Data
+self.ConfigData = {}
+for lv2 in ["EEPROM Size (Bytes)", "PDI Type", "Device Emulation"]:
+self.ConfigData[lv2] = self.Tree.AppendItem(self.Level1Nodes["Config Data"], lv2)
+#   Device Identity
+self.DeviceIdentity = {}
+for lv2 in ["Vendor ID", "Product Code", "Revision No.", "Serial No."]:
+self.DeviceIdentity[lv2] = self.Tree.AppendItem(self.Level1Nodes["Device Identity"], lv2)
+#   Mailbox
+self.Mailbox = {}
+for lv2 in ["Supported Mailbox", "Bootstrap Configuration", "Standard Configuration"]:
+self.Mailbox[lv2] = self.Tree.AppendItem(self.Level1Nodes["Mailbox"], lv2)
+#  Level 3 nodes
+#   Children of Bootstrap Configuration
+self.BootstrapConfig = {}
+for lv3 in ["Receive Offset", "Receive Size", "Send Offset", "Send Size"]:
+self.BootstrapConfig[lv3] = self.Tree.AppendItem(self.Mailbox["Bootstrap Configuration"], lv3)
+#   Children of Standard Configuration
+self.StandardConfig = {}
+for lv3 in ["Receive Offset", "Receive Size", "Send Offset", "Send Size"]:
+self.StandardConfig[lv3] = self.Tree.AppendItem(self.Mailbox["Standard Configuration"], lv3)
+# Expand Tree
+for tree in [self.Root,
+self.Level1Nodes["Config Data"],
+self.Level1Nodes["Device Identity"],
+self.Level1Nodes["Mailbox"],
+self.Mailbox["Bootstrap Configuration"],
+self.Mailbox["Standard Configuration"]]:
+self.Tree.Expand(tree)
+#-------------------------------------------------------------------------------
+#                         For Hex View Panel
+#            shows EEPROM binary as hex data and characters.
+#-------------------------------------------------------------------------------
+class HexView(wx.Panel):
+def __init__(self, parent, controler):
+"""
+Constructor
+@param parent: Reference to the parent EtherCATManagementTreebook class
+@param controler: _EthercatSlaveCTN class in EthercatSlave.py
+"""
+wx.Panel.__init__(self, parent, -1)
+self.parent = parent
+self.Controler = controler
+self.HexRow = 8
+self.HexCol = 17
+self.HexViewSizer = {"view" : wx.FlexGridSizer(cols=1, hgap=10, rows=2, vgap=10),
+"siiButton" : wx.BoxSizer()}
+self.HexViewButton = {}
+for key, evt_handler in [("Sii Upload", self.OnButtonSiiUpload),
+("Sii Download", self.OnButtonSiiDownload),
+("Write to File", self.OnButtonWriteToBinFile),
+("Read from File", self.OnButtonReadFromBinFile),
+("XML to EEPROM Image", self.OnButtonXmlToEEPROMImg)]:
+self.HexViewButton[key] = wx.Button(self, -1, key)
+self.HexViewButton[key].Bind(wx.EVT_BUTTON, evt_handler)
+self.HexViewSizer["siiButton"].Add(self.HexViewButton[key])
+self.SiiBinary = self.Controler.CommonMethod.XmlToEeprom()
+self.HexCode, self.HexRow, self.HexCol = self.Controler.CommonMethod.HexRead(self.SiiBinary)
+self.SiiGrid = SiiGridTable(self, self.Controler, self.HexRow, self.HexCol)
+self.HexViewSizer["view"].AddMany([self.HexViewSizer["siiButton"], self.SiiGrid])
+self.SiiGrid.CreateGrid(self.HexRow, self.HexCol)
+self.SetSizer(self.HexViewSizer["view"])
+self.HexViewSizer["view"].FitInside(self.parent.parent)
+self.parent.parent.FitInside()
+self.SiiGrid.SetValue(self.HexCode)
+self.SiiGrid.Update()
+def UpdateSiiGridTable(self, row, col):
+"""
+Destroy existing grid and recreate
+@param row, col : Hex View grid size
+"""
+self.HexViewSizer["view"].Detach(self.SiiGrid)
+self.SiiGrid.Destroy()
+self.SiiGrid = SiiGridTable(self, self.Controler, row, col)
+self.HexViewSizer["view"].Add(self.SiiGrid)
+self.SiiGrid.CreateGrid(row, col)
+self.SetSizer(self.HexViewSizer["view"])
+self.HexViewSizer["view"].FitInside(self.parent.parent)
+self.parent.parent.FitInside()
+def OnButtonSiiUpload(self, event):
+"""
+Load EEPROM data from slave and refresh Hex View grid
+Binded to 'Sii Upload' button.
+@param event : wx.EVT_BUTTON object
+"""
+# Check whether beremiz connected or not.
+check_connect_flag = self.Controler.CommonMethod.CheckConnect(False)
+if check_connect_flag:
+# load from EEPROM data and parsing
+self.SiiBinary = self.Controler.CommonMethod.LoadData()
+self.HexCode, self.HexRow, self.HexCol = self.Controler.CommonMethod.HexRead(self.SiiBinary)
+self.UpdateSiiGridTable(self.HexRow, self.HexCol)
+self.SiiGrid.SetValue(self.HexCode)
+self.SiiGrid.Update()
+def OnButtonSiiDownload(self, event):
+"""
+Write current EEPROM data to slave and refresh data structure kept by master
+Binded to 'Sii Download' button.
+@param event : wx.EVT_BUTTON object
+"""
+# Check whether beremiz connected or not,
+# and whether status is "Started" or not.
+check_connect_flag = self.Controler.CommonMethod.CheckConnect(False)
+if check_connect_flag:
+status, count = self.Controler.GetCTRoot()._connector.GetPLCstatus()
+if status is not "Started":
+self.Controler.CommonMethod.SiiWrite(self.SiiBinary)
+self.Controler.CommonMethod.Rescan()
+def OnButtonWriteToBinFile(self, event):
+"""
+Save current EEPROM data to binary file through FileDialog
+Binded to 'Write to File' button.
+@param event : wx.EVT_BUTTON object
+"""
+dialog = wx.FileDialog(self, _("Save as..."), os.getcwd(), "slave0.bin",
+_("bin files (*.bin)|*.bin|All files|*.*"), wx.SAVE|wx.OVERWRITE_PROMPT)
+if dialog.ShowModal() == wx.ID_OK:
+filepath = dialog.GetPath()
+binfile = open(filepath,"wb")
+binfile.write(self.SiiBinary)
+binfile.close()
+dialog.Destroy()
+def OnButtonReadFromBinFile(self, event):
+"""
+Load binary file through FileDialog
+Binded to 'Read from File' button.
+@param event : wx.EVT_BUTTON object
+"""
+dialog = wx.FileDialog(self, _("Choose a binary file"), os.getcwd(), "",
+_("bin files (*.bin)|*.bin"), wx.OPEN)
+if dialog.ShowModal() == wx.ID_OK:
+filepath = dialog.GetPath()
+try:
+binfile = open(filepath, "rb")
+self.SiiBinary = binfile.read()
+self.HexCode, self.HexRow, self.HexCol = self.Controler.CommonMethod.HexRead(self.SiiBinary)
+self.UpdateSiiGridTable(self.HexRow, self.HexCol)
+self.SiiGrid.SetValue(self.HexCode)
+self.SiiGrid.Update()
+except:
+self.Controler.CommonMethod.CreateErrorDialog('The file does not exist!')
+dialog.Destroy()
+def OnButtonXmlToEEPROMImg(self, event):
+"""
+Create EEPROM data based XML data that current imported
+Binded to 'XML to EEPROM' button.
+@param event : wx.EVT_BUTTON object
+"""
+self.SiiBinary = self.Controler.CommonMethod.XmlToEeprom()
+self.HexCode, self.HexRow, self.HexCol = self.Controler.CommonMethod.HexRead(self.SiiBinary)
+self.UpdateSiiGridTable(self.HexRow, self.HexCol)
+self.SiiGrid.SetValue(self.HexCode)
+self.SiiGrid.Update()
+#-------------------------------------------------------------------------------
+#                    For Hex View grid (fill hex data)
+#-------------------------------------------------------------------------------
+class SiiGridTable(wx.grid.Grid):
+def __init__(self, parent, controler, row, col):
+"""
+Constructor
+@param parent: Reference to the parent HexView class
+@param controler: _EthercatSlaveCTN class in EthercatSlave.py
+@param row, col: Hex View grid size
+"""
+self.parent = parent
+self.Controler = controler
+self.Row = row
+self.Col = col
+wx.grid.Grid.__init__(self, parent, -1, size=(830,450),
+style=wx.ALIGN_CENTRE_HORIZONTAL|wx.ALIGN_CENTER_VERTICAL)
+def SetValue(self, value):
+"""
+Set data in the table
+@param value: EEPROM data list of which element is 1 Byte hex data
+"""
+# set label name and size
+self.SetRowLabelSize(100)
+for col in range(self.Col):
+if col == 16:
+self.SetColLabelValue(16, "Text View")
+self.SetColSize(16, (self.GetSize().x-120)*4/20)
+else:
+self.SetColLabelValue(col, '%s'%col)
+self.SetColSize(col, (self.GetSize().x-120)/20)
+# set data into table
+row = col = 0
+for row_idx in value:
+col = 0
+self.SetRowLabelValue(row, "0x"+"{:0>4x}".format(row*(self.Col-1)))
+for hex in row_idx:
+self.SetCellValue(row, col, hex)
+if col == 16:
+self.SetCellAlignment(row, col, wx.ALIGN_LEFT, wx.ALIGN_CENTER)
+else:
+self.SetCellAlignment(row, col, wx.ALIGN_CENTRE, wx.ALIGN_CENTER)
+self.SetReadOnly(row, col, True)
+col = col + 1
+row = row + 1
+#-------------------------------------------------------------------------------
+#                    For Register Access Panel
+#-------------------------------------------------------------------------------
+class RegisterAccessPanel(wx.Panel):
+def __init__(self, parent, controler):
+"""
+	    Constructor
+	    @param parent: EEPROMAccessPanel object
+	    @param controler: _EthercatSlaveCTN class in EthercatSlave.py
+	    """
+self.parent = parent
+self.Controler = controler
+self.__init_data()
+wx.Panel.__init__(self, parent, -1)
+sizer = wx.FlexGridSizer(cols=1, hgap=20, rows=2, vgap=5)
+button_sizer = wx.FlexGridSizer(cols=2, hgap=10, rows=1, vgap=10)
+self.ReloadButton = wx.Button(self, -1, "Reload")
+self.CompactViewCheckbox = wx.CheckBox(self, -1, "Compact View")
+self.RegisterNotebook = RegisterNotebook(self, self.Controler)
+button_sizer.AddMany([self.ReloadButton, self.CompactViewCheckbox])
+sizer.AddMany([button_sizer, self.RegisterNotebook])
+self.SetSizer(sizer)
+self.ReloadButton.Bind(wx.EVT_BUTTON, self.OnReloadButton)
+self.CompactViewCheckbox.Bind(wx.EVT_CHECKBOX, self.ToggleCompactViewCheckbox)
+for index in range(4):
+self.RegisterNotebook.RegPage[index].MainTable.CreateGrid(self.MainRow[index], self.MainCol)
+self.RegisterNotebook.RegPage[index].MainTable.SetValue(self, 0, index*512, (index+1)*512)
+# data default setting
+if self.Controler.CommonMethod.RegData == "":
+self.CompactViewCheckbox.Disable()
+for index in range(4):
+self.RegisterNotebook.RegPage[index].MainTable.SetValue(self, 0, index*512, (index+1)*512)
+else: # If data was saved,
+self.BasicSetData()
+self.ParseData()
+for index in range(4):
+self.RegisterNotebook.RegPage[index].MainTable.SetValue(self, self.RegMonitorData, index*512, (index+1)*512)
+def __init_data(self):
+"""
+	    Declare initial data.
+	    """
+# flag for compact view
+self.CompactFlag = False
+# main grid의 rows and cols
+self.MainRow = [512, 512, 512, 512]
+self.MainCol = 4
+# main grids' data range
+self.PageRange = []
+for index in range(4):
+self.PageRange.append([512*index, 512*(index+1)])
+#  Previous value of register data for register description configuration
+self.PreRegSpec = {"ESCType": "",
+"FMMUNumber": "",
+"SMNumber": "",
+"PDIType": ""}
+def LoadData(self):
+"""
+Get data from the register.
+"""
+self.Controler.CommonMethod.RegData = ""
+#ethercat reg_read
+#ex : ethercat reg_read -p 0 0x0000 0x0001
+#return value : 0x11
+for index in range(4):
+self.Controler.CommonMethod.RegData = self.Controler.CommonMethod.RegData + " " + self.Controler.CommonMethod.RegRead("0x"+"{:0>4x}".format(index*1024), "0x0400")
+# store previous value
+# (ESC type, port number of FMMU, port number of SM, and PDI type))
+for reg_spec in ["ESCType","FMMUNumber","SMNumber", "PDIType"]:
+self.PreRegSpec[reg_spec] = self.Controler.CommonMethod.CrtRegSpec[reg_spec]
+# update registers' description
+# (ESC type, port number of FMMU, port number of SM, and PDI type)
+for reg_spec, address in [("ESCType", "0x0000"),
+("FMMUNumber", "0x0004"),
+("SMNumber", "0x0005"),
+("PDIType", "0x0140")]:
+self.Controler.CommonMethod.CrtRegSpec[reg_spec] = self.Controler.CommonMethod.RegRead(address, "0x0001")
+# Enable compactView checkbox
+self.CompactViewCheckbox.Enable()
+def BasicSetData(self):
+"""
+Get and save the description of registers.
+It's done by parsing register_information.xml.
+"""
+# parse the above register's value
+# If the value is 0x12, the result is 12
+self.ESCType = self.Controler.CommonMethod.CrtRegSpec["ESCType"].split('x')[1]
+self.PDIType = self.Controler.CommonMethod.CrtRegSpec["PDIType"].split('x')[1]
+# If the value is 0x12, the result is 18 (It's converted to decimal value)
+self.FMMUNumber = int(self.Controler.CommonMethod.CrtRegSpec["FMMUNumber"], 16)
+self.SMNumber = int(self.Controler.CommonMethod.CrtRegSpec["SMNumber"], 16)
+# initialize description dictionary of register main table and register sub table.
+self.RegisterDescriptionDict = {}
+self.RegisterSubGridDict = {}
+# ./EthercatMaster/register_information.xml contains register description.
+if wx.Platform == '__WXMSW__':
+reg_info_file = open("../../EthercatMaster/register_information.xml", 'r')
+else:
+reg_info_file = open("./EthercatMaster/register_information.xml", 'r')
+reg_info_tree = minidom.parse(reg_info_file)
+reg_info_file.close()
+# parse register description
+for register_info in reg_info_tree.childNodes:
+for register in register_info.childNodes:
+if register.nodeType == reg_info_tree.ELEMENT_NODE and register.nodeName == "Register":
+# If it depends on the property(ESC type, PDI type, FMMU number, SM number)
+for property, type, value in [("esc", "type", self.ESCType),
+("pdi", "type", self.PDIType),
+("fmmu", "number", self.FMMUNumber),
+("sm", "number", self.SMNumber)]:
+if property in register.attributes.keys():
+if type == "type":
+if register.attributes[property].value == value:
+self.GetRegisterInfo(reg_info_tree, register)
+break
+else: # type == "number"
+if register.attributes[property].value < value:
+self.GetRegisterInfo(reg_info_tree, register)
+break
+else:
+self.GetRegisterInfo(reg_info_tree, register)
+break
+def GetRegisterInfo(self, reg_info_tree, register):
+"""
+Save the register's description into the dictionary.
+reg_info_tree is based on the register_information.xml.
+@param reg_info_tree: XML tree
+@param register: register which you want to get the description
+"""
+# temporary variables for register main table idescription dictionary
+reg_index = ""
+reg_main_description = ""
+for data in register.childNodes:
+if data.nodeType == reg_info_tree.ELEMENT_NODE and data.nodeName == "Index":
+for index in data.childNodes:
+reg_index = index.nodeValue
+if data.nodeType == reg_info_tree.ELEMENT_NODE and data.nodeName == "Description":
+for description in data.childNodes:
+reg_main_description = description.nodeValue
+# Add description for register main table
+if reg_index is not "" and reg_main_description is not "":
+self.RegisterDescriptionDict[reg_index] = reg_main_description
+if data.nodeType == reg_info_tree.ELEMENT_NODE and data.nodeName == "Details":
+# declare register sub table description dictionary about this index
+self.RegisterSubGridDict[reg_index] = []
+for detail in data.childNodes:
+if detail.nodeType == reg_info_tree.ELEMENT_NODE and detail.nodeName == "Detail":
+# If it depends on the property(ESC type, PDI type, FMMU number, SM number)
+for property, type, value in [("esc", "type", self.ESCType),
+("pdi", "type", self.PDIType),
+("fmmu", "number", self.FMMUNumber),
+("sm", "number", self.SMNumber)]:
+if property in detail.attributes.keys():
+if type == "type":
+if detail.attributes[property].value == value:
+self.GetRegisterDetailInfo(reg_info_tree, reg_index, detail)
+break
+else: # type == "number"
+if detail.attributes[property].value < value:
+self.GetRegisterDetailInfo(reg_info_tree, reg_index, detail)
+break
+else:
+self.GetRegisterDetailInfo(reg_info_tree, reg_index, detail)
+break
+def GetRegisterDetailInfo(self, reg_info_tree, reg_index, detail):
+"""
+Get the resgister's detailed description(for sub table) from the reg_info_tree.
+@param reg_info_tree: XML tree (register_information.xml)
+@param reg_index: index of the register
+@param detail: description of the register
+"""
+# temporary variables for register sub table description dictionary
+# - It is initialized in every sub description
+reg_bit_range = ""
+reg_sub_description = ""
+reg_enum_dictionary = {}
+for detail_data in detail.childNodes:
+if detail_data.nodeType == reg_info_tree.ELEMENT_NODE and detail_data.nodeName == "Range":
+for range in detail_data.childNodes:
+reg_bit_range = range.nodeValue
+if detail_data.nodeType == reg_info_tree.ELEMENT_NODE and detail_data.nodeName == "Description":
+for description in detail_data.childNodes:
+reg_sub_description = description.nodeValue
+if detail_data.nodeType == reg_info_tree.ELEMENT_NODE and detail_data.nodeName == "Enum":
+for enum in detail_data.childNodes:
+if enum.nodeType == reg_info_tree.ELEMENT_NODE and enum.nodeName == "item":
+# temporary variables for a description of each value
+# For example, if the bit is 1, it is 'enabled'('On', 'True', etc.),
+# otherwise 'disabled'('Off', 'False', etc.).
+reg_sub_value = ""
+reg_sub_value_description = ""
+for item in enum.childNodes:
+if item.nodeType == reg_info_tree.ELEMENT_NODE and item.nodeName == "value":
+for value in item.childNodes:
+reg_sub_value = value.nodeValue
+if item.nodeType == reg_info_tree.ELEMENT_NODE and item.nodeName == "Description":
+for description in item.childNodes:
+reg_sub_value_description = description.nodeValue
+# Add a description of each value to register enum dictionary
+if reg_sub_value is not "" and reg_sub_value_description is not "":
+reg_enum_dictionary[reg_sub_value] = reg_sub_value_description
+# add a description to register sub table description dictionary
+if reg_bit_range is not "" and reg_sub_description is not "":
+self.RegisterSubGridDict[reg_index].append([reg_bit_range,
+reg_sub_description, reg_enum_dictionary])
+def ParseData(self):
+"""
+Transform the data into dec, hex, string, and description
+"""
+row_data = []
+self.RegMonitorData = []
+reg_word = ""
+reg_data = self.Controler.CommonMethod.RegData.split()
+# loop for register(0x0000:0x0fff)
+for address in range(0x1000):
+# arrange 2 Bytes of register data
+reg_word = reg_data[address].split('x')[1] + reg_word
+if (address%2) == 1:
+# append address
+hex_address = "{:0>4x}".format(address-1)
+row_data.append(hex_address)
+# append description
+if self.RegisterDescriptionDict.has_key(hex_address):
+row_data.append(self.RegisterDescriptionDict[hex_address])
+else:
+row_data.append("")
+# append Decimal value
+row_data.append(str(int(reg_word, 16)))
+# append Hex value
+row_data.append('0x'+reg_word)
+# append ASCII value
+char_data = ""
+for iter in range(2):
+if int(reg_word[iter*2:iter*2+2], 16)>=32 and int(reg_word[iter*2:iter*2+2], 16)<=126:
+char_data = char_data + chr(int(reg_word[iter*2:iter*2+2], 16))
+else:
+char_data = char_data + "."
+row_data.append(char_data)
+self.RegMonitorData.append(row_data)
+reg_word = "" # initialize regWord
+row_data = []
+def OnReloadButton(self, event):
+"""
+Handle the click event of the 'Reload' button.
+Get the data from registers again, and update the table.
+@param event: wx.EVT_BUTTON object
+"""
+# Check whether beremiz connected or not.
+check_connect_flag = self.Controler.CommonMethod.CheckConnect(False)
+if check_connect_flag:
+self.LoadData()
+self.BasicSetData()
+self.ParseData()
+# set data into UI
+if self.CompactFlag:
+self.ToggleCompactViewCheckbox(True)
+else :
+for index in range(4):
+self.RegisterNotebook.RegPage[index].UpdateMainTable(self.MainRow[index], self.MainCol,
+self.PageRange[index][0], self.PageRange[index][1],
+self.RegMonitorData)
+def ToggleCompactViewCheckbox(self, event):
+"""
+Handles the event of the 'Compact view' check box.
+If it's checked, show only the registers that have a description.
+If not, show all the registers.
+@param event: wx.EVT_CHECKBOX object
+"""
+# If "Compact View" Checkbox is True
+## 'event' is argument of this method or event of checkbox.
+if event==True or event.GetEventObject().GetValue():
+self.CompactFlag = True
+reg_compact_data = []
+page_row = [0, 0, 0, 0]
+for index in range(4):
+self.PageRange[index] = [0, 0]
+for reg_row_data in self.RegMonitorData:
+if reg_row_data[1] is not "":
+# data structure for "compact view"
+reg_compact_data.append(reg_row_data)
+# count for each register notebooks' row
+# It compare with register's address.
+for index in range(4):
+if int('0x'+reg_row_data[0], 16) < (index+1)*1024:
+page_row[index] += 1
+break
+# Setting tables' rows and cols, range for compact view
+for index in range(4):
+self.MainRow[index] = page_row[index]
+self.PageRange[index][1] = page_row[index]
+for iter in range(index):
+self.PageRange[index][0] += page_row[iter]
+self.PageRange[index][1] += page_row[iter]
+# Update table
+for index in range(4):
+self.RegisterNotebook.RegPage[index].UpdateMainTable(self.MainRow[index], self.MainCol,
+self.PageRange[index][0], self.PageRange[index][1],
+reg_compact_data)
+# Compact View Checkbox is False
+else:
+self.CompactFlag = False
+# Setting original rows, cols and range
+self.MainRow = [512, 512, 512, 512]
+self.PageRange = []
+for index in range(4):
+self.PageRange.append([512*index, 512*(index+1)])
+# Update table
+for index in range(4):
+self.RegisterNotebook.RegPage[index].UpdateMainTable(self.MainRow[index], self.MainCol,
+self.PageRange[index][0], self.PageRange[index][1],
+self.RegMonitorData)
+#-------------------------------------------------------------------------------
+#                    For Register Access Notebook (divide index range)
+#-------------------------------------------------------------------------------
+class RegisterNotebook(wx.Notebook):
+def __init__(self, parent, controler):
+"""
+Constructor
+@param parent: RegisterAccessPanel object
+@param controler: _EthercatSlaveCTN class in EthercatSlave.py
+"""
+wx.Notebook.__init__(self, parent, id = -1)
+self.parent = parent
+self.Controler = controler
+# Initialize pages
+self.RegPage = []
+for iter in range(4):
+self.RegPage.append(None)
+for index in range(4):
+self.RegPage[index] = RegisterNotebookPanel(self, self.Controler,
+parent.MainRow[index], parent.MainCol)
+self.AddPage(self.RegPage[index],
+"0x"+"{:0>4x}".format(index*1024)+" - 0x"+"{:0>4x}".format((index+1)*1024-1))
+self.Bind(wx.EVT_NOTEBOOK_PAGE_CHANGED, self.OnPageChanged)
+self.Bind(wx.EVT_NOTEBOOK_PAGE_CHANGING, self.OnPageChanging)
+def OnPageChanged(self, event):
+old = event.GetOldSelection()
+new = event.GetSelection()
+sel = self.GetSelection()
+event.Skip()
+def OnPageChanging(self, event):
+old = event.GetOldSelection()
+new = event.GetSelection()
+sel = self.GetSelection()
+event.Skip()
+#-------------------------------------------------------------------------------
+#                    For Register Access Notebook Panel
+#                  (Main UI : including main, sub table)
+#-------------------------------------------------------------------------------
+class RegisterNotebookPanel(wx.Panel):
+def __init__(self, parent, controler, row, col):
+"""
+Constructor
+@param parent: RegisterAccessPanel object
+@param controler: _EthercatSlaveCTN class in EthercatSlave.py
+@param row, col: size of the table
+	"""
+wx.Panel.__init__(self, parent, -1)
+self.parent = parent
+self.Controler = controler
+self.Row = row
+self.Col = col
+sub_row = 0
+sub_col = 4
+self.Sizer = wx.FlexGridSizer(cols=1, hgap=10, rows=2, vgap=30)
+self.MainTable = RegisterMainTable(self, self.Row, self.Col, self.Controler)
+self.SubTable = RegisterSubTable(self, sub_row, sub_col)
+self.SubTable.CreateGrid(sub_row, sub_col)
+self.SubTable.SetValue(self, [])
+self.Sizer.AddMany([self.MainTable, self.SubTable])
+self.SetSizer(self.Sizer)
+def UpdateMainTable(self, row, col, low_index, high_index, data):
+"""
+Updates main table.
+It's done by deleting the main table and creating it again.
+@param row, col: size of the table
+@param low_index: the lowest index of the page
+@param high_index: the highest index of the page
+@param data: data
+	"""
+self.MainTable.Destroy()
+self.MainTable = RegisterMainTable(self, row, col, self.Controler)
+self.Sizer.Detach(self.SubTable)
+self.Sizer.AddMany([self.MainTable, self.SubTable])
+self.SetSizer(self.Sizer)
+self.MainTable.CreateGrid(row, col)
+self.MainTable.SetValue(self, data, low_index, high_index)
+self.MainTable.Update()
+def UpdateSubTable(self, row, col, data):
+"""
+Updates sub table.
+It's done by deleting the sub table and creating it again.
+@param row, col: size of the table
+@param data: data
+	"""
+self.SubTable.Destroy()
+self.SubTable = RegisterSubTable(self, row, col)
+self.Sizer.Detach(self.MainTable)
+self.Sizer.AddMany([self.MainTable, self.SubTable])
+self.Sizer.Layout()
+self.SetSizer(self.Sizer)
+self.SubTable.CreateGrid(row, col)
+self.SubTable.SetValue(self, data)
+self.SubTable.Update()
+#-------------------------------------------------------------------------------
+#                    For Register Access Notebook Panel (Main Table)
+#-------------------------------------------------------------------------------
+class RegisterMainTable(wx.grid.Grid):
+def __init__(self, parent, row, col, controler):
+"""
+	    Constructor
+	    @param parent: RegisterNotebook object
+	    @param row, col: size of the table
+	    @param controler: _EthercatSlaveCTN class in EthercatSlave.py
+	    """
+self.parent = parent
+self.Data = {}
+self.Row = row
+self.Col = col
+self.Controler = controler
+self.RegisterAccessPanel = self.parent.parent.parent
+wx.grid.Grid.__init__(self, parent, -1, size=(820,300),
+style=wx.EXPAND|wx.ALIGN_CENTRE_HORIZONTAL|wx.ALIGN_CENTER_VERTICAL)
+for evt, mapping_method in [(gridlib.EVT_GRID_CELL_LEFT_CLICK, self.OnSelectCell),
+(gridlib.EVT_GRID_CELL_LEFT_CLICK, self.OnSelectCell),
+(gridlib.EVT_GRID_CELL_LEFT_DCLICK, self.OnRegModifyDialog)]:
+self.Bind(evt, mapping_method)
+def SetValue(self, parent, reg_monitor_data, low_index, high_index):
+"""
+	    Set the RegMonitorData into the main table.
+	    @param parent: RegisterNotebook object
+	    @param reg_monitor_data: data
+	    @param low_index: the lowest index of the page
+	    @param high_index: the highest index of the page
+	    """
+self.RegMonitorData = reg_monitor_data
+# set label name and size
+register_maintable_label = [(0, "Description"), (1, "Dec"),
+(2, "Hex"), (3, "Char")]
+for (index, label) in register_maintable_label:
+self.SetColLabelValue(index, label)
+self.SetColSize(0, 200)
+# if reg_monitor_data is 0, it is initialization of register access.
+if reg_monitor_data == 0:
+return 0
+# set data into UI
+row = col = 0
+for row_index in reg_monitor_data[low_index:high_index]:
+col = 0
+self.SetRowLabelValue(row, row_index[0])
+for data_index in range(4):
+self.SetCellValue(row, col, row_index[data_index+1])
+self.SetCellAlignment(row, col, wx.ALIGN_CENTRE, wx.ALIGN_CENTER)
+self.SetReadOnly(row, col, True)
+col = col + 1
+row = row + 1
+def OnSelectCell(self, event):
+"""
+	    Handles the event of the cell of the main table.
+	    @param event: gridlib object (left click)
+	    """
+# if reg_monitor_data is 0, it is initialization of register access.
+if self.RegMonitorData == 0:
+event.Skip()
+return 0
+sub_row = 0
+sub_col = 4
+address = self.GetRowLabelValue(event.GetRow())
+reg_sub_grid_data = []
+BIT_RANGE, NAME, DESCRIPTIONS = range(3)
+# Check if this register's detail description is exist or not,
+# and create data structure for the detail description table ; sub grid
+if address in self.RegisterAccessPanel.RegisterSubGridDict:
+for element in self.RegisterAccessPanel.RegisterSubGridDict[address]:
+row_data =[]
+row_data.append(element[BIT_RANGE])
+row_data.append(element[NAME])
+bin_data = "{:0>16b}".format(int(self.GetCellValue(event.GetRow(), 1)))
+value_range = element[BIT_RANGE].split('-')
+value = (bin_data[8:16][::-1]+bin_data[0:8][::-1])[int(value_range[0]):(int(value_range[-1])+1)][::-1]
+row_data.append(str(int(('0b'+str(value)), 2)))
+if value in element[DESCRIPTIONS]:
+row_data.append(element[DESCRIPTIONS][value])
+else:
+row_data.append('')
+reg_sub_grid_data.append(row_data)
+sub_row = sub_row + 1
+self.parent.UpdateSubTable(sub_row, sub_col, reg_sub_grid_data)
+# event.Skip() updates UI of selecting cell
+event.Skip()
+def OnRegModifyDialog(self, event):
+"""
+Handle the event of the cell of the main table.
+Display the window where the user modifies the value of the cell.
+@param event: gridlib object (double click)
+	    """
+# user can enter a value in case that user double-clicked 'Dec' or 'Hex' value.
+if event.GetCol() == 1 or event.GetCol() == 2:
+dlg = wx.TextEntryDialog(self, "Enter hex(0xnnnn) or dec(n) value",
+"Register Modify Dialog", style = wx.OK|wx.CANCEL)
+# Setting value in initial dialog value
+start_value = self.GetCellValue(event.GetRow(), event.GetCol())
+dlg.SetValue(start_value)
+if dlg.ShowModal() == wx.ID_OK:
+try:
+# It int(input) success, this input is dev or hex value.
+# Otherwise, it's error, so it goes except.
+int(dlg.GetValue(), 0)
+# reg_write
+# ex) ethercat reg_write -p 0 -t uint16 0x0000 0x0000
+return_val = self.Controler.CommonMethod.RegWrite('0x'+self.GetRowLabelValue(event.GetRow()), dlg.GetValue())
+if len(return_val)==0:
+# set dec
+self.SetCellValue(event.GetRow(), 1, str(int(dlg.GetValue(), 0)))
+# set hex
+hex_data = '0x'+"{:0>4x}".format(int(dlg.GetValue(), 0))
+self.SetCellValue(event.GetRow(), 2, hex_data)
+# set char
+char_data = ""
+# If hex_data is been able to convert to ascii code, append ascii code.
+for iter in range(2):
+if int(hex_data[(iter+1)*2:(iter+2)*2], 16)>=32 and int(hex_data[(iter+1)*2:(iter+2)*2], 16)<=126:
+char_data = char_data + chr(int(hex_data[(iter+1)*2:(iter+2)*2], 16))
+else:
+char_data = char_data + "."
+self.SetCellValue(event.GetRow(), 3, char_data)
+else:
+self.Controler.CommonMethod.CreateErrorDialog('You can\'t modify it. This register is read-only or it\'s not connected.')
+except ValueError:
+self.Controler.CommonMethod.CreateErrorDialog('You entered wrong value. You can enter dec or hex value only.')
+#-------------------------------------------------------------------------------
+#                    For Register Access Notebook Panel (Sub Table)
+#-------------------------------------------------------------------------------
+class RegisterSubTable(wx.grid.Grid):
+def __init__(self, parent, row, col):
+"""
+	 Constructor
+	 @param parent: RegisterNotebook object
+	 @param row, col: size of the table
+	"""
+self.parent = parent
+self.Data = {}
+self.Row = row
+self.Col = col
+wx.grid.Grid.__init__(self, parent, -1, size=(820,150),
+style=wx.EXPAND|wx.ALIGN_CENTRE_HORIZONTAL|wx.ALIGN_CENTER_VERTICAL)
+def SetValue(self, parent, data):
+"""
+	    Set the data into the subtable.
+	    @param parent: RegisterNotebook object
+	    @param data: data
+	    """
+# lset label name and size
+Register_SubTable_Label = [(0, "Bits"), (1, "Name"),
+(2, "Value"), (3, "Enum")]
+for (index, label) in Register_SubTable_Label:
+self.SetColLabelValue(index, label)
+self.SetColSize(1, 200)
+self.SetColSize(3, 200)
+# set data into table
+row = col = 0
+for rowData in data:
+col = 0
+for element in rowData:
+self.SetCellValue(row, col, element)
+self.SetCellAlignment(row, col, wx.ALIGN_CENTRE, wx.ALIGN_CENTER)
+self.SetReadOnly(row, col, True)
+col = col + 1
+row = row + 1
+#-------------------------------------------------------------------------------
+#                    For Master State Panel
+#-------------------------------------------------------------------------------
+class MasterStatePanelClass(wx.Panel):
+def __init__(self, parent, controler):
+"""
+Constructor
+@param parent: wx.ScrollWindow object
+@Param controler: _EthercatSlaveCTN class in EthercatSlave.py
+"""
+wx.Panel.__init__(self, parent, -1, (0, 0),
+size=wx.DefaultSize, style = wx.SUNKEN_BORDER)
+self.Controler = controler
+self.parent = parent
+self.StaticBox = {}
+self.StaticText = {}
+self.TextCtrl = {}
+# ----------------------- Main Sizer and Update Button --------------------------------------------
+self.MasterStateSizer = {"main" : wx.BoxSizer(wx.VERTICAL)}
+for key, attr in [
+("innerMain",           [1, 10, 2, 10]),
+("innerTopHalf",        [2, 10, 1, 10]),
+("innerBottomHalf",     [2, 10, 1, 10]),
+("innerMasterState",    [2, 10, 3, 10]),
+("innerDeviceInfo",     [4, 10, 3, 10]),
+("innerFrameInfo",      [4, 10, 5, 10])]:
+self.MasterStateSizer[key] = wx.FlexGridSizer(cols=attr[0], hgap=attr[1], rows=attr[2], vgap=attr[3])
+self.UpdateButton = wx.Button(self, label=_('Update'))
+self.UpdateButton.Bind(wx.EVT_BUTTON, self.OnButtonClick)
+for key, label in [
+('masterState', 'EtherCAT Master State'),
+('deviceInfo', 'Ethernet Network Card Information'),
+('frameInfo', 'Network Frame Information')]:
+self.StaticBox[key] = wx.StaticBox(self, label=_(label))
+self.MasterStateSizer[key] = wx.StaticBoxSizer(self.StaticBox[key])
+# ----------------------- Master State -----------------------------------------------------------
+for key, label in [
+('Phase', 'Phase:'),
+('Active', 'Active:'),
+('Slaves', 'Slave Count:')]:
+self.StaticText[key] = wx.StaticText(self, label=_(label))
+self.TextCtrl[key] = wx.TextCtrl(self, size=wx.Size(130, 24), style=wx.TE_READONLY)
+self.MasterStateSizer['innerMasterState'].AddMany([self.StaticText[key], self.TextCtrl[key]])
+self.MasterStateSizer['masterState'].AddSizer(self.MasterStateSizer['innerMasterState'])
+# ----------------------- Ethernet Network Card Information ---------------------------------------
+for key, label in [
+('Main', 'MAC Address:'),
+('Link', 'Link State:'),
+('Tx frames', 'Tx Frames:'),
+('Rx frames', 'Rx Frames:'),
+('Lost frames', 'Lost Frames:')]:
+self.StaticText[key] = wx.StaticText(self, label=_(label))
+self.TextCtrl[key] = wx.TextCtrl(self, size=wx.Size(130, 24), style=wx.TE_READONLY)
+self.MasterStateSizer['innerDeviceInfo'].AddMany([self.StaticText[key], self.TextCtrl[key]])
+self.MasterStateSizer['deviceInfo'].AddSizer(self.MasterStateSizer['innerDeviceInfo'])
+# ----------------------- Network Frame Information -----------------------------------------------
+for key, label in [
+('Tx frame rate [1/s]', 'Tx Frame Rate [1/s]:'),
+('Rx frame rate [1/s]', 'Tx Rate [kByte/s]:'),
+('Loss rate [1/s]', 'Loss Rate [1/s]:'),
+('Frame loss [%]', 'Frame Loss [%]:')]:
+self.StaticText[key] = wx.StaticText(self, label=_(label))
+self.MasterStateSizer['innerFrameInfo'].Add(self.StaticText[key])
+self.TextCtrl[key] = {}
+for index in ['0', '1', '2']:
+self.TextCtrl[key][index] = wx.TextCtrl(self, size=wx.Size(130, 24), style=wx.TE_READONLY)
+self.MasterStateSizer['innerFrameInfo'].Add(self.TextCtrl[key][index])
+self.MasterStateSizer['frameInfo'].AddSizer(self.MasterStateSizer['innerFrameInfo'])
+# --------------------------------- Main Sizer ----------------------------------------------------
+for key, sub, in [
+('innerTopHalf', [
+'masterState', 'deviceInfo']),
+('innerBottomHalf', [
+'frameInfo']),
+('innerMain', [
+'innerTopHalf', 'innerBottomHalf'])]:
+for key2 in sub:
+self.MasterStateSizer[key].AddSizer(self.MasterStateSizer[key2])
+self.MasterStateSizer['main'].AddSizer(self.UpdateButton)
+self.MasterStateSizer['main'].AddSizer(self.MasterStateSizer['innerMain'])
+self.SetSizer(self.MasterStateSizer['main'])
+def OnButtonClick(self, event):
+"""
+Handle the event of the 'Update' button.
+Update the data of the master state.
+@param event: wx.EVT_BUTTON object
+"""
+if self.Controler.GetCTRoot()._connector is not None:
+self.MasterState = self.Controler.CommonMethod.GetMasterState()
+# Update each TextCtrl
+if self.MasterState:
+for key in self.TextCtrl:
+if isinstance(self.TextCtrl[key], dict):
+for index in self.TextCtrl[key]:
+self.TextCtrl[key][index].SetValue(self.MasterState[key][int(index)])
+else:
+self.TextCtrl[key].SetValue(self.MasterState[key][0])
+else :
+self.Controler.CommonMethod.CreateErrorDialog('PLC not connected!')

changeset 2165	02a2b5dee5e3
parent 2152	e6946c298a42
child 2353	8f1a2846b2f5
child 2641	c9deff128c37