beremiz: comparison ProjectController.py

equal deleted inserted replaced

-:c8e008b8cefe
+:72a826dfcfbb
 from util.ProcessLogger import ProcessLogger
 from util.BitmapLibrary import GetBitmap
 from editors.FileManagementPanel import FileManagementPanel
 from editors.ProjectNodeEditor import ProjectNodeEditor
 from editors.IECCodeViewer import IECCodeViewer
-from graphics import DebugViewer
+from editors.DebugViewer import DebugViewer
 from dialogs import DiscoveryDialog
 from PLCControler import PLCControler
 from plcopen.structures import IEC_KEYWORDS
 from targets.typemapping import DebugTypesSize, LogLevelsCount, LogLevels
 from ConfigTreeNode import ConfigTreeNode
 def __init__(self, frame, logger):
 PLCControler.__init__(self)
 self.MandatoryParams = None
-self.SetAppFrame(frame, logger)
 self._builder = None
 self._connector = None
+self.SetAppFrame(frame, logger)
 self.iec2c_path = os.path.join(base_folder, "matiec", "iec2c"+(".exe" if wx.Platform == '__WXMSW__' else ""))
 self.ieclib_path = os.path.join(base_folder, "matiec", "lib")
 # Setup debug information
 self.ProjectPath = None
 self._setBuildPath(None)
 self.DebugThread = None
 self.debug_break = False
 self.previous_plcstate = None
-self.previous_log_count = [None]*LogLevelsCount
 # copy ConfNodeMethods so that it can be later customized
 self.StatusMethods = [dic.copy() for dic in self.StatusMethods]
 def LoadLibraries(self):
 self.Libraries = []
 self.AppFrame = frame
 self.logger = logger
 self.StatusTimer = None
 if frame is not None:
+frame.LogViewer.SetLogSource(self._connector)
 # Timer to pull PLC status
 ID_STATUSTIMER = wx.NewId()
 self.StatusTimer = wx.Timer(self.AppFrame, ID_STATUSTIMER)
 self.AppFrame.Bind(wx.EVT_TIMER, self.PullPLCStatusProc, self.StatusTimer)
 return params
 def SetParamsAttribute(self, path, value):
 if path.startswith("BeremizRoot.TargetType.") and self.BeremizRoot.getTargetType().getcontent() is None:
 self.BeremizRoot.setTargetType(self.GetTarget())
-return ConfigTreeNode.SetParamsAttribute(self, path, value)
+res = ConfigTreeNode.SetParamsAttribute(self, path, value)
+if path.startswith("BeremizRoot.Libraries."):
+wx.CallAfter(self.RefreshConfNodesBlockLists)
+return res
 # helper func to check project path write permission
 def CheckProjectPathPerm(self, dosave=True):
 if CheckPathPerm(self.ProjectPath):
 return True
-dialog = wx.MessageDialog(self.AppFrame,
+if self.AppFrame is not None:
-_('You must have permission to work on the project\nWork on a project copy ?'),
+dialog = wx.MessageDialog(self.AppFrame,
-_('Error'),
+_('You must have permission to work on the project\nWork on a project copy ?'),
-wx.YES_NO | wx.NO_DEFAULT | wx.ICON_QUESTION)
+_('Error'),
-answer = dialog.ShowModal()
+wx.YES_NO | wx.NO_DEFAULT | wx.ICON_QUESTION)
-dialog.Destroy()
+answer = dialog.ShowModal()
-if answer == wx.ID_YES:
+dialog.Destroy()
-if self.SaveProjectAs():
+if answer == wx.ID_YES:
-self.AppFrame.RefreshTitle()
+if self.SaveProjectAs():
-self.AppFrame.RefreshFileMenu()
+self.AppFrame.RefreshTitle()
-self.AppFrame.RefreshPageTitles()
+self.AppFrame.RefreshFileMenu()
-return True
+self.AppFrame.RefreshPageTitles()
+return True
 return False
