beremiz: comparison plugins/canfestival/canfestival.py

equal deleted inserted replaced

-:d72f3a42f440
+:9d20df7c144a
 from objdictedit import objdictedit
 import canfestival_config as local_canfestival_config
 from plugger import PlugTemplate
 from commondialogs import CreateNodeDialog
 import wx
+from SlaveEditor import SlaveEditor
+from NetworkEditor import NetworkEditor
 from gnosis.xml.pickle import *
 from gnosis.xml.pickle.util import setParanoia
 setParanoia(0)
 </xsd:attribute>
 </xsd:complexType>
 </xsd:element>
 </xsd:schema>
 """ % DEFAULT_SETTINGS
-def GetSlaveODPath(self):
+EditorType = SlaveEditor
-return os.path.join(self.PlugPath(), 'slave.od')
 def __init__(self):
 # TODO change netname when name change
 NodeManager.__init__(self)
 odfilepath = self.GetSlaveODPath()
 "None",       # profile
 "", # prfile filepath
 "heartbeat",  # NMT
 [])           # options
 dialog.Destroy()
-_View = None
+self.OnPlugSave()
+def GetSlaveODPath(self):
+return os.path.join(self.PlugPath(), 'slave.od')
+def GetCanDevice(self):
+return self.CanFestivalSlaveNode.getCan_Device()
 def _OpenView(self):
-if not self._View:
+PlugTemplate._OpenView(self)
-open_objdictedit = True
+if self._View is not None:
-has_permissions = self.GetPlugRoot().CheckProjectPathPerm()
+self._View.SetBusId(self.GetCurrentLocation())
-if not has_permissions:
-dialog = wx.MessageDialog(self.GetPlugRoot().AppFrame,
-_("You don't have write permissions.\nOpen ObjDictEdit anyway ?"),
-_("Open ObjDictEdit"),
-wx.YES_NO|wx.ICON_QUESTION)
-open_objdictedit = dialog.ShowModal() == wx.ID_YES
-dialog.Destroy()
-if open_objdictedit:
-def _onclose():
-self._View = None
-if has_permissions:
-def _onsave():
-self.GetPlugRoot().SaveProject()
-else:
-def _onsave():
-pass
-self._View = objdictedit(self.GetPlugRoot().AppFrame, self)
-# TODO redefine BusId when IEC channel change
-self._View.SetBusId(self.GetCurrentLocation())
-self._View._onclose = _onclose
-self._View._onsave = _onsave
-self._View.Show()
 PluginMethods = [
 {"bitmap" : os.path.join("images", "NetworkEdit"),
 "name" : "Edit slave",
 "tooltip" : "Edit CanOpen slave with ObjdictEdit",
 return self.ChangesToSave or self.OneFileHasChanged()
 def OnPlugSave(self):
 return self.SaveCurrentInFile(self.GetSlaveODPath())
+def SetParamsAttribute(self, path, value):
+result = PlugTemplate.SetParamsAttribute(self, path, value)
+# Filter IEC_Channel and Name, that have specific behavior
+if path == "BaseParams.IEC_Channel" and self._View is not None:
+self._View.SetBusId(self.GetCurrentLocation())
+return result
 def PlugGenerate_C(self, buildpath, locations):
 """
 Generate C code
 @param current_location: Tupple containing plugin IEC location : %I0.0.4.5 => (0,0,4,5)
 @param locations: List of complete variables locations \
 res = eds_utils.GenerateEDSFile(os.path.join(buildpath, "Slave_%s.eds"%prefix), slave)
 if res :
 raise Exception, res
 return [(Gen_OD_path,local_canfestival_config.getCFLAGS(CanFestivalPath))],"",False
+def LoadPrevious(self):
+self.LoadCurrentPrevious()
+def LoadNext(self):
+self.LoadCurrentNext()
+def GetBufferState(self):
+return self.GetCurrentBufferState()
 #--------------------------------------------------
 #                    MASTER
 #--------------------------------------------------
