wiliot-certificate 4.5.0__py3-none-any.whl → 4.5.0a1__py3-none-any.whl

certificate/tests/energy2400/signal_indicator_ext_adv_test/signal_indicator_ext_adv_test.py

@@ -5,169 +5,327 @@ 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_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
+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
 
-    # 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]
+    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]
     if test.rc == TEST_FAILED:
-        test.add_reason(f"DUT BRG {dut.id_str}: didn't receive signal indicator transmitter configuration!")
+        test.add_reason(f"BRG {rx_brg_.id_str}: didn't receive signal indicator receiver configuration!")
         return test
-    # 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]
+    # 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"DUT BRG {dut.id_str}: didn't receive extended advertising and rx channel configuration!")
+        test.add_reason(f"BRG {tx_brg_.id_str}: didn't receive signal indicator transmitter 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
 
-    # 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]
+    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]
     if test.rc == TEST_FAILED:
-        test.add_reason(f"TESTER BRG {tester.id_str}: didn't receive signal indicator receiver configuration!")
+        test.add_reason(f"BRG {rx_brg_.id_str}: didn't receive signal indicator receiver configuration!")
         return test
-    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]
+    # 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]
     if test.rc == TEST_FAILED:
-        test.add_reason(f"TESTER BRG {tester.id_str}: didn't receive rx channel configuration!")
+        test.add_reason(f"BRG {tx_brg_.id_str}: didn't receive signal indicator transmitter configuration!")
         return test
-
+    utPrint(f"BRG {tx_brg_.id_str} configured to be transmitter - cycle = {cycle},"
+            f"repetition = {rep}", "BOLD")
     # 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):
+    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):
         test.rc = TEST_FAILED
-        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, "
+        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, "
                         f"expected {expected_signal_ind_pkts} packets")
-        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])
+        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!")
         return test
+    utPrint(f"BRG {rx_brg_.id_str} successfully configured as Signal Indicator Receiver\n", "BOLD")
 
-    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)
+    # 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")
 
     return test
 
 
-def test_ext_adv_rx10(test):
+def test_brg0_rxtx_brg1_rxtx(test):
 
-    dut = cert_config.get_brg_by_target(test, DUT)
-    tester = cert_config.get_brg_by_target(test, TESTER)
-    cycle, rep = 8, 4
+    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
 
-    # 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!")
+    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!")
         return test
-    # 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!")
+    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!")
         return test
-    if test.dut_is_bridge():
-        wait_time_n_print(BLE5_MAX_DURATION_SEC)  # BLE5 configuration can take up to BLE5_MAX_DURATION_SEC
+    utPrint(f"BRG {tx_brg_.id_str} configured to be transmitter - cycle={tx_cycle}, repetition={tx_rep}", "BOLD")
 
-    # 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!")
+    # 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!")
         return test
-    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!")
+    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!")
         return test
+    utPrint(f"BRG {rx_brg_.id_str} configured to be transmitter - cycle={rx_cycle}, repetition={rx_rep}")
 
     # 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):
+    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):
         test.rc = TEST_FAILED
-        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, "
+        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, "
                         f"expected {expected_signal_ind_pkts} packets")
-        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])
+        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!")
         return test
 
-    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)
+    # 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_)
 
     return test
 
 
-SIGNAL_INDICATOR_TEST_MAP = {"ext_adv_rx37": test_ext_adv_rx37, "ext_adv_rx10": test_ext_adv_rx10}
+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}
 
 
 def run(test):
     # Test prolog
     test = cert_common.test_prolog(test)
 
-    # 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)
-
-    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 rx_channel in [ag.RX_CHANNEL_10_500K, ag.RX_CHANNEL_37]:
 
+        # 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)
-            if test.exit_on_param_failure:
+            if test.rc == TEST_FAILED and 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.dut_is_bridge():
-        wait_time_n_print(2 * BLE5_MAX_DURATION_SEC)  # BLE5 configuration can take up to 2 * BLE5_MAX_DURATION_SEC
-    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")
+            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()
 
-    return cert_common.test_epilog(test, revert_brgs=False)
+    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)

certificate/tests/energy2400/signal_indicator_test/signal_indicator_test.json

@@ -19,6 +19,5 @@
     "multiBridgeTest": 1,
     "gwOnlyTest": 0,
     "dataSimOnlyTest": 0,
-    "SupportedFromApiVersion": 13,
     "allSupportedValues": ["rssi_threshold", "rx", "tx_eu_pattern", "disable_tx", "disable_rx", "rx_tx"]
 }

certificate/tests/energy2400/signal_indicator_test/signal_indicator_test.py

@@ -288,7 +288,7 @@ def test_rx_tx(test):
         print(rec_sig_ind_pkts)  # TODO: logging print(debug)
 
     # Analyzing tester performance as receiver
