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

brg_certificate/certificate_sanity_test_list.txt

@@ -0,0 +1,36 @@
+# The certificate should run for every bridge change
+# The setup will include 1 tested BRG + 1 GW connected with UART
+# python ut.py --gw SIM --brg <XXXXXXXXXXXX> --tl certificate_sanity_test_list.txt --data sim --port <COM_PORT>
+
+# ------------- edge_mgmt -------------
+edge_mgmt/stat_test
+edge_mgmt/actions_test ACTION_GW_HB ACTION_BLINK ACTION_SEND_HB ACTION_GET_BATTERY_SENSOR ACTION_GET_POF_DATA ACTION_PL_STATUS ACTION_GET_MODULE ACTION_REBOOT ACTION_RESTORE_DEFAULTS
+
+# ------------- energy2400 -------------
+energy2400/pattern_test ENERGY_PATTERN_2_4_CHANNEL_37 ENERGY_PATTERN_2_4_CHANNEL_39 ENERGY_PATTERN_2_4_FREQ_2454
+energy2400/output_power_test -12 0 3
+energy2400/duty_cycle_test 1 50 75
+energy2400/signal_indicator_test internal_brg brg0_rxtx_brg1_rxtx
+
+# ------------- energy_sub1g -------------
+energy_sub1g/pattern_test SUB1G_ENERGY_PATTERN_NO_ENERGIZING SUB1G_ENERGY_PATTERN_FCC_HOPPING SUB1G_ENERGY_PATTERN_SINGLE_TONE_917500 SUB1G_ENERGY_PATTERN_NZ_HOPPING
+energy_sub1g/duty_cycle_test 15 20 40 0
+energy_sub1g/signal_indicator_test 60,4
+
+# ------------- datapath -------------
+datapath/rssi_threshold_test -80
+datapath/pattern_test DATAPATH_PATTERN_38_38_39 DATAPATH_PATTERN_EU_PATTERN
+datapath/tx_repetition_test 2 4
+datapath/output_power_test -12 0 3
+datapath/pkt_filter_test PKT_FILTER_DISABLE_FORWARDING PKT_FILTER_TEMP_PKT
+datapath/pkt_filter_gen3_test PKT_FILTER_DISABLE_FORWARDING PKT_FILTER_TEMP_PKT
+datapath/pkt_filter_ble5_test PKT_FILTER_DISABLE_FORWARDING PKT_FILTER_TEMP_PKT
+datapath/rx_channel_test RX_CHANNEL_37 RX_CHANNEL_38 RX_CHANNEL_10_250K RX_CHANNEL_10_500K
+datapath/num_of_tags_test 500
+datapath/stress_gen3_test rep1_adaptive_pacer 
+
+
+# ------------- calibration -------------
+calibration/output_power_test -12 0 3
+calibration/interval_test 1 25 50
+calibration/pattern_test CALIBRATION_PATTERN_38_38_39 CALIBRATION_PATTERN_DISABLE_BEACON

brg_certificate/certificate_test_list.txt

@@ -0,0 +1,43 @@
+# The certificate should run for every bridge change
+# The setup will include 1 tested BRG + 1 GW connected with UART
+# Run command example:
+# python ut.py --gw SIM --brg <XXXXXXXXXXXX> --tl certificate_test_list.txt --data sim --port <COM_PORT>
+
+# ------------- edge_mgmt -------------
+edge_mgmt/stat_test
+edge_mgmt/actions_test ACTION_GW_HB ACTION_BLINK ACTION_SEND_HB ACTION_GET_BATTERY_SENSOR ACTION_GET_POF_DATA ACTION_PL_STATUS ACTION_GET_MODULE ACTION_REBOOT ACTION_RESTORE_DEFAULTS
+
+# ------------- energy2400 -------------
+energy2400/pattern_test ENERGY_PATTERN_2_4_NO_ENERGIZING ENERGY_PATTERN_2_4_CHANNEL_37 ENERGY_PATTERN_2_4_CHANNEL_38 ENERGY_PATTERN_2_4_CHANNEL_39 ENERGY_PATTERN_2_4_FREQ_2450 ENERGY_PATTERN_2_4_FREQ_2454
+energy2400/output_power_test -12 -8 -4 0 2 3
+energy2400/duty_cycle_test 1 25 50 75
+energy2400/signal_indicator_test internal_brg rssi_threshold brg0_rx_brg1_tx brg0_none_brg1_rx brg0_rxtx_brg1_rxtx brg0_tx_brg1_none
+
+# ------------- energy_sub1g -------------
+energy_sub1g/pattern_test SUB1G_ENERGY_PATTERN_NO_ENERGIZING SUB1G_ENERGY_PATTERN_SINGLE_TONE_915000 SUB1G_ENERGY_PATTERN_FCC_HOPPING SUB1G_ENERGY_PATTERN_SINGLE_TONE_917500 SUB1G_ENERGY_PATTERN_NZ_HOPPING
+energy_sub1g/duty_cycle_test 15 20 40 0
+energy_sub1g/signal_indicator_test 60,4 100,3
+
+# ------------- datapath -------------
+datapath/rssi_threshold_test -80 -65 -10
+datapath/pattern_test DATAPATH_PATTERN_38_38_39 DATAPATH_PATTERN_EU_PATTERN
+datapath/tx_repetition_test 2 4
+datapath/output_power_test -12 -8 -4 0 2 3
+datapath/pacer_interval_test 5 15 30 60
+datapath/pacer_interval_ble5_test 5 15 30 60
+datapath/pkt_filter_test PKT_FILTER_RANDOM_FIRST_ARRIVING_PKT PKT_FILTER_DISABLE_FORWARDING PKT_FILTER_TEMP_PKT PKT_FILTER_ADVANCED_PKT PKT_FILTER_TEMP_AND_ADVANCED_PKTS PKT_FILTER_TEMP_ADVANCED_AND_DEBUG_PKTS
+datapath/pkt_filter_gen3_test PKT_FILTER_RANDOM_FIRST_ARRIVING_PKT PKT_FILTER_DISABLE_FORWARDING PKT_FILTER_TEMP_PKT PKT_FILTER_ADVANCED_PKT PKT_FILTER_TEMP_AND_ADVANCED_PKTS
+datapath/pkt_filter_ble5_test PKT_FILTER_RANDOM_FIRST_ARRIVING_PKT PKT_FILTER_DISABLE_FORWARDING PKT_FILTER_TEMP_PKT PKT_FILTER_ADVANCED_PKT PKT_FILTER_TEMP_AND_ADVANCED_PKTS
+datapath/rx_channel_test RX_CHANNEL_37 RX_CHANNEL_38 RX_CHANNEL_39 RX_CHANNEL_10_250K RX_CHANNEL_10_500K
+datapath/rx_rate_gen2_test mid_values diff_pacer min_value max_value  diff_rate
+datapath/rx_rate_gen3_test mid_values diff_pacer min_value max_value  diff_rate
+datapath/num_of_tags_test 2500
+datapath/pacer_interval_tags_count_test 1 10 15 30
+datapath/stress_test rep3 rep2 rep1 rep1_adaptive_pacer pixel_burst
+datapath/stress_gen3_test rep3 rep2 rep1 rep1_adaptive_pacer pixel_burst
+
+# ------------- calibration -------------
+calibration/output_power_test -12 -8 -4 0 2 3
+calibration/interval_test 1 25 50
+calibration/pattern_test CALIBRATION_PATTERN_38_38_39 CALIBRATION_PATTERN_STANDARD CALIBRATION_PATTERN_EU_PATTERN CALIBRATION_PATTERN_DISABLE_BEACON
+

brg_certificate/config/eclipse.json

@@ -0,0 +1,10 @@
+{
+    "customBroker" : true,
+    "port" : 8883,
+    "brokerUrl" : "mqtts://mqtt.eclipseprojects.io", 
+    "username" : "",
+    "password" : "",
+    "updateTopic" : "update-test/wiliot/",
+    "statusTopic" : "status-test/wiliot/",
+    "dataTopic" : "data-test/wiliot/"
+}

brg_certificate/config/hivemq.json

@@ -0,0 +1,10 @@
+{
+    "customBroker" : true,
+    "port" : 8883,
+    "brokerUrl" : "mqtts://broker.hivemq.com",
+    "username" : "",
+    "password" : "",
+    "updateTopic" : "update-test/wiliot/",
+    "statusTopic" : "status-test/wiliot/",
+    "dataTopic" : "data-test/wiliot/"
+}

