Merge branch 'update_submodule/matter_1.4.2' into 'main'

connectedhomeip: Update the submodule to latest v1.4.2-branch.

See merge request app-frameworks/esp-matter!1223

Author: dhrishi

.gitlab-ci.yml

@@ -28,7 +28,7 @@ variables:
     IDF_CHECKOUT_REF: "v5.4.1"
     # This variable represents the short hash of the connectedhomeip submodule.
     # Note: Do change this short hash on submodule update MRs.
-    CHIP_SHORT_HASH: "d144bbbaae"
+    CHIP_SHORT_HASH: "320b9a6f6c"
     DOCKER_IMAGE_NAME: "espressif/chip-idf"
 
 .add_gitlab_ssh_key: &add_gitlab_ssh_key |

README.md

@@ -28,7 +28,7 @@ section in the ESP-Matter Programming Guide.
 
 ## Supported ESP-IDF and connectedhomeip versions
 
-- This SDK currently works with commit [d144bbbaae] (https://github.com/project-chip/connectedhomeip/tree/d144bbbaae) of connectedhomeip.
+- This SDK currently works with commit [320b9a6f6c] (https://github.com/project-chip/connectedhomeip/tree/320b9a6f66) of connectedhomeip.
 - For Matter projects development with this SDK, it is recommended to utilize ESP-IDF [v5.4.1](https://github.com/espressif/esp-idf/tree/v5.4.1).
 - For ESP32C5, it is recommended to utilize ESP-IDF [98cd765953](https://github.com/espressif/esp-idf/commit/98cd765953dfe0e7bb1c5df8367e1b54bd966cce).
 

components/esp_matter/CMakeLists.txt

@@ -11,6 +11,7 @@ set(INCLUDE_DIRS_LIST   "."
 
 # TODO: This file has compilation errors
 set(EXCLUDE_SRCS_LIST "${MATTER_SDK_PATH}/src/app/clusters/closure-control-server/closure-control-server.cpp")
+list(APPEND EXCLUDE_SRCS_LIST "${MATTER_SDK_PATH}/src/app/clusters/general-commissioning-server/TemporaryTestCoupling.cpp")
 
 if (CONFIG_ESP_MATTER_ENABLE_MATTER_SERVER)
     list(APPEND SRC_DIRS_LIST    "${MATTER_SDK_PATH}/src/app/server"
@@ -36,13 +37,23 @@ if (CONFIG_ESP_MATTER_ENABLE_MATTER_SERVER)
                                   "private")
         list(APPEND INCLUDE_DIRS_LIST "zap_common"
                                       "data_model")
+        list(APPEND EXCLUDE_SRCS_LIST "${MATTER_SDK_PATH}/src/app/clusters/software-diagnostics-server/CodegenIntegration.cpp")
+        list(APPEND EXCLUDE_SRCS_LIST "${MATTER_SDK_PATH}/src/app/clusters/administrator-commissioning-server/CodegenIntegration.cpp")
+        list(APPEND EXCLUDE_SRCS_LIST "${MATTER_SDK_PATH}/src/app/clusters/ota-provider/CodegenIntegration.cpp")
+   
+        if(NOT CONFIG_SUPPORT_SOFTWARE_DIAGNOSTICS_CLUSTER)
+              list(APPEND EXCLUDE_SRCS_LIST "data_model/software_diagnostics_codegen_integration.cpp")
+        endif()
+
     endif(CONFIG_ESP_MATTER_ENABLE_DATA_MODEL)
 else()
     list(APPEND EXCLUDE_SRCS_LIST "esp_matter_identify.cpp"
                                   "esp_matter_ota.cpp"
                                   "esp_matter_attribute_utils.cpp")
 endif(CONFIG_ESP_MATTER_ENABLE_MATTER_SERVER)
 
+
+
 set(REQUIRES_LIST       chip bt esp_matter_console nvs_flash app_update esp_secure_cert_mgr mbedtls esp_system openthread json)
 
 idf_component_register( SRC_DIRS        ${SRC_DIRS_LIST}

components/esp_matter/data_model/administrator_commissioning_codegen_integration.cpp

@@ -0,0 +1,79 @@
+// Copyright 2025 Espressif Systems (Shanghai) PTE LTD
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include <app/clusters/administrator-commissioning-server/AdministratorCommissioningCluster.h>
+#include <data-model-providers/codegen/CodegenDataModelProvider.h>
+#include <app-common/zap-generated/attributes/Accessors.h>
+#include <app/util/attribute-storage.h>
+
+using namespace chip;
+using namespace chip::app;
+using namespace chip::app::Clusters;
+using namespace chip::app::Clusters::AdministratorCommissioning::Attributes;
+using chip::Protocols::InteractionModel::Status;
+
+namespace {
+
+// AdministratorCommissioningCluster implementation is specifically implemented
+// only for the root endpoint (endpoint 0)
+// So either:
+//   - we have a fixed config and it is endpoint 0 OR
+//   - we have a fully dynamic config
+
+static constexpr size_t kAdministratorCommissioningFixedClusterCount = 0;
+  
+using ClusterImpl = AdministratorCommissioningWithBasicCommissioningWindowCluster;
+LazyRegisteredServerCluster<ClusterImpl> gServer;
+
+} // namespace
+
+void emberAfAdministratorCommissioningClusterInitCallback(EndpointId endpointId)
+{
+    if (endpointId != kRootEndpointId)
+    {
+        return;
+    }
+
+    uint32_t rawFeatureMap;
+    if (FeatureMap::Get(endpointId, &rawFeatureMap) != Status::Success)
+    {
+        ChipLogError(AppServer, "Failed to get feature map for endpoint %u", endpointId);
+        rawFeatureMap = 0;
+    }
+
+    gServer.Create(endpointId, BitFlags<AdministratorCommissioning::Feature>(rawFeatureMap));
+    CHIP_ERROR err = CodegenDataModelProvider::Instance().Registry().Register(gServer.Registration());
+    if (err != CHIP_NO_ERROR)
+    {
+        ChipLogError(AppServer, "Admin Commissioning register error: endpoint %u, %" CHIP_ERROR_FORMAT, endpointId, err.Format());
+    }
+}
+
+void emberAfAdministratorCommissioningClusterShutdownCallback(EndpointId endpointId)
+{
+    if (endpointId != kRootEndpointId)
+    {
+        return;
+    }
+
+    CHIP_ERROR err = CodegenDataModelProvider::Instance().Registry().Unregister(&gServer.Cluster());
+    if (err != CHIP_NO_ERROR)
+    {
+        ChipLogError(AppServer, "Admin Commissioning unregister error: endpoint %u, %" CHIP_ERROR_FORMAT, endpointId, err.Format());
+    }
+    gServer.Destroy();
+}
+
+void MatterAdministratorCommissioningPluginServerInitCallback() {}
+void MatterAdministratorCommissioningPluginServerShutdownCallback() {}

components/esp_matter/data_model/esp_matter_attribute.cpp

@@ -297,6 +297,13 @@ attribute_t *create_max_paths_per_invoke(cluster_t *cluster, uint16_t value)
                                          esp_matter_uint16(value));
 }
 
+attribute_t *create_configuration_version(cluster_t *cluster, uint32_t value)
+{
+    return esp_matter::attribute::create(cluster, BasicInformation::Attributes::ConfigurationVersion::Id,
+                                         ATTRIBUTE_FLAG_MANAGED_INTERNALLY, esp_matter_uint32(value));
+}
+
+
 } /* attribute */
 } /* basic_information */
 
@@ -958,7 +965,7 @@ attribute_t *create_detached_role_count(cluster_t *cluster, uint16_t value)
                                          ATTRIBUTE_FLAG_MANAGED_INTERNALLY, esp_matter_uint16(value));
 }
 
