wiliot-certificate 1.3.0a1__py3-none-any.whl → 1.4.0a1__py3-none-any.whl

gw_certificate/common/debug.py

@@ -1,6 +1,5 @@
 import datetime
 import logging
-import os
 import colorama
 import tabulate
 import pprint
@@ -41,23 +40,3 @@ def debug_print(txt, pretty=False, center=False, tab=False, color=None, enable=T
             log.info(txt)
         else:
             print(datetime.datetime.now().strftime("[%d/%m/%Y, %H:%M:%S]: ") + txt)
-
-def is_databricks():
-    """returns if running in databricks"""
-    try:
-        get_ipython().__class__.__name__
-        return True
-    except NameError:
-        return False
-
-
-def is_databricks():
-    try:
-        from IPython import get_ipython
-        if "IPKernelApp" not in get_ipython().config:
-            return False
-        if "VSCODE_PID" in os.environ:
-            return False
-        return True
-    except Exception as e:
-        return False

gw_certificate/common/utils.py

@@ -1,219 +1,8 @@
+
 # External libraries
-import math
-import pandas as pd
-import numpy as np
 import datetime
-from collections import defaultdict
-
-from gw_certificate.common.debug import is_databricks
-
-try:
-    from zoneinfo import ZoneInfo  # will run only in python 3.9+
-except ImportError:
-    from backports.zoneinfo import ZoneInfo  # backport to python < 3.9
-
-# CSV Parsing
-def get_ref_tags(csv_filepath):
-    # TODO - fix to insert header if not given
-    """
-        returns an array of tags externalIds from a csv including one column of all the tags
-        :type csv_filepath: string
-        :param csv_filepath: filepath to csv with one column including all the tags
-        output type: array
-        output param: array of tags externalIds from a csv
-    """
-    tags_list = pd.read_csv(csv_filepath)
-    tags_list = tags_list.to_dict()
-    res = defaultdict(list)
-    for key in tags_list.keys():
-        for idx in tags_list[key]:
-            if type(tags_list[key][idx]) == str and len(tags_list[key][idx]) == 31:
-                res[key].append(tags_list[key][idx])
-    return res
-
-def get_bridges_from_csv(csv_filepath):
-    """
-        :type csv_filepath: string
-        :param csv_filepath: bridges names csv file path
-    """
-    if csv_filepath is None:
-        return None
-    bridges_df = pd.read_csv(csv_filepath)
-    zones_dict = bridges_df.to_dict('list')
-    return zones_dict
 
 # Date & Time Related
-def convert_datetime_to_timestamp(year=2022, month=1, day=1, hour=0, minute=0, seconds=0, micro_secs=0,
-                                hours_from_utc=0):
-    """
-    returns the timestamp of Israeli datetime
-    :type year: int
-    :param year: year of desired datetime
-    :type month: int
-    :param month: month of desired datetime
-    :type day: int
-    :param day: day of desired datetime
-    :type hour: int
-    :param hour: hour of desired datetime
-    :type minute: int
-    :param minute: minute of desired datetime
-    :type seconds: int
-    :param seconds: seconds of desired datetime
-    :type micro_secs: int
-    :param micro_secs: micro seconds of desired datetime
-    :type hours_from_utc: int
-    :param hours_from_utc: hours difference from UTC timezone
-    :returns: timestamp in UTC
-    """
-
-    dt = datetime.datetime(year, month, day, hour, minute, seconds, micro_secs)
-    # getting the timestamp
-    ts = datetime.datetime.timestamp(dt)
-    # if runs in data bricks - subtract hours_from_utc hours to transfer to relevant time zone
-    if is_databricks():
-        ts = ts - 3600 * hours_from_utc
-    # convert to ms
-    ts_in_ms = math.ceil(ts * 1000)
-    return ts_in_ms
-
-def mstimestamp_to_timezone(timestamp, timezone='Israel', milli=True, hour=True, return_datetime=False):
-    """
-    :type timestamp: float / str / int
-    :param timestamp: millisecond timestamp
-    :type timezone: str
-    :param timezone: ZoneInfo Timestamp name, defaults to Israel
-    :type milli: bool
-    :param milli: if false, omits millisecond from result
-    :type return_datetime: bool
-    :param return_datetime: whether to return datetime
-    :rtype: str | datetime
-    :return: String of datetime in timezone | datetime object in timezone
-    """
-    server_timezone = ZoneInfo("Etc/UTC")
-    chosen_timezone = ZoneInfo(timezone)
-    if timestamp == 0 or np.isnan(timestamp):
-        return None
-    try:
-        timestamp = float(timestamp)
-    except ValueError as e:
-        raise ValueError(f'Timestamp {timestamp} could not be converted to float!' + e)
-    dt = datetime.datetime.fromtimestamp(timestamp / 1000)
-    dt.replace(tzinfo=server_timezone)
-    if return_datetime:
-        return dt.astimezone(chosen_timezone)
-    if hour:
-        if milli:
-            dt = dt.astimezone(chosen_timezone).strftime('%Y-%m-%d %H:%M:%S.%f %Z')
-        else:
-            dt = dt.astimezone(chosen_timezone).strftime('%Y-%m-%d %H:%M:%S %Z')
-    else:
-        dt = dt.astimezone(chosen_timezone).strftime('%Y-%m-%d')
-    return dt
-
-def convert_timestamp_to_datetime(timestamp, up_to_sec_res=False):
-    """
-    converts timestamp to datetime
-    :param timestamp: timestamp
-    :type timestamp: str
-    :param up_to_sec_res: if true will return the datetime in a resolution of seconds
-    :type up_to_sec_res: bool
-    """
-    num_digits = len(str(int(float(timestamp))))
-    timestamp = float(timestamp)
-    timestamp = timestamp * math.pow(10, ((num_digits*-1) + 10))
-    dt = datetime.datetime.fromtimestamp(float(timestamp))
-    if up_to_sec_res:
-        dt = dt - datetime.timedelta(microseconds=dt.microsecond)
-    return dt
-
-def datetime_to_timezone(dt, timezone='Israel'):
-    return dt.astimezone(ZoneInfo(timezone))
-
-
 def current_timestamp():
     """returns current timestamp (UTC) in milliseconds"""
     return datetime.datetime.timestamp(datetime.datetime.now()) * 1000
-
-
-def timestamp_timedelta(method=False, **kwargs):
-    now = datetime.datetime.now()
-    if method:
-        calc = now + datetime.timedelta(**kwargs)
-    else:
-        calc = now - datetime.timedelta(**kwargs)
-    return calc.timestamp() * 1000
-
-
-def string_to_bool(string):
-    if string == 'True':
-        return True
-    if string == 'False':
-        return False
-    else:
-        raise ValueError('Value not equal to True or False!')
-
-
-def filter_namedtuple(namedtuple, keys, val_type=int):
-    """
-    gets named tuple (from DataFrame.itertuples) and returns a dictionary of filtered keys from named tuple,
-    filtering out keys which have NaN values
-    :type namedtuple: Named Tuple
-    :param namedtuple: named tuple to filter
-    :type keys: list
-    :param keys: keys to filter from named tuple
-    :rtype: dict
-    :return: dictionary of keys and values filtered from named tuple
-    """
-    d = dict()
-    for k in keys:
-        try:
-            val = getattr(namedtuple, k)
-            if pd.isna(val):
-                continue
-            if str(val).replace('.', '').isnumeric():
-                val = val_type(val)
-            d[k] = val
-        except AttributeError:
-            continue
-    return d
-
-
-def parse_si_packet(df):
-    def from_twos_complement(value):
-        if value>(pow(2,7)):
-            return value-(1<<8)
-        else:
-            return value
-    
-    df['band'] = df.rawPacket.apply(lambda x: x[16:18])=="01"
-    dfn = pd.DataFrame()
-    # add column of output power
-    for band in df['band'].unique():
-        tmp = df[df['band']==band]
-        if band:  # sub1g is 8 bit positive number
-            tmp = tmp.assign(tx_outputpower=tmp.rawPacket.apply(lambda x: int(x[14:16], 16)))
-        else:  # ble is 8 bit negative 2's complement number
-            tmp = tmp.assign(tx_outputpower=tmp.rawPacket.apply(lambda x: from_twos_complement(int(x[14:16], 16))))
-        dfn = pd.concat([dfn, tmp])
-    # add columns of tx and rx antena
-    df['tx_ant'] = df.rawPacket.apply(lambda x: x[18:20])
-    df['rx_ant'] = df.rawPacket.apply(lambda x: x[20:22])
-    df['rssi'] = -df['rssi']
-    return df
-
-
-def match_bridge_ids(bridge_ids, alias_bridge_ids):
-    # Convert hex IDs to integers
-    bridge_ints = {bid: int(bid, 16) for bid in bridge_ids}
-    alias_ints = {abid: int(abid, 16) for abid in alias_bridge_ids}
-    matches = {}
-    for alias, alias_int in alias_ints.items():
-        cnt = 0
-        for bridge, bridge_int in bridge_ints.items():
-            # Check if aliasBridgeId matches bridgeId exactly, or with the first bit modified
-            if (alias_int == bridge_int or  alias_int == (bridge_int | 0xC00000000000)): 
-                cnt = cnt + 1
-                matches[alias] = bridge
-        if alias not in matches:
-            matches[alias] = None
-    return matches

gw_certificate/common/utils_defines.py

@@ -1,102 +1,15 @@
 # Brownout / OTA Defines
 SEP = "#" * 50
-MINUTES_TO_BROWN_OUT = 5
-TABLES_SYNC_MINUTES = 70
-MINUTES_FOR_LC = 2
-LATEST_FW = "1.9.0"
-SINGLE_BAT_BO_DICT = {"2.4GhzOutputPower": 2, 'txPeriodMs': 75, 'rxTxPeriodMs': 255, 'energyPattern': 25}
-DUAL_BAT_BO_DICT = {"2.4GhzOutputPower": 2, 'txPeriodMs': 75, 'rxTxPeriodMs': 255, 'energyPattern': 50}
-LEGACY_BO_DICT = {'energyPattern': 17, 'rxTxPeriodMs': 99}
-# BO_DICT_PREV = {'energyPattern': 36}
 BO_DICT = {
     'datapath': {'config': {'pktFilter': 'Disable forwarding'}},
     'energy2400': {'config': {'energyPattern2400': 'No Energizing'}},
     'energySub1g': {'config': {'sub1gEnergyPattern': 'No Energizing'}},
     'calibration': {'config': {'calibPattern': 'Disable calibration beaconing'}}
 }
-
-
-# Configuration tool / change Brg/Gw Defines
-ATC_GW_CONFIG = {
-    'wifi': {'gwDataSrc': 'Bridges only (ch38)',
-             'pacerInterval': 60,
-             'txPeriodMs': 3,
-             'rxTxPeriodMs': 90,
-             'energizingPattern': 17,
-             "2.4GhzOutputPower": 8},
-    'lte': {},
-    'mobile': {},
-    'unknown': {}}
-ATC_REGION_DICT = {
-    'IL': {
-        'sub1GhzFrequency': 919100,
-        'energyPattern': 50
-    }
-}
-
-energy_patterns = [18, 25, 26]
-energy_patterns_db = {17: 50, 18: 51, 25: 56, 26: 57}
-gw_rx_channel = {17: "Bridges only (ch39)", 18: "Bridges only (ch38)", 24: "Bridges only (ch39)",
-                 25: "Bridges only (ch39)", 26: "Bridges only (ch39)", 51: "Bridges only (ch38)",
-                 55: "Bridges only (ch39)", 56: "Bridges only (ch39)", 57: "Bridges only (ch39)",
-                 50: "Bridges only (ch39)"}
-shifted_brg_energy_patterns = [33, 34, 35, 58, 59, 60]
-shifted_gw_energizing_patterns = [33]
-lc_output_powers = [14, 17, 20, 23, 26, 29, 32]
-fp_duty_cycles = [0.1, 0.15, 0.2, 0.25, 0.3]
-
-# Power Mgmt
-EXIT_POWER_MGMT_GW_DICT = {
-    'gwDataSrc': gw_rx_channel[17],
-    'txPeriodMs': 3,
-    'rxTxPeriodMs': 15,
-    'energizingPattern': 17,
-    'gwMgmtMode': 'active'
-}
-KEEP_ALIVE_PERIOD = 30  # seconds
-KEEP_ALIVE_SCAN_DURATION = 300  # in millisecond
-SEC_TO_SEND = 2
 BROADCAST_DST_MAC = 'FFFFFFFFFFFF'
 
 colors = ['red', 'blue', 'yellow', 'cyan', 'green', 'brown', 'orange', 'pink', 'purple', 'black']
 
 # Test Tool
-WH_OWNER = '832742983939'
-INIT_GW_CONFIG = {
-    'wifi':{'gwDataSrc': gw_rx_channel[18],
-            'gwDataMode': gw_rx_channel[18]},
-    'lte':{},
-    'mobile':{},
-    'unknown':{}}
-INIT_BRG_CONFIG = {
-	'calibration': {'config': {'calibPattern': 'Disable calibration beaconing', 'calibInterval': 10, 'calibOutputPower': 2}},
-    'externalSensor': {'config': {'adType0': 0, 'adType1': 0, 'uuidLsb0': 0, 'uuidLsb1': 0, 'uuidMsb0': 0, 'uuidMsb1': 0, 'sensor0Scramble': 0, 'sensor1Scramble': 0}},
-    'energy2400': {'config': {'dutyCycle': 30, 'outputPower': 2, 'energyPattern2400': 'No Energizing'}},
-    'datapath': {'config': {'pktFilter': 'Disable forwarding', 'txRepetition': 0, 'adaptivePacer': 0, 'pacerInterval': 15, 'unifiedEchoPkt': 0, 'commOutputPower': 2, 'globalPacingGroup': 0}},
-    'powerManagement': {'config': {'staticLedsOn': 1, 'dynamicLedsOn': 1, 'staticOnDuration': 0, 'dynamicOnDuration': 0, 'staticKeepAliveScan': 300, 'staticSleepDuration': 0, 'dynamicKeepAliveScan': 300, 'dynamicSleepDuration': 0, 'staticKeepAlivePeriod': 20, 'dynamicKeepAlivePeriod': 20}},
-    'energySub1g': {'config': {'cycle': 15, 'dutyCycle': 30, 'outputPower': 29, 'sub1gEnergyPattern': 'No Energizing'}},
-    }
-
-# prev init cfg for prev brgs version (lower then version 4.0)
-INIT_BRG_PREV_CONFIG = {
-	'energy2400': {'config': {'txPeriod': 5, 'rxTxPeriod': 15, 'outputPower': 2, 'energyPattern': 36}},
-	'datapath': {'config': {'txRepetition': 0, 'pacerInterval': 15, 'globalPacingGroup': 0}}, 
-	'energySub1g': {'config': {'frequency': 919100, 'outputPower': 32}}
-    }
-
-BRG_KEYS = ['calibPattern','calibInterval','calibOutputPower',
-            'adType0','adType1','uuidLsb0','uuidLsb1','uuidMsb0','uuidMsb1','sensor0Scramble','sensor1Scramble',
-            'txPeriod','rxTxPeriod','2.4GhzOutputPower','energyPattern','sub1GhzFrequency','sub1GhzOutputPower',
-            'dutyCycle','outputPower','energyPattern2400','pktFilter','txRepetition','adaptivePacer','pktTypesMask',
-            'pacerInterval','unifiedEchoPkt','commOutputPower','globalPacingGroup',
-            'staticLedsOn','dynamicLedsOn','staticOnDuration','dynamicOnDuration','staticKeepAliveScan','staticSleepDuration',
-            'dynamicKeepAliveScan','dynamicSleepDuration','staticKeepAlivePeriod','dynamicKeepAlivePeriod',
-            'cycle','dutyCycle','outputPower','sub1gEnergyPattern']
-GW_KEYS = ['gwDataSrc', 'gwDataMode']
 GW_DATA_SRC = 'gwDataSrc'
 GW_DATA_MODE = 'gwDataMode'
-GW_KEYS_THIN = ['dataCoupling', 'useStaticLocation', 'gwMgmtMode']
-GW_SHARED_KEYS = ['gw_2.4GhzOutputPower', 'gw_txPeriodMs', 'gw_pacerInterval', 'gw_energizingPattern',
-                  'gw_rxTxPeriodMs']
-TIME_COLUMNS = ['endTimestamp', 'startTimestamp', 'receivedTestConfigTimestamp']
-TEST_CONFIG_COLUMNS = ['testId', 'testTimeMins', 'gatewaysIncluded', 'bridgesIncluded']

gw_certificate/gw_certificate.py

@@ -41,16 +41,17 @@ class TemplateEngine:
 
 
 class GWCertificate:
-    def __init__(self, gw_id, owner_id, tests:list = TESTS_DEFAULT, topic_suffix='', update_fw=False, stress_pps=None, aggregation_time=0, env='prod'):
+    def __init__(self, gw_id, owner_id, actions:list, tests:list, topic_suffix='', update_fw=False, stress_pps=None,
+                 aggregation_time=0, env='prod'):
         # Runtime
         self.env_dirs = WiliotDir()
         self.current_datetime = datetime.datetime.now().strftime('%Y%m%d_%H%M%S')
         self.certificate_dir = os.path.join(self.env_dirs.get_wiliot_root_app_dir(), 'gw-certificate', self.current_datetime)
         self.env_dirs.create_dir(self.certificate_dir)
-        self.start_timestamp = initialize_logger(self.certificate_dir)
-        self.logger_filepath = os.path.join(self.certificate_dir, f'{self.start_timestamp}.log')
-        self.mqtt_logger_filepath = os.path.join(self.certificate_dir, f'{self.start_timestamp}_mqtt.log')
-        self.sniffer_logger_filepath = os.path.join(self.certificate_dir, f'{self.start_timestamp}_sniffer.log')
+        self.logger_filename = initialize_logger(self.certificate_dir)
+        self.logger_filepath = os.path.join(self.certificate_dir, f'{self.logger_filename}.log')
+        self.mqtt_logger_filepath = os.path.join(self.certificate_dir, f'{self.logger_filename}_mqtt.log')
+        self.sniffer_logger_filepath = os.path.join(self.certificate_dir, f'{self.logger_filename}_sniffer.log')
         self.result_html_path = os.path.join(self.certificate_dir, f'results_{self.current_datetime}.html')
         self.template_engine = TemplateEngine()
         self.env = env
@@ -66,6 +67,7 @@ class GWCertificate:
         self.gw_capabilities = GWCapabilities()
         self.stress_pps = stress_pps
         self.aggregation_time = aggregation_time
+        self.actions = actions
         
         # UART-related. Require only when running tests that need it
         self.use_uart = not all(test in TESTS_NO_UART for test in tests)
@@ -74,11 +76,10 @@ class GWCertificate:
             self.uart_comports = get_uart_ports()
             debug_print(f'UART Ports:{self.uart_comports}')
             if len(self.uart_comports) < 1:
-                raise GWCertificateError('A Wiliot tester board must be connected to USB!')
+                raise GWCertificateError('A Wiliot certification kit must be connected to USB!')
         
             for port in self.uart_comports:
                 try:
-                    # TODO Fix UARTInterface firmware update and then call it with the flag set to True
                     self.uart = UARTInterface(port, update_fw=update_fw)
                     break
                 except UARTError as e:
@@ -102,6 +103,7 @@ class GWCertificate:
             #     if (type(test) == DownlinkTest and self.gw_capabilities.downlinkSupported == False):
             #         debug_print(f'# Skipping {type(test)} since it is not a supported capability. #')
             #         continue
+            test.prepare_test()
             test.run()
             test.end_test()
         

gw_certificate/gw_certificate_cli.py

@@ -2,32 +2,37 @@
 import time
 from argparse import ArgumentParser
 
+from gw_certificate.common.debug import debug_print
 from gw_certificate.gw_certificate import GWCertificate, GW_CERT_VERSION
-from gw_certificate.tests import TESTS, TESTS_DEFAULT
-from gw_certificate.tests.throughput import STRESS_DEFAULT_PPS
+from gw_certificate.tests import TESTS
+from gw_certificate.tests.actions import ACTIONS_STAGES
+from gw_certificate.tests.throughput import STRESS_DEFAULT_PPS, StressTest
 from gw_certificate.tests.registration import REG_CERT_OWNER_ID, RegistrationTest
 from gw_certificate.tests.uplink import UplinkTest
-from gw_certificate.tests.throughput import StressTest
+
+def filter_by_args(args_list, list_to_filter):
+    chosen_list = []
+    for entry in list_to_filter:
+        for arg in args_list:
+            if arg in entry.__name__.lower() and entry not in chosen_list:
+                chosen_list.append(entry)
+    return chosen_list
 
 def filter_tests(tests_names):
-    chosen_tests = []
-    if tests_names == []:
-        return TESTS_DEFAULT
-    for test_class in TESTS:
-        for test_name in tests_names:
-            if test_name in test_class.__name__.lower() and test_class not in chosen_tests:
-                chosen_tests.append(test_class)
-    return chosen_tests
+    return filter_by_args(tests_names, TESTS)
+
+def filter_actions(actions_names):
+    return filter_by_args(actions_names, ACTIONS_STAGES)
 
 def main():
     usage = (
         "usage: wlt-gw-certificate [-h] -owner OWNER -gw GW\n"
         f"                          [-tests {{connection, uplink, downlink, stress}}] [-update] [-pps {STRESS_DEFAULT_PPS}]\n"
-        "                           [-agg AGG] [-env {prod, test, dev}]"
+        "                           [-agg AGG] [-env {prod, test, dev}] [-no-reboot]"
         )
 
     parser = ArgumentParser(prog='wlt-gw-certificate',
-                            description=f'Gateway Certificate {GW_CERT_VERSION} - CLI Tool to test Wiliot GWs', usage=usage)
+                            description=f'Gateway Certificate v{GW_CERT_VERSION} - CLI Tool to test Wiliot GWs', usage=usage)
 
     required = parser.add_argument_group('required arguments')
     required.add_argument('-gw', type=str, help="Gateway ID", required=True)
