1

import ctypes

     2

from LPCProto import *

     3

     4

LPC_STATUS={0x01 : "Started",

     5

            0x02 : "Stopped"}

     6

     7

class LPCAppProto(LPCProto):

     8

    def HandleTransaction(self, transaction):

     9

        self.TransactionLock.acquire()

    10

        try:

    11

            transaction.SetPseudoFile(self.serialPort)

    12

            # send command, wait ack (timeout)

    13

            transaction.SendCommand()

    14

            current_plc_status = transaction.GetCommandAck()

    15

            if current_plc_status is not None:

    16

                res = transaction.ExchangeData()

    17

            else:

    18

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

    19

        finally:

    20

            self.TransactionLock.release()

    21

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

    22

    23

class LPCAppTransaction:

    24

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

    25

        self.Command = command

    26

        self.OptData = optdata

    27

        self.pseudofile = None

    28

    29

    def SetPseudoFile(self, pseudofile):

    30

        self.pseudofile = pseudofile

    31

    32

    def SendCommand(self):

    33

        # send command thread

    34

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

    35

    36

    def GetCommandAck(self):

    37

        res = self.pseudofile.read(2)

    38

        if len(res) == 2:

    39

            comm_status, current_plc_status = map(ord, res)

    40

        else:

    41

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

    42

        # LPC returns command itself as an ack for command

    43

        if(comm_status == self.Command):

    44

            return current_plc_status

    45

        return None 

    46

    47

    def SendData(self):

    48

        length = len(self.OptData)

    49

        # transform length into a byte string

    50

        # we presuppose endianess of LPC same as PC

    51

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

    52

        buffer = lengthstr + self.OptData

    53

        return self.pseudofile.write(buffer)

    54

    55

    def GetData(self):

    56

        lengthstr = self.pseudofile.read(4)

    57

        # transform a byte string into length 

    58

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

    59

        return self.pseudofile.read(length)

    60

    61

    def ExchangeData(self): 

    62

        pass

    63

    64

class IDLETransaction(LPCAppTransaction):

    65

    def __init__(self):

    66

        LPCAppTransaction.__init__(self, 0x00)

    67

    68

class STARTTransaction(LPCAppTransaction):

    69

    def __init__(self):

    70

        LPCAppTransaction.__init__(self, 0x01)

    71

    72

class STOPTransaction(LPCAppTransaction):

    73

    def __init__(self):

    74

        LPCAppTransaction.__init__(self, 0x02)

    75

    76

class RESETTransaction(LPCAppTransaction):

    77

    def __init__(self):

    78

        LPCAppTransaction.__init__(self, 0x03)

    79

    80

class SET_TRACE_VARIABLETransaction(LPCAppTransaction):

    81

    def __init__(self, data):

    82

        LPCAppTransaction.__init__(self, 0x04, data)

    83

    ExchangeData = LPCAppTransaction.SendData

    84

    85

class GET_TRACE_VARIABLETransaction(LPCAppTransaction):

    86

    def __init__(self):

    87

        LPCAppTransaction.__init__(self, 0x05)

    88

    ExchangeData = LPCAppTransaction.GetData

    89

    90

class GET_PLCIDTransaction(LPCAppTransaction):

    91

    def __init__(self):

    92

        LPCAppTransaction.__init__(self, 0x07)

    93

    ExchangeData = LPCAppTransaction.GetData

    94

    95

if __name__ == "__main__":

    96

    TestConnection = LPCAppProto(6,115200,2)

    97

#    TestConnection.HandleTransaction(GET_PLCIDTransaction())

    98

    TestConnection.HandleTransaction(STARTTransaction())

    99

#    TestConnection.HandleTransaction(SET_TRACE_VARIABLETransaction(

   100

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

   101

#    TestConnection.HandleTransaction(STARTTransaction())

   102

    while True:

   103

        TestConnection.HandleTransaction(SET_TRACE_VARIABLETransaction(

   104

           "\x01\x00\x00\x00"+

   105

           "\x04"+

   106

           "\x01\x02\x02\x04"+

   107

           "\x01\x00\x00\x00"+

   108

           "\x08"+

   109

           "\x01\x02\x02\x04"+

   110

           "\x01\x02\x02\x04"+

   111

           "\x01\x00\x00\x00"+

   112

           "\x04"+

   113

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

   114

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

   115

    #print len(res)

   116

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

   117

    #TestConnection.HandleTransaction(STOPTransaction())