def test_voltage_reading(self, qtbot, sim_app, device_type):
flush_packets(sim_app, device_type)
snapshot = get_event_stats_snapshot()
sim_app.send_command(device_type.name + ".VOLT")
assert SINGLE_SENSOR_EVENT.wait(snapshot) == 1
last_battery_voltage = sim_app.rocket_data.last_value_by_device(
device_type, DataEntryIds.VOLTAGE)
assert (round(last_battery_voltage,
1) == VoltageSensor.NOMINAL_BATTERY_VOLTAGE)
# The ADC level of 863 gets converted to 10.9V in battery.cpp in FLARE 21899292dc39015570f795ef9e607081aab57e3e
updated_voltage_sensor = VoltageSensor(dummy_adc_level=863)
hw = get_hw_sim(sim_app, device_type)
hw.replace_sensor(updated_voltage_sensor)
flush_packets(sim_app, device_type)
snapshot = get_event_stats_snapshot()
sim_app.send_command(device_type.name + ".VOLT")
assert SINGLE_SENSOR_EVENT.wait(snapshot) == 1
last_battery_voltage = sim_app.rocket_data.last_value_by_device(
device_type, DataEntryIds.VOLTAGE)
assert (round(last_battery_voltage, 1) == 10.9)
def test_status_ping_packet(qtbot, single_connection_tantalus):
app = single_connection_tantalus
connection = app.connections['DEBUG_CONNECTION']
packet = radio_packets.status_ping(
0xFFFFFFFF, radio_packets.StatusType.CRITICAL_FAILURE, 0xFF, 0xFF,
0xFF, 0xFF)
snapshot = get_event_stats_snapshot()
connection.receive(packet)
assert BUNDLE_ADDED_EVENT.wait(snapshot) == 1
assert app.rocket_data.last_value_by_device(
DeviceType.TANTALUS_STAGE_1_FLARE, DataEntryIds.TIME) == 0xFFFFFFFF
assert (app.rocket_data.last_value_by_device(
DeviceType.TANTALUS_STAGE_1_FLARE,
DataEntryIds.OVERALL_STATUS) == DataEntryValues.STATUS_CRITICAL_FAILURE
)
for sensor in SENSOR_TYPES:
assert app.rocket_data.last_value_by_device(
DeviceType.TANTALUS_STAGE_1_FLARE, sensor) == 1
for other in OTHER_STATUS_TYPES:
assert app.rocket_data.last_value_by_device(
DeviceType.TANTALUS_STAGE_1_FLARE, other) == 1
def test_general_usage(self):
snapshot = get_event_stats_snapshot()
TEST_EVENT.increment()
ret = TEST_EVENT.wait(snapshot)
assert ret == 1
snapshot = get_event_stats_snapshot()
TEST_EVENT.increment(num=5)
ret = TEST_EVENT.wait(snapshot)
assert ret == 5
def test_bad_snapshot(self):
TEST_EVENT.increment()
snapshot = get_event_stats_snapshot()
snapshot[TEST_EVENT._key] += 1
with pytest.raises(ValueError) as ex:
TEST_EVENT.wait(snapshot)
def test_config_packet(qtbot, single_connection_tantalus):
app = single_connection_tantalus
connection = app.connections['DEBUG_CONNECTION']
version_id = REQUIRED_FLARE
assert len(
version_id) == VERSION_ID_LEN # make sure test val is acceptable
packet = radio_packets.config(0xFFFFFFFF, True, 0x00, version_id)
snapshot = get_event_stats_snapshot()
connection.receive(packet)
assert CONFIG_EVENT.wait(snapshot) == 1
assert BUNDLE_ADDED_EVENT.wait(snapshot) == 1
assert app.rocket_data.last_value_by_device(
DeviceType.TANTALUS_STAGE_1_FLARE, DataEntryIds.TIME) == 0xFFFFFFFF
assert app.rocket_data.last_value_by_device(
DeviceType.TANTALUS_STAGE_1_FLARE, DataEntryIds.IS_SIM) == True
assert app.rocket_data.last_value_by_device(
DeviceType.TANTALUS_STAGE_1_FLARE,
DataEntryIds.DEVICE_TYPE) == DeviceType.TANTALUS_STAGE_1_FLARE
assert app.rocket_data.last_value_by_device(
DeviceType.TANTALUS_STAGE_1_FLARE,
DataEntryIds.VERSION_ID) == version_id
def test_multi_connection_commands(qtbot, test_app):
con_a = DebugConnection(
'TANTALUS_STAGE_1_ADDRESS',
DEVICE_TYPE_TO_ID[DeviceType.TANTALUS_STAGE_1_FLARE],
generate_radio_packets=False)
con_b = DebugConnection(
'TANTALUS_STAGE_2_ADDRESS',
DEVICE_TYPE_TO_ID[DeviceType.TANTALUS_STAGE_2_FLARE],
generate_radio_packets=False)
con_a.send = MagicMock()
con_b.send = MagicMock()
snapshot = get_event_stats_snapshot()
app = test_app(TantalusProfile(), {
'DEBUG_CONNECTION_1': con_a,
'DEBUG_CONNECTION_2': con_b
},
num_devices=2)
# Fake some other device on same connection
con_a.device_address = 'OTHER_ADDRESS'
sample_version = '1234567890123456789012345678901234567890'
con_a.receive(
radio_packets.config(0xFFFFFFFF, True,
DEVICE_TYPE_TO_ID[DeviceType.CO_PILOT_FLARE],
sample_version))
assert DEVICE_REGISTERED_EVENT.wait(snapshot, num_expected=3) == 3
# Send commands to each and assert called
snapshot = get_event_stats_snapshot()
app.send_command("tantalus_stage_1_flare.arm")
COMMAND_SENT_EVENT.wait(snapshot)
con_a.send.assert_called_with('TANTALUS_STAGE_1_ADDRESS', ANY)
snapshot = get_event_stats_snapshot()
app.send_command("tantalus_stage_2_flare.arm")
COMMAND_SENT_EVENT.wait(snapshot)
con_b.send.assert_called_with('TANTALUS_STAGE_2_ADDRESS', ANY)
snapshot = get_event_stats_snapshot()
app.send_command("co_pilot_flare.arm")
COMMAND_SENT_EVENT.wait(snapshot)
con_a.send.assert_called_with('OTHER_ADDRESS', ANY)
def test_ground_rx(xbee):
snapshot = get_event_stats_snapshot()
xbee.send_to_rocket(b"HelloRocket") # 11 bytes
assert SENT_TO_ROCKET_EVENT.wait(snapshot) == 1
assert len(xbee.rocket_callback.call_args[0][0]) == 27
assert xbee.rocket_callback.call_args[0][0][15:-1] == b"HelloRocket"
def test_timeout(self):
snapshot = get_event_stats_snapshot()
start = time()
ret = TEST_EVENT.wait(snapshot, timeout=0.2)
end = time()
assert ret == 0
assert 0.1 < end - start < 0.4
def test_command_response_reliability(self, qtbot, sim_app, device_type):
CYCLES = 100
recv = 0
for i in range(CYCLES):
snapshot = get_event_stats_snapshot()
sim_app.send_command(device_type.name + ".baropres")
assert SINGLE_SENSOR_EVENT.wait(snapshot, num_expected=1) == 1
def test_module_differentiation(self):
snapshot = get_event_stats_snapshot()
snapshot[event_stats._hash(TEST_EVENT._name, 'other_module')] = 5
TEST_EVENT.increment()
ret = TEST_EVENT.wait(snapshot)
assert ret == 1
def test_rocket_rx_pieces(xbee):
test_data = b"TxData0A"
tx_1 = bytearray(b"\x7E\x00\x16\x10\x01") + TEST_GS_ADDR_ESCAPED[:7]
tx_2 = bytearray(TEST_GS_ADDR_ESCAPED[7:] + b"\xFF\xFE\x00\x00" + test_data + b"\x7D\x33")
snapshot = get_event_stats_snapshot()
xbee.recieved_from_rocket(tx_1)
xbee.recieved_from_rocket(tx_2)
assert FRAME_PARSED_EVENT.wait(snapshot) == 1
xbee.ground_callback.assert_called_with(test_data)
def test_baro_altitude(self, qtbot, sim_app, device_type):
Pb = 101325
Tb = 288.15
Lb = -0.0065
R = 8.3144598
g0 = 9.80665
M = 0.0289644
altitude = lambda pres: Tb / Lb * ((Pb / pres)**(R * Lb /
(g0 * M)) - 1)
# Set base/ground altitude
initial_pres = 1000
set_dummy_sensor_values(sim_app, device_type, SensorType.BAROMETER,
initial_pres, 25)
flush_packets(sim_app, device_type)
initial_altitude = sim_app.rocket_data.last_value_by_device(
device_type, DataEntryIds.CALCULATED_ALTITUDE)
# Disable ignitors to prevent sim from launching
# TODO: This is not clean, fix this hack
hw = get_hw_sim(sim_app, device_type)
for ign in hw._ignitors.values():
ign.action_fn = None
# Note: Kind of a hack because ground altitude is only solidified once rocket launches. Here we are abusing the
# fact that we dont update the ground altitude if the pressure change is too large. This allows us to run these
# tests in the standby state
test_vals = [
(150000, 25),
(100000, 25),
(50000, 25),
(25000, 32),
]
for vals in test_vals:
set_dummy_sensor_values(sim_app, device_type, SensorType.BAROMETER,
*vals)
flush_packets(sim_app, device_type)
snapshot = get_event_stats_snapshot()
sim_app.send_command(device_type.name + ".baropres")
sim_app.send_command(device_type.name + ".barotemp")
assert SINGLE_SENSOR_EVENT.wait(snapshot, num_expected=2) == 2
assert sim_app.rocket_data.last_value_by_device(
device_type, DataEntryIds.PRESSURE) == vals[0]
assert sim_app.rocket_data.last_value_by_device(
device_type, DataEntryIds.BAROMETER_TEMPERATURE) == vals[1]
assert sim_app.rocket_data.last_value_by_device(device_type,
DataEntryIds.CALCULATED_ALTITUDE) - initial_altitude == \
approx(altitude(vals[0]) - altitude(initial_pres), abs=0.01)
assert sim_app.rocket_data.last_value_by_device(
device_type, DataEntryIds.BAROMETER_TEMPERATURE) == vals[1]
def test_arm_signal(qtbot, single_connection_tantalus):
app = single_connection_tantalus
snapshot = get_event_stats_snapshot()
app.send_command("tantalus_stage_1_flare.arm")
assert ARMED_EVENT.wait(snapshot) == 1
app.send_command("tantalus_stage_1_flare.disarm")
assert DISARMED_EVENT.wait(snapshot) == 1
def test_rocket_rx_bad_addr(xbee):
test_data = b"TxData0A"
tx_example = bytearray(
b"\x7E\x00\x16\x10\x01" + bytes(8) +
b"\xFF\xFE\x00\x00" + test_data + b"\x3A"
)
snapshot = get_event_stats_snapshot()
xbee.recieved_from_rocket(tx_example)
assert FRAME_PARSED_EVENT.wait(snapshot) == 1
assert xbee.ground_callback.call_count == 0
def construct(profile, connections, num_devices=None):
nonlocal app
snapshot = get_event_stats_snapshot()
app = profile.construct_app(connections)
if num_devices is None:
expected = len(profile.expected_devices)
else:
expected = num_devices
assert DEVICE_REGISTERED_EVENT.wait(snapshot, num_expected=expected) == expected
return app
def test_state_packet(qtbot, single_connection_tantalus):
app = single_connection_tantalus
connection = app.connections['DEBUG_CONNECTION']
state_to_test = 0x00
packet = radio_packets.state(0xFFFFFFFF, state_to_test)
snapshot = get_event_stats_snapshot()
connection.receive(packet)
assert STATE_EVENT.wait(snapshot) == 1
assert app.rocket_data.last_value_by_device(
DeviceType.TANTALUS_STAGE_1_FLARE, DataEntryIds.TIME) == 0xFFFFFFFF
assert app.rocket_data.last_value_by_device(
DeviceType.TANTALUS_STAGE_1_FLARE,
DataEntryIds.STATE) == STATE_IDS[state_to_test]
def test_bulk_sensor_packet(qtbot, single_connection_tantalus):
app = single_connection_tantalus
connection = app.connections['DEBUG_CONNECTION']
state_input = 0x09
sensor_inputs = (1, 2, 3, 4, 5, 6, 7, 8, 9, 10, state_input)
packet = radio_packets.bulk_sensor(*sensor_inputs)
snapshot = get_event_stats_snapshot()
with qtbot.waitSignal(
app.ReadThread.sig_received
): # Needed otherwise signals wont process because UI is in same thread
connection.receive(packet)
assert STATE_EVENT.wait(snapshot) == 1
assert BULK_SENSOR_EVENT.wait(snapshot) == 1
assert BUNDLE_ADDED_EVENT.wait(snapshot) == 1
def get_val(val):
return app.rocket_data.last_value_by_device(
DeviceType.TANTALUS_STAGE_1_FLARE, val)
vals_to_get = (
DataEntryIds.CALCULATED_ALTITUDE,
DataEntryIds.ACCELERATION_X,
DataEntryIds.ACCELERATION_Y,
DataEntryIds.ACCELERATION_Z,
DataEntryIds.ORIENTATION_1,
DataEntryIds.ORIENTATION_2,
DataEntryIds.ORIENTATION_3,
DataEntryIds.LATITUDE,
DataEntryIds.LONGITUDE,
)
last_values = tuple(map(get_val, vals_to_get))
# Only check items in tuple vals_to_get
assert sensor_inputs[1:-1] == last_values
# Special check for state
state_val = get_val(DataEntryIds.STATE)
assert STATE_IDS[state_input] == state_val
assert LABLES_UPDATED_EVENT.wait(snapshot) >= 1
assert app.AltitudeLabel.text() == '2.00 m'
assert app.GPSLabel.text() == '9.00000\xb0, 10.00000\xb0'
assert app.StateLabel.text() == STATE_IDS[state_input].name
def test_config_change_gs_address(self, qtbot, sim_app, device_type):
flush_packets(sim_app, device_type)
snapshot = get_event_stats_snapshot()
sim_app.send_command(device_type.name + ".config")
flush_packets(sim_app, device_type)
assert CONFIG_EVENT.wait(snapshot) == 1
for connection in sim_app.connections.values():
connection._xbee.gs_address = b'\x00\x13\xa2\x00Ag\x8f\xc1'
sim_app.send_command(device_type.name + ".config")
flush_packets(sim_app, device_type)
assert CONFIG_EVENT.wait(snapshot, num_expected=2) == 2
def test_message_packet(qtbot, single_connection_tantalus, caplog):
app = single_connection_tantalus
connection = app.connections['DEBUG_CONNECTION']
packet = radio_packets.message(0xFFFFFFFF, "test_message")
snapshot = get_event_stats_snapshot()
connection.receive(packet)
assert BUNDLE_ADDED_EVENT.wait(snapshot) == 1
assert app.rocket_data.last_value_by_device(
DeviceType.TANTALUS_STAGE_1_FLARE, DataEntryIds.TIME) == 0xFFFFFFFF
assert app.rocket_data.last_value_by_device(
DeviceType.TANTALUS_STAGE_1_FLARE,
DataEntryIds.MESSAGE) == "test_message"
assert "test_message" in caplog.text
def test_temperature_read(self, qtbot, sim_app, device_type):
test_vals = [
(0, ),
(10, ),
(20, ),
]
for vals in test_vals:
set_dummy_sensor_values(sim_app, device_type,
SensorType.TEMPERATURE, *vals)
flush_packets(
sim_app, device_type
) # Just to wait a few cycles for the FW to read from HW sim
snapshot = get_event_stats_snapshot()
sim_app.send_command(device_type.name + ".TEMP")
assert SINGLE_SENSOR_EVENT.wait(snapshot) == 1
assert sim_app.rocket_data.last_value_by_device(
device_type, DataEntryIds.TEMPERATURE) == vals[0]
def test_single_sensor_packet(qtbot, single_connection_tantalus):
app = single_connection_tantalus
connection = app.connections['DEBUG_CONNECTION']
vals = [
(SubpacketIds.ACCELERATION_Y, 1),
(SubpacketIds.ACCELERATION_X, 2),
(SubpacketIds.ACCELERATION_Z, 3),
(SubpacketIds.PRESSURE, 4),
(SubpacketIds.BAROMETER_TEMPERATURE, 5),
(SubpacketIds.TEMPERATURE, 6),
(SubpacketIds.LATITUDE, 7),
(SubpacketIds.LONGITUDE, 8),
(SubpacketIds.GPS_ALTITUDE, 9),
(SubpacketIds.CALCULATED_ALTITUDE, 10),
(SubpacketIds.GROUND_ALTITUDE, 12),
(SubpacketIds.ACCELERATION_Y, 13),
(SubpacketIds.ACCELERATION_X, 14),
(SubpacketIds.ACCELERATION_Z, 15),
(SubpacketIds.PRESSURE, 16),
(SubpacketIds.BAROMETER_TEMPERATURE, 17),
(SubpacketIds.TEMPERATURE, 18),
(SubpacketIds.LATITUDE, 19),
(SubpacketIds.LONGITUDE, 20),
(SubpacketIds.GPS_ALTITUDE, 21),
(SubpacketIds.CALCULATED_ALTITUDE, 22),
(SubpacketIds.GROUND_ALTITUDE, 24),
]
for sensor_id, val in vals:
data_entry_id = DataEntryIds[sensor_id.name]
packet = radio_packets.single_sensor(0xFFFFFFFF, sensor_id, val)
snapshot = get_event_stats_snapshot()
connection.receive(packet)
assert SINGLE_SENSOR_EVENT.wait(snapshot) == 1
assert app.rocket_data.last_value_by_device(
DeviceType.TANTALUS_STAGE_1_FLARE, DataEntryIds.TIME) == 0xFFFFFFFF
assert app.rocket_data.last_value_by_device(
DeviceType.TANTALUS_STAGE_1_FLARE, data_entry_id) == val
def test_normal_registration():
device_manager = DeviceManager(None, None)
full_address_1 = FullAddress(connection_name='TantalusStage1Connection',
device_address='TantalusStage1Address')
full_address_2 = FullAddress(connection_name='TantalusStage2Connection',
device_address='TantalusStage2Address')
snapshot = get_event_stats_snapshot()
device_manager.register_device(DeviceType.TANTALUS_STAGE_1_FLARE, None,
full_address_1)
device_manager.register_device(DeviceType.TANTALUS_STAGE_2_FLARE, None,
full_address_2)
assert DEVICE_REGISTERED_EVENT.wait(snapshot, num_expected=2,
timeout=0) == 2
assert device_manager.get_full_address(
DeviceType.TANTALUS_STAGE_1_FLARE) == full_address_1
assert device_manager.get_full_address(
DeviceType.TANTALUS_STAGE_2_FLARE) == full_address_2
def test_config_hello(self, qtbot, sim_app, device_type):
flush_packets(sim_app, device_type)
# Should have already received at least one config packet from the startup hello
assert sim_app.rocket_data.last_value_by_device(
device_type, DataEntryIds.IS_SIM) == True
assert sim_app.rocket_data.last_value_by_device(
device_type, DataEntryIds.DEVICE_TYPE) == device_type
snapshot = get_event_stats_snapshot()
sim_app.send_command(device_type.name + ".config")
flush_packets(sim_app, device_type)
assert CONFIG_EVENT.wait(snapshot) == 1
assert sim_app.rocket_data.last_value_by_device(
device_type, DataEntryIds.IS_SIM) == True
assert sim_app.rocket_data.last_value_by_device(
device_type, DataEntryIds.VERSION_ID) is not None
assert sim_app.rocket_data.last_value_by_device(
device_type, DataEntryIds.DEVICE_TYPE) == device_type
def flush_packets(main_app: MainApp, device_type: DeviceType):
"""
Wait a few update cycles to flush any old packets out
:param rocket_data:
:param device_type:
:return:
"""
received = 0
last_time = 0
while received < 5:
snapshot = get_event_stats_snapshot()
assert BUNDLE_ADDED_EVENT.wait(snapshot) >= 1
assert CONNECTION_MESSAGE_READ_EVENT.wait(snapshot) >= 1
# To ensure that we're only considering packets from specific device
new_time = main_app.rocket_data.last_value_by_device(device_type, DataEntryIds.TIME)
if new_time != last_time: # No guarantee that packets come in chronological order
received += 1
last_time = new_time
def test_gps_read(self, qtbot, sim_app, device_type):
test_vals = [
(11, 12, 13),
(21, 22, 23),
(31, 32, 33),
]
for vals in test_vals:
set_dummy_sensor_values(sim_app, device_type, SensorType.GPS,
*vals)
flush_packets(sim_app, device_type)
snapshot = get_event_stats_snapshot()
sim_app.send_command(device_type.name + ".gpsalt")
assert SINGLE_SENSOR_EVENT.wait(snapshot) == 1
assert sim_app.rocket_data.last_value_by_device(
device_type, DataEntryIds.LATITUDE) == vals[0]
assert sim_app.rocket_data.last_value_by_device(
device_type, DataEntryIds.LONGITUDE) == vals[1]
assert sim_app.rocket_data.last_value_by_device(
device_type, DataEntryIds.GPS_ALTITUDE) == vals[2]
def _run_self_test(self):
try:
LOGGER.info("SELF TEST STARTED")
snapshot = get_event_stats_snapshot()
sleep(20)
# Dont wait, check difference now all at once
# Add any other common events here
assert LABLES_UPDATED_EVENT.wait(snapshot, timeout=0) >= 2
assert MAP_UPDATED_EVENT.wait(snapshot, timeout=0) >= 2
LOGGER.info("SELF TEST PASSED")
ret_code = 0
except AssertionError:
LOGGER.exception("SELF TEST FAILED")
ret_code = 1
self.main_app.shutdown()
os._exit(ret_code)
def test_multi_connection_receive(qtbot, test_app):
con_a = DebugConnection(
'TANTALUS_STAGE_1_ADDRESS',
DEVICE_TYPE_TO_ID[DeviceType.TANTALUS_STAGE_1_FLARE],
generate_radio_packets=False)
con_b = DebugConnection(
'TANTALUS_STAGE_2_ADDRESS',
DEVICE_TYPE_TO_ID[DeviceType.TANTALUS_STAGE_2_FLARE],
generate_radio_packets=False)
snapshot = get_event_stats_snapshot()
app = test_app(TantalusProfile(), {
'DEBUG_CONNECTION_1': con_a,
'DEBUG_CONNECTION_2': con_b
},
num_devices=2)
con_a.receive(
radio_packets.single_sensor(0xFFFFFFFF, SubpacketIds.PRESSURE, 1))
con_b.receive(
radio_packets.single_sensor(0xFFFFFFFF, SubpacketIds.PRESSURE, 2))
# Fake some other device on same connection
con_a.device_address = 'OTHER_ADDRESS'
sample_version = '1234567890123456789012345678901234567890'
con_a.receive(
radio_packets.config(0xFFFFFFFF, True,
DEVICE_TYPE_TO_ID[DeviceType.CO_PILOT_FLARE],
sample_version))
con_a.receive(
radio_packets.single_sensor(0xFFFFFFFF, SubpacketIds.PRESSURE, 3))
assert DEVICE_REGISTERED_EVENT.wait(snapshot, num_expected=3) == 3
assert BUNDLE_ADDED_EVENT.wait(snapshot, num_expected=6) == 6
assert app.rocket_data.last_value_by_device(
DeviceType.TANTALUS_STAGE_1_FLARE, DataEntryIds.PRESSURE) == 1
assert app.rocket_data.last_value_by_device(
DeviceType.TANTALUS_STAGE_2_FLARE, DataEntryIds.PRESSURE) == 2
assert app.rocket_data.last_value_by_device(DeviceType.CO_PILOT_FLARE,
DataEntryIds.PRESSURE) == 3
def test_gps_packet(qtbot, single_connection_tantalus):
app = single_connection_tantalus
connection = app.connections['DEBUG_CONNECTION']
gps_inputs = (0xFFFFFFFF, 1, 2, 3)
packet = radio_packets.gps(*gps_inputs)
snapshot = get_event_stats_snapshot()
connection.receive(packet)
assert BUNDLE_ADDED_EVENT.wait(snapshot) == 1
assert app.rocket_data.last_value_by_device(
DeviceType.TANTALUS_STAGE_1_FLARE, DataEntryIds.TIME) == 0xFFFFFFFF
assert app.rocket_data.last_value_by_device(
DeviceType.TANTALUS_STAGE_1_FLARE, DataEntryIds.LATITUDE) == 1
assert app.rocket_data.last_value_by_device(
DeviceType.TANTALUS_STAGE_1_FLARE, DataEntryIds.LONGITUDE) == 2
assert app.rocket_data.last_value_by_device(
DeviceType.TANTALUS_STAGE_1_FLARE, DataEntryIds.GPS_ALTITUDE) == 3
def test_register_after_data(qtbot, test_app):
con = DebugConnection('TANTALUS_STAGE_1_ADDRESS',
DEVICE_TYPE_TO_ID[DeviceType.TANTALUS_STAGE_1_FLARE],
generate_radio_packets=False)
app = test_app(TantalusProfile(), {'DEBUG_CONNECTION': con}, num_devices=1)
snapshot = get_event_stats_snapshot()
# Fake stage 2 on same connection
con.device_address = 'TANTALUS_STAGE_2_ADDRESS'
con.receive(
radio_packets.single_sensor(0xFFFFFFFF, SubpacketIds.PRESSURE, 1))
assert BUNDLE_ADDED_EVENT.wait(snapshot) == 1
# Cause device to register
con.receive(
radio_packets.config(
0xFFFFFFFF, True,
DEVICE_TYPE_TO_ID[DeviceType.TANTALUS_STAGE_2_FLARE],
REQUIRED_FLARE))
assert DEVICE_REGISTERED_EVENT.wait(snapshot) == 1
assert app.rocket_data.last_value_by_device(
DeviceType.TANTALUS_STAGE_2_FLARE, DataEntryIds.PRESSURE) == 1
def test_orientation_packet(qtbot, single_connection_tantalus):
app = single_connection_tantalus
connection = app.connections['DEBUG_CONNECTION']
orientation_inputs = (0xFFFFFFFF, 1, 2, 3, 4)
packet = radio_packets.orientation(*orientation_inputs)
snapshot = get_event_stats_snapshot()
connection.receive(packet)
assert BUNDLE_ADDED_EVENT.wait(snapshot) == 1
assert app.rocket_data.last_value_by_device(
DeviceType.TANTALUS_STAGE_1_FLARE, DataEntryIds.TIME) == 0xFFFFFFFF
assert app.rocket_data.last_value_by_device(
DeviceType.TANTALUS_STAGE_1_FLARE, DataEntryIds.ORIENTATION_1) == 1
assert app.rocket_data.last_value_by_device(
DeviceType.TANTALUS_STAGE_1_FLARE, DataEntryIds.ORIENTATION_2) == 2
assert app.rocket_data.last_value_by_device(
DeviceType.TANTALUS_STAGE_1_FLARE, DataEntryIds.ORIENTATION_3) == 3
assert app.rocket_data.last_value_by_device(
DeviceType.TANTALUS_STAGE_1_FLARE, DataEntryIds.ORIENTATION_4) == 4