@@ -35,30 +40,41 @@ def main():
     optional.add_argument('-owner', type=str, help="Owner ID", required=False, default=REG_CERT_OWNER_ID)
     optional.add_argument('-suffix', type=str, help="Topic suffix", default='', required=False)
     optional.add_argument('-tests', type=str, choices=['registration', 'connection', 'uplink', 'downlink', 'actions', 'stress'],
-                          help="Tests to run. Registration omitted by default.", required=False, nargs='+', default=[])
+                          help="Tests to run. Registration omitted by default.", required=False, nargs='+',
+                          default=['connection', 'uplink', 'downlink', 'actions', 'stress'])
+    optional.add_argument('-actions', type=str, choices=['info', 'reboot', 'bridgeota'],
+                          help="Action stages to run under ActionsTest", required=False, nargs='+', default=['info', 'reboot', 'ota'])
     optional.add_argument('-update', action='store_true', help='Update test board firmware', default=False, required=False)
     optional.add_argument('-pps', type=int, help='Single packets-per-second rate to simulate in the stress test',
                           choices=STRESS_DEFAULT_PPS, default=None, required=False)
     optional.add_argument('-agg', type=int, help='Aggregation time [seconds] the Uplink stages wait before processing results',
                           default=0, required=False)
-    optional.add_argument('-env', type=str, help='Environment for the registration test (Internal usage)',
+    optional.add_argument('-env', type=str, help='Environment for the RegistrationTest & BridgeOTAStage',
                           choices=['prod', 'test', 'dev'], default='prod', required=False)
     args = parser.parse_args()
 
-    tests = filter_tests(args.tests)
     topic_suffix = '' if args.suffix == '' else '-'+args.suffix
+    tests = filter_tests(args.tests)
+    actions = filter_actions(args.actions)
 
+    # Validate args combination before running
     if args.pps != None and StressTest not in tests:
         parser.error("Packets per second (-pps) flag can only be used when 'stress' is included in test list (e.g. -tests stress)")
-    if args.agg != 0 and UplinkTest not in tests:
-        parser.error("Aggregation time (-agg) flag can only be used when 'uplink' is included in test list (e.g. -tests uplink)")
-    if args.owner == REG_CERT_OWNER_ID and not all(test == RegistrationTest for test in tests):
-        print(f"Note: using default owner ID (-owner) - {REG_CERT_OWNER_ID}..")
-        time.sleep(2)
-        # parser.error("The -owner flag is required when running any test other than the RegistrationTest.")
+    if args.agg != 0 and not any(t in tests for t in (UplinkTest, StressTest)):
+        parser.error("Aggregation time (-agg) flag can only be used when 'uplink' or 'stress' are included in test list (e.g. -tests uplink)")
+
+    if RegistrationTest in tests:
+        if not all(test == RegistrationTest for test in tests):
+            parser.error("The registration test must be run on it's own, without any others tests.")
+        if args.owner != REG_CERT_OWNER_ID:
+            parser.error(f"The registration test must be run without the -owner flag (defaults to {REG_CERT_OWNER_ID}).")
+    elif args.owner == REG_CERT_OWNER_ID:
+        parser.error("When running any test other than registration, the gateway must be registered to an owner which should be provided using the '-owner' flag.")
+
 
     gwc = GWCertificate(gw_id=args.gw, owner_id=args.owner, topic_suffix=topic_suffix, tests=tests, update_fw=args.update,
-                        stress_pps=args.pps, aggregation_time=args.agg, env=args.env)
+                        stress_pps=args.pps, aggregation_time=args.agg, env=args.env, actions=actions)
+    debug_print(f"All arguments: {vars(args)}")
     gwc.run_tests()
     gwc.create_results_html()
 

