blob: bfa5e1e97fa5881ba392e618d574ad0241532991 [file] [log] [blame]
/**
*
* Copyright (c) 2020 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 "window-covering-server.h"
#include <app-common/zap-generated/attributes/Accessors.h>
#include <app-common/zap-generated/cluster-objects.h>
#include <app/CommandHandler.h>
#include <app/ConcreteCommandPath.h>
#include <app/reporting/reporting.h>
#include <app/util/af-types.h>
#include <app/util/attribute-storage.h>
#include <app/util/config.h>
#include <lib/support/TypeTraits.h>
#include <string.h>
#ifdef MATTER_DM_PLUGIN_SCENES_MANAGEMENT
#include <app/clusters/scenes-server/scenes-server.h>
#endif // MATTER_DM_PLUGIN_SCENES_MANAGEMENT
using namespace chip;
using namespace chip::app::Clusters;
using namespace chip::app::Clusters::WindowCovering;
using chip::Protocols::InteractionModel::Status;
#define CHECK_BOUNDS_INVALID(MIN, VAL, MAX) ((VAL < MIN) || (VAL > MAX))
#define CHECK_BOUNDS_VALID(MIN, VAL, MAX) (!CHECK_BOUNDS_INVALID(MIN, VAL, MAX))
#define FAKE_MOTION_DELAY_MS 5000
namespace {
constexpr size_t kWindowCoveringDelegateTableSize =
MATTER_DM_WINDOW_COVERING_CLUSTER_SERVER_ENDPOINT_COUNT + CHIP_DEVICE_CONFIG_DYNAMIC_ENDPOINT_COUNT;
static_assert(kWindowCoveringDelegateTableSize <= kEmberInvalidEndpointIndex, "WindowCovering Delegate table size error");
Delegate * gDelegateTable[kWindowCoveringDelegateTableSize] = { nullptr };
Delegate * GetDelegate(EndpointId endpoint)
{
uint16_t ep =
emberAfGetClusterServerEndpointIndex(endpoint, WindowCovering::Id, MATTER_DM_WINDOW_COVERING_CLUSTER_SERVER_ENDPOINT_COUNT);
return (ep >= kWindowCoveringDelegateTableSize ? nullptr : gDelegateTable[ep]);
}
/*
* ConvertValue: Converts values from one range to another
* Range In -> from inputLowValue to inputHighValue
* Range Out -> from outputLowValue to outputtHighValue
*/
uint16_t ConvertValue(uint16_t inputLowValue, uint16_t inputHighValue, uint16_t outputLowValue, uint16_t outputHighValue,
uint16_t value)
{
uint16_t inputMin = inputLowValue, inputMax = inputHighValue, inputRange = UINT16_MAX;
uint16_t outputMin = outputLowValue, outputMax = outputHighValue, outputRange = UINT16_MAX;
if (inputLowValue > inputHighValue)
{
inputMin = inputHighValue;
inputMax = inputLowValue;
}
if (outputLowValue > outputHighValue)
{
outputMin = outputHighValue;
outputMax = outputLowValue;
}
inputRange = static_cast<uint16_t>(inputMax - inputMin);
outputRange = static_cast<uint16_t>(outputMax - outputMin);
if (value < inputMin)
{
return outputMin;
}
if (value > inputMax)
{
return outputMax;
}
if (inputRange > 0)
{
return static_cast<uint16_t>(outputMin + ((outputRange * (value - inputMin) / inputRange)));
}
return outputMax;
}
Percent100ths ValueToPercent100ths(AbsoluteLimits limits, uint16_t absolute)
{
return ConvertValue(limits.open, limits.closed, WC_PERCENT100THS_MIN_OPEN, WC_PERCENT100THS_MAX_CLOSED, absolute);
}
} // namespace
namespace chip {
namespace app {
namespace Clusters {
namespace WindowCovering {
bool HasFeature(chip::EndpointId endpoint, Feature feature)
{
bool hasFeature = false;
uint32_t featureMap = 0;
Status status = Attributes::FeatureMap::Get(endpoint, &featureMap);
if (Status::Success == status)
{
hasFeature = (featureMap & chip::to_underlying(feature));
}
return hasFeature;
}
bool HasFeaturePaLift(chip::EndpointId endpoint)
{
return (HasFeature(endpoint, Feature::kLift) && HasFeature(endpoint, Feature::kPositionAwareLift));
}
bool HasFeaturePaTilt(chip::EndpointId endpoint)
{
return (HasFeature(endpoint, Feature::kTilt) && HasFeature(endpoint, Feature::kPositionAwareTilt));
}
void TypeSet(chip::EndpointId endpoint, Type type)
{
Attributes::Type::Set(endpoint, type);
}
Type TypeGet(chip::EndpointId endpoint)
{
Type value;
Attributes::Type::Get(endpoint, &value);
return value;
}
void ConfigStatusPrint(const chip::BitMask<ConfigStatus> & configStatus)
{
ChipLogProgress(Zcl, "ConfigStatus 0x%02X Operational=%u OnlineReserved=%u", configStatus.Raw(),
configStatus.Has(ConfigStatus::kOperational), configStatus.Has(ConfigStatus::kOnlineReserved));
ChipLogProgress(Zcl, "Lift(PA=%u Encoder=%u Reversed=%u) Tilt(PA=%u Encoder=%u)",
configStatus.Has(ConfigStatus::kLiftPositionAware), configStatus.Has(ConfigStatus::kLiftEncoderControlled),
configStatus.Has(ConfigStatus::kLiftMovementReversed), configStatus.Has(ConfigStatus::kTiltPositionAware),
configStatus.Has(ConfigStatus::kTiltEncoderControlled));
}
void ConfigStatusSet(chip::EndpointId endpoint, const chip::BitMask<ConfigStatus> & configStatus)
{
Attributes::ConfigStatus::Set(endpoint, configStatus);
}
chip::BitMask<ConfigStatus> ConfigStatusGet(chip::EndpointId endpoint)
{
chip::BitMask<ConfigStatus> configStatus;
Attributes::ConfigStatus::Get(endpoint, &configStatus);
return configStatus;
}
void ConfigStatusUpdateFeatures(chip::EndpointId endpoint)
{
chip::BitMask<ConfigStatus> configStatus = ConfigStatusGet(endpoint);
configStatus.Set(ConfigStatus::kLiftPositionAware, HasFeaturePaLift(endpoint));
configStatus.Set(ConfigStatus::kTiltPositionAware, HasFeaturePaTilt(endpoint));
if (!HasFeaturePaLift(endpoint))
configStatus.Clear(ConfigStatus::kLiftEncoderControlled);
if (!HasFeaturePaTilt(endpoint))
configStatus.Clear(ConfigStatus::kTiltEncoderControlled);
ConfigStatusSet(endpoint, configStatus);
}
void OperationalStatusPrint(const chip::BitMask<OperationalStatus> & opStatus)
{
ChipLogProgress(Zcl, "OperationalStatus raw=0x%02X global=%u lift=%u tilt=%u", opStatus.Raw(),
opStatus.GetField(OperationalStatus::kGlobal), opStatus.GetField(OperationalStatus::kLift),
opStatus.GetField(OperationalStatus::kTilt));
}
chip::BitMask<OperationalStatus> OperationalStatusGet(chip::EndpointId endpoint)
{
chip::BitMask<OperationalStatus> status;
Attributes::OperationalStatus::Get(endpoint, &status);
return status;
}
void OperationalStatusSet(chip::EndpointId endpoint, chip::BitMask<OperationalStatus> newStatus)
{
chip::BitMask<OperationalStatus> prevStatus;
Attributes::OperationalStatus::Get(endpoint, &prevStatus);
// Filter changes
if (newStatus != prevStatus)
{
OperationalStatusPrint(newStatus);
Attributes::OperationalStatus::Set(endpoint, newStatus);
}
}
void OperationalStateSet(chip::EndpointId endpoint, const chip::BitMask<OperationalStatus> field, OperationalState state)
{
chip::BitMask<OperationalStatus> status;
Attributes::OperationalStatus::Get(endpoint, &status);
/* Filter only Lift or Tilt action since we cannot allow global reflecting a state alone */
if ((OperationalStatus::kLift == field) || (OperationalStatus::kTilt == field))
{
status.SetField(field, static_cast<uint8_t>(state));
status.SetField(OperationalStatus::kGlobal, static_cast<uint8_t>(state));
/* Global Always follow Lift by priority or therefore fallback to Tilt */
chip::BitMask<OperationalStatus> opGlobal =
status.HasAny(OperationalStatus::kLift) ? OperationalStatus::kLift : OperationalStatus::kTilt;
status.SetField(OperationalStatus::kGlobal, status.GetField(opGlobal));
OperationalStatusSet(endpoint, status);
}
}
OperationalState OperationalStateGet(chip::EndpointId endpoint, const chip::BitMask<OperationalStatus> field)
{
chip::BitMask<OperationalStatus> status;
Attributes::OperationalStatus::Get(endpoint, &status);
return static_cast<OperationalState>(status.GetField(field));
}
void EndProductTypeSet(chip::EndpointId endpoint, EndProductType type)
{
Attributes::EndProductType::Set(endpoint, type);
}
EndProductType EndProductTypeGet(chip::EndpointId endpoint)
{
EndProductType value;
Attributes::EndProductType::Get(endpoint, &value);
return value;
}
void ModePrint(const chip::BitMask<Mode> & mode)
{
ChipLogProgress(Zcl, "Mode 0x%02X MotorDirReversed=%u LedFeedback=%u Maintenance=%u Calibration=%u", mode.Raw(),
mode.Has(Mode::kMotorDirectionReversed), mode.Has(Mode::kLedFeedback), mode.Has(Mode::kMaintenanceMode),
mode.Has(Mode::kCalibrationMode));
}
void ModeSet(chip::EndpointId endpoint, chip::BitMask<Mode> & newMode)
{
chip::BitMask<ConfigStatus> newStatus;
chip::BitMask<ConfigStatus> oldStatus = ConfigStatusGet(endpoint);
chip::BitMask<Mode> oldMode = ModeGet(endpoint);
newStatus = oldStatus;
// Attribute: ConfigStatus reflects the following current mode flags
newStatus.Set(ConfigStatus::kOperational, !newMode.HasAny(Mode::kMaintenanceMode, Mode::kCalibrationMode));
newStatus.Set(ConfigStatus::kLiftMovementReversed, newMode.Has(Mode::kMotorDirectionReversed));
// Verify only one mode supported at once and maintenance lock goes over calibration
if (newMode.HasAll(Mode::kMaintenanceMode, Mode::kCalibrationMode))
{
newMode.Clear(Mode::kCalibrationMode);
}
if (oldMode != newMode)
Attributes::Mode::Set(endpoint, newMode);
if (oldStatus != newStatus)
ConfigStatusSet(endpoint, newStatus);
}
chip::BitMask<Mode> ModeGet(chip::EndpointId endpoint)
{
chip::BitMask<Mode> mode;
Attributes::Mode::Get(endpoint, &mode);
return mode;
}
void SafetyStatusSet(chip::EndpointId endpoint, chip::BitMask<SafetyStatus> & newSafetyStatus)
{
Attributes::SafetyStatus::Set(endpoint, newSafetyStatus);
}
chip::BitMask<SafetyStatus> SafetyStatusGet(chip::EndpointId endpoint)
{
chip::BitMask<SafetyStatus> safetyStatus;
Attributes::SafetyStatus::Get(endpoint, &safetyStatus);
return safetyStatus;
}
LimitStatus CheckLimitState(uint16_t position, AbsoluteLimits limits)
{
if (limits.open > limits.closed)
return LimitStatus::Inverted;
if (position == limits.open)
return LimitStatus::IsUpOrOpen;
if (position == limits.closed)
return LimitStatus::IsDownOrClose;
if ((limits.open > 0) && (position < limits.open))
return LimitStatus::IsPastUpOrOpen;
if ((limits.closed > 0) && (position > limits.closed))
return LimitStatus::IsPastDownOrClose;
return LimitStatus::Intermediate;
}
bool IsPercent100thsValid(Percent100ths percent100ths)
{
if (CHECK_BOUNDS_VALID(WC_PERCENT100THS_MIN_OPEN, percent100ths, WC_PERCENT100THS_MAX_CLOSED))
return true;
return false;
}
bool IsPercent100thsValid(NPercent100ths percent100ths)
{
if (!percent100ths.IsNull())
{
return IsPercent100thsValid(percent100ths.Value());
}
return true;
}
uint16_t Percent100thsToValue(AbsoluteLimits limits, Percent100ths relative)
{
return ConvertValue(WC_PERCENT100THS_MIN_OPEN, WC_PERCENT100THS_MAX_CLOSED, limits.open, limits.closed, relative);
}
uint16_t LiftToPercent100ths(chip::EndpointId endpoint, uint16_t lift)
{
uint16_t openLimit = 0;
uint16_t closedLimit = 0;
Attributes::InstalledOpenLimitLift::Get(endpoint, &openLimit);
Attributes::InstalledClosedLimitLift::Get(endpoint, &closedLimit);
AbsoluteLimits limits = { .open = openLimit, .closed = closedLimit };
return ValueToPercent100ths(limits, lift);
}
uint16_t Percent100thsToLift(chip::EndpointId endpoint, uint16_t percent100ths)
{
uint16_t openLimit = 0;
uint16_t closedLimit = 0;
Attributes::InstalledOpenLimitLift::Get(endpoint, &openLimit);
Attributes::InstalledClosedLimitLift::Get(endpoint, &closedLimit);
AbsoluteLimits limits = { .open = openLimit, .closed = closedLimit };
return Percent100thsToValue(limits, percent100ths);
}
void LiftPositionSet(chip::EndpointId endpoint, NPercent100ths percent100ths)
{
NPercent percent;
NAbsolute rawpos;
if (percent100ths.IsNull())
{
percent.SetNull();
rawpos.SetNull();
ChipLogProgress(Zcl, "Lift[%u] Position Set to Null", endpoint);
}
else
{
percent.SetNonNull(static_cast<uint8_t>(percent100ths.Value() / 100));
rawpos.SetNonNull(Percent100thsToLift(endpoint, percent100ths.Value()));
ChipLogProgress(Zcl, "Lift[%u] Position Set: %u", endpoint, percent100ths.Value());
}
Attributes::CurrentPositionLift::Set(endpoint, rawpos);
Attributes::CurrentPositionLiftPercentage::Set(endpoint, percent);
Attributes::CurrentPositionLiftPercent100ths::Set(endpoint, percent100ths);
}
uint16_t TiltToPercent100ths(chip::EndpointId endpoint, uint16_t tilt)
{
uint16_t openLimit = 0;
uint16_t closedLimit = 0;
Attributes::InstalledOpenLimitTilt::Get(endpoint, &openLimit);
Attributes::InstalledClosedLimitTilt::Get(endpoint, &closedLimit);
AbsoluteLimits limits = { .open = openLimit, .closed = closedLimit };
return ValueToPercent100ths(limits, tilt);
}
uint16_t Percent100thsToTilt(chip::EndpointId endpoint, uint16_t percent100ths)
{
uint16_t openLimit = 0;
uint16_t closedLimit = 0;
Attributes::InstalledOpenLimitTilt::Get(endpoint, &openLimit);
Attributes::InstalledClosedLimitTilt::Get(endpoint, &closedLimit);
AbsoluteLimits limits = { .open = openLimit, .closed = closedLimit };
return Percent100thsToValue(limits, percent100ths);
}
void TiltPositionSet(chip::EndpointId endpoint, NPercent100ths percent100ths)
{
NPercent percent;
NAbsolute rawpos;
if (percent100ths.IsNull())
{
percent.SetNull();
rawpos.SetNull();
ChipLogProgress(Zcl, "Tilt[%u] Position Set to Null", endpoint);
}
else
{
percent.SetNonNull(static_cast<uint8_t>(percent100ths.Value() / 100));
rawpos.SetNonNull(Percent100thsToTilt(endpoint, percent100ths.Value()));
ChipLogProgress(Zcl, "Tilt[%u] Position Set: %u", endpoint, percent100ths.Value());
}
Attributes::CurrentPositionTilt::Set(endpoint, rawpos);
Attributes::CurrentPositionTiltPercentage::Set(endpoint, percent);
Attributes::CurrentPositionTiltPercent100ths::Set(endpoint, percent100ths);
}
OperationalState ComputeOperationalState(uint16_t target, uint16_t current)
{
OperationalState opState = OperationalState::Stall;
if (current != target)
{
opState = (current < target) ? OperationalState::MovingDownOrClose : OperationalState::MovingUpOrOpen;
}
return opState;
}
OperationalState ComputeOperationalState(NPercent100ths target, NPercent100ths current)
{
if (!current.IsNull() && !target.IsNull())
{
return ComputeOperationalState(target.Value(), current.Value());
}
return OperationalState::Stall;
}
Percent100ths ComputePercent100thsStep(OperationalState direction, Percent100ths previous, Percent100ths delta)
{
Percent100ths percent100ths = previous;
switch (direction)
{
case OperationalState::MovingDownOrClose:
if (percent100ths < (WC_PERCENT100THS_MAX_CLOSED - delta))
{
percent100ths = static_cast<Percent100ths>(percent100ths + delta);
}
else
{
percent100ths = WC_PERCENT100THS_MAX_CLOSED;
}
break;
case OperationalState::MovingUpOrOpen:
if (percent100ths > (WC_PERCENT100THS_MIN_OPEN + delta))
{
percent100ths = static_cast<Percent100ths>(percent100ths - delta);
}
else
{
percent100ths = WC_PERCENT100THS_MIN_OPEN;
}
break;
default:
// nothing to do we keep previous value, simple passthrought
break;
}
if (percent100ths > WC_PERCENT100THS_MAX_CLOSED)
return WC_PERCENT100THS_MAX_CLOSED;
return percent100ths;
}
void PostAttributeChange(chip::EndpointId endpoint, chip::AttributeId attributeId)
{
// all-cluster-app: simulation for the CI testing
// otherwise it is defined for manufacturer specific implementation */
BitMask<Mode> mode;
BitMask<ConfigStatus> configStatus;
NPercent100ths current, target;
ChipLogProgress(Zcl, "WC POST ATTRIBUTE=%u", (unsigned int) attributeId);
OperationalState opLift = OperationalStateGet(endpoint, OperationalStatus::kLift);
OperationalState opTilt = OperationalStateGet(endpoint, OperationalStatus::kTilt);
switch (attributeId)
{
/* ============= Positions for Position Aware ============= */
case Attributes::CurrentPositionLiftPercent100ths::Id:
Attributes::TargetPositionLiftPercent100ths::Get(endpoint, target);
Attributes::CurrentPositionLiftPercent100ths::Get(endpoint, current);
if ((OperationalState::Stall != opLift) && (current == target))
{
ChipLogProgress(Zcl, "Lift stop");
OperationalStateSet(endpoint, OperationalStatus::kLift, OperationalState::Stall);
}
break;
case Attributes::CurrentPositionTiltPercent100ths::Id:
Attributes::TargetPositionTiltPercent100ths::Get(endpoint, target);
Attributes::CurrentPositionTiltPercent100ths::Get(endpoint, current);
if ((OperationalState::Stall != opTilt) && (current == target))
{
ChipLogProgress(Zcl, "Tilt stop");
OperationalStateSet(endpoint, OperationalStatus::kTilt, OperationalState::Stall);
}
break;
/* For a device supporting Position Awareness : Changing the Target triggers motions on the real or simulated device */
case Attributes::TargetPositionLiftPercent100ths::Id:
Attributes::TargetPositionLiftPercent100ths::Get(endpoint, target);
Attributes::CurrentPositionLiftPercent100ths::Get(endpoint, current);
opLift = ComputeOperationalState(target, current);
OperationalStateSet(endpoint, OperationalStatus::kLift, opLift);
break;
/* For a device supporting Position Awareness : Changing the Target triggers motions on the real or simulated device */
case Attributes::TargetPositionTiltPercent100ths::Id:
Attributes::TargetPositionTiltPercent100ths::Get(endpoint, target);
Attributes::CurrentPositionTiltPercent100ths::Get(endpoint, current);
opTilt = ComputeOperationalState(target, current);
OperationalStateSet(endpoint, OperationalStatus::kTilt, opTilt);
break;
/* Mode change is either internal from the application or external from a write request */
case Attributes::Mode::Id:
mode = ModeGet(endpoint);
ModePrint(mode);
ModeSet(endpoint, mode); // refilter mode if needed
break;
case Attributes::ConfigStatus::Id:
configStatus = ConfigStatusGet(endpoint);
ConfigStatusPrint(configStatus);
break;
default:
break;
}
}
Status GetMotionLockStatus(chip::EndpointId endpoint)
{
BitMask<Mode> mode = ModeGet(endpoint);
BitMask<ConfigStatus> configStatus = ConfigStatusGet(endpoint);
// Is the device locked?
if (!configStatus.Has(ConfigStatus::kOperational))
{
if (mode.Has(Mode::kMaintenanceMode))
{
// Mainterance Mode
return Status::Busy;
}
if (mode.Has(Mode::kCalibrationMode))
{
// Calibration Mode
return Status::Failure;
}
}
return Status::Success;
}
void SetDefaultDelegate(EndpointId endpoint, Delegate * delegate)
{
uint16_t ep =
emberAfGetClusterServerEndpointIndex(endpoint, WindowCovering::Id, MATTER_DM_WINDOW_COVERING_CLUSTER_SERVER_ENDPOINT_COUNT);
// if endpoint is found
if (ep < kWindowCoveringDelegateTableSize)
{
gDelegateTable[ep] = delegate;
}
else
{
ChipLogProgress(Zcl, "Failed to set WindowCovering delegate for endpoint:%u", endpoint);
}
}
} // namespace WindowCovering
} // namespace Clusters
} // namespace app
} // namespace chip
//------------------------------------------------------------------------------
// Callbacks
//------------------------------------------------------------------------------
/**
* @brief Cluster UpOrOpen Command callback (from client)
*/
bool emberAfWindowCoveringClusterUpOrOpenCallback(app::CommandHandler * commandObj, const app::ConcreteCommandPath & commandPath,
const Commands::UpOrOpen::DecodableType & commandData)
{
EndpointId endpoint = commandPath.mEndpointId;
ChipLogProgress(Zcl, "UpOrOpen command received");
Status status = GetMotionLockStatus(endpoint);
if (Status::Success != status)
{
ChipLogProgress(Zcl, "Err device locked");
commandObj->AddStatus(commandPath, status);
return true;
}
if (HasFeature(endpoint, Feature::kPositionAwareLift))
{
Attributes::TargetPositionLiftPercent100ths::Set(endpoint, WC_PERCENT100THS_MIN_OPEN);
}
if (HasFeature(endpoint, Feature::kPositionAwareTilt))
{
Attributes::TargetPositionTiltPercent100ths::Set(endpoint, WC_PERCENT100THS_MIN_OPEN);
}
Delegate * delegate = GetDelegate(endpoint);
if (delegate)
{
if (HasFeature(endpoint, Feature::kPositionAwareLift))
{
LogErrorOnFailure(delegate->HandleMovement(WindowCoveringType::Lift));
}
if (HasFeature(endpoint, Feature::kPositionAwareTilt))
{
LogErrorOnFailure(delegate->HandleMovement(WindowCoveringType::Tilt));
}
}
else
{
ChipLogProgress(Zcl, "WindowCovering has no delegate set for endpoint:%u", endpoint);
}
commandObj->AddStatus(commandPath, Status::Success);
return true;
}
/**
* @brief Cluster DownOrClose Command callback (from client)
*/
bool emberAfWindowCoveringClusterDownOrCloseCallback(app::CommandHandler * commandObj, const app::ConcreteCommandPath & commandPath,
const Commands::DownOrClose::DecodableType & commandData)
{
EndpointId endpoint = commandPath.mEndpointId;
ChipLogProgress(Zcl, "DownOrClose command received");
Status status = GetMotionLockStatus(endpoint);
if (Status::Success != status)
{
ChipLogProgress(Zcl, "Err device locked");
commandObj->AddStatus(commandPath, status);
return true;
}
if (HasFeature(endpoint, Feature::kPositionAwareLift))
{
Attributes::TargetPositionLiftPercent100ths::Set(endpoint, WC_PERCENT100THS_MAX_CLOSED);
}
if (HasFeature(endpoint, Feature::kPositionAwareTilt))
{
Attributes::TargetPositionTiltPercent100ths::Set(endpoint, WC_PERCENT100THS_MAX_CLOSED);
}
commandObj->AddStatus(commandPath, Status::Success);
Delegate * delegate = GetDelegate(endpoint);
if (delegate)
{
if (HasFeature(endpoint, Feature::kPositionAwareLift))
{
LogErrorOnFailure(delegate->HandleMovement(WindowCoveringType::Lift));
}
if (HasFeature(endpoint, Feature::kPositionAwareTilt))
{
LogErrorOnFailure(delegate->HandleMovement(WindowCoveringType::Tilt));
}
}
else
{
ChipLogProgress(Zcl, "WindowCovering has no delegate set for endpoint:%u", endpoint);
}
return true;
}
/**
* @brief Cluster StopMotion Command callback (from client)
*/
bool emberAfWindowCoveringClusterStopMotionCallback(app::CommandHandler * commandObj, const app::ConcreteCommandPath & commandPath,
const Commands::StopMotion::DecodableType & fields)
{
app::DataModel::Nullable<Percent100ths> current;
chip::EndpointId endpoint = commandPath.mEndpointId;
ChipLogProgress(Zcl, "StopMotion command received");
Status status = GetMotionLockStatus(endpoint);
if (Status::Success != status)
{
ChipLogProgress(Zcl, "Err device locked");
commandObj->AddStatus(commandPath, status);
return true;
}
bool changeTarget = true;
Delegate * delegate = GetDelegate(endpoint);
if (delegate)
{
CHIP_ERROR err = delegate->HandleStopMotion();
if (err == CHIP_ERROR_IN_PROGRESS)
{
changeTarget = false;
}
else
{
LogErrorOnFailure(err);
}
}
else
{
ChipLogProgress(Zcl, "WindowCovering has no delegate set for endpoint:%u", endpoint);
}
if (changeTarget)
{
if (HasFeaturePaLift(endpoint))
{
(void) Attributes::CurrentPositionLiftPercent100ths::Get(endpoint, current);
(void) Attributes::TargetPositionLiftPercent100ths::Set(endpoint, current);
}
if (HasFeaturePaTilt(endpoint))
{
(void) Attributes::CurrentPositionTiltPercent100ths::Get(endpoint, current);
(void) Attributes::TargetPositionTiltPercent100ths::Set(endpoint, current);
}
}
commandObj->AddStatus(commandPath, Status::Success);
return true;
}
/**
* @brief Cluster GoToLiftValue Command callback (from client)
*/
bool emberAfWindowCoveringClusterGoToLiftValueCallback(app::CommandHandler * commandObj,
const app::ConcreteCommandPath & commandPath,
const Commands::GoToLiftValue::DecodableType & commandData)
{
auto & liftValue = commandData.liftValue;
EndpointId endpoint = commandPath.mEndpointId;
ChipLogProgress(Zcl, "GoToLiftValue %u command received", liftValue);
Status status = GetMotionLockStatus(endpoint);
if (Status::Success != status)
{
ChipLogProgress(Zcl, "Err device locked");
commandObj->AddStatus(commandPath, status);
return true;
}
if (HasFeature(endpoint, Feature::kAbsolutePosition) && HasFeaturePaLift(endpoint))
{
Attributes::TargetPositionLiftPercent100ths::Set(endpoint, LiftToPercent100ths(endpoint, liftValue));
Delegate * delegate = GetDelegate(endpoint);
if (delegate)
{
LogErrorOnFailure(delegate->HandleMovement(WindowCoveringType::Lift));
}
else
{
ChipLogProgress(Zcl, "WindowCovering has no delegate set for endpoint:%u", endpoint);
}
commandObj->AddStatus(commandPath, Status::Success);
}
else
{
ChipLogProgress(Zcl, "Err Device is not PA LF");
commandObj->AddStatus(commandPath, Status::Failure);
}
return true;
}
/**
* @brief Cluster GoToLiftPercentage Command callback (from client)
*/
bool emberAfWindowCoveringClusterGoToLiftPercentageCallback(app::CommandHandler * commandObj,
const app::ConcreteCommandPath & commandPath,
const Commands::GoToLiftPercentage::DecodableType & commandData)
{
Percent100ths percent100ths = commandData.liftPercent100thsValue;
EndpointId endpoint = commandPath.mEndpointId;
ChipLogProgress(Zcl, "GoToLiftPercentage %u command received", percent100ths);
Status status = GetMotionLockStatus(endpoint);
if (Status::Success != status)
{
ChipLogProgress(Zcl, "Err device locked");
commandObj->AddStatus(commandPath, status);
return true;
}
if (HasFeaturePaLift(endpoint))
{
if (IsPercent100thsValid(percent100ths))
{
Attributes::TargetPositionLiftPercent100ths::Set(endpoint, percent100ths);
Delegate * delegate = GetDelegate(endpoint);
if (delegate)
{
LogErrorOnFailure(delegate->HandleMovement(WindowCoveringType::Lift));
}
else
{
ChipLogProgress(Zcl, "WindowCovering has no delegate set for endpoint:%u", endpoint);
}
commandObj->AddStatus(commandPath, Status::Success);
}
else
{
commandObj->AddStatus(commandPath, Status::ConstraintError);
}
}
else
{
ChipLogProgress(Zcl, "Err Device is not PA LF");
commandObj->AddStatus(commandPath, Status::Failure);
}
return true;
}
/**
* @brief Cluster GoToTiltValue Command callback (from client)
*/
bool emberAfWindowCoveringClusterGoToTiltValueCallback(app::CommandHandler * commandObj,
const app::ConcreteCommandPath & commandPath,
const Commands::GoToTiltValue::DecodableType & commandData)
{
auto & tiltValue = commandData.tiltValue;
EndpointId endpoint = commandPath.mEndpointId;
ChipLogProgress(Zcl, "GoToTiltValue %u command received", tiltValue);
Status status = GetMotionLockStatus(endpoint);
if (Status::Success != status)
{
ChipLogProgress(Zcl, "Err device locked");
commandObj->AddStatus(commandPath, status);
return true;
}
if (HasFeature(endpoint, Feature::kAbsolutePosition) && HasFeaturePaTilt(endpoint))
{
Attributes::TargetPositionTiltPercent100ths::Set(endpoint, TiltToPercent100ths(endpoint, tiltValue));
Delegate * delegate = GetDelegate(endpoint);
if (delegate)
{
LogErrorOnFailure(delegate->HandleMovement(WindowCoveringType::Tilt));
}
else
{
ChipLogProgress(Zcl, "WindowCovering has no delegate set for endpoint:%u", endpoint);
}
commandObj->AddStatus(commandPath, Status::Success);
}
else
{
ChipLogProgress(Zcl, "Err Device is not PA TL");
commandObj->AddStatus(commandPath, Status::Failure);
}
return true;
}
/**
* @brief Cluster GoToTiltPercentage Command callback (from client)
*/
bool emberAfWindowCoveringClusterGoToTiltPercentageCallback(app::CommandHandler * commandObj,
const app::ConcreteCommandPath & commandPath,
const Commands::GoToTiltPercentage::DecodableType & commandData)
{
Percent100ths percent100ths = commandData.tiltPercent100thsValue;
EndpointId endpoint = commandPath.mEndpointId;
ChipLogProgress(Zcl, "GoToTiltPercentage %u command received", percent100ths);
Status status = GetMotionLockStatus(endpoint);
if (Status::Success != status)
{
ChipLogProgress(Zcl, "Err device locked");
commandObj->AddStatus(commandPath, status);
return true;
}
if (HasFeaturePaTilt(endpoint))
{
if (IsPercent100thsValid(percent100ths))
{
Attributes::TargetPositionTiltPercent100ths::Set(endpoint, percent100ths);
Delegate * delegate = GetDelegate(endpoint);
if (delegate)
{
LogErrorOnFailure(delegate->HandleMovement(WindowCoveringType::Tilt));
}
else
{
ChipLogProgress(Zcl, "WindowCovering has no delegate set for endpoint:%u", endpoint);
}
commandObj->AddStatus(commandPath, Status::Success);
}
else
{
commandObj->AddStatus(commandPath, Status::ConstraintError);
}
}
else
{
ChipLogProgress(Zcl, "Err Device is not PA TL");
commandObj->AddStatus(commandPath, Status::Failure);
}
return true;
}
/**
* @brief Cluster Attribute Changed Callback
*
* The method is implemented by default as a weak function and it takes care of updating
* the server attribute values by calling the PostAttributeChange method. If the application overrides
* this method, it needs to handle updating attributes (ideally by calling PostAttributeChange).
*
*/
void __attribute__((weak))
MatterWindowCoveringClusterServerAttributeChangedCallback(const app::ConcreteAttributePath & attributePath)
{
PostAttributeChange(attributePath.mEndpointId, attributePath.mAttributeId);
}
/**
* @brief Cluster Plugin Init Callback
*/
void MatterWindowCoveringPluginServerInitCallback() {}