greg@229: #!/usr/bin/env python greg@229: # -*- coding: utf-8 -*- greg@229: andrej@1667: # This file is part of Beremiz runtime. greg@229: # andrej@1571: # Copyright (C) 2007: Edouard TISSERANT and Laurent BESSARD greg@229: # andrej@1667: # See COPYING.Runtime file for copyrights details. greg@229: # andrej@1667: # This library is free software; you can redistribute it and/or andrej@1667: # modify it under the terms of the GNU Lesser General Public andrej@1667: # License as published by the Free Software Foundation; either andrej@1667: # version 2.1 of the License, or (at your option) any later version. andrej@1667: andrej@1667: # This library is distributed in the hope that it will be useful, andrej@1571: # but WITHOUT ANY WARRANTY; without even the implied warranty of andrej@1667: # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU andrej@1667: # Lesser General Public License for more details. andrej@1667: andrej@1667: # You should have received a copy of the GNU Lesser General Public andrej@1667: # License along with this library; if not, write to the Free Software andrej@1667: # Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA greg@229: greg@229: import Pyro.core as pyro Edouard@1434: from threading import Timer, Thread, Lock, Semaphore, Event andrej@1732: import ctypes andrej@1732: import os andrej@1732: import commands andrej@1732: import types andrej@1732: import sys Edouard@1075: from targets.typemapping import LogLevelsDefault, LogLevelsCount, TypeTranslator, UnpackDebugBuffer Edouard@1434: from time import time Edouard@917: etisserant@301: greg@229: if os.name in ("nt", "ce"): greg@229: from _ctypes import LoadLibrary as dlopen greg@229: from _ctypes import FreeLibrary as dlclose greg@229: elif os.name == "posix": greg@229: from _ctypes import dlopen, dlclose greg@229: greg@344: import traceback andrej@1736: andrej@1736: laurent@699: def get_last_traceback(tb): laurent@699: while tb.tb_next: laurent@699: tb = tb.tb_next laurent@699: return tb greg@229: andrej@1749: andrej@1742: lib_ext = { andrej@1740: "linux2": ".so", andrej@1740: "win32": ".dll", greg@229: }.get(sys.platform, "") greg@229: andrej@1736: etisserant@291: def PLCprint(message): etisserant@291: sys.stdout.write("PLCobject : "+message+"\n") etisserant@291: sys.stdout.flush() etisserant@291: andrej@1736: greg@229: class PLCObject(pyro.ObjBase): Edouard@1438: def __init__(self, workingdir, daemon, argv, statuschange, evaluator, pyruntimevars): greg@229: pyro.ObjBase.__init__(self) etisserant@301: self.evaluator = evaluator andrej@1737: self.argv = [workingdir] + argv # force argv[0] to be "path" to exec... greg@229: self.workingdir = workingdir Edouard@1447: self.PLCStatus = "Empty" greg@229: self.PLClibraryHandle = None greg@352: self.PLClibraryLock = Lock() laurent@366: self.DummyIteratorLock = None greg@229: # Creates fake C funcs proxies greg@229: self._FreePLC() greg@229: self.daemon = daemon greg@269: self.statuschange = statuschange etisserant@301: self.hmi_frame = None Edouard@1438: self.pyruntimevars = pyruntimevars Edouard@914: self._loading_error = None Edouard@1014: self.python_runtime_vars = None Edouard@1434: self.TraceThread = None Edouard@1434: self.TraceLock = Lock() Edouard@1434: self.TraceWakeup = Event() Edouard@1434: self.Traces = [] Edouard@1433: Edouard@1447: def AutoLoad(self): greg@229: # Get the last transfered PLC if connector must be restart greg@229: try: andrej@1742: self.CurrentPLCFilename = open( greg@229: self._GetMD5FileName(), greg@229: "r").read().strip() + lib_ext andrej@1570: if self.LoadPLC(): andrej@1570: self.PLCStatus = "Stopped" greg@229: except Exception, e: greg@229: self.PLCStatus = "Empty" andrej@1742: self.CurrentPLCFilename = None greg@229: etisserant@286: def StatusChange(self): etisserant@286: if self.statuschange is not None: Edouard@1438: for callee in self.statuschange: Edouard@1438: callee(self.PLCStatus) etisserant@286: Edouard@917: def LogMessage(self, *args): Edouard@917: if len(args) == 2: Edouard@917: level, msg = args Edouard@917: else: Edouard@917: level = LogLevelsDefault Edouard@917: msg, = args Edouard@917: return self._LogMessage(level, msg, len(msg)) Edouard@917: Laurent@1093: def ResetLogCount(self): Laurent@1093: if self._ResetLogCount is not None: Laurent@1093: self._ResetLogCount() Edouard@917: Edouard@917: def GetLogCount(self, level): andrej@1739: if self._GetLogCount is not None: Edouard@917: return int(self._GetLogCount(level)) andrej@1742: elif self._loading_error is not None and level == 0: Laurent@1093: return 1 Edouard@914: Edouard@917: def GetLogMessage(self, level, msgid): Edouard@921: tick = ctypes.c_uint32() Edouard@921: tv_sec = ctypes.c_uint32() Edouard@921: tv_nsec = ctypes.c_uint32() Edouard@914: if self._GetLogMessage is not None: Edouard@914: maxsz = len(self._log_read_buffer)-1 Edouard@1433: sz = self._GetLogMessage(level, msgid, Edouard@921: self._log_read_buffer, maxsz, Edouard@921: ctypes.byref(tick), Edouard@921: ctypes.byref(tv_sec), Edouard@921: ctypes.byref(tv_nsec)) Edouard@914: if sz and sz <= maxsz: Edouard@914: self._log_read_buffer[sz] = '\x00' andrej@1740: return self._log_read_buffer.value, tick.value, tv_sec.value, tv_nsec.value andrej@1742: elif self._loading_error is not None and level == 0: andrej@1740: return self._loading_error, 0, 0, 0 Edouard@914: return None Edouard@911: greg@229: def _GetMD5FileName(self): greg@229: return os.path.join(self.workingdir, "lasttransferedPLC.md5") greg@229: greg@229: def _GetLibFileName(self): andrej@1740: return os.path.join(self.workingdir, self.CurrentPLCFilename) greg@229: Edouard@1027: def LoadPLC(self): greg@229: """ greg@229: Load PLC library greg@229: Declare all functions, arguments and return values greg@229: """ Edouard@1457: md5 = open(self._GetMD5FileName(), "r").read() greg@229: try: greg@229: self._PLClibraryHandle = dlopen(self._GetLibFileName()) greg@229: self.PLClibraryHandle = ctypes.CDLL(self.CurrentPLCFilename, handle=self._PLClibraryHandle) Edouard@1433: Edouard@1463: self.PLC_ID = ctypes.c_char_p.in_dll(self.PLClibraryHandle, "PLC_ID") andrej@1739: if len(md5) == 32: andrej@1730: self.PLC_ID.value = md5 Edouard@1457: greg@229: self._startPLC = self.PLClibraryHandle.startPLC greg@229: self._startPLC.restype = ctypes.c_int greg@229: self._startPLC.argtypes = [ctypes.c_int, ctypes.POINTER(ctypes.c_char_p)] Edouard@1433: ed@455: self._stopPLC_real = self.PLClibraryHandle.stopPLC ed@455: self._stopPLC_real.restype = None Edouard@1433: laurent@366: self._PythonIterator = getattr(self.PLClibraryHandle, "PythonIterator", None) laurent@366: if self._PythonIterator is not None: laurent@366: self._PythonIterator.restype = ctypes.c_char_p Edouard@851: self._PythonIterator.argtypes = [ctypes.c_char_p, ctypes.POINTER(ctypes.c_void_p)] Edouard@1433: edouard@483: self._stopPLC = self._stopPLC_real laurent@366: else: Edouard@717: # If python confnode is not enabled, we reuse _PythonIterator Edouard@1433: # as a call that block pythonthread until StopPLC Edouard@1442: self.PlcStopping = Event() andrej@1750: Edouard@868: def PythonIterator(res, blkid): Edouard@1442: self.PlcStopping.clear() Edouard@1442: self.PlcStopping.wait() laurent@366: return None ed@455: self._PythonIterator = PythonIterator Edouard@1433: edouard@483: def __StopPLC(): ed@455: self._stopPLC_real() Edouard@1442: self.PlcStopping.set() edouard@483: self._stopPLC = __StopPLC Edouard@1433: greg@229: self._ResetDebugVariables = self.PLClibraryHandle.ResetDebugVariables greg@229: self._ResetDebugVariables.restype = None Edouard@1433: etisserant@235: self._RegisterDebugVariable = self.PLClibraryHandle.RegisterDebugVariable greg@229: self._RegisterDebugVariable.restype = None edouard@477: self._RegisterDebugVariable.argtypes = [ctypes.c_int, ctypes.c_void_p] Edouard@1433: greg@229: self._FreeDebugData = self.PLClibraryHandle.FreeDebugData greg@229: self._FreeDebugData.restype = None Edouard@1433: edouard@450: self._GetDebugData = self.PLClibraryHandle.GetDebugData Edouard@1433: self._GetDebugData.restype = ctypes.c_int edouard@450: self._GetDebugData.argtypes = [ctypes.POINTER(ctypes.c_uint32), ctypes.POINTER(ctypes.c_uint32), ctypes.POINTER(ctypes.c_void_p)] etisserant@235: etisserant@235: self._suspendDebug = self.PLClibraryHandle.suspendDebug Edouard@614: self._suspendDebug.restype = ctypes.c_int edouard@462: self._suspendDebug.argtypes = [ctypes.c_int] etisserant@235: etisserant@235: self._resumeDebug = self.PLClibraryHandle.resumeDebug etisserant@235: self._resumeDebug.restype = None Edouard@906: Laurent@1093: self._ResetLogCount = self.PLClibraryHandle.ResetLogCount Laurent@1093: self._ResetLogCount.restype = None Laurent@1093: Edouard@906: self._GetLogCount = self.PLClibraryHandle.GetLogCount Edouard@906: self._GetLogCount.restype = ctypes.c_uint32 Edouard@917: self._GetLogCount.argtypes = [ctypes.c_uint8] Edouard@906: Edouard@911: self._LogMessage = self.PLClibraryHandle.LogMessage Edouard@911: self._LogMessage.restype = ctypes.c_int Edouard@971: self._LogMessage.argtypes = [ctypes.c_uint8, ctypes.c_char_p, ctypes.c_uint32] Laurent@1093: andrej@1760: self._log_read_buffer = ctypes.create_string_buffer(1 << 14) # 16K Edouard@911: self._GetLogMessage = self.PLClibraryHandle.GetLogMessage Edouard@911: self._GetLogMessage.restype = ctypes.c_uint32 Edouard@921: self._GetLogMessage.argtypes = [ctypes.c_uint8, ctypes.c_uint32, ctypes.c_char_p, ctypes.c_uint32, ctypes.POINTER(ctypes.c_uint32), ctypes.POINTER(ctypes.c_uint32), ctypes.POINTER(ctypes.c_uint32)] Edouard@911: Edouard@914: self._loading_error = None Edouard@1035: Edouard@1035: self.PythonRuntimeInit() Edouard@1035: greg@229: return True greg@229: except: Edouard@914: self._loading_error = traceback.format_exc() Edouard@914: PLCprint(self._loading_error) greg@229: return False greg@229: Edouard@1045: def UnLoadPLC(self): Edouard@1045: self.PythonRuntimeCleanup() Edouard@1045: self._FreePLC() Edouard@1045: greg@229: def _FreePLC(self): greg@229: """ greg@229: Unload PLC library. greg@229: This is also called by __init__ to create dummy C func proxies greg@229: """ greg@352: self.PLClibraryLock.acquire() greg@229: # Forget all refs to library andrej@1740: self._startPLC = lambda x, y: None andrej@1740: self._stopPLC = lambda: None andrej@1740: self._ResetDebugVariables = lambda: None andrej@1740: self._RegisterDebugVariable = lambda x, y: None andrej@1740: self._IterDebugData = lambda x, y: None andrej@1740: self._FreeDebugData = lambda: None andrej@1740: self._GetDebugData = lambda: -1 andrej@1740: self._suspendDebug = lambda x: -1 andrej@1740: self._resumeDebug = lambda: None andrej@1740: self._PythonIterator = lambda: "" Edouard@1433: self._GetLogCount = None andrej@1740: self._LogMessage = lambda l, m, s: PLCprint("OFF LOG :"+m) Edouard@914: self._GetLogMessage = None greg@229: self.PLClibraryHandle = None greg@229: # Unload library explicitely andrej@1740: if getattr(self, "_PLClibraryHandle", None) is not None: greg@229: dlclose(self._PLClibraryHandle) laurent@393: self._PLClibraryHandle = None Edouard@1433: greg@352: self.PLClibraryLock.release() greg@229: return False greg@229: Edouard@1014: def PythonRuntimeCall(self, methodname): Edouard@1433: """ Edouard@1433: Calls init, start, stop or cleanup method provided by Edouard@1014: runtime python files, loaded when new PLC uploaded Edouard@1014: """ andrej@1734: for method in self.python_runtime_vars.get("_runtime_%s" % methodname, []): andrej@1740: res, exp = self.evaluator(method) Edouard@1433: if exp is not None: andrej@1740: self.LogMessage(0, '\n'.join(traceback.format_exception(*exp))) Edouard@1014: Edouard@1014: def PythonRuntimeInit(self): Edouard@1014: MethodNames = ["init", "start", "stop", "cleanup"] Edouard@1014: self.python_runtime_vars = globals().copy() Edouard@1438: self.python_runtime_vars.update(self.pyruntimevars) Edouard@1438: Edouard@1144: class PLCSafeGlobals: Edouard@1145: def __getattr__(_self, name): andrej@1739: try: Edouard@1156: t = self.python_runtime_vars["_"+name+"_ctype"] Edouard@1156: except KeyError: andrej@1734: raise KeyError("Try to get unknown shared global variable : %s" % name) Edouard@1156: v = t() Edouard@1145: r = self.python_runtime_vars["_PySafeGetPLCGlob_"+name](ctypes.byref(v)) Edouard@1145: return self.python_runtime_vars["_"+name+"_unpack"](v) andrej@1750: Edouard@1145: def __setattr__(_self, name, value): andrej@1739: try: Edouard@1156: t = self.python_runtime_vars["_"+name+"_ctype"] Edouard@1156: except KeyError: andrej@1734: raise KeyError("Try to set unknown shared global variable : %s" % name) andrej@1740: v = self.python_runtime_vars["_"+name+"_pack"](t, value) Edouard@1145: self.python_runtime_vars["_PySafeSetPLCGlob_"+name](ctypes.byref(v)) Edouard@1447: Edouard@1447: self.python_runtime_vars.update({ andrej@1739: "PLCGlobals": PLCSafeGlobals(), andrej@1739: "WorkingDir": self.workingdir, andrej@1739: "PLCObject": self, andrej@1739: "PLCBinary": self.PLClibraryHandle, andrej@1739: "PLCGlobalsDesc": []}) andrej@1739: andrej@1739: for methodname in MethodNames: andrej@1734: self.python_runtime_vars["_runtime_%s" % methodname] = [] Edouard@1447: Edouard@972: try: Edouard@1447: filenames = os.listdir(self.workingdir) Edouard@1447: filenames.sort() Edouard@1447: for filename in filenames: Edouard@972: name, ext = os.path.splitext(filename) Edouard@972: if name.upper().startswith("RUNTIME") and ext.upper() == ".PY": Edouard@1014: execfile(os.path.join(self.workingdir, filename), self.python_runtime_vars) Edouard@1433: for methodname in MethodNames: Edouard@1014: method = self.python_runtime_vars.get("_%s_%s" % (name, methodname), None) Edouard@1014: if method is not None: andrej@1734: self.python_runtime_vars["_runtime_%s" % methodname].append(method) Edouard@972: except: andrej@1740: self.LogMessage(0, traceback.format_exc()) Edouard@972: raise Edouard@1433: Edouard@1014: self.PythonRuntimeCall("init") Edouard@1014: Edouard@1014: def PythonRuntimeCleanup(self): Edouard@1014: if self.python_runtime_vars is not None: Edouard@1014: self.PythonRuntimeCall("cleanup") Edouard@1014: Edouard@1014: self.python_runtime_vars = None etisserant@291: edouard@462: def PythonThreadProc(self): laurent@798: self.StartSem.release() andrej@1740: res, cmd, blkid = "None", "None", ctypes.c_void_p() andrej@1742: compile_cache = {} laurent@798: while True: Edouard@851: # print "_PythonIterator(", res, ")", andrej@1740: cmd = self._PythonIterator(res, blkid) Edouard@1433: FBID = blkid.value Edouard@851: # print " -> ", cmd, blkid laurent@798: if cmd is None: laurent@798: break andrej@1739: try: andrej@1742: self.python_runtime_vars["FBID"] = FBID andrej@1742: ccmd, AST = compile_cache.get(FBID, (None, None)) andrej@1742: if ccmd is None or ccmd != cmd: Edouard@867: AST = compile(cmd, '', 'eval') andrej@1742: compile_cache[FBID] = (cmd, AST) andrej@1740: result, exp = self.evaluator(eval, AST, self.python_runtime_vars) Edouard@1433: if exp is not None: Edouard@1052: res = "#EXCEPTION : "+str(exp[1]) andrej@1740: self.LogMessage(1, ('PyEval@0x%x(Code="%s") Exception "%s"') % (FBID, cmd, Edouard@1052: '\n'.join(traceback.format_exception(*exp)))) Edouard@867: else: andrej@1742: res = str(result) andrej@1742: self.python_runtime_vars["FBID"] = None andrej@1740: except Exception, e: laurent@798: res = "#EXCEPTION : "+str(e) andrej@1740: self.LogMessage(1, ('PyEval@0x%x(Code="%s") Exception "%s"') % (FBID, cmd, str(e))) Edouard@1433: edouard@462: def StartPLC(self): edouard@465: if self.CurrentPLCFilename is not None and self.PLCStatus == "Stopped": laurent@798: c_argv = ctypes.c_char_p * len(self.argv) laurent@798: error = None andrej@1740: res = self._startPLC(len(self.argv), c_argv(*self.argv)) Edouard@906: if res == 0: Edouard@1442: self.PLCStatus = "Started" Edouard@1442: self.StatusChange() Edouard@1442: self.PythonRuntimeCall("start") andrej@1742: self.StartSem = Semaphore(0) Edouard@906: self.PythonThread = Thread(target=self.PythonThreadProc) Edouard@906: self.PythonThread.start() Edouard@906: self.StartSem.acquire() Edouard@917: self.LogMessage("PLC started") laurent@798: else: andrej@1740: self.LogMessage(0, _("Problem starting PLC : error %d" % res)) laurent@798: self.PLCStatus = "Broken" laurent@798: self.StatusChange() Edouard@1433: greg@229: def StopPLC(self): greg@229: if self.PLCStatus == "Started": Edouard@917: self.LogMessage("PLC stopped") greg@352: self._stopPLC() laurent@798: self.PythonThread.join() Edouard@1442: self.PLCStatus = "Stopped" Edouard@1442: self.StatusChange() Edouard@1442: self.PythonRuntimeCall("stop") andrej@1739: if self.TraceThread is not None: Edouard@1434: self.TraceWakeup.set() Edouard@1434: self.TraceThread.join() Edouard@1434: self.TraceThread = None greg@229: return True greg@229: return False greg@229: greg@229: def _Reload(self): greg@229: self.daemon.shutdown(True) greg@229: self.daemon.sock.close() andrej@1740: os.execv(sys.executable, [sys.executable]+sys.argv[:]) greg@229: # never reached greg@229: return 0 greg@229: greg@229: def ForceReload(self): greg@229: # respawn python interpreter andrej@1740: Timer(0.1, self._Reload).start() greg@229: return True greg@229: greg@229: def GetPLCstatus(self): andrej@1740: return self.PLCStatus, map(self.GetLogCount, xrange(LogLevelsCount)) Edouard@1433: greg@229: def NewPLC(self, md5sum, data, extrafiles): laurent@393: if self.PLCStatus in ["Stopped", "Empty", "Broken"]: greg@229: NewFileName = md5sum + lib_ext andrej@1740: extra_files_log = os.path.join(self.workingdir, "extra_files.txt") Edouard@906: Edouard@1045: self.UnLoadPLC() Edouard@1045: andrej@1734: self.LogMessage("NewPLC (%s)" % md5sum) Edouard@906: self.PLCStatus = "Empty" Edouard@906: greg@229: try: greg@229: os.remove(os.path.join(self.workingdir, greg@229: self.CurrentPLCFilename)) laurent@364: for filename in file(extra_files_log, "r").readlines() + [extra_files_log]: greg@229: try: laurent@364: os.remove(os.path.join(self.workingdir, filename.strip())) greg@229: except: greg@229: pass greg@229: except: greg@229: pass Edouard@1433: greg@229: try: greg@229: # Create new PLC file andrej@1740: open(os.path.join(self.workingdir, NewFileName), greg@229: 'wb').write(data) Edouard@1433: greg@229: # Store new PLC filename based on md5 key greg@229: open(self._GetMD5FileName(), "w").write(md5sum) Edouard@1433: greg@229: # Then write the files greg@229: log = file(extra_files_log, "w") andrej@1740: for fname, fdata in extrafiles: andrej@1740: fpath = os.path.join(self.workingdir, fname) greg@229: open(fpath, "wb").write(fdata) greg@229: log.write(fname+'\n') greg@229: greg@229: # Store new PLC filename greg@229: self.CurrentPLCFilename = NewFileName greg@229: except: Edouard@906: self.PLCStatus = "Broken" Edouard@906: self.StatusChange() etisserant@291: PLCprint(traceback.format_exc()) greg@229: return False Edouard@906: Edouard@1027: if self.LoadPLC(): greg@229: self.PLCStatus = "Stopped" Edouard@906: else: Edouard@1035: self.PLCStatus = "Broken" Edouard@906: self._FreePLC() Edouard@906: self.StatusChange() Edouard@906: Edouard@906: return self.PLCStatus == "Stopped" greg@229: return False greg@229: greg@229: def MatchMD5(self, MD5): greg@229: try: greg@229: last_md5 = open(self._GetMD5FileName(), "r").read() greg@229: return last_md5 == MD5 greg@229: except: Edouard@1440: pass Edouard@1440: return False Edouard@1433: greg@229: def SetTraceVariablesList(self, idxs): greg@229: """ Edouard@1433: Call ctype imported function to append greg@229: these indexes to registred variables in PLC debugger greg@229: """ edouard@462: if idxs: edouard@462: # suspend but dont disable Edouard@614: if self._suspendDebug(False) == 0: Edouard@614: # keep a copy of requested idx Edouard@614: self._ResetDebugVariables() andrej@1740: for idx, iectype, force in idxs: andrej@1743: if force is not None: andrej@1740: c_type, unpack_func, pack_func = \ Edouard@614: TypeTranslator.get(iectype, andrej@1740: (None, None, None)) andrej@1740: force = ctypes.byref(pack_func(c_type, force)) Edouard@614: self._RegisterDebugVariable(idx, force) Edouard@1434: self._TracesSwap() Edouard@614: self._resumeDebug() edouard@462: else: edouard@462: self._suspendDebug(True) Edouard@1434: Edouard@1434: def _TracesPush(self, trace): Edouard@1434: self.TraceLock.acquire() Edouard@1434: lT = len(self.Traces) andrej@1739: if lT != 0 and lT * len(self.Traces[0]) > 1024 * 1024: Edouard@1434: self.Traces.pop(0) Edouard@1434: self.Traces.append(trace) Edouard@1434: self.TraceLock.release() Edouard@1434: Edouard@1434: def _TracesSwap(self): Edouard@1434: self.LastSwapTrace = time() Edouard@1434: if self.TraceThread is None and self.PLCStatus == "Started": Edouard@1434: self.TraceThread = Thread(target=self.TraceThreadProc) Edouard@1434: self.TraceThread.start() Edouard@1434: self.TraceLock.acquire() Edouard@1434: Traces = self.Traces Edouard@1434: self.Traces = [] Edouard@1434: self.TraceLock.release() Edouard@1434: self.TraceWakeup.set() Edouard@1434: return Traces Edouard@1434: Edouard@1434: def _TracesAutoSuspend(self): Edouard@1434: # TraceProc stops here if Traces not polled for 3 seconds Edouard@1434: traces_age = time() - self.LastSwapTrace Edouard@1434: if traces_age > 3: Edouard@1434: self.TraceLock.acquire() Edouard@1434: self.Traces = [] Edouard@1434: self.TraceLock.release() andrej@1737: self._suspendDebug(True) # Disable debugger Edouard@1435: self.TraceWakeup.clear() Edouard@1434: self.TraceWakeup.wait() andrej@1737: self._resumeDebug() # Re-enable debugger Edouard@1434: Edouard@1434: def _TracesFlush(self): Edouard@1434: self.TraceLock.acquire() Edouard@1434: self.Traces = [] Edouard@1434: self.TraceLock.release() etisserant@280: greg@229: def GetTraceVariables(self): Edouard@1434: return self.PLCStatus, self._TracesSwap() Edouard@1434: Edouard@1434: def TraceThreadProc(self): Edouard@1434: """ Edouard@1434: Return a list of traces, corresponding to the list of required idx Edouard@1434: """ andrej@1739: while self.PLCStatus == "Started": edouard@450: tick = ctypes.c_uint32() edouard@450: size = ctypes.c_uint32() Edouard@1075: buff = ctypes.c_void_p() Edouard@1433: TraceBuffer = None laurent@795: if self.PLClibraryLock.acquire(False): laurent@795: if self._GetDebugData(ctypes.byref(tick), laurent@795: ctypes.byref(size), Edouard@1075: ctypes.byref(buff)) == 0: laurent@795: if size.value: Edouard@1433: TraceBuffer = ctypes.string_at(buff.value, size.value) laurent@795: self._FreeDebugData() edouard@483: self.PLClibraryLock.release() Edouard@1433: if TraceBuffer is not None: Edouard@1434: self._TracesPush((tick.value, TraceBuffer)) Edouard@1434: self._TracesAutoSuspend() Edouard@1434: self._TracesFlush() Edouard@1434: Edouard@1440: def RemoteExec(self, script, *kwargs): laurent@699: try: laurent@699: exec script in kwargs laurent@699: except: laurent@699: e_type, e_value, e_traceback = sys.exc_info() laurent@699: line_no = traceback.tb_lineno(get_last_traceback(e_traceback)) Edouard@1433: return (-1, "RemoteExec script failed!\n\nLine %d: %s\n\t%s" % laurent@699: (line_no, e_value, script.splitlines()[line_no - 1])) laurent@699: return (0, kwargs.get("returnVal", None))