--- a/plugins/canfestival/config_utils.py Tue Sep 11 17:29:27 2007 +0200
+++ b/plugins/canfestival/config_utils.py Wed Sep 12 17:16:27 2007 +0200
@@ -25,22 +25,24 @@
# Translation between IEC types and Can Open types
-DicoTypes = {"BOOL":0x01, "SINT":0x02, "INT":0x03,"DINT":0x04,"LINT":0x10,- "USINT":0x05,"UINT":0x06,"UDINT":0x07,"ULINT":0x1B,"REAL":0x08,- "LREAL":0x11,"STRING":0x09,"BYTE":0x05,"WORD":0x06,"DWORD":0x07,- "LWORD":0x1B,"WSTRING":0x0B}-DictNameVariable = { "" : 1, "X": 2, "B": 3, "W": 4, "D": 5, "L": 6, "increment": 0x100, 1:("__I", 0x2000), 2:("__Q", 0x4000)}+IECToCOType = {"BOOL":0x01, "SINT":0x02, "INT":0x03,"DINT":0x04,"LINT":0x10, + "USINT":0x05,"UINT":0x06,"UDINT":0x07,"ULINT":0x1B,"REAL":0x08, + "LREAL":0x11,"STRING":0x09,"BYTE":0x05,"WORD":0x06,"DWORD":0x07, + "LWORD":0x1B,"WSTRING":0x0B} # Constants for PDO types
SlavePDOType = {"I" : TPDO, "Q" : RPDO}
InvertPDOType = {RPDO : TPDO, TPDO : RPDO}
-GenerateMasterMapping = lambda x:[None] + [(loc_infos["type"], name) for name, loc_infos in x]+VariableIncrement = 0x100 +VariableStartIndex = {TPDO : 0x2000, RPDO : 0x4000} +VariableDirText = {TPDO : "__I", RPDO : "__Q"} +VariableTypeOffset = dict(zip(["","X","B","W","D","L"], range(6))) -TrashVariableSizes = {1 : 0x01, 8 : 0x05, 16 : 0x06, 32 : 0x07, 64 : 0x1B}+TrashVariables = [(1, 0x01), (8, 0x05), (16, 0x06), (32, 0x07), (64, 0x1B)] def LE_to_BE(value, size):
@@ -55,6 +57,7 @@
return "".join([chr(int(car, 16)) for car in list_car])
def GetNodePDOIndexes(node, type, parameters = False):
Find the PDO indexes of a node
@@ -74,6 +77,7 @@
def SearchNodePDOMapping(loc_infos, node):
Find the PDO indexes of a node
@@ -94,26 +98,53 @@
+def GeneratePDOMappingDCF(idx, cobid, transmittype, pdomapping): + Build concise DCF value for configuring a PDO + @param idx: index of PDO parameters + @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 + # Create entry for RPDO or TPDO parameters and Disable PDO + dcfdata = LE_to_BE(idx, 2) + LE_to_BE(0x01, 1) + LE_to_BE(0x04, 4) + LE_to_BE((0x80000000 + cobid), 4) + # Set Transmit type synchrone + dcfdata += LE_to_BE(idx, 2) + LE_to_BE(0x02, 1) + LE_to_BE(0x01, 4) + LE_to_BE(transmittype, 1) + # ---- INDEX ----- --- SUBINDEX ---- ----- SIZE ------ ------ DATA ------ + dcfdata += LE_to_BE(idx, 2) + LE_to_BE(0x01, 1) + LE_to_BE(0x04, 4) + LE_to_BE(0x00000000 + cobid, 4) + for subindex, (name, loc_infos) in enumerate(pdomapping): + value = (loc_infos["index"] << 16) + (loc_infos["subindex"] << 8) + loc_infos["size"] + dcfdata += LE_to_BE(idx + 0x200, 2) + LE_to_BE(subindex + 1, 1) + LE_to_BE(0x04, 4) + LE_to_BE(value, 4) + return dcfdata, nbparams class ConciseDCFGenerator:
def __init__(self, nodelist):
# Dictionary of location informations classed by name
- self.DictLocations = {}+ # Dictionary of location that have not been mapped yet + self.LocationsNotMapped = {} # Dictionary of location informations classed by name
- # Dictionary of location that have not been mapped yet- self.DictLocationsNotMapped = {}+ self.MasterMapping = {} # List of COB IDs available
self.ListCobIDAvailable = range(0x180, 0x580)
self.SlavesPdoNumber = {}
# Dictionary of mapping value where unexpected variables are stored
- TrashVariableValue = {}+ self.TrashVariables = {} self.Manager = self.NodeList.Manager
self.MasterNode = self.Manager.GetCurrentNodeCopy()
def RemoveUsedNodeCobId(self, node):
Remove all PDO COB ID used by the given node from the list of available COB ID
@@ -137,6 +168,7 @@
return len(nodeRpdoIndexes), len(nodeTpdoIndexes)
def PrepareMasterNode(self):
Add mandatory entries for DCF generation into MasterNode.
@@ -145,18 +177,18 @@
# Adding DCF entry into Master node
if not self.MasterNode.IsEntry(0x1F22):
self.MasterNode.AddEntry(0x1F22, 1, "")
- self.Manager.AddSubentriesToCurrent(0x1F22, 127, masternode)+ self.Manager.AddSubentriesToCurrent(0x1F22, 127, self.MasterNode) # Adding trash mappable variables for unused mapped datas
- idxTrashVariables = 0x2000 + masternode.GetNodeID()+ idxTrashVariables = 0x2000 + self.MasterNode.GetNodeID() # Add an entry for storing unexpected all variable
- self.Manager.AddMapVariableToCurrent(idxTrashVariables, "trashvariables", 3, len(TrashVariableSizes), self.MasterNode)- for subidx, (size, typeidx) in enumerate(TrashVariableSizes.items()):+ self.Manager.AddMapVariableToCurrent(idxTrashVariables, "trashvariables", 3, len(TrashVariables), self.MasterNode) + for subidx, (size, typeidx) in enumerate(TrashVariables): # Add a subentry for storing unexpected variable of this size
self.Manager.SetCurrentEntry(idxTrashVariables, subidx + 1, "TRASH%d" % size, "name", None, self.MasterNode)
self.Manager.SetCurrentEntry(idxTrashVariables, subidx + 1, typeidx, "type", None, self.MasterNode)
# Store the mapping value for this entry
- self.TrashVariableValue[size] = (idxTrashVariables << 16) + ((subidx + 1) << 8) + size+ self.TrashVariables[size] = (idxTrashVariables << 16) + ((subidx + 1) << 8) + size RPDOnumber, TPDOnumber = self.RemoveUsedNodeCobId(self.MasterNode)
@@ -164,7 +196,7 @@
self.CurrentPDOParamsIdx = {RPDO : 0x1400 + RPDOnumber, TPDO : 0x1800 + TPDOnumber}
# Prepare MasterNode with all nodelist slaves
- for nodeid, nodeinfos in self.NodeList.SlaveNodes.items():+ for idx, (nodeid, nodeinfos) in enumerate(self.NodeList.SlaveNodes.items()): @@ -182,41 +214,23 @@
TSDO_cobid = 0x580 + nodeid
# Configure Master's SDO parameters entries
- self.Manager.ManageEntriesOfCurrent([0x1280 + nodeid], [], self.MasterNode)- self.MasterNode.SetEntry(0x1280 + nodeid, 0x01, RSDO_cobid)- self.MasterNode.SetEntry(0x1280 + nodeid, 0x02, TSDO_cobid)- self.MasterNode.SetEntry(0x1280 + nodeid, 0x03, nodeid) + 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)
- def GenerateMappingDCF(cobid, idx, pdomapping, mapped):- # Create entry for RPDO or TPDO parameters and Disable PDO- dcfdata = LE_to_BE(idx, 2) + LE_to_BE(0x01, 1) + LE_to_BE(0x04, 4) + LE_to_BE((0x80000000 + cobid), 4)- # Set Transmit type synchrone- dcfdata += LE_to_BE(idx, 2) + LE_to_BE(0x02, 1) + LE_to_BE(0x01, 4) + LE_to_BE(DefaultTransmitTypeSlave, 1)- # ---- INDEX ----- --- SUBINDEX ---- ----- SIZE ------ ------ DATA ------- dcfdata += LE_to_BE(idx, 2) + LE_to_BE(0x01, 1) + LE_to_BE(0x04, 4) + LE_to_BE(0x00000000 + cobid, 4)- if mapped == False and pdomapping != None:- for subindex, (name, loc_infos) in enumerate(pdomapping):- value = (loc_infos["index"] << 16) + (loc_infos["subindex"] << 8) + loc_infos["size"]- dcfdata += LE_to_BE(idx + 0x200, 2) + LE_to_BE(subindex + 1, 1) + LE_to_BE(0x04, 4) + LE_to_BE(value, 4)- return dcfdata, nbparams- # Return a cobid not used def GetNewCobID(self, nodeid, type):
Select a COB ID from the list of those available
- @param nodeid: id of the slave node+ @param nodeid: id of the slave (int) @param type: type of PDO (RPDO or TPDO)
@return: a tuple of the COD ID and PDO index or None
@@ -249,7 +263,56 @@
return self.ListCobIDAvailable.pop(0), 0x1800 + nbSlavePDO
+ def AddParamsToDCF(self, nodeid, data, nbparams): + Select a COB ID from the list of those available + @param nodeid: id of the slave (int) + @param data: data to add to slave DCF (string) + @param nbparams: number of params added to slave DCF (int) + # 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]] + nbparams += int(''.join(["%2.2x"%ord(i) for i in tmpnbparams]), 16) + data = nodeDCF[4:] + data + dcf = LE_to_BE(nbparams, 0x04) + data + # Set new DCF for slave + self.MasterNode.SetEntry(0x1F22, nodeid, dcf) + def AddPDOMapping(self, nodeid, pdotype, pdomapping, sync_TPDOs): + Select a COB ID from the list of those available + @param nodeid: id of the slave (int) + @param pdotype: type of PDO to generated (RPDO or TPDO) + @param pdomapping: list od variables to map with PDO + result = self.GetNewCobID(nodeid, pdotype) + new_cobid, new_idx = result + # Increment the number of PDO of this type for node + self.SlavesPdoNumber[nodeid][pdotype] += 1 + # Add an entry to MasterMapping + self.MasterMapping[new_cobid] = {"type" : InvertPDOType[pdotype], + "mapping" : [None] + [(loc_infos["type"], name) for name, loc_infos in pdomapping]} + # Return the data to add to DCF + return GeneratePDOMappingDCF(new_idx, new_cobid, 0x01, pdomapping) + return GeneratePDOMappingDCF(new_idx, new_cobid, 0xFF, pdomapping) def GenerateDCF(self, locations, current_location, sync_TPDOs):
Generate Concise DCF of MasterNode for the locations list given
@@ -258,12 +321,12 @@
@param sync_TPDOs: indicate if TPDO must be synchronous
- # Get list of locations check if exists and mappables -> put them in DictLocations+ # Get list of locations check if exists and mappables -> put them in IECLocations for location in locations:
- COlocationtype = DicoTypes[location["IEC_TYPE"]]+ COlocationtype = IECToCOType[location["IEC_TYPE"]] - if name in DictLocations:- if DictLocations[name]["type"] != COlocationtype:+ if name in self.IECLocations: + if self.IECLocations[name]["type"] != COlocationtype: raise ValueError, "Conflict type for location \"%s\"" % name
# Get only the part of the location that concern this node
@@ -280,11 +343,11 @@
nodeid, index, subindex = loc[:3]
# Check Id is in slave node list
- if nodeid not in nodelist.SlaveNodes.keys():+ if nodeid not in self.NodeList.SlaveNodes.keys(): raise ValueError, "Non existing node ID : %d (variable %s)" % (nodeid,name)
# Get the model for this node (made from EDS)
- node = nodelist.SlaveNodes[nodeid]["Node"]+ node = self.NodeList.SlaveNodes[nodeid]["Node"] # Extract and check index and subindex
if not node.IsEntry(index, subindex):
@@ -307,72 +370,69 @@
raise ValueError, "Invalid type \"%s\"-> %d != %d for location\"%s\"" % (location["IEC_TYPE"], COlocationtype, entryinfos["type"] , name)
typeinfos = node.GetEntryInfos(COlocationtype)
- DictLocations[name] = {"type":COlocationtype, "pdotype":SlavePDOType[direction],- "nodeid": nodeid, "index": index,"subindex": subindex,- "bit": numbit, "size": typeinfos["size"], "sizelocation": sizelocation}+ self.IECLocations[name] = {"type":COlocationtype, "pdotype":SlavePDOType[direction], + "nodeid": nodeid, "index": index,"subindex": subindex, + "bit": numbit, "size": typeinfos["size"], "sizelocation": sizelocation} raise ValueError, "Not PDO mappable variable : '%s' (ID:%d,Idx:%x,sIdx:%x))" % (name,nodeid,index,subindex)
- # Create DictCobID with variables already mapped and add them in DictValidLocations- for name, locationinfos in DictLocations.items():+ #------------------------------------------------------------------------------- + # 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)
- cobid = nodelist.GetSlaveNodeEntry(locationinfos["nodeid"], index - 0x200, 1)- transmittype = nodelist.GetSlaveNodeEntry(locationinfos["nodeid"], index - 0x200, 2)+ # Get COB ID of the PDO + cobid = self.NodeList.GetSlaveNodeEntry(locationinfos["nodeid"], index - 0x200, 1) - if transmittype != sync_TPDOs:- if sync_TPDOs : # Change TransmitType to ASYCHRONE- node = nodelist.SlaveNodes[nodeid]["Node"]- nodeDCF = masternode.GetEntry(0x1F22, nodeid)- if nodeDCF != None and nodeDCF != '':- tmpnbparams = [i for i in nodeDCF[:4]]- nbparams = int(''.join(["%2.2x"%ord(i) for i in tmpnbparams]), 16)- dataparams = nodeDCF[4:]+ # Verify that PDO transmit type is conform to sync_TPDOs + transmittype = self.NodeList.GetSlaveNodeEntry(locationinfos["nodeid"], index - 0x200, 2) + if sync_TPDOs and transmittype != 0x01 or transmittype != 0xFF: + # Change TransmitType to SYNCHRONE + data, nbparams = GeneratePDOMappingDCF(index - 0x200, cobid, 0x01, []) + # Change TransmitType to ASYCHRONE + data, nbparams = GeneratePDOMappingDCF(index - 0x200, cobid, 0xFF, []) - else: # Change TransmitType to SYNCHRONE - if cobid not in DictCobID.keys():+ # Add entry to slave dcf to change transmit type of + self.AddParamsToDCF(locationinfos["nodeid"], data, nbparams) + # Add PDO to MasterMapping + if cobid not in self.MasterMapping.keys(): values = node.GetEntry(index)
+ # Store the size of each entry mapped in PDO mapping.append(value % 0x100)
- DictCobID[cobid] = {"type" : InvertPDOType[locationinfos["pdotype"]], "mapping" : mapping}+ self.MasterMapping[cobid] = {"type" : InvertPDOType[locationinfos["pdotype"]], "mapping" : mapping} - DictCobID[cobid]["mapping"][subindex] = (locationinfos["type"], name)+ # Indicate that this PDO entry must be saved + self.MasterMapping[cobid]["mapping"][subindex] = (locationinfos["type"], name) - if locationinfos["nodeid"] not in DictLocationsNotMapped.keys():- DictLocationsNotMapped[locationinfos["nodeid"]] = {TPDO : [], RPDO : []}- DictLocationsNotMapped[locationinfos["nodeid"]][locationinfos["pdotype"]].append((name, locationinfos))+ # 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 DictLocationsNotMapped.items():- # Get current concise DCF+ for nodeid, locations in self.LocationsNotMapped.items(): node = nodelist.SlaveNodes[nodeid]["Node"]
- nodeDCF = masternode.GetEntry(0x1F22, nodeid)- if nodeDCF != None and nodeDCF != '':- tmpnbparams = [i for i in nodeDCF[:4]]- nbparams = int(''.join(["%2.2x"%ord(i) for i in tmpnbparams]), 16)- dataparams = nodeDCF[4:]+ # Initialize number of params and data to add to node DCF + # Generate the best PDO mapping for each type of PDO for pdotype in (TPDO, RPDO):
@@ -380,103 +440,117 @@
pdosize += loc_infos["size"]
# If pdo's size > 64 bits
- result = GetNewCobID(nodeid, pdotype)- SlavesPdoNumber[nodeid][pdotype] += 1- new_cobid, new_idx = result- data, nbaddedparams = GenerateMappingDCF(new_cobid, new_idx, pdomapping, False)- nbparams += nbaddedparams- DictCobID[new_cobid] = {"type" : InvertPDOType[pdotype], "mapping" : GenerateMasterMapping(pdomapping)}+ # Generate a new PDO Mapping + data, nbaddedparams = self.AddPDOMapping(nodeid, pdotype, pdomapping, sync_TPDOs) + nbparams += nbaddedparams pdosize = loc_infos["size"]
pdomapping = [(name, loc_infos)]
pdomapping.append((name, loc_infos))
+ # If there isn't locations yet but there is still a PDO to generate - result = GetNewCobID(nodeid, pdotype)- SlavesPdoNumber[nodeid][pdotype] += 1- new_cobid, new_idx = result- data, nbaddedparams = GenerateMappingDCF(new_cobid, new_idx, pdomapping, False)- nbparams += nbaddedparams- DictCobID[new_cobid] = {"type" : InvertPDOType[pdotype], "mapping" : GenerateMasterMapping(pdomapping)}+ # Generate a new PDO Mapping + data, nbaddedparams = self.AddPDOMapping(nodeid, pdotype, pdomapping, sync_TPDOs) + nbparams += nbaddedparams - dcf = LE_to_BE(nbparams, 0x04) + dataparams- masternode.SetEntry(0x1F22, nodeid, dcf)+ # Add number of params and data to node DCF + self.AddParamsToDCF(nodeid, dataparams, nbparams) #-------------------------------------------------------------------------------
# Master Node Configuration
#-------------------------------------------------------------------------------
- # Configure Master's PDO parameters entries and set cobid, transmit type- for cobid, pdo_infos in DictCobID.items():- current_idx = CurrentPDOParamsIdx[pdo_infos["type"]]- addinglist = [current_idx, current_idx + 0x200]- manager.ManageEntriesOfCurrent(addinglist, [], masternode)- masternode.SetEntry(current_idx, 0x01, cobid)- masternode.SetEntry(current_idx, 0x02, DefaultTransmitTypeMaster)+ # 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: + # 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 + self.MasterNode.SetEntry(current_idx, 0x02, 0x01) + self.MasterNode.SetEntry(current_idx, 0x02, 0xFF) + # Add some subentries to PDO mapping if there is not enough if len(pdo_infos["mapping"]) > 2:
- manager.AddSubentriesToCurrent(current_idx + 0x200, len(pdo_infos["mapping"]) - 2, masternode)+ self.Manager.AddSubentriesToCurrent(current_idx + 0x200, len(pdo_infos["mapping"]) - 2, self.MasterNode) - # Create Master's PDO mapping+ # Generate MasterNode's PDO mapping for subindex, variable in enumerate(pdo_infos["mapping"]):
- if type(variable) != IntType:+ if type(variable) == IntType: + # If variable is an integer then variable is unexpected + self.MasterNode.SetEntry(current_idx + 0x200, subindex, self.TrashVariables[variable]) typeidx, varname = variable
- DictNameVariable[DictLocations[variable[1]]["pdotype"]][0] + \- DictLocations[variable[1]]["sizelocation"] + \- '_'.join(map(str,current_location)) + \- str(DictLocations[variable[1]]["nodeid"])- mapvariableidx = DictNameVariable[DictLocations[variable[1]]["pdotype"]][1] + DictNameVariable[DictLocations[variable[1]]["sizelocation"]] * DictNameVariable["increment"]- #indexname = DictNameVariable[DictLocations[variable[1]]["pdotype"]][0] + DictLocations[variable[1]]["sizelocation"] + str(DictLocations[variable[1]]["prefix"]) + "_" + str(DictLocations[variable[1]]["nodeid"])- #mapvariableidx = DictNameVariable[DictLocations[variable[1]]["pdotype"]][1] + DictNameVariable[DictLocations[variable[1]]["sizelocation"]] * DictNameVariable["increment"]+ variable_infos = self.IECLocations[varname] + # Calculate base index for storing variable + mapvariableidx = VariableStartIndex[variable_infos["pdotype"]] + \ + VariableTypeOffset[variable_infos["sizelocation"]] * VariableIncrement + \ + variable_infos["nodeid"] - if not masternode.IsEntry(mapvariableidx):- manager.AddMapVariableToCurrent(mapvariableidx, indexname, 3, 1, masternode)- nbsubentries = masternode.GetEntry(mapvariableidx, 0x00)- nbsubentries = masternode.GetEntry(mapvariableidx, 0x00)- mapvariableidxbase = mapvariableidx - while mapvariableidx < (mapvariableidxbase + 0x1FF) and nbsubentries == 0xFF:- mapvariableidx += 0x800- if not manager.IsCurrentEntry(mapvariableidx):- manager.AddMapVariableToCurrent(mapvariableidx, indexname, 3, 1, masternode)- nbsubentries = masternode.GetEntry(mapvariableidx, 0x00)- if mapvariableidx < 0x6000:- if DictLocations[variable[1]]["bit"] != None:- subindexname = str(DictLocations[variable[1]]["index"]) + "_" + str(DictLocations[variable[1]]["subindex"]) + "_" + str(DictLocations[variable[1]]["bit"])+ # Search for an entry that has an empty subindex + while mapvariableidx < VariableStartIndex[variable_infos["pdotype"]] + 0x2000: + if not self.MasterNode.IsEntry(mapvariableidx): + indexname = "%s%s%s_%d"%(VariableDirText[variable_infos["pdotype"]], + variable_infos["sizelocation"], + '_'.join(map(str,current_location)), + variable_infos["nodeid"]) + # Add entry to MasterNode + self.Manager.AddMapVariableToCurrent(mapvariableidx, indexname, 3, 1, self.MasterNode) + nbsubentries = self.MasterNode.GetEntry(mapvariableidx, 0x00) - subindexname = str(DictLocations[variable[1]]["index"]) + "_" + str(DictLocations[variable[1]]["subindex"])+ # Get Number of subentries already defined + nbsubentries = self.MasterNode.GetEntry(mapvariableidx, 0x00) + # if entry is full, go to next entry possible or stop now + if nbsubentries == 0xFF: + mapvariableidx += 8 * VariableIncrement + # Verify that a not full entry has been found + if mapvariableidx < VariableStartIndex[variable_infos["pdotype"]] + 0x2000: + # Generate subentry name + if variable_infos["bit"] != None: + subindexname = "%(index)d_%(subindex)d_%(bit)d"%variable_infos + subindexname = "%(index)d_%(subindex)d"%variable_infos + # If entry have just been created, no subentry have to be added - manager.AddSubentriesToCurrent(mapvariableidx, 1, masternode)+ self.Manager.AddSubentriesToCurrent(mapvariableidx, 1, self.MasterNode) - masternode.SetMappingEntry(mapvariableidx, nbsubentries, values = {"name" : subindexname})- masternode.SetMappingEntry(mapvariableidx, nbsubentries, values = {"type" : typeidx})+ # Add informations to the new subentry created + self.MasterNode.SetMappingEntry(mapvariableidx, nbsubentries, values = {"name" : subindexname}) + self.MasterNode.SetMappingEntry(mapvariableidx, nbsubentries, values = {"type" : typeidx})
- typeinfos = manager.GetEntryInfos(typeidx)+ # Set value of the PDO mapping + typeinfos = self.Manager.GetEntryInfos(typeidx) value = (mapvariableidx << 16) + ((nbsubentries) << 8) + typeinfos["size"]
- masternode.SetEntry(current_idx + 0x200, subindex, value)- masternode.SetEntry(current_idx + 0x200, subindex, TrashVariableValue[variable])- CurrentPDOParamsIdx[pdo_infos["type"]] += 1+ self.MasterNode.SetEntry(current_idx + 0x200, subindex, value) def GenerateConciseDCF(locations, current_location, nodelist, sync_TPDOs):
@@ -496,31 +570,56 @@
dcfgenerator.GenerateDCF(locations, current_location, sync_TPDOs)
return dcfgenerator.GetMasterNode()
-if __name__ == "__main__": +if __name__ == "__main__": + base_folder = sys.path[0] + base_folder = os.path.split(base_folder)[0] + sys.path.append(os.path.join(base_folder, "CanFestival-3", "objdictgen")) from nodemanager import *
- manager = NodeManager(sys.path[0])+ manager = NodeManager() nodelist = NodeList(manager)
- result = nodelist.LoadProject("/home/deobox/Desktop/TestMapping")-## manager.CurrentNode.Print()-## for nodeid, node in nodelist.SlaveNodes.items():-## print "SlaveNode name=%s id=0x%2.2X :"%(node["Name"], nodeid)- #filepath = "/home/deobox/beremiz/test_nodelist/listlocations.txt"- filepath = "/home/deobox/Desktop/TestMapping/listlocations.txt"+ result = nodelist.LoadProject("test_config") + 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)}, + {"IEC_TYPE":"INT","NAME":"__IW0_1_64_25601_3","DIR":"I","SIZE":"W","LOC":(0,1,64,25601,3)}, + {"IEC_TYPE":"INT","NAME":"__QW0_1_64_25617_2","DIR":"Q","SIZE":"W","LOC":(0,1,64,25617,1)}, + {"IEC_TYPE":"BYTE","NAME":"__IB0_1_64_24578_1","DIR":"I","SIZE":"B","LOC":(0,1,64,24578,1)}, + {"IEC_TYPE":"UDINT","NAME":"__ID0_1_64_25638_1","DIR":"I","SIZE":"D","LOC":(0,1,64,25638,1)}, + {"IEC_TYPE":"UDINT","NAME":"__ID0_1_64_25638_2","DIR":"I","SIZE":"D","LOC":(0,1,64,25638,2)}, + {"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)}] + masternode = GenerateConciseDCF(locations, (0, 1), nodelist, True) + result = [line.rstrip() for line in masternode.PrintString().splitlines()] + file = open("test_config/result.txt", "r") + model = [line.rstrip() for line in file.readlines()] - file = open(filepath,'r')- locations = [location.split(' ') for location in [line.strip() for line in file.readlines() if len(line) > 0]] - GenerateConciseDCF(locations, 32, nodelist)- manager.CurrentNode.Print()\ No newline at end of file
+ for i, line in enumerate(model): + print "Line %d disappear :"%(i + 1) + elif line != result[i]: + print "Error on line %d :"%(i + 1) + print "Instead of :\n\t%s"%line + for i in xrange(len(model), len(result)): + print "Line %d appear :"%(i + 1) + print "Test Successful!" \ No newline at end of file
