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

@param command : target slave state

"""

def GetSlaveStateFromSlave(self):

"""

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

"""

mb = device.getMailbox()

if mb is not None:

for mailbox_protocol in mailbox_protocols:

smartview_infos["supported_mailbox"] = smartview_infos["supported_mailbox"].strip(", ")

# get standard configuration of mailbox; <Device>-<Sm>

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

mb = device.getMailbox()

if mb is not None :

for bit,mbprot in enumerate(mailbox_protocols):

data += 1<<bit

data = "{:0>4x}".format(data)

eeprom.append(data[2:4])

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

pass

else:

padflag = True

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

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

if coe is not None:

for bit,flag in enumerate(["SdoInfo", "PdoAssign", "PdoConfig",

"PdoUpload", "CompleteAccess"]):

coe_details += 1<<bit

eeprom.append("{:0>2x}".format(coe_details))

eeprom.append("28")

eeprom.append("00")

# category length

padflag = True

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

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

en_mandatory = False

en_virtual = False

# PDO Index

data += "{:0>4x}".format(ExtractHexDecValue(element.getIndex().getcontent()))[2:4]

data += "{:0>4x}".format(ExtractHexDecValue(element.getIndex().getcontent()))[0:2]

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

try:

values = eval(data)

except Exception:

values = None

if not isinstance(values, TupleType):

values = None

if values is not None and col != wx.NOT_FOUND and row != wx.NOT_FOUND and 2 <= col <= 3:

location = None

else:

message = _("'Read from' and 'Write to' variables types are not compatible")

else:

if message is not None:

wx.CallAfter(self.ShowMessage, message)

try:

values = eval(data)

except Exception:

values = None

if not isinstance(values, TupleType):

values = None

if values is not None:

location = None

else:

message = _("Entry can't be write through SDO")

else:

if message is not None:

wx.CallAfter(self.ShowMessage, message)

self.SetColLabelValue(16, "Text View")

self.SetColSize(16, (self.GetSize().x-120)*4/20)

else:

self.SetColSize(col, (self.GetSize().x-120)/20)

# set data into table

for address in range(0x1000):

# arrange 2 Bytes of register data

reg_word = reg_data[address].split('x')[1] + reg_word

# append address

hex_address = "{:0>4x}".format(address-1)

row_data.append(hex_address)

# Write generated content to CIA402 node file

Gen_CIA402Nodefile_path = os.path.join(buildpath,

cia402nodefile = open(Gen_CIA402Nodefile_path, 'w')

cia402nodefile.write(plc_cia402node_code % locals())

cia402nodefile.close()

"size": var_size,

"IEC_type": entry["Type"],

"var_name": "%s_%4.4x_%2.2x" % ("_".join(device_name.split()), index, subindex),

(index, subindex)))),

"description": "",

"children": []})

# define a unique name for the generated C file

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

self.FileGenerator = _EthercatCFileGenerator(self)

LocationCFilesAndCFLAGS.insert(0,

(current_location,

True))

LDFLAGS.append("-lethercat_rtdm -lrtdm")

if res != 0 :

PLCObject.LogMessage(

LogLevelsDict["WARNING"],

def EthercatSDOUpload(pos, index, subindex, var_type):

global SDOThread