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

gw_certificate/tests/static/uplink_defines.py

@@ -9,6 +9,6 @@ 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

@@ -15,7 +15,7 @@ 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, ACLRunData
-from gw_certificate.tests.generic import PassCriteria, PERFECT_SCORE, MINIMUM_SCORE, GenericTest, GenericStage, ERR_SUMMARY_DEFAULT
+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
@@ -108,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
@@ -205,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)
 
@@ -223,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):
@@ -374,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
@@ -568,9 +576,6 @@ 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 swap_endianness(hex_str: str) -> str:
-            return ''.join(format(b, '02X') for b in bytes.fromhex(hex_str)[::-1])
 
         def is_alias_bridge_id_valid(message): 
             nonlocal aliasBridgeId_valid
@@ -585,7 +590,7 @@ class AliasBridgeIDStage(GenericUplinkStage):
                         debug_print(f"validation_data unexpected len:{len(validation_data)}, for payload:{pkt_payload}")
                         return
                     expected_bridge_id = validation_data.iloc[0]['adva']
-                    expected_bridge_ids = [expected_bridge_id, swap_endianness(expected_bridge_id)]
+                    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
@@ -625,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):
@@ -672,7 +678,7 @@ class GeolocationStage(GenericUplinkStage):
 
 class ACLStage(GenericUplinkStage):
     def __init__(self, **kwargs):
-        self.stage_tooltip = "Tests the Access Control List capability of a gateway. Simulates packets from two bridges, with different ACL configurations"
+        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
@@ -712,7 +718,10 @@ class ACLStage(GenericUplinkStage):
             self.mqttc.send_payload(payload)
             time.sleep(5 if self.aggregation_time == 0 else self.aggregation_time)
             debug_print('Status message received from gw:')
-            debug_print(self.mqttc.get_status_message())
+            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()
@@ -759,18 +768,28 @@ class ACLStage(GenericUplinkStage):
         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_falsly = (self.comparison[SHOULD_RECEIVE].eq(False) & self.comparison[RECEIVED].eq(True)).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} / {num_pkts_should_received}")
+        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"False positives (failed to discard): {num_pkts_received_falsly}")
+        self.add_to_stage_report(f"Failed to discard: {num_pkts_failed_to_discard}\n")
 
-        if num_pkts_received_falsly > 0:
+        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"

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: wiliot_certificate
-Version: 1.5.3a1
+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