[SL-ONLY] Oven app commands implementation

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

@@ -39,12 +39,40 @@ class CookSurfaceEndpoint
      */
     CHIP_ERROR Init();
 
-    void HandleOffCommand();
+    /**
+     * @brief Gets the current On/Off state from server.
+     * @param state Reference to store the current On/Off state.
+     *
+     * Note: This helper reads the OnOff attribute from the CHIP attribute storage and
+     * therefore must be invoked from the CHIP/DeviceLayer task context or while holding
+     * the CHIP stack lock (DeviceLayer::PlatformMgr().LockChipStack()). Calling this
+     * API from an arbitrary thread can cause asserts / crashes in the CHIP stack.
+     * If you are not in the CHIP task, schedule work onto the CHIP task using
+     * PlatformMgr().ScheduleWork(...) and call this helper from there.
+     *
+     * @return Returns Status::Success on success, or an error code on failure.
+     */
+
+    chip::Protocols::InteractionModel::Status GetOnOffState(bool & state);
+
+    /**
+     * @brief Set On/Off state for the CookSurface.
+     * @param state Desired On/Off state.
+     *
+     * Note: This helper writes the OnOff attribute to the CHIP attribute storage and
+     * therefore must be invoked from the CHIP/DeviceLayer task context or while holding
+     * the CHIP stack lock (DeviceLayer::PlatformMgr().LockChipStack()). Calling this
+     * API from an arbitrary thread can cause asserts / crashes in the CHIP stack.
+     * If you are not in the CHIP task, schedule work onto the CHIP task using
+     * PlatformMgr().ScheduleWork(...) and call this helper from there.
+     *
+     * @return Returns Status::Success on success, or an error code on failure.
+     */
+    chip::Protocols::InteractionModel::Status SetOnOffState(bool state);
 
     EndpointId GetEndpointId() const { return mEndpointId; }
 
 private:
-    bool currentOnOffState = false;
     EndpointId mEndpointId = kInvalidEndpointId;
 };
 

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

@@ -38,7 +38,20 @@ class CookTopEndpoint
      */
     CHIP_ERROR Init();
 
-    void HandleOffCommand();
+    /**
+     * @brief Set On/Off state for the CookTop
+     * @param state Desired On/Off state.
+     *
+     * Note: This helper writes the OnOff attribute to the CHIP attribute storage and
+     * therefore must be invoked from the CHIP/DeviceLayer task context or while holding
+     * the CHIP stack lock (DeviceLayer::PlatformMgr().LockChipStack()). Calling this
+     * API from an arbitrary thread can cause asserts / crashes in the CHIP stack.
+     * If you are not in the CHIP task, schedule work onto the CHIP task using
+     * PlatformMgr().ScheduleWork(...) and call this helper from there.
+     *
+     * @return Returns Status::Success on success, or an error code on failure.
+     */
+    chip::Protocols::InteractionModel::Status SetOnOffState(bool state);
 
 private:
     bool currentOnOffState = false;

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

@@ -57,10 +57,17 @@ 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;
 
