objdictgen/nodelist.py
changeset 242 4864f7f01e1d
parent 239 f45fd4cd3832
child 243 7fcc129a06ce
equal deleted inserted replaced
241:4ecc2f3690f4 242:4864f7f01e1d
    27 
    27 
    28 from node import *
    28 from node import *
    29 import eds_utils
    29 import eds_utils
    30 import os, shutil
    30 import os, shutil
    31 
    31 
    32 
       
    33 #-------------------------------------------------------------------------------
    32 #-------------------------------------------------------------------------------
    34 #                          Definition of NodeList Object
    33 #                          Definition of NodeList Object
    35 #-------------------------------------------------------------------------------
    34 #-------------------------------------------------------------------------------
    36 
    35 
    37 
       
    38 """
    36 """
    39 Class recording a node list for a CANOpen network.
    37 Class recording a node list for a CANOpen network.
    40 """
    38 """
    41 
    39 
    42 class NodeList:
    40 class NodeList:
    43     
    41     
    44     def __init__(self, manager):
    42     def __init__(self, manager, netname = ""):
    45         self.Root = ""
    43         self.Root = ""
    46         self.Manager = manager
    44         self.Manager = manager
    47         self.NetworkName = ""
    45         self.NetworkName = netname
    48         self.SlaveNodes = {}
    46         self.SlaveNodes = {}
    49         self.EDSNodes = {}
    47         self.EDSNodes = {}
    50         self.CurrentSelected = None
    48         self.CurrentSelected = None
       
    49         self.Changed = False
       
    50     
       
    51     def HasChanged(self):
       
    52         return self.Changed or not self.Manager.CurrentIsSaved()
       
    53     
       
    54     def ForceChanged(self, changed):
       
    55         self.Changed = changed
    51     
    56     
    52     def GetNetworkName(self):
    57     def GetNetworkName(self):
    53         return self.NetworkName
    58         return self.NetworkName
    54     
    59     
    55     def SetNetworkName(self, name):
    60     def SetNetworkName(self, name):
    78         self.CurrentSelected = selected
    83         self.CurrentSelected = selected
    79         
    84         
    80     def GetCurrentSelected(self):
    85     def GetCurrentSelected(self):
    81         return self.CurrentSelected
    86         return self.CurrentSelected
    82             
    87             
    83     def LoadProject(self, root):
    88     def LoadProject(self, root, netname = None):
    84         self.SlaveNodes = {}
    89         self.SlaveNodes = {}
    85         self.EDSNodes = {}
    90         self.EDSNodes = {}
    86         
    91         
    87         self.Root = root
    92         self.Root = root
    88         if not os.path.exists(self.Root):
    93         if not os.path.exists(self.Root):
    96         for file in files:
   101         for file in files:
    97             result = self.LoadEDS(file)
   102             result = self.LoadEDS(file)
    98             if result != None:
   103             if result != None:
    99                 return result
   104                 return result
   100                 
   105                 
   101         result = self.LoadMasterNode()
   106         result = self.LoadMasterNode(netname)
   102         if result != None:
   107         if result != None:
   103             return result
   108             return result
   104             
   109             
   105         result = self.LoadSlaveNodes()
   110         result = self.LoadSlaveNodes(netname)
   106         if result != None:
   111         if result != None:
   107             return result
   112             return result
   108     
   113         
   109     def SaveProject(self):
   114         self.NetworkName = netname
   110         result = self.SaveMasterNode()
   115     
       
   116     def SaveProject(self, netname = None):
       
   117         result = self.SaveMasterNode(netname)
   111         if result != None:
   118         if result != None:
   112             return result
   119             return result
   113             
   120             
   114         result = self.SaveNodeList()
   121         result = self.SaveNodeList(netname)
   115         if result != None:
   122         if result != None:
   116             return result
   123             return result
   117     
   124     
   118     def ImportEDSFile(self, edspath):
   125     def ImportEDSFile(self, edspath):
   119         dir, file = os.path.split(edspath)
   126         dir, file = os.path.split(edspath)
   135     
   142     
   136     def AddSlaveNode(self, nodeName, nodeID, eds):
   143     def AddSlaveNode(self, nodeName, nodeID, eds):
   137         if eds in self.EDSNodes.keys():
   144         if eds in self.EDSNodes.keys():
   138             slave = {"Name" : nodeName, "EDS" : eds, "Node" : self.EDSNodes[eds]}
   145             slave = {"Name" : nodeName, "EDS" : eds, "Node" : self.EDSNodes[eds]}
   139             self.SlaveNodes[nodeID] = slave
   146             self.SlaveNodes[nodeID] = slave
       
   147             self.Changed = True
   140             return None
   148             return None
   141         else:
   149         else:
   142             return "\"%s\" EDS file is not available"%eds
   150             return "\"%s\" EDS file is not available"%eds
   143     
   151     
   144     def RemoveSlaveNode(self, index):
   152     def RemoveSlaveNode(self, index):
   145         if index in self.SlaveNodes.keys():
   153         if index in self.SlaveNodes.keys():
   146             self.SlaveNodes.pop(index)
   154             self.SlaveNodes.pop(index)
       
   155             OnCloseProjectMenu
   147             return None
   156             return None
   148         else:
   157         else:
   149             return "Node with \"0x%2.2X\" ID doesn't exist"
   158             return "Node with \"0x%2.2X\" ID doesn't exist"
   150     
   159     
   151     def LoadMasterNode(self):
   160     def LoadMasterNode(self, netname = None):
   152         masterpath = os.path.join(self.Root, "master.od")
   161         if netname:
       
   162             masterpath = os.path.join(self.Root, "%s_master.od"%netname)
       
   163         else:
       
   164             masterpath = os.path.join(self.Root, "master.od")
   153         if os.path.isfile(masterpath):
   165         if os.path.isfile(masterpath):
   154             self.Manager.OpenFileInCurrent(masterpath)
   166             self.Manager.OpenFileInCurrent(masterpath)
   155         else:
   167         else:
   156             self.Manager.CreateNewNode("MasterNode", 0x00, "master", "", "None", "", "heartbeat", ["DS302"])
   168             self.Manager.CreateNewNode("MasterNode", 0x00, "master", "", "None", "", "heartbeat", ["DS302"])
   157         return None
   169         return None
   158     
   170     
   159     def SaveMasterNode(self):
   171     def SaveMasterNode(self, netname = None):
   160         masterpath = os.path.join(self.Root, "master.od")
   172         if netname:
       
   173             masterpath = os.path.join(self.Root, "%s_master.od"%netname)
       
   174         else:
       
   175             masterpath = os.path.join(self.Root, "master.od")
   161         if self.Manager.SaveCurrentInFile(masterpath):
   176         if self.Manager.SaveCurrentInFile(masterpath):
   162             return None
   177             return None
   163         else:
   178         else:
   164             return "Fail to save Master Node"
   179             return "Fail to save Master Node"
   165     
   180     
   166     def LoadSlaveNodes(self):
   181     def LoadSlaveNodes(self, netname = None):
   167         cpjpath = os.path.join(self.Root, "nodelist.cpj")
   182         cpjpath = os.path.join(self.Root, "nodelist.cpj")
   168         if os.path.isfile(cpjpath):
   183         if os.path.isfile(cpjpath):
   169             try:
   184             try:
   170                 networks = eds_utils.ParseCPJFile(cpjpath)
   185                 networks = eds_utils.ParseCPJFile(cpjpath)
   171                 if len(networks) > 0:
   186                 network = None
   172                     self.NetworkName = networks[0]["Name"]
   187                 if netname:
   173                     for nodeid, node in networks[0]["Nodes"].items():
   188                     for net in networks:
       
   189                         if net["Name"] == netname:
       
   190                             network = net
       
   191                     self.NetworkName = netname
       
   192                 elif len(networks) > 0:
       
   193                     network = networks[0]
       
   194                     self.NetworkName = network["Name"]
       
   195                 if network:
       
   196                     for nodeid, node in network["Nodes"].items():
   174                         if node["Present"] == 1:
   197                         if node["Present"] == 1:
   175                             result = self.AddSlaveNode(node["Name"], nodeid, node["DCFName"])
   198                             result = self.AddSlaveNode(node["Name"], nodeid, node["DCFName"])
   176                             if result != None:
   199                             if result != None:
   177                                 return result
   200                                 return result        
       
   201                 self.Changed = False
   178             except SyntaxError, message:
   202             except SyntaxError, message:
   179                 return "Unable to load CPJ file\n%s"%message
   203                 return "Unable to load CPJ file\n%s"%message
   180         return None
   204         return None
   181     
   205     
   182     def SaveNodeList(self):
   206     def SaveNodeList(self, netname = None):
   183         cpjpath = os.path.join(self.Root, "nodelist.cpj")
   207         try:
   184         content = eds_utils.GenerateCPJContent(self)
   208             cpjpath = os.path.join(self.Root, "nodelist.cpj")
   185         file = open(cpjpath, "w")
   209             content = eds_utils.GenerateCPJContent(self)
   186         file.write(content)
   210             if netname:
   187         file.close()
   211                 file = open(cpjpath, "a")
       
   212             else:
       
   213                 file = open(cpjpath, "w")
       
   214             file.write(content)
       
   215             file.close()
       
   216             self.Changed = False
       
   217             return None
       
   218         except:
       
   219             return "Fail to save node list"
   188     
   220     
   189     def GetSlaveNodeEntry(self, nodeid, index, subindex = None):
   221     def GetSlaveNodeEntry(self, nodeid, index, subindex = None):
   190         if nodeid in self.SlaveNodes.keys():
   222         if nodeid in self.SlaveNodes.keys():
   191             self.SlaveNodes[nodeid]["Node"].SetNodeID(nodeid)
   223             self.SlaveNodes[nodeid]["Node"].SetNodeID(nodeid)
   192             return self.SlaveNodes[nodeid]["Node"].GetEntry(index, subindex)
   224             return self.SlaveNodes[nodeid]["Node"].GetEntry(index, subindex)
   229                 return self.Manager.GetEntryInfos(index)
   261                 return self.Manager.GetEntryInfos(index)
   230             else:
   262             else:
   231                 node = self.SlaveNodes[self.CurrentSelected]["Node"]
   263                 node = self.SlaveNodes[self.CurrentSelected]["Node"]
   232                 if node:
   264                 if node:
   233                     return node.GetEntryInfos(index)
   265                     return node.GetEntryInfos(index)
       
   266         return None
       
   267 
       
   268     def GetSubentryInfos(self, index, subindex):
       
   269         if self.CurrentSelected != None:
       
   270             if self.CurrentSelected == 0:
       
   271                 return self.Manager.GetSubentryInfos(index, subindex)
       
   272             else:
       
   273                 node = self.SlaveNodes[self.CurrentSelected]["Node"]
       
   274                 if node:
       
   275                     return node.GetSubentryInfos(index, subindex)
   234         return None
   276         return None
   235 
   277 
   236     def GetCurrentValidIndexes(self, min, max):
   278     def GetCurrentValidIndexes(self, min, max):
   237         if self.CurrentSelected != None:
   279         if self.CurrentSelected != None:
   238             if self.CurrentSelected == 0:
   280             if self.CurrentSelected == 0:
   250         return []
   292         return []
   251     
   293     
   252     def GetCurrentEntryValues(self, index):
   294     def GetCurrentEntryValues(self, index):
   253         if self.CurrentSelected != None:
   295         if self.CurrentSelected != None:
   254             node = self.SlaveNodes[self.CurrentSelected]["Node"]
   296             node = self.SlaveNodes[self.CurrentSelected]["Node"]
   255             node.SetNodeID(self.CurrentSelected)
       
   256             if node:
   297             if node:
   257                 return self.Manager.GetNodeEntryValues(node, index)
   298                 return self.Manager.GetNodeEntryValues(node, index)
   258             else:
   299             else:
   259                 print "Can't find node"
   300                 print "Can't find node"
   260         return [], []
   301         return [], []
   261 
   302     
   262 if __name__ == "__main__":
   303 if __name__ == "__main__":
   263     from nodemanager import *
   304     from nodemanager import *
   264     import os, sys, shutil
   305     import os, sys, shutil
   265     
   306     
   266     manager = NodeManager(sys.path[0])
   307     manager = NodeManager(sys.path[0])
       
   308     
   267     nodelist = NodeList(manager)
   309     nodelist = NodeList(manager)
   268     #result = nodelist.LoadProject("/home/deobox/beremiz/test_nodelist")
   310     
   269     result = nodelist.LoadProject("/home/deobox/Desktop/TestMapping")
   311     result = nodelist.LoadProject("/home/laurent/test_nodelist")
   270     if result != None:
   312     if result != None:
   271         print result
   313         print result
   272     else:
   314     else:
   273         print "MasterNode :"
   315         print "MasterNode :"
   274         manager.CurrentNode.Print()
   316         manager.CurrentNode.Print()
       
   317         print 
   275         for nodeid, node in nodelist.SlaveNodes.items():
   318         for nodeid, node in nodelist.SlaveNodes.items():
   276             print "SlaveNode name=%s id=0x%2.2X :"%(node["Name"], nodeid)
   319             print "SlaveNode name=%s id=0x%2.2X :"%(node["Name"], nodeid)
   277             node["Node"].Print()
   320             node["Node"].Print()
   278 
   321             print
       
   322