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):
"""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):
# serialize access lock
self.TransactionLock = Lock()
# open serial port
# self.serialPort = serial.Serial( port, rate, timeout = timeout )
# Debugging serial stuff
self._serialPort = serial.Serial( port, rate, timeout = timeout )
class myser:
def read(self_,cnt):
res = self._serialPort.read(cnt)
print "Recv :", map(hex,map(ord,res))
return res
def write(self_, str):
print "Send :", map(hex,map(ord,str))
self._serialPort.write(str)
def flush(self_):
self._serialPort.flush()
self.serialPort = myser()
# 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())