-attribute_t *create_chlid_role_count(cluster_t *cluster, uint16_t value)
+attribute_t *create_child_role_count(cluster_t *cluster, uint16_t value)
 {
     return esp_matter::attribute::create(cluster, ThreadNetworkDiagnostics::Attributes::ChildRoleCount::Id,
                                          ATTRIBUTE_FLAG_MANAGED_INTERNALLY, esp_matter_uint16(value));
@@ -1388,6 +1395,12 @@ attribute_t *create_product_appearance(cluster_t *cluster, uint8_t *value, uint1
                                          ATTRIBUTE_FLAG_NONE, esp_matter_array(value, length, count));
 }
 
+attribute_t *create_configuration_version(cluster_t *cluster, uint32_t value)
+{
+    return esp_matter::attribute::create(cluster, BridgedDeviceBasicInformation::Attributes::ConfigurationVersion::Id,
+                                         ATTRIBUTE_FLAG_MANAGED_INTERNALLY, esp_matter_uint32(value));
+}
+
 } /* attribute */
 } /* bridged_device_basic_information */
 
@@ -2758,7 +2771,7 @@ attribute_t *create_auto_relock_time(cluster_t *cluster, uint32_t value)
                                          esp_matter_uint32(value));
 }
 
-attribute_t *create_sound_valume(cluster_t *cluster, uint8_t value)
+attribute_t *create_sound_volume(cluster_t *cluster, uint8_t value)
 {
     return esp_matter::attribute::create(cluster, DoorLock::Attributes::SoundVolume::Id, ATTRIBUTE_FLAG_WRITABLE,
                                          esp_matter_enum8(value));
@@ -3333,6 +3346,13 @@ attribute_t *create_temperature_unit(cluster_t *cluster, uint8_t value)
                                          ATTRIBUTE_FLAG_WRITABLE | ATTRIBUTE_FLAG_NONVOLATILE,
                                          esp_matter_enum8(value));
 }
