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, '<plc>', '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: