wiliot-certificate 1.5.1a1__py3-none-any.whl → 1.5.2a1__py3-none-any.whl

brg_certificate/tests/energy2400/signal_indicator_test/signal_indicator_test.py

@@ -24,117 +24,72 @@ import brg_certificate.cert_config as cert_config
 
 
 # Test MACROS #
-DEFAULT_HDR = ag.Hdr(group_id=ag.GROUP_ID_GW2BRG)
-NUM_OF_SCANNING_CYCLE = 2
-DEFAULT_SCAN_TIME = 60
-SCAN_DELAY_TIME = 5
-BOARD_TYPES_2_POLARIZATION_ANT_LIST = [ag.BOARD_TYPE_MINEW_SINGLE_BAND_V0, ag.BOARD_TYPE_MINEW_DUAL_BAND_V0, ag.BOARD_TYPE_ENERGOUS_V2, ag.BOARD_TYPE_ERM_V0, ag.BOARD_TYPE_ERM_V1]
+NUM_OF_SCANNING_CYCLE = 5
+DEFAULT_SCAN_TIME = 30
+SCAN_DELAY_TIME = 3
+
 
 # Test functions #
-def mqtt_scan_n_create_log_file(test, duration, phase):
-    test.mqttc.flush_pkts()
-    mqtt_scan_wait(test, duration=duration)
-    generate_log_file(test, phase)
-
-def get_all_signal_ind_pkt(test=None, rx_brg=None, tx_brg=None):
-    if rx_brg == test.brg1:
-        all_sensor_packets = cert_mqtt.get_all_brg1_ext_sensor_pkts(mqttc=test.mqttc, test=test)
-    elif rx_brg == test.brg0:
-        all_sensor_packets = cert_mqtt.get_all_sensor_pkts(mqttc=test.mqttc, test=test)
-    signal_ind_pkts = []
-    for p in all_sensor_packets:
-        if p[SENSOR_UUID] == "{:06X}".format(ag.SENSOR_SERVICE_ID_SIGNAL_INDICATOR) and p[BRIDGE_ID] == rx_brg.id_str and (p[SENSOR_ID] == tx_brg.id_alias):
-            signal_ind_pkts.append(p)
-    #TODO: logging print 
-    print(f" Found {len(signal_ind_pkts)} signal indicator pkts \n")
-    return signal_ind_pkts
-
-def expected_signal_ind_pkts_calc(tx_brg, rx_brg):
-    if (tx_brg.board_type in BOARD_TYPES_2_POLARIZATION_ANT_LIST):
-        tx_brg_ant_polarization_num = 2
-    else:
-        tx_brg_ant_polarization_num = 1
-    if (rx_brg.board_type in BOARD_TYPES_2_POLARIZATION_ANT_LIST):
-        rx_brg_ant_polarization_num = 2
-        result = [(NUM_OF_SCANNING_CYCLE * tx_brg_ant_polarization_num * rx_brg_ant_polarization_num) - 1,
-                  NUM_OF_SCANNING_CYCLE * tx_brg_ant_polarization_num * rx_brg_ant_polarization_num]
-    else:
-        rx_brg_ant_polarization_num = 1
-        result = [NUM_OF_SCANNING_CYCLE * tx_brg_ant_polarization_num * rx_brg_ant_polarization_num]
-    return result
-
-def rssi_check(test, received_signal_ind_pkts ):
-    threshold_rssi  = [0,80]
+def rssi_check(test, received_signal_ind_pkts):
+    threshold_rssi = [0, 80]
     for p in received_signal_ind_pkts:
-        #TODO: logging print
-        # print(f"rssi value: {p[RSSI]}")
         if not threshold_rssi[0] < p[RSSI] < threshold_rssi[1]:
             test.rc = TEST_FAILED
             test.add_reason("rssi value is wrong, out of 0 to 80 ")
 
     return test
 
