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

brg_certificate/tests/energy_sub1g/signal_indicator_functionality_test/signal_indicator_functionality_test.py

@@ -20,7 +20,7 @@ import random
 #   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.
+#   phase 5 - One BRG will be configured as signal indicator tx, but no rx, so we don't expect to receive signal indicator packets.
 #   that way we can assure the logic within the receiver is not confused by the signal indicator uuid as external sensor.
 
 
@@ -29,7 +29,11 @@ DEFAULT_HDR = ag.Hdr(group_id=ag.GROUP_ID_GW2BRG)
 NUM_OF_SCANNING_CYCLE = 2
 DEFAULT_SCAN_TIME = 60
 SCAN_DELAY_TIME = 5
-VALUES_DICT = {0:(5,3),1:(5,3),2:(60,4),3:(ag.BRG_DEFAULT_SIGNAL_INDICATOR_CYCLE,ag.BRG_DEFAULT_SIGNAL_INDICATOR_REP),4:[(45,3),(90,4)],5:(15,1)}
+VALUES_DICT = {0: (5, 3), 1: (5, 3),
+               2: (60, 4),
+               3: (ag.BRG_DEFAULT_SIGNAL_INDICATOR_CYCLE, ag.BRG_DEFAULT_SIGNAL_INDICATOR_REP),
+               4: [(45, 3), (90, 4)],
+               5: (15, 1)}
 CYCLE_IDX = 0
 REP_IDX = 1
 TX_BRG_IDX = 0
@@ -38,32 +42,16 @@ TEST_SUB1G_ENERGY_PATTERNS = [ag.SUB1G_ENERGY_PATTERN_SINGLE_TONE_915000, ag.SUB
                               ag.SUB1G_ENERGY_PATTERN_SINGLE_TONE_916300, ag.SUB1G_ENERGY_PATTERN_SINGLE_TONE_917500,
                               ag.SUB1G_ENERGY_PATTERN_AUSTRALIA, ag.SUB1G_ENERGY_PATTERN_ISRAEL, ag.SUB1G_ENERGY_PATTERN_NZ_HOPPING]
 
-hex2id_get =lambda id_str : "{:012X}".format(id_str)
 
 # Helper function #
 def get_phase_tx_params_values(phase, brg):
     if phase == 4:
-        return VALUES_DICT[phase][brg][CYCLE_IDX] , VALUES_DICT[phase][brg][REP_IDX]
+        return VALUES_DICT[phase][brg][CYCLE_IDX], VALUES_DICT[phase][brg][REP_IDX]
     else:
         return VALUES_DICT[phase][CYCLE_IDX], VALUES_DICT[phase][REP_IDX]
 
-# 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_str:
-            signal_ind_pkts.append(p)
-    return signal_ind_pkts
 
+# Test functions #
 def terminate_test(test, phase=0, revert_rx_brg=False, revert_tx_brg=False, modules=[]):
     # Temp solution for internal_brg test because test_epilog doesn't support both internal brg and test.brgs
     utPrint("Terminating test!!!!!!!!\n", "BLUE")
