wiliot-certificate 1.5.1a1__py3-none-any.whl → 1.5.3a1__py3-none-any.whl

brg_certificate/cert_common.py

@@ -15,9 +15,16 @@ DEFAULT_HDR = ag.Hdr(group_id=ag.GROUP_ID_GW2BRG)
 # Returns a 12 chars long hex string
 int2mac_get = lambda int_val: f"{int_val:012X}"
 
+# Returns True if running with bridge with cloud connectivity, else False
+is_bcc_running = lambda test: not (test.sim_mqttc == test.mqttc)
+
+# Returns True if running from PyPi package, else False
+is_cert_running = lambda : not (CERT_VERSION == LOCAL_DEV)
+
 def name_to_val(name):
     return globals()[name]
 
+
 def test_prolog(test):
     """
     kicks off the test:
@@ -154,8 +161,12 @@ def get_gw_geolocation(test):
         for p in test.mqttc._userdata[PKTS].status:
             if GW_INFO in p.body:
                 print_pkt(p.body)
-                gw_lat = p.body[GW_INFO][GW_LATITUDE]
-                gw_lng = p.body[GW_INFO][GW_LONGITUDE]
+                if test.protobuf:
+                    gw_lat = p.body[GW_INFO][ENTRIES][GW_LATITUDE][NUM_VAL]
+                    gw_lng = p.body[GW_INFO][ENTRIES][GW_LONGITUDE][NUM_VAL]
+                else:
+                    gw_lat = p.body[GW_INFO][GW_LATITUDE]
+                    gw_lng = p.body[GW_INFO][GW_LONGITUDE]
                 print(f"gw_lat:{gw_lat} \ngw_lng:{gw_lng}")
                 found = True
         print_update_wait()
@@ -406,7 +417,7 @@ def pacing_analysis(test, pacer_interval, df, pkt_filter_cfg=ag.PKT_FILTER_RANDO
     if pkt_filter_cfg != ag.PKT_FILTER_RANDOM_FIRST_ARRIVING_PKT:
         for pkt_type in list(df[PACKET_TYPE].unique()):
             if ((pkt_filter_cfg & (1 << pkt_type)) == 0
-                and not (is_ble5_test and test.internal_brg and pkt_type == ag.PKT_TYPE_BLE5_EXTENDED_TEMP_ADVANCED)):
+                and not (is_ble5_test and (test.internal_brg or is_bcc_running(test)) and pkt_type == ag.PKT_TYPE_BLE5_EXTENDED_TEMP_ADVANCED)):
                 test.rc = TEST_FAILED
                 test.add_reason(f"Tag is of packet type {pkt_type} which is turned off in packet_types_mask configuration!")
                 return test
@@ -414,7 +425,10 @@ def pacing_analysis(test, pacer_interval, df, pkt_filter_cfg=ag.PKT_FILTER_RANDO
     # Verify the tags count according to simulation data and pkt_filter_cfg
     tags_count = len(list(df[TAG_ID].unique()))
     if test.data == DATA_SIMULATION and num_of_pixels:
-        if pkt_filter_cfg == ag.PKT_FILTER_TEMP_AND_ADVANCED_PKTS or pkt_filter_cfg == ag.PKT_FILTER_TEMP_AND_DEBUG_PKTS:
+        if is_ble5_test and is_bcc_running(test):
+            # In ble5 bcc packet type 2 extended uploaded as is without splitting to ble4 packets
+            expected_tags_count = num_of_pixels
+        elif pkt_filter_cfg == ag.PKT_FILTER_TEMP_AND_ADVANCED_PKTS or pkt_filter_cfg == ag.PKT_FILTER_TEMP_AND_DEBUG_PKTS:
             expected_tags_count = num_of_pixels * 2
         elif pkt_filter_cfg == ag.PKT_FILTER_TEMP_ADVANCED_AND_DEBUG_PKTS:
             expected_tags_count = num_of_pixels * 3
@@ -440,16 +454,9 @@ def pacing_analysis(test, pacer_interval, df, pkt_filter_cfg=ag.PKT_FILTER_RANDO
             failed_tags += 1
             print(f"Tag {tag} with diff_time {list(pkts.timestamp.diff().div(1000))}, avg_pacer={avg_pacer} exceeds {PACER_INTERVAL_CEIL_THRESHOLD} maximum threshold!")
             if failed_tags/tags_count > 0.2: # Fail the test on ceil threshold only when more than 20 %  tag failed
+                test.add_reason(f"{failed_tags}/{tags_count} tags with wrong time diff")
                 test.rc = TEST_FAILED
 
-    # PASS test if only 1 tag out of many failed - this could be an issue with the tag
-    if tags_count >= PACER_INTERVAL_MIN_TAGS_COUNT and failed_tags <= PACER_INTERVAL_MAX_FAILED_TAGS:
-        test.rc = TEST_PASSED
-    # Addition to understand how many tags failed in total
-    if test.rc == TEST_FAILED:
-        test.add_reason(f"{failed_tags}/{tags_count} tags with wrong time diff")
-        print(test.reason)
-        return test
     return test
 
 def reboot_config_analysis(test, expected_hash, timeout=ACTION_LONG_TIMEOUT, ble_version=None, bl_version=None):
@@ -745,23 +752,10 @@ def brg_restore_defaults_check(test):
         print_update_wait()
     return test, revived, output
 
-def erase_sensors(test):
-    module = eval_pkt(f'ModuleExtSensorsV{test.active_brg.api_version}')
-    wltpkt = WltPkt(hdr=DEFAULT_HDR, pkt=eval_pkt(f'ModuleExtSensorsV{test.active_brg.api_version}')(brg_mac=test.active_brg.id_int, msg_type=ag.BRG_MGMT_MSG_TYPE_CFG_SET, seq_id=random.randrange(99),
-                                                                                   sensor0=0, sensor1=0))
-    print("Erasing all sensors from BRG {}".format(test.active_brg.id_int))
-    test = cert_config.brg_configure(test=test, cfg_pkt=wltpkt)[0]
-
-    if test.rc == TEST_FAILED:
-        test.add_reason("Failed to erase sensors! Didn't receive module ext sensors pkt")
-    else:
-        utPrint("SUCCESS! Module ext_sensors returned to default!", "GREEN")
-    return test
-
 # Pwr Mgmt
 def brg_pwr_mgmt_turn_on(test):
     utPrint("Sending pwr_mgmt static mode configuration - 30 seconds ON, 60 seconds SLEEP!", "BLUE")
-    module = eval_pkt(f'ModulePwrMgmtV{test.active_brg.api_version}')
+    module = test.active_brg.pwr_mgmt
     # send pwr mgmt module packet
     wltpkt = WltPkt(hdr=DEFAULT_HDR, pkt=module(module_type=ag.MODULE_PWR_MGMT, msg_type=ag.BRG_MGMT_MSG_TYPE_CFG_SET,
                                                       api_version=ag.API_VERSION_LATEST,seq_id=random.randrange(99),
@@ -778,7 +772,7 @@ def brg_pwr_mgmt_turn_on(test):
 
 def brg_pwr_mgmt_turn_off(test):
     utPrint("Turning pwr mgmt OFF - sending default configuration!", "BLUE")
-    module = eval_pkt(f'ModulePwrMgmtV{test.active_brg.api_version}')
+    module = test.active_brg.pwr_mgmt
     start_time = datetime.datetime.now()
     wltpkt = WltPkt(hdr=DEFAULT_HDR, pkt=module(module_type=ag.MODULE_PWR_MGMT, msg_type=ag.BRG_MGMT_MSG_TYPE_CFG_SET,
                                                       api_version=ag.API_VERSION_LATEST,seq_id=random.randrange(99),
@@ -814,4 +808,116 @@ def value_check_if_y(test, received_value, stage):
     if 'y' != received_value.lower():
         test.rc = TEST_FAILED
         test.add_reason(f"{stage} failed")
-    return test
+    return test
+
+
+##########################################
+# Signal Indicator functions
+##########################################
+def dual_polarization_ant_boards_get():
+    return [ag.BOARD_TYPE_MINEW_SINGLE_BAND_V0, ag.BOARD_TYPE_MINEW_DUAL_BAND_V0,
+            ag.BOARD_TYPE_ENERGOUS_V2, ag.BOARD_TYPE_ERM_V0, ag.BOARD_TYPE_ERM_V1,
+            ag.BOARD_TYPE_MINEW_POE_V0]
+
+def exp_sig_ind_pkts(tx_brg, rx_brg, cycles):
+    if tx_brg.board_type in dual_polarization_ant_boards_get():
+        tx_brg_ant_polarization_num = 2
+    else:
+        tx_brg_ant_polarization_num = 1
+    if rx_brg.board_type in dual_polarization_ant_boards_get():
+        rx_brg_ant_polarization_num = 2
+    else:
+        rx_brg_ant_polarization_num = 1
+
+    expected = cycles * tx_brg_ant_polarization_num * rx_brg_ant_polarization_num
+    # Allow missing 1 pkt
+    return [expected - 1, expected]
+
+def exp_sig_ind_pkts2(tx_brg, rx_brg, cycles):
+    if tx_brg.board_type in dual_polarization_ant_boards_get():
+        tx_brg_ant_polarization_num = 2
+    else:
+        tx_brg_ant_polarization_num = 1
+    if rx_brg.board_type in dual_polarization_ant_boards_get():
+        rx_brg_ant_polarization_num = 2
+    else:
+        rx_brg_ant_polarization_num = 1
+
+    expected = cycles * tx_brg_ant_polarization_num * rx_brg_ant_polarization_num
+    return expected
+
+def sig_ind_pkts_fail_analysis(tx_brg, rx_brg, cycles, received_pkts):
+
+    expected = exp_sig_ind_pkts2(tx_brg, rx_brg, cycles)
+    print(f"Expected pkts: {expected}, Received pkts: {len(received_pkts)}")
+    # Allow missing 25% max
+    if int(0.75 * expected) <= len(received_pkts) <= int(1.25 * expected):
+        return False
+    return True
+
+def get_all_sig_ind_pkts(test=None, rx_brg=None, tx_brg=None):
+    if rx_brg == test.brg1:
+        all_sensor_packets = cert_mqtt.get_all_brg1_ext_sensor_pkts(test=test)
+    elif rx_brg == test.brg0:
+        all_sensor_packets = cert_mqtt.get_all_sensor_pkts(test=test)
+    signal_ind_pkts = []
+    for p in all_sensor_packets:
+        if (p[SENSOR_UUID] == f"{ag.SENSOR_SERVICE_ID_SIGNAL_INDICATOR:06X}" and
+                p[BRIDGE_ID] == rx_brg.id_str and p[SENSOR_ID] == tx_brg.id_alias):
+            signal_ind_pkts.append(p)
+    return signal_ind_pkts
+
+def output_power_check(test, received_signal_ind_pkts, tx_brg_):
+
+    output_power_default = tx_brg_.datapath().output_power
+
+    for p in received_signal_ind_pkts:
+        if p[SENSOR_PKT].pkt.output_power != output_power_default:
+            test.rc = TEST_FAILED
+            test.add_reason("output power of internal brg  is incorrect!\n"
+                            f"got:{p[SENSOR_PKT].pkt.output_power}, expected: {output_power_default}\n")
+    return test
+
+def rssi_check(test, received_signal_ind_pkts):
+    threshold_rssi = [0, 80]
+    for p in received_signal_ind_pkts:
+        if not threshold_rssi[0] < p[RSSI] < threshold_rssi[1]:
+            test.rc = TEST_FAILED
+            test.add_reason("rssi value is wrong, out of 0 to 80 ")
+
+    return test
+
+
+def rx_tx_antenna_check(test, received_signal_ind_pkts, tx_brg_, rx_brg_, cycles):
+
+    # Allow to miss 1 packet or get 1 extra packet
+    expected = range(int(cycles * 0.5), cycles + 2)
+
+    received = len(get_polar_signal_ind_pkt(received_signal_ind_pkts, rx_ant=0, tx_ant=0))
+    if received not in expected:
+        test.rc = TEST_FAILED
+        test.add_reason(f"rx_ant=0 tx_ant=0 expected={cycles} received={received}")
+
+    if tx_brg_.board_type in dual_polarization_ant_boards_get():
+        received = len(get_polar_signal_ind_pkt(received_signal_ind_pkts, rx_ant=0, tx_ant=1))
+        if received not in expected:
+            test.rc = TEST_FAILED
+            test.add_reason(f"rx_ant=0 tx_ant=1 expected={cycles} received={received}")
+
+    if rx_brg_.board_type in dual_polarization_ant_boards_get():
+        received = len(get_polar_signal_ind_pkt(received_signal_ind_pkts, rx_ant=1, tx_ant=0))
+        if received not in expected:
+            test.rc = TEST_FAILED
+            test.add_reason(f"rx_ant=1 tx_ant=0 expected={cycles} received={received}")
+
+    if (rx_brg_.board_type in dual_polarization_ant_boards_get() and
+            tx_brg_.board_type in dual_polarization_ant_boards_get()):
+        received = len(get_polar_signal_ind_pkt(received_signal_ind_pkts, rx_ant=1, tx_ant=1))
+        if received not in expected:
+            test.rc = TEST_FAILED
+            test.add_reason(f"rx_ant=1 tx_ant=1 expected={cycles} received={received}")
+    return test
+
+
+def get_polar_signal_ind_pkt(pkts, rx_ant, tx_ant):
+    return [p for p in pkts if p[SENSOR_PKT].pkt.rx_antenna == rx_ant and p[SENSOR_PKT].pkt.tx_antenna == tx_ant]

brg_certificate/cert_config.py

@@ -161,7 +161,10 @@ def fields_n_vals_dict_get(fields, values):
     functionality_run_print(print_string)
     return fields_and_values
 
-def brg_configure(test, cfg_pkt=None, module=None, fields=None, values=None, wait=True, ret_cfg_pkt=False):
+def brg_configure(test, cfg_pkt=None, module=None, fields=None, values=None, wait=True, ret_cfg_pkt=False, ble5=False):
+    if ble5:
+        return brg_configure_ble5(test, cfg_pkt=cfg_pkt, module=module, fields=fields,
+                                  values=values, ret_cfg_pkt=ret_cfg_pkt, wait=wait)
     retries = 3
     if not cfg_pkt:
         fields_n_vals = fields_n_vals_dict_get(fields, values)
@@ -217,7 +220,9 @@ def brg_configure_ble5(test, cfg_pkt=None, module=None, fields=None, values=None
     wlt_pkt = WltPkt()
     start_time = datetime.datetime.now()
     gw_downlink(test=test, raw_tx_data=cfg_pkt.dump(), max_duration=BLE5_MAX_DURATION, max_retries=BLE5_MAX_RETRIES)
-    while not pkts_found and wait:
+    if wait is False:
+        return test, DONE
+    while not pkts_found:
         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
@@ -279,16 +284,16 @@ def get_default_brg_pkt(test, pkt_type, group_id=ag.GROUP_ID_GW2BRG, seq_id=0, *
         brg_pkt = WltPkt(hdr=ag.Hdr(group_id=group_id), pkt=pkt_type(brg_mac=test.active_brg.id_int if test.active_brg else 0, seq_id=seq_id, **kwargs))
         return brg_pkt
 
-def config_brg_defaults(test, modules=[], ble5=False):
+def config_brg_defaults(test, modules=[], ble5=False, wait=True):
     failed_cfg = False
     modules = test.active_brg.modules if not modules else modules
     for module in modules:
         utPrint(f"Configuring {module.__name__} to defaults. board type[{test.active_brg.board_type}] api version[{test.active_brg.api_version}]", "BLUE")
         cfg_pkt = get_default_brg_pkt(test, module)
         if ble5:
-            test, res = brg_configure_ble5(test=test, cfg_pkt=cfg_pkt)
+            test, res = brg_configure_ble5(test=test, cfg_pkt=cfg_pkt, wait=wait)
         else:
-            test, res = brg_configure(test=test, cfg_pkt=cfg_pkt)
+            test, res = brg_configure(test=test, cfg_pkt=cfg_pkt, wait=wait)
         if res == NO_RESPONSE:
             utPrint(f"FAILURE: {module.__name__} not configured to defaults", "RED")
             failed_cfg = True
@@ -296,9 +301,9 @@ def config_brg_defaults(test, modules=[], ble5=False):
             utPrint(f"SUCCESS: {module.__name__} configured to defaults", "GREEN")
     return (test, DONE) if not failed_cfg else (test, NO_RESPONSE)
 
-def config_brg1_defaults(test, modules=[], ble5=False):
+def config_brg1_defaults(test, modules=[], ble5=False, wait=True):
     test.active_brg = test.brg1
-    test, res = config_brg_defaults(test, modules, ble5)
+    test, res = config_brg_defaults(test, modules=modules, ble5=ble5, wait=wait)
     test.active_brg = test.brg0
     return test, res
 

brg_certificate/cert_data_sim.py

@@ -126,13 +126,28 @@ class WiliotPixelGen3Extended:
         adva-6 adi-2 hdr-7 nonce/pkt_id-4 uid-6 mic-6 payload0-8 payload1-8 """
         return self.adva + self.adi + self.hdr.dump() + self.get_pkt_id() + self.uid + self.mic + self.payload0 + self.payload1
 
+class RawData:
+    """Represents Explicit Data. Can be sensors, tags or anything else"""
+    def __init__(self, raw):
+        self.raw = raw
+
+    def __repr__(self) -> str:
+        return f'RawPkt: {self.get_pkt()}'
+
+    def set_pkt_type(self, _):
+        pass
+    def get_pkt(self):
+        return self.raw
+
 class DataSimThread(threading.Thread):
-    def __init__(self, test, num_of_pixels, duplicates, delay, pkt_types, pixels_type=GEN2):
+    def __init__(self, test, num_of_pixels, duplicates, delay, pkt_types, pixels_type=GEN2, pkts=[]):
         super().__init__()
         self.test = test
         self.num_of_pixels = num_of_pixels
-        # Create pixels list
-        if pixels_type == GEN2:
+        # Create data list
+        if pixels_type == RAW_DATA:
+            self.pixels = [RawData(p) for p in pkts]
+        elif pixels_type == GEN2:
             self.pixels = [WiliotPixelGen2() for _ in range(self.num_of_pixels)]
         elif pixels_type == GEN3:
             self.pixels = [WiliotPixelGen3() for _ in range(self.num_of_pixels)]
@@ -165,7 +180,9 @@ class DataSimThread(threading.Thread):
                     pkt.set_pkt_type(pkt_type)
 
                     # Set pkt_id, in Gen3 pkt_type_1 has pkt_id_0+1
