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

gw_certificate/tests/static/references.py

@@ -1,4 +1,5 @@
 
 GW_ACTIONS_DOC = "https://community.wiliot.com/customers/s/article/Wiliot-Gateway-Actions"
 GW_REGISTER_DOC = "https://community.wiliot.com/customers/s/article/Registering-Third-Party-Gateways"
-GW_MQTT_DOC = "https://community.wiliot.com/customers/s/article/Sending-Wiliot-Packets-to-the-Wiliot-Cloud"
+GW_MQTT_DOC = "https://community.wiliot.com/customers/s/article/Sending-Wiliot-Packets-to-the-Wiliot-Cloud"
+GW_BRIDGE_OTA_DOC = "https://community.wiliot.com/customers/s/article/Bridge-OTA"

gw_certificate/tests/static/uplink_defines.py

@@ -1,18 +1,11 @@
 from gw_certificate.interface.if_defines import *
 from gw_certificate.ag.ut_defines import *
 
-UPLINK_BRG_ID = 'FFFFFFFFFFFF'
 RECEIVED = 'received'
-SEQ_ID = "sequenceId"
 SHARED_COLUMNS = [PAYLOAD]
 INT64_COLUMNS = [RSSI]
 OBJECT_COLUMNS = [PAYLOAD]
-INIT_STAGES_DUPLICATIONS = [i for i in range(2,9)]
 REPORT_COLUMNS = ['pkt_id', 'duplication', 'time_delay']
-INCREMENTAL_TIME_DELAYS = [10, 50, 100, 255]
-TAG_STAGE_ADVA = '0000000000C0'
-TAG_STAGE_PACKETS = range(40)
-INCREMENTAL_PACKETS = range(255)
 
 ADV_TIMESTAMP = 'adv_timestamp'
 TS_DEVIATION = 1500

gw_certificate/tests/throughput.py

@@ -14,7 +14,6 @@ from gw_certificate.tests.uplink import TimestampsHelper
 from gw_certificate.interface.mqtt import MqttClient
 from gw_certificate.tests.static.generated_packet_table import StressRunData
 from gw_certificate.tests.generic import PassCriteria, PERFECT_SCORE, GenericTest, GenericStage, INFORMATIVE
-from gw_certificate.interface.packet_error import PacketError
 
 # HELPER DEFINES
 ONE_SECOND_MS = 1000
@@ -28,7 +27,7 @@ TIME_PER_DELAY_FIRST = 50
 def process_payload(packet:dict):
     payload = packet[PAYLOAD]
     payload = payload.upper()
-    if len(payload) == 62 and payload[:4] == '1E16':
+    if len(payload) == 62 and payload[2:4] == '16':
         payload = payload [4:]
     # big2little endian
     if payload[:4] == 'FCC6':
@@ -38,10 +37,6 @@ def process_payload(packet:dict):
 
 
 # TEST STAGES
-
-class StressTestError(Exception):
-    pass
-
 class GenericStressStage(GenericStage):
     def __init__(self, mqttc:MqttClient, ble_sim:BLESimulator, gw_capabilities:GWCapabilities, stage_name,
                 **kwargs):
@@ -61,9 +56,6 @@ class GenericStressStage(GenericStage):
         
         # GW Capabilities
         self.gw_capabilities = gw_capabilities
-        
-        # Packet Error
-        self.packet_error = PacketError()
 
         #Run Data
         self.run_stress_data = StressRunData()
@@ -128,6 +120,9 @@ class StressTestStage(GenericStressStage):
     def run_full_stress_test(self, delay_idx, delay):
         self.prepare_stage()
         self.run_stress_test_with_delay(delay_idx, delay)
+        if self.aggregation_time > 0:
+            debug_print(f"Waiting {self.aggregation_time} seconds for packets to be uploaded before processing results..")
+            time.sleep(self.aggregation_time)
         self.generate_stage_report(delay_idx)
         self.teardown_stage()
 
@@ -202,8 +197,9 @@ class StressTestStage(GenericStressStage):
             self.add_report_header()
             self.add_to_stage_report(tabulate.tabulate(pd.DataFrame(report), showindex=False))   
             for idx, delay in enumerate(self.delays):
