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