wiliot-certificate 1.5.2a1__py3-none-any.whl → 4.4.0__py3-none-any.whl

gw_certificate/tests/static/uplink_defines.py

@@ -2,12 +2,13 @@ from gw_certificate.interface.if_defines import *
 from gw_certificate.ag.ut_defines import *
 
 RECEIVED = 'received'
+SHOULD_RECEIVE = 'shouldReceive'
 SHARED_COLUMNS = [PAYLOAD]
 INT64_COLUMNS = [RSSI]
 OBJECT_COLUMNS = [PAYLOAD]
 REPORT_COLUMNS = ['pkt_id', 'duplication', 'time_delay']
 
 ADV_TIMESTAMP = 'adv_timestamp'
-TS_DEVIATION = 1500
+TS_DEVIATION = 4500
 TS_TOLERANCE = 2500
 REC_TIMESTAMP = 'rec_timestamp'

gw_certificate/tests/throughput.py

@@ -134,6 +134,7 @@ class StressTestStage(GenericStressStage):
         run_data = self.run_stress_data.data
         end_time = datetime.datetime.now() + datetime.timedelta(seconds=TIME_PER_DELAY_FIRST if delay == STRESS_DEFAULT_DELAYS[0] else TIME_PER_DELAY)
         last_sent_time = time.perf_counter_ns()
+        debug_print('Advertising packets...')
         for index, row in run_data.iterrows():
             if datetime.datetime.now() > end_time:
                 debug_print(f"Timeout for PPS rate {int(ONE_SECOND_MS / delay)} reached")
@@ -142,7 +143,7 @@ class StressTestStage(GenericStressStage):
             self.local_pkts.append(row[PAYLOAD])
             while True:
                 if time.perf_counter_ns() - last_sent_time >= delay * 10**6:
-                    self.ble_sim.send_packet(data, duplicates=self.duplicates, delay=0)
+                    self.ble_sim.send_packet(data, duplicates=self.duplicates, delay=0, print_for_debug=False)
                     last_sent_time = time.perf_counter_ns()
                     break
             self.ts_records_arr[delay_idx].set_adv_timestamp_current(data)
@@ -199,7 +200,7 @@ class StressTestStage(GenericStressStage):
             for idx, delay in enumerate(self.delays):
                 if self.ts_records_arr[idx].is_ts_error():
                     self.add_to_stage_report(f"Timestamps errors during PPS {self.report_data[str(delay)]['pkts_per_sec_desired']}:")
-                    self.ts_records_arr[idx].add_ts_errs_to_report(self)
+                    self.ts_records_arr[idx].add_ts_errs_to_report(self, newline=False)
                     self.add_report_line_separator()
             self.add_to_stage_report(f'Stage data saved - {self.csv_path}')
 

gw_certificate/tests/uplink.py

@@ -14,16 +14,18 @@ from gw_certificate.interface.if_defines import DEFAULT_DELAY, LOCATION
 from gw_certificate.tests.static.uplink_defines import *
 from gw_certificate.interface.mqtt import MqttClient, Serialization
 from gw_certificate.interface.pkt_generator import BrgPktGenerator, apply_adva_bitmask
-from gw_certificate.tests.static.generated_packet_table import UnifiedRunData, SensorRunData, MgmtRunData, PacketTableHelper
-from gw_certificate.tests.generic import PassCriteria, PERFECT_SCORE, MINIMUM_SCORE, GenericTest, GenericStage, ERR_SUMMARY_DEFAULT
+from gw_certificate.tests.static.generated_packet_table import UnifiedRunData, SensorRunData, MgmtRunData, PacketTableHelper, ACLRunData
+from gw_certificate.tests.generic import PassCriteria, PERFECT_SCORE, MINIMUM_SCORE, GenericTest, GenericStage, ERR_SUMMARY_DEFAULT, INFORMATIVE
 from gw_certificate.api_if.api_validation import MESSAGE_TYPES, validate_message
 from gw_certificate.tests.static.generated_packet_table import CSV_NAME
+from gw_certificate.common.serialization_formatter import ACL_MODE, ACL_BRIDGE_IDS, SerializationFormatter, Configurable, ACL_ALLOW, ACL_DENY
 
 
 # HELPER DEFINES
 TABLE_SUFFIX = "Table"
 ERR_SUM_MISSING_PKTS = "Insufficient amount of packets were scanned & uploaded by the gateway. "
 ERR_SUM_ONLY_1E = "Packets with length != '1E' were not uploaded. "
+ACL_MODE_COUNT = 2
 
 # HELPER FUNCTIONS
 def process_payload(packet:dict):
@@ -106,21 +108,24 @@ class TimestampsHelper(PacketTableHelper):
 
         packets_sent_df[REC_TIMESTAMP] = packets_sent_df.apply(validate_row, axis=1)
 
-        # Validate no 2 packets hold the same timestamp
-        if REC_TIMESTAMP in packets_sent_df.columns:
-            duplicates = packets_sent_df[REC_TIMESTAMP].value_counts()
-            duplicated_ts = duplicates[duplicates > 1].index
+        # # Validate no 2 packets hold the same timestamp - disabled, not a requirement for certification
+        # if REC_TIMESTAMP in packets_sent_df.columns:
+        #     duplicates = packets_sent_df[REC_TIMESTAMP].value_counts()
+        #     duplicated_ts = duplicates[duplicates > 1].index
 
-            for ts in duplicated_ts:
-                self.ts_errors.append(f"Multiple packets were uploaded with identical timestamp (ts = {int(ts)})")
-                self.has_identical_ts = True
+        #     for ts in duplicated_ts:
+        #         self.ts_errors.append(f"Multiple packets were uploaded with identical timestamp (ts = {int(ts)})")
+        #         self.has_identical_ts = True
+
+    def add_ts_errs_to_report(self, stage:GenericStage, newline=True):
 
-    def add_ts_errs_to_report(self, stage:GenericStage):
         for idx, ts_err in enumerate(self.ts_errors):
             stage.add_to_stage_report(ts_err)
             if idx == 1 and (len(self.ts_errors) - 1) > idx:
                 stage.add_to_stage_report(f'Additional errors ({len(self.ts_errors) - 1 - idx}) are suppressed to avoid clutter')
                 break
+        if len(self.ts_errors) > 0 and newline:
+            stage.add_to_stage_report('')
     
     def is_ts_error(self) -> bool:
         return len(self.ts_errors) > 0
@@ -203,6 +208,7 @@ class GenericUplinkStage(GenericStage):
         if len(not_received) > 0:
             self.add_to_stage_report('Packets not received:')
             self.add_to_stage_report(tabulate.tabulate(not_received, headers='keys', showindex=False))
+            self.add_to_stage_report('')
 
         self.ts_records.add_ts_errs_to_report(self)
 
@@ -221,6 +227,9 @@ class GenericUplinkStage(GenericStage):
         
         return self.report
 
+    def swap_endianness(self, hex_str: str) -> str:
+        return ''.join(format(b, '02X') for b in bytes.fromhex(hex_str)[::-1])
+
 
 class ManagementPacketStage(GenericUplinkStage):  
     def __init__(self, **kwargs):
@@ -372,6 +381,7 @@ class SensorPacketStage(GenericUplinkStage):
         if len(not_received) > 0:
             self.add_to_stage_report('Packets not received:')
             self.add_to_stage_report(tabulate.tabulate(not_received_rep_cols, headers='keys', showindex=False))
+            self.add_to_stage_report('')
 
             def all_varying_len_sensors_missed(not_received_df):
                 not_uploaded_count = 0
@@ -548,22 +558,8 @@ class AliasBridgeIDStage(GenericUplinkStage):
         all_payloads = uplink_tests_df[PAYLOAD]
         self.all_test_payloads = all_payloads.tolist()
 
-        def _parser(row, desired:Literal['adva', 'without_adva']):
-            if desired == 'adva':
-                output_string = row.at[ADVA_PAYLOAD][:12]
-            elif desired == 'without_adva':
-                output_string = row.at[ADVA_PAYLOAD][12:]
-            else:
-                raise ValueError
-            return output_string
-
         # Create data set for alias bridge verification
-        alias_bridge_id_df = uplink_tests_df.copy()
-        # Take the adva from the payload
-        alias_bridge_id_df['alias_bridge_id'] = alias_bridge_id_df['adva']
-        # Convert bridge_id to little endian
-        alias_bridge_id_df['alias_bridge_id'] = alias_bridge_id_df['alias_bridge_id'].apply(lambda x: ''.join(format(byte, '02X') for byte in bytes.fromhex(x)[::-1]))
-        self.alias_bridge_id_df = alias_bridge_id_df
+        self.alias_bridge_id_df = uplink_tests_df.copy()
    
     def generate_stage_report(self, **kwargs):
         report = []
@@ -580,7 +576,7 @@ class AliasBridgeIDStage(GenericUplinkStage):
                 if any(payload in test_payload for test_payload in self.all_test_payloads):
                     filtered_pkts.append(pkt)
             message['packets'] = filtered_pkts
-                    
+
         def is_alias_bridge_id_valid(message): 
             nonlocal aliasBridgeId_valid
             packets = message['packets']
@@ -593,9 +589,10 @@ class AliasBridgeIDStage(GenericUplinkStage):
                     if len(validation_data) != 1:
                         debug_print(f"validation_data unexpected len:{len(validation_data)}, for payload:{pkt_payload}")
                         return
-                    required_bridge_id = validation_data.iloc[0]['alias_bridge_id']
-                    if required_bridge_id != pkt_alias_bridge_id.upper():
-                        report.append(f"Alias bridge ID of the packet does not match. The required alias bridge ID is {required_bridge_id} but the packet alias bridge ID is {pkt_alias_bridge_id}")
+                    expected_bridge_id = validation_data.iloc[0]['adva']
+                    expected_bridge_ids = [expected_bridge_id, self.swap_endianness(expected_bridge_id)]
+                    if pkt_alias_bridge_id.upper() not in expected_bridge_ids:
+                        report.append(f"Alias bridge ID of the packet does not match. Expected alias bridge IDs:{expected_bridge_ids} but the packet alias bridge ID is {pkt_alias_bridge_id}")
                         self.stage_pass = MINIMUM_SCORE
                         self.error_summary = "aliasBridgeId doesn't match the expected one of a packet. "
                         aliasBridgeId_valid = False 
@@ -633,6 +630,7 @@ class GeolocationStage(GenericUplinkStage):
         self.__dict__.update(kwargs)
         super().__init__(**self.__dict__, stage_name=type(self).__name__)
         self.graph_html_path = os.path.join(self.test_dir, f'{self.stage_name}.html')
+        self.result_indication = INFORMATIVE
 
     
     def prepare_stage(self):
@@ -678,11 +676,150 @@ class GeolocationStage(GenericUplinkStage):
                                                                 stage_report=self.report.split('\n'), graph = graph_div)
         return self.report
 
+class ACLStage(GenericUplinkStage):
+    def __init__(self, **kwargs):
+        self.stage_tooltip = "Configures the gateway's Access Control List and simulate bridges. Expects 100% discard rate"
+        self.__dict__.update(kwargs)
+        super().__init__(**self.__dict__, stage_name=type(self).__name__)
+        self.pass_min = 60
+        self.inconclusive_min = 50
+        self.run_data = ACLRunData().data
+
+    @property
+    def acl_modes(self):
+        return [ACL_ALLOW, ACL_DENY]
+
+    def run(self):
+        super().run()
+
+        def advertise_packets(pkts_group, adv_count, acl_brg_ids, mode):
+            acl_dict = {ACL_MODE: mode, ACL_BRIDGE_IDS: acl_brg_ids}
+
+            # Calculate row indices we want to advertise
+            df_packets_count = len(self.run_data) // adv_count
+            start_idx = df_packets_count * pkts_group
+            end_idx = df_packets_count * (pkts_group + 1)
+
+            for index, row in self.run_data.iloc[start_idx:end_idx].iterrows():
+                if mode == ACL_ALLOW:
+                    should_be_received = row['bridge_id'] in acl_brg_ids
+                else:
+                    should_be_received = row['bridge_id'] not in acl_brg_ids
+                data = row[ADVA_PAYLOAD]
+                self.local_pkts.append((row[PAYLOAD], row['duplication'], row['time_delay'], row['adva'], acl_dict, should_be_received))
+                self.ble_sim.send_packet(raw_packet=data, duplicates=row['duplication'], delay=row['time_delay'])
+                self.ts_records.set_adv_timestamp_current(data)
+
+        def configure_acl(mode, bridgeIds):
+            acl_dict = {ACL_MODE: mode, ACL_BRIDGE_IDS: bridgeIds}
+            ser_format = SerializationFormatter(self.mqttc.get_serialization())
+            payload = ser_format.cfg_param_set(self.cfg_data.status_msg_get(), Configurable.ACL.value, acl_dict)
+            self.mqttc.flush_messages_topic('status')
+            self.mqttc.send_payload(payload)
+            time.sleep(5 if self.aggregation_time == 0 else self.aggregation_time)
+            debug_print('Status message received from gw:')
+            gw_status = self.mqttc.get_status_message()
+            if gw_status != None and isinstance(gw_status, dict) and ser_format.is_pb():
+                gw_status = ser_format.pb_status_acl_bytes_to_hex_string(gw_status)
+            debug_print(gw_status)
+
+        # Configuring each bridge in ACL, once for each mode
+        brg_ids = self.run_data['bridge_id'].unique().tolist()
+        cfg_and_adv_loops = len(brg_ids) * len(self.acl_modes)
+        i = 0
+        for brg_id in brg_ids:
+            acl_brg_ids = [brg_id]
+            for mode in self.acl_modes:
+                configure_acl(mode, acl_brg_ids)
+                time.sleep(5 if self.aggregation_time == 0 else self.aggregation_time)
+                advertise_packets(i, cfg_and_adv_loops, acl_brg_ids, mode)
+                time.sleep(5 if self.aggregation_time == 0 else self.aggregation_time)
+                i += 1
+
+        configure_acl(ACL_DENY, [])
+        time.sleep(5)
+    
+    def compare_local_mqtt(self):
+        self.fetch_mqtt_from_stage()
+        local_pkts_df = pd.DataFrame(self.local_pkts, columns=[PAYLOAD, 'duplication', 'time_delay', 'aliasBridgeId', 'ACL', SHOULD_RECEIVE])
+        mqtt_pkts_df = pd.DataFrame(self.mqtt_pkts)
+        comparison = local_pkts_df
+
+        if PAYLOAD not in mqtt_pkts_df.columns:
+            mqtt_pkts_df[PAYLOAD] = ''
+        received_pkts_df = pd.merge(local_pkts_df[PAYLOAD], mqtt_pkts_df[PAYLOAD], how='inner')
+        
+        received_pkts = set(received_pkts_df[PAYLOAD])
+
+        self.pkts_received_count = pd.Series.count(received_pkts_df)
+        unique_received_count = len(received_pkts)
+        self.pkts_filtered_out_count = self.pkts_received_count - unique_received_count
+
+        comparison[RECEIVED] = comparison[PAYLOAD].isin(received_pkts)
+        self.comparison = comparison
+
+    def generate_stage_report(self):
+        self.compare_local_mqtt()
+        self.ts_records.validate_timestamps(self.mqtt_pkts)
+        self.add_report_header()
+        
+        num_pkts_sent = len(self.comparison)
+        num_pkts_received = self.comparison[RECEIVED].eq(True).sum()
+        num_pkts_should_received = self.comparison[SHOULD_RECEIVE].eq(True).sum()
+        num_pkts_should_discard = self.comparison[SHOULD_RECEIVE].eq(False).sum()
+        num_pkts_discarded_correctly = (self.comparison[SHOULD_RECEIVE].eq(False) & self.comparison[RECEIVED].eq(False)).sum()
+        num_pkts_received_correctly = (self.comparison[SHOULD_RECEIVE].eq(True) & self.comparison[RECEIVED].eq(True)).sum()
+        num_pkts_failed_to_discard = (self.comparison[SHOULD_RECEIVE].eq(False) & self.comparison[RECEIVED].eq(True)).sum()
+        num_pkts_failed_to_receive = (self.comparison[SHOULD_RECEIVE].eq(True) & self.comparison[RECEIVED].eq(False)).sum()
+        self.add_to_stage_report(f"Total packets advertised: {num_pkts_sent}")
+        self.add_to_stage_report(f"Packets received / should've received: {num_pkts_received_correctly} / {num_pkts_should_received}")
+        self.add_to_stage_report(f"Packets discarded / should've discarded: {num_pkts_discarded_correctly} / {num_pkts_should_discard}")
+        self.add_to_stage_report(f"Failed to discard: {num_pkts_failed_to_discard}\n")
+
+        if num_pkts_failed_to_discard > 0:
+            self.stage_pass = MINIMUM_SCORE
+            self.error_summary = "Received packet/s that should've been discarded"
+            for index, row in self.comparison.iterrows():
+                if row[RECEIVED] == True and row[SHOULD_RECEIVE] == False:
+                    self.add_to_stage_report(f"Payload from bridge {row['aliasBridgeId']} should have been filtered out: {row[PAYLOAD]}")
+            self.add_to_stage_report('')
+            # Report packets failed to receive only if we have issue discarding.
+            # Since it increase the likelyhood of bad logic, and not just missed packets
+            if num_pkts_failed_to_receive > 0:
+                for index, row in self.comparison.iterrows():
+                    if row[RECEIVED] == False and row[SHOULD_RECEIVE] == True:
+                        self.add_to_stage_report(f"Payload from bridge {row['aliasBridgeId']} wasn't received: {row[PAYLOAD]}")
+                self.add_to_stage_report('')
+        elif num_pkts_received == 0:
+            self.stage_pass = MINIMUM_SCORE
+            self.error_summary = "No packets received"
+            debug_print(f"No packets were received")
+        else:
+            self.stage_pass = num_pkts_received / num_pkts_should_received * PERFECT_SCORE
+            if self.stage_pass < self.pass_min:
+                self.add_to_stage_report(ERR_SUM_MISSING_PKTS)
+                self.error_summary = ERR_SUM_MISSING_PKTS
+        
+        if num_pkts_received > 0:
+            self.add_report_topic_validation('data')
+
+        self.ts_records.add_ts_errs_to_report(self)
+
+        self.comparison.to_csv(self.csv_path)
+        self.add_report_line_separator()
+        self.add_to_stage_report(f'Stage data saved - {self.csv_path}')
+        debug_print(self.report)
+        
+        # Generate HTML
+        self.report_html = self.template_engine.render_template('stage.html', stage=self, 
+                                                                stage_report=self.report.split('\n'))
+        
+        return self.report
 
 # TEST CLASS
-TX_STAGES = [ManagementPacketStage, DataPacketStage, SensorPacketStage]
+TX_STAGES = [ManagementPacketStage, DataPacketStage, SensorPacketStage, ACLStage]
 UNCOUPLED_STAGES = [ManagementPacketStage, DataPacketStage, SensorPacketStage,
-                    SequentialSequenceIdStage, AliasBridgeIDStage, GeolocationStage] 
+                    SequentialSequenceIdStage, GeolocationStage]
 
 class UplinkTest(GenericTest):
     def __init__(self, **kwargs):
@@ -695,7 +832,9 @@ class UplinkTest(GenericTest):
         super().prepare_test()
         stages = UNCOUPLED_STAGES
         if self.mqttc.get_serialization() == Serialization.JSON:
-            stages = stages + [ApiValidationStage]
+            stages.append(ApiValidationStage)
+        if self.cfg_data.is_acl_supported():
+            stages.append(ACLStage)
         # if self.gw_capabilities.geoLocationSupport:
         #     stages.append(GeolocationStage)
         self.stages = [stage(**self.__dict__) for stage in stages]

{wiliot_certificate-1.5.2a1.dist-info → wiliot_certificate-4.4.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: wiliot_certificate
-Version: 1.5.2a1
+Version: 4.4.0
 Summary: A library for certifying Wiliot-compliant boards
 Author-email: Wiliot <support@wiliot.com>
 License: MIT License
@@ -52,24 +52,33 @@ Requires-Dist: reportlab>=4.3.1
 Requires-Dist: google-api-python-client>=2.162.0
 Dynamic: license-file
 
-# wiliot-certificate
+# wiliot-certificate Version 4.4.0
 
 <!-- Description -->
-wiliot-certificate is a python library with tools used to test & certify boards and their compatibility with Wiliot's echosystem.
+wiliot-certificate is a Python library that provides tools for testing and certifying boards for compatibility with Wiliot’s ecosystem.
 This python package includes the following CLI utilities:
  - Gateway Certificate (`wlt-cert-gw`)
  - Bridge Certificate (`wlt-cert-brg`)
 
+# Version: 
+wiliot-certificate versions 4.4.0 are compatible with firmware version 4.4.6 (ESP: 4.4.44, BLE: 4.4.93)
+
 ## Installing wiliot-certificate
+Uninstall wiliot-deployment-tools if installed (relevant for old wlt-gw-certificate users):
+````commandline
+pip uninstall wiliot-deployment-tools
+````
+
+Install wiliot-certificate:
 ````commandline
 pip install wiliot-certificate
 ````
 
 ## Using wiliot-certificate
 ### Gateway Certificate
-Test Wiliot GWs capabilities.
-The GW Certificate includes different test that run sequentially to test each capability reported by the GW.
-To run the GW Certificate the GW needs to use a public MQTT Broker (Eclipse):
+Test Wiliot Gateway capabilities.
+The Gateway Certificate includes different test that run sequentially to test each capability reported by the Gateway.
+To run the Gateway Certificate the Gateway needs to use a public MQTT Broker (Eclipse):
 
 Host:	mqtt.eclipseprojects.io
 TLS TCP Port:	8883
@@ -79,59 +88,91 @@ Websocket Port:	80
 
 More information can be found at https://mqtt.eclipseprojects.io/.
 
-#### GW Certificate Release Notes:
+#### Gateway Certificate Release Notes:
 Release:
  - Standalone wiliot-certificate package
  - Python 3.13 support
- - Gw API version 205 support
+ - Gateway API version 205 support
  - Registration test added
  - Bridge OTA stage added under actions
  - Aggregation flag supported by StressTest
  - -update flag compatibility fix. Upgrades bootloader if needed
  - -actions flag to select specific actions to test
+ - ACL (Access control list) test for gateways reporting API version 205 in the connection test
+
+#### The following capabilities are not tested in this version
+ - Access control list stress stress
+ - Validation schema verification
+ - Board type registered within the Board Type Management system
+ - Bridge OTA progress reporting
+
 
 ```
-usage: wlt-gw-certificate [-h] -owner OWNER -gw GW [-suffix SUFFIX] [-tests {connection,uplink,downlink,stress}]
+Usage: wlt-cert-gw [-h] -owner OWNER -gw GW [-suffix SUFFIX] [-tests {connection,uplink,downlink,stress}]
 
 Gateway Certificate - CLI Tool to test Wiliot GWs
 
-required arguments:
+Required arguments:
   -gw GW        Gateway ID
 
-optional arguments:
+Optional arguments:
   -owner OWNER  Owner ID (Required for non-registration tests)
   -tests        Pick specific tests to run
   -actions      Pick specific actions to test during the ActionsTest
   -update       Update the firmware of the test board
   -pps          Pick specific PPS rate for the stress test
-  -agg          Time the uplink stages should wait before processing packets
-  -suffix       Allow for different suffixes after the GW ID in MQTT topics
-  -env          Wiliot envrionment for Registration and bridgeOTA tests
+  -agg          Duration uplink stages wait before processing packets
+  -suffix       Allow for different suffixes after the Gateway ID in MQTT topics
+  -env          Wiliot environment for registration and bridgeOTA tests
   -h, --help    show this help message and exit
   ```
 
 ### Bridge Certificate
-Test Wiliot BRGs capabilities.
-The BRG Certificate includes different tests that run sequentially to test each capability reported by the BRG.
-The BRG Certificate tool uses a public MQTT Broker (Eclipse):
-
-Host:	mqtt.eclipseprojects.io
-TLS TCP Port:	8883
-TLS Websocket Port:	443
-TCP Port:	1883
-Websocket Port:	80
-
-More information can be found at https://mqtt.eclipseprojects.io/.
+Test Wiliot Bridge capabilities.
+The Bridge Certificate includes different tests that run sequentially to test each capability reported by the bridge.
+
+
+# update Gateway sim version :
+- Update your gateway and bridge using Wiliot's platform. (https://platform.wiliot.com/) 
+- Transfer the gateway to dev mode - run the following command: py ut\dev_mode.py --gw [GW] --enable
+- Connect the gateway to your laptop via USB connection:
+- Run the following: wlt-cert-brg --gw SIM --brg <XXXXXXXXXXXX> --port <COM_PORT>
+- For other options of running, see the 'run example' section. 
+
+#### Bridge Certificate Release Notes:
+Release
+- First release of Bridge Certificate – includes validation tests for bridge functionality.
+- Additional details are available in the JSON files.
+
+# The following capabilities are not tested in this version
+
+Power management
+  - Functionality of energize and transmit in sleep mode
+Edge management
+  - Timing of heartbeat and interface packets 
+Module Energy 2400
+  - Functionality of energy pattern, output power and duty cycle
+Module Energy SUB1G
+  - Functionality of energy pattern and duty cycle 
+Module Datapath 
+  - RSSI edge cases: -127 and 0 
+  - Functionality of transmission pattern, output power
+  - Pacer interval with channel 10 and 500k modulation
+  - Pacer interval using GEN3 Pixels 
+  - Packet filter: the following configuration - DEBUG, TEMP & DEBUG, TEMPS & DEBUG & ADVANCE
+  - Rx rate feature with extended advertising 
+  - Functionality of adaptive pacer algorithm
+  - Supported Pixels for extended advertising and GEN3
+Calibration 
+  - Functionality of output power and interval calibration 
+  - Functionality of calibration transmission patterns for the configuration STANDARD & EU & DISABLE
 
-#### BRG Certificate Release Notes:
-1.3.0:
- - FIRST VERSION
 
 ```
-usage: brg_certificate_cli.py [-h] [--brg BRG] [--brg_cloud_connectivity BRG_CLOUD_CONNECTIVITY] [--brg1 BRG1] --gw GW [--data {tags,sim}] [--port PORT] [--clean] [--tl TL] [--run RUN]
+usage: wlt-cert-brg [-h] [--brg BRG] [--brg_cloud_connectivity BRG_CLOUD_CONNECTIVITY] [--brg1 BRG1] --gw GW [--data {tags,sim}] [--port PORT] [--clean] [--tl TL] [--run RUN]
                               [--drun DRUN] [--exit_on_test_failure] [--exit_on_param_failure] [--analyze_interference]
 
-Bridge Certificate CLI
+# Bridge Certificate CLI
 
 options:
   -h, --help            show this help message and exit