Valve: Disco ball - Handle automatic close

Author: cecille

src/app/clusters/valve-configuration-and-control-server/valve-configuration-and-control-cluster-logic.cpp

@@ -457,13 +457,44 @@ CHIP_ERROR ClusterLogic::HandleOpenCommand(std::optional<DataModel::Nullable<Ela
 void ClusterLogic::HandleCloseInternal()
 {
     // TODO: call the delegate and add to tests
-    // TODO: Handle error returns on the delegate.
-
+    CHIP_ERROR err;
+    BitMask<ValveFaultBitmap> faults;
+    if (mConformance.HasFeature(Feature::kLevel))
+    {
+        Percent currentLevel;
+        err = mClusterDriver.HandleCloseValve(currentLevel, faults);
+        if (err == CHIP_NO_ERROR)
+        {
+            mState.SetCurrentLevel(DataModel::Nullable<Percent>(currentLevel));
+            if (currentLevel == 0)
+            {
+                mState.SetCurrentState(DataModel::Nullable<ValveStateEnum>(ValveStateEnum::kClosed));
+            }
+            else
+            {
+                mState.SetCurrentState(DataModel::Nullable<ValveStateEnum>(ValveStateEnum::kTransitioning));
+            }
+        }
+    }
+    else
+    {
+        ValveStateEnum state;
+        err = mClusterDriver.HandleCloseValve(state, faults);
+        if (err == CHIP_NO_ERROR)
+        {
+            mState.SetCurrentState(state);
+        }
+    }
+    // If there was an error, we know nothing about the current state
+    if (err != CHIP_NO_ERROR)
+    {
+        mState.SetCurrentLevel(DataModel::NullNullable);
+        mState.SetCurrentState(DataModel::NullNullable);
+    }
+    mState.SetValveFault(faults);
     mState.SetOpenDuration(DataModel::NullNullable);
     mState.SetRemainingDuration(DataModel::NullNullable);
-    mState.SetCurrentLevel(DataModel::Nullable<Percent>(0));
     mState.SetTargetLevel(DataModel::NullNullable);
-    mState.SetCurrentState(DataModel::Nullable<ValveStateEnum>(ValveStateEnum::kClosed));
     mState.SetTargetState(DataModel::NullNullable);
     mState.SetAutoCloseTime(DataModel::NullNullable);
 }

src/app/clusters/valve-configuration-and-control-server/valve-configuration-and-control-delegate.h

@@ -59,13 +59,6 @@ class DelegateBase
     DelegateBase(){};
     virtual ~DelegateBase() = default;
 
-    // TODO: Remove these
-    virtual DataModel::Nullable<chip::Percent> HandleOpenValve(DataModel::Nullable<chip::Percent> level)
-    {
-        return DataModel::NullNullable;
-    }
-    virtual void HandleRemainingDurationTick(uint32_t duration) {}
-
     // This delegate function will be called only for valve implementations that support the LVL feature.
     // Delegates for valves that do not support the LVL feature return CHIP_ERROR_NOT_IMPLEMENTED.
     // When this function is called, the delegate should set the valve to the target level, or begin the async process of opening
@@ -89,7 +82,7 @@ class DelegateBase
     // When this function is called, the delegate should open the valve, or begin the async process of opening the valve.
     // If the valve is able to be opened (success)
     //    - If the valve is fully open, currentState should be set to kOpen
-    //    - If the valve is not fully opened, the delegate should set the currentLevel to the current valve level and the caller
+    //    - If the valve is not fully opened, the delegate should set the currentState to kTransitioning and the caller
     //    will continue to query the valve level until the target level is reached or the valve is closed.
     //  - A valve fault may be returned even if the Open command is successful, if the fault did not prevent the valve from safely
     //  opening
@@ -103,7 +96,41 @@ class DelegateBase
     virtual Percent GetCurrentValveLevel() = 0;
     // This delegate function will be called only for valve implementations that do not support the LVL feature.
     virtual ValveStateEnum GetCurrentValveState() = 0;
-    virtual CHIP_ERROR HandleCloseValve()         = 0;
+
+    // This delegate function will be called when the valve needs to be closed either due to an explicit command or
+    // from the expiration of the open duration. This function will be called for valves that support the LVL feature.
+    // Delegates for valves that do not support the LVL feature should return CHIP_ERROR_NOT_IMPLEMENTED.
+    // When this function is called, the delegate should close the valve, or begin the async process of closing.
+    // If the valve is able to be closed (success)
+    //  - the delegate should set currentLevel
+    //    - If the valve is fully closed, currentLevel should be set to 0
+    //    - If the valve is not fully closed, the delegate should set the currentLevel to the current valve level and the caller
+    //    will continue to query the valve level until the valve reaches 0 or a command overrides.
+    //  - A valve fault may be returned even if the Open command is successful, if the fault did not prevent the valve from safely
+    //  closing
+    //  - return CHIP_NO_ERROR
+    // If the valve cannot be closed (failure)
+    //  - The delegate should set the valveFault parameter to indicate the reason for the failure (if applicable)
+    //  - The delegate should return a CHIP_ERROR_INTERNAL
+    virtual CHIP_ERROR HandleCloseValve(Percent & currentLevel, BitMask<ValveFaultBitmap> & valveFault) = 0;
+
+    // This delegate function will be called when the valve needs to be closed either due to an explicit command or
+    // from the expiration of the open duration.
+    // This delegate function will be called only for valve implementations that DO NOT support the LVL feature.
+    // Delegates for valves that support the LVL feature should return CHIP_ERROR_NOT_IMPLEMENTED.
+    // When this function is called, the delegate should close the valve, or begin the async process of closing.
+    // If the valve is able to be closed (success)
+    //    - If the valve is fully closed, currentState should be set to kClosed
+    //    - If the valve is not fully opened, the delegate should set the currentLevel to the current valve level and the caller
+    //    will continue to query the valve level until the target level is reached or the valve is closed.
+    //  - A valve fault may be returned even if the Open command is successful, if the fault did not prevent the valve from safely
+    //  opening
+    //  - return CHIP_NO_ERROR
+    // If the valve cannot be safely opened (failure)
+    //  - The delegate should set the valveFault parameter to indicate the reason for the failure (if applicable)
+    //  - The delegate should return a CHIP_ERROR_INTERNAL
+    virtual CHIP_ERROR HandleCloseValve(ValveStateEnum & currentState, BitMask<ValveFaultBitmap> & valveFault) = 0;
+
     virtual DelegateType GetDelegateType() { return DelegateType::kBase; };
 };
 
