git.rot13.org Git - goodfet/blob - client/GoodFETMCPCANCommunication.py

   1 #!/usr/bin/env python
   2 # GoodFET SPI Flash Client
   3 #
   4 # (C) 2012 Travis Goodspeed <travis at radiantmachines.com>
   5 #
   6 #
   7 # Ted's working copy
   8 #   1) getting hot reads on frequency
   9 #   2) allow sniffing in "normal" mode to get ack bits
  10 #       --check if that's whats causing error flags in board-to-board transmission
  11 #
  12 #
  13
  14 import sys;
  15 import binascii;
  16 import array;
  17 import csv, time, argparse;
  18 import datetime
  19
  20 from GoodFETMCPCAN import GoodFETMCPCAN;
  21 from intelhex import IntelHex;
  22
  23 class GoodFETMCPCANCommunication:
  24
  25     def __init__(self, filename=None):
  26        self.client=GoodFETMCPCAN();
  27        self.client.serInit()
  28        self.client.MCPsetup();
  29
  30        if( filname == None):
  31            # create a filename with today's date
  32            now = datetime.datetime.now()
  33            self.filename = "../../contrib/ThayerData/"
  34            self.filename += now.strftime("%Y%m%d")
  35        else:
  36            self.filename=filename
  37
  38     ##########################
  39     #   INFO
  40     ##########################
  41     #
  42     # Prints MCP state info
  43     #
  44     def printInfo(self):
  45         print "MCP2515 Info:\n\n";
  46
  47         print "Mode: %s" % self.client.MCPcanstatstr();
  48         print "Read Status: %02x" % self.client.MCPreadstatus();
  49         print "Rx Status:   %02x" % self.client.MCPrxstatus();
  50         print "Tx Errors:  %3d" % self.client.peek8(0x1c);
  51         print "Rx Errors:  %3d\n" % self.client.peek8(0x1d);
  52
  53         print "Timing Info:";
  54         print "CNF1: %02x" %self.client.peek8(0x2a);
  55         print "CNF2: %02x" %self.client.peek8(0x29);
  56         print "CNF3: %02x\n" %self.client.peek8(0x28);
  57         print "RXB0 CTRL: %02x" %self.client.peek8(0x60);
  58         print "RXB1 CTRL: %02x" %self.client.peek8(0x70);
  59         print "RX Buffers:"
  60         packet0=self.client.readrxbuffer(0);
  61         packet1=self.client.readrxbuffer(1);
  62         for foo in [packet0, packet1]:
  63            print self.client.packet2str(foo);
  64
  65     def reset(self):
  66         self.client.MCPsetup();
  67
  68     def sniff(self,freq,duration,description, verbose=True, comment=None):
  69         self.client.MCPsetrate(freq);
  70         outfile = open(self.filename,'a');
  71         dataWriter = csv.writer(outfile,delimiter=',');
  72         dataWriter.writerow(['# Time     Error        Bytes 1-13']);
  73         dataWriter.writerow(['#' + description])
  74
  75         self.client.MCPreqstatListenOnly();
  76         print "Listening...";
  77         packetcount = 0;
  78         starttime = time.time();
  79
  80         while((time.time()-starttime < duration)):
  81             packet=self.client.rxpacket();
  82             if packet!=None:
  83                 if( verbose==True):
  84                     print self.client.packet2str(packet)
  85                 packetcount+=1;
  86                 row = [];
  87                 row.append("%f"%time.time());
  88                 if (self.client.peek8(0x2C) & 0x80):
  89                     self.client.MCPbitmodify(0x2C,0x80,0x00);
  90                     print "ERROR: Malformed packet recieved: " + self.client.packet2str(packet);
  91                     row.append(1);
  92                 else:
  93                     row.append(0);
  94
  95                 #write comment
  96                 row.append(comment)
  97                 for byte in packet:
  98                     row.append("%02x"%ord(byte));
  99                 dataWriter.writerow(row);
 100
 101         outfile.close()
 102         print "Listened for %x seconds, captured %x packets." %(duration,packetcount);
 103
 104
 105
 106     def sniffTest(self, freq):
 107         self.client.MCPsetup();
 108
 109         rate = freq;
 110
 111         print "Calling MCPsetrate for %i." %rate;
 112         self.client.MCPsetrate(rate);
 113         self.client.MCPreqstatNormal();
 114
 115         print "Mode: %s" % self.client.MCPcanstatstr();
 116         print "CNF1: %02x" %self.client.peek8(0x2a);
 117         print "CNF2: %02x" %self.client.peek8(0x29);
 118         print "CNF3: %02x\n" %self.client.peek8(0x28);
 119
 120         while(1):
 121             packet=self.client.rxpacket();
 122
 123             if packet!=None:
 124                 if (self.client.peek8(0x2C) & 0x80):
 125                     self.client.MCPbitmodify(0x2C,0x80,0x00);
 126                     print "malformed packet recieved: "+ self.client.packet2str(packet);
 127                 else:
 128                     print "properly formatted packet recieved" + self.client.packet2str(packet);
 129
 130
 131     def freqtest(self,freq):
 132         self.client.MCPsetup();
 133
 134         self.client.MCPsetrate(freq);
 135         self.client.MCPreqstatListenOnly();
 136
 137         print "CAN Freq Test: %3d kHz" %freq;
 138
 139         x = 0;
 140         errors = 0;
 141
 142         starttime = time.time();
 143         while((time.time()-starttime < args.time)):
 144             packet=self.client.rxpacket();
 145             if packet!=None:
 146                 x+=1;
 147
 148                 if (self.client.peek8(0x2C) & 0x80):
 149                     print "malformed packet recieved"
 150                     errors+=1;
 151                     self.client.MCPbitmodify(0x2C,0x80,0x00);
 152                 else:
 153                     print self.client.packet2str(packet);
 154
 155         print "Results for %3.1d kHz: recieved %3d packets, registered %3d RX errors." %(freq, x, errors);
 156
 157
 158     def isniff(self,freq):
 159         """ An intelligent sniffer, decodes message format """
 160         """ More features to be added soon """
 161
 162         self.client.MCPsetrate(freq);
 163         self.client.MCPreqstatListenOnly();
 164         while 1:
 165             packet=self.client.rxpacket();
 166             if packet!=None:
 167                 plist=[];
 168                 for byte in packet:
 169                     plist.append(byte);
 170                 arbid=plist[0:2];
 171                 eid=plist[2:4];
 172                 dlc=plist[4:5];
 173                 data=plist[5:13];
 174                 print "\nArbID: " + self.client.packet2str(arbid);
 175                 print "EID: " + self.client.packet2str(eid);
 176                 print "DLC: " + self.client.packet2str(dlc);
 177                 print "Data: " + self.client.packet2str(data);
 178
 179     def test(self):
 180         print "\nMCP2515 Self Test:";
 181
 182         #Switch to config mode and try to rewrite TEC.
 183         self.client.MCPreqstatConfiguration();
 184         self.client.poke8(0x00,0xde);
 185         if self.client.peek8(0x00)!=0xde:
 186             print "ERROR: Poke to TEC failed.";
 187         else:
 188             print "SUCCESS: Register read/write.";
 189
 190         #Switch to Loopback mode and try to catch our own packet.
 191         self.client.MCPreqstatLoopback();
 192
 193         packet1 = [0x00,
 194                    0x08, # LOWER nibble must be 8 or greater to set EXTENDED ID
 195                    0x00, 0x00,
 196                    0x08, # UPPER nibble must be 0 to set RTR bit for DATA FRAME
 197                          # LOWER nibble is DLC
 198                    0x01,0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0xFF]
 199         self.client.txpacket(packet1);
 200         self.client.txpacket(packet1);
 201         print "Waiting on loopback packets.";
 202         packet=None;
 203         while(1):
 204             packet=self.client.rxpacket();
 205             if packet!=None:
 206                 print "Message recieved: %s" % self.client.packet2str(packet);
 207                 break;
 208
 209
 210     def spit(self,freq):
 211         self.client.MCPsetrate(freq);
 212         self.client.MCPreqstatNormal();
 213
 214         print "Tx Errors:  %3d" % self.client.peek8(0x1c);
 215         print "Rx Errors:  %3d" % self.client.peek8(0x1d);
 216         print "Error Flags:  %02x\n" % self.client.peek8(0x2d);
 217         print "TXB0CTRL: %02x" %self.client.peek8(0x30);
 218         print "CANINTF: %02x"  %self.client.peek8(0x2C);
 219
 220
 221         packet = [0x00,
 222                    0x08, # LOWER nibble must be 8 or greater to set EXTENDED ID
 223                    0x00, 0x00,
 224                    0x08, # UPPER nibble must be 0 to set RTR bit for DATA FRAME
 225                       # LOWER nibble is DLC
 226                    0x01,0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0xFF]
 227
 228         self.client.txpacket(packet);
 229
 230         if(self.client.peek8(0x2C)&0x80)==0x80:
 231             print "Error flag raised on transmission. Clearing this flag and proceeding.\n"
 232             print "INT Flags:  %02x" % self.client.peek8(0x2c);
 233             self.client.MCPbitmodify(0x2C,0x80,0x00);
 234             print "INT Flags modified to:  %02x\n" % self.client.peek8(0x2c);
 235             print "TXB0CTRL: %02x" %self.client.peek8(0x30);
 236             self.client.MCPbitmodify(0x30,0x08,0x00);
 237             print "TXB0CTRL modified to: %02x\n" %self.client.peek8(0x30);
 238
 239         print "message sending attempted.";
 240         print "Tx Errors:  %02x" % self.client.peek8(0x1c);
 241         print "Rx Errors:  %02x" % self.client.peek8(0x1d);
 242         print "Error Flags:  %02x" % self.client.peek8(0x2d);
 243
 244
 245
 246 if __name__ == "__main__":
 247
 248     parser = argparse.ArgumentParser(formatter_class=argparse.RawDescriptionHelpFormatter,description='''\
 249
 250         Run commands on the MCP2515. Valid commands are:
 251
 252             info
 253             test
 254             peek 0x(start) [0x(stop)]
 255             reset
 256
 257             sniff
 258             freqtest
 259             snifftest
 260             spit
 261         ''')
 262
 263
 264     parser.add_argument('verb', choices=['info', 'test','peek', 'reset', 'sniff', 'freqtest','snifftest', 'spit']);
 265     parser.add_argument('-f', '--freq', type=int, default=500, help='The desired frequency (kHz)', choices=[100, 125, 250, 500, 1000]);
 266     parser.add_argument('-t','--time', type=int, default=15, help='The duration to run the command (s)');
 267     parser.add_argument('-o', '--output', default="../../contrib/ted/sniff_out.csv",help='Output file');
 268     parser.add_argument("-d", "--description", help='Description of experiment (included in the output file)', default="");
 269     parser.add_argument('-v',"--verbose",action='store_false',help='-v will stop packet output to terminal', default=True);
 270     parser.add_argument('-c','--comment', help='Comment attached to ech packet uploaded',default=None);
 271
 272     args = parser.parse_args();
 273     freq = args.freq
 274     duration = args.time
 275     filename = args.output
 276     description = args.description
 277     verbose = args.verbose
 278     comments = args.comment
 279
 280     comm = GoodFETMCPCANCommunication();
 281
 282     ##########################
 283     #   INFO
 284     ##########################
 285     #
 286     # Prints MCP state info
 287     #
 288     if(args.verb=="info"):
 289         comm.printInfo()
 290
 291
 292     ##########################
 293     #   RESET
 294     ##########################
 295     #
 296     #
 297
 298     if(args.verb=="reset"):
 299         comm.reset()
 300
 301     ##########################
 302     #   SNIFF
 303     ##########################
 304     #
 305     #   runs in ListenOnly mode
 306     #   utility function to pull info off the car's CAN bus
 307     #
 308
 309     if(args.verb=="sniff"):
 310         comm.sniff(freq=freq,duration=duration,filename=filename,description=description,verbose=verbose,comment=comments)
 311
 312
 313
 314     ##########################
 315     #   SNIFF TEST
 316     ##########################
 317     #
 318     #   runs in NORMAL mode
 319     #   intended for NETWORKED MCP chips to verify proper operation
 320     #
 321
 322     if(args.verb=="snifftest"):
 323         comm.sniffTest(freq=freq)
 324
 325     ##########################
 326     #   FREQ TEST
 327     ##########################
 328     #
 329     #   runs in LISTEN ONLY mode
 330     #   tests bus for desired frequency --> sniffs bus for specified length of time and reports
 331     #   if packets were properly formatted
 332     #
 333     #
 334
 335     if(args.verb=="freqtest"):
 336         comm.freqtest(freq=freq)
 337
 338     ##########################
 339     #   iSniff
 340     ##########################
 341     #
 342     #    """ An intelligent sniffer, decodes message format """
 343     #    """ More features to be added soon """
 344     if(args.verb=="isniff"):
 345         comm.isniff(freq=freq)
 346
 347
 348     ##########################
 349     #   MCP TEST
 350     ##########################
 351     #
 352     #   Runs in LOOPBACK mode
 353     #   self-check diagnostic
 354     #   wasn't working before due to improperly formatted packet
 355     #
 356     #   ...add automatic packet check rather than making user verify successful packet
 357     if(args.verb=="test"):
 358         comm.test()
 359
 360
 361     if(args.verb=="peek"):
 362         start=0x0000;
 363         if(len(sys.argv)>2):
 364             start=int(sys.argv[2],16);
 365         stop=start;
 366         if(len(sys.argv)>3):
 367             stop=int(sys.argv[3],16);
 368         print "Peeking from %04x to %04x." % (start,stop);
 369         while start<=stop:
 370             print "%04x: %02x" % (start,client.peek8(start));
 371             start=start+1;
 372
 373     ##########################
 374     #   SPIT
 375     ##########################
 376     #
 377     #   Basic packet transmission
 378     #   runs in NORMAL MODE!
 379     #
 380     #   checking TX error flags--> currently throwing error flags on every
 381     #   transmission (travis thinks this is because we're sniffing in listen-only
 382     #   and thus not generating an ack bit on the recieving board)
 383     if(args.verb=="spit"):
 384         comm.spit(freq=freq)
 385
 386
 387
 388
 389
 390
 391
 392
 393
 394