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