wiliot-certificate 4.5.0a2__py3-none-any.whl → 4.5.0a3__py3-none-any.whl

certificate/tests/energy2400/signal_indicator_ext_adv_test/signal_indicator_ext_adv_test.py

@@ -5,327 +5,167 @@ import certificate.cert_mqtt as cert_mqtt
 import certificate.cert_common as cert_common
 import certificate.cert_config as cert_config
 
-# Test Description:
-#   This test is to verify the functionality of both signal indicator tx (tx_brg) and rx (rx_brg) at BRG level.
-#   We will configure several signal indicator params during the test, and check the functionality of the signal indicator logic
-#   for each of them.
-#   It is important to execute the test with several setups: 2 Fanstel BRG's, 2 Minew BRG's and 1 Fanstel and 1 Minew BRG.
-#   At first, we will configure several tx signal indicator params and check for ack's, to verify all indicated params were
-#   received at the cloud.
-#   Then, we will examine the signal indicator end-2-end logic with both transmitter and receiver:
-#   phase 1 - One BRG will be configured as signal indicator tx, and the other as signal indicator rx, and we expect to see
-#   signal indicator packets only from the tx BRG, and according to the tx params (to check the repetition and cycle params).
-#   phase 2 - Same as phase 1, but with different tx params configured.
-#   phase 3 - One rx BRG without any tx BRG. We don't expect to see any signal indicator packets. This phase is to verify the
-#   brg module logic is working properly, and no tag packet is accidentally being treated as signal indicator packet.
-#   phase 4 - Both BRG's will be configured to be transmitters and receivers, with different tx params for each one. we expect
-#   to see signal indicator packets from both BRG's, according to the tx params.
-#   phase 5 - One BRG will be configured as signal indicator tx, but no rx, so we don't expect to receive signal indicatopr packets.
-#   that way we can assure the logic within the receiver is not confused by the signal indicator uuid as external sensor.
-
-
 # Test MACROS #
 NUM_OF_SCANNING_CYCLE = 5
-DEFAULT_SCAN_TIME = 30
 SCAN_DELAY_TIME = 3
-BLE5_MAX_DURATION_SEC = ag.BLE5_PARAM_PRIMARY_CHANNEL_SCAN_CYCLE // 1000 + 1
 
 
-def test_rssi_threshold(test):
-    cycle, rep = 5, 4
-    rx_brg_ = test.brg1  # when internal_brg test this is the internal_brg
-    tx_brg_ = cert_config.get_brg_by_target(test, DUT)
-    rssi_threshold = -25
+def test_ext_adv_rx37(test):
+
+    dut = cert_config.get_brg_by_target(test, DUT)
+    tester = cert_config.get_brg_by_target(test, TESTER)
+    cycle, rep = 8, 4
 
-    utPrint(f"TX BRG with RX- cycle = {cycle}, repetition = {rep}\n", "BLUE")
-    # configuring receiver #
-    utPrint(f"Configuring BRG {rx_brg_.id_str} as Signal Indicator Receiver with RSSI Threshold of {rssi_threshold}", "BOLD")
-    is_ble5 = not test.internal_brg
-    test = cert_config.brg_configure(test=test, module=rx_brg_.sensors,
-                                     fields=[BRG_SENSOR0, BRG_RSSI_THRESHOLD],
-                                     values=[ag.EXTERNAL_SENSORS_SIGNAL_INDICATOR, rssi_threshold],
-                                     ble5=is_ble5, wait=True, target=BRG1)[0]
+    # Configuring DUT #
+    # configuring transmitter #
+    utPrint(f"Configuring DUT BRG {dut.id_str} as Signal Indicator Transmitter (cycle={cycle}, repetition={rep})", "BLUE")
+    test = cert_config.brg_configure(test=test, module=dut.energy2400,
+                                     fields=[BRG_SIGNAL_INDICATOR_CYCLE, BRG_SIGNAL_INDICATOR_REP],
+                                     values=[cycle, rep])[0]
     if test.rc == TEST_FAILED:
-        test.add_reason(f"BRG {rx_brg_.id_str}: didn't receive signal indicator receiver configuration!")
+        test.add_reason(f"DUT BRG {dut.id_str}: didn't receive signal indicator transmitter configuration!")
         return test
-    # configuring transmitter #
-    utPrint(f"Configuring BRG {tx_brg_.id_str} as Signal Indicator Transmitter", "BOLD")
-    wait = not test.internal_brg
-    test = cert_config.brg_configure(test=test, module=tx_brg_.energy2400, fields=[BRG_SIGNAL_INDICATOR_CYCLE, BRG_SIGNAL_INDICATOR_REP],
-                                     values=[cycle, rep], ble5=True, wait=wait)[0]
+    # configuring extended advertising and rx channel #
+    utPrint(f"Configuring DUT BRG {dut.id_str} with extended advertising and rx channel 37", "BLUE")
+    test = cert_config.brg_configure(test=test, module=dut.datapath,
+                                     fields=[BRG_RX_CHANNEL, BRG_PATTERN],
+                                     values=[ag.RX_CHANNEL_37, ag.DATAPATH_PATTERN_EXTENDED_ADV])[0]
     if test.rc == TEST_FAILED:
-        test.add_reason(f"BRG {tx_brg_.id_str}: didn't receive signal indicator transmitter configuration!")
+        test.add_reason(f"DUT BRG {dut.id_str}: didn't receive extended advertising and rx channel configuration!")
         return test
-    utPrint(f"BRG {tx_brg_.id_str} configured to be transmitter - cycle = {cycle},"
-            f"repetition = {rep}", "BOLD")
-    # phase analysis #
-    print_update_wait(BLE5_MAX_DURATION_SEC)  # BLE5 configuration can take up to BLE5_MAX_DURATION_SEC
-    cert_mqtt.mqtt_scan_n_create_log_file(test, (NUM_OF_SCANNING_CYCLE * cycle) + SCAN_DELAY_TIME, "rssi_threshold")
-    received_signal_ind_pkts = cert_common.get_all_sig_ind_pkts(test=test, rx_brg=rx_brg_, tx_brg=tx_brg_)
-    for p in received_signal_ind_pkts:
-        print(f"rssi value: {p[UNIFIED_SENSOR_PKT].pkt.rssi}")
-    rssi_threshold_viloation_pkts = [p for p in received_signal_ind_pkts if p[UNIFIED_SENSOR_PKT].pkt.rssi >= -1 * rssi_threshold]
-    if rssi_threshold_viloation_pkts:
-        test.rc = TEST_FAILED
-        test.add_reason(f"rssi_threshold phase failed - BRG {rx_brg_.id_str} echoed"
-                        f" {len(rssi_threshold_viloation_pkts)} signal indicator packets\n with RSSI weaker than {rssi_threshold}")
-    return test
-
-
-def test_brg0_tx_brg1_rx(test):
-
-    tx_brg_ = cert_config.get_brg_by_target(test, DUT)
-    rx_brg_ = test.brg1   # when internal_brg test this is the internal_brg
-    cycle, rep = 8, 4
 
-    utPrint(f"TX BRG with RX- cycle = {cycle}, repetition = {rep}\n", "BLUE")
-    # configuring receiver #
-    utPrint(f"Configuring BRG {rx_brg_.id_str} as Signal Indicator Receiver", "BOLD")
-    is_ble5 = not test.internal_brg
-    test = cert_config.brg_configure(test=test, module=rx_brg_.sensors,
-                                     fields=[BRG_SENSOR0],
-                                     values=[ag.EXTERNAL_SENSORS_SIGNAL_INDICATOR],
-                                     ble5=is_ble5, wait=True, target=BRG1)[0]
+    # configuring TESTER #
+    utPrint(f"Configuring TESTER BRG {tester.id_str} as Signal Indicator Receiver", "BLUE")
+    test = cert_config.brg_configure(test=test, module=tester.sensors, fields=[BRG_SENSOR0],
+                                     values=[ag.EXTERNAL_SENSORS_SIGNAL_INDICATOR], target=TESTER)[0]
     if test.rc == TEST_FAILED:
-        test.add_reason(f"BRG {rx_brg_.id_str}: didn't receive signal indicator receiver configuration!")
+        test.add_reason(f"TESTER BRG {tester.id_str}: didn't receive signal indicator receiver configuration!")
         return test
-    # configuring transmitter #
-    wait = not test.internal_brg
-    utPrint(f"Configuring BRG {tx_brg_.id_str} as Signal Indicator Transmitter", "BOLD")
-    test = cert_config.brg_configure(test=test, module=tx_brg_.energy2400,
-                                     fields=[BRG_SIGNAL_INDICATOR_CYCLE, BRG_SIGNAL_INDICATOR_REP],
-                                     values=[cycle, rep], ble5=True, wait=wait)[0]
+    utPrint(f"Configuring TESTER BRG {tester.id_str} with rx channel 37", "BLUE")
+    test = cert_config.brg_configure(test=test, module=tester.datapath, fields=[BRG_RX_CHANNEL],
+                                     values=[ag.RX_CHANNEL_37], target=TESTER)[0]
     if test.rc == TEST_FAILED:
-        test.add_reason(f"BRG {tx_brg_.id_str}: didn't receive signal indicator transmitter configuration!")
+        test.add_reason(f"TESTER BRG {tester.id_str}: didn't receive rx channel configuration!")
         return test
-    utPrint(f"BRG {tx_brg_.id_str} configured to be transmitter - cycle = {cycle},"
-            f"repetition = {rep}", "BOLD")
-    # phase analysis #
-    print_update_wait(BLE5_MAX_DURATION_SEC)  # BLE5 configuration can take up to BLE5_MAX_DURATION_SEC
-    cert_mqtt.mqtt_scan_n_create_log_file(test, (NUM_OF_SCANNING_CYCLE * cycle) + SCAN_DELAY_TIME, f"brg0_rx_brg1_tx_{cycle}_{rep}")
-    received_signal_ind_pkts = cert_common.get_all_sig_ind_pkts(test=test, rx_brg=rx_brg_, tx_brg=tx_brg_)
 
-    if cert_common.sig_ind_pkts_fail_analysis(tx_brg_, rx_brg_, NUM_OF_SCANNING_CYCLE, received_signal_ind_pkts):
+    # phase analysis #
+    cert_mqtt.mqtt_scan_n_create_log_file(test, (NUM_OF_SCANNING_CYCLE * cycle) + SCAN_DELAY_TIME,
+                                          f"tx_{cycle}_{rep}")
+    rec_sig_ind_pkts = cert_common.get_all_sig_ind_pkts(test=test, rx_brg=tester, tx_brg=dut)
+    if cert_common.sig_ind_pkts_fail_analysis(tx_brg=dut, rx_brg=tester, cycles=NUM_OF_SCANNING_CYCLE, received_pkts=rec_sig_ind_pkts):
         test.rc = TEST_FAILED
