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

brg_certificate/tests/edge_mgmt/leds_test/leds_test.py

@@ -0,0 +1,210 @@
+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
+
+# Tests definitions
+BRG_REBOOT_TIME = 30
+NUM_OF_LED_BLINKS_ACTION = 10
+LEDS_KEEP_ALIVE_PERIOD = 10
+LEDS_KEEP_ALIVE_BLINKS_NUM = 2
+ENERGIZING_LED_COLOR = "RED"
+BOARD_TYPE_2_ECHOING_LED_COLLOR_DICT = {ag.BOARD_TYPE_FANSTEL_SINGLE_BAND_V0: "Green",
+                                        ag.BOARD_TYPE_FANSTEL_DUAL_BAND_V0: "Green",
+                                        ag.BOARD_TYPE_MINEW_SINGLE_BAND_V0: "Green",
+                                        ag.BOARD_TYPE_MINEW_DUAL_BAND_V0: "Blue",
+                                        ag.BOARD_TYPE_ENERGOUS_V0: "Blue",
+                                        ag.BOARD_TYPE_ENERGOUS_V1: "Blue",
+                                        ag.BOARD_TYPE_ENERGOUS_V2: "Blue",
+                                        ag.BOARD_TYPE_ENERGOUS_V3: "Blue",
+                                        ag.BOARD_TYPE_ENERGOUS_V4: "Blue",
+                                        ag.BOARD_TYPE_ERM_V0: "Blue",
+                                        ag.BOARD_TYPE_ERM_V1: "Blue",
+                                        ag.BOARD_TYPE_KOAMTAC_V0: "Green",
+                                        ag.BOARD_TYPE_MINEW_POE_V0: "Yellow"}
+
+
+# Helper functions
+def compare_versions(gw_version, brg_version):
+    # Split versions into components
+    gw_version_parts = gw_version.split('.')
+    brg_version_parts = brg_version.split('.')
+
+    # Compare each component
+    if (len(gw_version_parts) == 3 and len(brg_version_parts) == 3 and
+            gw_version_parts[0] == brg_version_parts[0] and
+            gw_version_parts[1] == brg_version_parts[1] and
+            gw_version_parts[2] == brg_version_parts[2]):
+        return True
+    else:
+        return False
+
+
+def run(test):
+    test = cert_common.test_prolog(test)
+    if test.rc == TEST_FAILED or test.reason != TEST_SUCCESS:
+        return cert_common.test_epilog(test)
+
+    test.mqttc.flush_pkts()
+    # --------------------- Pre stage ------------------------------ #
+    utPrint("Pre state - Please make sure you have a registerd GW connected to the UT BRG!!!", "WARNING")
+    utPrint("Press 'y' if the GW is registered and connected to the UT BRG", "BLUE")
+    value = cert_common.check_input_n_try_again(input())
+    test = cert_common.value_check_if_y(test, value, "PRE STAGE")
+    if test.rc == TEST_FAILED and test.exit_on_param_failure:
+        return cert_common.test_epilog(test)
+    utPrint("GW is registered and connected to UT BRG!", "GREEN")
+
+    # Determine LED colors according to the board type
+    test, interface = cert_common.get_module_if_pkt(test)
+    if test.rc == TEST_FAILED:
+        utPrint("Failed to get the GW interface packet!", "RED")
+        return cert_common.test_epilog(test)
+    board_type = interface.board_type
+    if board_type not in BOARD_TYPE_2_ECHOING_LED_COLLOR_DICT:
+        utPrint(f"Unknown board type: {board_type}", "RED")
+        return cert_common.test_epilog(test)
+    else:
+        ECHOING_LED_COLOR = BOARD_TYPE_2_ECHOING_LED_COLLOR_DICT[board_type]
+    if board_type == ag.BOARD_TYPE_MINEW_POE_V0:
+        NUS_INDICATION_LED_COLOR = "Green"
+    else:
+        NUS_INDICATION_LED_COLOR = ECHOING_LED_COLOR
+
+    # Version verification
+    gw_ble_version = test.gw_orig_versions.get(BLE_VERSION)
+    bridge_ble_version = test.active_brg.version
+    if gw_ble_version and bridge_ble_version:
+        if compare_versions(gw_ble_version, bridge_ble_version) is False:
+            utPrint("Versions are not alligned - Please make sure the BLE versions are the same", "RED")
+            return cert_common.test_epilog(test)
+        else:
+            utPrint("GW & BRG versions are the same - Pre stage Passed!", "GREEN")
+    else:
+        utPrint("Failed to get the BLE versions, please try again!", "RED")
+        return cert_common.test_epilog(test)
+
+    utPrint("Starting examining the LED's, Please pay attention to the following steps!", "WARNING")
+    # ---------------------  Advertising LED  --------------------- #
+    utPrint("Advertising LED check - sending Reboot action to BRG!", "HEADER")
+    cert_config.send_brg_action(test, ag.ACTION_REBOOT)
+    reboot_start_ts = int(datetime.datetime.now().timestamp())
+    utPrint(f"The BRG was rebooted - is the advertising LED ({NUS_INDICATION_LED_COLOR}) continuously "
+            "on and all other LED's are off? (Y/N)", "BLUE")
+    value = cert_common.check_input_n_try_again(input())
+    test = cert_common.value_check_if_y(test, value, "Advertising LED check")
+    if test.rc == TEST_FAILED and test.exit_on_param_failure:
+        return cert_common.test_epilog(test)
+    # wait for advertisement phase to finish
+    if (int(datetime.datetime.now().timestamp()) - reboot_start_ts < BRG_REBOOT_TIME):
+        utPrint(f"Now we'll wait for the BRG to finish his {BRG_REBOOT_TIME} advertismeent!", "BLUE")
+        cert_common.wait_time_n_print(BRG_REBOOT_TIME - (int(datetime.datetime.now().timestamp()) - reboot_start_ts))
+    utPrint("Advertisement LED check completed!\n", "GREEN")
+
+    # ------------------  Eenergizing LED check  ------------------ #
+    #  Energizing is ON (Non default for SUB1G, but for UT purposses we'll set it to ON)
+    utPrint("Energizing LED check!", "HEADER")
+    utPrint(f"Is the Energizing LED ({ENERGIZING_LED_COLOR}) on? (Y/N)", "BLUE")
+    value = cert_common.check_input_n_try_again(input())
+    test = cert_common.value_check_if_y(test, value, "Eenergizing LED check")
+    if test.rc == TEST_FAILED and test.exit_on_param_failure:
+        return cert_common.test_epilog(test)
+
+    # Energizing is OFF
+    #  Default cfg for 2400 is 0 == no energizing so we only eliminating sub1g energizing
+    utPrint("Configuring the BRG to no energizing in sub1g", "WARNING")
+    sub1g_module = eval(f'ModuleEnergySub1GV{test.active_brg.api_version}')
+    test = cert_config.brg_configure(test, fields=[BRG_PATTERN], values=[ag.SUB1G_ENERGY_PATTERN_NO_ENERGIZING], module=sub1g_module)[0]
+    if test.rc == TEST_FAILED and test.exit_on_param_failure:
+        return cert_common.test_epilog(test, revert_brgs=True, modules=[sub1g_module])
+    utPrint(f"wait a few seconds for the change to apply - Is the Energizing LED ({ENERGIZING_LED_COLOR}) off? (Y/N)", "BLUE")
+    value = cert_common.check_input_n_try_again(input())
+    test = cert_common.value_check_if_y(test, value, "Eenergizing LED check")
+    if test.rc == TEST_FAILED and test.exit_on_param_failure:
+        return cert_common.test_epilog(test, revert_brgs=True, modules=[sub1g_module])
+    utPrint("Energizing LED check completed!\n", "GREEN")
+
+    # ------------------- Echo LED check -------------------------- #
+    utPrint("Echoing LED check!", "HEADER")
+    utPrint("Please make sure you have tags around you before answering!", "WARNING")
+    utPrint(f"Is the Echoing LED ({ECHOING_LED_COLOR}) blinking? (Y/N)", "BLUE")
+    value = cert_common.check_input_n_try_again(input())
+    test = cert_common.value_check_if_y(test, value, "Echoing LED check")
+    if test.rc == TEST_FAILED and test.exit_on_param_failure:
+        return cert_common.test_epilog(test)
+    utPrint("Echoing LED check completed!\n", "GREEN")
+
+    # ---------------- LEDS_KEEP_ALIVE_PERIOD_CHECK --------------- #
+    utPrint("LEDS_KEEP_ALIVE_PERIOD check!", "HEADER")
+    utPrint("Please remove all tags from the bridge surrounding for this check!", "WARNING")
+    utPrint(f"Look at the LEDS - Are both LED's off except for {LEDS_KEEP_ALIVE_BLINKS_NUM} blinks \n"
+            f"of the Echoing LED ({ECHOING_LED_COLOR}) every {LEDS_KEEP_ALIVE_PERIOD} seconds? (Y/N)", "BLUE")
+    value = cert_common.check_input_n_try_again(input())
+    test = cert_common.value_check_if_y(test, value, "LEDS_KEEP_ALIVE_PERIOD check")
+    if test.rc == TEST_FAILED and test.exit_on_param_failure:
+        return cert_common.test_epilog(test, revert_brgs=True, modules=[sub1g_module])
+    utPrint("LEDS_KEEP_ALIVE_PERIOD check completed! - please restore the tags to position around the bridge\n", "GREEN")
+
+    # Revert to default
+    utPrint("Reverting the BRG to default configuration", "WARNING")
+    test = cert_config.config_brg_defaults(test, modules=[sub1g_module])[0]
+    if test.rc == TEST_FAILED and test.exit_on_param_failure:
+        return cert_common.test_epilog(test, revert_brgs=True, modules=[sub1g_module])
+    utPrint(f"wait a few seconds for the change to apply - Is the Energizing LED ({ENERGIZING_LED_COLOR}) back on \n"
+            f" and the Echoing LED ({ECHOING_LED_COLOR}) blinking? (Y/N)", "BLUE")
+    value = cert_common.check_input_n_try_again(input())
+    test = cert_common.value_check_if_y(test, value, "Eenergizing LED check")
+    if test.rc == TEST_FAILED and test.exit_on_param_failure:
+        return cert_common.test_epilog(test, revert_brgs=True, modules=[sub1g_module])
+    utPrint("Succesfully Reverted the BRG to default configuration!\n", "GREEN")
+
+    # -----------------------  Blink check  ----------------------- #
+    utPrint("Blink action check - pay attention to the LED's", "HEADER")
+    cert_config.send_brg_action(test, ag.ACTION_BLINK)
+    if board_type == ag.BOARD_TYPE_MINEW_POE_V0:
+        utPrint(f"wait a few seconds for the action to apply - "
+                f"Did you see all 4 LED's blink {NUM_OF_LED_BLINKS_ACTION} times? (Y/N)", "BLUE")
+    else:
+        utPrint(f"wait a few seconds for the action to apply - "
+                f"Did you see both LED's blink {NUM_OF_LED_BLINKS_ACTION} times? (Y/N)", "BLUE")
+    value = cert_common.check_input_n_try_again(input())
+    test = cert_common.value_check_if_y(test, value, "Blink check")
+    if test.rc == TEST_FAILED and test.exit_on_param_failure:
+        return cert_common.test_epilog(test)
+    utPrint("Blink action check completed!\n", "GREEN")
+
+    # ------------- Power management sleep & Keep Alive Mode ------------- #
+    utPrint("Power management Sleep state & Keep Alive Mode check!", "HEADER")
+    utPrint("Sending the BRG power management configuration in order to enter sleep state", "WARNING")
+    pwr_mgmt_module = eval(f'ModulePwrMgmtV{test.active_brg.api_version}')
+    test, wltpkt = cert_common.brg_pwr_mgmt_turn_on(test)
+    if test.rc == TEST_FAILED and test.exit_on_param_failure:
+        # Preventing leaving brg in pwr mgmt, protection for on that worked yet no ack was received
+        test = cert_common.brg_pwr_mgmt_turn_off(test)
+        return cert_common.test_epilog(test, revert_brgs=True, modules=[pwr_mgmt_module])
+    utPrint("pwr mgmt static mode turned on!", "GREEN")
+    utPrint("Waiting for on_duration to expire!", "BLUE")
+    cert_common.wait_time_n_print(wltpkt.pkt.static_on_duration)
+    sleep_state_start_ts = int(datetime.datetime.now().timestamp())
+    utPrint("Now we'll check sleep_Keep_Alive state blink .\n", "WARNING")
+    utPrint(f"look ath the LEDS - Are all leds off, besides 1 blink ({wltpkt.pkt.static_keep_alive_scan} msec period) of the \n"
+            f"Echoing LED ({ECHOING_LED_COLOR}) every {wltpkt.pkt.static_keep_alive_period} seconds? (Y/N)", "BLUE")
+    value = cert_common.check_input_n_try_again(input())
+    test = cert_common.value_check_if_y(test, value, "Sleep Keep Alive mode check")
+    if test.rc == TEST_FAILED and test.exit_on_param_failure:
+        return cert_common.test_epilog(test, revert_brgs=True, modules=[pwr_mgmt_module])
+    # wait for sleep_duration to expire to revert the bridge to defualt configuration
+    if wltpkt.pkt.static_sleep_duration - (int(datetime.datetime.now().timestamp()) - sleep_state_start_ts) > 0:
+        utPrint("Waiting for sleep_duration to expire", "BLUE")
+        cert_common.wait_time_n_print(wltpkt.pkt.static_sleep_duration - (int(datetime.datetime.now().timestamp()) - sleep_state_start_ts))
+    # Revert to default
+    test = cert_common.brg_pwr_mgmt_turn_off(test)
+    if test.rc == TEST_FAILED and test.exit_on_param_failure:
+        test = cert_common.brg_pwr_mgmt_turn_off(test)
+        return cert_common.test_epilog(test, revert_brgs=True, modules=[pwr_mgmt_module])
+    utPrint("Keep Alive Mode check completed!", "GREEN")
+
+    # ---------------------  Post stage ----------------------------- #
+    utPrint("Test is completed, Good job!!!", "GREEN")
+    return cert_common.test_epilog(test)

