Chef: Add APIs to provide deviceType info on Endpoints. Make chef static temperature levels (temperature control cluster) endpoint agnostic.

examples/chef/common/DataModelUtils.cpp

@@ -0,0 +1,59 @@
+/*
+ *
+ *    Copyright (c) 2025 Project CHIP Authors
+ *    All rights reserved.
+ *
+ *    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 <DataModelUtils.h>
+#include <app/InteractionModelEngine.h>
+#include <app/data-model-provider/MetadataTypes.h>
+#include <lib/support/CodeUtils.h>
+
+using namespace chef;
+using namespace chip;
+using namespace chip::app;
+
+bool DataModelUtils::EndpointHasDeviceType(EndpointId endpoint, DeviceTypeId deviceTypeId)
+{
+    DataModel::ListBuilder<DataModel::DeviceTypeEntry> deviceTypesList;
+    InteractionModelEngine::GetInstance()->GetDataModelProvider()->DeviceTypes(endpoint, deviceTypesList);
+    auto deviceTypes = deviceTypesList.TakeBuffer();
+    for (const auto & type : deviceTypes)
+    {
+        if (type.deviceTypeId == deviceTypeId)
+        {
+            return true;
+        }
+    }
+    return false;
+}
+
+DataModel::ListBuilder<EndpointId> DataModelUtils::GetAllEndpointsHavingDeviceType(DeviceTypeId devieType)
+{
+    DataModel::ListBuilder<DataModel::EndpointEntry> endpointsList;
+    InteractionModelEngine::GetInstance()->GetDataModelProvider()->Endpoints(endpointsList);
+    auto allEndpoints = endpointsList.TakeBuffer();
+
+    DataModel::ListBuilder<EndpointId> endpoints;
+
+    for (const auto & ep : allEndpoints)
+    {
+        if (EndpointHasDeviceType(ep.id, devieType))
+        {
+            endpoints.Append(ep.id);
+        }
+    }
+    return endpoints;
+}

examples/chef/common/DataModelUtils.h

@@ -0,0 +1,38 @@
+/*
+ *
+ *    Copyright (c) 2025 Project CHIP Authors
+ *    All rights reserved.
+ *
+ *    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/data-model-provider/MetadataList.h>
+#include <lib/core/CHIPError.h>
+#include <lib/core/DataModelTypes.h>
+
+namespace chef {
+namespace DataModelUtils {
+
+// Common location to store all device type IDs
+constexpr chip::DeviceTypeId kCookSurfaceDeviceId                  = 0x0077;
+constexpr chip::DeviceTypeId kCooktopDeviceId                      = 0x0078;
+constexpr chip::DeviceTypeId kOvenDeviceId                         = 0x007B;
+constexpr chip::DeviceTypeId kRefrigeratorDeviceId                 = 0x0070;
+constexpr chip::DeviceTypeId kTemperatureControlledCabinetDeviceId = 0x0071;
+
+// Datamodel Util APIs
+bool EndpointHasDeviceType(chip::EndpointId endpoint, chip::DeviceTypeId deviceTypeId);
+chip::app::DataModel::ListBuilder<chip::EndpointId> GetAllEndpointsHavingDeviceType(chip::DeviceTypeId devieType);
+
+} // namespace DataModelUtils
+} // namespace chef

examples/chef/common/clusters/temperature-control/static-supported-temperature-levels.cpp

@@ -21,6 +21,7 @@
 #ifdef MATTER_DM_PLUGIN_TEMPERATURE_CONTROL_SERVER
 #include "static-supported-temperature-levels.h"
 #include <app/clusters/temperature-control-server/supported-temperature-levels-manager.h>
+#include <app/util/attribute-storage.h>
 #include <lib/support/CodeUtils.h>
 
 using namespace chip;
@@ -30,12 +31,12 @@ using chip::Protocols::InteractionModel::Status;
 
 app::Clusters::TemperatureControl::AppSupportedTemperatureLevelsDelegate sAppSupportedTemperatureLevelsDelegate;
 
-CharSpan AppSupportedTemperatureLevelsDelegate::temperatureLevelOptions[] = { "Low"_span, "Medium"_span, "High"_span };
+namespace ChefTemperatureControl {
+static const CharSpan temperatureLevelOptions[3] = { "Low"_span, "Medium"_span, "High"_span };
+} // namespace ChefTemperatureControl
 
-const AppSupportedTemperatureLevelsDelegate::EndpointPair AppSupportedTemperatureLevelsDelegate::supportedOptionsByEndpoints
-    [MATTER_DM_TEMPERATURE_CONTROL_CLUSTER_SERVER_ENDPOINT_COUNT] = { EndpointPair(
-        1 /* endpointId */, AppSupportedTemperatureLevelsDelegate::temperatureLevelOptions,
-        MATTER_ARRAY_SIZE(AppSupportedTemperatureLevelsDelegate::temperatureLevelOptions)) };
+ChefTemperatureControl::EndpointPair
+    AppSupportedTemperatureLevelsDelegate::supportedOptionsByEndpoints[MATTER_DM_TEMPERATURE_CONTROL_CLUSTER_SERVER_ENDPOINT_COUNT];
 
 uint8_t AppSupportedTemperatureLevelsDelegate::Size()
 {
@@ -72,7 +73,13 @@ CHIP_ERROR AppSupportedTemperatureLevelsDelegate::Next(MutableCharSpan & item)
 }
 void emberAfTemperatureControlClusterInitCallback(EndpointId endpoint)
 {
-    static_assert(MATTER_DM_TEMPERATURE_CONTROL_CLUSTER_SERVER_ENDPOINT_COUNT == 1, "This cluster is only enabled for endpoint 1");
+    ChipLogDetail(DeviceLayer, "Initializing TemperatureControl cluster for Endpoint: %d", endpoint);
+    uint16_t epIndex = emberAfGetClusterServerEndpointIndex(endpoint, TemperatureControl::Id,
+                                                            MATTER_DM_TEMPERATURE_CONTROL_CLUSTER_SERVER_ENDPOINT_COUNT);
+    sAppSupportedTemperatureLevelsDelegate.SetSupportedEndpointPair(
+        epIndex,
+        ChefTemperatureControl::EndpointPair(endpoint /* endpointId */, ChefTemperatureControl::temperatureLevelOptions,
+                                             MATTER_ARRAY_SIZE(ChefTemperatureControl::temperatureLevelOptions)));
 
     chip::app::Clusters::TemperatureControl::SetInstance(&sAppSupportedTemperatureLevelsDelegate);
 }

examples/chef/common/clusters/temperature-control/static-supported-temperature-levels.h

@@ -21,32 +21,41 @@
 #include <app/clusters/temperature-control-server/supported-temperature-levels-manager.h>
 #include <app/util/config.h>
 
+namespace ChefTemperatureControl {
+struct EndpointPair
+{
+    chip::EndpointId mEndpointId;
+    const chip::CharSpan * mTemperatureLevels;
+    uint8_t mSize;
+
+    EndpointPair() : mEndpointId(chip::kInvalidEndpointId), mTemperatureLevels(NULL), mSize(0) {}
+
+    EndpointPair(chip::EndpointId aEndpointId, const chip::CharSpan * TemperatureLevels, uint8_t size) :
+        mEndpointId(aEndpointId), mTemperatureLevels(TemperatureLevels), mSize(size)
+    {}
+};
+} // namespace ChefTemperatureControl
+
 namespace chip {
 namespace app {
 namespace Clusters {
 namespace TemperatureControl {
 
 class AppSupportedTemperatureLevelsDelegate : public SupportedTemperatureLevelsIteratorDelegate
 {
-    struct EndpointPair
-    {
-        EndpointId mEndpointId;
-        CharSpan * mTemperatureLevels;
-        uint8_t mSize;
-
-        EndpointPair(EndpointId aEndpointId, CharSpan * TemperatureLevels, uint8_t size) :
-            mEndpointId(aEndpointId), mTemperatureLevels(TemperatureLevels), mSize(size)
-        {}
-    };
-
-    static CharSpan temperatureLevelOptions[3];
-    static const EndpointPair supportedOptionsByEndpoints[MATTER_DM_TEMPERATURE_CONTROL_CLUSTER_SERVER_ENDPOINT_COUNT];
+    static ChefTemperatureControl::EndpointPair
+        supportedOptionsByEndpoints[MATTER_DM_TEMPERATURE_CONTROL_CLUSTER_SERVER_ENDPOINT_COUNT];
 
 public:
     uint8_t Size() override;
 
     CHIP_ERROR Next(MutableCharSpan & item) override;
 
+    static void SetSupportedEndpointPair(uint16_t index, ChefTemperatureControl::EndpointPair endpointPair)
+    {
+        supportedOptionsByEndpoints[index] = endpointPair;
+    }
+
     ~AppSupportedTemperatureLevelsDelegate() {}
 };
 

examples/chef/common/stubs.cpp

@@ -1,3 +1,4 @@
+#include "DataModelUtils.h"
 #include <app-common/zap-generated/attributes/Accessors.h>
 #include <app-common/zap-generated/callback.h>
 #include <app/data-model/Nullable.h>
@@ -7,6 +8,7 @@
 
 using chip::app::DataModel::Nullable;
 
+using namespace chef;
 using namespace chip;
 using namespace chip::app;
 using namespace chip::app::Clusters;
@@ -38,21 +40,30 @@ using namespace chip::app::Clusters;
 #include "refrigerator-and-temperature-controlled-cabinet-mode/tcc-mode.h"
 #endif // MATTER_DM_PLUGIN_REFRIGERATOR_AND_TEMPERATURE_CONTROLLED_CABINET_MODE_SERVER
 
-#ifdef MATTER_DM_PLUGIN_REFRIGERATOR_ALARM_SERVER
 namespace {
 
 // Please refer to https://github.com/CHIP-Specifications/connectedhomeip-spec/blob/master/src/namespaces
 constexpr const uint8_t kNamespaceRefrigerator = 0x41;
 // Refrigerator Namespace: 0x41, tag 0x00 (Refrigerator)
 constexpr const uint8_t kTagRefrigerator = 0x00;
 // Refrigerator Namespace: 0x41, tag 0x01 (Freezer)
-constexpr const uint8_t kTagFreezer                                                = 0x01;
-const Clusters::Descriptor::Structs::SemanticTagStruct::Type refrigeratorTagList[] = { { .namespaceID = kNamespaceRefrigerator,
-                                                                                         .tag         = kTagRefrigerator } };
-const Clusters::Descriptor::Structs::SemanticTagStruct::Type freezerTagList[]      = { { .namespaceID = kNamespaceRefrigerator,
-                                                                                         .tag         = kTagFreezer } };
+constexpr const uint8_t kTagFreezer                                                 = 0x01;
+const Clusters::Descriptor::Structs::SemanticTagStruct::Type gRefrigeratorTagList[] = { { .namespaceID = kNamespaceRefrigerator,
+                                                                                          .tag         = kTagRefrigerator } };
+const Clusters::Descriptor::Structs::SemanticTagStruct::Type gFreezerTagList[]      = { { .namespaceID = kNamespaceRefrigerator,
+                                                                                          .tag         = kTagFreezer } };
 } // namespace
-#endif // MATTER_DM_PLUGIN_REFRIGERATOR_ALARM_SERVER
+
+namespace PostionSemanticTag {
+
+constexpr const uint8_t kNamespace                                   = 0x08; // Common Position Namespace
+const Clusters::Descriptor::Structs::SemanticTagStruct::Type kLeft   = { .namespaceID = kNamespace, .tag = 0x00 };
+const Clusters::Descriptor::Structs::SemanticTagStruct::Type kRight  = { .namespaceID = kNamespace, .tag = 0x01 };
+const Clusters::Descriptor::Structs::SemanticTagStruct::Type kTop    = { .namespaceID = kNamespace, .tag = 0x02 };
+const Clusters::Descriptor::Structs::SemanticTagStruct::Type kBottom = { .namespaceID = kNamespace, .tag = 0x03 };
+const Clusters::Descriptor::Structs::SemanticTagStruct::Type kMiddle = { .namespaceID = kNamespace, .tag = 0x04 };
+
+} // namespace PostionSemanticTag
 
 #ifdef MATTER_DM_PLUGIN_RVC_OPERATIONAL_STATE_SERVER
 #include "chef-rvc-operational-state-delegate.h"
@@ -347,22 +358,119 @@ void emberAfWakeOnLanClusterInitCallback(EndpointId endpoint)
 }
 #endif
 
-void ApplicationInit()
+/**
+ * This initializer is for the application having refrigerator on EP1 and child
+ * temperatureControlledCabinet endpoints on EP2 and EP3.
+ */
+void RefrigeratorTemperatureControlledCabinetInit()
 {
-    ChipLogProgress(NotSpecified, "Chef Application Init !!!");
-
-#ifdef MATTER_DM_PLUGIN_REFRIGERATOR_ALARM_SERVER
-    // set Parent Endpoint and Composition Type for an Endpoint
     EndpointId kRefEndpointId           = 1;
     EndpointId kColdCabinetEndpointId   = 2;
     EndpointId kFreezeCabinetEndpointId = 3;
-    SetTreeCompositionForEndpoint(kRefEndpointId);
-    SetParentEndpointForEndpoint(kColdCabinetEndpointId, kRefEndpointId);
-    SetParentEndpointForEndpoint(kFreezeCabinetEndpointId, kRefEndpointId);
-    // set TagList
-    SetTagList(kColdCabinetEndpointId, Span<const Clusters::Descriptor::Structs::SemanticTagStruct::Type>(refrigeratorTagList));
-    SetTagList(kFreezeCabinetEndpointId, Span<const Clusters::Descriptor::Structs::SemanticTagStruct::Type>(freezerTagList));
-#endif // MATTER_DM_PLUGIN_REFRIGERATOR_ALARM_SERVER
+    if (DataModelUtils::EndpointHasDeviceType(kRefEndpointId, DataModelUtils::kRefrigeratorDeviceId))
+    {
+        ChipLogDetail(NotSpecified, "Refrigerator device type on EP: %d", kRefEndpointId);
+        SetTreeCompositionForEndpoint(kRefEndpointId);
+
+        // Cold Cabinet
+        if (DataModelUtils::EndpointHasDeviceType(kColdCabinetEndpointId, DataModelUtils::kTemperatureControlledCabinetDeviceId))
+        {
+            ChipLogDetail(NotSpecified, "Temperature controlled cabinet device type on EP: %d", kColdCabinetEndpointId);
+            SetParentEndpointForEndpoint(kColdCabinetEndpointId, kRefEndpointId);
+            SetTagList(kColdCabinetEndpointId,
+                       Span<const Clusters::Descriptor::Structs::SemanticTagStruct::Type>(gRefrigeratorTagList));
+        }
+
+        // Freeze Cabinet
+        if (DataModelUtils::EndpointHasDeviceType(kFreezeCabinetEndpointId, DataModelUtils::kTemperatureControlledCabinetDeviceId))
+        {
+            ChipLogDetail(NotSpecified, "Temperature controlled cabinet device type on EP: %d", kFreezeCabinetEndpointId);
+            SetParentEndpointForEndpoint(kFreezeCabinetEndpointId, kRefEndpointId);
+            SetTagList(kFreezeCabinetEndpointId,
+                       Span<const Clusters::Descriptor::Structs::SemanticTagStruct::Type>(gFreezerTagList));
+        }
+    }
+}
+
+/**
+ * This initializer is for the application having cooktop. The cooktop can be a part of an oven
+ * or standalone cooktop.
+ *     Standalone Cooktop: Cooktop on EP1 and optional CookSurface on EP2.
+ *     Cooktop part of Oven: Oven on EP1, Cooktop on EP3 and optional CookSurface on EP4.
+ */
+void CooktopCookSurfaceInit(EndpointId kCooktopEpId)
+{
+    SetTreeCompositionForEndpoint(kCooktopEpId);
+    switch (kCooktopEpId)
+    {
+    case 1: // Standalone cooktop.
+        if (DataModelUtils::EndpointHasDeviceType(kCooktopEpId, DataModelUtils::kCooktopDeviceId))
+        {
+            ChipLogDetail(NotSpecified, "Cooktop device type on EP: %d", kCooktopEpId);
+            EndpointId kCookSurfaceEpId = 2;
+            if (DataModelUtils::EndpointHasDeviceType(kCookSurfaceEpId, DataModelUtils::kCookSurfaceDeviceId))
+            {
+                ChipLogDetail(NotSpecified, "Cook Surface device type on EP: %d", kCookSurfaceEpId);
+                SetParentEndpointForEndpoint(kCookSurfaceEpId, kCooktopEpId);
+                const Clusters::Descriptor::Structs::SemanticTagStruct::Type cookSurfacePosition[] = { PostionSemanticTag::kLeft };
+                SetTagList(kCookSurfaceEpId,
+                           Span<const Clusters::Descriptor::Structs::SemanticTagStruct::Type>(cookSurfacePosition));
+            }
+        }
+        break;
+    case 3: // Cooktop part of oven.
+        EndpointId kOvenEpId = 1;
+        if (DataModelUtils::EndpointHasDeviceType(kCooktopEpId, DataModelUtils::kCooktopDeviceId) &&
+            DataModelUtils::EndpointHasDeviceType(kOvenEpId, DataModelUtils::kOvenDeviceId))
+        {
+            ChipLogDetail(NotSpecified, "Cooktop device type on EP: %d", kCooktopEpId);
+            SetParentEndpointForEndpoint(kCooktopEpId, kOvenEpId);
+            EndpointId kCookSurfaceEpId = 4;
+            if (DataModelUtils::EndpointHasDeviceType(kCookSurfaceEpId, DataModelUtils::kCookSurfaceDeviceId))
+            {
+                ChipLogDetail(NotSpecified, "Cook Surface device type on EP: %d", kCookSurfaceEpId);
+                SetParentEndpointForEndpoint(kCookSurfaceEpId, kCooktopEpId);
+                const Clusters::Descriptor::Structs::SemanticTagStruct::Type cookSurfacePosition[] = { PostionSemanticTag::kLeft };
+                SetTagList(kCookSurfaceEpId,
+                           Span<const Clusters::Descriptor::Structs::SemanticTagStruct::Type>(cookSurfacePosition));
+            }
+        }
+    }
+}
+
+/**
+ * This initializer is for the application having oven on EP1 and child endpoints -
+ * temperatureControlledCabinet on EP2, cooktop on EP3 and cooksurface on EP4.
+ */
+void OvenTemperatureControlledCabinetCooktopCookSurfaceInit()
+{
+    EndpointId kOvenEpId                         = 1;
+    EndpointId kTemperatureControlledCabinetEpId = 2;
+    EndpointId kCooktopEpId                      = 3;
+    if (DataModelUtils::EndpointHasDeviceType(kOvenEpId, DataModelUtils::kOvenDeviceId))
+    {
+        ChipLogDetail(NotSpecified, "Oven device type on EP: %d", kOvenEpId);
+        SetTreeCompositionForEndpoint(kOvenEpId);
+
+        if (DataModelUtils::EndpointHasDeviceType(kTemperatureControlledCabinetEpId,
+                                                  DataModelUtils::kTemperatureControlledCabinetDeviceId))
+        {
+            ChipLogDetail(NotSpecified, "Temperature controlled cabinet device type on EP: %d", kTemperatureControlledCabinetEpId);
+            SetParentEndpointForEndpoint(kTemperatureControlledCabinetEpId, kOvenEpId);
+            const Clusters::Descriptor::Structs::SemanticTagStruct::Type cabinetPosition[] = { PostionSemanticTag::kTop };
+            SetTagList(kTemperatureControlledCabinetEpId,
+                       Span<const Clusters::Descriptor::Structs::SemanticTagStruct::Type>(cabinetPosition));
+        }
+        CooktopCookSurfaceInit(kCooktopEpId);
+    }
+}
+
+void ApplicationInit()
+{
+    ChipLogProgress(NotSpecified, "Chef Application Init !!!");
+
+    RefrigeratorTemperatureControlledCabinetInit();
+    OvenTemperatureControlledCabinetCooktopCookSurfaceInit();
 
 #ifdef MATTER_DM_PLUGIN_WINDOW_COVERING_SERVER
     ChipLogProgress(NotSpecified, "Initializing WindowCovering cluster delegate.");

examples/chef/linux/BUILD.gn

@@ -40,6 +40,7 @@ chip_data_model("chef-data-model") {
 
 executable("${sample_name}") {
   sources = [
+    "${project_dir}/common/DataModelUtils.cpp",
     "${project_dir}/common/chef-air-quality.cpp",
     "${project_dir}/common/chef-concentration-measurement.cpp",
     "${project_dir}/common/chef-dishwasher-alarm-delegate-impl.cpp",

examples/chef/nrfconnect/CMakeLists.txt

@@ -78,6 +78,7 @@ if (CONFIG_CHIP_LIB_SHELL)
 endif()
 
 target_sources(app PRIVATE
+    ${CHEF}/common/DataModelUtils.cpp
     ${CHEF}/common/chef-air-quality.cpp
     ${CHEF}/common/chef-concentration-measurement.cpp
     ${CHEF}/common/chef-fan-control-manager.cpp