-        expected_signal_ind_pkts = cert_common.exp_sig_ind_pkts2(tx_brg_, rx_brg_, NUM_OF_SCANNING_CYCLE)
-        test.add_reason(f"brg0_rx_brg1_tx phase failed - BRG {rx_brg_.id_str} received wrong number of "
-                        f"signal indicator packets\nreceived {len(received_signal_ind_pkts)} packets, "
+        expected_signal_ind_pkts = cert_common.exp_sig_ind_pkts2(tester, dut, NUM_OF_SCANNING_CYCLE)
+        test.add_reason(f"tx phase failed - BRG {dut.id_str} received wrong number of "
+                        f"signal indicator packets\nreceived {len(rec_sig_ind_pkts)} packets, "
                         f"expected {expected_signal_ind_pkts} packets")
-        print(received_signal_ind_pkts)  # TODO: logging print(debug)
-        print([[p[TIMESTAMP], p[UNIFIED_SENSOR_PKT].pkt.signal_indicator_payload.rx_antenna] for p in received_signal_ind_pkts])
-
-    test = cert_common.rx_tx_antenna_check(test, received_signal_ind_pkts, tx_brg_, rx_brg_, NUM_OF_SCANNING_CYCLE)
-    test = cert_common.output_power_check(test, received_signal_ind_pkts, tx_brg_)
-    test = cert_common.rssi_check(test, received_signal_ind_pkts)
-
-    return test
-
-
-def test_brg0_none_brg1_rx(test):
-    cycle, rep = ag.BRG_DEFAULT_SIGNAL_INDICATOR_CYCLE, ag.BRG_DEFAULT_SIGNAL_INDICATOR_REP
-    tx_brg_ = cert_config.get_brg_by_target(test, DUT)
-    rx_brg_ = test.brg1  # when internal_brg test this is the internal_brg
-    utPrint(f"RX BRG without TX- cycle = {cycle}, repetition = {rep}\n", "BLUE")
-    # configuring receiver #
-    utPrint(f"Configuring BRG {rx_brg_.id_str} as Signal Indicator Receiver", "BOLD")
-    is_ble5 = not test.internal_brg
-    test = cert_config.brg_configure(test=test, module=rx_brg_.sensors,
-                                     fields=[BRG_SENSOR0],
-                                     values=[ag.EXTERNAL_SENSORS_SIGNAL_INDICATOR],
-                                     ble5=is_ble5, wait=True, target=BRG1)[0]
-    if test.rc == TEST_FAILED:
-        test.add_reason(f"BRG {rx_brg_.id_str}: didn't receive signal indicator receiver configuration!")
+        print(rec_sig_ind_pkts)  # TODO: logging print(debug)
+        print([[p[TIMESTAMP], p[UNIFIED_SENSOR_PKT].pkt.signal_indicator_payload.rx_antenna] for p in rec_sig_ind_pkts])
         return test
-    utPrint(f"BRG {rx_brg_.id_str} successfully configured as Signal Indicator Receiver\n", "BOLD")
 
-    # phase analysis #
-    print_update_wait(BLE5_MAX_DURATION_SEC)  # BLE5 configuration can take up to BLE5_MAX_DURATION_SEC
-    cert_mqtt.mqtt_scan_n_create_log_file(test, DEFAULT_SCAN_TIME, "brg0_none_brg1_rx")
-    expected_signal_ind_pkts = [0]
-    received_signal_ind_pkts = cert_common.get_all_sig_ind_pkts(test=test, rx_brg=rx_brg_, tx_brg=tx_brg_)
-    if len(received_signal_ind_pkts) not in expected_signal_ind_pkts:
-        test.rc = TEST_FAILED
-        test.add_reason(f"brg0_rx_brg1_tx phase failed - BRG {rx_brg_.id_str} received wrong number of "
-                        f"signal indicator packets\n received {len(received_signal_ind_pkts)} packets, "
-                        f"expected {expected_signal_ind_pkts} packets")
+    test = cert_common.rx_tx_antenna_check(test, rec_sig_ind_pkts, dut, tester, NUM_OF_SCANNING_CYCLE)
+    test = cert_common.output_power_check(test, rec_sig_ind_pkts, dut)
+    test = cert_common.rssi_check(test, rec_sig_ind_pkts)
 
     return test
 
 
-def test_brg0_rxtx_brg1_rxtx(test):
+def test_ext_adv_rx10(test):
 
-    if test.internal_brg:
-        # Can't scan on ble5 with internal brg because config won't be received
-        test.add_reason("skip for internal BRG")
-        test.rc = TEST_SKIPPED
-        return test
+    dut = cert_config.get_brg_by_target(test, DUT)
+    tester = cert_config.get_brg_by_target(test, TESTER)
+    cycle, rep = 8, 4
 
-    tx_cycle, tx_rep = 5, 4
-    rx_cycle, rx_rep = 5, 4
-    tx_brg_ = cert_config.get_brg_by_target(test, DUT)
-    rx_brg_ = test.brg1
-    utPrint("Both BRG's are transmitter and receivers, with different values\n", "BLUE")
-    # configuring first brg (tx_brg_) as receiver
-    utPrint(f"Configuring BRG {tx_brg_.id_str} as Signal Indicator Receiver", "BOLD")
-    test = cert_config.brg_configure(test=test, module=tx_brg_.sensors, fields=[BRG_SENSOR0],
-                                     values=[ag.EXTERNAL_SENSORS_SIGNAL_INDICATOR], ble5=True)[0]
-    if test.rc == TEST_FAILED and test.exit_on_param_failure:
-        test.add_reason(f"BRG {tx_brg_.id_str}: didn't receive signal indicator receiver configuration!")
+    # Configuring DUT #
+    # configuring transmitter #
+    utPrint(f"Configuring DUT BRG {dut.id_str} as Signal Indicator Transmitter (cycle={cycle}, repetition={rep})", "BLUE")
+    test = cert_config.brg_configure(test=test, module=dut.energy2400,
+                                     fields=[BRG_SIGNAL_INDICATOR_CYCLE, BRG_SIGNAL_INDICATOR_REP],
+                                     values=[cycle, rep])[0]
+    if test.rc == TEST_FAILED:
+        test.add_reason(f"DUT BRG {dut.id_str}: didn't receive signal indicator transmitter configuration!")
         return test
-    utPrint(f"BRG {tx_brg_.id_str} successfully configured as Signal Indicator Receiver\n", "BOLD")
-    # configuring first brg (tx_brg_) as transmitter
-    utPrint(f"Configuring BRG {tx_brg_.id_str} as Signal Indicator Transmitter", "BOLD")
-    test = cert_config.brg_configure(test=test, module=tx_brg_.energy2400, fields=[BRG_SIGNAL_INDICATOR_CYCLE, BRG_SIGNAL_INDICATOR_REP],
-                                     values=[tx_cycle, tx_rep], ble5=True)[0]
-    if test.rc == TEST_FAILED and test.exit_on_param_failure:
-        test.add_reason(f"BRG {tx_brg_.id_str}: didn't receive signal indicator transmitter configuration!")
+    # configuring extended advertising and rx channel #
+    utPrint(f"Configuring DUT BRG {dut.id_str} with extended advertising and rx channel 10", "BLUE")
+    test = cert_config.brg_configure(test=test, module=dut.datapath,
+                                     fields=[BRG_RX_CHANNEL, BRG_PATTERN],
+                                     values=[ag.RX_CHANNEL_10_500K, ag.DATAPATH_PATTERN_EXTENDED_ADV],
+                                     ble5=test.dut_is_bridge(), wait=test.dut_is_combo())[0]
+    if test.rc == TEST_FAILED:
+        test.add_reason(f"DUT BRG {dut.id_str}: didn't receive extended advertising and rx channel configuration!")
         return test
-    utPrint(f"BRG {tx_brg_.id_str} configured to be transmitter - cycle={tx_cycle}, repetition={tx_rep}", "BOLD")
+    if test.dut_is_bridge():
+        wait_time_n_print(BLE5_MAX_DURATION_SEC)  # BLE5 configuration can take up to BLE5_MAX_DURATION_SEC
 
-    # configuring second brg (rx_brg_) as receiver
-    utPrint(f"Configuring BRG {rx_brg_.id_str} as Signal Indicator Receiver", "BOLD")
-    test = cert_config.brg_configure(test=test, module=rx_brg_.sensors,
-                                     fields=[BRG_SENSOR0],
-                                     values=[ag.EXTERNAL_SENSORS_SIGNAL_INDICATOR],
-                                     ble5=True, target=BRG1)[0]
-    if test.rc == TEST_FAILED and test.exit_on_param_failure:
-        test.add_reason(f"BRG {rx_brg_.id_str}: didn't receive signal indicator receiver configuration!")
+    # configuring TESTER #
+    utPrint(f"Configuring TESTER BRG {tester.id_str} as Signal Indicator Receiver", "BLUE")
+    test = cert_config.brg_configure(test=test, module=tester.sensors, fields=[BRG_SENSOR0],
+                                     values=[ag.EXTERNAL_SENSORS_SIGNAL_INDICATOR], target=TESTER)[0]
+    if test.rc == TEST_FAILED:
+        test.add_reason(f"TESTER BRG {tester.id_str}: didn't receive signal indicator receiver configuration!")
         return test
-    utPrint(f"BRG {rx_brg_.id_str} successfully configured as Signal Indicator Receiver\n", "BOLD")
-
-    # configuring second brg (rx_brg_) as transmitter (already configured as rx)
-    utPrint(f"Configuring BRG {rx_brg_.id_str} as Signal Indicator Transmitter", "BOLD")
-    test = cert_config.brg_configure(test=test, module=rx_brg_.energy2400,
-                                     fields=[BRG_SIGNAL_INDICATOR_CYCLE, BRG_SIGNAL_INDICATOR_REP],
-                                     values=[rx_cycle, rx_rep],
-                                     ble5=True, target=BRG1)[0]
-    if test.rc == TEST_FAILED and test.exit_on_param_failure:
-        test.add_reason(f"BRG {rx_brg_.id_str}: didn't receive signal indicator transmitter configuration!")
+    utPrint(f"Configuring TESTER BRG {tester.id_str} with rx channel 10", "BLUE")
+    test = cert_config.brg_configure(test=test, module=tester.datapath, fields=[BRG_RX_CHANNEL],
+                                     values=[ag.RX_CHANNEL_10_500K], target=TESTER)[0]
+    if test.rc == TEST_FAILED:
+        test.add_reason(f"TESTER BRG {tester.id_str}: didn't receive rx channel configuration!")
         return test
-    utPrint(f"BRG {rx_brg_.id_str} configured to be transmitter - cycle={rx_cycle}, repetition={rx_rep}")
 
     # phase analysis #
-    print_update_wait(BLE5_MAX_DURATION_SEC)  # BLE5 configuration can take up to BLE5_MAX_DURATION_SEC
-    cert_mqtt.mqtt_scan_n_create_log_file(test, NUM_OF_SCANNING_CYCLE * max(tx_cycle, rx_cycle) + SCAN_DELAY_TIME, "brg0_rxtx_brg1_rxtx")
-
-    # Analyzing tx_brg_ performance as receiver
-    utPrint(f"Analyzing tx_brg {tx_brg_.id_str} performance as a Receiver\n", "BOLD")
-    received_signal_ind_pkts = cert_common.get_all_sig_ind_pkts(test=test, rx_brg=tx_brg_, tx_brg=rx_brg_)
-    if cert_common.sig_ind_pkts_fail_analysis(tx_brg_, rx_brg_, NUM_OF_SCANNING_CYCLE, received_signal_ind_pkts):
-        test.rc = TEST_FAILED
-        expected_signal_ind_pkts = cert_common.exp_sig_ind_pkts2(tx_brg_, rx_brg_, NUM_OF_SCANNING_CYCLE)
-        test.add_reason(f"brg0_rxtx_brg1_rxtx phase failed - BRG {tx_brg_.id_str} received wrong number of "
-                        f"signal indicator packets\nreceived {len(received_signal_ind_pkts)} packets, "
-                        f"expected {expected_signal_ind_pkts} packets")
-        print(received_signal_ind_pkts)  # TODO: logging print(debug)
-
-    # Analyzing rx_brg_ performance as receiver
-    utPrint(f"Analyzing rx_brg {rx_brg_.id_str} performance as a Receiver\n", "BOLD")
-    received_signal_ind_pkts = cert_common.get_all_sig_ind_pkts(test=test, rx_brg=rx_brg_, tx_brg=tx_brg_)
-    if cert_common.sig_ind_pkts_fail_analysis(tx_brg_, rx_brg_, NUM_OF_SCANNING_CYCLE, received_signal_ind_pkts):
+    cert_mqtt.mqtt_scan_n_create_log_file(test, (NUM_OF_SCANNING_CYCLE * cycle) + SCAN_DELAY_TIME,
+                                          f"tx_{cycle}_{rep}")
+    rec_sig_ind_pkts = cert_common.get_all_sig_ind_pkts(test=test, rx_brg=tester, tx_brg=dut)
+    if cert_common.sig_ind_pkts_fail_analysis(tx_brg=dut, rx_brg=tester, cycles=NUM_OF_SCANNING_CYCLE, received_pkts=rec_sig_ind_pkts):
         test.rc = TEST_FAILED
-        expected_signal_ind_pkts = cert_common.exp_sig_ind_pkts2(tx_brg_, rx_brg_, NUM_OF_SCANNING_CYCLE)
-        test.add_reason(f"brg0_rxtx_brg1_rxtx phase failed - BRG {rx_brg_.id_str} received wrong number of "
-                        f"signal indicator packets\n received {len(received_signal_ind_pkts)} packets, "
+        expected_signal_ind_pkts = cert_common.exp_sig_ind_pkts2(tester, dut, NUM_OF_SCANNING_CYCLE)
+        test.add_reason(f"tx phase failed - BRG {dut.id_str} received wrong number of "
+                        f"signal indicator packets\nreceived {len(rec_sig_ind_pkts)} packets, "
                         f"expected {expected_signal_ind_pkts} packets")
-        print(received_signal_ind_pkts)  # TODO: logging print(debug)
-    # NOTE: We skipped the antenna and output power checks for this phase
-    return test
-
-
-def test_brg0_tx_brg1_none(test):
-    # Tx BRG without rx. just waiting for packets to be sent from the transmitter and verify
-    # The receiver isn't receiving any signal indicator packets.
-    cycle, rep = 4, 3
-    tx_brg_ = cert_config.get_brg_by_target(test, DUT)
-    rx_brg_ = test.brg1  # when internal_brg test this is the internal_brg
-    utPrint(f"TX BRG without RX - cycle = {cycle}, repetition = {rep}\n", "BLUE")
-    # configuring transmitter #
-    utPrint(f"Configuring BRG {tx_brg_.id_str} as Signal Indicator Transmitter", "BOLD")
-    wait = not test.internal_brg
-    test = cert_config.brg_configure(test=test, module=tx_brg_.energy2400, fields=[BRG_SIGNAL_INDICATOR_CYCLE, BRG_SIGNAL_INDICATOR_REP],
-                                     values=[cycle, rep], ble5=True, wait=wait)[0]
-    if test.rc == TEST_FAILED:
-        test.add_reason(f"BRG {tx_brg_.id_str}: didn't receive signal indicator transmitter configuration!")
+        print(rec_sig_ind_pkts)  # TODO: logging print(debug)
+        print([[p[TIMESTAMP], p[UNIFIED_SENSOR_PKT].pkt.signal_indicator_payload.rx_antenna] for p in rec_sig_ind_pkts])
         return test
 
-    # phase analysis #
-    print_update_wait(BLE5_MAX_DURATION_SEC)  # BLE5 configuration can take up to BLE5_MAX_DURATION_SEC
-    cert_mqtt.mqtt_scan_n_create_log_file(test, (NUM_OF_SCANNING_CYCLE * cycle) + SCAN_DELAY_TIME, "brg0_tx_brg1_none")
-    expected_signal_ind_pkts = [0]
-    received_signal_ind_pkts = cert_common.get_all_sig_ind_pkts(test=test, rx_brg=rx_brg_, tx_brg=tx_brg_)
-    if len(received_signal_ind_pkts) not in expected_signal_ind_pkts:
-        test.rc = TEST_FAILED
-        test.add_reason(f"brg0_tx_brg1_none phase failed - received signal indicator packet from BRG"
-                        f"{rx_brg_.id_str}")
-    test = cert_common.output_power_check(test, received_signal_ind_pkts, tx_brg_)
+    test = cert_common.rx_tx_antenna_check(test, rec_sig_ind_pkts, dut, tester, NUM_OF_SCANNING_CYCLE)
+    test = cert_common.output_power_check(test, rec_sig_ind_pkts, dut)
+    test = cert_common.rssi_check(test, rec_sig_ind_pkts)
 
     return test
 
 
-SIGNAL_INDICATOR_TEST_MAP = {"rssi_threshold": test_rssi_threshold, "brg0_tx_brg1_rx": test_brg0_tx_brg1_rx,
-                             "brg0_none_brg1_rx": test_brg0_none_brg1_rx, "brg0_rxtx_brg1_rxtx": test_brg0_rxtx_brg1_rxtx,
-                             "brg0_tx_brg1_none": test_brg0_tx_brg1_none}
+SIGNAL_INDICATOR_TEST_MAP = {"ext_adv_rx37": test_ext_adv_rx37, "ext_adv_rx10": test_ext_adv_rx10}
 
 
 def run(test):
     # Test prolog
     test = cert_common.test_prolog(test)
 
-    for rx_channel in [ag.RX_CHANNEL_10_500K, ag.RX_CHANNEL_37]:
+    # Configure to rx channel and extended advertising pattern
+    dut = cert_config.get_brg_by_target(test, DUT)
+    tester = cert_config.get_brg_by_target(test, TESTER)
 
-        # Configure to rx channel and extended advertising pattern
-        brg_dut = cert_config.get_brg_by_target(test, DUT)
-        test = cert_config.brg_configure(test, fields=[BRG_RX_CHANNEL, BRG_PATTERN],
-                                         values=[rx_channel, ag.DATAPATH_PATTERN_EXTENDED_ADV],
-                                         module=brg_dut.datapath, ble5=True)[0]
-        if test.rc == TEST_FAILED:
-            return cert_common.test_epilog(test, revert_brgs=True,
-                                           modules=[brg_dut.datapath], ble5=True)
-        test = cert_config.brg_configure(test, fields=[BRG_RX_CHANNEL, BRG_PATTERN],
-                                         values=[rx_channel, ag.DATAPATH_PATTERN_EXTENDED_ADV],
-                                         module=test.brg1.datapath, target=BRG1)[0]
-        if test.rc == TEST_FAILED:
-            return cert_common.test_epilog(test, revert_brgs=True,
-                                           modules=[brg_dut.datapath],
-                                           brg1_modules=[test.brg1.datapath], ble5=True)
+    for param in test.params:
+        phase_run_print(param.name)
+        test = SIGNAL_INDICATOR_TEST_MAP[param.value](test)
+        cert_mqtt.generate_log_file(test, param.name)
+        field_functionality_pass_fail_print(test, param.name)
+        test.set_phase_rc(param.name, test.rc)
+        test.add_phase_reason(param.name, test.reason)
 
-        for param in test.params:
-            phase_run_print(param.name)
-            test = SIGNAL_INDICATOR_TEST_MAP[param.value](test)
-            cert_mqtt.generate_log_file(test, param.name)
-            field_functionality_pass_fail_print(test, param.name)
+        if test.rc == TEST_FAILED:
             test.set_phase_rc(param.name, test.rc)
             test.add_phase_reason(param.name, test.reason)
-            if test.rc == TEST_FAILED and test.exit_on_param_failure:
+            if test.exit_on_param_failure:
                 break
-            else:
-                test.reset_result()
+        else:
+            test.reset_result()
 
-            # Reset to defaults after every phase (don't fail the phase on that)
-            brg_dut = cert_config.get_brg_by_target(test, DUT)
-            test = cert_config.config_brg_defaults(test,
-                                                   modules=[brg_dut.energy2400, brg_dut.sensors],
-                                                   ble5=True, wait=False)[0]
-            # BLE5 configuration can take up to BLE5_MAX_DURATION_SEC, we configured 2 modules here
-            print_update_wait(2 * BLE5_MAX_DURATION_SEC)
-            if test.rc == TEST_FAILED:
-                test.add_reason("Failed to restore brg0 to defaults")
-            else:
-                test = cert_config.config_brg_defaults(test, modules=[test.brg1.energy2400, test.brg1.sensors], ble5=True, target=BRG1)[0]
-                # BLE5 configuration can take up to BLE5_MAX_DURATION_SEC, we configured 2 modules here
-                print_update_wait(2 * BLE5_MAX_DURATION_SEC)
-                if test.rc == TEST_FAILED:
-                    test.add_reason("Failed to restore brg0 to defaults")
-            if test.rc == TEST_FAILED:
-                test.set_phase_rc(param.name, test.rc)
-                test.add_phase_reason(param.name, test.reason)
-                if test.exit_on_param_failure:
-                    break
-            else:
-                test.reset_result()
+    # Revert DUT and TESTER to defaults here and not in epilog
+    test = cert_config.config_brg_defaults(test, modules=[dut.datapath, dut.energy2400],
+                                           ble5=test.dut_is_bridge(), wait=test.dut_is_combo())[0]
+    if test.rc == TEST_FAILED:
+        test.add_reason("Failed to revert dut to defaults")
+    else:
+        test = cert_config.config_brg_defaults(test, modules=[tester.datapath, tester.sensors], target=TESTER)[0]
+        if test.rc == TEST_FAILED:
+            test.add_reason("Failed to revert tester to defaults")
 
-    brg_dut = cert_config.get_brg_by_target(test, DUT)
-    return cert_common.test_epilog(test, revert_brgs=True,
-                                   modules=[brg_dut.datapath],
-                                   brg1_modules=[test.brg1.datapath], ble5=True)
+    return cert_common.test_epilog(test, revert_brgs=False)

certificate/tests/sensors/ext_sensor_test/ext_sensor_test.py

@@ -413,19 +413,14 @@ EXT_SENSOR_TEST_MAP = {"tag_data_only": test_tag_data_only,
 
 
 def run(test):
-    datapath_module = test.active_brg.datapath
-    ext_sensors_module = test.active_brg.sensors
+
     test = cert_common.test_prolog(test)
     # check for problems in prolog
     if test.rc == TEST_FAILED:
         test = cert_common.test_epilog(test)
         return test
 
-    # Adaptation of GW configuration for internal BRG test
-    if test.internal_brg:
-        test = cert_config.brg_configure(test, fields=[BRG_RX_CHANNEL], values=[ag.RX_CHANNEL_37], module=datapath_module, wait=True)[0]
-        if test.rc == TEST_FAILED and test.exit_on_param_failure:
-            return cert_common.test_epilog(test, revert_gws=True)
+    dut = cert_config.get_brg_by_target(test, DUT)
 
     # create csv file for the test
     in_pkts = create_csv_file_in(test)
@@ -439,7 +434,7 @@ def run(test):
 
     for param in test.params:
         phase_run_print(param.name)
-        test = EXT_SENSOR_TEST_MAP[param.value](test, param.name, ext_sensors_module)
+        test = EXT_SENSOR_TEST_MAP[param.value](test, param.name, dut.sensors)
         field_functionality_pass_fail_print(test, param.name)
         test.set_phase_rc(param.name, test.rc)
         test.add_phase_reason(param.name, test.reason)
@@ -452,4 +447,4 @@ def run(test):
     if test.data == DATA_SIMULATION:
         ble_sim_thread.stop()
 
-    return cert_common.test_epilog(test, revert_brgs=True, modules=[ext_sensors_module, datapath_module])
+    return cert_common.test_epilog(test, revert_brgs=True, modules=[dut.sensors, dut.datapath])