1

import serial

     2

import exceptions

     3

import ctypes

     4

import time

     5

from threading import Lock

     6

     7

MAX_PACKET_SIZE=64

     8

     9

LPC_STATUS={0x01 : "Started",

    10

            0x02 : "Stopped"}

    11

    12

class LPCError(exceptions.Exception):

    13

        """Exception class"""

    14

        def __init__(self, msg):

    15

                self.msg = msg

    16

                return

    17

    18

        def __str__(self):

    19

                return "LPC communication error ! " + str(self.msg)

    20

    21

class LPCProto:

    22

    def __init__(self, port, rate, timeout):

    23

        # serialize access lock

    24

        self.TransactionLock = Lock()

    25

        # open serial port

    26

#        self.serialPort = serial.Serial( port, rate, timeout = timeout )

    27

        # Debugging serial stuff

    28

        self._serialPort = serial.Serial( port, rate, timeout = timeout )

    29

        class myser:

    30

            def read(self_,cnt):

    31

                res = self._serialPort.read(cnt)

    32

                print "Recv :", map(hex,map(ord,res))

    33

                return res

    34

            def write(self_, str):

    35

                print "Send :", map(hex,map(ord,str))

    36

                self._serialPort.write(str)

    37

            def flush(self_):

    38

                self._serialPort.flush()

    39

        self.serialPort = myser()

    40

        # start with empty

    41

        self.serialPort.flush()

    42

    43

    def HandleTransaction(self, transaction):

    44

        self.TransactionLock.acquire()

    45

        try:

    46

            transaction.SetPseudoFile(self.serialPort)

    47

            # send command, wait ack (timeout)

    48

            transaction.SendCommand()

    49

            current_plc_status = transaction.GetCommandAck()

    50

            if current_plc_status is not None:

    51

                res = transaction.ExchangeData()

    52

            else:

    53

                raise LPCError("LPC transaction error - controller did not answer as expected")

    54

        finally:

    55

            self.TransactionLock.release()

    56

        return LPC_STATUS.get(current_plc_status,"Broken"), res

    57

    58

class LPCTransaction:

    59

    def __init__(self, command, optdata = ""):

    60

        self.Command = command

    61

        self.OptData = optdata

    62

        self.pseudofile = None

    63

    64

    def SetPseudoFile(self, pseudofile):

    65

        self.pseudofile = pseudofile

    66

    67

    def SendCommand(self):

    68

        # send command thread

    69

        self.pseudofile.write(chr(self.Command))

    70

    71

    def GetCommandAck(self):

    72

        res = self.pseudofile.read(2)

    73

        if len(res) == 2:

    74

            comm_status, current_plc_status = map(ord, res)

    75

        else:

    76

            raise LPCError("LPC transaction error - controller did not ack order")

    77

        # LPC returns command itself as an ack for command

    78

        if(comm_status == self.Command):

    79

            return current_plc_status

    80

        return None 

    81

    82

    def SendData(self):

    83

        length = len(self.OptData)

    84

        # transform length into a byte string

    85

        # we presuppose endianess of LPC same as PC

    86

        lengthstr = ctypes.string_at(ctypes.pointer(ctypes.c_int(length)),4)

    87

        buffer = lengthstr + self.OptData

    89

    90

    def GetData(self):

    91

        lengthstr = self.pseudofile.read(4)

    92

        # transform a byte string into length 

    93

        length = ctypes.cast(ctypes.c_char_p(lengthstr), ctypes.POINTER(ctypes.c_int)).contents.value

    94

        return self.pseudofile.read(length)

    95

    96

    def ExchangeData(self): 

    97

        pass

    98

    99

class IDLETransaction(LPCTransaction):

   100

    def __init__(self):

   101

        LPCTransaction.__init__(self, 0x00)

   102

   103

class STARTTransaction(LPCTransaction):

   104

    def __init__(self):

   105

        LPCTransaction.__init__(self, 0x01)

   106

   107

class STOPTransaction(LPCTransaction):

   108

    def __init__(self):

   109

        LPCTransaction.__init__(self, 0x02)

   110

   111

class SET_TRACE_VARIABLETransaction(LPCTransaction):

   112

    def __init__(self, data):

   113

        LPCTransaction.__init__(self, 0x04, data)

   114

    ExchangeData = LPCTransaction.SendData

   115

   116

class GET_TRACE_VARIABLETransaction(LPCTransaction):

   117

    def __init__(self):

   118

        LPCTransaction.__init__(self, 0x05)

   119

    ExchangeData = LPCTransaction.GetData

   120

   121

class GET_PLCIDTransaction(LPCTransaction):

   122

    def __init__(self):

   123

        LPCTransaction.__init__(self, 0x07)

   124

    ExchangeData = LPCTransaction.GetData

   125

   126

if __name__ == "__main__":

   127

    TestConnection = LPCProto(6,115200,2)

   128

#    TestConnection.HandleTransaction(GET_PLCIDTransaction())

   129

    TestConnection.HandleTransaction(STARTTransaction())

   130

#    TestConnection.HandleTransaction(SET_TRACE_VARIABLETransaction(

   131

#           "\x03\x00\x00\x00"*200))

   132

#    TestConnection.HandleTransaction(STARTTransaction())

   133

    while True:

   134

        TestConnection.HandleTransaction(SET_TRACE_VARIABLETransaction(

   135

           "\x01\x00\x00\x00"+

   136

           "\x04"+

   137

           "\x01\x02\x02\x04"+

   138

           "\x01\x00\x00\x00"+

   139

           "\x08"+

   140

           "\x01\x02\x02\x04"+

   141

           "\x01\x02\x02\x04"+

   142

           "\x01\x00\x00\x00"+

   143

           "\x04"+

   144

           "\x01\x02\x02\x04"))

   145

    #status,res = TestConnection.HandleTransaction(GET_TRACE_VARIABLETransaction())

   146

    #print len(res)

   147

    #print "GOT : ", map(hex, map(ord, res))

   148

    #TestConnection.HandleTransaction(STOPTransaction())