| /* |
| * Copyright (c) 2023 Project CHIP Authors |
| * |
| * Licensed under the Apache License, Version 2.0 (the "License"); |
| * you may not use this file except in compliance with the License. |
| * You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| */ |
| |
| #include "device-energy-management-server.h" |
| |
| #include <app/AttributeAccessInterface.h> |
| #include <app/AttributeAccessInterfaceRegistry.h> |
| #include <app/CommandHandlerInterfaceRegistry.h> |
| #include <app/ConcreteAttributePath.h> |
| #include <app/InteractionModelEngine.h> |
| #include <app/util/attribute-storage.h> |
| |
| using namespace chip; |
| using namespace chip::app; |
| using namespace chip::app::Clusters; |
| using namespace chip::app::Clusters::DeviceEnergyManagement; |
| using namespace chip::app::Clusters::DeviceEnergyManagement::Attributes; |
| |
| using chip::Protocols::InteractionModel::Status; |
| |
| namespace chip { |
| namespace app { |
| namespace Clusters { |
| namespace DeviceEnergyManagement { |
| |
| CHIP_ERROR Instance::Init() |
| { |
| ReturnErrorOnFailure(CommandHandlerInterfaceRegistry::Instance().RegisterCommandHandler(this)); |
| VerifyOrReturnError(AttributeAccessInterfaceRegistry::Instance().Register(this), CHIP_ERROR_INCORRECT_STATE); |
| |
| return CHIP_NO_ERROR; |
| } |
| |
| void Instance::Shutdown() |
| { |
| CommandHandlerInterfaceRegistry::Instance().UnregisterCommandHandler(this); |
| AttributeAccessInterfaceRegistry::Instance().Unregister(this); |
| } |
| |
| bool Instance::HasFeature(Feature aFeature) const |
| { |
| return mFeature.Has(aFeature); |
| } |
| |
| // AttributeAccessInterface |
| CHIP_ERROR Instance::Read(const ConcreteReadAttributePath & aPath, AttributeValueEncoder & aEncoder) |
| { |
| switch (aPath.mAttributeId) |
| { |
| case ESAType::Id: |
| return aEncoder.Encode(mDelegate.GetESAType()); |
| case ESACanGenerate::Id: |
| return aEncoder.Encode(mDelegate.GetESACanGenerate()); |
| case ESAState::Id: |
| return aEncoder.Encode(mDelegate.GetESAState()); |
| case AbsMinPower::Id: |
| return aEncoder.Encode(mDelegate.GetAbsMinPower()); |
| case AbsMaxPower::Id: |
| return aEncoder.Encode(mDelegate.GetAbsMaxPower()); |
| case PowerAdjustmentCapability::Id: |
| /* PA - PowerAdjustment */ |
| if (!HasFeature(Feature::kPowerAdjustment)) |
| { |
| return CHIP_IM_GLOBAL_STATUS(UnsupportedAttribute); |
| } |
| return aEncoder.Encode(mDelegate.GetPowerAdjustmentCapability()); |
| case Forecast::Id: |
| /* PFR | SFR - Power Forecast Reporting or State Forecast Reporting */ |
| if (!HasFeature(Feature::kPowerForecastReporting) && !HasFeature(Feature::kStateForecastReporting)) |
| { |
| return CHIP_IM_GLOBAL_STATUS(UnsupportedAttribute); |
| } |
| return aEncoder.Encode(mDelegate.GetForecast()); |
| case OptOutState::Id: |
| /* PA | STA | PAU | FA | CON */ |
| if (!HasFeature(Feature::kPowerAdjustment) && !HasFeature(Feature::kStartTimeAdjustment) && |
| !HasFeature(Feature::kPausable) && !HasFeature(Feature::kForecastAdjustment) && |
| !HasFeature(Feature::kConstraintBasedAdjustment)) |
| { |
| return CHIP_IM_GLOBAL_STATUS(UnsupportedAttribute); |
| } |
| return aEncoder.Encode(mDelegate.GetOptOutState()); |
| |
| /* FeatureMap - is held locally */ |
| case FeatureMap::Id: |
| return aEncoder.Encode(mFeature); |
| } |
| |
| /* Allow all other unhandled attributes to fall through to Ember */ |
| return CHIP_NO_ERROR; |
| } |
| |
| // CommandHandlerInterface |
| CHIP_ERROR Instance::EnumerateAcceptedCommands(const ConcreteClusterPath & cluster, CommandIdCallback callback, void * context) |
| { |
| using namespace Commands; |
| |
| if (HasFeature(Feature::kPowerAdjustment)) |
| { |
| for (auto && cmd : { |
| PowerAdjustRequest::Id, |
| CancelPowerAdjustRequest::Id, |
| }) |
| { |
| VerifyOrExit(callback(cmd, context) == Loop::Continue, /**/); |
| } |
| } |
| |
| if (HasFeature(Feature::kStartTimeAdjustment)) |
| { |
| VerifyOrExit(callback(StartTimeAdjustRequest::Id, context) == Loop::Continue, /**/); |
| } |
| |
| if (HasFeature(Feature::kPausable)) |
| { |
| VerifyOrExit(callback(PauseRequest::Id, context) == Loop::Continue, /**/); |
| VerifyOrExit(callback(ResumeRequest::Id, context) == Loop::Continue, /**/); |
| } |
| |
| if (HasFeature(Feature::kForecastAdjustment)) |
| { |
| VerifyOrExit(callback(ModifyForecastRequest::Id, context) == Loop::Continue, /**/); |
| } |
| |
| if (HasFeature(Feature::kConstraintBasedAdjustment)) |
| { |
| VerifyOrExit(callback(RequestConstraintBasedForecast::Id, context) == Loop::Continue, /**/); |
| } |
| |
| if (HasFeature(Feature::kStartTimeAdjustment) || HasFeature(Feature::kForecastAdjustment) || |
| HasFeature(Feature::kConstraintBasedAdjustment)) |
| { |
| VerifyOrExit(callback(CancelRequest::Id, context) == Loop::Continue, /**/); |
| } |
| |
| exit: |
| return CHIP_NO_ERROR; |
| } |
| |
| void Instance::InvokeCommand(HandlerContext & handlerContext) |
| { |
| using namespace Commands; |
| |
| switch (handlerContext.mRequestPath.mCommandId) |
| { |
| case PowerAdjustRequest::Id: |
| if (!HasFeature(Feature::kPowerAdjustment)) |
| { |
| handlerContext.mCommandHandler.AddStatus(handlerContext.mRequestPath, Status::UnsupportedCommand); |
| } |
| else |
| { |
| HandleCommand<PowerAdjustRequest::DecodableType>( |
| handlerContext, |
| [this](HandlerContext & ctx, const auto & commandData) { HandlePowerAdjustRequest(ctx, commandData); }); |
| } |
| return; |
| case CancelPowerAdjustRequest::Id: |
| if (!HasFeature(Feature::kPowerAdjustment)) |
| { |
| handlerContext.mCommandHandler.AddStatus(handlerContext.mRequestPath, Status::UnsupportedCommand); |
| } |
| else |
| { |
| HandleCommand<CancelPowerAdjustRequest::DecodableType>( |
| handlerContext, |
| [this](HandlerContext & ctx, const auto & commandData) { HandleCancelPowerAdjustRequest(ctx, commandData); }); |
| } |
| return; |
| case StartTimeAdjustRequest::Id: |
| if (!HasFeature(Feature::kStartTimeAdjustment)) |
| { |
| handlerContext.mCommandHandler.AddStatus(handlerContext.mRequestPath, Status::UnsupportedCommand); |
| } |
| else |
| { |
| HandleCommand<StartTimeAdjustRequest::DecodableType>( |
| handlerContext, |
| [this](HandlerContext & ctx, const auto & commandData) { HandleStartTimeAdjustRequest(ctx, commandData); }); |
| } |
| return; |
| case PauseRequest::Id: |
| if (!HasFeature(Feature::kPausable)) |
| { |
| handlerContext.mCommandHandler.AddStatus(handlerContext.mRequestPath, Status::UnsupportedCommand); |
| } |
| else |
| { |
| HandleCommand<PauseRequest::DecodableType>( |
| handlerContext, [this](HandlerContext & ctx, const auto & commandData) { HandlePauseRequest(ctx, commandData); }); |
| } |
| return; |
| case ResumeRequest::Id: |
| if (!HasFeature(Feature::kPausable)) |
| { |
| handlerContext.mCommandHandler.AddStatus(handlerContext.mRequestPath, Status::UnsupportedCommand); |
| } |
| else |
| { |
| HandleCommand<ResumeRequest::DecodableType>( |
| handlerContext, [this](HandlerContext & ctx, const auto & commandData) { HandleResumeRequest(ctx, commandData); }); |
| } |
| return; |
| case ModifyForecastRequest::Id: |
| if (!HasFeature(Feature::kForecastAdjustment)) |
| { |
| handlerContext.mCommandHandler.AddStatus(handlerContext.mRequestPath, Status::UnsupportedCommand); |
| } |
| else |
| { |
| HandleCommand<ModifyForecastRequest::DecodableType>( |
| handlerContext, |
| [this](HandlerContext & ctx, const auto & commandData) { HandleModifyForecastRequest(ctx, commandData); }); |
| } |
| return; |
| case RequestConstraintBasedForecast::Id: |
| if (!HasFeature(Feature::kConstraintBasedAdjustment)) |
| { |
| handlerContext.mCommandHandler.AddStatus(handlerContext.mRequestPath, Status::UnsupportedCommand); |
| } |
| else |
| { |
| HandleCommand<RequestConstraintBasedForecast::DecodableType>( |
| handlerContext, |
| [this](HandlerContext & ctx, const auto & commandData) { HandleRequestConstraintBasedForecast(ctx, commandData); }); |
| } |
| return; |
| case CancelRequest::Id: |
| if (!HasFeature(Feature::kStartTimeAdjustment) && !HasFeature(Feature::kForecastAdjustment) && |
| !HasFeature(Feature::kConstraintBasedAdjustment)) |
| { |
| handlerContext.mCommandHandler.AddStatus(handlerContext.mRequestPath, Status::UnsupportedCommand); |
| } |
| else |
| { |
| HandleCommand<CancelRequest::DecodableType>( |
| handlerContext, [this](HandlerContext & ctx, const auto & commandData) { HandleCancelRequest(ctx, commandData); }); |
| } |
| return; |
| } |
| } |
| |
| Status Instance::CheckOptOutAllowsRequest(AdjustmentCauseEnum adjustmentCause) |
| { |
| OptOutStateEnum optOutState = mDelegate.GetOptOutState(); |
| |
| if (adjustmentCause == AdjustmentCauseEnum::kUnknownEnumValue) |
| { |
| ChipLogError(Zcl, "DEM: adjustment cause is invalid (%d)", static_cast<int>(adjustmentCause)); |
| return Status::InvalidValue; |
| } |
| |
| switch (optOutState) |
| { |
| case OptOutStateEnum::kNoOptOut: /* User has NOT opted out so allow it */ |
| ChipLogProgress(Zcl, "DEM: OptOutState = kNoOptOut"); |
| return Status::Success; |
| |
| case OptOutStateEnum::kLocalOptOut: /* User has opted out from Local only*/ |
| ChipLogProgress(Zcl, "DEM: OptOutState = kLocalOptOut"); |
| switch (adjustmentCause) |
| { |
| case AdjustmentCauseEnum::kGridOptimization: |
| return Status::Success; |
| case AdjustmentCauseEnum::kLocalOptimization: |
| default: |
| return Status::ConstraintError; |
| } |
| |
| case OptOutStateEnum::kGridOptOut: /* User has opted out from Grid only */ |
| ChipLogProgress(Zcl, "DEM: OptOutState = kGridOptOut"); |
| switch (adjustmentCause) |
| { |
| case AdjustmentCauseEnum::kLocalOptimization: |
| return Status::Success; |
| case AdjustmentCauseEnum::kGridOptimization: |
| default: |
| return Status::ConstraintError; |
| } |
| |
| case OptOutStateEnum::kOptOut: /* User has opted out from both local and grid */ |
| ChipLogProgress(Zcl, "DEM: OptOutState = kOptOut"); |
| return Status::ConstraintError; |
| |
| default: |
| ChipLogError(Zcl, "DEM: invalid optOutState %d", static_cast<int>(optOutState)); |
| return Status::InvalidValue; |
| } |
| } |
| |
| void Instance::HandlePowerAdjustRequest(HandlerContext & ctx, const Commands::PowerAdjustRequest::DecodableType & commandData) |
| { |
| bool validArgs = false; |
| |
| int64_t power = commandData.power; |
| uint32_t durationSec = commandData.duration; |
| AdjustmentCauseEnum adjustmentCause = commandData.cause; |
| |
| // Notify the appliance if the appliance hardware cannot be adjusted, then return Failure |
| if (!HasFeature(DeviceEnergyManagement::Feature::kPowerAdjustment)) |
| { |
| ChipLogError(Zcl, "PowerAdjust not supported"); |
| ctx.mCommandHandler.AddStatus(ctx.mRequestPath, Status::Failure); |
| return; |
| } |
| |
| Status status = CheckOptOutAllowsRequest(adjustmentCause); |
| if (status != Status::Success) |
| { |
| ChipLogError(Zcl, "DEM: PowerAdjustRequest command rejected"); |
| ctx.mCommandHandler.AddStatus(ctx.mRequestPath, status); |
| return; |
| } |
| |
| DataModel::Nullable<Structs::PowerAdjustCapabilityStruct::Type> powerAdjustmentCapabilityStruct = |
| mDelegate.GetPowerAdjustmentCapability(); |
| if (powerAdjustmentCapabilityStruct.IsNull()) |
| { |
| ChipLogError(Zcl, "DEM: powerAdjustmentCapabilityStruct IsNull"); |
| ctx.mCommandHandler.AddStatus(ctx.mRequestPath, Status::ConstraintError); |
| return; |
| } |
| |
| if (powerAdjustmentCapabilityStruct.Value().powerAdjustCapability.IsNull()) |
| { |
| ChipLogError(Zcl, "DEM: powerAdjustmentCapabilityStruct.powerAdjustCapability IsNull"); |
| ctx.mCommandHandler.AddStatus(ctx.mRequestPath, Status::ConstraintError); |
| return; |
| } |
| |
| /* PowerAdjustmentCapability is a list - so iterate through checking if the command is within one of the offers */ |
| for (auto pas : powerAdjustmentCapabilityStruct.Value().powerAdjustCapability.Value()) |
| { |
| if ((power >= pas.minPower) && (durationSec >= pas.minDuration) && (power <= pas.maxPower) && |
| (durationSec <= pas.maxDuration)) |
| { |
| ChipLogProgress(Zcl, "DEM: Good PowerAdjustment args"); |
| validArgs = true; |
| break; |
| } |
| } |
| |
| if (!validArgs) |
| { |
| ChipLogError(Zcl, "DEM: invalid request range"); |
| ctx.mCommandHandler.AddStatus(ctx.mRequestPath, Status::ConstraintError); |
| return; |
| } |
| |
| ChipLogProgress(Zcl, "DEM: Good PowerAdjustRequest() args."); |
| |
| status = mDelegate.PowerAdjustRequest(power, durationSec, adjustmentCause); |
| ctx.mCommandHandler.AddStatus(ctx.mRequestPath, status); |
| if (status != Status::Success) |
| { |
| ChipLogError(Zcl, "DEM: Failed to PowerAdjustRequest() args."); |
| } |
| } |
| |
| void Instance::HandleCancelPowerAdjustRequest(HandlerContext & ctx, |
| const Commands::CancelPowerAdjustRequest::DecodableType & commandData) |
| { |
| if (!HasFeature(DeviceEnergyManagement::Feature::kPowerAdjustment)) |
| { |
| ChipLogError(Zcl, "PowerAdjust not supported"); |
| ctx.mCommandHandler.AddStatus(ctx.mRequestPath, Status::Failure); |
| return; |
| } |
| |
| /* Check that the ESA state is PowerAdjustActive */ |
| ESAStateEnum esaStatus = mDelegate.GetESAState(); |
| if (ESAStateEnum::kPowerAdjustActive != esaStatus) |
| { |
| ChipLogError(Zcl, "DEM: kPowerAdjustActive != esaStatus"); |
| ctx.mCommandHandler.AddStatus(ctx.mRequestPath, Status::InvalidInState); |
| return; |
| } |
| |
| Status status = mDelegate.CancelPowerAdjustRequest(); |
| ctx.mCommandHandler.AddStatus(ctx.mRequestPath, status); |
| if (status != Status::Success) |
| { |
| ChipLogError(Zcl, "DEM: Failed to CancelPowerAdjustRequest()"); |
| return; |
| } |
| } |
| |
| void Instance::HandleStartTimeAdjustRequest(HandlerContext & ctx, |
| const Commands::StartTimeAdjustRequest::DecodableType & commandData) |
| { |
| Status status; |
| uint32_t earliestStartTimeEpoch = 0; |
| uint32_t latestEndTimeEpoch = 0; |
| uint32_t duration; |
| |
| uint32_t requestedStartTimeEpoch = commandData.requestedStartTime; |
| AdjustmentCauseEnum adjustmentCause = commandData.cause; |
| |
| status = CheckOptOutAllowsRequest(adjustmentCause); |
| if (status != Status::Success) |
| { |
| ChipLogError(Zcl, "DEM: StartTimeAdjustRequest command rejected"); |
| ctx.mCommandHandler.AddStatus(ctx.mRequestPath, status); |
| return; |
| } |
| |
| DataModel::Nullable<Structs::ForecastStruct::Type> forecastNullable = mDelegate.GetForecast(); |
| |
| if (forecastNullable.IsNull()) |
| { |
| ChipLogError(Zcl, "DEM: Forecast is Null"); |
| ctx.mCommandHandler.AddStatus(ctx.mRequestPath, Status::Failure); |
| return; |
| } |
| |
| /* Temporary variable to save calling .Value() on forecastNullable */ |
| auto & forecast = forecastNullable.Value(); |
| |
| /** |
| * If the RequestedStartTime value resulted in a time shift which is |
| * outside the time constraints of EarliestStartTime and |
| * LatestEndTime, then the command SHALL be rejected with CONSTRAINT_ERROR; |
| * in other failure scenarios the command SHALL be rejected with FAILURE |
| */ |
| /* earliestStartTime is optional based on the StartTimeAdjust (STA) feature AND is nullable */ |
| if (!(forecast.earliestStartTime.HasValue()) || !(forecast.latestEndTime.HasValue())) |
| { |
| /* These should have values, since this command requires STA feature and these are mandatory for that */ |
| ChipLogError(Zcl, "DEM: EarliestStartTime / LatestEndTime do not have values"); |
| ctx.mCommandHandler.AddStatus(ctx.mRequestPath, Status::Failure); |
| return; |
| } |
| |
| /* Temporary variable to save keep calling .Value() on the Optional element */ |
| DataModel::Nullable<uint32_t> & earliestStartTimeNullable = forecast.earliestStartTime.Value(); |
| /* Latest End Time is optional & cannot be null - unlike earliestStartTime! */ |
| latestEndTimeEpoch = forecast.latestEndTime.Value(); |
| |
| if (earliestStartTimeNullable.IsNull()) |
| { |
| System::Clock::Milliseconds64 cTMs; |
| CHIP_ERROR err = System::SystemClock().GetClock_RealTimeMS(cTMs); |
| if (err != CHIP_NO_ERROR) |
| { |
| ChipLogError(Zcl, "DEM: Unable to get current time - err:%" CHIP_ERROR_FORMAT, err.Format()); |
| ctx.mCommandHandler.AddStatus(ctx.mRequestPath, Status::Failure); |
| return; |
| } |
| |
| auto unixEpoch = std::chrono::duration_cast<System::Clock::Seconds32>(cTMs).count(); |
| uint32_t chipEpoch = 0; |
| if (!UnixEpochToChipEpochTime(unixEpoch, chipEpoch)) |
| { |
| ChipLogError(Zcl, "DEM: unable to convert Unix Epoch time to Matter Epoch Time"); |
| ctx.mCommandHandler.AddStatus(ctx.mRequestPath, Status::Failure); |
| return; |
| } |
| |
| /* Null means - We can start immediately */ |
| earliestStartTimeEpoch = chipEpoch; /* NOW */ |
| } |
| else |
| { |
| earliestStartTimeEpoch = earliestStartTimeNullable.Value(); |
| } |
| |
| duration = forecast.endTime - forecast.startTime; // the current entire forecast duration |
| if (requestedStartTimeEpoch < earliestStartTimeEpoch) |
| { |
| ChipLogError(Zcl, "DEM: Bad requestedStartTime %ld, earlier than earliestStartTime %ld.", |
| static_cast<long unsigned int>(requestedStartTimeEpoch), |
| static_cast<long unsigned int>(earliestStartTimeEpoch)); |
| ctx.mCommandHandler.AddStatus(ctx.mRequestPath, Status::ConstraintError); |
| return; |
| } |
| |
| if ((requestedStartTimeEpoch + duration) > latestEndTimeEpoch) |
| { |
| ChipLogError(Zcl, "DEM: Bad requestedStartTimeEpoch + duration %ld, later than latestEndTime %ld.", |
| static_cast<long unsigned int>(requestedStartTimeEpoch + duration), |
| static_cast<long unsigned int>(latestEndTimeEpoch)); |
| ctx.mCommandHandler.AddStatus(ctx.mRequestPath, Status::ConstraintError); |
| return; |
| } |
| |
| ChipLogProgress(Zcl, "DEM: Good requestedStartTimeEpoch %ld.", static_cast<long unsigned int>(requestedStartTimeEpoch)); |
| status = mDelegate.StartTimeAdjustRequest(requestedStartTimeEpoch, adjustmentCause); |
| ctx.mCommandHandler.AddStatus(ctx.mRequestPath, status); |
| if (status != Status::Success) |
| { |
| ChipLogError(Zcl, "DEM: StartTimeAdjustRequest(%ld) FAILURE", static_cast<long unsigned int>(requestedStartTimeEpoch)); |
| return; |
| } |
| } |
| |
| void Instance::HandlePauseRequest(HandlerContext & ctx, const Commands::PauseRequest::DecodableType & commandData) |
| { |
| Status status = Status::Success; |
| CHIP_ERROR err = CHIP_NO_ERROR; |
| DataModel::Nullable<Structs::ForecastStruct::Type> forecast = mDelegate.GetForecast(); |
| |
| if (!HasFeature(DeviceEnergyManagement::Feature::kPausable)) |
| { |
| ChipLogError(AppServer, "Pause not supported"); |
| ctx.mCommandHandler.AddStatus(ctx.mRequestPath, Status::Failure); |
| return; |
| } |
| |
| uint32_t duration = commandData.duration; |
| AdjustmentCauseEnum adjustmentCause = commandData.cause; |
| |
| status = CheckOptOutAllowsRequest(adjustmentCause); |
| if (status != Status::Success) |
| { |
| ChipLogError(Zcl, "DEM: PauseRequest command rejected"); |
| ctx.mCommandHandler.AddStatus(ctx.mRequestPath, status); |
| return; |
| } |
| |
| if (forecast.IsNull()) |
| { |
| ChipLogError(Zcl, "DEM: Forecast is Null"); |
| ctx.mCommandHandler.AddStatus(ctx.mRequestPath, Status::Failure); |
| return; |
| } |
| |
| /* value SHALL be between the MinPauseDuration and MaxPauseDuration indicated in the |
| ActiveSlotNumber index in the Slots list in the Forecast. |
| */ |
| uint16_t activeSlotNumber; |
| if (forecast.Value().activeSlotNumber.IsNull()) |
| { |
| ChipLogError(Zcl, "DEM: activeSlotNumber Is Null"); |
| ctx.mCommandHandler.AddStatus(ctx.mRequestPath, Status::Failure); |
| return; |
| } |
| |
| activeSlotNumber = forecast.Value().activeSlotNumber.Value(); |
| if (activeSlotNumber >= forecast.Value().slots.size()) |
| { |
| ChipLogError(Zcl, "DEM: Bad activeSlotNumber %d , size()=%d.", activeSlotNumber, |
| static_cast<int>(forecast.Value().slots.size())); |
| ctx.mCommandHandler.AddStatus(ctx.mRequestPath, Status::Failure); |
| return; |
| } |
| |
| /* We expect that there should be a slotIsPausable entry (but it is optional) */ |
| if (!forecast.Value().slots[activeSlotNumber].slotIsPausable.HasValue()) |
| { |
| ChipLogError(Zcl, "DEM: activeSlotNumber %d does not include slotIsPausable.", activeSlotNumber); |
| ctx.mCommandHandler.AddStatus(ctx.mRequestPath, Status::Failure); |
| return; |
| } |
| |
| if (!forecast.Value().slots[activeSlotNumber].minPauseDuration.HasValue()) |
| { |
| ChipLogError(Zcl, "DEM: activeSlotNumber %d does not include minPauseDuration.", activeSlotNumber); |
| ctx.mCommandHandler.AddStatus(ctx.mRequestPath, Status::Failure); |
| return; |
| } |
| |
| if (!forecast.Value().slots[activeSlotNumber].maxPauseDuration.HasValue()) |
| { |
| ChipLogError(Zcl, "DEM: activeSlotNumber %d does not include minPauseDuration.", activeSlotNumber); |
| ctx.mCommandHandler.AddStatus(ctx.mRequestPath, Status::Failure); |
| return; |
| } |
| |
| if (!forecast.Value().slots[activeSlotNumber].slotIsPausable.Value()) |
| { |
| ChipLogError(Zcl, "DEM: activeSlotNumber %d is NOT pausable.", activeSlotNumber); |
| ctx.mCommandHandler.AddStatus(ctx.mRequestPath, Status::Failure); |
| return; |
| } |
| |
| if ((duration < forecast.Value().slots[activeSlotNumber].minPauseDuration.Value()) || |
| (duration > forecast.Value().slots[activeSlotNumber].maxPauseDuration.Value())) |
| { |
| ChipLogError(Zcl, "DEM: out of range pause duration %ld", static_cast<long unsigned int>(duration)); |
| ctx.mCommandHandler.AddStatus(ctx.mRequestPath, Status::ConstraintError); |
| return; |
| } |
| |
| err = mDelegate.SetESAState(ESAStateEnum::kPaused); |
| if (CHIP_NO_ERROR != err) |
| { |
| ChipLogError(Zcl, "DEM: SetESAState(paused) FAILURE"); |
| ctx.mCommandHandler.AddStatus(ctx.mRequestPath, Status::Failure); |
| return; |
| } |
| |
| status = mDelegate.PauseRequest(duration, adjustmentCause); |
| ctx.mCommandHandler.AddStatus(ctx.mRequestPath, status); |
| if (status != Status::Success) |
| { |
| ChipLogError(Zcl, "DEM: PauseRequest(%ld) FAILURE", static_cast<long unsigned int>(duration)); |
| ctx.mCommandHandler.AddStatus(ctx.mRequestPath, status); |
| return; |
| } |
| } |
| |
| void Instance::HandleResumeRequest(HandlerContext & ctx, const Commands::ResumeRequest::DecodableType & commandData) |
| { |
| if (!HasFeature(DeviceEnergyManagement::Feature::kPausable)) |
| { |
| ChipLogError(AppServer, "Pause not supported"); |
| ctx.mCommandHandler.AddStatus(ctx.mRequestPath, Status::Failure); |
| return; |
| } |
| |
| if (ESAStateEnum::kPaused != mDelegate.GetESAState()) |
| { |
| ChipLogError(Zcl, "DEM: ESAState not Paused."); |
| ctx.mCommandHandler.AddStatus(ctx.mRequestPath, Status::InvalidInState); |
| return; |
| } |
| |
| Status status = mDelegate.ResumeRequest(); |
| ctx.mCommandHandler.AddStatus(ctx.mRequestPath, status); |
| if (status != Status::Success) |
| { |
| ChipLogError(Zcl, "DEM: ResumeRequest FAILURE"); |
| return; |
| } |
| } |
| |
| void Instance::HandleModifyForecastRequest(HandlerContext & ctx, const Commands::ModifyForecastRequest::DecodableType & commandData) |
| { |
| if (!HasFeature(DeviceEnergyManagement::Feature::kForecastAdjustment)) |
| { |
| ChipLogError(Zcl, "ModifyForecast not supported"); |
| ctx.mCommandHandler.AddStatus(ctx.mRequestPath, Status::Failure); |
| return; |
| } |
| |
| Status status; |
| DataModel::Nullable<Structs::ForecastStruct::Type> forecast; |
| |
| uint32_t forecastID = commandData.forecastID; |
| DataModel::DecodableList<Structs::SlotAdjustmentStruct::Type> slotAdjustments = commandData.slotAdjustments; |
| AdjustmentCauseEnum adjustmentCause = commandData.cause; |
| |
| status = CheckOptOutAllowsRequest(adjustmentCause); |
| if (status != Status::Success) |
| { |
| ChipLogError(Zcl, "DEM: ModifyForecastRequest command rejected"); |
| ctx.mCommandHandler.AddStatus(ctx.mRequestPath, status); |
| return; |
| } |
| |
| forecast = mDelegate.GetForecast(); |
| if (forecast.IsNull()) |
| { |
| ChipLogError(Zcl, "DEM: Forecast is Null"); |
| ctx.mCommandHandler.AddStatus(ctx.mRequestPath, Status::Failure); |
| return; |
| } |
| |
| // Check the various values in the slot structures |
| auto iterator = slotAdjustments.begin(); |
| while (iterator.Next()) |
| { |
| const Structs::SlotAdjustmentStruct::Type & slotAdjustment = iterator.GetValue(); |
| |
| // Check for an invalid slotIndex |
| if (slotAdjustment.slotIndex >= forecast.Value().slots.size()) |
| { |
| ChipLogError(Zcl, "DEM: Bad slot index %d", slotAdjustment.slotIndex); |
| ctx.mCommandHandler.AddStatus(ctx.mRequestPath, Status::Failure); |
| return; |
| } |
| |
| // Check to see if trying to modify a slot which has already been run |
| if (!forecast.Value().activeSlotNumber.IsNull() && slotAdjustment.slotIndex < forecast.Value().activeSlotNumber.Value()) |
| { |
| ChipLogError(Zcl, "DEM: Modifying already run slot index %d", slotAdjustment.slotIndex); |
| ctx.mCommandHandler.AddStatus(ctx.mRequestPath, Status::ConstraintError); |
| return; |
| } |
| |
| const Structs::SlotStruct::Type & slot = forecast.Value().slots[slotAdjustment.slotIndex]; |
| |
| // NominalPower is only relevant if PFR is supported |
| if (HasFeature(Feature::kPowerForecastReporting)) |
| { |
| if (!slotAdjustment.nominalPower.HasValue() || !slot.minPowerAdjustment.HasValue() || |
| !slot.maxPowerAdjustment.HasValue() || slotAdjustment.nominalPower.Value() < slot.minPowerAdjustment.Value() || |
| slotAdjustment.nominalPower.Value() > slot.maxPowerAdjustment.Value()) |
| { |
| ChipLogError(Zcl, "DEM: Bad nominalPower"); |
| ctx.mCommandHandler.AddStatus(ctx.mRequestPath, Status::ConstraintError); |
| return; |
| } |
| } |
| |
| if (!slot.minDurationAdjustment.HasValue() || !slot.maxDurationAdjustment.HasValue() || |
| slotAdjustment.duration < slot.minDurationAdjustment.Value() || |
| slotAdjustment.duration > slot.maxDurationAdjustment.Value()) |
| { |
| ChipLogError(Zcl, "DEM: Bad min/max duration"); |
| ctx.mCommandHandler.AddStatus(ctx.mRequestPath, Status::ConstraintError); |
| return; |
| } |
| } |
| |
| if (iterator.GetStatus() != CHIP_NO_ERROR) |
| { |
| ctx.mCommandHandler.AddStatus(ctx.mRequestPath, Status::InvalidCommand); |
| return; |
| } |
| |
| status = mDelegate.ModifyForecastRequest(forecastID, slotAdjustments, adjustmentCause); |
| ctx.mCommandHandler.AddStatus(ctx.mRequestPath, status); |
| if (status != Status::Success) |
| { |
| ChipLogError(Zcl, "DEM: ModifyForecastRequest FAILURE"); |
| ctx.mCommandHandler.AddStatus(ctx.mRequestPath, Status::Failure); |
| return; |
| } |
| } |
| |
| void Instance::HandleRequestConstraintBasedForecast(HandlerContext & ctx, |
| const Commands::RequestConstraintBasedForecast::DecodableType & commandData) |
| { |
| if (!HasFeature(DeviceEnergyManagement::Feature::kConstraintBasedAdjustment)) |
| { |
| ChipLogError(AppServer, "RequestConstraintBasedForecast CON not supported"); |
| ctx.mCommandHandler.AddStatus(ctx.mRequestPath, Status::Failure); |
| return; |
| } |
| |
| Status status = Status::Success; |
| |
| DataModel::DecodableList<Structs::ConstraintsStruct::DecodableType> constraints = commandData.constraints; |
| AdjustmentCauseEnum adjustmentCause = commandData.cause; |
| |
| status = CheckOptOutAllowsRequest(adjustmentCause); |
| if (status != Status::Success) |
| { |
| ChipLogError(Zcl, "DEM: RequestConstraintBasedForecast command rejected"); |
| ctx.mCommandHandler.AddStatus(ctx.mRequestPath, status); |
| return; |
| } |
| |
| uint32_t currentUtcTime = 0; |
| status = GetMatterEpochTimeFromUnixTime(currentUtcTime); |
| if (status != Status::Success) |
| { |
| ChipLogError(Zcl, "DEM: Failed to get UTC time"); |
| ctx.mCommandHandler.AddStatus(ctx.mRequestPath, status); |
| return; |
| } |
| |
| // Check for invalid power levels and whether the constraint time/duration is in the past |
| { |
| auto iterator = constraints.begin(); |
| if (iterator.Next()) |
| { |
| const Structs::ConstraintsStruct::DecodableType & constraint = iterator.GetValue(); |
| |
| // Check to see if this constraint is in the past |
| if (constraint.startTime < currentUtcTime) |
| { |
| ctx.mCommandHandler.AddStatus(ctx.mRequestPath, Status::ConstraintError); |
| return; |
| } |
| |
| if (HasFeature(Feature::kPowerForecastReporting)) |
| { |
| if (!constraint.nominalPower.HasValue()) |
| { |
| ChipLogError(Zcl, "DEM: RequestConstraintBasedForecast no nominalPower"); |
| ctx.mCommandHandler.AddStatus(ctx.mRequestPath, Status::InvalidCommand); |
| return; |
| } |
| |
| if (constraint.nominalPower.Value() < mDelegate.GetAbsMinPower() || |
| constraint.nominalPower.Value() > mDelegate.GetAbsMaxPower()) |
| { |
| ChipLogError(Zcl, |
| "DEM: RequestConstraintBasedForecast nominalPower " ChipLogFormatX64 |
| " out of range [" ChipLogFormatX64 ", " ChipLogFormatX64 "]", |
| ChipLogValueX64(constraint.nominalPower.Value()), ChipLogValueX64(mDelegate.GetAbsMinPower()), |
| ChipLogValueX64(mDelegate.GetAbsMaxPower())); |
| |
| ctx.mCommandHandler.AddStatus(ctx.mRequestPath, Status::ConstraintError); |
| return; |
| } |
| |
| if (!constraint.maximumEnergy.HasValue()) |
| { |
| ChipLogError(Zcl, "DEM: RequestConstraintBasedForecast no value for maximumEnergy"); |
| ctx.mCommandHandler.AddStatus(ctx.mRequestPath, Status::InvalidCommand); |
| return; |
| } |
| } |
| |
| if (HasFeature(Feature::kStateForecastReporting)) |
| { |
| if (!constraint.loadControl.HasValue()) |
| { |
| ChipLogError(Zcl, "DEM: RequestConstraintBasedForecast no loadControl"); |
| ctx.mCommandHandler.AddStatus(ctx.mRequestPath, Status::InvalidCommand); |
| return; |
| } |
| |
| if (constraint.loadControl.Value() < -100 || constraint.loadControl.Value() > 100) |
| { |
| ChipLogError(Zcl, "DEM: RequestConstraintBasedForecast bad loadControl %d", constraint.loadControl.Value()); |
| ctx.mCommandHandler.AddStatus(ctx.mRequestPath, Status::ConstraintError); |
| return; |
| } |
| } |
| } |
| |
| if (iterator.GetStatus() != CHIP_NO_ERROR) |
| { |
| ctx.mCommandHandler.AddStatus(ctx.mRequestPath, Status::InvalidCommand); |
| return; |
| } |
| } |
| |
| // Check for overlappping elements |
| { |
| auto iterator = constraints.begin(); |
| if (iterator.Next()) |
| { |
| // Get the first constraint |
| Structs::ConstraintsStruct::DecodableType prevConstraint = iterator.GetValue(); |
| |
| // Start comparing next vs prev constraints |
| while (iterator.Next()) |
| { |
| const Structs::ConstraintsStruct::DecodableType & constraint = iterator.GetValue(); |
| if (constraint.startTime < prevConstraint.startTime || |
| prevConstraint.startTime + prevConstraint.duration >= constraint.startTime) |
| { |
| ChipLogError(Zcl, "DEM: RequestConstraintBasedForecast overlapping constraint times"); |
| ctx.mCommandHandler.AddStatus(ctx.mRequestPath, Status::ConstraintError); |
| return; |
| } |
| |
| prevConstraint = constraint; |
| } |
| } |
| |
| if (iterator.GetStatus() != CHIP_NO_ERROR) |
| { |
| ctx.mCommandHandler.AddStatus(ctx.mRequestPath, Status::InvalidCommand); |
| return; |
| } |
| } |
| |
| status = mDelegate.RequestConstraintBasedForecast(constraints, adjustmentCause); |
| ctx.mCommandHandler.AddStatus(ctx.mRequestPath, status); |
| if (status != Status::Success) |
| { |
| ChipLogError(Zcl, "DEM: RequestConstraintBasedForecast FAILURE"); |
| return; |
| } |
| } |
| |
| void Instance::HandleCancelRequest(HandlerContext & ctx, const Commands::CancelRequest::DecodableType & commandData) |
| { |
| Status status = Status::Failure; |
| DataModel::Nullable<Structs::ForecastStruct::Type> forecast = mDelegate.GetForecast(); |
| |
| if (forecast.IsNull()) |
| { |
| ChipLogDetail(AppServer, "Cancelling on a Null forecast!"); |
| status = Status::Failure; |
| } |
| else if (forecast.Value().forecastUpdateReason == ForecastUpdateReasonEnum::kInternalOptimization) |
| { |
| ChipLogDetail(AppServer, "Bad Cancel when ESA ForecastUpdateReason was already Internal Optimization!"); |
| status = Status::InvalidInState; |
| } |
| else |
| { |
| status = mDelegate.CancelRequest(); |
| } |
| |
| ctx.mCommandHandler.AddStatus(ctx.mRequestPath, status); |
| } |
| |
| Status Instance::GetMatterEpochTimeFromUnixTime(uint32_t & currentUtcTime) const |
| { |
| currentUtcTime = 0; |
| System::Clock::Milliseconds64 cTMs; |
| |
| CHIP_ERROR err = System::SystemClock().GetClock_RealTimeMS(cTMs); |
| if (err != CHIP_NO_ERROR) |
| { |
| ChipLogError(Zcl, "DEM: Unable to get current time - err:%" CHIP_ERROR_FORMAT, err.Format()); |
| return Status::Failure; |
| } |
| |
| auto unixEpoch = std::chrono::duration_cast<System::Clock::Seconds32>(cTMs).count(); |
| if (!UnixEpochToChipEpochTime(unixEpoch, currentUtcTime)) |
| { |
| ChipLogError(Zcl, "DEM: unable to convert Unix Epoch time to Matter Epoch Time"); |
| return Status::Failure; |
| } |
| |
| return Status::Success; |
| } |
| |
| } // namespace DeviceEnergyManagement |
| } // namespace Clusters |
| } // namespace app |
| } // namespace chip |
| |
| void MatterDeviceEnergyManagementPluginServerInitCallback() {} |