@@ -73,8 +61,7 @@ def terminate_test(test, phase=0, revert_rx_brg=False, revert_tx_brg=False, modu
         test, response = cert_config.config_brg1_defaults(test, modules=restore_modules)
         if response == NO_RESPONSE and test.exit_on_param_failure:
             test.rc = TEST_FAILED
-            test.add_reason(f"BRG {test.brg1.id_str} didn't revert modules "
-                                   f"{restore_modules} to default configuration!")
+            test.add_reason(f"BRG {test.brg1.id_str} didn't revert modules {restore_modules} to default configuration!")
 
     if revert_tx_brg:
         restore_modules = [modules[0]] if (test.internal_brg or phase != 4) else modules
@@ -82,11 +69,10 @@ def terminate_test(test, phase=0, revert_rx_brg=False, revert_tx_brg=False, modu
         test, response = cert_config.config_brg_defaults(test, modules=restore_modules)
         if response == NO_RESPONSE and test.exit_on_param_failure:
             test.rc = TEST_FAILED
-            test.add_reason(f"BRG {test.brg0.id_str} didn't revert modules"
-                                   f"{restore_modules} to default configuration!")
+            test.add_reason(f"BRG {test.brg0.id_str} didn't revert modules {restore_modules} to default configuration!")
     return cert_common.test_epilog(test)
 
-# Test execution #
+
 def run(test):
 
     # Test modules evaluation #
@@ -120,36 +106,37 @@ def run(test):
 
     # configuring RX #
     utPrint(f"Configuring BRG {rx_brg_.id_str} as SUB1G Signal Indicator Receiver", "BOLD")
-    test =  cert_config.brg1_configure(test=test, module=ext_sensors_module, fields=[BRG_SENSOR0, BRG_SUB1G_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_SUB1G_RSSI_THRESHOLD],
+                                      values=[ag.EXTERNAL_SENSORS_SIGNAL_INDICATOR, rssi_threshold])[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 terminate_test(test, phase=phase, revert_rx_brg=True, modules=modules)
-    utPrint(f"BRG {rx_brg_.id_str} succesfully configured to be Receiver", "GREEN")
+    utPrint(f"BRG {rx_brg_.id_str} successfully configured to be Receiver", "GREEN")
 
     # configuring TX #
     utPrint(f"Configuring BRG {tx_brg_.id_str} as SUB1G Signal Indicator Transmitter\n", "BOLD")
     transmitter_cfg_pkt = WltPkt(hdr=DEFAULT_HDR, pkt=tx_module(seq_id=random.randrange(99), brg_mac=tx_brg_.id_int,
-                                    signal_indicator_cycle=tx_signal_ind_cycle, signal_indicator_rep=tx_signal_ind_rep, pattern=ag.SUB1G_ENERGY_PATTERN_ISRAEL, duty_cycle=30))
+                                 signal_indicator_cycle=tx_signal_ind_cycle, signal_indicator_rep=tx_signal_ind_rep,
+                                 pattern=ag.SUB1G_ENERGY_PATTERN_ISRAEL, duty_cycle=30))
     test = cert_config.brg_configure(test=test, cfg_pkt=transmitter_cfg_pkt)[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 terminate_test(test, phase=phase, revert_rx_brg=True,revert_tx_brg=True, modules=modules)
-    utPrint(f"BRG {tx_brg_.id_str} succesfully configured to be transmitter - cycle = {tx_signal_ind_cycle},"
+        return terminate_test(test, phase=phase, revert_rx_brg=True, revert_tx_brg=True, modules=modules)
+    utPrint(f"BRG {tx_brg_.id_str} successfully configured to be transmitter - cycle = {tx_signal_ind_cycle},"
             f"repetition = {tx_signal_ind_rep}, pattern = {ag.SUB1G_ENERGY_PATTERN_ISRAEL}", "GREEN")
-    
+
     # Analyzing RSSI Threshold violation #
     mqtt_scan_n_create_log_file(test, (NUM_OF_SCANNING_CYCLE * tx_signal_ind_cycle) + SCAN_DELAY_TIME, phase)
-    received_signal_ind_pkts = get_all_signal_ind_pkt(test=test, rx_brg=rx_brg_, tx_brg=tx_brg_)
-    rssi_threshold_viloation_pkts = [p for p in received_signal_ind_pkts if p[RSSI] >= -1*rssi_threshold]
-    if rssi_threshold_viloation_pkts:
+    received_signal_ind_pkts = cert_common.get_all_sig_ind_pkts(test=test, rx_brg=rx_brg_, tx_brg=tx_brg_)
+    rssi_threshold_violation_pkts = [p for p in received_signal_ind_pkts if p[RSSI] >= -1 * rssi_threshold]
+    if rssi_threshold_violation_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}")
+                        f" {len(rssi_threshold_violation_pkts)} signal indicator packets\n with RSSI weaker than {rssi_threshold}")
 
-    field_functionality_pass_fail_print(test,'phase',phase)
+    field_functionality_pass_fail_print(test, 'phase', phase)
     if test.rc == TEST_FAILED:
-        return terminate_test(test, phase=phase, revert_rx_brg=True,revert_tx_brg=True, modules=modules)
+        return terminate_test(test, phase=phase, revert_rx_brg=True, revert_tx_brg=True, modules=modules)
 
     phase = 1
     functionality_run_print(f"phase {phase}")
@@ -161,49 +148,52 @@ def run(test):
 
     # configuring RX #
     utPrint(f"Configuring BRG {rx_brg_.id_str} as SUB1G 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 terminate_test(test, phase=phase, revert_rx_brg=True, modules=modules)
-    utPrint(f"BRG {rx_brg_.id_str} succesfully configured to be Receiver", "GREEN")
+    utPrint(f"BRG {rx_brg_.id_str} successfully configured to be Receiver", "GREEN")
 
     for energy_pattern in TEST_SUB1G_ENERGY_PATTERNS:
         utPrint(f"Energy pattern is {energy_pattern}", "WARNING")
 
         # configuring RX BRG to desired pattern #
         utPrint(f"Configuring RX BRG {rx_brg_.id_str} to EP {energy_pattern}", "BOLD")
-        receiver_cfg_pkt = WltPkt(hdr=DEFAULT_HDR, pkt=tx_module(seq_id=random.randrange(99), brg_mac=rx_brg_.id_int, pattern=energy_pattern, duty_cycle=30))
+        receiver_cfg_pkt = WltPkt(hdr=DEFAULT_HDR, pkt=tx_module(seq_id=random.randrange(99), brg_mac=rx_brg_.id_int,
+                                                                 pattern=energy_pattern, duty_cycle=30))
         test = cert_config.brg1_configure(test=test, cfg_pkt=receiver_cfg_pkt)[0]
         if test.rc == TEST_FAILED and test.exit_on_param_failure:
-            test.add_reason(f"Reciever BRG {rx_brg_.id_str} didn't received sub1g EP configuration!")
-            return terminate_test(test, phase=phase, revert_rx_brg=True,revert_tx_brg=True, modules=modules)
-        utPrint(f"Receiver BRG {rx_brg_.id_str} succesfully configured to desired sub1g EP", "GREEN")
+            test.add_reason(f"Receiver BRG {rx_brg_.id_str} didn't received sub1g EP configuration!")
+            return terminate_test(test, phase=phase, revert_rx_brg=True, revert_tx_brg=True, modules=modules)
+        utPrint(f"Receiver BRG {rx_brg_.id_str} successfully configured to desired sub1g EP", "GREEN")
 
         # configuring TX #
         # in sub1g must configure also the energy pattern
         utPrint(f"Configuring BRG {tx_brg_.id_str} as SUB1G Signal Indicator Transmitter\n", "BOLD")
         transmitter_cfg_pkt = WltPkt(hdr=DEFAULT_HDR, pkt=tx_module(seq_id=random.randrange(99), brg_mac=tx_brg_.id_int,
-                                        signal_indicator_cycle=tx_signal_ind_cycle, signal_indicator_rep=tx_signal_ind_rep, pattern=energy_pattern, duty_cycle=30))
+                                     signal_indicator_cycle=tx_signal_ind_cycle,
+                                     signal_indicator_rep=tx_signal_ind_rep, pattern=energy_pattern, duty_cycle=30))
         test = cert_config.brg_configure(test=test, cfg_pkt=transmitter_cfg_pkt)[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 terminate_test(test, phase=phase, revert_rx_brg=True,revert_tx_brg=True, modules=modules)
-        utPrint(f"BRG {tx_brg_.id_str} succesfully configured to be transmitter - cycle = {tx_signal_ind_cycle},"
+            return terminate_test(test, phase=phase, revert_rx_brg=True, revert_tx_brg=True, modules=modules)
+        utPrint(f"BRG {tx_brg_.id_str} successfully configured to be transmitter - cycle = {tx_signal_ind_cycle},"
                 f"repetition = {tx_signal_ind_rep}, pattern = {energy_pattern}", "GREEN")
 
         # phase analysis #
         mqtt_scan_n_create_log_file(test, (NUM_OF_SCANNING_CYCLE * tx_signal_ind_cycle) + SCAN_DELAY_TIME, phase)
         expected_signal_ind_pkts = NUM_OF_SCANNING_CYCLE
-        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) < expected_signal_ind_pkts:
-                test.rc = TEST_FAILED
-                test.add_reason(f"Phase {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")
-        field_functionality_pass_fail_print(test,'Energy pattern',energy_pattern)
+            test.rc = TEST_FAILED
+            test.add_reason(f"Phase {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")
+        field_functionality_pass_fail_print(test, 'Energy pattern', energy_pattern)
         if test.rc == TEST_FAILED:
-            return terminate_test(test, phase=phase, revert_rx_brg=True,revert_tx_brg=True, modules=modules)
-    field_functionality_pass_fail_print(test,'phase',phase)
+            return terminate_test(test, phase=phase, revert_rx_brg=True, revert_tx_brg=True, modules=modules)
+    field_functionality_pass_fail_print(test, 'phase', phase)
 
     phase = 2
     functionality_run_print(f"phase {phase}")
@@ -214,39 +204,40 @@ def run(test):
 
     # configuring RX BRG to default pattern #
     utPrint(f"Configuring BRG {rx_brg_.id_str} to default EP", "BOLD")
-    receiver_cfg_pkt = WltPkt(hdr=DEFAULT_HDR, pkt=tx_module(seq_id=random.randrange(99), brg_mac=rx_brg_.id_int, pattern=ag.SUB1G_ENERGY_PATTERN_ISRAEL, duty_cycle=30))
+    receiver_cfg_pkt = WltPkt(hdr=DEFAULT_HDR, pkt=tx_module(seq_id=random.randrange(99), brg_mac=rx_brg_.id_int,
+                                                             pattern=ag.SUB1G_ENERGY_PATTERN_ISRAEL, duty_cycle=30))
     test = cert_config.brg1_configure(test=test, cfg_pkt=receiver_cfg_pkt)[0]
     if test.rc == TEST_FAILED and test.exit_on_param_failure:
-        test.add_reason(f"Reciever BRG {rx_brg_.id_str} didn't revert to defualt sub1g EP!")
-        return terminate_test(test, phase=phase, revert_rx_brg=True,revert_tx_brg=True, modules=modules)
-    utPrint(f"Receiver BRG {rx_brg_.id_str} succesfully configured to desired sub1g EP", "GREEN")
+        test.add_reason(f"Receiver BRG {rx_brg_.id_str} didn't revert to default sub1g EP!")
+        return terminate_test(test, phase=phase, revert_rx_brg=True, revert_tx_brg=True, modules=modules)
+    utPrint(f"Receiver BRG {rx_brg_.id_str} successfully configured to desired sub1g EP", "GREEN")
 
     # configuring transmitter, SUB1G_ENERGY_PATTERN_ISRAEL is must here because this is the receiver freq #
     utPrint(f"Configuring BRG {tx_brg_.id_str} as Signal Indicator Transmitter\n", "BOLD")
     transmitter_cfg_pkt = WltPkt(hdr=DEFAULT_HDR, pkt=tx_module(seq_id=random.randrange(99), brg_mac=tx_brg_.id_int,
-                                    signal_indicator_cycle=tx_signal_ind_cycle, signal_indicator_rep=tx_signal_ind_rep,
-                                    pattern=ag.SUB1G_ENERGY_PATTERN_ISRAEL, duty_cycle=30))
+                                 signal_indicator_cycle=tx_signal_ind_cycle, signal_indicator_rep=tx_signal_ind_rep,
+                                 pattern=ag.SUB1G_ENERGY_PATTERN_ISRAEL, duty_cycle=30))
     test = cert_config.brg_configure(test=test, cfg_pkt=transmitter_cfg_pkt)[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 terminate_test(test, phase=phase, revert_rx_brg=True,revert_tx_brg=True, modules=modules)
-    utPrint(f"BRG {tx_brg_.id_str} succesfully configured to be transmitter - cycle = {tx_signal_ind_cycle},"
-              f"repetition = {tx_signal_ind_rep}, EP = {ag.SUB1G_ENERGY_PATTERN_ISRAEL}", "GREEN")
+        return terminate_test(test, phase=phase, revert_rx_brg=True, revert_tx_brg=True, modules=modules)
+    utPrint(f"BRG {tx_brg_.id_str} successfully configured to be transmitter - cycle = {tx_signal_ind_cycle},"
+            f"repetition = {tx_signal_ind_rep}, EP = {ag.SUB1G_ENERGY_PATTERN_ISRAEL}", "GREEN")
 
     # phase analysis #
-    mqtt_scan_n_create_log_file(test, (NUM_OF_SCANNING_CYCLE*tx_signal_ind_cycle) + SCAN_DELAY_TIME, phase)
+    mqtt_scan_n_create_log_file(test, (NUM_OF_SCANNING_CYCLE * tx_signal_ind_cycle) + SCAN_DELAY_TIME, phase)
     expected_signal_ind_pkts = NUM_OF_SCANNING_CYCLE
-    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 (not len(received_signal_ind_pkts) or
             len(received_signal_ind_pkts) < expected_signal_ind_pkts or
             len(received_signal_ind_pkts) > expected_signal_ind_pkts):
-            test.rc = TEST_FAILED
-            test.add_reason(f"Phase {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")
-    field_functionality_pass_fail_print(test,'phase',phase)
+        test.rc = TEST_FAILED
+        test.add_reason(f"Phase {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")
+    field_functionality_pass_fail_print(test, 'phase', phase)
     if test.rc == TEST_FAILED:
-        return terminate_test(test, phase=phase, revert_rx_brg=True,revert_tx_brg=True, modules=modules)
+        return terminate_test(test, phase=phase, revert_rx_brg=True, revert_tx_brg=True, modules=modules)
 
     phase = 3
     functionality_run_print(f"phase {phase}")
@@ -262,19 +253,18 @@ def run(test):
     test = cert_config.brg_configure(test=test, cfg_pkt=transmitter_cfg_pkt)[0]
     if test.rc == TEST_FAILED and test.exit_on_param_failure:
         test.add_reason(f"BRG {tx_brg_.id_str}: didn't revert to default (no signal indicator tx)!")
-        return terminate_test(test, phase=phase, revert_rx_brg=True,revert_tx_brg=True, modules=modules)
-    utPrint(f"BRG {tx_brg_.id_str} succesfully configured to default!!! cycle = {tx_signal_ind_cycle},"
-              f"repetition = {tx_signal_ind_rep}, EP = {ag.SUB1G_ENERGY_PATTERN_ISRAEL}", "GREEN")
+        return terminate_test(test, phase=phase, revert_rx_brg=True, revert_tx_brg=True, modules=modules)
+    utPrint(f"BRG {tx_brg_.id_str} successfully configured to default!!! cycle = {tx_signal_ind_cycle},"
+            f"repetition = {tx_signal_ind_rep}, EP = {ag.SUB1G_ENERGY_PATTERN_ISRAEL}", "GREEN")
 
     # phase analysis #
     mqtt_scan_n_create_log_file(test, DEFAULT_SCAN_TIME, phase)
     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) != expected_signal_ind_pkts:
