beremiz

Refactored LPC connector for new bootloader and application modes

2010-06-03, Lolitech
627e5c636a4f
Parents 064165a5276a
Children 093a20ea5ffc
Refactored LPC connector for new bootloader and application modes
7 files changed, 395 insertions(+), 280 deletions(-)
  • +157 -0
    connectors/LPC/LPCAppObject.py
  • +117 -0
    connectors/LPC/LPCAppProto.py
  • +52 -0
    connectors/LPC/LPCBootObject.py
  • +34 -0
    connectors/LPC/LPCBootProto.py
  • +17 -153
    connectors/LPC/LPCObject.py
  • +10 -117
    connectors/LPC/LPCProto.py
  • +8 -10
    connectors/LPC/__init__.py
    • --- /dev/null Thu Jan 01 00:00:00 1970 +0000
    +++ b/connectors/LPC/LPCAppObject.py Thu Jun 03 12:57:28 2010 +0200
    @@ -0,0 +1,157 @@
    +#!/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 ctypes
    +from LPCAppProto import *
    +from LPCObject import *
    +
    +class LPCAppObject(LPCObject):
    + def connect(self,comport):
    + self.SerialConnection = LPCAppProto(comport,#number
    + 115200, #speed
    + 2) #timeout
    + self.HandleSerialTransaction(IDLETransaction())
    +
    + def HandleSerialTransaction(self, transaction):
    + if self.SerialConnection is not None:
    + try:
    + self.PLCStatus, res = self.SerialConnection.HandleTransaction(transaction)
    + return res
    + except LPCError,e:
    + self.pluginsroot.logger.write_error(str(e)+"\n")
    + self.SerialConnection = None
    + self.PLCStatus = "Disconnected"
    + return None
    +
    + def StartPLC(self, debug=False):
    + PLCprint("StartPLC")
    + self.HandleSerialTransaction(STARTTransaction())
    +
    + def StopPLC(self):
    + PLCprint("StopPLC")
    + self.HandleSerialTransaction(STOPTransaction())
    +
    + def GetPLCstatus(self):
    + self.HandleSerialTransaction(RESETTransaction())
    + return self.PLCStatus
    +
    + def ResetPLC(self):
    + self.HandleSerialTransaction(IDLETransaction())
    + return self.PLCStatus
    +
    + def MatchMD5(self, MD5):
    + data = self.HandleSerialTransaction(GET_PLCIDTransaction())
    + print "PLCINFO",data[32:]
    + return data[:32] == MD5
    +
    + class IEC_STRING(ctypes.Structure):
    + """
    + Must be changed according to changes in iec_types.h
    + """
    + _fields_ = [("len", ctypes.c_uint8),
    + ("body", ctypes.c_char * 126)]
    +
    + TypeTranslator = {"BOOL" : (ctypes.c_uint8, lambda x:x.value!=0, lambda t,x:t(x)),
    + "STEP" : (ctypes.c_uint8, lambda x:x.value, lambda t,x:t(x)),
    + "TRANSITION" : (ctypes.c_uint8, lambda x:x.value, lambda t,x:t(x)),
    + "ACTION" : (ctypes.c_uint8, lambda x:x.value, lambda t,x:t(x)),
    + "SINT" : (ctypes.c_int8, lambda x:x.value, lambda t,x:t(x)),
    + "USINT" : (ctypes.c_uint8, lambda x:x.value, lambda t,x:t(x)),
    + "BYTE" : (ctypes.c_uint8, lambda x:x.value, lambda t,x:t(x)),
    + "STRING" : (IEC_STRING, lambda x:x.body[:x.len], lambda t,x:t(len(x),x)),
    + "INT" : (ctypes.c_int16, lambda x:x.value, lambda t,x:t(x)),
    + "UINT" : (ctypes.c_uint16, lambda x:x.value, lambda t,x:t(x)),
    + "WORD" : (ctypes.c_uint16, lambda x:x.value, lambda t,x:t(x)),
    + "WSTRING" : (None, None, None),#TODO
    + "DINT" : (ctypes.c_int32, lambda x:x.value, lambda t,x:t(x)),
    + "UDINT" : (ctypes.c_uint32, lambda x:x.value, lambda t,x:t(x)),
    + "DWORD" : (ctypes.c_uint32, lambda x:x.value, lambda t,x:t(x)),
    + "LINT" : (ctypes.c_int64, lambda x:x.value, lambda t,x:t(x)),
    + "ULINT" : (ctypes.c_uint64, lambda x:x.value, lambda t,x:t(x)),
    + "LWORD" : (ctypes.c_uint64, lambda x:x.value, lambda t,x:t(x)),
    + "REAL" : (ctypes.c_float, lambda x:x.value, lambda t,x:t(x)),
    + "LREAL" : (ctypes.c_double, lambda x:x.value, lambda t,x:t(x)),
    + }
    +
    + def SetTraceVariablesList(self, idxs):
    + """
    + Call ctype imported function to append
    + these indexes to registred variables in PLC debugger
    + """
    + if idxs:
    + buff = ""
    + # keep a copy of requested idx
    + self._Idxs = idxs[:]
    + for idx,iectype,force in idxs:
    + idxstr = ctypes.string_at(
    + ctypes.pointer(
    + ctypes.c_uint32(length)),4)
    + if force !=None:
    + c_type,unpack_func, pack_func = self.TypeTranslator.get(iectype, (None,None,None))
    + forcedsizestr = chr(ctypes.sizeof(c_type))
    + forcestr = ctypes.string_at(
    + ctypes.pointer(
    + pack_func(c_type,force)),
    + forced_type_size)
    + buff += idxstr + forced_type_size_str + forcestr
    + else:
    + buff += idxstr + chr(0)
    + data = self.HandleSerialTransaction(
    + SET_TRACE_VARIABLETransaction(buff))
    + else:
    + self._Idxs = []
    +
    + def GetTraceVariables(self):
    + """
    + Return a list of variables, corresponding to the list of required idx
    + """
    + offset = 0
    + strbuf = self.HandleSerialTransaction(
    + GET_TRACE_VARIABLETransaction())
    + size = len(strbuf) - 4
    + if size > 0 and self.PLCStatus == "Started":
    + tick = ctypes.cast(
    + ctypes.c_char_p(strbuf[:4]),
    + ctypes.POINTER(ctypes.c_int)).contents
    + buffer = ctypes.cast(
    + ctypes.c_char_p(strbuf[4:]),
    + ctypes.c_void_p)
    + 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:
    + 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:
    + PLCprint("Debug error - buffer too small !")
    + break
    + if offset and offset == size:
    + return self.PLCStatus, tick.value, res
    + PLCprint("Debug error - wrong buffer unpack !")
    + return self.PLCStatus, None, None
    +
    --- /dev/null Thu Jan 01 00:00:00 1970 +0000
    +++ b/connectors/LPC/LPCAppProto.py Thu Jun 03 12:57:28 2010 +0200
    @@ -0,0 +1,117 @@
    +import ctypes
    +from LPCProto import *
    +
    +LPC_STATUS={0x01 : "Started",
    + 0x02 : "Stopped"}
    +
    +class LPCAppProto(LPCProto):
    + 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 LPCProtoError("LPC transaction error - controller did not answer as expected")
    + finally:
    + self.TransactionLock.release()
    + return LPC_STATUS.get(current_plc_status,"Broken"), res
    +
    +class LPCAppTransaction:
    + def __init__(self, command, optdata = ""):
    + self.Command = command
    + self.OptData = optdata
    + self.pseudofile = None
    +
    + def SetPseudoFile(self, pseudofile):
    + self.pseudofile = pseudofile
    +
    + def SendCommand(self):
    + # send command thread
    + self.pseudofile.write(chr(self.Command))
    +
    + def GetCommandAck(self):
    + res = self.pseudofile.read(2)
    + if len(res) == 2:
    + comm_status, current_plc_status = map(ord, res)
    + else:
    + raise LPCProtoError("LPC transaction error - controller did not ack order")
    + # LPC returns command itself as an ack for command
    + if(comm_status == self.Command):
    + return current_plc_status
    + return None
    +
    + def SendData(self):
    + 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)
    + buffer = lengthstr + self.OptData
    + return self.pseudofile.write(buffer)
    +
    + def GetData(self):
    + 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)
    +
    + def ExchangeData(self):
    + pass
    +
    +class IDLETransaction(LPCAppTransaction):
    + def __init__(self):
    + LPCAppTransaction.__init__(self, 0x00)
    +
    +class STARTTransaction(LPCAppTransaction):
    + def __init__(self):
    + LPCAppTransaction.__init__(self, 0x01)
    +
    +class STOPTransaction(LPCAppTransaction):
    + def __init__(self):
    + LPCAppTransaction.__init__(self, 0x02)
    +
    +class RESETTransaction(LPCAppTransaction):
    + def __init__(self):
    + LPCAppTransaction.__init__(self, 0x03)
    +
    +class SET_TRACE_VARIABLETransaction(LPCAppTransaction):
    + def __init__(self, data):
    + LPCAppTransaction.__init__(self, 0x04, data)
    + ExchangeData = LPCAppTransaction.SendData
    +
    +class GET_TRACE_VARIABLETransaction(LPCAppTransaction):
    + def __init__(self):
    + LPCAppTransaction.__init__(self, 0x05)
    + ExchangeData = LPCAppTransaction.GetData
    +
    +class GET_PLCIDTransaction(LPCAppTransaction):
    + def __init__(self):
    + LPCAppTransaction.__init__(self, 0x07)
    + ExchangeData = LPCAppTransaction.GetData
    +
    +if __name__ == "__main__":
    + TestConnection = LPCAppProto(6,115200,2)
    +# TestConnection.HandleTransaction(GET_PLCIDTransaction())
    + TestConnection.HandleTransaction(STARTTransaction())
    +# TestConnection.HandleTransaction(SET_TRACE_VARIABLETransaction(
    +# "\x03\x00\x00\x00"*200))
    +# TestConnection.HandleTransaction(STARTTransaction())
    + while True:
    + TestConnection.HandleTransaction(SET_TRACE_VARIABLETransaction(
    + "\x01\x00\x00\x00"+
    + "\x04"+
    + "\x01\x02\x02\x04"+
    + "\x01\x00\x00\x00"+
    + "\x08"+
    + "\x01\x02\x02\x04"+
    + "\x01\x02\x02\x04"+
    + "\x01\x00\x00\x00"+
    + "\x04"+
    + "\x01\x02\x02\x04"))
    + #status,res = TestConnection.HandleTransaction(GET_TRACE_VARIABLETransaction())
    + #print len(res)
    + #print "GOT : ", map(hex, map(ord, res))
    + #TestConnection.HandleTransaction(STOPTransaction())
    --- /dev/null Thu Jan 01 00:00:00 1970 +0000
    +++ b/connectors/LPC/LPCBootObject.py Thu Jun 03 12:57:28 2010 +0200
    @@ -0,0 +1,52 @@
    +#!/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 LPCBootProto import *
    +from LPCObject import *
    +
    +class LPCBootObject(LPCObject):
    + def __init__(self, pluginsroot, comportstr):
    + LPCObject.__init__(self, pluginsroot, comportstr)
    + self.successfully_transfered = False
    +
    + def connect(self,comport):
    + self.SerialConnection = LPCBootProto(comport,#number
    + 115200, #speed
    + 120) #timeout
    + self.PLCStatus = "Stopped"
    +
    + def NewPLC(self, md5sum, data, extrafiles):
    + self.successfully_transfered = self.HandleSerialTransaction(LOADTransaction(data))
    + return successfully_transfered
    +
    + def MatchMD5(self, MD5):
    + return self.successfully_transfered
    +
    +
    + def SetTraceVariablesList(self, idxs):
    + pass
    +
    + def GetTraceVariables(self):
    + return self.PLCStatus, None, None
    +
    --- /dev/null Thu Jan 01 00:00:00 1970 +0000
    +++ b/connectors/LPC/LPCBootProto.py Thu Jun 03 12:57:28 2010 +0200
    @@ -0,0 +1,34 @@
    +from LPCProto import *
    +
    +class LPCBootProto(LPCProto):
    + def HandleTransaction(self, transaction):
    + self.TransactionLock.acquire()
    + try:
    + transaction.SetPseudoFile(self.serialPort)
    + res = transaction.ExchangeData()
    + finally:
    + self.TransactionLock.release()
    + return "Stopped", res
    +
    +class LPCBootTransaction:
    + def __init__(self, optdata = ""):
    + self.OptData = optdata
    + self.pseudofile = None
    +
    + def SetPseudoFile(self, pseudofile):
    + self.pseudofile = pseudofile
    +
    + def SendData(self):
    + return self.pseudofile.write(self.OptData) == len(self.OptData)
    +
    + def GetData(self):
    + pass # not impl
    +
    + def ExchangeData(self):
    + pass
    +
    +class LOADTransaction(LPCBootTransaction):
    + def __init__(self, data):
    + LPCBootTransaction.__init__(self, data)
    + ExchangeData = LPCBootTransaction.SendData
    +
    --- a/connectors/LPC/LPCObject.py Thu Jun 03 12:56:21 2010 +0200
    +++ b/connectors/LPC/LPCObject.py Thu Jun 03 12:57:28 2010 +0200
    @@ -22,187 +22,51 @@
    #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 ctypes, os, commands, types, sys
    from LPCProto import *
    class LPCObject():
    - def __init__(self,pluginsroot, location):
    + def __init__(self, pluginsroot, comportstr):
    self.PLCStatus = "Disconnected"
    self.pluginsroot = pluginsroot
    self.PLCprint = pluginsroot.logger.write
    self._Idxs = []
    - self.UpdateLocation(location)
    + comport = int(comportstr[3:comportstr.index(':')]) - 1
    + try:
    + self.connect(comportstr)
    + except Exception,e:
    + self.pluginsroot.logger.write_error(str(e)+"\n")
    + self.SerialConnection = None
    + self.PLCStatus = "Disconnected"
    - def UpdateLocation(self, location):
    - # Is that a comport ?
    - if len(location) == 5 and\
    - location.startswith("COM") and \
    - location[3].isdigit() and \
    - location[4]==":" :
    - self.StorageConnection = None
    - try:
    - comport = int(location[3]) - 1
    - self.SerialConnection = LPCProto(comport,#number
    - 115200, #speed
    - 2) #timeout
    - # This will update status
    - self.HandleSerialTransaction(IDLETransaction())
    - except Exception,e:
    - self.pluginsroot.logger.write_error(str(e)+"\n")
    - self.SerialConnection = None
    - self.PLCStatus = "Disconnected"
    - # or a drive unit ?
    - elif len(location)==2 and \
    - location[0].isalpha() and \
    - location[1] == ':' :
    - self.SerialConnection = None
    - if os.path.exists(location):
    - self.StorageConnection = location
    - self.PLCStatus = "Stopped"
    - else:
    - self.pluginsroot.logger.write_error("Drive "+
    - location+
    - " do not exist !\n")
    - self.StorageConnection = None
    - self.PLCStatus = "Disconnected"
    -
    def HandleSerialTransaction(self, transaction):
    if self.SerialConnection is not None:
    try:
    self.PLCStatus, res = self.SerialConnection.HandleTransaction(transaction)
    return res
    - except LPCError,e:
    + except LPCProtoError,e:
    self.pluginsroot.logger.write_error(str(e)+"\n")
    self.SerialConnection = None
    self.PLCStatus = "Disconnected"
    return None
    -
    +
    def StartPLC(self, debug=False):
    - PLCprint("StartPLC")
    - self.HandleSerialTransaction(STARTTransaction())
    + raise LPCProtoError("Not implemented")
    def StopPLC(self):
    - PLCprint("StopPLC")
    - self.HandleSerialTransaction(STOPTransaction())
    -
    - def ForceReload(self):
    - pass
    + raise LPCProtoError("Not implemented")
    def GetPLCstatus(self):
    - self.HandleSerialTransaction(IDLETransaction())
    - return self.PLCStatus
    + raise LPCProtoError("Not implemented")
    def NewPLC(self, md5sum, data, extrafiles):
    - if os.path.exists(self.StorageConnection):
    - firmwarepath = os.path.join(
    - self.StorageConnection,
    - "firmware.bin")
    - try:
    - if os.path.exists(firmwarepath ):
    - os.unlink(firmwarepath)
    - f = open(firmwarepath, "wb")
    - f.write(data)
    - f.close()
    - return True
    - except LPCError,e:
    - self.StorageConnection = None
    - self.PLCStatus = "Disconnected"
    - self.pluginsroot.logger.write_error(
    - "LPC transfer error : "+
    - str(e)+"\n")
    + raise LPCProtoError("Not implemented")
    def MatchMD5(self, MD5):
    - data = self.HandleSerialTransaction(GET_PLCIDTransaction())
    - print "PLCINFO",data[32:]
    - return data[:32] == MD5
    -
    - class IEC_STRING(ctypes.Structure):
    - """
    - Must be changed according to changes in iec_types.h
    - """
    - _fields_ = [("len", ctypes.c_uint8),
    - ("body", ctypes.c_char * 126)]
    -
    - TypeTranslator = {"BOOL" : (ctypes.c_uint8, lambda x:x.value!=0, lambda t,x:t(x)),
    - "STEP" : (ctypes.c_uint8, lambda x:x.value, lambda t,x:t(x)),
    - "TRANSITION" : (ctypes.c_uint8, lambda x:x.value, lambda t,x:t(x)),
    - "ACTION" : (ctypes.c_uint8, lambda x:x.value, lambda t,x:t(x)),
    - "SINT" : (ctypes.c_int8, lambda x:x.value, lambda t,x:t(x)),
    - "USINT" : (ctypes.c_uint8, lambda x:x.value, lambda t,x:t(x)),
    - "BYTE" : (ctypes.c_uint8, lambda x:x.value, lambda t,x:t(x)),
    - "STRING" : (IEC_STRING, lambda x:x.body[:x.len], lambda t,x:t(len(x),x)),
    - "INT" : (ctypes.c_int16, lambda x:x.value, lambda t,x:t(x)),
    - "UINT" : (ctypes.c_uint16, lambda x:x.value, lambda t,x:t(x)),
    - "WORD" : (ctypes.c_uint16, lambda x:x.value, lambda t,x:t(x)),
    - "WSTRING" : (None, None, None),#TODO
    - "DINT" : (ctypes.c_int32, lambda x:x.value, lambda t,x:t(x)),
    - "UDINT" : (ctypes.c_uint32, lambda x:x.value, lambda t,x:t(x)),
    - "DWORD" : (ctypes.c_uint32, lambda x:x.value, lambda t,x:t(x)),
    - "LINT" : (ctypes.c_int64, lambda x:x.value, lambda t,x:t(x)),
    - "ULINT" : (ctypes.c_uint64, lambda x:x.value, lambda t,x:t(x)),
    - "LWORD" : (ctypes.c_uint64, lambda x:x.value, lambda t,x:t(x)),
    - "REAL" : (ctypes.c_float, lambda x:x.value, lambda t,x:t(x)),
    - "LREAL" : (ctypes.c_double, lambda x:x.value, lambda t,x:t(x)),
    - }
    + raise LPCProtoError("Not implemented")
    def SetTraceVariablesList(self, idxs):
    - """
    - Call ctype imported function to append
    - these indexes to registred variables in PLC debugger
    - """
    - if idxs:
    - buff = ""
    - # keep a copy of requested idx
    - self._Idxs = idxs[:]
    - for idx,iectype,force in idxs:
    - idxstr = ctypes.string_at(
    - ctypes.pointer(
    - ctypes.c_uint32(length)),4)
    - if force !=None:
    - c_type,unpack_func, pack_func = self.TypeTranslator.get(iectype, (None,None,None))
    - forcedsizestr = chr(ctypes.sizeof(c_type))
    - forcestr = ctypes.string_at(
    - ctypes.pointer(
    - pack_func(c_type,force)),
    - forced_type_size)
    - buff += idxstr + forced_type_size_str + forcestr
    - else:
    - buff += idxstr + chr(0)
    - data = self.HandleSerialTransaction(
    - SET_TRACE_VARIABLETransaction(buff))
    - else:
    - self._Idxs = []
    + raise LPCProtoError("Not implemented")
    def GetTraceVariables(self):
    - """
    - Return a list of variables, corresponding to the list of required idx
    - """
    - offset = 0
    - strbuf = self.HandleSerialTransaction(
    - GET_TRACE_VARIABLETransaction())
    - size = len(strbuf) - 4
    - if size > 0 and self.PLCStatus == "Started":
    - tick = ctypes.cast(
    - ctypes.c_char_p(strbuf[:4]),
    - ctypes.POINTER(ctypes.c_int)).contents
    - buffer = ctypes.cast(
    - ctypes.c_char_p(strbuf[4:]),
    - ctypes.c_void_p)
    - 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:
    - 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:
    - PLCprint("Debug error - buffer too small !")
    - break
    - if offset and offset == size:
    - return self.PLCStatus, tick.value, res
    - PLCprint("Debug error - wrong buffer unpack !")
    - return self.PLCStatus, None, None
    + raise LPCProtoError("Not implemented")
    --- a/connectors/LPC/LPCProto.py Thu Jun 03 12:56:21 2010 +0200
    +++ b/connectors/LPC/LPCProto.py Thu Jun 03 12:57:28 2010 +0200
    @@ -1,19 +1,11 @@
    import serial
    import exceptions
    -import ctypes
    -import time
    from threading import Lock
    -MAX_PACKET_SIZE=64
    -
    -LPC_STATUS={0x01 : "Started",
    - 0x02 : "Stopped"}
    -
    -class LPCError(exceptions.Exception):
    +class LPCProtoError(exceptions.Exception):
    """Exception class"""
    def __init__(self, msg):
    self.msg = msg
    - return
    def __str__(self):
    return "LPC communication error ! " + str(self.msg)
    @@ -29,10 +21,17 @@
    class myser:
    def read(self_,cnt):
    res = self._serialPort.read(cnt)
    - print "Recv :", map(hex,map(ord,res))
    + if len(res) > 16:
    + print "Recv :", map(hex,map(ord,res[:16])), "[...]"
    + else:
    + print "Recv :", map(hex,map(ord,res))
    +
    return res
    def write(self_, str):
    - print "Send :", map(hex,map(ord,str))
    + if len(str) > 16:
    + print "Send :", map(hex,map(ord,str[:16])), "[...]"
    + else:
    + print "Send :", map(hex,map(ord,str))
    self._serialPort.write(str)
    def flush(self_):
    self._serialPort.flush()
    @@ -40,109 +39,3 @@
    # start with empty
    self.serialPort.flush()
    - 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 LPC_STATUS.get(current_plc_status,"Broken"), res
    -
    -class LPCTransaction:
    - def __init__(self, command, optdata = ""):
    - self.Command = command
    - self.OptData = optdata
    - self.pseudofile = None
    -
    - def SetPseudoFile(self, pseudofile):
    - self.pseudofile = pseudofile
    -
    - def SendCommand(self):
    - # send command thread
    - self.pseudofile.write(chr(self.Command))
    -
    - def GetCommandAck(self):
    - res = self.pseudofile.read(2)
    - if len(res) == 2:
    - comm_status, current_plc_status = map(ord, res)
    - else:
    - raise LPCError("LPC transaction error - controller did not ack order")
    - # LPC returns command itself as an ack for command
    - if(comm_status == self.Command):
    - return current_plc_status
    - return None
    -
    - def SendData(self):
    - 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)
    - buffer = lengthstr + self.OptData
    - return self.pseudofile.write(buffer)
    -
    - def GetData(self):
    - 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)
    -
    - def ExchangeData(self):
    - pass
    -
    -class IDLETransaction(LPCTransaction):
    - def __init__(self):
    - LPCTransaction.__init__(self, 0x00)
    -
    -class STARTTransaction(LPCTransaction):
    - def __init__(self):
    - LPCTransaction.__init__(self, 0x01)
    -
    -class STOPTransaction(LPCTransaction):
    - def __init__(self):
    - LPCTransaction.__init__(self, 0x02)
    -
    -class SET_TRACE_VARIABLETransaction(LPCTransaction):
    - def __init__(self, data):
    - LPCTransaction.__init__(self, 0x04, data)
    - ExchangeData = LPCTransaction.SendData
    -
    -class GET_TRACE_VARIABLETransaction(LPCTransaction):
    - def __init__(self):
    - LPCTransaction.__init__(self, 0x05)
    - ExchangeData = LPCTransaction.GetData
    -
    -class GET_PLCIDTransaction(LPCTransaction):
    - def __init__(self):
    - LPCTransaction.__init__(self, 0x07)
    - ExchangeData = LPCTransaction.GetData
    -
    -if __name__ == "__main__":
    - TestConnection = LPCProto(6,115200,2)
    -# TestConnection.HandleTransaction(GET_PLCIDTransaction())
    - TestConnection.HandleTransaction(STARTTransaction())
    -# TestConnection.HandleTransaction(SET_TRACE_VARIABLETransaction(
    -# "\x03\x00\x00\x00"*200))
    -# TestConnection.HandleTransaction(STARTTransaction())
    - while True:
    - TestConnection.HandleTransaction(SET_TRACE_VARIABLETransaction(
    - "\x01\x00\x00\x00"+
    - "\x04"+
    - "\x01\x02\x02\x04"+
    - "\x01\x00\x00\x00"+
    - "\x08"+
    - "\x01\x02\x02\x04"+
    - "\x01\x02\x02\x04"+
    - "\x01\x00\x00\x00"+
    - "\x04"+
    - "\x01\x02\x02\x04"))
    - #status,res = TestConnection.HandleTransaction(GET_TRACE_VARIABLETransaction())
    - #print len(res)
    - #print "GOT : ", map(hex, map(ord, res))
    - #TestConnection.HandleTransaction(STOPTransaction())
    --- a/connectors/LPC/__init__.py Thu Jun 03 12:56:21 2010 +0200
    +++ b/connectors/LPC/__init__.py Thu Jun 03 12:57:28 2010 +0200
    @@ -19,19 +19,17 @@
    #License along with this library; if not, write to the Free Software
    #Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
    -permanant_connector = None
    -
    def LPC_connector_factory(uri, pluginsroot):
    """
    This returns the connector to LPC style PLCobject
    """
    - from LPCObject import LPCObject
    - global permanant_connector
    servicetype, location = uri.split("://")
    - if permanant_connector is None:
    - permanant_connector = LPCObject(pluginsroot,location)
    - else:
    - permanant_connector.UpdateLocation(location)
    - return permanant_connector
    -
    + mode,comportstr = location.split('/')
    + if mode=="APPLICATION":
    + from LPCAppObject import LPCAppObject
    + return LPCAppObject(pluginsroot,comportstr)
    + elif mode=="BOOTLOADER":
    + from LPCBootObject import LPCBootObject
    + return LPCBootObject(pluginsroot,comportstr)
    +