"""

# exectute "ethercat master" command

master_state = {}

# parse the reslut

for each_line in return_val.splitlines():

Command example : "ethercat states -p 0 PREOP" (target slave position and target state are given.)

@param command : target slave state

"""

def GetSlaveStateFromSlave(self):

"""

(self.SlaveState) for "Slave State"

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

"""

self.SlaveState = return_val

return return_val

Command example : "ethercat sdos -p 0"

@return return_val : execution results of "ethercat sdos" command (need to be parsed later)

"""

return return_val

def SDODownload(self, data_type, idx, sub_idx, value):

@param sub_idx : subindex of the SDO entry

@param value : value of SDO entry

"""

def BackupSDODataSet(self):

"""

"""

Clear the specified SDO entry information.

"""

self.SaveSDOData.append([])

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

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

type_infos = slave.getType()

# Initialize PDO data set

self.ClearDataSet()

@param device : Slave information extracted from ESI XML file

"""

# Parsing TXPDO entries

# Save pdo_index, entry, and name of each entry

pdo_index = ExtractHexDecValue(pdo.getIndex().getcontent())

entries = pdo.getEntry()

self.TxPDOCategory.append(categorys)

# Parsing RxPDO entries

# Save pdo_index, entry, and name of each entry

pdo_index = ExtractHexDecValue(pdo.getIndex().getcontent())

entries = pdo.getEntry()

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

type_infos = slave.getType()

# 'device' represents current slave device selected by user

if device is not None:

Command example : "ethercat sii_read -p 0"

@return return_val : result of "ethercat sii_read" (binary data)

"""

self.SiiData = return_val

return return_val

@param binary : EEPROM contents in binary data format

@return return_val : result of "ethercat sii_write" (If it succeeds, the return value is NULL.)

"""

return return_val

def LoadData(self):

self.Controler.SiiData = self.BinaryCode

# append zero-filled padding data up to EEPROM size

self.BinaryCode = self.BinaryCode + 'ff'.decode('hex')

return self.BinaryCode

eeprom_list = []

if direction is 0 or 1:

if data == "":

eeprom_list.append("00")

else:

# 'device' is the slave device of the current EtherCAT slave plugin

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

type_infos = slave.getType()

if device is not None:

# get ConfigData for EEPROM offset 0x0000-0x000d; <Device>-<Eeprom>-<ConfigData>

crc = (crc << 1) | ((int(segment, 16) >> (7 - i)) & 0x01)

if bit:

crc ^= 0x07

bit = crc & 0x80

crc <<= 1

if bit:

grouptypeflag = True

break

if grouptypeflag is False:

count += 1

self.Strings.append(data)

vendor_spec_strings.append(data)

# element2-2; <EtherCATInfo>-<Groups>-<Group>-<Type>

if grouptypeflag is False:

if self.Controler.CTNParent.CTNParent.ModulesLibrary.Library is not None:

for group_type, group_etc in vendor["groups"].iteritems():

for device_item in group_etc["devices"]:

if device == device_item[1]:

grouptypeflag = True

break

if grouptypeflag is False:

count += 1

self.Strings.append(data)

vendor_spec_strings.append(data)

# element3; <EtherCATInfo>-<Descriptions>-<Groups>-<Group>-<Name(LcId is "1033")>

if self.Controler.CTNParent.CTNParent.ModulesLibrary.Library is not None:

for group_type, group_etc in vendor["groups"].iteritems():

for device_item in group_etc["devices"]:

if device == device_item[1]:

# element5-2; <EtherCATInfo>-<Descriptions>-<Groups>-<Group>-<Image16x14>

if imageflag is False:

if self.Controler.CTNParent.CTNParent.ModulesLibrary.Library is not None:

for group_type, group_etc in vendor["groups"].iteritems():

for device_item in group_etc["devices"]:

if device == device_item[1]:

dc_related_elements,

input_elements,

output_elements]:

if element == "":

eeprom.append("00")

else:

@return eeprom : "Strings" category EEPROM image data

"""

eeprom = []

# category header

eeprom.append("1e")

else:

eeprom.append("{:0>4x}".format((count)/2)[2:4])

eeprom.append("{:0>4x}".format((count)/2)[0:2])

if data == "":

eeprom.append("00")

else:

# category length

eeprom.append("{:0>4x}".format(len(data)/4)[2:4])

eeprom.append("{:0>4x}".format(len(data)/4)[0:2])

if data == "":

eeprom.append("00")

else:

eeprom.append("{:0>4x}".format(len(data)/4)[2:4])

eeprom.append("{:0>4x}".format(len(data)/4)[0:2])

data = str(data.lower())

if data == "":

eeprom.append("00")

else:

eeprom.append("{:0>4x}".format(len(data)/4)[2:4])

eeprom.append("{:0>4x}".format(len(data)/4)[0:2])

data = str(data.lower())

if data == "":

eeprom.append("00")

else:

@param length : register length

@return return_val : register data

"""

