debuggin of some gui methods
[goodfet] / 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 import os
20 from random import randrange
21 from GoodFETMCPCAN import GoodFETMCPCAN;
22 from intelhex import IntelHex;
23 import Queue
24
25 class GoodFETMCPCANCommunication:
26     
27     def __init__(self, dataLocation):
28        self.client=GoodFETMCPCAN();
29        """ Communication with the bus"""
30        self.client.serInit()
31        self.client.MCPsetup();
32        #self.DATA_LOCATION = "../../contrib/ThayerData/"
33        self.DATA_LOCATION = dataLocation; 
34        """ Stores file data location. This is the root folder where basic sniffs will be stored"""
35        self.INJECT_DATA_LOCATION  = self.DATA_LOCATION+"InjectedData/" 
36        """ stores the sub folder path where injected data will be stored"""
37        
38
39     
40     def printInfo(self):
41         """ 
42         This method will print information about the board to the terminal. 
43         It is good for diagnostics
44         """
45         
46         self.client.MCPreqstatConfiguration();
47         
48         print "MCP2515 Info:\n\n";
49         
50         print "Mode: %s" % self.client.MCPcanstatstr();
51         print "Read Status: %02x" % self.client.MCPreadstatus();
52         print "Rx Status:   %02x" % self.client.MCPrxstatus();
53         print "Error Flags:  %02x" % self.client.peek8(0x2D);
54         print "Tx Errors:  %3d" % self.client.peek8(0x1c);
55         print "Rx Errors:  %3d\n" % self.client.peek8(0x1d);
56         
57         print "Timing Info:";
58         print "CNF1: %02x" %self.client.peek8(0x2a);
59         print "CNF2: %02x" %self.client.peek8(0x29);
60         print "CNF3: %02x\n" %self.client.peek8(0x28);
61         print "RXB0 CTRL: %02x" %self.client.peek8(0x60);
62         print "RXB1 CTRL: %02x" %self.client.peek8(0x70);
63         
64         print "RX Info:";
65         print "RXB0: %02x" %self.client.peek8(0x60);
66         print "RXB1: %02x" %self.client.peek8(0x70);
67         print "RXB0 masks: %02x, %02x, %02x, %02x" %(self.client.peek8(0x20), self.client.peek8(0x21), self.client.peek8(0x22), self.client.peek8(0x23));
68         print "RXB1 masks: %02x, %02x, %02x, %02x" %(self.client.peek8(0x24), self.client.peek8(0x25), self.client.peek8(0x26), self.client.peek8(0x27));
69
70         
71         print "RX Buffers:"
72         packet0=self.client.readrxbuffer(0);
73         packet1=self.client.readrxbuffer(1);
74         for foo in [packet0, packet1]:
75            print self.client.packet2str(foo);
76            
77     def reset(self):
78         """ 
79         Reset the chip
80         """
81         self.client.MCPsetup();
82     
83     
84     ##########################
85     #   SNIFF
86     ##########################
87          
88     def sniff(self,freq,duration,description, verbose=True, comment=None, filename=None, standardid=None, debug=False, faster=False, parsed=True, data = None,writeToFile=True, db0 = None, db1 = None):
89         """
90         
91         """
92         #reset eveything on the chip
93         self.client.serInit() 
94         self.reset()
95         
96         # filtering for specific packets
97         if(db0 != None and db1 != None and standardid != None):
98             self.filterForPacket(standardid[0], db0, db1, verbose)
99             if(comment == None):
100                 comment = ""
101             comment += ("f%d[%d][%d]" %(standardid[0], db0, db1))
102         # filtering for standard ID
103         elif(standardid != None):
104             self.addFilter(standardid, verbose)
105             if(comment == None):
106                 comment = ""
107                 for ID in standardid:
108                     comment += ("f%d" %(ID))
109
110                 
111         self.client.MCPsetrate(freq);
112         
113         # This will handle the files so that we do not loose them. each day we will create a new csv file
114         if( filename==None and writeToFile == True):
115             #get folder information (based on today's date)
116             now = datetime.datetime.now()
117             datestr = now.strftime("%Y%m%d")
118             path = self.DATA_LOCATION+datestr+".csv"
119             filename = path
120             
121         if( writeToFile == True):
122             outfile = open(filename,'a');
123             dataWriter = csv.writer(outfile,delimiter=',');
124             dataWriter.writerow(['# Time     Error        Bytes 1-13']);
125             dataWriter.writerow(['#' + description])
126             
127         self.client.MCPreqstatNormal();
128         print "Listening...";
129         packetcount = 0;
130         starttime = time.time();
131         
132         while((time.time()-starttime < duration)):
133             
134             if(faster):
135                 packet=self.client.fastrxpacket();
136             else:
137                 packet=self.client.rxpacket();
138                 
139             #add the data to list if the pointer was included
140             if(data != None and packet != None):
141                 #data.append(self.client.packet2parsedstr(packet))
142                 packetParsed = self.client.packet2parsed(packet)
143                 packetParsed["time"] =time.time()
144                 data.put(packetParsed)
145             if(debug == True):
146                 #check packet status
147                 MCPstatusReg = self.client.MCPrxstatus();
148                 messagestat=MCPstatusReg&0xC0;
149                 messagetype=MCPstatusReg&0x18;
150                 if(messagestat == 0xC0):
151                     print "Message in both buffers; message type is %02x (0x00 is standard data, 0x08 is standard remote)." %messagetype
152                 elif(messagestat == 0x80):
153                     print "Message in RXB1; message type is %02x (0x00 is standard data, 0x08 is standard remote)." %messagetype
154                 elif(messagestat == 0x40):
155                     print "Message in RXB0; message type is %02x (0x00 is standard data, 0x08 is standard remote)." %messagetype
156                 elif(messagestat == 0x00):
157                     print "No messages in buffers."
158             #check to see if there was a packet
159             if( packet != None):
160                 packetcount+=1;
161             if (packet!=None and writeToFile == True):
162                 
163                 row = [];
164                 row.append("%f"%time.time());
165                 
166                 if( verbose==True):
167                     #if we want to print a parsed message
168                     if( parsed == True):
169                         packetParsed = self.client.packet2parsed(packet)
170                         sId = packetParsed.get('sID')
171                         msg = "sID: %04d" %sId
172                         if( packetParsed.get('eID')):
173                             msg += " eID: %d" %packetParsed.get('eID')
174                         msg += " rtr: %d"%packetParsed['rtr']
175                         length = packetParsed['length']
176                         msg += " length: %d"%length
177                         msg += " data:"
178                         for i in range(0,length):
179                             dbidx = 'db%d'%i
180                             msg +=" %03d"% packetParsed[dbidx]
181                         #msg = self.client.packet2parsedstr(packet)
182                         print msg
183                     # if we want to print just the message as it is read off the chip
184                     else:
185                         print self.client.packet2str(packet)
186                 
187                 if(debug == True):
188                     
189                     #check overflow
190                     MCPeflgReg=self.client.peek8(0x2D);
191                     print"EFLG register equals: %x" %MCPeflgReg;
192                     if((MCPeflgReg & 0xC0)==0xC0):
193                         print "WARNING: BOTH overflow flags set. Missed a packet. Clearing and proceeding."
194                     elif(MCPeflgReg & 0x80):
195                         print "WARNING: RXB1 overflow flag set. A packet has been missed. Clearing and proceeding."
196                     elif(MCPeflgReg & 0x40):
197                         print "WARNING: RXB0 overflow flag set. A packet has been missed. Clearing and proceeding."
198                     self.client.MCPbitmodify(0x2D,0xC0,0x00);
199                     print"EFLG register set to: %x" % self.client.peek(0x2D);
200                 
201                     #check for errors
202                     if (self.client.peek8(0x2C) & 0x80):
203                         self.client.MCPbitmodify(0x2C,0x80,0x00);
204                         print "ERROR: Malformed packet recieved: " + self.client.packet2str(packet);
205                         row.append(1);
206                     else:
207                         row.append(0);
208                 else:
209                     row.append(0);  #since we don't check for errors if we're not in debug mode...
210                             
211                 row.append(comment)
212                 #how long the sniff was for
213                 row.append(duration)
214                 #boolean that tells us if there was filtering. 0 == no filters, 1 == filters
215                 if(standardid != None):
216                     row.append(1)
217                 else:
218                     row.append(0)
219                 #write packet to file
220                 for byte in packet:
221                     row.append("%02x"%ord(byte));
222                 dataWriter.writerow(row);
223         if(writeToFile == True):
224             outfile.close()
225         print "Listened for %d seconds, captured %d packets." %(duration,packetcount);
226         return packetcount
227         
228         
229 #    def filterStdSweep(self, freq, low, high, time = 5):
230 #        msgIDs = []
231 #        self.client.serInit()
232 #        self.client.MCPsetup()
233 #        for i in range(low, high+1, 6):
234 #            print "sniffing id: %d, %d, %d, %d, %d, %d" % (i,i+1,i+2,i+3,i+4,i+5)
235 #            comment= "sweepFilter: "
236 #            #comment = "sweepFilter_%d_%d_%d_%d_%d_%d" % (i,i+1,i+2,i+3,i+4,i+5)
237 #            description = "Running a sweep filer for all the possible standard IDs. This run filters for: %d, %d, %d, %d, %d, %d" % (i,i+1,i+2,i+3,i+4,i+5)
238 #            count = self.sniff(freq=freq, duration = time, description = description,comment = comment, standardid = [i, i+1, i+2, i+3, i+4, i+5])
239 #            if( count != 0):
240 #                for j in range(i,i+5):
241 #                    comment = "sweepFilter: "
242 #                    #comment = "sweepFilter: %d" % (j)
243 #                    description = "Running a sweep filer for all the possible standard IDs. This run filters for: %d " % j
244 #                    count = self.sniff(freq=freq, duration = time, description = description,comment = comment, standardid = [j, j, j, j])
245 #                    if( count != 0):
246 #                        msgIDs.append(j)
247 #        return msgIDs
248     
249 #    def sweepRandom(self, freq, number = 5, time = 200):
250 #        msgIDs = []
251 #        ids = []
252 #        self.client.serInit()
253 #        self.client.MCPsetup()
254 #        for i in range(0,number+1,6):
255 #            idsTemp = []
256 #            comment = "sweepFilter: "
257 #            for j in range(0,6,1):
258 #                id = randrange(2047)
259 #                #comment += "_%d" % id
260 #                idsTemp.append(id)
261 #                ids.append(id)
262 #            print comment
263 #            description = "Running a sweep filer for all the possible standard IDs. This runs the following : " + comment
264 #            count = self.sniff(freq=freq, duration=time, description=description, comment = comment, standardid = idsTemp)
265 #            if( count != 0):
266 #                for element in idsTemp:
267 #                    #comment = "sweepFilter: %d" % (element)
268 #                    comment="sweepFilter: "
269 #                    description = "Running a sweep filer for all the possible standard IDs. This run filters for: %d " % element
270 #                    count = self.sniff(freq=freq, duration = time, description = description,comment = comment, standardid = [element, element, element])
271 #                    if( count != 0):
272 #                        msgIDs.append(j)
273 #        return msgIDs, ids
274     
275     def sniffTest(self, freq):
276         """
277         This method will preform a test to see if we can sniff corretly formed packets from the CAN bus.
278         
279         @type freq: number
280         @param freq: frequency of the CAN bus
281         """
282         rate = freq;
283         
284         print "Calling MCPsetrate for %i." %rate;
285         self.client.MCPsetrate(rate);
286         self.client.MCPreqstatNormal();
287         
288         print "Mode: %s" % self.client.MCPcanstatstr();
289         print "CNF1: %02x" %self.client.peek8(0x2a);
290         print "CNF2: %02x" %self.client.peek8(0x29);
291         print "CNF3: %02x\n" %self.client.peek8(0x28);
292         
293         while(1):
294             packet=self.client.rxpacket();
295             
296             if packet!=None:                
297                 if (self.client.peek8(0x2C) & 0x80):
298                     self.client.MCPbitmodify(0x2C,0x80,0x00);
299                     print "malformed packet recieved: "+ self.client.packet2str(packet);
300                 else:
301                     print "properly formatted packet recieved" + self.client.packet2str(packet);
302    
303     
304     def freqtest(self,freq):
305         """
306         This method will test the frequency provided to see if it is the correct frequency for this CAN bus.
307         
308         @type freq: Number
309         @param freq: The frequency to listen to the CAN bus.
310         
311         """
312         self.client.MCPsetup();
313
314         self.client.MCPsetrate(freq);
315         self.client.MCPreqstatListenOnly();
316     
317         print "CAN Freq Test: %3d kHz" %freq;
318     
319         x = 0;
320         errors = 0;
321     
322         starttime = time.time();
323         while((time.time()-starttime < args.time)):
324             packet=self.client.rxpacket();
325             if packet!=None:
326                 x+=1;
327                 
328                 if (self.client.peek8(0x2C) & 0x80):
329                     print "malformed packet recieved"
330                     errors+=1;
331                     self.client.MCPbitmodify(0x2C,0x80,0x00);
332                 else:         
333                     print self.client.packet2str(packet);
334     
335         print "Results for %3.1d kHz: recieved %3d packets, registered %3d RX errors." %(freq, x, errors);
336     
337
338     def isniff(self,freq):
339         """ An intelligent sniffer, decodes message format """
340         """ More features to be added soon """
341         
342         self.client.MCPsetrate(freq);
343         self.client.MCPreqstatListenOnly();
344         while 1:
345             packet=self.client.rxpacket();
346             if packet!=None:
347                 plist=[];
348                 for byte in packet:
349                     plist.append(byte);
350                 arbid=plist[0:2];
351                 eid=plist[2:4];
352                 dlc=plist[4:5];
353                 data=plist[5:13];         
354                 print "\nArbID: " + self.client.packet2str(arbid);
355                 print "EID: " + self.client.packet2str(eid);
356                 print "DLC: " + self.client.packet2str(dlc);
357                 print "Data: " + self.client.packet2str(data);
358
359     def test(self):
360         """ This will perform a test on the GOODTHOPTER10. Diagnostic messages will be printed
361         out to the terminal
362         """
363         comm.reset();
364         print "Just reset..."
365         print "EFLG register:  %02x" % self.client.peek8(0x2d);
366         print "Tx Errors:  %3d" % self.client.peek8(0x1c);
367         print "Rx Errors:  %3d" % self.client.peek8(0x1d);
368         print "CANINTF: %02x"  %self.client.peek8(0x2C);
369         self.client.MCPreqstatConfiguration();
370         self.client.poke8(0x60,0x66);
371         self.client.MCPsetrate(500);
372         self.client.MCPreqstatNormal();
373         print "In normal mode now"
374         print "EFLG register:  %02x" % self.client.peek8(0x2d);
375         print "Tx Errors:  %3d" % self.client.peek8(0x1c);
376         print "Rx Errors:  %3d" % self.client.peek8(0x1d);
377         print "CANINTF: %02x"  %self.client.peek8(0x2C);
378         print "Waiting on packets.";
379         checkcount = 0;
380         packet=None;
381         while(1):
382             packet=self.client.rxpacket();
383             if packet!=None:
384                 print "Message recieved: %s" % self.client.packet2str(packet);
385             else:
386                 checkcount=checkcount+1;
387                 if (checkcount%30==0):
388                     print "EFLG register:  %02x" % self.client.peek8(0x2d);
389                     print "Tx Errors:  %3d" % self.client.peek8(0x1c);
390                     print "Rx Errors:  %3d" % self.client.peek8(0x1d);
391                     print "CANINTF: %02x"  %self.client.peek8(0x2C);
392
393     
394     
395     
396     def addFilter(self,standardid, verbose= True):
397         """ This method will configure filters on the board. Filters are positive filters meaning that they will only 
398         store messages that match the ids provided in the list of standardid. Since there are 2 buffers and due to the configuration
399         of how the filtering works (see MCP2515 documentation), at least 3 filters must be set to guarentee you do not get any
400         unwanted messages. However even with only 1 filter set you should get all messages from that ID but the other buffer will store 
401         any additional messages.
402         @type standardid: list of integers
403         @param standardid: List of standard ids that need to be set. There can be at most 6 filters set.
404         @type verbose: Boolean
405         @param verbose: If true it will print out messages and diagnostics to terminal.
406         
407         @rtype: None
408         @return: This method does not return anything
409         @todo: rename setFilters
410         """
411        
412         ### ON-CHIP FILTERING
413         if(standardid != None):
414             self.client.MCPreqstatConfiguration();  
415             self.client.poke8(0x60,0x26); # set RXB0 CTRL register to ONLY accept STANDARD messages with filter match (RXM1=0, RMX0=1, BUKT=1)
416             self.client.poke8(0x20,0xFF); #set buffer 0 mask 1 (SID 10:3) to FF
417             self.client.poke8(0x21,0xE0); #set buffer 0 mask 2 bits 7:5 (SID 2:0) to 1s
418             if(len(standardid)>2):
419                self.client.poke8(0x70,0x20); # set RXB1 CTRL register to ONLY accept STANDARD messages with filter match (RXM1=0, RMX0=1)
420                self.client.poke8(0x24,0xFF); #set buffer 1 mask 1 (SID 10:3) to FF
421                self.client.poke8(0x25,0xE0); #set buffer 1 mask 2 bits 7:5 (SID 2:0) to 1s 
422             
423             for filter,ID in enumerate(standardid):
424         
425                if (filter==0):
426                 RXFSIDH = 0x00;
427                 RXFSIDL = 0x01;
428                elif (filter==1):
429                 RXFSIDH = 0x04;
430                 RXFSIDL = 0x05;
431                elif (filter==2):
432                 RXFSIDH = 0x08;
433                 RXFSIDL = 0x09;
434                elif (filter==3):
435                 RXFSIDH = 0x10;
436                 RXFSIDL = 0x11;
437                elif (filter==4):
438                 RXFSIDH = 0x14;
439                 RXFSIDL = 0x15;
440                else:
441                 RXFSIDH = 0x18;
442                 RXFSIDL = 0x19;
443         
444                #### split SID into different regs
445                SIDlow = (ID & 0x07) << 5;  # get SID bits 2:0, rotate them to bits 7:5
446                SIDhigh = (ID >> 3) & 0xFF; # get SID bits 10:3, rotate them to bits 7:0
447                
448                #write SID to regs 
449                self.client.poke8(RXFSIDH,SIDhigh);
450                self.client.poke8(RXFSIDL, SIDlow);
451                        
452                if (verbose == True):
453                    print "Filtering for SID %d (0x%02xh) with filter #%d"%(ID, ID, filter);
454                
455         self.client.MCPreqstatNormal();
456     
457     def filterForPacket(self, standardid, DB0, DB1, verbose= True):
458         """ 
459         This method will configure filters on the board to listen for a specific packet originating 
460         from standardid with data bytes 0 and 1. It will configure all six filters, so you will not receive any other packets.
461         
462         @type standardid: integer
463         @param standardid: standardID to listen for
464         @type DB0: integer
465         @param standardid: DB0 contents to filter for
466         @type DB1: integer
467         @param standardid: DB1 contents to filter for
468         @type verbose: Boolean
469         @param verbose: If true it will print out messages and diagnostics to terminal.
470         
471         @rtype: None
472         @return: This method does not return anything
473         """
474         
475         ### ON-CHIP FILTERING
476        
477         self.client.MCPreqstatConfiguration();  
478         
479         # SID filtering: set CTRL registers to only accept standard messages
480         self.client.poke8(0x60,0x06); # set RXB0 CTRL register to ONLY accept STANDARD messages with filter match (RXM1=0, RXM=1, BUKT=1)
481         self.client.poke8(0x70,0x00); # set RXB1 CTRL register to ONLY accept STANDARD messages with filter match (RXM1=0, RXM0=1)
482
483         # Mask buffer 0 to match SID, DB0, DB1
484         self.client.poke8(0x20,0xFF); #set buffer 0 mask 1 (SID 10:3) to FF
485         self.client.poke8(0x21,0xE0); #set buffer 0 mask 2 bits 7:5 (SID 2:0) to 1s
486         self.client.poke8(0x22,0xFF); #set buffer 0 mask 3 (DB0) to FF 
487         self.client.poke8(0x23,0xFF); #set buffer 0 mask 4 (DB0) to FF
488
489         # Mask buffer 1 to match SID, DB0, DB1
490         self.client.poke8(0x24,0xFF); #set buffer 1 mask 1 (SID 10:3) to FF
491         self.client.poke8(0x25,0xE0); #set buffer 1 mask 2 bits 7:5 (SID 2:0) to 1s
492         self.client.poke8(0x26,0xFF); #set buffer 1 mask 3 (DB0) to FF
493         self.client.poke8(0x27,0xFF); #set buffer 1 mask 4 (DB1) to FF
494         
495         # Split SID into high and low bytes
496         SIDlow = (standardid & 0x07) << 5;  # get SID bits 2:0, rotate them to bits 7:5
497         SIDhigh = (standardid >> 3) & 0xFF; # get SID bits 10:3, rotate them to bits 7:0
498
499             
500         for filter in range(0,5):
501             if (filter==0):
502                 RXFSIDH = 0x00;
503                 RXFSIDL = 0x01;
504                 RXFDB0 = 0x02;
505                 RXFDB1 = 0x03;
506             elif (filter==1):
507                 RXFSIDH = 0x04;
508                 RXFSIDL = 0x05;
509                 RXFDB0 = 0x06;
510                 RXFDB1 = 0x07;
511             elif (filter==2):
512                 RXFSIDH = 0x08;
513                 RXFSIDL = 0x09;
514                 RXFDB0 = 0x0A;
515                 RXFDB1 = 0x0B;
516             elif (filter==3):
517                 RXFSIDH = 0x10;
518                 RXFSIDL = 0x11;
519                 RXFDB0 = 0x12;
520                 RXFDB1 = 0x13;
521             elif (filter==4):
522                 RXFSIDH = 0x14;
523                 RXFSIDL = 0x15;
524                 RXFDB0 = 0x16;
525                 RXFDB1 = 0x17;
526             else:
527                 RXFSIDH = 0x18;
528                 RXFSIDL = 0x19;
529                 RXFDB0 = 0x1A;
530                 RXFDB1 = 0x1B;
531             
532
533             self.client.poke8(RXFSIDH, SIDhigh);
534             self.client.poke8(RXFSIDL, SIDlow);
535             self.client.poke8(RXFDB0, DB0);
536             self.client.poke8(RXFDB1, DB1);
537                 
538             if (verbose == True):
539                 print "Filtering for SID %d DB0 %d DB1 %d with filter #%d"%(standardid, DB0, DB1, filter);
540         
541         self.client.MCPreqstatNormal();    
542    
543         
544     def spitSetup(self,freq):
545         """ 
546         This method sets up the chip for transmitting messages, but does not transmit anything itself.
547         """
548         self.reset();
549         self.client.MCPsetrate(freq);
550         self.client.MCPreqstatNormal();
551         
552     
553     def spitSingle(self,freq, standardid, repeat,writes, period = None, debug = False, packet = None):
554         """ 
555         This method will spit a single message onto the bus. If there is no packet information provided then the 
556         message will be sent as a remote transmission request (RTR). The packet length is assumed to be 8 bytes The message can be repeated given number of times with
557         a gap of period (milliseconds) between each message. This will continue for the the number of times specified in the writes input.
558         This method will setup the bus and call the spit method, L{spit}. This method includes a bus reset and initialization.
559         
560         @type freq: number
561         @param freq: The frequency of the bus
562         
563         @type standardid: list of integer
564         @param standardid: This is a single length list with one integer elment that corresponds to the standard id you wish to write to
565         
566         @type repeat: Boolean
567         @param repeat: If true the message will be repeatedly injected. if not the message will only be injected 1 time
568         
569         @type writes: Integer
570         @param writes: Number of writes of the packet
571         
572         @type period: Integer
573         @param period: Time delay between injections of the packet in Milliseconds
574         
575         @type debug: Boolean
576         @param debug: When true debug status messages will be printed to the terminal
577         
578         @type packet: List
579         @param packet: Contains the data bytes for the packet which is assumed to be of length 8. Each byte is stored as
580                        an integer and can range from 0 to 255 (8 bits). If packet == None then an RTR will be sent on the given
581                        standard id.
582         
583         """
584         self.spitSetup(freq);
585         spit(self,freq, standardid, repeat,writes,  period, debug , packet)
586
587     def spit(self,freq, standardid, repeat,writes, period = None, debug = False, packet = None):
588         """ 
589         This method will spit a single message onto the bus. If there is no packet information provided then the 
590         message will be sent as a remote transmission request (RTR). The packet length is assumed to be 8 bytes The message can be repeated a given number of times with
591         a gap of period (milliseconds) between each message. This will continue for the the number of times specified in the writes input.
592         This method does not include bus setup, it must be done before the method call.
593         
594         
595         @type freq: number
596         @param freq: The frequency of the bus
597         
598         @type standardid: list of integer
599         @param standardid: This is a single length list with one integer elment that corresponds to the standard id you wish to write to
600         
601         @type repeat: Boolean
602         @param repeat: If true the message will be repeatedly injected. if not the message will only be injected 1 time
603         
604         @type writes: Integer
605         @param writes: Number of writes of the packet
606         
607         @type period: Integer
608         @param period: Time delay between injections of the packet in Milliseconds
609         
610         @type debug: Boolean
611         @param debug: When true debug status messages will be printed to the terminal
612         
613         @type packet: List
614         @param packet: Contains the data bytes for the packet which is assumed to be of length 8. Each byte is stored as
615                        an integer and can range from 0 to 255 (8 bits). If packet == None then an RTR will be sent on the given
616                        standard id.
617         
618         """
619
620         #### split SID into different regs
621         SIDlow = (standardid[0] & 0x07) << 5;  # get SID bits 2:0, rotate them to bits 7:5
622         SIDhigh = (standardid[0] >> 3) & 0xFF; # get SID bits 10:3, rotate them to bits 7:0
623         
624         if(packet == None):
625             
626             # if no packet, RTR for inputted arbID
627             # so packet to transmit is SID + padding out EID registers + RTR request (set bit 6, clear lower nibble of DLC register)
628             packet = [SIDhigh, SIDlow, 0x00,0x00,0x40] 
629         
630         
631         else:
632
633             # if we do have a packet, packet is SID + padding out EID registers + DLC of 8 + packet
634             #
635             """@todo: allow for variable-length packets"""
636             #    TODO: allow for variable-length packets
637             #
638             packet = [SIDhigh, SIDlow, 0x00,0x00, # pad out EID regs
639                   0x08, # bit 6 must be set to 0 for data frame (1 for RTR) 
640                   # lower nibble is DLC                   
641                  packet[0],packet[1],packet[2],packet[3],packet[4],packet[5],packet[6],packet[7]]
642             
643         
644         if(debug):
645             if self.client.MCPcanstat()>>5!=0:
646                 print "Warning: currently in %s mode. NOT in normal mode! May not transmit.\n" %self.client.MCPcanstatstr();
647             print "\nInitial state:"
648             print "Tx Errors:  %3d" % self.client.peek8(0x1c);
649             print "Rx Errors:  %3d" % self.client.peek8(0x1d);
650             print "Error Flags:  %02x\n" % self.client.peek8(0x2d);
651             print "TXB0CTRL: %02x" %self.client.peek8(0x30);
652             print "CANINTF: %02x\n"  %self.client.peek8(0x2C);
653             print "\n\nATTEMPTING TRANSMISSION!!!"
654                 
655         print "Transmitting packet: "
656         #print self.client.packet2str(packet)
657                 
658         self.client.txpacket(packet);
659             
660         if repeat:
661             """@todo: the repeat variable is no longer needed and can be removed """
662             print "\nNow looping on transmit. "
663             if period != None:
664                 for i in range(0,writes):
665                     self.client.MCPrts(TXB0=True);
666                     #tic = time.time()
667                     time.sleep(period/1000) # pause for period ms before sending again
668                     #print time.time()-tic
669                 #starttime = time.time();
670                 #while((time.time()-starttime < duration)):
671                 #    self.client.MCPrts(TXB0=True);
672                 #    print "MSG printed"
673             else:
674                 for i in range(0,writes): 
675                     self.client.MCPrts(TXB0=True);
676         print "messages injected"
677         
678         # MORE DEBUGGING        
679         if(debug): 
680             checkcount = 0;
681             TXB0CTRL = self.client.peek8(0x30);
682         
683             print "Tx Errors:  %3d" % self.client.peek8(0x1c);
684             print "Rx Errors:  %3d" % self.client.peek8(0x1d);
685             print "EFLG register:  %02x" % self.client.peek8(0x2d);
686             print "TXB0CTRL: %02x" %TXB0CTRL;
687             print "CANINTF: %02x\n"  %self.client.peek8(0x2C);
688         
689             while(TXB0CTRL | 0x00 != 0x00):
690                 checkcount+=1;
691                 TXB0CTRL = self.client.peek8(0x30);
692                 if (checkcount %30 ==0):
693                     print "Tx Errors:  %3d" % self.client.peek8(0x1c);
694                     print "Rx Errors:  %3d" % self.client.peek8(0x1d);
695                     print "EFLG register:  %02x" % self.client.peek8(0x2d);
696                     print "TXB0CTRL: %02x" %TXB0CTRL;
697                     print "CANINTF: %02x\n"  %self.client.peek8(0x2C);
698
699
700     def setRate(self,freq):
701         """ 
702         This method will reset the frequency that the MCP2515 expects the CAN bus to be on.
703         
704         @type freq: Number
705         @param freq: Frequency of the CAN bus
706         """
707         self.client.MCPsetrate(freq);
708
709         
710
711     # This will write the data provided in the packets which is expected to be a list of lists
712     # of the following form:
713     # for a given row = packets[i]
714     # row[0] time delay relative to the last packet. if 0 or empty there will be no delay
715     # row[1] = Standard ID (integer)
716     # row[2] = Data Length (0-8) (if it is zero we assume an Remote Transmit Request)
717     # row[3] = Data Byte 0
718     # row[4] = Data Byte 1
719     #    .... up to Data Byte 8 ( THIS ASSUMES A PACKET OF LENGTH 8!!!
720     def writeData(self,packets,freq):
721         self.client.serInit()
722         self.spitSetup(freq)
723         for row in packets:
724             if( row[0] != 0 and row[0] != ""):
725                 time.sleep(row[0])
726             sID = row[1]
727             #### split SID into different regs
728             SIDlow = (sID & 0x07) << 5;  # get SID bits 2:0, rotate them to bits 7:5
729             SIDhigh = (sID >> 3) & 0xFF; # get SID bits 10:3, rotate them to bits 7:0
730             packet = [SIDhigh,SIDlow,0x00,0x00,0x08]
731             #dlc = row[2]
732             dlc = 8
733             for i in range(3,dlc+3):
734                 packet.append(row[i])
735             print packet
736             self.client.txpacket(packet)
737                 
738         
739         
740         
741
742 if __name__ == "__main__":  
743
744     parser = argparse.ArgumentParser(formatter_class=argparse.RawDescriptionHelpFormatter,description='''\
745     
746         Run commands on the MCP2515. Valid commands are:
747         
748             info 
749             test
750             peek 0x(start) [0x(stop)]
751             reset
752             
753             sniff 
754             freqtest
755             snifftest
756             spit
757         ''')
758         
759     
760     parser.add_argument('verb', choices=['info', 'test','peek', 'reset', 'sniff', 'freqtest','snifftest', 'spit', 'packet']);
761     parser.add_argument('-f', '--freq', type=int, default=500, help='The desired frequency (kHz)', choices=[100, 125, 250, 500, 1000]);
762     parser.add_argument('-t','--time', type=int, default=15, help='The duration to run the command (s)');
763     parser.add_argument('-o', '--output', default=None,help='Output file');
764     parser.add_argument("-d", "--description", help='Description of experiment (included in the output file)', default="");
765     parser.add_argument('-v',"--verbose",action='store_false',help='-v will stop packet output to terminal', default=True);
766     parser.add_argument('-c','--comment', help='Comment attached to ech packet uploaded',default=None);
767     parser.add_argument('-b', '--debug', action='store_true', help='-b will turn on debug mode, printing packet status', default=False);
768     parser.add_argument('-a', '--standardid', type=int, action='append', help='Standard ID to accept with filter 0 [1, 2, 3, 4, 5]', default=None);
769     parser.add_argument('-x', '--faster', action='store_true', help='-x will use "fast packet recieve," which may duplicate packets and/or cause other weird behavior.', default=False);
770     parser.add_argument('-r', '--repeat', action='store_true', help='-r with "spit" will continuously send the inputted packet. This will put the GoodTHOPTHER into an infinite loop.', default=False);
771     parser.add_argument('-db0', '--databyte0', type=int, default = None, help='-db0 to filter for a specfic data byte');
772     parser.add_argument('-db1', '--databyte1', type=int, default = None, help='-db0 to filter for a specfic data byte');
773
774     
775     
776     args = parser.parse_args();
777     freq = args.freq
778     duration = args.time
779     filename = args.output
780     description = args.description
781     verbose = args.verbose
782     comments = args.comment
783     debug = args.debug
784     standardid = args.standardid
785     faster=args.faster
786     repeat = args.repeat
787     db0 = args.databyte0
788     db1 = args.databyte1
789
790     comm = GoodFETMCPCANCommunication("./");
791     
792     if(args.verb=="packet"):
793         comm.filterForPacket(standardid=standardid[0], DB0=db0, DB1=db1, verbose= True)
794     
795     ##########################
796     #   INFO
797     ##########################
798     #
799     # Prints MCP state info
800     #
801     if(args.verb=="info"):
802         comm.printInfo()
803         
804            
805     ##########################
806     #   RESET
807     ##########################
808     #
809     #
810             
811     if(args.verb=="reset"):
812         comm.reset()
813         
814     ##########################
815     #   SNIFF
816     ##########################
817     #
818     #   runs in ListenOnly mode
819     #   utility function to pull info off the car's CAN bus
820     #
821     
822     if(args.verb=="sniff"):
823         comm.sniff(freq=freq,duration=duration,description=description,verbose=verbose,comment=comments,filename=filename, standardid=standardid, debug=debug, faster=faster, db0=db0, db1=db1)    
824                     
825     ##########################
826     #   SNIFF TEST
827     ##########################
828     #
829     #   runs in NORMAL mode
830     #   intended for NETWORKED MCP chips to verify proper operation
831     #
832        
833     if(args.verb=="snifftest"):
834         comm.sniffTest(freq=freq)
835         
836         
837     ##########################
838     #   FREQ TEST
839     ##########################
840     #
841     #   runs in LISTEN ONLY mode
842     #   tests bus for desired frequency --> sniffs bus for specified length of time and reports
843     #   if packets were properly formatted
844     #
845     #
846     
847     if(args.verb=="freqtest"):
848         comm.freqtest(freq=freq)
849
850
851
852     ##########################
853     #   iSniff
854     ##########################
855     #
856     #    """ An intelligent sniffer, decodes message format """
857     #    """ More features to be added soon """
858     if(args.verb=="isniff"):
859         comm.isniff(freq=freq)
860                 
861                 
862     ##########################
863     #   MCP TEST
864     ##########################
865     #
866     #   Runs in LOOPBACK mode
867     #   self-check diagnostic
868     #   wasn't working before due to improperly formatted packet
869     #
870     #   ...add automatic packet check rather than making user verify successful packet
871     if(args.verb=="test"):
872         comm.test()
873         
874     if(args.verb=="peek"):
875         start=0x0000;
876         if(len(sys.argv)>2):
877             start=int(sys.argv[2],16);
878         stop=start;
879         if(len(sys.argv)>3):
880             stop=int(sys.argv[3],16);
881         print "Peeking from %04x to %04x." % (start,stop);
882         while start<=stop:
883             print "%04x: %02x" % (start,client.peek8(start));
884             start=start+1;
885             
886     ##########################
887     #   SPIT
888     ##########################
889     #
890     #   Basic packet transmission
891     #   runs in NORMAL MODE!
892     # 
893     #   checking TX error flags--> currently throwing error flags on every
894     #   transmission (travis thinks this is because we're sniffing in listen-only
895     #   and thus not generating an ack bit on the recieving board)
896     if(args.verb=="spit"):
897         comm.spitSingle(freq=freq, standardid=standardid,duration=duration, repeat=repeat, debug=debug)
898
899
900     
901     
902     
903     
904         
905         
906     
907     
908     
909