Add logic to handle the oven-mode change

Author: arun-silabs

examples/oven-app/oven-app-common/include/OvenEndpoint.h

@@ -57,10 +57,12 @@ class OvenModeDelegate : public ModeBase::Delegate
     CHIP_ERROR GetModeValueByIndex(uint8_t modeIndex, uint8_t & value) override;
     CHIP_ERROR GetModeTagsByIndex(uint8_t modeIndex, DataModel::List<detail::Structs::ModeTagStruct::Type> & tags) override;
 
+    // Public helper to query support status without exposing internal tables
+    static bool IsSupportedMode(uint8_t mode);
+
 private:
     EndpointId mEndpointId;
 
-    // Static arrays moved to implementation file to reduce header size
     static const detail::Structs::ModeTagStruct::Type sModeTagsBake[];
     static const detail::Structs::ModeTagStruct::Type sModeTagsConvection[];
     static const detail::Structs::ModeTagStruct::Type sModeTagsGrill[];

examples/oven-app/oven-app-common/src/OvenEndpoint.cpp

@@ -18,6 +18,9 @@
 
 #include "OvenEndpoint.h"
 #include <app-common/zap-generated/cluster-objects.h>
+#include <app-common/zap-generated/attributes/Accessors.h>
+
+#include "OvenManager.h"
 #include <app/clusters/mode-base-server/mode-base-cluster-objects.h>
 #include <lib/core/CHIPError.h>
 #include <lib/support/CodeUtils.h>
@@ -92,9 +95,8 @@ CHIP_ERROR OvenModeDelegate::Init()
 
 void OvenModeDelegate::HandleChangeToMode(uint8_t NewMode, ModeBase::Commands::ChangeToModeResponse::Type & response)
 {
-    ChipLogProgress(Zcl, "OvenModeDelegate::HandleChangeToMode: NewMode=%d", NewMode);
-    // TODO: Implement logic to change the oven mode.
-    response.status = to_underlying(ModeBase::StatusCode::kSuccess);
+  ChipLogProgress(Zcl, "OvenModeDelegate forwarding mode change to OvenManager (ep=%u newMode=%u)", mEndpointId, NewMode);
+  OvenManager::GetInstance().ProcessOvenModeChange(mEndpointId, NewMode, response);
 }
 
 CHIP_ERROR OvenModeDelegate::GetModeLabelByIndex(uint8_t modeIndex, MutableCharSpan & label)
@@ -147,3 +149,16 @@ CHIP_ERROR OvenEndpoint::Init()
 {
     return CHIP_NO_ERROR;
 }
+
+bool OvenModeDelegate::IsSupportedMode(uint8_t mode)
+{
+  for (auto const & opt : skModeOptions)
+  {
+    if (opt.mode == mode)
+    {
+      return true;
+    }
+  }
+  return false;
+}
+

examples/oven-app/silabs/include/OvenManager.h

@@ -36,6 +36,7 @@
 
 #include <app-common/zap-generated/ids/Attributes.h>
 #include <app/clusters/on-off-server/on-off-server.h>
+#include <app/clusters/mode-base-server/mode-base-cluster-objects.h>
 #include <lib/core/DataModelTypes.h>
 
 class OvenManager
@@ -80,6 +81,14 @@ class OvenManager
     CHIP_ERROR SetTemperatureControlledCabinetInitialState(chip::EndpointId temperatureControlledCabinetEndpoint);
     void TempCtrlAttributeChangeHandler(chip::EndpointId endpointId, chip::AttributeId attributeId, uint8_t * value, uint16_t size);
     void OnOffAttributeChangeHandler(chip::EndpointId endpointId, chip::AttributeId attributeId, uint8_t * value, uint16_t size);
+    void OvenModeAttributeChangeHandler(chip::EndpointId endpointId, chip::AttributeId attributeId, uint8_t * value, uint16_t size);
+
+    /**
+     * @brief Central handler for OvenMode delegate requests. Applies validation, blocked-transition policy,
+     *        and writes the CurrentMode attribute if allowed.
+     */
+    void ProcessOvenModeChange(chip::EndpointId endpointId, uint8_t newMode,
+                               chip::app::Clusters::ModeBase::Commands::ChangeToModeResponse::Type & response);
 
 private:
     static OvenManager sOvenMgr;

examples/oven-app/silabs/src/DataModelCallbacks.cpp

@@ -56,6 +56,11 @@ void MatterPostAttributeChangeCallback(const app::ConcreteAttributePath & attrib
                         ChipLogValueMEI(attributeId), type, *value, size);
         OvenManager::GetInstance().TempCtrlAttributeChangeHandler(attributePath.mEndpointId, attributeId, value, size);
         break;