+
+attribute_t *create_supported_temperature_units(cluster_t *cluster, uint8_t *value, uint16_t length, uint16_t count)
+{
+    return esp_matter::attribute::create(cluster, UnitLocalization::Attributes::SupportedTemperatureUnits::Id, ATTRIBUTE_FLAG_MANAGED_INTERNALLY,
+                                         esp_matter_array(value, length, count));
+}
+
 } /* attribute */
 } /* unit_localization */
 

components/esp_matter/data_model/esp_matter_attribute.h

@@ -86,6 +86,7 @@ attribute_t *create_unique_id(cluster_t *cluster, char *value, uint16_t length);
 attribute_t *create_capability_minima(cluster_t *cluster, uint8_t *value, uint16_t length, uint16_t count);
 attribute_t *create_specification_version(cluster_t *cluster, uint32_t value);
 attribute_t *create_max_paths_per_invoke(cluster_t *cluster, uint16_t value);
+attribute_t *create_configuration_version(cluster_t *cluster, uint32_t value);
 
 /** These attributes are optional for the cluster, but when added to this cluster, the value is maintained internally.
   * If the attributes are added in some other cluster, then the value is not maintained internally.
@@ -259,7 +260,7 @@ attribute_t *create_ext_address(cluster_t *cluster, nullable<uint64_t> value);
 attribute_t *create_rloc16(cluster_t *cluster, nullable<uint16_t> value);
 attribute_t *create_overrun_count(cluster_t *cluster, uint64_t value);
 attribute_t *create_detached_role_count(cluster_t *cluster, uint16_t value);
-attribute_t *create_chlid_role_count(cluster_t *cluster, uint16_t value);
+attribute_t *create_child_role_count(cluster_t *cluster, uint16_t value);
 attribute_t *create_router_role_count(cluster_t *cluster, uint16_t value);
 attribute_t *create_leader_role_count(cluster_t *cluster, uint16_t value);
 attribute_t *create_attach_attempt_count(cluster_t *cluster, uint16_t value);
@@ -355,6 +356,8 @@ attribute_t *create_serial_number(cluster_t *cluster, char *value, uint16_t leng
 attribute_t *create_reachable(cluster_t *cluster, bool value);
 attribute_t *create_unique_id(cluster_t *cluster, char *value, uint16_t length);
 attribute_t *create_product_appearance(cluster_t *cluster, uint8_t *value, uint16_t length, uint16_t count);
+attribute_t *create_configuration_version(cluster_t *cluster, uint32_t *value);
+
 } /* attribute */
 } /* bridged_device_basic_information */
 
@@ -667,7 +670,7 @@ attribute_t *create_number_of_credentials_supported_per_user(cluster_t *cluster,
 attribute_t *create_language(cluster_t *cluster, const char * value, uint16_t length);
 attribute_t *create_led_settings(cluster_t *cluster, uint8_t value);
 attribute_t *create_auto_relock_time(cluster_t *cluster, uint32_t value);
-attribute_t *create_sound_valume(cluster_t *cluster, uint8_t value);
+attribute_t *create_sound_volume(cluster_t *cluster, uint8_t value);
 attribute_t *create_operating_mode(cluster_t *cluster, uint8_t value, uint8_t min, uint8_t max);
 attribute_t *create_supported_operating_modes(cluster_t *cluster, const uint16_t value);
 attribute_t *create_default_configuration_register(cluster_t *cluster, uint16_t value);
@@ -830,6 +833,8 @@ attribute_t *create_supported_locales(cluster_t *cluster, uint8_t *value, uint16
 namespace unit_localization {
 namespace attribute {
 attribute_t *create_temperature_unit(cluster_t *cluster, uint8_t value);
+attribute_t *create_supported_temperature_units(cluster_t *cluster, uint8_t *value, uint16_t length, uint16_t count);
+
 } /* attribute */
 } /* unit_localization */
 

components/esp_matter/data_model/esp_matter_cluster.cpp

@@ -240,6 +240,7 @@ cluster_t *create(endpoint_t *endpoint, config_t *config, uint8_t flags)
         attribute::create_capability_minima(cluster, NULL, 0, 0);
         attribute::create_specification_version(cluster, 0);
         attribute::create_max_paths_per_invoke(cluster, 0);
+        attribute::create_configuration_version(cluster, 0);
 
         /* Attributes not managed internally */
         global::attribute::create_cluster_revision(cluster, cluster_revision);