beremiz: comparison etherlab/etherlab.py

equal deleted inserted replaced

-:5132c497918c
+:7c848efa21c6
 "BYTE" : "B", "WORD" : "W", "DWORD" : "D", "LWORD" : "L"}
 DATATYPECONVERSION = {"BOOL" : "BIT", "SINT" : "S8", "INT" : "S16", "DINT" : "S32", "LINT" : "S64",
 "USINT" : "U8", "UINT" : "U16", "UDINT" : "U32", "ULINT" : "U64",
 "BYTE" : "U8", "WORD" : "U16", "DWORD" : "U32", "LWORD" : "U64"}
+VARCLASSCONVERSION = {"ro": LOCATION_VAR_INPUT, "wo": LOCATION_VAR_OUTPUT, "rw": LOCATION_VAR_MEMORY}
 #--------------------------------------------------
 #                 Ethercat MASTER
 #--------------------------------------------------
 except:
 pass
 try:
 return int(value.replace("#", "0"), 16)
 except:
-raise "Invalid value for HexDecValue \"%s\"" % value
+raise ValueError, "Invalid value for HexDecValue \"%s\"" % value
 def GenerateHexDecValue(value, base=10):
 if base == 10:
 return str(value)
 elif base == 16:
 return "#x%.8x" % value
 else:
-raise "Not supported base"
+raise ValueError, "Not supported base"
 cls = EtherCATConfigClasses.get("Config_Slave", None)
 if cls:
 def getType(self):
 if slave is not None:
 type_infos = slave.getType()
 device = self.GetModuleInfos(type_infos)
 if device is not None:
 infos = type_infos.copy()
+entries = device.GetEntriesList()
+entries_list = entries.items()
+entries_list.sort()
 infos.update({"physics": device.getPhysics(),
-"variables": []})
+"sync_managers": device.GetSyncManagers(),
-for TxPdo in device.getTxPdo():
+"entries": [entry[1] for entry in entries_list]})
-ExtractPdoInfos(TxPdo, "Transmit", infos)
-for RxPdo in device.getRxPdo():
-ExtractPdoInfos(RxPdo, "Receive", infos)
 return infos
 return None
 def GetModuleInfos(self, type_infos):
 return self.PlugParent.GetModuleInfos(type_infos)
 if sync_manager_direction:
 sync_managers.append(LOCATION_VAR_OUTPUT)
 else:
 sync_managers.append(LOCATION_VAR_INPUT)
-for pdo in device.getTxPdo() + device.getRxPdo():
+entries = device.GetEntriesList().items()
-var_class = sync_managers[pdo.getSm()]
+entries.sort()
+for (index, subindex), entry in entries:
-for entry in pdo.getEntry():
+var_size = self.GetSizeOfType(entry["Type"])
-index = ExtractHexDecValue(entry.getIndex().getcontent())
+if var_size is not None:
-subindex = ExtractHexDecValue(entry.getSubIndex())
+var_class = VARCLASSCONVERSION.get(entry["Access"], LOCATION_VAR_MEMORY)
-var_type = entry.getDataType().getcontent()
-var_size = self.GetSizeOfType(var_type)
 if var_class == LOCATION_VAR_INPUT:
 var_dir = "%I"
 else:
 var_dir = "%Q"
