def test_wait_for_intf_remote_wakeup(can_in_interface, can_out_interface):
"""Verifies wait_for_intf_remote_wakeup does not fail catastrophically.
We can at least see how long it takes us to wait. Longer term, we should
switch the test to start waiting and then call ``input_session.start`` and
ensure it unblocks after that call.
To see the wait time, run py.test with ``-s``_.
Assumes test_frames.test_queued_loopback works.
"""
database_name = 'NIXNET_example'
cluster_name = 'CAN_Cluster'
frame_name = 'CANEventFrame1'
with nixnet.FrameInQueuedSession(
can_in_interface,
database_name,
cluster_name,
frame_name) as input_session:
input_session.start()
input_session.intf.can_tcvr_state = constants.CanTcvrState.SLEEP
assert input_session.can_comm.sleep
with pytest.raises(errors.XnetError) as excinfo:
input_session.wait_for_intf_remote_wakeup(5)
assert excinfo.value.error_type == constants.Err.EVENT_TIMEOUT
def test_queued_loopback(can_in_interface, can_out_interface):
database_name = 'NIXNET_example'
cluster_name = 'CAN_Cluster'
frame_name = 'CANEventFrame1'
with nixnet.FrameInQueuedSession(can_in_interface, database_name,
cluster_name,
frame_name) as input_session:
with nixnet.FrameOutQueuedSession(can_out_interface, database_name,
cluster_name,
frame_name) as output_session:
# Start the input session manually to make sure that the first
# frame value sent before the initial read will be received.
input_session.start()
payload_list = [2, 4, 8, 16]
expected_frames = [
types.CanFrame(66, constants.FrameType.CAN_DATA,
bytes(bytearray(payload_list)))
]
output_session.frames.write(expected_frames)
# Wait 1 s and then read the received values.
# They should be the same as the ones sent.
time.sleep(1)
actual_frames = list(input_session.frames.read(1))
assert len(expected_frames) == len(actual_frames)
for i, (expected,
actual) in enumerate(zip(expected_frames, actual_frames)):
assert_can_frame(i, expected, actual)
def test_wait_for_intf_communicating(can_in_interface):
"""Verifies wait_for_intf_communicating does not catastrophically fail.
Considering the wait time is so short, it'd be hard to verify it,
especially in a reproducible way.
Assumes test_frames.test_queued_loopback works.
"""
database_name = 'NIXNET_example'
cluster_name = 'CAN_Cluster'
frame_name = 'CANEventFrame1'
with nixnet.FrameInQueuedSession(
can_in_interface,
database_name,
cluster_name,
frame_name) as input_session:
input_session.start()
input_session.wait_for_intf_communicating()
expected_frames = []
actual_frames = list(input_session.frames.read(1))
assert len(expected_frames) == len(actual_frames)
for i, (expected, actual) in enumerate(zip(expected_frames, actual_frames)):
assert_can_frame(i, expected, actual)
def test_frames_container(nixnet_in_interface):
database_name = 'NIXNET_example'
cluster_name = 'CAN_Cluster'
frame_name = 'CANEventFrame1'
with nixnet.FrameInQueuedSession(nixnet_in_interface, database_name,
cluster_name,
frame_name) as input_session:
assert frame_name in input_session.frames
assert 0 in input_session.frames
assert len(input_session.frames) == 1
frames = list(input_session.frames)
assert len(frames) == 1
frame = frames[0]
assert str(frame) == frame_name
assert int(frame) == 0
assert frame == input_session.frames[0]
assert frame == input_session.frames[frame_name]
with pytest.raises(IndexError):
input_session.frames[1]
with pytest.raises(KeyError):
input_session.frames["<random>"]
assert frame == input_session.frames.get(0)
assert frame == input_session.frames.get(frame_name)
assert input_session.frames.get(1) is None
assert input_session.frames.get("<random>") is None
def test_sleep_transition(can_in_interface):
database_name = 'NIXNET_example'
cluster_name = 'CAN_Cluster'
frame_name = 'CANEventFrame1'
with nixnet.FrameInQueuedSession(
can_in_interface,
database_name,
cluster_name,
frame_name) as input_session:
assert not input_session.can_comm.sleep
with pytest.raises(errors.XnetError) as excinfo:
input_session.intf.can_tcvr_state = constants.CanTcvrState.SLEEP
assert excinfo.value.error_type == constants.Err.SESSION_NOT_STARTED
assert not input_session.can_comm.sleep
input_session.start()
assert not input_session.can_comm.sleep
input_session.intf.can_tcvr_state = constants.CanTcvrState.SLEEP
assert input_session.can_comm.sleep
input_session.intf.can_tcvr_state = constants.CanTcvrState.NORMAL
assert not input_session.can_comm.sleep
def test_session_j1939_properties(can_in_interface):
database_name = 'NIXNET_example'
cluster_name = 'J1939_Over_CAN'
frame_name = 'J1939_Gloabal_Event_HighPrio'
with nixnet.FrameInQueuedSession(can_in_interface, database_name,
cluster_name,
frame_name) as input_session:
# todo: Add testing to cover more J1939 properties.
input_session.j1939.include_dest_addr_in_pgn = True
assert input_session.j1939.include_dest_addr_in_pgn
def test_intf_container(nixnet_in_interface):
database_name = 'NIXNET_example'
cluster_name = 'CAN_Cluster'
frame_name = 'CANEventFrame1'
with nixnet.FrameInQueuedSession(nixnet_in_interface, database_name,
cluster_name,
frame_name) as input_session:
assert str(input_session.intf) == nixnet_in_interface
assert input_session.intf == nixnet_in_interface
assert input_session.intf != "<random>"
def test_wait_for_transmit_complete(can_in_interface, can_out_interface):
"""Verifies wait_for_transmit_complete does not fail catastrophically.
We can at least see how long it takes us to wait. Longer term, we should
switch the test to start waiting and then call ``input_session.start`` and
ensure it unblocks after that call.
To see the wait time, run py.test with ``-s``_.
Assumes test_frames.test_queued_loopback works.
"""
database_name = 'NIXNET_example'
cluster_name = 'CAN_Cluster'
frame_name = 'CANEventFrame1'
with nixnet.FrameInQueuedSession(
can_in_interface,
database_name,
cluster_name,
frame_name) as input_session:
with nixnet.FrameOutQueuedSession(
can_out_interface,
database_name,
cluster_name,
frame_name) as output_session:
output_session.auto_start = False
input_session.start()
expected_frames = [
types.CanFrame(66, constants.FrameType.CAN_DATA, b'\x01\x02\x03\x04'),
types.CanFrame(66, constants.FrameType.CAN_DATA, b'\x05\x06\x08\x09'),
types.CanFrame(66, constants.FrameType.CAN_DATA, b'\x01\x02\x03\x04'),
types.CanFrame(66, constants.FrameType.CAN_DATA, b'\x05\x06\x08\x09'),
types.CanFrame(66, constants.FrameType.CAN_DATA, b'\x01\x02\x03\x04'),
types.CanFrame(66, constants.FrameType.CAN_DATA, b'\x05\x06\x08\x09'),
types.CanFrame(66, constants.FrameType.CAN_DATA, b'\x01\x02\x03\x04'),
types.CanFrame(66, constants.FrameType.CAN_DATA, b'\x05\x06\x08\x09'),
types.CanFrame(66, constants.FrameType.CAN_DATA, b'\x01\x02\x03\x04'),
types.CanFrame(66, constants.FrameType.CAN_DATA, b'\x05\x06\x08\x09'),
types.CanFrame(66, constants.FrameType.CAN_DATA, b'\x01\x02\x03\x04'),
types.CanFrame(66, constants.FrameType.CAN_DATA, b'\x05\x06\x08\x09')]
output_session.start()
initial = time.time()
output_session.frames.write(expected_frames)
written = time.time()
output_session.wait_for_transmit_complete(10)
finished = time.time()
print("Write took {} s".format(written - initial))
print("Wait took {} s".format(finished - written))
def test_disconnect_terminals_failures(can_in_interface):
"""Verifies disconnect_terminals fails when expected to."""
database_name = 'NIXNET_example'
cluster_name = 'CAN_Cluster'
frame_name = 'CANEventFrame1'
with nixnet.FrameInQueuedSession(
can_in_interface,
database_name,
cluster_name,
frame_name) as input_session:
with pytest.raises(errors.XnetError) as excinfo:
input_session.disconnect_terminals("FrontPanel0", "FrontPanel1")
assert excinfo.value.error_type in [
constants.Err.SYNCHRONIZATION_NOT_ALLOWED,
constants.Err.INVALID_SYNCHRONIZATION_COMBINATION]
def test_session_frame_container(can_in_interface):
database_name = 'NIXNET_example'
cluster_name = 'CAN_Cluster'
frame_name = 'CANEventFrame1'
with nixnet.FrameInQueuedSession(can_in_interface, database_name,
cluster_name,
frame_name) as input_session:
frames = input_session.frames
assert len(frames) == 1, "Pre-requisite failed"
frame = frames[0]
assert frame == frame
assert not (frame == 5)
assert not (frame != frame)
assert frame != 5
print(repr(frame))
def test_flush_baseline(can_in_interface, can_out_interface):
"""Demonstrate that the non-flush version of the code works.
Assumes test_frames.test_queued_loopback works.
"""
database_name = 'NIXNET_example'
cluster_name = 'CAN_Cluster'
frame_name = 'CANEventFrame1'
with nixnet.FrameInQueuedSession(
can_in_interface,
database_name,
cluster_name,
frame_name) as input_session:
with nixnet.FrameOutQueuedSession(
can_out_interface,
database_name,
cluster_name,
frame_name) as output_session:
output_session.auto_start = False
input_session.start()
dropped_frames = [
types.CanFrame(66, constants.FrameType.CAN_DATA, b'\x01\x02\x03\x04')]
output_session.frames.write(dropped_frames)
expected_frames = [
types.CanFrame(66, constants.FrameType.CAN_DATA, b'\x05\x06\x08\x09')]
output_session.frames.write(expected_frames)
expected_frames = dropped_frames + expected_frames
output_session.start()
# Wait 1 s and then read the received values.
# They should be the same as the ones sent.
time.sleep(1)
actual_frames = list(input_session.frames.read(2))
assert len(expected_frames) == len(actual_frames)
for i, (expected, actual) in enumerate(zip(expected_frames, actual_frames)):
assert_can_frame(i, expected, actual)
def test_intf_container(can_in_interface):
database_name = 'NIXNET_example'
cluster_name = 'CAN_Cluster'
frame_name = 'CANEventFrame1'
with nixnet.FrameInQueuedSession(can_in_interface, database_name,
cluster_name,
frame_name) as input_session:
assert input_session.intf == input_session.intf
assert input_session.intf == can_in_interface
assert not (input_session.intf == "<random>")
assert not (input_session.intf == 5)
assert not (input_session.intf != input_session.intf)
assert not (input_session.intf != can_in_interface)
assert input_session.intf != "<random>"
assert input_session.intf != 5
assert str(input_session.intf) == can_in_interface
print(repr(input_session.intf))
def test_start_explicit(can_in_interface, can_out_interface):
"""Demonstrate that data is properly sent out on an explicit start.
Assumes test_frames.test_queued_loopback works
"""
database_name = 'NIXNET_example'
cluster_name = 'CAN_Cluster'
frame_name = 'CANEventFrame1'
with nixnet.FrameInQueuedSession(
can_in_interface,
database_name,
cluster_name,
frame_name) as input_session:
with nixnet.FrameOutQueuedSession(
can_out_interface,
database_name,
cluster_name,
frame_name) as output_session:
output_session.auto_start = False
# Start the input session manually to make sure that the first
# frame value sent before the initial read will be received.
input_session.start()
expected_frames = [
types.CanFrame(66, constants.FrameType.CAN_DATA, b'\x01\x02\x03\x04')]
output_session.frames.write(expected_frames)
output_session.start()
# Wait 1 s and then read the received values.
# They should be the same as the ones sent.
time.sleep(1)
actual_frames = list(input_session.frames.read(1))
assert len(expected_frames) == len(actual_frames)
for i, (expected, actual) in enumerate(zip(expected_frames, actual_frames)):
assert_can_frame(i, expected, actual)
def main():
database_name = 'NIXNET_example'
cluster_name = 'CAN_Cluster'
input_frame = 'CANEventFrame1'
output_frame = 'CANEventFrame1'
interface1 = 'CAN1'
interface2 = 'CAN2'
with nixnet.FrameInQueuedSession(interface1, database_name, cluster_name,
input_frame) as input_session:
with nixnet.FrameOutQueuedSession(interface2, database_name,
cluster_name,
output_frame) as output_session:
terminated_cable = six.moves.input(
'Are you using a terminated cable (Y or N)? ')
if terminated_cable.lower() == "y":
input_session.intf.can_term = constants.CanTerm.ON
output_session.intf.can_term = constants.CanTerm.OFF
elif terminated_cable.lower() == "n":
input_session.intf.can_term = constants.CanTerm.ON
output_session.intf.can_term = constants.CanTerm.ON
else:
print("Unrecognised input ({}), assuming 'n'".format(
terminated_cable))
input_session.intf.can_term = constants.CanTerm.ON
output_session.intf.can_term = constants.CanTerm.ON
# Start the input session manually to make sure that the first
# frame value sent before the initial read will be received.
input_session.start()
user_value = six.moves.input('Enter payload [int, int]: ')
try:
payload_list = [int(x.strip()) for x in user_value.split(",")]
except ValueError:
payload_list = [2, 4, 8, 16]
print('Unrecognized input ({}). Setting data buffer to {}',
user_value, payload_list)
id = 0
extended = False
payload = bytearray(payload_list)
frame = types.CanFrame(id, extended, constants.FrameType.CAN_DATA,
payload)
i = 0
while True:
for index, byte in enumerate(payload):
payload[index] = byte + i
frame.payload = payload
output_session.frames.write_can([frame])
print('Sent frame with ID %s payload: %s' % (id, payload))
# Wait 1 s and then read the received values.
# They should be the same as the ones sent.
time.sleep(1)
count = 1
frames = input_session.frames.read_can(count)
for frame in frames:
print('Received frame: ')
pp.pprint(frame)
i += 1
if max(payload) + i > 0xFF:
i = 0
inp = six.moves.input('Hit enter to continue (q to quit): ')
if inp.lower() == 'q':
break
print('Data acquisition stopped.')