-                self.ts_records_arr[idx].add_ts_errs_to_report(self)
                 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.add_report_line_separator()
             self.add_to_stage_report(f'Stage data saved - {self.csv_path}')
 
@@ -235,10 +231,9 @@ class StressTest(GenericTest):
 
     def run(self):
         super().run()
-        self.test_pass = PERFECT_SCORE
         for stage in self.stages:
             stage.prepare_stage()
             stage.run()
-            self.test_pass = PassCriteria.calc_for_test(self.test_pass, stage)
+            self.test_pass = PassCriteria.calc_for_test(self, stage)
             self.all_messages_in_test.extend(self.mqttc.get_all_messages_from_topic('data'))
     

gw_certificate/tests/uplink.py

@@ -14,9 +14,8 @@ 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 UplinkRunData, UnifiedRunData, SensorRunData, MgmtRunData, PacketTableHelper
-from gw_certificate.tests.generic import PassCriteria, PERFECT_SCORE, MINIMUM_SCORE, INCONCLUSIVE_MINIMUM, INIT_INCONCLUSIVE_MINIMUM, GenericTest, GenericStage
-from gw_certificate.interface.packet_error import PacketError
+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.api_if.api_validation import MESSAGE_TYPES, validate_message
 from gw_certificate.tests.static.generated_packet_table import CSV_NAME
 
@@ -25,13 +24,13 @@ from gw_certificate.tests.static.generated_packet_table import CSV_NAME
 TABLE_SUFFIX = "Table"
 ERR_SUM_MISSING_PKTS = "Insufficient amount of packets were scanned & uploaded by the gateway. "
 ERR_SUM_INVALID_TS = "Invalid timestamps were uploaded by the gateway. "
+ERR_SUM_ONLY_1E = "Packets with length != '1E' were not uploaded. "
 
 # HELPER FUNCTIONS
-
 def process_payload(packet:dict):
     payload = packet[PAYLOAD]
     payload = payload.upper()
-    if len(payload) == 62 and payload[:4] == '1E16':
+    if len(payload) == 62 and payload[2:4] == '16':
         payload = payload [4:]
     # big2little endian
     if payload[:4] == 'FCC6':
@@ -43,6 +42,8 @@ def process_payload(packet:dict):
 class TimestampsHelper(PacketTableHelper):
     def __init__(self):
         self.ts_errors = []
+        self.has_out_of_range_ts = False
+        self.has_identical_ts = False
         super().__init__()
 
     def set_adv_timestamp(self, data_payload, timestamp):
@@ -64,8 +65,10 @@ class TimestampsHelper(PacketTableHelper):
     def validate_timestamps(self, received_pkts:list):
         packets_sent_df = self.get_advertised_entries().copy()
 
-        # Convert received packets into a DataFrame for vectorized processing
         received_df = pd.DataFrame(received_pkts)
+        if PAYLOAD not in received_df.columns or TIMESTAMP not in received_df.columns:
+            debug_print(f"Can't find payload/timestamp columns, skipping timestamp validation")
+            return
         received_df = received_df[[PAYLOAD, TIMESTAMP]]
         received_df[TIMESTAMP] = pd.to_numeric(received_df[TIMESTAMP], errors='coerce')
 
@@ -95,6 +98,7 @@ class TimestampsHelper(PacketTableHelper):
                         f"Timestamp {received_ts} is too far off the accepted range "
                         f"{min_accepted_ts}-{max_accepted_ts} for payload: {row[PAYLOAD]}"
                     )
+                    self.has_out_of_range_ts = True
                 return received_ts
             return None
 
@@ -107,23 +111,20 @@ class TimestampsHelper(PacketTableHelper):
 
             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):
         for idx, ts_err in enumerate(self.ts_errors):
             stage.add_to_stage_report(ts_err)
-            if idx == 3 and (len(self.ts_errors) - 1) > idx:
+            if idx == 2 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
     
     def is_ts_error(self) -> bool:
         return len(self.ts_errors) > 0