-                    if type(pkt) == WiliotPixelGen3:
+                    if type(pkt) == RawData:
+                        pass
+                    elif type(pkt) == WiliotPixelGen3:
                         if pkt_type == 1:
                             if self.pkt_types == [0,1]:
                                 pkt.pkt_id += 1
@@ -194,6 +211,7 @@ class DataSimThread(threading.Thread):
                     write_to_data_sim_log_file(f"{pkt}" + " {}\n".format(datetime.datetime.now().strftime("%d/%m,%H:%M:%S.%f")[:-4]))
                     actual_delay = max(self.delay, self.duplicates*(PIXEL_SIM_MIN_CYCLE))
                     time.sleep(actual_delay/1000)
+
     def stop(self):
         """Stops the thread completely"""
         self._stop_event.set()

brg_certificate/cert_defines.py

@@ -4,16 +4,17 @@ import importlib.metadata
 # BASE_DIR should be initiated in the same dir as brg_certificate.py
 BASE_DIR = os.path.dirname(os.path.abspath(__file__))
 # CERT_VERSION handling - local/PyPi
+LOCAL_DEV = "local-dev"
 if hasattr(importlib.metadata,'packages_distributions') and "wiliot-certificate" in importlib.metadata.packages_distributions():
     CERT_VERSION = importlib.metadata.version("wiliot-certificate")
 else:
-    CERT_VERSION = "local-dev"
+    CERT_VERSION = LOCAL_DEV
 CERT_MQTT_LOG_FILE =            "cert_mqtt_log.json"
 DATA_SIM_LOG_FILE =             "data_sim_log.txt"
 UT_RESULT_FILE_HTML =           "results.html"
 UT_RESULT_FILE_PDF =            "results.pdf"
 UT_RESULT_FILE =                "results.html"
-UTILS_BASE_REL_PATH = "../../../utils"
+UTILS_BASE_REL_PATH =           "../../../utils"
 
 # GW defines
 GW_ID =                         "gatewayId"
@@ -56,6 +57,7 @@ WLT_SERVER =                    "wiliotServer"
 PACER_INTERVAL =                "pacerInterval"
 OUTPUT_POWER_2_4 =              "2.4GhzOutputPower"
 USE_STAT_LOC =                  "useStaticLocation"
+LOCATION =                      "location"
 GW_ENERGY_PATTERN =             "energizingPattern"
 VERSION =                       "version"
 WIFI_VERSION =                  "interfaceChipSwVersion"
@@ -105,6 +107,7 @@ DATA_REAL_TAGS =               'tags'
 GEN2 =                         2
 GEN3 =                         3
 GEN3_EXTENDED =                4