-            test.rc = TEST_FAILED
-            test.add_reason(f"Phase {phase} failed - received signal indicator packet from BRG"
-                                   f"{rx_brg_.id_str}")
-    field_functionality_pass_fail_print(test,'phase',phase)
+        test.rc = TEST_FAILED
+        test.add_reason(f"Phase {phase} failed - received signal indicator packet from BRG {rx_brg_.id_str}")
+    field_functionality_pass_fail_print(test, 'phase', phase)
     if test.rc == TEST_FAILED:
         return terminate_test(test, phase=phase, revert_rx_brg=True, modules=modules)
 
@@ -283,76 +273,80 @@ def run(test):
         functionality_run_print(f"phase {phase}")
         # Phase 4 - Both BRG's will be configured to be transmitters and receivers, with different tx params for each one.
         # expecting to see signal indicator packets from both BRG's, according to the tx params.
-        utPrint(f"Both BRG's are transmitter and receivers, with different values\n", "HEADER")
+        utPrint("Both BRG's are transmitter and receivers, with different values\n", "HEADER")
 
         # configuring first BRG (tx_brg_) #
         tx_brg_signal_indicator_cycle, tx_brg_signal_indicator_rep = get_phase_tx_params_values(phase, TX_BRG_IDX)
         # 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 terminate_test(test, phase=phase, revert_rx_brg=True,revert_tx_brg=True, modules=modules)