+class MiniNodeManager(NodeManager):
+def __init__(self, parent, filepath, fullname):
+NodeManager.__init__(self)
+self.OpenFileInCurrent(filepath)
+self.Parent = parent
+self.Fullname = fullname
+def OnCloseEditor(self, view):
+self.Parent.OnCloseEditor(view)
+def PlugFullName(self):
+return self.Fullname
+def GetBufferState(self):
+return self.GetCurrentBufferState()
 class _NodeListPlug(NodeList):
 XSD = """<?xml version="1.0" encoding="ISO-8859-1" ?>
 <xsd:schema xmlns:xsd="http://www.w3.org/2001/XMLSchema">
 <xsd:element name="CanFestivalNode">
 <xsd:attribute name="Sync_TPDOs" type="xsd:boolean" use="optional" default="true"/>
 </xsd:complexType>
 </xsd:element>
 </xsd:schema>
 """ % DEFAULT_SETTINGS
+EditorType = NetworkEditor
 def __init__(self):
 manager = NodeManager()
-# TODO change netname when name change
+NodeList.__init__(self, manager)
-NodeList.__init__(self, manager, self.BaseParams.getName())
 self.LoadProject(self.PlugPath())
+self.SetNetworkName(self.BaseParams.getName())
-_View = None
+def GetCanDevice(self):
+return self.CanFestivalNode.getCan_Device()
+def SetParamsAttribute(self, path, value):
+result = PlugTemplate.SetParamsAttribute(self, path, value)
+# Filter IEC_Channel and Name, that have specific behavior
+if path == "BaseParams.IEC_Channel" and self._View is not None:
+self._View.SetBusId(self.GetCurrentLocation())
+elif path == "BaseParams.Name":
+self.SetNetworkName(value)
+return result
 def _OpenView(self):
-if not self._View:
+PlugTemplate._OpenView(self)
-open_networkedit = True
+if self._View is not None:
-has_permissions = self.GetPlugRoot().CheckProjectPathPerm()
+self._View.SetBusId(self.GetCurrentLocation())
-if not has_permissions:
-dialog = wx.MessageDialog(self.GetPlugRoot().AppFrame,
+_GeneratedView = None
-_("You don't have write permissions.\nOpen NetworkEdit anyway ?"),
-_("Open NetworkEdit"),
-wx.YES_NO|wx.ICON_QUESTION)
-open_networkedit = dialog.ShowModal() == wx.ID_YES
-dialog.Destroy()
-if open_networkedit:
-def _onclose():
-self._View = None
-if has_permissions:
-def _onsave():
-self.GetPlugRoot().SaveProject()
-else:
-def _onsave():
-pass
-self._View = networkedit(self.GetPlugRoot().AppFrame, self)
-# TODO redefine BusId when IEC channel change
-self._View.SetBusId(self.GetCurrentLocation())
-self._View._onclose = _onclose
-self._View._onsave = _onsave
-self._View.Show()
 def _ShowMasterGenerated(self):
-buildpath = self._getBuildPath()
+if self._GeneratedView is None:
-# Eventually create build dir
+buildpath = self._getBuildPath()
-if not os.path.exists(buildpath):
+# Eventually create build dir
-self.GetPlugRoot().logger.write_error(_("Error: No PLC built\n"))
+if not os.path.exists(buildpath):
-return
+self.GetPlugRoot().logger.write_error(_("Error: No PLC built\n"))
+return
-masterpath = os.path.join(buildpath, "MasterGenerated.od")
-if not os.path.exists(masterpath):
+masterpath = os.path.join(buildpath, "MasterGenerated.od")
-self.GetPlugRoot().logger.write_error(_("Error: No Master generated\n"))
+if not os.path.exists(masterpath):
-return
+self.GetPlugRoot().logger.write_error(_("Error: No Master generated\n"))
+return
-new_dialog = objdictedit(None, filesOpen=[masterpath])
-new_dialog.Show()
+app_frame = self.GetPlugRoot().AppFrame
+manager = MiniNodeManager(self, masterpath, self.PlugFullName() + ".generated_master")
+self._GeneratedView = SlaveEditor(app_frame.TabsOpened, manager, app_frame, False)
+app_frame.EditProjectElement(self._GeneratedView, "MasterGenerated")
+def _CloseGenerateView(self):
+if self._GeneratedView is not None:
+app_frame = self.GetPlugRoot().AppFrame
+if app_frame is not None:
+app_frame.DeletePage(self._GeneratedView)
 PluginMethods = [
 {"bitmap" : os.path.join("images", "NetworkEdit"),
 "name" : _("Edit network"),
 "tooltip" : _("Edit CanOpen Network with NetworkEdit"),
 "method" : "_OpenView"},
 {"bitmap" : os.path.join("images", "ShowMaster"),
 "name" : _("Show Master"),
 "tooltip" : _("Show Master generated by config_utils"),
 "method" : "_ShowMasterGenerated"}
 ]
