wiliot-certificate 1.3.0a1__py3-none-any.whl → 1.4.0a1__py3-none-any.whl

brg_certificate/tests/datapath/output_power_test/output_power_test.py

@@ -0,0 +1,27 @@
+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_config as cert_config
+
+def run(test):
+
+    fields = [BRG_OUTPUT_POWER]
+    datapath_module = eval_pkt(f'ModuleDatapathV{test.active_brg.api_version}')
+
+    test = cert_common.test_prolog(test)
+    if test.rc == TEST_FAILED or test.reason != TEST_SUCCESS:
+        return cert_common.test_epilog(test)
+
+    for param in test.params:
+        test = cert_config.brg_configure(test, fields=fields, values=[param.value], module=datapath_module)[0]
+        generate_log_file(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()
+
+    return cert_common.test_epilog(test, revert_brgs=True, modules=[datapath_module])

brg_certificate/tests/datapath/pacer_interval_ble5_test/pacer_interval_ble5_test.json

@@ -0,0 +1,13 @@
+{
+    "name": "pacer_interval_ble5_test",
+    "module": "datapath",
+    "purpose": "Test pacer interval feature configuration and functionality in the bridge with BLE5 packets for different pacer interval values",
+    "documentaion": "<TEST_DOCUMENTATION_LINK>",
+    "initialCondition": "Bridge & data simulator configured to defaults",
+    "procedure": ["Test prolog", "Pacer interval configuration", "Generate GEN3 pixels packets & scan for packets in the bridge", "Compare pacer interval mean per pixel to the configured value", "Repeat for all given pacer interval values", "Test epilog and revert to defaults"],
+    "expectedOutcome": "All values configured successfully and actual pacing found matching to the configured values",
+    "mandatory": 1,
+    "multiBridgeTest": 0,
+    "gwOnlyTest": 0,
+    "allSupportedValues": [5, 15, 30, 60]
+}

brg_certificate/tests/datapath/pacer_interval_ble5_test/pacer_interval_ble5_test.py

@@ -0,0 +1,43 @@
+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_config as cert_config
+
+def run(test):
+
+    fields = [BRG_PACER_INTERVAL, BRG_RX_CHANNEL, BRG_PKT_FILTER]
+    datapath_module = eval_pkt(f'ModuleDatapathV{test.active_brg.api_version}')
+
+    test = cert_common.test_prolog(test)
+    if test.rc == TEST_FAILED or test.reason != TEST_SUCCESS:
+        return cert_common.test_epilog(test)
+
+    for param in test.params:
+        test = cert_config.brg_configure_ble5(test, fields=fields, values=[param.value, ag.RX_CHANNEL_10_250K, ag.PKT_FILTER_TEMP_PKT], module=datapath_module)[0]
+        if test.rc == TEST_FAILED and test.exit_on_param_failure:
+            break
+        num_of_pixels = 0
+        if test.data == DATA_SIMULATION:
+            # start generating pkts and send them using data simulator
+            num_of_pixels = 10
+            pixel_sim_thread = cert_data_sim.DataSimThread(test=test, num_of_pixels=num_of_pixels, duplicates=2, delay=0, pkt_types=[2], pixels_type=GEN3_EXTENDED)
+            pixel_sim_thread.start()
+        df = cert_common.data_scan(test, scan_time=param.value*4, brg_data=(not test.internal_brg), gw_data=test.internal_brg)
+        if test.data == DATA_SIMULATION:
+            # stop generating pkts with data simulator and wait a few seconds for full flush
+            pixel_sim_thread.stop()
+            time.sleep(5)
+        cert_mqtt.dump_pkts(test, log=param.name)
+        cert_common.display_data(df, nfpkt=True, tbc=True, name_prefix=f"brg_pacer_{param.name}_", dir=test.dir)
+        test = cert_common.pacing_analysis(test, df=df, pacer_interval=param.value, num_of_pixels=num_of_pixels)
+        generate_log_file(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()
+
+    return cert_common.test_epilog(test, revert_brgs=True, revert_gws=test.internal_brg, modules=[datapath_module], ble5=True)

brg_certificate/tests/datapath/pacer_interval_tags_count_test/pacer_interval_tags_count_test.json

@@ -0,0 +1,13 @@
+{
+    "name": "pacer_interval_test",
+    "module": "datapath",
+    "purpose": "Test pixels handling in the bridge for different pacer interval values",
+    "documentaion": "<TEST_DOCUMENTATION_LINK>",
+    "initialCondition": "Bridge configured to defaults",
+    "procedure": ["Test prolog", "Pacer interval configuration", "Scan for pixel packets in the bridge", "Compare maximal amount of received pixels to the amount received with different pacer interval value", "Repeat for all given pacer interval values", "Test epilog and revert to defaults"],
+    "expectedOutcome": "All values configured successfully and no significant gaps between received amounts of pixels were found",
+    "mandatory": 1,
+    "multiBridgeTest": 0,
+    "gwOnlyTest": 0,
+    "allSupportedValues": [1, 10, 15, 30]
+}

brg_certificate/tests/datapath/pacer_interval_tags_count_test/pacer_interval_tags_count_test.py

@@ -0,0 +1,63 @@
+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_config as cert_config
+
+def run(test):
+    pacer_threshold = PACER_INTERVAL_THRESHOLD_HIGH if test.private_setup else PACER_INTERVAL_THRESHOLD
+
+    fields = [BRG_PACER_INTERVAL, BRG_TX_REPETITION]
+    datapath_module = eval_pkt(f'ModuleDatapathV{test.active_brg.api_version}')
+
+    test = cert_common.test_prolog(test)
+    if test.rc == TEST_FAILED or test.reason != TEST_SUCCESS:
+        return cert_common.test_epilog(test)
+
+    # Configure the GW to receive tags pkt
+    if test.internal_brg:
+        test = cert_config.brg_configure(test, fields=[BRG_RX_CHANNEL], values=[ag.RX_CHANNEL_37], module=datapath_module, wait=True)[0]
+        if test.rc == TEST_FAILED or test.reason != TEST_SUCCESS:
+            return cert_common.test_epilog(test, revert_gws=True)
+
+    num_of_pixels = 200
+    if test.data == DATA_SIMULATION:
+        # start generating pkts and send them using data simulator
+        pixel_sim_thread = cert_data_sim.DataSimThread(test=test, num_of_pixels=num_of_pixels, duplicates=3, delay=0, pkt_types=[0])
+        pixel_sim_thread.start()
+
+    tags_count_per_pacer = {}
+    for param in test.params:
+        test = cert_config.brg_configure(test, fields=fields, values=[param.value, 1], module=datapath_module)[0]
+        if test.rc == TEST_FAILED and test.exit_on_param_failure:
+            generate_log_file(test, param.name)
+            return cert_common.test_epilog(test, revert_brgs=True, revert_gws=test.internal_brg, modules=[datapath_module])
+        df = cert_common.data_scan(test, scan_time=120, brg_data=True)
+        cert_common.display_data(df, nfpkt=True, tbc=True, name_prefix=f"brg_pacer_tags_count_{param.name}_", dir=test.dir)
+        tags_count_per_pacer[param.value] = df[TAG_ID].nunique()
+        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:
+            return cert_common.test_epilog(test, revert_brgs=True, revert_gws=test.internal_brg, modules=[datapath_module])
+        else:
+            test.reset_result()
+
+    if test.data == DATA_SIMULATION:
+        # stop generating pkts with data simulator and wait a few seconds for full flush
+        pixel_sim_thread.stop()
+        time.sleep(5)
+
+    print("tags_count_per_pacer: ", tags_count_per_pacer)
+    max_count = max([tags_count_per_pacer[pacer] for pacer in tags_count_per_pacer])
+    for param in test.params:
+        if test.data == DATA_SIMULATION:
+            if tags_count_per_pacer[param.value] != num_of_pixels:
+                test.set_phase_rc(param.name, TEST_FAILED)
+                test.add_phase_reason(param.name, f"received_tags={tags_count_per_pacer[param.value]} num_of_pixels={num_of_pixels}")
+        # make sure minimal received tags number is more than minimal threshold (precentile from max) (diff of less than 3 tags will be accepted anyway)
+        elif tags_count_per_pacer[param.value] < (pacer_threshold * max_count) and (max_count - tags_count_per_pacer[param.value]) > 3:
+            test.set_phase_rc(param.name, TEST_FAILED)
+            test.add_phase_reason(param.name, f"received_tags={tags_count_per_pacer[param.value]} max_tags={max_count} less than {int(pacer_threshold * 100)}%")
+
+    return cert_common.test_epilog(test, revert_brgs=True, revert_gws=test.internal_brg, modules=[datapath_module])

brg_certificate/tests/datapath/pacer_interval_test/pacer_interval_test.json

@@ -0,0 +1,13 @@
+{
+    "name": "pacer_interval_test",
+    "module": "datapath",
+    "purpose": "Test pacer interval feature configuration and functionality in the bridge for different pacer interval values",
+    "documentaion": "<TEST_DOCUMENTATION_LINK>",
+    "initialCondition": "Bridge & data simulator configured to defaults",
+    "procedure": ["Test prolog", "Pacer interval configuration", "Generate pixels packets & scan for packets in the bridge", "Compare pacer interval mean per pixel to the configured value", "Repeat for all given pacer interval values", "Test epilog and revert to defaults"],
+    "expectedOutcome": "All values configured successfully and actual pacing found matching to the configured values",
+    "mandatory": 1,
+    "multiBridgeTest": 0,
+    "gwOnlyTest": 0,
+    "allSupportedValues": [5, 10, 15, 30, 60]
+}

brg_certificate/tests/datapath/pacer_interval_test/pacer_interval_test.py

@@ -0,0 +1,50 @@
+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_config as cert_config
+
+def run(test):
+
+    fields = [BRG_PACER_INTERVAL, BRG_PKT_FILTER, BRG_RX_CHANNEL]
+    datapath_module = eval_pkt(f'ModuleDatapathV{test.active_brg.api_version}')
+
+    test = cert_common.test_prolog(test)
+    if test.rc == TEST_FAILED or test.reason != TEST_SUCCESS:
+        return cert_common.test_epilog(test)
+
+    for param in test.params:
+        test = cert_config.brg_configure(test, fields=fields, values=[param.value, ag.PKT_FILTER_TEMP_PKT, ag.RX_CHANNEL_37], module=datapath_module)[0]
+        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()
+
+        num_of_pixels = 0
+        if test.data == DATA_SIMULATION:
+            # start generating pkts and send them using data simulator
+            num_of_pixels = 10
+            pixel_sim_thread = cert_data_sim.DataSimThread(test=test, num_of_pixels=num_of_pixels, duplicates=3, delay=100, pkt_types=[0])
+            pixel_sim_thread.start()
+        df = cert_common.data_scan(test, scan_time=param.value*4, brg_data=(not test.internal_brg), gw_data=test.internal_brg)
+        if test.data == DATA_SIMULATION:
+            # stop generating pkts with data simulator and wait a few seconds for full flush
+            pixel_sim_thread.stop()
+            time.sleep(5)
+        cert_mqtt.dump_pkts(test, log=param.name)
+        cert_common.display_data(df, nfpkt=True, tbc=True, name_prefix=f"brg_pacer_{param.name}_", dir=test.dir)
+        test = cert_common.pacing_analysis(test, df=df, pacer_interval=param.value, num_of_pixels=num_of_pixels)
+        generate_log_file(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:
+            break
+
+    return cert_common.test_epilog(test, revert_brgs=True, revert_gws=test.internal_brg, modules=[datapath_module])

brg_certificate/tests/datapath/pattern_test/pattern_test.json

@@ -0,0 +1,13 @@
+{
+    "name": "pattern_test",
+    "module": "datapath",
+    "purpose": "Test configuration for all supported calibration pattern values",
+    "documentaion": "<TEST_DOCUMENTATION_LINK>",
+    "initialCondition": "Bridge configured to defaults",
+    "procedure": ["Test prolog", "Configurations", "Test epilog and revert to defaults"],
+    "expectedOutcome": "All values configured successfully",
+    "mandatory": 1,
+    "multiBridgeTest": 0,
+    "gwOnlyTest": 0,
+    "allSupportedValues": ["DATAPATH_PATTERN_STANDARD", "DATAPATH_PATTERN_38_38_39", "DATAPATH_PATTERN_EU_PATTERN"]
+}

brg_certificate/tests/datapath/pattern_test/pattern_test.py

@@ -0,0 +1,28 @@
+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_config as cert_config
+
+def run(test):
+
+    fields = [BRG_PATTERN]
+    datapath_module = eval_pkt(f'ModuleDatapathV{test.active_brg.api_version}')
+
+    test = cert_common.test_prolog(test)
+    if test.rc == TEST_FAILED or test.reason != TEST_SUCCESS:
+        return cert_common.test_epilog(test)
+
+    for param in test.params:
+        # Set brg cfg
+        test = cert_config.brg_configure(test, fields=fields, values=[param.value], module=datapath_module)[0]
+        generate_log_file(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()
+
+    return cert_common.test_epilog(test, revert_brgs=True, modules=[datapath_module])

brg_certificate/tests/datapath/pkt_filter_ble5_test/pkt_filter_ble5_test.json

@@ -0,0 +1,13 @@
+{
+    "name": "pkt_filter_test",
+    "module": "datapath",
+    "purpose": "Test packet filter feature configuration and functionality in the bridge for different packet filters using BLE5",
+    "documentaion": "https://community.wiliot.com/customers/s/article/Wiliot-Network-Data-Path-Module-Pacing",
+    "initialCondition": "Bridge & data simulator configured to defaults",
+    "procedure": ["Test prolog", "Packet filter & secondary BLE5 rx channel configuration", "Generate pixels packets & scan for packets in the bridge", "Compare pacer interval mean per pixel & packet type to the configured value", "Repeat for all given packet filter values", "Test epilog and revert to defaults"],
+    "expectedOutcome": "All values configured successfully and actual pacing found matching to the configured values",
+    "mandatory": 1,
+    "multiBridgeTest": 0,
+    "gwOnlyTest": 0,
+    "allSupportedValues": ["PKT_FILTER_RANDOM_FIRST_ARRIVING_PKT", "PKT_FILTER_DISABLE_FORWARDING", "PKT_FILTER_TEMP_PKT", "PKT_FILTER_TEMP_AND_ADVANCED_PKTS", "PKT_FILTER_TEMP_ADVANCED_AND_DEBUG_PKTS"]
+}

brg_certificate/tests/datapath/pkt_filter_ble5_test/pkt_filter_ble5_test.py

@@ -0,0 +1,51 @@
+from brg_certificate.cert_prints import *
+from brg_certificate.cert_defines import *
+from brg_certificate.ag.wlt_types_ag import *
+import brg_certificate.cert_common as cert_common
+import brg_certificate.cert_config as cert_config
+
+PKT_FILTER_TEST_PACER_INTERVAL = 10
+
+def run(test):
+
+    fields = [BRG_PKT_FILTER, BRG_RX_CHANNEL, BRG_PACER_INTERVAL]
+    datapath_module = eval(f'ModuleDatapathV{test.active_brg.api_version}')
+
+    test = cert_common.test_prolog(test)
+    if test.rc == TEST_FAILED or test.reason != TEST_SUCCESS:
+        return cert_common.test_epilog(test)
+
+
+    for param in test.params:
+        test = cert_config.brg_configure_ble5(test, fields=fields, values=[param.value, RX_CHANNEL_10_250K, PKT_FILTER_TEST_PACER_INTERVAL], module=datapath_module)[0]
+        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()
+        print("waiting 5 seconds for datapath to clear")
+        print_update_wait(5)
+        num_of_pixels = 0
+        if test.data == DATA_SIMULATION:
+            # start generating pkts and send them using data simulator
+            num_of_pixels = 5
+            pixel_sim_thread = cert_data_sim.DataSimThread(test=test, num_of_pixels=num_of_pixels, duplicates=2, delay=0, pkt_types=[2], pixels_type=GEN3_EXTENDED)
+            pixel_sim_thread.start()
+        df = cert_common.data_scan(test, brg_data=(not test.internal_brg), gw_data=test.internal_brg, scan_time=PKT_FILTER_TEST_PACER_INTERVAL*6, per_pkt_type=True, pkt_filter_cfg=param.value, flush_pkts=True)
+        if test.data == DATA_SIMULATION:
+            # stop generating pkts with data simulator and wait a few seconds for full flush
+            pixel_sim_thread.stop()
+            time.sleep(5)
+        cert_common.display_data(df, nfpkt=True, tbc=True, name_prefix=f"{param.name}_", dir=test.dir)
+        test = cert_common.pacing_analysis(test, pacer_interval=PKT_FILTER_TEST_PACER_INTERVAL, df=df, pkt_filter_cfg=param.value, num_of_pixels=num_of_pixels, is_ble5_test=True)
+        generate_log_file(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()
+
+    return cert_common.test_epilog(test, revert_brgs=True, revert_gws=test.internal_brg, modules=[datapath_module], ble5=True)

brg_certificate/tests/datapath/pkt_filter_gen3_test/pkt_filter_gen3_test.json

@@ -0,0 +1,13 @@
+{
+    "name": "pkt_filter_gen3_test",
+    "module": "datapath",
+    "purpose": "Test the packet filter feature configuration and functionality in the bridge for different packet filters with Gen3 data packets",
+    "documentaion": "https://community.wiliot.com/customers/s/article/Wiliot-Network-Data-Path-Module-Pacing",
+    "initialCondition": "Bridge & data simulator configured to defaults",
+    "procedure": ["Test prolog", "Packet filter configuration", "Generate Gen3 pixels packets & scan for packets in the bridge", "Compare pacer interval mean per pixel & packet type to the configured value", "Repeat for all given packet filter values", "Test epilog and revert to defaults"],
+    "expectedOutcome": "All values configured successfully and actual pacing found matching to the configured values",
+    "mandatory": 1,
+    "multiBridgeTest": 0,
+    "gwOnlyTest": 0,
+    "allSupportedValues": ["PKT_FILTER_RANDOM_FIRST_ARRIVING_PKT", "PKT_FILTER_DISABLE_FORWARDING", "PKT_FILTER_TEMP_PKT", "PKT_FILTER_TEMP_AND_ADVANCED_PKTS"]
+}

brg_certificate/tests/datapath/pkt_filter_gen3_test/pkt_filter_gen3_test.py

@@ -0,0 +1,54 @@
+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_config as cert_config
+
+PKT_FILTER_TEST_PACER_INTERVAL = 10
+
+def run(test):
+
+    # We add the field BRG_RX_CHANNEL so internal BRGs will be configured to channel 37 (default is 39)
+    fields = [BRG_PKT_FILTER, BRG_RX_CHANNEL, BRG_PACER_INTERVAL]
+    datapath_module = eval_pkt(f'ModuleDatapathV{test.active_brg.api_version}')
+
+    test = cert_common.test_prolog(test)
+    if test.rc == TEST_FAILED or test.reason != TEST_SUCCESS:
+        return cert_common.test_epilog(test)
+
+
+    for param in test.params:
+        test = cert_config.brg_configure(test, fields=fields, values=[param.value, ag.RX_CHANNEL_37, PKT_FILTER_TEST_PACER_INTERVAL], module=datapath_module)[0]
+        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()
+        print("waiting 5 seconds for datapath to clear")
+        print_update_wait(5)
+
+        num_of_pixels = 0
+        if test.data == DATA_SIMULATION:
+            # start generating pkts and send them using data simulator
+            num_of_pixels = 5
+            pixel_sim_thread = cert_data_sim.DataSimThread(test=test, num_of_pixels=num_of_pixels, duplicates=2, delay=0, pkt_types=[0,1], pixels_type=GEN3)
+            pixel_sim_thread.start()
+        df = cert_common.data_scan(test, brg_data=(not test.internal_brg), gw_data=test.internal_brg, scan_time=PKT_FILTER_TEST_PACER_INTERVAL*6, per_pkt_type=True,
+                                 pkt_filter_cfg=param.value, flush_pkts=True)
+        if test.data == DATA_SIMULATION:
+            # stop generating pkts with data simulator and wait a few seconds for full flush
+            pixel_sim_thread.stop()
+            time.sleep(5)
+        cert_common.display_data(df, nfpkt=True, tbc=True, name_prefix=f"pkt_filter_gen3_{param.name}_", dir=test.dir)
+        test = cert_common.pacing_analysis(test, pacer_interval=PKT_FILTER_TEST_PACER_INTERVAL, df=df, pkt_filter_cfg=param.value, num_of_pixels=num_of_pixels)
+        generate_log_file(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()
+
+    return cert_common.test_epilog(test, revert_brgs=True, revert_gws=test.internal_brg, modules=[datapath_module])

brg_certificate/tests/datapath/pkt_filter_test/pkt_filter_test.json

@@ -0,0 +1,13 @@
+{
+    "name": "pkt_filter_test",
+    "module": "datapath",
+    "purpose": "Test packet filter feature configuration and functionality in the bridge for different packet filters",
+    "documentaion": "https://community.wiliot.com/customers/s/article/Wiliot-Network-Data-Path-Module-Pacing",
+    "initialCondition": "Bridge & data simulator configured to defaults",
+    "procedure": ["Test prolog", "Packet filter configuration", "Generate pixels packets & scan for packets in the bridge", "Compare pacer interval mean per pixel & packet type to the configured value", "Repeat for all given packet filter values", "Test epilog and revert to defaults"],
+    "expectedOutcome": "All values configured successfully and actual pacing found matching to the configured values",
+    "mandatory": 1,
+    "multiBridgeTest": 0,
+    "gwOnlyTest": 0,
+    "allSupportedValues": ["PKT_FILTER_RANDOM_FIRST_ARRIVING_PKT", "PKT_FILTER_DISABLE_FORWARDING", "PKT_FILTER_TEMP_PKT", "PKT_FILTER_TEMP_AND_ADVANCED_PKTS", "PKT_FILTER_TEMP_ADVANCED_AND_DEBUG_PKTS"]
+}

brg_certificate/tests/datapath/pkt_filter_test/pkt_filter_test.py

@@ -0,0 +1,55 @@
+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_config as cert_config
+
+PKT_FILTER_TEST_PACER_INTERVAL = 10
+
+def run(test):
+
+    # We add the field BRG_RX_CHANNEL so internal BRGs will be configured to channel 37 (default is 39)
+    fields = [BRG_PKT_FILTER, BRG_RX_CHANNEL, BRG_PACER_INTERVAL]
+    datapath_module = eval_pkt(f'ModuleDatapathV{test.active_brg.api_version}')
+
+    test = cert_common.test_prolog(test)
+    if test.rc == TEST_FAILED or test.reason != TEST_SUCCESS:
+        return cert_common.test_epilog(test)
+
+
+    for param in test.params:
+        test = cert_config.brg_configure(test, fields=fields, values=[param.value, ag.RX_CHANNEL_37, PKT_FILTER_TEST_PACER_INTERVAL], module=datapath_module)[0]
+        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()
+        print("waiting 5 seconds for datapath to clear")
+        print_update_wait(5)
+
+        num_of_pixels = 0
+        if test.data == DATA_SIMULATION:
+            # start generating pkts and send them using data simulator
+            num_of_pixels = 5
+            pixel_sim_thread = cert_data_sim.DataSimThread(test=test, num_of_pixels=num_of_pixels, duplicates=2, delay=0, pkt_types=[0,1,2])
+            pixel_sim_thread.start()
+        df = cert_common.data_scan(test, brg_data=(not test.internal_brg), gw_data=test.internal_brg, scan_time=PKT_FILTER_TEST_PACER_INTERVAL*6, per_pkt_type=True,
+                                 pkt_filter_cfg=param.value, flush_pkts=True)
+        if test.data == DATA_SIMULATION:
+            # stop generating pkts with data simulator and wait a few seconds for full flush
+            pixel_sim_thread.stop()
+            time.sleep(5)
+        cert_common.display_data(df, nfpkt=True, tbc=True, name_prefix=f"pkt_filter_{param.name}_", dir=test.dir)
+        test = cert_common.pacing_analysis(test, pacer_interval=PKT_FILTER_TEST_PACER_INTERVAL, df=df, pkt_filter_cfg=param.value, num_of_pixels=num_of_pixels)
+        # param epilog
+        generate_log_file(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()
+
+    return cert_common.test_epilog(test, revert_brgs=True, revert_gws=test.internal_brg, modules=[datapath_module])

brg_certificate/tests/datapath/rssi_threshold_test/rssi_threshold_test.json

@@ -0,0 +1,13 @@
+{
+    "name": "rssi_threshold_test",
+    "module": "datapath",
+    "purpose": "Test RSSI threshold configuration and functionality in the bridge",
+    "documentaion": "TODO",
+    "initialCondition": "Bridge configured to defaults",
+    "procedure": ["Test prolog", "RSSI Threshold configuration", "Checking for packets violating RSSI threshold", "Test epilog and revert to defaults"],
+    "expectedOutcome": "RSSI Threshold configured successfully and no pixel packets with RSSI weaker than the threshold have been echoed.",
+    "mandatory": 1,
+    "multiBridgeTest": 0,
+    "gwOnlyTest": 0,
+    "allSupportedValues": ["-80", "-65", "-10"]
+}

brg_certificate/tests/datapath/rssi_threshold_test/rssi_threshold_test.py

@@ -0,0 +1,73 @@
+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_config as cert_config
+
+def rssi_threshold_analysis(test, df, threshold):
+    tags_count = len(list(df[TAG_ID].unique()))
+
+    # Filter rows where RSSI is higher than threshold
+    low_rssi_df = df[df[RSSI] >= (-1)*threshold]
+
+    # Extract all tag IDs from those filtered rows
+    low_rssi_tag_ids = low_rssi_df[TAG_ID].unique()
+    failed_tags = len(low_rssi_tag_ids)
+
+    if failed_tags:
+        test.rc =TEST_FAILED
+        print("Tag IDs with RSSI exceeding", (-1)*threshold, ":", low_rssi_tag_ids)
+
+    if test.rc == TEST_FAILED:
+        test.add_reason(f"{failed_tags}/{tags_count} tags rssi violating threshold of {(-1)*threshold}")
+        print(test.reason)
+    else:
+        test.rc = TEST_PASSED
+    return test
+
+def run(test):
+
+    fields = [BRG_RSSI_THRESHOLD]
+    datapath_module = eval_pkt(f'ModuleDatapathV{test.active_brg.api_version}')
+
+    test = cert_common.test_prolog(test)
+    if test.rc == TEST_FAILED or test.reason != TEST_SUCCESS:
+        return cert_common.test_epilog(test)
+    
+    # Configure the BRG with RSSI threshold and check for packets violating the threshold
+    for param in test.params:
+        functionality_run_print(f"test for RSSI threshold of {param.value}")
+
+        test = cert_config.brg_configure(test, fields=fields, values=[param.value], module=datapath_module)[0]
+        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()
+        print("waiting 5 seconds for datapath to clear")
+        print_update_wait(5)
+
+        if test.data == DATA_SIMULATION:
+            # start generating pkts and send them using data simulator
+            num_of_pixels = 10
+            pixel_sim_thread = cert_data_sim.DataSimThread(test=test, num_of_pixels=num_of_pixels, duplicates=3, delay=100, pkt_types=[0])
+            pixel_sim_thread.start()
+        df = cert_common.data_scan(test, brg_data=(not test.internal_brg), gw_data=test.internal_brg, scan_time=60)
+        if test.data == DATA_SIMULATION:
+            # stop generating pkts with data simulator and wait a few seconds for full flush
+            pixel_sim_thread.stop()
+            time.sleep(5)
+        test = rssi_threshold_analysis(test, df, param.value)
+
+        # param epilog
+        generate_log_file(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()
+
+    return cert_common.test_epilog(test, revert_brgs=True, revert_gws=test.internal_brg, modules=[datapath_module])

brg_certificate/tests/datapath/rx_channel_test/rx_channel_test.json

@@ -0,0 +1,13 @@
+{
+    "name": "rx_channel_test",
+    "module": "datapath",
+    "purpose": "Test configuration for all supported datapath rx channel values",
+    "documentaion": "<TEST_DOCUMENTATION_LINK>",
+    "initialCondition": "Bridge configured to defaults",
+    "procedure": ["Test prolog", "Configurations", "Test epilog and revert to defaults"],
+    "expectedOutcome": "All values configured successfully",
+    "mandatory": 1,
+    "multiBridgeTest": 0,
+    "gwOnlyTest": 0,
+    "allSupportedValues": ["RX_CHANNEL_37", "RX_CHANNEL_38", "RX_CHANNEL_39", "RX_CHANNEL_10_250K", "RX_CHANNEL_10_500K"]
+}

brg_certificate/tests/datapath/rx_channel_test/rx_channel_test.py

@@ -0,0 +1,41 @@
+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_config as cert_config
+
+def is_primary_channel(channel):
+    if channel == ag.RX_CHANNEL_37 or channel == ag.RX_CHANNEL_38 or channel == ag.RX_CHANNEL_39:
+        return True
+    else:
+        return False
+
+def run(test):
+
+    fields = [BRG_RX_CHANNEL]
+    print(test.params)
+    datapath_module = eval_pkt(f'ModuleDatapathV{test.active_brg.api_version}')
+    ble5_state =  False # We use this flag to know whether the BRG is currently in BLE5 mode and needs special configuration next time it is configured
+
+    test = cert_common.test_prolog(test)
+    if test.rc == TEST_FAILED or test.reason != TEST_SUCCESS:
+        return cert_common.test_epilog(test)
+
+    for param in test.params:
+        if ble5_state:
+            test = cert_config.brg_configure_ble5(test, fields=fields, values=[param.value], module=datapath_module)[0]
+        else:
+            test = cert_config.brg_configure(test, fields=fields, values=[param.value], module=datapath_module)[0]
+
+        # param epilog
+        ble5_state = not is_primary_channel(param.value)
+        generate_log_file(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()
+
+    return cert_common.test_epilog(test, revert_brgs=True, modules=[datapath_module], ble5=ble5_state)