+            return terminate_test(test, phase=phase, revert_rx_brg=True, revert_tx_brg=True, modules=modules)
         utPrint(f"BRG {tx_brg_.id_str} successfully configured as Signal Indicator Receiver\n", "GREEN")
         # configuring first brg (tx_brg_) as transmitter
         utPrint(f"Configuring BRG {tx_brg_.id_str} as Signal Indicator Transmitter", "BOLD")
         transmitter_cfg_pkt = WltPkt(hdr=DEFAULT_HDR, pkt=tx_module(seq_id=random.randrange(99), brg_mac=tx_brg_.id_int,
-                                        signal_indicator_cycle=tx_brg_signal_indicator_cycle, signal_indicator_rep=tx_brg_signal_indicator_rep,
-                                        pattern=ag.SUB1G_ENERGY_PATTERN_ISRAEL))
+                                     signal_indicator_cycle=tx_brg_signal_indicator_cycle,
+                                     signal_indicator_rep=tx_brg_signal_indicator_rep,
+                                     pattern=ag.SUB1G_ENERGY_PATTERN_ISRAEL))
         test = cert_config.brg_configure(test=test, cfg_pkt=transmitter_cfg_pkt)[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 terminate_test(test, phase=phase, revert_rx_brg=True,revert_tx_brg=True, modules=modules)
-        utPrint(f"BRG {tx_brg_.id_str} succesfully configured to be transmitter - cycle = {tx_brg_signal_indicator_cycle},"
-                  f"repetition = {tx_brg_signal_indicator_rep}, EP = {ag.SUB1G_ENERGY_PATTERN_ISRAEL}", "GREEN")
+            return terminate_test(test, phase=phase, revert_rx_brg=True, revert_tx_brg=True, modules=modules)
+        utPrint(f"BRG {tx_brg_.id_str} successfully configured to be transmitter - cycle = {tx_brg_signal_indicator_cycle},"
+                f"repetition = {tx_brg_signal_indicator_rep}, EP = {ag.SUB1G_ENERGY_PATTERN_ISRAEL}", "GREEN")
 
         # configuring second BRG (rx_brg_), already configured as rx, need only tx configuration #
         rx_brg_signal_indicator_cycle, rx_brg_signal_indicator_rep = get_phase_tx_params_values(phase, RX_BRG_IDX)
         # configuring second brg (rx_brg_) as transmitter
         utPrint(f"Configuring BRG {rx_brg_.id_str} as Signal Indicator Transmitter\n", "BOLD")
         transmitter_cfg_pkt = WltPkt(hdr=DEFAULT_HDR, pkt=tx_module(seq_id=random.randrange(99), brg_mac=rx_brg_.id_int,
-                                        signal_indicator_cycle=rx_brg_signal_indicator_cycle, signal_indicator_rep=rx_brg_signal_indicator_rep,
-                                        pattern=ag.SUB1G_ENERGY_PATTERN_ISRAEL))
+                                     signal_indicator_cycle=rx_brg_signal_indicator_cycle,
+                                     signal_indicator_rep=rx_brg_signal_indicator_rep,
+                                     pattern=ag.SUB1G_ENERGY_PATTERN_ISRAEL))
         test = cert_config.brg1_configure(test=test, cfg_pkt=transmitter_cfg_pkt)[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 terminate_test(test, phase=phase, revert_rx_brg=True,revert_tx_brg=True, modules=modules)
-        utPrint(f"BRG {rx_brg_.id_str} succesfully configured to be transmitter - cycle = {rx_brg_signal_indicator_cycle},"
-                  f"repetition = {rx_brg_signal_indicator_rep}, EP = {ag.SUB1G_ENERGY_PATTERN_ISRAEL}", "GREEN")
+            return terminate_test(test, phase=phase, revert_rx_brg=True, revert_tx_brg=True, modules=modules)
+        utPrint(f"BRG {rx_brg_.id_str} successfully configured to be transmitter - cycle = {rx_brg_signal_indicator_cycle},"
+                f"repetition = {rx_brg_signal_indicator_rep}, EP = {ag.SUB1G_ENERGY_PATTERN_ISRAEL}", "GREEN")
 
         # phase analysis #
-        mqtt_scan_n_create_log_file(test, NUM_OF_SCANNING_CYCLE * max(tx_brg_signal_indicator_cycle, rx_brg_signal_indicator_cycle) + SCAN_DELAY_TIME, phase)
+        duration = NUM_OF_SCANNING_CYCLE * max(tx_brg_signal_indicator_cycle, rx_brg_signal_indicator_cycle) + SCAN_DELAY_TIME
+        mqtt_scan_n_create_log_file(test, duration, phase)
 
-        # Analysing tx_brg_ performance as receiver
+        # Analyzing tx_brg_ performance as receiver
         rx_brg_tx_cycles = max(tx_brg_signal_indicator_cycle, rx_brg_signal_indicator_cycle) / rx_brg_signal_indicator_cycle
         expected_signal_ind_pkts = int(NUM_OF_SCANNING_CYCLE * rx_brg_tx_cycles)
-        received_signal_ind_pkts = get_all_signal_ind_pkt(test=test, rx_brg=tx_brg_, tx_brg=rx_brg_)
+        received_signal_ind_pkts = cert_common.get_all_sig_ind_pkts(test=test, rx_brg=tx_brg_, tx_brg=rx_brg_)
         if (not len(received_signal_ind_pkts) or
                 len(received_signal_ind_pkts) < expected_signal_ind_pkts or
                 len(received_signal_ind_pkts) > expected_signal_ind_pkts):
-                test.rc = TEST_FAILED
-                test.add_reason(f"Phase {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")
+            test.rc = TEST_FAILED
+            test.add_reason(f"Phase {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")
         if test.rc == TEST_FAILED:
-            field_functionality_pass_fail_print(test,'phase',phase)
-            return terminate_test(test, phase=phase, revert_rx_brg=True,revert_tx_brg=True, modules=modules)
+            field_functionality_pass_fail_print(test, 'phase', phase)
+            return terminate_test(test, phase=phase, revert_rx_brg=True, revert_tx_brg=True, modules=modules)
 
-        # Analysing rx_brg_ performance as receiver
+        # Analyzing rx_brg_ performance as receiver
         tx_brg_tx_cycles = max(tx_brg_signal_indicator_cycle, rx_brg_signal_indicator_cycle) / tx_brg_signal_indicator_cycle
         expected_signal_ind_pkts = int(NUM_OF_SCANNING_CYCLE * tx_brg_tx_cycles)
-        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 (not len(received_signal_ind_pkts) or
                 len(received_signal_ind_pkts) < expected_signal_ind_pkts or
                 len(received_signal_ind_pkts) > expected_signal_ind_pkts):
-                test.rc = TEST_FAILED
-                test.add_reason(f"Phase {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.rc = TEST_FAILED
+            test.add_reason(f"Phase {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")
         if test.rc == TEST_FAILED:
-            field_functionality_pass_fail_print(test,'phase',phase)
-            return terminate_test(test, phase=phase, revert_rx_brg=True,revert_tx_brg=True, modules=modules)
-        field_functionality_pass_fail_print(test,'phase',phase)
+            field_functionality_pass_fail_print(test, 'phase', phase)
+            return terminate_test(test, phase=phase, revert_rx_brg=True, revert_tx_brg=True, modules=modules)
+        field_functionality_pass_fail_print(test, 'phase', phase)
 
     phase = 5 if not test.internal_brg else 4
     functionality_run_print(f"phase {phase}")
@@ -367,31 +361,30 @@ def run(test):
     test = cert_config.config_brg1_defaults(test, modules=modules)[0]
     if test.rc == TEST_FAILED and test.exit_on_param_failure:
         test.add_reason(f"BRG {rx_brg_.id_str}: didn't revert to default configuration!")
-        return terminate_test(test, phase=phase, revert_rx_brg=True,revert_tx_brg=True, modules=modules)
+        return terminate_test(test, phase=phase, revert_rx_brg=True, revert_tx_brg=True, modules=modules)
 
     # configuring transmitter #
     utPrint(f"Configuring BRG {tx_brg_.id_str} as Signal Indicator Transmitter", "BOLD")
     transmitter_cfg_pkt = WltPkt(hdr=DEFAULT_HDR, pkt=tx_module(seq_id=random.randrange(99), brg_mac=tx_brg_.id_int,
-                                    signal_indicator_cycle=tx_signal_ind_cycle, signal_indicator_rep=tx_signal_ind_rep,
-                                    pattern=ag.SUB1G_ENERGY_PATTERN_ISRAEL))
+                                 signal_indicator_cycle=tx_signal_ind_cycle, signal_indicator_rep=tx_signal_ind_rep,
+                                 pattern=ag.SUB1G_ENERGY_PATTERN_ISRAEL))
     test = cert_config.brg_configure(test=test, cfg_pkt=transmitter_cfg_pkt)[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 terminate_test(test, phase=phase, revert_tx_brg=True, modules=modules)
-    utPrint(f"BRG {tx_brg_.id_str} succesfully configured to be transmitter - cycle = {tx_signal_ind_cycle},"
-                  f"repetition = {tx_signal_ind_rep}, EP = {ag.SUB1G_ENERGY_PATTERN_ISRAEL}", "GREEN")
+    utPrint(f"BRG {tx_brg_.id_str} successfully configured to be transmitter - cycle = {tx_signal_ind_cycle},"
+            f"repetition = {tx_signal_ind_rep}, EP = {ag.SUB1G_ENERGY_PATTERN_ISRAEL}", "GREEN")
 
     # phase analysis #
-    mqtt_scan_n_create_log_file(test, (NUM_OF_SCANNING_CYCLE*tx_signal_ind_cycle) + SCAN_DELAY_TIME, phase)
+    mqtt_scan_n_create_log_file(test, (NUM_OF_SCANNING_CYCLE * tx_signal_ind_cycle) + SCAN_DELAY_TIME, phase)
     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) != expected_signal_ind_pkts:
-            test.rc = TEST_FAILED
-            test.add_reason(f"Phase {phase} failed - received signal indicator packet from BRG"
-                                   f"{rx_brg_.id_str}")
-    field_functionality_pass_fail_print(test,'phase',phase)
+        test.rc = TEST_FAILED
+        test.add_reason(f"Phase {phase} failed - received signal indicator packet from BRG {rx_brg_.id_str}")
+    field_functionality_pass_fail_print(test, 'phase', phase)
     if test.rc == TEST_FAILED:
-        return terminate_test(test, phase=phase, revert_rx_brg=False,revert_tx_brg=True, modules=modules)
+        return terminate_test(test, phase=phase, revert_rx_brg=False, revert_tx_brg=True, modules=modules)
 
     # Test epilog
-    return terminate_test(test, phase=phase, revert_rx_brg=False,revert_tx_brg=True, modules=modules)
+    return terminate_test(test, phase=phase, revert_rx_brg=False, revert_tx_brg=True, modules=modules)

brg_certificate/tests/energy_sub1g/signal_indicator_test/signal_indicator_test.json

@@ -1,13 +1,16 @@
 {
-    "name": "signal_indicator_test",
-    "module": "energy_sub1g",
+    "name": "Signal Indicator Configuration",
+    "module": "Energizer Sub-1GHz",
     "purpose": "Test configuration for supported energy_sub1g signal indicator cycle & repetitions sets of values",
-    "documentaion": "<TEST_DOCUMENTATION_LINK>",
+    "documentation": "https://community.wiliot.com/customers/s/article/Wiliot-Network-Sub1-Ghz-Energizer-module",
     "initialCondition": "Bridge configured to defaults",
-    "procedure": ["Test prolog", "Configurations", "Test epilog and revert to defaults"],
+    "procedure": ["Test prolog",
+                  "For each supported value - configure the BRG and verify the value",
+                  "Test epilog and revert to defaults"],
     "expectedOutcome": "All values configured successfully",
     "mandatory": 1,
     "multiBridgeTest": 0,
     "gwOnlyTest": 0,
+    "internalBridge": 1,
     "allSupportedValues": [[60,4], [100,3]]
 }

