1

import serial

     2

from threading import Lock

     3

     4

LPC_CMDS=dict(IDLE = 0x00,

     5

              START = 0x01,

     6

              STOP = 0x02,

     7

              SET_TRACE_VARIABLE = 0x04,

     8

              GET_TRACE_VARIABLES = 0x05,

     9

              SET_FORCED_VARIABLE = 0x06,

    10

              GET_PLCID = 0x07)

    11

    12

WAIT_DATA = 0x04

    13

    14

LPC_STATUS=dict(STARTED = 0x01,

    15

                STOPPED = 0x02,

    16

                DEBUG = 0x03)

    17

    18

class LPCError(exceptions.Exception):

    19

        """Exception class"""

    20

        def __init__(self, msg):

    21

                self.msg = msg

    22

                return

    23

    24

        def __str__(self):

    25

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

    26

    27

class LPCProto:

    28

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

    29

        # open serial port

    30

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

    31

        self.serialPort.flush()

    32

        # handshake

    33

        self.HandleTransaction(LPCTransaction("IDLE"))

    34

        # serialize access lock

    35

        self.TransactionLock = Lock()

    36

    37

    def HandleTransaction(self, transaction):

    38

        self.TransactionLock.acquire()

    39

        try:

    40

            transaction.SetPseudoFile(self.serialPort)

    41

            # send command, wait ack (timeout)

    42

            transaction.SendCommand()

    43

            current_plc_status = transaction.GetCommandAck()

    44

            if current_plc_status is not None:

    45

                res = transaction.ExchangeData()

    46

            else:

    47

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

    48

        finally:

    49

            self.TransactionLock.release()

    50

        return current_plc_status, res

    51

    52

class LPCTransaction:

    53

    def __init__(self, command, optdata):

    54

        self.Command =  LPC_CMDS[command]

    55

        self.OptData = optdata[:]

    56

        self.serialPort = None

    57

    58

    def SetPseudoFile(pseudofile):

    59

        self.pseudofile = pseudofile

    60

    61

    def SendCommand(self):

    62

        # send command thread

    63

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

    64

    65

    def GetCommandAck(self):

    66

        comm_status, current_plc_status = map(ord, self.pseudofile.read(2))

    67

        # LPC returns command itself as an ack for command

    68

        if(comm_status == self.Command):

    69

            return current_plc_status

    70

        return None 

    71

    72

    def ExchangeData(self):

    73

        if self.Command & WAIT_DATA :

    74

            length = len(self.OptData)

    75

            # transform length into a byte string

    76

            # we presuppose endianess of LPC same as PC

    77

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

    78

            self.pseudofile.write(lengthstr + self.OptData)

    79

    80

            lengthstr = self.pseudofile.read(4)

    81

            # transform a byte string into length 

    82

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

    83

            return self.pseudofile.read(length)

    84

        return None

    85

    86

if __name__ == "__main__":

    87

    TestConnection = LPCProto()

    88