brg_certificate/config/mosquitto.json

@@ -0,0 +1,10 @@
+{
+    "customBroker" : true,
+    "port" : 1883,
+    "brokerUrl" : "mqtts://localhost",
+    "username" : "",
+    "password" : "",
+    "updateTopic" : "update-test/wiliot/",
+    "statusTopic" : "status-test/wiliot/",
+    "dataTopic" : "data-test/wiliot/"
+}

brg_certificate/config/mosquitto.md

@@ -0,0 +1,95 @@
+
+## Downloading and Running a Mosquitto MQTT Broker Locally
+
+This guide will walk you through the process of downloading and running the Mosquitto MQTT broker on your local machine.
+
+__Step 1:__ Download Mosquitto
+
+For Windows:
+1. Visit the Mosquitto website download page: https://mosquitto.org/download/
+2. Download the latest Windows installer (mosquitto-{version}-install-windows-x64.exe).
+3. Run the installer and follow the installation steps.
+   - <strong style="color:red">IMPORTANT NOTE:</strong> Make sure to check the option to add Mosquitto to your system's PATH during installation!
+4. The default installation path is C:\Program Files\mosquitto.
+
+For Linux (Ubuntu/Debian):
+1. Open the terminal.
+2. Run the following commands to install Mosquitto and the client utilities:
+   ```bash
+   sudo apt update
+   sudo apt install mosquitto mosquitto-clients
+   ```
+
+For macOS:
+1. Install Homebrew if you don’t have it by running:
+   ```bash
+   /bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)"
+   ```
+2. Run the following command to install Mosquitto:
+   ```bash
+   brew install mosquitto
+   ```
+
+__Step 2:__ Start the Mosquitto Broker
+
+For Windows:
+1. Open the Command Prompt or PowerShell.
+2. Navigate to the Mosquitto installation folder, if it’s not added to your PATH:
+   ```bash
+   cd "C:\Program Files\mosquitto"
+   ```
+3. Run the Mosquitto broker:
+   ```bash
+   mosquitto
+   ```
+
+For Linux (Ubuntu/Debian):
+1. Start the Mosquitto service:
+   ```bash
+   sudo systemctl start mosquitto
+   ```
+   Or, to run it manually for testing:
+   ```bash
+   mosquitto -v
+   ```
+
+For macOS:
+1. Start Mosquitto using the terminal:
+   ```bash
+   mosquitto -v
+   ```
+
+__Step 3:__ Test the Mosquitto Broker
+
+You can test the broker by publishing and subscribing to a topic.
+
+Open two terminal windows:
+
+1. In the first window (Subscriber):
+   ```bash
+   mosquitto_sub -t test/topic
+   ```
+
+2. In the second window (Publisher):
+   ```bash
+   mosquitto_pub -t test/topic -m "Hello, MQTT!"
+   ```
+
+If everything works correctly, you should see the message "Hello, MQTT!" in the subscriber window.
+
+__Step 4:__ Enable Mosquitto on Startup (Optional)
+
+For Linux (Ubuntu/Debian):
+To make Mosquitto start automatically on boot:
+```bash
+sudo systemctl enable mosquitto
+```
+
+__Step 5:__ Stop the Mosquitto Broker
+
+To stop the broker, use CTRL+C in the terminal where it’s running or stop the service:
+
+For Linux:
+```bash
+sudo systemctl stop mosquitto
+```

brg_certificate/config/wiliot-dev.json

@@ -0,0 +1,10 @@
+{
+    "customBroker" : true,
+    "port" : 8883,
+    "brokerUrl" : "mqtts://mqtt.us-east-2.dev.wiliot.cloud",
+    "username" : "wiliot",
+    "password" : "wiliot",
+    "updateTopic" : "update-test/wiliot/",
+    "statusTopic" : "status-test/wiliot/",
+    "dataTopic" : "data-test/wiliot/"
+}

brg_certificate/restore_brg.py

@@ -0,0 +1,59 @@
+import os
+import argparse
+import brg_certificate.cert_common as cert_common
+from brg_certificate.cert_utils import *
+
+os.system('')
+
+def main():
+
+    parser = argparse.ArgumentParser(description='Process some integers.')
+    parser.add_argument('--brg', '-b', required=True, help='Bridge id to restore')
+    parser.add_argument('--gw', '-g', required=True, help='GW id to use')
+    args = parser.parse_args()
+    utPrint(str(args.__dict__))
+
+    mqttc = cert_mqtt.mqttc_init(args.gw, data="sim")
+    brg = Bridge(args.brg)
+    test = WltTest("", args.gw, mqttc, brg0=brg, server="prod")
+
+    utPrint(SEP)
+    utPrint(f"Getting GW {args.gw} Information", "BLUE")
+    response = cert_common.get_gw_info(test)
+    if response == NO_RESPONSE:
+        error = f"ERROR: Didn't get response from {args.gw} !"
+        utPrint(error, "red")
+        sys.exit(-1)
+    else:
+        if ENTRIES in response[GW_INFO]:
+            test.protobuf = True
+
+    utPrint(SEP)
+    utPrint(f"Getting BRG {brg.id_str} interface pkt", "BLUE")
+    test, _ = cert_common.get_module_if_pkt(test)
+    if test.rc == TEST_PASSED:
+        utPrint("Success! Done!", "green")
+        sys.exit(0)
+    else:
+        error = f"ERROR: Didn't get ModuleIfV{test.active_brg.api_version} from BRG:{brg.id_str}!"
+        utPrint(error, "red")
+        # Send restore defaults for 16 seconds
+        test.rc = TEST_PASSED
+        print(f"\nSending {ag.ACTIONS_DICT[ag.ACTION_RESTORE_DEFAULTS]}{test.active_brg.api_version} for 16 seconds")
+        action_pkt = cert_config.get_default_brg_pkt(test, pkt_type=eval_pkt(f'{ag.ACTIONS_DICT[ag.ACTION_RESTORE_DEFAULTS]}{test.active_brg.api_version}'))
+        cert_config.gw_downlink(test, raw_tx_data=action_pkt.dump(), max_retries=cert_config.BLE5_MAX_RETRIES*2)
+
+        print("Waiting for 16*2 seconds broadcast + 30 seconds reboot!")
+        for _ in range(16*2 + 30):
+            print_update_wait(1)
+        test, _ = cert_common.get_module_if_pkt(test)
+        if test.rc == TEST_PASSED:
+            utPrint("Success! Done!", "green")
+            sys.exit(0)
+        else:
+            error = f"ERROR: Still Didn't get ModuleIfV{test.active_brg.api_version} from BRG:{brg.id_str}!"
+            utPrint(error, "red")
+            sys.exit(-1)
+
+if __name__ == "__main__":
+    main()

brg_certificate/tests/calibration/interval_test/interval_test.json

@@ -0,0 +1,13 @@
+{
+    "name": "interval_test",
+    "module": "calibration",
+    "purpose": "Test configuration for all supported calibration interval values",
+    "documentaion": "https://community.wiliot.com/customers/s/article/Wiliot-Network-Calibration-Module",
+    "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": [1, 25, 50, 100, 255]
+}

brg_certificate/tests/calibration/interval_test/interval_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_CALIB_INTERVAL]
+    calib_module = eval_pkt(f'ModuleCalibrationV{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=calib_module)[0]
+        # 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, modules=[calib_module])

brg_certificate/tests/calibration/output_power_test/output_power_test.json

@@ -0,0 +1,13 @@
+{
+    "name": "output_power_test",
+    "module": "calibration",
+    "purpose": "Test configuration for all supported calibration output power 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": ["OUTPUT_POWER_2_4_NEG_12", "OUTPUT_POWER_2_4_NEG_8", "OUTPUT_POWER_2_4_NEG_4", "OUTPUT_POWER_2_4_POS_0", "OUTPUT_POWER_2_4_POS_2", "OUTPUT_POWER_2_4_POS_3"]
+}

brg_certificate/tests/calibration/output_power_test/output_power_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_OUTPUT_POWER]
+    calib_module = eval_pkt(f'ModuleCalibrationV{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=calib_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=[calib_module])

brg_certificate/tests/calibration/pattern_test/pattern_test.json

@@ -0,0 +1,13 @@
+{
+    "name": "pattern_test",
+    "module": "calibration",
+    "purpose": "Test configuration for all supported calibration pattern values",
+    "documentaion": "<TEST_DOCUMENTATION_LINK>",
+    "initialCondition": "Bridge configured to defaults",
+    "procedure": ["Test prolog", "Configurations and received packets sanity check (for specific patterns)", "Test epilog and revert to defaults"],
+    "expectedOutcome": "All values configured successfully and packets received only on included channels. When configuring the brg to CALIBRATION_PATTERN_38_38_39 we configure the GW to rx channel 37 and make sure GW doesn't get any pixels",
+    "mandatory": 1,
+    "multiBridgeTest": 0,
+    "gwOnlyTest": 0,
+    "allSupportedValues": ["CALIBRATION_PATTERN_STANDARD", "CALIBRATION_PATTERN_38_38_39", "CALIBRATION_PATTERN_EU_PATTERN", "CALIBRATION_PATTERN_DISABLE_BEACON"]
+}

brg_certificate/tests/calibration/pattern_test/pattern_test.py

@@ -0,0 +1,70 @@
+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]
+    calib_module = eval_pkt(f'ModuleCalibrationV{test.active_brg.api_version}')
+    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:
+        if param.value == ag.CALIBRATION_PATTERN_38_38_39:
+            utPrint("\nCALIBRATION_PATTERN_38_38_39 was configured - checking the GW doesn't receive tag packets", "BLUE")
+            # Config internal_brg's rx_channel to CHANNEL_37
+            test = cert_config.internal_brg_configure(test, fields=[BRG_RX_CHANNEL], values=[ag.RX_CHANNEL_37], module=datapath_module)[0]
+            if test.rc == TEST_FAILED and test.exit_on_param_failure:
+                break
+            # Configure the BRG, wait=False
+            test = cert_config.brg_configure(test, fields=[BRG_PATTERN, BRG_CALIB_INTERVAL],
+                                             values=[param.value, 1], module=calib_module, wait=False)[0]
+            cert_common.wait_time_n_print(CLEAR_DATA_PATH_TIMEOUT)
+            # MQTT scan
+            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=10, duplicates=1, delay=100, pkt_types=[0])
+                pixel_sim_thread.start()
+            df = cert_common.data_scan(test, gw_data=True, brg_data=True, scan_time=(40))
+            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)
+
+            # Analyze pass/fail
+            gw_tags_pkts = len(df.query('src_id == gw_id'))
+            brg_tags_pkts = len(df.query('src_id != gw_id'))
+            print(f"Found gw_tags_pkts={gw_tags_pkts}, brg_tags_pkts={brg_tags_pkts}")
+            if (gw_tags_pkts == 0 and test.data == DATA_REAL_TAGS) or brg_tags_pkts != 0:
+                test.rc = TEST_FAILED
+                test.add_reason(f"gw_tags_pkts={gw_tags_pkts} brg_tags_pkts={brg_tags_pkts} for BRG 38,38,39 calibration, "
+                                "and GW scanning on ch 37")
+                break
+            # Revert internal_brg
+            test = cert_config.internal_brg_configure(test, 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()
+        else:
+            test = cert_config.brg_configure(test, fields=fields, values=[param.value], module=calib_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=[calib_module, datapath_module])

brg_certificate/tests/datapath/adaptive_pacer_algo_test/adaptive_pacer_algo_test.json

@@ -0,0 +1,13 @@
+{
+    "name": "adaptive_pacer_algo_test",
+    "module": "datapath",
+    "purpose": "Test the adaptive pacer algorithm",
+    "documentaion": "<TEST_DOCUMENTATION_LINK>",
+    "initialCondition": "Bridge configured to defaults",
+    "procedure": ["Test prolog", "Turn on adaptive pacer and configure bridge to encourage adaptive pacer algorithm activation", "Wait for tx repetition algorithm to work and then activate pacing algorithm", "Check effective pacer incrementation is stable", "Test actual tags pacing interval", "Test epilog and revert to defaults"],
+    "expectedOutcome": "All configurations completed successfully and adaptive pacing works as expected",
+    "mandatory": 0,
+    "multiBridgeTest": 0,
+    "gwOnlyTest": 0,
+    "allSupportedValues": []
+}

brg_certificate/tests/datapath/adaptive_pacer_algo_test/adaptive_pacer_algo_test.py

@@ -0,0 +1,76 @@
+# This test check for the algo of the adaptive pacer - run with 1 gw & 1 brg
+# In order to have a lot of stress on the BRG you best use ble sim with pacer_algo_test_pkts.csv
+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 effective_pacer_increment_highest_get(test):
+    cert_config.send_brg_action(test, ag.ACTION_SEND_HB)
+    test, mgmt_pkts = cert_common.scan_for_mgmt_pkts(test, [eval_pkt(f'Brg2GwHbV{test.active_brg.api_version}')])
+    highest = 0
+    if mgmt_pkts:
+        for p in mgmt_pkts:
+            if p[MGMT_PKT].pkt.effective_pacer_increment:
+                highest = p[MGMT_PKT].pkt.effective_pacer_increment if p[MGMT_PKT].pkt.effective_pacer_increment > highest else highest
+    return highest
+
+def run(test):
+
+    fields = [BRG_ADAPTIVE_PACER, BRG_PACER_INTERVAL, BRG_PKT_FILTER, BRG_TX_REPETITION]
+    values = [ag.ADAPTIVE_PACER_ON, 1, ag.PKT_FILTER_TEMP_ADVANCED_AND_DEBUG_PKTS, 1]
+    datapath_module = eval_pkt(f'ModuleDatapathV{test.active_brg.api_version}')
+    calib_module = eval_pkt(f'ModuleCalibrationV{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)
+
+    # Turn on adaptive pacer and set cfgs to help activating adaptive pacer algo
+    test = cert_config.brg_configure(test, fields=fields, values=values, module=datapath_module)[0]
+    if test.rc == TEST_FAILED or test.reason != TEST_SUCCESS:
+        return cert_common.test_epilog(test, revert_brgs=True, modules=[datapath_module])
+    test = cert_config.brg_configure(test, fields=[BRG_CALIB_INTERVAL], values=[30], module=calib_module)[0]
+    if test.rc == TEST_FAILED or test.reason != TEST_SUCCESS:
+        return cert_common.test_epilog(test, revert_brgs=True, modules=[calib_module])
+
+    # Wait for tx rep algo to work & then activate pacing algo
+    # Checking effective_pacer_increment every minute untill its
+    # stable for 3 mins to start checking tags actual pacing
+    effective_pacer_increment = False
+    last_incarement = 0
+    count = 0
+    for i in range(10):
+        effective_pacer_increment = effective_pacer_increment_highest_get(test)
+        print(f"Current eff_pacer_increment = {effective_pacer_increment}, i = {i}")
+
+        if effective_pacer_increment == 0:
+            if i == 10:
+                test.rc == TEST_FAILED
+                test.add_reason("The effective_pacer_increment is 0 after 10 minutes")
+                return cert_common.test_epilog(test)
+            cert_common.wait_time_n_print(15)
+            continue
+
+        if last_incarement == effective_pacer_increment:
+            count += 1
+            if count == 3:
+                break
+        else:
+            last_incarement = effective_pacer_increment
+
+    if count != 3:
+        test.rc == TEST_FAILED
+        test.add_reason("The effective_pacer_increment havn't been stable for 10 minutes")
+        return cert_common.test_epilog(test)
+
+    df = cert_common.data_scan(test, scan_time=60, brg_data=(not test.internal_brg), gw_data=test.internal_brg)
+    cert_mqtt.dump_pkts(test, log=str(values))
+    cert_common.display_data(df, nfpkt=True, pkt_cntr_diff=True, cer_per_tag=True, name_prefix=test.module_name, dir=test.dir)
+
+    test = cert_common.pacing_analysis(test, df=df, pacer_interval=1+effective_pacer_increment)
+    if test.rc == TEST_FAILED or test.reason != TEST_SUCCESS:
+        return cert_common.test_epilog(test, revert_brgs=True, modules=[datapath_module, calib_module])
+
+    return cert_common.test_epilog(test, revert_brgs=True, modules=[datapath_module, calib_module])

brg_certificate/tests/datapath/num_of_tags_test/num_of_tags_test.json

@@ -0,0 +1,13 @@
+{
+    "name": "num_of_tags_test",
+    "module": "datapath",
+    "purpose": "Test pixels handling in the bridge for different amount of pixels",
+    "documentaion": "<TEST_DOCUMENTATION_LINK>",
+    "initialCondition": "Bridge & data simulator configured to defaults",
+    "procedure": ["Test prolog", "Generate packets from the given amount of pixels & scan for packets in the bridge", "Compare received amount of pixels and the heartbeat pixels counter to the given value","Repeat for all given pixels amounts", "Test epilog and revert to defaults"],
+    "expectedOutcome": "All values configured successfully",
+    "mandatory": 1,
+    "multiBridgeTest": 0,
+    "gwOnlyTest": 0,
+    "allSupportedValues": [500, 1000, 2500]
+}

brg_certificate/tests/datapath/num_of_tags_test/num_of_tags_test.py

@@ -0,0 +1,83 @@
+
+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
+
+GW_CYCLE_TIME = 0.02 # GW sends BLE packet every 20 nsec
+
+def run(test):
+    
+    datapath_module = eval_pkt(f'ModuleDatapathV{test.active_brg.api_version}')
+    print(f"values: {[param.value for param in test.params]}")
+
+    test = cert_common.test_prolog(test)
+    if test.rc == TEST_FAILED or test.reason != TEST_SUCCESS:
+        return cert_common.test_epilog(test)
+
+    duplicates = 3
+
+    for param in test.params:
+
+        # The time it takes to send two cycles from the GW/DataSimThread
+        time_of_sending_pkts = duplicates * param.value * GW_CYCLE_TIME * 2
+
+        test = cert_config.brg_configure(test, fields=[BRG_PACER_INTERVAL], values=[time_of_sending_pkts], module=datapath_module)[0]
+        if test.rc == TEST_FAILED and test.reason != TEST_SUCCESS:
+            return cert_common.test_epilog(test)
+    
+
+        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=param.value, duplicates=duplicates, delay=0, pkt_types=[0])
+            pixel_sim_thread.start()
+
+        df = cert_common.data_scan(test, scan_time=time_of_sending_pkts+5, 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(10)
+
+        cert_common.display_data(df, nfpkt=True, name_prefix=f"num_of_tags_{param.name}_", dir=test.dir)
+
+        num_of_tags = len(df[TAG_ID].unique())
+        print(f"Tags from DF: {num_of_tags}")
+
+        cert_config.send_brg_action(test, ag.ACTION_SEND_HB)
+        test, mgmt_pkts = cert_common.scan_for_mgmt_pkts(test, [eval_pkt(f'Brg2GwHbV{test.active_brg.api_version}')])
+        if not mgmt_pkts:
+            test.rc = TEST_FAILED
+            test.add_reason("Didn't find ACTION HB pkt")
+            break
+
+        num_of_tags_HB = mgmt_pkts[0][MGMT_PKT].pkt.tags_ctr
+        print(f"Tags from HB: {num_of_tags_HB}\n ")
+
+        cert_common.display_data(df, nfpkt=True, name_prefix=f"num_of_tags_{param.name}_", dir=test.dir)
+
+        # compare the numbers of tags that come from the brg, success in 95% from number of tags (value) or more. 
+        if num_of_tags < (param.value*0.95):
+            test.rc = TEST_FAILED
+            test.add_reason(f"Found {num_of_tags} pixels instead of {param.name} pixels!")
+            test.add_reason(f"Note - HB was {num_of_tags_HB}")
+            
+        # compare the counter tags in the HB packet 
+        if  num_of_tags_HB < param.value or num_of_tags_HB > (param.value + 100):
+            test.rc = TEST_FAILED
+            test.add_reason(f"pixels counter in HB packet is  {num_of_tags_HB} instead of {param.name} pixels!")
+            test.add_reason(f"Note - tag counter field = {num_of_tags}")
+
+        # param epilog
+        time.sleep(10)
+        generate_log_file(test, param.name)
+        field_functionality_pass_fail_print(test, "num_of_tags", 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)

brg_certificate/tests/datapath/output_power_test/output_power_test.json

@@ -0,0 +1,13 @@
+{
+    "name": "output_power_test",
+    "module": "datapath",
+    "purpose": "Test configuration for all supported datapath output power 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": [-12, -8, -4, 0, 2, 3]
+}