brg_certificate/tests/energy_sub1g/signal_indicator_test/signal_indicator_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_SIGNAL_INDICATOR_CYCLE, BRG_SIGNAL_INDICATOR_REP]
@@ -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/pwr_mgmt/pwr_mgmt_test/pwr_mgmt_test.json

@@ -0,0 +1,18 @@
+{
+    "name": "Power Management",
+    "module": "Power Management",
+    "purpose": "Validate the bridge power management functionality",
+    "documentation": "https://community.wiliot.com/customers/s/article/Bridge-Power-Management",
+    "initialCondition": "Bridge configured to defaults",
+    "procedure": ["Test prolog",
+                  "Configure power management static mode - on_duration= 30 [sec] ,sleep_duration= 60 [sec], keep_alive_period= 20 [sec]",
+                  "Verify bridge sent appropriate amount of HB_Sleep_pkts",
+                  "Turn off power management mode",
+                  "Test epilog"],
+    "expectedOutcome": "The bridge sent the expected amount of HB_Sleep_pkts",
+    "mandatory": 0,
+    "multiBridgeTest": 0,
+    "gwOnlyTest": 0,
+    "internalBridge": 1,
+    "allSupportedValues": []
+}

brg_certificate/tests/pwr_mgmt/pwr_mgmt_test/pwr_mgmt_test.py

