wiliot-certificate 1.5.2a1__py3-none-any.whl → 1.5.3a1__py3-none-any.whl

gw_certificate/common/wltPb_pb2.pyi

@@ -62,6 +62,28 @@ class UplinkMessage(_message.Message):
     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 ACL(_message.Message):
+    __slots__ = ("mode_allow", "ids")
+    MODE_ALLOW_FIELD_NUMBER: _ClassVar[int]
+    IDS_FIELD_NUMBER: _ClassVar[int]
+    mode_allow: bool
+    ids: _containers.RepeatedScalarFieldContainer[bytes]
+    def __init__(self, mode_allow: bool = ..., ids: _Optional[_Iterable[bytes]] = ...) -> None: ...
+
+class GatewayConfigValue(_message.Message):
+    __slots__ = ("integerValue", "numberValue", "stringValue", "boolValue", "aclValue")
+    INTEGERVALUE_FIELD_NUMBER: _ClassVar[int]
+    NUMBERVALUE_FIELD_NUMBER: _ClassVar[int]
+    STRINGVALUE_FIELD_NUMBER: _ClassVar[int]
+    BOOLVALUE_FIELD_NUMBER: _ClassVar[int]
+    ACLVALUE_FIELD_NUMBER: _ClassVar[int]
+    integerValue: int
+    numberValue: float
+    stringValue: str
+    boolValue: bool
+    aclValue: ACL
+    def __init__(self, integerValue: _Optional[int] = ..., numberValue: _Optional[float] = ..., stringValue: _Optional[str] = ..., boolValue: bool = ..., aclValue: _Optional[_Union[ACL, _Mapping]] = ...) -> None: ...
+
 class GatewayStatus(_message.Message):
     __slots__ = ("gatewayId", "gatewayType", "downlinkSupported", "bridgeOtaUpgradeSupported", "apiVersion", "version", "bleSwVersion", "interfaceSwVersion", "location", "config", "bleAddress")
     class ConfigEntry(_message.Message):
@@ -69,8 +91,8 @@ class GatewayStatus(_message.Message):
         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: ...
+        value: GatewayConfigValue
+        def __init__(self, key: _Optional[str] = ..., value: _Optional[_Union[GatewayConfigValue, _Mapping]] = ...) -> None: ...
     GATEWAYID_FIELD_NUMBER: _ClassVar[int]
     GATEWAYTYPE_FIELD_NUMBER: _ClassVar[int]
     DOWNLINKSUPPORTED_FIELD_NUMBER: _ClassVar[int]
@@ -91,9 +113,9 @@ class GatewayStatus(_message.Message):
     bleSwVersion: str
     interfaceSwVersion: str
     location: Location
-    config: _containers.MessageMap[str, Value]
+    config: _containers.MessageMap[str, GatewayConfigValue]
     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: ...
+    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, GatewayConfigValue]] = ..., bleAddress: _Optional[str] = ...) -> None: ...
 
 class GatewayInfo(_message.Message):
     __slots__ = ("entries",)
@@ -115,28 +137,32 @@ class GatewayLogs(_message.Message):
     def __init__(self, logs: _Optional[_Iterable[str]] = ...) -> None: ...
 
 class ActionStatus(_message.Message):
-    __slots__ = ("action", "status")
+    __slots__ = ("action", "status", "step", "progress", "bridgeId")
     ACTION_FIELD_NUMBER: _ClassVar[int]
     STATUS_FIELD_NUMBER: _ClassVar[int]
+    STEP_FIELD_NUMBER: _ClassVar[int]
+    PROGRESS_FIELD_NUMBER: _ClassVar[int]
+    BRIDGEID_FIELD_NUMBER: _ClassVar[int]
     action: int
     status: int
-    def __init__(self, action: _Optional[int] = ..., status: _Optional[int] = ...) -> None: ...
+    step: int
+    progress: int
+    bridgeId: bytes
+    def __init__(self, action: _Optional[int] = ..., status: _Optional[int] = ..., step: _Optional[int] = ..., progress: _Optional[int] = ..., bridgeId: _Optional[bytes] = ...) -> None: ...
 
 class DownlinkMessage(_message.Message):
