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

certificate/cert_common.py

@@ -1,6 +1,8 @@
 from certificate.cert_prints import *
 from certificate.cert_defines import *
 from certificate.wlt_types import *
+from certificate.cert_utils import Phase
+from certificate.cert_utils import *
 import certificate.cert_utils as cert_utils
 import certificate.cert_config as cert_config
 import certificate.cert_mqtt as cert_mqtt
@@ -479,8 +481,8 @@ def pacing_analysis(test, pacer_interval, df, pkt_filter_cfg=ag.PKT_FILTER_RANDO
                 # In non-sterile runs - rssi is less stable and can trigger more events
                 max_count_threshold = float('inf')
             else:
-                # In rssi movement events the alpha filter takes about 13 packets to stabilize 
-                max_count_threshold = 1 + (RSSI_EVENT_PKTS_TO_STABILIZE / expected_event_pkt_count)
+                # In rssi movement events the alpha filter takes about 10 packets to stabilize 
+                max_count_threshold = 1 + (10 / expected_event_pkt_count)
         else:
             max_count_threshold = PACER_INTERVAL_CEIL_THRESHOLD
 
@@ -490,14 +492,12 @@ def pacing_analysis(test, pacer_interval, df, pkt_filter_cfg=ag.PKT_FILTER_RANDO
 
             if not (PACER_INTERVAL_THRESHOLD <= len(event_pkts) / expected_event_pkt_count <= max_count_threshold):
                 test.rc = TEST_FAILED
-                msg = f"Packet count for dynamic tag {tag} is wrong! expected_event_pkt_count = {expected_event_pkt_count}, received pkt count = {len(event_pkts)}"
-                test.add_reason(msg)
-                utPrint(msg, "RED")
+                test.add_reason(f"Packet count for dynamic tag {tag} is wrong!")
+                print(f"expected_event_pkt_count = {expected_event_pkt_count}, received pkt count = {len(event_pkts)}")
             if not (PACER_INTERVAL_THRESHOLD <= avg_event_pacer / event_pacing <= PACER_INTERVAL_CEIL_THRESHOLD):
                 test.rc = TEST_FAILED
-                msg = f"Tag {tag} has a wrong avg time diff. diff_time {list(event_pkts.timestamp.diff().div(1000))}, avg_event_pacer={avg_event_pacer} exceeds threshold!"
-                test.add_reason(msg)
-                utPrint(msg, "RED")
+                print(f"Tag {tag} with diff_time {list(event_pkts.timestamp.diff().div(1000))}, avg_event_pacer={avg_event_pacer} exceeds threshold!")
+                test.add_reason(f"Tag {tag} has a wrong avg time diff")
 
     # Verify the tags pacer interval (without event)
     failed_tags = 0
@@ -512,9 +512,8 @@ def pacing_analysis(test, pacer_interval, df, pkt_filter_cfg=ag.PKT_FILTER_RANDO
         if ((avg_pacer / pacer_interval) < PACER_INTERVAL_THRESHOLD_HIGH and (pacer_interval - avg_pacer) > 1):
             failed_tags += 1
             test.rc = TEST_FAILED
-            msg = f"Tag {tag} with diff_time {list(pkts.timestamp.diff().div(1000))}, avg_pacer={avg_pacer} exceeds {PACER_INTERVAL_THRESHOLD_HIGH} minimum threshold!"
-            utPrint(msg, "RED")
-            test.add_reason(msg)
+            print(f"Tag {tag} with diff_time {list(pkts.timestamp.diff().div(1000))}, avg_pacer={avg_pacer} exceeds {PACER_INTERVAL_THRESHOLD_HIGH} minimum threshold!")
+            test.add_reason(f"{failed_tags}/{tags_count} tags with wrong time diff")
             # Pass the test with real tags when less than 5% tag failed
             if test.data != DATA_SIMULATION and failed_tags / tags_count < 0.05:
                 test.rc = TEST_PASSED
@@ -523,9 +522,7 @@ def pacing_analysis(test, pacer_interval, df, pkt_filter_cfg=ag.PKT_FILTER_RANDO
             if max_received_pkts == len(pkts):
                 # we fail the tag only if it received all expected pkts and pacer caluculation is valid
                 failed_tags += 1
-                msg = f"Tag {tag} with diff_time {list(pkts.timestamp.diff().div(1000))}, avg_pacer={avg_pacer} exceeds {PACER_INTERVAL_CEIL_THRESHOLD} maximum threshold!"
-                utPrint(msg, "RED")
-                test.add_reason(msg)
+                print(f"Tag {tag} with diff_time {list(pkts.timestamp.diff().div(1000))}, avg_pacer={avg_pacer} exceeds {PACER_INTERVAL_CEIL_THRESHOLD} maximum threshold!")
             else:
                 print(f"Tag {tag} received only {len(pkts)} pkts out of {max_received_pkts}, avg_pacer failed but skipping pacer ceil validation")
             if failed_tags / tags_count > 0.2:  # Fail the test on ceil threshold only when more than 20% tag failed
@@ -605,13 +602,12 @@ def run_event_test_phase(test, phase, datapath_module, values, scan_time, event_
     scan_time_multiplier = 1
     delay = DATA_SIM_EVENT_TESTING_DELAY_MS
     if "rssi" in phase:
-        test.sterile_run = is_quiet_setup_running()
         delay = DATA_SIM_RSSI_EVENT_TESTING_DELAY_MS
         scan_time_multiplier = (1 / 3)
         fields += [BRG_RSSI_MOVEMENT_THRESHOLD]
 
-    ble5 = ble5_test and test.dut_is_bridge()  # ble5 only for bridge dut (with combo we don't need to wait)
-    test = cert_config.brg_configure(test, fields=fields, values=values, module=datapath_module, ble5=ble5)[0]
+    test = (cert_config.brg_configure_ble5(test, fields=fields, values=values, module=datapath_module)[0] if ble5_test
+            else cert_config.brg_configure(test, fields=fields, values=values, module=datapath_module)[0])
     test.set_phase_rc(phase, test.rc)
     test.add_phase_reason(phase, test.reason)
     if test.rc == TEST_FAILED and test.exit_on_param_failure:
@@ -748,9 +744,7 @@ def scan_for_mgmt_pkts(test, mgmt_type, target=DUT):
             break
     if not found:
         test.rc = TEST_FAILED
-        error = f"Didn't receive {mgmt_type[0].__name__} pkt after {DEFAULT_BRG_FIELD_UPDATE_TIMEOUT} seconds!"
-        test.add_reason(error)
-        utPrint(error, "RED")
+        test.add_reason(f"Didn't receive {mgmt_type[0].__name__} pkt after {DEFAULT_BRG_FIELD_UPDATE_TIMEOUT} seconds!")
     return test, ret_pkts
 
 # Actions test functions
@@ -782,7 +776,8 @@ def scan_for_modules(test, modules=[]):
 
 
 def search_action_ack(test, action_id, **kwargs):
-    test, mgmt_pkts = scan_for_mgmt_pkts(test, mgmt_type=[eval_pkt(f'{ag.ACTIONS_DICT[action_id]}{test.active_brg.api_version}')])
+    test, mgmt_pkts = cert_common.scan_for_mgmt_pkts(test,
+                                                     mgmt_type=[eval_pkt(f'{ag.ACTIONS_DICT[action_id]}{test.active_brg.api_version}')])
     if test.rc == TEST_FAILED:
         return test
     print("\nReceived ACK pkts:")
@@ -1056,24 +1051,14 @@ def get_gw_type(mqttc):
 
 def get_module_if_pkt(test):
     cert_config.send_brg_action(test, ag.ACTION_GET_MODULE, interface=1)
-    mgmt_type = [m for m in ag.MODULES_LIST if "ModuleIf" in m.__name__]
-    test, pkts = scan_for_mgmt_pkts(test, mgmt_type=mgmt_type)
-
+    test, pkts = scan_for_mgmt_pkts(test, mgmt_type=[eval_pkt(f'ModuleIfV{test.active_brg.api_version}'),
+                                                     eval_pkt(f'ModuleIfV{test.active_brg.api_version - 1}'),])
     if test.rc == TEST_FAILED:
         return test, NO_RESPONSE
     else:
         print(pkts[-1][MGMT_PKT].pkt)
         return test, pkts[-1][MGMT_PKT].pkt
 
-def get_gw_api_version(mqttc):
-    messages = cert_mqtt.get_all_status_pkts(mqttc)
-    for msg in messages:
-        if GW_CONF in msg: # JSON
-            return msg[GW_CONF][GW_API_VERSION]
-        if GW_STATUS in msg: # protobuf
-            return msg[GW_STATUS][GW_API_VERSION]
-    return None
-
 def get_cfg_hash(test):
     utPrint(f"Fetching BRG cfg hash for BRG {test.active_brg.id_str}", "BLUE")
     test, module_if_pkt = get_module_if_pkt(test)
@@ -1289,27 +1274,10 @@ def output_power_supported(board_type, output_power):
         return output_power in ag.OUTPUT_POWER_2_4_SUPPORTED_VALUES
 
 
-def validate_received_packets(pkts_array):
-    for pkt in pkts_array:
-        # Check all required fields are present
-        if TIMESTAMP not in pkt:
-            return False, "timestamp field is missing in some of the packets"
-        if ALIAS_BRIDGE_ID not in pkt:
-            return False, "alias_bridge_id field is missing in some of the packets"
-        if PAYLOAD not in pkt:
-            return False, "payload field is missing in some of the packets"
-        if SEQUENCE_ID not in pkt:
-            return False, "sequence_id field is missing in some of the packets"
-        # Check that the payload length is either 62 or 74 hex characters (equevelnt to 31 or 37 bytes)
-        if len(pkt[PAYLOAD]) != 62 and len(pkt[PAYLOAD]) !=74:
-            return False, f"Payload length is invalid for packet {pkt[PAYLOAD]}"
-    return True, ""
-
-
 def wiliot_pkts_validation(test, all_messages_in_test, all_data_pkts):
     PHASE_NAME = "Wiliot packets validation"
     phase_run_print(PHASE_NAME)
-    wiliot_pkts_validation_phase = cert_utils.Phase(PHASE_NAME, rc=TEST_PASSED)
+    wiliot_pkts_validation_phase = Phase(PHASE_NAME, rc=TEST_PASSED)
 
     if len(all_messages_in_test) == 0:
         wiliot_pkts_validation_phase.rc = TEST_FAILED
@@ -1322,7 +1290,7 @@ def wiliot_pkts_validation(test, all_messages_in_test, all_data_pkts):
         wiliot_pkts_validation_phase = seq_id_validation(wiliot_pkts_validation_phase, all_data_pkts)
 
     field_functionality_pass_fail_print(wiliot_pkts_validation_phase, PHASE_NAME)
-    test.add_phase(wiliot_pkts_validation_phase)
+    test.phases[-1:-1] = [wiliot_pkts_validation_phase]
     return test
 
 
@@ -1393,7 +1361,7 @@ def timestamps_validation(wiliot_pkts_validation_phase, all_messages_in_test, up
                 else:
                     if inner_pkt[TIMESTAMP] < previous_ts:
                         wiliot_pkts_validation_phase.rc = TEST_FAILED
-                        wiliot_pkts_validation_phase.reason = f'Timestamp is not incremental for inner packet {inner_pkt[PAYLOAD]}'
+                        wiliot_pkts_validation_phase.reason = f'Timestamp is not incremental for inner packet {inner_pkt}'
                         return wiliot_pkts_validation_phase
                     previous_ts = inner_pkt[TIMESTAMP]
     return wiliot_pkts_validation_phase
@@ -1405,19 +1373,19 @@ def generate_graph_stress_test(test, results, test_pkts_received):
     graph_data = []
     for i in range(0, len(results), 2):
         if i + 1 < len(results):
-            graph_data.append({'pkts_per_sec': results[i], 'received_pps': results[i + 1]})
+            graph_data.append({'pkts_per_sec': results[i], 'percent_received': results[i + 1]})
     
     graph_df = pd.DataFrame(graph_data)
     html_file_path = os.path.join(ARTIFACTS_DIR, test.dir, 'stress_graph.html')
     
     # First graph: percentage received vs packets per second
-    fig1 = px.line(graph_df, x='pkts_per_sec', y='received_pps',
-                   title='Packets Per Second Uploaded vs Packets Per Second Advertised',
-                   labels={'pkts_per_sec': 'Advertised PPS', 'received_pps': 'Uploaded PPS'},
-                   markers=True, text='received_pps')
+    fig1 = px.line(graph_df, x='pkts_per_sec', y='percent_received',
+                   title='Percentage of packets uploaded by packets per second advertised',
+                   labels={'pkts_per_sec': 'Packets Sent Per Second', 'percent_received': 'Percentage of packets received'},
+                   markers=True, text='percent_received')
     
-    # Set y-axis to [0 - highest_pps] scale
-    fig1.update_yaxes(range=[0, results[-2]])
+    # Set y-axis to 1-100 scale
+    fig1.update_yaxes(range=[1, 100])
     
     # Position text labels next to the markers
     fig1.update_traces(textposition="top right")
@@ -1450,8 +1418,11 @@ def generate_graph_stress_test(test, results, test_pkts_received):
 
 
 def stress_analysis(test, pps, sent_pkts, received_pkts):
-
-    _sent_pkts = [p[12:] for p in sent_pkts]
+    _sent_pkts = []
+    for pkt in sent_pkts:
+        adva_endianness_change = change_endianness(pkt[:12]) + pkt[12:]  # Switch to big endian adva
+        _sent_pkts.append(adva_endianness_change)
+    
     sent_df = pd.DataFrame(_sent_pkts, columns=[PACKETS])
     received_df = pd.DataFrame(received_pkts, columns=[PACKETS])
 
@@ -1460,29 +1431,29 @@ def stress_analysis(test, pps, sent_pkts, received_pkts):
     pkts_sent_count = len(sent_df)
     pkts_received_count = len(merged_df)
 
-    # Prints and calculations
+    # Prints
+    print(f'Number of packets sent: {pkts_sent_count}')
+    print(f'Number of packets received: {pkts_received_count}')
     percentage_received = round(pkts_received_count * 100 / pkts_sent_count)
-    utPrint(f'Sent: {pkts_sent_count}, Received: {pkts_received_count} ({percentage_received}%)', "BLUE")
-    received_pps = pps * percentage_received / 100
     
     # PASS/FAIL logic
-    if percentage_received < 1: # If less than 1% of the packets were received, fail the test
-        test.set_phase_rc(str(pps), TEST_FAILED)
-        test.add_phase_reason(str(pps), f"{percentage_received}% of the packets were scanned & uploaded by the gateway")
+    stage_pass = pkts_received_count / pkts_sent_count * 100
+    if stage_pass < 1: # If less than 1% of the packets were received, fail the test
+        test.rc = TEST_FAILED
+        test.reason = "Insufficient amount of packets were scanned & uploaded by the gateway"
     else:
-        test.set_phase_rc(str(pps), TEST_PASSED)
-        test.add_phase_reason(str(pps), f"received pps: {received_pps} ({percentage_received}% of packets)")
+        test.reason = f'{percentage_received}% of packets received, average pps: {pps * percentage_received / 100}'
 
-    return test, received_pps
+    return test, percentage_received
 
 
 def generate_adv_payload(test_indicator, unique_pkt=False):
     # Keep last 4 bytes as zeroes so for incrementing them in FW 'ble_sim'
-    adva = hex2alias_id_get(get_random_hex_str(12))
-    unique_pkt_byte = get_random_hex_str(2) if unique_pkt == False else "00"
+    adva = hex2alias_id_get(cert_utils.get_random_hex_str(12))
+    unique_pkt_byte = cert_utils.get_random_hex_str(2) if unique_pkt == False else "00"
     payload = (ag.Hdr(group_id=ag.GROUP_ID_UNIFIED_PKT_V2).dump() + test_indicator +
-               get_random_hex_str(32) + unique_pkt_byte + "00000000")
+               cert_utils.get_random_hex_str(32) + unique_pkt_byte + "00000000")
     return adva + payload
 
 def change_endianness(hex_str: str) -> str:
-    return ''.join(f"{b:02X}" for b in bytes.fromhex(hex_str)[::-1])
+    return ''.join(f"{b:02X}" for b in bytes.fromhex(hex_str)[::-1])

certificate/cert_config.py

@@ -4,7 +4,7 @@ from certificate.wlt_types import *
 import certificate.cert_common as cert_common
 import certificate.cert_protobuf as cert_protobuf
 import certificate.cert_mqtt as cert_mqtt
-import datetime, string, json, random, inspect
+import datetime, string, json, random
 
 BLE5_MAX_RETRIES = BLE5_MAX_DURATION_MS//20
 
@@ -40,9 +40,7 @@ def gw_configure(test, cfg={}, version="", extended_cfg={}, ret_pkt=False, wait=
         while (datetime.datetime.now() - start_time).seconds < DEFAULT_GW_FIELD_UPDATE_TIMEOUT:
             for p in cert_mqtt.get_all_status_pkts(mqttc):
                 if GW_CONF in p or GW_STATUS in p:
-                    test.gw_api_version = (p.get(GW_CONF, {}).get(GW_API_VERSION) or p.get(GW_STATUS, {}).get(GW_API_VERSION))
-                    if target == DUT and is_gw(test.dut):
-                        test.dut.gw_api_version = test.gw_api_version
+                    test.gw_api_version = p[GW_CONF][GW_API_VERSION] if GW_CONF in p else p[GW_STATUS][GW_API_VERSION]
                     print_pkt(p)
                     utPrint("SUCCESS: Found GW cfg", "GREEN")
                     wait_time_n_print(2)
@@ -79,18 +77,15 @@ def gw_fw_upgrade(test, version, board_type, target=DUT):
 def create_gw_config(test, cfg, target=DUT, version=""):
     gw = test.dut if is_gw(test.dut) and target == DUT else test.tester
     if version:
-        conf = {LAT: GW_LATITUDE_DEFAULT, LNG: GW_LONGITUDE_DEFAULT, WIFI_VERSION: version[WIFI_VERSION],
-                BLE_VERSION: version[BLE_VERSION], ADDITIONAL: dict(cfg)}
+        return dict({GW_CONF:{LAT: GW_LATITUDE_DEFAULT, LNG: GW_LONGITUDE_DEFAULT, WIFI_VERSION: version[WIFI_VERSION],
+                     BLE_VERSION: version[BLE_VERSION], GW_API_VERSION: gw.gw_api_version, ADDITIONAL:dict(cfg)}})
     elif gw.gw_orig_versions:
-        conf = {LAT: GW_LATITUDE_DEFAULT, LNG: GW_LONGITUDE_DEFAULT, WIFI_VERSION: gw.gw_orig_versions[WIFI_VERSION],
-                BLE_VERSION: gw.gw_orig_versions[BLE_VERSION], ADDITIONAL: dict(cfg)}
+        return dict({GW_CONF:{LAT: GW_LATITUDE_DEFAULT, LNG: GW_LONGITUDE_DEFAULT, WIFI_VERSION: gw.gw_orig_versions[WIFI_VERSION],
+                     BLE_VERSION: gw.gw_orig_versions[BLE_VERSION], GW_API_VERSION:  gw.gw_api_version, ADDITIONAL:dict(cfg)}})
     # Protection for FDM gw config
     else:
-        conf = {LAT: GW_LATITUDE_DEFAULT, LNG: GW_LONGITUDE_DEFAULT, ADDITIONAL: dict(cfg)}
-    # If api version was not sent in gw info then the gw_api_version is None, we don't want to set it in the config
-    if gw.gw_api_version is not None:
-        conf[GW_API_VERSION] = gw.gw_api_version
-    return dict({GW_CONF: conf})
+        return dict({GW_CONF:{LAT: GW_LATITUDE_DEFAULT, LNG: GW_LONGITUDE_DEFAULT, GW_API_VERSION: gw.gw_api_version,
+                     ADDITIONAL:dict(cfg)}})
 
 def gw_downlink(test, raw_tx_data="", is_ota=False, version="", max_duration=100, max_retries=8, target=DUT):
     mqttc = test.get_mqttc_by_target(target)
@@ -318,14 +313,14 @@ def brg_configure_ble5(test, cfg_pkt=None, module=None, fields=None, values=None
     if wait is False:
         return test, DONE
     while not pkts_found:
-        if ((datetime.datetime.now() - start_time).seconds > BLE5_MAX_DURATION_SEC):
+        if ((datetime.datetime.now() - start_time).seconds > ((ag.BLE5_PARAM_PRIMARY_CHANNEL_SCAN_CYCLE/1000)+1)):
             if num_of_tries < 3:
                 num_of_tries += 1
                 start_time = datetime.datetime.now()
                 gw_downlink(test=test, raw_tx_data=cfg_pkt.dump(), max_duration=BLE5_MAX_DURATION_MS, max_retries=BLE5_MAX_RETRIES, target=target)
-                print(f"Brg configure - BLE5 mode : No pkts found after {BLE5_MAX_DURATION_SEC} seconds, in try number {num_of_tries}")
+                print(f"Brg configure - BLE5 mode : No pkts found after {(ag.BLE5_PARAM_PRIMARY_CHANNEL_SCAN_CYCLE/1000)+1} seconds, in try number {num_of_tries}")
             else:
-                test.add_reason(f"Brg configure - BLE5 mode : No pkts found after {BLE5_MAX_DURATION_SEC} seconds, in 3 tries")
+                test.add_reason(f"Brg configure - BLE5 mode : No pkts found after {BLE5_MAX_DURATION_MS} seconds, in 3 tries")
                 test.rc = TEST_FAILED
                 time.sleep(1)
                 mqttc.flush_pkts()
@@ -351,35 +346,15 @@ def send_brg_action(test, action_id, target=DUT, **kwargs):
     action_pkt = get_default_brg_pkt(test, pkt_type=eval_pkt(f'{ag.ACTIONS_DICT[action_id]}{brg.api_version}'), **kwargs)
     gw_downlink(test, raw_tx_data=action_pkt.dump(), target=target)
 
-def backward_compatible_handler(test, pkt_type, **kwargs):
-    datapath_output_power = 8
-    energy_2400_output_power = 2
-    calibration_output_power = 2
-    init_params = inspect.signature(pkt_type.__init__).parameters
-    safe_kwargs = {}
-    for k, v in kwargs.items():
-        if k in init_params:
-             safe_kwargs[k] = v
-        else:
-            utPrint(f"WARNING: Parameter {k} not in {pkt_type.__name__} parameters, ignoring it!", "WARNING")
-
-    if test.active_brg.api_version < ag.API_VERSION_V13:
-        if "ModuleDatapathV12" in pkt_type.__name__ and BRG_OUTPUT_POWER not in safe_kwargs:
-            safe_kwargs.update({BRG_OUTPUT_POWER: datapath_output_power})
-        if "ModuleEnergy2400V12" in pkt_type.__name__ and BRG_OUTPUT_POWER not in safe_kwargs:
-            safe_kwargs.update({BRG_OUTPUT_POWER: energy_2400_output_power})
-        if "ModuleCalibrationV12" in pkt_type.__name__ and BRG_OUTPUT_POWER not in safe_kwargs:
-            safe_kwargs.update({BRG_OUTPUT_POWER: calibration_output_power})
-    return safe_kwargs
-
 def get_default_brg_pkt(test, pkt_type, group_id=ag.GROUP_ID_GW2BRG, seq_id=0, target=DUT, **kwargs):
     brg = get_brg_by_target(test, target)
     seq_id = test.get_seq_id() if seq_id == 0 else seq_id
-    safe_kwargs = backward_compatible_handler(test, pkt_type, **kwargs)
     # Bypass from default sub1g ep cfg of 0 (no energizing) ONLY if not using data simulation
-    if "ModuleEnergySub1G" in pkt_type.__name__ and BRG_PATTERN not in safe_kwargs and test.data != DATA_SIMULATION:
-        safe_kwargs.update({BRG_PATTERN: ag.SUB1G_ENERGY_PATTERN_ISRAEL})
-    brg_pkt = WltPkt(hdr=ag.Hdr(group_id=group_id), pkt=pkt_type(brg_mac=brg.id_int if brg else 0, seq_id=seq_id, **safe_kwargs))
+    if "ModuleEnergySub1G" in pkt_type.__name__ and BRG_PATTERN not in kwargs and test.data != DATA_SIMULATION:
+        # TODO - Remove on next api_version update - this is a patch for parameter name change from api version 11 to 12
+        brg_pattern = "sub1g_energy_" + BRG_PATTERN if brg.api_version < ag.API_VERSION_V12 else BRG_PATTERN
+        kwargs.update({brg_pattern: ag.SUB1G_ENERGY_PATTERN_ISRAEL})
+    brg_pkt = WltPkt(hdr=ag.Hdr(group_id=group_id), pkt=pkt_type(brg_mac=brg.id_int if brg else 0, seq_id=seq_id, **kwargs))
     return brg_pkt
 
 def config_brg_defaults(test, modules=[], ble5=False, wait=True, target=DUT):
@@ -400,7 +375,7 @@ def config_brg_defaults(test, modules=[], ble5=False, wait=True, target=DUT):
             utPrint(f"SUCCESS: {module.__name__} configured to defaults", "GREEN")
     return (test, DONE) if not failed_cfg else (test, NO_RESPONSE)
 
-def brg_ota(test, ble_version, search_ack=True, ble5=False, target=DUT, upgrader=TESTER, timeout=VER_UPDATE_TIMEOUT):
+def brg_ota(test, ble_version, search_ack=True, ble5=False, target=DUT, upgrader=TESTER):
     brg = get_brg_by_target(test, target)
     mqttc = test.get_mqttc_by_target(upgrader)
 
@@ -418,7 +393,7 @@ def brg_ota(test, ble_version, search_ack=True, ble5=False, target=DUT, upgrader
             gw_downlink(test=test, raw_tx_data=action_pkt.dump(), is_ota=True, version=ble_version, max_duration=BLE5_MAX_DURATION_MS, max_retries=BLE5_MAX_RETRIES, target=upgrader)
 
         # expected_hash=1 due to different cfgs and versions between builds
-        test = cert_common.reboot_config_analysis(test=test, expected_hash=1, ble_version=ble_version, timeout=timeout)
+        test = cert_common.reboot_config_analysis(test=test, expected_hash=1, ble_version=ble_version, timeout=VER_UPDATE_TIMEOUT)
         # for debug - print all logs to see failure reason
         cert_common.get_gw_logs_packets(test, print_log=True)
         if test.rc == TEST_FAILED and test.exit_on_param_failure:

certificate/cert_data_sim.py

@@ -23,10 +23,10 @@ SECONDARY_CHANNEL_10       = 10
 SECONDARY_CHANNEL_21       = 21
 
 # Randomize pixel simulation indicator once per run (6 hex chars)
-PIXEL_SIM_INDICATOR = get_random_hex_str(6)
+PIXEL_SIM_INDICATOR        = cert_utils.get_random_hex_str(6)
 
 def init_adva(flow_version_major=0x4, flow_version_minor=0x34):
-    return "{0:02X}".format(flow_version_major) + get_random_hex_str(8) + "{0:02X}".format(flow_version_minor)
+    return "{0:02X}".format(flow_version_major) + cert_utils.get_random_hex_str(8) + "{0:02X}".format(flow_version_minor)
 
 random_bytes = lambda n: int.from_bytes(os.urandom(n), "big")
 
@@ -41,16 +41,15 @@ def brg_pkt_gen(num_of_pkts_per_brg, num_of_brgs, brgs_list=[], pkt_type=PIXELS_
         if brgs_list:
             brg_mac = brgs_list[i]
         else:
-            brg_mac = cert_common.hex2alias_id_get(get_random_hex_str(12))
+            brg_mac = cert_common.hex2alias_id_get(cert_utils.get_random_hex_str(12))
             bridge_ids.append(brg_mac)
         adva = cert_common.change_endianness(brg_mac) # Change endianness to little endian
-
+        
         for j in range(num_of_pkts_per_brg):
-            serial_pkt_id = f"{i % 256:02X}{j % 256:02X}{idx:04X}"  # 8 hex chars - 4 bytes
-
+            serial_pkt_id = f"{i % 256:02X}{j % 256:02X}{idx:04X}"
+            
             if pkt_type == PIXELS_PKT:
-                payload = (ag.Hdr(group_id=ag.GROUP_ID_UNIFIED_PKT_V2).dump() +
-                           indicator + brg_mac + get_random_hex_str(22) + serial_pkt_id)
+                payload = ag.Hdr(group_id=ag.GROUP_ID_UNIFIED_PKT_V2).dump() + indicator + cert_utils.get_random_hex_str(34) + serial_pkt_id
 
             if pkt_type == MGMT_PKT:
                 mgmt_pkt = eval_pkt(f'GenericV{ag.API_VERSION_LATEST}')
@@ -58,12 +57,10 @@ def brg_pkt_gen(num_of_pkts_per_brg, num_of_brgs, brgs_list=[], pkt_type=PIXELS_
                 payload = ag.Hdr(group_id=ag.GROUP_ID_BRG2GW).dump() + body.dump()[:-14] + indicator + serial_pkt_id
 
             if pkt_type == SENSOR_PKT:
-                payload = (ag.Hdr(uuid_msb=ag.HDR_DEFAULT_BRG_SENSOR_UUID_MSB, uuid_lsb=ag.HDR_DEFAULT_BRG_SENSOR_UUID_LSB).dump() +
-                           indicator + brg_mac + get_random_hex_str(22) + serial_pkt_id)
+                payload = ag.Hdr(uuid_msb=ag.HDR_DEFAULT_BRG_SENSOR_UUID_MSB, uuid_lsb=ag.HDR_DEFAULT_BRG_SENSOR_UUID_LSB).dump() + indicator + cert_utils.get_random_hex_str(34) + serial_pkt_id
 
             if pkt_type == SIDE_INFO_SENSOR_PKT:
-                payload = (ag.Hdr(group_id=ag.GROUP_ID_SIDE_INFO_SENSOR).dump() +
-                           indicator + brg_mac + get_random_hex_str(22) + serial_pkt_id)
+                payload = ag.Hdr(group_id=ag.GROUP_ID_SIDE_INFO_SENSOR).dump() + indicator + cert_utils.get_random_hex_str(34) + serial_pkt_id
 
             idx += 1
             pkts += [GenericPkt(adva=adva, payload=payload)]

certificate/cert_defines.py

@@ -1,16 +1,11 @@
 # Files
 import os
-import random
 import datetime
 import importlib.metadata
 import certificate.ag.wlt_types_ag as ag
-
-get_random_hex_str = lambda n: ''.join([random.choice('0123456789ABCDEF') for _ in range(n)])
-
 # BASE_DIR should be initiated in the same dir as certificate.py
 BASE_DIR = os.path.dirname(os.path.abspath(__file__))
 ARTIFACTS_DIR = os.path.join(os.getcwd(), f"cert_artifacts_{datetime.datetime.now().strftime("%d_%m_%Y__%H_%M_%S")}")
-
 # CERT_VERSION handling - local/PyPi
 LOCAL_DEV = "local-dev"
 try:
@@ -19,7 +14,6 @@ except importlib.metadata.PackageNotFoundError:
     CERT_VERSION = LOCAL_DEV
 CERT_MQTT_LOG_FILE =            "cert_mqtt_log.json"
 DATA_SIM_LOG_FILE =             "data_sim_log.txt"
-RESULT_NOTES_FILE =             "results_notes.txt"
 UT_RESULT_FILE_HTML =           "results.html"
 UT_RESULT_FILE_PDF =            "results.pdf"
 UTILS_BASE_REL_PATH =           "../../../utils"
@@ -283,7 +277,6 @@ GW_LONGITUDE_DEFAULT =                      -117.0839
 GW_API_VER_DEFAULT =                "201"
 GW_API_VER_OLD =                    "200"
 GW_API_VER_LATEST =                 "206"
-API_OLDEST_SUPPORTED_VERSION =      ag.API_VERSION_V12
 BRG_CFG_HAS_LEN =                   2
 CLEAR_DATA_PATH_TIMEOUT =           10
 ACTION_LONG_TIMEOUT =               120
@@ -307,7 +300,6 @@ BLE5_MAX_DURATION_SEC =                             BLE5_MAX_DURATION_MS // 1000
 DATA_SIM_EVENT_TESTING_DELAY_SEC =                  DATA_SIM_EVENT_TESTING_DELAY_MS / 1000
 DATA_SIM_RSSI_EVENT_TESTING_DELAY_SEC =             DATA_SIM_RSSI_EVENT_TESTING_DELAY_MS / 1000
 DATA_SIM_EVENT_PACER_INTERVAL_TESTING =             10
-RSSI_EVENT_PKTS_TO_STABILIZE =                      13 # The alpha filter takes about 13 packets to stabilize
 PACKETS_ECHO_OFF =                                  16
 TEST_PASSED =                                       0
 TEST_FAILED =                                       -1
@@ -350,7 +342,6 @@ MODULE =                                            "module"
 NAME =                                              "name"
 DOCUMENTATION =                                     "documentation"
 ALL_SUPPORTED_VALUES =                              "allSupportedValues"
-SUPPORTED_FROM_API_VERSION =                        "SupportedFromApiVersion"
 PRE_CONFIG =                                        "Pre Configuration"
 TEST_BODY =                                         "Test Body"
 RESTORE_CONFIG =                                    "Restore Configuration"

certificate/cert_gw_sim.py

@@ -198,7 +198,7 @@ def gw_app_reponse(ble_serial):
     start_time = datetime.datetime.now()
     while (datetime.datetime.now() - start_time).seconds < 2:
         input = read_from_ble(ble_serial)
-        if input is not None and GW_APP_VERSION_HEADER in input:
+        if GW_APP_VERSION_HEADER in input:
             print(input)
             ble_chip_sw_ver = re.search(r'WILIOT_GW_BLE_CHIP_SW_VER=(\d+\.\d+\.\d+)', input).group(1)
             ble_mac_address = re.search(r'WILIOT_GW_BLE_CHIP_MAC_ADDRESS=([0-9A-F]{12})', input).group(1)
@@ -255,9 +255,6 @@ def interference_analysis(ble_serial):
         for key in CNTRS_KEYS:
             diff_dict[key] = handle_wrap_around(end_cntrs[key] - start_cntrs[key])
         bad_crc_percentage = round((diff_dict[BAD_CRC] / (diff_dict[WLT_RX] + diff_dict[NON_WLT_RX])) * 100)
-        notes_file_path = os.path.join(ARTIFACTS_DIR, RESULT_NOTES_FILE)
-        with open(notes_file_path, "a") as f:
-            f.write(f'Channel {channel[0]} ({channel[1]} MHz) Ambient Interference (bad CRC percentage): {bad_crc_percentage}%\n')
         print(color('WARNING', f'Channel {channel[0]} ({channel[1]} MHz) Ambient Interference (bad CRC percentage) is: {bad_crc_percentage}%'))
         print(f'Good CRC packets = {diff_dict[NON_WLT_RX] + diff_dict[WLT_RX] - diff_dict[BAD_CRC]}, bad CRC packets: {diff_dict[BAD_CRC]}')
 
@@ -327,42 +324,21 @@ def parse_uart_pkts(input, mqttc, custom_broker, gw_id, seq_id):
 def handle_cmds(input, ble_serial):
     if input.startswith(RX_NORDIC_RECOVER_RESET):
         utPrint(f"Simulator received reboot packet", "CYAN")
-        global GW_SIM_RESET_TS
         GW_SIM_RESET_TS = datetime.datetime.now()
         write_to_ble(ble_serial, RESET_GW, sleep=0)
     if input.startswith(RX_NORDIC_RECOVER_NORESET):
-        utPrint(f"COM tester recovered", "CYAN")
+        utPrint(f"Simulator recovered", "CYAN")
         write_to_ble(ble_serial, f"{CONNECTIVITY_STATUS} 1 1")
 
-def validate_port(port):
-    try:
-        with serial.serial_for_url(url=port, baudrate=921600, timeout=SERIAL_TIMEOUT,
-                                   write_timeout=SERIAL_TIMEOUT * 10) as ser:
-            ser.flushInput()
-            write_to_ble(ser, txt=VERSION, print_enable=True)
-            start_time = datetime.datetime.now()
-            while (datetime.datetime.now() - start_time).seconds < 2:
-                input = read_from_ble(ser)
-                if input is not None and GW_APP_VERSION_HEADER in input:
-                    return True
-            return False
-    except Exception as e:
-        utPrint(f"Failed to open serial: {e}", "RED")
-        return False
-
-
-def gw_sim_run(port, gw_id, custom_broker, disable_interference_analyzer=False):
+def gw_sim_run(port, gw_id, custom_broker, analyze_interference=False):
 
     # Init serial side
     if not port:
         print("\nNo COM port given. Scanning for available ports:")
         for port, desc, hwid in sorted(serial.tools.list_ports.comports()):
             print("{}: {} [{}]".format(port, desc, hwid))
-            if validate_port(port):
-                utPrint(f"Found the tester's port ({port})", "GREEN")
-                break
     if not port:
-        print("\nNo available COM port found! Please verify a tester is connected and set the correct --port parameter.")
+        print("\nNo available COM port found!")
         sys.exit(-1)
     print(f"###>>> GW SIM STARTED WITH PORT {port}")
     ble_serial = serial.serial_for_url(url=port, baudrate=921600, timeout=SERIAL_TIMEOUT)
@@ -391,19 +367,15 @@ def gw_sim_run(port, gw_id, custom_broker, disable_interference_analyzer=False):
     write_to_ble(ble_serial, RESET_GW, sleep=5)
     gw_app_res = gw_app_reponse(ble_serial)
     if gw_app_res[0] == TEST_FAILED:
-        utPrint("ERROR: didn't get version response! Please verify a tester is connected and set the correct --port parameter.", "RED")
-        sys.exit(1)
-    if gw_app_res[2] not in cert_utils.TESTER_FW_VERSIONS:
-        utPrint(f"ERROR: Tester FW version={gw_app_res[2]} instead of versions={cert_utils.TESTER_FW_VERSIONS}!\n"
-                f"Please run the command wlt-cert-tester-upgrade to upgrade the tester firmware!", "RED")
-        sys.exit(1)
+        print("ERROR: didn't get version response!")
+        return
     os.environ[GW_SIM_BLE_MAC_ADDRESS] = gw_app_res[1]
     os.environ[GW_APP_VERSION_HEADER] = gw_app_res[2]
     write_to_ble(ble_serial, STOP_ADVERTISING, sleep=2)
     write_to_ble(ble_serial, f"{CONNECTIVITY_STATUS} 1 1")
 
     # Run interference analysis
-    if not disable_interference_analyzer:
+    if analyze_interference:
         print(color("BLUE", f"\nStarting interference analysis for channels {[ch[0] for ch in CHANNELS_TO_ANALYZE]}. This will take {30 * len(CHANNELS_TO_ANALYZE)} seconds (total)"))
         interference_analysis(ble_serial)
 

certificate/cert_mqtt.py

@@ -198,8 +198,7 @@ def on_message_json(mqttc, userdata, message):
     wlt_mqtt_pkts = userdata[PKTS]
     data = json.loads(message.payload.decode("utf-8"))
     wlt_mqtt_pkts.insert(WltMqttPkt(data, message.topic, userdata))
-    text = json.dumps(json.loads(message.payload.decode("utf-8")), indent=4)
-    write_to_mqtt_log_file("// JSON message received at {}, topic={}:\n{}\n".format(datetime.datetime.now().strftime("%d/%m/%Y, %H:%M:%S"), message.topic, text))
+    write_to_mqtt_log_file("// JSON message received at {}, topic={}:\n{}\n".format(datetime.datetime.now().strftime("%d/%m/%Y, %H:%M:%S"), message.topic, str(message.payload.decode("utf-8"))))
 
 def on_message_protobuf(mqttc, userdata, message):
     pb_msg = None
@@ -223,8 +222,7 @@ def on_message_protobuf(mqttc, userdata, message):
         # Align formats with JSON (bytes to hex strings)
         if 'status' in message.topic:
             if ACTION_STATUS in pb_msg_dict:
-                if BRIDGE_ID in pb_msg_dict[ACTION_STATUS].keys():
-                    pb_msg_dict[ACTION_STATUS][BRIDGE_ID] = base64.b64decode(pb_msg_dict[ACTION_STATUS][BRIDGE_ID]).hex().upper()
+                pb_msg_dict[ACTION_STATUS][BRIDGE_ID] = base64.b64decode(pb_msg_dict[ACTION_STATUS][BRIDGE_ID]).hex().upper()
             if GW_STATUS in pb_msg_dict and ACL_IDS in pb_msg_dict[GW_STATUS][CONFIG][ACL][ACL_VALUE]:
                 ids_list = pb_msg_dict[GW_STATUS][CONFIG][ACL][ACL_VALUE][ACL_IDS]
                 for idx, id in enumerate(ids_list):
@@ -266,9 +264,9 @@ def load_custom_broker(broker_filepath, gw):
     except FileNotFoundError:
         raise FileNotFoundError(f"No such file: {broker_filepath}")
     data = json.load(f)
-    data[CUSTOM_BROKER_UPDATE_TOPIC] = data[CUSTOM_BROKER_UPDATE_TOPIC].replace(f'<{GW_ID}>', gw)
-    data[CUSTOM_BROKER_STATUS_TOPIC] = data[CUSTOM_BROKER_STATUS_TOPIC].replace(f'<{GW_ID}>', gw)
-    data[CUSTOM_BROKER_DATA_TOPIC] = data[CUSTOM_BROKER_DATA_TOPIC].replace(f'<{GW_ID}>', gw)
+    data[CUSTOM_BROKER_UPDATE_TOPIC] += gw
+    data[CUSTOM_BROKER_STATUS_TOPIC] += gw
+    data[CUSTOM_BROKER_DATA_TOPIC] += gw
     return data
 
 def mqttc_init(gw_id, custom_broker, data=DATA_REAL_TAGS):
@@ -300,14 +298,6 @@ def mqttc_init(gw_id, custom_broker, data=DATA_REAL_TAGS):
     mqttc.subscribe(mqttc.status_topic)
     print(f"Subscribed to status topic: {mqttc.status_topic}")
 
-    # v2 protobuf topics
-    mqttc.data_topic_pb = re.sub(r'^([^/]+)', r'\1-v2', custom_broker[CUSTOM_BROKER_DATA_TOPIC])
-    mqttc.subscribe(mqttc.data_topic_pb)
-    print(f"Subscribed to data topic: {mqttc.data_topic_pb}")
-    mqttc.status_topic_pb = re.sub(r'^([^/]+)', r'\1-v2', custom_broker[CUSTOM_BROKER_STATUS_TOPIC])
-    mqttc.subscribe(mqttc.status_topic_pb)
-    print(f"Subscribed to status topic: {mqttc.status_topic_pb}")
-
     mqttc.flush_pkts = mqttc._userdata[PKTS].flush
     mqttc.flush_data_pkts = mqttc._userdata[PKTS].flush_data
     mqttc.flush_status_pkts = mqttc._userdata[PKTS].flush_status

certificate/cert_prints.py

@@ -18,7 +18,6 @@ COLORS = {
 }
 color = lambda c, t : COLORS["BOLD"]+COLORS[c]+t+COLORS["ENDC"]
 pipeline_running = lambda : True if 'BITBUCKET_BUILD_NUMBER' in os.environ else False
-is_quiet_setup_running = lambda : True if 'CI_GW' in os.environ else False
 camelcase_to_title = lambda s: ' '.join(word.capitalize() for word in re.split('(?=[A-Z])', s))
 SEP = '\n' + '#'*100 + '\n'
 SEP2 = '\n' + '#'*100 + '\n' + '#'*100 + '\n'