Commands implementation

Author: arun-silabs

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

@@ -39,7 +39,17 @@ class CookSurfaceEndpoint
      */
     CHIP_ERROR Init();
 
-    void HandleOffCommand();
+    /**
+     * @brief Returns the cached current On/Off state without querying attributes.
+     */
+    bool CurrentState() const { return currentOnOffState; }
+
+    bool GetOnOffState();
+
+    /**
+     * @brief Set On/Off state for the CookSurface.
+     */
+    void SetOnOffState(bool state);
 
     EndpointId GetEndpointId() const { return mEndpointId; }
 

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

@@ -38,7 +38,10 @@ class CookTopEndpoint
      */
     CHIP_ERROR Init();
 
-    void HandleOffCommand();
+    /**
+     * @brief Handle the "off" command for the cooktop.
+     */
+    void SetOnOffState(bool state);
 
 private:
     bool currentOnOffState = false;

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

@@ -17,14 +17,34 @@
  */
 
 #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()
 {
+    bool state = false;
+    OnOffServer::Instance().getOnOffValue(mEndpointId, &state);
+    currentOnOffState = state;
     return CHIP_NO_ERROR;
 }
 
-void CookSurfaceEndpoint::HandleOffCommand() {}
+bool CookSurfaceEndpoint::GetOnOffState()
+{
+    bool state = false;
+    OnOffServer::Instance().getOnOffValue(mEndpointId, &state);
+    return state;
+}
+
+void CookSurfaceEndpoint::SetOnOffState(bool state)
+{
+    CommandId commandId = state ? OnOff::Commands::On::Id : OnOff::Commands::Off::Id;
+    auto status = OnOffServer::Instance().setOnOffValue(mEndpointId, commandId, false);
+    if (status == chip::Protocols::InteractionModel::Status::Success)
+    {
+        currentOnOffState = state;
+    }
+}

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

@@ -27,4 +27,13 @@ CHIP_ERROR CookTopEndpoint::Init()
     return CHIP_NO_ERROR;
 }
 
-void CookTopEndpoint::HandleOffCommand() {}
+void CookTopEndpoint::SetOnOffState(bool state)
+{
+    CommandId commandId = state ? OnOff::Commands::On::Id : OnOff::Commands::Off::Id;
+    auto status = OnOffServer::Instance().setOnOffValue(mEndpointId, commandId, false);
+    if (status == chip::Protocols::InteractionModel::Status::Success)
+    {
+        currentOnOffState = state;
+    }
+    return;
+}

examples/oven-app/silabs/BUILD.gn

@@ -76,6 +76,8 @@ if (wifi_soc) {
       "${examples_plat_dir}",
       "${chip_root}/src/lib",
       "${examples_common_plat_dir}",
+      # Added for oven app Option A: expose shared oven-app-common headers to all upstream targets
+      "${example_oven_dir}/oven-app-common/include",
     ]
 
     defines = []

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

@@ -35,6 +35,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
@@ -81,6 +82,9 @@ class AppTask : public BaseApplication
 private:
     static AppTask sAppTask;
 
