wiliot-certificate 1.5.3a1__py3-none-any.whl → 4.4.0a1__py3-none-any.whl

brg_certificate/tests/datapath/rx_rate_gen3_test/rx_rate_gen3_test.py

@@ -11,7 +11,7 @@ import time
 def cal_scan_time(test, delay, pacer_interval):
     # Calculate the scan time to ensure at least 5 packets are captured in data scan
     # define the num of packet that you want to get
-    num_of_sending_pkt = 3  # actually it will be 3 because the first one always send
+    num_of_sending_pkt = 2  # actually it will be 3 because the first one always send
     delay = delay / 1000
     if delay < pacer_interval:
         scan_time = (pacer_interval * num_of_sending_pkt) + 10
@@ -34,8 +34,8 @@ def scan_and_compare(test, pacer_interval, delay, expected_address_value):
     pixel_sim_thread.stop()
     cert_mqtt.dump_pkts(test, log="rx_rate")
     cert_common.display_data(df, tbc=True, nfpkt=True, rssi=True, dir=test.dir)
-
-    if df.empty:
+    # check if the dataframe is empty or not
+    if len(df) <= 1:
         print("Df is empty")
         test.rc = TEST_FAILED
         test.add_reason("Df is empty")
@@ -48,11 +48,16 @@ def scan_and_compare(test, pacer_interval, delay, expected_address_value):
         print(f"Most common tag: {most_common_tag}")
         df = df[df[TAG_ID] == most_common_tag]
         df = df[[TAG_ID, TBC, PACKET_TYPE, DATETIME]]
+        length = len(df)
+        mid_index = int(length // 2)
+        if mid_index == 0:
+            mid_index = 1
+        print(f"Length of df: {length}, mid index: {mid_index}")
         print(f"df:\n {df}")
 
         tag = df.iloc[0][TAG_ID]
         # iloc [1:] to skip the first value of tbc_values which could be 0 sometimes.
-        actual_address_value = round(df.iloc[1:][TBC].mean(), 2)  # extract the tbc value from df
+        actual_address_value = round(df.iloc[mid_index:][TBC].mean(), 2)  # extract the tbc value from df
         print(f"\nactual address value: {actual_address_value}\nexpected address value: {expected_address_value}")
         THRESHOLD_ADDRESS_VALUE = 5
         # check if the actual address value is in the range of -+5 of the expected address value
@@ -128,29 +133,28 @@ def max_value(test, datapath_module):
 def diff_rate(test, datapath_module):
     # diff rate - a filter: Generate packets with delay 1 and change to 5, according the delay change test the tolerance address value
     pacer_interval = 1
-    delay = {500: 5, 3000: 30}  # key=delay and value = the duration it will be activated
-    first_delay = list(delay.keys())[0]
-    first_duration = list(delay.values())[0]
-    second_delay = list(delay.keys())[1]
-
+    delay_duration = [[500, 5], [3000, 3]]
+    first_delay = delay_duration[0][0]
+    first_duration = delay_duration[0][1]
+    second_delay = delay_duration[1][0]
     test = cert_config.brg_configure(test, fields=[BRG_PACER_INTERVAL], values=[pacer_interval], module=datapath_module)[0]
     if test.rc == TEST_FAILED:
         test.add_reason(f"Didn't succeed to config pacer interval {pacer_interval}")
         return test
-    pixel_sim_thread = cert_data_sim.DataSimThread(test=test, num_of_pixels=1, duplicates=3,
+    pixel_sim_thread = cert_data_sim.DataSimThread(test=test, num_of_pixels=1, duplicates=2,
                                                    delay=first_delay, pkt_types=[0], pixels_type=GEN3)
     pixel_sim_thread.start()
     time_sleep = first_duration - ((first_delay / 1000) / 2)
     print(f"sleep for {time_sleep} sec\n")
     time.sleep(time_sleep)
     pixel_sim_thread.delay = second_delay
-    print(f"changing delay value to {second_delay}\n")
-    scan_time = sum(delay.values()) + 20
+    scan_time = sum(duration for _, duration in delay_duration) + 20
     df = cert_common.data_scan(test, scan_time=scan_time, brg_data=(not test.internal_brg), gw_data=test.internal_brg)
     pixel_sim_thread.stop()
     df = df[[TAG_ID, TBC]]
+    lenght = len(df)
 
-    if df.empty:
+    if len(df) <= 1:
         test.add_reason("Df is empty")
         test.rc = TEST_FAILED
         return test
@@ -158,35 +162,27 @@ def diff_rate(test, datapath_module):
         print(f"Df:\n {df}")
     # NOTE: all next rows are specific for the values: delay 0.5 and 3, and in relation address values 128 and 235
     # check if the last tbc value is as we expected  for delay 3 sec we need to get 235 according to LUT  table
-    # we define tolerance of +-2 units for address value
+    # we define tolerance of +-10 units for address value
+
+    # Most important check, verify it converges to the correct value
     if df.iloc[-1][TBC] not in range(232, 237):
         test.rc = TEST_FAILED
         test.add_reason(f"TBC value: {df.iloc[-1][TBC]}, expected value [232,236]")
         print(f"TBC value: {df.iloc[-1][TBC]}, expected value [232,236] according to delay:{second_delay / 1000} sec")
-    # skip the first packet in case the second one is still from the last delay value
-    index = 0
-    if df.iloc[1][TBC] in range(232, 237):
-        index = 1
-
-    # verify the first tbc value
-    first_tbc = df.iloc[index][TBC]
-    if first_tbc not in range(120, 145):
-        test.rc = TEST_FAILED
-        test.add_reason(f"TBC value: {first_tbc}, expected value [120,144]")
-        print(f"TBC value of last packet before the delay change is wrong\n"
-              f"TBC value: {first_tbc}, expected value [120,144] according to delay:{first_delay / 1000} sec")
-
-    # check the first change of tbc value after delay changing which is verify the calculation of alpha filter
-    second_tbc = df.iloc[index + 1][TBC]
-    expected_address_value = 200
-    # 4 is equal to 0.09 sec error
-    threshold = 4  # 2 equal to 0.04 sec error
-    if not expected_address_value - threshold <= second_tbc <= expected_address_value + threshold:
+        return test
+    # for loop that skip the first row and check if somewhere there is the expected gap 130 to 200
+    result = False
+    for i in range(0, lenght - 1):
+        prev = df.iloc[i][TBC]
+        current = df.iloc[i + 1][TBC]
+        if prev in range(120, 140) and current in range(190, 210):
+            print(f"Found the gap between {prev} and {current}")
+            print(f"row {i}: {df.iloc[i][TBC]}")
+            print(f"row {i + 1}: {df.iloc[i + 1][TBC]}")
+            result = True
+    if not result:
         test.rc = TEST_FAILED
-        test.add_reason(f"TBC value: {second_tbc}, expected value [196,204]")
-        print(f"first change of address value is wrong.\n"
-              f"alpha filter probably is not define well\n"
-              f"TBC value: {second_tbc}, expected value [196,204]")
+        test.add_reason("Didn't find the correct gap according to alpha filter calculation")
     return test
 
 
@@ -201,7 +197,7 @@ def run(test):
     test = cert_config.brg_configure(test, fields=[BRG_PACER_INTERVAL], values=[pacer_interval], module=datapath_module)[0]
     if test.rc == TEST_FAILED:
         test.add_reason(f"Didn't succeed to config pacer interval {pacer_interval}")
-        return test
+        return cert_common.test_epilog(test)
 
     RX_RATE_TEST_MAP = {"mid_values": mid_values, "diff_pacer": diff_pacer, "min_value": min_value,
                         "max_value": max_value, "diff_rate": diff_rate}
@@ -212,9 +208,10 @@ def run(test):
         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.rc == TEST_FAILED and test.exit_on_param_failure:
-            break
-        else:
-            test.reset_result()
-
+        if test.rc == TEST_FAILED:
+            if test.exit_on_param_failure:
+                break  # break the whole for loop and keep the test as failed
+            else:
+                test.reset_result()  # reset result and continue to next param
+                continue
     return cert_common.test_epilog(test)

brg_certificate/tests/datapath/stress_gen3_test/stress_gen3_test.json

@@ -11,12 +11,11 @@
                   "rep 3 - config pacer interval 22, then check repetition value = 3, pacer increment = 0, num of tags = all tags",
                   "rep 2 - config pacer interval 12, then check repetition value = 2, pacer increment = 0, num of tags = all tags",
                   "rep 1 - config pacer interval 7, then check repetition value = 1, pacer increment = 0, num of tags = all tags",
-                  "rep 1 adaptive pacer - config pacer interval 1, then check repetition value = 1, pacer increment = 3 , num of tags = all tags",
                   "Test epilog"],
     "expectedOutcome": "all metrics values will be as expected then the bridge is working correctly and the algorithms are working correctly",
     "mandatory": 1,
     "multiBridgeTest": 0,
     "gwOnlyTest": 0,
     "internalBridge": 0,
-    "allSupportedValues": ["rep3", "rep2", "rep1", "rep1_adaptive_pacer"]
+    "allSupportedValues": ["rep3", "rep2", "rep1"]
 }

brg_certificate/tests/datapath/stress_gen3_test/stress_gen3_test.py

@@ -172,10 +172,7 @@ def run(test):
     # config GW deduplication pkts = 0
     print("Configuring GW with !deduplication_pkts 0")
     cert_config.gw_action(test, f"{DEDUPLICATION_PKTS} 0")
-    if test.rc == TEST_FAILED and test.exit_on_param_failure:
-        return cert_common.test_epilog(test, revert_gws=True)
-
-    STRESS_TEST_MAP = {"rep3": rep3, "rep2": rep2, "rep1": rep1, "rep1_adaptive_pacer": rep1_adaptive_pacer}
+    STRESS_TEST_MAP = {"rep3": rep3, "rep2": rep2, "rep1": rep1}
     num_of_pixels = 300
     pixel_sim_thread = cert_data_sim.DataSimThread(test=test,
                                                    num_of_pixels=num_of_pixels,
@@ -192,10 +189,11 @@ def run(test):
         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.rc == TEST_FAILED and test.exit_on_param_failure:
-            break
-        else:
-            test.reset_result()
+        if test.rc == TEST_FAILED:
+            if test.exit_on_param_failure:
+                break
+            else:
+                test.reset_result()
         time.sleep(5)
     pixel_sim_thread.stop()
     # Re-enable unified packets deduplication

brg_certificate/tests/datapath/stress_test/stress_test.json

@@ -11,12 +11,11 @@
                   "rep 3 - config pacer interval 22, then check repetition value = 3, pacer increment = 0, num of tags = all tags",
                   "rep 2 - config pacer interval 12, then check repetition value = 2, pacer increment = 0, num of tags = all tags",
                   "rep 1 - config pacer interval 7, then check repetition value = 1, pacer increment = 0, num of tags = all tags",
-                  "rep 1 adaptive pacer - config pacer interval 1, then check repetition value = 1, pacer increment = 3 , num of tags = all tags",
                   "Test epilog"],
     "expectedOutcome": "all metrics values will be as expected then the bridge is working correctly and the algorithms are working correctly",
     "mandatory": 1,
     "multiBridgeTest": 0,
     "gwOnlyTest": 0,
     "internalBridge": 0,