+    case app::Clusters::OvenMode::Id:
+        ChipLogProgress(Zcl, "OvenMode cluster ID: " ChipLogFormatMEI " Type: %u Value: %u, length %u",
+                        ChipLogValueMEI(attributeId), type, *value, size);
+        OvenManager::GetInstance().OvenModeAttributeChangeHandler(attributePath.mEndpointId, attributeId, value, size);
+        break;
     default:
         break;
     }

examples/oven-app/silabs/src/OvenManager.cpp

@@ -22,6 +22,10 @@
 #include "CookTopEndpoint.h"
 #include "OvenEndpoint.h"
 
+#include <app-common/zap-generated/cluster-objects.h>
+#include <app-common/zap-generated/attributes/Accessors.h>
+#include <app/clusters/mode-base-server/mode-base-cluster-objects.h>
+
 #include "AppConfig.h"
 #include "AppTask.h"
 
@@ -50,6 +54,24 @@ void OvenManager::Init()
 
     VerifyOrReturn(mCookTopEndpoint.Init() == CHIP_NO_ERROR, ChipLogError(AppServer, "CookTopEndpoint Init failed"));
 
+    // Initialize TemperatureControl cluster numeric temperature attributes for endpoint 2 (silent on failure)
+    {
+    Status tcStatus = TemperatureControl::Attributes::TemperatureSetpoint::Set(kTemperatureControlledCabinetEndpoint2, 0);
+    VerifyOrReturn(tcStatus == Status::Success,
+               ChipLogError(AppServer, "Endpoint2 TemperatureSetpoint init failed"));
+
+    tcStatus = TemperatureControl::Attributes::MinTemperature::Set(kTemperatureControlledCabinetEndpoint2, 0);
+    VerifyOrReturn(tcStatus == Status::Success,
+               ChipLogError(AppServer, "Endpoint2 MinTemperature init failed"));
+
+    tcStatus = TemperatureControl::Attributes::MaxTemperature::Set(kTemperatureControlledCabinetEndpoint2, 30000);
+    VerifyOrReturn(tcStatus == Status::Success,
+               ChipLogError(AppServer, "Endpoint2 MaxTemperature init failed"));
+
+    tcStatus = TemperatureControl::Attributes::Step::Set(kTemperatureControlledCabinetEndpoint2, 500);
+    VerifyOrReturn(tcStatus == Status::Success, ChipLogError(AppServer, "Endpoint2 Step init failed"));
+    }
+
     // Register the shared TemperatureLevelsDelegate for all the cooksurface endpoints
     TemperatureControl::SetInstance(&mTemperatureControlDelegate);
 
