fix endianness in device descriptor
[goodfet] / client / GoodFETMCPCAN.py
1 #!/usr/bin/env python
2 # GoodFET MCP2515 CAN Bus Client
3
4 # (C) 2012 Travis Goodspeed <travis at radiantmachines.com>
5 #
6 # WORKING COPY
7 # Currently being updated by Siege Technology's ENGS89 team
8 # Primary contact: Theodore Sumers <ted.sumers at gmail.com>
9 # ADDED FUNCTIONALITY:
10 #   10.4/41.6/83.3 kHz sniffing
11 #   setbitrate
12 #   debugs on TX and RX packet
13 #   int-based state change reqs for preserving state
14 #
15
16 # The MCP2515 is a CAN Bus to SPI adapter from Microchip Technology,
17 # as used in the Goodthopter series of boards.  It requires a separate
18 # chip for voltage level conversion, such as the MCP2551.
19
20 import sys, time, string, cStringIO, struct, glob, os;
21
22 from GoodFETSPI import GoodFETSPI;
23
24 class GoodFETMCPCAN(GoodFETSPI):
25     """This class uses the regular SPI app to implement a CAN Bus
26     adapter on the Goodthopter10 hardware."""
27     MCPMODES=["Normal","Sleep","Loopback","Listen-only","Configuration",
28               "UNKNOWN","UNKNOWN","PowerUp"];
29     
30     def MCPsetup(self):
31         """Sets up the ports."""
32         self.SPIsetup();
33         self.MCPreset(); #Reset the chip.
34         # We're going to set some registers, so we must be in config
35         # mode.
36         self.MCPreqstatConfiguration();
37         
38         # If we don't enable promiscous mode, we'll miss a lot of
39         # packets.  It can be manually disabled later.
40         #self.poke8(0x60,0xFF); #TODO Does this have any unpleasant side effects?
41         self.poke8(0x60,0x66); #Wanted FF, but some bits are reserved.
42
43     #Array of supported rates.
44     MCPrates=[10.4, 41.6, 83.3, 100, 125, 250, 500, 1000];
45     
46     def MCPreset(self):
47         """Reset the MCP2515 chip."""
48         self.SPItrans([0xC0]);
49     
50       
51     ################    SETTING BAUD RATE   ################
52     
53     
54     def MCPsetrate(self,rate=125):
55         """Sets the data rate in kHz."""
56         # Now we need to set the timing registers.  See chapter 5 of
57         # the MCP2515 datasheet to get some clue as to how this
58         # arithmetic of this works.
59
60         
61         #STORE the prior status
62         oldstatus=self.MCPcanstatint();
63         print "Setting rate of %i kHz." % rate;
64         #print "Current state is %s." % self.MCPcanstatstr();
65         self.MCPreqstatConfiguration();
66         # print "Switched to %s state." % self.MCPcanstatstr();
67         
68         
69         if rate>41 and rate<42:
70             # NOT CHECKED: based on kvaser website.
71             # Sets baud rate for 41.6 kbps
72             CNF1=0x8e;
73             CNF2=0xa3;
74             CNF3=0x05;
75         elif rate>10 and rate<11:
76             # NOT CHECKED: based on kvaser website.
77             # Sets baud rate for 10.4 kbps
78             CNF1=0xbb;
79             CNF2=0xa3;
80             CNF3=0x05;  
81         elif rate==125:
82             #125 kHz, 16 TQ, not quite as worked out above.
83             CNF1=0x04;
84             CNF2=0xB8;
85             CNF3=0x05;
86         elif rate==100:
87             #100 kHz, 20 TQ
88             CNF1=0x04;
89             CNF2=0xBA;
90             CNF3=0x07;
91         elif rate>83 and rate<83.5:
92             #83+1/3 kHz, 8 TQ
93             # 0.04% error from 83.30
94             CNF1=0x0E;
95             CNF2=0x90;
96             CNF3=0x02;
97         elif rate==250:
98             #256 kHz, 20 TQ
99             CNF1=0x01;
100             CNF2=0xBA;
101             CNF3=0x07;
102         elif rate==500:
103             #500 kHz, 20 TQ
104             CNF1=0x00;
105             CNF2=0xBA;
106             CNF3=0x07;
107         elif rate==1000:
108             #1,000 kHz, 10 TQ
109             CNF1=0x00;
110             CNF2=0xA0;
111             CNF3=0x02;
112             print "WARNING: Because of chip errata, this probably won't work."
113         else:
114             print "Given unsupported rate of %i kHz." % rate;
115             print "Defaulting to 125kHz.";
116             CNF1=0x04;
117             CNF2=0xB8;
118             CNF3=0x05;
119         self.poke8(0x2a,CNF1);
120         self.poke8(0x29,CNF2);
121         self.poke8(0x28,CNF3);
122
123         # and now return to whatever state we were in before
124         self.MCPreqstat(oldstatus);
125         #print "Reverted to %s." % self.MCPcanstatstr();
126
127     
128     #################   STATE MANAGEMENT   ##################
129
130     def MCPcanstat(self):
131         """Get the CAN Status."""
132         return self.peek8(0x0E);
133     def MCPcanstatstr(self):
134         """Read the present status as a string."""
135         opmod=self.MCPcanstatint();
136         return self.MCPMODES[opmod];
137     def MCPcanstatint(self):
138         """Read present status as an int."""
139         return self.MCPcanstat()>>5;
140
141             
142     def MCPreqstat(self, state):
143         """Set the CAN state."""
144         if state==0:
145             self.MCPreqstatNormal();
146         elif state==1:
147             self.MCPreqstatSleep();
148         elif state==2:
149             self.MCPreqstatLoopback();
150         elif state==3:
151             self.MCPreqstatListenOnly();
152         elif state==4:
153             self.MCPreqstatConfiguration();
154         else:
155             print "Invalid state entered; defaulting to Listen-Only"
156             self.MCPreqstatListenOnly();
157     def MCPreqstatNormal(self):
158         """Set the CAN state."""
159         state=0x0;
160         self.MCPbitmodify(0x0F,0xE0,(state<<5));
161     def MCPreqstatSleep(self):
162         """Set the CAN state."""
163         state=0x1;
164         self.MCPbitmodify(0x0F,0xE0,(state<<5));
165     def MCPreqstatLoopback(self):
166         """Set the CAN state."""
167         state=0x2;
168         self.MCPbitmodify(0x0F,0xE0,(state<<5));
169     def MCPreqstatListenOnly(self):
170         """Set the CAN state."""
171         state=0x3;
172         self.MCPbitmodify(0x0F,0xE0,(state<<5));
173     def MCPreqstatConfiguration(self):
174         """Set the CAN state."""
175         state=0x4;
176         self.MCPbitmodify(0x0F,0xE0,(state<<5));
177     
178     ####################     RX MANAGEMENT     #####################
179     
180     def MCPrxstatus(self):
181         """Reads the RX Status by the SPI verb of the same name."""
182         data=self.SPItrans([0xB0,0x00]);
183         return ord(data[1]);
184
185     def MCPreadstatus(self):
186         """Reads the Read Status by the SPI verb of the same name."""
187         #See page 69 of the datasheet for the flag names.
188         data=self.SPItrans([0xA0,0x00]);
189         return ord(data[1]);
190             
191     def readrxbuffer(self,packbuf=0):
192         """Reads the RX buffer.  Might have old data."""
193         data=self.SPItrans([0x90|(packbuf<<2),
194                             0x00,0x00, #SID
195                             0x00,0x00, #EID
196                             0x00,      #DLC
197                             0x00, 0x00, 0x00, 0x00,
198                             0x00, 0x00, 0x00, 0x00
199                             ]);
200         
201         return data[1:len(data)];
202     
203     def fastrxpacket(self):
204         return self.readrxbuffer(0);
205     
206     def rxpacket(self):
207         """Reads the next incoming packet from either buffer.
208             Returns None immediately if no packet is waiting."""
209         status=self.MCPrxstatus()&0xC0;
210         if status&0x40:
211             #Buffer 0 has higher priority.
212             return self.readrxbuffer(0);
213         elif status&0x80:
214             #Buffer 1 has lower priority.
215             return self.readrxbuffer(1);
216         else:
217             return None;
218
219     #################      TX MANAGEMENT    ##################
220             
221     def MCPrts(self,TXB0=False,TXB1=False,TXB2=False):
222         """Requests to send one of the transmit buffers."""
223         flags=0;
224         if TXB0: flags=flags|1;
225         if TXB1: flags=flags|2;
226         if TXB2: flags=flags|4;
227         
228         if flags==0:
229             print "Warning: Requesting to send no buffer.";
230         self.SPItrans([0x80|flags]);
231     
232     def writetxbuffer(self,packet,packbuf=0):
233         """Writes the transmit buffer."""
234         
235         self.SPItrans([0x40|(packbuf<<1)]+packet);
236
237    
238     def txpacket(self,packet):
239         """Transmits a packet through one of the outbound buffers.
240         As usual, the packet should begin with SIDH.
241         For now, only TXB0 is supported."""
242
243         self.writetxbuffer(packet,0);
244         self.MCPrts(TXB0=True);
245
246                 
247     ###############   UTILITY FUNCTIONS  #################
248      
249     def simpleParse(self,packet):
250         """ 
251         This will print a simple parsing of the data with the standard Id and the extended id parsed.
252         """
253         dataPt = ord(packet[0]);
254         dataPt2 = ord(packet[1]);
255         # check if we have a standard frame, the msb of the second
256         # nibble will be 1. otherwise it is an extended rame
257         stdCheck = dataPt2 & 0x0f
258         if( stdCheck == 16 ):
259             #arb id is first byte + 3 msb of the 2nd byte
260             dataPt = dataPt<<3 | dataPt2>>5
261             print "Standard Packet \n Arb ID: "+("%d"%dataPt)
262         else:
263             #arb id is first byte + 3 msb + 2 lsb of 2nd byte +
264             # 3rd byte + 4th byte
265             dataPt = dataPt<<3 | dataPt2>>5
266             dataPt = dataPt<<2 | (dataPt2 & 0x03)
267             dataPt = dataPt<<8 | ord(packet[2])
268             dataPt = dataPt<<8 | ord(packet[3])
269             print "Extended Data Frame \n Arb ID: "+("%d"%dataPt)
270         
271         #find the dataLength
272         dataPt5 = packet[4]
273         dataLength = dataPt5 & 0x0e
274         #print "Data Length: "+("%d"%dataLength)
275         # Print the data packet
276         #print "Data:"
277         # Temporary, until correct packets are read
278         if( dataLength > 8 ):
279             dataLength = 8
280         toprint = self.pcket2str(packet[5:12])
281         print toprint
282         # For reading correct packets
283        # if (dataLength > 8 ):
284         #    print "Acceptable Length Exceeded"
285             # Data length value should never exceed 8
286        # else:
287        # toprint =  self.pcket2str(packet[5:(5+dataLength)])
288        # print toprint
289
290             
291     def packet2str(self,packet):
292         """Converts a packet from the internal format to a string."""
293         toprint="";
294         for bar in packet:
295             toprint=toprint+("%02x "%ord(bar))
296         return toprint;
297     
298     
299     
300     def packet2parsed(self,data):
301         """
302         This method will parse the packet that was received via L{rxpacket}.
303         
304         @type data: List
305         @param data: data packet read off of the MCP2515 from the CAN bus. format will be
306                      14 bytes where each element is a character whose unicode integer value corresponds
307                      to the hex value of the byte (use the ord() method).
308         
309         @rtype: Dictionary
310         @return: Dictionary of the packet parsed into various components. The key values will be as follows
311                      
312                      1. ide : 1 if the message is an extended frame. 0 otherwise
313                      2. eID : extended ID. Not included if not an extended frame
314                      3. rtr : 1 if the message is a remote transmission request (RTR)
315                      4. sID : Standard ID. 
316                      5. length: packet length (between 0 and 8)
317                      6. db0 : Data byte 0 (not included if RTR message)
318                          
319                          ---
320                      7. db7 : Data byte 7 (not included if RTR message)
321         """
322         dp1 = ord(data[0])
323         dp2 = ord(data[1])
324         dp5 = ord(data[4])
325         
326         packet = {}
327         #get the ide bit. allows us to check to see if we have an extended
328         #frame
329         packet['ide'] = (dp2 & 0x0f)>>3
330         #we have an extended frame
331         if( packet['ide'] != 0):
332             #get lower nibble, last 2 bits
333             eId = dp2 & 0x03
334             eId = eId<<8 | ord(data[2])
335             eId = eId<<8 | ord(data[3])
336             rtr = dp5>>6 & 0x01
337             packet['eID'] = " eID: %06d" %(eId)
338             packet['rtr'] = " rtr: %d" % (rtr)
339     
340         else:
341             packet['rtr'] = dp2>>4 & 0x01
342             
343         
344         # Create the standard ID. from the message
345         packet['sID'] = dp1<<3 | dp2>>5
346         packet['length'] = dp5 & 0x0f
347         
348         #generate the data section
349         for i in range(0,packet['length']):
350             idx = 5 + i
351             dbidx = 'db%d'%i
352             packet[dbidx] = ord(data[idx])
353         return packet
354     
355     def packet2parsedstr(self,data):
356         """
357         This will return a string that is the parsed CAN message. The bytes will be parsed
358         for the standard ID, extended ID (if one is present), rtr, length and databytes (if present).
359         The message will be placed into a string as decimal integers not hex values. This method 
360         calls L{packet2parsed} to do the packet parsing.
361         
362         @type data: List
363         @param data: Data packet as returned by the L{rxpacket}
364         @rtype: String
365         @return: String that shows the data message in decimal format, parsed.
366         """
367         packet = self.packet2parsed(data)
368         msg = "sID: %04d" %packet['sId']
369         if( packetParsed.get('eID')):
370             msg += " eID: %d" %packetParsed.get('eID')
371         msg += " rtr: %d"%packetParsed['rtr']
372         length = packetParsed['length']
373         msg += " length: %d"%length
374         msg += " data:"
375         for i in range(0,length):
376             dbidx = 'db%d'%i
377             msg +=" %03d"% ord(packetParsed[dbidx])  # could change this to HEX
378         #msg = self.client.packet2parsedstr(packet)
379         return msg
380         
381         
382     def peek8(self,adr):
383         """Read a byte from the given address.  Untested."""
384         data=self.SPItrans([0x03,adr&0xFF,00]);
385         return ord(data[2]);
386     def poke8(self,adr,val):
387         """Poke a value into RAM.  Untested"""
388         self.SPItrans([0x02,adr&0xFF,val&0xFF]);
389         newval=self.peek8(adr);
390         if newval!=val:
391             print "Failed to poke %02x to %02x.  Got %02x." % (adr,val,newval);
392             print "Are you not in idle mode?";
393         return val;
394     def MCPbitmodify(self,adr,mask,data):
395         """Writes a byte with a mask.  Doesn't work for many registers."""
396         data=self.SPItrans([0x05,adr&0xFF,mask&0xFF,data&0xFF]);
397         return ord(data[2]);
398
399 ############### DEBUG UTILITIES: STATUS MESSAGES ##############
400
401 #    def MCPrxstatusmessage(self):
402 #        """Returns string indicating status of RX buffers"""
403 #        status = self.MCPrxstatus();
404 #
405 #        if status < 64:
406 #            print "No RX message";
407 #        elif status < 128:
408 #            print "Message in RXB0";
409 #        elif status < 192:
410 #            print "Message in RXB1";
411 #        else:
412 #            print "Messages in both buffers";
413
414
415
416 # TXB0TRL = 0x30
417 # RXB0CTRL = 0x60
418 # CNF3/2/1 = 0x28, 29, 2a
419 # CANINTE = 0x2b
420 # CANINTF = 0x2c
421 # TXRTSCTRL = x0D
422
423
424