-def _getProjectFilesPath(self):
+def _getProjectFilesPath(self, project_path=None):
+if project_path is not None:
+return os.path.join(project_path, "project_files")
 projectfiles_path = os.path.join(self.GetProjectPath(), "project_files")
 if not os.path.exists(projectfiles_path):
 os.mkdir(projectfiles_path)
 return projectfiles_path
 Load a project contained in a folder
 @param ProjectPath: path of the project folder
 """
 if os.path.basename(ProjectPath) == "":
 ProjectPath = os.path.dirname(ProjectPath)
-		# Verify that project contains a PLCOpen program
+# Verify that project contains a PLCOpen program
 plc_file = os.path.join(ProjectPath, "plc.xml")
 if not os.path.isfile(plc_file):
 return _("Chosen folder doesn't contain a program. It's not a valid project!")
 # Load PLCOpen file
 result = self.OpenXMLFile(plc_file)
 self.RefreshConfNodesBlockLists()
 if os.path.exists(self._getBuildPath()):
 self.EnableMethod("_Clean", True)
-if os.path.isfile(self._getIECrawcodepath()):
+if os.path.isfile(self._getIECcodepath()):
 self.ShowMethod("_showIECcode", True)
+self.UpdateMethodsFromPLCStatus()
 return None
 def RecursiveConfNodeInfos(self, confnode):
 values = []
 for CTNChild in confnode.IECSortedChildren():
 values.append(
 {"name": "%s: %s" % (CTNChild.GetFullIEC_Channel(),
 CTNChild.CTNName()),
+"tagname": CTNChild.CTNFullName(),
 "type": ITEM_CONFNODE,
 "confnode": CTNChild,
 "icon": CTNChild.GetIconName(),
 "values": self.RecursiveConfNodeInfos(CTNChild)})
 return values
 def CloseProject(self):
 self.ClearChildren()
 self.ResetAppFrame(None)
-def SaveProject(self):
+def SaveProject(self, from_project_path=None):
 if self.CheckProjectPathPerm(False):
+if from_project_path is not None:
+old_projectfiles_path = self._getProjectFilesPath(from_project_path)
+if os.path.isdir(old_projectfiles_path):
+shutil.copytree(old_projectfiles_path,
+self._getProjectFilesPath(self.ProjectPath))
 self.SaveXMLFile(os.path.join(self.ProjectPath, 'plc.xml'))
-result = self.CTNRequestSave()
+result = self.CTNRequestSave(from_project_path)
 if result:
 self.logger.write_error(result)
-def SaveProjectAs(self, dosave=True):
+def SaveProjectAs(self):
 # Ask user to choose a path with write permissions
 if wx.Platform == '__WXMSW__':
 path = os.getenv("USERPROFILE")
 else:
 path = os.getenv("HOME")
 answer = dirdialog.ShowModal()
 dirdialog.Destroy()
 if answer == wx.ID_OK:
 newprojectpath = dirdialog.GetPath()
 if os.path.isdir(newprojectpath):
-self.ProjectPath = newprojectpath
+self.ProjectPath, old_project_path = newprojectpath, self.ProjectPath
-if dosave:
+self.SaveProject(old_project_path)
-self.SaveProject()
 self._setBuildPath(self.BuildPath)
 return True
 return False
 def GetLibrariesTypes(self):
 if not C_files:
 self.logger.write_error(_("Error : At least one configuration and one resource must be declared in PLC !\n"))
 return False
 # transform those base names to full names with path
 C_files = map(lambda filename:os.path.join(buildpath, filename), C_files)
+# prepend beremiz include to configuration header
+H_files = [ fname for fname in result.splitlines() if fname[-2:]==".h" or fname[-2:]==".H" ]
+H_files.remove("LOCATED_VARIABLES.h")
+H_files = map(lambda filename:os.path.join(buildpath, filename), H_files)
+for H_file in H_files:
+with file(H_file, 'r') as original: data = original.read()
+with file(H_file, 'w') as modified: modified.write('#include "beremiz.h"\n' + data)
 self.logger.write(_("Extracting Located Variables...\n"))
 # Keep track of generated located variables for later use by self._Generate_C
 self.PLCGeneratedLocatedVars = self.GetLocations()
 # Keep track of generated C files for later use by self.CTNGenerate_C
 self.PLCGeneratedCFiles = C_files
 "VAR":"        return %(type)s_ENUM;\n"}[v["vartype"]]%v
 for v in self._VariablesList if v["vartype"] != "FB" and v["type"] in DebugTypesSize ])}
 return debug_code
-def Generate_plc_common_main(self):
+def Generate_plc_main(self):
 """
 Use confnodes layout given in LocationCFilesAndCFLAGS to
 generate glue code that dispatch calls to all confnodes
 """
 # filter location that are related to code that will be called
 # in retreive, publish, init, cleanup
 locstrs = map(lambda x:"_".join(map(str,x)),
 [loc for loc,Cfiles,DoCalls in self.LocationCFilesAndCFLAGS if loc and DoCalls])
 # Generate main, based on template
 if not self.BeremizRoot.getDisable_Extensions():
-plc_main_code = targets.GetCode("plc_common_main") % {
+plc_main_code = targets.GetCode("plc_main_head") % {
 "calls_prototypes":"\n".join([(
 "int __init_%(s)s(int argc,char **argv);\n"+
 "void __cleanup_%(s)s(void);\n"+
 "void __retrieve_%(s)s(void);\n"+
 "void __publish_%(s)s(void);")%{'s':locstr} for locstr in locstrs]),
 "retrieve_calls":"\n    ".join([
-"__retrieve_%s();"%locstrs[i-1] for i in xrange(len(locstrs), 0, -1)]),
+"__retrieve_%s();"%locstr for locstr in locstrs]),
 "publish_calls":"\n    ".join([ #Call publish in reverse order
-"__publish_%s();"%locstr for locstr in locstrs]),
+"__publish_%s();"%locstrs[i-1] for i in xrange(len(locstrs), 0, -1)]),
 "init_calls":"\n    ".join([
 "init_level=%d; "%(i+1)+
 "if((res = __init_%s(argc,argv))){"%locstr +
 #"printf(\"%s\"); "%locstr + #for debug
 "return res;}" for i,locstr in enumerate(locstrs)]),
 "cleanup_calls":"\n    ".join([
 "if(init_level >= %d) "%i+
 "__cleanup_%s();"%locstrs[i-1] for i in xrange(len(locstrs), 0, -1)])
 }
 else:
-plc_main_code = targets.GetCode("plc_common_main") % {
+plc_main_code = targets.GetCode("plc_main_head") % {
 "calls_prototypes":"\n",
 "retrieve_calls":"\n",
 "publish_calls":"\n",
 "init_calls":"\n",
 "cleanup_calls":"\n"
 }
 plc_main_code += targets.GetTargetCode(self.GetTarget().getcontent()["name"])
+plc_main_code += targets.GetCode("plc_main_tail")
 return plc_main_code
 def _Build(self):
 """
 fpath = os.path.join(extrafilespath,fname)
 open(fpath, "wb").write(fobject.read())
 # Now we can forget ExtraFiles (will close files object)
 del ExtraFiles
