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

brg_certificate/brg_certificate.py

@@ -38,6 +38,8 @@ def skip_test_check(test, args):
     skip_string = ""
     if test.multi_brg and not test.brg1:
         skip_string = f"Skipped {test.module_name} multi brg test because brg1 wasn't given"
+    elif (args.brg_cloud_connectivity or test.internal_brg) and not test.test_json[INTERNAL_BRG]:
+        skip_string = f"Skipped {test.module_name} because test is unable to run on an internal brg"
     elif args.skip_internal and test.internal_brg:
         skip_string = f"Skipped {test.module_name} for internal brg because skip_internal flag is set"
     elif test.active_brg and not test.active_brg.is_sup_cap(test):
@@ -86,7 +88,16 @@ def main(args):
             sys.exit(0)
 
     # Init mqtt client
-    mqttc = cert_mqtt.mqttc_init(args.gw, data=args.data)
+    if args.brg_cloud_connectivity:
+        # Mqtt client for tested device
+        mqttc = cert_mqtt.mqttc_init(args.brg_cloud_connectivity, data=args.data)
+        # Mqtt client for testing device
+        sim_mqttc = cert_mqtt.mqttc_init(args.gw, data=args.data)
+    else:
+        # Single mqtt client for a single device with cloud connectivity
+        mqttc = cert_mqtt.mqttc_init(args.gw, data=args.data)
+        sim_mqttc = mqttc
+
 
     # Run Gateway Simulator in separated thread if exists
     gw_sim_thread = None
@@ -105,12 +116,29 @@ def main(args):
 
     # Prepare GW
     if gw_sim_thread:
-        gw, internal_brg, gw_server, gw_version, protobuf = cert_gw_sim.prep_gw(args, mqttc, start_time)
+        if args.brg_cloud_connectivity:
+            # Prepare tested device
+            gw, internal_brg, gw_server, gw_version, protobuf = ut_prep_gw(args, mqttc, start_time)
+            # Prepare testing device
+            _, internal_brg_sim, _, _, _ = cert_gw_sim.prep_gw(args, sim_mqttc, start_time)
+        else:
+            # Prepare single device with cloud connectivity
+            gw, internal_brg, gw_server, gw_version, protobuf = cert_gw_sim.prep_gw(args, mqttc, start_time)
     else:
-        gw, internal_brg, gw_server, gw_version, protobuf = ut_prep_gw(args, mqttc, start_time)
+        if args.brg_cloud_connectivity:
+            # Prepare tested device
+            gw, internal_brg, gw_server, gw_version, protobuf = ut_prep_gw(args, mqttc, start_time)
+            # Prepare testing device
+            _, internal_brg_sim, _, _, _ = ut_prep_gw(args, sim_mqttc, start_time, tester_gw=True)
+        else:
+            # Prepare single device with cloud connectivity
+            gw, internal_brg, gw_server, gw_version, protobuf = ut_prep_gw(args, mqttc, start_time)
 
     brg0, brg1 = None, None
-    if args.brg:
+    if args.brg_cloud_connectivity:
+        brg0 = internal_brg
+        internal_brg = internal_brg_sim
+    elif args.brg:
         brg0 = ut_prep_brg(args, mqttc, start_time, gw, args.brg, gw_server, protobuf)
         if args.brg1:
             brg1 = ut_prep_brg(args, mqttc, start_time, gw, args.brg1, gw_server, protobuf)
@@ -119,7 +147,7 @@ def main(args):
     tests = []
     for l in open(os.path.join(BASE_DIR, test_list)).readlines():
         if l.strip() and not l.strip().startswith("#"):
