Merge branch 'master' into TC-SC-4.1-automation-latest

Author: raul-marquez-csa

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;
 

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;

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");
+    }
 }

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;
+}

integrations/docker/images/chip-cert-bins/Dockerfile

@@ -302,7 +302,29 @@ FROM ubuntu:24.04
 ENV TZ=Etc/UTC
 RUN ln -snf /usr/share/zoneinfo/$TZ /etc/localtime && echo $TZ > /etc/timezone
 RUN apt-get update -y
-RUN apt-get install -y libssl-dev libdbus-1-dev libglib2.0-dev libavahi-client-dev avahi-utils iproute2 libcairo2-dev libgirepository1.0-dev python3-pip libpcsclite-dev libpcsclite1 pcscd libcurl4 libgstreamer1.0-0 libgstreamer-plugins-base1.0-0 libavformat60 libavcodec60 libavutil58
+RUN apt-get install -y           \
+  avahi-utils                    \
+  gstreamer1.0-plugins-good      \
+  gstreamer1.0-plugins-ugly      \
+  iproute2                       \
+  libavahi-client-dev            \
+  libavcodec60                   \
+  libavformat60                  \
+  libavutil58                    \
+  libcairo2-dev                  \
+  libcurl4                       \
+  libdbus-1-dev                  \
+  libgirepository1.0-dev         \
+  libglib2.0-dev                 \
+  libgstreamer1.0-0              \
+  libgstreamer-plugins-base1.0-0 \
+  libpcsclite1                   \
+  libpcsclite-dev                \
+  libssl-dev                     \
+  pcscd                          \
+  python3-pip
+
+
 WORKDIR /root/
 COPY --from=chip-build-cert-bins /root/.sdk-sha-version .sdk-sha-version
 RUN mkdir apps

scripts/py_matter_idl/matter/idl/generators/cpp/sdk/Ids.h.jinja

@@ -1,11 +1,10 @@
 // DO NOT EDIT MANUALLY - Generated file
 //
-// Identifier constant values for cluster {{cluster.name}} (cluster code: {{"%d/0x04%X" | format(cluster.code, cluster.code)}})
+// Identifier constant values for cluster {{cluster.name}} (cluster code: {{"%d/0x%04X" | format(cluster.code, cluster.code)}})
 // based on {{input_name}}
 #pragma once
 
 #include <clusters/{{cluster.name}}/AttributeIds.h>
 #include <clusters/{{cluster.name}}/ClusterId.h>
 #include <clusters/{{cluster.name}}/CommandIds.h>
 #include <clusters/{{cluster.name}}/EventIds.h>
-

scripts/tests/local.py

@@ -997,8 +997,8 @@ def as_runner(path):
                             f.write(result.stderr)
 
                     else:
-                        logging.info("STDOUT:\n%s", result.stdout.decode("utf8"))
-                        logging.warning("STDERR:\n%s", result.stderr.decode("utf8"))
+                        logging.info("STDOUT:\n%s", result.stdout.decode("utf8", errors='replace'))
+                        logging.warning("STDERR:\n%s", result.stderr.decode("utf8", errors='replace'))
                     if not keep_going:
                         sys.exit(1)
                     failed_tests.append(script)

scripts/tests/run_python_test.py

@@ -333,7 +333,7 @@ def main_impl(app: str, factory_reset: bool, factory_reset_app_only: bool, app_a
 
         if quiet:
             if exit_code:
-                sys.stdout.write(stream_output.getvalue().decode('utf-8'))
+                sys.stdout.write(stream_output.getvalue().decode('utf-8', errors='replace'))
             else:
                 logging.info("Test completed successfully")
 

scripts/tools/esp32_log_cat.py

@@ -64,7 +64,7 @@ def Log(self, raw):
 
         if raw.startswith(b'\x1b['):
             raw = raw[raw.find(b'm')+1:]
-        raw = raw.decode('utf8').strip()
+        raw = raw.decode('utf8', errors='replace').strip()
 
         self.ExtractSeverity(raw)