+RAW_DATA =                     5
 
 # Configurable brg fields' names by modules
 # common #
@@ -230,7 +233,7 @@ ACTION_SHORT_TIMEOUT =              5
 PACER_INTERVAL_MIN_TAGS_COUNT =                     20
 PACER_INTERVAL_MAX_FAILED_TAGS =                    2
 PACER_INTERVAL_THRESHOLD_HIGH =                     0.90
-PACER_INTERVAL_CEIL_THRESHOLD =                     1.1
+PACER_INTERVAL_CEIL_THRESHOLD =                     1.2
 PACER_INTERVAL_THRESHOLD =                          0.80
 PACKETS_ECHO_OFF =                                  16
 TEST_PASSED =                                       0
@@ -265,11 +268,13 @@ GW_ONLY_TEST =                                      "gwOnlyTest" # used for gw o
 INTERNAL_BRG =                                      "internalBridge"
 PURPOSE =                                           "purpose"
 MANDATORY =                                         "mandatory"
+MODULE =                                            "module"
+NAME =                                              "name"
 DOCUMENTATION =                                     "documentation"
 ALL_SUPPORTED_VALUES =                              "allSupportedValues"
-PRE_CONFIG =                                        "Pre config"
+PRE_CONFIG =                                        "Pre Configuration"
 TEST_BODY =                                         "Test Body"