-            test = (WltTest(l.strip(), gw, mqttc, exit_on_param_failure=args.exit_on_param_failure, gw_lan=args.lan,
+            test = (WltTest(l.strip(), gw, mqttc, sim_mqttc=sim_mqttc, exit_on_param_failure=args.exit_on_param_failure, gw_lan=args.lan,
                     gw_orig_versions={BLE_VERSION:gw_version[BLE_VERSION], WIFI_VERSION:gw_version[WIFI_VERSION]},
                     server=gw_server, latest=args.latest, release_candidate=args.rc, private_setup=args.private_setup, internal_brg_obj=internal_brg,
                     gw_sim=gw_sim_thread, data=args.data, port=args.port, protobuf=protobuf))
@@ -150,6 +178,8 @@ def main(args):
         test_module_name = load_module(f'{test.module_name}.py', f'{test.dir}/{test.module_name}.py')
         test = skip_test_check(test, args)
         if test.rc == TEST_SKIPPED:
+            for phase in test.phases:
+                phase.rc = TEST_SKIPPED
             skipped += 1
         else:
             test = test_module_name.run(test)
@@ -182,8 +212,9 @@ def main(args):
     print_pass_or_fail(not failures, f"Wiliot Certificate")
 
     pipeline = cert_common.pipeline_running()
-    cert_results.generate_results_files(html=True, pdf=True, failures=failures, skipped=skipped, start_time=start_time, duration=duration, brg_version=brg_version,
-                                        brg=args.brg, gw_ble_version = gw_version[BLE_VERSION], gw_ble_mac = internal_brg.id_str, tests=tests, pipeline=pipeline)
+    # brg = args.brg_cloud_connectivity if args.brg_cloud_connectivity else args.brg
+    cert_results.generate_results_files(html=True, pdf=True, failures=failures, skipped=skipped, start_time=start_time, duration=duration,
+                                        brg=test.active_brg, internal_brg=internal_brg, tests=tests, pipeline=pipeline)
     if not pipeline:
         webbrowser.open('file://' + os.path.realpath(os.path.join(BASE_DIR, UT_RESULT_FILE_PDF)))
 

brg_certificate/brg_certificate_cli.py

@@ -1,21 +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
@@ -439,17 +461,10 @@ def pacing_analysis(test, pacer_interval, df, pkt_filter_cfg=ag.PKT_FILTER_RANDO
         if test.data == DATA_SIMULATION and (avg_pacer / pacer_interval) > PACER_INTERVAL_CEIL_THRESHOLD:
             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 > 1: # Fail the test on ceil threshold only when more than one tag failed
+            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):
@@ -527,12 +542,14 @@ def scan_for_mgmt_pkts(test, mgmt_type):
         print_update_wait()
         pkts_collected = cert_mqtt.get_brg2gw_mgmt_pkts(test.mqttc, test, mgmt_types=mgmt_type)
         if pkts_collected:
-            utPrint("Found brg2gw_mgmt_pkts:", "GREEN")
+            #TODO: logging print 
+            # utPrint("Found brg2gw_mgmt_pkts:", "GREEN")
             seq_ids = []
             for p in pkts_collected:
                 if seq_ids == [] or p[SEQUENCE_ID] not in seq_ids:
                     seq_ids.append(p[SEQUENCE_ID])
-                    print(p[MGMT_PKT].pkt)
+                    #TODO: Logging print 
+                    # print(p[MGMT_PKT].pkt)
                     ret_pkts.append(p)
             found = True
             break
@@ -721,25 +738,6 @@ def get_cfg_hash(test):
     else:
         return test, module_if_pkt.cfg_hash
 
-def module_ack_search(test, test_pkt, mgmt_type, wait=True):
-    """
-    module ack search
-    wait=False is for pwr mgmt off - in order to send the "off" pkt repeatidly while searching for the ack
-    """
-    if wait:
-        test, mgmt_pkts = scan_for_mgmt_pkts(test, [mgmt_type])
-    else:
-        mgmt_pkts = cert_mqtt.get_brg2gw_mgmt_pkts(test.mqttc, test, mgmt_types=[mgmt_type])
-    if not test.rc:
-        for p in mgmt_pkts:
-            pkt = p[MGMT_PKT].pkt
-            if (pkt == test_pkt.pkt):
-                return test, True
-        if wait:
-            test.rc = TEST_FAILED
-            test.add_reason(f"{mgmt_type} module does not match pkt received")
-            print(test.reason)
-    return test, False
 
 def brg_restore_defaults_check(test):
     print("Starting Restore Defaults Check")
@@ -762,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")
@@ -785,8 +770,7 @@ def brg_pwr_mgmt_turn_on(test):
                                                       brg_mac=test.active_brg.id_int, static_on_duration=30, static_sleep_duration=60,
                                                       dynamic_leds_on=0,dynamic_keep_alive_period=0, dynamic_keep_alive_scan=0,
                                                       dynamic_on_duration=0,dynamic_sleep_duration=0))
-    cert_config.gw_downlink(test, raw_tx_data=wltpkt.dump())
-    test = module_ack_search(test, test_pkt=wltpkt, mgmt_type=module)[0]
+    test = cert_config.brg_configure(test=test, cfg_pkt=wltpkt, module=module)[0]
 
     if test.rc == TEST_FAILED:
         test.add_reason("Turning pwr mgmt ON failed, Didn't receive GW MEL pwr mgmt ON pkt")
