diff -r d51af006fa6b -r 64d8f52bc8c8 canfestival/config_utils.py --- a/canfestival/config_utils.py Fri Aug 11 15:18:19 2017 +0300 +++ b/canfestival/config_utils.py Mon Aug 14 19:13:01 2017 +0300 @@ -30,7 +30,7 @@ "LREAL":0x11,"STRING":0x09,"BYTE":0x05,"WORD":0x06,"DWORD":0x07, "LWORD":0x1B,"WSTRING":0x0B} -# Constants for PDO types +# Constants for PDO types RPDO = 1 TPDO = 2 @@ -61,7 +61,7 @@ @param size: number of bytes generated @return: a string containing the value converted """ - + data = ("%" + str(size * 2) + "." + str(size * 2) + "X") % value list_car = [data[i:i+2] for i in xrange(0, len(data), 2)] list_car.reverse() @@ -71,12 +71,12 @@ def GetNodePDOIndexes(node, type, parameters = False): """ Find the PDO indexes of a node - @param node: node + @param node: node @param type: type of PDO searched (RPDO or TPDO or both) @param parameters: indicate which indexes are expected (PDO paramaters : True or PDO mappings : False) @return: a list of indexes found """ - + indexes = [] if type & RPDO: indexes.extend([idx for idx in node.GetIndexes() if 0x1400 <= idx <= 0x15FF]) @@ -91,14 +91,14 @@ def SearchNodePDOMapping(loc_infos, node): """ Find the PDO indexes of a node - @param node: node + @param node: node @param type: type of PDO searched (RPDO or TPDO or both) @param parameters: indicate which indexes are expected (PDO paramaters : True or PDO mappings : False) @return: a list of indexes found """ - + model = (loc_infos["index"] << 16) + (loc_infos["subindex"] << 8) - + for PDOidx in GetNodePDOIndexes(node, loc_infos["pdotype"]): values = node.GetEntry(PDOidx) if values != None: @@ -115,9 +115,9 @@ @param cobid: PDO generated COB ID @param transmittype : PDO transmit type @param pdomapping: list of PDO mappings - @return: a tuple of value and number of parameters to add to DCF - """ - + @return: a tuple of value and number of parameters to add to DCF + """ + dcfdata=[] # Create entry for RPDO or TPDO parameters and Disable PDO # ---- INDEX ----- --- SUBINDEX ---- ----- SIZE ------ ------ DATA ------ @@ -152,7 +152,7 @@ self.TrashVariables = {} # Dictionary of pointed variables self.PointedVariables = {} - + self.NodeList = nodelist self.Manager = self.NodeList.Manager self.MasterNode = self.Manager.GetCurrentNodeCopy() @@ -161,18 +161,18 @@ def GetPointedVariables(self): return self.PointedVariables - + def RemoveUsedNodeCobId(self, node): """ Remove all PDO COB ID used by the given node from the list of available COB ID @param node: node @return: a tuple of number of RPDO and TPDO for the node """ - + # Get list of all node TPDO and RPDO indexes nodeRpdoIndexes = GetNodePDOIndexes(node, RPDO, True) nodeTpdoIndexes = GetNodePDOIndexes(node, TPDO, True) - + # Mark all the COB ID of the node already mapped PDO as not available for PdoIdx in nodeRpdoIndexes + nodeTpdoIndexes: pdo_cobid = node.GetEntry(PdoIdx, 0x01) @@ -182,20 +182,20 @@ # Remove COB ID from the list of available COB ID if pdo_cobid in self.ListCobIDAvailable: self.ListCobIDAvailable.remove(pdo_cobid) - + return len(nodeRpdoIndexes), len(nodeTpdoIndexes) - + def PrepareMasterNode(self): """ Add mandatory entries for DCF generation into MasterNode. """ - + # Adding DCF entry into Master node if not self.MasterNode.IsEntry(0x1F22): self.MasterNode.AddEntry(0x1F22, 1, "") self.Manager.AddSubentriesToCurrent(0x1F22, 127, self.MasterNode) - + # Adding trash mappable variables for unused mapped datas idxTrashVariables = 0x2000 + self.MasterNode.GetNodeID() # Add an entry for storing unexpected all variable @@ -206,9 +206,9 @@ self.Manager.SetCurrentEntry(idxTrashVariables, subidx + 1, typeidx, "type", None, self.MasterNode) # Store the mapping value for this entry self.TrashVariables[size] = (idxTrashVariables << 16) + ((subidx + 1) << 8) + size - + RPDOnumber, TPDOnumber = self.RemoveUsedNodeCobId(self.MasterNode) - + # Store the indexes of the first RPDO and TPDO available for MasterNode self.CurrentPDOParamsIdx = {RPDO : 0x1400 + RPDOnumber, TPDO : 0x1800 + TPDOnumber} @@ -216,9 +216,9 @@ for idx, (nodeid, nodeinfos) in enumerate(self.NodeList.SlaveNodes.items()): node = nodeinfos["Node"] node.SetNodeID(nodeid) - + RPDOnumber, TPDOnumber = self.RemoveUsedNodeCobId(node) - + # Get Slave's default SDO server parameters RSDO_cobid = node.GetEntry(0x1200,0x01) if not RSDO_cobid: @@ -226,20 +226,20 @@ TSDO_cobid = node.GetEntry(0x1200,0x02) if not TSDO_cobid: TSDO_cobid = 0x580 + nodeid - + # Configure Master's SDO parameters entries self.Manager.ManageEntriesOfCurrent([0x1280 + idx], [], self.MasterNode) self.MasterNode.SetEntry(0x1280 + idx, 0x01, RSDO_cobid) self.MasterNode.SetEntry(0x1280 + idx, 0x02, TSDO_cobid) - self.MasterNode.SetEntry(0x1280 + idx, 0x03, nodeid) - - + self.MasterNode.SetEntry(0x1280 + idx, 0x03, nodeid) + + def GetMasterNode(self): """ Return MasterNode. """ return self.MasterNode - + def AddParamsToDCF(self, nodeid, data, nbparams): """ Add entry to DCF, for the requested nodeID @@ -249,19 +249,19 @@ """ # Get current DCF for slave nodeDCF = self.MasterNode.GetEntry(0x1F22, nodeid) - + # Extract data and number of params in current DCF if nodeDCF != None and nodeDCF != '': tmpnbparams = [i for i in nodeDCF[:4]] tmpnbparams.reverse() nbparams += int(''.join(["%2.2x"%ord(i) for i in tmpnbparams]), 16) data = nodeDCF[4:] + data - + # Build new DCF dcf = LE_to_BE(nbparams, 0x04) + data # Set new DCF for slave self.MasterNode.SetEntry(0x1F22, nodeid, dcf) - + def GetEmptyPDO(self, nodeid, pdotype, start_index=None): """ Search a not configured PDO for a slave @@ -275,7 +275,7 @@ index = PDOTypeBaseIndex[pdotype] else: index = start_index - + # Search for all PDO possible index until find a configurable PDO # starting from start_index while index < PDOTypeBaseIndex[pdotype] + 0x200: @@ -296,7 +296,7 @@ return index, cobid, values[0] index += 1 return None - + def AddPDOMapping(self, nodeid, pdotype, pdoindex, pdocobid, pdomapping, sync_TPDOs): """ Record a new mapping request for a slave, and add related slave config to the DCF @@ -305,16 +305,16 @@ @param pdomapping: list od variables to map with PDO """ # Add an entry to MasterMapping - self.MasterMapping[pdocobid] = {"type" : InvertPDOType[pdotype], + self.MasterMapping[pdocobid] = {"type" : InvertPDOType[pdotype], "mapping" : [None] + [(loc_infos["type"], name) for name, loc_infos in pdomapping]} - + # Return the data to add to DCF if sync_TPDOs: return GeneratePDOMappingDCF(pdoindex, pdocobid, 0x01, pdomapping) else: return GeneratePDOMappingDCF(pdoindex, pdocobid, 0xFF, pdomapping) return 0, "" - + def GenerateDCF(self, locations, current_location, sync_TPDOs): """ Generate Concise DCF of MasterNode for the locations list given @@ -322,18 +322,18 @@ @param current_location: tuple of the located prefixes not to be considered @param sync_TPDOs: indicate if TPDO must be synchronous """ - + #------------------------------------------------------------------------------- # Verify that locations correspond to real slave variables #------------------------------------------------------------------------------- - + # Get list of locations check if exists and mappables -> put them in IECLocations for location in locations: COlocationtype = IECToCOType[location["IEC_TYPE"]] name = location["NAME"] if name in self.IECLocations: if self.IECLocations[name]["type"] != COlocationtype: - raise PDOmappingException, _("Type conflict for location \"%s\"") % name + raise PDOmappingException, _("Type conflict for location \"%s\"") % name else: # Get only the part of the location that concern this node loc = location["LOC"][len(current_location):] @@ -342,30 +342,30 @@ raise PDOmappingException, _("Bad location size : %s") % str(loc) elif len(loc) == 2: continue - + direction = location["DIR"] - + sizelocation = location["SIZE"] - + # Extract and check nodeid nodeid, index, subindex = loc[:3] - + # Check Id is in slave node list if nodeid not in self.NodeList.SlaveNodes.keys(): raise PDOmappingException, _("Non existing node ID : {a1} (variable {a2})").format(a1 = nodeid, a2 = name) - + # Get the model for this node (made from EDS) node = self.NodeList.SlaveNodes[nodeid]["Node"] - + # Extract and check index and subindex if not node.IsEntry(index, subindex): msg = _("No such index/subindex ({a1},{a2}) in ID : {a3} (variable {a4})").\ format(a1 = "%x" % index, a2 ="%x" % subindex, a3 = nodeid, a4 = name) raise PDOmappingException, msg - + # Get the entry info subentry_infos = node.GetSubentryInfos(index, subindex) - + # If a PDO mappable if subentry_infos and subentry_infos["pdo"]: if sizelocation == "X" and len(loc) > 3: @@ -376,11 +376,11 @@ raise PDOmappingException, msg else: numbit = None - + if location["IEC_TYPE"] != "BOOL" and subentry_infos["type"] != COlocationtype: raise PDOmappingException, _("Invalid type \"{a1}\"-> {a2} != {a3} for location \"{a4}\"").\ format(a1 = location["IEC_TYPE"], a2 = COlocationtype, a3 = subentry_infos["type"] , a4 = name) - + typeinfos = node.GetEntryInfos(COlocationtype) self.IECLocations[name] = {"type":COlocationtype, "pdotype":SlavePDOType[direction], "nodeid": nodeid, "index": index,"subindex": subindex, @@ -388,21 +388,21 @@ else: raise PDOmappingException, _("Not PDO mappable variable : '{a1}' (ID:{a2},Idx:{a3},sIdx:{a4}))").\ format(a1 = name, a2 = nodeid, a3 = "%x" % index, a4 = "%x" % subindex) - + #------------------------------------------------------------------------------- # Search for locations already mapped #------------------------------------------------------------------------------- - + for name, locationinfos in self.IECLocations.items(): node = self.NodeList.SlaveNodes[locationinfos["nodeid"]]["Node"] - + # Search if slave has a PDO mapping this locations result = SearchNodePDOMapping(locationinfos, node) if result != None: index, subindex = result # Get COB ID of the PDO cobid = self.NodeList.GetSlaveNodeEntry(locationinfos["nodeid"], index - 0x200, 1) - + # Add PDO to MasterMapping if cobid not in self.MasterMapping.keys(): # Verify that PDO transmit type is conform to sync_TPDOs @@ -414,10 +414,10 @@ else: # Change TransmitType to ASYCHRONE data, nbparams = GeneratePDOMappingDCF(index - 0x200, cobid, 0xFF, []) - - # Add entry to slave dcf to change transmit type of + + # Add entry to slave dcf to change transmit type of self.AddParamsToDCF(locationinfos["nodeid"], data, nbparams) - + mapping = [None] values = node.GetEntry(index) # Store the size of each entry mapped in PDO @@ -425,7 +425,7 @@ if value != 0: mapping.append(value % 0x100) self.MasterMapping[cobid] = {"type" : InvertPDOType[locationinfos["pdotype"]], "mapping" : mapping} - + # Indicate that this PDO entry must be saved if locationinfos["bit"] is not None: if not isinstance(self.MasterMapping[cobid]["mapping"][subindex], ListType): @@ -434,24 +434,24 @@ self.MasterMapping[cobid]["mapping"][subindex][locationinfos["bit"]] = (locationinfos["type"], name) else: self.MasterMapping[cobid]["mapping"][subindex] = (locationinfos["type"], name) - + else: # Add location to those that haven't been mapped yet if locationinfos["nodeid"] not in self.LocationsNotMapped.keys(): self.LocationsNotMapped[locationinfos["nodeid"]] = {TPDO : [], RPDO : []} self.LocationsNotMapped[locationinfos["nodeid"]][locationinfos["pdotype"]].append((name, locationinfos)) - + #------------------------------------------------------------------------------- # Build concise DCF for the others locations #------------------------------------------------------------------------------- - + for nodeid, locations in self.LocationsNotMapped.items(): node = self.NodeList.SlaveNodes[nodeid]["Node"] - + # Initialize number of params and data to add to node DCF nbparams = 0 dataparams = "" - + # Generate the best PDO mapping for each type of PDO for pdotype in (TPDO, RPDO): if len(locations[pdotype]) > 0: @@ -483,78 +483,78 @@ data, nbaddedparams = self.AddPDOMapping(nodeid, pdotype, pdoindex, pdocobid, pdomapping, sync_TPDOs) dataparams += data nbparams += nbaddedparams - + # Add number of params and data to node DCF self.AddParamsToDCF(nodeid, dataparams, nbparams) - + #------------------------------------------------------------------------------- # Master Node Configuration #------------------------------------------------------------------------------- - + # Generate Master's Configuration from informations stored in MasterMapping for cobid, pdo_infos in self.MasterMapping.items(): # Get next PDO index in MasterNode for this PDO type current_idx = self.CurrentPDOParamsIdx[pdo_infos["type"]] - + # Search if there is already a PDO in MasterNode with this cob id for idx in GetNodePDOIndexes(self.MasterNode, pdo_infos["type"], True): if self.MasterNode.GetEntry(idx, 1) == cobid: current_idx = idx - + # Add a PDO to MasterNode if not PDO have been found if current_idx == self.CurrentPDOParamsIdx[pdo_infos["type"]]: addinglist = [current_idx, current_idx + 0x200] self.Manager.ManageEntriesOfCurrent(addinglist, [], self.MasterNode) self.MasterNode.SetEntry(current_idx, 0x01, cobid) - + # Increment the number of PDO for this PDO type self.CurrentPDOParamsIdx[pdo_infos["type"]] += 1 - + # Change the transmit type of the PDO if sync_TPDOs: self.MasterNode.SetEntry(current_idx, 0x02, 0x01) else: self.MasterNode.SetEntry(current_idx, 0x02, 0xFF) - + mapping = [] for item in pdo_infos["mapping"]: if isinstance(item, ListType): mapping.extend(item) else: mapping.append(item) - + # Add some subentries to PDO mapping if there is not enough if len(mapping) > 1: self.Manager.AddSubentriesToCurrent(current_idx + 0x200, len(mapping) - 1, self.MasterNode) - + # Generate MasterNode's PDO mapping for subindex, variable in enumerate(mapping): if subindex == 0: continue new_index = False - + if isinstance(variable, (IntType, LongType)): # If variable is an integer then variable is unexpected self.MasterNode.SetEntry(current_idx + 0x200, subindex, self.TrashVariables[variable]) else: typeidx, varname = variable variable_infos = self.IECLocations[varname] - + # Calculate base index for storing variable mapvariableidx = VariableStartIndex[variable_infos["pdotype"]] + \ VariableTypeOffset[variable_infos["sizelocation"]] * VariableIncrement + \ variable_infos["nodeid"] - + # Generate entry name indexname = "%s%s%s_%d"%(VariableDirText[variable_infos["pdotype"]], variable_infos["sizelocation"], '_'.join(map(str,current_location)), - variable_infos["nodeid"]) - - # Search for an entry that has an empty subindex + variable_infos["nodeid"]) + + # Search for an entry that has an empty subindex while mapvariableidx < VariableStartIndex[variable_infos["pdotype"]] + 0x2000: # Entry doesn't exist - if not self.MasterNode.IsEntry(mapvariableidx): + if not self.MasterNode.IsEntry(mapvariableidx): # Add entry to MasterNode self.Manager.AddMapVariableToCurrent(mapvariableidx, "beremiz"+indexname, 3, 1, self.MasterNode) new_index = True @@ -567,7 +567,7 @@ mapvariableidx += 8 * VariableIncrement else: break - + # Verify that a not full entry has been found if mapvariableidx < VariableStartIndex[variable_infos["pdotype"]] + 0x2000: # Generate subentry name @@ -582,13 +582,13 @@ # Add informations to the new subentry created self.MasterNode.SetMappingEntry(mapvariableidx, nbsubentries, values = {"name" : subindexname}) self.MasterNode.SetMappingEntry(mapvariableidx, nbsubentries, values = {"type" : typeidx}) - + # Set value of the PDO mapping typeinfos = self.Manager.GetEntryInfos(typeidx) if typeinfos != None: value = (mapvariableidx << 16) + ((nbsubentries) << 8) + typeinfos["size"] self.MasterNode.SetEntry(current_idx + 0x200, subindex, value) - + # Add variable to pointed variables self.PointedVariables[(mapvariableidx, nbsubentries)] = "%s_%s"%(indexname, subindexname) @@ -605,7 +605,7 @@ @param nodelist: CanFestival network editor model @return: a modified copy of the given CanFestival network editor model """ - + dcfgenerator = ConciseDCFGenerator(nodelist, nodename) dcfgenerator.GenerateDCF(locations, current_location, sync_TPDOs) masternode,pointers = dcfgenerator.GetMasterNode(), dcfgenerator.GetPointedVariables() @@ -621,7 +621,7 @@ name = location["NAME"] if name in IECLocations: if IECLocations[name] != COlocationtype: - raise PDOmappingException, _("Type conflict for location \"%s\"") % name + raise PDOmappingException, _("Type conflict for location \"%s\"") % name else: # Get only the part of the location that concern this node loc = location["LOC"][len(current_location):] @@ -630,25 +630,25 @@ raise PDOmappingException, _("Bad location size : %s") % str(loc) elif len(loc) != 2: continue - + # Extract and check nodeid index, subindex = loc[:2] - + # Extract and check index and subindex if not slave.IsEntry(index, subindex): raise PDOmappingException, _("No such index/subindex ({a1},{a2}) (variable {a3})").\ format(a1 = "%x" % index, a2 = "%x" % subindex, a3 = name) - + # Get the entry info - subentry_infos = slave.GetSubentryInfos(index, subindex) + subentry_infos = slave.GetSubentryInfos(index, subindex) if subentry_infos["type"] != COlocationtype: raise PDOmappingException, _("Invalid type \"{a1}\"-> {a2} != {a3} for location \"{a4}\"").\ format( a1 = location["IEC_TYPE"], a2 = COlocationtype, a3 = subentry_infos["type"] , a4 = name) - + IECLocations[name] = COlocationtype pointers[(index, subindex)] = name return pointers - + if __name__ == "__main__": import os, sys, getopt @@ -667,7 +667,7 @@ Use with caution. Be sure that config_utils is currently working properly. """%sys.argv[0] - + # Boolean that indicate if reference result must be redefined reset = False @@ -693,15 +693,15 @@ base_folder = os.path.split(base_folder)[0] # Add CanFestival folder to search pathes sys.path.append(os.path.join(base_folder, "CanFestival-3", "objdictgen")) - + from nodemanager import * from nodelist import * - + # Open the test nodelist contained into test_config folder manager = NodeManager() nodelist = NodeList(manager) result = nodelist.LoadProject("test_config") - + # List of locations, we try to map for test locations = [{"IEC_TYPE":"BYTE","NAME":"__IB0_1_64_24576_1","DIR":"I","SIZE":"B","LOC":(0,1,64,24576,1)}, {"IEC_TYPE":"INT","NAME":"__IW0_1_64_25601_2","DIR":"I","SIZE":"W","LOC":(0,1,64,25601,2)}, @@ -713,34 +713,34 @@ {"IEC_TYPE":"UDINT","NAME":"__ID0_1_64_25638_3","DIR":"I","SIZE":"D","LOC":(0,1,64,25638,3)}, {"IEC_TYPE":"UDINT","NAME":"__ID0_1_64_25638_4","DIR":"I","SIZE":"D","LOC":(0,1,64,25638,4)}, {"IEC_TYPE":"UDINT","NAME":"__ID0_1_4096_0","DIR":"I","SIZE":"D","LOC":(0,1,4096,0)}] - + # Generate MasterNode configuration try: masternode, pointedvariables = GenerateConciseDCF(locations, (0, 1), nodelist, True, "TestNode") except ValueError, message: print "%s\nTest Failed!"%message sys.exit() - + import pprint - # Get Text corresponding to MasterNode + # Get Text corresponding to MasterNode result_node = masternode.PrintString() result_vars = pprint.pformat(pointedvariables) result = result_node + "\n********POINTERS*********\n" + result_vars + "\n" - + # If reset has been choosen if reset: # Write Text into reference result file testfile = open("test_config/result.txt", "w") testfile.write(result) testfile.close() - + print "Reset Successful!" else: import os - + testfile = open("test_config/result_tmp.txt", "w") testfile.write(result) testfile.close() - + os.system("diff test_config/result.txt test_config/result_tmp.txt") os.remove("test_config/result_tmp.txt")