-    __slots__ = ("txPacket", "gatewayAction", "bridgeUpgrade", "gatewayConfig", "customBroker", "customMessage")
+    __slots__ = ("txPacket", "gatewayAction", "bridgeUpgrade", "gatewayConfig", "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: ...
+    def __init__(self, txPacket: _Optional[_Union[TxPacket, _Mapping]] = ..., gatewayAction: _Optional[_Union[GatewayAction, _Mapping]] = ..., bridgeUpgrade: _Optional[_Union[BridgeUpgrade, _Mapping]] = ..., gatewayConfig: _Optional[_Union[GatewayConfig, _Mapping]] = ..., customMessage: _Optional[_Union[CustomMessage, _Mapping]] = ...) -> None: ...
 
 class TxPacket(_message.Message):
     __slots__ = ("payload", "maxRetries", "maxDurationMs")
@@ -179,8 +205,8 @@ class GatewayConfig(_message.Message):
         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: ...
+        value: GatewayConfigValue
+        def __init__(self, key: _Optional[str] = ..., value: _Optional[_Union[GatewayConfigValue, _Mapping]] = ...) -> None: ...
     VERSION_FIELD_NUMBER: _ClassVar[int]
     BLESWVERSION_FIELD_NUMBER: _ClassVar[int]
     INTERFACESWVERSION_FIELD_NUMBER: _ClassVar[int]
@@ -190,28 +216,8 @@ class GatewayConfig(_message.Message):
     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: ...
+    config: _containers.MessageMap[str, GatewayConfigValue]
+    def __init__(self, version: _Optional[str] = ..., bleSwVersion: _Optional[str] = ..., interfaceSwVersion: _Optional[str] = ..., location: _Optional[_Union[Location, _Mapping]] = ..., config: _Optional[_Mapping[str, GatewayConfigValue]] = ...) -> None: ...
 
 class CustomMessage(_message.Message):
     __slots__ = ("entries",)

gw_certificate/gw_certificate.py

@@ -18,8 +18,9 @@ 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.api_if.gw_capabilities import GWCapabilities, ConfigurationData
 from gw_certificate.tests import TESTS_NO_UART
+
 import gw_certificate.cert_results as cert_results
 
 GW_CERT_VERSION = importlib.metadata.version("wiliot-certificate")
@@ -58,6 +59,7 @@ class GWCertificate:
         self.result_pdf_path = os.path.join(self.certificate_dir, f'results_{self.current_datetime.strftime('%Y%m%d_%H%M%S')}.pdf')
         self.template_engine = TemplateEngine()
         self.env = env
+        self.error = ""
 
         # Version 
         self.gw_cert_version = GW_CERT_VERSION
@@ -71,7 +73,7 @@ class GWCertificate:
         self.stress_pps = stress_pps
         self.aggregation_time = aggregation_time
         self.actions = actions
-        self.error = ""
+        self.cfg_data = ConfigurationData()
         
         # UART-related. Require only when running tests that need it
         self.use_uart = not all(test in TESTS_NO_UART for test in tests)

gw_certificate/gw_certificate_cli.py

@@ -1,6 +1,6 @@
 
 import time
-from argparse import ArgumentParser
+from argparse import ArgumentParser, SUPPRESS
 
 from gw_certificate.common.debug import debug_print
 from gw_certificate.gw_certificate import GWCertificate, GW_CERT_VERSION
@@ -27,7 +27,7 @@ def filter_actions(actions_names):
 def main():
     usage = (
         "usage: wlt-gw-certificate [-h] -owner OWNER -gw GW\n"
-        f"                          [-tests {{connection, uplink, downlink, actions, stress}}] [-update] [-pps {STRESS_DEFAULT_PPS}]\n"
+        f"                          [-tests {{connection, uplink, downlink, actions, stress}}] [-noupdate] [-pps {STRESS_DEFAULT_PPS}]\n"
         f"                          [-actions {{info, reboot, bridgeota}}] [-agg AGG] [-env {{prod, test, dev}}]"
         )
 
@@ -44,13 +44,14 @@ def main():
                           default=['connection', 'uplink', 'downlink', 'actions', 'stress'])
     optional.add_argument('-actions', type=str, choices=['info', 'reboot', 'bridgeota'],
                           help="Action stages to run under ActionsTest", required=False, nargs='+', default=['info', 'reboot', 'bridgeota'])
