wiliot-certificate 1.3.0a1__py3-none-any.whl

gw_certificate/common/wltPb_pb2.pyi

@@ -0,0 +1,227 @@
+from google.protobuf.internal import containers as _containers
+from google.protobuf import descriptor as _descriptor
+from google.protobuf import message as _message
+from typing import ClassVar as _ClassVar, Iterable as _Iterable, Mapping as _Mapping, Optional as _Optional, Union as _Union
+
+DESCRIPTOR: _descriptor.FileDescriptor
+
+class Location(_message.Message):
+    __slots__ = ("lat", "lng")
+    LAT_FIELD_NUMBER: _ClassVar[int]
+    LNG_FIELD_NUMBER: _ClassVar[int]
+    lat: float
+    lng: float
+    def __init__(self, lat: _Optional[float] = ..., lng: _Optional[float] = ...) -> None: ...
+
+class Value(_message.Message):
+    __slots__ = ("integerValue", "numberValue", "stringValue", "boolValue")
+    INTEGERVALUE_FIELD_NUMBER: _ClassVar[int]
+    NUMBERVALUE_FIELD_NUMBER: _ClassVar[int]
+    STRINGVALUE_FIELD_NUMBER: _ClassVar[int]
+    BOOLVALUE_FIELD_NUMBER: _ClassVar[int]
+    integerValue: int
+    numberValue: float
+    stringValue: str
+    boolValue: bool
+    def __init__(self, integerValue: _Optional[int] = ..., numberValue: _Optional[float] = ..., stringValue: _Optional[str] = ..., boolValue: bool = ...) -> None: ...
+
+class GatewayData(_message.Message):
+    __slots__ = ("gatewayId", "timestamp", "packets", "location")
+    class Packet(_message.Message):
+        __slots__ = ("payload", "timestamp", "sequenceId", "rssi", "aliasBridgeId")
+        PAYLOAD_FIELD_NUMBER: _ClassVar[int]
+        TIMESTAMP_FIELD_NUMBER: _ClassVar[int]
+        SEQUENCEID_FIELD_NUMBER: _ClassVar[int]
+        RSSI_FIELD_NUMBER: _ClassVar[int]
+        ALIASBRIDGEID_FIELD_NUMBER: _ClassVar[int]
+        payload: bytes
+        timestamp: int
+        sequenceId: int
+        rssi: int
+        aliasBridgeId: str
+        def __init__(self, payload: _Optional[bytes] = ..., timestamp: _Optional[int] = ..., sequenceId: _Optional[int] = ..., rssi: _Optional[int] = ..., aliasBridgeId: _Optional[str] = ...) -> None: ...
+    GATEWAYID_FIELD_NUMBER: _ClassVar[int]
+    TIMESTAMP_FIELD_NUMBER: _ClassVar[int]
+    PACKETS_FIELD_NUMBER: _ClassVar[int]
+    LOCATION_FIELD_NUMBER: _ClassVar[int]
+    gatewayId: str
+    timestamp: int
+    packets: _containers.RepeatedCompositeFieldContainer[GatewayData.Packet]
+    location: Location
+    def __init__(self, gatewayId: _Optional[str] = ..., timestamp: _Optional[int] = ..., packets: _Optional[_Iterable[_Union[GatewayData.Packet, _Mapping]]] = ..., location: _Optional[_Union[Location, _Mapping]] = ...) -> None: ...
+
+class UplinkMessage(_message.Message):
+    __slots__ = ("gatewayStatus", "gatewayInfo", "gatewayLogs", "actionStatus")
+    GATEWAYSTATUS_FIELD_NUMBER: _ClassVar[int]
+    GATEWAYINFO_FIELD_NUMBER: _ClassVar[int]
+    GATEWAYLOGS_FIELD_NUMBER: _ClassVar[int]
+    ACTIONSTATUS_FIELD_NUMBER: _ClassVar[int]
+    gatewayStatus: GatewayStatus
+    gatewayInfo: GatewayInfo
+    gatewayLogs: GatewayLogs
+    actionStatus: ActionStatus
+    def __init__(self, gatewayStatus: _Optional[_Union[GatewayStatus, _Mapping]] = ..., gatewayInfo: _Optional[_Union[GatewayInfo, _Mapping]] = ..., gatewayLogs: _Optional[_Union[GatewayLogs, _Mapping]] = ..., actionStatus: _Optional[_Union[ActionStatus, _Mapping]] = ...) -> None: ...
+
+class GatewayStatus(_message.Message):
+    __slots__ = ("gatewayId", "gatewayType", "downlinkSupported", "bridgeOtaUpgradeSupported", "apiVersion", "version", "bleSwVersion", "interfaceSwVersion", "location", "config", "bleAddress")
+    class ConfigEntry(_message.Message):
+        __slots__ = ("key", "value")
+        KEY_FIELD_NUMBER: _ClassVar[int]
+        VALUE_FIELD_NUMBER: _ClassVar[int]
+        key: str
+        value: Value
+        def __init__(self, key: _Optional[str] = ..., value: _Optional[_Union[Value, _Mapping]] = ...) -> None: ...
+    GATEWAYID_FIELD_NUMBER: _ClassVar[int]
+    GATEWAYTYPE_FIELD_NUMBER: _ClassVar[int]
+    DOWNLINKSUPPORTED_FIELD_NUMBER: _ClassVar[int]
+    BRIDGEOTAUPGRADESUPPORTED_FIELD_NUMBER: _ClassVar[int]
+    APIVERSION_FIELD_NUMBER: _ClassVar[int]
+    VERSION_FIELD_NUMBER: _ClassVar[int]
+    BLESWVERSION_FIELD_NUMBER: _ClassVar[int]
+    INTERFACESWVERSION_FIELD_NUMBER: _ClassVar[int]
+    LOCATION_FIELD_NUMBER: _ClassVar[int]
+    CONFIG_FIELD_NUMBER: _ClassVar[int]
+    BLEADDRESS_FIELD_NUMBER: _ClassVar[int]
+    gatewayId: str
+    gatewayType: str
+    downlinkSupported: bool
+    bridgeOtaUpgradeSupported: bool
+    apiVersion: int
+    version: str
+    bleSwVersion: str
+    interfaceSwVersion: str
+    location: Location
+    config: _containers.MessageMap[str, Value]
+    bleAddress: str
+    def __init__(self, gatewayId: _Optional[str] = ..., gatewayType: _Optional[str] = ..., downlinkSupported: bool = ..., bridgeOtaUpgradeSupported: bool = ..., apiVersion: _Optional[int] = ..., version: _Optional[str] = ..., bleSwVersion: _Optional[str] = ..., interfaceSwVersion: _Optional[str] = ..., location: _Optional[_Union[Location, _Mapping]] = ..., config: _Optional[_Mapping[str, Value]] = ..., bleAddress: _Optional[str] = ...) -> None: ...
+
+class GatewayInfo(_message.Message):
+    __slots__ = ("entries",)
+    class EntriesEntry(_message.Message):
+        __slots__ = ("key", "value")
+        KEY_FIELD_NUMBER: _ClassVar[int]
+        VALUE_FIELD_NUMBER: _ClassVar[int]
+        key: str
+        value: Value
+        def __init__(self, key: _Optional[str] = ..., value: _Optional[_Union[Value, _Mapping]] = ...) -> None: ...
+    ENTRIES_FIELD_NUMBER: _ClassVar[int]
+    entries: _containers.MessageMap[str, Value]
+    def __init__(self, entries: _Optional[_Mapping[str, Value]] = ...) -> None: ...
+
+class GatewayLogs(_message.Message):
+    __slots__ = ("logs",)
+    LOGS_FIELD_NUMBER: _ClassVar[int]
+    logs: _containers.RepeatedScalarFieldContainer[str]
+    def __init__(self, logs: _Optional[_Iterable[str]] = ...) -> None: ...
+
+class ActionStatus(_message.Message):
+    __slots__ = ("action", "status")
+    ACTION_FIELD_NUMBER: _ClassVar[int]
+    STATUS_FIELD_NUMBER: _ClassVar[int]
+    action: int
+    status: int
+    def __init__(self, action: _Optional[int] = ..., status: _Optional[int] = ...) -> None: ...
+
+class DownlinkMessage(_message.Message):
+    __slots__ = ("txPacket", "gatewayAction", "bridgeUpgrade", "gatewayConfig", "customBroker", "customMessage")
+    TXPACKET_FIELD_NUMBER: _ClassVar[int]
+    GATEWAYACTION_FIELD_NUMBER: _ClassVar[int]
+    BRIDGEUPGRADE_FIELD_NUMBER: _ClassVar[int]
+    GATEWAYCONFIG_FIELD_NUMBER: _ClassVar[int]
+    CUSTOMBROKER_FIELD_NUMBER: _ClassVar[int]
+    CUSTOMMESSAGE_FIELD_NUMBER: _ClassVar[int]
+    txPacket: TxPacket
+    gatewayAction: GatewayAction
+    bridgeUpgrade: BridgeUpgrade
+    gatewayConfig: GatewayConfig
+    customBroker: CustomBroker
+    customMessage: CustomMessage
+    def __init__(self, txPacket: _Optional[_Union[TxPacket, _Mapping]] = ..., gatewayAction: _Optional[_Union[GatewayAction, _Mapping]] = ..., bridgeUpgrade: _Optional[_Union[BridgeUpgrade, _Mapping]] = ..., gatewayConfig: _Optional[_Union[GatewayConfig, _Mapping]] = ..., customBroker: _Optional[_Union[CustomBroker, _Mapping]] = ..., customMessage: _Optional[_Union[CustomMessage, _Mapping]] = ...) -> None: ...
+
+class TxPacket(_message.Message):
+    __slots__ = ("payload", "maxRetries", "maxDurationMs")
+    PAYLOAD_FIELD_NUMBER: _ClassVar[int]
+    MAXRETRIES_FIELD_NUMBER: _ClassVar[int]
+    MAXDURATIONMS_FIELD_NUMBER: _ClassVar[int]
+    payload: bytes
+    maxRetries: int
+    maxDurationMs: int
+    def __init__(self, payload: _Optional[bytes] = ..., maxRetries: _Optional[int] = ..., maxDurationMs: _Optional[int] = ...) -> None: ...
+
+class GatewayAction(_message.Message):
+    __slots__ = ("action",)
+    ACTION_FIELD_NUMBER: _ClassVar[int]
+    action: str
+    def __init__(self, action: _Optional[str] = ...) -> None: ...
+
+class BridgeUpgrade(_message.Message):
+    __slots__ = ("rebootPacket", "txMaxDurationMs", "txMaxRetries", "bridgeId", "versionUuid", "upgradeBlSd", "imageDirUrl")
+    REBOOTPACKET_FIELD_NUMBER: _ClassVar[int]
+    TXMAXDURATIONMS_FIELD_NUMBER: _ClassVar[int]
+    TXMAXRETRIES_FIELD_NUMBER: _ClassVar[int]
+    BRIDGEID_FIELD_NUMBER: _ClassVar[int]
+    VERSIONUUID_FIELD_NUMBER: _ClassVar[int]
+    UPGRADEBLSD_FIELD_NUMBER: _ClassVar[int]
+    IMAGEDIRURL_FIELD_NUMBER: _ClassVar[int]
+    rebootPacket: bytes
+    txMaxDurationMs: int
+    txMaxRetries: int
+    bridgeId: str
+    versionUuid: str
+    upgradeBlSd: bool
+    imageDirUrl: str
+    def __init__(self, rebootPacket: _Optional[bytes] = ..., txMaxDurationMs: _Optional[int] = ..., txMaxRetries: _Optional[int] = ..., bridgeId: _Optional[str] = ..., versionUuid: _Optional[str] = ..., upgradeBlSd: bool = ..., imageDirUrl: _Optional[str] = ...) -> None: ...
+
+class GatewayConfig(_message.Message):
+    __slots__ = ("version", "bleSwVersion", "interfaceSwVersion", "location", "config")
+    class ConfigEntry(_message.Message):
+        __slots__ = ("key", "value")
+        KEY_FIELD_NUMBER: _ClassVar[int]
+        VALUE_FIELD_NUMBER: _ClassVar[int]
+        key: str
+        value: Value
+        def __init__(self, key: _Optional[str] = ..., value: _Optional[_Union[Value, _Mapping]] = ...) -> None: ...
+    VERSION_FIELD_NUMBER: _ClassVar[int]
+    BLESWVERSION_FIELD_NUMBER: _ClassVar[int]
+    INTERFACESWVERSION_FIELD_NUMBER: _ClassVar[int]
+    LOCATION_FIELD_NUMBER: _ClassVar[int]
+    CONFIG_FIELD_NUMBER: _ClassVar[int]
+    version: str
+    bleSwVersion: str
+    interfaceSwVersion: str
+    location: Location
+    config: _containers.MessageMap[str, Value]
+    def __init__(self, version: _Optional[str] = ..., bleSwVersion: _Optional[str] = ..., interfaceSwVersion: _Optional[str] = ..., location: _Optional[_Union[Location, _Mapping]] = ..., config: _Optional[_Mapping[str, Value]] = ...) -> None: ...
+
+class CustomBroker(_message.Message):
+    __slots__ = ("customBroker", "port", "brokerUrl", "username", "password", "updateTopic", "statusTopic", "dataTopic")
+    CUSTOMBROKER_FIELD_NUMBER: _ClassVar[int]
+    PORT_FIELD_NUMBER: _ClassVar[int]
+    BROKERURL_FIELD_NUMBER: _ClassVar[int]
+    USERNAME_FIELD_NUMBER: _ClassVar[int]
+    PASSWORD_FIELD_NUMBER: _ClassVar[int]
+    UPDATETOPIC_FIELD_NUMBER: _ClassVar[int]
+    STATUSTOPIC_FIELD_NUMBER: _ClassVar[int]
+    DATATOPIC_FIELD_NUMBER: _ClassVar[int]
+    customBroker: bool
+    port: int
+    brokerUrl: str
+    username: str
+    password: str
+    updateTopic: str
+    statusTopic: str
+    dataTopic: str
+    def __init__(self, customBroker: bool = ..., port: _Optional[int] = ..., brokerUrl: _Optional[str] = ..., username: _Optional[str] = ..., password: _Optional[str] = ..., updateTopic: _Optional[str] = ..., statusTopic: _Optional[str] = ..., dataTopic: _Optional[str] = ...) -> None: ...
+
+class CustomMessage(_message.Message):
+    __slots__ = ("entries",)
+    class EntriesEntry(_message.Message):
+        __slots__ = ("key", "value")
+        KEY_FIELD_NUMBER: _ClassVar[int]
+        VALUE_FIELD_NUMBER: _ClassVar[int]
+        key: str
+        value: Value
+        def __init__(self, key: _Optional[str] = ..., value: _Optional[_Union[Value, _Mapping]] = ...) -> None: ...
+    ENTRIES_FIELD_NUMBER: _ClassVar[int]
+    entries: _containers.MessageMap[str, Value]
+    def __init__(self, entries: _Optional[_Mapping[str, Value]] = ...) -> None: ...

gw_certificate/gw_certificate.py

@@ -0,0 +1,138 @@
+# External Imports
+import time
+import datetime
+import os
+import webbrowser
+from jinja2 import Environment, FileSystemLoader
+import pkg_resources
+import time
+import importlib.metadata
+from wiliot_core.utils.utils import WiliotDir
+
+# Internal Imports
+from gw_certificate.common.analysis_data_bricks import initialize_logger
+from gw_certificate.common.debug import debug_print
+from gw_certificate.interface.ble_sniffer import BLESniffer
+from gw_certificate.interface.uart_if import UARTError, UARTInterface
+from gw_certificate.interface.ble_simulator import BLESimulator
+from gw_certificate.interface.mqtt import MqttClient
+from gw_certificate.tests import *
+from gw_certificate.interface.uart_ports import get_uart_ports
+from gw_certificate.api_if.gw_capabilities import GWCapabilities
+from gw_certificate.tests import TESTS_NO_UART
+
+GW_CERT_VERSION = importlib.metadata.version("wiliot-certificate")
+
+class GWCertificateError(Exception):
+    pass
+
+
+class TemplateEngine:
+    def __init__(self):
+        self.template_dir = pkg_resources.resource_filename(__name__, 'templates')
+        self.env = Environment(loader=FileSystemLoader(self.template_dir))
+
+    def get_template(self, template_name):
+        return self.env.get_template(template_name)
+
+    def render_template(self, template_name, **kwargs):
+        template = self.get_template(template_name)
+        return template.render(**kwargs)
+
+
+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'):
+        # 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.result_html_path = os.path.join(self.certificate_dir, f'results_{self.current_datetime}.html')
+        self.template_engine = TemplateEngine()
+        self.env = env
+
+        # Version 
+        self.gw_cert_version = GW_CERT_VERSION
+        
+        # GW & specific tests related
+        self.gw_id = gw_id
+        self.owner_id = owner_id
+        self.topic_suffix = topic_suffix
+        self.mqttc = MqttClient(gw_id, owner_id, self.mqtt_logger_filepath, topic_suffix=topic_suffix, broker='eclipse')
+        self.gw_capabilities = GWCapabilities()
+        self.stress_pps = stress_pps
+        self.aggregation_time = aggregation_time
+        
+        # UART-related. Require only when running tests that need it
+        self.use_uart = not all(test in TESTS_NO_UART for test in tests)
+        if self.use_uart:
+            self.uart = None
+            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!')
+        
+            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:
+                    debug_print(f'Port: {port} - {e}')
+            if type(self.uart) is not UARTInterface:
+                raise GWCertificateError("Cannot initialize any port!")
+            self.ble_sim = BLESimulator(self.uart)
+            self.sniffer = BLESniffer(self.uart, logger_filepath=self.sniffer_logger_filepath)
+        
+        # Tests
+        self.tests = [t(**self.__dict__) for t in tests]
+        debug_print(f'Running Tests: {self.tests}')
+    
+    def run_tests(self):
+        debug_print("Sleeping 20 seconds after mqtt connect")
+        time.sleep(20)
+
+        # capabilities_received = ConnectionTest in self.tests
+        for test in self.tests:
+            # if capabilities_received:
+            #     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.run()
+            test.end_test()
+        
+    def create_results_html(self):
+        with open(self.logger_filepath, 'r') as f:
+            log = f.read().split('\n')
+        with open(self.mqtt_logger_filepath, 'r') as f:
+            mqtt_log = f.read().split('\n')
+        if self.use_uart:
+            with open(self.sniffer_logger_filepath, 'r') as f:
+                sniffer_log = f.read().split('\n')
+        else:
+            sniffer_log = []
+
+        
+        html = self.template_engine.render_template('results.html', tests=self.tests,
+                                                    log = log,
+                                                    mqtt_log = mqtt_log,
+                                                    sniffer_log = sniffer_log,
+                                                    gw_id = self.gw_id,
+                                                    version = self.gw_cert_version,
+                                                    datetime = self.current_datetime)
+        with open(self.result_html_path, 'w', encoding="utf-8") as f:
+            f.write(html)
+        debug_print("Test Finished. Results HTML Saved: " + self.result_html_path)
+        webbrowser.open('file://' + os.path.realpath(self.result_html_path))
+
+if __name__ == "__main__":
+    from api_secrets import *
+    gw_id = 'gw_id'
+    owner_id = 'owner_id'
+    gwc = GWCertificate(gw_id=gw_id,owner_id=owner_id, tests=[ConnectionTest, DownlinkTest, UplinkTest, StressTest])
+    gwc.run_tests()
+    gwc.create_results_html()