-    "allSupportedValues": ["rep3", "rep2", "rep1", "rep1_adaptive_pacer"]
+    "allSupportedValues": ["rep3", "rep2", "rep1"]
 }

brg_certificate/tests/datapath/stress_test/stress_test.py

@@ -96,7 +96,7 @@ def combination_func(test, param, datapath_module, pacer_interval, num_of_sim_ta
             test = metric_checking_HB(test, check, hbs, tx_queue_expected, pacer_increment_expected)
             return test
         else:
-            # in case it failed because the repetition value.
+            # in case it failed because the repetition value. the reason has been added in the metric_checking_df function
             return test
 
     time.sleep(30)
@@ -172,10 +172,7 @@ def run(test):
     # config GW deduplication pkts = 0
     print("Configuring GW with !deduplication_pkts 0")
     cert_config.gw_action(test, f"{DEDUPLICATION_PKTS} 0")
-    if test.rc == TEST_FAILED and test.exit_on_param_failure:
-        return cert_common.test_epilog(test, revert_gws=True)
-
-    STRESS_TEST_MAP = {"rep3": rep3, "rep2": rep2, "rep1": rep1, "rep1_adaptive_pacer": rep1_adaptive_pacer}
+    STRESS_TEST_MAP = {"rep3": rep3, "rep2": rep2, "rep1": rep1}
     num_of_pixels = 300
     pixel_sim_thread = cert_data_sim.DataSimThread(test=test,
                                                    num_of_pixels=num_of_pixels,
@@ -192,10 +189,11 @@ def run(test):
         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.rc == TEST_FAILED and test.exit_on_param_failure:
-            break
-        else:
-            test.reset_result()
+        if test.rc == TEST_FAILED:
+            if test.exit_on_param_failure:
+                break
+            else:
+                test.reset_result()
         time.sleep(5)
     pixel_sim_thread.stop()
     # Re-enable unified packets deduplication

brg_certificate/tests/datapath/tx_repetition_test/tx_repetition_test.py

@@ -58,24 +58,27 @@ def run(test):
 
     print("Configuring GW with !deduplication_pkts 0")
     cert_config.gw_action(test, f"{DEDUPLICATION_PKTS} 0")
-    if test.rc == TEST_FAILED and test.exit_on_param_failure:
-        return cert_common.test_epilog(test, revert_gws=True)
 
     for param in test.params:
         test = cert_config.brg_configure(test, fields=fields,
                                          values=[param.value, ag.PKT_FILTER_RANDOM_FIRST_ARRIVING_PKT, ag.RX_CHANNEL_37],
                                          module=datapath_module)[0]
-        if test.rc == TEST_FAILED and test.exit_on_param_failure:
-            break
+        if test.rc == TEST_FAILED:
+            if test.exit_on_param_failure:
+                break  # break the whole for loop and keep the test as failed
+            else:
+                test.reset_result()   # reset result and continue to next param
+                continue
         tx_repetitions_analysis(test, param.name)
         field_functionality_pass_fail_print(test, fields[0], value=param.name)
         test.set_phase_rc(param.name, test.rc)
         test.add_phase_reason(param.name, test.reason)
-        if test.rc == TEST_FAILED and test.exit_on_param_failure:
-            break
-        else:
-            test.reset_result()
-
+        if test.rc == TEST_FAILED:
+            if test.exit_on_param_failure:
+                break  # break the whole for loop and keep the test as failed
+            else:
+                test.reset_result()   # reset result and continue to next param
+                continue
     # Re-enable unified packets deduplication
     cert_config.gw_action(test, f"{DEDUPLICATION_PKTS} 1")
-    return cert_common.test_epilog(test, revert_brgs=True, revert_gws=True, modules=[datapath_module])
+    return cert_common.test_epilog(test, revert_brgs=True, modules=[datapath_module])

brg_certificate/tests/edge_mgmt/actions_test/actions_test.py

@@ -388,9 +388,11 @@ def run(test):
         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.rc == TEST_FAILED and test.exit_on_param_failure:
-            break
-        else:
-            test.reset_result()
+        if test.rc == TEST_FAILED:
+            if test.exit_on_param_failure:
+                break  # break the whole for loop and keep the test as failed
+            else:
+                test.reset_result()  # reset result and continue to next param
+                continue
 
     return cert_common.test_epilog(test)

brg_certificate/tests/energy2400/duty_cycle_test/duty_cycle_test.py

@@ -19,9 +19,11 @@ def run(test):
         field_functionality_pass_fail_print(test, fields[0], value=param.name)
         test.set_phase_rc(param.name, test.rc)
         test.add_phase_reason(param.name, test.reason)
-        if test.rc == TEST_FAILED and test.exit_on_param_failure:
-            break
-        else:
-            test.reset_result()
+        if test.rc == TEST_FAILED:
+            if test.exit_on_param_failure:
+                break  # break the whole for loop and keep the test as failed
+            else:
+                test.reset_result()  # reset result and continue to next param
+                continue
 
     return cert_common.test_epilog(test, revert_brgs=True, modules=[energy2400_module])

brg_certificate/tests/energy2400/output_power_test/output_power_test.py

@@ -20,9 +20,11 @@ def run(test):
         field_functionality_pass_fail_print(test, fields[0], value=param.name)
         test.set_phase_rc(param.name, test.rc)
         test.add_phase_reason(param.name, test.reason)
-        if test.rc == TEST_FAILED and test.exit_on_param_failure:
-            break
-        else:
-            test.reset_result()
+        if test.rc == TEST_FAILED:
+            if test.exit_on_param_failure:
+                break  # break the whole for loop and keep the test as failed
+            else:
+                test.reset_result()  # reset result and continue to next param
+                continue
 
     return cert_common.test_epilog(test, revert_brgs=True, modules=[energy2400_module])

brg_certificate/tests/energy2400/pattern_test/pattern_test.py

@@ -21,9 +21,11 @@ def run(test):
         field_functionality_pass_fail_print(test, fields[0], value=param.name)
         test.set_phase_rc(param.name, test.rc)
         test.add_phase_reason(param.name, test.reason)
-        if test.rc == TEST_FAILED and test.exit_on_param_failure:
-            break
-        else:
-            test.reset_result()
+        if test.rc == TEST_FAILED:
+            if test.exit_on_param_failure:
+                break  # break the whole for loop and keep the test as failed
+            else:
+                test.reset_result()  # reset result and continue to next param
+                continue
 
     return cert_common.test_epilog(test, revert_brgs=True, modules=[energy2400_module])

brg_certificate/tests/energy2400/signal_indicator_test/signal_indicator_test.py

@@ -249,10 +249,12 @@ def run(test):
         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.rc == TEST_FAILED and test.exit_on_param_failure:
-            break
-        else:
-            test.reset_result()
+        if test.rc == TEST_FAILED:
+            if test.exit_on_param_failure:
+                break  # break the whole for loop and keep the test as failed
+            else:
+                test.reset_result()  # reset result and continue to next param
+                continue
 
         # Reset to defaults after every phase (don't fail the phase on that)
         test = cert_config.config_brg_defaults(test, modules=[test.brg0.energy2400, test.brg0.sensors])[0]

brg_certificate/tests/energy_sub1g/duty_cycle_test/duty_cycle_test.py

@@ -20,9 +20,10 @@ def run(test):
         field_functionality_pass_fail_print(test, fields, value=param_name)
         test.set_phase_rc(param.name, test.rc)
         test.add_phase_reason(param.name, test.reason)
-        if test.rc == TEST_FAILED and test.exit_on_param_failure:
-            break
-        else:
-            test.reset_result()
-
+        if test.rc == TEST_FAILED:
+            if test.exit_on_param_failure:
+                break  # break the whole for loop and keep the test as failed
+            else:
+                test.reset_result()  # reset result and continue to next param
+                continue
     return cert_common.test_epilog(test, revert_brgs=True, modules=[sub1g_module])

brg_certificate/tests/energy_sub1g/pattern_test/pattern_test.py

@@ -19,9 +19,11 @@ def run(test):
         field_functionality_pass_fail_print(test, fields, value=param.name)
         test.set_phase_rc(param.name, test.rc)
         test.add_phase_reason(param.name, test.reason)
-        if test.rc == TEST_FAILED and test.exit_on_param_failure:
-            break
-        else:
-            test.reset_result()
+        if test.rc == TEST_FAILED:
+            if test.exit_on_param_failure:
+                break  # break the whole for loop and keep the test as failed
+            else:
+                test.reset_result()  # reset result and continue to next param
+                continue
 
     return cert_common.test_epilog(test, revert_brgs=True, modules=[sub1g_module])

brg_certificate/tests/energy_sub1g/signal_indicator_test/signal_indicator_test.py

@@ -20,9 +20,10 @@ def run(test):
         generate_log_file(test, param_name)
         test.set_phase_rc(param.name, test.rc)
         test.add_phase_reason(param.name, test.reason)
-        if test.rc == TEST_FAILED and test.exit_on_param_failure:
-            break
-        else:
-            test.reset_result()
-
+        if test.rc == TEST_FAILED:
+            if test.exit_on_param_failure:
+                break  # break the whole for loop and keep the test as failed
+            else:
+                test.reset_result()  # reset result and continue to next param
+                continue
     return cert_common.test_epilog(test, revert_brgs=True, modules=[sub1g_module])

brg_certificate/tests/sensors/ext_sensor_test/ext_sensor_test.py

@@ -293,11 +293,12 @@ def run(test):
         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.rc == TEST_FAILED and test.exit_on_param_failure:
-            field_functionality_pass_fail_print(test, 'phase', param.name)
-            break
-        else:
-            test.reset_result()
+        if test.rc == TEST_FAILED:
+            if test.exit_on_param_failure:
+                break  # break the whole for loop and keep the test as failed
+            else:
+                test.reset_result()  # reset result and continue to next param
+                continue
 
     # Kill the ble simulator
     if test.data == DATA_SIMULATION:

gw_certificate/common/wltPb_pb2.py

@@ -2,7 +2,7 @@
 # Generated by the protocol buffer compiler.  DO NOT EDIT!
 # NO CHECKED-IN PROTOBUF GENCODE
 # source: wltPb.proto
-# Protobuf Python Version: 5.29.1
+# Protobuf Python Version: 6.30.2
 """Generated protocol buffer code."""
 from google.protobuf import descriptor as _descriptor
 from google.protobuf import descriptor_pool as _descriptor_pool
@@ -11,9 +11,9 @@ from google.protobuf import symbol_database as _symbol_database
 from google.protobuf.internal import builder as _builder
 _runtime_version.ValidateProtobufRuntimeVersion(
     _runtime_version.Domain.PUBLIC,
-    5,
-    29,
-    1,
+    6,
+    30,
+    2,
     '',
     'wltPb.proto'
 )

gw_certificate/common/wltPb_pb2.pyi

@@ -1,7 +1,8 @@
 from google.protobuf.internal import containers as _containers
 from google.protobuf import descriptor as _descriptor
 from google.protobuf import message as _message
-from typing import ClassVar as _ClassVar, Iterable as _Iterable, Mapping as _Mapping, Optional as _Optional, Union as _Union
+from collections.abc import Iterable as _Iterable, Mapping as _Mapping
+from typing import ClassVar as _ClassVar, Optional as _Optional, Union as _Union
 
 DESCRIPTOR: _descriptor.FileDescriptor
 

gw_certificate/interface/ble_simulator.py

@@ -20,19 +20,21 @@ class BLESimulator():
             self.uart.reset_gw()
         time.sleep(3)
 
-    def send_packet(self, raw_packet, duplicates=DEFAULT_DUPLICATES, output_power=DEFAULT_OUTPUT_POWER, channel=SEND_ALL_ADV_CHANNELS, delay=DEFAULT_DELAY):
+    def send_packet(self, raw_packet, duplicates=DEFAULT_DUPLICATES, output_power=DEFAULT_OUTPUT_POWER, channel=SEND_ALL_ADV_CHANNELS,
+                    delay=DEFAULT_DELAY, print_for_debug=True):
         assert self.sim_mode is True, 'BLE Sim not initialized!'
         if len(raw_packet) == 62:
             # Add ADVA
             raw_packet = DEFAULT_ADVA + raw_packet
         if len(raw_packet) != 74:
             raise ValueError('Raw Packet must be 62/74 chars long!')
-        self.uart.write_ble_command(f"!ble_sim {str(raw_packet)} {str(duplicates)} {str(output_power)} {str(channel)} {str(delay)}")
+        self.uart.write_ble_command(f"!ble_sim {str(raw_packet)} {str(duplicates)} {str(output_power)} {str(channel)} {str(delay)}", print_for_debug=print_for_debug)
         if delay > 0:
             diff = time.perf_counter()
             time.sleep((delay/1000) * duplicates)
             diff = time.perf_counter() - diff
-            debug_print(f'Desired Delay: {(delay/1000) * duplicates} Actual Delay {diff}')
+            if print_for_debug:
+                debug_print(f'Desired Delay: {(delay/1000) * duplicates} Actual Delay {diff}')
 
     
     def send_data_si_pair(self, data_packet, si_packet, duplicates, output_power=DEFAULT_OUTPUT_POWER, delay=DEFAULT_DELAY, packet_error=None):

gw_certificate/interface/uart_if.py

@@ -12,7 +12,7 @@ import pkg_resources
 from gw_certificate.common.debug import debug_print
 from gw_certificate.interface.if_defines import *
 
-LATEST_VERSION = '4.4.82'
+LATEST_VERSION = '4.4.88'
 LATEST_VERSION_FILE = f'{LATEST_VERSION}_sd_bl_app.zip'
 LATEST_VERSION_PATH = pkg_resources.resource_filename(__name__, LATEST_VERSION_FILE)
 LATEST_VERSION_FILE_APP = f'{LATEST_VERSION}_app.zip'
@@ -65,9 +65,10 @@ class UARTInterface:
             return None
         return answer
 
-    def write_ble_command(self, cmd, read=False):
+    def write_ble_command(self, cmd, read=False, print_for_debug=True):
         # This function writes a command (cmd) to the ble using a serial connection (ble_ser) that are provided to it beforehand.. and returns the answer from the device as string
-        debug_print("Write to BLE: {}".format(cmd))
+        if print_for_debug:
+            debug_print("Write to BLE: {}".format(cmd))
         # Shows on terminal what command is about to be printed to the BLE device
         bytes_to_write = bytes(cmd.encode("utf-8")) + b'\r\n'
         self.serial.write(bytes_to_write)
@@ -77,7 +78,8 @@ class UARTInterface:
             # Pauses the program for execution for 0.01sec. This is done to allow the device to process the command and provide a response before reading the response.
             time.sleep(1)
             answer = self.read_line()
-            debug_print(answer)
+            if print_for_debug:
+                debug_print(answer)
         return answer
     
     def flush(self, request_power_cycle=False):

gw_certificate/tests/actions.py

@@ -131,7 +131,7 @@ class BridgeOTAStage(GenericActionsStage):
         self.error_summary = "Bridge wasn't upgraded."
         self.action = "Bridge Upgrade"
 
-        OTA_VERSIONS_TO_USE = ("4.4.82", "4.4.83")
+        OTA_VERSIONS_TO_USE = ("4.4.88", "4.4.89")
         if version.parse(OTA_VERSIONS_TO_USE[0]) != self.uart.fw_version:
             self.desired_version = version.parse(OTA_VERSIONS_TO_USE[0])
         else:

gw_certificate/tests/static/generated_packet_table.py

@@ -134,22 +134,22 @@ class GeneratedPacketTable:
 
         def _acl_data(df):
             hardcoded_data = [
-                {"test": "acl", "duplication": "10", "time_delay": "20", "bridge_idx": 1, ADVA_PAYLOAD: "A365FECA59D61E16C6FC00003F020AD2A365FECA5916095E9101FF1104EB0958D400110100", "payload": "C6FC00003F020AD2A365FECA5916095E9101FF1104EB0958D400110100", "si": "", "bridge_id": "A365FECA5916", "adva": "A365FECA59D6", "pkt_id": "00110100"},
-                {"test": "acl", "duplication": "10", "time_delay": "20", "bridge_idx": 2, ADVA_PAYLOAD: "A365FEC659DA1E16C6FC00003F020AD2A365FEC6591A095E9101FF1104EB0958D400110100", "payload": "C6FC00003F020AD2A365FEC6591A095E9101FF1104EB0958D400110100", "si": "", "bridge_id": "A365FEC6591A", "adva": "A365FEC659DA", "pkt_id": "00110100"},
-                {"test": "acl", "duplication": "10", "time_delay": "20", "bridge_idx": 1, ADVA_PAYLOAD: "A365FECA59D61E16C6FC00003F020AD3A365FECA5916095E9101FF1104EB0958D400110101", "payload": "C6FC00003F020AD3A365FECA5916095E9101FF1104EB0958D400110101", "si": "", "bridge_id": "A365FECA5916", "adva": "A365FECA59D6", "pkt_id": "00110101"},
-                {"test": "acl", "duplication": "10", "time_delay": "20", "bridge_idx": 2, ADVA_PAYLOAD: "A365FEC659DA1E16C6FC00003F020AD3A365FEC6591A095E9101FF1104EB0958D400110101", "payload": "C6FC00003F020AD3A365FEC6591A095E9101FF1104EB0958D400110101", "si": "", "bridge_id": "A365FEC6591A", "adva": "A365FEC659DA", "pkt_id": "00110101"},
-                {"test": "acl", "duplication": "10", "time_delay": "20", "bridge_idx": 1, ADVA_PAYLOAD: "A365FECA59D61E16C6FC00003F020AD4A365FECA5916095E9101FF1104EB0958D400110102", "payload": "C6FC00003F020AD4A365FECA5916095E9101FF1104EB0958D400110102", "si": "", "bridge_id": "A365FECA5916", "adva": "A365FECA59D6", "pkt_id": "00110102"},
-                {"test": "acl", "duplication": "10", "time_delay": "20", "bridge_idx": 2, ADVA_PAYLOAD: "A365FEC659DA1E16C6FC00003F020AD4A365FEC6591A095E9101FF1104EB0958D400110102", "payload": "C6FC00003F020AD4A365FEC6591A095E9101FF1104EB0958D400110102", "si": "", "bridge_id": "A365FEC6591A", "adva": "A365FEC659DA", "pkt_id": "00110102"},
-                {"test": "acl", "duplication": "10", "time_delay": "20", "bridge_idx": 1, ADVA_PAYLOAD: "A365FECA59D61E16C6FC00003F020AD5A365FECA5916095E9101FF1104EB0958D400110103", "payload": "C6FC00003F020AD5A365FECA5916095E9101FF1104EB0958D400110103", "si": "", "bridge_id": "A365FECA5916", "adva": "A365FECA59D6", "pkt_id": "00110103"},
-                {"test": "acl", "duplication": "10", "time_delay": "20", "bridge_idx": 2, ADVA_PAYLOAD: "A365FEC659DA1E16C6FC00003F020AD5A365FEC6591A095E9101FF1104EB0958D400110103", "payload": "C6FC00003F020AD5A365FEC6591A095E9101FF1104EB0958D400110103", "si": "", "bridge_id": "A365FEC6591A", "adva": "A365FEC659DA", "pkt_id": "00110103"},
-                {"test": "acl", "duplication": "10", "time_delay": "20", "bridge_idx": 1, ADVA_PAYLOAD: "A365FECA59D61E16C6FC00003F020AD6A365FECA5916095E9101FF1104EB0958D400110104", "payload": "C6FC00003F020AD6A365FECA5916095E9101FF1104EB0958D400110104", "si": "", "bridge_id": "A365FECA5916", "adva": "A365FECA59D6", "pkt_id": "00110104"},
-                {"test": "acl", "duplication": "10", "time_delay": "20", "bridge_idx": 2, ADVA_PAYLOAD: "A365FEC659DA1E16C6FC00003F020AD6A365FEC6591A095E9101FF1104EB0958D400110104", "payload": "C6FC00003F020AD6A365FEC6591A095E9101FF1104EB0958D400110104", "si": "", "bridge_id": "A365FEC6591A", "adva": "A365FEC659DA", "pkt_id": "00110104"},
-                {"test": "acl", "duplication": "10", "time_delay": "20", "bridge_idx": 1, ADVA_PAYLOAD: "A365FECA59D61E16C6FC00003F020AD7A365FECA5916095E9101FF1104EB0958D400110105", "payload": "C6FC00003F020AD7A365FECA5916095E9101FF1104EB0958D400110105", "si": "", "bridge_id": "A365FECA5916", "adva": "A365FECA59D6", "pkt_id": "00110105"},
-                {"test": "acl", "duplication": "10", "time_delay": "20", "bridge_idx": 2, ADVA_PAYLOAD: "A365FEC659DA1E16C6FC00003F020AD7A365FEC6591A095E9101FF1104EB0958D400110105", "payload": "C6FC00003F020AD7A365FEC6591A095E9101FF1104EB0958D400110105", "si": "", "bridge_id": "A365FEC6591A", "adva": "A365FEC659DA", "pkt_id": "00110105"},
-                {"test": "acl", "duplication": "10", "time_delay": "20", "bridge_idx": 1, ADVA_PAYLOAD: "A365FECA59D61E16C6FC00003F020AD8A365FECA5916095E9101FF1104EB0958D400110106", "payload": "C6FC00003F020AD8A365FECA5916095E9101FF1104EB0958D400110106", "si": "", "bridge_id": "A365FECA5916", "adva": "A365FECA59D6", "pkt_id": "00110106"},
-                {"test": "acl", "duplication": "10", "time_delay": "20", "bridge_idx": 2, ADVA_PAYLOAD: "A365FEC659DA1E16C6FC00003F020AD8A365FEC6591A095E9101FF1104EB0958D400110106", "payload": "C6FC00003F020AD8A365FEC6591A095E9101FF1104EB0958D400110106", "si": "", "bridge_id": "A365FEC6591A", "adva": "A365FEC659DA", "pkt_id": "00110106"},
-                {"test": "acl", "duplication": "10", "time_delay": "20", "bridge_idx": 1, ADVA_PAYLOAD: "A365FECA59D61E16C6FC00003F020AD9A365FECA5916095E9101FF1104EB0958D400110107", "payload": "C6FC00003F020AD9A365FECA5916095E9101FF1104EB0958D400110107", "si": "", "bridge_id": "A365FECA5916", "adva": "A365FECA59D6", "pkt_id": "00110107"},
-                {"test": "acl", "duplication": "10", "time_delay": "20", "bridge_idx": 2, ADVA_PAYLOAD: "A365FEC659DA1E16C6FC00003F020AD9A365FEC6591A095E9101FF1104EB0958D400110107", "payload": "C6FC00003F020AD9A365FEC6591A095E9101FF1104EB0958D400110107", "si": "", "bridge_id": "A365FEC6591A", "adva": "A365FEC659DA", "pkt_id": "00110107"},
+                {"test": "acl", "duplication": "10", "time_delay": "20", "bridge_idx": 1, ADVA_PAYLOAD: "D659CAFE65A31E16C6FC00003F020AD2A365FECA5916095E9101FF1104EB0958D400110100", "payload": "C6FC00003F020AD2A365FECA5916095E9101FF1104EB0958D400110100", "si": "", "bridge_id": "A365FECA5916", "adva": "D659CAFE65A3", "pkt_id": "00110100"},
+                {"test": "acl", "duplication": "10", "time_delay": "20", "bridge_idx": 2, ADVA_PAYLOAD: "DA59C6FE65A31E16C6FC00003F020AD2A365FEC6591A095E9101FF1104EB0958D400110100", "payload": "C6FC00003F020AD2A365FEC6591A095E9101FF1104EB0958D400110100", "si": "", "bridge_id": "A365FEC6591A", "adva": "DA59C6FE65A3", "pkt_id": "00110100"},
+                {"test": "acl", "duplication": "10", "time_delay": "20", "bridge_idx": 1, ADVA_PAYLOAD: "D659CAFE65A31E16C6FC00003F020AD3A365FECA5916095E9101FF1104EB0958D400110101", "payload": "C6FC00003F020AD3A365FECA5916095E9101FF1104EB0958D400110101", "si": "", "bridge_id": "A365FECA5916", "adva": "D659CAFE65A3", "pkt_id": "00110101"},
+                {"test": "acl", "duplication": "10", "time_delay": "20", "bridge_idx": 2, ADVA_PAYLOAD: "DA59C6FE65A31E16C6FC00003F020AD3A365FEC6591A095E9101FF1104EB0958D400110101", "payload": "C6FC00003F020AD3A365FEC6591A095E9101FF1104EB0958D400110101", "si": "", "bridge_id": "A365FEC6591A", "adva": "DA59C6FE65A3", "pkt_id": "00110101"},
+                {"test": "acl", "duplication": "10", "time_delay": "20", "bridge_idx": 1, ADVA_PAYLOAD: "D659CAFE65A31E16C6FC00003F020AD4A365FECA5916095E9101FF1104EB0958D400110102", "payload": "C6FC00003F020AD4A365FECA5916095E9101FF1104EB0958D400110102", "si": "", "bridge_id": "A365FECA5916", "adva": "D659CAFE65A3", "pkt_id": "00110102"},
+                {"test": "acl", "duplication": "10", "time_delay": "20", "bridge_idx": 2, ADVA_PAYLOAD: "DA59C6FE65A31E16C6FC00003F020AD4A365FEC6591A095E9101FF1104EB0958D400110102", "payload": "C6FC00003F020AD4A365FEC6591A095E9101FF1104EB0958D400110102", "si": "", "bridge_id": "A365FEC6591A", "adva": "DA59C6FE65A3", "pkt_id": "00110102"},
+                {"test": "acl", "duplication": "10", "time_delay": "20", "bridge_idx": 1, ADVA_PAYLOAD: "D659CAFE65A31E16C6FC00003F020AD5A365FECA5916095E9101FF1104EB0958D400110103", "payload": "C6FC00003F020AD5A365FECA5916095E9101FF1104EB0958D400110103", "si": "", "bridge_id": "A365FECA5916", "adva": "D659CAFE65A3", "pkt_id": "00110103"},
+                {"test": "acl", "duplication": "10", "time_delay": "20", "bridge_idx": 2, ADVA_PAYLOAD: "DA59C6FE65A31E16C6FC00003F020AD5A365FEC6591A095E9101FF1104EB0958D400110103", "payload": "C6FC00003F020AD5A365FEC6591A095E9101FF1104EB0958D400110103", "si": "", "bridge_id": "A365FEC6591A", "adva": "DA59C6FE65A3", "pkt_id": "00110103"},
+                {"test": "acl", "duplication": "10", "time_delay": "20", "bridge_idx": 1, ADVA_PAYLOAD: "D659CAFE65A31E16C6FC00003F020AD6A365FECA5916095E9101FF1104EB0958D400110104", "payload": "C6FC00003F020AD6A365FECA5916095E9101FF1104EB0958D400110104", "si": "", "bridge_id": "A365FECA5916", "adva": "D659CAFE65A3", "pkt_id": "00110104"},
+                {"test": "acl", "duplication": "10", "time_delay": "20", "bridge_idx": 2, ADVA_PAYLOAD: "DA59C6FE65A31E16C6FC00003F020AD6A365FEC6591A095E9101FF1104EB0958D400110104", "payload": "C6FC00003F020AD6A365FEC6591A095E9101FF1104EB0958D400110104", "si": "", "bridge_id": "A365FEC6591A", "adva": "DA59C6FE65A3", "pkt_id": "00110104"},
+                {"test": "acl", "duplication": "10", "time_delay": "20", "bridge_idx": 1, ADVA_PAYLOAD: "D659CAFE65A31E16C6FC00003F020AD7A365FECA5916095E9101FF1104EB0958D400110105", "payload": "C6FC00003F020AD7A365FECA5916095E9101FF1104EB0958D400110105", "si": "", "bridge_id": "A365FECA5916", "adva": "D659CAFE65A3", "pkt_id": "00110105"},
+                {"test": "acl", "duplication": "10", "time_delay": "20", "bridge_idx": 2, ADVA_PAYLOAD: "DA59C6FE65A31E16C6FC00003F020AD7A365FEC6591A095E9101FF1104EB0958D400110105", "payload": "C6FC00003F020AD7A365FEC6591A095E9101FF1104EB0958D400110105", "si": "", "bridge_id": "A365FEC6591A", "adva": "DA59C6FE65A3", "pkt_id": "00110105"},
+                {"test": "acl", "duplication": "10", "time_delay": "20", "bridge_idx": 1, ADVA_PAYLOAD: "D659CAFE65A31E16C6FC00003F020AD8A365FECA5916095E9101FF1104EB0958D400110106", "payload": "C6FC00003F020AD8A365FECA5916095E9101FF1104EB0958D400110106", "si": "", "bridge_id": "A365FECA5916", "adva": "D659CAFE65A3", "pkt_id": "00110106"},
+                {"test": "acl", "duplication": "10", "time_delay": "20", "bridge_idx": 2, ADVA_PAYLOAD: "DA59C6FE65A31E16C6FC00003F020AD8A365FEC6591A095E9101FF1104EB0958D400110106", "payload": "C6FC00003F020AD8A365FEC6591A095E9101FF1104EB0958D400110106", "si": "", "bridge_id": "A365FEC6591A", "adva": "DA59C6FE65A3", "pkt_id": "00110106"},
+                {"test": "acl", "duplication": "10", "time_delay": "20", "bridge_idx": 1, ADVA_PAYLOAD: "D659CAFE65A31E16C6FC00003F020AD9A365FECA5916095E9101FF1104EB0958D400110107", "payload": "C6FC00003F020AD9A365FECA5916095E9101FF1104EB0958D400110107", "si": "", "bridge_id": "A365FECA5916", "adva": "D659CAFE65A3", "pkt_id": "00110107"},
+                {"test": "acl", "duplication": "10", "time_delay": "20", "bridge_idx": 2, ADVA_PAYLOAD: "DA59C6FE65A31E16C6FC00003F020AD9A365FEC6591A095E9101FF1104EB0958D400110107", "payload": "C6FC00003F020AD9A365FEC6591A095E9101FF1104EB0958D400110107", "si": "", "bridge_id": "A365FEC6591A", "adva": "DA59C6FE65A3", "pkt_id": "00110107"},
             ]
         
             hardcoded_df = pd.DataFrame(hardcoded_data)