beremiz: comparison etherlab/CommonEtherCATFunction.py

equal deleted inserted replaced

-:af050469fc5c
+:ffd091b51cd0
 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)
+_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)
 """
 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)
+_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)
+_error, return_val = self.Controler.RemoteExec(GET_SLAVE, return_val=None)
 self.SlaveState = return_val
 return return_val
 # -------------------------------------------------------------------------------
 #                        Used SDO Management
 """
 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)
+_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.
 @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)
+_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.
 def ClearSDODataSet(self):
 """
 Clear the specified SDO entry information.
 """
-for count in range(6):
+for dummy in range(6):
 self.SaveSDOData.append([])
 # -------------------------------------------------------------------------------
 #                        Used PDO Monitoring
 # -------------------------------------------------------------------------------
 """
 # 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)
+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:
 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()]):
+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())
 categorys = {"pdo_index": pdo_index, "name": pdo_name, "number_of_entry": count}
 self.TxPDOCategory.append(categorys)
 # Parsing RxPDO entries
-for pdo, pdo_info in ([(rxpdo, "Outputs") for rxpdo in device.getRxPdo()]):
+for pdo, _pdo_info in ([(rxpdo, "Outputs") for rxpdo 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())
 "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, _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>
 """
 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)
+_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)
+_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_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)):
+for dummy in range(self.SmartViewInfosFromXML["eeprom_size"] - len(self.BinaryCode)):
 self.BinaryCode = self.BinaryCode + 'ff'.decode('hex')
 return self.BinaryCode
 def HexRead(self, binary):
 @return eeprom_list : reconstructed list data structure
 """
 eeprom_list = []
 if direction is 0 or 1:
-for i in range(length/2):
+for dummy 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]
 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)
+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":
 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):
+for dummy in range(8):
 bit = crc & 0x80
 crc <<= 1
 if bit:
 crc ^= 0x07
 eeprom.append(hex(crc)[len(hex(crc))-3:len(hex(crc))-1])
 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(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 _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 isinstance(data, unicode):
 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(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 _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 isinstance(data, unicode):
 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 _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 isinstance(data, unicode):
 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):
+for dummy in range(len(element)/2):
 if element == "":
 eeprom.append("00")
 else:
 eeprom.append(element[0:2])
 element = element[2:len(element)]
 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")
 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):
+for dummy in range(count):
 if data == "":
 eeprom.append("00")
 else:
 eeprom.append(data[0:2])
 data = data[2:len(data)]
 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):
+for dummy in range(len(data)/2):
 if data == "":
 eeprom.append("00")
 else:
 eeprom.append(data[0:2])
 data = data[2:len(data)]
 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):
+for dummy in range(len(data)/2):
 if data == "":
 eeprom.append("00")
 else:
 eeprom.append(data[0:2])
 data = data[2:len(data)]
 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):
+for dummy in range(len(data)/2):
 if data == "":
 eeprom.append("00")
 else:
 eeprom.append(data[0:2])
 data = data[2:len(data)]
 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)
+_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)
+_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)
+_error, _return_val = self.Controler.RemoteExec(RESCAN % (self.Controler.GetSlavePos()), return_val=None)
 # -------------------------------------------------------------------------------
 #                        Common Use Methods
 # -------------------------------------------------------------------------------
 def CheckConnect(self, cyclic_flag):
 @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)
+_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

changeset 2406	ffd091b51cd0
parent 2405	af050469fc5c
child 2407	5f2b1bb464a0