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