-def rx_tx_antenna_check(test, received_signal_ind_pkts , tx_brg_, rx_brg_ ):
-    #TODO: logging print
-    # print(f"length of received signal indicator pkts: {len(received_signal_ind_pkts)}\n ")
-    # print(f"tx_brg board_type:{tx_brg_.board_type}\n")
-    # print(f"rx_brg board_type:{rx_brg_.board_type}\n")
-    
-    list = get_polar_signal_ind_pkt(received_signal_ind_pkts,0,0)
-    print(f"polar signal ind pkt 0,0: {list}")
-    if len(get_polar_signal_ind_pkt(received_signal_ind_pkts, 0, 0)) != NUM_OF_SCANNING_CYCLE:
+
+def rx_tx_antenna_check(test, received_signal_ind_pkts, tx_brg_, rx_brg_):
+
+    # Allow to miss 1 packet
+    expected = range(int(NUM_OF_SCANNING_CYCLE * 0.5), NUM_OF_SCANNING_CYCLE + 1)
+
+    received = len(get_polar_signal_ind_pkt(received_signal_ind_pkts, rx_ant=0, tx_ant=0))
+    if received not in expected:
         test.rc = TEST_FAILED
-        test.add_reason("incorrect num of packets with (0,0)!")
+        test.add_reason(f"rx_ant=0 tx_ant=0 expected={NUM_OF_SCANNING_CYCLE} received={received}")
 
-    if tx_brg_.board_type in BOARD_TYPES_2_POLARIZATION_ANT_LIST:
-        list = get_polar_signal_ind_pkt(received_signal_ind_pkts,0,1)
-        print(f"polar signal ind pkt 0,1: {list}")
-        if len(get_polar_signal_ind_pkt(pkts=received_signal_ind_pkts, rx_ant=0, tx_ant=1)) != NUM_OF_SCANNING_CYCLE:
+    if tx_brg_.board_type in cert_common.dual_polarization_ant_boards_get():
+        received = len(get_polar_signal_ind_pkt(received_signal_ind_pkts, rx_ant=0, tx_ant=1))
+        if received not in expected:
             test.rc = TEST_FAILED
-            test.add_reason("incorrect num of packets with (0,1)")
-    
-    if rx_brg_.board_type in BOARD_TYPES_2_POLARIZATION_ANT_LIST:
-        list = get_polar_signal_ind_pkt(received_signal_ind_pkts,1,0)
-        print(f"polar signal ind pkt 1,0: {list}")
-        if len(get_polar_signal_ind_pkt(received_signal_ind_pkts, 1, 0)) != NUM_OF_SCANNING_CYCLE:
+            test.add_reason(f"rx_ant=0 tx_ant=1 expected={NUM_OF_SCANNING_CYCLE} received={received}")
+
+    if rx_brg_.board_type in cert_common.dual_polarization_ant_boards_get():
+        received = len(get_polar_signal_ind_pkt(received_signal_ind_pkts, rx_ant=1, tx_ant=0))
+        if received not in expected:
             test.rc = TEST_FAILED
-            test.add_reason("incorrect num of packets with (1,0)")
+            test.add_reason(f"rx_ant=1 tx_ant=0 expected={NUM_OF_SCANNING_CYCLE} received={received}")
 
-    if rx_brg_.board_type in BOARD_TYPES_2_POLARIZATION_ANT_LIST and tx_brg_.board_type in BOARD_TYPES_2_POLARIZATION_ANT_LIST:
-        list = get_polar_signal_ind_pkt(received_signal_ind_pkts,1,1)
-        print(f"polar signal ind pkt 1,1: {list}")
-        if len(get_polar_signal_ind_pkt(received_signal_ind_pkts, 1, 1)) != NUM_OF_SCANNING_CYCLE:
+    if (rx_brg_.board_type in cert_common.dual_polarization_ant_boards_get() and
+            tx_brg_.board_type in cert_common.dual_polarization_ant_boards_get()):
+        received = len(get_polar_signal_ind_pkt(received_signal_ind_pkts, rx_ant=1, tx_ant=1))
+        if received not in expected:
             test.rc = TEST_FAILED
-            test.add_reason("incorrect num of packets with (1,1)")
+            test.add_reason(f"rx_ant=1 tx_ant=1 expected={NUM_OF_SCANNING_CYCLE} received={received}")
     return test
 
+
 def get_polar_signal_ind_pkt(pkts, rx_ant, tx_ant):
-    for p in pkts:
-        #TODO: logging print
-        print(f" rx antenna: {p[SENSOR_PKT].pkt.rx_antenna}, tx antenna: {p[SENSOR_PKT].pkt.tx_antenna}  ######    rx_ant: {rx_ant}, tx_ant: {tx_ant}")
     return [p for p in pkts if p[SENSOR_PKT].pkt.rx_antenna == rx_ant and p[SENSOR_PKT].pkt.tx_antenna == tx_ant]
 
