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()
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@1745:             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)
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, '<plc>', '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))