-    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 RegistrationTest & BridgeOTAStage',
                           choices=['prod', 'test', 'dev'], default='prod', required=False)
+    optional.add_argument('-update', action='store_true', help=SUPPRESS, default=True, required=False)
+    optional.add_argument('-noupdate', action='store_true', help='Skip the default certification kit firmware update', default=False, required=False)
     args = parser.parse_args()
 
     topic_suffix = '' if args.suffix == '' else '-'+args.suffix
@@ -72,7 +73,7 @@ def main():
         parser.error("When running any test other than registration, the gateway must be registered to an owner which should be provided using the '-owner' flag.")
 
 
-    gwc = GWCertificate(gw_id=args.gw, owner_id=args.owner, topic_suffix=topic_suffix, tests=tests, update_fw=args.update,
+    gwc = GWCertificate(gw_id=args.gw, owner_id=args.owner, topic_suffix=topic_suffix, tests=tests, update_fw=(not args.noupdate),
                         stress_pps=args.pps, aggregation_time=args.agg, env=args.env, actions=actions)
     debug_print(f"All arguments: {vars(args)}")
     gwc.run_tests()

gw_certificate/interface/mqtt.py

@@ -346,7 +346,7 @@ class MqttClient:
                     return message.body_ex
         return None
         
-    def get_gw_configuration(self):
+    def get_gw_configuration_reboot(self):
         self.flush_messages()
         self.send_action(GwAction.REBOOT_GW)
         debug_print('---GW CONFIG---')
@@ -360,20 +360,29 @@ class MqttClient:
         if mqtt_mode == 'legacy':
             return self.send_action(GwAction.DISABLE_DEV_MODE)
         elif mqtt_mode == 'automatic':
-            custom_mqtt = {
-                "customBroker": False,
-                "brokerUrl": "",
-                "port": 8883,
-                "username": "",
-                "password": "",
-                "updateTopic": f"update/{self.owner_id}/{self.gw_id}",
-                "statusTopic": f"status/{self.owner_id}/{self.gw_id}",
-                "dataTopic": f"data/{self.owner_id}/{self.gw_id}"
-                }
             if self.get_serialization() in {Serialization.UNKNOWN, Serialization.JSON}:
+                custom_mqtt = {
+                    "customBroker": False,
+                    "brokerUrl": "",
+                    "port": 8883,
+                    "username": "",
+                    "password": "",
+                    "updateTopic": f"update/{self.owner_id}/{self.gw_id}",
+                    "statusTopic": f"status/{self.owner_id}/{self.gw_id}",
+                    "dataTopic": f"data/{self.owner_id}/{self.gw_id}"
+                    }
                 self.send_payload(custom_mqtt)
             if self.get_serialization() in {Serialization.UNKNOWN, Serialization.PB}:
-                self.send_payload({'customBroker': custom_mqtt})
+                custom_mqtt = wltPb_pb2.DownlinkMessage()
+                custom_mqtt.customMessage.entries['customBroker'].CopyFrom(wltPb_pb2.Value(boolValue=False))
+                custom_mqtt.customMessage.entries['brokerUrl'].CopyFrom(wltPb_pb2.Value(stringValue=""))
+                custom_mqtt.customMessage.entries['port'].CopyFrom(wltPb_pb2.Value(integerValue=8883))
+                custom_mqtt.customMessage.entries['username'].CopyFrom(wltPb_pb2.Value(stringValue=""))
+                custom_mqtt.customMessage.entries['password'].CopyFrom(wltPb_pb2.Value(stringValue=""))
+                custom_mqtt.customMessage.entries['updateTopic'].CopyFrom(wltPb_pb2.Value(stringValue=f"update/{self.owner_id}/{self.gw_id}"))
+                custom_mqtt.customMessage.entries['statusTopic'].CopyFrom(wltPb_pb2.Value(stringValue=f"status/{self.owner_id}/{self.gw_id}"))
+                custom_mqtt.customMessage.entries['dataTopic'].CopyFrom(wltPb_pb2.Value(stringValue=f"data/{self.owner_id}/{self.gw_id}"))
+                self.send_payload(custom_mqtt)
         elif mqtt_mode == 'manual':
             debug_print(f"Make sure GW {self.gw_id} is set to Wiliot MQTT broker")
             return True
@@ -383,6 +392,15 @@ class MqttClient:
         self.userdata = {'messages': WltMqttMessages(), 'gw_seen': False , 'logger': self.logger, 'serialization':self.get_serialization(), 'published':[]}
         self.client.user_data_set(self.userdata)
     
+    def flush_messages_topic(self, topic:Literal['status', 'data', 'update']):
+        if topic == 'data':
+            self.userdata['messages'].data = []
+        elif topic == 'status':
+            self.userdata['messages'].status = []
+        elif topic == 'update':
+            self.userdata['messages'].update = []
+            
+    
     def get_all_messages_from_topic(self, topic:Literal['status', 'data', 'update']):
         return getattr(self.userdata['messages'], topic)
     
@@ -406,19 +424,21 @@ class MqttClient:
                 elif GATEWAYSTATUS in message.body_ex.keys():
                     return message.body_ex[GATEWAYSTATUS]
         return None
-
+    
     def get_action_status_message(self):
+        # Implemented with a list since we can't expect when the GW will publish a msg. To avoid flushing it.
         messages = self.get_all_messages_from_topic('status')
+        action_status_msgs = []
         for message in messages:
             if GW_LOGS not in message.body_ex.keys():
                 if STATUS_CODE_STR in message.body_ex.keys():
-                    return message.body_ex
+                    action_status_msgs.append(message.body_ex)
                 elif ACTIONSTATUS in message.body_ex.keys():
-                    if 'status' not in message.body_ex[ACTIONSTATUS].keys():
-                        # Default values are omitted in protobuf, set 0 for explicitness
-                        message.body_ex[ACTIONSTATUS]['status'] = 0
-                    return message.body_ex[ACTIONSTATUS]
-        return None
+                    message.body_ex[ACTIONSTATUS].setdefault('status', 0)
+                    action_status_msgs.append(message.body_ex[ACTIONSTATUS])
+        if len(action_status_msgs) == 0:
+            return None
+        return action_status_msgs[-1]
     
     def get_coupled_tags_pkts(self):
         return [p for p in self.get_all_pkts_from_topic('data') if NFPKT in p]
@@ -517,9 +537,6 @@ def on_message_protobuf(mqttc, userdata, message):
         try:
             pb_message = wltPb_pb2.GatewayData()
             pb_message.ParseFromString(message.payload)
-            # # Decode packets payloads as hex
-            # for idx, packet in enumerate(pb_message.packets):
-            #     pb_message.packets[idx].payload = packet.payload.hex().upper().encode('utf-8')
         except DecodeError as e: 
             userdata['logger'].debug(f'{message.topic}: An exception occured:\n{e}\n(could be a JSON msg or pb msg that is not UplinkMessage)###########')
             userdata['logger'].debug(f'Raw Payload: {message.payload}')
@@ -528,7 +545,6 @@ def on_message_protobuf(mqttc, userdata, message):
         userdata['logger'].debug(f'{message.topic}: {message.payload}')
     if pb_message is not None:
         pb_message_dict = MessageToDict(pb_message)
-        # Decode b64 packet payloads to hex
         if 'data' in message.topic and 'packets' in pb_message_dict.keys():
             for idx, packet in enumerate(pb_message_dict['packets']):
                 pb_message_dict['packets'][idx]['payload'] = base64.b64decode(packet['payload']).hex().upper()

gw_certificate/interface/pkt_generator.py

@@ -185,15 +185,6 @@ class TagPktGenerator:
         assert len(pkt) == 62, "packet must be 74 / 62 hex chars long!"
         self.data_packet.set(pkt)
     
-    def get_expected_mqtt(self):
-        timestamp = int(datetime.datetime.now().timestamp() * 1000)
-        expected = {
-            TIMESTAMP: timestamp,
-            PAYLOAD: self.get_packet()[ADVA_LENGTH+GAP_LENGTH:]
-        }
-        return expected
-
-
 
 class BrgPktGenerator:
     """Bridge Packet Generator - represents 1 wiliot Bridge"""
@@ -451,41 +442,6 @@ class BrgPktGenerator:
         }
         return [expected_data, expected_si]
 