@@ -112,26 +139,38 @@ class LevelControlDelegate : public DelegateBase
     virtual CHIP_ERROR HandleOpenValve(const Percent targetLevel, Percent & currentLevel,
                                        BitMask<ValveFaultBitmap> & valveFault) = 0;
 
-    virtual Percent GetCurrentValveLevel() = 0;
+    virtual Percent GetCurrentValveLevel()                                                              = 0;
+    virtual CHIP_ERROR HandleCloseValve(Percent & currentLevel, BitMask<ValveFaultBitmap> & valveFault) = 0;
 
     // Final overrides - the driver should not implement these classes
     CHIP_ERROR HandleOpenValve(ValveStateEnum & currentState, BitMask<ValveFaultBitmap> & valveFault) final
     {
         return CHIP_ERROR_NOT_IMPLEMENTED;
     }
+    CHIP_ERROR HandleCloseValve(ValveStateEnum & currentState, BitMask<ValveFaultBitmap> & valveFault) final
+    {
+        return CHIP_ERROR_NOT_IMPLEMENTED;
+    }
+
     ValveStateEnum GetCurrentValveState() final { return ValveStateEnum::kUnknownEnumValue; }
     DelegateType GetDelegateType() final { return DelegateType::kLevel; };
 };
 
 class NonLevelControlDelegate : public DelegateBase
 {
-    virtual CHIP_ERROR HandleOpenValve(ValveStateEnum & currentState, BitMask<ValveFaultBitmap> & valveFault) = 0;
-    virtual ValveStateEnum GetCurrentValveState()                                                             = 0;
+    virtual CHIP_ERROR HandleOpenValve(ValveStateEnum & currentState, BitMask<ValveFaultBitmap> & valveFault)  = 0;
+    virtual ValveStateEnum GetCurrentValveState()                                                              = 0;
+    virtual CHIP_ERROR HandleCloseValve(ValveStateEnum & currentState, BitMask<ValveFaultBitmap> & valveFault) = 0;
 
     CHIP_ERROR HandleOpenValve(const Percent targetLevel, Percent & currentLevel, BitMask<ValveFaultBitmap> & valveFault) final
     {
         return CHIP_ERROR_NOT_IMPLEMENTED;
     }
+    CHIP_ERROR HandleCloseValve(Percent & currentLevel, BitMask<ValveFaultBitmap> & valveFault) final
+    {
+        return CHIP_ERROR_NOT_IMPLEMENTED;
+    }
+
     Percent GetCurrentValveLevel() final { return 0; }
     DelegateType GetDelegateType() final { return DelegateType::kNonLevel; };
 };