beremiz: comparison etherlab/etherlab.py

equal deleted inserted replaced

-:7d0ebbff1d08
+:49242019a9ca
 #                    Ethercat Node
 #--------------------------------------------------
 class _EthercatSlaveCTN:
-XSD = """<?xml version="1.0" encoding="ISO-8859-1" ?>
-<xsd:schema xmlns:xsd="http://www.w3.org/2001/XMLSchema">
-<xsd:element name="SlaveParams">
-<xsd:complexType>
-<xsd:attribute name="DynamicPDOs" type="xsd:boolean" use="optional" default="true"/>
-</xsd:complexType>
-</xsd:element>
-</xsd:schema>
-"""
 NODE_PROFILE = None
 EditorType = NodeEditor
 def GetIconName(self):
 return "Slave"
 class _EthercatCIA402SlaveCTN(_EthercatSlaveCTN):
 XSD = """<?xml version="1.0" encoding="ISO-8859-1" ?>
 <xsd:schema xmlns:xsd="http://www.w3.org/2001/XMLSchema">
 <xsd:element name="CIA402SlaveParams">
 <xsd:complexType>
-<xsd:attribute name="DynamicPDOs" type="xsd:boolean" use="optional" default="true"/>
 %s
 </xsd:complexType>
 </xsd:element>
 </xsd:schema>
 """ % AxisXSD
 XSD = """<?xml version="1.0" encoding="ISO-8859-1" ?>
 <xsd:schema xmlns:xsd="http://www.w3.org/2001/XMLSchema">
 <xsd:element name="EtherlabNode">
 <xsd:complexType>
 <xsd:attribute name="MasterNumber" type="xsd:integer" use="optional" default="0"/>
-<xsd:attribute name="ConfigurePDOs" type="xsd:boolean" use="optional" default="true"/>
 </xsd:complexType>
 </xsd:element>
 </xsd:schema>
 """
 current_location = self.GetCurrentLocation()
 slaves = self.GetSlaves()
 for slave_pos in slaves:
 slave = self.GetSlave(slave_pos)
-slave_node = self.GetChildByIECLocation([slave_pos])
-if slave_node.CTNParams is not None:
-slave_infos = slave_node.CTNParams[1]
-else:
-slave_infos = None
 if slave is not None:
-self.FileGenerator.DeclareSlave(slave_pos, slave.getInfo().getAutoIncAddr(), slave.getType(), slave_infos)
+self.FileGenerator.DeclareSlave(slave_pos, slave.getInfo().getAutoIncAddr(), slave.getType())
 for location in locations:
 loc = location["LOC"][len(current_location):]
 slave_pos = loc[0]
 if slave_pos in slaves and len(loc) == 3:
 self.Slaves = []
 self.UsedVariables = {}
 def __del__(self):
 self.Controler = None
-def DeclareSlave(self, slave_index, slave_alias, slave, slave_infos):
+def DeclareSlave(self, slave_index, slave_alias, slave):
-self.Slaves.append((slave_index, slave_alias, slave, slave_infos))
+self.Slaves.append((slave_index, slave_alias, slave))
 def DeclareVariable(self, slave_index, index, subindex, iec_type, dir, name):
 slave_variables = self.UsedVariables.setdefault(slave_index, {})
 entry_infos = slave_variables.get((index, subindex), None)
 elif entry_infos["infos"] != (iec_type, dir, name):
 raise ValueError, _("Definition conflict for location \"%s\"") % name
 def GenerateCFile(self, filepath, location_str, etherlab_node_infos):
+# Extract etherlab master code template
 plc_etherlab_filepath = os.path.join(os.path.split(__file__)[0], "plc_etherlab.c")
 plc_etherlab_file = open(plc_etherlab_filepath, 'r')
 plc_etherlab_code = plc_etherlab_file.read()
 plc_etherlab_file.close()
+# Initialize strings for formatting master code template
 str_completion = {
 "location": location_str,
-"configure_pdos": int(etherlab_node_infos.getConfigurePDOs()),
 "master_number": etherlab_node_infos.getMasterNumber(),
 "located_variables_declaration": [],
 "used_pdo_entry_offset_variables_declaration": [],
 "used_pdo_entry_configuration": [],
 "pdos_configuration_declaration": "",
 "slaves_initialization": "",
 "retrieve_variables": [],
 "publish_variables": [],
 }
+# Initialize variable storing variable mapping state
 for slave_entries in self.UsedVariables.itervalues():
 for entry_infos in slave_entries.itervalues():
 entry_infos["mapped"] = False
+# Sort slaves by position (IEC_Channel)
 self.Slaves.sort()
+# Initialize dictionary storing alias auto-increment position values
 alias = {}
-for (slave_idx, slave_alias, type_infos, slave_infos) in self.Slaves:
+# Generating code for each slave
+for (slave_idx, slave_alias, type_infos) in self.Slaves:
+# Defining slave alias and auto-increment position
 if alias.get(slave_alias) is not None:
 alias[slave_alias] += 1
 else:
 alias[slave_alias] = 0
 slave_pos = (slave_alias, alias[slave_alias])
+# Extract slave device informations
 device = self.Controler.GetModuleInfos(type_infos)
 if device is not None:
+# Extract slaves variables to be mapped
 slave_variables = self.UsedVariables.get(slave_idx, {})
+# Extract slave device object dictionary entries
 device_entries = device.GetEntriesList()
