1

import serial

     2

import exceptions

     3

import ctypes

     4

import time

     5

from threading import Lock

     6

     7

LPC_STATUS=dict(STARTED = 0x01,

     8

                STOPPED = 0x02,

     9

                DEBUG = 0x03)

    10

    11

class LPCError(exceptions.Exception):

    12

        """Exception class"""

    13

        def __init__(self, msg):

    14

                self.msg = msg

    15

                return

    16

    17

        def __str__(self):

    18

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

    19

    20

class LPCProto:

    21

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

    22

        # serialize access lock

    23

        self.TransactionLock = Lock()

    24

        # open serial port

    25

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

    26

        # Debugging serial stuff

    27

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

    28

        class myser:

    29

            def read(self_,cnt):

    30

                res = self._serialPort.read(cnt)

    31

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

    32

                return res

    33

            def write(self_, str):

    34

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

    35

                self._serialPort.write(str)

    36

            def flush(self_):

    37

                self._serialPort.flush()

    38

        self.serialPort = myser()

    39

        # start with empty

    40

        self.serialPort.flush()

    41

        # handshake

    42

        self.HandleTransaction(IDLETransaction())

    43

    44

    def HandleTransaction(self, transaction):

    45

        self.TransactionLock.acquire()

    46

        try:

    47

            transaction.SetPseudoFile(self.serialPort)

    48

            # send command, wait ack (timeout)

    49

            transaction.SendCommand()

    50

            current_plc_status = transaction.GetCommandAck()

    51

            if current_plc_status is not None:

    52

                res = transaction.ExchangeData()

    53

            else:

    54

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

    55

        finally:

    56

            self.TransactionLock.release()

    57

        return current_plc_status, res

    58

    59

class LPCTransaction:

    60

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

    61

        self.Command = command

    62

        self.OptData = optdata

    63

        self.pseudofile = None

    64

    65

    def SetPseudoFile(self, pseudofile):

    66

        self.pseudofile = pseudofile

    67

    68

    def SendCommand(self):

    69

        # send command thread

    70

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

    71

    72

    def GetCommandAck(self):

    73

        res = self.pseudofile.read(2)

    74

        if len(res) == 2:

    75

            comm_status, current_plc_status = map(ord, res)

    76

        else:

    77

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

    78

        # LPC returns command itself as an ack for command

    79

        if(comm_status == self.Command):

    80

            return current_plc_status

    81

        return None 

    82

    83

    def SendData(self):

    84

        length = len(self.OptData)

    85

        # transform length into a byte string

    86

        # we presuppose endianess of LPC same as PC

    87

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

    88

        self.pseudofile.write(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 SET_FORCED_VARIABLETransaction(LPCTransaction):

   122

    def __init__(self, data):

   123

        LPCTransaction.__init__(self, 0x06, data)

   124

    ExchangeData = LPCTransaction.SendData

   125

   126

class GET_PLCIDTransaction(LPCTransaction):

   127

    def __init__(self):

   128

        LPCTransaction.__init__(self, 0x07)

   129

    ExchangeData = LPCTransaction.GetData

   130

   131

if __name__ == "__main__":

   132

    TestConnection = LPCProto(6,115200,2)

   133

    #TestConnection.HandleTransaction(GET_PLCIDTransaction())

   134

    TestConnection.HandleTransaction(STARTTransaction())

   135

    TestConnection.HandleTransaction(SET_TRACE_VARIABLETransaction(

   136

           "\x03\x00\x00\x00"))

   137

    TestConnection.HandleTransaction(STARTTransaction())

   138

    while True:

   139

        time.sleep(0.5)

   140

        TestConnection.HandleTransaction(SET_TRACE_VARIABLETransaction(

   141

           "\x01\x00\x00\x00"*31))

   142

   #print map(hex,map(ord,TestConnection.HandleTransaction(GET_TRACE_VARIABLETransaction())))

   143

    #TestConnection.HandleTransaction(STOPTransaction())