From 538329886c77cebd5481f767042d635084d56931 Mon Sep 17 00:00:00 2001
From: pankore <86098180+pankore@users.noreply.github.com>
Date: Wed, 23 Nov 2022 22:52:29 +0800
Subject: [PATCH] [Ameba] Shell commands update (#23005)

* [Shell] Read cluster attributes from matter shell
- Received data but DataResponse is still not printed out
- Support more OnOff commands for matter shell

* [Shell] enable inputting arguments for certain commands

* [Shell] Add levelcontrol commands to shell
- Separate different cluster commands into header files

* [Shell] Add colorcontrol commands to shell

* [Shell] Add thermostat commands to shell

* [Shell] Add handlers for group commands

* [README] Update readme for all-clusters-app

* [Shell] Add identify commands to shell

* [Shell] Increase the number of tokens to fit more arguments
- Add in missing colorcontrol commands
- Fix readme link

* [Shell] Enable reading of attribute list

* [Shell] Fix transition data type and argument errors
- Added logs for levelcontrol commands

* [Shell] Fix compile errors for when CONFIG_ENABLE_CHIP_SHELL is disabled
- Added CONFIG_ENABLE_CHIP_SHELL macro to block off code that requires shell

* [Resyle] fix styling

* Restyled by prettier-markdown

* [Shell] Change ColorTemperature to ColorTemperatureMireds

* [Readme] Update all-clusters-app readme

* [Shell] Change currentx and currenty to current-x and current-y respectively
- To avoid spell check failing as it identifies currenty as mispelling of currently

* [Readme] Restyle

* [Shell] Fix typecasting error

* [Shell] restyle

Co-authored-by: Restyled.io <commits@restyled.io>
---
 config/ameba/chip.cmake                       |    1 +
 examples/all-clusters-app/ameba/README.md     |   49 +-
 .../all-clusters-app/ameba/chip_main.cmake    |    1 +
 .../ameba/main/BindingHandler.cpp             |  591 +++--
 .../ameba/main/include/BindingHandler.h       |    6 +-
 .../ameba/main/include/ColorControlCommands.h | 2159 +++++++++++++++++
 .../ameba/main/include/IdentifyCommand.h      |  270 +++
 .../ameba/main/include/LevelControlCommands.h |  843 +++++++
 .../ameba/main/include/OnOffCommands.h        |  474 ++++
 .../ameba/main/include/ThermostatCommands.h   |  445 ++++
 10 files changed, 4641 insertions(+), 198 deletions(-)
 create mode 100644 examples/all-clusters-app/ameba/main/include/ColorControlCommands.h
 create mode 100644 examples/all-clusters-app/ameba/main/include/IdentifyCommand.h
 create mode 100644 examples/all-clusters-app/ameba/main/include/LevelControlCommands.h
 create mode 100644 examples/all-clusters-app/ameba/main/include/OnOffCommands.h
 create mode 100644 examples/all-clusters-app/ameba/main/include/ThermostatCommands.h

diff --git a/config/ameba/chip.cmake b/config/ameba/chip.cmake
index a6e696882a0c9d..515bff64ef99c9 100644
--- a/config/ameba/chip.cmake
+++ b/config/ameba/chip.cmake
@@ -30,6 +30,7 @@ list(
     -DCHIP_DEVICE_LAYER_TARGET=Ameba
     -DMBEDTLS_CONFIG_FILE=<mbedtls_config.h>
     -D_POSIX_REALTIME_SIGNALS
+    -DCHIP_SHELL_MAX_TOKENS=11
 )
 
 list(
diff --git a/examples/all-clusters-app/ameba/README.md b/examples/all-clusters-app/ameba/README.md
index ddbdf66ecf9a9d..a710a2e5e006f9 100644
--- a/examples/all-clusters-app/ameba/README.md
+++ b/examples/all-clusters-app/ameba/README.md
@@ -14,7 +14,7 @@ control.
     -   [Cluster control](#cluster-control)
     -   [Running RPC Console](#running-rpc-console)
     -   [Running Matter Shell](#running-matter-shell)
-    -   [Binding and Controlling a Lighting Device](#binding-and-controlling-a-lighting-device)
+    -   [Binding and Controlling a Device](#binding-and-controlling-a-device)
 
 ---
 
@@ -137,28 +137,55 @@ to be On or Off.
 
 -   Open the USB-TTL serial port and type `help` to view the available commands
 
-## Binding and Controlling a Lighting Device
+-   To know what are the available subcommands are there, enter `switch` command
+    in the shell
 
--   This example shows how to bind a Switch Device to a Lighting Device and
+## Binding and Controlling a Device
+
+-   This example shows how to bind a Switch Device to a Controllee Device and
     control it through the Matter Shell. One binding client (Switch Device) and
-    one binding server (Lighting Device) is required.
+    one binding server (Controllee) is required.
 
--   Commission the switch (nodeID 1) and lighting device (nodeID 2) using
+-   Commission the switch (nodeID 1) and controllee device (nodeID 2) using
     chip-tool.
 
               $ ./chip-tool pairing ble-wifi 1 <SSID> <PASSWORD> 20202021 3840
               $ ./chip-tool pairing ble-wifi 2 <SSID> <PASSWORD> 20202021 3840
 
-*   After successful commissioning, configure the ACL in the lighting device to
-    allow access from switch device and chip-tool.
+-   After successful commissioning, configure the ACL in the controllee device
+    to allow access from switch device and chip-tool.
 
               $ ./chip-tool accesscontrol write acl '[{"fabricIndex": 1, "privilege": 5, "authMode": 2, "subjects": [112233], "targets": null },{"fabricIndex": 1, "privilege": 5, "authMode": 2, "subjects": [1], "targets": null }]' 2 0
 
--   Bind the lighting device to the switch device.
+-   Bind the endpoint 1 OnOff cluster of the controllee device to the switch
+    device.
 
               $ ./chip-tool binding write binding '[{"fabricIndex": 1, "node":2, "endpoint":1, "cluster":6}]' 1 1
 
--   Control the lighting device through the switch device's Matter Shell
+-   Send OnOff command to the device through the switch device's Matter Shell
+
+    `switch onoff on`
+
+    `switch onoff off`
+
+*   You may also bind more than one cluster to the switch device. Below command
+    binds the Identify, OnOff, LevelControl, ColorControl and Thermostat
+    clusters to the switch device.
+
+              $ ./chip-tool binding write binding '[{"fabricIndex": 1, "node":2, "endpoint":1, "cluster":3}, {"fabricIndex": 1, "node":2, "endpoint":1, "cluster":6}, {"fabricIndex": 1, "node":2, "endpoint":1, "cluster":8}, {"fabricIndex": 1, "node":2, "endpoint":1, "cluster":768}, {"fabricIndex": 1, "node":2, "endpoint":1, "cluster":513}]' 1 1
+
+-   After binding the clusters, you may send these cluster commands to the
+    controllee device through the switch device's Matter Shell. Follow the
+    format shown in the description of the commands.
+
+    `switch onoff on`
+
+    `switch levelcontrol movetolevel 100 0 0 0`
+
+    `switch colorcontrol movetohue 100 0 0 0 0`
+
+    `switch thermostat SPRL 0 0`
+
+*   You may also request to read cluster attributes from Matter Shell
 
-              > switch onoff on
-              > switch onoff off
+    `switch <cluster> read <attribute>`
diff --git a/examples/all-clusters-app/ameba/chip_main.cmake b/examples/all-clusters-app/ameba/chip_main.cmake
index 35d0b2877e3788..50d0d2d76ca9c1 100755
--- a/examples/all-clusters-app/ameba/chip_main.cmake
+++ b/examples/all-clusters-app/ameba/chip_main.cmake
@@ -255,6 +255,7 @@ list(
     -DUSE_ZAP_CONFIG
     -DCHIP_HAVE_CONFIG_H
     -DMBEDTLS_CONFIG_FILE=<mbedtls_config.h>
+    -DCHIP_SHELL_MAX_TOKENS=11
 )
 
 if (matter_enable_persistentstorage_audit)
diff --git a/examples/all-clusters-app/ameba/main/BindingHandler.cpp b/examples/all-clusters-app/ameba/main/BindingHandler.cpp
index 29acdaae952896..64ccb619a2edf5 100644
--- a/examples/all-clusters-app/ameba/main/BindingHandler.cpp
+++ b/examples/all-clusters-app/ameba/main/BindingHandler.cpp
@@ -17,10 +17,15 @@
  */
 
 #include "BindingHandler.h"
-#include "app/CommandSender.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>
@@ -40,95 +45,84 @@ using Shell::streamer_get;
 using Shell::streamer_printf;
 
 Engine sShellSwitchSubCommands;
-Engine sShellSwitchOnOffSubCommands;
-
 Engine sShellSwitchGroupsSubCommands;
-Engine sShellSwitchGroupsOnOffSubCommands;
-
 Engine sShellSwitchBindingSubCommands;
 #endif // defined(ENABLE_CHIP_SHELL)
 
 namespace {
-
-void ProcessOnOffUnicastBindingCommand(CommandId commandId, const EmberBindingTableEntry & binding,
-                                       OperationalDeviceProxy * peer_device)
-{
-    auto onSuccess = [](const ConcreteCommandPath & commandPath, const StatusIB & status, const auto & dataResponse) {
-        ChipLogProgress(NotSpecified, "OnOff command succeeds");
-    };
-
-    auto onFailure = [](CHIP_ERROR error) {
-        ChipLogError(NotSpecified, "OnOff command failed: %" CHIP_ERROR_FORMAT, error.Format());
-    };
-
-    VerifyOrDie(peer_device != nullptr && peer_device->ConnectionReady());
-    switch (commandId)
-    {
-    case Clusters::OnOff::Commands::Toggle::Id:
-        Clusters::OnOff::Commands::Toggle::Type toggleCommand;
-        Controller::InvokeCommandRequest(peer_device->GetExchangeManager(), peer_device->GetSecureSession().Value(), binding.remote,
-                                         toggleCommand, onSuccess, onFailure);
-        break;
-
-    case Clusters::OnOff::Commands::On::Id:
-        Clusters::OnOff::Commands::On::Type onCommand;
-        Controller::InvokeCommandRequest(peer_device->GetExchangeManager(), peer_device->GetSecureSession().Value(), binding.remote,
-                                         onCommand, onSuccess, onFailure);
-        break;
-
-    case Clusters::OnOff::Commands::Off::Id:
-        Clusters::OnOff::Commands::Off::Type offCommand;
-        Controller::InvokeCommandRequest(peer_device->GetExchangeManager(), peer_device->GetSecureSession().Value(), binding.remote,
-                                         offCommand, onSuccess, onFailure);
-        break;
-    }
-}
-
-void ProcessOnOffGroupBindingCommand(CommandId commandId, const EmberBindingTableEntry & binding)
-{
-    Messaging::ExchangeManager & exchangeMgr = Server::GetInstance().GetExchangeManager();
-
-    switch (commandId)
-    {
-    case Clusters::OnOff::Commands::Toggle::Id:
-        Clusters::OnOff::Commands::Toggle::Type toggleCommand;
-        Controller::InvokeGroupCommandRequest(&exchangeMgr, binding.fabricIndex, binding.groupId, toggleCommand);
-        break;
-
-    case Clusters::OnOff::Commands::On::Id:
-        Clusters::OnOff::Commands::On::Type onCommand;
-        Controller::InvokeGroupCommandRequest(&exchangeMgr, binding.fabricIndex, binding.groupId, onCommand);
-
-        break;
-
-    case Clusters::OnOff::Commands::Off::Id:
-        Clusters::OnOff::Commands::Off::Type offCommand;
-        Controller::InvokeGroupCommandRequest(&exchangeMgr, binding.fabricIndex, binding.groupId, offCommand);
-        break;
-    }
-}
-
 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 (binding.type == EMBER_MULTICAST_BINDING && data->isGroup)
+    if (data->isReadAttribute)
     {
-        switch (data->clusterId)
+        // It should always enter here if isReadAttribute is true
+        if (binding.type == EMBER_UNICAST_BINDING && !data->isGroup)
         {
-        case Clusters::OnOff::Id:
-            ProcessOnOffGroupBindingCommand(data->commandId, binding);
-            break;
+            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 == EMBER_UNICAST_BINDING && !data->isGroup)
+    else
     {
-        switch (data->clusterId)
+        if (binding.type == EMBER_MULTICAST_BINDING && data->isGroup)
         {
-        case Clusters::OnOff::Id:
-            ProcessOnOffUnicastBindingCommand(data->commandId, binding, peer_device);
-            break;
+            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 == EMBER_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;
+            }
         }
     }
 }
@@ -149,7 +143,7 @@ void InitBindingHandlerInternal(intptr_t arg)
     chip::BindingManager::GetInstance().RegisterBoundDeviceContextReleaseHandler(LightSwitchContextReleaseHandler);
 }
 
-#ifdef CONFIG_ENABLE_CHIP_SHELL
+#if CONFIG_ENABLE_CHIP_SHELL
 
 /********************************************************
  * Switch shell functions
@@ -171,56 +165,6 @@ CHIP_ERROR SwitchCommandHandler(int argc, char ** argv)
     return sShellSwitchSubCommands.ExecCommand(argc, argv);
 }
 
-/********************************************************
- * OnOff switch shell functions
- *********************************************************/
-
-CHIP_ERROR OnOffHelpHandler(int argc, char ** argv)
-{
-    sShellSwitchOnOffSubCommands.ForEachCommand(Shell::PrintCommandHelp, nullptr);
-    return CHIP_NO_ERROR;
-}
-
-CHIP_ERROR OnOffSwitchCommandHandler(int argc, char ** argv)
-{
-    if (argc == 0)
-    {
-        return OnOffHelpHandler(argc, argv);
-    }
-
-    return sShellSwitchOnOffSubCommands.ExecCommand(argc, argv);
-}
-
-CHIP_ERROR OnSwitchCommandHandler(int argc, char ** argv)
-{
-    BindingCommandData * data = Platform::New<BindingCommandData>();
-    data->commandId           = Clusters::OnOff::Commands::On::Id;
-    data->clusterId           = Clusters::OnOff::Id;
-
-    DeviceLayer::PlatformMgr().ScheduleWork(SwitchWorkerFunction, reinterpret_cast<intptr_t>(data));
-    return CHIP_NO_ERROR;
-}
-
-CHIP_ERROR OffSwitchCommandHandler(int argc, char ** argv)
-{
-    BindingCommandData * data = Platform::New<BindingCommandData>();
-    data->commandId           = Clusters::OnOff::Commands::Off::Id;
-    data->clusterId           = Clusters::OnOff::Id;
-
-    DeviceLayer::PlatformMgr().ScheduleWork(SwitchWorkerFunction, reinterpret_cast<intptr_t>(data));
-    return CHIP_NO_ERROR;
-}
-
-CHIP_ERROR ToggleSwitchCommandHandler(int argc, char ** argv)
-{
-    BindingCommandData * data = Platform::New<BindingCommandData>();
-    data->commandId           = Clusters::OnOff::Commands::Toggle::Id;
-    data->clusterId           = Clusters::OnOff::Id;
-
-    DeviceLayer::PlatformMgr().ScheduleWork(SwitchWorkerFunction, reinterpret_cast<intptr_t>(data));
-    return CHIP_NO_ERROR;
-}
-
 /********************************************************
  * bind switch shell functions
  *********************************************************/
@@ -292,59 +236,6 @@ CHIP_ERROR GroupsSwitchCommandHandler(int argc, char ** argv)
     return sShellSwitchGroupsSubCommands.ExecCommand(argc, argv);
 }
 
-/********************************************************
- * Groups OnOff switch shell functions
- *********************************************************/
-
-CHIP_ERROR GroupsOnOffHelpHandler(int argc, char ** argv)
-{
-    sShellSwitchGroupsOnOffSubCommands.ForEachCommand(Shell::PrintCommandHelp, nullptr);
-    return CHIP_NO_ERROR;
-}
-
-CHIP_ERROR GroupsOnOffSwitchCommandHandler(int argc, char ** argv)
-{
-    if (argc == 0)
-    {
-        return GroupsOnOffHelpHandler(argc, argv);
-    }
-
-    return sShellSwitchGroupsOnOffSubCommands.ExecCommand(argc, argv);
-}
-
-CHIP_ERROR GroupOnSwitchCommandHandler(int argc, char ** argv)
-{
-    BindingCommandData * data = Platform::New<BindingCommandData>();
-    data->commandId           = Clusters::OnOff::Commands::On::Id;
-    data->clusterId           = Clusters::OnOff::Id;
-    data->isGroup             = true;
-
-    DeviceLayer::PlatformMgr().ScheduleWork(SwitchWorkerFunction, reinterpret_cast<intptr_t>(data));
-    return CHIP_NO_ERROR;
-}
-
-CHIP_ERROR GroupOffSwitchCommandHandler(int argc, char ** argv)
-{
-    BindingCommandData * data = Platform::New<BindingCommandData>();
-    data->commandId           = Clusters::OnOff::Commands::Off::Id;
-    data->clusterId           = Clusters::OnOff::Id;
-    data->isGroup             = true;
-
-    DeviceLayer::PlatformMgr().ScheduleWork(SwitchWorkerFunction, reinterpret_cast<intptr_t>(data));
-    return CHIP_NO_ERROR;
-}
-
-CHIP_ERROR GroupToggleSwitchCommandHandler(int argc, char ** argv)
-{
-    BindingCommandData * data = Platform::New<BindingCommandData>();
-    data->commandId           = Clusters::OnOff::Commands::Toggle::Id;
-    data->clusterId           = Clusters::OnOff::Id;
-    data->isGroup             = true;
-
-    DeviceLayer::PlatformMgr().ScheduleWork(SwitchWorkerFunction, reinterpret_cast<intptr_t>(data));
-    return CHIP_NO_ERROR;
-}
-
 /**
  * @brief configures switch matter shell
  *
@@ -354,27 +245,332 @@ 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", "Sends on command to bound lighting app" },
-        { &OffSwitchCommandHandler, "off", "Sends off command to bound lighting app" },
-        { &ToggleSwitchCommandHandler, "toggle", "Sends toggle command to bound lighting app" }
+        { &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 sSwitchGroupsSubCommands[] = { { &GroupsHelpHandler, "help", "Usage: switch groups <subcommand>" },
-                                                                { &GroupsOnOffSwitchCommandHandler, "onoff",
-                                                                  "Usage: switch groups onoff <subcommand>" } };
+    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" }
+        { &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[] = {
@@ -386,8 +582,31 @@ static void RegisterSwitchCommands()
     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));
diff --git a/examples/all-clusters-app/ameba/main/include/BindingHandler.h b/examples/all-clusters-app/ameba/main/include/BindingHandler.h
index 280c94874f04dd..6df428594b4921 100644
--- a/examples/all-clusters-app/ameba/main/include/BindingHandler.h
+++ b/examples/all-clusters-app/ameba/main/include/BindingHandler.h
@@ -18,6 +18,7 @@
 
 #pragma once
 
+#include "app-common/zap-generated/ids/Attributes.h"
 #include "app-common/zap-generated/ids/Clusters.h"
 #include "app-common/zap-generated/ids/Commands.h"
 #include "lib/core/CHIPError.h"
@@ -28,8 +29,11 @@ void BindingWorkerFunction(intptr_t context);
 
 struct BindingCommandData
 {
+    chip::AttributeId attributeId;
     chip::EndpointId localEndpointId = 1;
     chip::CommandId commandId;
     chip::ClusterId clusterId;
-    bool isGroup = false;
+    bool isGroup         = false;
+    bool isReadAttribute = false;
+    uint32_t args[7];
 };
diff --git a/examples/all-clusters-app/ameba/main/include/ColorControlCommands.h b/examples/all-clusters-app/ameba/main/include/ColorControlCommands.h
new file mode 100644
index 00000000000000..f4514470b3e630
--- /dev/null
+++ b/examples/all-clusters-app/ameba/main/include/ColorControlCommands.h
@@ -0,0 +1,2159 @@
+/*
+ *
+ *    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 "controller/InvokeInteraction.h"
+#include "controller/ReadInteraction.h"
+#include <app/clusters/bindings/bindings.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 sShellSwitchColorControlSubCommands;
+Engine sShellSwitchColorControlReadSubCommands;
+Engine sShellSwitchGroupsColorControlSubCommands;
+#endif // defined(ENABLE_CHIP_SHELL)
+
+void ProcessColorControlUnicastBindingRead(BindingCommandData * data, const EmberBindingTableEntry & binding,
+                                           OperationalDeviceProxy * peer_device)
+{
+    auto onSuccess = [](const ConcreteDataAttributePath & attributePath, const auto & dataResponse) {
+        ChipLogProgress(NotSpecified, "Read ColorControl attribute succeeds");
+    };
+
+    auto onFailure = [](const ConcreteDataAttributePath * attributePath, CHIP_ERROR error) {
+        ChipLogError(NotSpecified, "Read ColorControl attribute failed: %" CHIP_ERROR_FORMAT, error.Format());
+    };
+
+    VerifyOrDie(peer_device != nullptr && peer_device->ConnectionReady());
+
+    switch (data->attributeId)
+    {
+    case Clusters::ColorControl::Attributes::AttributeList::Id:
+        Controller::ReadAttribute<Clusters::ColorControl::Attributes::AttributeList::TypeInfo>(
+            peer_device->GetExchangeManager(), peer_device->GetSecureSession().Value(), binding.remote, onSuccess, onFailure);
+        break;
+
+    case Clusters::ColorControl::Attributes::CurrentHue::Id:
+        Controller::ReadAttribute<Clusters::ColorControl::Attributes::CurrentHue::TypeInfo>(
+            peer_device->GetExchangeManager(), peer_device->GetSecureSession().Value(), binding.remote, onSuccess, onFailure);
+        break;
+
+    case Clusters::ColorControl::Attributes::CurrentSaturation::Id:
+        Controller::ReadAttribute<Clusters::ColorControl::Attributes::CurrentSaturation::TypeInfo>(
+            peer_device->GetExchangeManager(), peer_device->GetSecureSession().Value(), binding.remote, onSuccess, onFailure);
+        break;
+
+    case Clusters::ColorControl::Attributes::RemainingTime::Id:
+        Controller::ReadAttribute<Clusters::ColorControl::Attributes::RemainingTime::TypeInfo>(
+            peer_device->GetExchangeManager(), peer_device->GetSecureSession().Value(), binding.remote, onSuccess, onFailure);
+        break;
+
+    case Clusters::ColorControl::Attributes::CurrentX::Id:
+        Controller::ReadAttribute<Clusters::ColorControl::Attributes::CurrentX::TypeInfo>(
+            peer_device->GetExchangeManager(), peer_device->GetSecureSession().Value(), binding.remote, onSuccess, onFailure);
+        break;
+
+    case Clusters::ColorControl::Attributes::CurrentY::Id:
+        Controller::ReadAttribute<Clusters::ColorControl::Attributes::CurrentY::TypeInfo>(
+            peer_device->GetExchangeManager(), peer_device->GetSecureSession().Value(), binding.remote, onSuccess, onFailure);
+        break;
+
+    case Clusters::ColorControl::Attributes::DriftCompensation::Id:
+        Controller::ReadAttribute<Clusters::ColorControl::Attributes::DriftCompensation::TypeInfo>(
+            peer_device->GetExchangeManager(), peer_device->GetSecureSession().Value(), binding.remote, onSuccess, onFailure);
+        break;
+
+    case Clusters::ColorControl::Attributes::CompensationText::Id:
+        Controller::ReadAttribute<Clusters::ColorControl::Attributes::CompensationText::TypeInfo>(
+            peer_device->GetExchangeManager(), peer_device->GetSecureSession().Value(), binding.remote, onSuccess, onFailure);
+        break;
+
+    case Clusters::ColorControl::Attributes::ColorTemperatureMireds::Id:
+        Controller::ReadAttribute<Clusters::ColorControl::Attributes::ColorTemperatureMireds::TypeInfo>(
+            peer_device->GetExchangeManager(), peer_device->GetSecureSession().Value(), binding.remote, onSuccess, onFailure);
+        break;
+
+    case Clusters::ColorControl::Attributes::ColorMode::Id:
+        Controller::ReadAttribute<Clusters::ColorControl::Attributes::ColorMode::TypeInfo>(
+            peer_device->GetExchangeManager(), peer_device->GetSecureSession().Value(), binding.remote, onSuccess, onFailure);
+        break;
+
+    case Clusters::ColorControl::Attributes::Options::Id:
+        Controller::ReadAttribute<Clusters::ColorControl::Attributes::Options::TypeInfo>(
+            peer_device->GetExchangeManager(), peer_device->GetSecureSession().Value(), binding.remote, onSuccess, onFailure);
+        break;
+
+    case Clusters::ColorControl::Attributes::NumberOfPrimaries::Id:
+        Controller::ReadAttribute<Clusters::ColorControl::Attributes::NumberOfPrimaries::TypeInfo>(
+            peer_device->GetExchangeManager(), peer_device->GetSecureSession().Value(), binding.remote, onSuccess, onFailure);
+        break;
+
+    case Clusters::ColorControl::Attributes::Primary1X::Id:
+        Controller::ReadAttribute<Clusters::ColorControl::Attributes::Primary1X::TypeInfo>(
+            peer_device->GetExchangeManager(), peer_device->GetSecureSession().Value(), binding.remote, onSuccess, onFailure);
+        break;
+
+    case Clusters::ColorControl::Attributes::Primary1Y::Id:
+        Controller::ReadAttribute<Clusters::ColorControl::Attributes::Primary1Y::TypeInfo>(
+            peer_device->GetExchangeManager(), peer_device->GetSecureSession().Value(), binding.remote, onSuccess, onFailure);
+        break;
+
+    case Clusters::ColorControl::Attributes::Primary1Intensity::Id:
+        Controller::ReadAttribute<Clusters::ColorControl::Attributes::Primary1Intensity::TypeInfo>(
+            peer_device->GetExchangeManager(), peer_device->GetSecureSession().Value(), binding.remote, onSuccess, onFailure);
+        break;
+
+    case Clusters::ColorControl::Attributes::Primary2X::Id:
+        Controller::ReadAttribute<Clusters::ColorControl::Attributes::Primary2X::TypeInfo>(
+            peer_device->GetExchangeManager(), peer_device->GetSecureSession().Value(), binding.remote, onSuccess, onFailure);
+        break;
+
+    case Clusters::ColorControl::Attributes::Primary2Y::Id:
+        Controller::ReadAttribute<Clusters::ColorControl::Attributes::Primary2Y::TypeInfo>(
+            peer_device->GetExchangeManager(), peer_device->GetSecureSession().Value(), binding.remote, onSuccess, onFailure);
+        break;
+
+    case Clusters::ColorControl::Attributes::Primary2Intensity::Id:
+        Controller::ReadAttribute<Clusters::ColorControl::Attributes::Primary2Intensity::TypeInfo>(
+            peer_device->GetExchangeManager(), peer_device->GetSecureSession().Value(), binding.remote, onSuccess, onFailure);
+        break;
+
+    case Clusters::ColorControl::Attributes::Primary3X::Id:
+        Controller::ReadAttribute<Clusters::ColorControl::Attributes::Primary3X::TypeInfo>(
+            peer_device->GetExchangeManager(), peer_device->GetSecureSession().Value(), binding.remote, onSuccess, onFailure);
+        break;
+
+    case Clusters::ColorControl::Attributes::Primary3Y::Id:
+        Controller::ReadAttribute<Clusters::ColorControl::Attributes::Primary3Y::TypeInfo>(
+            peer_device->GetExchangeManager(), peer_device->GetSecureSession().Value(), binding.remote, onSuccess, onFailure);
+        break;
+
+    case Clusters::ColorControl::Attributes::Primary3Intensity::Id:
+        Controller::ReadAttribute<Clusters::ColorControl::Attributes::Primary3Intensity::TypeInfo>(
+            peer_device->GetExchangeManager(), peer_device->GetSecureSession().Value(), binding.remote, onSuccess, onFailure);
+        break;
+
+    case Clusters::ColorControl::Attributes::Primary4X::Id:
+        Controller::ReadAttribute<Clusters::ColorControl::Attributes::Primary4X::TypeInfo>(
+            peer_device->GetExchangeManager(), peer_device->GetSecureSession().Value(), binding.remote, onSuccess, onFailure);
+        break;
+
+    case Clusters::ColorControl::Attributes::Primary4Y::Id:
+        Controller::ReadAttribute<Clusters::ColorControl::Attributes::Primary4Y::TypeInfo>(
+            peer_device->GetExchangeManager(), peer_device->GetSecureSession().Value(), binding.remote, onSuccess, onFailure);
+        break;
+
+    case Clusters::ColorControl::Attributes::Primary4Intensity::Id:
+        Controller::ReadAttribute<Clusters::ColorControl::Attributes::Primary4Intensity::TypeInfo>(
+            peer_device->GetExchangeManager(), peer_device->GetSecureSession().Value(), binding.remote, onSuccess, onFailure);
+        break;
+
+    case Clusters::ColorControl::Attributes::Primary5X::Id:
+        Controller::ReadAttribute<Clusters::ColorControl::Attributes::Primary5X::TypeInfo>(
+            peer_device->GetExchangeManager(), peer_device->GetSecureSession().Value(), binding.remote, onSuccess, onFailure);
+        break;
+
+    case Clusters::ColorControl::Attributes::Primary5Y::Id:
+        Controller::ReadAttribute<Clusters::ColorControl::Attributes::Primary5Y::TypeInfo>(
+            peer_device->GetExchangeManager(), peer_device->GetSecureSession().Value(), binding.remote, onSuccess, onFailure);
+        break;
+
+    case Clusters::ColorControl::Attributes::Primary5Intensity::Id:
+        Controller::ReadAttribute<Clusters::ColorControl::Attributes::Primary5Intensity::TypeInfo>(
+            peer_device->GetExchangeManager(), peer_device->GetSecureSession().Value(), binding.remote, onSuccess, onFailure);
+        break;
+
+    case Clusters::ColorControl::Attributes::Primary6X::Id:
+        Controller::ReadAttribute<Clusters::ColorControl::Attributes::Primary6X::TypeInfo>(
+            peer_device->GetExchangeManager(), peer_device->GetSecureSession().Value(), binding.remote, onSuccess, onFailure);
+        break;
+
+    case Clusters::ColorControl::Attributes::Primary6Y::Id:
+        Controller::ReadAttribute<Clusters::ColorControl::Attributes::Primary6Y::TypeInfo>(
+            peer_device->GetExchangeManager(), peer_device->GetSecureSession().Value(), binding.remote, onSuccess, onFailure);
+        break;
+
+    case Clusters::ColorControl::Attributes::Primary6Intensity::Id:
+        Controller::ReadAttribute<Clusters::ColorControl::Attributes::Primary6Intensity::TypeInfo>(
+            peer_device->GetExchangeManager(), peer_device->GetSecureSession().Value(), binding.remote, onSuccess, onFailure);
+        break;
+
+    case Clusters::ColorControl::Attributes::WhitePointX::Id:
+        Controller::ReadAttribute<Clusters::ColorControl::Attributes::WhitePointX::TypeInfo>(
+            peer_device->GetExchangeManager(), peer_device->GetSecureSession().Value(), binding.remote, onSuccess, onFailure);
+        break;
+
+    case Clusters::ColorControl::Attributes::WhitePointY::Id:
+        Controller::ReadAttribute<Clusters::ColorControl::Attributes::WhitePointY::TypeInfo>(
+            peer_device->GetExchangeManager(), peer_device->GetSecureSession().Value(), binding.remote, onSuccess, onFailure);
+        break;
+
+    case Clusters::ColorControl::Attributes::ColorPointRX::Id:
+        Controller::ReadAttribute<Clusters::ColorControl::Attributes::ColorPointRX::TypeInfo>(
+            peer_device->GetExchangeManager(), peer_device->GetSecureSession().Value(), binding.remote, onSuccess, onFailure);
+        break;
+
+    case Clusters::ColorControl::Attributes::ColorPointRY::Id:
+        Controller::ReadAttribute<Clusters::ColorControl::Attributes::ColorPointRY::TypeInfo>(
+            peer_device->GetExchangeManager(), peer_device->GetSecureSession().Value(), binding.remote, onSuccess, onFailure);
+        break;
+
+    case Clusters::ColorControl::Attributes::ColorPointRIntensity::Id:
+        Controller::ReadAttribute<Clusters::ColorControl::Attributes::ColorPointRIntensity::TypeInfo>(
+            peer_device->GetExchangeManager(), peer_device->GetSecureSession().Value(), binding.remote, onSuccess, onFailure);
+        break;
+
+    case Clusters::ColorControl::Attributes::ColorPointGX::Id:
+        Controller::ReadAttribute<Clusters::ColorControl::Attributes::ColorPointGX::TypeInfo>(
+            peer_device->GetExchangeManager(), peer_device->GetSecureSession().Value(), binding.remote, onSuccess, onFailure);
+        break;
+
+    case Clusters::ColorControl::Attributes::ColorPointGY::Id:
+        Controller::ReadAttribute<Clusters::ColorControl::Attributes::ColorPointGY::TypeInfo>(
+            peer_device->GetExchangeManager(), peer_device->GetSecureSession().Value(), binding.remote, onSuccess, onFailure);
+        break;
+
+    case Clusters::ColorControl::Attributes::ColorPointGIntensity::Id:
+        Controller::ReadAttribute<Clusters::ColorControl::Attributes::ColorPointGIntensity::TypeInfo>(
+            peer_device->GetExchangeManager(), peer_device->GetSecureSession().Value(), binding.remote, onSuccess, onFailure);
+        break;
+
+    case Clusters::ColorControl::Attributes::ColorPointBX::Id:
+        Controller::ReadAttribute<Clusters::ColorControl::Attributes::ColorPointBX::TypeInfo>(
+            peer_device->GetExchangeManager(), peer_device->GetSecureSession().Value(), binding.remote, onSuccess, onFailure);
+        break;
+
+    case Clusters::ColorControl::Attributes::ColorPointBY::Id:
+        Controller::ReadAttribute<Clusters::ColorControl::Attributes::ColorPointBY::TypeInfo>(
+            peer_device->GetExchangeManager(), peer_device->GetSecureSession().Value(), binding.remote, onSuccess, onFailure);
+        break;
+
+    case Clusters::ColorControl::Attributes::ColorPointBIntensity::Id:
+        Controller::ReadAttribute<Clusters::ColorControl::Attributes::ColorPointBIntensity::TypeInfo>(
+            peer_device->GetExchangeManager(), peer_device->GetSecureSession().Value(), binding.remote, onSuccess, onFailure);
+        break;
+
+    case Clusters::ColorControl::Attributes::EnhancedCurrentHue::Id:
+        Controller::ReadAttribute<Clusters::ColorControl::Attributes::EnhancedCurrentHue::TypeInfo>(
+            peer_device->GetExchangeManager(), peer_device->GetSecureSession().Value(), binding.remote, onSuccess, onFailure);
+        break;
+
+    case Clusters::ColorControl::Attributes::EnhancedColorMode::Id:
+        Controller::ReadAttribute<Clusters::ColorControl::Attributes::EnhancedColorMode::TypeInfo>(
+            peer_device->GetExchangeManager(), peer_device->GetSecureSession().Value(), binding.remote, onSuccess, onFailure);
+        break;
+
+    case Clusters::ColorControl::Attributes::ColorLoopActive::Id:
+        Controller::ReadAttribute<Clusters::ColorControl::Attributes::ColorLoopActive::TypeInfo>(
+            peer_device->GetExchangeManager(), peer_device->GetSecureSession().Value(), binding.remote, onSuccess, onFailure);
+        break;
+
+    case Clusters::ColorControl::Attributes::ColorLoopDirection::Id:
+        Controller::ReadAttribute<Clusters::ColorControl::Attributes::ColorLoopDirection::TypeInfo>(
+            peer_device->GetExchangeManager(), peer_device->GetSecureSession().Value(), binding.remote, onSuccess, onFailure);
+        break;
+
+    case Clusters::ColorControl::Attributes::ColorLoopTime::Id:
+        Controller::ReadAttribute<Clusters::ColorControl::Attributes::ColorLoopTime::TypeInfo>(
+            peer_device->GetExchangeManager(), peer_device->GetSecureSession().Value(), binding.remote, onSuccess, onFailure);
+        break;
+
+    case Clusters::ColorControl::Attributes::ColorLoopStartEnhancedHue::Id:
+        Controller::ReadAttribute<Clusters::ColorControl::Attributes::ColorLoopStartEnhancedHue::TypeInfo>(
+            peer_device->GetExchangeManager(), peer_device->GetSecureSession().Value(), binding.remote, onSuccess, onFailure);
+        break;
+
+    case Clusters::ColorControl::Attributes::ColorLoopStoredEnhancedHue::Id:
+        Controller::ReadAttribute<Clusters::ColorControl::Attributes::ColorLoopStoredEnhancedHue::TypeInfo>(
+            peer_device->GetExchangeManager(), peer_device->GetSecureSession().Value(), binding.remote, onSuccess, onFailure);
+        break;
+
+    case Clusters::ColorControl::Attributes::ColorCapabilities::Id:
+        Controller::ReadAttribute<Clusters::ColorControl::Attributes::ColorCapabilities::TypeInfo>(
+            peer_device->GetExchangeManager(), peer_device->GetSecureSession().Value(), binding.remote, onSuccess, onFailure);
+        break;
+
+    case Clusters::ColorControl::Attributes::ColorTempPhysicalMinMireds::Id:
+        Controller::ReadAttribute<Clusters::ColorControl::Attributes::ColorTempPhysicalMinMireds::TypeInfo>(
+            peer_device->GetExchangeManager(), peer_device->GetSecureSession().Value(), binding.remote, onSuccess, onFailure);
+        break;
+
+    case Clusters::ColorControl::Attributes::ColorTempPhysicalMaxMireds::Id:
+        Controller::ReadAttribute<Clusters::ColorControl::Attributes::ColorTempPhysicalMaxMireds::TypeInfo>(
+            peer_device->GetExchangeManager(), peer_device->GetSecureSession().Value(), binding.remote, onSuccess, onFailure);
+        break;
+
+    case Clusters::ColorControl::Attributes::CoupleColorTempToLevelMinMireds::Id:
+        Controller::ReadAttribute<Clusters::ColorControl::Attributes::CoupleColorTempToLevelMinMireds::TypeInfo>(
+            peer_device->GetExchangeManager(), peer_device->GetSecureSession().Value(), binding.remote, onSuccess, onFailure);
+        break;
+
+    case Clusters::ColorControl::Attributes::StartUpColorTemperatureMireds::Id:
+        Controller::ReadAttribute<Clusters::ColorControl::Attributes::StartUpColorTemperatureMireds::TypeInfo>(
+            peer_device->GetExchangeManager(), peer_device->GetSecureSession().Value(), binding.remote, onSuccess, onFailure);
+        break;
+    }
+}
+
+void ProcessColorControlUnicastBindingCommand(BindingCommandData * data, const EmberBindingTableEntry & binding,
+                                              OperationalDeviceProxy * peer_device)
+{
+    auto onSuccess = [](const ConcreteCommandPath & commandPath, const StatusIB & status, const auto & dataResponse) {
+        ChipLogProgress(NotSpecified, "ColorControl command succeeds");
+    };
+
+    auto onFailure = [](CHIP_ERROR error) {
+        ChipLogError(NotSpecified, "ColorControl command failed: %" CHIP_ERROR_FORMAT, error.Format());
+    };
+
+    VerifyOrDie(peer_device != nullptr && peer_device->ConnectionReady());
+
+    Clusters::ColorControl::Commands::MoveToHue::Type moveToHueCommand;
+    Clusters::ColorControl::Commands::MoveHue::Type moveHueCommand;
+    Clusters::ColorControl::Commands::StepHue::Type stepHueCommand;
+    Clusters::ColorControl::Commands::MoveToSaturation::Type moveToSaturationCommand;
+    Clusters::ColorControl::Commands::MoveSaturation::Type moveSaturationCommand;
+    Clusters::ColorControl::Commands::StepSaturation::Type stepSaturationCommand;
+    Clusters::ColorControl::Commands::MoveToHueAndSaturation::Type moveToHueAndSaturationCommand;
+    Clusters::ColorControl::Commands::MoveToColor::Type moveToColorCommand;
+    Clusters::ColorControl::Commands::MoveColor::Type moveColorCommand;
+    Clusters::ColorControl::Commands::StepColor::Type stepColorCommand;
+    Clusters::ColorControl::Commands::MoveToColorTemperature::Type moveToColorTemperatureCommand;
+    Clusters::ColorControl::Commands::EnhancedMoveToHue::Type enhancedMoveToHueCommand;
+    Clusters::ColorControl::Commands::EnhancedMoveHue::Type enhancedMoveHueCommand;
+    Clusters::ColorControl::Commands::EnhancedStepHue::Type enhancedStepHueCommand;
+    Clusters::ColorControl::Commands::EnhancedMoveToHueAndSaturation::Type enhancedMoveToHueAndSaturationCommand;
+    Clusters::ColorControl::Commands::ColorLoopSet::Type colorLoopSetCommand;
+    Clusters::ColorControl::Commands::StopMoveStep::Type stopMoveStepCommand;
+    Clusters::ColorControl::Commands::MoveColorTemperature::Type moveColorTemperatureCommand;
+    Clusters::ColorControl::Commands::StepColorTemperature::Type stepColorTemperatureCommand;
+
+    switch (data->commandId)
+    {
+    case Clusters::ColorControl::Commands::MoveToHue::Id:
+        moveToHueCommand.hue             = static_cast<uint8_t>(data->args[0]);
+        moveToHueCommand.direction       = static_cast<EmberAfHueDirection>(data->args[1]);
+        moveToHueCommand.transitionTime  = static_cast<uint16_t>(data->args[2]);
+        moveToHueCommand.optionsMask     = static_cast<uint8_t>(data->args[3]);
+        moveToHueCommand.optionsOverride = static_cast<uint8_t>(data->args[4]);
+        Controller::InvokeCommandRequest(peer_device->GetExchangeManager(), peer_device->GetSecureSession().Value(), binding.remote,
+                                         moveToHueCommand, onSuccess, onFailure);
+        break;
+
+    case Clusters::ColorControl::Commands::MoveHue::Id:
+        moveHueCommand.moveMode        = static_cast<EmberAfHueMoveMode>(data->args[0]);
+        moveHueCommand.rate            = static_cast<uint8_t>(data->args[1]);
+        moveHueCommand.optionsMask     = static_cast<uint8_t>(data->args[2]);
+        moveHueCommand.optionsOverride = static_cast<uint8_t>(data->args[3]);
+        Controller::InvokeCommandRequest(peer_device->GetExchangeManager(), peer_device->GetSecureSession().Value(), binding.remote,
+                                         moveHueCommand, onSuccess, onFailure);
+        break;
+
+    case Clusters::ColorControl::Commands::StepHue::Id:
+        stepHueCommand.stepMode        = static_cast<EmberAfHueStepMode>(data->args[0]);
+        stepHueCommand.stepSize        = static_cast<uint8_t>(data->args[1]);
+        stepHueCommand.transitionTime  = static_cast<uint8_t>(data->args[2]);
+        stepHueCommand.optionsMask     = static_cast<uint8_t>(data->args[3]);
+        stepHueCommand.optionsOverride = static_cast<uint8_t>(data->args[4]);
+        Controller::InvokeCommandRequest(peer_device->GetExchangeManager(), peer_device->GetSecureSession().Value(), binding.remote,
+                                         stepHueCommand, onSuccess, onFailure);
+        break;
+
+    case Clusters::ColorControl::Commands::MoveToSaturation::Id:
+        moveToSaturationCommand.saturation      = static_cast<uint8_t>(data->args[0]);
+        moveToSaturationCommand.transitionTime  = static_cast<uint16_t>(data->args[1]);
+        moveToSaturationCommand.optionsMask     = static_cast<uint8_t>(data->args[2]);
+        moveToSaturationCommand.optionsOverride = static_cast<uint8_t>(data->args[3]);
+        Controller::InvokeCommandRequest(peer_device->GetExchangeManager(), peer_device->GetSecureSession().Value(), binding.remote,
+                                         moveToSaturationCommand, onSuccess, onFailure);
+        break;
+
+    case Clusters::ColorControl::Commands::MoveSaturation::Id:
+        moveSaturationCommand.moveMode        = static_cast<EmberAfSaturationMoveMode>(data->args[0]);
+        moveSaturationCommand.rate            = static_cast<uint8_t>(data->args[1]);
+        moveSaturationCommand.optionsMask     = static_cast<uint8_t>(data->args[2]);
+        moveSaturationCommand.optionsOverride = static_cast<uint8_t>(data->args[3]);
+        Controller::InvokeCommandRequest(peer_device->GetExchangeManager(), peer_device->GetSecureSession().Value(), binding.remote,
+                                         moveSaturationCommand, onSuccess, onFailure);
+        break;
+
+    case Clusters::ColorControl::Commands::StepSaturation::Id:
+        stepSaturationCommand.stepMode        = static_cast<EmberAfSaturationStepMode>(data->args[0]);
+        stepSaturationCommand.stepSize        = static_cast<uint8_t>(data->args[1]);
+        stepSaturationCommand.transitionTime  = static_cast<uint8_t>(data->args[2]);
+        stepSaturationCommand.optionsMask     = static_cast<uint8_t>(data->args[3]);
+        stepSaturationCommand.optionsOverride = static_cast<uint8_t>(data->args[4]);
+        Controller::InvokeCommandRequest(peer_device->GetExchangeManager(), peer_device->GetSecureSession().Value(), binding.remote,
+                                         stepSaturationCommand, onSuccess, onFailure);
+        break;
+
+    case Clusters::ColorControl::Commands::MoveToHueAndSaturation::Id:
+        moveToHueAndSaturationCommand.hue             = static_cast<uint8_t>(data->args[0]);
+        moveToHueAndSaturationCommand.saturation      = static_cast<uint8_t>(data->args[1]);
+        moveToHueAndSaturationCommand.transitionTime  = static_cast<uint16_t>(data->args[2]);
+        moveToHueAndSaturationCommand.optionsMask     = static_cast<uint8_t>(data->args[3]);
+        moveToHueAndSaturationCommand.optionsOverride = static_cast<uint8_t>(data->args[4]);
+        Controller::InvokeCommandRequest(peer_device->GetExchangeManager(), peer_device->GetSecureSession().Value(), binding.remote,
+                                         moveToHueAndSaturationCommand, onSuccess, onFailure);
+        break;
+
+    case Clusters::ColorControl::Commands::MoveToColor::Id:
+        moveToColorCommand.colorX          = static_cast<uint16_t>(data->args[0]);
+        moveToColorCommand.colorY          = static_cast<uint16_t>(data->args[1]);
+        moveToColorCommand.transitionTime  = static_cast<uint16_t>(data->args[2]);
+        moveToColorCommand.optionsMask     = static_cast<uint8_t>(data->args[3]);
+        moveToColorCommand.optionsOverride = static_cast<uint8_t>(data->args[4]);
+        Controller::InvokeCommandRequest(peer_device->GetExchangeManager(), peer_device->GetSecureSession().Value(), binding.remote,
+                                         moveToColorCommand, onSuccess, onFailure);
+        break;
+
+    case Clusters::ColorControl::Commands::MoveColor::Id:
+        moveColorCommand.rateX           = static_cast<uint16_t>(data->args[0]);
+        moveColorCommand.rateY           = static_cast<uint16_t>(data->args[1]);
+        moveColorCommand.optionsMask     = static_cast<uint8_t>(data->args[2]);
+        moveColorCommand.optionsOverride = static_cast<uint8_t>(data->args[3]);
+        Controller::InvokeCommandRequest(peer_device->GetExchangeManager(), peer_device->GetSecureSession().Value(), binding.remote,
+                                         moveColorCommand, onSuccess, onFailure);
+        break;
+
+    case Clusters::ColorControl::Commands::StepColor::Id:
+        stepColorCommand.stepX           = static_cast<uint16_t>(data->args[0]);
+        stepColorCommand.stepY           = static_cast<uint16_t>(data->args[1]);
+        stepColorCommand.transitionTime  = static_cast<uint16_t>(data->args[2]);
+        stepColorCommand.optionsMask     = static_cast<uint8_t>(data->args[3]);
+        stepColorCommand.optionsOverride = static_cast<uint8_t>(data->args[4]);
+        Controller::InvokeCommandRequest(peer_device->GetExchangeManager(), peer_device->GetSecureSession().Value(), binding.remote,
+                                         stepColorCommand, onSuccess, onFailure);
+        break;
+
+    case Clusters::ColorControl::Commands::MoveToColorTemperature::Id:
+        moveToColorTemperatureCommand.colorTemperature = static_cast<uint16_t>(data->args[0]);
+        moveToColorTemperatureCommand.transitionTime   = static_cast<uint16_t>(data->args[1]);
+        moveToColorTemperatureCommand.optionsMask      = static_cast<uint8_t>(data->args[2]);
+        moveToColorTemperatureCommand.optionsOverride  = static_cast<uint8_t>(data->args[3]);
+        Controller::InvokeCommandRequest(peer_device->GetExchangeManager(), peer_device->GetSecureSession().Value(), binding.remote,
+                                         moveToColorTemperatureCommand, onSuccess, onFailure);
+        break;
+
+    case Clusters::ColorControl::Commands::EnhancedMoveToHue::Id:
+        enhancedMoveToHueCommand.enhancedHue     = static_cast<uint16_t>(data->args[0]);
+        enhancedMoveToHueCommand.direction       = static_cast<EmberAfHueDirection>(data->args[1]);
+        enhancedMoveToHueCommand.transitionTime  = static_cast<uint16_t>(data->args[2]);
+        enhancedMoveToHueCommand.optionsMask     = static_cast<uint8_t>(data->args[3]);
+        enhancedMoveToHueCommand.optionsOverride = static_cast<uint8_t>(data->args[4]);
+        Controller::InvokeCommandRequest(peer_device->GetExchangeManager(), peer_device->GetSecureSession().Value(), binding.remote,
+                                         enhancedMoveToHueCommand, onSuccess, onFailure);
+        break;
+
+    case Clusters::ColorControl::Commands::EnhancedMoveHue::Id:
+        enhancedMoveHueCommand.moveMode        = static_cast<EmberAfHueMoveMode>(data->args[0]);
+        enhancedMoveHueCommand.rate            = static_cast<uint16_t>(data->args[1]);
+        enhancedMoveHueCommand.optionsMask     = static_cast<uint8_t>(data->args[2]);
+        enhancedMoveHueCommand.optionsOverride = static_cast<uint8_t>(data->args[3]);
+        Controller::InvokeCommandRequest(peer_device->GetExchangeManager(), peer_device->GetSecureSession().Value(), binding.remote,
+                                         enhancedMoveHueCommand, onSuccess, onFailure);
+        break;
+
+    case Clusters::ColorControl::Commands::EnhancedStepHue::Id:
+        enhancedStepHueCommand.stepMode        = static_cast<EmberAfHueStepMode>(data->args[0]);
+        enhancedStepHueCommand.stepSize        = static_cast<uint16_t>(data->args[1]);
+        enhancedStepHueCommand.transitionTime  = static_cast<uint16_t>(data->args[2]);
+        enhancedStepHueCommand.optionsMask     = static_cast<uint8_t>(data->args[3]);
+        enhancedStepHueCommand.optionsOverride = static_cast<uint8_t>(data->args[4]);
+        Controller::InvokeCommandRequest(peer_device->GetExchangeManager(), peer_device->GetSecureSession().Value(), binding.remote,
+                                         enhancedStepHueCommand, onSuccess, onFailure);
+        break;
+
+    case Clusters::ColorControl::Commands::EnhancedMoveToHueAndSaturation::Id:
+        enhancedMoveToHueAndSaturationCommand.enhancedHue     = static_cast<uint16_t>(data->args[0]);
+        enhancedMoveToHueAndSaturationCommand.saturation      = static_cast<uint8_t>(data->args[1]);
+        enhancedMoveToHueAndSaturationCommand.transitionTime  = static_cast<uint16_t>(data->args[2]);
+        enhancedMoveToHueAndSaturationCommand.optionsMask     = static_cast<uint8_t>(data->args[3]);
+        enhancedMoveToHueAndSaturationCommand.optionsOverride = static_cast<uint8_t>(data->args[4]);
+        Controller::InvokeCommandRequest(peer_device->GetExchangeManager(), peer_device->GetSecureSession().Value(), binding.remote,
+                                         enhancedMoveToHueAndSaturationCommand, onSuccess, onFailure);
+        break;
+
+    case Clusters::ColorControl::Commands::ColorLoopSet::Id:
+        colorLoopSetCommand.updateFlags =
+            static_cast<chip::BitMask<chip::app::Clusters::ColorControl::ColorLoopUpdateFlags>>(data->args[0]);
+        colorLoopSetCommand.action          = static_cast<EmberAfColorLoopAction>(data->args[1]);
+        colorLoopSetCommand.direction       = static_cast<EmberAfColorLoopDirection>(data->args[2]);
+        colorLoopSetCommand.time            = static_cast<uint16_t>(data->args[3]);
+        colorLoopSetCommand.startHue        = static_cast<uint16_t>(data->args[4]);
+        colorLoopSetCommand.optionsMask     = static_cast<uint8_t>(data->args[5]);
+        colorLoopSetCommand.optionsOverride = static_cast<uint8_t>(data->args[6]);
+        Controller::InvokeCommandRequest(peer_device->GetExchangeManager(), peer_device->GetSecureSession().Value(), binding.remote,
+                                         colorLoopSetCommand, onSuccess, onFailure);
+        break;
+
+    case Clusters::ColorControl::Commands::StopMoveStep::Id:
+        stopMoveStepCommand.optionsMask     = static_cast<uint8_t>(data->args[0]);
+        stopMoveStepCommand.optionsOverride = static_cast<uint8_t>(data->args[1]);
+        Controller::InvokeCommandRequest(peer_device->GetExchangeManager(), peer_device->GetSecureSession().Value(), binding.remote,
+                                         stopMoveStepCommand, onSuccess, onFailure);
+        break;
+
+    case Clusters::ColorControl::Commands::MoveColorTemperature::Id:
+        moveColorTemperatureCommand.moveMode                      = static_cast<EmberAfHueMoveMode>(data->args[0]);
+        moveColorTemperatureCommand.rate                          = static_cast<uint16_t>(data->args[1]);
+        moveColorTemperatureCommand.colorTemperatureMinimumMireds = static_cast<uint16_t>(data->args[2]);
+        moveColorTemperatureCommand.colorTemperatureMaximumMireds = static_cast<uint16_t>(data->args[3]);
+        moveColorTemperatureCommand.optionsMask                   = static_cast<uint8_t>(data->args[4]);
+        moveColorTemperatureCommand.optionsOverride               = static_cast<uint8_t>(data->args[5]);
+        Controller::InvokeCommandRequest(peer_device->GetExchangeManager(), peer_device->GetSecureSession().Value(), binding.remote,
+                                         moveColorTemperatureCommand, onSuccess, onFailure);
+        break;
+
+    case Clusters::ColorControl::Commands::StepColorTemperature::Id:
+        stepColorTemperatureCommand.stepMode                      = static_cast<EmberAfHueStepMode>(data->args[0]);
+        stepColorTemperatureCommand.stepSize                      = static_cast<uint16_t>(data->args[1]);
+        stepColorTemperatureCommand.transitionTime                = static_cast<uint16_t>(data->args[2]);
+        stepColorTemperatureCommand.colorTemperatureMinimumMireds = static_cast<uint16_t>(data->args[3]);
+        stepColorTemperatureCommand.colorTemperatureMaximumMireds = static_cast<uint16_t>(data->args[4]);
+        stepColorTemperatureCommand.optionsMask                   = static_cast<uint8_t>(data->args[5]);
+        stepColorTemperatureCommand.optionsOverride               = static_cast<uint8_t>(data->args[6]);
+        Controller::InvokeCommandRequest(peer_device->GetExchangeManager(), peer_device->GetSecureSession().Value(), binding.remote,
+                                         stepColorTemperatureCommand, onSuccess, onFailure);
+        break;
+    }
+}
+
+void ProcessColorControlGroupBindingCommand(BindingCommandData * data, const EmberBindingTableEntry & binding)
+{
+    Messaging::ExchangeManager & exchangeMgr = Server::GetInstance().GetExchangeManager();
+
+    Clusters::ColorControl::Commands::MoveToHue::Type moveToHueCommand;
+    Clusters::ColorControl::Commands::MoveHue::Type moveHueCommand;
+    Clusters::ColorControl::Commands::StepHue::Type stepHueCommand;
+    Clusters::ColorControl::Commands::MoveToSaturation::Type moveToSaturationCommand;
+    Clusters::ColorControl::Commands::MoveSaturation::Type moveSaturationCommand;
+    Clusters::ColorControl::Commands::StepSaturation::Type stepSaturationCommand;
+    Clusters::ColorControl::Commands::MoveToHueAndSaturation::Type moveToHueAndSaturationCommand;
+    Clusters::ColorControl::Commands::MoveToColor::Type moveToColorCommand;
+    Clusters::ColorControl::Commands::MoveColor::Type moveColorCommand;
+    Clusters::ColorControl::Commands::StepColor::Type stepColorCommand;
+    Clusters::ColorControl::Commands::MoveToColorTemperature::Type moveToColorTemperatureCommand;
+    Clusters::ColorControl::Commands::EnhancedMoveToHue::Type enhancedMoveToHueCommand;
+    Clusters::ColorControl::Commands::EnhancedMoveHue::Type enhancedMoveHueCommand;
+    Clusters::ColorControl::Commands::EnhancedStepHue::Type enhancedStepHueCommand;
+    Clusters::ColorControl::Commands::EnhancedMoveToHueAndSaturation::Type enhancedMoveToHueAndSaturationCommand;
+    Clusters::ColorControl::Commands::ColorLoopSet::Type colorLoopSetCommand;
+    Clusters::ColorControl::Commands::StopMoveStep::Type stopMoveStepCommand;
+    Clusters::ColorControl::Commands::MoveColorTemperature::Type moveColorTemperatureCommand;
+    Clusters::ColorControl::Commands::StepColorTemperature::Type stepColorTemperatureCommand;
+
+    switch (data->commandId)
+    {
+    case Clusters::ColorControl::Commands::MoveToHue::Id:
+        moveToHueCommand.hue             = static_cast<uint8_t>(data->args[0]);
+        moveToHueCommand.direction       = static_cast<EmberAfHueDirection>(data->args[1]);
+        moveToHueCommand.transitionTime  = static_cast<uint16_t>(data->args[2]);
+        moveToHueCommand.optionsMask     = static_cast<uint8_t>(data->args[3]);
+        moveToHueCommand.optionsOverride = static_cast<uint8_t>(data->args[4]);
+        Controller::InvokeGroupCommandRequest(&exchangeMgr, binding.fabricIndex, binding.groupId, moveToHueCommand);
+        break;
+
+    case Clusters::ColorControl::Commands::MoveHue::Id:
+        moveHueCommand.moveMode        = static_cast<EmberAfHueMoveMode>(data->args[0]);
+        moveHueCommand.rate            = static_cast<uint8_t>(data->args[1]);
+        moveHueCommand.optionsMask     = static_cast<uint8_t>(data->args[2]);
+        moveHueCommand.optionsOverride = static_cast<uint8_t>(data->args[3]);
+        Controller::InvokeGroupCommandRequest(&exchangeMgr, binding.fabricIndex, binding.groupId, moveHueCommand);
+        break;
+
+    case Clusters::ColorControl::Commands::StepHue::Id:
+        stepHueCommand.stepMode        = static_cast<EmberAfHueStepMode>(data->args[0]);
+        stepHueCommand.stepSize        = static_cast<uint8_t>(data->args[1]);
+        stepHueCommand.transitionTime  = static_cast<uint8_t>(data->args[2]);
+        stepHueCommand.optionsMask     = static_cast<uint8_t>(data->args[3]);
+        stepHueCommand.optionsOverride = static_cast<uint8_t>(data->args[4]);
+        Controller::InvokeGroupCommandRequest(&exchangeMgr, binding.fabricIndex, binding.groupId, stepHueCommand);
+        break;
+
+    case Clusters::ColorControl::Commands::MoveToSaturation::Id:
+        moveToSaturationCommand.saturation      = static_cast<uint8_t>(data->args[0]);
+        moveToSaturationCommand.transitionTime  = static_cast<uint16_t>(data->args[1]);
+        moveToSaturationCommand.optionsMask     = static_cast<uint8_t>(data->args[2]);
+        moveToSaturationCommand.optionsOverride = static_cast<uint8_t>(data->args[3]);
+        Controller::InvokeGroupCommandRequest(&exchangeMgr, binding.fabricIndex, binding.groupId, moveToSaturationCommand);
+        break;
+
+    case Clusters::ColorControl::Commands::MoveSaturation::Id:
+        moveSaturationCommand.moveMode        = static_cast<EmberAfSaturationMoveMode>(data->args[0]);
+        moveSaturationCommand.rate            = static_cast<uint8_t>(data->args[1]);
+        moveSaturationCommand.optionsMask     = static_cast<uint8_t>(data->args[2]);
+        moveSaturationCommand.optionsOverride = static_cast<uint8_t>(data->args[3]);
+        Controller::InvokeGroupCommandRequest(&exchangeMgr, binding.fabricIndex, binding.groupId, moveSaturationCommand);
+        break;
+
+    case Clusters::ColorControl::Commands::StepSaturation::Id:
+        stepSaturationCommand.stepMode        = static_cast<EmberAfSaturationStepMode>(data->args[0]);
+        stepSaturationCommand.stepSize        = static_cast<uint8_t>(data->args[1]);
+        stepSaturationCommand.transitionTime  = static_cast<uint8_t>(data->args[2]);
+        stepSaturationCommand.optionsMask     = static_cast<uint8_t>(data->args[3]);
+        stepSaturationCommand.optionsOverride = static_cast<uint8_t>(data->args[4]);
+        Controller::InvokeGroupCommandRequest(&exchangeMgr, binding.fabricIndex, binding.groupId, stepSaturationCommand);
+        break;
+
+    case Clusters::ColorControl::Commands::MoveToHueAndSaturation::Id:
+        moveToHueAndSaturationCommand.hue             = static_cast<uint8_t>(data->args[0]);
+        moveToHueAndSaturationCommand.saturation      = static_cast<uint8_t>(data->args[1]);
+        moveToHueAndSaturationCommand.transitionTime  = static_cast<uint16_t>(data->args[2]);
+        moveToHueAndSaturationCommand.optionsMask     = static_cast<uint8_t>(data->args[3]);
+        moveToHueAndSaturationCommand.optionsOverride = static_cast<uint8_t>(data->args[4]);
+        Controller::InvokeGroupCommandRequest(&exchangeMgr, binding.fabricIndex, binding.groupId, moveToHueAndSaturationCommand);
+        break;
+
+    case Clusters::ColorControl::Commands::MoveToColor::Id:
+        moveToColorCommand.colorX          = static_cast<uint16_t>(data->args[0]);
+        moveToColorCommand.colorY          = static_cast<uint16_t>(data->args[1]);
+        moveToColorCommand.transitionTime  = static_cast<uint16_t>(data->args[2]);
+        moveToColorCommand.optionsMask     = static_cast<uint8_t>(data->args[3]);
+        moveToColorCommand.optionsOverride = static_cast<uint8_t>(data->args[4]);
+        Controller::InvokeGroupCommandRequest(&exchangeMgr, binding.fabricIndex, binding.groupId, moveToColorCommand);
+        break;
+
+    case Clusters::ColorControl::Commands::MoveColor::Id:
+        moveColorCommand.rateX           = static_cast<uint16_t>(data->args[0]);
+        moveColorCommand.rateY           = static_cast<uint16_t>(data->args[1]);
+        moveColorCommand.optionsMask     = static_cast<uint8_t>(data->args[2]);
+        moveColorCommand.optionsOverride = static_cast<uint8_t>(data->args[3]);
+        Controller::InvokeGroupCommandRequest(&exchangeMgr, binding.fabricIndex, binding.groupId, moveColorCommand);
+        break;
+
+    case Clusters::ColorControl::Commands::StepColor::Id:
+        stepColorCommand.stepX           = static_cast<uint16_t>(data->args[0]);
+        stepColorCommand.stepY           = static_cast<uint16_t>(data->args[1]);
+        stepColorCommand.transitionTime  = static_cast<uint16_t>(data->args[2]);
+        stepColorCommand.optionsMask     = static_cast<uint8_t>(data->args[3]);
+        stepColorCommand.optionsOverride = static_cast<uint8_t>(data->args[4]);
+        Controller::InvokeGroupCommandRequest(&exchangeMgr, binding.fabricIndex, binding.groupId, stepColorCommand);
+        break;
+
+    case Clusters::ColorControl::Commands::MoveToColorTemperature::Id:
+        moveToColorTemperatureCommand.colorTemperature = static_cast<uint16_t>(data->args[0]);
+        moveToColorTemperatureCommand.transitionTime   = static_cast<uint16_t>(data->args[1]);
+        moveToColorTemperatureCommand.optionsMask      = static_cast<uint8_t>(data->args[2]);
+        moveToColorTemperatureCommand.optionsOverride  = static_cast<uint8_t>(data->args[3]);
+        Controller::InvokeGroupCommandRequest(&exchangeMgr, binding.fabricIndex, binding.groupId, moveToColorTemperatureCommand);
+        break;
+
+    case Clusters::ColorControl::Commands::EnhancedMoveToHue::Id:
+        enhancedMoveToHueCommand.enhancedHue     = static_cast<uint16_t>(data->args[0]);
+        enhancedMoveToHueCommand.direction       = static_cast<EmberAfHueDirection>(data->args[1]);
+        enhancedMoveToHueCommand.transitionTime  = static_cast<uint16_t>(data->args[2]);
+        enhancedMoveToHueCommand.optionsMask     = static_cast<uint8_t>(data->args[3]);
+        enhancedMoveToHueCommand.optionsOverride = static_cast<uint8_t>(data->args[4]);
+        Controller::InvokeGroupCommandRequest(&exchangeMgr, binding.fabricIndex, binding.groupId, enhancedMoveToHueCommand);
+        break;
+
+    case Clusters::ColorControl::Commands::EnhancedMoveHue::Id:
+        enhancedMoveHueCommand.moveMode        = static_cast<EmberAfHueMoveMode>(data->args[0]);
+        enhancedMoveHueCommand.rate            = static_cast<uint16_t>(data->args[1]);
+        enhancedMoveHueCommand.optionsMask     = static_cast<uint8_t>(data->args[2]);
+        enhancedMoveHueCommand.optionsOverride = static_cast<uint8_t>(data->args[3]);
+        Controller::InvokeGroupCommandRequest(&exchangeMgr, binding.fabricIndex, binding.groupId, enhancedMoveHueCommand);
+        break;
+
+    case Clusters::ColorControl::Commands::EnhancedStepHue::Id:
+        enhancedStepHueCommand.stepMode        = static_cast<EmberAfHueStepMode>(data->args[0]);
+        enhancedStepHueCommand.stepSize        = static_cast<uint16_t>(data->args[1]);
+        enhancedStepHueCommand.transitionTime  = static_cast<uint16_t>(data->args[2]);
+        enhancedStepHueCommand.optionsMask     = static_cast<uint8_t>(data->args[3]);
+        enhancedStepHueCommand.optionsOverride = static_cast<uint8_t>(data->args[4]);
+        Controller::InvokeGroupCommandRequest(&exchangeMgr, binding.fabricIndex, binding.groupId, enhancedStepHueCommand);
+        break;
+
+    case Clusters::ColorControl::Commands::EnhancedMoveToHueAndSaturation::Id:
+        enhancedMoveToHueAndSaturationCommand.enhancedHue     = static_cast<uint16_t>(data->args[0]);
+        enhancedMoveToHueAndSaturationCommand.saturation      = static_cast<uint8_t>(data->args[1]);
+        enhancedMoveToHueAndSaturationCommand.transitionTime  = static_cast<uint16_t>(data->args[2]);
+        enhancedMoveToHueAndSaturationCommand.optionsMask     = static_cast<uint8_t>(data->args[3]);
+        enhancedMoveToHueAndSaturationCommand.optionsOverride = static_cast<uint8_t>(data->args[4]);
+        Controller::InvokeGroupCommandRequest(&exchangeMgr, binding.fabricIndex, binding.groupId,
+                                              enhancedMoveToHueAndSaturationCommand);
+        break;
+
+    case Clusters::ColorControl::Commands::ColorLoopSet::Id:
+        colorLoopSetCommand.updateFlags =
+            static_cast<chip::BitMask<chip::app::Clusters::ColorControl::ColorLoopUpdateFlags>>(data->args[0]);
+        colorLoopSetCommand.action          = static_cast<EmberAfColorLoopAction>(data->args[1]);
+        colorLoopSetCommand.direction       = static_cast<EmberAfColorLoopDirection>(data->args[2]);
+        colorLoopSetCommand.time            = static_cast<uint16_t>(data->args[3]);
+        colorLoopSetCommand.startHue        = static_cast<uint16_t>(data->args[4]);
+        colorLoopSetCommand.optionsMask     = static_cast<uint8_t>(data->args[5]);
+        colorLoopSetCommand.optionsOverride = static_cast<uint8_t>(data->args[6]);
+        Controller::InvokeGroupCommandRequest(&exchangeMgr, binding.fabricIndex, binding.groupId, colorLoopSetCommand);
+        break;
+
+    case Clusters::ColorControl::Commands::StopMoveStep::Id:
+        stopMoveStepCommand.optionsMask     = static_cast<uint8_t>(data->args[0]);
+        stopMoveStepCommand.optionsOverride = static_cast<uint8_t>(data->args[1]);
+        Controller::InvokeGroupCommandRequest(&exchangeMgr, binding.fabricIndex, binding.groupId, stopMoveStepCommand);
+        break;
+
+    case Clusters::ColorControl::Commands::MoveColorTemperature::Id:
+        moveColorTemperatureCommand.moveMode                      = static_cast<EmberAfHueMoveMode>(data->args[0]);
+        moveColorTemperatureCommand.rate                          = static_cast<uint16_t>(data->args[1]);
+        moveColorTemperatureCommand.colorTemperatureMinimumMireds = static_cast<uint16_t>(data->args[2]);
+        moveColorTemperatureCommand.colorTemperatureMaximumMireds = static_cast<uint16_t>(data->args[3]);
+        moveColorTemperatureCommand.optionsMask                   = static_cast<uint8_t>(data->args[4]);
+        moveColorTemperatureCommand.optionsOverride               = static_cast<uint8_t>(data->args[5]);
+        Controller::InvokeGroupCommandRequest(&exchangeMgr, binding.fabricIndex, binding.groupId, moveColorTemperatureCommand);
+        break;
+
+    case Clusters::ColorControl::Commands::StepColorTemperature::Id:
+        stepColorTemperatureCommand.stepMode                      = static_cast<EmberAfHueStepMode>(data->args[0]);
+        stepColorTemperatureCommand.stepSize                      = static_cast<uint16_t>(data->args[1]);
+        stepColorTemperatureCommand.transitionTime                = static_cast<uint16_t>(data->args[2]);
+        stepColorTemperatureCommand.colorTemperatureMinimumMireds = static_cast<uint16_t>(data->args[3]);
+        stepColorTemperatureCommand.colorTemperatureMaximumMireds = static_cast<uint16_t>(data->args[4]);
+        stepColorTemperatureCommand.optionsMask                   = static_cast<uint8_t>(data->args[5]);
+        stepColorTemperatureCommand.optionsOverride               = static_cast<uint8_t>(data->args[6]);
+        Controller::InvokeGroupCommandRequest(&exchangeMgr, binding.fabricIndex, binding.groupId, stepColorTemperatureCommand);
+        break;
+    }
+}
+
+#if CONFIG_ENABLE_CHIP_SHELL
+/********************************************************
+ * ColorControl switch shell functions
+ *********************************************************/
+
+CHIP_ERROR ColorControlHelpHandler(int argc, char ** argv)
+{
+    sShellSwitchColorControlSubCommands.ForEachCommand(Shell::PrintCommandHelp, nullptr);
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR ColorControlSwitchCommandHandler(int argc, char ** argv)
+{
+    if (argc == 0)
+    {
+        return ColorControlHelpHandler(argc, argv);
+    }
+
+    return sShellSwitchColorControlSubCommands.ExecCommand(argc, argv);
+}
+
+CHIP_ERROR MoveToHueCommandHandler(int argc, char ** argv)
+{
+    if (argc != 5)
+    {
+        return ColorControlHelpHandler(argc, argv);
+    }
+
+    BindingCommandData * data = Platform::New<BindingCommandData>();
+    data->commandId           = Clusters::ColorControl::Commands::MoveToHue::Id;
+    data->clusterId           = Clusters::ColorControl::Id;
+    data->args[0]             = atoi(argv[0]);
+    data->args[1]             = atoi(argv[1]);
+    data->args[2]             = atoi(argv[2]);
+    data->args[3]             = atoi(argv[3]);
+    data->args[4]             = atoi(argv[4]);
+
+    DeviceLayer::PlatformMgr().ScheduleWork(SwitchWorkerFunction, reinterpret_cast<intptr_t>(data));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR MoveHueCommandHandler(int argc, char ** argv)
+{
+    if (argc != 4)
+    {
+        return ColorControlHelpHandler(argc, argv);
+    }
+
+    BindingCommandData * data = Platform::New<BindingCommandData>();
+    data->commandId           = Clusters::ColorControl::Commands::MoveHue::Id;
+    data->clusterId           = Clusters::ColorControl::Id;
+    data->args[0]             = atoi(argv[0]);
+    data->args[1]             = atoi(argv[1]);
+    data->args[2]             = atoi(argv[2]);
+    data->args[3]             = atoi(argv[3]);
+
+    DeviceLayer::PlatformMgr().ScheduleWork(SwitchWorkerFunction, reinterpret_cast<intptr_t>(data));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR StepHueCommandHandler(int argc, char ** argv)
+{
+    if (argc != 5)
+    {
+        return ColorControlHelpHandler(argc, argv);
+    }
+
+    BindingCommandData * data = Platform::New<BindingCommandData>();
+    data->commandId           = Clusters::ColorControl::Commands::StepHue::Id;
+    data->clusterId           = Clusters::ColorControl::Id;
+    data->args[0]             = atoi(argv[0]);
+    data->args[1]             = atoi(argv[1]);
+    data->args[2]             = atoi(argv[2]);
+    data->args[3]             = atoi(argv[3]);
+    data->args[4]             = atoi(argv[4]);
+
+    DeviceLayer::PlatformMgr().ScheduleWork(SwitchWorkerFunction, reinterpret_cast<intptr_t>(data));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR MoveToSaturationCommandHandler(int argc, char ** argv)
+{
+    if (argc != 4)
+    {
+        return ColorControlHelpHandler(argc, argv);
+    }
+
+    BindingCommandData * data = Platform::New<BindingCommandData>();
+    data->commandId           = Clusters::ColorControl::Commands::MoveToSaturation::Id;
+    data->clusterId           = Clusters::ColorControl::Id;
+    data->args[0]             = atoi(argv[0]);
+    data->args[1]             = atoi(argv[1]);
+    data->args[2]             = atoi(argv[2]);
+    data->args[3]             = atoi(argv[3]);
+
+    DeviceLayer::PlatformMgr().ScheduleWork(SwitchWorkerFunction, reinterpret_cast<intptr_t>(data));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR MoveSaturationCommandHandler(int argc, char ** argv)
+{
+    if (argc != 4)
+    {
+        return ColorControlHelpHandler(argc, argv);
+    }
+
+    BindingCommandData * data = Platform::New<BindingCommandData>();
+    data->commandId           = Clusters::ColorControl::Commands::MoveSaturation::Id;
+    data->clusterId           = Clusters::ColorControl::Id;
+    data->args[0]             = atoi(argv[0]);
+    data->args[1]             = atoi(argv[1]);
+    data->args[2]             = atoi(argv[2]);
+    data->args[3]             = atoi(argv[3]);
+
+    DeviceLayer::PlatformMgr().ScheduleWork(SwitchWorkerFunction, reinterpret_cast<intptr_t>(data));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR StepSaturationCommandHandler(int argc, char ** argv)
+{
+    if (argc != 5)
+    {
+        return ColorControlHelpHandler(argc, argv);
+    }
+
+    BindingCommandData * data = Platform::New<BindingCommandData>();
+    data->commandId           = Clusters::ColorControl::Commands::StepSaturation::Id;
+    data->clusterId           = Clusters::ColorControl::Id;
+    data->args[0]             = atoi(argv[0]);
+    data->args[1]             = atoi(argv[1]);
+    data->args[2]             = atoi(argv[2]);
+    data->args[3]             = atoi(argv[3]);
+    data->args[4]             = atoi(argv[4]);
+
+    DeviceLayer::PlatformMgr().ScheduleWork(SwitchWorkerFunction, reinterpret_cast<intptr_t>(data));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR MoveToHueAndSaturationCommandHandler(int argc, char ** argv)
+{
+    if (argc != 5)
+    {
+        return ColorControlHelpHandler(argc, argv);
+    }
+
+    BindingCommandData * data = Platform::New<BindingCommandData>();
+    data->commandId           = Clusters::ColorControl::Commands::MoveToHueAndSaturation::Id;
+    data->clusterId           = Clusters::ColorControl::Id;
+    data->args[0]             = atoi(argv[0]);
+    data->args[1]             = atoi(argv[1]);
+    data->args[2]             = atoi(argv[2]);
+    data->args[3]             = atoi(argv[3]);
+    data->args[4]             = atoi(argv[4]);
+
+    DeviceLayer::PlatformMgr().ScheduleWork(SwitchWorkerFunction, reinterpret_cast<intptr_t>(data));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR MoveToColorCommandHandler(int argc, char ** argv)
+{
+    if (argc != 5)
+    {
+        return ColorControlHelpHandler(argc, argv);
+    }
+
+    BindingCommandData * data = Platform::New<BindingCommandData>();
+    data->commandId           = Clusters::ColorControl::Commands::MoveToColor::Id;
+    data->clusterId           = Clusters::ColorControl::Id;
+    data->args[0]             = atoi(argv[0]);
+    data->args[1]             = atoi(argv[1]);
+    data->args[2]             = atoi(argv[2]);
+    data->args[3]             = atoi(argv[3]);
+    data->args[4]             = atoi(argv[4]);
+
+    DeviceLayer::PlatformMgr().ScheduleWork(SwitchWorkerFunction, reinterpret_cast<intptr_t>(data));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR MoveColorCommandHandler(int argc, char ** argv)
+{
+    if (argc != 4)
+    {
+        return ColorControlHelpHandler(argc, argv);
+    }
+
+    BindingCommandData * data = Platform::New<BindingCommandData>();
+    data->commandId           = Clusters::ColorControl::Commands::MoveColor::Id;
+    data->clusterId           = Clusters::ColorControl::Id;
+    data->args[0]             = atoi(argv[0]);
+    data->args[1]             = atoi(argv[1]);
+    data->args[2]             = atoi(argv[2]);
+    data->args[3]             = atoi(argv[3]);
+
+    DeviceLayer::PlatformMgr().ScheduleWork(SwitchWorkerFunction, reinterpret_cast<intptr_t>(data));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR StepColorCommandHandler(int argc, char ** argv)
+{
+    if (argc != 5)
+    {
+        return ColorControlHelpHandler(argc, argv);
+    }
+
+    BindingCommandData * data = Platform::New<BindingCommandData>();
+    data->commandId           = Clusters::ColorControl::Commands::StepColor::Id;
+    data->clusterId           = Clusters::ColorControl::Id;
+    data->args[0]             = atoi(argv[0]);
+    data->args[1]             = atoi(argv[1]);
+    data->args[2]             = atoi(argv[2]);
+    data->args[3]             = atoi(argv[3]);
+    data->args[4]             = atoi(argv[4]);
+
+    DeviceLayer::PlatformMgr().ScheduleWork(SwitchWorkerFunction, reinterpret_cast<intptr_t>(data));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR MoveToColorTemperatureCommandHandler(int argc, char ** argv)
+{
+    if (argc != 4)
+    {
+        return ColorControlHelpHandler(argc, argv);
+    }
+
+    BindingCommandData * data = Platform::New<BindingCommandData>();
+    data->commandId           = Clusters::ColorControl::Commands::MoveToColorTemperature::Id;
+    data->clusterId           = Clusters::ColorControl::Id;
+    data->args[0]             = atoi(argv[0]);
+    data->args[1]             = atoi(argv[1]);
+    data->args[2]             = atoi(argv[2]);
+    data->args[3]             = atoi(argv[3]);
+
+    DeviceLayer::PlatformMgr().ScheduleWork(SwitchWorkerFunction, reinterpret_cast<intptr_t>(data));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR EnhancedMoveToHueCommandHandler(int argc, char ** argv)
+{
+    if (argc != 5)
+    {
+        return ColorControlHelpHandler(argc, argv);
+    }
+
+    BindingCommandData * data = Platform::New<BindingCommandData>();
+    data->commandId           = Clusters::ColorControl::Commands::EnhancedMoveToHue::Id;
+    data->clusterId           = Clusters::ColorControl::Id;
+    data->args[0]             = atoi(argv[0]);
+    data->args[1]             = atoi(argv[1]);
+    data->args[2]             = atoi(argv[2]);
+    data->args[3]             = atoi(argv[3]);
+    data->args[4]             = atoi(argv[4]);
+
+    DeviceLayer::PlatformMgr().ScheduleWork(SwitchWorkerFunction, reinterpret_cast<intptr_t>(data));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR EnhancedMoveHueCommandHandler(int argc, char ** argv)
+{
+    if (argc != 4)
+    {
+        return ColorControlHelpHandler(argc, argv);
+    }
+
+    BindingCommandData * data = Platform::New<BindingCommandData>();
+    data->commandId           = Clusters::ColorControl::Commands::EnhancedMoveHue::Id;
+    data->clusterId           = Clusters::ColorControl::Id;
+    data->args[0]             = atoi(argv[0]);
+    data->args[1]             = atoi(argv[1]);
+    data->args[2]             = atoi(argv[2]);
+    data->args[3]             = atoi(argv[3]);
+
+    DeviceLayer::PlatformMgr().ScheduleWork(SwitchWorkerFunction, reinterpret_cast<intptr_t>(data));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR EnhancedStepHueCommandHandler(int argc, char ** argv)
+{
+    if (argc != 5)
+    {
+        return ColorControlHelpHandler(argc, argv);
+    }
+
+    BindingCommandData * data = Platform::New<BindingCommandData>();
+    data->commandId           = Clusters::ColorControl::Commands::EnhancedStepHue::Id;
+    data->clusterId           = Clusters::ColorControl::Id;
+    data->args[0]             = atoi(argv[0]);
+    data->args[1]             = atoi(argv[1]);
+    data->args[2]             = atoi(argv[2]);
+    data->args[3]             = atoi(argv[3]);
+    data->args[4]             = atoi(argv[4]);
+
+    DeviceLayer::PlatformMgr().ScheduleWork(SwitchWorkerFunction, reinterpret_cast<intptr_t>(data));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR EnhancedMoveToHueAndSaturationCommandHandler(int argc, char ** argv)
+{
+    if (argc != 5)
+    {
+        return ColorControlHelpHandler(argc, argv);
+    }
+
+    BindingCommandData * data = Platform::New<BindingCommandData>();
+    data->commandId           = Clusters::ColorControl::Commands::EnhancedMoveToHueAndSaturation::Id;
+    data->clusterId           = Clusters::ColorControl::Id;
+    data->args[0]             = atoi(argv[0]);
+    data->args[1]             = atoi(argv[1]);
+    data->args[2]             = atoi(argv[2]);
+    data->args[3]             = atoi(argv[3]);
+    data->args[4]             = atoi(argv[4]);
+
+    DeviceLayer::PlatformMgr().ScheduleWork(SwitchWorkerFunction, reinterpret_cast<intptr_t>(data));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR ColorLoopSetCommandHandler(int argc, char ** argv)
+{
+    if (argc != 7)
+    {
+        return ColorControlHelpHandler(argc, argv);
+    }
+
+    BindingCommandData * data = Platform::New<BindingCommandData>();
+    data->commandId           = Clusters::ColorControl::Commands::ColorLoopSet::Id;
+    data->clusterId           = Clusters::ColorControl::Id;
+    data->args[0]             = atoi(argv[0]);
+    data->args[1]             = atoi(argv[1]);
+    data->args[2]             = atoi(argv[2]);
+    data->args[3]             = atoi(argv[3]);
+    data->args[4]             = atoi(argv[4]);
+    data->args[5]             = atoi(argv[5]);
+    data->args[6]             = atoi(argv[6]);
+
+    DeviceLayer::PlatformMgr().ScheduleWork(SwitchWorkerFunction, reinterpret_cast<intptr_t>(data));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR StopMoveStepCommandHandler(int argc, char ** argv)
+{
+    if (argc != 2)
+    {
+        return ColorControlHelpHandler(argc, argv);
+    }
+
+    BindingCommandData * data = Platform::New<BindingCommandData>();
+    data->commandId           = Clusters::ColorControl::Commands::StopMoveStep::Id;
+    data->clusterId           = Clusters::ColorControl::Id;
+    data->args[0]             = atoi(argv[0]);
+    data->args[1]             = atoi(argv[1]);
+
+    DeviceLayer::PlatformMgr().ScheduleWork(SwitchWorkerFunction, reinterpret_cast<intptr_t>(data));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR MoveColorTemperatureCommandHandler(int argc, char ** argv)
+{
+    if (argc != 6)
+    {
+        return ColorControlHelpHandler(argc, argv);
+    }
+
+    BindingCommandData * data = Platform::New<BindingCommandData>();
+    data->commandId           = Clusters::ColorControl::Commands::MoveColorTemperature::Id;
+    data->clusterId           = Clusters::ColorControl::Id;
+    data->args[0]             = atoi(argv[0]);
+    data->args[1]             = atoi(argv[1]);
+    data->args[2]             = atoi(argv[2]);
+    data->args[3]             = atoi(argv[3]);
+    data->args[4]             = atoi(argv[4]);
+    data->args[5]             = atoi(argv[5]);
+
+    DeviceLayer::PlatformMgr().ScheduleWork(SwitchWorkerFunction, reinterpret_cast<intptr_t>(data));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR StepColorTemperatureCommandHandler(int argc, char ** argv)
+{
+    if (argc != 7)
+    {
+        return ColorControlHelpHandler(argc, argv);
+    }
+
+    BindingCommandData * data = Platform::New<BindingCommandData>();
+    data->commandId           = Clusters::ColorControl::Commands::StepColorTemperature::Id;
+    data->clusterId           = Clusters::ColorControl::Id;
+    data->args[0]             = atoi(argv[0]);
+    data->args[1]             = atoi(argv[1]);
+    data->args[2]             = atoi(argv[2]);
+    data->args[3]             = atoi(argv[3]);
+    data->args[4]             = atoi(argv[4]);
+    data->args[5]             = atoi(argv[5]);
+    data->args[6]             = atoi(argv[6]);
+
+    DeviceLayer::PlatformMgr().ScheduleWork(SwitchWorkerFunction, reinterpret_cast<intptr_t>(data));
+    return CHIP_NO_ERROR;
+}
+
+/********************************************************
+ * ColorControl Read switch shell functions
+ *********************************************************/
+
+CHIP_ERROR ColorControlReadHelpHandler(int argc, char ** argv)
+{
+    sShellSwitchColorControlReadSubCommands.ForEachCommand(Shell::PrintCommandHelp, nullptr);
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR ColorControlRead(int argc, char ** argv)
+{
+    if (argc == 0)
+    {
+        return ColorControlReadHelpHandler(argc, argv);
+    }
+
+    return sShellSwitchColorControlReadSubCommands.ExecCommand(argc, argv);
+}
+
+CHIP_ERROR ColorControlReadAttributeList(int argc, char ** argv)
+{
+    BindingCommandData * data = Platform::New<BindingCommandData>();
+    data->attributeId         = Clusters::ColorControl::Attributes::AttributeList::Id;
+    data->clusterId           = Clusters::ColorControl::Id;
+    data->isReadAttribute     = true;
+
+    DeviceLayer::PlatformMgr().ScheduleWork(SwitchWorkerFunction, reinterpret_cast<intptr_t>(data));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR ColorControlReadCurrentHue(int argc, char ** argv)
+{
+    BindingCommandData * data = Platform::New<BindingCommandData>();
+    data->attributeId         = Clusters::ColorControl::Attributes::CurrentHue::Id;
+    data->clusterId           = Clusters::ColorControl::Id;
+    data->isReadAttribute     = true;
+
+    DeviceLayer::PlatformMgr().ScheduleWork(SwitchWorkerFunction, reinterpret_cast<intptr_t>(data));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR ColorControlReadCurrentSaturation(int argc, char ** argv)
+{
+    BindingCommandData * data = Platform::New<BindingCommandData>();
+    data->attributeId         = Clusters::ColorControl::Attributes::CurrentSaturation::Id;
+    data->clusterId           = Clusters::ColorControl::Id;
+    data->isReadAttribute     = true;
+
+    DeviceLayer::PlatformMgr().ScheduleWork(SwitchWorkerFunction, reinterpret_cast<intptr_t>(data));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR ColorControlReadRemainingTime(int argc, char ** argv)
+{
+    BindingCommandData * data = Platform::New<BindingCommandData>();
+    data->attributeId         = Clusters::ColorControl::Attributes::RemainingTime::Id;
+    data->clusterId           = Clusters::ColorControl::Id;
+    data->isReadAttribute     = true;
+
+    DeviceLayer::PlatformMgr().ScheduleWork(SwitchWorkerFunction, reinterpret_cast<intptr_t>(data));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR ColorControlReadCurrentX(int argc, char ** argv)
+{
+    BindingCommandData * data = Platform::New<BindingCommandData>();
+    data->attributeId         = Clusters::ColorControl::Attributes::CurrentX::Id;
+    data->clusterId           = Clusters::ColorControl::Id;
+    data->isReadAttribute     = true;
+
+    DeviceLayer::PlatformMgr().ScheduleWork(SwitchWorkerFunction, reinterpret_cast<intptr_t>(data));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR ColorControlReadCurrentY(int argc, char ** argv)
+{
+    BindingCommandData * data = Platform::New<BindingCommandData>();
+    data->attributeId         = Clusters::ColorControl::Attributes::CurrentY::Id;
+    data->clusterId           = Clusters::ColorControl::Id;
+    data->isReadAttribute     = true;
+
+    DeviceLayer::PlatformMgr().ScheduleWork(SwitchWorkerFunction, reinterpret_cast<intptr_t>(data));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR ColorControlReadDriftCompensation(int argc, char ** argv)
+{
+    BindingCommandData * data = Platform::New<BindingCommandData>();
+    data->attributeId         = Clusters::ColorControl::Attributes::DriftCompensation::Id;
+    data->clusterId           = Clusters::ColorControl::Id;
+    data->isReadAttribute     = true;
+
+    DeviceLayer::PlatformMgr().ScheduleWork(SwitchWorkerFunction, reinterpret_cast<intptr_t>(data));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR ColorControlReadCompensationText(int argc, char ** argv)
+{
+    BindingCommandData * data = Platform::New<BindingCommandData>();
+    data->attributeId         = Clusters::ColorControl::Attributes::CompensationText::Id;
+    data->clusterId           = Clusters::ColorControl::Id;
+    data->isReadAttribute     = true;
+
+    DeviceLayer::PlatformMgr().ScheduleWork(SwitchWorkerFunction, reinterpret_cast<intptr_t>(data));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR ColorControlReadColorTemperature(int argc, char ** argv)
+{
+    BindingCommandData * data = Platform::New<BindingCommandData>();
+    data->attributeId         = Clusters::ColorControl::Attributes::ColorTemperatureMireds::Id;
+    data->clusterId           = Clusters::ColorControl::Id;
+    data->isReadAttribute     = true;
+
+    DeviceLayer::PlatformMgr().ScheduleWork(SwitchWorkerFunction, reinterpret_cast<intptr_t>(data));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR ColorControlReadColorMode(int argc, char ** argv)
+{
+    BindingCommandData * data = Platform::New<BindingCommandData>();
+    data->attributeId         = Clusters::ColorControl::Attributes::ColorMode::Id;
+    data->clusterId           = Clusters::ColorControl::Id;
+    data->isReadAttribute     = true;
+
+    DeviceLayer::PlatformMgr().ScheduleWork(SwitchWorkerFunction, reinterpret_cast<intptr_t>(data));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR ColorControlReadOptions(int argc, char ** argv)
+{
+    BindingCommandData * data = Platform::New<BindingCommandData>();
+    data->attributeId         = Clusters::ColorControl::Attributes::Options::Id;
+    data->clusterId           = Clusters::ColorControl::Id;
+    data->isReadAttribute     = true;
+
+    DeviceLayer::PlatformMgr().ScheduleWork(SwitchWorkerFunction, reinterpret_cast<intptr_t>(data));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR ColorControlReadNumberOfPrimaries(int argc, char ** argv)
+{
+    BindingCommandData * data = Platform::New<BindingCommandData>();
+    data->attributeId         = Clusters::ColorControl::Attributes::NumberOfPrimaries::Id;
+    data->clusterId           = Clusters::ColorControl::Id;
+    data->isReadAttribute     = true;
+
+    DeviceLayer::PlatformMgr().ScheduleWork(SwitchWorkerFunction, reinterpret_cast<intptr_t>(data));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR ColorControlReadPrimary1X(int argc, char ** argv)
+{
+    BindingCommandData * data = Platform::New<BindingCommandData>();
+    data->attributeId         = Clusters::ColorControl::Attributes::Primary1X::Id;
+    data->clusterId           = Clusters::ColorControl::Id;
+    data->isReadAttribute     = true;
+
+    DeviceLayer::PlatformMgr().ScheduleWork(SwitchWorkerFunction, reinterpret_cast<intptr_t>(data));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR ColorControlReadPrimary1Y(int argc, char ** argv)
+{
+    BindingCommandData * data = Platform::New<BindingCommandData>();
+    data->attributeId         = Clusters::ColorControl::Attributes::Primary1Y::Id;
+    data->clusterId           = Clusters::ColorControl::Id;
+    data->isReadAttribute     = true;
+
+    DeviceLayer::PlatformMgr().ScheduleWork(SwitchWorkerFunction, reinterpret_cast<intptr_t>(data));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR ColorControlReadPrimary1Intensity(int argc, char ** argv)
+{
+    BindingCommandData * data = Platform::New<BindingCommandData>();
+    data->attributeId         = Clusters::ColorControl::Attributes::Primary1Intensity::Id;
+    data->clusterId           = Clusters::ColorControl::Id;
+    data->isReadAttribute     = true;
+
+    DeviceLayer::PlatformMgr().ScheduleWork(SwitchWorkerFunction, reinterpret_cast<intptr_t>(data));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR ColorControlReadPrimary2X(int argc, char ** argv)
+{
+    BindingCommandData * data = Platform::New<BindingCommandData>();
+    data->attributeId         = Clusters::ColorControl::Attributes::Primary2X::Id;
+    data->clusterId           = Clusters::ColorControl::Id;
+    data->isReadAttribute     = true;
+
+    DeviceLayer::PlatformMgr().ScheduleWork(SwitchWorkerFunction, reinterpret_cast<intptr_t>(data));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR ColorControlReadPrimary2Y(int argc, char ** argv)
+{
+    BindingCommandData * data = Platform::New<BindingCommandData>();
+    data->attributeId         = Clusters::ColorControl::Attributes::Primary2Y::Id;
+    data->clusterId           = Clusters::ColorControl::Id;
+    data->isReadAttribute     = true;
+
+    DeviceLayer::PlatformMgr().ScheduleWork(SwitchWorkerFunction, reinterpret_cast<intptr_t>(data));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR ColorControlReadPrimary2Intensity(int argc, char ** argv)
+{
+    BindingCommandData * data = Platform::New<BindingCommandData>();
+    data->attributeId         = Clusters::ColorControl::Attributes::Primary2Intensity::Id;
+    data->clusterId           = Clusters::ColorControl::Id;
+    data->isReadAttribute     = true;
+
+    DeviceLayer::PlatformMgr().ScheduleWork(SwitchWorkerFunction, reinterpret_cast<intptr_t>(data));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR ColorControlReadPrimary3X(int argc, char ** argv)
+{
+    BindingCommandData * data = Platform::New<BindingCommandData>();
+    data->attributeId         = Clusters::ColorControl::Attributes::Primary3X::Id;
+    data->clusterId           = Clusters::ColorControl::Id;
+    data->isReadAttribute     = true;
+
+    DeviceLayer::PlatformMgr().ScheduleWork(SwitchWorkerFunction, reinterpret_cast<intptr_t>(data));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR ColorControlReadPrimary3Y(int argc, char ** argv)
+{
+    BindingCommandData * data = Platform::New<BindingCommandData>();
+    data->attributeId         = Clusters::ColorControl::Attributes::Primary3Y::Id;
+    data->clusterId           = Clusters::ColorControl::Id;
+    data->isReadAttribute     = true;
+
+    DeviceLayer::PlatformMgr().ScheduleWork(SwitchWorkerFunction, reinterpret_cast<intptr_t>(data));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR ColorControlReadPrimary3Intensity(int argc, char ** argv)
+{
+    BindingCommandData * data = Platform::New<BindingCommandData>();
+    data->attributeId         = Clusters::ColorControl::Attributes::Primary3Intensity::Id;
+    data->clusterId           = Clusters::ColorControl::Id;
+    data->isReadAttribute     = true;
+
+    DeviceLayer::PlatformMgr().ScheduleWork(SwitchWorkerFunction, reinterpret_cast<intptr_t>(data));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR ColorControlReadPrimary4X(int argc, char ** argv)
+{
+    BindingCommandData * data = Platform::New<BindingCommandData>();
+    data->attributeId         = Clusters::ColorControl::Attributes::Primary4X::Id;
+    data->clusterId           = Clusters::ColorControl::Id;
+    data->isReadAttribute     = true;
+
+    DeviceLayer::PlatformMgr().ScheduleWork(SwitchWorkerFunction, reinterpret_cast<intptr_t>(data));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR ColorControlReadPrimary4Y(int argc, char ** argv)
+{
+    BindingCommandData * data = Platform::New<BindingCommandData>();
+    data->attributeId         = Clusters::ColorControl::Attributes::Primary4Y::Id;
+    data->clusterId           = Clusters::ColorControl::Id;
+    data->isReadAttribute     = true;
+
+    DeviceLayer::PlatformMgr().ScheduleWork(SwitchWorkerFunction, reinterpret_cast<intptr_t>(data));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR ColorControlReadPrimary4Intensity(int argc, char ** argv)
+{
+    BindingCommandData * data = Platform::New<BindingCommandData>();
+    data->attributeId         = Clusters::ColorControl::Attributes::Primary4Intensity::Id;
+    data->clusterId           = Clusters::ColorControl::Id;
+    data->isReadAttribute     = true;
+
+    DeviceLayer::PlatformMgr().ScheduleWork(SwitchWorkerFunction, reinterpret_cast<intptr_t>(data));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR ColorControlReadPrimary5X(int argc, char ** argv)
+{
+    BindingCommandData * data = Platform::New<BindingCommandData>();
+    data->attributeId         = Clusters::ColorControl::Attributes::Primary5X::Id;
+    data->clusterId           = Clusters::ColorControl::Id;
+    data->isReadAttribute     = true;
+
+    DeviceLayer::PlatformMgr().ScheduleWork(SwitchWorkerFunction, reinterpret_cast<intptr_t>(data));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR ColorControlReadPrimary5Y(int argc, char ** argv)
+{
+    BindingCommandData * data = Platform::New<BindingCommandData>();
+    data->attributeId         = Clusters::ColorControl::Attributes::Primary5Y::Id;
+    data->clusterId           = Clusters::ColorControl::Id;
+    data->isReadAttribute     = true;
+
+    DeviceLayer::PlatformMgr().ScheduleWork(SwitchWorkerFunction, reinterpret_cast<intptr_t>(data));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR ColorControlReadPrimary5Intensity(int argc, char ** argv)
+{
+    BindingCommandData * data = Platform::New<BindingCommandData>();
+    data->attributeId         = Clusters::ColorControl::Attributes::Primary5Intensity::Id;
+    data->clusterId           = Clusters::ColorControl::Id;
+    data->isReadAttribute     = true;
+
+    DeviceLayer::PlatformMgr().ScheduleWork(SwitchWorkerFunction, reinterpret_cast<intptr_t>(data));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR ColorControlReadPrimary6X(int argc, char ** argv)
+{
+    BindingCommandData * data = Platform::New<BindingCommandData>();
+    data->attributeId         = Clusters::ColorControl::Attributes::Primary6X::Id;
+    data->clusterId           = Clusters::ColorControl::Id;
+    data->isReadAttribute     = true;
+
+    DeviceLayer::PlatformMgr().ScheduleWork(SwitchWorkerFunction, reinterpret_cast<intptr_t>(data));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR ColorControlReadPrimary6Y(int argc, char ** argv)
+{
+    BindingCommandData * data = Platform::New<BindingCommandData>();
+    data->attributeId         = Clusters::ColorControl::Attributes::Primary6Y::Id;
+    data->clusterId           = Clusters::ColorControl::Id;
+    data->isReadAttribute     = true;
+
+    DeviceLayer::PlatformMgr().ScheduleWork(SwitchWorkerFunction, reinterpret_cast<intptr_t>(data));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR ColorControlReadPrimary6Intensity(int argc, char ** argv)
+{
+    BindingCommandData * data = Platform::New<BindingCommandData>();
+    data->attributeId         = Clusters::ColorControl::Attributes::Primary6Intensity::Id;
+    data->clusterId           = Clusters::ColorControl::Id;
+    data->isReadAttribute     = true;
+
+    DeviceLayer::PlatformMgr().ScheduleWork(SwitchWorkerFunction, reinterpret_cast<intptr_t>(data));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR ColorControlReadWhitePointX(int argc, char ** argv)
+{
+    BindingCommandData * data = Platform::New<BindingCommandData>();
+    data->attributeId         = Clusters::ColorControl::Attributes::WhitePointX::Id;
+    data->clusterId           = Clusters::ColorControl::Id;
+    data->isReadAttribute     = true;
+
+    DeviceLayer::PlatformMgr().ScheduleWork(SwitchWorkerFunction, reinterpret_cast<intptr_t>(data));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR ColorControlReadWhitePointY(int argc, char ** argv)
+{
+    BindingCommandData * data = Platform::New<BindingCommandData>();
+    data->attributeId         = Clusters::ColorControl::Attributes::WhitePointY::Id;
+    data->clusterId           = Clusters::ColorControl::Id;
+    data->isReadAttribute     = true;
+
+    DeviceLayer::PlatformMgr().ScheduleWork(SwitchWorkerFunction, reinterpret_cast<intptr_t>(data));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR ColorControlReadColorPointRX(int argc, char ** argv)
+{
+    BindingCommandData * data = Platform::New<BindingCommandData>();
+    data->attributeId         = Clusters::ColorControl::Attributes::ColorPointRX::Id;
+    data->clusterId           = Clusters::ColorControl::Id;
+    data->isReadAttribute     = true;
+
+    DeviceLayer::PlatformMgr().ScheduleWork(SwitchWorkerFunction, reinterpret_cast<intptr_t>(data));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR ColorControlReadColorPointRY(int argc, char ** argv)
+{
+    BindingCommandData * data = Platform::New<BindingCommandData>();
+    data->attributeId         = Clusters::ColorControl::Attributes::ColorPointRY::Id;
+    data->clusterId           = Clusters::ColorControl::Id;
+    data->isReadAttribute     = true;
+
+    DeviceLayer::PlatformMgr().ScheduleWork(SwitchWorkerFunction, reinterpret_cast<intptr_t>(data));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR ColorControlReadColorPointRIntensity(int argc, char ** argv)
+{
+    BindingCommandData * data = Platform::New<BindingCommandData>();
+    data->attributeId         = Clusters::ColorControl::Attributes::ColorPointRIntensity::Id;
+    data->clusterId           = Clusters::ColorControl::Id;
+    data->isReadAttribute     = true;
+
+    DeviceLayer::PlatformMgr().ScheduleWork(SwitchWorkerFunction, reinterpret_cast<intptr_t>(data));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR ColorControlReadColorPointGX(int argc, char ** argv)
+{
+    BindingCommandData * data = Platform::New<BindingCommandData>();
+    data->attributeId         = Clusters::ColorControl::Attributes::ColorPointGX::Id;
+    data->clusterId           = Clusters::ColorControl::Id;
+    data->isReadAttribute     = true;
+
+    DeviceLayer::PlatformMgr().ScheduleWork(SwitchWorkerFunction, reinterpret_cast<intptr_t>(data));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR ColorControlReadColorPointGY(int argc, char ** argv)
+{
+    BindingCommandData * data = Platform::New<BindingCommandData>();
+    data->attributeId         = Clusters::ColorControl::Attributes::ColorPointGY::Id;
+    data->clusterId           = Clusters::ColorControl::Id;
+    data->isReadAttribute     = true;
+
+    DeviceLayer::PlatformMgr().ScheduleWork(SwitchWorkerFunction, reinterpret_cast<intptr_t>(data));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR ColorControlReadColorPointGIntensity(int argc, char ** argv)
+{
+    BindingCommandData * data = Platform::New<BindingCommandData>();
+    data->attributeId         = Clusters::ColorControl::Attributes::ColorPointGIntensity::Id;
+    data->clusterId           = Clusters::ColorControl::Id;
+    data->isReadAttribute     = true;
+
+    DeviceLayer::PlatformMgr().ScheduleWork(SwitchWorkerFunction, reinterpret_cast<intptr_t>(data));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR ColorControlReadColorPointBX(int argc, char ** argv)
+{
+    BindingCommandData * data = Platform::New<BindingCommandData>();
+    data->attributeId         = Clusters::ColorControl::Attributes::ColorPointBX::Id;
+    data->clusterId           = Clusters::ColorControl::Id;
+    data->isReadAttribute     = true;
+
+    DeviceLayer::PlatformMgr().ScheduleWork(SwitchWorkerFunction, reinterpret_cast<intptr_t>(data));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR ColorControlReadColorPointBY(int argc, char ** argv)
+{
+    BindingCommandData * data = Platform::New<BindingCommandData>();
+    data->attributeId         = Clusters::ColorControl::Attributes::ColorPointBY::Id;
+    data->clusterId           = Clusters::ColorControl::Id;
+    data->isReadAttribute     = true;
+
+    DeviceLayer::PlatformMgr().ScheduleWork(SwitchWorkerFunction, reinterpret_cast<intptr_t>(data));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR ColorControlReadColorPointBIntensity(int argc, char ** argv)
+{
+    BindingCommandData * data = Platform::New<BindingCommandData>();
+    data->attributeId         = Clusters::ColorControl::Attributes::ColorPointBIntensity::Id;
+    data->clusterId           = Clusters::ColorControl::Id;
+    data->isReadAttribute     = true;
+
+    DeviceLayer::PlatformMgr().ScheduleWork(SwitchWorkerFunction, reinterpret_cast<intptr_t>(data));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR ColorControlReadEnhancedCurrentHue(int argc, char ** argv)
+{
+    BindingCommandData * data = Platform::New<BindingCommandData>();
+    data->attributeId         = Clusters::ColorControl::Attributes::EnhancedCurrentHue::Id;
+    data->clusterId           = Clusters::ColorControl::Id;
+    data->isReadAttribute     = true;
+
+    DeviceLayer::PlatformMgr().ScheduleWork(SwitchWorkerFunction, reinterpret_cast<intptr_t>(data));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR ColorControlReadEnhancedColorMode(int argc, char ** argv)
+{
+    BindingCommandData * data = Platform::New<BindingCommandData>();
+    data->attributeId         = Clusters::ColorControl::Attributes::EnhancedColorMode::Id;
+    data->clusterId           = Clusters::ColorControl::Id;
+    data->isReadAttribute     = true;
+
+    DeviceLayer::PlatformMgr().ScheduleWork(SwitchWorkerFunction, reinterpret_cast<intptr_t>(data));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR ColorControlReadColorLoopActive(int argc, char ** argv)
+{
+    BindingCommandData * data = Platform::New<BindingCommandData>();
+    data->attributeId         = Clusters::ColorControl::Attributes::ColorLoopActive::Id;
+    data->clusterId           = Clusters::ColorControl::Id;
+    data->isReadAttribute     = true;
+
+    DeviceLayer::PlatformMgr().ScheduleWork(SwitchWorkerFunction, reinterpret_cast<intptr_t>(data));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR ColorControlReadColorLoopDirection(int argc, char ** argv)
+{
+    BindingCommandData * data = Platform::New<BindingCommandData>();
+    data->attributeId         = Clusters::ColorControl::Attributes::ColorLoopDirection::Id;
+    data->clusterId           = Clusters::ColorControl::Id;
+    data->isReadAttribute     = true;
+
+    DeviceLayer::PlatformMgr().ScheduleWork(SwitchWorkerFunction, reinterpret_cast<intptr_t>(data));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR ColorControlReadColorLoopTime(int argc, char ** argv)
+{
+    BindingCommandData * data = Platform::New<BindingCommandData>();
+    data->attributeId         = Clusters::ColorControl::Attributes::ColorLoopTime::Id;
+    data->clusterId           = Clusters::ColorControl::Id;
+    data->isReadAttribute     = true;
+
+    DeviceLayer::PlatformMgr().ScheduleWork(SwitchWorkerFunction, reinterpret_cast<intptr_t>(data));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR ColorControlReadColorLoopStartEnhancedHue(int argc, char ** argv)
+{
+    BindingCommandData * data = Platform::New<BindingCommandData>();
+    data->attributeId         = Clusters::ColorControl::Attributes::ColorLoopStartEnhancedHue::Id;
+    data->clusterId           = Clusters::ColorControl::Id;
+    data->isReadAttribute     = true;
+
+    DeviceLayer::PlatformMgr().ScheduleWork(SwitchWorkerFunction, reinterpret_cast<intptr_t>(data));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR ColorControlReadColorLoopStoredEnhancedHue(int argc, char ** argv)
+{
+    BindingCommandData * data = Platform::New<BindingCommandData>();
+    data->attributeId         = Clusters::ColorControl::Attributes::ColorLoopStoredEnhancedHue::Id;
+    data->clusterId           = Clusters::ColorControl::Id;
+    data->isReadAttribute     = true;
+
+    DeviceLayer::PlatformMgr().ScheduleWork(SwitchWorkerFunction, reinterpret_cast<intptr_t>(data));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR ColorControlReadColorCapabilities(int argc, char ** argv)
+{
+    BindingCommandData * data = Platform::New<BindingCommandData>();
+    data->attributeId         = Clusters::ColorControl::Attributes::ColorCapabilities::Id;
+    data->clusterId           = Clusters::ColorControl::Id;
+    data->isReadAttribute     = true;
+
+    DeviceLayer::PlatformMgr().ScheduleWork(SwitchWorkerFunction, reinterpret_cast<intptr_t>(data));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR ColorControlReadColorTempPhysicalMinMireds(int argc, char ** argv)
+{
+    BindingCommandData * data = Platform::New<BindingCommandData>();
+    data->attributeId         = Clusters::ColorControl::Attributes::ColorTempPhysicalMinMireds::Id;
+    data->clusterId           = Clusters::ColorControl::Id;
+    data->isReadAttribute     = true;
+
+    DeviceLayer::PlatformMgr().ScheduleWork(SwitchWorkerFunction, reinterpret_cast<intptr_t>(data));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR ColorControlReadColorTempPhysicalMaxMireds(int argc, char ** argv)
+{
+    BindingCommandData * data = Platform::New<BindingCommandData>();
+    data->attributeId         = Clusters::ColorControl::Attributes::ColorTempPhysicalMaxMireds::Id;
+    data->clusterId           = Clusters::ColorControl::Id;
+    data->isReadAttribute     = true;
+
+    DeviceLayer::PlatformMgr().ScheduleWork(SwitchWorkerFunction, reinterpret_cast<intptr_t>(data));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR ColorControlReadCoupleColorTempToLevelMinMireds(int argc, char ** argv)
+{
+    BindingCommandData * data = Platform::New<BindingCommandData>();
+    data->attributeId         = Clusters::ColorControl::Attributes::CoupleColorTempToLevelMinMireds::Id;
+    data->clusterId           = Clusters::ColorControl::Id;
+    data->isReadAttribute     = true;
+
+    DeviceLayer::PlatformMgr().ScheduleWork(SwitchWorkerFunction, reinterpret_cast<intptr_t>(data));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR ColorControlReadStartUpColorTemperatureMireds(int argc, char ** argv)
+{
+    BindingCommandData * data = Platform::New<BindingCommandData>();
+    data->attributeId         = Clusters::ColorControl::Attributes::StartUpColorTemperatureMireds::Id;
+    data->clusterId           = Clusters::ColorControl::Id;
+    data->isReadAttribute     = true;
+
+    DeviceLayer::PlatformMgr().ScheduleWork(SwitchWorkerFunction, reinterpret_cast<intptr_t>(data));
+    return CHIP_NO_ERROR;
+}
+
+/********************************************************
+ * Groups ColorControl switch shell functions
+ *********************************************************/
+
+CHIP_ERROR GroupsColorControlHelpHandler(int argc, char ** argv)
+{
+    sShellSwitchGroupsColorControlSubCommands.ForEachCommand(Shell::PrintCommandHelp, nullptr);
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR GroupsColorControlSwitchCommandHandler(int argc, char ** argv)
+{
+    if (argc == 0)
+    {
+        return GroupsColorControlHelpHandler(argc, argv);
+    }
+
+    return sShellSwitchGroupsColorControlSubCommands.ExecCommand(argc, argv);
+}
+
+CHIP_ERROR GroupsMoveToHueCommandHandler(int argc, char ** argv)
+{
+    if (argc != 5)
+    {
+        return GroupsColorControlHelpHandler(argc, argv);
+    }
+
+    BindingCommandData * data = Platform::New<BindingCommandData>();
+    data->commandId           = Clusters::ColorControl::Commands::MoveToHue::Id;
+    data->clusterId           = Clusters::ColorControl::Id;
+    data->args[0]             = atoi(argv[0]);
+    data->args[1]             = atoi(argv[1]);
+    data->args[2]             = atoi(argv[2]);
+    data->args[3]             = atoi(argv[3]);
+    data->args[4]             = atoi(argv[4]);
+    data->isGroup             = true;
+
+    DeviceLayer::PlatformMgr().ScheduleWork(SwitchWorkerFunction, reinterpret_cast<intptr_t>(data));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR GroupsMoveHueCommandHandler(int argc, char ** argv)
+{
+    if (argc != 4)
+    {
+        return GroupsColorControlHelpHandler(argc, argv);
+    }
+
+    BindingCommandData * data = Platform::New<BindingCommandData>();
+    data->commandId           = Clusters::ColorControl::Commands::MoveHue::Id;
+    data->clusterId           = Clusters::ColorControl::Id;
+    data->args[0]             = atoi(argv[0]);
+    data->args[1]             = atoi(argv[1]);
+    data->args[2]             = atoi(argv[2]);
+    data->args[3]             = atoi(argv[3]);
+    data->isGroup             = true;
+
+    DeviceLayer::PlatformMgr().ScheduleWork(SwitchWorkerFunction, reinterpret_cast<intptr_t>(data));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR GroupsStepHueCommandHandler(int argc, char ** argv)
+{
+    if (argc != 5)
+    {
+        return GroupsColorControlHelpHandler(argc, argv);
+    }
+
+    BindingCommandData * data = Platform::New<BindingCommandData>();
+    data->commandId           = Clusters::ColorControl::Commands::StepHue::Id;
+    data->clusterId           = Clusters::ColorControl::Id;
+    data->args[0]             = atoi(argv[0]);
+    data->args[1]             = atoi(argv[1]);
+    data->args[2]             = atoi(argv[2]);
+    data->args[3]             = atoi(argv[3]);
+    data->args[4]             = atoi(argv[4]);
+    data->isGroup             = true;
+
+    DeviceLayer::PlatformMgr().ScheduleWork(SwitchWorkerFunction, reinterpret_cast<intptr_t>(data));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR GroupsMoveToSaturationCommandHandler(int argc, char ** argv)
+{
+    if (argc != 4)
+    {
+        return GroupsColorControlHelpHandler(argc, argv);
+    }
+
+    BindingCommandData * data = Platform::New<BindingCommandData>();
+    data->commandId           = Clusters::ColorControl::Commands::MoveToSaturation::Id;
+    data->clusterId           = Clusters::ColorControl::Id;
+    data->args[0]             = atoi(argv[0]);
+    data->args[1]             = atoi(argv[1]);
+    data->args[2]             = atoi(argv[2]);
+    data->args[3]             = atoi(argv[3]);
+    data->isGroup             = true;
+
+    DeviceLayer::PlatformMgr().ScheduleWork(SwitchWorkerFunction, reinterpret_cast<intptr_t>(data));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR GroupsMoveSaturationCommandHandler(int argc, char ** argv)
+{
+    if (argc != 4)
+    {
+        return GroupsColorControlHelpHandler(argc, argv);
+    }
+
+    BindingCommandData * data = Platform::New<BindingCommandData>();
+    data->commandId           = Clusters::ColorControl::Commands::MoveSaturation::Id;
+    data->clusterId           = Clusters::ColorControl::Id;
+    data->args[0]             = atoi(argv[0]);
+    data->args[1]             = atoi(argv[1]);
+    data->args[2]             = atoi(argv[2]);
+    data->args[3]             = atoi(argv[3]);
+    data->isGroup             = true;
+
+    DeviceLayer::PlatformMgr().ScheduleWork(SwitchWorkerFunction, reinterpret_cast<intptr_t>(data));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR GroupsStepSaturationCommandHandler(int argc, char ** argv)
+{
+    if (argc != 5)
+    {
+        return GroupsColorControlHelpHandler(argc, argv);
+    }
+
+    BindingCommandData * data = Platform::New<BindingCommandData>();
+    data->commandId           = Clusters::ColorControl::Commands::StepSaturation::Id;
+    data->clusterId           = Clusters::ColorControl::Id;
+    data->args[0]             = atoi(argv[0]);
+    data->args[1]             = atoi(argv[1]);
+    data->args[2]             = atoi(argv[2]);
+    data->args[3]             = atoi(argv[3]);
+    data->args[4]             = atoi(argv[4]);
+    data->isGroup             = true;
+
+    DeviceLayer::PlatformMgr().ScheduleWork(SwitchWorkerFunction, reinterpret_cast<intptr_t>(data));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR GroupsMoveToHueAndSaturationCommandHandler(int argc, char ** argv)
+{
+    if (argc != 5)
+    {
+        return GroupsColorControlHelpHandler(argc, argv);
+    }
+
+    BindingCommandData * data = Platform::New<BindingCommandData>();
+    data->commandId           = Clusters::ColorControl::Commands::MoveToHueAndSaturation::Id;
+    data->clusterId           = Clusters::ColorControl::Id;
+    data->args[0]             = atoi(argv[0]);
+    data->args[1]             = atoi(argv[1]);
+    data->args[2]             = atoi(argv[2]);
+    data->args[3]             = atoi(argv[3]);
+    data->args[4]             = atoi(argv[4]);
+    data->isGroup             = true;
+
+    DeviceLayer::PlatformMgr().ScheduleWork(SwitchWorkerFunction, reinterpret_cast<intptr_t>(data));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR GroupsMoveToColorCommandHandler(int argc, char ** argv)
+{
+    if (argc != 5)
+    {
+        return GroupsColorControlHelpHandler(argc, argv);
+    }
+
+    BindingCommandData * data = Platform::New<BindingCommandData>();
+    data->commandId           = Clusters::ColorControl::Commands::MoveToColor::Id;
+    data->clusterId           = Clusters::ColorControl::Id;
+    data->args[0]             = atoi(argv[0]);
+    data->args[1]             = atoi(argv[1]);
+    data->args[2]             = atoi(argv[2]);
+    data->args[3]             = atoi(argv[3]);
+    data->args[4]             = atoi(argv[4]);
+    data->isGroup             = true;
+
+    DeviceLayer::PlatformMgr().ScheduleWork(SwitchWorkerFunction, reinterpret_cast<intptr_t>(data));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR GroupsMoveColorCommandHandler(int argc, char ** argv)
+{
+    if (argc != 4)
+    {
+        return GroupsColorControlHelpHandler(argc, argv);
+    }
+
+    BindingCommandData * data = Platform::New<BindingCommandData>();
+    data->commandId           = Clusters::ColorControl::Commands::MoveColor::Id;
+    data->clusterId           = Clusters::ColorControl::Id;
+    data->args[0]             = atoi(argv[0]);
+    data->args[1]             = atoi(argv[1]);
+    data->args[2]             = atoi(argv[2]);
+    data->args[3]             = atoi(argv[3]);
+    data->isGroup             = true;
+
+    DeviceLayer::PlatformMgr().ScheduleWork(SwitchWorkerFunction, reinterpret_cast<intptr_t>(data));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR GroupsStepColorCommandHandler(int argc, char ** argv)
+{
+    if (argc != 5)
+    {
+        return GroupsColorControlHelpHandler(argc, argv);
+    }
+
+    BindingCommandData * data = Platform::New<BindingCommandData>();
+    data->commandId           = Clusters::ColorControl::Commands::MoveColor::Id;
+    data->clusterId           = Clusters::ColorControl::Id;
+    data->args[0]             = atoi(argv[0]);
+    data->args[1]             = atoi(argv[1]);
+    data->args[2]             = atoi(argv[2]);
+    data->args[3]             = atoi(argv[3]);
+    data->args[4]             = atoi(argv[4]);
+    data->isGroup             = true;
+
+    DeviceLayer::PlatformMgr().ScheduleWork(SwitchWorkerFunction, reinterpret_cast<intptr_t>(data));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR GroupsMoveToColorTemperatureCommandHandler(int argc, char ** argv)
+{
+    if (argc != 4)
+    {
+        return GroupsColorControlHelpHandler(argc, argv);
+    }
+
+    BindingCommandData * data = Platform::New<BindingCommandData>();
+    data->commandId           = Clusters::ColorControl::Commands::MoveColor::Id;
+    data->clusterId           = Clusters::ColorControl::Id;
+    data->args[0]             = atoi(argv[0]);
+    data->args[1]             = atoi(argv[1]);
+    data->args[2]             = atoi(argv[2]);
+    data->args[3]             = atoi(argv[3]);
+    data->isGroup             = true;
+
+    DeviceLayer::PlatformMgr().ScheduleWork(SwitchWorkerFunction, reinterpret_cast<intptr_t>(data));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR GroupsEnhancedMoveToHueCommandHandler(int argc, char ** argv)
+{
+    if (argc != 5)
+    {
+        return GroupsColorControlHelpHandler(argc, argv);
+    }
+
+    BindingCommandData * data = Platform::New<BindingCommandData>();
+    data->commandId           = Clusters::ColorControl::Commands::EnhancedMoveToHue::Id;
+    data->clusterId           = Clusters::ColorControl::Id;
+    data->args[0]             = atoi(argv[0]);
+    data->args[1]             = atoi(argv[1]);
+    data->args[2]             = atoi(argv[2]);
+    data->args[3]             = atoi(argv[3]);
+    data->args[4]             = atoi(argv[4]);
+    data->isGroup             = true;
+
+    DeviceLayer::PlatformMgr().ScheduleWork(SwitchWorkerFunction, reinterpret_cast<intptr_t>(data));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR GroupsEnhancedMoveHueCommandHandler(int argc, char ** argv)
+{
+    if (argc != 4)
+    {
+        return GroupsColorControlHelpHandler(argc, argv);
+    }
+
+    BindingCommandData * data = Platform::New<BindingCommandData>();
+    data->commandId           = Clusters::ColorControl::Commands::EnhancedMoveHue::Id;
+    data->clusterId           = Clusters::ColorControl::Id;
+    data->args[0]             = atoi(argv[0]);
+    data->args[1]             = atoi(argv[1]);
+    data->args[2]             = atoi(argv[2]);
+    data->args[3]             = atoi(argv[3]);
+    data->isGroup             = true;
+
+    DeviceLayer::PlatformMgr().ScheduleWork(SwitchWorkerFunction, reinterpret_cast<intptr_t>(data));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR GroupsEnhancedStepHueCommandHandler(int argc, char ** argv)
+{
+    if (argc != 5)
+    {
+        return GroupsColorControlHelpHandler(argc, argv);
+    }
+
+    BindingCommandData * data = Platform::New<BindingCommandData>();
+    data->commandId           = Clusters::ColorControl::Commands::EnhancedStepHue::Id;
+    data->clusterId           = Clusters::ColorControl::Id;
+    data->args[0]             = atoi(argv[0]);
+    data->args[1]             = atoi(argv[1]);
+    data->args[2]             = atoi(argv[2]);
+    data->args[3]             = atoi(argv[3]);
+    data->args[4]             = atoi(argv[4]);
+    data->isGroup             = true;
+
+    DeviceLayer::PlatformMgr().ScheduleWork(SwitchWorkerFunction, reinterpret_cast<intptr_t>(data));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR GroupsEnhancedMoveToHueAndSaturationCommandHandler(int argc, char ** argv)
+{
+    if (argc != 5)
+    {
+        return GroupsColorControlHelpHandler(argc, argv);
+    }
+
+    BindingCommandData * data = Platform::New<BindingCommandData>();
+    data->commandId           = Clusters::ColorControl::Commands::EnhancedMoveToHueAndSaturation::Id;
+    data->clusterId           = Clusters::ColorControl::Id;
+    data->args[0]             = atoi(argv[0]);
+    data->args[1]             = atoi(argv[1]);
+    data->args[2]             = atoi(argv[2]);
+    data->args[3]             = atoi(argv[3]);
+    data->args[4]             = atoi(argv[4]);
+    data->isGroup             = true;
+
+    DeviceLayer::PlatformMgr().ScheduleWork(SwitchWorkerFunction, reinterpret_cast<intptr_t>(data));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR GroupsColorLoopSetCommandHandler(int argc, char ** argv)
+{
+    if (argc != 7)
+    {
+        return GroupsColorControlHelpHandler(argc, argv);
+    }
+
+    BindingCommandData * data = Platform::New<BindingCommandData>();
+    data->commandId           = Clusters::ColorControl::Commands::ColorLoopSet::Id;
+    data->clusterId           = Clusters::ColorControl::Id;
+    data->args[0]             = atoi(argv[0]);
+    data->args[1]             = atoi(argv[1]);
+    data->args[2]             = atoi(argv[2]);
+    data->args[3]             = atoi(argv[3]);
+    data->args[4]             = atoi(argv[4]);
+    data->args[5]             = atoi(argv[5]);
+    data->args[6]             = atoi(argv[6]);
+    data->isGroup             = true;
+
+    DeviceLayer::PlatformMgr().ScheduleWork(SwitchWorkerFunction, reinterpret_cast<intptr_t>(data));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR GroupsStopMoveStepCommandHandler(int argc, char ** argv)
+{
+    if (argc != 2)
+    {
+        return GroupsColorControlHelpHandler(argc, argv);
+    }
+
+    BindingCommandData * data = Platform::New<BindingCommandData>();
+    data->commandId           = Clusters::ColorControl::Commands::StopMoveStep::Id;
+    data->clusterId           = Clusters::ColorControl::Id;
+    data->args[0]             = atoi(argv[0]);
+    data->args[1]             = atoi(argv[1]);
+    data->isGroup             = true;
+
+    DeviceLayer::PlatformMgr().ScheduleWork(SwitchWorkerFunction, reinterpret_cast<intptr_t>(data));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR GroupsMoveColorTemperatureCommandHandler(int argc, char ** argv)
+{
+    if (argc != 6)
+    {
+        return GroupsColorControlHelpHandler(argc, argv);
+    }
+
+    BindingCommandData * data = Platform::New<BindingCommandData>();
+    data->commandId           = Clusters::ColorControl::Commands::MoveColorTemperature::Id;
+    data->clusterId           = Clusters::ColorControl::Id;
+    data->args[0]             = atoi(argv[0]);
+    data->args[1]             = atoi(argv[1]);
+    data->args[2]             = atoi(argv[2]);
+    data->args[3]             = atoi(argv[3]);
+    data->args[4]             = atoi(argv[4]);
+    data->args[5]             = atoi(argv[5]);
+    data->isGroup             = true;
+
+    DeviceLayer::PlatformMgr().ScheduleWork(SwitchWorkerFunction, reinterpret_cast<intptr_t>(data));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR GroupsStepColorTemperatureCommandHandler(int argc, char ** argv)
+{
+    if (argc != 7)
+    {
+        return GroupsColorControlHelpHandler(argc, argv);
+    }
+
+    BindingCommandData * data = Platform::New<BindingCommandData>();
+    data->commandId           = Clusters::ColorControl::Commands::StepColorTemperature::Id;
+    data->clusterId           = Clusters::ColorControl::Id;
+    data->args[0]             = atoi(argv[0]);
+    data->args[1]             = atoi(argv[1]);
+    data->args[2]             = atoi(argv[2]);
+    data->args[3]             = atoi(argv[3]);
+    data->args[4]             = atoi(argv[4]);
+    data->args[5]             = atoi(argv[5]);
+    data->args[6]             = atoi(argv[6]);
+    data->isGroup             = true;
+
+    DeviceLayer::PlatformMgr().ScheduleWork(SwitchWorkerFunction, reinterpret_cast<intptr_t>(data));
+    return CHIP_NO_ERROR;
+}
+#endif // CONFIG_ENABLE_CHIP_SHELL
diff --git a/examples/all-clusters-app/ameba/main/include/IdentifyCommand.h b/examples/all-clusters-app/ameba/main/include/IdentifyCommand.h
new file mode 100644
index 00000000000000..ab93460a84a300
--- /dev/null
+++ b/examples/all-clusters-app/ameba/main/include/IdentifyCommand.h
@@ -0,0 +1,270 @@
+/*
+ *
+ *    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 "controller/InvokeInteraction.h"
+#include "controller/ReadInteraction.h"
+#include <app/clusters/bindings/bindings.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 sShellSwitchIdentifySubCommands;
+Engine sShellSwitchIdentifyReadSubCommands;
+Engine sShellSwitchGroupsIdentifySubCommands;
+#endif // defined(ENABLE_CHIP_SHELL)
+
+void ProcessIdentifyUnicastBindingRead(BindingCommandData * data, const EmberBindingTableEntry & binding,
+                                       OperationalDeviceProxy * peer_device)
+{
+    auto onSuccess = [](const ConcreteDataAttributePath & attributePath, const auto & dataResponse) {
+        ChipLogProgress(NotSpecified, "Read Identify attribute succeeds");
+    };
+
+    auto onFailure = [](const ConcreteDataAttributePath * attributePath, CHIP_ERROR error) {
+        ChipLogError(NotSpecified, "Read Identify attribute failed: %" CHIP_ERROR_FORMAT, error.Format());
+    };
+
+    VerifyOrDie(peer_device != nullptr && peer_device->ConnectionReady());
+
+    switch (data->attributeId)
+    {
+    case Clusters::Identify::Attributes::AttributeList::Id:
+        Controller::ReadAttribute<Clusters::Identify::Attributes::AttributeList::TypeInfo>(
+            peer_device->GetExchangeManager(), peer_device->GetSecureSession().Value(), binding.remote, onSuccess, onFailure);
+        break;
+
+    case Clusters::Identify::Attributes::IdentifyTime::Id:
+        Controller::ReadAttribute<Clusters::Identify::Attributes::IdentifyTime::TypeInfo>(
+            peer_device->GetExchangeManager(), peer_device->GetSecureSession().Value(), binding.remote, onSuccess, onFailure);
+        break;
+
+    case Clusters::Identify::Attributes::IdentifyType::Id:
+        Controller::ReadAttribute<Clusters::Identify::Attributes::IdentifyType::TypeInfo>(
+            peer_device->GetExchangeManager(), peer_device->GetSecureSession().Value(), binding.remote, onSuccess, onFailure);
+        break;
+    }
+}
+
+void ProcessIdentifyUnicastBindingCommand(BindingCommandData * data, const EmberBindingTableEntry & binding,
+                                          OperationalDeviceProxy * peer_device)
+{
+    auto onSuccess = [](const ConcreteCommandPath & commandPath, const StatusIB & status, const auto & dataResponse) {
+        ChipLogProgress(NotSpecified, "Identify command succeeds");
+    };
+
+    auto onFailure = [](CHIP_ERROR error) {
+        ChipLogError(NotSpecified, "Identify command failed: %" CHIP_ERROR_FORMAT, error.Format());
+    };
+
+    VerifyOrDie(peer_device != nullptr && peer_device->ConnectionReady());
+
+    Clusters::Identify::Commands::Identify::Type identifyCommand;
+    Clusters::Identify::Commands::TriggerEffect::Type triggerEffectCommand;
+
+    switch (data->commandId)
+    {
+    case Clusters::Identify::Commands::Identify::Id:
+        identifyCommand.identifyTime = static_cast<uint16_t>(data->args[0]);
+        Controller::InvokeCommandRequest(peer_device->GetExchangeManager(), peer_device->GetSecureSession().Value(), binding.remote,
+                                         identifyCommand, onSuccess, onFailure);
+        break;
+
+    case Clusters::Identify::Commands::TriggerEffect::Id:
+        triggerEffectCommand.effectIdentifier = static_cast<EmberAfIdentifyEffectIdentifier>(data->args[0]);
+        triggerEffectCommand.effectVariant    = static_cast<EmberAfIdentifyEffectVariant>(data->args[1]);
+        Controller::InvokeCommandRequest(peer_device->GetExchangeManager(), peer_device->GetSecureSession().Value(), binding.remote,
+                                         triggerEffectCommand, onSuccess, onFailure);
+        break;
+    }
+}
+
+void ProcessIdentifyGroupBindingCommand(BindingCommandData * data, const EmberBindingTableEntry & binding)
+{
+    Messaging::ExchangeManager & exchangeMgr = Server::GetInstance().GetExchangeManager();
+
+    Clusters::Identify::Commands::Identify::Type identifyCommand;
+    Clusters::Identify::Commands::TriggerEffect::Type triggerEffectCommand;
+
+    switch (data->commandId)
+    {
+    case Clusters::Identify::Commands::Identify::Id:
+        identifyCommand.identifyTime = static_cast<uint16_t>(data->args[0]);
+        Controller::InvokeGroupCommandRequest(&exchangeMgr, binding.fabricIndex, binding.groupId, identifyCommand);
+        break;
+
+    case Clusters::Identify::Commands::TriggerEffect::Id:
+        triggerEffectCommand.effectIdentifier = static_cast<EmberAfIdentifyEffectIdentifier>(data->args[0]);
+        triggerEffectCommand.effectVariant    = static_cast<EmberAfIdentifyEffectVariant>(data->args[1]);
+        Controller::InvokeGroupCommandRequest(&exchangeMgr, binding.fabricIndex, binding.groupId, triggerEffectCommand);
+        break;
+    }
+}
+
+#if CONFIG_ENABLE_CHIP_SHELL
+/********************************************************
+ * Identify switch shell functions
+ *********************************************************/
+
+CHIP_ERROR IdentifyHelpHandler(int argc, char ** argv)
+{
+    sShellSwitchIdentifySubCommands.ForEachCommand(Shell::PrintCommandHelp, nullptr);
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR IdentifySwitchCommandHandler(int argc, char ** argv)
+{
+    if (argc == 0)
+    {
+        return IdentifyHelpHandler(argc, argv);
+    }
+
+    return sShellSwitchIdentifySubCommands.ExecCommand(argc, argv);
+}
+
+CHIP_ERROR IdentifyCommandHandler(int argc, char ** argv)
+{
+    BindingCommandData * data = Platform::New<BindingCommandData>();
+    data->commandId           = Clusters::Identify::Commands::Identify::Id;
+    data->clusterId           = Clusters::Identify::Id;
+    data->args[0]             = atoi(argv[0]);
+
+    DeviceLayer::PlatformMgr().ScheduleWork(SwitchWorkerFunction, reinterpret_cast<intptr_t>(data));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR TriggerEffectSwitchCommandHandler(int argc, char ** argv)
+{
+    BindingCommandData * data = Platform::New<BindingCommandData>();
+    data->commandId           = Clusters::Identify::Commands::TriggerEffect::Id;
+    data->clusterId           = Clusters::Identify::Id;
+    data->args[0]             = atoi(argv[0]);
+    data->args[1]             = atoi(argv[1]);
+
+    DeviceLayer::PlatformMgr().ScheduleWork(SwitchWorkerFunction, reinterpret_cast<intptr_t>(data));
+    return CHIP_NO_ERROR;
+}
+
+/********************************************************
+ * Identify Read switch shell functions
+ *********************************************************/
+
+CHIP_ERROR IdentifyReadHelpHandler(int argc, char ** argv)
+{
+    sShellSwitchIdentifyReadSubCommands.ForEachCommand(Shell::PrintCommandHelp, nullptr);
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR IdentifyRead(int argc, char ** argv)
+{
+    if (argc == 0)
+    {
+        return IdentifyReadHelpHandler(argc, argv);
+    }
+
+    return sShellSwitchIdentifyReadSubCommands.ExecCommand(argc, argv);
+}
+
+CHIP_ERROR IdentifyReadAttributeList(int argc, char ** argv)
+{
+    BindingCommandData * data = Platform::New<BindingCommandData>();
+    data->attributeId         = Clusters::Identify::Attributes::AttributeList::Id;
+    data->clusterId           = Clusters::Identify::Id;
+    data->isReadAttribute     = true;
+
+    DeviceLayer::PlatformMgr().ScheduleWork(SwitchWorkerFunction, reinterpret_cast<intptr_t>(data));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR IdentifyReadIdentifyTime(int argc, char ** argv)
+{
+    BindingCommandData * data = Platform::New<BindingCommandData>();
+    data->attributeId         = Clusters::Identify::Attributes::IdentifyTime::Id;
+    data->clusterId           = Clusters::Identify::Id;
+    data->isReadAttribute     = true;
+
+    DeviceLayer::PlatformMgr().ScheduleWork(SwitchWorkerFunction, reinterpret_cast<intptr_t>(data));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR IdentifyReadIdentifyType(int argc, char ** argv)
+{
+    BindingCommandData * data = Platform::New<BindingCommandData>();
+    data->attributeId         = Clusters::Identify::Attributes::IdentifyType::Id;
+    data->clusterId           = Clusters::Identify::Id;
+    data->isReadAttribute     = true;
+
+    DeviceLayer::PlatformMgr().ScheduleWork(SwitchWorkerFunction, reinterpret_cast<intptr_t>(data));
+    return CHIP_NO_ERROR;
+}
+
+/********************************************************
+ * Groups Identify switch shell functions
+ *********************************************************/
+
+CHIP_ERROR GroupsIdentifyHelpHandler(int argc, char ** argv)
+{
+    sShellSwitchGroupsIdentifySubCommands.ForEachCommand(Shell::PrintCommandHelp, nullptr);
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR GroupsIdentifySwitchCommandHandler(int argc, char ** argv)
+{
+    if (argc == 0)
+    {
+        return GroupsIdentifyHelpHandler(argc, argv);
+    }
+
+    return sShellSwitchGroupsIdentifySubCommands.ExecCommand(argc, argv);
+}
+
+CHIP_ERROR GroupIdentifyCommandHandler(int argc, char ** argv)
+{
+    BindingCommandData * data = Platform::New<BindingCommandData>();
+    data->commandId           = Clusters::Identify::Commands::Identify::Id;
+    data->clusterId           = Clusters::Identify::Id;
+    data->args[0]             = atoi(argv[0]);
+    data->isGroup             = true;
+
+    DeviceLayer::PlatformMgr().ScheduleWork(SwitchWorkerFunction, reinterpret_cast<intptr_t>(data));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR GroupTriggerEffectSwitchCommandHandler(int argc, char ** argv)
+{
+    BindingCommandData * data = Platform::New<BindingCommandData>();
+    data->commandId           = Clusters::Identify::Commands::TriggerEffect::Id;
+    data->clusterId           = Clusters::Identify::Id;
+    data->args[0]             = atoi(argv[0]);
+    data->args[1]             = atoi(argv[1]);
+    data->isGroup             = true;
+
+    DeviceLayer::PlatformMgr().ScheduleWork(SwitchWorkerFunction, reinterpret_cast<intptr_t>(data));
+    return CHIP_NO_ERROR;
+}
+#endif // CONFIG_ENABLE_CHIP_SHELL
diff --git a/examples/all-clusters-app/ameba/main/include/LevelControlCommands.h b/examples/all-clusters-app/ameba/main/include/LevelControlCommands.h
new file mode 100644
index 00000000000000..a84dcb83c6f2ab
--- /dev/null
+++ b/examples/all-clusters-app/ameba/main/include/LevelControlCommands.h
@@ -0,0 +1,843 @@
+/*
+ *
+ *    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 "controller/InvokeInteraction.h"
+#include "controller/ReadInteraction.h"
+#include <app/clusters/bindings/bindings.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 chip::app::Clusters::LevelControl::LevelControlOptions;
+using Shell::Engine;
+using Shell::shell_command_t;
+using Shell::streamer_get;
+using Shell::streamer_printf;
+
+Engine sShellSwitchLevelControlSubCommands;
+Engine sShellSwitchLevelControlReadSubCommands;
+Engine sShellSwitchGroupsLevelControlSubCommands;
+#endif // defined(ENABLE_CHIP_SHELL)
+
+void ProcessLevelControlUnicastBindingRead(BindingCommandData * data, const EmberBindingTableEntry & binding,
+                                           OperationalDeviceProxy * peer_device)
+{
+    auto onSuccess = [](const ConcreteDataAttributePath & attributePath, const auto & dataResponse) {
+        ChipLogProgress(NotSpecified, "Read LevelControl attribute succeeds");
+    };
+
+    auto onFailure = [](const ConcreteDataAttributePath * attributePath, CHIP_ERROR error) {
+        ChipLogError(NotSpecified, "Read LevelControl attribute failed: %" CHIP_ERROR_FORMAT, error.Format());
+    };
+
+    VerifyOrDie(peer_device != nullptr && peer_device->ConnectionReady());
+
+    switch (data->attributeId)
+    {
+    case Clusters::LevelControl::Attributes::AttributeList::Id:
+        Controller::ReadAttribute<Clusters::LevelControl::Attributes::AttributeList::TypeInfo>(
+            peer_device->GetExchangeManager(), peer_device->GetSecureSession().Value(), binding.remote, onSuccess, onFailure);
+        break;
+
+    case Clusters::LevelControl::Attributes::CurrentLevel::Id:
+        Controller::ReadAttribute<Clusters::LevelControl::Attributes::CurrentLevel::TypeInfo>(
+            peer_device->GetExchangeManager(), peer_device->GetSecureSession().Value(), binding.remote, onSuccess, onFailure);
+        break;
+
+    case Clusters::LevelControl::Attributes::RemainingTime::Id:
+        Controller::ReadAttribute<Clusters::LevelControl::Attributes::RemainingTime::TypeInfo>(
+            peer_device->GetExchangeManager(), peer_device->GetSecureSession().Value(), binding.remote, onSuccess, onFailure);
+        break;
+
+    case Clusters::LevelControl::Attributes::MinLevel::Id:
+        Controller::ReadAttribute<Clusters::LevelControl::Attributes::MinLevel::TypeInfo>(
+            peer_device->GetExchangeManager(), peer_device->GetSecureSession().Value(), binding.remote, onSuccess, onFailure);
+        break;
+
+    case Clusters::LevelControl::Attributes::MaxLevel::Id:
+        Controller::ReadAttribute<Clusters::LevelControl::Attributes::MaxLevel::TypeInfo>(
+            peer_device->GetExchangeManager(), peer_device->GetSecureSession().Value(), binding.remote, onSuccess, onFailure);
+        break;
+
+    case Clusters::LevelControl::Attributes::CurrentFrequency::Id:
+        Controller::ReadAttribute<Clusters::LevelControl::Attributes::CurrentFrequency::TypeInfo>(
+            peer_device->GetExchangeManager(), peer_device->GetSecureSession().Value(), binding.remote, onSuccess, onFailure);
+        break;
+
+    case Clusters::LevelControl::Attributes::MinFrequency::Id:
+        Controller::ReadAttribute<Clusters::LevelControl::Attributes::MinFrequency::TypeInfo>(
+            peer_device->GetExchangeManager(), peer_device->GetSecureSession().Value(), binding.remote, onSuccess, onFailure);
+        break;
+
+    case Clusters::LevelControl::Attributes::MaxFrequency::Id:
+        Controller::ReadAttribute<Clusters::LevelControl::Attributes::MaxFrequency::TypeInfo>(
+            peer_device->GetExchangeManager(), peer_device->GetSecureSession().Value(), binding.remote, onSuccess, onFailure);
+        break;
+
+    case Clusters::LevelControl::Attributes::Options::Id:
+        Controller::ReadAttribute<Clusters::LevelControl::Attributes::Options::TypeInfo>(
+            peer_device->GetExchangeManager(), peer_device->GetSecureSession().Value(), binding.remote, onSuccess, onFailure);
+        break;
+
+    case Clusters::LevelControl::Attributes::OnOffTransitionTime::Id:
+        Controller::ReadAttribute<Clusters::LevelControl::Attributes::OnOffTransitionTime::TypeInfo>(
+            peer_device->GetExchangeManager(), peer_device->GetSecureSession().Value(), binding.remote, onSuccess, onFailure);
+        break;
+
+    case Clusters::LevelControl::Attributes::OnLevel::Id:
+        Controller::ReadAttribute<Clusters::LevelControl::Attributes::OnLevel::TypeInfo>(
+            peer_device->GetExchangeManager(), peer_device->GetSecureSession().Value(), binding.remote, onSuccess, onFailure);
+        break;
+
+    case Clusters::LevelControl::Attributes::OnTransitionTime::Id:
+        Controller::ReadAttribute<Clusters::LevelControl::Attributes::OnTransitionTime::TypeInfo>(
+            peer_device->GetExchangeManager(), peer_device->GetSecureSession().Value(), binding.remote, onSuccess, onFailure);
+        break;
+
+    case Clusters::LevelControl::Attributes::OffTransitionTime::Id:
+        Controller::ReadAttribute<Clusters::LevelControl::Attributes::OffTransitionTime::TypeInfo>(
+            peer_device->GetExchangeManager(), peer_device->GetSecureSession().Value(), binding.remote, onSuccess, onFailure);
+        break;
+
+    case Clusters::LevelControl::Attributes::DefaultMoveRate::Id:
+        Controller::ReadAttribute<Clusters::LevelControl::Attributes::DefaultMoveRate::TypeInfo>(
+            peer_device->GetExchangeManager(), peer_device->GetSecureSession().Value(), binding.remote, onSuccess, onFailure);
+        break;
+
+    case Clusters::LevelControl::Attributes::StartUpCurrentLevel::Id:
+        Controller::ReadAttribute<Clusters::LevelControl::Attributes::StartUpCurrentLevel::TypeInfo>(
+            peer_device->GetExchangeManager(), peer_device->GetSecureSession().Value(), binding.remote, onSuccess, onFailure);
+        break;
+    }
+}
+
+void ProcessLevelControlUnicastBindingCommand(BindingCommandData * data, const EmberBindingTableEntry & binding,
+                                              OperationalDeviceProxy * peer_device)
+{
+    auto onSuccess = [](const ConcreteCommandPath & commandPath, const StatusIB & status, const auto & dataResponse) {
+        ChipLogProgress(NotSpecified, "LevelControl command succeeds");
+    };
+
+    auto onFailure = [](CHIP_ERROR error) {
+        ChipLogError(NotSpecified, "LevelControl command failed: %" CHIP_ERROR_FORMAT, error.Format());
+    };
+
+    VerifyOrDie(peer_device != nullptr && peer_device->ConnectionReady());
+
+    Clusters::LevelControl::Commands::MoveToLevel::Type moveToLevelCommand;
+    Clusters::LevelControl::Commands::Move::Type moveCommand;
+    Clusters::LevelControl::Commands::Step::Type stepCommand;
+    Clusters::LevelControl::Commands::Stop::Type stopCommand;
+    Clusters::LevelControl::Commands::MoveToLevelWithOnOff::Type moveToLevelWithOnOffCommand;
+    Clusters::LevelControl::Commands::MoveWithOnOff::Type moveWithOnOffCommand;
+    Clusters::LevelControl::Commands::StepWithOnOff::Type stepWithOnOffCommand;
+    Clusters::LevelControl::Commands::StopWithOnOff::Type stopWithOnOffCommand;
+
+    switch (data->commandId)
+    {
+    case Clusters::LevelControl::Commands::MoveToLevel::Id:
+        moveToLevelCommand.level           = static_cast<uint8_t>(data->args[0]);
+        moveToLevelCommand.transitionTime  = static_cast<DataModel::Nullable<uint16_t>>(data->args[1]);
+        moveToLevelCommand.optionsMask     = static_cast<chip::BitMask<LevelControlOptions>>(data->args[2]);
+        moveToLevelCommand.optionsOverride = static_cast<chip::BitMask<LevelControlOptions>>(data->args[3]);
+        Controller::InvokeCommandRequest(peer_device->GetExchangeManager(), peer_device->GetSecureSession().Value(), binding.remote,
+                                         moveToLevelCommand, onSuccess, onFailure);
+        break;
+
+    case Clusters::LevelControl::Commands::Move::Id:
+        moveCommand.moveMode        = static_cast<EmberAfMoveMode>(data->args[0]);
+        moveCommand.rate            = static_cast<DataModel::Nullable<uint8_t>>(data->args[1]);
+        moveCommand.optionsMask     = static_cast<chip::BitMask<LevelControlOptions>>(data->args[2]);
+        moveCommand.optionsOverride = static_cast<chip::BitMask<LevelControlOptions>>(data->args[3]);
+        Controller::InvokeCommandRequest(peer_device->GetExchangeManager(), peer_device->GetSecureSession().Value(), binding.remote,
+                                         moveCommand, onSuccess, onFailure);
+        break;
+
+    case Clusters::LevelControl::Commands::Step::Id:
+        stepCommand.stepMode        = static_cast<EmberAfStepMode>(data->args[0]);
+        stepCommand.stepSize        = static_cast<uint8_t>(data->args[1]);
+        stepCommand.transitionTime  = static_cast<DataModel::Nullable<uint16_t>>(data->args[2]);
+        stepCommand.optionsMask     = static_cast<chip::BitMask<LevelControlOptions>>(data->args[3]);
+        stepCommand.optionsOverride = static_cast<chip::BitMask<LevelControlOptions>>(data->args[4]);
+        Controller::InvokeCommandRequest(peer_device->GetExchangeManager(), peer_device->GetSecureSession().Value(), binding.remote,
+                                         stepCommand, onSuccess, onFailure);
+        break;
+
+    case Clusters::LevelControl::Commands::Stop::Id:
+        stopCommand.optionsMask     = static_cast<chip::BitMask<LevelControlOptions>>(data->args[0]);
+        stopCommand.optionsOverride = static_cast<chip::BitMask<LevelControlOptions>>(data->args[1]);
+        Controller::InvokeCommandRequest(peer_device->GetExchangeManager(), peer_device->GetSecureSession().Value(), binding.remote,
+                                         stopCommand, onSuccess, onFailure);
+        break;
+
+    case Clusters::LevelControl::Commands::MoveToLevelWithOnOff::Id:
+        moveToLevelWithOnOffCommand.level           = static_cast<uint8_t>(data->args[0]);
+        moveToLevelWithOnOffCommand.transitionTime  = static_cast<DataModel::Nullable<uint16_t>>(data->args[1]);
+        moveToLevelWithOnOffCommand.optionsMask     = static_cast<chip::BitMask<LevelControlOptions>>(data->args[2]);
+        moveToLevelWithOnOffCommand.optionsOverride = static_cast<chip::BitMask<LevelControlOptions>>(data->args[3]);
+        Controller::InvokeCommandRequest(peer_device->GetExchangeManager(), peer_device->GetSecureSession().Value(), binding.remote,
+                                         moveToLevelWithOnOffCommand, onSuccess, onFailure);
+        break;
+
+    case Clusters::LevelControl::Commands::MoveWithOnOff::Id:
+        moveWithOnOffCommand.moveMode        = static_cast<EmberAfMoveMode>(data->args[0]);
+        moveWithOnOffCommand.rate            = static_cast<DataModel::Nullable<uint8_t>>(data->args[1]);
+        moveWithOnOffCommand.optionsMask     = static_cast<chip::BitMask<LevelControlOptions>>(data->args[2]);
+        moveWithOnOffCommand.optionsOverride = static_cast<chip::BitMask<LevelControlOptions>>(data->args[3]);
+        Controller::InvokeCommandRequest(peer_device->GetExchangeManager(), peer_device->GetSecureSession().Value(), binding.remote,
+                                         moveWithOnOffCommand, onSuccess, onFailure);
+        break;
+
+    case Clusters::LevelControl::Commands::StepWithOnOff::Id:
+        stepWithOnOffCommand.stepMode        = static_cast<EmberAfStepMode>(data->args[0]);
+        stepWithOnOffCommand.stepSize        = static_cast<uint8_t>(data->args[1]);
+        stepWithOnOffCommand.transitionTime  = static_cast<DataModel::Nullable<uint16_t>>(data->args[2]);
+        stepWithOnOffCommand.optionsMask     = static_cast<chip::BitMask<LevelControlOptions>>(data->args[3]);
+        stepWithOnOffCommand.optionsOverride = static_cast<chip::BitMask<LevelControlOptions>>(data->args[4]);
+        Controller::InvokeCommandRequest(peer_device->GetExchangeManager(), peer_device->GetSecureSession().Value(), binding.remote,
+                                         stepWithOnOffCommand, onSuccess, onFailure);
+        break;
+
+    case Clusters::LevelControl::Commands::StopWithOnOff::Id:
+        stopWithOnOffCommand.optionsMask     = static_cast<chip::BitMask<LevelControlOptions>>(data->args[0]);
+        stopWithOnOffCommand.optionsOverride = static_cast<chip::BitMask<LevelControlOptions>>(data->args[1]);
+        Controller::InvokeCommandRequest(peer_device->GetExchangeManager(), peer_device->GetSecureSession().Value(), binding.remote,
+                                         stopWithOnOffCommand, onSuccess, onFailure);
+        break;
+    }
+}
+
+void ProcessLevelControlGroupBindingCommand(BindingCommandData * data, const EmberBindingTableEntry & binding)
+{
+    Messaging::ExchangeManager & exchangeMgr = Server::GetInstance().GetExchangeManager();
+
+    Clusters::LevelControl::Commands::MoveToLevel::Type moveToLevelCommand;
+    Clusters::LevelControl::Commands::Move::Type moveCommand;
+    Clusters::LevelControl::Commands::Step::Type stepCommand;
+    Clusters::LevelControl::Commands::Stop::Type stopCommand;
+    Clusters::LevelControl::Commands::MoveToLevelWithOnOff::Type moveToLevelWithOnOffCommand;
+    Clusters::LevelControl::Commands::MoveWithOnOff::Type moveWithOnOffCommand;
+    Clusters::LevelControl::Commands::StepWithOnOff::Type stepWithOnOffCommand;
+    Clusters::LevelControl::Commands::StopWithOnOff::Type stopWithOnOffCommand;
+
+    switch (data->commandId)
+    {
+    case Clusters::LevelControl::Commands::MoveToLevel::Id:
+        moveToLevelCommand.level           = static_cast<uint8_t>(data->args[0]);
+        moveToLevelCommand.transitionTime  = static_cast<DataModel::Nullable<uint16_t>>(data->args[1]);
+        moveToLevelCommand.optionsMask     = static_cast<chip::BitMask<LevelControlOptions>>(data->args[2]);
+        moveToLevelCommand.optionsOverride = static_cast<chip::BitMask<LevelControlOptions>>(data->args[3]);
+        Controller::InvokeGroupCommandRequest(&exchangeMgr, binding.fabricIndex, binding.groupId, moveToLevelCommand);
+        break;
+
+    case Clusters::LevelControl::Commands::Move::Id:
+        moveCommand.moveMode        = static_cast<EmberAfMoveMode>(data->args[0]);
+        moveCommand.rate            = static_cast<DataModel::Nullable<uint8_t>>(data->args[1]);
+        moveCommand.optionsMask     = static_cast<chip::BitMask<LevelControlOptions>>(data->args[2]);
+        moveCommand.optionsOverride = static_cast<chip::BitMask<LevelControlOptions>>(data->args[3]);
+        Controller::InvokeGroupCommandRequest(&exchangeMgr, binding.fabricIndex, binding.groupId, moveCommand);
+        break;
+
+    case Clusters::LevelControl::Commands::Step::Id:
+        stepCommand.stepMode        = static_cast<EmberAfStepMode>(data->args[0]);
+        stepCommand.stepSize        = static_cast<uint8_t>(data->args[1]);
+        stepCommand.transitionTime  = static_cast<DataModel::Nullable<uint16_t>>(data->args[2]);
+        stepCommand.optionsMask     = static_cast<chip::BitMask<LevelControlOptions>>(data->args[3]);
+        stepCommand.optionsOverride = static_cast<chip::BitMask<LevelControlOptions>>(data->args[4]);
+        Controller::InvokeGroupCommandRequest(&exchangeMgr, binding.fabricIndex, binding.groupId, stepCommand);
+        break;
+
+    case Clusters::LevelControl::Commands::Stop::Id:
+        stopCommand.optionsMask     = static_cast<chip::BitMask<LevelControlOptions>>(data->args[0]);
+        stopCommand.optionsOverride = static_cast<chip::BitMask<LevelControlOptions>>(data->args[1]);
+        Controller::InvokeGroupCommandRequest(&exchangeMgr, binding.fabricIndex, binding.groupId, stopCommand);
+        break;
+
+    case Clusters::LevelControl::Commands::MoveToLevelWithOnOff::Id:
+        moveToLevelWithOnOffCommand.level           = static_cast<uint8_t>(data->args[0]);
+        moveToLevelWithOnOffCommand.transitionTime  = static_cast<DataModel::Nullable<uint16_t>>(data->args[1]);
+        moveToLevelWithOnOffCommand.optionsMask     = static_cast<chip::BitMask<LevelControlOptions>>(data->args[2]);
+        moveToLevelWithOnOffCommand.optionsOverride = static_cast<chip::BitMask<LevelControlOptions>>(data->args[3]);
+        Controller::InvokeGroupCommandRequest(&exchangeMgr, binding.fabricIndex, binding.groupId, moveToLevelWithOnOffCommand);
+        break;
+
+    case Clusters::LevelControl::Commands::MoveWithOnOff::Id:
+        moveWithOnOffCommand.moveMode        = static_cast<EmberAfMoveMode>(data->args[0]);
+        moveWithOnOffCommand.rate            = static_cast<DataModel::Nullable<uint8_t>>(data->args[1]);
+        moveWithOnOffCommand.optionsMask     = static_cast<chip::BitMask<LevelControlOptions>>(data->args[2]);
+        moveWithOnOffCommand.optionsOverride = static_cast<chip::BitMask<LevelControlOptions>>(data->args[3]);
+        Controller::InvokeGroupCommandRequest(&exchangeMgr, binding.fabricIndex, binding.groupId, moveWithOnOffCommand);
+        break;
+
+    case Clusters::LevelControl::Commands::StepWithOnOff::Id:
+        stepWithOnOffCommand.stepMode        = static_cast<EmberAfStepMode>(data->args[0]);
+        stepWithOnOffCommand.stepSize        = static_cast<uint8_t>(data->args[1]);
+        stepWithOnOffCommand.transitionTime  = static_cast<DataModel::Nullable<uint16_t>>(data->args[2]);
+        stepWithOnOffCommand.optionsMask     = static_cast<chip::BitMask<LevelControlOptions>>(data->args[3]);
+        stepWithOnOffCommand.optionsOverride = static_cast<chip::BitMask<LevelControlOptions>>(data->args[4]);
+        Controller::InvokeGroupCommandRequest(&exchangeMgr, binding.fabricIndex, binding.groupId, stepWithOnOffCommand);
+        break;
+
+    case Clusters::LevelControl::Commands::StopWithOnOff::Id:
+        stopWithOnOffCommand.optionsMask     = static_cast<chip::BitMask<LevelControlOptions>>(data->args[0]);
+        stopWithOnOffCommand.optionsOverride = static_cast<chip::BitMask<LevelControlOptions>>(data->args[1]);
+        Controller::InvokeGroupCommandRequest(&exchangeMgr, binding.fabricIndex, binding.groupId, stopWithOnOffCommand);
+        break;
+    }
+}
+
+#if CONFIG_ENABLE_CHIP_SHELL
+/********************************************************
+ * LevelControl switch shell functions
+ *********************************************************/
+
+CHIP_ERROR LevelControlHelpHandler(int argc, char ** argv)
+{
+    sShellSwitchLevelControlSubCommands.ForEachCommand(Shell::PrintCommandHelp, nullptr);
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR LevelControlSwitchCommandHandler(int argc, char ** argv)
+{
+    if (argc == 0)
+    {
+        return LevelControlHelpHandler(argc, argv);
+    }
+
+    return sShellSwitchLevelControlSubCommands.ExecCommand(argc, argv);
+}
+
+CHIP_ERROR MoveToLevelSwitchCommandHandler(int argc, char ** argv)
+{
+    if (argc != 4)
+    {
+        return LevelControlHelpHandler(argc, argv);
+    }
+
+    BindingCommandData * data = Platform::New<BindingCommandData>();
+    data->commandId           = Clusters::LevelControl::Commands::MoveToLevel::Id;
+    data->clusterId           = Clusters::LevelControl::Id;
+    data->args[0]             = atoi(argv[0]);
+    data->args[1]             = atoi(argv[1]);
+    data->args[2]             = atoi(argv[2]);
+    data->args[3]             = atoi(argv[3]);
+
+    DeviceLayer::PlatformMgr().ScheduleWork(SwitchWorkerFunction, reinterpret_cast<intptr_t>(data));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR MoveSwitchCommandHandler(int argc, char ** argv)
+{
+    if (argc != 4)
+    {
+        return LevelControlHelpHandler(argc, argv);
+    }
+
+    BindingCommandData * data = Platform::New<BindingCommandData>();
+    data->commandId           = Clusters::LevelControl::Commands::Move::Id;
+    data->clusterId           = Clusters::LevelControl::Id;
+    data->args[0]             = atoi(argv[0]);
+    data->args[1]             = atoi(argv[1]);
+    data->args[2]             = atoi(argv[2]);
+    data->args[3]             = atoi(argv[3]);
+
+    DeviceLayer::PlatformMgr().ScheduleWork(SwitchWorkerFunction, reinterpret_cast<intptr_t>(data));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR StepSwitchCommandHandler(int argc, char ** argv)
+{
+    if (argc != 5)
+    {
+        return LevelControlHelpHandler(argc, argv);
+    }
+
+    BindingCommandData * data = Platform::New<BindingCommandData>();
+    data->commandId           = Clusters::LevelControl::Commands::Step::Id;
+    data->clusterId           = Clusters::LevelControl::Id;
+    data->args[0]             = atoi(argv[0]);
+    data->args[1]             = atoi(argv[1]);
+    data->args[2]             = atoi(argv[2]);
+    data->args[3]             = atoi(argv[3]);
+    data->args[4]             = atoi(argv[4]);
+
+    DeviceLayer::PlatformMgr().ScheduleWork(SwitchWorkerFunction, reinterpret_cast<intptr_t>(data));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR StopSwitchCommandHandler(int argc, char ** argv)
+{
+    if (argc != 2)
+    {
+        return LevelControlHelpHandler(argc, argv);
+    }
+
+    BindingCommandData * data = Platform::New<BindingCommandData>();
+    data->commandId           = Clusters::LevelControl::Commands::Stop::Id;
+    data->clusterId           = Clusters::LevelControl::Id;
+    data->args[0]             = atoi(argv[0]);
+    data->args[1]             = atoi(argv[1]);
+
+    DeviceLayer::PlatformMgr().ScheduleWork(SwitchWorkerFunction, reinterpret_cast<intptr_t>(data));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR MoveToLevelWithOnOffSwitchCommandHandler(int argc, char ** argv)
+{
+    if (argc != 4)
+    {
+        return LevelControlHelpHandler(argc, argv);
+    }
+
+    BindingCommandData * data = Platform::New<BindingCommandData>();
+    data->commandId           = Clusters::LevelControl::Commands::MoveToLevelWithOnOff::Id;
+    data->clusterId           = Clusters::LevelControl::Id;
+    data->args[0]             = atoi(argv[0]);
+    data->args[1]             = atoi(argv[1]);
+    data->args[2]             = atoi(argv[2]);
+    data->args[3]             = atoi(argv[3]);
+
+    DeviceLayer::PlatformMgr().ScheduleWork(SwitchWorkerFunction, reinterpret_cast<intptr_t>(data));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR MoveWithOnOffSwitchCommandHandler(int argc, char ** argv)
+{
+    if (argc != 4)
+    {
+        return LevelControlHelpHandler(argc, argv);
+    }
+
+    BindingCommandData * data = Platform::New<BindingCommandData>();
+    data->commandId           = Clusters::LevelControl::Commands::MoveWithOnOff::Id;
+    data->clusterId           = Clusters::LevelControl::Id;
+    data->args[0]             = atoi(argv[0]);
+    data->args[1]             = atoi(argv[1]);
+    data->args[2]             = atoi(argv[2]);
+    data->args[3]             = atoi(argv[3]);
+
+    DeviceLayer::PlatformMgr().ScheduleWork(SwitchWorkerFunction, reinterpret_cast<intptr_t>(data));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR StepWithOnOffSwitchCommandHandler(int argc, char ** argv)
+{
+    if (argc != 5)
+    {
+        return LevelControlHelpHandler(argc, argv);
+    }
+
+    BindingCommandData * data = Platform::New<BindingCommandData>();
+    data->commandId           = Clusters::LevelControl::Commands::StepWithOnOff::Id;
+    data->clusterId           = Clusters::LevelControl::Id;
+    data->args[0]             = atoi(argv[0]);
+    data->args[1]             = atoi(argv[1]);
+    data->args[2]             = atoi(argv[2]);
+    data->args[3]             = atoi(argv[3]);
+    data->args[4]             = atoi(argv[4]);
+
+    DeviceLayer::PlatformMgr().ScheduleWork(SwitchWorkerFunction, reinterpret_cast<intptr_t>(data));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR StopWithOnOffSwitchCommandHandler(int argc, char ** argv)
+{
+    if (argc != 2)
+    {
+        return LevelControlHelpHandler(argc, argv);
+    }
+
+    BindingCommandData * data = Platform::New<BindingCommandData>();
+    data->commandId           = Clusters::LevelControl::Commands::StopWithOnOff::Id;
+    data->clusterId           = Clusters::LevelControl::Id;
+    data->args[0]             = atoi(argv[0]);
+    data->args[1]             = atoi(argv[1]);
+
+    DeviceLayer::PlatformMgr().ScheduleWork(SwitchWorkerFunction, reinterpret_cast<intptr_t>(data));
+    return CHIP_NO_ERROR;
+}
+
+/********************************************************
+ * LevelControl Read switch shell functions
+ *********************************************************/
+
+CHIP_ERROR LevelControlReadHelpHandler(int argc, char ** argv)
+{
+    sShellSwitchLevelControlReadSubCommands.ForEachCommand(Shell::PrintCommandHelp, nullptr);
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR LevelControlRead(int argc, char ** argv)
+{
+    if (argc == 0)
+    {
+        return LevelControlReadHelpHandler(argc, argv);
+    }
+
+    return sShellSwitchLevelControlReadSubCommands.ExecCommand(argc, argv);
+}
+
+CHIP_ERROR LevelControlReadAttributeList(int argc, char ** argv)
+{
+    BindingCommandData * data = Platform::New<BindingCommandData>();
+    data->attributeId         = Clusters::LevelControl::Attributes::AttributeList::Id;
+    data->clusterId           = Clusters::LevelControl::Id;
+    data->isReadAttribute     = true;
+
+    DeviceLayer::PlatformMgr().ScheduleWork(SwitchWorkerFunction, reinterpret_cast<intptr_t>(data));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR LevelControlReadCurrentLevel(int argc, char ** argv)
+{
+    BindingCommandData * data = Platform::New<BindingCommandData>();
+    data->attributeId         = Clusters::LevelControl::Attributes::CurrentLevel::Id;
+    data->clusterId           = Clusters::LevelControl::Id;
+    data->isReadAttribute     = true;
+    ChipLogProgress(NotSpecified, "Read cluster=0x%x, attribute=0x%08x", data->clusterId, data->attributeId);
+    DeviceLayer::PlatformMgr().ScheduleWork(SwitchWorkerFunction, reinterpret_cast<intptr_t>(data));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR LevelControlReadRemainingTime(int argc, char ** argv)
+{
+    BindingCommandData * data = Platform::New<BindingCommandData>();
+    data->attributeId         = Clusters::LevelControl::Attributes::RemainingTime::Id;
+    data->clusterId           = Clusters::LevelControl::Id;
+    data->isReadAttribute     = true;
+    ChipLogProgress(NotSpecified, "Read cluster=0x%x, attribute=0x%08x", data->clusterId, data->attributeId);
+    DeviceLayer::PlatformMgr().ScheduleWork(SwitchWorkerFunction, reinterpret_cast<intptr_t>(data));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR LevelControlReadMinLevel(int argc, char ** argv)
+{
+    BindingCommandData * data = Platform::New<BindingCommandData>();
+    data->attributeId         = Clusters::LevelControl::Attributes::MinLevel::Id;
+    data->clusterId           = Clusters::LevelControl::Id;
+    data->isReadAttribute     = true;
+    ChipLogProgress(NotSpecified, "Read cluster=0x%x, attribute=0x%08x", data->clusterId, data->attributeId);
+    DeviceLayer::PlatformMgr().ScheduleWork(SwitchWorkerFunction, reinterpret_cast<intptr_t>(data));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR LevelControlReadMaxLevel(int argc, char ** argv)
+{
+    BindingCommandData * data = Platform::New<BindingCommandData>();
+    data->attributeId         = Clusters::LevelControl::Attributes::MaxLevel::Id;
+    data->clusterId           = Clusters::LevelControl::Id;
+    data->isReadAttribute     = true;
+    ChipLogProgress(NotSpecified, "Read cluster=0x%x, attribute=0x%08x", data->clusterId, data->attributeId);
+    DeviceLayer::PlatformMgr().ScheduleWork(SwitchWorkerFunction, reinterpret_cast<intptr_t>(data));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR LevelControlReadCurrentFrequency(int argc, char ** argv)
+{
+    BindingCommandData * data = Platform::New<BindingCommandData>();
+    data->attributeId         = Clusters::LevelControl::Attributes::CurrentFrequency::Id;
+    data->clusterId           = Clusters::LevelControl::Id;
+    data->isReadAttribute     = true;
+    ChipLogProgress(NotSpecified, "Read cluster=0x%x, attribute=0x%08x", data->clusterId, data->attributeId);
+    DeviceLayer::PlatformMgr().ScheduleWork(SwitchWorkerFunction, reinterpret_cast<intptr_t>(data));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR LevelControlReadMinFrequency(int argc, char ** argv)
+{
+    BindingCommandData * data = Platform::New<BindingCommandData>();
+    data->attributeId         = Clusters::LevelControl::Attributes::MinFrequency::Id;
+    data->clusterId           = Clusters::LevelControl::Id;
+    data->isReadAttribute     = true;
+    ChipLogProgress(NotSpecified, "Read cluster=0x%x, attribute=0x%08x", data->clusterId, data->attributeId);
+    DeviceLayer::PlatformMgr().ScheduleWork(SwitchWorkerFunction, reinterpret_cast<intptr_t>(data));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR LevelControlReadMaxFrequency(int argc, char ** argv)
+{
+    BindingCommandData * data = Platform::New<BindingCommandData>();
+    data->attributeId         = Clusters::LevelControl::Attributes::MaxFrequency::Id;
+    data->clusterId           = Clusters::LevelControl::Id;
+    data->isReadAttribute     = true;
+    ChipLogProgress(NotSpecified, "Read cluster=0x%x, attribute=0x%08x", data->clusterId, data->attributeId);
+    DeviceLayer::PlatformMgr().ScheduleWork(SwitchWorkerFunction, reinterpret_cast<intptr_t>(data));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR LevelControlReadOptions(int argc, char ** argv)
+{
+    BindingCommandData * data = Platform::New<BindingCommandData>();
+    data->attributeId         = Clusters::LevelControl::Attributes::Options::Id;
+    data->clusterId           = Clusters::LevelControl::Id;
+    data->isReadAttribute     = true;
+    ChipLogProgress(NotSpecified, "Read cluster=0x%x, attribute=0x%08x", data->clusterId, data->attributeId);
+    DeviceLayer::PlatformMgr().ScheduleWork(SwitchWorkerFunction, reinterpret_cast<intptr_t>(data));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR LevelControlReadOnOffTransitionTime(int argc, char ** argv)
+{
+    BindingCommandData * data = Platform::New<BindingCommandData>();
+    data->attributeId         = Clusters::LevelControl::Attributes::OnOffTransitionTime::Id;
+    data->clusterId           = Clusters::LevelControl::Id;
+    data->isReadAttribute     = true;
+    ChipLogProgress(NotSpecified, "Read cluster=0x%x, attribute=0x%08x", data->clusterId, data->attributeId);
+    DeviceLayer::PlatformMgr().ScheduleWork(SwitchWorkerFunction, reinterpret_cast<intptr_t>(data));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR LevelControlReadOnLevel(int argc, char ** argv)
+{
+    BindingCommandData * data = Platform::New<BindingCommandData>();
+    data->attributeId         = Clusters::LevelControl::Attributes::OnLevel::Id;
+    data->clusterId           = Clusters::LevelControl::Id;
+    data->isReadAttribute     = true;
+    ChipLogProgress(NotSpecified, "Read cluster=0x%x, attribute=0x%08x", data->clusterId, data->attributeId);
+    DeviceLayer::PlatformMgr().ScheduleWork(SwitchWorkerFunction, reinterpret_cast<intptr_t>(data));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR LevelControlReadOnTransitionTime(int argc, char ** argv)
+{
+    BindingCommandData * data = Platform::New<BindingCommandData>();
+    data->attributeId         = Clusters::LevelControl::Attributes::OnTransitionTime::Id;
+    data->clusterId           = Clusters::LevelControl::Id;
+    data->isReadAttribute     = true;
+    ChipLogProgress(NotSpecified, "Read cluster=0x%x, attribute=0x%08x", data->clusterId, data->attributeId);
+    DeviceLayer::PlatformMgr().ScheduleWork(SwitchWorkerFunction, reinterpret_cast<intptr_t>(data));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR LevelControlReadOffTransitionTime(int argc, char ** argv)
+{
+    BindingCommandData * data = Platform::New<BindingCommandData>();
+    data->attributeId         = Clusters::LevelControl::Attributes::OffTransitionTime::Id;
+    data->clusterId           = Clusters::LevelControl::Id;
+    data->isReadAttribute     = true;
+    ChipLogProgress(NotSpecified, "Read cluster=0x%x, attribute=0x%08x", data->clusterId, data->attributeId);
+    DeviceLayer::PlatformMgr().ScheduleWork(SwitchWorkerFunction, reinterpret_cast<intptr_t>(data));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR LevelControlReadDefaultMoveRate(int argc, char ** argv)
+{
+    BindingCommandData * data = Platform::New<BindingCommandData>();
+    data->attributeId         = Clusters::LevelControl::Attributes::DefaultMoveRate::Id;
+    data->clusterId           = Clusters::LevelControl::Id;
+    data->isReadAttribute     = true;
+    ChipLogProgress(NotSpecified, "Read cluster=0x%x, attribute=0x%08x", data->clusterId, data->attributeId);
+    DeviceLayer::PlatformMgr().ScheduleWork(SwitchWorkerFunction, reinterpret_cast<intptr_t>(data));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR LevelControlReadStartUpCurrentLevel(int argc, char ** argv)
+{
+    BindingCommandData * data = Platform::New<BindingCommandData>();
+    data->attributeId         = Clusters::LevelControl::Attributes::StartUpCurrentLevel::Id;
+    data->clusterId           = Clusters::LevelControl::Id;
+    data->isReadAttribute     = true;
+    ChipLogProgress(NotSpecified, "Read cluster=0x%x, attribute=0x%08x", data->clusterId, data->attributeId);
+    DeviceLayer::PlatformMgr().ScheduleWork(SwitchWorkerFunction, reinterpret_cast<intptr_t>(data));
+    return CHIP_NO_ERROR;
+}
+
+/********************************************************
+ * Groups LevelControl switch shell functions
+ *********************************************************/
+
+CHIP_ERROR GroupsLevelControlHelpHandler(int argc, char ** argv)
+{
+    sShellSwitchGroupsLevelControlSubCommands.ForEachCommand(Shell::PrintCommandHelp, nullptr);
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR GroupsLevelControlSwitchCommandHandler(int argc, char ** argv)
+{
+    if (argc == 0)
+    {
+        return GroupsLevelControlHelpHandler(argc, argv);
+    }
+
+    return sShellSwitchGroupsLevelControlSubCommands.ExecCommand(argc, argv);
+}
+
+CHIP_ERROR GroupsMoveToLevelSwitchCommandHandler(int argc, char ** argv)
+{
+    if (argc != 4)
+    {
+        return GroupsLevelControlHelpHandler(argc, argv);
+    }
+
+    BindingCommandData * data = Platform::New<BindingCommandData>();
+    data->commandId           = Clusters::LevelControl::Commands::MoveToLevel::Id;
+    data->clusterId           = Clusters::LevelControl::Id;
+    data->args[0]             = atoi(argv[0]);
+    data->args[1]             = atoi(argv[1]);
+    data->args[2]             = atoi(argv[2]);
+    data->args[3]             = atoi(argv[3]);
+    data->isGroup             = true;
+
+    DeviceLayer::PlatformMgr().ScheduleWork(SwitchWorkerFunction, reinterpret_cast<intptr_t>(data));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR GroupsMoveSwitchCommandHandler(int argc, char ** argv)
+{
+    if (argc != 4)
+    {
+        return GroupsLevelControlHelpHandler(argc, argv);
+    }
+
+    BindingCommandData * data = Platform::New<BindingCommandData>();
+    data->commandId           = Clusters::LevelControl::Commands::Move::Id;
+    data->clusterId           = Clusters::LevelControl::Id;
+    data->args[0]             = atoi(argv[0]);
+    data->args[1]             = atoi(argv[1]);
+    data->args[2]             = atoi(argv[2]);
+    data->args[3]             = atoi(argv[3]);
+    data->isGroup             = true;
+
+    DeviceLayer::PlatformMgr().ScheduleWork(SwitchWorkerFunction, reinterpret_cast<intptr_t>(data));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR GroupsStepSwitchCommandHandler(int argc, char ** argv)
+{
+    if (argc != 5)
+    {
+        return GroupsLevelControlHelpHandler(argc, argv);
+    }
+
+    BindingCommandData * data = Platform::New<BindingCommandData>();
+    data->commandId           = Clusters::LevelControl::Commands::Step::Id;
+    data->clusterId           = Clusters::LevelControl::Id;
+    data->args[0]             = atoi(argv[0]);
+    data->args[1]             = atoi(argv[1]);
+    data->args[2]             = atoi(argv[2]);
+    data->args[3]             = atoi(argv[3]);
+    data->args[4]             = atoi(argv[4]);
+    data->isGroup             = true;
+
+    DeviceLayer::PlatformMgr().ScheduleWork(SwitchWorkerFunction, reinterpret_cast<intptr_t>(data));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR GroupsStopSwitchCommandHandler(int argc, char ** argv)
+{
+    if (argc != 2)
+    {
+        return GroupsLevelControlHelpHandler(argc, argv);
+    }
+
+    BindingCommandData * data = Platform::New<BindingCommandData>();
+    data->commandId           = Clusters::LevelControl::Commands::Stop::Id;
+    data->clusterId           = Clusters::LevelControl::Id;
+    data->args[0]             = atoi(argv[0]);
+    data->args[1]             = atoi(argv[1]);
+    data->isGroup             = true;
+
+    DeviceLayer::PlatformMgr().ScheduleWork(SwitchWorkerFunction, reinterpret_cast<intptr_t>(data));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR GroupsMoveToLevelWithOnOffSwitchCommandHandler(int argc, char ** argv)
+{
+    if (argc != 4)
+    {
+        return GroupsLevelControlHelpHandler(argc, argv);
+    }
+
+    BindingCommandData * data = Platform::New<BindingCommandData>();
+    data->commandId           = Clusters::LevelControl::Commands::MoveToLevelWithOnOff::Id;
+    data->clusterId           = Clusters::LevelControl::Id;
+    data->args[0]             = atoi(argv[0]);
+    data->args[1]             = atoi(argv[1]);
+    data->args[2]             = atoi(argv[2]);
+    data->args[3]             = atoi(argv[3]);
+    data->isGroup             = true;
+
+    DeviceLayer::PlatformMgr().ScheduleWork(SwitchWorkerFunction, reinterpret_cast<intptr_t>(data));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR GroupsMoveWithOnOffSwitchCommandHandler(int argc, char ** argv)
+{
+    if (argc != 4)
+    {
+        return GroupsLevelControlHelpHandler(argc, argv);
+    }
+
+    BindingCommandData * data = Platform::New<BindingCommandData>();
+    data->commandId           = Clusters::LevelControl::Commands::MoveWithOnOff::Id;
+    data->clusterId           = Clusters::LevelControl::Id;
+    data->args[0]             = atoi(argv[0]);
+    data->args[1]             = atoi(argv[1]);
+    data->args[2]             = atoi(argv[2]);
+    data->args[3]             = atoi(argv[3]);
+    data->isGroup             = true;
+
+    DeviceLayer::PlatformMgr().ScheduleWork(SwitchWorkerFunction, reinterpret_cast<intptr_t>(data));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR GroupsStepWithOnOffSwitchCommandHandler(int argc, char ** argv)
+{
+    if (argc != 5)
+    {
+        return GroupsLevelControlHelpHandler(argc, argv);
+    }
+
+    BindingCommandData * data = Platform::New<BindingCommandData>();
+    data->commandId           = Clusters::LevelControl::Commands::StepWithOnOff::Id;
+    data->clusterId           = Clusters::LevelControl::Id;
+    data->args[0]             = atoi(argv[0]);
+    data->args[1]             = atoi(argv[1]);
+    data->args[2]             = atoi(argv[2]);
+    data->args[3]             = atoi(argv[3]);
+    data->args[4]             = atoi(argv[4]);
+    data->isGroup             = true;
+
+    DeviceLayer::PlatformMgr().ScheduleWork(SwitchWorkerFunction, reinterpret_cast<intptr_t>(data));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR GroupsStopWithOnOffSwitchCommandHandler(int argc, char ** argv)
+{
+    if (argc != 2)
+    {
+        return GroupsLevelControlHelpHandler(argc, argv);
+    }
+
+    BindingCommandData * data = Platform::New<BindingCommandData>();
+    data->commandId           = Clusters::LevelControl::Commands::StopWithOnOff::Id;
+    data->clusterId           = Clusters::LevelControl::Id;
+    data->args[0]             = atoi(argv[0]);
+    data->args[1]             = atoi(argv[1]);
+    data->isGroup             = true;
+
+    DeviceLayer::PlatformMgr().ScheduleWork(SwitchWorkerFunction, reinterpret_cast<intptr_t>(data));
+    return CHIP_NO_ERROR;
+}
+#endif // CONFIG_ENABLE_CHIP_SHELL
diff --git a/examples/all-clusters-app/ameba/main/include/OnOffCommands.h b/examples/all-clusters-app/ameba/main/include/OnOffCommands.h
new file mode 100644
index 00000000000000..47dfe5698de4aa
--- /dev/null
+++ b/examples/all-clusters-app/ameba/main/include/OnOffCommands.h
@@ -0,0 +1,474 @@
+/*
+ *
+ *    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 "controller/InvokeInteraction.h"
+#include "controller/ReadInteraction.h"
+#include <app/clusters/bindings/bindings.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 sShellSwitchOnOffSubCommands;
+Engine sShellSwitchOnOffReadSubCommands;
+Engine sShellSwitchGroupsOnOffSubCommands;
+#endif // defined(ENABLE_CHIP_SHELL)
+
+void ProcessOnOffUnicastBindingRead(BindingCommandData * data, const EmberBindingTableEntry & binding,
+                                    OperationalDeviceProxy * peer_device)
+{
+    auto onSuccess = [](const ConcreteDataAttributePath & attributePath, const auto & dataResponse) {
+        ChipLogProgress(NotSpecified, "Read OnOff attribute succeeds");
+    };
+
+    auto onFailure = [](const ConcreteDataAttributePath * attributePath, CHIP_ERROR error) {
+        ChipLogError(NotSpecified, "Read OnOff attribute failed: %" CHIP_ERROR_FORMAT, error.Format());
+    };
+
+    VerifyOrDie(peer_device != nullptr && peer_device->ConnectionReady());
+
+    switch (data->attributeId)
+    {
+    case Clusters::OnOff::Attributes::AttributeList::Id:
+        Controller::ReadAttribute<Clusters::OnOff::Attributes::AttributeList::TypeInfo>(
+            peer_device->GetExchangeManager(), peer_device->GetSecureSession().Value(), binding.remote, onSuccess, onFailure);
+        break;
+
+    case Clusters::OnOff::Attributes::OnOff::Id:
+        Controller::ReadAttribute<Clusters::OnOff::Attributes::OnOff::TypeInfo>(
+            peer_device->GetExchangeManager(), peer_device->GetSecureSession().Value(), binding.remote, onSuccess, onFailure);
+        break;
+
+    case Clusters::OnOff::Attributes::GlobalSceneControl::Id:
+        Controller::ReadAttribute<Clusters::OnOff::Attributes::GlobalSceneControl::TypeInfo>(
+            peer_device->GetExchangeManager(), peer_device->GetSecureSession().Value(), binding.remote, onSuccess, onFailure);
+        break;
+
+    case Clusters::OnOff::Attributes::OnTime::Id:
+        Controller::ReadAttribute<Clusters::OnOff::Attributes::OnTime::TypeInfo>(
+            peer_device->GetExchangeManager(), peer_device->GetSecureSession().Value(), binding.remote, onSuccess, onFailure);
+        break;
+
+    case Clusters::OnOff::Attributes::OffWaitTime::Id:
+        Controller::ReadAttribute<Clusters::OnOff::Attributes::OffWaitTime::TypeInfo>(
+            peer_device->GetExchangeManager(), peer_device->GetSecureSession().Value(), binding.remote, onSuccess, onFailure);
+        break;
+
+    case Clusters::OnOff::Attributes::StartUpOnOff::Id:
+        Controller::ReadAttribute<Clusters::OnOff::Attributes::StartUpOnOff::TypeInfo>(
+            peer_device->GetExchangeManager(), peer_device->GetSecureSession().Value(), binding.remote, onSuccess, onFailure);
+        break;
+    }
+}
+
+void ProcessOnOffUnicastBindingCommand(BindingCommandData * data, const EmberBindingTableEntry & binding,
+                                       OperationalDeviceProxy * peer_device)
+{
+    auto onSuccess = [](const ConcreteCommandPath & commandPath, const StatusIB & status, const auto & dataResponse) {
+        ChipLogProgress(NotSpecified, "OnOff command succeeds");
+    };
+
+    auto onFailure = [](CHIP_ERROR error) {
+        ChipLogError(NotSpecified, "OnOff command failed: %" CHIP_ERROR_FORMAT, error.Format());
+    };
+
+    VerifyOrDie(peer_device != nullptr && peer_device->ConnectionReady());
+
+    Clusters::OnOff::Commands::Toggle::Type toggleCommand;
+    Clusters::OnOff::Commands::On::Type onCommand;
+    Clusters::OnOff::Commands::Off::Type offCommand;
+    Clusters::OnOff::Commands::OffWithEffect::Type offwitheffectCommand;
+    Clusters::OnOff::Commands::OnWithRecallGlobalScene::Type onwithrecallglobalsceneCommand;
+    Clusters::OnOff::Commands::OnWithTimedOff::Type onwithtimedoffCommand;
+
+    switch (data->commandId)
+    {
+    case Clusters::OnOff::Commands::Toggle::Id:
+        Controller::InvokeCommandRequest(peer_device->GetExchangeManager(), peer_device->GetSecureSession().Value(), binding.remote,
+                                         toggleCommand, onSuccess, onFailure);
+        break;
+
+    case Clusters::OnOff::Commands::On::Id:
+        Controller::InvokeCommandRequest(peer_device->GetExchangeManager(), peer_device->GetSecureSession().Value(), binding.remote,
+                                         onCommand, onSuccess, onFailure);
+        break;
+
+    case Clusters::OnOff::Commands::Off::Id:
+        Controller::InvokeCommandRequest(peer_device->GetExchangeManager(), peer_device->GetSecureSession().Value(), binding.remote,
+                                         offCommand, onSuccess, onFailure);
+        break;
+
+    case Clusters::OnOff::Commands::OffWithEffect::Id:
+        offwitheffectCommand.effectId      = static_cast<EmberAfOnOffEffectIdentifier>(data->args[0]);
+        offwitheffectCommand.effectVariant = static_cast<EmberAfOnOffDelayedAllOffEffectVariant>(data->args[1]);
+        Controller::InvokeCommandRequest(peer_device->GetExchangeManager(), peer_device->GetSecureSession().Value(), binding.remote,
+                                         offwitheffectCommand, onSuccess, onFailure);
+        break;
+
+    case Clusters::OnOff::Commands::OnWithRecallGlobalScene::Id:
+        Controller::InvokeCommandRequest(peer_device->GetExchangeManager(), peer_device->GetSecureSession().Value(), binding.remote,
+                                         onwithrecallglobalsceneCommand, onSuccess, onFailure);
+        break;
+
+    case Clusters::OnOff::Commands::OnWithTimedOff::Id:
+        onwithtimedoffCommand.onOffControl = static_cast<chip::BitMask<chip::app::Clusters::OnOff::OnOffControl>>(data->args[0]);
+        onwithtimedoffCommand.onTime       = static_cast<uint16_t>(data->args[1]);
+        onwithtimedoffCommand.offWaitTime  = static_cast<uint16_t>(data->args[2]);
+        Controller::InvokeCommandRequest(peer_device->GetExchangeManager(), peer_device->GetSecureSession().Value(), binding.remote,
+                                         onwithtimedoffCommand, onSuccess, onFailure);
+        break;
+    }
+}
+
+void ProcessOnOffGroupBindingCommand(BindingCommandData * data, const EmberBindingTableEntry & binding)
+{
+    Messaging::ExchangeManager & exchangeMgr = Server::GetInstance().GetExchangeManager();
+
+    Clusters::OnOff::Commands::Toggle::Type toggleCommand;
+    Clusters::OnOff::Commands::On::Type onCommand;
+    Clusters::OnOff::Commands::Off::Type offCommand;
+    Clusters::OnOff::Commands::OffWithEffect::Type offwitheffectCommand;
+    Clusters::OnOff::Commands::OnWithRecallGlobalScene::Type onwithrecallglobalsceneCommand;
+    Clusters::OnOff::Commands::OnWithTimedOff::Type onwithtimedoffCommand;
+
+    switch (data->commandId)
+    {
+    case Clusters::OnOff::Commands::Toggle::Id:
+        Controller::InvokeGroupCommandRequest(&exchangeMgr, binding.fabricIndex, binding.groupId, toggleCommand);
+        break;
+
+    case Clusters::OnOff::Commands::On::Id:
+        Controller::InvokeGroupCommandRequest(&exchangeMgr, binding.fabricIndex, binding.groupId, onCommand);
+        break;
+
+    case Clusters::OnOff::Commands::Off::Id:
+        Controller::InvokeGroupCommandRequest(&exchangeMgr, binding.fabricIndex, binding.groupId, offCommand);
+        break;
+
+    case Clusters::OnOff::Commands::OffWithEffect::Id:
+        offwitheffectCommand.effectId      = static_cast<EmberAfOnOffEffectIdentifier>(data->args[0]);
+        offwitheffectCommand.effectVariant = static_cast<EmberAfOnOffDelayedAllOffEffectVariant>(data->args[1]);
+        Controller::InvokeGroupCommandRequest(&exchangeMgr, binding.fabricIndex, binding.groupId, offwitheffectCommand);
+        break;
+
+    case Clusters::OnOff::Commands::OnWithRecallGlobalScene::Id:
+        Controller::InvokeGroupCommandRequest(&exchangeMgr, binding.fabricIndex, binding.groupId, onwithrecallglobalsceneCommand);
+        break;
+
+    case Clusters::OnOff::Commands::OnWithTimedOff::Id:
+        onwithtimedoffCommand.onOffControl = static_cast<chip::BitMask<chip::app::Clusters::OnOff::OnOffControl>>(data->args[0]);
+        onwithtimedoffCommand.onTime       = static_cast<uint16_t>(data->args[1]);
+        onwithtimedoffCommand.offWaitTime  = static_cast<uint16_t>(data->args[2]);
+        Controller::InvokeGroupCommandRequest(&exchangeMgr, binding.fabricIndex, binding.groupId, onwithtimedoffCommand);
+        break;
+    }
+}
+
+#if CONFIG_ENABLE_CHIP_SHELL
+/********************************************************
+ * OnOff switch shell functions
+ *********************************************************/
+
+CHIP_ERROR OnOffHelpHandler(int argc, char ** argv)
+{
+    sShellSwitchOnOffSubCommands.ForEachCommand(Shell::PrintCommandHelp, nullptr);
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR OnOffSwitchCommandHandler(int argc, char ** argv)
+{
+    if (argc == 0)
+    {
+        return OnOffHelpHandler(argc, argv);
+    }
+
+    return sShellSwitchOnOffSubCommands.ExecCommand(argc, argv);
+}
+
+CHIP_ERROR OnSwitchCommandHandler(int argc, char ** argv)
+{
+    BindingCommandData * data = Platform::New<BindingCommandData>();
+    data->commandId           = Clusters::OnOff::Commands::On::Id;
+    data->clusterId           = Clusters::OnOff::Id;
+
+    DeviceLayer::PlatformMgr().ScheduleWork(SwitchWorkerFunction, reinterpret_cast<intptr_t>(data));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR OffSwitchCommandHandler(int argc, char ** argv)
+{
+    BindingCommandData * data = Platform::New<BindingCommandData>();
+    data->commandId           = Clusters::OnOff::Commands::Off::Id;
+    data->clusterId           = Clusters::OnOff::Id;
+
+    DeviceLayer::PlatformMgr().ScheduleWork(SwitchWorkerFunction, reinterpret_cast<intptr_t>(data));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR ToggleSwitchCommandHandler(int argc, char ** argv)
+{
+    BindingCommandData * data = Platform::New<BindingCommandData>();
+    data->commandId           = Clusters::OnOff::Commands::Toggle::Id;
+    data->clusterId           = Clusters::OnOff::Id;
+
+    DeviceLayer::PlatformMgr().ScheduleWork(SwitchWorkerFunction, reinterpret_cast<intptr_t>(data));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR OffWithEffectSwitchCommandHandler(int argc, char ** argv)
+{
+    if (argc != 2)
+    {
+        return OnOffHelpHandler(argc, argv);
+    }
+
+    BindingCommandData * data = Platform::New<BindingCommandData>();
+    data->commandId           = Clusters::OnOff::Commands::OffWithEffect::Id;
+    data->clusterId           = Clusters::OnOff::Id;
+    data->args[0]             = atoi(argv[0]);
+    data->args[1]             = atoi(argv[1]);
+
+    DeviceLayer::PlatformMgr().ScheduleWork(SwitchWorkerFunction, reinterpret_cast<intptr_t>(data));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR OnWithRecallGlobalSceneSwitchCommandHandler(int argc, char ** argv)
+{
+    BindingCommandData * data = Platform::New<BindingCommandData>();
+    data->commandId           = Clusters::OnOff::Commands::OnWithRecallGlobalScene::Id;
+    data->clusterId           = Clusters::OnOff::Id;
+
+    DeviceLayer::PlatformMgr().ScheduleWork(SwitchWorkerFunction, reinterpret_cast<intptr_t>(data));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR OnWithTimedOffSwitchCommandHandler(int argc, char ** argv)
+{
+    if (argc != 3)
+    {
+        return OnOffHelpHandler(argc, argv);
+    }
+
+    BindingCommandData * data = Platform::New<BindingCommandData>();
+    data->commandId           = Clusters::OnOff::Commands::OnWithTimedOff::Id;
+    data->clusterId           = Clusters::OnOff::Id;
+    data->args[0]             = atoi(argv[0]);
+    data->args[1]             = atoi(argv[1]);
+    data->args[2]             = atoi(argv[2]);
+
+    DeviceLayer::PlatformMgr().ScheduleWork(SwitchWorkerFunction, reinterpret_cast<intptr_t>(data));
+    return CHIP_NO_ERROR;
+}
+
+/********************************************************
+ * OnOff Read switch shell functions
+ *********************************************************/
+
+CHIP_ERROR OnOffReadHelpHandler(int argc, char ** argv)
+{
+    sShellSwitchOnOffReadSubCommands.ForEachCommand(Shell::PrintCommandHelp, nullptr);
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR OnOffRead(int argc, char ** argv)
+{
+    if (argc == 0)
+    {
+        return OnOffReadHelpHandler(argc, argv);
+    }
+
+    return sShellSwitchOnOffReadSubCommands.ExecCommand(argc, argv);
+}
+
+CHIP_ERROR OnOffReadAttributeList(int argc, char ** argv)
+{
+    BindingCommandData * data = Platform::New<BindingCommandData>();
+    data->attributeId         = Clusters::OnOff::Attributes::AttributeList::Id;
+    data->clusterId           = Clusters::OnOff::Id;
+    data->isReadAttribute     = true;
+
+    DeviceLayer::PlatformMgr().ScheduleWork(SwitchWorkerFunction, reinterpret_cast<intptr_t>(data));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR OnOffReadOnOff(int argc, char ** argv)
+{
+    BindingCommandData * data = Platform::New<BindingCommandData>();
+    data->attributeId         = Clusters::OnOff::Attributes::OnOff::Id;
+    data->clusterId           = Clusters::OnOff::Id;
+    data->isReadAttribute     = true;
+
+    DeviceLayer::PlatformMgr().ScheduleWork(SwitchWorkerFunction, reinterpret_cast<intptr_t>(data));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR OnOffReadGlobalSceneControl(int argc, char ** argv)
+{
+    BindingCommandData * data = Platform::New<BindingCommandData>();
+    data->attributeId         = Clusters::OnOff::Attributes::GlobalSceneControl::Id;
+    data->clusterId           = Clusters::OnOff::Id;
+    data->isReadAttribute     = true;
+
+    DeviceLayer::PlatformMgr().ScheduleWork(SwitchWorkerFunction, reinterpret_cast<intptr_t>(data));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR OnOffReadOnTime(int argc, char ** argv)
+{
+    BindingCommandData * data = Platform::New<BindingCommandData>();
+    data->attributeId         = Clusters::OnOff::Attributes::OnTime::Id;
+    data->clusterId           = Clusters::OnOff::Id;
+    data->isReadAttribute     = true;
+
+    DeviceLayer::PlatformMgr().ScheduleWork(SwitchWorkerFunction, reinterpret_cast<intptr_t>(data));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR OnOffReadOffWaitTime(int argc, char ** argv)
+{
+    BindingCommandData * data = Platform::New<BindingCommandData>();
+    data->attributeId         = Clusters::OnOff::Attributes::OffWaitTime::Id;
+    data->clusterId           = Clusters::OnOff::Id;
+    data->isReadAttribute     = true;
+
+    DeviceLayer::PlatformMgr().ScheduleWork(SwitchWorkerFunction, reinterpret_cast<intptr_t>(data));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR OnOffReadStartUpOnOff(int argc, char ** argv)
+{
+    BindingCommandData * data = Platform::New<BindingCommandData>();
+    data->attributeId         = Clusters::OnOff::Attributes::StartUpOnOff::Id;
+    data->clusterId           = Clusters::OnOff::Id;
+    data->isReadAttribute     = true;
+
+    DeviceLayer::PlatformMgr().ScheduleWork(SwitchWorkerFunction, reinterpret_cast<intptr_t>(data));
+    return CHIP_NO_ERROR;
+}
+
+/********************************************************
+ * Groups OnOff switch shell functions
+ *********************************************************/
+
+CHIP_ERROR GroupsOnOffHelpHandler(int argc, char ** argv)
+{
+    sShellSwitchGroupsOnOffSubCommands.ForEachCommand(Shell::PrintCommandHelp, nullptr);
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR GroupsOnOffSwitchCommandHandler(int argc, char ** argv)
+{
+    if (argc == 0)
+    {
+        return GroupsOnOffHelpHandler(argc, argv);
+    }
+
+    return sShellSwitchGroupsOnOffSubCommands.ExecCommand(argc, argv);
+}
+
+CHIP_ERROR GroupOnSwitchCommandHandler(int argc, char ** argv)
+{
+    BindingCommandData * data = Platform::New<BindingCommandData>();
+    data->commandId           = Clusters::OnOff::Commands::On::Id;
+    data->clusterId           = Clusters::OnOff::Id;
+    data->isGroup             = true;
+
+    DeviceLayer::PlatformMgr().ScheduleWork(SwitchWorkerFunction, reinterpret_cast<intptr_t>(data));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR GroupOffSwitchCommandHandler(int argc, char ** argv)
+{
+    BindingCommandData * data = Platform::New<BindingCommandData>();
+    data->commandId           = Clusters::OnOff::Commands::Off::Id;
+    data->clusterId           = Clusters::OnOff::Id;
+    data->isGroup             = true;
+
+    DeviceLayer::PlatformMgr().ScheduleWork(SwitchWorkerFunction, reinterpret_cast<intptr_t>(data));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR GroupToggleSwitchCommandHandler(int argc, char ** argv)
+{
+    BindingCommandData * data = Platform::New<BindingCommandData>();
+    data->commandId           = Clusters::OnOff::Commands::Toggle::Id;
+    data->clusterId           = Clusters::OnOff::Id;
+    data->isGroup             = true;
+
+    DeviceLayer::PlatformMgr().ScheduleWork(SwitchWorkerFunction, reinterpret_cast<intptr_t>(data));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR GroupOffWithEffectSwitchCommandHandler(int argc, char ** argv)
+{
+    if (argc != 2)
+    {
+        return GroupsOnOffHelpHandler(argc, argv);
+    }
+
+    BindingCommandData * data = Platform::New<BindingCommandData>();
+    data->commandId           = Clusters::OnOff::Commands::OffWithEffect::Id;
+    data->clusterId           = Clusters::OnOff::Id;
+    data->args[0]             = atoi(argv[0]);
+    data->args[1]             = atoi(argv[1]);
+    data->isGroup             = true;
+
+    DeviceLayer::PlatformMgr().ScheduleWork(SwitchWorkerFunction, reinterpret_cast<intptr_t>(data));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR GroupOnWithRecallGlobalSceneSwitchCommandHandler(int argc, char ** argv)
+{
+    BindingCommandData * data = Platform::New<BindingCommandData>();
+    data->commandId           = Clusters::OnOff::Commands::OnWithRecallGlobalScene::Id;
+    data->clusterId           = Clusters::OnOff::Id;
+    data->isGroup             = true;
+
+    DeviceLayer::PlatformMgr().ScheduleWork(SwitchWorkerFunction, reinterpret_cast<intptr_t>(data));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR GroupOnWithTimedOffSwitchCommandHandler(int argc, char ** argv)
+{
+    if (argc != 2)
+    {
+        return GroupsOnOffHelpHandler(argc, argv);
+    }
+
+    BindingCommandData * data = Platform::New<BindingCommandData>();
+    data->commandId           = Clusters::OnOff::Commands::OnWithTimedOff::Id;
+    data->clusterId           = Clusters::OnOff::Id;
+    data->args[0]             = atoi(argv[0]);
+    data->args[1]             = atoi(argv[1]);
+    data->args[2]             = atoi(argv[2]);
+    data->isGroup             = true;
+
+    DeviceLayer::PlatformMgr().ScheduleWork(SwitchWorkerFunction, reinterpret_cast<intptr_t>(data));
+    return CHIP_NO_ERROR;
+}
+#endif // CONFIG_ENABLE_CHIP_SHELL
diff --git a/examples/all-clusters-app/ameba/main/include/ThermostatCommands.h b/examples/all-clusters-app/ameba/main/include/ThermostatCommands.h
new file mode 100644
index 00000000000000..c1444bf332c0ab
--- /dev/null
+++ b/examples/all-clusters-app/ameba/main/include/ThermostatCommands.h
@@ -0,0 +1,445 @@
+/*
+ *
+ *    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 "controller/InvokeInteraction.h"
+#include "controller/ReadInteraction.h"
+#include <app/clusters/bindings/bindings.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 sShellSwitchThermostatSubCommands;
+Engine sShellSwitchThermostatReadSubCommands;
+Engine sShellSwitchGroupsThermostatSubCommands;
+#endif // defined(ENABLE_CHIP_SHELL)
+
+void ProcessThermostatUnicastBindingRead(BindingCommandData * data, const EmberBindingTableEntry & binding,
+                                         OperationalDeviceProxy * peer_device)
+{
+    auto onSuccess = [](const ConcreteDataAttributePath & attributePath, const auto & dataResponse) {
+        ChipLogProgress(NotSpecified, "Read Thermostat attribute succeeds");
+    };
+
+    auto onFailure = [](const ConcreteDataAttributePath * attributePath, CHIP_ERROR error) {
+        ChipLogError(NotSpecified, "Read Thermostat attribute failed: %" CHIP_ERROR_FORMAT, error.Format());
+    };
+
+    VerifyOrDie(peer_device != nullptr && peer_device->ConnectionReady());
+
+    switch (data->attributeId)
+    {
+    case Clusters::Thermostat::Attributes::AttributeList::Id:
+        Controller::ReadAttribute<Clusters::Thermostat::Attributes::AttributeList::TypeInfo>(
+            peer_device->GetExchangeManager(), peer_device->GetSecureSession().Value(), binding.remote, onSuccess, onFailure);
+        break;
+
+    case Clusters::Thermostat::Attributes::LocalTemperature::Id:
+        Controller::ReadAttribute<Clusters::Thermostat::Attributes::LocalTemperature::TypeInfo>(
+            peer_device->GetExchangeManager(), peer_device->GetSecureSession().Value(), binding.remote, onSuccess, onFailure);
+        break;
+
+    case Clusters::Thermostat::Attributes::AbsMinHeatSetpointLimit::Id:
+        Controller::ReadAttribute<Clusters::Thermostat::Attributes::AbsMinHeatSetpointLimit::TypeInfo>(
+            peer_device->GetExchangeManager(), peer_device->GetSecureSession().Value(), binding.remote, onSuccess, onFailure);
+        break;
+
+    case Clusters::Thermostat::Attributes::AbsMaxHeatSetpointLimit::Id:
+        Controller::ReadAttribute<Clusters::Thermostat::Attributes::AbsMaxHeatSetpointLimit::TypeInfo>(
+            peer_device->GetExchangeManager(), peer_device->GetSecureSession().Value(), binding.remote, onSuccess, onFailure);
+        break;
+
+    case Clusters::Thermostat::Attributes::AbsMinCoolSetpointLimit::Id:
+        Controller::ReadAttribute<Clusters::Thermostat::Attributes::AbsMinCoolSetpointLimit::TypeInfo>(
+            peer_device->GetExchangeManager(), peer_device->GetSecureSession().Value(), binding.remote, onSuccess, onFailure);
+        break;
+
+    case Clusters::Thermostat::Attributes::AbsMaxCoolSetpointLimit::Id:
+        Controller::ReadAttribute<Clusters::Thermostat::Attributes::AbsMaxCoolSetpointLimit::TypeInfo>(
+            peer_device->GetExchangeManager(), peer_device->GetSecureSession().Value(), binding.remote, onSuccess, onFailure);
+        break;
+
+    case Clusters::Thermostat::Attributes::PICoolingDemand::Id:
+        Controller::ReadAttribute<Clusters::Thermostat::Attributes::PICoolingDemand::TypeInfo>(
+            peer_device->GetExchangeManager(), peer_device->GetSecureSession().Value(), binding.remote, onSuccess, onFailure);
+        break;
+
+    case Clusters::Thermostat::Attributes::PIHeatingDemand::Id:
+        Controller::ReadAttribute<Clusters::Thermostat::Attributes::PIHeatingDemand::TypeInfo>(
+            peer_device->GetExchangeManager(), peer_device->GetSecureSession().Value(), binding.remote, onSuccess, onFailure);
+        break;
+
+    case Clusters::Thermostat::Attributes::OccupiedCoolingSetpoint::Id:
+        Controller::ReadAttribute<Clusters::Thermostat::Attributes::OccupiedCoolingSetpoint::TypeInfo>(
+            peer_device->GetExchangeManager(), peer_device->GetSecureSession().Value(), binding.remote, onSuccess, onFailure);
+        break;
+
+    case Clusters::Thermostat::Attributes::OccupiedHeatingSetpoint::Id:
+        Controller::ReadAttribute<Clusters::Thermostat::Attributes::OccupiedHeatingSetpoint::TypeInfo>(
+            peer_device->GetExchangeManager(), peer_device->GetSecureSession().Value(), binding.remote, onSuccess, onFailure);
+        break;
+
+    case Clusters::Thermostat::Attributes::MinHeatSetpointLimit::Id:
+        Controller::ReadAttribute<Clusters::Thermostat::Attributes::MinHeatSetpointLimit::TypeInfo>(
+            peer_device->GetExchangeManager(), peer_device->GetSecureSession().Value(), binding.remote, onSuccess, onFailure);
+        break;
+
+    case Clusters::Thermostat::Attributes::MaxHeatSetpointLimit::Id:
+        Controller::ReadAttribute<Clusters::Thermostat::Attributes::MaxHeatSetpointLimit::TypeInfo>(
+            peer_device->GetExchangeManager(), peer_device->GetSecureSession().Value(), binding.remote, onSuccess, onFailure);
+        break;
+
+    case Clusters::Thermostat::Attributes::MinCoolSetpointLimit::Id:
+        Controller::ReadAttribute<Clusters::Thermostat::Attributes::MinCoolSetpointLimit::TypeInfo>(
+            peer_device->GetExchangeManager(), peer_device->GetSecureSession().Value(), binding.remote, onSuccess, onFailure);
+        break;
+
+    case Clusters::Thermostat::Attributes::MaxCoolSetpointLimit::Id:
+        Controller::ReadAttribute<Clusters::Thermostat::Attributes::MaxCoolSetpointLimit::TypeInfo>(
+            peer_device->GetExchangeManager(), peer_device->GetSecureSession().Value(), binding.remote, onSuccess, onFailure);
+        break;
+
+    case Clusters::Thermostat::Attributes::ControlSequenceOfOperation::Id:
+        Controller::ReadAttribute<Clusters::Thermostat::Attributes::ControlSequenceOfOperation::TypeInfo>(
+            peer_device->GetExchangeManager(), peer_device->GetSecureSession().Value(), binding.remote, onSuccess, onFailure);
+        break;
+
+    case Clusters::Thermostat::Attributes::SystemMode::Id:
+        Controller::ReadAttribute<Clusters::Thermostat::Attributes::SystemMode::TypeInfo>(
+            peer_device->GetExchangeManager(), peer_device->GetSecureSession().Value(), binding.remote, onSuccess, onFailure);
+        break;
+    }
+}
+
+void ProcessThermostatUnicastBindingCommand(BindingCommandData * data, const EmberBindingTableEntry & binding,
+                                            OperationalDeviceProxy * peer_device)
+{
+    auto onSuccess = [](const ConcreteCommandPath & commandPath, const StatusIB & status, const auto & dataResponse) {
+        ChipLogProgress(NotSpecified, "Thermostat command succeeds");
+    };
+
+    auto onFailure = [](CHIP_ERROR error) {
+        ChipLogError(NotSpecified, "Thermostat command failed: %" CHIP_ERROR_FORMAT, error.Format());
+    };
+
+    VerifyOrDie(peer_device != nullptr && peer_device->ConnectionReady());
+
+    Clusters::Thermostat::Commands::SetpointRaiseLower::Type setpointRaiseLowerCommand;
+
+    switch (data->commandId)
+    {
+    case Clusters::Thermostat::Commands::SetpointRaiseLower::Id:
+        setpointRaiseLowerCommand.mode   = static_cast<EmberAfSetpointAdjustMode>(data->args[0]);
+        setpointRaiseLowerCommand.amount = static_cast<int8_t>(data->args[1]);
+        Controller::InvokeCommandRequest(peer_device->GetExchangeManager(), peer_device->GetSecureSession().Value(), binding.remote,
+                                         setpointRaiseLowerCommand, onSuccess, onFailure);
+        break;
+    }
+}
+
+void ProcessThermostatGroupBindingCommand(BindingCommandData * data, const EmberBindingTableEntry & binding)
+{
+    Messaging::ExchangeManager & exchangeMgr = Server::GetInstance().GetExchangeManager();
+
+    Clusters::Thermostat::Commands::SetpointRaiseLower::Type setpointRaiseLowerCommand;
+
+    switch (data->commandId)
+    {
+    case Clusters::Thermostat::Commands::SetpointRaiseLower::Id:
+        setpointRaiseLowerCommand.mode   = static_cast<EmberAfSetpointAdjustMode>(data->args[0]);
+        setpointRaiseLowerCommand.amount = static_cast<int8_t>(data->args[1]);
+        Controller::InvokeGroupCommandRequest(&exchangeMgr, binding.fabricIndex, binding.groupId, setpointRaiseLowerCommand);
+        break;
+    }
+}
+
+#if CONFIG_ENABLE_CHIP_SHELL
+/********************************************************
+ * Thermostat switch shell functions
+ *********************************************************/
+
+CHIP_ERROR ThermostatHelpHandler(int argc, char ** argv)
+{
+    sShellSwitchThermostatSubCommands.ForEachCommand(Shell::PrintCommandHelp, nullptr);
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR ThermostatSwitchCommandHandler(int argc, char ** argv)
+{
+    if (argc == 0)
+    {
+        return ThermostatHelpHandler(argc, argv);
+    }
+
+    return sShellSwitchThermostatSubCommands.ExecCommand(argc, argv);
+}
+
+CHIP_ERROR SetpointRaiseLowerSwitchCommandHandler(int argc, char ** argv)
+{
+    if (argc != 2)
+    {
+        return ThermostatHelpHandler(argc, argv);
+    }
+
+    BindingCommandData * data = Platform::New<BindingCommandData>();
+    data->commandId           = Clusters::Thermostat::Commands::SetpointRaiseLower::Id;
+    data->clusterId           = Clusters::Thermostat::Id;
+    data->args[0]             = atoi(argv[0]);
+    data->args[1]             = atoi(argv[1]);
+
+    DeviceLayer::PlatformMgr().ScheduleWork(SwitchWorkerFunction, reinterpret_cast<intptr_t>(data));
+    return CHIP_NO_ERROR;
+}
+
+/********************************************************
+ * Thermostat Read switch shell functions
+ *********************************************************/
+
+CHIP_ERROR ThermostatReadHelpHandler(int argc, char ** argv)
+{
+    sShellSwitchThermostatReadSubCommands.ForEachCommand(Shell::PrintCommandHelp, nullptr);
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR ThermostatRead(int argc, char ** argv)
+{
+    if (argc == 0)
+    {
+        return ThermostatReadHelpHandler(argc, argv);
+    }
+
+    return sShellSwitchThermostatReadSubCommands.ExecCommand(argc, argv);
+}
+
+CHIP_ERROR ThermostatReadAttributeList(int argc, char ** argv)
+{
+    BindingCommandData * data = Platform::New<BindingCommandData>();
+    data->attributeId         = Clusters::Thermostat::Attributes::AttributeList::Id;
+    data->clusterId           = Clusters::Thermostat::Id;
+    data->isReadAttribute     = true;
+
+    DeviceLayer::PlatformMgr().ScheduleWork(SwitchWorkerFunction, reinterpret_cast<intptr_t>(data));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR ThermostatReadLocalTemperature(int argc, char ** argv)
+{
+    BindingCommandData * data = Platform::New<BindingCommandData>();
+    data->attributeId         = Clusters::Thermostat::Attributes::LocalTemperature::Id;
+    data->clusterId           = Clusters::Thermostat::Id;
+    data->isReadAttribute     = true;
+
+    DeviceLayer::PlatformMgr().ScheduleWork(SwitchWorkerFunction, reinterpret_cast<intptr_t>(data));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR ThermostatReadAbsMinHeatSetpointLimit(int argc, char ** argv)
+{
+    BindingCommandData * data = Platform::New<BindingCommandData>();
+    data->attributeId         = Clusters::Thermostat::Attributes::AbsMinHeatSetpointLimit::Id;
+    data->clusterId           = Clusters::Thermostat::Id;
+    data->isReadAttribute     = true;
+
+    DeviceLayer::PlatformMgr().ScheduleWork(SwitchWorkerFunction, reinterpret_cast<intptr_t>(data));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR ThermostatReadAbsMaxHeatSetpointLimit(int argc, char ** argv)
+{
+    BindingCommandData * data = Platform::New<BindingCommandData>();
+    data->attributeId         = Clusters::Thermostat::Attributes::AbsMaxHeatSetpointLimit::Id;
+    data->clusterId           = Clusters::Thermostat::Id;
+    data->isReadAttribute     = true;
+
+    DeviceLayer::PlatformMgr().ScheduleWork(SwitchWorkerFunction, reinterpret_cast<intptr_t>(data));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR ThermostatReadAbsMinCoolSetpointLimit(int argc, char ** argv)
+{
+    BindingCommandData * data = Platform::New<BindingCommandData>();
+    data->attributeId         = Clusters::Thermostat::Attributes::AbsMinCoolSetpointLimit::Id;
+    data->clusterId           = Clusters::Thermostat::Id;
+    data->isReadAttribute     = true;
+
+    DeviceLayer::PlatformMgr().ScheduleWork(SwitchWorkerFunction, reinterpret_cast<intptr_t>(data));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR ThermostatReadAbsMaxCoolSetpointLimit(int argc, char ** argv)
+{
+    BindingCommandData * data = Platform::New<BindingCommandData>();
+    data->attributeId         = Clusters::Thermostat::Attributes::AbsMaxCoolSetpointLimit::Id;
+    data->clusterId           = Clusters::Thermostat::Id;
+    data->isReadAttribute     = true;
+
+    DeviceLayer::PlatformMgr().ScheduleWork(SwitchWorkerFunction, reinterpret_cast<intptr_t>(data));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR ThermostatReadPiCoolingDemand(int argc, char ** argv)
+{
+    BindingCommandData * data = Platform::New<BindingCommandData>();
+    data->attributeId         = Clusters::Thermostat::Attributes::PICoolingDemand::Id;
+    data->clusterId           = Clusters::Thermostat::Id;
+    data->isReadAttribute     = true;
+
+    DeviceLayer::PlatformMgr().ScheduleWork(SwitchWorkerFunction, reinterpret_cast<intptr_t>(data));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR ThermostatReadPiHeatingDemand(int argc, char ** argv)
+{
+    BindingCommandData * data = Platform::New<BindingCommandData>();
+    data->attributeId         = Clusters::Thermostat::Attributes::PIHeatingDemand::Id;
+    data->clusterId           = Clusters::Thermostat::Id;
+    data->isReadAttribute     = true;
+
+    DeviceLayer::PlatformMgr().ScheduleWork(SwitchWorkerFunction, reinterpret_cast<intptr_t>(data));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR ThermostatReadOccupiedCoolingSetpoint(int argc, char ** argv)
+{
+    BindingCommandData * data = Platform::New<BindingCommandData>();
+    data->attributeId         = Clusters::Thermostat::Attributes::OccupiedCoolingSetpoint::Id;
+    data->clusterId           = Clusters::Thermostat::Id;
+    data->isReadAttribute     = true;
+
+    DeviceLayer::PlatformMgr().ScheduleWork(SwitchWorkerFunction, reinterpret_cast<intptr_t>(data));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR ThermostatReadOccupiedHeatingSetpoint(int argc, char ** argv)
+{
+    BindingCommandData * data = Platform::New<BindingCommandData>();
+    data->attributeId         = Clusters::Thermostat::Attributes::OccupiedHeatingSetpoint::Id;
+    data->clusterId           = Clusters::Thermostat::Id;
+    data->isReadAttribute     = true;
+
+    DeviceLayer::PlatformMgr().ScheduleWork(SwitchWorkerFunction, reinterpret_cast<intptr_t>(data));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR ThermostatReadMinHeatSetpointLimit(int argc, char ** argv)
+{
+    BindingCommandData * data = Platform::New<BindingCommandData>();
+    data->attributeId         = Clusters::Thermostat::Attributes::MinHeatSetpointLimit::Id;
+    data->clusterId           = Clusters::Thermostat::Id;
+    data->isReadAttribute     = true;
+
+    DeviceLayer::PlatformMgr().ScheduleWork(SwitchWorkerFunction, reinterpret_cast<intptr_t>(data));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR ThermostatReadMaxHeatSetpointLimit(int argc, char ** argv)
+{
+    BindingCommandData * data = Platform::New<BindingCommandData>();
+    data->attributeId         = Clusters::Thermostat::Attributes::MaxHeatSetpointLimit::Id;
+    data->clusterId           = Clusters::Thermostat::Id;
+    data->isReadAttribute     = true;
+
+    DeviceLayer::PlatformMgr().ScheduleWork(SwitchWorkerFunction, reinterpret_cast<intptr_t>(data));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR ThermostatReadMinCoolSetpointLimit(int argc, char ** argv)
+{
+    BindingCommandData * data = Platform::New<BindingCommandData>();
+    data->attributeId         = Clusters::Thermostat::Attributes::MinCoolSetpointLimit::Id;
+    data->clusterId           = Clusters::Thermostat::Id;
+    data->isReadAttribute     = true;
+
+    DeviceLayer::PlatformMgr().ScheduleWork(SwitchWorkerFunction, reinterpret_cast<intptr_t>(data));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR ThermostatReadMaxCoolSetpointLimit(int argc, char ** argv)
+{
+    BindingCommandData * data = Platform::New<BindingCommandData>();
+    data->attributeId         = Clusters::Thermostat::Attributes::MaxCoolSetpointLimit::Id;
+    data->clusterId           = Clusters::Thermostat::Id;
+    data->isReadAttribute     = true;
+
+    DeviceLayer::PlatformMgr().ScheduleWork(SwitchWorkerFunction, reinterpret_cast<intptr_t>(data));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR ThermostatReadControlSequenceOfOperation(int argc, char ** argv)
+{
+    BindingCommandData * data = Platform::New<BindingCommandData>();
+    data->attributeId         = Clusters::Thermostat::Attributes::ControlSequenceOfOperation::Id;
+    data->clusterId           = Clusters::Thermostat::Id;
+    data->isReadAttribute     = true;
+
+    DeviceLayer::PlatformMgr().ScheduleWork(SwitchWorkerFunction, reinterpret_cast<intptr_t>(data));
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR ThermostatReadSystemMode(int argc, char ** argv)
+{
+    BindingCommandData * data = Platform::New<BindingCommandData>();
+    data->attributeId         = Clusters::Thermostat::Attributes::SystemMode::Id;
+    data->clusterId           = Clusters::Thermostat::Id;
+    data->isReadAttribute     = true;
+
+    DeviceLayer::PlatformMgr().ScheduleWork(SwitchWorkerFunction, reinterpret_cast<intptr_t>(data));
+    return CHIP_NO_ERROR;
+}
+
+/********************************************************
+ * Groups Thermostat switch shell functions
+ *********************************************************/
+
+CHIP_ERROR GroupsThermostatHelpHandler(int argc, char ** argv)
+{
+    sShellSwitchGroupsThermostatSubCommands.ForEachCommand(Shell::PrintCommandHelp, nullptr);
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR GroupsThermostatSwitchCommandHandler(int argc, char ** argv)
+{
+    if (argc == 0)
+    {
+        return GroupsThermostatHelpHandler(argc, argv);
+    }
+
+    return sShellSwitchGroupsThermostatSubCommands.ExecCommand(argc, argv);
+}
+
+CHIP_ERROR GroupsSetpointRaiseLowerSwitchCommandHandler(int argc, char ** argv)
+{
+    BindingCommandData * data = Platform::New<BindingCommandData>();
+    data->commandId           = Clusters::Thermostat::Commands::SetpointRaiseLower::Id;
+    data->clusterId           = Clusters::Thermostat::Id;
+    data->isGroup             = true;
+
+    DeviceLayer::PlatformMgr().ScheduleWork(SwitchWorkerFunction, reinterpret_cast<intptr_t>(data));
+    return CHIP_NO_ERROR;
+}
+#endif // CONFIG_ENABLE_CHIP_SHELL