-
+    
 
 # TEST STAGES
-
-class UplinkTestError(Exception):
-    pass
-
 class GenericUplinkStage(GenericStage):
     def __init__(self, mqttc:MqttClient, ble_sim:BLESimulator, gw_capabilities:GWCapabilities, stage_name,
                 **kwargs):
@@ -141,12 +142,8 @@ class GenericUplinkStage(GenericStage):
         # GW Capabilities
         self.gw_capabilities = gw_capabilities
         
-        # Packet Error / Run data
-        self.packet_error = PacketError()
-        self.run_data = UplinkRunData
-        
-        # Unified stage
-        self.run_data_unified = UnifiedRunData
+        # Run data
+        self.run_data = None
 
         self.ts_records = TimestampsHelper()
 
@@ -161,7 +158,6 @@ class GenericUplinkStage(GenericStage):
         # self.mqtt_packets is a list of pkt jsons: [{timestamp:..., aliasbr.. payload...}, {...}]
         self.mqtt_pkts = list(map(lambda p: process_payload(p), mqtt_pkts))
     
-    ## TODO - REWRITE
     def compare_local_mqtt(self):
         self.fetch_mqtt_from_stage()
         local_pkts_df = pd.DataFrame(self.local_pkts, columns=[PAYLOAD, 'duplication', 'time_delay', 'aliasBridgeId'])
@@ -195,8 +191,11 @@ class GenericUplinkStage(GenericStage):
         if self.stage_pass < self.pass_min:
             self.error_summary = ERR_SUM_MISSING_PKTS
         if self.ts_records.is_ts_error():
-            self.stage_pass = min(self.stage_pass, self.inconclusive_min)
-            self.error_summary += ERR_SUM_INVALID_TS
+            if self.stage_pass > self.inconclusive_min:
+                self.stage_pass = self.inconclusive_min
+                self.error_summary = ERR_SUM_INVALID_TS
+            else:
+                self.error_summary += ERR_SUM_INVALID_TS
 
         self.add_report_header()
         self.add_to_stage_report(f'Number of unique packets sent: {num_pkts_sent}')
@@ -211,6 +210,9 @@ class GenericUplinkStage(GenericStage):
 
         self.ts_records.add_ts_errs_to_report(self)
 
+        if num_pkts_received > 0:
+            self.add_report_topic_validation('data')
+
         self.comparison.to_csv(self.csv_path)
         self.add_to_stage_report(f'Stage data saved - {self.csv_path}')
         debug_print(self.report)
@@ -229,12 +231,13 @@ class ManagementPacketStage(GenericUplinkStage):
         self.__dict__.update(kwargs)
         super().__init__(**self.__dict__, stage_name=type(self).__name__)
         self.run_data = MgmtRunData().data
+        self.pass_min = 40
+        self.inconclusive_min = 30
 
     def run(self):
         super().run()
         for index, row in self.run_data.iterrows():
             data = row[ADVA_PAYLOAD]
-            # cur_ts = time.time_ns() // 1_000_000
             self.local_pkts.append((row[PAYLOAD], row['duplication'], row['time_delay'], row['adva']))
             self.ble_sim.send_packet(raw_packet=data, duplicates=row['duplication'], delay=row['time_delay'])
             self.ts_records.set_adv_timestamp_current(data)
@@ -250,8 +253,11 @@ class ManagementPacketStage(GenericUplinkStage):
         if self.stage_pass < self.pass_min:
             self.error_summary = ERR_SUM_MISSING_PKTS
         if self.ts_records.is_ts_error():
-            self.stage_pass = min(self.stage_pass, self.inconclusive_min)
-            self.error_summary += ERR_SUM_INVALID_TS
+            if self.stage_pass > self.inconclusive_min:
+                self.stage_pass = self.inconclusive_min
+                self.error_summary = ERR_SUM_INVALID_TS
+            else:
+                self.error_summary += ERR_SUM_INVALID_TS
 
         self.add_report_header()
         self.add_to_stage_report(f'Number of unique packets sent: {num_pkts_sent}')
@@ -263,6 +269,9 @@ class ManagementPacketStage(GenericUplinkStage):
             self.add_to_stage_report(tabulate.tabulate(not_received, headers='keys', showindex=False))
             self.add_to_stage_report('Check the CSV for more info')
         
+        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)
@@ -294,7 +303,6 @@ class DataPacketStage(GenericUplinkStage):
         time.sleep(5)
 
 
-
 class SensorPacketStage(GenericUplinkStage):
     def __init__(self, **kwargs):
         self.__dict__.update(kwargs)
@@ -315,15 +323,16 @@ class SensorPacketStage(GenericUplinkStage):
             data = row[ADVA_PAYLOAD]
             si = row['si']
             # Save to local_pkts once for data and once for side info. Each with corresponding adva.
-            self.local_pkts.append((row[PAYLOAD], row['duplication'], row['time_delay'], apply_adva_bitmask(row['bridge_id'], 'random_static')))
-            self.local_pkts.append((remove_pre_uuid(row['si']), row['duplication'], row['time_delay'], row['adva']))
+            self.local_pkts.append((row[ADVA_PAYLOAD], row[PAYLOAD], row['duplication'], row['time_delay'], apply_adva_bitmask(row['bridge_id'], 'random_static')))
+            self.local_pkts.append((row['si'], remove_pre_uuid(row['si']), row['duplication'], row['time_delay'], row['adva']))
             self.ble_sim.send_data_si_pair(data_packet=data, si_packet=si, duplicates=row['duplication'], delay=row['time_delay'])
             self.ts_records.set_adv_timestamp_current(data)
         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'])
+        # 'columns' must correspond to number of columns appended previously
+        local_pkts_df = pd.DataFrame(self.local_pkts, columns=[ADVA_PAYLOAD, PAYLOAD, 'duplication', 'time_delay', 'aliasBridgeId'])
         mqtt_pkts_df = pd.DataFrame(self.mqtt_pkts)
         comparison = local_pkts_df
 
@@ -348,8 +357,7 @@ class SensorPacketStage(GenericUplinkStage):
         
     def generate_stage_report(self):
         self.compare_local_mqtt()
-        print(self.comparison)
-        report = []
+        self.ts_records.validate_timestamps(self.mqtt_pkts)
         num_pkts_sent = len(self.comparison)
         num_pkts_received = self.comparison['received'].eq(True).sum()
         pkt_id_pairs = self.comparison.groupby('pkt_id').filter(lambda x: x['received'].all() and len(x) == 2)
@@ -360,15 +368,43 @@ class SensorPacketStage(GenericUplinkStage):
             self.stage_pass = PERFECT_SCORE
         else:
             self.stage_pass = MINIMUM_SCORE
+        
+        if self.ts_records.is_ts_error():
+            if self.stage_pass > self.inconclusive_min:
+                self.stage_pass = self.inconclusive_min
+                self.error_summary = ERR_SUM_INVALID_TS
+            else:
+                self.error_summary += ERR_SUM_INVALID_TS
             
         self.add_report_header()
         self.add_to_stage_report((f'Number of sensor packets sent: {int(num_pkts_sent / 2)}'))
         self.add_to_stage_report((f'Number of sensor packets received correctly: {num_pairs}\n'))
 
-        not_received = self.comparison[self.comparison[RECEIVED]==False][REPORT_COLUMNS]
+        not_received = self.comparison[self.comparison[RECEIVED]==False]
+        not_received_rep_cols = not_received[REPORT_COLUMNS]
         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(tabulate.tabulate(not_received_rep_cols, headers='keys', showindex=False))
+
+            def only_varying_len_sensors_missed(not_received_df):
+                for index, line in not_received_df.iterrows():
+                    if line[ADVA_PAYLOAD][12:14] == '1E':
+                        return False
+                return True
+
+            if only_varying_len_sensors_missed(not_received):
+                self.add_to_stage_report(f"Warning {ERR_SUM_ONLY_1E}")
+                if self.score_pass():
+                    self.stage_pass = self.inconclusive_min
+                    self.error_summary = ERR_SUM_ONLY_1E
+                else:
+                    self.error_summary += ERR_SUM_ONLY_1E
+        
+        self.ts_records.add_ts_errs_to_report(self)
+
+        if num_pkts_received > 0:
+            self.add_report_topic_validation('data')
+
         self.comparison.to_csv(self.csv_path)
         self.add_to_stage_report(f'Stage data saved - {self.csv_path}')
         debug_print(self.report)