return return_val

def RegWrite(self, address, data):

@param data : data to write

@return return_val : the execution result of "ethercat reg_write" (for error check)

"""

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"

"""

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

# Common Use Methods

if self.Controler.GetCTRoot()._connector is not None:

# Check connection between the master and the slave.

# Command example : "ethercat xml -p 0"

number_of_lines = return_val.split("\n")

if len(number_of_lines) <= 2: # No slave connected to the master controller

if not cyclic_flag:

event.Skip()

def OnVariablesGridLeftClick(self, event):

if item.IsOk():

entry = self.VariablesGrid.GetItemPyData(item)

data_type = entry.get("Type", "")

for colname, colsize, colalign in zip(

[_("Name")] + [param_infos["column_label"]

self.ModuleLibrary.MODULES_EXTRA_PARAMS],

[400] + [param_infos["column_size"]

self.ModuleLibrary.MODULES_EXTRA_PARAMS],

[wx.ALIGN_LEFT] + [wx.ALIGN_RIGHT] * len(self.ModuleLibrary.MODULES_EXTRA_PARAMS)):

self.ModulesGrid.AddColumn(_(colname), colsize, colalign, edit=True)

item = self.ModulesGrid.AppendItem(root, "")

self.ModulesGrid.SetItemText(item, module["name"], 0)

if module["infos"] is not None:

self.ModulesGrid.SetItemText(item,

str(module["infos"][param]),

param_idx + 1)

def OnDeleteButton(self, event):

filepath = self.GetSelectedFilePath()

if os.path.isfile(filepath):

dialog = wx.MessageDialog(self.ParentWindow,

_("Do you really want to delete the file '%s'?") % filename,

event.Skip()

def OnModulesGridLeftDown(self, event):

if item.IsOk():

entry_infos = self.ModulesGrid.GetItemPyData(item)

if entry_infos is not None and col > 0:

event.Veto()

def OnModulesGridHeaderMotion(self, event):

if col != self.LastToolTipCol and self.LastToolTipCol is not None:

self.ModulesGrid.GetHeaderWindow().SetToolTip(None)

self.LastToolTipCol = None

if col > 0 and self.LastToolTipCol != col:

self.LastToolTipCol = col

wx.CallAfter(self.ModulesGrid.GetHeaderWindow().SetToolTipString,

param_infos["description"])

event.Skip()

for spname, spclass in subs:

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

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

# For SlaveState Panel

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

# (2) Otherwise, show error message and return

else:

if status == "Started":

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

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

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

token_head = token_head.split(",")

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

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

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

token_tail = token_tail.split(",")

try:

# SDO data is not return "dec value"

# line example :

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

except Exception:

name_after_check = self.StringTest(name)

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

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

else:

# If user click "Cancel" loop suspend immediately

if not keep_going:

self.CreateNoteBook()

def CreateNoteBook(self):

"""

Create each NoteBook page, divided SDO index

("0x6000 - 0x9fff", self.parent.ProfileSpecific),

("0xa000 - 0xffff", self.parent.Reserved)]

self.DeleteAllPages()

self.Win = SlaveSDOTable(self, self.Data)

self.AddPage(self.Win, txt)

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

# For SDO Grid (fill index, subindex, etc...)

self.AddPage(RxWin, "RxPDO")

self.AddPage(TxWin, "TxPDO")

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

# For PDO Notebook (divide PDO index)

self.AddPage(win, txt)

count += 1

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

# For PDO Grid (fill entry index, subindex etc...)

# 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:

if status is not "Started":

dialog = wx.FileDialog(self, _("Choose a binary file"), os.getcwd(), "", _("bin files (*.bin)|*.bin"), wx.OPEN)

# and whether status is "Started" or not.

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

if check_connect_flag:

if status is not "Started":

self.Controler.CommonMethod.SiiWrite(self.SiiBinary)

self.Controler.CommonMethod.Rescan()

# Initialize pages

self.RegPage = []

self.RegPage.append(None)

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))

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

# For Register Access Notebook Panel

from PLCControler import LOCATION_CONFNODE, LOCATION_VAR_INPUT

from etherlab.EthercatSlave import _EthercatSlaveCTN, _CommonSlave

from etherlab.ConfigEditor import CIA402NodeEditor

location_str = "_".join(map(str, current_location))

slave_pos = self.GetSlavePos()

# Open CIA402 node code template file

plc_cia402node_filepath = os.path.join(os.path.split(__file__)[0],

return_outputs = "\n".join([

"""\

for output_name in ["DONE", "BUSY", "ERROR"] + [

output["name"].upper()

for output in blocktype_infos["outputs"]]

])

