# HG changeset patch # User Lolitech # Date 1275562648 -7200 # Node ID 627e5c636a4fab23a25c5909368cf721ab5a20fc # Parent 064165a5276a4efd6a8c0b22dffa5ed66153e12e Refactored LPC connector for new bootloader and application modes diff -r 064165a5276a -r 627e5c636a4f connectors/LPC/LPCAppObject.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 + diff -r 064165a5276a -r 627e5c636a4f connectors/LPC/LPCAppProto.py --- /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()) diff -r 064165a5276a -r 627e5c636a4f connectors/LPC/LPCBootObject.py --- /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 + diff -r 064165a5276a -r 627e5c636a4f connectors/LPC/LPCBootProto.py --- /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 + diff -r 064165a5276a -r 627e5c636a4f connectors/LPC/LPCObject.py --- 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") diff -r 064165a5276a -r 627e5c636a4f connectors/LPC/LPCProto.py --- 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()) diff -r 064165a5276a -r 627e5c636a4f connectors/LPC/__init__.py --- 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) +