beremiz: comparison ProjectController.py

equal deleted inserted replaced

-:1fdc32be71b8
+:691d119ba20f
 self.DebugTicks = []
 self.SetAppFrame(frame, logger)
 # Setup debug information
 self.IECdebug_datas = {}
-self.IECdebug_lock = Lock()
 self.DebugTimer = None
 self.ResetIECProgramsAndVariables()
 # In both new or load scenario, no need to save
 self.Children = {}
 self._View = None
 # After __init__ root confnode is not valid
 self.ProjectPath = None
 self._setBuildPath(None)
-self.DebugThread = None
 self.debug_break = False
 self.previous_plcstate = None
 # copy ConfNodeMethods so that it can be later customized
 self.StatusMethods = [dic.copy() for dic in self.StatusMethods]
 def PullPLCStatusProc(self, event):
 self.UpdateMethodsFromPLCStatus()
 def SnapshotAndResetDebugValuesBuffers(self):
+plc_status, Traces = self._connector.GetTraceVariables()
+# print [dict.keys() for IECPath, (dict, log, status, fvalue) in self.IECdebug_datas.items()]
+if plc_status == "Started":
+if len(Traces) > 0:
+for debug_tick, debug_buff in Traces:
+debug_vars = UnpackDebugBuffer(debug_buff, self.TracedIECTypes)
+if debug_vars is not None and len(debug_vars) == len(self.TracedIECPath):
+for IECPath, values_buffer, value in izip(
+self.TracedIECPath,
+self.DebugValuesBuffers,
+debug_vars):
+IECdebug_data = self.IECdebug_datas.get(IECPath, None)
+if IECdebug_data is not None and value is not None:
+forced = IECdebug_data[2:4] == ["Forced", value]
+if not IECdebug_data[4] and len(values_buffer) > 0:
+values_buffer[-1] = (value, forced)
+else:
+values_buffer.append((value, forced))
+self.DebugTicks.append(debug_tick)
 buffers, self.DebugValuesBuffers = (self.DebugValuesBuffers,
 [list() for dummy in xrange(len(self.TracedIECPath))])
 ticks, self.DebugTicks = self.DebugTicks, []
 return ticks, buffers
 def RegisterDebugVarToConnector(self):
 self.DebugTimer = None
 Idxs = []
 self.TracedIECPath = []
 self.TracedIECTypes = []
 if self._connector is not None:
-self.IECdebug_lock.acquire()
 IECPathsToPop = []
 for IECPath, data_tuple in self.IECdebug_datas.iteritems():
 WeakCallableDict, _data_log, _status, fvalue, _buffer_list = data_tuple
 if len(WeakCallableDict) == 0:
 # Callable Dict is empty.
 self._connector.SetTraceVariablesList(zip(*IdxsT[0:3]))
 else:
 self.TracedIECPath = []
 self._connector.SetTraceVariablesList([])
 self.SnapshotAndResetDebugValuesBuffers()