-pdo_name = ExtractName(pdo.getName())
+vars.append({"name": "0x%4.4x-0x%2.2x: %s" % (index, subindex, entry["Name"]),
-entry_name = ExtractName(entry.getName())
-vars.append({"name": "%s - %s" % (pdo_name, entry_name),
 "type": var_class,
 "size": var_size,
-"IEC_type": var_type,
+"IEC_type": entry["Type"],
-"var_name": "%s_%s" % (type_infos["device_type"], "_".join(pdo_name.split())),
+"var_name": "%s_%4.4x_%2.2x" % (type_infos["device_type"], index, subindex),
 "location": "%s%s%s"%(var_dir, var_size, ".".join(map(str, current_location +
 slave_pos +
 (index, subindex)))),
 "description": "",
 "children": []})
 fprintf(stderr, "Failed to configure PDOs for slave %(device_type)s at alias %(alias)d and position %(position)d.\\n");
 return -1;
 }
 """
+def ConfigureVariable(entry_infos, str_completion):
+data_type = DATATYPECONVERSION.get(entry_infos["var_type"], None)
+if data_type is None:
+raise ValueError, _("Type of location \"%s\" not yet supported!") % entry_infos["var_name"]
+str_completion["located_variables_declaration"].extend(
+["IEC_%(var_type)s beremiz%(var_name)s;" % entry_infos,
+"IEC_%(var_type)s *%(var_name)s = &beremiz%(var_name)s;" % entry_infos])
+if data_type == "BIT":
+str_completion["used_pdo_entry_offset_variables_declaration"].extend(
+["static unsigned int slave%(slave)d_%(index).4x_%(subindex).2x;" % entry_infos,
+"static unsigned int slave%(slave)d_%(index).4x_%(subindex).2x_bit;" % entry_infos])
+str_completion["used_pdo_entry_configuration"].append(
+("    {%(alias)d, %(position)d, 0x%(vendor).8x, 0x%(product_code).8x, " +
+"0x%(index).4x, %(subindex)d, &slave%(slave)d_%(index).4x_%(subindex).2x, " +
+"&slave%(slave)d_%(index).4x_%(subindex).2x_bit},") % entry_infos)
+if entry_infos["dir"] == "I":
+str_completion["retrieve_variables"].append(
+("    beremiz%(name)s = EC_READ_BIT(domain1_pd + slave%(slave)d_%(index).4x_%(subindex).2x, " +
+"slave%(slave)d_%(index).4x_%(subindex).2x_bit);") % entry_infos)
+elif entry_infos["dir"] == "Q":
+str_completion["publish_variables"].append(
+("    EC_WRITE_BIT(domain1_pd + slave%(slave)d_%(index).4x_%(subindex).2x, " +
+"slave%(slave)d_%(index).4x_%(subindex).2x_bit, beremiz%(var_name)s);") % entry_infos)
+else:
+entry_infos["data_type"] = data_type
+str_completion["used_pdo_entry_offset_variables_declaration"].append(
+"static unsigned int slave%(slave)d_%(index).4x_%(subindex).2x;" % entry_infos)
+str_completion["used_pdo_entry_configuration"].append(
+("    {%(alias)d, %(position)d, 0x%(vendor).8x, 0x%(product_code).8x, 0x%(index).4x, " +
+"%(subindex)d, &slave%(slave)d_%(index).4x_%(subindex).2x},") % entry_infos)
+if entry_infos["dir"] == "I":
+str_completion["retrieve_variables"].append(
+("    beremiz%(var_name)s = EC_READ_BIT(domain1_pd + " +
+"slave%(slave)d_%(index).4x_%(subindex).2x);") % entry_infos)
+elif entry_infos["dir"] == "Q":
+str_completion["publish_variables"].append(
+("    EC_WRITE_BIT(domain1_pd + slave%(slave)d_%(index).4x_%(subindex).2x, " +
+"beremiz%(var_name)s);") % entry_infos)
 class _EthercatCFileGenerator:
 def __init__(self, controler, filepath):
 self.Controler = controler
 self.FilePath = filepath
 def DeclareVariable(self, slave_identifier, index, subindex, iec_type, dir, name):
 slave_variables = self.UsedVariables.setdefault(slave_identifier, {})
 entry_infos = slave_variables.get((index, subindex), None)
 if entry_infos is None:
-slave_variables[(index, subindex)] = (iec_type, dir, name)
+slave_variables[(index, subindex)] = {
-elif entry_infos != (iec_type, dir, name):
+"infos": (iec_type, dir, name),
+"mapped": False}
+elif entry_infos["infos"] != (iec_type, dir, name):
 raise ValueError, _("Definition conflict for location \"%s\"") % name
 def GenerateCFile(self):
 current_location = self.Controler.GetCurrentLocation()
 # define a unique name for the generated C file
 location_str = "_".join(map(lambda x:str(x), current_location))
 "slaves_configuration": "",
 "retrieve_variables": [],
 "publish_variables": [],
 }
+for slave_entries in self.UsedVariables.itervalues():
+for entry_infos in slave_entries.itervalues():
+entry_infos["mapped"] = False
 for slave_idx, slave_pos in enumerate(self.Controler.GetSlaves()):
 slave = self.Controler.GetSlave(slave_pos)
 if slave is not None:
 type_infos = slave.getType()
 device = self.Controler.GetModuleInfos(type_infos)
 if device is not None:
+slave_variables = self.UsedVariables.get(slave_pos, {})
+device_entries = device.GetEntriesList()
-pdos = device.getTxPdo() + device.getRxPdo()
+if len(device.getTxPdo() + device.getRxPdo()) > 0 or len(slave_variables) > 0:
-if len(pdos) > 0:
-slave_variables = self.UsedVariables.get(slave_pos, {})
 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)))
 sync_managers = []
 for sync_manager_idx, sync_manager in enumerate(device.getSm()):
 sync_manager_infos = {
 "index": sync_manager_idx,
+"name": sync_manager.getcontent(),
 "slave": slave_idx,
+"pdos": [],
 "pdos_number": 0,
 }
 sync_manager_control_byte = ExtractHexDecValue(sync_manager.getControlByte())
 sync_manager_direction = sync_manager_control_byte & 0x0c
 else:
 sync_manager_infos["watchdog"] = "EC_WD_DISABLE"
 sync_managers.append(sync_manager_infos)
-entry_offset = 0
+pdos_index = []
-for pdo in pdos:
+for pdo, pdo_type in ([(pdo, "Inputs") for pdo in device.getTxPdo()] +
+[(pdo, "Outputs") for pdo in device.getRxPdo()]):
 entries = pdo.getEntry()
 pdo_needed = pdo.getMandatory()
+pdo_index = ExtractHexDecValue(pdo.getIndex().getcontent())
+pdos_index.append(pdo_index)
 entries_infos = []
 for entry in entries:
 index = ExtractHexDecValue(entry.getIndex().getcontent())
 subindex = ExtractHexDecValue(entry.getSubIndex())
 entries_infos.append("    {0x%(index).4x, 0x%(subindex).2x, %(bitlen)d}, /* %(name)s */" % entry_infos)
 entry_declaration = slave_variables.get((index, subindex), None)
 if entry_declaration is not None:
 pdo_needed = True
-entry_infos.update(dict(zip(["var_type", "dir", "var_name"], entry_declaration)))
+entry_infos.update(dict(zip(["var_type", "dir", "var_name"], entry_declaration["infos"])))
+entry_declaration["mapped"] = True
 if entry_infos["var_type"] != entry.getDataType().getcontent():
 raise ValueError, _("Wrong type for location \"%s\"!") % entry_infos["var_name"]
-data_type = DATATYPECONVERSION.get(entry_infos["var_type"], None)
+if (entry_infos["dir"] == "I" and pdo_type != "Inputs" or
-if data_type is None:
+entry_infos["dir"] == "Q" and pdo_type != "Outputs"):
-raise ValueError, _("Type of location \"%s\" not yet supported!") % entry_infos["var_name"]
-if (entry_infos["dir"] == "I" and sync_managers[pdo.getSm()]["sync_manager_type"] != "EC_DIR_INPUT" or
-entry_infos["dir"] == "Q" and sync_managers[pdo.getSm()]["sync_manager_type"] != "EC_DIR_OUTPUT"):
 raise ValueError, _("Wrong direction for location \"%s\"!") % entry_infos["var_name"]
-str_completion["located_variables_declaration"].extend(
+ConfigureVariable(entry_infos, str_completion)
-["IEC_%(var_type)s beremiz%(var_name)s;" % entry_infos,
-"IEC_%(var_type)s *%(var_name)s = &beremiz%(var_name)s;" % entry_infos])
-if data_type == "BIT":
-str_completion["used_pdo_entry_offset_variables_declaration"].extend(
-["static unsigned int slave%(slave)d_%(index).4x_%(subindex).2x;" % entry_infos,
-"static unsigned int slave%(slave)d_%(index).4x_%(subindex).2x_bit;" % entry_infos])
-str_completion["used_pdo_entry_configuration"].append(
-("    {%(alias)d, %(position)d, 0x%(vendor).8x, 0x%(product_code).8x, " +
-"0x%(index).4x, %(subindex)d, &slave%(slave)d_%(index).4x_%(subindex).2x, " +
-"&slave%(slave)d_%(index).4x_%(subindex).2x_bit},") % entry_infos)
-if entry_infos["dir"] == "I":
-str_completion["retrieve_variables"].append(
-("    beremiz%(name)s = EC_READ_BIT(domain1_pd + slave%(slave)d_%(index).4x_%(subindex).2x, " +
-"slave%(slave)d_%(index).4x_%(subindex).2x_bit);") % entry_infos)
-elif entry_infos["dir"] == "Q":
-str_completion["publish_variables"].append(
-("    EC_WRITE_BIT(domain1_pd + slave%(slave)d_%(index).4x_%(subindex).2x, " +
-"slave%(slave)d_%(index).4x_%(subindex).2x_bit, beremiz%(var_name)s);") % entry_infos)
-else:
-entry_infos["data_type"] = data_type
-str_completion["used_pdo_entry_offset_variables_declaration"].append(
-"static unsigned int slave%(slave)d_%(index).4x_%(subindex).2x;" % entry_infos)
-str_completion["used_pdo_entry_configuration"].append(
-("    {%(alias)d, %(position)d, 0x%(vendor).8x, 0x%(product_code).8x, 0x%(index).4x, " +
-"%(subindex)d, &slave%(slave)d_%(index).4x_%(subindex).2x},") % entry_infos)
-if entry_infos["dir"] == "I":
-str_completion["retrieve_variables"].append(
-("    beremiz%(name)s = EC_READ_BIT(domain1_pd + " +
-"slave%(slave)d_%(index).4x_%(subindex).2x);") % entry_infos)
-elif entry_infos["dir"] == "Q":
-str_completion["publish_variables"].append(
-("    EC_WRITE_BIT(domain1_pd + slave%(slave)d_%(index).4x_%(subindex).2x, " +
-"beremiz%(var_name)s);") % entry_infos)
 if pdo_needed:
-sync_managers[pdo.getSm()]["pdos_number"] += 1
+sm = pdo.getSm()
-pdo_infos = {
+if sm is None:
-"slave": slave_idx,
+for sm_idx, sync_manager in enumerate(sync_managers):
-"index": ExtractHexDecValue(pdo.getIndex().getcontent()),
+if sync_manager["Name"] == pdo_type:
-"name": ExtractName(pdo.getName()),
+sm = sm_idx
-"offset": entry_offset,
+if sm is None:
-"entries_number": len(entries)
+raise ValueError, _("No sync manager available for %s pdo!") % pdo_type
+sync_managers[sm]["pdos_number"] += 1
+sync_managers[sm]["pdos"].append(
+{"slave": slave_idx,
+"index": pdo_index,
+"name": ExtractName(pdo.getName()),
+"type": pdo_type,
+"entries": entries_infos,
+"entries_number": len(entries_infos),
+"fixed": pdo.getFixed() == True})
+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:
+if sync_manager["name"] == category:
+category_infos = dynamic_pdos.setdefault(category, {})
+category_infos["sync_manager"] = sync_manager
+category_infos["pdos"] = [pdo for pdo in category_infos["sync_manager"]["pdos"]
+if not pdo["fixed"] and pdo["type"] == category]
+category_infos["current_index"] = min_index
+category_infos["max_index"] = max_index
+break
+for (index, subindex), entry_declaration in slave_variables.iteritems():
+if not entry_declaration["mapped"]:
+entry = device_entries.get((index, subindex), None)
+if entry is None:
+raise ValueError, _("Unknown entry index 0x%4.4x, subindex 0x%2.2x for device %s") % \
+(index, subindex, type_infos["device_type"])
+entry_infos = {
+"index": index,
+"subindex": subindex,
+"name": entry["Name"],
+"bitlen": entry["BitSize"],
 }
+entry_infos.update(type_infos)
+entry_infos.update(dict(zip(["var_type", "dir", "var_name"], entry_declaration["infos"])))
+entry_declaration["mapped"] = True
+if entry_infos["var_type"] != entry["Type"]:
+raise ValueError, _("Wrong type for location \"%s\"!") % entry_infos["var_name"]
+if entry_infos["dir"] == "I" and entry["Access"] in ["ro", "rw"]:
+pdo_type = "Inputs"
+elif entry_infos["dir"] == "Q" and entry["Access"] in ["wo", "rw"]:
+pdo_type = "Outputs"
+else:
+raise ValueError, _("Wrong direction for location \"%s\"!") % entry_infos["var_name"]
+if not dynamic_pdos.has_key(pdo_type):
+raise ValueError, _("No Sync manager defined for %s!") % pdo_type
+ConfigureVariable(entry_infos, str_completion)
+if len(dynamic_pdos[pdo_type]["pdos"]) > 0:
+pdo = dynamic_pdos[pdo_type]["pdos"][0]
+else:
+while dynamic_pdos[pdo_type]["current_index"] in pdos_index:
+dynamic_pdos[pdo_type]["current_index"] += 1
+if dynamic_pdos[pdo_type]["current_index"] >= dynamic_pdos[pdo_type]["max_index"]:
+raise ValueError, _("No more free PDO index available for %s!") % pdo_type
+pdos_index.append(dynamic_pdos[pdo_type]["current_index"])
+dynamic_pdos_number += 1
+pdo = {"slave": slave_idx,
+"index": dynamic_pdos[pdo_type]["current_index"],
+"name": "Dynamic PDO %d" % dynamic_pdos_number,
+"type": pdo_type,
+"entries": [],
+"entries_number": 0,
+"fixed": False}
+dynamic_pdos[pdo_type]["sync_manager"]["pdos_number"] += 1
+dynamic_pdos[pdo_type]["sync_manager"]["pdos"].append(pdo)
+dynamic_pdos[pdo_type]["pdos"].append(pdo)
+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, " +
 "slave_%(slave)d_pdo_entries + %(offset)d}, /* %(name)s */") % pdo_infos)
-entry_offset += len(entries)
+entry_offset += len(pdo_entries)
-pdos_infos["pdos_entries_infos"].extend(entries_infos)
+pdos_infos["pdos_entries_infos"].extend(pdo_entries)
-pdo_offset = 0
-for sync_manager_infos in sync_managers:
 sync_manager_infos["offset"] = pdo_offset
 pdos_infos["pdos_sync_infos"].append(
 ("    {%(index)d, %(sync_manager_type)s, %(pdos_number)d, " +
 "slave_%(slave)d_pdos + %(offset)d, %(watchdog)s},") % sync_manager_infos)
 pdo_offset += sync_manager_infos["pdos_number"]
 #                 Ethercat Plugin
 #--------------------------------------------------
 EtherCATInfoClasses = GenerateClassesFromXSD(os.path.join(os.path.dirname(__file__), "EtherCATInfo.xsd"))
+cls = EtherCATInfoClasses["EtherCATInfo.xsd"].get("DeviceType", None)
+if cls:
+cls.DataTypes = None
+def GetProfileDictionaries(self):
+dictionaries = []
+for profile in self.getProfile():
+profile_content = profile.getcontent()
+if profile_content is None:
+return None
+for content_element in profile_content["value"]:
+if content_element["name"] == "Dictionary":
+dictionaries.append(content_element["value"])
+elif content_element["name"] == "DictionaryFile":
+raise ValueError, "DictionaryFile for defining Device Profile is not yet supported!"
+return dictionaries
+setattr(cls, "GetProfileDictionaries", GetProfileDictionaries)
+def ExtractDataTypes(self):
+self.DataTypes = {}
+for dictionary in self.GetProfileDictionaries():
+datatypes = dictionary.getDataTypes()
+if datatypes is not None:
+for datatype in datatypes.getDataType():
+content = datatype.getcontent()
+if content is not None and content["name"] == "SubItem":
+self.DataTypes[datatype.getName()] = datatype
+setattr(cls, "ExtractDataTypes", ExtractDataTypes)
+def GetEntriesList(self):
+if self.DataTypes is None:
+self.ExtractDataTypes()
+entries = {}
+for dictionary in self.GetProfileDictionaries():
+for object in dictionary.getObjects().getObject():
+entry_index = object.getIndex().getcontent()
+index = ExtractHexDecValue(entry_index)
+entry_type = object.getType()
+entry_name = ExtractName(object.getName())
+entry_type_infos = self.DataTypes.get(entry_type, None)
+if entry_type_infos is not None:
+content = entry_type_infos.getcontent()
+for subitem in content["value"]:
+entry_subidx = subitem.getSubIdx()
+if entry_subidx is None:
+entry_subidx = "0"
+subidx = ExtractHexDecValue(entry_subidx)
+subitem_access = ""
+subitem_flags = subitem.getFlags()
+if subitem_flags is not None:
+access = subitem_flags.getAccess()
+if access is not None:
+subitem_access = access.getcontent()
+entries[(index, subidx)] = {
+"Index": entry_index,
+"SubIndex": entry_subidx,
+"Name": "%s - %s" %
+(entry_name.decode("utf-8"),
+ExtractName(subitem.getDisplayName(),
+subitem.getName()).decode("utf-8")),
+"Type": subitem.getType(),
+"BitSize": subitem.getBitSize(),
+"Access": subitem_access,
+"PDO index": "",
+"PDO name": "",
+"PDO type": ""}
+else:
+entry_access = ""
+entry_flags = object.getFlags()
+if entry_flags is not None:
+access = entry_flags.getAccess()
+if access is not None:
+entry_access = access.getcontent()
+entries[(index, 0)] = {
+"Index": entry_index,
+"SubIndex": "0",
+"Name": entry_name,
+"Type": entry_type,
+"BitSize": object.getBitSize(),
+"Access": entry_access,
+"PDO index": "",
+"PDO name": "",
+"PDO type": ""}
+for TxPdo in self.getTxPdo():
+ExtractPdoInfos(TxPdo, "Transmit", entries)
+for RxPdo in self.getRxPdo():
+ExtractPdoInfos(RxPdo, "Receive", entries)
+return entries
+setattr(cls, "GetEntriesList", GetEntriesList)
+def GetSyncManagers(self):
+sync_managers = []
+for sync_manager in self.getSm():
+sync_manager_infos = {}
+for name, value in [("Name", sync_manager.getcontent()),
+("Start Address", sync_manager.getStartAddress()),
+("Default Size", sync_manager.getDefaultSize()),
+("Control Byte", sync_manager.getControlByte()),
+("Enable", sync_manager.getEnable())]:
+if value is None:
+value =""
+sync_manager_infos[name] = value
+sync_managers.append(sync_manager_infos)
+return sync_managers
+setattr(cls, "GetSyncManagers", GetSyncManagers)
 def GroupItemCompare(x, y):
 if x["type"] == y["type"]:
 if x["type"] == ETHERCAT_GROUP:
 return x["order"].__cmp__(y["order"])
 else:
 for name in names:
 if name.getLcId() == 1033:
 return name.getcontent()
 return default
-def ExtractPdoInfos(pdo, pdo_type, infos):
+def ExtractPdoInfos(pdo, pdo_type, entries):
 pdo_index = pdo.getIndex().getcontent()
-for entry in pdo.getEntry():
+pdo_name = ExtractName(pdo.getName())
-infos["variables"].append({"Index": entry.getIndex().getcontent(),
+for pdo_entry in pdo.getEntry():
-"SubIndex": entry.getSubIndex(),
+entry_index = pdo_entry.getIndex().getcontent()
-"Name": ExtractName(entry.getName()),
+entry_subindex = pdo_entry.getSubIndex()
-"Type": entry.getDataType().getcontent(),
+index = ExtractHexDecValue(entry_index)
-"PDO index": pdo_index,
+subindex = ExtractHexDecValue(entry_subindex)
-"PDO name": ExtractName(pdo.getName()),
-"PDO type": pdo_type})
+entry = entries.get((index, subindex), None)
+if entry is not None:
+entry["PDO index"] = pdo_index
+entry["PDO name"] = pdo_name
+entry["PDO type"] = pdo_type
+else:
+if pdo_type == "Transmit":
+access = "ro"
+else:
+access = "wo"
+entries[(index, subindex)] = {
+"Index": entry_index,
+"SubIndex": entry_subindex,
+"Name": ExtractName(pdo_entry.getName()),
+"Type": pdo_entry.getDataType().getcontent(),
+"Access": access,
+"PDO index": pdo_index,
+"PDO name": pdo_name,
+"PDO type": pdo_type}
 class RootClass:
 PlugChildsTypes = [("EthercatNode",_EthercatPlug,"Ethercat Master")]
 def GetModuleInfos(self, type_infos):
 vendor = self.ModulesLibrary.get(type_infos["vendor"], None)
 if vendor is not None:
 for group_name, group in vendor["groups"].iteritems():
 for device_type, device in group["devices"]:
-product_code = device.getType().getProductCode()
+product_code = ExtractHexDecValue(device.getType().getProductCode())
-revision_number = device.getType().getRevisionNo()
+revision_number = ExtractHexDecValue(device.getType().getRevisionNo())
 if (device_type == type_infos["device_type"] and
-product_code == type_infos["product_code"] and
+product_code == ExtractHexDecValue(type_infos["product_code"]) and
-revision_number == type_infos["revision_number"]):
+revision_number == ExtractHexDecValue(type_infos["revision_number"])):
 return device
 return None

changeset 2029	7c848efa21c6
parent 2026	65ecbfe9a6f9
child 2030	7147f20c23e3