+
 def output_power_check(test, received_signal_ind_pkts, tx_brg_):
-    #TODO: verify that in this implement it corresponding to the current board. and verify situation that we have 2 different board type. 
-    output_power_def_internal = ag.BRG_DEFAULT_OUTPUT_POWER_2_4
-    output_power_def_not_internal = ag.BRG_DEFAULT_DATAPATH_OUTPUT_POWER
+
+    datapath_module = cert_common.get_module_by_name(tx_brg_.modules, "Datapath")
+    output_power_default = datapath_module().output_power
 
     for p in received_signal_ind_pkts:
-        print(p[SENSOR_PKT].pkt)
-        # NOTE: generic way to identify if the brg is internal or not 
-        if len(tx_brg_.__dict__["sup_caps"]) == 3 : # which mean it's internal bridge 
-            if p[SENSOR_PKT].pkt.output_power != output_power_def_internal:
-                test.rc = TEST_FAILED
-                test.add_reason(f"output power of internal brg  is incorrect! \n got:{p[SENSOR_PKT].pkt.out_power}, expected: {output_power_def_internal}\n")
-        else:
-            if p[SENSOR_PKT].pkt.output_power != output_power_def_not_internal:
-                test.rc = TEST_FAILED
-                test.add_reason(f"output power of active brg  is incorrect! \n got:{p[SENSOR_PKT].pkt.output_power}, expected: {output_power_def_internal}\n")
+        if p[SENSOR_PKT].pkt.output_power != output_power_default:
+            test.rc = TEST_FAILED
+            test.add_reason("output power of internal brg  is incorrect!\n"
+                            f"got:{p[SENSOR_PKT].pkt.output_power}, expected: {output_power_default}\n")
     return test
 
 
 def test_rssi_threshold(test, energy2400_module, ext_sensors_module):
-    cycle, rep = 30, 3
+    cycle, rep = 5, 4
     tx_brg_ = test.brg0
     rx_brg_ = test.brg1
     rssi_threshold = -25
@@ -142,117 +97,131 @@ def test_rssi_threshold(test, energy2400_module, ext_sensors_module):
     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")
-    test =  cert_config.brg1_configure(test=test, module=ext_sensors_module, fields=[BRG_SENSOR0, BRG_RSSI_THRESHOLD], values=[ag.EXTERNAL_SENSORS_SIGNAL_INDICATOR, rssi_threshold])[0]
+    test = cert_config.brg1_configure(test=test, module=ext_sensors_module, fields=[BRG_SENSOR0, BRG_RSSI_THRESHOLD],
+                                      values=[ag.EXTERNAL_SENSORS_SIGNAL_INDICATOR, rssi_threshold])[0]
     if test.rc == TEST_FAILED:
         test.add_reason(f"BRG {rx_brg_.id_str}: didn't receive signal indicator receiver configuration!")
         return test
     # configuring transmitter #
     utPrint(f"Configuring BRG {tx_brg_.id_str} as Signal Indicator Transmitter", "BOLD")
-    test =  cert_config.brg_configure(test=test, module=energy2400_module, fields=[BRG_SIGNAL_INDICATOR_CYCLE, BRG_SIGNAL_INDICATOR_REP], values=[cycle, rep])[0]
+    test = cert_config.brg_configure(test=test, module=energy2400_module, fields=[BRG_SIGNAL_INDICATOR_CYCLE, BRG_SIGNAL_INDICATOR_REP],
+                                     values=[cycle, rep])[0]
     if test.rc == TEST_FAILED:
         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 #