-self.IECdebug_lock.release()
 def IsPLCStarted(self):
 return self.previous_plcstate == "Started"
 def ReArmDebugRegisterTimer(self):
 weakly referenced callables
 """
 if IECPath != "__tick__" and IECPath not in self._IECPathToIdx:
 return None
-self.IECdebug_lock.acquire()
 # If no entry exist, create a new one with a fresh WeakKeyDictionary
 IECdebug_data = self.IECdebug_datas.get(IECPath, None)
 if IECdebug_data is None:
 IECdebug_data = [
 WeakKeyDictionary(),  # Callables
 else:
 IECdebug_data[4] |= buffer_list
 IECdebug_data[0][callableobj] = buffer_list
-self.IECdebug_lock.release()
 self.ReArmDebugRegisterTimer()
 return IECdebug_data[1]
 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)
 else:
 IECdebug_data[4] = reduce(
 lambda x, y: x | y,
 IECdebug_data[0].itervalues(),
 False)
-self.IECdebug_lock.release()
 self.ReArmDebugRegisterTimer()
 def UnsubscribeAllDebugIECVariable(self):
-self.IECdebug_lock.acquire()
 self.IECdebug_datas = {}
-self.IECdebug_lock.release()
 self.ReArmDebugRegisterTimer()
 def ForceDebugIECVariable(self, IECPath, fvalue):
 if IECPath not in self.IECdebug_datas:
 return
-self.IECdebug_lock.acquire()
 # If no entry exist, create a new one with a fresh WeakKeyDictionary
 IECdebug_data = self.IECdebug_datas.get(IECPath, None)
 IECdebug_data[2] = "Forced"
 IECdebug_data[3] = fvalue
-self.IECdebug_lock.release()
 self.ReArmDebugRegisterTimer()
 def ReleaseDebugIECVariable(self, IECPath):
 if IECPath not in self.IECdebug_datas:
 return
-self.IECdebug_lock.acquire()
 # If no entry exist, create a new one with a fresh WeakKeyDictionary
 IECdebug_data = self.IECdebug_datas.get(IECPath, None)
 IECdebug_data[2] = "Registered"
 IECdebug_data[3] = None
-self.IECdebug_lock.release()
 self.ReArmDebugRegisterTimer()
 def CallWeakcallables(self, IECPath, function_name, *cargs):
 data_tuple = self.IECdebug_datas.get(IECPath, None)
 def RemoteExec(self, script, **kwargs):
 if self._connector is None:
 return -1, "No runtime connected!"
 return self._connector.RemoteExec(script, **kwargs)
-def DebugThreadProc(self):
-"""
-This thread waid PLC debug data, and dispatch them to subscribers
-"""
-self.debug_break = False
-debug_getvar_retry = 0
-while (not self.debug_break) and (self._connector is not None):
-plc_status, Traces = self._connector.GetTraceVariables()
-debug_getvar_retry += 1
-# print [dict.keys() for IECPath, (dict, log, status, fvalue) in self.IECdebug_datas.items()]
-if plc_status == "Started":
-if len(Traces) > 0:
-self.IECdebug_lock.acquire()
-for debug_tick, debug_buff in Traces:
-debug_vars = UnpackDebugBuffer(debug_buff, self.TracedIECTypes)
-if debug_vars is not None and len(debug_vars) == len(self.TracedIECPath):
-for IECPath, values_buffer, value in izip(
-self.TracedIECPath,
-self.DebugValuesBuffers,
-debug_vars):
-IECdebug_data = self.IECdebug_datas.get(IECPath, None)  # FIXME get
-if IECdebug_data is not None and value is not None:
-forced = IECdebug_data[2:4] == ["Forced", value]
-if not IECdebug_data[4] and len(values_buffer) > 0:
-values_buffer[-1] = (value, forced)
-else:
-values_buffer.append((value, forced))
-self.DebugTicks.append(debug_tick)
-debug_getvar_retry = 0
-self.IECdebug_lock.release()
-if debug_getvar_retry != 0:
-# Be patient, tollerate PLC to come with fresh samples
-time.sleep(0.1)
-else:
-self.debug_break = True
-self.logger.write(_("Debugger disabled\n"))
-self.DebugThread = None
-if self.DispatchDebugValuesTimer is not None:
-self.DispatchDebugValuesTimer.Stop()
 def DispatchDebugValuesProc(self, event):
-self.IECdebug_lock.acquire()
 debug_ticks, buffers = self.SnapshotAndResetDebugValuesBuffers()
-self.IECdebug_lock.release()
 start_time = time.time()
 if len(self.TracedIECPath) == len(buffers):
 for IECPath, values in izip(self.TracedIECPath, buffers):
 if len(values) > 0:
 self.CallWeakcallables(IECPath, "NewValues", debug_ticks, values)
 if len(debug_ticks) > 0:
 self.CallWeakcallables("__tick__", "NewDataAvailable", debug_ticks)
 delay = time.time() - start_time
 next_refresh = max(REFRESH_PERIOD - delay, 0.2 * delay)
-if self.DispatchDebugValuesTimer is not None and self.DebugThread is not None:
+if self.DispatchDebugValuesTimer is not None:
 self.DispatchDebugValuesTimer.Start(
 int(next_refresh * 1000), oneShot=True)
 event.Skip()
 def KillDebugThread(self):
-tmp_debugthread = self.DebugThread
-self.debug_break = True
-if tmp_debugthread is not None:
-self.logger.writeyield(_("Stopping debugger...\n"))
-tmp_debugthread.join(timeout=5)
-if tmp_debugthread.isAlive() and self.logger:
-self.logger.write_warning(_("Couldn't stop debugger.\n"))
-else:
-self.logger.write(_("Debugger stopped.\n"))
-self.DebugThread = None
 if self.DispatchDebugValuesTimer is not None:
 self.DispatchDebugValuesTimer.Stop()
 def _connect_debug(self):
 self.previous_plcstate = None
 self.AppFrame.ResetGraphicViewers()
 self.RegisterDebugVarToConnector()
 if self.DispatchDebugValuesTimer is not None:
 self.DispatchDebugValuesTimer.Start(
 int(REFRESH_PERIOD * 1000), oneShot=True)
-if self.DebugThread is None:
-self.DebugThread = Thread(target=self.DebugThreadProc)
-self.DebugThread.start()
 def _Run(self):
 """
 Start PLC
 """

changeset 1995	691d119ba20f
parent 1953	5736d25bb393
child 1996	4ae9c4447947