@@ -0,0 +1,84 @@
+from brg_certificate.cert_prints import *
+from brg_certificate.cert_defines import *
+from brg_certificate.wlt_types import *
+import brg_certificate.cert_common as cert_common
+import brg_certificate.cert_mqtt as cert_mqtt
+
+# Test MACROS #
+SEC_TO_MS = 1000
+LOW_VALUE_IDX = 0
+HIGH_VALUE_IDX = -1
+STATIC_MODE = 0
+
+
+# Test Functions #
+def num_to_str(id):
+    return str(id).zfill(2)
+
+
+def get_expected_hb_sleep_msgs_count(pkt):
+    # sent cfg is static_sleep_duration = 60, static_keep_alive_period = 20
+    periods_ratio = int(pkt.static_sleep_duration / pkt.static_keep_alive_period)
+    if not (pkt.static_sleep_duration % pkt.static_keep_alive_period):
+        return [periods_ratio - 1, periods_ratio]
+    else:
+        return [periods_ratio, periods_ratio + 1]
+
+
+def get_hb_sleep_pkts(test, start_ts, end_ts):
+    mgmt_pkts_found = cert_mqtt.get_brg2gw_mgmt_pkts(test.mqttc, test)
+    # Screen pkts according to ts
+    mgmt_pkts = [p for p in mgmt_pkts_found if (start_ts <= p[TIMESTAMP] and p[TIMESTAMP] <= end_ts)]
+    # return count of HbSleep pkts
+    return len([p for p in mgmt_pkts if isinstance(p[MGMT_PKT].pkt, eval_pkt(f'Brg2GwHbSleepV{test.active_brg.api_version}'))])
+
+
+def brg_pwr_mgmt_sleep_state_analysis(test, wltpkt, start_ts, end_ts):
+    utPrint("Analyzing HB Sleep pkts count", "HEADER")
+    hb_sleep_pkts = get_hb_sleep_pkts(test, start_ts, end_ts)
+    exp_hb_sleep_msgs = get_expected_hb_sleep_msgs_count(wltpkt.pkt)
+
+    if (not hb_sleep_pkts or
+            hb_sleep_pkts < exp_hb_sleep_msgs[LOW_VALUE_IDX] or
+            hb_sleep_pkts > exp_hb_sleep_msgs[HIGH_VALUE_IDX]):
+        test.rc = TEST_FAILED
+        test.add_reason(f"Didn't received expected number of HB_SLEEP pkts during sleep state, "
+                        f"Found {hb_sleep_pkts} Expected {exp_hb_sleep_msgs[LOW_VALUE_IDX]}-{exp_hb_sleep_msgs[HIGH_VALUE_IDX]}")
+    else:
+        utPrint(f"Success! found {hb_sleep_pkts} HB_SLEEP pkts "
+                f"(expected {exp_hb_sleep_msgs[LOW_VALUE_IDX]}-{exp_hb_sleep_msgs[HIGH_VALUE_IDX]})", "BLUE")
+
+    return test
+
+
+def run(test):
+
+    test = cert_common.test_prolog(test)
+    if test.rc == TEST_FAILED:
+        return cert_common.test_epilog(test)
+
+    # Turn on pwr mgmt static mode - 30 sec on, 60 sec sleep
+    test, wltpkt = cert_common.brg_pwr_mgmt_turn_on(test)
+    if test.rc == TEST_FAILED:
+        # Need to turn off just in case the ON was successful but didn't receive the ack packet
+        test = cert_common.brg_pwr_mgmt_turn_off(test)
+        cert_mqtt.dump_pkts(test, log=test.module_name)
+        return cert_common.test_epilog(test, revert_brgs=True, modules=[eval_pkt(f'ModulePwrMgmtV{test.active_brg.api_version}')])
+
+    # On duration starts
+    utPrint(f"On duration started - Waiting for {int(wltpkt.pkt.static_on_duration)} seconds!", "WARNING")
+    cert_common.wait_time_n_print(wltpkt.pkt.static_on_duration)
+    utPrint(f"On duration expired - Entering sleep state for {int(wltpkt.pkt.static_sleep_duration)} seconds!", "BLUE")
+    # Sleep duration starts
+    sleep_state_start_ts = int(datetime.datetime.now().timestamp() * SEC_TO_MS)
+    test.mqttc.flush_pkts()
+    cert_common.wait_time_n_print(wltpkt.pkt.static_sleep_duration)
+    sleep_state_end_ts = int(datetime.datetime.now().timestamp() * SEC_TO_MS)
+    utPrint(f"Sleep duration expired - Returning to on state for {int(wltpkt.pkt.static_on_duration)} seconds!", "BLUE")
+
+    # Sleep state analysis - check for SLEEP_HB packet
+    test = brg_pwr_mgmt_sleep_state_analysis(test, wltpkt, sleep_state_start_ts, sleep_state_end_ts)
+    test = cert_common.brg_pwr_mgmt_turn_off(test)
+
+    cert_mqtt.dump_pkts(test, log=test.module_name)
+    return cert_common.test_epilog(test, revert_brgs=True, modules=[eval_pkt(f'ModulePwrMgmtV{test.active_brg.api_version}')])