-    mqtt_scan_n_create_log_file(test, (NUM_OF_SCANNING_CYCLE * cycle) + SCAN_DELAY_TIME, f"rssi_threshold")
-    received_signal_ind_pkts = get_all_signal_ind_pkt(test=test, rx_brg=rx_brg_, tx_brg=tx_brg_)
+    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[RSSI]}")
-    rssi_threshold_viloation_pkts = [p for p in received_signal_ind_pkts if p[RSSI] >= -1*rssi_threshold]
+    rssi_threshold_viloation_pkts = [p for p in received_signal_ind_pkts if p[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}")
+        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_rx_brg1_tx(test, energy2400_module, ext_sensors_module):
-    cycle_rep = [(30,3), (60,4)]
-    tx_brg_ = test.brg0
-    rx_brg_ = test.brg1
 
-    for cycle,rep in cycle_rep:
-        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")
-        test =  cert_config.brg1_configure(test=test, module=ext_sensors_module, fields=[BRG_SENSOR0], values=[ag.EXTERNAL_SENSORS_SIGNAL_INDICATOR])[0]
-        if test.rc == TEST_FAILED:
-            test.add_reason(f"BRG {rx_brg_.id_str}: didn't receive signal indicator receiver configuration!")
-            return test
-        # configuring transmitter #
-        utPrint(f"Configuring BRG {tx_brg_.id_str} as Signal Indicator Transmitter", "BOLD")
-        test =  cert_config.brg_configure(test=test, module=energy2400_module, fields=[BRG_SIGNAL_INDICATOR_CYCLE, BRG_SIGNAL_INDICATOR_REP], values=[cycle, rep])[0]
-        if test.rc == TEST_FAILED:
-            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 #
-        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 = get_all_signal_ind_pkt(test=test, rx_brg=rx_brg_, tx_brg=tx_brg_)
-        expected_signal_ind_pkts = expected_signal_ind_pkts_calc(tx_brg_, rx_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")
+    rx_brg_ = test.brg0
+    tx_brg_ = test.brg1
+    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")
+    test = cert_config.brg_configure(test=test, module=ext_sensors_module, fields=[BRG_SENSOR0],
+                                     values=[ag.EXTERNAL_SENSORS_SIGNAL_INDICATOR])[0]
+    if test.rc == TEST_FAILED:
+        test.add_reason(f"BRG {rx_brg_.id_str}: didn't receive signal indicator receiver configuration!")
+        return test
+    # configuring transmitter #
+    utPrint(f"Configuring BRG {tx_brg_.id_str} as Signal Indicator Transmitter", "BOLD")
+    test = cert_config.brg1_configure(test=test, module=energy2400_module,
+                                      fields=[BRG_SIGNAL_INDICATOR_CYCLE, BRG_SIGNAL_INDICATOR_REP],
+                                      values=[cycle, rep])[0]
+    if test.rc == TEST_FAILED:
+        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 #
+    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(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(received_signal_ind_pkts)  # TODO: logging print(debug)
+        print([[p[TIMESTAMP], p[SENSOR_PKT].pkt.rx_antenna] for p in received_signal_ind_pkts])
+
+    test = rx_tx_antenna_check(test, received_signal_ind_pkts, tx_brg_, rx_brg_)
+    test = output_power_check(test, received_signal_ind_pkts, tx_brg_)
+    test = rssi_check(test, received_signal_ind_pkts)
 
-        test = rx_tx_antenna_check(test, received_signal_ind_pkts, tx_brg_, rx_brg_)
-        test = output_power_check(test, received_signal_ind_pkts, tx_brg_)
-        test = rssi_check(test, received_signal_ind_pkts)
     return test
 
+
 def test_brg0_none_brg1_rx(test, energy2400_module, ext_sensors_module):
     cycle, rep = ag.BRG_DEFAULT_SIGNAL_INDICATOR_CYCLE, ag.BRG_DEFAULT_SIGNAL_INDICATOR_REP
-    tx_brg_ = test.brg0
+    tx_brg_ = test.brg1
     rx_brg_ = test.brg1
     utPrint(f"RX BRG without TX- cycle = {cycle}, repetition = {rep}\n", "BLUE")
-    # configuring transmitter to no TX #
-    utPrint(f"Configuring BRG {tx_brg_.id_str} to default", "BOLD")
-    test =  cert_config.brg_configure(test=test, module=energy2400_module, fields=[BRG_SIGNAL_INDICATOR_CYCLE, BRG_SIGNAL_INDICATOR_REP], values=[cycle, rep])[0]
+    # configuring receiver #
+    utPrint(f"Configuring BRG {rx_brg_.id_str} as Signal Indicator Receiver", "BOLD")
+    test = cert_config.brg1_configure(test=test, module=ext_sensors_module, fields=[BRG_SENSOR0],
+                                      values=[ag.EXTERNAL_SENSORS_SIGNAL_INDICATOR])[0]
     if test.rc == TEST_FAILED:
-        test.add_reason(f"BRG {tx_brg_.id_str}: didn't revert to default (no signal indicator tx)!")
+        test.add_reason(f"BRG {rx_brg_.id_str}: didn't receive signal indicator receiver configuration!")
         return test
-    utPrint(f"BRG {tx_brg_.id_str} configured to default!!! cycle = {cycle},"
-              f"repetition = {rep}", "BOLD")
+    utPrint(f"BRG {rx_brg_.id_str} successfully configured as Signal Indicator Receiver\n", "BOLD")
+
     # phase analysis #
     mqtt_scan_n_create_log_file(test, DEFAULT_SCAN_TIME, "brg0_none_brg1_rx")
     expected_signal_ind_pkts = [0]
-    received_signal_ind_pkts = get_all_signal_ind_pkt(test=test, rx_brg=rx_brg_, tx_brg=tx_brg_)
+    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")
+                        f"signal indicator packets\n received {len(received_signal_ind_pkts)} packets, "
+                        f"expected {expected_signal_ind_pkts} packets")
 
     return test
 
+
 def test_brg0_rxtx_brg1_rxtx(test, energy2400_module, ext_sensors_module):
-    tx_cycle, tx_rep = 15,4
-    rx_cycle, rx_rep = 16,4
+    tx_cycle, tx_rep = 5, 4
+    rx_cycle, rx_rep = 5, 4
     tx_brg_ = test.brg0
     rx_brg_ = test.brg1
-    utPrint(f"Both BRG's are transmitter and receivers, with different values\n", "BLUE")
+    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=ext_sensors_module, fields=[BRG_SENSOR0], values=[ag.EXTERNAL_SENSORS_SIGNAL_INDICATOR])[0]
+    test = cert_config.brg_configure(test=test, module=ext_sensors_module, fields=[BRG_SENSOR0],
+                                     values=[ag.EXTERNAL_SENSORS_SIGNAL_INDICATOR])[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
     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=energy2400_module, fields=[BRG_SIGNAL_INDICATOR_CYCLE, BRG_SIGNAL_INDICATOR_REP], values=[tx_cycle, tx_rep])[0]
+    test = cert_config.brg_configure(test=test, module=energy2400_module, fields=[BRG_SIGNAL_INDICATOR_CYCLE, BRG_SIGNAL_INDICATOR_REP],
+                                     values=[tx_cycle, tx_rep])[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
-    utPrint(f"BRG {tx_brg_.id_str} configured to be transmitter - cycle = {tx_cycle},"
-                f"repetition = {tx_rep}", "BOLD")
+    utPrint(f"BRG {tx_brg_.id_str} configured to be transmitter - cycle={tx_cycle}, repetition={tx_rep}", "BOLD")
 
     # configuring second brg (rx_brg_) as receiver
     utPrint(f"Configuring BRG {rx_brg_.id_str} as Signal Indicator Receiver", "BOLD")
-    test =  cert_config.brg1_configure(test=test, module=ext_sensors_module, fields=[BRG_SENSOR0], values=[ag.EXTERNAL_SENSORS_SIGNAL_INDICATOR])[0]
+    test = cert_config.brg1_configure(test=test, module=ext_sensors_module, fields=[BRG_SENSOR0],
+                                      values=[ag.EXTERNAL_SENSORS_SIGNAL_INDICATOR])[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
@@ -260,83 +229,84 @@ def test_brg0_rxtx_brg1_rxtx(test, energy2400_module, ext_sensors_module):
 
     # 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.brg1_configure(test=test, module=energy2400_module, fields=[BRG_SIGNAL_INDICATOR_CYCLE, BRG_SIGNAL_INDICATOR_REP], values=[rx_cycle, rx_rep])[0]
+    test = cert_config.brg1_configure(test=test, module=energy2400_module, fields=[BRG_SIGNAL_INDICATOR_CYCLE, BRG_SIGNAL_INDICATOR_REP],
+                                      values=[rx_cycle, rx_rep])[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},"
-                f"repetition = {rx_rep}")
+    utPrint(f"BRG {rx_brg_.id_str} configured to be transmitter - cycle={rx_cycle}, repetition={rx_rep}")
 
     # phase analysis #
     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")
-    expected_signal_ind_pkts = expected_signal_ind_pkts_calc(rx_brg_, tx_brg_)
-    received_signal_ind_pkts = get_all_signal_ind_pkt(test=test, rx_brg=tx_brg_, tx_brg=rx_brg_)
-    if len(received_signal_ind_pkts) not in expected_signal_ind_pkts:
+    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\n received {len(received_signal_ind_pkts)} packets, "
-                                f"expected {expected_signal_ind_pkts} packets")
+                        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")
-    expected_signal_ind_pkts = expected_signal_ind_pkts_calc(tx_brg_, rx_brg_)
-    received_signal_ind_pkts = get_all_signal_ind_pkt(test=test, rx_brg=rx_brg_, tx_brg=tx_brg_)
-    if len(received_signal_ind_pkts) not in expected_signal_ind_pkts:
+    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(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")
-    #NOTE: I skipped the antenna and output power checks for this phase 
+                        f"signal indicator packets\n received {len(received_signal_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, energy2400_module, ext_sensors_module):
     # 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 = 15,3
+    cycle, rep = 4, 3
     tx_brg_ = test.brg0
     rx_brg_ = test.brg1
     utPrint(f"TX BRG without RX - cycle = {cycle}, repetition = {rep}\n", "BLUE")
-    # restore default configuration for receiver #
-    utPrint(f"Configuring BRG {rx_brg_.id_str} to default", "BOLD")
-    test = cert_config.config_brg1_defaults(test, modules=[energy2400_module, ext_sensors_module])[0]
-    if test.rc == TEST_FAILED:
-        test.add_reason(f"BRG {rx_brg_.id_str}: didn't revert to default configuration!")
-        return test
     # configuring transmitter #
     utPrint(f"Configuring BRG {tx_brg_.id_str} as Signal Indicator Transmitter", "BOLD")
-    test =  cert_config.brg_configure(test=test, module=energy2400_module, fields=[BRG_SIGNAL_INDICATOR_CYCLE, BRG_SIGNAL_INDICATOR_REP], values=[cycle, rep])[0]
+    test = cert_config.brg_configure(test=test, module=energy2400_module,
+                                     fields=[BRG_SIGNAL_INDICATOR_CYCLE, BRG_SIGNAL_INDICATOR_REP], values=[cycle, rep])[0]
     if test.rc == TEST_FAILED:
         test.add_reason(f"BRG {tx_brg_.id_str}: didn't receive signal indicator transmitter configuration!")
         return test
 
     # phase analysis #
-    mqtt_scan_n_create_log_file(test, (NUM_OF_SCANNING_CYCLE*cycle) + SCAN_DELAY_TIME, "brg0_tx_brg1_none")
+    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 = get_all_signal_ind_pkt(test=test, rx_brg=rx_brg_, tx_brg=tx_brg_)
+    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}")
+                        f"{rx_brg_.id_str}")
     test = output_power_check(test, received_signal_ind_pkts, tx_brg_)
 
     return test
 
