[Silabs] Closure button implementation for silabs paltform (#41455)

sabollim-silabs · restyled-commits · web-flow · commit 4940afb82c44 · 2025-11-06T20:27:36.000Z
* Closure button implementation

* Restyled by whitespace

* Restyled by clang-format

* Addressing PR comments

* addressing PR comments

* PR comments

* Restyled by whitespace

* Restyled by clang-format

* Updated logic to schedulelambda from apptask and remove unnessary chiplocks

* cleanup unnessary changes

* Restyled by whitespace

* Restyled by clang-format

---------

Co-authored-by: Restyled.io &lt;commits@restyled.io&gt;
diff --git a/examples/closure-app/silabs/include/AppTask.h b/examples/closure-app/silabs/include/AppTask.h
@@ -78,6 +78,14 @@ class AppTask : public BaseApplication
      */
     static void ButtonEventHandler(uint8_t button, uint8_t btnAction);
 
+    /**
+     * @brief Closure button action event handler
+     * Handles button press events for closure control operations
+     *
+     * @param aEvent pointer to the button event being processed
+     */
+    static void ClosureButtonActionEventHandler(AppEvent * aEvent);
+
 private:
     static AppTask sAppTask;
 
diff --git a/examples/closure-app/silabs/include/ClosureManager.h b/examples/closure-app/silabs/include/ClosureManager.h
@@ -156,6 +156,23 @@ class ClosureManager
      */
     const Action_t & GetCurrentAction() const { return mCurrentAction; }
 
+    /**
+     * @brief Checks if a MoveTo action is currently in progress.
+     *
+     * @return true if a MoveTo action is in progress, false otherwise.
+     */
+    bool IsClosureControlMotionInProgress() const;
+
+    /**
+     * @brief Gets the ClosureControlEndpoint logic for direct access.
+     *
+     * This allows direct access to the cluster logic methods (e.g., HandleMoveTo)
+     * when called from chip task context (e.g., via ScheduleWork).
+     *
+     * @return Reference to the ClosureControlEndpoint logic.
+     */
+    chip::app::Clusters::ClosureControl::ClusterLogic & GetClosureControlLogic() { return mClosureEndpoint1.GetLogic(); }
+
     /**
      * @brief Sets the initial state for the ClosureControlEndpoint.
      *
@@ -188,10 +205,10 @@ class ClosureManager
     // make them thread-safe using mutex or other synchronization mechanisms. Presently, we use
     // DeviceLayer::PlatformMgr().LockChipStack() and DeviceLayer::PlatformMgr().UnlockChipStack()
     // to ensure that these variables are set in thread safe manner in chip task context.
-    bool isCalibrationInProgress = false;
-    bool isMoveToInProgress      = false;
-    bool isSetTargetInProgress   = false;
-    bool isStepActionInProgress  = false;
+    bool mIsCalibrationInProgress = false;
+    bool mIsMoveToInProgress      = false;
+    bool mIsSetTargetInProgress   = false;
+    bool mIsStepActionInProgress  = false;
 
     Action_t mCurrentAction                   = Action_t::INVALID_ACTION;
     chip::EndpointId mCurrentActionEndpointId = chip::kInvalidEndpointId;
diff --git a/examples/closure-app/silabs/src/AppTask.cpp b/examples/closure-app/silabs/src/AppTask.cpp
@@ -42,6 +42,7 @@
 #include <assert.h>
 #include <lib/support/BitMask.h>
 #include <lib/support/CodeUtils.h>
+#include <lib/support/logging/CHIPLogging.h>
 #include <platform/CHIPDeviceLayer.h>
 #include <platform/silabs/platformAbstraction/SilabsPlatform.h>
 #include <setup_payload/OnboardingCodesUtil.h>
@@ -116,11 +117,11 @@ void AppTask::AppTaskMain(void * pvParameter)
     CHIP_ERROR err = sAppTask.Init();
     if (err != CHIP_NO_ERROR)
     {
-        SILABS_LOG("AppTask.Init() failed");
+        ChipLogError(AppServer, "AppTask Init failed");
         appError(err);
     }
 
-    SILABS_LOG("App Task started");
+    ChipLogProgress(AppServer, "App Task started");
 
     while (true)
     {
@@ -138,6 +139,92 @@ void AppTask::ButtonEventHandler(uint8_t button, uint8_t btnAction)
     AppEvent button_event           = {};
     button_event.Type               = AppEvent::kEventType_Button;
     button_event.ButtonEvent.Action = btnAction;
-    button_event.Handler            = BaseApplication::ButtonHandler;
-    AppTask::GetAppTask().PostEvent(&button_event);
+
+    if (button == APP_CLOSURE_BUTTON && btnAction == static_cast<uint8_t>(SilabsPlatform::ButtonAction::ButtonPressed))
+    {
+        button_event.Handler = ClosureButtonActionEventHandler;
+        sAppTask.PostEvent(&button_event);
+    }
+    else if (button == APP_FUNCTION_BUTTON)
+    {
+        button_event.Handler = BaseApplication::ButtonHandler;
+        sAppTask.PostEvent(&button_event);
+    }
+}
+
+void AppTask::ClosureButtonActionEventHandler(AppEvent * aEvent)
+{
+    if (aEvent->Type == AppEvent::kEventType_Button)
+    {
+        // Schedule work on the chip stack thread to ensure all CHIP API calls are safe
+        chip::DeviceLayer::PlatformMgr().ScheduleWork(
+            [](intptr_t) {
+                // Check if an action is already in progress
+                if (ClosureManager::GetInstance().IsClosureControlMotionInProgress())
+                {
+                    // Stop the current action
+                    auto status = ClosureManager::GetInstance().GetClosureControlLogic().HandleStop();
+                    if (status != Protocols::InteractionModel::Status::Success)
+                    {
+                        ChipLogError(AppServer, "Failed to stop closure action: %u", to_underlying(status));
+                    }
+                }
+                else
+                {
+                    DataModel::Nullable<ClosureControl::GenericOverallCurrentState> currentState;
+                    CHIP_ERROR err = ClosureManager::GetInstance().GetClosureControlLogic().GetOverallCurrentState(currentState);
+
+                    if (err != CHIP_NO_ERROR)
+                    {
+                        ChipLogError(AppServer, "Failed to get current closure state: %s", chip::ErrorStr(err));
+                        return;
+                    }
+                    if (currentState.IsNull())
+                    {
+                        ChipLogError(AppServer, "Failed to get current closure state: currentState is null");
+                        return;
+                    }
+                    if (!currentState.Value().position.HasValue() || currentState.Value().position.Value().IsNull())
+                    {
+                        ChipLogError(AppServer, "Failed to get current closure state: position is null");
+                        return;
+                    }
+
+                    // Get current position and determine target position (toggle)
+                    auto currentPosition = currentState.Value().position.Value().Value();
+                    ChipLogProgress(AppServer, "Current state - Position: %d", to_underlying(currentPosition));
+
+                    ClosureControl::TargetPositionEnum targetPosition =
+                        (currentPosition == ClosureControl::CurrentPositionEnum::kFullyOpened)
+                        ? ClosureControl::TargetPositionEnum::kMoveToFullyClosed
+                        : ClosureControl::TargetPositionEnum::kMoveToFullyOpen;
+                    ChipLogProgress(AppServer, "Target position: %d", to_underlying(targetPosition));
+
+                    Optional<bool> latch = chip::NullOptional;
+                    if (currentState.Value().latch.HasValue() && !currentState.Value().latch.Value().IsNull())
+                    {
+                        latch = MakeOptional(false);
+                    }
+
+                    Optional<Globals::ThreeLevelAutoEnum> speed = NullOptional;
+                    if (currentState.Value().speed.HasValue())
+                    {
+                        speed = chip::MakeOptional(currentState.Value().speed.Value());
+                    }
+
+                    // Move to the target position with latch set to false and preserved speed value
+                    auto status = ClosureManager::GetInstance().GetClosureControlLogic().HandleMoveTo(MakeOptional(targetPosition),
+                                                                                                      latch, speed);
+                    if (status != Protocols::InteractionModel::Status::Success)
+                    {
+                        ChipLogError(AppServer, "Failed to move closure to target position: %u", to_underlying(status));
+                    }
+                }
+            },
+            0);
+    }
+    else
+    {
+        ChipLogError(AppServer, "Unhandled event type in ClosureButtonActionEventHandler");
+    }
 }
diff --git a/examples/closure-app/silabs/src/ClosureManager.cpp b/examples/closure-app/silabs/src/ClosureManager.cpp
@@ -394,32 +394,32 @@ void ClosureManager::HandleClosureActionComplete(Action_t action)
         instance.mClosurePanelEndpoint3.OnCalibrateActionComplete();
 
         DeviceLayer::PlatformMgr().LockChipStack();
-        isCalibrationInProgress = false;
+        mIsCalibrationInProgress = false;
         DeviceLayer::PlatformMgr().UnlockChipStack();
 
         break;
     }
     case Action_t::STOP_ACTION: {
-        if (isCalibrationInProgress)
+        if (mIsCalibrationInProgress)
         {
             ChipLogDetail(AppServer, "Stopping calibration action");
             instance.mClosureEndpoint1.OnStopCalibrateActionComplete();
             instance.mClosurePanelEndpoint2.OnStopCalibrateActionComplete();
             instance.mClosurePanelEndpoint3.OnStopCalibrateActionComplete();
 
             DeviceLayer::PlatformMgr().LockChipStack();
-            isCalibrationInProgress = false;
+            mIsCalibrationInProgress = false;
             DeviceLayer::PlatformMgr().UnlockChipStack();
         }
-        else if (isMoveToInProgress)
+        else if (mIsMoveToInProgress)
         {
             ChipLogDetail(AppServer, "Stopping move to action");
             instance.mClosureEndpoint1.OnStopMotionActionComplete();
             instance.mClosurePanelEndpoint2.OnStopMotionActionComplete();
             instance.mClosurePanelEndpoint3.OnStopMotionActionComplete();
 
             DeviceLayer::PlatformMgr().LockChipStack();
-            isMoveToInProgress = false;
+            mIsMoveToInProgress = false;
             DeviceLayer::PlatformMgr().UnlockChipStack();
         }
         else
@@ -435,7 +435,7 @@ void ClosureManager::HandleClosureActionComplete(Action_t action)
         instance.mClosurePanelEndpoint3.OnMoveToActionComplete();
 
         DeviceLayer::PlatformMgr().LockChipStack();
-        instance.isMoveToInProgress = false;
+        instance.mIsMoveToInProgress = false;
         DeviceLayer::PlatformMgr().UnlockChipStack();
         ChipLogDetail(AppServer, "MoveTo action completed");
         break;
@@ -451,7 +451,7 @@ void ClosureManager::HandleClosureActionComplete(Action_t action)
         }
 
         DeviceLayer::PlatformMgr().LockChipStack();
-        instance.isSetTargetInProgress = false;
+        instance.mIsSetTargetInProgress = false;
         DeviceLayer::PlatformMgr().UnlockChipStack();
         break;
     case Action_t::PANEL_STEP_ACTION:
@@ -466,7 +466,7 @@ void ClosureManager::HandleClosureActionComplete(Action_t action)
         }
 
         DeviceLayer::PlatformMgr().LockChipStack();
-        instance.isStepActionInProgress = false;
+        instance.mIsStepActionInProgress = false;
         DeviceLayer::PlatformMgr().UnlockChipStack();
         break;
     default:
@@ -489,7 +489,7 @@ chip::Protocols::InteractionModel::Status ClosureManager::OnCalibrateCommand()
     DeviceLayer::PlatformMgr().LockChipStack();
     SetCurrentAction(Action_t::CALIBRATE_ACTION);
     mCurrentActionEndpointId = mClosureEndpoint1.GetEndpointId();
-    isCalibrationInProgress  = true;
+    mIsCalibrationInProgress = true;
     DeviceLayer::PlatformMgr().UnlockChipStack();
 
     // Post an event to initiate the calibration action asynchronously.
@@ -654,7 +654,7 @@ chip::Protocols::InteractionModel::Status ClosureManager::OnMoveToCommand(const
     {
         SetCurrentAction(MOVE_TO_ACTION);
     }
-    isMoveToInProgress = true;
+    mIsMoveToInProgress = true;
     DeviceLayer::PlatformMgr().UnlockChipStack();
 
     // Post an event to initiate the move to action asynchronously.
@@ -816,7 +816,7 @@ chip::Protocols::InteractionModel::Status ClosureManager::OnSetTargetCommand(con
 {
     MainStateEnum mClosureEndpoint1MainState;
     VerifyOrReturnError(mClosureEndpoint1.GetLogic().GetMainState(mClosureEndpoint1MainState) == CHIP_NO_ERROR, Status::Failure,
-                        ChipLogError(AppServer, "Failed to get main state for Step command on Endpoint 1"));
+                        ChipLogError(AppServer, "Failed to get main state for SetTarget command on Endpoint 1"));
 
     // If this command is received while the MainState attribute is currently either in Disengaged, Protected, Calibrating,
     //  SetupRequired or Error, then a status code of INVALID_IN_STATE shall be returned.
@@ -827,7 +827,7 @@ chip::Protocols::InteractionModel::Status ClosureManager::OnSetTargetCommand(con
         Status::InvalidInState,
         ChipLogError(AppServer, "Step command not allowed in current state: %d", static_cast<int>(mClosureEndpoint1MainState)));
 
-    if (isSetTargetInProgress && mCurrentActionEndpointId != endpointId)
+    if (mIsSetTargetInProgress && mCurrentActionEndpointId != endpointId)
     {
         ChipLogError(AppServer, "SetTarget action is already in progress on Endpoint %d", mCurrentActionEndpointId);
         return Status::Failure;
@@ -886,7 +886,7 @@ chip::Protocols::InteractionModel::Status ClosureManager::OnSetTargetCommand(con
         SetCurrentAction(Action_t::SET_TARGET_ACTION);
     }
     mCurrentActionEndpointId = endpointId;
-    isSetTargetInProgress    = true;
+    mIsSetTargetInProgress   = true;
     DeviceLayer::PlatformMgr().UnlockChipStack();
 
     AppEvent event;
@@ -1113,7 +1113,7 @@ chip::Protocols::InteractionModel::Status ClosureManager::OnStepCommand(const St
         Status::InvalidInState,
         ChipLogError(AppServer, "Step command not allowed in current state: %d", static_cast<int>(mClosureEndpoint1MainState)));
 
-    if (isStepActionInProgress && mCurrentActionEndpointId != endpointId)
+    if (mIsStepActionInProgress && mCurrentActionEndpointId != endpointId)
     {
         ChipLogError(AppServer, "Step action is already in progress on Endpoint %d", mCurrentActionEndpointId);
         return Status::Failure;
@@ -1145,7 +1145,7 @@ chip::Protocols::InteractionModel::Status ClosureManager::OnStepCommand(const St
     DeviceLayer::PlatformMgr().LockChipStack();
     SetCurrentAction(PANEL_STEP_ACTION);
     mCurrentActionEndpointId = endpointId;
-    isStepActionInProgress   = true;
+    mIsStepActionInProgress  = true;
     DeviceLayer::PlatformMgr().UnlockChipStack();
 
     AppEvent event;
@@ -1284,3 +1284,7 @@ bool ClosureManager::GetPanelNextPosition(const GenericDimensionStateStruct & cu
     }
     return true;
 }
+bool ClosureManager::IsClosureControlMotionInProgress() const
+{
+    return mIsMoveToInProgress;
+}
