def __init__(self, dbc_name):
self.dv = defaultdict(dict)
self.dbc_name = dbc_name
self.dbc = libdbc.dbc_lookup(dbc_name)
num_vals = self.dbc[0].num_vals
self.address_to_msg_name = {}
num_msgs = self.dbc[0].num_msgs
for i in range(num_msgs):
msg = self.dbc[0].msgs[i]
name = ffi.string(msg.name)
address = msg.address
self.address_to_msg_name[address] = name
for i in range(num_vals):
val = self.dbc[0].vals[i]
sgname = ffi.string(val.name)
address = val.address
def_val = ffi.string(val.def_val)
#separate definition/value pairs
def_val = def_val.split()
values = [int(v) for v in def_val[::2]]
defs = def_val[1::2]
if address not in self.dv:
self.dv[address] = {}
msgname = self.address_to_msg_name[address]
self.dv[msgname] = {}
# two ways to lookup: address or msg name
self.dv[address][sgname] = {v: d for v, d in zip(values, defs)} #build dict
self.dv[msgname][sgname] = self.dv[address][sgname]
def __init__(self, dbc_name):
self.packer = libdbc.canpack_init(dbc_name)
self.dbc = libdbc.dbc_lookup(dbc_name)
self.sig_names = {}
self.name_to_address_and_size = {}
num_msgs = self.dbc[0].num_msgs
for i in range(num_msgs):
msg = self.dbc[0].msgs[i]
name = ffi.string(msg.name)
address = msg.address
self.name_to_address_and_size[name] = (address, msg.size)
self.name_to_address_and_size[address] = (address, msg.size)
def __init__(self, dbc_name):
print "dbc_name:", dbc_name
self.dv = defaultdict(dict)
print 1
self.dbc_name = dbc_name
print 2
self.dbc = libdbc.dbc_lookup(dbc_name)
print "dbc:", self.dbc
num_vals = self.dbc[0].num_vals
print "num_vals", num_vals
self.address_to_msg_name = {}
num_msgs = self.dbc[0].num_msgs
print "num_msgs:", num_msgs
print "num_msgs loop..."
for i in range(num_msgs):
msg = self.dbc[0].msgs[i]
print "msg:", msg
name = ffi.string(msg.name)
print "name:", name
address = msg.address
print "address", address
self.address_to_msg_name[address] = name
print "num_vals loop..."
for i in range(num_vals):
val = self.dbc[0].vals[i]
print "val:", val
sgname = ffi.string(val.name)
print "sgname:", sgname
address = val.address
print "address:", address
def_val = ffi.string(val.def_val)
#separate definition/value pairs
def_val = def_val.split()
values = [int(v) for v in def_val[::2]]
defs = def_val[1::2]
if address not in self.dv:
self.dv[address] = {}
msgname = self.address_to_msg_name[address]
self.dv[msgname] = {}
# two ways to lookup: address or msg name
self.dv[address][sgname] = {v: d for v, d in zip(values, defs)} #build dict
self.dv[msgname][sgname] = self.dv[address][sgname]
print "CANDefine done"
def __init__(self, dbc_name):
#2018.09.06 9:19PM Print dbc_name test
#print("packer.py debug")
# print(dbc_name)
#print("packer.py packer check")
self.packer = libdbc.canpack_init(dbc_name)
# print("packer.py packer check")
# print(self.packer)
self.dbc = libdbc.dbc_lookup(dbc_name)
# print("packer.py packer self.dbc lookup dbc_name")
# print(self.dbc)
self.sig_names = {}
# print("packer.py sig_names")
#print(self.sig_names)
self.name_to_address_and_size = {}
#print("packer.py names to address size")
#print(self.name_to_address_and_size)
num_msgs = self.dbc[0].num_msgs
#print("packer.py num_msgs")
#print(num_msgs)
for i in range(num_msgs):
msg = self.dbc[0].msgs[i]
#print("packer.py .msg[i]")
#print(msg[i])
#print("packer.py self.dbc[0]")
# print(self.dbc[0])
# print("packer.py msg")
# print(msg)
name = ffi.string(msg.name)
address = msg.address
self.name_to_address_and_size[name] = (address, msg.size)
self.name_to_address_and_size[address] = (address, msg.size)
def __init__(self,
dbc_name,
signals,
checks=None,
bus=0,
sendcan=False,
tcp_addr="127.0.0.1"):
if checks is None:
checks = []
self.can_valid = True
self.vl = defaultdict(dict)
self.ts = defaultdict(dict)
self.dbc_name = dbc_name
self.dbc = libdbc.dbc_lookup(dbc_name)
self.msg_name_to_addres = {}
self.address_to_msg_name = {}
num_msgs = self.dbc[0].num_msgs
for i in range(num_msgs):
msg = self.dbc[0].msgs[i]
name = ffi.string(msg.name)
address = msg.address
self.msg_name_to_addres[name] = address
self.address_to_msg_name[address] = name
# Convert message names into addresses
for i in range(len(signals)):
s = signals[i]
if not isinstance(s[1], numbers.Number):
s = (s[0], self.msg_name_to_addres[s[1]], s[2])
signals[i] = s
for i in range(len(checks)):
c = checks[i]
if not isinstance(c[0], numbers.Number):
c = (self.msg_name_to_addres[c[0]], c[1])
checks[i] = c
sig_names = dict(
(name, ffi.new("char[]", name)) for name, _, _ in signals)
signal_options_c = ffi.new(
"SignalParseOptions[]", [{
'address': sig_address,
'name': sig_names[sig_name],
'default_value': sig_default,
} for sig_name, sig_address, sig_default in signals])
message_options = dict((address, 0) for _, address, _ in signals)
message_options.update(dict(checks))
message_options_c = ffi.new(
"MessageParseOptions[]", [{
'address': msg_address,
'check_frequency': freq,
} for msg_address, freq in message_options.items()])
self.can = libdbc.can_init(bus, dbc_name,
len(message_options_c), message_options_c,
len(signal_options_c), signal_options_c,
sendcan, tcp_addr)
self.p_can_valid = ffi.new("bool*")
value_count = libdbc.can_query(self.can, 0, self.p_can_valid, 0,
ffi.NULL)
self.can_values = ffi.new("SignalValue[%d]" % value_count)
self.update_vl(0)
