1

import ctypes

     2

from LPCProto import *

     3

     4

LPC_STATUS={0xaa : "Started",

     5

            0x55 : "Stopped"}

     6

     7

class LPCAppProto(LPCProto):

     8

    def HandleTransaction(self, transaction):

     9

        try:

    10

            transaction.SetPseudoFile(self.serialPort)

    11

            # send command, wait ack (timeout)

    12

            transaction.SendCommand()

    13

            current_plc_status = transaction.GetCommandAck()

    14

            if current_plc_status is not None:

    15

                res = transaction.ExchangeData()

    16

            else:

    17

                raise LPCProtoError("controller did not answer as expected")

    18

        except Exception, e:

    19

            raise LPCProtoError("application mode transaction error : "+str(e))

    20

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

    21

    22

class LPCAppTransaction:

    23

    def __init__(self, command):

    24

        self.Command = command

    25

        self.pseudofile = None

    26

    27

    def SetPseudoFile(self, pseudofile):

    28

        self.pseudofile = pseudofile

    29

    30

    def SendCommand(self):

    31

        # send command thread

    32

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

    33

    34

    def GetCommandAck(self):

    35

        res = self.pseudofile.read(2)

    36

        if len(res) == 2:

    37

            comm_status, current_plc_status = map(ord, res)

    38

        else:

    39

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

    40

        # LPC returns command itself as an ack for command

    41

        if(comm_status == self.Command):

    42

            return current_plc_status

    43

        return None 

    44

    45

    def SendData(self, Data):

    46

        return self.pseudofile.write(Data)

    47

    48

    def GetData(self):

    49

        lengthstr = self.pseudofile.read(4)

    50

        # transform a byte string into length 

    51

        length = ctypes.cast(

    52

            ctypes.c_char_p(lengthstr), 

    53

            ctypes.POINTER(ctypes.c_uint32)).contents.value

    54

        return self.pseudofile.read(length)

    55

    56

    def ExchangeData(self): 

    57

        pass

    58

    59

class IDLETransaction(LPCAppTransaction):

    60

    def __init__(self):

    61

        LPCAppTransaction.__init__(self, 0x07)

    62

    ExchangeData = LPCAppTransaction.GetData

    63

    64

class STARTTransaction(LPCAppTransaction):

    65

    def __init__(self):

    66

        LPCAppTransaction.__init__(self, 0x01)

    67

    68

class STOPTransaction(LPCAppTransaction):

    69

    def __init__(self):

    70

        LPCAppTransaction.__init__(self, 0x02)

    71

    72

class RESETTransaction(LPCAppTransaction):

    73

    def __init__(self):

    74

        LPCAppTransaction.__init__(self, 0x03)

    75

    76

class SET_TRACE_VARIABLETransaction(LPCAppTransaction):

    77

    def __init__(self, data):

    78

        LPCAppTransaction.__init__(self, 0x04)

    79

        length = len(data)

    80

        # transform length into a byte string

    81

        # we presuppose endianess of LPC same as PC

    82

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

    83

        self.Data = lengthstr + data

    84

    85

    def ExchangeData(self):

    86

        self.SendData(self.Data)

    87

    88

class GET_TRACE_VARIABLETransaction(LPCAppTransaction):

    89

    def __init__(self):

    90

        LPCAppTransaction.__init__(self, 0x05)

    91

    ExchangeData = LPCAppTransaction.GetData

    92

    93

class GET_PLCIDTransaction(LPCAppTransaction):

    94

    def __init__(self):

    95

        LPCAppTransaction.__init__(self, 0x07)

    96

    ExchangeData = LPCAppTransaction.GetData

    97

    98

class GET_LOGCOUNTSTransaction(LPCAppTransaction):

    99

    def __init__(self):

   100

        LPCAppTransaction.__init__(self, 0x0B)

   101

    ExchangeData = LPCAppTransaction.GetData

   102

   103

class GET_LOGMSGTransaction(LPCAppTransaction):

   104

    def __init__(self,level,msgid):

   105

        LPCAppTransaction.__init__(self, 0x0C)

   106

        msgidstr = ctypes.string_at(ctypes.pointer(ctypes.c_int(msgid)),4)

   107

        self.Data = chr(level)+msgidstr

   108

   109

    def ExchangeData(self):

   110

        self.SendData(self.Data)

   111

        return self.GetData()

   112

   113

if __name__ == "__main__":

   114

    __builtins__.BMZ_DBG = True

   115

    TestConnection = LPCAppProto(6,115200,2)

   116

#    TestConnection.HandleTransaction(GET_PLCIDTransaction())

   117

    TestConnection.HandleTransaction(STARTTransaction())

   118

#    TestConnection.HandleTransaction(SET_TRACE_VARIABLETransaction(

   119

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

   120

#    TestConnection.HandleTransaction(STARTTransaction())

   121

    while True:

   122

        TestConnection.HandleTransaction(SET_TRACE_VARIABLETransaction(

   123

           "\x01\x00\x00\x00"+

   124

           "\x04"+

   125

           "\x01\x02\x02\x04"+

   126

           "\x01\x00\x00\x00"+

   127

           "\x08"+

   128

           "\x01\x02\x02\x04"+

   129

           "\x01\x02\x02\x04"+

   130

           "\x01\x00\x00\x00"+

   131

           "\x04"+

   132

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

   133

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

   134

    #print len(res)

   135

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

   136

    #TestConnection.HandleTransaction(STOPTransaction())