Exemple #1
0
class GoodFETMCPCANommunication:
    def __init__(self):
        self.client = GoodFETMCPCAN()
        self.client.serInit()
        self.client.MCPsetup()

    ##########################
    #   INFO
    ##########################
    #
    # Prints MCP state info
    #
    def printInfo(self):
        print "MCP2515 Info:\n\n"

        print "Mode: %s" % self.client.MCPcanstatstr()
        print "Read Status: %02x" % self.client.MCPreadstatus()
        print "Rx Status:   %02x" % self.client.MCPrxstatus()
        print "Tx Errors:  %3d" % self.client.peek8(0x1c)
        print "Rx Errors:  %3d\n" % self.client.peek8(0x1d)

        print "Timing Info:"
        print "CNF1: %02x" % self.client.peek8(0x2a)
        print "CNF2: %02x" % self.client.peek8(0x29)
        print "CNF3: %02x\n" % self.client.peek8(0x28)
        print "RXB0 CTRL: %02x" % self.client.peek8(0x60)
        print "RXB1 CTRL: %02x" % self.client.peek8(0x70)
        print "RX Buffers:"
        packet0 = self.client.readrxbuffer(0)
        packet1 = self.client.readrxbuffer(1)
        for foo in [packet0, packet1]:
            print self.client.packet2str(foo)

    def reset(self):
        self.client.MCPsetup()

    def sniff(self, freq, duration, filename, description, verbose=True):
        self.client.MCPsetrate(freq)
        outfile = open(filename, 'a')
        dataWriter = csv.writer(outfile, delimiter=',')
        dataWriter.writerow(['# Time     Error        Bytes 1-13'])
        dataWriter.writerow(['#' + description])

        client.MCPreqstatListenOnly()
        print "Listening..."
        packetcount = 0
        starttime = time.time()

        while ((time.time() - starttime < duration)):
            packet = self.client.rxpacket()
            if packet != None:
                if (verbose == True):
                    print self.client.packet2str(packet)
                packetcount += 1
                row = []
                row.append("%f" % time.time())
                if (self.client.peek8(0x2C) & 0x80):
                    self.client.MCPbitmodify(0x2C, 0x80, 0x00)
                    print "ERROR: Malformed packet recieved: " + self.client.packet2str(
                        packet)
                    row.append(1)
                else:
                    row.append(0)
                for byte in packet:
                    row.append("%02x" % ord(byte))
                dataWriter.writerow(row)

        outfile.close()
        print "Listened for %x seconds, captured %x packets." % (duration,
                                                                 packetcount)

    def sniffTest(self, freq):
        self.client.MCPsetup()

        rate = freq

        print "Calling MCPsetrate for %i." % rate
        self.client.MCPsetrate(rate)
        self.client.MCPreqstatNormal()

        print "Mode: %s" % self.client.MCPcanstatstr()
        print "CNF1: %02x" % self.client.peek8(0x2a)
        print "CNF2: %02x" % self.client.peek8(0x29)
        print "CNF3: %02x\n" % self.client.peek8(0x28)

        while (1):
            packet = self.client.rxpacket()

            if packet != None:
                if (self.client.peek8(0x2C) & 0x80):
                    self.client.MCPbitmodify(0x2C, 0x80, 0x00)
                    print "malformed packet recieved: " + self.client.packet2str(
                        packet)
                else:
                    print "properly formatted packet recieved" + self.client.packet2str(
                        packet)

    def freqtest(self, freq):
        self.client.MCPsetup()

        self.client.MCPsetrate(freq)
        self.client.MCPreqstatListenOnly()

        print "CAN Freq Test: %3d kHz" % freq

        x = 0
        errors = 0

        starttime = time.time()
        while ((time.time() - starttime < args.time)):
            packet = self.client.rxpacket()
            if packet != None:
                x += 1

                if (self.client.peek8(0x2C) & 0x80):
                    print "malformed packet recieved"
                    errors += 1
                    self.client.MCPbitmodify(0x2C, 0x80, 0x00)
                else:
                    print self.client.packet2str(packet)

        print "Results for %3.1d kHz: recieved %3d packets, registered %3d RX errors." % (
            freq, x, errors)

    def isniff(self, freq):
        """ An intelligent sniffer, decodes message format """
        """ More features to be added soon """

        self.client.MCPsetrate(freq)
        self.client.MCPreqstatListenOnly()
        while 1:
            packet = self.client.rxpacket()
            if packet != None:
                plist = []
                for byte in packet:
                    plist.append(byte)
                arbid = plist[0:2]
                eid = plist[2:4]
                dlc = plist[4:5]
                data = plist[5:13]
                print "\nArbID: " + self.client.packet2str(arbid)
                print "EID: " + self.client.packet2str(eid)
                print "DLC: " + self.client.packet2str(dlc)
                print "Data: " + self.client.packet2str(data)

    def test(self):
        print "\nMCP2515 Self Test:"

        #Switch to config mode and try to rewrite TEC.
        self.client.MCPreqstatConfiguration()
        self.client.poke8(0x00, 0xde)
        if self.client.peek8(0x00) != 0xde:
            print "ERROR: Poke to TEC failed."
        else:
            print "SUCCESS: Register read/write."

        #Switch to Loopback mode and try to catch our own packet.
        self.client.MCPreqstatLoopback()

        packet1 = [
            0x00,
            0x08,  # LOWER nibble must be 8 or greater to set EXTENDED ID 
            0x00,
            0x00,
            0x08,  # UPPER nibble must be 0 to set RTR bit for DATA FRAME
            # LOWER nibble is DLC
            0x01,
            0x02,
            0x03,
            0x04,
            0x05,
            0x06,
            0x07,
            0xFF
        ]
        self.client.txpacket(packet1)
        self.client.txpacket(packet1)
        print "Waiting on loopback packets."
        packet = None
        while (1):
            packet = self.client.rxpacket()
            if packet != None:
                print "Message recieved: %s" % self.client.packet2str(packet)
                break

    def spit(self, freq):
        self.client.MCPsetrate(freq)
        self.client.MCPreqstatNormal()

        print "Tx Errors:  %3d" % self.client.peek8(0x1c)
        print "Rx Errors:  %3d" % self.client.peek8(0x1d)
        print "Error Flags:  %02x\n" % self.client.peek8(0x2d)
        print "TXB0CTRL: %02x" % self.client.peek8(0x30)
        print "CANINTF: %02x" % self.client.peek8(0x2C)

        packet = [
            0x00,
            0x08,  # LOWER nibble must be 8 or greater to set EXTENDED ID 
            0x00,
            0x00,
            0x08,  # UPPER nibble must be 0 to set RTR bit for DATA FRAME
            # LOWER nibble is DLC
            0x01,
            0x02,
            0x03,
            0x04,
            0x05,
            0x06,
            0x07,
            0xFF
        ]

        self.client.txpacket(packet)

        if (self.client.peek8(0x2C) & 0x80) == 0x80:
            print "Error flag raised on transmission. Clearing this flag and proceeding.\n"
            print "INT Flags:  %02x" % self.client.peek8(0x2c)
            self.client.MCPbitmodify(0x2C, 0x80, 0x00)
            print "INT Flags modified to:  %02x\n" % self.client.peek8(0x2c)
            print "TXB0CTRL: %02x" % self.client.peek8(0x30)
            self.client.MCPbitmodify(0x30, 0x08, 0x00)
            print "TXB0CTRL modified to: %02x\n" % self.client.peek8(0x30)

        print "message sending attempted."
        print "Tx Errors:  %02x" % self.client.peek8(0x1c)
        print "Rx Errors:  %02x" % self.client.peek8(0x1d)
        print "Error Flags:  %02x" % self.client.peek8(0x2d)