@@ -515,9 +551,10 @@ class AliasBridgeIDStage(GenericUplinkStage):
         relative_path = 'static/' + CSV_NAME
         csv_path = pkg_resources.resource_filename(__name__, relative_path)
         df = pd.read_csv(csv_path)
+        uplink_tests_df = df[(df['test'] == 'unified') | (df['test'] == 'mgmt') | (df['test'] == 'sensor')].copy()
 
         # Store all test payloads
-        all_payloads = df[ADVA_PAYLOAD].str[12:]
+        all_payloads = uplink_tests_df[PAYLOAD]
         self.all_test_payloads = all_payloads.tolist()
 
         def _parser(row, desired:Literal['adva', 'without_adva']):
@@ -530,10 +567,9 @@ class AliasBridgeIDStage(GenericUplinkStage):
             return output_string
 
         # Create data set for alias bridge verification
-        alias_bridge_id_df = df[(df['test'] == 'unified') | (df['test'] == 'mgmt')].copy()
-        alias_bridge_id_df['payload'] = alias_bridge_id_df.apply(lambda row: _parser(row, 'without_adva'), axis=1)
+        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.apply(lambda row: _parser(row, 'adva'), axis=1)
+        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
@@ -563,7 +599,10 @@ class AliasBridgeIDStage(GenericUplinkStage):
                     pkt_payload = pkt['payload']
                     pkt_alias_bridge_id = pkt['aliasBridgeId']
                     validation_data = self.alias_bridge_id_df[self.alias_bridge_id_df['payload'].str.contains(pkt_payload, case=False)] 
-                    required_bridge_id = validation_data['alias_bridge_id'].iat[0]
+                    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}")
                         self.stage_pass = MINIMUM_SCORE
@@ -652,7 +691,7 @@ class GeolocationStage(GenericUplinkStage):
 # TEST CLASS
 TX_STAGES = [ManagementPacketStage, DataPacketStage, SensorPacketStage]
 UNCOUPLED_STAGES = [ManagementPacketStage, DataPacketStage, SensorPacketStage,
-                    SequentialSequenceIdStage, AliasBridgeIDStage] 
+                    SequentialSequenceIdStage, AliasBridgeIDStage, GeolocationStage] 
 
 class UplinkTest(GenericTest):
     def __init__(self, **kwargs):
@@ -660,17 +699,18 @@ class UplinkTest(GenericTest):
         self.__dict__.update(kwargs)
         super().__init__(**self.__dict__, test_name=type(self).__name__)
         self.all_messages_in_test = []
+        
+    def prepare_test(self):
+        super().prepare_test()
         stages = UNCOUPLED_STAGES
         if self.mqttc.get_serialization() == Serialization.JSON:
             stages = stages + [ApiValidationStage]
-        if self.gw_capabilities.geoLocationSupport:
-            stages.append(GeolocationStage)
+        # if self.gw_capabilities.geoLocationSupport:
+        #     stages.append(GeolocationStage)
         self.stages = [stage(**self.__dict__) for stage in stages]
-        
 
     def run(self):
         super().run()
-        self.test_pass = PERFECT_SCORE
         for stage in self.stages:
             stage.prepare_stage()
             stage.run()
@@ -678,6 +718,6 @@ class UplinkTest(GenericTest):
                 debug_print(f"Waiting {self.aggregation_time} seconds for packets to be uploaded before processing results..")
                 time.sleep(self.aggregation_time)
             self.add_to_test_report(stage.generate_stage_report())
-            self.test_pass = PassCriteria.calc_for_test(self.test_pass, stage)
+            self.test_pass = PassCriteria.calc_for_test(self, stage)
             self.all_messages_in_test.extend(self.mqttc.get_all_messages_from_topic('data'))
     