+# Header file for extensions
+open(os.path.join(buildpath,"beremiz.h"), "w").write(targets.GetHeader())
 # Template based part of C code generation
 # files are stacked at the beginning, as files of confnode tree root
 for generator, filename, name in [
 # debugger code
 (self.Generate_plc_debugger, "plc_debugger.c", "Debugger"),
 # init/cleanup/retrieve/publish, run and align code
-(self.Generate_plc_common_main,"plc_common_main.c","Common runtime")]:
+(self.Generate_plc_main,"plc_main.c","Common runtime")]:
 try:
 # Do generate
 code = generator()
 if code is None:
 raise
 def _OpenView(self, name=None, onlyopened=False):
 if name == "IEC code":
 if self._IECCodeView is None:
 plc_file = self._getIECcodepath()
-self._IECCodeView = IECCodeViewer(self.AppFrame.TabsOpened, "", None, None, instancepath=name)
+self._IECCodeView = IECCodeViewer(self.AppFrame.TabsOpened, "", self.AppFrame, None, instancepath=name)
 self._IECCodeView.SetTextSyntax("ALL")
 self._IECCodeView.SetKeywords(IEC_KEYWORDS)
 try:
 text = file(plc_file).read()
 except:
 elif name == "IEC raw code":
 if self._IECRawCodeView is None:
 controler = MiniTextControler(self._getIECrawcodepath(), self)
-self._IECRawCodeView = IECCodeViewer(self.AppFrame.TabsOpened, "", None, controler, instancepath=name)
+self._IECRawCodeView = IECCodeViewer(self.AppFrame.TabsOpened, "", self.AppFrame, controler, instancepath=name)
 self._IECRawCodeView.SetTextSyntax("ALL")
 self._IECRawCodeView.SetKeywords(IEC_KEYWORDS)
 self._IECRawCodeView.RefreshView()
 self._IECRawCodeView.SetIcon(GetBitmap("ST"))
 setattr(self._IECRawCodeView, "_OnClose", self.OnCloseEditor)
 # kill the builder
 self._builder = None
 self.CompareLocalAndRemotePLC()
 def UpdatePLCLog(self, log_count):
-if log_count :
+if log_count:
-to_console = []
+if self.AppFrame is not None:
-for level, count, prev in zip(xrange(LogLevelsCount), log_count,self.previous_log_count):
+self.AppFrame.LogViewer.SetLogCounters(log_count)
-if count is not None and prev != count:
-# XXX replace dump to console with dedicated log panel.
-dump_end = max( # request message sent after the last one we already got
-prev - 1 if prev is not None else -1,
-count - 100) # 100 is purely arbitrary number
-# dedicated panel should only ask for a small range,
-# depending on how user navigate in the panel
-# and only ask for last one in follow mode
-for msgidx in xrange(count-1, dump_end,-1):
-answer = self._connector.GetLogMessage(level, msgidx)
-if answer is not None :
-msg, tick, tv_sec, tv_nsec = answer
-to_console.insert(0,(
-(tv_sec, tv_nsec),
-'%d|%s.%9.9d|%s(%s)'%(
-int(tick),
-str(datetime.fromtimestamp(tv_sec)),
-tv_nsec,
-msg,
-LogLevels[level])))
-else:
-break;
-self.previous_log_count[level] = count
-if to_console:
-to_console.sort()
-self.logger.write("\n".join(zip(*to_console)[1]+('',)))
 def UpdateMethodsFromPLCStatus(self):
 status = None
 if self._connector is not None:
 PLCstatus = self._connector.GetPLCstatus()
 if PLCstatus is not None:
 status, log_count = PLCstatus
 self.UpdatePLCLog(log_count)
 if status is None:
-self._connector = None
+self._SetConnector(None, False)
 status = "Disconnected"
 if(self.previous_plcstate != status):
 for args in {
 "Started" :     [("_Run", False),
 ("_Stop", True)],
 ("_Transfer", False),
 ("_Connect", True),
 ("_Disconnect", False)],
 }.get(status,[]):
 self.ShowMethod(*args)
-{"Broken": self.logger.write_error,
-None: lambda x: None}.get(
-status, self.logger.write)(_("PLC state is \"%s\"\n")%_(status))
 self.previous_plcstate = status
 if self.AppFrame is not None:
 self.AppFrame.RefreshStatusToolBar()
+if status == "Disconnected":
+self.AppFrame.ConnectionStatusBar.SetStatusText(_(status), 1)
+self.AppFrame.ConnectionStatusBar.SetStatusText('', 2)
+else:
+self.AppFrame.ConnectionStatusBar.SetStatusText(
+_("Connected to URI: %s") % self.BeremizRoot.getURI_location().strip(), 1)
+self.AppFrame.ConnectionStatusBar.SetStatusText(_(status), 2)
 def PullPLCStatusProc(self, event):
-if self._connector is None:
-self.StatusTimer.Stop()
 self.UpdateMethodsFromPLCStatus()
 def RegisterDebugVarToConnector(self):
 self.DebugTimer=None
 Idxs = []
 self._connector.SetTraceVariablesList(zip(*zip(*Idxs)[0:3]))
 else:
 self.TracedIECPath = []
 self._connector.SetTraceVariablesList([])
 self.IECdebug_lock.release()
+def IsPLCStarted(self):
+return self.previous_plcstate == "Started"
 def ReArmDebugRegisterTimer(self):
 if self.DebugTimer is not None:
 self.DebugTimer.cancel()
-# Timer to prevent rapid-fire when registering many variables
+# Prevent to call RegisterDebugVarToConnector when PLC is not started
-# use wx.CallAfter use keep using same thread. TODO : use wx.Timer instead
+# If an output location var is forced it's leads to segmentation fault in runtime
-self.DebugTimer=Timer(0.5,wx.CallAfter,args = [self.RegisterDebugVarToConnector])
+# Links between PLC located variables and real variables are not ready
-# Rearm anti-rapid-fire timer
+if self.IsPLCStarted():
-self.DebugTimer.start()
+# Timer to prevent rapid-fire when registering many variables
+# use wx.CallAfter use keep using same thread. TODO : use wx.Timer instead
+self.DebugTimer=Timer(0.5,wx.CallAfter,args = [self.RegisterDebugVarToConnector])
+# Rearm anti-rapid-fire timer
+self.DebugTimer.start()
 def GetDebugIECVariableType(self, IECPath):
 Idx, IEC_Type = self._IECPathToIdx.get(IECPath,(None,None))
 return IEC_Type
 def UnsubscribeDebugIECVariable(self, IECPath, callableobj):
 self.IECdebug_lock.acquire()
 IECdebug_data = self.IECdebug_datas.get(IECPath, None)
 if IECdebug_data is not None:
 IECdebug_data[0].pop(callableobj,None)