+def OnCloseEditor(self, view):
+PlugTemplate.OnCloseEditor(self, view)
+if self._GeneratedView == view:
+self._GeneratedView = None
 def OnPlugClose(self):
-if self._View:
+PlugTemplate.OnPlugClose(self)
-self._View.Close()
+self._CloseGenerateView()
+return True
 def PlugTestModified(self):
 return self.ChangesToSave or self.HasChanged()
 def OnPlugSave(self):
 "SIZE" : size "X", "B", "W", "D", "L"
 "LOC" : tuple of interger for IEC location (0,1,2,...)
 }, ...]
 @return: [(C_file_name, CFLAGS),...] , LDFLAGS_TO_APPEND
 """
+self._CloseGenerateView()
 current_location = self.GetCurrentLocation()
 # define a unique name for the generated C file
 prefix = "_".join(map(str, current_location))
 Gen_OD_path = os.path.join(buildpath, "OD_%s.c"%prefix )
 # Create a new copy of the model with DCF loaded with PDO mappings for desired location
 dump(master, file)
 file.close()
 return [(Gen_OD_path,local_canfestival_config.getCFLAGS(CanFestivalPath))],"",False
+def LoadPrevious(self):
+self.Manager.LoadCurrentPrevious()
+def LoadNext(self):
+self.Manager.LoadCurrentNext()
+def GetBufferState(self):
+return self.Manager.GetCurrentBufferState()
 class RootClass:
 XSD = """<?xml version="1.0" encoding="ISO-8859-1" ?>
 <xsd:schema xmlns:xsd="http://www.w3.org/2001/XMLSchema">
 <xsd:element name="CanFestivalInstance">
 <xsd:complexType>
 if element["name"] == "CanFestivalInstance":
 for child in element["children"]:
 if child["name"] == "CAN_Driver":
 DLL_LIST= getattr(local_canfestival_config,"DLL_LIST",None)
 if DLL_LIST is not None:
 child["type"] = DLL_LIST
-return infos
 return infos