-SIGNAL_INDICATOR_TEST_MAP = {"rssi_threshold" : test_rssi_threshold, "brg0_rx_brg1_tx": test_brg0_rx_brg1_tx,
+
+SIGNAL_INDICATOR_TEST_MAP = {"rssi_threshold": test_rssi_threshold, "brg0_rx_brg1_tx": test_brg0_rx_brg1_tx,
                              "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)
+
     # Test modules evaluation #
     energy2400_module = eval_pkt(f'ModuleEnergy2400V{test.active_brg.api_version}')
     ext_sensors_module = eval_pkt(f'ModuleExtSensorsV{test.active_brg.api_version}')
 
-    # Test prolog
-    test = cert_common.test_prolog(test)
     for param in test.params:
-        functionality_run_print(param.name)
+        phase_run_print(param.name)
         test = SIGNAL_INDICATOR_TEST_MAP[param.value](test, energy2400_module, ext_sensors_module)
         generate_log_file(test, param.name)
         field_functionality_pass_fail_print(test, param.name)
@@ -346,6 +316,22 @@ def run(test):
             break
         else:
             test.reset_result()
-    
+
+        # Reset to defaults after every phase (don't fail the phase on that)
+        test = cert_config.config_brg_defaults(test, modules=[energy2400_module, ext_sensors_module])[0]
+        if test.rc == TEST_FAILED:
+            test.add_reason("Failed to restore brg0 to defaults")
+        else:
+            test = cert_config.config_brg1_defaults(test, modules=[energy2400_module, ext_sensors_module])[0]
+            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=True, modules=[energy2400_module, ext_sensors_module],
-                                 brg1_modules=[energy2400_module, ext_sensors_module])
+                                   brg1_modules=[energy2400_module, ext_sensors_module])