brg_certificate/tests/edge_mgmt/ota_test/ota_test.json

@@ -0,0 +1,13 @@
+{
+    "name": "ota_test",
+    "module": "edge_mgmt",
+    "purpose": "TODO",
+    "documentaion": "<TEST_DOCUMENTATION_LINK>",
+    "initialCondition": "TODO",
+    "procedure": ["Test prolog", "TODO", "Test epilog"],
+    "expectedOutcome": "TODO",
+    "mandatory": 0,
+    "multiBridgeTest": 0,
+    "gwOnlyTest": 0,
+    "allSupportedValues": []
+}

brg_certificate/tests/edge_mgmt/ota_test/ota_test.py

@@ -0,0 +1,83 @@
+from brg_certificate.cert_prints import *
+from brg_certificate.cert_defines import *
+import brg_certificate.cert_common as cert_common
+import brg_certificate.cert_config as cert_config
+import brg_certificate.cert_utils as cert_utils
+import datetime
+import tabulate
+
+# Index 0 = stage name Index 1 = value log to find
+BRG_OTA_LOGS = {
+    "got ota action": "Got OTA action request for BRG",
+    "file download finish dat": "Downloaded files to /sd_images/ble_image_dat_file successfully",
+    "dat file open": "file opening /sd_images/ble_image_dat_file success",
+    "dat file transfer finish": "BRG_OTA_FILE_TRANSFER_FINISH",
+    "file download finish bin": "Downloaded files to /sd_images/ble_image_bin_file successfully",
+    "bin file open": "file opening /sd_images/ble_image_bin_file success",
+    "bin file transfer finish": "BRG_OTA_FILE_TRANSFER_FINISH",
+    "start brg ota": "Starting OTA to BRG",
+    "finish brg ota": "BRG OTA finished with status",
+}
+
+
+def get_ts_from_log(log):
+    ts_end = log.find(']')
+    ts_str = log[1:ts_end]
+    # Convers from ms to sec
+    return int(ts_str) / 1000
+
+
+# Prints the time each step individually for regression & follow up purposes
+def breakdown_steps_timing(test, start_ts):
+    # timing data [step, is_found, time from start, stage timing]
+    timing_data = []
+    last_ts = start_ts
+
+    # Collect data
+    for step, log in BRG_OTA_LOGS.items():
+        found = []
+        suffix = "(dat)" if step.startswith("dat") else "(bin)" if step.startswith("bin") else ""
+        test, res, found = cert_common.single_log_search(test, log, found, fail_on_find=False, print_logs=False, additional_log=suffix)
+        time_from_start = -100  # invalid
+        step_time = -100  # invalid
+        if res:
+            found_ts = get_ts_from_log(found[0])
+            time_from_start = found_ts - start_ts
+            step_time = found_ts - last_ts
+            last_ts = found_ts
+        timing_data.append([step, res, round(time_from_start, 1), round(step_time, 1)])
+
+    # Create table
+    headers = ["Step", "Log Found", "Time From Start (secs)", "Step Time (secs)"]
+    print(tabulate.tabulate(tabular_data=timing_data, headers=headers, tablefmt="fancy_grid"))
+
+
+def run(test):
+
+    test = cert_common.test_prolog(test)
+    if test.rc == TEST_FAILED or test.reason != TEST_SUCCESS:
+        return cert_common.test_epilog(test, revert_brgs=True)
+
+    versions_mgmt = cert_utils.load_module('versions_mgmt.py', f'{UTILS_BASE_REL_PATH}/versions_mgmt.py')
+    if test.latest:
+        _, version = versions_mgmt.get_versions(env='aws', server='test', ci=True)
+    elif test.release_candidate:
+        _, version = versions_mgmt.get_versions(env='aws', server='test', rc=True)
+    else:
+        test.rc = TEST_FAILED
+        test.reason = NO_PARAMS_GIVEN
+        print(NO_PARAMS_GIVEN)
+
+    #  check for problems in prolog
+    if test.rc == TEST_FAILED or not version:
+        test = cert_common.test_epilog(test)
+        return test
+
+    start_time = datetime.datetime.now()
+    test = cert_config.brg_ota(test, gw_ble_version=version)
+    generate_log_file(test, f"brg_ota_{version}")
+
+    if test.rc == TEST_PASSED and WANTED_VER_SAME not in test.reason:
+        breakdown_steps_timing(test, start_time.timestamp())
+
+    return cert_common.test_epilog(test)

brg_certificate/tests/edge_mgmt/stat_test/stat_test.json

@@ -0,0 +1,13 @@
+{
+    "name": "stat_test",
+    "module": "edge_mgmt",
+    "purpose": "Test static packets (heartbeat and interface) sent from the bridge",
+    "documentaion": "<TEST_DOCUMENTATION_LINK>",
+    "initialCondition": "Bridge configured to defaults",
+    "procedure": ["Test prolog", "Scan for heartbeat and interface packets", "Test epilog"],
+    "expectedOutcome": "Both heartbeat and interface packets received from the bridge within 65 seconds",
+    "mandatory": 1,
+    "multiBridgeTest": 0,
+    "gwOnlyTest": 0,
+    "allSupportedValues": []
+}

brg_certificate/tests/edge_mgmt/stat_test/stat_test.py

@@ -0,0 +1,48 @@
+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
+
+BRG_STAT_SCAN_TIMEOUT = 65
+
+
+def scan_for_brg_stat(test, timeout=BRG_STAT_SCAN_TIMEOUT, only_hb=False):
+    # In case we want to look for HB pkts only - set all modules to be True --> as if there are alredy found
+    found = {HB: False, MODULE_IF: False}
+    if only_hb is True:
+        for pkt_type in found:
+            if pkt_type != HB:
+                found[pkt_type] = True
+    else:  # flash pkts if only_hb=False
+        test.mqttc.flush_pkts()
+
+    start_time = datetime.datetime.now()
+    # Search for packets
+    while not all(found.values()):
+        if (cert_mqtt.get_brg2gw_mgmt_pkts(test.mqttc, test, mgmt_types=[eval_pkt(f'Brg2GwHbV{test.active_brg.api_version}')]) and
+                not found[HB]):
+            found[HB] = True
+            print(f"Got HB packet after {(datetime.datetime.now() - start_time).seconds} sec!")
+        if (cert_mqtt.get_brg2gw_mgmt_pkts(test.mqttc, test, mgmt_types=[eval_pkt(f'ModuleIfV{test.active_brg.api_version}')]) and
+                not found[MODULE_IF]):
+            found[MODULE_IF] = True
+            print(f"Got interface module packet after {(datetime.datetime.now() - start_time).seconds} sec!")
+        print_update_wait()
+        if (datetime.datetime.now() - start_time).seconds > timeout:
+            test.rc = TEST_FAILED
+            err_print = f"{'HB' if not found[HB] else ''} {'MODULE_IF' if not found[MODULE_IF] else ''}"
+            test.add_reason(f"Didn't receive {err_print} pkt after {timeout} seconds!")
+            break
+    return test
+
+
+def run(test):
+
+    test = cert_common.test_prolog(test)
+    if test.rc == TEST_FAILED or test.reason != TEST_SUCCESS:
+        return cert_common.test_epilog(test)
+
+    test = scan_for_brg_stat(test)
+    generate_log_file(test, "stat")
+
+    return cert_common.test_epilog(test)

brg_certificate/tests/energy2400/duty_cycle_test/duty_cycle_test.json

@@ -0,0 +1,13 @@
+{
+    "name": "duty_cycle_test",
+    "module": "energy2400",
+    "purpose": "Test configuration for supported energy2400 duty cycle 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": [1, 25, 50, 75]
+}

brg_certificate/tests/energy2400/duty_cycle_test/duty_cycle_test.py

@@ -0,0 +1,26 @@
+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_DUTY_CYCLE]
+    energy2400_module = eval_pkt(f'ModuleEnergy2400V{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=energy2400_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=[energy2400_module])

brg_certificate/tests/energy2400/output_power_test/output_power_test.json

@@ -0,0 +1,13 @@
+{
+    "name": "output_power_test",
+    "module": "energy2400",
+    "purpose": "Test configuration for all supported energy2400 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/energy2400/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]
+    energy2400_module = eval_pkt(f'ModuleEnergy2400V{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=energy2400_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=[energy2400_module])

brg_certificate/tests/energy2400/pattern_test/pattern_test.json

@@ -0,0 +1,13 @@
+{
+    "name": "pattern_test",
+    "module": "energy2400",
+    "purpose": "Test configuration for all supported Energy 2400MHz 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": ["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"]
+}

brg_certificate/tests/energy2400/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]
+    energy2400_module = eval_pkt(f'ModuleEnergy2400V{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=energy2400_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=[energy2400_module])

brg_certificate/tests/energy2400/signal_indicator_ble5_test/signal_indicator_ble5_test.json

@@ -0,0 +1,13 @@
+{
+    "name": "signal_indicator_functionality_ble5_test",
+    "module": "energy2400",
+    "purpose": "TODO",
+    "documentaion": "<TEST_DOCUMENTATION_LINK>",
+    "initialCondition": "TODO",
+    "procedure": ["Test prolog", "TODO", "Test epilog"],
+    "expectedOutcome": "TODO",
+    "mandatory": 0,
+    "multiBridgeTest": 1,
+    "gwOnlyTest": 0,
+    "allSupportedValues": ["RX_CHANNEL_10_250K", "RX_CHANNEL_10_500K"]
+}