Improve error handling

Author: PeterC1965

examples/water-heater-management-app/water-heater-management-common/include/WhmDelegate.h

@@ -174,7 +174,7 @@ class WaterHeaterManagementDelegate : public WaterHeaterManagement::Delegate,
     /**
      * @brief Determine whether the heating sources need to be turned on or off
      */
-    void CheckIfHeatNeedsToBeTurnedOnOrOff();
+    Protocols::InteractionModel::Status CheckIfHeatNeedsToBeTurnedOnOrOff();
 
     /**
      * @brief Static timer callback for when Boost timer expires.

examples/water-heater-management-app/water-heater-management-common/include/WhmManufacturer.h

@@ -70,15 +70,42 @@ class WhmManufacturer
     /**
      * @brief   Turn the heating of the water tank on.
      */
-    void TurnHeatingOn();
+    Protocols::InteractionModel::Status TurnHeatingOn();
 
     /**
      * @brief   Turn the heating of the water tank off.
      */
-    void TurnHeatingOff();
+    Protocols::InteractionModel::Status TurnHeatingOff();
+
+    /**
+     * @brief Called to handle a boost command.
+     *
+     * @param duration  Indicates the time period in seconds for which the BOOST state is activated before it automatically reverts to the previous mode (e.g. OFF, MANUAL or TIMED).
+     * @param oneShot  Indicates whether the BOOST state should be automatically canceled once the hot water has first reached the set point temperature (or the TemporarySetpoint temperature, if specified) for the TargetPercentage (if specified).
+     * @param emergencyBoost  Indicates that the consumer wants the water to be heated as quickly as practicable. This MAY cause multiple heat sources to be activated (e.g. a heat pump and direct electric heating element).
+     * @param temporarySetpoint  Indicates the target temperature to which to heat the hot water for this Boost command. It SHALL be used instead of the normal set point temperature whilst the BOOST state is active.
+     * @param targetPercentage  If the tank supports the TankPercent feature, this field indicates the amount of water that SHALL be heated by this Boost command before the heater is switched off.
+     * @param targetReheat  If the tank supports the TankPercent feature, and the heating by this Boost command has ceased because the TargetPercentage of the water in the tank has been heated to the set point (or TemporarySetpoint if included), this field indicates the percentage to which the hot water in the tank SHALL be allowed to fall before again beginning to reheat it.
+     *
+     * @return  Success if the boost command is successful; otherwise return the appropriate error.
+     */
+    Protocols::InteractionModel::Status BoostCommandStarted(uint32_t duration, Optional<bool> oneShot, Optional<bool> emergencyBoost, Optional<int16_t> temporarySetpoint, Optional<chip::Percent> targetPercentage, Optional<chip::Percent> targetReheat);
+
+    /**
+     * @brief Called when the Boost command has been cancelled.
+     *
+     * @return It should report SUCCESS if successful and FAILURE otherwise.
+     */
+    Protocols::InteractionModel::Status BoostCommandCancelled();
+
+    /**
+     * @brief Called when a boost command has completed.
+     */
+    void BoostCommandFinished();
 
 private:
     WaterHeaterManagementInstance * mWhmInstance;
