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 greg@229: #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@690: from threading import Timer, Thread, Lock, Semaphore etisserant@301: import ctypes, os, commands, types, sys Edouard@592: from targets.typemapping import SameEndianessTypeTranslator as TypeTranslator 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): etisserant@235: _Idxs = [] laurent@368: def __init__(self, workingdir, daemon, argv, statuschange, evaluator, website): 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 greg@229: self.PLCStatus = "Stopped" 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 laurent@368: self.website = website greg@229: 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 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: etisserant@286: self.statuschange(self.PLCStatus) etisserant@286: 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: greg@229: def _LoadNewPLC(self): greg@229: """ greg@229: Load PLC library greg@229: Declare all functions, arguments and return values greg@229: """ greg@229: try: greg@229: self._PLClibraryHandle = dlopen(self._GetLibFileName()) greg@229: self.PLClibraryHandle = ctypes.CDLL(self.CurrentPLCFilename, handle=self._PLClibraryHandle) greg@229: 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)] greg@229: ed@455: self._stopPLC_real = self.PLClibraryHandle.stopPLC ed@455: self._stopPLC_real.restype = None laurent@366: 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 laurent@366: self._PythonIterator.argtypes = [ctypes.c_char_p] laurent@366: edouard@483: self._stopPLC = self._stopPLC_real laurent@366: else: Edouard@717: # If python confnode is not enabled, we reuse _PythonIterator ed@455: # as a call that block pythonthread until StopPLC ed@455: self.PythonIteratorLock = Lock() ed@455: self.PythonIteratorLock.acquire() ed@455: def PythonIterator(res): ed@455: self.PythonIteratorLock.acquire() ed@455: self.PythonIteratorLock.release() laurent@366: return None ed@455: self._PythonIterator = PythonIterator laurent@366: edouard@483: def __StopPLC(): ed@455: self._stopPLC_real() ed@455: self.PythonIteratorLock.release() edouard@483: self._stopPLC = __StopPLC edouard@483: greg@229: greg@229: self._ResetDebugVariables = self.PLClibraryHandle.ResetDebugVariables greg@229: self._ResetDebugVariables.restype = None greg@229: 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] greg@229: greg@229: self._FreeDebugData = self.PLClibraryHandle.FreeDebugData greg@229: self._FreeDebugData.restype = None greg@229: edouard@450: self._GetDebugData = self.PLClibraryHandle.GetDebugData edouard@450: 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 etisserant@235: greg@229: return True greg@229: except: etisserant@291: PLCprint(traceback.format_exc()) greg@229: return False greg@229: 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 greg@229: self._startPLC = lambda: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:"" 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 laurent@393: greg@352: self.PLClibraryLock.release() greg@229: return False greg@229: etisserant@299: def PrepareRuntimePy(self): etisserant@290: self.python_threads_vars = globals().copy() greg@344: self.python_threads_vars["WorkingDir"] = self.workingdir laurent@368: self.python_threads_vars["website"] = self.website laurent@366: self.python_threads_vars["_runtime_begin"] = [] laurent@366: self.python_threads_vars["_runtime_cleanup"] = [] Edouard@734: self.python_threads_vars["PLCObject"] = self Edouard@734: self.python_threads_vars["PLCBinary"] = self.PLClibraryHandle laurent@368: laurent@366: for filename in os.listdir(self.workingdir): laurent@366: name, ext = os.path.splitext(filename) greg@391: if name.upper().startswith("RUNTIME") and ext.upper() == ".PY": laurent@366: try: laurent@366: # TODO handle exceptions in runtime.py laurent@366: # pyfile may redefine _runtime_cleanup laurent@366: # or even call _PythonThreadProc itself. laurent@366: execfile(os.path.join(self.workingdir, filename), self.python_threads_vars) laurent@366: except: laurent@366: PLCprint(traceback.format_exc()) laurent@366: runtime_begin = self.python_threads_vars.get("_%s_begin" % name, None) laurent@366: if runtime_begin is not None: laurent@366: self.python_threads_vars["_runtime_begin"].append(runtime_begin) laurent@366: runtime_cleanup = self.python_threads_vars.get("_%s_cleanup" % name, None) laurent@366: if runtime_cleanup is not None: laurent@366: self.python_threads_vars["_runtime_cleanup"].append(runtime_cleanup) laurent@366: laurent@366: for runtime_begin in self.python_threads_vars.get("_runtime_begin", []): greg@329: runtime_begin() laurent@368: laurent@368: if self.website is not None: laurent@368: self.website.PLCStarted() etisserant@291: etisserant@291: def FinishRuntimePy(self): laurent@366: for runtime_cleanup in self.python_threads_vars.get("_runtime_cleanup", []): laurent@366: runtime_cleanup() laurent@368: if self.website is not None: laurent@368: self.website.PLCStopped() etisserant@291: self.python_threads_vars = None etisserant@291: edouard@462: def PythonThreadProc(self): greg@350: c_argv = ctypes.c_char_p * len(self.argv) greg@350: error = None greg@350: if self._LoadNewPLC(): greg@350: if self._startPLC(len(self.argv),c_argv(*self.argv)) == 0: greg@229: self.PLCStatus = "Started" etisserant@286: self.StatusChange() Edouard@690: self.StartSem.release() greg@350: self.evaluator(self.PrepareRuntimePy) greg@350: res,cmd = "None","None" greg@352: while True: greg@350: #print "_PythonIterator(", res, ")", greg@350: cmd = self._PythonIterator(res) greg@350: #print " -> ", cmd greg@350: if cmd is None: greg@350: break greg@350: try : greg@350: res = str(self.evaluator(eval,cmd,self.python_threads_vars)) greg@350: except Exception,e: greg@350: res = "#EXCEPTION : "+str(e) greg@350: PLCprint(res) greg@350: self.PLCStatus = "Stopped" greg@350: self.StatusChange() greg@350: self.evaluator(self.FinishRuntimePy) greg@229: else: greg@350: error = "starting" greg@350: else: greg@350: error = "loading" greg@350: if error is not None: greg@350: PLCprint("Problem %s PLC"%error) greg@350: self.PLCStatus = "Broken" Edouard@690: self.StatusChange() Edouard@690: self.StartSem.release() greg@350: self._FreePLC() greg@350: edouard@462: def StartPLC(self): greg@350: PLCprint("StartPLC") edouard@465: if self.CurrentPLCFilename is not None and self.PLCStatus == "Stopped": Edouard@690: self.StartSem=Semaphore(0) edouard@462: self.PythonThread = Thread(target=self.PythonThreadProc) greg@350: self.PythonThread.start() Edouard@690: self.StartSem.acquire() greg@352: greg@229: def StopPLC(self): greg@350: PLCprint("StopPLC") greg@229: if self.PLCStatus == "Started": edouard@483: self.PLCStatus = "Stopped" greg@352: self._stopPLC() 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): greg@229: return self.PLCStatus greg@229: greg@229: def NewPLC(self, md5sum, data, extrafiles): etisserant@291: PLCprint("NewPLC (%s)"%md5sum) 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") 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 greg@229: greg@229: try: greg@229: # Create new PLC file greg@229: open(os.path.join(self.workingdir,NewFileName), greg@229: 'wb').write(data) greg@229: greg@229: # Store new PLC filename based on md5 key greg@229: open(self._GetMD5FileName(), "w").write(md5sum) greg@229: 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: etisserant@291: PLCprint(traceback.format_exc()) greg@229: return False greg@229: if self.PLCStatus == "Empty": greg@229: self.PLCStatus = "Stopped" greg@229: return True 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: greg@229: return False greg@229: edouard@477: Edouard@592: greg@229: def SetTraceVariablesList(self, idxs): greg@229: """ greg@229: 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._Idxs = idxs[:] 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@614: force = ctypes.byref(pack_func(c_type,force)) Edouard@614: self._RegisterDebugVariable(idx, force) Edouard@614: self._resumeDebug() edouard@462: else: edouard@462: self._suspendDebug(True) edouard@462: self._Idxs = [] etisserant@280: greg@229: def GetTraceVariables(self): greg@229: """ greg@339: Return a list of variables, corresponding to the list of required idx greg@229: """ etisserant@286: if self.PLCStatus == "Started": ed@455: res=[] edouard@450: tick = ctypes.c_uint32() edouard@450: size = ctypes.c_uint32() edouard@450: buffer = ctypes.c_void_p() edouard@465: offset = 0 edouard@483: if self.PLClibraryLock.acquire(False) and \ edouard@504: self._GetDebugData(ctypes.byref(tick), edouard@504: ctypes.byref(size), edouard@504: ctypes.byref(buffer)) == 0 : edouard@483: if size.value: edouard@483: for idx, iectype, forced in self._Idxs: edouard@483: cursor = ctypes.c_void_p(buffer.value + offset) edouard@504: c_type,unpack_func, pack_func = \ edouard@593: TypeTranslator.get(iectype, edouard@504: (None,None,None)) Edouard@592: if c_type is not None and offset < size.value: edouard@504: res.append(unpack_func( edouard@504: ctypes.cast(cursor, edouard@504: ctypes.POINTER(c_type)).contents)) edouard@483: offset += ctypes.sizeof(c_type) edouard@483: else: edouard@483: if c_type is None: edouard@504: PLCprint("Debug error - " + iectype + edouard@504: " not supported !") Edouard@592: #if offset >= size.value: Edouard@592: #PLCprint("Debug error - buffer too small ! %d != %d"%(offset, size.value)) edouard@483: break edouard@483: self._FreeDebugData() edouard@483: self.PLClibraryLock.release() edouard@465: if offset and offset == size.value: edouard@460: return self.PLCStatus, tick.value, res Edouard@592: #elif size.value: Edouard@592: #PLCprint("Debug error - wrong buffer unpack ! %d != %d"%(offset, size.value)) Edouard@592: return self.PLCStatus, None, [] Edouard@592: laurent@699: 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)) laurent@699: 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)) laurent@699: laurent@699: