wiliot-certificate 4.4.3__py3-none-any.whl → 4.5.0a1__py3-none-any.whl

brg_certificate/tests/datapath/output_power_test/output_power_test.json → certificate/tests/datapath/rx_channel_hopping_test/rx_channel_hopping_test.json

@@ -1,16 +1,17 @@
 {
-    "name": "Output Power",
+    "name": "Rx Channel Hopping",
     "module": "Datapath",
-    "purpose": "Test configuration for all supported datapath output power values",
+    "purpose": "Test functionality of Rx Channel Hopping configuration",
     "documentation": "https://community.wiliot.com/customers/s/article/Wiliot-Network-Data-Path-Module-Configuration",
     "initialCondition": "Bridge configured to defaults",
     "procedure": ["Test prolog",
                   "For each supported value - configure the BRG and verify the value",
+                  "Scan Packets on channel 37 and channel 10 and check if packets in both channels were received when configured to hopping, and if packet count is the same",
                   "Test epilog and revert to defaults"],
     "expectedOutcome": "All values configured successfully",
     "mandatory": 0,
     "multiBridgeTest": 0,
     "gwOnlyTest": 0,
-    "internalBridge": 1,
-    "allSupportedValues": [-12, -8, -4, 0, 2, 3]
+    "dataSimOnlyTest": 0,
+    "allSupportedValues": []
 }

certificate/tests/datapath/rx_channel_hopping_test/rx_channel_hopping_test.py

@@ -0,0 +1,77 @@
+from certificate.cert_prints import *
+from certificate.cert_defines import *
+from certificate.wlt_types import *
+import certificate.cert_mqtt as cert_mqtt
+import certificate.cert_data_sim as cert_data_sim
+import certificate.cert_common as cert_common
+import certificate.cert_config as cert_config
+
+SCAN_TIME_PER_CH = 60   # in seconds
+
+
+def run(test):
+
+    fields = [BRG_RX_CHANNEL, BRG_PACER_INTERVAL]
+
+    datapath_module = test.active_brg.datapath
+    pacer_interval = 1
+
+    test = cert_common.test_prolog(test)
+    if test.rc == TEST_FAILED:
+        return cert_common.test_epilog(test)
+
+    if not (test.data == DATA_SIMULATION):
+        test.rc = TEST_FAILED
+        warning_txt = "WARNING: This test should be ran with data simulator!"
+        utPrint(warning_txt, "RED")
+        test.add_reason(warning_txt)
+        return cert_common.test_epilog(test)
+
+    test = cert_config.brg_configure(test, fields=fields, values=[ag.RX_CHANNEL_HOPPING_37_10, pacer_interval], module=datapath_module)[0]
+
+    num_of_pixels = 5
+    # For bridge with cloud connectivity, each ble5 sent as is and not split to 2 packets
+    split_pkt_mult = 1 if test.dut_is_combo() else 2
+
+    # Simulating tag packets on channel 37
+    utPrint("Scanning packets on channel 37", "BLUE")
+    pixel_sim_thread_ch_37 = cert_data_sim.DataSimThread(test=test, num_of_pixels=num_of_pixels, duplicates=1,
+                                                         delay=0, pkt_types=[0])
+    pixel_sim_thread_ch_37.start()
+    df_37 = cert_common.data_scan(test, scan_time=SCAN_TIME_PER_CH, brg_data=(not test.internal_brg), gw_data=test.internal_brg)
+    pixel_sim_thread_ch_37.stop()
+    time.sleep(5)
+
+    # Simulating packets on ch 10
+    utPrint("Scanning packets on channel 10", "BLUE")
+    pixel_sim_thread_ch_10 = cert_data_sim.DataSimThread(test=test, num_of_pixels=num_of_pixels, duplicates=1,
+                                                         delay=0, pkt_types=[2],
+                                                         pixels_type=GEN3_EXTENDED)
+    pixel_sim_thread_ch_10.start()
+    df_10 = cert_common.data_scan(test, scan_time=SCAN_TIME_PER_CH, brg_data=(not test.internal_brg), gw_data=test.internal_brg)
+    pixel_sim_thread_ch_10.stop()
+
+    cert_mqtt.dump_pkts(test, log=test.module_name)
+
+    # Analyze packet count per channel
+    df_37_counts = df_37['tag_id'].value_counts().rename('pkt_count').reset_index().rename(columns={'index': 'tag_id'})
+    df_10_counts = df_10['tag_id'].value_counts().rename('pkt_count').reset_index().rename(columns={'index': 'tag_id'})
+    print(df_37_counts)
+    print(f"Channel 37 avg pkt count: {df_37_counts['pkt_count'].mean()}")
+    print(df_10_counts)
+    print(f"Channel 10 avg pkt count: {df_10_counts['pkt_count'].mean()}")
+
+    if not (0.9 * df_10_counts['pkt_count'].mean() <=
+            split_pkt_mult * df_37_counts['pkt_count'].mean() <=
+            1.1 * df_10_counts['pkt_count'].mean()):
+        print("Packet count on both channels doesn't match!")
+        test.rc = TEST_FAILED
+        test.add_reason("Packet count on both channels doesn't match!")
+    else:
+        utPrint("Packet count match!")
+
+    # param epilog
+    cert_mqtt.generate_log_file(test, test.module_name)
+    field_functionality_pass_fail_print(test, fields[0], value=test.module_name)
+
+    return cert_common.test_epilog(test, revert_brgs=True, modules=[datapath_module])

{brg_certificate → certificate}/tests/datapath/rx_channel_test/rx_channel_test.json

@@ -11,6 +11,6 @@
     "mandatory": 0,
     "multiBridgeTest": 0,
     "gwOnlyTest": 0,
-    "internalBridge": 1,
-    "allSupportedValues": ["RX_CHANNEL_37", "RX_CHANNEL_38", "RX_CHANNEL_39", "RX_CHANNEL_10_250K", "RX_CHANNEL_10_500K"]
+    "dataSimOnlyTest": 0,
+    "allSupportedValues": ["RX_CHANNEL_37", "RX_CHANNEL_38", "RX_CHANNEL_39", "RX_CHANNEL_10_500K", "RX_CHANNEL_HOPPING_37_10"]
 }

{brg_certificate → certificate}/tests/datapath/rx_channel_test/rx_channel_test.py

@@ -1,8 +1,9 @@
-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
+from certificate.cert_prints import *
+from certificate.cert_defines import *
+from certificate.wlt_types import *
+import certificate.cert_mqtt as cert_mqtt
+import certificate.cert_common as cert_common
+import certificate.cert_config as cert_config
 
 
 def is_primary_channel(channel):
@@ -32,7 +33,7 @@ def run(test):
             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)
+        cert_mqtt.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)

{brg_certificate → certificate}/tests/datapath/rx_rate_gen2_test/rx_rate_gen2_test.json

@@ -5,16 +5,16 @@
     "documentation": "https://community.wiliot.com/customers/s/article/Wiliot-Network-Data-Path-Module-Pacing",
     "initialCondition": "Bridge set to default configuration",
     "procedure": [
-        "mid_values - Sanity check: Generate packets with delays of 1, 5, and 0.5 seconds. Check address values 192, 243, and 128. Verify that the address value is 0 for the first packet.",
-        "diff_pacer - Generate packets with a 1-second delay and pacer intervals of 30 and 60. Ensure the address value remains 192.",
-        "min_value - Minimum value: Generate packets with a 0.1-second delay. Verify that the address value is 1.",
-        "max_value - Maximum value: Generate packets with a 70-second delay and a pacer interval of 80. Verify that the address value is 255.",
-        "diff_rate - alpha filter: Generate packets with delay 0.5 second and change to 3 second, according the delay changing verify the tolerance address value"
+        "mid_values - Sanity check: Generate packets with delays of 1, 5, and 0.5 seconds. Verify that the correct TBC values are received and that the first packet's TBC is zero.",
+        "diff_pacer - Generate packets with a 1-second delay and pacer intervals of 30 and 60. Ensure that the TBC value remains unchanged.",
+        "min_value - Minimum value: Generate packets with a 0.1-second delay. Verify the correct TBC value is received.",
+        "max_value - Maximum value: Generate packets with a 70-second delay and a pacer interval of 80. Verify the correct TBC value is received.",
+        "diff_rate - alpha filter: Generate packets with delay 0.5 second and change to 3 seconds. Verify that the TBC value changes according to the delay, within the expected tolerance."
     ],
-    "expectedOutcome": "verify that the address value we received matches the expected value, with a tolerance of up to five percent.",
+    "expectedOutcome": "Ensure that the received TBC values match the expected ones, within a tolerance of up to ten percent.",
     "mandatory": 1,
     "multiBridgeTest": 0,
     "gwOnlyTest": 0,
-    "internalBridge": 1,
+    "dataSimOnlyTest": 1,
     "allSupportedValues": ["mid_values", "diff_pacer", "min_value", "max_value", "diff_rate"]
 }

{brg_certificate → certificate}/tests/datapath/rx_rate_gen2_test/rx_rate_gen2_test.py

@@ -1,31 +1,35 @@
 
-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
-import brg_certificate.cert_data_sim as cert_data_sim
+from certificate.cert_prints import *
+from certificate.cert_defines import *
+from certificate.wlt_types import *
+import certificate.cert_mqtt as cert_mqtt
+import certificate.cert_common as cert_common
+import certificate.cert_config as cert_config
+import certificate.cert_data_sim as cert_data_sim
 import time
 
 
+# input address value and return the TBC value in s
+def address2tbc(address):
+    if address == 0:
+        return 0
+    result = 64 / (256 - address)
+    return result
+
+
 def cal_scan_time(test, delay, pacer_interval):
-    # Calculate the scan time to ensure at least 5 packets are captured in data scan
+    # Calculate the scan time to ensure enough packets are captured in data scan
     # define the num of packet that you want to get
-    num_of_sending_pkt = 2  # actually it will be 3 because the first one always send
+    num_of_cycles = 5
     delay = delay / 1000
     if delay < pacer_interval:
-        scan_time = (pacer_interval * num_of_sending_pkt) + 10
-    elif pacer_interval <= delay:
-        scan_time = (delay * num_of_sending_pkt) + 10
-    # verify scan time value
-    if scan_time < (2 * pacer_interval):
-        print("scan time is too low in related to pacer interval")
-        test.rc == TEST_FAILED
-        test.add_reason("scan time is too low in related to pacer interval value")
+        scan_time = (pacer_interval * num_of_cycles) + 10
+    else:  # pacer_interval <= delay
+        scan_time = (delay * num_of_cycles) + 10
     return test, scan_time
 
 
-def scan_and_compare(test, pacer_interval, delay, expected_address_value):
+def scan_and_compare(test, pacer_interval, delay, expected_TBC_value):
 
     pixel_sim_thread = cert_data_sim.DataSimThread(test=test, num_of_pixels=1, duplicates=3, delay=delay, pkt_types=[0], pixels_type=GEN3)
     pixel_sim_thread.start()
@@ -33,7 +37,7 @@ def scan_and_compare(test, pacer_interval, delay, expected_address_value):
     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()
     cert_mqtt.dump_pkts(test, log="rx_rate")
-    cert_common.display_data(df, tbc=True, nfpkt=True, rssi=True, dir=test.dir)
+    cert_common.display_data(df, tbc=True, rssi=True, dir=test.dir)
     # check if the dataframe is empty or not
     if len(df) <= 1:
         print("Df is empty")
@@ -53,19 +57,26 @@ def scan_and_compare(test, pacer_interval, delay, expected_address_value):
         if mid_index == 0:
             mid_index = 1
         print(f"Length of df: {length}, mid index: {mid_index}")
-        print(f"df:\n {df}")
-
+        # TODO: Logging print
+        # print(f"Df:\n {df}")
+        df[TBC] = df[TBC].apply(address2tbc)
+        print(f"Df after invert tbc:\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[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
-        if (actual_address_value < (expected_address_value - THRESHOLD_ADDRESS_VALUE) or
-                actual_address_value > (expected_address_value + THRESHOLD_ADDRESS_VALUE)):
-            print(f"\nAddress value for tag {tag} is {actual_address_value}, expected value: {expected_address_value}!\n")
+
+        actual_tbc_value = round(df.iloc[mid_index:][TBC].mean(), 3)
+        expected_tbc_value = round(expected_TBC_value, 3)
+        threshold = 0.1 * expected_tbc_value
+        print(f"Actual TBC value: {actual_tbc_value}")
+        print(f"Expected TBC value: {expected_tbc_value} range: [{expected_tbc_value - threshold}, {expected_tbc_value + threshold}]")
+
+        # Validate the received value is in 10% of the expected value
+        if not ((expected_tbc_value - threshold) <= actual_tbc_value <= (expected_tbc_value + threshold)):
             test.rc = TEST_FAILED
-            test.add_reason(f"Address value for tag {tag} is {actual_address_value} expected: {expected_address_value}!\n")
+            test.add_reason(f"TBC value for tag {tag}: got: {actual_tbc_value}, expected: {expected_tbc_value}!\n")
+            if actual_tbc_value < expected_tbc_value:
+                print(f" Actual TBC value: {actual_tbc_value} is less than expected TBC value: {expected_tbc_value}!\n")
+            if actual_tbc_value > (expected_tbc_value + threshold):
+                print(f" TBC value is higher than expected TBC value: {expected_tbc_value}!\n")
         if test.params == [mid_values] and delay == 1000:
             # checking 0 value in the first packet.
             first_row = df.iloc[0][TBC]
@@ -76,20 +87,22 @@ def scan_and_compare(test, pacer_interval, delay, expected_address_value):
     return test
 
 
-def mid_values(test, datapath_module):
-    # mid values - Sanity check: Generate packets with delays of 1, 5, and 0.5 seconds.
-    # Check address values 192, 243, and 128. Verify that the address value is 0 for the first packet.
-    SANITY_DELAY_ADDRESS_VALUES = {1000: 192, 5000: 243, 500: 128}
-    for delay, expected_address_value in SANITY_DELAY_ADDRESS_VALUES.items():
+def mid_values(test, _):
+    # Mid_values - Sanity check: Generate packets with delays of 1, 5, and 0.5 seconds.
+    # Verify that the correct TBC values are received and that the first packet's TBC is zero.
+
+    SANITY_DELAY_VALUES = [1000, 5000, 500]
+    for delay in SANITY_DELAY_VALUES:
         pacer_interval = 1
-        test = scan_and_compare(test, pacer_interval=pacer_interval, delay=delay, expected_address_value=expected_address_value)
-    time.sleep(2)
+        test = scan_and_compare(test, pacer_interval=pacer_interval, delay=delay, expected_TBC_value=(delay / 1000))
+    time.sleep(10)
     return test
 
 
 def diff_pacer(test, datapath_module):
-    # diff pacer - Generate packets with a 1-second delay and pacer intervals of 30 and 60. Ensure the address value remains 192.
-    SANITY_ADDRESS_VALUE = 192
+    # Diff_pacer - Generate packets with a 1-second delay and pacer intervals of 30 and 60.
+    # Ensure that the TBC value remains unchanged.
+
     PACER_INTERVAL_LIST = [30, 60]
     delay = 1000  # 1 sec
     for pacer_interval in PACER_INTERVAL_LIST:
@@ -97,41 +110,46 @@ def diff_pacer(test, datapath_module):
         if test.rc == TEST_FAILED:
             test.add_reason(f"Didn't succeed to config pacer interval {pacer_interval}")
             return test
-        test = scan_and_compare(test, pacer_interval=pacer_interval, delay=delay, expected_address_value=SANITY_ADDRESS_VALUE)
-    time.sleep(2)
+        test = scan_and_compare(test, pacer_interval=pacer_interval, delay=delay, expected_TBC_value=(delay / 1000))
+    time.sleep(10)
     return test
 
 
 def min_value(test, datapath_module):
-    # min_value -  Minimum value: Generate packets with a 0.1-second delay. Verify that the address value is 1.
-    MIN_ADDRESS_VALUE = 1
+    # Min_value - Minimum value: Generate packets with a 0.1-second delay.
+    # Verify the correct TBC value is received.
+    # NOTE: The min TBC value is 0.25 seconds.
+    MIN_ADDRESS_VALUE = 0.25
     pacer_interval = 1
     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
     delay = 100
-    test = scan_and_compare(test, pacer_interval=pacer_interval, delay=delay, expected_address_value=MIN_ADDRESS_VALUE)
-    time.sleep(2)
+    test = scan_and_compare(test, pacer_interval=pacer_interval, delay=delay, expected_TBC_value=MIN_ADDRESS_VALUE)
+    time.sleep(10)
     return test
 
 
 def max_value(test, datapath_module):
-    # max value - Maximum value: Generate packets with a 70-second delay and a pacer interval of 80. Verify that the address value is 255.
-    MAX_ADDRESS_VALUE = 255
+    # Max_value - Maximum value: Generate packets with a 70-second delay and a pacer interval of 80.
+    # Verify the correct TBC value is received.
+    # NOTE: The max TBC value is 64 seconds.
+    MAX_TBC_VALUE = 64
     pacer_interval = 80
     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
     delay = 70000
-    test = scan_and_compare(test, pacer_interval=pacer_interval, delay=delay, expected_address_value=MAX_ADDRESS_VALUE)
-    time.sleep(2)
+    test = scan_and_compare(test, pacer_interval=pacer_interval, delay=delay, expected_TBC_value=MAX_TBC_VALUE)
+    time.sleep(10)
     return test
 
 
 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
+    # Diff_rate - alpha filter: Generate packets with delay 0.5 second and change to 3 seconds.
+    # Verify that the TBC value changes according to the delay, within the expected tolerance.
     pacer_interval = 1
     delay_duration = [[500, 5], [3000, 3]]
     first_delay = delay_duration[0][0]
@@ -148,41 +166,63 @@ def diff_rate(test, datapath_module):
     print(f"sleep for {time_sleep} sec\n")
     time.sleep(time_sleep)
     pixel_sim_thread.delay = second_delay
-    scan_time = sum(duration for _, duration in delay_duration) + 20
+    scan_time = sum(duration for _, duration in delay_duration) + 40
     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)
-
+    # TODO: logging print
+    # print(f"df:\n {df}")
+    df[TBC] = df[TBC].apply(address2tbc)
     if len(df) <= 1:
         test.add_reason("Df is empty")
         test.rc = TEST_FAILED
         return test
     else:
         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
+    # NOTE: all next rows are specific for the values: delay 0.5 and 3 sec.
+    # 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 +-10 units for address value
-
+    expected_second_tbc_value = second_delay / 1000
+    print(f"expected second tbc value: {expected_second_tbc_value}")
     # Most important check, verify it converges to the correct value
-    if df.iloc[-1][TBC] not in range(232, 237):
+    average_of_last_5_tbc_value = round(df.iloc[-5:][TBC].mean(), 3)
+    print(f"last tbc value: {average_of_last_5_tbc_value}")
+    THRESHOLD_MIN = 0.95
+    # NOTE: assume that there is time difference between SIM and GW
+    if test.tester.is_simulated():
+        THRESHOLD_MAX = 1.1
+    else:
+        THRESHOLD_MAX = 1.15
+    min_expected_tbc_value = round(expected_second_tbc_value * THRESHOLD_MIN, 3)
+    max_expected_tbc_value = round(expected_second_tbc_value * THRESHOLD_MAX, 3)
+
+    print(f"TBC value: {average_of_last_5_tbc_value}")
+    print(f"expected value [{min_expected_tbc_value},{max_expected_tbc_value}] according to delay:{second_delay / 1000} sec")
+    if not (min_expected_tbc_value <= average_of_last_5_tbc_value <= max_expected_tbc_value):
         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")