brg_certificate/tests/sensors/ext_sensor_test/ext_sensor_test.json

@@ -0,0 +1,21 @@
+{
+    "name": "External Sensors",
+    "module": "BLE Sensor",
+    "purpose": "Verify the external_sensor module functionality - configuration, data collection and data transmission.",
+    "documentation": "<TEST_DOCUMENTATION_LINK>",
+    "initialCondition": "Bridge configured to defaults",
+    "procedure": ["Test prolog",
+    "tag_data_only - No external sensor configured, only tag data is expected.",
+    "rssi_threshold - One external sensor with no scrambling is configured and rssi threshold is set to -25. We expect to receive sensor packets only from the registered sensor & with rssi value between 0 to -25.",
+    "snsr0_no_scrmbl - One external sensor with no scrambling is configured and no rssi threshold is set. We expect to receive unscrambled sensor packets only from the registered sensor, with no rssi limitations.",
+    "snsr1_scrmbl - One external sensor with scrambling is configured with and no rssi threshold is set. We expect to receive scrambled sensor packets only from the registered sensor, with no rssi limitations.",
+    "snsr0_scrmbl_snsr1_no_scrmbl - Two external sensors are configured -  one with scrambling and one without. No rssi threshold is set. We expect to receive sensor packets from both sensors, with the first sensor's data scrambled and the second sensor's data unscrambled.",
+    "snsr0_scrmbl_snsr1_scrmbl - Two external sensors are configured -  both with scrambling. No rssi threshold is set. We expect to receive sensor packets from both sensors, with both sensors' data scrambled.",
+    "Test epilog"],
+    "expectedOutcome": "All phases passed successfully!",
+    "mandatory": 0,
+    "multiBridgeTest": 0,
+    "gwOnlyTest": 0,
+    "internalBridge": 1,
+    "allSupportedValues": ["tag_data_only", "rssi_threshold", "snsr0_no_scrmbl", "snsr1_scrmbl", "snsr0_scrmbl_snsr1_no_scrmbl", "snsr0_scrmbl_snsr1_scrmbl"]
+}