+def GetCanDriver(self):
+can_driver = self.CanFestivalInstance.getCAN_Driver()
+if sys.platform == 'win32':
+if self.CanFestivalInstance.getDebug_mode() and os.path.isfile(os.path.join("%s"%(can_driver + '_DEBUG.dll'))):
+can_driver += '_DEBUG.dll'
+else:
+can_driver += '.dll'
+return can_driver
 def PlugGenerate_C(self, buildpath, locations):
 format_dict = {"locstr" : "_".join(map(str,self.GetCurrentLocation())),
-"candriver" : self.CanFestivalInstance.getCAN_Driver(),
+"candriver" : self.GetCanDriver(),
 "nodes_includes" : "",
 "board_decls" : "",
 "nodes_init" : "",
 "nodes_open" : "",
 "nodes_stop" : "",
 format_dict["nodes_send_sync"] += 'NODE_SEND_SYNC(%s)\n    '%(nodename)
 format_dict["nodes_proceed_sync"] += 'NODE_PROCEED_SYNC(%s)\n    '%(nodename)
 # initialize and declare node boot status variables for post_SlaveBootup lookup
 SlaveIDs = child.GetSlaveIDs()
-for id in SlaveIDs:
+if len(SlaveIDs) == 0:
+# define post_SlaveBootup lookup functions
 format_dict["slavebootups"] += (
-"int %s_slave_%d_booted = 0;\n"%(nodename, id))
+"static void %s_post_SlaveBootup(CO_Data* d, UNS8 nodeId){}\n"%(nodename))
-# define post_SlaveBootup lookup functions
+else:
-format_dict["slavebootups"] += (
+for id in SlaveIDs:
-"static void %s_post_SlaveBootup(CO_Data* d, UNS8 nodeId){\n"%(nodename)+
+format_dict["slavebootups"] += (
-"    switch(nodeId){\n")
+"int %s_slave_%d_booted = 0;\n"%(nodename, id))
-# one case per declared node, mark node as booted
+# define post_SlaveBootup lookup functions
-for id in SlaveIDs:
 format_dict["slavebootups"] += (
-"        case %d:\n"%(id)+
+"static void %s_post_SlaveBootup(CO_Data* d, UNS8 nodeId){\n"%(nodename)+
-"            %s_slave_%d_booted = 1;\n"%(nodename, id)+
+"    switch(nodeId){\n")
-"            break;\n")
+# one case per declared node, mark node as booted
-format_dict["slavebootups"] += (
+for id in SlaveIDs:
-"        default:\n"+
+format_dict["slavebootups"] += (
-"            break;\n"+
+"        case %d:\n"%(id)+
-"    }\n"+
+"            %s_slave_%d_booted = 1;\n"%(nodename, id)+
-"    if( ")
+"            break;\n")
-# expression to test if all declared nodes booted
+format_dict["slavebootups"] += (
-format_dict["slavebootups"] += " && ".join(["%s_slave_%d_booted"%(nodename, id) for id in SlaveIDs])
+"        default:\n"+
-format_dict["slavebootups"] += " )\n" + (
+"            break;\n"+
-"        Master_post_SlaveBootup(d,nodeId);\n"+
+"    }\n"+
-"}\n")
+"    if( ")
+# expression to test if all declared nodes booted
+format_dict["slavebootups"] += " && ".join(["%s_slave_%d_booted"%(nodename, id) for id in SlaveIDs])
+format_dict["slavebootups"] += " )\n" + (
+"        Master_post_SlaveBootup(d,nodeId);\n"+
+"}\n")
 # register previously declared func as post_SlaveBootup callback for that node
 format_dict["slavebootup_register"] += (
 "%s_Data.post_SlaveBootup = %s_post_SlaveBootup;\n"%(nodename,nodename))
 else:
 # Slave node
 # Include generated OD headers
 format_dict["nodes_includes"] += '#include "%s.h"\n'%(nodename)
 # Declare CAN channels according user filled config
 format_dict["board_decls"] += 'BOARD_DECL(%s, "%s", "%s")\n'%(
 nodename,
-child_data.getCAN_Device(),
+child.GetCanDevice(),
 child_data.getCAN_Baudrate())
 format_dict["nodes_open"] += 'NODE_OPEN(%s)\n    '%(nodename)
 format_dict["nodes_close"] += 'NODE_CLOSE(%s)\n    '%(nodename)
 format_dict["nodes_stop"] += 'NODE_STOP(%s)\n    '%(nodename)
-if sys.platform == 'win32':
-if self.CanFestivalInstance.getDebug_mode() and os.path.isfile(os.path.join("%s"%(format_dict["candriver"] + '_DEBUG.dll'))):
-format_dict["candriver"] += '_DEBUG.dll'
-else:
-format_dict["candriver"] += '.dll'
 filename = os.path.join(os.path.split(__file__)[0],"cf_runtime.c")
 cf_main = open(filename).read() % format_dict
 cf_main_path = os.path.join(buildpath, "CF_%(locstr)s.c"%format_dict)
 f = open(cf_main_path,'w')

changeset 682	9d20df7c144a
parent 512	36aeab46f27d
child 684	d376a8b0b602