1

import serial

     2

import exceptions

     3

from threading import Lock

     4

     5

class LPCProtoError(exceptions.Exception):

     6

        """Exception class"""

     7

        def __init__(self, msg):

     8

                self.msg = msg

     9

    10

        def __str__(self):

    11

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

    12

    13

class LPCProto:

    14

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

    15

        # serialize access lock

    16

        self.TransactionLock = Lock()

    17

        # open serial port

    18

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

    19

        # Debugging serial stuff

    20

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

    21

#        class myser:

    22

#            def read(self_,cnt):

    23

#                res = self._serialPort.read(cnt)

    24

#                if len(res) > 16:

    25

#                    print "Recv :", map(hex,map(ord,res[:16])), "[...]"

    26

#                else:

    27

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

    28

#                    

    29

#                return res

    30

#            def write(self_, str):

    31

#                if len(str) > 16:

    32

#                    print "Send :", map(hex,map(ord,str[:16])), "[...]"

    33

#                else:

    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

    42

    def __del__(self):

    43

        if self.serialPort:

    44

            self.serialPort.close()

    45

    46

    def close(self):

    47

        self.serialPort.close()

    48

        self.serialPort = None