+    /**
+     * @brief Checks if the provided mode is supported.
+     *
+     * @param mode The mode to check.
+     * @return true if the mode is supported, false otherwise.
+     */
+    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[];
@@ -77,8 +84,10 @@ class OvenModeDelegate : public ModeBase::Delegate
 class TemperatureControlledCabinetEndpoint
 {
 public:
+    static constexpr uint8_t kModeBaseFeatures = 0; // No specific features for ModeBase::Instance
     TemperatureControlledCabinetEndpoint(EndpointId endpointId) :
-        mEndpointId(endpointId), mOvenModeDelegate(mEndpointId), mOvenModeInstance(&mOvenModeDelegate, mEndpointId, OvenMode::Id, 0)
+        mEndpointId(endpointId), mOvenModeDelegate(mEndpointId),
+        mOvenModeInstance(&mOvenModeDelegate, mEndpointId, OvenMode::Id, kModeBaseFeatures)
     {}
 
     /**
@@ -89,6 +98,13 @@ class TemperatureControlledCabinetEndpoint
      */
     CHIP_ERROR Init();
 
+    /**
+     * @brief Get the oven mode delegate instance.
+     *
+     * @return Reference to the oven mode delegate.
+     */
+    OvenModeDelegate & GetOvenModeDelegate() { return mOvenModeDelegate; }
+
 private:
     EndpointId mEndpointId = kInvalidEndpointId;
     OvenModeDelegate mOvenModeDelegate;

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

@@ -17,14 +17,26 @@
  */
 
 #include "CookSurfaceEndpoint.h"
-#include <lib/core/CHIPError.h>
+#include <app/clusters/on-off-server/on-off-server.h>
+#include <protocols/interaction_model/StatusCode.h>
 
 using namespace chip;
+using namespace chip::app::Clusters;
 using namespace chip::app::Clusters::CookSurface;
 
 CHIP_ERROR CookSurfaceEndpoint::Init()
 {
+    // Placeholder for user Init
     return CHIP_NO_ERROR;
 }
 
-void CookSurfaceEndpoint::HandleOffCommand() {}
+chip::Protocols::InteractionModel::Status CookSurfaceEndpoint::GetOnOffState(bool & state)
+{
+    return OnOffServer::Instance().getOnOffValue(mEndpointId, &state);
+}
+
+chip::Protocols::InteractionModel::Status CookSurfaceEndpoint::SetOnOffState(bool state)
+{
+    CommandId commandId = state ? OnOff::Commands::On::Id : OnOff::Commands::Off::Id;
+    return OnOffServer::Instance().setOnOffValue(mEndpointId, commandId, false);
+}

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

@@ -24,7 +24,12 @@ using namespace chip::app::Clusters::CookTop;
 
 CHIP_ERROR CookTopEndpoint::Init()
 {
+    // Placeholder for user Init
     return CHIP_NO_ERROR;
 }
 
-void CookTopEndpoint::HandleOffCommand() {}
+chip::Protocols::InteractionModel::Status CookTopEndpoint::SetOnOffState(bool state)
+{
+    CommandId commandId = state ? OnOff::Commands::On::Id : OnOff::Commands::Off::Id;
+    return OnOffServer::Instance().setOnOffValue(mEndpointId, commandId, false);
+}

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

@@ -17,7 +17,10 @@
  */
 
 #include "OvenEndpoint.h"
+#include <app-common/zap-generated/attributes/Accessors.h>
 #include <app-common/zap-generated/cluster-objects.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>
@@ -29,59 +32,55 @@ using namespace chip::app::Clusters::Oven;
 using namespace chip::app::Clusters::OvenMode;
 using namespace chip::app::Clusters::TemperatureControlledCabinet;
 using chip::Protocols::InteractionModel::Status;
+using detail::Structs::ModeTagStruct::Type;
 
 // Static member definitions
-const detail::Structs::ModeTagStruct::Type OvenModeDelegate::sModeTagsBake[1] = { { .value = to_underlying(ModeTag::kBake) } };
+const Type OvenModeDelegate::sModeTagsBake[1] = { { .value = to_underlying(ModeTag::kBake) } };
 
-const detail::Structs::ModeTagStruct::Type OvenModeDelegate::sModeTagsConvection[1] = { { .value = to_underlying(
-                                                                                              ModeTag::kConvection) } };
+const Type OvenModeDelegate::sModeTagsConvection[1] = { { .value = to_underlying(ModeTag::kConvection) } };
 
-const detail::Structs::ModeTagStruct::Type OvenModeDelegate::sModeTagsGrill[1] = { { .value = to_underlying(ModeTag::kGrill) } };
+const Type OvenModeDelegate::sModeTagsGrill[1] = { { .value = to_underlying(ModeTag::kGrill) } };
 
-const detail::Structs::ModeTagStruct::Type OvenModeDelegate::sModeTagsRoast[1] = { { .value = to_underlying(ModeTag::kRoast) } };
+const Type OvenModeDelegate::sModeTagsRoast[1] = { { .value = to_underlying(ModeTag::kRoast) } };
 
-const detail::Structs::ModeTagStruct::Type OvenModeDelegate::sModeTagsClean[1] = { { .value = to_underlying(ModeTag::kClean) } };
+const Type OvenModeDelegate::sModeTagsClean[1] = { { .value = to_underlying(ModeTag::kClean) } };
 
-const detail::Structs::ModeTagStruct::Type OvenModeDelegate::sModeTagsConvectionBake[1] = { { .value = to_underlying(
-                                                                                                  ModeTag::kConvectionBake) } };
+const Type OvenModeDelegate::sModeTagsConvectionBake[1] = { { .value = to_underlying(ModeTag::kConvectionBake) } };
 
-const detail::Structs::ModeTagStruct::Type OvenModeDelegate::sModeTagsConvectionRoast[1] = { { .value = to_underlying(
-                                                                                                   ModeTag::kConvectionRoast) } };
+const Type OvenModeDelegate::sModeTagsConvectionRoast[1] = { { .value = to_underlying(ModeTag::kConvectionRoast) } };
 
-const detail::Structs::ModeTagStruct::Type OvenModeDelegate::sModeTagsWarming[1] = { { .value =
-                                                                                           to_underlying(ModeTag::kWarming) } };
+const Type OvenModeDelegate::sModeTagsWarming[1] = { { .value = to_underlying(ModeTag::kWarming) } };
 
-const detail::Structs::ModeTagStruct::Type OvenModeDelegate::sModeTagsProofing[1] = { { .value =
-                                                                                            to_underlying(ModeTag::kProofing) } };
+const Type OvenModeDelegate::sModeTagsProofing[1] = { { .value = to_underlying(ModeTag::kProofing) } };
 
 const detail::Structs::ModeOptionStruct::Type OvenModeDelegate::skModeOptions[to_underlying(OvenModes::kModeCount)] = {
     { .label    = CharSpan::fromCharString("Bake"),
       .mode     = to_underlying(OvenModes::kModeBake),
-      .modeTags = DataModel::List<const detail::Structs::ModeTagStruct::Type>(sModeTagsBake) },
+      .modeTags = DataModel::List<const Type>(sModeTagsBake) },
     { .label    = CharSpan::fromCharString("Convection"),
       .mode     = to_underlying(OvenModes::kModeConvection),
-      .modeTags = DataModel::List<const detail::Structs::ModeTagStruct::Type>(sModeTagsConvection) },
+      .modeTags = DataModel::List<const Type>(sModeTagsConvection) },
     { .label    = CharSpan::fromCharString("Grill"),
       .mode     = to_underlying(OvenModes::kModeGrill),
-      .modeTags = DataModel::List<const detail::Structs::ModeTagStruct::Type>(sModeTagsGrill) },
+      .modeTags = DataModel::List<const Type>(sModeTagsGrill) },
     { .label    = CharSpan::fromCharString("Roast"),
       .mode     = to_underlying(OvenModes::kModeRoast),
-      .modeTags = DataModel::List<const detail::Structs::ModeTagStruct::Type>(sModeTagsRoast) },
+      .modeTags = DataModel::List<const Type>(sModeTagsRoast) },
     { .label    = CharSpan::fromCharString("Clean"),
       .mode     = to_underlying(OvenModes::kModeClean),
-      .modeTags = DataModel::List<const detail::Structs::ModeTagStruct::Type>(sModeTagsClean) },
+      .modeTags = DataModel::List<const Type>(sModeTagsClean) },
     { .label    = CharSpan::fromCharString("Convection Bake"),
       .mode     = to_underlying(OvenModes::kModeConvectionBake),
-      .modeTags = DataModel::List<const detail::Structs::ModeTagStruct::Type>(sModeTagsConvectionBake) },
+      .modeTags = DataModel::List<const Type>(sModeTagsConvectionBake) },
     { .label    = CharSpan::fromCharString("Convection Roast"),
       .mode     = to_underlying(OvenModes::kModeConvectionRoast),
-      .modeTags = DataModel::List<const detail::Structs::ModeTagStruct::Type>(sModeTagsConvectionRoast) },
+      .modeTags = DataModel::List<const Type>(sModeTagsConvectionRoast) },
     { .label    = CharSpan::fromCharString("Warming"),
       .mode     = to_underlying(OvenModes::kModeWarming),
-      .modeTags = DataModel::List<const detail::Structs::ModeTagStruct::Type>(sModeTagsWarming) },
+      .modeTags = DataModel::List<const Type>(sModeTagsWarming) },
     { .label    = CharSpan::fromCharString("Proofing"),
       .mode     = to_underlying(OvenModes::kModeProofing),
-      .modeTags = DataModel::List<const detail::Structs::ModeTagStruct::Type>(sModeTagsProofing) }
+      .modeTags = DataModel::List<const Type>(sModeTagsProofing) }
 };
 
 CHIP_ERROR OvenModeDelegate::Init()
