src/app/encoder.cpp

   1 /*
   2  *
   3  *    Copyright (c) 2021 Project CHIP Authors
   4  *
   5  *    Licensed under the Apache License, Version 2.0 (the "License");
   6  *    you may not use this file except in compliance with the License.
   7  *    You may obtain a copy of the License at
   8  *
   9  *        http://www.apache.org/licenses/LICENSE-2.0
  10  *
  11  *    Unless required by applicable law or agreed to in writing, software
  12  *    distributed under the License is distributed on an "AS IS" BASIS,
  13  *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  14  *    See the License for the specific language governing permissions and
  15  *    limitations under the License.
  16  */
  17
  18 // THIS FILE IS GENERATED BY ZAP
  19
  20 #include "chip-zcl-zpro-codec.h"
  21
  22 #include <support/BufferWriter.h>
  23 #include <support/SafeInt.h>
  24 #include <support/logging/CHIPLogging.h>
  25
  26 #include <app/util/basic-types.h>
  27 #include <lib/support/Span.h>
  28
  29 using namespace chip;
  30 using namespace chip::System;
  31 using namespace chip::Encoding::LittleEndian;
  32
  33 static uint16_t doEncodeApsFrame(BufferWriter & buf, ClusterId clusterId, EndpointId sourceEndpoint, EndpointId destinationEndpoint,
  34                                  EmberApsOption options, GroupId groupId, uint8_t sequence, uint8_t radius, bool isMeasuring)
  35 {
  36
  37     uint8_t control_byte = 0;
  38     buf.Put(control_byte) // Put in a control byte
  39         .Put16(clusterId)
  40         .Put8(sourceEndpoint)
  41         .Put8(destinationEndpoint)
  42         .EndianPut(options, sizeof(EmberApsOption))
  43         .Put16(groupId)
  44         .Put8(sequence)
  45         .Put8(radius);
  46
  47     size_t result = buf.Needed();
  48     if (isMeasuring)
  49     {
  50         ChipLogDetail(Zcl, "Measured APS frame size %d", result);
  51     }
  52     else if (buf.Fit())
  53     {
  54         ChipLogDetail(Zcl, "Successfully encoded %d bytes", result);
  55     }
  56     else
  57     {
  58         ChipLogError(Zcl, "Error encoding APS Frame: Buffer too small");
  59         result = 0;
  60     }
  61
  62     if (!CanCastTo<uint16_t>(result))
  63     {
  64         ChipLogError(Zcl, "Can't fit our measured size in uint16_t");
  65         result = 0;
  66     }
  67
  68     return static_cast<uint16_t>(result);
  69 }
  70
  71 uint16_t encodeApsFrame(uint8_t * buffer, uint16_t buf_length, EmberApsFrame * apsFrame)
  72 {
  73     BufferWriter buf(buffer, buf_length);
  74     return doEncodeApsFrame(buf, apsFrame->clusterId, apsFrame->sourceEndpoint, apsFrame->destinationEndpoint, apsFrame->options,
  75                             apsFrame->groupId, apsFrame->sequence, apsFrame->radius, !buffer);
  76 }
  77
  78 #define COMMAND_HEADER(name, clusterId)                                                                                            \
  79     const char * kName = name;                                                                                                     \
  80                                                                                                                                    \
  81     PacketBufferWriter buf(System::PacketBufferHandle::New(kMaxBufferSize));                                                       \
  82     if (buf.IsNull())                                                                                                              \
  83     {                                                                                                                              \
  84         ChipLogError(Zcl, "Could not allocate packet buffer while trying to encode %s command", kName);                            \
  85         return PacketBufferHandle();                                                                                               \
  86     }                                                                                                                              \
  87                                                                                                                                    \
  88     if (doEncodeApsFrame(buf, clusterId, kSourceEndpoint, destinationEndpoint, 0, 0, 0, 0, false))                                 \
  89     {
  90
  91 #define COMMAND_FOOTER()                                                                                                           \
  92     }                                                                                                                              \
  93     if (!buf.Fit())                                                                                                                \
  94     {                                                                                                                              \
  95         ChipLogError(Zcl, "Command %s can't fit in the allocated buffer", kName);                                                  \
  96     }                                                                                                                              \
  97     return buf.Finalize();
  98
  99 /*----------------------------------------------------------------------------*\
 100 | Cluster Name                                                        |   ID   |
 101 |---------------------------------------------------------------------+--------|
 102 | ApplicationBasic                                                    | 0x050D |
 103 | BarrierControl                                                      | 0x0103 |
 104 | Basic                                                               | 0x0028 |
 105 | Binding                                                             | 0xF000 |
 106 | ColorControl                                                        | 0x0300 |
 107 | ContentLaunch                                                       | 0xF002 |
 108 | DoorLock                                                            | 0x0101 |
 109 | GeneralCommissioning                                                | 0x0030 |
 110 | Groups                                                              | 0x0004 |
 111 | IasZone                                                             | 0x0500 |
 112 | Identify                                                            | 0x0003 |
 113 | LevelControl                                                        | 0x0008 |
 114 | LowPower                                                            | 0x0508 |
 115 | MediaPlayback                                                       | 0xF001 |
 116 | NetworkCommissioning                                                | 0xAAAA |
 117 | OnOff                                                               | 0x0006 |
 118 | Scenes                                                              | 0x0005 |
 119 | TemperatureMeasurement                                              | 0x0402 |
 120 \*----------------------------------------------------------------------------*/
 121
 122 #define EMBER_ZCL_REPORTING_DIRECTION_REPORTED 0x00
 123
 124 #define ZCL_READ_ATTRIBUTES_COMMAND_ID (0x00)
 125 #define ZCL_READ_ATTRIBUTES_RESPONSE_COMMAND_ID (0x01)
 126 #define ZCL_WRITE_ATTRIBUTES_COMMAND_ID (0x02)
 127 #define ZCL_WRITE_ATTRIBUTES_UNDIVIDED_COMMAND_ID (0x03)
 128 #define ZCL_WRITE_ATTRIBUTES_RESPONSE_COMMAND_ID (0x04)
 129 #define ZCL_WRITE_ATTRIBUTES_NO_RESPONSE_COMMAND_ID (0x05)
 130 #define ZCL_CONFIGURE_REPORTING_COMMAND_ID (0x06)
 131 #define ZCL_CONFIGURE_REPORTING_RESPONSE_COMMAND_ID (0x07)
 132 #define ZCL_READ_REPORTING_CONFIGURATION_COMMAND_ID (0x08)
 133 #define ZCL_READ_REPORTING_CONFIGURATION_RESPONSE_COMMAND_ID (0x09)
 134 #define ZCL_REPORT_ATTRIBUTES_COMMAND_ID (0x0A)
 135 #define ZCL_DEFAULT_RESPONSE_COMMAND_ID (0x0B)
 136 #define ZCL_DISCOVER_ATTRIBUTES_COMMAND_ID (0x0C)
 137 #define ZCL_DISCOVER_ATTRIBUTES_RESPONSE_COMMAND_ID (0x0D)
 138 #define ZCL_READ_ATTRIBUTES_STRUCTURED_COMMAND_ID (0x0E)
 139 #define ZCL_WRITE_ATTRIBUTES_STRUCTURED_COMMAND_ID (0x0F)
 140 #define ZCL_WRITE_ATTRIBUTES_STRUCTURED_RESPONSE_COMMAND_ID (0x10)
 141 #define ZCL_DISCOVER_COMMANDS_RECEIVED_COMMAND_ID (0x11)
 142 #define ZCL_DISCOVER_COMMANDS_RECEIVED_RESPONSE_COMMAND_ID (0x12)
 143 #define ZCL_DISCOVER_COMMANDS_GENERATED_COMMAND_ID (0x13)
 144 #define ZCL_DISCOVER_COMMANDS_GENERATED_RESPONSE_COMMAND_ID (0x14)
 145 #define ZCL_DISCOVER_ATTRIBUTES_EXTENDED_COMMAND_ID (0x15)
 146 #define ZCL_DISCOVER_ATTRIBUTES_EXTENDED_RESPONSE_COMMAND_ID (0x16)
 147
 148 #define APPLICATION_BASIC_CLUSTER_ID 0x050D
 149
 150 #define BARRIER_CONTROL_CLUSTER_ID 0x0103
 151 #define ZCL_BARRIER_CONTROL_GO_TO_PERCENT_COMMAND_ID (0x00)
 152 #define ZCL_BARRIER_CONTROL_STOP_COMMAND_ID (0x01)
 153
 154 #define BASIC_CLUSTER_ID 0x0028
 155 #define ZCL_MFG_SPECIFIC_PING_COMMAND_ID (0x00)
 156
 157 #define BINDING_CLUSTER_ID 0xF000
 158 #define ZCL_BIND_COMMAND_ID (0x00)
 159 #define ZCL_UNBIND_COMMAND_ID (0x01)
 160
 161 #define COLOR_CONTROL_CLUSTER_ID 0x0300
 162 #define ZCL_MOVE_COLOR_COMMAND_ID (0x08)
 163 #define ZCL_MOVE_COLOR_TEMPERATURE_COMMAND_ID (0x4B)
 164 #define ZCL_MOVE_HUE_COMMAND_ID (0x01)
 165 #define ZCL_MOVE_SATURATION_COMMAND_ID (0x04)
 166 #define ZCL_MOVE_TO_COLOR_COMMAND_ID (0x07)
 167 #define ZCL_MOVE_TO_COLOR_TEMPERATURE_COMMAND_ID (0x0A)
 168 #define ZCL_MOVE_TO_HUE_COMMAND_ID (0x00)
 169 #define ZCL_MOVE_TO_HUE_AND_SATURATION_COMMAND_ID (0x06)
 170 #define ZCL_MOVE_TO_SATURATION_COMMAND_ID (0x03)
 171 #define ZCL_STEP_COLOR_COMMAND_ID (0x09)
 172 #define ZCL_STEP_COLOR_TEMPERATURE_COMMAND_ID (0x4C)
 173 #define ZCL_STEP_HUE_COMMAND_ID (0x02)
 174 #define ZCL_STEP_SATURATION_COMMAND_ID (0x05)
 175 #define ZCL_STOP_MOVE_STEP_COMMAND_ID (0x47)
 176
 177 #define CONTENT_LAUNCH_CLUSTER_ID 0xF002
 178 #define ZCL_LAUNCH_CONTENT_COMMAND_ID (0x00)
 179 #define ZCL_LAUNCH_URL_COMMAND_ID (0x01)
 180
 181 #define DOOR_LOCK_CLUSTER_ID 0x0101
 182 #define ZCL_CLEAR_ALL_PINS_COMMAND_ID (0x08)
 183 #define ZCL_CLEAR_ALL_RFIDS_COMMAND_ID (0x19)
 184 #define ZCL_CLEAR_HOLIDAY_SCHEDULE_COMMAND_ID (0x13)
 185 #define ZCL_CLEAR_PIN_COMMAND_ID (0x07)
 186 #define ZCL_CLEAR_RFID_COMMAND_ID (0x18)
 187 #define ZCL_CLEAR_WEEKDAY_SCHEDULE_COMMAND_ID (0x0D)
 188 #define ZCL_CLEAR_YEARDAY_SCHEDULE_COMMAND_ID (0x10)
 189 #define ZCL_GET_HOLIDAY_SCHEDULE_COMMAND_ID (0x12)
 190 #define ZCL_GET_LOG_RECORD_COMMAND_ID (0x04)
 191 #define ZCL_GET_PIN_COMMAND_ID (0x06)
 192 #define ZCL_GET_RFID_COMMAND_ID (0x17)
 193 #define ZCL_GET_USER_TYPE_COMMAND_ID (0x15)
 194 #define ZCL_GET_WEEKDAY_SCHEDULE_COMMAND_ID (0x0C)
 195 #define ZCL_GET_YEARDAY_SCHEDULE_COMMAND_ID (0x0F)
 196 #define ZCL_LOCK_DOOR_COMMAND_ID (0x00)
 197 #define ZCL_SET_HOLIDAY_SCHEDULE_COMMAND_ID (0x11)
 198 #define ZCL_SET_PIN_COMMAND_ID (0x05)
 199 #define ZCL_SET_RFID_COMMAND_ID (0x16)
 200 #define ZCL_SET_USER_TYPE_COMMAND_ID (0x14)
 201 #define ZCL_SET_WEEKDAY_SCHEDULE_COMMAND_ID (0x0B)
 202 #define ZCL_SET_YEARDAY_SCHEDULE_COMMAND_ID (0x0E)
 203 #define ZCL_UNLOCK_DOOR_COMMAND_ID (0x01)
 204 #define ZCL_UNLOCK_WITH_TIMEOUT_COMMAND_ID (0x03)
 205
 206 #define GENERAL_COMMISSIONING_CLUSTER_ID 0x0030
 207 #define ZCL_ARM_FAIL_SAFE_COMMAND_ID (0x02)
 208 #define ZCL_COMMISSIONING_COMPLETE_COMMAND_ID (0x06)
 209 #define ZCL_SET_FABRIC_COMMAND_ID (0x00)
 210
 211 #define GROUPS_CLUSTER_ID 0x0004
 212 #define ZCL_ADD_GROUP_COMMAND_ID (0x00)
 213 #define ZCL_ADD_GROUP_IF_IDENTIFYING_COMMAND_ID (0x05)
 214 #define ZCL_GET_GROUP_MEMBERSHIP_COMMAND_ID (0x02)
 215 #define ZCL_REMOVE_ALL_GROUPS_COMMAND_ID (0x04)
 216 #define ZCL_REMOVE_GROUP_COMMAND_ID (0x03)
 217 #define ZCL_VIEW_GROUP_COMMAND_ID (0x01)
 218
 219 #define IAS_ZONE_CLUSTER_ID 0x0500
 220
 221 #define IDENTIFY_CLUSTER_ID 0x0003
 222 #define ZCL_IDENTIFY_COMMAND_ID (0x00)
 223 #define ZCL_IDENTIFY_QUERY_COMMAND_ID (0x01)
 224
 225 #define LEVEL_CONTROL_CLUSTER_ID 0x0008
 226 #define ZCL_MOVE_COMMAND_ID (0x01)
 227 #define ZCL_MOVE_TO_LEVEL_COMMAND_ID (0x00)
 228 #define ZCL_MOVE_TO_LEVEL_WITH_ON_OFF_COMMAND_ID (0x04)
 229 #define ZCL_MOVE_WITH_ON_OFF_COMMAND_ID (0x05)
 230 #define ZCL_STEP_COMMAND_ID (0x02)
 231 #define ZCL_STEP_WITH_ON_OFF_COMMAND_ID (0x06)
 232 #define ZCL_STOP_COMMAND_ID (0x03)
 233 #define ZCL_STOP_WITH_ON_OFF_COMMAND_ID (0x07)
 234
 235 #define LOW_POWER_CLUSTER_ID 0x0508
 236 #define ZCL_SLEEP_COMMAND_ID (0x00)
 237
 238 #define MEDIA_PLAYBACK_CLUSTER_ID 0xF001
 239 #define ZCL_FAST_FORWARD_REQUEST_COMMAND_ID (0x07)
 240 #define ZCL_NEXT_REQUEST_COMMAND_ID (0x05)
 241 #define ZCL_PAUSE_REQUEST_COMMAND_ID (0x01)
 242 #define ZCL_PLAY_REQUEST_COMMAND_ID (0x00)
 243 #define ZCL_PREVIOUS_REQUEST_COMMAND_ID (0x04)
 244 #define ZCL_REWIND_REQUEST_COMMAND_ID (0x06)
 245 #define ZCL_SKIP_BACKWARD_REQUEST_COMMAND_ID (0x09)
 246 #define ZCL_SKIP_FORWARD_REQUEST_COMMAND_ID (0x08)
 247 #define ZCL_START_OVER_REQUEST_COMMAND_ID (0x03)
 248 #define ZCL_STOP_REQUEST_COMMAND_ID (0x02)
 249
 250 #define NETWORK_COMMISSIONING_CLUSTER_ID 0xAAAA
 251 #define ZCL_ADD_THREAD_NETWORK_COMMAND_ID (0x06)
 252 #define ZCL_ADD_WI_FI_NETWORK_COMMAND_ID (0x02)
 253 #define ZCL_DISABLE_NETWORK_COMMAND_ID (0x0E)
 254 #define ZCL_ENABLE_NETWORK_COMMAND_ID (0x0C)
 255 #define ZCL_GET_LAST_NETWORK_COMMISSIONING_RESULT_COMMAND_ID (0x10)
 256 #define ZCL_REMOVE_NETWORK_COMMAND_ID (0x0A)
 257 #define ZCL_SCAN_NETWORKS_COMMAND_ID (0x00)
 258 #define ZCL_UPDATE_THREAD_NETWORK_COMMAND_ID (0x08)
 259 #define ZCL_UPDATE_WI_FI_NETWORK_COMMAND_ID (0x04)
 260
 261 #define ON_OFF_CLUSTER_ID 0x0006
 262 #define ZCL_OFF_COMMAND_ID (0x00)
 263 #define ZCL_ON_COMMAND_ID (0x01)
 264 #define ZCL_TOGGLE_COMMAND_ID (0x02)
 265
 266 #define SCENES_CLUSTER_ID 0x0005
 267 #define ZCL_ADD_SCENE_COMMAND_ID (0x00)
 268 #define ZCL_GET_SCENE_MEMBERSHIP_COMMAND_ID (0x06)
 269 #define ZCL_RECALL_SCENE_COMMAND_ID (0x05)
 270 #define ZCL_REMOVE_ALL_SCENES_COMMAND_ID (0x03)
 271 #define ZCL_REMOVE_SCENE_COMMAND_ID (0x02)
 272 #define ZCL_STORE_SCENE_COMMAND_ID (0x04)
 273 #define ZCL_VIEW_SCENE_COMMAND_ID (0x01)
 274
 275 #define TEMP_MEASUREMENT_CLUSTER_ID 0x0402
 276
 277 // TODO: Find a way to calculate maximum message length for clusters
 278 //       https://github.com/project-chip/connectedhomeip/issues/965
 279 constexpr uint16_t kMaxBufferSize = 1024;
 280
 281 // This is a cluster-specific command so low two bits are 0b01.  The command
 282 // is standard, so does not need a manufacturer code, and we're sending
 283 // client to server, so all the remaining bits are 0.
 284 constexpr uint8_t kFrameControlClusterSpecificCommand = 0x01;
 285
 286 // This is a global command, so the low bits are 0b00.  The command is
 287 // standard, so does not need a manufacturer code, and we're sending client
 288 // to server, so all the remaining bits are 0.
 289 constexpr uint8_t kFrameControlGlobalCommand = 0x00;
 290
 291 // Pick source endpoint as 1 for now
 292 constexpr EndpointId kSourceEndpoint = 1;
 293
 294 /*----------------------------------------------------------------------------*\
 295 | Cluster ApplicationBasic                                            | 0x050D |
 296 |------------------------------------------------------------------------------|
 297 | Commands:                                                           |        |
 298 |------------------------------------------------------------------------------|
 299 | Attributes:                                                         |        |
 300 | * VendorName                                                        | 0x0000 |
 301 | * VendorId                                                          | 0x0001 |
 302 | * ApplicationName                                                   | 0x0002 |
 303 | * ProductId                                                         | 0x0003 |
 304 | * ApplicationId                                                     | 0x0005 |
 305 | * CatalogVendorId                                                   | 0x0006 |
 306 | * ApplicationSatus                                                  | 0x0007 |
 307 | * ClusterRevision                                                   | 0xFFFD |
 308 \*----------------------------------------------------------------------------*/
 309
 310 PacketBufferHandle encodeApplicationBasicClusterDiscoverAttributes(uint8_t seqNum, EndpointId destinationEndpoint)
 311 {
 312     COMMAND_HEADER("DiscoverApplicationBasicAttributes", APPLICATION_BASIC_CLUSTER_ID);
 313     buf.Put8(kFrameControlGlobalCommand).Put8(seqNum).Put8(ZCL_DISCOVER_ATTRIBUTES_COMMAND_ID).Put16(0x0000).Put8(0xFF);
 314     COMMAND_FOOTER();
 315 }
 316
 317 /*
 318  * Attribute VendorName
 319  */
 320 PacketBufferHandle encodeApplicationBasicClusterReadVendorNameAttribute(uint8_t seqNum, EndpointId destinationEndpoint)
 321 {
 322     COMMAND_HEADER("ReadApplicationBasicVendorName", APPLICATION_BASIC_CLUSTER_ID);
 323     buf.Put8(kFrameControlGlobalCommand).Put8(seqNum).Put8(ZCL_READ_ATTRIBUTES_COMMAND_ID).Put16(0x0000);
 324     COMMAND_FOOTER();
 325 }
 326
 327 /*
 328  * Attribute VendorId
 329  */
 330 PacketBufferHandle encodeApplicationBasicClusterReadVendorIdAttribute(uint8_t seqNum, EndpointId destinationEndpoint)
 331 {
 332     COMMAND_HEADER("ReadApplicationBasicVendorId", APPLICATION_BASIC_CLUSTER_ID);
 333     buf.Put8(kFrameControlGlobalCommand).Put8(seqNum).Put8(ZCL_READ_ATTRIBUTES_COMMAND_ID).Put16(0x0001);
 334     COMMAND_FOOTER();
 335 }
 336
 337 /*
 338  * Attribute ApplicationName
 339  */
 340 PacketBufferHandle encodeApplicationBasicClusterReadApplicationNameAttribute(uint8_t seqNum, EndpointId destinationEndpoint)
 341 {
 342     COMMAND_HEADER("ReadApplicationBasicApplicationName", APPLICATION_BASIC_CLUSTER_ID);
 343     buf.Put8(kFrameControlGlobalCommand).Put8(seqNum).Put8(ZCL_READ_ATTRIBUTES_COMMAND_ID).Put16(0x0002);
 344     COMMAND_FOOTER();
 345 }
 346
 347 /*
 348  * Attribute ProductId
 349  */
 350 PacketBufferHandle encodeApplicationBasicClusterReadProductIdAttribute(uint8_t seqNum, EndpointId destinationEndpoint)
 351 {
 352     COMMAND_HEADER("ReadApplicationBasicProductId", APPLICATION_BASIC_CLUSTER_ID);
 353     buf.Put8(kFrameControlGlobalCommand).Put8(seqNum).Put8(ZCL_READ_ATTRIBUTES_COMMAND_ID).Put16(0x0003);
 354     COMMAND_FOOTER();
 355 }
 356
 357 /*
 358  * Attribute ApplicationId
 359  */
 360 PacketBufferHandle encodeApplicationBasicClusterReadApplicationIdAttribute(uint8_t seqNum, EndpointId destinationEndpoint)
 361 {
 362     COMMAND_HEADER("ReadApplicationBasicApplicationId", APPLICATION_BASIC_CLUSTER_ID);
 363     buf.Put8(kFrameControlGlobalCommand).Put8(seqNum).Put8(ZCL_READ_ATTRIBUTES_COMMAND_ID).Put16(0x0005);
 364     COMMAND_FOOTER();
 365 }
 366
 367 /*
 368  * Attribute CatalogVendorId
 369  */
 370 PacketBufferHandle encodeApplicationBasicClusterReadCatalogVendorIdAttribute(uint8_t seqNum, EndpointId destinationEndpoint)
 371 {
 372     COMMAND_HEADER("ReadApplicationBasicCatalogVendorId", APPLICATION_BASIC_CLUSTER_ID);
 373     buf.Put8(kFrameControlGlobalCommand).Put8(seqNum).Put8(ZCL_READ_ATTRIBUTES_COMMAND_ID).Put16(0x0006);
 374     COMMAND_FOOTER();
 375 }
 376
 377 /*
 378  * Attribute ApplicationSatus
 379  */
 380 PacketBufferHandle encodeApplicationBasicClusterReadApplicationSatusAttribute(uint8_t seqNum, EndpointId destinationEndpoint)
 381 {
 382     COMMAND_HEADER("ReadApplicationBasicApplicationSatus", APPLICATION_BASIC_CLUSTER_ID);
 383     buf.Put8(kFrameControlGlobalCommand).Put8(seqNum).Put8(ZCL_READ_ATTRIBUTES_COMMAND_ID).Put16(0x0007);
 384     COMMAND_FOOTER();
 385 }
 386
 387 /*
 388  * Attribute ClusterRevision
 389  */
 390 PacketBufferHandle encodeApplicationBasicClusterReadClusterRevisionAttribute(uint8_t seqNum, EndpointId destinationEndpoint)
 391 {
 392     COMMAND_HEADER("ReadApplicationBasicClusterRevision", APPLICATION_BASIC_CLUSTER_ID);
 393     buf.Put8(kFrameControlGlobalCommand).Put8(seqNum).Put8(ZCL_READ_ATTRIBUTES_COMMAND_ID).Put16(0xFFFD);
 394     COMMAND_FOOTER();
 395 }
 396
 397 /*----------------------------------------------------------------------------*\
 398 | Cluster BarrierControl                                              | 0x0103 |
 399 |------------------------------------------------------------------------------|
 400 | Commands:                                                           |        |
 401 | * BarrierControlGoToPercent                                         |   0x00 |
 402 | * BarrierControlStop                                                |   0x01 |
 403 |------------------------------------------------------------------------------|
 404 | Attributes:                                                         |        |
 405 | * BarrierMovingState                                                | 0x0001 |
 406 | * BarrierSafetyStatus                                               | 0x0002 |
 407 | * BarrierCapabilities                                               | 0x0003 |
 408 | * BarrierPosition                                                   | 0x000A |
 409 | * ClusterRevision                                                   | 0xFFFD |
 410 \*----------------------------------------------------------------------------*/
 411
 412 /*
 413  * Command BarrierControlGoToPercent
 414  */
 415 PacketBufferHandle encodeBarrierControlClusterBarrierControlGoToPercentCommand(uint8_t seqNum, EndpointId destinationEndpoint,
 416                                                                                uint8_t percentOpen)
 417 {
 418     COMMAND_HEADER("BarrierControlGoToPercent", BARRIER_CONTROL_CLUSTER_ID);
 419
 420     buf.Put8(kFrameControlClusterSpecificCommand).Put8(seqNum).Put8(ZCL_BARRIER_CONTROL_GO_TO_PERCENT_COMMAND_ID).Put8(percentOpen);
 421     COMMAND_FOOTER();
 422 }
 423
 424 /*
 425  * Command BarrierControlStop
 426  */
 427 PacketBufferHandle encodeBarrierControlClusterBarrierControlStopCommand(uint8_t seqNum, EndpointId destinationEndpoint)
 428 {
 429     COMMAND_HEADER("BarrierControlStop", BARRIER_CONTROL_CLUSTER_ID);
 430     buf.Put8(kFrameControlClusterSpecificCommand).Put8(seqNum).Put8(ZCL_BARRIER_CONTROL_STOP_COMMAND_ID);
 431     COMMAND_FOOTER();
 432 }
 433
 434 PacketBufferHandle encodeBarrierControlClusterDiscoverAttributes(uint8_t seqNum, EndpointId destinationEndpoint)
 435 {
 436     COMMAND_HEADER("DiscoverBarrierControlAttributes", BARRIER_CONTROL_CLUSTER_ID);
 437     buf.Put8(kFrameControlGlobalCommand).Put8(seqNum).Put8(ZCL_DISCOVER_ATTRIBUTES_COMMAND_ID).Put16(0x0000).Put8(0xFF);
 438     COMMAND_FOOTER();
 439 }
 440
 441 /*
 442  * Attribute BarrierMovingState
 443  */
 444 PacketBufferHandle encodeBarrierControlClusterReadBarrierMovingStateAttribute(uint8_t seqNum, EndpointId destinationEndpoint)
 445 {
 446     COMMAND_HEADER("ReadBarrierControlBarrierMovingState", BARRIER_CONTROL_CLUSTER_ID);
 447     buf.Put8(kFrameControlGlobalCommand).Put8(seqNum).Put8(ZCL_READ_ATTRIBUTES_COMMAND_ID).Put16(0x0001);
 448     COMMAND_FOOTER();
 449 }
 450
 451 /*
 452  * Attribute BarrierSafetyStatus
 453  */
 454 PacketBufferHandle encodeBarrierControlClusterReadBarrierSafetyStatusAttribute(uint8_t seqNum, EndpointId destinationEndpoint)
 455 {
 456     COMMAND_HEADER("ReadBarrierControlBarrierSafetyStatus", BARRIER_CONTROL_CLUSTER_ID);
 457     buf.Put8(kFrameControlGlobalCommand).Put8(seqNum).Put8(ZCL_READ_ATTRIBUTES_COMMAND_ID).Put16(0x0002);
 458     COMMAND_FOOTER();
 459 }
 460
 461 /*
 462  * Attribute BarrierCapabilities
 463  */
 464 PacketBufferHandle encodeBarrierControlClusterReadBarrierCapabilitiesAttribute(uint8_t seqNum, EndpointId destinationEndpoint)
 465 {
 466     COMMAND_HEADER("ReadBarrierControlBarrierCapabilities", BARRIER_CONTROL_CLUSTER_ID);
 467     buf.Put8(kFrameControlGlobalCommand).Put8(seqNum).Put8(ZCL_READ_ATTRIBUTES_COMMAND_ID).Put16(0x0003);
 468     COMMAND_FOOTER();
 469 }
 470
 471 /*
 472  * Attribute BarrierPosition
 473  */
 474 PacketBufferHandle encodeBarrierControlClusterReadBarrierPositionAttribute(uint8_t seqNum, EndpointId destinationEndpoint)
 475 {
 476     COMMAND_HEADER("ReadBarrierControlBarrierPosition", BARRIER_CONTROL_CLUSTER_ID);
 477     buf.Put8(kFrameControlGlobalCommand).Put8(seqNum).Put8(ZCL_READ_ATTRIBUTES_COMMAND_ID).Put16(0x000A);
 478     COMMAND_FOOTER();
 479 }
 480
 481 /*
 482  * Attribute ClusterRevision
 483  */
 484 PacketBufferHandle encodeBarrierControlClusterReadClusterRevisionAttribute(uint8_t seqNum, EndpointId destinationEndpoint)
 485 {
 486     COMMAND_HEADER("ReadBarrierControlClusterRevision", BARRIER_CONTROL_CLUSTER_ID);
 487     buf.Put8(kFrameControlGlobalCommand).Put8(seqNum).Put8(ZCL_READ_ATTRIBUTES_COMMAND_ID).Put16(0xFFFD);
 488     COMMAND_FOOTER();
 489 }
 490
 491 /*----------------------------------------------------------------------------*\
 492 | Cluster Basic                                                       | 0x0028 |
 493 |------------------------------------------------------------------------------|
 494 | Commands:                                                           |        |
 495 | * MfgSpecificPing                                                   |   0x00 |
 496 |------------------------------------------------------------------------------|
 497 | Attributes:                                                         |        |
 498 | * InteractionModelVersion                                           | 0x0000 |
 499 | * VendorName                                                        | 0x0001 |
 500 | * VendorID                                                          | 0x0002 |
 501 | * ProductName                                                       | 0x0003 |
 502 | * ProductID                                                         | 0x0004 |
 503 | * UserLabel                                                         | 0x0005 |
 504 | * Location                                                          | 0x0006 |
 505 | * HardwareVersion                                                   | 0x0007 |
 506 | * HardwareVersionString                                             | 0x0008 |
 507 | * SoftwareVersion                                                   | 0x0009 |
 508 | * SoftwareVersionString                                             | 0x000A |
 509 | * ClusterRevision                                                   | 0xFFFD |
 510 \*----------------------------------------------------------------------------*/
 511
 512 /*
 513  * Command MfgSpecificPing
 514  */
 515 PacketBufferHandle encodeBasicClusterMfgSpecificPingCommand(uint8_t seqNum, EndpointId destinationEndpoint)
 516 {
 517     COMMAND_HEADER("MfgSpecificPing", BASIC_CLUSTER_ID);
 518     buf.Put8(kFrameControlClusterSpecificCommand | (1u << 2)).Put16(0x1002).Put8(seqNum).Put8(ZCL_MFG_SPECIFIC_PING_COMMAND_ID);
 519     COMMAND_FOOTER();
 520 }
 521
 522 PacketBufferHandle encodeBasicClusterDiscoverAttributes(uint8_t seqNum, EndpointId destinationEndpoint)
 523 {
 524     COMMAND_HEADER("DiscoverBasicAttributes", BASIC_CLUSTER_ID);
 525     buf.Put8(kFrameControlGlobalCommand).Put8(seqNum).Put8(ZCL_DISCOVER_ATTRIBUTES_COMMAND_ID).Put16(0x0000).Put8(0xFF);
 526     COMMAND_FOOTER();
 527 }
 528
 529 /*
 530  * Attribute InteractionModelVersion
 531  */
 532 PacketBufferHandle encodeBasicClusterReadInteractionModelVersionAttribute(uint8_t seqNum, EndpointId destinationEndpoint)
 533 {
 534     COMMAND_HEADER("ReadBasicInteractionModelVersion", BASIC_CLUSTER_ID);
 535     buf.Put8(kFrameControlGlobalCommand).Put8(seqNum).Put8(ZCL_READ_ATTRIBUTES_COMMAND_ID).Put16(0x0000);
 536     COMMAND_FOOTER();
 537 }
 538
 539 /*
 540  * Attribute VendorName
 541  */
 542 PacketBufferHandle encodeBasicClusterReadVendorNameAttribute(uint8_t seqNum, EndpointId destinationEndpoint)
 543 {
 544     COMMAND_HEADER("ReadBasicVendorName", BASIC_CLUSTER_ID);
 545     buf.Put8(kFrameControlGlobalCommand).Put8(seqNum).Put8(ZCL_READ_ATTRIBUTES_COMMAND_ID).Put16(0x0001);
 546     COMMAND_FOOTER();
 547 }
 548
 549 /*
 550  * Attribute VendorID
 551  */
 552 PacketBufferHandle encodeBasicClusterReadVendorIDAttribute(uint8_t seqNum, EndpointId destinationEndpoint)
 553 {
 554     COMMAND_HEADER("ReadBasicVendorID", BASIC_CLUSTER_ID);
 555     buf.Put8(kFrameControlGlobalCommand).Put8(seqNum).Put8(ZCL_READ_ATTRIBUTES_COMMAND_ID).Put16(0x0002);
 556     COMMAND_FOOTER();
 557 }
 558
 559 /*
 560  * Attribute ProductName
 561  */
 562 PacketBufferHandle encodeBasicClusterReadProductNameAttribute(uint8_t seqNum, EndpointId destinationEndpoint)
 563 {
 564     COMMAND_HEADER("ReadBasicProductName", BASIC_CLUSTER_ID);
 565     buf.Put8(kFrameControlGlobalCommand).Put8(seqNum).Put8(ZCL_READ_ATTRIBUTES_COMMAND_ID).Put16(0x0003);
 566     COMMAND_FOOTER();
 567 }
 568
 569 /*
 570  * Attribute ProductID
 571  */
 572 PacketBufferHandle encodeBasicClusterReadProductIDAttribute(uint8_t seqNum, EndpointId destinationEndpoint)
 573 {
 574     COMMAND_HEADER("ReadBasicProductID", BASIC_CLUSTER_ID);
 575     buf.Put8(kFrameControlGlobalCommand).Put8(seqNum).Put8(ZCL_READ_ATTRIBUTES_COMMAND_ID).Put16(0x0004);
 576     COMMAND_FOOTER();
 577 }
 578
 579 /*
 580  * Attribute UserLabel
 581  */
 582 PacketBufferHandle encodeBasicClusterReadUserLabelAttribute(uint8_t seqNum, EndpointId destinationEndpoint)
 583 {
 584     COMMAND_HEADER("ReadBasicUserLabel", BASIC_CLUSTER_ID);
 585     buf.Put8(kFrameControlGlobalCommand).Put8(seqNum).Put8(ZCL_READ_ATTRIBUTES_COMMAND_ID).Put16(0x0005);
 586     COMMAND_FOOTER();
 587 }
 588
 589 PacketBufferHandle encodeBasicClusterWriteUserLabelAttribute(uint8_t seqNum, EndpointId destinationEndpoint,
 590                                                              chip::ByteSpan userLabel)
 591 {
 592     COMMAND_HEADER("WriteBasicUserLabel", BASIC_CLUSTER_ID);
 593     size_t userLabelStrLen = userLabel.size();
 594     if (!CanCastTo<uint8_t>(userLabelStrLen))
 595     {
 596         ChipLogError(Zcl, "Error encoding %s command. String too long: %d", kName, userLabelStrLen);
 597         return PacketBufferHandle();
 598     }
 599
 600     buf.Put8(kFrameControlGlobalCommand)
 601         .Put8(seqNum)
 602         .Put8(ZCL_WRITE_ATTRIBUTES_COMMAND_ID)
 603         .Put16(0x0005)
 604         .Put8(66)
 605         .Put(static_cast<uint8_t>(userLabelStrLen))
 606         .Put(userLabel.data(), userLabelStrLen);
 607     COMMAND_FOOTER();
 608 }
 609
 610 /*
 611  * Attribute Location
 612  */
 613 PacketBufferHandle encodeBasicClusterReadLocationAttribute(uint8_t seqNum, EndpointId destinationEndpoint)
 614 {
 615     COMMAND_HEADER("ReadBasicLocation", BASIC_CLUSTER_ID);
 616     buf.Put8(kFrameControlGlobalCommand).Put8(seqNum).Put8(ZCL_READ_ATTRIBUTES_COMMAND_ID).Put16(0x0006);
 617     COMMAND_FOOTER();
 618 }
 619
 620 PacketBufferHandle encodeBasicClusterWriteLocationAttribute(uint8_t seqNum, EndpointId destinationEndpoint, chip::ByteSpan location)
 621 {
 622     COMMAND_HEADER("WriteBasicLocation", BASIC_CLUSTER_ID);
 623     size_t locationStrLen = location.size();
 624     if (!CanCastTo<uint8_t>(locationStrLen))
 625     {
 626         ChipLogError(Zcl, "Error encoding %s command. String too long: %d", kName, locationStrLen);
 627         return PacketBufferHandle();
 628     }
 629
 630     buf.Put8(kFrameControlGlobalCommand)
 631         .Put8(seqNum)
 632         .Put8(ZCL_WRITE_ATTRIBUTES_COMMAND_ID)
 633         .Put16(0x0006)
 634         .Put8(66)
 635         .Put(static_cast<uint8_t>(locationStrLen))
 636         .Put(location.data(), locationStrLen);
 637     COMMAND_FOOTER();
 638 }
 639
 640 /*
 641  * Attribute HardwareVersion
 642  */
 643 PacketBufferHandle encodeBasicClusterReadHardwareVersionAttribute(uint8_t seqNum, EndpointId destinationEndpoint)
 644 {
 645     COMMAND_HEADER("ReadBasicHardwareVersion", BASIC_CLUSTER_ID);
 646     buf.Put8(kFrameControlGlobalCommand).Put8(seqNum).Put8(ZCL_READ_ATTRIBUTES_COMMAND_ID).Put16(0x0007);
 647     COMMAND_FOOTER();
 648 }
 649
 650 /*
 651  * Attribute HardwareVersionString
 652  */
 653 PacketBufferHandle encodeBasicClusterReadHardwareVersionStringAttribute(uint8_t seqNum, EndpointId destinationEndpoint)
 654 {
 655     COMMAND_HEADER("ReadBasicHardwareVersionString", BASIC_CLUSTER_ID);
 656     buf.Put8(kFrameControlGlobalCommand).Put8(seqNum).Put8(ZCL_READ_ATTRIBUTES_COMMAND_ID).Put16(0x0008);
 657     COMMAND_FOOTER();
 658 }
 659
 660 /*
 661  * Attribute SoftwareVersion
 662  */
 663 PacketBufferHandle encodeBasicClusterReadSoftwareVersionAttribute(uint8_t seqNum, EndpointId destinationEndpoint)
 664 {
 665     COMMAND_HEADER("ReadBasicSoftwareVersion", BASIC_CLUSTER_ID);
 666     buf.Put8(kFrameControlGlobalCommand).Put8(seqNum).Put8(ZCL_READ_ATTRIBUTES_COMMAND_ID).Put16(0x0009);
 667     COMMAND_FOOTER();
 668 }
 669
 670 /*
 671  * Attribute SoftwareVersionString
 672  */
 673 PacketBufferHandle encodeBasicClusterReadSoftwareVersionStringAttribute(uint8_t seqNum, EndpointId destinationEndpoint)
 674 {
 675     COMMAND_HEADER("ReadBasicSoftwareVersionString", BASIC_CLUSTER_ID);
 676     buf.Put8(kFrameControlGlobalCommand).Put8(seqNum).Put8(ZCL_READ_ATTRIBUTES_COMMAND_ID).Put16(0x000A);
 677     COMMAND_FOOTER();
 678 }
 679
 680 /*
 681  * Attribute ClusterRevision
 682  */
 683 PacketBufferHandle encodeBasicClusterReadClusterRevisionAttribute(uint8_t seqNum, EndpointId destinationEndpoint)
 684 {
 685     COMMAND_HEADER("ReadBasicClusterRevision", BASIC_CLUSTER_ID);
 686     buf.Put8(kFrameControlGlobalCommand).Put8(seqNum).Put8(ZCL_READ_ATTRIBUTES_COMMAND_ID).Put16(0xFFFD);
 687     COMMAND_FOOTER();
 688 }
 689
 690 /*----------------------------------------------------------------------------*\
 691 | Cluster Binding                                                     | 0xF000 |
 692 |------------------------------------------------------------------------------|
 693 | Commands:                                                           |        |
 694 | * Bind                                                              |   0x00 |
 695 | * Unbind                                                            |   0x01 |
 696 |------------------------------------------------------------------------------|
 697 | Attributes:                                                         |        |
 698 | * ClusterRevision                                                   | 0xFFFD |
 699 \*----------------------------------------------------------------------------*/
 700
 701 /*
 702  * Command Bind
 703  */
 704 PacketBufferHandle encodeBindingClusterBindCommand(uint8_t seqNum, EndpointId destinationEndpoint, chip::NodeId nodeId,
 705                                                    chip::GroupId groupId, chip::EndpointId endpointId, chip::ClusterId clusterId)
 706 {
 707     COMMAND_HEADER("Bind", BINDING_CLUSTER_ID);
 708
 709     buf.Put8(kFrameControlClusterSpecificCommand)
 710         .Put8(seqNum)
 711         .Put8(ZCL_BIND_COMMAND_ID)
 712         .Put64(nodeId)
 713         .Put16(groupId)
 714         .Put8(endpointId)
 715         .Put16(clusterId);
 716     COMMAND_FOOTER();
 717 }
 718
 719 /*
 720  * Command Unbind
 721  */
 722 PacketBufferHandle encodeBindingClusterUnbindCommand(uint8_t seqNum, EndpointId destinationEndpoint, chip::NodeId nodeId,
 723                                                      chip::GroupId groupId, chip::EndpointId endpointId, chip::ClusterId clusterId)
 724 {
 725     COMMAND_HEADER("Unbind", BINDING_CLUSTER_ID);
 726
 727     buf.Put8(kFrameControlClusterSpecificCommand)
 728         .Put8(seqNum)
 729         .Put8(ZCL_UNBIND_COMMAND_ID)
 730         .Put64(nodeId)
 731         .Put16(groupId)
 732         .Put8(endpointId)
 733         .Put16(clusterId);
 734     COMMAND_FOOTER();
 735 }
 736
 737 PacketBufferHandle encodeBindingClusterDiscoverAttributes(uint8_t seqNum, EndpointId destinationEndpoint)
 738 {
 739     COMMAND_HEADER("DiscoverBindingAttributes", BINDING_CLUSTER_ID);
 740     buf.Put8(kFrameControlGlobalCommand).Put8(seqNum).Put8(ZCL_DISCOVER_ATTRIBUTES_COMMAND_ID).Put16(0x0000).Put8(0xFF);
 741     COMMAND_FOOTER();
 742 }
 743
 744 /*
 745  * Attribute ClusterRevision
 746  */
 747 PacketBufferHandle encodeBindingClusterReadClusterRevisionAttribute(uint8_t seqNum, EndpointId destinationEndpoint)
 748 {
 749     COMMAND_HEADER("ReadBindingClusterRevision", BINDING_CLUSTER_ID);
 750     buf.Put8(kFrameControlGlobalCommand).Put8(seqNum).Put8(ZCL_READ_ATTRIBUTES_COMMAND_ID).Put16(0xFFFD);
 751     COMMAND_FOOTER();
 752 }
 753
 754 /*----------------------------------------------------------------------------*\
 755 | Cluster ColorControl                                                | 0x0300 |
 756 |------------------------------------------------------------------------------|
 757 | Commands:                                                           |        |
 758 | * MoveColor                                                         |   0x08 |
 759 | * MoveColorTemperature                                              |   0x4B |
 760 | * MoveHue                                                           |   0x01 |
 761 | * MoveSaturation                                                    |   0x04 |
 762 | * MoveToColor                                                       |   0x07 |
 763 | * MoveToColorTemperature                                            |   0x0A |
 764 | * MoveToHue                                                         |   0x00 |
 765 | * MoveToHueAndSaturation                                            |   0x06 |
 766 | * MoveToSaturation                                                  |   0x03 |
 767 | * StepColor                                                         |   0x09 |
 768 | * StepColorTemperature                                              |   0x4C |
 769 | * StepHue                                                           |   0x02 |
 770 | * StepSaturation                                                    |   0x05 |
 771 | * StopMoveStep                                                      |   0x47 |
 772 |------------------------------------------------------------------------------|
 773 | Attributes:                                                         |        |
 774 | * CurrentHue                                                        | 0x0000 |
 775 | * CurrentSaturation                                                 | 0x0001 |
 776 | * RemainingTime                                                     | 0x0002 |
 777 | * CurrentX                                                          | 0x0003 |
 778 | * CurrentY                                                          | 0x0004 |
 779 | * DriftCompensation                                                 | 0x0005 |
 780 | * CompensationText                                                  | 0x0006 |
 781 | * ColorTemperature                                                  | 0x0007 |
 782 | * ColorMode                                                         | 0x0008 |
 783 | * ColorControlOptions                                               | 0x000F |
 784 | * NumberOfPrimaries                                                 | 0x0010 |
 785 | * Primary1X                                                         | 0x0011 |
 786 | * Primary1Y                                                         | 0x0012 |
 787 | * Primary1Intensity                                                 | 0x0013 |
 788 | * Primary2X                                                         | 0x0015 |
 789 | * Primary2Y                                                         | 0x0016 |
 790 | * Primary2Intensity                                                 | 0x0017 |
 791 | * Primary3X                                                         | 0x0019 |
 792 | * Primary3Y                                                         | 0x001A |
 793 | * Primary3Intensity                                                 | 0x001B |
 794 | * Primary4X                                                         | 0x0020 |
 795 | * Primary4Y                                                         | 0x0021 |
 796 | * Primary4Intensity                                                 | 0x0022 |
 797 | * Primary5X                                                         | 0x0024 |
 798 | * Primary5Y                                                         | 0x0025 |
 799 | * Primary5Intensity                                                 | 0x0026 |
 800 | * Primary6X                                                         | 0x0028 |
 801 | * Primary6Y                                                         | 0x0029 |
 802 | * Primary6Intensity                                                 | 0x002A |
 803 | * WhitePointX                                                       | 0x0030 |
 804 | * WhitePointY                                                       | 0x0031 |
 805 | * ColorPointRX                                                      | 0x0032 |
 806 | * ColorPointRY                                                      | 0x0033 |
 807 | * ColorPointRIntensity                                              | 0x0034 |
 808 | * ColorPointGX                                                      | 0x0036 |
 809 | * ColorPointGY                                                      | 0x0037 |
 810 | * ColorPointGIntensity                                              | 0x0038 |
 811 | * ColorPointBX                                                      | 0x003A |
 812 | * ColorPointBY                                                      | 0x003B |
 813 | * ColorPointBIntensity                                              | 0x003C |
 814 | * EnhancedCurrentHue                                                | 0x4000 |
 815 | * EnhancedColorMode                                                 | 0x4001 |
 816 | * ColorLoopActive                                                   | 0x4002 |
 817 | * ColorLoopDirection                                                | 0x4003 |
 818 | * ColorLoopTime                                                     | 0x4004 |
 819 | * ColorCapabilities                                                 | 0x400A |
 820 | * ColorTempPhysicalMin                                              | 0x400B |
 821 | * ColorTempPhysicalMax                                              | 0x400C |
 822 | * CoupleColorTempToLevelMinMireds                                   | 0x400D |
 823 | * StartUpColorTemperatureMireds                                     | 0x4010 |
 824 | * ClusterRevision                                                   | 0xFFFD |
 825 \*----------------------------------------------------------------------------*/
 826
 827 /*
 828  * Command MoveColor
 829  */
 830 PacketBufferHandle encodeColorControlClusterMoveColorCommand(uint8_t seqNum, EndpointId destinationEndpoint, int16_t rateX,
 831                                                              int16_t rateY, uint8_t optionsMask, uint8_t optionsOverride)
 832 {
 833     COMMAND_HEADER("MoveColor", COLOR_CONTROL_CLUSTER_ID);
 834
 835     buf.Put8(kFrameControlClusterSpecificCommand)
 836         .Put8(seqNum)
 837         .Put8(ZCL_MOVE_COLOR_COMMAND_ID)
 838         .Put16(static_cast<uint16_t>(rateX))
 839         .Put16(static_cast<uint16_t>(rateY))
 840         .Put8(optionsMask)
 841         .Put8(optionsOverride);
 842     COMMAND_FOOTER();
 843 }
 844
 845 /*
 846  * Command MoveColorTemperature
 847  */
 848 PacketBufferHandle encodeColorControlClusterMoveColorTemperatureCommand(uint8_t seqNum, EndpointId destinationEndpoint,
 849                                                                         uint8_t moveMode, uint16_t rate,
 850                                                                         uint16_t colorTemperatureMinimum,
 851                                                                         uint16_t colorTemperatureMaximum, uint8_t optionsMask,
 852                                                                         uint8_t optionsOverride)
 853 {
 854     COMMAND_HEADER("MoveColorTemperature", COLOR_CONTROL_CLUSTER_ID);
 855
 856     buf.Put8(kFrameControlClusterSpecificCommand)
 857         .Put8(seqNum)
 858         .Put8(ZCL_MOVE_COLOR_TEMPERATURE_COMMAND_ID)
 859         .Put8(moveMode)
 860         .Put16(rate)
 861         .Put16(colorTemperatureMinimum)
 862         .Put16(colorTemperatureMaximum)
 863         .Put8(optionsMask)
 864         .Put8(optionsOverride);
 865     COMMAND_FOOTER();
 866 }
 867
 868 /*
 869  * Command MoveHue
 870  */
 871 PacketBufferHandle encodeColorControlClusterMoveHueCommand(uint8_t seqNum, EndpointId destinationEndpoint, uint8_t moveMode,
 872                                                            uint8_t rate, uint8_t optionsMask, uint8_t optionsOverride)
 873 {
 874     COMMAND_HEADER("MoveHue", COLOR_CONTROL_CLUSTER_ID);
 875
 876     buf.Put8(kFrameControlClusterSpecificCommand)
 877         .Put8(seqNum)
 878         .Put8(ZCL_MOVE_HUE_COMMAND_ID)
 879         .Put8(moveMode)
 880         .Put8(rate)
 881         .Put8(optionsMask)
 882         .Put8(optionsOverride);
 883     COMMAND_FOOTER();
 884 }
 885
 886 /*
 887  * Command MoveSaturation
 888  */
 889 PacketBufferHandle encodeColorControlClusterMoveSaturationCommand(uint8_t seqNum, EndpointId destinationEndpoint, uint8_t moveMode,
 890                                                                   uint8_t rate, uint8_t optionsMask, uint8_t optionsOverride)
 891 {
 892     COMMAND_HEADER("MoveSaturation", COLOR_CONTROL_CLUSTER_ID);
 893
 894     buf.Put8(kFrameControlClusterSpecificCommand)
 895         .Put8(seqNum)
 896         .Put8(ZCL_MOVE_SATURATION_COMMAND_ID)
 897         .Put8(moveMode)
 898         .Put8(rate)
 899         .Put8(optionsMask)
 900         .Put8(optionsOverride);
 901     COMMAND_FOOTER();
 902 }
 903
 904 /*
 905  * Command MoveToColor
 906  */
 907 PacketBufferHandle encodeColorControlClusterMoveToColorCommand(uint8_t seqNum, EndpointId destinationEndpoint, uint16_t colorX,
 908                                                                uint16_t colorY, uint16_t transitionTime, uint8_t optionsMask,
 909                                                                uint8_t optionsOverride)
 910 {
 911     COMMAND_HEADER("MoveToColor", COLOR_CONTROL_CLUSTER_ID);
 912
 913     buf.Put8(kFrameControlClusterSpecificCommand)
 914         .Put8(seqNum)
 915         .Put8(ZCL_MOVE_TO_COLOR_COMMAND_ID)
 916         .Put16(colorX)
 917         .Put16(colorY)
 918         .Put16(transitionTime)
 919         .Put8(optionsMask)
 920         .Put8(optionsOverride);
 921     COMMAND_FOOTER();
 922 }
 923
 924 /*
 925  * Command MoveToColorTemperature
 926  */
 927 PacketBufferHandle encodeColorControlClusterMoveToColorTemperatureCommand(uint8_t seqNum, EndpointId destinationEndpoint,
 928                                                                           uint16_t colorTemperature, uint16_t transitionTime,
 929                                                                           uint8_t optionsMask, uint8_t optionsOverride)
 930 {
 931     COMMAND_HEADER("MoveToColorTemperature", COLOR_CONTROL_CLUSTER_ID);
 932
 933     buf.Put8(kFrameControlClusterSpecificCommand)
 934         .Put8(seqNum)
 935         .Put8(ZCL_MOVE_TO_COLOR_TEMPERATURE_COMMAND_ID)
 936         .Put16(colorTemperature)
 937         .Put16(transitionTime)
 938         .Put8(optionsMask)
 939         .Put8(optionsOverride);
 940     COMMAND_FOOTER();
 941 }
 942
 943 /*
 944  * Command MoveToHue
 945  */
 946 PacketBufferHandle encodeColorControlClusterMoveToHueCommand(uint8_t seqNum, EndpointId destinationEndpoint, uint8_t hue,
 947                                                              uint8_t direction, uint16_t transitionTime, uint8_t optionsMask,
 948                                                              uint8_t optionsOverride)
 949 {
 950     COMMAND_HEADER("MoveToHue", COLOR_CONTROL_CLUSTER_ID);
 951
 952     buf.Put8(kFrameControlClusterSpecificCommand)
 953         .Put8(seqNum)
 954         .Put8(ZCL_MOVE_TO_HUE_COMMAND_ID)
 955         .Put8(hue)
 956         .Put8(direction)
 957         .Put16(transitionTime)
 958         .Put8(optionsMask)
 959         .Put8(optionsOverride);
 960     COMMAND_FOOTER();
 961 }
 962
 963 /*
 964  * Command MoveToHueAndSaturation
 965  */
 966 PacketBufferHandle encodeColorControlClusterMoveToHueAndSaturationCommand(uint8_t seqNum, EndpointId destinationEndpoint,
 967                                                                           uint8_t hue, uint8_t saturation, uint16_t transitionTime,
 968                                                                           uint8_t optionsMask, uint8_t optionsOverride)
 969 {
 970     COMMAND_HEADER("MoveToHueAndSaturation", COLOR_CONTROL_CLUSTER_ID);
 971
 972     buf.Put8(kFrameControlClusterSpecificCommand)
 973         .Put8(seqNum)
 974         .Put8(ZCL_MOVE_TO_HUE_AND_SATURATION_COMMAND_ID)
 975         .Put8(hue)
 976         .Put8(saturation)
 977         .Put16(transitionTime)
 978         .Put8(optionsMask)
 979         .Put8(optionsOverride);
 980     COMMAND_FOOTER();
 981 }
 982
 983 /*
 984  * Command MoveToSaturation
 985  */
 986 PacketBufferHandle encodeColorControlClusterMoveToSaturationCommand(uint8_t seqNum, EndpointId destinationEndpoint,
 987                                                                     uint8_t saturation, uint16_t transitionTime,
 988                                                                     uint8_t optionsMask, uint8_t optionsOverride)
 989 {
 990     COMMAND_HEADER("MoveToSaturation", COLOR_CONTROL_CLUSTER_ID);
 991
 992     buf.Put8(kFrameControlClusterSpecificCommand)
 993         .Put8(seqNum)
 994         .Put8(ZCL_MOVE_TO_SATURATION_COMMAND_ID)
 995         .Put8(saturation)
 996         .Put16(transitionTime)
 997         .Put8(optionsMask)
 998         .Put8(optionsOverride);
 999     COMMAND_FOOTER();
1000 }
1001
1002 /*
1003  * Command StepColor
1004  */
1005 PacketBufferHandle encodeColorControlClusterStepColorCommand(uint8_t seqNum, EndpointId destinationEndpoint, int16_t stepX,
1006                                                              int16_t stepY, uint16_t transitionTime, uint8_t optionsMask,
1007                                                              uint8_t optionsOverride)
1008 {
1009     COMMAND_HEADER("StepColor", COLOR_CONTROL_CLUSTER_ID);
1010
1011     buf.Put8(kFrameControlClusterSpecificCommand)
1012         .Put8(seqNum)
1013         .Put8(ZCL_STEP_COLOR_COMMAND_ID)
1014         .Put16(static_cast<uint16_t>(stepX))
1015         .Put16(static_cast<uint16_t>(stepY))
1016         .Put16(transitionTime)
1017         .Put8(optionsMask)
1018         .Put8(optionsOverride);
1019     COMMAND_FOOTER();
1020 }
1021
1022 /*
1023  * Command StepColorTemperature
1024  */
1025 PacketBufferHandle encodeColorControlClusterStepColorTemperatureCommand(uint8_t seqNum, EndpointId destinationEndpoint,
1026                                                                         uint8_t stepMode, uint16_t stepSize,
1027                                                                         uint16_t transitionTime, uint16_t colorTemperatureMinimum,
1028                                                                         uint16_t colorTemperatureMaximum, uint8_t optionsMask,
1029                                                                         uint8_t optionsOverride)
1030 {
1031     COMMAND_HEADER("StepColorTemperature", COLOR_CONTROL_CLUSTER_ID);
1032
1033     buf.Put8(kFrameControlClusterSpecificCommand)
1034         .Put8(seqNum)
1035         .Put8(ZCL_STEP_COLOR_TEMPERATURE_COMMAND_ID)
1036         .Put8(stepMode)
1037         .Put16(stepSize)
1038         .Put16(transitionTime)
1039         .Put16(colorTemperatureMinimum)
1040         .Put16(colorTemperatureMaximum)
1041         .Put8(optionsMask)
1042         .Put8(optionsOverride);
1043     COMMAND_FOOTER();
1044 }
1045
1046 /*
1047  * Command StepHue
1048  */
1049 PacketBufferHandle encodeColorControlClusterStepHueCommand(uint8_t seqNum, EndpointId destinationEndpoint, uint8_t stepMode,
1050                                                            uint8_t stepSize, uint8_t transitionTime, uint8_t optionsMask,
1051                                                            uint8_t optionsOverride)
1052 {
1053     COMMAND_HEADER("StepHue", COLOR_CONTROL_CLUSTER_ID);
1054
1055     buf.Put8(kFrameControlClusterSpecificCommand)
1056         .Put8(seqNum)
1057         .Put8(ZCL_STEP_HUE_COMMAND_ID)
1058         .Put8(stepMode)
1059         .Put8(stepSize)
1060         .Put8(transitionTime)
1061         .Put8(optionsMask)
1062         .Put8(optionsOverride);
1063     COMMAND_FOOTER();
1064 }
1065
1066 /*
1067  * Command StepSaturation
1068  */
1069 PacketBufferHandle encodeColorControlClusterStepSaturationCommand(uint8_t seqNum, EndpointId destinationEndpoint, uint8_t stepMode,
1070                                                                   uint8_t stepSize, uint8_t transitionTime, uint8_t optionsMask,
1071                                                                   uint8_t optionsOverride)
1072 {
1073     COMMAND_HEADER("StepSaturation", COLOR_CONTROL_CLUSTER_ID);
1074
1075     buf.Put8(kFrameControlClusterSpecificCommand)
1076         .Put8(seqNum)
1077         .Put8(ZCL_STEP_SATURATION_COMMAND_ID)
1078         .Put8(stepMode)
1079         .Put8(stepSize)
1080         .Put8(transitionTime)
1081         .Put8(optionsMask)
1082         .Put8(optionsOverride);
1083     COMMAND_FOOTER();
1084 }
1085
1086 /*
1087  * Command StopMoveStep
1088  */
1089 PacketBufferHandle encodeColorControlClusterStopMoveStepCommand(uint8_t seqNum, EndpointId destinationEndpoint, uint8_t optionsMask,
1090                                                                 uint8_t optionsOverride)
1091 {
1092     COMMAND_HEADER("StopMoveStep", COLOR_CONTROL_CLUSTER_ID);
1093
1094     buf.Put8(kFrameControlClusterSpecificCommand)
1095         .Put8(seqNum)
1096         .Put8(ZCL_STOP_MOVE_STEP_COMMAND_ID)
1097         .Put8(optionsMask)
1098         .Put8(optionsOverride);
1099     COMMAND_FOOTER();
1100 }
1101
1102 PacketBufferHandle encodeColorControlClusterDiscoverAttributes(uint8_t seqNum, EndpointId destinationEndpoint)
1103 {
1104     COMMAND_HEADER("DiscoverColorControlAttributes", COLOR_CONTROL_CLUSTER_ID);
1105     buf.Put8(kFrameControlGlobalCommand).Put8(seqNum).Put8(ZCL_DISCOVER_ATTRIBUTES_COMMAND_ID).Put16(0x0000).Put8(0xFF);
1106     COMMAND_FOOTER();
1107 }
1108
1109 /*
1110  * Attribute CurrentHue
1111  */
1112 PacketBufferHandle encodeColorControlClusterReadCurrentHueAttribute(uint8_t seqNum, EndpointId destinationEndpoint)
1113 {
1114     COMMAND_HEADER("ReadColorControlCurrentHue", COLOR_CONTROL_CLUSTER_ID);
1115     buf.Put8(kFrameControlGlobalCommand).Put8(seqNum).Put8(ZCL_READ_ATTRIBUTES_COMMAND_ID).Put16(0x0000);
1116     COMMAND_FOOTER();
1117 }
1118
1119 PacketBufferHandle encodeColorControlClusterConfigureCurrentHueAttribute(uint8_t seqNum, EndpointId destinationEndpoint,
1120                                                                          uint16_t minInterval, uint16_t maxInterval, uint8_t change)
1121 {
1122     COMMAND_HEADER("ReportColorControlCurrentHue", COLOR_CONTROL_CLUSTER_ID);
1123     buf.Put8(kFrameControlGlobalCommand)
1124         .Put8(seqNum)
1125         .Put8(ZCL_CONFIGURE_REPORTING_COMMAND_ID)
1126         .Put8(EMBER_ZCL_REPORTING_DIRECTION_REPORTED)
1127         .Put16(0x0000)
1128         .Put8(32)
1129         .Put16(minInterval)
1130         .Put16(maxInterval);
1131     buf.Put8(static_cast<uint8_t>(change));
1132     COMMAND_FOOTER();
1133 }
1134
1135 /*
1136  * Attribute CurrentSaturation
1137  */
1138 PacketBufferHandle encodeColorControlClusterReadCurrentSaturationAttribute(uint8_t seqNum, EndpointId destinationEndpoint)
1139 {
1140     COMMAND_HEADER("ReadColorControlCurrentSaturation", COLOR_CONTROL_CLUSTER_ID);
1141     buf.Put8(kFrameControlGlobalCommand).Put8(seqNum).Put8(ZCL_READ_ATTRIBUTES_COMMAND_ID).Put16(0x0001);
1142     COMMAND_FOOTER();
1143 }
1144
1145 PacketBufferHandle encodeColorControlClusterConfigureCurrentSaturationAttribute(uint8_t seqNum, EndpointId destinationEndpoint,
1146                                                                                 uint16_t minInterval, uint16_t maxInterval,
1147                                                                                 uint8_t change)
1148 {
1149     COMMAND_HEADER("ReportColorControlCurrentSaturation", COLOR_CONTROL_CLUSTER_ID);
1150     buf.Put8(kFrameControlGlobalCommand)
1151         .Put8(seqNum)
1152         .Put8(ZCL_CONFIGURE_REPORTING_COMMAND_ID)
1153         .Put8(EMBER_ZCL_REPORTING_DIRECTION_REPORTED)
1154         .Put16(0x0001)
1155         .Put8(32)
1156         .Put16(minInterval)
1157         .Put16(maxInterval);
1158     buf.Put8(static_cast<uint8_t>(change));
1159     COMMAND_FOOTER();
1160 }
1161
1162 /*
1163  * Attribute RemainingTime
1164  */
1165 PacketBufferHandle encodeColorControlClusterReadRemainingTimeAttribute(uint8_t seqNum, EndpointId destinationEndpoint)
1166 {
1167     COMMAND_HEADER("ReadColorControlRemainingTime", COLOR_CONTROL_CLUSTER_ID);
1168     buf.Put8(kFrameControlGlobalCommand).Put8(seqNum).Put8(ZCL_READ_ATTRIBUTES_COMMAND_ID).Put16(0x0002);
1169     COMMAND_FOOTER();
1170 }
1171
1172 /*
1173  * Attribute CurrentX
1174  */
1175 PacketBufferHandle encodeColorControlClusterReadCurrentXAttribute(uint8_t seqNum, EndpointId destinationEndpoint)
1176 {
1177     COMMAND_HEADER("ReadColorControlCurrentX", COLOR_CONTROL_CLUSTER_ID);
1178     buf.Put8(kFrameControlGlobalCommand).Put8(seqNum).Put8(ZCL_READ_ATTRIBUTES_COMMAND_ID).Put16(0x0003);
1179     COMMAND_FOOTER();
1180 }
1181
1182 PacketBufferHandle encodeColorControlClusterConfigureCurrentXAttribute(uint8_t seqNum, EndpointId destinationEndpoint,
1183                                                                        uint16_t minInterval, uint16_t maxInterval, uint16_t change)
1184 {
1185     COMMAND_HEADER("ReportColorControlCurrentX", COLOR_CONTROL_CLUSTER_ID);
1186     buf.Put8(kFrameControlGlobalCommand)
1187         .Put8(seqNum)
1188         .Put8(ZCL_CONFIGURE_REPORTING_COMMAND_ID)
1189         .Put8(EMBER_ZCL_REPORTING_DIRECTION_REPORTED)
1190         .Put16(0x0003)
1191         .Put8(33)
1192         .Put16(minInterval)
1193         .Put16(maxInterval);
1194     buf.Put16(static_cast<uint16_t>(change));
1195     COMMAND_FOOTER();
1196 }
1197
1198 /*
1199  * Attribute CurrentY
1200  */
1201 PacketBufferHandle encodeColorControlClusterReadCurrentYAttribute(uint8_t seqNum, EndpointId destinationEndpoint)
1202 {
1203     COMMAND_HEADER("ReadColorControlCurrentY", COLOR_CONTROL_CLUSTER_ID);
1204     buf.Put8(kFrameControlGlobalCommand).Put8(seqNum).Put8(ZCL_READ_ATTRIBUTES_COMMAND_ID).Put16(0x0004);
1205     COMMAND_FOOTER();
1206 }
1207
1208 PacketBufferHandle encodeColorControlClusterConfigureCurrentYAttribute(uint8_t seqNum, EndpointId destinationEndpoint,
1209                                                                        uint16_t minInterval, uint16_t maxInterval, uint16_t change)
1210 {
1211     COMMAND_HEADER("ReportColorControlCurrentY", COLOR_CONTROL_CLUSTER_ID);
1212     buf.Put8(kFrameControlGlobalCommand)
1213         .Put8(seqNum)
1214         .Put8(ZCL_CONFIGURE_REPORTING_COMMAND_ID)
1215         .Put8(EMBER_ZCL_REPORTING_DIRECTION_REPORTED)
1216         .Put16(0x0004)
1217         .Put8(33)
1218         .Put16(minInterval)
1219         .Put16(maxInterval);
1220     buf.Put16(static_cast<uint16_t>(change));
1221     COMMAND_FOOTER();
1222 }
1223
1224 /*
1225  * Attribute DriftCompensation
1226  */
1227 PacketBufferHandle encodeColorControlClusterReadDriftCompensationAttribute(uint8_t seqNum, EndpointId destinationEndpoint)
1228 {
1229     COMMAND_HEADER("ReadColorControlDriftCompensation", COLOR_CONTROL_CLUSTER_ID);
1230     buf.Put8(kFrameControlGlobalCommand).Put8(seqNum).Put8(ZCL_READ_ATTRIBUTES_COMMAND_ID).Put16(0x0005);
1231     COMMAND_FOOTER();
1232 }
1233
1234 /*
1235  * Attribute CompensationText
1236  */
1237 PacketBufferHandle encodeColorControlClusterReadCompensationTextAttribute(uint8_t seqNum, EndpointId destinationEndpoint)
1238 {
1239     COMMAND_HEADER("ReadColorControlCompensationText", COLOR_CONTROL_CLUSTER_ID);
1240     buf.Put8(kFrameControlGlobalCommand).Put8(seqNum).Put8(ZCL_READ_ATTRIBUTES_COMMAND_ID).Put16(0x0006);
1241     COMMAND_FOOTER();
1242 }
1243
1244 /*
1245  * Attribute ColorTemperature
1246  */
1247 PacketBufferHandle encodeColorControlClusterReadColorTemperatureAttribute(uint8_t seqNum, EndpointId destinationEndpoint)
1248 {
1249     COMMAND_HEADER("ReadColorControlColorTemperature", COLOR_CONTROL_CLUSTER_ID);
1250     buf.Put8(kFrameControlGlobalCommand).Put8(seqNum).Put8(ZCL_READ_ATTRIBUTES_COMMAND_ID).Put16(0x0007);
1251     COMMAND_FOOTER();
1252 }
1253
1254 PacketBufferHandle encodeColorControlClusterConfigureColorTemperatureAttribute(uint8_t seqNum, EndpointId destinationEndpoint,
1255                                                                                uint16_t minInterval, uint16_t maxInterval,
1256                                                                                uint16_t change)
1257 {
1258     COMMAND_HEADER("ReportColorControlColorTemperature", COLOR_CONTROL_CLUSTER_ID);
1259     buf.Put8(kFrameControlGlobalCommand)
1260         .Put8(seqNum)
1261         .Put8(ZCL_CONFIGURE_REPORTING_COMMAND_ID)
1262         .Put8(EMBER_ZCL_REPORTING_DIRECTION_REPORTED)
1263         .Put16(0x0007)
1264         .Put8(33)
1265         .Put16(minInterval)
1266         .Put16(maxInterval);
1267     buf.Put16(static_cast<uint16_t>(change));
1268     COMMAND_FOOTER();
1269 }
1270
1271 /*
1272  * Attribute ColorMode
1273  */
1274 PacketBufferHandle encodeColorControlClusterReadColorModeAttribute(uint8_t seqNum, EndpointId destinationEndpoint)
1275 {
1276     COMMAND_HEADER("ReadColorControlColorMode", COLOR_CONTROL_CLUSTER_ID);
1277     buf.Put8(kFrameControlGlobalCommand).Put8(seqNum).Put8(ZCL_READ_ATTRIBUTES_COMMAND_ID).Put16(0x0008);
1278     COMMAND_FOOTER();
1279 }
1280
1281 /*
1282  * Attribute ColorControlOptions
1283  */
1284 PacketBufferHandle encodeColorControlClusterReadColorControlOptionsAttribute(uint8_t seqNum, EndpointId destinationEndpoint)
1285 {
1286     COMMAND_HEADER("ReadColorControlColorControlOptions", COLOR_CONTROL_CLUSTER_ID);
1287     buf.Put8(kFrameControlGlobalCommand).Put8(seqNum).Put8(ZCL_READ_ATTRIBUTES_COMMAND_ID).Put16(0x000F);
1288     COMMAND_FOOTER();
1289 }
1290
1291 PacketBufferHandle encodeColorControlClusterWriteColorControlOptionsAttribute(uint8_t seqNum, EndpointId destinationEndpoint,
1292                                                                               uint8_t colorControlOptions)
1293 {
1294     COMMAND_HEADER("WriteColorControlColorControlOptions", COLOR_CONTROL_CLUSTER_ID);
1295     buf.Put8(kFrameControlGlobalCommand)
1296         .Put8(seqNum)
1297         .Put8(ZCL_WRITE_ATTRIBUTES_COMMAND_ID)
1298         .Put16(0x000F)
1299         .Put8(24)
1300         .Put8(static_cast<uint8_t>(colorControlOptions));
1301     COMMAND_FOOTER();
1302 }
1303
1304 /*
1305  * Attribute NumberOfPrimaries
1306  */
1307 PacketBufferHandle encodeColorControlClusterReadNumberOfPrimariesAttribute(uint8_t seqNum, EndpointId destinationEndpoint)
1308 {
1309     COMMAND_HEADER("ReadColorControlNumberOfPrimaries", COLOR_CONTROL_CLUSTER_ID);
1310     buf.Put8(kFrameControlGlobalCommand).Put8(seqNum).Put8(ZCL_READ_ATTRIBUTES_COMMAND_ID).Put16(0x0010);
1311     COMMAND_FOOTER();
1312 }
1313
1314 /*
1315  * Attribute Primary1X
1316  */
1317 PacketBufferHandle encodeColorControlClusterReadPrimary1XAttribute(uint8_t seqNum, EndpointId destinationEndpoint)
1318 {
1319     COMMAND_HEADER("ReadColorControlPrimary1X", COLOR_CONTROL_CLUSTER_ID);
1320     buf.Put8(kFrameControlGlobalCommand).Put8(seqNum).Put8(ZCL_READ_ATTRIBUTES_COMMAND_ID).Put16(0x0011);
1321     COMMAND_FOOTER();
1322 }
1323
1324 /*
1325  * Attribute Primary1Y
1326  */
1327 PacketBufferHandle encodeColorControlClusterReadPrimary1YAttribute(uint8_t seqNum, EndpointId destinationEndpoint)
1328 {
1329     COMMAND_HEADER("ReadColorControlPrimary1Y", COLOR_CONTROL_CLUSTER_ID);
1330     buf.Put8(kFrameControlGlobalCommand).Put8(seqNum).Put8(ZCL_READ_ATTRIBUTES_COMMAND_ID).Put16(0x0012);
1331     COMMAND_FOOTER();
1332 }
1333
1334 /*
1335  * Attribute Primary1Intensity
1336  */
1337 PacketBufferHandle encodeColorControlClusterReadPrimary1IntensityAttribute(uint8_t seqNum, EndpointId destinationEndpoint)
1338 {
1339     COMMAND_HEADER("ReadColorControlPrimary1Intensity", COLOR_CONTROL_CLUSTER_ID);
1340     buf.Put8(kFrameControlGlobalCommand).Put8(seqNum).Put8(ZCL_READ_ATTRIBUTES_COMMAND_ID).Put16(0x0013);
1341     COMMAND_FOOTER();
1342 }
1343
1344 /*
1345  * Attribute Primary2X
1346  */
1347 PacketBufferHandle encodeColorControlClusterReadPrimary2XAttribute(uint8_t seqNum, EndpointId destinationEndpoint)
1348 {
1349     COMMAND_HEADER("ReadColorControlPrimary2X", COLOR_CONTROL_CLUSTER_ID);
1350     buf.Put8(kFrameControlGlobalCommand).Put8(seqNum).Put8(ZCL_READ_ATTRIBUTES_COMMAND_ID).Put16(0x0015);
1351     COMMAND_FOOTER();
1352 }
1353
1354 /*
1355  * Attribute Primary2Y
1356  */
1357 PacketBufferHandle encodeColorControlClusterReadPrimary2YAttribute(uint8_t seqNum, EndpointId destinationEndpoint)
1358 {
1359     COMMAND_HEADER("ReadColorControlPrimary2Y", COLOR_CONTROL_CLUSTER_ID);
1360     buf.Put8(kFrameControlGlobalCommand).Put8(seqNum).Put8(ZCL_READ_ATTRIBUTES_COMMAND_ID).Put16(0x0016);
1361     COMMAND_FOOTER();
1362 }
1363
1364 /*
1365  * Attribute Primary2Intensity
1366  */
1367 PacketBufferHandle encodeColorControlClusterReadPrimary2IntensityAttribute(uint8_t seqNum, EndpointId destinationEndpoint)
1368 {
1369     COMMAND_HEADER("ReadColorControlPrimary2Intensity", COLOR_CONTROL_CLUSTER_ID);
1370     buf.Put8(kFrameControlGlobalCommand).Put8(seqNum).Put8(ZCL_READ_ATTRIBUTES_COMMAND_ID).Put16(0x0017);
1371     COMMAND_FOOTER();
1372 }
1373
1374 /*
1375  * Attribute Primary3X
1376  */
1377 PacketBufferHandle encodeColorControlClusterReadPrimary3XAttribute(uint8_t seqNum, EndpointId destinationEndpoint)
1378 {
1379     COMMAND_HEADER("ReadColorControlPrimary3X", COLOR_CONTROL_CLUSTER_ID);
1380     buf.Put8(kFrameControlGlobalCommand).Put8(seqNum).Put8(ZCL_READ_ATTRIBUTES_COMMAND_ID).Put16(0x0019);
1381     COMMAND_FOOTER();
1382 }
1383
1384 /*
1385  * Attribute Primary3Y
1386  */
1387 PacketBufferHandle encodeColorControlClusterReadPrimary3YAttribute(uint8_t seqNum, EndpointId destinationEndpoint)
1388 {
1389     COMMAND_HEADER("ReadColorControlPrimary3Y", COLOR_CONTROL_CLUSTER_ID);
1390     buf.Put8(kFrameControlGlobalCommand).Put8(seqNum).Put8(ZCL_READ_ATTRIBUTES_COMMAND_ID).Put16(0x001A);
1391     COMMAND_FOOTER();
1392 }
1393
1394 /*
1395  * Attribute Primary3Intensity
1396  */
1397 PacketBufferHandle encodeColorControlClusterReadPrimary3IntensityAttribute(uint8_t seqNum, EndpointId destinationEndpoint)
1398 {
1399     COMMAND_HEADER("ReadColorControlPrimary3Intensity", COLOR_CONTROL_CLUSTER_ID);
1400     buf.Put8(kFrameControlGlobalCommand).Put8(seqNum).Put8(ZCL_READ_ATTRIBUTES_COMMAND_ID).Put16(0x001B);
1401     COMMAND_FOOTER();
1402 }
1403
1404 /*
1405  * Attribute Primary4X
1406  */
1407 PacketBufferHandle encodeColorControlClusterReadPrimary4XAttribute(uint8_t seqNum, EndpointId destinationEndpoint)
1408 {
1409     COMMAND_HEADER("ReadColorControlPrimary4X", COLOR_CONTROL_CLUSTER_ID);
1410     buf.Put8(kFrameControlGlobalCommand).Put8(seqNum).Put8(ZCL_READ_ATTRIBUTES_COMMAND_ID).Put16(0x0020);
1411     COMMAND_FOOTER();
1412 }
1413
1414 /*
1415  * Attribute Primary4Y
1416  */
1417 PacketBufferHandle encodeColorControlClusterReadPrimary4YAttribute(uint8_t seqNum, EndpointId destinationEndpoint)
1418 {
1419     COMMAND_HEADER("ReadColorControlPrimary4Y", COLOR_CONTROL_CLUSTER_ID);
1420     buf.Put8(kFrameControlGlobalCommand).Put8(seqNum).Put8(ZCL_READ_ATTRIBUTES_COMMAND_ID).Put16(0x0021);
1421     COMMAND_FOOTER();
1422 }
1423
1424 /*
1425  * Attribute Primary4Intensity
1426  */
1427 PacketBufferHandle encodeColorControlClusterReadPrimary4IntensityAttribute(uint8_t seqNum, EndpointId destinationEndpoint)
1428 {
1429     COMMAND_HEADER("ReadColorControlPrimary4Intensity", COLOR_CONTROL_CLUSTER_ID);
1430     buf.Put8(kFrameControlGlobalCommand).Put8(seqNum).Put8(ZCL_READ_ATTRIBUTES_COMMAND_ID).Put16(0x0022);
1431     COMMAND_FOOTER();
1432 }
1433
1434 /*
1435  * Attribute Primary5X
1436  */
1437 PacketBufferHandle encodeColorControlClusterReadPrimary5XAttribute(uint8_t seqNum, EndpointId destinationEndpoint)
1438 {
1439     COMMAND_HEADER("ReadColorControlPrimary5X", COLOR_CONTROL_CLUSTER_ID);
1440     buf.Put8(kFrameControlGlobalCommand).Put8(seqNum).Put8(ZCL_READ_ATTRIBUTES_COMMAND_ID).Put16(0x0024);
1441     COMMAND_FOOTER();
1442 }
1443
1444 /*
1445  * Attribute Primary5Y
1446  */
1447 PacketBufferHandle encodeColorControlClusterReadPrimary5YAttribute(uint8_t seqNum, EndpointId destinationEndpoint)
1448 {
1449     COMMAND_HEADER("ReadColorControlPrimary5Y", COLOR_CONTROL_CLUSTER_ID);
1450     buf.Put8(kFrameControlGlobalCommand).Put8(seqNum).Put8(ZCL_READ_ATTRIBUTES_COMMAND_ID).Put16(0x0025);
1451     COMMAND_FOOTER();
1452 }
1453
1454 /*
1455  * Attribute Primary5Intensity
1456  */
1457 PacketBufferHandle encodeColorControlClusterReadPrimary5IntensityAttribute(uint8_t seqNum, EndpointId destinationEndpoint)
1458 {
1459     COMMAND_HEADER("ReadColorControlPrimary5Intensity", COLOR_CONTROL_CLUSTER_ID);
1460     buf.Put8(kFrameControlGlobalCommand).Put8(seqNum).Put8(ZCL_READ_ATTRIBUTES_COMMAND_ID).Put16(0x0026);
1461     COMMAND_FOOTER();
1462 }
1463
1464 /*
1465  * Attribute Primary6X
1466  */
1467 PacketBufferHandle encodeColorControlClusterReadPrimary6XAttribute(uint8_t seqNum, EndpointId destinationEndpoint)
1468 {
1469     COMMAND_HEADER("ReadColorControlPrimary6X", COLOR_CONTROL_CLUSTER_ID);
1470     buf.Put8(kFrameControlGlobalCommand).Put8(seqNum).Put8(ZCL_READ_ATTRIBUTES_COMMAND_ID).Put16(0x0028);
1471     COMMAND_FOOTER();
1472 }
1473
1474 /*
1475  * Attribute Primary6Y
1476  */
1477 PacketBufferHandle encodeColorControlClusterReadPrimary6YAttribute(uint8_t seqNum, EndpointId destinationEndpoint)
1478 {
1479     COMMAND_HEADER("ReadColorControlPrimary6Y", COLOR_CONTROL_CLUSTER_ID);
1480     buf.Put8(kFrameControlGlobalCommand).Put8(seqNum).Put8(ZCL_READ_ATTRIBUTES_COMMAND_ID).Put16(0x0029);
1481     COMMAND_FOOTER();
1482 }
1483
1484 /*
1485  * Attribute Primary6Intensity
1486  */
1487 PacketBufferHandle encodeColorControlClusterReadPrimary6IntensityAttribute(uint8_t seqNum, EndpointId destinationEndpoint)
1488 {
1489     COMMAND_HEADER("ReadColorControlPrimary6Intensity", COLOR_CONTROL_CLUSTER_ID);
1490     buf.Put8(kFrameControlGlobalCommand).Put8(seqNum).Put8(ZCL_READ_ATTRIBUTES_COMMAND_ID).Put16(0x002A);
1491     COMMAND_FOOTER();
1492 }
1493
1494 /*
1495  * Attribute WhitePointX
1496  */
1497 PacketBufferHandle encodeColorControlClusterReadWhitePointXAttribute(uint8_t seqNum, EndpointId destinationEndpoint)
1498 {
1499     COMMAND_HEADER("ReadColorControlWhitePointX", COLOR_CONTROL_CLUSTER_ID);
1500     buf.Put8(kFrameControlGlobalCommand).Put8(seqNum).Put8(ZCL_READ_ATTRIBUTES_COMMAND_ID).Put16(0x0030);
1501     COMMAND_FOOTER();
1502 }
1503
1504 PacketBufferHandle encodeColorControlClusterWriteWhitePointXAttribute(uint8_t seqNum, EndpointId destinationEndpoint,
1505                                                                       uint16_t whitePointX)
1506 {
1507     COMMAND_HEADER("WriteColorControlWhitePointX", COLOR_CONTROL_CLUSTER_ID);
1508     buf.Put8(kFrameControlGlobalCommand)
1509         .Put8(seqNum)
1510         .Put8(ZCL_WRITE_ATTRIBUTES_COMMAND_ID)
1511         .Put16(0x0030)
1512         .Put8(33)
1513         .Put16(static_cast<uint16_t>(whitePointX));
1514     COMMAND_FOOTER();
1515 }
1516
1517 /*
1518  * Attribute WhitePointY
1519  */
1520 PacketBufferHandle encodeColorControlClusterReadWhitePointYAttribute(uint8_t seqNum, EndpointId destinationEndpoint)
1521 {
1522     COMMAND_HEADER("ReadColorControlWhitePointY", COLOR_CONTROL_CLUSTER_ID);
1523     buf.Put8(kFrameControlGlobalCommand).Put8(seqNum).Put8(ZCL_READ_ATTRIBUTES_COMMAND_ID).Put16(0x0031);
1524     COMMAND_FOOTER();
1525 }
1526
1527 PacketBufferHandle encodeColorControlClusterWriteWhitePointYAttribute(uint8_t seqNum, EndpointId destinationEndpoint,
1528                                                                       uint16_t whitePointY)
1529 {
1530     COMMAND_HEADER("WriteColorControlWhitePointY", COLOR_CONTROL_CLUSTER_ID);
1531     buf.Put8(kFrameControlGlobalCommand)
1532         .Put8(seqNum)
1533         .Put8(ZCL_WRITE_ATTRIBUTES_COMMAND_ID)
1534         .Put16(0x0031)
1535         .Put8(33)
1536         .Put16(static_cast<uint16_t>(whitePointY));
1537     COMMAND_FOOTER();
1538 }
1539
1540 /*
1541  * Attribute ColorPointRX
1542  */
1543 PacketBufferHandle encodeColorControlClusterReadColorPointRXAttribute(uint8_t seqNum, EndpointId destinationEndpoint)
1544 {
1545     COMMAND_HEADER("ReadColorControlColorPointRX", COLOR_CONTROL_CLUSTER_ID);
1546     buf.Put8(kFrameControlGlobalCommand).Put8(seqNum).Put8(ZCL_READ_ATTRIBUTES_COMMAND_ID).Put16(0x0032);
1547     COMMAND_FOOTER();
1548 }
1549
1550 PacketBufferHandle encodeColorControlClusterWriteColorPointRXAttribute(uint8_t seqNum, EndpointId destinationEndpoint,
1551                                                                        uint16_t colorPointRX)
1552 {
1553     COMMAND_HEADER("WriteColorControlColorPointRX", COLOR_CONTROL_CLUSTER_ID);
1554     buf.Put8(kFrameControlGlobalCommand)
1555         .Put8(seqNum)
1556         .Put8(ZCL_WRITE_ATTRIBUTES_COMMAND_ID)
1557         .Put16(0x0032)
1558         .Put8(33)
1559         .Put16(static_cast<uint16_t>(colorPointRX));
1560     COMMAND_FOOTER();
1561 }
1562
1563 /*
1564  * Attribute ColorPointRY
1565  */
1566 PacketBufferHandle encodeColorControlClusterReadColorPointRYAttribute(uint8_t seqNum, EndpointId destinationEndpoint)
1567 {
1568     COMMAND_HEADER("ReadColorControlColorPointRY", COLOR_CONTROL_CLUSTER_ID);
1569     buf.Put8(kFrameControlGlobalCommand).Put8(seqNum).Put8(ZCL_READ_ATTRIBUTES_COMMAND_ID).Put16(0x0033);
1570     COMMAND_FOOTER();
1571 }
1572
1573 PacketBufferHandle encodeColorControlClusterWriteColorPointRYAttribute(uint8_t seqNum, EndpointId destinationEndpoint,
1574                                                                        uint16_t colorPointRY)
1575 {
1576     COMMAND_HEADER("WriteColorControlColorPointRY", COLOR_CONTROL_CLUSTER_ID);
1577     buf.Put8(kFrameControlGlobalCommand)
1578         .Put8(seqNum)
1579         .Put8(ZCL_WRITE_ATTRIBUTES_COMMAND_ID)
1580         .Put16(0x0033)
1581         .Put8(33)
1582         .Put16(static_cast<uint16_t>(colorPointRY));
1583     COMMAND_FOOTER();
1584 }
1585
1586 /*
1587  * Attribute ColorPointRIntensity
1588  */
1589 PacketBufferHandle encodeColorControlClusterReadColorPointRIntensityAttribute(uint8_t seqNum, EndpointId destinationEndpoint)
1590 {
1591     COMMAND_HEADER("ReadColorControlColorPointRIntensity", COLOR_CONTROL_CLUSTER_ID);
1592     buf.Put8(kFrameControlGlobalCommand).Put8(seqNum).Put8(ZCL_READ_ATTRIBUTES_COMMAND_ID).Put16(0x0034);
1593     COMMAND_FOOTER();
1594 }
1595
1596 PacketBufferHandle encodeColorControlClusterWriteColorPointRIntensityAttribute(uint8_t seqNum, EndpointId destinationEndpoint,
1597                                                                                uint8_t colorPointRIntensity)
1598 {
1599     COMMAND_HEADER("WriteColorControlColorPointRIntensity", COLOR_CONTROL_CLUSTER_ID);
1600     buf.Put8(kFrameControlGlobalCommand)
1601         .Put8(seqNum)
1602         .Put8(ZCL_WRITE_ATTRIBUTES_COMMAND_ID)
1603         .Put16(0x0034)
1604         .Put8(32)
1605         .Put8(static_cast<uint8_t>(colorPointRIntensity));
1606     COMMAND_FOOTER();
1607 }
1608
1609 /*
1610  * Attribute ColorPointGX
1611  */
1612 PacketBufferHandle encodeColorControlClusterReadColorPointGXAttribute(uint8_t seqNum, EndpointId destinationEndpoint)
1613 {
1614     COMMAND_HEADER("ReadColorControlColorPointGX", COLOR_CONTROL_CLUSTER_ID);
1615     buf.Put8(kFrameControlGlobalCommand).Put8(seqNum).Put8(ZCL_READ_ATTRIBUTES_COMMAND_ID).Put16(0x0036);
1616     COMMAND_FOOTER();
1617 }
1618
1619 PacketBufferHandle encodeColorControlClusterWriteColorPointGXAttribute(uint8_t seqNum, EndpointId destinationEndpoint,
1620                                                                        uint16_t colorPointGX)
1621 {
1622     COMMAND_HEADER("WriteColorControlColorPointGX", COLOR_CONTROL_CLUSTER_ID);
1623     buf.Put8(kFrameControlGlobalCommand)
1624         .Put8(seqNum)
1625         .Put8(ZCL_WRITE_ATTRIBUTES_COMMAND_ID)
1626         .Put16(0x0036)
1627         .Put8(33)
1628         .Put16(static_cast<uint16_t>(colorPointGX));
1629     COMMAND_FOOTER();
1630 }
1631
1632 /*
1633  * Attribute ColorPointGY
1634  */
1635 PacketBufferHandle encodeColorControlClusterReadColorPointGYAttribute(uint8_t seqNum, EndpointId destinationEndpoint)
1636 {
1637     COMMAND_HEADER("ReadColorControlColorPointGY", COLOR_CONTROL_CLUSTER_ID);
1638     buf.Put8(kFrameControlGlobalCommand).Put8(seqNum).Put8(ZCL_READ_ATTRIBUTES_COMMAND_ID).Put16(0x0037);
1639     COMMAND_FOOTER();
1640 }
1641
1642 PacketBufferHandle encodeColorControlClusterWriteColorPointGYAttribute(uint8_t seqNum, EndpointId destinationEndpoint,
1643                                                                        uint16_t colorPointGY)
1644 {
1645     COMMAND_HEADER("WriteColorControlColorPointGY", COLOR_CONTROL_CLUSTER_ID);
1646     buf.Put8(kFrameControlGlobalCommand)
1647         .Put8(seqNum)
1648         .Put8(ZCL_WRITE_ATTRIBUTES_COMMAND_ID)
1649         .Put16(0x0037)
1650         .Put8(33)
1651         .Put16(static_cast<uint16_t>(colorPointGY));
1652     COMMAND_FOOTER();
1653 }
1654
1655 /*
1656  * Attribute ColorPointGIntensity
1657  */
1658 PacketBufferHandle encodeColorControlClusterReadColorPointGIntensityAttribute(uint8_t seqNum, EndpointId destinationEndpoint)
1659 {
1660     COMMAND_HEADER("ReadColorControlColorPointGIntensity", COLOR_CONTROL_CLUSTER_ID);
1661     buf.Put8(kFrameControlGlobalCommand).Put8(seqNum).Put8(ZCL_READ_ATTRIBUTES_COMMAND_ID).Put16(0x0038);
1662     COMMAND_FOOTER();
1663 }
1664
1665 PacketBufferHandle encodeColorControlClusterWriteColorPointGIntensityAttribute(uint8_t seqNum, EndpointId destinationEndpoint,
1666                                                                                uint8_t colorPointGIntensity)
1667 {
1668     COMMAND_HEADER("WriteColorControlColorPointGIntensity", COLOR_CONTROL_CLUSTER_ID);
1669     buf.Put8(kFrameControlGlobalCommand)
1670         .Put8(seqNum)
1671         .Put8(ZCL_WRITE_ATTRIBUTES_COMMAND_ID)
1672         .Put16(0x0038)
1673         .Put8(32)
1674         .Put8(static_cast<uint8_t>(colorPointGIntensity));
1675     COMMAND_FOOTER();
1676 }
1677
1678 /*
1679  * Attribute ColorPointBX
1680  */
1681 PacketBufferHandle encodeColorControlClusterReadColorPointBXAttribute(uint8_t seqNum, EndpointId destinationEndpoint)
1682 {
1683     COMMAND_HEADER("ReadColorControlColorPointBX", COLOR_CONTROL_CLUSTER_ID);
1684     buf.Put8(kFrameControlGlobalCommand).Put8(seqNum).Put8(ZCL_READ_ATTRIBUTES_COMMAND_ID).Put16(0x003A);
1685     COMMAND_FOOTER();
1686 }
1687
1688 PacketBufferHandle encodeColorControlClusterWriteColorPointBXAttribute(uint8_t seqNum, EndpointId destinationEndpoint,
1689                                                                        uint16_t colorPointBX)
1690 {
1691     COMMAND_HEADER("WriteColorControlColorPointBX", COLOR_CONTROL_CLUSTER_ID);
1692     buf.Put8(kFrameControlGlobalCommand)
1693         .Put8(seqNum)
1694         .Put8(ZCL_WRITE_ATTRIBUTES_COMMAND_ID)
1695         .Put16(0x003A)
1696         .Put8(33)
1697         .Put16(static_cast<uint16_t>(colorPointBX));
1698     COMMAND_FOOTER();
1699 }
1700
1701 /*
1702  * Attribute ColorPointBY
1703  */
1704 PacketBufferHandle encodeColorControlClusterReadColorPointBYAttribute(uint8_t seqNum, EndpointId destinationEndpoint)
1705 {
1706     COMMAND_HEADER("ReadColorControlColorPointBY", COLOR_CONTROL_CLUSTER_ID);
1707     buf.Put8(kFrameControlGlobalCommand).Put8(seqNum).Put8(ZCL_READ_ATTRIBUTES_COMMAND_ID).Put16(0x003B);
1708     COMMAND_FOOTER();
1709 }
1710
1711 PacketBufferHandle encodeColorControlClusterWriteColorPointBYAttribute(uint8_t seqNum, EndpointId destinationEndpoint,
1712                                                                        uint16_t colorPointBY)
1713 {
1714     COMMAND_HEADER("WriteColorControlColorPointBY", COLOR_CONTROL_CLUSTER_ID);
1715     buf.Put8(kFrameControlGlobalCommand)
1716         .Put8(seqNum)
1717         .Put8(ZCL_WRITE_ATTRIBUTES_COMMAND_ID)
1718         .Put16(0x003B)
1719         .Put8(33)
1720         .Put16(static_cast<uint16_t>(colorPointBY));
1721     COMMAND_FOOTER();
1722 }
1723
1724 /*
1725  * Attribute ColorPointBIntensity
1726  */
1727 PacketBufferHandle encodeColorControlClusterReadColorPointBIntensityAttribute(uint8_t seqNum, EndpointId destinationEndpoint)
1728 {
1729     COMMAND_HEADER("ReadColorControlColorPointBIntensity", COLOR_CONTROL_CLUSTER_ID);
1730     buf.Put8(kFrameControlGlobalCommand).Put8(seqNum).Put8(ZCL_READ_ATTRIBUTES_COMMAND_ID).Put16(0x003C);
1731     COMMAND_FOOTER();
1732 }
1733
1734 PacketBufferHandle encodeColorControlClusterWriteColorPointBIntensityAttribute(uint8_t seqNum, EndpointId destinationEndpoint,
1735                                                                                uint8_t colorPointBIntensity)
1736 {
1737     COMMAND_HEADER("WriteColorControlColorPointBIntensity", COLOR_CONTROL_CLUSTER_ID);
1738     buf.Put8(kFrameControlGlobalCommand)
1739         .Put8(seqNum)
1740         .Put8(ZCL_WRITE_ATTRIBUTES_COMMAND_ID)
1741         .Put16(0x003C)
1742         .Put8(32)
1743         .Put8(static_cast<uint8_t>(colorPointBIntensity));
1744     COMMAND_FOOTER();
1745 }
1746
1747 /*
1748  * Attribute EnhancedCurrentHue
1749  */
1750 PacketBufferHandle encodeColorControlClusterReadEnhancedCurrentHueAttribute(uint8_t seqNum, EndpointId destinationEndpoint)
1751 {
1752     COMMAND_HEADER("ReadColorControlEnhancedCurrentHue", COLOR_CONTROL_CLUSTER_ID);
1753     buf.Put8(kFrameControlGlobalCommand).Put8(seqNum).Put8(ZCL_READ_ATTRIBUTES_COMMAND_ID).Put16(0x4000);
1754     COMMAND_FOOTER();
1755 }
1756
1757 /*
1758  * Attribute EnhancedColorMode
1759  */
1760 PacketBufferHandle encodeColorControlClusterReadEnhancedColorModeAttribute(uint8_t seqNum, EndpointId destinationEndpoint)
1761 {
1762     COMMAND_HEADER("ReadColorControlEnhancedColorMode", COLOR_CONTROL_CLUSTER_ID);
1763     buf.Put8(kFrameControlGlobalCommand).Put8(seqNum).Put8(ZCL_READ_ATTRIBUTES_COMMAND_ID).Put16(0x4001);
1764     COMMAND_FOOTER();
1765 }
1766
1767 /*
1768  * Attribute ColorLoopActive
1769  */
1770 PacketBufferHandle encodeColorControlClusterReadColorLoopActiveAttribute(uint8_t seqNum, EndpointId destinationEndpoint)
1771 {
1772     COMMAND_HEADER("ReadColorControlColorLoopActive", COLOR_CONTROL_CLUSTER_ID);
1773     buf.Put8(kFrameControlGlobalCommand).Put8(seqNum).Put8(ZCL_READ_ATTRIBUTES_COMMAND_ID).Put16(0x4002);
1774     COMMAND_FOOTER();
1775 }
1776
1777 /*
1778  * Attribute ColorLoopDirection
1779  */
1780 PacketBufferHandle encodeColorControlClusterReadColorLoopDirectionAttribute(uint8_t seqNum, EndpointId destinationEndpoint)
1781 {
1782     COMMAND_HEADER("ReadColorControlColorLoopDirection", COLOR_CONTROL_CLUSTER_ID);
1783     buf.Put8(kFrameControlGlobalCommand).Put8(seqNum).Put8(ZCL_READ_ATTRIBUTES_COMMAND_ID).Put16(0x4003);
1784     COMMAND_FOOTER();
1785 }
1786
1787 /*
1788  * Attribute ColorLoopTime
1789  */
1790 PacketBufferHandle encodeColorControlClusterReadColorLoopTimeAttribute(uint8_t seqNum, EndpointId destinationEndpoint)
1791 {
1792     COMMAND_HEADER("ReadColorControlColorLoopTime", COLOR_CONTROL_CLUSTER_ID);
1793     buf.Put8(kFrameControlGlobalCommand).Put8(seqNum).Put8(ZCL_READ_ATTRIBUTES_COMMAND_ID).Put16(0x4004);
1794     COMMAND_FOOTER();
1795 }
1796
1797 /*
1798  * Attribute ColorCapabilities
1799  */
1800 PacketBufferHandle encodeColorControlClusterReadColorCapabilitiesAttribute(uint8_t seqNum, EndpointId destinationEndpoint)
1801 {
1802     COMMAND_HEADER("ReadColorControlColorCapabilities", COLOR_CONTROL_CLUSTER_ID);
1803     buf.Put8(kFrameControlGlobalCommand).Put8(seqNum).Put8(ZCL_READ_ATTRIBUTES_COMMAND_ID).Put16(0x400A);
1804     COMMAND_FOOTER();
1805 }
1806
1807 /*
1808  * Attribute ColorTempPhysicalMin
1809  */
1810 PacketBufferHandle encodeColorControlClusterReadColorTempPhysicalMinAttribute(uint8_t seqNum, EndpointId destinationEndpoint)
1811 {
1812     COMMAND_HEADER("ReadColorControlColorTempPhysicalMin", COLOR_CONTROL_CLUSTER_ID);
1813     buf.Put8(kFrameControlGlobalCommand).Put8(seqNum).Put8(ZCL_READ_ATTRIBUTES_COMMAND_ID).Put16(0x400B);
1814     COMMAND_FOOTER();
1815 }
1816
1817 /*
1818  * Attribute ColorTempPhysicalMax
1819  */
1820 PacketBufferHandle encodeColorControlClusterReadColorTempPhysicalMaxAttribute(uint8_t seqNum, EndpointId destinationEndpoint)
1821 {
1822     COMMAND_HEADER("ReadColorControlColorTempPhysicalMax", COLOR_CONTROL_CLUSTER_ID);
1823     buf.Put8(kFrameControlGlobalCommand).Put8(seqNum).Put8(ZCL_READ_ATTRIBUTES_COMMAND_ID).Put16(0x400C);
1824     COMMAND_FOOTER();
1825 }
1826
1827 /*
1828  * Attribute CoupleColorTempToLevelMinMireds
1829  */
1830 PacketBufferHandle encodeColorControlClusterReadCoupleColorTempToLevelMinMiredsAttribute(uint8_t seqNum,
1831                                                                                          EndpointId destinationEndpoint)
1832 {
1833     COMMAND_HEADER("ReadColorControlCoupleColorTempToLevelMinMireds", COLOR_CONTROL_CLUSTER_ID);
1834     buf.Put8(kFrameControlGlobalCommand).Put8(seqNum).Put8(ZCL_READ_ATTRIBUTES_COMMAND_ID).Put16(0x400D);
1835     COMMAND_FOOTER();
1836 }
1837
1838 /*
1839  * Attribute StartUpColorTemperatureMireds
1840  */
1841 PacketBufferHandle encodeColorControlClusterReadStartUpColorTemperatureMiredsAttribute(uint8_t seqNum,
1842                                                                                        EndpointId destinationEndpoint)
1843 {
1844     COMMAND_HEADER("ReadColorControlStartUpColorTemperatureMireds", COLOR_CONTROL_CLUSTER_ID);
1845     buf.Put8(kFrameControlGlobalCommand).Put8(seqNum).Put8(ZCL_READ_ATTRIBUTES_COMMAND_ID).Put16(0x4010);
1846     COMMAND_FOOTER();
1847 }
1848
1849 PacketBufferHandle encodeColorControlClusterWriteStartUpColorTemperatureMiredsAttribute(uint8_t seqNum,
1850                                                                                         EndpointId destinationEndpoint,
1851                                                                                         uint16_t startUpColorTemperatureMireds)
1852 {
1853     COMMAND_HEADER("WriteColorControlStartUpColorTemperatureMireds", COLOR_CONTROL_CLUSTER_ID);
1854     buf.Put8(kFrameControlGlobalCommand)
1855         .Put8(seqNum)
1856         .Put8(ZCL_WRITE_ATTRIBUTES_COMMAND_ID)
1857         .Put16(0x4010)
1858         .Put8(33)
1859         .Put16(static_cast<uint16_t>(startUpColorTemperatureMireds));
1860     COMMAND_FOOTER();
1861 }
1862
1863 /*
1864  * Attribute ClusterRevision
1865  */
1866 PacketBufferHandle encodeColorControlClusterReadClusterRevisionAttribute(uint8_t seqNum, EndpointId destinationEndpoint)
1867 {
1868     COMMAND_HEADER("ReadColorControlClusterRevision", COLOR_CONTROL_CLUSTER_ID);
1869     buf.Put8(kFrameControlGlobalCommand).Put8(seqNum).Put8(ZCL_READ_ATTRIBUTES_COMMAND_ID).Put16(0xFFFD);
1870     COMMAND_FOOTER();
1871 }
1872
1873 /*----------------------------------------------------------------------------*\
1874 | Cluster ContentLaunch                                               | 0xF002 |
1875 |------------------------------------------------------------------------------|
1876 | Commands:                                                           |        |
1877 | * LaunchContent                                                     |   0x00 |
1878 | * LaunchURL                                                         |   0x01 |
1879 |------------------------------------------------------------------------------|
1880 | Attributes:                                                         |        |
1881 | * ClusterRevision                                                   | 0xFFFD |
1882 \*----------------------------------------------------------------------------*/
1883
1884 /*
1885  * Command LaunchContent
1886  */
1887 PacketBufferHandle encodeContentLaunchClusterLaunchContentCommand(uint8_t seqNum, EndpointId destinationEndpoint)
1888 {
1889     COMMAND_HEADER("LaunchContent", CONTENT_LAUNCH_CLUSTER_ID);
1890     buf.Put8(kFrameControlClusterSpecificCommand).Put8(seqNum).Put8(ZCL_LAUNCH_CONTENT_COMMAND_ID);
1891     COMMAND_FOOTER();
1892 }
1893
1894 /*
1895  * Command LaunchURL
1896  */
1897 PacketBufferHandle encodeContentLaunchClusterLaunchURLCommand(uint8_t seqNum, EndpointId destinationEndpoint)
1898 {
1899     COMMAND_HEADER("LaunchURL", CONTENT_LAUNCH_CLUSTER_ID);
1900     buf.Put8(kFrameControlClusterSpecificCommand).Put8(seqNum).Put8(ZCL_LAUNCH_URL_COMMAND_ID);
1901     COMMAND_FOOTER();
1902 }
1903
1904 PacketBufferHandle encodeContentLaunchClusterDiscoverAttributes(uint8_t seqNum, EndpointId destinationEndpoint)
1905 {
1906     COMMAND_HEADER("DiscoverContentLaunchAttributes", CONTENT_LAUNCH_CLUSTER_ID);
1907     buf.Put8(kFrameControlGlobalCommand).Put8(seqNum).Put8(ZCL_DISCOVER_ATTRIBUTES_COMMAND_ID).Put16(0x0000).Put8(0xFF);
1908     COMMAND_FOOTER();
1909 }
1910
1911 /*
1912  * Attribute ClusterRevision
1913  */
1914 PacketBufferHandle encodeContentLaunchClusterReadClusterRevisionAttribute(uint8_t seqNum, EndpointId destinationEndpoint)
1915 {
1916     COMMAND_HEADER("ReadContentLaunchClusterRevision", CONTENT_LAUNCH_CLUSTER_ID);
1917     buf.Put8(kFrameControlGlobalCommand).Put8(seqNum).Put8(ZCL_READ_ATTRIBUTES_COMMAND_ID).Put16(0xFFFD);
1918     COMMAND_FOOTER();
1919 }
1920
1921 /*----------------------------------------------------------------------------*\
1922 | Cluster DoorLock                                                    | 0x0101 |
1923 |------------------------------------------------------------------------------|
1924 | Commands:                                                           |        |
1925 | * ClearAllPins                                                      |   0x08 |
1926 | * ClearAllRfids                                                     |   0x19 |
1927 | * ClearHolidaySchedule                                              |   0x13 |
1928 | * ClearPin                                                          |   0x07 |
1929 | * ClearRfid                                                         |   0x18 |
1930 | * ClearWeekdaySchedule                                              |   0x0D |
1931 | * ClearYeardaySchedule                                              |   0x10 |
1932 | * GetHolidaySchedule                                                |   0x12 |
1933 | * GetLogRecord                                                      |   0x04 |
1934 | * GetPin                                                            |   0x06 |
1935 | * GetRfid                                                           |   0x17 |
1936 | * GetUserType                                                       |   0x15 |
1937 | * GetWeekdaySchedule                                                |   0x0C |
1938 | * GetYeardaySchedule                                                |   0x0F |
1939 | * LockDoor                                                          |   0x00 |
1940 | * SetHolidaySchedule                                                |   0x11 |
1941 | * SetPin                                                            |   0x05 |
1942 | * SetRfid                                                           |   0x16 |
1943 | * SetUserType                                                       |   0x14 |
1944 | * SetWeekdaySchedule                                                |   0x0B |
1945 | * SetYeardaySchedule                                                |   0x0E |
1946 | * UnlockDoor                                                        |   0x01 |
1947 | * UnlockWithTimeout                                                 |   0x03 |
1948 |------------------------------------------------------------------------------|
1949 | Attributes:                                                         |        |
1950 | * LockState                                                         | 0x0000 |
1951 | * LockType                                                          | 0x0001 |
1952 | * ActuatorEnabled                                                   | 0x0002 |
1953 | * ClusterRevision                                                   | 0xFFFD |
1954 \*----------------------------------------------------------------------------*/
1955
1956 /*
1957  * Command ClearAllPins
1958  */
1959 PacketBufferHandle encodeDoorLockClusterClearAllPinsCommand(uint8_t seqNum, EndpointId destinationEndpoint)
1960 {
1961     COMMAND_HEADER("ClearAllPins", DOOR_LOCK_CLUSTER_ID);
1962     buf.Put8(kFrameControlClusterSpecificCommand).Put8(seqNum).Put8(ZCL_CLEAR_ALL_PINS_COMMAND_ID);
1963     COMMAND_FOOTER();
1964 }
1965
1966 /*
1967  * Command ClearAllRfids
1968  */
1969 PacketBufferHandle encodeDoorLockClusterClearAllRfidsCommand(uint8_t seqNum, EndpointId destinationEndpoint)
1970 {
1971     COMMAND_HEADER("ClearAllRfids", DOOR_LOCK_CLUSTER_ID);
1972     buf.Put8(kFrameControlClusterSpecificCommand).Put8(seqNum).Put8(ZCL_CLEAR_ALL_RFIDS_COMMAND_ID);
1973     COMMAND_FOOTER();
1974 }
1975
1976 /*
1977  * Command ClearHolidaySchedule
1978  */
1979 PacketBufferHandle encodeDoorLockClusterClearHolidayScheduleCommand(uint8_t seqNum, EndpointId destinationEndpoint,
1980                                                                     uint8_t scheduleId)
1981 {
1982     COMMAND_HEADER("ClearHolidaySchedule", DOOR_LOCK_CLUSTER_ID);
1983
1984     buf.Put8(kFrameControlClusterSpecificCommand).Put8(seqNum).Put8(ZCL_CLEAR_HOLIDAY_SCHEDULE_COMMAND_ID).Put8(scheduleId);
1985     COMMAND_FOOTER();
1986 }
1987
1988 /*
1989  * Command ClearPin
1990  */
1991 PacketBufferHandle encodeDoorLockClusterClearPinCommand(uint8_t seqNum, EndpointId destinationEndpoint, uint16_t userId)
1992 {
1993     COMMAND_HEADER("ClearPin", DOOR_LOCK_CLUSTER_ID);
1994
1995     buf.Put8(kFrameControlClusterSpecificCommand).Put8(seqNum).Put8(ZCL_CLEAR_PIN_COMMAND_ID).Put16(userId);
1996     COMMAND_FOOTER();
1997 }
1998
1999 /*
2000  * Command ClearRfid
2001  */
2002 PacketBufferHandle encodeDoorLockClusterClearRfidCommand(uint8_t seqNum, EndpointId destinationEndpoint, uint16_t userId)
2003 {
2004     COMMAND_HEADER("ClearRfid", DOOR_LOCK_CLUSTER_ID);
2005
2006     buf.Put8(kFrameControlClusterSpecificCommand).Put8(seqNum).Put8(ZCL_CLEAR_RFID_COMMAND_ID).Put16(userId);
2007     COMMAND_FOOTER();
2008 }
2009
2010 /*
2011  * Command ClearWeekdaySchedule
2012  */
2013 PacketBufferHandle encodeDoorLockClusterClearWeekdayScheduleCommand(uint8_t seqNum, EndpointId destinationEndpoint,
2014                                                                     uint8_t scheduleId, uint16_t userId)
2015 {
2016     COMMAND_HEADER("ClearWeekdaySchedule", DOOR_LOCK_CLUSTER_ID);
2017
2018     buf.Put8(kFrameControlClusterSpecificCommand)
2019         .Put8(seqNum)
2020         .Put8(ZCL_CLEAR_WEEKDAY_SCHEDULE_COMMAND_ID)
2021         .Put8(scheduleId)
2022         .Put16(userId);
2023     COMMAND_FOOTER();
2024 }
2025
2026 /*
2027  * Command ClearYeardaySchedule
2028  */
2029 PacketBufferHandle encodeDoorLockClusterClearYeardayScheduleCommand(uint8_t seqNum, EndpointId destinationEndpoint,
2030                                                                     uint8_t scheduleId, uint16_t userId)
2031 {
2032     COMMAND_HEADER("ClearYeardaySchedule", DOOR_LOCK_CLUSTER_ID);
2033
2034     buf.Put8(kFrameControlClusterSpecificCommand)
2035         .Put8(seqNum)
2036         .Put8(ZCL_CLEAR_YEARDAY_SCHEDULE_COMMAND_ID)
2037         .Put8(scheduleId)
2038         .Put16(userId);
2039     COMMAND_FOOTER();
2040 }
2041
2042 /*
2043  * Command GetHolidaySchedule
2044  */
2045 PacketBufferHandle encodeDoorLockClusterGetHolidayScheduleCommand(uint8_t seqNum, EndpointId destinationEndpoint,
2046                                                                   uint8_t scheduleId)
2047 {
2048     COMMAND_HEADER("GetHolidaySchedule", DOOR_LOCK_CLUSTER_ID);
2049
2050     buf.Put8(kFrameControlClusterSpecificCommand).Put8(seqNum).Put8(ZCL_GET_HOLIDAY_SCHEDULE_COMMAND_ID).Put8(scheduleId);
2051     COMMAND_FOOTER();
2052 }
2053
2054 /*
2055  * Command GetLogRecord
2056  */
2057 PacketBufferHandle encodeDoorLockClusterGetLogRecordCommand(uint8_t seqNum, EndpointId destinationEndpoint, uint16_t logIndex)
2058 {
2059     COMMAND_HEADER("GetLogRecord", DOOR_LOCK_CLUSTER_ID);
2060
2061     buf.Put8(kFrameControlClusterSpecificCommand).Put8(seqNum).Put8(ZCL_GET_LOG_RECORD_COMMAND_ID).Put16(logIndex);
2062     COMMAND_FOOTER();
2063 }
2064
2065 /*
2066  * Command GetPin
2067  */
2068 PacketBufferHandle encodeDoorLockClusterGetPinCommand(uint8_t seqNum, EndpointId destinationEndpoint, uint16_t userId)
2069 {
2070     COMMAND_HEADER("GetPin", DOOR_LOCK_CLUSTER_ID);
2071
2072     buf.Put8(kFrameControlClusterSpecificCommand).Put8(seqNum).Put8(ZCL_GET_PIN_COMMAND_ID).Put16(userId);
2073     COMMAND_FOOTER();
2074 }
2075
2076 /*
2077  * Command GetRfid
2078  */
2079 PacketBufferHandle encodeDoorLockClusterGetRfidCommand(uint8_t seqNum, EndpointId destinationEndpoint, uint16_t userId)
2080 {
2081     COMMAND_HEADER("GetRfid", DOOR_LOCK_CLUSTER_ID);
2082
2083     buf.Put8(kFrameControlClusterSpecificCommand).Put8(seqNum).Put8(ZCL_GET_RFID_COMMAND_ID).Put16(userId);
2084     COMMAND_FOOTER();
2085 }
2086
2087 /*
2088  * Command GetUserType
2089  */
2090 PacketBufferHandle encodeDoorLockClusterGetUserTypeCommand(uint8_t seqNum, EndpointId destinationEndpoint, uint16_t userId)
2091 {
2092     COMMAND_HEADER("GetUserType", DOOR_LOCK_CLUSTER_ID);
2093
2094     buf.Put8(kFrameControlClusterSpecificCommand).Put8(seqNum).Put8(ZCL_GET_USER_TYPE_COMMAND_ID).Put16(userId);
2095     COMMAND_FOOTER();
2096 }
2097
2098 /*
2099  * Command GetWeekdaySchedule
2100  */
2101 PacketBufferHandle encodeDoorLockClusterGetWeekdayScheduleCommand(uint8_t seqNum, EndpointId destinationEndpoint,
2102                                                                   uint8_t scheduleId, uint16_t userId)
2103 {
2104     COMMAND_HEADER("GetWeekdaySchedule", DOOR_LOCK_CLUSTER_ID);
2105
2106     buf.Put8(kFrameControlClusterSpecificCommand)
2107         .Put8(seqNum)
2108         .Put8(ZCL_GET_WEEKDAY_SCHEDULE_COMMAND_ID)
2109         .Put8(scheduleId)
2110         .Put16(userId);
2111     COMMAND_FOOTER();
2112 }
2113
2114 /*
2115  * Command GetYeardaySchedule
2116  */
2117 PacketBufferHandle encodeDoorLockClusterGetYeardayScheduleCommand(uint8_t seqNum, EndpointId destinationEndpoint,
2118                                                                   uint8_t scheduleId, uint16_t userId)
2119 {
2120     COMMAND_HEADER("GetYeardaySchedule", DOOR_LOCK_CLUSTER_ID);
2121
2122     buf.Put8(kFrameControlClusterSpecificCommand)
2123         .Put8(seqNum)
2124         .Put8(ZCL_GET_YEARDAY_SCHEDULE_COMMAND_ID)
2125         .Put8(scheduleId)
2126         .Put16(userId);
2127     COMMAND_FOOTER();
2128 }
2129
2130 /*
2131  * Command LockDoor
2132  */
2133 PacketBufferHandle encodeDoorLockClusterLockDoorCommand(uint8_t seqNum, EndpointId destinationEndpoint, chip::ByteSpan pin)
2134 {
2135     COMMAND_HEADER("LockDoor", DOOR_LOCK_CLUSTER_ID);
2136     size_t pinStrLen = pin.size();
2137     if (!CanCastTo<uint8_t>(pinStrLen))
2138     {
2139         ChipLogError(Zcl, "Error encoding %s command. String too long: %d", kName, pinStrLen);
2140         return PacketBufferHandle();
2141     }
2142
2143     buf.Put8(kFrameControlClusterSpecificCommand)
2144         .Put8(seqNum)
2145         .Put8(ZCL_LOCK_DOOR_COMMAND_ID)
2146         .Put(static_cast<uint8_t>(pinStrLen))
2147         .Put(pin.data(), pin.size());
2148     COMMAND_FOOTER();
2149 }
2150
2151 /*
2152  * Command SetHolidaySchedule
2153  */
2154 PacketBufferHandle encodeDoorLockClusterSetHolidayScheduleCommand(uint8_t seqNum, EndpointId destinationEndpoint,
2155                                                                   uint8_t scheduleId, uint32_t localStartTime,
2156                                                                   uint32_t localEndTime, uint8_t operatingModeDuringHoliday)
2157 {
2158     COMMAND_HEADER("SetHolidaySchedule", DOOR_LOCK_CLUSTER_ID);
2159
2160     buf.Put8(kFrameControlClusterSpecificCommand)
2161         .Put8(seqNum)
2162         .Put8(ZCL_SET_HOLIDAY_SCHEDULE_COMMAND_ID)
2163         .Put8(scheduleId)
2164         .Put32(localStartTime)
2165         .Put32(localEndTime)
2166         .Put8(operatingModeDuringHoliday);
2167     COMMAND_FOOTER();
2168 }
2169
2170 /*
2171  * Command SetPin
2172  */
2173 PacketBufferHandle encodeDoorLockClusterSetPinCommand(uint8_t seqNum, EndpointId destinationEndpoint, uint16_t userId,
2174                                                       uint8_t userStatus, uint8_t userType, chip::ByteSpan pin)
2175 {
2176     COMMAND_HEADER("SetPin", DOOR_LOCK_CLUSTER_ID);
2177
2178     size_t pinStrLen = pin.size();
2179     if (!CanCastTo<uint8_t>(pinStrLen))
2180     {
2181         ChipLogError(Zcl, "Error encoding %s command. String too long: %d", kName, pinStrLen);
2182         return PacketBufferHandle();
2183     }
2184
2185     buf.Put8(kFrameControlClusterSpecificCommand)
2186         .Put8(seqNum)
2187         .Put8(ZCL_SET_PIN_COMMAND_ID)
2188         .Put16(userId)
2189         .Put8(userStatus)
2190         .Put8(userType)
2191         .Put(static_cast<uint8_t>(pinStrLen))
2192         .Put(pin.data(), pin.size());
2193     COMMAND_FOOTER();
2194 }
2195
2196 /*
2197  * Command SetRfid
2198  */
2199 PacketBufferHandle encodeDoorLockClusterSetRfidCommand(uint8_t seqNum, EndpointId destinationEndpoint, uint16_t userId,
2200                                                        uint8_t userStatus, uint8_t userType, chip::ByteSpan id)
2201 {
2202     COMMAND_HEADER("SetRfid", DOOR_LOCK_CLUSTER_ID);
2203
2204     size_t idStrLen = id.size();
2205     if (!CanCastTo<uint8_t>(idStrLen))
2206     {
2207         ChipLogError(Zcl, "Error encoding %s command. String too long: %d", kName, idStrLen);
2208         return PacketBufferHandle();
2209     }
2210
2211     buf.Put8(kFrameControlClusterSpecificCommand)
2212         .Put8(seqNum)
2213         .Put8(ZCL_SET_RFID_COMMAND_ID)
2214         .Put16(userId)
2215         .Put8(userStatus)
2216         .Put8(userType)
2217         .Put(static_cast<uint8_t>(idStrLen))
2218         .Put(id.data(), id.size());
2219     COMMAND_FOOTER();
2220 }
2221
2222 /*
2223  * Command SetUserType
2224  */
2225 PacketBufferHandle encodeDoorLockClusterSetUserTypeCommand(uint8_t seqNum, EndpointId destinationEndpoint, uint16_t userId,
2226                                                            uint8_t userType)
2227 {
2228     COMMAND_HEADER("SetUserType", DOOR_LOCK_CLUSTER_ID);
2229
2230     buf.Put8(kFrameControlClusterSpecificCommand).Put8(seqNum).Put8(ZCL_SET_USER_TYPE_COMMAND_ID).Put16(userId).Put8(userType);
2231     COMMAND_FOOTER();
2232 }
2233
2234 /*
2235  * Command SetWeekdaySchedule
2236  */
2237 PacketBufferHandle encodeDoorLockClusterSetWeekdayScheduleCommand(uint8_t seqNum, EndpointId destinationEndpoint,
2238                                                                   uint8_t scheduleId, uint16_t userId, uint8_t daysMask,
2239                                                                   uint8_t startHour, uint8_t startMinute, uint8_t endHour,
2240                                                                   uint8_t endMinute)
2241 {
2242     COMMAND_HEADER("SetWeekdaySchedule", DOOR_LOCK_CLUSTER_ID);
2243
2244     buf.Put8(kFrameControlClusterSpecificCommand)
2245         .Put8(seqNum)
2246         .Put8(ZCL_SET_WEEKDAY_SCHEDULE_COMMAND_ID)
2247         .Put8(scheduleId)
2248         .Put16(userId)
2249         .Put8(daysMask)
2250         .Put8(startHour)
2251         .Put8(startMinute)
2252         .Put8(endHour)
2253         .Put8(endMinute);
2254     COMMAND_FOOTER();
2255 }
2256
2257 /*
2258  * Command SetYeardaySchedule
2259  */
2260 PacketBufferHandle encodeDoorLockClusterSetYeardayScheduleCommand(uint8_t seqNum, EndpointId destinationEndpoint,
2261                                                                   uint8_t scheduleId, uint16_t userId, uint32_t localStartTime,
2262                                                                   uint32_t localEndTime)
2263 {
2264     COMMAND_HEADER("SetYeardaySchedule", DOOR_LOCK_CLUSTER_ID);
2265
2266     buf.Put8(kFrameControlClusterSpecificCommand)
2267         .Put8(seqNum)
2268         .Put8(ZCL_SET_YEARDAY_SCHEDULE_COMMAND_ID)
2269         .Put8(scheduleId)
2270         .Put16(userId)
2271         .Put32(localStartTime)
2272         .Put32(localEndTime);
2273     COMMAND_FOOTER();
2274 }
2275
2276 /*
2277  * Command UnlockDoor
2278  */
2279 PacketBufferHandle encodeDoorLockClusterUnlockDoorCommand(uint8_t seqNum, EndpointId destinationEndpoint, chip::ByteSpan pin)
2280 {
2281     COMMAND_HEADER("UnlockDoor", DOOR_LOCK_CLUSTER_ID);
2282     size_t pinStrLen = pin.size();
2283     if (!CanCastTo<uint8_t>(pinStrLen))
2284     {
2285         ChipLogError(Zcl, "Error encoding %s command. String too long: %d", kName, pinStrLen);
2286         return PacketBufferHandle();
2287     }
2288
2289     buf.Put8(kFrameControlClusterSpecificCommand)
2290         .Put8(seqNum)
2291         .Put8(ZCL_UNLOCK_DOOR_COMMAND_ID)
2292         .Put(static_cast<uint8_t>(pinStrLen))
2293         .Put(pin.data(), pin.size());
2294     COMMAND_FOOTER();
2295 }
2296
2297 /*
2298  * Command UnlockWithTimeout
2299  */
2300 PacketBufferHandle encodeDoorLockClusterUnlockWithTimeoutCommand(uint8_t seqNum, EndpointId destinationEndpoint,
2301                                                                  uint16_t timeoutInSeconds, chip::ByteSpan pin)
2302 {
2303     COMMAND_HEADER("UnlockWithTimeout", DOOR_LOCK_CLUSTER_ID);
2304
2305     size_t pinStrLen = pin.size();
2306     if (!CanCastTo<uint8_t>(pinStrLen))
2307     {
2308         ChipLogError(Zcl, "Error encoding %s command. String too long: %d", kName, pinStrLen);
2309         return PacketBufferHandle();
2310     }
2311
2312     buf.Put8(kFrameControlClusterSpecificCommand)
2313         .Put8(seqNum)
2314         .Put8(ZCL_UNLOCK_WITH_TIMEOUT_COMMAND_ID)
2315         .Put16(timeoutInSeconds)
2316         .Put(static_cast<uint8_t>(pinStrLen))
2317         .Put(pin.data(), pin.size());
2318     COMMAND_FOOTER();
2319 }
2320
2321 PacketBufferHandle encodeDoorLockClusterDiscoverAttributes(uint8_t seqNum, EndpointId destinationEndpoint)
2322 {
2323     COMMAND_HEADER("DiscoverDoorLockAttributes", DOOR_LOCK_CLUSTER_ID);
2324     buf.Put8(kFrameControlGlobalCommand).Put8(seqNum).Put8(ZCL_DISCOVER_ATTRIBUTES_COMMAND_ID).Put16(0x0000).Put8(0xFF);
2325     COMMAND_FOOTER();
2326 }
2327
2328 /*
2329  * Attribute LockState
2330  */
2331 PacketBufferHandle encodeDoorLockClusterReadLockStateAttribute(uint8_t seqNum, EndpointId destinationEndpoint)
2332 {
2333     COMMAND_HEADER("ReadDoorLockLockState", DOOR_LOCK_CLUSTER_ID);
2334     buf.Put8(kFrameControlGlobalCommand).Put8(seqNum).Put8(ZCL_READ_ATTRIBUTES_COMMAND_ID).Put16(0x0000);
2335     COMMAND_FOOTER();
2336 }
2337
2338 PacketBufferHandle encodeDoorLockClusterConfigureLockStateAttribute(uint8_t seqNum, EndpointId destinationEndpoint,
2339                                                                     uint16_t minInterval, uint16_t maxInterval)
2340 {
2341     COMMAND_HEADER("ReportDoorLockLockState", DOOR_LOCK_CLUSTER_ID);
2342     buf.Put8(kFrameControlGlobalCommand)
2343         .Put8(seqNum)
2344         .Put8(ZCL_CONFIGURE_REPORTING_COMMAND_ID)
2345         .Put8(EMBER_ZCL_REPORTING_DIRECTION_REPORTED)
2346         .Put16(0x0000)
2347         .Put8(48)
2348         .Put16(minInterval)
2349         .Put16(maxInterval);
2350     COMMAND_FOOTER();
2351 }
2352
2353 /*
2354  * Attribute LockType
2355  */
2356 PacketBufferHandle encodeDoorLockClusterReadLockTypeAttribute(uint8_t seqNum, EndpointId destinationEndpoint)
2357 {
2358     COMMAND_HEADER("ReadDoorLockLockType", DOOR_LOCK_CLUSTER_ID);
2359     buf.Put8(kFrameControlGlobalCommand).Put8(seqNum).Put8(ZCL_READ_ATTRIBUTES_COMMAND_ID).Put16(0x0001);
2360     COMMAND_FOOTER();
2361 }
2362
2363 /*
2364  * Attribute ActuatorEnabled
2365  */
2366 PacketBufferHandle encodeDoorLockClusterReadActuatorEnabledAttribute(uint8_t seqNum, EndpointId destinationEndpoint)
2367 {
2368     COMMAND_HEADER("ReadDoorLockActuatorEnabled", DOOR_LOCK_CLUSTER_ID);
2369     buf.Put8(kFrameControlGlobalCommand).Put8(seqNum).Put8(ZCL_READ_ATTRIBUTES_COMMAND_ID).Put16(0x0002);
2370     COMMAND_FOOTER();
2371 }
2372
2373 /*
2374  * Attribute ClusterRevision
2375  */
2376 PacketBufferHandle encodeDoorLockClusterReadClusterRevisionAttribute(uint8_t seqNum, EndpointId destinationEndpoint)
2377 {
2378     COMMAND_HEADER("ReadDoorLockClusterRevision", DOOR_LOCK_CLUSTER_ID);
2379     buf.Put8(kFrameControlGlobalCommand).Put8(seqNum).Put8(ZCL_READ_ATTRIBUTES_COMMAND_ID).Put16(0xFFFD);
2380     COMMAND_FOOTER();
2381 }
2382
2383 /*----------------------------------------------------------------------------*\
2384 | Cluster GeneralCommissioning                                        | 0x0030 |
2385 |------------------------------------------------------------------------------|
2386 | Commands:                                                           |        |
2387 | * ArmFailSafe                                                       |   0x02 |
2388 | * CommissioningComplete                                             |   0x06 |
2389 | * SetFabric                                                         |   0x00 |
2390 |------------------------------------------------------------------------------|
2391 | Attributes:                                                         |        |
2392 | * FabricId                                                          | 0x0000 |
2393 | * Breadcrumb                                                        | 0x0001 |
2394 | * ClusterRevision                                                   | 0xFFFD |
2395 \*----------------------------------------------------------------------------*/
2396
2397 /*
2398  * Command ArmFailSafe
2399  */
2400 PacketBufferHandle encodeGeneralCommissioningClusterArmFailSafeCommand(uint8_t seqNum, EndpointId destinationEndpoint,
2401                                                                        uint16_t expiryLengthSeconds, uint64_t breadcrumb,
2402                                                                        uint32_t timeoutMs)
2403 {
2404     COMMAND_HEADER("ArmFailSafe", GENERAL_COMMISSIONING_CLUSTER_ID);
2405
2406     buf.Put8(kFrameControlClusterSpecificCommand)
2407         .Put8(seqNum)
2408         .Put8(ZCL_ARM_FAIL_SAFE_COMMAND_ID)
2409         .Put16(expiryLengthSeconds)
2410         .Put64(breadcrumb)
2411         .Put32(timeoutMs);
2412     COMMAND_FOOTER();
2413 }
2414
2415 /*
2416  * Command CommissioningComplete
2417  */
2418 PacketBufferHandle encodeGeneralCommissioningClusterCommissioningCompleteCommand(uint8_t seqNum, EndpointId destinationEndpoint)
2419 {
2420     COMMAND_HEADER("CommissioningComplete", GENERAL_COMMISSIONING_CLUSTER_ID);
2421     buf.Put8(kFrameControlClusterSpecificCommand).Put8(seqNum).Put8(ZCL_COMMISSIONING_COMPLETE_COMMAND_ID);
2422     COMMAND_FOOTER();
2423 }
2424
2425 /*
2426  * Command SetFabric
2427  */
2428 PacketBufferHandle encodeGeneralCommissioningClusterSetFabricCommand(uint8_t seqNum, EndpointId destinationEndpoint,
2429                                                                      chip::ByteSpan fabricId, chip::ByteSpan fabricSecret,
2430                                                                      uint64_t breadcrumb, uint32_t timeoutMs)
2431 {
2432     COMMAND_HEADER("SetFabric", GENERAL_COMMISSIONING_CLUSTER_ID);
2433     size_t fabricIdStrLen = fabricId.size();
2434     if (!CanCastTo<uint8_t>(fabricIdStrLen))
2435     {
2436         ChipLogError(Zcl, "Error encoding %s command. String too long: %d", kName, fabricIdStrLen);
2437         return PacketBufferHandle();
2438     }
2439
2440     size_t fabricSecretStrLen = fabricSecret.size();
2441     if (!CanCastTo<uint8_t>(fabricSecretStrLen))
2442     {
2443         ChipLogError(Zcl, "Error encoding %s command. String too long: %d", kName, fabricSecretStrLen);
2444         return PacketBufferHandle();
2445     }
2446
2447     buf.Put8(kFrameControlClusterSpecificCommand)
2448         .Put8(seqNum)
2449         .Put8(ZCL_SET_FABRIC_COMMAND_ID)
2450         .Put(static_cast<uint8_t>(fabricIdStrLen))
2451         .Put(fabricId.data(), fabricId.size())
2452         .Put(static_cast<uint8_t>(fabricSecretStrLen))
2453         .Put(fabricSecret.data(), fabricSecret.size())
2454         .Put64(breadcrumb)
2455         .Put32(timeoutMs);
2456     COMMAND_FOOTER();
2457 }
2458
2459 PacketBufferHandle encodeGeneralCommissioningClusterDiscoverAttributes(uint8_t seqNum, EndpointId destinationEndpoint)
2460 {
2461     COMMAND_HEADER("DiscoverGeneralCommissioningAttributes", GENERAL_COMMISSIONING_CLUSTER_ID);
2462     buf.Put8(kFrameControlGlobalCommand).Put8(seqNum).Put8(ZCL_DISCOVER_ATTRIBUTES_COMMAND_ID).Put16(0x0000).Put8(0xFF);
2463     COMMAND_FOOTER();
2464 }
2465
2466 /*
2467  * Attribute FabricId
2468  */
2469 PacketBufferHandle encodeGeneralCommissioningClusterReadFabricIdAttribute(uint8_t seqNum, EndpointId destinationEndpoint)
2470 {
2471     COMMAND_HEADER("ReadGeneralCommissioningFabricId", GENERAL_COMMISSIONING_CLUSTER_ID);
2472     buf.Put8(kFrameControlGlobalCommand).Put8(seqNum).Put8(ZCL_READ_ATTRIBUTES_COMMAND_ID).Put16(0x0000);
2473     COMMAND_FOOTER();
2474 }
2475
2476 /*
2477  * Attribute Breadcrumb
2478  */
2479 PacketBufferHandle encodeGeneralCommissioningClusterReadBreadcrumbAttribute(uint8_t seqNum, EndpointId destinationEndpoint)
2480 {
2481     COMMAND_HEADER("ReadGeneralCommissioningBreadcrumb", GENERAL_COMMISSIONING_CLUSTER_ID);
2482     buf.Put8(kFrameControlGlobalCommand).Put8(seqNum).Put8(ZCL_READ_ATTRIBUTES_COMMAND_ID).Put16(0x0001);
2483     COMMAND_FOOTER();
2484 }
2485
2486 PacketBufferHandle encodeGeneralCommissioningClusterWriteBreadcrumbAttribute(uint8_t seqNum, EndpointId destinationEndpoint,
2487                                                                              uint64_t breadcrumb)
2488 {
2489     COMMAND_HEADER("WriteGeneralCommissioningBreadcrumb", GENERAL_COMMISSIONING_CLUSTER_ID);
2490     buf.Put8(kFrameControlGlobalCommand)
2491         .Put8(seqNum)
2492         .Put8(ZCL_WRITE_ATTRIBUTES_COMMAND_ID)
2493         .Put16(0x0001)
2494         .Put8(39)
2495         .Put64(static_cast<uint64_t>(breadcrumb));
2496     COMMAND_FOOTER();
2497 }
2498
2499 /*
2500  * Attribute ClusterRevision
2501  */
2502 PacketBufferHandle encodeGeneralCommissioningClusterReadClusterRevisionAttribute(uint8_t seqNum, EndpointId destinationEndpoint)
2503 {
2504     COMMAND_HEADER("ReadGeneralCommissioningClusterRevision", GENERAL_COMMISSIONING_CLUSTER_ID);
2505     buf.Put8(kFrameControlGlobalCommand).Put8(seqNum).Put8(ZCL_READ_ATTRIBUTES_COMMAND_ID).Put16(0xFFFD);
2506     COMMAND_FOOTER();
2507 }
2508
2509 /*----------------------------------------------------------------------------*\
2510 | Cluster Groups                                                      | 0x0004 |
2511 |------------------------------------------------------------------------------|
2512 | Commands:                                                           |        |
2513 | * AddGroup                                                          |   0x00 |
2514 | * AddGroupIfIdentifying                                             |   0x05 |
2515 | * GetGroupMembership                                                |   0x02 |
2516 | * RemoveAllGroups                                                   |   0x04 |
2517 | * RemoveGroup                                                       |   0x03 |
2518 | * ViewGroup                                                         |   0x01 |
2519 |------------------------------------------------------------------------------|
2520 | Attributes:                                                         |        |
2521 | * NameSupport                                                       | 0x0000 |
2522 | * ClusterRevision                                                   | 0xFFFD |
2523 \*----------------------------------------------------------------------------*/
2524
2525 /*
2526  * Command AddGroup
2527  */
2528 PacketBufferHandle encodeGroupsClusterAddGroupCommand(uint8_t seqNum, EndpointId destinationEndpoint, uint16_t groupId,
2529                                                       chip::ByteSpan groupName)
2530 {
2531     COMMAND_HEADER("AddGroup", GROUPS_CLUSTER_ID);
2532
2533     size_t groupNameStrLen = groupName.size();
2534     if (!CanCastTo<uint8_t>(groupNameStrLen))
2535     {
2536         ChipLogError(Zcl, "Error encoding %s command. String too long: %d", kName, groupNameStrLen);
2537         return PacketBufferHandle();
2538     }
2539
2540     buf.Put8(kFrameControlClusterSpecificCommand)
2541         .Put8(seqNum)
2542         .Put8(ZCL_ADD_GROUP_COMMAND_ID)
2543         .Put16(groupId)
2544         .Put(static_cast<uint8_t>(groupNameStrLen))
2545         .Put(groupName.data(), groupName.size());
2546     COMMAND_FOOTER();
2547 }
2548
2549 /*
2550  * Command AddGroupIfIdentifying
2551  */
2552 PacketBufferHandle encodeGroupsClusterAddGroupIfIdentifyingCommand(uint8_t seqNum, EndpointId destinationEndpoint, uint16_t groupId,
2553                                                                    chip::ByteSpan groupName)
2554 {
2555     COMMAND_HEADER("AddGroupIfIdentifying", GROUPS_CLUSTER_ID);
2556
2557     size_t groupNameStrLen = groupName.size();
2558     if (!CanCastTo<uint8_t>(groupNameStrLen))
2559     {
2560         ChipLogError(Zcl, "Error encoding %s command. String too long: %d", kName, groupNameStrLen);
2561         return PacketBufferHandle();
2562     }
2563
2564     buf.Put8(kFrameControlClusterSpecificCommand)
2565         .Put8(seqNum)
2566         .Put8(ZCL_ADD_GROUP_IF_IDENTIFYING_COMMAND_ID)
2567         .Put16(groupId)
2568         .Put(static_cast<uint8_t>(groupNameStrLen))
2569         .Put(groupName.data(), groupName.size());
2570     COMMAND_FOOTER();
2571 }
2572
2573 /*
2574  * Command GetGroupMembership
2575  */
2576 PacketBufferHandle encodeGroupsClusterGetGroupMembershipCommand(uint8_t seqNum, EndpointId destinationEndpoint, uint8_t groupCount,
2577                                                                 uint16_t groupList)
2578 {
2579     COMMAND_HEADER("GetGroupMembership", GROUPS_CLUSTER_ID);
2580
2581     buf.Put8(kFrameControlClusterSpecificCommand)
2582         .Put8(seqNum)
2583         .Put8(ZCL_GET_GROUP_MEMBERSHIP_COMMAND_ID)
2584         .Put8(groupCount)
2585         .Put16(groupList);
2586     COMMAND_FOOTER();
2587 }
2588
2589 /*
2590  * Command RemoveAllGroups
2591  */
2592 PacketBufferHandle encodeGroupsClusterRemoveAllGroupsCommand(uint8_t seqNum, EndpointId destinationEndpoint)
2593 {
2594     COMMAND_HEADER("RemoveAllGroups", GROUPS_CLUSTER_ID);
2595     buf.Put8(kFrameControlClusterSpecificCommand).Put8(seqNum).Put8(ZCL_REMOVE_ALL_GROUPS_COMMAND_ID);
2596     COMMAND_FOOTER();
2597 }
2598
2599 /*
2600  * Command RemoveGroup
2601  */
2602 PacketBufferHandle encodeGroupsClusterRemoveGroupCommand(uint8_t seqNum, EndpointId destinationEndpoint, uint16_t groupId)
2603 {
2604     COMMAND_HEADER("RemoveGroup", GROUPS_CLUSTER_ID);
2605
2606     buf.Put8(kFrameControlClusterSpecificCommand).Put8(seqNum).Put8(ZCL_REMOVE_GROUP_COMMAND_ID).Put16(groupId);
2607     COMMAND_FOOTER();
2608 }
2609
2610 /*
2611  * Command ViewGroup
2612  */
2613 PacketBufferHandle encodeGroupsClusterViewGroupCommand(uint8_t seqNum, EndpointId destinationEndpoint, uint16_t groupId)
2614 {
2615     COMMAND_HEADER("ViewGroup", GROUPS_CLUSTER_ID);
2616
2617     buf.Put8(kFrameControlClusterSpecificCommand).Put8(seqNum).Put8(ZCL_VIEW_GROUP_COMMAND_ID).Put16(groupId);
2618     COMMAND_FOOTER();
2619 }
2620
2621 PacketBufferHandle encodeGroupsClusterDiscoverAttributes(uint8_t seqNum, EndpointId destinationEndpoint)
2622 {
2623     COMMAND_HEADER("DiscoverGroupsAttributes", GROUPS_CLUSTER_ID);
2624     buf.Put8(kFrameControlGlobalCommand).Put8(seqNum).Put8(ZCL_DISCOVER_ATTRIBUTES_COMMAND_ID).Put16(0x0000).Put8(0xFF);
2625     COMMAND_FOOTER();
2626 }
2627
2628 /*
2629  * Attribute NameSupport
2630  */
2631 PacketBufferHandle encodeGroupsClusterReadNameSupportAttribute(uint8_t seqNum, EndpointId destinationEndpoint)
2632 {
2633     COMMAND_HEADER("ReadGroupsNameSupport", GROUPS_CLUSTER_ID);
2634     buf.Put8(kFrameControlGlobalCommand).Put8(seqNum).Put8(ZCL_READ_ATTRIBUTES_COMMAND_ID).Put16(0x0000);
2635     COMMAND_FOOTER();
2636 }
2637
2638 /*
2639  * Attribute ClusterRevision
2640  */
2641 PacketBufferHandle encodeGroupsClusterReadClusterRevisionAttribute(uint8_t seqNum, EndpointId destinationEndpoint)
2642 {
2643     COMMAND_HEADER("ReadGroupsClusterRevision", GROUPS_CLUSTER_ID);
2644     buf.Put8(kFrameControlGlobalCommand).Put8(seqNum).Put8(ZCL_READ_ATTRIBUTES_COMMAND_ID).Put16(0xFFFD);
2645     COMMAND_FOOTER();
2646 }
2647
2648 /*----------------------------------------------------------------------------*\
2649 | Cluster IasZone                                                     | 0x0500 |
2650 |------------------------------------------------------------------------------|
2651 | Commands:                                                           |        |
2652 |------------------------------------------------------------------------------|
2653 | Attributes:                                                         |        |
2654 | * ZoneState                                                         | 0x0000 |
2655 | * ZoneType                                                          | 0x0001 |
2656 | * ZoneStatus                                                        | 0x0002 |
2657 | * IasCieAddress                                                     | 0x0010 |
2658 | * ZoneId                                                            | 0x0011 |
2659 | * ClusterRevision                                                   | 0xFFFD |
2660 \*----------------------------------------------------------------------------*/
2661
2662 PacketBufferHandle encodeIasZoneClusterDiscoverAttributes(uint8_t seqNum, EndpointId destinationEndpoint)
2663 {
2664     COMMAND_HEADER("DiscoverIasZoneAttributes", IAS_ZONE_CLUSTER_ID);
2665     buf.Put8(kFrameControlGlobalCommand).Put8(seqNum).Put8(ZCL_DISCOVER_ATTRIBUTES_COMMAND_ID).Put16(0x0000).Put8(0xFF);
2666     COMMAND_FOOTER();
2667 }
2668
2669 /*
2670  * Attribute ZoneState
2671  */
2672 PacketBufferHandle encodeIasZoneClusterReadZoneStateAttribute(uint8_t seqNum, EndpointId destinationEndpoint)
2673 {
2674     COMMAND_HEADER("ReadIasZoneZoneState", IAS_ZONE_CLUSTER_ID);
2675     buf.Put8(kFrameControlGlobalCommand).Put8(seqNum).Put8(ZCL_READ_ATTRIBUTES_COMMAND_ID).Put16(0x0000);
2676     COMMAND_FOOTER();
2677 }
2678
2679 /*
2680  * Attribute ZoneType
2681  */
2682 PacketBufferHandle encodeIasZoneClusterReadZoneTypeAttribute(uint8_t seqNum, EndpointId destinationEndpoint)
2683 {
2684     COMMAND_HEADER("ReadIasZoneZoneType", IAS_ZONE_CLUSTER_ID);
2685     buf.Put8(kFrameControlGlobalCommand).Put8(seqNum).Put8(ZCL_READ_ATTRIBUTES_COMMAND_ID).Put16(0x0001);
2686     COMMAND_FOOTER();
2687 }
2688
2689 /*
2690  * Attribute ZoneStatus
2691  */
2692 PacketBufferHandle encodeIasZoneClusterReadZoneStatusAttribute(uint8_t seqNum, EndpointId destinationEndpoint)
2693 {
2694     COMMAND_HEADER("ReadIasZoneZoneStatus", IAS_ZONE_CLUSTER_ID);
2695     buf.Put8(kFrameControlGlobalCommand).Put8(seqNum).Put8(ZCL_READ_ATTRIBUTES_COMMAND_ID).Put16(0x0002);
2696     COMMAND_FOOTER();
2697 }
2698
2699 /*
2700  * Attribute IasCieAddress
2701  */
2702 PacketBufferHandle encodeIasZoneClusterReadIasCieAddressAttribute(uint8_t seqNum, EndpointId destinationEndpoint)
2703 {
2704     COMMAND_HEADER("ReadIasZoneIasCieAddress", IAS_ZONE_CLUSTER_ID);
2705     buf.Put8(kFrameControlGlobalCommand).Put8(seqNum).Put8(ZCL_READ_ATTRIBUTES_COMMAND_ID).Put16(0x0010);
2706     COMMAND_FOOTER();
2707 }
2708
2709 PacketBufferHandle encodeIasZoneClusterWriteIasCieAddressAttribute(uint8_t seqNum, EndpointId destinationEndpoint,
2710                                                                    uint64_t iasCieAddress)
2711 {
2712     COMMAND_HEADER("WriteIasZoneIasCieAddress", IAS_ZONE_CLUSTER_ID);
2713     buf.Put8(kFrameControlGlobalCommand)
2714         .Put8(seqNum)
2715         .Put8(ZCL_WRITE_ATTRIBUTES_COMMAND_ID)
2716         .Put16(0x0010)
2717         .Put8(240)
2718         .Put64(static_cast<uint64_t>(iasCieAddress));
2719     COMMAND_FOOTER();
2720 }
2721
2722 /*
2723  * Attribute ZoneId
2724  */
2725 PacketBufferHandle encodeIasZoneClusterReadZoneIdAttribute(uint8_t seqNum, EndpointId destinationEndpoint)
2726 {
2727     COMMAND_HEADER("ReadIasZoneZoneId", IAS_ZONE_CLUSTER_ID);
2728     buf.Put8(kFrameControlGlobalCommand).Put8(seqNum).Put8(ZCL_READ_ATTRIBUTES_COMMAND_ID).Put16(0x0011);
2729     COMMAND_FOOTER();
2730 }
2731
2732 /*
2733  * Attribute ClusterRevision
2734  */
2735 PacketBufferHandle encodeIasZoneClusterReadClusterRevisionAttribute(uint8_t seqNum, EndpointId destinationEndpoint)
2736 {
2737     COMMAND_HEADER("ReadIasZoneClusterRevision", IAS_ZONE_CLUSTER_ID);
2738     buf.Put8(kFrameControlGlobalCommand).Put8(seqNum).Put8(ZCL_READ_ATTRIBUTES_COMMAND_ID).Put16(0xFFFD);
2739     COMMAND_FOOTER();
2740 }
2741
2742 /*----------------------------------------------------------------------------*\
2743 | Cluster Identify                                                    | 0x0003 |
2744 |------------------------------------------------------------------------------|
2745 | Commands:                                                           |        |
2746 | * Identify                                                          |   0x00 |
2747 | * IdentifyQuery                                                     |   0x01 |
2748 |------------------------------------------------------------------------------|
2749 | Attributes:                                                         |        |
2750 | * IdentifyTime                                                      | 0x0000 |
2751 | * ClusterRevision                                                   | 0xFFFD |
2752 \*----------------------------------------------------------------------------*/
2753
2754 /*
2755  * Command Identify
2756  */
2757 PacketBufferHandle encodeIdentifyClusterIdentifyCommand(uint8_t seqNum, EndpointId destinationEndpoint, uint16_t identifyTime)
2758 {
2759     COMMAND_HEADER("Identify", IDENTIFY_CLUSTER_ID);
2760
2761     buf.Put8(kFrameControlClusterSpecificCommand).Put8(seqNum).Put8(ZCL_IDENTIFY_COMMAND_ID).Put16(identifyTime);
2762     COMMAND_FOOTER();
2763 }
2764
2765 /*
2766  * Command IdentifyQuery
2767  */
2768 PacketBufferHandle encodeIdentifyClusterIdentifyQueryCommand(uint8_t seqNum, EndpointId destinationEndpoint)
2769 {
2770     COMMAND_HEADER("IdentifyQuery", IDENTIFY_CLUSTER_ID);
2771     buf.Put8(kFrameControlClusterSpecificCommand).Put8(seqNum).Put8(ZCL_IDENTIFY_QUERY_COMMAND_ID);
2772     COMMAND_FOOTER();
2773 }
2774
2775 PacketBufferHandle encodeIdentifyClusterDiscoverAttributes(uint8_t seqNum, EndpointId destinationEndpoint)
2776 {
2777     COMMAND_HEADER("DiscoverIdentifyAttributes", IDENTIFY_CLUSTER_ID);
2778     buf.Put8(kFrameControlGlobalCommand).Put8(seqNum).Put8(ZCL_DISCOVER_ATTRIBUTES_COMMAND_ID).Put16(0x0000).Put8(0xFF);
2779     COMMAND_FOOTER();
2780 }
2781
2782 /*
2783  * Attribute IdentifyTime
2784  */
2785 PacketBufferHandle encodeIdentifyClusterReadIdentifyTimeAttribute(uint8_t seqNum, EndpointId destinationEndpoint)
2786 {
2787     COMMAND_HEADER("ReadIdentifyIdentifyTime", IDENTIFY_CLUSTER_ID);
2788     buf.Put8(kFrameControlGlobalCommand).Put8(seqNum).Put8(ZCL_READ_ATTRIBUTES_COMMAND_ID).Put16(0x0000);
2789     COMMAND_FOOTER();
2790 }
2791
2792 PacketBufferHandle encodeIdentifyClusterWriteIdentifyTimeAttribute(uint8_t seqNum, EndpointId destinationEndpoint,
2793                                                                    uint16_t identifyTime)
2794 {
2795     COMMAND_HEADER("WriteIdentifyIdentifyTime", IDENTIFY_CLUSTER_ID);
2796     buf.Put8(kFrameControlGlobalCommand)
2797         .Put8(seqNum)
2798         .Put8(ZCL_WRITE_ATTRIBUTES_COMMAND_ID)
2799         .Put16(0x0000)
2800         .Put8(33)
2801         .Put16(static_cast<uint16_t>(identifyTime));
2802     COMMAND_FOOTER();
2803 }
2804
2805 /*
2806  * Attribute ClusterRevision
2807  */
2808 PacketBufferHandle encodeIdentifyClusterReadClusterRevisionAttribute(uint8_t seqNum, EndpointId destinationEndpoint)
2809 {
2810     COMMAND_HEADER("ReadIdentifyClusterRevision", IDENTIFY_CLUSTER_ID);
2811     buf.Put8(kFrameControlGlobalCommand).Put8(seqNum).Put8(ZCL_READ_ATTRIBUTES_COMMAND_ID).Put16(0xFFFD);
2812     COMMAND_FOOTER();
2813 }
2814
2815 /*----------------------------------------------------------------------------*\
2816 | Cluster LevelControl                                                | 0x0008 |
2817 |------------------------------------------------------------------------------|
2818 | Commands:                                                           |        |
2819 | * Move                                                              |   0x01 |
2820 | * MoveToLevel                                                       |   0x00 |
2821 | * MoveToLevelWithOnOff                                              |   0x04 |
2822 | * MoveWithOnOff                                                     |   0x05 |
2823 | * Step                                                              |   0x02 |
2824 | * StepWithOnOff                                                     |   0x06 |
2825 | * Stop                                                              |   0x03 |
2826 | * StopWithOnOff                                                     |   0x07 |
2827 |------------------------------------------------------------------------------|
2828 | Attributes:                                                         |        |
2829 | * CurrentLevel                                                      | 0x0000 |
2830 | * ClusterRevision                                                   | 0xFFFD |
2831 \*----------------------------------------------------------------------------*/
2832
2833 /*
2834  * Command Move
2835  */
2836 PacketBufferHandle encodeLevelControlClusterMoveCommand(uint8_t seqNum, EndpointId destinationEndpoint, uint8_t moveMode,
2837                                                         uint8_t rate, uint8_t optionMask, uint8_t optionOverride)
2838 {
2839     COMMAND_HEADER("Move", LEVEL_CONTROL_CLUSTER_ID);
2840
2841     buf.Put8(kFrameControlClusterSpecificCommand)
2842         .Put8(seqNum)
2843         .Put8(ZCL_MOVE_COMMAND_ID)
2844         .Put8(moveMode)
2845         .Put8(rate)
2846         .Put8(optionMask)
2847         .Put8(optionOverride);
2848     COMMAND_FOOTER();
2849 }
2850
2851 /*
2852  * Command MoveToLevel
2853  */
2854 PacketBufferHandle encodeLevelControlClusterMoveToLevelCommand(uint8_t seqNum, EndpointId destinationEndpoint, uint8_t level,
2855                                                                uint16_t transitionTime, uint8_t optionMask, uint8_t optionOverride)
2856 {
2857     COMMAND_HEADER("MoveToLevel", LEVEL_CONTROL_CLUSTER_ID);
2858
2859     buf.Put8(kFrameControlClusterSpecificCommand)
2860         .Put8(seqNum)
2861         .Put8(ZCL_MOVE_TO_LEVEL_COMMAND_ID)
2862         .Put8(level)
2863         .Put16(transitionTime)
2864         .Put8(optionMask)
2865         .Put8(optionOverride);
2866     COMMAND_FOOTER();
2867 }
2868
2869 /*
2870  * Command MoveToLevelWithOnOff
2871  */
2872 PacketBufferHandle encodeLevelControlClusterMoveToLevelWithOnOffCommand(uint8_t seqNum, EndpointId destinationEndpoint,
2873                                                                         uint8_t level, uint16_t transitionTime)
2874 {
2875     COMMAND_HEADER("MoveToLevelWithOnOff", LEVEL_CONTROL_CLUSTER_ID);
2876
2877     buf.Put8(kFrameControlClusterSpecificCommand)
2878         .Put8(seqNum)
2879         .Put8(ZCL_MOVE_TO_LEVEL_WITH_ON_OFF_COMMAND_ID)
2880         .Put8(level)
2881         .Put16(transitionTime);
2882     COMMAND_FOOTER();
2883 }
2884
2885 /*
2886  * Command MoveWithOnOff
2887  */
2888 PacketBufferHandle encodeLevelControlClusterMoveWithOnOffCommand(uint8_t seqNum, EndpointId destinationEndpoint, uint8_t moveMode,
2889                                                                  uint8_t rate)
2890 {
2891     COMMAND_HEADER("MoveWithOnOff", LEVEL_CONTROL_CLUSTER_ID);
2892
2893     buf.Put8(kFrameControlClusterSpecificCommand).Put8(seqNum).Put8(ZCL_MOVE_WITH_ON_OFF_COMMAND_ID).Put8(moveMode).Put8(rate);
2894     COMMAND_FOOTER();
2895 }
2896
2897 /*
2898  * Command Step
2899  */
2900 PacketBufferHandle encodeLevelControlClusterStepCommand(uint8_t seqNum, EndpointId destinationEndpoint, uint8_t stepMode,
2901                                                         uint8_t stepSize, uint16_t transitionTime, uint8_t optionMask,
2902                                                         uint8_t optionOverride)
2903 {
2904     COMMAND_HEADER("Step", LEVEL_CONTROL_CLUSTER_ID);
2905
2906     buf.Put8(kFrameControlClusterSpecificCommand)
2907         .Put8(seqNum)
2908         .Put8(ZCL_STEP_COMMAND_ID)
2909         .Put8(stepMode)
2910         .Put8(stepSize)
2911         .Put16(transitionTime)
2912         .Put8(optionMask)
2913         .Put8(optionOverride);
2914     COMMAND_FOOTER();
2915 }
2916
2917 /*
2918  * Command StepWithOnOff
2919  */
2920 PacketBufferHandle encodeLevelControlClusterStepWithOnOffCommand(uint8_t seqNum, EndpointId destinationEndpoint, uint8_t stepMode,
2921                                                                  uint8_t stepSize, uint16_t transitionTime)
2922 {
2923     COMMAND_HEADER("StepWithOnOff", LEVEL_CONTROL_CLUSTER_ID);
2924
2925     buf.Put8(kFrameControlClusterSpecificCommand)
2926         .Put8(seqNum)
2927         .Put8(ZCL_STEP_WITH_ON_OFF_COMMAND_ID)
2928         .Put8(stepMode)
2929         .Put8(stepSize)
2930         .Put16(transitionTime);
2931     COMMAND_FOOTER();
2932 }
2933
2934 /*
2935  * Command Stop
2936  */
2937 PacketBufferHandle encodeLevelControlClusterStopCommand(uint8_t seqNum, EndpointId destinationEndpoint, uint8_t optionMask,
2938                                                         uint8_t optionOverride)
2939 {
2940     COMMAND_HEADER("Stop", LEVEL_CONTROL_CLUSTER_ID);
2941
2942     buf.Put8(kFrameControlClusterSpecificCommand).Put8(seqNum).Put8(ZCL_STOP_COMMAND_ID).Put8(optionMask).Put8(optionOverride);
2943     COMMAND_FOOTER();
2944 }
2945
2946 /*
2947  * Command StopWithOnOff
2948  */
2949 PacketBufferHandle encodeLevelControlClusterStopWithOnOffCommand(uint8_t seqNum, EndpointId destinationEndpoint)
2950 {
2951     COMMAND_HEADER("StopWithOnOff", LEVEL_CONTROL_CLUSTER_ID);
2952     buf.Put8(kFrameControlClusterSpecificCommand).Put8(seqNum).Put8(ZCL_STOP_WITH_ON_OFF_COMMAND_ID);
2953     COMMAND_FOOTER();
2954 }
2955
2956 PacketBufferHandle encodeLevelControlClusterDiscoverAttributes(uint8_t seqNum, EndpointId destinationEndpoint)
2957 {
2958     COMMAND_HEADER("DiscoverLevelControlAttributes", LEVEL_CONTROL_CLUSTER_ID);
2959     buf.Put8(kFrameControlGlobalCommand).Put8(seqNum).Put8(ZCL_DISCOVER_ATTRIBUTES_COMMAND_ID).Put16(0x0000).Put8(0xFF);
2960     COMMAND_FOOTER();
2961 }
2962
2963 /*
2964  * Attribute CurrentLevel
2965  */
2966 PacketBufferHandle encodeLevelControlClusterReadCurrentLevelAttribute(uint8_t seqNum, EndpointId destinationEndpoint)
2967 {
2968     COMMAND_HEADER("ReadLevelControlCurrentLevel", LEVEL_CONTROL_CLUSTER_ID);
2969     buf.Put8(kFrameControlGlobalCommand).Put8(seqNum).Put8(ZCL_READ_ATTRIBUTES_COMMAND_ID).Put16(0x0000);
2970     COMMAND_FOOTER();
2971 }
2972
2973 PacketBufferHandle encodeLevelControlClusterConfigureCurrentLevelAttribute(uint8_t seqNum, EndpointId destinationEndpoint,
2974                                                                            uint16_t minInterval, uint16_t maxInterval,
2975                                                                            uint8_t change)
2976 {
2977     COMMAND_HEADER("ReportLevelControlCurrentLevel", LEVEL_CONTROL_CLUSTER_ID);
2978     buf.Put8(kFrameControlGlobalCommand)
2979         .Put8(seqNum)
2980         .Put8(ZCL_CONFIGURE_REPORTING_COMMAND_ID)
2981         .Put8(EMBER_ZCL_REPORTING_DIRECTION_REPORTED)
2982         .Put16(0x0000)
2983         .Put8(32)
2984         .Put16(minInterval)
2985         .Put16(maxInterval);
2986     buf.Put8(static_cast<uint8_t>(change));
2987     COMMAND_FOOTER();
2988 }
2989
2990 /*
2991  * Attribute ClusterRevision
2992  */
2993 PacketBufferHandle encodeLevelControlClusterReadClusterRevisionAttribute(uint8_t seqNum, EndpointId destinationEndpoint)
2994 {
2995     COMMAND_HEADER("ReadLevelControlClusterRevision", LEVEL_CONTROL_CLUSTER_ID);
2996     buf.Put8(kFrameControlGlobalCommand).Put8(seqNum).Put8(ZCL_READ_ATTRIBUTES_COMMAND_ID).Put16(0xFFFD);
2997     COMMAND_FOOTER();
2998 }
2999
3000 /*----------------------------------------------------------------------------*\
3001 | Cluster LowPower                                                    | 0x0508 |
3002 |------------------------------------------------------------------------------|
3003 | Commands:                                                           |        |
3004 | * Sleep                                                             |   0x00 |
3005 |------------------------------------------------------------------------------|
3006 | Attributes:                                                         |        |
3007 | * ClusterRevision                                                   | 0xFFFD |
3008 \*----------------------------------------------------------------------------*/
3009
3010 /*
3011  * Command Sleep
3012  */
3013 PacketBufferHandle encodeLowPowerClusterSleepCommand(uint8_t seqNum, EndpointId destinationEndpoint)
3014 {
3015     COMMAND_HEADER("Sleep", LOW_POWER_CLUSTER_ID);
3016     buf.Put8(kFrameControlClusterSpecificCommand).Put8(seqNum).Put8(ZCL_SLEEP_COMMAND_ID);
3017     COMMAND_FOOTER();
3018 }
3019
3020 PacketBufferHandle encodeLowPowerClusterDiscoverAttributes(uint8_t seqNum, EndpointId destinationEndpoint)
3021 {
3022     COMMAND_HEADER("DiscoverLowPowerAttributes", LOW_POWER_CLUSTER_ID);
3023     buf.Put8(kFrameControlGlobalCommand).Put8(seqNum).Put8(ZCL_DISCOVER_ATTRIBUTES_COMMAND_ID).Put16(0x0000).Put8(0xFF);
3024     COMMAND_FOOTER();
3025 }
3026
3027 /*
3028  * Attribute ClusterRevision
3029  */
3030 PacketBufferHandle encodeLowPowerClusterReadClusterRevisionAttribute(uint8_t seqNum, EndpointId destinationEndpoint)
3031 {
3032     COMMAND_HEADER("ReadLowPowerClusterRevision", LOW_POWER_CLUSTER_ID);
3033     buf.Put8(kFrameControlGlobalCommand).Put8(seqNum).Put8(ZCL_READ_ATTRIBUTES_COMMAND_ID).Put16(0xFFFD);
3034     COMMAND_FOOTER();
3035 }
3036
3037 /*----------------------------------------------------------------------------*\
3038 | Cluster MediaPlayback                                               | 0xF001 |
3039 |------------------------------------------------------------------------------|
3040 | Commands:                                                           |        |
3041 | * FastForwardRequest                                                |   0x07 |
3042 | * NextRequest                                                       |   0x05 |
3043 | * PauseRequest                                                      |   0x01 |
3044 | * PlayRequest                                                       |   0x00 |
3045 | * PreviousRequest                                                   |   0x04 |
3046 | * RewindRequest                                                     |   0x06 |
3047 | * SkipBackwardRequest                                               |   0x09 |
3048 | * SkipForwardRequest                                                |   0x08 |
3049 | * StartOverRequest                                                  |   0x03 |
3050 | * StopRequest                                                       |   0x02 |
3051 |------------------------------------------------------------------------------|
3052 | Attributes:                                                         |        |
3053 | * CurrentState                                                      | 0x0000 |
3054 | * ClusterRevision                                                   | 0xFFFD |
3055 \*----------------------------------------------------------------------------*/
3056
3057 /*
3058  * Command FastForwardRequest
3059  */
3060 PacketBufferHandle encodeMediaPlaybackClusterFastForwardRequestCommand(uint8_t seqNum, EndpointId destinationEndpoint)
3061 {
3062     COMMAND_HEADER("FastForwardRequest", MEDIA_PLAYBACK_CLUSTER_ID);
3063     buf.Put8(kFrameControlClusterSpecificCommand).Put8(seqNum).Put8(ZCL_FAST_FORWARD_REQUEST_COMMAND_ID);
3064     COMMAND_FOOTER();
3065 }
3066
3067 /*
3068  * Command NextRequest
3069  */
3070 PacketBufferHandle encodeMediaPlaybackClusterNextRequestCommand(uint8_t seqNum, EndpointId destinationEndpoint)
3071 {
3072     COMMAND_HEADER("NextRequest", MEDIA_PLAYBACK_CLUSTER_ID);
3073     buf.Put8(kFrameControlClusterSpecificCommand).Put8(seqNum).Put8(ZCL_NEXT_REQUEST_COMMAND_ID);
3074     COMMAND_FOOTER();
3075 }
3076
3077 /*
3078  * Command PauseRequest
3079  */
3080 PacketBufferHandle encodeMediaPlaybackClusterPauseRequestCommand(uint8_t seqNum, EndpointId destinationEndpoint)
3081 {
3082     COMMAND_HEADER("PauseRequest", MEDIA_PLAYBACK_CLUSTER_ID);
3083     buf.Put8(kFrameControlClusterSpecificCommand).Put8(seqNum).Put8(ZCL_PAUSE_REQUEST_COMMAND_ID);
3084     COMMAND_FOOTER();
3085 }
3086
3087 /*
3088  * Command PlayRequest
3089  */
3090 PacketBufferHandle encodeMediaPlaybackClusterPlayRequestCommand(uint8_t seqNum, EndpointId destinationEndpoint)
3091 {
3092     COMMAND_HEADER("PlayRequest", MEDIA_PLAYBACK_CLUSTER_ID);
3093     buf.Put8(kFrameControlClusterSpecificCommand).Put8(seqNum).Put8(ZCL_PLAY_REQUEST_COMMAND_ID);
3094     COMMAND_FOOTER();
3095 }
3096
3097 /*
3098  * Command PreviousRequest
3099  */
3100 PacketBufferHandle encodeMediaPlaybackClusterPreviousRequestCommand(uint8_t seqNum, EndpointId destinationEndpoint)
3101 {
3102     COMMAND_HEADER("PreviousRequest", MEDIA_PLAYBACK_CLUSTER_ID);
3103     buf.Put8(kFrameControlClusterSpecificCommand).Put8(seqNum).Put8(ZCL_PREVIOUS_REQUEST_COMMAND_ID);
3104     COMMAND_FOOTER();
3105 }
3106
3107 /*
3108  * Command RewindRequest
3109  */
3110 PacketBufferHandle encodeMediaPlaybackClusterRewindRequestCommand(uint8_t seqNum, EndpointId destinationEndpoint)
3111 {
3112     COMMAND_HEADER("RewindRequest", MEDIA_PLAYBACK_CLUSTER_ID);
3113     buf.Put8(kFrameControlClusterSpecificCommand).Put8(seqNum).Put8(ZCL_REWIND_REQUEST_COMMAND_ID);
3114     COMMAND_FOOTER();
3115 }
3116
3117 /*
3118  * Command SkipBackwardRequest
3119  */
3120 PacketBufferHandle encodeMediaPlaybackClusterSkipBackwardRequestCommand(uint8_t seqNum, EndpointId destinationEndpoint)
3121 {
3122     COMMAND_HEADER("SkipBackwardRequest", MEDIA_PLAYBACK_CLUSTER_ID);
3123     buf.Put8(kFrameControlClusterSpecificCommand).Put8(seqNum).Put8(ZCL_SKIP_BACKWARD_REQUEST_COMMAND_ID);
3124     COMMAND_FOOTER();
3125 }
3126
3127 /*
3128  * Command SkipForwardRequest
3129  */
3130 PacketBufferHandle encodeMediaPlaybackClusterSkipForwardRequestCommand(uint8_t seqNum, EndpointId destinationEndpoint)
3131 {
3132     COMMAND_HEADER("SkipForwardRequest", MEDIA_PLAYBACK_CLUSTER_ID);
3133     buf.Put8(kFrameControlClusterSpecificCommand).Put8(seqNum).Put8(ZCL_SKIP_FORWARD_REQUEST_COMMAND_ID);
3134     COMMAND_FOOTER();
3135 }
3136
3137 /*
3138  * Command StartOverRequest
3139  */
3140 PacketBufferHandle encodeMediaPlaybackClusterStartOverRequestCommand(uint8_t seqNum, EndpointId destinationEndpoint)
3141 {
3142     COMMAND_HEADER("StartOverRequest", MEDIA_PLAYBACK_CLUSTER_ID);
3143     buf.Put8(kFrameControlClusterSpecificCommand).Put8(seqNum).Put8(ZCL_START_OVER_REQUEST_COMMAND_ID);
3144     COMMAND_FOOTER();
3145 }
3146
3147 /*
3148  * Command StopRequest
3149  */
3150 PacketBufferHandle encodeMediaPlaybackClusterStopRequestCommand(uint8_t seqNum, EndpointId destinationEndpoint)
3151 {
3152     COMMAND_HEADER("StopRequest", MEDIA_PLAYBACK_CLUSTER_ID);
3153     buf.Put8(kFrameControlClusterSpecificCommand).Put8(seqNum).Put8(ZCL_STOP_REQUEST_COMMAND_ID);
3154     COMMAND_FOOTER();
3155 }
3156
3157 PacketBufferHandle encodeMediaPlaybackClusterDiscoverAttributes(uint8_t seqNum, EndpointId destinationEndpoint)
3158 {
3159     COMMAND_HEADER("DiscoverMediaPlaybackAttributes", MEDIA_PLAYBACK_CLUSTER_ID);
3160     buf.Put8(kFrameControlGlobalCommand).Put8(seqNum).Put8(ZCL_DISCOVER_ATTRIBUTES_COMMAND_ID).Put16(0x0000).Put8(0xFF);
3161     COMMAND_FOOTER();
3162 }
3163
3164 /*
3165  * Attribute CurrentState
3166  */
3167 PacketBufferHandle encodeMediaPlaybackClusterReadCurrentStateAttribute(uint8_t seqNum, EndpointId destinationEndpoint)
3168 {
3169     COMMAND_HEADER("ReadMediaPlaybackCurrentState", MEDIA_PLAYBACK_CLUSTER_ID);
3170     buf.Put8(kFrameControlGlobalCommand).Put8(seqNum).Put8(ZCL_READ_ATTRIBUTES_COMMAND_ID).Put16(0x0000);
3171     COMMAND_FOOTER();
3172 }
3173
3174 /*
3175  * Attribute ClusterRevision
3176  */
3177 PacketBufferHandle encodeMediaPlaybackClusterReadClusterRevisionAttribute(uint8_t seqNum, EndpointId destinationEndpoint)
3178 {
3179     COMMAND_HEADER("ReadMediaPlaybackClusterRevision", MEDIA_PLAYBACK_CLUSTER_ID);
3180     buf.Put8(kFrameControlGlobalCommand).Put8(seqNum).Put8(ZCL_READ_ATTRIBUTES_COMMAND_ID).Put16(0xFFFD);
3181     COMMAND_FOOTER();
3182 }
3183
3184 /*----------------------------------------------------------------------------*\
3185 | Cluster NetworkCommissioning                                        | 0xAAAA |
3186 |------------------------------------------------------------------------------|
3187 | Commands:                                                           |        |
3188 | * AddThreadNetwork                                                  |   0x06 |
3189 | * AddWiFiNetwork                                                    |   0x02 |
3190 | * DisableNetwork                                                    |   0x0E |
3191 | * EnableNetwork                                                     |   0x0C |
3192 | * GetLastNetworkCommissioningResult                                 |   0x10 |
3193 | * RemoveNetwork                                                     |   0x0A |
3194 | * ScanNetworks                                                      |   0x00 |
3195 | * UpdateThreadNetwork                                               |   0x08 |
3196 | * UpdateWiFiNetwork                                                 |   0x04 |
3197 |------------------------------------------------------------------------------|
3198 | Attributes:                                                         |        |
3199 | * ClusterRevision                                                   | 0xFFFD |
3200 \*----------------------------------------------------------------------------*/
3201
3202 /*
3203  * Command AddThreadNetwork
3204  */
3205 PacketBufferHandle encodeNetworkCommissioningClusterAddThreadNetworkCommand(uint8_t seqNum, EndpointId destinationEndpoint,
3206                                                                             chip::ByteSpan operationalDataset, uint64_t breadcrumb,
3207                                                                             uint32_t timeoutMs)
3208 {
3209     COMMAND_HEADER("AddThreadNetwork", NETWORK_COMMISSIONING_CLUSTER_ID);
3210     size_t operationalDatasetStrLen = operationalDataset.size();
3211     if (!CanCastTo<uint8_t>(operationalDatasetStrLen))
3212     {
3213         ChipLogError(Zcl, "Error encoding %s command. String too long: %d", kName, operationalDatasetStrLen);
3214         return PacketBufferHandle();
3215     }
3216
3217     buf.Put8(kFrameControlClusterSpecificCommand)
3218         .Put8(seqNum)
3219         .Put8(ZCL_ADD_THREAD_NETWORK_COMMAND_ID)
3220         .Put(static_cast<uint8_t>(operationalDatasetStrLen))
3221         .Put(operationalDataset.data(), operationalDataset.size())
3222         .Put64(breadcrumb)
3223         .Put32(timeoutMs);
3224     COMMAND_FOOTER();
3225 }
3226
3227 /*
3228  * Command AddWiFiNetwork
3229  */
3230 PacketBufferHandle encodeNetworkCommissioningClusterAddWiFiNetworkCommand(uint8_t seqNum, EndpointId destinationEndpoint,
3231                                                                           chip::ByteSpan ssid, chip::ByteSpan credentials,
3232                                                                           uint64_t breadcrumb, uint32_t timeoutMs)
3233 {
3234     COMMAND_HEADER("AddWiFiNetwork", NETWORK_COMMISSIONING_CLUSTER_ID);
3235     size_t ssidStrLen = ssid.size();
3236     if (!CanCastTo<uint8_t>(ssidStrLen))
3237     {
3238         ChipLogError(Zcl, "Error encoding %s command. String too long: %d", kName, ssidStrLen);
3239         return PacketBufferHandle();
3240     }
3241
3242     size_t credentialsStrLen = credentials.size();
3243     if (!CanCastTo<uint8_t>(credentialsStrLen))
3244     {
3245         ChipLogError(Zcl, "Error encoding %s command. String too long: %d", kName, credentialsStrLen);
3246         return PacketBufferHandle();
3247     }
3248
3249     buf.Put8(kFrameControlClusterSpecificCommand)
3250         .Put8(seqNum)
3251         .Put8(ZCL_ADD_WI_FI_NETWORK_COMMAND_ID)
3252         .Put(static_cast<uint8_t>(ssidStrLen))
3253         .Put(ssid.data(), ssid.size())
3254         .Put(static_cast<uint8_t>(credentialsStrLen))
3255         .Put(credentials.data(), credentials.size())
3256         .Put64(breadcrumb)
3257         .Put32(timeoutMs);
3258     COMMAND_FOOTER();
3259 }
3260
3261 /*
3262  * Command DisableNetwork
3263  */
3264 PacketBufferHandle encodeNetworkCommissioningClusterDisableNetworkCommand(uint8_t seqNum, EndpointId destinationEndpoint,
3265                                                                           chip::ByteSpan networkID, uint64_t breadcrumb,
3266                                                                           uint32_t timeoutMs)
3267 {
3268     COMMAND_HEADER("DisableNetwork", NETWORK_COMMISSIONING_CLUSTER_ID);
3269     size_t networkIDStrLen = networkID.size();
3270     if (!CanCastTo<uint8_t>(networkIDStrLen))
3271     {
3272         ChipLogError(Zcl, "Error encoding %s command. String too long: %d", kName, networkIDStrLen);
3273         return PacketBufferHandle();
3274     }
3275
3276     buf.Put8(kFrameControlClusterSpecificCommand)
3277         .Put8(seqNum)
3278         .Put8(ZCL_DISABLE_NETWORK_COMMAND_ID)
3279         .Put(static_cast<uint8_t>(networkIDStrLen))
3280         .Put(networkID.data(), networkID.size())
3281         .Put64(breadcrumb)
3282         .Put32(timeoutMs);
3283     COMMAND_FOOTER();
3284 }
3285
3286 /*
3287  * Command EnableNetwork
3288  */
3289 PacketBufferHandle encodeNetworkCommissioningClusterEnableNetworkCommand(uint8_t seqNum, EndpointId destinationEndpoint,
3290                                                                          chip::ByteSpan networkID, uint64_t breadcrumb,
3291                                                                          uint32_t timeoutMs)
3292 {
3293     COMMAND_HEADER("EnableNetwork", NETWORK_COMMISSIONING_CLUSTER_ID);
3294     size_t networkIDStrLen = networkID.size();
3295     if (!CanCastTo<uint8_t>(networkIDStrLen))
3296     {
3297         ChipLogError(Zcl, "Error encoding %s command. String too long: %d", kName, networkIDStrLen);
3298         return PacketBufferHandle();
3299     }
3300
3301     buf.Put8(kFrameControlClusterSpecificCommand)
3302         .Put8(seqNum)
3303         .Put8(ZCL_ENABLE_NETWORK_COMMAND_ID)
3304         .Put(static_cast<uint8_t>(networkIDStrLen))
3305         .Put(networkID.data(), networkID.size())
3306         .Put64(breadcrumb)
3307         .Put32(timeoutMs);
3308     COMMAND_FOOTER();
3309 }
3310
3311 /*
3312  * Command GetLastNetworkCommissioningResult
3313  */
3314 PacketBufferHandle encodeNetworkCommissioningClusterGetLastNetworkCommissioningResultCommand(uint8_t seqNum,
3315                                                                                              EndpointId destinationEndpoint,
3316                                                                                              uint32_t timeoutMs)
3317 {
3318     COMMAND_HEADER("GetLastNetworkCommissioningResult", NETWORK_COMMISSIONING_CLUSTER_ID);
3319
3320     buf.Put8(kFrameControlClusterSpecificCommand)
3321         .Put8(seqNum)
3322         .Put8(ZCL_GET_LAST_NETWORK_COMMISSIONING_RESULT_COMMAND_ID)
3323         .Put32(timeoutMs);
3324     COMMAND_FOOTER();
3325 }
3326
3327 /*
3328  * Command RemoveNetwork
3329  */
3330 PacketBufferHandle encodeNetworkCommissioningClusterRemoveNetworkCommand(uint8_t seqNum, EndpointId destinationEndpoint,
3331                                                                          chip::ByteSpan networkID, uint64_t breadcrumb,
3332                                                                          uint32_t timeoutMs)
3333 {
3334     COMMAND_HEADER("RemoveNetwork", NETWORK_COMMISSIONING_CLUSTER_ID);
3335     size_t networkIDStrLen = networkID.size();
3336     if (!CanCastTo<uint8_t>(networkIDStrLen))
3337     {
3338         ChipLogError(Zcl, "Error encoding %s command. String too long: %d", kName, networkIDStrLen);
3339         return PacketBufferHandle();
3340     }
3341
3342     buf.Put8(kFrameControlClusterSpecificCommand)
3343         .Put8(seqNum)
3344         .Put8(ZCL_REMOVE_NETWORK_COMMAND_ID)
3345         .Put(static_cast<uint8_t>(networkIDStrLen))
3346         .Put(networkID.data(), networkID.size())
3347         .Put64(breadcrumb)
3348         .Put32(timeoutMs);
3349     COMMAND_FOOTER();
3350 }
3351
3352 /*
3353  * Command ScanNetworks
3354  */
3355 PacketBufferHandle encodeNetworkCommissioningClusterScanNetworksCommand(uint8_t seqNum, EndpointId destinationEndpoint,
3356                                                                         chip::ByteSpan ssid, uint64_t breadcrumb,
3357                                                                         uint32_t timeoutMs)
3358 {
3359     COMMAND_HEADER("ScanNetworks", NETWORK_COMMISSIONING_CLUSTER_ID);
3360     size_t ssidStrLen = ssid.size();
3361     if (!CanCastTo<uint8_t>(ssidStrLen))
3362     {
3363         ChipLogError(Zcl, "Error encoding %s command. String too long: %d", kName, ssidStrLen);
3364         return PacketBufferHandle();
3365     }
3366
3367     buf.Put8(kFrameControlClusterSpecificCommand)
3368         .Put8(seqNum)
3369         .Put8(ZCL_SCAN_NETWORKS_COMMAND_ID)
3370         .Put(static_cast<uint8_t>(ssidStrLen))
3371         .Put(ssid.data(), ssid.size())
3372         .Put64(breadcrumb)
3373         .Put32(timeoutMs);
3374     COMMAND_FOOTER();
3375 }
3376
3377 /*
3378  * Command UpdateThreadNetwork
3379  */
3380 PacketBufferHandle encodeNetworkCommissioningClusterUpdateThreadNetworkCommand(uint8_t seqNum, EndpointId destinationEndpoint,
3381                                                                                chip::ByteSpan operationalDataset,
3382                                                                                uint64_t breadcrumb, uint32_t timeoutMs)
3383 {
3384     COMMAND_HEADER("UpdateThreadNetwork", NETWORK_COMMISSIONING_CLUSTER_ID);
3385     size_t operationalDatasetStrLen = operationalDataset.size();
3386     if (!CanCastTo<uint8_t>(operationalDatasetStrLen))
3387     {
3388         ChipLogError(Zcl, "Error encoding %s command. String too long: %d", kName, operationalDatasetStrLen);
3389         return PacketBufferHandle();
3390     }
3391
3392     buf.Put8(kFrameControlClusterSpecificCommand)
3393         .Put8(seqNum)
3394         .Put8(ZCL_UPDATE_THREAD_NETWORK_COMMAND_ID)
3395         .Put(static_cast<uint8_t>(operationalDatasetStrLen))
3396         .Put(operationalDataset.data(), operationalDataset.size())
3397         .Put64(breadcrumb)
3398         .Put32(timeoutMs);
3399     COMMAND_FOOTER();
3400 }
3401
3402 /*
3403  * Command UpdateWiFiNetwork
3404  */
3405 PacketBufferHandle encodeNetworkCommissioningClusterUpdateWiFiNetworkCommand(uint8_t seqNum, EndpointId destinationEndpoint,
3406                                                                              chip::ByteSpan ssid, chip::ByteSpan credentials,
3407                                                                              uint64_t breadcrumb, uint32_t timeoutMs)
3408 {
3409     COMMAND_HEADER("UpdateWiFiNetwork", NETWORK_COMMISSIONING_CLUSTER_ID);
3410     size_t ssidStrLen = ssid.size();
3411     if (!CanCastTo<uint8_t>(ssidStrLen))
3412     {
3413         ChipLogError(Zcl, "Error encoding %s command. String too long: %d", kName, ssidStrLen);
3414         return PacketBufferHandle();
3415     }
3416
3417     size_t credentialsStrLen = credentials.size();
3418     if (!CanCastTo<uint8_t>(credentialsStrLen))
3419     {
3420         ChipLogError(Zcl, "Error encoding %s command. String too long: %d", kName, credentialsStrLen);
3421         return PacketBufferHandle();
3422     }
3423
3424     buf.Put8(kFrameControlClusterSpecificCommand)
3425         .Put8(seqNum)
3426         .Put8(ZCL_UPDATE_WI_FI_NETWORK_COMMAND_ID)
3427         .Put(static_cast<uint8_t>(ssidStrLen))
3428         .Put(ssid.data(), ssid.size())
3429         .Put(static_cast<uint8_t>(credentialsStrLen))
3430         .Put(credentials.data(), credentials.size())
3431         .Put64(breadcrumb)
3432         .Put32(timeoutMs);
3433     COMMAND_FOOTER();
3434 }
3435
3436 PacketBufferHandle encodeNetworkCommissioningClusterDiscoverAttributes(uint8_t seqNum, EndpointId destinationEndpoint)
3437 {
3438     COMMAND_HEADER("DiscoverNetworkCommissioningAttributes", NETWORK_COMMISSIONING_CLUSTER_ID);
3439     buf.Put8(kFrameControlGlobalCommand).Put8(seqNum).Put8(ZCL_DISCOVER_ATTRIBUTES_COMMAND_ID).Put16(0x0000).Put8(0xFF);
3440     COMMAND_FOOTER();
3441 }
3442
3443 /*
3444  * Attribute ClusterRevision
3445  */
3446 PacketBufferHandle encodeNetworkCommissioningClusterReadClusterRevisionAttribute(uint8_t seqNum, EndpointId destinationEndpoint)
3447 {
3448     COMMAND_HEADER("ReadNetworkCommissioningClusterRevision", NETWORK_COMMISSIONING_CLUSTER_ID);
3449     buf.Put8(kFrameControlGlobalCommand).Put8(seqNum).Put8(ZCL_READ_ATTRIBUTES_COMMAND_ID).Put16(0xFFFD);
3450     COMMAND_FOOTER();
3451 }
3452
3453 /*----------------------------------------------------------------------------*\
3454 | Cluster OnOff                                                       | 0x0006 |
3455 |------------------------------------------------------------------------------|
3456 | Commands:                                                           |        |
3457 | * Off                                                               |   0x00 |
3458 | * On                                                                |   0x01 |
3459 | * Toggle                                                            |   0x02 |
3460 |------------------------------------------------------------------------------|
3461 | Attributes:                                                         |        |
3462 | * OnOff                                                             | 0x0000 |
3463 | * ClusterRevision                                                   | 0xFFFD |
3464 \*----------------------------------------------------------------------------*/
3465
3466 /*
3467  * Command Off
3468  */
3469 PacketBufferHandle encodeOnOffClusterOffCommand(uint8_t seqNum, EndpointId destinationEndpoint)
3470 {
3471     COMMAND_HEADER("Off", ON_OFF_CLUSTER_ID);
3472     buf.Put8(kFrameControlClusterSpecificCommand).Put8(seqNum).Put8(ZCL_OFF_COMMAND_ID);
3473     COMMAND_FOOTER();
3474 }
3475
3476 /*
3477  * Command On
3478  */
3479 PacketBufferHandle encodeOnOffClusterOnCommand(uint8_t seqNum, EndpointId destinationEndpoint)
3480 {
3481     COMMAND_HEADER("On", ON_OFF_CLUSTER_ID);
3482     buf.Put8(kFrameControlClusterSpecificCommand).Put8(seqNum).Put8(ZCL_ON_COMMAND_ID);
3483     COMMAND_FOOTER();
3484 }
3485
3486 /*
3487  * Command Toggle
3488  */
3489 PacketBufferHandle encodeOnOffClusterToggleCommand(uint8_t seqNum, EndpointId destinationEndpoint)
3490 {
3491     COMMAND_HEADER("Toggle", ON_OFF_CLUSTER_ID);
3492     buf.Put8(kFrameControlClusterSpecificCommand).Put8(seqNum).Put8(ZCL_TOGGLE_COMMAND_ID);
3493     COMMAND_FOOTER();
3494 }
3495
3496 PacketBufferHandle encodeOnOffClusterDiscoverAttributes(uint8_t seqNum, EndpointId destinationEndpoint)
3497 {
3498     COMMAND_HEADER("DiscoverOnOffAttributes", ON_OFF_CLUSTER_ID);
3499     buf.Put8(kFrameControlGlobalCommand).Put8(seqNum).Put8(ZCL_DISCOVER_ATTRIBUTES_COMMAND_ID).Put16(0x0000).Put8(0xFF);
3500     COMMAND_FOOTER();
3501 }
3502
3503 /*
3504  * Attribute OnOff
3505  */
3506 PacketBufferHandle encodeOnOffClusterReadOnOffAttribute(uint8_t seqNum, EndpointId destinationEndpoint)
3507 {
3508     COMMAND_HEADER("ReadOnOffOnOff", ON_OFF_CLUSTER_ID);
3509     buf.Put8(kFrameControlGlobalCommand).Put8(seqNum).Put8(ZCL_READ_ATTRIBUTES_COMMAND_ID).Put16(0x0000);
3510     COMMAND_FOOTER();
3511 }
3512
3513 PacketBufferHandle encodeOnOffClusterConfigureOnOffAttribute(uint8_t seqNum, EndpointId destinationEndpoint, uint16_t minInterval,
3514                                                              uint16_t maxInterval)
3515 {
3516     COMMAND_HEADER("ReportOnOffOnOff", ON_OFF_CLUSTER_ID);
3517     buf.Put8(kFrameControlGlobalCommand)
3518         .Put8(seqNum)
3519         .Put8(ZCL_CONFIGURE_REPORTING_COMMAND_ID)
3520         .Put8(EMBER_ZCL_REPORTING_DIRECTION_REPORTED)
3521         .Put16(0x0000)
3522         .Put8(16)
3523         .Put16(minInterval)
3524         .Put16(maxInterval);
3525     COMMAND_FOOTER();
3526 }
3527
3528 /*
3529  * Attribute ClusterRevision
3530  */
3531 PacketBufferHandle encodeOnOffClusterReadClusterRevisionAttribute(uint8_t seqNum, EndpointId destinationEndpoint)
3532 {
3533     COMMAND_HEADER("ReadOnOffClusterRevision", ON_OFF_CLUSTER_ID);
3534     buf.Put8(kFrameControlGlobalCommand).Put8(seqNum).Put8(ZCL_READ_ATTRIBUTES_COMMAND_ID).Put16(0xFFFD);
3535     COMMAND_FOOTER();
3536 }
3537
3538 /*----------------------------------------------------------------------------*\
3539 | Cluster Scenes                                                      | 0x0005 |
3540 |------------------------------------------------------------------------------|
3541 | Commands:                                                           |        |
3542 | * AddScene                                                          |   0x00 |
3543 | * GetSceneMembership                                                |   0x06 |
3544 | * RecallScene                                                       |   0x05 |
3545 | * RemoveAllScenes                                                   |   0x03 |
3546 | * RemoveScene                                                       |   0x02 |
3547 | * StoreScene                                                        |   0x04 |
3548 | * ViewScene                                                         |   0x01 |
3549 |------------------------------------------------------------------------------|
3550 | Attributes:                                                         |        |
3551 | * SceneCount                                                        | 0x0000 |
3552 | * CurrentScene                                                      | 0x0001 |
3553 | * CurrentGroup                                                      | 0x0002 |
3554 | * SceneValid                                                        | 0x0003 |
3555 | * NameSupport                                                       | 0x0004 |
3556 | * ClusterRevision                                                   | 0xFFFD |
3557 \*----------------------------------------------------------------------------*/
3558
3559 /*
3560  * Command AddScene
3561  */
3562 PacketBufferHandle encodeScenesClusterAddSceneCommand(uint8_t seqNum, EndpointId destinationEndpoint, uint16_t groupId,
3563                                                       uint8_t sceneId, uint16_t transitionTime, chip::ByteSpan sceneName,
3564                                                       chip::ClusterId clusterId, uint8_t length, uint8_t value)
3565 {
3566     COMMAND_HEADER("AddScene", SCENES_CLUSTER_ID);
3567
3568     size_t sceneNameStrLen = sceneName.size();
3569     if (!CanCastTo<uint8_t>(sceneNameStrLen))
3570     {
3571         ChipLogError(Zcl, "Error encoding %s command. String too long: %d", kName, sceneNameStrLen);
3572         return PacketBufferHandle();
3573     }
3574
3575     buf.Put8(kFrameControlClusterSpecificCommand)
3576         .Put8(seqNum)
3577         .Put8(ZCL_ADD_SCENE_COMMAND_ID)
3578         .Put16(groupId)
3579         .Put8(sceneId)
3580         .Put16(transitionTime)
3581         .Put(static_cast<uint8_t>(sceneNameStrLen))
3582         .Put(sceneName.data(), sceneName.size())
3583         .Put16(clusterId)
3584         .Put8(length)
3585         .Put8(value);
3586     COMMAND_FOOTER();
3587 }
3588
3589 /*
3590  * Command GetSceneMembership
3591  */
3592 PacketBufferHandle encodeScenesClusterGetSceneMembershipCommand(uint8_t seqNum, EndpointId destinationEndpoint, uint16_t groupId)
3593 {
3594     COMMAND_HEADER("GetSceneMembership", SCENES_CLUSTER_ID);
3595
3596     buf.Put8(kFrameControlClusterSpecificCommand).Put8(seqNum).Put8(ZCL_GET_SCENE_MEMBERSHIP_COMMAND_ID).Put16(groupId);
3597     COMMAND_FOOTER();
3598 }
3599
3600 /*
3601  * Command RecallScene
3602  */
3603 PacketBufferHandle encodeScenesClusterRecallSceneCommand(uint8_t seqNum, EndpointId destinationEndpoint, uint16_t groupId,
3604                                                          uint8_t sceneId, uint16_t transitionTime)
3605 {
3606     COMMAND_HEADER("RecallScene", SCENES_CLUSTER_ID);
3607
3608     buf.Put8(kFrameControlClusterSpecificCommand)
3609         .Put8(seqNum)
3610         .Put8(ZCL_RECALL_SCENE_COMMAND_ID)
3611         .Put16(groupId)
3612         .Put8(sceneId)
3613         .Put16(transitionTime);
3614     COMMAND_FOOTER();
3615 }
3616
3617 /*
3618  * Command RemoveAllScenes
3619  */
3620 PacketBufferHandle encodeScenesClusterRemoveAllScenesCommand(uint8_t seqNum, EndpointId destinationEndpoint, uint16_t groupId)
3621 {
3622     COMMAND_HEADER("RemoveAllScenes", SCENES_CLUSTER_ID);
3623
3624     buf.Put8(kFrameControlClusterSpecificCommand).Put8(seqNum).Put8(ZCL_REMOVE_ALL_SCENES_COMMAND_ID).Put16(groupId);
3625     COMMAND_FOOTER();
3626 }
3627
3628 /*
3629  * Command RemoveScene
3630  */
3631 PacketBufferHandle encodeScenesClusterRemoveSceneCommand(uint8_t seqNum, EndpointId destinationEndpoint, uint16_t groupId,
3632                                                          uint8_t sceneId)
3633 {
3634     COMMAND_HEADER("RemoveScene", SCENES_CLUSTER_ID);
3635
3636     buf.Put8(kFrameControlClusterSpecificCommand).Put8(seqNum).Put8(ZCL_REMOVE_SCENE_COMMAND_ID).Put16(groupId).Put8(sceneId);
3637     COMMAND_FOOTER();
3638 }
3639
3640 /*
3641  * Command StoreScene
3642  */
3643 PacketBufferHandle encodeScenesClusterStoreSceneCommand(uint8_t seqNum, EndpointId destinationEndpoint, uint16_t groupId,
3644                                                         uint8_t sceneId)
3645 {
3646     COMMAND_HEADER("StoreScene", SCENES_CLUSTER_ID);
3647
3648     buf.Put8(kFrameControlClusterSpecificCommand).Put8(seqNum).Put8(ZCL_STORE_SCENE_COMMAND_ID).Put16(groupId).Put8(sceneId);
3649     COMMAND_FOOTER();
3650 }
3651
3652 /*
3653  * Command ViewScene
3654  */
3655 PacketBufferHandle encodeScenesClusterViewSceneCommand(uint8_t seqNum, EndpointId destinationEndpoint, uint16_t groupId,
3656                                                        uint8_t sceneId)
3657 {
3658     COMMAND_HEADER("ViewScene", SCENES_CLUSTER_ID);
3659
3660     buf.Put8(kFrameControlClusterSpecificCommand).Put8(seqNum).Put8(ZCL_VIEW_SCENE_COMMAND_ID).Put16(groupId).Put8(sceneId);
3661     COMMAND_FOOTER();
3662 }
3663
3664 PacketBufferHandle encodeScenesClusterDiscoverAttributes(uint8_t seqNum, EndpointId destinationEndpoint)
3665 {
3666     COMMAND_HEADER("DiscoverScenesAttributes", SCENES_CLUSTER_ID);
3667     buf.Put8(kFrameControlGlobalCommand).Put8(seqNum).Put8(ZCL_DISCOVER_ATTRIBUTES_COMMAND_ID).Put16(0x0000).Put8(0xFF);
3668     COMMAND_FOOTER();
3669 }
3670
3671 /*
3672  * Attribute SceneCount
3673  */
3674 PacketBufferHandle encodeScenesClusterReadSceneCountAttribute(uint8_t seqNum, EndpointId destinationEndpoint)
3675 {
3676     COMMAND_HEADER("ReadScenesSceneCount", SCENES_CLUSTER_ID);
3677     buf.Put8(kFrameControlGlobalCommand).Put8(seqNum).Put8(ZCL_READ_ATTRIBUTES_COMMAND_ID).Put16(0x0000);
3678     COMMAND_FOOTER();
3679 }
3680
3681 /*
3682  * Attribute CurrentScene
3683  */
3684 PacketBufferHandle encodeScenesClusterReadCurrentSceneAttribute(uint8_t seqNum, EndpointId destinationEndpoint)
3685 {
3686     COMMAND_HEADER("ReadScenesCurrentScene", SCENES_CLUSTER_ID);
3687     buf.Put8(kFrameControlGlobalCommand).Put8(seqNum).Put8(ZCL_READ_ATTRIBUTES_COMMAND_ID).Put16(0x0001);
3688     COMMAND_FOOTER();
3689 }
3690
3691 /*
3692  * Attribute CurrentGroup
3693  */
3694 PacketBufferHandle encodeScenesClusterReadCurrentGroupAttribute(uint8_t seqNum, EndpointId destinationEndpoint)
3695 {
3696     COMMAND_HEADER("ReadScenesCurrentGroup", SCENES_CLUSTER_ID);
3697     buf.Put8(kFrameControlGlobalCommand).Put8(seqNum).Put8(ZCL_READ_ATTRIBUTES_COMMAND_ID).Put16(0x0002);
3698     COMMAND_FOOTER();
3699 }
3700
3701 /*
3702  * Attribute SceneValid
3703  */
3704 PacketBufferHandle encodeScenesClusterReadSceneValidAttribute(uint8_t seqNum, EndpointId destinationEndpoint)
3705 {
3706     COMMAND_HEADER("ReadScenesSceneValid", SCENES_CLUSTER_ID);
3707     buf.Put8(kFrameControlGlobalCommand).Put8(seqNum).Put8(ZCL_READ_ATTRIBUTES_COMMAND_ID).Put16(0x0003);
3708     COMMAND_FOOTER();
3709 }
3710
3711 /*
3712  * Attribute NameSupport
3713  */
3714 PacketBufferHandle encodeScenesClusterReadNameSupportAttribute(uint8_t seqNum, EndpointId destinationEndpoint)
3715 {
3716     COMMAND_HEADER("ReadScenesNameSupport", SCENES_CLUSTER_ID);
3717     buf.Put8(kFrameControlGlobalCommand).Put8(seqNum).Put8(ZCL_READ_ATTRIBUTES_COMMAND_ID).Put16(0x0004);
3718     COMMAND_FOOTER();
3719 }
3720
3721 /*
3722  * Attribute ClusterRevision
3723  */
3724 PacketBufferHandle encodeScenesClusterReadClusterRevisionAttribute(uint8_t seqNum, EndpointId destinationEndpoint)
3725 {
3726     COMMAND_HEADER("ReadScenesClusterRevision", SCENES_CLUSTER_ID);
3727     buf.Put8(kFrameControlGlobalCommand).Put8(seqNum).Put8(ZCL_READ_ATTRIBUTES_COMMAND_ID).Put16(0xFFFD);
3728     COMMAND_FOOTER();
3729 }
3730
3731 /*----------------------------------------------------------------------------*\
3732 | Cluster TemperatureMeasurement                                      | 0x0402 |
3733 |------------------------------------------------------------------------------|
3734 | Commands:                                                           |        |
3735 |------------------------------------------------------------------------------|
3736 | Attributes:                                                         |        |
3737 | * MeasuredValue                                                     | 0x0000 |
3738 | * MinMeasuredValue                                                  | 0x0001 |
3739 | * MaxMeasuredValue                                                  | 0x0002 |
3740 | * ClusterRevision                                                   | 0xFFFD |
3741 \*----------------------------------------------------------------------------*/
3742
3743 PacketBufferHandle encodeTemperatureMeasurementClusterDiscoverAttributes(uint8_t seqNum, EndpointId destinationEndpoint)
3744 {
3745     COMMAND_HEADER("DiscoverTemperatureMeasurementAttributes", TEMP_MEASUREMENT_CLUSTER_ID);
3746     buf.Put8(kFrameControlGlobalCommand).Put8(seqNum).Put8(ZCL_DISCOVER_ATTRIBUTES_COMMAND_ID).Put16(0x0000).Put8(0xFF);
3747     COMMAND_FOOTER();
3748 }
3749
3750 /*
3751  * Attribute MeasuredValue
3752  */
3753 PacketBufferHandle encodeTemperatureMeasurementClusterReadMeasuredValueAttribute(uint8_t seqNum, EndpointId destinationEndpoint)
3754 {
3755     COMMAND_HEADER("ReadTemperatureMeasurementMeasuredValue", TEMP_MEASUREMENT_CLUSTER_ID);
3756     buf.Put8(kFrameControlGlobalCommand).Put8(seqNum).Put8(ZCL_READ_ATTRIBUTES_COMMAND_ID).Put16(0x0000);
3757     COMMAND_FOOTER();
3758 }
3759
3760 PacketBufferHandle encodeTemperatureMeasurementClusterConfigureMeasuredValueAttribute(uint8_t seqNum,
3761                                                                                       EndpointId destinationEndpoint,
3762                                                                                       uint16_t minInterval, uint16_t maxInterval,
3763                                                                                       int16_t change)
3764 {
3765     COMMAND_HEADER("ReportTemperatureMeasurementMeasuredValue", TEMP_MEASUREMENT_CLUSTER_ID);
3766     buf.Put8(kFrameControlGlobalCommand)
3767         .Put8(seqNum)
3768         .Put8(ZCL_CONFIGURE_REPORTING_COMMAND_ID)
3769         .Put8(EMBER_ZCL_REPORTING_DIRECTION_REPORTED)
3770         .Put16(0x0000)
3771         .Put8(41)
3772         .Put16(minInterval)
3773         .Put16(maxInterval);
3774     buf.Put16(static_cast<uint16_t>(change));
3775     COMMAND_FOOTER();
3776 }
3777
3778 /*
3779  * Attribute MinMeasuredValue
3780  */
3781 PacketBufferHandle encodeTemperatureMeasurementClusterReadMinMeasuredValueAttribute(uint8_t seqNum, EndpointId destinationEndpoint)
3782 {
3783     COMMAND_HEADER("ReadTemperatureMeasurementMinMeasuredValue", TEMP_MEASUREMENT_CLUSTER_ID);
3784     buf.Put8(kFrameControlGlobalCommand).Put8(seqNum).Put8(ZCL_READ_ATTRIBUTES_COMMAND_ID).Put16(0x0001);
3785     COMMAND_FOOTER();
3786 }
3787
3788 /*
3789  * Attribute MaxMeasuredValue
3790  */
3791 PacketBufferHandle encodeTemperatureMeasurementClusterReadMaxMeasuredValueAttribute(uint8_t seqNum, EndpointId destinationEndpoint)
3792 {
3793     COMMAND_HEADER("ReadTemperatureMeasurementMaxMeasuredValue", TEMP_MEASUREMENT_CLUSTER_ID);
3794     buf.Put8(kFrameControlGlobalCommand).Put8(seqNum).Put8(ZCL_READ_ATTRIBUTES_COMMAND_ID).Put16(0x0002);
3795     COMMAND_FOOTER();
3796 }
3797
3798 /*
3799  * Attribute ClusterRevision
3800  */
3801 PacketBufferHandle encodeTemperatureMeasurementClusterReadClusterRevisionAttribute(uint8_t seqNum, EndpointId destinationEndpoint)
3802 {
3803     COMMAND_HEADER("ReadTemperatureMeasurementClusterRevision", TEMP_MEASUREMENT_CLUSTER_ID);
3804     buf.Put8(kFrameControlGlobalCommand).Put8(seqNum).Put8(ZCL_READ_ATTRIBUTES_COMMAND_ID).Put16(0xFFFD);
3805     COMMAND_FOOTER();
3806 }