-RESTORE_CONFIG =                                    "Restore config"
+RESTORE_CONFIG =                                    "Restore Configuration"
 
 # test reasons
 NO_PARAMS_GIVEN =           "No parameters given!"

brg_certificate/cert_gw_sim.py

@@ -215,12 +215,14 @@ def on_message(client, userdata, message):
 # GW SIMULATOR
 ##############################################
 def parse_uart_pkts(input, mqttc, custom_broker, gw_id, seq_id):
-    if input.startswith("p6 "):
+    # 3 for p6, 12 for alias_brg_id, 62 for payload, 2 for rssi
+    if input.startswith("p6 ") and len(input) == (3 + 12 + 62 + 2):
         # p6 1234567898761E16C6FC0000EE02093E3C71BF6DFA3C006648001CB8003A730160000E010031
         pkt = UplinkPkt(gw_id, seq_id, input.split()[1])
         mqttc.publish(custom_broker[CUSTOM_BROKER_DATA_TOPIC], payload=json.dumps(pkt.dump(), indent=4))
         return True
-    elif input.startswith("p7 "):
+    # 3 for p7, 12 for alias_brg_id, 78 for payload, 6 for side info, 2 for rssi
+    elif input.startswith("p7 ") and len(input) == (3 + 12 + 78 + 6 + 2):
         # p7 1234567898762616C6FC05000002093E3C71BF6DFA3C006648001CB8003A730160000E0100112233445566778831
         pkt = UplinkExtendedPkt(gw_id, seq_id, input.split()[1])
         mqttc.publish(custom_broker[CUSTOM_BROKER_DATA_TOPIC], payload=json.dumps(pkt.dump(), indent=4))

brg_certificate/cert_mqtt.py

@@ -287,7 +287,7 @@ def get_undecrypted_data_pkts_count(mqttc):
             undecrypted += p.body_ex['undecrypted']
     return undecrypted
 
-def get_all_sensor_pkts(mqttc, test, is_embedded=False):
+def get_all_sensor_pkts(test, is_embedded=False):
     all_sensor_pkts = couple_sensor_data_si_coupling(test)
     all_sensor_pkts = [p for p in all_sensor_pkts if test.active_brg.id_str == p[BRIDGE_ID] and (p[IS_EMBEDDED] == is_embedded)]
     return all_sensor_pkts
