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

brg_certificate/ag/wlt_cmd_if.html

@@ -26,6 +26,7 @@ tr:nth-child(odd) {
 <table>
 <tr><th>Name</th><th>Shortcut</th><th>Num of Arguments</th><th>Description</th><th>Example</th></tr>
 <tr><td>energous</td><td>NONE</td><td>SKIP_ARGS_VALIDATION</td><td></td><td></td></tr>
+<tr><td>esp</td><td>NONE</td><td>SKIP_ARGS_VALIDATION</td><td></td><td>!esp reset</td></tr>
 <tr><td>ant_sel_mode_set</td><td>asms</td><td>1</td><td>set antenna polarity mode, whereas 0 = random_toggle, 1 = clear, 2 = set, 3 = toggle</td><td>!ant_sel_mode_set 1</td></tr>
 <tr><td>ant_sel_set</td><td>ass</td><td>1</td><td>Set the antenna select pin to be 0 or 1</td><td>!ant_sel_set 1</td></tr>
 <tr><td>pwr_cal_set</td><td>pcs</td><td>2</td><td>Set power calibration value (used by Energous during production line)</td><td>!pwr_cal_set 127 124</td></tr>
@@ -92,9 +93,9 @@ tr:nth-child(odd) {
 <tr><td>calib_pattern</td><td>cp</td><td>1</td><td>Set new configuration for Calibration Pattern, could be - {0: 'Standard beaconing', 1: 'No beacons on channel 37', 2: 'EU pattern', 3: 'Disable communication beaconing'}</td><td>!cp 0</td></tr>
 <tr><td>signal_indicator_2_4_set</td><td>si24</td><td>2</td><td>Set a new configuration for 2.4GHz signal_indicator packets cycle. The cycle is the duration in seconds between transmission of signal indicator packets. Min - 0 , Max - 16383. 0 - disable the transmission. When the 'Signal Indicator Cycle' is 0 repetitions value is irrelevant. repetitions Min - 1, Max - 4</td><td>!si24 60 4</td></tr>
 <tr><td>signal_indicator_sub1g_set</td><td>sis</td><td>2</td><td>Set a new configuration for sub1g signal_indicator packets cycle and repetition. The cycle is the duration in seconds between transmission of signal indicator packets. Min - 0 , Max - 16383. 0 - disable the transmission. When the 'Signal Indicator Cycle' is 0 repetitions value is irrelevant. repetitions Min - 1, Max - 4</td><td>!sis 60 4</td></tr>
-<tr><td>test_mode_2_4_set</td><td>tm24</td><td>3</td><td>Test mode for the 2.4Ghz radio, Frequency [2400-2480 MHz]; Power (before PA that can add ~20) [+8 dBm to -12 dBm]; Test Duration [Seconds]</td><td>!tm24 2400 2 20</td></tr>
+<tr><td>test_mode_2_4_set</td><td>tm24</td><td>3</td><td>Test mode for the 2.4Ghz radio, Frequency [2400-2480 MHz]; Power (before PA that can add ~20) [+8 dBm to -12 dBm]; Test Duration [Seconds]</td><td>!tm24 2400 2 30</td></tr>
 <tr><td>test_mode_sub1g_set</td><td>tms</td><td>5</td><td>Test mode for the Sub1G radio, Frequency [905000-920000 kHz], Output Power (before PA that can add ~20) ,On time [milliseconds], Off time [milliseconds]; Test Duration[Seconds]</td><td>!tms 905000 4 20 60 20</td></tr>
-<tr><td>test_mode_operational_2_4_set</td><td>tmo24</td><td>3</td><td>Test mode for various 2.4Ghz operational modes: Pattern [0=Beacons 37/38/39, 1=Beacons 38/38/39, 2=EU pattern]; Power [+8 dBm to -12 dBm , before PA that can add ~20 [dBm]]; Test Duration[Seconds]</td><td>!tmo24 0 2</td></tr>
+<tr><td>test_mode_operational_2_4_set</td><td>tmo24</td><td>3</td><td>Test mode for various 2.4Ghz operational modes: Pattern [0=Beacons 37/38/39, 1=Beacons 38/38/39, 2=EU pattern]; Power [+8 dBm to -12 dBm , before PA that can add ~20 [dBm]]; Test Duration[Seconds]</td><td>!tmo24 0 2 30</td></tr>
 <tr><td>test_mode_operational_sub1g_set</td><td>tmos</td><td>3</td><td>Test mode for various sub1G operational modes: Pattern [0=No energy, 1=Single one 915M, 2=FCC Hopping, 3=Japan_1W, 4=Jappan_350mW, 5=Korea, 6=916.3 MHz, 7=917.5 mHz,8=Australia, 9=Israel, 10=NZ Hopping; Output Power (before PA that can add ~20); Test Duration[Seconds]</td><td>!tmos 2 4 60</td></tr>
 
 </table>

brg_certificate/brg_certificate_cli.py

@@ -1,22 +1,37 @@
 import sys
 import os
 sys.path.insert(0, os.path.abspath(".."))
-from argparse import ArgumentParser
+from argparse import ArgumentParser, RawDescriptionHelpFormatter
 from brg_certificate.cert_defines import DATA_REAL_TAGS, DATA_SIMULATION
 import brg_certificate.brg_certificate as brg_certificate
-TEST_LIST_DEFAULT_FILE = "certificate_sanity_test_list.txt"
+TEST_LIST_DEFAULT_FILE = "certificate_test_list.txt"
 
 class BrgCertificateCLI:
     """Bridge Certificate CLI."""
     def __init__(self):
         self.parser = ArgumentParser(
             description="Bridge Certificate CLI",
+            epilog=
+            "run examples:\n"
+            "  Run command example with COM PORT connection:\n"
+            "  wlt-cert-brg --gw SIM --brg <XXXXXXXXXXXX> --port <COM_PORT>\n"
+            "  Run command example with remote GW connection:\n"
+            "  wlt-cert-brg --gw <YYYYYYYYYYYY> --brg <XXXXXXXXXXXX>\n"
+            "  Run command example for running datapath module tests only:\n"
+            "  wlt-cert-brg --gw <YYYYYYYYYYYY> --brg <XXXXXXXXXXXX> --run datapath\n"
+            "  Run command example with sanity test list:\n"
+            "  wlt-cert-brg --gw <YYYYYYYYYYYY> --brg <XXXXXXXXXXXX> --tl certificate_sanity_test_list.txt\n"
+            "  Run command example with COM PORT connection for bridge with cloud connectivity:\n"
+            "  wlt-cert-brg --gw SIM --brg_cloud_connectivity <XXXXXXXXXXXX> --tl certificate_bcc_test_list.txt --port <COM_PORT>\n"
+            "  Run command example with remote GW connection for bridge with cloud connectivity:\n"
+            "  wlt-cert-brg --gw <YYYYYYYYYYYY> --brg_cloud_connectivity <XXXXXXXXXXXX> --tl certificate_bcc_test_list.txt\n",
+            formatter_class=RawDescriptionHelpFormatter
         )
         self.parser.add_argument('--brg', '-b', default="", help='Bridge id to run on the tests')
         self.parser.add_argument('--brg_cloud_connectivity', '-bcc', default="", help='Bridge with cloud connectivity id to run on the tests')
         self.parser.add_argument('--brg1', '-b1', default="", help='Second bridge id to run on tests two bridges needed')
         self.parser.add_argument('--gw', '-g', type=str, required=True, help='GW id to run on the test, SIM prefix is used for Gateway simulation')
-        self.parser.add_argument('--data', '-d', choices=[DATA_REAL_TAGS, DATA_SIMULATION], default=DATA_REAL_TAGS, help='Choose if data generated from real tags or by simulation')
+        self.parser.add_argument('--data', '-d', choices=[DATA_REAL_TAGS, DATA_SIMULATION], default=DATA_SIMULATION, help='Choose if data generated from real tags or by simulation')
         self.parser.add_argument('--port', '-p', default='', help='Enable UT using UART connection for Gateway Simulation or Data Simulation')
         self.parser.add_argument('--clean', default=False, action='store_true', help='Clean all logs')
         self.parser.add_argument('--tl', type=str, help='Test list file to use', default=TEST_LIST_DEFAULT_FILE)

brg_certificate/cert_common.py

@@ -15,9 +15,24 @@ 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 get_module_by_name(modules, name):
+    # Get module from active modules in device (loaded from board type ag defines)
+    for module in modules:
+        if name in module.__name__:
+            return module
+    return None
+
+
 def test_prolog(test):
     """
     kicks off the test:
@@ -154,8 +169,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 +425,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 +433,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 +462,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,19 +760,6 @@ 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")
@@ -814,4 +816,58 @@ 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

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)