+    static void ActionInitiated(OvenManager::Action_t aAction, int32_t aActor, uint8_t * value);
+    static void ActionCompleted(OvenManager::Action_t aAction);
+
     /**
      * @brief Override of BaseApplication::AppInit() virtual method, called by BaseApplication::Init()
      *

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

@@ -27,14 +27,41 @@
 #pragma once
 
 #include "AppSupportedTemperatureLevelsDelegate.h"
-#include "CookSurfaceEndpoint.h"
-#include "CookTopEndpoint.h"
+// Corrected relative paths (silabs/include -> go up two levels to oven-app root)
 #include "OvenEndpoint.h"
+#include "CookTopEndpoint.h"
+#include "CookSurfaceEndpoint.h"
+
+#include "AppEvent.h"
+
+#include <app-common/zap-generated/ids/Attributes.h>
+#include <app/clusters/on-off-server/on-off-server.h>
 #include <lib/core/DataModelTypes.h>
 
 class OvenManager
 {
 public:
+    enum Action_t
+    {
+        ON_ACTION = 0,
+        OFF_ACTION,
+
+        INVALID_ACTION
+    } Action;
+
+    enum State_t
+    {
+        kState_OffInitiated = 0,
+        kState_OffCompleted,
+        kState_OnInitiated,
+        kState_OnCompleted,
+    } State;
+
+    bool InitiateAction(int32_t aActor, Action_t aAction, uint8_t * aValue);
+    typedef void (*Callback_fn_initiated)(Action_t, int32_t aActor, uint8_t * value);
+    typedef void (*Callback_fn_completed)(Action_t);
+    void SetCallbacks(Callback_fn_initiated aActionInitiated_CB, Callback_fn_completed aActionCompleted_CB);
+
     /**
      * @brief Initializes the OvenManager and its associated resources.
      *
@@ -51,11 +78,20 @@ class OvenManager
     CHIP_ERROR SetCookSurfaceInitialState(chip::EndpointId cookSurfaceEndpoint);
 
     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);
 
 private:
     static OvenManager sOvenMgr;
     chip::app::Clusters::AppSupportedTemperatureLevelsDelegate mTemperatureControlDelegate;
 
+    State_t mState;
+
+    Callback_fn_initiated mActionInitiated_CB;
+    Callback_fn_completed mActionCompleted_CB;
+
+    static void ActuatorMovementHandler(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/AppTask.cpp

@@ -70,9 +70,9 @@ CHIP_ERROR AppTask::AppInit()
     GetLCD().Init((uint8_t *) "Oven-App");
 #endif
 
-    // Initialization of Oven Manager and endpoints of oven and ovenpanel.
+    // Initialization of Oven Manager and endpoints of oven.
     OvenManager::GetInstance().Init();
-
+    OvenManager::GetInstance().SetCallbacks(ActionInitiated, ActionCompleted);
 // Update the LCD with the Stored value. Show QR Code if not provisioned
 #ifdef DISPLAY_ENABLED
     GetLCD().WriteDemoUI(false);
@@ -129,3 +129,41 @@ void AppTask::ButtonEventHandler(uint8_t button, uint8_t btnAction)
     button_event.Handler            = BaseApplication::ButtonHandler;
     AppTask::GetAppTask().PostEvent(&button_event);
 }
+
+void AppTask::ActionInitiated(OvenManager::Action_t aAction, int32_t aActor, uint8_t * aValue)
+{
+    // Action initiated
+    bool lightOn = aAction == OvenManager::ON_ACTION;
+    SILABS_LOG("Turning light %s", (lightOn) ? "On" : "Off");
+
+    //TODO: Update LED state
+
+#ifdef DISPLAY_ENABLED
+    sAppTask.GetLCD().WriteDemoUI(lightOn);
+#endif
+
+    if (aActor == AppEvent::kEventType_Button)
+    {
+        sAppTask.mSyncClusterToButtonAction = true;
+    }
+}
+
+void AppTask::ActionCompleted(OvenManager::Action_t aAction)
+{
+    // action has been completed on the oven
+    if (aAction == OvenManager::ON_ACTION)
+    {
+        SILABS_LOG("Oven ON")
+    }
+    else if (aAction == OvenManager::OFF_ACTION)
+    {
+        SILABS_LOG("Oven OFF")
+    }
+
+    if (sAppTask.mSyncClusterToButtonAction)
+    {
+        // chip::DeviceLayer::PlatformMgr().ScheduleWork(UpdateClusterState, reinterpret_cast<intptr_t>(nullptr));
+        // Schedule work to Update CookTop and CookSurfaceEndpoints (turn on/off)
+        sAppTask.mSyncClusterToButtonAction = false;
+    }
+}

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

@@ -22,6 +22,7 @@
 
 #include <AppConfig.h>
 
+#include "OvenManager.h"
 #include <app-common/zap-generated/attributes/Accessors.h>
 #include <app-common/zap-generated/callback.h>
 #include <app-common/zap-generated/cluster-objects.h>
@@ -36,11 +37,24 @@ using namespace ::chip;
 void MatterPostAttributeChangeCallback(const app::ConcreteAttributePath & attributePath, uint8_t type, uint16_t size,
                                        uint8_t * value)
 {
-    switch (attributePath.mClusterId)
+    ClusterId clusterId     = attributePath.mClusterId;
+    AttributeId attributeId = attributePath.mAttributeId;
+    switch (clusterId)
     {
     case app::Clusters::Identify::Id:
         ChipLogProgress(Zcl, "Identify cluster ID: " ChipLogFormatMEI " Type: %u Value: %u, length %u",
-                        ChipLogValueMEI(attributePath.mAttributeId), type, *value, size);
+                        ChipLogValueMEI(attributeId), type, *value, size);
+        break;
+    case app::Clusters::OnOff::Id:
+        ChipLogProgress(Zcl, "OnOff cluster ID: " ChipLogFormatMEI " Type: %u Value: %u, length %u",
+                        ChipLogValueMEI(attributeId), type, *value, size);
+        ChipLogProgress(Zcl, "OnOff received for endpoint: %d", attributePath.mEndpointId);
+        OvenManager::GetInstance().OnOffAttributeChangeHandler(attributePath.mEndpointId, attributeId, value, size);
+        break;
+    case app::Clusters::TemperatureControl::Id:
+        ChipLogProgress(Zcl, "TemperatureControl cluster ID: " ChipLogFormatMEI " Type: %u Value: %u, length %u",
+                        ChipLogValueMEI(attributeId), type, *value, size);
+        OvenManager::GetInstance().TempCtrlAttributeChangeHandler(attributePath.mEndpointId, attributeId, value, size);
         break;
     default:
         break;