gw_certificate/interface/ble_simulator.py

@@ -57,35 +57,3 @@ class BLESimulator():
             diff = time.perf_counter() - diff
             debug_print(f'Desired Delay: {delay/1000} Actual Delay {diff}')
             packet_to_send = switch_packet(packet_to_send)
-    
-    def trigger_by_time_stamp(self, ts):
-        if ts == None:
-            return
-        current_time = datetime.datetime.timestamp(datetime.datetime.now()) * 1000
-        time_difference = ts-current_time
-        print(f"The test will start in: {time_difference/1000} secondes")
-        time.sleep(time_difference/1000)
-
-    def send_brg_network_pkts(self, pkts, duplicates, output_power=DEFAULT_OUTPUT_POWER):
-        num_brgs = len(pkts)
-        total_pkts_to_send = num_brgs * 2 * duplicates
-        for pkt_idx in range(total_pkts_to_send):
-            brg_idx = pkt_idx % 3
-            pkt = pkts[brg_idx]
-            pkt_idx_per_brg = pkt_idx // num_brgs
-            if not bool(pkt_idx % 2):
-                packet_to_send = pkt['data_packet']
-            else:
-                packet_to_send = pkt['si_packet']
-            packet_error = pkt['packet_error']
-            if packet_error[pkt_idx_per_brg]:
-                debug_print(f'BRG {pkt["bridge_id"]}: Sending Packet {pkt_idx_per_brg}')
-                self.send_packet(packet_to_send, duplicates=1, output_power=output_power,
-                                 channel=SEND_ALL_ADV_CHANNELS, delay=0)
-            else:
-                debug_print(f'BRG {pkt["bridge_id"]}: Dropping Packet {pkt_idx_per_brg}')
-            diff = time.perf_counter()
-            delay = pkt['time_delay']
-            time.sleep(delay/1000)
-            diff = time.perf_counter() - diff
-            debug_print(f'Desired Delay: {delay/1000} Actual Delay {diff}')

gw_certificate/interface/if_defines.py

@@ -16,6 +16,7 @@ GAP_TYPE = '16'
 DEFAULT_ADVA = 'FFFFFFFFFFFF'
 DEFAULT_DUPLICATES = 3
 GW_APP_VERSION_HEADER = 'WILIOT_GW_BLE_CHIP_SW_VER'
+GW_MAC_ADDRESS_HEADER = 'WILIOT_GW_BLE_CHIP_MAC_ADDRESS'
 LOCATION = 'location'
 DEFAULT_OUTPUT_POWER = 8
 DEFAULT_DELAY = 20