def test_signal_decode_return_type(self):
with open('./tests/dbc.json', 'r') as f:
dbc_json = json.loads(f.read())
message_data = b'\xff\xff\xff\xff\xff\xff\xff\xff'
message = caneton.message_decode(
message_id=1942,
message_length=len(message_data),
message_data=message_data,
dbc_json=dbc_json,
)
# Factor is float and integer
signal = caneton.message_get_signal(message, 'Foo1')
self.assertEqual(signal['value'], 255)
self.assertIs(type(signal['value']), int)
# Offset is float and integer
signal = caneton.message_get_signal(message, 'Foo2')
self.assertEqual(signal['value'], 255)
self.assertIs(type(signal['value']), int)
# Factor is float but not integer
signal = caneton.message_get_signal(message, 'Bar1')
self.assertEqual(signal['value'], 32767.5)
self.assertIs(type(signal['value']), float)
# Offset is float but not integer
signal = caneton.message_get_signal(message, 'Bar2')
self.assertEqual(signal['value'], 65535.5)
self.assertIs(type(signal['value']), float)
def receive_once(self):
decoded_msg = {}
try:
message_r = self.bus.recv()
#print "row message:"
#print message_r
logger.info("RECV_received_msg:%s" %str(message_r))
message_data_str = ""
for i in range(message_r.dlc):
message_data_str += "%02x" %message_r.data[i]
#print "received data in hex %s" %message_data_str
message_hex = binascii.unhexlify(message_data_str)
decoded_msg = caneton.message_decode(
message_id=message_r.arbitration_id,
message_length=len(message_hex),
message_data=message_hex,
dbc_json=self.json_handle
)
s_msg = "%s:\t" %decoded_msg["name"]
#check valid
if len(decoded_msg["signals"]) == 0:
logger.warning("Empty decoded_message.signal" + str(decoded_msg))
else:
self.recv_suc += 1
#logging
for k in decoded_msg["signals"]:
s_msg += "%s=%d\t" %(k["name"],k["value"])
logger.info("Decoded_msg:" + s_msg)
#for it in decoded_msg["signals"]:
# print "name:%s,value:%d" %(it["name"], it["value"])
except BaseException,e:
val = sys.exc_info()[1]
logger.error("RECV_once_failed,reason:%s" %(str(val)))
def test_message(self):
with open('./tests/dbc.json', 'r') as f:
dbc_json = json.loads(f.read())
message_data = binascii.unhexlify('01780178010000')
message = caneton.message_decode(message_id=0x701,
message_length=len(message_data),
message_data=message_data,
dbc_json=dbc_json)
signal = caneton.message_get_signal(message, 'Bar2')
self.assertEqual(signal['name'], 'Bar2')
self.assertEqual(signal['value'], 188.0)
self.assertEqual(signal['unit'], 'V')
message_data = binascii.unhexlify('041d000000000000')
message = caneton.message_decode(
message_id=0x63f,
message_length=len(message_data),
message_data=message_data,
dbc_json=dbc_json,
)
signal = caneton.message_get_signal(message, 'TempsChargeRestant')
self.assertIsNotNone(signal)
self.assertEqual(signal['value'], 29)
self.assertEqual(signal['unit'], 'mn')
message_data = binascii.unhexlify('00CDCCA042030000')
message = caneton.message_decode(
message_id=0x63f,
message_length=len(message_data),
message_data=message_data,
dbc_json=dbc_json,
)
signal = caneton.message_get_signal(message, 'Temperature_max')
self.assertIsNotNone(signal)
self.assertEqual(signal['value'], 1117834445)
self.assertEqual(signal['unit'], u'°C')
signal = caneton.message_get_signal(message, 'PuissanceDispoVch')
self.assertIsNotNone(signal)
self.assertEqual(signal['value'], 1)
self.assertEqual(signal['unit'], '')
signal = caneton.message_get_signal(message, 'PuissanceDispoVpack')
self.assertIsNotNone(signal)
self.assertEqual(signal['value'], 1)
self.assertEqual(signal['unit'], '')
def main():
parser = create_parser()
args = parser.parse_args()
cleaned_args = args_cleanup(args)
args.dbcfile.close()
message = caneton.message_decode(**cleaned_args)
message_output(message, args.output == 'json')
def main():
parser = create_parser()
args = parser.parse_args()
cleaned_args = args_cleanup(args)
args.dbcfile.close()
message = caneton.message_decode(**cleaned_args)
message_output(message, args.output == 'json')
def decode_message(m_id, data):
with open('dbc.json') as dbc_file:
dbc_json = json.loads(dbc_file.read())
print(data)
message_data = binascii.unhexlify(data)
print("mess_len=%d" % len(message_data))
message = caneton.message_decode(message_id=m_id,
message_length=len(message_data),
message_data=message_data,
dbc_json=dbc_json)
return message
def test_message_wo_signals(self):
message_id = 542
message_length = 8
message_data = b' ' * message_length
with open('./tests/dbc.json', 'r') as f:
dbc_json = json.loads(f.read())
message = caneton.message_decode(
message_id=message_id, message_length=message_length,
message_data=message_data, dbc_json=dbc_json)
self.assertEqual(message['signals'], [])
self.assertEqual(
caneton.message_get_signal(message, 'Doesntexist'), None)
def test_message_wo_signals(self):
message_id = 542
message_length = 8
message_data = b' ' * message_length
with open('./tests/dbc.json', 'r') as f:
dbc_json = json.loads(f.read())
message = caneton.message_decode(message_id=message_id,
message_length=message_length,
message_data=message_data,
dbc_json=dbc_json)
self.assertEqual(message['signals'], [])
self.assertEqual(caneton.message_get_signal(message, 'Doesntexist'),
None)
def test_message_with_negative_signed_int_type(self):
with open('./tests/dbc.json', 'r') as f:
dbc_json = json.loads(f.read())
message_data = binascii.unhexlify('1100F9FB00000000')
message = caneton.message_decode(
message_id=0x195,
message_length=len(message_data),
message_data=message_data,
dbc_json=dbc_json,
)
signal = caneton.message_get_signal(message, 'truck_speed')
self.assertEqual(signal['name'], 'truck_speed')
self.assertEqual(signal['value'], -10.31)
self.assertEqual(signal['unit'], 'km/h')
def test_message(self):
message_id = 0x701
message_data = binascii.unhexlify('00780178010001')
message_length = len(message_data)
with open('./tests/dbc.json', 'r') as f:
dbc_json = json.loads(f.read())
message = caneton.message_decode(
message_id=message_id, message_length=message_length,
message_data=message_data, dbc_json=dbc_json)
signal = caneton.message_get_signal(message, 'Bar2')
self.assertEqual(signal['name'], 'Bar2')
self.assertEqual(signal['value'], 188.0)
self.assertEqual(signal['unit'], 'V')
def test_message_with_float_type(self):
with open('./tests/dbc.json', 'r') as f:
dbc_json = json.loads(f.read())
message_data = binascii.unhexlify('0000284200000000')
message = caneton.message_decode(
message_id=0x63e,
message_length=len(message_data),
message_data=message_data,
dbc_json=dbc_json,
)
signal = caneton.message_get_signal(message,
'HvBatteryCurrent_Puissance')
self.assertEqual(signal['name'], 'HvBatteryCurrent_Puissance')
self.assertEqual(signal['value'], 42.0)
self.assertEqual(signal['unit'], 'A')
def test_message(self):
message_id = 0x701
message_data = binascii.unhexlify('01780178010000')
message_length = len(message_data)
with open('./tests/dbc.json', 'r') as f:
dbc_json = json.loads(f.read())
message = caneton.message_decode(message_id=message_id,
message_length=message_length,
message_data=message_data,
dbc_json=dbc_json)
signal = caneton.message_get_signal(message, 'Bar2')
self.assertEqual(signal['name'], 'Bar2')
self.assertEqual(signal['value'], 188.0)
self.assertEqual(signal['unit'], 'V')
def test_message_701(self):
args = self.parser.parse_args(['./tests/dbc.json', '0x701', '0x00780178010001'])
cleaned_args = cli.args_cleanup(args)
args.dbcfile.close()
message = caneton.message_decode(**cleaned_args)
self.assertEqual(message['name'], 'CU_MULTI_FOO_BAR')
signals = message['signals']
# The multiplexor is excluded from the list of signals
expected_signals = [
{'name': 'Bar1', 'value': 376},
{'name': 'Bar2', 'value': 188.0},
]
self.assertEqual(len(signals), len(expected_signals))
for (signal, expected_signal) in zip(signals, expected_signals):
self.assertEqual(signal['name'], expected_signal['name'])
self.assertEqual(signal['value'], expected_signal['value'], signal['name'])
self.assertIsInstance(signal['value'], type(expected_signal['value']), signal['name'])
def test_message_701(self):
args = self.parser.parse_args(['./tests/dbc.json', '0x701', '0x01780178010000'])
cleaned_args = cli.args_cleanup(args)
args.dbcfile.close()
message = caneton.message_decode(**cleaned_args)
self.assertEqual(message['name'], 'CU_MULTI_FOO_BAR')
signals = message['signals']
# The multiplexor is excluded from the list of signals
expected_signals = [
{'name': 'Bar1', 'value': 376},
{'name': 'Bar2', 'value': 188.0},
]
self.assertEqual(len(signals), len(expected_signals))
for (signal, expected_signal) in zip(signals, expected_signals):
self.assertEqual(signal['name'], expected_signal['name'])
self.assertEqual(signal['value'], expected_signal['value'], signal['name'])
self.assertIsInstance(signal['value'], type(expected_signal['value']), signal['name'])
if not len(sys.argv) == 3:
print("USAGE: "+sys.argv[0]+" candata.cap dbcfile.json")
print("outputs to stdout")
sys.exit(1)
capFile = open(sys.argv[1],'r')
with open(sys.argv[2]) as dbc_file:
dbc_json = json.loads(dbc_file.read())
pcap = dpkt.pcap.Reader(capFile)
for ts, buf in pcap:
print ts,
eth = dpkt.sll.SLL(buf)
ip = eth.data
udp = ip.data
if isinstance (udp, dpkt.udp.UDP):
if udp.sport == 20100:
packet=''.join(x.encode('hex') for x in str(udp))
message_id = int(packet[20:24],16)
message_data = binascii.unhexlify(packet[24:])
message_length = len(packet[24:]) / 2 # half the number number of hex characters
try:
message = caneton.message_decode(message_id, message_length, message_data, dbc_json)
print(message)
except:
print(packet+' decode failed ID: 0x'+packet[20:24])
else:
print "x"
else:
print "x"
print("outputs to stdout")
sys.exit(1)
capFile = open(sys.argv[1], 'r')
with open(sys.argv[2]) as dbc_file:
dbc_json = json.loads(dbc_file.read())
pcap = dpkt.pcap.Reader(capFile)
for ts, buf in pcap:
print ts,
eth = dpkt.sll.SLL(buf)
ip = eth.data
udp = ip.data
if isinstance(udp, dpkt.udp.UDP):
if udp.sport == 20100:
packet = ''.join(x.encode('hex') for x in str(udp))
message_id = int(packet[20:24], 16)
message_data = binascii.unhexlify(packet[24:])
message_length = len(
packet[24:]) / 2 # half the number number of hex characters
try:
message = caneton.message_decode(message_id, message_length,
message_data, dbc_json)
print(message)
except:
print(packet + ' decode failed ID: 0x' + packet[20:24])
else:
print "x"
else:
print "x"
