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