@@ -92,8 +91,50 @@ 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.
+    ChipLogProgress(Zcl, "OvenModeDelegate forwarding mode change to OvenManager (ep=%u newMode=%u)", mEndpointId, NewMode);
+    // Verify newMode is among supported modes
+    bool supported = IsSupportedMode(NewMode);
+    if (!supported)
+    {
+        response.status = to_underlying(ModeBase::StatusCode::kUnsupportedMode);
+        return;
+    }
+
+    // Read Current Oven Mode
+    uint8_t currentMode;
+    Status attrStatus = OvenMode::Attributes::CurrentMode::Get(mEndpointId, &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;
+    }
+
+    // No action needed if current mode is the same as new mode
+    if (currentMode == NewMode)
+    {
+        response.status = to_underlying(ModeBase::StatusCode::kSuccess);
+        return;
+    }
+
+    if (OvenManager::GetInstance().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;
+    }
+
+    // Write new mode
+    Status writeStatus = OvenMode::Attributes::CurrentMode::Set(mEndpointId, 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);
 }
 
@@ -135,3 +176,15 @@ 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/BUILD.gn

@@ -76,6 +76,7 @@ if (wifi_soc) {
       "${examples_plat_dir}",
       "${chip_root}/src/lib",
       "${examples_common_plat_dir}",
+      "${example_oven_dir}/oven-app-common/include",
     ]
 
     defines = []

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

@@ -26,7 +26,10 @@ struct AppEvent : public BaseAppEvent
     enum AppEventTypes
     {
         kEventType_Oven = BaseAppEvent::kEventType_Max + 1,
+        kEventType_CookTop,
+        kEventType_CookSurface,
         kEventType_Install,
+        kEventType_UIUpdate,
     };
 
     union
@@ -35,6 +38,7 @@ struct AppEvent : public BaseAppEvent
         {
             uint8_t Action;
             int32_t Actor;
+            void * Context;
         } OvenEvent;
     };
 };

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

@@ -28,6 +28,7 @@
 
 #include "AppEvent.h"
 #include "BaseApplication.h"
+#include "OvenManager.h"
 
 #include "FreeRTOS.h"
 #include "timers.h" // provides FreeRTOS timer support
@@ -87,13 +88,4 @@ class AppTask : public BaseApplication
      * @return CHIP_ERROR
      */
     CHIP_ERROR AppInit() override;
-
-    /**
-     * @brief PB0 Button event processing function
-     *        Press and hold will trigger a factory reset timer start
-     *        Press and release will restart BLEAdvertising if not commissioned
-     *
-     * @param aEvent button event being processed
-     */
-    static void ButtonHandler(AppEvent * aEvent);
 };