fieldbus_interface_declaration.append("""

extern void ETHERLAB%(ucase_blocktype)s_body__(ETHERLAB%(ucase_blocktype)s* data__);

void __%(blocktype)s_%(location_str)s(MC_%(ucase_blocktype)s *data__) {

%(extract_inputs)s

ETHERLAB%(ucase_blocktype)s_body__(%(blockname)s);

%(return_outputs)s

fieldbus_interface_definition.append("""\

AxsPub.axis->__mcl_func_MC_%(blocktype)s = __%(blocktype)s_%(location_str)s;\

# Get a copy list of default variables to map

variables = NODE_VARIABLES[:]

variables.append(variable_infos["description"])

# Add code to publish or retrive variable

if template is not None:

extra_variables_publish.append(template % locals())

else str(param["value"]))

init_axis_params.append("""\

# Add each variable in list of variables to map to master list of

# variables to add to network configuration

for name, index, subindex, var_type, dir in variables:

var_size = self.GetSizeOfType(var_type)

var_name = """\

extern_located_variables_declaration.append(

entry_variables.append(

init_entry_variables.append(

self.CTNParent.FileGenerator.DeclareVariable(

slave_pos, index, subindex, var_type, dir, var_name)

ethelabfile.write(etherlab_ext_code)

ethelabfile.close()

return ((["etherlab_ext"], [(Gen_etherlabfile_path, IECCFLAGS)], True), "",

("runtime_etherlab.py", file(GetLocalPath("runtime_etherlab.py"))))

self.GetSlaveTypesLibrary())

if dialog.ShowModal() == wx.ID_OK:

type_infos = dialog.GetValueInfos()

if device is not None:

if HAS_MCL and _EthercatCIA402SlaveCTN.NODE_PROFILE in device.GetProfileNumbers():

ConfNodeType = "EthercatCIA402Slave"

type_infos = slave.getType()

if vendor is not None and ExtractHexDecValue(type_infos["vendor"]) != vendor:

return False

if slave_profile is not None and slave_profile not in device.GetProfileNumbers():

return False

return True

"product_code": slave["product_code"],

"revision_number": slave["revision_number"],

}

if device is not None:

if HAS_MCL and _EthercatCIA402SlaveCTN.NODE_PROFILE in device.GetProfileNumbers():

CTNType = "EthercatCIA402Slave"

slave = self.GetSlave(slave_pos)

if slave is not None:

type_infos = slave.getType()

if device is not None:

infos = type_infos.copy()

infos.update({"physics": device.getPhysics(),

slave = self.GetSlave(slave_pos)

if slave is not None:

type_infos = slave.getType()

if device is not None:

entries = device.GetEntriesList(limits)

entries_list = entries.items()

entries = []

current_index = None

current_entry = {}

entry["children"] = []

if slave_pos is not None:

entry["Position"] = str(slave_pos)

def GetSlaveVariableDataType(self, slave_pos, index, subindex):

slave = self.GetSlave(slave_pos)

if slave is not None:

if device is not None:

entries = device.GetEntriesList()

entry_infos = entries.get((index, subindex))

type_infos = slave.getType()

if vendor is not None and ExtractHexDecValue(type_infos["vendor"]) != vendor:

continue

if slave_profile is not None and slave_profile not in device.GetProfileNumbers():

continue

entries.extend(self.GetSlaveVariables(slave_position, limits, device))

if slave is not None:

type_infos = slave.getType()

if device is not None:

sync_managers = []

for sync_manager in device.getSm():

vendor = ExtractHexDecValue(module_infos["vendor"])

vendor_infos = self.Library.get(vendor)

if vendor_infos is not None:

for device_type, device_infos in group_infos["devices"]:

product_code = ExtractHexDecValue(device_infos.getType().getProductCode())

revision_number = ExtractHexDecValue(device_infos.getType().getRevisionNo())

has_header = False

else:

params_values = {}

self.MODULES_EXTRA_PARAMS, row[3:]):

if value != "":

params_values[param] = int(value)

def SaveModulesExtraParams(self):

csvfile = open(self.GetModulesExtraParamsFilePath(), "wb")

writer = csv.writer(csvfile, delimiter=';')

writer.writerow(['Vendor', 'product_code', 'revision_number'] + extra_params)

for (vendor, product_code, revision_number), module_extra_params in self.ModulesExtraParams.iteritems():