+if len(IECdebug_data[0]) == 0:
+self.IECdebug_datas.pop(IECPath)
 self.IECdebug_lock.release()
 self.ReArmDebugRegisterTimer()
 def UnsubscribeAllDebugIECVariable(self):
 self.IECdebug_lock.acquire()
-IECdebug_data = {}
+self.IECdebug_datas = {}
 self.IECdebug_lock.release()
 self.ReArmDebugRegisterTimer()
 def ForceDebugIECVariable(self, IECPath, fvalue):
 if(Trace):
 plc_status, debug_tick, debug_vars = Trace
 else:
 plc_status = None
 debug_getvar_retry += 1
+#print [dict.keys() for IECPath, (dict, log, status, fvalue) in self.IECdebug_datas.items()]
 if plc_status == "Started":
 self.IECdebug_lock.acquire()
 if len(debug_vars) == len(self.TracedIECPath):
 if debug_getvar_retry > DEBUG_RETRIES_WARN:
 self.logger.write(_("... debugger recovered\n"))
 self.logger.write(_("Debugger stopped.\n"))
 self.DebugThread = None
 def _connect_debug(self):
 self.previous_plcstate = None
-self.previous_log_count = [None]*LogLevelsCount
 if self.AppFrame:
 self.AppFrame.ResetGraphicViewers()
 self.RegisterDebugVarToConnector()
 if self.DebugThread is None:
 self.DebugThread = Thread(target=self.DebugThreadProc)
 # debugthread should die on his own
 #self.KillDebugThread()
 wx.CallAfter(self.UpdateMethodsFromPLCStatus)
+def _SetConnector(self, connector, update_status=True):
+self._connector = connector
+if self.AppFrame is not None:
+self.AppFrame.LogViewer.SetLogSource(connector)
+if connector is not None:
+# Start the status Timer
+self.StatusTimer.Start(milliseconds=500, oneShot=False)
+else:
+# Stop the status Timer
+self.StatusTimer.Stop()
+if update_status:
+wx.CallAfter(self.UpdateMethodsFromPLCStatus)
 def _Connect(self):
 # don't accept re-connetion if already connected
 if self._connector is not None:
 self.logger.write_error(_("Already connected. Please disconnect\n"))
 self.AppFrame.RefreshEditMenu()
 self.AppFrame.RefreshPageTitles()
 # Get connector from uri
 try:
-self._connector = connectors.ConnectorFactory(uri, self)
+self._SetConnector(connectors.ConnectorFactory(uri, self))
 except Exception, msg:
 self.logger.write_error(_("Exception while connecting %s!\n")%uri)
 self.logger.write_error(traceback.format_exc())
 # Did connection success ?
 status = _(self.previous_plcstate)
 else:
 status = ""
 #self.logger.write(_("PLC is %s\n")%status)
-# Start the status Timer
-self.StatusTimer.Start(milliseconds=500, oneShot=False)
 if self.previous_plcstate in ["Started","Stopped"]:
 if self.DebugAvailable() and self.GetIECProgramsAndVariables():
 self.logger.write(_("Debugger ready\n"))
 self._connect_debug()
 #                _("Cannot compare latest build to target. Please build.\n"))
 self.EnableMethod("_Transfer", False)
 def _Disconnect(self):
-self._connector = None
+self._SetConnector(None)
-self.StatusTimer.Stop()
-wx.CallAfter(self.UpdateMethodsFromPLCStatus)
 def _Transfer(self):
 # Get the last build PLC's
 MD5 = self.GetLastBuildMD5()
 self.logger.write(_("Transfer completed successfully.\n"))
 else:
 self.logger.write_error(_("Transfer failed\n"))
 else:
 self.logger.write_error(_("No PLC to transfer (did build succeed ?)\n"))
-self.previous_log_count = [None]*LogLevelsCount
 wx.CallAfter(self.UpdateMethodsFromPLCStatus)
 StatusMethods = [
 {"bitmap" : "Build",

branch	1.1 Korean release
changeset 1280	72a826dfcfbb
parent 1262	7b9259945453
child 1282	f427352f9727