+        test.add_reason(f"TBC value: {average_of_last_5_tbc_value}, expected value {expected_second_tbc_value}")
         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("Didn't find the correct gap according to alpha filter calculation")
+
+    # # TODO: we skip that part until we decide if there is a need to check the gap between the first and second tbc values
+    # # for loop that skip the first row and check if somewhere there is the expected gap 0.5 to 3 sec
+    # result = False
+    # expected_first_tbc_value = first_delay / 1000
+    # print(f"expected first tbc value: {expected_first_tbc_value}")
+    # expected_first_gap_tbc_value = round(address_2_tbc(200), 3)
+    # print(f"expected second tbc value: {expected_first_gap_tbc_value}")
+    # for i in range(0, length - 1):
+    #     prev = round(df.iloc[i][TBC],3)
+    #     current = round(df.iloc[i + 1][TBC],3)
+    #     print(f"prev: {prev}, current: {current}")
+    #     if expected_first_tbc_value*0.9 <= prev <= expected_first_tbc_value*1.1:
+    #       if expected_first_gap_tbc_value*0.9 <= current <= expected_first_gap_tbc_value*1.1:
+    #         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("Didn't find the correct gap according to alpha filter calculation")
     return test
 
 
@@ -208,7 +248,7 @@ def run(test):
     for param in test.params:
         functionality_run_print(param.name)
         test = RX_RATE_TEST_MAP[param.value](test, datapath_module)
-        generate_log_file(test, param.name)
+        cert_mqtt.generate_log_file(test, param.name)
         field_functionality_pass_fail_print(test, param.name)
         test.set_phase_rc(param.name, test.rc)
         test.add_phase_reason(param.name, test.reason)

{brg_certificate → certificate}/tests/datapath/rx_rate_gen3_test/rx_rate_gen3_test.json

@@ -5,16 +5,16 @@
     "documentation": "https://community.wiliot.com/customers/s/article/Wiliot-Network-Data-Path-Module-Pacing",
     "initialCondition": "Bridge set to default configuration",
     "procedure": [
-        "mid_values - Sanity check: Generate packets with delays of 1, 5, and 0.5 seconds. Check address values 192, 243, and 128. Verify that the address value is 0 for the first packet.",
-        "diff_pacer - Generate packets with a 1-second delay and pacer intervals of 30 and 60. Ensure the address value remains 192.",
-        "min_value - Minimum value: Generate packets with a 0.1-second delay. Verify that the address value is 1.",
-        "max_value - Maximum value: Generate packets with a 70-second delay and a pacer interval of 80. Verify that the address value is 255.",
-        "diff_rate - alpha filter: Generate packets with delay 0.5 second and change to 3 second, according the delay changing verify the tolerance address value"
+        "mid_values - Sanity check: Generate packets with delays of 1, 5, and 0.5 seconds. Verify that the correct TBC values are received and that the first packet's TBC is zero.",
+        "diff_pacer - Generate packets with a 1-second delay and pacer intervals of 30 and 60. Ensure that the TBC value remains unchanged.",
+        "min_value - Minimum value: Generate packets with a 0.1-second delay. Verify the correct TBC value is received.",
+        "max_value - Maximum value: Generate packets with a 70-second delay and a pacer interval of 80. Verify the correct TBC value is received.",
+        "diff_rate - alpha filter: Generate packets with delay 0.5 second and change to 3 seconds. Verify that the TBC value changes according to the delay, within the expected tolerance."
     ],
-    "expectedOutcome": "verify that the address value we received matches the expected value, with a tolerance of up to five percent.",
+    "expectedOutcome": "Ensure that the received TBC values match the expected ones, within a tolerance of up to ten percent.",
     "mandatory": 1,
     "multiBridgeTest": 0,
     "gwOnlyTest": 0,
-    "internalBridge": 1,
+    "dataSimOnlyTest": 1,
     "allSupportedValues": ["mid_values", "diff_pacer", "min_value", "max_value", "diff_rate"]
 }