-if len(device.getTxPdo() + device.getRxPdo()) > 0 or len(slave_variables) > 0:
+# Adding code for declaring slave in master code template strings
+for element in ["vendor", "product_code", "revision_number"]:
+type_infos[element] = ExtractHexDecValue(type_infos[element])
+type_infos.update(dict(zip(["slave", "alias", "position"], (slave_idx,) + slave_pos)))
+# Extract slave device CoE informations
+device_coe = device.getCoE()
+if device_coe is not None:
-for element in ["vendor", "product_code", "revision_number"]:
+# If device support CanOpen over Ethernet, adding code for calling
-type_infos[element] = ExtractHexDecValue(type_infos[element])
+# init commands when initializing slave in master code template strings
-type_infos.update(dict(zip(["slave", "alias", "position"], (slave_idx,) + slave_pos)))
+for initCmd in device_coe.getInitCmd():
-str_completion["slaves_declaration"] += "static ec_slave_config_t *slave%(slave)d = NULL;\n" % type_infos
-str_completion["slaves_configuration"] += SLAVE_CONFIGURATION_TEMPLATE % type_infos
-for initCmd in device.getInitCmd():
 index = ExtractHexDecValue(initCmd.getIndex())
 subindex = ExtractHexDecValue(initCmd.getSubIndex())
 entry = device_entries.get((index, subindex), None)
 if entry is not None:
 data_size = entry["BitSize"] / 8
 "data": data_str,
 "data_size": data_size
 }
 init_cmd_infos.update(type_infos)
 str_completion["slaves_initialization"] += SLAVE_INITIALIZATION_TEMPLATE % init_cmd_infos
+# Extract slave device PDO configuration capabilities
+PdoAssign = device_coe.getPdoAssign()
+PdoConfig = device_coe.getPdoConfig()
+else:
+PdoAssign = PdoConfig = False
+# Test if slave has a configuration or need one
+if len(device.getTxPdo() + device.getRxPdo()) > 0 or len(slave_variables) > 0 and PdoConfig and PdoAssign:
+str_completion["slaves_declaration"] += "static ec_slave_config_t *slave%(slave)d = NULL;\n" % type_infos
+str_completion["slaves_configuration"] += SLAVE_CONFIGURATION_TEMPLATE % type_infos
+# Initializing
 pdos_infos = {
 "pdos_entries_infos": [],
 "pdos_infos": [],
 "pdos_sync_infos": [],
 }
 entry_infos["dir"] == "Q" and pdo_type != "Outputs"):
 raise ValueError, _("Wrong direction for location \"%s\"!") % entry_infos["var_name"]
 ConfigureVariable(entry_infos, str_completion)
-elif pdo_type == "Outputs" and entry.getDataType() is not None:
+elif pdo_type == "Outputs" and entry.getDataType() is not None and device_coe is not None:
 entry_infos["dir"] = "Q"
 entry_infos["data_size"] = max(1, entry_infos["bitlen"] / 8)
 entry_infos["var_type"] = entry.getDataType().getcontent()
 entry_infos["real_var"] = "slave%(slave)d_%(index).4x_%(subindex).2x_default" % entry_infos
 "type": pdo_type,
 "entries": entries_infos,
 "entries_number": len(entries_infos),
 "fixed": pdo.getFixed() == True})
-if slave_infos is None or slave_infos.getDynamicPDOs():
+if PdoConfig and PdoAssign:
 dynamic_pdos = {}
 dynamic_pdos_number = 0
 for category, min_index, max_index in [("Inputs", 0x1600, 0x1800),
 ("Outputs", 0x1a00, 0x1C00)]:
 for sync_manager in sync_managers:
 pdo["entries"].append("    {0x%(index).4x, 0x%(subindex).2x, %(bitlen)d}, /* %(name)s */" % entry_infos)
 pdo["entries_number"] += 1
 if pdo["entries_number"] == 255:
 dynamic_pdos[pdo_type]["pdos"].pop(0)
 pdo_offset = 0
 entry_offset = 0
 for sync_manager_infos in sync_managers:
 for pdo_infos in sync_manager_infos["pdos"]:
 pdo_infos["offset"] = entry_offset
 pdo_entries = pdo_infos["entries"]
 pdos_infos["pdos_infos"].append(
 ("    {0x%(index).4x, %(entries_number)d, " +
 for element in ["pdos_entries_infos", "pdos_infos", "pdos_sync_infos"]:
 pdos_infos[element] = "\n".join(pdos_infos[element])
 str_completion["pdos_configuration_declaration"] += SLAVE_PDOS_CONFIGURATION_DECLARATION % pdos_infos
+for (index, subindex), entry_declaration in slave_variables.iteritems():
+if not entry_declaration["mapped"]:
+message = _("Entry index 0x%4.4x, subindex 0x%2.2x not mapped for device %s") % \
+(index, subindex, type_infos["device_type"])
+self.Controler.GetCTRoot().logger.write_warning(_("Warning: ") + message + "\n")
 for element in ["used_pdo_entry_offset_variables_declaration",
 "used_pdo_entry_configuration",
 "located_variables_declaration",
 "retrieve_variables",
 "publish_variables"]:
 if content is not None and content["name"] == "SubItem":
 self.DataTypes[datatype.getName()] = datatype
 setattr(cls, "ExtractDataTypes", ExtractDataTypes)
-def getInitCmd(self):
+def getCoE(self):
 mailbox = self.getMailbox()
-if mailbox is None:
+if mailbox is not None:
-return []
+return mailbox.getCoE()
+return None
-coe = mailbox.getCoE()
+setattr(cls, "getCoE", getCoE)
-if coe is None:
-return []
-return coe.getInitCmd()
-setattr(cls, "getInitCmd", getInitCmd)
 def GetEntriesList(self):
 if self.DataTypes is None:
 self.ExtractDataTypes()

changeset 2079	49242019a9ca
parent 2077	14dfb786c53e
child 2080	6d0d94cd0fe0