def dump(mydb, f, **options):
# type: (canmatrix.CanMatrix, typing.IO, **typing.Any) -> None
# create copy because export changes database
db = copy.deepcopy(mydb)
dbf_export_encoding = options.get("dbfExportEncoding", 'iso-8859-1')
ignore_encoding_errors = options.get("ignoreEncodingErrors", "strict")
db.enum_attribs_to_keys()
if len(db.signals) > 0:
free_signals_dummy_frame = canmatrix.Frame(
"VECTOR__INDEPENDENT_SIG_MSG")
free_signals_dummy_frame.arbitration_id = canmatrix.ArbitrationId(
id=0x40000000, extended=True)
free_signals_dummy_frame.signals = db.signals
db.add_frame(free_signals_dummy_frame)
out_str = """//******************************BUSMASTER Messages and signals Database ******************************//
[DATABASE_VERSION] 1.3
[PROTOCOL] CAN
[BUSMASTER_VERSION] [1.7.2]
[NUMBER_OF_MESSAGES] """
out_str += str(len(db.frames)) + "\n"
cycle_times_of_all_frames = [x.cycle_time for x in db.frames]
if len(cycle_times_of_all_frames) > 0 and max(
cycle_times_of_all_frames) > 0:
db.add_frame_defines("GenMsgCycleTime", 'INT 0 65535')
cycle_times_of_all_singals = [
x.cycle_time for y in db.frames for x in y.signals
]
if len(cycle_times_of_all_singals) > 0 and max(
cycle_times_of_all_singals) > 0:
db.add_signal_defines("GenSigCycleTime", 'INT 0 65535')
initial_values_of_all_singals = [
x.initial_value for y in db.frames for x in y.signals
]
if len(initial_values_of_all_singals) > 0 and (
max(initial_values_of_all_singals) > 0
or min(initial_values_of_all_singals)) < 0:
db.add_signal_defines("GenSigStartValue", 'FLOAT 0 100000000000')
# Frames
for frame in db.frames:
if frame.is_complex_multiplexed:
logger.error(
"export complex multiplexers is not supported - ignoring frame "
+ frame.name)
continue
# Name unMsgId m_ucLength m_ucNumOfSignals m_cDataFormat m_cFrameFormat? m_txNode
# m_cDataFormat Data format: 1-Intel, 0-Motorola -- always 1 original converter decides based on signal count.
# cFrameFormat Standard 'S' Extended 'X'
extended = 'X' if frame.arbitration_id.extended == 1 else 'S'
out_str += "[START_MSG] " + frame.name + \
",%d,%d,%d,1,%c," % (frame.arbitration_id.id, frame.size, len(frame.signals), extended)
if not frame.transmitters:
frame.add_transmitter("Vector__XXX")
# DBF does not support multiple Transmitters
out_str += frame.transmitters[0] + "\n"
for signal in frame.signals:
# m_acName ucLength m_ucWhichByte m_ucStartBit
# m_ucDataFormat m_fOffset m_fScaleFactor m_acUnit m_acMultiplex m_rxNode
# m_ucDataFormat
which_byte = int(
math.floor(
signal.get_startbit(bit_numbering=1, start_little=True) /
8) + 1)
sign = 'I'
if not signal.is_signed:
sign = 'U'
if signal.is_float:
if signal.size > 32:
sign = 'D'
else:
sign = 'F'
if signal.factor == 0:
signal.factor = 1
out_str += "[START_SIGNALS] " + signal.name \
+ ",%d,%d,%d,%c," % (signal.size,
which_byte,
int(signal.get_startbit(bit_numbering=1,
start_little=True)) % 8,
sign) + '{},{}'.format(float(signal.max) / float(signal.factor),
float(signal.min) / float(signal.factor))
out_str += ",%d,%s,%s" % (signal.is_little_endian, signal.offset,
signal.factor)
multiplex = ""
if signal.multiplex is not None:
if signal.multiplex == 'Multiplexor':
multiplex = 'M'
else:
multiplex = 'm' + str(signal.multiplex)
out_str += "," + signal.unit + ",%s," % multiplex + \
','.join(signal.receivers) + "\n"
if len(signal.values) > 0:
for value, name in sorted(list(signal.values.items())):
out_str += '[VALUE_DESCRIPTION] "' + \
name + '",' + str(value) + '\n'
out_str += "[END_MSG]\n\n"
# Board units
out_str += "[NODE] "
count = 1
for ecu in db.ecus:
out_str += ecu.name
if count < len(db.ecus):
out_str += ","
count += 1
out_str += "\n"
out_str += "[START_DESC]\n\n"
# BU-descriptions
out_str += "[START_DESC_MSG]\n"
for frame in db.frames:
if frame.comment is not None:
comment = frame.comment.replace("\n", " ")
out_str += str(frame.arbitration_id.id) + ' S "' + comment + '";\n'
out_str += "[END_DESC_MSG]\n"
# Frame descriptions
out_str += "[START_DESC_NODE]\n"
for ecu in db.ecus:
if ecu.comment is not None:
comment = ecu.comment.replace("\n", " ")
out_str += ecu.name + ' "' + comment + '";\n'
out_str += "[END_DESC_NODE]\n"
# signal descriptions
out_str += "[START_DESC_SIG]\n"
for frame in db.frames:
if frame.is_complex_multiplexed:
continue
for signal in frame.signals:
if signal.comment is not None:
comment = signal.comment.replace("\n", " ")
out_str += "%d S " % frame.arbitration_id.id + signal.name + ' "' + comment + '";\n'
out_str += "[END_DESC_SIG]\n"
out_str += "[END_DESC]\n\n"
out_str += "[START_PARAM]\n"
# db-parameter
out_str += "[START_PARAM_NET]\n"
for (data_type, define) in sorted(list(db.global_defines.items())):
default_val = define.defaultValue
if default_val is None:
default_val = "0"
out_str += '"' + data_type + '",' + define.definition.replace(
' ', ',') + ',' + default_val + '\n'
out_str += "[END_PARAM_NET]\n"
# bu-parameter
out_str += "[START_PARAM_NODE]\n"
for (data_type, define) in sorted(list(db.ecu_defines.items())):
default_val = define.defaultValue
if default_val is None:
default_val = "0"
out_str += '"' + data_type + '",' + define.definition.replace(
' ', ',') + ',' + default_val + '\n'
out_str += "[END_PARAM_NODE]\n"
# frame-parameter
out_str += "[START_PARAM_MSG]\n"
for (data_type, define) in sorted(list(db.frame_defines.items())):
default_val = define.defaultValue
if default_val is None:
default_val = "0"
out_str += '"' + data_type + '",' + define.definition.replace(
' ', ',') + '\n' # + ',' + default_val + '\n'
out_str += "[END_PARAM_MSG]\n"
# signal-parameter
out_str += "[START_PARAM_SIG]\n"
for (data_type, define) in list(db.signal_defines.items()):
default_val = define.defaultValue
if default_val is None:
default_val = "0"
out_str += '"' + data_type + '",' + define.definition.replace(
' ', ',') + ',' + default_val + '\n'
out_str += "[END_PARAM_SIG]\n"
out_str += "[START_PARAM_VAL]\n"
# board unit attributes:
out_str += "[START_PARAM_NODE_VAL]\n"
for ecu in db.ecus:
for attrib, val in sorted(list(ecu.attributes.items())):
out_str += ecu.name + ',"' + attrib + '","' + val + '"\n'
out_str += "[END_PARAM_NODE_VAL]\n"
# messages-attributes:
out_str += "[START_PARAM_MSG_VAL]\n"
for frame in db.frames:
if frame.is_complex_multiplexed:
continue
for attrib, val in sorted(list(frame.attributes.items())):
out_str += str(frame.arbitration_id.id
) + ',S,"' + attrib + '","' + val + '"\n'
out_str += "[END_PARAM_MSG_VAL]\n"
# signal-attributes:
out_str += "[START_PARAM_SIG_VAL]\n"
for frame in db.frames:
if frame.is_complex_multiplexed:
continue
for signal in frame.signals:
for attrib, val in sorted(list(signal.attributes.items())):
out_str += str(frame.arbitration_id.id) + ',S,' + signal.name + \
',"' + attrib + '","' + val + '"\n'
out_str += "[END_PARAM_SIG_VAL]\n"
out_str += "[END_PARAM_VAL]\n"
f.write(out_str.encode(dbf_export_encoding, ignore_encoding_errors))
# import of a second CAN-Matrix (*.dbc, *.dbf, *.kcd, *.arxml)
db2 = canmatrix.formats.loadp_flat("second.dbc")
#
# create target Matrix
#
db3 = canmatrix.CanMatrix()
#
# Here a new Can-Matrix can be 'programmed':
# -----------------------------------------------------
#
# Copy Can-ID 1234 from second CAN-Matrix to target-Matrix
canmatrix.copy.copy_frame(canmatrix.ArbitrationId(100), db2, db3)
# Copy frame "Engine_123" from first CAN-Matrix to target-Matrix
canmatrix.copy.copy_frame(canmatrix.ArbitrationId(200), db1, db3)
# Copy ECU (with all Frames) "Gateway" from first CAN-Matrix to target-Matrix
canmatrix.copy.copy_ecu_with_frames("Gateway", db1, db3)
#
# -----------------------------------------------------
#
#
#
# export the new (target)-Matrix for example as .dbc:
#
def load(file, **options):
# type: (typing.IO, **typing.Any) -> canmatrix.CanMatrix
motorola_bit_format = options.get("xlsMotorolaBitFormat", "msbreverse")
float_factory = options.get("float_factory", default_float_factory)
additional_inputs = dict()
wb = xlrd.open_workbook(file_contents=file.read())
sh = wb.sheet_by_index(0)
db = canmatrix.CanMatrix()
# Defines not imported...
# db.add_ecu_defines("NWM-Stationsadresse", 'HEX 0 63')
# db.add_ecu_defines("NWM-Knoten", 'ENUM "nein","ja"')
db.add_frame_defines("GenMsgCycleTime", 'INT 0 65535')
db.add_frame_defines("GenMsgDelayTime", 'INT 0 65535')
db.add_frame_defines("GenMsgCycleTimeActive", 'INT 0 65535')
db.add_frame_defines("GenMsgNrOfRepetitions", 'INT 0 65535')
# db.addFrameDefines("GenMsgStartValue", 'STRING')
launch_types = [] # type: typing.List[str]
# db.addSignalDefines("GenSigStartValue", 'HEX 0 4294967295')
db.add_signal_defines("GenSigSNA", 'STRING')
# eval search for correct columns:
index = {}
for i in range(sh.ncols):
value = sh.cell(0, i).value
if value == "ID":
index['ID'] = i
elif "Frame Name" in value:
index['frameName'] = i
elif "Cycle" in value:
index['cycle'] = i
elif "Launch Type" in value:
index['launchType'] = i
elif "Launch Parameter" in value:
index['launchParam'] = i
elif "Signal Byte No." in value:
index['startbyte'] = i
elif "Signal Bit No." in value:
index['startbit'] = i
elif "Signal Name" in value:
index['signalName'] = i
elif "Signal Function" in value:
index['signalComment'] = i
elif "Signal Length" in value:
index['signalLength'] = i
elif "Signal Default" in value:
index['signalDefault'] = i
elif "Signal Not Ava" in value:
index['signalSNA'] = i
elif "Value" in value:
index['Value'] = i
elif "Name / Phys" in value:
index['ValueName'] = i
elif "Function /" in value:
index['function'] = i
elif "Byteorder" in value:
index['byteorder'] = i
else:
if 'Value' in index and i > index['Value']:
additional_inputs[i] = value
if "byteorder" in index:
index['ECUstart'] = index['byteorder'] + 1
else:
index['ECUstart'] = index['signalSNA'] + 1
index['ECUend'] = index['Value']
# ECUs:
for x in range(index['ECUstart'], index['ECUend']):
db.add_ecu(canmatrix.Ecu(sh.cell(0, x).value))
# initialize:
frame_id = None
signal_name = ""
new_frame = None
for row_num in range(1, sh.nrows):
# ignore empty row
if len(sh.cell(row_num, index['ID']).value) == 0:
break
# new frame detected
if sh.cell(row_num, index['ID']).value != frame_id:
# new Frame
frame_id = sh.cell(row_num, index['ID']).value
frame_name = sh.cell(row_num, index['frameName']).value
cycle_time = sh.cell(row_num, index['cycle']).value
launch_type = sh.cell(row_num, index['launchType']).value
dlc = 8
launch_param = sh.cell(row_num, index['launchParam']).value
try:
launch_param = str(int(launch_param))
except:
launch_param = "0"
new_frame = canmatrix.Frame(frame_name, size=dlc)
if frame_id.endswith("xh"):
new_frame.arbitration_id = canmatrix.ArbitrationId(
int(frame_id[:-2], 16), extended=True)
else:
new_frame.arbitration_id = canmatrix.ArbitrationId(
int(frame_id[:-2], 16), extended=False)
db.add_frame(new_frame)
# eval launch_type
if launch_type is not None:
new_frame.add_attribute("GenMsgSendType", launch_type)
if launch_type not in launch_types:
launch_types.append(launch_type)
# eval cycle time
try:
cycle_time = int(cycle_time)
except:
cycle_time = 0
new_frame.add_attribute("GenMsgCycleTime", str(int(cycle_time)))
for additional_index in additional_inputs:
if "frame" in additional_inputs[additional_index]:
command_str = additional_inputs[additional_index].replace(
"frame", "new_frame")
command_str += "="
command_str += str(
sh.cell(row_num, additional_index).value)
exec(command_str)
# new signal detected
if sh.cell(row_num, index['signalName']).value != signal_name \
and len(sh.cell(row_num, index['signalName']).value) > 0:
# new Signal
receiver = []
start_byte = int(sh.cell(row_num, index['startbyte']).value)
start_bit = int(sh.cell(row_num, index['startbit']).value)
signal_name = sh.cell(row_num, index['signalName']).value
signal_comment = sh.cell(row_num,
index['signalComment']).value.strip()
signal_length = int(sh.cell(row_num, index['signalLength']).value)
signal_default = sh.cell(row_num, index['signalDefault']).value
signal_sna = sh.cell(row_num, index['signalSNA']).value
multiplex = None # type: typing.Union[str, int, None]
if signal_comment.startswith('Mode Signal:'):
multiplex = 'Multiplexor'
signal_comment = signal_comment[12:]
elif signal_comment.startswith('Mode '):
mux, signal_comment = signal_comment[4:].split(':', 1)
multiplex = int(mux.strip())
if index.get("byteorder", False):
signal_byte_order = sh.cell(row_num, index['byteorder']).value
if 'i' in signal_byte_order:
is_little_endian = True
else:
is_little_endian = False
else:
is_little_endian = True # Default Intel
is_signed = False
if signal_name != "-":
for x in range(index['ECUstart'], index['ECUend']):
if 's' in sh.cell(row_num, x).value:
new_frame.add_transmitter(sh.cell(0, x).value.strip())
if 'r' in sh.cell(row_num, x).value:
receiver.append(sh.cell(0, x).value.strip())
new_signal = canmatrix.Signal(
signal_name,
start_bit=(start_byte - 1) * 8 + start_bit,
size=int(signal_length),
is_little_endian=is_little_endian,
is_signed=is_signed,
receivers=receiver,
multiplex=multiplex)
if not is_little_endian:
# motorola
if motorola_bit_format == "msb":
new_signal.set_startbit(
(start_byte - 1) * 8 + start_bit, bitNumbering=1)
elif motorola_bit_format == "msbreverse":
new_signal.set_startbit((start_byte - 1) * 8 +
start_bit)
else: # motorola_bit_format == "lsb"
new_signal.set_startbit(
(start_byte - 1) * 8 + start_bit,
bitNumbering=1,
startLittle=True)
for additional_index in additional_inputs: # todo explain this possibly dangerous code with eval
if "signal" in additional_inputs[additional_index]:
command_str = additional_inputs[
additional_index].replace("signal", "new_signal")
command_str += "="
command_str += str(
sh.cell(row_num, additional_index).value)
if len(str(sh.cell(row_num,
additional_index).value)) > 0:
exec(command_str)
new_frame.add_signal(new_signal)
new_signal.add_comment(signal_comment)
function = sh.cell(row_num, index['function']).value
value = str(sh.cell(row_num, index['Value']).value)
value_name = sh.cell(row_num, index['ValueName']).value
if value_name == 0:
value_name = "0"
elif value_name == 1:
value_name = "1"
# .encode('utf-8')
unit = ""
factor = sh.cell(row_num, index['function']).value
if isinstance(factor, past.builtins.basestring):
factor = factor.strip()
if " " in factor and factor[0].isdigit():
(factor, unit) = factor.strip().split(" ", 1)
factor = factor.strip()
unit = unit.strip()
new_signal.unit = unit
try:
new_signal.factor = float_factory(factor)
except:
logger.warning(
"Some error occurred while decoding scale of Signal %s: '%s'",
signal_name,
sh.cell(row_num, index['function']).value)
else:
unit = factor.strip()
new_signal.unit = unit
new_signal.factor = 1
(mini, maxi, offset,
value_table) = parse_value_name_column(value_name, value,
new_signal.size, float_factory)
if new_signal.min is None:
new_signal.min = mini
if new_signal.max is None:
new_signal.max = maxi
if new_signal.offset is None:
new_signal.offset = offset
if value_table is not None:
for value, name in value_table.items():
new_signal.add_values(value, name)
for frame in db.frames:
frame.update_receiver()
frame.calc_dlc()
launch_type_enum = "ENUM"
launch_type_enum += ",".join([
' "{}"'.format(launch_type) for launch_type in launch_types
if launch_type
])
db.add_frame_defines("GenMsgSendType", launch_type_enum)
db.set_fd_type()
return db
def load(f, **options):
# type: (typing.IO, **typing.Any) -> typing.Dict[str, canmatrix.CanMatrix]
float_factory = options.get("float_factory",
default_float_factory) # type: typing.Callable
dbs = {} # type: typing.Dict[str, canmatrix.CanMatrix]
tree = etree.parse(f)
root = tree.getroot()
namespace = "{" + tree.xpath('namespace-uri(.)') + "}"
node_list = {}
nodes = root.findall('./' + namespace + 'Node')
buses = root.findall('./' + namespace + 'Bus')
counter = 0
for bus in buses:
db = canmatrix.CanMatrix()
db.add_frame_defines("GenMsgCycleTime", 'INT 0 65535')
for node in nodes:
db.ecus.append(canmatrix.Ecu(node.get('name')))
node_list[node.get('id')] = node.get('name')
messages = bus.findall('./' + namespace + 'Message')
for message in messages:
dlc = None
# new_frame = Frame(int(message.get('id'), 16), message.get('name'), 1, None)
new_frame = canmatrix.Frame(message.get('name'))
if 'triggered' in message.attrib:
new_frame.add_attribute("GenMsgCycleTime",
message.get('interval'))
if 'length' in message.attrib:
dlc = int(message.get('length'))
new_frame.size = dlc
if 'format' in message.attrib and message.get(
'format') == "extended":
new_frame.arbitration_id = canmatrix.ArbitrationId(
int(message.get('id'), 16), extended=True)
else:
new_frame.arbitration_id = canmatrix.ArbitrationId(
int(message.get('id'), 16), extended=False)
multiplex = message.find('./' + namespace + 'Multiplex')
if multiplex is not None:
start_bit = 0
if 'offset' in multiplex.attrib:
start_bit = int(multiplex.get('offset'))
signal_size = 1
if 'length' in multiplex.attrib:
signal_size = int(multiplex.get('length'))
is_little_endian = True
min_value = None
max_value = None
values = multiplex.find('./' + namespace + 'Value')
if values is not None:
if 'min' in values.attrib:
min_value = float_factory(values.get('min'))
if 'max' in values.attrib:
max_value = float_factory(values.get('max'))
unit = ""
offset = float_factory('0')
factor = float_factory('1')
is_signed = False
if 'type' in multiplex.attrib:
if multiplex.get('type') == 'signed':
is_signed = True
receiver_names = [] # type: typing.List[str]
consumers = multiplex.findall('./' + namespace + 'Consumer')
for consumer in consumers:
node_refs = consumer.findall('./' + namespace + 'NodeRef')
for node_ref in node_refs:
receiver_names.append(node_list[node_ref.get('id')])
new_signal = canmatrix.Signal(
multiplex.get('name'),
start_bit=int(start_bit),
size=int(signal_size),
is_little_endian=is_little_endian,
is_signed=is_signed,
factor=factor,
offset=offset,
unit=unit,
receivers=receiver_names,
multiplex='Multiplexor')
if min_value is not None:
new_signal.min = min_value
if max_value is not None:
new_signal.max = max_value
if is_little_endian is False:
# motorola/big_endian set/convert startbit
new_signal.set_startbit(start_bit)
notes = multiplex.findall('./' + namespace + 'Notes')
comment = ""
for note in notes:
comment += note.text
new_signal.add_comment(comment)
label_sets = multiplex.findall('./' + namespace + 'LabelSet')
for label_set in label_sets:
labels = label_set.findall('./' + namespace + 'Label')
for label in labels:
name = label.get('name')
value = label.get('value')
new_signal.add_values(value, name)
new_frame.add_signal(new_signal)
mux_groups = multiplex.findall('./' + namespace + 'MuxGroup')
for mux_group in mux_groups:
mux = mux_group.get('count')
signals = mux_group.findall('./' + namespace + 'Signal')
for signal in signals:
new_signal = parse_signal(signal, mux, namespace,
node_list, float_factory)
new_frame.add_signal(new_signal)
signals = message.findall('./' + namespace + 'Signal')
producers = message.findall('./' + namespace + 'Producer')
for producer in producers:
node_refs = producer.findall('./' + namespace + 'NodeRef')
for node_ref in node_refs:
new_frame.add_transmitter(node_list[node_ref.get('id')])
for signal in signals:
new_signal = parse_signal(signal, None, namespace, node_list,
float_factory)
new_frame.add_signal(new_signal)
notes = message.findall('./' + namespace + 'Notes')
comment = ""
for note in notes:
if note.text is not None:
comment += note.text
new_frame.add_comment(comment)
if dlc is None:
new_frame.calc_dlc()
else:
new_frame.size = dlc
new_frame.update_receiver()
db.add_frame(new_frame)
name = bus.get('name')
if not name:
name = "CAN%d" % counter
counter += 1
dbs[name] = db
return dbs
def convert(infile, out_file_name,
**options): # type: (str, str, **str) -> None
logger.info("Importing " + infile + " ... ")
dbs = canmatrix.formats.loadp(infile, **options)
logger.info("done\n")
logger.info("Exporting " + out_file_name + " ... ")
out_dbs = {} # type: typing.Dict[str, canmatrix.CanMatrix]
for name in dbs:
db = None
if options.get('ecus', False):
ecu_list = options['ecus'].split(',')
db = canmatrix.CanMatrix()
direction = None
for ecu in ecu_list:
if ":" in ecu:
ecu, direction = ecu.split(":")
canmatrix.copy.copy_ecu_with_frames(ecu,
dbs[name],
db,
rx=(direction != "tx"),
tx=(direction != "rx"))
if options.get('frames', False):
frame_list = options['frames'].split(',')
db = canmatrix.CanMatrix() if db is None else db
for frame_name in frame_list:
frame_to_copy = dbs[name].frame_by_name(frame_name)
canmatrix.copy.copy_frame(frame_to_copy.arbitration_id,
dbs[name], db)
if options.get('signals', False):
signal_list = options['signals'].split(',')
db = canmatrix.CanMatrix() if db is None else db
for signal_name in signal_list:
canmatrix.copy.copy_signal(signal_name, dbs[name], db)
if db is None:
db = dbs[name]
if 'merge' in options and options['merge'] is not None:
merge_files = options['merge'].split(',')
for database in merge_files:
merge_string = database.split(':')
db_temp_list = canmatrix.formats.loadp(merge_string[0])
for dbTemp in db_temp_list:
if merge_string.__len__() == 1:
print("merge complete: " + merge_string[0])
db.merge([db_temp_list[dbTemp]])
# for frame in db_temp_list[dbTemp].frames:
# copyResult = canmatrix.copy.copy_frame(frame.id, db_temp_list[dbTemp], db)
# if copyResult == False:
# logger.error("ID Conflict, could not copy/merge frame " + frame.name + " %xh " % frame.id + database)
for mergeOpt in merge_string[1:]:
if mergeOpt.split('=')[0] == "ecu":
canmatrix.copy.copy_ecu_with_frames(
mergeOpt.split('=')[1], db_temp_list[dbTemp],
db)
if mergeOpt.split('=')[0] == "frame":
frame_to_copy = db_temp_list[name].frame_by_name(
mergeOpt.split('=')[1])
canmatrix.copy.copy_frame(
frame_to_copy.arbitration_id,
db_temp_list[dbTemp], db)
if 'renameEcu' in options and options['renameEcu'] is not None:
rename_tuples = options['renameEcu'].split(',')
for renameTuple in rename_tuples:
old, new = renameTuple.split(':')
db.rename_ecu(old, new)
if 'deleteEcu' in options and options['deleteEcu'] is not None:
delete_ecu_list = options['deleteEcu'].split(',')
for ecu in delete_ecu_list:
db.del_ecu(ecu)
if 'renameFrame' in options and options['renameFrame'] is not None:
rename_tuples = options['renameFrame'].split(',')
for renameTuple in rename_tuples:
old, new = renameTuple.split(':')
db.rename_frame(old, new)
if 'deleteFrame' in options and options['deleteFrame'] is not None:
delete_frame_names = options['deleteFrame'].split(',')
for frame_name in delete_frame_names:
db.del_frame(frame_name)
if 'addFrameReceiver' in options and options[
'addFrameReceiver'] is not None:
touples = options['addFrameReceiver'].split(',')
for touple in touples:
(frameName, ecu) = touple.split(':')
frames = db.glob_frames(frameName)
for frame in frames:
for signal in frame.signals:
signal.add_receiver(ecu)
frame.update_receiver()
if 'frameIdIncrement' in options and options[
'frameIdIncrement'] is not None:
id_increment = int(options['frameIdIncrement'])
for frame in db.frames:
frame.arbitration_id.id += id_increment
if 'changeFrameId' in options and options['changeFrameId'] is not None:
change_tuples = options['changeFrameId'].split(',')
for renameTuple in change_tuples:
old, new = renameTuple.split(':')
frame = db.frame_by_id(canmatrix.ArbitrationId(int(old)))
if frame is not None:
frame.arbitration_id.id = int(new)
else:
logger.error("frame with id {} not found", old)
if 'setFrameFd' in options and options['setFrameFd'] is not None:
fd_frame_list = options['setFrameFd'].split(',')
for frame_name in fd_frame_list:
frame_ptr = db.frame_by_name(frame_name)
if frame_ptr is not None:
frame_ptr.is_fd = True
if 'unsetFrameFd' in options and options['unsetFrameFd'] is not None:
fd_frame_list = options['unsetFrameFd'].split(',')
for frame_name in fd_frame_list:
frame_ptr = db.frame_by_name(frame_name)
if frame_ptr is not None:
frame_ptr.is_fd = False
frame_ptr.del_attribute("VFrameFormat")
if 'skipLongDlc' in options and options['skipLongDlc'] is not None:
delete_frame_list = [
frame for frame in db.frames
if frame.size > int(options['skipLongDlc'])
]
for frame in delete_frame_list:
db.del_frame(frame)
if 'cutLongFrames' in options and options['cutLongFrames'] is not None:
for frame in db.frames:
if frame.size > int(options['cutLongFrames']):
delete_signal_list = [
sig for sig in frame.signals if sig.get_startbit() +
int(sig.size) > int(options['cutLongFrames']) * 8
]
for sig in delete_signal_list:
frame.signals.remove(sig)
frame.size = 0
frame.calc_dlc()
if 'renameSignal' in options and options['renameSignal'] is not None:
rename_tuples = options['renameSignal'].split(',')
for renameTuple in rename_tuples:
old, new = renameTuple.split(':')
db.rename_signal(old, new)
if 'deleteSignal' in options and options['deleteSignal'] is not None:
delete_signal_names = options['deleteSignal'].split(',')
for signal_name in delete_signal_names:
db.del_signal(signal_name)
if 'deleteZeroSignals' in options and options['deleteZeroSignals']:
db.delete_zero_signals()
if 'deleteSignalAttributes' in options and options[
'deleteSignalAttributes']:
unwanted_attributes = options['deleteSignalAttributes'].split(',')
db.del_signal_attributes(unwanted_attributes)
if 'deleteFrameAttributes' in options and options[
'deleteFrameAttributes']:
unwanted_attributes = options['deleteFrameAttributes'].split(',')
db.del_frame_attributes(unwanted_attributes)
if 'deleteObsoleteDefines' in options and options[
'deleteObsoleteDefines']:
db.delete_obsolete_defines()
if 'deleteObsoleteEcus' in options and options['deleteObsoleteEcus']:
db.delete_obsolete_ecus()
if 'recalcDLC' in options and options['recalcDLC']:
db.recalc_dlc(options['recalcDLC'])
logger.info(name)
logger.info("%d Frames found" % (db.frames.__len__()))
out_dbs[name] = db
if 'force_output' in options and options['force_output'] is not None:
canmatrix.formats.dumpp(out_dbs,
out_file_name,
export_type=options['force_output'],
**options)
else:
canmatrix.formats.dumpp(out_dbs, out_file_name, **options)
logger.info("done")