@@ -123,24 +145,20 @@ CHIP_ERROR OvenManager::SetTemperatureControlledCabinetInitialState(EndpointId t
 
 void OvenManager::TempCtrlAttributeChangeHandler(EndpointId endpointId, AttributeId attributeId, uint8_t * value, uint16_t size)
 {
-    if (endpointId == kTemperatureControlledCabinetEndpoint2)
-    {
-        // Handle temperature control attribute changes for the temperature-controlled cabinet
-    }
-    else if (endpointId == kCookSurfaceEndpoint4 || endpointId == kCookSurfaceEndpoint5)
+    if (endpointId == kCookSurfaceEndpoint4 || endpointId == kCookSurfaceEndpoint5)
     {
         // Handle temperature control attribute changes for the cook surface endpoints
         if (*value == 0) // low
         {
-
+            // TODO: Adjust the temperature-setpoint value in TemperatureControl Cluster accordingly
         }
         else if (*value == 1) // medium
         {
-
+            // TODO: Adjust the temperature-setpoint value in TemperatureControl Cluster accordingly
         }
         else if (*value == 2) // high
         {
-
+            // TODO: Adjust the temperature-setpoint value in TemperatureControl Cluster accordingly
         }
     }
     return;
@@ -160,11 +178,8 @@ void OvenManager::OnOffAttributeChangeHandler(EndpointId endpointId, AttributeId
     else if (endpointId == kCookSurfaceEndpoint4 || endpointId == kCookSurfaceEndpoint5)
     {
         // Handle On/Off attribute changes for the cook surface endpoints
-        ChipLogProgress(AppServer, "OnOff command received for endpoint : %d", endpointId);
         bool cookSurfaceEndpoint4State = mCookSurfaceEndpoint4.GetOnOffState();
         bool cookSurfaceEndpoint5State = mCookSurfaceEndpoint5.GetOnOffState();
-        ChipLogProgress(AppServer, "ep4 OnOff state : %d", cookSurfaceEndpoint4State);
-        ChipLogProgress(AppServer, "ep5 OnOff state : %d", cookSurfaceEndpoint5State);
         // Check if both cooksurfaces are off. If yes, turn off the cooktop (call cooktop.TurnOffCookTop)
         if (cookSurfaceEndpoint4State == false && cookSurfaceEndpoint5State == false)
         {
@@ -174,6 +189,13 @@ void OvenManager::OnOffAttributeChangeHandler(EndpointId endpointId, AttributeId
     return;
 }
 
+void OvenManager::OvenModeAttributeChangeHandler(chip::EndpointId endpointId, chip::AttributeId attributeId, uint8_t * value, uint16_t size)
+{
+    VerifyOrReturn(endpointId == kTemperatureControlledCabinetEndpoint2, 
+                    ChipLogError(AppServer, "Command received over Unsupported Endpoint"));
+    // TODO: Update the LCD with the new Oven Mode
+    return;
+}
 
 void OvenManager::SetCallbacks(Callback_fn_initiated aActionInitiated_CB, Callback_fn_completed aActionCompleted_CB)
 {
@@ -246,3 +268,86 @@ void OvenManager::ActuatorMovementHandler(AppEvent * aEvent)
         }
     }
 }
+
+// ---------------- Oven Mode Handling ----------------
+
+namespace {
+struct BlockedTransition
+{
+    uint8_t fromMode;
+    uint8_t toMode;
+};
+
+// Disallowed OvenMode Transitions.
+static constexpr BlockedTransition kBlockedTransitions[] = {
+    { TemperatureControlledCabinet::OvenModeDelegate::kModeGrill, TemperatureControlledCabinet::OvenModeDelegate::kModeProofing },
+    { TemperatureControlledCabinet::OvenModeDelegate::kModeProofing, TemperatureControlledCabinet::OvenModeDelegate::kModeClean },
+    { TemperatureControlledCabinet::OvenModeDelegate::kModeClean, TemperatureControlledCabinet::OvenModeDelegate::kModeBake },
+};
+
+static bool IsTransitionBlocked(uint8_t fromMode, uint8_t toMode)
+{
+    for (auto const & bt : kBlockedTransitions)
+    {
+        if (bt.fromMode == fromMode && bt.toMode == toMode)
+        {
+            return true;
+        }
+    }
+    return false;
+}
+} // namespace
+
+void OvenManager::ProcessOvenModeChange(chip::EndpointId endpointId, uint8_t newMode,
+                                        chip::app::Clusters::ModeBase::Commands::ChangeToModeResponse::Type & response)
+{
+    using namespace chip::app::Clusters;
+    using chip::Protocols::InteractionModel::Status;
+    ChipLogProgress(AppServer, "OvenManager::ProcessOvenModeChange ep=%u newMode=%u", endpointId, newMode);
+
+    // 1. Verify newMode is among supported modes
+    bool supported = TemperatureControlledCabinet::OvenModeDelegate::IsSupportedMode(newMode);
+    if (!supported)
+    {
+        response.status = to_underlying(ModeBase::StatusCode::kUnsupportedMode);
+        return;
+    }
+
+    // 2. Read current mode
+    uint8_t currentMode;
+    Status attrStatus   = OvenMode::Attributes::CurrentMode::Get(endpointId, &currentMode);
+    if (attrStatus != Status::Success)
+    {
+    ChipLogError(AppServer, "OvenManager: Failed to read CurrentMode");
+        response.status = to_underlying(ModeBase::StatusCode::kGenericFailure);
+        response.statusText.SetValue(CharSpan::fromCharString("Read CurrentMode failed"));
+        return;
+    }
+
+    // 3. No-op
+    if (currentMode == newMode)
+    {
+        response.status = to_underlying(ModeBase::StatusCode::kSuccess);
+        return;
+    }
+
+    // 4. Policy check
+    if (IsTransitionBlocked(currentMode, newMode))
+    {
+        ChipLogProgress(AppServer, "OvenManager: Blocked transition %u -> %u", currentMode, newMode);
+        response.status = to_underlying(ModeBase::StatusCode::kGenericFailure);
+        response.statusText.SetValue(CharSpan::fromCharString("Transition blocked"));
+        return;
+    }
+
+    // 5. Write new mode
+    Status writeStatus = OvenMode::Attributes::CurrentMode::Set(endpointId, newMode);
+    if (writeStatus != Status::Success)
+    {
+    ChipLogError(AppServer, "OvenManager: Failed to write CurrentMode");
+        response.status = to_underlying(ModeBase::StatusCode::kGenericFailure);
+        response.statusText.SetValue(CharSpan::fromCharString("Write CurrentMode failed"));
+        return;
+    }
+    response.status = to_underlying(ModeBase::StatusCode::kSuccess);
+}