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

brg_certificate/ag/wlt_types_ag.py

@@ -7433,21 +7433,21 @@ class ModuleExtSensorsV7():
         self.unused2 = d[14]
 
 class ModuleCustomV12():
-    def __init__(self, raw='', module_type=MODULE_CUSTOM, msg_type=BRG_MGMT_MSG_TYPE_CFG_SET, api_version=API_VERSION_V12, seq_id=0, brg_mac=0, state_threshold=LIS2DW12_DEFAULTS_STATE_THRESHOLD, wake_up_duration=LIS2DW12_DEFAULTS_WAKE_UP_DURATION, sleep_duration=LIS2DW12_DEFAULTS_SLEEP_DURATION, unused1=0):
+    def __init__(self, raw='', module_type=MODULE_CUSTOM, msg_type=BRG_MGMT_MSG_TYPE_CFG_SET, api_version=API_VERSION_V12, seq_id=0, brg_mac=0, motion_sensitivity_threshold=LIS2DW12_DEFAULTS_STATE_THRESHOLD, s2d_transition_time=LIS2DW12_DEFAULTS_WAKE_UP_DURATION, d2s_transition_time=LIS2DW12_DEFAULTS_SLEEP_DURATION, unused1=0):
         self.module_type = module_type
         self.msg_type = msg_type
         self.api_version = api_version
         self.seq_id = seq_id
         self.brg_mac = brg_mac
-        self.state_threshold = state_threshold # 31 [mg] resolution
-        self.wake_up_duration = wake_up_duration # 3 [sec] resolution
-        self.sleep_duration = sleep_duration # 5 [sec] resolution
+        self.motion_sensitivity_threshold = motion_sensitivity_threshold # 31 [mg] resolution
+        self.s2d_transition_time = s2d_transition_time # 3 [sec] resolution
+        self.d2s_transition_time = d2s_transition_time # 5 [sec] resolution
         self.unused1 = unused1
         if raw:
             self.set(raw)
 
     def __repr__(self) -> str:
-        return "\n==> Packet module_custom_v12 <==\n" + tabulate.tabulate([['module_type', f"0x{self.module_type:X} ({self.module_type})"],['msg_type', f"0x{self.msg_type:X} ({self.msg_type})"],['api_version', f"0x{self.api_version:X} ({self.api_version})"],['seq_id', f"0x{self.seq_id:X} ({self.seq_id})"],['brg_mac', f"0x{self.brg_mac:X} ({self.brg_mac})"],['state_threshold', f"0x{self.state_threshold:X} ({self.state_threshold})"],['wake_up_duration', f"0x{self.wake_up_duration:X} ({self.wake_up_duration})"],['sleep_duration', f"0x{self.sleep_duration:X} ({self.sleep_duration})"]], tablefmt="texttable")
+        return "\n==> Packet module_custom_v12 <==\n" + tabulate.tabulate([['module_type', f"0x{self.module_type:X} ({self.module_type})"],['msg_type', f"0x{self.msg_type:X} ({self.msg_type})"],['api_version', f"0x{self.api_version:X} ({self.api_version})"],['seq_id', f"0x{self.seq_id:X} ({self.seq_id})"],['brg_mac', f"0x{self.brg_mac:X} ({self.brg_mac})"],['motion_sensitivity_threshold', f"0x{self.motion_sensitivity_threshold:X} ({self.motion_sensitivity_threshold})"],['s2d_transition_time', f"0x{self.s2d_transition_time:X} ({self.s2d_transition_time})"],['d2s_transition_time', f"0x{self.d2s_transition_time:X} ({self.d2s_transition_time})"]], tablefmt="texttable")
 
     def __eq__(self, other):
         if other and set(other.__dict__.keys()) == set(self.__dict__.keys()):
@@ -7456,14 +7456,14 @@ class ModuleCustomV12():
                 self.msg_type == other.msg_type and
                 self.api_version == other.api_version and
                 self.brg_mac == other.brg_mac and
-                self.state_threshold == other.state_threshold and
-                self.wake_up_duration == other.wake_up_duration and
-                self.sleep_duration == other.sleep_duration
+                self.motion_sensitivity_threshold == other.motion_sensitivity_threshold and
+                self.s2d_transition_time == other.s2d_transition_time and
+                self.d2s_transition_time == other.d2s_transition_time
             )
         return False
 
     def dump(self):