gw_certificate/gw_certificate_cli.py

@@ -0,0 +1,70 @@
+
+import time
+from argparse import ArgumentParser
+
+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.registration import REG_CERT_OWNER_ID, RegistrationTest
+from gw_certificate.tests.uplink import UplinkTest
+from gw_certificate.tests.throughput import StressTest
+
+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
+
+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}]"
+        )
+
+    parser = ArgumentParser(prog='wlt-gw-certificate',
+                            description=f'Gateway Certificate {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)
+    optional = parser.add_argument_group('optional arguments')
+    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=[])
+    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)',
+                          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
+
+    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.")
+
+    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)
+    gwc.run_tests()
+    gwc.create_results_html()
+
+def main_cli():
+    main()
+
+if __name__ == '__main__':
+    main()
+    

gw_certificate/interface/ble_simulator.py

@@ -0,0 +1,91 @@
+import datetime
+import time
+
+from gw_certificate.interface.uart_if import UARTInterface
+from gw_certificate.common.debug import debug_print
+from gw_certificate.interface.if_defines import *
+
+class BLESimulator():
+    def __init__(self, uart:UARTInterface):
+        self.uart = uart
+        self.sim_mode = False
+
+    def set_sim_mode(self, sim_mode):
+        self.uart.flush()
+        mode_dict = {True: 1, False: 0}
+        self.sim_mode = sim_mode
+        self.uart.reset_gw()
+        self.uart.write_ble_command(f"!ble_sim_init {mode_dict[sim_mode]}")
+        if not sim_mode:
+            self.uart.reset_gw()
+        time.sleep(3)
+
+    def send_packet(self, raw_packet, duplicates=DEFAULT_DUPLICATES, output_power=DEFAULT_OUTPUT_POWER, channel=SEND_ALL_ADV_CHANNELS, delay=DEFAULT_DELAY):
+        assert self.sim_mode is True, 'BLE Sim not initialized!'
+        if len(raw_packet) == 62:
+            # Add ADVA
+            raw_packet = DEFAULT_ADVA + raw_packet
+        if len(raw_packet) != 74:
+            raise ValueError('Raw Packet must be 62/74 chars long!')
+        self.uart.write_ble_command(f"!ble_sim {str(raw_packet)} {str(duplicates)} {str(output_power)} {str(channel)} {str(delay)}")
+        if delay > 0:
+            diff = time.perf_counter()
+            time.sleep((delay/1000) * duplicates)
+            diff = time.perf_counter() - diff
+            debug_print(f'Desired Delay: {(delay/1000) * duplicates} Actual Delay {diff}')
+
+    
+    def send_data_si_pair(self, data_packet, si_packet, duplicates, output_power=DEFAULT_OUTPUT_POWER, delay=DEFAULT_DELAY, packet_error=None):
+        if packet_error is None:
+            packet_error = [True for i in range (duplicates * 2)]
+        # debug_print(packet_error)
+        # print(f'delay {delay}')
+        packet_to_send = data_packet
+        def switch_packet(packet_to_send):
+            if packet_to_send == data_packet:
+                return si_packet
+            else:
+                return data_packet
+        for dup in range(duplicates * 2):
+            diff = time.perf_counter()
+            if packet_error[dup]:
+                debug_print(f'Sending Packet {dup}')
+                self.send_packet(packet_to_send, duplicates=1, output_power=output_power, channel=SEND_ALL_ADV_CHANNELS, delay=0)
+            else:
+                debug_print(f'Dropping Packet {dup}')
+            time.sleep(delay/1000)
+            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}')