{wiliot_certificate-1.3.0a1.dist-info → wiliot_certificate-1.4.0a1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: wiliot_certificate
-Version: 1.3.0a1
+Version: 1.4.0a1
 Summary: A library for certifying Wiliot-compliant boards
 Author-email: Wiliot <support@wiliot.com>
 License: MIT License
@@ -30,7 +30,7 @@ Project-URL: Certified, https://www.wiliot.com/product/ambient-iot-network#partn
 Classifier: Programming Language :: Python :: 3
 Classifier: License :: OSI Approved :: MIT License
 Classifier: Operating System :: OS Independent
-Requires-Python: >=3.9
+Requires-Python: >=3.13
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: jinja2>=3.1.5
@@ -42,18 +42,22 @@ Requires-Dist: colorama>=0.4.6
 Requires-Dist: tabulate>=0.9.0
 Requires-Dist: wiliot-core>=5.9.1
 Requires-Dist: paho-mqtt>=2.1.0
-Requires-Dist: bitstruct>=8.19.0
+Requires-Dist: bitstruct>=8.20.0
 Requires-Dist: protobuf>=5.29.3
 Requires-Dist: wiliot-api>=4.10.8
 Requires-Dist: jsonschema>=4.23.0
 Requires-Dist: statsmodels>=0.14.4
+Requires-Dist: pyserial>=3.5
+Requires-Dist: reportlab>=4.3.1
+Requires-Dist: google-api-python-client>=2.162.0
 
-# wiliot-certificate #
+# wiliot-certificate
 
 <!-- Description -->
 wiliot-certificate is a python library with tools used to test & certify boards and their compatibility with Wiliot's echosystem.
 This python package includes the following CLI utilities:
  - Gateway Certificate (`wlt-gw-certificate`)
+ - Bridge Certificate (`wlt-cert-brg`)
 
 ## Installing wiliot-certificate
 ````commandline
@@ -87,11 +91,12 @@ Sends advertising actions (txPacket) via MQTT to the GW and validates their adve
 Increments time delays between packets to evaluate GW's capability in handling increasing packets per second rates.
 
 #### GW Certificate Release Notes:
-1.3.0:
+1.4.0:
  - Released in a standalone wiliot-certificate package
- - Python 3.13 support
+ - Python 3.12 support
  - Gw API version 205 support
  - Registration Test
+ - Aggregation flag supported by StressTest
 
 
 ```
@@ -101,13 +106,59 @@ Gateway Certificate - CLI Tool to test Wiliot GWs
 
 required arguments:
   -gw GW        Gateway ID
-  -owner OWNER  Owner ID (optional when running only the registration test)
 
 optional arguments:
-  -suffix       Allow for different suffixes after the GW ID in MQTT topics
+  -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
   -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/.
+
+#### XXX Test
+TEST EXPLANATION
+
+#### BRG Certificate Release Notes:
+1.3.0:
+ - FIRST VERSION
+
+
+```
+usage: wlt-cert-brg [-h] [-h] [-b BRG] [-b1 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]
+
+Gateway Certificate - CLI Tool to test Wiliot BRGs
+
+required arguments:
+  --gw, -g GW        Gateway ID
+  --port, -p PORT    COM Port
+  --brg, -b BRG      Bridge ID
+
+optional arguments:
+  --brg1, -b1 BRG1                              Second bridge id to run on tests two bridges needed
+  --data, -d {tags,sim}                         Choose if data generated from real tags or by simulation
+  --port, -p PORT                               Enable UT using UART connection for Gateway Simulation or Data Simulation
+  --clean                                       Clean all logs
+  --tl TL                                       Test list file to use
+  --run RUN                                     String to filter tests to run
+  --drun DRUN                                   String to filter tests not to run
+  --exit_on_test_failure                        Stop running the tests if a test failed
+  --exit_on_param_failure                       Sets exit_on_param_failure mode to true in order to prevent tests from continuing iteration over all possibilities in case of failure
+  --analyze_interference, -ai                   Analyze interference before tests start (relevant only for Gateway Simulator)
+  ```