beremiz

convert some etherlab source files to unix format

2018-09-28, Andrey Skvortsov
9460872f1440
Parents 8f1a2846b2f5
Children fec77f2b9e07
convert some etherlab source files to unix format
3 files changed, 3801 insertions(+), 3801 deletions(-)
  • +1591 -1591
    etherlab/CommonEtherCATFunction.py
  • +3 -3
    etherlab/ConfigEditor.py
  • +2207 -2207
    etherlab/EtherCATManagementEditor.py
    • --- a/etherlab/CommonEtherCATFunction.py Fri Sep 28 17:14:42 2018 +0300
    +++ b/etherlab/CommonEtherCATFunction.py Fri Sep 28 17:15:53 2018 +0300
    @@ -1,1591 +1,1591 @@
    -#!/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, Korea
    -#
    -# See COPYING file for copyrights details.
    -
    -import os
    -import wx
    -
    -mailbox_protocols = ["AoE", "EoE", "CoE", "FoE", "SoE", "VoE"]
    -
    -def ExtractHexDecValue(value):
    - """
    - convert numerical value in string format into decimal or hex format.
    - @param value : hex or decimal data
    - @return integer data
    - """
    - try:
    - return int(value)
    - except Exception:
    - pass
    - try:
    - return int(value.replace("#", "0"), 16)
    -
    - except Exception:
    - raise ValueError, "Invalid value for HexDecValue \"%s\"" % value
    -
    -def ExtractName(names, default=None):
    - """
    - Extract "name" field from XML entries.
    - @param names : XML entry
    - @default : if it fails to extract from the designated XML entry, return the default value ("None").
    - @return default or the name extracted
    - """
    - if len(names) == 1:
    - return names[0].getcontent()
    - else:
    - for name in names:
    - if name.getLcId() == 1033:
    - return name.getcontent()
    - return default
    -
    -#--------------------------------------------------
    -# Remote Exec Etherlab Commands
    -#--------------------------------------------------
    -
    -# --------------------- for master ---------------------------
    -MASTER_STATE = """
    -import commands
    -result = commands.getoutput("ethercat master")
    -returnVal =result
    -"""
    -
    -# --------------------- for slave ----------------------------
    -# ethercat state -p (slave position) (state (INIT, PREOP, SAFEOP, OP))
    -SLAVE_STATE = """
    -import commands
    -result = commands.getoutput("ethercat state -p %d %s")
    -returnVal = result
    -"""
    -
    -# ethercat slave
    -GET_SLAVE = """
    -import commands
    -result = commands.getoutput("ethercat slaves")
    -returnVal =result
    -"""
    -
    -# ethercat xml -p (slave position)
    -SLAVE_XML = """
    -import commands
    -result = commands.getoutput("ethercat xml -p %d")
    -returnVal = result
    -"""
    -
    -# ethercat sdos -p (slave position)
    -SLAVE_SDO = """
    -import commands
    -result = commands.getoutput("ethercat sdos -p %d")
    -returnVal =result
    -"""
    -
    -# ethercat upload -p (slave position) (main index) (sub index)
    -GET_SLOW_SDO = """
    -import commands
    -result = commands.getoutput("ethercat upload -p %d %s %s")
    -returnVal =result
    -"""
    -
    -# ethercat download -p (slave position) (main index) (sub index) (value)
    -SDO_DOWNLOAD = """
    -import commands
    -result = commands.getoutput("ethercat download --type %s -p %d %s %s %s")
    -returnVal =result
    -"""
    -
    -# ethercat sii_read -p (slave position)
    -SII_READ = """
    -import commands
    -result = commands.getoutput("ethercat sii_read -p %d")
    -returnVal =result
    -"""
    -
    -# ethercat reg_read -p (slave position) (address) (size)
    -REG_READ = """
    -import commands
    -result = commands.getoutput("ethercat reg_read -p %d %s %s")
    -returnVal =result
    -"""
    -
    -# ethercat sii_write -p (slave position) - (contents)
    -SII_WRITE = """
    -import subprocess
    -process = subprocess.Popen(
    - ["ethercat", "-f", "sii_write", "-p", "%d", "-"],
    - stdin=subprocess.PIPE)
    -process.communicate(sii_data)
    -returnVal = process.returncode
    -"""
    -
    -# ethercat reg_write -p (slave position) -t (uinit16) (address) (data)
    -REG_WRITE = """
    -import commands
    -result = commands.getoutput("ethercat reg_write -p %d -t uint16 %s %s")
    -returnVal =result
    -"""
    -
    -# ethercat rescan -p (slave position)
    -RESCAN = """
    -import commands
    -result = commands.getoutput("ethercat rescan -p %d")
    -returnVal =result
    -"""
    -
    -#--------------------------------------------------
    -# Common Method For EtherCAT Management
    -#--------------------------------------------------
    -class _CommonSlave:
    -
    - # ----- Data Structure for ethercat management ----
    - SlaveState = ""
    -
    - # category of SDO data
    - DatatypeDescription, CommunicationObject, ManufacturerSpecific, \
    - ProfileSpecific, Reserved, AllSDOData = range(6)
    -
    - # store the execution result of "ethercat sdos" command into SaveSDOData.
    - SaveSDOData = []
    -
    - # Flags for checking "write" permission of OD entries
    - CheckPREOP = False
    - CheckSAFEOP = False
    - CheckOP = False
    -
    - # Save PDO Data
    - TxPDOInfo = []
    - TxPDOCategory = []
    - RxPDOInfo = []
    - RxPDOCategory = []
    -
    - # Save EEPROM Data
    - SiiData = ""
    -
    - # Save Register Data
    - RegData = ""
    - CrtRegSpec = {"ESCType": "",
    - "FMMUNumber": "",
    - "SMNumber": "",
    - "PDIType": ""}
    -
    - def __init__(self, controler):
    - """
    - Constructor
    - @param controler: _EthercatSlaveCTN class in EthercatSlave.py
    - """
    - self.Controler = controler
    -
    - self.ClearSDODataSet()
    -
    - #-------------------------------------------------------------------------------
    - # Used Master State
    - #-------------------------------------------------------------------------------
    - def GetMasterState(self):
    - """
    - Execute "ethercat master" command and parse the execution result
    - @return MasterState
    - """
    -
    - # exectute "ethercat master" command
    - error, return_val = self.Controler.RemoteExec(MASTER_STATE, return_val = None)
    - master_state = {}
    - # parse the reslut
    - for each_line in return_val.splitlines():
    - if len(each_line) > 0 :
    - chunks = each_line.strip().split(':', 1)
    - key = chunks[0]
    - value = []
    - if len(chunks) > 1 :
    - value = chunks[1].split()
    - if '(attached)' in value:
    - value.remove('(attached)')
    - master_state[key] = value
    -
    - return master_state
    -
    - #-------------------------------------------------------------------------------
    - # Used Slave State
    - #-------------------------------------------------------------------------------
    - def RequestSlaveState(self, command):
    - """
    - Set slave state to the specified one using "ethercat states -p %d %s" command.
    - Command example : "ethercat states -p 0 PREOP" (target slave position and target state are given.)
    - @param command : target slave state
    - """
    - error, return_val = self.Controler.RemoteExec(SLAVE_STATE%(self.Controler.GetSlavePos(), command), return_val = None)
    -
    - def GetSlaveStateFromSlave(self):
    - """
    - Get slave information using "ethercat slaves" command and store the information into internal data structure
    - (self.SlaveState) for "Slave State"
    - return_val example : 0 0:0 PREOP + EL9800 (V4.30) (PIC24, SPI, ET1100)
    - """
    - error, return_val = self.Controler.RemoteExec(GET_SLAVE, return_val = None)
    - self.SlaveState = return_val
    - return return_val
    -
    - #-------------------------------------------------------------------------------
    - # Used SDO Management
    - #-------------------------------------------------------------------------------
    - def GetSlaveSDOFromSlave(self):
    - """
    - Get SDO objects information of current slave using "ethercat sdos -p %d" command.
    - Command example : "ethercat sdos -p 0"
    - @return return_val : execution results of "ethercat sdos" command (need to be parsed later)
    - """
    - error, return_val = self.Controler.RemoteExec(SLAVE_SDO%(self.Controler.GetSlavePos()), return_val = None)
    - return return_val
    -
    - def SDODownload(self, data_type, idx, sub_idx, value):
    - """
    - Set an SDO object value to user-specified value using "ethercat download" command.
    - Command example : "ethercat download --type int32 -p 0 0x8020 0x12 0x00000000"
    - @param data_type : data type of SDO entry
    - @param idx : index of the SDO entry
    - @param sub_idx : subindex of the SDO entry
    - @param value : value of SDO entry
    - """
    - error, return_val = self.Controler.RemoteExec(SDO_DOWNLOAD%(data_type, self.Controler.GetSlavePos(), idx, sub_idx, value), return_val = None)
    -
    - def BackupSDODataSet(self):
    - """
    - Back-up current SDO entry information to restore the SDO data
    - in case that the user cancels SDO update operation.
    - """
    - self.BackupDatatypeDescription = self.SaveDatatypeDescription
    - self.BackupCommunicationObject = self.SaveCommunicationObject
    - self.BackupManufacturerSpecific = self.SaveManufacturerSpecific
    - self.BackupProfileSpecific = self.SaveProfileSpecific
    - self.BackupReserved = self.SaveReserved
    - self.BackupAllSDOData = self.SaveAllSDOData
    -
    - def ClearSDODataSet(self):
    - """
    - Clear the specified SDO entry information.
    - """
    - for count in range(6):
    - self.SaveSDOData.append([])
    -
    - #-------------------------------------------------------------------------------
    - # Used PDO Monitoring
    - #-------------------------------------------------------------------------------
    - def RequestPDOInfo(self):
    - """
    - Load slave information from RootClass (XML data) and parse the information (calling SlavePDOData() method).
    - """
    - # Load slave information from ESI XML file (def EthercatMaster.py)
    - slave = self.Controler.CTNParent.GetSlave(self.Controler.GetSlavePos())
    -
    - type_infos = slave.getType()
    - device, alignment = self.Controler.CTNParent.GetModuleInfos(type_infos)
    - # Initialize PDO data set
    - self.ClearDataSet()
    -
    - # if 'device' object is valid, call SavePDOData() to parse PDO data
    - if device is not None :
    - self.SavePDOData(device)
    -
    - def SavePDOData(self, device):
    - """
    - Parse PDO data and store the results in TXPDOCategory and RXPDOCategory
    - Tx(Rx)PDOCategory : index, name, entry number
    - Tx(Rx)Info : entry index, sub index, name, length, type
    - @param device : Slave information extracted from ESI XML file
    - """
    - # Parsing TXPDO entries
    - for pdo, pdo_info in ([(pdo, "Inputs") for pdo in device.getTxPdo()]):
    - # Save pdo_index, entry, and name of each entry
    - pdo_index = ExtractHexDecValue(pdo.getIndex().getcontent())
    - entries = pdo.getEntry()
    - pdo_name = ExtractName(pdo.getName())
    -
    - # Initialize entry number count
    - count = 0
    -
    - # Parse entries
    - for entry in entries:
    - # Save index and subindex
    - index = ExtractHexDecValue(entry.getIndex().getcontent())
    - subindex = ExtractHexDecValue(entry.getSubIndex())
    - # if entry name exists, save entry data
    - if ExtractName(entry.getName()) is not None :
    - entry_infos = {
    - "entry_index" : index,
    - "subindex" : subindex,
    - "name" : ExtractName(entry.getName()),
    - "bitlen" : entry.getBitLen(),
    - "type" : entry.getDataType().getcontent()
    - }
    - self.TxPDOInfo.append(entry_infos)
    - count += 1
    -
    - categorys = {"pdo_index" : pdo_index, "name" : pdo_name, "number_of_entry" : count}
    - self.TxPDOCategory.append(categorys)
    -
    - # Parsing RxPDO entries
    - for pdo, pdo_info in ([(pdo, "Outputs") for pdo in device.getRxPdo()]):
    - # Save pdo_index, entry, and name of each entry
    - pdo_index = ExtractHexDecValue(pdo.getIndex().getcontent())
    - entries = pdo.getEntry()
    - pdo_name = ExtractName(pdo.getName())
    -
    - # Initialize entry number count
    - count = 0
    -
    - # Parse entries
    - for entry in entries:
    - # Save index and subindex
    - index = ExtractHexDecValue(entry.getIndex().getcontent())
    - subindex = ExtractHexDecValue(entry.getSubIndex())
    - # if entry name exists, save entry data
    - if ExtractName(entry.getName()) is not None :
    - entry_infos = {
    - "entry_index" : index,
    - "subindex" : subindex,
    - "name" : ExtractName(entry.getName()),
    - "bitlen" : str(entry.getBitLen()),
    - "type" : entry.getDataType().getcontent()
    - }
    - self.RxPDOInfo.append(entry_infos)
    - count += 1
    -
    - categorys = {"pdo_index" : pdo_index, "name" : pdo_name, "number_of_entry" : count}
    - self.RxPDOCategory.append(categorys)
    -
    - def GetTxPDOCategory(self):
    - """
    - Get TxPDOCategory data structure (Meta informaton of TxPDO).
    - TxPDOCategorys : index, name, number of entries
    - @return TxPDOCategorys
    - """
    - return self.TxPDOCategory
    -
    - def GetRxPDOCategory(self):
    - """
    - Get RxPDOCategory data structure (Meta information of RxPDO).
    - RxPDOCategorys : index, name, number of entries
    - @return RxPDOCategorys
    - """
    - return self.RxPDOCategory
    -
    - def GetTxPDOInfo(self):
    - """
    - Get TxPDOInfo data structure (Detailed information on TxPDO entries).
    - TxPDOInfos : entry index, sub index, name, length, type
    - @return TxPDOInfos
    - """
    - return self.TxPDOInfo
    -
    - def GetRxPDOInfo(self):
    - """
    - Get RxPDOInfo data structure (Detailed information on RxPDO entries).
    - RxPDOInfos : entry index, sub index, name, length, type
    - @return RxPDOInfos
    - """
    - return self.RxPDOInfo
    -
    - def ClearDataSet(self):
    - """
    - Initialize PDO management data structure.
    - """
    - self.TxPDOInfos = []
    - self.TxPDOCategorys = []
    - self.RxPDOInfos = []
    - self.RxPDOCategorys = []
    -
    - #-------------------------------------------------------------------------------
    - # Used EEPROM Management
    - #-------------------------------------------------------------------------------
    - # Base data types in ETG2000; format = {"Name": "BitSize"}
    - BaseDataTypeDict = {"BOOL": "01",
    - "SINT": "02",
    - "INT": "03",
    - "DINT": "04",
    - "USINT": "05",
    - "UINT": "06",
    - "UDINT": "07",
    - "REAL": "08",
    - "INT24": "10",
    - "LREAL": "11",
    - "INT40": "12",
    - "INT48": "13",
    - "INT56": "14",
    - "LINT": "15",
    - "UINT24": "16",
    - "UINT40": "18",
    - "UINT48": "19",
    - "UINT56": "1a",
    - "ULINT": "1b",
    - "USINT": "1e",
    - "BITARR8": "2d",
    - "BITARR16": "2e",
    - "BITARR32": "2f",
    - "BIT1": "30",
    - "BIT2": "31",
    - "BIT3": "32",
    - "BIT4": "33",
    - "BIT5": "34",
    - "BIT6": "35",
    - "BIT7": "36",
    - "BIT8": "37"}
    -
    - def GetSmartViewInfos(self):
    - """
    - Parse XML data for "Smart View" of EEPROM contents.
    - @return smartview_infos : EEPROM contents dictionary
    - """
    -
    - smartview_infos = {"eeprom_size": 128,
    - "pdi_type": 0,
    - "device_emulation": "False",
    - "vendor_id": '0x00000000',
    - "product_code": '0x00000000',
    - "revision_no": '0x00000000',
    - "serial_no": '0x00000000',
    - "supported_mailbox": "",
    - "mailbox_bootstrapconf_outstart": '0',
    - "mailbox_bootstrapconf_outlength": '0',
    - "mailbox_bootstrapconf_instart": '0',
    - "mailbox_bootstrapconf_inlength": '0',
    - "mailbox_standardconf_outstart": '0',
    - "mailbox_standardconf_outlength": '0',
    - "mailbox_standardconf_instart": '0',
    - "mailbox_standardconf_inlength": '0'}
    -
    - slave = self.Controler.CTNParent.GetSlave(self.Controler.GetSlavePos())
    - type_infos = slave.getType()
    - device, alignment = self.Controler.CTNParent.GetModuleInfos(type_infos)
    -
    - # 'device' represents current slave device selected by user
    - if device is not None:
    - for eeprom_element in device.getEeprom().getcontent():
    - # get EEPROM size; <Device>-<Eeprom>-<ByteSize>
    - if eeprom_element["name"] == "ByteSize":
    - smartview_infos["eeprom_size"] = eeprom_element
    -
    - elif eeprom_element["name"] == "ConfigData":
    - configData_data = self.DecimalToHex(eeprom_element)
    - # get PDI type; <Device>-<Eeprom>-<ConfigData> address 0x00
    - smartview_infos["pdi_type"] = int(configData_data[0:2], 16)
    - # get state of device emulation; <Device>-<Eeprom>-<ConfigData> address 0x01
    - if "{:0>8b}".format(int(configData_data[2:4], 16))[7] == '1':
    - smartview_infos["device_emulation"] = "True"
    -
    - elif eeprom_element["name"] == "BootStrap":
    - bootstrap_data = "{:0>16x}".format(eeprom_element)
    - # get bootstrap configuration; <Device>-<Eeprom>-<BootStrap>
    - for cfg, iter in [("mailbox_bootstrapconf_outstart", 0),
    - ("mailbox_bootstrapconf_outlength", 1),
    - ("mailbox_bootstrapconf_instart", 2),
    - ("mailbox_bootstrapconf_inlength", 3)]:
    - smartview_infos[cfg] = str(int(bootstrap_data[4*iter+2:4*(iter+1)]+bootstrap_data[4*iter:4*iter+2], 16))
    -
    - # get protocol (profile) types supported by mailbox; <Device>-<Mailbox>
    - mb = device.getMailbox()
    - if mb is not None:
    - for mailbox_protocol in mailbox_protocols:
    - if getattr(mb,"get%s"%mailbox_protocol)() is not None:
    - smartview_infos["supported_mailbox"] += "%s, "%mailbox_protocol
    - smartview_infos["supported_mailbox"] = smartview_infos["supported_mailbox"].strip(", ")
    -
    - # get standard configuration of mailbox; <Device>-<Sm>
    - for sm_element in device.getSm():
    - if sm_element.getcontent() == "MBoxOut":
    - smartview_infos["mailbox_standardconf_outstart"] = str(ExtractHexDecValue(sm_element.getStartAddress()))
    - smartview_infos["mailbox_standardconf_outlength"] = str(ExtractHexDecValue(sm_element.getDefaultSize()))
    - elif sm_element.getcontent() == "MBoxIn":
    - smartview_infos["mailbox_standardconf_instart"] = str(ExtractHexDecValue(sm_element.getStartAddress()))
    - smartview_infos["mailbox_standardconf_inlength"] = str(ExtractHexDecValue(sm_element.getDefaultSize()))
    - else:
    - pass
    -
    - # get device identity from <Device>-<Type>
    - # vendor ID; by default, pre-defined value in self.ModulesLibrary
    - # if device type in 'vendor' item equals to actual slave device type, set 'vendor_id' to vendor ID.
    - for vendor_id, vendor in self.Controler.CTNParent.CTNParent.ModulesLibrary.Library.iteritems():
    - for available_device in vendor["groups"][vendor["groups"].keys()[0]]["devices"]:
    - if available_device[0] == type_infos["device_type"]:
    - smartview_infos["vendor_id"] = "0x" + "{:0>8x}".format(vendor_id)
    -
    - # product code;
    - if device.getType().getProductCode() is not None:
    - product_code = device.getType().getProductCode()
    - smartview_infos["product_code"] = "0x"+"{:0>8x}".format(ExtractHexDecValue(product_code))
    -
    - # revision number;
    - if device.getType().getRevisionNo() is not None:
    - revision_no = device.getType().getRevisionNo()
    - smartview_infos["revision_no"] = "0x"+"{:0>8x}".format(ExtractHexDecValue(revision_no))
    -
    - # serial number;
    - if device.getType().getSerialNo() is not None:
    - serial_no = device.getType().getSerialNo()
    - smartview_infos["serial_no"] = "0x"+"{:0>8x}".format(ExtractHexDecValue(serial_no))
    -
    - return smartview_infos
    -
    - else:
    - return None
    -
    - def DecimalToHex(self, decnum):
    - """
    - Convert decimal value into hexadecimal representation.
    - @param decnum : decimal value
    - @return hex_data : hexadecimal representation of input value in decimal
    - """
    - value = "%x" % decnum
    - value_len = len(value)
    - if (value_len % 2) == 0:
    - hex_len = value_len
    - else:
    - hex_len = (value_len / 2) * 2 + 2
    -
    - hex_data = ("{:0>"+str(hex_len)+"x}").format(decnum)
    -
    - return hex_data
    -
    - def SiiRead(self):
    - """
    - Get slave EEPROM contents maintained by master device using "ethercat sii_read -p %d" command.
    - Command example : "ethercat sii_read -p 0"
    - @return return_val : result of "ethercat sii_read" (binary data)
    - """
    - error, return_val = self.Controler.RemoteExec(SII_READ%(self.Controler.GetSlavePos()), return_val = None)
    - self.SiiData = return_val
    - return return_val
    -
    - def SiiWrite(self, binary):
    - """
    - Overwrite slave EEPROM contents using "ethercat sii_write -p %d" command.
    - Command example : "ethercat sii_write -p 0 - (binary contents)"
    - @param binary : EEPROM contents in binary data format
    - @return return_val : result of "ethercat sii_write" (If it succeeds, the return value is NULL.)
    - """
    - error, return_val = self.Controler.RemoteExec(SII_WRITE%(self.Controler.GetSlavePos()), return_val = None, sii_data = binary)
    - return return_val
    -
    - def LoadData(self):
    - """
    - Loading data from EEPROM use Sii_Read Method
    - @return self.BinaryCode : slave EEPROM data in binary format (zero-padded)
    - """
    - return_val = self.Controler.CommonMethod.SiiRead()
    - self.BinaryCode = return_val
    - self.Controler.SiiData = self.BinaryCode
    -
    - # append zero-filled padding data up to EEPROM size
    - for index in range(self.SmartViewInfosFromXML["eeprom_size"] - len(self.BinaryCode)):
    - self.BinaryCode = self.BinaryCode +'ff'.decode('hex')
    -
    - return self.BinaryCode
    -
    - def HexRead(self, binary):
    - """
    - Convert binary digit representation into hexadecimal representation for "Hex View" menu.
    - @param binary : binary digits
    - @return hexCode : hexadecimal digits
    - @return hexview_table_row, hexview_table_col : Grid size for "Hex View" UI
    - """
    - row_code = []
    - row_text = ""
    - row = 0
    - hex_code = []
    -
    - hexview_table_col = 17
    -
    - for index in range(0, len(binary)) :
    - if len(binary[index]) != 1:
    - break
    - else:
    - digithexstr = hex(ord(binary[index]))
    -
    - tempvar2 = digithexstr[2:4]
    - if len(tempvar2) == 1:
    - tempvar2 = "0" + tempvar2
    - row_code.append(tempvar2)
    -
    - if int(digithexstr, 16)>=32 and int(digithexstr, 16)<=126:
    - row_text = row_text + chr(int(digithexstr, 16))
    - else:
    - row_text = row_text + "."
    -
    - if index != 0 :
    - if len(row_code) == (hexview_table_col - 1):
    - row_code.append(row_text)
    - hex_code.append(row_code)
    - row_text = ""
    - row_code = []
    - row = row + 1
    -
    - hexview_table_row = row
    -
    - return hex_code, hexview_table_row, hexview_table_col
    -
    - def GenerateEEPROMList(self, data, direction, length):
    - """
    - Generate EEPROM data list by reconstructing 'data' string.
    - example : data="12345678", direction=0, length=8 -> eeprom_list=['12', '34', '56', '78']
    - data="12345678", direction=1, length=8 -> eeprom_list=['78', '56', '34', '12']
    - @param data : string to be reconstructed
    - @param direction : endianness
    - @param length : data length
    - @return eeprom_list : reconstructed list data structure
    - """
    - eeprom_list = []
    -
    - if direction is 0 or 1:
    - for i in range(length/2):
    - if data == "":
    - eeprom_list.append("00")
    - else:
    - eeprom_list.append(data[direction*(length-2):direction*(length-2)+2])
    - data = data[(1-direction)*2:length-direction*2]
    - length -= 2
    - return eeprom_list
    -
    - def XmlToEeprom(self):
    - """
    - Extract slave EEPROM contents using slave ESI XML file.
    - - Mandatory parts
    - - String category : ExtractEEPROMStringCategory()
    - - General category : ExtractEEPROMGeneralCategory()
    - - FMMU category : ExtractEEPROMFMMUCategory
    - - SyncM category : ExtractEEPROMSyncMCategory()
    - - Tx/RxPDO category : ExtractEEPROMPDOCategory()
    - - DC category : ExtractEEPROMDCCategory()
    - @return eeprom_binary
    - """
    - eeprom = []
    - data = ""
    - eeprom_size = 0
    - eeprom_binary = ""
    -
    - # 'device' is the slave device of the current EtherCAT slave plugin
    - slave = self.Controler.CTNParent.GetSlave(self.Controler.GetSlavePos())
    - type_infos = slave.getType()
    - device, alignment = self.Controler.CTNParent.GetModuleInfos(type_infos)
    -
    - if device is not None:
    - # get ConfigData for EEPROM offset 0x0000-0x000d; <Device>-<Eeprom>-<ConfigData>
    - for eeprom_element in device.getEeprom().getcontent():
    - if eeprom_element["name"] == "ConfigData":
    - data = self.DecimalToHex(eeprom_element)
    - eeprom += self.GenerateEEPROMList(data, 0, 28)
    -
    - # calculate CRC for EEPROM offset 0x000e-0x000f
    - crc = 0x48
    - for segment in eeprom:
    - for i in range(8):
    - bit = crc & 0x80
    - crc = (crc << 1) | ((int(segment, 16) >> (7 - i)) & 0x01)
    - if bit:
    - crc ^= 0x07
    - for k in range(8):
    - bit = crc & 0x80
    - crc <<= 1
    - if bit:
    - crc ^= 0x07
    - eeprom.append(hex(crc)[len(hex(crc))-3:len(hex(crc))-1])
    - eeprom.append("00")
    -
    - # get VendorID for EEPROM offset 0x0010-0x0013;
    - data = ""
    - for vendor_id, vendor in self.Controler.CTNParent.CTNParent.ModulesLibrary.Library.iteritems():
    - for available_device in vendor["groups"][vendor["groups"].keys()[0]]["devices"]:
    - if available_device[0] == type_infos["device_type"]:
    - data = "{:0>8x}".format(vendor_id)
    - eeprom += self.GenerateEEPROMList(data, 1, 8)
    -
    - # get Product Code for EEPROM offset 0x0014-0x0017;
    - data = ""
    - if device.getType().getProductCode() is not None:
    - data = "{:0>8x}".format(ExtractHexDecValue(device.getType().getProductCode()))
    - eeprom += self.GenerateEEPROMList(data, 1, 8)
    -
    - # get Revision Number for EEPROM offset 0x0018-0x001b;
    - data = ""
    - if device.getType().getRevisionNo() is not None:
    - data = "{:0>8x}".format(ExtractHexDecValue(device.getType().getRevisionNo()))
    - eeprom += self.GenerateEEPROMList(data, 1, 8)
    -
    - # get Serial Number for EEPROM 0x001c-0x001f;
    - data = ""
    - if device.getType().getSerialNo() is not None:
    - data = "{:0>8x}".format(ExtractHexDecValue(device.getType().getSerialNo()))
    - eeprom += self.GenerateEEPROMList(data, 1, 8)
    -
    - # get Execution Delay for EEPROM 0x0020-0x0021; not analyzed yet
    - eeprom.append("00")
    - eeprom.append("00")
    -
    - # get Port0/1 Delay for EEPROM offset 0x0022-0x0025; not analyzed yet
    - eeprom.append("00")
    - eeprom.append("00")
    - eeprom.append("00")
    - eeprom.append("00")
    -
    - # reserved for EEPROM offset 0x0026-0x0027;
    - eeprom.append("00")
    - eeprom.append("00")
    -
    - # get BootStrap for EEPROM offset 0x0028-0x002e; <Device>-<Eeprom>-<BootStrap>
    - data = ""
    - for eeprom_element in device.getEeprom().getcontent():
    - if eeprom_element["name"] == "BootStrap":
    - data = "{:0>16x}".format(eeprom_element)
    - eeprom += self.GenerateEEPROMList(data, 0, 16)
    -
    - # get Standard Mailbox for EEPROM offset 0x0030-0x0037; <Device>-<sm>
    - data = ""
    - standard_send_mailbox_offset = None
    - standard_send_mailbox_size = None
    - standard_receive_mailbox_offset = None
    - standard_receive_mailbox_size = None
    - for sm_element in device.getSm():
    - if sm_element.getcontent() == "MBoxOut":
    - standard_receive_mailbox_offset = "{:0>4x}".format(ExtractHexDecValue(sm_element.getStartAddress()))
    - standard_receive_mailbox_size = "{:0>4x}".format(ExtractHexDecValue(sm_element.getDefaultSize()))
    - elif sm_element.getcontent() == "MBoxIn":
    - standard_send_mailbox_offset = "{:0>4x}".format(ExtractHexDecValue(sm_element.getStartAddress()))
    - standard_send_mailbox_size = "{:0>4x}".format(ExtractHexDecValue(sm_element.getDefaultSize()))
    -
    - if standard_receive_mailbox_offset is None:
    - eeprom.append("00")
    - eeprom.append("00")
    - else:
    - eeprom.append(standard_receive_mailbox_offset[2:4])
    - eeprom.append(standard_receive_mailbox_offset[0:2])
    - if standard_receive_mailbox_size is None:
    - eeprom.append("00")
    - eeprom.append("00")
    - else:
    - eeprom.append(standard_receive_mailbox_size[2:4])
    - eeprom.append(standard_receive_mailbox_size[0:2])
    - if standard_send_mailbox_offset is None:
    - eeprom.append("00")
    - eeprom.append("00")
    - else:
    - eeprom.append(standard_send_mailbox_offset[2:4])
    - eeprom.append(standard_send_mailbox_offset[0:2])
    - if standard_send_mailbox_size is None:
    - eeprom.append("00")
    - eeprom.append("00")
    - else:
    - eeprom.append(standard_send_mailbox_size[2:4])
    - eeprom.append(standard_send_mailbox_size[0:2])
    -
    - # get supported mailbox protocols for EEPROM offset 0x0038-0x0039;
    - data = 0
    - mb = device.getMailbox()
    - if mb is not None :
    - for bit,mbprot in enumerate(mailbox_protocols):
    - if getattr(mb,"get%s"%mbprot)() is not None:
    - data += 1<<bit
    - data = "{:0>4x}".format(data)
    - eeprom.append(data[2:4])
    - eeprom.append(data[0:2])
    -
    - # resereved for EEPROM offset 0x003a-0x007b;
    - for i in range(0x007b-0x003a+0x0001):
    - eeprom.append("00")
    -
    - # get EEPROM size for EEPROM offset 0x007c-0x007d;
    - data = ""
    - for eeprom_element in device.getEeprom().getcontent():
    - if eeprom_element["name"] == "ByteSize":
    - eeprom_size = int(str(eeprom_element))
    - data = "{:0>4x}".format(int(eeprom_element)/1024*8-1)
    -
    - if data == "":
    - eeprom.append("00")
    - eeprom.append("00")
    - else:
    - eeprom.append(data[2:4])
    - eeprom.append(data[0:2])
    -
    - # Version for EEPROM 0x007e-0x007f;
    - # According to "EtherCAT Slave Device Description(V0.3.0)"
    - eeprom.append("01")
    - eeprom.append("00")
    -
    - # append String Category data
    - for data in self.ExtractEEPROMStringCategory(device):
    - eeprom.append(data)
    -
    - # append General Category data
    - for data in self.ExtractEEPROMGeneralCategory(device):
    - eeprom.append(data)
    -
    - # append FMMU Category data
    - for data in self.ExtractEEPROMFMMUCategory(device):
    - eeprom.append(data)
    -
    - # append SyncM Category data
    - for data in self.ExtractEEPROMSyncMCategory(device):
    - eeprom.append(data)
    -
    - # append TxPDO Category data
    - for data in self.ExtractEEPROMPDOCategory(device, "TxPdo"):
    - eeprom.append(data)
    -
    - # append RxPDO Category data
    - for data in self.ExtractEEPROMPDOCategory(device, "RxPdo"):
    - eeprom.append(data)
    -
    - # append DC Category data
    - for data in self.ExtractEEPROMDCCategory(device):
    - eeprom.append(data)
    -
    - # append padding
    - padding = eeprom_size-len(eeprom)
    - for i in range(padding):
    - eeprom.append("ff")
    -
    - # convert binary code
    - for index in range(eeprom_size):
    - eeprom_binary = eeprom_binary + eeprom[index].decode('hex')
    -
    - return eeprom_binary
    -
    - def ExtractEEPROMStringCategory(self, device):
    - """
    - Extract "Strings" category data from slave ESI XML and generate EEPROM image data.
    - @param device : 'device' object in the slave ESI XML
    - @return eeprom : "Strings" category EEPROM image data
    - """
    - eeprom = []
    - self.Strings = []
    - data = ""
    - count = 0 # string counter
    - padflag = False # padding flag if category length is odd
    -
    - # index information for General Category in EEPROM
    - self.GroupIdx = 0
    - self.ImgIdx = 0
    - self.OrderIdx = 0
    - self.NameIdx = 0
    -
    - # flag for preventing duplicated vendor specific data
    - typeflag = False
    - grouptypeflag = False
    - groupnameflag = False
    - devnameflag = False
    - imageflag = False
    -
    - # vendor specific data
    - # element1; <EtherCATInfo>-<Descriptions>-<Devices>-<Device>-<Type>
    - # vendor_specific_data : vendor specific data (binary type)
    - vendor_specific_data = ""
    - # vendor_spec_strings : list of vendor specific "strings" for preventing duplicated strings
    - vendor_spec_strings = []
    - for element in device.getType().getcontent():
    - data += element
    - if data is not "" and type(data) == unicode:
    - for vendor_spec_string in vendor_spec_strings:
    - if data == vendor_spec_string:
    - self.OrderIdx = vendor_spec_strings.index(data)+1
    - typeflag = True
    - break
    - if typeflag is False:
    - count += 1
    - self.Strings.append(data)
    - vendor_spec_strings.append(data)
    - typeflag = True
    - self.OrderIdx = count
    - vendor_specific_data += "{:0>2x}".format(len(data))
    - for character in range(len(data)):
    - vendor_specific_data += "{:0>2x}".format(ord(data[character]))
    - data = ""
    -
    - # element2-1; <EtherCATInfo>-<Descriptions>-<Devices>-<Device>-<GroupType>
    - data = device.getGroupType()
    - if data is not None and type(data) == unicode:
    - for vendor_spec_string in vendor_spec_strings:
    - if data == vendor_spec_string:
    - self.GroupIdx = vendor_spec_strings.index(data)+1
    - grouptypeflag = True
    - break
    - if grouptypeflag is False:
    - grouptype = data
    - count += 1
    - self.Strings.append(data)
    - vendor_spec_strings.append(data)
    - grouptypeflag = True
    - self.GroupIdx = count
    - vendor_specific_data += "{:0>2x}".format(len(data))
    - for character in range(len(data)):
    - vendor_specific_data += "{:0>2x}".format(ord(data[character]))
    -
    - # element2-2; <EtherCATInfo>-<Groups>-<Group>-<Type>
    - if grouptypeflag is False:
    - if self.Controler.CTNParent.CTNParent.ModulesLibrary.Library is not None:
    - for vendor_id, vendor in self.Controler.CTNParent.CTNParent.ModulesLibrary.Library.iteritems():
    - for group_type, group_etc in vendor["groups"].iteritems():
    - for device_item in group_etc["devices"]:
    - if device == device_item[1]:
    - data = group_type
    - if data is not None and type(data) == unicode:
    - for vendor_spec_string in vendor_spec_strings:
    - if data == vendor_spec_string:
    - self.GroupIdx = vendor_spec_strings.index(data)+1
    - grouptypeflag = True
    - break
    - if grouptypeflag is False:
    - grouptype = data
    - count += 1
    - self.Strings.append(data)
    - vendor_spec_strings.append(data)
    - grouptypeflag = True
    - self.GroupIdx = count
    - vendor_specific_data += "{:0>2x}".format(len(data))
    - for character in range(len(data)):
    - vendor_specific_data += "{:0>2x}".format(ord(data[character]))
    - data = ""
    -
    - # element3; <EtherCATInfo>-<Descriptions>-<Groups>-<Group>-<Name(LcId is "1033")>
    - if self.Controler.CTNParent.CTNParent.ModulesLibrary.Library is not None:
    - for vendorId, vendor in self.Controler.CTNParent.CTNParent.ModulesLibrary.Library.iteritems():
    - for group_type, group_etc in vendor["groups"].iteritems():
    - for device_item in group_etc["devices"]:
    - if device == device_item[1]:
    - data = group_etc["name"]
    - if data is not "" and type(data) == unicode:
    - for vendor_spec_string in vendor_spec_strings:
    - if data == vendor_spec_string:
    - groupnameflag = True
    - break
    - if groupnameflag is False:
    - count += 1
    - self.Strings.append(data)
    - vendor_spec_strings.append(data)
    - groupnameflag = True
    - vendor_specific_data += "{:0>2x}".format(len(data))
    - for character in range(len(data)):
    - vendor_specific_data += "{:0>2x}".format(ord(data[character]))
    - data = ""
    -
    - # element4; <EtherCATInfo>-<Descriptions>-<Devices>-<Device>-<Name(LcId is "1033" or "1"?)>
    - for element in device.getName():
    - if element.getLcId() == 1 or element.getLcId()==1033:
    - data = element.getcontent()
    - if data is not "" and type(data) == unicode:
    - for vendor_spec_string in vendor_spec_strings:
    - if data == vendor_spec_string:
    - self.NameIdx = vendor_spec_strings.index(data)+1
    - devnameflag = True
    - break
    - if devnameflag is False:
    - count += 1
    - self.Strings.append(data)
    - vendor_spec_strings.append(data)
    - devnameflag = True
    - self.NameIdx = count
    - vendor_specific_data += "{:0>2x}".format(len(data))
    - for character in range(len(data)):
    - vendor_specific_data += "{:0>2x}".format(ord(data[character]))
    - data = ""
    -
    - # element5-1; <EtherCATInfo>-<Descriptions>-<Devices>-<Device>-<Image16x14>
    - if device.getcontent() is not None:
    - data = device.getcontent()
    - if data is not None and type(data) == unicode:
    - for vendor_spec_string in vendor_spec_strings:
    - if data == vendor_spec_string:
    - self.ImgIdx = vendor_spec_strings.index(data)+1
    - imageflag = True
    - break
    - if imageflag is False:
    - count += 1
    - self.Strings.append(data)
    - vendor_spec_strings.append(data)
    - imageflag = True
    - self.ImgIdx = count
    - vendor_specific_data += "{:0>2x}".format(len(data))
    - for character in range(len(data)):
    - vendor_specific_data += "{:0>2x}".format(ord(data[character]))
    -
    - # element5-2; <EtherCATInfo>-<Descriptions>-<Groups>-<Group>-<Image16x14>
    - if imageflag is False:
    - if self.Controler.CTNParent.CTNParent.ModulesLibrary.Library is not None:
    - for vendor_id, vendor in self.Controler.CTNParent.CTNParent.ModulesLibrary.Library.iteritems():
    - for group_type, group_etc in vendor["groups"].iteritems():
    - for device_item in group_etc["devices"]:
    - if device == device_item[1]:
    - data = group_etc
    - if data is not None and type(data) == unicode:
    - for vendor_spec_string in vendor_spec_strings:
    - if data == vendor_spec_string:
    - self.ImgIdx = vendor_spec_strings.index(data)+1
    - imageflag = True
    - break
    - if imageflag is False:
    - count += 1
    - self.Strings.append(data)
    - vendor_spec_strings.append(data)
    - imageflag = True
    - self.ImgIdx = count
    - vendor_specific_data += "{:0>2x}".format(len(data))
    - for character in range(len(data)):
    - vendor_specific_data += "{:0>2x}".format(ord(data[character]))
    - data = ""
    -
    - # DC related elements
    - # <EtherCATInfo>-<Descriptions>-<Devices>-<Device>-<Dc>-<OpMode>-<Name>
    - dc_related_elements = ""
    - if device.getDc() is not None:
    - for element in device.getDc().getOpMode():
    - data = element.getName()
    - if data is not "":
    - count += 1
    - self.Strings.append(data)
    - dc_related_elements += "{:0>2x}".format(len(data))
    - for character in range(len(data)):
    - dc_related_elements += "{:0>2x}".format(ord(data[character]))
    - data = ""
    -
    - # Input elements(TxPDO)
    - # <EtherCATInfo>-<Descriptions>-<Devices>-<Device>-<TxPdo>; Name
    - input_elements = ""
    - inputs = []
    - for element in device.getTxPdo():
    - for name in element.getName():
    - data = name.getcontent()
    - for input in inputs:
    - if data == input:
    - data = ""
    - if data is not "":
    - count += 1
    - self.Strings.append(data)
    - inputs.append(data)
    - input_elements += "{:0>2x}".format(len(data))
    - for character in range(len(data)):
    - input_elements += "{:0>2x}".format(ord(data[character]))
    - data = ""
    - for entry in element.getEntry():
    - for name in entry.getName():
    - data = name.getcontent()
    - for input in inputs:
    - if data == input:
    - data = ""
    - if data is not "":
    - count += 1
    - self.Strings.append(data)
    - inputs.append(data)
    - input_elements += "{:0>2x}".format(len(data))
    - for character in range(len(data)):
    - input_elements += "{:0>2x}".format(ord(data[character]))
    - data = ""
    -
    - # Output elements(RxPDO)
    - # <EtherCATInfo>-<Descriptions>-<Devices>-<Device>-<RxPdo>; Name
    - output_elements = ""
    - outputs = []
    - for element in device.getRxPdo():
    - for name in element.getName():
    - data = name.getcontent()
    - for output in outputs:
    - if data == output:
    - data = ""
    - if data is not "":
    - count += 1
    - self.Strings.append(data)
    - outputs.append(data)
    - output_elements += "{:0>2x}".format(len(data))
    - for character in range(len(data)):
    - output_elements += "{:0>2x}".format(ord(data[character]))
    - data = ""
    - for entry in element.getEntry():
    - for name in entry.getName():
    - data = name.getcontent()
    - for output in outputs:
    - if data == output:
    - data = ""
    - if data is not "":
    - count += 1
    - self.Strings.append(data)
    - outputs.append(data)
    - output_elements += "{:0>2x}".format(len(data))
    - for character in range(len(data)):
    - output_elements += "{:0>2x}".format(ord(data[character]))
    - data = ""
    -
    - # form eeprom data
    - # category header
    - eeprom.append("0a")
    - eeprom.append("00")
    - # category length (word); 1 word is 4 bytes. "+2" is the length of string's total number
    - length = len(vendor_specific_data + dc_related_elements + input_elements + output_elements) + 2
    - if length%4 == 0:
    - pass
    - else:
    - length +=length%4
    - padflag = True
    - eeprom.append("{:0>4x}".format(length/4)[2:4])
    - eeprom.append("{:0>4x}".format(length/4)[0:2])
    - # total numbers of strings
    - eeprom.append("{:0>2x}".format(count))
    - for element in [vendor_specific_data,
    - dc_related_elements,
    - input_elements,
    - output_elements]:
    - for iter in range(len(element)/2):
    - if element == "":
    - eeprom.append("00")
    - else:
    - eeprom.append(element[0:2])
    - element = element[2:len(element)]
    - # padding if length is odd bytes
    - if padflag is True:
    - eeprom.append("ff")
    -
    - return eeprom
    -
    - def ExtractEEPROMGeneralCategory(self, device):
    - """
    - Extract "General" category data from slave ESI XML and generate EEPROM image data.
    - @param device : 'device' object in the slave ESI XML
    - @return eeprom : "Strings" category EEPROM image data
    - """
    - eeprom = []
    - data = ""
    -
    - # category header
    - eeprom.append("1e")
    - eeprom.append("00")
    -
    - # category length
    - eeprom.append("10")
    - eeprom.append("00")
    -
    - # word 1 : Group Type index and Image index in STRINGS Category
    - eeprom.append("{:0>2x}".format(self.GroupIdx))
    - eeprom.append("{:0>2x}".format(self.ImgIdx))
    -
    - # word 2 : Device Type index and Device Name index in STRINGS Category
    - eeprom.append("{:0>2x}".format(self.OrderIdx))
    - eeprom.append("{:0>2x}".format(self.NameIdx))
    -
    - # word 3 : Physical Layer Port info. and CoE Details
    - eeprom.append("01") # Physical Layer Port info - assume 01
    - # CoE Details; <EtherCATInfo>-<Descriptions>-<Devices>-<Device>-<Mailbox>-<CoE>
    - coe_details = 0
    - mb = device.getMailbox()
    - coe_details = 1 # sdo enabled
    - if mb is not None :
    - coe = mb.getCoE()
    - if coe is not None:
    - for bit,flag in enumerate(["SdoInfo", "PdoAssign", "PdoConfig",
    - "PdoUpload", "CompleteAccess"]):
    - if getattr(coe,"get%s"%flag)() is not None:
    - coe_details += 1<<bit
    - eeprom.append("{:0>2x}".format(coe_details))
    -
    - # word 4 : FoE Details and EoE Details
    - # FoE Details; <EtherCATInfo>-<Descriptions>-<Devices>-<Device>-<Mailbox>-<FoE>
    - if mb is not None and mb.getFoE() is not None:
    - eeprom.append("01")
    - else:
    - eeprom.append("00")
    - # EoE Details; <EtherCATInfo>-<Descriptions>-<Devices>-<Device>-<Mailbox>-<EoE>
    - if mb is not None and mb.getEoE() is not None:
    - eeprom.append("01")
    - else:
    - eeprom.append("00")
    -
    - # word 5 : SoE Channels(reserved) and DS402 Channels
    - # SoE Details; <EtherCATInfo>-<Descriptions>-<Devices>-<Device>-<Mailbox>-<SoE>
    - if mb is not None and mb.getSoE() is not None:
    - eeprom.append("01")
    - else:
    - eeprom.append("00")
    - # DS402Channels; <EtherCATInfo>-<Descriptions>-<Devices>-<Device>-<Mailbox>-<CoE>: DS402Channels
    - ds402ch = False
    - if mb is not None :
    - coe = mb.getCoE()
    - if coe is not None :
    - ds402ch = coe.getDS402Channels()
    - eeprom.append("01" if ds402ch in [True,1] else "00")
    -
    - # word 6 : SysmanClass(reserved) and Flags
    - eeprom.append("00") # reserved
    - # Flags
    - en_safeop = False
    - en_lrw = False
    - if device.getType().getTcCfgModeSafeOp() == True \
    - or device.getType().getTcCfgModeSafeOp() == 1:
    - en_safeop = True
    - if device.getType().getUseLrdLwr() == True \
    - or device.getType().getUseLrdLwr() == 1:
    - en_lrw = True
    -
    - flags = "0b"+"000000"+str(int(en_lrw))+str(int(en_safeop))
    - eeprom.append("{:0>2x}".format(int(flags, 2)))
    -
    - # word 7 : Current On EBus (assume 0x0000)
    - eeprom.append("00")
    - eeprom.append("00")
    - # after word 7; couldn't analyze yet
    - eeprom.append("03")
    - eeprom.append("00")
    - eeprom.append("11")
    - eeprom.append("00")
    - eeprom.append("00")
    - eeprom.append("00")
    - eeprom.append("00")
    - eeprom.append("00")
    - eeprom.append("00")
    - eeprom.append("00")
    - eeprom.append("00")
    - eeprom.append("00")
    - eeprom.append("00")
    - eeprom.append("00")
    - eeprom.append("00")
    - eeprom.append("00")
    - eeprom.append("00")
    - eeprom.append("00")
    -
    - return eeprom
    -
    - def ExtractEEPROMFMMUCategory(self, device):
    - """
    - Extract "FMMU" category data from slave ESI XML and generate EEPROM image data.
    - @param device : 'device' object in the slave ESI XML
    - @return eeprom : "Strings" category EEPROM image data
    - """
    - eeprom = []
    - data = ""
    - count = 0 # number of FMMU
    - padflag = False
    -
    - for fmmu in device.getFmmu():
    - count += 1
    - if fmmu.getcontent() == "Outputs":
    - data += "01"
    - if fmmu.getcontent() == "Inputs":
    - data += "02"
    - if fmmu.getcontent() == "MBoxState":
    - data += "03"
    -
    - # construct of EEPROM data
    - if data is not "":
    - # category header
    - eeprom.append("28")
    - eeprom.append("00")
    - # category length
    - if count%2 == 1:
    - padflag = True
    - eeprom.append("{:0>4x}".format((count+1)/2)[2:4])
    - eeprom.append("{:0>4x}".format((count+1)/2)[0:2])
    - else:
    - eeprom.append("{:0>4x}".format((count)/2)[2:4])
    - eeprom.append("{:0>4x}".format((count)/2)[0:2])
    - for i in range(count):
    - if data == "":
    - eeprom.append("00")
    - else:
    - eeprom.append(data[0:2])
    - data = data[2:len(data)]
    - # padding if length is odd bytes
    - if padflag is True:
    - eeprom.append("ff")
    -
    - return eeprom
    -
    - def ExtractEEPROMSyncMCategory(self, device):
    - """
    - Extract "SyncM" category data from slave ESI XML and generate EEPROM image data.
    - @param device : 'device' object in the slave ESI XML
    - @return eeprom : "Strings" category EEPROM image data
    - """
    - eeprom = []
    - data = ""
    - number = {"MBoxOut":"01", "MBoxIn":"02", "Outputs":"03", "Inputs":"04"}
    -
    - for sm in device.getSm():
    - for attr in [sm.getStartAddress(),
    - sm.getDefaultSize(),
    - sm.getControlByte()]:
    - if attr is not None:
    - data += "{:0>4x}".format(ExtractHexDecValue(attr))[2:4]
    - data += "{:0>4x}".format(ExtractHexDecValue(attr))[0:2]
    - else:
    - data += "0000"
    - if sm.getEnable() == "1" or sm.getEnable() == True:
    - data += "01"
    - else:
    - data += "00"
    - data += number[sm.getcontent()]
    -
    - if data is not "":
    - # category header
    - eeprom.append("29")
    - eeprom.append("00")
    - # category length
    - eeprom.append("{:0>4x}".format(len(data)/4)[2:4])
    - eeprom.append("{:0>4x}".format(len(data)/4)[0:2])
    - for i in range(len(data)/2):
    - if data == "":
    - eeprom.append("00")
    - else:
    - eeprom.append(data[0:2])
    - data = data[2:len(data)]
    -
    - return eeprom
    -
    - def ExtractEEPROMPDOCategory(self, device, pdotype):
    - """
    - Extract ""PDO (Tx, Rx)"" category data from slave ESI XML and generate EEPROM image data.
    - @param device : 'device' object in the slave ESI XML
    - @param pdotype : identifier whether "TxPDO" or "RxPDO".
    - @return eeprom : "Strings" category EEPROM image data
    - """
    - eeprom = []
    - data = ""
    - count = 0
    - en_fixed = False
    - en_mandatory = False
    - en_virtual = False
    -
    - for element in eval("device.get%s()"%pdotype):
    - # PDO Index
    - data += "{:0>4x}".format(ExtractHexDecValue(element.getIndex().getcontent()))[2:4]
    - data += "{:0>4x}".format(ExtractHexDecValue(element.getIndex().getcontent()))[0:2]
    - # Number of Entries
    - data += "{:0>2x}".format(len(element.getEntry()))
    - # About Sync Manager
    - if element.getSm() is not None:
    - data += "{:0>2x}".format(element.getSm())
    - else:
    - data += "ff"
    - # Reference to DC Synch (according to ET1100 documentation) - assume 0
    - data += "00"
    - # Name Index
    - objname = ""
    - for name in element.getName():
    - objname = name.getcontent()
    - for name in self.Strings:
    - count += 1
    - if objname == name:
    - break
    - if len(self.Strings)+1 == count:
    - data += "00"
    - else:
    - data += "{:0>2x}".format(count)
    - count = 0
    - # Flags; by Fixed, Mandatory, Virtual attributes ?
    - if element.getFixed() == True or 1:
    - en_fixed = True
    - if element.getMandatory() == True or 1:
    - en_mandatory = True
    - if element.getVirtual() == True or element.getVirtual():
    - en_virtual = True
    - data += str(int(en_fixed)) + str(int(en_mandatory)) + str(int(en_virtual)) + "0"
    -
    - for entry in element.getEntry():
    - # Entry Index
    - data += "{:0>4x}".format(ExtractHexDecValue(entry.getIndex().getcontent()))[2:4]
    - data += "{:0>4x}".format(ExtractHexDecValue(entry.getIndex().getcontent()))[0:2]
    - # Subindex
    - data += "{:0>2x}".format(int(entry.getSubIndex()))
    - # Entry Name Index
    - objname = ""
    - for name in entry.getName():
    - objname = name.getcontent()
    - for name in self.Strings:
    - count += 1
    - if objname == name:
    - break
    - if len(self.Strings)+1 == count:
    - data += "00"
    - else:
    - data += "{:0>2x}".format(count)
    - count = 0
    - # DataType
    - if entry.getDataType() is not None:
    - if entry.getDataType().getcontent() in self.BaseDataTypeDict:
    - data += self.BaseDataTypeDict[entry.getDataType().getcontent()]
    - else:
    - data += "00"
    - else:
    - data += "00"
    - # BitLen
    - if entry.getBitLen() is not None:
    - data += "{:0>2x}".format(int(entry.getBitLen()))
    - else:
    - data += "00"
    - # Flags; by Fixed attributes ?
    - en_fixed = False
    - if entry.getFixed() == True or entry.getFixed() == 1:
    - en_fixed = True
    - data += str(int(en_fixed)) + "000"
    -
    - if data is not "":
    - # category header
    - if pdotype == "TxPdo":
    - eeprom.append("32")
    - elif pdotype == "RxPdo":
    - eeprom.append("33")
    - else:
    - eeprom.append("00")
    - eeprom.append("00")
    - # category length
    - eeprom.append("{:0>4x}".format(len(data)/4)[2:4])
    - eeprom.append("{:0>4x}".format(len(data)/4)[0:2])
    - data = str(data.lower())
    - for i in range(len(data)/2):
    - if data == "":
    - eeprom.append("00")
    - else:
    - eeprom.append(data[0:2])
    - data = data[2:len(data)]
    -
    - return eeprom
    -
    - def ExtractEEPROMDCCategory(self, device):
    - """
    - Extract "DC(Distributed Clock)" category data from slave ESI XML and generate EEPROM image data.
    - @param device : 'device' object in the slave ESI XML
    - @return eeprom : "Strings" category EEPROM image data
    - """
    - eeprom = []
    - data = ""
    - count = 0
    - namecount = 0
    -
    - if device.getDc() is not None:
    - for element in device.getDc().getOpMode():
    - count += 1
    - # assume that word 1-7 are 0x0000
    - data += "0000"
    - data += "0000"
    - data += "0000"
    - data += "0000"
    - data += "0000"
    - data += "0000"
    - data += "0000"
    - # word 8-10
    - # AssignActivate
    - if element.getAssignActivate() is not None:
    - data += "{:0>4x}".format(ExtractHexDecValue(element.getAssignActivate()))[2:4]
    - data += "{:0>4x}".format(ExtractHexDecValue(element.getAssignActivate()))[0:2]
    - else:
    - data += "0000"
    - # Factor of CycleTimeSync0 ? and default is 1?
    - if element.getCycleTimeSync0() is not None:
    - if element.getCycleTimeSync0().getFactor() is not None:
    - data += "{:0>2x}".format(int(element.getCycleTimeSync0().getFactor()))
    - data += "00"
    - else:
    - data += "0100"
    - else:
    - data += "0100"
    - # Index of Name in STRINGS Category
    - # Name Index
    - objname = ""
    - for name in element.getName():
    - objname += name
    - for name in self.Strings:
    - namecount += 1
    - if objname == name:
    - break
    - if len(self.Strings)+1 == namecount:
    - data += "00"
    - else:
    - data += "{:0>2x}".format(namecount)
    - namecount = 0
    - data += "00"
    - # assume that word 11-12 are 0x0000
    - data += "0000"
    - data += "0000"
    -
    - if data is not "":
    - # category header
    - eeprom.append("3c")
    - eeprom.append("00")
    - # category length
    - eeprom.append("{:0>4x}".format(len(data)/4)[2:4])
    - eeprom.append("{:0>4x}".format(len(data)/4)[0:2])
    - data = str(data.lower())
    - for i in range(len(data)/2):
    - if data == "":
    - eeprom.append("00")
    - else:
    - eeprom.append(data[0:2])
    - data = data[2:len(data)]
    -
    - return eeprom
    -
    - #-------------------------------------------------------------------------------
    - # Used Register Access
    - #-------------------------------------------------------------------------------
    - def RegRead(self, offset, length):
    - """
    - Read slave ESC register content using "ethercat reg_read -p %d %s %s" command.
    - Command example : "ethercat reg_read -p 0 0x0c00 0x0400"
    - @param offset : register address
    - @param length : register length
    - @return return_val : register data
    - """
    - error, return_val = self.Controler.RemoteExec(REG_READ%(self.Controler.GetSlavePos(), offset, length), return_val = None)
    - return return_val
    -
    - def RegWrite(self, address, data):
    - """
    - Write data to slave ESC register using "ethercat reg_write -p %d %s %s" command.
    - Command example : "ethercat reg_write -p 0 0x0c04 0x0001"
    - @param address : register address
    - @param data : data to write
    - @return return_val : the execution result of "ethercat reg_write" (for error check)
    - """
    - error, return_val = self.Controler.RemoteExec(REG_WRITE%(self.Controler.GetSlavePos(), address, data), return_val = None)
    - return return_val
    -
    - def Rescan(self):
    - """
    - Synchronize EEPROM data in master controller with the data in slave device after EEPROM write.
    - Command example : "ethercat rescan -p 0"
    - """
    - error, return_val = self.Controler.RemoteExec(RESCAN%(self.Controler.GetSlavePos()), return_val = None)
    -
    - #-------------------------------------------------------------------------------
    - # Common Use Methods
    - #-------------------------------------------------------------------------------
    - def CheckConnect(self, cyclic_flag):
    - """
    - Check connection status (1) between Beremiz and the master (2) between the master and the slave.
    - @param cyclic_flag: 0 - one shot, 1 - periodic
    - @return True or False
    - """
    - if self.Controler.GetCTRoot()._connector is not None:
    - # Check connection between the master and the slave.
    - # Command example : "ethercat xml -p 0"
    - error, return_val = self.Controler.RemoteExec(SLAVE_XML%(self.Controler.GetSlavePos()), return_val = None)
    - number_of_lines = return_val.split("\n")
    - if len(number_of_lines) <= 2 : # No slave connected to the master controller
    - if not cyclic_flag :
    - self.CreateErrorDialog('No connected slaves')
    - return False
    -
    - elif len(number_of_lines) > 2 :
    - return True
    - else:
    - # The master controller is not connected to Beremiz host
    - if not cyclic_flag :
    - self.CreateErrorDialog('PLC not connected!')
    - return False
    -
    - def CreateErrorDialog(self, mention):
    - """
    - Create a dialog to indicate error or warning.
    - @param mention : Error String
    - """
    - app_frame = self.Controler.GetCTRoot().AppFrame
    - dlg = wx.MessageDialog (app_frame, mention,
    - ' Warning...',
    - wx.OK | wx.ICON_INFORMATION)
    - dlg.ShowModal()
    - dlg.Destroy()
    +#!/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, Korea
    +#
    +# See COPYING file for copyrights details.
    +
    +import os
    +import wx
    +
    +mailbox_protocols = ["AoE", "EoE", "CoE", "FoE", "SoE", "VoE"]
    +
    +def ExtractHexDecValue(value):
    + """
    + convert numerical value in string format into decimal or hex format.
    + @param value : hex or decimal data
    + @return integer data
    + """
    + try:
    + return int(value)
    + except Exception:
    + pass
    + try:
    + return int(value.replace("#", "0"), 16)
    +
    + except Exception:
    + raise ValueError, "Invalid value for HexDecValue \"%s\"" % value
    +
    +def ExtractName(names, default=None):
    + """
    + Extract "name" field from XML entries.
    + @param names : XML entry
    + @default : if it fails to extract from the designated XML entry, return the default value ("None").
    + @return default or the name extracted
    + """
    + if len(names) == 1:
    + return names[0].getcontent()
    + else:
    + for name in names:
    + if name.getLcId() == 1033:
    + return name.getcontent()
    + return default
    +
    +#--------------------------------------------------
    +# Remote Exec Etherlab Commands
    +#--------------------------------------------------
    +
    +# --------------------- for master ---------------------------
    +MASTER_STATE = """
    +import commands
    +result = commands.getoutput("ethercat master")
    +returnVal =result
    +"""
    +
    +# --------------------- for slave ----------------------------
    +# ethercat state -p (slave position) (state (INIT, PREOP, SAFEOP, OP))
    +SLAVE_STATE = """
    +import commands
    +result = commands.getoutput("ethercat state -p %d %s")
    +returnVal = result
    +"""
    +
    +# ethercat slave
    +GET_SLAVE = """
    +import commands
    +result = commands.getoutput("ethercat slaves")
    +returnVal =result
    +"""
    +
    +# ethercat xml -p (slave position)
    +SLAVE_XML = """
    +import commands
    +result = commands.getoutput("ethercat xml -p %d")
    +returnVal = result
    +"""
    +
    +# ethercat sdos -p (slave position)
    +SLAVE_SDO = """
    +import commands
    +result = commands.getoutput("ethercat sdos -p %d")
    +returnVal =result
    +"""
    +
    +# ethercat upload -p (slave position) (main index) (sub index)
    +GET_SLOW_SDO = """
    +import commands
    +result = commands.getoutput("ethercat upload -p %d %s %s")
    +returnVal =result
    +"""
    +
    +# ethercat download -p (slave position) (main index) (sub index) (value)
    +SDO_DOWNLOAD = """
    +import commands
    +result = commands.getoutput("ethercat download --type %s -p %d %s %s %s")
    +returnVal =result
    +"""
    +
    +# ethercat sii_read -p (slave position)
    +SII_READ = """
    +import commands
    +result = commands.getoutput("ethercat sii_read -p %d")
    +returnVal =result
    +"""
    +
    +# ethercat reg_read -p (slave position) (address) (size)
    +REG_READ = """
    +import commands
    +result = commands.getoutput("ethercat reg_read -p %d %s %s")
    +returnVal =result
    +"""
    +
    +# ethercat sii_write -p (slave position) - (contents)
    +SII_WRITE = """
    +import subprocess
    +process = subprocess.Popen(
    + ["ethercat", "-f", "sii_write", "-p", "%d", "-"],
    + stdin=subprocess.PIPE)
    +process.communicate(sii_data)
    +returnVal = process.returncode
    +"""
    +
    +# ethercat reg_write -p (slave position) -t (uinit16) (address) (data)
    +REG_WRITE = """
    +import commands
    +result = commands.getoutput("ethercat reg_write -p %d -t uint16 %s %s")
    +returnVal =result
    +"""
    +
    +# ethercat rescan -p (slave position)
    +RESCAN = """
    +import commands
    +result = commands.getoutput("ethercat rescan -p %d")
    +returnVal =result
    +"""
    +
    +#--------------------------------------------------
    +# Common Method For EtherCAT Management
    +#--------------------------------------------------
    +class _CommonSlave:
    +
    + # ----- Data Structure for ethercat management ----
    + SlaveState = ""
    +
    + # category of SDO data
    + DatatypeDescription, CommunicationObject, ManufacturerSpecific, \
    + ProfileSpecific, Reserved, AllSDOData = range(6)
    +
    + # store the execution result of "ethercat sdos" command into SaveSDOData.
    + SaveSDOData = []
    +
    + # Flags for checking "write" permission of OD entries
    + CheckPREOP = False
    + CheckSAFEOP = False
    + CheckOP = False
    +
    + # Save PDO Data
    + TxPDOInfo = []
    + TxPDOCategory = []
    + RxPDOInfo = []
    + RxPDOCategory = []
    +
    + # Save EEPROM Data
    + SiiData = ""
    +
    + # Save Register Data
    + RegData = ""
    + CrtRegSpec = {"ESCType": "",
    + "FMMUNumber": "",
    + "SMNumber": "",
    + "PDIType": ""}
    +
    + def __init__(self, controler):
    + """
    + Constructor
    + @param controler: _EthercatSlaveCTN class in EthercatSlave.py
    + """
    + self.Controler = controler
    +
    + self.ClearSDODataSet()
    +
    + #-------------------------------------------------------------------------------
    + # Used Master State
    + #-------------------------------------------------------------------------------
    + def GetMasterState(self):
    + """
    + Execute "ethercat master" command and parse the execution result
    + @return MasterState
    + """
    +
    + # exectute "ethercat master" command
    + error, return_val = self.Controler.RemoteExec(MASTER_STATE, return_val = None)
    + master_state = {}
    + # parse the reslut
    + for each_line in return_val.splitlines():
    + if len(each_line) > 0 :
    + chunks = each_line.strip().split(':', 1)
    + key = chunks[0]
    + value = []
    + if len(chunks) > 1 :
    + value = chunks[1].split()
    + if '(attached)' in value:
    + value.remove('(attached)')
    + master_state[key] = value
    +
    + return master_state
    +
    + #-------------------------------------------------------------------------------
    + # Used Slave State
    + #-------------------------------------------------------------------------------
    + def RequestSlaveState(self, command):
    + """
    + Set slave state to the specified one using "ethercat states -p %d %s" command.
    + Command example : "ethercat states -p 0 PREOP" (target slave position and target state are given.)
    + @param command : target slave state
    + """
    + error, return_val = self.Controler.RemoteExec(SLAVE_STATE%(self.Controler.GetSlavePos(), command), return_val = None)
    +
    + def GetSlaveStateFromSlave(self):
    + """
    + Get slave information using "ethercat slaves" command and store the information into internal data structure
    + (self.SlaveState) for "Slave State"
    + return_val example : 0 0:0 PREOP + EL9800 (V4.30) (PIC24, SPI, ET1100)
    + """
    + error, return_val = self.Controler.RemoteExec(GET_SLAVE, return_val = None)
    + self.SlaveState = return_val
    + return return_val
    +
    + #-------------------------------------------------------------------------------
    + # Used SDO Management
    + #-------------------------------------------------------------------------------
    + def GetSlaveSDOFromSlave(self):
    + """
    + Get SDO objects information of current slave using "ethercat sdos -p %d" command.
    + Command example : "ethercat sdos -p 0"
    + @return return_val : execution results of "ethercat sdos" command (need to be parsed later)
    + """
    + error, return_val = self.Controler.RemoteExec(SLAVE_SDO%(self.Controler.GetSlavePos()), return_val = None)
    + return return_val
    +
    + def SDODownload(self, data_type, idx, sub_idx, value):
    + """
    + Set an SDO object value to user-specified value using "ethercat download" command.
    + Command example : "ethercat download --type int32 -p 0 0x8020 0x12 0x00000000"
    + @param data_type : data type of SDO entry
    + @param idx : index of the SDO entry
    + @param sub_idx : subindex of the SDO entry
    + @param value : value of SDO entry
    + """
    + error, return_val = self.Controler.RemoteExec(SDO_DOWNLOAD%(data_type, self.Controler.GetSlavePos(), idx, sub_idx, value), return_val = None)
    +
    + def BackupSDODataSet(self):
    + """
    + Back-up current SDO entry information to restore the SDO data
    + in case that the user cancels SDO update operation.
    + """
    + self.BackupDatatypeDescription = self.SaveDatatypeDescription
    + self.BackupCommunicationObject = self.SaveCommunicationObject
    + self.BackupManufacturerSpecific = self.SaveManufacturerSpecific
    + self.BackupProfileSpecific = self.SaveProfileSpecific
    + self.BackupReserved = self.SaveReserved
    + self.BackupAllSDOData = self.SaveAllSDOData
    +
    + def ClearSDODataSet(self):
    + """
    + Clear the specified SDO entry information.
    + """
    + for count in range(6):
    + self.SaveSDOData.append([])
    +
    + #-------------------------------------------------------------------------------
    + # Used PDO Monitoring
    + #-------------------------------------------------------------------------------
    + def RequestPDOInfo(self):
    + """
    + Load slave information from RootClass (XML data) and parse the information (calling SlavePDOData() method).
    + """
    + # Load slave information from ESI XML file (def EthercatMaster.py)
    + slave = self.Controler.CTNParent.GetSlave(self.Controler.GetSlavePos())
    +
    + type_infos = slave.getType()
    + device, alignment = self.Controler.CTNParent.GetModuleInfos(type_infos)
    + # Initialize PDO data set
    + self.ClearDataSet()
    +
    + # if 'device' object is valid, call SavePDOData() to parse PDO data
    + if device is not None :
    + self.SavePDOData(device)
    +
    + def SavePDOData(self, device):
    + """
    + Parse PDO data and store the results in TXPDOCategory and RXPDOCategory
    + Tx(Rx)PDOCategory : index, name, entry number
    + Tx(Rx)Info : entry index, sub index, name, length, type
    + @param device : Slave information extracted from ESI XML file
    + """
    + # Parsing TXPDO entries
    + for pdo, pdo_info in ([(pdo, "Inputs") for pdo in device.getTxPdo()]):
    + # Save pdo_index, entry, and name of each entry
    + pdo_index = ExtractHexDecValue(pdo.getIndex().getcontent())
    + entries = pdo.getEntry()
    + pdo_name = ExtractName(pdo.getName())
    +
    + # Initialize entry number count
    + count = 0
    +
    + # Parse entries
    + for entry in entries:
    + # Save index and subindex
    + index = ExtractHexDecValue(entry.getIndex().getcontent())
    + subindex = ExtractHexDecValue(entry.getSubIndex())
    + # if entry name exists, save entry data
    + if ExtractName(entry.getName()) is not None :
    + entry_infos = {
    + "entry_index" : index,
    + "subindex" : subindex,
    + "name" : ExtractName(entry.getName()),
    + "bitlen" : entry.getBitLen(),
    + "type" : entry.getDataType().getcontent()
    + }
    + self.TxPDOInfo.append(entry_infos)
    + count += 1
    +
    + categorys = {"pdo_index" : pdo_index, "name" : pdo_name, "number_of_entry" : count}
    + self.TxPDOCategory.append(categorys)
    +
    + # Parsing RxPDO entries
    + for pdo, pdo_info in ([(pdo, "Outputs") for pdo in device.getRxPdo()]):
    + # Save pdo_index, entry, and name of each entry
    + pdo_index = ExtractHexDecValue(pdo.getIndex().getcontent())
    + entries = pdo.getEntry()
    + pdo_name = ExtractName(pdo.getName())
    +
    + # Initialize entry number count
    + count = 0
    +
    + # Parse entries
    + for entry in entries:
    + # Save index and subindex
    + index = ExtractHexDecValue(entry.getIndex().getcontent())
    + subindex = ExtractHexDecValue(entry.getSubIndex())
    + # if entry name exists, save entry data
    + if ExtractName(entry.getName()) is not None :
    + entry_infos = {
    + "entry_index" : index,
    + "subindex" : subindex,
    + "name" : ExtractName(entry.getName()),
    + "bitlen" : str(entry.getBitLen()),
    + "type" : entry.getDataType().getcontent()
    + }
    + self.RxPDOInfo.append(entry_infos)
    + count += 1
    +
    + categorys = {"pdo_index" : pdo_index, "name" : pdo_name, "number_of_entry" : count}
    + self.RxPDOCategory.append(categorys)
    +
    + def GetTxPDOCategory(self):
    + """
    + Get TxPDOCategory data structure (Meta informaton of TxPDO).
    + TxPDOCategorys : index, name, number of entries
    + @return TxPDOCategorys
    + """
    + return self.TxPDOCategory
    +
    + def GetRxPDOCategory(self):
    + """
    + Get RxPDOCategory data structure (Meta information of RxPDO).
    + RxPDOCategorys : index, name, number of entries
    + @return RxPDOCategorys
    + """
    + return self.RxPDOCategory
    +
    + def GetTxPDOInfo(self):
    + """
    + Get TxPDOInfo data structure (Detailed information on TxPDO entries).
    + TxPDOInfos : entry index, sub index, name, length, type
    + @return TxPDOInfos
    + """
    + return self.TxPDOInfo
    +
    + def GetRxPDOInfo(self):
    + """
    + Get RxPDOInfo data structure (Detailed information on RxPDO entries).
    + RxPDOInfos : entry index, sub index, name, length, type
    + @return RxPDOInfos
    + """
    + return self.RxPDOInfo
    +
    + def ClearDataSet(self):
    + """
    + Initialize PDO management data structure.
    + """
    + self.TxPDOInfos = []
    + self.TxPDOCategorys = []
    + self.RxPDOInfos = []
    + self.RxPDOCategorys = []
    +
    + #-------------------------------------------------------------------------------
    + # Used EEPROM Management
    + #-------------------------------------------------------------------------------
    + # Base data types in ETG2000; format = {"Name": "BitSize"}
    + BaseDataTypeDict = {"BOOL": "01",
    + "SINT": "02",
    + "INT": "03",
    + "DINT": "04",
    + "USINT": "05",
    + "UINT": "06",
    + "UDINT": "07",
    + "REAL": "08",
    + "INT24": "10",
    + "LREAL": "11",
    + "INT40": "12",
    + "INT48": "13",
    + "INT56": "14",
    + "LINT": "15",
    + "UINT24": "16",
    + "UINT40": "18",
    + "UINT48": "19",
    + "UINT56": "1a",
    + "ULINT": "1b",
    + "USINT": "1e",
    + "BITARR8": "2d",
    + "BITARR16": "2e",
    + "BITARR32": "2f",
    + "BIT1": "30",
    + "BIT2": "31",
    + "BIT3": "32",
    + "BIT4": "33",
    + "BIT5": "34",
    + "BIT6": "35",
    + "BIT7": "36",
    + "BIT8": "37"}
    +
    + def GetSmartViewInfos(self):
    + """
    + Parse XML data for "Smart View" of EEPROM contents.
    + @return smartview_infos : EEPROM contents dictionary
    + """
    +
    + smartview_infos = {"eeprom_size": 128,
    + "pdi_type": 0,
    + "device_emulation": "False",
    + "vendor_id": '0x00000000',
    + "product_code": '0x00000000',
    + "revision_no": '0x00000000',
    + "serial_no": '0x00000000',
    + "supported_mailbox": "",
    + "mailbox_bootstrapconf_outstart": '0',
    + "mailbox_bootstrapconf_outlength": '0',
    + "mailbox_bootstrapconf_instart": '0',
    + "mailbox_bootstrapconf_inlength": '0',
    + "mailbox_standardconf_outstart": '0',
    + "mailbox_standardconf_outlength": '0',
    + "mailbox_standardconf_instart": '0',
    + "mailbox_standardconf_inlength": '0'}
    +
    + slave = self.Controler.CTNParent.GetSlave(self.Controler.GetSlavePos())
    + type_infos = slave.getType()
    + device, alignment = self.Controler.CTNParent.GetModuleInfos(type_infos)
    +
    + # 'device' represents current slave device selected by user
    + if device is not None:
    + for eeprom_element in device.getEeprom().getcontent():
    + # get EEPROM size; <Device>-<Eeprom>-<ByteSize>
    + if eeprom_element["name"] == "ByteSize":
    + smartview_infos["eeprom_size"] = eeprom_element
    +
    + elif eeprom_element["name"] == "ConfigData":
    + configData_data = self.DecimalToHex(eeprom_element)
    + # get PDI type; <Device>-<Eeprom>-<ConfigData> address 0x00
    + smartview_infos["pdi_type"] = int(configData_data[0:2], 16)
    + # get state of device emulation; <Device>-<Eeprom>-<ConfigData> address 0x01
    + if "{:0>8b}".format(int(configData_data[2:4], 16))[7] == '1':
    + smartview_infos["device_emulation"] = "True"
    +
    + elif eeprom_element["name"] == "BootStrap":
    + bootstrap_data = "{:0>16x}".format(eeprom_element)
    + # get bootstrap configuration; <Device>-<Eeprom>-<BootStrap>
    + for cfg, iter in [("mailbox_bootstrapconf_outstart", 0),
    + ("mailbox_bootstrapconf_outlength", 1),
    + ("mailbox_bootstrapconf_instart", 2),
    + ("mailbox_bootstrapconf_inlength", 3)]:
    + smartview_infos[cfg] = str(int(bootstrap_data[4*iter+2:4*(iter+1)]+bootstrap_data[4*iter:4*iter+2], 16))
    +
    + # get protocol (profile) types supported by mailbox; <Device>-<Mailbox>
    + mb = device.getMailbox()
    + if mb is not None:
    + for mailbox_protocol in mailbox_protocols:
    + if getattr(mb,"get%s"%mailbox_protocol)() is not None:
    + smartview_infos["supported_mailbox"] += "%s, "%mailbox_protocol
    + smartview_infos["supported_mailbox"] = smartview_infos["supported_mailbox"].strip(", ")
    +
    + # get standard configuration of mailbox; <Device>-<Sm>
    + for sm_element in device.getSm():
    + if sm_element.getcontent() == "MBoxOut":
    + smartview_infos["mailbox_standardconf_outstart"] = str(ExtractHexDecValue(sm_element.getStartAddress()))
    + smartview_infos["mailbox_standardconf_outlength"] = str(ExtractHexDecValue(sm_element.getDefaultSize()))
    + elif sm_element.getcontent() == "MBoxIn":
    + smartview_infos["mailbox_standardconf_instart"] = str(ExtractHexDecValue(sm_element.getStartAddress()))
    + smartview_infos["mailbox_standardconf_inlength"] = str(ExtractHexDecValue(sm_element.getDefaultSize()))
    + else:
    + pass
    +
    + # get device identity from <Device>-<Type>
    + # vendor ID; by default, pre-defined value in self.ModulesLibrary
    + # if device type in 'vendor' item equals to actual slave device type, set 'vendor_id' to vendor ID.
    + for vendor_id, vendor in self.Controler.CTNParent.CTNParent.ModulesLibrary.Library.iteritems():
    + for available_device in vendor["groups"][vendor["groups"].keys()[0]]["devices"]:
    + if available_device[0] == type_infos["device_type"]:
    + smartview_infos["vendor_id"] = "0x" + "{:0>8x}".format(vendor_id)
    +
    + # product code;
    + if device.getType().getProductCode() is not None:
    + product_code = device.getType().getProductCode()
    + smartview_infos["product_code"] = "0x"+"{:0>8x}".format(ExtractHexDecValue(product_code))
    +
    + # revision number;
    + if device.getType().getRevisionNo() is not None:
    + revision_no = device.getType().getRevisionNo()
    + smartview_infos["revision_no"] = "0x"+"{:0>8x}".format(ExtractHexDecValue(revision_no))
    +
    + # serial number;
    + if device.getType().getSerialNo() is not None:
    + serial_no = device.getType().getSerialNo()
    + smartview_infos["serial_no"] = "0x"+"{:0>8x}".format(ExtractHexDecValue(serial_no))
    +
    + return smartview_infos
    +
    + else:
    + return None
    +
    + def DecimalToHex(self, decnum):
    + """
    + Convert decimal value into hexadecimal representation.
    + @param decnum : decimal value
    + @return hex_data : hexadecimal representation of input value in decimal
    + """
    + value = "%x" % decnum
    + value_len = len(value)
    + if (value_len % 2) == 0:
    + hex_len = value_len
    + else:
    + hex_len = (value_len / 2) * 2 + 2
    +
    + hex_data = ("{:0>"+str(hex_len)+"x}").format(decnum)
    +
    + return hex_data
    +
    + def SiiRead(self):
    + """
    + Get slave EEPROM contents maintained by master device using "ethercat sii_read -p %d" command.
    + Command example : "ethercat sii_read -p 0"
    + @return return_val : result of "ethercat sii_read" (binary data)
    + """
    + error, return_val = self.Controler.RemoteExec(SII_READ%(self.Controler.GetSlavePos()), return_val = None)
    + self.SiiData = return_val
    + return return_val
    +
    + def SiiWrite(self, binary):
    + """
    + Overwrite slave EEPROM contents using "ethercat sii_write -p %d" command.
    + Command example : "ethercat sii_write -p 0 - (binary contents)"
    + @param binary : EEPROM contents in binary data format
    + @return return_val : result of "ethercat sii_write" (If it succeeds, the return value is NULL.)
    + """
    + error, return_val = self.Controler.RemoteExec(SII_WRITE%(self.Controler.GetSlavePos()), return_val = None, sii_data = binary)
    + return return_val
    +
    + def LoadData(self):
    + """
    + Loading data from EEPROM use Sii_Read Method
    + @return self.BinaryCode : slave EEPROM data in binary format (zero-padded)
    + """
    + return_val = self.Controler.CommonMethod.SiiRead()
    + self.BinaryCode = return_val
    + self.Controler.SiiData = self.BinaryCode
    +
    + # append zero-filled padding data up to EEPROM size
    + for index in range(self.SmartViewInfosFromXML["eeprom_size"] - len(self.BinaryCode)):
    + self.BinaryCode = self.BinaryCode +'ff'.decode('hex')
    +
    + return self.BinaryCode
    +
    + def HexRead(self, binary):
    + """
    + Convert binary digit representation into hexadecimal representation for "Hex View" menu.
    + @param binary : binary digits
    + @return hexCode : hexadecimal digits
    + @return hexview_table_row, hexview_table_col : Grid size for "Hex View" UI
    + """
    + row_code = []
    + row_text = ""
    + row = 0
    + hex_code = []
    +
    + hexview_table_col = 17
    +
    + for index in range(0, len(binary)) :
    + if len(binary[index]) != 1:
    + break
    + else:
    + digithexstr = hex(ord(binary[index]))
    +
    + tempvar2 = digithexstr[2:4]
    + if len(tempvar2) == 1:
    + tempvar2 = "0" + tempvar2
    + row_code.append(tempvar2)
    +
    + if int(digithexstr, 16)>=32 and int(digithexstr, 16)<=126:
    + row_text = row_text + chr(int(digithexstr, 16))
    + else:
    + row_text = row_text + "."
    +
    + if index != 0 :
    + if len(row_code) == (hexview_table_col - 1):
    + row_code.append(row_text)
    + hex_code.append(row_code)
    + row_text = ""
    + row_code = []
    + row = row + 1
    +
    + hexview_table_row = row
    +
    + return hex_code, hexview_table_row, hexview_table_col
    +
    + def GenerateEEPROMList(self, data, direction, length):
    + """
    + Generate EEPROM data list by reconstructing 'data' string.
    + example : data="12345678", direction=0, length=8 -> eeprom_list=['12', '34', '56', '78']
    + data="12345678", direction=1, length=8 -> eeprom_list=['78', '56', '34', '12']
    + @param data : string to be reconstructed
    + @param direction : endianness
    + @param length : data length
    + @return eeprom_list : reconstructed list data structure
    + """
    + eeprom_list = []
    +
    + if direction is 0 or 1:
    + for i in range(length/2):
    + if data == "":
    + eeprom_list.append("00")
    + else:
    + eeprom_list.append(data[direction*(length-2):direction*(length-2)+2])
    + data = data[(1-direction)*2:length-direction*2]
    + length -= 2
    + return eeprom_list
    +
    + def XmlToEeprom(self):
    + """
    + Extract slave EEPROM contents using slave ESI XML file.
    + - Mandatory parts
    + - String category : ExtractEEPROMStringCategory()
    + - General category : ExtractEEPROMGeneralCategory()
    + - FMMU category : ExtractEEPROMFMMUCategory
    + - SyncM category : ExtractEEPROMSyncMCategory()
    + - Tx/RxPDO category : ExtractEEPROMPDOCategory()
    + - DC category : ExtractEEPROMDCCategory()
    + @return eeprom_binary
    + """
    + eeprom = []
    + data = ""
    + eeprom_size = 0
    + eeprom_binary = ""
    +
    + # 'device' is the slave device of the current EtherCAT slave plugin
    + slave = self.Controler.CTNParent.GetSlave(self.Controler.GetSlavePos())
    + type_infos = slave.getType()
    + device, alignment = self.Controler.CTNParent.GetModuleInfos(type_infos)
    +
    + if device is not None:
    + # get ConfigData for EEPROM offset 0x0000-0x000d; <Device>-<Eeprom>-<ConfigData>
    + for eeprom_element in device.getEeprom().getcontent():
    + if eeprom_element["name"] == "ConfigData":
    + data = self.DecimalToHex(eeprom_element)
    + eeprom += self.GenerateEEPROMList(data, 0, 28)
    +
    + # calculate CRC for EEPROM offset 0x000e-0x000f
    + crc = 0x48
    + for segment in eeprom:
    + for i in range(8):
    + bit = crc & 0x80
    + crc = (crc << 1) | ((int(segment, 16) >> (7 - i)) & 0x01)
    + if bit:
    + crc ^= 0x07
    + for k in range(8):
    + bit = crc & 0x80
    + crc <<= 1
    + if bit:
    + crc ^= 0x07
    + eeprom.append(hex(crc)[len(hex(crc))-3:len(hex(crc))-1])
    + eeprom.append("00")
    +
    + # get VendorID for EEPROM offset 0x0010-0x0013;
    + data = ""
    + for vendor_id, vendor in self.Controler.CTNParent.CTNParent.ModulesLibrary.Library.iteritems():
    + for available_device in vendor["groups"][vendor["groups"].keys()[0]]["devices"]:
    + if available_device[0] == type_infos["device_type"]:
    + data = "{:0>8x}".format(vendor_id)
    + eeprom += self.GenerateEEPROMList(data, 1, 8)
    +
    + # get Product Code for EEPROM offset 0x0014-0x0017;
    + data = ""
    + if device.getType().getProductCode() is not None:
    + data = "{:0>8x}".format(ExtractHexDecValue(device.getType().getProductCode()))
    + eeprom += self.GenerateEEPROMList(data, 1, 8)
    +
    + # get Revision Number for EEPROM offset 0x0018-0x001b;
    + data = ""
    + if device.getType().getRevisionNo() is not None:
    + data = "{:0>8x}".format(ExtractHexDecValue(device.getType().getRevisionNo()))
    + eeprom += self.GenerateEEPROMList(data, 1, 8)
    +
    + # get Serial Number for EEPROM 0x001c-0x001f;
    + data = ""
    + if device.getType().getSerialNo() is not None:
    + data = "{:0>8x}".format(ExtractHexDecValue(device.getType().getSerialNo()))
    + eeprom += self.GenerateEEPROMList(data, 1, 8)
    +
    + # get Execution Delay for EEPROM 0x0020-0x0021; not analyzed yet
    + eeprom.append("00")
    + eeprom.append("00")
    +
    + # get Port0/1 Delay for EEPROM offset 0x0022-0x0025; not analyzed yet
    + eeprom.append("00")
    + eeprom.append("00")
    + eeprom.append("00")
    + eeprom.append("00")
    +
    + # reserved for EEPROM offset 0x0026-0x0027;
    + eeprom.append("00")
    + eeprom.append("00")
    +
    + # get BootStrap for EEPROM offset 0x0028-0x002e; <Device>-<Eeprom>-<BootStrap>
    + data = ""
    + for eeprom_element in device.getEeprom().getcontent():
    + if eeprom_element["name"] == "BootStrap":
    + data = "{:0>16x}".format(eeprom_element)
    + eeprom += self.GenerateEEPROMList(data, 0, 16)
    +
    + # get Standard Mailbox for EEPROM offset 0x0030-0x0037; <Device>-<sm>
    + data = ""
    + standard_send_mailbox_offset = None
    + standard_send_mailbox_size = None
    + standard_receive_mailbox_offset = None
    + standard_receive_mailbox_size = None
    + for sm_element in device.getSm():
    + if sm_element.getcontent() == "MBoxOut":
    + standard_receive_mailbox_offset = "{:0>4x}".format(ExtractHexDecValue(sm_element.getStartAddress()))
    + standard_receive_mailbox_size = "{:0>4x}".format(ExtractHexDecValue(sm_element.getDefaultSize()))
    + elif sm_element.getcontent() == "MBoxIn":
    + standard_send_mailbox_offset = "{:0>4x}".format(ExtractHexDecValue(sm_element.getStartAddress()))
    + standard_send_mailbox_size = "{:0>4x}".format(ExtractHexDecValue(sm_element.getDefaultSize()))
    +
    + if standard_receive_mailbox_offset is None:
    + eeprom.append("00")
    + eeprom.append("00")
    + else:
    + eeprom.append(standard_receive_mailbox_offset[2:4])
    + eeprom.append(standard_receive_mailbox_offset[0:2])
    + if standard_receive_mailbox_size is None:
    + eeprom.append("00")
    + eeprom.append("00")
    + else:
    + eeprom.append(standard_receive_mailbox_size[2:4])
    + eeprom.append(standard_receive_mailbox_size[0:2])
    + if standard_send_mailbox_offset is None:
    + eeprom.append("00")
    + eeprom.append("00")
    + else:
    + eeprom.append(standard_send_mailbox_offset[2:4])
    + eeprom.append(standard_send_mailbox_offset[0:2])
    + if standard_send_mailbox_size is None:
    + eeprom.append("00")
    + eeprom.append("00")
    + else:
    + eeprom.append(standard_send_mailbox_size[2:4])
    + eeprom.append(standard_send_mailbox_size[0:2])
    +
    + # get supported mailbox protocols for EEPROM offset 0x0038-0x0039;
    + data = 0
    + mb = device.getMailbox()
    + if mb is not None :
    + for bit,mbprot in enumerate(mailbox_protocols):
    + if getattr(mb,"get%s"%mbprot)() is not None:
    + data += 1<<bit
    + data = "{:0>4x}".format(data)
    + eeprom.append(data[2:4])
    + eeprom.append(data[0:2])
    +
    + # resereved for EEPROM offset 0x003a-0x007b;
    + for i in range(0x007b-0x003a+0x0001):
    + eeprom.append("00")
    +
    + # get EEPROM size for EEPROM offset 0x007c-0x007d;
    + data = ""
    + for eeprom_element in device.getEeprom().getcontent():
    + if eeprom_element["name"] == "ByteSize":
    + eeprom_size = int(str(eeprom_element))
    + data = "{:0>4x}".format(int(eeprom_element)/1024*8-1)
    +
    + if data == "":
    + eeprom.append("00")
    + eeprom.append("00")
    + else:
    + eeprom.append(data[2:4])
    + eeprom.append(data[0:2])
    +
    + # Version for EEPROM 0x007e-0x007f;
    + # According to "EtherCAT Slave Device Description(V0.3.0)"
    + eeprom.append("01")
    + eeprom.append("00")
    +
    + # append String Category data
    + for data in self.ExtractEEPROMStringCategory(device):
    + eeprom.append(data)
    +
    + # append General Category data
    + for data in self.ExtractEEPROMGeneralCategory(device):
    + eeprom.append(data)
    +
    + # append FMMU Category data
    + for data in self.ExtractEEPROMFMMUCategory(device):
    + eeprom.append(data)
    +
    + # append SyncM Category data
    + for data in self.ExtractEEPROMSyncMCategory(device):
    + eeprom.append(data)
    +
    + # append TxPDO Category data
    + for data in self.ExtractEEPROMPDOCategory(device, "TxPdo"):
    + eeprom.append(data)
    +
    + # append RxPDO Category data
    + for data in self.ExtractEEPROMPDOCategory(device, "RxPdo"):
    + eeprom.append(data)
    +
    + # append DC Category data
    + for data in self.ExtractEEPROMDCCategory(device):
    + eeprom.append(data)
    +
    + # append padding
    + padding = eeprom_size-len(eeprom)
    + for i in range(padding):
    + eeprom.append("ff")
    +
    + # convert binary code
    + for index in range(eeprom_size):
    + eeprom_binary = eeprom_binary + eeprom[index].decode('hex')
    +
    + return eeprom_binary
    +
    + def ExtractEEPROMStringCategory(self, device):
    + """
    + Extract "Strings" category data from slave ESI XML and generate EEPROM image data.
    + @param device : 'device' object in the slave ESI XML
    + @return eeprom : "Strings" category EEPROM image data
    + """
    + eeprom = []
    + self.Strings = []
    + data = ""
    + count = 0 # string counter
    + padflag = False # padding flag if category length is odd
    +
    + # index information for General Category in EEPROM
    + self.GroupIdx = 0
    + self.ImgIdx = 0
    + self.OrderIdx = 0
    + self.NameIdx = 0
    +
    + # flag for preventing duplicated vendor specific data
    + typeflag = False
    + grouptypeflag = False
    + groupnameflag = False
    + devnameflag = False
    + imageflag = False
    +
    + # vendor specific data
    + # element1; <EtherCATInfo>-<Descriptions>-<Devices>-<Device>-<Type>
    + # vendor_specific_data : vendor specific data (binary type)
    + vendor_specific_data = ""
    + # vendor_spec_strings : list of vendor specific "strings" for preventing duplicated strings
    + vendor_spec_strings = []
    + for element in device.getType().getcontent():
    + data += element
    + if data is not "" and type(data) == unicode:
    + for vendor_spec_string in vendor_spec_strings:
    + if data == vendor_spec_string:
    + self.OrderIdx = vendor_spec_strings.index(data)+1
    + typeflag = True
    + break
    + if typeflag is False:
    + count += 1
    + self.Strings.append(data)
    + vendor_spec_strings.append(data)
    + typeflag = True
    + self.OrderIdx = count
    + vendor_specific_data += "{:0>2x}".format(len(data))
    + for character in range(len(data)):
    + vendor_specific_data += "{:0>2x}".format(ord(data[character]))
    + data = ""
    +
    + # element2-1; <EtherCATInfo>-<Descriptions>-<Devices>-<Device>-<GroupType>
    + data = device.getGroupType()
    + if data is not None and type(data) == unicode:
    + for vendor_spec_string in vendor_spec_strings:
    + if data == vendor_spec_string:
    + self.GroupIdx = vendor_spec_strings.index(data)+1
    + grouptypeflag = True
    + break
    + if grouptypeflag is False:
    + grouptype = data
    + count += 1
    + self.Strings.append(data)
    + vendor_spec_strings.append(data)
    + grouptypeflag = True
    + self.GroupIdx = count
    + vendor_specific_data += "{:0>2x}".format(len(data))
    + for character in range(len(data)):
    + vendor_specific_data += "{:0>2x}".format(ord(data[character]))
    +
    + # element2-2; <EtherCATInfo>-<Groups>-<Group>-<Type>
    + if grouptypeflag is False:
    + if self.Controler.CTNParent.CTNParent.ModulesLibrary.Library is not None:
    + for vendor_id, vendor in self.Controler.CTNParent.CTNParent.ModulesLibrary.Library.iteritems():
    + for group_type, group_etc in vendor["groups"].iteritems():
    + for device_item in group_etc["devices"]:
    + if device == device_item[1]:
    + data = group_type
    + if data is not None and type(data) == unicode:
    + for vendor_spec_string in vendor_spec_strings:
    + if data == vendor_spec_string:
    + self.GroupIdx = vendor_spec_strings.index(data)+1
    + grouptypeflag = True
    + break
    + if grouptypeflag is False:
    + grouptype = data
    + count += 1
    + self.Strings.append(data)
    + vendor_spec_strings.append(data)
    + grouptypeflag = True
    + self.GroupIdx = count
    + vendor_specific_data += "{:0>2x}".format(len(data))
    + for character in range(len(data)):
    + vendor_specific_data += "{:0>2x}".format(ord(data[character]))
    + data = ""
    +
    + # element3; <EtherCATInfo>-<Descriptions>-<Groups>-<Group>-<Name(LcId is "1033")>
    + if self.Controler.CTNParent.CTNParent.ModulesLibrary.Library is not None:
    + for vendorId, vendor in self.Controler.CTNParent.CTNParent.ModulesLibrary.Library.iteritems():
    + for group_type, group_etc in vendor["groups"].iteritems():
    + for device_item in group_etc["devices"]:
    + if device == device_item[1]:
    + data = group_etc["name"]
    + if data is not "" and type(data) == unicode:
    + for vendor_spec_string in vendor_spec_strings:
    + if data == vendor_spec_string:
    + groupnameflag = True
    + break
    + if groupnameflag is False:
    + count += 1
    + self.Strings.append(data)
    + vendor_spec_strings.append(data)
    + groupnameflag = True
    + vendor_specific_data += "{:0>2x}".format(len(data))
    + for character in range(len(data)):
    + vendor_specific_data += "{:0>2x}".format(ord(data[character]))
    + data = ""
    +
    + # element4; <EtherCATInfo>-<Descriptions>-<Devices>-<Device>-<Name(LcId is "1033" or "1"?)>
    + for element in device.getName():
    + if element.getLcId() == 1 or element.getLcId()==1033:
    + data = element.getcontent()
    + if data is not "" and type(data) == unicode:
    + for vendor_spec_string in vendor_spec_strings:
    + if data == vendor_spec_string:
    + self.NameIdx = vendor_spec_strings.index(data)+1
    + devnameflag = True
    + break
    + if devnameflag is False:
    + count += 1
    + self.Strings.append(data)
    + vendor_spec_strings.append(data)
    + devnameflag = True
    + self.NameIdx = count
    + vendor_specific_data += "{:0>2x}".format(len(data))
    + for character in range(len(data)):
    + vendor_specific_data += "{:0>2x}".format(ord(data[character]))
    + data = ""
    +
    + # element5-1; <EtherCATInfo>-<Descriptions>-<Devices>-<Device>-<Image16x14>
    + if device.getcontent() is not None:
    + data = device.getcontent()
    + if data is not None and type(data) == unicode:
    + for vendor_spec_string in vendor_spec_strings:
    + if data == vendor_spec_string:
    + self.ImgIdx = vendor_spec_strings.index(data)+1
    + imageflag = True
    + break
    + if imageflag is False:
    + count += 1
    + self.Strings.append(data)
    + vendor_spec_strings.append(data)
    + imageflag = True
    + self.ImgIdx = count
    + vendor_specific_data += "{:0>2x}".format(len(data))
    + for character in range(len(data)):
    + vendor_specific_data += "{:0>2x}".format(ord(data[character]))
    +
    + # element5-2; <EtherCATInfo>-<Descriptions>-<Groups>-<Group>-<Image16x14>
    + if imageflag is False:
    + if self.Controler.CTNParent.CTNParent.ModulesLibrary.Library is not None:
    + for vendor_id, vendor in self.Controler.CTNParent.CTNParent.ModulesLibrary.Library.iteritems():
    + for group_type, group_etc in vendor["groups"].iteritems():
    + for device_item in group_etc["devices"]:
    + if device == device_item[1]:
    + data = group_etc
    + if data is not None and type(data) == unicode:
    + for vendor_spec_string in vendor_spec_strings:
    + if data == vendor_spec_string:
    + self.ImgIdx = vendor_spec_strings.index(data)+1
    + imageflag = True
    + break
    + if imageflag is False:
    + count += 1
    + self.Strings.append(data)
    + vendor_spec_strings.append(data)
    + imageflag = True
    + self.ImgIdx = count
    + vendor_specific_data += "{:0>2x}".format(len(data))
    + for character in range(len(data)):
    + vendor_specific_data += "{:0>2x}".format(ord(data[character]))
    + data = ""
    +
    + # DC related elements
    + # <EtherCATInfo>-<Descriptions>-<Devices>-<Device>-<Dc>-<OpMode>-<Name>
    + dc_related_elements = ""
    + if device.getDc() is not None:
    + for element in device.getDc().getOpMode():
    + data = element.getName()
    + if data is not "":
    + count += 1
    + self.Strings.append(data)
    + dc_related_elements += "{:0>2x}".format(len(data))
    + for character in range(len(data)):
    + dc_related_elements += "{:0>2x}".format(ord(data[character]))
    + data = ""
    +
    + # Input elements(TxPDO)
    + # <EtherCATInfo>-<Descriptions>-<Devices>-<Device>-<TxPdo>; Name
    + input_elements = ""
    + inputs = []
    + for element in device.getTxPdo():
    + for name in element.getName():
    + data = name.getcontent()
    + for input in inputs:
    + if data == input:
    + data = ""
    + if data is not "":
    + count += 1
    + self.Strings.append(data)
    + inputs.append(data)
    + input_elements += "{:0>2x}".format(len(data))
    + for character in range(len(data)):
    + input_elements += "{:0>2x}".format(ord(data[character]))
    + data = ""
    + for entry in element.getEntry():
    + for name in entry.getName():
    + data = name.getcontent()
    + for input in inputs:
    + if data == input:
    + data = ""
    + if data is not "":
    + count += 1
    + self.Strings.append(data)
    + inputs.append(data)
    + input_elements += "{:0>2x}".format(len(data))
    + for character in range(len(data)):
    + input_elements += "{:0>2x}".format(ord(data[character]))
    + data = ""
    +
    + # Output elements(RxPDO)
    + # <EtherCATInfo>-<Descriptions>-<Devices>-<Device>-<RxPdo>; Name
    + output_elements = ""
    + outputs = []
    + for element in device.getRxPdo():
    + for name in element.getName():
    + data = name.getcontent()
    + for output in outputs:
    + if data == output:
    + data = ""
    + if data is not "":
    + count += 1
    + self.Strings.append(data)
    + outputs.append(data)
    + output_elements += "{:0>2x}".format(len(data))
    + for character in range(len(data)):
    + output_elements += "{:0>2x}".format(ord(data[character]))
    + data = ""
    + for entry in element.getEntry():
    + for name in entry.getName():
    + data = name.getcontent()
    + for output in outputs:
    + if data == output:
    + data = ""
    + if data is not "":
    + count += 1
    + self.Strings.append(data)
    + outputs.append(data)
    + output_elements += "{:0>2x}".format(len(data))
    + for character in range(len(data)):
    + output_elements += "{:0>2x}".format(ord(data[character]))
    + data = ""
    +
    + # form eeprom data
    + # category header
    + eeprom.append("0a")
    + eeprom.append("00")
    + # category length (word); 1 word is 4 bytes. "+2" is the length of string's total number
    + length = len(vendor_specific_data + dc_related_elements + input_elements + output_elements) + 2
    + if length%4 == 0:
    + pass
    + else:
    + length +=length%4
    + padflag = True
    + eeprom.append("{:0>4x}".format(length/4)[2:4])
    + eeprom.append("{:0>4x}".format(length/4)[0:2])
    + # total numbers of strings
    + eeprom.append("{:0>2x}".format(count))
    + for element in [vendor_specific_data,
    + dc_related_elements,
    + input_elements,
    + output_elements]:
    + for iter in range(len(element)/2):
    + if element == "":
    + eeprom.append("00")
    + else:
    + eeprom.append(element[0:2])
    + element = element[2:len(element)]
    + # padding if length is odd bytes
    + if padflag is True:
    + eeprom.append("ff")
    +
    + return eeprom
    +
    + def ExtractEEPROMGeneralCategory(self, device):
    + """
    + Extract "General" category data from slave ESI XML and generate EEPROM image data.
    + @param device : 'device' object in the slave ESI XML
    + @return eeprom : "Strings" category EEPROM image data
    + """
    + eeprom = []
    + data = ""
    +
    + # category header
    + eeprom.append("1e")
    + eeprom.append("00")
    +
    + # category length
    + eeprom.append("10")
    + eeprom.append("00")
    +
    + # word 1 : Group Type index and Image index in STRINGS Category
    + eeprom.append("{:0>2x}".format(self.GroupIdx))
    + eeprom.append("{:0>2x}".format(self.ImgIdx))
    +
    + # word 2 : Device Type index and Device Name index in STRINGS Category
    + eeprom.append("{:0>2x}".format(self.OrderIdx))
    + eeprom.append("{:0>2x}".format(self.NameIdx))
    +
    + # word 3 : Physical Layer Port info. and CoE Details
    + eeprom.append("01") # Physical Layer Port info - assume 01
    + # CoE Details; <EtherCATInfo>-<Descriptions>-<Devices>-<Device>-<Mailbox>-<CoE>
    + coe_details = 0
    + mb = device.getMailbox()
    + coe_details = 1 # sdo enabled
    + if mb is not None :
    + coe = mb.getCoE()
    + if coe is not None:
    + for bit,flag in enumerate(["SdoInfo", "PdoAssign", "PdoConfig",
    + "PdoUpload", "CompleteAccess"]):
    + if getattr(coe,"get%s"%flag)() is not None:
    + coe_details += 1<<bit
    + eeprom.append("{:0>2x}".format(coe_details))
    +
    + # word 4 : FoE Details and EoE Details
    + # FoE Details; <EtherCATInfo>-<Descriptions>-<Devices>-<Device>-<Mailbox>-<FoE>
    + if mb is not None and mb.getFoE() is not None:
    + eeprom.append("01")
    + else:
    + eeprom.append("00")
    + # EoE Details; <EtherCATInfo>-<Descriptions>-<Devices>-<Device>-<Mailbox>-<EoE>
    + if mb is not None and mb.getEoE() is not None:
    + eeprom.append("01")
    + else:
    + eeprom.append("00")
    +
    + # word 5 : SoE Channels(reserved) and DS402 Channels
    + # SoE Details; <EtherCATInfo>-<Descriptions>-<Devices>-<Device>-<Mailbox>-<SoE>
    + if mb is not None and mb.getSoE() is not None:
    + eeprom.append("01")
    + else:
    + eeprom.append("00")
    + # DS402Channels; <EtherCATInfo>-<Descriptions>-<Devices>-<Device>-<Mailbox>-<CoE>: DS402Channels
    + ds402ch = False
    + if mb is not None :
    + coe = mb.getCoE()
    + if coe is not None :
    + ds402ch = coe.getDS402Channels()
    + eeprom.append("01" if ds402ch in [True,1] else "00")
    +
    + # word 6 : SysmanClass(reserved) and Flags
    + eeprom.append("00") # reserved
    + # Flags
    + en_safeop = False
    + en_lrw = False
    + if device.getType().getTcCfgModeSafeOp() == True \
    + or device.getType().getTcCfgModeSafeOp() == 1:
    + en_safeop = True
    + if device.getType().getUseLrdLwr() == True \
    + or device.getType().getUseLrdLwr() == 1:
    + en_lrw = True
    +
    + flags = "0b"+"000000"+str(int(en_lrw))+str(int(en_safeop))
    + eeprom.append("{:0>2x}".format(int(flags, 2)))
    +
    + # word 7 : Current On EBus (assume 0x0000)
    + eeprom.append("00")
    + eeprom.append("00")
    + # after word 7; couldn't analyze yet
    + eeprom.append("03")
    + eeprom.append("00")
    + eeprom.append("11")
    + eeprom.append("00")
    + eeprom.append("00")
    + eeprom.append("00")
    + eeprom.append("00")
    + eeprom.append("00")
    + eeprom.append("00")
    + eeprom.append("00")
    + eeprom.append("00")
    + eeprom.append("00")
    + eeprom.append("00")
    + eeprom.append("00")
    + eeprom.append("00")
    + eeprom.append("00")
    + eeprom.append("00")
    + eeprom.append("00")
    +
    + return eeprom
    +
    + def ExtractEEPROMFMMUCategory(self, device):
    + """
    + Extract "FMMU" category data from slave ESI XML and generate EEPROM image data.
    + @param device : 'device' object in the slave ESI XML
    + @return eeprom : "Strings" category EEPROM image data
    + """
    + eeprom = []
    + data = ""
    + count = 0 # number of FMMU
    + padflag = False
    +
    + for fmmu in device.getFmmu():
    + count += 1
    + if fmmu.getcontent() == "Outputs":
    + data += "01"
    + if fmmu.getcontent() == "Inputs":
    + data += "02"
    + if fmmu.getcontent() == "MBoxState":
    + data += "03"
    +
    + # construct of EEPROM data
    + if data is not "":
    + # category header
    + eeprom.append("28")
    + eeprom.append("00")
    + # category length
    + if count%2 == 1:
    + padflag = True
    + eeprom.append("{:0>4x}".format((count+1)/2)[2:4])
    + eeprom.append("{:0>4x}".format((count+1)/2)[0:2])
    + else:
    + eeprom.append("{:0>4x}".format((count)/2)[2:4])
    + eeprom.append("{:0>4x}".format((count)/2)[0:2])
    + for i in range(count):
    + if data == "":
    + eeprom.append("00")
    + else:
    + eeprom.append(data[0:2])
    + data = data[2:len(data)]
    + # padding if length is odd bytes
    + if padflag is True:
    + eeprom.append("ff")
    +
    + return eeprom
    +
    + def ExtractEEPROMSyncMCategory(self, device):
    + """
    + Extract "SyncM" category data from slave ESI XML and generate EEPROM image data.
    + @param device : 'device' object in the slave ESI XML
    + @return eeprom : "Strings" category EEPROM image data
    + """
    + eeprom = []
    + data = ""
    + number = {"MBoxOut":"01", "MBoxIn":"02", "Outputs":"03", "Inputs":"04"}
    +
    + for sm in device.getSm():
    + for attr in [sm.getStartAddress(),
    + sm.getDefaultSize(),
    + sm.getControlByte()]:
    + if attr is not None:
    + data += "{:0>4x}".format(ExtractHexDecValue(attr))[2:4]
    + data += "{:0>4x}".format(ExtractHexDecValue(attr))[0:2]
    + else:
    + data += "0000"
    + if sm.getEnable() == "1" or sm.getEnable() == True:
    + data += "01"
    + else:
    + data += "00"
    + data += number[sm.getcontent()]
    +
    + if data is not "":
    + # category header
    + eeprom.append("29")
    + eeprom.append("00")
    + # category length
    + eeprom.append("{:0>4x}".format(len(data)/4)[2:4])
    + eeprom.append("{:0>4x}".format(len(data)/4)[0:2])
    + for i in range(len(data)/2):
    + if data == "":
    + eeprom.append("00")
    + else:
    + eeprom.append(data[0:2])
    + data = data[2:len(data)]
    +
    + return eeprom
    +
    + def ExtractEEPROMPDOCategory(self, device, pdotype):
    + """
    + Extract ""PDO (Tx, Rx)"" category data from slave ESI XML and generate EEPROM image data.
    + @param device : 'device' object in the slave ESI XML
    + @param pdotype : identifier whether "TxPDO" or "RxPDO".
    + @return eeprom : "Strings" category EEPROM image data
    + """
    + eeprom = []
    + data = ""
    + count = 0
    + en_fixed = False
    + en_mandatory = False
    + en_virtual = False
    +
    + for element in eval("device.get%s()"%pdotype):
    + # PDO Index
    + data += "{:0>4x}".format(ExtractHexDecValue(element.getIndex().getcontent()))[2:4]
    + data += "{:0>4x}".format(ExtractHexDecValue(element.getIndex().getcontent()))[0:2]
    + # Number of Entries
    + data += "{:0>2x}".format(len(element.getEntry()))
    + # About Sync Manager
    + if element.getSm() is not None:
    + data += "{:0>2x}".format(element.getSm())
    + else:
    + data += "ff"
    + # Reference to DC Synch (according to ET1100 documentation) - assume 0
    + data += "00"
    + # Name Index
    + objname = ""
    + for name in element.getName():
    + objname = name.getcontent()
    + for name in self.Strings:
    + count += 1
    + if objname == name:
    + break
    + if len(self.Strings)+1 == count:
    + data += "00"
    + else:
    + data += "{:0>2x}".format(count)
    + count = 0
    + # Flags; by Fixed, Mandatory, Virtual attributes ?
    + if element.getFixed() == True or 1:
    + en_fixed = True
    + if element.getMandatory() == True or 1:
    + en_mandatory = True
    + if element.getVirtual() == True or element.getVirtual():
    + en_virtual = True
    + data += str(int(en_fixed)) + str(int(en_mandatory)) + str(int(en_virtual)) + "0"
    +
    + for entry in element.getEntry():
    + # Entry Index
    + data += "{:0>4x}".format(ExtractHexDecValue(entry.getIndex().getcontent()))[2:4]
    + data += "{:0>4x}".format(ExtractHexDecValue(entry.getIndex().getcontent()))[0:2]
    + # Subindex
    + data += "{:0>2x}".format(int(entry.getSubIndex()))
    + # Entry Name Index
    + objname = ""
    + for name in entry.getName():
    + objname = name.getcontent()
    + for name in self.Strings:
    + count += 1
    + if objname == name:
    + break
    + if len(self.Strings)+1 == count:
    + data += "00"
    + else:
    + data += "{:0>2x}".format(count)
    + count = 0
    + # DataType
    + if entry.getDataType() is not None:
    + if entry.getDataType().getcontent() in self.BaseDataTypeDict:
    + data += self.BaseDataTypeDict[entry.getDataType().getcontent()]
    + else:
    + data += "00"
    + else:
    + data += "00"
    + # BitLen
    + if entry.getBitLen() is not None:
    + data += "{:0>2x}".format(int(entry.getBitLen()))
    + else:
    + data += "00"
    + # Flags; by Fixed attributes ?
    + en_fixed = False
    + if entry.getFixed() == True or entry.getFixed() == 1:
    + en_fixed = True
    + data += str(int(en_fixed)) + "000"
    +
    + if data is not "":
    + # category header
    + if pdotype == "TxPdo":
    + eeprom.append("32")
    + elif pdotype == "RxPdo":
    + eeprom.append("33")
    + else:
    + eeprom.append("00")
    + eeprom.append("00")
    + # category length
    + eeprom.append("{:0>4x}".format(len(data)/4)[2:4])
    + eeprom.append("{:0>4x}".format(len(data)/4)[0:2])
    + data = str(data.lower())
    + for i in range(len(data)/2):
    + if data == "":
    + eeprom.append("00")
    + else:
    + eeprom.append(data[0:2])
    + data = data[2:len(data)]
    +
    + return eeprom
    +
    + def ExtractEEPROMDCCategory(self, device):
    + """
    + Extract "DC(Distributed Clock)" category data from slave ESI XML and generate EEPROM image data.
    + @param device : 'device' object in the slave ESI XML
    + @return eeprom : "Strings" category EEPROM image data
    + """
    + eeprom = []
    + data = ""
    + count = 0
    + namecount = 0
    +
    + if device.getDc() is not None:
    + for element in device.getDc().getOpMode():
    + count += 1
    + # assume that word 1-7 are 0x0000
    + data += "0000"
    + data += "0000"
    + data += "0000"
    + data += "0000"
    + data += "0000"
    + data += "0000"
    + data += "0000"
    + # word 8-10
    + # AssignActivate
    + if element.getAssignActivate() is not None:
    + data += "{:0>4x}".format(ExtractHexDecValue(element.getAssignActivate()))[2:4]
    + data += "{:0>4x}".format(ExtractHexDecValue(element.getAssignActivate()))[0:2]
    + else:
    + data += "0000"
    + # Factor of CycleTimeSync0 ? and default is 1?
    + if element.getCycleTimeSync0() is not None:
    + if element.getCycleTimeSync0().getFactor() is not None:
    + data += "{:0>2x}".format(int(element.getCycleTimeSync0().getFactor()))
    + data += "00"
    + else:
    + data += "0100"
    + else:
    + data += "0100"
    + # Index of Name in STRINGS Category
    + # Name Index
    + objname = ""
    + for name in element.getName():
    + objname += name
    + for name in self.Strings:
    + namecount += 1
    + if objname == name:
    + break
    + if len(self.Strings)+1 == namecount:
    + data += "00"
    + else:
    + data += "{:0>2x}".format(namecount)
    + namecount = 0
    + data += "00"
    + # assume that word 11-12 are 0x0000
    + data += "0000"
    + data += "0000"
    +
    + if data is not "":
    + # category header
    + eeprom.append("3c")
    + eeprom.append("00")
    + # category length
    + eeprom.append("{:0>4x}".format(len(data)/4)[2:4])
    + eeprom.append("{:0>4x}".format(len(data)/4)[0:2])
    + data = str(data.lower())
    + for i in range(len(data)/2):
    + if data == "":
    + eeprom.append("00")
    + else:
    + eeprom.append(data[0:2])
    + data = data[2:len(data)]
    +
    + return eeprom
    +
    + #-------------------------------------------------------------------------------
    + # Used Register Access
    + #-------------------------------------------------------------------------------
    + def RegRead(self, offset, length):
    + """
    + Read slave ESC register content using "ethercat reg_read -p %d %s %s" command.
    + Command example : "ethercat reg_read -p 0 0x0c00 0x0400"
    + @param offset : register address
    + @param length : register length
    + @return return_val : register data
    + """
    + error, return_val = self.Controler.RemoteExec(REG_READ%(self.Controler.GetSlavePos(), offset, length), return_val = None)
    + return return_val
    +
    + def RegWrite(self, address, data):
    + """
    + Write data to slave ESC register using "ethercat reg_write -p %d %s %s" command.
    + Command example : "ethercat reg_write -p 0 0x0c04 0x0001"
    + @param address : register address
    + @param data : data to write
    + @return return_val : the execution result of "ethercat reg_write" (for error check)
    + """
    + error, return_val = self.Controler.RemoteExec(REG_WRITE%(self.Controler.GetSlavePos(), address, data), return_val = None)
    + return return_val
    +
    + def Rescan(self):
    + """
    + Synchronize EEPROM data in master controller with the data in slave device after EEPROM write.
    + Command example : "ethercat rescan -p 0"
    + """
    + error, return_val = self.Controler.RemoteExec(RESCAN%(self.Controler.GetSlavePos()), return_val = None)
    +
    + #-------------------------------------------------------------------------------
    + # Common Use Methods
    + #-------------------------------------------------------------------------------
    + def CheckConnect(self, cyclic_flag):
    + """
    + Check connection status (1) between Beremiz and the master (2) between the master and the slave.
    + @param cyclic_flag: 0 - one shot, 1 - periodic
    + @return True or False
    + """
    + if self.Controler.GetCTRoot()._connector is not None:
    + # Check connection between the master and the slave.
    + # Command example : "ethercat xml -p 0"
    + error, return_val = self.Controler.RemoteExec(SLAVE_XML%(self.Controler.GetSlavePos()), return_val = None)
    + number_of_lines = return_val.split("\n")
    + if len(number_of_lines) <= 2 : # No slave connected to the master controller
    + if not cyclic_flag :
    + self.CreateErrorDialog('No connected slaves')
    + return False
    +
    + elif len(number_of_lines) > 2 :
    + return True
    + else:
    + # The master controller is not connected to Beremiz host
    + if not cyclic_flag :
    + self.CreateErrorDialog('PLC not connected!')
    + return False
    +
    + def CreateErrorDialog(self, mention):
    + """
    + Create a dialog to indicate error or warning.
    + @param mention : Error String
    + """
    + app_frame = self.Controler.GetCTRoot().AppFrame
    + dlg = wx.MessageDialog (app_frame, mention,
    + ' Warning...',
    + wx.OK | wx.ICON_INFORMATION)
    + dlg.ShowModal()
    + dlg.Destroy()
    --- a/etherlab/ConfigEditor.py Fri Sep 28 17:14:42 2018 +0300
    +++ b/etherlab/ConfigEditor.py Fri Sep 28 17:15:53 2018 +0300
    @@ -25,9 +25,9 @@
    from controls.CustomStyledTextCtrl import NAVIGATION_KEYS
    # -----------------------------------------------------------------------
    -from EtherCATManagementEditor import EtherCATManagementTreebook, MasterStatePanelClass
    -# -----------------------------------------------------------------------
    -
    +from EtherCATManagementEditor import EtherCATManagementTreebook, MasterStatePanelClass
    +# -----------------------------------------------------------------------
    +
    [ETHERCAT_VENDOR, ETHERCAT_GROUP, ETHERCAT_DEVICE] = range(3)
    def AppendMenu(parent, help, id, kind, text):
    --- a/etherlab/EtherCATManagementEditor.py Fri Sep 28 17:14:42 2018 +0300
    +++ b/etherlab/EtherCATManagementEditor.py Fri Sep 28 17:15:53 2018 +0300
    @@ -1,2207 +1,2207 @@
    -#!/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 Exception:
    - 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 Exception:
    - 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 Exception:
    - 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 Exception:
    - 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 Exception:
    - 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 Exception:
    - 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!')
    +#!/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 Exception:
    + 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 Exception:
    + 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 Exception:
    + 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 Exception:
    + 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 Exception:
    + 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 Exception:
    + 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!')