greg@229: #!/usr/bin/env python greg@229: # -*- coding: utf-8 -*- greg@229: greg@229: #This file is part of Beremiz, a Integrated Development Environment for Edouard@1433: #programming IEC 61131-3 automates supporting plcopen standard and CanFestival. greg@229: # greg@229: #Copyright (C) 2007: Edouard TISSERANT and Laurent BESSARD greg@229: # greg@229: #See COPYING file for copyrights details. greg@229: # greg@229: #This library is free software; you can redistribute it and/or greg@229: #modify it under the terms of the GNU General Public greg@229: #License as published by the Free Software Foundation; either greg@229: #version 2.1 of the License, or (at your option) any later version. greg@229: # greg@229: #This library is distributed in the hope that it will be useful, greg@229: #but WITHOUT ANY WARRANTY; without even the implied warranty of greg@229: #MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU greg@229: #General Public License for more details. greg@229: # greg@229: #You should have received a copy of the GNU General Public greg@229: #License along with this library; if not, write to the Free Software greg@229: #Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA greg@229: greg@229: import Pyro.core as pyro Edouard@1434: from threading import Timer, Thread, Lock, Semaphore, Event etisserant@301: import ctypes, os, commands, types, 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 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: greg@229: lib_ext ={ greg@229: "linux2":".so", greg@229: "win32":".dll", greg@229: }.get(sys.platform, "") greg@229: etisserant@291: def PLCprint(message): etisserant@291: sys.stdout.write("PLCobject : "+message+"\n") etisserant@291: sys.stdout.flush() etisserant@291: 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 greg@229: 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: greg@229: self.CurrentPLCFilename=open( greg@229: self._GetMD5FileName(), greg@229: "r").read().strip() + lib_ext Laurent@1121: self.LoadPLC() greg@229: except Exception, e: greg@229: self.PLCStatus = "Empty" greg@229: 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): Edouard@911: if self._GetLogCount is not None : Edouard@917: return int(self._GetLogCount(level)) Edouard@917: 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' Edouard@921: return self._log_read_buffer.value,tick.value,tv_sec.value,tv_nsec.value Edouard@917: elif self._loading_error is not None and level==0: Edouard@921: 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): greg@229: return os.path.join(self.workingdir,self.CurrentPLCFilename) greg@229: 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") Edouard@1457: if len(md5) == 32 : Edouard@1463: 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() 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: 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: Edouard@911: 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 Edouard@1027: self._startPLC = lambda x,y:None greg@229: self._stopPLC = lambda:None greg@229: self._ResetDebugVariables = lambda:None laurent@479: self._RegisterDebugVariable = lambda x, y:None greg@229: self._IterDebugData = lambda x,y:None greg@229: self._FreeDebugData = lambda:None edouard@450: self._GetDebugData = lambda:-1 Edouard@614: self._suspendDebug = lambda x:-1 etisserant@235: self._resumeDebug = lambda:None etisserant@280: self._PythonIterator = lambda:"" Edouard@1433: self._GetLogCount = None Edouard@917: 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 greg@229: 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: """ Edouard@1051: for method in self.python_runtime_vars.get("_runtime_%s"%methodname, []): Edouard@1051: res,exp = self.evaluator(method) Edouard@1433: if exp is not None: Edouard@1052: 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): Edouard@1156: try : Edouard@1156: t = self.python_runtime_vars["_"+name+"_ctype"] Edouard@1156: except KeyError: Edouard@1156: 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) Edouard@1145: def __setattr__(_self, name, value): Edouard@1156: try : Edouard@1156: t = self.python_runtime_vars["_"+name+"_ctype"] Edouard@1156: except KeyError: Edouard@1156: raise KeyError("Try to set unknown shared global variable : %s"%name) Edouard@1145: 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({ Edouard@1447: "PLCGlobals" : PLCSafeGlobals(), Edouard@1447: "WorkingDir" : self.workingdir, Edouard@1447: "PLCObject" : self, Edouard@1447: "PLCBinary" : self.PLClibraryHandle, Edouard@1447: "PLCGlobalsDesc" : []}) Edouard@1447: Edouard@1447: for methodname in MethodNames : Edouard@1447: 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: Edouard@1014: self.python_runtime_vars["_runtime_%s"%methodname].append(method) Edouard@972: except: Edouard@972: self.LogMessage(0,traceback.format_exc()) Edouard@972: raise Edouard@1433: Edouard@1014: self.PythonRuntimeCall("init") Edouard@1014: etisserant@291: 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() Edouard@851: res,cmd,blkid = "None","None",ctypes.c_void_p() Edouard@867: compile_cache={} laurent@798: while True: Edouard@851: # print "_PythonIterator(", res, ")", Edouard@851: cmd = self._PythonIterator(res,blkid) Edouard@1433: FBID = blkid.value Edouard@851: # print " -> ", cmd, blkid laurent@798: if cmd is None: laurent@798: break laurent@798: try : Edouard@1014: self.python_runtime_vars["FBID"]=FBID Edouard@867: ccmd,AST =compile_cache.get(FBID, (None,None)) Edouard@867: if ccmd is None or ccmd!=cmd: Edouard@867: AST = compile(cmd, '', 'eval') Edouard@867: compile_cache[FBID]=(cmd,AST) Edouard@1288: result,exp = self.evaluator(eval,AST,self.python_runtime_vars) Edouard@1433: if exp is not None: Edouard@1052: res = "#EXCEPTION : "+str(exp[1]) Edouard@1052: self.LogMessage(1,('PyEval@0x%x(Code="%s") Exception "%s"')%(FBID,cmd, Edouard@1052: '\n'.join(traceback.format_exception(*exp)))) Edouard@867: else: Edouard@867: res=str(result) Edouard@1014: self.python_runtime_vars["FBID"]=None laurent@798: except Exception,e: laurent@798: res = "#EXCEPTION : "+str(e) Edouard@972: 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 Edouard@906: 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") Edouard@906: 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: Edouard@972: 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") Edouard@1434: 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() greg@229: 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 greg@229: Timer(0.1,self._Reload).start() greg@229: return True greg@229: greg@229: def GetPLCstatus(self): Edouard@917: 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 greg@229: extra_files_log = os.path.join(self.workingdir,"extra_files.txt") Edouard@906: Edouard@1045: self.UnLoadPLC() Edouard@1045: Laurent@1011: 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 greg@229: 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") greg@229: for fname,fdata in extrafiles: greg@229: 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() Edouard@614: for idx,iectype,force in idxs: Edouard@614: if force !=None: Edouard@614: c_type,unpack_func, pack_func = \ Edouard@614: TypeTranslator.get(iectype, Edouard@614: (None,None,None)) Edouard@1433: 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) Edouard@1434: 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() Edouard@1434: self._suspendDebug(True) # Disable debugger Edouard@1435: self.TraceWakeup.clear() Edouard@1434: self.TraceWakeup.wait() Edouard@1434: 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: """ Edouard@1434: 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@592: 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)) Edouard@1433: Edouard@1433: