def test_database_database_container():
with database.Database('NIXNET_example') as db_1:
with database.Database('NIXNET_exampleLDF') as db_2:
db_3 = database.Database('NIXNET_example')
# test dunders
assert db_1 == db_3
assert db_1 != db_2
assert len({db_1, db_2, db_3}) == 2 # testing `__hash__`
print(repr(db_1))
db_3.close()
del db_3
def test_signal_dbc_signal_value_table():
database_filepath = os.path.join(os.path.dirname(__file__), 'databases\\attributes.dbc')
with database.Database(database_filepath) as db:
cluster = db.clusters['Cluster']
frame1 = cluster.frames['Msg1']
sig1 = frame1.mux_static_signals['Sig1']
sig2 = frame1.mux_static_signals['Sig2']
# test dunders
assert len(sig1.dbc_signal_value_table) == 3
assert len(sig2.dbc_signal_value_table) == 0
assert len({sig1.dbc_signal_value_table, sig1.dbc_signal_value_table}) == 1 # testing `__hash__`
assert len({sig1.dbc_signal_value_table, sig2.dbc_signal_value_table}) == 2 # testing `__hash__`
assert sig1.dbc_signal_value_table == sig1.dbc_signal_value_table
assert sig1.dbc_signal_value_table != sig2.dbc_signal_value_table
for key in sig1.dbc_signal_value_table:
print(sig1.dbc_signal_value_table[key])
# test container
assert sorted(sig1.dbc_signal_value_table.keys()) == ['High', 'Low', 'Zero']
assert sorted(sig1.dbc_signal_value_table.values()) == ['-10', '0', '4']
assert sorted(sig1.dbc_signal_value_table.items()) == [('High', '4'), ('Low', '-10'), ('Zero', '0')]
# test values
assert sig1.dbc_signal_value_table['Low'] == '-10'
assert sig1.dbc_signal_value_table['High'] == '4'
assert sig1.dbc_signal_value_table['Zero'] == '0'
def test_database_collection_container():
test_cluster_name = '__cluster__name__for__testing__'
with database.Database('NIXNET_example') as db:
collection_1 = db.clusters # type: _collection.DbCollection
collection_2 = db.clusters # type: _collection.DbCollection
collection_3 = db.clusters[
'CAN_Cluster'].ecus # type: _collection.DbCollection
# test dunders
assert collection_1 == collection_2
assert collection_1 != collection_3
assert len({collection_1, collection_2, collection_3
}) == 2 # testing `__hash__`
print(repr(collection_1))
for key in collection_1:
print(collection_1[key])
with pytest.raises(errors.XnetError):
print(collection_1[test_cluster_name])
with pytest.raises(TypeError):
print(collection_1[5])
# test '__del__' after using the add function
cluster = db.clusters.add(test_cluster_name)
assert (cluster == db.clusters[test_cluster_name])
del db.clusters[test_cluster_name]
with pytest.raises(errors.XnetError):
print(db.clusters[test_cluster_name])
# test container
assert len(list(collection_1.keys())) > 0
assert len(list(collection_1.values())) > 0
assert len(list(collection_1.items())) > 0
def test_signal_dbc_attributes():
database_filepath = os.path.join(os.path.dirname(__file__), 'databases\\attributes.dbc')
with database.Database(database_filepath) as db:
cluster = db.clusters['Cluster']
frame1 = cluster.frames['Msg1']
sig1 = frame1.mux_static_signals['Sig1']
sig2 = frame1.mux_static_signals['Sig2']
# test dunders
assert len(sig1.dbc_attributes) == 1
assert len({sig1.dbc_attributes, sig1.dbc_attributes}) == 1 # testing `__hash__`
assert len({sig1.dbc_attributes, sig2.dbc_attributes}) == 2 # testing `__hash__`
assert sig1.dbc_attributes == sig1.dbc_attributes
assert sig1.dbc_attributes != sig2.dbc_attributes
for key in sig1.dbc_attributes:
print(sig1.dbc_attributes[key])
# test container
assert sorted(sig2.dbc_attributes.keys()) == ['SigAttr1']
assert sorted(sig2.dbc_attributes.values()) == [('11', False)]
assert sorted(sig2.dbc_attributes.items()) == [('SigAttr1', ('11', False))]
# test values
assert sig1.dbc_attributes['SigAttr1'] == ('1', True)
assert sig2.dbc_attributes['SigAttr1'] == ('11', False)
def test_database_signal_properties():
with database.Database('NIXNET_example') as db:
signal = db.find(database.Signal, 'CANCyclicSignal1') # type: database.Signal
# test references
print(signal.frame)
print(signal.pdu)
with pytest.raises(errors.XnetError):
print(signal.mux_subfrm)
# test setters
signal.byte_ordr = constants.SigByteOrdr.BIG_ENDIAN
signal.data_type = constants.SigDataType.IEEE_FLOAT
signal.comment = 'This is a comment.'
signal.default = signal.default
signal.max = signal.max
signal.min = signal.min
signal.name = 'NewSignalName'
signal.num_bits = signal.num_bits
signal.scale_fac = signal.scale_fac
signal.scale_off = signal.scale_off
signal.start_bit = signal.start_bit
signal.unit = 'Volts'
signal.mux_is_data_mux = signal.mux_is_data_mux
# test getters
print(signal.byte_ordr)
print(signal.comment)
print(signal.data_type)
print(signal.name)
print(signal.name_unique_to_cluster)
print(signal.unit)
print(signal.mux_is_dynamic)
print(signal.mux_value)
def test_database_frame_properties_common():
with database.Database('NIXNET_example') as db:
frame = db.find(database.Frame,
'CANCyclicFrame1') # type: database.Frame
# test references
print(frame.cluster)
assert len(list(frame.sigs)) > 0
assert len(list(frame.pdu_properties)) > 0
assert len(frame.mux_static_signals) > 0
assert len(frame.mux_subframes) == 0
with pytest.raises(errors.XnetError):
print(frame.mux_data_mux_sig)
# test setters
frame.application_protocol = constants.AppProtocol.NONE
frame.comment = 'This is a comment.'
frame.default_payload = list(frame.default_payload)
frame.id = frame.id
frame.name = 'NewFrameName'
frame.payload_len = frame.payload_len
frame.variable_payload = frame.variable_payload
# test getters
print(frame.application_protocol)
print(frame.comment)
print(frame.name)
print(frame.mux_is_muxed)
def test_database_frame_properties_can():
with database.Database('NIXNET_example') as db:
frame = db.find(database.Frame,
'CANCyclicFrame1') # type: database.Frame
frame.can_ext_id = frame.can_ext_id
frame.can_tx_time = frame.can_tx_time
frame.can_timing_type = constants.FrmCanTiming.CYCLIC_DATA
print(frame.can_timing_type)
def test_database_database_save():
# Avoid using an installed example database for saving to ensure those aren't modified.
# Instead, save the pre-existing 'attributes.dbc' database to a temp XML (FIBEX).
input_filepath = os.path.join(os.path.dirname(__file__),
'databases\\attributes.dbc')
output_filepath = tempfile.NamedTemporaryFile(suffix='.xml',
delete=False).name
with database.Database(input_filepath) as db:
db.save(output_filepath)
def test_database_subframe_functions():
with database.Database('NIXNET_example') as db:
frame = db.find(database.Frame,
'CANCyclicFrame1') # type: database.Frame
subframe = frame.mux_subframes.add(
'subframe1') # type: database.SubFrame
subframe.check_config_status()
with pytest.raises(errors.XnetError):
subframe.find(database.Signal, 'signal_name')
def test_database_frame_container():
with database.Database('NIXNET_example') as db:
cluster = db.clusters['CAN_Cluster'] # type: database.Cluster
frame_1 = cluster.frames['CANCyclicFrame1'] # type: database.Frame
frame_2 = cluster.frames['CANCyclicFrame1'] # type: database.Frame
frame_3 = cluster.frames['CANCyclicFrame2'] # type: database.Frame
# test dunders
assert frame_1 == frame_2
assert frame_1 != frame_3
assert len({frame_1, frame_2, frame_3}) == 2 # testing `__hash__`
print(repr(frame_1))
def test_database_lin_sched_container():
with database.Database('NIXNET_exampleLDF') as db:
cluster = db.clusters['Cluster'] # type: database.Cluster
sched_1 = cluster.lin_schedules['FastSchedule'] # type: database.LinSched
sched_2 = cluster.lin_schedules['FastSchedule'] # type: database.LinSched
sched_3 = cluster.lin_schedules['SlowSchedule'] # type: database.LinSched
# test dunders
assert sched_1 == sched_2
assert sched_1 != sched_3
assert len({sched_1, sched_2, sched_3}) == 2 # testing `__hash__`
print(repr(sched_1))
def test_database_ecu_container():
with database.Database('NIXNET_example') as db:
cluster = db.clusters['CAN_Demo_Box_Cluster'] # type: database.Cluster
ecu_1 = cluster.ecus['CAN_Demo_Box'] # type: database.Ecu
ecu_2 = cluster.ecus['CAN_Demo_Box'] # type: database.Ecu
ecu_3 = cluster.ecus['PC_Master'] # type: database.Ecu
# test dunders
assert ecu_1 == ecu_2
assert ecu_1 != ecu_3
assert len({ecu_1, ecu_2, ecu_3}) == 2 # testing `__hash__`
print(repr(ecu_1))
def test_database_pdu_container():
with database.Database('NIXNET_example') as db:
cluster = db.clusters['CAN_Cluster'] # type: database.Cluster
pdu_1 = cluster.pdus['CANCyclicFrame1_pdu'] # type: database.Pdu
pdu_2 = cluster.pdus['CANCyclicFrame1_pdu'] # type: database.Pdu
pdu_3 = cluster.pdus['CANCyclicFrame2_pdu'] # type: database.Pdu
# test dunders
assert pdu_1 == pdu_2
assert pdu_1 != pdu_3
assert len({pdu_1, pdu_2, pdu_3}) == 2 # testing `__hash__`
print(repr(pdu_1))
def test_database_signal_container():
with database.Database('NIXNET_example') as db:
cluster = db.clusters['CAN_Cluster'] # type: database.Cluster
frame = cluster.frames['CANCyclicFrame1'] # type: database.Frame
sig_1 = frame.mux_static_signals['CANCyclicSignal1'] # type: database.Signal
sig_2 = frame.mux_static_signals['CANCyclicSignal1'] # type: database.Signal
sig_3 = frame.mux_static_signals['CANCyclicSignal2'] # type: database.Signal
# test dunders
assert sig_1 == sig_2
assert sig_1 != sig_3
assert len({sig_1, sig_2, sig_3}) == 2 # testing `__hash__`
print(repr(sig_1))
def test_database_lin_sched_entry_container():
with database.Database('NIXNET_exampleLDF') as db:
cluster = db.clusters['Cluster'] # type: database.Cluster
sched = cluster.lin_schedules['FastSchedule'] # type: database.LinSched
entry_1 = sched.entries['se1'] # type: database.LinSchedEntry
entry_2 = sched.entries['se1'] # type: database.LinSchedEntry
entry_3 = sched.entries['se2'] # type: database.LinSchedEntry
# test dunders
assert entry_1 == entry_2
assert entry_1 != entry_3
assert len({entry_1, entry_2, entry_3}) == 2 # testing `__hash__`
print(repr(entry_1))
def test_database_ecu_properties():
with database.Database('NIXNET_exampleLDF') as db:
ecu = db.find(database.Ecu, 'Master1') # type: database.Ecu
# test references
assert len(list(ecu.rx_frms)) > 0
assert len(list(ecu.tx_frms)) > 0
# test setters
ecu.comment = 'This is a comment.'
ecu.name = 'NewEcuName'
# test getters
print(ecu.clst)
print(ecu.comment)
print(ecu.name)
def test_database_subframe_container():
with database.Database('NIXNET_example') as db:
cluster = db.clusters['CAN_Cluster'] # type: database.Cluster
frame = cluster.frames['CANCyclicFrame1'] # type: database.Frame
subframe_1 = frame.mux_subframes.add(
'subframe1') # type: database.SubFrame
subframe_2 = frame.find(database.SubFrame,
'subframe1') # type: database.SubFrame
subframe_3 = frame.mux_subframes.add(
'subframe3') # type: database.SubFrame
# test dunders
assert subframe_1 == subframe_2
assert subframe_1 != subframe_3
assert len({subframe_1, subframe_2, subframe_3
}) == 2 # testing `__hash__`
print(repr(subframe_1))
def test_database_lin_sched_properties():
with database.Database('NIXNET_exampleLDF') as db:
sched = db.find(database.LinSched, 'FastSchedule') # type: database.LinSched
# test references
print(sched.clst)
assert len(sched.entries) > 0
# test setters
sched.comment = 'This is a comment.'
sched.name = 'NewScheduleName'
sched.priority = sched.priority
sched.run_mode = constants.LinSchedRunMode.NULL
# test getters
print(sched.comment)
print(sched.name)
print(sched.run_mode)
def test_database_subframe_properties():
with database.Database('NIXNET_example') as db:
frame = db.find(database.Frame,
'CANCyclicFrame1') # type: database.Frame
subframe = frame.mux_subframes.add(
'subframe1') # type: database.SubFrame
# test references
print(subframe.frm)
print(subframe.pdu)
assert len(subframe.dyn_signals) == 0
# test setters
subframe.mux_value = 1
subframe.name = 'NewSubframeName'
# test getters
print(subframe.mux_value)
print(subframe.name)
print(subframe.name_unique_to_cluster)
def test_database_lin_sched_entry_properties():
with database.Database('NIXNET_exampleLDF') as db:
entry = db.find(database.LinSchedEntry, 'se1') # type: database.LinSchedEntry
# test references
assert len(list(entry.frames)) > 0
print(entry.sched)
with pytest.raises(errors.XnetError):
print(entry.collision_res_sched)
# test setters
entry.delay = entry.delay
entry.event_id = 1
entry.name = 'NewEntryName'
entry.type = entry.type
# test getters
print(entry.event_id)
print(entry.name)
print(entry.name_unique_to_cluster)
def test_database_ecu_properties_lin():
with database.Database('NIXNET_exampleLDF') as db:
ecu = db.find(database.Ecu, 'Master1') # type: database.Ecu
# test setters
ecu.lin_master = ecu.lin_master
ecu.lin_protocol_ver = constants.LinProtocolVer.VER_2_1
ecu.lin_initial_nad = 0
ecu.lin_config_nad = 0
ecu.lin_supplier_id = 0
ecu.lin_function_id = 0
ecu.lin_p2_min = 0
ecu.lin_st_min = 0
# test getters
print(ecu.lin_protocol_ver)
print(ecu.lin_initial_nad)
print(ecu.lin_config_nad)
print(ecu.lin_supplier_id)
print(ecu.lin_function_id)
print(ecu.lin_p2_min)
print(ecu.lin_st_min)
def test_database_pdu_properties():
with database.Database('NIXNET_example') as db:
pdu = db.find(database.Pdu,
'CANCyclicFrame1_pdu') # type: database.Pdu
# test references
print(pdu.cluster)
assert len(list(pdu.frms)) > 0
assert len(pdu.signals) > 0
assert len(list(pdu.mux_static_sigs)) > 0
assert len(list(pdu.mux_subframes)) == 0
with pytest.raises(errors.XnetError):
print(pdu.mux_data_mux_sig)
# test setters
pdu.comment = 'This is a comment.'
pdu.name = 'NewPduName'
pdu.payload_len = pdu.payload_len
# test getters
print(pdu.comment)
print(pdu.name)
print(pdu.mux_is_muxed)
def test_cluster_dbc_attributes():
database_filepath = os.path.join(os.path.dirname(__file__), 'databases\\attributes.dbc')
with database.Database(database_filepath) as db:
cluster = db.clusters['Cluster']
frame1 = cluster.frames['Msg1']
# test dunders
assert len(cluster.dbc_attributes) == 2
assert len({cluster.dbc_attributes, cluster.dbc_attributes}) == 1 # testing `__hash__`
assert len({cluster.dbc_attributes, frame1.dbc_attributes}) == 2 # testing `__hash__`
assert cluster.dbc_attributes == cluster.dbc_attributes
assert cluster.dbc_attributes != frame1.dbc_attributes
for key in cluster.dbc_attributes:
print(cluster.dbc_attributes[key])
# test container
assert sorted(cluster.dbc_attributes.keys()) == ['BusType', 'NetworkAttr1']
assert sorted(cluster.dbc_attributes.values()) == [('CAN', True), ('abc', True)]
assert sorted(cluster.dbc_attributes.items()) == [('BusType', ('CAN', True)), ('NetworkAttr1', ('abc', True))]
# test values
assert cluster.dbc_attributes['BusType'] == ('CAN', True)
assert cluster.dbc_attributes['NetworkAttr1'] == ('abc', True)
def test_ecu_dbc_attributes():
database_filepath = os.path.join(os.path.dirname(__file__), 'databases\\attributes.dbc')
with database.Database(database_filepath) as db:
cluster = db.clusters['Cluster']
ecu1 = cluster.ecus['ECU1']
ecu2 = cluster.ecus['ECU2']
# test dunders
assert len(ecu1.dbc_attributes) == 1
assert len({ecu1.dbc_attributes, ecu1.dbc_attributes}) == 1 # testing `__hash__`
assert len({ecu1.dbc_attributes, ecu2.dbc_attributes}) == 2 # testing `__hash__`
assert ecu1.dbc_attributes == ecu1.dbc_attributes
assert ecu1.dbc_attributes != ecu2.dbc_attributes
for key in ecu1.dbc_attributes:
print(ecu1.dbc_attributes[key])
# test container
assert sorted(ecu1.dbc_attributes.keys()) == ['EcuAttr1']
assert sorted(ecu1.dbc_attributes.items()) == [('EcuAttr1', ('xEcu1', True))]
assert sorted(ecu1.dbc_attributes.values()) == [('xEcu1', True)]
# test values
assert ecu1.dbc_attributes['EcuAttr1'] == ('xEcu1', True)
assert ecu2.dbc_attributes['EcuAttr1'] == ('xEcu2-Set', False)
def test_frame_dbc_attributes():
database_filepath = os.path.join(os.path.dirname(__file__), 'databases\\attributes.dbc')
with database.Database(database_filepath) as db:
cluster = db.clusters['Cluster']
frame1 = cluster.frames['Msg1']
frame2 = cluster.frames['Msg2']
# test dunders
assert len(frame1.dbc_attributes) == 4
assert len({frame1.dbc_attributes, frame1.dbc_attributes}) == 1 # testing `__hash__`
assert len({frame1.dbc_attributes, frame2.dbc_attributes}) == 2 # testing `__hash__`
assert frame1.dbc_attributes == frame1.dbc_attributes
assert frame1.dbc_attributes != frame2.dbc_attributes
for key in frame1.dbc_attributes:
print(frame1.dbc_attributes[key])
# test container
assert sorted(frame1.dbc_attributes.keys()) == ['MsgAttr1', 'MsgAttr2', 'MsgAttr3', 'MsgAttr4']
assert sorted(frame1.dbc_attributes.values()) == [('-11.1', True),
('2', True),
('2', True),
('DefaultMsgAttr3String', True)]
assert sorted(frame1.dbc_attributes.items()) == [('MsgAttr1', ('2', True)),
('MsgAttr2', ('-11.1', True)),
('MsgAttr3', ('DefaultMsgAttr3String', True)),
('MsgAttr4', ('2', True))]
# test values
assert frame1.dbc_attributes['MsgAttr1'] == ('2', True)
assert frame1.dbc_attributes['MsgAttr2'] == ('-11.1', True)
assert frame1.dbc_attributes['MsgAttr3'] == ('DefaultMsgAttr3String', True)
assert frame1.dbc_attributes['MsgAttr4'] == ('2', True)
assert frame2.dbc_attributes['MsgAttr1'] == ('22', False)
assert frame2.dbc_attributes['MsgAttr2'] == ('-23.33', False)
assert frame2.dbc_attributes['MsgAttr3'] == ('MsgAttr3String', False)
assert frame2.dbc_attributes['MsgAttr4'] == ('1', False)
def main():
database_name = ':memory:'
cluster_name = 'LIN_Cluster'
ecu_1_name = 'LIN_ECU_1'
ecu_2_name = 'LIN_ECU_2'
schedule_name = 'LIN_Schedule_1'
schedule_entry_name = 'LIN_Schedule_Entry'
frame_name = 'LIN_Frame'
signal_1_name = 'LIN_Signal_1'
signal_2_name = 'LIN_Signal_2'
signal_list = [signal_1_name, signal_2_name]
output_interface = 'LIN1'
input_interface = 'LIN2'
# Open the default in-memory database.
with database.Database(database_name) as db:
# Add a LIN cluster, a frame, and two signals to the database.
cluster = db.clusters.add(cluster_name)
cluster.protocol = constants.Protocol.LIN
cluster.baud_rate = 19200
frame = cluster.frames.add(frame_name)
frame.id = 1
frame.payload_len = 2
signal_1 = frame.mux_static_signals.add(signal_1_name)
signal_1.byte_ordr = constants.SigByteOrdr.BIG_ENDIAN
signal_1.data_type = constants.SigDataType.UNSIGNED
signal_1.start_bit = 0
signal_1.num_bits = 8
signal_2 = frame.mux_static_signals.add(signal_2_name)
signal_2.byte_ordr = constants.SigByteOrdr.BIG_ENDIAN
signal_2.data_type = constants.SigDataType.UNSIGNED
signal_2.start_bit = 8
signal_2.num_bits = 8
# Add a LIN ECU and LIN Schedule to the cluster.
ecu_1 = cluster.ecus.add(ecu_1_name)
ecu_1.lin_protocol_ver = constants.LinProtocolVer.VER_2_2
ecu_1.lin_master = True
ecu_2 = cluster.ecus.add(ecu_2_name)
ecu_2.lin_protocol_ver = constants.LinProtocolVer.VER_2_2
ecu_2.lin_master = False
cluster.lin_tick = 0.01
schedule = cluster.lin_schedules.add(schedule_name)
schedule.priority = 0
schedule.run_mode = constants.LinSchedRunMode.CONTINUOUS
schedule_entry = schedule.entries.add(schedule_entry_name)
schedule_entry.delay = 1000.0
schedule_entry.type = constants.LinSchedEntryType.UNCONDITIONAL
schedule_entry.frames = [frame]
# Using the database we just created, write and then read a pair of signals.
with nixnet.SignalOutSinglePointSession(output_interface,
database_name, cluster_name,
signal_list) as output_session:
with nixnet.SignalInSinglePointSession(
input_interface, database_name, cluster_name,
signal_list) as input_session:
terminated_cable = six.moves.input(
'Are you using a terminated cable (Y or N)? ')
if terminated_cable.lower() == "y":
input_session.intf.lin_term = constants.LinTerm.ON
output_session.intf.lin_term = constants.LinTerm.OFF
elif terminated_cable.lower() == "n":
input_session.intf.lin_term = constants.LinTerm.ON
output_session.intf.lin_term = constants.LinTerm.ON
else:
print("Unrecognised input ({}), assuming 'n'".format(
terminated_cable))
input_session.intf.lin_term = constants.LinTerm.ON
output_session.intf.lin_term = constants.LinTerm.ON
# Start the input session manually to make sure that the first
# signal values sent before the initial read will be received.
input_session.start()
# Set the schedule. This will also automatically enable master mode.
output_session.change_lin_schedule(0)
# Generate a pair of random values and send out the signals.
output_values = [randint(0, 255), randint(0, 255)]
output_session.signals.write(output_values)
print('Sent signal values: {}'.format(output_values))
# Wait 1 s and then read the received values.
# They should be the same as the ones sent.
time.sleep(1)
input_signals = input_session.signals.read()
input_values = [
int(value) for timestamp, value in input_signals
]
print('Received signal values: {}'.format(input_values))
def test_database_frame_properties_lin():
with database.Database('NIXNET_exampleLDF') as db:
frame = db.find(database.Frame, 'MasterFrame1') # type: database.Frame
print(frame.lin_checksum)
def test_database_frame_functions():
with database.Database('NIXNET_example') as db:
frame = db.find(database.Frame,
'CANCyclicFrame1') # type: database.Frame
frame.check_config_status()
frame.find(database.Signal, 'CANCyclicSignal1')
def test_database_database_properties():
with database.Database('NIXNET_example') as db:
assert len(db.clusters) > 0
assert db.name == 'NIXNET_example'
db.show_invalid_from_open = db.show_invalid_from_open
def test_database_database_find():
with database.Database('NIXNET_example') as db:
cluster = db.clusters['CAN_Cluster'] # type: database.Cluster
frame_1 = cluster.frames['CANEventFrame1']
frame_2 = db.find(database.Frame, 'CANEventFrame1')
assert frame_1 == frame_2
