| /* |
| * |
| * Copyright (c) 2022 Project CHIP Authors |
| * All rights reserved. |
| * |
| * 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 "BindingHandler.h" |
| #include "ColorControlCommands.h" |
| #include "IdentifyCommand.h" |
| #include "LevelControlCommands.h" |
| #include "OnOffCommands.h" |
| #include "ThermostatCommands.h" |
| #include "app/clusters/bindings/BindingManager.h" |
| #include "app/server/Server.h" |
| #include "controller/InvokeInteraction.h" |
| #include "controller/ReadInteraction.h" |
| #include "platform/CHIPDeviceLayer.h" |
| #include <app/clusters/bindings/bindings.h> |
| #include <lib/support/CodeUtils.h> |
| |
| #if CONFIG_ENABLE_CHIP_SHELL |
| #include "lib/shell/Engine.h" |
| #include "lib/shell/commands/Help.h" |
| #endif // ENABLE_CHIP_SHELL |
| |
| using namespace chip; |
| using namespace chip::app; |
| |
| #if CONFIG_ENABLE_CHIP_SHELL |
| using Shell::Engine; |
| using Shell::shell_command_t; |
| using Shell::streamer_get; |
| using Shell::streamer_printf; |
| |
| Engine sShellSwitchSubCommands; |
| Engine sShellSwitchGroupsSubCommands; |
| Engine sShellSwitchBindingSubCommands; |
| #endif // defined(ENABLE_CHIP_SHELL) |
| |
| namespace { |
| void LightSwitchChangedHandler(const EmberBindingTableEntry & binding, OperationalDeviceProxy * peer_device, void * context) |
| { |
| VerifyOrReturn(context != nullptr, ChipLogError(NotSpecified, "OnDeviceConnectedFn: context is null")); |
| BindingCommandData * data = static_cast<BindingCommandData *>(context); |
| |
| if (data->isReadAttribute) |
| { |
| // It should always enter here if isReadAttribute is true |
| if (binding.type == MATTER_UNICAST_BINDING && !data->isGroup) |
| { |
| switch (data->clusterId) |
| { |
| case Clusters::Identify::Id: |
| ProcessIdentifyUnicastBindingRead(data, binding, peer_device); |
| break; |
| case Clusters::OnOff::Id: |
| ProcessOnOffUnicastBindingRead(data, binding, peer_device); |
| break; |
| case Clusters::LevelControl::Id: |
| ProcessLevelControlUnicastBindingRead(data, binding, peer_device); |
| break; |
| case Clusters::ColorControl::Id: |
| ProcessColorControlUnicastBindingRead(data, binding, peer_device); |
| break; |
| case Clusters::Thermostat::Id: |
| ProcessThermostatUnicastBindingRead(data, binding, peer_device); |
| break; |
| } |
| } |
| } |
| else |
| { |
| if (binding.type == MATTER_MULTICAST_BINDING && data->isGroup) |
| { |
| switch (data->clusterId) |
| { |
| case Clusters::Identify::Id: |
| ProcessIdentifyGroupBindingCommand(data, binding); |
| break; |
| case Clusters::OnOff::Id: |
| ProcessOnOffGroupBindingCommand(data, binding); |
| break; |
| case Clusters::LevelControl::Id: |
| ProcessColorControlGroupBindingCommand(data, binding); |
| break; |
| case Clusters::ColorControl::Id: |
| ProcessColorControlGroupBindingCommand(data, binding); |
| break; |
| case Clusters::Thermostat::Id: |
| ProcessThermostatGroupBindingCommand(data, binding); |
| break; |
| } |
| } |
| else if (binding.type == MATTER_UNICAST_BINDING && !data->isGroup) |
| { |
| switch (data->clusterId) |
| { |
| case Clusters::Identify::Id: |
| ProcessIdentifyUnicastBindingCommand(data, binding, peer_device); |
| break; |
| case Clusters::OnOff::Id: |
| ProcessOnOffUnicastBindingCommand(data, binding, peer_device); |
| break; |
| case Clusters::LevelControl::Id: |
| ProcessLevelControlUnicastBindingCommand(data, binding, peer_device); |
| break; |
| case Clusters::ColorControl::Id: |
| ProcessColorControlUnicastBindingCommand(data, binding, peer_device); |
| break; |
| case Clusters::Thermostat::Id: |
| ProcessThermostatUnicastBindingCommand(data, binding, peer_device); |
| break; |
| } |
| } |
| } |
| } |
| |
| void LightSwitchContextReleaseHandler(void * context) |
| { |
| VerifyOrReturn(context != nullptr, ChipLogError(NotSpecified, "Invalid context for Light switch context release handler")); |
| |
| Platform::Delete(static_cast<BindingCommandData *>(context)); |
| } |
| |
| void InitBindingHandlerInternal(intptr_t arg) |
| { |
| auto & server = chip::Server::GetInstance(); |
| chip::BindingManager::GetInstance().Init( |
| { &server.GetFabricTable(), server.GetCASESessionManager(), &server.GetPersistentStorage() }); |
| chip::BindingManager::GetInstance().RegisterBoundDeviceChangedHandler(LightSwitchChangedHandler); |
| chip::BindingManager::GetInstance().RegisterBoundDeviceContextReleaseHandler(LightSwitchContextReleaseHandler); |
| } |
| |
| #if CONFIG_ENABLE_CHIP_SHELL |
| |
| /******************************************************** |
| * Switch shell functions |
| *********************************************************/ |
| |
| CHIP_ERROR SwitchHelpHandler(int argc, char ** argv) |
| { |
| sShellSwitchSubCommands.ForEachCommand(Shell::PrintCommandHelp, nullptr); |
| return CHIP_NO_ERROR; |
| } |
| |
| CHIP_ERROR SwitchCommandHandler(int argc, char ** argv) |
| { |
| if (argc == 0) |
| { |
| return SwitchHelpHandler(argc, argv); |
| } |
| |
| return sShellSwitchSubCommands.ExecCommand(argc, argv); |
| } |
| |
| /******************************************************** |
| * bind switch shell functions |
| *********************************************************/ |
| |
| CHIP_ERROR BindingHelpHandler(int argc, char ** argv) |
| { |
| sShellSwitchBindingSubCommands.ForEachCommand(Shell::PrintCommandHelp, nullptr); |
| return CHIP_NO_ERROR; |
| } |
| |
| CHIP_ERROR BindingSwitchCommandHandler(int argc, char ** argv) |
| { |
| if (argc == 0) |
| { |
| return BindingHelpHandler(argc, argv); |
| } |
| |
| return sShellSwitchBindingSubCommands.ExecCommand(argc, argv); |
| } |
| |
| CHIP_ERROR BindingGroupBindCommandHandler(int argc, char ** argv) |
| { |
| VerifyOrReturnError(argc == 2, CHIP_ERROR_INVALID_ARGUMENT); |
| |
| EmberBindingTableEntry * entry = Platform::New<EmberBindingTableEntry>(); |
| entry->type = MATTER_MULTICAST_BINDING; |
| entry->fabricIndex = atoi(argv[0]); |
| entry->groupId = atoi(argv[1]); |
| entry->local = 1; // Hardcoded to endpoint 1 for now |
| entry->clusterId.emplace(6); // Hardcoded to OnOff cluster for now |
| |
| DeviceLayer::PlatformMgr().ScheduleWork(BindingWorkerFunction, reinterpret_cast<intptr_t>(entry)); |
| return CHIP_NO_ERROR; |
| } |
| |
| CHIP_ERROR BindingUnicastBindCommandHandler(int argc, char ** argv) |
| { |
| VerifyOrReturnError(argc == 3, CHIP_ERROR_INVALID_ARGUMENT); |
| |
| EmberBindingTableEntry * entry = Platform::New<EmberBindingTableEntry>(); |
| entry->type = MATTER_UNICAST_BINDING; |
| entry->fabricIndex = atoi(argv[0]); |
| entry->nodeId = atoi(argv[1]); |
| entry->local = 1; // Hardcoded to endpoint 1 for now |
| entry->remote = atoi(argv[2]); |
| entry->clusterId.emplace(6); // Hardcode to OnOff cluster for now |
| |
| DeviceLayer::PlatformMgr().ScheduleWork(BindingWorkerFunction, reinterpret_cast<intptr_t>(entry)); |
| return CHIP_NO_ERROR; |
| } |
| |
| /******************************************************** |
| * Groups switch shell functions |
| *********************************************************/ |
| |
| CHIP_ERROR GroupsHelpHandler(int argc, char ** argv) |
| { |
| sShellSwitchGroupsSubCommands.ForEachCommand(Shell::PrintCommandHelp, nullptr); |
| return CHIP_NO_ERROR; |
| } |
| |
| CHIP_ERROR GroupsSwitchCommandHandler(int argc, char ** argv) |
| { |
| if (argc == 0) |
| { |
| return GroupsHelpHandler(argc, argv); |
| } |
| |
| return sShellSwitchGroupsSubCommands.ExecCommand(argc, argv); |
| } |
| |
| /** |
| * @brief configures switch matter shell |
| * |
| */ |
| static void RegisterSwitchCommands() |
| { |
| |
| static const shell_command_t sSwitchSubCommands[] = { |
| { &SwitchHelpHandler, "help", "Usage: switch <subcommand>" }, |
| { &IdentifySwitchCommandHandler, "identify", " Usage: switch identify <subcommand>" }, |
| { &OnOffSwitchCommandHandler, "onoff", " Usage: switch onoff <subcommand>" }, |
| { &LevelControlSwitchCommandHandler, "levelcontrol", " Usage: switch levlecontrol <subcommand>" }, |
| { &ColorControlSwitchCommandHandler, "colorcontrol", " Usage: switch colorcontrol <subcommand>" }, |
| { &ThermostatSwitchCommandHandler, "thermostat", " Usage: switch thermostat <subcommand>" }, |
| { &GroupsSwitchCommandHandler, "groups", "Usage: switch groups <subcommand>" }, |
| { &BindingSwitchCommandHandler, "binding", "Usage: switch binding <subcommand>" } |
| }; |
| |
| static const shell_command_t sSwitchIdentifySubCommands[] = { |
| { &IdentifyHelpHandler, "help", "Usage: switch identify <subcommand>" }, |
| { &IdentifyCommandHandler, "identify", "identify Usage: switch identify identify" }, |
| { &TriggerEffectSwitchCommandHandler, "triggereffect", "triggereffect Usage: switch identify triggereffect" }, |
| { &IdentifyRead, "read", "Usage : switch identify read <attribute>" } |
| }; |
| |
| static const shell_command_t sSwitchIdentifyReadSubCommands[] = { |
| { &IdentifyReadHelpHandler, "help", "Usage : switch identify read <attribute>" }, |
| { &IdentifyReadAttributeList, "attlist", "Read attribute list" }, |
| { &IdentifyReadIdentifyTime, "identifytime", "Read identifytime attribute" }, |
| { &IdentifyReadIdentifyType, "identifytype", "Read identifytype attribute" }, |
| }; |
| |
| static const shell_command_t sSwitchOnOffSubCommands[] = { |
| { &OnOffHelpHandler, "help", "Usage: switch ononff <subcommand>" }, |
| { &OnSwitchCommandHandler, "on", "on Usage: switch onoff on" }, |
| { &OffSwitchCommandHandler, "off", "off Usage: switch onoff off" }, |
| { &ToggleSwitchCommandHandler, "toggle", "toggle Usage: switch onoff toggle" }, |
| { &OffWithEffectSwitchCommandHandler, "offWE", "off-with-effect Usage: switch onoff offWE <EffectId> <EffectVariant>" }, |
| { &OnWithRecallGlobalSceneSwitchCommandHandler, "onWRGS", "on-with-recall-global-scene Usage: switch onoff onWRGS" }, |
| { &OnWithTimedOffSwitchCommandHandler, "onWTO", |
| "on-with-timed-off Usage: switch onoff onWTO <OnOffControl> <OnTime> <OffWaitTime>" }, |
| { &OnOffRead, "read", "Usage : switch onoff read <attribute>" } |
| }; |
| |
| static const shell_command_t sSwitchOnOffReadSubCommands[] = { |
| { &OnOffReadHelpHandler, "help", "Usage : switch ononff read <attribute>" }, |
| { &OnOffReadAttributeList, "attlist", "Read attribute list" }, |
| { &OnOffReadOnOff, "onoff", "Read onoff attribute" }, |
| { &OnOffReadGlobalSceneControl, "GSC", "Read GlobalSceneControl attribute" }, |
| { &OnOffReadOnTime, "ontime", "Read ontime attribute" }, |
| { &OnOffReadOffWaitTime, "offwaittime", "Read offwaittime attribute" }, |
| { &OnOffReadStartUpOnOff, "SOO", "Read startuponoff attribute" }, |
| }; |
| |
| static const shell_command_t sSwitchLevelControlSubCommands[] = { |
| { &LevelControlHelpHandler, "help", "Usage: switch levelcontrol <subcommand>" }, |
| { &MoveToLevelSwitchCommandHandler, "movetolevel", |
| "movetolevel Usage: switch levelcontrol movetolevel <level> <transitiontime> <optionsmask> <optionsoverride>" }, |
| { &MoveSwitchCommandHandler, "move", |
| "move Usage: switch levelcontrol move <movemode> <rate> <optionsmask> <optionsoverride>" }, |
| { &StepSwitchCommandHandler, "step", |
| "step Usage: switch levelcontrol step <stepmode> <stepsize> <transitiontime> <optionsmask> <optionsoverride>" }, |
| { &StopSwitchCommandHandler, "stop", "step Usage: switch levelcontrol stop <optionsmask> <optionsoverride>" }, |
| { &MoveToLevelWithOnOffSwitchCommandHandler, "MTLWOO", |
| "movetolevelwithonoff Usage: switch levelcontrol MTLWOO <level> <transitiontime> <optionsmask> <optionsoverride>" }, |
| { &MoveWithOnOffSwitchCommandHandler, "MWOO", |
| "movewithonoff Usage: switch levelcontrol MWOO <movemode> <rate> <optionsmask> <optionsoverride>" }, |
| { &StepWithOnOffSwitchCommandHandler, "stepWOO", |
| "stepwithonoff Usage: switch levelcontrol stepWOO <stepmode> <stepsize> <transitiontime> <optionsmask> " |
| "<optionsoverride>" }, |
| { &StopWithOnOffSwitchCommandHandler, "stopWOO", |
| "stopwithonoff Usage: switch levelcontrol stopWOO <optionsmask> <optionsoverride>" }, |
| { &LevelControlRead, "read", "Usage : switch levelcontrol read <attribute>" } |
| }; |
| |
| static const shell_command_t sSwitchLevelControlReadSubCommands[] = { |
| { &LevelControlReadHelpHandler, "help", "Usage : switch levelcontrol read <attribute>" }, |
| { &LevelControlReadAttributeList, "attlist", "Read attribute list" }, |
| { &LevelControlReadCurrentLevel, "currentlevel", "Read currentlevel attribute" }, |
| { &LevelControlReadRemainingTime, "remainingtime", "Read remainingtime attribute" }, |
| { &LevelControlReadMinLevel, "minlevel", "Read minlevel attribute" }, |
| { &LevelControlReadMaxLevel, "maxlevel", "Read maxlevel attribute" }, |
| { &LevelControlReadCurrentFrequency, "currentfrequency", "Read currentfrequency attribute" }, |
| { &LevelControlReadMinFrequency, "minfrequency", "Read minfrequency attribute" }, |
| { &LevelControlReadMaxFrequency, "maxfrequency", "Read maxfrequency attribute" }, |
| { &LevelControlReadOptions, "options", "Read options attribute" }, |
| { &LevelControlReadOnOffTransitionTime, "OOTT", "Read onofftransitiontime attribute" }, |
| { &LevelControlReadOnLevel, "onlevel", "Read onlevel attribute" }, |
| { &LevelControlReadOnTransitionTime, "OnTT", "Read ontransitiontime attribute" }, |
| { &LevelControlReadOffTransitionTime, "OffTT", "Read offtransitiontime attribute" }, |
| { &LevelControlReadDefaultMoveRate, "DMR", "Read defaultmoverate attribute" }, |
| { &LevelControlReadStartUpCurrentLevel, "SUCL", "Read startupcurrentlevel attribute" }, |
| }; |
| |
| static const shell_command_t sSwitchColorControlSubCommands[] = { |
| { &ColorControlHelpHandler, "help", "Usage: switch colorcontrol <subcommand>" }, |
| { &MoveToHueCommandHandler, "movetohue", |
| "movetohue Usage: switch colorcontrol movetohue <hue> <direction> <transitiontime> <optionsmask> <optionsoverride>" }, |
| { &MoveHueCommandHandler, "movehue", |
| "movehue Usage: switch colorcontrol movehue <movemode> <rate> <optionsmask> <optionsoverride>" }, |
| { &StepHueCommandHandler, "stephue", |
| "stephue Usage: switch colorcontrol stephue <stepmode> <stepsize> <transitiontime> <optionsmask> <optionsoverride>" }, |
| { &MoveToSaturationCommandHandler, "movetosat", |
| "movetosaturation Usage: switch colorcontrol movetosat <saturation> <transitiontime> <optionsmask> <optionsoverride>" }, |
| { &MoveSaturationCommandHandler, "movesat", |
| "movesaturation Usage: switch colorcontrol movesat <movemode> <rate> <optionsmask> <optionsoverride>" }, |
| { &StepSaturationCommandHandler, "stepsat", |
| "stepsaturation Usage: switch colorcontrol stepsat <stepmode> <stepsize> <transitiontime> <optionsmask> " |
| "<optionsoverride>" }, |
| { &MoveToHueAndSaturationCommandHandler, "movetoHS", |
| "movetohueandsaturation Usage: switch colorcontrol movetoHS <hue> <saturation> <transitiontime> <optionsmask> " |
| "<optionsoverride>" }, |
| { &MoveToColorCommandHandler, "movetocolor", |
| "movetocolor Usage: switch colorcontrol movetocolor <colorx> <colory> <transitiontime> <optionsmask> <optionsoverride>" }, |
| { &MoveColorCommandHandler, "movecolor", |
| "movecolor Usage: switch colorcontrol movecolor <ratex> <ratey> <optionsmask> <optionsoverride>" }, |
| { &StepColorCommandHandler, "stepcolor", |
| "stepcolor Usage: switch colorcontrol stepcolor <stepx> <stepy> <transitiontime> <optionsmask> <optionsoverride>" }, |
| { &MoveToColorTemperatureCommandHandler, "movetoCT", |
| "movetocolortemperature Usage: switch colorcontrol movetoCT <colortempmireds> <transitiontime> <optionsmask> " |
| "<optionsoverride>" }, |
| { &EnhancedMoveToHueCommandHandler, "Emovetohue", |
| "enhancedmovetohue Usage: switch colorcontrol Emovetohue <enhancedhue> <direction> <transitiontime> <optionsmask> " |
| "<optionsoverride>" }, |
| { &EnhancedMoveHueCommandHandler, "Emovehue", |
| "enhancedmovehue Usage: switch colorcontrol Emovehue <movemode> <rate> <optionsmask> <optionsoverride>" }, |
| { &EnhancedStepHueCommandHandler, "Estephue", |
| "enhancedstephue Usage: switch colorcontrol Estephue <stepmode> <stepsize> <transitiontime> <optionsmask> " |
| "<optionsoverride>" }, |
| { &EnhancedMoveToHueAndSaturationCommandHandler, "EmovetoHS", |
| "enhancedmovetohueandsaturation Usage: switch colorcontrol EmovetoHS <enhancedhue> <saturation> <transitiontime> " |
| "<optionsmask> <optionsoverride>" }, |
| { &ColorLoopSetCommandHandler, "colorloopset", |
| "colorloopset Usage: switch colorcontrol colorloopset <updateflags> <action> <direction> <time> <starhue> <optionsmask> " |
| "<optionsoverride>" }, |
| { &StopMoveStepCommandHandler, "stopmovestep", |
| "stopmovestep Usage: switch colorcontrol stopmovestep <optionsmask> <optionsoverride>" }, |
| { &MoveColorTemperatureCommandHandler, "moveCT", |
| "movecolortemperature Usage: switch colorcontrol moveCT <movemode> <rate> <colortempminmireds> <colortempmaxmireds> " |
| "<optionsmask> <optionsoverride>" }, |
| { &StepColorTemperatureCommandHandler, "stepCT", |
| "stepcolortemperature Usage: switch colorcontrol stepCT <stepmode> <stepsize> <transitiontime> <colortempminmireds> " |
| "<colortempmaxmireds> <optionsmask> <optionsoverride>" }, |
| { &ColorControlRead, "read", "Usage : switch colorcontrol read <attribute>" } |
| }; |
| |
| static const shell_command_t sSwitchColorControlReadSubCommands[] = { |
| // fill in read color control attributes commands |
| { &ColorControlReadHelpHandler, "help", "Usage : switch colorcontrol read <attribute>" }, |
| { &ColorControlReadAttributeList, "attlist", "Read attribute list" }, |
| { &ColorControlReadCurrentHue, "currenthue", "Read currenthue attribute" }, |
| { &ColorControlReadCurrentSaturation, "currentsat", "Read currentsaturaion attribute" }, |
| { &ColorControlReadRemainingTime, "remaintime", "Read remainingtime attribute" }, |
| { &ColorControlReadCurrentX, "current-x", "Read current-x attribute" }, |
| { &ColorControlReadCurrentY, "current-y", "Read current-y attribute" }, |
| { &ColorControlReadDriftCompensation, "driftcomp", "Read driftcompensation attribute" }, |
| { &ColorControlReadCompensationText, "comptext", "Read compensationtext attribute" }, |
| { &ColorControlReadColorTemperature, "colortemp", "Read colortemperature attribute" }, |
| { &ColorControlReadColorMode, "colormode", "Read colormode attribute" }, |
| { &ColorControlReadOptions, "options", "Read options attribute" }, |
| { &ColorControlReadNumberOfPrimaries, "noofprimaries", "Read numberofprimaries attribute" }, |
| { &ColorControlReadPrimary1X, "primary1x", "Read primary1x attribute" }, |
| { &ColorControlReadPrimary1Y, "primary1y", "Read primary1y attribute" }, |
| { &ColorControlReadPrimary1Intensity, "primary1intensity", "Read primary1intensity attribute" }, |
| { &ColorControlReadPrimary2X, "primary2x", "Read primary2x attribute" }, |
| { &ColorControlReadPrimary2Y, "primary2y", "Read primary2y attribute" }, |
| { &ColorControlReadPrimary2Intensity, "primary2intensity", "Read primary2intensity attribute" }, |
| { &ColorControlReadPrimary3X, "primary3x", "Read primary3x attribute" }, |
| { &ColorControlReadPrimary3Y, "primary3y", "Read primary3y attribute" }, |
| { &ColorControlReadPrimary3Intensity, "primary3intensity", "Read primary3intensity attribute" }, |
| { &ColorControlReadPrimary4X, "primary4x", "Read primary4x attribute" }, |
| { &ColorControlReadPrimary4Y, "primary4y", "Read primary4y attribute" }, |
| { &ColorControlReadPrimary4Intensity, "primary4intensity", "Read primary4intensity attribute" }, |
| { &ColorControlReadPrimary5X, "primary5x", "Read primary5x attribute" }, |
| { &ColorControlReadPrimary5Y, "primary5y", "Read primary5y attribute" }, |
| { &ColorControlReadPrimary5Intensity, "primary5intensity", "Read primary5intensity attribute" }, |
| { &ColorControlReadPrimary6X, "primary6x", "Read primary6x attribute" }, |
| { &ColorControlReadPrimary6Y, "primary6y", "Read primary6y attribute" }, |
| { &ColorControlReadPrimary6Intensity, "primary6intensity", "Read primary6intensity attribute" }, |
| { &ColorControlReadWhitePointX, "whitepointx", "Read whitepointx attribute" }, |
| { &ColorControlReadWhitePointY, "whitepointy", "Read whitepointy attribute" }, |
| { &ColorControlReadColorPointRX, "colorpointrx", "Read colorpointrx attribute" }, |
| { &ColorControlReadColorPointRY, "colorpointry", "Read colorpointry attribute" }, |
| { &ColorControlReadColorPointRIntensity, "colorpointrintensity", "Read colorpointrintensity attribute" }, |
| { &ColorControlReadColorPointGX, "colorpointgx", "Read colorpointgx attribute" }, |
| { &ColorControlReadColorPointGY, "colorpointgy", "Read colorpointgy attribute" }, |
| { &ColorControlReadColorPointGIntensity, "colorpointgintensity", "Read colorpointgintensity attribute" }, |
| { &ColorControlReadColorPointBX, "colorpointbx", "Read colorpointbx attribute" }, |
| { &ColorControlReadColorPointBY, "colorpointby", "Read colorpointby attribute" }, |
| { &ColorControlReadColorPointBIntensity, "colorpointbintensity", "Read colorpointbintensity attribute" }, |
| { &ColorControlReadEnhancedCurrentHue, "Ecurrenthue", "Read enhancedcurrenthue attribute" }, |
| { &ColorControlReadEnhancedColorMode, "Ecolormode", "Read enhancedcolormode attribute" }, |
| { &ColorControlReadColorLoopActive, "colorloopactive", "Read colorloopactive attribute" }, |
| { &ColorControlReadColorLoopDirection, "colorloopdirection", "Read colorloopdirection attribute" }, |
| { &ColorControlReadColorLoopTime, "colorlooptime", "Read colorlooptime attribute" }, |
| { &ColorControlReadColorLoopStartEnhancedHue, "colorloopstartenhancedhue", "Read colorloopstartenhancedHue attribute" }, |
| { &ColorControlReadColorLoopStoredEnhancedHue, "colorloopstoredenhancedhue", "Read colorloopstoredenhancedHue attribute" }, |
| { &ColorControlReadColorCapabilities, "colorcapabilities", "Read colorcapabilities attribute" }, |
| { &ColorControlReadColorTempPhysicalMinMireds, "colortempphyminmireds", "Read colortempphysicalminmireds attribute" }, |
| { &ColorControlReadColorTempPhysicalMaxMireds, "colortempphymaxmireds", "Read colortempphysicalmaxmireds attribute" }, |
| { &ColorControlReadCoupleColorTempToLevelMinMireds, "CCTTMM", "Read couplecolortemptolevelminmireds attribute" }, |
| { &ColorControlReadStartUpColorTemperatureMireds, "SUCTM", "Read startupcolortempmireds attribute" }, |
| }; |
| |
| static const shell_command_t sSwitchThermostatSubCommands[] = { |
| { &ThermostatHelpHandler, "help", "Usage: switch thermostat <subcommand>" }, |
| { &SetpointRaiseLowerSwitchCommandHandler, "SPRL", "setpointraiselower Usage: switch thermostat SPRL <mode> <amount>" }, |
| { &ThermostatRead, "read", "Usage : switch thermostat read <attribute>" } |
| }; |
| |
| static const shell_command_t sSwitchThermostatReadSubCommands[] = { |
| { &ThermostatReadHelpHandler, "help", "Usage : switch thermostat read <attribute>" }, |
| { &ThermostatReadAttributeList, "attlist", "Read attribute list" }, |
| { &ThermostatReadLocalTemperature, "localtemp", "Read localtemperature attribute" }, |
| { &ThermostatReadAbsMinHeatSetpointLimit, "absminHSL", "Read absminheatsetpointlimit attribute" }, |
| { &ThermostatReadAbsMaxHeatSetpointLimit, "absmaxHSL", "Read absmaxheatsetpointlimit attribute" }, |
| { &ThermostatReadAbsMinCoolSetpointLimit, "absminCSL", "Read absmincoolsetpointlimit attribute" }, |
| { &ThermostatReadAbsMaxCoolSetpointLimit, "absmaxCSL", "Read absmaxcoolsetpointlimit attribute" }, |
| { &ThermostatReadPiCoolingDemand, "picoolingdemand", "Read picoolingdemand attribute" }, |
| { &ThermostatReadPiHeatingDemand, "piheatingdemand", "Read piheatingdemand attribute" }, |
| { &ThermostatReadOccupiedCoolingSetpoint, "OCS", "Read occupiedcoolingsetpoint attribute" }, |
| { &ThermostatReadOccupiedHeatingSetpoint, "OHS", "Read occupiedheatingsetpoint attribute" }, |
| { &ThermostatReadMinHeatSetpointLimit, "minHSL", "Read minheatsetpointlimit attribute" }, |
| { &ThermostatReadMaxHeatSetpointLimit, "maxHSL", "Read maxheatsetpointlimit attribute" }, |
| { &ThermostatReadMinCoolSetpointLimit, "minCSL", "Read mincoolsetpointlimit attribute" }, |
| { &ThermostatReadMaxCoolSetpointLimit, "maxCSL", "Read maxcoolsetpointlimit attribute" }, |
| { &ThermostatReadControlSequenceOfOperation, "CSOP", "Read controlsequenceofoperation attribute" }, |
| { &ThermostatReadSystemMode, "systemmode", "Read systemmode attribute" }, |
| }; |
| |
| static const shell_command_t sSwitchGroupsSubCommands[] = { |
| { &GroupsHelpHandler, "help", "Usage: switch groups <subcommand>" }, |
| { &GroupsOnOffSwitchCommandHandler, "onoff", "Usage: switch groups onoff <subcommand>" }, |
| { &GroupsLevelControlSwitchCommandHandler, "levelcontrol", "Usage: switch groups levelcontrol <subcommand>" }, |
| { &GroupsColorControlSwitchCommandHandler, "colorcontrol", "Usage: switch groups colorcontrol <subcommand>" }, |
| { &GroupsThermostatSwitchCommandHandler, "thermostat", "Usage: switch groups thermostat <subcommand>" }, |
| }; |
| |
| static const shell_command_t sSwitchGroupsIdentifySubCommands[] = { |
| { &GroupsIdentifyHelpHandler, "help", "Usage: switch groups onoff <subcommand>" }, |
| { &GroupIdentifyCommandHandler, "identify", "Sends identify command to bound group" }, |
| { &GroupTriggerEffectSwitchCommandHandler, "triggereffect", "Sends triggereffect command to group" }, |
| }; |
| |
| static const shell_command_t sSwitchGroupsOnOffSubCommands[] = { |
| { &GroupsOnOffHelpHandler, "help", "Usage: switch groups onoff <subcommand>" }, |
| { &GroupOnSwitchCommandHandler, "on", "Sends on command to bound group" }, |
| { &GroupOffSwitchCommandHandler, "off", "Sends off command to bound group" }, |
| { &GroupToggleSwitchCommandHandler, "toggle", "Sends toggle command to group" }, |
| { &GroupOffWithEffectSwitchCommandHandler, "offWE", "Sends off-with-effect command to group" }, |
| { &GroupOnWithRecallGlobalSceneSwitchCommandHandler, "onWRGS", "Sends on-with-recall-global-scene command to group" }, |
| { &GroupOnWithTimedOffSwitchCommandHandler, "onWTO", "Sends on-with-timed-off command to group" } |
| }; |
| |
| static const shell_command_t sSwitchGroupsLevelControlSubCommands[] = { |
| { &GroupsLevelControlHelpHandler, "help", "Usage: switch groupos levelcontrol <subcommand>" }, |
| { &GroupsMoveToLevelSwitchCommandHandler, "movetolevel", |
| "movetolevel Usage: switch groups levelcontrol movetolevel <level> <transitiontime> <optionsmask> <optionsoverride>" }, |
| { &GroupsMoveSwitchCommandHandler, "move", |
| "move Usage: switch groups levelcontrol move <movemode> <rate> <optionsmask> <optionsoverride>" }, |
| { &GroupsStepSwitchCommandHandler, "step", |
| "step Usage: switch groups levelcontrol step <stepmode> <stepsize> <transitiontime> <optionsmask> <optionsoverride>" }, |
| { &GroupsStopSwitchCommandHandler, "stop", "step Usage: switch groups levelcontrol stop <optionsmask> <optionsoverride>" }, |
| { &GroupsMoveToLevelWithOnOffSwitchCommandHandler, "MTLWOO", |
| "movetolevelwithonoff Usage: switch groups levelcontrol MTLWOO <level> <transitiontime> <optionsmask> " |
| "<optionsoverride>" }, |
| { &GroupsMoveWithOnOffSwitchCommandHandler, "MWOO", |
| "movewithonoff Usage: switch groups levelcontrol MWOO <movemode> <rate> <optionsmask> <optionsoverride>" }, |
| { &GroupsStepWithOnOffSwitchCommandHandler, "stepWOO", |
| "stepwithonoff Usage: switch groups levelcontrol stepWOO <stepmode> <stepsize> <transitiontime> <optionsmask> " |
| "<optionsoverride>" }, |
| { &GroupsStopWithOnOffSwitchCommandHandler, "stopWOO", |
| "stopwithonoff Usage: switch groups levelcontrol stopWOO <optionsmask> <optionsoverride>" }, |
| }; |
| |
| static const shell_command_t sSwitchGroupsColorControlSubCommands[] = { |
| { &GroupsColorControlHelpHandler, "help", "Usage: switch groups colorcontrol <subcommand>" }, |
| { &GroupsMoveToHueCommandHandler, "movetohue", |
| "movetohue Usage: switch groups colorcontrol movetohue <hue> <direction> <transitiontime> <optionsmask> " |
| "<optionsoverride>" }, |
| { &GroupsMoveHueCommandHandler, "movehue", |
| "movehue Usage: switch groups colorcontrol movehue <movemode> <rate> <optionsmask> <optionsoverride>" }, |
| { &GroupsStepHueCommandHandler, "stephue", |
| "stephue Usage: switch groups colorcontrol stephue <stepmode> <stepsize> <transitiontime> <optionsmask> " |
| "<optionsoverride>" }, |
| { &GroupsMoveToSaturationCommandHandler, "movetosat", |
| "movetosaturation Usage: switch groups colorcontrol movetosat <saturation> <transitiontime> <optionsmask> " |
| "<optionsoverride>" }, |
| { &GroupsMoveSaturationCommandHandler, "movesat", |
| "movesaturation Usage: switch groups colorcontrol movesat <movemode> <rate> <optionsmask> <optionsoverride>" }, |
| { &GroupsStepSaturationCommandHandler, "stepsat", |
| "stepsaturation Usage: switch groups colorcontrol stepsat <stepmode> <stepsize> <transitiontime> <optionsmask> " |
| "<optionsoverride>" }, |
| { &GroupsMoveToHueAndSaturationCommandHandler, "movetoHS", |
| "movetohueandsaturation Usage: switch groups colorcontrol movetoHS <hue> <saturation> <transitiontime> <optionsmask> " |
| "<optionsoverride>" }, |
| { &GroupsMoveToColorCommandHandler, "movetocolor", |
| "movetocolor Usage: switch groups colorcontrol movetocolor <colorx> <colory> <transitiontime> <optionsmask> " |
| "<optionsoverride>" }, |
| { &GroupsMoveColorCommandHandler, "movecolor", |
| "movecolor Usage: switch groups colorcontrol movecolor <ratex> <ratey> <optionsmask> <optionsoverride>" }, |
| { &GroupsStepColorCommandHandler, "stepcolor", |
| "stepcolor Usage: switch groups colorcontrol stepcolor <stepx> <stepy> <transitiontime> <optionsmask> " |
| "<optionsoverride>" }, |
| { &GroupsMoveToColorTemperatureCommandHandler, "movetoCT", |
| "movetocolortemperature Usage: switch groups colorcontrol movetoCT <colortempmireds> <transitiontime> <optionsmask> " |
| "<optionsoverride>" }, |
| { &GroupsEnhancedMoveToHueCommandHandler, "Emovetohue", |
| "enhancedmovetohue Usage: switch groups colorcontrol Emovetohue <enhancedhue> <direction> <transitiontime> <optionsmask> " |
| "<optionsoverride>" }, |
| { &GroupsEnhancedMoveHueCommandHandler, "Emovehue", |
| "enhancedmovehue Usage: switch groups colorcontrol Emovehue <movemode> <rate> <optionsmask> <optionsoverride>" }, |
| { &GroupsEnhancedStepHueCommandHandler, "Estephue", |
| "enhancedstephue Usage: switch gropus colorcontrol Estephue <stepmode> <stepsize> <transitiontime> <optionsmask> " |
| "<optionsoverride>" }, |
| { &GroupsEnhancedMoveToHueAndSaturationCommandHandler, "EmovetoHS", |
| "enhancedmovetohueandsaturation Usage: switch groups colorcontrol EmovetoHS <enhancedhue> <saturation> <transitiontime> " |
| "<optionsmask> <optionsoverride>" }, |
| { &GroupsColorLoopSetCommandHandler, "colorloopset", |
| "colorloopset Usage: switch groups colorcontrol colorloopset <updateflags> <action> <direction> <time> <starhue> " |
| "<optionsmask> <optionsoverride>" }, |
| { &GroupsStopMoveStepCommandHandler, "stopmovestep", |
| "stopmovestep Usage: switch groups colorcontrol stopmovestep <optionsmask> <optionsoverride>" }, |
| { &GroupsMoveColorTemperatureCommandHandler, "moveCT", |
| "movecolortemperature Usage: switch groups colorcontrol moveCT <movemode> <rate> <colortempminmireds> " |
| "<colortempmaxmireds> <optionsmask> <optionsoverride>" }, |
| { &GroupsStepColorTemperatureCommandHandler, "stepCT", |
| "stepcolortemperature Usage: switch groups colorcontrol stepCT <stepmode> <stepsize> <transitiontime> " |
| "<colortempminmireds> <colortempmaxmireds> <optionsmask> <optionsoverride>" }, |
| }; |
| |
| static const shell_command_t sSwitchGroupsThermostatSubCommands[] = { |
| { &GroupsThermostatHelpHandler, "help", "Usage: switch groups thermostat <subcommand>" }, |
| { &GroupsSetpointRaiseLowerSwitchCommandHandler, "SPRL", |
| "setpointraiselower Usage: switch groups thermostat SPRL <mode> <amount>" }, |
| }; |
| |
| static const shell_command_t sSwitchBindingSubCommands[] = { |
| { &BindingHelpHandler, "help", "Usage: switch binding <subcommand>" }, |
| { &BindingGroupBindCommandHandler, "group", "Usage: switch binding group <fabric index> <group id>" }, |
| { &BindingUnicastBindCommandHandler, "unicast", "Usage: switch binding unicast <fabric index> <node id> <endpoint>" } |
| }; |
| |
| static const shell_command_t sSwitchCommand = { &SwitchCommandHandler, "switch", |
| "Light-switch commands. Usage: switch <subcommand>" }; |
| |
| // Register groups command |
| sShellSwitchGroupsIdentifySubCommands.RegisterCommands(sSwitchGroupsIdentifySubCommands, |
| ArraySize(sSwitchGroupsIdentifySubCommands)); |
| sShellSwitchGroupsOnOffSubCommands.RegisterCommands(sSwitchGroupsOnOffSubCommands, ArraySize(sSwitchGroupsOnOffSubCommands)); |
| sShellSwitchGroupsLevelControlSubCommands.RegisterCommands(sSwitchGroupsLevelControlSubCommands, |
| ArraySize(sSwitchGroupsLevelControlSubCommands)); |
| sShellSwitchGroupsColorControlSubCommands.RegisterCommands(sSwitchGroupsColorControlSubCommands, |
| ArraySize(sSwitchGroupsColorControlSubCommands)); |
| sShellSwitchGroupsThermostatSubCommands.RegisterCommands(sSwitchGroupsThermostatSubCommands, |
| ArraySize(sSwitchGroupsThermostatSubCommands)); |
| |
| // Register commands |
| sShellSwitchIdentifySubCommands.RegisterCommands(sSwitchIdentifySubCommands, ArraySize(sSwitchIdentifySubCommands)); |
| sShellSwitchIdentifyReadSubCommands.RegisterCommands(sSwitchIdentifyReadSubCommands, ArraySize(sSwitchIdentifyReadSubCommands)); |
| sShellSwitchOnOffSubCommands.RegisterCommands(sSwitchOnOffSubCommands, ArraySize(sSwitchOnOffSubCommands)); |
| sShellSwitchOnOffReadSubCommands.RegisterCommands(sSwitchOnOffReadSubCommands, ArraySize(sSwitchOnOffReadSubCommands)); |
| sShellSwitchLevelControlSubCommands.RegisterCommands(sSwitchLevelControlSubCommands, ArraySize(sSwitchLevelControlSubCommands)); |
| sShellSwitchLevelControlReadSubCommands.RegisterCommands(sSwitchLevelControlReadSubCommands, |
| ArraySize(sSwitchLevelControlReadSubCommands)); |
| sShellSwitchColorControlSubCommands.RegisterCommands(sSwitchColorControlSubCommands, ArraySize(sSwitchColorControlSubCommands)); |
| sShellSwitchColorControlReadSubCommands.RegisterCommands(sSwitchColorControlReadSubCommands, |
| ArraySize(sSwitchColorControlReadSubCommands)); |
| sShellSwitchThermostatSubCommands.RegisterCommands(sSwitchThermostatSubCommands, ArraySize(sSwitchThermostatSubCommands)); |
| sShellSwitchThermostatReadSubCommands.RegisterCommands(sSwitchThermostatReadSubCommands, |
| ArraySize(sSwitchThermostatReadSubCommands)); |
| sShellSwitchGroupsSubCommands.RegisterCommands(sSwitchGroupsSubCommands, ArraySize(sSwitchGroupsSubCommands)); |
| sShellSwitchBindingSubCommands.RegisterCommands(sSwitchBindingSubCommands, ArraySize(sSwitchBindingSubCommands)); |
| sShellSwitchSubCommands.RegisterCommands(sSwitchSubCommands, ArraySize(sSwitchSubCommands)); |
| |
| Engine::Root().RegisterCommands(&sSwitchCommand, 1); |
| } |
| #endif // ENABLE_CHIP_SHELL |
| |
| } // namespace |
| |
| /******************************************************** |
| * Switch functions |
| *********************************************************/ |
| |
| void SwitchWorkerFunction(intptr_t context) |
| { |
| VerifyOrReturn(context != 0, ChipLogError(NotSpecified, "SwitchWorkerFunction - Invalid work data")); |
| |
| BindingCommandData * data = reinterpret_cast<BindingCommandData *>(context); |
| BindingManager::GetInstance().NotifyBoundClusterChanged(data->localEndpointId, data->clusterId, static_cast<void *>(data)); |
| } |
| |
| void BindingWorkerFunction(intptr_t context) |
| { |
| VerifyOrReturn(context != 0, ChipLogError(NotSpecified, "BindingWorkerFunction - Invalid work data")); |
| |
| EmberBindingTableEntry * entry = reinterpret_cast<EmberBindingTableEntry *>(context); |
| AddBindingEntry(*entry); |
| |
| Platform::Delete(entry); |
| } |
| |
| CHIP_ERROR InitBindingHandler() |
| { |
| // The initialization of binding manager will try establishing connection with unicast peers |
| // so it requires the Server instance to be correctly initialized. Post the init function to |
| // the event queue so that everything is ready when initialization is conducted. |
| chip::DeviceLayer::PlatformMgr().ScheduleWork(InitBindingHandlerInternal); |
| #if CONFIG_ENABLE_CHIP_SHELL |
| RegisterSwitchCommands(); |
| #endif |
| return CHIP_NO_ERROR; |
| } |
