[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 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);
 
 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[];
@@ -89,6 +96,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/oven-app.matter

@@ -2589,5 +2589,3 @@ endpoint 5 {
     ram      attribute clusterRevision default = 4;
   }
 }
-
-

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

@@ -17,14 +17,31 @@
  */
 
 #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()
 {
     return CHIP_NO_ERROR;
 }
 
-void CookSurfaceEndpoint::HandleOffCommand() {}
+chip::Protocols::InteractionModel::Status CookSurfaceEndpoint::GetOnOffState(bool & state)
+{
+    auto status = OnOffServer::Instance().getOnOffValue(mEndpointId, &state);
+    VerifyOrReturnValue(status == Protocols::InteractionModel::Status::Success, status,
+                        ChipLogError(AppServer, "ERR: reading on/off %x", to_underlying(status)));
+    return status;
+}
+
+chip::Protocols::InteractionModel::Status CookSurfaceEndpoint::SetOnOffState(bool state)
+{
+    CommandId commandId = state ? OnOff::Commands::On::Id : OnOff::Commands::Off::Id;
+    auto status         = OnOffServer::Instance().setOnOffValue(mEndpointId, commandId, false);
+    VerifyOrReturnValue(status == Protocols::InteractionModel::Status::Success, status,
+                        ChipLogError(AppServer, "ERR: updating on/off %x", to_underlying(status)));
+    return status;
+}

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

@@ -27,4 +27,11 @@ CHIP_ERROR CookTopEndpoint::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;
+    auto status         = OnOffServer::Instance().setOnOffValue(mEndpointId, commandId, false);
+    VerifyOrReturnValue(status == Protocols::InteractionModel::Status::Success, status,
+                        ChipLogError(AppServer, "ERR: updating on/off %x", to_underlying(status)));
+    return status;
+}

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>
@@ -92,8 +95,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 +180,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);
 };

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

@@ -31,11 +31,28 @@
 #include "CookSurfaceEndpoint.h"
 #include "CookTopEndpoint.h"
 #include "OvenEndpoint.h"
+
+#include "AppEvent.h"
+
+#include <app-common/zap-generated/ids/Attributes.h>
+#include <app/clusters/mode-base-server/mode-base-cluster-objects.h>
+#include <app/clusters/on-off-server/on-off-server.h>
 #include <lib/core/DataModelTypes.h>
+#include <lib/support/TypeTraits.h>
+#include <platform/CHIPDeviceLayer.h>
 
 class OvenManager
 {
+
 public:
+    enum State_t
+    {
+        kCookTopState_Off = 0,
+        kCookTopState_On,
+        kCookSurfaceState_Off,
+        kCookSurfaceState_On
+    };
+
     /**
      * @brief Initializes the OvenManager and its associated resources.
      *
@@ -52,11 +69,76 @@ class OvenManager
     CHIP_ERROR SetCookSurfaceInitialState(chip::EndpointId cookSurfaceEndpoint);
 
     CHIP_ERROR SetTemperatureControlledCabinetInitialState(chip::EndpointId temperatureControlledCabinetEndpoint);
+    /**
+     * @brief Handles temperature control attribute changes.
+     *
+     * @param endpointId The ID of the endpoint.
+     * @param attributeId The ID of the attribute.
+     * @param value Pointer to the new value.
+     * @param size Size of the new value.
+     */
+    void TempCtrlAttributeChangeHandler(chip::EndpointId endpointId, chip::AttributeId attributeId, uint8_t * value, uint16_t size);
+
+    /**
+     * @brief Handles on/off attribute changes.
+     *
+     * @param endpointId The ID of the endpoint.
+     * @param attributeId The ID of the attribute.
+     * @param value Pointer to the new value.
+     * @param size Size of the new value.
+     */
+    void OnOffAttributeChangeHandler(chip::EndpointId endpointId, chip::AttributeId attributeId, uint8_t * value, uint16_t size);
+
+    /**
+     * @brief Handles oven mode attribute changes.
+     *
+     * @param endpointId The ID of the endpoint.
+     * @param attributeId The ID of the attribute.
+     * @param value Pointer to the new value.
+     * @param size Size of the new value.
+     */
+    void OvenModeAttributeChangeHandler(chip::EndpointId endpointId, chip::AttributeId attributeId, uint8_t * value, uint16_t size);
+
+    /**
+     * @brief Checks if a transition between two oven modes is blocked.
+     *
+     * @param fromMode The current mode.
+     * @param toMode The desired mode.
+     * @return True if the transition is blocked, false otherwise.
+     */
+    bool IsTransitionBlocked(uint8_t fromMode, uint8_t toMode);
 
 private:
+    struct BlockedTransition
+    {
+        uint8_t fromMode;
+        uint8_t toMode;
+    };
+
+    // Disallowed OvenMode Transitions.
+    static constexpr BlockedTransition kBlockedTransitions[3] = {
+        { chip::to_underlying(chip::app::Clusters::TemperatureControlledCabinet::OvenModeDelegate::OvenModes::kModeGrill),
+          chip::to_underlying(chip::app::Clusters::TemperatureControlledCabinet::OvenModeDelegate::OvenModes::kModeProofing) },
+        { chip::to_underlying(chip::app::Clusters::TemperatureControlledCabinet::OvenModeDelegate::OvenModes::kModeProofing),
+          chip::to_underlying(chip::app::Clusters::TemperatureControlledCabinet::OvenModeDelegate::OvenModes::kModeClean) },
+        { chip::to_underlying(chip::app::Clusters::TemperatureControlledCabinet::OvenModeDelegate::OvenModes::kModeClean),
+          chip::to_underlying(chip::app::Clusters::TemperatureControlledCabinet::OvenModeDelegate::OvenModes::kModeBake) },
+    };
+
     static OvenManager sOvenMgr;
     chip::app::Clusters::AppSupportedTemperatureLevelsDelegate mTemperatureControlDelegate;
 
+    State_t mCookTopState;
+    State_t mCookSurfaceState1;
+    State_t mCookSurfaceState2;
+
+    /**
+     * @brief Updates the oven hardware state and UI (LEDs, LCD) in response to an event.
+     *
+     * @param aEvent Pointer to the event structure.
+     */
+    static void OvenActionHandler(AppEvent * aEvent);
+
     // Define the endpoint ID for the Oven
     static constexpr chip::EndpointId kOvenEndpoint                         = 1;
     static constexpr chip::EndpointId kTemperatureControlledCabinetEndpoint = 2;

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

@@ -32,7 +32,6 @@ CHIP_ERROR AppSupportedTemperatureLevelsDelegate::RegisterSupportedLevels(Endpoi
 
     VerifyOrReturnError(mRegisteredEndpointCount < kNumCookSurfaceEndpoints, CHIP_ERROR_NO_MEMORY,
                         ChipLogError(AppServer, "RegisterSupportedLevels: capacity exceeded (%zu)", mRegisteredEndpointCount));
-
     // Prevent duplicate endpoints
     for (size_t i = 0; i < mRegisteredEndpointCount; ++i)
     {