@@ -339,16 +339,17 @@ def count_pkt_id_duplications(test, all_sensor_data_pkts, all_sensor_side_info_p
         coupled_pkt[PKT_ID_CTR] = pkt_ids.count(_pkt_id)
         if coupled_pkt[PKT_ID_CTR] > SENSORS_DATA_SI_DUP:
             print(f"pkt_id {_pkt_id:08X}: {coupled_pkt[PKT_ID_CTR]} occurrences")
-            test.reason = f'Warning: {coupled_pkt[PKT_ID_CTR]} sensor data and si with pkt id 0x{_pkt_id:08X}'
+            #TODO: logging print(debug)
+            # test.reason = f'Warning: {coupled_pkt[PKT_ID_CTR]} sensor data and si with pkt id 0x{_pkt_id:08X}'
 
-def get_all_brg1_ext_sensor_pkts(mqttc, test=None):
+def get_all_brg1_ext_sensor_pkts(test=None):
     test.active_brg = test.brg1
-    pkts = get_all_sensor_pkts(mqttc, test)
+    pkts = get_all_sensor_pkts(test)
     test.active_brg = test.brg0
     return pkts
 
-def get_all_custom_pkts(mqttc, test=None):
-    return get_all_sensor_pkts(mqttc, test, is_embedded=True)
+def get_all_custom_pkts(test=None):
+    return get_all_sensor_pkts(test, is_embedded=True)
 
 def get_all_mgmt_pkts(mqttc):
     all_data_pkts = get_all_data_pkts(mqttc)

brg_certificate/cert_prints.py

@@ -22,6 +22,7 @@ color = lambda c, t : COLORS["BOLD"]+COLORS[c]+t+COLORS["ENDC"]
 pipeline_running = lambda : True if 'BITBUCKET_BUILD_NUMBER' 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'
 WIL_CERT_TEXT = r'''
  __        _____ _     ___ ___ _____    ____ _____ ____ _____ ___ _____ ___ ____    _  _____ _____ 
  \ \      / /_ _| |   |_ _/ _ \_   _|  / ___| ____|  _ \_   _|_ _|  ___|_ _/ ___|  / \|_   _| ____|
@@ -65,17 +66,23 @@ def mqtt_scan_wait(test, duration):
         i += 1
     print("\n")
 
+def mqtt_scan_n_create_log_file(test, duration, phase):
+    test.mqttc.flush_pkts()
+    mqtt_scan_wait(test, duration=duration)
+    generate_log_file(test, phase)
+
 def print_update_wait(secs=1):
     sys.stdout.write(".")
     sys.stdout.flush()
     time.sleep(secs)
 
 def field_functionality_pass_fail_print(test, field, value=""):
-    print_string = "{}={}".format(field, value)
+    print_string = f"{field}={value}"
     if value == "":
         print_string = str(field)
     if test.rc == TEST_FAILED:
         utPrint(print_string + " functionality failed!", "RED")
+        utPrint(test.reason, "RED")
     elif test.rc == TEST_SKIPPED:
         utPrint(print_string + " functionality skipped!", "WARNING")
     else:
@@ -127,6 +134,12 @@ def functionality_run_print(func):
     cert_mqtt.write_to_mqtt_log_file(txt)
     cert_data_sim.write_to_data_sim_log_file(txt)
 
+def phase_run_print(func):
+    txt = f"{SEP2}==>> Phase {func}{SEP2}\n"
+    utPrint(txt, "CYAN")
+    cert_mqtt.write_to_mqtt_log_file(txt)
+    cert_data_sim.write_to_data_sim_log_file(txt)
+
 
 def generate_print_string(fields_and_values):
     list_to_print = []

brg_certificate/cert_protobuf.py

@@ -36,19 +36,19 @@ def gw_cfg_pb(msg: dict):
         pb_msg.gatewayConfig.bleSwVersion = msg[BLE_VERSION]
 
     for key, val in msg[ADDITIONAL].items():
-        # Skip GW_MODE since it doesn't exist today and harm the parsing in PB
-        if GW_MODE == key:
+        # Skip GW_MODE since it doesn't exist today and harm the parsing in PB, and skip lat & lng to create duplicate values
+        if key == GW_MODE or key == LAT or key == LNG:
             continue
         pb_value = wpb.GatewayConfigValue()
-        if isinstance(val, int):
+        if type(val) is int:
             pb_value.integerValue = val
-        elif isinstance(val, float):
+        elif type(val) is float:
             pb_value.numberValue = val
-        elif isinstance(val, str):
+        elif type(val) is str:
             pb_value.stringValue = val
-        elif isinstance(val, bool):
+        elif type(val) is bool:
             pb_value.boolValue = val
-        elif isinstance(val, dict) and key == ACL:
+        elif type(val) is dict and key == ACL:
             pb_value.aclValue.mode_allow = ACL_DENY_VALUE if msg[ADDITIONAL][ACL][ACL_MODE] == ACL_DENY else ACL_ALLOW_VALUE
             ids_bytes = [bytes.fromhex(id) for id in msg[ADDITIONAL][ACL][ACL_BRIDGE_IDS]]
             pb_value.aclValue.ids.extend(ids_bytes)