X-Git-Url: http://git.rot13.org/?p=goodfet;a=blobdiff_plain;f=client%2FGoodFETMCPCAN.py;h=39faace56c18b74fbc0f1201258133900bd6fca5;hp=4c805edcf9297b5c29772f63cc7261262bb53971;hb=f0032d5d7e1d42b3b2dea4c95f734aeadfa01b74;hpb=f15cabc15a42fb1b0b57e433dc3a1f300cff2b6c diff --git a/client/GoodFETMCPCAN.py b/client/GoodFETMCPCAN.py index 4c805ed..39faace 100644 --- a/client/GoodFETMCPCAN.py +++ b/client/GoodFETMCPCAN.py @@ -227,36 +227,66 @@ class GoodFETMCPCAN(GoodFETSPI): if flags==0: print "Warning: Requesting to send no buffer."; - if self.MCPcanstat()>>5!=0: - print "Warning: currently in %s mode. NOT in normal mode! May not transmit." %self.MCPcanstatstr(); self.SPItrans([0x80|flags]); def writetxbuffer(self,packet,packbuf=0): """Writes the transmit buffer.""" self.SPItrans([0x40|(packbuf<<1)]+packet); - #READ BACK BUFFER 0 to check what we're about to send out - data=self.SPItrans([0x03, 0x31, - 0x00,0x00, #SID - 0x00,0x00, #EID - 0x00, #DLC - 0x00, 0x00, 0x00, 0x00, - 0x00, 0x00, 0x00, 0x00 - ]); - print "about to transmit:" + self.packet2str(data[2:len(data)]); - + + def txpacket(self,packet): """Transmits a packet through one of the outbound buffers. As usual, the packet should begin with SIDH. For now, only TXB0 is supported.""" self.writetxbuffer(packet,0); - - #self.SPItrans([0x81]); self.MCPrts(TXB0=True); ############### UTILITY FUNCTIONS ################# + + def simpleParse(self,packet): + """ + This will print a simple parsing of the data with the standard Id and the extended id parsed. + """ + dataPt = ord(packet[0]); + dataPt2 = ord(packet[1]); + # check if we have a standard frame, the msb of the second + # nibble will be 1. otherwise it is an extended rame + stdCheck = dataPt2 & 0x0f + if( stdCheck == 16 ): + #arb id is first byte + 3 msb of the 2nd byte + dataPt = dataPt<<3 | dataPt2>>5 + print "Standard Packet \n Arb ID: "+("%d"%dataPt) + else: + #arb id is first byte + 3 msb + 2 lsb of 2nd byte + + # 3rd byte + 4th byte + dataPt = dataPt<<3 | dataPt2>>5 + dataPt = dataPt<<2 | (dataPt2 & 0x03) + dataPt = dataPt<<8 | ord(packet[2]) + dataPt = dataPt<<8 | ord(packet[3]) + print "Extended Data Frame \n Arb ID: "+("%d"%dataPt) + + #find the dataLength + dataPt5 = packet[4] + dataLength = dataPt5 & 0x0e + #print "Data Length: "+("%d"%dataLength) + # Print the data packet + #print "Data:" + # Temporary, until correct packets are read + if( dataLength > 8 ): + dataLength = 8 + toprint = self.pcket2str(packet[5:12]) + print toprint + # For reading correct packets + # if (dataLength > 8 ): + # print "Acceptable Length Exceeded" + # Data length value should never exceed 8 + # else: + # toprint = self.pcket2str(packet[5:(5+dataLength)]) + # print toprint + def packet2str(self,packet): """Converts a packet from the internal format to a string.""" @@ -264,6 +294,91 @@ class GoodFETMCPCAN(GoodFETSPI): for bar in packet: toprint=toprint+("%02x "%ord(bar)) return toprint; + + + + def packet2parsed(self,data): + """ + This method will parse the packet that was received via L{rxpacket}. + + @type data: List + @param data: data packet read off of the MCP2515 from the CAN bus. format will be + 14 bytes where each element is a character whose unicode integer value corresponds + to the hex value of the byte (use the ord() method). + + @rtype: Dictionary + @return: Dictionary of the packet parsed into various components. The key values will be as follows + + 1. ide : 1 if the message is an extended frame. 0 otherwise + 2. eID : extended ID. Not included if not an extended frame + 3. rtr : 1 if the message is a remote transmission request (RTR) + 4. sID : Standard ID. + 5. length: packet length (between 0 and 8) + 6. db0 : Data byte 0 (not included if RTR message) + + --- + 7. db7 : Data byte 7 (not included if RTR message) + """ + dp1 = ord(data[0]) + dp2 = ord(data[1]) + dp5 = ord(data[4]) + + packet = {} + #get the ide bit. allows us to check to see if we have an extended + #frame + packet['ide'] = (dp2 & 0x0f)>>3 + #we have an extended frame + if( packet['ide'] != 0): + #get lower nibble, last 2 bits + eId = dp2 & 0x03 + eId = eId<<8 | ord(data[2]) + eId = eId<<8 | ord(data[3]) + rtr = dp5>>6 & 0x01 + packet['eID'] = " eID: %06d" %(eId) + packet['rtr'] = " rtr: %d" % (rtr) + + else: + packet['rtr'] = dp2>>4 & 0x01 + + + # Create the standard ID. from the message + packet['sID'] = dp1<<3 | dp2>>5 + packet['length'] = dp5 & 0x0f + + #generate the data section + for i in range(0,packet['length']): + idx = 5 + i + dbidx = 'db%d'%i + packet[dbidx] = ord(data[idx]) + return packet + + def packet2parsedstr(self,data): + """ + This will return a string that is the parsed CAN message. The bytes will be parsed + for the standard ID, extended ID (if one is present), rtr, length and databytes (if present). + The message will be placed into a string as decimal integers not hex values. This method + calls L{packet2parsed} to do the packet parsing. + + @type data: List + @param data: Data packet as returned by the L{rxpacket} + @rtype: String + @return: String that shows the data message in decimal format, parsed. + """ + packet = self.packet2parsed(data) + msg = "sID: %04d" %packet['sId'] + if( packetParsed.get('eID')): + msg += " eID: %d" %packetParsed.get('eID') + msg += " rtr: %d"%packetParsed['rtr'] + length = packetParsed['length'] + msg += " length: %d"%length + msg += " data:" + for i in range(0,length): + dbidx = 'db%d'%i + msg +=" %03d"% ord(packetParsed[dbidx]) # could change this to HEX + #msg = self.client.packet2parsedstr(packet) + return msg + + def peek8(self,adr): """Read a byte from the given address. Untested.""" data=self.SPItrans([0x03,adr&0xFF,00]); @@ -306,4 +421,4 @@ class GoodFETMCPCAN(GoodFETSPI): # TXRTSCTRL = x0D - \ No newline at end of file +