#!/usr/bin/env python
# -*- coding: utf-8 -*-
#This file is part of Beremiz, a Integrated Development Environment for
#programming IEC 61131-3 automates supporting plcopen standard and CanFestival.
#
#Copyright (C) 2007: Edouard TISSERANT and Laurent BESSARD
#
#See COPYING file for copyrights details.
#
#This library is free software; you can redistribute it and/or
#modify it under the terms of the GNU General Public
#License as published by the Free Software Foundation; either
#version 2.1 of the License, or (at your option) any later version.
#
#This library is distributed in the hope that it will be useful,
#but WITHOUT ANY WARRANTY; without even the implied warranty of
#MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
#General Public License for more details.
#
#You should have received a copy of the GNU General Public
#License along with this library; if not, write to the Free Software
#Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
import Pyro.core as pyro
from threading import Timer, Thread, Lock
import ctypes, os, commands, types, sys
from datetime import timedelta as td
from targets.typemapping import SameEndianessTypeTranslator as TypeTranslator
if os.name in ("nt", "ce"):
from _ctypes import LoadLibrary as dlopen
from _ctypes import FreeLibrary as dlclose
elif os.name == "posix":
from _ctypes import dlopen, dlclose
import traceback
lib_ext ={
"linux2":".so",
"win32":".dll",
}.get(sys.platform, "")
def PLCprint(message):
sys.stdout.write("PLCobject : "+message+"\n")
sys.stdout.flush()
class PLCObject(pyro.ObjBase):
_Idxs = []
def __init__(self, workingdir, daemon, argv, statuschange, evaluator, website):
pyro.ObjBase.__init__(self)
self.evaluator = evaluator
self.argv = [workingdir] + argv # force argv[0] to be "path" to exec...
self.workingdir = workingdir
self.PLCStatus = "Stopped"
self.PLClibraryHandle = None
self.PLClibraryLock = Lock()
self.DummyIteratorLock = None
# Creates fake C funcs proxies
self._FreePLC()
self.daemon = daemon
self.statuschange = statuschange
self.hmi_frame = None
self.website = website
# Get the last transfered PLC if connector must be restart
try:
self.CurrentPLCFilename=open(
self._GetMD5FileName(),
"r").read().strip() + lib_ext
except Exception, e:
self.PLCStatus = "Empty"
self.CurrentPLCFilename=None
def StatusChange(self):
if self.statuschange is not None:
self.statuschange(self.PLCStatus)
def _GetMD5FileName(self):
return os.path.join(self.workingdir, "lasttransferedPLC.md5")
def _GetLibFileName(self):
return os.path.join(self.workingdir,self.CurrentPLCFilename)
def _LoadNewPLC(self):
"""
Load PLC library
Declare all functions, arguments and return values
"""
try:
self._PLClibraryHandle = dlopen(self._GetLibFileName())
self.PLClibraryHandle = ctypes.CDLL(self.CurrentPLCFilename, handle=self._PLClibraryHandle)
self._startPLC = self.PLClibraryHandle.startPLC
self._startPLC.restype = ctypes.c_int
self._startPLC.argtypes = [ctypes.c_int, ctypes.POINTER(ctypes.c_char_p)]
self._stopPLC_real = self.PLClibraryHandle.stopPLC
self._stopPLC_real.restype = None
self._PythonIterator = getattr(self.PLClibraryHandle, "PythonIterator", None)
if self._PythonIterator is not None:
self._PythonIterator.restype = ctypes.c_char_p
self._PythonIterator.argtypes = [ctypes.c_char_p]
self._stopPLC = self._stopPLC_real
else:
# If python plugin is not enabled, we reuse _PythonIterator
# as a call that block pythonthread until StopPLC
self.PythonIteratorLock = Lock()
self.PythonIteratorLock.acquire()
def PythonIterator(res):
self.PythonIteratorLock.acquire()
self.PythonIteratorLock.release()
return None
self._PythonIterator = PythonIterator
def __StopPLC():
self._stopPLC_real()
self.PythonIteratorLock.release()
self._stopPLC = __StopPLC
self._ResetDebugVariables = self.PLClibraryHandle.ResetDebugVariables
self._ResetDebugVariables.restype = None
self._RegisterDebugVariable = self.PLClibraryHandle.RegisterDebugVariable
self._RegisterDebugVariable.restype = None
self._RegisterDebugVariable.argtypes = [ctypes.c_int, ctypes.c_void_p]
self._FreeDebugData = self.PLClibraryHandle.FreeDebugData
self._FreeDebugData.restype = None
self._GetDebugData = self.PLClibraryHandle.GetDebugData
self._GetDebugData.restype = ctypes.c_int
self._GetDebugData.argtypes = [ctypes.POINTER(ctypes.c_uint32), ctypes.POINTER(ctypes.c_uint32), ctypes.POINTER(ctypes.c_void_p)]
self._suspendDebug = self.PLClibraryHandle.suspendDebug
self._suspendDebug.restype = None
self._suspendDebug.argtypes = [ctypes.c_int]
self._resumeDebug = self.PLClibraryHandle.resumeDebug
self._resumeDebug.restype = None
return True
except:
PLCprint(traceback.format_exc())
return False
def _FreePLC(self):
"""
Unload PLC library.
This is also called by __init__ to create dummy C func proxies
"""
self.PLClibraryLock.acquire()
# Forget all refs to library
self._startPLC = lambda:None
self._stopPLC = lambda:None
self._ResetDebugVariables = lambda:None
self._RegisterDebugVariable = lambda x, y:None
self._IterDebugData = lambda x,y:None
self._FreeDebugData = lambda:None
self._GetDebugData = lambda:-1
self._suspendDebug = lambda x:None
self._resumeDebug = lambda:None
self._PythonIterator = lambda:""
self.PLClibraryHandle = None
# Unload library explicitely
if getattr(self,"_PLClibraryHandle",None) is not None:
dlclose(self._PLClibraryHandle)
self._PLClibraryHandle = None
self.PLClibraryLock.release()
return False
def PrepareRuntimePy(self):
self.python_threads_vars = globals().copy()
self.python_threads_vars["WorkingDir"] = self.workingdir
self.python_threads_vars["website"] = self.website
self.python_threads_vars["_runtime_begin"] = []
self.python_threads_vars["_runtime_cleanup"] = []
for filename in os.listdir(self.workingdir):
name, ext = os.path.splitext(filename)
if name.upper().startswith("RUNTIME") and ext.upper() == ".PY":
try:
# TODO handle exceptions in runtime.py
# pyfile may redefine _runtime_cleanup
# or even call _PythonThreadProc itself.
execfile(os.path.join(self.workingdir, filename), self.python_threads_vars)
except:
PLCprint(traceback.format_exc())
runtime_begin = self.python_threads_vars.get("_%s_begin" % name, None)
if runtime_begin is not None:
self.python_threads_vars["_runtime_begin"].append(runtime_begin)
runtime_cleanup = self.python_threads_vars.get("_%s_cleanup" % name, None)
if runtime_cleanup is not None:
self.python_threads_vars["_runtime_cleanup"].append(runtime_cleanup)
for runtime_begin in self.python_threads_vars.get("_runtime_begin", []):
runtime_begin()
if self.website is not None:
self.website.PLCStarted()
def FinishRuntimePy(self):
for runtime_cleanup in self.python_threads_vars.get("_runtime_cleanup", []):
runtime_cleanup()
if self.website is not None:
self.website.PLCStopped()
self.python_threads_vars = None
def PythonThreadProc(self):
c_argv = ctypes.c_char_p * len(self.argv)
error = None
if self._LoadNewPLC():
if self._startPLC(len(self.argv),c_argv(*self.argv)) == 0:
self.PLCStatus = "Started"
self.StatusChange()
self.evaluator(self.PrepareRuntimePy)
res,cmd = "None","None"
while True:
#print "_PythonIterator(", res, ")",
cmd = self._PythonIterator(res)
#print " -> ", cmd
if cmd is None:
break
try :
res = str(self.evaluator(eval,cmd,self.python_threads_vars))
except Exception,e:
res = "#EXCEPTION : "+str(e)
PLCprint(res)
self.PLCStatus = "Stopped"
self.StatusChange()
self.evaluator(self.FinishRuntimePy)
else:
error = "starting"
else:
error = "loading"
if error is not None:
PLCprint("Problem %s PLC"%error)
self.PLCStatus = "Broken"
self._FreePLC()
def StartPLC(self):
PLCprint("StartPLC")
if self.CurrentPLCFilename is not None and self.PLCStatus == "Stopped":
self.PLCStatus = "Started"
self.PythonThread = Thread(target=self.PythonThreadProc)
self.PythonThread.start()
def StopPLC(self):
PLCprint("StopPLC")
if self.PLCStatus == "Started":
self.PLCStatus = "Stopped"
self._stopPLC()
return True
return False
def _Reload(self):
self.daemon.shutdown(True)
self.daemon.sock.close()
os.execv(sys.executable,[sys.executable]+sys.argv[:])
# never reached
return 0
def ForceReload(self):
# respawn python interpreter
Timer(0.1,self._Reload).start()
return True
def GetPLCstatus(self):
return self.PLCStatus
def NewPLC(self, md5sum, data, extrafiles):
PLCprint("NewPLC (%s)"%md5sum)
if self.PLCStatus in ["Stopped", "Empty", "Broken"]:
NewFileName = md5sum + lib_ext
extra_files_log = os.path.join(self.workingdir,"extra_files.txt")
try:
os.remove(os.path.join(self.workingdir,
self.CurrentPLCFilename))
for filename in file(extra_files_log, "r").readlines() + [extra_files_log]:
try:
os.remove(os.path.join(self.workingdir, filename.strip()))
except:
pass
except:
pass
try:
# Create new PLC file
open(os.path.join(self.workingdir,NewFileName),
'wb').write(data)
# Store new PLC filename based on md5 key
open(self._GetMD5FileName(), "w").write(md5sum)
# Then write the files
log = file(extra_files_log, "w")
for fname,fdata in extrafiles:
fpath = os.path.join(self.workingdir,fname)
open(fpath, "wb").write(fdata)
log.write(fname+'\n')
# Store new PLC filename
self.CurrentPLCFilename = NewFileName
except:
PLCprint(traceback.format_exc())
return False
if self.PLCStatus == "Empty":
self.PLCStatus = "Stopped"
return True
return False
def MatchMD5(self, MD5):
try:
last_md5 = open(self._GetMD5FileName(), "r").read()
return last_md5 == MD5
except:
return False
def SetTraceVariablesList(self, idxs):
"""
Call ctype imported function to append
these indexes to registred variables in PLC debugger
"""
if idxs:
# suspend but dont disable
self._suspendDebug(False)
# keep a copy of requested idx
self._Idxs = idxs[:]
self._ResetDebugVariables()
for idx,iectype,force in idxs:
if force !=None:
c_type,unpack_func, pack_func = \
self.TypeTranslator.get(iectype,
(None,None,None))
force = ctypes.byref(pack_func(c_type,force))
self._RegisterDebugVariable(idx, force)
self._resumeDebug()
else:
self._suspendDebug(True)
self._Idxs = []
def GetTraceVariables(self):
"""
Return a list of variables, corresponding to the list of required idx
"""
if self.PLCStatus == "Started":
res=[]
tick = ctypes.c_uint32()
size = ctypes.c_uint32()
buffer = ctypes.c_void_p()
offset = 0
if self.PLClibraryLock.acquire(False) and \
self._GetDebugData(ctypes.byref(tick),
ctypes.byref(size),
ctypes.byref(buffer)) == 0 :
if size.value:
for idx, iectype, forced in self._Idxs:
cursor = ctypes.c_void_p(buffer.value + offset)
c_type,unpack_func, pack_func = \
self.TypeTranslator.get(iectype,
(None,None,None))
if c_type is not None and offset < size.value:
res.append(unpack_func(
ctypes.cast(cursor,
ctypes.POINTER(c_type)).contents))
offset += ctypes.sizeof(c_type)
else:
if c_type is None:
PLCprint("Debug error - " + iectype +
" not supported !")
#if offset >= size.value:
#PLCprint("Debug error - buffer too small ! %d != %d"%(offset, size.value))
break
self._FreeDebugData()
self.PLClibraryLock.release()
if offset and offset == size.value:
return self.PLCStatus, tick.value, res
#elif size.value:
#PLCprint("Debug error - wrong buffer unpack ! %d != %d"%(offset, size.value))
return self.PLCStatus, None, []