-    utPrint(f"Analyzing DUT {dut.id_str} performance as a Transmitter\n", "BOLD")
+    utPrint(f"Analyzing DUT {tester.id_str} performance as a Transmitter\n", "BOLD")
     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

certificate/tests/energy_sub1g/duty_cycle_test/duty_cycle_test.json

@@ -12,6 +12,5 @@
     "multiBridgeTest": 0,
     "gwOnlyTest": 0,
     "dataSimOnlyTest": 0,
-    "SupportedFromApiVersion": 12,
     "allSupportedValues": [15, 20, 40, 0]
 }

certificate/tests/energy_sub1g/pattern_test/pattern_test.json

@@ -12,7 +12,6 @@
     "multiBridgeTest": 0,
     "gwOnlyTest": 0,
     "dataSimOnlyTest": 0,
-    "SupportedFromApiVersion": 12,
     "allSupportedValues": ["SUB1G_ENERGY_PATTERN_NO_ENERGIZING", "SUB1G_ENERGY_PATTERN_SINGLE_TONE_915000",
                            "SUB1G_ENERGY_PATTERN_FCC_HOPPING", "SUB1G_ENERGY_PATTERN_JAPAN_1W",
                            "SUB1G_ENERGY_PATTERN_JAPAN_350MW", "SUB1G_ENERGY_PATTERN_KOREA",

certificate/tests/pwr_mgmt/pwr_mgmt_test/pwr_mgmt_test.json

@@ -14,6 +14,5 @@
     "multiBridgeTest": 0,
     "gwOnlyTest": 0,
     "dataSimOnlyTest": 0,
-    "SupportedFromApiVersion": 12,
     "allSupportedValues": []
 }

certificate/tests/sensors/ext_sensor_test/ext_sensor_test.json

@@ -17,6 +17,5 @@
     "multiBridgeTest": 0,
     "gwOnlyTest": 0,
     "dataSimOnlyTest": 1,
-    "SupportedFromApiVersion": 13,
     "allSupportedValues": ["tag_data_only", "rssi_threshold", "snsr2_unified", "snsr0_no_scrmbl", "snsr1_scrmbl", "snsr0_no_scrmbl_snsr1_scrmbl_snsr2_scrmbl", "snsr0_no_scrmbl_snsr1_scrmbl_snsr2_unified"]
 }

certificate/tests/sensors/ext_sensor_test/ext_sensor_test.py

@@ -413,14 +413,19 @@ 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
 
-    dut = cert_config.get_brg_by_target(test, DUT)
+    # 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)
 
     # create csv file for the test
     in_pkts = create_csv_file_in(test)
@@ -434,7 +439,7 @@ def run(test):
 
     for param in test.params:
         phase_run_print(param.name)
-        test = EXT_SENSOR_TEST_MAP[param.value](test, param.name, dut.sensors)
+        test = EXT_SENSOR_TEST_MAP[param.value](test, param.name, ext_sensors_module)
         field_functionality_pass_fail_print(test, param.name)
         test.set_phase_rc(param.name, test.rc)
         test.add_phase_reason(param.name, test.reason)
@@ -447,4 +452,4 @@ def run(test):
     if test.data == DATA_SIMULATION:
         ble_sim_thread.stop()
 
-    return cert_common.test_epilog(test, revert_brgs=True, modules=[dut.sensors, dut.datapath])
+    return cert_common.test_epilog(test, revert_brgs=True, modules=[ext_sensors_module, datapath_module])

common/api_if/api_validation.py

@@ -23,13 +23,7 @@ def api_validation(test):
         utPrint("API validation is skipped for protobuf messages", "WARNING")
         api_validation_phase.rc = TEST_SKIPPED
         api_validation_phase.reason = "API validation is skipped for protobuf messages"
-        test.add_phase(api_validation_phase)
-        return test
-    elif not test.dut.gw_api_version:
-        utPrint("API validation is skipped because no API version was specified", "WARNING")
-        api_validation_phase.rc = TEST_FAILED
-        api_validation_phase.reason = "API validation is skipped because no API version was specified"
-        test.add_phase(api_validation_phase)
+        test.phases[-1:-1] = [api_validation_phase]
         return test
     else:
         def validate_message(message: dict, msg_type=MESSAGE_TYPES.DATA.value) -> tuple[bool, str]:
@@ -87,5 +81,5 @@ def api_validation(test):
             api_validation_phase.rc = TEST_FAILED
             api_validation_phase.reason = "API (JSON strcture) is invalid"
         field_functionality_pass_fail_print(api_validation_phase, API_VALIDATION)
-        test.add_phase(api_validation_phase)
+        test.phases[-1:-1] = [api_validation_phase]
         return test