-    def get_expected_mqtt_unified(self, full_data_pkt, tag_idx:int=None):
-        if tag_idx is None:
-            tag_idx = 0
-        assert tag_idx <= len(self.tag_list), f'Tag index must be in {[i for i in range(len(self.tag_list))]}'
-
-        def extract_param_from_pkt():
-            # Take only the relevant digis from the data packet
-            param_hex_string = full_data_pkt[46:-22]
-            if len(param_hex_string) != 6:
-                raise ValueError("The parameters hex representation must be 6 digits long")
-            
-            # Convert to decimal from binari and assign
-            param_binari_string = bin(int(param_hex_string, 16))[2:].zfill(24)
-            nfpkt = int(param_binari_string[:8], 2)
-            rssi = int(param_binari_string[8:14], 2)
-            # Note: rssi here is -40 then the actual value. This portion is to be added on cloud
-            brg_latency = int(param_binari_string[14:20], 2)
-            brg_global_pacing_group = int(param_binari_string[20:], 2)
-            return [nfpkt, rssi, brg_latency, brg_global_pacing_group]
-
-        """generates expected MQTT packet"""
-        timestamp = int(datetime.datetime.now().timestamp() * 1000)
-        pkt_param = extract_param_from_pkt()
-
-        expected_data = {
-            TIMESTAMP: timestamp,
-            BRIDGE_ID: self.bridge_id,
-            NFPKT: pkt_param[0],
-            RSSI: pkt_param[1],
-            BRG_LATENCY: pkt_param[2],
-            BRG_GLOBAL_PACING_GROUP: pkt_param[3],
-            PAYLOAD: full_data_pkt[(ADVA_LENGTH+GAP_LENGTH):]
-        }
-        return [expected_data]
-
     def get_expected_hb_mqtt(self):
         timestamp = int(datetime.datetime.now().timestamp() * 1000)
         expected = {

gw_certificate/interface/uart_if.py

@@ -12,7 +12,7 @@ import pkg_resources
 from gw_certificate.common.debug import debug_print
 from gw_certificate.interface.if_defines import *
 
-LATEST_VERSION = '4.4.52'
+LATEST_VERSION = '4.4.82'
 LATEST_VERSION_FILE = f'{LATEST_VERSION}_sd_bl_app.zip'
 LATEST_VERSION_PATH = pkg_resources.resource_filename(__name__, LATEST_VERSION_FILE)
 LATEST_VERSION_FILE_APP = f'{LATEST_VERSION}_app.zip'
@@ -43,7 +43,8 @@ class UARTInterface:
             if not update_status:
                 raise UARTError('Update Failed! Update FW manually using NRF Tools')
             if self.fw_version >= version.Version('3.17.0'):
-                self.write_ble_command(GATEWAY_APP)
+                if self.fw_version < version.Version('4.4.0'):
+                    self.write_ble_command(GATEWAY_APP)
                 self.flush()
         debug_print(f'Serial Connection {comport} Initialized')
 
@@ -79,14 +80,16 @@ class UARTInterface:
             debug_print(answer)
         return answer
     
-    def flush(self):
+    def flush(self, request_power_cycle=False):
         self.serial.close()
+        if request_power_cycle:
+            input('Please power cycle (unplug and replug from your pc) the certificate kit. Press enter when plugged')
         time.sleep(2)
         self.serial.open()
         self.serial.flushInput()
         self.serial.flush()
         self.serial.reset_output_buffer()
-
+    
     def reset_gw(self, stop_advertising=True):
         self.flush()
         self.write_ble_command(RESET_GW)
@@ -104,16 +107,20 @@ class UARTInterface:
         if self.gw_app_rx is None:
             self.reset_gw()
 
-        if self.fw_version >= version.Version('3.17.0'):
+        if self.fw_version >= version.Version('4.4.0'):
+            # full_cfg isn't supported anymore. RX channels are configured by set_sniffer.
+            pass
+        elif self.fw_version >= version.Version('3.17.0'):
             # from 3.17.0, only full_cfg can be used to configure channels. sending it with:
             # Data coupling(DC) off, wifi(NW) and mqtt(MQ) on.
             rx_ch_to_fw_enums = {37: 2, 38: 3, 39: 4}
             cmd = f'!full_cfg DM {rx_ch_to_fw_enums[rx_channel]} DC 0 NW 1 MQ 1 CH {rx_channel}'
             # cmd = '!gateway_app'
+            self.write_ble_command(cmd)
         else:
             cmd = f'!gateway_app {rx_channel} 30 0 17'
+            self.write_ble_command(cmd)
 
-        self.write_ble_command(cmd)
         self.gw_app_rx = rx_channel
 
     def set_sniffer(self, rx_channel):
@@ -128,7 +135,11 @@ class UARTInterface:
         time.sleep(1)
 
     def cancel_sniffer(self):
-        self.write_ble_command(CANCEL_SNIFFER)
+        if self.fw_version >= version.Version('4.4.0'):
+            # Set_logger_mode must have 2 args, even when disabled.
+            self.write_ble_command(f'{CANCEL_SNIFFER} 37')
+        else:
+            self.write_ble_command(CANCEL_SNIFFER)
         self.flush()
 
     def get_version_mac(self):
@@ -197,8 +208,8 @@ class UARTInterface:
         return_code = dfu_full_process.returncode
         for line in dfu_full_process.stderr:
             if NRFUTIL_FW_TOO_LOW_ERROR in line:
-                debug_print(f"DFU failed due to firmware (bootloader/application) version being too low.")
-                debug_print(f"Probably since bootloader is already upgraded. Attempting to upgrade application only..")
+                debug_print(f"DFU failed because bootloader/application version is too high.")
+                debug_print(f"Attempting to upgrade application only..")
                 dfu_app_process = subprocess.Popen(f'{nrfutil_file} dfu serial --package "{LATEST_VERSION_PATH_APP}" -p {self.comport} -fc 0 -b 115200 -t 10',
                                     stderr=subprocess.PIPE, shell=True, text=True)
                 dfu_app_process.wait()

gw_certificate/tests/actions.py

@@ -131,7 +131,7 @@ class BridgeOTAStage(GenericActionsStage):
         self.error_summary = "Bridge wasn't upgraded."
         self.action = "Bridge Upgrade"
 
-        OTA_VERSIONS_TO_USE = ("4.4.52", "4.4.53")
+        OTA_VERSIONS_TO_USE = ("4.4.82", "4.4.83")
         if version.parse(OTA_VERSIONS_TO_USE[0]) != self.uart.fw_version:
             self.desired_version = version.parse(OTA_VERSIONS_TO_USE[0])
         else:
@@ -144,6 +144,28 @@ class BridgeOTAStage(GenericActionsStage):
         debug_print(f"BridgeOTAStage attempt: {str(self.uart.fw_version)} -> {str(self.desired_version)}")
         # Reset to remove any log/cert mode we had in the kit so it behaves as a bridge
         self.uart.reset_gw()
+    
+    def is_final_action_status(self, msg):
+        LAST_OTA_STEP = 7
+        if not isinstance(msg, dict):
+            return False
+
+        step = msg.get('step')
+        progress = msg.get('progress')
+        status = msg.get('statusCode')
+        if status == None:
+            # Both json/pb
+            status = msg.get('status')
+
+        if step == None:
+            # Old action status
+            if status != None:
+                return True
+        else:
+            # New progress action status
+            if (step == LAST_OTA_STEP and progress == 100) or (status != 0):
+                return True
+        return False
 
     def run(self):
         super().run()
@@ -156,15 +178,21 @@ class BridgeOTAStage(GenericActionsStage):
         self.mqttc.send_bridge_ota_action(self.uart.mac, str(self.desired_version), 200, False, self.gw_id, "aws", self.env)
         debug_print("Sent a BridgeOTA action to the gateway")
         debug_print("Waiting for an actionStatus message from the gateway... (timeout=10)")
+
         while datetime.datetime.now() < timeout and self.action_status is None:
             line = self.uart.read_line()
             if line != None and 'reset' in line:
-                self.uart.reset_gw(stop_advertising=False)
                 self.reboot_packet_ts = datetime.datetime.now()
                 debug_print("A reboot packet was received by the bridge")
-            self.action_status = self.mqttc.get_action_status_message()
+                self.uart.reset_gw(stop_advertising=False)
+
+            # Ignoring progress report until test supported
+            msg = self.mqttc.get_action_status_message()
+            if self.is_final_action_status(msg):
+                self.action_status = msg
             time.sleep(2)
         
+        debug_print(f'{self.action_status}')
         if self.action_status != None:
             debug_print("actionStatus was received from the gateway")
             self.action_status_ts = datetime.datetime.now()
@@ -181,8 +209,8 @@ class BridgeOTAStage(GenericActionsStage):
 
         cur_ver = self.uart.get_version()
         if cur_ver == None:
-            debug_print("ERROR: The certificate kit, acting as bridge in this stage, is not responding!")
-            self.uart.flush()
+            debug_print("ERROR: The certificate kit, acting as bridge in this stage, is not responding.")
+            self.uart.flush(request_power_cycle=True)
             cur_ver = self.uart.get_version()
             if cur_ver == None:
                 raise UARTError("Communication to the certificate kit halted! "

gw_certificate/tests/connection.py

@@ -35,6 +35,7 @@ class ConnectionStage(GenericStage):
         self.status_message = None
 
         while datetime.datetime.now() < timeout and self.status_message is None:
+            time.sleep(2)
             self.status_message = self.mqttc.get_status_message()
 
         if self.status_message is not None:
@@ -49,6 +50,7 @@ class ConnectionStage(GenericStage):
             for key, value in self.status_message.items():
                 if key in GWCapabilities.get_capabilities() and type(value) is bool:
                     self.gw_capabilities.set_capability(key, value)
+            self.cfg_data.status_msg_set(self.status_message, self.mqttc.get_serialization())
 
     def generate_stage_report(self):
         self.add_report_header()
@@ -73,7 +75,7 @@ class ConnectionStage(GenericStage):
 
             self.add_report_topic_validation('status')
         else:
-            self.error_summary = "No message recieved from GW in status topic after 3 mins."
+            self.error_summary = f"No message recieved from GW in status topic after {STATUS_MSG_TIMEOUT} mins."
             self.add_to_stage_report(self.error_summary)
 
         self.report_html = self.template_engine.render_template('stage.html', stage=self,

gw_certificate/tests/generic.py

@@ -161,7 +161,7 @@ class GenericStage():
         self.result_indication = kwargs.get('result_indication', SCORE_BASED)
         self.stage_pass = MINIMUM_SCORE
         self.pass_min = kwargs.get('pass_min', PASS_MINIMUM)
-        self.inconclusive_min = INCONCLUSIVE_MINIMUM
+        self.inconclusive_min = kwargs.get('inconclusive_min', INCONCLUSIVE_MINIMUM)
         self.report = ''
         self.report_html = ''
         self.start_time = None

gw_certificate/tests/registration.py

@@ -41,7 +41,7 @@ class Status(Enum):
     APPROVED = 'approved'
     ACTIVE = 'active'
 
-class SharedData():
+class RegistrationData():
     """
     Hold variables which values must be shared between different stages.
     gw_online_ts hold the time in which the gateway status became online
@@ -205,7 +205,7 @@ class OnlineStage(GenericRegistrationStage):
             self.add_to_stage_report("Token acquisition and MQTT connection were done succesfully.")
             self.add_to_stage_report("Gateway is online.")
             debug_print("Gateway connected to MQTT successfully, it is online")
-            self.shared_data.gw_online_ts = datetime.datetime.now()
+            self.reg_data.gw_online_ts = datetime.datetime.now()
 
         self.report_html = self.template_engine.render_template('stage.html', stage=self,
                                                                 stage_report=self.report.split('\n'))
@@ -259,7 +259,7 @@ class RefreshStage(GenericRegistrationStage):
     def run(self):
         super().run()
         debug_print(f"Waiting for the token to expire..")
-        timeout = self.shared_data.gw_online_ts + datetime.timedelta(minutes=TOKEN_EXPIRY_MINUTES)
+        timeout = self.reg_data.gw_online_ts + datetime.timedelta(minutes=TOKEN_EXPIRY_MINUTES)
         while datetime.datetime.now() < timeout:
             time.sleep(BUSY_WAIT_DELAY_SEC)
 
@@ -313,7 +313,7 @@ class RegistrationTest(GenericTest):
             raise Exception(f"An API security key must be set to the envrionment variable {self.env_variable} in order to run the RegistrationTest")
         self.edge = ExtendedEdgeClient(api_sec_key, REG_CERT_OWNER_ID, env=self.env)
 
-        self.shared_data = SharedData()
+        self.reg_data = RegistrationData()
 
         super().__init__(**self.__dict__, test_name=type(self).__name__)
         stages = STAGES