@@ -805,16 +789,15 @@ def brg_pwr_mgmt_turn_off(test):
                                                       static_on_duration=0,static_sleep_duration=0,
                                                       dynamic_leds_on=0,dynamic_keep_alive_period=0,
                                                       dynamic_keep_alive_scan=0,dynamic_on_duration=0,dynamic_sleep_duration=0))
-    found = False
-    while not found:
-        cert_config.gw_downlink(test, raw_tx_data=wltpkt.dump())
-        test, found = module_ack_search(test, wltpkt, module, wait=False)
+    found = NOT_FOUND
+    while found != DONE:
+        test, found = cert_config.brg_configure(test=test, cfg_pkt=wltpkt, module=module, wait=False)
         if ((datetime.datetime.now() - start_time).seconds > (ag.PWR_MGMT_DEFAULTS_KEEP_ALIVE_PERIOD + 1)):
             test.add_reason(f"Didn't receive GW MEL pwr mgmt OFF ack after {ag.PWR_MGMT_DEFAULTS_KEEP_ALIVE_PERIOD + 1} seconds")
             test.rc = TEST_FAILED
             break
         print_update_wait()
-    if found:
+    if found == DONE:
         utPrint(f"FOUND off pkt after {(datetime.datetime.now() - start_time)} secs", "GREEN")
         utPrint("SUCCESS! pwr mgmt static mode turned off!", "GREEN")
     return test
@@ -833,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_config.py

@@ -64,7 +64,8 @@ def create_gw_config(test, cfg, version=""):
 
 def gw_downlink(test, raw_tx_data="", is_ota=False, version="", max_duration=100, max_retries=8):
     pkt = create_gw_downlink_pkt(test, raw_tx_data, is_ota, version=version, max_duration=max_duration, max_retries=max_retries)
-    print("GW Downlink:", pkt)
+    #TODO: logging print
+    # print("GW Downlink:", pkt)
     payload = cert_protobuf.downlink_to_pb(pkt) if test.protobuf else json.dumps(pkt)
     test.mqttc.publish(test.mqttc.update_topic, payload=payload, qos=1)
 
@@ -73,9 +74,9 @@ def create_gw_downlink_pkt(test, raw_tx_data="", is_ota=False, version="", max_d
                 TX_MAX_DURATION_MS: max_duration,
                 TX_MAX_RETRIES: max_retries})
     if is_ota == False:
-        ret[ACTION] = 0
+        ret[ACTION] = ACTION_ADVERTISING
     else:
-        ret[ACTION] = 1
+        ret[ACTION] = ACTION_BRG_OTA
         ret[GW_ID] = str(test.gw)
         ret[BRIDGE_ID] = test.active_brg.id_str
         ret[IMG_DIR_URL] = f"https://api.us-east-2.prod.wiliot.cloud/v1/bridge/type/{test.active_brg.board_type}/version/{version}/binary/"
@@ -262,7 +263,8 @@ def internal_brg_configure(test, cfg_pkt=None, module=None, fields=None, values=
     return test, res
 
 def send_brg_action(test, action_id, **kwargs):
-    print(f"\nSending {ag.ACTIONS_DICT[action_id]}{test.active_brg.api_version} with parameters={kwargs if kwargs else None}")
+    #TODO: logging print
+    # print(f"\nSending {ag.ACTIONS_DICT[action_id]}{test.active_brg.api_version} with parameters={kwargs if kwargs else None}")
     test.mqttc.flush_pkts()
     action_pkt = get_default_brg_pkt(test, pkt_type=eval_pkt(f'{ag.ACTIONS_DICT[action_id]}{test.active_brg.api_version}'), **kwargs)
     gw_downlink(test, raw_tx_data=action_pkt.dump())

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)]
@@ -144,18 +159,30 @@ class DataSimThread(threading.Thread):
         self.delay = delay
         self.pkt_types = pkt_types
         self._stop_event = threading.Event()
+        self._pause_event = threading.Event()
+        self._pause_event.set()
         self.daemon = True
 
     def run(self):
         write_to_data_sim_log_file(f"num_of_pixels={self.num_of_pixels} duplicates={self.duplicates} delay={self.delay} pkt_types={self.pkt_types}\n")
         # Run pixel_sim loop
         while not self._stop_event.is_set():
+            self._pause_event.wait()
             for i in range(self.num_of_pixels):
+                if self._stop_event.is_set():
+                    return  
+                if not self._pause_event.is_set():
+                    break
                 for pkt_type in self.pkt_types:
+                    if not self._pause_event.is_set():
+                        break
                     pkt = self.pixels[i]
                     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
@@ -175,14 +202,27 @@ class DataSimThread(threading.Thread):
                         TX_MAX_RETRIES: self.duplicates,
                         TX_MAX_DURATION_MS: 100,
                         ACTION: 0}
-                    if self.test.protobuf == True:
+                    # Use protobuf if protubuf flag is set to True AND data sim does not use a gw simulator board
+                    if self.test.protobuf == True and not self.test.gw_sim:
                         payload = cert_protobuf.downlink_to_pb(msg)
                     else:
                         payload = json.dumps(msg)
-                    self.test.mqttc.publish(self.test.mqttc.update_topic, payload=payload)
+                    self.test.sim_mqttc.publish(self.test.sim_mqttc.update_topic, payload=payload)
                     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):
-        self._stop_event.set()
+        """Stops the thread completely"""
+        self._stop_event.set()
+        write_to_data_sim_log_file(f"DataSimThread stopped\n")
+
+    def pause(self):
+        """Pauses the thread execution"""
+        self._pause_event.clear()
+        write_to_data_sim_log_file(f"DataSimThread paused\n")
+
+    def resume(self):
+        """Resumes the thread execution"""
+        self._pause_event.set()
+        write_to_data_sim_log_file(f"DataSimThread resumed\n")

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
-if "wiliot-certificate" in importlib.metadata.packages_distributions():
+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"
@@ -93,6 +95,8 @@ TX_PKT =                        "txPacket"
 TX_MAX_DURATION_MS =            "txMaxDurationMs"
 TX_MAX_RETRIES =                "txMaxRetries"
 TRANPARENT_PKT_LEN =            31 * 2
+ACTION_ADVERTISING =            0
+ACTION_BRG_OTA =                1
 
 # Simulator defines
 GW_SIM_BLE_MAC_ADDRESS =       'GW_SIM_BLE_MAC_ADDRESS'
@@ -103,6 +107,7 @@ DATA_REAL_TAGS =               'tags'
 GEN2 =                         2
 GEN3 =                         3
 GEN3_EXTENDED =                4
+RAW_DATA =                     5
 
 # Configurable brg fields' names by modules
 # common #
@@ -178,6 +183,8 @@ STATUS_CODE =                    "status" # Protobuf
 IMG_DIR_URL =                    "imageDirUrl"
 UPGRADE_BLSD =                   "upgradeBlSd"
 VER_UUID_STR =                   "versionUUID"
+STEP =                           "step"
+PROGRESS =                       "progress"
 VER_MAX_LEN =                    31
 
 # Versions
@@ -226,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
@@ -234,6 +241,7 @@ TEST_FAILED =                                       -1
 TEST_SKIPPED =                                      1
 TEST_INIT =                                         2
 NO_RESPONSE =                                       "NO_RESPONSE"
+NOT_FOUND =                                         "NOT_FOUND"
 DONE =                                              "DONE"
 MGMT_PKT =                                          "mgmt_pkt"
 UNIFIED_PKT =                                       "unified_pkt"
@@ -257,10 +265,16 @@ AWS =                                               "aws"
 TEST =                                              "test"
 MULTI_BRG_TEST =                                    "multiBridgeTest" # used for multi brg tests
 GW_ONLY_TEST =                                      "gwOnlyTest" # used for gw only tests
+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

@@ -93,8 +93,8 @@ def prep_gw(args, mqttc, start_time):
 # UART FUNCTIONS
 ##############################################
 def write_to_ble(ble_serial, txt, print_enable=True, sleep=0):
-    if print_enable:
-        print('\n' + txt)
+    # if print_enable:
+    #     print('\n' + txt)
     ble_serial.write(bytes(txt, encoding='utf-8') + b'\r\n')
     if sleep:
         cert_common.wait_time_n_print(sleep)
@@ -193,8 +193,10 @@ def on_unsubscribe(mqttc, userdata, mid):
 def on_message(client, userdata, message):
     data = json.loads(message.payload.decode("utf-8"))
     print_enable = True if not PIXEL_SIM_INDICATOR in str(message.payload.decode("utf-8")) else False
-    if print_enable:
-        print("##########\n// 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"))))
+    # if print_enable:
+    #     print("##########\n// 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"))))
+    #     #TODO: logging print
+    #     # print("##########\n// 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"))))
     # Send packet to UART
     if TX_PKT in data:
         # Downlink packet
@@ -213,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))