+    bool mBoostActive;
 };
 
 /** @brief Helper function to return the singleton WhmManufacturer instance

examples/water-heater-management-app/water-heater-management-common/src/WhmDelegateImpl.cpp

@@ -169,7 +169,9 @@ void WaterHeaterManagementDelegate::SetBoostState(BoostStateEnum boostState)
  */
 Status WaterHeaterManagementDelegate::HandleBoost(uint32_t durationS, Optional<bool> oneShot, Optional<bool> emergencyBoost, Optional<int16_t> temporarySetpoint, Optional<chip::Percent> targetPercentage, Optional<chip::Percent> targetReheat)
 {
-    ChipLogProgress(AppServer, "WaterHeaterManagementDelegate::HandleBoost");
+    Status status = Status::Success;
+
+    ChipLogProgress(AppServer, "HandleBoost");
 
     // Keep track of the boost command parameters
     mBoostOneShot = oneShot;
@@ -189,7 +191,7 @@ Status WaterHeaterManagementDelegate::HandleBoost(uint32_t durationS, Optional<b
     CHIP_ERROR err = DeviceLayer::SystemLayer().StartTimer(System::Clock::Seconds32(durationS), BoostTimerExpiry, this);
     if (err != CHIP_NO_ERROR)
     {
-        ChipLogError(AppServer, "Unable to start a Boost timer: %" CHIP_ERROR_FORMAT, err.Format());
+        ChipLogError(AppServer, "HandleBoost: Unable to start a Boost timer: %" CHIP_ERROR_FORMAT, err.Format());
 
         // Not a lot we can do -> just set the boost state to inactive
         SetBoostState(BoostStateEnum::kInactive);
@@ -200,10 +202,23 @@ Status WaterHeaterManagementDelegate::HandleBoost(uint32_t durationS, Optional<b
     // Now running a boost command
     SetBoostState(BoostStateEnum::kActive);
 
-    // See if the heat needs to be turned on or off as a result of this boost command
-    CheckIfHeatNeedsToBeTurnedOnOrOff();
+    if (mpWhmManufacturer != nullptr)
+    {
+        status = mpWhmManufacturer->BoostCommandStarted(durationS, oneShot, emergencyBoost, temporarySetpoint, targetPercentage, targetReheat);
+    }
+    else
+    {
+        status = Status::InvalidInState;
+        ChipLogError(AppServer, "HandleBoost: mpWhmManufacturer == nullptr");
+    }
+
+    if (status == Status::Success)
+    {
+        // See if the heat needs to be turned on or off as a result of this boost command
+        status = CheckIfHeatNeedsToBeTurnedOnOrOff();
+    }
 
-    return Status::Success;
+    return status;
 }
 
 void WaterHeaterManagementDelegate::BoostTimerExpiry(System::Layer * systemLayer, void * delegate)
@@ -218,11 +233,20 @@ void WaterHeaterManagementDelegate::BoostTimerExpiry(System::Layer * systemLayer
  */
 void WaterHeaterManagementDelegate::HandleBoostTimerExpiry()
 {
-    ChipLogError(AppServer, "WaterHeaterManagementDelegate::HandleBoostTimerExpiry");
+    ChipLogError(AppServer, "HandleBoostTimerExpiry");
 
     // The PowerAdjustment is no longer in progress
     SetBoostState(BoostStateEnum::kInactive);
 
+    if (mpWhmManufacturer != nullptr)
+    {
+        mpWhmManufacturer->BoostCommandFinished();
+    }
+    else
+    {
+        ChipLogError(AppServer, "HandleBoostTimerExpiry: mpWhmManufacturer == nullptr");
+    }
+
     CheckIfHeatNeedsToBeTurnedOnOrOff();
 }
 
@@ -233,18 +257,30 @@ void WaterHeaterManagementDelegate::HandleBoostTimerExpiry()
  */
 Status WaterHeaterManagementDelegate::HandleCancelBoost()
 {
-    ChipLogProgress(AppServer, "WaterHeaterManagementDelegate::HandleCancelBoost");
+    Status status = Status::Success;
+
+    ChipLogProgress(AppServer, "HandleCancelBoost");
 
     if (mBoostState == BoostStateEnum::kActive)
     {
         SetBoostState(BoostStateEnum::kInactive);
 
         DeviceLayer::SystemLayer().CancelTimer(BoostTimerExpiry, this);
 
-        CheckIfHeatNeedsToBeTurnedOnOrOff();
+        if (mpWhmManufacturer != nullptr)
+        {
+            status = mpWhmManufacturer->BoostCommandCancelled();
+        }
+        else
+        {
+            status = Status::InvalidInState;
+            ChipLogError(AppServer, "HandleCancelBoost: mpWhmManufacturer == nullptr");
+        }
+
+        status = CheckIfHeatNeedsToBeTurnedOnOrOff();
     }
 
-    return Status::Success;
+    return status;
 }
 
 /*********************************************************************************
@@ -387,8 +423,9 @@ bool WaterHeaterManagementDelegate::HasWaterTemperatureReachedTarget() const
     return (mTankPercentage >= targetPercentage) && (mHotWaterTemperature >= targetTemperature);
 }
 
-void WaterHeaterManagementDelegate::CheckIfHeatNeedsToBeTurnedOnOrOff()
+Status WaterHeaterManagementDelegate::CheckIfHeatNeedsToBeTurnedOnOrOff()
 {
+    Status status = Status::Success;
     bool turningHeatOff = false;
 
     if (!HasWaterTemperatureReachedTarget())
@@ -416,19 +453,20 @@ void WaterHeaterManagementDelegate::CheckIfHeatNeedsToBeTurnedOnOrOff()
                     SetHeatDemand(heaterDemand);
 
                     // And turn the heating of the water tank on.
-                    mpWhmManufacturer->TurnHeatingOn();
+                    status = mpWhmManufacturer->TurnHeatingOn();
                 }
                 else
                 {
-                    ChipLogError(Zcl, "WaterHeaterManagementDelegate::CheckIfHeatNeedsToBeTurnedOnOrOff: Failed as mpWhmManufacturer == nullptr");
+                    status = Status::InvalidInState;
+                    ChipLogError(AppServer, "CheckIfHeatNeedsToBeTurnedOnOrOff: Failed as mpWhmManufacturer == nullptr");
                 }
             }
         }
         else if (mBoostState == BoostStateEnum::kInactive && mode == ModeOff)
         {
             // The water temperature is not at the target temperature but there is no boost command in progress and the mode is Off
             // so need to ensure the heating is turned off.
-            ChipLogError(Zcl, "WaterHeaterManagementDelegate::CheckIfHeatNeedsToBeTurnedOnOrOff turning heating off due to mode");
+            ChipLogError(AppServer, "CheckIfHeatNeedsToBeTurnedOnOrOff turning heating off due to mode");
 
             SetHeatDemand(BitMask<WaterHeaterDemandBitmap>(0));
 
@@ -455,32 +493,45 @@ void WaterHeaterManagementDelegate::CheckIfHeatNeedsToBeTurnedOnOrOff()
             SetBoostState(BoostStateEnum::kInactive);
 
             DeviceLayer::SystemLayer().CancelTimer(BoostTimerExpiry, this);
+
+            if (mpWhmManufacturer != nullptr)
+            {
+                status = mpWhmManufacturer->BoostCommandCancelled();
+            }
+            else
+            {
+                status = Status::InvalidInState;
+                ChipLogError(AppServer, "CheckIfHeatNeedsToBeTurnedOnOrOff: mpWhmManufacturer == nullptr");
+            }
         }
 
         // Turn the heating off
         if (mpWhmManufacturer != nullptr)
         {
-            mpWhmManufacturer->TurnHeatingOff();
+            status = mpWhmManufacturer->TurnHeatingOff();
         }
         else
         {
-            ChipLogError(Zcl, "WaterHeaterManagementDelegate::CheckIfHeatNeedsToBeTurnedOnOrOff: Failed to turn the heating off as mpWhmManufacturer == nullptr");
+            status = Status::InvalidInState;
+            ChipLogError(AppServer, "CheckIfHeatNeedsToBeTurnedOnOrOff: Failed to turn the heating off as mpWhmManufacturer == nullptr");
         }
     }
+
+    return status;
 }
 
 void WaterHeaterManagementDelegate::SetWaterHeaterMode(uint8_t modeValue)
 {
     if (!mInstance->IsSupportedMode(modeValue))
     {
-        ChipLogError(Zcl, "WaterHeaterManagementDelegate::SetWaterHeaterMode bad mode");
+        ChipLogError(AppServer, "SetWaterHeaterMode bad mode");
         return;
     }
 
     Status status = mInstance->UpdateCurrentMode(modeValue);
     if (status != Status::Success)
     {
-        ChipLogError(Zcl, "WaterHeaterManagementDelegate::SetWaterHeaterMode updateMode failed");
+        ChipLogError(AppServer, "SetWaterHeaterMode updateMode failed");
         return;
     }
 

examples/water-heater-management-app/water-heater-management-common/src/WhmManufacturer.cpp

@@ -27,6 +27,8 @@
 using namespace chip;
 using namespace chip::app::Clusters::WaterHeaterManagement;
 
+using Protocols::InteractionModel::Status;
+
 CHIP_ERROR WhmManufacturer::Init()
 {
     WaterHeaterManagementDelegate * dg = GetWhmManufacturer()->GetWhmDelegate();
@@ -36,6 +38,8 @@ CHIP_ERROR WhmManufacturer::Init()
         return CHIP_ERROR_UNINITIALIZED;
     }
 
+    mBoostActive = false;
+
     return CHIP_NO_ERROR;
 }
 
@@ -90,14 +94,48 @@ BitMask<WaterHeaterDemandBitmap> WhmManufacturer::DetermineHeatingSources()
     return BitMask<WaterHeaterDemandBitmap>(heaterDemandMask);
 }
 
-void WhmManufacturer::TurnHeatingOn()
+Status WhmManufacturer::TurnHeatingOn()
 {
+    Status status = Status::Success;
+
     ChipLogProgress(AppServer, "WhmManufacturer::TurnHeatingOn");
+
+    WaterHeaterManagementDelegate * dg = GetWhmDelegate();
+
+    if (dg->GetBoostState() == BoostStateEnum::kActive)
+    {
+        mBoostActive = true;
+    }
+
+    return status;
 }
 
-void WhmManufacturer::TurnHeatingOff()
+Status WhmManufacturer::TurnHeatingOff()
 {
+    Status status = Status::Success;
+
     ChipLogProgress(AppServer, "WhmManufacturer::TurnHeatingOff");
+
+    if (mBoostActive)
+    {
+        mBoostActive = false;
+    }
+
+    return status;
+}
+
+Status WhmManufacturer::BoostCommandStarted(uint32_t duration, Optional<bool> oneShot, Optional<bool> emergencyBoost, Optional<int16_t> temporarySetpoint, Optional<chip::Percent> targetPercentage, Optional<chip::Percent> targetReheat)
+{
+    return Status::Success;
+}
+
+Status WhmManufacturer::BoostCommandCancelled()
+{
+    return Status::Success;
+}
+
+void WhmManufacturer::BoostCommandFinished()
+{
 }
 
 WaterHeaterManagementDelegate * GetWhmDelegate()