1 #!/usr/bin/env python

     2 # -*- coding: utf-8 -*-

     3 

     4 #This file is part of CanFestival, a library implementing CanOpen Stack. 

     5 #

     6 #Copyright (C): Edouard TISSERANT, Francis DUPIN and Laurent BESSARD

     7 #

     8 #See COPYING file for copyrights details.

     9 #

    10 #This library is free software; you can redistribute it and/or

    11 #modify it under the terms of the GNU Lesser General Public

    12 #License as published by the Free Software Foundation; either

    13 #version 2.1 of the License, or (at your option) any later version.

    14 #

    15 #This library is distributed in the hope that it will be useful,

    16 #but WITHOUT ANY WARRANTY; without even the implied warranty of

    17 #MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

    18 #Lesser General Public License for more details.

    19 #

    20 #You should have received a copy of the GNU Lesser General Public

    21 #License along with this library; if not, write to the Free Software

    22 #Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

    23 

    24 from gnosis.xml.pickle import *

    25 from gnosis.xml.pickle.util import setParanoia

    26 setParanoia(0)

    27 

    28 from node import *

    29 import eds_utils

    30 import os, shutil

    31 

    32 #-------------------------------------------------------------------------------

    33 #                          Definition of NodeList Object

    34 #-------------------------------------------------------------------------------

    35 

    36 """

    37 Class recording a node list for a CANOpen network.

    38 """

    39 

    40 class NodeList:

    41     

    42     def __init__(self, manager):

    43         self.Root = ""

    44         self.Manager = manager

    45         self.NetworkName = ""

    46         self.SlaveNodes = {}

    47         self.EDSNodes = {}

    48         self.CurrentSelected = None

    49     

    50     def GetNetworkName(self):

    51         return self.NetworkName

    52     

    53     def SetNetworkName(self, name):

    54         self.NetworkName = name

    55     

    56     def GetManager(self):

    57         return self.Manager

    58     

    59     def GetRoot(self):

    60         return self.Root

    61     

    62     def GetSlaveNumber(self):

    63         return len(self.SlaveNodes)

    64     

    65     def GetSlaveNames(self):

    66         nodes = self.SlaveNodes.keys()

    67         nodes.sort()

    68         return ["0x%2.2X %s"%(idx, self.SlaveNodes[idx]["Name"]) for idx in nodes]

    69     

    70     def GetSlaveIDs(self):

    71         nodes = self.SlaveNodes.keys()

    72         nodes.sort()

    73         return nodes

    74         

    75     def SetCurrentSelected(self, selected):

    76         self.CurrentSelected = selected

    77         

    78     def GetCurrentSelected(self):

    79         return self.CurrentSelected

    80             

    81     def LoadProject(self, root):

    82         self.SlaveNodes = {}

    83         self.EDSNodes = {}

    84         

    85         self.Root = root

    86         if not os.path.exists(self.Root):

    87             return "\"%s\" folder doesn't exist"%self.Root

    88         

    89         self.EDSFolder = os.path.join(self.Root, "eds")

    90         if not os.path.exists(self.EDSFolder):

    91             return "\"%s\" folder doesn't contain a \"eds\" folder"%self.Root

    92         

    93         files = os.listdir(self.EDSFolder)

    94         for file in files:

    95             result = self.LoadEDS(file)

    96             if result != None:

    97                 return result

    98                 

    99         result = self.LoadMasterNode()

   100         if result != None:

   101             return result

   102             

   103         result = self.LoadSlaveNodes()

   104         if result != None:

   105             return result

   106     

   107     def SaveProject(self):

   108         result = self.SaveMasterNode()

   109         if result != None:

   110             return result

   111             

   112         result = self.SaveNodeList()

   113         if result != None:

   114             return result

   115     

   116     def ImportEDSFile(self, edspath):

   117         dir, file = os.path.split(edspath)

   118         eds = os.path.join(self.EDSFolder, file)

   119         if os.path.isfile(eds):

   120             return "EDS file already imported"

   121         else:

   122             shutil.copy(edspath, self.EDSFolder)

   123             return self.LoadEDS(file)

   124     

   125     def LoadEDS(self, eds):

   126         edspath = os.path.join(self.EDSFolder, eds)

   127         node = eds_utils.GenerateNode(edspath, self.Manager.ScriptDirectory)

   128         if isinstance(node, Node):

   129             self.EDSNodes[eds] = node

   130             return None

   131         else:

   132             return node

   133     

   134     def AddSlaveNode(self, nodeName, nodeID, eds):

   135         if eds in self.EDSNodes.keys():

   136             slave = {"Name" : nodeName, "EDS" : eds, "Node" : self.EDSNodes[eds]}

   137             self.SlaveNodes[nodeID] = slave

   138             return None

   139         else:

   140             return "\"%s\" EDS file is not available"%eds

   141     

   142     def RemoveSlaveNode(self, index):

   143         if index in self.SlaveNodes.keys():

   144             self.SlaveNodes.pop(index)

   145             return None

   146         else:

   147             return "Node with \"0x%2.2X\" ID doesn't exist"

   148     

   149     def LoadMasterNode(self):

   150         masterpath = os.path.join(self.Root, "master.od")

   151         if os.path.isfile(masterpath):

   152             self.Manager.OpenFileInCurrent(masterpath)

   153         else:

   154             self.Manager.CreateNewNode("MasterNode", 0x00, "master", "", "None", "", "heartbeat", ["DS302"])

   155         return None

   156     

   157     def SaveMasterNode(self):

   158         masterpath = os.path.join(self.Root, "master.od")

   159         if self.Manager.SaveCurrentInFile(masterpath):

   160             return None

   161         else:

   162             return "Fail to save Master Node"

   163     

   164     def LoadSlaveNodes(self):

   165         cpjpath = os.path.join(self.Root, "nodelist.cpj")

   166         if os.path.isfile(cpjpath):

   167             try:

   168                 networks = eds_utils.ParseCPJFile(cpjpath)

   169                 if len(networks) > 0:

   170                     self.NetworkName = networks[0]["Name"]

   171                     for nodeid, node in networks[0]["Nodes"].items():

   172                         if node["Present"] == 1:

   173                             result = self.AddSlaveNode(node["Name"], nodeid, node["DCFName"])

   174                             if result != None:

   175                                 return result

   176             except SyntaxError, message:

   177                 return "Unable to load CPJ file\n%s"%message

   178         return None

   179     

   180     def SaveNodeList(self):

   181         cpjpath = os.path.join(self.Root, "nodelist.cpj")

   182         content = eds_utils.GenerateCPJContent(self)

   183         file = open(cpjpath, "w")

   184         file.write(content)

   185         file.close()

   186     

   187     def GetSlaveNodeEntry(self, nodeid, index, subindex = None):

   188         if nodeid in self.SlaveNodes.keys():

   189             self.SlaveNodes[nodeid]["Node"].SetNodeID(nodeid)

   190             return self.SlaveNodes[nodeid]["Node"].GetEntry(index, subindex)

   191         else:

   192             return "Node 0x%2.2X doesn't exist"%nodeid

   193 

   194     def GetMasterNodeEntry(self, index, subindex = None):

   195         return self.Manager.GetCurrentEntry(index, subindex)

   196         

   197     def SetMasterNodeEntry(self, index, subindex = None, value = None):

   198         self.Manager.SetCurrentEntry(index, subindex, value)

   199     

   200     def GetOrderNumber(self, nodeid):

   201         nodeindexes = self.SlaveNodes.keys()

   202         nodeindexes.sort()

   203         return nodeindexes.index(nodeid) + 1

   204     

   205     def GetNodeByOrder(self, order):

   206         if order > 0:

   207             nodeindexes = self.SlaveNodes.keys()

   208             nodeindexes.sort()

   209             print nodeindexes

   210             if order <= len(nodeindexes):

   211                 return self.SlaveNodes[nodeindexes[order - 1]]["Node"]

   212         return None

   213     

   214     def IsCurrentEntry(self, index):

   215         if self.CurrentSelected != None:

   216             if self.CurrentSelected == 0:

   217                 return self.Manager.IsCurrentEntry(index)

   218             else:

   219                 node = self.SlaveNodes[self.CurrentSelected]["Node"]

   220                 if node:

   221                     return node.IsEntry(index)

   222         return False

   223     

   224     def GetEntryInfos(self, index):

   225         if self.CurrentSelected != None:

   226             if self.CurrentSelected == 0:

   227                 return self.Manager.GetEntryInfos(index)

   228             else:

   229                 node = self.SlaveNodes[self.CurrentSelected]["Node"]

   230                 if node:

   231                     return node.GetEntryInfos(index)

   232         return None

   233 

   234     def GetCurrentValidIndexes(self, min, max):

   235         if self.CurrentSelected != None:

   236             if self.CurrentSelected == 0:

   237                 return self.Manager.GetCurrentValidIndexes(min, max)

   238             else:

   239                 node = self.SlaveNodes[self.CurrentSelected]["Node"]

   240                 if node:

   241                     validindexes = []

   242                     for index in node.GetIndexes():

   243                         if min <= index <= max:

   244                             validindexes.append((node.GetEntryName(index), index))

   245                     return validindexes

   246                 else:

   247                     print "Can't find node"

   248         return []

   249     

   250     def GetCurrentEntryValues(self, index):

   251         if self.CurrentSelected != None:

   252             node = self.SlaveNodes[self.CurrentSelected]["Node"]

   253             if node:

   254                 return self.Manager.GetNodeEntryValues(node, index)

   255             else:

   256                 print "Can't find node"

   257         return [], []

   258     

   259 if __name__ == "__main__":

   260     from nodemanager import *

   261     import os, sys, shutil

   262     

   263     manager = NodeManager(sys.path[0])

   264     

   265     nodelist = NodeList(manager)

   266     

   267     result = nodelist.LoadProject("/home/laurent/test_nodelist")

   268     if result != None:

   269         print result

   270     else:

   271         print "MasterNode :"

   272         manager.CurrentNode.Print()

   273         print 

   274         for nodeid, node in nodelist.SlaveNodes.items():

   275             print "SlaveNode name=%s id=0x%2.2X :"%(node["Name"], nodeid)

   276             node["Node"].Print()

   277             print

   278