-        string = bitstruct.pack("u4u4u8u8u48u8u8u8u96", self.module_type, self.msg_type, self.api_version, self.seq_id, self.brg_mac, ((self.state_threshold-0)//31), ((self.wake_up_duration-0)//3), ((self.sleep_duration-0)//5), self.unused1)
+        string = bitstruct.pack("u4u4u8u8u48u8u8u8u96", self.module_type, self.msg_type, self.api_version, self.seq_id, self.brg_mac, ((self.motion_sensitivity_threshold-0)//31), ((self.s2d_transition_time-0)//3), ((self.d2s_transition_time-0)//5), self.unused1)
         return string.hex().upper()
 
     def set(self, string):
@@ -7473,9 +7473,9 @@ class ModuleCustomV12():
         self.api_version = d[2]
         self.seq_id = d[3]
         self.brg_mac = d[4]
-        self.state_threshold = ((d[5]*31)+0)
-        self.wake_up_duration = ((d[6]*3)+0)
-        self.sleep_duration = ((d[7]*5)+0)
+        self.motion_sensitivity_threshold = ((d[5]*31)+0)
+        self.s2d_transition_time = ((d[6]*3)+0)
+        self.d2s_transition_time = ((d[7]*5)+0)
         self.unused1 = d[8]
 
 class ModuleCustomV11():

brg_certificate/brg_certificate.py

@@ -3,7 +3,7 @@
 import sys
 import os
 sys.path.insert(0, os.path.abspath(".."))
-import argparse
+import webbrowser
 import glob
 import datetime
 import tabulate
@@ -156,7 +156,7 @@ def main(args):
             test.update_overall_rc()
         if test.rc == TEST_FAILED:
             failures += 1
-            if "versions_test" in test.module_name and "EXITING UT" in test.reason:
+            if "versions_test" in test.module_name and f"EXITING CERTIFICATE" in test.reason:
                 exit_on_test_failure = True
         print(f"Test Duration: {test.duration}")
         print(tabulate.tabulate([[i+1, i+1-(failures+skipped), skipped, failures, len(tests)]],
@@ -177,12 +177,15 @@ def main(args):
     print(tabulate.tabulate([[i+1, i+1-(failures+skipped), skipped, failures, len(tests)]],
                             headers=["FINISHED", "PASSED", "SKIPPED", "FAILED", "TOTAL"], tablefmt="pretty"))
 
-    print(WIL_UT_TEXT)
+    print(WIL_CERT_TEXT)
     print_warn(get_important_tests_info())
-    print_pass_or_fail(not failures, "Wiliot UT")
+    print_pass_or_fail(not failures, f"Wiliot Certificate")
 
-    cert_results.generate_results_files(html=True, pdf=True, failures=failures, skipped=skipped, duration=duration, brg_version=brg_version,
-                                  tests=tests, pipeline=cert_common.pipeline_running())
+    pipeline = cert_common.pipeline_running()
+    cert_results.generate_results_files(html=True, pdf=True, failures=failures, skipped=skipped, start_time=start_time, duration=duration, brg_version=brg_version,
+                                        brg=args.brg, gw_ble_version = gw_version[BLE_VERSION], gw_ble_mac = internal_brg.id_str, tests=tests, pipeline=pipeline)
+    if not pipeline:
+        webbrowser.open('file://' + os.path.realpath(os.path.join(BASE_DIR, UT_RESULT_FILE_PDF)))
 
     if failures:
         sys.exit(-1)

brg_certificate/cert_common.py

@@ -13,7 +13,7 @@ import math, random
 DEFAULT_HDR = ag.Hdr(group_id=ag.GROUP_ID_GW2BRG)
 
 # Returns a 12 chars long hex string
-int2mac_get = lambda int_val: "{:012X}".format(int_val)
+int2mac_get = lambda int_val: f"{int_val:012X}"
 
 def name_to_val(name):
     return globals()[name]
@@ -35,8 +35,8 @@ def test_prolog(test):
     test.mqttc.flush_pkts()
 
     #TODO - remove/check status later on in the test
-    test.set_phase_rc(PROLOG, rc=test.rc) 
-    test.add_phase_reason(PROLOG, reason=test.reason)
+    test.set_phase_rc(PRE_CONFIG, rc=test.rc) 
+    test.add_phase_reason(PRE_CONFIG, reason=test.reason)
     #
 
     return test
@@ -59,37 +59,37 @@ def test_epilog(test, revert_brgs=False, revert_gws=False, modules=[], brg1_modu
         test.add_phase_reason(TEST_BODY, test.reason)
 
     test.reset_result()
-    test.set_phase_rc(EPILOG, TEST_PASSED)
+    test.set_phase_rc(RESTORE_CONFIG, TEST_PASSED)
 
     if revert_brgs:
         res2 = DONE
         test, res = cert_config.config_brg_defaults(test, modules=modules, ble5=ble5)
         # TODO - REMOVE when rc is re-designed
-        test.set_phase_rc(EPILOG, test.rc)
+        test.set_phase_rc(RESTORE_CONFIG, test.rc)
         test.reset_result()
         #
         if test.brg1 and test.multi_brg:
             brg1_modules = modules if not brg1_modules else brg1_modules
             test, res2 = cert_config.config_brg1_defaults(test, modules=brg1_modules)
             # TODO - REMOVE when rc is re-designed
-            test.set_phase_rc(EPILOG, test.rc)
+            test.set_phase_rc(RESTORE_CONFIG, test.rc)
             test.reset_result()
             #
         if res == NO_RESPONSE or res2 == NO_RESPONSE:
             txt = "Failed: Revert BRGs to defaults"
             utPrint(txt, "RED")
-            test.add_phase_reason(EPILOG, txt)
+            test.add_phase_reason(RESTORE_CONFIG, txt)
 
     if revert_gws:
         test, res = cert_config.config_gw_defaults(test)
         # TODO - REMOVE when rc is re-designed
-        test.set_phase_rc(EPILOG, test.rc)
+        test.set_phase_rc(RESTORE_CONFIG, test.rc)
         test.reset_result()
         #
         if res == NO_RESPONSE:
             txt = "Failed: Revert GW to defaults"
             utPrint(txt, "RED")
-            test.add_phase_reason(EPILOG, txt)
+            test.add_phase_reason(RESTORE_CONFIG, txt)
 
     test.mqttc.flush_pkts()
     test.end_time = datetime.datetime.now()
@@ -101,7 +101,7 @@ def test_epilog(test, revert_brgs=False, revert_gws=False, modules=[], brg1_modu
         and test.get_phase_rc(TEST_BODY) == TEST_FAILED):
         print("Setting rc to TEST_PASSED for pipeline after BRG OTA succeeded")
         test.set_phase_rc(TEST_BODY, TEST_PASSED)
-        test.set_phase_rc(EPILOG, TEST_PASSED)
+        test.set_phase_rc(RESTORE_CONFIG, TEST_PASSED)
 
     test_epilog_print(test)
     return test
@@ -259,7 +259,11 @@ time_in_sec = lambda t : t.seconds + t.microseconds / 1000000
 
 def get_all_brg_pkts(test):
     utPrint(f"Collecting all BRG pkts", "BLUE")
-    return cert_mqtt.get_unified_data_pkts(test)
+    return cert_mqtt.get_unified_data_pkts(test, only_active_brg=True)
+
+def get_all_brgs_pkts(test):
+    utPrint(f"Collecting all BRG pkts", "BLUE")
+    return cert_mqtt.get_unified_data_pkts(test, only_active_brg=False)
 
 def get_pkts_data_frame(test, gw_data=False, brg_data=False, per_pkt_type=False):
     pkts = []
@@ -591,7 +595,7 @@ def display_data(df, csv=True, nfpkt=False, pkt_cntr_diff=False, cer_per_tag=Fal
             f.write(g.to_html(full_html=False, include_plotlyjs='cdn', include_mathjax='cdn'))
             f.write("<br>")
     if csv:
-        df.to_csv(os.path.join(dir, f"{name_prefix}all_data.csv"), index=False)
+        df.to_csv(os.path.join(BASE_DIR, dir, f"{name_prefix}all_data.csv"), index=False)
 
     return ttfp_graph
 
@@ -599,7 +603,11 @@ def single_log_search(test, s, found, fail_on_find=False, print_logs=True, addit
     res = False
     for p in test.mqttc._userdata[PKTS].status:
         if GW_LOGS in p.body:
-            logs = p.body[GW_LOGS][LOGS] if test.protobuf else p.body[GW_LOGS]
+            if test.protobuf and p.body[GW_LOGS]:
+                # handle protobuf structure (when GW_LOGS is not empty)
+                logs = p.body[GW_LOGS][LOGS]
+            else:
+                logs = p.body[GW_LOGS]
             for log in logs:
                 if any([s in log]) and any([additional_log in log]) and (log not in found):
                     print(f"Log: {log}, Additional Log: {additional_log}")

brg_certificate/cert_config.py

@@ -87,7 +87,7 @@ def create_gw_downlink_pkt(test, raw_tx_data="", is_ota=False, version="", max_d
 
 def get_default_gw_dict(test=None):
     return dict({WLT_SERVER: test.server if test else PROD, GW_MODE: BLE_WIFI, USE_STAT_LOC: False,
-                 SERIALIZATION_FORMAT: PROTOBUF})
+                 SERIALIZATION_FORMAT: PROTOBUF, ACL:dict({ACL_MODE: ACL_DENY , ACL_BRIDGE_IDS:[]})})
 
 def config_gw_defaults(test, version=""):
     utPrint(f"Configuring gateway {test.gw} to defaults", "BLUE")

brg_certificate/cert_defines.py

@@ -1,7 +1,13 @@
 # Files
 import os
+import importlib.metadata
 # BASE_DIR should be initiated in the same dir as brg_certificate.py
 BASE_DIR = os.path.dirname(os.path.abspath(__file__))
+# CERT_VERSION handling - local/PyPi
+if "wiliot-certificate" in importlib.metadata.packages_distributions():
+    CERT_VERSION = importlib.metadata.version("wiliot-certificate")
+else:
+    CERT_VERSION = "local-dev"
 CERT_MQTT_LOG_FILE =            "cert_mqtt_log.json"
 DATA_SIM_LOG_FILE =             "data_sim_log.txt"
 UT_RESULT_FILE_HTML =           "results.html"
@@ -60,6 +66,15 @@ PROD =                          "prod"
 SERIALIZATION_FORMAT =          "serializationFormat"
 PROTOBUF =                      "Protobuf"
 JSON =                          "JSON"
+ACL =                           "accessControlList"
+ACL_MODE =                      "mode"
+ACL_MODE_ALLOW =                "mode_allow"
+ACL_BRIDGE_IDS =                "bridgeIds"
+ACL_IDS =                       "ids"
+ACL_DENY =                      "deny"
+ACL_ALLOW =                     "allow"
+ACL_DENY_VALUE =                 0
+ACL_ALLOW_VALUE =                1
 
 GET_INFO_ACTION =               "getGwInfo"
 REBOOT_GW_ACTION =              "rebootGw"
@@ -81,6 +96,7 @@ TRANPARENT_PKT_LEN =            31 * 2
 
 # Simulator defines
 GW_SIM_BLE_MAC_ADDRESS =       'GW_SIM_BLE_MAC_ADDRESS'
+GW_APP_VERSION_HEADER =        'WILIOT_GW_BLE_CHIP_SW_VER'
 GW_SIM_PREFIX =                'SIM'
 DATA_SIMULATION =              'sim'
 DATA_REAL_TAGS =               'tags'
@@ -135,6 +151,8 @@ NUM_VAL =                       "numberValue"
 GW_STATUS =                     "gatewayStatus"
 BRG_UPGRADE =                   "bridgeUpgrade"
 REBOOT_PKT =                    "rebootPacket"
+CONFIG =                        "config"
+ACL_VALUE =                     "aclValue"
 
 # Custom broker
 CUSTOM_BROKER_ENABLE       = "customBroker"
@@ -197,6 +215,7 @@ GW_LONGITUDE_DEFAULT =              -117.0839
 # Set to work with default when versions tests only pass through new api ver
 GW_API_VER_DEFAULT =                "201"
 GW_API_VER_OLD =                    "200"
+GW_API_VER_LATEST =                 "205"
 BRG_CFG_HAS_LEN =                   2
 CLEAR_DATA_PATH_TIMEOUT =           10
 ACTION_LONG_TIMEOUT =               120
@@ -216,7 +235,6 @@ TEST_SKIPPED =                                      1
 TEST_INIT =                                         2
 NO_RESPONSE =                                       "NO_RESPONSE"
 DONE =                                              "DONE"
-TEST_SUCCESS =                                      ":)"
 MGMT_PKT =                                          "mgmt_pkt"
 UNIFIED_PKT =                                       "unified_pkt"
 SIDE_INFO_SENSOR_PKT =                              "side_info_sensor_pkt"
@@ -240,9 +258,9 @@ TEST =                                              "test"
 MULTI_BRG_TEST =                                    "multiBridgeTest" # used for multi brg tests
 GW_ONLY_TEST =                                      "gwOnlyTest" # used for gw only tests
 ALL_SUPPORTED_VALUES =                              "allSupportedValues"
-PROLOG =                                            "Prolog"
+PRE_CONFIG =                                        "Pre config"
 TEST_BODY =                                         "Test Body"
-EPILOG =                                            "Epilog"
+RESTORE_CONFIG =                                    "Restore config"
 
 # test reasons
 NO_PARAMS_GIVEN =           "No parameters given!"

brg_certificate/cert_gw_sim.py

@@ -13,7 +13,6 @@ import brg_certificate.cert_utils as cert_utils
 
 # Generic Defines
 SERIAL_TIMEOUT =                                    0.1 # TODO decide about the right value
-GW_APP_VERSION_HEADER =                             'WILIOT_GW_BLE_CHIP_SW_VER'
 STOP_ADVERTISING =                                  '!stop_advertising'
 RESET_GW =                                          '!reset'
 DEDUPLICATION_PKTS =                                '!deduplication_pkts'
@@ -82,12 +81,13 @@ def prep_gw(args, mqttc, start_time):
     gw = args.gw
     protobuf = False
     internal_brg_mac_addr = os.getenv(GW_SIM_BLE_MAC_ADDRESS)
+    internal_brg_ble_ver = os.getenv(GW_APP_VERSION_HEADER)
     if not internal_brg_mac_addr:
         cert_utils.handle_error(f"ERROR: Didn't receive {GW_SIM_BLE_MAC_ADDRESS} response!", start_time)
     internal_brg = cert_utils.ut_prep_brg(args, mqttc, start_time, gw, internal_brg_mac_addr, "prod", protobuf)
     if internal_brg.api_version != ag.API_VERSION_LATEST:
         cert_utils.handle_error(f"ERROR: Certificate FW api_version={internal_brg.api_version} instead of api_version={ag.API_VERSION_LATEST}! Please upgrade the FW!", start_time)
-    return gw, internal_brg, "prod", {BLE_VERSION:"0.0.0", WIFI_VERSION:"0.0.0"}, protobuf
+    return gw, internal_brg, "prod", {BLE_VERSION:internal_brg_ble_ver, WIFI_VERSION:"0.0.0"}, protobuf
 
 ##############################################
 # UART FUNCTIONS
@@ -113,9 +113,10 @@ def gw_app_reponse(ble_serial):
         input = read_from_ble(ble_serial)
         if GW_APP_VERSION_HEADER in input:
             print(input)
-            ble_mac_address = re.search('WILIOT_GW_BLE_CHIP_MAC_ADDRESS=([0-9A-F]{12})', input).group(1)
+            ble_chip_sw_ver = re.search(r'WILIOT_GW_BLE_CHIP_SW_VER=(\d+\.\d+\.\d+)', input).group(1)
+            ble_mac_address = re.search(r'WILIOT_GW_BLE_CHIP_MAC_ADDRESS=([0-9A-F]{12})', input).group(1)
             print("success!")
-            return TEST_PASSED, ble_mac_address
+            return TEST_PASSED, ble_mac_address, ble_chip_sw_ver
     print("failure!")
     return TEST_FAILED, ''
 
@@ -264,6 +265,7 @@ def gw_sim_run(port, gw_id, analyze_interference=False):
         print("ERROR: didn't get version response!")
         return
     os.environ[GW_SIM_BLE_MAC_ADDRESS] = gw_app_res[1]
+    os.environ[GW_APP_VERSION_HEADER] = gw_app_res[2]
     write_to_ble(ble_serial, STOP_ADVERTISING, sleep=2)
     write_to_ble(ble_serial, f"{CONNECTIVITY_STATUS} 1 1")
 

brg_certificate/cert_mqtt.py

@@ -170,6 +170,11 @@ def on_message_protobuf(mqttc, userdata, message):
     if pb_decoded is True:
         pb_msg_dict = MessageToDict(pb_msg)
         # Align formats with JSON (bytes to hex strings)
+        if 'status' in message.topic:
+            if GW_STATUS in pb_msg_dict and ACL_IDS in pb_msg_dict[GW_STATUS][CONFIG][ACL][ACL_VALUE]:
+                ids_list = pb_msg_dict[GW_STATUS][CONFIG][ACL][ACL_VALUE][ACL_IDS]
+                for idx, id in enumerate(ids_list):
+                    ids_list[idx] = base64.b64decode(id).hex().upper()
         if 'data' in message.topic and PACKETS in pb_msg_dict.keys():
             for idx, pkt in enumerate(pb_msg_dict[PACKETS]):
                 pb_msg_dict[PACKETS][idx][PAYLOAD] = base64.b64decode(pkt[PAYLOAD]).hex().upper()
@@ -353,13 +358,14 @@ def get_brg2gw_mgmt_pkts(mqttc, test=None, mgmt_types=[]):
     pkts = [p for p in brg2gw_mgmt_pkts if test.active_brg.id_str in p[PAYLOAD]]
     return pkts
 
-def get_unified_data_pkts(test):
+def get_unified_data_pkts(test, only_active_brg=True):
     all_unified_pkts, pkts = [], get_all_sim_data_pkts(test.mqttc) if test.data == DATA_SIMULATION else get_all_data_pkts(test.mqttc)
     for p in pkts:
         if UNIFIED_PKT in p:
             all_unified_pkts += [p]
     pkts = all_unified_pkts
-    pkts = [p for p in all_unified_pkts if p[ALIAS_BRIDGE_ID] == test.active_brg.id_alias]
+    if only_active_brg:
+        pkts = [p for p in all_unified_pkts if p[ALIAS_BRIDGE_ID] == test.active_brg.id_alias]
     print(f"\nCollected {len(pkts)} unified data pkts")
     return pkts
 

brg_certificate/cert_prints.py

@@ -22,11 +22,13 @@ color = lambda c, t : COLORS["BOLD"]+COLORS[c]+t+COLORS["ENDC"]
 pipeline_running = lambda : True if 'BITBUCKET_BUILD_NUMBER' in os.environ else False
 camelcase_to_title = lambda s: ' '.join(word.capitalize() for word in re.split('(?=[A-Z])', s))
 SEP = '\n' + '#'*100 + '\n'
-WIL_UT_TEXT = r'''
-__      _____ _    ___ ___ _____   _   _ _____
-\ \    / /_ _| |  |_ _/ _ \_   _| | | | |_   _|
- \ \/\/ / | || |__ | | (_) || |   | |_| | | |
-  \_/\_/ |___|____|___\___/ |_|    \___/  |_|
+WIL_CERT_TEXT = r'''
+ __        _____ _     ___ ___ _____    ____ _____ ____ _____ ___ _____ ___ ____    _  _____ _____ 
+ \ \      / /_ _| |   |_ _/ _ \_   _|  / ___| ____|  _ \_   _|_ _|  ___|_ _/ ___|  / \|_   _| ____|
+  \ \ /\ / / | || |    | | | | || |   | |   |  _| | |_) || |  | || |_   | | |     / _ \ | | |  _|  
+   \ V  V /  | || |___ | | |_| || |   | |___| |___|  _ < | |  | ||  _|  | | |___ / ___ \| | | |___ 
+    \_/\_/  |___|_____|___\___/ |_|    \____|_____|_| \_\|_| |___|_|   |___\____/_/   \_\_| |_____|
+                                                                                                   
 '''
 
 hex_str2int = lambda s : int(s, 16)

brg_certificate/cert_protobuf.py

@@ -39,7 +39,7 @@ def gw_cfg_pb(msg: dict):
         # Skip GW_MODE since it doesn't exist today and harm the parsing in PB
         if GW_MODE == key:
             continue
-        pb_value = wpb.Value()
+        pb_value = wpb.GatewayConfigValue()
         if isinstance(val, int):
             pb_value.integerValue = val
         elif isinstance(val, float):
@@ -48,6 +48,10 @@ def gw_cfg_pb(msg: dict):
             pb_value.stringValue = val
         elif isinstance(val, bool):
             pb_value.boolValue = val
+        elif isinstance(val, dict) and key == ACL:
+            pb_value.aclValue.mode_allow = ACL_DENY_VALUE if msg[ADDITIONAL][ACL][ACL_MODE] == ACL_DENY else ACL_ALLOW_VALUE
+            ids_bytes = [bytes.fromhex(id) for id in msg[ADDITIONAL][ACL][ACL_BRIDGE_IDS]]
+            pb_value.aclValue.ids.extend(ids_bytes)
         else:
             raise ValueError(f"Unsupported value type for key '{key}': {type(val)}")
         pb_msg.gatewayConfig.config[key].CopyFrom(pb_value)