brg_certificate/tests/energy_sub1g/duty_cycle_test/duty_cycle_test.json

@@ -1,6 +1,6 @@
 {
-    "name": "duty_cycle_test",
-    "module": "energy_sub1g",
+    "name": "Duty Cycle",
+    "module": "Energizer Sub-1GHz",
     "purpose": "Test configuration for supported energy_sub1g duty cycle & bridge cycle sets of values",
     "documentation": "https://community.wiliot.com/customers/s/article/Wiliot-Network-Sub1-Ghz-Energizer-module",
     "initialCondition": "Bridge configured to defaults",

brg_certificate/tests/energy_sub1g/duty_cycle_test/duty_cycle_test.py

@@ -4,6 +4,7 @@ from brg_certificate.wlt_types import *
 import brg_certificate.cert_common as cert_common
 import brg_certificate.cert_config as cert_config
 
+
 def run(test):
 
     fields = [BRG_DUTY_CYCLE]
@@ -24,4 +25,4 @@ def run(test):
         else:
             test.reset_result()
 
-    return cert_common.test_epilog(test, revert_brgs=True, modules=[sub1g_module])
+    return cert_common.test_epilog(test, revert_brgs=True, modules=[sub1g_module])

brg_certificate/tests/energy_sub1g/pattern_test/pattern_test.json

@@ -1,7 +1,7 @@
 {
-    "name": "pattern_test",
-    "module": "energy_sub1g",
-    "purpose": "Test configuration for all supported Energy SUB1GHz pattern values",
+    "name": "Pattern",
+    "module": "Energizer Sub-1GHz",
+    "purpose": "Test configuration for all supported energy_sub1g pattern values",
     "documentation": "https://community.wiliot.com/customers/s/article/Wiliot-Network-Sub1-Ghz-Energizer-module",
     "initialCondition": "Bridge configured to defaults",
     "procedure": ["Test prolog",
@@ -11,6 +11,7 @@
     "mandatory": 1,
     "multiBridgeTest": 0,
     "gwOnlyTest": 0,
+    "internalBridge": 1,
     "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",

brg_certificate/tests/energy_sub1g/pattern_test/pattern_test.py

@@ -4,6 +4,7 @@ from brg_certificate.wlt_types import *
 import brg_certificate.cert_common as cert_common
 import brg_certificate.cert_config as cert_config
 
+
 def run(test):
 
     fields = [BRG_PATTERN]
@@ -23,4 +24,4 @@ def run(test):
         else:
             test.reset_result()
 
-    return cert_common.test_epilog(test, revert_brgs=True, modules=[sub1g_module])
+    return cert_common.test_epilog(test, revert_brgs=True, modules=[sub1g_module])

brg_certificate/tests/energy_sub1g/signal_indicator_functionality_test/signal_indicator_functionality_test.json

@@ -1,11 +1,17 @@
 {
-    "name": "signal_indicator_functionality_test",
-    "module": "energy_sub1g",
-    "purpose": "TODO",
-    "documentation": "<TEST_DOCUMENTATION_LINK>",
-    "initialCondition": "TODO",
-    "procedure": ["Test prolog", "TODO", "Test epilog"],
-    "expectedOutcome": "TODO",
+    "name": "Signal Indicator Functionality",
+    "module": "Energizer Sub-1GHz",
+    "purpose": "Test functionality for supported sub1g signal indicator cycle & repetitions sets of values",
+    "documentation": "https://community.wiliot.com/customers/s/article/Wiliot-Network-Sub1-Ghz-Energizer-module",
+    "initialCondition": "1 GW and at least 1 BRG configured to defaults",
+    "procedure": ["Test prolog",
+    "rssi_threshold - check the if rssi value is between 0 to -25.",
+    "brg0_tx_brg1_rx (for all EP's)- one brg is transmitter and the second is receiver, we expect to receive signal indicator packets for all energy patterns",
+    "brg0_tx_brg1_rx ( only israel ep) - one brg is transmitter and the second is receiver, we expect to receive signal indicator packets in the specified energy pattern",
+    "brg0_none_brg1_rx - One BRG will be configured as signal indicator rx, but no tx, so we don't expect to receive signal indicator packets.",
+    "brg0_rxtx_brg1_rxtx - 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.",
+    "Test epilog"],
+    "expectedOutcome": "All phases passes successfully",
     "mandatory": 0,
     "multiBridgeTest": 1,
     "gwOnlyTest": 0,