beremiz

Some rough copy'n'paste to pave path for an LPC connector

2009-12-01, ed
8ef035de86de
Parents af3399aca7b7
Children 9d5036e86c3d
Some rough copy'n'paste to pave path for an LPC connector
3 files changed, 352 insertions(+), 0 deletions(-)
  • +177 -0
    connectors/LPC/LPCObject.py
  • +88 -0
    connectors/LPC/LPCProto.py
  • +87 -0
    connectors/LPC/__init__.py
    • --- /dev/null Thu Jan 01 00:00:00 1970 +0000
    +++ b/connectors/LPC/LPCObject.py Tue Dec 01 13:48:47 2009 +0100
    @@ -0,0 +1,177 @@
    +#!/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
    +
    +from threading import Timer, Thread, Lock
    +import ctypes, os, commands, types, sys
    +import traceback
    +
    +class LPCObject():
    + _Idxs = []
    + def __init__(self,pluginsroot):
    + self.PLCStatus = "Stopped"
    + self.pluginsroot = pluginsroot
    + self.PLCprint = pluginsroot.logger.write
    +
    + def StartPLC(self, debug=False):
    + PLCprint("StartPLC")
    + if self.CurrentPLCFilename is not None:
    + self.PLCStatus = "Started"
    + self.PythonThread = Thread(target=self.PythonThreadProc, args=[debug])
    + self.PythonThread.start()
    +
    + def StopPLC(self):
    + PLCprint("StopPLC")
    + if self.PLCStatus == "Started":
    + self._stopPLC()
    + return True
    + return False
    +
    + 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
    + """
    + self._suspendDebug()
    + # keep a copy of requested idx
    + self._Idxs = idxs[:]
    + self._ResetDebugVariables()
    + for idx in idxs:
    + self._RegisterDebugVariable(idx)
    + self._resumeDebug()
    +
    + class IEC_STRING(ctypes.Structure):
    + """
    + Must be changed according to changes in iec_types.h
    + """
    + _fields_ = [("len", ctypes.c_uint8),
    + ("body", ctypes.c_char * 127)]
    +
    + TypeTranslator = {"BOOL" : (ctypes.c_uint8, lambda x:x.value!=0),
    + "STEP" : (ctypes.c_uint8, lambda x:x.value),
    + "TRANSITION" : (ctypes.c_uint8, lambda x:x.value),
    + "ACTION" : (ctypes.c_uint8, lambda x:x.value),
    + "SINT" : (ctypes.c_int8, lambda x:x.value),
    + "USINT" : (ctypes.c_uint8, lambda x:x.value),
    + "BYTE" : (ctypes.c_uint8, lambda x:x.value),
    + "STRING" : (IEC_STRING, lambda x:x.body[:x.len]),
    + "INT" : (ctypes.c_int16, lambda x:x.value),
    + "UINT" : (ctypes.c_uint16, lambda x:x.value),
    + "WORD" : (ctypes.c_uint16, lambda x:x.value),
    + "WSTRING" : (None, None),#TODO
    + "DINT" : (ctypes.c_int32, lambda x:x.value),
    + "UDINT" : (ctypes.c_uint32, lambda x:x.value),
    + "DWORD" : (ctypes.c_uint32, lambda x:x.value),
    + "LINT" : (ctypes.c_int64, lambda x:x.value),
    + "ULINT" : (ctypes.c_uint64, lambda x:x.value),
    + "LWORD" : (ctypes.c_uint64, lambda x:x.value),
    + "REAL" : (ctypes.c_float, lambda x:x.value),
    + "LREAL" : (ctypes.c_double, lambda x:x.value),
    + }
    +
    + def GetTraceVariables(self):
    + """
    + Return a list of variables, corresponding to the list of required idx
    + """
    + if self.PLCStatus == "Started":
    + self.PLClibraryLock.acquire()
    + tick = self._WaitDebugData()
    + #PLCprint("Debug tick : %d"%tick)
    + if tick == 2**32 - 1:
    + tick = -1
    + res = None
    + else:
    + idx = ctypes.c_int()
    + typename = ctypes.c_char_p()
    + res = []
    +
    + for given_idx in self._Idxs:
    + buffer=self._IterDebugData(ctypes.byref(idx), ctypes.byref(typename))
    + c_type,unpack_func = self.TypeTranslator.get(typename.value, (None,None))
    + if c_type is not None and given_idx == idx.value:
    + res.append(unpack_func(ctypes.cast(buffer,
    + ctypes.POINTER(c_type)).contents))
    + else:
    + PLCprint("Debug error idx : %d, expected_idx %d, type : %s"%(idx.value, given_idx,typename.value))
    + res.append(None)
    + self._FreeDebugData()
    + self.PLClibraryLock.release()
    + return tick, res
    + return -1, None
    +
    --- /dev/null Thu Jan 01 00:00:00 1970 +0000
    +++ b/connectors/LPC/LPCProto.py Tue Dec 01 13:48:47 2009 +0100
    @@ -0,0 +1,88 @@
    +import serial
    +from threading import Lock
    +
    +LPC_CMDS=dict(IDLE = 0x00,
    + START = 0x01,
    + STOP = 0x02,
    + SET_TRACE_VARIABLE = 0x04,
    + GET_TRACE_VARIABLES = 0x05,
    + SET_FORCED_VARIABLE = 0x06,
    + GET_PLCID = 0x07)
    +
    +WAIT_DATA = 0x04
    +
    +LPC_STATUS=dict(STARTED = 0x01,
    + STOPPED = 0x02,
    + DEBUG = 0x03)
    +
    +class LPCError(exceptions.Exception):
    + """Exception class"""
    + def __init__(self, msg):
    + self.msg = msg
    + return
    +
    + def __str__(self):
    + return "LPC communication error ! " + str(self.msg)
    +
    +class LPCProto:
    + def __init__(self, port, rate, timeout):
    + # open serial port
    + self.serialPort = serial.Serial( port, rate, timeout = timeout )
    + self.serialPort.flush()
    + # handshake
    + self.HandleTransaction(LPCTransaction("IDLE"))
    + # serialize access lock
    + self.TransactionLock = Lock()
    +
    + def HandleTransaction(self, transaction):
    + self.TransactionLock.acquire()
    + try:
    + transaction.SetPseudoFile(self.serialPort)
    + # send command, wait ack (timeout)
    + transaction.SendCommand()
    + current_plc_status = transaction.GetCommandAck()
    + if current_plc_status is not None:
    + res = transaction.ExchangeData()
    + else:
    + raise LPCError("LPC transaction error - controller did not answer as expected")
    + finally:
    + self.TransactionLock.release()
    + return current_plc_status, res
    +
    +class LPCTransaction:
    + def __init__(self, command, optdata):
    + self.Command = LPC_CMDS[command]
    + self.OptData = optdata[:]
    + self.serialPort = None
    +
    + def SetPseudoFile(pseudofile):
    + self.pseudofile = pseudofile
    +
    + def SendCommand(self):
    + # send command thread
    + self.pseudofile.write(chr(self.Command))
    +
    + def GetCommandAck(self):
    + comm_status, current_plc_status = map(ord, self.pseudofile.read(2))
    + # LPC returns command itself as an ack for command
    + if(comm_status == self.Command):
    + return current_plc_status
    + return None
    +
    + def ExchangeData(self):
    + if self.Command & WAIT_DATA :
    + length = len(self.OptData)
    + # transform length into a byte string
    + # we presuppose endianess of LPC same as PC
    + lengthstr = ctypes.string_at(ctypes.pointer(ctypes.c_int(length)),4)
    + self.pseudofile.write(lengthstr + self.OptData)
    +
    + lengthstr = self.pseudofile.read(4)
    + # transform a byte string into length
    + length = ctypes.cast(ctypes.c_char_p(lengthstr), ctypes.POINTER(ctypes.c_int)).contents.value
    + return self.pseudofile.read(length)
    + return None
    +
    +if __name__ == "__main__":
    + TestConnection = LPCProto()
    +
    \ No newline at end of file
    --- /dev/null Thu Jan 01 00:00:00 1970 +0000
    +++ b/connectors/LPC/__init__.py Tue Dec 01 13:48:47 2009 +0100
    @@ -0,0 +1,87 @@
    +#!/usr/bin/env python
    +# -*- coding: utf-8 -*-
    +#
    +#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 traceback
    +
    +
    +def LPC_connector_factory(uri, pluginsroot):
    + """
    + This returns the connector to LPC style PLCobject
    + """
    + pluginsroot.logger.write(_("Connecting to URI : %s\n")%uri)
    +
    + servicetype, location = uri.split("://")
    +
    + # Try to get the proxy object
    + try :
    + # TODO: Open Serial Port
    + RemotePLCObjectProxy = LPCObject(pluginsroot) # LPC_PLCObject_Proxy
    + except Exception, msg:
    + pluginsroot.logger.write_error(_("Couldn't connect !\n"))
    + pluginsroot.logger.write_error(traceback.format_exc())
    + return None
    +
    + def LPCCatcher(func, default=None):
    + """
    + A function that catch a pyserial exceptions, write error to logger
    + and return defaul value when it happen
    + """
    + def catcher_func(*args,**kwargs):
    + try:
    + return func(*args,**kwargs)
    + except Exception,e:
    + #pluginsroot.logger.write_error(traceback.format_exc())
    + pluginsroot.logger.write_error(str(e)+"\n")
    + pluginsroot._connector = None
    + return default
    + return catcher_func
    +
    + # Check connection is effective.
    + # lambda is for getattr of GetPLCstatus to happen inside catcher
    + if LPCCatcher(lambda:RemotePLCObjectProxy.GetPLCstatus())() == None:
    + pluginsroot.logger.write_error(_("Cannot get PLC status - connection failed.\n"))
    + return None
    +
    +
    + class LPCProxy:
    + """
    + A Serial proxy class to handle Beremiz Pyro interface specific behavior.
    + And to put LPC exception catcher in between caller and pyro proxy
    + """
    + def _LPCGetTraceVariables(self):
    + return self.RemotePLCObjectProxy.GetTraceVariables()
    + GetTraceVariables = LPCCatcher(_LPCGetTraceVariables,("Broken",None,None))
    +
    + def _LPCGetPLCstatus(self):
    + return RemotePLCObjectProxy.GetPLCstatus()
    + GetPLCstatus = LPCCatcher(_LPCGetPLCstatus, "Broken")
    +
    + def __getattr__(self, attrName):
    + member = self.__dict__.get(attrName, None)
    + if member is None:
    + def my_local_func(*args,**kwargs):
    + return RemotePLCObjectProxy.__getattr__(attrName)(*args,**kwargs)
    + member = LPCCatcher(my_local_func, None)
    + self.__dict__[attrName] = member
    + return member
    +
    + return LPCProxy()
    +
    +